stuff

13 files changed, 752 insertions, 76 deletions

diff --git a/src/fs/Makefile.am b/src/fs/Makefile.am
index 5aca42ac2..f1bc64784 100644
--- a/src/fs/Makefile.am
+++ b/src/fs/Makefile.am
@@ -26,6 +26,7 @@ libgnunetfs_la_SOURCES = \
   fs_uri.c 
 
 libgnunetfs_la_LIBADD = \
+  $(top_builddir)/src/datastore/libgnunetdatastore.la \
   $(top_builddir)/src/util/libgnunetutil.la \
   -lextractor \
   $(GN_LIBINTL) $(XLIB)
@@ -35,11 +36,11 @@ libgnunetfs_la_LDFLAGS = \
   -version-info 0:0:0
 
 
-#bin_PROGRAMS =  
+bin_PROGRAMS = \
+  gnunet-publish 
 # gnunet-directory 
 # gnunet-download 
 # gnunet-pseudonym 
-# gnunet-publish 
 # gnunet-search
 # gnunet-unindex 
 
@@ -51,6 +52,14 @@ libgnunetfs_la_LDFLAGS = \
 #  $(GN_LIBINTL)
 
 
+gnunet_publish_SOURCES =  \
+ gnunet-publish.c         
+gnunet_publish_LDADD =  \
+ $(top_builddir)/src/fs/libgnunetfs.la \
+ $(top_builddir)/src/util/libgnunetutil.la \
+ $(GN_LIBINTL)
+
+
 check_PROGRAMS = \
  test_fs_collection \
  test_fs_directory \
diff --git a/src/fs/fs.h b/src/fs/fs.h
index c66249613..3c92b42ae 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -308,13 +308,13 @@ struct GNUNET_FS_FileInformation
        * Size of the directory itself (in bytes); 0 if the
        * size has not yet been calculated.
        */
-      uint64_t dir_size;
+      size_t dir_size;
 
       /**
        * Pointer to the data for the directory (or NULL if not
        * available).
        */
-      char *dir_data;
+      void *dir_data;
 
     } dir;
 
diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index e5a9f963f..489cf8f19 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -24,7 +24,6 @@
  * @author Christian Grothoff
  *
  * TODO:
- * - add support for embedded file data (use padding room!)
  * - modify directory builder API to support incremental
  *   generation of directories (to allow directories that
  *   would not fit into memory to be created)
@@ -42,6 +41,13 @@
 #endif
 
 /**
+ * String that is used to indicate that a file
+ * is a GNUnet directory.
+ */
+#define GNUNET_DIRECTORY_MAGIC "\211GND\r\n\032\n"
+
+
+/**
  * Does the meta-data claim that this is a directory?
  * Checks if the mime-type is that of a GNUnet directory.
  *
@@ -118,6 +124,7 @@ GNUNET_FS_directory_list_contents (size_t size,
                                    void *dep_cls)
 {
   const char *cdata = data;
+  char *file_data;
   char *emsg;
   uint64_t pos;
   uint64_t align;
@@ -217,17 +224,18 @@ GNUNET_FS_directory_list_contents (size_t size,
           return; /* malformed ! */
         }
       pos += mdSize;
-      // EXTRACTOR_GNUNET_FULL_DATA
-      /* FIXME: add support for embedded data */
       filename = GNUNET_CONTAINER_meta_data_get_by_type (md,
                                                          EXTRACTOR_FILENAME);
+      file_data = GNUNET_CONTAINER_meta_data_get_by_type (md,
+                                                          EXTRACTOR_GNUNET_FULL_DATA);
       if (dep != NULL) 
          dep (dep_cls,
               filename,
               uri,
               md,
-              0,
-              NULL);
+              (file_data != NULL) ? strlen(file_data) : 0,
+              file_data);
+      GNUNET_free_non_null (file_data);
       GNUNET_free_non_null (filename);
       GNUNET_CONTAINER_meta_data_destroy (md);
       GNUNET_FS_uri_destroy (uri);
@@ -308,6 +316,7 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   struct BuilderEntry *e;
   uint64_t fsize;
   uint32_t big;
+  ssize_t ret;
   size_t mds;
   size_t mdxs;
   char *uris;
@@ -316,12 +325,12 @@ GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
   struct GNUNET_CONTAINER_MetaData *meta;
   const struct GNUNET_CONTAINER_MetaData *meta_use;
 
-  GNUNET_assert (! GNUNET_FS_uri_ksk_test (uri));
+  GNUNET_assert (! GNUNET_FS_uri_test_ksk (uri));
   if (NULL != data)
-    if (GNUNET_FS_uri_chk_test (uri))
-      fsize = GNUNET_FS_uri_chk_get_size (uri);
+    if (GNUNET_FS_uri_test_chk (uri))
+      fsize = GNUNET_FS_uri_chk_get_file_size (uri);
     else
-      fsize = GNUNET_FS_uri_chk_get_size (GNUNET_FS_uri_loc_get_uri (uri));
+      fsize = GNUNET_FS_uri_chk_get_file_size (GNUNET_FS_uri_loc_get_uri (uri));
   else
     fsize = 0; /* not given */
   if (fsize > GNUNET_FS_MAX_INLINE_SIZE)
@@ -500,8 +509,8 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   uint32_t big;
 
   size = 8 + sizeof (uint32_t);
