-non-trivial refactoring/cleanup of the DHT code

1 files changed, 74 insertions, 126 deletions

diff --git a/src/dht/gnunet-service-dht_routing.c b/src/dht/gnunet-service-dht_routing.c
index ef3aded77..8ba0c70ad 100644
--- a/src/dht/gnunet-service-dht_routing.c
+++ b/src/dht/gnunet-service-dht_routing.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2011 GNUnet e.V.
+     Copyright (C) 2011, 2022 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -31,8 +31,9 @@
 
 /**
  * Number of requests we track at most (for routing replies).
+ * TODO: make configurable!
  */
-#define DHT_MAX_RECENT (1024 * 16)
+#define DHT_MAX_RECENT (1024 * 128)
 
 
 /**
@@ -96,14 +97,14 @@ static struct GNUNET_CONTAINER_MultiHashMap *recent_map;
 
 
 /**
- * Closure for the 'process' function.
+ * Closure for the process() function.
  */
 struct ProcessContext
 {
   /**
-   * Path of the original PUT
+   * Block data.
    */
-  const struct GNUNET_PeerIdentity *put_path;
+  const struct GDS_DATACACHE_BlockData *bd;
 
   /**
    * Path of the reply.
@@ -111,34 +112,10 @@ struct ProcessContext
   const struct GNUNET_PeerIdentity *get_path;
 
   /**
-   * Payload of the reply.
-   */
-  const void *data;
-
-  /**
-   * Expiration time of the result.
-   */
-  struct GNUNET_TIME_Absolute expiration_time;
-
-  /**
-   * Number of entries in @e put_path.
-   */
-  unsigned int put_path_length;
-
-  /**
    * Number of entries in @e get_path.
    */
   unsigned int get_path_length;
 
-  /**
-   * Number of bytes in @e data.
-   */
-  size_t data_size;
-
-  /**
-   * Type of the reply.
-   */
-  enum GNUNET_BLOCK_Type type;
 };
 
 
@@ -146,71 +123,56 @@ struct ProcessContext
  * Forward the result to the given peer if it matches the request.
  *
  * @param cls the `struct ProcessContext` with the result
