resume and less debug crap

22 files changed, 228 insertions, 131 deletions

diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index 6e215ed27..eb45f795d 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -175,6 +175,61 @@ transmit_download_request (void *cls,
 
 
 /**
+ * Closure for iterator processing results.
+ */
+struct ProcessResultClosure
+{
+  
+  /**
+   * Hash of data.
+   */
+  GNUNET_HashCode query;
+
+  /**
+   * Data found in P2P network.
+   */ 
+  const void *data;
+
+  /**
+   * Our download context.
+   */
+  struct GNUNET_FS_DownloadContext *dc;
+                
+  /**
+   * Number of bytes in data.
+   */
+  size_t size;
+
+  /**
+   * Type of data.
+   */
+  uint32_t type;
+
+  /**
+   * Flag to indicate if this block should be stored on disk.
+   */
+  int do_store;
+  
+};
+
+
+/**
+ * Iterator over entries in the pending requests in the 'active' map for the
+ * reply that we just got.
+ *
+ * @param cls closure (our 'struct ProcessResultClosure')
+ * @param key query for the given value / request
+ * @param value value in the hash map (a 'struct DownloadRequest')
+ * @return GNUNET_YES (we should continue to iterate); unless serious error
+ */
+static int
+process_result_with_request (void *cls,
+                             const GNUNET_HashCode * key,
+                             void *value);
+
+
+
+/**
  * Schedule the download of the specified block in the tree.
  *
  * @param dc overall download this block belongs to
@@ -192,7 +247,12 @@ schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
                          unsigned int depth)
 {
   struct DownloadRequest *sm;
+  uint64_t total;
   uint64_t off;
+  size_t len;
+  char block[DBLOCK_SIZE];
+  GNUNET_HashCode key;
+  struct ProcessResultClosure prc;
 
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -201,20 +261,77 @@ schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
               depth,
               GNUNET_h2s (&chk->query));
 #endif
-  off = compute_disk_offset (GNUNET_ntohll (dc->uri->data.chk.file_length),
+  total = GNUNET_ntohll (dc->uri->data.chk.file_length);
+  off = compute_disk_offset (total,
                              offset,
                              depth,
                              dc->treedepth);
+  len = GNUNET_FS_tree_calculate_block_size (total,
+                                             dc->treedepth,
+                                             offset,
+                                             depth);
+  sm = GNUNET_malloc (sizeof (struct DownloadRequest));
+  sm->chk = *chk;
+  sm->offset = offset;
+  sm->depth = depth;
+  sm->is_pending = GNUNET_YES;
+  sm->next = dc->pending;
+  dc->pending = sm;
+  GNUNET_CONTAINER_multihashmap_put (dc->active,
+                                     &chk->query,
+                                     sm,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+
   if ( (dc->old_file_size > off) &&
        (dc->handle != NULL) &&
        (off  == 
         GNUNET_DISK_file_seek (dc->handle,
                                off,
-                               GNUNET_DISK_SEEK_SET) ) )
+                               GNUNET_DISK_SEEK_SET) ) &&
+       (len == 
+        GNUNET_DISK_file_read (dc->handle,
+                               block,
+                               len)) )
     {
-      // FIXME: check if block exists on disk!
-      // (read block, encode, compare with
-      // query; if matches, simply return)
+      /* FIXME: also check query matches!? */
+      if (0 == memcmp (&key,
+                       &chk->key,
+                       sizeof (GNUNET_HashCode)))
+        {
+          char enc[len];
+          struct GNUNET_CRYPTO_AesSessionKey sk;
+          struct GNUNET_CRYPTO_AesInitializationVector iv;
+          GNUNET_HashCode query;
+
+          GNUNET_CRYPTO_hash_to_aes_key (&key, &sk, &iv);
+          GNUNET_CRYPTO_aes_encrypt (block, len,
+                                     &sk,
+                                     &iv,
+                                     enc);
+          GNUNET_CRYPTO_hash (enc, len, &query);
+          if (0 == memcmp (&query,
+                           &chk->query,
+                           sizeof (GNUNET_HashCode)))
+            {
+              /* already got it! */
+              prc.dc = dc;
+              prc.data = enc;
+              prc.size = len;
+              prc.type = (dc->treedepth == depth) 
+                ? GNUNET_DATASTORE_BLOCKTYPE_DBLOCK 
+                : GNUNET_DATASTORE_BLOCKTYPE_IBLOCK;
+              prc.query = chk->query;
+              prc.do_store = GNUNET_NO; /* useless */
+              process_result_with_request (&prc,
+                                           &key,
+                                           sm);
+            }
+          else
+            {
+              GNUNET_break_op (0);
+            }
+          return;
+        }
     }
   if (depth < dc->treedepth)
     {
@@ -224,17 +341,6 @@ schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
       // (read block(s), encode, compare with
       // query; if matches, simply return)
     }
