adapting main code base to work with libextractor 0.6 API; testcases will follow later

8 files changed, 149 insertions, 88 deletions

diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index e037130c8..48578c650 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -36,10 +36,6 @@
 #include "gnunet_fs_service.h"
 #include "fs.h"
 
-#ifndef EXTRACTOR_GNUNET_FULL_DATA
-#define EXTRACTOR_GNUNET_FULL_DATA 137
-#endif
-
 /**
  * String that is used to indicate that a file
  * is a GNUnet directory.
@@ -60,7 +56,7 @@ GNUNET_FS_meta_data_test_for_directory (const struct GNUNET_CONTAINER_MetaData *
   char *mime;
   int ret;
   
-  mime = GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_MIMETYPE);
+  mime = GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime == NULL)
     return GNUNET_SYSERR;
   ret = (0 == strcmp (mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES : GNUNET_NO;
@@ -80,7 +76,7 @@ GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
 {
   char *mime;
   
-  mime = GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_MIMETYPE);
+  mime = GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime != NULL)
     {
       GNUNET_break (0 == strcmp (mime,
@@ -89,8 +85,12 @@ GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
       return;
     }
   GNUNET_CONTAINER_meta_data_insert (md, 
-                                     EXTRACTOR_MIMETYPE,
-                                     GNUNET_FS_DIRECTORY_MIME);
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_MIMETYPE,
+                                     EXTRACTOR_METAFORMAT_UTF8,
+                                     "text/plain",
+                                     GNUNET_FS_DIRECTORY_MIME,
+                                     strlen (GNUNET_FS_DIRECTORY_MIME)+1);
 }
 
 
@@ -225,9 +225,9 @@ GNUNET_FS_directory_list_contents (size_t size,
         }
       pos += mdSize;
       filename = GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                                         EXTRACTOR_FILENAME);
+                                                         EXTRACTOR_METATYPE_FILENAME);
       file_data = GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                                          EXTRACTOR_GNUNET_FULL_DATA);
+                                                          EXTRACTOR_METATYPE_GNUNET_FULL_DATA);
       if (dep != NULL) 
          dep (dep_cls,
               filename,
@@ -322,6 +322,7 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   size_t mdxs;
   char *uris;
   char *ser;
+  char *sptr;
   size_t slen;
   struct GNUNET_CONTAINER_MetaData *meta;
   const struct GNUNET_CONTAINER_MetaData *meta_use;
@@ -340,25 +341,24 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
     fsize = 0; /* not given */
   if (fsize > MAX_INLINE_SIZE)
     fsize = 0; /* too large */
-  if ( (NULL == data) ||
-       (NULL != memchr (data, 0, fsize)) )
-    fsize = 0; /* must not have 0's in data! */
   uris = GNUNET_FS_uri_to_string (uri);
   slen = strlen (uris) + 1;
   mds =
-    GNUNET_CONTAINER_meta_data_get_serialized_size (md,
-                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);  
+    GNUNET_CONTAINER_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,
-                                         EXTRACTOR_GNUNET_FULL_DATA,
-                                         data);
+                                         "<gnunet>",                                     
+                                         EXTRACTOR_METATYPE_GNUNET_FULL_DATA,
+                                         EXTRACTOR_METAFORMAT_BINARY,
+                                         NULL,
+                                         data,
+                                         fsize);
       mdxs =