- * @param key the query
+ * @param query_hash the hash from the original query
  * @param value the `struct RecentRequest` with the request
  * @return #GNUNET_OK (continue to iterate)
  */
 static enum GNUNET_GenericReturnValue
 process (void *cls,
-         const struct GNUNET_HashCode *key,
+         const struct GNUNET_HashCode *query_hash,
          void *value)
 {
   struct ProcessContext *pc = cls;
   struct RecentRequest *rr = value;
   enum GNUNET_BLOCK_ReplyEvaluationResult eval;
-  unsigned int gpl;
-  unsigned int ppl;
-  struct GNUNET_HashCode hc;
-  const struct GNUNET_HashCode *eval_key;
+  unsigned int get_path_length;
+  struct GDS_DATACACHE_BlockData bdx = *pc->bd;
 
-  if ((rr->type != GNUNET_BLOCK_TYPE_ANY) &&
-      (rr->type != pc->type))
+  if ( (rr->type != GNUNET_BLOCK_TYPE_ANY) &&
+       (rr->type != pc->bd->type) )
     return GNUNET_OK;           /* type mismatch */
-
   if (0 != (rr->options & GNUNET_DHT_RO_RECORD_ROUTE))
   {
-    gpl = pc->get_path_length;
-    ppl = pc->put_path_length;
+    get_path_length = pc->get_path_length;
   }
   else
   {
-    gpl = 0;
-    ppl = 0;
+    get_path_length = 0;
+    bdx.put_path_length = 0;
+    bdx.put_path = NULL;
   }
-  /* FIXME-SCHANZEN: should we modify FIND_PEER to
-     be a generic approximate search and not check
-     for the DHT_HELLO type here? */
-  if ( (0 != (rr->options & GNUNET_DHT_RO_FIND_PEER)) &&
-       (pc->type == GNUNET_BLOCK_TYPE_DHT_HELLO) )
+  if ( (0 == (rr->options & GNUNET_DHT_RO_FIND_PEER)) &&
+       (0 != GNUNET_memcmp (query_hash,
+                            &bdx.key)) )
   {
-    /* 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;
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Inexact matches discarded in exact search",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_OK; /* exact search, but inexact match */
   }
-  eval
-    = GNUNET_BLOCK_check_reply (GDS_block_context,
-                                pc->type,
-                                rr->bg,
-                                eval_key,
-                                rr->xquery,
-                                rr->xquery_size,
-                                pc->data,
-                                pc->data_size);
+  eval = GNUNET_BLOCK_check_reply (GDS_block_context,
+                                   bdx.type,
+                                   rr->bg,
+                                   &bdx.key,
+                                   rr->xquery,
+                                   rr->xquery_size,
+                                   bdx.data,
+                                   bdx.data_size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Result for %s of type %d was evaluated as %d\n",
-              GNUNET_h2s (key),
-              pc->type,
+              GNUNET_h2s (&bdx.key),
+              bdx.type,
               eval);
   switch (eval)
   {
@@ -222,13 +184,9 @@ process (void *cls,
                               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);
+                                 &bdx,
+                                 query_hash,
+                                 get_path_length, pc->get_path);
     break;
   case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
     GNUNET_STATISTICS_update (GDS_stats,
@@ -264,39 +222,25 @@ process (void *cls,
  * GDS_NEIGHBOURS_handle_reply() for all peers that sent us a matching
  * request recently.
  *
- * @param type type of the block
- * @param expiration_time when does the content expire
- * @param key key for the content
- * @param put_path_length number of entries in @a put_path
- * @param put_path peers the original PUT traversed (if tracked)
+ * @param bd block details
+ * @param query_hash query used in the inquiry
  * @param get_path_length number of entries in @a get_path
  * @param get_path peers this reply has traversed so far (if tracked)
- * @param data payload of the reply
- * @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,
+GDS_ROUTING_process (const struct GDS_DATACACHE_BlockData *bd,
+                     const struct GNUNET_HashCode *query_hash,
                      unsigned int get_path_length,
-                     const struct GNUNET_PeerIdentity *get_path,
-                     const void *data,
-                     size_t data_size)
+                     const struct GNUNET_PeerIdentity *get_path)
 {
-  struct ProcessContext pc;
-
-  pc.type = type;
-  pc.expiration_time = expiration_time;
-  pc.put_path_length = put_path_length;
-  pc.put_path = put_path;
-  pc.get_path_length = get_path_length;
-  pc.get_path = get_path;
-  pc.data = data;
-  pc.data_size = data_size;
+  struct ProcessContext pc = {
+    .bd = bd,
+    .get_path = get_path,
+    .get_path_length = get_path_length
+  };
+
   GNUNET_CONTAINER_multihashmap_get_multiple (recent_map,
-                                              key,
+                                              query_hash,
                                               &process,
                                               &pc);
 }
@@ -313,7 +257,7 @@ expire_oldest_entry (void)
   struct RecentRequest *recent_req;
 
   GNUNET_STATISTICS_update (GDS_stats,
-                            "# Entries removed from routing table",
+                            "# Old entries removed from routing table",
                             1,
                             GNUNET_NO);
   recent_req = GNUNET_CONTAINER_heap_peek (recent_heap);
@@ -334,7 +278,7 @@ expire_oldest_entry (void)
  *
  * @param cls the new `struct RecentRequest` (to discard upon successful combination)
  * @param key the query
- * @param value the existing 'struct RecentRequest' (to update upon successful combination)
+ * @param value the existing `struct RecentRequest` (to update upon successful combination)
  * @return #GNUNET_OK (continue to iterate),
  *         #GNUNET_SYSERR if the request was successfully combined
  */
@@ -346,13 +290,13 @@ try_combine_recent (void *cls,
   struct RecentRequest *in = cls;
   struct RecentRequest *rr = value;
 
-  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)))
+  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) ) )
     return GNUNET_OK;
   GNUNET_break (GNUNET_SYSERR !=
                 GNUNET_BLOCK_group_merge (in->bg,
@@ -410,19 +354,21 @@ GDS_ROUTING_add (const struct GNUNET_PeerIdentity *sender,
                                                   recent_req))
   {
     GNUNET_STATISTICS_update (GDS_stats,
-                              gettext_noop
-                                ("# DHT requests combined"),
-                              1, GNUNET_NO);
+                              "# 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,
-                                     recent_req,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    = GNUNET_CONTAINER_heap_insert (
+        recent_heap,
+        recent_req,
+        GNUNET_TIME_absolute_get ().abs_value_us);
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    recent_map,
+    key,
+    recent_req,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 }
 
 
@@ -446,10 +392,12 @@ 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_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_assert (0 ==
+                 GNUNET_CONTAINER_multihashmap_size (recent_map));
   GNUNET_CONTAINER_multihashmap_destroy (recent_map);
   recent_map = NULL;
 }