src/gns/gnunet-service-gns_resolver.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011-2013 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 /**
  22  * @file gns/gnunet-service-gns_resolver.c
  23  * @brief GNU Name System resolver logic
  24  * @author Martin Schanzenbach
  25  * @author Christian Grothoff
  26  *
  27  * TODO:
  28  * - GNS: handle special SRV names --- no delegation, direct lookup;
  29  *        can likely be done in 'resolver_lookup_get_next_label'. (#3003)
  30  * - revocation checks (use REVOCATION service!), (#3004)
  31  * - DNAME support (#3005)
  32  */
  33 #include "platform.h"
  34 #include "gnunet_util_lib.h"
  35 #include "gnunet_dnsstub_lib.h"
  36 #include "gnunet_dht_service.h"
  37 #include "gnunet_gnsrecord_lib.h"
  38 #include "gnunet_namecache_service.h"
  39 #include "gnunet_namestore_service.h"
  40 #include "gnunet_dns_service.h"
  41 #include "gnunet_resolver_service.h"
  42 #include "gnunet_dnsparser_lib.h"
  43 #include "gnunet_gns_service.h"
  44 #include "gns.h"
  45 #include "gnunet-service-gns_resolver.h"
  46 #include "gnunet-service-gns_shorten.h"
  47 #include "gnunet_vpn_service.h"
  48
  49
  50 /**
  51  * Default DHT timeout for lookups.
  52  */
  53 #define DHT_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  54
  55 /**
  56  * Default timeout for DNS lookups.
  57  */
  58 #define DNS_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  59
  60 /**
  61  * Default timeout for VPN redirections.
  62  */
  63 #define VPN_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
  64
  65 /**
  66  * DHT replication level
  67  */
  68 #define DHT_GNS_REPLICATION_LEVEL 5
  69
  70 /**
  71  * How deep do we allow recursions to go before we abort?
  72  */
  73 #define MAX_RECURSION 256
  74
  75
  76 /**
  77  * DLL to hold the authority chain we had to pass in the resolution
  78  * process.
  79  */
  80 struct AuthorityChain
  81 {
  82   /**
  83    * This is a DLL.
  84    */
  85   struct AuthorityChain *prev;
  86
  87   /**
  88    * This is a DLL.
  89    */
  90   struct AuthorityChain *next;
  91
  92   /**
  93    * Resolver handle this entry in the chain belongs to.
  94    */
  95   struct GNS_ResolverHandle *rh;
  96
  97   /**
  98    * label/name corresponding to the authority
  99    */
 100   char *label;
 101
 102   /**
 103    * #GNUNET_YES if the authority was a GNS authority,
 104    * #GNUNET_NO if the authority was a DNS authority.
 105    */
 106   int gns_authority;
 107
 108   /**
 109    * Information about the resolver authority for this label.
 110    */
 111   union
 112   {
 113
 114     /**
 115      * The zone of the GNS authority
 116      */
 117     struct GNUNET_CRYPTO_EcdsaPublicKey gns_authority;
 118
 119     struct
 120     {
 121       /**
 122        * Domain of the DNS resolver that is the authority.
 123        * (appended to construct the DNS name to resolve;
 124        * this is NOT the DNS name of the DNS server!).
 125        */
 126       char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 1];
 127
 128       /**
 129        * IP address of the DNS resolver that is authoritative.
 130        * (this implementation currently only supports one
 131        * IP at a time).
 132        */
 133       struct sockaddr_storage dns_ip;
 134
 135     } dns_authority;
 136
 137   } authority_info;
 138
 139 };
 140
 141
 142 /**
 143  * A result we got from DNS.
 144  */
 145 struct DnsResult
 146 {
 147
 148   /**
 149    * Kept in DLL.
 150    */
 151   struct DnsResult *next;
 152
 153   /**
 154    * Kept in DLL.
 155    */
 156   struct DnsResult *prev;
 157
 158   /**
 159    * Binary value stored in the DNS record (appended to this struct)
 160    */
 161   const void *data;
 162
 163   /**
 164    * Expiration time for the DNS record, 0 if we didn't
 165    * get anything useful (i.e. 'gethostbyname' was used).
 166    */
 167   uint64_t expiration_time;
 168
 169   /**
 170    * Number of bytes in 'data'.
 171    */
 172   size_t data_size;
 173
 174   /**
 175    * Type of the GNS/DNS record.
 176    */
 177   uint32_t record_type;
 178
 179 };
 180
 181
 182 /**
 183  * Closure for #vpn_allocation_cb.
 184  */
 185 struct VpnContext
 186 {
 187
 188   /**
 189    * Which resolution process are we processing.
 190    */
 191   struct GNS_ResolverHandle *rh;
 192
 193   /**
 194    * Handle to the VPN request that we were performing.
 195    */
 196   struct GNUNET_VPN_RedirectionRequest *vpn_request;
 197
 198   /**
 199    * Number of records serialized in @e rd_data.
 200    */
 201   unsigned int rd_count;
 202
 203   /**
 204    * Serialized records.
 205    */
 206   char *rd_data;
 207
 208   /**
 209    * Number of bytes in @e rd_data.
 210    */
 211   size_t rd_data_size;
 212 };
 213
 214
 215 /**
 216  * Handle to a currenty pending resolution.  On result (positive or
 217  * negative) the #GNS_ResultProcessor is called.
 218  */
 219 struct GNS_ResolverHandle
 220 {
 221
 222   /**
 223    * DLL
 224    */
 225   struct GNS_ResolverHandle *next;
 226
 227   /**
 228    * DLL
 229    */
 230   struct GNS_ResolverHandle *prev;
 231
 232   /**
 233    * The top-level GNS authoritative zone to query
 234    */
 235   struct GNUNET_CRYPTO_EcdsaPublicKey authority_zone;
 236
 237   /**
 238    * called when resolution phase finishes
 239    */
 240   GNS_ResultProcessor proc;
 241
 242   /**
 243    * closure passed to proc
 244    */
 245   void* proc_cls;
 246
 247   /**
 248    * Handle for DHT lookups. should be NULL if no lookups are in progress
 249    */
 250   struct GNUNET_DHT_GetHandle *get_handle;
 251
 252   /**
 253    * Handle to a VPN request, NULL if none is active.
 254    */
 255   struct VpnContext *vpn_ctx;
 256
 257   /**
 258    * Socket for a DNS request, NULL if none is active.
 259    */
 260   struct GNUNET_DNSSTUB_RequestSocket *dns_request;
 261
 262   /**
 263    * Handle for standard DNS resolution, NULL if none is active.
 264    */
 265   struct GNUNET_RESOLVER_RequestHandle *std_resolve;
 266
 267   /**
 268    * Pending Namecache lookup task
 269    */
 270   struct GNUNET_NAMECACHE_QueueEntry *namecache_qe;
 271
 272   /**
 273    * Heap node associated with this lookup.  Used to limit number of
 274    * concurrent requests.
 275    */
 276   struct GNUNET_CONTAINER_HeapNode *dht_heap_node;
 277
 278   /**
 279    * DLL to store the authority chain
 280    */
 281   struct AuthorityChain *ac_head;
 282
 283   /**
 284    * DLL to store the authority chain
 285    */
 286   struct AuthorityChain *ac_tail;
 287
 288   /**
 289    * Private key of the shorten zone, NULL to not shorten.
 290    */
 291   struct GNUNET_CRYPTO_EcdsaPrivateKey *shorten_key;
 292
 293   /**
 294    * ID of a task associated with the resolution process.
 295    */
 296   GNUNET_SCHEDULER_TaskIdentifier task_id;
 297
 298   /**
 299    * The name to resolve
 300    */
 301   char *name;
 302
 303   /**
 304    * DLL of results we got from DNS.
 305    */
 306   struct DnsResult *dns_result_head;
 307
 308   /**
 309    * DLL of results we got from DNS.
 310    */
 311   struct DnsResult *dns_result_tail;
 312
 313   /**
 314    * Current offset in 'name' where we are resolving.
 315    */
 316   size_t name_resolution_pos;
 317
 318   /**
 319    * Use only cache
 320    */
 321   int only_cached;
 322
 323   /**
 324    * Desired type for the resolution.
 325    */
 326   int record_type;
 327
 328   /**
 329    * We increment the loop limiter for each step in a recursive
 330    * resolution.  If it passes our threshold (i.e. due to
 331    * self-recursion in the resolution, i.e CNAME fun), we stop.
 332    */
 333   unsigned int loop_limiter;
 334
 335 };
 336
 337
 338 /**
 339  * Active namestore caching operations.
 340  */
 341 struct CacheOps
 342 {
 343
 344   /**
 345    * Organized in a DLL.
 346    */
 347   struct CacheOps *next;
 348
 349   /**
 350    * Organized in a DLL.
 351    */
 352   struct CacheOps *prev;
 353
 354   /**
 355    * Pending Namestore caching task.
 356    */
 357   struct GNUNET_NAMECACHE_QueueEntry *namecache_qe_cache;
 358
 359 };
 360
 361
 362 /**
 363  * Our handle to the namestore service
 364  */
 365 static struct GNUNET_NAMESTORE_Handle *namestore_handle;
 366
 367 /**
 368  * Our handle to the namecache service
 369  */
 370 static struct GNUNET_NAMECACHE_Handle *namecache_handle;
 371
 372 /**
 373  * Our handle to the vpn service
 374  */
 375 static struct GNUNET_VPN_Handle *vpn_handle;
 376
 377 /**
 378  * Resolver handle to the dht
 379  */
 380 static struct GNUNET_DHT_Handle *dht_handle;
 381
 382 /**
 383  * Handle to perform DNS lookups.
 384  */
 385 static struct GNUNET_DNSSTUB_Context *dns_handle;
 386
 387 /**
 388  * Heap for limiting parallel DHT lookups
 389  */
 390 static struct GNUNET_CONTAINER_Heap *dht_lookup_heap;
 391
 392 /**
 393  * Maximum amount of parallel queries to the DHT
 394  */
 395 static unsigned long long max_allowed_background_queries;
 396
 397 /**
 398  * Head of resolver lookup list
 399  */
 400 static struct GNS_ResolverHandle *rlh_head;
 401
 402 /**
 403  * Tail of resolver lookup list
 404  */
 405 static struct GNS_ResolverHandle *rlh_tail;
 406
 407 /**
 408  * Organized in a DLL.
 409  */
 410 static struct CacheOps *co_head;
 411
 412 /**
 413  * Organized in a DLL.
 414  */
 415 static struct CacheOps *co_tail;
 416
 417
 418 /**
 419  * Global configuration.
 420  */
 421 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 422
 423 #if 0
 424 /**
 425  * Check if name is in srv format (_x._y.xxx)
 426  *
 427  * @param name
 428  * @return #GNUNET_YES if true
 429  */
 430 static int
 431 is_srv (const char *name)
 432 {
 433   char *ndup;
 434   int ret;
 435
 436   if (*name != '_')
 437     return GNUNET_NO;
 438   if (NULL == strstr (name, "._"))
 439     return GNUNET_NO;
 440   ret = GNUNET_YES;
 441   ndup = GNUNET_strdup (name);
 442   strtok (ndup, ".");
 443   if (NULL == strtok (NULL, "."))
 444     ret = GNUNET_NO;
 445   if (NULL == strtok (NULL, "."))
 446     ret = GNUNET_NO;
 447   if (NULL != strtok (NULL, "."))
 448     ret = GNUNET_NO;
 449   GNUNET_free (ndup);
 450   return ret;
 451 }
 452 #endif
 453
 454
 455 /**
 456  * Determine if this name is canonical (is a legal name in a zone, without delegation);
 457  * note that we do not test that the name does not contain illegal characters, we only
 458  * test for delegation.  Note that service records (i.e. _foo._srv) are canonical names
 459  * even though they consist of multiple labels.
 460  *
 461  * Examples:
 462  * a.b.gnu  = not canonical
 463  * a         = canonical
 464  * _foo._srv = canonical
 465  * _f.bar    = not canonical
 466  *
 467  * @param name the name to test
 468  * @return #GNUNET_YES if canonical
 469  */
 470 static int
 471 is_canonical (const char *name)
 472 {
 473   const char *pos;
 474   const char *dot;
 475
 476   if (NULL == strchr (name, '.'))
 477     return GNUNET_YES;
 478   if ('_' != name[0])
 479     return GNUNET_NO;
 480   pos = &name[1];
 481   while (NULL != (dot = strchr (pos, '.')))
 482     if ('_' != dot[1])
 483       return GNUNET_NO;
 484     else
 485       pos = dot + 1;
 486   return GNUNET_YES;
 487 }
 488
 489 /* ************************** Resolution **************************** */
 490
 491 /**
 492  * Expands a name ending in .+ with the zone of origin.
 493  *
 494  * @param rh resolution context
 495  * @param name name to modify (to be free'd or returned)
 496  * @return updated name
 497  */
 498 static char *
 499 translate_dot_plus (struct GNS_ResolverHandle *rh,
 500                     char *name)
 501 {
 502   char *ret;
 503   size_t s_len = strlen (name);
 504
 505   if (0 != strcmp (&name[s_len - 2],
 506                    ".+"))
 507     return name; /* did not end in ".+" */
 508   GNUNET_assert (GNUNET_YES == rh->ac_tail->gns_authority);
 509   GNUNET_asprintf (&ret,
 510                    "%.*s.%s",
 511                    (int) (s_len - 2),
 512                    name,
 513                    GNUNET_GNSRECORD_pkey_to_zkey (&rh->ac_tail->authority_info.gns_authority));
 514   GNUNET_free (name);
 515   return ret;
 516 }
 517
 518
 519 /**
 520  * Task scheduled to asynchronously fail a resolution.
 521  *
 522  * @param cls the 'struct GNS_ResolverHandle' of the resolution to fail
 523  * @param tc task context
 524  */
 525 static void
 526 fail_resolution (void *cls,
 527                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 528 {
 529   struct GNS_ResolverHandle *rh = cls;
 530
 531   rh->task_id = GNUNET_SCHEDULER_NO_TASK;
 532   rh->proc (rh->proc_cls, 0, NULL);
 533   GNS_resolver_lookup_cancel (rh);
 534 }
 535
 536
 537 #if (defined WINDOWS) || (defined DARWIN)
 538 /* Don't have this on W32, here's a naive implementation
 539  * Was somehow removed on OS X ...  */
 540 void *
 541 memrchr (const void *s,
 542          int c,
 543          size_t n)
 544 {
 545   const unsigned char *ucs = s;
 546   ssize_t i;
 547
 548   for (i = n - 1; i >= 0; i--)
 549     if (c == (int) ucs[i])
 550       return (void *) &ucs[i];
 551   return NULL;
 552 }
 553 #endif
 554
 555
 556 /**
 557  * Get the next, rightmost label from the name that we are trying to resolve,
 558  * and update the resolution position accordingly.
 559  *
 560  * @param rh handle to the resolution operation to get the next label from
 561  * @return NULL if there are no more labels
 562  */
 563 static char *
 564 resolver_lookup_get_next_label (struct GNS_ResolverHandle *rh)
 565 {
 566   const char *rp;
 567   const char *dot;
 568   size_t len;
 569
 570   if (0 == rh->name_resolution_pos)
 571     return NULL;
 572   dot = memrchr (rh->name, (int) '.', rh->name_resolution_pos);
 573   if (NULL == dot)
 574   {
 575     /* done, this was the last one */
 576     len = rh->name_resolution_pos;
 577     rp = rh->name;
 578     rh->name_resolution_pos = 0;
 579   }
 580   else
 581   {
 582     /* advance by one label */
 583     len = rh->name_resolution_pos - (dot - rh->name) - 1;
 584     rp = dot + 1;
 585     rh->name_resolution_pos = dot - rh->name;
 586   }
 587   return GNUNET_strndup (rp, len);
 588 }
 589
 590
 591 /**
 592  * Gives the cummulative result obtained to the callback and clean up the request.
 593  *
 594  * @param rh resolution process that has culminated in a result
 595  */
 596 static void
 597 transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
 598 {
 599   struct DnsResult *pos;
 600   unsigned int n;
 601   unsigned int i;
 602
 603   n = 0;
 604   for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
 605     n++;
 606   {
 607     struct GNUNET_GNSRECORD_Data rd[n];
 608
 609     i = 0;
 610     for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
 611     {
 612       rd[i].data = pos->data;
 613       rd[i].data_size = pos->data_size;
 614       rd[i].record_type = pos->record_type;
 615       if (0 == pos->expiration_time)
 616       {
 617         rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
 618         rd[i].expiration_time = 0;
 619       }
 620       else
 621       {
 622         rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
 623         rd[i].expiration_time = pos->expiration_time;
 624       }
 625       i++;
 626     }
 627     GNUNET_assert (i == n);
 628     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 629                 "Transmitting standard DNS result with %u records\n",
 630                 n);
 631     rh->proc (rh->proc_cls,
 632               n,
 633               rd);
 634   }
 635   GNS_resolver_lookup_cancel (rh);
 636 }
 637
 638
 639 /**
 640  * Add a result from DNS to the records to be returned to the application.
 641  *
 642  * @param rh resolution request to extend with a result
 643  * @param expiration_time expiration time for the answer
 644  * @param record_type DNS record type of the answer
 645  * @param data_size number of bytes in @a data
 646  * @param data binary data to return in DNS record
 647  */
 648 static void
 649 add_dns_result (struct GNS_ResolverHandle *rh,
 650                 uint64_t expiration_time,
 651                 uint32_t record_type,
 652                 size_t data_size,
 653                 const void *data)
 654 {
 655   struct DnsResult *res;
 656
 657   res = GNUNET_malloc (sizeof (struct DnsResult) + data_size);
 658   res->expiration_time = expiration_time;
 659   res->data_size = data_size;
 660   res->record_type = record_type;
 661   res->data = &res[1];
 662   memcpy (&res[1], data, data_size);
 663   GNUNET_CONTAINER_DLL_insert (rh->dns_result_head,
 664                                rh->dns_result_tail,
 665                                res);
 666 }
 667
 668
 669 /**
 670  * We had to do a DNS lookup.  Convert the result (if any) and return
 671  * it.
 672  *
 673  * @param cls closure with the `struct GNS_ResolverHandle`
 674  * @param addr one of the addresses of the host, NULL for the last address
 675  * @param addrlen length of the address
 676  */
 677 static void
 678 handle_dns_result (void *cls,
 679                    const struct sockaddr *addr,
 680                    socklen_t addrlen)
 681 {
 682   struct GNS_ResolverHandle *rh = cls;
 683   const struct sockaddr_in *sa4;
 684   const struct sockaddr_in6 *sa6;
 685
 686   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 687               "Received %u bytes of DNS IP data\n",
 688               addrlen);
 689   if (NULL == addr)
 690   {
 691     rh->std_resolve = NULL;
 692     transmit_lookup_dns_result (rh);
 693     return;
 694   }
 695   switch (addr->sa_family)
 696   {
 697   case AF_INET:
 698     sa4 = (const struct sockaddr_in *) addr;
 699     add_dns_result (rh,
 700                     0 /* expiration time is unknown */,
 701                     GNUNET_DNSPARSER_TYPE_A,
 702                     sizeof (struct in_addr),
 703                     &sa4->sin_addr);
 704     break;
 705   case AF_INET6:
 706     sa6 = (const struct sockaddr_in6 *) addr;
 707     add_dns_result (rh,
 708                     0 /* expiration time is unknown */,
 709                     GNUNET_DNSPARSER_TYPE_AAAA,
 710                     sizeof (struct in6_addr),
 711                     &sa6->sin6_addr);
 712     break;
 713   default:
 714     GNUNET_break (0);
 715     break;
 716   }
 717 }
 718
 719
 720 /**
 721  * Task scheduled to continue with the resolution process.
 722  *
 723  * @param cls the 'struct GNS_ResolverHandle' of the resolution
 724  * @param tc task context
 725  */
 726 static void
 727 recursive_resolution (void *cls,
 728                       const struct GNUNET_SCHEDULER_TaskContext *tc);
 729
 730
 731 /**
 732  * Begin the resolution process from 'name', starting with
 733  * the identification of the zone specified by 'name'.
 734  *
 735  * @param rh resolution to perform
 736  */
 737 static void
 738 start_resolver_lookup (struct GNS_ResolverHandle *rh);
 739
 740
 741 /**
 742  * Function called with the result of a DNS resolution.
 743  *
 744  * @param cls the request handle of the resolution that
 745  *        we were attempting to make
 746  * @param rs socket that received the response
 747  * @param dns dns response, never NULL
 748  * @param dns_len number of bytes in @a dns
 749  */
 750 static void
 751 dns_result_parser (void *cls,
 752                    struct GNUNET_DNSSTUB_RequestSocket *rs,
 753                    const struct GNUNET_TUN_DnsHeader *dns,
 754                    size_t dns_len)
 755 {
 756   struct GNS_ResolverHandle *rh = cls;
 757   struct GNUNET_DNSPARSER_Packet *p;
 758   const struct GNUNET_DNSPARSER_Record *rec;
 759   unsigned int rd_count;
 760   unsigned int i;
 761
 762   rh->dns_request = NULL;
 763   GNUNET_SCHEDULER_cancel (rh->task_id);
 764   rh->task_id = GNUNET_SCHEDULER_NO_TASK;
 765   p = GNUNET_DNSPARSER_parse ((const char *) dns,
 766                               dns_len);
 767   if (NULL == p)
 768   {
 769     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 770                 _("Failed to parse DNS response\n"));
 771     rh->proc (rh->proc_cls, 0, NULL);
 772     GNS_resolver_lookup_cancel (rh);
 773     return;
 774   }
 775   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 776               "Received DNS response for `%s' with %u answers\n",
 777               rh->ac_tail->label,
 778               (unsigned int) p->num_answers);
 779   if ( (p->num_answers > 0) &&
 780        (GNUNET_DNSPARSER_TYPE_CNAME == p->answers[0].type) &&
 781        (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type) )
 782     {
 783       GNUNET_free (rh->name);
 784       rh->name = GNUNET_strdup (p->answers[0].data.hostname);
 785       start_resolver_lookup (rh);
 786       GNUNET_DNSPARSER_free_packet (p);
 787       return;
 788     }
 789   /* FIXME: add DNAME support */
 790
 791   /* convert from (parsed) DNS to (binary) GNS format! */
 792   rd_count = p->num_answers + p->num_authority_records + p->num_additional_records;
 793   {
 794     struct GNUNET_GNSRECORD_Data rd[rd_count];
 795     unsigned int skip;
 796     char buf[UINT16_MAX];
 797     size_t buf_off;
 798     size_t buf_start;
 799
 800     buf_off = 0;
 801     skip = 0;
 802     memset (rd, 0, sizeof (rd));
 803     for (i=0;i<rd_count;i++)
 804     {
 805       if (i < p->num_answers)
 806         rec = &p->answers[i];
 807       else if (i < p->num_answers + p->num_authority_records)
 808         rec = &p->authority_records[i - p->num_answers];
 809       else
 810         rec = &p->authority_records[i - p->num_answers - p->num_authority_records];
 811       /* As we copied the full DNS name to 'rh->ac_tail->label', this
 812          should be the correct check to see if this record is actually
 813          a record for our label... */
 814       if (0 != strcmp (rec->name,
 815                        rh->ac_tail->label))
 816       {
 817         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 818                     "Dropping record `%s', does not match desired name `%s'\n",
 819                     rec->name,
 820                     rh->ac_tail->label);
 821         skip++;
 822         continue;
 823       }
 824       rd[i - skip].record_type = rec->type;
 825       rd[i - skip].expiration_time = rec->expiration_time.abs_value_us;
 826       switch (rec->type)
 827       {
 828       case GNUNET_DNSPARSER_TYPE_A:
 829         if (rec->data.raw.data_len != sizeof (struct in_addr))
 830         {
 831           GNUNET_break_op (0);
 832           skip++;
 833           continue;
 834         }
 835         rd[i - skip].data_size = rec->data.raw.data_len;
 836         rd[i - skip].data = rec->data.raw.data;
 837         break;
 838       case GNUNET_DNSPARSER_TYPE_AAAA:
 839         if (rec->data.raw.data_len != sizeof (struct in6_addr))
 840         {
 841           GNUNET_break_op (0);
 842           skip++;
 843           continue;
 844         }
 845         rd[i - skip].data_size = rec->data.raw.data_len;
 846         rd[i - skip].data = rec->data.raw.data;
 847         break;
 848       case GNUNET_DNSPARSER_TYPE_CNAME:
 849       case GNUNET_DNSPARSER_TYPE_PTR:
 850       case GNUNET_DNSPARSER_TYPE_NS:
 851         buf_start = buf_off;
 852         if (GNUNET_OK !=
 853             GNUNET_DNSPARSER_builder_add_name (buf,
 854                                                sizeof (buf),
 855                                                &buf_off,
 856                                                rec->data.hostname))
 857         {
 858           GNUNET_break (0);
 859           skip++;
 860           continue;
 861         }
 862         rd[i - skip].data_size = buf_off - buf_start;
 863         rd[i - skip].data = &buf[buf_start];
 864         break;
 865       case GNUNET_DNSPARSER_TYPE_SOA:
 866         buf_start = buf_off;
 867         if (GNUNET_OK !=
 868             GNUNET_DNSPARSER_builder_add_soa (buf,
 869                                                sizeof (buf),
 870                                                &buf_off,
 871                                                rec->data.soa))
 872         {
 873           GNUNET_break (0);
 874           skip++;
 875           continue;
 876         }
 877         rd[i - skip].data_size = buf_off - buf_start;
 878         rd[i - skip].data = &buf[buf_start];
 879         break;
 880       case GNUNET_DNSPARSER_TYPE_MX:
 881         buf_start = buf_off;
 882         if (GNUNET_OK !=
 883             GNUNET_DNSPARSER_builder_add_mx (buf,
 884                                              sizeof (buf),
 885                                              &buf_off,
 886                                              rec->data.mx))
 887         {
 888           GNUNET_break (0);
 889           skip++;
 890           continue;
 891         }
 892         rd[i - skip].data_size = buf_off - buf_start;
 893         rd[i - skip].data = &buf[buf_start];
 894         break;
 895       case GNUNET_DNSPARSER_TYPE_SRV:
 896         buf_start = buf_off;
 897         if (GNUNET_OK !=
 898             GNUNET_DNSPARSER_builder_add_srv (buf,
 899                                               sizeof (buf),
 900                                               &buf_off,
 901                                               rec->data.srv))
 902         {
 903           GNUNET_break (0);
 904           skip++;
 905           continue;
 906         }
 907         rd[i - skip].data_size = buf_off - buf_start;
 908         rd[i - skip].data = &buf[buf_start];
 909         break;
 910       default:
 911         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 912                     _("Skipping record of unsupported type %d\n"),
 913                     rec->type);
 914         skip++;
 915         continue;
 916       }
 917     }
 918     rh->proc (rh->proc_cls, rd_count - skip, rd);
 919     GNS_resolver_lookup_cancel (rh);
 920   }
 921   GNUNET_DNSPARSER_free_packet (p);
 922 }
 923
 924
 925 /**
 926  * Perform recursive DNS resolution.  Asks the given DNS resolver to
 927  * resolve "rh->dns_name", possibly recursively proceeding following
 928  * NS delegations, CNAMES, etc., until 'rh->loop_limiter' bounds us or
 929  * we find the answer.
 930  *
 931  * @param rh resolution information
 932  */
 933 static void
 934 recursive_dns_resolution (struct GNS_ResolverHandle *rh)
 935 {
 936   struct AuthorityChain *ac;
 937   socklen_t sa_len;
 938   struct GNUNET_DNSPARSER_Query *query;
 939   struct GNUNET_DNSPARSER_Packet *p;
 940   char *dns_request;
 941   size_t dns_request_length;
 942
 943   ac = rh->ac_tail;
 944   GNUNET_assert (NULL != ac);
 945   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 946               "Starting DNS lookup for `%s'\n",
 947               ac->label);
 948   GNUNET_assert (GNUNET_NO == ac->gns_authority);
 949   switch (((const struct sockaddr *) &ac->authority_info.dns_authority.dns_ip)->sa_family)
 950   {
 951   case AF_INET:
 952     sa_len = sizeof (struct sockaddr_in);
 953     break;
 954   case AF_INET6:
 955     sa_len = sizeof (struct sockaddr_in6);
 956     break;
 957   default:
 958     GNUNET_break (0);
 959     rh->proc (rh->proc_cls, 0, NULL);
 960     GNS_resolver_lookup_cancel (rh);
 961     return;
 962   }
 963   query = GNUNET_new (struct GNUNET_DNSPARSER_Query);
 964   query->name = GNUNET_strdup (ac->label);
 965   query->type = rh->record_type;
 966   query->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 967   p = GNUNET_new (struct GNUNET_DNSPARSER_Packet);
 968   p->queries = query;
 969   p->num_queries = 1;
 970   p->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
 971                                                UINT16_MAX);
 972   p->flags.opcode = GNUNET_TUN_DNS_OPCODE_QUERY;
 973   p->flags.recursion_desired = 1;
 974   if (GNUNET_OK !=
 975       GNUNET_DNSPARSER_pack (p, 1024, &dns_request, &dns_request_length))
 976   {
 977     GNUNET_break (0);
 978     rh->proc (rh->proc_cls, 0, NULL);
 979     GNS_resolver_lookup_cancel (rh);
 980   }
 981   else
 982   {
 983     rh->dns_request = GNUNET_DNSSTUB_resolve (dns_handle,
 984                                               (const struct sockaddr *) &ac->authority_info.dns_authority.dns_ip,
 985                                               sa_len,
 986                                               dns_request,
 987                                               dns_request_length,
 988                                               &dns_result_parser,
 989                                               rh);
 990     rh->task_id = GNUNET_SCHEDULER_add_delayed (DNS_LOOKUP_TIMEOUT,
 991                                                 &fail_resolution,
 992                                                 rh);
 993   }
 994   GNUNET_free (dns_request);
 995   GNUNET_DNSPARSER_free_packet (p);
 996 }
 997
 998
 999 /**
1000  * We encountered a CNAME record during our resolution.
1001  * Merge it into our chain.
1002  *
1003  * @param rh resolution we are performing
1004  * @param cname value of the cname record we got for the current
1005  *        authority chain tail
1006  */
1007 static void
1008 handle_gns_cname_result (struct GNS_ResolverHandle *rh,
1009                          const char *cname)
1010 {
1011   size_t nlen;
1012   char *res;
1013   struct AuthorityChain *ac;
1014
1015   nlen = strlen (cname);
1016   if ( (nlen > 2) &&
1017        (0 == strcmp (".+",
1018                      &cname[nlen - 2])) )
1019   {
1020     /* CNAME resolution continues relative to current domain */
1021     if (0 == rh->name_resolution_pos)
1022     {
1023       res = GNUNET_strndup (cname, nlen - 2);
1024       rh->name_resolution_pos = nlen - 2;
1025     }
1026     else
1027     {
1028       GNUNET_asprintf (&res,
1029                        "%.*s.%.*s",
1030                        (int) rh->name_resolution_pos,
1031                        rh->name,
1032                        (int) (nlen - 2),
1033                        cname);
1034       rh->name_resolution_pos = strlen (res);
1035     }
1036     GNUNET_free (rh->name);
1037     rh->name = res;
1038     ac = GNUNET_new (struct AuthorityChain);
1039     ac->rh = rh;
1040     ac->gns_authority = GNUNET_YES;
1041     ac->authority_info.gns_authority = rh->ac_tail->authority_info.gns_authority;
1042     ac->label = resolver_lookup_get_next_label (rh);
1043     /* tigger shortening */
1044     if (NULL != rh->shorten_key)
1045       GNS_shorten_start (rh->ac_tail->label,
1046                          &ac->authority_info.gns_authority,
1047                          rh->shorten_key);
1048     /* add AC to tail */
1049     GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
1050                                       rh->ac_tail,
1051                                       ac);
1052     rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
1053                                             rh);
1054     return;
1055   }
1056   /* name is absolute, start from the beginning */
1057   GNUNET_free (rh->name);
1058   rh->name = GNUNET_strdup (cname);
1059   start_resolver_lookup (rh);
1060 }
1061
1062
1063 /**
1064  * Process a records that were decrypted from a block.
1065  *
1066  * @param cls closure with the 'struct GNS_ResolverHandle'
1067  * @param rd_count number of entries in @a rd array
1068  * @param rd array of records with data to store
1069  */
1070 static void
1071 handle_gns_resolution_result (void *cls,
1072                               unsigned int rd_count,
1073                               const struct GNUNET_GNSRECORD_Data *rd);
1074
1075
1076 /**
1077  * Callback invoked from the VPN service once a redirection is
1078  * available.  Provides the IP address that can now be used to
1079  * reach the requested destination.  Replaces the "VPN" record
1080  * with the respective A/AAAA record and continues processing.
1081  *
1082  * @param cls closure
1083  * @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error;
1084  *                will match 'result_af' from the request
1085  * @param address IP address (struct in_addr or struct in_addr6, depending on 'af')
1086  *                that the VPN allocated for the redirection;
1087  *                traffic to this IP will now be redirected to the
1088  *                specified target peer; NULL on error
1089  */
1090 static void
1091 vpn_allocation_cb (void *cls,
1092                    int af,
1093                    const void *address)
1094 {
1095   struct VpnContext *vpn_ctx = cls;
1096   struct GNS_ResolverHandle *rh = vpn_ctx->rh;
1097   struct GNUNET_GNSRECORD_Data rd[vpn_ctx->rd_count];
1098   unsigned int i;
1099
1100   vpn_ctx->vpn_request = NULL;
1101   rh->vpn_ctx = NULL;
1102   GNUNET_assert (GNUNET_OK ==
1103                  GNUNET_GNSRECORD_records_deserialize (vpn_ctx->rd_data_size,
1104                                                        vpn_ctx->rd_data,
1105                                                        vpn_ctx->rd_count,
1106                                                        rd));
1107   for (i=0;i<vpn_ctx->rd_count;i++)
1108   {
1109     if (GNUNET_GNSRECORD_TYPE_VPN == rd[i].record_type)
1110     {
1111       switch (af)
1112       {
1113       case AF_INET:
1114         rd[i].record_type = GNUNET_DNSPARSER_TYPE_A;
1115         rd[i].data_size = sizeof (struct in_addr);
1116         rd[i].expiration_time = GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT).abs_value_us;
1117         rd[i].flags = 0;
1118         rd[i].data = address;
1119         break;
1120       case AF_INET6:
1121         rd[i].record_type = GNUNET_DNSPARSER_TYPE_AAAA;
1122         rd[i].expiration_time = GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT).abs_value_us;
1123         rd[i].flags = 0;
1124         rd[i].data = address;
1125         rd[i].data_size = sizeof (struct in6_addr);
1126         break;
1127       default:
1128         GNUNET_assert (0);
1129       }
1130       break;
1131     }
1132   }
1133   GNUNET_assert (i < vpn_ctx->rd_count);
1134   handle_gns_resolution_result (rh,
1135                                 vpn_ctx->rd_count,
1136                                 rd);
1137   GNUNET_free (vpn_ctx->rd_data);
1138   GNUNET_free (vpn_ctx);
1139 }
1140
1141
1142 /**
1143  * Process a records that were decrypted from a block.
1144  *
1145  * @param cls closure with the `struct GNS_ResolverHandle`
1146  * @param rd_count number of entries in @a rd array
1147  * @param rd array of records with data to store
1148  */
1149 static void
1150 handle_gns_resolution_result (void *cls,
1151                               unsigned int rd_count,
1152                               const struct GNUNET_GNSRECORD_Data *rd)
1153 {
1154   struct GNS_ResolverHandle *rh = cls;
1155   struct AuthorityChain *ac;
1156   unsigned int i;
1157   unsigned int j;
1158   struct sockaddr *sa;
1159   struct sockaddr_in v4;
1160   struct sockaddr_in6 v6;
1161   size_t sa_len;
1162   char *cname;
1163   struct VpnContext *vpn_ctx;
1164   const struct GNUNET_TUN_GnsVpnRecord *vpn;
1165   const char *vname;
1166   struct GNUNET_HashCode vhash;
1167   int af;
1168   char scratch[UINT16_MAX];
1169   size_t scratch_off;
1170   size_t scratch_start;
1171   size_t off;
1172   struct GNUNET_GNSRECORD_Data rd_new[rd_count];
1173   unsigned int rd_off;
1174
1175   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1176               "Resolution succeeded for `%s' in zone %s, got %u records\n",
1177               rh->ac_tail->label,
1178               GNUNET_GNSRECORD_z2s (&rh->ac_tail->authority_info.gns_authority),
1179               rd_count);
1180   if (0 == rh->name_resolution_pos)
1181   {
1182     /* top-level match, are we done yet? */
1183     if ( (rd_count > 0) &&
1184          (GNUNET_DNSPARSER_TYPE_CNAME == rd[0].record_type) &&
1185          (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type) )
1186     {
1187       off = 0;
1188       cname = GNUNET_DNSPARSER_parse_name (rd[0].data,
1189                                            rd[0].data_size,
1190                                            &off);
1191       if ( (NULL == cname) ||
1192            (off != rd[0].data_size) )
1193       {
1194         GNUNET_break_op (0);
1195         rh->proc (rh->proc_cls, 0, NULL);
1196         GNS_resolver_lookup_cancel (rh);
1197         return;
1198       }
1199       handle_gns_cname_result (rh,
1200                                cname);
1201       GNUNET_free (cname);
1202       return;
1203     }
1204     /* If A/AAAA was requested, but we got a VPN
1205        record, we convert it to A/AAAA using GNUnet VPN */
1206     if ( (GNUNET_DNSPARSER_TYPE_A == rh->record_type) ||
1207          (GNUNET_DNSPARSER_TYPE_AAAA == rh->record_type) )
1208     {
1209       for (i=0;i<rd_count;i++)
1210       {
1211         switch (rd[i].record_type)
1212         {
1213         case GNUNET_GNSRECORD_TYPE_VPN:
1214           {
1215             af = (GNUNET_DNSPARSER_TYPE_A == rh->record_type) ? AF_INET : AF_INET6;
1216             if (sizeof (struct GNUNET_TUN_GnsVpnRecord) <
1217                 rd[i].data_size)
1218             {
1219               GNUNET_break_op (0);
1220               rh->proc (rh->proc_cls, 0, NULL);
1221               GNS_resolver_lookup_cancel (rh);
1222               return;
1223             }
1224             vpn = (const struct GNUNET_TUN_GnsVpnRecord *) rd[i].data;
1225             vname = (const char *) &vpn[1];
1226             if ('\0' != vname[rd[i].data_size - 1 - sizeof (struct GNUNET_TUN_GnsVpnRecord)])
1227             {
1228               GNUNET_break_op (0);
1229               rh->proc (rh->proc_cls, 0, NULL);
1230               GNS_resolver_lookup_cancel (rh);
1231               return;
1232             }
1233             GNUNET_CRYPTO_hash (vname,
1234                                 strlen (vname), // FIXME: +1?
1235                                 &vhash);
1236             vpn_ctx = GNUNET_new (struct VpnContext);
1237             rh->vpn_ctx = vpn_ctx;
1238             vpn_ctx->rh = rh;
1239             vpn_ctx->rd_data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
1240                                                                        rd);
1241             vpn_ctx->rd_data = GNUNET_malloc (vpn_ctx->rd_data_size);
1242             (void) GNUNET_GNSRECORD_records_serialize (rd_count,
1243                                                        rd,
1244                                                        vpn_ctx->rd_data_size,
1245                                                        vpn_ctx->rd_data);
1246             vpn_ctx->vpn_request = GNUNET_VPN_redirect_to_peer (vpn_handle,
1247                                                                 af,
1248                                                                 ntohs (vpn->proto),
1249                                                                 &vpn->peer,
1250                                                                 &vhash,
1251                                                                 GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT),
1252                                                                 &vpn_allocation_cb,
1253                                                                 rh);
1254             return;
1255           }
1256         case GNUNET_GNSRECORD_TYPE_GNS2DNS:
1257           {
1258             /* delegation to DNS */
1259             goto do_recurse;
1260           }
1261         default:
1262           break;
1263         }
1264       }
1265     }
1266     /* convert relative names in record values to absolute names,
1267        using 'scratch' array for memory allocations */
1268     scratch_off = 0;
1269     rd_off = 0;
1270     for (i=0;i<rd_count;i++)
1271     {
1272       rd_new[rd_off] = rd[i];
1273       /* Check if the embedded name(s) end in "+", and if so,
1274          replace the "+" with the zone at "ac_tail", changing the name
1275          to a ".zkey".  The name is allocated on the 'scratch' array,
1276          so we can free it afterwards. */
1277       switch (rd[i].record_type)
1278       {
1279       case GNUNET_DNSPARSER_TYPE_CNAME:
1280         {
1281           char *cname;
1282
1283           off = 0;
1284           cname = GNUNET_DNSPARSER_parse_name (rd[i].data,
1285                                                rd[i].data_size,
1286                                                &off);
1287           if ( (NULL == cname) ||
1288                (off != rd[i].data_size) )
1289           {
1290             GNUNET_break_op (0); /* record not well-formed */
1291           }
1292           else
1293           {
1294             cname = translate_dot_plus (rh, cname);
1295             scratch_start = scratch_off;
1296             if (GNUNET_OK !=
1297                 GNUNET_DNSPARSER_builder_add_name (scratch,
1298                                                    sizeof (scratch),
1299                                                    &scratch_off,
1300                                                    cname))
1301             {
1302               GNUNET_break (0);
1303             }
1304             else
1305             {
1306               rd_new[rd_off].data = &scratch[scratch_start];
1307               rd_new[rd_off].data_size = scratch_off - scratch_start;
1308               rd_off++;
1309             }
1310           }
1311           GNUNET_free_non_null (cname);
1312         }
1313         break;
1314       case GNUNET_DNSPARSER_TYPE_SOA:
1315         {
1316           struct GNUNET_DNSPARSER_SoaRecord *soa;
1317
1318           off = 0;
1319           soa = GNUNET_DNSPARSER_parse_soa (rd[i].data,
1320                                             rd[i].data_size,
1321                                             &off);
1322           if ( (NULL == soa) ||
1323                (off != rd[i].data_size) )
1324           {
1325             GNUNET_break_op (0); /* record not well-formed */
1326           }
1327           else
1328           {
1329             soa->mname = translate_dot_plus (rh, soa->mname);
1330             soa->rname = translate_dot_plus (rh, soa->rname);
1331             scratch_start = scratch_off;
1332             if (GNUNET_OK !=
1333                 GNUNET_DNSPARSER_builder_add_soa (scratch,
1334                                                   sizeof (scratch),
1335                                                   &scratch_off,
1336                                                   soa))
1337             {
1338               GNUNET_break (0);
1339             }
1340             else
1341             {
1342               rd_new[rd_off].data = &scratch[scratch_start];
1343               rd_new[rd_off].data_size = scratch_off - scratch_start;
1344               rd_off++;
1345             }
1346           }
1347           if (NULL != soa)
1348             GNUNET_DNSPARSER_free_soa (soa);
1349         }
1350         break;
1351       case GNUNET_DNSPARSER_TYPE_MX:
1352         {
1353           struct GNUNET_DNSPARSER_MxRecord *mx;
1354
1355           off = 0;
1356           mx = GNUNET_DNSPARSER_parse_mx (rd[i].data,
1357                                           rd[i].data_size,
1358                                           &off);
1359           if ( (NULL == mx) ||
1360                (off != rd[i].data_size) )
1361           {
1362             GNUNET_break_op (0); /* record not well-formed */
1363           }
1364           else
1365           {
1366             mx->mxhost = translate_dot_plus (rh, mx->mxhost);
1367             scratch_start = scratch_off;
1368             if (GNUNET_OK !=
1369                 GNUNET_DNSPARSER_builder_add_mx (scratch,
1370                                                  sizeof (scratch),
1371                                                  &scratch_off,
1372                                                  mx))
1373             {
1374               GNUNET_break (0);
1375             }
1376             else
1377             {
1378               rd_new[rd_off].data = &scratch[scratch_start];
1379               rd_new[rd_off].data_size = scratch_off - scratch_start;
1380               rd_off++;
1381             }
1382           }
1383           if (NULL != mx)
1384             GNUNET_DNSPARSER_free_mx (mx);
1385         }
1386         break;
1387       case GNUNET_DNSPARSER_TYPE_SRV:
1388         {
1389           struct GNUNET_DNSPARSER_SrvRecord *srv;
1390
1391           off = 0;
1392           /* FIXME: passing rh->name here is is not necessarily what we want
1393              (SRV support not finished) */
1394           srv = GNUNET_DNSPARSER_parse_srv (rh->name,
1395                                             rd[i].data,
1396                                             rd[i].data_size,
1397                                             &off);
1398           if ( (NULL == srv) ||
1399                (off != rd[i].data_size) )
1400           {
1401             GNUNET_break_op (0); /* record not well-formed */
1402           }
1403           else
1404           {
1405             srv->domain_name = translate_dot_plus (rh, srv->domain_name);
1406             srv->target = translate_dot_plus (rh, srv->target);
1407             scratch_start = scratch_off;
1408             if (GNUNET_OK !=
1409                 GNUNET_DNSPARSER_builder_add_srv (scratch,
1410                                                   sizeof (scratch),
1411                                                   &scratch_off,
1412                                                   srv))
1413             {
1414               GNUNET_break (0);
1415             }
1416             else
1417             {
1418               rd_new[rd_off].data = &scratch[scratch_start];
1419               rd_new[rd_off].data_size = scratch_off - scratch_start;
1420               rd_off++;
1421             }
1422           }
1423           if (NULL != srv)
1424             GNUNET_DNSPARSER_free_srv (srv);
1425         }
1426         break;
1427       case GNUNET_GNSRECORD_TYPE_PKEY:
1428         {
1429           struct GNUNET_CRYPTO_EcdsaPublicKey pub;
1430
1431           if (rd[i].data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
1432           {
1433             GNUNET_break_op (0);
1434             break;
1435           }
1436           memcpy (&pub, rd[i].data, rd[i].data_size);
1437
1438           /* tigger shortening */
1439           if (NULL != rh->shorten_key)
1440           {
1441             GNS_shorten_start (rh->ac_tail->label,
1442                                &pub,
1443                                rh->shorten_key);
1444           }
1445           rd_off++;
1446           if (GNUNET_GNSRECORD_TYPE_PKEY != rh->record_type)
1447           {
1448             /* try to resolve "+" */
1449             struct AuthorityChain *ac;
1450
1451             ac = GNUNET_new (struct AuthorityChain);
1452             ac->rh = rh;
1453             ac->gns_authority = GNUNET_YES;
1454             ac->authority_info.gns_authority = pub;
1455             ac->label = GNUNET_strdup (GNUNET_GNS_MASTERZONE_STR);
1456             GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
1457                                               rh->ac_tail,
1458                                               ac);
1459             rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
1460                                                     rh);
1461             return;
1462           }
1463         }
1464         break;
1465       default:
1466         rd_off++;
1467         break;
1468       }
1469     }
1470
1471     /* yes, we are done, return result */
1472     rh->proc (rh->proc_cls, rd_off, rd_new);
1473     GNS_resolver_lookup_cancel (rh);
1474     return;
1475   }
1476  do_recurse:
1477   /* need to recurse, check if we can */
1478   for (i=0;i<rd_count;i++)
1479   {
1480     switch (rd[i].record_type)
1481     {
1482     case GNUNET_GNSRECORD_TYPE_PKEY:
1483       /* delegation to another zone */
1484       if (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) !=
1485           rd[i].data_size)
1486       {
1487         GNUNET_break_op (0);
1488         rh->proc (rh->proc_cls, 0, NULL);
1489         GNS_resolver_lookup_cancel (rh);
1490         return;
1491       }
1492       /* expand authority chain */
1493       ac = GNUNET_new (struct AuthorityChain);
1494       ac->rh = rh;
1495       ac->gns_authority = GNUNET_YES;
1496       memcpy (&ac->authority_info.gns_authority,
1497               rd[i].data,
1498               sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
1499       ac->label = resolver_lookup_get_next_label (rh);
1500       /* tigger shortening */
1501       if (NULL != rh->shorten_key)
1502         GNS_shorten_start (rh->ac_tail->label,
1503                            &ac->authority_info.gns_authority,
1504                            rh->shorten_key);
1505       /* add AC to tail */
1506       GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
1507                                         rh->ac_tail,
1508                                         ac);
1509       /* recurse */
1510       rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
1511                                               rh);
1512       return;
1513     case GNUNET_GNSRECORD_TYPE_GNS2DNS:
1514       {
1515         char *ns;
1516         /* resolution continues within DNS */
1517         if (GNUNET_DNSPARSER_MAX_NAME_LENGTH < rd[i].data_size)
1518         {
1519           GNUNET_break_op (0);
1520           rh->proc (rh->proc_cls, 0, NULL);
1521           GNS_resolver_lookup_cancel (rh);
1522           return;
1523         }
1524         /* find associated A/AAAA record */
1525         sa = NULL;
1526         sa_len = 0;
1527         for (j=0;j<rd_count;j++)
1528         {
1529           switch (rd[j].record_type)
1530             {
1531             case GNUNET_DNSPARSER_TYPE_A:
1532               if (sizeof (struct in_addr) != rd[j].data_size)
1533               {
1534                 GNUNET_break_op (0);
1535                 rh->proc (rh->proc_cls, 0, NULL);
1536                 GNS_resolver_lookup_cancel (rh);
1537                 return;
1538               }
1539               /* FIXME: might want to check if we support IPv4 here,
1540                  and otherwise skip this one and hope we find another */
1541               memset (&v4, 0, sizeof (v4));
1542               sa_len = sizeof (v4);
1543               v4.sin_family = AF_INET;
1544               v4.sin_port = htons (53);
1545 #if HAVE_SOCKADDR_IN_SIN_LEN
1546               v4.sin_len = (u_char) sa_len;
1547 #endif
1548               memcpy (&v4.sin_addr,
1549                       rd[j].data,
1550                       sizeof (struct in_addr));
1551               sa = (struct sockaddr *) &v4;
1552               break;
1553             case GNUNET_DNSPARSER_TYPE_AAAA:
1554               if (sizeof (struct in6_addr) != rd[j].data_size)
1555               {
1556                 GNUNET_break_op (0);
1557                 rh->proc (rh->proc_cls, 0, NULL);
1558                 GNS_resolver_lookup_cancel (rh);
1559                 return;
1560               }
1561               /* FIXME: might want to check if we support IPv6 here,
1562                  and otherwise skip this one and hope we find another */
1563               memset (&v6, 0, sizeof (v6));
1564               sa_len = sizeof (v6);
1565               v6.sin6_family = AF_INET6;
1566               v6.sin6_port = htons (53);
1567 #if HAVE_SOCKADDR_IN_SIN_LEN
1568               v6.sin6_len = (u_char) sa_len;
1569 #endif
1570               memcpy (&v6.sin6_addr,
1571                       rd[j].data,
1572                       sizeof (struct in6_addr));
1573               sa = (struct sockaddr *) &v6;
1574               break;
1575             default:
1576               break;
1577             }
1578           if (NULL != sa)
1579             break;
1580         }
1581         if (NULL == sa)
1582         {
1583           /* we cannot continue; NS without A/AAAA */
1584           rh->proc (rh->proc_cls, 0, NULL);
1585           GNS_resolver_lookup_cancel (rh);
1586           return;
1587         }
1588         /* expand authority chain */
1589         ac = GNUNET_new (struct AuthorityChain);
1590         ac->rh = rh;
1591         off = 0;
1592         ns = GNUNET_DNSPARSER_parse_name (rd[i].data,
1593                                           rd[i].data_size,
1594                                           &off);
1595         if ( (NULL == ns) ||
1596              (off != rd[i].data_size) )
1597         {
1598           GNUNET_break_op (0); /* record not well-formed */
1599           rh->proc (rh->proc_cls, 0, NULL);
1600           GNS_resolver_lookup_cancel (rh);
1601           GNUNET_free_non_null (ns);
1602           GNUNET_free (ac);
1603           return;
1604         }
1605         strcpy (ac->authority_info.dns_authority.name,
1606                 ns);
1607         memcpy (&ac->authority_info.dns_authority.dns_ip,
1608                 sa,
1609                 sa_len);
1610         /* for DNS recursion, the label is the full DNS name,
1611            created from the remainder of the GNS name and the
1612            name in the NS record */
1613         GNUNET_asprintf (&ac->label,
1614                          "%.*s%s%s",
1615                          (int) rh->name_resolution_pos,
1616                          rh->name,
1617                          (0 != rh->name_resolution_pos) ? "." : "",
1618                          ns);
1619         GNUNET_free (ns);
1620         GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
1621                                           rh->ac_tail,
1622                                           ac);
1623         if (strlen (ac->label) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
1624         {
1625           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1626                       _("GNS lookup resulted in DNS name that is too long (`%s')\n"),
1627                       ac->label);
1628           rh->proc (rh->proc_cls, 0, NULL);
1629           GNS_resolver_lookup_cancel (rh);
1630           return;
1631         }
1632         /* recurse */
1633         rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
1634                                                 rh);
1635         return;
1636       }
1637     case GNUNET_DNSPARSER_TYPE_CNAME:
1638       {
1639         char *cname;
1640
1641         off = 0;
1642         cname = GNUNET_DNSPARSER_parse_name (rd[i].data,
1643                                              rd[i].data_size,
1644                                              &off);
1645         if ( (NULL == cname) ||
1646              (off != rd[i].data_size) )
1647         {
1648           GNUNET_break_op (0); /* record not well-formed */
1649           rh->proc (rh->proc_cls, 0, NULL);
1650           GNS_resolver_lookup_cancel (rh);
1651           GNUNET_free_non_null (cname);
1652           return;
1653         }
1654         handle_gns_cname_result (rh,
1655                                  cname);
1656         GNUNET_free (cname);
1657         return;
1658       }
1659       /* FIXME: handle DNAME */
1660     default:
1661       /* skip */
1662       break;
1663     }
1664   }
1665   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1666               _("GNS lookup recursion failed (no delegation record found)\n"));
1667   rh->proc (rh->proc_cls, 0, NULL);
1668   GNS_resolver_lookup_cancel (rh);
1669 }
1670
1671
1672 /**
1673  * Function called once the namestore has completed the request for
1674  * caching a block.
1675  *
1676  * @param cls closure with the `struct CacheOps`
1677  * @param success #GNUNET_OK on success
1678  * @param emsg error message
1679  */
1680 static void
1681 namecache_cache_continuation (void *cls,
1682                               int32_t success,
1683                               const char *emsg)
1684 {
1685   struct CacheOps *co = cls;
1686
1687   co->namecache_qe_cache = NULL;
1688   if (NULL != emsg)
1689     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1690                 _("Failed to cache GNS resolution: %s\n"),
1691                 emsg);
1692   GNUNET_CONTAINER_DLL_remove (co_head,
1693                                co_tail,
1694                                co);
1695   GNUNET_free (co);
1696 }
1697
1698
1699 /**
1700  * Iterator called on each result obtained for a DHT
1701  * operation that expects a reply
1702  *
1703  * @param cls closure with the `struct GNS_ResolverHandle`
1704  * @param exp when will this value expire
1705  * @param key key of the result
1706  * @param get_path peers on reply path (or NULL if not recorded)
1707  *                 [0] = datastore's first neighbor, [length - 1] = local peer
1708  * @param get_path_length number of entries in @a get_path
1709  * @param put_path peers on the PUT path (or NULL if not recorded)
1710  *                 [0] = origin, [length - 1] = datastore
1711  * @param put_path_length number of entries in @a put_path
1712  * @param type type of the result
1713  * @param size number of bytes in data
1714  * @param data pointer to the result data
1715  */
1716 static void
1717 handle_dht_response (void *cls,
1718                      struct GNUNET_TIME_Absolute exp,
1719                      const struct GNUNET_HashCode *key,
1720                      const struct GNUNET_PeerIdentity *get_path,
1721                      unsigned int get_path_length,
1722                      const struct GNUNET_PeerIdentity *put_path,
1723                      unsigned int put_path_length,
1724                      enum GNUNET_BLOCK_Type type,
1725                      size_t size, const void *data)
1726 {
1727   struct GNS_ResolverHandle *rh = cls;
1728   struct AuthorityChain *ac = rh->ac_tail;
1729   const struct GNUNET_GNSRECORD_Block *block;
1730   struct CacheOps *co;
1731
1732   GNUNET_DHT_get_stop (rh->get_handle);
1733   rh->get_handle = NULL;
1734   GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
1735   rh->dht_heap_node = NULL;
1736   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1737               "Handling response from the DHT\n");
1738   if (size < sizeof (struct GNUNET_GNSRECORD_Block))
1739   {
1740     /* how did this pass DHT block validation!? */
1741     GNUNET_break (0);
1742     rh->proc (rh->proc_cls, 0, NULL);
1743     GNS_resolver_lookup_cancel (rh);
1744     return;
1745   }
1746   block = data;
1747   if (size !=
1748       ntohl (block->purpose.size) +
1749       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
1750       sizeof (struct GNUNET_CRYPTO_EcdsaSignature))
1751   {
1752     /* how did this pass DHT block validation!? */
1753     GNUNET_break (0);
1754     rh->proc (rh->proc_cls, 0, NULL);
1755     GNS_resolver_lookup_cancel (rh);
1756     return;
1757   }
1758   if (GNUNET_OK !=
1759       GNUNET_GNSRECORD_block_decrypt (block,
1760                                       &ac->authority_info.gns_authority,
1761                                       ac->label,
1762                                       &handle_gns_resolution_result,
1763                                       rh))
1764   {
1765     GNUNET_break_op (0); /* block was ill-formed */
1766     rh->proc (rh->proc_cls, 0, NULL);
1767     GNS_resolver_lookup_cancel (rh);
1768     return;
1769   }
1770   /* Cache well-formed blocks */
1771   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1772               "Caching response from the DHT in namestore\n");
1773   co = GNUNET_new (struct CacheOps);
1774   co->namecache_qe_cache = GNUNET_NAMECACHE_block_cache (namecache_handle,
1775                                                          block,
1776                                                          &namecache_cache_continuation,
1777                                                          co);
1778   GNUNET_CONTAINER_DLL_insert (co_head,
1779                                co_tail,
1780                                co);
1781 }
1782
1783
1784 /**
1785  * Process a record that was stored in the namestore.
1786  *
1787  * @param cls closure with the `struct GNS_ResolverHandle`
1788  * @param block block that was stored in the namestore
1789  */
1790 static void
1791 handle_namestore_block_response (void *cls,
1792                                  const struct GNUNET_GNSRECORD_Block *block)
1793 {
1794   struct GNS_ResolverHandle *rh = cls;
1795   struct GNS_ResolverHandle *rx;
1796   struct AuthorityChain *ac = rh->ac_tail;
1797   const char *label = ac->label;
1798   const struct GNUNET_CRYPTO_EcdsaPublicKey *auth = &ac->authority_info.gns_authority;
1799   struct GNUNET_HashCode query;
1800
1801   GNUNET_GNSRECORD_query_from_public_key (auth,
1802                                           label,
1803                                           &query);
1804   GNUNET_assert (NULL != rh->namecache_qe);
1805   rh->namecache_qe = NULL;
1806   if ( (GNUNET_NO == rh->only_cached) &&
1807        ( (NULL == block) ||
1808          (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (block->expiration_time)).rel_value_us) ) )
1809   {
1810     /* Namestore knows nothing; try DHT lookup */
1811     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1812                 "Starting DHT lookup for `%s' in zone %s\n",
1813                 ac->label,
1814                 GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
1815     GNUNET_assert (NULL == rh->get_handle);
1816     rh->get_handle = GNUNET_DHT_get_start (dht_handle,
1817                                            GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
1818                                            &query,
1819                                            DHT_GNS_REPLICATION_LEVEL,
1820                                            GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
1821                                            NULL, 0,
1822                                            &handle_dht_response, rh);
1823     rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
1824                                                       rh,
1825                                                       GNUNET_TIME_absolute_get ().abs_value_us);
1826     if (GNUNET_CONTAINER_heap_get_size (dht_lookup_heap) > max_allowed_background_queries)
1827     {
1828       /* fail longest-standing DHT request */
1829       rx = GNUNET_CONTAINER_heap_peek (dht_lookup_heap);
1830       GNUNET_assert (NULL != rx);
1831       rx->proc (rx->proc_cls, 0, NULL);
1832       GNS_resolver_lookup_cancel (rx);
1833     }
1834     return;
1835   }
1836   if ( (NULL == block) ||
1837        (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (block->expiration_time)).rel_value_us) )
1838   {
1839     /* DHT not permitted and no local result, fail */
1840     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1841                 "Resolution failed for `%s' in zone %s (DHT lookup not permitted by configuration)\n",
1842                 ac->label,
1843                 GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
1844     rh->proc (rh->proc_cls, 0, NULL);
1845     GNS_resolver_lookup_cancel (rh);
1846     return;
1847   }
1848   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1849               "Decrypting block from the namestore\n");
1850   if (GNUNET_OK !=
1851       GNUNET_GNSRECORD_block_decrypt (block,
1852                                       auth,
1853                                       label,
1854                                       &handle_gns_resolution_result,
1855                                       rh))
1856   {
1857     GNUNET_break_op (0); /* block was ill-formed */
1858     rh->proc (rh->proc_cls, 0, NULL);
1859     GNS_resolver_lookup_cancel (rh);
1860     return;
1861   }
1862 }
1863
1864
1865 /**
1866  * Lookup tail of our authority chain in the namestore.
1867  *
1868  * @param rh query we are processing
1869  */
1870 static void
1871 recursive_gns_resolution_namestore (struct GNS_ResolverHandle *rh)
1872 {
1873   struct AuthorityChain *ac = rh->ac_tail;
1874   struct GNUNET_HashCode query;
1875
1876   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1877               "Starting GNS resolution for `%s' in zone %s\n",
1878               ac->label,
1879               GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
1880   GNUNET_GNSRECORD_query_from_public_key (&ac->authority_info.gns_authority,
1881                                           ac->label,
1882                                           &query);
1883   rh->namecache_qe = GNUNET_NAMECACHE_lookup_block (namecache_handle,
1884                                                     &query,
1885                                                     &handle_namestore_block_response,
1886                                                     rh);
1887   GNUNET_assert (NULL != rh->namecache_qe);
1888 }
1889
1890
1891 /**
1892  * Task scheduled to continue with the resolution process.
1893  *
1894  * @param cls the `struct GNS_ResolverHandle` of the resolution
1895  * @param tc task context
1896  */
1897 static void
1898 recursive_resolution (void *cls,
1899                       const struct GNUNET_SCHEDULER_TaskContext *tc)
1900 {
1901   struct GNS_ResolverHandle *rh = cls;
1902
1903   rh->task_id = GNUNET_SCHEDULER_NO_TASK;
1904   if (MAX_RECURSION < rh->loop_limiter++)
1905   {
1906     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1907                 "Encountered unbounded recursion resolving `%s'\n",
1908                 rh->name);
1909     rh->proc (rh->proc_cls, 0, NULL);
1910     GNS_resolver_lookup_cancel (rh);
1911     return;
1912   }
1913   if (GNUNET_YES == rh->ac_tail->gns_authority)
1914     recursive_gns_resolution_namestore (rh);
1915   else
1916     recursive_dns_resolution (rh);
1917 }
1918
1919
1920 /**
1921  * Begin the resolution process from 'name', starting with
1922  * the identification of the zone specified by 'name'.
1923  *
1924  * @param rh resolution to perform
1925  */
1926 static void
1927 start_resolver_lookup (struct GNS_ResolverHandle *rh)
1928 {
1929   struct AuthorityChain *ac;
1930   char *x;
1931   char *y;
1932   char *pkey;
1933
1934   if ( ( (GNUNET_YES == is_canonical (rh->name)) &&
1935          (0 != strcmp (GNUNET_GNS_TLD, rh->name)) ) ||
1936        ( (GNUNET_YES != is_gnu_tld (rh->name)) &&
1937          (GNUNET_YES != is_zkey_tld (rh->name)) ) )
1938   {
1939     /* use standard DNS lookup */
1940     int af;
1941
1942     switch (rh->record_type)
1943     {
1944     case GNUNET_DNSPARSER_TYPE_A:
1945       af = AF_INET;
1946       break;
1947     case GNUNET_DNSPARSER_TYPE_AAAA:
1948       af = AF_INET6;
1949       break;
1950     default:
1951       af = AF_UNSPEC;
1952       break;
1953     }
1954     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1955                 "Doing standard DNS lookup for `%s'\n",
1956                 rh->name);
1957     rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
1958                                               af,
1959                                               DNS_LOOKUP_TIMEOUT,
1960                                               &handle_dns_result,
1961                                               rh);
1962     return;
1963   }
1964   if (is_zkey_tld (rh->name))
1965   {
1966     /* Name ends with ".zkey", try to replace authority zone with zkey
1967        authority */
1968     GNUNET_free (resolver_lookup_get_next_label (rh)); /* will return "zkey" */
1969     x = resolver_lookup_get_next_label (rh); /* will return 'x' coordinate */
1970     y = resolver_lookup_get_next_label (rh); /* will return 'y' coordinate */
1971     GNUNET_asprintf (&pkey,
1972                      "%s%s",
1973                      x, y);
1974     if ( (NULL == x) ||
1975          (NULL == y) ||
1976          (GNUNET_OK !=
1977           GNUNET_CRYPTO_ecdsa_public_key_from_string (pkey,
1978                                                     strlen (pkey),
1979                                                     &rh->authority_zone)) )
1980     {
1981       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1982                   _("Hostname `%s' is not well-formed, resolution fails\n"),
1983                   rh->name);
1984       rh->task_id = GNUNET_SCHEDULER_add_now (&fail_resolution, rh);
1985     }
1986     GNUNET_free_non_null (x);
1987     GNUNET_free_non_null (y);
1988     GNUNET_free (pkey);
1989   }
1990   else
1991   {
1992     /* Name ends with ".gnu", eat ".gnu" and continue with resolution */
1993     GNUNET_free (resolver_lookup_get_next_label (rh));
1994   }
1995   ac = GNUNET_new (struct AuthorityChain);
1996   ac->rh = rh;
1997   ac->label = resolver_lookup_get_next_label (rh);
1998   if (NULL == ac->label)
1999     /* name was just "gnu", so we default to label '+' */
2000     ac->label = GNUNET_strdup (GNUNET_GNS_MASTERZONE_STR);
2001   ac->gns_authority = GNUNET_YES;
2002   ac->authority_info.gns_authority = rh->authority_zone;
2003   GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
2004                                     rh->ac_tail,
2005                                     ac);
2006   rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
2007                                           rh);
2008 }
2009
2010
2011 /**
2012  * Lookup of a record in a specific zone calls lookup result processor
2013  * on result.
2014  *
2015  * @param zone the zone to perform the lookup in
2016  * @param record_type the record type to look up
2017  * @param name the name to look up
2018  * @param shorten_key a private key for use with PSEU import (can be NULL)
2019  * @param only_cached #GNUNET_NO to only check locally not DHT for performance
2020  * @param proc the processor to call on result
2021  * @param proc_cls the closure to pass to @a proc
2022  * @return handle to cancel operation
2023  */
2024 struct GNS_ResolverHandle *
2025 GNS_resolver_lookup (const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
2026                      uint32_t record_type,
2027                      const char *name,
2028                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *shorten_key,
2029                      int only_cached,
2030                      GNS_ResultProcessor proc, void *proc_cls)
2031 {
2032   struct GNS_ResolverHandle *rh;
2033
2034   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2035               (NULL == shorten_key)
2036               ? "Starting lookup for `%s' with shortening disabled\n"
2037               : "Starting lookup for `%s' with shortening enabled\n",
2038               name);
2039   rh = GNUNET_new (struct GNS_ResolverHandle);
2040   GNUNET_CONTAINER_DLL_insert (rlh_head,
2041                                rlh_tail,
2042                                rh);
2043   rh->authority_zone = *zone;
2044   rh->proc = proc;
2045   rh->proc_cls = proc_cls;
2046   rh->only_cached = only_cached;
2047   rh->record_type = record_type;
2048   rh->name = GNUNET_strdup (name);
2049   rh->name_resolution_pos = strlen (name);
2050   if (NULL != shorten_key)
2051   {
2052     rh->shorten_key = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
2053     *rh->shorten_key = *shorten_key;
2054   }
2055   start_resolver_lookup (rh);
2056   return rh;
2057 }
2058
2059
2060 /**
2061  * Cancel active resolution (i.e. client disconnected).
2062  *
2063  * @param rh resolution to abort
2064  */
2065 void
2066 GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh)
2067 {
2068   struct DnsResult *dr;
2069   struct AuthorityChain *ac;
2070   struct VpnContext *vpn_ctx;
2071
2072   GNUNET_CONTAINER_DLL_remove (rlh_head,
2073                                rlh_tail,
2074                                rh);
2075   while (NULL != (ac = rh->ac_head))
2076   {
2077     GNUNET_CONTAINER_DLL_remove (rh->ac_head,
2078                                  rh->ac_tail,
2079                                  ac);
2080     GNUNET_free (ac->label);
2081     GNUNET_free (ac);
2082   }
2083   if (GNUNET_SCHEDULER_NO_TASK != rh->task_id)
2084   {
2085     GNUNET_SCHEDULER_cancel (rh->task_id);
2086     rh->task_id = GNUNET_SCHEDULER_NO_TASK;
2087   }
2088   if (NULL != rh->get_handle)
2089   {
2090     GNUNET_DHT_get_stop (rh->get_handle);
2091     rh->get_handle = NULL;
2092   }
2093   if (NULL != rh->dht_heap_node)
2094   {
2095     GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
2096     rh->dht_heap_node = NULL;
2097   }
2098   if (NULL != (vpn_ctx = rh->vpn_ctx))
2099   {
2100     GNUNET_VPN_cancel_request (vpn_ctx->vpn_request);
2101     GNUNET_free (vpn_ctx->rd_data);
2102     GNUNET_free (vpn_ctx);
2103   }
2104   if (NULL != rh->dns_request)
2105   {
2106     GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
2107     rh->dns_request = NULL;
2108   }
2109   if (NULL != rh->namecache_qe)
2110   {
2111     GNUNET_NAMECACHE_cancel (rh->namecache_qe);
2112     rh->namecache_qe = NULL;
2113   }
2114   if (NULL != rh->std_resolve)
2115   {
2116     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2117                 "Canceling standard DNS resolution\n");
2118     GNUNET_RESOLVER_request_cancel (rh->std_resolve);
2119     rh->std_resolve = NULL;
2120   }
2121   while (NULL != (dr = rh->dns_result_head))
2122   {
2123     GNUNET_CONTAINER_DLL_remove (rh->dns_result_head,
2124                                  rh->dns_result_tail,
2125                                  dr);
2126     GNUNET_free (dr);
2127   }
2128   GNUNET_free_non_null (rh->shorten_key);
2129   GNUNET_free (rh->name);
2130   GNUNET_free (rh);
2131 }
2132
2133
2134 /* ***************** Resolver initialization ********************* */
2135
2136
2137 /**
2138  * Initialize the resolver
2139  *
2140  * @param nh the namestore handle
2141  * @param nc the namecache handle
2142  * @param dht the dht handle
2143  * @param c configuration handle
2144  * @param max_bg_queries maximum number of parallel background queries in dht
2145  */
2146 void
2147 GNS_resolver_init (struct GNUNET_NAMESTORE_Handle *nh,
2148                    struct GNUNET_NAMECACHE_Handle *nc,
2149                    struct GNUNET_DHT_Handle *dht,
2150                    const struct GNUNET_CONFIGURATION_Handle *c,
2151                    unsigned long long max_bg_queries)
2152 {
2153   char *dns_ip;
2154
2155   cfg = c;
2156   namecache_handle = nc;
2157   namestore_handle = nh;
2158   dht_handle = dht;
2159   dht_lookup_heap =
2160     GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
2161   max_allowed_background_queries = max_bg_queries;
2162   if (GNUNET_OK !=
2163       GNUNET_CONFIGURATION_get_value_string (c,
2164                                              "gns",
2165                                              "DNS_RESOLVER",
2166                                              &dns_ip))
2167   {
2168     /* user did not specify DNS resolver, use 8.8.8.8 */
2169     dns_ip = GNUNET_strdup ("8.8.8.8");
2170   }
2171   dns_handle = GNUNET_DNSSTUB_start (dns_ip);
2172   GNUNET_free (dns_ip);
2173   vpn_handle = GNUNET_VPN_connect (cfg);
2174 }
2175
2176
2177 /**
2178  * Shutdown resolver
2179  */
2180 void
2181 GNS_resolver_done ()
2182 {
2183   struct GNS_ResolverHandle *rh;
2184   struct CacheOps *co;
2185
2186   /* abort active resolutions */
2187   while (NULL != (rh = rlh_head))
2188   {
2189     rh->proc (rh->proc_cls, 0, NULL);
2190     GNS_resolver_lookup_cancel (rh);
2191   }
2192   while (NULL != (co = co_head))
2193   {
2194     GNUNET_CONTAINER_DLL_remove (co_head,
2195                                  co_tail,
2196                                  co);
2197     GNUNET_NAMECACHE_cancel (co->namecache_qe_cache);
2198     GNUNET_free (co);
2199   }
2200   GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
2201   dht_lookup_heap = NULL;
2202   GNUNET_DNSSTUB_stop (dns_handle);
2203   dns_handle = NULL;
2204   GNUNET_VPN_disconnect (vpn_handle);
2205   vpn_handle = NULL;
2206   dht_handle = NULL;
2207   namecache_handle = NULL;
2208   namestore_handle = NULL;
2209 }
2210
2211
2212 /* *************** common helper functions (do not really belong here) *********** */
2213
2214 /**
2215  * Checks if @a name ends in ".TLD"
2216  *
2217  * @param name the name to check
2218  * @param tld the TLD to check for
2219  * @return GNUNET_YES or GNUNET_NO
2220  */
2221 int
2222 is_tld (const char* name, const char* tld)
2223 {
2224   size_t offset = 0;
2225
2226   if (strlen (name) <= strlen (tld))
2227     return GNUNET_NO;
2228   offset = strlen (name) - strlen (tld);
2229   if (0 != strcmp (name + offset, tld))
2230     return GNUNET_NO;
2231   return GNUNET_YES;
2232 }
2233
2234
2235 /* end of gnunet-service-gns_resolver.c */