fix key management issue with LOC signing identified in #3559

11 files changed, 454 insertions, 171 deletions

diff --git a/src/fs/Makefile.am b/src/fs/Makefile.am
index 1dd6065f0..39c9e3c85 100644
--- a/src/fs/Makefile.am
+++ b/src/fs/Makefile.am
@@ -380,7 +380,7 @@ test_fs_search_with_and_SOURCES = \
 test_fs_search_with_and_LDADD = \
   $(top_builddir)/src/testing/libgnunettesting.la \
   libgnunetfs.la        \
-  $(top_builddir)/src/util/libgnunetutil.la  
+  $(top_builddir)/src/util/libgnunetutil.la
 
 test_fs_search_probes_SOURCES = \
  test_fs_search_probes.c
@@ -525,7 +525,6 @@ EXTRA_DIST = \
   test_fs_publish_data.conf \
   test_fs_search_data.conf \
   test_fs_unindex_data.conf \
-  test_fs_uri_data.conf \
   test_gnunet_service_fs_migration_data.conf \
   test_gnunet_service_fs_p2p_cadet.conf \
   test_gnunet_fs_idx_data.conf \
diff --git a/src/fs/fs.h b/src/fs/fs.h
index ae6ca489a..5fa4261b2 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -66,6 +66,77 @@ struct ContentHashKey
 
 GNUNET_NETWORK_STRUCT_BEGIN
 
+
+/**
+ * Message sent from a GNUnet (fs) publishing activity to sign
+ * a LOC URI.
+ */
+struct RequestLocSignatureMessage
+{
+
+  /**
+   * Message type will be #GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Requested signature purpose.  For now, always
+   * #GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT.
+   */
+  uint32_t purpose GNUNET_PACKED;
+
+  /**
+   * Requested expiration time.
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * Information about the shared file (to be signed).
+   */
+  struct ContentHashKey chk;
+
+  /**
+   * Size of the shared file (to be signed).
+   */
+  uint64_t file_length;
+};
+
+
+/**
+ * Message sent from the service with the signed LOC URI.
+ */
+struct ResponseLocSignatureMessage
+{
+
+  /**
+   * Message type will be
+   * #GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Purpose of the generated signature.  For now, always
+   * #GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT.
+   */
+  uint32_t purpose GNUNET_PACKED;
+
+  /**
+   * Expiration time that was actually used (rounded!).
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The requested signature.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature signature;
+
+  /**
+   * Identity of the peer sharing the file.
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
 /**
  * Message sent from a GNUnet (fs) publishing activity to the
  * gnunet-fs-service to initiate indexing of a file.  The service is
diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index 46f398e86..157662a65 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -416,15 +416,17 @@ struct GNUNET_FS_FileInformation
  * @param cls closure
  * @param client handle to use for FS communication
  */
-typedef void (*GNUNET_FS_QueueStart) (void *cls,
-                                      struct GNUNET_CLIENT_Connection * client);
+typedef void
+(*GNUNET_FS_QueueStart) (void *cls,
+                         struct GNUNET_CLIENT_Connection *client);
 
 
 /**
  * The job must now stop to run and should destry the client handle as
  * soon as possible (ideally prior to returning).
  */
-typedef void (*GNUNET_FS_QueueStop) (void *cls);
+typedef void
+(*GNUNET_FS_QueueStop) (void *cls);
 
 
 
@@ -680,7 +682,7 @@ GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe);
  *            that the caller might need to go backwards
  *            a bit at times
  * @param max maximum number of bytes that should be
- *            copied to buf; readers are not allowed
+ *            copied to @a buf; readers are not allowed
  *            to provide less data unless there is an error;
  *            a value of "0" will be used at the end to allow
  *            the reader to clean up its internal state
@@ -689,12 +691,15 @@ GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe);
  * @return number of bytes written, usually "max", 0 on error
  */
 size_t
-GNUNET_FS_data_reader_file_ (void *cls, uint64_t offset, size_t max, void *buf,
+GNUNET_FS_data_reader_file_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
                              char **emsg);
 
 
 /**
- * Create the closure for the 'GNUNET_FS_data_reader_file_' callback.
+ * Create the closure for the #GNUNET_FS_data_reader_file_() callback.
  *
  * @param filename file to read
  * @return closure to use
@@ -712,23 +717,26 @@ GNUNET_FS_make_file_reader_context_ (const char *filename);
  *            that the caller might need to go backwards
  *            a bit at times
  * @param max maximum number of bytes that should be
- *            copied to buf; readers are not allowed
+ *            copied to @a buf; readers are not allowed
  *            to provide less data unless there is an error;
  *            a value of "0" will be used at the end to allow
  *            the reader to clean up its internal state
  * @param buf where the reader should write the data
  * @param emsg location for the reader to store an error message
- * @return number of bytes written, usually "max", 0 on error
+ * @return number of bytes written, usually @a max, 0 on error
  */
 size_t
