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