major modification to datacache to store route options (and clean up the API)

7 files changed, 769 insertions, 519 deletions

diff --git a/src/datacache/datacache.c b/src/datacache/datacache.c
index 761ab801f..c93ed58d6 100644
--- a/src/datacache/datacache.c
+++ b/src/datacache/datacache.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2015 GNUnet e.V.
+     Copyright (C) 2004-2010, 2015, 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
@@ -259,26 +259,14 @@ GNUNET_DATACACHE_destroy (struct GNUNET_DATACACHE_Handle *h)
 
 enum GNUNET_GenericReturnValue
 GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
-                      const struct GNUNET_HashCode *key,
                       uint32_t xor_distance,
-                      size_t data_size,
-                      const char *data,
-                      enum GNUNET_BLOCK_Type type,
-                      struct GNUNET_TIME_Absolute discard_time,
-                      unsigned int path_info_len,
-                      const struct GNUNET_DHT_PathElement *path_info)
+                      const struct GNUNET_DATACACHE_Block *block)
 {
   ssize_t used;
 
   used = h->api->put (h->api->cls,
-                      key,
                       xor_distance,
-                      data_size,
-                      data,
-                      type,
-                      discard_time,
-                      path_info_len,
-                      path_info);
+                      block);
   if (-1 == used)
   {
     GNUNET_break (0);
@@ -291,10 +279,10 @@ GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Stored data under key `%s' in cache\n",
-       GNUNET_h2s (key));
+       GNUNET_h2s (&block->key));
   if (NULL != h->filter)
     GNUNET_CONTAINER_bloomfilter_add (h->filter,
-                                      key);
+                                      &block->key);
   GNUNET_STATISTICS_update (h->stats,
                             "# bytes stored",
                             used,
@@ -325,9 +313,10 @@ GNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing request for key `%s'\n",
        GNUNET_h2s (key));
-  if ((NULL != h->filter) &&
-      (GNUNET_OK !=
-       GNUNET_CONTAINER_bloomfilter_test (h->filter, key)))
+  if ( (NULL != h->filter) &&
+       (GNUNET_OK !=
+        GNUNET_CONTAINER_bloomfilter_test (h->filter,
+                                           key)) )
   {
     GNUNET_STATISTICS_update (h->stats,
                               "# requests filtered by bloom filter",
@@ -364,7 +353,8 @@ GNUNET_DATACACHE_get_closest (struct GNUNET_DATACACHE_Handle *h,
                               key,
                               type,
                               num_results,
-                              iter, iter_cls);
+                              iter,
+                              iter_cls);
 }
 
 
diff --git a/src/datacache/plugin_datacache_heap.c b/src/datacache/plugin_datacache_heap.c
index 5b50468a5..a2b60c8da 100644
--- a/src/datacache/plugin_datacache_heap.c
+++ b/src/datacache/plugin_datacache_heap.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     Copyright (C) 2012, 2015 GNUnet e.V.
+     Copyright (C) 2012, 2015, 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
@@ -63,14 +63,9 @@ struct Plugin
 struct Value
 {
   /**
-   * Key for the entry.
+   * Block data.
    */
-  struct GNUNET_HashCode key;
-
-  /**
-   * Expiration time.
-   */
-  struct GNUNET_TIME_Absolute discard_time;
+  struct GNUNET_DATACACHE_Block block;
 
   /**
    * Corresponding node in the heap.
@@ -78,29 +73,15 @@ struct Value
   struct GNUNET_CONTAINER_HeapNode *hn;
 
   /**
-   * Path information.
-   */
-  struct GNUNET_DHT_PathElement *path_info;
-
-  /**
-   * Payload (actual payload follows this struct)
-   */
-  size_t size;
-
-  /**
-   * Number of entries in @e path_info.
+   * Put path as a non-const pointer.
    */
-  unsigned int path_info_len;
+  struct GNUNET_DHT_PathElement *put_path;
 
   /**
    * How close is the hash to us? Determines which heap we are in!
    */
   uint32_t distance;
 
-  /**
-   * Type of the block.
-   */
-  enum GNUNET_BLOCK_Type type;
 };
 
 
@@ -113,39 +94,14 @@ struct Value
 struct PutContext
 {
   /**
-   * Expiration time for the new value.
-   */
-  struct GNUNET_TIME_Absolute discard_time;
-
-  /**
-   * Data for the new value.
-   */
-  const char *data;
-
-  /**
-   * Path information.
+   * Block data.
    */
-  const struct GNUNET_DHT_PathElement *path_info;
+  const struct GNUNET_DATACACHE_Block *block;
 
   /**
-   * Number of bytes in @e data.
+   * Value to set to true if an equivalent block was found.
    */
-  size_t size;
-
-  /**
-   * Type of the node.
-   */
-  enum GNUNET_BLOCK_Type type;
-
-  /**
-   * Number of entries in @e path_info.
-   */
-  unsigned int path_info_len;
-
-  /**
-   * Value to set to #GNUNET_YES if an equivalent block was found.
-   */
-  int found;
+  bool found;
 };
 
 
@@ -166,31 +122,31 @@ put_cb (void *cls,
   struct PutContext *put_ctx = cls;
   struct Value *val = value;
 
-  if ((val->size == put_ctx->size) &&
-      (val->type == put_ctx->type) &&
-      (0 == memcmp (&val[1],
-                    put_ctx->data,
-                    put_ctx->size)))
+  if ((val->block.data_size == put_ctx->block->data_size) &&
+      (val->block.type == put_ctx->block->type) &&
+      (0 == memcmp (val->block.data,
+                    put_ctx->block->data,
+                    put_ctx->block->data_size)))
   {
-    put_ctx->found = GNUNET_YES;
-    val->discard_time = GNUNET_TIME_absolute_max (val->discard_time,
-                                                  put_ctx->discard_time);
+    put_ctx->found = true;
+    val->block.expiration_time
+      = GNUNET_TIME_absolute_max (val->block.expiration_time,
+                                  put_ctx->block->expiration_time);
     /* replace old path with new path */
-    GNUNET_array_grow (val->path_info,
-                       val->path_info_len,
-                       put_ctx->path_info_len);
-    GNUNET_memcpy (val->path_info,
-                   put_ctx->path_info,
-                   put_ctx->path_info_len * sizeof(struct
-                                                   GNUNET_DHT_PathElement));
+    GNUNET_free (val->put_path);
+    val->put_path = GNUNET_memdup (put_ctx->block->put_path,
+                                   put_ctx->block->put_path_length
+                                   * sizeof (struct GNUNET_DHT_PathElement));
+    val->block.put_path = val->put_path;
+    val->block.put_path_length = put_ctx->block->put_path_length;
     GNUNET_CONTAINER_heap_update_cost (val->hn,
-                                       val->discard_time.abs_value_us);
+                                       val->block.expiration_time.abs_value_us);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Got same value for key %s and type %d (size %u vs %u)\n",
+                "Got same value for key %s and type %u (size %u vs %u)\n",
                 GNUNET_h2s (key),
-                val->type,
-                (unsigned int) val->size,
-                (unsigned int) put_ctx->size);
+                (unsigned int) val->block.type,
+                (unsigned int) val->block.data_size,
+                (unsigned int) put_ctx->block->data_size);
     return GNUNET_NO;
   }
   return GNUNET_YES;
@@ -201,75 +157,58 @@ put_cb (void *cls,
  * Store an item in the datastore.
  *
  * @param cls closure (our `struct Plugin`)
- * @param key key to store data under
  * @param xor_distance how close is @a key to our PID?
- * @param size number of bytes in @a data
- * @param data data to store
- * @param type type of the value
- * @param discard_time when to discard the value in any case
- * @param path_info_len number of entries in @a path_info
- * @param path_info a path through the network
+ * @param block data to store
  * @return 0 if duplicate, -1 on error, number of bytes used otherwise
  */
 static ssize_t
 heap_plugin_put (void *cls,
-                 const struct GNUNET_HashCode *key,
                  uint32_t xor_distance,
-                 size_t size,
-                 const char *data,
-                 enum GNUNET_BLOCK_Type type,
-                 struct GNUNET_TIME_Absolute discard_time,
-                 unsigned int path_info_len,
-                 const struct GNUNET_DHT_PathElement *path_info)
+                 const struct GNUNET_DATACACHE_Block *block)
 {
   struct Plugin *plugin = cls;
   struct Value *val;
   struct PutContext put_ctx = {
-    .data = data,
-    .size = size,
-    .path_info = path_info,
-    .path_info_len = path_info_len,
-    .discard_time = discard_time,
-    .type = type
+    .block = block,
+    .found = false
   };
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Storing %u bytes under key %s with path length %u\n",
-              (unsigned int) size,
-              GNUNET_h2s (key),
-              path_info_len);
+              (unsigned int) block->data_size,
+              GNUNET_h2s (&block->key),
+              block->put_path_length);
   GNUNET_CONTAINER_multihashmap_get_multiple (plugin->map,
-                                              key,
+                                              &block->key,
                                               &put_cb,
                                               &put_ctx);
   if (GNUNET_YES == put_ctx.found)
     return 0;