-GNUNET_FS_data_reader_copy_ (void *cls, uint64_t offset, size_t max, void *buf,
+GNUNET_FS_data_reader_copy_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
                              char **emsg);
 
 
 /**
  * Notification of FS that a search probe has made progress.
  * This function is used INSTEAD of the client's event handler
- * for downloads where the GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.
+ * for downloads where the #GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.
  *
  * @param cls closure, always NULL (!), actual closure
  *        is in the client-context of the info struct
@@ -738,7 +746,7 @@ GNUNET_FS_data_reader_copy_ (void *cls, uint64_t offset, size_t max, void *buf,
  *         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.
+ *         field in the `struct GNUNET_FS_ProgressInfo`.
  */
 void *
 GNUNET_FS_search_probe_progress_ (void *cls,
@@ -764,7 +772,8 @@ GNUNET_FS_publish_main_ (void *cls,
  * @param file_id computed hash, NULL on error
  */
 void
-GNUNET_FS_unindex_process_hash_ (void *cls, const struct GNUNET_HashCode * file_id);
+GNUNET_FS_unindex_process_hash_ (void *cls,
+                                 const struct GNUNET_HashCode *file_id);
 
 
 /**
@@ -890,6 +899,7 @@ GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc);
 void
 GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
 
+
 /**
  * Remove serialization/deserialization file from disk.
  *
@@ -898,7 +908,8 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
  * @param ent entity identifier
  */
 void
-GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h, const char *ext,
+GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
+                             const char *ext,
                              const char *ent);
 
 
@@ -991,7 +1002,7 @@ GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc);
  * Create SUSPEND event for the given publish operation
  * and then clean up our state (without stop signal).
  *
- * @param cls the 'struct GNUNET_FS_PublishContext' to signal for
+ * @param cls the `struct GNUNET_FS_PublishContext` to signal for
  */
 void
 GNUNET_FS_publish_signal_suspend_ (void *cls);
@@ -1021,7 +1032,7 @@ GNUNET_FS_download_signal_suspend_ (void *cls);
  * Create SUSPEND event for the given unindex operation
  * and then clean up our state (without stop signal).
  *
- * @param cls the 'struct GNUNET_FS_UnindexContext' to signal for
+ * @param cls the `struct GNUNET_FS_UnindexContext` to signal for
  */
 void
 GNUNET_FS_unindex_signal_suspend_ (void *cls);
@@ -1212,6 +1223,11 @@ struct GNUNET_FS_PublishContext
   struct GNUNET_FS_Handle *h;
 
   /**
+   * Connection to FS service (only used for LOC URI signing).
+   */
+  struct GNUNET_CLIENT_Handle *fs_client;
+
+  /**
    * Our top-level activity entry (if we are top-level, otherwise NULL).
    */
   struct TopLevelActivity *top;
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index beeab8b12..a8a9a220f 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -823,6 +823,116 @@ hash_for_index_cb (void *cls,
 
 
 /**
+ * We've computed the CHK/LOC URI, now publish the KSKs (if applicable).
+ *
+ * @param pc publishing context to do this for
+ */
+static void
+publish_kblocks (struct GNUNET_FS_PublishContext *pc)
+{
+  struct GNUNET_FS_FileInformation *p;
+
+  p = pc->fi_pos;
+  /* upload of "p" complete, publish KBlocks! */
+  if (NULL != p->keywords)
+  {
+    pc->ksk_pc = GNUNET_FS_publish_ksk (pc->h,
+                                        p->keywords,
+                                        p->meta,
+                                        p->chk_uri,
+                                        &p->bo,
+                                        pc->options,
+                                        &publish_kblocks_cont, pc);
+  }
+  else
+  {
+    publish_kblocks_cont (pc, p->chk_uri, NULL);
+  }
+}
+
+
+/**
+ * Process the response (or lack thereof) from
+ * the "fs" service to our LOC sign request.
+ *
+ * @param cls closure (of type `struct GNUNET_FS_PublishContext *`)
+ * @param msg the response we got
+ */
+static void
+process_signature_response (void *cls,
+                            const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_FS_PublishContext *pc = cls;
+  const struct ResponseLocSignatureMessage *sig;
+  struct GNUNET_FS_FileInformation *p;
+
+  p = pc->fi_pos;
+  if (NULL == msg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Can not create LOC URI. Will continue with CHK instead.\n"));
+    publish_kblocks (pc);
+    return;
+  }
+  if (sizeof (struct ResponseLocSignatureMessage) !=
+      ntohs (msg->size))
+  {
+    GNUNET_break (0);
+    publish_kblocks (pc);
+    return;
+  }
+  sig = (const struct ResponseLocSignatureMessage *) msg;
+  p->chk_uri->type = GNUNET_FS_URI_LOC;
+  /* p->data.loc.fi kept from CHK before */
+  p->chk_uri->data.loc.peer = sig->peer;
+  p->chk_uri->data.loc.expirationTime = GNUNET_TIME_absolute_ntoh (sig->expiration_time);
+  p->chk_uri->data.loc.contentSignature = sig->signature;
+  GNUNET_FS_file_information_sync_ (p);
+  GNUNET_FS_publish_sync_ (pc);
+  publish_kblocks (pc);
+}
+
+
+/**
+ * We're publishing without anonymity. Contact the FS service
+ * to create a signed LOC URI for further processing, then
+ * continue with KSKs.
+ *
+ * @param pc the publishing context do to this for
+ */
+static void
+create_loc_uri (struct GNUNET_FS_PublishContext *pc)
+{
+  struct RequestLocSignatureMessage req;
+  struct GNUNET_FS_FileInformation *p;
+
+  if (NULL == pc->client)
+    pc->client = GNUNET_CLIENT_connect ("fs", pc->h->cfg);
+  if (NULL == pc->client)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Can not create LOC URI. Will continue with CHK instead.\n"));
+    publish_kblocks (pc);
+    return;
+  }
+  p = pc->fi_pos;
+  req.header.size = htons (sizeof (struct RequestLocSignatureMessage));
+  req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN);
+  req.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  req.expiration_time = GNUNET_TIME_absolute_hton (p->bo.expiration_time);
+  req.chk = p->chk_uri->data.chk.chk;
+  req.file_length = GNUNET_htonll (p->chk_uri->data.chk.file_length);
+  GNUNET_break (GNUNET_YES ==
+                GNUNET_CLIENT_transmit_and_get_response (pc->client,
+                                                         &req.header,
+                                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                                         GNUNET_YES,
+                                                         &process_signature_response,
+                                                         pc));
+}
+
+
+/**
  * Main function that performs the upload.
  *
  * @param cls `struct GNUNET_FS_PublishContext *` identifies the upload
@@ -835,7 +945,6 @@ GNUNET_FS_publish_main_ (void *cls,
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_FS_FileInformation *p;
-  struct GNUNET_FS_Uri *loc;
   char *fn;
 
   pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
@@ -875,13 +984,17 @@ GNUNET_FS_publish_main_ (void *cls,
       p = p->dir;
       if (fn != NULL)
       {
-        GNUNET_asprintf (&p->emsg, _("Recursive upload failed at `%s': %s"), fn,
+        GNUNET_asprintf (&p->emsg,
+                         _("Recursive upload failed at `%s': %s"),
+                         fn,
                          p->emsg);
         GNUNET_free (fn);
       }
       else
       {
-        GNUNET_asprintf (&p->emsg, _("Recursive upload failed: %s"), p->emsg);
+        GNUNET_asprintf (&p->emsg,
+                         _("Recursive upload failed: %s"),
+                         p->emsg);
       }
       pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
       pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
@@ -897,31 +1010,18 @@ GNUNET_FS_publish_main_ (void *cls,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "File upload complete, now publishing KSK blocks.\n");
-    if (0 == p->bo.anonymity_level)
-    {
-      /* zero anonymity, box CHK URI in LOC URI */
-      loc = GNUNET_FS_uri_loc_create (p->chk_uri,
-                                      pc->h->cfg,
-                                      p->bo.expiration_time);
-      GNUNET_FS_uri_destroy (p->chk_uri);
-      p->chk_uri = loc;
-      GNUNET_FS_file_information_sync_ (p);
-    }
     GNUNET_FS_publish_sync_ (pc);
