dirmngr: Fix bugs in the standard resolver code.
[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 # ifdef HAVE_WINSOCK2_H
35 #  include <winsock2.h>
36 # endif
37 # include <windows.h>
38 #else
39 # if HAVE_SYSTEM_RESOLVER
40 #  include <netinet/in.h>
41 #  include <arpa/nameser.h>
42 #  include <resolv.h>
43 # endif
44 # include <netdb.h>
45 #endif
46 #include <string.h>
47 #include <unistd.h>
48
49 /* William Ahern's DNS library, included as a source copy.  */
50 #include "dns.h"
51
52 #ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
53 # undef USE_NPTH
54 #endif
55 #ifdef USE_NPTH
56 # include <npth.h>
57 #endif
58
59 #include "./dirmngr-err.h"
60 #include "util.h"
61 #include "host2net.h"
62 #include "dns-stuff.h"
63
64 #ifdef USE_NPTH
65 # define my_unprotect()        npth_unprotect ()
66 # define my_protect()          npth_protect ()
67 #else
68 # define my_unprotect()        do { } while(0)
69 # define my_protect()          do { } while(0)
70 #endif
71
72 /* We allow the use of 0 instead of AF_UNSPEC - check this assumption.  */
73 #if AF_UNSPEC != 0
74 # error AF_UNSPEC does not have the value 0
75 #endif
76
77 /* Windows does not support the AI_ADDRCONFIG flag - use zero instead.  */
78 #ifndef AI_ADDRCONFIG
79 # define AI_ADDRCONFIG 0
80 #endif
81
82 /* Not every installation has gotten around to supporting SRVs or
83    CERTs yet... */
84 #ifndef T_SRV
85 #define T_SRV 33
86 #endif
87 #ifndef T_CERT
88 # define T_CERT 37
89 #endif
90
91
92 /* The default nameserver used in Tor mode.  */
93 #define DEFAULT_NAMESERVER "8.8.8.8"
94
95 /* If set force the use of the standard resolver.  */
96 static int standard_resolver;
97
98 /* If set Tor mode shall be used.  */
99 static int tor_mode;
100
101 /* A string with the nameserver IP address used with Tor.
102   (40 should be sufficient for v6 but we add some extra for a scope.) */
103 static char tor_nameserver[40+20];
104
105 /* A string to hold the credentials presented to Tor.  */
106 static char tor_credentials[50];
107
108
109 /* Calling this function with YES set to True forces the use of the
110  * standard resolver even if dirmngr has been built with support for
111  * an alternative resolver.  */
112 void
113 enable_standard_resolver (int yes)
114 {
115   standard_resolver = yes;
116 }
117
118
119 /* Return true if the standard resolver is used.  */
120 int
121 standard_resolver_p (void)
122 {
123   return standard_resolver;
124 }
125
126
127 /* Sets the module in Tor mode.  Returns 0 is this is possible or an
128    error code.  */
129 gpg_error_t
130 enable_dns_tormode (int new_circuit)
131 {
132   /* XXX: dns.c doesn't support SOCKS credentials.  */
133
134   if (!*tor_credentials || new_circuit)
135     {
136       static unsigned int counter;
137
138       gpgrt_snprintf (tor_credentials, sizeof tor_credentials,
139                       "dirmngr-%lu:p%u",
140                       (unsigned long)getpid (), counter);
141       counter++;
142     }
143   tor_mode = 1;
144   return 0;
145 }
146
147
148 /* Change the default IP address of the nameserver to IPADDR.  The
149    address needs to be a numerical IP address and will be used for the
150    next DNS query.  Note that this is only used in Tor mode.  */
151 void
152 set_dns_nameserver (const char *ipaddr)
153 {
154   strncpy (tor_nameserver, ipaddr? ipaddr : DEFAULT_NAMESERVER,
155            sizeof tor_nameserver -1);
156   tor_nameserver[sizeof tor_nameserver -1] = 0;
157 }
158
159
160 /* Free an addressinfo linked list as returned by resolve_dns_name.  */
161 void
162 free_dns_addrinfo (dns_addrinfo_t ai)
163 {
164   while (ai)
165     {
166       dns_addrinfo_t next = ai->next;
167       xfree (ai);
168       ai = next;
169     }
170 }
171
172 /* Return H_ERRNO mapped to a gpg-error code.  Will never return 0. */
173 static gpg_error_t
174 get_h_errno_as_gpg_error (void)
175 {
176   gpg_err_code_t ec;
177
178   switch (h_errno)
179     {
180     case HOST_NOT_FOUND: ec = GPG_ERR_UNKNOWN_HOST; break;
181     case TRY_AGAIN:      ec = GPG_ERR_TRY_LATER; break;
182     case NO_RECOVERY:    ec = GPG_ERR_SERVER_FAILED; break;
183     case NO_DATA:        ec = GPG_ERR_NO_DATA; break;
184     default:             ec = GPG_ERR_UNKNOWN_ERRNO; break;
185     }
186   return gpg_error (ec);
187 }
188
189
190 static gpg_error_t
191 map_eai_to_gpg_error (int ec)
192 {
193   gpg_error_t err;
194
195   switch (ec)
196     {
197     case EAI_AGAIN:     err = gpg_error (GPG_ERR_EAGAIN); break;
198     case EAI_BADFLAGS:  err = gpg_error (GPG_ERR_INV_FLAG); break;
199     case EAI_FAIL:      err = gpg_error (GPG_ERR_SERVER_FAILED); break;
200     case EAI_MEMORY:    err = gpg_error (GPG_ERR_ENOMEM); break;
201 #ifdef EAI_NODATA
202     case EAI_NODATA:    err = gpg_error (GPG_ERR_NO_DATA); break;
203 #endif
204     case EAI_NONAME:    err = gpg_error (GPG_ERR_NO_NAME); break;
205     case EAI_SERVICE:   err = gpg_error (GPG_ERR_NOT_SUPPORTED); break;
206     case EAI_FAMILY:    err = gpg_error (GPG_ERR_EAFNOSUPPORT); break;
207     case EAI_SOCKTYPE:  err = gpg_error (GPG_ERR_ESOCKTNOSUPPORT); break;
208 #ifndef HAVE_W32_SYSTEM
209 # ifdef EAI_ADDRFAMILY
210     case EAI_ADDRFAMILY:err = gpg_error (GPG_ERR_EADDRNOTAVAIL); break;
211 # endif
212     case EAI_SYSTEM:    err = gpg_error_from_syserror (); break;
213 #endif
214     default:            err = gpg_error (GPG_ERR_UNKNOWN_ERRNO); break;
215     }
216   return err;
217 }
218
219 struct
220 {
221   struct dns_resolv_conf *resolv_conf;
222   struct dns_hosts *hosts;
223   struct dns_hints *hints;
224
225   struct sockaddr_storage socks_host;
226 } libdns;
227
228 static gpg_error_t
229 libdns_error_to_gpg_error (int error)
230 {
231   gpg_err_code_t ec;
232
233   switch (error)
234     {
235     case 0:
236       return 0;
237
238     default:
239       /* XXX */
240       fprintf (stderr, "libdns: %s\n", dns_strerror (error));
241       ec = GPG_ERR_GENERAL;
242       break;
243     }
244   return gpg_error (ec);
245 }
246
247 static gpg_error_t
248 libdns_init (void)
249 {
250   int error;
251
252   libdns.resolv_conf = dns_resconf_open (&error);
253   if (! libdns.resolv_conf)
254     goto leave;
255
256 #if 0
257   error = dns_resconf_pton (&libdns.resolv_conf->nameserver[0],
258                             "[127.0.0.1]:53");
259   if (error)
260     goto leave;
261 #else
262   error = dns_resconf_loadpath (libdns.resolv_conf, "/etc/resolv.conf");
263   if (error)
264     goto leave;
265
266   error = dns_nssconf_loadpath (libdns.resolv_conf, "/etc/nsswitch.conf");
267   if (error)
268     goto leave;
269 #endif
270
271   libdns.hosts = dns_hosts_open (&error);
272   if (! libdns.hosts)
273     goto leave;
274
275   /* dns_hints_local for stub mode, dns_hints_root for recursive.  */
276   libdns.hints = dns_hints_local (libdns.resolv_conf, &error);
277   if (! libdns.hints)
278     goto leave;
279
280   /* XXX */
281  leave:
282   return libdns_error_to_gpg_error (error);
283 }
284
285
286 static gpg_error_t
287 resolve_name_libdns (const char *name, unsigned short port,
288                      int want_family, int want_socktype,
289                      dns_addrinfo_t *r_dai, char **r_canonname)
290 {
291   gpg_error_t err = 0;
292   dns_addrinfo_t daihead = NULL;
293   dns_addrinfo_t dai;
294   struct dns_resolver *res;
295   struct dns_addrinfo *ai = NULL;
296   struct addrinfo hints;
297   struct addrinfo *ent;
298   char portstr_[21];
299   char *portstr = portstr_;
300   int ret;
301
302   err = libdns_init ();
303   if (err)
304     return err;
305
306   *r_dai = NULL;
307   if (r_canonname)
308     *r_canonname = NULL;
309
310   memset (&hints, 0, sizeof hints);
311   hints.ai_family = want_family;
312   hints.ai_socktype = want_socktype;
313   hints.ai_flags = AI_ADDRCONFIG;
314   if (r_canonname)
315     hints.ai_flags |= AI_CANONNAME;
316
317   if (port)
318     snprintf (portstr_, sizeof portstr_, "%hu", port);
319   else
320     portstr = NULL;
321
322   res = dns_res_open (libdns.resolv_conf, libdns.hosts, libdns.hints, NULL,
323                       dns_opts (/*.socks_host=&libdns.socks_host*/), &ret);
324   if (! res)
325     return libdns_error_to_gpg_error (ret);
326
327   ai = dns_ai_open (name, portstr, 0, &hints, res, &ret);
328   if (! ai)
329     goto leave;
330
331   /* XXX this is blocking.  */
332   do {
333     ret = dns_ai_nextent (&ent, ai);
334     switch (ret) {
335     case 0:
336       if (r_canonname && ! *r_canonname && ent && ent->ai_canonname)
337         {
338           *r_canonname = xtrystrdup (ent->ai_canonname);
339           if (!*r_canonname)
340             {
341               err = gpg_error_from_syserror ();
342               goto leave;
343             }
344         }
345
346       dai = xtrymalloc (sizeof *dai + ent->ai_addrlen - 1);
347       if (dai == NULL)
348         {
349           err = ENOMEM;
350           goto leave;
351         }
352
353       dai->family = ent->ai_family;
354       dai->socktype = ent->ai_socktype;
355       dai->protocol = ent->ai_protocol;
356       dai->addrlen = ent->ai_addrlen;
357       memcpy (dai->addr, ent->ai_addr, ent->ai_addrlen);
358       dai->next = daihead;
359       daihead = dai;
360
361       xfree (ent);
362       break;
363
364     case ENOENT:
365       break;
366
367     case EAGAIN:
368       if (dns_ai_elapsed (ai) > 30)
369         log_assert (! "XXX: query timed-out");
370
371       dns_ai_poll (ai, 1);
372       break;
373
374     default:
375       goto leave;
376     }
377   } while (ret != ENOENT);
378
379   if (ret == ENOENT && daihead != NULL)
380     ret = 0;    /* We got some results, we're good.  */
381
382  leave:
383   dns_ai_close (ai);
384   dns_res_close (res);
385
386   if (ret && ! err)
387     err = libdns_error_to_gpg_error (ret);
388
389   if (err)
390     {
391       if (r_canonname)
392         {
393           xfree (*r_canonname);
394           *r_canonname = NULL;
395         }
396       free_dns_addrinfo (daihead);
397     }
398   else
399     *r_dai = daihead;
400
401   return err;
402 }
403
404
405 /* Resolve a name using the standard system function.  */
406 static gpg_error_t
407 resolve_name_standard (const char *name, unsigned short port,
408                        int want_family, int want_socktype,
409                        dns_addrinfo_t *r_dai, char **r_canonname)
410 {
411   gpg_error_t err = 0;
412   dns_addrinfo_t daihead = NULL;
413   dns_addrinfo_t dai;
414   struct addrinfo *aibuf = NULL;
415   struct addrinfo hints, *ai;
416   char portstr[21];
417   int ret;
418
419   *r_dai = NULL;
420   if (r_canonname)
421     *r_canonname = NULL;
422
423   memset (&hints, 0, sizeof hints);
424   hints.ai_family = want_family;
425   hints.ai_socktype = want_socktype;
426   hints.ai_flags = AI_ADDRCONFIG;
427   if (r_canonname)
428     hints.ai_flags |= AI_CANONNAME;
429
430   if (port)
431     snprintf (portstr, sizeof portstr, "%hu", port);
432   else
433     *portstr = 0;
434
435   /* We can't use the the AI_IDN flag because that does the conversion
436      using the current locale.  However, GnuPG always used UTF-8.  To
437      support IDN we would need to make use of the libidn API.  */
438   ret = getaddrinfo (name, *portstr? portstr : NULL, &hints, &aibuf);
439   if (ret)
440     {
441       aibuf = NULL;
442       err = map_eai_to_gpg_error (ret);
443       if (gpg_err_code (err) == GPG_ERR_NO_NAME)
444         {
445           /* There seems to be a bug in the glibc getaddrinfo function
446              if the CNAME points to a long list of A and AAAA records
447              in which case the function return NO_NAME.  Let's do the
448              CNAME redirection again.  */
449           char *cname;
450
451           if (get_dns_cname (name, &cname))
452             goto leave; /* Still no success.  */
453
454           ret = getaddrinfo (cname, *portstr? portstr : NULL, &hints, &aibuf);
455           xfree (cname);
456           if (ret)
457             {
458               aibuf = NULL;
459               err = map_eai_to_gpg_error (ret);
460               goto leave;
461             }
462           err = 0; /* Yep, now it worked.  */
463         }
464       else
465         goto leave;
466     }
467
468   if (r_canonname && aibuf && aibuf->ai_canonname)
469     {
470       *r_canonname = xtrystrdup (aibuf->ai_canonname);
471       if (!*r_canonname)
472         {
473           err = gpg_error_from_syserror ();
474           goto leave;
475         }
476     }
477
478   for (ai = aibuf; ai; ai = ai->ai_next)
479     {
480       if (ai->ai_family != AF_INET6 && ai->ai_family != AF_INET)
481         continue;
482
483       dai = xtrymalloc (sizeof *dai + ai->ai_addrlen - 1);
484       dai->family = ai->ai_family;
485       dai->socktype = ai->ai_socktype;
486       dai->protocol = ai->ai_protocol;
487       dai->addrlen = ai->ai_addrlen;
488       memcpy (dai->addr, ai->ai_addr, ai->ai_addrlen);
489       dai->next = daihead;
490       daihead = dai;
491     }
492
493  leave:
494   if (aibuf)
495     freeaddrinfo (aibuf);
496   if (err)
497     {
498       if (r_canonname)
499         {
500           xfree (*r_canonname);
501           *r_canonname = NULL;
502         }
503       free_dns_addrinfo (daihead);
504     }
505   else
506     *r_dai = daihead;
507   return err;
508 }
509
510
511 /* Resolve an address using the standard system function.  */
512 static gpg_error_t
513 resolve_addr_standard (const struct sockaddr *addr, int addrlen,
514                        unsigned int flags, char **r_name)
515 {
516   gpg_error_t err;
517   int ec;
518   char *buffer, *p;
519   int buflen;
520
521   *r_name = NULL;
522
523   buflen = NI_MAXHOST;
524   buffer = xtrymalloc (buflen + 2 + 1);
525   if (!buffer)
526     return gpg_error_from_syserror ();
527
528   if ((flags & DNS_NUMERICHOST) || tor_mode)
529     ec = EAI_NONAME;
530   else
531     ec = getnameinfo (addr, addrlen, buffer, buflen, NULL, 0, NI_NAMEREQD);
532
533   if (!ec && *buffer == '[')
534     ec = EAI_FAIL;  /* A name may never start with a bracket.  */
535   else if (ec == EAI_NONAME)
536     {
537       p = buffer;
538       if (addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
539         {
540           *p++ = '[';
541           buflen -= 2;
542         }
543       ec = getnameinfo (addr, addrlen, p, buflen, NULL, 0, NI_NUMERICHOST);
544       if (!ec && addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
545         strcat (buffer, "]");
546     }
547
548   if (ec)
549     err = map_eai_to_gpg_error (ec);
550   else
551     {
552       p = xtryrealloc (buffer, strlen (buffer)+1);
553       if (!p)
554         err = gpg_error_from_syserror ();
555       else
556         {
557           buffer = p;
558           err = 0;
559         }
560     }
561
562   if (err)
563     xfree (buffer);
564   else
565     *r_name = buffer;
566
567   return err;
568 }
569
570
571 /* This a wrapper around getaddrinfo with slightly different semantics.
572    NAME is the name to resolve.
573    PORT is the requested port or 0.
574    WANT_FAMILY is either 0 (AF_UNSPEC), AF_INET6, or AF_INET4.
575    WANT_SOCKETTYPE is either SOCK_STREAM or SOCK_DGRAM.
576
577    On success the result is stored in a linked list with the head
578    stored at the address R_AI; the caller must call gpg_addrinfo_free
579    on this.  If R_CANONNAME is not NULL the official name of the host
580    is stored there as a malloced string; if that name is not available
581    NULL is stored.  */
582 gpg_error_t
583 resolve_dns_name (const char *name, unsigned short port,
584                   int want_family, int want_socktype,
585                   dns_addrinfo_t *r_ai, char **r_canonname)
586 {
587   if (!standard_resolver)
588     return resolve_name_libdns (name, port, want_family, want_socktype,
589                                 r_ai, r_canonname);
590
591   return resolve_name_standard (name, port, want_family, want_socktype,
592                                 r_ai, r_canonname);
593 }
594
595
596 gpg_error_t
597 resolve_dns_addr (const struct sockaddr *addr, int addrlen,
598                   unsigned int flags, char **r_name)
599 {
600   return resolve_addr_standard (addr, addrlen, flags, r_name);
601 }
602
603
604 /* Check whether NAME is an IP address.  Returns true if it is either
605    an IPv6 or IPv4 numerical address.  */
606 int
607 is_ip_address (const char *name)
608 {
609   const char *s;
610   int ndots, dblcol, n;
611
612   if (*name == '[')
613     return 1; /* yes: A legal DNS name may not contain this character;
614                  this mut be bracketed v6 address.  */
615   if (*name == '.')
616     return 0; /* No.  A leading dot is not a valid IP address.  */
617
618   /* Check whether this is a v6 address.  */
619   ndots = n = dblcol = 0;
620   for (s=name; *s; s++)
621     {
622       if (*s == ':')
623         {
624           ndots++;
625           if (s[1] == ':')
626             {
627               ndots++;
628               if (dblcol)
629                 return 0; /* No: Only one "::" allowed.  */
630               dblcol++;
631               if (s[1])
632                 s++;
633             }
634           n = 0;
635         }
636       else if (*s == '.')
637         goto legacy;
638       else if (!strchr ("0123456789abcdefABCDEF", *s))
639         return 0; /* No: Not a hex digit.  */
640       else if (++n > 4)
641         return 0; /* To many digits in a group.  */
642     }
643   if (ndots > 7)
644     return 0; /* No: Too many colons.  */
645   else if (ndots > 1)
646     return 1; /* Yes: At least 2 colons indicate an v6 address.  */
647
648  legacy:
649   /* Check whether it is legacy IP address.  */
650   ndots = n = 0;
651   for (s=name; *s; s++)
652     {
653       if (*s == '.')
654         {
655           if (s[1] == '.')
656             return 0; /* No:  Douple dot. */
657           if (atoi (s+1) > 255)
658             return 0; /* No:  Ipv4 byte value too large.  */
659           ndots++;
660           n = 0;
661         }
662       else if (!strchr ("0123456789", *s))
663         return 0; /* No: Not a digit.  */
664       else if (++n > 3)
665         return 0; /* No: More than 3 digits.  */
666     }
667   return !!(ndots == 3);
668 }
669
670
671 /* Return true if NAME is an onion address.  */
672 int
673 is_onion_address (const char *name)
674 {
675   size_t len;
676
677   len = name? strlen (name) : 0;
678   if (len < 8 || strcmp (name + len - 6, ".onion"))
679     return 0;
680   /* Note that we require at least 2 characters before the suffix.  */
681   return 1;  /* Yes.  */
682 }
683
684
685 /* libdns version of get_dns_cert.  */
686 static gpg_error_t
687 get_dns_cert_libdns (const char *name, int want_certtype,
688                      void **r_key, size_t *r_keylen,
689                      unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
690 {
691   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
692 }
693
694
695 /* Standard resolver version of get_dns_cert.  */
696 static gpg_error_t
697 get_dns_cert_standard (const char *name, int want_certtype,
698                        void **r_key, size_t *r_keylen,
699                        unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
700 {
701 #ifdef HAVE_SYSTEM_RESOLVER
702   gpg_error_t err;
703   unsigned char *answer;
704   int r;
705   u16 count;
706
707   /* Allocate a 64k buffer which is the limit for an DNS response.  */
708   answer = xtrymalloc (65536);
709   if (!answer)
710     return gpg_error_from_syserror ();
711
712   err = gpg_error (GPG_ERR_NOT_FOUND);
713   r = res_query (name, C_IN,
714                  (want_certtype < DNS_CERTTYPE_RRBASE
715                   ? T_CERT
716                   : (want_certtype - DNS_CERTTYPE_RRBASE)),
717                  answer, 65536);
718   /* Not too big, not too small, no errors and at least 1 answer. */
719   if (r >= sizeof (HEADER) && r <= 65536
720       && (((HEADER *)(void *) answer)->rcode) == NOERROR
721       && (count = ntohs (((HEADER *)(void *) answer)->ancount)))
722     {
723       int rc;
724       unsigned char *pt, *emsg;
725
726       emsg = &answer[r];
727
728       pt = &answer[sizeof (HEADER)];
729
730       /* Skip over the query */
731
732       rc = dn_skipname (pt, emsg);
733       if (rc == -1)
734         {
735           err = gpg_error (GPG_ERR_INV_OBJ);
736           goto leave;
737         }
738       pt += rc + QFIXEDSZ;
739
740       /* There are several possible response types for a CERT request.
741          We're interested in the PGP (a key) and IPGP (a URI) types.
742          Skip all others.  TODO: A key is better than a URI since
743          we've gone through all this bother to fetch it, so favor that
744          if we have both PGP and IPGP? */
745
746       while (count-- > 0 && pt < emsg)
747         {
748           u16 type, class, dlen, ctype;
749
750           rc = dn_skipname (pt, emsg);  /* the name we just queried for */
751           if (rc == -1)
752             {
753               err = gpg_error (GPG_ERR_INV_OBJ);
754               goto leave;
755             }
756
757           pt += rc;
758
759           /* Truncated message? 15 bytes takes us to the point where
760              we start looking at the ctype. */
761           if ((emsg - pt) < 15)
762             break;
763
764           type = buf16_to_u16 (pt);
765           pt += 2;
766
767           class = buf16_to_u16 (pt);
768           pt += 2;
769
770           if (class != C_IN)
771             break;
772
773           /* ttl */
774           pt += 4;
775
776           /* data length */
777           dlen = buf16_to_u16 (pt);
778           pt += 2;
779
780           /* Check the type and parse.  */
781           if (want_certtype >= DNS_CERTTYPE_RRBASE
782               && type == (want_certtype - DNS_CERTTYPE_RRBASE)
783               && r_key)
784             {
785               *r_key = xtrymalloc (dlen);
786               if (!*r_key)
787                 err = gpg_error_from_syserror ();
788               else
789                 {
790                   memcpy (*r_key, pt, dlen);
791                   *r_keylen = dlen;
792                   err = 0;
793                 }
794               goto leave;
795             }
796           else if (want_certtype >= DNS_CERTTYPE_RRBASE)
797             {
798               /* We did not found the requested RR.  */
799               pt += dlen;
800             }
801           else if (type == T_CERT)
802             {
803               /* We got a CERT type.   */
804               ctype = buf16_to_u16 (pt);
805               pt += 2;
806
807               /* Skip the CERT key tag and algo which we don't need. */
808               pt += 3;
809
810               dlen -= 5;
811
812               /* 15 bytes takes us to here */
813               if (want_certtype && want_certtype != ctype)
814                 ; /* Not of the requested certtype.  */
815               else if (ctype == DNS_CERTTYPE_PGP && dlen && r_key && r_keylen)
816                 {
817                   /* PGP type */
818                   *r_key = xtrymalloc (dlen);
819                   if (!*r_key)
820                     err = gpg_error_from_syserror ();
821                   else
822                     {
823                       memcpy (*r_key, pt, dlen);
824                       *r_keylen = dlen;
825                       err = 0;
826                     }
827                   goto leave;
828                 }
829               else if (ctype == DNS_CERTTYPE_IPGP
830                        && dlen && dlen < 1023 && dlen >= pt[0] + 1)
831                 {
832                   /* IPGP type */
833                   *r_fprlen = pt[0];
834                   if (*r_fprlen)
835                     {
836                       *r_fpr = xtrymalloc (*r_fprlen);
837                       if (!*r_fpr)
838                         {
839                           err = gpg_error_from_syserror ();
840                           goto leave;
841                         }
842                       memcpy (*r_fpr, &pt[1], *r_fprlen);
843                     }
844                   else
845                     *r_fpr = NULL;
846
847                   if (dlen > *r_fprlen + 1)
848                     {
849                       *r_url = xtrymalloc (dlen - (*r_fprlen + 1) + 1);
850                       if (!*r_fpr)
851                         {
852                           err = gpg_error_from_syserror ();
853                           xfree (*r_fpr);
854                           *r_fpr = NULL;
855                           goto leave;
856                         }
857                       memcpy (*r_url, &pt[*r_fprlen + 1],
858                               dlen - (*r_fprlen + 1));
859                       (*r_url)[dlen - (*r_fprlen + 1)] = '\0';
860                     }
861                   else
862                     *r_url = NULL;
863
864                   err = 0;
865                   goto leave;
866                 }
867
868               /* No subtype matches, so continue with the next answer. */
869               pt += dlen;
870             }
871           else
872             {
873               /* Not a requested type - might be a CNAME. Try next item.  */
874               pt += dlen;
875             }
876         }
877     }
878
879  leave:
880   xfree (answer);
881   return err;
882
883 #else /*!HAVE_SYSTEM_RESOLVER*/
884
885   (void)name;
886   (void)want_certtype;
887   (void)r_key;
888   (void)r_keylen;
889   (void)r_fpr;
890   (void)r_fprlen;
891   (void)r_url;
892   return gpg_error (GPG_ERR_NOT_SUPPORTED);
893
894 #endif /*!HAVE_SYSTEM_RESOLVER*/
895 }
896
897
898 /* Returns 0 on success or an error code.  If a PGP CERT record was
899    found, the malloced data is returned at (R_KEY, R_KEYLEN) and
900    the other return parameters are set to NULL/0.  If an IPGP CERT
901    record was found the fingerprint is stored as an allocated block at
902    R_FPR and its length at R_FPRLEN; an URL is is allocated as a
903    string and returned at R_URL.  If WANT_CERTTYPE is 0 this function
904    returns the first CERT found with a supported type; it is expected
905    that only one CERT record is used.  If WANT_CERTTYPE is one of the
906    supported certtypes only records with this certtype are considered
907    and the first found is returned.  (R_KEY,R_KEYLEN) are optional. */
908 gpg_error_t
909 get_dns_cert (const char *name, int want_certtype,
910               void **r_key, size_t *r_keylen,
911               unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
912 {
913   if (r_key)
914     *r_key = NULL;
915   if (r_keylen)
916     *r_keylen = 0;
917   *r_fpr = NULL;
918   *r_fprlen = 0;
919   *r_url = NULL;
920
921   if (!standard_resolver)
922     return get_dns_cert_libdns (name, want_certtype, r_key, r_keylen,
923                                 r_fpr, r_fprlen, r_url);
924
925   return get_dns_cert_standard (name, want_certtype, r_key, r_keylen,
926                                 r_fpr, r_fprlen, r_url);
927 }
928
929
930 static int
931 priosort(const void *a,const void *b)
932 {
933   const struct srventry *sa=a,*sb=b;
934   if(sa->priority>sb->priority)
935     return 1;
936   else if(sa->priority<sb->priority)
937     return -1;
938   else
939     return 0;
940 }
941
942
943 /* Libdns based helper for getsrv.  Note that it is expected that NULL
944  * is stored at the address of LIST and 0 is stored at the address of
945  * R_COUNT.  */
946 static gpg_error_t
947 getsrv_libdns (const char *name, struct srventry **list, int *r_count)
948 {
949   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
950 }
951
952
953 /* Standard resolver based helper for getsrv.  Note that it is
954  * expected that NULL is stored at the address of LIST and 0 is stored
955  * at the address of R_COUNT.  */
956 static int
957 getsrv_standard (const char *name, struct srventry **list, int *r_count)
958 {
959 #ifdef HAVE_SYSTEM_RESOLVER
960   union {
961     unsigned char ans[2048];
962     HEADER header[1];
963   } res;
964   unsigned char *answer = res.ans;
965   HEADER *header = res.header;
966   unsigned char *pt, *emsg;
967   int r, rc;
968   u16 dlen;
969   int srvcount=0;
970   u16 count;
971
972   /* Do not allow a query using the standard resolver in Tor mode.  */
973   if (tor_mode)
974     return gpg_error (GPG_ERR_NOT_ENABLED);
975
976   my_unprotect ();
977   r = res_query (name, C_IN, T_SRV, answer, sizeof res.ans);
978   my_protect ();
979   if (r < 0)
980     return get_h_errno_as_gpg_error ();
981   if (r < sizeof (HEADER))
982     return gpg_error (GPG_ERR_SERVER_FAILED);
983   if (r > sizeof res.ans)
984     return gpg_error (GPG_ERR_SYSTEM_BUG);
985   if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
986     return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found.  */
987
988   emsg = &answer[r];
989   pt = &answer[sizeof(HEADER)];
990
991   /* Skip over the query */
992   rc = dn_skipname (pt, emsg);
993   if (rc == -1)
994     goto fail;
995
996   pt += rc + QFIXEDSZ;
997
998   while (count-- > 0 && pt < emsg)
999     {
1000       struct srventry *srv;
1001       u16 type, class;
1002       struct srventry *newlist;
1003
1004       newlist = xtryrealloc (*list, (srvcount+1)*sizeof(struct srventry));
1005       if (!newlist)
1006         goto fail;
1007       *list = newlist;
1008       memset (&(*list)[srvcount], 0, sizeof(struct srventry));
1009       srv = &(*list)[srvcount];
1010       srvcount++;
1011
1012       rc = dn_skipname (pt, emsg); /* The name we just queried for.  */
1013       if (rc == -1)
1014         goto fail;
1015       pt += rc;
1016
1017       /* Truncated message? */
1018       if ((emsg-pt) < 16)
1019         goto fail;
1020
1021       type = buf16_to_u16 (pt);
1022       pt += 2;
1023       /* We asked for SRV and got something else !? */
1024       if (type != T_SRV)
1025         goto fail;
1026
1027       class = buf16_to_u16 (pt);
1028       pt += 2;
1029       /* We asked for IN and got something else !? */
1030       if (class != C_IN)
1031         goto fail;
1032
1033       pt += 4; /* ttl */
1034       dlen = buf16_to_u16 (pt);
1035       pt += 2;
1036
1037       srv->priority = buf16_to_ushort (pt);
1038       pt += 2;
1039       srv->weight = buf16_to_ushort (pt);
1040       pt += 2;
1041       srv->port = buf16_to_ushort (pt);
1042       pt += 2;
1043
1044       /* Get the name.  2782 doesn't allow name compression, but
1045        * dn_expand still works to pull the name out of the packet. */
1046       rc = dn_expand (answer, emsg, pt, srv->target, sizeof srv->target);
1047       if (rc == 1 && srv->target[0] == 0) /* "." */
1048         {
1049           xfree(*list);
1050           *list = NULL;
1051           return 0;
1052         }
1053       if (rc == -1)
1054         goto fail;
1055       pt += rc;
1056       /* Corrupt packet? */
1057       if (dlen != rc+6)
1058         goto fail;
1059     }
1060
1061   *r_count = srvcount;
1062   return 0;
1063
1064  fail:
1065   xfree (*list);
1066   *list = NULL;
1067   return gpg_error (GPG_ERR_GENERAL);
1068
1069 #else /*!HAVE_SYSTEM_RESOLVER*/
1070
1071   (void)name;
1072   (void)list;
1073   (void)r_count;
1074   return gpg_error (GPG_ERR_NOT_SUPPORTED);
1075
1076 #endif /*!HAVE_SYSTEM_RESOLVER*/
1077 }
1078
1079
1080 int
1081 getsrv (const char *name, struct srventry **list)
1082 {
1083   gpg_error_t err;
1084   int srvcount;
1085   int i;
1086
1087   *list = NULL;
1088   srvcount = 0;
1089   if (!standard_resolver)
1090     err = getsrv_libdns (name, list, &srvcount);
1091   else
1092     err = getsrv_standard (name, list, &srvcount);
1093
1094   if (err)
1095     return -1;  /* Ugly.  FIXME: Return an error code. */
1096
1097   /* Now we have an array of all the srv records. */
1098
1099   /* Order by priority */
1100   qsort(*list,srvcount,sizeof(struct srventry),priosort);
1101
1102   /* For each priority, move the zero-weighted items first. */
1103   for (i=0; i < srvcount; i++)
1104     {
1105       int j;
1106
1107       for (j=i;j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
1108         {
1109           if((*list)[j].weight==0)
1110             {
1111               /* Swap j with i */
1112               if(j!=i)
1113                 {
1114                   struct srventry temp;
1115
1116                   memcpy (&temp,&(*list)[j],sizeof(struct srventry));
1117                   memcpy (&(*list)[j],&(*list)[i],sizeof(struct srventry));
1118                   memcpy (&(*list)[i],&temp,sizeof(struct srventry));
1119                 }
1120
1121               break;
1122             }
1123         }
1124     }
1125
1126   /* Run the RFC-2782 weighting algorithm.  We don't need very high
1127      quality randomness for this, so regular libc srand/rand is
1128      sufficient.  */
1129
1130   {
1131     static int done;
1132     if (!done)
1133       {
1134         done = 1;
1135         srand (time (NULL)*getpid());
1136       }
1137   }
1138
1139   for (i=0; i < srvcount; i++)
1140     {
1141       int j;
1142       float prio_count=0,chose;
1143
1144       for (j=i; j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
1145         {
1146           prio_count+=(*list)[j].weight;
1147           (*list)[j].run_count=prio_count;
1148         }
1149
1150       chose=prio_count*rand()/RAND_MAX;
1151
1152       for (j=i;j<srvcount && (*list)[i].priority==(*list)[j].priority;j++)
1153         {
1154           if (chose<=(*list)[j].run_count)
1155             {
1156               /* Swap j with i */
1157               if(j!=i)
1158                 {
1159                   struct srventry temp;
1160
1161                   memcpy(&temp,&(*list)[j],sizeof(struct srventry));
1162                   memcpy(&(*list)[j],&(*list)[i],sizeof(struct srventry));
1163                   memcpy(&(*list)[i],&temp,sizeof(struct srventry));
1164                 }
1165               break;
1166             }
1167         }
1168     }
1169
1170   return srvcount;
1171 }
1172
1173
1174 /* libdns version of get_dns_cname.  */
1175 gpg_error_t
1176 get_dns_cname_libdns (const char *name, char **r_cname)
1177 {
1178   return gpg_error (ENOTSUP);
1179 }
1180
1181
1182 /* Standard resolver version of get_dns_cname.  */
1183 gpg_error_t
1184 get_dns_cname_standard (const char *name, char **r_cname)
1185 {
1186 #ifdef HAVE_SYSTEM_RESOLVER
1187   gpg_error_t err;
1188   int rc;
1189   union {
1190     unsigned char ans[2048];
1191     HEADER header[1];
1192   } res;
1193   unsigned char *answer = res.ans;
1194   HEADER *header = res.header;
1195   unsigned char *pt, *emsg;
1196   int r;
1197   char *cname;
1198   int cnamesize = 1025;
1199   u16 count;
1200
1201   /* Do not allow a query using the standard resolver in Tor mode.  */
1202   if (tor_mode)
1203     return -1;
1204
1205   my_unprotect ();
1206   r = res_query (name, C_IN, T_CERT, answer, sizeof res.ans);
1207   my_protect ();
1208   if (r < 0)
1209     return get_h_errno_as_gpg_error ();
1210   if (r < sizeof (HEADER))
1211     return gpg_error (GPG_ERR_SERVER_FAILED);
1212   if (r > sizeof res.ans)
1213     return gpg_error (GPG_ERR_SYSTEM_BUG);
1214   if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
1215     return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found.  */
1216   if (count != 1)
1217     return gpg_error (GPG_ERR_SERVER_FAILED);
1218
1219   emsg = &answer[r];
1220   pt = &answer[sizeof(HEADER)];
1221   rc = dn_skipname (pt, emsg);
1222   if (rc == -1)
1223     return gpg_error (GPG_ERR_SERVER_FAILED);
1224
1225   pt += rc + QFIXEDSZ;
1226   if (pt >= emsg)
1227     return gpg_error (GPG_ERR_SERVER_FAILED);
1228
1229   rc = dn_skipname (pt, emsg);
1230   if (rc == -1)
1231     return gpg_error (GPG_ERR_SERVER_FAILED);
1232   pt += rc + 2 + 2 + 4;
1233   if (pt+2 >= emsg)
1234     return gpg_error (GPG_ERR_SERVER_FAILED);
1235   pt += 2;  /* Skip rdlen */
1236
1237   cname = xtrymalloc (cnamesize);
1238   if (!cname)
1239     return gpg_error_from_syserror ();
1240
1241   rc = dn_expand (answer, emsg, pt, cname, cnamesize -1);
1242   if (rc == -1)
1243     {
1244       xfree (cname);
1245       return gpg_error (GPG_ERR_SERVER_FAILED);
1246     }
1247   *r_cname = xtryrealloc (cname, strlen (cname)+1);
1248   if (!*r_cname)
1249     {
1250       err = gpg_error_from_syserror ();
1251       xfree (cname);
1252       return err;
1253     }
1254   return 0;
1255
1256 #else /*!HAVE_SYSTEM_RESOLVER*/
1257
1258   (void)name;
1259   (void)r_cname;
1260   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1261
1262 #endif /*!HAVE_SYSTEM_RESOLVER*/
1263 }
1264
1265
1266 gpg_error_t
1267 get_dns_cname (const char *name, char **r_cname)
1268 {
1269   *r_cname = NULL;
1270
1271   if (!standard_resolver)
1272     return get_dns_cname_libdns (name, r_cname);
1273
1274   return get_dns_cname_standard (name, r_cname);
1275 }