-  val = GNUNET_malloc (sizeof(struct Value) + size);
+  val = GNUNET_malloc (sizeof(struct Value)
+                       + block->data_size);
   GNUNET_memcpy (&val[1],
-                 data,
-                 size);
-  val->key = *key;
-  val->type = type;
-  val->discard_time = discard_time;
-  val->size = size;
+                 block->data,
+                 block->data_size);
+  val->block = *block;
+  val->block.data = &val[1];
   if (xor_distance >= NUM_HEAPS)
     val->distance = NUM_HEAPS - 1;
   else
     val->distance = xor_distance;
-  GNUNET_array_grow (val->path_info,
-                     val->path_info_len,
-                     path_info_len);
-  GNUNET_memcpy (val->path_info,
-                 path_info,
-                 path_info_len * sizeof(struct GNUNET_DHT_PathElement));
+  if (0 != block->put_path_length)
+    val->block.put_path
+      = GNUNET_memdup (block->put_path,
+                       block->put_path_length
+                       * sizeof (struct GNUNET_DHT_PathElement));
   (void) GNUNET_CONTAINER_multihashmap_put (plugin->map,
-                                            &val->key,
+                                            &val->block.key,
                                             val,
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  val->hn = GNUNET_CONTAINER_heap_insert (plugin->heaps[val->distance],
-                                          val,
-                                          val->discard_time.abs_value_us);
-  return size + OVERHEAD;
+  val->hn = GNUNET_CONTAINER_heap_insert (
+    plugin->heaps[val->distance],
+    val,
+    val->block.expiration_time.abs_value_us);
+  return val->block.data_size + OVERHEAD;
 }
 
 
@@ -309,16 +248,16 @@ struct GetContext
  * @param value an existing value
  * @return #GNUNET_YES to continue to iterate
  */
-static int
+static enum GNUNET_GenericReturnValue
 get_cb (void *cls,
         const struct GNUNET_HashCode *key,
         void *value)
 {
   struct GetContext *get_ctx = cls;
   struct Value *val = value;
-  int ret;
+  enum GNUNET_GenericReturnValue ret;
 
-  if ( (get_ctx->type != val->type) &&
+  if ( (get_ctx->type != val->block.type) &&
        (GNUNET_BLOCK_TYPE_ANY != get_ctx->type) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -327,7 +266,7 @@ get_cb (void *cls,
                 get_ctx->type);
     return GNUNET_OK;
   }
-  if (GNUNET_TIME_absolute_is_past (val->discard_time))
+  if (GNUNET_TIME_absolute_is_past (val->block.expiration_time))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Result for key %s is expired\n",
@@ -339,13 +278,7 @@ get_cb (void *cls,
               GNUNET_h2s (key));
   if (NULL != get_ctx->iter)
     ret = get_ctx->iter (get_ctx->iter_cls,
-                         key,
-                         val->size,
-                         (const char *) &val[1],
-                         val->type,
-                         val->discard_time,
-                         val->path_info_len,
-                         val->path_info);
+                         &val->block);
   else
     ret = GNUNET_YES;
   get_ctx->cnt++;
@@ -393,7 +326,7 @@ heap_plugin_get (void *cls,
  * @param cls closure (our `struct Plugin`)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
-static int
+static enum GNUNET_GenericReturnValue
 heap_plugin_del (void *cls)
 {
   struct Plugin *plugin = cls;
@@ -409,12 +342,12 @@ heap_plugin_del (void *cls)
     return GNUNET_SYSERR;
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_remove (plugin->map,
-                                                       &val->key,
+                                                       &val->block.key,
                                                        val));
   plugin->env->delete_notify (plugin->env->cls,
-                              &val->key,
-                              val->size + OVERHEAD);
-  GNUNET_free (val->path_info);
+                              &val->block.key,
+                              val->block.data_size + OVERHEAD);
+  GNUNET_free (val->put_path);
   GNUNET_free (val);
   return GNUNET_OK;
 }
