gnunet-datastore.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2010, 2013 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 <inttypes.h>
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_datastore_service.h"

GNUNET_NETWORK_STRUCT_BEGIN

struct DataRecord {
  uint32_t size GNUNET_PACKED;

  uint32_t type GNUNET_PACKED;

  uint32_t priority GNUNET_PACKED;

  uint32_t anonymity GNUNET_PACKED;

  uint32_t replication GNUNET_PACKED;

  struct GNUNET_TIME_AbsoluteNBO expiration;

  struct GNUNET_HashCode key;
};
GNUNET_NETWORK_STRUCT_END


static const size_t MAGIC_LEN = 16;

static const uint8_t MAGIC_BYTES[16] = "GNUNETDATASTORE1";

static int dump;

static int insert;

static char *file_name;

static struct GNUNET_DISK_FileHandle *file_handle;

static int ret;

static struct GNUNET_DATASTORE_Handle *datastore;

static struct GNUNET_DATASTORE_QueueEntry *qe;

static uint64_t record_count;


static void
do_shutdown(void *cls)
{
  if (NULL != qe)
    GNUNET_DATASTORE_cancel(qe);
  if (NULL != datastore)
    GNUNET_DATASTORE_disconnect(datastore, GNUNET_NO);
  if (NULL != file_handle)
    GNUNET_DISK_file_close(file_handle);
}


static void
start_dump(void);


static void
start_insert(void);


static void
do_get(const uint64_t next_uid);


static void
get_cb(void *cls,
       const struct GNUNET_HashCode *key,
       size_t size,
       const void *data,
       enum GNUNET_BLOCK_Type type,
       uint32_t priority,
       uint32_t anonymity,
       uint32_t replication,
       struct GNUNET_TIME_Absolute expiration,
       uint64_t uid)
{
  qe = NULL;
  if (NULL == key)
    {
      fprintf(stderr, _("Dumped %" PRIu64 " records\n"), record_count);
      GNUNET_DISK_file_close(file_handle);
      file_handle = NULL;
      if (insert)
        start_insert();
      else
        {
          ret = 0;
          GNUNET_SCHEDULER_shutdown();
        }
      return;
    }

  struct DataRecord dr;
  dr.size = htonl((uint32_t)size);
  dr.type = htonl(type);
  dr.priority = htonl(priority);
  dr.anonymity = htonl(anonymity);
  dr.replication = htonl(replication);
  dr.expiration = GNUNET_TIME_absolute_hton(expiration);
  dr.key = *key;

  ssize_t len;
  len = GNUNET_DISK_file_write(file_handle, &dr, sizeof(dr));
  if (sizeof(dr) != len)
    {
      fprintf(stderr,
              _("Short write to file: %zd bytes expecting %zd\n"),
              len,
              sizeof(dr));
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }

  len = GNUNET_DISK_file_write(file_handle, data, size);
  if (size != len)
    {
      fprintf(stderr,
              _("Short write to file: %zd bytes expecting %zd\n"),
              len,
              size);
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }

  record_count++;
  do_get(uid + 1);
}


static void
do_get(const uint64_t next_uid)
{
  GNUNET_assert(NULL == qe);
  qe = GNUNET_DATASTORE_get_key(datastore,
                                next_uid,
                                false /* random */,
                                NULL /* key */,
                                GNUNET_BLOCK_TYPE_ANY,
                                0 /* queue_priority */,
                                1 /* max_queue_size */,
                                &get_cb,
                                NULL /* proc_cls */);
  if (NULL == qe)
    {
      fprintf(stderr, _("Error queueing datastore GET operation\n"));
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
    }
}


static void
start_dump()
{
  record_count = 0;

  if (NULL != file_name)
    {
      file_handle = GNUNET_DISK_file_open(file_name,
                                          GNUNET_DISK_OPEN_WRITE |
                                          GNUNET_DISK_OPEN_TRUNCATE |
                                          GNUNET_DISK_OPEN_CREATE,
                                          GNUNET_DISK_PERM_USER_READ |
                                          GNUNET_DISK_PERM_USER_WRITE);
      if (NULL == file_handle)
        {
          fprintf(stderr, _("Unable to open dump file: %s\n"), file_name);
          ret = 1;
          GNUNET_SCHEDULER_shutdown();
          return;
        }
    }
  else
    {
      file_handle = GNUNET_DISK_get_handle_from_int_fd(STDOUT_FILENO);
    }
  GNUNET_DISK_file_write(file_handle, MAGIC_BYTES, MAGIC_LEN);
  do_get(0);
}


