6 files changed, 258 insertions, 194 deletions

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;i<sc->uri->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,
@@ -172,17 +337,43 @@ 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