-    /* upload of "p" complete, publish KBlocks! */
-    if (NULL != p->keywords)
+
+    if ( (0 == p->bo.anonymity_level) &&
+         (GNUNET_YES !=
+          GNUNET_FS_uri_test_loc (p->chk_uri)) )
     {
-      pc->ksk_pc = GNUNET_FS_publish_ksk (pc->h,
-                                          p->keywords,
-                                          p->meta,
-                                          p->chk_uri,
-                                          &p->bo,
-                                          pc->options,
-                                          &publish_kblocks_cont, pc);
+      /* zero anonymity, box CHK URI in LOC URI */
+      create_loc_uri (pc);
     }
     else
     {
-      publish_kblocks_cont (pc, p->chk_uri, NULL);
+      publish_kblocks (pc);
     }
     return;
   }
@@ -1320,7 +1420,7 @@ fip_signal_stop (void *cls,
     pc->skip_next_fi_callback = GNUNET_YES;
     GNUNET_FS_file_information_inspect (fi, &fip_signal_stop, pc);
   }
-  if (fi->serialization != NULL)
+  if (NULL != fi->serialization)
   {
     GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
                                  fi->serialization);
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 1597f38ae..883e4b84a 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -837,61 +837,46 @@ GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri)
 
 /**
  * Construct a location URI (this peer will be used for the location).
+ * This function should only be called from within gnunet-service-fs,
+ * as it requires the peer's private key which is generally unavailable
+ * to processes directly under the user's control.  However, for
+ * testing and as it logically fits under URIs, it is in this API.
  *
- * @param baseUri content offered by the sender
- * @param cfg configuration information (used to find our hostkey)
+ * @param base_uri content offered by the sender
+ * @param sign_key private key of the peer
  * @param expiration_time how long will the content be offered?
  * @return the location URI, NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
-                          const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *base_uri,
+                          const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
                           struct GNUNET_TIME_Absolute expiration_time)
 {
   struct GNUNET_FS_Uri *uri;
-  struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
   struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
-  char *keyfile;
   struct LocUriAssembly ass;
   struct GNUNET_TIME_Absolute et;
 
-  if (baseUri->type != GNUNET_FS_URI_CHK)
+  if (GNUNET_FS_URI_CHK != base_uri->type)
     return NULL;
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                               "PEER", "PRIVATE_KEY",
-                                               &keyfile))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Lacking key configuration settings.\n"));
-    return NULL;
-  }
-  if (NULL ==
-      (my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not access hostkey file `%s'.\n"), keyfile);
-    GNUNET_free (keyfile);
-    return NULL;
-  }
-  GNUNET_free (keyfile);
   /* we round expiration time to full seconds for SKS URIs */
   et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
