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