@@ -448,7 +381,7 @@ find_closest (void *cls,
   if (1 != GNUNET_CRYPTO_hash_cmp (key,
                                    gcc->key))
     return GNUNET_OK; /* useless */
-  if ( (val->type != gcc->type) &&
+  if ( (val->block.type != gcc->type) &&
        (GNUNET_BLOCK_TYPE_ANY != gcc->type) )
     return GNUNET_OK; /* useless */
   j = gcc->num_results;
@@ -460,7 +393,7 @@ find_closest (void *cls,
       break;
     }
     if (1 ==
-        GNUNET_CRYPTO_hash_cmp (&gcc->values[i]->key,
+        GNUNET_CRYPTO_hash_cmp (&gcc->values[i]->block.key,
                                 key))
     {
       j = i;
@@ -512,14 +445,15 @@ heap_plugin_get_closest (void *cls,
   {
     if (NULL == values[i])
       return i;
-    iter (iter_cls,
-          &values[i]->key,
-          values[i]->size,
-          (void *) &values[i][1],
-          values[i]->type,
-          values[i]->discard_time,
-          values[i]->path_info_len,
-          values[i]->path_info);
+    if ( (NULL != iter) &&
+         (GNUNET_SYSERR ==
+          iter (iter_cls,
+                &values[i]->block)) )
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Ending iteration (client error)\n");
+      return i;
+    }
   }
   return num_results * 2;
 }
@@ -576,9 +510,9 @@ libgnunet_plugin_datacache_heap_done (void *cls)
     {
       GNUNET_assert (GNUNET_YES ==
                      GNUNET_CONTAINER_multihashmap_remove (plugin->map,
-                                                           &val->key,
+                                                           &val->block.key,
                                                            val));
-      GNUNET_free (val->path_info);
+      GNUNET_free (val->put_path);
       GNUNET_free (val);
     }
     GNUNET_CONTAINER_heap_destroy (plugin->heaps[i]);
diff --git a/src/datacache/plugin_datacache_postgres.c b/src/datacache/plugin_datacache_postgres.c
index 1a83cda86..d9e25992b 100644
--- a/src/datacache/plugin_datacache_postgres.c
+++ b/src/datacache/plugin_datacache_postgres.c
@@ -63,73 +63,75 @@ struct Plugin
  * @param plugin global context
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
-static int
+static enum GNUNET_GenericReturnValue
 init_connection (struct Plugin *plugin)
 {
   struct GNUNET_PQ_ExecuteStatement es[] = {
     GNUNET_PQ_make_try_execute (
-      "CREATE TEMPORARY SEQUENCE IF NOT EXISTS gn011dc_oid_seq"),
-    GNUNET_PQ_make_execute ("CREATE TEMPORARY TABLE IF NOT EXISTS gn011dc ("
-                            "  oid OID NOT NULL DEFAULT nextval('gn011dc_oid_seq'),"
+      "CREATE TEMPORARY SEQUENCE IF NOT EXISTS gn180dc_oid_seq"),
+    GNUNET_PQ_make_execute ("CREATE TEMPORARY TABLE IF NOT EXISTS gn180dc ("
+                            "  oid OID NOT NULL DEFAULT nextval('gn180dc_oid_seq'),"
                             "  type INTEGER NOT NULL,"
+                            "  ro INTEGER NOT NULL,"
                             "  prox INTEGER NOT NULL,"
-                            "  discard_time BIGINT NOT NULL,"
+                            "  expiration_time BIGINT NOT NULL,"
                             "  key BYTEA NOT NULL,"
                             "  value BYTEA NOT NULL,"
                             "  path BYTEA DEFAULT NULL)"),
     GNUNET_PQ_make_try_execute (
-      "ALTER SEQUENCE gnu011dc_oid_seq OWNED BY gn011dc.oid"),
+      "ALTER SEQUENCE gnu011dc_oid_seq OWNED BY gn180dc.oid"),
     GNUNET_PQ_make_try_execute (
-      "CREATE INDEX IF NOT EXISTS idx_oid ON gn011dc (oid)"),
+      "CREATE INDEX IF NOT EXISTS idx_oid ON gn180dc (oid)"),
     GNUNET_PQ_make_try_execute (
-      "CREATE INDEX IF NOT EXISTS idx_key ON gn011dc (key)"),
+      "CREATE INDEX IF NOT EXISTS idx_key ON gn180dc (key)"),
     GNUNET_PQ_make_try_execute (
-      "CREATE INDEX IF NOT EXISTS idx_dt ON gn011dc (discard_time)"),
+      "CREATE INDEX IF NOT EXISTS idx_dt ON gn180dc (expiration_time)"),
     GNUNET_PQ_make_execute (
-      "ALTER TABLE gn011dc ALTER value SET STORAGE EXTERNAL"),
-    GNUNET_PQ_make_execute ("ALTER TABLE gn011dc ALTER key SET STORAGE PLAIN"),
+      "ALTER TABLE gn180dc ALTER value SET STORAGE EXTERNAL"),
+    GNUNET_PQ_make_execute ("ALTER TABLE gn180dc ALTER key SET STORAGE PLAIN"),
     GNUNET_PQ_EXECUTE_STATEMENT_END
   };
   struct GNUNET_PQ_PreparedStatement ps[] = {
     GNUNET_PQ_make_prepare ("getkt",
-                            "SELECT discard_time,type,value,path FROM gn011dc "
-                            "WHERE key=$1 AND type=$2 AND discard_time >= $3",
+                            "SELECT expiration_time,type,ro,value,path FROM gn180dc "
+                            "WHERE key=$1 AND type=$2 AND expiration_time >= $3",
                             3),
     GNUNET_PQ_make_prepare ("getk",
-                            "SELECT discard_time,type,value,path FROM gn011dc "
-                            "WHERE key=$1 AND discard_time >= $2",
+                            "SELECT expiration_time,type,ro,value,path FROM gn180dc "
+                            "WHERE key=$1 AND expiration_time >= $2",
                             2),
     GNUNET_PQ_make_prepare ("getex",
-                            "SELECT length(value) AS len,oid,key FROM gn011dc"
-                            " WHERE discard_time < $1"
-                            " ORDER BY discard_time ASC LIMIT 1",
+                            "SELECT LENGTH(value) AS len,oid,key FROM gn180dc"
+                            " WHERE expiration_time < $1"
+                            " ORDER BY expiration_time ASC LIMIT 1",
                             1),
     GNUNET_PQ_make_prepare ("getm",
-                            "SELECT length(value) AS len,oid,key FROM gn011dc"
-                            " ORDER BY prox ASC, discard_time ASC LIMIT 1",
+                            "SELECT LENGTH(value) AS len,oid,key FROM gn180dc"
+                            " ORDER BY prox ASC, expiration_time ASC LIMIT 1",
                             0),
     GNUNET_PQ_make_prepare ("get_closest",
-                            "(SELECT discard_time,type,value,path,key FROM gn011dc"
+                            "(SELECT expiration_time,type,ro,value,path,key FROM gn180dc"
                             " WHERE key >= $1"
-                            "   AND discard_time >= $2"
+                            "   AND expiration_time >= $2"
                             "   AND ( (type = $3) OR ( 0 = $3) )"
                             " ORDER BY key ASC"
                             " LIMIT $4)"
                             " UNION "
-                            "(SELECT discard_time,type,value,path,key FROM gn011dc"
+                            "(SELECT expiration_time,type,ro,value,path,key FROM gn180dc"
                             " WHERE key <= $1"
-                            "   AND discard_time >= $2"
+                            "   AND expiration_time >= $2"
                             "   AND ( (type = $3) OR ( 0 = $3) )"
                             " ORDER BY key DESC"
                             " LIMIT $4)",
                             4),
     GNUNET_PQ_make_prepare ("delrow",
-                            "DELETE FROM gn011dc WHERE oid=$1",
+                            "DELETE FROM gn180dc WHERE oid=$1",
                             1),
     GNUNET_PQ_make_prepare ("put",
-                            "INSERT INTO gn011dc (type, prox, discard_time, key, value, path) "
-                            "VALUES ($1, $2, $3, $4, $5, $6)",
-                            6),
+                            "INSERT INTO gn180dc"
+                            " (type, ro, prox, expiration_time, key, value, path) "
+                            "VALUES ($1, $2, $3, $4, $5, $6, $7)",
+                            7),
     GNUNET_PQ_PREPARED_STATEMENT_END
   };
 
@@ -148,38 +150,29 @@ init_connection (struct Plugin *plugin)
  * Store an item in the datastore.
  *
  * @param cls closure (our `struct Plugin`)
- * @param key key to store @a data under
  * @param prox proximity of @a key to my PID
- * @param data_size number of bytes in @a data
- * @param data data to store
- * @param type type of the value
- * @param discard_time when to discard the value in any case
- * @param path_info_len number of entries in @a path_info
- * @param path_info a path through the network
+ * @param block data to store
  * @return 0 if duplicate, -1 on error, number of bytes used otherwise
  */
 static ssize_t
 postgres_plugin_put (void *cls,
-                     const struct GNUNET_HashCode *key,
                      uint32_t prox,
-                     size_t data_size,
-                     const char *data,
-                     enum GNUNET_BLOCK_Type type,
-                     struct GNUNET_TIME_Absolute discard_time,
-                     unsigned int path_info_len,
-                     const struct GNUNET_DHT_PathElement *path_info)
+                     const struct GNUNET_DATACACHE_Block *block)
 {
   struct Plugin *plugin = cls;
-  uint32_t type32 = (uint32_t) type;
+  uint32_t type32 = (uint32_t) block->type;
+  uint32_t ro32 = (uint32_t) block->type;
   struct GNUNET_PQ_QueryParam params[] = {
     GNUNET_PQ_query_param_uint32 (&type32),
+    GNUNET_PQ_query_param_uint32 (&ro32),
     GNUNET_PQ_query_param_uint32 (&prox),
-    GNUNET_PQ_query_param_absolute_time (&discard_time),
-    GNUNET_PQ_query_param_auto_from_type (key),
-    GNUNET_PQ_query_param_fixed_size (data, data_size),
-    GNUNET_PQ_query_param_fixed_size (path_info,
-                                      path_info_len * sizeof(struct
-                                                             GNUNET_DHT_PathElement)),
+    GNUNET_PQ_query_param_absolute_time (&block->expiration_time),
+    GNUNET_PQ_query_param_auto_from_type (&block->key),
+    GNUNET_PQ_query_param_fixed_size (block->data,
+                                      block->data_size),
+    GNUNET_PQ_query_param_fixed_size (block->put_path,
+                                      block->put_path_length
+                                      * sizeof(struct GNUNET_DHT_PathElement)),
     GNUNET_PQ_query_param_end
   };
   enum GNUNET_DB_QueryStatus ret;
@@ -190,7 +183,7 @@ postgres_plugin_put (void *cls,
   if (0 > ret)
     return -1;
   plugin->num_items++;
-  return data_size + OVERHEAD;
+  return block->data_size + OVERHEAD;
 }
 
 
@@ -234,23 +227,25 @@ handle_results (void *cls,
 
   for (unsigned int i = 0; i < num_results; i++)
   {
-    struct GNUNET_TIME_Absolute expiration_time;
-    uint32_t type;
+    uint32_t type32;
+    uint32_t bro32;
     void *data;
-    size_t data_size;
-    struct GNUNET_DHT_PathElement *path;
-    size_t path_len;
+    struct GNUNET_DATACACHE_Block block;
+    void *path;
+    size_t path_size;
     struct GNUNET_PQ_ResultSpec rs[] = {
-      GNUNET_PQ_result_spec_absolute_time ("discard_time",
-                                           &expiration_time),
+      GNUNET_PQ_result_spec_absolute_time ("expiration_time",
+                                           &block.expiration_time),
       GNUNET_PQ_result_spec_uint32 ("type",
-                                    &type),
+                                    &type32),
+      GNUNET_PQ_result_spec_uint32 ("ro",
+                                    &bro32),
       GNUNET_PQ_result_spec_variable_size ("value",
                                            &data,
-                                           &data_size),
+                                           &block.data_size),
       GNUNET_PQ_result_spec_variable_size ("path",
-                                           (void **) &path,
-                                           &path_len),
+                                           &path,
+                                           &path_size),
       GNUNET_PQ_result_spec_end
     };
 
