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   GNUNET_free (gc);
 300 }
 301
 302
 303 /**
 304  * Add a client to our list of active clients.
 305  *
 306  * @param cls NULL
 307  * @param client client to add
 308  * @param mq message queue for @a client
 309  * @return internal namestore client structure for this client
 310  */
 311 static void *
 312 client_connect_cb (void *cls,
 313                    struct GNUNET_SERVICE_Client *client,
 314                    struct GNUNET_MQ_Handle *mq)
 315 {
 316   struct GnsClient *gc;
 317
 318   (void) cls;
 319   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 320               "Client %p connected\n",
 321               client);
 322   gc = GNUNET_new (struct GnsClient);
 323   gc->client = client;
 324   gc->mq = mq;
 325   return gc;
 326 }
 327
 328
 329 /**
 330  * Reply to client with the result from our lookup.
 331  *
 332  * @param cls the closure (our client lookup handle)
 333  * @param rd_count the number of records in @a rd
 334  * @param rd the record data
 335  */
 336 static void
 337 send_lookup_response (void* cls,
 338                       uint32_t rd_count,
 339                       const struct GNUNET_GNSRECORD_Data *rd)
 340 {
 341   struct ClientLookupHandle *clh = cls;
 342   struct GnsClient *gc = clh->gc;
 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   len = GNUNET_GNSRECORD_records_get_size (rd_count,
 351                                            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,
 358                                       rd,
 359                                       len,
 360                                       (char*) &rmsg[1]);
 361   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (gc->client),
 362                   env);
 363   GNUNET_CONTAINER_DLL_remove (gc->clh_head,
 364                                gc->clh_tail,
 365                                clh);
 366   GNUNET_free (clh);
 367   GNUNET_STATISTICS_update (statistics,
 368                             "Completed lookups", 1,
 369                             GNUNET_NO);
 370   GNUNET_STATISTICS_update (statistics,
 371                             "Records resolved",
 372                             rd_count,
 373                             GNUNET_NO);
 374 }
 375
 376
 377 /**
 378  * Checks a #GNUNET_MESSAGE_TYPE_GNS_LOOKUP message
 379  *
 380  * @param cls client sending the message
 381  * @param l_msg message of type `struct LookupMessage`
 382  * @return #GNUNET_OK if @a l_msg is well-formed
 383  */
 384 static int
 385 check_lookup (void *cls,
 386               const struct LookupMessage *l_msg)
 387 {
 388   size_t msg_size;
 389   const char* name;
 390
 391   (void) cls;
 392   msg_size = ntohs (l_msg->header.size);
 393   if (msg_size < sizeof (struct LookupMessage))
 394   {
 395     GNUNET_break (0);
 396     return GNUNET_SYSERR;
 397   }
 398   name = (const char *) &l_msg[1];
 399   if ( ('\0' != name[msg_size - sizeof (struct LookupMessage) - 1]) ||
 400        (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) )
 401   {
 402     GNUNET_break (0);
 403     return GNUNET_SYSERR;
 404   }
 405   return GNUNET_OK;
 406 }
 407
 408
 409 /**
 410  * Handle lookup requests from client
 411  *
 412  * @param cls the closure
 413  * @param client the client
 414  * @param message the message
 415  */
 416 static void
 417 handle_lookup (void *cls,
 418                const struct LookupMessage *sh_msg)
 419 {
 420   struct GnsClient *gc = cls;
 421   char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 1];
 422   struct ClientLookupHandle *clh;
 423   char *nameptr = name;
 424   const char *utf_in;
 425
 426   GNUNET_SERVICE_client_continue (gc->client);
 427   utf_in = (const char *) &sh_msg[1];
 428   GNUNET_STRINGS_utf8_tolower (utf_in,
 429                                nameptr);
 430   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 431               "Received LOOKUP `%s' message\n",
 432               name);
 433   clh = GNUNET_new (struct ClientLookupHandle);
 434   GNUNET_CONTAINER_DLL_insert (gc->clh_head,
 435                                gc->clh_tail,
 436                                clh);
 437   clh->gc = gc;
 438   clh->request_id = sh_msg->id;
 439   if ( (GNUNET_DNSPARSER_TYPE_A == ntohl (sh_msg->type)) &&
 440        (GNUNET_OK != v4_enabled) )
 441   {
 442     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 443                 "LOOKUP: Query for A record but AF_INET not supported!");
 444     send_lookup_response (clh,
 445                           0,
 446                           NULL);
 447     return;
 448   }
 449   if ( (GNUNET_DNSPARSER_TYPE_AAAA == ntohl (sh_msg->type)) &&
 450        (GNUNET_OK != v6_enabled) )
 451   {
 452     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 453                 "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
 454     send_lookup_response (clh,
 455                           0,
 456                           NULL);
 457     return;
 458   }
 459   clh->lookup = GNS_resolver_lookup (&sh_msg->zone,
 460                                      ntohl (sh_msg->type),
 461                                      name,
 462                                      (enum GNUNET_GNS_LocalOptions) ntohs (sh_msg->options),
 463                                      &send_lookup_response, clh);
 464   GNUNET_STATISTICS_update (statistics,
 465                             "Lookup attempts",
 466                             1, GNUNET_NO);
 467 }
 468
 469
 470 /**
 471  * Reads the configuration and populates TLDs
 472  *
 473  * @param cls unused
 474  * @param section name of section in config, always "gns"
 475  * @param option name of the option, TLDs start with "."
 476  * @param value value for the option, public key for TLDs
 477  */
 478 static void
 479 read_service_conf (void *cls,
 480                    const char *section,
 481                    const char *option,
 482                    const char *value)
 483 {
 484   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 485   struct GNS_TopLevelDomain *tld;
 486
 487   (void) cls;
 488   (void) section;
 489   if (option[0] != '.')
 490     return;
 491   if (GNUNET_OK !=
 492       GNUNET_STRINGS_string_to_data (value,
 493                                      strlen (value),
 494                                      &pk,
 495                                      sizeof (pk)))
 496   {
 497     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
 498                                section,
 499                                option,
 500                                _("Properly base32-encoded public key required"));
 501     return;
 502   }
 503   tld = GNUNET_new (struct GNS_TopLevelDomain);
 504   tld->tld = GNUNET_strdup (&option[1]);
 505   tld->pkey = pk;
 506   GNUNET_CONTAINER_DLL_insert (tld_head,
 507                                tld_tail,
 508                                tld);
 509 }
 510
 511
 512 /**
 513  * Process GNS requests.
 514  *
 515  * @param cls closure
 516  * @param server the initialized server
 517  * @param c configuration to use
 518  */
 519 static void
 520 run (void *cls,
 521      const struct GNUNET_CONFIGURATION_Handle *c,
 522      struct GNUNET_SERVICE_Handle *service)
 523 {
 524   unsigned long long max_parallel_bg_queries = 16;
 525
 526   GNUNET_CONFIGURATION_iterate_section_values (c,
 527                                                "gns",
 528                                                &read_service_conf,
 529                                                NULL);
 530   v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
 531   v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
 532   namecache_handle = GNUNET_NAMECACHE_connect (c);
 533   if (NULL == namecache_handle)
 534   {
 535     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 536                 _("Failed to connect to the namecache!\n"));
 537     GNUNET_SCHEDULER_shutdown ();
 538     return;
 539   }
 540   if (GNUNET_OK ==
 541       GNUNET_CONFIGURATION_get_value_number (c,
 542                                              "gns",
 543                                              "MAX_PARALLEL_BACKGROUND_QUERIES",
 544                                              &max_parallel_bg_queries))
 545   {
 546     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 547                 "Number of allowed parallel background queries: %llu\n",
 548                 max_parallel_bg_queries);
 549   }
 550   dht_handle = GNUNET_DHT_connect (c,
 551                                    (unsigned int) max_parallel_bg_queries);
 552   if (NULL == dht_handle)
 553   {
 554     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 555                 _("Could not connect to DHT!\n"));
 556     GNUNET_SCHEDULER_add_now (&shutdown_task,
 557                               NULL);
 558     return;
 559   }
 560   GNS_resolver_init (namecache_handle,
 561                      dht_handle,
 562                      c,
 563                      max_parallel_bg_queries);
 564   if ( (GNUNET_YES ==
 565         GNUNET_CONFIGURATION_get_value_yesno (c,
 566                                               "gns",
 567                                               "INTERCEPT_DNS")) &&
 568        (GNUNET_SYSERR ==
 569         GNS_interceptor_init (c)) )
 570   {
 571     GNUNET_break (0);
 572     GNUNET_SCHEDULER_add_now (&shutdown_task,
 573                               NULL);
 574     return;
 575   }
 576   statistics = GNUNET_STATISTICS_create ("gns",
 577                                          c);
 578   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
 579                                  NULL);
 580 }
 581
 582
 583 /**
 584  * Define "main" method using service macro.
 585  */
 586 GNUNET_SERVICE_MAIN
 587 ("gns",
 588  GNUNET_SERVICE_OPTION_NONE,
 589  &run,
 590  &client_connect_cb,
 591  &client_disconnect_cb,
 592  NULL,
 593  GNUNET_MQ_hd_var_size (lookup,
 594                         GNUNET_MESSAGE_TYPE_GNS_LOOKUP,
 595                         struct LookupMessage,
 596                         NULL),
 597  GNUNET_MQ_handler_end());
 598
 599
 600 /* end of gnunet-service-gns.c */