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