Large refactor in order to restore some sanity with respect to private defines used in headers

46 files changed, 1963 insertions, 321 deletions

diff --git a/src/fs/Makefile.am b/src/fs/Makefile.am
index 56df4bfc7..7773c58ee 100644
--- a/src/fs/Makefile.am
+++ b/src/fs/Makefile.am
@@ -40,7 +40,8 @@ libgnunetfs_la_SOURCES = \
   fs_sharetree.c \
   fs_tree.c fs_tree.h \
   fs_unindex.c \
-  fs_uri.c
+  fs_uri.c \
+  meta_data.c
 
 libgnunetfs_la_LIBADD = \
   $(top_builddir)/src/datastore/libgnunetdatastore.la \
@@ -148,8 +149,9 @@ endif
 gnunet_helper_fs_publish_SOURCES =  \
  gnunet-helper-fs-publish.c
 gnunet_helper_fs_publish_LDADD =  \
- $(top_builddir)/src/util/libgnunetutil.la \
- $(GN_LIBINTL)
+  libgnunetfs.la \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(GN_LIBINTL)
 
 if HAVE_LIBEXTRACTOR
 gnunet_helper_fs_publish_LDADD += \
@@ -249,6 +251,7 @@ check_PROGRAMS = \
  test_fs_unindex \
  test_fs_unindex_persistence \
  test_fs_uri \
+ test_fs_meta_data \
  test_gnunet_service_fs_migration \
  test_gnunet_service_fs_p2p \
  test_gnunet_service_fs_p2p_cadet \
@@ -294,6 +297,7 @@ TESTS = \
  test_fs_unindex_persistence \
  test_fs_uri \
  test_fs_test_lib \
+ test_fs_meta_data \
  test_gnunet_service_fs_migration \
  test_gnunet_service_fs_p2p \
  test_gnunet_service_fs_p2p_cadet \
@@ -446,6 +450,13 @@ test_fs_unindex_persistence_LDADD = \
   libgnunetfs.la \
   $(top_builddir)/src/util/libgnunetutil.la
 
+test_fs_meta_data_SOURCES = \
+ test_fs_meta_data.c
+test_fs_meta_data_LDADD = \
+ libgnunetfs.la \
+ $(top_builddir)/src/util/libgnunetutil.la
+
+
 test_fs_uri_SOURCES = \
  test_fs_uri.c
 test_fs_uri_LDADD = \
@@ -520,7 +531,6 @@ perf_gnunet_service_fs_p2p_respect_LDADD = \
   libgnunetfs.la  \
   $(top_builddir)/src/util/libgnunetutil.la
 
-
 test_gnunet_fs_psd.py: test_gnunet_fs_psd.py.in Makefile
         $(AWK) -v bdir="$(bindir)" -v py="$(PYTHON)" -v awkay="$(AWK_BINARY)" -v pfx="$(prefix)" -v prl="$(PERL)" -v sysconfdirectory="$(sysconfdir)" -v pkgdatadirectory="$(pkgdatadir)" -f $(top_srcdir)/bin/dosubst.awk < $(srcdir)/test_gnunet_fs_psd.py.in > test_gnunet_fs_psd.py
         chmod +x test_gnunet_fs_psd.py
diff --git a/src/fs/fs.h b/src/fs/fs.h
index 4c433e774..920cf27b2 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -29,6 +29,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_datastore_service.h"
 #include "gnunet_dht_service.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_block_lib.h"
 #include "block_fs.h"
diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 6e97a3812..c786d660c 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -26,6 +26,7 @@
 
 #include "platform.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 #include "fs_tree.h"