-  size += GNUNET_meta_data_get_serialized_size (bld->meta, 
-                                                GNUNET_SERIALIZE_FULL);
+  size += GNUNET_CONTAINER_meta_data_get_serialized_size (bld->meta, 
+                                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   if (bld->count > 0)
     {
       sizes = GNUNET_malloc (bld->count * sizeof (size_t));
@@ -512,7 +521,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
         {
           perm[i] = i;
           bes[i] = pos;
-          sizes[i] = pos->size;
+          sizes[i] = pos->len;
           pos = pos->next;
         }
     }  
@@ -534,22 +543,22 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   memcpy (data, GNUNET_DIRECTORY_MAGIC, 8);
   off = 8;
 
-  ret = GNUNET_CONTAINER_meta_data_serialize (meta,
-                                              &(*data)[off +
-                                                       sizeof (uint32_t)],
-                                              size - pos - sizeof (uint32_t),
-                                              GNUNET_SERIALIZE_FULL);
+  ret = GNUNET_CONTAINER_meta_data_serialize (bld->meta,
+                                              &data[off +
+                                                    sizeof (uint32_t)],
+                                              size - off - sizeof (uint32_t),
+                                              GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   GNUNET_assert (ret != -1);
   big = htonl (ret);  
-  memcpy (&(*data)[8], &big, sizeof (uint32_t));
-  pos += sizeof (uint32_t) + ret;
-  for (j = 0; j < count; j++)
+  memcpy (&data[8], &big, sizeof (uint32_t));
+  off += sizeof (uint32_t) + ret;
+  for (j = 0; j < bld->count; j++)
     {
       i = perm[j];
-      psize = pos;
-      pos += sizes[i];
-      pos = do_align (psize, pos);
-      memcpy (&data[pos - sizes[i]], 
+      psize = off;
+      off += sizes[i];
+      off = do_align (psize, off);
+      memcpy (&data[off - sizes[i]], 
               &(bes[i])[1],
               sizes[i]);
       GNUNET_free (bes[i]);
@@ -557,7 +566,7 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   GNUNET_free (sizes);
   GNUNET_free (perm);
   GNUNET_free (bes);
-  GNUNET_assert (pos == size);  
+  GNUNET_assert (off == size);  
   GNUNET_CONTAINER_meta_data_destroy (bld->meta);
   GNUNET_free (bld);
 }
diff --git a/src/fs/fs_getopt.c b/src/fs/fs_getopt.c
index dfcc4fdc4..a0d232641 100644
--- a/src/fs/fs_getopt.c
+++ b/src/fs/fs_getopt.c
@@ -42,7 +42,7 @@
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_configure_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
+GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
                                          void *scls,
                                          const char *option,
                                          const char *value)
@@ -124,7 +124,7 @@ GNUNET_FS_getopt_configure_set_keywords (struct GNUNET_GETOPT_CommandLineProcess
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_configure_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
+GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
                                          void *scls,
                                          const char *option,
                                          const char *value)
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 0078d0d32..f5c2b4cdc 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -26,7 +26,6 @@
  * @author Christian Grothoff
  *
  * TODO:
- * - directory creation
  * - KBlocks
  * - SBlocks
  * - indexing support
@@ -119,6 +118,7 @@ ds_put_cont (void *cls,
  *
  * @param sc overall upload data
  * @param p file that the block belongs to (needed for options!)
+ * @param query what the block should be indexed under
  * @param blk encoded block to publish
  * @param blk_size size of the block
  * @param blk_type type of the block
@@ -127,15 +127,14 @@ ds_put_cont (void *cls,
 static void
 publish_block (struct GNUNET_FS_PublishContext *sc,
                struct GNUNET_FS_FileInformation *p,
+               const GNUNET_HashCode *query,
                const void* blk,
                uint16_t blk_size,
                uint32_t blk_type,
                GNUNET_SCHEDULER_Task cont)
 {
-  struct GNUNET_HashCode key;
+  struct PutContCtx * dpc_cls;
 
-  // FIXME: GNUNET_FS_get_key (blk_type, blk, blk_size, &key);
-  // (or add "key" as argument to reduce hashing?)
   dpc_cls = GNUNET_malloc(sizeof(struct PutContCtx));
   dpc_cls->cont = cont;
   dpc_cls->sc = sc;
@@ -146,8 +145,9 @@ publish_block (struct GNUNET_FS_PublishContext *sc,
   // a task ID!  
   GNUNET_DATASTORE_put (sc->dsh,
                         sc->rid,
-                        &key,
+                        query,
                         blk_size,
+                        blk,
                         blk_type,
                         p->priority,
                         p->anonymity,
@@ -280,7 +280,8 @@ compute_chk_offset (unsigned int height,
                     uint64_t offset)
 {
   uint64_t bds;
-  unsigned  int ret;
+  unsigned int ret;
+  unsigned int i;
 
   bds = GNUNET_FS_DBLOCK_SIZE; /* number of bytes each CHK at level "i"
                                   corresponds to */
@@ -305,7 +306,7 @@ static void
 publish_content (struct GNUNET_FS_PublishContext *sc,
                  struct GNUNET_FS_FileInformation *p)
 {
-  struct ContentHashKey *chk;
+  struct ContentHashKey *mychk;
   const void *pt_block;
   uint16_t pt_size;
   char *emsg;
@@ -315,6 +316,10 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   uint64_t size;
   unsigned int off;
+  struct GNUNET_FS_DirectoryBuilder *db;
+  struct GNUNET_FS_FileInformation *dirpos;
+  void *raw_data;
+  char *dd;
 
   // FIXME: figure out how to share this code
   // with unindex!
@@ -323,14 +328,47 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
     {
       if (p->is_directory)
         {
-          /* FIXME: create function to create directory
-             and use that API here! */
-          GNUNET_FS_directory_create (&p->data.dir.dir_size,
-                                      &p->data.dir.dir_data,
-                                      p->meta,
-                                      &directory_entry_lister,
-                                      p->data.dir.entries);
-          size = p->data.dir.data_size;
+          db = GNUNET_FS_directory_builder_create (p->meta);
+          dirpos = p->data.dir.entries;
+          while (NULL != dirpos)
+            {
+              if (dirpos->is_directory)
+                {
+                  raw_data = dirpos->data.dir.dir_data;
+                  dirpos->data.dir.dir_data = NULL;
+                }
+              else
+                {
+                  raw_data = NULL;
+                  if ( (dirpos->data.file.file_size < GNUNET_FS_MAX_INLINE_SIZE) &&
+                       (dirpos->data.file.file_size > 0) )
+                    {
+                      raw_data = GNUNET_malloc (dirpos->data.file.file_size);
+                      emsg = NULL;
+                      if (dirpos->data.file.file_size !=
+                          dirpos->data.file.reader (dirpos->data.file.reader_cls,
+                                                    0,
+                                                    dirpos->data.file.file_size,
+                                                    raw_data,
+                                                    &emsg))
+                        {
+                          GNUNET_free_non_null (emsg);
+                          GNUNET_free (raw_data);
+                          raw_data = NULL;
+                        } 
+                    }
+                }
+              GNUNET_FS_directory_builder_add (db,
+                                               dirpos->chk_uri,
+                                               dirpos->meta,
+                                               raw_data);
+              GNUNET_free_non_null (raw_data);
+              dirpos = dirpos->next;
+            }
+          GNUNET_FS_directory_builder_finish (db,
+                                              &p->data.dir.dir_size,
+                                              &p->data.dir.dir_data);
+          size = p->data.dir.dir_size;
         }
       p->chk_tree_depth = compute_depth (size);
       p->chk_tree = GNUNET_malloc (p->chk_tree_depth * 
@@ -344,17 +382,24 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
         {
           pt_size = GNUNET_MIN(GNUNET_FS_DBLOCK_SIZE,
                                p->data.dir.dir_size - p->publish_offset);
-          pt_block = &p->data.dir.dir_data[p->publish_offset];
+          dd = p->data.dir.dir_data;
+          pt_block = &dd[p->publish_offset];
         }
       else
         {
           pt_size = GNUNET_MIN(GNUNET_FS_DBLOCK_SIZE,
                                p->data.file.file_size - p->publish_offset);
-          p->data.file.reader (p->data.file.reader_cls,
-                               p->publish_offset,
-                               pt_size,
-                               iob,
-                               &emsg);
+          emsg = NULL;
+          if (pt_size !=
+              p->data.file.reader (p->data.file.reader_cls,
+                                   p->publish_offset,
+                                   pt_size,
+                                   iob,
+                                   &emsg))
+            {
+              // FIXME: abort with error "emsg"
+              GNUNET_free (emsg);
+            }
           pt_block = iob;
         }
     }
@@ -367,9 +412,9 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
     }
   off = compute_chk_offset (p->chk_tree_depth - p->current_depth,
                             p->publish_offset);
-  chk = &p->chk_tree[(p->current_depth-1)*GNUNET_FS_CHK_PER_INODE+off];
-  GNUNET_CRYPTO_hash (pt_block, pt_size, &chk->key);
-  GNUNET_CRYPTO_hash_to_aes_key (&chk->key, &sk, &iv);
+  mychk = &p->chk_tree[(p->current_depth-1)*GNUNET_FS_CHK_PER_INODE+off];
+  GNUNET_CRYPTO_hash (pt_block, pt_size, &mychk->key);
+  GNUNET_CRYPTO_hash_to_aes_key (&mychk->key, &sk, &iv);
   GNUNET_CRYPTO_aes_encrypt (pt_block,
                              pt_size,
                              &sk,
@@ -379,13 +424,16 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
   // between publish/unindex!  Parameterize & move this code!
   // FIXME: something around here would need to change
   // for indexing!
-  publish_block (sc, p, enc, pt_size, 
+  publish_block (sc, p, 
+                 &mychk->query,
+                 enc, 
+                 pt_size, 
                  (p->current_depth == p->chk_tree_depth) 
                  ? GNUNET_DATASTORE_BLOCKTYPE_DBLOCK 
                  : GNUNET_DATASTORE_BLOCKTYPE_IBLOCK,
                  &do_upload);
   // FIXME: should call progress function somewhere here!
-  GNUNET_CRYPTO_hash (enc, pt_size, &chk->query);
+  GNUNET_CRYPTO_hash (enc, pt_size, &mychk->query);
   if (p->current_depth == p->chk_tree_depth) 
     { 
       p->publish_offset += pt_size;
@@ -404,9 +452,9 @@ publish_content (struct GNUNET_FS_PublishContext *sc,
   if (0 == p->current_depth)
     {
       p->chk_uri = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
-      p->chk_uri.type = chk;
-      p->chk_uri.data.chk.chk = p->chk_tree[0];
-      p->chk_uri.data.chk.file_length = size;
+      p->chk_uri->type = chk;
+      p->chk_uri->data.chk.chk = p->chk_tree[0];
+      p->chk_uri->data.chk.file_length = size;
       GNUNET_free (p->chk_tree);
       p->chk_tree = NULL;
     }
@@ -445,7 +493,8 @@ do_upload (void *cls,
       publish_kblocks (sc, p);
       return;
     }
-  if (p->do_index)
+  if ( (!p->is_directory) &&
+       (p->data.file.do_index) )
     {
       // FIXME: need to pre-compute hash over
       // the entire file and ask FS to prepare
@@ -542,7 +591,7 @@ GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *sc)
   GNUNET_FS_namespace_delete (sc->namespace, GNUNET_NO);
   GNUNET_free_non_null (sc->nid);  
   GNUNET_free_non_null (sc->nuid);
-  GNUNET_DATASTORE_disconnect (sc->dsh);
+  GNUNET_DATASTORE_disconnect (sc->dsh, GNUNET_NO);
   GNUNET_free (sc);
 }
 
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
new file mode 100644
index 000000000..58885c234
--- /dev/null
+++ b/src/fs/gnunet-publish.c
@@ -0,0 +1,556 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, 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
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file fs/gnunet-publish.c
+ * @brief publishing files on GNUnet
+ * @author Christian Grothoff
+ * @author Krista Bennett
+ * @author James Blackwell
+ * @author Igor Wronsky
+ *
+ * TODO:
+ * - support for some options is still missing (uri argument, simulate)
+ * - progress callbacks not implemented (and need verbosity option)
+ * - clean shutdown is not implemented (stop ctx, etc.)
+ */
+#include "platform.h"
+#include "gnunet_fs_service.h"
+
+#define DEFAULT_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_YEARS, 2)
+
+static int ret;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_FS_Handle *ctx;
+
+static struct GNUNET_FS_PublishContext *pc;
+
+static struct GNUNET_TIME_Absolute start_time;
+
+static struct GNUNET_CONTAINER_MetaData *meta;
+
+static struct GNUNET_FS_Uri *topKeywords;
+
+static unsigned int anonymity = 1;
+
+static unsigned int priority = 365;
+
+static char *uri_string;
+
+static char *next_id;
+
+static char *this_id;
+
+static char *pseudonym;
+
+static int do_insert;
+
+static int disable_extractor;
+
+static int do_simulate;
+
+static int extract_only;
+
+static int do_disable_creation_time;
+
+
+/**
+ * Called by FS client to give information about the progress of an 
+ * operation.
+ *
+ * @param cls closure
+ * @param info details about the event, specifying the event type
+ *        and various bits about the event
+ * @return client-context (for the next progress call
+ *         for this operation; should be set to NULL for
+ *         SUSPEND and STOPPED events).  The value returned
+ *         will be passed to future callbacks in the respective
+ *         field in the GNUNET_FS_ProgressInfo struct.
+ */
+static void *
+progress_cb (void *cls,
+             const struct GNUNET_FS_ProgressInfo *info)
+{
+  return NULL;
+}
+
+
+/**
+ * Print metadata entries (except binary
+ * metadata and the filename).
+ *
+ * @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
+ */
+static int
+meta_printer (void *cls,
+              EXTRACTOR_KeywordType type,
+              const char *data)
+{
+  if ( (type == EXTRACTOR_FILENAME) ||
+       (EXTRACTOR_isBinaryType (type)) )
+    return GNUNET_OK;
+  fprintf (stdout, 
+           "%s - %s",
+           EXTRACTOR_getKeywordTypeAsString (type),
+           data);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Merge metadata entries (except binary
+ * metadata).
+ *
+ * @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
+ */
+static int
+meta_merger (void *cls,
+             EXTRACTOR_KeywordType type,
+             const char *data)
+{
+  struct GNUNET_CONTAINER_MetaData *m = cls;
+  GNUNET_CONTAINER_meta_data_insert (m,
+                                     type, 
+                                     data);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called on all entries before the
+ * publication.  This is where we perform
+ * modifications to the default based on
+ * command-line options.
+ *
+ * @param cls closure
+ * @param fi the entry in the publish-structure
+ * @param length length of the file or directory
+ * @param m metadata for the file or directory (can be modified)
+ * @param uri pointer to the keywords that will be used for this entry (can be modified)
+ * @param anonymity pointer to selected anonymity level (can be modified)
+ * @param priority pointer to selected priority (can be modified)
+ * @param expirationTime pointer to selected expiration time (can be modified)
+ * @param client_info pointer to client context set upon creation (can be modified)
+ * @return GNUNET_OK to continue, GNUNET_NO to remove
+ *         this entry from the directory, GNUNET_SYSERR
+ *         to abort the iteration
+ */
+static int
+publish_inspector (void *cls,
+                   struct GNUNET_FS_FileInformation *fi,
+                   uint64_t length,
+                   struct GNUNET_CONTAINER_MetaData *m,
+                   struct GNUNET_FS_Uri **uri,
+                   unsigned int *anonymity,
+                   unsigned int *priority,
+                   struct GNUNET_TIME_Absolute *expirationTime,
+                   void **client_info)
+{
+  char *fn;
+  char *fs;
+  struct GNUNET_FS_Uri *new_uri;
+
+  if (! do_disable_creation_time)
+    GNUNET_CONTAINER_meta_data_add_publication_date (meta);
+  if (NULL != topKeywords)
+    {
+      new_uri = GNUNET_FS_uri_ksk_merge (topKeywords,
+                                         *uri);
+      GNUNET_FS_uri_destroy (*uri);
+      *uri = new_uri;
+      GNUNET_FS_uri_destroy (topKeywords);
+      topKeywords = NULL;
+    }
+  if (NULL != meta)
+    {
+      GNUNET_CONTAINER_meta_data_get_contents (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);
+      fs = GNUNET_STRINGS_byte_size_fancy (length);
+      fprintf (stdout,
+               _("Keywords for file `%s' (%s)\n"),
+               fn,
+               fs);
+      GNUNET_free (fn);
+      GNUNET_free (fs);
+      GNUNET_CONTAINER_meta_data_get_contents (meta,
+                                               &meta_printer,
+                                               NULL);
+      fprintf (stdout, "\n");
+    }
+  if (GNUNET_FS_meta_data_test_for_directory (meta))
+    GNUNET_FS_file_information_inspect (fi,
+                                        &publish_inspector,
+                                        NULL);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param sched the scheduler to use
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     struct GNUNET_SCHEDULER_Handle *sched,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  struct GNUNET_FS_FileInformation *fi;
+  struct GNUNET_FS_Namespace *namespace;
+  EXTRACTOR_ExtractorList *l;
+  char *ex;
+  char *emsg;
+  
+  /* check arguments */
+  if ( ( (uri_string == NULL) || (extract_only) ) 
+       && ( (args[0] == NULL) || (args[1] != NULL) ) )
+    {
+      printf (_
+              ("You must specify one and only one filename for insertion.\n"));
+      ret = -1;
+      return;
+    }
+  if ((uri_string != NULL) && (args[0] != NULL))
+    {
+      printf (_("You must NOT specify an URI and a filename.\n"));
+      ret = -1;
+      return;
+    }
+  if ((uri_string != NULL) && (extract_only))
+    {
+      printf (_("Cannot extract metadata from a URI!\n"));
+      ret = -1;
+      return;
+    }
+  if (pseudonym != NULL)
+    {
+      if (NULL == this_id)
+        {
+          fprintf (stderr,
+                   _("Option `%s' is required when using option `%s'.\n"),
+                   "-t", "-P");
+          ret = -1;
+          return;
+        }
+    }
+  else
+    {                           /* ordinary insertion checks */
+      if (NULL != next_id)
+        {
+          fprintf (stderr,
+                   _("Option `%s' makes no sense without option `%s'.\n"),
+                   "-N", "-P");
+          ret = -1;
+          return;
+        }
+      if (NULL != this_id)
+        {
+          fprintf (stderr,
+                   _("Option `%s' makes no sense without option `%s'.\n"),
+                   "-t", "-P");
+          ret = -1;
+          return;
+        }
+    }
+  if (args[0] == NULL)
+    {
+      fprintf (stderr,
+               _("Need the name of a file to publish!\n"));
+      ret = 1;
+      return;
+    }
+  cfg = c;
+  ctx = GNUNET_FS_start (sched,
+                         cfg,
+                         "gnunet-publish",
+                         &progress_cb,
+                         NULL);
+  if (NULL == ctx)
+    {
+      fprintf (stderr,
+               _("Could not initialize `%s' subsystem.\n"),
+               "FS");
+      ret = 1;
+      return;
+    }
+  namespace = NULL;
+  if (NULL != pseudonym)
+    {
+      namespace = GNUNET_FS_namespace_create (ctx,
+                                              pseudonym);
+      if (NULL == namespace)
+        {
+          fprintf (stderr,
+                   _("Could not create namespace `%s'\n"),
+                   pseudonym);
+          GNUNET_FS_stop (ctx);
+          ret = 1;
+          return;
+        }
+    }
+  if (NULL != uri_string)
+    {
+      // FIXME -- implement!
+      return;
+    }
+  start_time = GNUNET_TIME_absolute_get ();
+
+  l = NULL;
+  if (! disable_extractor)
+    {
+      l = EXTRACTOR_loadDefaultLibraries ();
+      if (GNUNET_OK ==
+          GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS",
+                                                 &ex))
+        {
+          if (strlen (ex) > 0)
+            l = EXTRACTOR_loadConfigLibraries (l, ex);
+          GNUNET_free (ex);
+        }
+    }
+  fi = GNUNET_FS_file_information_create_from_directory (NULL,
+                                                         args[0],
+                                                         &GNUNET_FS_directory_scanner_default,
+                                                         l,
+                                                         !do_insert,
+                                                         anonymity,
+                                                         priority,
+                                                         GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION),
+                                                         &emsg);
+  EXTRACTOR_removeAll (l);  
+  if (fi == NULL)
+    {
+      fprintf (stderr,
+               _("Could not publish `%s': %s\n"),
+               args[0],
+               emsg);
+      GNUNET_free (emsg);
+      if (namespace != NULL)
+        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+      GNUNET_FS_stop (ctx);
+      ret = 1;
+      return;
+    }
+  GNUNET_FS_file_information_inspect (fi,
+                                      &publish_inspector,
+                                      NULL);
+  if (extract_only)
+    {
+      if (namespace != NULL)
+        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+      GNUNET_FS_file_information_destroy (fi, NULL, NULL);
+      GNUNET_FS_stop (ctx);
+      return;
+    }
+  pc = GNUNET_FS_publish_start (ctx,
+                                NULL,
+                                fi,
+                                namespace,
+                                this_id,
+                                next_id);
+}
+
+
+/**
+ * gnunet-publish command line options
+ */
+static struct GNUNET_GETOPT_CommandLineOption options[] = {
+  {'a', "anonymity", "LEVEL",
+   gettext_noop ("set the desired LEVEL of sender-anonymity"),
+   1, &GNUNET_GETOPT_set_uint, &anonymity},
+  {'d', "disable-creation-time", NULL,
+   gettext_noop
+   ("disable adding the creation time to the metadata of the uploaded file"),
+   0, &GNUNET_GETOPT_set_one, &do_disable_creation_time},
+  {'D', "disable-extractor", NULL,
+   gettext_noop
+   ("do not use libextractor to add keywords or metadata"),
+   0, &GNUNET_GETOPT_set_one, &disable_extractor},
+  {'e', "extract", NULL,
+   gettext_noop
+   ("print list of extracted keywords that would be used, but do not perform upload"),
+   0, &GNUNET_GETOPT_set_one, &extract_only},
+  {'k', "key", "KEYWORD",
+   gettext_noop
+   ("add an additional keyword for the top-level file or directory"
+    " (this option can be specified multiple times)"),
+   1, &GNUNET_FS_getopt_set_keywords, &topKeywords},
+  // *: option not yet used... (can handle in a pass over FI)
+  {'m', "meta", "TYPE:VALUE",
+   gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
+   1, &GNUNET_FS_getopt_set_metadata, &meta},
+  {'n', "noindex", NULL,
+   gettext_noop ("do not index, perform full insertion (stores entire "
+                 "file in encrypted form in GNUnet database)"),
+   0, &GNUNET_GETOPT_set_one, &do_insert},
+  {'N', "next", "ID",
+   gettext_noop
+   ("specify ID of an updated version to be published in the future"
+    " (for namespace insertions only)"),
+   1, &GNUNET_GETOPT_set_string, &next_id},
+  {'p', "priority", "PRIORITY",
+   gettext_noop ("specify the priority of the content"),
+   1, &GNUNET_GETOPT_set_uint, &priority},
+  {'P', "pseudonym", "NAME",
+   gettext_noop
+   ("publish the files under the pseudonym NAME (place file into namespace)"),
+   1, &GNUNET_GETOPT_set_string, &pseudonym},
+  // *: option not yet used... (need FS API support!)
+  {'s', "simulate-only", NULL,
+   gettext_noop ("only simulate the process but do not do any "
+                 "actual publishing (useful to compute URIs)"),
+   0, &GNUNET_GETOPT_set_one, &do_simulate},
+  {'t', "this", "ID",
+   gettext_noop ("set the ID of this version of the publication"
+                 " (for namespace insertions only)"),
+   1, &GNUNET_GETOPT_set_string, &this_id},
+  // *: option not yet used... (need FS API support!)
+  {'u', "uri", "URI",
+   gettext_noop ("URI to be published (can be used instead of passing a "
+                 "file to add keywords to the file with the respective URI)"),
+   1, &GNUNET_GETOPT_set_string, &uri_string},
+  GNUNET_GETOPT_OPTION_END
+};
+
+
+/**
+ * The main function to publish content to GNUnet.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "gnunet-publish",
+                              gettext_noop
+                              ("Publish files on GNUnet."),
+                              options, &run, NULL)) ? ret : 1;
+}
+
+/* end of gnunet-publish.c */
+
+////////////////////////////////////////////////////////////////
+
+
+/**
+ * Print progess message.
+ */
+static void *
+printstatus (void *ctx, const GNUNET_FSUI_Event * event)
+{
+  unsigned long long delta;
+  char *fstring;
+
+  switch (event->type)
+    {
+    case GNUNET_FSUI_upload_progress:
+      if (*verboselevel)
+        {
+          char *ret;
+          GNUNET_CronTime now;
+
+          now = GNUNET_get_time ();
+          delta = event->data.UploadProgress.eta - now;
+          if (event->data.UploadProgress.eta < now)
+            delta = 0;
+          ret = GNUNET_get_time_interval_as_fancy_string (delta);
+          PRINTF (_("%16llu of %16llu bytes inserted "
+                    "(estimating %6s to completion) - %s\n"),
+                  event->data.UploadProgress.completed,
+                  event->data.UploadProgress.total,
+                  ret, event->data.UploadProgress.filename);
+          GNUNET_free (ret);
+        }
+      break;
+    case GNUNET_FSUI_upload_completed:
+      if (*verboselevel)
+        {
+          delta = GNUNET_get_time () - start_time;
+          PRINTF (_("Upload of `%s' complete, "
+                    "%llu bytes took %llu seconds (%8.3f KiB/s).\n"),
+                  event->data.UploadCompleted.filename,
+                  event->data.UploadCompleted.total,
+                  delta / GNUNET_CRON_SECONDS,
+                  (delta == 0)
+                  ? (double) (-1.0)
+                  : (double) (event->data.UploadCompleted.total
+                              / 1024.0 * GNUNET_CRON_SECONDS / delta));
+        }
+      fstring = GNUNET_ECRS_uri_to_string (event->data.UploadCompleted.uri);
+      printf (_("File `%s' has URI: %s\n"),
+              event->data.UploadCompleted.filename, fstring);
+      GNUNET_free (fstring);
+      if (ul == event->data.UploadCompleted.uc.pos)
+        {
+          postProcess (event->data.UploadCompleted.uri);
+          errorCode = 0;
+          GNUNET_shutdown_initiate ();
+        }
+      break;
+    case GNUNET_FSUI_upload_aborted:
+      printf (_("\nUpload aborted.\n"));
+      errorCode = 2;
+      GNUNET_shutdown_initiate ();
+      break;
+    case GNUNET_FSUI_upload_error:
+      printf (_("\nError uploading file: %s"),
+              event->data.UploadError.message);
+      errorCode = 3;
+      GNUNET_shutdown_initiate ();
+      break;
+    case GNUNET_FSUI_upload_started:
+    case GNUNET_FSUI_upload_stopped:
+      break;
+    default:
+      printf (_("\nUnexpected event: %d\n"), event->type);
+      GNUNET_GE_BREAK (ectx, 0);
+      break;
+    }
+  return NULL;
+}
+#endif
+
+/* end of gnunet-publish.c */
diff --git a/src/include/gnunet_connection_lib.h b/src/include/gnunet_connection_lib.h
index bc4aeea9b..69bd7d4a6 100644
--- a/src/include/gnunet_connection_lib.h
+++ b/src/include/gnunet_connection_lib.h
@@ -23,8 +23,8 @@
  * @brief basic, low-level TCP networking interface

  * @author Christian Grothoff

  */

-#ifndef GNUNET_NETWORK_LIB_H

-#define GNUNET_NETWORK_LIB_H

+#ifndef GNUNET_CONNECTION_LIB_H

+#define GNUNET_CONNECTION_LIB_H

 

 #ifdef __cplusplus

 extern "C"

@@ -325,6 +325,6 @@ GNUNET_NETWORK_connection_notify_transmit_ready_cancel (struct
 #endif

 

 

-/* ifndef GNUNET_NETWORK_LIB_H */

+/* ifndef GNUNET_CONNECTION_LIB_H */

 #endif

 /* end of gnunet_connection_lib.h */

diff --git a/src/include/gnunet_container_lib.h b/src/include/gnunet_container_lib.h
index e2a0787c8..1adae17b1 100644
--- a/src/include/gnunet_container_lib.h
+++ b/src/include/gnunet_container_lib.h
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -201,11 +201,16 @@ typedef int (*GNUNET_CONTAINER_MetaDataProcessor) (void *cls,
 
 /**
  * Create a fresh MetaData token.
+ * 
+ * @return empty meta-data container
  */
 struct GNUNET_CONTAINER_MetaData *GNUNET_CONTAINER_meta_data_create (void);
 
 /**
  * Duplicate a MetaData token.
+ * 
+ * @param meta what to duplicate
+ * @return duplicate meta-data container
  */
 struct GNUNET_CONTAINER_MetaData *GNUNET_CONTAINER_meta_data_duplicate (const
                                                                         struct
@@ -214,12 +219,18 @@ struct GNUNET_CONTAINER_MetaData *GNUNET_CONTAINER_meta_data_duplicate (const
 
 /**
  * Free meta data.
+ *
+ * @param md what to free
  */
 void GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData
                                          *md);
 
 /**
  * Test if two MDs are equal.
+ *
+ * @param md1 first value to check
+ * @param md2 other value to check
+ * @return GNUNET_YES if they are equal
  */
 int GNUNET_CONTAINER_meta_data_test_equal (const struct
                                            GNUNET_CONTAINER_MetaData *md1,
@@ -229,6 +240,10 @@ int GNUNET_CONTAINER_meta_data_test_equal (const struct
 
 /**
  * Extend metadata.
+ *
+ * @param md metadata to extend
+ * @param type type of the new entry
+ * @param data value for the entry
  * @return GNUNET_OK on success, GNUNET_SYSERR if this entry already exists
  */
 int GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
@@ -237,6 +252,10 @@ int GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
 
 /**
  * Remove an item.
+ *
+ * @param type type of the item to remove
+ * @param data specific value to remove, NULL to remove all
+ *        entries of the given type
  * @return GNUNET_OK on success, GNUNET_SYSERR if the item does not exist in md
  */
 int GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
@@ -246,6 +265,8 @@ int GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
 /**
  * Add the current time as the publication date
  * to the meta-data.
+ *
+ * @param md metadata to modify
  */
 void GNUNET_CONTAINER_meta_data_add_publication_date (struct
                                                       GNUNET_CONTAINER_MetaData
@@ -254,6 +275,9 @@ void GNUNET_CONTAINER_meta_data_add_publication_date (struct
 /**
  * Iterate over MD entries, excluding thumbnails.
  *
+ * @param md metadata to inspect
+ * @param iterator function to call on each entry
+ * @param closure closure for iterator
  * @return number of entries
  */
 int GNUNET_CONTAINER_meta_data_get_contents (const struct
@@ -263,6 +287,9 @@ int GNUNET_CONTAINER_meta_data_get_contents (const struct
 
 /**
  * Get the first MD entry of the given type.
+ *
+ * @param md metadata to inspect
+ * @param type type to look for
  * @return NULL if we do not have any such entry,
  *  otherwise client is responsible for freeing the value!
  */
@@ -272,7 +299,9 @@ char *GNUNET_CONTAINER_meta_data_get_by_type (const struct
 
 /**
  * Get the first matching MD entry of the given types.
- * @paarm ... -1-terminated list of types
+ *
+ * @param md metadata to inspect
+ * @param ... -1-terminated list of types
  * @return NULL if we do not have any such entry,
  *  otherwise client is responsible for freeing the value!
  */
@@ -283,6 +312,7 @@ char *GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
 /**
  * Get a thumbnail from the meta-data (if present).
  *
+ * @param md metadata to inspect
  * @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
@@ -294,6 +324,9 @@ size_t GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
 /**
  * Extract meta-data from a file.
  *
+ * @param md metadata to set
+ * @param filename name of file to inspect
+ * @param extractors plugins to use
  * @return GNUNET_SYSERR on error, otherwise the number
  *   of meta-data items obtained
  */
@@ -315,12 +348,13 @@ enum GNUNET_CONTAINER_MetaDataSerializationOptions
 /**
  * Serialize meta-data to target.
  *
+ * @param md metadata to serialize
  * @param size maximum number of bytes available
  * @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
+ *         -1 on error (typically: not enough
  *         space)
  */
 ssize_t GNUNET_CONTAINER_meta_data_serialize (const struct
@@ -334,9 +368,12 @@ ssize_t GNUNET_CONTAINER_meta_data_serialize (const struct
 /**
  * Compute size of the meta-data in
  * serialized form.
+ *
+ * @param md metadata to inspect
  * @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 needed for serialization, -1 on error
  */
 ssize_t GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
                                                         GNUNET_CONTAINER_MetaData
@@ -347,6 +384,8 @@ ssize_t GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
 
 /**
  * Deserialize meta-data.  Initializes md.
+ *
+ * @param input serialized meta-data.
  * @param size number of bytes available
  * @return MD on success, NULL on error (i.e.
  *         bad format)
@@ -359,6 +398,7 @@ struct GNUNET_CONTAINER_MetaData
  * Does the meta-data claim that this is a directory?
  * Checks if the mime-type is that of a GNUnet directory.
  *
+ * @param md metadata to inspect
  * @return GNUNET_YES if it is, GNUNET_NO if it is not, GNUNET_SYSERR if
  *  we have no mime-type information (treat as 'GNUNET_NO')
  */
diff --git a/src/include/gnunet_fs_service.h b/src/include/gnunet_fs_service.h
index 3c71d40e7..f78ed51e5 100644
--- a/src/include/gnunet_fs_service.h
+++ b/src/include/gnunet_fs_service.h
@@ -21,6 +21,10 @@
  * @file include/gnunet_fs_service.h
  * @brief API for file-sharing via GNUnet 
  * @author Christian Grothoff
+ *
+ * TODO:
+ * - extend API with support for publish simulation (-s)
+ *   and URI-argument binding to keyword/namespace (-u)
  */
 #ifndef GNUNET_FS_LIB_H
 #define GNUNET_FS_LIB_H
@@ -398,7 +402,7 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_configure_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
+GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
                                          void *scls,
                                          const char *option,
                                          const char *value);
@@ -417,7 +421,7 @@ GNUNET_FS_getopt_configure_set_keywords (struct GNUNET_GETOPT_CommandLineProcess
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_configure_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
+GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
                                          void *scls,
                                          const char *option,
                                          const char *value);
diff --git a/src/include/gnunet_network_lib.h b/src/include/gnunet_network_lib.h
index baba3aba8..645353520 100644
--- a/src/include/gnunet_network_lib.h
+++ b/src/include/gnunet_network_lib.h
@@ -24,8 +24,8 @@
  * @author Nils Durner
  */
 
-#ifndef GNUNET_NETWORK_LIB_H_
-#define GNUNET_NETWORK_LIB_H_
+#ifndef GNUNET_NETWORK_LIB_H
+#define GNUNET_NETWORK_LIB_H
 
 #ifdef __cplusplus
 extern "C"
@@ -54,6 +54,11 @@ struct GNUNET_NETWORK_Descriptor *GNUNET_NETWORK_socket_accept (const struct GNU
                       struct sockaddr *address,
                       socklen_t *address_len);
 
+int
+GNUNET_NETWORK_socket_set_inheritable (const struct GNUNET_NETWORK_Descriptor
+                                       *desc);
+
+
 int GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Descriptor *desc,
                     const struct sockaddr *address, socklen_t address_len);
 
@@ -128,7 +133,7 @@ int GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
 
 int GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1, const struct GNUNET_NETWORK_FDSet *fds2);
 
-struct GNUNET_NETWORK_FDSet *GNUNET_NETWORK_fdset_create ();
+struct GNUNET_NETWORK_FDSet *GNUNET_NETWORK_fdset_create (void);
 
 void GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds);
 
@@ -140,4 +145,4 @@ void GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds);
 }
 #endif
 
-#endif /* GNUNET_NETWORK_LIB_H_ */
+#endif /* GNUNET_NETWORK_LIB_H */
diff --git a/src/util/Makefile.am b/src/util/Makefile.am
index f6c1783a6..d58d80bac 100644
--- a/src/util/Makefile.am
+++ b/src/util/Makefile.am
@@ -37,6 +37,7 @@ libgnunetutil_la_SOURCES = \
   getopt.c \
   getopt_helpers.c \
   network.c \
+  network_socket.c \
   os_installation.c \
   os_load.c \
   os_network.c \
@@ -49,7 +50,6 @@ libgnunetutil_la_SOURCES = \
   server_tc.c \
   service.c \
   signal.c \
-  sock.c \
   strings.c \
   time.c \
   $(WINSRC)
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
index d80c5fd2b..4cb4ea148 100644
--- a/src/util/container_meta_data.c
+++ b/src/util/container_meta_data.c
@@ -689,6 +689,10 @@ FAILURE:
 
 /**
  * Test if two MDs are equal.
+ *
+ * @param md1 first value to check
+ * @param md2 other value to check
+ * @return GNUNET_YES if they are equal
  */
 int
 GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
diff --git a/src/util/sock.c b/src/util/network_socket.c
index 33b6df148..59afb7246 100644
--- a/src/util/sock.c
+++ b/src/util/network_socket.c
@@ -675,4 +675,4 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 #endif

 }

 

-/* end of io.c */

+/* end of sock.c */