From 49ede7a464271d2fed12da3ec8bf6a1dde2b4e75 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 28 Mar 2010 15:22:14 +0000 Subject: [PATCH] working on fs, bugfixes --- TODO | 28 ++-- src/fs/fs.h | 1 - src/fs/fs_publish.c | 139 ++--------------- src/fs/fs_search.c | 43 +++--- src/fs/gnunet-service-fs.c | 25 +-- src/fs/test_fs_namespace.c | 239 +++++++++++++++++++++++++---- src/fs/test_fs_namespace_data.conf | 5 +- 7 files changed, 274 insertions(+), 206 deletions(-) diff --git a/TODO b/TODO index 6b7dee43e..20bd3cceb 100644 --- a/TODO +++ b/TODO @@ -23,14 +23,20 @@ away), in order in which they will likely be done: sessions even if no connections exist for a while! (likely related...) - transport reports bw quota violations on big-endian systems (core or transport issue?) +* DATASTORE: + - utilization can (easily, restart?) go out of control (very large), causing + content expiration job to go crazy and delete everything! * FS: + ! fs_search test fails (hangs) since blocktype was changed from "ANY" to "KBLOCK"! + (insert blocktype wrong? or what!?) + ! fs_namespace test fails (hangs), but local fs service has found results; somehow + they are not passed to the client and/or the shutdown sequence is not working - gnunet-publish cannot be aborted using CTRL-C - on some systems, keyword search does not find locally published content - (need testcase of command-line tools!) + (need testcase of command-line tools! - also good to cover getopt API!) - 2-peer download is still too slow (why?) - advanced FS API parts + search: SBlocks, NBlocks, probes, notify FS-service of known results - + location URIs (publish, search, download) + indexing: index-failure-cleanup + gnunet-publish (URI args) + gnunet-download (directory) @@ -38,13 +44,9 @@ away), in order in which they will likely be done: + gnunet-download (many options) + gnunet-directory (man page, options) + gnunet-pseudonym (all of it) - + gnunet-service-fs (remove failing on-demand blocks, hot-path routing, load-based routing, nitpicks) + + gnunet-service-fs (remove failing on-demand blocks, hot-path routing, + load-based routing, nitpicks) - implement adv. FS testcases - + getopt API - + insert: sblocks, loc uris - + download: loc uris - + search: sblocks, nblocks, loc uris - + namespaces - [./fs/gnunet-service-fs.c:208]: (style) struct or union member 'LocalGetContext::results_bf_size' is never used - [./fs/gnunet-service-fs.c:501]: (style) struct or union member 'PendingRequest::used_pids_size' is never used - [./fs/gnunet-service-fs.c:654]: (style) struct or union member 'ConnectedPeer::last_client_replies' is never used @@ -53,7 +55,6 @@ away), in order in which they will likely be done: - [./fs/gnunet-service-fs.c:688]: (style) struct or union member 'ConnectedPeer::pending_requests' is never used - [./fs/gnunet-service-fs.c:694]: (style) struct or union member 'ConnectedPeer::last_p2p_replies_woff' is never used - [./fs/gnunet-service-fs.c:700]: (style) struct or union member 'ConnectedPeer::last_client_replies_woff' is never used - * WWW: - Get IPv6 hooked up - change DNS @@ -61,7 +62,7 @@ away), in order in which they will likely be done: 0.9.0pre1: * Module features to implement: - tbench (RC-pre1) - + good to have for DV evaluation! + + good to have for DV evaluation! [MW] - DV (RC-pre1) + write DV API + implement DV service [Nate & CG] @@ -76,9 +77,11 @@ away), in order in which they will likely be done: + how to integrate scheduler with GTK event loop! * STATISTICS: - does not seem to work with timeouts (especially if service is not running) -* UTIL: +* PEERINFO: - trust: need *fast* way to check/update trust in peers - (async peerinfo would not be right) + (async peerinfo would not be right; certainly not with the + current API) +* UTIL: - scheduler should change OS process priority based on task priority; should make better use of task priorities in general - only connect() sockets that are ready (select()) [Nils] @@ -152,6 +155,7 @@ away), in order in which they will likely be done: debug output, detect random vs. deterministic crashes) - shutdown sequence? * FS: + - location URIs (publish, search, download) - collection API & tests - implement FS performance tests + insert diff --git a/src/fs/fs.h b/src/fs/fs.h index 0d4ed268a..b7fab55f0 100644 --- a/src/fs/fs.h +++ b/src/fs/fs.h @@ -1306,7 +1306,6 @@ struct SearchMessage /** * Type of the content that we're looking for. - * 0 for any. */ uint32_t type GNUNET_PACKED; diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c index 50c6bdd7b..f6e66e456 100644 --- a/src/fs/fs_publish.c +++ b/src/fs/fs_publish.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2009 Christian Grothoff (and other contributing authors) + (C) 2009, 2010 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -40,7 +40,7 @@ #include "fs.h" #include "fs_tree.h" -#define DEBUG_PUBLISH GNUNET_NO +#define DEBUG_PUBLISH GNUNET_YES /** * Main function that performs the upload. @@ -1487,8 +1487,9 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h, struct SBlock *sb; struct SBlock *sb_enc; char *dest; - GNUNET_HashCode key; /* hash of thisId = key */ + GNUNET_HashCode key; /* hash of thisId = key */ GNUNET_HashCode id; /* hash of hc = identifier */ + GNUNET_HashCode query; /* id ^ nsid = DB query */ uris = GNUNET_FS_uri_to_string (uri); slen = strlen (uris) + 1; @@ -1575,10 +1576,12 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h, _("Failed to connect to datastore.")); return; } - + GNUNET_CRYPTO_hash_xor (&sks_uri->data.sks.namespace, + &id, + &query); GNUNET_DATASTORE_put (psc->dsh, 0, - &sb->identifier, + &sb_enc->identifier, size, sb_enc, GNUNET_DATASTORE_BLOCKTYPE_SBLOCK, @@ -1588,133 +1591,9 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h, GNUNET_CONSTANTS_SERVICE_TIMEOUT, &sb_put_cont, psc); + GNUNET_free (sb); GNUNET_free (sb_enc); } - -#if 0 - -/** - * Add an entry into a namespace. - * - * @param dstU to which URI should the namespace entry refer? - * @param md what meta-data should be associated with the - * entry? - * @param thisId name of this entry in the namespace (keyword/identifier) - * @param nextId name of the update for this entry (to be published in - * the future; maybe NULL) - * @param pid unique identifier of the namespace/pseudonym - * @return URI on success, NULL on error - */ -struct GNUNET_ECRS_URI * -GNUNET_ECRS_namespace_add_content (struct GNUNET_GE_Context *ectx, - struct GNUNET_GC_Configuration *cfg, - const GNUNET_HashCode * pid, - uint32_t anonymityLevel, - uint32_t priority, - GNUNET_CronTime expiration, - const char *thisId, - const char *nextId, - const struct GNUNET_ECRS_URI *dstU, - const struct GNUNET_MetaData *md) -{ - struct GNUNET_ECRS_URI *uri; - struct GNUNET_ClientServerConnection *sock; - GNUNET_DatastoreValue *value; - unsigned int size; - unsigned int mdsize; - struct GNUNET_RSA_PrivateKey *hk; - GNUNET_EC_SBlock *sb; - char *dstURI; - char *destPos; - GNUNET_HashCode hc; /* hash of thisId = key */ - GNUNET_HashCode hc2; /* hash of hc = identifier */ - int ret; - unsigned int nidlen; - - hk = read_namespace_key (cfg, pid); - if (hk == NULL) - return NULL; - - /* THEN: construct GNUNET_EC_SBlock */ - dstURI = GNUNET_ECRS_uri_to_string (dstU); - mdsize = GNUNET_meta_data_get_serialized_size (md, GNUNET_SERIALIZE_PART); - if (nextId == NULL) - nextId = ""; - nidlen = strlen (nextId) + 1; - size = mdsize + sizeof (GNUNET_EC_SBlock) + strlen (dstURI) + 1 + nidlen; - if (size > MAX_SBLOCK_SIZE) - { - size = MAX_SBLOCK_SIZE; - mdsize = - size - (sizeof (GNUNET_EC_SBlock) + strlen (dstURI) + 1 + nidlen); - } - value = GNUNET_malloc (sizeof (GNUNET_DatastoreValue) + size); - sb = (GNUNET_EC_SBlock *) & value[1]; - sb->type = htonl (GNUNET_ECRS_BLOCKTYPE_SIGNED); - destPos = (char *) &sb[1]; - memcpy (destPos, nextId, nidlen); - destPos += nidlen; - memcpy (destPos, dstURI, strlen (dstURI) + 1); - destPos += strlen (dstURI) + 1; - mdsize = GNUNET_meta_data_serialize (ectx, - md, - destPos, - mdsize, GNUNET_SERIALIZE_PART); - if (mdsize == -1) - { - GNUNET_GE_BREAK (ectx, 0); - GNUNET_free (dstURI); - GNUNET_RSA_free_key (hk); - GNUNET_free (value); - return NULL; - } - size = sizeof (GNUNET_EC_SBlock) + mdsize + strlen (dstURI) + 1 + nidlen; - value->size = htonl (sizeof (GNUNET_DatastoreValue) + size); - value->type = htonl (GNUNET_ECRS_BLOCKTYPE_SIGNED); - value->priority = htonl (priority); - value->anonymity_level = htonl (anonymityLevel); - value->expiration_time = GNUNET_htonll (expiration); - GNUNET_hash (thisId, strlen (thisId), &hc); - GNUNET_hash (&hc, sizeof (GNUNET_HashCode), &hc2); - uri = GNUNET_malloc (sizeof (URI)); - uri->type = sks; - GNUNET_RSA_get_public_key (hk, &sb->subspace); - GNUNET_hash (&sb->subspace, - sizeof (GNUNET_RSA_PublicKey), &uri->data.sks.namespace); - GNUNET_GE_BREAK (ectx, 0 == memcmp (&uri->data.sks.namespace, - pid, sizeof (GNUNET_HashCode))); - uri->data.sks.identifier = GNUNET_strdup (thisId); - GNUNET_hash_xor (&hc2, &uri->data.sks.namespace, &sb->identifier); - GNUNET_ECRS_encryptInPlace (&hc, &sb[1], size - sizeof (GNUNET_EC_SBlock)); - GNUNET_GE_ASSERT (ectx, - GNUNET_OK == GNUNET_RSA_sign (hk, - size - - - sizeof - (GNUNET_RSA_Signature) - - sizeof - (GNUNET_RSA_PublicKey) - - sizeof (unsigned int), - &sb->identifier, - &sb->signature)); - GNUNET_RSA_free_key (hk); - sock = GNUNET_client_connection_create (ectx, cfg); - ret = GNUNET_FS_insert (sock, value); - if (ret != GNUNET_OK) - { - GNUNET_free (uri); - uri = NULL; - } - GNUNET_client_connection_destroy (sock); - GNUNET_free (value); - GNUNET_free (dstURI); - - return uri; -} - -#endif - - /* end of fs_publish.c */ diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index a03e9becb..746a2f19d 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c @@ -38,7 +38,7 @@ #include "gnunet_protocols.h" #include "fs.h" -#define DEBUG_SEARCH GNUNET_NO +#define DEBUG_SEARCH GNUNET_YES @@ -161,8 +161,8 @@ struct GetResultContext /** - * Check if the given result is identical - * to the given URI and if so return it. + * 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 @@ -186,9 +186,8 @@ get_result_present (void *cls, /** - * We have received a KSK result. Check - * how it fits in with the overall query - * and notify the client accordingly. + * We have received a KSK result. Check how it fits in with the + * overall query and notify the client accordingly. * * @param sc context for the overall query * @param ent entry for the specific keyword @@ -208,14 +207,7 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc, int is_new; /* check if new */ - if (! GNUNET_FS_uri_test_chk (uri)) - { - GNUNET_break_op (0); - return; - } - GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key, - &uri->data.chk.chk.query, - &key); + GNUNET_FS_uri_to_key (uri, &key); if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_get_multiple (ent->results, &key, @@ -281,9 +273,8 @@ search_start (struct GNUNET_FS_Handle *h, /** - * We have received an SKS result. Start - * searching for updates and notify the - * client if it is a new result. + * We have received an SKS result. Start searching for updates and + * notify the client if it is a new result. * * @param sc context for the overall query * @param id_update identifier for updates, NULL for none @@ -301,11 +292,7 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc, struct SearchResult *sr; /* check if new */ - if (! GNUNET_FS_uri_test_ksk (uri)) - { - GNUNET_break_op (0); - return; - } + GNUNET_FS_uri_to_key (uri, &key); GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key, &uri->data.chk.chk.query, &key); @@ -618,6 +605,7 @@ transmit_search_request (void *cls, struct SearchMessage *sm; unsigned int i; const char *identifier; + GNUNET_HashCode key; GNUNET_HashCode idh; if (NULL == buf) @@ -635,28 +623,34 @@ transmit_search_request (void *cls, { 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); + sm[i].type = htonl (GNUNET_DATASTORE_BLOCKTYPE_KBLOCK); + sm[i].anonymity_level = htonl (sc->anonymity); sm[i].query = sc->requests[i].query; } } else { + GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri)); msize = sizeof (struct SearchMessage); GNUNET_assert (size >= msize); sm = buf; memset (sm, 0, msize); sm->header.size = htons (sizeof (struct SearchMessage)); sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH); + sm->type = htonl (GNUNET_DATASTORE_BLOCKTYPE_SBLOCK); sm->anonymity_level = htonl (sc->anonymity); sm->target = sc->uri->data.sks.namespace; identifier = sc->uri->data.sks.identifier; GNUNET_CRYPTO_hash (identifier, strlen (identifier), + &key); + GNUNET_CRYPTO_hash (&key, + sizeof (GNUNET_HashCode), &idh); GNUNET_CRYPTO_hash_xor (&idh, &sm->target, &sm->query); - } + } GNUNET_CLIENT_receive (sc->client, &receive_results, sc, @@ -785,6 +779,7 @@ search_start (struct GNUNET_FS_Handle *h, sc->client_info = cctx; if (GNUNET_FS_uri_test_ksk (uri)) { + GNUNET_assert (0 != sc->uri->data.ksk.keywordCount); sc->requests = GNUNET_malloc (sizeof (struct SearchRequestEntry) * sc->uri->data.ksk.keywordCount); for (i=0;iuri->data.ksk.keywordCount;i++) diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c index b8c9d91fa..e230a5e77 100644 --- a/src/fs/gnunet-service-fs.c +++ b/src/fs/gnunet-service-fs.c @@ -1657,7 +1657,7 @@ check_sblock (const struct SBlock *sb, return GNUNET_SYSERR; } if (dsize != - ntohs (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature)) + ntohl (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature)) { GNUNET_break_op (0); return GNUNET_SYSERR; @@ -1836,6 +1836,11 @@ process_reply (void *cls, do_remove = GNUNET_YES; break; case GNUNET_DATASTORE_BLOCKTYPE_SBLOCK: + if (pr->namespace == NULL) + { + GNUNET_break (0); + return GNUNET_YES; + } if (0 != memcmp (pr->namespace, &prq->namespace, sizeof (GNUNET_HashCode))) @@ -2484,10 +2489,11 @@ handle_p2p_get (void *cls, #if DEBUG_FS GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received request for `%s' of type %u from peer `%4s'\n", + "Received request for `%s' of type %u from peer `%4s' with flags %u\n", GNUNET_h2s (&gm->query), (unsigned int) type, - GNUNET_i2s (other)); + GNUNET_i2s (other), + (unsigned int) bm); #endif have_ns = (0 != (bm & GET_MESSAGE_BIT_SKS_NAMESPACE)); pr = GNUNET_malloc (sizeof (struct PendingRequest) + @@ -2685,9 +2691,14 @@ handle_start_search (void *cls, client_list = cl; } type = ntohl (sm->type); +#if DEBUG_FS + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received request for `%s' of type %u from local client\n", + GNUNET_h2s (&sm->query), + (unsigned int) type); +#endif switch (type) { - case GNUNET_DATASTORE_BLOCKTYPE_ANY: case GNUNET_DATASTORE_BLOCKTYPE_DBLOCK: case GNUNET_DATASTORE_BLOCKTYPE_IBLOCK: case GNUNET_DATASTORE_BLOCKTYPE_KBLOCK: @@ -2699,12 +2710,6 @@ handle_start_search (void *cls, GNUNET_SYSERR); return; } -#if DEBUG_FS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received request for `%s' of type %u from local client\n", - GNUNET_h2s (&sm->query), - (unsigned int) type); -#endif /* detect duplicate KBLOCK requests */ if (type == GNUNET_DATASTORE_BLOCKTYPE_KBLOCK) diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index ea9e00c90..6014e4394 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.c @@ -22,21 +22,38 @@ * @file fs/test_fs_namespace.c * @brief Test for fs_namespace.c * @author Christian Grothoff + * + * TODO: + * - add timeout task */ - #include "platform.h" #include "gnunet_util_lib.h" #include "gnunet_arm_service.h" #include "gnunet_fs_service.h" +#define VERBOSE GNUNET_YES + #define START_ARM GNUNET_YES static struct GNUNET_SCHEDULER_Handle *sched; static struct PeerContext p1; +static GNUNET_HashCode nsid; + +static struct GNUNET_FS_Uri *sks_expect_uri; + +static struct GNUNET_FS_Uri *ksk_expect_uri; + static struct GNUNET_FS_Handle *fs; +static struct GNUNET_FS_SearchContext *sks_search; + +static struct GNUNET_FS_SearchContext *ksk_search; + +static int update_started; + +static int err; struct PeerContext { @@ -79,21 +96,131 @@ stop_arm (struct PeerContext *p) } -#if 0 static void -spcb (void *cls, - const char *name, - const GNUNET_HashCode * key) +abort_ksk_search_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { + if (ksk_search != NULL) + { + GNUNET_FS_search_stop (ksk_search); + ksk_search = NULL; + if (sks_search == NULL) + GNUNET_FS_stop (fs); + } } -#endif +static void +abort_sks_search_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_FS_Namespace *ns; + + if (sks_search != NULL) + { + GNUNET_FS_search_stop (sks_search); + sks_search = NULL; + ns = GNUNET_FS_namespace_create (fs, + "testNamespace"); + GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); + if (ksk_search == NULL) + GNUNET_FS_stop (fs); + } +} + static void * progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) { + switch (event->status) + { + case GNUNET_FS_STATUS_SEARCH_RESULT: + if (sks_search == event->value.search.sc) + { + fprintf (stderr, + "Search result for sks received\n"); + if (! GNUNET_FS_uri_test_equal (sks_expect_uri, + event->value.search.specifics.result.uri)) + { + fprintf (stderr, + "Wrong result for sks search!\n"); + err = 1; + } + /* give system 1ms to initiate update search! */ + GNUNET_SCHEDULER_add_delayed (sched, + GNUNET_TIME_UNIT_MILLISECONDS, + &abort_sks_search_task, + NULL); + } + else if (ksk_search == event->value.search.sc) + { + fprintf (stderr, + "Search result for ksk received\n"); + if (! GNUNET_FS_uri_test_equal (ksk_expect_uri, + event->value.search.specifics.result.uri)) + { + fprintf (stderr, + "Wrong result for ksk search!\n"); + err = 1; + } + GNUNET_SCHEDULER_add_continuation (sched, + &abort_ksk_search_task, + NULL, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + } + else + { + fprintf (stderr, + "Search result received!?\n"); + GNUNET_break (0); + } + break; + case GNUNET_FS_STATUS_SEARCH_ERROR: + fprintf (stderr, + "Error searching file: %s\n", + event->value.search.specifics.error.message); + if (sks_search == event->value.search.sc) + GNUNET_SCHEDULER_add_continuation (sched, + &abort_sks_search_task, + NULL, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + else if (ksk_search == event->value.search.sc) + GNUNET_SCHEDULER_add_continuation (sched, + &abort_ksk_search_task, + NULL, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + else + GNUNET_break (0); + break; + case GNUNET_FS_STATUS_SEARCH_START: + fprintf (stderr, + "Search start event for `%s' received\n", + (const char*) event->value.search.cctx); + GNUNET_assert ( (NULL == event->value.search.cctx) || + (0 == strcmp ("sks_search", event->value.search.cctx)) || + (0 == strcmp ("ksk_search", event->value.search.cctx))); + if (NULL == event->value.search.cctx) + { + GNUNET_assert (sks_search == event->value.search.pctx); + update_started = GNUNET_YES; + } + GNUNET_assert (1 == event->value.search.anonymity); + break; + case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: + break; + case GNUNET_FS_STATUS_SEARCH_STOPPED: + fprintf (stderr, + "Search stop event received\n"); + GNUNET_assert ( (ksk_search == event->value.search.sc) || + (sks_search == event->value.search.sc)); + break; + default: + fprintf (stderr, + "Unexpected event: %d\n", + event->status); + break; + } return NULL; } @@ -103,11 +230,39 @@ publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) { - struct GNUNET_FS_SearchContext *search; - - GNUNET_assert (NULL == emsg); + char *msg; + struct GNUNET_FS_Uri *sks_uri; + char sbuf[1024]; + struct GNUNET_CRYPTO_HashAsciiEncoded enc; + + if (NULL != emsg) + { + fprintf (stderr, "Error publishing: %s\n", emsg); + err = 1; + GNUNET_FS_stop (fs); + return; + } + GNUNET_CRYPTO_hash_to_enc (&nsid, + &enc); + GNUNET_snprintf (sbuf, + sizeof (sbuf), + "gnunet://fs/sks/%s/this", + &enc); + sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); + if (msg != NULL) + { + fprintf (stderr, "failed to parse URI `%s': %s\n", + sbuf, + msg); + err = 1; + GNUNET_FS_stop (fs); + return; + } fprintf (stderr, "Starting keyword search...\n"); - search = GNUNET_FS_search_start (fs, ksk_uri, 1, NULL); + ksk_search = GNUNET_FS_search_start (fs, ksk_uri, 1, "ksk_search"); + fprintf (stderr, "Starting namespace search...\n") ; + sks_search = GNUNET_FS_search_start (fs, sks_uri, 1, "sks_search"); + GNUNET_FS_uri_destroy (sks_uri); } @@ -127,6 +282,7 @@ sks_cont (void *cls, ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg); GNUNET_assert (NULL == msg); fprintf (stderr, "Advertising update 'this' namespace entry under keyword...\n"); + ksk_expect_uri = GNUNET_FS_uri_dup (uri); GNUNET_FS_publish_ksk (fs, ksk_uri, meta, @@ -136,6 +292,7 @@ sks_cont (void *cls, GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); + GNUNET_FS_uri_destroy (ksk_uri); GNUNET_CONTAINER_meta_data_destroy (meta); } @@ -149,18 +306,26 @@ adv_cont (void *cls, struct GNUNET_FS_Namespace *ns; struct GNUNET_TIME_Absolute expiration; + if (NULL != emsg) + { + fprintf (stderr, "Error publishing: %s\n", emsg); + err = 1; + GNUNET_FS_stop (fs); + return; + } expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); ns = GNUNET_FS_namespace_create (fs, "testNamespace"); meta = GNUNET_CONTAINER_meta_data_create (); GNUNET_assert (NULL == emsg); fprintf (stderr, "Advertising update 'this->next' namespace update...\n"); + sks_expect_uri = GNUNET_FS_uri_dup (uri); GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, - uri, /* FIXME: this is non-sense (use CHK URI!) */ + uri, /* FIXME: this is non-sense (use CHK URI!?) */ expiration, 1, 1, GNUNET_FS_PUBLISH_OPTION_NONE, @@ -171,18 +336,44 @@ adv_cont (void *cls, } +static void +ns_iterator (void *cls, + const char *name, + const GNUNET_HashCode *id) +{ + int *ok = cls; + + if (0 != strcmp (name, + "testNamespace")) + return; + *ok = GNUNET_YES; + nsid = *id; +} + + static void testNamespace () { struct GNUNET_FS_Namespace *ns; struct GNUNET_TIME_Absolute expiration; struct GNUNET_CONTAINER_MetaData *meta; + int ok; - expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); - meta = GNUNET_CONTAINER_meta_data_create (); ns = GNUNET_FS_namespace_create (fs, "testNamespace"); + ok = GNUNET_NO; + GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); + if (GNUNET_NO == ok) + { + fprintf (stderr, "namespace_list failed to find namespace!\n"); + GNUNET_FS_namespace_delete (ns, GNUNET_YES); + GNUNET_FS_stop (fs); + err = 1; + return; + } fprintf (stderr, "Advertising namespace root...\n"); + expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + meta = GNUNET_CONTAINER_meta_data_create (); GNUNET_FS_namespace_advertise (fs, ns, meta, @@ -194,17 +385,6 @@ testNamespace () GNUNET_CONTAINER_meta_data_destroy (meta); } -#if 0 - fprintf (stderr, "Completed namespace search...\n"); - GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (NULL, cfg, &pid)); - GNUNET_assert (GNUNET_SYSERR == GNUNET_FS_namespace_delete (NULL, cfg, &pid)); - GNUNET_FS_uri_destroy (rootURI); - GNUNET_FS_uri_destroy (advURI); - GNUNET_assert (match == 1); - return 0; -} -#endif - static void run (void *cls, @@ -214,7 +394,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) { sched = s; - setup_peer (&p1, "test_fs_download_data.conf"); + setup_peer (&p1, "test_fs_namespace_data.conf"); fs = GNUNET_FS_start (sched, cfg, "test-fs-namespace", @@ -253,10 +433,15 @@ main (int argc, char *argv[]) argvx, "test-fs-namespace", "nohelp", options, &run, NULL); stop_arm (&p1); + if (GNUNET_YES != update_started) + { + fprintf (stderr, + "Update search never started!\n"); + err = 1; + } GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/"); - return 0; + return err; } - /* end of test_fs_namespace.c */ diff --git a/src/fs/test_fs_namespace_data.conf b/src/fs/test_fs_namespace_data.conf index d7c2af4c4..3316da3da 100644 --- a/src/fs/test_fs_namespace_data.conf +++ b/src/fs/test_fs_namespace_data.conf @@ -19,7 +19,7 @@ HOSTNAME = localhost DEFAULTSERVICES = resolver datastore transport core fs [datastore] -#DEBUG = YES +DEBUG = YES [statistics] PORT = 42467 @@ -36,7 +36,8 @@ HOSTNAME = localhost [fs] PORT = 42471 HOSTNAME = localhost -#DEBUG = YES +IDENTITY_DIR = $SERVICEHOME/pseudos/ +DEBUG = YES [testing] WEAKRANDOM = YES -- 2.25.1