1 files changed, 198 insertions, 191 deletions

diff --git a/src/dht/gnunet-service-dht_routing.c b/src/dht/gnunet-service-dht_routing.c
index 99c6b5e4f..3454c1acb 100644
--- a/src/dht/gnunet-service-dht_routing.c
+++ b/src/dht/gnunet-service-dht_routing.c
@@ -39,7 +39,8 @@
  * Information we keep about all recent GET requests
  * so that we can route replies.
  */
-struct RecentRequest {
+struct RecentRequest
+{
   /**
    * The peer this request was received from.
    */
@@ -97,7 +98,8 @@ static struct GNUNET_CONTAINER_MultiHashMap *recent_map;
 /**
  * Closure for the 'process' function.
  */
-struct ProcessContext {
+struct ProcessContext
+{
   /**
    * Path of the original PUT
    */
@@ -150,9 +152,9 @@ struct ProcessContext {
  *         #GNUNET_SYSERR if the result is malformed or type unsupported
  */
 static int
-process(void *cls,
-        const struct GNUNET_HashCode *key,
-        void *value)
+process (void *cls,
+         const struct GNUNET_HashCode *key,
+         void *value)
 {
   struct ProcessContext *pc = cls;
   struct RecentRequest *rr = value;
@@ -167,106 +169,110 @@ process(void *cls,
     return GNUNET_OK;           /* type missmatch */
 
   if (0 != (rr->options & GNUNET_DHT_RO_RECORD_ROUTE))
-    {
-      gpl = pc->get_path_length;
-      ppl = pc->put_path_length;
-    }
+  {
+    gpl = pc->get_path_length;
+    ppl = pc->put_path_length;
+  }
   else
-    {
-      gpl = 0;
-      ppl = 0;
-    }
+  {
+    gpl = 0;
+    ppl = 0;
+  }
   if ((0 != (rr->options & GNUNET_DHT_RO_FIND_PEER)) &&
       (pc->type == GNUNET_BLOCK_TYPE_DHT_HELLO))
-    {
-      /* key may not match HELLO, which is OK since
-       * the search is approximate.  Still, the evaluation
-       * would fail since the match is not exact.  So
-       * we fake it by changing the key to the actual PID ... */
-      GNUNET_BLOCK_get_key(GDS_block_context,
-                           GNUNET_BLOCK_TYPE_DHT_HELLO,
-                           pc->data,
-                           pc->data_size,
-                           &hc);
-      eval_key = &hc;
-    }
+  {
+    /* key may not match HELLO, which is OK since
+     * the search is approximate.  Still, the evaluation
+     * would fail since the match is not exact.  So
+     * we fake it by changing the key to the actual PID ... */
+    GNUNET_BLOCK_get_key (GDS_block_context,
+                          GNUNET_BLOCK_TYPE_DHT_HELLO,
+                          pc->data,
+                          pc->data_size,
+                          &hc);
+    eval_key = &hc;
+  }
   else
-    {
-      eval_key = key;
-    }
+  {
+    eval_key = key;
+  }
   eval
-    = GNUNET_BLOCK_evaluate(GDS_block_context,
-                            pc->type,
-                            rr->bg,
-                            GNUNET_BLOCK_EO_NONE,
-                            eval_key,
-                            rr->xquery,
-                            rr->xquery_size,
-                            pc->data,
-                            pc->data_size);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Result for %s of type %d was evaluated as %d\n",
-             GNUNET_h2s(key),
-             pc->type,
-             eval);
+    = GNUNET_BLOCK_evaluate (GDS_block_context,
+                             pc->type,
+                             rr->bg,
+                             GNUNET_BLOCK_EO_NONE,
+                             eval_key,
+                             rr->xquery,
+                             rr->xquery_size,
+                             pc->data,
+                             pc->data_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Result for %s of type %d was evaluated as %d\n",
+              GNUNET_h2s (key),
+              pc->type,
+              eval);
   switch (eval)
-    {
-    case GNUNET_BLOCK_EVALUATION_OK_MORE:
-    case GNUNET_BLOCK_EVALUATION_OK_LAST:
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# Good REPLIES matched against routing table"),
-                               1, GNUNET_NO);
-      GDS_NEIGHBOURS_handle_reply(&rr->peer,
-                                  pc->type,
-                                  pc->expiration_time,
-                                  key,
-                                  ppl, pc->put_path,
-                                  gpl, pc->get_path,
-                                  pc->data,
-                                  pc->data_size);
-      break;
-
-    case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# Duplicate REPLIES matched against routing table"),
-                               1, GNUNET_NO);
-      return GNUNET_OK;
-
-    case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# Invalid REPLIES matched against routing table"),
-                               1, GNUNET_NO);
-      return GNUNET_SYSERR;
-
-    case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# Irrelevant REPLIES matched against routing table"),
-                               1, GNUNET_NO);
-      return GNUNET_OK;
-
-    case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
-      GNUNET_break(0);
-      return GNUNET_OK;
-
-    case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
-      GNUNET_break(0);
-      return GNUNET_OK;
-
-    case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# Unsupported REPLIES matched against routing table"),
-                               1, GNUNET_NO);
-      return GNUNET_SYSERR;
-
-    default:
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+  case GNUNET_BLOCK_EVALUATION_OK_MORE:
+  case GNUNET_BLOCK_EVALUATION_OK_LAST:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                                ("# Good REPLIES matched against routing table"),
+                              1, GNUNET_NO);
+    GDS_NEIGHBOURS_handle_reply (&rr->peer,
+                                 pc->type,
+                                 pc->expiration_time,
+                                 key,
+                                 ppl, pc->put_path,
+                                 gpl, pc->get_path,
+                                 pc->data,
+                                 pc->data_size);
+    break;
+
+  case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                              (
+                                "# Duplicate REPLIES matched against routing table"),
+                              1, GNUNET_NO);
+    return GNUNET_OK;
+
+  case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                              (
+                                "# Invalid REPLIES matched against routing table"),
+                              1, GNUNET_NO);
+    return GNUNET_SYSERR;
+
+  case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                              (
+                                "# Irrelevant REPLIES matched against routing table"),
+                              1, GNUNET_NO);
+    return GNUNET_OK;
+
+  case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
+    GNUNET_break (0);
+    return GNUNET_OK;
+
+  case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
+    GNUNET_break (0);
+    return GNUNET_OK;
+
+  case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                              (
+                                "# Unsupported REPLIES matched against routing table"),
+                              1, GNUNET_NO);
+    return GNUNET_SYSERR;
+
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -289,15 +295,15 @@ process(void *cls,
  * @param data_size number of bytes in data
  */
 void
-GDS_ROUTING_process(enum GNUNET_BLOCK_Type type,
-                    struct GNUNET_TIME_Absolute expiration_time,
-                    const struct GNUNET_HashCode *key,
-                    unsigned int put_path_length,
-                    const struct GNUNET_PeerIdentity *put_path,
-                    unsigned int get_path_length,
-                    const struct GNUNET_PeerIdentity *get_path,
-                    const void *data,
-                    size_t data_size)
+GDS_ROUTING_process (enum GNUNET_BLOCK_Type type,
+                     struct GNUNET_TIME_Absolute expiration_time,
+                     const struct GNUNET_HashCode *key,
+                     unsigned int put_path_length,
+                     const struct GNUNET_PeerIdentity *put_path,
+                     unsigned int get_path_length,
+                     const struct GNUNET_PeerIdentity *get_path,
+                     const void *data,
+                     size_t data_size)
 {
   struct ProcessContext pc;
 
@@ -310,19 +316,19 @@ GDS_ROUTING_process(enum GNUNET_BLOCK_Type type,
   pc.data = data;
   pc.data_size = data_size;
   if (NULL == data)
-    {
-      /* Some apps might have an 'empty' reply as a valid reply; however,
-         'process' will call GNUNET_BLOCK_evaluate' which treats a 'NULL'
-         reply as request-validation (but we need response-validation).
-         So we set 'data' to a 0-byte non-NULL value just to be sure */
-      GNUNET_break(0 == data_size);
-      pc.data_size = 0;
-      pc.data = ""; /* something not null */
-    }
-  GNUNET_CONTAINER_multihashmap_get_multiple(recent_map,
-                                             key,
-                                             &process,
-                                             &pc);
+  {
+    /* Some apps might have an 'empty' reply as a valid reply; however,
+       'process' will call GNUNET_BLOCK_evaluate' which treats a 'NULL'
+       reply as request-validation (but we need response-validation).
+       So we set 'data' to a 0-byte non-NULL value just to be sure */
+    GNUNET_break (0 == data_size);
+    pc.data_size = 0;
+    pc.data = "";   /* something not null */
+  }
+  GNUNET_CONTAINER_multihashmap_get_multiple (recent_map,
+                                              key,
+                                              &process,
+                                              &pc);
 }
 
 
@@ -332,23 +338,23 @@ GDS_ROUTING_process(enum GNUNET_BLOCK_Type type,
  * in the heap and hashmap.
  */
 static void
-expire_oldest_entry()
+expire_oldest_entry ()
 {
   struct RecentRequest *recent_req;
 
-  GNUNET_STATISTICS_update(GDS_stats,
-                           gettext_noop
-                             ("# Entries removed from routing table"), 1,
-                           GNUNET_NO);
-  recent_req = GNUNET_CONTAINER_heap_peek(recent_heap);
-  GNUNET_assert(recent_req != NULL);
-  GNUNET_CONTAINER_heap_remove_node(recent_req->heap_node);
-  GNUNET_BLOCK_group_destroy(recent_req->bg);
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_remove(recent_map,
-                                                     &recent_req->key,
-                                                     recent_req));
-  GNUNET_free(recent_req);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            gettext_noop
+                              ("# Entries removed from routing table"), 1,
+                            GNUNET_NO);
+  recent_req = GNUNET_CONTAINER_heap_peek (recent_heap);
+  GNUNET_assert (recent_req != NULL);
+  GNUNET_CONTAINER_heap_remove_node (recent_req->heap_node);
+  GNUNET_BLOCK_group_destroy (recent_req->bg);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (recent_map,
+                                                       &recent_req->key,
+                                                       recent_req));
+  GNUNET_free (recent_req);
 }
 
 
