From dfeef02bf7882cdfb952430cfbdb9793ecd780e2 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 21 Jul 2019 11:08:40 +0200 Subject: [PATCH] fix #5793 --- src/fs/gnunet-service-fs_pr.c | 781 ++++++++++++++-------------- src/include/gnunet_container_lib.h | 26 +- src/set/gnunet-set-ibf-profiler.c | 150 +++--- src/util/container_multihashmap.c | 6 +- src/util/container_multihashmap32.c | 123 ++--- src/util/container_multiuuidmap.c | 6 +- 6 files changed, 555 insertions(+), 537 deletions(-) diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c index abbaf94ef..f9702486a 100644 --- a/src/fs/gnunet-service-fs_pr.c +++ b/src/fs/gnunet-service-fs_pr.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -157,7 +157,7 @@ struct GSF_PendingRequest /** * Task that warns us if the local datastore lookup takes too long. */ - struct GNUNET_SCHEDULER_Task * warn_task; + struct GNUNET_SCHEDULER_Task *warn_task; /** * Do we have a first UID yet? @@ -195,7 +195,6 @@ struct GSF_PendingRequest * Length of the 'replies_seen' array. */ unsigned int replies_seen_size; - }; @@ -237,7 +236,6 @@ static struct GNUNET_CONTAINER_Heap *requests_by_expiration_heap; static unsigned long long max_pending_requests = (32 * 1024); - /** * Recalculate our bloom filter for filtering replies. This function * will create a new bloom filter from scratch, so it should only be @@ -249,8 +247,7 @@ static unsigned long long max_pending_requests = (32 * 1024); * @param pr request for which the BF is to be recomputed */ static void -refresh_bloomfilter (enum GNUNET_BLOCK_Type type, - struct GSF_PendingRequest *pr) +refresh_bloomfilter (enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr) { if (NULL != pr->bg) { @@ -259,16 +256,16 @@ refresh_bloomfilter (enum GNUNET_BLOCK_Type type, } if (GNUNET_BLOCK_TYPE_FS_UBLOCK != type) return; /* no need */ - pr->bg - = GNUNET_BLOCK_group_create (GSF_block_ctx, - type, - GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, - UINT32_MAX), - NULL, - 0, - "seen-set-size", - pr->replies_seen_count, - NULL); + pr->bg = + GNUNET_BLOCK_group_create (GSF_block_ctx, + type, + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + UINT32_MAX), + NULL, + 0, + "seen-set-size", + pr->replies_seen_count, + NULL); if (NULL == pr->bg) return; GNUNET_break (GNUNET_OK == @@ -324,10 +321,12 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating request handle for `%s' of type %d\n", - GNUNET_h2s (query), type); + GNUNET_h2s (query), + type); #if INSANE_STATISTICS GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Pending requests created"), 1, + gettext_noop ("# Pending requests created"), + 1, GNUNET_NO); #endif extra = 0; @@ -339,9 +338,7 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, if (NULL != target) { pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr; - GNUNET_memcpy (eptr, - target, - sizeof (struct GNUNET_PeerIdentity)); + GNUNET_memcpy (eptr, target, sizeof (struct GNUNET_PeerIdentity)); } pr->public_data.anonymity_level = anonymity_level; pr->public_data.priority = priority; @@ -355,55 +352,49 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, pr->rh_cls = rh_cls; GNUNET_assert ((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY))); if (ttl >= 0) - pr->public_data.ttl = - GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - (uint32_t) ttl)); + pr->public_data.ttl = GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, (uint32_t) ttl)); else - pr->public_data.ttl = - GNUNET_TIME_absolute_subtract (pr->public_data.start_time, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - (uint32_t) (-ttl))); + pr->public_data.ttl = GNUNET_TIME_absolute_subtract ( + pr->public_data.start_time, + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, + (uint32_t) (-ttl))); if (replies_seen_count > 0) { pr->replies_seen_size = replies_seen_count; - pr->replies_seen = GNUNET_new_array (pr->replies_seen_size, - struct GNUNET_HashCode); + pr->replies_seen = + GNUNET_new_array (pr->replies_seen_size, struct GNUNET_HashCode); GNUNET_memcpy (pr->replies_seen, replies_seen, replies_seen_count * sizeof (struct GNUNET_HashCode)); pr->replies_seen_count = replies_seen_count; } - if ( (NULL != bf_data) && - (GNUNET_BLOCK_TYPE_FS_UBLOCK == pr->public_data.type) ) + if ((NULL != bf_data) && + (GNUNET_BLOCK_TYPE_FS_UBLOCK == pr->public_data.type)) { - pr->bg - = GNUNET_BLOCK_group_create (GSF_block_ctx, - pr->public_data.type, - mingle, - bf_data, - bf_size, - "seen-set-size", - 0, - NULL); + pr->bg = GNUNET_BLOCK_group_create (GSF_block_ctx, + pr->public_data.type, + mingle, + bf_data, + bf_size, + "seen-set-size", + 0, + NULL); } else if ((replies_seen_count > 0) && (0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH))) { - refresh_bloomfilter (pr->public_data.type, - pr); + refresh_bloomfilter (pr->public_data.type, pr); } GNUNET_CONTAINER_multihashmap_put (pr_map, - &pr->public_data.query, + &pr->public_data.query, pr, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); if (0 == (options & GSF_PRO_REQUEST_NEVER_EXPIRES)) { - pr->hnode = - GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap, - pr, - pr->public_data.ttl.abs_value_us); + pr->hnode = GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap, + pr, + pr->public_data.ttl.abs_value_us); /* make sure we don't track too many requests */ while (GNUNET_CONTAINER_heap_get_size (requests_by_expiration_heap) > max_pending_requests) @@ -411,23 +402,23 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, dpr = GNUNET_CONTAINER_heap_peek (requests_by_expiration_heap); GNUNET_assert (NULL != dpr); if (pr == dpr) - break; /* let the request live briefly... */ + break; /* let the request live briefly... */ if (NULL != dpr->rh) - dpr->rh (dpr->rh_cls, + dpr->rh (dpr->rh_cls, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, dpr, - UINT32_MAX, + UINT32_MAX, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_BLOCK_TYPE_ANY, NULL, 0); - GSF_pending_request_cancel_ (dpr, - GNUNET_YES); + GSF_pending_request_cancel_ (dpr, GNUNET_YES); } } GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Pending requests active"), 1, + gettext_noop ("# Pending requests active"), + 1, GNUNET_NO); return pr; } @@ -458,10 +449,10 @@ int GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra, struct GSF_PendingRequest *prb) { - if ( (pra->public_data.type != prb->public_data.type) || - (0 != memcmp (&pra->public_data.query, - &prb->public_data.query, - sizeof (struct GNUNET_HashCode)))) + if ((pra->public_data.type != prb->public_data.type) || + (0 != memcmp (&pra->public_data.query, + &prb->public_data.query, + sizeof (struct GNUNET_HashCode)))) return GNUNET_NO; return GNUNET_OK; } @@ -477,11 +468,11 @@ GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra, */ void GSF_pending_request_update_ (struct GSF_PendingRequest *pr, - const struct GNUNET_HashCode * replies_seen, + const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count) { if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count) - return; /* integer overflow */ + return; /* integer overflow */ if (0 != (pr->public_data.options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)) { /* we're responsible for the BF, full refresh */ @@ -493,8 +484,7 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr, replies_seen, sizeof (struct GNUNET_HashCode) * replies_seen_count); pr->replies_seen_count += replies_seen_count; - refresh_bloomfilter (pr->public_data.type, - pr); + refresh_bloomfilter (pr->public_data.type, pr); } else { @@ -502,8 +492,7 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr, { /* we're not the initiator, but the initiator did not give us * any bloom-filter, so we need to create one on-the-fly */ - refresh_bloomfilter (pr->public_data.type, - pr); + refresh_bloomfilter (pr->public_data.type, pr); } else { @@ -515,8 +504,8 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr, } if (NULL != pr->gh) GNUNET_DHT_get_filter_known_results (pr->gh, - replies_seen_count, - replies_seen); + replies_seen_count, + replies_seen); } @@ -544,18 +533,18 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr) uint32_t bf_nonce; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Building request message for `%s' of type %d\n", - GNUNET_h2s (&pr->public_data.query), - pr->public_data.type); + "Building request message for `%s' of type %d\n", + GNUNET_h2s (&pr->public_data.query), + pr->public_data.type); k = 0; bm = 0; do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY)); - if ((!do_route) && (pr->sender_pid == 0)) + if ((! do_route) && (pr->sender_pid == 0)) { GNUNET_break (0); do_route = GNUNET_YES; } - if (!do_route) + if (! do_route) { bm |= GET_MESSAGE_BIT_RETURN_TO; k++; @@ -566,22 +555,18 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr) k++; } if (GNUNET_OK != - GNUNET_BLOCK_group_serialize (pr->bg, - &bf_nonce, - &bf_data, - &bf_size)) + GNUNET_BLOCK_group_serialize (pr->bg, &bf_nonce, &bf_data, &bf_size)) { bf_size = 0; bf_data = NULL; } env = GNUNET_MQ_msg_extra (gm, - bf_size + k * sizeof (struct GNUNET_PeerIdentity), - GNUNET_MESSAGE_TYPE_FS_GET); + bf_size + k * sizeof (struct GNUNET_PeerIdentity), + GNUNET_MESSAGE_TYPE_FS_GET); gm->type = htonl (pr->public_data.type); if (do_route) - prio = - GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, - pr->public_data.priority + 1); + prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + pr->public_data.priority + 1); else prio = 0; pr->public_data.priority -= prio; @@ -597,13 +582,10 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr) ext = (struct GNUNET_PeerIdentity *) &gm[1]; k = 0; if (! do_route) - GNUNET_PEER_resolve (pr->sender_pid, - &ext[k++]); + GNUNET_PEER_resolve (pr->sender_pid, &ext[k++]); if (NULL != pr->public_data.target) ext[k++] = *pr->public_data.target; - GNUNET_memcpy (&ext[k], - bf_data, - bf_size); + GNUNET_memcpy (&ext[k], bf_data, bf_size); GNUNET_free_non_null (bf_data); return env; } @@ -618,16 +600,14 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr) * @return #GNUNET_YES (we should continue to iterate) */ static int -clean_request (void *cls, - const struct GNUNET_HashCode *key, - void *value) +clean_request (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GSF_PendingRequest *pr = value; GSF_LocalLookupContinuation cont; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up pending request for `%s'.\n", - GNUNET_h2s (key)); + GNUNET_h2s (key)); if (NULL != pr->cadet_request) { pr->cadet_retry_count = CADET_RETRY_MAX; @@ -637,9 +617,7 @@ clean_request (void *cls, if (NULL != (cont = pr->llc_cont)) { pr->llc_cont = NULL; - cont (pr->llc_cont_cls, - pr, - pr->local_result); + cont (pr->llc_cont_cls, pr, pr->local_result); } GSF_plan_notify_request_done_ (pr); GNUNET_free_non_null (pr->replies_seen); @@ -669,10 +647,9 @@ clean_request (void *cls, GNUNET_SCHEDULER_cancel (pr->warn_task); pr->warn_task = NULL; } - GNUNET_assert (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_remove (pr_map, - &pr->public_data.query, - pr)); + GNUNET_assert ( + GNUNET_OK == + GNUNET_CONTAINER_multihashmap_remove (pr_map, &pr->public_data.query, pr)); GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# Pending requests active"), -1, @@ -689,13 +666,12 @@ clean_request (void *cls, * @param full_cleanup fully purge the request */ void -GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, - int full_cleanup) +GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup) { GSF_LocalLookupContinuation cont; if (NULL == pr_map) - return; /* already cleaned up! */ + return; /* already cleaned up! */ if (GNUNET_NO == full_cleanup) { /* make request inactive (we're no longer interested in more results), @@ -711,9 +687,7 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, if (NULL != (cont = pr->llc_cont)) { pr->llc_cont = NULL; - cont (pr->llc_cont_cls, - pr, - pr->local_result); + cont (pr->llc_cont_cls, pr, pr->local_result); } GSF_plan_notify_request_done_ (pr); if (NULL != pr->qe) @@ -734,9 +708,7 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, return; } GNUNET_assert (GNUNET_YES == - clean_request (NULL, - &pr->public_data.query, - pr)); + clean_request (NULL, &pr->public_data.query, pr)); } @@ -749,9 +721,10 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, void GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls) { - GNUNET_CONTAINER_multihashmap_iterate (pr_map, - (GNUNET_CONTAINER_HashMapIterator) it, - cls); + GNUNET_CONTAINER_multihashmap_iterate ( + pr_map, + (GNUNET_CONTAINER_MulitHashMapIteratorCallback) it, + cls); } @@ -825,7 +798,8 @@ update_request_performance_data (struct ProcessReplyClosure *prq, { if (prq->sender == NULL) return; - GSF_peer_update_performance_ (prq->sender, pr->public_data.start_time, + GSF_peer_update_performance_ (prq->sender, + pr->public_data.start_time, prq->priority); } @@ -839,9 +813,7 @@ update_request_performance_data (struct ProcessReplyClosure *prq, * @return #GNUNET_YES (we should 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 ProcessReplyClosure *prq = cls; struct GSF_PendingRequest *pr = value; @@ -855,18 +827,18 @@ process_reply (void *cls, (unsigned int) prq->type, GNUNET_h2s (key)); GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# replies received and matched"), 1, + gettext_noop ("# replies received and matched"), + 1, GNUNET_NO); - prq->eval = - GNUNET_BLOCK_evaluate (GSF_block_ctx, - prq->type, - pr->bg, - prq->eo, - key, - NULL, - 0, - prq->data, - prq->size); + prq->eval = GNUNET_BLOCK_evaluate (GSF_block_ctx, + prq->type, + pr->bg, + prq->eo, + key, + NULL, + 0, + prq->data, + prq->size); switch (prq->eval) { case GNUNET_BLOCK_EVALUATION_OK_MORE: @@ -876,37 +848,46 @@ process_reply (void *cls, /* short cut: stop processing early, no BF-update, etc. */ update_request_performance_data (prq, pr); GNUNET_LOAD_update (GSF_rt_entry_lifetime, - GNUNET_TIME_absolute_get_duration (pr-> - public_data.start_time).rel_value_us); + GNUNET_TIME_absolute_get_duration ( + pr->public_data.start_time) + .rel_value_us); if (GNUNET_YES != - GSF_request_plan_reference_get_last_transmission_ (pr->public_data.pr_head, - prq->sender, - &last_transmission)) - last_transmission.abs_value_us = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us; + GSF_request_plan_reference_get_last_transmission_ (pr->public_data + .pr_head, + prq->sender, + &last_transmission)) + last_transmission.abs_value_us = + GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us; /* pass on to other peers / local clients */ - pr->rh (pr->rh_cls, prq->eval, pr, prq->anonymity_level, prq->expiration, - last_transmission, prq->type, prq->data, prq->size); + pr->rh (pr->rh_cls, + prq->eval, + pr, + prq->anonymity_level, + prq->expiration, + last_transmission, + prq->type, + prq->data, + prq->size); return GNUNET_YES; case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE: #if INSANE_STATISTICS GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# duplicate replies discarded (bloomfilter)"), - 1, GNUNET_NO); + gettext_noop ( + "# duplicate replies discarded (bloomfilter)"), + 1, + GNUNET_NO); #endif - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Duplicate response, discarding.\n"); - return GNUNET_YES; /* duplicate */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate response, discarding.\n"); + return GNUNET_YES; /* duplicate */ case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT: GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# irrelevant replies discarded"), - 1, GNUNET_NO); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Irrelevant response, ignoring.\n"); + gettext_noop ("# irrelevant replies discarded"), + 1, + GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Irrelevant response, ignoring.\n"); return GNUNET_YES; case GNUNET_BLOCK_EVALUATION_RESULT_INVALID: - return GNUNET_YES; /* wrong namespace */ + return GNUNET_YES; /* wrong namespace */ case GNUNET_BLOCK_EVALUATION_REQUEST_VALID: GNUNET_break (0); return GNUNET_YES; @@ -915,17 +896,13 @@ process_reply (void *cls, return GNUNET_YES; case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED: GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("Unsupported block type %u\n"), + _ ("Unsupported block type %u\n"), prq->type); return GNUNET_NO; } /* update bloomfilter */ - GNUNET_CRYPTO_hash (prq->data, - prq->size, - &chash); - GSF_pending_request_update_ (pr, - &chash, - 1); + GNUNET_CRYPTO_hash (prq->data, prq->size, &chash); + GSF_pending_request_update_ (pr, &chash, 1); if (NULL == prq->sender) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -946,14 +923,15 @@ process_reply (void *cls, pr->public_data.results_found++; prq->request_found = GNUNET_YES; /* finally, pass on to other peer / local client */ - if (! GSF_request_plan_reference_get_last_transmission_ (pr->public_data.pr_head, - prq->sender, - &last_transmission)) + if (! GSF_request_plan_reference_get_last_transmission_ (pr->public_data + .pr_head, + prq->sender, + &last_transmission)) last_transmission.abs_value_us = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us; pr->rh (pr->rh_cls, prq->eval, pr, - prq->anonymity_level, + prq->anonymity_level, prq->expiration, last_transmission, prq->type, @@ -997,9 +975,10 @@ struct PutMigrationContext * @param msg NULL on success, otherwise an error message */ static void -put_migration_continuation (void *cls, int success, - struct GNUNET_TIME_Absolute min_expiration, - const char *msg) +put_migration_continuation (void *cls, + int success, + struct GNUNET_TIME_Absolute min_expiration, + const char *msg) { struct PutMigrationContext *pmc = cls; struct GSF_ConnectedPeer *cp; @@ -1011,13 +990,14 @@ put_migration_continuation (void *cls, int success, if (GNUNET_SYSERR != success) { GNUNET_LOAD_update (datastore_put_load, - GNUNET_TIME_absolute_get_duration (pmc->start).rel_value_us); + GNUNET_TIME_absolute_get_duration (pmc->start) + .rel_value_us); } else { /* on queue failure / timeout, increase the put load dramatically */ GNUNET_LOAD_update (datastore_put_load, - GNUNET_TIME_UNIT_MINUTES.rel_value_us); + GNUNET_TIME_UNIT_MINUTES.rel_value_us); } } cp = GSF_peer_get_ (&pmc->origin); @@ -1031,38 +1011,41 @@ put_migration_continuation (void *cls, int success, GNUNET_free (pmc); return; } - if ( (GNUNET_NO == success) && - (GNUNET_NO == pmc->requested) && - (NULL != cp) ) + if ((GNUNET_NO == success) && (GNUNET_NO == pmc->requested) && (NULL != cp)) { ppd = GSF_get_peer_performance_data_ (cp); if (min_expiration.abs_value_us > 0) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Asking to stop migration for %s because datastore is full\n", - GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_expiration), GNUNET_YES)); + "Asking to stop migration for %s because datastore is full\n", + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_remaining (min_expiration), + GNUNET_YES)); GSF_block_peer_migration_ (cp, min_expiration); } else { ppd->migration_delay = GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_SECONDS, - ppd->migration_delay); - ppd->migration_delay = GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_HOURS, - ppd->migration_delay); - mig_pause.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, - ppd->migration_delay.rel_value_us); - ppd->migration_delay = GNUNET_TIME_relative_saturating_multiply (ppd->migration_delay, 2); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Replicated content already exists locally, asking to stop migration for %s\n", - GNUNET_STRINGS_relative_time_to_string (mig_pause, - GNUNET_YES)); + ppd->migration_delay); + ppd->migration_delay = + GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_HOURS, ppd->migration_delay); + mig_pause.rel_value_us = + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, + ppd->migration_delay.rel_value_us); + ppd->migration_delay = + GNUNET_TIME_relative_saturating_multiply (ppd->migration_delay, 2); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Replicated content already exists locally, asking to stop migration for %s\n", + GNUNET_STRINGS_relative_time_to_string (mig_pause, GNUNET_YES)); GSF_block_peer_migration_ (cp, GNUNET_TIME_relative_to_absolute (mig_pause)); } } GNUNET_free (pmc); GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Datastore `PUT' failures"), 1, + gettext_noop ("# Datastore `PUT' failures"), + 1, GNUNET_NO); } @@ -1084,13 +1067,14 @@ test_put_load_too_high (uint32_t priority) if (NULL == datastore_put_load) return GNUNET_NO; if (GNUNET_LOAD_get_average (datastore_put_load) < 50) - return GNUNET_NO; /* very fast */ + return GNUNET_NO; /* very fast */ ld = GNUNET_LOAD_get_load (datastore_put_load); if (ld < 2.0 * (1 + priority)) return GNUNET_NO; GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# storage requests dropped due to high load"), 1, + gettext_noop ( + "# storage requests dropped due to high load"), + 1, GNUNET_NO); return GNUNET_YES; } @@ -1128,14 +1112,16 @@ handle_dht_reply (void *cls, struct PutMigrationContext *pmc; GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Replies received from DHT"), 1, + gettext_noop ("# Replies received from DHT"), + 1, GNUNET_NO); memset (&prq, 0, sizeof (prq)); prq.data = data; prq.expiration = exp; /* do not allow migrated content to live longer than 1 year */ - prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_YEARS), - prq.expiration); + prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_UNIT_YEARS), + prq.expiration); prq.size = size; prq.type = type; prq.eo = GNUNET_BLOCK_EO_NONE; @@ -1145,16 +1131,25 @@ handle_dht_reply (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Replicating result for query `%s' with priority %u\n", - GNUNET_h2s (key), prq.priority); + GNUNET_h2s (key), + prq.priority); pmc = GNUNET_new (struct PutMigrationContext); pmc->start = GNUNET_TIME_absolute_get (); pmc->requested = GNUNET_YES; - if (NULL == - GNUNET_DATASTORE_put (GSF_dsh, 0, key, size, data, type, prq.priority, - 1 /* anonymity */ , - 0 /* replication */ , - exp, 1 + prq.priority, MAX_DATASTORE_QUEUE, - &put_migration_continuation, pmc)) + if (NULL == GNUNET_DATASTORE_put (GSF_dsh, + 0, + key, + size, + data, + type, + prq.priority, + 1 /* anonymity */, + 0 /* replication */, + exp, + 1 + prq.priority, + MAX_DATASTORE_QUEUE, + &put_migration_continuation, + pmc)) { put_migration_continuation (pmc, GNUNET_SYSERR, @@ -1194,17 +1189,19 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr) GNUNET_memcpy (&buf[xquery_size], &pi, sizeof (struct GNUNET_PeerIdentity)); xquery_size += sizeof (struct GNUNET_PeerIdentity); } - pr->gh = - GNUNET_DHT_get_start (GSF_dht, - pr->public_data.type, &pr->public_data.query, - DHT_GET_REPLICATION, - GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, - xquery, xquery_size, &handle_dht_reply, pr); - if ( (NULL != pr->gh) && - (0 != pr->replies_seen_count) ) + pr->gh = GNUNET_DHT_get_start (GSF_dht, + pr->public_data.type, + &pr->public_data.query, + DHT_GET_REPLICATION, + GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, + xquery, + xquery_size, + &handle_dht_reply, + pr); + if ((NULL != pr->gh) && (0 != pr->replies_seen_count)) GNUNET_DHT_get_filter_known_results (pr->gh, - pr->replies_seen_count, - pr->replies_seen); + pr->replies_seen_count, + pr->replies_seen); } @@ -1219,10 +1216,10 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr) */ static void cadet_reply_proc (void *cls, - enum GNUNET_BLOCK_Type type, - struct GNUNET_TIME_Absolute expiration, - size_t data_size, - const void *data) + enum GNUNET_BLOCK_Type type, + struct GNUNET_TIME_Absolute expiration, + size_t data_size, + const void *data) { struct GSF_PendingRequest *pr = cls; struct ProcessReplyClosure prq; @@ -1236,8 +1233,7 @@ cadet_reply_proc (void *cls, pr->cadet_retry_count++; if (pr->cadet_retry_count >= CADET_RETRY_MAX) return; /* give up on cadet */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Error retrieiving block via cadet\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error retrieiving block via cadet\n"); /* retry -- without delay, as this is non-anonymous and cadet/cadet connect will take some time anyway */ pr->cadet_request = GSF_cadet_query (pr->public_data.target, @@ -1248,25 +1244,25 @@ cadet_reply_proc (void *cls, return; } if (GNUNET_YES != - GNUNET_BLOCK_get_key (GSF_block_ctx, - type, - data, data_size, &query)) + GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, data_size, &query)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Failed to derive key for block of type %d\n", - (int) type); + "Failed to derive key for block of type %d\n", + (int) type); GNUNET_break_op (0); return; } GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Replies received from CADET"), 1, + gettext_noop ("# Replies received from CADET"), + 1, GNUNET_NO); memset (&prq, 0, sizeof (prq)); prq.data = data; prq.expiration = expiration; /* do not allow migrated content to live longer than 1 year */ - prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_YEARS), - prq.expiration); + prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_UNIT_YEARS), + prq.expiration); prq.size = data_size; prq.type = type; prq.eo = GNUNET_BLOCK_EO_NONE; @@ -1287,7 +1283,7 @@ GSF_cadet_lookup_ (struct GSF_PendingRequest *pr) if (0 == pr->public_data.target) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Cannot do cadet-based download, target peer not known\n"); + "Cannot do cadet-based download, target peer not known\n"); return; } if (NULL != pr->cadet_request) @@ -1311,13 +1307,13 @@ warn_delay_task (void *cls) struct GSF_PendingRequest *pr = cls; GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, - _("Datastore lookup already took %s!\n"), - GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pr->qe_start), - GNUNET_YES)); - pr->warn_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, - &warn_delay_task, - pr); + _ ("Datastore lookup already took %s!\n"), + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_duration (pr->qe_start), + GNUNET_YES)); + pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, + &warn_delay_task, + pr); } @@ -1332,11 +1328,13 @@ odc_warn_delay_task (void *cls) struct GSF_PendingRequest *pr = cls; GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("On-demand lookup already took %s!\n"), - GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pr->qe_start), GNUNET_YES)); - pr->warn_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, - &odc_warn_delay_task, pr); + _ ("On-demand lookup already took %s!\n"), + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_duration (pr->qe_start), + GNUNET_YES)); + pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, + &odc_warn_delay_task, + pr); } @@ -1353,7 +1351,7 @@ call_continuation (struct GSF_PendingRequest *pr) pr->warn_task = NULL; } if (NULL == cont) - return; /* no continuation */ + return; /* no continuation */ pr->llc_cont = NULL; if (0 != (GSF_PRO_LOCAL_ONLY & pr->public_data.options)) { @@ -1362,14 +1360,14 @@ call_continuation (struct GSF_PendingRequest *pr) /* Signal that we are done and that there won't be any additional results to allow client to clean up state. */ pr->rh (pr->rh_cls, - GNUNET_BLOCK_EVALUATION_OK_LAST, - pr, - UINT32_MAX, - GNUNET_TIME_UNIT_ZERO_ABS, - GNUNET_TIME_UNIT_FOREVER_ABS, - GNUNET_BLOCK_TYPE_ANY, - NULL, - 0); + GNUNET_BLOCK_EVALUATION_OK_LAST, + pr, + UINT32_MAX, + GNUNET_TIME_UNIT_ZERO_ABS, + GNUNET_TIME_UNIT_FOREVER_ABS, + GNUNET_BLOCK_TYPE_ANY, + NULL, + 0); } /* Finally, call our continuation to signal that we are done with local processing of this request; i.e. to @@ -1389,10 +1387,11 @@ no_more_local_results (struct GSF_PendingRequest *pr) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, "No further local responses available.\n"); #if INSANE_STATISTICS - if ( (GNUNET_BLOCK_TYPE_FS_DBLOCK == pr->public_data.type) || - (GNUNET_BLOCK_TYPE_FS_IBLOCK == pr->public_data.type) ) + if ((GNUNET_BLOCK_TYPE_FS_DBLOCK == pr->public_data.type) || + (GNUNET_BLOCK_TYPE_FS_IBLOCK == pr->public_data.type)) GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# requested DBLOCK or IBLOCK not found"), + gettext_noop ( + "# requested DBLOCK or IBLOCK not found"), 1, GNUNET_NO); #endif @@ -1421,37 +1420,40 @@ start_local_query (struct GSF_PendingRequest *pr, bool random) { pr->qe_start = GNUNET_TIME_absolute_get (); - pr->warn_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, - &warn_delay_task, - pr); - pr->qe = - GNUNET_DATASTORE_get_key (GSF_dsh, - next_uid, - random, - &pr->public_data.query, - pr->public_data.type == - GNUNET_BLOCK_TYPE_FS_DBLOCK ? - GNUNET_BLOCK_TYPE_ANY : pr->public_data.type, - (0 != - (GSF_PRO_PRIORITY_UNLIMITED & pr-> - public_data.options)) ? UINT_MAX : 1 - /* queue priority */ , - (0 != - (GSF_PRO_PRIORITY_UNLIMITED & pr-> - public_data.options)) ? UINT_MAX : - GSF_datastore_queue_size - /* max queue size */ , - &process_local_reply, pr); + pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, + &warn_delay_task, + pr); + pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh, + next_uid, + random, + &pr->public_data.query, + pr->public_data.type == + GNUNET_BLOCK_TYPE_FS_DBLOCK + ? GNUNET_BLOCK_TYPE_ANY + : pr->public_data.type, + (0 != (GSF_PRO_PRIORITY_UNLIMITED & + pr->public_data.options)) + ? UINT_MAX + : 1 + /* queue priority */, + (0 != (GSF_PRO_PRIORITY_UNLIMITED & + pr->public_data.options)) + ? UINT_MAX + : GSF_datastore_queue_size + /* max queue size */, + &process_local_reply, + pr); if (NULL != pr->qe) return; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "ERROR Requesting `%s' of type %d with next_uid %llu from datastore.\n", - GNUNET_h2s (&pr->public_data.query), - pr->public_data.type, - (unsigned long long) next_uid); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "ERROR Requesting `%s' of type %d with next_uid %llu from datastore.\n", + GNUNET_h2s (&pr->public_data.query), + pr->public_data.type, + (unsigned long long) next_uid); GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Datastore lookups concluded (error queueing)"), + gettext_noop ( + "# Datastore lookups concluded (error queueing)"), 1, GNUNET_NO); call_continuation (pr); @@ -1498,44 +1500,43 @@ process_local_reply (void *cls, if (NULL == pr->qe) goto called_from_on_demand; pr->qe = NULL; - if ( (NULL == key) && - pr->seen_null && - !pr->have_first_uid) /* We have hit the end for the 2nd time with no results */ + if ( + (NULL == key) && pr->seen_null && + ! pr->have_first_uid) /* We have hit the end for the 2nd time with no results */ { /* No results */ #if INSANE_STATISTICS GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# Datastore lookups concluded (no results)"), - 1, GNUNET_NO); + gettext_noop ( + "# Datastore lookups concluded (no results)"), + 1, + GNUNET_NO); #endif no_more_local_results (pr); return; } - if ( ( (NULL == key) && - pr->seen_null ) || /* We have hit the end for the 2nd time OR */ - ( pr->seen_null && - pr->have_first_uid && - (uid >= pr->first_uid) ) ) /* We have hit the end and past first UID */ + if (((NULL == key) && + pr->seen_null) || /* We have hit the end for the 2nd time OR */ + (pr->seen_null && pr->have_first_uid && + (uid >= pr->first_uid))) /* We have hit the end and past first UID */ { /* Seen all results */ GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# Datastore lookups concluded (seen all)"), - 1, GNUNET_NO); + gettext_noop ( + "# Datastore lookups concluded (seen all)"), + 1, + GNUNET_NO); no_more_local_results (pr); return; } if (NULL == key) { - GNUNET_assert (!pr->seen_null); + GNUNET_assert (! pr->seen_null); pr->seen_null = true; - start_local_query (pr, - 0 /* next_uid */, - false /* random */); + start_local_query (pr, 0 /* next_uid */, false /* random */); return; } - if (!pr->have_first_uid) + if (! pr->have_first_uid) { pr->first_uid = uid; pr->have_first_uid = true; @@ -1543,54 +1544,57 @@ process_local_reply (void *cls, pr->result_count++; if (pr->result_count > MAX_RESULTS) { - GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# Datastore lookups aborted (more than MAX_RESULTS)"), - 1, GNUNET_NO); + GNUNET_STATISTICS_update ( + GSF_stats, + gettext_noop ("# Datastore lookups aborted (more than MAX_RESULTS)"), + 1, + GNUNET_NO); no_more_local_results (pr); return; } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received reply for `%s' of type %d with UID %llu from datastore.\n", - GNUNET_h2s (key), type, (unsigned long long) uid); + GNUNET_h2s (key), + type, + (unsigned long long) uid); if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found ONDEMAND block, performing on-demand encoding\n"); GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# on-demand blocks matched requests"), 1, + gettext_noop ( + "# on-demand blocks matched requests"), + 1, GNUNET_NO); pr->qe_start = GNUNET_TIME_absolute_get (); - pr->warn_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, - &odc_warn_delay_task, pr); - if (GNUNET_OK == - GNUNET_FS_handle_on_demand_block (key, - size, - data, - type, - priority, - anonymity, - replication, - expiration, - uid, - &process_local_reply, - pr)) + pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, + &odc_warn_delay_task, + pr); + if (GNUNET_OK == GNUNET_FS_handle_on_demand_block (key, + size, + data, + type, + priority, + anonymity, + replication, + expiration, + uid, + &process_local_reply, + pr)) { GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# on-demand lookups performed successfully"), - 1, GNUNET_NO); - return; /* we're done */ + gettext_noop ( + "# on-demand lookups performed successfully"), + 1, + GNUNET_NO); + return; /* we're done */ } GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# on-demand lookups failed"), 1, + gettext_noop ("# on-demand lookups failed"), + 1, GNUNET_NO); GNUNET_SCHEDULER_cancel (pr->warn_task); - start_local_query (pr, - uid + 1 /* next_uid */, - false /* random */); + start_local_query (pr, uid + 1 /* next_uid */, false /* random */); return; } called_from_on_demand: @@ -1603,11 +1607,15 @@ called_from_on_demand: GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, size, &query)) { GNUNET_break (0); - GNUNET_DATASTORE_remove (GSF_dsh, key, size, data, UINT_MAX, UINT_MAX, - NULL, NULL); - start_local_query (pr, - uid + 1 /* next_uid */, - false /* random */); + GNUNET_DATASTORE_remove (GSF_dsh, + key, + size, + data, + UINT_MAX, + UINT_MAX, + NULL, + NULL); + start_local_query (pr, uid + 1 /* next_uid */, false /* random */); return; } prq.type = type; @@ -1621,11 +1629,11 @@ called_from_on_demand: pr->local_result = prq.eval; if (GNUNET_BLOCK_EVALUATION_OK_LAST == prq.eval) { - GNUNET_STATISTICS_update (GSF_stats, - gettext_noop - ("# Datastore lookups concluded (found last result)"), - 1, - GNUNET_NO); + GNUNET_STATISTICS_update ( + GSF_stats, + gettext_noop ("# Datastore lookups concluded (found last result)"), + 1, + GNUNET_NO); call_continuation (pr); return; } @@ -1633,18 +1641,16 @@ called_from_on_demand: ((GNUNET_YES == GSF_test_get_load_too_high_ (0)) || (pr->public_data.results_found > 5 + 2 * pr->public_data.priority))) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Load too high, done with request\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load too high, done with request\n"); GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Datastore lookups concluded (load too high)"), + gettext_noop ( + "# Datastore lookups concluded (load too high)"), 1, GNUNET_NO); call_continuation (pr); return; } - start_local_query (pr, - uid + 1 /* next_uid */, - false /* random */); + start_local_query (pr, uid + 1 /* next_uid */, false /* random */); } @@ -1664,10 +1670,9 @@ GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr, if (0 == pr->origin_pid) return GNUNET_YES; GNUNET_PEER_resolve (pr->origin_pid, &pi); - return (0 == - memcmp (&pi, target, - sizeof (struct GNUNET_PeerIdentity))) ? GNUNET_NO : - GNUNET_YES; + return (0 == memcmp (&pi, target, sizeof (struct GNUNET_PeerIdentity))) + ? GNUNET_NO + : GNUNET_YES; } @@ -1690,16 +1695,14 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr, pr->llc_cont_cls = cont_cls; #if INSANE_STATISTICS GNUNET_STATISTICS_update (GSF_stats, - gettext_noop ("# Datastore lookups initiated"), 1, + gettext_noop ("# Datastore lookups initiated"), + 1, GNUNET_NO); #endif - start_local_query(pr, - 0 /* next_uid */, - true /* random */); + start_local_query (pr, 0 /* next_uid */, true /* random */); } - /** * Handle P2P "CONTENT" message. Checks that the message is * well-formed and then checks if there are any pending requests for @@ -1710,8 +1713,7 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr, * @param put the actual message */ void -handle_p2p_put (void *cls, - const struct PutMessage *put) +handle_p2p_put (void *cls, const struct PutMessage *put) { struct GSF_ConnectedPeer *cp = cls; uint16_t msize; @@ -1733,14 +1735,11 @@ handle_p2p_put (void *cls, type = ntohl (put->type); expiration = GNUNET_TIME_absolute_ntoh (put->expiration); /* do not allow migrated content to live longer than 1 year */ - expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_YEARS), - expiration); + expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_UNIT_YEARS), + expiration); if (GNUNET_OK != - GNUNET_BLOCK_get_key (GSF_block_ctx, - type, - &put[1], - dsize, - &query)) + GNUNET_BLOCK_get_key (GSF_block_ctx, type, &put[1], dsize, &query)) { GNUNET_break_op (0); return; @@ -1767,11 +1766,10 @@ handle_p2p_put (void *cls, { GSF_connected_peer_change_preference_ (cp, CONTENT_BANDWIDTH_VALUE + - 1000 * prq.priority); + 1000 * prq.priority); GSF_get_peer_performance_data_ (cp)->respect += prq.priority; } - if ((GNUNET_YES == active_to_migration) && - (NULL != cp) && + if ((GNUNET_YES == active_to_migration) && (NULL != cp) && (GNUNET_NO == test_put_load_too_high (prq.priority))) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -1784,20 +1782,20 @@ handle_p2p_put (void *cls, GNUNET_assert (0 != GSF_get_peer_performance_data_ (cp)->pid); GNUNET_PEER_resolve (GSF_get_peer_performance_data_ (cp)->pid, &pmc->origin); - if (NULL == - GNUNET_DATASTORE_put (GSF_dsh, - 0, - &query, - dsize, - &put[1], - type, - prq.priority, - 1 /* anonymity */ , - 0 /* replication */ , - expiration, 1 + prq.priority, - MAX_DATASTORE_QUEUE, - &put_migration_continuation, - pmc)) + if (NULL == GNUNET_DATASTORE_put (GSF_dsh, + 0, + &query, + dsize, + &put[1], + type, + prq.priority, + 1 /* anonymity */, + 0 /* replication */, + expiration, + 1 + prq.priority, + MAX_DATASTORE_QUEUE, + &put_migration_continuation, + pmc)) { put_migration_continuation (pmc, GNUNET_SYSERR, @@ -1810,32 +1808,29 @@ handle_p2p_put (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Choosing not to keep content `%s' (%d/%d)\n", GNUNET_h2s (&query), - active_to_migration, + active_to_migration, test_put_load_too_high (prq.priority)); } putl = GNUNET_LOAD_get_load (datastore_put_load); - if ( (NULL != cp) && - (GNUNET_NO == prq.request_found) && - ( (GNUNET_YES != active_to_migration) || - (putl > 2.5 * (1 + prq.priority)) ) ) + if ((NULL != cp) && (GNUNET_NO == prq.request_found) && + ((GNUNET_YES != active_to_migration) || + (putl > 2.5 * (1 + prq.priority)))) { if (GNUNET_YES != active_to_migration) putl = 1.0 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 5); - block_time = - GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, - 5000 + - GNUNET_CRYPTO_random_u32 - (GNUNET_CRYPTO_QUALITY_WEAK, - (unsigned int) (60000 * putl * putl))); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Asking to stop migration for %s because of load %f and events %d/%d\n", - GNUNET_STRINGS_relative_time_to_string (block_time, - GNUNET_YES), - putl, - active_to_migration, - (GNUNET_NO == prq.request_found)); + block_time = GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_MILLISECONDS, + 5000 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + (unsigned int) (60000 * putl * putl))); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Asking to stop migration for %s because of load %f and events %d/%d\n", + GNUNET_STRINGS_relative_time_to_string (block_time, GNUNET_YES), + putl, + active_to_migration, + (GNUNET_NO == prq.request_found)); GSF_block_peer_migration_ (cp, - GNUNET_TIME_relative_to_absolute (block_time)); + GNUNET_TIME_relative_to_absolute (block_time)); } } @@ -1860,19 +1855,21 @@ void GSF_pending_request_init_ () { if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number (GSF_cfg, "fs", + GNUNET_CONFIGURATION_get_value_number (GSF_cfg, + "fs", "MAX_PENDING_REQUESTS", &max_pending_requests)) { GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO, - "fs", "MAX_PENDING_REQUESTS"); + "fs", + "MAX_PENDING_REQUESTS"); } active_to_migration = - GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING"); + GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING"); datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE); pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024, GNUNET_YES); requests_by_expiration_heap = - GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); } @@ -1882,9 +1879,7 @@ GSF_pending_request_init_ () void GSF_pending_request_done_ () { - GNUNET_CONTAINER_multihashmap_iterate (pr_map, - &clean_request, - NULL); + GNUNET_CONTAINER_multihashmap_iterate (pr_map, &clean_request, NULL); GNUNET_CONTAINER_multihashmap_destroy (pr_map); pr_map = NULL; GNUNET_CONTAINER_heap_destroy (requests_by_expiration_heap); diff --git a/src/include/gnunet_container_lib.h b/src/include/gnunet_container_lib.h index fbfbf2d40..8796fdcb6 100644 --- a/src/include/gnunet_container_lib.h +++ b/src/include/gnunet_container_lib.h @@ -768,7 +768,7 @@ enum GNUNET_CONTAINER_MultiHashMapOption * iterate, * #GNUNET_NO if not. */ -typedef int (*GNUNET_CONTAINER_HashMapIterator) ( +typedef int (*GNUNET_CONTAINER_MulitHashMapIteratorCallback) ( void *cls, const struct GNUNET_HashCode *key, void *value); @@ -946,7 +946,7 @@ GNUNET_CONTAINER_multihashmap_size ( int GNUNET_CONTAINER_multihashmap_iterate ( struct GNUNET_CONTAINER_MultiHashMap *map, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls); @@ -1016,7 +1016,7 @@ int GNUNET_CONTAINER_multihashmap_get_multiple ( struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls); @@ -1034,7 +1034,7 @@ GNUNET_CONTAINER_multihashmap_get_multiple ( unsigned int GNUNET_CONTAINER_multihashmap_get_random ( const struct GNUNET_CONTAINER_MultiHashMap *map, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls); @@ -1613,7 +1613,7 @@ GNUNET_CONTAINER_multishortmap_get_random ( * iterate, * #GNUNET_NO if not. */ -typedef int (*GNUNET_CONTAINER_MultiUuidmapIterator) ( +typedef int (*GNUNET_CONTAINER_MultiUuidmapIteratorCallback) ( void *cls, const struct GNUNET_Uuid *key, void *value); @@ -1786,7 +1786,7 @@ GNUNET_CONTAINER_multiuuidmap_size ( int GNUNET_CONTAINER_multiuuidmap_iterate ( struct GNUNET_CONTAINER_MultiUuidmap *map, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls); @@ -1859,7 +1859,7 @@ int GNUNET_CONTAINER_multiuuidmap_get_multiple ( struct GNUNET_CONTAINER_MultiUuidmap *map, const struct GNUNET_Uuid *key, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls); @@ -1877,7 +1877,7 @@ GNUNET_CONTAINER_multiuuidmap_get_multiple ( unsigned int GNUNET_CONTAINER_multiuuidmap_get_random ( const struct GNUNET_CONTAINER_MultiUuidmap *map, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls); @@ -1909,9 +1909,9 @@ struct GNUNET_CONTAINER_MultiHashMap32Iterator; * iterate, * #GNUNET_NO if not. */ -typedef int (*GNUNET_CONTAINER_HashMapIterator32) (void *cls, - uint32_t key, - void *value); +typedef int (*GNUNET_CONTAINER_MulitHashMapIterator32Callback) (void *cls, + uint32_t key, + void *value); /** @@ -1979,7 +1979,7 @@ GNUNET_CONTAINER_multihashmap32_get ( int GNUNET_CONTAINER_multihashmap32_iterate ( struct GNUNET_CONTAINER_MultiHashMap32 *map, - GNUNET_CONTAINER_HashMapIterator32 it, + GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls); @@ -2087,7 +2087,7 @@ int GNUNET_CONTAINER_multihashmap32_get_multiple ( struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, - GNUNET_CONTAINER_HashMapIterator32 it, + GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls); diff --git a/src/set/gnunet-set-ibf-profiler.c b/src/set/gnunet-set-ibf-profiler.c index d45669dc7..1e3f78595 100644 --- a/src/set/gnunet-set-ibf-profiler.c +++ b/src/set/gnunet-set-ibf-profiler.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -56,16 +56,17 @@ register_hashcode (struct GNUNET_HashCode *hash) struct IBF_Key key; key = ibf_key_from_hashcode (hash); ibf_hashcode_from_key (key, &replicated); - (void) GNUNET_CONTAINER_multihashmap_put (key_to_hashcode, - &replicated, - GNUNET_memdup (hash, sizeof *hash), - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + (void) GNUNET_CONTAINER_multihashmap_put ( + key_to_hashcode, + &replicated, + GNUNET_memdup (hash, sizeof *hash), + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); } static void iter_hashcodes (struct IBF_Key key, - GNUNET_CONTAINER_HashMapIterator iter, + GNUNET_CONTAINER_MulitHashMapIteratorCallback iter, void *cls) { struct GNUNET_HashCode replicated; @@ -73,14 +74,13 @@ iter_hashcodes (struct IBF_Key key, ibf_hashcode_from_key (key, &replicated); GNUNET_CONTAINER_multihashmap_get_multiple (key_to_hashcode, &replicated, - iter, cls); + iter, + cls); } static int -insert_iterator (void *cls, - const struct GNUNET_HashCode *key, - void *value) +insert_iterator (void *cls, const struct GNUNET_HashCode *key, void *value) { struct InvertibleBloomFilter *ibf = cls; @@ -90,9 +90,7 @@ insert_iterator (void *cls, static int -remove_iterator (void *cls, - const struct GNUNET_HashCode *key, - void *value) +remove_iterator (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls; /* if remove fails, there just was a collision with another key */ @@ -115,18 +113,27 @@ run (void *cls, struct GNUNET_TIME_Absolute start_time; struct GNUNET_TIME_Relative delta_time; - set_a = GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)), - GNUNET_NO); - set_b = GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)), - GNUNET_NO); + set_a = + GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)), + GNUNET_NO); + set_b = + GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)), + GNUNET_NO); set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize), GNUNET_NO); - key_to_hashcode = GNUNET_CONTAINER_multihashmap_create (((asize+bsize+csize == 0) ? 1 : (asize+bsize+csize)), - GNUNET_NO); + key_to_hashcode = + GNUNET_CONTAINER_multihashmap_create (((asize + bsize + csize == 0) + ? 1 + : (asize + bsize + csize)), + GNUNET_NO); printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n", - hash_num, ibf_size, asize, bsize, csize); + hash_num, + ibf_size, + asize, + bsize, + csize); i = 0; while (i < asize) @@ -135,8 +142,11 @@ run (void *cls, if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id)) continue; GNUNET_break (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put (set_a, &id, NULL, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CONTAINER_multihashmap_put ( + set_a, + &id, + NULL, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); register_hashcode (&id); i++; } @@ -149,8 +159,11 @@ run (void *cls, if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id)) continue; GNUNET_break (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put (set_b, &id, NULL, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CONTAINER_multihashmap_put ( + set_b, + &id, + NULL, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); register_hashcode (&id); i++; } @@ -165,16 +178,18 @@ run (void *cls, if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id)) continue; GNUNET_break (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put (set_c, &id, NULL, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CONTAINER_multihashmap_put ( + set_c, + &id, + NULL, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); register_hashcode (&id); i++; } ibf_a = ibf_create (ibf_size, hash_num); ibf_b = ibf_create (ibf_size, hash_num); - if ( (NULL == ibf_a) || - (NULL == ibf_b) ) + if ((NULL == ibf_a) || (NULL == ibf_b)) { /* insufficient memory */ GNUNET_break (0); @@ -195,8 +210,7 @@ run (void *cls, delta_time = GNUNET_TIME_absolute_get_duration (start_time); printf ("encoded in: %s\n", - GNUNET_STRINGS_relative_time_to_string (delta_time, - GNUNET_NO)); + GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO)); ibf_subtract (ibf_a, ibf_b); @@ -209,8 +223,9 @@ run (void *cls, if (GNUNET_SYSERR == res) { printf ("decode failed, %u/%u elements left\n", - GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b), - asize + bsize); + GNUNET_CONTAINER_multihashmap_size (set_a) + + GNUNET_CONTAINER_multihashmap_size (set_b), + asize + bsize); return; } if (GNUNET_NO == res) @@ -220,8 +235,7 @@ run (void *cls, { delta_time = GNUNET_TIME_absolute_get_duration (start_time); printf ("decoded successfully in: %s\n", - GNUNET_STRINGS_relative_time_to_string (delta_time, - GNUNET_NO)); + GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO)); } else { @@ -235,9 +249,10 @@ run (void *cls, if (side == -1) iter_hashcodes (ibf_key, remove_iterator, set_b); } - printf("cyclic IBF, %u/%u elements left\n", - GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b), - asize + bsize); + printf ("cyclic IBF, %u/%u elements left\n", + GNUNET_CONTAINER_multihashmap_size (set_a) + + GNUNET_CONTAINER_multihashmap_size (set_b), + asize + bsize); } @@ -247,40 +262,45 @@ main (int argc, char **argv) struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_option_uint ('A', - "asize", - NULL, - gettext_noop ("number of element in set A-B"), - &asize), + "asize", + NULL, + gettext_noop ("number of element in set A-B"), + &asize), GNUNET_GETOPT_option_uint ('B', - "bsize", - NULL, - gettext_noop ("number of element in set B-A"), - &bsize), + "bsize", + NULL, + gettext_noop ("number of element in set B-A"), + &bsize), GNUNET_GETOPT_option_uint ('C', - "csize", - NULL, - gettext_noop ("number of common elements in A and B"), - &csize), - + "csize", + NULL, + gettext_noop ( + "number of common elements in A and B"), + &csize), + GNUNET_GETOPT_option_uint ('k', - "hash-num", - NULL, - gettext_noop ("hash num"), - &hash_num), + "hash-num", + NULL, + gettext_noop ("hash num"), + &hash_num), GNUNET_GETOPT_option_uint ('s', - "ibf-size", - NULL, - gettext_noop ("ibf size"), - &ibf_size), - - GNUNET_GETOPT_OPTION_END - }; - - GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus-ibf", - "help", - options, &run, NULL, GNUNET_YES); + "ibf-size", + NULL, + gettext_noop ("ibf size"), + &ibf_size), + + GNUNET_GETOPT_OPTION_END}; + + GNUNET_PROGRAM_run2 (argc, + argv, + "gnunet-consensus-ibf", + "help", + options, + &run, + NULL, + GNUNET_YES); return 0; } diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c index 165f04149..bcf6dccf0 100644 --- a/src/util/container_multihashmap.c +++ b/src/util/container_multihashmap.c @@ -355,7 +355,7 @@ GNUNET_CONTAINER_multihashmap_get ( int GNUNET_CONTAINER_multihashmap_iterate ( struct GNUNET_CONTAINER_MultiHashMap *map, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls) { int count; @@ -876,7 +876,7 @@ int GNUNET_CONTAINER_multihashmap_get_multiple ( struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls) { int count; @@ -942,7 +942,7 @@ GNUNET_CONTAINER_multihashmap_get_multiple ( unsigned int GNUNET_CONTAINER_multihashmap_get_random ( const struct GNUNET_CONTAINER_MultiHashMap *map, - GNUNET_CONTAINER_HashMapIterator it, + GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls) { unsigned int off; diff --git a/src/util/container_multihashmap32.c b/src/util/container_multihashmap32.c index a614c04ae..0956ada67 100644 --- a/src/util/container_multihashmap32.c +++ b/src/util/container_multihashmap32.c @@ -28,7 +28,8 @@ #include "platform.h" #include "gnunet_container_lib.h" -#define LOG(kind,...) GNUNET_log_from (kind, "util-container-multihashmap32", __VA_ARGS__) +#define LOG(kind, ...) \ + GNUNET_log_from (kind, "util-container-multihashmap32", __VA_ARGS__) /** @@ -59,7 +60,6 @@ struct MapEntry * If there is a hash collision, we create a linked list. */ struct MapEntry *next; - }; /** @@ -146,8 +146,7 @@ GNUNET_CONTAINER_multihashmap32_create (unsigned int len) GNUNET_assert (len > 0); ret = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap32); - ret->map = GNUNET_malloc_large (len * - sizeof (struct MapEntry *)); + ret->map = GNUNET_malloc_large (len * sizeof (struct MapEntry *)); if (NULL == ret->map) { GNUNET_free (ret); @@ -165,7 +164,8 @@ GNUNET_CONTAINER_multihashmap32_create (unsigned int len) * @param map the map */ void -GNUNET_CONTAINER_multihashmap32_destroy (struct GNUNET_CONTAINER_MultiHashMap32 *map) +GNUNET_CONTAINER_multihashmap32_destroy ( + struct GNUNET_CONTAINER_MultiHashMap32 *map) { struct MapEntry *e; @@ -190,8 +190,7 @@ GNUNET_CONTAINER_multihashmap32_destroy (struct GNUNET_CONTAINER_MultiHashMap32 * @return offset into the "map" array of "m" */ static unsigned int -idx_of (const struct GNUNET_CONTAINER_MultiHashMap32 *m, - const uint32_t key) +idx_of (const struct GNUNET_CONTAINER_MultiHashMap32 *m, const uint32_t key) { GNUNET_assert (NULL != m); return ((unsigned int) key) % m->map_length; @@ -205,7 +204,8 @@ idx_of (const struct GNUNET_CONTAINER_MultiHashMap32 *m, * @return the number of key value pairs */ unsigned int -GNUNET_CONTAINER_multihashmap32_size (const struct GNUNET_CONTAINER_MultiHashMap32 *map) +GNUNET_CONTAINER_multihashmap32_size ( + const struct GNUNET_CONTAINER_MultiHashMap32 *map) { return map->size; } @@ -222,8 +222,9 @@ GNUNET_CONTAINER_multihashmap32_size (const struct GNUNET_CONTAINER_MultiHashMap * key-value pairs with value NULL */ void * -GNUNET_CONTAINER_multihashmap32_get (const struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key) +GNUNET_CONTAINER_multihashmap32_get ( + const struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key) { struct MapEntry *e; @@ -248,9 +249,10 @@ GNUNET_CONTAINER_multihashmap32_get (const struct GNUNET_CONTAINER_MultiHashMap3 * #GNUNET_SYSERR if it aborted iteration */ int -GNUNET_CONTAINER_multihashmap32_iterate (struct GNUNET_CONTAINER_MultiHashMap32 *map, - GNUNET_CONTAINER_HashMapIterator32 it, - void *it_cls) +GNUNET_CONTAINER_multihashmap32_iterate ( + struct GNUNET_CONTAINER_MultiHashMap32 *map, + GNUNET_CONTAINER_MulitHashMapIterator32Callback it, + void *it_cls) { int count; struct MapEntry **ce; @@ -269,13 +271,11 @@ GNUNET_CONTAINER_multihashmap32_iterate (struct GNUNET_CONTAINER_MultiHashMap32 *ce = e->next; if (NULL != it) { - if (GNUNET_OK != it (it_cls, - e->key, - e->value)) - { - GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE); + if (GNUNET_OK != it (it_cls, e->key, e->value)) + { + GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE); return GNUNET_SYSERR; - } + } } count++; } @@ -294,9 +294,9 @@ GNUNET_CONTAINER_multihashmap32_iterate (struct GNUNET_CONTAINER_MultiHashMap32 */ static void update_next_cache (struct GNUNET_CONTAINER_MultiHashMap32 *map, - const struct MapEntry *me) + const struct MapEntry *me) { - for (unsigned int i=0;inext_cache_off;i++) + for (unsigned int i = 0; i < map->next_cache_off; i++) if (map->next_cache[i] == me) map->next_cache[i] = me->next; } @@ -314,9 +314,10 @@ update_next_cache (struct GNUNET_CONTAINER_MultiHashMap32 *map, * is not in the map */ int -GNUNET_CONTAINER_multihashmap32_remove (struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key, - const void *value) +GNUNET_CONTAINER_multihashmap32_remove ( + struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key, + const void *value) { struct MapEntry *e; struct MapEntry *p; @@ -329,14 +330,13 @@ GNUNET_CONTAINER_multihashmap32_remove (struct GNUNET_CONTAINER_MultiHashMap32 * e = map->map[i]; while (e != NULL) { - if ( (key == e->key) && (value == e->value) ) + if ((key == e->key) && (value == e->value)) { if (p == NULL) map->map[i] = e->next; else p->next = e->next; - update_next_cache (map, - e); + update_next_cache (map, e); GNUNET_free (e); map->size--; return GNUNET_YES; @@ -357,8 +357,9 @@ GNUNET_CONTAINER_multihashmap32_remove (struct GNUNET_CONTAINER_MultiHashMap32 * * @return number of values removed */ int -GNUNET_CONTAINER_multihashmap32_remove_all (struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key) +GNUNET_CONTAINER_multihashmap32_remove_all ( + struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key) { struct MapEntry *e; struct MapEntry *p; @@ -379,8 +380,7 @@ GNUNET_CONTAINER_multihashmap32_remove_all (struct GNUNET_CONTAINER_MultiHashMap map->map[i] = e->next; else p->next = e->next; - update_next_cache (map, - e); + update_next_cache (map, e); GNUNET_free (e); map->size--; if (p == NULL) @@ -409,8 +409,9 @@ GNUNET_CONTAINER_multihashmap32_remove_all (struct GNUNET_CONTAINER_MultiHashMap * #GNUNET_NO if not */ int -GNUNET_CONTAINER_multihashmap32_contains (const struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key) +GNUNET_CONTAINER_multihashmap32_contains ( + const struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key) { struct MapEntry *e; @@ -436,16 +437,17 @@ GNUNET_CONTAINER_multihashmap32_contains (const struct GNUNET_CONTAINER_MultiHas * #GNUNET_NO if not */ int -GNUNET_CONTAINER_multihashmap32_contains_value (const struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key, - const void *value) +GNUNET_CONTAINER_multihashmap32_contains_value ( + const struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key, + const void *value) { struct MapEntry *e; e = map->map[idx_of (map, key)]; while (e != NULL) { - if ( (key == e->key) && (e->value == value) ) + if ((key == e->key) && (e->value == value)) return GNUNET_YES; e = e->next; } @@ -475,8 +477,7 @@ grow (struct GNUNET_CONTAINER_MultiHashMap32 *map) new_len = old_len; /* never use 0 */ if (new_len == old_len) return; /* nothing changed */ - new_map = GNUNET_malloc_large (new_len * - sizeof (struct MapEntry *)); + new_map = GNUNET_malloc_large (new_len * sizeof (struct MapEntry *)); if (NULL == new_map) return; /* grow not possible */ map->modification_counter++; @@ -509,10 +510,11 @@ grow (struct GNUNET_CONTAINER_MultiHashMap32 *map) * value already exists */ int -GNUNET_CONTAINER_multihashmap32_put (struct GNUNET_CONTAINER_MultiHashMap32 - *map, uint32_t key, void *value, - enum GNUNET_CONTAINER_MultiHashMapOption - opt) +GNUNET_CONTAINER_multihashmap32_put ( + struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key, + void *value, + enum GNUNET_CONTAINER_MultiHashMapOption opt) { struct MapEntry *e; unsigned int i; @@ -560,10 +562,11 @@ GNUNET_CONTAINER_multihashmap32_put (struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_SYSERR if it aborted iteration */ int -GNUNET_CONTAINER_multihashmap32_get_multiple (struct GNUNET_CONTAINER_MultiHashMap32 *map, - uint32_t key, - GNUNET_CONTAINER_HashMapIterator32 it, - void *it_cls) +GNUNET_CONTAINER_multihashmap32_get_multiple ( + struct GNUNET_CONTAINER_MultiHashMap32 *map, + uint32_t key, + GNUNET_CONTAINER_MulitHashMapIterator32Callback it, + void *it_cls) { int count; struct MapEntry *e; @@ -579,14 +582,11 @@ GNUNET_CONTAINER_multihashmap32_get_multiple (struct GNUNET_CONTAINER_MultiHashM *ce = e->next; if (key != e->key) continue; - if ( (NULL != it) && - (GNUNET_OK != it (it_cls, - key, - e->value)) ) - { - GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE); - return GNUNET_SYSERR; - } + if ((NULL != it) && (GNUNET_OK != it (it_cls, key, e->value))) + { + GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE); + return GNUNET_SYSERR; + } count++; } GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE); @@ -607,7 +607,8 @@ GNUNET_CONTAINER_multihashmap32_get_multiple (struct GNUNET_CONTAINER_MultiHashM * @return an iterator over the given multihashmap @a map */ struct GNUNET_CONTAINER_MultiHashMap32Iterator * -GNUNET_CONTAINER_multihashmap32_iterator_create (const struct GNUNET_CONTAINER_MultiHashMap32 *map) +GNUNET_CONTAINER_multihashmap32_iterator_create ( + const struct GNUNET_CONTAINER_MultiHashMap32 *map) { struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter; @@ -634,9 +635,10 @@ GNUNET_CONTAINER_multihashmap32_iterator_create (const struct GNUNET_CONTAINER_M * #GNUNET_NO if we are out of elements */ int -GNUNET_CONTAINER_multihashmap32_iterator_next (struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter, - uint32_t *key, - const void **value) +GNUNET_CONTAINER_multihashmap32_iterator_next ( + struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter, + uint32_t *key, + const void **value) { /* make sure the map has not been modified */ GNUNET_assert (iter->modification_counter == iter->map->modification_counter); @@ -668,7 +670,8 @@ GNUNET_CONTAINER_multihashmap32_iterator_next (struct GNUNET_CONTAINER_MultiHash * @param iter the iterator to destroy */ void -GNUNET_CONTAINER_multihashmap32_iterator_destroy (struct GNUNET_CONTAINER_MultiHashMapIterator *iter) +GNUNET_CONTAINER_multihashmap32_iterator_destroy ( + struct GNUNET_CONTAINER_MultiHashMapIterator *iter) { GNUNET_free (iter); } diff --git a/src/util/container_multiuuidmap.c b/src/util/container_multiuuidmap.c index 49eb64cfe..dd21fd128 100644 --- a/src/util/container_multiuuidmap.c +++ b/src/util/container_multiuuidmap.c @@ -338,7 +338,7 @@ GNUNET_CONTAINER_multiuuidmap_get ( int GNUNET_CONTAINER_multiuuidmap_iterate ( struct GNUNET_CONTAINER_MultiUuidmap *map, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls) { int count; @@ -802,7 +802,7 @@ int GNUNET_CONTAINER_multiuuidmap_get_multiple ( struct GNUNET_CONTAINER_MultiUuidmap *map, const struct GNUNET_Uuid *key, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls) { int count; @@ -868,7 +868,7 @@ GNUNET_CONTAINER_multiuuidmap_get_multiple ( unsigned int GNUNET_CONTAINER_multiuuidmap_get_random ( const struct GNUNET_CONTAINER_MultiUuidmap *map, - GNUNET_CONTAINER_MultiUuidmapIterator it, + GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls) { unsigned int off; -- 2.25.1