@@ -262,26 +257,27 @@ handle_results (void *cls,
       GNUNET_break (0);
       return;
     }
-    if (0 != (path_len % sizeof(struct GNUNET_DHT_PathElement)))
+    if (0 != (path_size % sizeof(struct GNUNET_DHT_PathElement)))
     {
       GNUNET_break (0);
-      path_len = 0;
+      path_size = 0;
+      path = NULL;
     }
-    path_len %= sizeof(struct GNUNET_DHT_PathElement);
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length
+      = path_size / sizeof (struct GNUNET_DHT_PathElement);
+    block.type = (enum GNUNET_BLOCK_Type) type32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    block.key = *hrc->key;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Found result of size %u bytes and type %u in database\n",
-         (unsigned int) data_size,
-         (unsigned int) type);
-    if ((NULL != hrc->iter) &&
-        (GNUNET_SYSERR ==
-         hrc->iter (hrc->iter_cls,
-                    hrc->key,
-                    data_size,
-                    data,
-                    (enum GNUNET_BLOCK_Type) type,
-                    expiration_time,
-                    path_len,
-                    path)))
+         (unsigned int) block.data_size,
+         (unsigned int) block.type);
+    if ( (NULL != hrc->iter) &&
+         (GNUNET_SYSERR ==
+          hrc->iter (hrc->iter_cls,
+                     &block)) )
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Ending iteration (client error)\n");
@@ -350,7 +346,7 @@ postgres_plugin_get (void *cls,
  * @param cls closure (our `struct Plugin`)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
-static int
+static enum GNUNET_GenericReturnValue
 postgres_plugin_del (void *cls)
 {
   struct Plugin *plugin = cls;
@@ -453,26 +449,27 @@ extract_result_cb (void *cls,
     return;
   for (unsigned int i = 0; i < num_results; i++)
   {
-    struct GNUNET_TIME_Absolute expiration_time;
-    uint32_t type;
+    uint32_t type32;
+    uint32_t bro32;
+    struct GNUNET_DATACACHE_Block block;
     void *data;
-    size_t data_size;
-    struct GNUNET_DHT_PathElement *path;
-    size_t path_len;
-    struct GNUNET_HashCode key;
+    void *path;
+    size_t path_size;
     struct GNUNET_PQ_ResultSpec rs[] = {
-      GNUNET_PQ_result_spec_absolute_time ("",
-                                           &expiration_time),
+      GNUNET_PQ_result_spec_absolute_time ("expiration_time",
+                                           &block.expiration_time),
       GNUNET_PQ_result_spec_uint32 ("type",
-                                    &type),
+                                    &type32),
+      GNUNET_PQ_result_spec_uint32 ("ro",
+                                    &bro32),
       GNUNET_PQ_result_spec_variable_size ("value",
                                            &data,
-                                           &data_size),
+                                           &block.data_size),
       GNUNET_PQ_result_spec_variable_size ("path",
-                                           (void **) &path,
-                                           &path_len),
+                                           &path,
+                                           &path_size),
       GNUNET_PQ_result_spec_auto_from_type ("key",
-                                            &key),
+                                            &block.key),
       GNUNET_PQ_result_spec_end
     };
 
@@ -484,25 +481,25 @@ extract_result_cb (void *cls,
       GNUNET_break (0);
       return;
     }
-    if (0 != (path_len % sizeof(struct GNUNET_DHT_PathElement)))
+    if (0 != (path_size % sizeof(struct GNUNET_DHT_PathElement)))
     {
       GNUNET_break (0);
-      path_len = 0;
+      path_size = 0;
+      path = NULL;
     }
-    path_len %= sizeof(struct GNUNET_DHT_PathElement);
+    block.type = (enum GNUNET_BLOCK_Type) type32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof (struct GNUNET_DHT_PathElement);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Found result of size %u bytes and type %u in database\n",
-         (unsigned int) data_size,
-         (unsigned int) type);
-    if (GNUNET_SYSERR ==
-        erc->iter (erc->iter_cls,
-                   &key,
-                   data_size,
-                   data,
-                   (enum GNUNET_BLOCK_Type) type,
-                   expiration_time,
-                   path_len,
-                   path))
+         (unsigned int) block.data_size,
+         (unsigned int) block.type);
+    if ( (NULL != erc->iter) &&
+         (GNUNET_SYSERR ==
+          erc->iter (erc->iter_cls,
+                     &block)) )
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Ending iteration (client error)\n");
diff --git a/src/datacache/plugin_datacache_sqlite.c b/src/datacache/plugin_datacache_sqlite.c
index 6f2165433..22ae5c0f5 100644
--- a/src/datacache/plugin_datacache_sqlite.c
+++ b/src/datacache/plugin_datacache_sqlite.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     Copyright (C) 2006, 2009, 2015 GNUnet e.V.
+     Copyright (C) 2006, 2009, 2015, 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
@@ -74,9 +74,19 @@ struct Plugin
   /**
    * Prepared statement for #sqlite_plugin_get.
    */
+  sqlite3_stmt *get_count_any_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
   sqlite3_stmt *get_stmt;
 
   /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
+  sqlite3_stmt *get_any_stmt;
+
+  /**
    * Prepared statement for #sqlite_plugin_del.
    */
   sqlite3_stmt *del_select_stmt;