@@ -363,26 +369,26 @@ expire_oldest_entry()
  *         #GNUNET_SYSERR if the request was successfully combined
  */
 static int
-try_combine_recent(void *cls,
-                   const struct GNUNET_HashCode *key,
-                   void *value)
+try_combine_recent (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
 {
   struct RecentRequest *in = cls;
   struct RecentRequest *rr = value;
 
-  if ((0 != GNUNET_memcmp(&in->peer,
-                          &rr->peer)) ||
+  if ((0 != GNUNET_memcmp (&in->peer,
+                           &rr->peer)) ||
       (in->type != rr->type) ||
       (in->xquery_size != rr->xquery_size) ||
-      (0 != memcmp(in->xquery,
-                   rr->xquery,
-                   in->xquery_size)))
+      (0 != memcmp (in->xquery,
+                    rr->xquery,
+                    in->xquery_size)))
     return GNUNET_OK;
-  GNUNET_break(GNUNET_SYSERR !=
-               GNUNET_BLOCK_group_merge(in->bg,
-                                        rr->bg));
+  GNUNET_break (GNUNET_SYSERR !=
+                GNUNET_BLOCK_group_merge (in->bg,
+                                          rr->bg));
   rr->bg = in->bg;
-  GNUNET_free(in);
+  GNUNET_free (in);
   return GNUNET_SYSERR;
 }
 
@@ -400,53 +406,53 @@ try_combine_recent(void *cls,
  * @param reply_bf_mutator mutator for @a reply_bf
  */
 void
-GDS_ROUTING_add(const struct GNUNET_PeerIdentity *sender,
-                enum GNUNET_BLOCK_Type type,
-                struct GNUNET_BLOCK_Group *bg,
-                enum GNUNET_DHT_RouteOption options,
-                const struct GNUNET_HashCode *key,
-                const void *xquery,
-                size_t xquery_size)
+GDS_ROUTING_add (const struct GNUNET_PeerIdentity *sender,
+                 enum GNUNET_BLOCK_Type type,
+                 struct GNUNET_BLOCK_Group *bg,
+                 enum GNUNET_DHT_RouteOption options,
+                 const struct GNUNET_HashCode *key,
+                 const void *xquery,
+                 size_t xquery_size)
 {
   struct RecentRequest *recent_req;
 
-  while (GNUNET_CONTAINER_heap_get_size(recent_heap) >= DHT_MAX_RECENT)
-    expire_oldest_entry();
-  GNUNET_STATISTICS_update(GDS_stats,
-                           gettext_noop("# Entries added to routing table"),
-                           1,
-                           GNUNET_NO);
-  recent_req = GNUNET_malloc(sizeof(struct RecentRequest) + xquery_size);
+  while (GNUNET_CONTAINER_heap_get_size (recent_heap) >= DHT_MAX_RECENT)
+    expire_oldest_entry ();
+  GNUNET_STATISTICS_update (GDS_stats,
+                            gettext_noop ("# Entries added to routing table"),
+                            1,
+                            GNUNET_NO);
+  recent_req = GNUNET_malloc (sizeof(struct RecentRequest) + xquery_size);
   recent_req->peer = *sender;
   recent_req->key = *key;
   recent_req->bg = bg;
   recent_req->type = type;
   recent_req->options = options;
   recent_req->xquery = &recent_req[1];
-  GNUNET_memcpy(&recent_req[1],
-                xquery,
-                xquery_size);
+  GNUNET_memcpy (&recent_req[1],
+                 xquery,
+                 xquery_size);
   recent_req->xquery_size = xquery_size;
   if (GNUNET_SYSERR ==
-      GNUNET_CONTAINER_multihashmap_get_multiple(recent_map,
-                                                 key,
-                                                 &try_combine_recent,
-                                                 recent_req))
-    {
-      GNUNET_STATISTICS_update(GDS_stats,
-                               gettext_noop
-                                 ("# DHT requests combined"),
-                               1, GNUNET_NO);
-      return;
-    }
+      GNUNET_CONTAINER_multihashmap_get_multiple (recent_map,
+                                                  key,
+                                                  &try_combine_recent,
+                                                  recent_req))
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              gettext_noop
+                                ("# DHT requests combined"),
+                              1, GNUNET_NO);
+    return;
+  }
   recent_req->heap_node
