src/namecache/gnunet-namecache.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 it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20 /**
  21  * @file gnunet-namecache.c
  22  * @brief command line tool to inspect the name cache
  23  * @author Christian Grothoff
  24  *
  25  * TODO:
  26  * - test
  27  */
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_dnsparser_lib.h"
  31 #include "gnunet_identity_service.h"
  32 #include "gnunet_gnsrecord_lib.h"
  33 #include "gnunet_namecache_service.h"
  34
  35
  36 /**
  37  * Handle to the namecache.
  38  */
  39 static struct GNUNET_NAMECACHE_Handle *ns;
  40
  41 /**
  42  * Queue entry for the 'query' operation.
  43  */
  44 static struct GNUNET_NAMECACHE_QueueEntry *qe;
  45
  46 /**
  47  * Name (label) of the records to list.
  48  */
  49 static char *name;
  50
  51 /**
  52  * Public key of the zone to look in.
  53  */
  54 static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
  55
  56 /**
  57  * Public key of the zone to look in, in ASCII.
  58  */
  59 static char *pkey;
  60
  61 /**
  62  * Global return value
  63  */
  64 static int ret;
  65
  66
  67 /**
  68  * Task run on shutdown.  Cleans up everything.
  69  *
  70  * @param cls unused
  71  */
  72 static void
  73 do_shutdown(void *cls)
  74 {
  75   if (NULL != qe)
  76     {
  77       GNUNET_NAMECACHE_cancel(qe);
  78       qe = NULL;
  79     }
  80   if (NULL != ns)
  81     {
  82       GNUNET_NAMECACHE_disconnect(ns);
  83       ns = NULL;
  84     }
  85 }
  86
  87
  88 /**
  89  * Process a record that was stored in the namecache in a block.
  90  *
  91  * @param cls closure, NULL
  92  * @param rd_len number of entries in @a rd array
  93  * @param rd array of records with data to store
  94  */
  95 static void
  96 display_records_from_block(void *cls,
  97                            unsigned int rd_len,
  98                            const struct GNUNET_GNSRECORD_Data *rd)
  99 {
 100   const char *typestring;
 101   char *s;
 102   unsigned int i;
 103
 104   if (0 == rd_len)
 105     {
 106       fprintf(stdout, _("No records found for `%s'"), name);
 107       return;
 108     }
 109   fprintf(stdout, "%s:\n", name);
 110   for (i = 0; i < rd_len; i++)
 111     {
 112       typestring = GNUNET_GNSRECORD_number_to_typename(rd[i].record_type);
 113       s = GNUNET_GNSRECORD_value_to_string(rd[i].record_type,
 114                                            rd[i].data,
 115                                            rd[i].data_size);
 116       if (NULL == s)
 117         {
 118           fprintf(stdout,
 119                   _("\tCorrupt or unsupported record of type %u\n"),
 120                   (unsigned int)rd[i].record_type);
 121           continue;
 122         }
 123       fprintf(stdout, "\t%s: %s\n", typestring, s);
 124       GNUNET_free(s);
 125     }
 126   fprintf(stdout, "%s", "\n");
 127 }
 128
 129
 130 /**
 131  * Display block obtained from listing (by name).
 132  *
 133  * @param cls NULL
 134  * @param block NULL if not found
 135  */
 136 static void
 137 handle_block(void *cls, const struct GNUNET_GNSRECORD_Block *block)
 138 {
 139   qe = NULL;
 140   if (NULL == block)
 141     {
 142       fprintf(stderr, "No matching block found\n");
 143     }
 144   else if (GNUNET_OK !=
 145            GNUNET_GNSRECORD_block_decrypt(block,
 146                                           &pubkey,
 147                                           name,
 148                                           &display_records_from_block,
 149                                           NULL))
 150     {
 151       fprintf(stderr, "Failed to decrypt block!\n");
 152     }
 153   GNUNET_SCHEDULER_shutdown();
 154 }
 155
 156
 157 /**
 158  * Main function that will be run.
 159  *
 160  * @param cls closure
 161  * @param args remaining command-line arguments
 162  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 163  * @param cfg configuration
 164  */
 165 static void
 166 run(void *cls,
 167     char *const *args,
 168     const char *cfgfile,
 169     const struct GNUNET_CONFIGURATION_Handle *cfg)
 170 {
 171   struct GNUNET_HashCode dhash;
 172
 173   if (NULL == pkey)
 174     {
 175       fprintf(stderr, _("You must specify which zone should be accessed\n"));
 176       return;
 177     }
 178
 179   if (GNUNET_OK !=
 180       GNUNET_CRYPTO_ecdsa_public_key_from_string(pkey, strlen(pkey), &pubkey))
 181     {
 182       fprintf(stderr, _("Invalid public key for zone `%s'\n"), pkey);
 183       GNUNET_SCHEDULER_shutdown();
 184       return;
 185     }
 186   if (NULL == name)
 187     {
 188       fprintf(stderr, _("You must specify a name\n"));
 189       return;
 190     }
 191
 192   GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
 193   ns = GNUNET_NAMECACHE_connect(cfg);
 194   GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &dhash);
 195   qe = GNUNET_NAMECACHE_lookup_block(ns, &dhash, &handle_block, NULL);
 196 }
 197
 198
 199 /**
 200  * The main function for gnunet-namecache.
 201  *
 202  * @param argc number of arguments from the command line
 203  * @param argv command line arguments
 204  * @return 0 ok, 1 on error
 205  */
 206 int
 207 main(int argc, char *const *argv)
 208 {
 209   struct GNUNET_GETOPT_CommandLineOption options[] =
 210   { GNUNET_GETOPT_option_string('n',
 211                                 "name",
 212                                 "NAME",
 213                                 gettext_noop(
 214                                   "name of the record to add/delete/display"),
 215                                 &name),
 216
 217     GNUNET_GETOPT_option_string(
 218       'z',
 219       "zone",
 220       "PKEY",
 221       gettext_noop("specifies the public key of the zone to look in"),
 222       &pkey),
 223
 224     GNUNET_GETOPT_OPTION_END };
 225
 226   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
 227     return 2;
 228
 229   GNUNET_log_setup("gnunet-namecache", "WARNING", NULL);
 230   if (GNUNET_OK != GNUNET_PROGRAM_run(argc,
 231                                       argv,
 232                                       "gnunet-namecache",
 233                                       _("GNUnet zone manipulation tool"),
 234                                       options,
 235                                       &run,
 236                                       NULL))
 237     {
 238       GNUNET_free((void *)argv);
 239       return 1;
 240     }
 241   GNUNET_free((void *)argv);
 242   return ret;
 243 }
 244
 245 /* end of gnunet-namecache.c */