-        GNUNET_CONTAINER_meta_data_get_serialized_size (meta,
-                                                        GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);  
+        GNUNET_CONTAINER_meta_data_get_serialized_size (meta);  
       if ( (slen + sizeof (uint32_t) + mdxs - 1) / DBLOCK_SIZE ==
            (slen + sizeof (uint32_t) + mds - 1) / DBLOCK_SIZE)
         {
@@ -376,8 +376,9 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   ser = (char*) &e[1];
   memcpy (ser, uris, slen);
   GNUNET_free (uris);
+  sptr = &ser[slen + sizeof(uint32_t)];
   ret = GNUNET_CONTAINER_meta_data_serialize (meta_use,
-                                              &ser[slen + sizeof(uint32_t)],
+                                              &sptr,
                                               mds,
                                               GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (NULL != meta)
@@ -503,6 +504,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
                                     void **rdata)
 {
   char *data;
+  char *sptr;
   size_t *sizes;
   unsigned int *perm;
   unsigned int i;
@@ -516,8 +518,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   uint32_t big;
 
   size = 8 + sizeof (uint32_t);
-  size += GNUNET_CONTAINER_meta_data_get_serialized_size (bld->meta, 
-                                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  size += GNUNET_CONTAINER_meta_data_get_serialized_size (bld->meta);
   sizes = NULL;
   perm = NULL;
   bes = NULL;
@@ -560,9 +561,9 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   memcpy (data, GNUNET_DIRECTORY_MAGIC, 8);
   off = 8;
 
+  sptr = &data[off + sizeof (uint32_t)];
   ret = GNUNET_CONTAINER_meta_data_serialize (bld->meta,
-                                              &data[off +
-                                                    sizeof (uint32_t)],
+                                              &sptr,
                                               size - off - sizeof (uint32_t),
                                               GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   GNUNET_assert (ret != -1);
diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index c28635198..9c193f88b 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -364,7 +364,7 @@ struct DirScanCls
   /**
    * Metadata extractors to use.
    */
-  struct EXTRACTOR_Extractor *extractors;
+  struct EXTRACTOR_PluginList *extractors;
 
   /**
    * Function to call on each directory entry.
@@ -518,7 +518,7 @@ GNUNET_FS_directory_scanner_default (void *cls,
                                      void *proc_cls,
                                      char **emsg)
 {
-  struct EXTRACTOR_Extractor *ex = cls;
+  struct EXTRACTOR_PluginList *ex = cls;
   struct DirScanCls dsc;
 
   dsc.extractors = ex;
diff --git a/src/fs/fs_getopt.c b/src/fs/fs_getopt.c
index a0d232641..f985ed8d0 100644
--- a/src/fs/fs_getopt.c
+++ b/src/fs/fs_getopt.c
@@ -131,7 +131,7 @@ GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext*
 
 {
   struct GNUNET_CONTAINER_MetaData **mm = scls;
-  EXTRACTOR_KeywordType type;
+  enum EXTRACTOR_MetaType type;
   const char *typename;
   const char *typename_i18n;
   struct GNUNET_CONTAINER_MetaData *meta;
@@ -151,17 +151,23 @@ GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext*
                                 "utf-8"
 #endif
     );
-  type = EXTRACTOR_getHighestKeywordTypeNumber ();
+  type = EXTRACTOR_metatype_get_max ();
   while (type > 0)
     {
       type--;
-      typename = EXTRACTOR_getKeywordTypeAsString (type);
+      typename = EXTRACTOR_metatype_to_string (type);
       typename_i18n = dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN, typename);
       if ((strlen (tmp) >= strlen (typename) + 1) &&
           (tmp[strlen (typename)] == ':') &&
           (0 == strncmp (typename, tmp, strlen (typename))))
         {
-          GNUNET_CONTAINER_meta_data_insert (meta, type, &tmp[strlen (typename) + 1]);
+          GNUNET_CONTAINER_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;
@@ -170,8 +176,13 @@ GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext*
           (tmp[strlen (typename_i18n)] == ':') &&
           (0 == strncmp (typename_i18n, tmp, strlen (typename_i18n))))
         {
-          GNUNET_CONTAINER_meta_data_insert (meta, type,
-                                             &tmp[strlen (typename_i18n) + 1]);
+          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_free (tmp);
           tmp = NULL;
           break;
@@ -179,7 +190,13 @@ GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext*
     }
   if (tmp != NULL)
     {
-      GNUNET_CONTAINER_meta_data_insert (meta, EXTRACTOR_UNKNOWN, tmp);
+      GNUNET_CONTAINER_meta_data_insert (meta, 
+                                         "<gnunet>",
+                                         EXTRACTOR_METATYPE_UNKNOWN, 
+                                         EXTRACTOR_METAFORMAT_UTF8,
+                                         "text/plain",
+                                         tmp,
+                                         strlen(tmp) + 1);
       GNUNET_free (tmp);
       printf (_
               ("Unknown metadata type in metadata option `%s'.  Using metadata type `unknown' instead.\n"),
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 46b342cab..02ddb2a0d 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -842,7 +842,7 @@ do_upload (void *cls,
       while (NULL != p->dir)
         {
           fn = GNUNET_CONTAINER_meta_data_get_by_type (p->meta,
-                                                       EXTRACTOR_FILENAME);
+                                                       EXTRACTOR_METATYPE_FILENAME);
           p = p->dir;
           GNUNET_asprintf (&p->emsg, 
                            _("Recursive upload failed at `%s'"),
@@ -1305,6 +1305,7 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   char *uris;
   size_t size;
   char *kbe;
+  char *sptr;
 
   pkc = GNUNET_malloc (sizeof (struct PublishKskContext));
   pkc->h = h;
@@ -1324,8 +1325,7 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
           return;
         }
     }
-  pkc->mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta,
-                                                                GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+  pkc->mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
   GNUNET_assert (pkc->mdsize >= 0);
   uris = GNUNET_FS_uri_to_string (uri);
   pkc->slen = strlen (uris) + 1;
@@ -1339,8 +1339,9 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   kbe = (char *) &pkc->kb[1];
   memcpy (kbe, uris, pkc->slen);
   GNUNET_free (uris);
+  sptr = &kbe[pkc->slen];
   pkc->mdsize = GNUNET_CONTAINER_meta_data_serialize (meta,
-                                                      &kbe[pkc->slen],
+                                                      &sptr,
                                                       pkc->mdsize,
                                                       GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (pkc->mdsize == -1)
@@ -1480,8 +1481,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   if (update == NULL)
     update = "";
   nidlen = strlen (update) + 1;
-  mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta, 
-                                                           GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+  mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
 
   size = sizeof (struct SBlock) + slen + nidlen + mdsize;
   if (size > MAX_SBLOCK_SIZE)
@@ -1496,7 +1496,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   memcpy (dest, uris, slen);
   dest += slen;
   mdsize = GNUNET_CONTAINER_meta_data_serialize (meta,
-                                                 dest,
+                                                 &dest,
                                                  mdsize, 
                                                  GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (mdsize == -1)
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 02310a080..16b6e26e9 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -1469,19 +1469,34 @@ GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
  * Adds it to the URI.
  *
  * @param cls URI to update
- * @param type type of the meta data
- * @param data value of the meta data
- * @return GNUNET_OK (always)
+ * @param plugin_name name of the plugin that produced this value;
+ *        special values can be used (i.e. '<zlib>' 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_len number of bytes in data
+ * @return 0 (always)
  */
 static int
 gather_uri_data (void *cls,
-                 EXTRACTOR_KeywordType type, 
-                 const char *data)
+                 const char *plugin_name,
+                 enum EXTRACTOR_MetaType type, 
+                 enum EXTRACTOR_MetaFormat format,
+                 const char *data_mime_type,
+                 const char *data,
+                 size_t data_len)
 {
   struct GNUNET_FS_Uri *uri = cls;
   char *nkword;
   int j;
   
+  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
+       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+    return 0;
   for (j = uri->data.ksk.keywordCount - 1; j >= 0; j--)
     if (0 == strcmp (&uri->data.ksk.keywords[j][1], data))
       return GNUNET_OK;
@@ -1489,7 +1504,7 @@ gather_uri_data (void *cls,
   strcpy (nkword, " ");         /* not mandatory */
   strcat (nkword, data);
   uri->data.ksk.keywords[uri->data.ksk.keywordCount++] = nkword;
-  return GNUNET_OK;
+  return 0;
 }
 
 
@@ -1514,8 +1529,8 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
   ret->data.ksk.keywords = NULL;
   ret->data.ksk.keywords
     = GNUNET_malloc (sizeof (char *) *
-                     GNUNET_CONTAINER_meta_data_get_contents (md, NULL, NULL));
-  GNUNET_CONTAINER_meta_data_get_contents (md, &gather_uri_data, ret);
+                     GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL));
+  GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
   return ret;
 
 }
diff --git a/src/fs/gnunet-directory.c b/src/fs/gnunet-directory.c
index 6201c5dbb..3ea76985e 100644
--- a/src/fs/gnunet-directory.c
+++ b/src/fs/gnunet-directory.c
@@ -36,13 +36,20 @@ static int ret;
  */
 static int
 item_printer (void *cls,
-              EXTRACTOR_KeywordType type, 
-              const char *data)
+              const char *plugin_name,
+              enum EXTRACTOR_MetaType type, 
+              enum EXTRACTOR_MetaFormat format,
+              const char *data_mime_type,
+              const char *data,
+              size_t data_size)
 {
+  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
+       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+    return 0;
   printf ("\t%20s: %s\n",
           dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
-                    EXTRACTOR_getKeywordTypeAsString (type)), data);
-  return GNUNET_OK;
+                    EXTRACTOR_metatype_to_string (type)), data);
+  return 0;
 }
 
 
