src/gns/gnunet-gns-import.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012-2013 GNUnet e.V.
   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 private-zone.
  64  */
  65 static char *private_zone_pkey;
  66
  67 /**
  68  * String version of PKEY for pin-zone.
  69  */
  70 static char *pin_zone_pkey = "72QC35CO20UJN1E91KPJFNT9TG4CLKAPB4VK9S3Q758S9MLBRKOG";
  71
  72 /**
  73  * Set to GNUNET_YES if private record was found;
  74  */
  75 static int found_private_rec = GNUNET_NO;
  76
  77 /**
  78  * Set to GNUNET_YES if pin record was found;
  79  */
  80 static int found_pin_rec = GNUNET_NO;
  81
  82 /**
  83  * Exit code.
  84  */
  85 static int ret;
  86
  87
  88 static int
  89 run_process_and_wait (int pipe_control,
  90                       enum GNUNET_OS_InheritStdioFlags std_inheritance,
  91                       struct GNUNET_DISK_PipeHandle *pipe_stdin,
  92                       struct GNUNET_DISK_PipeHandle *pipe_stdout,
  93                       enum GNUNET_OS_ProcessStatusType *st,
  94                       unsigned long *code,
  95                       const char *filename, ...)
  96 {
  97   static struct GNUNET_OS_Process *p;
  98   int arglen;
  99   char *arg;
 100   char *args;
 101   char *argp;
 102   va_list ap, apc1, apc2;
 103
 104   va_start (ap, filename);
 105   va_copy (apc1, ap);
 106   va_copy (apc2, ap);
 107   arglen = 0;
 108   while (NULL != (arg = va_arg (apc1, char *)))
 109     arglen += strlen (arg) + 1;
 110   va_end (apc1);
 111   args = argp = GNUNET_malloc (arglen);
 112   while (NULL != (arg = va_arg (apc2, char *)))
 113   {
 114     strcpy (argp, arg);
 115     argp += strlen (arg);
 116     *argp = ' ';
 117     argp += 1;
 118   }
 119   va_end (apc2);
 120   if (arglen > 0)
 121     argp[-1] = '\0';
 122   p = GNUNET_OS_start_process_va (pipe_control, std_inheritance,
 123                                   pipe_stdin,
 124                                   pipe_stdout,
 125                                   NULL,
 126                                   filename, ap);
 127   va_end (ap);
 128   if (NULL == p)
 129   {
 130     ret = 3;
 131     fprintf (stderr, "Failed to run `%s'\n", args);
 132     GNUNET_free (args);
 133     return 1;
 134   }
 135
 136   if (GNUNET_OK != GNUNET_OS_process_wait (p))
 137   {
 138     ret = 4;
 139     fprintf (stderr, "Failed to wait for `%s'\n", args);
 140     GNUNET_free (args);
 141     return 1;
 142   }
 143
 144   switch (GNUNET_OS_process_status (p, st, code))
 145   {
 146     case GNUNET_OK:
 147       break;
 148     case GNUNET_NO:
 149       ret = 5;
 150       fprintf (stderr, "`%s' is still running\n", args);
 151       GNUNET_free (args);
 152       return 1;
 153     default:
 154     case GNUNET_SYSERR:
 155       ret = 6;
 156       fprintf (stderr, "Failed to check the status of `%s'\n", args);
 157       GNUNET_free (args);
 158       return 1;
 159   }
 160 #ifdef WINDOWS
 161   if (GNUNET_OS_PROCESS_EXITED != *st || 0 != *code)
 162   {
 163     ret = 7;
 164     fprintf (stderr, "`%s' did not end correctly (%d, %d)\n", args, *st, *code);
 165     return 1;
 166   }
 167 #endif
 168   return 0;
 169 }
 170
 171 static void
 172 check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
 173     char *pk, int *found_rec)
 174 {
 175   int i;
 176   for (i = 0; i < rd_len; i++)
 177   {
 178     char *s;
 179     if (GNUNET_GNSRECORD_TYPE_PKEY != rd[i].record_type ||
 180         rd[i].data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
 181       continue;
 182     s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
 183                                           rd[i].data,
 184                                           rd[i].data_size);
 185     if (NULL == s)
 186       continue;
 187     if (0 == strcmp (s, pk))
 188       *found_rec = GNUNET_YES;
 189     GNUNET_free (s);
 190   }
 191 }
 192
 193 /**
 194  * Process a record that was stored in the namestore.
 195  *
 196  * @param cls closure
 197  * @param zone_key private key of the zone
 198  * @param rname name that is being mapped (at most 255 characters long)
 199  * @param rd_len number of entries in @a rd array
 200  * @param rd array of records with data to store
 201  */
 202 static void
 203 zone_iterator (void *cls,
 204     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 205     const char *rname, unsigned int rd_len,
 206     const struct GNUNET_GNSRECORD_Data *rd)
 207 {
 208   if (NULL != rname)
 209   {
 210     if (0 == strcmp (rname, "private"))
 211       check_pkey (rd_len, rd, private_zone_pkey, &found_private_rec);
 212     else if (0 == strcmp (rname, "pin"))
 213       check_pkey (rd_len, rd, pin_zone_pkey, &found_pin_rec);
 214   }
 215   GNUNET_NAMESTORE_zone_iterator_next (list_it);
 216 }
 217
 218 static void
 219 zone_iteration_error (void *cls)
 220 {
 221   enum GNUNET_OS_ProcessStatusType st;
 222   unsigned long code;
 223   if (!found_private_rec)
 224   {
 225     if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 226         "gnunet-namestore",
 227         "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "private", "-p", "-t", "PKEY", "-V", private_zone_pkey, NULL))
 228     {
 229       ret = 8;
 230       return;
 231     }
 232   }
 233   if (!found_pin_rec)
 234   {
 235     if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 236         "gnunet-namestore",
 237         "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "pin", "-p", "-t", "PKEY", "-V", pin_zone_pkey, NULL))
 238     {
 239       ret = 10;
 240       return;
 241     }
 242   }
 243   list_it = NULL;
 244   GNUNET_SCHEDULER_shutdown ();
 245 }
 246
 247
 248 static void
 249 zone_iteration_finished (void *cls)
 250 {
 251 }
 252
 253
 254 /**
 255  * Get master-zone and private-zone keys.
 256  *
 257  * This function is initially called for all egos and then again
 258  * whenever a ego's identifier changes or if it is deleted.  At the
 259  * end of the initial pass over all egos, the function is once called
 260  * with 'NULL' for 'ego'. That does NOT mean that the callback won't
 261  * be invoked in the future or that there was an error.
 262  *
 263  * When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get',
 264  * this function is only called ONCE, and 'NULL' being passed in
 265  * 'ego' does indicate an error (i.e. name is taken or no default
 266  * value is known).  If 'ego' is non-NULL and if '*ctx'
 267  * is set in those callbacks, the value WILL be passed to a subsequent
 268  * call to the identity callback of 'GNUNET_IDENTITY_connect' (if
 269  * that one was not NULL).
 270  *
 271  * When an identity is renamed, this function is called with the
 272  * (known) ego but the NEW identifier.
 273  *
 274  * When an identity is deleted, this function is called with the
 275  * (known) ego and "NULL" for the 'identifier'.  In this case,
 276  * the 'ego' is henceforth invalid (and the 'ctx' should also be
 277  * cleaned up).
 278  *
 279  * @param cls closure
 280  * @param ego ego handle
 281  * @param ctx context for application to store data for this ego
 282  *                 (during the lifetime of this process, initially NULL)
 283  * @param identifier identifier assigned by the user for this ego,
 284  *                   NULL if the user just deleted the ego and it
 285  *                   must thus no longer be used
 286 */
 287 static void
 288 get_ego (void *cls,
 289          struct GNUNET_IDENTITY_Ego *ego,
 290          void **ctx,
 291          const char *identifier)
 292 {
 293   static struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 294   if (NULL == ego)
 295   {
 296     if (NULL == master_zone_pkey ||
 297         NULL == private_zone_pkey)
 298     {
 299       ret = 11;
 300       GNUNET_SCHEDULER_shutdown ();
 301       return;
 302     }
 303     list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
 304         &master_pk, &zone_iteration_error, NULL, &zone_iterator, NULL, &zone_iteration_finished, NULL);
 305     if (NULL == list_it)
 306     {
 307       ret = 12;
 308       GNUNET_SCHEDULER_shutdown ();
 309     }
 310     return;
 311   }
 312   GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
 313   if (NULL != identifier)
 314   {
 315     if (NULL == master_zone_pkey && 0 == strcmp ("master-zone", identifier))
 316     {
 317       master_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
 318       master_pk = *GNUNET_IDENTITY_ego_get_private_key (ego);
 319     }
 320     else if (NULL == private_zone_pkey && 0 == strcmp ("private-zone", identifier))
 321       private_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
 322   }
 323 }
 324
 325 /**
 326  * Task run on shutdown.
 327  *
 328  * @param cls NULL
 329  */
 330 static void
 331 shutdown_task (void *cls)
 332 {
 333   GNUNET_free_non_null (master_zone_pkey);
 334   master_zone_pkey = NULL;
 335   GNUNET_free_non_null (private_zone_pkey);
 336   private_zone_pkey = NULL;
 337   if (NULL != list_it)
 338   {
 339     GNUNET_NAMESTORE_zone_iteration_stop (list_it);
 340     list_it = NULL;
 341   }
 342   if (NULL != ns)
 343   {
 344     GNUNET_NAMESTORE_disconnect (ns);
 345     ns = NULL;
 346   }
 347   if (NULL != sh)
 348   {
 349     GNUNET_IDENTITY_disconnect (sh);
 350     sh = NULL;
 351   }
 352 }
 353
 354 /**
 355  * Main function that will be run.
 356  *
 357  * @param cls closure
 358  * @param args remaining command-line arguments
 359  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 360  * @param c configuration
 361  */
 362 static void
 363 run (void *cls, char *const *args, const char *cfgfile,
 364      const struct GNUNET_CONFIGURATION_Handle *c)
 365 {
 366   enum GNUNET_OS_ProcessStatusType st;
 367   unsigned long code;
 368
 369   cfg = c;
 370
 371   if (0 != run_process_and_wait (GNUNET_NO, 0, NULL, NULL, &st, &code,
 372       "gnunet-arm",
 373       "gnunet-arm", "-I", NULL))
 374   {
 375     if (7 == ret)
 376       fprintf (stderr, "GNUnet is not running, please start GNUnet before running import\n");
 377     return;
 378   }
 379
 380   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 381       "gnunet-identity",
 382       "gnunet-identity", "-C", "master-zone", NULL))
 383     return;
 384
 385   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 386       "gnunet-identity",
 387       "gnunet-identity", "-C", "private-zone", NULL))
 388     return;
 389
 390   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 391       "gnunet-identity",
 392       "gnunet-identity", "-C", "sks-zone", NULL))
 393     return;
 394
 395   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 396       "gnunet-identity",
 397       "gnunet-identity", "-e", "master-zone", "-s", "gns-master", NULL))
 398     return;
 399
 400   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 401       "gnunet-identity",
 402       "gnunet-identity", "-e", "master-zone", "-s", "namestore", NULL))
 403     return;
 404
 405   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 406       "gnunet-identity",
 407       "gnunet-identity", "-e", "master-zone", "-s", "gns-proxy", NULL))
 408     return;
 409
 410   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 411       "gnunet-identity",
 412       "gnunet-identity", "-e", "master-zone", "-s", "gns-intercept", NULL))
 413     return;
 414
 415   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 416       "gnunet-identity",
 417       "gnunet-identity", "-e", "private-zone", "-s", "gns-private", NULL))
 418     return;
 419
 420   if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
 421       "gnunet-identity",
 422       "gnunet-identity", "-e", "sks-zone", "-s", "fs-sks", NULL))
 423     return;
 424
 425   ns = GNUNET_NAMESTORE_connect (cfg);
 426   sh = GNUNET_IDENTITY_connect (cfg, &get_ego, NULL);
 427   GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 428 }
 429
 430
 431 /**
 432  * The main function for gnunet-gns.
 433  *
 434  * @param argc number of arguments from the command line
 435  * @param argv command line arguments
 436  * @return 0 ok, 1 on error
 437  */
 438 int
 439 main (int argc, char *const *argv)
 440 {
 441   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 442     GNUNET_GETOPT_OPTION_END
 443   };
 444   int r;
 445
 446   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 447     return 2;
 448
 449   GNUNET_log_setup ("gnunet-gns-import", "WARNING", NULL);
 450   ret = 0;
 451   r = GNUNET_PROGRAM_run (argc, argv, "gnunet-gns-import",
 452                           _("This program will import some GNS authorities into your GNS namestore."),
 453                           options,
 454                           &run, NULL);
 455   GNUNET_free ((void*) argv);
 456   return GNUNET_OK == r ? ret : 1;
 457 }
 458
 459 /* end of gnunet-gns-import.c */