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