gnunet-gns-import.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2012-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 "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_identity_service.h>
#include <gnunet_namestore_service.h>
 
static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct GNUNET_IDENTITY_Handle *sh;
 
struct GNUNET_NAMESTORE_ZoneIterator *list_it;
 
static struct GNUNET_NAMESTORE_Handle *ns;
 
static char *master_zone_pkey;
 
static struct GNUNET_CRYPTO_EcdsaPrivateKey master_pk;
 
static char *private_zone_pkey;
 
static char *pin_zone_pkey =
  "72QC35CO20UJN1E91KPJFNT9TG4CLKAPB4VK9S3Q758S9MLBRKOG";
 
static int found_private_rec = GNUNET_NO;
 
static int found_pin_rec = GNUNET_NO;
 
static int ret;
 
 
static int
run_process_and_wait (enum GNUNET_OS_InheritStdioFlags std_inheritance,
                      struct GNUNET_DISK_PipeHandle *pipe_stdin,
                      struct GNUNET_DISK_PipeHandle *pipe_stdout,
                      enum GNUNET_OS_ProcessStatusType *st,
                      unsigned long *code,
                      const char *filename, ...)
{
  static struct GNUNET_OS_Process *p;
  int arglen;
  char *arg;
  char *args;
  char *argp;
  va_list ap, apc1, apc2;
 
  va_start (ap, filename);
  va_copy (apc1, ap);
  va_copy (apc2, ap);
  arglen = 0;
  while (NULL != (arg = va_arg (apc1, char *)))
    arglen += strlen (arg) + 1;
  va_end (apc1);
  args = argp = GNUNET_malloc (arglen);
  while (NULL != (arg = va_arg (apc2, char *)))
  {
    strcpy (argp, arg);
    argp += strlen (arg);
    *argp = ' ';
    argp += 1;
  }
  va_end (apc2);
  if (arglen > 0)
    argp[-1] = '\0';
  p = GNUNET_OS_start_process_va (std_inheritance,
                                  pipe_stdin,
                                  pipe_stdout,
                                  NULL,
                                  filename, ap);
  va_end (ap);
  if (NULL == p)
  {
    ret = 3;
    fprintf (stderr, "Failed to run `%s'\n", args);
    GNUNET_free (args);
    return 1;
  }
 
  if (GNUNET_OK != GNUNET_OS_process_wait (p))
  {
    ret = 4;
    fprintf (stderr, "Failed to wait for `%s'\n", args);
    GNUNET_free (args);
    return 1;
  }
 
  switch (GNUNET_OS_process_status (p, st, code))
  {
  case GNUNET_OK:
    break;
 
  case GNUNET_NO:
    ret = 5;
    fprintf (stderr, "`%s' is still running\n", args);
    GNUNET_free (args);
    return 1;
 
  default:
  case GNUNET_SYSERR:
    ret = 6;
    fprintf (stderr, "Failed to check the status of `%s'\n", args);
    GNUNET_free (args);
    return 1;
  }
  return 0;
}
 
 
static void
check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
            char *pk, int *found_rec)
{
  int i;
  struct GNUNET_IDENTITY_PublicKey pubkey;
 
  for (i = 0; i < rd_len; i++)
  {
    char *s;
    if (sizeof (uint32_t) > rd[i].data_size)
      continue;
    if (GNUNET_OK != GNUNET_GNSRECORD_identity_from_data (rd[i].data,
                                                          rd[i].data_size,
                                                          rd[i].record_type,
                                                          &pubkey))
      continue;
    s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                          rd[i].data,
                                          rd[i].data_size);
    if (NULL == s)
      continue;
    if (0 == strcmp (s, pk))
      *found_rec = GNUNET_YES;
    GNUNET_free (s);
  }
}
 
 
static void
zone_iterator (void *cls,
               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
               const char *rname, unsigned int rd_len,
               const struct GNUNET_GNSRECORD_Data *rd)
{
  if (NULL != rname)
  {
    if (0 == strcmp (rname, "private"))
      check_pkey (rd_len, rd, private_zone_pkey, &found_private_rec);
    else if (0 == strcmp (rname, "pin"))
      check_pkey (rd_len, rd, pin_zone_pkey, &found_pin_rec);
  }
  GNUNET_NAMESTORE_zone_iterator_next (list_it);
}
 
 
static void
zone_iteration_error (void *cls)
{
  enum GNUNET_OS_ProcessStatusType st;
  unsigned long code;
 
  if (! found_private_rec)
  {
    if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                   NULL, NULL, &st, &code,
                                   "gnunet-namestore",
                                   "gnunet-namestore", "-z", "master-zone",
                                   "-a", "-e", "never", "-n", "private", "-p",
                                   "-t", "PKEY", "-V",
                                   private_zone_pkey, NULL))
    {
      ret = 8;
      return;
    }
  }
  if (! found_pin_rec)
  {
    if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                   NULL, NULL, &st, &code,
                                   "gnunet-namestore",
                                   "gnunet-namestore", "-z", "master-zone",
                                   "-a", "-e", "never", "-n", "pin", "-p", "-t",
                                   "PKEY", "-V", pin_zone_pkey,
                                   NULL))
    {
      ret = 10;
      return;
    }
  }
  list_it = NULL;
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static void
zone_iteration_finished (void *cls)
{
}
 
 
static void
get_ego (void *cls,
         struct GNUNET_IDENTITY_Ego *ego,
         void **ctx,
         const char *identifier)
{
  static struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 
  if (NULL == ego)
  {
    if ((NULL == master_zone_pkey) ||
        (NULL == private_zone_pkey) )
    {
      ret = 11;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
                                                     &master_pk,
                                                     &zone_iteration_error,
                                                     NULL, &zone_iterator, NULL,
                                                     &zone_iteration_finished,
                                                     NULL);
    if (NULL == list_it)
    {
      ret = 12;
      GNUNET_SCHEDULER_shutdown ();
    }
    return;
  }
  GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
  if (NULL != identifier)
  {
    if ((NULL == master_zone_pkey) && (0 == strcmp ("master-zone",
                                                    identifier)) )
    {
      master_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
      master_pk = *GNUNET_IDENTITY_ego_get_private_key (ego);
    }
    else if ((NULL == private_zone_pkey) && (0 == strcmp ("private-zone",
                                                          identifier)) )
      private_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
  }
}
 
 
static void
shutdown_task (void *cls)
{
  GNUNET_free (master_zone_pkey);
  master_zone_pkey = NULL;
  GNUNET_free (private_zone_pkey);
  private_zone_pkey = NULL;
  if (NULL != list_it)
  {
    GNUNET_NAMESTORE_zone_iteration_stop (list_it);
    list_it = NULL;
  }
  if (NULL != ns)
  {
    GNUNET_NAMESTORE_disconnect (ns);
    ns = NULL;
  }
  if (NULL != sh)
  {
    GNUNET_IDENTITY_disconnect (sh);
    sh = NULL;
  }
}
 
 
static void
run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *c)
{
  enum GNUNET_OS_ProcessStatusType st;
  unsigned long code;
 
  cfg = c;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_NONE,
                                 NULL, NULL, &st, &code,
                                 "gnunet-arm",
                                 "gnunet-arm", "-I", NULL))
  {
    if (7 == ret)
      fprintf (stderr,
               "GNUnet is not running, please start GNUnet before running import\n");
    return;
  }
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-C", "master-zone", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-C", "private-zone", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-C", "sks-zone", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "master-zone", "-s",
                                 "gns-master", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "master-zone", "-s",
                                 "namestore", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "master-zone", "-s",
                                 "gns-proxy", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "master-zone", "-s",
                                 "gns-intercept", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "private-zone", "-s",
                                 "gns-private", NULL))
    return;
 
  if (0 != run_process_and_wait (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, &st, &code,
                                 "gnunet-identity",
                                 "gnunet-identity", "-e", "sks-zone", "-s",
                                 "fs-sks", NULL))
    return;
 
  ns = GNUNET_NAMESTORE_connect (cfg);
  sh = GNUNET_IDENTITY_connect (cfg, &get_ego, NULL);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}
 
 
int
main (int argc, char *const *argv)
{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int r;
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  GNUNET_log_setup ("gnunet-gns-import", "WARNING", NULL);
  ret = 0;
  r = GNUNET_PROGRAM_run (argc, argv, "gnunet-gns-import",
                          _ (
                            "This program will import some GNS authorities into your GNS namestore."),
                          options,
                          &run, NULL);
  GNUNET_free_nz ((void *) argv);
  return GNUNET_OK == r ? ret : 1;
}
 
 
/* end of gnunet-gns-import.c */