1 files changed, 462 insertions, 457 deletions

diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c
index 516c96479..c6443f102 100644
--- a/src/dht/dht_api.c
+++ b/src/dht/dht_api.c
@@ -34,13 +34,14 @@
 #include "gnunet_dht_service.h"
 #include "dht.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "dht-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "dht-api", __VA_ARGS__)
 
 
 /**
  * Handle to a PUT request.
  */
-struct GNUNET_DHT_PutHandle {
+struct GNUNET_DHT_PutHandle
+{
   /**
    * Kept in a DLL.
    */
@@ -75,7 +76,8 @@ struct GNUNET_DHT_PutHandle {
 /**
  * Handle to a GET request
  */
-struct GNUNET_DHT_GetHandle {
+struct GNUNET_DHT_GetHandle
+{
   /**
    * Iterator to call on data receipt
    */
@@ -144,7 +146,8 @@ struct GNUNET_DHT_GetHandle {
 /**
  * Handle to a monitoring request.
  */
-struct GNUNET_DHT_MonitorHandle {
+struct GNUNET_DHT_MonitorHandle
+{
   /**
    * DLL.
    */
@@ -195,7 +198,8 @@ struct GNUNET_DHT_MonitorHandle {
 /**
  * Connection to the DHT service.
  */
-struct GNUNET_DHT_Handle {
+struct GNUNET_DHT_Handle
+{
   /**
    * Configuration to use.
    */
@@ -257,7 +261,7 @@ struct GNUNET_DHT_Handle {
  * @return #GNUNET_YES on success, #GNUNET_NO on failure.
  */
 static int
-try_connect(struct GNUNET_DHT_Handle *h);
+try_connect (struct GNUNET_DHT_Handle *h);
 
 
 /**
@@ -266,25 +270,25 @@ try_connect(struct GNUNET_DHT_Handle *h);
  * @param gh GET to generate messages for.
  */
 static void
-send_get(struct GNUNET_DHT_GetHandle *gh)
+send_get (struct GNUNET_DHT_GetHandle *gh)
 {
   struct GNUNET_DHT_Handle *h = gh->dht_handle;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_DHT_ClientGetMessage *get_msg;
 
-  env = GNUNET_MQ_msg_extra(get_msg,
-                            gh->xquery_size,
-                            GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);
-  get_msg->options = htonl((uint32_t)gh->options);
-  get_msg->desired_replication_level = htonl(gh->desired_replication_level);
-  get_msg->type = htonl(gh->type);
+  env = GNUNET_MQ_msg_extra (get_msg,
+                             gh->xquery_size,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);
+  get_msg->options = htonl ((uint32_t) gh->options);
+  get_msg->desired_replication_level = htonl (gh->desired_replication_level);
+  get_msg->type = htonl (gh->type);
   get_msg->key = gh->key;
   get_msg->unique_id = gh->unique_id;
-  GNUNET_memcpy(&get_msg[1],
-                &gh[1],
-                gh->xquery_size);
-  GNUNET_MQ_send(h->mq,
-                 env);
+  GNUNET_memcpy (&get_msg[1],
+                 &gh[1],
+                 gh->xquery_size);
+  GNUNET_MQ_send (h->mq,
+                  env);
 }
 
 
@@ -298,8 +302,8 @@ send_get(struct GNUNET_DHT_GetHandle *gh)
  * @param transmission_offset_start at which offset should we start?
  */
 static void
-send_get_known_results(struct GNUNET_DHT_GetHandle *gh,
-                       unsigned int transmission_offset_start)
+send_get_known_results (struct GNUNET_DHT_GetHandle *gh,
+                        unsigned int transmission_offset_start)
 {
   struct GNUNET_DHT_Handle *h = gh->dht_handle;
   struct GNUNET_MQ_Envelope *env;
@@ -312,22 +316,22 @@ send_get_known_results(struct GNUNET_DHT_GetHandle *gh,
         / sizeof(struct GNUNET_HashCode);
   transmission_offset = transmission_offset_start;
   while (transmission_offset < gh->seen_results_end)
-    {
-      delta = gh->seen_results_end - transmission_offset;
-      if (delta > max)
-        delta = max;
-      env = GNUNET_MQ_msg_extra(msg,
-                                delta * sizeof(struct GNUNET_HashCode),
-                                GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN);
-      msg->key = gh->key;
-      msg->unique_id = gh->unique_id;
-      GNUNET_memcpy(&msg[1],
-                    &gh->seen_results[transmission_offset],
-                    sizeof(struct GNUNET_HashCode) * delta);
-      GNUNET_MQ_send(h->mq,
-                     env);
-      transmission_offset += delta;
-    }
+  {
+    delta = gh->seen_results_end - transmission_offset;
+    if (delta > max)
+      delta = max;
+    env = GNUNET_MQ_msg_extra (msg,
+                               delta * sizeof(struct GNUNET_HashCode),
+                               GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN);
+    msg->key = gh->key;
+    msg->unique_id = gh->unique_id;
+    GNUNET_memcpy (&msg[1],
+                   &gh->seen_results[transmission_offset],
+                   sizeof(struct GNUNET_HashCode) * delta);
+    GNUNET_MQ_send (h->mq,
+                    env);
+    transmission_offset += delta;
+  }
 }
 
 
@@ -341,19 +345,19 @@ send_get_known_results(struct GNUNET_DHT_GetHandle *gh,
  * @return #GNUNET_YES (always)
  */
 static int
-add_get_request_to_pending(void *cls,
-                           const struct GNUNET_HashCode *key,
-                           void *value)
+add_get_request_to_pending (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            void *value)
 {
   struct GNUNET_DHT_Handle *handle = cls;
   struct GNUNET_DHT_GetHandle *gh = value;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Retransmitting request related to %s to DHT %p\n",
-      GNUNET_h2s(key),
-      handle);
-  send_get(gh);
-  send_get_known_results(gh, 0);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Retransmitting request related to %s to DHT %p\n",
+       GNUNET_h2s (key),
+       handle);
+  send_get (gh);
+  send_get_known_results (gh, 0);
   return GNUNET_YES;
 }
 
@@ -364,25 +368,25 @@ add_get_request_to_pending(void *cls,
  * @param mh monitor handle to generate start message for
  */
 static void
-send_monitor_start(struct GNUNET_DHT_MonitorHandle *mh)
+send_monitor_start (struct GNUNET_DHT_MonitorHandle *mh)
 {
   struct GNUNET_DHT_Handle *h = mh->dht_handle;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_DHT_MonitorStartStopMessage *m;
 
-  env = GNUNET_MQ_msg(m,
-                      GNUNET_MESSAGE_TYPE_DHT_MONITOR_START);
-  m->type = htonl(mh->type);
-  m->get = htons(NULL != mh->get_cb);
-  m->get_resp = htons(NULL != mh->get_resp_cb);
-  m->put = htons(NULL != mh->put_cb);
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_START);
+  m->type = htonl (mh->type);
+  m->get = htons (NULL != mh->get_cb);
+  m->get_resp = htons (NULL != mh->get_resp_cb);
+  m->put = htons (NULL != mh->put_cb);
   if (NULL != mh->key)
-    {
-      m->filter_key = htons(1);
-      m->key = *mh->key;
-    }
-  GNUNET_MQ_send(h->mq,
-                 env);
+  {
+    m->filter_key = htons (1);
+    m->key = *mh->key;
+  }
+  GNUNET_MQ_send (h->mq,
+                  env);
 }
 
 
@@ -392,31 +396,31 @@ send_monitor_start(struct GNUNET_DHT_MonitorHandle *mh)
  * @param cls a `struct GNUNET_DHT_Handle`
  */
 static void
-try_reconnect(void *cls)
+try_reconnect (void *cls)
 {
   struct GNUNET_DHT_Handle *h = cls;
   struct GNUNET_DHT_MonitorHandle *mh;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Reconnecting with DHT %p\n",
-      h);
-  h->retry_time = GNUNET_TIME_STD_BACKOFF(h->retry_time);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Reconnecting with DHT %p\n",
+       h);
+  h->retry_time = GNUNET_TIME_STD_BACKOFF (h->retry_time);
   h->reconnect_task = NULL;
-  if (GNUNET_YES != try_connect(h))
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "DHT reconnect failed!\n");
-      h->reconnect_task
-        = GNUNET_SCHEDULER_add_delayed(h->retry_time,
-                                       &try_reconnect,
-                                       h);
-      return;
-    }
-  GNUNET_CONTAINER_multihashmap_iterate(h->active_requests,
-                                        &add_get_request_to_pending,
-                                        h);
+  if (GNUNET_YES != try_connect (h))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "DHT reconnect failed!\n");
+    h->reconnect_task
+      = GNUNET_SCHEDULER_add_delayed (h->retry_time,
+                                      &try_reconnect,
+                                      h);
+    return;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (h->active_requests,
+                                         &add_get_request_to_pending,
+                                         h);
   for (mh = h->monitor_head; NULL != mh; mh = mh->next)
-    send_monitor_start(mh);
+    send_monitor_start (mh);
 }
 
 
@@ -426,7 +430,7 @@ try_reconnect(void *cls)
  * @param h handle to dht to (possibly) disconnect and reconnect
  */
 static void
-do_disconnect(struct GNUNET_DHT_Handle *h)
+do_disconnect (struct GNUNET_DHT_Handle *h)
 {
   struct GNUNET_DHT_PutHandle *ph;
   GNUNET_SCHEDULER_TaskCallback cont;
@@ -434,27 +438,27 @@ do_disconnect(struct GNUNET_DHT_Handle *h)
 
   if (NULL == h->mq)
     return;
-  GNUNET_MQ_destroy(h->mq);
+  GNUNET_MQ_destroy (h->mq);
   h->mq = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Disconnecting from DHT service, will try to reconnect in %s\n",
-             GNUNET_STRINGS_relative_time_to_string(h->retry_time,
-                                                    GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting from DHT service, will try to reconnect in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (h->retry_time,
+                                                      GNUNET_YES));
   /* notify client about all PUTs that (may) have failed due to disconnect */
   while (NULL != (ph = h->put_head))
-    {
-      cont = ph->cont;
-      cont_cls = ph->cont_cls;
-      ph->env = NULL;
-      GNUNET_DHT_put_cancel(ph);
-      if (NULL != cont)
-        cont(cont_cls);
-    }
-  GNUNET_assert(NULL == h->reconnect_task);
+  {
+    cont = ph->cont;
+    cont_cls = ph->cont_cls;
+    ph->env = NULL;
+    GNUNET_DHT_put_cancel (ph);
+    if (NULL != cont)
+      cont (cont_cls);
+  }
+  GNUNET_assert (NULL == h->reconnect_task);
   h->reconnect_task
-    = GNUNET_SCHEDULER_add_delayed(h->retry_time,
-                                   &try_reconnect,
-                                   h);
+    = GNUNET_SCHEDULER_add_delayed (h->retry_time,
+                                    &try_reconnect,
+                                    h);
 }
 
 
@@ -467,12 +471,12 @@ do_disconnect(struct GNUNET_DHT_Handle *h)
  * @param error error code
  */
 static void
-mq_error_handler(void *cls,
-                 enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_DHT_Handle *h = cls;
 
-  do_disconnect(h);
+  do_disconnect (h);
 }
 
 
@@ -485,18 +489,18 @@ mq_error_handler(void *cls,
  *         #GNUNET_SYSERR if the message is malformed.
  */
 static int
-check_monitor_get(void *cls,
-                  const struct GNUNET_DHT_MonitorGetMessage *msg)
+check_monitor_get (void *cls,
+                   const struct GNUNET_DHT_MonitorGetMessage *msg)
 {
-  uint32_t plen = ntohl(msg->get_path_length);
-  uint16_t msize = ntohs(msg->header.size) - sizeof(*msg);
+  uint32_t plen = ntohl (msg->get_path_length);
+  uint16_t msize = ntohs (msg->header.size) - sizeof(*msg);
 
   if ((plen > UINT16_MAX) ||
       (plen * sizeof(struct GNUNET_PeerIdentity) != msize))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -508,31 +512,31 @@ check_monitor_get(void *cls,
  * @param msg Monitor get message from the service.
  */
 static void
-handle_monitor_get(void *cls,
-                   const struct GNUNET_DHT_MonitorGetMessage *msg)
+handle_monitor_get (void *cls,
+                    const struct GNUNET_DHT_MonitorGetMessage *msg)
 {
   struct GNUNET_DHT_Handle *handle = cls;
   struct GNUNET_DHT_MonitorHandle *mh;
 
   for (mh = handle->monitor_head; NULL != mh; mh = mh->next)
-    {
-      if (NULL == mh->get_cb)
-        continue;
-      if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
-           (mh->type == ntohl(msg->type))) &&
-          ((NULL == mh->key) ||
-           (0 == memcmp(mh->key,
-                        &msg->key,
-                        sizeof(struct GNUNET_HashCode)))))
-        mh->get_cb(mh->cb_cls,
-                   ntohl(msg->options),
-                   (enum GNUNET_BLOCK_Type)ntohl(msg->type),
-                   ntohl(msg->hop_count),
-                   ntohl(msg->desired_replication_level),
-                   ntohl(msg->get_path_length),
-                   (struct GNUNET_PeerIdentity *)&msg[1],
-                   &msg->key);
-    }
+  {
+    if (NULL == mh->get_cb)
+      continue;
+    if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
+         (mh->type == ntohl (msg->type))) &&
+        ((NULL == mh->key) ||
+         (0 == memcmp (mh->key,
+                       &msg->key,
+                       sizeof(struct GNUNET_HashCode)))))
+      mh->get_cb (mh->cb_cls,
+                  ntohl (msg->options),
+                  (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                  ntohl (msg->hop_count),
+                  ntohl (msg->desired_replication_level),
+                  ntohl (msg->get_path_length),
+                  (struct GNUNET_PeerIdentity *) &msg[1],
+                  &msg->key);
+  }
 }
 
 
@@ -545,19 +549,19 @@ handle_monitor_get(void *cls,
  *         #GNUNET_SYSERR if the message is malformed.
  */
 static int
-check_monitor_get_resp(void *cls,
-                       const struct GNUNET_DHT_MonitorGetRespMessage *msg)
+check_monitor_get_resp (void *cls,
+                        const struct GNUNET_DHT_MonitorGetRespMessage *msg)
 {
-  size_t msize = ntohs(msg->header.size) - sizeof(*msg);
-  uint32_t getl = ntohl(msg->get_path_length);
-  uint32_t putl = ntohl(msg->put_path_length);
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t getl = ntohl (msg->get_path_length);
+  uint32_t putl = ntohl (msg->put_path_length);
 
   if ((getl + putl < getl) ||
       ((msize / sizeof(struct GNUNET_PeerIdentity)) < getl + putl))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -569,38 +573,39 @@ check_monitor_get_resp(void *cls,
  * @param msg monitor get response message from the service
  */
 static void
-handle_monitor_get_resp(void *cls,
-                        const struct GNUNET_DHT_MonitorGetRespMessage *msg)
+handle_monitor_get_resp (void *cls,
+                         const struct GNUNET_DHT_MonitorGetRespMessage *msg)
 {
   struct GNUNET_DHT_Handle *handle = cls;
-  size_t msize = ntohs(msg->header.size) - sizeof(*msg);
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
   const struct GNUNET_PeerIdentity *path;
-  uint32_t getl = ntohl(msg->get_path_length);
-  uint32_t putl = ntohl(msg->put_path_length);
+  uint32_t getl = ntohl (msg->get_path_length);
+  uint32_t putl = ntohl (msg->put_path_length);
   struct GNUNET_DHT_MonitorHandle *mh;
 
-  path = (const struct GNUNET_PeerIdentity *)&msg[1];
+  path = (const struct GNUNET_PeerIdentity *) &msg[1];
   for (mh = handle->monitor_head; NULL != mh; mh = mh->next)
-    {
-      if (NULL == mh->get_resp_cb)
-        continue;
-      if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
-           (mh->type == ntohl(msg->type))) &&
-          ((NULL == mh->key) ||
-           (0 == memcmp(mh->key,
-                        &msg->key,
-                        sizeof(struct GNUNET_HashCode)))))
-        mh->get_resp_cb(mh->cb_cls,
-                        (enum GNUNET_BLOCK_Type)ntohl(msg->type),
-                        path,
-                        getl,
-                        &path[getl],
-                        putl,
-                        GNUNET_TIME_absolute_ntoh(msg->expiration_time),
-                        &msg->key,
-                        (const void *)&path[getl + putl],
-                        msize - sizeof(struct GNUNET_PeerIdentity) * (putl + getl));
-    }
+  {
+    if (NULL == mh->get_resp_cb)
+      continue;
+    if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
+         (mh->type == ntohl (msg->type))) &&
+        ((NULL == mh->key) ||
+         (0 == memcmp (mh->key,
+                       &msg->key,
+                       sizeof(struct GNUNET_HashCode)))))
+      mh->get_resp_cb (mh->cb_cls,
+                       (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                       path,
+                       getl,
+                       &path[getl],
+                       putl,
+                       GNUNET_TIME_absolute_ntoh (msg->expiration_time),
+                       &msg->key,
+                       (const void *) &path[getl + putl],
+                       msize - sizeof(struct GNUNET_PeerIdentity) * (putl
+                                                                     + getl));
+  }
 }
 
 
@@ -613,19 +618,19 @@ handle_monitor_get_resp(void *cls,
  *         #GNUNET_SYSERR if the message is malformed.
  */
 static int
-check_monitor_put(void *cls,
-                  const struct GNUNET_DHT_MonitorPutMessage *msg)
+check_monitor_put (void *cls,
+                   const struct GNUNET_DHT_MonitorPutMessage *msg)
 {
   size_t msize;
   uint32_t putl;
 
-  msize = ntohs(msg->header.size) - sizeof(*msg);
-  putl = ntohl(msg->put_path_length);
+  msize = ntohs (msg->header.size) - sizeof(*msg);
+  putl = ntohl (msg->put_path_length);
   if ((msize / sizeof(struct GNUNET_PeerIdentity)) < putl)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -637,38 +642,38 @@ check_monitor_put(void *cls,
  * @param msg Monitor put message from the service.
  */
 static void
-handle_monitor_put(void *cls,
-                   const struct GNUNET_DHT_MonitorPutMessage *msg)
+handle_monitor_put (void *cls,
+                    const struct GNUNET_DHT_MonitorPutMessage *msg)
 {
   struct GNUNET_DHT_Handle *handle = cls;
-  size_t msize = ntohs(msg->header.size) - sizeof(*msg);
-  uint32_t putl = ntohl(msg->put_path_length);
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t putl = ntohl (msg->put_path_length);
   const struct GNUNET_PeerIdentity *path;
   struct GNUNET_DHT_MonitorHandle *mh;
 
-  path = (const struct GNUNET_PeerIdentity *)&msg[1];
+  path = (const struct GNUNET_PeerIdentity *) &msg[1];
   for (mh = handle->monitor_head; NULL != mh; mh = mh->next)
-    {
-      if (NULL == mh->put_cb)
-        continue;
-      if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
-           (mh->type == ntohl(msg->type))) &&
-          ((NULL == mh->key) ||
-           (0 == memcmp(mh->key,
-                        &msg->key,
-                        sizeof(struct GNUNET_HashCode)))))
-        mh->put_cb(mh->cb_cls,
-                   ntohl(msg->options),
-                   (enum GNUNET_BLOCK_Type)ntohl(msg->type),
-                   ntohl(msg->hop_count),
-                   ntohl(msg->desired_replication_level),
-                   putl,
-                   path,
-                   GNUNET_TIME_absolute_ntoh(msg->expiration_time),
-                   &msg->key,
-                   (const void *)&path[putl],
-                   msize - sizeof(struct GNUNET_PeerIdentity) * putl);
-    }
+  {
+    if (NULL == mh->put_cb)
+      continue;
+    if (((GNUNET_BLOCK_TYPE_ANY == mh->type) ||
+         (mh->type == ntohl (msg->type))) &&
+        ((NULL == mh->key) ||
+         (0 == memcmp (mh->key,
+                       &msg->key,
+                       sizeof(struct GNUNET_HashCode)))))
+      mh->put_cb (mh->cb_cls,
+                  ntohl (msg->options),
+                  (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                  ntohl (msg->hop_count),
+                  ntohl (msg->desired_replication_level),
+                  putl,
+                  path,
+                  GNUNET_TIME_absolute_ntoh (msg->expiration_time),
+                  &msg->key,
+                  (const void *) &path[putl],
+                  msize - sizeof(struct GNUNET_PeerIdentity) * putl);
+  }
 }
 
 
@@ -681,12 +686,12 @@ handle_monitor_put(void *cls,
  *         #GNUNET_SYSERR if the message is malformed.
  */
 static int
-check_client_result(void *cls,
-                    const struct GNUNET_DHT_ClientResultMessage *msg)
+check_client_result (void *cls,
+                     const struct GNUNET_DHT_ClientResultMessage *msg)
 {
-  size_t msize = ntohs(msg->header.size) - sizeof(*msg);
-  uint32_t put_path_length = ntohl(msg->put_path_length);
-  uint32_t get_path_length = ntohl(msg->get_path_length);
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t put_path_length = ntohl (msg->put_path_length);
+  uint32_t get_path_length = ntohl (msg->get_path_length);
   size_t meta_length;
 
   meta_length =
@@ -696,10 +701,10 @@ check_client_result(void *cls,
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)) ||
       (put_path_length >
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -713,15 +718,15 @@ check_client_result(void *cls,
  * @return #GNUNET_YES to continue to iterate over all results
  */
 static int
-process_client_result(void *cls,
-                      const struct GNUNET_HashCode *key,
-                      void *value)
+process_client_result (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
 {
   const struct GNUNET_DHT_ClientResultMessage *crm = cls;
   struct GNUNET_DHT_GetHandle *get_handle = value;
-  size_t msize = ntohs(crm->header.size) - sizeof(*crm);
-  uint32_t put_path_length = ntohl(crm->put_path_length);
-  uint32_t get_path_length = ntohl(crm->get_path_length);
+  size_t msize = ntohs (crm->header.size) - sizeof(*crm);
+  uint32_t put_path_length = ntohl (crm->put_path_length);
+  uint32_t get_path_length = ntohl (crm->get_path_length);
   const struct GNUNET_PeerIdentity *put_path;
   const struct GNUNET_PeerIdentity *get_path;
   struct GNUNET_HashCode hc;
@@ -730,59 +735,59 @@ process_client_result(void *cls,
   const void *data;
 
   if (crm->unique_id != get_handle->unique_id)
-    {
-      /* UID mismatch */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Ignoring reply for %s: UID mismatch: %llu/%llu\n",
-          GNUNET_h2s(key),
-          crm->unique_id,
-          get_handle->unique_id);
-      return GNUNET_YES;
-    }
+  {
+    /* UID mismatch */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Ignoring reply for %s: UID mismatch: %llu/%llu\n",
+         GNUNET_h2s (key),
+         crm->unique_id,
+         get_handle->unique_id);
+    return GNUNET_YES;
+  }
   /* FIXME: might want to check that type matches */
   meta_length =
     sizeof(struct GNUNET_PeerIdentity) * (get_path_length + put_path_length);
   data_length = msize - meta_length;
-  put_path = (const struct GNUNET_PeerIdentity *)&crm[1];
+  put_path = (const struct GNUNET_PeerIdentity *) &crm[1];
   get_path = &put_path[put_path_length];
   {
     char *pp;
     char *gp;
 
-    gp = GNUNET_STRINGS_pp2s(get_path,
-                             get_path_length);
-    pp = GNUNET_STRINGS_pp2s(put_path,
-                             put_path_length);
-    LOG(GNUNET_ERROR_TYPE_DEBUG,
-        "Giving %u byte reply for %s to application (GP: %s, PP: %s)\n",
-        (unsigned int)data_length,
-        GNUNET_h2s(key),
-        gp,
-        pp);
-    GNUNET_free(gp);
-    GNUNET_free(pp);
+    gp = GNUNET_STRINGS_pp2s (get_path,
+                              get_path_length);
+    pp = GNUNET_STRINGS_pp2s (put_path,
+                              put_path_length);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Giving %u byte reply for %s to application (GP: %s, PP: %s)\n",
+         (unsigned int) data_length,
+         GNUNET_h2s (key),
+         gp,
+         pp);
+    GNUNET_free (gp);
+    GNUNET_free (pp);
   }
   data = &get_path[get_path_length];
   /* remember that we've seen this result */
-  GNUNET_CRYPTO_hash(data,
-                     data_length,
-                     &hc);
+  GNUNET_CRYPTO_hash (data,
+                      data_length,
+                      &hc);
   if (get_handle->seen_results_size == get_handle->seen_results_end)
-    GNUNET_array_grow(get_handle->seen_results,
-                      get_handle->seen_results_size,
-                      get_handle->seen_results_size * 2 + 1);
+    GNUNET_array_grow (get_handle->seen_results,
+                       get_handle->seen_results_size,
+                       get_handle->seen_results_size * 2 + 1);
   get_handle->seen_results[get_handle->seen_results_end++] = hc;
   /* no need to block it explicitly, service already knows about it! */
-  get_handle->iter(get_handle->iter_cls,
-                   GNUNET_TIME_absolute_ntoh(crm->expiration),
-                   key,
-                   get_path,
-                   get_path_length,
-                   put_path,
-                   put_path_length,
-                   ntohl(crm->type),
-                   data_length,
-                   data);
+  get_handle->iter (get_handle->iter_cls,
+                    GNUNET_TIME_absolute_ntoh (crm->expiration),
+                    key,
+                    get_path,
+                    get_path_length,
+                    put_path,
+                    put_path_length,
+                    ntohl (crm->type),
+                    data_length,
+                    data);
   return GNUNET_YES;
 }
 
@@ -794,15 +799,15 @@ process_client_result(void *cls,
  * @param msg Monitor put message from the service.
  */
 static void
-handle_client_result(void *cls,
-                     const struct GNUNET_DHT_ClientResultMessage *msg)
+handle_client_result (void *cls,
+                      const struct GNUNET_DHT_ClientResultMessage *msg)
 {
   struct GNUNET_DHT_Handle *handle = cls;
 
-  GNUNET_CONTAINER_multihashmap_get_multiple(handle->active_requests,
-                                             &msg->key,
-                                             &process_client_result,
-                                             (void *)msg);
+  GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests,
+                                              &msg->key,
+                                              &process_client_result,
+                                              (void *) msg);
 }
 
 
@@ -812,7 +817,7 @@ handle_client_result(void *cls,
  * @param cls The DHT handle.
  */
 static void
-handle_put_cont(void *cls)
+handle_put_cont (void *cls)
 {
   struct GNUNET_DHT_PutHandle *ph = cls;
   GNUNET_SCHEDULER_TaskCallback cont;
@@ -821,9 +826,9 @@ handle_put_cont(void *cls)
   cont = ph->cont;
   cont_cls = ph->cont_cls;
   ph->env = NULL;
-  GNUNET_DHT_put_cancel(ph);
+  GNUNET_DHT_put_cancel (ph);
   if (NULL != cont)
-    cont(cont_cls);
+    cont (cont_cls);
 }
 
 
@@ -834,41 +839,41 @@ handle_put_cont(void *cls)
  * @return #GNUNET_YES on success, #GNUNET_NO on failure.
  */
 static int
-try_connect(struct GNUNET_DHT_Handle *h)
+try_connect (struct GNUNET_DHT_Handle *h)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size(monitor_get,
-                          GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET,
-                          struct GNUNET_DHT_MonitorGetMessage,
-                          h),
-    GNUNET_MQ_hd_var_size(monitor_get_resp,
-                          GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP,
-                          struct GNUNET_DHT_MonitorGetRespMessage,
-                          h),
-    GNUNET_MQ_hd_var_size(monitor_put,
-                          GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT,
-                          struct GNUNET_DHT_MonitorPutMessage,
-                          h),
-    GNUNET_MQ_hd_var_size(client_result,
-                          GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT,
-                          struct GNUNET_DHT_ClientResultMessage,
-                          h),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (monitor_get,
+                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET,
+                           struct GNUNET_DHT_MonitorGetMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (monitor_get_resp,
+                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP,
+                           struct GNUNET_DHT_MonitorGetRespMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (monitor_put,
+                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT,
+                           struct GNUNET_DHT_MonitorPutMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (client_result,
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT,
+                           struct GNUNET_DHT_ClientResultMessage,
+                           h),
+    GNUNET_MQ_handler_end ()
   };
 
   if (NULL != h->mq)
     return GNUNET_OK;
-  h->mq = GNUNET_CLIENT_connect(h->cfg,
-                                "dht",
-                                handlers,
-                                &mq_error_handler,
-                                h);
+  h->mq = GNUNET_CLIENT_connect (h->cfg,
+                                 "dht",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
   if (NULL == h->mq)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Failed to connect to the DHT service!\n");
-      return GNUNET_NO;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Failed to connect to the DHT service!\n");
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -882,24 +887,24 @@ try_connect(struct GNUNET_DHT_Handle *h)
  * @return handle to the DHT service, or NULL on error
  */
 struct GNUNET_DHT_Handle *
-GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                   unsigned int ht_len)
+GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                    unsigned int ht_len)
 {
   struct GNUNET_DHT_Handle *handle;
 
-  handle = GNUNET_new(struct GNUNET_DHT_Handle);
+  handle = GNUNET_new (struct GNUNET_DHT_Handle);
   handle->cfg = cfg;
   handle->uid_gen
-    = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
-                               UINT64_MAX);
+    = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                UINT64_MAX);
   handle->active_requests
-    = GNUNET_CONTAINER_multihashmap_create(ht_len,
-                                           GNUNET_YES);
-  if (GNUNET_NO == try_connect(handle))
-    {
-      GNUNET_DHT_disconnect(handle);
-      return NULL;
-    }
+    = GNUNET_CONTAINER_multihashmap_create (ht_len,
+                                            GNUNET_YES);
+  if (GNUNET_NO == try_connect (handle))
+  {
+    GNUNET_DHT_disconnect (handle);
+    return NULL;
+  }
   return handle;
 }
 
@@ -910,30 +915,30 @@ GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param handle handle of the DHT connection to stop
  */
 void
-GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
+GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
 {
   struct GNUNET_DHT_PutHandle *ph;
 
-  GNUNET_assert(0 ==
-                GNUNET_CONTAINER_multihashmap_size(handle->active_requests));
+  GNUNET_assert (0 ==
+                 GNUNET_CONTAINER_multihashmap_size (handle->active_requests));
   while (NULL != (ph = handle->put_head))
-    {
-      if (NULL != ph->cont)
-        ph->cont(ph->cont_cls);
-      GNUNET_DHT_put_cancel(ph);
-    }
+  {
+    if (NULL != ph->cont)
+      ph->cont (ph->cont_cls);
+    GNUNET_DHT_put_cancel (ph);
+  }
   if (NULL != handle->mq)
-    {
-      GNUNET_MQ_destroy(handle->mq);
-      handle->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (handle->mq);
+    handle->mq = NULL;
+  }
   if (NULL != handle->reconnect_task)
-    {
-      GNUNET_SCHEDULER_cancel(handle->reconnect_task);
-      handle->reconnect_task = NULL;
-    }
-  GNUNET_CONTAINER_multihashmap_destroy(handle->active_requests);
-  GNUNET_free(handle);
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
+  GNUNET_free (handle);
 }
 
 
@@ -958,16 +963,16 @@ GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
  * @param cont_cls closure for @a cont
  */
 struct GNUNET_DHT_PutHandle *
-GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle,
-               const struct GNUNET_HashCode *key,
-               uint32_t desired_replication_level,
-               enum GNUNET_DHT_RouteOption options,
-               enum GNUNET_BLOCK_Type type,
-               size_t size,
-               const void *data,
-               struct GNUNET_TIME_Absolute exp,
-               GNUNET_SCHEDULER_TaskCallback cont,
-               void *cont_cls)
+GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
+                const struct GNUNET_HashCode *key,
+                uint32_t desired_replication_level,
+                enum GNUNET_DHT_RouteOption options,
+                enum GNUNET_BLOCK_Type type,
+                size_t size,
+                const void *data,
+                struct GNUNET_TIME_Absolute exp,
+                GNUNET_SCHEDULER_TaskCallback cont,
+                void *cont_cls)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_DHT_ClientPutMessage *put_msg;
@@ -977,40 +982,40 @@ GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle,
   msize = sizeof(struct GNUNET_DHT_ClientPutMessage) + size;
   if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
       (size >= GNUNET_MAX_MESSAGE_SIZE))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   if (NULL == handle->mq)
     return NULL;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending PUT for %s to DHT via %p\n",
-      GNUNET_h2s(key),
-      handle);
-  ph = GNUNET_new(struct GNUNET_DHT_PutHandle);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending PUT for %s to DHT via %p\n",
+       GNUNET_h2s (key),
+       handle);
+  ph = GNUNET_new (struct GNUNET_DHT_PutHandle);
   ph->dht_handle = handle;
   ph->cont = cont;
   ph->cont_cls = cont_cls;
-  GNUNET_CONTAINER_DLL_insert_tail(handle->put_head,
-                                   handle->put_tail,
-                                   ph);
-  env = GNUNET_MQ_msg_extra(put_msg,
-                            size,
-                            GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);
-  GNUNET_MQ_notify_sent(env,
-                        &handle_put_cont,
-                        ph);
+  GNUNET_CONTAINER_DLL_insert_tail (handle->put_head,
+                                    handle->put_tail,
+                                    ph);
+  env = GNUNET_MQ_msg_extra (put_msg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);
+  GNUNET_MQ_notify_sent (env,
+                         &handle_put_cont,
+                         ph);
   ph->env = env;
-  put_msg->type = htonl((uint32_t)type);
-  put_msg->options = htonl((uint32_t)options);
-  put_msg->desired_replication_level = htonl(desired_replication_level);
-  put_msg->expiration = GNUNET_TIME_absolute_hton(exp);
+  put_msg->type = htonl ((uint32_t) type);
+  put_msg->options = htonl ((uint32_t) options);
+  put_msg->desired_replication_level = htonl (desired_replication_level);
+  put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
   put_msg->key = *key;
-  GNUNET_memcpy(&put_msg[1],
-                data,
-                size);
-  GNUNET_MQ_send(handle->mq,
-                 env);
+  GNUNET_memcpy (&put_msg[1],
+                 data,
+                 size);
+  GNUNET_MQ_send (handle->mq,
+                  env);
   return ph;
 }
 
@@ -1027,18 +1032,18 @@ GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle,
  * @param ph put operation to cancel ('cont' will no longer be called)
  */
 void
-GNUNET_DHT_put_cancel(struct GNUNET_DHT_PutHandle *ph)
+GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph)
 {
   struct GNUNET_DHT_Handle *handle = ph->dht_handle;
 
   if (NULL != ph->env)
-    GNUNET_MQ_notify_sent(ph->env,
-                          NULL,
-                          NULL);
-  GNUNET_CONTAINER_DLL_remove(handle->put_head,
-                              handle->put_tail,
-                              ph);
-  GNUNET_free(ph);
+    GNUNET_MQ_notify_sent (ph->env,
+                           NULL,
+                           NULL);
+  GNUNET_CONTAINER_DLL_remove (handle->put_head,
+                               handle->put_tail,
+                               ph);
+  GNUNET_free (ph);
 }
 
 
@@ -1059,15 +1064,15 @@ GNUNET_DHT_put_cancel(struct GNUNET_DHT_PutHandle *ph)
  * @return handle to stop the async get
  */
 struct GNUNET_DHT_GetHandle *
-GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle,
-                     enum GNUNET_BLOCK_Type type,
-                     const struct GNUNET_HashCode *key,
-                     uint32_t desired_replication_level,
-                     enum GNUNET_DHT_RouteOption options,
-                     const void *xquery,
-                     size_t xquery_size,
-                     GNUNET_DHT_GetIterator iter,
-                     void *iter_cls)
+GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
+                      enum GNUNET_BLOCK_Type type,
+                      const struct GNUNET_HashCode *key,
+                      uint32_t desired_replication_level,
+                      enum GNUNET_DHT_RouteOption options,
+                      const void *xquery,
+                      size_t xquery_size,
+                      GNUNET_DHT_GetIterator iter,
+                      void *iter_cls)
 {
   struct GNUNET_DHT_GetHandle *gh;
   size_t msize;
@@ -1075,16 +1080,16 @@ GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle,
   msize = sizeof(struct GNUNET_DHT_ClientGetMessage) + xquery_size;
   if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
       (xquery_size >= GNUNET_MAX_MESSAGE_SIZE))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending query for %s to DHT %p\n",
-      GNUNET_h2s(key),
-      handle);
-  gh = GNUNET_malloc(sizeof(struct GNUNET_DHT_GetHandle) +
-                     xquery_size);
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending query for %s to DHT %p\n",
+       GNUNET_h2s (key),
+       handle);
+  gh = GNUNET_malloc (sizeof(struct GNUNET_DHT_GetHandle)
+                      + xquery_size);
   gh->iter = iter;
   gh->iter_cls = iter_cls;
   gh->dht_handle = handle;