@@ -902,7 +903,7 @@ deserialize_fi_node (struct GNUNET_FS_Handle *h,
   chks = NULL;
   skss = NULL;
   filename = NULL;
-  if ((GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "metadata", &ret->meta)) ||
+  if ((GNUNET_OK != GNUNET_FS_read_meta_data (rh, "metadata", &ret->meta)) ||
       (GNUNET_OK != GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32 * 1024)) ||
       ((NULL != ksks) &&
        ((NULL == (ret->keywords = GNUNET_FS_uri_parse (ksks, NULL))) ||
@@ -1370,7 +1371,7 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *fi)
     skss = NULL;
   struct GNUNET_BIO_WriteSpec ws1[] = {
     GNUNET_BIO_write_spec_object ("b", &b, sizeof (b)),
-    GNUNET_BIO_write_spec_meta_data ("meta", fi->meta),
+    GNUNET_FS_write_spec_meta_data ("meta", fi->meta),
     GNUNET_BIO_write_spec_string ("ksks", ksks),
     GNUNET_BIO_write_spec_string ("chks", chks),
     GNUNET_BIO_write_spec_string ("skss", skss),
@@ -1571,7 +1572,7 @@ static int
 fip_signal_resume (void *cls,
                    struct GNUNET_FS_FileInformation *fi,
                    uint64_t length,
-                   struct GNUNET_CONTAINER_MetaData *meta,
+                   struct GNUNET_FS_MetaData *meta,
                    struct GNUNET_FS_Uri **uri,
                    struct GNUNET_FS_BlockOptions *bo,
                    int *do_index,
@@ -2081,7 +2082,7 @@ GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc)
   uris = GNUNET_FS_uri_to_string (dc->uri);
   struct GNUNET_BIO_WriteSpec ws1[] = {
     GNUNET_BIO_write_spec_string ("uris", uris),
-    GNUNET_BIO_write_spec_meta_data ("metadata", dc->meta),
+    GNUNET_FS_write_spec_meta_data ("metadata", dc->meta),
     GNUNET_BIO_write_spec_string ("emsg", dc->emsg),
     GNUNET_BIO_write_spec_string ("filename", dc->filename),
     GNUNET_BIO_write_spec_string ("temp filename", dc->temp_filename),
@@ -2184,7 +2185,7 @@ GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
                                   (sr->update_search != NULL)
                                   ? sr->update_search->serialization
                                   : NULL),
-    GNUNET_BIO_write_spec_meta_data ("metadata", sr->meta),
+    GNUNET_FS_write_spec_meta_data ("metadata", sr->meta),
     GNUNET_BIO_write_spec_object ("key", &sr->key,
                                   sizeof(struct GNUNET_HashCode)),
     GNUNET_BIO_write_spec_int32 ("mandatory missing",
@@ -2558,7 +2559,7 @@ deserialize_search_result (void *cls, const char *filename)
        GNUNET_BIO_read_string (rh, "download-lnk", &download, 16)) ||
       (GNUNET_OK !=
        GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
-      (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "result-meta", &sr->meta)) ||
+      (GNUNET_OK != GNUNET_FS_read_meta_data (rh, "result-meta", &sr->meta)) ||
       (GNUNET_OK != GNUNET_BIO_read (rh,
                                      "result-key",
                                      &sr->key,
@@ -2655,7 +2656,7 @@ cleanup:
   if (NULL != sr->uri)
     GNUNET_FS_uri_destroy (sr->uri);
   if (NULL != sr->meta)
-    GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+    GNUNET_FS_meta_data_destroy (sr->meta);
   GNUNET_free (sr->serialization);
   GNUNET_free (sr);
   if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
@@ -2778,7 +2779,7 @@ free_result (void *cls, const struct GNUNET_HashCode *key, void *value)
     free_search_context (sr->update_search);
     GNUNET_assert (NULL == sr->update_search);
   }
-  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_FS_meta_data_destroy (sr->meta);
   GNUNET_FS_uri_destroy (sr->uri);
   GNUNET_free (sr);
   return GNUNET_YES;
@@ -2876,7 +2877,7 @@ free_download_context (struct GNUNET_FS_DownloadContext *dc)
   struct GNUNET_FS_DownloadContext *dcc;
 
   if (NULL != dc->meta)
-    GNUNET_CONTAINER_meta_data_destroy (dc->meta);
+    GNUNET_FS_meta_data_destroy (dc->meta);
   if (NULL != dc->uri)
     GNUNET_FS_uri_destroy (dc->uri);
   GNUNET_free (dc->temp_filename);
@@ -2925,7 +2926,7 @@ deserialize_download (struct GNUNET_FS_Handle *h,
   dc->h = h;
   dc->serialization = GNUNET_strdup (serialization);
   struct GNUNET_BIO_ReadSpec rs[] = {
-    GNUNET_BIO_read_spec_meta_data ("download-meta", &dc->meta),
+    GNUNET_FS_read_spec_meta_data ("download-meta", &dc->meta),
     GNUNET_BIO_read_spec_string ("download-emsg", &dc->emsg, 10 * 1024),
     GNUNET_BIO_read_spec_string ("download-fn", &dc->filename, 10 * 1024),
     GNUNET_BIO_read_spec_string ("download-tfn",
diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index 7c0c58bff..9c9ce0f24 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -29,6 +29,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_datastore_service.h"
 #include "gnunet_dht_service.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_block_lib.h"
 #include "block_fs.h"
@@ -249,7 +250,7 @@ struct GNUNET_FS_FileInformation
   /**
    * Metadata to use for the file.
    */
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
 
   /**
    * Keywords to use for KBlocks.
@@ -525,7 +526,7 @@ struct GNUNET_FS_SearchResult
   /**
    * Metadata for the search result.
    */
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
 
   /**
    * Client info for this search result.
@@ -1801,7 +1802,7 @@ struct GNUNET_FS_DownloadContext
   /**
    * Known meta-data for the file (can be NULL).
    */
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
 
   /**
    * Error message, NULL if we're doing OK.
diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index eb7aac5bb..e53b2dc11 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -33,6 +33,7 @@
  *   into memory
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 
@@ -52,15 +53,15 @@
  */
 int
 GNUNET_FS_meta_data_test_for_directory (const struct
-                                        GNUNET_CONTAINER_MetaData *md)
+                                        GNUNET_FS_MetaData *md)
 {
   char *mime;
   int ret;
 
   if (NULL == md)
     return GNUNET_SYSERR;
-  mime = GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                                 EXTRACTOR_METATYPE_MIMETYPE);
+  mime = GNUNET_FS_meta_data_get_by_type (md,
+                                          EXTRACTOR_METATYPE_MIMETYPE);
   if (NULL == mime)
     return GNUNET_SYSERR;
   ret = (0 == strcasecmp (mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES :
@@ -77,19 +78,19 @@ GNUNET_FS_meta_data_test_for_directory (const struct
  * @param md metadata to add mimetype to
  */
 void
-GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_FS_meta_data_make_directory (struct GNUNET_FS_MetaData *md)
 {
   char *mime;
 
   mime =
-    GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
+    GNUNET_FS_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime != NULL)
   {
     GNUNET_break (0 == strcmp (mime, GNUNET_FS_DIRECTORY_MIME));
     GNUNET_free (mime);
     return;
   }
-  GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
+  GNUNET_FS_meta_data_insert (md, "<gnunet>",
                                      EXTRACTOR_METATYPE_MIMETYPE,
                                      EXTRACTOR_METAFORMAT_UTF8, "text/plain",
                                      GNUNET_FS_DIRECTORY_MIME,
@@ -192,7 +193,7 @@ GNUNET_FS_directory_list_contents (size_t size,
   uint32_t mdSize;
   uint64_t epos;
   struct GNUNET_FS_Uri *uri;
-  struct GNUNET_CONTAINER_MetaData *md;
+  struct GNUNET_FS_MetaData *md;
   char *filename;
 
   if ((offset == 0) &&
@@ -215,8 +216,8 @@ GNUNET_FS_directory_list_contents (size_t size,
                   _ ("MAGIC mismatch.  This is not a GNUnet directory.\n"));
       return GNUNET_SYSERR;
     }
-    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[8 + sizeof(uint32_t)],
-                                                 mdSize);
+    md = GNUNET_FS_meta_data_deserialize (&cdata[8 + sizeof(uint32_t)],
+                                          mdSize);
     if (md == NULL)
     {
       GNUNET_break (0);
@@ -228,7 +229,7 @@ GNUNET_FS_directory_list_contents (size_t size,
          md,
          0,
          NULL);
-    GNUNET_CONTAINER_meta_data_destroy (md);
+    GNUNET_FS_meta_data_destroy (md);
     pos = 8 + sizeof(uint32_t) + mdSize;
   }
   while (pos < size)
@@ -283,7 +284,7 @@ GNUNET_FS_directory_list_contents (size_t size,
       return GNUNET_NO;         /* malformed - or partial download */
     }
 
-    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos],
+    md = GNUNET_FS_meta_data_deserialize (&cdata[pos],
                                                  mdSize);
     if (NULL == md)
     {
@@ -293,11 +294,11 @@ GNUNET_FS_directory_list_contents (size_t size,
     }
     pos += mdSize;
     filename =
-      GNUNET_CONTAINER_meta_data_get_by_type (md,
+      GNUNET_FS_meta_data_get_by_type (md,
                                               EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
     full_data.size = 0;
     full_data.data = NULL;
-    GNUNET_CONTAINER_meta_data_iterate (md,
+    GNUNET_FS_meta_data_iterate (md,
                                         &find_full_data,
                                         &full_data);
     if (NULL != dep)
@@ -311,7 +312,7 @@ GNUNET_FS_directory_list_contents (size_t size,
     }
     GNUNET_free (full_data.data);
     GNUNET_free (filename);
-    GNUNET_CONTAINER_meta_data_destroy (md);
+    GNUNET_FS_meta_data_destroy (md);
     GNUNET_FS_uri_destroy (uri);
   }
   return GNUNET_OK;
@@ -342,7 +343,7 @@ struct GNUNET_FS_DirectoryBuilder
   /**
    * Meta-data for the directory itself.
    */
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
 
   /**
    * Head of linked list of entries.
@@ -362,16 +363,16 @@ struct GNUNET_FS_DirectoryBuilder
  * @param mdir metadata for the directory
  */
 struct GNUNET_FS_DirectoryBuilder *
-GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData
+GNUNET_FS_directory_builder_create (const struct GNUNET_FS_MetaData
                                     *mdir)
 {
   struct GNUNET_FS_DirectoryBuilder *ret;
 
   ret = GNUNET_new (struct GNUNET_FS_DirectoryBuilder);
   if (mdir != NULL)
-    ret->meta = GNUNET_CONTAINER_meta_data_duplicate (mdir);
+    ret->meta = GNUNET_FS_meta_data_duplicate (mdir);
   else
-    ret->meta = GNUNET_CONTAINER_meta_data_create ();
+    ret->meta = GNUNET_FS_meta_data_create ();
   GNUNET_FS_meta_data_make_directory (ret->meta);
   return ret;
 }
@@ -390,7 +391,7 @@ GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData
 void
 GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
                                  const struct GNUNET_FS_Uri *uri,
-                                 const struct GNUNET_CONTAINER_MetaData *md,
+                                 const struct GNUNET_FS_MetaData *md,
                                  const void *data)
 {
   struct GNUNET_FS_Uri *curi;
@@ -404,8 +405,8 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   char *serialized;
   char *sptr;
   size_t slen;
-  struct GNUNET_CONTAINER_MetaData *meta;
-  const struct GNUNET_CONTAINER_MetaData *meta_use;
+  struct GNUNET_FS_MetaData *meta;
+  const struct GNUNET_FS_MetaData *meta_use;
 
   GNUNET_assert (! GNUNET_FS_uri_test_ksk (uri));
   if (NULL != data)
@@ -431,17 +432,17 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
     fsize = 0;                  /* too large */
   uris = GNUNET_FS_uri_to_string (uri);
   slen = strlen (uris) + 1;
-  mds = GNUNET_CONTAINER_meta_data_get_serialized_size (md);
+  mds = GNUNET_FS_meta_data_get_serialized_size (md);
   meta_use = md;
   meta = NULL;
   if (fsize > 0)
   {
-    meta = GNUNET_CONTAINER_meta_data_duplicate (md);
-    GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>",
+    meta = GNUNET_FS_meta_data_duplicate (md);
+    GNUNET_FS_meta_data_insert (meta, "<gnunet>",
                                        EXTRACTOR_METATYPE_GNUNET_FULL_DATA,
                                        EXTRACTOR_METAFORMAT_BINARY, NULL, data,
                                        fsize);
-    mdxs = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
+    mdxs = GNUNET_FS_meta_data_get_serialized_size (meta);
     if ((slen + sizeof(uint32_t) + mdxs - 1) / DBLOCK_SIZE ==
         (slen + sizeof(uint32_t) + mds - 1) / DBLOCK_SIZE)
     {
@@ -461,10 +462,10 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   GNUNET_free (uris);
   sptr = &serialized[slen + sizeof(uint32_t)];
   ret =
-    GNUNET_CONTAINER_meta_data_serialize (meta_use, &sptr, mds,
-                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+    GNUNET_FS_meta_data_serialize (meta_use, &sptr, mds,
+                                          GNUNET_FS_META_DATA_SERIALIZE_PART);
   if (NULL != meta)
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_destroy (meta);
   if (ret == -1)
     mds = 0;
   else
@@ -593,7 +594,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   uint32_t big;
 
   size = strlen (GNUNET_DIRECTORY_MAGIC) + sizeof(uint32_t);
-  size += GNUNET_CONTAINER_meta_data_get_serialized_size (bld->meta);
+  size += GNUNET_FS_meta_data_get_serialized_size (bld->meta);
   sizes = NULL;
   perm = NULL;
   bes = NULL;
@@ -643,10 +644,10 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
 
   sptr = &data[off + sizeof(uint32_t)];
   ret =
-    GNUNET_CONTAINER_meta_data_serialize (bld->meta,
+    GNUNET_FS_meta_data_serialize (bld->meta,
                                           &sptr,
                                           size - off - sizeof(uint32_t),
-                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+                                          GNUNET_FS_META_DATA_SERIALIZE_FULL);
   GNUNET_assert (ret != -1);
   big = htonl (ret);
   GNUNET_memcpy (&data[off],
@@ -666,7 +667,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   GNUNET_free (perm);
   GNUNET_free (bes);
   GNUNET_assert (off == size);
-  GNUNET_CONTAINER_meta_data_destroy (bld->meta);
+  GNUNET_FS_meta_data_destroy (bld->meta);
   GNUNET_free (bld);
   return GNUNET_OK;
 }
diff --git a/src/fs/fs_dirmetascan.c b/src/fs/fs_dirmetascan.c
index 8dd216324..3990a2521 100644
--- a/src/fs/fs_dirmetascan.c
+++ b/src/fs/fs_dirmetascan.c
@@ -26,6 +26,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_scheduler_lib.h"
 #include <pthread.h>
@@ -359,26 +360,26 @@ process_helper_msgs (void *cls, const struct GNUNET_MessageHeader *msg)
                              GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED);
       if (0 < left)
       {
-        ds->pos->meta = GNUNET_CONTAINER_meta_data_deserialize (end, left);
+        ds->pos->meta = GNUNET_FS_meta_data_deserialize (end, left);
         if (NULL == ds->pos->meta)
         {
           GNUNET_break (0);
           break;
         }
         /* having full filenames is too dangerous; always make sure we clean them up */
-        GNUNET_CONTAINER_meta_data_delete (ds->pos->meta,
-                                           EXTRACTOR_METATYPE_FILENAME,
-                                           NULL,
-                                           0);
+        GNUNET_FS_meta_data_delete (ds->pos->meta,
+                                    EXTRACTOR_METATYPE_FILENAME,
+                                    NULL,
+                                    0);
         /* instead, put in our 'safer' original filename */
-        GNUNET_CONTAINER_meta_data_insert (ds->pos->meta,
-                                           "<libgnunetfs>",
-                                           EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                           EXTRACTOR_METAFORMAT_UTF8,
-                                           "text/plain",
-                                           ds->pos->short_filename,
-                                           strlen (ds->pos->short_filename)
-                                           + 1);
+        GNUNET_FS_meta_data_insert (ds->pos->meta,
+                                    "<libgnunetfs>",
+                                    EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                    EXTRACTOR_METAFORMAT_UTF8,
+                                    "text/plain",
+                                    ds->pos->short_filename,
+                                    strlen (ds->pos->short_filename)
+                                    + 1);
       }
       ds->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_meta_data (
         ds->pos->meta);
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index 102b297c1..73e12acb1 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -24,6 +24,7 @@
  */
 #include "platform.h"
 #include "gnunet_constants.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 #include "fs_tree.h"
@@ -280,7 +281,7 @@ static void
 trigger_recursive_download (void *cls,
                             const char *filename,
                             const struct GNUNET_FS_Uri *uri,
-                            const struct GNUNET_CONTAINER_MetaData *meta,
+                            const struct GNUNET_FS_MetaData *meta,
                             size_t length,
                             const void *data);
 
@@ -850,7 +851,7 @@ static void
 trigger_recursive_download (void *cls,
                             const char *filename,
                             const struct GNUNET_FS_Uri *uri,
-                            const struct GNUNET_CONTAINER_MetaData *meta,
+                            const struct GNUNET_FS_MetaData *meta,
                             size_t length,
                             const void *data)
 {
@@ -968,7 +969,7 @@ trigger_recursive_download (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Triggering recursive download of size %llu with %u bytes MD\n",
               (unsigned long long) GNUNET_FS_uri_chk_get_file_size (uri),
-              (unsigned int) GNUNET_CONTAINER_meta_data_get_serialized_size (
+              (unsigned int) GNUNET_FS_meta_data_get_serialized_size (
                 meta));
   GNUNET_FS_download_start (dc->h,
                             uri,
@@ -1907,8 +1908,8 @@ GNUNET_FS_download_start_task_ (void *cls)
       GNUNET_ERROR_TYPE_DEBUG,
       "Trying to find embedded meta data for download of size %llu with %u bytes MD\n",
       (unsigned long long) GNUNET_FS_uri_chk_get_file_size (dc->uri),
-      (unsigned int) GNUNET_CONTAINER_meta_data_get_serialized_size (dc->meta));
-    GNUNET_CONTAINER_meta_data_iterate (dc->meta, &match_full_data, dc);
+      (unsigned int) GNUNET_FS_meta_data_get_serialized_size (dc->meta));
+    GNUNET_FS_meta_data_iterate (dc->meta, &match_full_data, dc);
     if (BRS_DOWNLOAD_UP == dc->top_request->state)
     {
       if (NULL != dc->rfh)
@@ -1996,7 +1997,7 @@ GNUNET_FS_download_signal_suspend_ (void *cls)
     dc->active = NULL;
   }
   GNUNET_free (dc->filename);
-  GNUNET_CONTAINER_meta_data_destroy (dc->meta);
+  GNUNET_FS_meta_data_destroy (dc->meta);
   GNUNET_FS_uri_destroy (dc->uri);
   GNUNET_free (dc->temp_filename);
   GNUNET_free (dc->serialization);
@@ -2027,7 +2028,7 @@ GNUNET_FS_download_signal_suspend_ (void *cls)
 struct GNUNET_FS_DownloadContext *
 create_download_context (struct GNUNET_FS_Handle *h,
                          const struct GNUNET_FS_Uri *uri,
-                         const struct GNUNET_CONTAINER_MetaData *meta,
+                         const struct GNUNET_FS_MetaData *meta,
                          const char *filename,
                          const char *tempname,
                          uint64_t offset,
@@ -2053,7 +2054,7 @@ create_download_context (struct GNUNET_FS_Handle *h,
               (unsigned long long) offset);
   dc->h = h;
   dc->uri = GNUNET_FS_uri_dup (uri);
-  dc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  dc->meta = GNUNET_FS_meta_data_duplicate (meta);
   dc->client_info = cctx;
   dc->start_time = GNUNET_TIME_absolute_get ();
   if (NULL != filename)
@@ -2098,7 +2099,7 @@ create_download_context (struct GNUNET_FS_Handle *h,
 struct GNUNET_FS_DownloadContext *
 GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
                           const struct GNUNET_FS_Uri *uri,
-                          const struct GNUNET_CONTAINER_MetaData *meta,
+                          const struct GNUNET_FS_MetaData *meta,
                           const char *filename,
                           const char *tempname,
                           uint64_t offset,
@@ -2319,7 +2320,7 @@ GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc, int do_delete)
     }
     GNUNET_free (dc->filename);
   }
-  GNUNET_CONTAINER_meta_data_destroy (dc->meta);
+  GNUNET_FS_meta_data_destroy (dc->meta);
   GNUNET_FS_uri_destroy (dc->uri);
   if (NULL != dc->temp_filename)
   {
diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index dc5db9d3f..f23b9da2a 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -57,7 +57,8 @@ GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s)
  * @return "filename" field of the structure (can be NULL)
  */
 const char *
-GNUNET_FS_file_information_get_filename (const struct GNUNET_FS_FileInformation *s)
+GNUNET_FS_file_information_get_filename (const struct
+                                         GNUNET_FS_FileInformation *s)
 {
   return s->filename;
 }
@@ -89,7 +90,7 @@ GNUNET_FS_file_information_create_from_file (
   void *client_info,
   const char *filename,
   const struct GNUNET_FS_Uri *keywords,
-  const struct GNUNET_CONTAINER_MetaData *meta,
+  const struct GNUNET_FS_MetaData *meta,
   int do_index,
   const struct GNUNET_FS_BlockOptions *bo)
 {
@@ -132,13 +133,13 @@ GNUNET_FS_file_information_create_from_file (
 /* FIXME: If we assume that on other platforms CRT is UTF-8-aware, then
  * this should be changed to EXTRACTOR_METAFORMAT_UTF8
  */
-  GNUNET_CONTAINER_meta_data_insert (ret->meta,
-                                     "<gnunet>",
-                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                     EXTRACTOR_METAFORMAT_C_STRING,
-                                     "text/plain",
-                                     fn,
-                                     strlen (fn) + 1);
+  GNUNET_FS_meta_data_insert (ret->meta,
+                              "<gnunet>",
+                              EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                              EXTRACTOR_METAFORMAT_C_STRING,
+                              "text/plain",
+                              fn,
+                              strlen (fn) + 1);
   return ret;
 }
 
@@ -150,7 +151,7 @@ GNUNET_FS_file_information_create_from_data (
   uint64_t length,
   void *data,
   const struct GNUNET_FS_Uri *keywords,
-  const struct GNUNET_CONTAINER_MetaData *meta,
+  const struct GNUNET_FS_MetaData *meta,
   int do_index,
   const struct GNUNET_FS_BlockOptions *bo)
 {
@@ -180,7 +181,7 @@ GNUNET_FS_file_information_create_from_reader (
   GNUNET_FS_DataReader reader,
   void *reader_cls,
   const struct GNUNET_FS_Uri *keywords,
-  const struct GNUNET_CONTAINER_MetaData *meta,
+  const struct GNUNET_FS_MetaData *meta,
   int do_index,
   const struct GNUNET_FS_BlockOptions *bo)
 {
@@ -194,9 +195,9 @@ GNUNET_FS_file_information_create_from_reader (
   ret = GNUNET_new (struct GNUNET_FS_FileInformation);
   ret->h = h;
   ret->client_info = client_info;
-  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  ret->meta = GNUNET_FS_meta_data_duplicate (meta);
   if (ret->meta == NULL)
-    ret->meta = GNUNET_CONTAINER_meta_data_create ();
+    ret->meta = GNUNET_FS_meta_data_create ();
   ret->keywords = (keywords == NULL) ? NULL : GNUNET_FS_uri_dup (keywords);
   ret->data.file.reader = reader;
   ret->data.file.reader_cls = reader_cls;
@@ -226,7 +227,7 @@ GNUNET_FS_file_information_create_empty_directory (
   struct GNUNET_FS_Handle *h,
   void *client_info,
   const struct GNUNET_FS_Uri *keywords,
-  const struct GNUNET_CONTAINER_MetaData *meta,
+  const struct GNUNET_FS_MetaData *meta,
   const struct GNUNET_FS_BlockOptions *bo,
   const char *filename)
 {
@@ -235,7 +236,7 @@ GNUNET_FS_file_information_create_empty_directory (
   ret = GNUNET_new (struct GNUNET_FS_FileInformation);
   ret->h = h;
   ret->client_info = client_info;
-  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  ret->meta = GNUNET_FS_meta_data_duplicate (meta);
   ret->keywords = GNUNET_FS_uri_dup (keywords);
   ret->bo = *bo;
   ret->is_directory = GNUNET_YES;
@@ -392,7 +393,7 @@ GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi,
   if (NULL != fi->keywords)
     GNUNET_FS_uri_destroy (fi->keywords);
   if (NULL != fi->meta)
-    GNUNET_CONTAINER_meta_data_destroy (fi->meta);
+    GNUNET_FS_meta_data_destroy (fi->meta);
   GNUNET_free (fi->serialization);
   if (NULL != fi->te)
   {
diff --git a/src/fs/fs_getopt.c b/src/fs/fs_getopt.c
index 945883a45..186963bba 100644
--- a/src/fs/fs_getopt.c
+++ b/src/fs/fs_getopt.c
@@ -24,6 +24,7 @@
  * @author Igor Wronsky, Christian Grothoff
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 
@@ -163,20 +164,20 @@ getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
                      const char *option,
                      const char *value)
 {
-  struct GNUNET_CONTAINER_MetaData **mm = scls;
+  struct GNUNET_FS_MetaData **mm = scls;
 
 #if HAVE_EXTRACTOR_H && HAVE_LIBEXTRACTOR
   enum EXTRACTOR_MetaType type;
   const char *typename;
   const char *typename_i18n;
 #endif
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   char *tmp;
 
   meta = *mm;
   if (meta == NULL)
   {
-    meta = GNUNET_CONTAINER_meta_data_create ();
+    meta = GNUNET_FS_meta_data_create ();
     *mm = meta;
   }
 
@@ -196,12 +197,12 @@ getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
         (tmp[strlen (typename)] == ':') &&
         (0 == strncmp (typename, tmp, strlen (typename))))
     {
-      GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>", type,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         &tmp[strlen (typename) + 1],
-                                         strlen (&tmp[strlen (typename) + 1])
-                                         + 1);
+      GNUNET_FS_meta_data_insert (meta, "<gnunet>", type,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain",
+                                  &tmp[strlen (typename) + 1],
+                                  strlen (&tmp[strlen (typename) + 1])
+                                  + 1);
       GNUNET_free (tmp);
       tmp = NULL;
       break;
@@ -210,13 +211,13 @@ getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
         (tmp[strlen (typename_i18n)] == ':') &&
         (0 == strncmp (typename_i18n, tmp, strlen (typename_i18n))))
     {
-      GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>", type,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         &tmp[strlen (typename_i18n) + 1],
-                                         strlen (&tmp
-                                                 [strlen (typename_i18n) + 1])
-                                         + 1);
+      GNUNET_FS_meta_data_insert (meta, "<gnunet>", type,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain",
+                                  &tmp[strlen (typename_i18n) + 1],
+                                  strlen (&tmp
+                                          [strlen (typename_i18n) + 1])
+                                  + 1);
       GNUNET_free (tmp);
       tmp = NULL;
       break;
@@ -226,10 +227,10 @@ getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
 
   if (NULL != tmp)
   {
-    GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>",
-                                       EXTRACTOR_METATYPE_UNKNOWN,
-                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                       tmp, strlen (tmp) + 1);
+    GNUNET_FS_meta_data_insert (meta, "<gnunet>",
+                                EXTRACTOR_METATYPE_UNKNOWN,
+                                EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                tmp, strlen (tmp) + 1);
     GNUNET_free (tmp);
     printf (_
             (
@@ -254,7 +255,7 @@ GNUNET_FS_GETOPT_METADATA (char shortName,
                            const char *name,
                            const char *argumentHelp,
                            const char *description,
-                           struct GNUNET_CONTAINER_MetaData **meta)
+                           struct GNUNET_FS_MetaData **meta)
 {
   struct GNUNET_GETOPT_CommandLineOption clo = {
     .shortName = shortName,
diff --git a/src/fs/fs_list_indexed.c b/src/fs/fs_list_indexed.c
index eaee4ce55..7d30933dd 100644
--- a/src/fs/fs_list_indexed.c
+++ b/src/fs/fs_list_indexed.c
@@ -26,6 +26,7 @@
 
 #include "platform.h"
 #include "gnunet_constants.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_protocols.h"
 #include "fs_api.h"
diff --git a/src/fs/fs_misc.c b/src/fs/fs_misc.c
index 2e7816d65..3ae82a82e 100644
--- a/src/fs/fs_misc.c
+++ b/src/fs/fs_misc.c
@@ -24,6 +24,7 @@
  */
 #include "platform.h"
 #include "gnunet_constants.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 
@@ -35,7 +36,7 @@
  * @return NULL if meta data is useless for suggesting a filename
  */
 char *
-GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData
+GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_FS_MetaData
                                       *md)
 {
   static const char *mimeMap[][2] = {
@@ -111,13 +112,13 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData
   const char *ext;
 
   ret =
-    GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                            EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    GNUNET_FS_meta_data_get_by_type (md,
+                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (ret != NULL)
     return ret;
   ext = NULL;
   mime =
-    GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
+    GNUNET_FS_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime != NULL)
   {
     i = 0;
@@ -131,24 +132,24 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData
     GNUNET_free (mime);
   }
   base =
-    GNUNET_CONTAINER_meta_data_get_first_by_types (md,
-                                                   EXTRACTOR_METATYPE_TITLE,
-                                                   EXTRACTOR_METATYPE_BOOK_TITLE,
-                                                   EXTRACTOR_METATYPE_ORIGINAL_TITLE,
-                                                   EXTRACTOR_METATYPE_PACKAGE_NAME,
-                                                   EXTRACTOR_METATYPE_URL,
-                                                   EXTRACTOR_METATYPE_URI,
-                                                   EXTRACTOR_METATYPE_DESCRIPTION,
-                                                   EXTRACTOR_METATYPE_ISRC,
-                                                   EXTRACTOR_METATYPE_JOURNAL_NAME,
-                                                   EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                                   EXTRACTOR_METATYPE_SUBJECT,
-                                                   EXTRACTOR_METATYPE_ALBUM,
-                                                   EXTRACTOR_METATYPE_ARTIST,
-                                                   EXTRACTOR_METATYPE_KEYWORDS,
-                                                   EXTRACTOR_METATYPE_COMMENT,
-                                                   EXTRACTOR_METATYPE_UNKNOWN,
-                                                   -1);
+    GNUNET_FS_meta_data_get_first_by_types (md,
+                                            EXTRACTOR_METATYPE_TITLE,
+                                            EXTRACTOR_METATYPE_BOOK_TITLE,
+                                            EXTRACTOR_METATYPE_ORIGINAL_TITLE,
+                                            EXTRACTOR_METATYPE_PACKAGE_NAME,
+                                            EXTRACTOR_METATYPE_URL,
+                                            EXTRACTOR_METATYPE_URI,
+                                            EXTRACTOR_METATYPE_DESCRIPTION,
+                                            EXTRACTOR_METATYPE_ISRC,
+                                            EXTRACTOR_METATYPE_JOURNAL_NAME,
+                                            EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                            EXTRACTOR_METATYPE_SUBJECT,
+                                            EXTRACTOR_METATYPE_ALBUM,
+                                            EXTRACTOR_METATYPE_ARTIST,
+                                            EXTRACTOR_METATYPE_KEYWORDS,
+                                            EXTRACTOR_METATYPE_COMMENT,
+                                            EXTRACTOR_METATYPE_UNKNOWN,
+                                            -1);
   if ((base == NULL) && (ext == NULL))
     return NULL;
   if (base == NULL)
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index bc94dd1fc..b3eeeb23c 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -28,6 +28,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_signatures.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 #include "fs_publish_ublock.h"
@@ -52,7 +53,7 @@ struct NamespaceUpdateNode
   /**
    * Metadata for this entry.
    */
-  struct GNUNET_CONTAINER_MetaData *md;
+  struct GNUNET_FS_MetaData *md;
 
   /**
    * URI of this entry in the namespace.
@@ -167,7 +168,7 @@ free_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
   for (i = 0; i < uig->update_node_count; i++)
   {
     nsn = uig->update_nodes[i];
-    GNUNET_CONTAINER_meta_data_destroy (nsn->md);
+    GNUNET_FS_meta_data_destroy (nsn->md);
     GNUNET_FS_uri_destroy (nsn->uri);
     GNUNET_free (nsn->id);
     GNUNET_free (nsn->update);
@@ -215,7 +216,7 @@ write_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
     uris = GNUNET_FS_uri_to_string (n->uri);
     struct GNUNET_BIO_WriteSpec ws[] = {
       GNUNET_BIO_write_spec_string ("fs-namespace-node-id", n->id),
-      GNUNET_BIO_write_spec_meta_data ("fs-namespace-node-meta", n->md),
+      GNUNET_FS_write_spec_meta_data ("fs-namespace-node-meta", n->md),
       GNUNET_BIO_write_spec_string ("fs-namespace-node-update", n->update),
       GNUNET_BIO_write_spec_string ("fs-namespace-uris", uris),
       GNUNET_BIO_write_spec_end (),
@@ -227,7 +228,7 @@ write_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
     }
     GNUNET_free (uris);
   }
-END:
+  END:
   if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to write `%s': %s\n"),
@@ -293,7 +294,7 @@ read_update_information_graph (struct GNUNET_FS_Handle *h,
     n = GNUNET_new (struct NamespaceUpdateNode);
     struct GNUNET_BIO_ReadSpec rs[] = {
       GNUNET_BIO_read_spec_string ("identifier", &n->id, 1024),
-      GNUNET_BIO_read_spec_meta_data ("meta", &n->md),
+      GNUNET_FS_read_spec_meta_data ("meta", &n->md),
       GNUNET_BIO_read_spec_string ("update-id", &n->update, 1024),
       GNUNET_BIO_read_spec_string ("uri", &uris, 1024 * 2),
       GNUNET_BIO_read_spec_end (),
@@ -304,7 +305,7 @@ read_update_information_graph (struct GNUNET_FS_Handle *h,
       GNUNET_free (n->id);
       GNUNET_free (n->update);
       if (n->md != NULL)
-        GNUNET_CONTAINER_meta_data_destroy (n->md);
+        GNUNET_FS_meta_data_destroy (n->md);
       GNUNET_free (n);
       break;
     }
@@ -316,14 +317,14 @@ read_update_information_graph (struct GNUNET_FS_Handle *h,
       GNUNET_free (emsg);
       GNUNET_free (n->id);
       GNUNET_free (n->update);
-      GNUNET_CONTAINER_meta_data_destroy (n->md);
+      GNUNET_FS_meta_data_destroy (n->md);
       GNUNET_free (n);
       break;
     }
     uig->update_nodes[i] = n;
   }
   uig->update_node_count = i;
-END:
+  END:
   if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -428,7 +429,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
                        const char *identifier,
                        const char *update,
-                       const struct GNUNET_CONTAINER_MetaData *meta,
+                       const struct GNUNET_FS_MetaData *meta,
                        const struct GNUNET_FS_Uri *uri,
                        const struct GNUNET_FS_BlockOptions *bo,
                        enum GNUNET_FS_PublishOptions options,
@@ -463,7 +464,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
     psc->nsn = GNUNET_new (struct NamespaceUpdateNode);
     psc->nsn->id = GNUNET_strdup (identifier);
     psc->nsn->update = GNUNET_strdup (update);
-    psc->nsn->md = GNUNET_CONTAINER_meta_data_duplicate (meta);
+    psc->nsn->md = GNUNET_FS_meta_data_duplicate (meta);
     psc->nsn->uri = GNUNET_FS_uri_dup (uri);
   }
   psc->uc = GNUNET_FS_publish_ublock_ (h,
@@ -502,7 +503,7 @@ GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
   GNUNET_FS_uri_destroy (psc->uri);
   if (NULL != psc->nsn)
   {
-    GNUNET_CONTAINER_meta_data_destroy (psc->nsn->md);
+    GNUNET_FS_meta_data_destroy (psc->nsn->md);
     GNUNET_FS_uri_destroy (psc->nsn->uri);
     GNUNET_free (psc->nsn->id);
     GNUNET_free (psc->nsn->update);
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 5cdf8f6e8..bd533fcfb 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -28,6 +28,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_signatures.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 #include "fs_tree.h"
@@ -1098,8 +1099,8 @@ GNUNET_FS_publish_main_ (void *cls)
      * related files as well! */
     while (NULL != p->dir)
     {
-      fn = GNUNET_CONTAINER_meta_data_get_by_type (p->meta,
-                                                   EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+      fn = GNUNET_FS_meta_data_get_by_type (p->meta,
+                                            EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
       p = p->dir;
       if (fn != NULL)
       {
@@ -1193,7 +1194,7 @@ static int
 fip_signal_start (void *cls,
                   struct GNUNET_FS_FileInformation *fi,
                   uint64_t length,
-                  struct GNUNET_CONTAINER_MetaData *meta,
+                  struct GNUNET_FS_MetaData *meta,
                   struct GNUNET_FS_Uri **uri,
                   struct GNUNET_FS_BlockOptions *bo,
                   int *do_index,
@@ -1319,7 +1320,7 @@ static int
 fip_signal_suspend (void *cls,
                     struct GNUNET_FS_FileInformation *fi,
                     uint64_t length,
-                    struct GNUNET_CONTAINER_MetaData *meta,
+                    struct GNUNET_FS_MetaData *meta,
                     struct GNUNET_FS_Uri **uri,
                     struct GNUNET_FS_BlockOptions *bo,
                     int *do_index,
@@ -1523,7 +1524,7 @@ static int
 fip_signal_stop (void *cls,
                  struct GNUNET_FS_FileInformation *fi,
                  uint64_t length,
-                 struct GNUNET_CONTAINER_MetaData *meta,
+                 struct GNUNET_FS_MetaData *meta,
                  struct GNUNET_FS_Uri **uri,
                  struct GNUNET_FS_BlockOptions *bo,
                  int *do_index, void **client_info)
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c
index dae5ccdf3..d8ea22da2 100644
--- a/src/fs/fs_publish_ksk.c
+++ b/src/fs/fs_publish_ksk.c
@@ -30,6 +30,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_signatures.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 #include "fs_tree.h"
@@ -53,7 +54,7 @@ struct GNUNET_FS_PublishKskContext
   /**
    * Metadata to use.
    */
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
 
   /**
    * Global FS context.
@@ -186,7 +187,7 @@ publish_ksk_cont (void *cls)
 struct GNUNET_FS_PublishKskContext *
 GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
                        const struct GNUNET_FS_Uri *ksk_uri,
-                       const struct GNUNET_CONTAINER_MetaData *meta,
+                       const struct GNUNET_FS_MetaData *meta,
                        const struct GNUNET_FS_Uri *uri,
                        const struct GNUNET_FS_BlockOptions *bo,
                        enum GNUNET_FS_PublishOptions options,
@@ -201,7 +202,7 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   pkc->options = options;
   pkc->cont = cont;
   pkc->cont_cls = cont_cls;
-  pkc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  pkc->meta = GNUNET_FS_meta_data_duplicate (meta);
   if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
   {
     pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
@@ -244,7 +245,7 @@ GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc)
     GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
     pkc->dsh = NULL;
   }
-  GNUNET_CONTAINER_meta_data_destroy (pkc->meta);
+  GNUNET_FS_meta_data_destroy (pkc->meta);
   GNUNET_FS_uri_destroy (pkc->ksk_uri);
   GNUNET_FS_uri_destroy (pkc->uri);
   GNUNET_free (pkc);
diff --git a/src/fs/fs_publish_ublock.c b/src/fs/fs_publish_ublock.c
index aed090bb3..ad12d9b08 100644
--- a/src/fs/fs_publish_ublock.c
+++ b/src/fs/fs_publish_ublock.c
@@ -155,7 +155,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
                            const char *label,
                            const char *ulabel,
                            const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                           const struct GNUNET_CONTAINER_MetaData *meta,
+                           const struct GNUNET_FS_MetaData *meta,
                            const struct GNUNET_FS_Uri *uri,
                            const struct GNUNET_FS_BlockOptions *bo,
                            enum GNUNET_FS_PublishOptions options,
@@ -181,7 +181,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
   if (NULL == meta)
     mdsize = 0;
   else
-    mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
+    mdsize = GNUNET_FS_meta_data_get_serialized_size (meta);
   GNUNET_assert (mdsize >= 0);
   uris = GNUNET_FS_uri_to_string (uri);
   slen = strlen (uris) + 1;
@@ -206,8 +206,8 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
   sptr = kbe;
   if (NULL != meta)
     mdsize =
-      GNUNET_CONTAINER_meta_data_serialize (meta, &sptr, mdsize,
-                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+      GNUNET_FS_meta_data_serialize (meta, &sptr, mdsize,
+                                     GNUNET_FS_META_DATA_SERIALIZE_PART);
   if (-1 == mdsize)
   {
     GNUNET_break (0);
diff --git a/src/fs/fs_publish_ublock.h b/src/fs/fs_publish_ublock.h
index bd1c1a4dd..991926444 100644
--- a/src/fs/fs_publish_ublock.h
+++ b/src/fs/fs_publish_ublock.h
@@ -30,6 +30,7 @@
 
 #include "gnunet_util_lib.h"
 #include "gnunet_datastore_service.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_identity_service.h"
 
@@ -90,7 +91,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
                            const char *label,
                            const char *ulabel,
                            const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                           const struct GNUNET_CONTAINER_MetaData *meta,
+                           const struct GNUNET_FS_MetaData *meta,
                            const struct GNUNET_FS_Uri *uri,
                            const struct GNUNET_FS_BlockOptions *bo,
                            enum GNUNET_FS_PublishOptions options,
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 5538b7838..975dcfb14 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -24,6 +24,7 @@
  */
 #include "platform.h"
 #include "gnunet_constants.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_protocols.h"
 #include "fs_api.h"
@@ -487,7 +488,7 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 struct GNUNET_FS_SearchResult *
 GNUNET_FS_probe (struct GNUNET_FS_Handle *h,
                  const struct GNUNET_FS_Uri *uri,
-                 const struct GNUNET_CONTAINER_MetaData *meta,
+                 const struct GNUNET_FS_MetaData *meta,
                  void *client_info,
                  uint32_t anonymity)
 {
@@ -498,7 +499,7 @@ GNUNET_FS_probe (struct GNUNET_FS_Handle *h,
   sr = GNUNET_new (struct GNUNET_FS_SearchResult);
   sr->h = h;
   sr->uri = GNUNET_FS_uri_dup (uri);
-  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
   sr->client_info = client_info;
   sr->anonymity = anonymity;
   GNUNET_FS_search_start_probe_ (sr);
@@ -543,7 +544,7 @@ GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
   GNUNET_assert (NULL == sr->sc);
   GNUNET_FS_search_stop_probe_ (sr);
   GNUNET_FS_uri_destroy (sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_FS_meta_data_destroy (sr->meta);
   client_info = sr->client_info;
   GNUNET_free (sr);
   return client_info;
@@ -564,7 +565,7 @@ static void
 process_ksk_result (struct GNUNET_FS_SearchContext *sc,
                     struct SearchRequestEntry *ent,
                     const struct GNUNET_FS_Uri *uri,
-                    const struct GNUNET_CONTAINER_MetaData *meta)
+                    const struct GNUNET_FS_MetaData *meta)
 {
   struct GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
@@ -602,7 +603,7 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc,
     sr->sc = sc;
     sr->anonymity = sc->anonymity;
     sr->uri = GNUNET_FS_uri_dup (uri);
-    sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+    sr->meta = GNUNET_FS_meta_data_duplicate (meta);
     sr->mandatory_missing = sc->mandatory_count;
     sr->key = key;
     sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7)
@@ -612,7 +613,7 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc,
   }
   else
   {
-    GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
+    GNUNET_FS_meta_data_merge (sr->meta, meta);
   }
   GNUNET_break (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (ent->results,
@@ -685,7 +686,7 @@ static void
 process_sks_result (struct GNUNET_FS_SearchContext *sc,
                     const char *id_update,
                     const struct GNUNET_FS_Uri *uri,
-                    const struct GNUNET_CONTAINER_MetaData *meta)
+                    const struct GNUNET_FS_MetaData *meta)
 {
   struct GNUNET_FS_Uri uu;
   struct GNUNET_HashCode key;
@@ -713,7 +714,7 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc,
   sr->sc = sc;
   sr->anonymity = sc->anonymity;
   sr->uri = GNUNET_FS_uri_dup (uri);
-  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
   sr->key = key;
   GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
@@ -800,7 +801,7 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
   size_t j;
   char pt[size - sizeof(struct UBlock)];
   const char *eos;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *uri;
   char *emsg;
   int i;
@@ -835,9 +836,9 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
   }
   j = eos - pt + 1;
   if (sizeof(pt) == j)
-    meta = GNUNET_CONTAINER_meta_data_create ();
+    meta = GNUNET_FS_meta_data_create ();
   else
-    meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof(pt) - j);
+    meta = GNUNET_FS_meta_data_deserialize (&pt[j], sizeof(pt) - j);
   if (NULL == meta)
   {
     GNUNET_break_op (0);        /* ublock malformed */
@@ -850,7 +851,7 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
                       meta);
 
   /* clean up */
-  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_FS_meta_data_destroy (meta);
   GNUNET_FS_uri_destroy (uri);
 }
 
@@ -872,7 +873,7 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
   size_t len = size - sizeof(struct UBlock);
   char pt[len];
   struct GNUNET_FS_Uri *uri;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   const char *id;
   const char *uris;
   size_t off;
@@ -888,8 +889,8 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
     GNUNET_break_op (0);        /* ublock malformed */
     return;
   }
-  if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len
-                                                              - off)))
+  if (NULL == (meta = GNUNET_FS_meta_data_deserialize (&pt[off], len
+                                                       - off)))
   {
     GNUNET_break_op (0);        /* ublock malformed */
     return;
@@ -901,14 +902,14 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
                 uris, emsg);
     GNUNET_break_op (0);        /* ublock malformed */
     GNUNET_free (emsg);
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_destroy (meta);
     return;
   }
   /* process */
   process_sks_result (sc, id, uri, meta);
   /* clean up */
   GNUNET_FS_uri_destroy (uri);
-  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_FS_meta_data_destroy (meta);
 }
 
 
@@ -1543,7 +1544,7 @@ search_result_suspend (void *cls,
   GNUNET_break (NULL == sr->client_info);
   GNUNET_free (sr->serialization);
   GNUNET_FS_uri_destroy (sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_FS_meta_data_destroy (sr->meta);
   GNUNET_free (sr->keyword_bitmap);
   GNUNET_free (sr);
   return GNUNET_OK;
@@ -1749,7 +1750,7 @@ search_result_free (void *cls,
   GNUNET_break (NULL == sr->client_info);
   GNUNET_free (sr->serialization);
   GNUNET_FS_uri_destroy (sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_FS_meta_data_destroy (sr->meta);
   GNUNET_free (sr->keyword_bitmap);
   GNUNET_free (sr);
   return GNUNET_OK;
diff --git a/src/fs/fs_sharetree.c b/src/fs/fs_sharetree.c
index 3610b202e..a09b3589d 100644
--- a/src/fs/fs_sharetree.c
+++ b/src/fs/fs_sharetree.c
@@ -25,6 +25,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_scheduler_lib.h"
 #include <pthread.h>
@@ -308,13 +309,13 @@ migrate_and_drop_metadata (void *cls, const struct GNUNET_HashCode *key,
   if (counter->count >= tc->move_threshold)
   {
     if (NULL == tc->pos->meta)
-      tc->pos->meta = GNUNET_CONTAINER_meta_data_create ();
-    GNUNET_CONTAINER_meta_data_insert (tc->pos->meta,
-                                       counter->plugin_name,
-                                       counter->type,
-                                       counter->format,
-                                       counter->data_mime_type, counter->data,
-                                       counter->data_size);
+      tc->pos->meta = GNUNET_FS_meta_data_create ();
+    GNUNET_FS_meta_data_insert (tc->pos->meta,
+                                counter->plugin_name,
+                                counter->type,
+                                counter->format,
+                                counter->data_mime_type, counter->data,
+                                counter->data_size);
   }
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_remove (tc->metacounter,
@@ -356,12 +357,12 @@ share_tree_trim (struct TrimContext *tc,
     {
       /* only use filename if it doesn't match $USER */
       if (NULL == tree->meta)
-        tree->meta = GNUNET_CONTAINER_meta_data_create ();
-      GNUNET_CONTAINER_meta_data_insert (tree->meta, "<libgnunetfs>",
-                                         EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain", tree->short_filename,
-                                         strlen (tree->short_filename) + 1);
+        tree->meta = GNUNET_FS_meta_data_create ();
+      GNUNET_FS_meta_data_insert (tree->meta, "<libgnunetfs>",
+                                  EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain", tree->short_filename,
+                                  strlen (tree->short_filename) + 1);
     }
   }
 
@@ -372,8 +373,8 @@ share_tree_trim (struct TrimContext *tc,
   for (pos = tree->children_head; NULL != pos; pos = pos->next)
   {
     if (NULL != pos->meta)
-      GNUNET_CONTAINER_meta_data_iterate (pos->meta, &add_to_meta_counter,
-                                          tc->metacounter);
+      GNUNET_FS_meta_data_iterate (pos->meta, &add_to_meta_counter,
+                                   tc->metacounter);
     if (NULL != pos->ksk_uri)
       GNUNET_FS_uri_ksk_get_keywords (pos->ksk_uri, &add_to_keyword_counter,
                                       tc->keywordcounter);
@@ -444,7 +445,7 @@ GNUNET_FS_share_tree_free (struct GNUNET_FS_ShareTreeItem *toplevel)
                                  toplevel->parent->children_tail,
                                  toplevel);
   if (NULL != toplevel->meta)
-    GNUNET_CONTAINER_meta_data_destroy (toplevel->meta);
+    GNUNET_FS_meta_data_destroy (toplevel->meta);
   if (NULL != toplevel->ksk_uri)
     GNUNET_FS_uri_destroy (toplevel->ksk_uri);
   GNUNET_free (toplevel->filename);
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 8c27af9de..6031d7bc3 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -26,6 +26,7 @@
  */
 #include "platform.h"
 #include "gnunet_constants.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_protocols.h"
 #include "fs_api.h"
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index cdea8b72d..0810f77ca 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -81,6 +81,7 @@
  *
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_signatures.h"
 #include "fs_api.h"
@@ -343,7 +344,7 @@ uri_ksk_parse (const char *s, char **emsg)
   ret->data.ksk.keywordCount = iret;
   ret->data.ksk.keywords = keywords;
   return ret;
-CLEANUP:
+  CLEANUP:
   for (i = 0; i < max; i++)
     GNUNET_free (keywords[i]);
   GNUNET_free (keywords);
@@ -620,7 +621,7 @@ uri_loc_parse (const char *s, char **emsg)
   uri->data.loc.contentSignature = sig;
 
   return uri;
-ERR:
+  ERR:
   return NULL;
 }
 
@@ -1768,7 +1769,7 @@ gather_uri_data (void *cls,
  */
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_ksk_create_from_meta_data (
-  const struct GNUNET_CONTAINER_MetaData *md)
+  const struct GNUNET_FS_MetaData *md)
 {
   struct GNUNET_FS_Uri *ret;
   char *filename;
@@ -1782,10 +1783,10 @@ GNUNET_FS_uri_ksk_create_from_meta_data (
     return NULL;
   ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_KSK;
-  ent = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
+  ent = GNUNET_FS_meta_data_iterate (md, NULL, NULL);
   if (ent > 0)
   {
-    full_name = GNUNET_CONTAINER_meta_data_get_first_by_types (
+    full_name = GNUNET_FS_meta_data_get_first_by_types (
       md,
       EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
       -1);
@@ -1801,7 +1802,7 @@ GNUNET_FS_uri_ksk_create_from_meta_data (
        plus theoretically one more for mime... */
     ret->data.ksk.keywords =
       GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3, char *);
-    GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
+    GNUNET_FS_meta_data_iterate (md, &gather_uri_data, ret);
   }
   if (tok_keywords > 0)
     ret->data.ksk.keywordCount +=
diff --git a/src/fs/gnunet-daemon-fsprofiler.c b/src/fs/gnunet-daemon-fsprofiler.c
index fbb7c6028..bc7ca9521 100644
--- a/src/fs/gnunet-daemon-fsprofiler.c
+++ b/src/fs/gnunet-daemon-fsprofiler.c
@@ -27,6 +27,7 @@
  * - how to signal driver that we're done?
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_statistics_service.h"
 
diff --git a/src/fs/gnunet-directory.c b/src/fs/gnunet-directory.c
index ef5c40ae2..e720628b3 100644
--- a/src/fs/gnunet-directory.c
+++ b/src/fs/gnunet-directory.c
@@ -23,6 +23,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 static int ret;
@@ -90,20 +91,20 @@ static void
 print_entry (void *cls,
              const char *filename,
              const struct GNUNET_FS_Uri *uri,
-             const struct GNUNET_CONTAINER_MetaData *meta,
+             const struct GNUNET_FS_MetaData *meta,
              size_t length,
              const void *data)
 {
   char *string;
   char *name;
 
-  name = GNUNET_CONTAINER_meta_data_get_by_type (
+  name = GNUNET_FS_meta_data_get_by_type (
     meta,
     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (uri == NULL)
   {
     printf (_ ("Directory `%s' meta data:\n"), name ? name : "");
-    GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
+    GNUNET_FS_meta_data_iterate (meta, &item_printer, NULL);
     printf ("\n");
     printf (_ ("Directory `%s' contents:\n"), name ? name : "");
     GNUNET_free (name);
@@ -112,7 +113,7 @@ print_entry (void *cls,
   string = GNUNET_FS_uri_to_string (uri);
   printf ("%s (%s):\n", name ? name : "", string);
   GNUNET_free (string);
-  GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
+  GNUNET_FS_meta_data_iterate (meta, &item_printer, NULL);
   printf ("\n");
   GNUNET_free (name);
 }
diff --git a/src/fs/gnunet-download.c b/src/fs/gnunet-download.c
index eebf8e993..f463f901e 100644
--- a/src/fs/gnunet-download.c
+++ b/src/fs/gnunet-download.c
@@ -26,6 +26,7 @@
  * @author Igor Wronsky
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 static int ret;
diff --git a/src/fs/gnunet-fs.c b/src/fs/gnunet-fs.c
index 0f8f02a1c..3dd00c7dc 100644
--- a/src/fs/gnunet-fs.c
+++ b/src/fs/gnunet-fs.c
@@ -23,6 +23,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 /**
diff --git a/src/fs/gnunet-helper-fs-publish.c b/src/fs/gnunet-helper-fs-publish.c
index ef1a9ce4b..b886280c9 100644
--- a/src/fs/gnunet-helper-fs-publish.c
+++ b/src/fs/gnunet-helper-fs-publish.c
@@ -27,6 +27,7 @@
  * and report the results to stdout.
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 
@@ -120,7 +121,7 @@ add_to_md (void *cls,
            const char *data,
            size_t data_len)
 {
-  struct GNUNET_CONTAINER_MetaData *md = cls;
+  struct GNUNET_FS_MetaData *md = cls;
 
   if (((EXTRACTOR_METAFORMAT_UTF8 == format) ||
        (EXTRACTOR_METAFORMAT_C_STRING == format)) &&
@@ -129,23 +130,23 @@ add_to_md (void *cls,
     char zdata[data_len + 1];
     GNUNET_memcpy (zdata, data, data_len);
     zdata[data_len] = '\0';
-    (void) GNUNET_CONTAINER_meta_data_insert (md,
-                                              plugin_name,
-                                              type,
-                                              format,
-                                              data_mime_type,
-                                              zdata,
-                                              data_len + 1);
+    (void) GNUNET_FS_meta_data_insert (md,
+                                       plugin_name,
+                                       type,
+                                       format,
+                                       data_mime_type,
+                                       zdata,
+                                       data_len + 1);
   }
   else
   {
-    (void) GNUNET_CONTAINER_meta_data_insert (md,
-                                              plugin_name,
-                                              type,
-                                              format,
-                                              data_mime_type,
-                                              data,
-                                              data_len);
+    (void) GNUNET_FS_meta_data_insert (md,
+                                       plugin_name,
+                                       type,
+                                       format,
+                                       data_mime_type,
+                                       data,
+                                       data_len);
   }
   return 0;
 }
@@ -373,7 +374,7 @@ preprocess_file (const char *filename, struct ScanTreeNode **dst)
 static int
 extract_files (struct ScanTreeNode *item)
 {
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   ssize_t size;
   size_t slen;
 
@@ -390,16 +391,16 @@ extract_files (struct ScanTreeNode *item)
   }
 
   /* this is the expensive operation, *afterwards* we'll check for aborts */
-  meta = GNUNET_CONTAINER_meta_data_create ();
+  meta = GNUNET_FS_meta_data_create ();
 #if HAVE_LIBEXTRACTOR
   EXTRACTOR_extract (plugins, item->filename, NULL, 0, &add_to_md, meta);
 #endif
   slen = strlen (item->filename) + 1;
-  size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
+  size = GNUNET_FS_meta_data_get_serialized_size (meta);
   if (-1 == size)
   {
     /* no meta data */
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_destroy (meta);
     if (GNUNET_OK !=
         write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
                        item->filename,
@@ -417,17 +418,17 @@ extract_files (struct ScanTreeNode *item)
     char *dst = &buf[slen];
 
     GNUNET_memcpy (buf, item->filename, slen);
-    size = GNUNET_CONTAINER_meta_data_serialize (
+    size = GNUNET_FS_meta_data_serialize (
       meta,
       &dst,
       size,
-      GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+      GNUNET_FS_META_DATA_SERIALIZE_PART);
     if (size < 0)
     {
       GNUNET_break (0);
       size = 0;
     }
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_destroy (meta);
     if (GNUNET_OK !=
         write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
                        buf,
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index c62edcd61..094cbc9b9 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -26,6 +26,7 @@
  * @author Igor Wronsky
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_identity_service.h"
 
@@ -57,7 +58,7 @@ static struct GNUNET_FS_PublishContext *pc;
 /**
  * Meta-data provided via command-line option.
  */
-static struct GNUNET_CONTAINER_MetaData *meta;
+static struct GNUNET_FS_MetaData *meta;
 
 /**
  * Keywords provided via command-line option.
@@ -175,7 +176,7 @@ do_stop_task (void *cls)
   }
   if (NULL != meta)
   {
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_destroy (meta);
     meta = NULL;
   }
   if (NULL != uri)
@@ -376,7 +377,7 @@ static int
 publish_inspector (void *cls,
                    struct GNUNET_FS_FileInformation *fi,
                    uint64_t length,
-                   struct GNUNET_CONTAINER_MetaData *m,
+                   struct GNUNET_FS_MetaData *m,
                    struct GNUNET_FS_Uri **uri,
                    struct GNUNET_FS_BlockOptions *bo,
                    int *do_index,
@@ -410,20 +411,20 @@ publish_inspector (void *cls,
   }
   if (NULL != meta)
   {
-    GNUNET_CONTAINER_meta_data_merge (m, meta);
-    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_meta_data_merge (m, meta);
+    GNUNET_FS_meta_data_destroy (meta);
     meta = NULL;
   }
   if (enable_creation_time)
-    GNUNET_CONTAINER_meta_data_add_publication_date (m);
+    GNUNET_FS_meta_data_add_publication_date (m);
   if (extract_only)
   {
-    fn = GNUNET_CONTAINER_meta_data_get_by_type (
+    fn = GNUNET_FS_meta_data_get_by_type (
       m,
       EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
     fs = GNUNET_STRINGS_byte_size_fancy (length);
     fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
-    GNUNET_CONTAINER_meta_data_iterate (m, &meta_printer, NULL);
+    GNUNET_FS_meta_data_iterate (m, &meta_printer, NULL);
     fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
     GNUNET_free (fn);
     GNUNET_free (fs);
@@ -521,11 +522,11 @@ get_file_information (struct GNUNET_FS_ShareTreeItem *item)
   if (GNUNET_YES == item->is_directory)
   {
     if (NULL == item->meta)
-      item->meta = GNUNET_CONTAINER_meta_data_create ();
-    GNUNET_CONTAINER_meta_data_delete (item->meta,
-                                       EXTRACTOR_METATYPE_MIMETYPE,
-                                       NULL,
-                                       0);
+      item->meta = GNUNET_FS_meta_data_create ();
+    GNUNET_FS_meta_data_delete (item->meta,
+                                EXTRACTOR_METATYPE_MIMETYPE,
+                                NULL,
+                                0);
     GNUNET_FS_meta_data_make_directory (item->meta);
     if (NULL == item->ksk_uri)
     {
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index 78f4f3d4d..b55602523 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -30,11 +30,12 @@
 #include <ctype.h>
 #include <inttypes.h>
 #include <limits.h>
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 
 #define GNUNET_SEARCH_log(kind, ...) \
-        GNUNET_log_from(kind, "gnunet-search", __VA_ARGS__)
+  GNUNET_log_from (kind, "gnunet-search", __VA_ARGS__)
 
 
 /*  The default settings that we use for the printed output  */
@@ -61,14 +62,16 @@
 #define GENERIC_FILE_MIMETYPE    "application/octet-stream"
 
 
-enum GNUNET_SEARCH_MetadataPrinterFlags {
+enum GNUNET_SEARCH_MetadataPrinterFlags
+{
   METADATA_PRINTER_FLAG_NONE = 0,
   METADATA_PRINTER_FLAG_ONE_RUN = 1,
   METADATA_PRINTER_FLAG_HAVE_TYPE = 2
 };
 
 
-struct GNUNET_SEARCH_MetadataPrinterInfo {
+struct GNUNET_SEARCH_MetadataPrinterInfo
+{
   unsigned int counter;
   unsigned int flags;
   int type;
@@ -132,7 +135,7 @@ static const char *
 print_escape_sequence (const char *const esc)
 {
   unsigned int probe;
-  const char * cursor = esc + 1;
+  const char *cursor = esc + 1;
   char tmp;
   switch (*cursor)
   {
@@ -150,7 +153,7 @@ print_escape_sequence (const char *const esc)
   /*  Possibly hexadecimal code point  */
   case 'x':
     probe = 0;
-    while (probe < 256 && isxdigit((tmp = *++cursor)))
+    while (probe < 256 && isxdigit ((tmp = *++cursor)))
       probe = (probe << 4) + tmp - (tmp > 96 ? 87 : tmp > 64 ? 55 : 48);
     goto maybe_codepoint;
 
@@ -167,7 +170,7 @@ print_escape_sequence (const char *const esc)
   default: printf ("\\%c", *cursor); return cursor + 1;
   }
 
-maybe_codepoint:
+  maybe_codepoint:
   if (probe < 256)
     putchar (probe);
   else
@@ -212,31 +215,31 @@ item_printer (void *const cls,
     return 0;
 
   const char *cursor = meta_format_string;
-  const char *next_spec = strchr(cursor, '%');
-  const char *next_esc = strchr(cursor, '\\');
+  const char *next_spec = strchr (cursor, '%');
+  const char *next_esc = strchr (cursor, '\\');
 
-parse_format:
+  parse_format:
 
   /*  If an escape sequence exists before the next format specifier...  */
-  if (next_esc && (!next_spec || next_esc < next_spec))
+  if (next_esc && (! next_spec || next_esc < next_spec))
   {
     if (next_esc > cursor)
       fwrite (cursor, 1, next_esc - cursor, stdout);
 
     cursor = print_escape_sequence (next_esc);
-    next_esc = strchr(cursor, '\\');
+    next_esc = strchr (cursor, '\\');
     goto parse_format;
   }
 
   /*  If a format specifier exists before the next escape sequence...  */
-  if (next_spec && (!next_esc || next_spec < next_esc))
+  if (next_spec && (! next_esc || next_spec < next_esc))
   {
     if (next_spec > cursor)
       fwrite (cursor, 1, next_spec - cursor, stdout);
 
     switch (*++next_spec)
     {
-    case '%': putchar('%'); break;
+    case '%': putchar ('%'); break;
     case 'i': printf ("%d", type); break;
     case 'l': printf ("%lu", (long unsigned int) data_size); break;
     case 'n': printf ("%u", info->counter); break;
@@ -249,11 +252,11 @@ parse_format:
       break;
 #endif
     case 'w': printf ("%s", plugin_name); break;
-    case '\0': putchar('%'); return 0;
+    case '\0': putchar ('%'); return 0;
     default: printf ("%%%c", *next_spec); break;
     }
     cursor = next_spec + 1;
-    next_spec = strchr(cursor, '%');
+    next_spec = strchr (cursor, '%');
     goto parse_format;
   }
 
@@ -270,7 +273,7 @@ parse_format:
  *
  * @param filename the filename for this result
  * @param uri the `struct GNUNET_FS_Uri` this result refers to
- * @param metadata the `struct GNUNET_CONTAINER_MetaData` associated with this
+ * @param metadata the `struct GNUNET_FS_MetaData` associated with this
           result
  * @param resultnum the result number
  * @param is_directory GNUNET_YES if this is a directory, otherwise GNUNET_NO
@@ -279,34 +282,34 @@ parse_format:
 static void
 print_search_result (const char *const filename,
                      const struct GNUNET_FS_Uri *const uri,
-                     const struct GNUNET_CONTAINER_MetaData *const metadata,
+                     const struct GNUNET_FS_MetaData *const metadata,
                      const unsigned int resultnum,
                      const int is_directory)
 {
 
   const char *cursor = GNUNET_YES == is_directory ?
-                         dir_format_string
+                       dir_format_string
                        : format_string;
 
-  const char *next_spec = strchr(cursor, '%');
-  const char *next_esc = strchr(cursor, '\\');
+  const char *next_spec = strchr (cursor, '%');
+  const char *next_esc = strchr (cursor, '\\');
   char *placeholder;
   struct GNUNET_SEARCH_MetadataPrinterInfo info;
 
-parse_format:
+  parse_format:
   /*  If an escape sequence exists before the next format specifier...  */
-  if (next_esc && (!next_spec || next_esc < next_spec))
+  if (next_esc && (! next_spec || next_esc < next_spec))
   {
     if (next_esc > cursor)
       fwrite (cursor, 1, next_esc - cursor, stdout);
 
     cursor = print_escape_sequence (next_esc);
-    next_esc = strchr(cursor, '\\');
+    next_esc = strchr (cursor, '\\');
     goto parse_format;
   }
 
   /*  If a format specifier exists before the next escape sequence...  */
-  if (next_spec && (!next_esc || next_spec < next_esc))
+  if (next_spec && (! next_esc || next_spec < next_esc))
   {
     if (next_spec > cursor)
       fwrite (cursor, 1, next_spec - cursor, stdout);
@@ -317,9 +320,9 @@ parse_format:
     case 'a':
       info.flags = METADATA_PRINTER_FLAG_NONE;
 
-iterate_meta:
+      iterate_meta:
       info.counter = 0;
-      GNUNET_CONTAINER_meta_data_iterate (metadata, &item_printer, &info);
+      GNUNET_FS_meta_data_iterate (metadata, &item_printer, &info);
       break;
     /*  File's name  */
     case 'f':
@@ -337,11 +340,11 @@ iterate_meta:
     /*  File name's length  */
     case 'l':
       printf ("%lu",
-              (long unsigned int) (  GNUNET_YES == is_directory ?
-                                       strlen(filename) +
-                                       (sizeof(GNUNET_FS_DIRECTORY_EXT) - 1)
+              (long unsigned int) (GNUNET_YES == is_directory ?
+                                   strlen (filename)
+                                   + (sizeof(GNUNET_FS_DIRECTORY_EXT) - 1)
                                    :
-                                       strlen(filename)));
+                                   strlen (filename)));
       break;
     /*  File's mime type  */
     case 'm':
@@ -350,7 +353,7 @@ iterate_meta:
         printf ("%s", GNUNET_FS_DIRECTORY_MIME);
         break;
       }
-      placeholder = GNUNET_CONTAINER_meta_data_get_by_type (
+      placeholder = GNUNET_FS_meta_data_get_by_type (
         metadata,
         EXTRACTOR_METATYPE_MIMETYPE);
       printf ("%s", placeholder ? placeholder : GENERIC_FILE_MIMETYPE);
@@ -376,7 +379,7 @@ iterate_meta:
     case '5': case '6': case '7': case '8': case '9':
       cursor = next_spec;
       info.type = *cursor - 48;
-      while (isdigit(*++cursor) && info.type < (INT_MAX - *cursor + 48) / 10)
+      while (isdigit (*++cursor) && info.type < (INT_MAX - *cursor + 48) / 10)
         info.type = info.type * 10 + *cursor - 48;
       if (info.type == 0 || *cursor != '#')
         goto not_a_specifier;
@@ -391,21 +394,21 @@ iterate_meta:
       /*  Only the first metadata field of type `info.type`  */
       case 'j':
         next_spec = cursor;
-        info.flags = METADATA_PRINTER_FLAG_HAVE_TYPE |
-                     METADATA_PRINTER_FLAG_ONE_RUN;
+        info.flags = METADATA_PRINTER_FLAG_HAVE_TYPE
+                     | METADATA_PRINTER_FLAG_ONE_RUN;
         goto iterate_meta;
       }
       goto not_a_specifier;
 
     /*  All other cases  */
-    case '%': putchar('%'); break;
-    case '\0': putchar('%'); return;
+    case '%': putchar ('%'); break;
+    case '\0': putchar ('%'); return;
 
-not_a_specifier:
+      not_a_specifier:
     default: printf ("%%%c", *next_spec); break;
     }
     cursor = next_spec + 1;
-    next_spec = strchr(cursor, '%');
+    next_spec = strchr (cursor, '%');
     goto parse_format;
   }
 
@@ -439,10 +442,10 @@ clean_task (void *const cls)
                             GNUNET_DISK_PERM_USER_READ
                             | GNUNET_DISK_PERM_USER_WRITE))
   {
-    GNUNET_SEARCH_log(GNUNET_ERROR_TYPE_ERROR,
-                      _ ("Failed to write directory with search results to "
-                         "`%s'\n"),
-                      output_filename);
+    GNUNET_SEARCH_log (GNUNET_ERROR_TYPE_ERROR,
+                       _ ("Failed to write directory with search results to "
+                          "`%s'\n"),
+                       output_filename);
   }
   GNUNET_free (ddata);
   GNUNET_free (output_filename);
@@ -490,7 +493,7 @@ progress_cb (void *const cls,
       break;
 
     cnt++;
-    filename = GNUNET_CONTAINER_meta_data_get_by_type (
+    filename = GNUNET_FS_meta_data_get_by_type (
       info->value.search.specifics.result.meta,
       EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
     is_directory = GNUNET_FS_meta_data_test_for_directory (
@@ -501,12 +504,12 @@ progress_cb (void *const cls,
         filename[strlen (filename) - 1] = '\0';
       GNUNET_DISK_filename_canonicalize (filename);
     }
-    print_search_result (  filename ?
-                             filename
+    print_search_result (filename ?
+                         filename
                          : is_directory ?
-                             GENERIC_DIRECTORY_NAME
+                         GENERIC_DIRECTORY_NAME
                          :
-                             GENERIC_FILE_NAME,
+                         GENERIC_FILE_NAME,
                          info->value.search.specifics.result.uri,
                          info->value.search.specifics.result.meta,
                          cnt,
@@ -528,9 +531,9 @@ progress_cb (void *const cls,
     break;
 
   case GNUNET_FS_STATUS_SEARCH_ERROR:
-    GNUNET_SEARCH_log(GNUNET_ERROR_TYPE_ERROR,
-                      _ ("Error searching: %s.\n"),
-                      info->value.search.specifics.error.message);
+    GNUNET_SEARCH_log (GNUNET_ERROR_TYPE_ERROR,
+                       _ ("Error searching: %s.\n"),
+                       info->value.search.specifics.error.message);
     GNUNET_SCHEDULER_shutdown ();
     break;
 
@@ -539,9 +542,9 @@ progress_cb (void *const cls,
     break;
 
   default:
-    GNUNET_SEARCH_log(GNUNET_ERROR_TYPE_ERROR,
-                      _ ("Unexpected status: %d\n"),
-                      info->status);
+    GNUNET_SEARCH_log (GNUNET_ERROR_TYPE_ERROR,
+                       _ ("Unexpected status: %d\n"),
+                       info->status);
     break;
   }
   return NULL;
@@ -600,7 +603,7 @@ run (void *const cls,
     ret = 1;
     return;
   }
-  if (silent_mode && !output_filename)
+  if (silent_mode && ! output_filename)
   {
     fprintf (stderr, _ ("An output file is mandatory for silent mode.\n"));
     ret = 1;
@@ -627,7 +630,7 @@ run (void *const cls,
     ret = 1;
     return;
   }
-  if (!GNUNET_FS_uri_test_ksk (uri) && !GNUNET_FS_uri_test_sks (uri))
+  if (! GNUNET_FS_uri_test_ksk (uri) && ! GNUNET_FS_uri_test_sks (uri))
   {
     fprintf (stderr,
              "%s",
@@ -640,7 +643,7 @@ run (void *const cls,
   }
   if (bookmark_only)
   {
-    char * bmstr = GNUNET_FS_uri_to_string (uri);
+    char *bmstr = GNUNET_FS_uri_to_string (uri);
     printf ("%s\n", bmstr);
     GNUNET_free (bmstr);
     GNUNET_FS_uri_destroy (uri);
@@ -779,15 +782,15 @@ main (int argc, char *const *argv)
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 12;
 
-  if (GNUNET_SYSERR == 
+  if (GNUNET_SYSERR ==
       GNUNET_PROGRAM_run (argc,
                           argv,
                           "gnunet-search [OPTIONS] KEYWORD1 KEYWORD2 ...",
                           gettext_noop ("Search for files that have been "
                                         "published on GNUnet\n"),
-                         options,
-                         &run,
-                         NULL))
+                          options,
+                          &run,
+                          NULL))
     ret = 1;
 
   GNUNET_free_nz ((void *) argv);
diff --git a/src/fs/gnunet-unindex.c b/src/fs/gnunet-unindex.c
index afc547127..80cd95c19 100644
--- a/src/fs/gnunet-unindex.c
+++ b/src/fs/gnunet-unindex.c
@@ -26,6 +26,7 @@
  * @author Igor Wronsky
  */
 #include "platform.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 
 static int ret;
diff --git a/src/fs/meta_data.c b/src/fs/meta_data.c
new file mode 100644
index 000000000..f676ce57c
--- /dev/null
+++ b/src/fs/meta_data.c
@@ -0,0 +1,1224 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2022 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file fs/meta_data.c
+ * @brief Storing of meta data
+ * @author Christian Grothoff
+ * @author Martin Schanzenbach
+ */
+
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
+#include "gnunet_fs_service.h"
+
+/**
+ * Maximum size allowed for meta data written/read from disk.
+ * File-sharing limits to 64k, so this should be rather generous.
+ */
+#define MAX_META_DATA (1024 * 1024)
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "fs-meta-data", \
+                                        __VA_ARGS__)
+
+
+
+/**
+ * Meta data item.
+ */
+struct MetaItem
+{
+  /**
+   * This is a doubly linked list.
+   */
+  struct MetaItem *next;
+
+  /**
+   * This is a doubly linked list.
+   */
+  struct MetaItem *prev;
+
+  /**
+   * Name of the extracting plugin.
+   */
+  char *plugin_name;
+
+  /**
+   * Mime-type of data.
+   */
+  char *mime_type;
+
+  /**
+   * The actual meta data.
+   */
+  char *data;
+
+  /**
+   * Number of bytes in 'data'.
+   */
+  size_t data_size;
+
+  /**
+   * Type of the meta data.
+   */
+  enum EXTRACTOR_MetaType type;
+
+  /**
+   * Format of the meta data.
+   */
+  enum EXTRACTOR_MetaFormat format;
+};
+
+/**
+ * Meta data to associate with a file, directory or namespace.
+ */
+struct GNUNET_FS_MetaData
+{
+  /**
+   * Head of linked list of the meta data items.
+   */
+  struct MetaItem *items_head;
+
+  /**
+   * Tail of linked list of the meta data items.
+   */
+  struct MetaItem *items_tail;
+
+  /**
+   * Complete serialized and compressed buffer of the items.
+   * NULL if we have not computed that buffer yet.
+   */
+  char *sbuf;
+
+  /**
+   * Number of bytes in 'sbuf'. 0 if the buffer is stale.
+   */
+  size_t sbuf_size;
+
+  /**
+   * Number of items in the linked list.
+   */
+  unsigned int item_count;
+};
+
+
+/**
+ * Create a fresh struct FS_MetaData token.
+ *
+ * @return empty meta-data container
+ */
+struct GNUNET_FS_MetaData *
+GNUNET_FS_meta_data_create ()
+{
+  return GNUNET_new (struct GNUNET_FS_MetaData);
+}
+
+
+/**
+ * Free meta data item.
+ *
+ * @param mi item to free
+ */
+static void
+meta_item_free (struct MetaItem *mi)
+{
+  GNUNET_free (mi->plugin_name);
+  GNUNET_free (mi->mime_type);
+  GNUNET_free (mi->data);
+  GNUNET_free (mi);
+}
+
+
+/**
+ * The meta data has changed, invalidate its serialization
+ * buffer.
+ *
+ * @param md meta data that changed
+ */
+static void
+invalidate_sbuf (struct GNUNET_FS_MetaData *md)
+{
+  if (NULL == md->sbuf)
+    return;
+  GNUNET_free (md->sbuf);
+  md->sbuf = NULL;
+  md->sbuf_size = 0;
+}
+
+
+void
+GNUNET_FS_meta_data_destroy (struct GNUNET_FS_MetaData *md)
+{
+  struct MetaItem *pos;
+
+  if (NULL == md)
+    return;
+  while (NULL != (pos = md->items_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
+    meta_item_free (pos);
+  }
+  GNUNET_free (md->sbuf);
+  GNUNET_free (md);
+}
+
+
+void
+GNUNET_FS_meta_data_clear (struct GNUNET_FS_MetaData *md)
+{
+  struct MetaItem *mi;
+
+  if (NULL == md)
+    return;
+  while (NULL != (mi = md->items_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, mi);
+    meta_item_free (mi);
+  }
+  GNUNET_free (md->sbuf);
+  memset (md, 0, sizeof(struct GNUNET_FS_MetaData));
+}
+
+
+int
+GNUNET_FS_meta_data_test_equal (const struct GNUNET_FS_MetaData
+                                *md1,
+                                const struct GNUNET_FS_MetaData
+                                *md2)
+{
+  struct MetaItem *i;
+  struct MetaItem *j;
+  int found;
+
+  if (md1 == md2)
+    return GNUNET_YES;
+  if (md1->item_count != md2->item_count)
+    return GNUNET_NO;
+  for (i = md1->items_head; NULL != i; i = i->next)
+  {
+    found = GNUNET_NO;
+    for (j = md2->items_head; NULL != j; j = j->next)
+    {
+      if ((i->type == j->type) && (i->format == j->format) &&
+          (i->data_size == j->data_size) &&
+          (0 == memcmp (i->data, j->data, i->data_size)))
+      {
+        found = GNUNET_YES;
+        break;
+      }
+      if (j->data_size < i->data_size)
+        break;     /* elements are sorted by (decreasing) size... */
+    }
+    if (GNUNET_NO == found)
+      return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Extend metadata.  Note that the list of meta data items is
+ * sorted by size (largest first).
+ *
+ * @param md metadata to extend
+ * @param plugin_name name of the plugin that produced this value;
+ *        special values can be used (e.g. '&lt;zlib&gt;' for zlib being
+ *        used in the main libextractor library and yielding
+ *        meta data).
+ * @param type libextractor-type describing the meta data
+ * @param format basic format information about data
+ * @param data_mime_type mime-type of data (not of the original file);
+ *        can be NULL (if mime-type is not known)
+ * @param data actual meta-data found
+ * @param data_size number of bytes in @a data
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if this entry already exists
+ *         data_mime_type and plugin_name are not considered for "exists" checks
+ */
+int
+GNUNET_FS_meta_data_insert (struct GNUNET_FS_MetaData *md,
+                            const char *plugin_name,
+                            enum EXTRACTOR_MetaType type,
+                            enum EXTRACTOR_MetaFormat format,
+                            const char *data_mime_type, const char *data,
+                            size_t data_size)
+{
+  struct MetaItem *pos;
+  struct MetaItem *mi;
+  char *p;
+
+  if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
+      (EXTRACTOR_METAFORMAT_C_STRING == format))
+    GNUNET_break ('\0' == data[data_size - 1]);
+
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+  {
+    if (pos->data_size < data_size)
+      break;   /* elements are sorted by size in the list */
+    if ((pos->type == type) && (pos->data_size == data_size) &&
+        (0 == memcmp (pos->data, data, data_size)))
+    {
+      if ((NULL == pos->mime_type) && (NULL != data_mime_type))
+      {
+        pos->mime_type = GNUNET_strdup (data_mime_type);
+        invalidate_sbuf (md);
+      }
+      if ((EXTRACTOR_METAFORMAT_C_STRING == pos->format) &&
+          (EXTRACTOR_METAFORMAT_UTF8 == format))
+      {
+        pos->format = EXTRACTOR_METAFORMAT_UTF8;
+        invalidate_sbuf (md);
+      }
+      return GNUNET_SYSERR;
+    }
+  }
+  md->item_count++;
+  mi = GNUNET_new (struct MetaItem);
+  mi->type = type;
+  mi->format = format;
+  mi->data_size = data_size;
+  if (NULL == pos)
+    GNUNET_CONTAINER_DLL_insert_tail (md->items_head,
+                                      md->items_tail,
+                                      mi);
+  else
+    GNUNET_CONTAINER_DLL_insert_after (md->items_head,
+                                       md->items_tail,
+                                       pos->prev,
+                                       mi);
+  mi->mime_type =
+    (NULL == data_mime_type) ? NULL : GNUNET_strdup (data_mime_type);
+  mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup (plugin_name);
+  mi->data = GNUNET_malloc (data_size);
+  GNUNET_memcpy (mi->data, data, data_size);
+  /* change all dir separators to POSIX style ('/') */
+  if ((EXTRACTOR_METATYPE_FILENAME == type) ||
+      (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type))
+  {
+    p = mi->data;
+    while (('\0' != *p) && (p < mi->data + data_size))
+    {
+      if ('\\' == *p)
+        *p = '/';
+      p++;
+    }
+  }
+  invalidate_sbuf (md);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Merge given meta data.
+ *
+ * @param cls the `struct GNUNET_FS_MetaData` to merge into
+ * @param plugin_name name of the plugin that produced this value;
+ *        special values can be used (e.g. '&lt;zlib&gt;' for zlib being
+ *        used in the main libextractor library and yielding
+ *        meta data).
+ * @param type libextractor-type describing the meta data
+ * @param format basic format information about data
+ * @param data_mime_type mime-type of data (not of the original file);
+ *        can be NULL (if mime-type is not known)
+ * @param data actual meta-data found
+ * @param data_size number of bytes in @a data
+ * @return 0 (to continue)
+ */
+static int
+merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
+              enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
+              const char *data, size_t data_size)
+{
+  struct GNUNET_FS_MetaData *md = cls;
+
+  (void) GNUNET_FS_meta_data_insert (md, plugin_name, type, format,
+                                     data_mime_type, data, data_size);
+  return 0;
+}
+
+
+void
+GNUNET_FS_meta_data_merge (struct GNUNET_FS_MetaData *md,
+                           const struct GNUNET_FS_MetaData *in)
+{
+  GNUNET_FS_meta_data_iterate (in, &merge_helper, md);
+}
+
+
+int
+GNUNET_FS_meta_data_delete (struct GNUNET_FS_MetaData *md,
+                            enum EXTRACTOR_MetaType type,
+                            const char *data, size_t data_size)
+{
+  struct MetaItem *pos;
+
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+  {
+    if (pos->data_size < data_size)
+      break;   /* items are sorted by (decreasing) size */
+    if ((pos->type == type) &&
+        ((NULL == data) ||
+         ((pos->data_size == data_size) &&
+          (0 == memcmp (pos->data, data, data_size)))))
+    {
+      GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
+      meta_item_free (pos);
+      md->item_count--;
+      invalidate_sbuf (md);
+      return GNUNET_OK;
+    }
+  }
+  return GNUNET_SYSERR;
+}
+
+
+void
+GNUNET_FS_meta_data_add_publication_date (struct
+                                          GNUNET_FS_MetaData *md)
+{
+  const char *dat;
+  struct GNUNET_TIME_Absolute t;
+
+  t = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_meta_data_delete (md,
+                              EXTRACTOR_METATYPE_PUBLICATION_DATE,
+                              NULL, 0);
+  dat = GNUNET_STRINGS_absolute_time_to_string (t);
+  GNUNET_FS_meta_data_insert (md, "<gnunet>",
+                              EXTRACTOR_METATYPE_PUBLICATION_DATE,
+                              EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                              dat, strlen (dat) + 1);
+}
+
+
+/**
+ * Iterate over MD entries.
+ *
+ * @param md metadata to inspect
+ * @param iter function to call on each entry
+ * @param iter_cls closure for iterator
+ * @return number of entries
+ */
+int
+GNUNET_FS_meta_data_iterate (const struct GNUNET_FS_MetaData *md,
+                             EXTRACTOR_MetaDataProcessor iter,
+                             void *iter_cls)
+{
+  struct MetaItem *pos;
+
+  if (NULL == md)
+    return 0;
+  if (NULL == iter)
+    return md->item_count;
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+    if (0 !=
+        iter (iter_cls, pos->plugin_name, pos->type, pos->format,
+              pos->mime_type, pos->data, pos->data_size))
+      return md->item_count;
+  return md->item_count;
+}
+
+
+char *
+GNUNET_FS_meta_data_get_by_type (const struct
+                                 GNUNET_FS_MetaData *md,
+                                 enum EXTRACTOR_MetaType type)
+{
+  struct MetaItem *pos;
+
+  if (NULL == md)
+    return NULL;
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+    if ((type == pos->type) &&
+        ((pos->format == EXTRACTOR_METAFORMAT_UTF8) ||
+         (pos->format == EXTRACTOR_METAFORMAT_C_STRING)))
+      return GNUNET_strdup (pos->data);
+  return NULL;
+}
+
+
+char *
+GNUNET_FS_meta_data_get_first_by_types (const struct
+                                        GNUNET_FS_MetaData *md,
+                                        ...)
+{
+  char *ret;
+  va_list args;
+  int type;
+
+  if (NULL == md)
+    return NULL;
+  ret = NULL;
+  va_start (args, md);
+  while (1)
+  {
+    type = va_arg (args, int);
+    if (-1 == type)
+      break;
+    if (NULL != (ret = GNUNET_FS_meta_data_get_by_type (md, type)))
+      break;
+  }
+  va_end (args);
+  return ret;
+}
+
+
+/**
+ * Get a thumbnail from the meta-data (if present).
+ *
+ * @param md metadata to get the thumbnail from
+ * @param thumb will be set to the thumbnail data.  Must be
+ *        freed by the caller!
+ * @return number of bytes in thumbnail, 0 if not available
+ */
+size_t
+GNUNET_FS_meta_data_get_thumbnail (const struct GNUNET_FS_MetaData
+                                   *md, unsigned char **thumb)
+{
+  struct MetaItem *pos;
+  struct MetaItem *match;
+
+  if (NULL == md)
+    return 0;
+  match = NULL;
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+  {
+    if ((NULL != pos->mime_type) &&
+        (0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
+        (EXTRACTOR_METAFORMAT_BINARY == pos->format))
+    {
+      if (NULL == match)
+        match = pos;
+      else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
+               (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
+        match = pos;
+    }
+  }
+  if ((NULL == match) || (0 == match->data_size))
+    return 0;
+  *thumb = GNUNET_malloc (match->data_size);
+  GNUNET_memcpy (*thumb, match->data, match->data_size);
+  return match->data_size;
+}
+
+
+/**
+ * Duplicate a `struct GNUNET_FS_MetaData`.
+ *
+ * @param md what to duplicate
+ * @return duplicate meta-data container
+ */
+struct GNUNET_FS_MetaData *
+GNUNET_FS_meta_data_duplicate (const struct GNUNET_FS_MetaData
+                               *md)
+{
+  struct GNUNET_FS_MetaData *ret;
+  struct MetaItem *pos;
+
+  if (NULL == md)
+    return NULL;
+  ret = GNUNET_FS_meta_data_create ();
+  for (pos = md->items_tail; NULL != pos; pos = pos->prev)
+    GNUNET_FS_meta_data_insert (ret, pos->plugin_name, pos->type,
+                                pos->format, pos->mime_type, pos->data,
+                                pos->data_size);
+  return ret;
+}
+
+
+/**
+ * Flag in 'version' that indicates compressed meta-data.
+ */
+#define HEADER_COMPRESSED 0x80000000
+
+
+/**
+ * Bits in 'version' that give the version number.
+ */
+#define HEADER_VERSION_MASK 0x7FFFFFFF
+
+
+/**
+ * Header for serialized meta data.
+ */
+struct MetaDataHeader
+{
+  /**
+   * The version of the MD serialization.  The highest bit is used to
+   * indicate compression.
+   *
+   * Version 0 is traditional (pre-0.9) meta data (unsupported)
+   * Version is 1 for a NULL pointer
+   * Version 2 is for 0.9.x (and possibly higher)
+   * Other version numbers are not yet defined.
+   */
+  uint32_t version;
+
+  /**
+   * How many MD entries are there?
+   */
+  uint32_t entries;
+
+  /**
+   * Size of the decompressed meta data.
+   */
+  uint32_t size;
+
+  /**
+   * This is followed by 'entries' values of type 'struct MetaDataEntry'
+   * and then by 'entry' plugin names, mime-types and data blocks
+   * as specified in those meta data entries.
+   */
+};
+
+
+/**
+ * Entry of serialized meta data.
+ */
+struct MetaDataEntry
+{
+  /**
+   * Meta data type.  Corresponds to an 'enum EXTRACTOR_MetaType'
+   */
+  uint32_t type;
+
+  /**
+   * Meta data format. Corresponds to an 'enum EXTRACTOR_MetaFormat'
+   */
+  uint32_t format;
+
+  /**
+   * Number of bytes of meta data.
+   */
+  uint32_t data_size;
+
+  /**
+   * Number of bytes in the plugin name including 0-terminator.  0 for NULL.
+   */
+  uint32_t plugin_name_len;
+
+  /**
+   * Number of bytes in the mime type including 0-terminator.  0 for NULL.
+   */
+  uint32_t mime_type_len;
+};
+
+
+/**
+ * Serialize meta-data to target.
+ *
+ * @param md metadata to serialize
+ * @param target where to write the serialized metadata;
+ *         *target can be NULL, in which case memory is allocated
+ * @param max maximum number of bytes available in target
+ * @param opt is it ok to just write SOME of the
+ *        meta-data to match the size constraint,
+ *        possibly discarding some data?
+ * @return number of bytes written on success,
+ *         #GNUNET_SYSERR on error (typically: not enough
+ *         space)
+ */
+ssize_t
+GNUNET_FS_meta_data_serialize (const struct GNUNET_FS_MetaData
+                               *md, char **target, size_t max,
+                               enum
+                               GNUNET_FS_MetaDataSerializationOptions
+                               opt)
+{
+  struct GNUNET_FS_MetaData *vmd;
+  struct MetaItem *pos;
+  struct MetaDataHeader ihdr;
+  struct MetaDataHeader *hdr;
+  struct MetaDataEntry *ent;
+  char *dst;
+  unsigned int i;
+  uint64_t msize;
+  size_t off;
+  char *mdata;
+  char *cdata;
+  size_t mlen;
+  size_t plen;
+  size_t size;
+  size_t left;
+  size_t clen;
+  size_t rlen;
+  int comp;
+
+  if (max < sizeof(struct MetaDataHeader))
+    return GNUNET_SYSERR;       /* far too small */
+  if (NULL == md)
+    return 0;
+
+  if (NULL != md->sbuf)
+  {
+    /* try to use serialization cache */
+    if (md->sbuf_size <= max)
+    {
+      if (NULL == *target)
+        *target = GNUNET_malloc (md->sbuf_size);
+      GNUNET_memcpy (*target, md->sbuf, md->sbuf_size);
+      return md->sbuf_size;
+    }
+    if (0 == (opt & GNUNET_FS_META_DATA_SERIALIZE_PART))
+      return GNUNET_SYSERR;     /* can say that this will fail */
+    /* need to compute a partial serialization, sbuf useless ... */
+  }
+  dst = NULL;
+  msize = 0;
+  for (pos = md->items_tail; NULL != pos; pos = pos->prev)
+  {
+    msize += sizeof(struct MetaDataEntry);
+    msize += pos->data_size;
+    if (NULL != pos->plugin_name)
+      msize += strlen (pos->plugin_name) + 1;
+    if (NULL != pos->mime_type)
+      msize += strlen (pos->mime_type) + 1;
+  }
+  size = (size_t) msize;
+  if (size != msize)
+  {
+    GNUNET_break (0);           /* integer overflow */
+    return GNUNET_SYSERR;
+  }
+  if (size >= GNUNET_MAX_MALLOC_CHECKED)
+  {
+    /* too large to be processed */
+    return GNUNET_SYSERR;
+  }
+  ent = GNUNET_malloc (size);
+  mdata = (char *) &ent[md->item_count];
+  off = size - (md->item_count * sizeof(struct MetaDataEntry));
+  i = 0;
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+  {
+    ent[i].type = htonl ((uint32_t) pos->type);
+    ent[i].format = htonl ((uint32_t) pos->format);
+    ent[i].data_size = htonl ((uint32_t) pos->data_size);
+    if (NULL == pos->plugin_name)
+      plen = 0;
+    else
+      plen = strlen (pos->plugin_name) + 1;
+    ent[i].plugin_name_len = htonl ((uint32_t) plen);
+    if (NULL == pos->mime_type)
+      mlen = 0;
+    else
+      mlen = strlen (pos->mime_type) + 1;
+    ent[i].mime_type_len = htonl ((uint32_t) mlen);
+    off -= pos->data_size;
+    if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) ||
+        (EXTRACTOR_METAFORMAT_C_STRING == pos->format))
+      GNUNET_break ('\0' == pos->data[pos->data_size - 1]);
+    GNUNET_memcpy (&mdata[off], pos->data, pos->data_size);
+    off -= plen;
+    if (NULL != pos->plugin_name)
+      GNUNET_memcpy (&mdata[off], pos->plugin_name, plen);
+    off -= mlen;
+    if (NULL != pos->mime_type)
+      GNUNET_memcpy (&mdata[off], pos->mime_type, mlen);
+    i++;
+  }
+  GNUNET_assert (0 == off);
+
+  clen = 0;
+  cdata = NULL;
+  left = size;
+  i = 0;
+  for (pos = md->items_head; NULL != pos; pos = pos->next)
+  {
+    comp = GNUNET_NO;
+    if (0 == (opt & GNUNET_FS_META_DATA_SERIALIZE_NO_COMPRESS))
+      comp = GNUNET_try_compression ((const char *) &ent[i],
+                                     left,
+                                     &cdata,
+                                     &clen);
+
+    if ((NULL == md->sbuf) && (0 == i))
+    {
+      /* fill 'sbuf'; this "modifies" md, but since this is only
+       * an internal cache we will cast away the 'const' instead
+       * of making the API look strange. */
+      vmd = (struct GNUNET_FS_MetaData *) md;
+      hdr = GNUNET_malloc (left + sizeof(struct MetaDataHeader));
+      hdr->size = htonl (left);
+      hdr->entries = htonl (md->item_count);
+      if (GNUNET_YES == comp)
+      {
+        GNUNET_assert (clen < left);
+        hdr->version = htonl (2 | HEADER_COMPRESSED);
+        GNUNET_memcpy (&hdr[1], cdata, clen);
+        vmd->sbuf_size = clen + sizeof(struct MetaDataHeader);
+      }
+      else
+      {
+        hdr->version = htonl (2);
+        GNUNET_memcpy (&hdr[1], &ent[0], left);
+        vmd->sbuf_size = left + sizeof(struct MetaDataHeader);
+      }
+      vmd->sbuf = (char *) hdr;
+    }
+
+    if (((left + sizeof(struct MetaDataHeader)) <= max) ||
+        ((GNUNET_YES == comp) && (clen <= max)))
+    {
+      /* success, this now fits! */
+      if (GNUNET_YES == comp)
+      {
+        if (NULL == dst)
+          dst = GNUNET_malloc (clen + sizeof(struct MetaDataHeader));
+        hdr = (struct MetaDataHeader *) dst;
+        hdr->version = htonl (2 | HEADER_COMPRESSED);
+        hdr->size = htonl (left);
+        hdr->entries = htonl (md->item_count - i);
+        GNUNET_memcpy (&dst[sizeof(struct MetaDataHeader)], cdata, clen);
+        GNUNET_free (cdata);
+        cdata = NULL;
+        GNUNET_free (ent);
+        rlen = clen + sizeof(struct MetaDataHeader);
+      }
+      else
+      {
+        if (NULL == dst)
+          dst = GNUNET_malloc (left + sizeof(struct MetaDataHeader));
+        hdr = (struct MetaDataHeader *) dst;
+        hdr->version = htonl (2);
+        hdr->entries = htonl (md->item_count - i);
+        hdr->size = htonl (left);
+        GNUNET_memcpy (&dst[sizeof(struct MetaDataHeader)], &ent[i], left);
+        GNUNET_free (ent);
+        rlen = left + sizeof(struct MetaDataHeader);
+      }
+      if (NULL != *target)
+      {
+        if (GNUNET_YES == comp)
+          GNUNET_memcpy (*target, dst, clen + sizeof(struct MetaDataHeader));
+        else
+          GNUNET_memcpy (*target, dst, left + sizeof(struct MetaDataHeader));
+        GNUNET_free (dst);
+      }
+      else
+      {
+        *target = dst;
+      }
+      return rlen;
+    }
+
+    if (0 == (opt & GNUNET_FS_META_DATA_SERIALIZE_PART))
+    {
+      /* does not fit! */
+      GNUNET_free (ent);
+      if (NULL != cdata)
+        GNUNET_free (cdata);
+      cdata = NULL;
+      return GNUNET_SYSERR;
+    }
+
+    /* next iteration: ignore the corresponding meta data at the
+     * end and try again without it */
+    left -= sizeof(struct MetaDataEntry);
+    left -= pos->data_size;
+    if (NULL != pos->plugin_name)
+      left -= strlen (pos->plugin_name) + 1;
+    if (NULL != pos->mime_type)
+      left -= strlen (pos->mime_type) + 1;
+
+    if (NULL != cdata)
+      GNUNET_free (cdata);
+    cdata = NULL;
+    i++;
+  }
+  GNUNET_free (ent);
+
+  /* nothing fit, only write header! */
+  ihdr.version = htonl (2);
+  ihdr.entries = htonl (0);
+  ihdr.size = htonl (0);
+  if (NULL == *target)
+    *target = (char *) GNUNET_new (struct MetaDataHeader);
+  GNUNET_memcpy (*target, &ihdr, sizeof(struct MetaDataHeader));
+  return sizeof(struct MetaDataHeader);
+}
+
+
+ssize_t
+GNUNET_FS_meta_data_get_serialized_size (const struct
+                                         GNUNET_FS_MetaData *md)
+{
+  ssize_t ret;
+  char *ptr;
+
+  if (NULL != md->sbuf)
+    return md->sbuf_size;
+  ptr = NULL;
+  ret =
+    GNUNET_FS_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
+                                   GNUNET_FS_META_DATA_SERIALIZE_FULL);
+  if (-1 != ret)
+    GNUNET_free (ptr);
+  return ret;
+}
+
+
+/**
+ * Deserialize meta-data.  Initializes md.
+ *
+ * @param input buffer with the serialized metadata
+ * @param size number of bytes available in input
+ * @return MD on success, NULL on error (i.e.
+ *         bad format)
+ */
+struct GNUNET_FS_MetaData *
+GNUNET_FS_meta_data_deserialize (const char *input, size_t size)
+{
+  struct GNUNET_FS_MetaData *md;
+  struct MetaDataHeader hdr;
+  struct MetaDataEntry ent;
+  uint32_t ic;
+  uint32_t i;
+  char *data;
+  const char *cdata;
+  uint32_t version;
+  uint32_t dataSize;
+  int compressed;
+  size_t left;
+  uint32_t mlen;
+  uint32_t plen;
+  uint32_t dlen;
+  const char *mdata;
+  const char *meta_data;
+  const char *plugin_name;
+  const char *mime_type;
+  enum EXTRACTOR_MetaFormat format;
+
+  if (size < sizeof(struct MetaDataHeader))
+    return NULL;
+  GNUNET_memcpy (&hdr, input, sizeof(struct MetaDataHeader));
+  version = ntohl (hdr.version) & HEADER_VERSION_MASK;
+  compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0;
+
+  if (1 == version)
+    return NULL;                /* null pointer */
+  if (2 != version)
+  {
+    GNUNET_break_op (0);        /* unsupported version */
+    return NULL;
+  }
+
+  ic = ntohl (hdr.entries);
+  dataSize = ntohl (hdr.size);
+  if (((sizeof(struct MetaDataEntry) * ic) > dataSize) ||
+      ((0 != ic) &&
+       (dataSize / ic < sizeof(struct MetaDataEntry))))
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+
+  if (compressed)
+  {
+    if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
+    {
+      /* make sure we don't blow our memory limit because of a mal-formed
+       * message... */
+      GNUNET_break_op (0);
+      return NULL;
+    }
+    data =
+      GNUNET_decompress ((const char *) &input[sizeof(struct MetaDataHeader)],
+                         size - sizeof(struct MetaDataHeader),
+                         dataSize);
+    if (NULL == data)
+    {
+      GNUNET_break_op (0);
+      return NULL;
+    }
+    cdata = data;
+  }
+  else
+  {
+    data = NULL;
+    cdata = (const char *) &input[sizeof(struct MetaDataHeader)];
+    if (dataSize != size - sizeof(struct MetaDataHeader))
+    {
+      GNUNET_break_op (0);
+      return NULL;
+    }
+  }
+
+  md = GNUNET_FS_meta_data_create ();
+  left = dataSize - ic * sizeof(struct MetaDataEntry);
+  mdata = &cdata[ic * sizeof(struct MetaDataEntry)];
+  for (i = 0; i < ic; i++)
+  {
+    GNUNET_memcpy (&ent, &cdata[i * sizeof(struct MetaDataEntry)],
+                   sizeof(struct MetaDataEntry));
+    format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
+    if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
+        (EXTRACTOR_METAFORMAT_C_STRING != format) &&
+        (EXTRACTOR_METAFORMAT_BINARY != format))
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    dlen = ntohl (ent.data_size);
+    plen = ntohl (ent.plugin_name_len);
+    mlen = ntohl (ent.mime_type_len);
+    if (dlen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= dlen;
+    meta_data = &mdata[left];
+    if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
+        (EXTRACTOR_METAFORMAT_C_STRING == format))
+    {
+      if (0 == dlen)
+      {
+        GNUNET_break_op (0);
+        break;
+      }
+      if ('\0' != meta_data[dlen - 1])
+      {
+        GNUNET_break_op (0);
+        break;
+      }
+    }
+    if (plen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= plen;
+    if ((plen > 0) && ('\0' != mdata[left + plen - 1]))
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    if (0 == plen)
+      plugin_name = NULL;
+    else
+      plugin_name = &mdata[left];
+
+    if (mlen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= mlen;
+    if ((mlen > 0) && ('\0' != mdata[left + mlen - 1]))
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    if (0 == mlen)
+      mime_type = NULL;
+    else
+      mime_type = &mdata[left];
+    GNUNET_FS_meta_data_insert (md, plugin_name,
+                                (enum EXTRACTOR_MetaType)
+                                ntohl (ent.type), format, mime_type,
+                                meta_data, dlen);
+  }
+  GNUNET_free (data);
+  return md;
+}
+
+/**
+ * Read a metadata container.
+ *
+ * @param h handle to an open file
+ * @param what describes what is being read (for error message creation)
+ * @param result the buffer to store a pointer to the (allocated) metadata
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+int
+GNUNET_FS_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
+                          const char *what,
+                          struct GNUNET_FS_MetaData **result)
+{
+  uint32_t size;
+  char *buf;
+  struct GNUNET_FS_MetaData *meta;
+
+  if (GNUNET_OK != GNUNET_BIO_read_int32 (h,
+                                          _ ("metadata length"),
+                                          (int32_t *) &size))
+    return GNUNET_SYSERR;
+  if (0 == size)
+  {
+    *result = NULL;
+    return GNUNET_OK;
+  }
+  if (MAX_META_DATA < size)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Serialized metadata `%s' larger than allowed (%u > %u)"),
+                what,
+                size,
+                MAX_META_DATA);
+    return GNUNET_SYSERR;
+  }
+  buf = GNUNET_malloc (size);
+  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
+  {
+    GNUNET_free (buf);
+    return GNUNET_SYSERR;
+  }
+  meta = GNUNET_FS_meta_data_deserialize (buf, size);
+  if (NULL == meta)
+  {
+    GNUNET_free (buf);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to deserialize metadata `%s'"), what);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (buf);
+  *result = meta;
+  return GNUNET_OK;
+}
+
+/**
+ * Write a metadata container.
+ *
+ * @param h the IO handle to write to
+ * @param what what is being written (for error message creation)
+ * @param m metadata to write
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_FS_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
+                           const char *what,
+                           const struct GNUNET_FS_MetaData *m)
+{
+  ssize_t size;
+  char *buf;
+
+  if (m == NULL)
+    return GNUNET_BIO_write_int32 (h, _ ("metadata length"), 0);
+  buf = NULL;
+  size = GNUNET_FS_meta_data_serialize (m,
+                                        &buf,
+                                        MAX_META_DATA,
+                                        GNUNET_FS_META_DATA_SERIALIZE_PART);
+  if (-1 == size)
+  {
+    GNUNET_free (buf);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to serialize metadata `%s'"),
+                what);
+    return GNUNET_SYSERR;
+  }
+  if ((GNUNET_OK != GNUNET_BIO_write_int32 (h,
+                                            _ ("metadata length"),
+                                            (uint32_t) size))
+      || (GNUNET_OK != GNUNET_BIO_write (h, what, buf, size)))
+  {
+    GNUNET_free (buf);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (buf);
+  return GNUNET_OK;
+}
+
+/**
+ * Function used internally to read a metadata container from within a read
+ * spec.
+ *
+ * @param cls ignored, always NULL
+ * @param h the IO handle to read from
+ * @param what what is being read (for error message creation)
+ * @param target where to store the data
+ * @param target_size ignored
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+read_spec_handler_meta_data (void *cls,
+                             struct GNUNET_BIO_ReadHandle *h,
+                             const char *what,
+                             void *target,
+                             size_t target_size)
+{
+  struct GNUNET_FS_MetaData **result = target;
+  return GNUNET_FS_read_meta_data (h, what, result);
+}
+
+/**
+ * Create the specification to read a metadata container.
+ *
+ * @param what describes what is being read (for error message creation)
+ * @param result the buffer to store a pointer to the (allocated) metadata
+ * @return the read spec
+ */
+struct GNUNET_BIO_ReadSpec
+GNUNET_FS_read_spec_meta_data (const char *what,
+                               struct GNUNET_FS_MetaData **result)
+{
+  struct GNUNET_BIO_ReadSpec rs = {
+    .rh = &read_spec_handler_meta_data,
+    .cls = NULL,
+    .target = result,
+    .size = 0,
+  };
+
+  return rs;
+}
+
+/**
+ * Function used internally to write a metadata container from within a write
+ * spec.
+ *
+ * @param cls ignored, always NULL
+ * @param h the IO handle to write to
+ * @param what what is being written (for error message creation)
+ * @param source the data to write
+ * @param source_size ignored
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
+ */
+static int
+write_spec_handler_meta_data (void *cls,
+                              struct GNUNET_BIO_WriteHandle *h,
+                              const char *what,
+                              void *source,
+                              size_t source_size)
+{
+  const struct GNUNET_FS_MetaData *m = source;
+  return GNUNET_FS_write_meta_data (h, what, m);
+}
+
+
+struct GNUNET_BIO_WriteSpec
+GNUNET_FS_write_spec_meta_data (const char *what,
+                                const struct GNUNET_FS_MetaData *m)
+{
+  struct GNUNET_BIO_WriteSpec ws = {
+    .wh = &write_spec_handler_meta_data,
+    .cls = NULL,
+    .what = what,
+    .source = (void *) m,
+    .source_size = 0,
+  };
+
+  return ws;
+}
+
+
+/* end of meta_data.c */
diff --git a/src/fs/plugin_block_fs.c b/src/fs/plugin_block_fs.c
index 11677a6b2..a6cfb2e64 100644
--- a/src/fs/plugin_block_fs.c
+++ b/src/fs/plugin_block_fs.c
@@ -25,6 +25,7 @@
  */
 #include "platform.h"
 #include "gnunet_block_plugin.h"
+#include "gnunet_extractor_compat.h"
 #include "gnunet_fs_service.h"
 #include "block_fs.h"
 #include "gnunet_signatures.h"
diff --git a/src/fs/test_fs_directory.c b/src/fs/test_fs_directory.c
index 908e7c555..f1f86fbf7 100644
--- a/src/fs/test_fs_directory.c
+++ b/src/fs/test_fs_directory.c
@@ -36,14 +36,14 @@
 struct PCLS
 {
   struct GNUNET_FS_Uri **uri;
-  struct GNUNET_CONTAINER_MetaData **md;
+  struct GNUNET_FS_MetaData **md;
   unsigned int pos;
   unsigned int max;
 };
 
 static void
 processor (void *cls, const char *filename, const struct GNUNET_FS_Uri *uri,
-           const struct GNUNET_CONTAINER_MetaData *md, size_t length,
+           const struct GNUNET_FS_MetaData *md, size_t length,
            const void *data)
 {
   struct PCLS *p = cls;
@@ -71,8 +71,8 @@ testDirectory (unsigned int i)
   char *data;
   size_t dlen;
   struct GNUNET_FS_Uri **uris;
-  struct GNUNET_CONTAINER_MetaData **mds;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData **mds;
+  struct GNUNET_FS_MetaData *meta;
   struct PCLS cls;
   char *emsg;
   int p;
@@ -85,7 +85,7 @@ testDirectory (unsigned int i)
 
   cls.max = i;
   uris = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri *) * i);
-  mds = GNUNET_malloc (sizeof(struct GNUNET_CONTAINER_MetaData *) * i);
+  mds = GNUNET_malloc (sizeof(struct GNUNET_FS_MetaData *) * i);
   meta = GNUNET_CONTAINER_meta_data_create ();
   GNUNET_CONTAINER_meta_data_insert (meta, "<test>", EXTRACTOR_METATYPE_TITLE,
                                      EXTRACTOR_METAFORMAT_UTF8, "text/plain",
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index 2fe0da77c..e8011f1e4 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -267,7 +267,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index 35d4ed441..c77d9277e 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -302,7 +302,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
diff --git a/src/fs/test_fs_file_information.c b/src/fs/test_fs_file_information.c
index 22013db27..fb9ddaa3d 100644
--- a/src/fs/test_fs_file_information.c
+++ b/src/fs/test_fs_file_information.c
@@ -49,7 +49,7 @@
 
 static int
 mycleaner (void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length,
-           struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri,
+           struct GNUNET_FS_MetaData *meta, struct GNUNET_FS_Uri **uri,
            struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
 {
   return GNUNET_OK;
@@ -67,7 +67,7 @@ run (void *cls, char *const *args, const char *cfgfile,
   char *fn1;
   char *fn2;
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi1;
   struct GNUNET_FS_FileInformation *fi2;
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c
index 2f04a017a..2f0c32756 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -183,7 +183,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi1;
   struct GNUNET_FS_FileInformation *fi2;
diff --git a/src/fs/test_fs_meta_data.c b/src/fs/test_fs_meta_data.c
new file mode 100644
index 000000000..50f902cb5
--- /dev/null
+++ b/src/fs/test_fs_meta_data.c
@@ -0,0 +1,379 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2003, 2004, 2006, 2009, 2010, 2022 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file util/test_fs_meta_data.c
+ * @brief Test for fs_meta_data.c
+ * @author Christian Grothoff
+ * @author Martin Schanzenbach
+ */
+
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_extractor_compat.h"
+#include "gnunet_fs_service.h"
+
+#define ABORT(m) { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+                   if (m != NULL) GNUNET_FS_meta_data_destroy (m); \
+                   return 1; }
+
+
+static int
+testMeta (int i)
+{
+  struct GNUNET_FS_MetaData *m;
+  char val[256];
+  char *sval;
+  int j;
+  unsigned int size;
+
+  m = GNUNET_FS_meta_data_create ();
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain", "TestTitle",
+                                  strlen ("TestTitle") + 1))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_insert (m, "<test>",
+                                  EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain", "TestTitle",
+                                  strlen ("TestTitle") + 1))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_FS_meta_data_insert (m, "<test>",
+                                               EXTRACTOR_METATYPE_TITLE,
+                                               EXTRACTOR_METAFORMAT_UTF8,
+                                               "text/plain",
+                                               "TestTitle", strlen (
+                                                 "TestTitle") + 1))                                                                                                             /* dup! */
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_FS_meta_data_insert (m, "<test>",
+                                               EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                               EXTRACTOR_METAFORMAT_UTF8,
+                                               "text/plain",
+                                               "TestTitle", strlen (
+                                                 "TestTitle") + 1))                                                                                                                     /* dup! */
+    ABORT (m);
+  if (2 != GNUNET_FS_meta_data_iterate (m, NULL, NULL))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                  "TestTitle", strlen ("TestTitle") + 1))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_FS_meta_data_delete (m,
+                                               EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                               "TestTitle", strlen (
+                                                 "TestTitle") + 1))                                                                     /* already gone */
+    ABORT (m);
+  if (1 != GNUNET_FS_meta_data_iterate (m, NULL, NULL))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
+                                  "TestTitle", strlen ("TestTitle") + 1))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_FS_meta_data_delete (m,
+                                               EXTRACTOR_METATYPE_TITLE,
+                                               "TestTitle", strlen (
+                                                 "TestTitle") + 1))                                                             /* already gone */
+    ABORT (m);
+  if (0 != GNUNET_FS_meta_data_iterate (m, NULL, NULL))
+    ABORT (m);
+  for (j = 0; j < i; j++)
+  {
+    GNUNET_snprintf (val, sizeof(val), "%s.%d",
+                     "A teststring that should compress well.", j);
+    if (GNUNET_OK !=
+        GNUNET_FS_meta_data_insert (m, "<test>",
+                                    EXTRACTOR_METATYPE_UNKNOWN,
+                                    EXTRACTOR_METAFORMAT_UTF8,
+                                    "text/plain", val, strlen (val) + 1))
+      ABORT (m);
+  }
+  if (i != GNUNET_FS_meta_data_iterate (m, NULL, NULL))
+    ABORT (m);
+
+  size = GNUNET_FS_meta_data_get_serialized_size (m);
+  sval = NULL;
+  if (size !=
+      GNUNET_FS_meta_data_serialize (m, &sval, size,
+                                     GNUNET_FS_META_DATA_SERIALIZE_FULL))
+  {
+    GNUNET_free (sval);
+    ABORT (m);
+  }
+  GNUNET_FS_meta_data_destroy (m);
+  m = GNUNET_FS_meta_data_deserialize (sval, size);
+  GNUNET_free (sval);
+  if (m == NULL)
+    ABORT (m);
+  for (j = 0; j < i; j++)
+  {
+    GNUNET_snprintf (val,
+                     sizeof(val),
+                     "%s.%d",
+                     "A teststring that should compress well.",
+                     j);
+    if (GNUNET_OK !=
+        GNUNET_FS_meta_data_delete (m,
+                                    EXTRACTOR_METATYPE_UNKNOWN,
+                                    val,
+                                    strlen (val) + 1))
+    {
+      ABORT (m);
+    }
+  }
+  if (0 != GNUNET_FS_meta_data_iterate (m, NULL, NULL))
+    ABORT (m);
+  GNUNET_FS_meta_data_destroy (m);
+  return 0;
+}
+
+
+static int
+testMetaMore (int i)
+{
+  struct GNUNET_FS_MetaData *meta;
+  int q;
+  char txt[128];
+  char *data;
+  unsigned long long size;
+
+  meta = GNUNET_FS_meta_data_create ();
+  for (q = 0; q <= i; q++)
+  {
+    GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
+    GNUNET_FS_meta_data_insert (meta, "<test>",
+                                q
+                                % 42 /* EXTRACTOR_metatype_get_max () */,
+                                EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                txt, strlen (txt) + 1);
+  }
+  size = GNUNET_FS_meta_data_get_serialized_size (meta);
+  data = GNUNET_malloc (size * 4);
+  if (size !=
+      GNUNET_FS_meta_data_serialize (meta, &data, size * 4,
+                                     GNUNET_FS_META_DATA_SERIALIZE_FULL))
+  {
+    GNUNET_free (data);
+    ABORT (meta);
+  }
+  GNUNET_FS_meta_data_destroy (meta);
+  GNUNET_free (data);
+  return 0;
+}
+
+
+static int
+testMetaLink ()
+{
+  struct GNUNET_FS_MetaData *m;
+  char *val;
+  unsigned int size;
+
+  m = GNUNET_FS_meta_data_create ();
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_insert (m, "<test>",
+                                  EXTRACTOR_METATYPE_UNKNOWN,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain", "link",
+                                  strlen ("link") + 1))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_FS_meta_data_insert (m, "<test>",
+                                  EXTRACTOR_METATYPE_FILENAME,
+                                  EXTRACTOR_METAFORMAT_UTF8,
+                                  "text/plain", "lib-link.m4",
+                                  strlen ("lib-link.m4") + 1))
+    ABORT (m);
+  val = NULL;
+  size =
+    GNUNET_FS_meta_data_serialize (m, &val, (size_t) -1,
+                                   GNUNET_FS_META_DATA_SERIALIZE_FULL);
+  GNUNET_FS_meta_data_destroy (m);
+  m = GNUNET_FS_meta_data_deserialize (val, size);
+  GNUNET_free (val);
+  if (m == NULL)
+    ABORT (m);
+  GNUNET_FS_meta_data_destroy (m);
+  return 0;
+}
+
+
+static int
+check ()
+{
+  struct GNUNET_FS_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta2;
+  int q;
+  int i = 100;
+  char txt[128];
+  char *str;
+  unsigned char *thumb;
+
+  meta = GNUNET_FS_meta_data_create ();
+  meta2 = GNUNET_FS_meta_data_create ();
+  for (q = 0; q <= i; q++)
+  {
+    GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
+    GNUNET_FS_meta_data_insert (meta, "<test>",
+                                EXTRACTOR_METATYPE_UNKNOWN,
+                                EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                "TestTitle", strlen ("TestTitle") + 1);
+    GNUNET_FS_meta_data_insert (meta2, "<test>",
+                                EXTRACTOR_METATYPE_UNKNOWN,
+                                EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                "TestTitle", strlen ("TestTitle") + 1);
+  }
+
+  // check meta_data_test_equal
+  if (GNUNET_YES != GNUNET_FS_meta_data_test_equal (meta, meta2))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+
+  // check meta_data_clear
+  GNUNET_FS_meta_data_clear (meta2);
+  if (0 != GNUNET_FS_meta_data_iterate (meta2, NULL, NULL))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+  // check equal branch in meta_data_test_equal
+  if (GNUNET_YES != GNUNET_FS_meta_data_test_equal (meta, meta))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+  // check "count" branch in meta_data_test_equal
+  if (GNUNET_NO != GNUNET_FS_meta_data_test_equal (meta, meta2))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+
+  // check meta_data_add_publication_date
+  GNUNET_FS_meta_data_add_publication_date (meta2);
+
+  // check meta_data_merge
+  GNUNET_FS_meta_data_clear (meta2);
+  GNUNET_FS_meta_data_merge (meta2, meta);
+  if (100 == GNUNET_FS_meta_data_iterate (meta2, NULL, NULL))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+
+  // check meta_data_get_by_type
+  GNUNET_FS_meta_data_clear (meta2);
+  if (NULL !=
+      (str =
+         GNUNET_FS_meta_data_get_by_type (meta2,
+                                          EXTRACTOR_METATYPE_UNKNOWN)))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    GNUNET_free (str);
+    ABORT (meta);
+  }
+
+  str =
+    GNUNET_FS_meta_data_get_by_type (meta, EXTRACTOR_METATYPE_UNKNOWN);
+  GNUNET_assert (NULL != str);
+  if (str[0] != 'T')
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    GNUNET_free (str);
+    ABORT (meta);
+  }
+  GNUNET_free (str);
+
+  // check branch
+  if (NULL !=
+      (str =
+         GNUNET_FS_meta_data_get_by_type (meta,
+                                          EXTRACTOR_METATYPE_PUBLICATION_DATE)))
+  {
+    GNUNET_free (str);
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+
+  // check meta_data_get_first_by_types
+  str =
+    GNUNET_FS_meta_data_get_first_by_types (meta,
+                                            EXTRACTOR_METATYPE_UNKNOWN,
+                                            -1);
+  GNUNET_assert (NULL != str);
+  if (str[0] != 'T')
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    GNUNET_free (str);
+    ABORT (meta);
+  }
+  GNUNET_free (str);
+
+  // check meta_data_get_thumbnail
+  if (GNUNET_FS_meta_data_get_thumbnail (meta, &thumb) != 0)
+  {
+    GNUNET_free (thumb);
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+  GNUNET_FS_meta_data_destroy (meta2);
+  // check meta_data_duplicate
+  meta2 = GNUNET_FS_meta_data_duplicate (meta);
+  if (200 == GNUNET_FS_meta_data_iterate (meta2, NULL, NULL))
+  {
+    GNUNET_FS_meta_data_destroy (meta2);
+    ABORT (meta);
+  }
+  GNUNET_FS_meta_data_destroy (meta2);
+  GNUNET_FS_meta_data_destroy (meta);
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  int i;
+
+  GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
+  for (i = 0; i < 255; i++)
+    failureCount += testMeta (i);
+  for (i = 1; i < 255; i++)
+    failureCount += testMetaMore (i);
+  failureCount += testMetaLink ();
+
+  int ret = check ();
+
+  if (ret == 1)
+    return 1;
+
+  if (failureCount != 0)
+    return 1;
+  return 0;
+}
+
+
+/* end of test_container_meta_data.c */
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index c1e10d575..3544b825e 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -206,7 +206,7 @@ publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
 static void
 sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *ksk_uri;
   char *msg;
   struct GNUNET_FS_BlockOptions bo;
@@ -238,7 +238,7 @@ sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 static void
 adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_CRYPTO_EcdsaPrivateKey ns;
   struct GNUNET_FS_BlockOptions bo;
 
@@ -270,7 +270,7 @@ static void
 testNamespace (void)
 {
   struct GNUNET_FS_BlockOptions bo;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *ksk_uri;
   struct GNUNET_FS_Uri *sks_uri;
 
diff --git a/src/fs/test_fs_namespace_list_updateable.c b/src/fs/test_fs_namespace_list_updateable.c
index 2132220fb..54f6c9a66 100644
--- a/src/fs/test_fs_namespace_list_updateable.c
+++ b/src/fs/test_fs_namespace_list_updateable.c
@@ -35,7 +35,7 @@ static int err;
 
 static struct GNUNET_CRYPTO_EcdsaPrivateKey ns;
 
-static struct GNUNET_CONTAINER_MetaData *meta;
+static struct GNUNET_FS_MetaData *meta;
 
 static struct GNUNET_FS_Uri *uri_this;
 
@@ -66,7 +66,7 @@ do_shutdown ()
 static void
 check_next (void *cls, const char *last_id,
             const struct GNUNET_FS_Uri *last_uri,
-            const struct GNUNET_CONTAINER_MetaData *last_meta,
+            const struct GNUNET_FS_MetaData *last_meta,
             const char *next_id)
 {
   GNUNET_break (0 == strcmp (last_id, "next"));
@@ -78,7 +78,7 @@ check_next (void *cls, const char *last_id,
 static void
 check_this_next (void *cls, const char *last_id,
                  const struct GNUNET_FS_Uri *last_uri,
-                 const struct GNUNET_CONTAINER_MetaData *last_meta,
+                 const struct GNUNET_FS_MetaData *last_meta,
                  const char *next_id)
 {
   GNUNET_break (0 == strcmp (last_id, "this"));
@@ -101,7 +101,7 @@ sks_cont_next (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 static void
 check_this (void *cls, const char *last_id,
             const struct GNUNET_FS_Uri *last_uri,
-            const struct GNUNET_CONTAINER_MetaData *last_meta,
+            const struct GNUNET_FS_MetaData *last_meta,
             const char *next_id)
 {
   GNUNET_break (0 == strcmp (last_id, "this"));
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index 2ffc722da..687ada0f1 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -169,7 +169,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi1;
   struct GNUNET_FS_FileInformation *fi2;
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index da0209793..d92006853 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -242,7 +242,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi1;
   struct GNUNET_FS_FileInformation *fi2;
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index b392cc8ac..252ab3de3 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -204,7 +204,7 @@ run (void *cls,
     "down_bar"
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_BlockOptions bo;
   struct GNUNET_FS_FileInformation *fi;
diff --git a/src/fs/test_fs_search_persistence.c b/src/fs/test_fs_search_persistence.c
index d523a6404..cbd87c077 100644
--- a/src/fs/test_fs_search_persistence.c
+++ b/src/fs/test_fs_search_persistence.c
@@ -269,7 +269,7 @@ run (void *cls,
     "down_bar"
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
diff --git a/src/fs/test_fs_search_probes.c b/src/fs/test_fs_search_probes.c
index b3c717aa1..510d18e9b 100644
--- a/src/fs/test_fs_search_probes.c
+++ b/src/fs/test_fs_search_probes.c
@@ -209,7 +209,7 @@ run (void *cls,
     "down_bar"
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_BlockOptions bo;
   struct GNUNET_FS_FileInformation *fi;
diff --git a/src/fs/test_fs_search_with_and.c b/src/fs/test_fs_search_with_and.c
index 2187f4531..e0018cec4 100644
--- a/src/fs/test_fs_search_with_and.c
+++ b/src/fs/test_fs_search_with_and.c
@@ -216,7 +216,7 @@ run (void *cls,
     "down_bar"
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_BlockOptions bo;
   struct GNUNET_FS_FileInformation *fi;
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c
index 992672244..c72bbce97 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -184,7 +184,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
diff --git a/src/fs/test_fs_unindex_persistence.c b/src/fs/test_fs_unindex_persistence.c
index 802aaf7ca..b903d07ee 100644
--- a/src/fs/test_fs_unindex_persistence.c
+++ b/src/fs/test_fs_unindex_persistence.c
@@ -253,7 +253,7 @@ run (void *cls,
     "down_bar",
   };
   char *buf;
-  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_MetaData *meta;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;