GNUnet  0.16.x
gnunet-service-testbed_connectionpool.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008--2015 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
27 #include "gnunet-service-testbed.h"
29 #include "testbed_api_operations.h"
31 
35 #ifdef LOG
36 #undef LOG
37 #endif
38 #define LOG(kind, ...) \
39  GNUNET_log_from (kind, "testbed-connectionpool", __VA_ARGS__)
40 
41 
45 #define CACHE_EXPIRY \
46  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
47 
48 
53 
54 
59 {
65 
71 
76 
81 
86 
91 
96 
101 
108 
114 
119 
124 
130 
136 
141 
146 
150  unsigned int demand;
151 
155  int in_lru;
156 
160  int in_pool;
161 
165  uint32_t index;
166 };
167 
168 
173 {
181 
186 
191 
196 
200  void *cb_cls;
201 
207 
213 
218 
223 
228 
233 };
234 
235 
240 
245 static struct PooledConnection *head_lru;
246 
250 static struct PooledConnection *tail_lru;
251 
258 
264 
268 static unsigned int max_size;
269 
270 
276 static void
277 expire_task_cancel (struct PooledConnection *entry);
278 
279 
285 static void
287 {
288  GNUNET_assert ((NULL == entry->head_notify) && (NULL == entry->tail_notify));
289  GNUNET_assert ((NULL == entry->head_waiting) &&
290  (NULL == entry->tail_waiting));
291  GNUNET_assert (0 == entry->demand);
292  expire_task_cancel (entry);
293  if (entry->in_lru)
295  if (entry->in_pool)
296  GNUNET_assert (
297  GNUNET_OK ==
299  if (NULL != entry->notify_task)
300  {
302  entry->notify_task = NULL;
303  }
304  LOG_DEBUG ("Cleaning up handles of a pooled connection\n");
305  if (NULL != entry->handle_transport)
306  GNUNET_assert (NULL != entry->op_transport);
307  if (NULL != entry->op_transport)
308  {
310  entry->op_transport = NULL;
311  }
312  if (NULL != entry->handle_ats_connectivity)
313  GNUNET_assert (NULL != entry->op_ats_connectivity);
314  if (NULL != entry->op_ats_connectivity)
315  {
317  entry->op_ats_connectivity = NULL;
318  }
319  if (NULL != entry->op_core)
320  {
322  entry->op_core = NULL;
323  }
324  GNUNET_assert (NULL == entry->handle_core);
325  GNUNET_assert (NULL == entry->handle_ats_connectivity);
326  GNUNET_assert (NULL == entry->handle_transport);
328  GNUNET_free (entry);
329 }
330 
331 
337 static void
338 expire (void *cls)
339 {
340  struct PooledConnection *entry = cls;
341 
342  entry->expire_task = NULL;
344 }
345 
346 
352 static void
354 {
355  if (NULL != entry->expire_task)
356  {
358  entry->expire_task = NULL;
359  }
360 }
361 
362 
368 static void
370 {
371  GNUNET_assert (0 == entry->demand);
372  GNUNET_assert (! entry->in_lru);
374  entry->in_lru = GNUNET_YES;
375  GNUNET_assert (NULL == entry->expire_task);
376  entry->expire_task =
378 }
379 
380 
392 static struct GST_ConnectionPool_GetHandle *
395 {
397 
398  for (gh = head; NULL != gh; gh = gh->next)
399  {
400  switch (gh->service)
401  {
403  if (NULL == entry->handle_core)
404  continue;
405  if (NULL == entry->peer_identity)
406  continue; /* CORE connection isn't ready yet */
407  break;
408 
410  if (NULL == entry->handle_transport)
411  continue;
412  break;
413 
415  if (NULL == entry->handle_ats_connectivity)
416  continue;
417  break;
418  }
419  break;
420  }
421  return gh;
422 }
423 
424 
434 static void
435 connection_ready (void *cls)
436 {
437  struct PooledConnection *entry = cls;
439  struct GST_ConnectionPool_GetHandle *gh_next;
440 
441  GNUNET_assert (NULL != entry->notify_task);
442  entry->notify_task = NULL;
444  GNUNET_assert (NULL != gh);
445  gh_next = NULL;
446  if (NULL != gh->next)
447  gh_next = search_waiting (entry, gh->next);
450  gh);
451  gh->connection_ready_called = 1;
452  if (NULL != gh_next)
454  entry);
455  if ((NULL != gh->target) && (NULL != gh->connect_notify_cb))
456  {
459  gh);
460  gh->notify_waiting = 1;
461  }
462  LOG_DEBUG ("Connection ready to %u for handle type %u\n",
463  (unsigned int) entry->index,
464  gh->service);
465  gh->cb (gh->cb_cls,
470  entry->cfg);
471 }
472 
473 
483 static void
485  const struct GNUNET_PeerIdentity *peer,
487 {
488  struct PooledConnection *entry = cls;
490  struct GST_ConnectionPool_GetHandle *gh_next;
492  void *cb_cls;
493 
494  for (gh = entry->head_notify; NULL != gh;)
495  {
496  GNUNET_assert (NULL != gh->target);
497  GNUNET_assert (NULL != gh->connect_notify_cb);
498  GNUNET_assert (gh->connection_ready_called);
499  if (service != gh->service)
500  {
501  gh = gh->next;
502  continue;
503  }
504  if (0 != memcmp (gh->target, peer, sizeof(struct GNUNET_PeerIdentity)))
505  {
506  gh = gh->next;
507  continue;
508  }
509  cb = gh->connect_notify_cb;
510  cb_cls = gh->connect_notify_cb_cls;
511  gh_next = gh->next;
513  gh->notify_waiting = 0;
514  LOG_DEBUG ("Peer connected to peer %u at service %u\n",
515  entry->index,
516  gh->service);
517  gh = gh_next;
518  cb (cb_cls, peer);
519  }
520 }
521 
522 
532 static void *
534  const struct GNUNET_PeerIdentity *peer,
535  struct GNUNET_MQ_Handle *mq)
536 {
537  struct PooledConnection *entry = cls;
538 
540  return NULL;
541 }
542 
543 
550 static void
552 {
553  struct PooledConnection *entry = cls;
554 
555  GNUNET_assert (NULL != entry);
556  LOG_DEBUG ("Opening a transport connection to peer %u\n", entry->index);
557  entry->handle_transport =
559  NULL,
560  NULL,
561  entry,
563  NULL,
564  NULL);
565  if (NULL == entry->handle_transport)
566  {
567  GNUNET_break (0);
568  return;
569  }
570  if (0 == entry->demand)
571  return;
572  if (NULL != entry->notify_task)
573  return;
574  if (NULL != search_waiting (entry, entry->head_waiting))
575  {
577  return;
578  }
579 }
580 
581 
588 static void
590 {
591  struct PooledConnection *entry = cls;
592 
593  if (NULL == entry->handle_transport)
594  return;
596  entry->handle_transport = NULL;
597 }
598 
599 
608 static void *
610  const struct GNUNET_PeerIdentity *peer,
611  struct GNUNET_MQ_Handle *mq)
612 {
613  struct PooledConnection *entry = cls;
614 
616  return (void *) peer;
617 }
618 
619 
632 static void
633 core_startup_cb (void *cls,
634  const struct GNUNET_PeerIdentity *my_identity)
635 {
636  struct PooledConnection *entry = cls;
637 
638  if (NULL == my_identity)
639  {
640  GNUNET_break (0);
641  return;
642  }
643  GNUNET_assert (NULL == entry->peer_identity);
644  entry->peer_identity = GNUNET_new (struct GNUNET_PeerIdentity);
645  *entry->peer_identity = *my_identity;
647  "Established CORE connection for peer %s (%u)\n",
649  (unsigned int) entry->index);
650  if (0 == entry->demand)
651  return;
652  if (NULL != entry->notify_task)
653  return;
654  if (NULL != search_waiting (entry, entry->head_waiting))
655  {
657  return;
658  }
659 }
660 
661 
668 static void
670 {
671  struct PooledConnection *entry = cls;
672 
673  GNUNET_assert (NULL != entry);
674  LOG_DEBUG ("Opening a CORE connection to peer %u\n", entry->index);
675  entry->handle_core =
676  GNUNET_CORE_connect (entry->cfg,
677  entry, /* closure */
678  &core_startup_cb, /* core startup notify */
679  &core_peer_connect_cb, /* peer connect notify */
680  NULL, /* peer disconnect notify */
681  NULL);
682 }
683 
684 
691 static void
693 {
694  struct PooledConnection *entry = cls;
695 
696  if (NULL == entry->handle_core)
697  return;
699  entry->handle_core = NULL;
700  GNUNET_free (entry->peer_identity);
701  entry->peer_identity = NULL;
702 }
703 
704 
711 static void
713 {
714  struct PooledConnection *entry = cls;
715 
717 }
718 
719 
726 static void
728 {
729  struct PooledConnection *entry = cls;
730 
731  if (NULL == entry->handle_ats_connectivity)
732  return;
734  entry->handle_ats_connectivity = NULL;
735 }
736 
737 
748 static int
749 cleanup_iterator (void *cls, uint32_t key, void *value)
750 {
751  struct PooledConnection *entry = value;
752 
753  GNUNET_assert (NULL != entry);
755  return GNUNET_YES;
756 }
757 
758 
766 void
768 {
769  max_size = size;
770  if (0 == max_size)
771  return;
772  GNUNET_assert (NULL == map);
773  map = GNUNET_CONTAINER_multihashmap32_create (((size * 3) / 4) + 1);
774 }
775 
776 
780 void
782 {
783  struct PooledConnection *entry;
784 
785  if (NULL != map)
786  {
787  GNUNET_assert (
788  GNUNET_SYSERR !=
791  map = NULL;
792  }
793  while (NULL != (entry = head_lru))
794  {
797  }
798  GNUNET_assert (NULL == head_not_pooled);
799 }
800 
801 
836  unsigned int peer_id,
837  const struct GNUNET_CONFIGURATION_Handle *cfg,
840  void *cb_cls,
841  const struct GNUNET_PeerIdentity *target,
843  void *connect_notify_cb_cls)
844 {
846  struct PooledConnection *entry;
848  void *handle;
849  uint32_t peer_id32;
850 
851  peer_id32 = (uint32_t) peer_id;
852  handle = NULL;
853  entry = NULL;
854  if (NULL != map)
855  entry = GNUNET_CONTAINER_multihashmap32_get (map, peer_id32);
856  if (NULL != entry)
857  {
858  if (entry->in_lru)
859  {
860  GNUNET_assert (0 == entry->demand);
861  expire_task_cancel (entry);
863  entry->in_lru = GNUNET_NO;
864  }
865  switch (service)
866  {
868  handle = entry->handle_transport;
869  if (NULL != handle)
870  LOG_DEBUG ("Found TRANSPORT handle for peer %u\n",
871  entry->index);
872  break;
874  handle = entry->handle_core;
875  if (NULL != handle)
876  LOG_DEBUG ("Found CORE handle for peer %u\n",
877  entry->index);
878  break;
881  if (NULL != handle)
882  LOG_DEBUG ("Found ATS CONNECTIVITY handle for peer %u\n",
883  entry->index);
884  break;
885  }
886  }
887  else
888  {
889  entry = GNUNET_new (struct PooledConnection);
890  entry->index = peer_id32;
891  if ((NULL != map) &&
893  {
896  map,
897  entry->index,
898  entry,
900  entry->in_pool = GNUNET_YES;
901  }
902  else
903  {
906  entry);
907  }
908  entry->cfg = GNUNET_CONFIGURATION_dup (cfg);
909  }
910  entry->demand++;
912  gh->entry = entry;
913  gh->cb = cb;
914  gh->cb_cls = cb_cls;
915  gh->target = target;
916  gh->connect_notify_cb = connect_notify_cb;
917  gh->connect_notify_cb_cls = connect_notify_cb_cls;
918  gh->service = service;
920  entry->tail_waiting,
921  gh);
922  if (NULL != handle)
923  {
924  if (NULL == entry->notify_task)
925  {
926  if (NULL != search_waiting (entry, entry->head_waiting))
927  entry->notify_task =
929  }
930  return gh;
931  }
932  op = NULL;
933  switch (gh->service)
934  {
936  if (NULL != entry->op_transport)
937  return gh; /* Operation pending */
941  entry->op_transport = op;
942  break;
943 
945  if (NULL != entry->op_core)
946  return gh; /* Operation pending */
950  entry->op_core = op;
951  break;
952 
954  if (NULL != entry->op_ats_connectivity)
955  return gh; /* Operation pending */
956  op =
960  entry->op_ats_connectivity = op;
961  break;
962  }
965  return gh;
966 }
967 
968 
981 void
983 {
984  struct PooledConnection *entry;
985 
986  if (NULL == gh)
987  return;
988  entry = gh->entry;
989  LOG_DEBUG ("Cleaning up get handle %p for service %u, peer %u\n",
990  gh,
991  gh->service,
992  entry->index);
993  if (! gh->connection_ready_called)
994  {
996  if ((NULL == search_waiting (entry, entry->head_waiting)) &&
997  (NULL != entry->notify_task))
998  {
1000  entry->notify_task = NULL;
1001  }
1002  }
1003  if (gh->notify_waiting)
1004  {
1006  gh->notify_waiting = 0;
1007  }
1008  GNUNET_free (gh);
1009  gh = NULL;
1010  GNUNET_assert (! entry->in_lru);
1011  if (! entry->in_pool)
1013  if (NULL != map)
1014  {
1015  if (GNUNET_YES ==
1017  goto unallocate;
1019  {
1020  if (NULL == head_lru)
1021  goto unallocate;
1023  }
1026  map,
1027  entry->index,
1028  entry,
1030  entry->in_pool = GNUNET_YES;
1031  }
1032 
1033 unallocate:
1034  GNUNET_assert (0 < entry->demand);
1035  entry->demand--;
1036  if (0 != entry->demand)
1037  return;
1038  if (entry->in_pool)
1039  {
1040  add_to_lru (entry);
1041  return;
1042  }
1043  destroy_pooled_connection (entry);
1044 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * value
Value of the record to add/remove.
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
data structures shared amongst components of TESTBED service
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
static struct GNUNET_CONTAINER_MultiHashMap32 * map
A hashmap for quickly finding connections in the connection pool.
static void destroy_pooled_connection(struct PooledConnection *entry)
Destroy a PooledConnection object.
static void add_to_lru(struct PooledConnection *entry)
Function to add a PooledConnection object into LRU and begin the expiry task.
static unsigned int max_size
The maximum number of entries that can be present in the connection pool.
#define CACHE_EXPIRY
Time to expire a cache entry.
static struct PooledConnection * tail_lru
DLL tail for maitaining the least recently used PooledConnection objects.
void GST_connection_pool_destroy()
Cleanup the connection pool.
static void oprelease_get_handle_ats_connectivity(void *cls)
Function called when the operation responsible for opening a ATS connection is marked as done.
static void opstart_get_handle_ats_connectivity(void *cls)
Function called when resources for opening a connection to ATS are available.
static struct GST_ConnectionPool_GetHandle * search_waiting(const struct PooledConnection *entry, struct GST_ConnectionPool_GetHandle *head)
Function to find a GST_ConnectionPool_GetHandle which is waiting for one of the handles in given entr...
static int cleanup_iterator(void *cls, uint32_t key, void *value)
This function will be called for every PooledConnection object in map.
static void core_startup_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect() has succeeded (or failed for good).
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
static struct PooledConnection * head_not_pooled
DLL head for maintaining PooledConnection objects that are not added into the connection pool as it w...
static void connection_ready(void *cls)
A handle in the PooledConnection object pointed by cls is ready and there is a GST_ConnectionPool_Get...
static void * core_peer_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects at CORE level.
static struct PooledConnection * tail_not_pooled
DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it w...
static struct PooledConnection * head_lru
DLL head for maitaining the least recently used PooledConnection objects.
static void expire(void *cls)
Expire a PooledConnection object.
static void oprelease_get_handle_core(void *cls)
Function called when the operation responsible for opening a CORE connection is marked as done.
static void opstart_get_handle_transport(void *cls)
Function called when resources for opening a connection to TRANSPORT are available.
static void * transport_peer_connect_notify_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Function called to notify transport users that another peer connected to us.
static void expire_task_cancel(struct PooledConnection *entry)
Cancel the expiration task of the give PooledConnection object.
static void opstart_get_handle_core(void *cls)
Function called when resources for opening a connection to CORE are available.
void GST_connection_pool_init(unsigned int size)
Initialise the connection pool.
static void oprelease_get_handle_transport(void *cls)
Function called when the operation responsible for opening a TRANSPORT connection is marked as done.
static void peer_connect_notify_cb(void *cls, const struct GNUNET_PeerIdentity *peer, const enum GST_ConnectionPool_Service service)
Function called from peer connect notify callbacks from CORE and TRANSPORT connections.
Interface for connection pooling subroutines.
void(* GST_connection_pool_peer_connect_notify)(void *cls, const struct GNUNET_PeerIdentity *target)
Callback to notify when the target peer given to GST_connection_pool_get_handle() is connected.
GST_ConnectionPool_Service
The type of service.
@ GST_CONNECTIONPOOL_SERVICE_TRANSPORT
Transport service.
@ GST_CONNECTIONPOOL_SERVICE_CORE
Core service.
@ GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY
ATS service.
void(* GST_connection_pool_connection_ready_cb)(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg)
Functions of this type are called when the needed handle is available for usage.
#define GNUNET_log(kind,...)
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
int GNUNET_CONTAINER_multihashmap32_contains(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Check if the map contains any value under the given key (including values that are NULL).
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
static unsigned int size
Size of the "table".
Definition: peer.c:67
Handle to the ATS subsystem for connectivity management.
Internal representation of the hash map.
Context for the core service connection.
Definition: core_api.c:78
Handle to a message queue.
Definition: mq.c:86
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:135
Opaque handle to an abstract operation to be executed by the testing framework.
void * cb_cls
Closure for callbacks.
Handle for the transport service (includes all of the state for the transport service).
The request handle for obtaining a pooled connection.
const struct GNUNET_PeerIdentity * target
The peer identity of the target peer.
void * cb_cls
The closure for the above callback.
enum GST_ConnectionPool_Service service
The service we want to connect to.
struct PooledConnection * entry
The pooled connection object this handle corresponds to.
struct GST_ConnectionPool_GetHandle * next
The next ptr for inclusion in the notification DLLs.
int notify_waiting
Are we waiting for any peer connect notifications?
GST_connection_pool_connection_ready_cb cb
The cache callback to call when a handle is available.
struct GST_ConnectionPool_GetHandle * prev
The prev ptr for inclusion in the notification DLLs.
GST_connection_pool_peer_connect_notify connect_notify_cb
The callback to be called for serving notification that the target peer is connected.
void * connect_notify_cb_cls
The closure for the notify callback.
int connection_ready_called
Did we call the pool_connection_ready_cb already?
struct GNUNET_TESTBED_Operation * op_ats_connectivity
The operation handle for ATS handle.
struct GST_ConnectionPool_GetHandle * tail_waiting
DLL tail for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the peer.
struct PooledConnection * next
Next ptr for placing this object in the DLL of least recently used pooled connections.
unsigned int demand
Number of active requests using this pooled connection.
struct GNUNET_ATS_ConnectivityHandle * handle_ats_connectivity
The ATS handle to the peer correspondign to this entry; can be NULL.
struct GNUNET_TRANSPORT_CoreHandle * handle_transport
The transport handle to the peer corresponding to this entry; can be NULL.
struct PooledConnection * prev
Prev ptr for placing this object in the DLL of the least recently used pooled connections.
int in_pool
Is this entry present in the connection pool.
struct GST_ConnectionPool_GetHandle * head_waiting
DLL head for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
struct GNUNET_TESTBED_Operation * op_transport
The operation handle for transport handle.
struct GST_ConnectionPool_GetHandle * tail_notify
DLL tail for the queue to serve notifications when a peer is connected.
struct GNUNET_SCHEDULER_Task * notify_task
The task to notify a waiting GST_ConnectionPool_GetHandle object.
struct GNUNET_CORE_Handle * handle_core
The core handle to the peer corresponding to this entry; can be NULL.
uint32_t index
The index of this peer.
struct GST_ConnectionPool_GetHandle * head_notify
DLL head for the queue to serve notifications when a peer is connected.
struct GNUNET_SCHEDULER_Task * expire_task
The task to expire this connection from the connection pool.
struct GNUNET_PeerIdentity * peer_identity
The peer identity of this peer.
struct GNUNET_TESTBED_Operation * op_core
The operation handle for core handle.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an 'operation' to be performed.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.
internal API to access the 'operations' subsystem
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.