src/namestore/gnunet-namestore.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012 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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file gnunet-gns.c
  22  * @brief command line tool to manipulate the local zone
  23  * @author Christian Grothoff
  24  *
  25  * TODO:
  26  * - printing records
  27  * - allow users to set record options (not just 'RF_AUTHORITY')
  28  * - test
  29  * - parsing SOA, PTR and MX value specifications (and define format!)
  30  * - add options to list/lookup individual records
  31  * - add option to shorten name (lookup PKEY, then lookup name by zone,
  32  *   then possibly lookup PSEU for the zone and update our zone)
  33  */
  34 #include "platform.h"
  35 #include <gnunet_util_lib.h>
  36 #include <gnunet_dnsparser_lib.h>
  37 #include <gnunet_namestore_service.h>
  38
  39 /**
  40  * Handle to the namestore.
  41  */
  42 static struct GNUNET_NAMESTORE_Handle *ns;
  43
  44 /**
  45  * Hash of the public key of our zone.
  46  */
  47 static GNUNET_HashCode zone;
  48
  49 /**
  50  * Private key for the our zone.
  51  */
  52 static struct GNUNET_CRYPTO_RsaPrivateKey *zone_pkey;
  53
  54 /**
  55  * Keyfile to manipulate.
  56  */
  57 static char *keyfile;
  58
  59 /**
  60  * Desired action is to add a record.
  61  */
  62 static int add;
  63
  64 /**
  65  * Queue entry for the 'add' operation.
  66  */
  67 static struct GNUNET_NAMESTORE_QueueEntry *add_qe;
  68
  69 /**
  70  * Desired action is to list records.
  71  */
  72 static int list;
  73
  74 /**
  75  * List iterator for the 'list' operation.
  76  */
  77 static struct GNUNET_NAMESTORE_ZoneIterator *list_it;
  78
  79 /**
  80  * Desired action is to remove a record.
  81  */
  82 static int del;
  83
  84 /**
  85  * Queue entry for the 'del' operation.
  86  */
  87 static struct GNUNET_NAMESTORE_QueueEntry *del_qe;
  88
  89 /**
  90  * Name of the records to add/list/remove.
  91  */
  92 static char *name;
  93
  94 /**
  95  * Value of the record to add/remove.
  96  */
  97 static char *value;
  98
  99 /**
 100  * Type of the record to add/remove, NULL to remove all.
 101  */
 102 static char *typestring;
 103
 104 /**
 105  * Desired expiration time.
 106  */
 107 static char *expirationstring;
 108
 109
 110 /**
 111  * Task run on shutdown.  Cleans up everything.
 112  *
 113  * @param cls unused
 114  * @param tc scheduler context
 115  */
 116 static void
 117 do_shutdown (void *cls,
 118              const struct GNUNET_SCHEDULER_TaskContext *tc)
 119 {
 120   if (NULL != ns)
 121   {
 122     GNUNET_NAMESTORE_disconnect (ns, GNUNET_NO);
 123     ns = NULL;
 124   }
 125   if (NULL != zone_pkey)
 126   {
 127     GNUNET_CRYPTO_rsa_key_free (zone_pkey);
 128     zone_pkey = NULL;
 129   }
 130 }
 131
 132
 133 /**
 134  * Continuation called to notify client about result of the
 135  * operation.
 136  *
 137  * @param cls closure, unused
 138  * @param success GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate)
 139  *                GNUNET_NO if content was already there
 140  *                GNUNET_YES (or other positive value) on success
 141  * @param emsg NULL on success, otherwise an error message
 142  */
 143 static void
 144 add_continuation (void *cls,
 145                   int32_t success,
 146                   const char *emsg)
 147 {
 148   add_qe = NULL;
 149   if (success != GNUNET_YES)
 150     fprintf (stderr,
 151              _("Adding record failed: %s\n"),
 152              (success == GNUNET_NO) ? "record exists" : emsg);
 153   if ( (NULL == del_qe) &&
 154        (NULL == list_it) )
 155     GNUNET_SCHEDULER_shutdown ();
 156 }
 157
 158
 159 /**
 160  * Continuation called to notify client about result of the
 161  * operation.
 162  *
 163  * @param cls closure, unused
 164  * @param success GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate)
 165  *                GNUNET_NO if content was already there
 166  *                GNUNET_YES (or other positive value) on success
 167  * @param emsg NULL on success, otherwise an error message
 168  */
 169 static void
 170 del_continuation (void *cls,
 171                   int32_t success,
 172                   const char *emsg)
 173 {
 174   del_qe = NULL;
 175   if (success != GNUNET_YES)
 176     fprintf (stderr,
 177              _("Deleting record failed: %s\n"),
 178              emsg);
 179   if ( (NULL == add_qe) &&
 180        (NULL == list_it) )
 181     GNUNET_SCHEDULER_shutdown ();
 182 }
 183
 184
 185 /**
 186  * Process a record that was stored in the namestore.
 187  *
 188  * @param cls closure
 189  * @param zone_key public key of the zone
 190  * @param expire when does the corresponding block in the DHT expire (until
 191  *               when should we never do a DHT lookup for the same name again)?;
 192  *               GNUNET_TIME_UNIT_ZERO_ABS if there are no records of any type in the namestore,
 193  *               or the expiration time of the block in the namestore (even if there are zero
 194  *               records matching the desired record type)
 195  * @param name name that is being mapped (at most 255 characters long)
 196  * @param rd_count number of entries in 'rd' array
 197  * @param rd array of records with data to store
 198  * @param signature signature of the record block, NULL if signature is unavailable (i.e.
 199  *        because the user queried for a particular record type only)
 200  */
 201 static void
 202 display_record (void *cls,
 203                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 204                 struct GNUNET_TIME_Absolute expire,
 205                 const char *name,
 206                 unsigned int rd_len,
 207                 const struct GNUNET_NAMESTORE_RecordData *rd,
 208                 const struct GNUNET_CRYPTO_RsaSignature *signature)
 209 {
 210   if (NULL == name)
 211   {
 212     list_it = NULL;
 213     if ( (NULL == del_qe) &&
 214          (NULL == add_qe) )
 215       GNUNET_SCHEDULER_shutdown ();
 216     return;
 217   }
 218   // FIXME: display record!
 219   GNUNET_NAMESTORE_zone_iterator_next (list_it);
 220 }
 221
 222
 223 /**
 224  * Main function that will be run.
 225  *
 226  * @param cls closure
 227  * @param args remaining command-line arguments
 228  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 229  * @param cfg configuration
 230  */
 231 static void
 232 run (void *cls, char *const *args, const char *cfgfile,
 233      const struct GNUNET_CONFIGURATION_Handle *cfg)
 234 {
 235   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
 236   uint32_t type;
 237   const void *data;
 238   size_t data_size;
 239   struct in_addr value_a;
 240   struct in6_addr value_aaaa;
 241   struct GNUNET_TIME_Relative etime;
 242   struct GNUNET_NAMESTORE_RecordData rd;
 243
 244   if (NULL == keyfile)
 245   {
 246     fprintf (stderr,
 247              _("Option `%s' not given, but I need a zone key file!\n"),
 248              "z");
 249     return;
 250   }
 251   zone_pkey = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
 252   GNUNET_free (keyfile);
 253   keyfile = NULL;
 254   if (! (add|del|list))
 255   {
 256     /* nothing more to be done */
 257     GNUNET_CRYPTO_rsa_key_free (zone_pkey);
 258     zone_pkey = NULL;
 259     return;
 260   }
 261   if (NULL == zone_pkey)
 262   {
 263     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 264                 _("Failed to read or create private zone key\n"));
 265     return;
 266   }
 267   GNUNET_CRYPTO_rsa_key_get_public (zone_pkey,
 268                                     &pub);
 269   GNUNET_CRYPTO_hash (&pub, sizeof (pub), &zone);
 270
 271   ns = GNUNET_NAMESTORE_connect (cfg);
 272   if (NULL == ns)
 273   {
 274     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 275                 _("Failed to connect to namestore\n"));
 276     return;
 277   }
 278   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 279                                 &do_shutdown, NULL);
 280   if (NULL == typestring)
 281     type = 0;
 282   else
 283     type = GNUNET_NAMESTORE_typename_to_number (typestring);
 284   if (UINT32_MAX == type)
 285   {
 286     fprintf (stderr, _("Unsupported type `%s'\n"), typestring);
 287     GNUNET_SCHEDULER_shutdown ();
 288     return;
 289   } else if (add | del)
 290   {
 291     fprintf (stderr,
 292              _("Missing option `%s' for operation `%s'\n"),
 293              "-t", _("add/del"));
 294     GNUNET_SCHEDULER_shutdown ();
 295     return;
 296   }
 297   if (NULL != value)
 298   {
 299     switch (type)
 300     {
 301     case 0:
 302       fprintf (stderr, _("Need a record type to interpret value `%s'\n"), value);
 303       GNUNET_SCHEDULER_shutdown ();
 304       break;
 305     case GNUNET_DNSPARSER_TYPE_A:
 306       if (1 != inet_pton (AF_INET, value, &value_a))
 307       {
 308         fprintf (stderr, _("Value `%s' invalid for record type `%s'\n"),
 309                  value,
 310                  typestring);
 311         GNUNET_SCHEDULER_shutdown ();
 312         return;
 313       }
 314       data = &value_a;
 315       data_size = sizeof (value_a);
 316       break;
 317     case GNUNET_DNSPARSER_TYPE_NS:
 318       data = value;
 319       data_size = strlen (value);
 320       break;
 321     case GNUNET_DNSPARSER_TYPE_CNAME:
 322       data = value;
 323       data_size = strlen (value);
 324       break;
 325     case GNUNET_DNSPARSER_TYPE_SOA:
 326       // FIXME
 327       fprintf (stderr, _("Record type `%s' not implemented yet\n"), typestring);
 328       GNUNET_SCHEDULER_shutdown ();
 329       return;
 330     case GNUNET_DNSPARSER_TYPE_PTR:
 331       // FIXME
 332       fprintf (stderr, _("Record type `%s' not implemented yet\n"), typestring);
 333       GNUNET_SCHEDULER_shutdown ();
 334       return;
 335     case GNUNET_DNSPARSER_TYPE_MX:
 336       // FIXME
 337       fprintf (stderr, _("Record type `%s' not implemented yet\n"), typestring);
 338       GNUNET_SCHEDULER_shutdown ();
 339       return;
 340     case GNUNET_DNSPARSER_TYPE_TXT:
 341       data = value;
 342       data_size = strlen (value);
 343       break;
 344     case GNUNET_DNSPARSER_TYPE_AAAA:
 345       if (1 != inet_pton (AF_INET6, value, &value_aaaa))
 346       {
 347         fprintf (stderr, _("Value `%s' invalid for record type `%s'\n"),
 348                  value,
 349                  typestring);
 350         GNUNET_SCHEDULER_shutdown ();
 351         return;
 352       }
 353       data = &value_aaaa;
 354       data_size = sizeof (value_aaaa);
 355       break;
 356     case GNUNET_GNS_TYPE_PKEY:
 357       fprintf (stderr, _("Record type `%s' not implemented yet\n"), typestring);
 358       GNUNET_SCHEDULER_shutdown ();
 359       return;
 360     case GNUNET_GNS_TYPE_PSEU:
 361       data = value;
 362       data_size = strlen (value);
 363       break;
 364     default:
 365       GNUNET_assert (0);
 366     }
 367   } else if (add | del)
 368   {
 369     fprintf (stderr,
 370              _("Missing option `%s' for operation `%s'\n"),
 371              "-V", _("add/del"));
 372     GNUNET_SCHEDULER_shutdown ();
 373     return;
 374   }
 375   if (NULL != expirationstring)
 376   {
 377     if (GNUNET_OK !=
 378         GNUNET_STRINGS_fancy_time_to_relative (expirationstring,
 379                                                &etime))
 380     {
 381       fprintf (stderr,
 382                _("Invalid time format `%s'\n"),
 383                expirationstring);
 384       GNUNET_SCHEDULER_shutdown ();
 385       return;
 386     }
 387   } else if (add | del)
 388   {
 389     fprintf (stderr,
 390              _("Missing option `%s' for operation `%s'\n"),
 391              "-e", _("add/del"));
 392     GNUNET_SCHEDULER_shutdown ();
 393     return;
 394   }
 395   if (add)
 396   {
 397     if (NULL == name)
 398     {
 399       fprintf (stderr,
 400                _("Missing option `%s' for operation `%s'\n"),
 401                "-n", _("add"));
 402       GNUNET_SCHEDULER_shutdown ();
 403       return;
 404     }
 405     rd.data = data;
 406     rd.data_size = data_size;
 407     rd.record_type = type;
 408     rd.expiration = GNUNET_TIME_relative_to_absolute (etime);
 409     rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; // FIXME: not always...
 410     add_qe = GNUNET_NAMESTORE_record_create (ns,
 411                                              zone_pkey,
 412                                              name,
 413                                              &rd,
 414                                              &add_continuation,
 415                                              NULL);
 416   }
 417   if (del)
 418   {
 419     if (NULL == name)
 420     {
 421       fprintf (stderr,
 422                _("Missing option `%s' for operation `%s'\n"),
 423                "-n", _("del"));
 424       GNUNET_SCHEDULER_shutdown ();
 425       return;
 426     }
 427     rd.data = data;
 428     rd.data_size = data_size;
 429     rd.record_type = type;
 430     rd.expiration = GNUNET_TIME_relative_to_absolute (etime);
 431     rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; // FIXME: not always...
 432     del_qe = GNUNET_NAMESTORE_record_create (ns,
 433                                              zone_pkey,
 434                                              name,
 435                                              &rd,
 436                                              &del_continuation,
 437                                              NULL);
 438   }
 439   if (list)
 440   {
 441     list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
 442                                                      &zone,
 443                                                      0, 0,
 444                                                      &display_record,
 445                                                      NULL);
 446   }
 447 }
 448
 449
 450 /**
 451  * The main function for gnunet-gns.
 452  *
 453  * @param argc number of arguments from the command line
 454  * @param argv command line arguments
 455  * @return 0 ok, 1 on error
 456  */
 457 int
 458 main (int argc, char *const *argv)
 459 {
 460   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 461     {'a', "add", NULL,
 462      gettext_noop ("add record"), 0,
 463      &GNUNET_GETOPT_set_one, &add},
 464     {'d', "delete", NULL,
 465      gettext_noop ("delete record"), 0,
 466      &GNUNET_GETOPT_set_one, &del},
 467     {'D', "display", NULL,
 468      gettext_noop ("display records"), 0,
 469      &GNUNET_GETOPT_set_one, &list},
 470     {'e', "expiration", "TIME",
 471      gettext_noop ("expiration time to use (for adding only)"), 1,
 472      &GNUNET_GETOPT_set_string, &expirationstring},
 473     {'n', "name", "NAME",
 474      gettext_noop ("name of the record to add/delete/display"), 1,
 475      &GNUNET_GETOPT_set_string, &name},
 476     {'t', "type", "TYPE",
 477      gettext_noop ("type of the record to add/delete/display"), 1,
 478      &GNUNET_GETOPT_set_string, &typestring},
 479     {'V', "value", "VALUE",
 480      gettext_noop ("value of the record to add/delete"), 1,
 481      &GNUNET_GETOPT_set_string, &value},
 482     {'z', "zonekey", "FILENAME",
 483      gettext_noop ("filename with the zone key"), 1,
 484      &GNUNET_GETOPT_set_string, &keyfile},
 485     GNUNET_GETOPT_OPTION_END
 486   };
 487
 488   int ret;
 489
 490   GNUNET_log_setup ("gnunet-gns", "WARNING", NULL);
 491   ret =
 492       (GNUNET_OK ==
 493        GNUNET_PROGRAM_run (argc, argv, "gnunet-gns",
 494                            _("GNUnet GNS zone manipulation tool"),
 495                            options,
 496                            &run, NULL)) ? 0 : 1;
 497
 498   return ret;
 499 }
 500
 501 /* end of gnunet-gns.c */