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