From 32e19a47f4e6bd369e99e3d292be7b01c009edac Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Sep 2009 13:19:01 +0000 Subject: [PATCH] seach --- TODO | 14 +- src/fs/fs.h | 120 +++++++- src/fs/fs_search.c | 449 ++++++++++++++++++++++++++--- src/include/gnunet_container_lib.h | 7 +- src/include/gnunet_fs_service.h | 41 +-- src/util/container_multihashmap.c | 2 +- 6 files changed, 549 insertions(+), 84 deletions(-) diff --git a/TODO b/TODO index 209a0c9f3..ac8cf0802 100644 --- a/TODO +++ b/TODO @@ -18,7 +18,7 @@ PHASE #2: (Goal: recover basic file-sharing functionality) - implement library for local testing + modify configuration to allow controlling connections for non-local starts - + CORE service does not start with valid peer ID (all zeross) + + CORE service does not start with valid peer ID (all zeros) -- testcase fails! + consider changing API for peer-group termination to call continuation when done @@ -37,14 +37,17 @@ PHASE #2: (Goal: recover basic file-sharing functionality) - implement testcases * FS (basic anonymous FS only) - implement basic FS library - - keyword-search - - download (need search to be done) + - download API + - gnunet-search (binary) + - gnunet-unindex (binary) + - gnunet-download (binary) + - API FIX: change type for anonymity/priority from unsigned int to uint32_t! - design network structs (P2P) + query + response - implement FS service + datastore request queueing mechanism - + CS-functions (search, download, index, get_indexed, unindex) + + CS-functions (search/download, index, get_indexed, unindex) + P2P-functions (query, response) - implement testcases + URI API @@ -74,8 +77,7 @@ PHASE #3: (Goal: ready for pre-release) [completion-goal: end of 2009] - advanced FS API parts + namespaces ~ fundamental namespace API - ~ SBlock search - ~ KSBlocks!? + + search: SBlocks, KSBlocks, probes + collection + location URIs (publish, search, download) + persistence support (publish, unindex, search, download) diff --git a/src/fs/fs.h b/src/fs/fs.h index 6e793bf8d..ed925d9c8 100644 --- a/src/fs/fs.h +++ b/src/fs/fs.h @@ -382,6 +382,12 @@ struct GNUNET_FS_Handle */ struct GNUNET_CLIENT_Connection *client; + /** + * How many downloads probing availability + * of search results do we have running + * right now? + */ + unsigned int active_probes; }; @@ -582,6 +588,72 @@ struct GNUNET_FS_UnindexContext }; +/** + * Information we store for each search result. + */ +struct SearchResult +{ + + /** + * URI to which this search result + * refers to. + */ + struct GNUNET_FS_Uri *uri; + + /** + * Metadata for the search result. + */ + struct GNUNET_CONTAINER_MetaData *meta; + + /** + * Client info for this search result. + */ + void *client_info; + + /** + * ID of a job that is currently probing + * this results' availability (NULL if we + * are not currently probing). + */ + struct GNUNET_FS_DownloadContext *probe_ctx; + + /** + * ID of the task that will clean up the probe_ctx + * should it not complete on time (and that will + * need to be cancelled if we clean up the search + * result before then). + */ + GNUNET_SCHEDULER_TaskIdentifier probe_cancel_task; + + /** + * Number of mandatory keywords for which + * we have NOT yet found the search result; + * when this value hits zero, the search + * result is given to the callback. + */ + uint32_t mandatory_missing; + + /** + * Number of optional keywords under which + * this result was also found. + */ + uint32_t optional_support; + + /** + * Number of availability tests that + * have succeeded for this result. + */ + uint32_t availability_success; + + /** + * Number of availability trials that we + * have performed for this search result. + */ + uint32_t availability_trials; + +}; + + /** * Information we keep for each keyword in * a keyword search. @@ -597,7 +669,24 @@ struct SearchRequestEntry /** * Hash of the public key, also known as the query. */ - GNUNET_HashCode query; + GNUNET_HashCode query; + + /** + * Map that contains a "struct SearchResult" for each result that + * was found under this keyword. Note that the entries will point + * to the same locations as those in the master result map (in + * "struct GNUNET_FS_SearchContext"), so they should not be freed. + * The key for each entry is the XOR of the key and query in the CHK + * URI (as a unique identifier for the search result). + */ + struct GNUNET_CONTAINER_MultiHashMap *results; + + /** + * Is this keyword a mandatory keyword + * (started with '+')? + */ + int mandatory; + }; @@ -616,13 +705,35 @@ struct GNUNET_FS_SearchContext */ struct GNUNET_FS_Uri *uri; + /** + * For update-searches, link to the + * base-SKS search that triggered the + * update search; otherwise NULL. + */ + struct GNUNET_FS_SearchContext *parent; + /** * Connection to the FS service. */ struct GNUNET_CLIENT_Connection *client; + /** + * Pointer we keep for the client. + */ + void *client_info; + + /** + * Map that contains a "struct SearchResult" for each result that + * was found in the search. The key for each entry is the XOR of + * the key and query in the CHK URI (as a unique identifier for the + * search result). + */ + struct GNUNET_CONTAINER_MultiHashMap *master_result_map; + /** * Per-keyword information for a keyword search. + * This array will have exactly as many entries + * as there were keywords. */ struct SearchRequestEntry *requests; @@ -644,9 +755,12 @@ struct GNUNET_FS_SearchContext /** * Anonymity level for the search. */ - unsigned int anonymity; - + uint32_t anonymity; + /** + * Number of mandatory keywords in this query. + */ + uint32_t mandatory_count; }; diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index e855a4d30..109a76791 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c @@ -24,9 +24,10 @@ * @author Christian Grothoff * * TODO: - * - aggregate and process results (FSUI-style) - * - call progress callbacks + * - handle SKS updates searches nicely (can wait) + * - handle availability probes (can wait) * - make operations persistent (can wait) + * - handle namespace advertisements (can wait) * - add support for pushing "already seen" information * to FS service for bloomfilter (can wait) */ @@ -40,6 +41,150 @@ #define DEBUG_SEARCH GNUNET_YES + +/** + * Fill in all of the generic fields for + * a search event. + * + * @param pc structure to fill in + * @param sc overall search context + */ +static void +make_search_status (struct GNUNET_FS_ProgressInfo *pi, + struct GNUNET_FS_SearchContext *sc) +{ + pi->value.search.sc = sc; + pi->value.search.cctx + = sc->client_info; + pi->value.search.pctx + = (sc->parent == NULL) ? NULL : sc->parent->client_info; + pi->value.search.query + = sc->uri; + pi->value.search.duration = GNUNET_TIME_absolute_get_duration (sc->start_time); + pi->value.search.anonymity = sc->anonymity; +} + + +/** + * Check if the given result is identical + * to the given URI. + * + * @param cls points to the URI we check against + * @param key not used + * @param value a "struct SearchResult" who's URI we + * should compare with + * @return GNUNET_SYSERR if the result is present, + * GNUNET_OK otherwise + */ +static int +test_result_present (void *cls, + const GNUNET_HashCode * key, + void *value) +{ + const struct GNUNET_FS_Uri *uri = cls; + struct SearchResult *sr = value; + + if (GNUNET_FS_uri_test_equal (uri, + sr->uri)) + return GNUNET_SYSERR; + return GNUNET_OK; +} + + +/** + * We've found a new CHK result. Let the client + * know about it. + * + * @param sc the search context + * @param sr the specific result + */ +static void +notify_client_chk_result (struct GNUNET_FS_SearchContext *sc, + struct SearchResult *sr) +{ + struct GNUNET_FS_ProgressInfo pi; + + pi.status = GNUNET_FS_STATUS_SEARCH_RESULT; + make_search_status (&pi, sc); + pi.value.search.specifics.result.meta = sr->meta; + pi.value.search.specifics.result.uri = sr->uri; + sr->client_info = sc->h->upcb (sc->h->upcb_cls, + &pi); +} + + +/** + * We've found new information about an existing CHK result. Let the + * client know about it. + * + * @param sc the search context + * @param sr the specific result + */ +static void +notify_client_chk_update (struct GNUNET_FS_SearchContext *sc, + struct SearchResult *sr) +{ + struct GNUNET_FS_ProgressInfo pi; + + pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE; + make_search_status (&pi, sc); + pi.value.search.specifics.update.cctx = sr->client_info; + pi.value.search.specifics.update.meta = sr->meta; + pi.value.search.specifics.update.uri = sr->uri; + pi.value.search.specifics.update.availability_rank + = 2*sr->availability_success - sr->availability_trials; + pi.value.search.specifics.update.availability_certainty + = sr->availability_trials; + pi.value.search.specifics.update.applicability_rank + = sr->optional_support; + sr->client_info = sc->h->upcb (sc->h->upcb_cls, + &pi); +} + + +/** + * Context for "get_result_present". + */ +struct GetResultContext +{ + /** + * The URI we're looking for. + */ + const struct GNUNET_FS_Uri *uri; + + /** + * Where to store a pointer to the search + * result struct if we found a match. + */ + struct SearchResult *sr; +}; + + +/** + * Check if the given result is identical + * to the given URI and if so return it. + * + * @param cls a "struct GetResultContext" + * @param key not used + * @param value a "struct SearchResult" who's URI we + * should compare with + * @return GNUNET_OK + */ +static int +get_result_present (void *cls, + const GNUNET_HashCode * key, + void *value) +{ + struct GetResultContext *grc = cls; + struct SearchResult *sr = value; + + if (GNUNET_FS_uri_test_equal (grc->uri, + sr->uri)) + grc->sr = sr; + return GNUNET_OK; +} + + /** * We have received a KSK result. Check * how it fits in with the overall query @@ -57,12 +202,82 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta) { - // FIXME: check if new - // FIXME: check if mandatory satisfied - // FIXME: notify client! + GNUNET_HashCode key; + struct SearchResult *sr; + struct GetResultContext grc; + int is_new; + + /* check if new */ + if (! GNUNET_FS_uri_test_ksk (uri)) + { + GNUNET_break_op (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 (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); + sr = grc.sr; + is_new = (NULL == sr) || (sr->mandatory_missing > 0); + if (NULL == sr) + { + sr = GNUNET_malloc (sizeof (struct SearchResult)); + sr->uri = GNUNET_FS_uri_dup (uri); + sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); + sr->mandatory_missing = sc->mandatory_count; + GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, + &key, + sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + } + else + { + /* FIXME: consider combining the meta data */ + } + /* check if mandatory satisfied */ + if (ent->mandatory) + sr->mandatory_missing--; + else + sr->optional_support++; + if (0 != sr->mandatory_missing) + return; + if (is_new) + notify_client_chk_result (sc, sr); + else + notify_client_chk_update (sc, sr); + /* FIXME: consider starting probes for "sr" */ } +/** + * Start search for content, internal API. + * + * @param h handle to the file sharing subsystem + * @param uri specifies the search parameters; can be + * a KSK URI or an SKS URI. + * @param anonymity desired level of anonymity + * @param parent parent search (for namespace update searches) + * @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, + unsigned int anonymity, + struct GNUNET_FS_SearchContext *parent); + + /** * We have received an SKS result. Start * searching for updates and notify the @@ -79,21 +294,49 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta) { - // FIXME: check if new - // FIXME: notify client + struct GNUNET_FS_Uri uu; + GNUNET_HashCode key; + struct SearchResult *sr; - if (strlen (id_update) > 0) + /* check if new */ + if (! GNUNET_FS_uri_test_ksk (uri)) { - // FIXME: search for updates! -#if 0 - updateURI.type = sks; - GNUNET_hash (&sb->subspace, - sizeof (GNUNET_RSA_PublicKey), - &updateURI.data.sks.namespace); - updateURI.data.sks.identifier = GNUNET_strdup (id); - add_search_for_uri (&updateURI, sqc); -#endif + GNUNET_break_op (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)) + return; /* duplicate result */ + sr = GNUNET_malloc (sizeof (struct SearchResult)); + sr->uri = GNUNET_FS_uri_dup (uri); + sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); + GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, + &key, + sr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + /* FIXME: consider starting probes for "sr" */ + + /* notify client */ + notify_client_chk_result (sc, sr); + /* search for updates */ + if (strlen (id_update) == 0) + return; /* no updates */ + uu.type = sks; + uu.data.sks.namespace = sc->uri->data.sks.namespace; + uu.data.sks.identifier = GNUNET_strdup (id_update); + /* FIXME: should attach update search + to the individual result, not + the entire SKS search! */ + search_start (sc->h, + &uu, + sc->anonymity, + sc); } @@ -371,12 +614,8 @@ transmit_search_request (void *cls, size_t msize; struct SearchMessage *sm; unsigned int i; - const char *keyword; const char *identifier; GNUNET_HashCode idh; - GNUNET_HashCode hc; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; - struct GNUNET_CRYPTO_RsaPrivateKey *pk; if (NULL == buf) { @@ -389,26 +628,12 @@ transmit_search_request (void *cls, GNUNET_assert (size >= msize); sm = buf; memset (sm, 0, msize); - sc->requests = GNUNET_malloc (sizeof (struct SearchRequestEntry) * - sc->uri->data.ksk.keywordCount); for (i=0;iuri->data.ksk.keywordCount;i++) { sm[i].header.size = htons (sizeof (struct SearchMessage)); sm[i].header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH); sm[i].anonymity_level = htonl (sc->anonymity); - keyword = &sc->uri->data.ksk.keywords[i][1]; - - GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc); - pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc); - GNUNET_CRYPTO_rsa_key_get_public (pk, &pub); - GNUNET_CRYPTO_rsa_key_free (pk); - GNUNET_CRYPTO_hash (&pub, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - &sm[i].query); - sc->requests[i].query = sm[i].query; - GNUNET_CRYPTO_hash (keyword, - strlen (keyword), - &sc->requests[i].key); + sm[i].query = sc->requests[i].query; } } else @@ -501,22 +726,30 @@ try_reconnect (struct GNUNET_FS_SearchContext *sc) /** - * Start search for content. + * Start search for content, internal API. * * @param h handle to the file sharing subsystem * @param uri specifies the search parameters; can be * a KSK URI or an SKS URI. * @param anonymity desired level of anonymity + * @param parent parent search (for namespace update searches) * @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, - unsigned int anonymity) +static struct GNUNET_FS_SearchContext * +search_start (struct GNUNET_FS_Handle *h, + const struct GNUNET_FS_Uri *uri, + unsigned int anonymity, + struct GNUNET_FS_SearchContext *parent) { struct GNUNET_FS_SearchContext *sc; struct GNUNET_CLIENT_Connection *client; + struct GNUNET_FS_ProgressInfo pi; size_t size; + unsigned int i; + const char *keyword; + GNUNET_HashCode hc; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; + struct GNUNET_CRYPTO_RsaPrivateKey *pk; if (GNUNET_FS_uri_test_ksk (uri)) { @@ -544,7 +777,38 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, sc->anonymity = anonymity; sc->start_time = GNUNET_TIME_absolute_get (); sc->client = client; - // FIXME: call callback! + sc->parent = parent; + sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16); + + sc->requests = GNUNET_malloc (sizeof (struct SearchRequestEntry) * + sc->uri->data.ksk.keywordCount); + for (i=0;iuri->data.ksk.keywordCount;i++) + { + keyword = &sc->uri->data.ksk.keywords[i][1]; + GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc); + pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc); + GNUNET_CRYPTO_rsa_key_get_public (pk, &pub); + GNUNET_CRYPTO_rsa_key_free (pk); + GNUNET_CRYPTO_hash (&pub, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &sc->requests[i].query); + sc->requests[i].mandatory = (sc->uri->data.ksk.keywords[i][0] == '+'); + if (sc->requests[i].mandatory) + sc->mandatory_count++; + sc->requests[i].results = GNUNET_CONTAINER_multihashmap_create (4); + GNUNET_CRYPTO_hash (keyword, + strlen (keyword), + &sc->requests[i].key); + } + if (NULL != parent) + { + // FIXME: need to track children + // in parent in case parent is stopped! + } + pi.status = GNUNET_FS_STATUS_SEARCH_START; + make_search_status (&pi, sc); + sc->client_info = h->upcb (h->upcb_cls, + &pi); GNUNET_CLIENT_notify_transmit_ready (client, size, GNUNET_CONSTANTS_SERVICE_TIMEOUT, @@ -554,6 +818,24 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, } +/** + * Start search for content. + * + * @param h handle to the file sharing subsystem + * @param uri specifies the search parameters; can be + * a KSK URI or an SKS URI. + * @param anonymity desired level of anonymity + * @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, + unsigned int anonymity) +{ + return search_start (h, uri, anonymity, NULL); +} + + /** * Pause search. * @@ -562,6 +844,8 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, void GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc) { + struct GNUNET_FS_ProgressInfo pi; + if (sc->task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (sc->h->sched, sc->task); @@ -570,7 +854,11 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc) GNUNET_CLIENT_disconnect (sc->client); sc->client = NULL; // FIXME: make persistent! - // FIXME: call callback! + // FIXME: should this freeze all active probes? + pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED; + make_search_status (&pi, sc); + sc->client_info = sc->h->upcb (sc->h->upcb_cls, + &pi); } @@ -582,11 +870,64 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc) void GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc) { + struct GNUNET_FS_ProgressInfo pi; + GNUNET_assert (sc->client == NULL); GNUNET_assert (sc->task == GNUNET_SCHEDULER_NO_TASK); do_reconnect (sc, NULL); // FIXME: make persistent! - // FIXME: call callback! + pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED; + make_search_status (&pi, sc); + sc->client_info = sc->h->upcb (sc->h->upcb_cls, + &pi); +} + + +/** + * Free the given search result. + * + * @param cls the global FS handle + * @param key the key for the search result (unused) + * @param value the search result to free + * @return GNUNET_OK + */ +static int +search_result_free (void *cls, + const GNUNET_HashCode * key, + void *value) +{ + struct GNUNET_FS_SearchContext *sc = cls; + struct GNUNET_FS_Handle *h = sc->h; + struct SearchResult *sr = value; + struct GNUNET_FS_ProgressInfo pi; + + pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED; + make_search_status (&pi, sc); + 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 = h->upcb (h->upcb_cls, + &pi); + GNUNET_break (NULL == sr->client_info); + + GNUNET_FS_uri_destroy (sr->uri); + GNUNET_CONTAINER_meta_data_destroy (sr->meta); + if (sr->probe_ctx != NULL) + { + GNUNET_FS_file_download_stop (sr->probe_ctx, GNUNET_YES); + h->active_probes--; + /* FIXME: trigger starting of new + probes here!? Maybe not -- could + cause new probes to be immediately + stopped again... */ + } + if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (h->sched, + sr->probe_cancel_task); + } + GNUNET_free (sr); + return GNUNET_OK; } @@ -598,13 +939,31 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc) void GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc) { + struct GNUNET_FS_ProgressInfo pi; + unsigned int i; + // FIXME: make un-persistent! - // FIXME: call callback! + if (NULL != sc->parent) + { + // FIXME: need to untrack sc + // in parent! + } + GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, + &search_result_free, + sc); + pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED; + make_search_status (&pi, sc); + sc->client_info = sc->h->upcb (sc->h->upcb_cls, + &pi); + GNUNET_break (NULL == sc->client_info); if (sc->task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (sc->h->sched, sc->task); if (NULL != sc->client) GNUNET_CLIENT_disconnect (sc->client); + GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); + for (i=0;iuri->data.ksk.keywordCount;i++) + GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results); GNUNET_free_non_null (sc->requests); GNUNET_FS_uri_destroy (sc->uri); GNUNET_free (sc); diff --git a/src/include/gnunet_container_lib.h b/src/include/gnunet_container_lib.h index 087324174..279d7df59 100644 --- a/src/include/gnunet_container_lib.h +++ b/src/include/gnunet_container_lib.h @@ -455,15 +455,16 @@ enum GNUNET_CONTAINER_MultiHashMapOption /** * Iterator over HashCodes. * + * @param cls closure * @param key current key code * @param value value in the hash map - * @param cls client-defined argument * @return GNUNET_YES if we should continue to * iterate, * GNUNET_NO if not. */ -typedef int (*GNUNET_CONTAINER_HashMapIterator) (const GNUNET_HashCode * key, - void *value, void *cls); +typedef int (*GNUNET_CONTAINER_HashMapIterator) (void *cls, + const GNUNET_HashCode * key, + void *value); /** diff --git a/src/include/gnunet_fs_service.h b/src/include/gnunet_fs_service.h index e8b8d0ba0..15aa85aa0 100644 --- a/src/include/gnunet_fs_service.h +++ b/src/include/gnunet_fs_service.h @@ -748,7 +748,7 @@ struct GNUNET_FS_ProgressInfo /** * What anonymity level is used for this upload? */ - unsigned int anonymity; + uint32_t anonymity; /** * Additional values for specific events. @@ -891,7 +891,7 @@ struct GNUNET_FS_ProgressInfo /** * What anonymity level is used for this download? */ - unsigned int anonymity; + uint32_t anonymity; /** * Additional values for specific events. @@ -927,11 +927,6 @@ struct GNUNET_FS_ProgressInfo */ unsigned int depth; - /** - * Amount of trust we offered to get the block. - */ - unsigned int trust_offered; - } progress; /** @@ -1027,13 +1022,7 @@ struct GNUNET_FS_ProgressInfo /** * What anonymity level is used for this search? */ - unsigned int anonymity; - - /** - * How much trust have we been offering for this search - * so far? - */ - unsigned int trust_offered; + uint32_t anonymity; /** * Additional values for specific events. @@ -1049,7 +1038,7 @@ struct GNUNET_FS_ProgressInfo /** * Metadata for the search result. */ - const struct GNUNET_MetaData *meta; + const struct GNUNET_CONTAINER_MetaData *meta; /** * URI for the search result. @@ -1067,7 +1056,7 @@ struct GNUNET_FS_ProgressInfo /** * Metadata for the search result. */ - const struct GNUNET_MetaData *meta; + const struct GNUNET_CONTAINER_MetaData *meta; /** * URI for the search result. @@ -1078,20 +1067,20 @@ struct GNUNET_FS_ProgressInfo * Current availability rank (negative: * unavailable, positive: available) */ - int availability_rank; + int32_t availability_rank; /** * On how many total queries is the given * availability_rank based? */ - unsigned int availabiliy_certainty; + uint32_t availabiliy_certainty; /** * Updated applicability rank (the larger, * the better the result fits the search * criteria). */ - unsigned int applicabiliy_rank; + uint32_t applicabiliy_rank; } resume_result; @@ -1110,7 +1099,7 @@ struct GNUNET_FS_ProgressInfo /** * Metadata for the search result. */ - const struct GNUNET_MetaData *meta; + const struct GNUNET_CONTAINER_MetaData *meta; /** * URI for the search result. @@ -1121,20 +1110,20 @@ struct GNUNET_FS_ProgressInfo * Current availability rank (negative: * unavailable, positive: available) */ - int availability_rank; + int32_t availability_rank; /** * On how many total queries is the given * availability_rank based? */ - unsigned int availabiliy_certainty; + uint32_t availability_certainty; /** * Updated applicability rank (the larger, * the better the result fits the search * criteria). */ - unsigned int applicabiliy_rank; + uint32_t applicability_rank; } update; @@ -1158,7 +1147,7 @@ struct GNUNET_FS_ProgressInfo /** * Metadata for the search result. */ - const struct GNUNET_MetaData *meta; + const struct GNUNET_CONTAINER_MetaData *meta; /** * URI for the search result. @@ -1187,7 +1176,7 @@ struct GNUNET_FS_ProgressInfo /** * Metadata for the search result. */ - const struct GNUNET_MetaData *meta; + const struct GNUNET_CONTAINER_MetaData *meta; /** * URI for the search result. @@ -1228,7 +1217,7 @@ struct GNUNET_FS_ProgressInfo } error; /** - * Values for all "GNUNET_FS_STATUS_RESULT_NAMESPACE" events. + * Values for all "GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE" events. */ struct { diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c index a84955eb3..410564a48 100644 --- a/src/util/container_multihashmap.c +++ b/src/util/container_multihashmap.c @@ -123,7 +123,7 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct e = map->map[i]; while (e != NULL) { - if ((NULL != it) && (GNUNET_OK != it (&e->key, e->value, cls))) + if ((NULL != it) && (GNUNET_OK != it (cls, &e->key, e->value))) return GNUNET_SYSERR; count++; e = e->next; -- 2.25.1