(_nss_dns_gethostbyname2_r): If res_search fails don't rely on errno value.
[kopensolaris-gnu/glibc.git] / resolv / nss_dns / dns-host.c
1 /* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Extended from original form by Ulrich Drepper <drepper@cygnus.com>, 1996.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 /* Parts of this file are plain copies of the file `gethtnamadr.c' from
21    the bind package and it has the following copyright.  */
22
23 /*
24  * ++Copyright++ 1985, 1988, 1993
25  * -
26  * Copyright (c) 1985, 1988, 1993
27  *    The Regents of the University of California.  All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  * 1. Redistributions of source code must retain the above copyright
33  *    notice, this list of conditions and the following disclaimer.
34  * 2. Redistributions in binary form must reproduce the above copyright
35  *    notice, this list of conditions and the following disclaimer in the
36  *    documentation and/or other materials provided with the distribution.
37  * 4. Neither the name of the University nor the names of its contributors
38  *    may be used to endorse or promote products derived from this software
39  *    without specific prior written permission.
40  *
41  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * -
53  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
54  *
55  * Permission to use, copy, modify, and distribute this software for any
56  * purpose with or without fee is hereby granted, provided that the above
57  * copyright notice and this permission notice appear in all copies, and that
58  * the name of Digital Equipment Corporation not be used in advertising or
59  * publicity pertaining to distribution of the document or software without
60  * specific, written prior permission.
61  *
62  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
63  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
64  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
65  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
66  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
67  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
68  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
69  * SOFTWARE.
70  * -
71  * --Copyright--
72  */
73
74 #include <ctype.h>
75 #include <errno.h>
76 #include <netdb.h>
77 #include <stdio.h>
78 #include <stdlib.h>
79 #include <stddef.h>
80 #include <string.h>
81 #include <sys/syslog.h>
82
83 #include "nsswitch.h"
84
85 /* Get implementation for some internal functions.  */
86 #include <resolv/mapv4v6addr.h>
87 #include <resolv/mapv4v6hostent.h>
88
89 /* Maximum number of aliases we allow.  */
90 #define MAX_NR_ALIASES  48
91 #define MAX_NR_ADDRS    48
92
93 #if PACKETSZ > 1024
94 # define MAXPACKET      PACKETSZ
95 #else
96 # define MAXPACKET      1024
97 #endif
98 /* As per RFC 1034 and 1035 a host name cannot exceed 255 octets in length.  */
99 #ifdef MAXHOSTNAMELEN
100 # undef MAXHOSTNAMELEN
101 #endif
102 #define MAXHOSTNAMELEN 256
103
104 static const char AskedForGot[] = "\
105 gethostby*.getanswer: asked for \"%s\", got \"%s\"";
106
107
108 /* We need this time later.  */
109 typedef union querybuf
110 {
111   HEADER hdr;
112   u_char buf[MAXPACKET];
113 } querybuf;
114
115 /* These functions are defined in res_comp.c.  */
116 #define NS_MAXCDNAME    255     /* maximum compressed domain name */
117 extern int __ns_name_ntop __P ((const u_char *, char *, size_t));
118 extern int __ns_name_unpack __P ((const u_char *, const u_char *,
119                                   const u_char *, u_char *, size_t));
120
121
122 static enum nss_status getanswer_r (const querybuf *answer, int anslen,
123                                     const char *qname, int qtype,
124                                     struct hostent *result, char *buffer,
125                                     size_t buflen, int *errnop, int *h_errnop);
126
127 enum nss_status
128 _nss_dns_gethostbyname2_r (const char *name, int af, struct hostent *result,
129                            char *buffer, size_t buflen, int *errnop,
130                            int *h_errnop)
131 {
132   querybuf host_buffer;
133   int size, type, n;
134   const char *cp;
135
136   switch (af) {
137   case AF_INET:
138     size = INADDRSZ;
139     type = T_A;
140     break;
141   case AF_INET6:
142     size = IN6ADDRSZ;
143     type = T_AAAA;
144     break;
145   default:
146     *h_errnop = NO_DATA;
147     *errnop = EAFNOSUPPORT;
148     return NSS_STATUS_UNAVAIL;
149   }
150
151   result->h_addrtype = af;
152   result->h_length = size;
153
154   /*
155    * if there aren't any dots, it could be a user-level alias.
156    * this is also done in res_query() since we are not the only
157    * function that looks up host names.
158    */
159   if (strchr (name, '.') == NULL && (cp = __hostalias (name)) != NULL)
160     name = cp;
161
162   n = res_search (name, C_IN, type, host_buffer.buf, sizeof (host_buffer.buf));
163   if (n < 0)
164     {
165       *h_errnop = h_errno;
166       *errnop = *h_errnop == TRY_AGAIN ? EAGAIN : ENOENT;
167       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
168     }
169
170   return getanswer_r (&host_buffer, n, name, type, result, buffer, buflen,
171                       errnop, h_errnop);
172 }
173
174
175 enum nss_status
176 _nss_dns_gethostbyname_r (const char *name, struct hostent *result,
177                           char *buffer, size_t buflen, int *errnop,
178                           int *h_errnop)
179 {
180   enum nss_status status = NSS_STATUS_NOTFOUND;
181
182   if (_res.options & RES_USE_INET6)
183     status = _nss_dns_gethostbyname2_r (name, AF_INET6, result, buffer,
184                                         buflen, errnop, h_errnop);
185   if (status == NSS_STATUS_NOTFOUND)
186     status = _nss_dns_gethostbyname2_r (name, AF_INET, result, buffer,
187                                         buflen, errnop, h_errnop);
188
189   return status;
190 }
191
192
193 enum nss_status
194 _nss_dns_gethostbyaddr_r (const char *addr, size_t len, int af,
195                           struct hostent *result, char *buffer, size_t buflen,
196                           int *errnop, int *h_errnop)
197 {
198   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
199   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
200   const u_char *uaddr = (const u_char *)addr;
201   struct host_data
202   {
203     char *aliases[MAX_NR_ALIASES];
204     unsigned char host_addr[16];        /* IPv4 or IPv6 */
205     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
206     char linebuffer[0];
207   } *host_data = (struct host_data *) buffer;
208   querybuf host_buffer;
209   char qbuf[MAXDNAME+1], *qp;
210   size_t size;
211   int n, status;
212
213   if (af == AF_INET6 && len == IN6ADDRSZ &&
214       (memcmp (uaddr, mapped, sizeof mapped) == 0
215        || memcmp (uaddr, tunnelled, sizeof tunnelled) == 0))
216     {
217       /* Unmap. */
218       addr += sizeof mapped;
219       uaddr += sizeof mapped;
220       af = AF_INET;
221       len = INADDRSZ;
222     }
223
224   switch (af)
225     {
226     case AF_INET:
227       size = INADDRSZ;
228       break;
229     case AF_INET6:
230       size = IN6ADDRSZ;
231       break;
232     default:
233       *errnop = EAFNOSUPPORT;
234       *h_errnop = NETDB_INTERNAL;
235       return NSS_STATUS_UNAVAIL;
236     }
237   if (size != len)
238     {
239       *errnop = EAFNOSUPPORT;
240       *h_errnop = NETDB_INTERNAL;
241       return NSS_STATUS_UNAVAIL;
242     }
243
244   switch (af)
245     {
246     case AF_INET:
247       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
248                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
249       break;
250     case AF_INET6:
251       qp = qbuf;
252       for (n = IN6ADDRSZ - 1; n >= 0; n--)
253         qp += sprintf (qp, "%x.%x.", uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
254       strcpy (qp, "ip6.int");
255       break;
256     default:
257       /* Cannot happen.  */
258     }
259
260   n = res_query (qbuf, C_IN, T_PTR, (u_char *)host_buffer.buf,
261                  sizeof host_buffer);
262   if (n < 0)
263     {
264       *h_errnop = h_errno;
265       *errnop = errno;
266       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
267     }
268
269   status = getanswer_r (&host_buffer, n, qbuf, T_PTR, result, buffer, buflen,
270                         errnop, h_errnop);
271   if (status != NSS_STATUS_SUCCESS)
272     {
273       *h_errnop = h_errno;
274       *errnop = errno;
275       return status;
276     }
277
278 #ifdef SUNSECURITY
279   This is not implemented because it is not possible to use the current
280   source from bind in a multi-threaded program.
281 #endif
282
283   result->h_addrtype = af;
284   result->h_length = len;
285   memcpy (host_data->host_addr, addr, len);
286   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
287   host_data->h_addr_ptrs[1] = NULL;
288   if (af == AF_INET && (_res.options & RES_USE_INET6))
289     {
290       map_v4v6_address ((char *) host_data->host_addr,
291                         (char *) host_data->host_addr);
292       result->h_addrtype = AF_INET6;
293       result->h_length = IN6ADDRSZ;
294     }
295   *h_errnop = NETDB_SUCCESS;
296   return NSS_STATUS_SUCCESS;
297 }
298
299
300 static enum nss_status
301 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
302              struct hostent *result, char *buffer, size_t buflen,
303              int *errnop, int *h_errnop)
304 {
305   struct host_data
306   {
307     char *aliases[MAX_NR_ALIASES];
308     unsigned char host_addr[16];        /* IPv4 or IPv6 */
309     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
310     char linebuffer[0];
311   } *host_data = (struct host_data *) buffer;
312   int linebuflen = buflen - offsetof (struct host_data, linebuffer);
313   register const HEADER *hp;
314   const u_char *end_of_message, *cp;
315   int n, ancount, qdcount;
316   int haveanswer, had_error;
317   char *bp, **ap, **hap;
318   char tbuf[MAXDNAME];
319   const char *tname;
320   int (*name_ok) __P ((const char *));
321   u_char packtmp[NS_MAXCDNAME];
322
323   if (linebuflen < 0)
324     {
325       /* The buffer is too small.  */
326     too_small:
327       *errnop = ERANGE;
328       *h_errnop = NETDB_INTERNAL;
329       return NSS_STATUS_TRYAGAIN;
330     }
331
332   tname = qname;
333   result->h_name = NULL;
334   end_of_message = answer->buf + anslen;
335   switch (qtype)
336     {
337     case T_A:
338     case T_AAAA:
339       name_ok = res_hnok;
340       break;
341     case T_PTR:
342       name_ok = res_dnok;
343       break;
344     default:
345       *errnop = ENOENT;
346       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
347     }
348
349   /*
350    * find first satisfactory answer
351    */
352   hp = &answer->hdr;
353   bp = host_data->linebuffer;
354   ancount = ntohs (hp->ancount);
355   qdcount = ntohs (hp->qdcount);
356   cp = answer->buf + HFIXEDSZ;
357   if (qdcount != 1)
358     {
359       *h_errnop = NO_RECOVERY;
360       *errnop = ENOENT;
361       return NSS_STATUS_UNAVAIL;
362     }
363
364   n = __ns_name_unpack (answer->buf, end_of_message, cp,
365                         packtmp, sizeof packtmp);
366   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
367     {
368       if (errno == EMSGSIZE)
369         goto too_small;
370
371       n = -1;
372     }
373
374   if (n > 0 && bp[0] == '.')
375     bp[0] = '\0';
376
377   if (n < 0 || (*name_ok) (bp) == 0)
378     {
379       *errnop = errno;
380       *h_errnop = NO_RECOVERY;
381       return NSS_STATUS_UNAVAIL;
382     }
383   cp += n + QFIXEDSZ;
384
385   if (qtype == T_A || qtype == T_AAAA)
386     {
387       /* res_send() has already verified that the query name is the
388        * same as the one we sent; this just gets the expanded name
389        * (i.e., with the succeeding search-domain tacked on).
390        */
391       n = strlen (bp) + 1;             /* for the \0 */
392       if (n >= MAXHOSTNAMELEN)
393         {
394           *h_errnop = NO_RECOVERY;
395           *errnop = ENOENT;
396           return NSS_STATUS_TRYAGAIN;
397         }
398       result->h_name = bp;
399       bp += n;
400       linebuflen -= n;
401       if (linebuflen < 0)
402         goto too_small;
403       /* The qname can be abbreviated, but h_name is now absolute. */
404       qname = result->h_name;
405     }
406
407   ap = host_data->aliases;
408   *ap = NULL;
409   result->h_aliases = host_data->aliases;
410   hap = host_data->h_addr_ptrs;
411   *hap = NULL;
412   result->h_addr_list = host_data->h_addr_ptrs;
413   haveanswer = 0;
414   had_error = 0;
415
416   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
417     {
418       int type, class;
419
420       n = __ns_name_unpack (answer->buf, end_of_message, cp,
421                             packtmp, sizeof packtmp);
422       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
423         {
424           if (errno == EMSGSIZE)
425             goto too_small;
426
427           n = -1;
428         }
429
430       if (n < 0 || (*name_ok) (bp) == 0)
431         {
432           ++had_error;
433           continue;
434         }
435       cp += n;                          /* name */
436       type = _getshort (cp);
437       cp += INT16SZ;                    /* type */
438       class = _getshort (cp);
439       cp += INT16SZ + INT32SZ;          /* class, TTL */
440       n = _getshort (cp);
441       cp += INT16SZ;                    /* len */
442       if (class != C_IN)
443         {
444           /* XXX - debug? syslog? */
445           cp += n;
446           continue;                     /* XXX - had_error++ ? */
447         }
448
449       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
450         {
451           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
452             continue;
453           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
454           if (n < 0 || (*name_ok) (tbuf) == 0)
455             {
456               ++had_error;
457               continue;
458             }
459           cp += n;
460           /* Store alias.  */
461           *ap++ = bp;
462           n = strlen (bp) + 1;          /* For the \0.  */
463           if (n >= MAXHOSTNAMELEN)
464             {
465               ++had_error;
466               continue;
467             }
468           bp += n;
469           linebuflen -= n;
470           /* Get canonical name.  */
471           n = strlen (tbuf) + 1;        /* For the \0.  */
472           if (n > linebuflen)
473             goto too_small;
474           if (n >= MAXHOSTNAMELEN)
475             {
476               ++had_error;
477               continue;
478             }
479           result->h_name = bp;
480           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
481           linebuflen -= n;
482           continue;
483         }
484
485       if (qtype == T_PTR && type == T_CNAME)
486         {
487           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
488           if (n < 0 || res_dnok (tbuf) == 0)
489             {
490               ++had_error;
491               continue;
492             }
493           cp += n;
494           /* Get canonical name.  */
495           n = strlen (tbuf) + 1;   /* For the \0.  */
496           if (n > linebuflen)
497             goto too_small;
498           if (n >= MAXHOSTNAMELEN)
499             {
500               ++had_error;
501               continue;
502             }
503           tname = bp;
504           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
505           linebuflen -= n;
506           continue;
507         }
508       if (type == T_SIG || type == T_KEY || type == T_NXT)
509         {
510           /* We don't support DNSSEC yet.  For now, ignore the record
511              and send a low priority message to syslog.  */
512           syslog (LOG_DEBUG | LOG_AUTH,
513                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
514                   qname, p_class (C_IN), p_type(qtype), p_type (type));
515           cp += n;
516           continue;
517         }
518       if (type != qtype)
519         {
520           syslog (LOG_NOTICE | LOG_AUTH,
521                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
522                   qname, p_class (C_IN), p_type (qtype), p_type (type));
523           cp += n;
524           continue;                     /* XXX - had_error++ ? */
525         }
526
527       switch (type)
528         {
529         case T_PTR:
530           if (__strcasecmp (tname, bp) != 0)
531             {
532               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
533               cp += n;
534               continue;                 /* XXX - had_error++ ? */
535             }
536
537           n = __ns_name_unpack (answer->buf, end_of_message, cp,
538                                 packtmp, sizeof packtmp);
539           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
540             {
541               if (errno == EMSGSIZE)
542                 goto too_small;
543
544               n = -1;
545             }
546
547           if (n < 0 || res_hnok (bp) == 0)
548             {
549               ++had_error;
550               break;
551             }
552 #if MULTI_PTRS_ARE_ALIASES
553           cp += n;
554           if (haveanswer == 0)
555             result->h_name = bp;
556           else if (ap < &host_data->aliases[MAXALIASES-1])
557             *ap++ = bp;
558           else
559             n = -1;
560           if (n != -1)
561             {
562               n = strlen (bp) + 1;      /* for the \0 */
563               if (n >= MAXHOSTNAMELEN)
564                 {
565                   ++had_error;
566                   break;
567                 }
568               bp += n;
569               linebuflen -= n;
570             }
571           break;
572 #else
573           result->h_name = bp;
574           if (_res.options & RES_USE_INET6)
575             {
576               n = strlen (bp) + 1;      /* for the \0 */
577               if (n >= MAXHOSTNAMELEN)
578                 {
579                   ++had_error;
580                   break;
581                 }
582               bp += n;
583               linebuflen -= n;
584               map_v4v6_hostent (result, &bp, &linebuflen);
585             }
586           *h_errnop = NETDB_SUCCESS;
587           return NSS_STATUS_SUCCESS;
588 #endif
589         case T_A:
590         case T_AAAA:
591           if (strcasecmp (result->h_name, bp) != 0)
592             {
593               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
594               cp += n;
595               continue;                 /* XXX - had_error++ ? */
596             }
597           if (n != result->h_length)
598             {
599               cp += n;
600               continue;
601             }
602           if (!haveanswer)
603             {
604               register int nn;
605
606               result->h_name = bp;
607               nn = strlen (bp) + 1;     /* for the \0 */
608               bp += nn;
609               linebuflen -= nn;
610             }
611
612           linebuflen -= sizeof (align) - ((u_long) bp % sizeof (align));
613           bp += sizeof (align) - ((u_long) bp % sizeof (align));
614
615           if (n > linebuflen)
616             goto too_small;
617           if (hap >= &host_data->h_addr_ptrs[MAX_NR_ADDRS-1])
618             {
619               cp += n;
620               continue;
621             }
622           bp = __mempcpy (*hap++ = bp, cp, n);
623           cp += n;
624           linebuflen -= n;
625           break;
626         default:
627           abort ();
628         }
629       if (had_error == 0)
630         ++haveanswer;
631     }
632
633   if (haveanswer > 0)
634     {
635       *ap = NULL;
636       *hap = NULL;
637 #if defined RESOLVSORT
638       /*
639        * Note: we sort even if host can take only one address
640        * in its return structures - should give it the "best"
641        * address in that case, not some random one
642        */
643       if (_res.nsort && haveanswer > 1 && qtype == T_A)
644         addrsort (host_data->h_addr_ptrs, haveanswer);
645 #endif /*RESOLVSORT*/
646
647       if (result->h_name == NULL)
648         {
649           n = strlen (qname) + 1;       /* For the \0.  */
650           if (n > linebuflen)
651             goto too_small;
652           if (n >= MAXHOSTNAMELEN)
653             goto no_recovery;
654           result->h_name = bp;
655           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
656           linebuflen -= n;
657         }
658
659       if (_res.options & RES_USE_INET6)
660         map_v4v6_hostent (result, &bp, &linebuflen);
661       *h_errnop = NETDB_SUCCESS;
662       return NSS_STATUS_SUCCESS;
663     }
664  no_recovery:
665   *h_errnop = NO_RECOVERY;
666   *errnop = ENOENT;
667   return NSS_STATUS_TRYAGAIN;
668 }