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