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