seach

5 files changed, 541 insertions, 78 deletions

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;
 
 };
 
@@ -583,6 +589,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;
+
 };
 
 
@@ -617,12 +706,34 @@ 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,13 +202,83 @@ 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
  * client if it is a new result.
@@ -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;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 @@ 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;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 @@ 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.  
  *
  * @param sc context for the search that should be paused
@@ -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;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);
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;