@@ -1094,15 +1099,15 @@ GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle,
   gh->desired_replication_level = desired_replication_level;
   gh->type = type;
   gh->options = options;
-  GNUNET_memcpy(&gh[1],
-                xquery,
-                xquery_size);
-  GNUNET_CONTAINER_multihashmap_put(handle->active_requests,
-                                    &gh->key,
-                                    gh,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_memcpy (&gh[1],
+                 xquery,
+                 xquery_size);
+  GNUNET_CONTAINER_multihashmap_put (handle->active_requests,
+                                     &gh->key,
+                                     gh,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   if (NULL != handle->mq)
-    send_get(gh);
+    send_get (gh);
   return gh;
 }
 
@@ -1118,9 +1123,9 @@ GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle,
  *        to be blocked
  */
 void
-GNUNET_DHT_get_filter_known_results(struct GNUNET_DHT_GetHandle *get_handle,
-                                    unsigned int num_results,
-                                    const struct GNUNET_HashCode *results)
+GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle,
+                                     unsigned int num_results,
+                                     const struct GNUNET_HashCode *results)
 {
   unsigned int needed;
   unsigned int had;
@@ -1128,16 +1133,16 @@ GNUNET_DHT_get_filter_known_results(struct GNUNET_DHT_GetHandle *get_handle,
   had = get_handle->seen_results_end;
   needed = had + num_results;
   if (needed > get_handle->seen_results_size)
-    GNUNET_array_grow(get_handle->seen_results,
-                      get_handle->seen_results_size,
-                      needed);
-  GNUNET_memcpy(&get_handle->seen_results[get_handle->seen_results_end],
-                results,
-                num_results * sizeof(struct GNUNET_HashCode));
+    GNUNET_array_grow (get_handle->seen_results,
+                       get_handle->seen_results_size,
+                       needed);
+  GNUNET_memcpy (&get_handle->seen_results[get_handle->seen_results_end],
+                 results,
+                 num_results * sizeof(struct GNUNET_HashCode));
   get_handle->seen_results_end += num_results;
   if (NULL != get_handle->dht_handle->mq)
-    send_get_known_results(get_handle,
-                           had);
+    send_get_known_results (get_handle,
+                            had);
 }
 
 
@@ -1147,35 +1152,35 @@ GNUNET_DHT_get_filter_known_results(struct GNUNET_DHT_GetHandle *get_handle,
  * @param get_handle handle to the GET operation to stop
  */
 void
-GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
+GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
 {
   struct GNUNET_DHT_Handle *handle = get_handle->dht_handle;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending STOP for %s to DHT via %p\n",
-      GNUNET_h2s(&get_handle->key),
-      handle);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending STOP for %s to DHT via %p\n",
+       GNUNET_h2s (&get_handle->key),
+       handle);
   if (NULL != handle->mq)
-    {
-      struct GNUNET_MQ_Envelope *env;
-      struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
-
-      env = GNUNET_MQ_msg(stop_msg,
-                          GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
-      stop_msg->reserved = htonl(0);
-      stop_msg->unique_id = get_handle->unique_id;
-      stop_msg->key = get_handle->key;
-      GNUNET_MQ_send(handle->mq,
-                     env);
-    }
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_remove(handle->active_requests,
-                                                     &get_handle->key,
-                                                     get_handle));
-  GNUNET_array_grow(get_handle->seen_results,
-                    get_handle->seen_results_end,
-                    0);
-  GNUNET_free(get_handle);
+  {
+    struct GNUNET_MQ_Envelope *env;
+    struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
+
+    env = GNUNET_MQ_msg (stop_msg,
+                         GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
+    stop_msg->reserved = htonl (0);
+    stop_msg->unique_id = get_handle->unique_id;
+    stop_msg->key = get_handle->key;
+    GNUNET_MQ_send (handle->mq,
+                    env);
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,
+                                                       &get_handle->key,
+                                                       get_handle));
+  GNUNET_array_grow (get_handle->seen_results,
+                     get_handle->seen_results_end,
+                     0);
+  GNUNET_free (get_handle);
 }
 
 
