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/fs_search.c | 1622 ++++++++++++++++++++++++++-------------------------- 1 file changed, 815 insertions(+), 807 deletions(-) (limited to 'src/fs/fs_search.c') diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index 662bc1619..62ff4e90d 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c @@ -45,9 +45,9 @@ * @return value returned by the callback */ void * -GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, - struct GNUNET_FS_Handle *h, - struct GNUNET_FS_SearchContext *sc) +GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi, + struct GNUNET_FS_Handle *h, + struct GNUNET_FS_SearchContext *sc) { void *ret; @@ -59,11 +59,12 @@ GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, : sc->psearch_result->client_info; pi->value.search.query = (NULL != sc) ? sc->uri : NULL; pi->value.search.duration = (NULL != sc) - ? GNUNET_TIME_absolute_get_duration(sc->start_time) + ? GNUNET_TIME_absolute_get_duration ( + sc->start_time) : GNUNET_TIME_UNIT_ZERO; pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0; pi->fsh = h; - ret = h->upcb(h->upcb_cls, pi); + ret = h->upcb (h->upcb_cls, pi); return ret; } @@ -79,14 +80,14 @@ GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, * #GNUNET_OK otherwise */ static int -test_result_present(void *cls, - const struct GNUNET_HashCode * key, - void *value) +test_result_present (void *cls, + const struct GNUNET_HashCode *key, + void *value) { const struct GNUNET_FS_Uri *uri = cls; struct GNUNET_FS_SearchResult *sr = value; - if (GNUNET_FS_uri_test_equal(uri, sr->uri)) + if (GNUNET_FS_uri_test_equal (uri, sr->uri)) return GNUNET_SYSERR; return GNUNET_OK; } @@ -100,8 +101,8 @@ test_result_present(void *cls, * @param sr the specific result */ static void -notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, - struct GNUNET_FS_SearchResult *sr) +notify_client_chk_result (struct GNUNET_FS_SearchContext *sc, + struct GNUNET_FS_SearchResult *sr) { struct GNUNET_FS_ProgressInfo pi; @@ -110,7 +111,7 @@ notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, pi.value.search.specifics.result.uri = sr->uri; pi.value.search.specifics.result.result = sr; pi.value.search.specifics.result.applicability_rank = sr->optional_support; - sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); + sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); } @@ -122,8 +123,8 @@ notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, * @param sr the specific result */ static void -notify_client_chk_update(struct GNUNET_FS_SearchContext *sc, - struct GNUNET_FS_SearchResult *sr) +notify_client_chk_update (struct GNUNET_FS_SearchContext *sc, + struct GNUNET_FS_SearchResult *sr) { struct GNUNET_FS_ProgressInfo pi; @@ -137,15 +138,16 @@ notify_client_chk_update(struct GNUNET_FS_SearchContext *sc, sr->availability_trials; pi.value.search.specifics.update.applicability_rank = sr->optional_support; pi.value.search.specifics.update.current_probe_time - = GNUNET_TIME_absolute_get_duration(sr->probe_active_time); - sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); + = GNUNET_TIME_absolute_get_duration (sr->probe_active_time); + sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); } /** * Context for "get_result_present". */ -struct GetResultContext { +struct GetResultContext +{ /** * The URI we're looking for. */ @@ -170,14 +172,14 @@ struct GetResultContext { * @return #GNUNET_OK */ static int -get_result_present(void *cls, - const struct GNUNET_HashCode *key, - void *value) +get_result_present (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GetResultContext *grc = cls; struct GNUNET_FS_SearchResult *sr = value; - if (GNUNET_FS_uri_test_equal(grc->uri, sr->uri)) + if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri)) grc->sr = sr; return GNUNET_OK; } @@ -190,7 +192,7 @@ get_result_present(void *cls, * @param sr search result to signal for */ static void -signal_probe_result(struct GNUNET_FS_SearchResult *sr) +signal_probe_result (struct GNUNET_FS_SearchResult *sr) { struct GNUNET_FS_ProgressInfo pi; @@ -204,9 +206,9 @@ signal_probe_result(struct GNUNET_FS_SearchResult *sr) = sr->availability_trials; pi.value.search.specifics.update.applicability_rank = sr->optional_support; pi.value.search.specifics.update.current_probe_time - = GNUNET_TIME_absolute_get_duration(sr->probe_active_time); - sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sr->sc); - GNUNET_FS_search_start_probe_(sr); + = GNUNET_TIME_absolute_get_duration (sr->probe_active_time); + sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc); + GNUNET_FS_search_start_probe_ (sr); } @@ -216,21 +218,21 @@ signal_probe_result(struct GNUNET_FS_SearchResult *sr) * @param cls our `struct GNUNET_FS_SearchResult *` */ static void -probe_failure_handler(void *cls) +probe_failure_handler (void *cls) { struct GNUNET_FS_SearchResult *sr = cls; sr->probe_cancel_task = NULL; sr->availability_trials++; - GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES); + GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); sr->probe_ctx = NULL; - GNUNET_FS_stop_probe_ping_task_(sr); - GNUNET_FS_search_result_sync_(sr); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Probe #%u for search result %p failed\n", - sr->availability_trials, - sr); - signal_probe_result(sr); + GNUNET_FS_stop_probe_ping_task_ (sr); + GNUNET_FS_search_result_sync_ (sr); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Probe #%u for search result %p failed\n", + sr->availability_trials, + sr); + signal_probe_result (sr); } @@ -240,22 +242,22 @@ probe_failure_handler(void *cls) * @param cls our `struct GNUNET_FS_SearchResult *` */ static void -probe_success_handler(void *cls) +probe_success_handler (void *cls) { struct GNUNET_FS_SearchResult *sr = cls; sr->probe_cancel_task = NULL; sr->availability_trials++; sr->availability_success++; - GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES); + GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); sr->probe_ctx = NULL; - GNUNET_FS_stop_probe_ping_task_(sr); - GNUNET_FS_search_result_sync_(sr); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Probe #%u for search result %p succeeded\n", - sr->availability_trials, - sr); - signal_probe_result(sr); + GNUNET_FS_stop_probe_ping_task_ (sr); + GNUNET_FS_search_result_sync_ (sr); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Probe #%u for search result %p succeeded\n", + sr->availability_trials, + sr); + signal_probe_result (sr); } @@ -275,91 +277,83 @@ probe_success_handler(void *cls) * field in the `struct GNUNET_FS_ProgressInfo`. */ void * -GNUNET_FS_search_probe_progress_(void *cls, - const struct GNUNET_FS_ProgressInfo *info) +GNUNET_FS_search_probe_progress_ (void *cls, + const struct GNUNET_FS_ProgressInfo *info) { struct GNUNET_FS_SearchResult *sr = info->value.download.cctx; struct GNUNET_TIME_Relative dur; switch (info->status) + { + case GNUNET_FS_STATUS_DOWNLOAD_START: + /* ignore */ + break; + case GNUNET_FS_STATUS_DOWNLOAD_RESUME: + /* probes should never be resumed */ + GNUNET_assert (0); + break; + case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: + /* probes should never be suspended */ + GNUNET_break (0); + break; + case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: + /* ignore */ + break; + case GNUNET_FS_STATUS_DOWNLOAD_ERROR: + if (NULL != sr->probe_cancel_task) { - case GNUNET_FS_STATUS_DOWNLOAD_START: - /* ignore */ - break; - - case GNUNET_FS_STATUS_DOWNLOAD_RESUME: - /* probes should never be resumed */ - GNUNET_assert(0); - break; - - case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: - /* probes should never be suspended */ - GNUNET_break(0); - break; - - case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: - /* ignore */ - break; - - case GNUNET_FS_STATUS_DOWNLOAD_ERROR: - if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } + sr->probe_cancel_task = + GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time, + &probe_failure_handler, sr); + break; + case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: + if (NULL != sr->probe_cancel_task) + { + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } + sr->probe_cancel_task = + GNUNET_SCHEDULER_add_now (&probe_success_handler, sr); + break; + case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: + if (NULL != sr->probe_cancel_task) + { + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } + sr = NULL; + break; + case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: + if (NULL == sr->probe_cancel_task) + { + sr->probe_active_time = GNUNET_TIME_absolute_get (); sr->probe_cancel_task = - GNUNET_SCHEDULER_add_delayed(sr->remaining_probe_time, - &probe_failure_handler, sr); - break; - - case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: - if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } + GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time, + &probe_failure_handler, sr); + } + break; + case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: + if (NULL != sr->probe_cancel_task) + { + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } + dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time); + sr->remaining_probe_time = + GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur); + if (0 == sr->remaining_probe_time.rel_value_us) sr->probe_cancel_task = - GNUNET_SCHEDULER_add_now(&probe_success_handler, sr); - break; - - case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: - if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } - sr = NULL; - break; + GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr); + GNUNET_FS_search_result_sync_ (sr); + break; - case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: - if (NULL == sr->probe_cancel_task) - { - sr->probe_active_time = GNUNET_TIME_absolute_get(); - sr->probe_cancel_task = - GNUNET_SCHEDULER_add_delayed(sr->remaining_probe_time, - &probe_failure_handler, sr); - } - break; - - case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: - if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } - dur = GNUNET_TIME_absolute_get_duration(sr->probe_active_time); - sr->remaining_probe_time = - GNUNET_TIME_relative_subtract(sr->remaining_probe_time, dur); - if (0 == sr->remaining_probe_time.rel_value_us) - sr->probe_cancel_task = - GNUNET_SCHEDULER_add_now(&probe_failure_handler, sr); - GNUNET_FS_search_result_sync_(sr); - break; - - default: - GNUNET_break(0); - return NULL; - } + default: + GNUNET_break (0); + return NULL; + } return sr; } @@ -370,18 +364,19 @@ GNUNET_FS_search_probe_progress_(void *cls, * @param cls the `struct GNUNET_FS_SearchResult` that we are probing for */ static void -probe_ping_task_cb(void *cls) +probe_ping_task_cb (void *cls) { struct GNUNET_FS_Handle *h = cls; - struct GNUNET_FS_SearchResult *sr; - for (sr = h->probes_head; NULL != sr; sr = sr->next) + for (struct GNUNET_FS_SearchResult *sr = h->probes_head; + NULL != sr; + sr = sr->next) if (NULL != sr->probe_ctx->mq) - signal_probe_result(sr); + signal_probe_result (sr); h->probe_ping_task - = GNUNET_SCHEDULER_add_delayed(GNUNET_FS_PROBE_UPDATE_FREQUENCY, - &probe_ping_task_cb, - h); + = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY, + &probe_ping_task_cb, + h); } @@ -391,17 +386,17 @@ probe_ping_task_cb(void *cls) * @param sr result to start pinging for. */ static void -start_probe_ping_task(struct GNUNET_FS_SearchResult *sr) +start_probe_ping_task (struct GNUNET_FS_SearchResult *sr) { struct GNUNET_FS_Handle *h = sr->h; - GNUNET_CONTAINER_DLL_insert(h->probes_head, - h->probes_tail, - sr); + GNUNET_CONTAINER_DLL_insert (h->probes_head, + h->probes_tail, + sr); if (NULL == h->probe_ping_task) h->probe_ping_task - = GNUNET_SCHEDULER_add_now(&probe_ping_task_cb, - h); + = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb, + h); } @@ -411,18 +406,18 @@ start_probe_ping_task(struct GNUNET_FS_SearchResult *sr) * @param sr result to start pinging for. */ void -GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr) +GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr) { struct GNUNET_FS_Handle *h = sr->h; - GNUNET_CONTAINER_DLL_remove(h->probes_head, - h->probes_tail, - sr); + GNUNET_CONTAINER_DLL_remove (h->probes_head, + h->probes_tail, + sr); if (NULL == h->probes_head) - { - GNUNET_SCHEDULER_cancel(h->probe_ping_task); - h->probe_ping_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (h->probe_ping_task); + h->probe_ping_task = NULL; + } } @@ -432,7 +427,7 @@ GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr) * @param sr the search result */ void -GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr) +GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr) { uint64_t off; uint64_t len; @@ -445,35 +440,37 @@ GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr) return; if (sr->availability_trials > AVAILABILITY_TRIALS_MAX) return; - if ((GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type)) + if ( (GNUNET_FS_URI_CHK != sr->uri->type) && + (GNUNET_FS_URI_LOC != sr->uri->type) ) return; - len = GNUNET_FS_uri_chk_get_file_size(sr->uri); + len = GNUNET_FS_uri_chk_get_file_size (sr->uri); if (0 == len) return; if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0)) return; off = len / DBLOCK_SIZE; if (off > 0) - off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, off); + off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off); off *= DBLOCK_SIZE; if (len - off < DBLOCK_SIZE) len = len - off; else len = DBLOCK_SIZE; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Starting probe #%u (at offset %llu) for search result %p\n", - sr->availability_trials + 1, - (unsigned long long)off, - sr); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting probe #%u (at offset %llu) for search result %p\n", + sr->availability_trials + 1, + (unsigned long long) off, + sr); sr->remaining_probe_time = - GNUNET_TIME_relative_saturating_multiply(sr->h->avg_block_latency, - 2 * (1 + sr->availability_trials)); + GNUNET_TIME_relative_saturating_multiply (sr->h->avg_block_latency, + 2 * (1 + + sr->availability_trials)); sr->probe_ctx = - GNUNET_FS_download_start(sr->h, sr->uri, sr->meta, NULL, NULL, off, - len, sr->anonymity, - GNUNET_FS_DOWNLOAD_NO_TEMPORARIES | - GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL); - start_probe_ping_task(sr); + GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off, + len, sr->anonymity, + GNUNET_FS_DOWNLOAD_NO_TEMPORARIES + | GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL); + start_probe_ping_task (sr); } @@ -488,23 +485,23 @@ GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr) * @return the search result handle to access the probe activity */ struct GNUNET_FS_SearchResult * -GNUNET_FS_probe(struct GNUNET_FS_Handle *h, - const struct GNUNET_FS_Uri *uri, - const struct GNUNET_CONTAINER_MetaData *meta, - void *client_info, - uint32_t anonymity) +GNUNET_FS_probe (struct GNUNET_FS_Handle *h, + const struct GNUNET_FS_Uri *uri, + const struct GNUNET_CONTAINER_MetaData *meta, + void *client_info, + uint32_t anonymity) { struct GNUNET_FS_SearchResult *sr; - GNUNET_assert(NULL != h); - GNUNET_assert(NULL != uri); - sr = GNUNET_new(struct GNUNET_FS_SearchResult); + GNUNET_assert (NULL != h); + GNUNET_assert (NULL != uri); + sr = GNUNET_new (struct GNUNET_FS_SearchResult); sr->h = h; - sr->uri = GNUNET_FS_uri_dup(uri); - sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta); + sr->uri = GNUNET_FS_uri_dup (uri); + sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); sr->client_info = client_info; sr->anonymity = anonymity; - GNUNET_FS_search_start_probe_(sr); + GNUNET_FS_search_start_probe_ (sr); return sr; } @@ -515,19 +512,19 @@ GNUNET_FS_probe(struct GNUNET_FS_Handle *h, * @param sr search result */ static void -GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr) +GNUNET_FS_search_stop_probe_ (struct GNUNET_FS_SearchResult *sr) { if (NULL != sr->probe_ctx) - { - GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES); - sr->probe_ctx = NULL; - GNUNET_FS_stop_probe_ping_task_(sr); - } + { + GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); + sr->probe_ctx = NULL; + GNUNET_FS_stop_probe_ping_task_ (sr); + } if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } } @@ -539,16 +536,16 @@ GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr) * @return the value of the 'client_info' pointer */ void * -GNUNET_FS_probe_stop(struct GNUNET_FS_SearchResult *sr) +GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr) { void *client_info; - GNUNET_assert(NULL == sr->sc); - GNUNET_FS_search_stop_probe_(sr); - GNUNET_FS_uri_destroy(sr->uri); - GNUNET_CONTAINER_meta_data_destroy(sr->meta); + GNUNET_assert (NULL == sr->sc); + GNUNET_FS_search_stop_probe_ (sr); + GNUNET_FS_uri_destroy (sr->uri); + GNUNET_CONTAINER_meta_data_destroy (sr->meta); client_info = sr->client_info; - GNUNET_free(sr); + GNUNET_free (sr); return client_info; } @@ -564,10 +561,10 @@ GNUNET_FS_probe_stop(struct GNUNET_FS_SearchResult *sr) * under the @a ent keyword */ static void -process_ksk_result(struct GNUNET_FS_SearchContext *sc, - struct SearchRequestEntry *ent, - const struct GNUNET_FS_Uri *uri, - const struct GNUNET_CONTAINER_MetaData *meta) +process_ksk_result (struct GNUNET_FS_SearchContext *sc, + struct SearchRequestEntry *ent, + const struct GNUNET_FS_Uri *uri, + const struct GNUNET_CONTAINER_MetaData *meta) { struct GNUNET_HashCode key; struct GNUNET_FS_SearchResult *sr; @@ -576,80 +573,81 @@ process_ksk_result(struct GNUNET_FS_SearchContext *sc, unsigned int koff; /* check if new */ - GNUNET_assert(NULL != sc); + GNUNET_assert (NULL != sc); if (GNUNET_OK != - GNUNET_FS_uri_to_key(uri, - &key)) - { - GNUNET_break_op(0); - return; - } + GNUNET_FS_uri_to_key (uri, + &key)) + { + GNUNET_break_op (0); + return; + } if (GNUNET_SYSERR == - GNUNET_CONTAINER_multihashmap_get_multiple(ent->results, - &key, - &test_result_present, - (void *)uri)) + GNUNET_CONTAINER_multihashmap_get_multiple (ent->results, + &key, + &test_result_present, + (void *) uri)) return; /* duplicate result */ /* try to find search result in master map */ grc.sr = NULL; grc.uri = uri; - GNUNET_CONTAINER_multihashmap_get_multiple(sc->master_result_map, - &key, - &get_result_present, &grc); + GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, + &key, + &get_result_present, &grc); sr = grc.sr; is_new = (NULL == sr) || (sr->mandatory_missing > 0); if (NULL == sr) - { - sr = GNUNET_new(struct GNUNET_FS_SearchResult); - sr->h = sc->h; - sr->sc = sc; - sr->anonymity = sc->anonymity; - sr->uri = GNUNET_FS_uri_dup(uri); - sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta); - sr->mandatory_missing = sc->mandatory_count; - sr->key = key; - sr->keyword_bitmap = GNUNET_malloc((sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */ - GNUNET_CONTAINER_multihashmap_put(sc->master_result_map, &key, sr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - } + { + sr = GNUNET_new (struct GNUNET_FS_SearchResult); + sr->h = sc->h; + sr->sc = sc; + sr->anonymity = sc->anonymity; + sr->uri = GNUNET_FS_uri_dup (uri); + sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); + sr->mandatory_missing = sc->mandatory_count; + sr->key = key; + sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7) + / 8); /* round up, count bits */ + GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + } else - { - GNUNET_CONTAINER_meta_data_merge(sr->meta, meta); - } - GNUNET_break(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(ent->results, - &sr->key, - sr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + { + GNUNET_CONTAINER_meta_data_merge (sr->meta, meta); + } + GNUNET_break (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (ent->results, + &sr->key, + sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); koff = ent - sc->requests; - GNUNET_assert((ent >= sc->requests) && - (koff < sc->uri->data.ksk.keywordCount)); + GNUNET_assert ((ent >= sc->requests) && + (koff < sc->uri->data.ksk.keywordCount)); sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8)); /* check if mandatory satisfied */ - if (1 <= GNUNET_CONTAINER_multihashmap_size(ent->results)) + if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results)) + { + if (ent->mandatory) { - if (ent->mandatory) - { - GNUNET_break(sr->mandatory_missing > 0); - sr->mandatory_missing--; - } - else - { - sr->optional_support++; - } + GNUNET_break (sr->mandatory_missing > 0); + sr->mandatory_missing--; } - if (0 != sr->mandatory_missing) + else { - GNUNET_break(NULL == sr->client_info); - return; + sr->optional_support++; } + } + if (0 != sr->mandatory_missing) + { + GNUNET_break (NULL == sr->client_info); + return; + } if (is_new) - notify_client_chk_result(sc, sr); + notify_client_chk_result (sc, sr); else - notify_client_chk_update(sc, sr); - GNUNET_FS_search_result_sync_(sr); - GNUNET_FS_search_start_probe_(sr); + notify_client_chk_update (sc, sr); + GNUNET_FS_search_result_sync_ (sr); + GNUNET_FS_search_start_probe_ (sr); } @@ -666,12 +664,12 @@ process_ksk_result(struct GNUNET_FS_SearchContext *sc, * @return context that can be used to control the search */ static struct GNUNET_FS_SearchContext * -search_start(struct GNUNET_FS_Handle *h, - const struct GNUNET_FS_Uri *uri, - uint32_t anonymity, - enum GNUNET_FS_SearchOptions options, - void *cctx, - struct GNUNET_FS_SearchResult *psearch); +search_start (struct GNUNET_FS_Handle *h, + const struct GNUNET_FS_Uri *uri, + uint32_t anonymity, + enum GNUNET_FS_SearchOptions options, + void *cctx, + struct GNUNET_FS_SearchResult *psearch); /** @@ -684,56 +682,56 @@ search_start(struct GNUNET_FS_Handle *h, * @param meta metadata associated with the URI */ static void -process_sks_result(struct GNUNET_FS_SearchContext *sc, - const char *id_update, - const struct GNUNET_FS_Uri *uri, - const struct GNUNET_CONTAINER_MetaData *meta) +process_sks_result (struct GNUNET_FS_SearchContext *sc, + const char *id_update, + const struct GNUNET_FS_Uri *uri, + const struct GNUNET_CONTAINER_MetaData *meta) { struct GNUNET_FS_Uri uu; struct GNUNET_HashCode key; struct GNUNET_FS_SearchResult *sr; /* check if new */ - GNUNET_assert(NULL != sc); + GNUNET_assert (NULL != sc); if (GNUNET_OK != - GNUNET_FS_uri_to_key(uri, - &key)) - { - GNUNET_break(0); - return; - } - GNUNET_CRYPTO_hash_xor(&uri->data.chk.chk.key, - &uri->data.chk.chk.query, - &key); + GNUNET_FS_uri_to_key (uri, + &key)) + { + GNUNET_break (0); + return; + } + GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key, + &uri->data.chk.chk.query, + &key); if (GNUNET_SYSERR == - GNUNET_CONTAINER_multihashmap_get_multiple(sc->master_result_map, &key, - &test_result_present, - (void *)uri)) + GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key, + &test_result_present, + (void *) uri)) return; /* duplicate result */ - sr = GNUNET_new(struct GNUNET_FS_SearchResult); + sr = GNUNET_new (struct GNUNET_FS_SearchResult); sr->h = sc->h; sr->sc = sc; sr->anonymity = sc->anonymity; - sr->uri = GNUNET_FS_uri_dup(uri); - sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta); + sr->uri = GNUNET_FS_uri_dup (uri); + sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); sr->key = key; - GNUNET_CONTAINER_multihashmap_put(sc->master_result_map, &key, sr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_FS_search_result_sync_(sr); - GNUNET_FS_search_start_probe_(sr); + GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + GNUNET_FS_search_result_sync_ (sr); + GNUNET_FS_search_start_probe_ (sr); /* notify client */ if (0 == sr->mandatory_missing) - notify_client_chk_result(sc, sr); + notify_client_chk_result (sc, sr); else - GNUNET_break(NULL == sr->client_info); + GNUNET_break (NULL == sr->client_info); /* search for updates */ - if (0 == strlen(id_update)) + if (0 == strlen (id_update)) return; /* no updates */ uu.type = GNUNET_FS_URI_SKS; uu.data.sks.ns = sc->uri->data.sks.ns; - uu.data.sks.identifier = GNUNET_strdup(id_update); - (void)search_start(sc->h, &uu, sc->anonymity, sc->options, NULL, sr); - GNUNET_free(uu.data.sks.identifier); + uu.data.sks.identifier = GNUNET_strdup (id_update); + (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr); + GNUNET_free (uu.data.sks.identifier); } @@ -752,11 +750,11 @@ process_sks_result(struct GNUNET_FS_SearchContext *sc, * keyword, internal error) */ static int -decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc, - const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub, - const void *edata, - size_t edata_size, - char *data) +decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc, + const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub, + const void *edata, + size_t edata_size, + char *data) { const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon; struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub; @@ -764,23 +762,23 @@ decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc, /* find key */ for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) - if (0 == memcmp(dpub, - &sc->requests[i].dpub, - sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))) + if (0 == memcmp (dpub, + &sc->requests[i].dpub, + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))) break; if (i == sc->uri->data.ksk.keywordCount) - { - /* oops, does not match any of our keywords!? */ - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + /* oops, does not match any of our keywords!? */ + GNUNET_break (0); + return GNUNET_SYSERR; + } /* decrypt */ - anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous(); - GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub); - GNUNET_FS_ublock_decrypt_(edata, edata_size, - &anon_pub, - sc->requests[i].keyword, - data); + anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous (); + GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub); + GNUNET_FS_ublock_decrypt_ (edata, edata_size, + &anon_pub, + sc->requests[i].keyword, + data); return i; } @@ -795,9 +793,9 @@ decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc, * @param size size of @a ub */ static void -process_kblock(struct GNUNET_FS_SearchContext *sc, - const struct UBlock *ub, - size_t size) +process_kblock (struct GNUNET_FS_SearchContext *sc, + const struct UBlock *ub, + size_t size) { size_t j; char pt[size - sizeof(struct UBlock)]; @@ -807,53 +805,53 @@ process_kblock(struct GNUNET_FS_SearchContext *sc, char *emsg; int i; - if (-1 == (i = decrypt_block_with_keyword(sc, - &ub->verification_key, - &ub[1], - size - sizeof(struct UBlock), - pt))) + if (-1 == (i = decrypt_block_with_keyword (sc, + &ub->verification_key, + &ub[1], + size - sizeof(struct UBlock), + pt))) return; /* parse; pt[0] is just '\0', so we skip over that */ - eos = memchr(&pt[1], '\0', sizeof(pt) - 1); + eos = memchr (&pt[1], '\0', sizeof(pt) - 1); if (NULL == eos) + { + GNUNET_break_op (0); + return; + } + if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg))) + { + if (GNUNET_FS_VERSION > 0x00090400) { - GNUNET_break_op(0); - return; - } - if (NULL == (uri = GNUNET_FS_uri_parse(&pt[1], &emsg))) - { - if (GNUNET_FS_VERSION > 0x00090400) - { - /* we broke this in 0x00090300, so don't bitch - too loudly just one version up... */ - GNUNET_break_op(0); /* ublock malformed */ - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Failed to parse URI `%s': %s\n"), - &pt[1], - emsg); - } - GNUNET_free_non_null(emsg); - return; + /* we broke this in 0x00090300, so don't bitch + too loudly just one version up... */ + GNUNET_break_op (0); /* ublock malformed */ + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to parse URI `%s': %s\n"), + &pt[1], + emsg); } + GNUNET_free_non_null (emsg); + return; + } j = eos - pt + 1; if (sizeof(pt) == j) - meta = GNUNET_CONTAINER_meta_data_create(); + meta = GNUNET_CONTAINER_meta_data_create (); else - meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[j], sizeof(pt) - j); + meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof(pt) - j); if (NULL == meta) - { - GNUNET_break_op(0); /* ublock malformed */ - GNUNET_FS_uri_destroy(uri); - return; - } - process_ksk_result(sc, - &sc->requests[i], - uri, - meta); + { + GNUNET_break_op (0); /* ublock malformed */ + GNUNET_FS_uri_destroy (uri); + return; + } + process_ksk_result (sc, + &sc->requests[i], + uri, + meta); /* clean up */ - GNUNET_CONTAINER_meta_data_destroy(meta); - GNUNET_FS_uri_destroy(uri); + GNUNET_CONTAINER_meta_data_destroy (meta); + GNUNET_FS_uri_destroy (uri); } @@ -867,9 +865,9 @@ process_kblock(struct GNUNET_FS_SearchContext *sc, * @param size size of @a ub */ static void -process_sblock(struct GNUNET_FS_SearchContext *sc, - const struct UBlock *ub, - size_t size) +process_sblock (struct GNUNET_FS_SearchContext *sc, + const struct UBlock *ub, + size_t size) { size_t len = size - sizeof(struct UBlock); char pt[len]; @@ -880,36 +878,37 @@ process_sblock(struct GNUNET_FS_SearchContext *sc, size_t off; char *emsg; - GNUNET_FS_ublock_decrypt_(&ub[1], len, - &sc->uri->data.sks.ns, - sc->uri->data.sks.identifier, - pt); + GNUNET_FS_ublock_decrypt_ (&ub[1], len, + &sc->uri->data.sks.ns, + sc->uri->data.sks.identifier, + pt); /* parse */ - if (0 == (off = GNUNET_STRINGS_buffer_tokenize(pt, len, 2, &id, &uris))) - { - GNUNET_break_op(0); /* ublock malformed */ - return; - } - if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[off], len - off))) - { - GNUNET_break_op(0); /* ublock malformed */ - return; - } - if (NULL == (uri = GNUNET_FS_uri_parse(uris, &emsg))) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Failed to parse URI `%s': %s\n"), - uris, emsg); - GNUNET_break_op(0); /* ublock malformed */ - GNUNET_free_non_null(emsg); - GNUNET_CONTAINER_meta_data_destroy(meta); - return; - } + if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris))) + { + GNUNET_break_op (0); /* ublock malformed */ + return; + } + if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len + - off))) + { + GNUNET_break_op (0); /* ublock malformed */ + return; + } + if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg))) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to parse URI `%s': %s\n"), + uris, emsg); + GNUNET_break_op (0); /* ublock malformed */ + GNUNET_free_non_null (emsg); + GNUNET_CONTAINER_meta_data_destroy (meta); + return; + } /* process */ - process_sks_result(sc, id, uri, meta); + process_sks_result (sc, id, uri, meta); /* clean up */ - GNUNET_FS_uri_destroy(uri); - GNUNET_CONTAINER_meta_data_destroy(meta); + GNUNET_FS_uri_destroy (uri); + GNUNET_CONTAINER_meta_data_destroy (meta); } @@ -921,7 +920,7 @@ process_sblock(struct GNUNET_FS_SearchContext *sc, * @param sc the search to reconnec */ static void -try_reconnect(struct GNUNET_FS_SearchContext *sc); +try_reconnect (struct GNUNET_FS_SearchContext *sc); /** @@ -931,8 +930,8 @@ try_reconnect(struct GNUNET_FS_SearchContext *sc); * @param msg result message received */ static int -check_result(void *cls, - const struct ClientPutMessage *cm) +check_result (void *cls, + const struct ClientPutMessage *cm) { /* payload of any variable size is OK */ return GNUNET_OK; @@ -946,54 +945,55 @@ check_result(void *cls, * @param msg result message received */ static void -handle_result(void *cls, - const struct ClientPutMessage *cm) +handle_result (void *cls, + const struct ClientPutMessage *cm) { struct GNUNET_FS_SearchContext *sc = cls; - uint16_t msize = ntohs(cm->header.size) - sizeof(*cm); - enum GNUNET_BLOCK_Type type = ntohl(cm->type); - - if (GNUNET_TIME_absolute_get_duration(GNUNET_TIME_absolute_ntoh(cm->expiration)).rel_value_us > 0) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Result received has already expired.\n"); - return; /* result expired */ - } + uint16_t msize = ntohs (cm->header.size) - sizeof(*cm); + enum GNUNET_BLOCK_Type type = ntohl (cm->type); + + if (GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh ( + cm->expiration)).rel_value_us > 0) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Result received has already expired.\n"); + return; /* result expired */ + } switch (type) - { - case GNUNET_BLOCK_TYPE_FS_UBLOCK: - if (GNUNET_FS_URI_SKS == sc->uri->type) - process_sblock(sc, - (const struct UBlock *)&cm[1], - msize); - else - process_kblock(sc, - (const struct UBlock *)&cm[1], - msize); - break; - - case GNUNET_BLOCK_TYPE_ANY: - GNUNET_break(0); - break; - - case GNUNET_BLOCK_TYPE_FS_DBLOCK: - GNUNET_break(0); - break; - - case GNUNET_BLOCK_TYPE_FS_ONDEMAND: - GNUNET_break(0); - break; - - case GNUNET_BLOCK_TYPE_FS_IBLOCK: - GNUNET_break(0); - break; - - default: - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Got result with unknown block type `%d', ignoring"), - type); - break; - } + { + case GNUNET_BLOCK_TYPE_FS_UBLOCK: + if (GNUNET_FS_URI_SKS == sc->uri->type) + process_sblock (sc, + (const struct UBlock *) &cm[1], + msize); + else + process_kblock (sc, + (const struct UBlock *) &cm[1], + msize); + break; + + case GNUNET_BLOCK_TYPE_ANY: + GNUNET_break (0); + break; + + case GNUNET_BLOCK_TYPE_FS_DBLOCK: + GNUNET_break (0); + break; + + case GNUNET_BLOCK_TYPE_FS_ONDEMAND: + GNUNET_break (0); + break; + + case GNUNET_BLOCK_TYPE_FS_IBLOCK: + GNUNET_break (0); + break; + + default: + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Got result with unknown block type `%d', ignoring"), + type); + break; + } } @@ -1004,13 +1004,14 @@ handle_result(void *cls, * @param sc context for the search */ static void -schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc); +schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc); /** * Closure for #build_result_set(). */ -struct MessageBuilderContext { +struct MessageBuilderContext +{ /** * How many entries can we store to xoff. */ @@ -1048,21 +1049,24 @@ struct MessageBuilderContext { * @return #GNUNET_OK to continue iterating */ static int -build_result_set(void *cls, - const struct GNUNET_HashCode *key, - void *value) +build_result_set (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct MessageBuilderContext *mbc = cls; struct GNUNET_FS_SearchResult *sr = value; if ((NULL != sr->keyword_bitmap) && - (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8))))) + (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 + << (mbc-> + keyword_offset + % 8))))) return GNUNET_OK; /* have no match for this keyword yet */ if (mbc->skip_cnt > 0) - { - mbc->skip_cnt--; - return GNUNET_OK; - } + { + mbc->skip_cnt--; + return GNUNET_OK; + } if (0 == mbc->put_cnt) return GNUNET_SYSERR; mbc->xoff[--mbc->put_cnt] = *key; @@ -1081,15 +1085,18 @@ build_result_set(void *cls, * @return #GNUNET_OK to continue iterating */ static int -find_result_set(void *cls, - const struct GNUNET_HashCode *key, - void *value) +find_result_set (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct MessageBuilderContext *mbc = cls; struct GNUNET_FS_SearchResult *sr = value; if ((NULL != sr->keyword_bitmap) && - (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8))))) + (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 + << (mbc-> + keyword_offset + % 8))))) return GNUNET_OK; /* have no match for this keyword yet */ mbc->put_cnt++; return GNUNET_OK; @@ -1103,7 +1110,7 @@ find_result_set(void *cls, * @param sc context for the search */ static void -schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc) +schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc) { struct MessageBuilderContext mbc; struct GNUNET_MQ_Envelope *env; @@ -1118,115 +1125,116 @@ schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc) unsigned int keyword_offset; int first_call; - memset(&mbc, 0, sizeof(mbc)); + memset (&mbc, 0, sizeof(mbc)); mbc.sc = sc; - if (GNUNET_FS_uri_test_ksk(sc->uri)) - { - /* This will calculate the result set size ONLY for - "keyword_offset == 0", so we will have to recalculate - it for the other keywords later! */ - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &find_result_set, - &mbc); - total_seen_results = mbc.put_cnt; - } + if (GNUNET_FS_uri_test_ksk (sc->uri)) + { + /* This will calculate the result set size ONLY for + "keyword_offset == 0", so we will have to recalculate + it for the other keywords later! */ + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &find_result_set, + &mbc); + total_seen_results = mbc.put_cnt; + } else - { - total_seen_results - = GNUNET_CONTAINER_multihashmap_size(sc->master_result_map); - } + { + total_seen_results + = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map); + } search_request_map_offset = 0; keyword_offset = 0; first_call = GNUNET_YES; while ((0 != (left = (total_seen_results - search_request_map_offset))) || (GNUNET_YES == first_call)) + { + first_call = GNUNET_NO; + options = SEARCH_MESSAGE_OPTION_NONE; + if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY)) + options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY; + + fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct + GNUNET_HashCode); + todo = GNUNET_MIN (fit, + left); + env = GNUNET_MQ_msg_extra (sm, + sizeof(struct GNUNET_HashCode) * todo, + GNUNET_MESSAGE_TYPE_FS_START_SEARCH); + mbc.skip_cnt = search_request_map_offset; + mbc.xoff = (struct GNUNET_HashCode *) &sm[1]; + sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK); + sm->anonymity_level = htonl (sc->anonymity); + memset (&sm->target, + 0, + sizeof(struct GNUNET_PeerIdentity)); + + if (GNUNET_FS_uri_test_ksk (sc->uri)) { - first_call = GNUNET_NO; - options = SEARCH_MESSAGE_OPTION_NONE; - if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY)) - options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY; - - fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct GNUNET_HashCode); - todo = GNUNET_MIN(fit, - left); - env = GNUNET_MQ_msg_extra(sm, - sizeof(struct GNUNET_HashCode) * todo, - GNUNET_MESSAGE_TYPE_FS_START_SEARCH); - mbc.skip_cnt = search_request_map_offset; - mbc.xoff = (struct GNUNET_HashCode *)&sm[1]; - sm->type = htonl(GNUNET_BLOCK_TYPE_FS_UBLOCK); - sm->anonymity_level = htonl(sc->anonymity); - memset(&sm->target, - 0, - sizeof(struct GNUNET_PeerIdentity)); - - if (GNUNET_FS_uri_test_ksk(sc->uri)) + mbc.keyword_offset = keyword_offset; + /* calculate how many results we can send in this message */ + mbc.put_cnt = todo; + /* now build message */ + sm->query = sc->requests[keyword_offset].uquery; + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &build_result_set, + &mbc); + search_request_map_offset += todo; + GNUNET_assert (0 == mbc.put_cnt); + GNUNET_assert (total_seen_results >= search_request_map_offset); + if (total_seen_results != search_request_map_offset) + { + /* more requesting to be done... */ + sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED); + } + else + { + sm->options = htonl (options); + keyword_offset++; + if (sc->uri->data.ksk.keywordCount != keyword_offset) { + /* more keywords => more requesting to be done... */ + first_call = GNUNET_YES; + search_request_map_offset = 0; + mbc.put_cnt = 0; mbc.keyword_offset = keyword_offset; - /* calculate how many results we can send in this message */ - mbc.put_cnt = todo; - /* now build message */ - sm->query = sc->requests[keyword_offset].uquery; - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &build_result_set, - &mbc); - search_request_map_offset += todo; - GNUNET_assert(0 == mbc.put_cnt); - GNUNET_assert(total_seen_results >= search_request_map_offset); - if (total_seen_results != search_request_map_offset) - { - /* more requesting to be done... */ - sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED); - } - else - { - sm->options = htonl(options); - keyword_offset++; - if (sc->uri->data.ksk.keywordCount != keyword_offset) - { - /* more keywords => more requesting to be done... */ - first_call = GNUNET_YES; - search_request_map_offset = 0; - mbc.put_cnt = 0; - mbc.keyword_offset = keyword_offset; - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &find_result_set, - &mbc); - total_seen_results = mbc.put_cnt; - } - } + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &find_result_set, + &mbc); + total_seen_results = mbc.put_cnt; } + } + } + else + { + GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri)); + + GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns, + sc->uri->data.sks.identifier, + "fs-ublock", + &dpub); + GNUNET_CRYPTO_hash (&dpub, + sizeof(dpub), + &sm->query); + mbc.put_cnt = todo; + mbc.keyword_offset = 0; + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &build_result_set, + &mbc); + GNUNET_assert (total_seen_results >= search_request_map_offset); + if (total_seen_results != search_request_map_offset) + { + /* more requesting to be done... */ + sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED); + } else - { - GNUNET_assert(GNUNET_FS_uri_test_sks(sc->uri)); - - GNUNET_CRYPTO_ecdsa_public_key_derive(&sc->uri->data.sks.ns, - sc->uri->data.sks.identifier, - "fs-ublock", - &dpub); - GNUNET_CRYPTO_hash(&dpub, - sizeof(dpub), - &sm->query); - mbc.put_cnt = todo; - mbc.keyword_offset = 0; - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &build_result_set, - &mbc); - GNUNET_assert(total_seen_results >= search_request_map_offset); - if (total_seen_results != search_request_map_offset) - { - /* more requesting to be done... */ - sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED); - } - else - { - sm->options = htonl(options); - } - } - GNUNET_MQ_send(sc->mq, - env); + { + sm->options = htonl (options); + } } + GNUNET_MQ_send (sc->mq, + env); + } } @@ -1239,17 +1247,17 @@ schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc) * @param error error code */ static void -search_mq_error_handler(void *cls, - enum GNUNET_MQ_Error error) +search_mq_error_handler (void *cls, + enum GNUNET_MQ_Error error) { struct GNUNET_FS_SearchContext *sc = cls; if (NULL != sc->mq) - { - GNUNET_MQ_destroy(sc->mq); - sc->mq = NULL; - } - try_reconnect(sc); + { + GNUNET_MQ_destroy (sc->mq); + sc->mq = NULL; + } + try_reconnect (sc); } @@ -1260,29 +1268,29 @@ search_mq_error_handler(void *cls, * @param cls our search context */ static void -do_reconnect(void *cls) +do_reconnect (void *cls) { struct GNUNET_FS_SearchContext *sc = cls; struct GNUNET_MQ_MessageHandler handlers[] = { - GNUNET_MQ_hd_var_size(result, - GNUNET_MESSAGE_TYPE_FS_PUT, - struct ClientPutMessage, - sc), - GNUNET_MQ_handler_end() + GNUNET_MQ_hd_var_size (result, + GNUNET_MESSAGE_TYPE_FS_PUT, + struct ClientPutMessage, + sc), + GNUNET_MQ_handler_end () }; sc->task = NULL; - sc->mq = GNUNET_CLIENT_connect(sc->h->cfg, - "fs", - handlers, - &search_mq_error_handler, - sc); + sc->mq = GNUNET_CLIENT_connect (sc->h->cfg, + "fs", + handlers, + &search_mq_error_handler, + sc); if (NULL == sc->mq) - { - try_reconnect(sc); - return; - } - schedule_transmit_search_request(sc); + { + try_reconnect (sc); + return; + } + schedule_transmit_search_request (sc); } @@ -1294,18 +1302,18 @@ do_reconnect(void *cls) * @param sc the search to reconnec */ static void -try_reconnect(struct GNUNET_FS_SearchContext *sc) +try_reconnect (struct GNUNET_FS_SearchContext *sc) { if (NULL != sc->mq) - { - GNUNET_MQ_destroy(sc->mq); - sc->mq = NULL; - } - sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF(sc->reconnect_backoff); + { + GNUNET_MQ_destroy (sc->mq); + sc->mq = NULL; + } + sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff); sc->task = - GNUNET_SCHEDULER_add_delayed(sc->reconnect_backoff, - &do_reconnect, - sc); + GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff, + &do_reconnect, + sc); } @@ -1322,39 +1330,39 @@ try_reconnect(struct GNUNET_FS_SearchContext *sc) * @return context that can be used to control the search */ static struct GNUNET_FS_SearchContext * -search_start(struct GNUNET_FS_Handle *h, - const struct GNUNET_FS_Uri *uri, - uint32_t anonymity, - enum GNUNET_FS_SearchOptions options, - void *cctx, - struct GNUNET_FS_SearchResult *psearch) +search_start (struct GNUNET_FS_Handle *h, + const struct GNUNET_FS_Uri *uri, + uint32_t anonymity, + enum GNUNET_FS_SearchOptions options, + void *cctx, + struct GNUNET_FS_SearchResult *psearch) { struct GNUNET_FS_SearchContext *sc; struct GNUNET_FS_ProgressInfo pi; - sc = GNUNET_new(struct GNUNET_FS_SearchContext); + sc = GNUNET_new (struct GNUNET_FS_SearchContext); sc->h = h; sc->options = options; - sc->uri = GNUNET_FS_uri_dup(uri); + sc->uri = GNUNET_FS_uri_dup (uri); sc->anonymity = anonymity; - sc->start_time = GNUNET_TIME_absolute_get(); + sc->start_time = GNUNET_TIME_absolute_get (); if (NULL != psearch) - { - sc->psearch_result = psearch; - psearch->update_search = sc; - } - sc->master_result_map = GNUNET_CONTAINER_multihashmap_create(16, GNUNET_NO); + { + sc->psearch_result = psearch; + psearch->update_search = sc; + } + sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO); sc->client_info = cctx; - if (GNUNET_OK != GNUNET_FS_search_start_searching_(sc)) - { - GNUNET_FS_uri_destroy(sc->uri); - GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map); - GNUNET_free(sc); - return NULL; - } - GNUNET_FS_search_sync_(sc); + if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc)) + { + GNUNET_FS_uri_destroy (sc->uri); + GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); + GNUNET_free (sc); + return NULL; + } + GNUNET_FS_search_sync_ (sc); pi.status = GNUNET_FS_STATUS_SEARCH_START; - sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); + sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); return sc; } @@ -1369,22 +1377,22 @@ search_start(struct GNUNET_FS_Handle *h, * @return #GNUNET_YES (we should continue to iterate) */ static int -update_sre_result_maps(void *cls, - const struct GNUNET_HashCode *key, - void *value) +update_sre_result_maps (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchContext *sc = cls; struct GNUNET_FS_SearchResult *sr = value; - unsigned int i; - for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) + for (unsigned int i = 0; i < sc->uri->data.ksk.keywordCount; i++) + { if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8)))) - GNUNET_break(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(sc->requests[i].results, - &sr->key, - sr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); - + GNUNET_break (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results, + &sr->key, + sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + } return GNUNET_YES; } @@ -1397,7 +1405,7 @@ update_sre_result_maps(void *cls, * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc) +GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc) { unsigned int i; const char *keyword; @@ -1405,45 +1413,45 @@ GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc) struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub; struct SearchRequestEntry *sre; - GNUNET_assert(NULL == sc->mq); - if (GNUNET_FS_uri_test_ksk(sc->uri)) + GNUNET_assert (NULL == sc->mq); + if (GNUNET_FS_uri_test_ksk (sc->uri)) + { + GNUNET_assert (0 != sc->uri->data.ksk.keywordCount); + anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous (); + GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub); + sc->requests + = GNUNET_new_array (sc->uri->data.ksk.keywordCount, + struct SearchRequestEntry); + + for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) { - GNUNET_assert(0 != sc->uri->data.ksk.keywordCount); - anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous(); - GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub); - sc->requests - = GNUNET_new_array(sc->uri->data.ksk.keywordCount, - struct SearchRequestEntry); - - for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) - { - keyword = &sc->uri->data.ksk.keywords[i][1]; - sre = &sc->requests[i]; - sre->keyword = GNUNET_strdup(keyword); - GNUNET_CRYPTO_ecdsa_public_key_derive(&anon_pub, - keyword, - "fs-ublock", - &sre->dpub); - GNUNET_CRYPTO_hash(&sre->dpub, - sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey), - &sre->uquery); - sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+'); - if (sre->mandatory) - sc->mandatory_count++; - sre->results = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO); - } - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &update_sre_result_maps, - sc); + keyword = &sc->uri->data.ksk.keywords[i][1]; + sre = &sc->requests[i]; + sre->keyword = GNUNET_strdup (keyword); + GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub, + keyword, + "fs-ublock", + &sre->dpub); + GNUNET_CRYPTO_hash (&sre->dpub, + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey), + &sre->uquery); + sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+'); + if (sre->mandatory) + sc->mandatory_count++; + sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO); } - GNUNET_assert(NULL == sc->task); - do_reconnect(sc); + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &update_sre_result_maps, + sc); + } + GNUNET_assert (NULL == sc->task); + do_reconnect (sc); if (NULL == sc->mq) - { - GNUNET_SCHEDULER_cancel(sc->task); - sc->task = NULL; - return GNUNET_SYSERR; - } + { + GNUNET_SCHEDULER_cancel (sc->task); + sc->task = NULL; + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -1457,25 +1465,25 @@ GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc) * @return #GNUNET_OK */ static int -search_result_freeze_probes(void *cls, - const struct GNUNET_HashCode *key, - void *value) +search_result_freeze_probes (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchResult *sr = value; if (NULL != sr->probe_ctx) - { - GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES); - sr->probe_ctx = NULL; - GNUNET_FS_stop_probe_ping_task_(sr); - } + { + GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); + sr->probe_ctx = NULL; + GNUNET_FS_stop_probe_ping_task_ (sr); + } if (NULL != sr->probe_cancel_task) - { - GNUNET_SCHEDULER_cancel(sr->probe_cancel_task); - sr->probe_cancel_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); + sr->probe_cancel_task = NULL; + } if (NULL != sr->update_search) - GNUNET_FS_search_pause(sr->update_search); + GNUNET_FS_search_pause (sr->update_search); return GNUNET_OK; } @@ -1489,15 +1497,15 @@ search_result_freeze_probes(void *cls, * @return #GNUNET_OK */ static int -search_result_resume_probes(void *cls, - const struct GNUNET_HashCode * key, - void *value) +search_result_resume_probes (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchResult *sr = value; - GNUNET_FS_search_start_probe_(sr); + GNUNET_FS_search_start_probe_ (sr); if (NULL != sr->update_search) - GNUNET_FS_search_continue(sr->update_search); + GNUNET_FS_search_continue (sr->update_search); return GNUNET_OK; } @@ -1511,40 +1519,40 @@ search_result_resume_probes(void *cls, * @return #GNUNET_OK */ static int -search_result_suspend(void *cls, - const struct GNUNET_HashCode *key, - void *value) +search_result_suspend (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchContext *sc = cls; struct GNUNET_FS_SearchResult *sr = value; struct GNUNET_FS_ProgressInfo pi; if (NULL != sr->download) - { - GNUNET_FS_download_signal_suspend_(sr->download); - sr->download = NULL; - } + { + GNUNET_FS_download_signal_suspend_ (sr->download); + sr->download = NULL; + } if (NULL != sr->update_search) - { - GNUNET_FS_search_signal_suspend_(sr->update_search); - sr->update_search = NULL; - } - GNUNET_FS_search_stop_probe_(sr); + { + GNUNET_FS_search_signal_suspend_ (sr->update_search); + sr->update_search = NULL; + } + GNUNET_FS_search_stop_probe_ (sr); if (0 == sr->mandatory_missing) - { - /* client is aware of search result, notify about suspension event */ - pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND; - pi.value.search.specifics.result_suspend.cctx = sr->client_info; - pi.value.search.specifics.result_suspend.meta = sr->meta; - pi.value.search.specifics.result_suspend.uri = sr->uri; - sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); - } - GNUNET_break(NULL == sr->client_info); - GNUNET_free_non_null(sr->serialization); - GNUNET_FS_uri_destroy(sr->uri); - GNUNET_CONTAINER_meta_data_destroy(sr->meta); - GNUNET_free_non_null(sr->keyword_bitmap); - GNUNET_free(sr); + { + /* client is aware of search result, notify about suspension event */ + pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND; + pi.value.search.specifics.result_suspend.cctx = sr->client_info; + pi.value.search.specifics.result_suspend.meta = sr->meta; + pi.value.search.specifics.result_suspend.uri = sr->uri; + sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); + } + GNUNET_break (NULL == sr->client_info); + GNUNET_free_non_null (sr->serialization); + GNUNET_FS_uri_destroy (sr->uri); + GNUNET_CONTAINER_meta_data_destroy (sr->meta); + GNUNET_free_non_null (sr->keyword_bitmap); + GNUNET_free (sr); return GNUNET_OK; } @@ -1556,43 +1564,43 @@ search_result_suspend(void *cls, * @param cls the `struct GNUNET_FS_SearchContext` to signal for */ void -GNUNET_FS_search_signal_suspend_(void *cls) +GNUNET_FS_search_signal_suspend_ (void *cls) { struct GNUNET_FS_SearchContext *sc = cls; struct GNUNET_FS_ProgressInfo pi; unsigned int i; - GNUNET_FS_end_top(sc->h, sc->top); - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &search_result_suspend, sc); + GNUNET_FS_end_top (sc->h, sc->top); + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_suspend, sc); pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND; - sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); - GNUNET_break(NULL == sc->client_info); + sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); + GNUNET_break (NULL == sc->client_info); if (sc->task != NULL) - { - GNUNET_SCHEDULER_cancel(sc->task); - sc->task = NULL; - } + { + GNUNET_SCHEDULER_cancel (sc->task); + sc->task = NULL; + } if (NULL != sc->mq) - { - GNUNET_MQ_destroy(sc->mq); - sc->mq = NULL; - } - GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map); + { + GNUNET_MQ_destroy (sc->mq); + sc->mq = NULL; + } + GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); if (NULL != sc->requests) + { + GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); + for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) { - GNUNET_assert(GNUNET_FS_uri_test_ksk(sc->uri)); - for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) - { - GNUNET_CONTAINER_multihashmap_destroy(sc->requests[i].results); - GNUNET_free(sc->requests[i].keyword); - } + GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results); + GNUNET_free (sc->requests[i].keyword); } - GNUNET_free_non_null(sc->requests); - GNUNET_free_non_null(sc->emsg); - GNUNET_FS_uri_destroy(sc->uri); - GNUNET_free_non_null(sc->serialization); - GNUNET_free(sc); + } + GNUNET_free_non_null (sc->requests); + GNUNET_free_non_null (sc->emsg); + GNUNET_FS_uri_destroy (sc->uri); + GNUNET_free_non_null (sc->serialization); + GNUNET_free (sc); } @@ -1608,16 +1616,16 @@ GNUNET_FS_search_signal_suspend_(void *cls) * @return context that can be used to control the search */ struct GNUNET_FS_SearchContext * -GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, - const struct GNUNET_FS_Uri *uri, uint32_t anonymity, - enum GNUNET_FS_SearchOptions options, void *cctx) +GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, + const struct GNUNET_FS_Uri *uri, uint32_t anonymity, + enum GNUNET_FS_SearchOptions options, void *cctx) { struct GNUNET_FS_SearchContext *ret; - ret = search_start(h, uri, anonymity, options, cctx, NULL); + ret = search_start (h, uri, anonymity, options, cctx, NULL); if (NULL == ret) return NULL; - ret->top = GNUNET_FS_make_top(h, &GNUNET_FS_search_signal_suspend_, ret); + ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret); return ret; } @@ -1628,28 +1636,28 @@ GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, * @param sc context for the search that should be paused */ void -GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc) +GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc) { struct GNUNET_FS_ProgressInfo pi; if (NULL != sc->task) - { - GNUNET_SCHEDULER_cancel(sc->task); - sc->task = NULL; - } + { + GNUNET_SCHEDULER_cancel (sc->task); + sc->task = NULL; + } if (NULL != sc->mq) - { - GNUNET_MQ_destroy(sc->mq); - sc->mq = NULL; - } - GNUNET_FS_search_sync_(sc); - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &search_result_freeze_probes, - sc); + { + GNUNET_MQ_destroy (sc->mq); + sc->mq = NULL; + } + GNUNET_FS_search_sync_ (sc); + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_freeze_probes, + sc); pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED; - sc->client_info = GNUNET_FS_search_make_status_(&pi, - sc->h, - sc); + sc->client_info = GNUNET_FS_search_make_status_ (&pi, + sc->h, + sc); } @@ -1659,18 +1667,18 @@ GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc) * @param sc context for the search that should be resumed */ void -GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc) +GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc) { struct GNUNET_FS_ProgressInfo pi; - GNUNET_assert(NULL == sc->mq); - GNUNET_assert(NULL == sc->task); - do_reconnect(sc); - GNUNET_FS_search_sync_(sc); + GNUNET_assert (NULL == sc->mq); + GNUNET_assert (NULL == sc->task); + do_reconnect (sc); + GNUNET_FS_search_sync_ (sc); pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED; - sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc); - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &search_result_resume_probes, sc); + sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc); + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_resume_probes, sc); } @@ -1683,48 +1691,48 @@ GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc) * @return #GNUNET_OK */ static int -search_result_stop(void *cls, - const struct GNUNET_HashCode *key, - void *value) +search_result_stop (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchContext *sc = cls; struct GNUNET_FS_SearchResult *sr = value; struct GNUNET_FS_ProgressInfo pi; - GNUNET_FS_search_stop_probe_(sr); + GNUNET_FS_search_stop_probe_ (sr); if (NULL != sr->download) + { + sr->download->search = NULL; + sr->download->top + = GNUNET_FS_make_top (sr->download->h, + &GNUNET_FS_download_signal_suspend_, + sr->download); + if (NULL != sr->download->serialization) { - sr->download->search = NULL; - sr->download->top - = GNUNET_FS_make_top(sr->download->h, - &GNUNET_FS_download_signal_suspend_, - sr->download); - if (NULL != sr->download->serialization) - { - GNUNET_FS_remove_sync_file_(sc->h, - GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, - sr->download->serialization); - GNUNET_free(sr->download->serialization); - sr->download->serialization = NULL; - } - pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT; - GNUNET_FS_download_make_status_(&pi, - sr->download); - GNUNET_FS_download_sync_(sr->download); - sr->download = NULL; + GNUNET_FS_remove_sync_file_ (sc->h, + GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, + sr->download->serialization); + GNUNET_free (sr->download->serialization); + sr->download->serialization = NULL; } + pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT; + GNUNET_FS_download_make_status_ (&pi, + sr->download); + GNUNET_FS_download_sync_ (sr->download); + sr->download = NULL; + } if (0 != sr->mandatory_missing) - { - /* client is unaware of search result as - it does not match required keywords */ - GNUNET_break(NULL == sr->client_info); - return GNUNET_OK; - } + { + /* client is unaware of search result as + it does not match required keywords */ + GNUNET_break (NULL == sr->client_info); + return GNUNET_OK; + } pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED; pi.value.search.specifics.result_stopped.cctx = sr->client_info; pi.value.search.specifics.result_stopped.meta = sr->meta; pi.value.search.specifics.result_stopped.uri = sr->uri; - sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sc); + sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc); return GNUNET_OK; } @@ -1738,25 +1746,25 @@ search_result_stop(void *cls, * @return #GNUNET_OK */ static int -search_result_free(void *cls, - const struct GNUNET_HashCode *key, - void *value) +search_result_free (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_FS_SearchResult *sr = value; if (NULL != sr->update_search) - { - GNUNET_FS_search_stop(sr->update_search); - GNUNET_assert(NULL == sr->update_search); - } - GNUNET_break(NULL == sr->probe_ctx); - GNUNET_break(NULL == sr->probe_cancel_task); - GNUNET_break(NULL == sr->client_info); - GNUNET_free_non_null(sr->serialization); - GNUNET_FS_uri_destroy(sr->uri); - GNUNET_CONTAINER_meta_data_destroy(sr->meta); - GNUNET_free_non_null(sr->keyword_bitmap); - GNUNET_free(sr); + { + GNUNET_FS_search_stop (sr->update_search); + GNUNET_assert (NULL == sr->update_search); + } + GNUNET_break (NULL == sr->probe_ctx); + GNUNET_break (NULL == sr->probe_cancel_task); + GNUNET_break (NULL == sr->client_info); + GNUNET_free_non_null (sr->serialization); + GNUNET_FS_uri_destroy (sr->uri); + GNUNET_CONTAINER_meta_data_destroy (sr->meta); + GNUNET_free_non_null (sr->keyword_bitmap); + GNUNET_free (sr); return GNUNET_OK; } @@ -1767,60 +1775,60 @@ search_result_free(void *cls, * @param sc context for the search that should be stopped */ void -GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc) +GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc) { struct GNUNET_FS_ProgressInfo pi; unsigned int i; if (NULL != sc->top) - GNUNET_FS_end_top(sc->h, sc->top); - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &search_result_stop, - sc); + GNUNET_FS_end_top (sc->h, sc->top); + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_stop, + sc); if (NULL != sc->psearch_result) sc->psearch_result->update_search = NULL; if (NULL != sc->serialization) - { - GNUNET_FS_remove_sync_file_(sc->h, - (NULL != sc->psearch_result) - ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH - : GNUNET_FS_SYNC_PATH_MASTER_SEARCH, - sc->serialization); - GNUNET_FS_remove_sync_dir_(sc->h, + { + GNUNET_FS_remove_sync_file_ (sc->h, (NULL != sc->psearch_result) ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH : GNUNET_FS_SYNC_PATH_MASTER_SEARCH, sc->serialization); - GNUNET_free(sc->serialization); - } + GNUNET_FS_remove_sync_dir_ (sc->h, + (NULL != sc->psearch_result) + ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH + : GNUNET_FS_SYNC_PATH_MASTER_SEARCH, + sc->serialization); + GNUNET_free (sc->serialization); + } pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED; - sc->client_info = GNUNET_FS_search_make_status_(&pi, - sc->h, - sc); - GNUNET_break(NULL == sc->client_info); + sc->client_info = GNUNET_FS_search_make_status_ (&pi, + sc->h, + sc); + GNUNET_break (NULL == sc->client_info); if (NULL != sc->task) - { - GNUNET_SCHEDULER_cancel(sc->task); - sc->task = NULL; - } + { + GNUNET_SCHEDULER_cancel (sc->task); + sc->task = NULL; + } if (NULL != sc->mq) - { - GNUNET_MQ_destroy(sc->mq); - sc->mq = NULL; - } - GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map, - &search_result_free, sc); - GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map); + { + GNUNET_MQ_destroy (sc->mq); + sc->mq = NULL; + } + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_free, sc); + GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); if (NULL != sc->requests) - { - GNUNET_assert(GNUNET_FS_uri_test_ksk(sc->uri)); - for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) - GNUNET_CONTAINER_multihashmap_destroy(sc->requests[i].results); - } - GNUNET_free_non_null(sc->requests); - GNUNET_free_non_null(sc->emsg); - GNUNET_FS_uri_destroy(sc->uri); - GNUNET_free(sc); + { + GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); + for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) + GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results); + } + GNUNET_free_non_null (sc->requests); + GNUNET_free_non_null (sc->emsg); + GNUNET_FS_uri_destroy (sc->uri); + GNUNET_free (sc); } /* end of fs_search.c */ -- cgit v1.2.3