static void
put_cb(void *cls,
       int32_t success,
       struct GNUNET_TIME_Absolute min_expiration,
       const char *msg)
{
  qe = NULL;
  if (GNUNET_SYSERR == success)
    {
      fprintf(stderr, _("Failed to store item: %s, aborting\n"), msg);
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }

  struct DataRecord dr;
  ssize_t len;

  len = GNUNET_DISK_file_read(file_handle, &dr, sizeof(dr));
  if (0 == len)
    {
      fprintf(stderr, _("Inserted %" PRIu64 " records\n"), record_count);
      ret = 0;
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  else if (sizeof(dr) != len)
    {
      fprintf(stderr,
              _("Short read from file: %zd bytes expecting %zd\n"),
              len,
              sizeof(dr));
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }

  const size_t size = ntohl(dr.size);
  uint8_t data[size];
  len = GNUNET_DISK_file_read(file_handle, data, size);
  if (size != len)
    {
      fprintf(stderr,
              _("Short read from file: %zd bytes expecting %zd\n"),
              len,
              size);
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }

  record_count++;
  qe = GNUNET_DATASTORE_put(datastore,
                            0,
                            &dr.key,
                            size,
                            data,
                            ntohl(dr.type),
                            ntohl(dr.priority),
                            ntohl(dr.anonymity),
                            ntohl(dr.replication),
                            GNUNET_TIME_absolute_ntoh(dr.expiration),
                            0,
                            1,
                            &put_cb,
                            NULL);
  if (NULL == qe)
    {
      fprintf(stderr, _("Error queueing datastore PUT operation\n"));
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
    }
}


static void
start_insert()
{
  record_count = 0;

  if (NULL != file_name)
    {
      file_handle = GNUNET_DISK_file_open(file_name,
                                          GNUNET_DISK_OPEN_READ,
                                          GNUNET_DISK_PERM_NONE);
      if (NULL == file_handle)
        {
          fprintf(stderr, _("Unable to open dump file: %s\n"), file_name);
          ret = 1;
          GNUNET_SCHEDULER_shutdown();
          return;
        }
    }
  else
    {
      file_handle = GNUNET_DISK_get_handle_from_int_fd(STDIN_FILENO);
    }

  uint8_t buf[MAGIC_LEN];
  ssize_t len;

  len = GNUNET_DISK_file_read(file_handle, buf, MAGIC_LEN);
  if (len != MAGIC_LEN || 0 != memcmp(buf, MAGIC_BYTES, MAGIC_LEN))
    {
      fprintf(stderr, _("Input file is not of a supported format\n"));
      return;
    }
  put_cb(NULL, GNUNET_YES, GNUNET_TIME_UNIT_ZERO_ABS, NULL);
}


static void
run(void *cls,
    char *const *args,
    const char *cfgfile,
    const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
  datastore = GNUNET_DATASTORE_connect(cfg);
  if (NULL == datastore)
    {
      fprintf(stderr, _("Failed connecting to the datastore.\n"));
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  if (dump)
    start_dump();
  else if (insert)
    start_insert();
  else
    {
      fprintf(stderr,
              _("Please choose at least one operation: %s, %s\n"),
              "dump",
              "insert");
      ret = 1;
      GNUNET_SCHEDULER_shutdown();
    }
}


int
main(int argc, char *const *argv)
{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag('d',
                              "dump",
                              gettext_noop(
                                "Dump all records from the datastore"),
                              &dump),
    GNUNET_GETOPT_option_flag('i',
                              "insert",
                              gettext_noop(
                                "Insert records into the datastore"),
                              &insert),
    GNUNET_GETOPT_option_filename('f',
                                  "file",
                                  "FILENAME",
                                  gettext_noop("File to dump or insert"),
                                  &file_name),
    GNUNET_GETOPT_OPTION_END };

  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
    return 2;

  if (GNUNET_OK !=
      GNUNET_PROGRAM_run(argc,
                         argv,
                         "gnunet-datastore",
                         gettext_noop("Manipulate GNUnet datastore"),
                         options,
                         &run,
                         NULL))
    ret = 1;
  GNUNET_free((void *)argv);
  return ret;
}

/* end of gnunet-datastore.c */