-  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_public_key);
+  GNUNET_CRYPTO_eddsa_key_get_public (sign_key,
+                                      &my_public_key);
   ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
   ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
   ass.exptime = GNUNET_TIME_absolute_hton (et);
-  ass.fi = baseUri->data.chk;
+  ass.fi = base_uri->data.chk;
   ass.peer.public_key = my_public_key;
   uri = GNUNET_new (struct GNUNET_FS_Uri);
   uri->type = GNUNET_FS_URI_LOC;
-  uri->data.loc.fi = baseUri->data.chk;
+  uri->data.loc.fi = base_uri->data.chk;
   uri->data.loc.expirationTime = et;
   uri->data.loc.peer.public_key = my_public_key;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_eddsa_sign (my_private_key, &ass.purpose,
+                 GNUNET_CRYPTO_eddsa_sign (sign_key,
+                                           &ass.purpose,
                                            &uri->data.loc.contentSignature));
-  GNUNET_free (my_private_key);
   return uri;
 }
 
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 6652ecb16..dd7d61118 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+     (C) 2009-2014 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
@@ -45,6 +45,7 @@
 #include "gnunet-service-fs_put.h"
 #include "gnunet-service-fs_cadet.h"
 #include "fs.h"
+#include "fs_api.h"
 
 /**
  * Size for the hash map for DHT requests from the FS
@@ -159,6 +160,11 @@ int GSF_enable_randomized_delays;
 static struct GNUNET_CONFIGURATION_Handle *block_cfg;
 
 /**
+ * Private key of this peer.  Used to sign LOC URI requests.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
+
+/**
  * ID of our task that we use to age the cover counters.
  */
 static GNUNET_SCHEDULER_TaskIdentifier cover_age_task;
@@ -173,6 +179,7 @@ static struct GNUNET_LOAD_Value *datastore_get_load;
  */
 static struct GNUNET_PeerIdentity my_id;
 
+
 /**
  * Task that periodically ages our cover traffic statistics.
  *
@@ -180,7 +187,8 @@ static struct GNUNET_PeerIdentity my_id;
  * @param tc task context
  */
 static void