@@ -1192,17 +1197,17 @@ GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
  * @return Handle to stop monitoring.
  */
 struct GNUNET_DHT_MonitorHandle *
-GNUNET_DHT_monitor_start(struct GNUNET_DHT_Handle *handle,
-                         enum GNUNET_BLOCK_Type type,
-                         const struct GNUNET_HashCode *key,
-                         GNUNET_DHT_MonitorGetCB get_cb,
-                         GNUNET_DHT_MonitorGetRespCB get_resp_cb,
-                         GNUNET_DHT_MonitorPutCB put_cb,
-                         void *cb_cls)
+GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle,
+                          enum GNUNET_BLOCK_Type type,
+                          const struct GNUNET_HashCode *key,
+                          GNUNET_DHT_MonitorGetCB get_cb,
+                          GNUNET_DHT_MonitorGetRespCB get_resp_cb,
+                          GNUNET_DHT_MonitorPutCB put_cb,
+                          void *cb_cls)
 {
   struct GNUNET_DHT_MonitorHandle *mh;
 
-  mh = GNUNET_new(struct GNUNET_DHT_MonitorHandle);
+  mh = GNUNET_new (struct GNUNET_DHT_MonitorHandle);
   mh->get_cb = get_cb;
   mh->get_resp_cb = get_resp_cb;
   mh->put_cb = put_cb;
@@ -1210,15 +1215,15 @@ GNUNET_DHT_monitor_start(struct GNUNET_DHT_Handle *handle,
   mh->type = type;
   mh->dht_handle = handle;
   if (NULL != key)
-    {
-      mh->key = GNUNET_new(struct GNUNET_HashCode);
-      *mh->key = *key;
-    }
-  GNUNET_CONTAINER_DLL_insert(handle->monitor_head,
-                              handle->monitor_tail,
-                              mh);
+  {
+    mh->key = GNUNET_new (struct GNUNET_HashCode);
+    *mh->key = *key;
+  }
+  GNUNET_CONTAINER_DLL_insert (handle->monitor_head,
+                               handle->monitor_tail,
+                               mh);
   if (NULL != handle->mq)
-    send_monitor_start(mh);
+    send_monitor_start (mh);
   return mh;
 }
 
@@ -1231,30 +1236,30 @@ GNUNET_DHT_monitor_start(struct GNUNET_DHT_Handle *handle,
  * On return get_handle will no longer be valid, caller must not use again!!!
  */
 void
-GNUNET_DHT_monitor_stop(struct GNUNET_DHT_MonitorHandle *mh)
+GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *mh)
 {
   struct GNUNET_DHT_Handle *handle = mh->dht_handle;
   struct GNUNET_DHT_MonitorStartStopMessage *m;
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_CONTAINER_DLL_remove(handle->monitor_head,
-                              handle->monitor_tail,
-                              mh);
-  env = GNUNET_MQ_msg(m,
-                      GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP);
-  m->type = htonl(mh->type);
-  m->get = htons(NULL != mh->get_cb);
-  m->get_resp = htons(NULL != mh->get_resp_cb);
-  m->put = htons(NULL != mh->put_cb);
+  GNUNET_CONTAINER_DLL_remove (handle->monitor_head,
+                               handle->monitor_tail,
+                               mh);
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP);
+  m->type = htonl (mh->type);
+  m->get = htons (NULL != mh->get_cb);
+  m->get_resp = htons (NULL != mh->get_resp_cb);
+  m->put = htons (NULL != mh->put_cb);
   if (NULL != mh->key)
-    {
-      m->filter_key = htons(1);
-      m->key = *mh->key;
-    }
-  GNUNET_MQ_send(handle->mq,
-                 env);
-  GNUNET_free_non_null(mh->key);
-  GNUNET_free(mh);
+  {
+    m->filter_key = htons (1);
+    m->key = *mh->key;
+  }
+  GNUNET_MQ_send (handle->mq,
+                  env);
+  GNUNET_free_non_null (mh->key);
+  GNUNET_free (mh);
 }