From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- .../gnunet-service-testbed_connectionpool.c | 656 +++++++++++---------- 1 file changed, 329 insertions(+), 327 deletions(-) (limited to 'src/testbed/gnunet-service-testbed_connectionpool.c') diff --git a/src/testbed/gnunet-service-testbed_connectionpool.c b/src/testbed/gnunet-service-testbed_connectionpool.c index fdb10f987..7f9c9fd57 100644 --- a/src/testbed/gnunet-service-testbed_connectionpool.c +++ b/src/testbed/gnunet-service-testbed_connectionpool.c @@ -36,14 +36,14 @@ #undef LOG #endif #define LOG(kind, ...) \ - GNUNET_log_from(kind, "testbed-connectionpool", __VA_ARGS__) + GNUNET_log_from (kind, "testbed-connectionpool", __VA_ARGS__) /** * Time to expire a cache entry */ #define CACHE_EXPIRY \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) /** @@ -55,7 +55,8 @@ struct GST_ConnectionPool_GetHandle; /** * A pooled connection */ -struct PooledConnection { +struct PooledConnection +{ /** * Next ptr for placing this object in the DLL of least recently used pooled * connections @@ -168,7 +169,8 @@ struct PooledConnection { /** * The request handle for obtaining a pooled connection */ -struct GST_ConnectionPool_GetHandle { +struct GST_ConnectionPool_GetHandle +{ /** * The next ptr for inclusion in the notification DLLs. At first the object * is placed in the waiting DLL of the corresponding #PooledConnection @@ -272,7 +274,7 @@ static unsigned int max_size; * @param entry the #PooledConnection object */ static void -expire_task_cancel(struct PooledConnection *entry); +expire_task_cancel (struct PooledConnection *entry); /** @@ -281,49 +283,49 @@ expire_task_cancel(struct PooledConnection *entry); * @param entry the #PooledConnection object */ static void -destroy_pooled_connection(struct PooledConnection *entry) +destroy_pooled_connection (struct PooledConnection *entry) { - GNUNET_assert((NULL == entry->head_notify) && (NULL == entry->tail_notify)); - GNUNET_assert((NULL == entry->head_waiting) && - (NULL == entry->tail_waiting)); - GNUNET_assert(0 == entry->demand); - expire_task_cancel(entry); + GNUNET_assert ((NULL == entry->head_notify) && (NULL == entry->tail_notify)); + GNUNET_assert ((NULL == entry->head_waiting) && + (NULL == entry->tail_waiting)); + GNUNET_assert (0 == entry->demand); + expire_task_cancel (entry); if (entry->in_lru) - GNUNET_CONTAINER_DLL_remove(head_lru, tail_lru, entry); + GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry); if (entry->in_pool) - GNUNET_assert( + GNUNET_assert ( GNUNET_OK == - GNUNET_CONTAINER_multihashmap32_remove(map, entry->index, entry)); + GNUNET_CONTAINER_multihashmap32_remove (map, entry->index, entry)); if (NULL != entry->notify_task) - { - GNUNET_SCHEDULER_cancel(entry->notify_task); - entry->notify_task = NULL; - } - LOG_DEBUG("Cleaning up handles of a pooled connection\n"); + { + GNUNET_SCHEDULER_cancel (entry->notify_task); + entry->notify_task = NULL; + } + LOG_DEBUG ("Cleaning up handles of a pooled connection\n"); if (NULL != entry->handle_transport) - GNUNET_assert(NULL != entry->op_transport); + GNUNET_assert (NULL != entry->op_transport); if (NULL != entry->op_transport) - { - GNUNET_TESTBED_operation_done(entry->op_transport); - entry->op_transport = NULL; - } + { + GNUNET_TESTBED_operation_done (entry->op_transport); + entry->op_transport = NULL; + } if (NULL != entry->handle_ats_connectivity) - GNUNET_assert(NULL != entry->op_ats_connectivity); + GNUNET_assert (NULL != entry->op_ats_connectivity); if (NULL != entry->op_ats_connectivity) - { - GNUNET_TESTBED_operation_done(entry->op_ats_connectivity); - entry->op_ats_connectivity = NULL; - } + { + GNUNET_TESTBED_operation_done (entry->op_ats_connectivity); + entry->op_ats_connectivity = NULL; + } if (NULL != entry->op_core) - { - GNUNET_TESTBED_operation_done(entry->op_core); - entry->op_core = NULL; - } - GNUNET_assert(NULL == entry->handle_core); - GNUNET_assert(NULL == entry->handle_ats_connectivity); - GNUNET_assert(NULL == entry->handle_transport); - GNUNET_CONFIGURATION_destroy(entry->cfg); - GNUNET_free(entry); + { + GNUNET_TESTBED_operation_done (entry->op_core); + entry->op_core = NULL; + } + GNUNET_assert (NULL == entry->handle_core); + GNUNET_assert (NULL == entry->handle_ats_connectivity); + GNUNET_assert (NULL == entry->handle_transport); + GNUNET_CONFIGURATION_destroy (entry->cfg); + GNUNET_free (entry); } @@ -333,12 +335,12 @@ destroy_pooled_connection(struct PooledConnection *entry) * @param cls the #PooledConnection object */ static void -expire(void *cls) +expire (void *cls) { struct PooledConnection *entry = cls; entry->expire_task = NULL; - destroy_pooled_connection(entry); + destroy_pooled_connection (entry); } @@ -348,13 +350,13 @@ expire(void *cls) * @param entry the #PooledConnection object */ static void -expire_task_cancel(struct PooledConnection *entry) +expire_task_cancel (struct PooledConnection *entry) { if (NULL != entry->expire_task) - { - GNUNET_SCHEDULER_cancel(entry->expire_task); - entry->expire_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (entry->expire_task); + entry->expire_task = NULL; + } } @@ -364,15 +366,15 @@ expire_task_cancel(struct PooledConnection *entry) * @param entry the #PooledConnection object */ static void -add_to_lru(struct PooledConnection *entry) +add_to_lru (struct PooledConnection *entry) { - GNUNET_assert(0 == entry->demand); - GNUNET_assert(!entry->in_lru); - GNUNET_CONTAINER_DLL_insert_tail(head_lru, tail_lru, entry); + GNUNET_assert (0 == entry->demand); + GNUNET_assert (! entry->in_lru); + GNUNET_CONTAINER_DLL_insert_tail (head_lru, tail_lru, entry); entry->in_lru = GNUNET_YES; - GNUNET_assert(NULL == entry->expire_task); + GNUNET_assert (NULL == entry->expire_task); entry->expire_task = - GNUNET_SCHEDULER_add_delayed(CACHE_EXPIRY, &expire, entry); + GNUNET_SCHEDULER_add_delayed (CACHE_EXPIRY, &expire, entry); } @@ -388,34 +390,34 @@ add_to_lru(struct PooledConnection *entry) * is found */ static struct GST_ConnectionPool_GetHandle * -search_waiting(const struct PooledConnection *entry, - struct GST_ConnectionPool_GetHandle *head) +search_waiting (const struct PooledConnection *entry, + struct GST_ConnectionPool_GetHandle *head) { struct GST_ConnectionPool_GetHandle *gh; for (gh = head; NULL != gh; gh = gh->next) + { + switch (gh->service) { - switch (gh->service) - { - case GST_CONNECTIONPOOL_SERVICE_CORE: - if (NULL == entry->handle_core) - continue; - if (NULL == entry->peer_identity) - continue; /* CORE connection isn't ready yet */ - break; - - case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: - if (NULL == entry->handle_transport) - continue; - break; - - case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: - if (NULL == entry->handle_ats_connectivity) - continue; - break; - } + case GST_CONNECTIONPOOL_SERVICE_CORE: + if (NULL == entry->handle_core) + continue; + if (NULL == entry->peer_identity) + continue; /* CORE connection isn't ready yet */ + break; + + case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: + if (NULL == entry->handle_transport) + continue; + break; + + case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: + if (NULL == entry->handle_ats_connectivity) + continue; break; } + break; + } return gh; } @@ -430,37 +432,37 @@ search_waiting(const struct PooledConnection *entry, * @param cls the #PooledConnection object */ static void -connection_ready(void *cls) +connection_ready (void *cls) { struct PooledConnection *entry = cls; struct GST_ConnectionPool_GetHandle *gh; struct GST_ConnectionPool_GetHandle *gh_next; - GNUNET_assert(NULL != entry->notify_task); + GNUNET_assert (NULL != entry->notify_task); entry->notify_task = NULL; - gh = search_waiting(entry, entry->head_waiting); - GNUNET_assert(NULL != gh); + gh = search_waiting (entry, entry->head_waiting); + GNUNET_assert (NULL != gh); gh_next = NULL; if (NULL != gh->next) - gh_next = search_waiting(entry, gh->next); - GNUNET_CONTAINER_DLL_remove(entry->head_waiting, entry->tail_waiting, gh); + gh_next = search_waiting (entry, gh->next); + GNUNET_CONTAINER_DLL_remove (entry->head_waiting, entry->tail_waiting, gh); gh->connection_ready_called = 1; if (NULL != gh_next) - entry->notify_task = GNUNET_SCHEDULER_add_now(&connection_ready, entry); + entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry); if ((NULL != gh->target) && (NULL != gh->connect_notify_cb)) - { - GNUNET_CONTAINER_DLL_insert_tail(entry->head_notify, - entry->tail_notify, - gh); - gh->notify_waiting = 1; - } - LOG_DEBUG("Connection ready for handle type %u\n", gh->service); - gh->cb(gh->cb_cls, - entry->handle_core, - entry->handle_transport, - entry->handle_ats_connectivity, - entry->peer_identity, - entry->cfg); + { + GNUNET_CONTAINER_DLL_insert_tail (entry->head_notify, + entry->tail_notify, + gh); + gh->notify_waiting = 1; + } + LOG_DEBUG ("Connection ready for handle type %u\n", gh->service); + gh->cb (gh->cb_cls, + entry->handle_core, + entry->handle_transport, + entry->handle_ats_connectivity, + entry->peer_identity, + entry->cfg); } @@ -474,9 +476,9 @@ connection_ready(void *cls) * @param service the service where this notification has originated */ static void -peer_connect_notify_cb(void *cls, - const struct GNUNET_PeerIdentity *peer, - const enum GST_ConnectionPool_Service service) +peer_connect_notify_cb (void *cls, + const struct GNUNET_PeerIdentity *peer, + const enum GST_ConnectionPool_Service service) { struct PooledConnection *entry = cls; struct GST_ConnectionPool_GetHandle *gh; @@ -485,31 +487,31 @@ peer_connect_notify_cb(void *cls, void *cb_cls; for (gh = entry->head_notify; NULL != gh;) + { + GNUNET_assert (NULL != gh->target); + GNUNET_assert (NULL != gh->connect_notify_cb); + GNUNET_assert (gh->connection_ready_called); + if (service != gh->service) { - GNUNET_assert(NULL != gh->target); - GNUNET_assert(NULL != gh->connect_notify_cb); - GNUNET_assert(gh->connection_ready_called); - if (service != gh->service) - { - gh = gh->next; - continue; - } - if (0 != memcmp(gh->target, peer, sizeof(struct GNUNET_PeerIdentity))) - { - gh = gh->next; - continue; - } - cb = gh->connect_notify_cb; - cb_cls = gh->connect_notify_cb_cls; - gh_next = gh->next; - GNUNET_CONTAINER_DLL_remove(entry->head_notify, entry->tail_notify, gh); - gh->notify_waiting = 0; - LOG_DEBUG("Peer connected to peer %u at service %u\n", - entry->index, - gh->service); - gh = gh_next; - cb(cb_cls, peer); + gh = gh->next; + continue; } + if (0 != memcmp (gh->target, peer, sizeof(struct GNUNET_PeerIdentity))) + { + gh = gh->next; + continue; + } + cb = gh->connect_notify_cb; + cb_cls = gh->connect_notify_cb_cls; + gh_next = gh->next; + GNUNET_CONTAINER_DLL_remove (entry->head_notify, entry->tail_notify, gh); + gh->notify_waiting = 0; + LOG_DEBUG ("Peer connected to peer %u at service %u\n", + entry->index, + gh->service); + gh = gh_next; + cb (cb_cls, peer); + } } @@ -523,13 +525,13 @@ peer_connect_notify_cb(void *cls, * @return NULL */ static void * -transport_peer_connect_notify_cb(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +transport_peer_connect_notify_cb (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { struct PooledConnection *entry = cls; - peer_connect_notify_cb(entry, peer, GST_CONNECTIONPOOL_SERVICE_TRANSPORT); + peer_connect_notify_cb (entry, peer, GST_CONNECTIONPOOL_SERVICE_TRANSPORT); return NULL; } @@ -541,34 +543,34 @@ transport_peer_connect_notify_cb(void *cls, * @param cls the #PooledConnection object */ static void -opstart_get_handle_transport(void *cls) +opstart_get_handle_transport (void *cls) { struct PooledConnection *entry = cls; - GNUNET_assert(NULL != entry); - LOG_DEBUG("Opening a transport connection to peer %u\n", entry->index); + GNUNET_assert (NULL != entry); + LOG_DEBUG ("Opening a transport connection to peer %u\n", entry->index); entry->handle_transport = - GNUNET_TRANSPORT_core_connect(entry->cfg, - NULL, - NULL, - entry, - &transport_peer_connect_notify_cb, - NULL, - NULL); + GNUNET_TRANSPORT_core_connect (entry->cfg, + NULL, + NULL, + entry, + &transport_peer_connect_notify_cb, + NULL, + NULL); if (NULL == entry->handle_transport) - { - GNUNET_break(0); - return; - } + { + GNUNET_break (0); + return; + } if (0 == entry->demand) return; if (NULL != entry->notify_task) return; - if (NULL != search_waiting(entry, entry->head_waiting)) - { - entry->notify_task = GNUNET_SCHEDULER_add_now(&connection_ready, entry); - return; - } + if (NULL != search_waiting (entry, entry->head_waiting)) + { + entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry); + return; + } } @@ -579,13 +581,13 @@ opstart_get_handle_transport(void *cls) * @param cls the cache entry */ static void -oprelease_get_handle_transport(void *cls) +oprelease_get_handle_transport (void *cls) { struct PooledConnection *entry = cls; if (NULL == entry->handle_transport) return; - GNUNET_TRANSPORT_core_disconnect(entry->handle_transport); + GNUNET_TRANSPORT_core_disconnect (entry->handle_transport); entry->handle_transport = NULL; } @@ -599,14 +601,14 @@ oprelease_get_handle_transport(void *cls) * @return peer */ static void * -core_peer_connect_cb(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +core_peer_connect_cb (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { struct PooledConnection *entry = cls; - peer_connect_notify_cb(entry, peer, GST_CONNECTIONPOOL_SERVICE_CORE); - return (void *)peer; + peer_connect_notify_cb (entry, peer, GST_CONNECTIONPOOL_SERVICE_CORE); + return (void *) peer; } @@ -623,27 +625,27 @@ core_peer_connect_cb(void *cls, * @param my_identity ID of this peer, NULL if we failed */ static void -core_startup_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity) +core_startup_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity) { struct PooledConnection *entry = cls; if (NULL == my_identity) - { - GNUNET_break(0); - return; - } - GNUNET_assert(NULL == entry->peer_identity); - entry->peer_identity = GNUNET_new(struct GNUNET_PeerIdentity); + { + GNUNET_break (0); + return; + } + GNUNET_assert (NULL == entry->peer_identity); + entry->peer_identity = GNUNET_new (struct GNUNET_PeerIdentity); *entry->peer_identity = *my_identity; if (0 == entry->demand) return; if (NULL != entry->notify_task) return; - if (NULL != search_waiting(entry, entry->head_waiting)) - { - entry->notify_task = GNUNET_SCHEDULER_add_now(&connection_ready, entry); - return; - } + if (NULL != search_waiting (entry, entry->head_waiting)) + { + entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry); + return; + } } @@ -654,19 +656,19 @@ core_startup_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity) * @param cls the #PooledConnection object */ static void -opstart_get_handle_core(void *cls) +opstart_get_handle_core (void *cls) { struct PooledConnection *entry = cls; - GNUNET_assert(NULL != entry); - LOG_DEBUG("Opening a CORE connection to peer %u\n", entry->index); + GNUNET_assert (NULL != entry); + LOG_DEBUG ("Opening a CORE connection to peer %u\n", entry->index); entry->handle_core = - GNUNET_CORE_connect(entry->cfg, - entry, /* closure */ - &core_startup_cb, /* core startup notify */ - &core_peer_connect_cb, /* peer connect notify */ - NULL, /* peer disconnect notify */ - NULL); + GNUNET_CORE_connect (entry->cfg, + entry, /* closure */ + &core_startup_cb, /* core startup notify */ + &core_peer_connect_cb, /* peer connect notify */ + NULL, /* peer disconnect notify */ + NULL); } @@ -677,15 +679,15 @@ opstart_get_handle_core(void *cls) * @param cls the #PooledConnection object */ static void -oprelease_get_handle_core(void *cls) +oprelease_get_handle_core (void *cls) { struct PooledConnection *entry = cls; if (NULL == entry->handle_core) return; - GNUNET_CORE_disconnect(entry->handle_core); + GNUNET_CORE_disconnect (entry->handle_core); entry->handle_core = NULL; - GNUNET_free_non_null(entry->peer_identity); + GNUNET_free_non_null (entry->peer_identity); entry->peer_identity = NULL; } @@ -697,11 +699,11 @@ oprelease_get_handle_core(void *cls) * @param cls the #PooledConnection object */ static void -opstart_get_handle_ats_connectivity(void *cls) +opstart_get_handle_ats_connectivity (void *cls) { struct PooledConnection *entry = cls; - entry->handle_ats_connectivity = GNUNET_ATS_connectivity_init(entry->cfg); + entry->handle_ats_connectivity = GNUNET_ATS_connectivity_init (entry->cfg); } @@ -712,13 +714,13 @@ opstart_get_handle_ats_connectivity(void *cls) * @param cls the #PooledConnection object */ static void -oprelease_get_handle_ats_connectivity(void *cls) +oprelease_get_handle_ats_connectivity (void *cls) { struct PooledConnection *entry = cls; if (NULL == entry->handle_ats_connectivity) return; - GNUNET_ATS_connectivity_done(entry->handle_ats_connectivity); + GNUNET_ATS_connectivity_done (entry->handle_ats_connectivity); entry->handle_ats_connectivity = NULL; } @@ -734,12 +736,12 @@ oprelease_get_handle_ats_connectivity(void *cls) * #GNUNET_NO if not. */ static int -cleanup_iterator(void *cls, uint32_t key, void *value) +cleanup_iterator (void *cls, uint32_t key, void *value) { struct PooledConnection *entry = value; - GNUNET_assert(NULL != entry); - destroy_pooled_connection(entry); + GNUNET_assert (NULL != entry); + destroy_pooled_connection (entry); return GNUNET_YES; } @@ -752,13 +754,13 @@ cleanup_iterator(void *cls, uint32_t key, void *value) * #GST_ConnectionPool_Service */ void -GST_connection_pool_init(unsigned int size) +GST_connection_pool_init (unsigned int size) { max_size = size; if (0 == max_size) return; - GNUNET_assert(NULL == map); - map = GNUNET_CONTAINER_multihashmap32_create(((size * 3) / 4) + 1); + GNUNET_assert (NULL == map); + map = GNUNET_CONTAINER_multihashmap32_create (((size * 3) / 4) + 1); } @@ -766,24 +768,24 @@ GST_connection_pool_init(unsigned int size) * Cleanup the connection pool */ void -GST_connection_pool_destroy() +GST_connection_pool_destroy () { struct PooledConnection *entry; if (NULL != map) - { - GNUNET_assert( - GNUNET_SYSERR != - GNUNET_CONTAINER_multihashmap32_iterate(map, &cleanup_iterator, NULL)); - GNUNET_CONTAINER_multihashmap32_destroy(map); - map = NULL; - } + { + GNUNET_assert ( + GNUNET_SYSERR != + GNUNET_CONTAINER_multihashmap32_iterate (map, &cleanup_iterator, NULL)); + GNUNET_CONTAINER_multihashmap32_destroy (map); + map = NULL; + } while (NULL != (entry = head_lru)) - { - GNUNET_CONTAINER_DLL_remove(head_lru, tail_lru, entry); - destroy_pooled_connection(entry); - } - GNUNET_assert(NULL == head_not_pooled); + { + GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry); + destroy_pooled_connection (entry); + } + GNUNET_assert (NULL == head_not_pooled); } @@ -820,7 +822,7 @@ GST_connection_pool_destroy() * longer being used */ struct GST_ConnectionPool_GetHandle * -GST_connection_pool_get_handle( +GST_connection_pool_get_handle ( unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, @@ -836,66 +838,66 @@ GST_connection_pool_get_handle( void *handle; uint32_t peer_id32; - peer_id32 = (uint32_t)peer_id; + peer_id32 = (uint32_t) peer_id; handle = NULL; entry = NULL; if (NULL != map) - entry = GNUNET_CONTAINER_multihashmap32_get(map, peer_id32); + entry = GNUNET_CONTAINER_multihashmap32_get (map, peer_id32); if (NULL != entry) + { + if (entry->in_lru) { - if (entry->in_lru) - { - GNUNET_assert(0 == entry->demand); - expire_task_cancel(entry); - GNUNET_CONTAINER_DLL_remove(head_lru, tail_lru, entry); - entry->in_lru = GNUNET_NO; - } - switch (service) - { - case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: - handle = entry->handle_transport; - if (NULL != handle) - LOG_DEBUG("Found TRANSPORT handle for peer %u\n", entry->index); - break; - - case GST_CONNECTIONPOOL_SERVICE_CORE: - handle = entry->handle_core; - if (NULL != handle) - LOG_DEBUG("Found CORE handle for peer %u\n", entry->index); - break; - - case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: - handle = entry->handle_ats_connectivity; - if (NULL != handle) - LOG_DEBUG("Found ATS CONNECTIVITY handle for peer %u\n", entry->index); - break; - } + GNUNET_assert (0 == entry->demand); + expire_task_cancel (entry); + GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry); + entry->in_lru = GNUNET_NO; + } + switch (service) + { + case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: + handle = entry->handle_transport; + if (NULL != handle) + LOG_DEBUG ("Found TRANSPORT handle for peer %u\n", entry->index); + break; + + case GST_CONNECTIONPOOL_SERVICE_CORE: + handle = entry->handle_core; + if (NULL != handle) + LOG_DEBUG ("Found CORE handle for peer %u\n", entry->index); + break; + + case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: + handle = entry->handle_ats_connectivity; + if (NULL != handle) + LOG_DEBUG ("Found ATS CONNECTIVITY handle for peer %u\n", entry->index); + break; } + } else + { + entry = GNUNET_new (struct PooledConnection); + entry->index = peer_id32; + if ((NULL != map) && + (GNUNET_CONTAINER_multihashmap32_size (map) < max_size)) + { + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap32_put ( + map, + entry->index, + entry, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); + entry->in_pool = GNUNET_YES; + } + else { - entry = GNUNET_new(struct PooledConnection); - entry->index = peer_id32; - if ((NULL != map) && - (GNUNET_CONTAINER_multihashmap32_size(map) < max_size)) - { - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap32_put( - map, - entry->index, - entry, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); - entry->in_pool = GNUNET_YES; - } - else - { - GNUNET_CONTAINER_DLL_insert_tail(head_not_pooled, - tail_not_pooled, - entry); - } - entry->cfg = GNUNET_CONFIGURATION_dup(cfg); + GNUNET_CONTAINER_DLL_insert_tail (head_not_pooled, + tail_not_pooled, + entry); } + entry->cfg = GNUNET_CONFIGURATION_dup (cfg); + } entry->demand++; - gh = GNUNET_new(struct GST_ConnectionPool_GetHandle); + gh = GNUNET_new (struct GST_ConnectionPool_GetHandle); gh->entry = entry; gh->cb = cb; gh->cb_cls = cb_cls; @@ -903,50 +905,50 @@ GST_connection_pool_get_handle( gh->connect_notify_cb = connect_notify_cb; gh->connect_notify_cb_cls = connect_notify_cb_cls; gh->service = service; - GNUNET_CONTAINER_DLL_insert(entry->head_waiting, entry->tail_waiting, gh); + GNUNET_CONTAINER_DLL_insert (entry->head_waiting, entry->tail_waiting, gh); if (NULL != handle) + { + if (NULL == entry->notify_task) { - if (NULL == entry->notify_task) - { - if (NULL != search_waiting(entry, entry->head_waiting)) - entry->notify_task = - GNUNET_SCHEDULER_add_now(&connection_ready, entry); - } - return gh; + if (NULL != search_waiting (entry, entry->head_waiting)) + entry->notify_task = + GNUNET_SCHEDULER_add_now (&connection_ready, entry); } + return gh; + } op = NULL; switch (gh->service) - { - case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: - if (NULL != entry->op_transport) - return gh; /* Operation pending */ - op = GNUNET_TESTBED_operation_create_(entry, - &opstart_get_handle_transport, - &oprelease_get_handle_transport); - entry->op_transport = op; - break; - - case GST_CONNECTIONPOOL_SERVICE_CORE: - if (NULL != entry->op_core) - return gh; /* Operation pending */ - op = GNUNET_TESTBED_operation_create_(entry, - &opstart_get_handle_core, - &oprelease_get_handle_core); - entry->op_core = op; - break; - - case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: - if (NULL != entry->op_ats_connectivity) - return gh; /* Operation pending */ - op = - GNUNET_TESTBED_operation_create_(entry, - &opstart_get_handle_ats_connectivity, - &oprelease_get_handle_ats_connectivity); - entry->op_ats_connectivity = op; - break; - } - GNUNET_TESTBED_operation_queue_insert_(GST_opq_openfds, op); - GNUNET_TESTBED_operation_begin_wait_(op); + { + case GST_CONNECTIONPOOL_SERVICE_TRANSPORT: + if (NULL != entry->op_transport) + return gh; /* Operation pending */ + op = GNUNET_TESTBED_operation_create_ (entry, + &opstart_get_handle_transport, + &oprelease_get_handle_transport); + entry->op_transport = op; + break; + + case GST_CONNECTIONPOOL_SERVICE_CORE: + if (NULL != entry->op_core) + return gh; /* Operation pending */ + op = GNUNET_TESTBED_operation_create_ (entry, + &opstart_get_handle_core, + &oprelease_get_handle_core); + entry->op_core = op; + break; + + case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY: + if (NULL != entry->op_ats_connectivity) + return gh; /* Operation pending */ + op = + GNUNET_TESTBED_operation_create_ (entry, + &opstart_get_handle_ats_connectivity, + &oprelease_get_handle_ats_connectivity); + entry->op_ats_connectivity = op; + break; + } + GNUNET_TESTBED_operation_queue_insert_ (GST_opq_openfds, op); + GNUNET_TESTBED_operation_begin_wait_ (op); return gh; } @@ -964,66 +966,66 @@ GST_connection_pool_get_handle( * @param gh the handle */ void -GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh) +GST_connection_pool_get_handle_done (struct GST_ConnectionPool_GetHandle *gh) { struct PooledConnection *entry; if (NULL == gh) return; entry = gh->entry; - LOG_DEBUG("Cleaning up get handle %p for service %u, peer %u\n", - gh, - gh->service, - entry->index); - if (!gh->connection_ready_called) + LOG_DEBUG ("Cleaning up get handle %p for service %u, peer %u\n", + gh, + gh->service, + entry->index); + if (! gh->connection_ready_called) + { + GNUNET_CONTAINER_DLL_remove (entry->head_waiting, entry->tail_waiting, gh); + if ((NULL == search_waiting (entry, entry->head_waiting)) && + (NULL != entry->notify_task)) { - GNUNET_CONTAINER_DLL_remove(entry->head_waiting, entry->tail_waiting, gh); - if ((NULL == search_waiting(entry, entry->head_waiting)) && - (NULL != entry->notify_task)) - { - GNUNET_SCHEDULER_cancel(entry->notify_task); - entry->notify_task = NULL; - } + GNUNET_SCHEDULER_cancel (entry->notify_task); + entry->notify_task = NULL; } + } if (gh->notify_waiting) - { - GNUNET_CONTAINER_DLL_remove(entry->head_notify, entry->tail_notify, gh); - gh->notify_waiting = 0; - } - GNUNET_free(gh); + { + GNUNET_CONTAINER_DLL_remove (entry->head_notify, entry->tail_notify, gh); + gh->notify_waiting = 0; + } + GNUNET_free (gh); gh = NULL; - GNUNET_assert(!entry->in_lru); - if (!entry->in_pool) - GNUNET_CONTAINER_DLL_remove(head_not_pooled, tail_not_pooled, entry); + GNUNET_assert (! entry->in_lru); + if (! entry->in_pool) + GNUNET_CONTAINER_DLL_remove (head_not_pooled, tail_not_pooled, entry); if (NULL != map) + { + if (GNUNET_YES == + GNUNET_CONTAINER_multihashmap32_contains (map, entry->index)) + goto unallocate; + if (GNUNET_CONTAINER_multihashmap32_size (map) == max_size) { - if (GNUNET_YES == - GNUNET_CONTAINER_multihashmap32_contains(map, entry->index)) + if (NULL == head_lru) goto unallocate; - if (GNUNET_CONTAINER_multihashmap32_size(map) == max_size) - { - if (NULL == head_lru) - goto unallocate; - destroy_pooled_connection(head_lru); - } - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap32_put( - map, - entry->index, - entry, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); - entry->in_pool = GNUNET_YES; + destroy_pooled_connection (head_lru); } + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap32_put ( + map, + entry->index, + entry, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + entry->in_pool = GNUNET_YES; + } unallocate: - GNUNET_assert(0 < entry->demand); + GNUNET_assert (0 < entry->demand); entry->demand--; if (0 != entry->demand) return; if (entry->in_pool) - { - add_to_lru(entry); - return; - } - destroy_pooled_connection(entry); + { + add_to_lru (entry); + return; + } + destroy_pooled_connection (entry); } -- cgit v1.2.3