@@ -75,9 +82,9 @@ print_entry (void *cls,
   string = GNUNET_FS_uri_to_string (uri);
   printf ("%s:\n", string);
   GNUNET_free (string);
-  GNUNET_CONTAINER_meta_data_get_contents (meta,
-                                           &item_printer,
-                                           NULL);
+  GNUNET_CONTAINER_meta_data_iterate (meta,
+                                      &item_printer,
+                                      NULL);
 }
 
 
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index e3918f6fb..65f437f11 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -140,43 +140,57 @@ progress_cb (void *cls,
  * @param cls closure
  * @param type type of the meta data
  * @param data value of the meta data
- * @return GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort
+ * @return always 0
  */
 static int
 meta_printer (void *cls,
-              EXTRACTOR_KeywordType type,
-              const char *data)
+              const char *plugin_name,
+              enum EXTRACTOR_MetaType type, 
+              enum EXTRACTOR_MetaFormat format,
+              const char *data_mime_type,
+              const char *data,
+              size_t data_size)
 {
-  if ( (type == EXTRACTOR_FILENAME) ||
-       (EXTRACTOR_isBinaryType (type)) )
-    return GNUNET_OK;
+  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
+       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+    return 0;
+  if (type == EXTRACTOR_METATYPE_FILENAME) 
+    return 0;
   fprintf (stdout, 
            "%s - %s",
-           EXTRACTOR_getKeywordTypeAsString (type),
+           EXTRACTOR_metatype_to_string (type),
            data);
-  return GNUNET_OK;
+  return 0;
 }
 
 
 /**
- * Merge metadata entries (except binary
- * metadata).
+ * Merge metadata entries.
  *
  * @param cls closure, target metadata structure
  * @param type type of the meta data
  * @param data value of the meta data
- * @return GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort
+ * @return always 0
  */
 static int
 meta_merger (void *cls,
-             EXTRACTOR_KeywordType type,
-             const char *data)
+              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_CONTAINER_MetaData *m = cls;
+
   GNUNET_CONTAINER_meta_data_insert (m,
+                                     plugin_name,
                                      type, 
-                                     data);
-  return GNUNET_OK;
+                                     format,
+                                     data_mime_type,
+                                     data,
+                                     data_size);
+  return 0;
 }
 
 
