(getanswer_r): Cleanup out-of-buffer handling.
[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 = 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_getipnodebyname (const char *name, int af, struct hostent *result,
195                           char *buffer, size_t buflen, int *errnop,
196                           int *h_errnop)
197 {
198 }
199
200
201 enum nss_status
202 _nss_dns_gethostbyaddr_r (const char *addr, size_t len, int af,
203                           struct hostent *result, char *buffer, size_t buflen,
204                           int *errnop, int *h_errnop)
205 {
206   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
207   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
208   const u_char *uaddr = (const u_char *)addr;
209   struct host_data
210   {
211     char *aliases[MAX_NR_ALIASES];
212     unsigned char host_addr[16];        /* IPv4 or IPv6 */
213     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
214     char linebuffer[0];
215   } *host_data = (struct host_data *) buffer;
216   querybuf host_buffer;
217   char qbuf[MAXDNAME+1], *qp;
218   size_t size;
219   int n, status;
220
221   if (af == AF_INET6 && len == IN6ADDRSZ &&
222       (memcmp (uaddr, mapped, sizeof mapped) == 0
223        || memcmp (uaddr, tunnelled, sizeof tunnelled) == 0))
224     {
225       /* Unmap. */
226       addr += sizeof mapped;
227       uaddr += sizeof mapped;
228       af = AF_INET;
229       len = INADDRSZ;
230     }
231
232   switch (af)
233     {
234     case AF_INET:
235       size = INADDRSZ;
236       break;
237     case AF_INET6:
238       size = IN6ADDRSZ;
239       break;
240     default:
241       *errnop = EAFNOSUPPORT;
242       *h_errnop = NETDB_INTERNAL;
243       return NSS_STATUS_UNAVAIL;
244     }
245   if (size != len)
246     {
247       *errnop = EAFNOSUPPORT;
248       *h_errnop = NETDB_INTERNAL;
249       return NSS_STATUS_UNAVAIL;
250     }
251
252   switch (af)
253     {
254     case AF_INET:
255       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
256                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
257       break;
258     case AF_INET6:
259       qp = qbuf;
260       for (n = IN6ADDRSZ - 1; n >= 0; n--)
261         qp += sprintf (qp, "%x.%x.", uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
262       strcpy (qp, "ip6.int");
263       break;
264     default:
265       /* Cannot happen.  */
266     }
267
268   n = res_query (qbuf, C_IN, T_PTR, (u_char *)host_buffer.buf,
269                  sizeof host_buffer);
270   if (n < 0)
271     {
272       *h_errnop = h_errno;
273       *errnop = errno;
274       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
275     }
276
277   status = getanswer_r (&host_buffer, n, qbuf, T_PTR, result, buffer, buflen,
278                         errnop, h_errnop);
279   if (status != NSS_STATUS_SUCCESS)
280     {
281       *h_errnop = h_errno;
282       *errnop = errno;
283       return status;
284     }
285
286 #ifdef SUNSECURITY
287   This is not implemented because it is not possible to use the current
288   source from bind in a multi-threaded program.
289 #endif
290
291   result->h_addrtype = af;
292   result->h_length = len;
293   memcpy (host_data->host_addr, addr, len);
294   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
295   host_data->h_addr_ptrs[1] = NULL;
296   if (af == AF_INET && (_res.options & RES_USE_INET6))
297     {
298       map_v4v6_address ((char *) host_data->host_addr,
299                         (char *) host_data->host_addr);
300       result->h_addrtype = AF_INET6;
301       result->h_length = IN6ADDRSZ;
302     }
303   *h_errnop = NETDB_SUCCESS;
304   return NSS_STATUS_SUCCESS;
305 }
306
307
308 static enum nss_status
309 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
310              struct hostent *result, char *buffer, size_t buflen,
311              int *errnop, int *h_errnop)
312 {
313   struct host_data
314   {
315     char *aliases[MAX_NR_ALIASES];
316     unsigned char host_addr[16];        /* IPv4 or IPv6 */
317     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
318     char linebuffer[0];
319   } *host_data = (struct host_data *) buffer;
320   int linebuflen = buflen - offsetof (struct host_data, linebuffer);
321   register const HEADER *hp;
322   const u_char *end_of_message, *cp;
323   int n, ancount, qdcount;
324   int haveanswer, had_error;
325   char *bp, **ap, **hap;
326   char tbuf[MAXDNAME];
327   const char *tname;
328   int (*name_ok) __P ((const char *));
329   u_char packtmp[NS_MAXCDNAME];
330
331   if (linebuflen < 0)
332     {
333       /* The buffer is too small.  */
334     too_small:
335       *errnop = ERANGE;
336       *h_errnop = NETDB_INTERNAL;
337       return NSS_STATUS_TRYAGAIN;
338     }
339
340   tname = qname;
341   result->h_name = NULL;
342   end_of_message = answer->buf + anslen;
343   switch (qtype)
344     {
345     case T_A:
346     case T_AAAA:
347       name_ok = res_hnok;
348       break;
349     case T_PTR:
350       name_ok = res_dnok;
351       break;
352     default:
353       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
354     }
355
356   /*
357    * find first satisfactory answer
358    */
359   hp = &answer->hdr;
360   bp = host_data->linebuffer;
361   ancount = ntohs (hp->ancount);
362   qdcount = ntohs (hp->qdcount);
363   cp = answer->buf + HFIXEDSZ;
364   if (qdcount != 1)
365     {
366       *h_errnop = NO_RECOVERY;
367       return NSS_STATUS_UNAVAIL;
368     }
369
370   n = __ns_name_unpack (answer->buf, end_of_message, cp,
371                         packtmp, sizeof packtmp);
372   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
373     {
374       if (errno == EMSGSIZE)
375         goto too_small;
376
377       n = -1;
378     }
379
380   if (n > 0 && bp[0] == '.')
381     bp[0] = '\0';
382
383   if (n < 0 || (*name_ok) (bp) == 0)
384     {
385       *errnop = errno;
386       *h_errnop = NO_RECOVERY;
387       return NSS_STATUS_UNAVAIL;
388     }
389   cp += n + QFIXEDSZ;
390
391   if (qtype == T_A || qtype == T_AAAA)
392     {
393       /* res_send() has already verified that the query name is the
394        * same as the one we sent; this just gets the expanded name
395        * (i.e., with the succeeding search-domain tacked on).
396        */
397       n = strlen (bp) + 1;             /* for the \0 */
398       if (n >= MAXHOSTNAMELEN)
399         {
400           *h_errnop = NO_RECOVERY;
401           return NSS_STATUS_TRYAGAIN;
402         }
403       result->h_name = bp;
404       bp += n;
405       linebuflen -= n;
406       if (linebuflen < 0)
407         goto too_small;
408       /* The qname can be abbreviated, but h_name is now absolute. */
409       qname = result->h_name;
410     }
411
412   ap = host_data->aliases;
413   *ap = NULL;
414   result->h_aliases = host_data->aliases;
415   hap = host_data->h_addr_ptrs;
416   *hap = NULL;
417   result->h_addr_list = host_data->h_addr_ptrs;
418   haveanswer = 0;
419   had_error = 0;
420
421   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
422     {
423       int type, class;
424
425       n = __ns_name_unpack (answer->buf, end_of_message, cp,
426                             packtmp, sizeof packtmp);
427       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
428         {
429           if (errno == EMSGSIZE)
430             goto too_small;
431
432           n = -1;
433         }
434
435       if (n < 0 || (*name_ok) (bp) == 0)
436         {
437           ++had_error;
438           continue;
439         }
440       cp += n;                          /* name */
441       type = _getshort (cp);
442       cp += INT16SZ;                    /* type */
443       class = _getshort (cp);
444       cp += INT16SZ + INT32SZ;          /* class, TTL */
445       n = _getshort (cp);
446       cp += INT16SZ;                    /* len */
447       if (class != C_IN)
448         {
449           /* XXX - debug? syslog? */
450           cp += n;
451           continue;                     /* XXX - had_error++ ? */
452         }
453
454       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
455         {
456           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
457             continue;
458           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
459           if (n < 0 || (*name_ok) (tbuf) == 0)
460             {
461               ++had_error;
462               continue;
463             }
464           cp += n;
465           /* Store alias.  */
466           *ap++ = bp;
467           n = strlen (bp) + 1;          /* For the \0.  */
468           if (n >= MAXHOSTNAMELEN)
469             {
470               ++had_error;
471               continue;
472             }
473           bp += n;
474           linebuflen -= n;
475           /* Get canonical name.  */
476           n = strlen (tbuf) + 1;        /* For the \0.  */
477           if (n > linebuflen)
478             goto too_small;
479           if (n >= MAXHOSTNAMELEN)
480             {
481               ++had_error;
482               continue;
483             }
484           result->h_name = bp;
485           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
486           linebuflen -= n;
487           continue;
488         }
489
490       if (qtype == T_PTR && type == T_CNAME)
491         {
492           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
493           if (n < 0 || res_dnok (tbuf) == 0)
494             {
495               ++had_error;
496               continue;
497             }
498           cp += n;
499           /* Get canonical name.  */
500           n = strlen (tbuf) + 1;   /* For the \0.  */
501           if (n > linebuflen)
502             goto too_small;
503           if (n >= MAXHOSTNAMELEN)
504             {
505               ++had_error;
506               continue;
507             }
508           tname = bp;
509           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
510           linebuflen -= n;
511           continue;
512         }
513       if (type == T_SIG || type == T_KEY || type == T_NXT)
514         {
515           /* We don't support DNSSEC yet.  For now, ignore the record
516              and send a low priority message to syslog.  */
517           syslog (LOG_DEBUG | LOG_AUTH,
518                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
519                   qname, p_class (C_IN), p_type(qtype), p_type (type));
520           cp += n;
521           continue;
522         }
523       if (type != qtype)
524         {
525           syslog (LOG_NOTICE | LOG_AUTH,
526                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
527                   qname, p_class (C_IN), p_type (qtype), p_type (type));
528           cp += n;
529           continue;                     /* XXX - had_error++ ? */
530         }
531
532       switch (type)
533         {
534         case T_PTR:
535           if (__strcasecmp (tname, bp) != 0)
536             {
537               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
538               cp += n;
539               continue;                 /* XXX - had_error++ ? */
540             }
541
542           n = __ns_name_unpack (answer->buf, end_of_message, cp,
543                                 packtmp, sizeof packtmp);
544           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
545             {
546               if (errno == EMSGSIZE)
547                 goto too_small;
548
549               n = -1;
550             }
551
552           if (n < 0 || res_hnok (bp) == 0)
553             {
554               ++had_error;
555               break;
556             }
557 #if MULTI_PTRS_ARE_ALIASES
558           cp += n;
559           if (haveanswer == 0)
560             result->h_name = bp;
561           else if (ap < &host_data->aliases[MAXALIASES-1])
562             *ap++ = bp;
563           else
564             n = -1;
565           if (n != -1)
566             {
567               n = strlen (bp) + 1;      /* for the \0 */
568               if (n >= MAXHOSTNAMELEN)
569                 {
570                   ++had_error;
571                   break;
572                 }
573               bp += n;
574               linebuflen -= n;
575             }
576           break;
577 #else
578           result->h_name = bp;
579           if (_res.options & RES_USE_INET6)
580             {
581               n = strlen (bp) + 1;      /* for the \0 */
582               if (n >= MAXHOSTNAMELEN)
583                 {
584                   ++had_error;
585                   break;
586                 }
587               bp += n;
588               linebuflen -= n;
589               map_v4v6_hostent (result, &bp, &linebuflen);
590             }
591           *h_errnop = NETDB_SUCCESS;
592           return NSS_STATUS_SUCCESS;
593 #endif
594         case T_A:
595         case T_AAAA:
596           if (strcasecmp (result->h_name, bp) != 0)
597             {
598               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
599               cp += n;
600               continue;                 /* XXX - had_error++ ? */
601             }
602           if (n != result->h_length)
603             {
604               cp += n;
605               continue;
606             }
607           if (!haveanswer)
608             {
609               register int nn;
610
611               result->h_name = bp;
612               nn = strlen (bp) + 1;     /* for the \0 */
613               bp += nn;
614               linebuflen -= nn;
615             }
616
617           linebuflen -= sizeof (align) - ((u_long) bp % sizeof (align));
618           bp += sizeof (align) - ((u_long) bp % sizeof (align));
619
620           if (n > linebuflen)
621             goto too_small;
622           if (hap >= &host_data->h_addr_ptrs[MAX_NR_ADDRS-1])
623             {
624               cp += n;
625               continue;
626             }
627           bp = __mempcpy (*hap++ = bp, cp, n);
628           cp += n;
629           linebuflen -= n;
630           break;
631         default:
632           abort ();
633         }
634       if (had_error == 0)
635         ++haveanswer;
636     }
637
638   if (haveanswer > 0)
639     {
640       *ap = NULL;
641       *hap = NULL;
642 #if defined RESOLVSORT
643       /*
644        * Note: we sort even if host can take only one address
645        * in its return structures - should give it the "best"
646        * address in that case, not some random one
647        */
648       if (_res.nsort && haveanswer > 1 && qtype == T_A)
649         addrsort (host_data->h_addr_ptrs, haveanswer);
650 #endif /*RESOLVSORT*/
651
652       if (result->h_name == NULL)
653         {
654           n = strlen (qname) + 1;       /* For the \0.  */
655           if (n > linebuflen)
656             goto too_small;
657           if (n >= MAXHOSTNAMELEN)
658             goto no_recovery;
659           result->h_name = bp;
660           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
661           linebuflen -= n;
662         }
663
664       if (_res.options & RES_USE_INET6)
665         map_v4v6_hostent (result, &bp, &linebuflen);
666       *h_errnop = NETDB_SUCCESS;
667       return NSS_STATUS_SUCCESS;
668     }
669  no_recovery:
670   *h_errnop = NO_RECOVERY;
671   return NSS_STATUS_TRYAGAIN;
672 }