gnunet-service-dht_datacache.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2009, 2010, 2011, 2015, 2017, 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
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
#include "platform.h"
#include "gnunet_datacache_lib.h"
#include "gnunet-service-dht_datacache.h"
#include "gnunet-service-dht_neighbours.h"
#include "gnunet-service-dht_routing.h"
#include "gnunet-service-dht.h"
 
#define LOG(kind, ...) GNUNET_log_from (kind, "dht-dhtcache", __VA_ARGS__)
 
#define NUM_CLOSEST 4
 
 
static struct GNUNET_DATACACHE_Handle *datacache;
 
 
void
GDS_DATACACHE_handle_put (const struct GDS_DATACACHE_BlockData *bd)
{
  struct GNUNET_HashCode xor;
  enum GNUNET_GenericReturnValue r;
 
  if (NULL == datacache)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "PUT request received, but have no datacache!\n");
    return;
  }
  if (bd->data_size >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return;
  }
  /* Put size is actual data size plus struct overhead plus path length (if any) */
  GNUNET_STATISTICS_update (GDS_stats,
                            "# ITEMS stored in datacache",
                            1,
                            GNUNET_NO);
  GNUNET_CRYPTO_hash_xor (&bd->key,
                          &GDS_my_identity_hash,
                          &xor);
  r = GNUNET_DATACACHE_put (datacache,
                            &bd->key,
                            GNUNET_CRYPTO_hash_count_leading_zeros (&xor),
                            bd->data_size,
                            bd->data,
                            bd->type,
                            bd->expiration_time,
                            bd->put_path_length,
                            bd->put_path);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "DATACACHE PUT for key %s [%lu] completed (%d) after %u hops\n",
       GNUNET_h2s (&bd->key),
       (unsigned long) bd->data_size,
       r,
       bd->put_path_length);
}
 
 
struct GetRequestContext
{
  const void *xquery;
 
  struct GNUNET_HashCode key;
 
  struct GNUNET_BLOCK_Group *bg;
 
  GDS_DATACACHE_GetCallback gc;
 
  void *gc_cls;
 
  size_t xquery_size;
 
  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
};
 
 
static enum GNUNET_GenericReturnValue
datacache_get_iterator (void *cls,
                        const struct GNUNET_HashCode *key,
                        size_t data_size,
                        const char *data,
                        enum GNUNET_BLOCK_Type type,
                        struct GNUNET_TIME_Absolute exp,
                        unsigned int put_path_length,
                        const struct GNUNET_DHT_PathElement *put_path)
{
  struct GetRequestContext *ctx = cls;
  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
  struct GDS_DATACACHE_BlockData bd = {
    .key = *key,
    .expiration_time = exp,
    .put_path = put_path,
    .data = data,
    .data_size = data_size,
    .put_path_length = put_path_length,
    .type = type
  };
 
  if (GNUNET_TIME_absolute_is_past (exp))
  {
    GNUNET_break (0);  /* why does datacache return expired values? */
    return GNUNET_OK;   /* skip expired record */
  }
  eval
    = GNUNET_BLOCK_check_reply (GDS_block_context,
                                bd.type,
                                ctx->bg,
                                &bd.key,
                                ctx->xquery,
                                ctx->xquery_size,
                                bd.data,
                                bd.data_size);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Evaluated reply for query %s in datacache, result is %d\n",
       GNUNET_h2s (key),
       (int) eval);
  ctx->eval = eval;
  switch (eval)
  {
  case GNUNET_BLOCK_REPLY_OK_MORE:
  case GNUNET_BLOCK_REPLY_OK_LAST:
  case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
    /* forward to initiator */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Good RESULTS found in datacache",
                              1,
                              GNUNET_NO);
    ctx->gc (ctx->gc_cls,
             &bd);
    break;
  case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Duplicate RESULTS found in datacache",
                              1,
                              GNUNET_NO);
    break;
  case GNUNET_BLOCK_REPLY_IRRELEVANT:
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Irrelevant RESULTS found in datacache",
                              1,
                              GNUNET_NO);
    break;
  }
  return (eval == GNUNET_BLOCK_REPLY_OK_LAST) ? GNUNET_NO : GNUNET_OK;
}
 
 
enum GNUNET_BLOCK_ReplyEvaluationResult
GDS_DATACACHE_handle_get (const struct GNUNET_HashCode *key,
                          enum GNUNET_BLOCK_Type type,
                          const void *xquery,
                          size_t xquery_size,
                          struct GNUNET_BLOCK_Group *bg,
                          GDS_DATACACHE_GetCallback gc,
                          void *gc_cls)
{
  struct GetRequestContext ctx = {
                                  .eval = GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
    .key = *key,
    .xquery = xquery,
    .xquery_size = xquery_size,
    .bg = bg,
    .gc = gc,
    .gc_cls = gc_cls
  };
  unsigned int r;
 
  if (NULL == datacache)
    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests given to datacache",
                            1,
                            GNUNET_NO);
  r = GNUNET_DATACACHE_get (datacache,
                            key,
                            type,
                            &datacache_get_iterator,
                            &ctx);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "DATACACHE GET for key %s completed (%d). %u results found.\n",
       GNUNET_h2s (key),
       ctx.eval,
       r);
  return ctx.eval;
}
 
 
enum GNUNET_BLOCK_ReplyEvaluationResult
GDS_DATACACHE_get_closest (const struct GNUNET_HashCode *key,
                           enum GNUNET_BLOCK_Type type,
                           const void *xquery,
                           size_t xquery_size,
                           struct GNUNET_BLOCK_Group *bg,
                           GDS_DATACACHE_GetCallback cb,
                           void *cb_cls)
{
  struct GetRequestContext ctx = {
                                  .eval = GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
    .key = *key,
    .xquery = xquery,
    .xquery_size = xquery_size,
    .bg = bg,
    .gc = cb,
    .gc_cls = cb_cls
  };
  unsigned int r;
 
  if (NULL == datacache)
    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET closest requests given to datacache",
                            1,
                            GNUNET_NO);
  r = GNUNET_DATACACHE_get_closest (datacache,
                                    key,
                                    type,
                                    NUM_CLOSEST,
                                    &datacache_get_iterator,
                                    &ctx);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "DATACACHE approximate GET for key %s completed (%d). %u results found.\n",
       GNUNET_h2s (key),
       ctx.eval,
       r);
  return ctx.eval;
}
 
 
void
GDS_DATACACHE_init ()
{
  datacache = GNUNET_DATACACHE_create (GDS_cfg,
                                       "dhtcache");
}
 
 
void
GDS_DATACACHE_done ()
{
  if (NULL != datacache)
  {
    GNUNET_DATACACHE_destroy (datacache);
    datacache = NULL;
  }
}
 
 
/* end of gnunet-service-dht_datacache.c */