[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r8946 - in gnunet: . src/fs src/include src/util
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r8946 - in gnunet: . src/fs src/include src/util |
|
Date: |
Sat, 5 Sep 2009 07:19:01 -0600 |
Author: grothoff
Date: 2009-09-05 07:19:01 -0600 (Sat, 05 Sep 2009)
New Revision: 8946
Modified:
gnunet/TODO
gnunet/src/fs/fs.h
gnunet/src/fs/fs_search.c
gnunet/src/include/gnunet_container_lib.h
gnunet/src/include/gnunet_fs_service.h
gnunet/src/util/container_multihashmap.c
Log:
seach
Modified: gnunet/TODO
===================================================================
--- gnunet/TODO 2009-09-04 22:36:41 UTC (rev 8945)
+++ gnunet/TODO 2009-09-05 13:19:01 UTC (rev 8946)
@@ -18,7 +18,7 @@
- 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 @@
- 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 @@
- 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)
Modified: gnunet/src/fs/fs.h
===================================================================
--- gnunet/src/fs/fs.h 2009-09-04 22:36:41 UTC (rev 8945)
+++ gnunet/src/fs/fs.h 2009-09-05 13:19:01 UTC (rev 8946)
@@ -382,6 +382,12 @@
*/
struct GNUNET_CLIENT_Connection *client;
+ /**
+ * How many downloads probing availability
+ * of search results do we have running
+ * right now?
+ */
+ unsigned int active_probes;
};
@@ -583,6 +589,72 @@
/**
+ * 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 @@
/**
* 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;
+
};
@@ -617,12 +706,34 @@
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 @@
/**
* Anonymity level for the search.
*/
- unsigned int anonymity;
+ uint32_t anonymity;
-
+ /**
+ * Number of mandatory keywords in this query.
+ */
+ uint32_t mandatory_count;
};
Modified: gnunet/src/fs/fs_search.c
===================================================================
--- gnunet/src/fs/fs_search.c 2009-09-04 22:36:41 UTC (rev 8945)
+++ gnunet/src/fs/fs_search.c 2009-09-05 13:19:01 UTC (rev 8946)
@@ -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,7 +41,151 @@
#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
* and notify the client accordingly.
@@ -57,13 +202,83 @@
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
* client if it is a new result.
@@ -79,21 +294,49 @@
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 @@
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 @@
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;i<sc->uri->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 @@
/**
- * 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 @@
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;i<sc->uri->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,
@@ -555,6 +819,24 @@
/**
+ * 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.
*
* @param sc context for the search that should be paused
@@ -562,6 +844,8 @@
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_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,15 +870,68 @@
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;
+}
+
+
+/**
* Stop search for content.
*
* @param sc context for the search that should be stopped
@@ -598,13 +939,31 @@
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;i<sc->uri->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);
Modified: gnunet/src/include/gnunet_container_lib.h
===================================================================
--- gnunet/src/include/gnunet_container_lib.h 2009-09-04 22:36:41 UTC (rev
8945)
+++ gnunet/src/include/gnunet_container_lib.h 2009-09-05 13:19:01 UTC (rev
8946)
@@ -455,15 +455,16 @@
/**
* 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);
/**
Modified: gnunet/src/include/gnunet_fs_service.h
===================================================================
--- gnunet/src/include/gnunet_fs_service.h 2009-09-04 22:36:41 UTC (rev
8945)
+++ gnunet/src/include/gnunet_fs_service.h 2009-09-05 13:19:01 UTC (rev
8946)
@@ -748,7 +748,7 @@
/**
* What anonymity level is used for this upload?
*/
- unsigned int anonymity;
+ uint32_t anonymity;
/**
* Additional values for specific events.
@@ -891,7 +891,7 @@
/**
* What anonymity level is used for this download?
*/
- unsigned int anonymity;
+ uint32_t anonymity;
/**
* Additional values for specific events.
@@ -927,11 +927,6 @@
*/
unsigned int depth;
- /**
- * Amount of trust we offered to get the block.
- */
- unsigned int trust_offered;
-
} progress;
/**
@@ -1027,15 +1022,9 @@
/**
* What anonymity level is used for this search?
*/
- unsigned int anonymity;
+ uint32_t anonymity;
/**
- * How much trust have we been offering for this search
- * so far?
- */
- unsigned int trust_offered;
-
- /**
* Additional values for specific events.
*/
union {
@@ -1049,7 +1038,7 @@
/**
* 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 @@
/**
* 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 @@
* 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 @@
/**
* 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 @@
* 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 @@
/**
* 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 @@
/**
* 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 @@
} error;
/**
- * Values for all "GNUNET_FS_STATUS_RESULT_NAMESPACE" events.
+ * Values for all "GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE" events.
*/
struct {
Modified: gnunet/src/util/container_multihashmap.c
===================================================================
--- gnunet/src/util/container_multihashmap.c 2009-09-04 22:36:41 UTC (rev
8945)
+++ gnunet/src/util/container_multihashmap.c 2009-09-05 13:19:01 UTC (rev
8946)
@@ -123,7 +123,7 @@
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;
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r8946 - in gnunet: . src/fs src/include src/util,
gnunet <=