src/gns/gnunet-gns-import.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012-2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file gnunet-gns.c
  22  * @brief binary version of gnunet-gns-import.sh
  23  *        (for OSes that have no POSIX shell).
  24  * @author LRN
  25  */
  26 #include "platform.h"
  27 #include <gnunet_util_lib.h>
  28 #include <gnunet_gnsrecord_lib.h>
  29 #include <gnunet_identity_service.h>
  30 #include <gnunet_namestore_service.h>
  31
  32 /**
  33  * Configuration we are using.
  34  */
  35 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  36
  37 /**
  38  * Handle to IDENTITY service.
  39  */
  40 static struct GNUNET_IDENTITY_Handle *sh;
  41
  42 /**
  43  * Zone iterator for master zone
  44  */
  45 struct GNUNET_NAMESTORE_ZoneIterator *list_it;
  46
  47 /**
  48  * Handle to the namestore.
  49  */
  50 static struct GNUNET_NAMESTORE_Handle *ns;
  51
  52 /**
  53  * String version of PKEY for master-zone.
  54  */
  55 static char *master_zone_pkey;
  56
  57 /**
  58  * Binary version of PKEY for master-zone.
  59  */
  60 static struct GNUNET_CRYPTO_EcdsaPrivateKey master_pk;
  61
  62 /**
  63  * String version of PKEY for short-zone.
  64  */
  65 static char *short_zone_pkey;
  66
  67 /**
  68  * String version of PKEY for private-zone.
  69  */
  70 static char *private_zone_pkey;
  71
  72 /**
  73  * String version of PKEY for pin-zone.
  74  */
  75 static char *pin_zone_pkey = "72QC35CO20UJN1E91KPJFNT9TG4CLKAPB4VK9S3Q758S9MLBRKOG";
  76
  77 /**
  78  * Set to GNUNET_YES if private record was found;
  79  */
  80 static int found_private_rec = GNUNET_NO;
  81
  82 /**
  83  * Set to GNUNET_YES if short record was found;
  84  */
  85 static int found_short_rec = GNUNET_NO;
  86
  87 /**
  88  * Set to GNUNET_YES if pin record was found;
  89  */
  90 static int found_pin_rec = GNUNET_NO;
  91
  92 /**
  93  * Exit code.
  94  */
  95 static int ret;
  96
  97
  98 static int
  99 run_process_and_wait (int pipe_control,
 100                       enum GNUNET_OS_InheritStdioFlags std_inheritance,
 101                       struct GNUNET_DISK_PipeHandle *pipe_stdin,
 102                       struct GNUNET_DISK_PipeHandle *pipe_stdout,
 103                       enum GNUNET_OS_ProcessStatusType *st,
 104                       unsigned long *code,
 105                       const char *filename, ...)
 106 {
 107   static struct GNUNET_OS_Process *p;
 108   int arglen;
 109   char *arg;
 110   char *args;
 111   char *argp;
 112   va_list ap, apc1, apc2;
 113
 114   va_start (ap, filename);
 115   va_copy (apc1, ap);
 116   va_copy (apc2, ap);
 117   arglen = 0;
 118   while (NULL != (arg = va_arg (apc1, char *)))
 119     arglen += strlen (arg) + 1;
 120   va_end (apc1);
 121   args = argp = GNUNET_malloc (arglen);
 122   while (NULL != (arg = va_arg (apc2, char *)))
 123   {
 124     strcpy (argp, arg);
 125     argp += strlen (arg);
 126     *argp = ' ';
 127     argp += 1;
 128   }
 129   va_end (apc2);
 130   if (arglen > 0)
 131     argp[-1] = '\0';
 132   p = GNUNET_OS_start_process_va (pipe_control, std_inheritance,
 133                                   pipe_stdin,
 134                                   pipe_stdout,
 135                                   NULL,
 136                                   filename, ap);
 137   va_end (ap);
 138   if (NULL == p)
 139   {
 140     ret = 3;
 141     fprintf (stderr, "Failed to run `%s'\n", args);
 142     GNUNET_free (args);
 143     return 1;
 144   }
 145
 146   if (GNUNET_OK != GNUNET_OS_process_wait (p))
 147   {
 148     ret = 4;
 149     fprintf (stderr, "Failed to wait for `%s'\n", args);
 150     GNUNET_free (args);
 151     return 1;
 152   }
 153
 154   switch (GNUNET_OS_process_status (p, st, code))
 155   {
 156     case GNUNET_OK:
 157       break;
 158     case GNUNET_NO:
 159       ret = 5;
 160       fprintf (stderr, "`%s' is still running\n", args);
 161       GNUNET_free (args);
 162       return 1;
 163     default:
 164     case GNUNET_SYSERR:
 165       ret = 6;
 166       fprintf (stderr, "Failed to check the status of `%s'\n", args);
 167       GNUNET_free (args);
 168       return 1;
 169   }
 170 #ifdef WINDOWS
 171   if (GNUNET_OS_PROCESS_EXITED != *st || 0 != *code)
 172   {
 173     ret = 7;
 174     fprintf (stderr, "`%s' did not end correctly (%d, %d)\n", args, *st, *code);
 175     return 1;
 176   }
 177 #endif
 178   return 0;
 179 }
 180
 181 static void
 182 check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
 183     char *pk, int *found_rec)
 184 {
 185   int i;
 186   for (i = 0; i < rd_len; i++)
 187   {
 188     char *s;
 189     if (GNUNET_GNSRECORD_TYPE_PKEY != rd[i].record_type ||
 190         rd[i].data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
 191       continue;
 192     s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
 193                                           rd[i].data,
 194                                           rd[i].data_size);
 195     if (NULL == s)
 196       continue;
 197     if (0 == strcmp (s, pk))
 198       *found_rec = GNUNET_YES;
 199     GNUNET_free (s);
 200   }
 201 }
 202
 203 /**
 204  * Process a record that was stored in the namestore.
 205  *
 206  * @param cls closure
 207  * @param zone_key private key of the zone
 208  * @param rname name that is being mapped (at most 255 characters long)
 209  * @param rd_len number of entries in @a rd array
 210  * @param rd array of records with data to store
 211  */
 212 static void
 213 zone_iterator (void *cls,
 214     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 215     const char *rname, unsigned int rd_len,
 216     const struct GNUNET_GNSRECORD_Data *rd)
 217 {
 218   if (NULL != rname)
 219   {
 220     if (0 == strcmp (rname, "private"))
 221       check_pkey (rd_len, rd, private_zone_pkey, &found_private_rec);
 222     else if (0 == strcmp (rname, "short"))
 223       check_pkey (rd_len, rd, short_zone_pkey, &found_short_rec);
 224     else if (0 == strcmp (rname, "pin"))
 225       check_pkey (rd_len, rd, pin_zone_pkey, &found_pin_rec);
 226   }
 227   if (NULL == rname && 0 == rd_len && NULL == rd)
 228   {
 229     enum GNUNET_OS_ProcessStatusType st;
 230     unsigned long code;
 231     if (!found_private_rec)
 232     {
 233       if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 234           "gnunet-namestore",
 235           "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "private", "-p", "-t", "PKEY", "-V", private_zone_pkey, NULL))
 236       {
 237         ret = 8;
 238         return;
 239       }
 240     }
 241     if (!found_short_rec)
 242     {
 243       if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 244           "gnunet-namestore",
 245           "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "short", "-p", "-t", "PKEY", "-V", short_zone_pkey, NULL))
 246       {
 247         ret = 9;
 248         return;
 249       }
 250     }
 251     if (!found_pin_rec)
 252     {
 253       if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 254           "gnunet-namestore",
 255           "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "pin", "-p", "-t", "PKEY", "-V", pin_zone_pkey, NULL))
 256       {
 257         ret = 10;
 258         return;
 259       }
 260     }
 261     list_it = NULL;
 262     GNUNET_SCHEDULER_shutdown ();
 263     return;
 264   }
 265   GNUNET_NAMESTORE_zone_iterator_next (list_it);
 266 }
 267
 268
 269 /**
 270  * Get master-zone, short-zone and private-zone keys.
 271  *
 272  * This function is initially called for all egos and then again
 273  * whenever a ego's identifier changes or if it is deleted.  At the
 274  * end of the initial pass over all egos, the function is once called
 275  * with 'NULL' for 'ego'. That does NOT mean that the callback won't
 276  * be invoked in the future or that there was an error.
 277  *
 278  * When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get',
 279  * this function is only called ONCE, and 'NULL' being passed in
 280  * 'ego' does indicate an error (i.e. name is taken or no default
 281  * value is known).  If 'ego' is non-NULL and if '*ctx'
 282  * is set in those callbacks, the value WILL be passed to a subsequent
 283  * call to the identity callback of 'GNUNET_IDENTITY_connect' (if
 284  * that one was not NULL).
 285  *
 286  * When an identity is renamed, this function is called with the
 287  * (known) ego but the NEW identifier.
 288  *
 289  * When an identity is deleted, this function is called with the
 290  * (known) ego and "NULL" for the 'identifier'.  In this case,
 291  * the 'ego' is henceforth invalid (and the 'ctx' should also be
 292  * cleaned up).
 293  *
 294  * @param cls closure
 295  * @param ego ego handle
 296  * @param ctx context for application to store data for this ego
 297  *                 (during the lifetime of this process, initially NULL)
 298  * @param identifier identifier assigned by the user for this ego,
 299  *                   NULL if the user just deleted the ego and it
 300  *                   must thus no longer be used
 301 */
 302 static void
 303 get_ego (void *cls,
 304          struct GNUNET_IDENTITY_Ego *ego,
 305          void **ctx,
 306          const char *identifier)
 307 {
 308   static struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 309   if (NULL == ego)
 310   {
 311     if (NULL == master_zone_pkey ||
 312         NULL == short_zone_pkey ||
 313         NULL == private_zone_pkey)
 314     {
 315       ret = 11;
 316       GNUNET_SCHEDULER_shutdown ();
 317       return;
 318     }
 319     list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
 320         &master_pk, &zone_iterator, NULL);
 321     if (NULL == list_it)
 322     {
 323       ret = 12;
 324       GNUNET_SCHEDULER_shutdown ();
 325     }
 326     return;
 327   }
 328   GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
 329   if (NULL != identifier)
 330   {
 331     if (NULL == master_zone_pkey && 0 == strcmp ("master-zone", identifier))
 332     {
 333       master_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
 334       master_pk = *GNUNET_IDENTITY_ego_get_private_key (ego);
 335     }
 336     else if (NULL == short_zone_pkey && 0 == strcmp ("short-zone", identifier))
 337       short_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
 338     else if (NULL == private_zone_pkey && 0 == strcmp ("private-zone", identifier))
 339       private_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
 340   }
 341 }
 342
 343 /**
 344  * Task run on shutdown.
 345  *
 346  * @param cls NULL
 347  * @param tc unused
 348  */
 349 static void
 350 shutdown_task (void *cls,
 351                const struct GNUNET_SCHEDULER_TaskContext *tc)
 352 {
 353   GNUNET_free_non_null (master_zone_pkey);
 354   master_zone_pkey = NULL;
 355   GNUNET_free_non_null (short_zone_pkey);
 356   short_zone_pkey = NULL;
 357   GNUNET_free_non_null (private_zone_pkey);
 358   private_zone_pkey = NULL;
 359   if (NULL != list_it)
 360   {
 361     GNUNET_NAMESTORE_zone_iteration_stop (list_it);
 362     list_it = NULL;
 363   }
 364   if (NULL != ns)
 365   {
 366     GNUNET_NAMESTORE_disconnect (ns);
 367     ns = NULL;
 368   }
 369   if (NULL != sh)
 370   {
 371     GNUNET_IDENTITY_disconnect (sh);
 372     sh = NULL;
 373   }
 374 }
 375
 376 /**
 377  * Main function that will be run.
 378  *
 379  * @param cls closure
 380  * @param args remaining command-line arguments
 381  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 382  * @param c configuration
 383  */
 384 static void
 385 run (void *cls, char *const *args, const char *cfgfile,
 386      const struct GNUNET_CONFIGURATION_Handle *c)
 387 {
 388   enum GNUNET_OS_ProcessStatusType st;
 389   unsigned long code;
 390
 391   cfg = c;
 392
 393   if (0 != run_process_and_wait (GNUNET_NO, 0, NULL, NULL, &st, &code,
 394       "gnunet-arm",
 395       "gnunet-arm", "-I", NULL))
 396   {
 397     if (7 == ret)
 398       fprintf (stderr, "GNUnet is not running, please start GNUnet before running import\n");
 399     return;
 400   }
 401
 402   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 403       "gnunet-identity",
 404       "gnunet-identity", "-C", "master-zone", NULL))
 405     return;
 406
 407   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 408       "gnunet-identity",
 409       "gnunet-identity", "-C", "short-zone", NULL))
 410     return;
 411
 412   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 413       "gnunet-identity",
 414       "gnunet-identity", "-C", "private-zone", NULL))
 415     return;
 416
 417   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 418       "gnunet-identity",
 419       "gnunet-identity", "-C", "sks-zone", NULL))
 420     return;
 421
 422   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 423       "gnunet-identity",
 424       "gnunet-identity", "-e", "short-zone", "-s", "gns-short", NULL))
 425     return;
 426
 427   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 428       "gnunet-identity",
 429       "gnunet-identity", "-e", "master-zone", "-s", "gns-master", NULL))
 430     return;
 431
 432   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 433       "gnunet-identity",
 434       "gnunet-identity", "-e", "master-zone", "-s", "namestore", NULL))
 435     return;
 436
 437   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 438       "gnunet-identity",
 439       "gnunet-identity", "-e", "master-zone", "-s", "gns-proxy", NULL))
 440     return;
 441
 442   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 443       "gnunet-identity",
 444       "gnunet-identity", "-e", "master-zone", "-s", "gns-intercept", NULL))
 445     return;
 446
 447   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 448       "gnunet-identity",
 449       "gnunet-identity", "-e", "private-zone", "-s", "gns-private", NULL))
 450     return;
 451
 452   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 453       "gnunet-identity",
 454       "gnunet-identity", "-e", "sks-zone", "-s", "fs-sks", NULL))
 455     return;
 456
 457   ns = GNUNET_NAMESTORE_connect (cfg);
 458   sh = GNUNET_IDENTITY_connect (cfg, &get_ego, NULL);
 459   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 460                                 &shutdown_task, NULL);
 461 }
 462
 463
 464 /**
 465  * The main function for gnunet-gns.
 466  *
 467  * @param argc number of arguments from the command line
 468  * @param argv command line arguments
 469  * @return 0 ok, 1 on error
 470  */
 471 int
 472 main (int argc, char *const *argv)
 473 {
 474   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 475     GNUNET_GETOPT_OPTION_END
 476   };
 477   int r;
 478
 479   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 480     return 2;
 481
 482   GNUNET_log_setup ("gnunet-gns-import", "WARNING", NULL);
 483   ret = 0;
 484   r = GNUNET_PROGRAM_run (argc, argv, "gnunet-gns-import",
 485                           _("This program will import some GNS authorities into your GNS namestore."),
 486                           options,
 487                           &run, NULL);
 488   GNUNET_free ((void*) argv);
 489   return GNUNET_OK == r ? ret : 1;
 490 }
 491
 492 /* end of gnunet-gns-import.c */