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