@@ -227,16 +241,16 @@ publish_inspector (void *cls,
     }
   if (NULL != meta)
     {
-      GNUNET_CONTAINER_meta_data_get_contents (meta,
-                                               &meta_merger,
-                                               m);
+      GNUNET_CONTAINER_meta_data_iterate (meta,
+                                          &meta_merger,
+                                          m);
       GNUNET_CONTAINER_meta_data_destroy (meta);
       meta = NULL;
     }
   if (extract_only)
     {
       fn = GNUNET_CONTAINER_meta_data_get_by_type (meta,
-                                                   EXTRACTOR_FILENAME);
+                                                   EXTRACTOR_METATYPE_FILENAME);
       fs = GNUNET_STRINGS_byte_size_fancy (length);
       fprintf (stdout,
                _("Keywords for file `%s' (%s)\n"),
@@ -244,9 +258,9 @@ publish_inspector (void *cls,
                fs);
       GNUNET_free (fn);
       GNUNET_free (fs);
-      GNUNET_CONTAINER_meta_data_get_contents (meta,
-                                               &meta_printer,
-                                               NULL);
+      GNUNET_CONTAINER_meta_data_iterate (meta,
+                                          &meta_printer,
+                                          NULL);
       fprintf (stdout, "\n");
     }
   if (GNUNET_FS_meta_data_test_for_directory (meta))
@@ -275,7 +289,7 @@ run (void *cls,
 {
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_Namespace *namespace;
-  EXTRACTOR_ExtractorList *l;
+  struct EXTRACTOR_PluginList *l;
   char *ex;
   char *emsg;
   
@@ -377,13 +391,13 @@ run (void *cls,
   l = NULL;
   if (! disable_extractor)
     {
-      l = EXTRACTOR_loadDefaultLibraries ();
+      l = EXTRACTOR_plugin_add_defaults (EXTRACTOR_OPTION_DEFAULT_POLICY);
       if (GNUNET_OK ==
           GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS",
                                                  &ex))
         {
           if (strlen (ex) > 0)
-            l = EXTRACTOR_loadConfigLibraries (l, ex);
+            l = EXTRACTOR_plugin_add_config (l, ex, EXTRACTOR_OPTION_DEFAULT_POLICY);
           GNUNET_free (ex);
         }
     }
@@ -396,7 +410,7 @@ run (void *cls,
                                                          priority,
                                                          GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION),
                                                          &emsg);
-  EXTRACTOR_removeAll (l);  
+  EXTRACTOR_plugin_remove_all (l);  
   if (fi == NULL)
     {
       fprintf (stderr,
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index 067d77159..4836f9d83 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -45,12 +45,19 @@ static int verbose;
 
 static int
 item_printer (void *cls,
-              EXTRACTOR_KeywordType type, 
-              const char *data)
+              const char *plugin_name,
+              enum EXTRACTOR_MetaType type, 
+              enum EXTRACTOR_MetaFormat format,
+              const char *data_mime_type,
+              const char *data,
+              size_t data_size)
 {
+  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
+       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+    return 0;
   printf ("\t%20s: %s\n",
           dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
-                    EXTRACTOR_getKeywordTypeAsString (type)),
+                    EXTRACTOR_metatype_to_string (type)),
           data);
   return GNUNET_OK;
 }
@@ -86,7 +93,7 @@ progress_cb (void *cls,
       printf ("%s:\n", uri);
       filename =
         GNUNET_CONTAINER_meta_data_get_by_type (info->value.search.specifics.result.meta,
-                                                EXTRACTOR_FILENAME);
+                                                EXTRACTOR_METATYPE_FILENAME);
       if (filename != NULL)
         {
           while (NULL != (dotdot = strstr (filename, "..")))
@@ -98,9 +105,9 @@ progress_cb (void *cls,
       else
         printf ("gnunet-download %s\n", uri);
       if (verbose)
-        GNUNET_CONTAINER_meta_data_get_contents (info->value.search.specifics.result.meta, 
-                                                 &item_printer,
-                                                 NULL);
+        GNUNET_CONTAINER_meta_data_iterate (info->value.search.specifics.result.meta, 
+                                            &item_printer,
+                                            NULL);
       printf ("\n");
       fflush(stdout);
       GNUNET_free_non_null (filename);