(getanswer_r): Correctly track usage of user-provided buffer.
[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 = NETDB_INTERNAL;
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 = errno;
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, int 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   int size, n, status;
211
212   if (af == AF_INET6 && len == IN6ADDRSZ &&
213       (memcmp (uaddr, mapped, sizeof mapped) == 0
214        || memcmp (uaddr, tunnelled, sizeof tunnelled) == 0))
215     {
216       /* Unmap. */
217       addr += sizeof mapped;
218       uaddr += sizeof mapped;
219       af = AF_INET;
220       len = INADDRSZ;
221     }
222
223   switch (af)
224     {
225     case AF_INET:
226       size = INADDRSZ;
227       break;
228     case AF_INET6:
229       size = IN6ADDRSZ;
230       break;
231     default:
232       *errnop = EAFNOSUPPORT;
233       *h_errnop = NETDB_INTERNAL;
234       return NSS_STATUS_UNAVAIL;
235     }
236   if (size != len)
237     {
238       *errnop = EAFNOSUPPORT;
239       *h_errnop = NETDB_INTERNAL;
240       return NSS_STATUS_UNAVAIL;
241     }
242
243   switch (af)
244     {
245     case AF_INET:
246       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
247                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
248       break;
249     case AF_INET6:
250       qp = qbuf;
251       for (n = IN6ADDRSZ - 1; n >= 0; n--)
252         qp += sprintf (qp, "%x.%x.", uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
253       strcpy (qp, "ip6.int");
254       break;
255     default:
256       /* Cannot happen.  */
257     }
258
259   n = res_query (qbuf, C_IN, T_PTR, (u_char *)host_buffer.buf,
260                  sizeof host_buffer);
261   if (n < 0)
262     {
263       *h_errnop = h_errno;
264       *errnop = errno;
265       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
266     }
267
268   status = getanswer_r (&host_buffer, n, qbuf, T_PTR, result, buffer, buflen,
269                         errnop, h_errnop);
270   if (status != NSS_STATUS_SUCCESS)
271     {
272       *h_errnop = h_errno;
273       *errnop = errno;
274       return status;
275     }
276
277 #ifdef SUNSECURITY
278   This is not implemented because it is not possible to use the current
279   source from bind in a multi-threaded program.
280 #endif
281
282   result->h_addrtype = af;
283   result->h_length = len;
284   memcpy (host_data->host_addr, addr, len);
285   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
286   host_data->h_addr_ptrs[1] = NULL;
287   if (af == AF_INET && (_res.options & RES_USE_INET6))
288     {
289       map_v4v6_address ((char *) host_data->host_addr,
290                         (char *) host_data->host_addr);
291       result->h_addrtype = AF_INET6;
292       result->h_length = IN6ADDRSZ;
293     }
294   *h_errnop = NETDB_SUCCESS;
295   return NSS_STATUS_SUCCESS;
296 }
297
298
299 static enum nss_status
300 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
301              struct hostent *result, char *buffer, size_t buflen,
302              int *errnop, int *h_errnop)
303 {
304   struct host_data
305   {
306     char *aliases[MAX_NR_ALIASES];
307     unsigned char host_addr[16];        /* IPv4 or IPv6 */
308     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
309     char linebuffer[0];
310   } *host_data = (struct host_data *) buffer;
311   int linebuflen = buflen - offsetof (struct host_data, linebuffer);
312   register const HEADER *hp;
313   const u_char *end_of_message, *cp;
314   int n, ancount, qdcount;
315   int haveanswer, had_error;
316   char *bp, **ap, **hap;
317   char tbuf[MAXDNAME];
318   const char *tname;
319   int (*name_ok) __P ((const char *));
320   u_char packtmp[NS_MAXCDNAME];
321
322   if (linebuflen < 0)
323     {
324       /* The buffer is too small.  */
325     too_small:
326       *errnop = ERANGE;
327       *h_errnop = NETDB_INTERNAL;
328       return NSS_STATUS_TRYAGAIN;
329     }
330
331   tname = qname;
332   result->h_name = NULL;
333   end_of_message = answer->buf + anslen;
334   switch (qtype)
335     {
336     case T_A:
337     case T_AAAA:
338       name_ok = res_hnok;
339       break;
340     case T_PTR:
341       name_ok = res_dnok;
342       break;
343     default:
344       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
345     }
346
347   /*
348    * find first satisfactory answer
349    */
350   hp = &answer->hdr;
351   bp = host_data->linebuffer;
352   ancount = ntohs (hp->ancount);
353   qdcount = ntohs (hp->qdcount);
354   cp = answer->buf + HFIXEDSZ;
355   if (qdcount != 1)
356     {
357       *h_errnop = NO_RECOVERY;
358       return NSS_STATUS_UNAVAIL;
359     }
360
361   n = __ns_name_unpack (answer->buf, end_of_message, cp,
362                         packtmp, sizeof packtmp);
363   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
364     {
365       if (errno == EMSGSIZE)
366         goto too_small;
367
368       n = -1;
369     }
370
371   if (n > 0 && bp[0] == '.')
372     bp[0] = '\0';
373
374   if (n < 0 || (*name_ok) (bp) == 0)
375     {
376       *errnop = errno;
377       *h_errnop = NO_RECOVERY;
378       return NSS_STATUS_UNAVAIL;
379     }
380   cp += n + QFIXEDSZ;
381
382   if (qtype == T_A || qtype == T_AAAA)
383     {
384       /* res_send() has already verified that the query name is the
385        * same as the one we sent; this just gets the expanded name
386        * (i.e., with the succeeding search-domain tacked on).
387        */
388       n = strlen (bp) + 1;             /* for the \0 */
389       if (n >= MAXHOSTNAMELEN)
390         {
391           *h_errnop = NO_RECOVERY;
392           return NSS_STATUS_TRYAGAIN;
393         }
394       result->h_name = bp;
395       bp += n;
396       linebuflen -= n;
397       if (linebuflen < 0)
398         goto too_small;
399       /* The qname can be abbreviated, but h_name is now absolute. */
400       qname = result->h_name;
401     }
402
403   ap = host_data->aliases;
404   *ap = NULL;
405   result->h_aliases = host_data->aliases;
406   hap = host_data->h_addr_ptrs;
407   *hap = NULL;
408   result->h_addr_list = host_data->h_addr_ptrs;
409   haveanswer = 0;
410   had_error = 0;
411
412   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
413     {
414       int type, class;
415
416       n = __ns_name_unpack (answer->buf, end_of_message, cp,
417                             packtmp, sizeof packtmp);
418       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
419         {
420           if (errno == EMSGSIZE)
421             {
422               *errnop = ERANGE;
423               *h_errnop = NETDB_INTERNAL;
424               return NSS_STATUS_TRYAGAIN;
425             }
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 ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
473             {
474               ++had_error;
475               continue;
476             }
477           result->h_name = bp;
478           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
479           linebuflen -= n;
480           continue;
481         }
482
483       if (qtype == T_PTR && type == T_CNAME)
484         {
485           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
486           if (n < 0 || res_dnok (tbuf) == 0)
487             {
488               ++had_error;
489               continue;
490             }
491           cp += n;
492           /* Get canonical name.  */
493           n = strlen (tbuf) + 1;   /* For the \0.  */
494           if ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
495             {
496               ++had_error;
497               continue;
498             }
499           tname = bp;
500           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
501           linebuflen -= n;
502           continue;
503         }
504       if (type == T_SIG || type == T_KEY || type == T_NXT)
505         {
506           /* We don't support DNSSEC yet.  For now, ignore the record
507              and send a low priority message to syslog.  */
508           syslog (LOG_DEBUG | LOG_AUTH,
509                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
510                   qname, p_class (C_IN), p_type(qtype), p_type (type));
511           cp += n;
512           continue;
513         }
514       if (type != qtype)
515         {
516           syslog (LOG_NOTICE | LOG_AUTH,
517                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
518                   qname, p_class (C_IN), p_type (qtype), p_type (type));
519           cp += n;
520           continue;                     /* XXX - had_error++ ? */
521         }
522
523       switch (type)
524         {
525         case T_PTR:
526           if (__strcasecmp (tname, bp) != 0)
527             {
528               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
529               cp += n;
530               continue;                 /* XXX - had_error++ ? */
531             }
532
533           n = __ns_name_unpack (answer->buf, end_of_message, cp,
534                                 packtmp, sizeof packtmp);
535           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
536             {
537               if (errno == EMSGSIZE)
538                 {
539                   *errnop = ERANGE;
540                   *h_errnop = NETDB_INTERNAL;
541                   return NSS_STATUS_TRYAGAIN;
542                 }
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             {
617               ++had_error;
618               continue;
619             }
620           if (hap >= &host_data->h_addr_ptrs[MAX_NR_ADDRS-1])
621             {
622               cp += n;
623               continue;
624             }
625           bp = __mempcpy (*hap++ = bp, cp, n);
626           cp += n;
627           linebuflen -= n;
628           break;
629         default:
630           abort ();
631         }
632       if (had_error == 0)
633         ++haveanswer;
634     }
635
636   if (haveanswer > 0)
637     {
638       *ap = NULL;
639       *hap = NULL;
640 #if defined RESOLVSORT
641       /*
642        * Note: we sort even if host can take only one address
643        * in its return structures - should give it the "best"
644        * address in that case, not some random one
645        */
646       if (_res.nsort && haveanswer > 1 && qtype == T_A)
647         addrsort (host_data->h_addr_ptrs, haveanswer);
648 #endif /*RESOLVSORT*/
649
650       if (result->h_name == NULL)
651         {
652           n = strlen (qname) + 1;       /* For the \0.  */
653           if (n > linebuflen)
654             {
655               *errnop = ERANGE;
656               *h_errnop = NETDB_INTERNAL;
657               return NSS_STATUS_TRYAGAIN;
658             }
659           if (n >= MAXHOSTNAMELEN)
660             goto no_recovery;
661           result->h_name = bp;
662           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
663           linebuflen -= n;
664         }
665
666       if (_res.options & RES_USE_INET6)
667         map_v4v6_hostent (result, &bp, &linebuflen);
668       *h_errnop = NETDB_SUCCESS;
669       return NSS_STATUS_SUCCESS;
670     }
671  no_recovery:
672   *h_errnop = NO_RECOVERY;
673   return NSS_STATUS_TRYAGAIN;
674 }