@@ -133,9 +143,10 @@ struct Plugin
   do                                                            \
   {                                                             \
     emsg = NULL;                                                \
-    if (SQLITE_OK != sqlite3_exec (db, cmd, NULL, NULL, &emsg)) \
+    if (SQLITE_OK !=                                            \
+        sqlite3_exec (db, cmd, NULL, NULL, &emsg))              \
     {                                                           \
-      LOG (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,    \
+      LOG (GNUNET_ERROR_TYPE_ERROR,                             \
            _ ("`%s' failed at %s:%d with error: %s\n"),         \
            "sqlite3_exec",                                      \
            __FILE__,                                            \
@@ -173,67 +184,222 @@ sq_prepare (sqlite3 *dbh,
  * Store an item in the datastore.
  *
  * @param cls closure (our `struct Plugin`)
- * @param key key to store @a data under
  * @param xor_distance how close is @a key to our PID?
- * @param size number of bytes in @a data
- * @param data data to store
- * @param type type of the value
- * @param discard_time when to discard the value in any case
- * @param path_info_len number of entries in @a path_info
- * @param path_info array of peers that have processed the request
+ * @param block data to store
  * @return 0 if duplicate, -1 on error, number of bytes used otherwise
  */
 static ssize_t
 sqlite_plugin_put (void *cls,
-                   const struct GNUNET_HashCode *key,
                    uint32_t xor_distance,
-                   size_t size,
-                   const char *data,
-                   enum GNUNET_BLOCK_Type type,
-                   struct GNUNET_TIME_Absolute discard_time,
-                   unsigned int path_info_len,
-                   const struct GNUNET_DHT_PathElement *path_info)
+                   const struct GNUNET_DATACACHE_Block *block)
 {
   struct Plugin *plugin = cls;
-  uint32_t type32 = type;
-  struct GNUNET_SQ_QueryParam params[] =
-  { GNUNET_SQ_query_param_uint32 (&type32),
-    GNUNET_SQ_query_param_absolute_time (&discard_time),
-    GNUNET_SQ_query_param_auto_from_type (key),
+  uint32_t type32 = (uint32_t) block->type;
+  uint32_t ro32 = (uint32_t) block->ro;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_uint32 (&ro32),
+    GNUNET_SQ_query_param_absolute_time (&block->expiration_time),
+    GNUNET_SQ_query_param_auto_from_type (&block->key),
     GNUNET_SQ_query_param_uint32 (&xor_distance),
-    GNUNET_SQ_query_param_fixed_size (data, size),
-    GNUNET_SQ_query_param_fixed_size (path_info,
-                                      path_info_len
+    GNUNET_SQ_query_param_fixed_size (block->data,
+                                      block->data_size),
+    GNUNET_SQ_query_param_fixed_size (block->put_path,
+                                      block->put_path_length
                                       * sizeof(struct GNUNET_DHT_PathElement)),
-    GNUNET_SQ_query_param_end };
+    GNUNET_SQ_query_param_end
+  };
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing PUT of %u bytes with key `%s' and expiration %s\n",
-       (unsigned int) size,
-       GNUNET_h2s (key),
+       (unsigned int) block->data_size,
+       GNUNET_h2s (&block->key),
        GNUNET_STRINGS_relative_time_to_string (
          GNUNET_TIME_absolute_get_remaining (
-           discard_time),
+           block->expiration_time),
          GNUNET_YES));
-  if (GNUNET_OK != GNUNET_SQ_bind (plugin->insert_stmt, params))
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->insert_stmt,
+                      params))
   {
     LOG_SQLITE (plugin->dbh,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                GNUNET_ERROR_TYPE_ERROR,
                 "sqlite3_bind_xxx");
-    GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->insert_stmt);
     return -1;
   }
-  if (SQLITE_DONE != sqlite3_step (plugin->insert_stmt))
+  if (SQLITE_DONE !=
+      sqlite3_step (plugin->insert_stmt))
   {
     LOG_SQLITE (plugin->dbh,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                GNUNET_ERROR_TYPE_ERROR,
                 "sqlite3_step");
-    GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->insert_stmt);
     return -1;
   }
   plugin->num_items++;
-  GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
-  return size + OVERHEAD;
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->insert_stmt);
+  return block->data_size + OVERHEAD;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+get_any (void *cls,
+         const struct GNUNET_HashCode *key,
+         GNUNET_DATACACHE_Iterator iter,
+         void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_TIME_Absolute now;
+  unsigned int cnt;
+  uint32_t off;
+  uint32_t btype32;
+  uint32_t bro32;
+  unsigned int total;
+  struct GNUNET_DATACACHE_Block block;
+  void *path;
+  void *data;
+  size_t path_size;
+  struct GNUNET_SQ_QueryParam params_count[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam params_select[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_uint32 (&off),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_uint32 (&btype32),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_end
+  };
+
+  now = GNUNET_TIME_absolute_get ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing GET for key `%s'\n",
+       GNUNET_h2s (key));
+
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->get_count_any_stmt,
+                      params_count))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_bind_xxx");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_any_stmt);
+    return 0;
+  }
+  if (SQLITE_ROW !=
+      sqlite3_step (plugin->get_count_any_stmt))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_any_stmt);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No content found when processing GET for key `%s'\n",
+         GNUNET_h2s (key));
+    return 0;
+  }
+  total = sqlite3_column_int (plugin->get_count_any_stmt,
+                              0);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_count_any_stmt);
+  if ( (0 == total) ||
+       (NULL == iter) )
+  {
+    if (0 == total)
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "No content found when processing GET for key `%s'\n",
+           GNUNET_h2s (key));
+    return total;
+  }
+
+  cnt = 0;
+  block.key = *key;
+  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  total);
+  while (cnt < total)
+  {
+    off = (off + 1) % total;
+    if (GNUNET_OK !=
+        GNUNET_SQ_bind (plugin->get_any_stmt,
+                        params_select))
+    {
+      LOG_SQLITE (plugin->dbh,
+                  GNUNET_ERROR_TYPE_ERROR,
+                  "sqlite3_bind_xxx");
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      return cnt;
+    }
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->get_any_stmt))
+      break;
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->get_any_stmt,
+                                  rs))
+    {
+      GNUNET_break (0);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      break;
+    }
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.type = (enum GNUNET_BLOCK_Type) btype32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    cnt++;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found %u-byte result when processing GET for key `%s'\n",
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+    if (GNUNET_OK !=
+        iter (iter_cls,
+              &block))
+    {
+      GNUNET_SQ_cleanup_result (rs);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      break;
+    }
+    GNUNET_SQ_cleanup_result (rs);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_any_stmt);
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_any_stmt);
+  return cnt;
 }
 
 
@@ -249,67 +415,81 @@ sqlite_plugin_put (void *cls,
  * @return the number of results found
  */
 static unsigned int
-sqlite_plugin_get (void *cls,
-                   const struct GNUNET_HashCode *key,
-                   enum GNUNET_BLOCK_Type type,
-                   GNUNET_DATACACHE_Iterator iter,
-                   void *iter_cls)
+get_typed (void *cls,
+           const struct GNUNET_HashCode *key,
+           enum GNUNET_BLOCK_Type type,
+           GNUNET_DATACACHE_Iterator iter,
+           void *iter_cls)
 {
   struct Plugin *plugin = cls;
   uint32_t type32 = type;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_TIME_Absolute exp;
-  size_t size;
-  void *dat;
   unsigned int cnt;
   uint32_t off;
+  uint32_t bro32;
   unsigned int total;
-  size_t psize;
-  struct GNUNET_DHT_PathElement *path;
-  struct GNUNET_SQ_QueryParam params_count[] =
-  { GNUNET_SQ_query_param_auto_from_type (key),
+  struct GNUNET_DATACACHE_Block block;
+  void *path;
+  void *data;
+  size_t path_size;
+  struct GNUNET_SQ_QueryParam params_count[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_uint32 (&type32),
     GNUNET_SQ_query_param_absolute_time (&now),
-    GNUNET_SQ_query_param_end };
-  struct GNUNET_SQ_QueryParam params_select[] =
-  { GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam params_select[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_uint32 (&type32),
     GNUNET_SQ_query_param_absolute_time (&now),
     GNUNET_SQ_query_param_uint32 (&off),
-    GNUNET_SQ_query_param_end };
-  struct GNUNET_SQ_ResultSpec rs[] =
-  { GNUNET_SQ_result_spec_variable_size (&dat, &size),
-    GNUNET_SQ_result_spec_absolute_time (&exp),
-    GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize),
-    GNUNET_SQ_result_spec_end };
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_end
+  };
 
   now = GNUNET_TIME_absolute_get ();
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing GET for key `%s'\n",
        GNUNET_h2s (key));
 
-  if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_count_stmt, params_count))
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->get_count_stmt,
+                      params_count))
   {
     LOG_SQLITE (plugin->dbh,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                GNUNET_ERROR_TYPE_ERROR,
                 "sqlite3_bind_xxx");
-    GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_stmt);
     return 0;
   }
-  if (SQLITE_ROW != sqlite3_step (plugin->get_count_stmt))
+  if (SQLITE_ROW !=
+      sqlite3_step (plugin->get_count_stmt))
   {
     LOG_SQLITE (plugin->dbh,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                GNUNET_ERROR_TYPE_ERROR,
                 "sqlite_step");
-    GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_stmt);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "No content found when processing GET for key `%s'\n",
          GNUNET_h2s (key));
     return 0;
   }
-  total = sqlite3_column_int (plugin->get_count_stmt, 0);
-  GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
-  if ((0 == total) || (NULL == iter))
+  total = sqlite3_column_int (plugin->get_count_stmt,
+                              0);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_count_stmt);
+  if ( (0 == total) ||
+       (NULL == iter) )
   {
     if (0 == total)
       LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -319,129 +499,206 @@ sqlite_plugin_get (void *cls,
   }
 
   cnt = 0;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total);
+  block.key = *key;
+  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  total);
   while (cnt < total)
   {
     off = (off + 1) % total;
-    if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_stmt, params_select))
+    if (GNUNET_OK !=
+        GNUNET_SQ_bind (plugin->get_stmt,
+                        params_select))
     {
       LOG_SQLITE (plugin->dbh,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  GNUNET_ERROR_TYPE_ERROR,
                   "sqlite3_bind_xxx");
-      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
       return cnt;
     }
-    if (SQLITE_ROW != sqlite3_step (plugin->get_stmt))
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->get_stmt))
       break;
-    if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_stmt, rs))
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->get_stmt,
+                                  rs))
     {
       GNUNET_break (0);
-      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
       break;
     }
-    if (0 != psize % sizeof(struct GNUNET_DHT_PathElement))
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
     {
       GNUNET_break (0);
-      psize = 0;
+      path_size = 0;
       path = NULL;
     }