-  sm = GNUNET_malloc (sizeof (struct DownloadRequest));
-  sm->chk = *chk;
-  sm->offset = offset;
-  sm->depth = depth;
-  sm->is_pending = GNUNET_YES;
-  sm->next = dc->pending;
-  dc->pending = sm;
-  GNUNET_CONTAINER_multihashmap_put (dc->active,
-                                     &chk->query,
-                                     sm,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
   if ( (dc->th == NULL) &&
        (dc->client != NULL) )
@@ -395,85 +501,6 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
- * Compute how many bytes of data should be stored in
- * the specified node.
- *
- * @param fsize overall file size
- * @param totaldepth depth of the entire tree
- * @param offset offset of the node
- * @param depth depth of the node
- * @return number of bytes stored in this node
- */
-static size_t
-calculate_block_size (uint64_t fsize,
-                      unsigned int totaldepth,
-                      uint64_t offset,
-                      unsigned int depth)
-{
-  unsigned int i;
-  size_t ret;
-  uint64_t rsize;
-  uint64_t epos;
-  unsigned int chks;
-
-  GNUNET_assert (offset < fsize);
-  if (depth == totaldepth)
-    {
-      ret = DBLOCK_SIZE;
-      if (offset + ret > fsize)
-        ret = (size_t) (fsize - offset);
-      return ret;
-    }
-
-  rsize = DBLOCK_SIZE;
-  for (i = totaldepth-1; i > depth; i--)
-    rsize *= CHK_PER_INODE;
-  epos = offset + rsize * CHK_PER_INODE;
-  GNUNET_assert (epos > offset);
-  if (epos > fsize)
-    epos = fsize;
-  /* round up when computing #CHKs in our IBlock */
-  chks = (epos - offset + rsize - 1) / rsize;
-  GNUNET_assert (chks <= CHK_PER_INODE);
-  return chks * sizeof (struct ContentHashKey);
-}
-
-
-/**
- * Closure for iterator processing results.
- */
-struct ProcessResultClosure
-{
-  
-  /**
-   * Hash of data.
-   */
-  GNUNET_HashCode query;
-
-  /**
-   * Data found in P2P network.
-   */ 
-  const void *data;
-
-  /**
-   * Our download context.
-   */
-  struct GNUNET_FS_DownloadContext *dc;
-                
-  /**
-   * Number of bytes in data.
-   */
-  size_t size;
-
-  /**
-   * Type of data.
-   */
-  uint32_t type;
-  
-};
-
-
-/**
  * We found an entry in a directory.  Check if the respective child
  * already exists and if not create the respective child download.
  *
@@ -764,23 +791,22 @@ process_result_with_request (void *cls,
   char pt[prc->size];
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
+  size_t bs;
   size_t app;
   int i;
   struct ContentHashKey *chk;
   char *emsg;
 
-  if (prc->size != calculate_block_size (GNUNET_ntohll (dc->uri->data.chk.file_length),
-                                         dc->treedepth,
-                                         sm->offset,
-                                         sm->depth))
+  bs = GNUNET_FS_tree_calculate_block_size (GNUNET_ntohll (dc->uri->data.chk.file_length),
+                                            dc->treedepth,
+                                            sm->offset,
+                                            sm->depth);
+    if (prc->size != bs)
     {
 #if DEBUG_DOWNLOAD
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Internal error or bogus download URI (expected %u bytes, got %u)\n",
-                  calculate_block_size (GNUNET_ntohll (dc->uri->data.chk.file_length),
-                                        dc->treedepth,
-                                        sm->offset,
-                                        sm->depth),
+                  bs,
                   prc->size);
 #endif
       dc->emsg = GNUNET_strdup ("Internal error or bogus download URI");
@@ -815,7 +841,8 @@ process_result_with_request (void *cls,
                              sm->depth,
                              dc->treedepth);
   /* save to disk */
-  if ( (NULL != dc->handle) &&
+  if ( ( GNUNET_YES == prc->do_store) &&
+       (NULL != dc->handle) &&
        ( (sm->depth == dc->treedepth) ||
          (0 == (dc->options & GNUNET_FS_DOWNLOAD_NO_TEMPORARIES)) ) )
     {
@@ -1006,6 +1033,7 @@ process_result (struct GNUNET_FS_DownloadContext *dc,
   prc.data = data;
   prc.size = size;
   prc.type = type;
+  prc.do_store = GNUNET_YES;
   GNUNET_CRYPTO_hash (data, size, &prc.query);
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c
index 1280548d8..ef7c560d6 100644
--- a/src/fs/fs_tree.c
+++ b/src/fs/fs_tree.c
@@ -198,9 +198,9 @@ GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,
  * @param offset current offset in the overall file
  * @return size of the corresponding IBlock
  */
-static uint16_t 
-compute_iblock_size (unsigned int height,
-                     uint64_t offset)
+uint16_t 
+GNUNET_FS_tree_compute_iblock_size (unsigned int height,
+                                    uint64_t offset)
 {
   unsigned int ret;
   unsigned int i;
@@ -231,6 +231,52 @@ compute_iblock_size (unsigned int height,
 
 
 /**
+ * Compute how many bytes of data should be stored in
+ * the specified node.
+ *
+ * @param fsize overall file size
+ * @param totaldepth depth of the entire tree
+ * @param offset offset of the node
+ * @param depth depth of the node
+ * @return number of bytes stored in this node
+ */
+size_t
+GNUNET_FS_tree_calculate_block_size (uint64_t fsize,
+                                     unsigned int totaldepth,
+                                     uint64_t offset,
+                                     unsigned int depth)
+{
+  unsigned int i;
+  size_t ret;
+  uint64_t rsize;
+  uint64_t epos;
+  unsigned int chks;
+
+  GNUNET_assert (offset < fsize);
+  if (depth == totaldepth)
+    {
+      ret = DBLOCK_SIZE;
+      if (offset + ret > fsize)
+        ret = (size_t) (fsize - offset);
+      return ret;
+    }
+  /* FIXME: this code should be *equivalent* to the
+     GNUNET_FS_tree_compute_iblock_size function above! Remove duplication! */
+  rsize = DBLOCK_SIZE;
+  for (i = totaldepth-1; i > depth; i--)
+    rsize *= CHK_PER_INODE;
+  epos = offset + rsize * CHK_PER_INODE;
+  GNUNET_assert (epos > offset);
+  if (epos > fsize)
+    epos = fsize;
+  /* round up when computing #CHKs in our IBlock */
+  chks = (epos - offset + rsize - 1) / rsize;
+  GNUNET_assert (chks <= CHK_PER_INODE);
+  return chks * sizeof (struct ContentHashKey);
+}
+
+
+/**
  * Compute the offset of the CHK for the
  * current block in the IBlock above.
  *
@@ -297,8 +343,8 @@ void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te)
     }
   else
     {
-      pt_size = compute_iblock_size (te->chk_tree_depth - te->current_depth,
-                                     te->publish_offset); 
+      pt_size = GNUNET_FS_tree_compute_iblock_size (te->chk_tree_depth - te->current_depth,
+                                                    te->publish_offset); 
       pt_block = &te->chk_tree[te->current_depth *
                                CHK_PER_INODE];
     }
diff --git a/src/fs/fs_tree.h b/src/fs/fs_tree.h
index bfbd7019b..82b897bd3 100644
--- a/src/fs/fs_tree.h
+++ b/src/fs/fs_tree.h
@@ -144,6 +144,36 @@ void GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder * te,
                                     char **emsg);
 
 
+/**
+ * Compute the size of the current IBlock.
+ *
+ * @param height height of the IBlock in the tree (aka overall
+ *               number of tree levels minus depth); 0 == DBlock
+ * @param offset current offset in the overall file
+ * @return size of the corresponding IBlock
+ */
+uint16_t 
+GNUNET_FS_tree_compute_iblock_size (unsigned int height,
+                                    uint64_t offset);
+
+
+/**
+ * Compute how many bytes of data should be stored in
+ * the specified node.
+ *
+ * @param fsize overall file size
+ * @param totaldepth depth of the entire tree
+ * @param offset offset of the node
+ * @param depth depth of the node
+ * @return number of bytes stored in this node
+ */
+size_t
+GNUNET_FS_tree_calculate_block_size (uint64_t fsize,
+                                     unsigned int totaldepth,
+                                     uint64_t offset,
+                                     unsigned int depth);
+
+
 #if 0
 /* the functions below will be needed for persistence
    but are not yet implemented -- FIXME... */
diff --git a/src/fs/gnunet-service-fs_indexing.c b/src/fs/gnunet-service-fs_indexing.c
index 404199742..3095092b8 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -244,7 +244,7 @@ signal_index_ok (struct IndexInfo *ii)
                                          (void*) ii->filename,
                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _("Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
                   ii->filename,
                   (const char*) GNUNET_CONTAINER_multihashmap_get (ifm,
diff --git a/src/fs/test_fs_data.conf b/src/fs/test_fs_data.conf
index c5fd6ec0c..23c263702 100644
--- a/src/fs/test_fs_data.conf
+++ b/src/fs/test_fs_data.conf
@@ -12,12 +12,12 @@ HOSTNAME = localhost
 [transport]
 PORT = 42465
 PLUGINS = 
-DEBUG = YES
+#DEBUG = YES
 
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 #DEBUG = YES
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index af1fbfa50..f33a1bd4a 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -246,7 +246,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_download_data.conf b/src/fs/test_fs_download_data.conf
index 366a30844..cf84afb72 100644
--- a/src/fs/test_fs_download_data.conf
+++ b/src/fs/test_fs_download_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c
index ce704f500..58a3f3a82 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -207,7 +207,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_list_indexed_data.conf b/src/fs/test_fs_list_indexed_data.conf
index c2e76b5ae..6c3b024d3 100644
--- a/src/fs/test_fs_list_indexed_data.conf
+++ b/src/fs/test_fs_list_indexed_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 #DEBUG = YES
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 8e13b211d..b57f19bc9 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -77,7 +77,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
@@ -106,7 +105,6 @@ abort_ksk_search_task (void *cls,
       ksk_search = NULL;
       if (sks_search == NULL)
         {
-          fprintf (stderr, "initiating shutdown\n");
           GNUNET_FS_stop (fs);
         }
     }
@@ -128,7 +126,6 @@ abort_sks_search_task (void *cls,
   GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES));
   if (ksk_search == NULL)
     {
-      fprintf (stderr, "initiating shutdown\n");
       GNUNET_FS_stop (fs);
     }    
 }
diff --git a/src/fs/test_fs_namespace_data.conf b/src/fs/test_fs_namespace_data.conf
index 3b4ba5c70..349a9218a 100644
--- a/src/fs/test_fs_namespace_data.conf
+++ b/src/fs/test_fs_namespace_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index 6ea074807..2d664817c 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -196,7 +196,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_publish_data.conf b/src/fs/test_fs_publish_data.conf
index 147c8bc78..5bca3aeae 100644
--- a/src/fs/test_fs_publish_data.conf
+++ b/src/fs/test_fs_publish_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 #DEBUG = YES
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index 4320f965f..5f5f7f62a 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -198,7 +198,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_search_data.conf b/src/fs/test_fs_search_data.conf
index ce89cd8df..654754ffe 100644
--- a/src/fs/test_fs_search_data.conf
+++ b/src/fs/test_fs_search_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = peerinfo resolver datastore fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_fs_start_stop.c b/src/fs/test_fs_start_stop.c
index e11684b70..aa991d4a2 100644
--- a/src/fs/test_fs_start_stop.c
+++ b/src/fs/test_fs_start_stop.c
@@ -29,6 +29,8 @@
 #include "gnunet_arm_service.h"
 #include "gnunet_fs_service.h"
 
+#define VERBOSE GNUNET_NO
+
 #define START_ARM GNUNET_YES
 
 static struct GNUNET_SCHEDULER_Handle *sched;
@@ -65,7 +67,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c
index 2690fc0e1..3607144f3 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -204,7 +204,6 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
 }
 
 
diff --git a/src/fs/test_fs_unindex_data.conf b/src/fs/test_fs_unindex_data.conf
index 7f16af126..a92ff5bb7 100644
--- a/src/fs/test_fs_unindex_data.conf
+++ b/src/fs/test_fs_unindex_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 42466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core fs
+DEFAULTSERVICES = resolver datastore fs
 
 [datastore]
 #DEBUG = YES
diff --git a/src/fs/test_gnunet_fs_idx_data.conf b/src/fs/test_gnunet_fs_idx_data.conf
index 9cfeefc0d..2140e06b3 100644
--- a/src/fs/test_gnunet_fs_idx_data.conf
+++ b/src/fs/test_gnunet_fs_idx_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 46466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core statistics fs
+DEFAULTSERVICES = resolver datastore statistics fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_gnunet_fs_ns_data.conf b/src/fs/test_gnunet_fs_ns_data.conf
index 50b0d6406..7eef81b65 100644
--- a/src/fs/test_gnunet_fs_ns_data.conf
+++ b/src/fs/test_gnunet_fs_ns_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 47466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core statistics fs
+DEFAULTSERVICES = resolver datastore statistics fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_gnunet_fs_psd_data.conf b/src/fs/test_gnunet_fs_psd_data.conf
index 221137c14..52be58575 100644
--- a/src/fs/test_gnunet_fs_psd_data.conf
+++ b/src/fs/test_gnunet_fs_psd_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 45466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core statistics fs
+DEFAULTSERVICES = resolver datastore statistics fs
 
 [datastore]
 # DEBUG = YES
diff --git a/src/fs/test_gnunet_fs_rec_data.conf b/src/fs/test_gnunet_fs_rec_data.conf
index 93c5cffbc..7b758fc15 100644
--- a/src/fs/test_gnunet_fs_rec_data.conf
+++ b/src/fs/test_gnunet_fs_rec_data.conf
@@ -16,7 +16,7 @@ PLUGINS =
 [arm]
 PORT = 44466
 HOSTNAME = localhost
-DEFAULTSERVICES = resolver datastore transport core statistics fs
+DEFAULTSERVICES = resolver datastore statistics fs
 
 [datastore]
 # DEBUG = YES