src/gns/gnunet-service-gns.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011-2018 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 gns/gnunet-service-gns.c
  22  * @brief GNU Name System (main service)
  23  * @author Martin Schanzenbach
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_dns_service.h"
  29 #include "gnunet_dnsparser_lib.h"
  30 #include "gnunet_dht_service.h"
  31 #include "gnunet_namecache_service.h"
  32 #include "gnunet_gnsrecord_lib.h"
  33 #include "gnunet_gns_service.h"
  34 #include "gnunet_statistics_service.h"
  35 #include "gns.h"
  36 #include "gnunet-service-gns_resolver.h"
  37 #include "gnunet-service-gns_interceptor.h"
  38 #include "gnunet_protocols.h"
  39
  40
  41 /**
  42  * GnsClient prototype
  43  */
  44 struct GnsClient;
  45
  46 /**
  47  * Handle to a lookup operation from client via API.
  48  */
  49 struct ClientLookupHandle
  50 {
  51
  52   /**
  53    * We keep these in a DLL.
  54    */
  55   struct ClientLookupHandle *next;
  56
  57   /**
  58    * We keep these in a DLL.
  59    */
  60   struct ClientLookupHandle *prev;
  61
  62   /**
  63    * Client handle
  64    */
  65   struct GnsClient *gc;
  66
  67   /**
  68    * Active handle for the lookup.
  69    */
  70   struct GNS_ResolverHandle *lookup;
  71
  72   /**
  73    * request id
  74    */
  75   uint32_t request_id;
  76
  77 };
  78
  79
  80 /**
  81  * Information we track per connected client.
  82  */
  83 struct GnsClient
  84 {
  85   /**
  86    * The client
  87    */
  88   struct GNUNET_SERVICE_Client *client;
  89
  90   /**
  91    * The MQ
  92    */
  93   struct GNUNET_MQ_Handle *mq;
  94
  95   /**
  96    * Head of the DLL.
  97    */
  98   struct ClientLookupHandle *clh_head;
  99
 100   /**
 101    * Tail of the DLL.
 102    */
 103   struct ClientLookupHandle *clh_tail;
 104 };
 105
 106
 107 /**
 108  * Representation of a TLD, mapping the respective TLD string
 109  * (i.e. ".gnu") to the respective public key of the zone.
 110  */
 111 struct GNS_TopLevelDomain
 112 {
 113
 114   /**
 115    * Kept in a DLL, as there are unlikely enough of these to
 116    * warrant a hash map.
 117    */
 118   struct GNS_TopLevelDomain *next;
 119
 120   /**
 121    * Kept in a DLL, as there are unlikely enough of these to
 122    * warrant a hash map.
 123    */
 124   struct GNS_TopLevelDomain *prev;
 125
 126   /**
 127    * Public key associated with the @a tld.
 128    */
 129   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 130
 131   /**
 132    * Top-level domain as a string, including leading ".".
 133    */
 134   char *tld;
 135
 136 };
 137
 138
 139 /**
 140  * Our handle to the DHT
 141  */
 142 static struct GNUNET_DHT_Handle *dht_handle;
 143
 144 /**
 145  * Our handle to the namecache service
 146  */
 147 static struct GNUNET_NAMECACHE_Handle *namecache_handle;
 148
 149 /**
 150  * #GNUNET_YES if ipv6 is supported
 151  */
 152 static int v6_enabled;
 153
 154 /**
 155  * #GNUNET_YES if ipv4 is supported
 156  */
 157 static int v4_enabled;
 158
 159 /**
 160  * Handle to the statistics service
 161  */
 162 static struct GNUNET_STATISTICS_Handle *statistics;
 163
 164 /**
 165  * Head of DLL of TLDs we map to GNS zones.
 166  */
 167 static struct GNS_TopLevelDomain *tld_head;
 168
 169 /**
 170  * Tail of DLL of TLDs we map to GNS zones.
 171  */
 172 static struct GNS_TopLevelDomain *tld_tail;
 173
 174
 175 /**
 176  * Find GNS zone belonging to TLD @a tld.
 177  *
 178  * @param tld_str top-level domain to look up
 179  * @param[out] pkey public key to set
 180  * @return #GNUNET_YES if @a tld was found #GNUNET_NO if not
 181  */
 182 int
 183 GNS_find_tld (const char *tld_str,
 184               struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 185 {
 186   if ('\0' == *tld_str)
 187     return GNUNET_NO;
 188   for (struct GNS_TopLevelDomain *tld = tld_head;
 189        NULL != tld;
 190        tld = tld->next)
 191   {
 192     if (0 == strcasecmp (tld_str,
 193                          tld->tld))
 194     {
 195       *pkey = tld->pkey;
 196       return GNUNET_YES;
 197     }
 198   }
 199   if (GNUNET_OK ==
 200       GNUNET_GNSRECORD_zkey_to_pkey (tld_str + 1,
 201                                      pkey))
 202     return GNUNET_YES; /* TLD string *was* the public key */
 203   return GNUNET_NO;
 204 }
 205
 206
 207 /**
 208  * Obtain the TLD of the given @a name.
 209  *
 210  * @param name a name
 211  * @return the part of @a name after the last ".",
 212  *         or @a name if @a name does not contain a "."
 213  */
 214 const char *
 215 GNS_get_tld (const char *name)
 216 {
 217   const char *tld;
 218
 219   tld = strrchr (name,
 220                  (unsigned char) '.');
 221   if (NULL == tld)
 222     tld = name;
 223   else
 224     tld++; /* skip the '.' */
 225   return tld;
 226 }
 227
 228
 229 /**
 230  * Task run during shutdown.
 231  *
 232  * @param cls unused, NULL
 233  */
 234 static void
 235 shutdown_task (void *cls)
 236 {
 237   struct GNS_TopLevelDomain *tld;
 238
 239   (void) cls;
 240   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 241               "Shutting down!\n");
 242   GNS_interceptor_done ();
 243   GNS_resolver_done ();
 244   if (NULL != statistics)
 245   {
 246     GNUNET_STATISTICS_destroy (statistics,
 247                                GNUNET_NO);
 248     statistics = NULL;
 249   }
 250   if (NULL != namecache_handle)
 251   {
 252     GNUNET_NAMECACHE_disconnect (namecache_handle);
 253     namecache_handle = NULL;
 254   }
 255   if (NULL != dht_handle)
 256   {
 257     GNUNET_DHT_disconnect (dht_handle);
 258     dht_handle = NULL;
 259   }
 260   while (NULL != (tld = tld_head))
 261   {
 262     GNUNET_CONTAINER_DLL_remove (tld_head,
 263                                  tld_tail,
 264                                  tld);
 265     GNUNET_free (tld->tld);
 266     GNUNET_free (tld);
 267   }
 268 }
 269
 270
 271 /**
 272  * Called whenever a client is disconnected.
 273  *
 274  * @param cls closure
 275  * @param client identification of the client
 276  * @param app_ctx @a client
 277  */
 278 static void
 279 client_disconnect_cb (void *cls,
 280                       struct GNUNET_SERVICE_Client *client,
 281                       void *app_ctx)
 282 {
 283   struct ClientLookupHandle *clh;
 284   struct GnsClient *gc = app_ctx;
 285
 286   (void) cls;
 287   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 288               "Client %p disconnected\n",
 289               client);
 290   while (NULL != (clh = gc->clh_head))
 291   {
 292     if (NULL != clh->lookup)
 293       GNS_resolver_lookup_cancel (clh->lookup);
 294     GNUNET_CONTAINER_DLL_remove (gc->clh_head,
 295                                  gc->clh_tail,
 296                                  clh);
 297     GNUNET_free (clh);
 298   }
 299
 300   GNUNET_free (gc);
 301 }
 302
 303
 304 /**
 305  * Add a client to our list of active clients.
 306  *
 307  * @param cls NULL
 308  * @param client client to add
 309  * @param mq message queue for @a client
 310  * @return internal namestore client structure for this client
 311  */
 312 static void *
 313 client_connect_cb (void *cls,
 314                    struct GNUNET_SERVICE_Client *client,
 315                    struct GNUNET_MQ_Handle *mq)
 316 {
 317   struct GnsClient *gc;
 318
 319   (void) cls;
 320   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 321               "Client %p connected\n",
 322               client);
 323   gc = GNUNET_new (struct GnsClient);
 324   gc->client = client;
 325   gc->mq = mq;
 326   return gc;
 327 }
 328
 329
 330 /**
 331  * Reply to client with the result from our lookup.
 332  *
 333  * @param cls the closure (our client lookup handle)
 334  * @param rd_count the number of records in @a rd
 335  * @param rd the record data
 336  */
 337 static void
 338 send_lookup_response (void* cls,
 339                       uint32_t rd_count,
 340                       const struct GNUNET_GNSRECORD_Data *rd)
 341 {
 342   struct ClientLookupHandle *clh = cls;
 343   struct GNUNET_MQ_Envelope *env;
 344   struct LookupResultMessage *rmsg;
 345   size_t len;
 346
 347   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 348               "Sending LOOKUP_RESULT message with %u results\n",
 349               (unsigned int) rd_count);
 350
 351   len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
 352   env = GNUNET_MQ_msg_extra (rmsg,
 353                              len,
 354                              GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
 355   rmsg->id = clh->request_id;
 356   rmsg->rd_count = htonl (rd_count);
 357   GNUNET_GNSRECORD_records_serialize (rd_count, rd, len,
 358                                       (char*) &rmsg[1]);
 359   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq(clh->gc->client),
 360                   env);
 361   GNUNET_CONTAINER_DLL_remove (clh->gc->clh_head,
 362                                clh->gc->clh_tail,
 363                                clh);
 364   GNUNET_free (clh);
 365   GNUNET_STATISTICS_update (statistics,
 366                             "Completed lookups", 1,
 367                             GNUNET_NO);
 368   GNUNET_STATISTICS_update (statistics,
 369                             "Records resolved",
 370                             rd_count,
 371                             GNUNET_NO);
 372 }
 373
 374
 375 /**
 376  * Checks a #GNUNET_MESSAGE_TYPE_GNS_LOOKUP message
 377  *
 378  * @param cls client sending the message
 379  * @param l_msg message of type `struct LookupMessage`
 380  * @return #GNUNET_OK if @a l_msg is well-formed
 381  */
 382 static int
 383 check_lookup (void *cls,
 384               const struct LookupMessage *l_msg)
 385 {
 386   size_t msg_size;
 387   const char* name;
 388
 389   (void) cls;
 390   msg_size = ntohs (l_msg->header.size);
 391   if (msg_size < sizeof (struct LookupMessage))
 392   {
 393     GNUNET_break (0);
 394     return GNUNET_SYSERR;
 395   }
 396   name = (const char *) &l_msg[1];
 397   if ( ('\0' != name[msg_size - sizeof (struct LookupMessage) - 1]) ||
 398        (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) )
 399   {
 400     GNUNET_break (0);
 401     return GNUNET_SYSERR;
 402   }
 403   return GNUNET_OK;
 404 }
 405
 406
 407 /**
 408  * Handle lookup requests from client
 409  *
 410  * @param cls the closure
 411  * @param client the client
 412  * @param message the message
 413  */
 414 static void
 415 handle_lookup (void *cls,
 416                const struct LookupMessage *sh_msg)
 417 {
 418   struct GnsClient *gc = cls;
 419   char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 1];
 420   struct ClientLookupHandle *clh;
 421   char *nameptr = name;
 422   const char *utf_in;
 423
 424   GNUNET_SERVICE_client_continue (gc->client);
 425   utf_in = (const char *) &sh_msg[1];
 426   GNUNET_STRINGS_utf8_tolower (utf_in,
 427                                nameptr);
 428   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 429               "Received LOOKUP `%s' message\n",
 430               name);
 431
 432   clh = GNUNET_new (struct ClientLookupHandle);
 433   GNUNET_CONTAINER_DLL_insert (gc->clh_head,
 434                                gc->clh_tail,
 435                                clh);
 436   clh->gc = gc;
 437   clh->request_id = sh_msg->id;
 438   if ( (GNUNET_DNSPARSER_TYPE_A == ntohl (sh_msg->type)) &&
 439        (GNUNET_OK != v4_enabled) )
 440   {
 441     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 442                 "LOOKUP: Query for A record but AF_INET not supported!");
 443     send_lookup_response (clh,
 444                           0,
 445                           NULL);
 446     return;
 447   }
 448   if ( (GNUNET_DNSPARSER_TYPE_AAAA == ntohl (sh_msg->type)) &&
 449        (GNUNET_OK != v6_enabled) )
 450   {
 451     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 452                 "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
 453     send_lookup_response (clh,
 454                           0,
 455                           NULL);
 456     return;
 457   }
 458   clh->lookup = GNS_resolver_lookup (&sh_msg->zone,
 459                                      ntohl (sh_msg->type),
 460                                      name,
 461                                      (enum GNUNET_GNS_LocalOptions) ntohs (sh_msg->options),
 462                                      &send_lookup_response, clh);
 463   GNUNET_STATISTICS_update (statistics,
 464                             "Lookup attempts",
 465                             1, GNUNET_NO);
 466 }
 467
 468
 469 /**
 470  * Reads the configuration and populates TLDs
 471  *
 472  * @param cls unused
 473  * @param section name of section in config, always "gns"
 474  * @param option name of the option, TLDs start with "."
 475  * @param value value for the option, public key for TLDs
 476  */
 477 static void
 478 read_service_conf (void *cls,
 479                    const char *section,
 480                    const char *option,
 481                    const char *value)
 482 {
 483   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 484   struct GNS_TopLevelDomain *tld;
 485
 486   (void) cls;
 487   (void) section;
 488   if (option[0] != '.')
 489     return;
 490   if (GNUNET_OK !=
 491       GNUNET_STRINGS_string_to_data (value,
 492                                      strlen (value),
 493                                      &pk,
 494                                      sizeof (pk)))
 495   {
 496     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
 497                                section,
 498                                option,
 499                                _("Properly base32-encoded public key required"));
 500     return;
 501   }
 502   tld = GNUNET_new (struct GNS_TopLevelDomain);
 503   tld->tld = GNUNET_strdup (&option[1]);
 504   tld->pkey = pk;
 505   GNUNET_CONTAINER_DLL_insert (tld_head,
 506                                tld_tail,
 507                                tld);
 508 }
 509
 510
 511 /**
 512  * Process GNS requests.
 513  *
 514  * @param cls closure
 515  * @param server the initialized server
 516  * @param c configuration to use
 517  */
 518 static void
 519 run (void *cls,
 520      const struct GNUNET_CONFIGURATION_Handle *c,
 521      struct GNUNET_SERVICE_Handle *service)
 522 {
 523   unsigned long long max_parallel_bg_queries = 16;
 524
 525   GNUNET_CONFIGURATION_iterate_section_values (c,
 526                                                "gns",
 527                                                &read_service_conf,
 528                                                NULL);
 529   v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
 530   v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
 531   namecache_handle = GNUNET_NAMECACHE_connect (c);
 532   if (NULL == namecache_handle)
 533   {
 534     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 535                 _("Failed to connect to the namecache!\n"));
 536     GNUNET_SCHEDULER_shutdown ();
 537     return;
 538   }
 539   if (GNUNET_OK ==
 540       GNUNET_CONFIGURATION_get_value_number (c,
 541                                              "gns",
 542                                              "MAX_PARALLEL_BACKGROUND_QUERIES",
 543                                              &max_parallel_bg_queries))
 544   {
 545     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 546                 "Number of allowed parallel background queries: %llu\n",
 547                 max_parallel_bg_queries);
 548   }
 549   dht_handle = GNUNET_DHT_connect (c,
 550                                    (unsigned int) max_parallel_bg_queries);
 551   if (NULL == dht_handle)
 552   {
 553     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 554                 _("Could not connect to DHT!\n"));
 555     GNUNET_SCHEDULER_add_now (&shutdown_task,
 556                               NULL);
 557     return;
 558   }
 559   GNS_resolver_init (namecache_handle,
 560                      dht_handle,
 561                      c,
 562                      max_parallel_bg_queries);
 563   if ( (GNUNET_YES ==
 564         GNUNET_CONFIGURATION_get_value_yesno (c,
 565                                               "gns",
 566                                               "INTERCEPT_DNS")) &&
 567        (GNUNET_SYSERR ==
 568         GNS_interceptor_init (c)) )
 569   {
 570     GNUNET_break (0);
 571     GNUNET_SCHEDULER_add_now (&shutdown_task,
 572                               NULL);
 573     return;
 574   }
 575   statistics = GNUNET_STATISTICS_create ("gns",
 576                                          c);
 577   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
 578                                  NULL);
 579 }
 580
 581
 582 /**
 583  * Define "main" method using service macro.
 584  */
 585 GNUNET_SERVICE_MAIN
 586 ("gns",
 587  GNUNET_SERVICE_OPTION_NONE,
 588  &run,
 589  &client_connect_cb,
 590  &client_disconnect_cb,
 591  NULL,
 592  GNUNET_MQ_hd_var_size (lookup,
 593                         GNUNET_MESSAGE_TYPE_GNS_LOOKUP,
 594                         struct LookupMessage,
 595                         NULL),
 596  GNUNET_MQ_handler_end());
 597
 598
 599 /* end of gnunet-service-gns.c */