-age_cover_counters (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+age_cover_counters (void *cls,
+                    const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GSF_cover_content_count = (GSF_cover_content_count * 15) / 16;
   GSF_cover_query_count = (GSF_cover_query_count * 15) / 16;
@@ -288,11 +296,12 @@ update_latencies (void *cls,
  * @param other the other peer involved (sender or receiver, NULL
  *        for loopback messages where we are both sender and receiver)
  * @param message the actual message
- * @return GNUNET_OK to keep the connection open,
- *         GNUNET_SYSERR to close it (signal serious error)
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-handle_p2p_put (void *cls, const struct GNUNET_PeerIdentity *other,
+handle_p2p_put (void *cls,
+                const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message)
 {
   struct GSF_ConnectedPeer *cp;
@@ -349,7 +358,8 @@ consider_request_for_forwarding (void *cls,
  * @param result final datastore lookup result
  */
 static void
-consider_forwarding (void *cls, struct GSF_PendingRequest *pr,
+consider_forwarding (void *cls,
+                     struct GSF_PendingRequest *pr,
                      enum GNUNET_BLOCK_EvaluationResult result)
 {
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
@@ -365,11 +375,12 @@ consider_forwarding (void *cls, struct GSF_PendingRequest *pr,
  * @param other the other peer involved (sender or receiver, NULL
  *        for loopback messages where we are both sender and receiver)
  * @param message the actual message
- * @return GNUNET_OK to keep the connection open,
- *         GNUNET_SYSERR to close it (signal serious error)
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-handle_p2p_get (void *cls, const struct GNUNET_PeerIdentity *other,
+handle_p2p_get (void *cls,
+                const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message)
 {
   struct GSF_PendingRequest *pr;
@@ -378,7 +389,8 @@ handle_p2p_get (void *cls, const struct GNUNET_PeerIdentity *other,
   if (NULL == pr)
     return GNUNET_SYSERR;
   GSF_pending_request_get_data_ (pr)->has_started = GNUNET_YES;
-  GSF_local_lookup_ (pr, &consider_forwarding, NULL);
+  GSF_local_lookup_ (pr,
+                     &consider_forwarding, NULL);
   return GNUNET_OK;
 }
 
@@ -389,18 +401,20 @@ handle_p2p_get (void *cls, const struct GNUNET_PeerIdentity *other,
  * result status).  Also signal that we can now
  * receive more request information from the client.
  *
- * @param cls the client doing the request ('struct GNUNET_SERVER_Client')
+ * @param cls the client doing the request (`struct GNUNET_SERVER_Client`)
  * @param pr the pending request we were processing
  * @param result final datastore lookup result
  */
 static void
-start_p2p_processing (void *cls, struct GSF_PendingRequest *pr,
+start_p2p_processing (void *cls,
+                      struct GSF_PendingRequest *pr,
                       enum GNUNET_BLOCK_EvaluationResult result)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GSF_PendingRequestData *prd;
 
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVER_receive_done (client,
+                              GNUNET_OK);
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
     return;                     /* we're done, 'pr' was already destroyed... */
   prd = GSF_pending_request_get_data_ (pr);
@@ -441,25 +455,32 @@ start_p2p_processing (void *cls, struct GSF_PendingRequest *pr,
  * @param message the actual message
  */
 static void
-handle_start_search (void *cls, struct GNUNET_SERVER_Client *client,
+handle_start_search (void *cls,
+                     struct GNUNET_SERVER_Client *client,
                      const struct GNUNET_MessageHeader *message)
 {
   struct GSF_PendingRequest *pr;
   int ret;
 
   pr = NULL;
-  ret = GSF_local_client_start_search_handler_ (client, message, &pr);
+  ret = GSF_local_client_start_search_handler_ (client,
+                                                message,
+                                                &pr);
   switch (ret)
   {
   case GNUNET_SYSERR:
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVER_receive_done (client,
+                                GNUNET_SYSERR);
     break;
   case GNUNET_NO:
-    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    GNUNET_SERVER_receive_done (client,
+                                GNUNET_OK);
     break;
   case GNUNET_YES:
     GSF_pending_request_get_data_ (pr)->has_started = GNUNET_YES;
-    GSF_local_lookup_ (pr, &start_p2p_processing, client);
+    GSF_local_lookup_ (pr,
+                       &start_p2p_processing,
+                       client);
     break;
   default:
     GNUNET_assert (0);
@@ -468,13 +489,56 @@ handle_start_search (void *cls, struct GNUNET_SERVER_Client *client,
 
 
 /**
+ * Handle request to sign a LOC URI (from client).
+ *
+ * @param cls closure (NULL)
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_loc_sign (void *cls,
+                 struct GNUNET_SERVER_Client *client,
+                 const struct GNUNET_MessageHeader *message)
+{
+  const struct RequestLocSignatureMessage *msg;
+  struct GNUNET_FS_Uri base;
+  struct GNUNET_FS_Uri *loc;
+  struct ResponseLocSignatureMessage resp;
+  struct GSF_LocalClient *lc;
+
+  msg = (const struct RequestLocSignatureMessage *) message;
+  GNUNET_break (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT ==
+                ntohl (msg->purpose));
+  base.type = GNUNET_FS_URI_CHK;
+  base.data.chk.chk = msg->chk;
+  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
+  loc = GNUNET_FS_uri_loc_create (&base,
+                                  pk,
+                                  GNUNET_TIME_absolute_ntoh (msg->expiration_time));
+  resp.header.size = htons (sizeof (struct ResponseLocSignatureMessage));
+  resp.header.type = htons (GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE);
+  resp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  resp.expiration_time = GNUNET_TIME_absolute_hton (loc->data.loc.expirationTime);
+  resp.signature = loc->data.loc.contentSignature;
+  resp.peer = loc->data.loc.peer;
+  GNUNET_FS_uri_destroy (loc);
+  lc = GSF_local_client_lookup_ (client);
+  GSF_local_client_transmit_ (lc,
+                              &resp.header);
+  GNUNET_free (loc);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
  * Task run during shutdown.
  *
  * @param cls unused
  * @param tc unused
  */
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls,
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GSF_cadet_stop_client ();
   GSF_cadet_stop_server ();
@@ -524,10 +588,11 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param cls the 'struct GSF_ConnectedPeer' of the new peer
  * @param key query for the request
  * @param pr handle to the pending request
- * @return GNUNET_YES to continue to iterate
+ * @return #GNUNET_YES to continue to iterate
  */
 static int
-consider_peer_for_forwarding (void *cls, const struct GNUNET_HashCode * key,
+consider_peer_for_forwarding (void *cls,
+                              const struct GNUNET_HashCode *key,
                               struct GSF_PendingRequest *pr)
 {
   struct GSF_ConnectedPeer *cp = cls;
@@ -568,11 +633,15 @@ connected_peer_cb (void *cls, struct GSF_ConnectedPeer *cp)
  * @param peer peer identity this notification is about
  */
 static void
-peer_connect_handler (void *cls, const struct GNUNET_PeerIdentity *peer)
+peer_connect_handler (void *cls,
+                      const struct GNUNET_PeerIdentity *peer)
 {
-  if (0 == memcmp (&my_id, peer, sizeof (struct GNUNET_PeerIdentity)))
+  if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_id,
+                                            peer))
     return;
-  GSF_peer_connect_handler_ (peer, &connected_peer_cb, NULL);
+  GSF_peer_connect_handler_ (peer,
+                             &connected_peer_cb,
+                             NULL);
 }
 
 
@@ -590,7 +659,13 @@ static void
 peer_init_handler (void *cls,
                    const struct GNUNET_PeerIdentity *my_identity)
 {
-  my_id = *my_identity;
+  if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_id,
+                                            my_identity))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Peer identity missmatch, refusing to start!\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
 }
 
 
@@ -605,31 +680,36 @@ main_init (struct GNUNET_SERVER_Handle *server,
            const struct GNUNET_CONFIGURATION_Handle *c)
 {
   static const struct GNUNET_CORE_MessageHandler no_p2p_handlers[] = {
-    {NULL, 0, 0}
+    { NULL, 0, 0 }
   };
   static const struct GNUNET_CORE_MessageHandler p2p_handlers[] = {
-    {&handle_p2p_get,
-     GNUNET_MESSAGE_TYPE_FS_GET, 0},
-    {&handle_p2p_put,
-     GNUNET_MESSAGE_TYPE_FS_PUT, 0},
-    {&GSF_handle_p2p_migration_stop_,
-     GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
-     sizeof (struct MigrationStopMessage)},
-    {NULL, 0, 0}
+    { &handle_p2p_get,
+      GNUNET_MESSAGE_TYPE_FS_GET, 0 },
+    { &handle_p2p_put,
+      GNUNET_MESSAGE_TYPE_FS_PUT, 0 },
+    { &GSF_handle_p2p_migration_stop_,
+      GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
+      sizeof (struct MigrationStopMessage) },
+    { NULL, 0, 0 }
   };
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    {&GNUNET_FS_handle_index_start, NULL,
-     GNUNET_MESSAGE_TYPE_FS_INDEX_START, 0},
-    {&GNUNET_FS_handle_index_list_get, NULL,
-     GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
-     sizeof (struct GNUNET_MessageHeader)},
-    {&GNUNET_FS_handle_unindex, NULL, GNUNET_MESSAGE_TYPE_FS_UNINDEX,
-     sizeof (struct UnindexMessage)},
-    {&handle_start_search, NULL, GNUNET_MESSAGE_TYPE_FS_START_SEARCH,
-     0},
+    { &GNUNET_FS_handle_index_start, NULL,
+      GNUNET_MESSAGE_TYPE_FS_INDEX_START, 0 },
+    { &GNUNET_FS_handle_index_list_get, NULL,
+      GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
+      sizeof (struct GNUNET_MessageHeader) },
+    { &GNUNET_FS_handle_unindex, NULL,
+      GNUNET_MESSAGE_TYPE_FS_UNINDEX,
+      sizeof (struct UnindexMessage) },
+    { &handle_start_search, NULL,
+      GNUNET_MESSAGE_TYPE_FS_START_SEARCH, 0 },
+    { &handle_loc_sign, NULL,
+      GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN,
+      sizeof (struct RequestLocSignatureMessage) },
     {NULL, NULL, 0, 0}
   };
   int anon_p2p_off;
+  char *keyfile;
 
   /* this option is really only for testcases that need to disable
      _anonymous_ file-sharing for some reason */
@@ -637,10 +717,31 @@ main_init (struct GNUNET_SERVER_Handle *server,
                   GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
                                                         "fs",
                                                         "DISABLE_ANON_TRANSFER"));
-  GSF_core =
-      GNUNET_CORE_connect (GSF_cfg, NULL, &peer_init_handler,
-                           &peer_connect_handler, &GSF_peer_disconnect_handler_,
-                           NULL, GNUNET_NO, NULL, GNUNET_NO,
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (GSF_cfg,
+                                               "PEER",
+                                               "PRIVATE_KEY",
+                                               &keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("FS service is lacking HOSTKEY configuration setting.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return GNUNET_SYSERR;
+  }
+  pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
+  GNUNET_free (keyfile);
+  GNUNET_assert (NULL != pk);
+  GNUNET_CRYPTO_eddsa_key_get_public (pk,
+                                      &my_id.public_key);
+
+  GSF_core
+    = GNUNET_CORE_connect (GSF_cfg, NULL,
+                           &peer_init_handler,
+                           &peer_connect_handler,
+                           &GSF_peer_disconnect_handler_,
+                           NULL, GNUNET_NO,
+                           NULL, GNUNET_NO,
                            (GNUNET_YES == anon_p2p_off)
                            ? no_p2p_handlers
                            : p2p_handlers);
diff --git a/src/fs/gnunet-service-fs_lc.c b/src/fs/gnunet-service-fs_lc.c
index ef30ba32a..6d3b761be 100644
--- a/src/fs/gnunet-service-fs_lc.c
+++ b/src/fs/gnunet-service-fs_lc.c
@@ -17,13 +17,11 @@
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
 */
-
 /**
  * @file fs/gnunet-service-fs_lc.c
  * @brief API to handle 'local clients'
  * @author Christian Grothoff
  */
-
 #include "platform.h"
 #include "gnunet-service-fs.h"
 #include "gnunet-service-fs_lc.h"
@@ -150,7 +148,6 @@ struct GSF_LocalClient
  */
 static struct GSF_LocalClient *client_head;
 
-
 /**
  * Head of linked list of our local clients.
  */
@@ -176,7 +173,9 @@ GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client)
     return pos;
   pos = GNUNET_new (struct GSF_LocalClient);
   pos->client = client;
-  GNUNET_CONTAINER_DLL_insert (client_head, client_tail, pos);
+  GNUNET_CONTAINER_DLL_insert (client_head,
+                               client_tail,
+                               pos);
   return pos;
 }
 
@@ -209,7 +208,7 @@ client_request_destroy (void *cls,
  * Handle a reply to a pending request.  Also called if a request
  * expires (then with data == NULL).  The handler may be called
  * many times (depending on the request type), but will not be
- * called during or after a call to GSF_pending_request_cancel
+ * called during or after a call to #GSF_pending_request_cancel()
  * and will also not be called anymore after a call signalling
  * expiration.
  *
@@ -217,19 +216,21 @@ client_request_destroy (void *cls,
  * @param eval evaluation of the result
  * @param pr handle to the original pending request
  * @param reply_anonymity_level anonymity level for the reply, UINT32_MAX for "unknown"
- * @param expiration when does 'data' expire?
+ * @param expiration when does @a data expire?
  * @param last_transmission when was the last time we've tried to download this block? (FOREVER if unknown)
  * @param type type of the block
  * @param data response data, NULL on request expiration
- * @param data_len number of bytes in @e data
+ * @param data_len number of bytes in @a data
  */
 static void
-client_response_handler (void *cls, enum GNUNET_BLOCK_EvaluationResult eval,
+client_response_handler (void *cls,
+                         enum GNUNET_BLOCK_EvaluationResult eval,
                          struct GSF_PendingRequest *pr,
                          uint32_t reply_anonymity_level,
                          struct GNUNET_TIME_Absolute expiration,
                          struct GNUNET_TIME_Absolute last_transmission,
-                         enum GNUNET_BLOCK_Type type, const void *data,
+                         enum GNUNET_BLOCK_Type type,
+                         const void *data,
                          size_t data_len)
 {
   struct ClientRequest *cr = cls;
@@ -405,13 +406,15 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
  * If we were able to transmit messages and there are still more
  * pending, ask core again for further calls to this function.
  *
- * @param cls closure, pointer to the 'struct GSF_LocalClient'
- * @param size number of bytes available in buf
+ * @param cls closure, pointer to the `struct GSF_LocalClient`
+ * @param size number of bytes available in @a buf
  * @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
  */
 static size_t
-transmit_to_client (void *cls, size_t size, void *buf)
+transmit_to_client (void *cls,
+                    size_t size,
+                    void *buf)
 {
   struct GSF_LocalClient *lc = cls;
   char *cbuf = buf;
@@ -458,8 +461,12 @@ GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
   res = GNUNET_malloc (sizeof (struct ClientResponse) + msize);
   res->lc = lc;
   res->msize = msize;
-  memcpy (&res[1], msg, msize);
-  GNUNET_CONTAINER_DLL_insert_tail (lc->res_head, lc->res_tail, res);
+  memcpy (&res[1],
+          msg,
+          msize);
+  GNUNET_CONTAINER_DLL_insert_tail (lc->res_head,
+                                    lc->res_tail,
+                                    res);
   if (NULL == lc->th)
     lc->th =
         GNUNET_SERVER_notify_transmit_ready (lc->client, msize,
@@ -476,7 +483,8 @@ GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
  * @param client handle of the client
  */
 void
-GSF_client_disconnect_handler_ (void *cls, struct GNUNET_SERVER_Client *client)
+GSF_client_disconnect_handler_ (void *cls,
+                                struct GNUNET_SERVER_Client *client)
 {
   struct GSF_LocalClient *pos;
   struct ClientRequest *cr;
diff --git a/src/fs/test_fs_uri.c b/src/fs/test_fs_uri.c
index afc80ef71..fdc39ce05 100644
--- a/src/fs/test_fs_uri.c
+++ b/src/fs/test_fs_uri.c
@@ -42,12 +42,12 @@ testKeyword ()
   }
   GNUNET_free (emsg);
   ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/foo+bar", &emsg);
-  if (ret == NULL)
+  if (NULL == ret)
   {
     GNUNET_free (emsg);
     GNUNET_assert (0);
   }
-  if (!GNUNET_FS_uri_test_ksk (ret))
+  if (! GNUNET_FS_uri_test_ksk (ret))
   {
     GNUNET_FS_uri_destroy (ret);
     GNUNET_assert (0);
@@ -81,7 +81,7 @@ testLocation ()
   struct GNUNET_FS_Uri *uri2;
   struct GNUNET_FS_Uri *baseURI;
   char *emsg;
-  struct GNUNET_CONFIGURATION_Handle *cfg;
+  struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
 
   baseURI =
       GNUNET_FS_uri_parse
@@ -89,38 +89,31 @@ testLocation ()
        &emsg);
   GNUNET_assert (baseURI != NULL);
   GNUNET_assert (emsg == NULL);
-  cfg = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, "test_fs_uri_data.conf"))
-  {
-    FPRINTF (stderr, "%s",  "Failed to parse configuration file\n");
-    GNUNET_FS_uri_destroy (baseURI);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
-  uri = GNUNET_FS_uri_loc_create (baseURI, cfg, GNUNET_TIME_absolute_get ());
-  if (uri == NULL)
+  pk = GNUNET_CRYPTO_eddsa_key_create ();
+  uri = GNUNET_FS_uri_loc_create (baseURI,
+                                  pk,
+                                  GNUNET_TIME_absolute_get ());
+  GNUNET_free (pk);
+  if (NULL == uri)
   {
     GNUNET_break (0);
     GNUNET_FS_uri_destroy (baseURI);
-    GNUNET_CONFIGURATION_destroy (cfg);
     return 1;
   }
-  if (!GNUNET_FS_uri_test_loc (uri))
+  if (! GNUNET_FS_uri_test_loc (uri))
   {
     GNUNET_break (0);
     GNUNET_FS_uri_destroy (uri);
     GNUNET_FS_uri_destroy (baseURI);
-    GNUNET_CONFIGURATION_destroy (cfg);
     return 1;
   }
   uri2 = GNUNET_FS_uri_loc_get_uri (uri);
-  if (!GNUNET_FS_uri_test_equal (baseURI, uri2))
+  if (! GNUNET_FS_uri_test_equal (baseURI, uri2))
   {
     GNUNET_break (0);
     GNUNET_FS_uri_destroy (uri);
     GNUNET_FS_uri_destroy (uri2);
     GNUNET_FS_uri_destroy (baseURI);
-    GNUNET_CONFIGURATION_destroy (cfg);
     return 1;
   }
   GNUNET_FS_uri_destroy (uri2);
@@ -137,7 +130,6 @@ testLocation ()
     fprintf (stderr, "URI parsing failed: %s\n", emsg);
     GNUNET_break (0);
     GNUNET_FS_uri_destroy (uri);
-    GNUNET_CONFIGURATION_destroy (cfg);
     GNUNET_free (emsg);
     return 1;
   }
@@ -147,12 +139,10 @@ testLocation ()
     GNUNET_break (0);
     GNUNET_FS_uri_destroy (uri);
     GNUNET_FS_uri_destroy (uri2);
-    GNUNET_CONFIGURATION_destroy (cfg);
     return 1;
   }
   GNUNET_FS_uri_destroy (uri2);
   GNUNET_FS_uri_destroy (uri);
-  GNUNET_CONFIGURATION_destroy (cfg);
   return 0;
 }
 
diff --git a/src/fs/test_fs_uri_data.conf b/src/fs/test_fs_uri_data.conf
deleted file mode 100644
index fcf6f42d4..000000000
--- a/src/fs/test_fs_uri_data.conf
+++ /dev/null
@@ -1,5 +0,0 @@
-@INLINE@ test_fs_defaults.conf
-[PATHS]
-GNUNET_TEST_HOME = /tmp/gnunet-test-fs-uri/
-
-
diff --git a/src/include/gnunet_fs_service.h b/src/include/gnunet_fs_service.h
index 9f3ff0d12..9ea278d87 100644
--- a/src/include/gnunet_fs_service.h
+++ b/src/include/gnunet_fs_service.h
@@ -162,7 +162,8 @@ GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri,
  * @return NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_parse (const char *uri, char **emsg);
+GNUNET_FS_uri_parse (const char *uri,
+                     char **emsg);
 
 
 /**
@@ -233,15 +234,19 @@ GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri);
 
 /**
  * Construct a location URI (this peer will be used for the location).
+ * This function should only be called from within gnunet-service-fs,
+ * as it requires the peer's private key which is generally unavailable
+ * to processes directly under the user's control.  However, for
+ * testing and as it logically fits under URIs, it is in this API.
  *
- * @param baseUri content offered by the sender
- * @param cfg configuration information (used to find our hostkey)
+ * @param base_uri content offered by the sender
+ * @param sign_key private key of the peer
  * @param expiration_time how long will the content be offered?
  * @return the location URI, NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
-                          const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *base_uri,
+                          const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
                           struct GNUNET_TIME_Absolute expiration_time);
 
 
@@ -285,7 +290,8 @@ GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri);
  *  if keywords is not legal (i.e. empty).
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create (const char *keywords, char **emsg);
+GNUNET_FS_uri_ksk_create (const char *keywords,
+                          char **emsg);
 
 
 /**
@@ -436,8 +442,9 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext
-                               *ctx, void *scls, const char *option,
+GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                               void *scls,
+                               const char *option,
                                const char *value);
 
 
@@ -454,8 +461,9 @@ GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext
-                               *ctx, void *scls, const char *option,
+GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                               void *scls,
+                               const char *option,
                                const char *value);
 
 
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index f9e8df77f..1279dd703 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001-2013 Christian Grothoff (and other contributing authors)
+     (C) 2001-2014 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
@@ -459,6 +459,16 @@ extern "C"
  ******************************************************************************/
 
 /**
+ * Message sent by fs client to request LOC signature.
+ */
+#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN 126
+
+/**
+ * Reply sent by fs service with LOC signature.
+ */
+#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE 127
+
+/**
  * Message sent by fs client to start indexing.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_START 128