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 --- src/fs/gnunet-service-fs_cadet_client.c | 423 ++++++++++++++++---------------- 1 file changed, 213 insertions(+), 210 deletions(-) (limited to 'src/fs/gnunet-service-fs_cadet_client.c') diff --git a/src/fs/gnunet-service-fs_cadet_client.c b/src/fs/gnunet-service-fs_cadet_client.c index a494ba751..96ccf8232 100644 --- a/src/fs/gnunet-service-fs_cadet_client.c +++ b/src/fs/gnunet-service-fs_cadet_client.c @@ -42,7 +42,7 @@ * After how long do we reset connections without replies? */ #define CLIENT_RETRY_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) /** @@ -54,7 +54,8 @@ struct CadetHandle; /** * Handle for a request that is going out via cadet API. */ -struct GSF_CadetRequest { +struct GSF_CadetRequest +{ /** * DLL. */ @@ -101,7 +102,8 @@ struct GSF_CadetRequest { /** * Handle for a cadet to another peer. */ -struct CadetHandle { +struct CadetHandle +{ /** * Head of DLL of pending requests on this cadet. */ @@ -165,7 +167,7 @@ struct GNUNET_CONTAINER_MultiPeerMap *cadet_map; * @param cls `struct CadetHandle` to process */ static void -transmit_pending(void *cls); +transmit_pending (void *cls); /** @@ -178,15 +180,15 @@ transmit_pending(void *cls); * @return #GNUNET_YES (continue to iterate) */ static int -move_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value) +move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value) { struct CadetHandle *mh = cls; struct GSF_CadetRequest *sr = value; - GNUNET_assert( + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove(mh->waiting_map, key, value)); - GNUNET_CONTAINER_DLL_insert(mh->pending_head, mh->pending_tail, sr); + GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, key, value)); + GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr); sr->was_transmitted = GNUNET_NO; return GNUNET_YES; } @@ -201,7 +203,7 @@ move_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value) * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing */ static int -check_reply(void *cls, const struct CadetReplyMessage *srm) +check_reply (void *cls, const struct CadetReplyMessage *srm) { /* We check later... */ return GNUNET_OK; @@ -214,7 +216,7 @@ check_reply(void *cls, const struct CadetReplyMessage *srm) * @param cls the `struct CadetHandle` to tear down */ static void -reset_cadet_task(void *cls); +reset_cadet_task (void *cls); /** @@ -224,18 +226,19 @@ reset_cadet_task(void *cls); * @param mh cadet to reset */ static void -reset_cadet_async(struct CadetHandle *mh) +reset_cadet_async (struct CadetHandle *mh) { if (NULL != mh->reset_task) - GNUNET_SCHEDULER_cancel(mh->reset_task); - mh->reset_task = GNUNET_SCHEDULER_add_now(&reset_cadet_task, mh); + GNUNET_SCHEDULER_cancel (mh->reset_task); + mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_cadet_task, mh); } /** * Closure for handle_reply(). */ -struct HandleReplyClosure { +struct HandleReplyClosure +{ /** * Reply payload. */ @@ -273,18 +276,18 @@ struct HandleReplyClosure { * @return #GNUNET_YES (continue to iterate) */ static int -process_reply(void *cls, const struct GNUNET_HashCode *key, void *value) +process_reply (void *cls, const struct GNUNET_HashCode *key, void *value) { struct HandleReplyClosure *hrc = cls; struct GSF_CadetRequest *sr = value; - sr->proc(sr->proc_cls, - hrc->type, - hrc->expiration, - hrc->data_size, - hrc->data); + sr->proc (sr->proc_cls, + hrc->type, + hrc->expiration, + hrc->data_size, + hrc->data); sr->proc = NULL; - GSF_cadet_query_cancel(sr); + GSF_cadet_query_cancel (sr); hrc->found = GNUNET_YES; return GNUNET_YES; } @@ -301,11 +304,11 @@ process_reply(void *cls, const struct GNUNET_HashCode *key, void *value) * @return #GNUNET_YES (continue to iterate) */ static int -free_waiting_entry(void *cls, const struct GNUNET_HashCode *key, void *value) +free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GSF_CadetRequest *sr = value; - GSF_cadet_query_cancel(sr); + GSF_cadet_query_cancel (sr); return GNUNET_YES; } @@ -318,7 +321,7 @@ free_waiting_entry(void *cls, const struct GNUNET_HashCode *key, void *value) * @param srm the actual message */ static void -handle_reply(void *cls, const struct CadetReplyMessage *srm) +handle_reply (void *cls, const struct CadetReplyMessage *srm) { struct CadetHandle *mh = cls; struct HandleReplyClosure hrc; @@ -326,47 +329,47 @@ handle_reply(void *cls, const struct CadetReplyMessage *srm) enum GNUNET_BLOCK_Type type; struct GNUNET_HashCode query; - msize = ntohs(srm->header.size) - sizeof(struct CadetReplyMessage); - type = (enum GNUNET_BLOCK_Type)ntohl(srm->type); + msize = ntohs (srm->header.size) - sizeof(struct CadetReplyMessage); + type = (enum GNUNET_BLOCK_Type) ntohl (srm->type); if (GNUNET_YES != - GNUNET_BLOCK_get_key(GSF_block_ctx, type, &srm[1], msize, &query)) - { - GNUNET_break_op(0); - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - "Received bogus reply of type %u with %u bytes via cadet from peer %s\n", - type, - msize, - GNUNET_i2s(&mh->target)); - reset_cadet_async(mh); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received reply `%s' via cadet from peer %s\n", - GNUNET_h2s(&query), - GNUNET_i2s(&mh->target)); - GNUNET_CADET_receive_done(mh->channel); - GNUNET_STATISTICS_update(GSF_stats, - gettext_noop("# replies received via cadet"), - 1, - GNUNET_NO); + GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query)) + { + GNUNET_break_op (0); + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + "Received bogus reply of type %u with %u bytes via cadet from peer %s\n", + type, + msize, + GNUNET_i2s (&mh->target)); + reset_cadet_async (mh); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received reply `%s' via cadet from peer %s\n", + GNUNET_h2s (&query), + GNUNET_i2s (&mh->target)); + GNUNET_CADET_receive_done (mh->channel); + GNUNET_STATISTICS_update (GSF_stats, + gettext_noop ("# replies received via cadet"), + 1, + GNUNET_NO); hrc.data = &srm[1]; hrc.data_size = msize; - hrc.expiration = GNUNET_TIME_absolute_ntoh(srm->expiration); + hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration); hrc.type = type; hrc.found = GNUNET_NO; - GNUNET_CONTAINER_multihashmap_get_multiple(mh->waiting_map, - &query, - &process_reply, - &hrc); + GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map, + &query, + &process_reply, + &hrc); if (GNUNET_NO == hrc.found) - { - GNUNET_STATISTICS_update(GSF_stats, - gettext_noop( - "# replies received via cadet dropped"), - 1, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (GSF_stats, + gettext_noop ( + "# replies received via cadet dropped"), + 1, + GNUNET_NO); + } } @@ -378,34 +381,34 @@ handle_reply(void *cls, const struct CadetReplyMessage *srm) * @param channel channel of the disconnecting client */ static void -disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel) +disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel) { struct CadetHandle *mh = cls; struct GSF_CadetRequest *sr; if (NULL == mh->channel) return; /* being destroyed elsewhere */ - GNUNET_assert(channel == mh->channel); + GNUNET_assert (channel == mh->channel); mh->channel = NULL; while (NULL != (sr = mh->pending_head)) - GSF_cadet_query_cancel(sr); + GSF_cadet_query_cancel (sr); /* first remove `mh` from the `cadet_map`, so that if the callback from `free_waiting_entry()` happens to re-issue the request, we don't immediately have it back in the `waiting_map`. */ - GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(cadet_map, - &mh->target, - mh)); - GNUNET_CONTAINER_multihashmap_iterate(mh->waiting_map, - &free_waiting_entry, - mh); + GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (cadet_map, + &mh->target, + mh)); + GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, + &free_waiting_entry, + mh); if (NULL != mh->timeout_task) - GNUNET_SCHEDULER_cancel(mh->timeout_task); + GNUNET_SCHEDULER_cancel (mh->timeout_task); if (NULL != mh->reset_task) - GNUNET_SCHEDULER_cancel(mh->reset_task); - GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(mh->waiting_map)); - GNUNET_CONTAINER_multihashmap_destroy(mh->waiting_map); - GNUNET_free(mh); + GNUNET_SCHEDULER_cancel (mh->reset_task); + GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)); + GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map); + GNUNET_free (mh); } @@ -424,16 +427,16 @@ disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel) * this value will be negative.. */ static void -window_change_cb(void *cls, - const struct GNUNET_CADET_Channel *channel, - int window_size) +window_change_cb (void *cls, + const struct GNUNET_CADET_Channel *channel, + int window_size) { /* FIXME: for flow control, implement? */ #if 0 /* Something like this instead of the GNUNET_MQ_notify_sent() in transmit_pending() might be good (once the window change CB works...) */ if (0 < window_size) /* test needed? */ - transmit_pending(mh); + transmit_pending (mh); #endif } @@ -444,38 +447,38 @@ window_change_cb(void *cls, * @param mh cadet to reset */ static void -reset_cadet(struct CadetHandle *mh) +reset_cadet (struct CadetHandle *mh) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resetting cadet channel to %s\n", - GNUNET_i2s(&mh->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Resetting cadet channel to %s\n", + GNUNET_i2s (&mh->target)); if (NULL != mh->channel) - { - GNUNET_CADET_channel_destroy(mh->channel); - mh->channel = NULL; - } - GNUNET_CONTAINER_multihashmap_iterate(mh->waiting_map, &move_to_pending, mh); + { + GNUNET_CADET_channel_destroy (mh->channel); + mh->channel = NULL; + } + GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, &move_to_pending, mh); { struct GNUNET_MQ_MessageHandler handlers[] = - { GNUNET_MQ_hd_var_size(reply, - GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, - struct CadetReplyMessage, - mh), - GNUNET_MQ_handler_end() }; + { GNUNET_MQ_hd_var_size (reply, + GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, + struct CadetReplyMessage, + mh), + GNUNET_MQ_handler_end () }; struct GNUNET_HashCode port; - GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, - strlen(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER), - &port); - mh->channel = GNUNET_CADET_channel_create(cadet_handle, - mh, - &mh->target, - &port, - &window_change_cb, - &disconnect_cb, - handlers); + GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, + strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER), + &port); + mh->channel = GNUNET_CADET_channel_create (cadet_handle, + mh, + &mh->target, + &port, + &window_change_cb, + &disconnect_cb, + handlers); } - transmit_pending(mh); + transmit_pending (mh); } @@ -485,19 +488,19 @@ reset_cadet(struct CadetHandle *mh) * @param cls the `struct CadetHandle` to tear down */ static void -cadet_timeout(void *cls) +cadet_timeout (void *cls) { struct CadetHandle *mh = cls; struct GNUNET_CADET_Channel *tun; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Timeout on cadet channel to %s\n", - GNUNET_i2s(&mh->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Timeout on cadet channel to %s\n", + GNUNET_i2s (&mh->target)); mh->timeout_task = NULL; tun = mh->channel; mh->channel = NULL; if (NULL != tun) - GNUNET_CADET_channel_destroy(tun); + GNUNET_CADET_channel_destroy (tun); } @@ -507,12 +510,12 @@ cadet_timeout(void *cls) * @param cls the `struct CadetHandle` to tear down */ static void -reset_cadet_task(void *cls) +reset_cadet_task (void *cls) { struct CadetHandle *mh = cls; mh->reset_task = NULL; - reset_cadet(mh); + reset_cadet (mh); } @@ -522,36 +525,36 @@ reset_cadet_task(void *cls) * @param cls `struct CadetHandle` to process */ static void -transmit_pending(void *cls) +transmit_pending (void *cls) { struct CadetHandle *mh = cls; - struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq(mh->channel); + struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (mh->channel); struct GSF_CadetRequest *sr; struct GNUNET_MQ_Envelope *env; struct CadetQueryMessage *sqm; - if ((0 != GNUNET_MQ_get_length(mq)) || (NULL == (sr = mh->pending_head))) + if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head))) return; - GNUNET_CONTAINER_DLL_remove(mh->pending_head, mh->pending_tail, sr); - GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multihashmap_put( - mh->waiting_map, - &sr->query, - sr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); + GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr); + GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put ( + mh->waiting_map, + &sr->query, + sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); sr->was_transmitted = GNUNET_YES; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending query for %s via cadet to %s\n", - GNUNET_h2s(&sr->query), - GNUNET_i2s(&mh->target)); - env = GNUNET_MQ_msg(sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY); - GNUNET_MQ_env_set_options(env, - GNUNET_MQ_PREF_GOODPUT | - GNUNET_MQ_PREF_CORK_ALLOWED | - GNUNET_MQ_PREF_OUT_OF_ORDER); - sqm->type = htonl(sr->type); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending query for %s via cadet to %s\n", + GNUNET_h2s (&sr->query), + GNUNET_i2s (&mh->target)); + env = GNUNET_MQ_msg (sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY); + GNUNET_MQ_env_set_options (env, + GNUNET_MQ_PREF_GOODPUT + | GNUNET_MQ_PREF_CORK_ALLOWED + | GNUNET_MQ_PREF_OUT_OF_ORDER); + sqm->type = htonl (sr->type); sqm->query = sr->query; - GNUNET_MQ_notify_sent(env, &transmit_pending, mh); - GNUNET_MQ_send(mq, env); + GNUNET_MQ_notify_sent (env, &transmit_pending, mh); + GNUNET_MQ_send (mq, env); } @@ -561,53 +564,53 @@ transmit_pending(void *cls) * @param target peer we want to communicate with */ static struct CadetHandle * -get_cadet(const struct GNUNET_PeerIdentity *target) +get_cadet (const struct GNUNET_PeerIdentity *target) { struct CadetHandle *mh; - mh = GNUNET_CONTAINER_multipeermap_get(cadet_map, target); + mh = GNUNET_CONTAINER_multipeermap_get (cadet_map, target); if (NULL != mh) + { + if (NULL != mh->timeout_task) { - if (NULL != mh->timeout_task) - { - GNUNET_SCHEDULER_cancel(mh->timeout_task); - mh->timeout_task = NULL; - } - return mh; + GNUNET_SCHEDULER_cancel (mh->timeout_task); + mh->timeout_task = NULL; } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Creating cadet channel to %s\n", - GNUNET_i2s(target)); - mh = GNUNET_new(struct CadetHandle); + return mh; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating cadet channel to %s\n", + GNUNET_i2s (target)); + mh = GNUNET_new (struct CadetHandle); mh->reset_task = - GNUNET_SCHEDULER_add_delayed(CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh); - mh->waiting_map = GNUNET_CONTAINER_multihashmap_create(16, GNUNET_YES); + GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh); + mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES); mh->target = *target; - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multipeermap_put( - cadet_map, - &mh->target, - mh, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multipeermap_put ( + cadet_map, + &mh->target, + mh, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); { struct GNUNET_MQ_MessageHandler handlers[] = - { GNUNET_MQ_hd_var_size(reply, - GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, - struct CadetReplyMessage, - mh), - GNUNET_MQ_handler_end() }; + { GNUNET_MQ_hd_var_size (reply, + GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, + struct CadetReplyMessage, + mh), + GNUNET_MQ_handler_end () }; struct GNUNET_HashCode port; - GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, - strlen(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER), - &port); - mh->channel = GNUNET_CADET_channel_create(cadet_handle, - mh, - &mh->target, - &port, - &window_change_cb, - &disconnect_cb, - handlers); + GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, + strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER), + &port); + mh->channel = GNUNET_CADET_channel_create (cadet_handle, + mh, + &mh->target, + &port, + &window_change_cb, + &disconnect_cb, + handlers); } return mh; } @@ -624,28 +627,28 @@ get_cadet(const struct GNUNET_PeerIdentity *target) * @return handle to cancel the operation */ struct GSF_CadetRequest * -GSF_cadet_query(const struct GNUNET_PeerIdentity *target, - const struct GNUNET_HashCode *query, - enum GNUNET_BLOCK_Type type, - GSF_CadetReplyProcessor proc, - void *proc_cls) +GSF_cadet_query (const struct GNUNET_PeerIdentity *target, + const struct GNUNET_HashCode *query, + enum GNUNET_BLOCK_Type type, + GSF_CadetReplyProcessor proc, + void *proc_cls) { struct CadetHandle *mh; struct GSF_CadetRequest *sr; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Preparing to send query for %s via cadet to %s\n", - GNUNET_h2s(query), - GNUNET_i2s(target)); - mh = get_cadet(target); - sr = GNUNET_new(struct GSF_CadetRequest); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Preparing to send query for %s via cadet to %s\n", + GNUNET_h2s (query), + GNUNET_i2s (target)); + mh = get_cadet (target); + sr = GNUNET_new (struct GSF_CadetRequest); sr->mh = mh; sr->proc = proc; sr->proc_cls = proc_cls; sr->type = type; sr->query = *query; - GNUNET_CONTAINER_DLL_insert(mh->pending_head, mh->pending_tail, sr); - transmit_pending(mh); + GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr); + transmit_pending (mh); return sr; } @@ -657,7 +660,7 @@ GSF_cadet_query(const struct GNUNET_PeerIdentity *target, * @param sr request to cancel */ void -GSF_cadet_query_cancel(struct GSF_CadetRequest *sr) +GSF_cadet_query_cancel (struct GSF_CadetRequest *sr) { struct CadetHandle *mh = sr->mh; GSF_CadetReplyProcessor p; @@ -665,26 +668,26 @@ GSF_cadet_query_cancel(struct GSF_CadetRequest *sr) p = sr->proc; sr->proc = NULL; if (NULL != p) - { - /* signal failure / cancellation to callback */ - p(sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL); - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Cancelled query for %s via cadet to %s\n", - GNUNET_h2s(&sr->query), - GNUNET_i2s(&sr->mh->target)); + { + /* signal failure / cancellation to callback */ + p (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL); + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Cancelled query for %s via cadet to %s\n", + GNUNET_h2s (&sr->query), + GNUNET_i2s (&sr->mh->target)); if (GNUNET_YES == sr->was_transmitted) - GNUNET_assert( + GNUNET_assert ( GNUNET_OK == - GNUNET_CONTAINER_multihashmap_remove(mh->waiting_map, &sr->query, sr)); + GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, &sr->query, sr)); else - GNUNET_CONTAINER_DLL_remove(mh->pending_head, mh->pending_tail, sr); - GNUNET_free(sr); - if ((0 == GNUNET_CONTAINER_multihashmap_size(mh->waiting_map)) && + GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr); + GNUNET_free (sr); + if ((0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) && (NULL == mh->pending_head)) - mh->timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, - &cadet_timeout, - mh); + mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, + &cadet_timeout, + mh); } @@ -697,27 +700,27 @@ GSF_cadet_query_cancel(struct GSF_CadetRequest *sr) * @return #GNUNET_YES (continue to iterate) */ int -GSF_cadet_release_clients(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +GSF_cadet_release_clients (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct CadetHandle *mh = value; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Timeout on cadet channel to %s\n", - GNUNET_i2s(&mh->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Timeout on cadet channel to %s\n", + GNUNET_i2s (&mh->target)); if (NULL != mh->channel) - { - struct GNUNET_CADET_Channel *channel = mh->channel; + { + struct GNUNET_CADET_Channel *channel = mh->channel; - mh->channel = NULL; - GNUNET_CADET_channel_destroy(channel); - } + mh->channel = NULL; + GNUNET_CADET_channel_destroy (channel); + } if (NULL != mh->reset_task) - { - GNUNET_SCHEDULER_cancel(mh->reset_task); - mh->reset_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (mh->reset_task); + mh->reset_task = NULL; + } return GNUNET_YES; } -- cgit v1.2.3