-    psize /= sizeof(struct GNUNET_DHT_PathElement);
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.type = type;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
     cnt++;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Found %u-byte result when processing GET for key `%s'\n",
-         (unsigned int) size,
-         GNUNET_h2s (key));
-    if (GNUNET_OK != iter (iter_cls, key, size, dat, type, exp, psize, path))
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+    if ( (NULL != iter) &&
+         (GNUNET_OK !=
+          iter (iter_cls,
+                &block)) )
     {
       GNUNET_SQ_cleanup_result (rs);
-      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
       break;
     }
     GNUNET_SQ_cleanup_result (rs);
-    GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_stmt);
   }
-  GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_stmt);
   return cnt;
 }
 
 
 /**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+sqlite_plugin_get (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   enum GNUNET_BLOCK_Type type,
+                   GNUNET_DATACACHE_Iterator iter,
+                   void *iter_cls)
+{
+  if (GNUNET_BLOCK_TYPE_ANY == type)
+    return get_any (cls,
+                    key,
+                    iter,
+                    iter_cls);
+  return get_typed (cls,
+                    key,
+                    type,
+                    iter,
+                    iter_cls);
+}
+
+
+/**
  * Delete the entry with the lowest expiration value
  * from the datacache right now.
  *
  * @param cls closure (our `struct Plugin`)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
-static int
+static enum GNUNET_GenericReturnValue
 sqlite_plugin_del (void *cls)
 {
   struct Plugin *plugin = cls;
   uint64_t rowid;
   void *data;
-  size_t dsize;
+  size_t data_size;
   struct GNUNET_HashCode hc;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_SQ_ResultSpec rs[] =
-  { GNUNET_SQ_result_spec_uint64 (&rowid),
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_uint64 (&rowid),
     GNUNET_SQ_result_spec_auto_from_type (&hc),
-    GNUNET_SQ_result_spec_variable_size ((void **) &data, &dsize),
-    GNUNET_SQ_result_spec_end };
-  struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 (
-                                             &rowid),
-                                           GNUNET_SQ_query_param_end };
-  struct GNUNET_SQ_QueryParam time_params[] =
-  { GNUNET_SQ_query_param_absolute_time (&now), GNUNET_SQ_query_param_end };
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing DEL\n");
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &data_size),
+    GNUNET_SQ_result_spec_end
+  };
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_uint64 (&rowid),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam time_params[] = {
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing DEL\n");
   now = GNUNET_TIME_absolute_get ();
-  if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_expired_stmt, time_params))
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->del_expired_stmt,
+                      time_params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
-    GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_expired_stmt);
     return GNUNET_SYSERR;
   }
-  if ((SQLITE_ROW != sqlite3_step (plugin->del_expired_stmt)) ||
-      (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_expired_stmt, rs)))
+  if ( (SQLITE_ROW !=
+        sqlite3_step (plugin->del_expired_stmt)) ||
+       (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->del_expired_stmt,
+                                  rs)))
   {
-    GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt);
-    if (SQLITE_ROW != sqlite3_step (plugin->del_select_stmt))
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_expired_stmt);
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->del_select_stmt))
     {
       LOG_SQLITE (plugin->dbh,
                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                   "sqlite3_step");
-      GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->del_select_stmt);
       return GNUNET_SYSERR;
     }
-    if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_select_stmt, rs))
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->del_select_stmt,
+                                  rs))
     {
-      GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->del_select_stmt);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
   }
   GNUNET_SQ_cleanup_result (rs);
-  GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
-  if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_stmt, params))
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->del_select_stmt);
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->del_stmt,
+                      params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
-    GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_stmt);
     return GNUNET_SYSERR;
   }
-  if (SQLITE_DONE != sqlite3_step (plugin->del_stmt))
+  if (SQLITE_DONE !=
+      sqlite3_step (plugin->del_stmt))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_step");
-    GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_stmt);
     return GNUNET_SYSERR;
   }
   plugin->num_items--;
-  plugin->env->delete_notify (plugin->env->cls, &hc, dsize + OVERHEAD);
-  GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
+  plugin->env->delete_notify (plugin->env->cls,
+                              &hc,
+                              data_size + OVERHEAD);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->del_stmt);
   return GNUNET_OK;
 }
 
@@ -472,14 +729,13 @@ sqlite_plugin_get_closest (void *cls,
   uint32_t type32 = type;
   uint32_t num_results32 = num_results;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_TIME_Absolute exp;
-  size_t size;
-  void *dat;
+  void *data;
+  void *path;
+  size_t path_size;
   unsigned int cnt;
-  size_t psize;
-  uint32_t rtype;
-  struct GNUNET_HashCode hc;
-  struct GNUNET_DHT_PathElement *path;
+  uint32_t bro32;
+  struct GNUNET_DATACACHE_Block block;
+  uint32_t rtype32;
   struct GNUNET_SQ_QueryParam params[] = {
     GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_absolute_time (&now),
@@ -488,11 +744,14 @@ sqlite_plugin_get_closest (void *cls,
     GNUNET_SQ_query_param_end
   };
   struct GNUNET_SQ_ResultSpec rs[] = {
-    GNUNET_SQ_result_spec_variable_size (&dat, &size),
-    GNUNET_SQ_result_spec_absolute_time (&exp),
-    GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize),
-    GNUNET_SQ_result_spec_uint32 (&rtype),
-    GNUNET_SQ_result_spec_auto_from_type (&hc),
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_uint32 (&rtype32),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_auto_from_type (&block.key),
     GNUNET_SQ_result_spec_end
   };
 
@@ -512,7 +771,8 @@ sqlite_plugin_get_closest (void *cls,
     return 0;
   }
   cnt = 0;
-  while (SQLITE_ROW == sqlite3_step (plugin->get_closest_stmt))
+  while (SQLITE_ROW ==
+         sqlite3_step (plugin->get_closest_stmt))
   {
     if (GNUNET_OK !=
         GNUNET_SQ_extract_result (plugin->get_closest_stmt,
@@ -521,26 +781,27 @@ sqlite_plugin_get_closest (void *cls,
       GNUNET_break (0);
       break;
     }
-    if (0 != psize % sizeof(struct GNUNET_DHT_PathElement))
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
     {
       GNUNET_break (0);
-      psize = 0;
+      path_size = 0;
       path = NULL;
     }
-    psize /= sizeof(struct GNUNET_DHT_PathElement);
+    block.put_path_length
+      = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.put_path = path;
+    block.data = data;
+    block.type = (enum GNUNET_BLOCK_Type) rtype32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
     cnt++;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Found %u-byte result at %s when processing GET_CLOSE\n",
-         (unsigned int) size,
-         GNUNET_h2s (&hc));
-    if (GNUNET_OK != iter (iter_cls,
-                           &hc,
-                           size,
-                           dat,
-                           rtype,
-                           exp,
-                           psize,
-                           path))
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+
+    if (GNUNET_OK !=
+        iter (iter_cls,
+              &block))
     {
       GNUNET_SQ_cleanup_result (rs);
       break;
@@ -570,25 +831,30 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   sqlite3 *dbh;
   char *emsg;
 
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                                          "datacache-sqlite",
-                                                          "IN_MEMORY"))
+  if (GNUNET_YES ==
+      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                            "datacache-sqlite",
+                                            "IN_MEMORY"))
   {
-    if (SQLITE_OK != sqlite3_open (":memory:", &dbh))
+    if (SQLITE_OK !=
+        sqlite3_open (":memory:",
+                      &dbh))
       return NULL;
     fn_utf8 = NULL;
   }
   else
   {
     fn = GNUNET_DISK_mktemp ("gnunet-datacache");
-    if (fn == NULL)
+    if (NULL == fn)
     {
       GNUNET_break (0);
       return NULL;
     }
     /* fn should be UTF-8-encoded. If it isn't, it's a bug. */
     fn_utf8 = GNUNET_strdup (fn);
-    if (SQLITE_OK != sqlite3_open (fn_utf8, &dbh))
+    if (SQLITE_OK !=
+        sqlite3_open (fn_utf8,
+                      &dbh))
     {
       GNUNET_free (fn);
       GNUNET_free (fn_utf8);
@@ -602,22 +868,30 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   SQLITE3_EXEC (dbh, "PRAGMA journal_mode=OFF");
   SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF");
   SQLITE3_EXEC (dbh, "PRAGMA page_size=4092");
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                                          "datacache-sqlite",
-                                                          "IN_MEMORY"))
+  if (GNUNET_YES ==
+      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                            "datacache-sqlite",
+                                            "IN_MEMORY"))
     SQLITE3_EXEC (dbh, "PRAGMA sqlite_temp_store=3");
 
   SQLITE3_EXEC (dbh,
-                "CREATE TABLE ds091 ("
+                "CREATE TABLE ds180 ("
                 "  type INTEGER NOT NULL DEFAULT 0,"
+                "  ro INTEGER NOT NULL DEFAULT 0,"
                 "  expire INTEGER NOT NULL,"
                 "  key BLOB NOT NULL DEFAULT '',"
                 "  prox INTEGER NOT NULL,"
                 "  value BLOB NOT NULL,"
                 "  path BLOB DEFAULT '')");
-  SQLITE3_EXEC (dbh, "CREATE INDEX idx_hashidx ON ds091 (key,type,expire)");
-  SQLITE3_EXEC (dbh, "CREATE INDEX idx_prox_expire ON ds091 (prox,expire)");
-  SQLITE3_EXEC (dbh, "CREATE INDEX idx_expire_only ON ds091 (expire)");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_hashidx"
+                " ON ds180 (key,type,expire)");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_prox_expire"
+                " ON ds180 (prox,expire)");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_expire_only"
+                " ON ds180 (expire)");
   plugin = GNUNET_new (struct Plugin);
   plugin->env = env;
   plugin->dbh = dbh;
@@ -625,41 +899,67 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
 
   if ((SQLITE_OK !=
        sq_prepare (plugin->dbh,
-                   "INSERT INTO ds091 (type, expire, key, prox, value, path) "
-                   "VALUES (?, ?, ?, ?, ?, ?)",
+                   "INSERT INTO ds180"
+                   " (type, ro, expire, key, prox, value, path)"
+                   " VALUES (?, ?, ?, ?, ?, ?, ?)",
                    &plugin->insert_stmt)) ||
-      (SQLITE_OK != sq_prepare (plugin->dbh,
-                                "SELECT count(*) FROM ds091 "
-                                "WHERE key=? AND type=? AND expire >= ?",
-                                &plugin->get_count_stmt)) ||
       (SQLITE_OK !=
        sq_prepare (plugin->dbh,
-                   "SELECT value,expire,path FROM ds091"
-                   " WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET ?",
+                   "SELECT COUNT(*) FROM ds180 "
+                   "WHERE key=?"
+                   " AND type=?"
+                   " AND expire >= ?",
+                   &plugin->get_count_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT COUNT(*) FROM ds180 "
+                   "WHERE key=? AND expire >= ?",
+                   &plugin->get_count_any_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path,ro"
+                   " FROM ds180"
+                   " WHERE key=?"
+                   " AND type=?"
+                   " AND expire >= ?"
+                   " LIMIT 1 OFFSET ?",
                    &plugin->get_stmt)) ||
-      (SQLITE_OK != sq_prepare (plugin->dbh,
-                                "SELECT _ROWID_,key,value FROM ds091"
-                                " WHERE expire < ?1"
-                                " ORDER BY expire ASC LIMIT 1",
-                                &plugin->del_expired_stmt)) ||
-      (SQLITE_OK != sq_prepare (plugin->dbh,
-                                "SELECT _ROWID_,key,value FROM ds091"
-                                " ORDER BY prox ASC, expire ASC LIMIT 1",
-                                &plugin->del_select_stmt)) ||
-      (SQLITE_OK != sq_prepare (plugin->dbh,
-                                "DELETE FROM ds091 WHERE _ROWID_=?",
-                                &plugin->del_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path,type,ro"
+                   " FROM ds180"
+                   " WHERE key=?"
+                   " AND expire >= ?"
+                   " LIMIT 1 OFFSET ?",
+                   &plugin->get_any_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT _ROWID_,key,value FROM ds180"
+                   " WHERE expire < ?1"
+                   " ORDER BY expire ASC LIMIT 1",
+                   &plugin->del_expired_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT _ROWID_,key,value FROM ds180"
+                   " ORDER BY prox ASC, expire ASC LIMIT 1",
+                   &plugin->del_select_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "DELETE FROM ds180 WHERE _ROWID_=?",
+                   &plugin->del_stmt)) ||
       (SQLITE_OK !=
        sq_prepare (plugin->dbh,
                    "SELECT * FROM ("
-                   " SELECT value,expire,path,type,key FROM ds091 "
+                   " SELECT value,expire,path,type,ro,key"
+                   " FROM ds180 "
                    " WHERE key>=?1 "
                    "  AND expire >= ?2"
                    "  AND ( (type=?3) or (0 == ?3) )"
                    " ORDER BY KEY ASC LIMIT ?4)"
                    "UNION "
                    "SELECT * FROM ("
-                   " SELECT value,expire,path,type,key FROM ds091 "
+                   " SELECT value,expire,path,type,ro,key"
+                   " FROM ds180 "
                    " WHERE key<=?1 "
                    "  AND expire >= ?2"
                    "  AND ( (type=?3) or (0 == ?3) )"
@@ -669,7 +969,8 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sq_prepare");
-    GNUNET_break (SQLITE_OK == sqlite3_close (plugin->dbh));
+    GNUNET_break (SQLITE_OK ==
+                  sqlite3_close (plugin->dbh));
     GNUNET_free (plugin);
     return NULL;
   }
@@ -680,7 +981,8 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   api->put = &sqlite_plugin_put;
   api->del = &sqlite_plugin_del;
   api->get_closest = &sqlite_plugin_get_closest;
-  LOG (GNUNET_ERROR_TYPE_INFO, "Sqlite datacache running\n");
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Sqlite datacache running\n");
   return api;
 }
 
@@ -703,13 +1005,18 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
 #endif
 
 #if ! WINDOWS || defined(__CYGWIN__)
-  if ((NULL != plugin->fn) && (0 != unlink (plugin->fn)))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn);
+  if ( (NULL != plugin->fn) &&
+       (0 != unlink (plugin->fn)) )
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
+                       "unlink",
+                       plugin->fn);
   GNUNET_free (plugin->fn);
 #endif
   sqlite3_finalize (plugin->insert_stmt);
   sqlite3_finalize (plugin->get_count_stmt);
+  sqlite3_finalize (plugin->get_count_any_stmt);
   sqlite3_finalize (plugin->get_stmt);
+  sqlite3_finalize (plugin->get_any_stmt);
   sqlite3_finalize (plugin->del_select_stmt);
   sqlite3_finalize (plugin->del_expired_stmt);
   sqlite3_finalize (plugin->del_stmt);
@@ -721,7 +1028,8 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _ (
            "Tried to close sqlite without finalizing all prepared statements.\n"));
-    stmt = sqlite3_next_stmt (plugin->dbh, NULL);
+    stmt = sqlite3_next_stmt (plugin->dbh,
+                              NULL);
     while (NULL != stmt)
     {
       result = sqlite3_finalize (stmt);
@@ -730,13 +1038,16 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
              "Failed to close statement %p: %d\n",
              stmt,
              result);
-      stmt = sqlite3_next_stmt (plugin->dbh, NULL);
+      stmt = sqlite3_next_stmt (plugin->dbh,
+                                NULL);
     }
     result = sqlite3_close (plugin->dbh);
   }
 #endif
   if (SQLITE_OK != result)
-    LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_close");
 
   GNUNET_free (plugin);
   GNUNET_free (api);
diff --git a/src/datacache/plugin_datacache_template.c b/src/datacache/plugin_datacache_template.c
index 2f7b41dbe..1bd712d39 100644
--- a/src/datacache/plugin_datacache_template.c
+++ b/src/datacache/plugin_datacache_template.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     Copyright (C) 2006, 2009, 2015 GNUnet e.V.
+     Copyright (C) 2006, 2009, 2015, 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
@@ -44,26 +44,14 @@ struct Plugin
  * Store an item in the datastore.
  *
  * @param cls closure (our `struct Plugin`)
- * @param key key to store @a data under
  * @param xor_distance distance of @a key to our PID
- * @param size number of bytes in @a data
- * @param data data to store
- * @param type type of the value
- * @param discard_time when to discard the value in any case
- * @param path_info_len number of entries in @a path_info
- * @param path_info a path through the network
+ * @param block data to store
  * @return 0 if duplicate, -1 on error, number of bytes used otherwise
  */
 static ssize_t
 template_plugin_put (void *cls,
-                     const struct GNUNET_HashCode *key,
                      uint32_t xor_distance,
-                     size_t size,
-                     const char *data,
-                     enum GNUNET_BLOCK_Type type,
-                     struct GNUNET_TIME_Absolute discard_time,
-                     unsigned int path_info_len,
-                     const struct GNUNET_DHT_PathElement *path_info)
+                     const struct GNUNET_DATACACHE_Block *block)
 {
   GNUNET_break (0);
   return -1;
@@ -100,7 +88,7 @@ template_plugin_get (void *cls,
  * @param cls closure (our `struct Plugin`)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
-static int
+static enum GNUNET_GenericReturnValue
 template_plugin_del (void *cls)
 {
   GNUNET_break (0);
diff --git a/src/datacache/test_datacache.c b/src/datacache/test_datacache.c
index 5740d2b7d..b5d978995 100644
--- a/src/datacache/test_datacache.c
+++ b/src/datacache/test_datacache.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2006, 2009, 2010 GNUnet e.V.
+     Copyright (C) 2006, 2009, 2010, 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
@@ -39,26 +39,18 @@ static int ok;
 static const char *plugin_name;
 
 
-static int
+static enum GNUNET_GenericReturnValue
 checkIt (void *cls,
-         const struct GNUNET_HashCode *key,
-         size_t size, const char *data,
-         enum GNUNET_BLOCK_Type type,
-         struct GNUNET_TIME_Absolute exp,
-         unsigned int path_len,
-         const struct GNUNET_DHT_PathElement *path)
+         const struct GNUNET_DATACACHE_Block *block)
 {
-  (void) key;
-  (void) type;
-  (void) exp;
-  (void) path_len;
-  (void) path;
-  if (size != sizeof(struct GNUNET_HashCode))
+  if (block->data_size != sizeof(struct GNUNET_HashCode))
   {
     GNUNET_break (0);
     ok = 2;
   }
-  if (0 != memcmp (data, cls, size))
+  if (0 != memcmp (block->data,
+                   cls,
+                   block->data_size))
   {
     GNUNET_break (0);
     ok = 3;
@@ -74,9 +66,9 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DATACACHE_Handle *h;
+  struct GNUNET_DATACACHE_Block block;
   struct GNUNET_HashCode k;
   struct GNUNET_HashCode n;
-  struct GNUNET_TIME_Absolute exp;
 
   (void) cls;
   (void) args;
@@ -84,7 +76,7 @@ run (void *cls,
   ok = 0;
   h = GNUNET_DATACACHE_create (cfg,
                                "testcache");
-  if (h == NULL)
+  if (NULL == h)
   {
     fprintf (stderr,
              "%s",
@@ -92,19 +84,28 @@ run (void *cls,
     ok = 77;   /* mark test as skipped */
     return;
   }
-  exp = GNUNET_TIME_absolute_get ();
-  exp.abs_value_us += 5 * 60 * 1000 * 1000LL;
-  memset (&k, 0, sizeof(struct GNUNET_HashCode));
+  block.expiration_time = GNUNET_TIME_absolute_get ();
+  block.expiration_time.abs_value_us += 5 * 60 * 1000 * 1000LL;
+  memset (&k,
+          0,
+          sizeof(struct GNUNET_HashCode));
   for (unsigned int i = 0; i < 100; i++)
   {
-    GNUNET_CRYPTO_hash (&k, sizeof(struct GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k,
+                        sizeof(struct GNUNET_HashCode),
+                        &n);
+    block.key = k;
+    block.data = &n;
+    block.data_size = sizeof (n);
+    block.ro = 42;
+    block.type = (enum GNUNET_BLOCK_Type) (1 + i % 16);
+    block.put_path = NULL;
+    block.put_path_length = 0;
+    block.ro = GNUNET_DHT_RO_RECORD_ROUTE;
     ASSERT (GNUNET_OK ==
             GNUNET_DATACACHE_put (h,
-                                  &k,
-                                  GNUNET_YES,
-                                  sizeof(struct GNUNET_HashCode),
-                                  (const char *) &n, 1 + i % 16, exp,
-                                  0, NULL));
+                                  42,
+                                  &block));
     k = n;
   }
   memset (&k,
@@ -117,7 +118,7 @@ run (void *cls,
                         &n);
     ASSERT (1 == GNUNET_DATACACHE_get (h,
                                        &k,
-                                       1 + i % 16,
+                                       (enum GNUNET_BLOCK_Type) (1 + i % 16),
                                        &checkIt,
                                        &n));
     k = n;
@@ -129,16 +130,19 @@ run (void *cls,
   GNUNET_CRYPTO_hash (&k,
                       sizeof(struct GNUNET_HashCode),
                       &n);
+  block.key = k;
+  block.data = &n;
+  block.data_size = sizeof (n);
+  block.ro = 42;
+  block.type = (enum GNUNET_BLOCK_Type) 792;
+  block.put_path = NULL;
+  block.put_path_length = 0;
+  block.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS;
+  block.ro = GNUNET_DHT_RO_RECORD_ROUTE;
   ASSERT (GNUNET_OK ==
           GNUNET_DATACACHE_put (h,
-                                &k,
-                                GNUNET_YES,
-                                sizeof(struct GNUNET_HashCode),
-                                (const char *) &n,
-                                792,
-                                GNUNET_TIME_UNIT_FOREVER_ABS,
-                                0,
-                                NULL));
+                                42,
+                                &block));
   ASSERT (0 != GNUNET_DATACACHE_get (h,
                                      &k,
                                      792,
diff --git a/src/datacache/test_datacache_quota.c b/src/datacache/test_datacache_quota.c
index 92807fbe2..0b647ee99 100644
--- a/src/datacache/test_datacache_quota.c
+++ b/src/datacache/test_datacache_quota.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2006, 2009, 2010 GNUnet e.V.
+     Copyright (C) 2006, 2009, 2010, 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
@@ -53,8 +53,8 @@ run (void *cls,
   struct GNUNET_DATACACHE_Handle *h;
   struct GNUNET_HashCode k;
   struct GNUNET_HashCode n;
+  struct GNUNET_DATACACHE_Block block;
   char buf[3200];
-  struct GNUNET_TIME_Absolute exp;
 
   (void) cls;
   (void) args;
@@ -70,9 +70,14 @@ run (void *cls,
              "Failed to initialize datacache.  Database likely not setup, skipping test.\n");
     return;
   }
-  exp = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
-  memset (buf, 1, sizeof(buf));
-  memset (&k, 0, sizeof(struct GNUNET_HashCode));
+  block.expiration_time = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_UNIT_HOURS);
+  memset (buf,
+          1,
+          sizeof(buf));
+  memset (&k,
+          0,
+          sizeof(struct GNUNET_HashCode));
   for (unsigned int i = 0; i < 10; i++)
   {
     fprintf (stderr,
@@ -83,35 +88,56 @@ run (void *cls,
                         &n);
     for (unsigned int j = i; j < sizeof(buf); j += 10)
     {
-      exp.abs_value_us++;
       buf[j] = i;
+      block.key = k;
+      block.data = buf;
+      block.data_size = j;
+      block.ro = 42;
+      block.type = (enum GNUNET_BLOCK_Type) (1 + i);
+      block.put_path = NULL;
+      block.put_path_length = 0;
+      block.ro = GNUNET_DHT_RO_RECORD_ROUTE;
+      block.expiration_time.abs_value_us++;
       ASSERT (GNUNET_OK ==
               GNUNET_DATACACHE_put (h,
-                                    &k,
-                                    GNUNET_YES,
-                                    j,
-                                    buf,
-                                    1 + i,
-                                    exp,
-                                    0,
-                                    NULL));
-      ASSERT (0 < GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
+                                    42,
+                                    &block));
+      ASSERT (0 < GNUNET_DATACACHE_get (h,
+                                        &k,
+                                        1 + i,
+                                        NULL,
+                                        NULL));
     }
     k = n;
   }
   fprintf (stderr, "%s", "\n");
-  memset (&k, 0, sizeof(struct GNUNET_HashCode));
+  memset (&k,
+          0,
+          sizeof(struct GNUNET_HashCode));
   for (unsigned int i = 0; i < 10; i++)
   {
     fprintf (stderr, "%s", ".");
-    GNUNET_CRYPTO_hash (&k, sizeof(struct GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k,
+                        sizeof(struct GNUNET_HashCode),
+                        &n);
     if (i < 2)
-      ASSERT (0 == GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
+      ASSERT (0 ==
+              GNUNET_DATACACHE_get (h,
+                                    &k,
+                                    1 + i,
+                                    NULL,
+                                    NULL));
     if (i == 9)
-      ASSERT (0 < GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
+      ASSERT (0 < GNUNET_DATACACHE_get (h,
+                                        &k,
+                                        1 + i,
+                                        NULL,
+                                        NULL));
     k = n;
   }
-  fprintf (stderr, "%s", "\n");
+  fprintf (stderr,
+           "%s",
+           "\n");
   GNUNET_DATACACHE_destroy (h);
   return;
 FAILURE: