* @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)
*/
#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
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
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);
}
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)
{
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
/**
- * 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))
{
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,
}
+/**
+ * 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.
*
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);
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);
}
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;
}
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);
projects / oweals / gnunet.git / commitdiff