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