-    = GNUNET_CONTAINER_heap_insert(recent_heap,
-                                   recent_req,
-                                   GNUNET_TIME_absolute_get().abs_value_us);
-  GNUNET_CONTAINER_multihashmap_put(recent_map,
-                                    key,
+    = GNUNET_CONTAINER_heap_insert (recent_heap,
                                     recent_req,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+                                    GNUNET_TIME_absolute_get ().abs_value_us);
+  GNUNET_CONTAINER_multihashmap_put (recent_map,
+                                     key,
+                                     recent_req,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 }
 
 
@@ -454,10 +460,11 @@ GDS_ROUTING_add(const struct GNUNET_PeerIdentity *sender,
  * Initialize routing subsystem.
  */
 void
-GDS_ROUTING_init()
+GDS_ROUTING_init ()
 {
-  recent_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  recent_map = GNUNET_CONTAINER_multihashmap_create(DHT_MAX_RECENT * 4 / 3, GNUNET_NO);
+  recent_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  recent_map = GNUNET_CONTAINER_multihashmap_create (DHT_MAX_RECENT * 4 / 3,
+                                                     GNUNET_NO);
 }
 
 
@@ -465,15 +472,15 @@ GDS_ROUTING_init()
  * Shutdown routing subsystem.
  */
 void
-GDS_ROUTING_done()
+GDS_ROUTING_done ()
 {
-  while (GNUNET_CONTAINER_heap_get_size(recent_heap) > 0)
-    expire_oldest_entry();
-  GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(recent_heap));
-  GNUNET_CONTAINER_heap_destroy(recent_heap);
+  while (GNUNET_CONTAINER_heap_get_size (recent_heap) > 0)
+    expire_oldest_entry ();
+  GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (recent_heap));
+  GNUNET_CONTAINER_heap_destroy (recent_heap);
   recent_heap = NULL;
-  GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(recent_map));
-  GNUNET_CONTAINER_multihashmap_destroy(recent_map);
+  GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (recent_map));
+  GNUNET_CONTAINER_multihashmap_destroy (recent_map);
   recent_map = NULL;
 }