GNUnet  0.11.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)
294  GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
295  if (entry->in_pool)
296  GNUNET_assert (
297  GNUNET_OK ==
298  GNUNET_CONTAINER_multihashmap32_remove (map, entry->index, entry));
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);
373  GNUNET_CONTAINER_DLL_insert_tail (head_lru, tail_lru, entry);
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;
443  gh = search_waiting (entry, entry->head_waiting);
444  GNUNET_assert (NULL != gh);
445  gh_next = NULL;
446  if (NULL != gh->next)
447  gh_next = search_waiting (entry, gh->next);
449  gh->connection_ready_called = 1;
450  if (NULL != gh_next)
452  if ((NULL != gh->target) && (NULL != gh->connect_notify_cb))
453  {
455  entry->tail_notify,
456  gh);
457  gh->notify_waiting = 1;
458  }
459  LOG_DEBUG ("Connection ready for handle type %u\n", gh->service);
460  gh->cb (gh->cb_cls,
461  entry->handle_core,
462  entry->handle_transport,
464  entry->peer_identity,
465  entry->cfg);
466 }
467 
468 
478 static void
480  const struct GNUNET_PeerIdentity *peer,
482 {
483  struct PooledConnection *entry = cls;
485  struct GST_ConnectionPool_GetHandle *gh_next;
487  void *cb_cls;
488 
489  for (gh = entry->head_notify; NULL != gh;)
490  {
491  GNUNET_assert (NULL != gh->target);
492  GNUNET_assert (NULL != gh->connect_notify_cb);
494  if (service != gh->service)
495  {
496  gh = gh->next;
497  continue;
498  }
499  if (0 != memcmp (gh->target, peer, sizeof(struct GNUNET_PeerIdentity)))
500  {
501  gh = gh->next;
502  continue;
503  }
504  cb = gh->connect_notify_cb;
505  cb_cls = gh->connect_notify_cb_cls;
506  gh_next = gh->next;
508  gh->notify_waiting = 0;
509  LOG_DEBUG ("Peer connected to peer %u at service %u\n",
510  entry->index,
511  gh->service);
512  gh = gh_next;
513  cb (cb_cls, peer);
514  }
515 }
516 
517 
527 static void *
529  const struct GNUNET_PeerIdentity *peer,
530  struct GNUNET_MQ_Handle *mq)
531 {
532  struct PooledConnection *entry = cls;
533 
535  return NULL;
536 }
537 
538 
545 static void
547 {
548  struct PooledConnection *entry = cls;
549 
550  GNUNET_assert (NULL != entry);
551  LOG_DEBUG ("Opening a transport connection to peer %u\n", entry->index);
552  entry->handle_transport =
554  NULL,
555  NULL,
556  entry,
558  NULL,
559  NULL);
560  if (NULL == entry->handle_transport)
561  {
562  GNUNET_break (0);
563  return;
564  }
565  if (0 == entry->demand)
566  return;
567  if (NULL != entry->notify_task)
568  return;
569  if (NULL != search_waiting (entry, entry->head_waiting))
570  {
572  return;
573  }
574 }
575 
576 
583 static void
585 {
586  struct PooledConnection *entry = cls;
587 
588  if (NULL == entry->handle_transport)
589  return;
591  entry->handle_transport = NULL;
592 }
593 
594 
603 static void *
605  const struct GNUNET_PeerIdentity *peer,
606  struct GNUNET_MQ_Handle *mq)
607 {
608  struct PooledConnection *entry = cls;
609 
611  return (void *) peer;
612 }
613 
614 
627 static void
629 {
630  struct PooledConnection *entry = cls;
631 
632  if (NULL == my_identity)
633  {
634  GNUNET_break (0);
635  return;
636  }
637  GNUNET_assert (NULL == entry->peer_identity);
638  entry->peer_identity = GNUNET_new (struct GNUNET_PeerIdentity);
639  *entry->peer_identity = *my_identity;
640  if (0 == entry->demand)
641  return;
642  if (NULL != entry->notify_task)
643  return;
644  if (NULL != search_waiting (entry, entry->head_waiting))
645  {
647  return;
648  }
649 }
650 
651 
658 static void
660 {
661  struct PooledConnection *entry = cls;
662 
663  GNUNET_assert (NULL != entry);
664  LOG_DEBUG ("Opening a CORE connection to peer %u\n", entry->index);
665  entry->handle_core =
666  GNUNET_CORE_connect (entry->cfg,
667  entry, /* closure */
668  &core_startup_cb, /* core startup notify */
669  &core_peer_connect_cb, /* peer connect notify */
670  NULL, /* peer disconnect notify */
671  NULL);
672 }
673 
674 
681 static void
683 {
684  struct PooledConnection *entry = cls;
685 
686  if (NULL == entry->handle_core)
687  return;
689  entry->handle_core = NULL;
691  entry->peer_identity = NULL;
692 }
693 
694 
701 static void
703 {
704  struct PooledConnection *entry = cls;
705 
707 }
708 
709 
716 static void
718 {
719  struct PooledConnection *entry = cls;
720 
721  if (NULL == entry->handle_ats_connectivity)
722  return;
724  entry->handle_ats_connectivity = NULL;
725 }
726 
727 
738 static int
739 cleanup_iterator (void *cls, uint32_t key, void *value)
740 {
741  struct PooledConnection *entry = value;
742 
743  GNUNET_assert (NULL != entry);
745  return GNUNET_YES;
746 }
747 
748 
756 void
758 {
759  max_size = size;
760  if (0 == max_size)
761  return;
762  GNUNET_assert (NULL == map);
763  map = GNUNET_CONTAINER_multihashmap32_create (((size * 3) / 4) + 1);
764 }
765 
766 
770 void
772 {
773  struct PooledConnection *entry;
774 
775  if (NULL != map)
776  {
777  GNUNET_assert (
778  GNUNET_SYSERR !=
781  map = NULL;
782  }
783  while (NULL != (entry = head_lru))
784  {
785  GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
787  }
788  GNUNET_assert (NULL == head_not_pooled);
789 }
790 
791 
826  unsigned int peer_id,
827  const struct GNUNET_CONFIGURATION_Handle *cfg,
830  void *cb_cls,
831  const struct GNUNET_PeerIdentity *target,
833  void *connect_notify_cb_cls)
834 {
836  struct PooledConnection *entry;
838  void *handle;
839  uint32_t peer_id32;
840 
841  peer_id32 = (uint32_t) peer_id;
842  handle = NULL;
843  entry = NULL;
844  if (NULL != map)
845  entry = GNUNET_CONTAINER_multihashmap32_get (map, peer_id32);
846  if (NULL != entry)
847  {
848  if (entry->in_lru)
849  {
850  GNUNET_assert (0 == entry->demand);
851  expire_task_cancel (entry);
852  GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
853  entry->in_lru = GNUNET_NO;
854  }
855  switch (service)
856  {
858  handle = entry->handle_transport;
859  if (NULL != handle)
860  LOG_DEBUG ("Found TRANSPORT handle for peer %u\n", entry->index);
861  break;
862 
864  handle = entry->handle_core;
865  if (NULL != handle)
866  LOG_DEBUG ("Found CORE handle for peer %u\n", entry->index);
867  break;
868 
870  handle = entry->handle_ats_connectivity;
871  if (NULL != handle)
872  LOG_DEBUG ("Found ATS CONNECTIVITY handle for peer %u\n", entry->index);
873  break;
874  }
875  }
876  else
877  {
878  entry = GNUNET_new (struct PooledConnection);
879  entry->index = peer_id32;
880  if ((NULL != map) &&
882  {
885  map,
886  entry->index,
887  entry,
889  entry->in_pool = GNUNET_YES;
890  }
891  else
892  {
893  GNUNET_CONTAINER_DLL_insert_tail (head_not_pooled,
894  tail_not_pooled,
895  entry);
896  }
897  entry->cfg = GNUNET_CONFIGURATION_dup (cfg);
898  }
899  entry->demand++;
901  gh->entry = entry;
902  gh->cb = cb;
903  gh->cb_cls = cb_cls;
904  gh->target = target;
905  gh->connect_notify_cb = connect_notify_cb;
906  gh->connect_notify_cb_cls = connect_notify_cb_cls;
907  gh->service = service;
909  if (NULL != handle)
910  {
911  if (NULL == entry->notify_task)
912  {
913  if (NULL != search_waiting (entry, entry->head_waiting))
914  entry->notify_task =
916  }
917  return gh;
918  }
919  op = NULL;
920  switch (gh->service)
921  {
923  if (NULL != entry->op_transport)
924  return gh; /* Operation pending */
928  entry->op_transport = op;
929  break;
930 
932  if (NULL != entry->op_core)
933  return gh; /* Operation pending */
937  entry->op_core = op;
938  break;
939 
941  if (NULL != entry->op_ats_connectivity)
942  return gh; /* Operation pending */
943  op =
947  entry->op_ats_connectivity = op;
948  break;
949  }
952  return gh;
953 }
954 
955 
968 void
970 {
971  struct PooledConnection *entry;
972 
973  if (NULL == gh)
974  return;
975  entry = gh->entry;
976  LOG_DEBUG ("Cleaning up get handle %p for service %u, peer %u\n",
977  gh,
978  gh->service,
979  entry->index);
980  if (! gh->connection_ready_called)
981  {
983  if ((NULL == search_waiting (entry, entry->head_waiting)) &&
984  (NULL != entry->notify_task))
985  {
987  entry->notify_task = NULL;
988  }
989  }
990  if (gh->notify_waiting)
991  {
993  gh->notify_waiting = 0;
994  }
995  GNUNET_free (gh);
996  gh = NULL;
997  GNUNET_assert (! entry->in_lru);
998  if (! entry->in_pool)
999  GNUNET_CONTAINER_DLL_remove (head_not_pooled, tail_not_pooled, entry);
1000  if (NULL != map)
1001  {
1002  if (GNUNET_YES ==
1004  goto unallocate;
1006  {
1007  if (NULL == head_lru)
1008  goto unallocate;
1009  destroy_pooled_connection (head_lru);
1010  }
1013  map,
1014  entry->index,
1015  entry,
1017  entry->in_pool = GNUNET_YES;
1018  }
1019 
1020 unallocate:
1021  GNUNET_assert (0 < entry->demand);
1022  entry->demand--;
1023  if (0 != entry->demand)
1024  return;
1025  if (entry->in_pool)
1026  {
1027  add_to_lru (entry);
1028  return;
1029  }
1030  destroy_pooled_connection (entry);
1031 }
static void add_to_lru(struct PooledConnection *entry)
Function to add a PooledConnection object into LRU and begin the expiry task.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static void oprelease_get_handle_core(void *cls)
Function called when the operation responsible for opening a CORE connection is marked as done...
struct GNUNET_TRANSPORT_CoreHandle * handle_transport
The transport handle to the peer corresponding to this entry; can be NULL.
void * cb_cls
Closure for callbacks.
GST_connection_pool_peer_connect_notify connect_notify_cb
The callback to be called for serving notification that the target peer is connected.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void destroy_pooled_connection(struct PooledConnection *entry)
Destroy a PooledConnection object.
static int cleanup_iterator(void *cls, uint32_t key, void *value)
This function will be called for every PooledConnection object in map.
internal API to access the &#39;operations&#39; subsystem
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Context for the core service connection.
Definition: core_api.c:77
int notify_waiting
Are we waiting for any peer connect notifications?
data structures shared amongst components of TESTBED service
GST_ConnectionPool_Service
The type of service.
The request handle for obtaining a pooled connection.
struct GST_ConnectionPool_GetHandle * tail_notify
DLL tail for the queue to serve notifications when a peer is connected.
static struct PooledConnection * tail_lru
DLL tail for maitaining the least recently used PooledConnection objects.
static void expire(void *cls)
Expire a PooledConnection object.
const struct GNUNET_PeerIdentity * target
The peer identity of the target peer.
struct GNUNET_TESTBED_Operation * op_transport
The operation handle for transport handle.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
struct GST_ConnectionPool_GetHandle * tail_waiting
DLL tail for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
static void oprelease_get_handle_transport(void *cls)
Function called when the operation responsible for opening a TRANSPORT connection is marked as done...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void oprelease_get_handle_ats_connectivity(void *cls)
Function called when the operation responsible for opening a ATS connection is marked as done...
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an &#39;operation&#39; to be performed.
int in_pool
Is this entry present in the connection pool.
void * connect_notify_cb_cls
The closure for the notify callback.
static void opstart_get_handle_transport(void *cls)
Function called when resources for opening a connection to TRANSPORT are available.
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).
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_TESTBED_Operation * op_core
The operation handle for core handle.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GST_ConnectionPool_GetHandle * head_notify
DLL head for the queue to serve notifications when a peer is connected.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
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.
struct GNUNET_SCHEDULER_Task * notify_task
The task to notify a waiting GST_ConnectionPool_GetHandle object.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
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.
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
Opaque handle to an abstract operation to be executed by the testing framework.
uint32_t index
The index of this peer.
struct PooledConnection * prev
Prev ptr for placing this object in the DLL of the least recently used pooled connections.
struct GNUNET_CORE_Handle * handle_core
The core handle to the peer corresponding to this entry; can be NULL.
struct GNUNET_PeerIdentity * peer_identity
The peer identity of this peer.
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 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...
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:1253
GST_connection_pool_connection_ready_cb cb
The cache callback to call when a handle is available.
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.
, &#39; bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_...
static char * value
Value of the record to add/remove.
unsigned int demand
Number of active requests using this pooled connection.
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)...
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.
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...
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:1280
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
enum GST_ConnectionPool_Service service
The service we want to connect to.
struct GST_ConnectionPool_GetHandle * head_waiting
DLL head for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
Internal representation of the hash map.
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:2044
static unsigned int max_size
The maximum number of entries that can be present in the connection pool.
struct PooledConnection * entry
The pooled connection object this handle corresponds to.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
struct GNUNET_TESTBED_Operation * op_ats_connectivity
The operation handle for ATS handle.
Interface for connection pooling subroutines.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
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 struct PooledConnection * head_not_pooled
DLL head for maintaining PooledConnection objects that are not added into the connection pool as it w...
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
static void opstart_get_handle_core(void *cls)
Function called when resources for opening a connection to CORE are available.
struct GST_ConnectionPool_GetHandle * prev
The prev ptr for inclusion in the notification DLLs.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void * cb_cls
The closure for the above callback.
#define CACHE_EXPIRY
Time to expire a cache entry.
static struct PooledConnection * tail_not_pooled
DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it w...
struct GST_ConnectionPool_GetHandle * next
The next ptr for inclusion in the notification DLLs.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
struct GNUNET_SCHEDULER_Task * expire_task
The task to expire this connection from the connection pool.
The identity of the host (wraps the signing key of the peer).
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.
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.
configuration data
Definition: configuration.c:85
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
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.
int connection_ready_called
Did we call the pool_connection_ready_cb already?
void GST_connection_pool_init(unsigned int size)
Initialise the connection pool.
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 * head_lru
DLL head for maitaining the least recently used PooledConnection objects.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
Entry in list of pending tasks.
Definition: scheduler.c:134
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_CONTAINER_MultiHashMap32 * map
A hashmap for quickly finding connections in the connection pool.
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
struct PooledConnection * next
Next ptr for placing this object in the DLL of least recently used pooled connections.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_ATS_ConnectivityHandle * handle_ats_connectivity
The ATS handle to the peer correspondign to this entry; can be NULL.
Handle for the transport service (includes all of the state for the transport service).
Handle to the ATS subsystem for connectivity management.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
static void opstart_get_handle_ats_connectivity(void *cls)
Function called when resources for opening a connection to ATS are available.
#define LOG_DEBUG(...)
Debug logging shorthand.
void GST_connection_pool_destroy()
Cleanup the connection pool.
#define GNUNET_free(ptr)
Wrapper around free.
static void expire_task_cancel(struct PooledConnection *entry)
Cancel the expiration task of the give PooledConnection object.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966