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 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 42

static struct GNUNET_DATACACHE_Handle *datacache;


void
GDS_DATACACHE_handle_put(struct GNUNET_TIME_Absolute expiration,
                         const struct GNUNET_HashCode *key,
                         unsigned int put_path_length,
                         const struct GNUNET_PeerIdentity *put_path,
                         enum GNUNET_BLOCK_Type type,
                         size_t data_size,
                         const void *data)
{
  int r;

  if (NULL == datacache)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 _("%s request received, but have no datacache!\n"), "PUT");
      return;
    }
  if (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,
                           gettext_noop("# ITEMS stored in datacache"),
                           1,
                           GNUNET_NO);
  r = GNUNET_DATACACHE_put(datacache,
                           key,
                           GNUNET_CRYPTO_hash_matching_bits(key,
                                                            &my_identity_hash),
                           data_size,
                           data,
                           type,
                           expiration,
                           put_path_length,
                           put_path);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "DATACACHE PUT for key %s [%u] completed (%d) after %u hops\n",
      GNUNET_h2s(key),
      data_size,
      r,
      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_EvaluationResult eval;
};


static int
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_PeerIdentity *put_path)
{
  static char non_null;
  struct GetRequestContext *ctx = cls;
  enum GNUNET_BLOCK_EvaluationResult eval;

  if (0 == GNUNET_TIME_absolute_get_remaining(exp).rel_value_us)
    {
      GNUNET_break(0); /* why does datacache return expired values? */
      return GNUNET_OK; /* skip expired record */
    }
  if ((NULL == data) &&
      (0 == data_size))
    data = &non_null; /* point anywhere, but not to NULL */

  eval
    = GNUNET_BLOCK_evaluate(GDS_block_context,
                            type,
                            ctx->bg,
                            GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO,
                            key,
                            ctx->xquery,
                            ctx->xquery_size,
                            data,
                            data_size);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Found reply for query %s in datacache, evaluation result is %d\n",
      GNUNET_h2s(key),
      (int)eval);
  ctx->eval = eval;
  switch (eval)
    {
    case GNUNET_BLOCK_EVALUATION_OK_MORE:
    case GNUNET_BLOCK_EVALUATION_OK_LAST:
      /* forward to local clients */
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop
                                 ("# Good RESULTS found in datacache"), 1,
                               GNUNET_NO);
      ctx->gc(ctx->gc_cls,
              type,
              exp,
              key,
              put_path_length, put_path,
              0, NULL,
              data, data_size);
      break;

    case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Duplicate RESULTS found in datacache"),
                               1,
                               GNUNET_NO);
      break;

    case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Invalid RESULTS found in datacache"),
                               1,
                               GNUNET_NO);
      break;

    case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Irrelevant RESULTS found in datacache"),
                               1,
                               GNUNET_NO);
      break;

    case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
      GNUNET_break(0);
      break;

    case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
      GNUNET_break_op(0);
      return GNUNET_SYSERR;

    case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Unsupported RESULTS found in datacache"),
                               1,
                               GNUNET_NO);
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 _("Unsupported block type (%u) in local response!\n"),
                 type);
      break;
    }
  return (eval == GNUNET_BLOCK_EVALUATION_OK_LAST) ? GNUNET_NO : GNUNET_OK;
}


enum GNUNET_BLOCK_EvaluationResult
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;
  unsigned int r;

  if (NULL == datacache)
    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# GET requests given to datacache"),
                           1,
                           GNUNET_NO);
  ctx.eval = GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
  ctx.key = *key;
  ctx.xquery = xquery;
  ctx.xquery_size = xquery_size;
  ctx.bg = bg;
  ctx.gc = gc;
  ctx.gc_cls = gc_cls;
  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;
}


static int
datacache_random_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 path_info_len,
                          const struct GNUNET_PeerIdentity *path_info)
{
  struct GNUNET_HashCode *dest = cls;

  *dest = *key;
  return GNUNET_OK; /* should actually not matter which we return */
}


int
GDS_DATACACHE_get_random_key(struct GNUNET_HashCode *key)
{
  if (0 ==
      GNUNET_DATACACHE_get_random(datacache,
                                  &datacache_random_iterator,
                                  key))
    {
      /* randomize key in this case */
      GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_NONCE,
                                       key);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}


struct SuccContext {
  GDS_DATACACHE_SuccessorCallback cb;

  void *cb_cls;
};


static int
datacache_get_successors_iterator(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 put_path_length,
                                  const struct GNUNET_PeerIdentity *put_path)
{
  const struct SuccContext *sc = cls;

  /* NOTE: The datacache currently does not store the RO from
     the original 'put', so we don't know the 'correct' option
     at this point anymore.  Thus, we conservatively assume
     that recording is desired (for now). */
  sc->cb(sc->cb_cls,
         GNUNET_DHT_RO_RECORD_ROUTE,
         key,
         type,
         put_path_length, put_path,
         exp,
         data,
         size);
  return GNUNET_OK;
}


void
GDS_DATACACHE_get_successors(const struct GNUNET_HashCode *key,
                             GDS_DATACACHE_SuccessorCallback cb,
                             void *cb_cls)
{
  struct SuccContext sc;

  sc.cb = cb;
  sc.cb_cls = cb_cls;
  (void)GNUNET_DATACACHE_get_closest(datacache,
                                     key,
                                     NUM_CLOSEST,
                                     &datacache_get_successors_iterator,
                                     &sc);
}


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 */