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