dirmngr/dns-stuff.c

   1 /* dns-stuff.c - DNS related code including CERT RR (rfc-4398)
   2  * Copyright (C) 2003, 2005, 2006, 2009 Free Software Foundation, Inc.
   3  * Copyright (C) 2005, 2006, 2009, 2015. 2016 Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * This file is free software; you can redistribute it and/or modify
   8  * it under the terms of either
   9  *
  10  *   - the GNU Lesser General Public License as published by the Free
  11  *     Software Foundation; either version 3 of the License, or (at
  12  *     your option) any later version.
  13  *
  14  * or
  15  *
  16  *   - the GNU General Public License as published by the Free
  17  *     Software Foundation; either version 2 of the License, or (at
  18  *     your option) any later version.
  19  *
  20  * or both in parallel, as here.
  21  *
  22  * This file is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  29  */
  30
  31 #include <config.h>
  32 #include <sys/types.h>
  33 #ifdef HAVE_W32_SYSTEM
  34 # define WIN32_LEAN_AND_MEAN
  35 # ifdef HAVE_WINSOCK2_H
  36 #  include <winsock2.h>
  37 # endif
  38 # include <windows.h>
  39 # include <iphlpapi.h>
  40 #else
  41 # if HAVE_SYSTEM_RESOLVER
  42 #  include <netinet/in.h>
  43 #  include <arpa/nameser.h>
  44 #  include <resolv.h>
  45 # endif
  46 # include <netdb.h>
  47 #endif
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51
  52 /* William Ahern's DNS library, included as a source copy.  */
  53 #ifdef USE_LIBDNS
  54 # include "dns.h"
  55 #endif
  56
  57 /* dns.c has a dns_p_free but it is not exported.  We use our own
  58  * wrapper here so that we do not accidentally use xfree which would
  59  * be wrong for dns.c allocated data.  */
  60 #define dns_free(a)  free ((a))
  61
  62
  63 #ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
  64 # undef USE_NPTH
  65 #endif
  66 #ifdef USE_NPTH
  67 # include <npth.h>
  68 #endif
  69
  70 #include "./dirmngr-err.h"
  71 #include "util.h"
  72 #include "host2net.h"
  73 #include "dns-stuff.h"
  74
  75 #ifdef USE_NPTH
  76 # define my_unprotect()        npth_unprotect ()
  77 # define my_protect()          npth_protect ()
  78 #else
  79 # define my_unprotect()        do { } while(0)
  80 # define my_protect()          do { } while(0)
  81 #endif
  82
  83 /* We allow the use of 0 instead of AF_UNSPEC - check this assumption.  */
  84 #if AF_UNSPEC != 0
  85 # error AF_UNSPEC does not have the value 0
  86 #endif
  87
  88 /* Windows does not support the AI_ADDRCONFIG flag - use zero instead.  */
  89 #ifndef AI_ADDRCONFIG
  90 # define AI_ADDRCONFIG 0
  91 #endif
  92
  93 /* Not every installation has gotten around to supporting SRVs or
  94    CERTs yet... */
  95 #ifndef T_SRV
  96 #define T_SRV 33
  97 #endif
  98 #ifndef T_CERT
  99 # define T_CERT 37
 100 #endif
 101
 102 /* The standard SOCKS and TOR ports.  */
 103 #define SOCKS_PORT 1080
 104 #define TOR_PORT   9050
 105 #define TOR_PORT2  9150   /* (Used by the Tor browser) */
 106
 107
 108 /* The default nameserver used in Tor mode.  */
 109 #define DEFAULT_NAMESERVER "8.8.8.8"
 110
 111 /* The default timeout in seconds for libdns requests.  */
 112 #define DEFAULT_TIMEOUT 30
 113
 114
 115 /* Two flags to enable verbose and debug mode.  */
 116 static int opt_verbose;
 117 static int opt_debug;
 118
 119 /* The timeout in seconds for libdns requests.  */
 120 static int opt_timeout;
 121
 122 /* If set force the use of the standard resolver.  */
 123 static int standard_resolver;
 124
 125 /* If set use recursive resolver when available. */
 126 static int recursive_resolver;
 127
 128 /* If set Tor mode shall be used.  */
 129 static int tor_mode;
 130
 131 /* A string with the nameserver IP address used with Tor.
 132   (40 should be sufficient for v6 but we add some extra for a scope.) */
 133 static char tor_nameserver[40+20];
 134
 135 /* Two strings to hold the credentials presented to Tor.  */
 136 static char tor_socks_user[30];
 137 static char tor_socks_password[20];
 138
 139
 140 #ifdef USE_LIBDNS
 141 /* Libdns gobal data.  */
 142 struct libdns_s
 143 {
 144   struct dns_resolv_conf *resolv_conf;
 145   struct dns_hosts *hosts;
 146   struct dns_hints *hints;
 147
 148   struct sockaddr_storage socks_host;
 149 } libdns;
 150
 151 /* If this flag is set, libdns shall be reinited for the next use.  */
 152 static int libdns_reinit_pending;
 153
 154 /* The Tor port to be used.  */
 155 static int libdns_tor_port;
 156
 157 #endif /*USE_LIBDNS*/
 158
 159
 160 /* Calling this function with YES set to True forces the use of the
 161  * standard resolver even if dirmngr has been built with support for
 162  * an alternative resolver.  */
 163 void
 164 enable_standard_resolver (int yes)
 165 {
 166   standard_resolver = yes;
 167 }
 168
 169
 170 /* Return true if the standard resolver is used.  */
 171 int
 172 standard_resolver_p (void)
 173 {
 174   return standard_resolver;
 175 }
 176
 177
 178 /* Calling this function with YES switches libdns into recursive mode.
 179  * It has no effect on the standard resolver.  */
 180 void
 181 enable_recursive_resolver (int yes)
 182 {
 183   recursive_resolver = yes;
 184 #ifdef USE_LIBDNS
 185   libdns_reinit_pending = 1;
 186 #endif
 187 }
 188
 189
 190 /* Return true iff the recursive resolver is used.  */
 191 int
 192 recursive_resolver_p (void)
 193 {
 194 #if USE_LIBDNS
 195   return !standard_resolver && recursive_resolver;
 196 #else
 197   return 0;
 198 #endif
 199 }
 200
 201
 202 /* Sets the module in Tor mode.  Returns 0 is this is possible or an
 203    error code.  */
 204 gpg_error_t
 205 enable_dns_tormode (int new_circuit)
 206 {
 207   if (!*tor_socks_user || new_circuit)
 208     {
 209       static unsigned int counter;
 210
 211       gpgrt_snprintf (tor_socks_user, sizeof tor_socks_user,
 212                       "dirmngr-%lu", (unsigned long)getpid ());
 213       gpgrt_snprintf (tor_socks_password, sizeof tor_socks_password,
 214                       "p%u", counter);
 215       counter++;
 216     }
 217   tor_mode = 1;
 218   return 0;
 219 }
 220
 221
 222 /* Set verbosity and debug mode for this module. */
 223 void
 224 set_dns_verbose (int verbose, int debug)
 225 {
 226   opt_verbose = verbose;
 227   opt_debug = debug;
 228 }
 229
 230
 231 /* Set the timeout for libdns requests to SECONDS.  A value of 0 sets
 232  * the default timeout and values are capped at 10 minutes.  */
 233 void
 234 set_dns_timeout (int seconds)
 235 {
 236   if (!seconds)
 237     seconds = DEFAULT_TIMEOUT;
 238   else if (seconds < 1)
 239     seconds = 1;
 240   else if (seconds > 600)
 241     seconds = 600;
 242
 243   opt_timeout = seconds;
 244 }
 245
 246
 247 /* Change the default IP address of the nameserver to IPADDR.  The
 248    address needs to be a numerical IP address and will be used for the
 249    next DNS query.  Note that this is only used in Tor mode.  */
 250 void
 251 set_dns_nameserver (const char *ipaddr)
 252 {
 253   strncpy (tor_nameserver, ipaddr? ipaddr : DEFAULT_NAMESERVER,
 254            sizeof tor_nameserver -1);
 255   tor_nameserver[sizeof tor_nameserver -1] = 0;
 256 #ifdef USE_LIBDNS
 257   libdns_reinit_pending = 1;
 258   libdns_tor_port = 0;  /* Start again with the default port.  */
 259 #endif
 260 }
 261
 262
 263 /* Free an addressinfo linked list as returned by resolve_dns_name.  */
 264 void
 265 free_dns_addrinfo (dns_addrinfo_t ai)
 266 {
 267   while (ai)
 268     {
 269       dns_addrinfo_t next = ai->next;
 270       xfree (ai);
 271       ai = next;
 272     }
 273 }
 274
 275
 276 #ifndef HAVE_W32_SYSTEM
 277 /* Return H_ERRNO mapped to a gpg-error code.  Will never return 0. */
 278 static gpg_error_t
 279 get_h_errno_as_gpg_error (void)
 280 {
 281   gpg_err_code_t ec;
 282
 283   switch (h_errno)
 284     {
 285     case HOST_NOT_FOUND: ec = GPG_ERR_NO_NAME; break;
 286     case TRY_AGAIN:      ec = GPG_ERR_TRY_LATER; break;
 287     case NO_RECOVERY:    ec = GPG_ERR_SERVER_FAILED; break;
 288     case NO_DATA:        ec = GPG_ERR_NO_DATA; break;
 289     default:             ec = GPG_ERR_UNKNOWN_ERRNO; break;
 290     }
 291   return gpg_error (ec);
 292 }
 293 #endif /*!HAVE_W32_SYSTEM*/
 294
 295 static gpg_error_t
 296 map_eai_to_gpg_error (int ec)
 297 {
 298   gpg_error_t err;
 299
 300   switch (ec)
 301     {
 302     case EAI_AGAIN:     err = gpg_error (GPG_ERR_EAGAIN); break;
 303     case EAI_BADFLAGS:  err = gpg_error (GPG_ERR_INV_FLAG); break;
 304     case EAI_FAIL:      err = gpg_error (GPG_ERR_SERVER_FAILED); break;
 305     case EAI_MEMORY:    err = gpg_error (GPG_ERR_ENOMEM); break;
 306 #ifdef EAI_NODATA
 307     case EAI_NODATA:    err = gpg_error (GPG_ERR_NO_DATA); break;
 308 #endif
 309     case EAI_NONAME:    err = gpg_error (GPG_ERR_NO_NAME); break;
 310     case EAI_SERVICE:   err = gpg_error (GPG_ERR_NOT_SUPPORTED); break;
 311     case EAI_FAMILY:    err = gpg_error (GPG_ERR_EAFNOSUPPORT); break;
 312     case EAI_SOCKTYPE:  err = gpg_error (GPG_ERR_ESOCKTNOSUPPORT); break;
 313 #ifndef HAVE_W32_SYSTEM
 314 # ifdef EAI_ADDRFAMILY
 315     case EAI_ADDRFAMILY:err = gpg_error (GPG_ERR_EADDRNOTAVAIL); break;
 316 # endif
 317     case EAI_SYSTEM:    err = gpg_error_from_syserror (); break;
 318 #endif
 319     default:            err = gpg_error (GPG_ERR_UNKNOWN_ERRNO); break;
 320     }
 321   return err;
 322 }
 323
 324
 325 #ifdef USE_LIBDNS
 326 static gpg_error_t
 327 libdns_error_to_gpg_error (int serr)
 328 {
 329   gpg_err_code_t ec;
 330
 331   switch (serr)
 332     {
 333     case 0: ec = 0; break;
 334
 335     case DNS_ENOBUFS:  ec = GPG_ERR_BUFFER_TOO_SHORT; break;
 336     case DNS_EILLEGAL: ec = GPG_ERR_INV_OBJ; break;
 337     case DNS_EORDER:   ec = GPG_ERR_INV_ORDER; break;
 338     case DNS_ESECTION: ec = GPG_ERR_DNS_SECTION; break;
 339     case DNS_EUNKNOWN: ec = GPG_ERR_DNS_UNKNOWN; break;
 340     case DNS_EADDRESS: ec = GPG_ERR_DNS_ADDRESS; break;
 341     case DNS_ENOQUERY: ec = GPG_ERR_DNS_NO_QUERY; break;
 342     case DNS_ENOANSWER:ec = GPG_ERR_DNS_NO_ANSWER; break;
 343     case DNS_EFETCHED: ec = GPG_ERR_ALREADY_FETCHED; break;
 344     case DNS_ESERVICE: ec = GPG_ERR_NOT_SUPPORTED; break;
 345     case DNS_ENONAME:  ec = GPG_ERR_NO_NAME; break;
 346     case DNS_EFAIL:    ec = GPG_ERR_SERVER_FAILED; break;
 347     case DNS_ECONNFIN: ec = GPG_ERR_DNS_CLOSED; break;
 348     case DNS_EVERIFY:  ec = GPG_ERR_DNS_VERIFY; break;
 349
 350     default:
 351       if (serr >= 0)
 352         ec = gpg_err_code_from_errno (serr);
 353       else
 354         ec = GPG_ERR_DNS_UNKNOWN;
 355       break;
 356     }
 357   return gpg_error (ec);
 358 }
 359 #endif /*USE_LIBDNS*/
 360
 361
 362 #ifdef USE_LIBDNS
 363 /* Initialize libdns.  Returns 0 on success; prints a diagnostic and
 364  * returns an error code on failure.  */
 365 static gpg_error_t
 366 libdns_init (void)
 367 {
 368   gpg_error_t err;
 369   struct libdns_s ld;
 370   int derr;
 371   char *cfgstr = NULL;
 372
 373   if (libdns.resolv_conf)
 374     return 0; /* Already initialized.  */
 375
 376   memset (&ld, 0, sizeof ld);
 377
 378   ld.resolv_conf = dns_resconf_open (&derr);
 379   if (!ld.resolv_conf)
 380     {
 381       err = libdns_error_to_gpg_error (derr);
 382       log_error ("failed to allocate DNS resconf object: %s\n",
 383                  gpg_strerror (err));
 384       goto leave;
 385     }
 386
 387   if (tor_mode)
 388     {
 389       if (!*tor_nameserver)
 390         set_dns_nameserver (NULL);
 391
 392       if (!libdns_tor_port)
 393         libdns_tor_port = TOR_PORT;
 394
 395       cfgstr = xtryasprintf ("[%s]:53", tor_nameserver);
 396       if (!cfgstr)
 397         err = gpg_error_from_syserror ();
 398       else
 399         err = libdns_error_to_gpg_error
 400           (dns_resconf_pton (&ld.resolv_conf->nameserver[0], cfgstr));
 401       if (err)
 402         log_error ("failed to set nameserver '%s': %s\n",
 403                    cfgstr, gpg_strerror (err));
 404       if (err)
 405         goto leave;
 406
 407       ld.resolv_conf->options.tcp = DNS_RESCONF_TCP_SOCKS;
 408
 409       xfree (cfgstr);
 410       cfgstr = xtryasprintf ("[%s]:%d", "127.0.0.1", libdns_tor_port);
 411       if (!cfgstr)
 412         err = gpg_error_from_syserror ();
 413       else
 414         err = libdns_error_to_gpg_error
 415           (dns_resconf_pton (&ld.socks_host, cfgstr));
 416       if (err)
 417         {
 418           log_error ("failed to set socks server '%s': %s\n",
 419                      cfgstr, gpg_strerror (err));
 420           goto leave;
 421         }
 422     }
 423   else
 424     {
 425 #ifdef HAVE_W32_SYSTEM
 426       ULONG ninfo_len;
 427       PFIXED_INFO ninfo;
 428       PIP_ADDR_STRING pip;
 429       int idx;
 430
 431       ninfo_len = 2048;
 432       ninfo = xtrymalloc (ninfo_len);
 433       if (!ninfo)
 434         {
 435           err = gpg_error_from_syserror ();
 436           goto leave;
 437         }
 438
 439       if (GetNetworkParams (ninfo, &ninfo_len))
 440         {
 441           log_error ("GetNetworkParms failed: %s\n", w32_strerror (-1));
 442           err = gpg_error (GPG_ERR_GENERAL);
 443           xfree (ninfo);
 444           goto leave;
 445         }
 446
 447       for (idx=0, pip = &(ninfo->DnsServerList);
 448            pip && idx < DIM (ld.resolv_conf->nameserver);
 449            pip = pip->Next)
 450         {
 451           if (opt_debug)
 452             log_debug ("dns: dnsserver[%d] '%s'\n", idx, pip->IpAddress.String);
 453           err = libdns_error_to_gpg_error
 454             (dns_resconf_pton (&ld.resolv_conf->nameserver[idx],
 455                                pip->IpAddress.String));
 456           if (err)
 457             log_error ("failed to set nameserver[%d] '%s': %s\n",
 458                        idx, pip->IpAddress.String, gpg_strerror (err));
 459           else
 460             idx++;
 461         }
 462       xfree (ninfo);
 463
 464 #else /* Unix */
 465       const char *fname;
 466
 467       fname = "/etc/resolv.conf";
 468       err = libdns_error_to_gpg_error
 469         (dns_resconf_loadpath (ld.resolv_conf, fname));
 470       if (err)
 471         {
 472           log_error ("failed to load '%s': %s\n", fname, gpg_strerror (err));
 473           goto leave;
 474         }
 475
 476       fname = "/etc/nsswitch.conf";
 477       err = libdns_error_to_gpg_error
 478         (dns_nssconf_loadpath (ld.resolv_conf, fname));
 479       if (err)
 480         {
 481           log_error ("failed to load '%s': %s\n", fname, gpg_strerror (err));
 482           goto leave;
 483         }
 484
 485 #endif /* Unix */
 486     }
 487
 488   ld.hosts = dns_hosts_open (&derr);
 489   if (!ld.hosts)
 490     {
 491       log_error ("failed to load hosts file: %s\n", gpg_strerror (err));
 492       err = libdns_error_to_gpg_error (derr);
 493       goto leave;
 494     }
 495
 496   /* dns_hints_local for stub mode, dns_hints_root for recursive.  */
 497   ld.hints = (recursive_resolver
 498               ? dns_hints_root  (ld.resolv_conf, &derr)
 499               : dns_hints_local (ld.resolv_conf, &derr));
 500   if (!ld.hints)
 501     {
 502       log_error ("failed to load DNS hints: %s\n", gpg_strerror (err));
 503       err = libdns_error_to_gpg_error (derr);
 504       goto leave;
 505     }
 506
 507   /* All fine.  Make the data global.  */
 508   libdns = ld;
 509
 510  leave:
 511   xfree (cfgstr);
 512   return err;
 513 }
 514 #endif /*USE_LIBDNS*/
 515
 516
 517 #ifdef USE_LIBDNS
 518 /* Deinitialize libdns.  */
 519 static void
 520 libdns_deinit (void)
 521 {
 522   struct libdns_s ld;
 523
 524   if (!libdns.resolv_conf)
 525     return; /* Not initialized.  */
 526
 527   ld = libdns;
 528   memset (&libdns, 0, sizeof libdns);
 529   dns_hints_close (ld.hints);
 530   dns_hosts_close (ld.hosts);
 531   dns_resconf_close (ld.resolv_conf);
 532 }
 533 #endif /*USE_LIBDNS*/
 534
 535
 536 /* SIGHUP action handler for this module.  With FORCE set objects are
 537  * all immediately released. */
 538 void
 539 reload_dns_stuff (int force)
 540 {
 541 #ifdef USE_LIBDNS
 542   if (force)
 543     {
 544       libdns_deinit ();
 545       libdns_reinit_pending = 0;
 546     }
 547   else
 548     libdns_reinit_pending = 1;
 549 #else
 550   (void)force;
 551 #endif
 552 }
 553
 554
 555 #ifdef USE_LIBDNS
 556 /*
 557  * Initialize libdns if needed and open a dns_resolver context.
 558  * Returns 0 on success and stores the new context at R_RES.  On
 559  * failure an error code is returned and NULL stored at R_RES.
 560  */
 561 static gpg_error_t
 562 libdns_res_open (struct dns_resolver **r_res)
 563 {
 564   gpg_error_t err;
 565   struct dns_resolver *res;
 566   int derr;
 567
 568   *r_res = NULL;
 569
 570   if (libdns_reinit_pending)
 571     {
 572       libdns_reinit_pending = 0;
 573       libdns_deinit ();
 574     }
 575
 576   err = libdns_init ();
 577   if (err)
 578     return err;
 579
 580   if (!opt_timeout)
 581     set_dns_timeout (0);
 582
 583   res = dns_res_open (libdns.resolv_conf, libdns.hosts, libdns.hints, NULL,
 584                       dns_opts (.socks_host     = &libdns.socks_host,
 585                                 .socks_user     = tor_socks_user,
 586                                 .socks_password = tor_socks_password ),
 587                       &derr);
 588   if (!res)
 589     return libdns_error_to_gpg_error (derr);
 590
 591   *r_res = res;
 592   return 0;
 593 }
 594 #endif /*USE_LIBDNS*/
 595
 596
 597 #ifdef USE_LIBDNS
 598 /* Helper to test whether we need totry again after having swicthed
 599  * the Tor port.  */
 600 static int
 601 libdns_switch_port_p (gpg_error_t err)
 602 {
 603   if (tor_mode && gpg_err_code (err) == GPG_ERR_ECONNREFUSED
 604       && libdns_tor_port == TOR_PORT)
 605     {
 606       /* Switch port and try again.  */
 607       if (opt_debug)
 608         log_debug ("dns: switching from SOCKS port %d to %d\n",
 609                    TOR_PORT, TOR_PORT2);
 610       libdns_tor_port = TOR_PORT2;
 611       libdns_reinit_pending = 1;
 612       return 1;
 613     }
 614   return 0;
 615 }
 616 #endif /*USE_LIBDNS*/
 617
 618
 619 #ifdef USE_LIBDNS
 620 /* Wrapper around dns_res_submit.  */
 621 static gpg_error_t
 622 libdns_res_submit (struct dns_resolver *res, const char *qname,
 623                    enum dns_type qtype, enum dns_class qclass)
 624 {
 625   return libdns_error_to_gpg_error (dns_res_submit (res, qname, qtype, qclass));
 626 }
 627 #endif /*USE_LIBDNS*/
 628
 629
 630 #ifdef USE_LIBDNS
 631 /* Standard event handling loop.  */
 632 gpg_error_t
 633 libdns_res_wait (struct dns_resolver *res)
 634 {
 635   gpg_error_t err;
 636
 637   while ((err = libdns_error_to_gpg_error (dns_res_check (res)))
 638          && gpg_err_code (err) == GPG_ERR_EAGAIN)
 639     {
 640       if (dns_res_elapsed (res) > opt_timeout)
 641         {
 642           err = gpg_error (GPG_ERR_DNS_TIMEOUT);
 643           break;
 644         }
 645
 646       my_unprotect ();
 647       dns_res_poll (res, 1);
 648       my_protect ();
 649     }
 650
 651   return err;
 652 }
 653 #endif /*USE_LIBDNS*/
 654
 655
 656 #ifdef USE_LIBDNS
 657 static gpg_error_t
 658 resolve_name_libdns (const char *name, unsigned short port,
 659                      int want_family, int want_socktype,
 660                      dns_addrinfo_t *r_dai, char **r_canonname)
 661 {
 662   gpg_error_t err;
 663   dns_addrinfo_t daihead = NULL;
 664   dns_addrinfo_t dai;
 665   struct dns_resolver *res = NULL;
 666   struct dns_addrinfo *ai = NULL;
 667   struct addrinfo hints;
 668   struct addrinfo *ent;
 669   char portstr_[21];
 670   char *portstr = NULL;
 671   int derr;
 672
 673   *r_dai = NULL;
 674   if (r_canonname)
 675     *r_canonname = NULL;
 676
 677   memset (&hints, 0, sizeof hints);
 678   hints.ai_family = want_family;
 679   hints.ai_socktype = want_socktype;
 680   hints.ai_flags = AI_ADDRCONFIG;
 681   if (r_canonname)
 682     hints.ai_flags |= AI_CANONNAME;
 683
 684   if (port)
 685     {
 686       snprintf (portstr_, sizeof portstr_, "%hu", port);
 687       portstr = portstr_;
 688     }
 689
 690   err = libdns_res_open (&res);
 691   if (err)
 692     goto leave;
 693
 694   ai = dns_ai_open (name, portstr, 0, &hints, res, &derr);
 695   if (!ai)
 696     {
 697       err = libdns_error_to_gpg_error (derr);
 698       goto leave;
 699     }
 700
 701   /* Loop over all records.  */
 702   for (;;)
 703     {
 704       err = libdns_error_to_gpg_error (dns_ai_nextent (&ent, ai));
 705       if (gpg_err_code (err) == GPG_ERR_ENOENT)
 706         {
 707           if (daihead)
 708             err = 0; /* We got some results, we're good.  */
 709           break; /* Ready.  */
 710         }
 711       if (gpg_err_code (err) == GPG_ERR_EAGAIN)
 712         {
 713           if (dns_ai_elapsed (ai) > opt_timeout)
 714             {
 715               err = gpg_error (GPG_ERR_DNS_TIMEOUT);
 716               goto leave;
 717             }
 718
 719           my_unprotect ();
 720           dns_ai_poll (ai, 1);
 721           my_protect ();
 722           continue;
 723         }
 724       if (err)
 725         goto leave;
 726
 727       if (r_canonname && ! *r_canonname && ent && ent->ai_canonname)
 728         {
 729           *r_canonname = xtrystrdup (ent->ai_canonname);
 730           if (!*r_canonname)
 731             {
 732               err = gpg_error_from_syserror ();
 733               goto leave;
 734             }
 735         }
 736
 737       dai = xtrymalloc (sizeof *dai + ent->ai_addrlen -1);
 738       if (dai == NULL)
 739         {
 740           err = gpg_error_from_syserror ();
 741           goto leave;
 742         }
 743
 744       dai->family = ent->ai_family;
 745       dai->socktype = ent->ai_socktype;
 746       dai->protocol = ent->ai_protocol;
 747       dai->addrlen = ent->ai_addrlen;
 748       memcpy (dai->addr, ent->ai_addr, ent->ai_addrlen);
 749       dai->next = daihead;
 750       daihead = dai;
 751
 752       xfree (ent);
 753   }
 754
 755  leave:
 756   dns_ai_close (ai);
 757   dns_res_close (res);
 758
 759   if (err)
 760     {
 761       if (r_canonname)
 762         {
 763           xfree (*r_canonname);
 764           *r_canonname = NULL;
 765         }
 766       free_dns_addrinfo (daihead);
 767     }
 768   else
 769     *r_dai = daihead;
 770
 771   return err;
 772 }
 773 #endif /*USE_LIBDNS*/
 774
 775
 776 /* Resolve a name using the standard system function.  */
 777 static gpg_error_t
 778 resolve_name_standard (const char *name, unsigned short port,
 779                        int want_family, int want_socktype,
 780                        dns_addrinfo_t *r_dai, char **r_canonname)
 781 {
 782   gpg_error_t err = 0;
 783   dns_addrinfo_t daihead = NULL;
 784   dns_addrinfo_t dai;
 785   struct addrinfo *aibuf = NULL;
 786   struct addrinfo hints, *ai;
 787   char portstr[21];
 788   int ret;
 789
 790   *r_dai = NULL;
 791   if (r_canonname)
 792     *r_canonname = NULL;
 793
 794   memset (&hints, 0, sizeof hints);
 795   hints.ai_family = want_family;
 796   hints.ai_socktype = want_socktype;
 797   hints.ai_flags = AI_ADDRCONFIG;
 798   if (r_canonname)
 799     hints.ai_flags |= AI_CANONNAME;
 800
 801   if (port)
 802     snprintf (portstr, sizeof portstr, "%hu", port);
 803   else
 804     *portstr = 0;
 805
 806   /* We can't use the the AI_IDN flag because that does the conversion
 807      using the current locale.  However, GnuPG always used UTF-8.  To
 808      support IDN we would need to make use of the libidn API.  */
 809   ret = getaddrinfo (name, *portstr? portstr : NULL, &hints, &aibuf);
 810   if (ret)
 811     {
 812       aibuf = NULL;
 813       err = map_eai_to_gpg_error (ret);
 814       if (gpg_err_code (err) == GPG_ERR_NO_NAME)
 815         {
 816           /* There seems to be a bug in the glibc getaddrinfo function
 817              if the CNAME points to a long list of A and AAAA records
 818              in which case the function return NO_NAME.  Let's do the
 819              CNAME redirection again.  */
 820           char *cname;
 821
 822           if (get_dns_cname (name, &cname))
 823             goto leave; /* Still no success.  */
 824
 825           ret = getaddrinfo (cname, *portstr? portstr : NULL, &hints, &aibuf);
 826           xfree (cname);
 827           if (ret)
 828             {
 829               aibuf = NULL;
 830               err = map_eai_to_gpg_error (ret);
 831               goto leave;
 832             }
 833           err = 0; /* Yep, now it worked.  */
 834         }
 835       else
 836         goto leave;
 837     }
 838
 839   if (r_canonname && aibuf && aibuf->ai_canonname)
 840     {
 841       *r_canonname = xtrystrdup (aibuf->ai_canonname);
 842       if (!*r_canonname)
 843         {
 844           err = gpg_error_from_syserror ();
 845           goto leave;
 846         }
 847     }
 848
 849   for (ai = aibuf; ai; ai = ai->ai_next)
 850     {
 851       if (ai->ai_family != AF_INET6 && ai->ai_family != AF_INET)
 852         continue;
 853
 854       dai = xtrymalloc (sizeof *dai + ai->ai_addrlen - 1);
 855       dai->family = ai->ai_family;
 856       dai->socktype = ai->ai_socktype;
 857       dai->protocol = ai->ai_protocol;
 858       dai->addrlen = ai->ai_addrlen;
 859       memcpy (dai->addr, ai->ai_addr, ai->ai_addrlen);
 860       dai->next = daihead;
 861       daihead = dai;
 862     }
 863
 864  leave:
 865   if (aibuf)
 866     freeaddrinfo (aibuf);
 867   if (err)
 868     {
 869       if (r_canonname)
 870         {
 871           xfree (*r_canonname);
 872           *r_canonname = NULL;
 873         }
 874       free_dns_addrinfo (daihead);
 875     }
 876   else
 877     *r_dai = daihead;
 878   return err;
 879 }
 880
 881
 882 /* Resolve an address using the standard system function.  */
 883 static gpg_error_t
 884 resolve_addr_standard (const struct sockaddr *addr, int addrlen,
 885                        unsigned int flags, char **r_name)
 886 {
 887   gpg_error_t err;
 888   int ec;
 889   char *buffer, *p;
 890   int buflen;
 891
 892   *r_name = NULL;
 893
 894   buflen = NI_MAXHOST;
 895   buffer = xtrymalloc (buflen + 2 + 1);
 896   if (!buffer)
 897     return gpg_error_from_syserror ();
 898
 899   if ((flags & DNS_NUMERICHOST) || tor_mode)
 900     ec = EAI_NONAME;
 901   else
 902     ec = getnameinfo (addr, addrlen, buffer, buflen, NULL, 0, NI_NAMEREQD);
 903
 904   if (!ec && *buffer == '[')
 905     ec = EAI_FAIL;  /* A name may never start with a bracket.  */
 906   else if (ec == EAI_NONAME)
 907     {
 908       p = buffer;
 909       if (addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
 910         {
 911           *p++ = '[';
 912           buflen -= 2;
 913         }
 914       ec = getnameinfo (addr, addrlen, p, buflen, NULL, 0, NI_NUMERICHOST);
 915       if (!ec && addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
 916         strcat (buffer, "]");
 917     }
 918
 919   if (ec)
 920     err = map_eai_to_gpg_error (ec);
 921   else
 922     {
 923       p = xtryrealloc (buffer, strlen (buffer)+1);
 924       if (!p)
 925         err = gpg_error_from_syserror ();
 926       else
 927         {
 928           buffer = p;
 929           err = 0;
 930         }
 931     }
 932
 933   if (err)
 934     xfree (buffer);
 935   else
 936     *r_name = buffer;
 937
 938   return err;
 939 }
 940
 941
 942 /* This a wrapper around getaddrinfo with slightly different semantics.
 943    NAME is the name to resolve.
 944    PORT is the requested port or 0.
 945    WANT_FAMILY is either 0 (AF_UNSPEC), AF_INET6, or AF_INET4.
 946    WANT_SOCKETTYPE is either SOCK_STREAM or SOCK_DGRAM.
 947
 948    On success the result is stored in a linked list with the head
 949    stored at the address R_AI; the caller must call gpg_addrinfo_free
 950    on this.  If R_CANONNAME is not NULL the official name of the host
 951    is stored there as a malloced string; if that name is not available
 952    NULL is stored.  */
 953 gpg_error_t
 954 resolve_dns_name (const char *name, unsigned short port,
 955                   int want_family, int want_socktype,
 956                   dns_addrinfo_t *r_ai, char **r_canonname)
 957 {
 958   gpg_error_t err;
 959
 960 #ifdef USE_LIBDNS
 961   if (!standard_resolver)
 962     {
 963       err = resolve_name_libdns (name, port, want_family, want_socktype,
 964                                   r_ai, r_canonname);
 965       if (err && libdns_switch_port_p (err))
 966         err = resolve_name_libdns (name, port, want_family, want_socktype,
 967                                    r_ai, r_canonname);
 968     }
 969   else
 970 #endif /*USE_LIBDNS*/
 971     err = resolve_name_standard (name, port, want_family, want_socktype,
 972                                  r_ai, r_canonname);
 973   if (opt_debug)
 974     log_debug ("dns: resolve_dns_name(%s): %s\n", name, gpg_strerror (err));
 975   return err;
 976 }
 977
 978
 979 gpg_error_t
 980 resolve_dns_addr (const struct sockaddr *addr, int addrlen,
 981                   unsigned int flags, char **r_name)
 982 {
 983   return resolve_addr_standard (addr, addrlen, flags, r_name);
 984 }
 985
 986
 987 /* Check whether NAME is an IP address.  Returns true if it is either
 988    an IPv6 or IPv4 numerical address.  */
 989 int
 990 is_ip_address (const char *name)
 991 {
 992   const char *s;
 993   int ndots, dblcol, n;
 994
 995   if (*name == '[')
 996     return 1; /* yes: A legal DNS name may not contain this character;
 997                  this mut be bracketed v6 address.  */
 998   if (*name == '.')
 999     return 0; /* No.  A leading dot is not a valid IP address.  */
1000
1001   /* Check whether this is a v6 address.  */
1002   ndots = n = dblcol = 0;
1003   for (s=name; *s; s++)
1004     {
1005       if (*s == ':')
1006         {
1007           ndots++;
1008           if (s[1] == ':')
1009             {
1010               ndots++;
1011               if (dblcol)
1012                 return 0; /* No: Only one "::" allowed.  */
1013               dblcol++;
1014               if (s[1])
1015                 s++;
1016             }
1017           n = 0;
1018         }
1019       else if (*s == '.')
1020         goto legacy;
1021       else if (!strchr ("0123456789abcdefABCDEF", *s))
1022         return 0; /* No: Not a hex digit.  */
1023       else if (++n > 4)
1024         return 0; /* To many digits in a group.  */
1025     }
1026   if (ndots > 7)
1027     return 0; /* No: Too many colons.  */
1028   else if (ndots > 1)
1029     return 1; /* Yes: At least 2 colons indicate an v6 address.  */
1030
1031  legacy:
1032   /* Check whether it is legacy IP address.  */
1033   ndots = n = 0;
1034   for (s=name; *s; s++)
1035     {
1036       if (*s == '.')
1037         {
1038           if (s[1] == '.')
1039             return 0; /* No:  Douple dot. */
1040           if (atoi (s+1) > 255)
1041             return 0; /* No:  Ipv4 byte value too large.  */
1042           ndots++;
1043           n = 0;
1044         }
1045       else if (!strchr ("0123456789", *s))
1046         return 0; /* No: Not a digit.  */
1047       else if (++n > 3)
1048         return 0; /* No: More than 3 digits.  */
1049     }
1050   return !!(ndots == 3);
1051 }
1052
1053
1054 /* Return true if NAME is an onion address.  */
1055 int
1056 is_onion_address (const char *name)
1057 {
1058   size_t len;
1059
1060   len = name? strlen (name) : 0;
1061   if (len < 8 || strcmp (name + len - 6, ".onion"))
1062     return 0;
1063   /* Note that we require at least 2 characters before the suffix.  */
1064   return 1;  /* Yes.  */
1065 }
1066
1067
1068 /* libdns version of get_dns_cert.  */
1069 #ifdef USE_LIBDNS
1070 static gpg_error_t
1071 get_dns_cert_libdns (const char *name, int want_certtype,
1072                      void **r_key, size_t *r_keylen,
1073                      unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
1074 {
1075   gpg_error_t err;
1076   struct dns_resolver *res = NULL;
1077   struct dns_packet *ans = NULL;
1078   struct dns_rr rr;
1079   struct dns_rr_i rri;
1080   char host[DNS_D_MAXNAME + 1];
1081   int derr;
1082   int qtype;
1083
1084   /* Gte the query type from WANT_CERTTYPE (which in general indicates
1085    * the subtype we want). */
1086   qtype = (want_certtype < DNS_CERTTYPE_RRBASE
1087            ? T_CERT
1088            : (want_certtype - DNS_CERTTYPE_RRBASE));
1089
1090
1091   err = libdns_res_open (&res);
1092   if (err)
1093     goto leave;
1094
1095   if (dns_d_anchor (host, sizeof host, name, strlen (name)) >= sizeof host)
1096     {
1097       err = gpg_error (GPG_ERR_ENAMETOOLONG);
1098       goto leave;
1099     }
1100
1101   err = libdns_res_submit (res, name, qtype, DNS_C_IN);
1102   if (err)
1103     goto leave;
1104
1105   err = libdns_res_wait (res);
1106   if (err)
1107     goto leave;
1108
1109   ans = dns_res_fetch (res, &derr);
1110   if (!ans)
1111     {
1112       err = libdns_error_to_gpg_error (derr);
1113       goto leave;
1114     }
1115
1116   /* Check the rcode.  */
1117   switch (dns_p_rcode (ans))
1118     {
1119     case DNS_RC_NOERROR: break;
1120     case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
1121     default: err = GPG_ERR_SERVER_FAILED; break;
1122     }
1123   if (err)
1124     goto leave;
1125
1126   memset (&rri, 0, sizeof rri);
1127   dns_rr_i_init (&rri, ans);
1128   rri.section = DNS_S_ALL & ~DNS_S_QD;
1129   rri.name    = host;
1130   rri.type    = qtype;
1131
1132   err = gpg_error (GPG_ERR_NOT_FOUND);
1133   while (dns_rr_grep (&rr, 1, &rri, ans, &derr))
1134     {
1135       unsigned char *rp  = ans->data + rr.rd.p;
1136       unsigned short len = rr.rd.len;
1137       u16 subtype;
1138
1139        if (!len)
1140         {
1141           /* Definitely too short - skip.  */
1142         }
1143       else if (want_certtype >= DNS_CERTTYPE_RRBASE
1144           && rr.type == (want_certtype - DNS_CERTTYPE_RRBASE)
1145           && r_key)
1146         {
1147           *r_key = xtrymalloc (len);
1148           if (!*r_key)
1149             err = gpg_error_from_syserror ();
1150           else
1151             {
1152               memcpy (*r_key, rp, len);
1153               *r_keylen = len;
1154               err = 0;
1155             }
1156           goto leave;
1157         }
1158       else if (want_certtype >= DNS_CERTTYPE_RRBASE)
1159         {
1160           /* We did not found the requested RR - skip. */
1161         }
1162       else if (rr.type == T_CERT && len > 5)
1163         {
1164           /* We got a CERT type.   */
1165           subtype = buf16_to_u16 (rp);
1166           rp += 2; len -= 2;
1167
1168           /* Skip the CERT key tag and algo which we don't need.  */
1169           rp += 3; len -= 3;
1170
1171           if (want_certtype && want_certtype != subtype)
1172             ; /* Not the requested subtype - skip.  */
1173           else if (subtype == DNS_CERTTYPE_PGP && len && r_key && r_keylen)
1174             {
1175               /* PGP subtype */
1176               *r_key = xtrymalloc (len);
1177               if (!*r_key)
1178                 err = gpg_error_from_syserror ();
1179               else
1180                 {
1181                   memcpy (*r_key, rp, len);
1182                   *r_keylen = len;
1183                   err = 0;
1184                 }
1185               goto leave;
1186             }
1187           else if (subtype == DNS_CERTTYPE_IPGP
1188                    && len && len < 1023 && len >= rp[0] + 1)
1189             {
1190               /* IPGP type */
1191               *r_fprlen = rp[0];
1192               if (*r_fprlen)
1193                 {
1194                   *r_fpr = xtrymalloc (*r_fprlen);
1195                   if (!*r_fpr)
1196                     {
1197                       err = gpg_error_from_syserror ();
1198                       goto leave;
1199                     }
1200                   memcpy (*r_fpr, rp+1, *r_fprlen);
1201                 }
1202               else
1203                 *r_fpr = NULL;
1204
1205               if (len > *r_fprlen + 1)
1206                 {
1207                   *r_url = xtrymalloc (len - (*r_fprlen + 1) + 1);
1208                   if (!*r_url)
1209                     {
1210                       err = gpg_error_from_syserror ();
1211                       xfree (*r_fpr);
1212                       *r_fpr = NULL;
1213                       goto leave;
1214                     }
1215                   memcpy (*r_url, rp + *r_fprlen + 1, len - (*r_fprlen + 1));
1216                   (*r_url)[len - (*r_fprlen + 1)] = 0;
1217                 }
1218               else
1219                 *r_url = NULL;
1220
1221               err = 0;
1222               goto leave;
1223             }
1224           else
1225             {
1226               /* Unknown subtype or record too short - skip.  */
1227             }
1228         }
1229       else
1230         {
1231           /* Not a requested type - skip.  */
1232         }
1233     }
1234
1235  leave:
1236   dns_free (ans);
1237   dns_res_close (res);
1238   return err;
1239 }
1240 #endif /*USE_LIBDNS*/
1241
1242
1243 /* Standard resolver version of get_dns_cert.  */
1244 static gpg_error_t
1245 get_dns_cert_standard (const char *name, int want_certtype,
1246                        void **r_key, size_t *r_keylen,
1247                        unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
1248 {
1249 #ifdef HAVE_SYSTEM_RESOLVER
1250   gpg_error_t err;
1251   unsigned char *answer;
1252   int r;
1253   u16 count;
1254
1255   /* Allocate a 64k buffer which is the limit for an DNS response.  */
1256   answer = xtrymalloc (65536);
1257   if (!answer)
1258     return gpg_error_from_syserror ();
1259
1260   err = gpg_error (GPG_ERR_NOT_FOUND);
1261   r = res_query (name, C_IN,
1262                  (want_certtype < DNS_CERTTYPE_RRBASE
1263                   ? T_CERT
1264                   : (want_certtype - DNS_CERTTYPE_RRBASE)),
1265                  answer, 65536);
1266   /* Not too big, not too small, no errors and at least 1 answer. */
1267   if (r >= sizeof (HEADER) && r <= 65536
1268       && (((HEADER *)(void *) answer)->rcode) == NOERROR
1269       && (count = ntohs (((HEADER *)(void *) answer)->ancount)))
1270     {
1271       int rc;
1272       unsigned char *pt, *emsg;
1273
1274       emsg = &answer[r];
1275
1276       pt = &answer[sizeof (HEADER)];
1277
1278       /* Skip over the query */
1279
1280       rc = dn_skipname (pt, emsg);
1281       if (rc == -1)
1282         {
1283           err = gpg_error (GPG_ERR_INV_OBJ);
1284           goto leave;
1285         }
1286       pt += rc + QFIXEDSZ;
1287
1288       /* There are several possible response types for a CERT request.
1289          We're interested in the PGP (a key) and IPGP (a URI) types.
1290          Skip all others.  TODO: A key is better than a URI since
1291          we've gone through all this bother to fetch it, so favor that
1292          if we have both PGP and IPGP? */
1293
1294       while (count-- > 0 && pt < emsg)
1295         {
1296           u16 type, class, dlen, ctype;
1297
1298           rc = dn_skipname (pt, emsg);  /* the name we just queried for */
1299           if (rc == -1)
1300             {
1301               err = gpg_error (GPG_ERR_INV_OBJ);
1302               goto leave;
1303             }
1304
1305           pt += rc;
1306
1307           /* Truncated message? 15 bytes takes us to the point where
1308              we start looking at the ctype. */
1309           if ((emsg - pt) < 15)
1310             break;
1311
1312           type = buf16_to_u16 (pt);
1313           pt += 2;
1314
1315           class = buf16_to_u16 (pt);
1316           pt += 2;
1317
1318           if (class != C_IN)
1319             break;
1320
1321           /* ttl */
1322           pt += 4;
1323
1324           /* data length */
1325           dlen = buf16_to_u16 (pt);
1326           pt += 2;
1327
1328           /* Check the type and parse.  */
1329           if (want_certtype >= DNS_CERTTYPE_RRBASE
1330               && type == (want_certtype - DNS_CERTTYPE_RRBASE)
1331               && r_key)
1332             {
1333               *r_key = xtrymalloc (dlen);
1334               if (!*r_key)
1335                 err = gpg_error_from_syserror ();
1336               else
1337                 {
1338                   memcpy (*r_key, pt, dlen);
1339                   *r_keylen = dlen;
1340                   err = 0;
1341                 }
1342               goto leave;
1343             }
1344           else if (want_certtype >= DNS_CERTTYPE_RRBASE)
1345             {
1346               /* We did not found the requested RR.  */
1347               pt += dlen;
1348             }
1349           else if (type == T_CERT)
1350             {
1351               /* We got a CERT type.   */
1352               ctype = buf16_to_u16 (pt);
1353               pt += 2;
1354
1355               /* Skip the CERT key tag and algo which we don't need. */
1356               pt += 3;
1357
1358               dlen -= 5;
1359
1360               /* 15 bytes takes us to here */
1361               if (want_certtype && want_certtype != ctype)
1362                 ; /* Not of the requested certtype.  */
1363               else if (ctype == DNS_CERTTYPE_PGP && dlen && r_key && r_keylen)
1364                 {
1365                   /* PGP type */
1366                   *r_key = xtrymalloc (dlen);
1367                   if (!*r_key)
1368                     err = gpg_error_from_syserror ();
1369                   else
1370                     {
1371                       memcpy (*r_key, pt, dlen);
1372                       *r_keylen = dlen;
1373                       err = 0;
1374                     }
1375                   goto leave;
1376                 }
1377               else if (ctype == DNS_CERTTYPE_IPGP
1378                        && dlen && dlen < 1023 && dlen >= pt[0] + 1)
1379                 {
1380                   /* IPGP type */
1381                   *r_fprlen = pt[0];
1382                   if (*r_fprlen)
1383                     {
1384                       *r_fpr = xtrymalloc (*r_fprlen);
1385                       if (!*r_fpr)
1386                         {
1387                           err = gpg_error_from_syserror ();
1388                           goto leave;
1389                         }
1390                       memcpy (*r_fpr, &pt[1], *r_fprlen);
1391                     }
1392                   else
1393                     *r_fpr = NULL;
1394
1395                   if (dlen > *r_fprlen + 1)
1396                     {
1397                       *r_url = xtrymalloc (dlen - (*r_fprlen + 1) + 1);
1398                       if (!*r_url)
1399                         {
1400                           err = gpg_error_from_syserror ();
1401                           xfree (*r_fpr);
1402                           *r_fpr = NULL;
1403                           goto leave;
1404                         }
1405                       memcpy (*r_url, &pt[*r_fprlen + 1],
1406                               dlen - (*r_fprlen + 1));
1407                       (*r_url)[dlen - (*r_fprlen + 1)] = '\0';
1408                     }
1409                   else
1410                     *r_url = NULL;
1411
1412                   err = 0;
1413                   goto leave;
1414                 }
1415
1416               /* No subtype matches, so continue with the next answer. */
1417               pt += dlen;
1418             }
1419           else
1420             {
1421               /* Not a requested type - might be a CNAME. Try next item.  */
1422               pt += dlen;
1423             }
1424         }
1425     }
1426
1427  leave:
1428   xfree (answer);
1429   return err;
1430
1431 #else /*!HAVE_SYSTEM_RESOLVER*/
1432
1433   (void)name;
1434   (void)want_certtype;
1435   (void)r_key;
1436   (void)r_keylen;
1437   (void)r_fpr;
1438   (void)r_fprlen;
1439   (void)r_url;
1440   return gpg_error (GPG_ERR_NOT_SUPPORTED);
1441
1442 #endif /*!HAVE_SYSTEM_RESOLVER*/
1443 }
1444
1445
1446 /* Returns 0 on success or an error code.  If a PGP CERT record was
1447    found, the malloced data is returned at (R_KEY, R_KEYLEN) and
1448    the other return parameters are set to NULL/0.  If an IPGP CERT
1449    record was found the fingerprint is stored as an allocated block at
1450    R_FPR and its length at R_FPRLEN; an URL is is allocated as a
1451    string and returned at R_URL.  If WANT_CERTTYPE is 0 this function
1452    returns the first CERT found with a supported type; it is expected
1453    that only one CERT record is used.  If WANT_CERTTYPE is one of the
1454    supported certtypes only records with this certtype are considered
1455    and the first found is returned.  (R_KEY,R_KEYLEN) are optional. */
1456 gpg_error_t
1457 get_dns_cert (const char *name, int want_certtype,
1458               void **r_key, size_t *r_keylen,
1459               unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
1460 {
1461   gpg_error_t err;
1462
1463   if (r_key)
1464     *r_key = NULL;
1465   if (r_keylen)
1466     *r_keylen = 0;
1467   *r_fpr = NULL;
1468   *r_fprlen = 0;
1469   *r_url = NULL;
1470
1471 #ifdef USE_LIBDNS
1472   if (!standard_resolver)
1473     {
1474       err = get_dns_cert_libdns (name, want_certtype, r_key, r_keylen,
1475                                  r_fpr, r_fprlen, r_url);
1476       if (err && libdns_switch_port_p (err))
1477         err = get_dns_cert_libdns (name, want_certtype, r_key, r_keylen,
1478                                    r_fpr, r_fprlen, r_url);
1479     }
1480   else
1481 #endif /*USE_LIBDNS*/
1482     err = get_dns_cert_standard (name, want_certtype, r_key, r_keylen,
1483                                  r_fpr, r_fprlen, r_url);
1484
1485   if (opt_debug)
1486     log_debug ("dns: get_dns_cert(%s): %s\n", name, gpg_strerror (err));
1487   return err;
1488 }
1489
1490
1491 static int
1492 priosort(const void *a,const void *b)
1493 {
1494   const struct srventry *sa=a,*sb=b;
1495   if(sa->priority>sb->priority)
1496     return 1;
1497   else if(sa->priority<sb->priority)
1498     return -1;
1499   else
1500     return 0;
1501 }
1502
1503
1504 /* Libdns based helper for getsrv.  Note that it is expected that NULL
1505  * is stored at the address of LIST and 0 is stored at the address of
1506  * R_COUNT.  */
1507 #ifdef USE_LIBDNS
1508 static gpg_error_t
1509 getsrv_libdns (const char *name, struct srventry **list, unsigned int *r_count)
1510 {
1511   gpg_error_t err;
1512   struct dns_resolver *res = NULL;
1513   struct dns_packet *ans = NULL;
1514   struct dns_rr rr;
1515   struct dns_rr_i rri;
1516   char host[DNS_D_MAXNAME + 1];
1517   int derr;
1518   unsigned int srvcount = 0;
1519
1520   err = libdns_res_open (&res);
1521   if (err)
1522     goto leave;
1523
1524   if (dns_d_anchor (host, sizeof host, name, strlen (name)) >= sizeof host)
1525     {
1526       err = gpg_error (GPG_ERR_ENAMETOOLONG);
1527       goto leave;
1528     }
1529
1530   err = libdns_res_submit (res, name, DNS_T_SRV, DNS_C_IN);
1531   if (err)
1532     goto leave;
1533
1534   err = libdns_res_wait (res);
1535   if (err)
1536     goto leave;
1537
1538   ans = dns_res_fetch (res, &derr);
1539   if (!ans)
1540     {
1541       err = libdns_error_to_gpg_error (derr);
1542       goto leave;
1543     }
1544
1545   /* Check the rcode.  */
1546   switch (dns_p_rcode (ans))
1547     {
1548     case DNS_RC_NOERROR: break;
1549     case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
1550     default: err = GPG_ERR_SERVER_FAILED; break;
1551     }
1552   if (err)
1553     goto leave;
1554
1555   memset (&rri, 0, sizeof rri);
1556   dns_rr_i_init (&rri, ans);
1557   rri.section = DNS_S_ALL & ~DNS_S_QD;
1558   rri.name        = host;
1559   rri.type        = DNS_T_SRV;
1560
1561   while (dns_rr_grep (&rr, 1, &rri, ans, &derr))
1562     {
1563       struct dns_srv dsrv;
1564       struct srventry *srv;
1565       struct srventry *newlist;
1566
1567       err = libdns_error_to_gpg_error (dns_srv_parse(&dsrv, &rr, ans));
1568       if (err)
1569         goto leave;
1570
1571       newlist = xtryrealloc (*list, (srvcount+1)*sizeof(struct srventry));
1572       if (!newlist)
1573         {
1574           err = gpg_error_from_syserror ();
1575           goto leave;
1576         }
1577       *list = newlist;
1578       memset (&(*list)[srvcount], 0, sizeof(struct srventry));
1579       srv = &(*list)[srvcount];
1580       srvcount++;
1581       srv->priority = dsrv.priority;
1582       srv->weight   = dsrv.weight;
1583       srv->port     = dsrv.port;
1584       mem2str (srv->target, dsrv.target, sizeof srv->target);
1585     }
1586
1587   *r_count = srvcount;
1588
1589  leave:
1590   if (err)
1591     {
1592       xfree (*list);
1593       *list = NULL;
1594     }
1595   dns_free (ans);
1596   dns_res_close (res);
1597   return err;
1598 }
1599 #endif /*USE_LIBDNS*/
1600
1601
1602 /* Standard resolver based helper for getsrv.  Note that it is
1603  * expected that NULL is stored at the address of LIST and 0 is stored
1604  * at the address of R_COUNT.  */
1605 static gpg_error_t
1606 getsrv_standard (const char *name,
1607                  struct srventry **list, unsigned int *r_count)
1608 {
1609 #ifdef HAVE_SYSTEM_RESOLVER
1610   union {
1611     unsigned char ans[2048];
1612     HEADER header[1];
1613   } res;
1614   unsigned char *answer = res.ans;
1615   HEADER *header = res.header;
1616   unsigned char *pt, *emsg;
1617   int r, rc;
1618   u16 dlen;
1619   unsigned int srvcount = 0;
1620   u16 count;
1621
1622   /* Do not allow a query using the standard resolver in Tor mode.  */
1623   if (tor_mode)
1624     return gpg_error (GPG_ERR_NOT_ENABLED);
1625
1626   my_unprotect ();
1627   r = res_query (name, C_IN, T_SRV, answer, sizeof res.ans);
1628   my_protect ();
1629   if (r < 0)
1630     return get_h_errno_as_gpg_error ();
1631   if (r < sizeof (HEADER))
1632     return gpg_error (GPG_ERR_SERVER_FAILED);
1633   if (r > sizeof res.ans)
1634     return gpg_error (GPG_ERR_SYSTEM_BUG);
1635   if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
1636     return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found.  */
1637
1638   emsg = &answer[r];
1639   pt = &answer[sizeof(HEADER)];
1640
1641   /* Skip over the query */
1642   rc = dn_skipname (pt, emsg);
1643   if (rc == -1)
1644     goto fail;
1645
1646   pt += rc + QFIXEDSZ;
1647
1648   while (count-- > 0 && pt < emsg)
1649     {
1650       struct srventry *srv;
1651       u16 type, class;
1652       struct srventry *newlist;
1653
1654       newlist = xtryrealloc (*list, (srvcount+1)*sizeof(struct srventry));
1655       if (!newlist)
1656         goto fail;
1657       *list = newlist;
1658       memset (&(*list)[srvcount], 0, sizeof(struct srventry));
1659       srv = &(*list)[srvcount];
1660       srvcount++;
1661
1662       rc = dn_skipname (pt, emsg); /* The name we just queried for.  */
1663       if (rc == -1)
1664         goto fail;
1665       pt += rc;
1666
1667       /* Truncated message? */
1668       if ((emsg-pt) < 16)
1669         goto fail;
1670
1671       type = buf16_to_u16 (pt);
1672       pt += 2;
1673       /* We asked for SRV and got something else !? */
1674       if (type != T_SRV)
1675         goto fail;
1676
1677       class = buf16_to_u16 (pt);
1678       pt += 2;
1679       /* We asked for IN and got something else !? */
1680       if (class != C_IN)
1681         goto fail;
1682
1683       pt += 4; /* ttl */
1684       dlen = buf16_to_u16 (pt);
1685       pt += 2;
1686
1687       srv->priority = buf16_to_ushort (pt);
1688       pt += 2;
1689       srv->weight = buf16_to_ushort (pt);
1690       pt += 2;
1691       srv->port = buf16_to_ushort (pt);
1692       pt += 2;
1693
1694       /* Get the name.  2782 doesn't allow name compression, but
1695        * dn_expand still works to pull the name out of the packet. */
1696       rc = dn_expand (answer, emsg, pt, srv->target, sizeof srv->target);
1697       if (rc == 1 && srv->target[0] == 0) /* "." */
1698         {
1699           xfree(*list);
1700           *list = NULL;
1701           return 0;
1702         }
1703       if (rc == -1)
1704         goto fail;
1705       pt += rc;
1706       /* Corrupt packet? */
1707       if (dlen != rc+6)
1708         goto fail;
1709     }
1710
1711   *r_count = srvcount;
1712   return 0;
1713
1714  fail:
1715   xfree (*list);
1716   *list = NULL;
1717   return gpg_error (GPG_ERR_GENERAL);
1718
1719 #else /*!HAVE_SYSTEM_RESOLVER*/
1720
1721   (void)name;
1722   (void)list;
1723   (void)r_count;
1724   return gpg_error (GPG_ERR_NOT_SUPPORTED);
1725
1726 #endif /*!HAVE_SYSTEM_RESOLVER*/
1727 }
1728
1729
1730 /* Note that we do not return NONAME but simply store 0 at R_COUNT.  */
1731 gpg_error_t
1732 get_dns_srv (const char *name, struct srventry **list, unsigned int *r_count)
1733 {
1734   gpg_error_t err;
1735   unsigned int srvcount;
1736   int i;
1737
1738   *list = NULL;
1739   *r_count = 0;
1740   srvcount = 0;
1741 #ifdef USE_LIBDNS
1742   if (!standard_resolver)
1743     {
1744       err = getsrv_libdns (name, list, &srvcount);
1745       if (err && libdns_switch_port_p (err))
1746         err = getsrv_libdns (name, list, &srvcount);
1747     }
1748   else
1749 #endif /*USE_LIBDNS*/
1750     err = getsrv_standard (name, list, &srvcount);
1751
1752   if (err)
1753     {
1754       if (gpg_err_code (err) == GPG_ERR_NO_NAME)
1755         err = 0;
1756       goto leave;
1757     }
1758
1759   /* Now we have an array of all the srv records. */
1760
1761   /* Order by priority */
1762   qsort(*list,srvcount,sizeof(struct srventry),priosort);
1763
1764   /* For each priority, move the zero-weighted items first. */
1765   for (i=0; i < srvcount; i++)
1766     {
1767       int j;
1768
1769       for (j=i;j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
1770         {
1771           if((*list)[j].weight==0)
1772             {
1773               /* Swap j with i */
1774               if(j!=i)
1775                 {
1776                   struct srventry temp;
1777
1778                   memcpy (&temp,&(*list)[j],sizeof(struct srventry));
1779                   memcpy (&(*list)[j],&(*list)[i],sizeof(struct srventry));
1780                   memcpy (&(*list)[i],&temp,sizeof(struct srventry));
1781                 }
1782
1783               break;
1784             }
1785         }
1786     }
1787
1788   /* Run the RFC-2782 weighting algorithm.  We don't need very high
1789      quality randomness for this, so regular libc srand/rand is
1790      sufficient.  */
1791
1792   {
1793     static int done;
1794     if (!done)
1795       {
1796         done = 1;
1797         srand (time (NULL)*getpid());
1798       }
1799   }
1800
1801   for (i=0; i < srvcount; i++)
1802     {
1803       int j;
1804       float prio_count=0,chose;
1805
1806       for (j=i; j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
1807         {
1808           prio_count+=(*list)[j].weight;
1809           (*list)[j].run_count=prio_count;
1810         }
1811
1812       chose=prio_count*rand()/RAND_MAX;
1813
1814       for (j=i;j<srvcount && (*list)[i].priority==(*list)[j].priority;j++)
1815         {
1816           if (chose<=(*list)[j].run_count)
1817             {
1818               /* Swap j with i */
1819               if(j!=i)
1820                 {
1821                   struct srventry temp;
1822
1823                   memcpy(&temp,&(*list)[j],sizeof(struct srventry));
1824                   memcpy(&(*list)[j],&(*list)[i],sizeof(struct srventry));
1825                   memcpy(&(*list)[i],&temp,sizeof(struct srventry));
1826                 }
1827               break;
1828             }
1829         }
1830     }
1831
1832  leave:
1833   if (opt_debug)
1834     {
1835       if (err)
1836         log_debug ("dns: getsrv(%s): %s\n", name, gpg_strerror (err));
1837       else
1838         log_debug ("dns: getsrv(%s) -> %u records\n", name, srvcount);
1839     }
1840   if (!err)
1841     *r_count = srvcount;
1842   return err;
1843 }
1844
1845
1846 \f
1847 #ifdef USE_LIBDNS
1848 /* libdns version of get_dns_cname.  */
1849 gpg_error_t
1850 get_dns_cname_libdns (const char *name, char **r_cname)
1851 {
1852   gpg_error_t err;
1853   struct dns_resolver *res;
1854   struct dns_packet *ans = NULL;
1855   struct dns_cname cname;
1856   int derr;
1857
1858   err = libdns_res_open (&res);
1859   if (err)
1860     goto leave;
1861
1862   err = libdns_res_submit (res, name, DNS_T_CNAME, DNS_C_IN);
1863   if (err)
1864     goto leave;
1865
1866   err = libdns_res_wait (res);
1867   if (err)
1868     goto leave;
1869
1870   ans = dns_res_fetch (res, &derr);
1871   if (!ans)
1872     {
1873       err = libdns_error_to_gpg_error (derr);
1874       goto leave;
1875     }
1876
1877   /* Check the rcode.  */
1878   switch (dns_p_rcode (ans))
1879     {
1880     case DNS_RC_NOERROR: break;
1881     case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
1882     default: err = GPG_ERR_SERVER_FAILED; break;
1883     }
1884   if (err)
1885     goto leave;
1886
1887   /* Parse the result into CNAME.  */
1888   err = libdns_error_to_gpg_error (dns_p_study (ans));
1889   if (err)
1890     goto leave;
1891
1892   if (!dns_d_cname (&cname, sizeof cname, name, strlen (name), ans, &derr))
1893     {
1894       err = libdns_error_to_gpg_error (derr);
1895       goto leave;
1896     }
1897
1898   /* Copy result.  */
1899   *r_cname = xtrystrdup (cname.host);
1900   if (!*r_cname)
1901     err = gpg_error_from_syserror ();
1902
1903  leave:
1904   dns_free (ans);
1905   dns_res_close (res);
1906   return err;
1907 }
1908 #endif /*USE_LIBDNS*/
1909
1910
1911 /* Standard resolver version of get_dns_cname.  */
1912 gpg_error_t
1913 get_dns_cname_standard (const char *name, char **r_cname)
1914 {
1915 #ifdef HAVE_SYSTEM_RESOLVER
1916   gpg_error_t err;
1917   int rc;
1918   union {
1919     unsigned char ans[2048];
1920     HEADER header[1];
1921   } res;
1922   unsigned char *answer = res.ans;
1923   HEADER *header = res.header;
1924   unsigned char *pt, *emsg;
1925   int r;
1926   char *cname;
1927   int cnamesize = 1025;
1928   u16 count;
1929
1930   /* Do not allow a query using the standard resolver in Tor mode.  */
1931   if (tor_mode)
1932     return -1;
1933
1934   my_unprotect ();
1935   r = res_query (name, C_IN, T_CERT, answer, sizeof res.ans);
1936   my_protect ();
1937   if (r < 0)
1938     return get_h_errno_as_gpg_error ();
1939   if (r < sizeof (HEADER))
1940     return gpg_error (GPG_ERR_SERVER_FAILED);
1941   if (r > sizeof res.ans)
1942     return gpg_error (GPG_ERR_SYSTEM_BUG);
1943   if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
1944     return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found.  */
1945   if (count != 1)
1946     return gpg_error (GPG_ERR_SERVER_FAILED);
1947
1948   emsg = &answer[r];
1949   pt = &answer[sizeof(HEADER)];
1950   rc = dn_skipname (pt, emsg);
1951   if (rc == -1)
1952     return gpg_error (GPG_ERR_SERVER_FAILED);
1953
1954   pt += rc + QFIXEDSZ;
1955   if (pt >= emsg)
1956     return gpg_error (GPG_ERR_SERVER_FAILED);
1957
1958   rc = dn_skipname (pt, emsg);
1959   if (rc == -1)
1960     return gpg_error (GPG_ERR_SERVER_FAILED);
1961   pt += rc + 2 + 2 + 4;
1962   if (pt+2 >= emsg)
1963     return gpg_error (GPG_ERR_SERVER_FAILED);
1964   pt += 2;  /* Skip rdlen */
1965
1966   cname = xtrymalloc (cnamesize);
1967   if (!cname)
1968     return gpg_error_from_syserror ();
1969
1970   rc = dn_expand (answer, emsg, pt, cname, cnamesize -1);
1971   if (rc == -1)
1972     {
1973       xfree (cname);
1974       return gpg_error (GPG_ERR_SERVER_FAILED);
1975     }
1976   *r_cname = xtryrealloc (cname, strlen (cname)+1);
1977   if (!*r_cname)
1978     {
1979       err = gpg_error_from_syserror ();
1980       xfree (cname);
1981       return err;
1982     }
1983   return 0;
1984
1985 #else /*!HAVE_SYSTEM_RESOLVER*/
1986
1987   (void)name;
1988   (void)r_cname;
1989   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1990
1991 #endif /*!HAVE_SYSTEM_RESOLVER*/
1992 }
1993
1994
1995 gpg_error_t
1996 get_dns_cname (const char *name, char **r_cname)
1997 {
1998   gpg_error_t err;
1999
2000   *r_cname = NULL;
2001
2002 #ifdef USE_LIBDNS
2003   if (!standard_resolver)
2004     {
2005       err = get_dns_cname_libdns (name, r_cname);
2006       if (err && libdns_switch_port_p (err))
2007         err = get_dns_cname_libdns (name, r_cname);
2008       return err;
2009     }
2010 #endif /*USE_LIBDNS*/
2011
2012   err = get_dns_cname_standard (name, r_cname);
2013   if (opt_debug)
2014     log_debug ("get_dns_cname(%s)%s%s\n", name,
2015                err ? ": " : " -> ",
2016                err ? gpg_strerror (err) : *r_cname);
2017   return err;
2018 }