1 /* $NetBSD: gethnamaddr.c,v 1.95 2023/08/10 20:38:00 mrg Exp $ */
2
3 /*
4 * ++Copyright++ 1985, 1988, 1993
5 * -
6 * Copyright (c) 1985, 1988, 1993
7 * The Regents of the University of California. All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 * -
33 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
34 *
35 * Permission to use, copy, modify, and distribute this software for any
36 * purpose with or without fee is hereby granted, provided that the above
37 * copyright notice and this permission notice appear in all copies, and that
38 * the name of Digital Equipment Corporation not be used in advertising or
39 * publicity pertaining to distribution of the document or software without
40 * specific, written prior permission.
41 *
42 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
43 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
44 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
45 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
46 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
47 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
48 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
49 * SOFTWARE.
50 * -
51 * --Copyright--
52 */
53
54 #include <sys/cdefs.h>
55 #if defined(LIBC_SCCS) && !defined(lint)
56 #if 0
57 static char sccsid[] = "@(#)gethostnamadr.c 8.1 (Berkeley) 6/4/93";
58 static char rcsid[] = "Id: gethnamaddr.c,v 8.21 1997/06/01 20:34:37 vixie Exp ";
59 #else
60 __RCSID("$NetBSD: gethnamaddr.c,v 1.95 2023/08/10 20:38:00 mrg Exp $");
61 #endif
62 #endif /* LIBC_SCCS and not lint */
63
64 #if defined(_LIBC)
65 #include "namespace.h"
66 #endif
67 #include <sys/param.h>
68 #include <sys/socket.h>
69 #include <netinet/in.h>
70 #include <arpa/inet.h>
71 #include <arpa/nameser.h>
72
73 #include <assert.h>
74 #include <ctype.h>
75 #include <errno.h>
76 #include <netdb.h>
77 #include <resolv.h>
78 #include <stdarg.h>
79 #include <stdio.h>
80 #include <syslog.h>
81
82 #ifndef LOG_AUTH
83 # define LOG_AUTH 0
84 #endif
85
86 #define MULTI_PTRS_ARE_ALIASES 1 /* XXX - experimental */
87
88 #include <nsswitch.h>
89 #include <stdlib.h>
90 #include <string.h>
91
92 #ifdef YP
93 #include <rpc/rpc.h>
94 #include <rpcsvc/yp_prot.h>
95 #include <rpcsvc/ypclnt.h>
96 #endif
97
98 #include "hostent.h"
99
100 #if defined(_LIBC) && defined(__weak_alias)
101 __weak_alias(gethostbyaddr,_gethostbyaddr)
102 __weak_alias(gethostbyname,_gethostbyname)
103 __weak_alias(gethostent,_gethostent)
104 #endif
105
106 #define maybe_ok(res, nm, ok) (((res)->options & RES_NOCHECKNAME) != 0U || \
107 (ok)(nm) != 0)
108 #define maybe_hnok(res, hn) maybe_ok((res), (hn), res_hnok)
109 #define maybe_dnok(res, dn) maybe_ok((res), (dn), res_dnok)
110
111 #define addalias(d, s, arr, siz) do { \
112 if (d >= &arr[siz]) { \
113 ptrdiff_t _off = d - arr; \
114 char **xptr = realloc(arr, (siz + 10) * sizeof(*arr)); \
115 if (xptr == NULL) \
116 goto nospc; \
117 d = xptr + _off; \
118 arr = xptr; \
119 siz += 10; \
120 } \
121 *d++ = s; \
122 } while (0)
123
124 #define setup(arr, siz) do { \
125 arr = malloc((siz = 10) * sizeof(*arr)); \
126 if (arr == NULL) \
127 goto nospc; \
128 } while (0)
129
130
131 static const char AskedForGot[] =
132 "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
133
134
135 #ifdef YP
136 static char *__ypdomain;
137 #endif
138
139 #define MAXPACKET (64*1024)
140
141 typedef union {
142 HEADER hdr;
143 u_char buf[MAXPACKET];
144 } querybuf;
145
146 typedef union {
147 int32_t al;
148 char ac;
149 } align;
150
151 #ifdef DEBUG
152 static void debugprintf(const char *, res_state, ...)
153 __attribute__((__format__(__printf__, 1, 3)));
154 #endif
155 static struct hostent *getanswer(const querybuf *, int, const char *, int,
156 res_state, struct hostent *, char *, size_t, int *);
157 static void map_v4v6_address(const char *, char *);
158 static void map_v4v6_hostent(struct hostent *, char **, char *);
159 static void addrsort(char **, int, res_state);
160
161 void dns_service(void);
162 #undef dn_skipname
163 int dn_skipname(const u_char *, const u_char *);
164
165 #ifdef YP
166 static struct hostent *_yp_hostent(char *, int, struct getnamaddr *);
167 #endif
168
169 static struct hostent *gethostbyname_internal(const char *, int, res_state,
170 struct hostent *, char *, size_t, int *);
171
172 static const ns_src default_dns_files[] = {
173 { NSSRC_FILES, NS_SUCCESS },
174 { NSSRC_DNS, NS_SUCCESS },
175 { 0, 0 }
176 };
177
178
179 #ifdef DEBUG
180 static void
debugprintf(const char * msg,res_state res,...)181 debugprintf(const char *msg, res_state res, ...)
182 {
183 _DIAGASSERT(msg != NULL);
184
185 if (res->options & RES_DEBUG) {
186 int save = errno;
187 va_list ap;
188
189 va_start (ap, res);
190 vprintf(msg, ap);
191 va_end (ap);
192
193 errno = save;
194 }
195 }
196 #else
197 # define debugprintf(msg, res, num) /*nada*/
198 #endif
199
200 #define BOUNDED_INCR(x) \
201 do { \
202 cp += (x); \
203 if (cp > eom) \
204 goto no_recovery; \
205 } while (0)
206
207 #define BOUNDS_CHECK(ptr, count) \
208 do { \
209 if ((ptr) + (count) > eom) \
210 goto no_recovery; \
211 } while (0)
212
213 static struct hostent *
getanswer(const querybuf * answer,int anslen,const char * qname,int qtype,res_state res,struct hostent * hent,char * buf,size_t buflen,int * he)214 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
215 res_state res, struct hostent *hent, char *buf, size_t buflen, int *he)
216 {
217 const HEADER *hp;
218 const u_char *cp;
219 int n;
220 size_t qlen;
221 const u_char *eom, *erdata;
222 char *bp, **ap, **hap, *ep;
223 int type, class, ancount, qdcount;
224 int haveanswer, had_error;
225 int toobig = 0;
226 char tbuf[MAXDNAME];
227 char **aliases;
228 size_t maxaliases;
229 char *addr_ptrs[MAXADDRS];
230 const char *tname;
231 int (*name_ok)(const char *);
232
233 _DIAGASSERT(answer != NULL);
234 _DIAGASSERT(qname != NULL);
235
236 tname = qname;
237 hent->h_name = NULL;
238 eom = answer->buf + anslen;
239 switch (qtype) {
240 case T_A:
241 case T_AAAA:
242 name_ok = res_hnok;
243 break;
244 case T_PTR:
245 name_ok = res_dnok;
246 break;
247 default:
248 *he = NO_RECOVERY;
249 return NULL; /* XXX should be abort(); */
250 }
251
252 setup(aliases, maxaliases);
253 /*
254 * find first satisfactory answer
255 */
256 hp = &answer->hdr;
257 ancount = ntohs(hp->ancount);
258 qdcount = ntohs(hp->qdcount);
259 bp = buf;
260 ep = buf + buflen;
261 cp = answer->buf;
262 BOUNDED_INCR(HFIXEDSZ);
263 if (qdcount != 1)
264 goto no_recovery;
265
266 n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
267 if ((n < 0) || !maybe_ok(res, bp, name_ok))
268 goto no_recovery;
269
270 BOUNDED_INCR(n + QFIXEDSZ);
271 if (qtype == T_A || qtype == T_AAAA) {
272 /* res_send() has already verified that the query name is the
273 * same as the one we sent; this just gets the expanded name
274 * (i.e., with the succeeding search-domain tacked on).
275 */
276 n = (int)strlen(bp) + 1; /* for the \0 */
277 if (n >= MAXHOSTNAMELEN)
278 goto no_recovery;
279 hent->h_name = bp;
280 bp += n;
281 /* The qname can be abbreviated, but h_name is now absolute. */
282 qname = hent->h_name;
283 }
284 hent->h_aliases = ap = aliases;
285 hent->h_addr_list = hap = addr_ptrs;
286 *ap = NULL;
287 *hap = NULL;
288 haveanswer = 0;
289 had_error = 0;
290 while (ancount-- > 0 && cp < eom && !had_error) {
291 n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
292 if ((n < 0) || !maybe_ok(res, bp, name_ok)) {
293 had_error++;
294 continue;
295 }
296 cp += n; /* name */
297 BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
298 type = _getshort(cp);
299 cp += INT16SZ; /* type */
300 class = _getshort(cp);
301 cp += INT16SZ + INT32SZ; /* class, TTL */
302 n = _getshort(cp);
303 cp += INT16SZ; /* len */
304 BOUNDS_CHECK(cp, n);
305 erdata = cp + n;
306 if (class != C_IN) {
307 /* XXX - debug? syslog? */
308 cp += n;
309 continue; /* XXX - had_error++ ? */
310 }
311 if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
312 n = dn_expand(answer->buf, eom, cp, tbuf,
313 (int)sizeof tbuf);
314 if ((n < 0) || !maybe_ok(res, tbuf, name_ok)) {
315 had_error++;
316 continue;
317 }
318 cp += n;
319 if (cp != erdata)
320 goto no_recovery;
321 /* Store alias. */
322 addalias(ap, bp, aliases, maxaliases);
323 n = (int)strlen(bp) + 1; /* for the \0 */
324 if (n >= MAXHOSTNAMELEN) {
325 had_error++;
326 continue;
327 }
328 bp += n;
329 /* Get canonical name. */
330 n = (int)strlen(tbuf) + 1; /* for the \0 */
331 if (n > ep - bp || n >= MAXHOSTNAMELEN) {
332 had_error++;
333 continue;
334 }
335 strlcpy(bp, tbuf, (size_t)(ep - bp));
336 hent->h_name = bp;
337 bp += n;
338 continue;
339 }
340 if (qtype == T_PTR && type == T_CNAME) {
341 n = dn_expand(answer->buf, eom, cp, tbuf,
342 (int)sizeof tbuf);
343 if (n < 0 || !maybe_dnok(res, tbuf)) {
344 had_error++;
345 continue;
346 }
347 cp += n;
348 if (cp != erdata)
349 goto no_recovery;
350 /* Get canonical name. */
351 n = (int)strlen(tbuf) + 1; /* for the \0 */
352 if (n > ep - bp || n >= MAXHOSTNAMELEN) {
353 had_error++;
354 continue;
355 }
356 strlcpy(bp, tbuf, (size_t)(ep - bp));
357 tname = bp;
358 bp += n;
359 continue;
360 }
361 if (type != qtype) {
362 if (type != T_KEY && type != T_SIG && type != T_DNAME)
363 syslog(LOG_NOTICE|LOG_AUTH,
364 "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
365 qname, p_class(C_IN), p_type(qtype),
366 p_type(type));
367 cp += n;
368 continue; /* XXX - had_error++ ? */
369 }
370 switch (type) {
371 case T_PTR:
372 if (strcasecmp(tname, bp) != 0) {
373 syslog(LOG_NOTICE|LOG_AUTH,
374 AskedForGot, qname, bp);
375 cp += n;
376 continue; /* XXX - had_error++ ? */
377 }
378 n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
379 if ((n < 0) || !maybe_hnok(res, bp)) {
380 had_error++;
381 break;
382 }
383 #if MULTI_PTRS_ARE_ALIASES
384 cp += n;
385 if (cp != erdata)
386 goto no_recovery;
387 if (!haveanswer)
388 hent->h_name = bp;
389 else
390 addalias(ap, bp, aliases, maxaliases);
391 if (n != -1) {
392 n = (int)strlen(bp) + 1; /* for the \0 */
393 if (n >= MAXHOSTNAMELEN) {
394 had_error++;
395 break;
396 }
397 bp += n;
398 }
399 break;
400 #else
401 hent->h_name = bp;
402 if (res->options & RES_USE_INET6) {
403 n = strlen(bp) + 1; /* for the \0 */
404 if (n >= MAXHOSTNAMELEN) {
405 had_error++;
406 break;
407 }
408 bp += n;
409 map_v4v6_hostent(hent, &bp, ep);
410 }
411 goto success;
412 #endif
413 case T_A:
414 case T_AAAA:
415 if (strcasecmp(hent->h_name, bp) != 0) {
416 syslog(LOG_NOTICE|LOG_AUTH,
417 AskedForGot, hent->h_name, bp);
418 cp += n;
419 continue; /* XXX - had_error++ ? */
420 }
421 if (n != hent->h_length) {
422 cp += n;
423 continue;
424 }
425 if (type == T_AAAA) {
426 struct in6_addr in6;
427 memcpy(&in6, cp, NS_IN6ADDRSZ);
428 if (IN6_IS_ADDR_V4MAPPED(&in6)) {
429 cp += n;
430 continue;
431 }
432 }
433 if (!haveanswer) {
434 int nn;
435
436 hent->h_name = bp;
437 nn = (int)strlen(bp) + 1; /* for the \0 */
438 bp += nn;
439 }
440
441 bp += sizeof(align) -
442 (size_t)((u_long)bp % sizeof(align));
443
444 if (bp + n >= ep) {
445 debugprintf("size (%d) too big\n", res, n);
446 had_error++;
447 continue;
448 }
449 if (hap >= &addr_ptrs[MAXADDRS - 1]) {
450 if (!toobig++) {
451 debugprintf("Too many addresses (%d)\n",
452 res, MAXADDRS);
453 }
454 cp += n;
455 continue;
456 }
457 (void)memcpy(*hap++ = bp, cp, (size_t)n);
458 bp += n;
459 cp += n;
460 if (cp != erdata)
461 goto no_recovery;
462 break;
463 default:
464 abort();
465 }
466 if (!had_error)
467 haveanswer++;
468 }
469 if (haveanswer) {
470 *ap = NULL;
471 *hap = NULL;
472 /*
473 * Note: we sort even if host can take only one address
474 * in its return structures - should give it the "best"
475 * address in that case, not some random one
476 */
477 if (res->nsort && haveanswer > 1 && qtype == T_A)
478 addrsort(addr_ptrs, haveanswer, res);
479 if (!hent->h_name) {
480 n = (int)strlen(qname) + 1; /* for the \0 */
481 if (n > ep - bp || n >= MAXHOSTNAMELEN)
482 goto no_recovery;
483 strlcpy(bp, qname, (size_t)(ep - bp));
484 hent->h_name = bp;
485 bp += n;
486 }
487 if (res->options & RES_USE_INET6)
488 map_v4v6_hostent(hent, &bp, ep);
489 goto success;
490 }
491 no_recovery:
492 free(aliases);
493 *he = NO_RECOVERY;
494 return NULL;
495 success:
496 bp = (char *)ALIGN(bp);
497 n = (int)(ap - aliases);
498 qlen = (n + 1) * sizeof(*hent->h_aliases);
499 if ((size_t)(ep - bp) < qlen)
500 goto nospc;
501 hent->h_aliases = (void *)bp;
502 memcpy(bp, aliases, qlen);
503 free(aliases);
504 aliases = NULL;
505
506 bp += qlen;
507 n = (int)(hap - addr_ptrs);
508 qlen = (n + 1) * sizeof(*hent->h_addr_list);
509 if ((size_t)(ep - bp) < qlen)
510 goto nospc;
511 hent->h_addr_list = (void *)bp;
512 memcpy(bp, addr_ptrs, qlen);
513 *he = NETDB_SUCCESS;
514 return hent;
515 nospc:
516 free(aliases);
517 errno = ENOSPC;
518 *he = NETDB_INTERNAL;
519 return NULL;
520 }
521
522 struct hostent *
gethostbyname_r(const char * name,struct hostent * hp,char * buf,size_t buflen,int * he)523 gethostbyname_r(const char *name, struct hostent *hp, char *buf, size_t buflen,
524 int *he)
525 {
526 res_state res = __res_get_state();
527
528 if (res == NULL) {
529 *he = NETDB_INTERNAL;
530 return NULL;
531 }
532
533 _DIAGASSERT(name != NULL);
534
535 if (res->options & RES_USE_INET6) {
536 struct hostent *nhp = gethostbyname_internal(name, AF_INET6,
537 res, hp, buf, buflen, he);
538 if (nhp) {
539 __res_put_state(res);
540 return nhp;
541 }
542 }
543 hp = gethostbyname_internal(name, AF_INET, res, hp, buf, buflen, he);
544 __res_put_state(res);
545 return hp;
546 }
547
548 struct hostent *
gethostbyname2_r(const char * name,int af,struct hostent * hp,char * buf,size_t buflen,int * he)549 gethostbyname2_r(const char *name, int af, struct hostent *hp, char *buf,
550 size_t buflen, int *he)
551 {
552 res_state res = __res_get_state();
553
554 if (res == NULL) {
555 *he = NETDB_INTERNAL;
556 return NULL;
557 }
558 hp = gethostbyname_internal(name, af, res, hp, buf, buflen, he);
559 __res_put_state(res);
560 return hp;
561 }
562
563 static struct hostent *
gethostbyname_internal(const char * name,int af,res_state res,struct hostent * hp,char * buf,size_t buflen,int * he)564 gethostbyname_internal(const char *name, int af, res_state res,
565 struct hostent *hp, char *buf, size_t buflen, int *he)
566 {
567 const char *cp;
568 struct getnamaddr info;
569 char hbuf[MAXHOSTNAMELEN];
570 size_t size;
571 static const ns_dtab dtab[] = {
572 NS_FILES_CB(_hf_gethtbyname, NULL)
573 { NSSRC_DNS, _dns_gethtbyname, NULL }, /* force -DHESIOD */
574 NS_NIS_CB(_yp_gethtbyname, NULL)
575 NS_NULL_CB
576 };
577
578 _DIAGASSERT(name != NULL);
579
580 switch (af) {
581 case AF_INET:
582 size = NS_INADDRSZ;
583 break;
584 case AF_INET6:
585 size = NS_IN6ADDRSZ;
586 break;
587 default:
588 *he = NETDB_INTERNAL;
589 errno = EAFNOSUPPORT;
590 return NULL;
591 }
592 if (buflen < size)
593 goto nospc;
594
595 hp->h_addrtype = af;
596 hp->h_length = (int)size;
597
598 /*
599 * if there aren't any dots, it could be a user-level alias.
600 * this is also done in res_nquery() since we are not the only
601 * function that looks up host names.
602 */
603 if (!strchr(name, '.') && (cp = res_hostalias(res, name,
604 hbuf, sizeof(hbuf))))
605 name = cp;
606
607 /*
608 * disallow names consisting only of digits/dots, unless
609 * they end in a dot.
610 */
611 if (isdigit((u_char) name[0]))
612 for (cp = name;; ++cp) {
613 if (!*cp) {
614 if (*--cp == '.')
615 break;
616 /*
617 * All-numeric, no dot at the end.
618 * Fake up a hostent as if we'd actually
619 * done a lookup.
620 */
621 goto fake;
622 }
623 if (!isdigit((u_char) *cp) && *cp != '.')
624 break;
625 }
626 if ((isxdigit((u_char) name[0]) && strchr(name, ':') != NULL) ||
627 name[0] == ':')
628 for (cp = name;; ++cp) {
629 if (!*cp) {
630 if (*--cp == '.')
631 break;
632 /*
633 * All-IPv6-legal, no dot at the end.
634 * Fake up a hostent as if we'd actually
635 * done a lookup.
636 */
637 goto fake;
638 }
639 if (!isxdigit((u_char) *cp) && *cp != ':' && *cp != '.')
640 break;
641 }
642
643 *he = NETDB_INTERNAL;
644 info.hp = hp;
645 info.buf = buf;
646 info.buflen = buflen;
647 info.he = he;
648 if (nsdispatch(&info, dtab, NSDB_HOSTS, "gethostbyname",
649 default_dns_files, name, strlen(name), af) != NS_SUCCESS)
650 return NULL;
651 *he = NETDB_SUCCESS;
652 return hp;
653 nospc:
654 *he = NETDB_INTERNAL;
655 errno = ENOSPC;
656 return NULL;
657 fake:
658 HENT_ARRAY(hp->h_addr_list, 1, buf, buflen);
659 HENT_ARRAY(hp->h_aliases, 0, buf, buflen);
660
661 hp->h_aliases[0] = NULL;
662 if (size > buflen)
663 goto nospc;
664
665 if (inet_pton(af, name, buf) <= 0) {
666 *he = HOST_NOT_FOUND;
667 return NULL;
668 }
669 hp->h_addr_list[0] = buf;
670 hp->h_addr_list[1] = NULL;
671 buf += size;
672 buflen -= size;
673 HENT_SCOPY(hp->h_name, name, buf, buflen);
674 if (res->options & RES_USE_INET6)
675 map_v4v6_hostent(hp, &buf, buf + buflen);
676 *he = NETDB_SUCCESS;
677 return hp;
678 }
679
680 struct hostent *
gethostbyaddr_r(const void * addr,socklen_t len,int af,struct hostent * hp,char * buf,size_t buflen,int * he)681 gethostbyaddr_r(const void *addr, socklen_t len, int af, struct hostent *hp,
682 char *buf, size_t buflen, int *he)
683 {
684 const u_char *uaddr = (const u_char *)addr;
685 socklen_t size;
686 struct getnamaddr info;
687 static const ns_dtab dtab[] = {
688 NS_FILES_CB(_hf_gethtbyaddr, NULL)
689 { NSSRC_DNS, _dns_gethtbyaddr, NULL }, /* force -DHESIOD */
690 NS_NIS_CB(_yp_gethtbyaddr, NULL)
691 NS_NULL_CB
692 };
693
694 _DIAGASSERT(addr != NULL);
695
696 if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
697 (IN6_IS_ADDR_LINKLOCAL((const struct in6_addr *)addr) ||
698 IN6_IS_ADDR_SITELOCAL((const struct in6_addr *)addr))) {
699 *he = HOST_NOT_FOUND;
700 return NULL;
701 }
702 if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
703 (IN6_IS_ADDR_V4MAPPED((const struct in6_addr *)addr) ||
704 IN6_IS_ADDR_V4COMPAT((const struct in6_addr *)addr))) {
705 /* Unmap. */
706 uaddr += NS_IN6ADDRSZ - NS_INADDRSZ;
707 addr = uaddr;
708 af = AF_INET;
709 len = NS_INADDRSZ;
710 }
711 switch (af) {
712 case AF_INET:
713 size = NS_INADDRSZ;
714 break;
715 case AF_INET6:
716 size = NS_IN6ADDRSZ;
717 break;
718 default:
719 errno = EAFNOSUPPORT;
720 *he = NETDB_INTERNAL;
721 return NULL;
722 }
723 if (size != len) {
724 errno = EINVAL;
725 *he = NETDB_INTERNAL;
726 return NULL;
727 }
728 info.hp = hp;
729 info.buf = buf;
730 info.buflen = buflen;
731 info.he = he;
732 *he = NETDB_INTERNAL;
733 if (nsdispatch(&info, dtab, NSDB_HOSTS, "gethostbyaddr",
734 default_dns_files, uaddr, len, af) != NS_SUCCESS)
735 return NULL;
736 *he = NETDB_SUCCESS;
737 return hp;
738 }
739
740 struct hostent *
gethostent_r(FILE * hf,struct hostent * hent,char * buf,size_t buflen,int * he)741 gethostent_r(FILE *hf, struct hostent *hent, char *buf, size_t buflen, int *he)
742 {
743 char *p, *name;
744 char *cp, **q;
745 int af, len;
746 size_t anum;
747 char **aliases;
748 size_t maxaliases;
749 struct in6_addr host_addr;
750
751 if (hf == NULL) {
752 *he = NETDB_INTERNAL;
753 errno = EINVAL;
754 return NULL;
755 }
756 p = NULL;
757 setup(aliases, maxaliases);
758 for (;;) {
759 free(p);
760 p = fparseln(hf, NULL, NULL, NULL, FPARSELN_UNESCALL);
761 if (p == NULL) {
762 free(aliases);
763 *he = HOST_NOT_FOUND;
764 return NULL;
765 }
766 if (!(cp = strpbrk(p, " \t")))
767 continue;
768 *cp++ = '\0';
769 if (inet_pton(AF_INET6, p, &host_addr) > 0) {
770 af = AF_INET6;
771 len = NS_IN6ADDRSZ;
772 } else {
773 if (inet_pton(AF_INET, p, &host_addr) <= 0)
774 continue;
775
776 res_state res = __res_get_state();
777 if (res == NULL)
778 goto nospc;
779 if (res->options & RES_USE_INET6) {
780 map_v4v6_address(buf, buf);
781 af = AF_INET6;
782 len = NS_IN6ADDRSZ;
783 } else {
784 af = AF_INET;
785 len = NS_INADDRSZ;
786 }
787 __res_put_state(res);
788 }
789
790 /* if this is not something we're looking for, skip it. */
791 if (hent->h_addrtype != 0 && hent->h_addrtype != af)
792 continue;
793 if (hent->h_length != 0 && hent->h_length != len)
794 continue;
795
796 while (*cp == ' ' || *cp == '\t')
797 cp++;
798 if ((cp = strpbrk(name = cp, " \t")) != NULL)
799 *cp++ = '\0';
800 q = aliases;
801 while (cp && *cp) {
802 if (*cp == ' ' || *cp == '\t') {
803 cp++;
804 continue;
805 }
806 addalias(q, cp, aliases, maxaliases);
807 if ((cp = strpbrk(cp, " \t")) != NULL)
808 *cp++ = '\0';
809 }
810 break;
811 }
812 hent->h_length = len;
813 hent->h_addrtype = af;
814 HENT_ARRAY(hent->h_addr_list, 1, buf, buflen);
815 anum = (size_t)(q - aliases);
816 HENT_ARRAY(hent->h_aliases, anum, buf, buflen);
817 HENT_COPY(hent->h_addr_list[0], &host_addr, hent->h_length, buf,
818 buflen);
819 hent->h_addr_list[1] = NULL;
820
821 HENT_SCOPY(hent->h_name, name, buf, buflen);
822 for (size_t i = 0; i < anum; i++)
823 HENT_SCOPY(hent->h_aliases[i], aliases[i], buf, buflen);
824 hent->h_aliases[anum] = NULL;
825
826 *he = NETDB_SUCCESS;
827 free(p);
828 free(aliases);
829 return hent;
830 nospc:
831 free(p);
832 free(aliases);
833 errno = ENOSPC;
834 *he = NETDB_INTERNAL;
835 return NULL;
836 }
837
838 static void
map_v4v6_address(const char * src,char * dst)839 map_v4v6_address(const char *src, char *dst)
840 {
841 u_char *p = (u_char *)dst;
842 char tmp[NS_INADDRSZ];
843 int i;
844
845 _DIAGASSERT(src != NULL);
846 _DIAGASSERT(dst != NULL);
847
848 /* Stash a temporary copy so our caller can update in place. */
849 (void)memcpy(tmp, src, NS_INADDRSZ);
850 /* Mark this ipv6 addr as a mapped ipv4. */
851 for (i = 0; i < 10; i++)
852 *p++ = 0x00;
853 *p++ = 0xff;
854 *p++ = 0xff;
855 /* Retrieve the saved copy and we're done. */
856 (void)memcpy(p, tmp, NS_INADDRSZ);
857 }
858
859 static void
map_v4v6_hostent(struct hostent * hp,char ** bpp,char * ep)860 map_v4v6_hostent(struct hostent *hp, char **bpp, char *ep)
861 {
862 char **ap;
863
864 _DIAGASSERT(hp != NULL);
865 _DIAGASSERT(bpp != NULL);
866 _DIAGASSERT(ep != NULL);
867
868 if (hp->h_addrtype != AF_INET || hp->h_length != NS_INADDRSZ)
869 return;
870 hp->h_addrtype = AF_INET6;
871 hp->h_length = NS_IN6ADDRSZ;
872 for (ap = hp->h_addr_list; *ap; ap++) {
873 int i = (int)(sizeof(align) -
874 (size_t)((u_long)*bpp % sizeof(align)));
875
876 if (ep - *bpp < (i + NS_IN6ADDRSZ)) {
877 /* Out of memory. Truncate address list here. XXX */
878 *ap = NULL;
879 return;
880 }
881 *bpp += i;
882 map_v4v6_address(*ap, *bpp);
883 *ap = *bpp;
884 *bpp += NS_IN6ADDRSZ;
885 }
886 }
887
888 static void
addrsort(char ** ap,int num,res_state res)889 addrsort(char **ap, int num, res_state res)
890 {
891 int i, j;
892 char **p;
893 short aval[MAXADDRS];
894 int needsort = 0;
895
896 _DIAGASSERT(ap != NULL);
897
898 p = ap;
899 for (i = 0; i < num; i++, p++) {
900 for (j = 0 ; (unsigned)j < res->nsort; j++)
901 if (res->sort_list[j].addr.s_addr ==
902 (((struct in_addr *)(void *)(*p))->s_addr &
903 res->sort_list[j].mask))
904 break;
905 aval[i] = j;
906 if (needsort == 0 && i > 0 && j < aval[i-1])
907 needsort = i;
908 }
909 if (!needsort)
910 return;
911
912 while (needsort < num) {
913 for (j = needsort - 1; j >= 0; j--) {
914 if (aval[j] > aval[j+1]) {
915 char *hp;
916
917 i = aval[j];
918 aval[j] = aval[j+1];
919 aval[j+1] = i;
920
921 hp = ap[j];
922 ap[j] = ap[j+1];
923 ap[j+1] = hp;
924 } else
925 break;
926 }
927 needsort++;
928 }
929 }
930
931
932 /*ARGSUSED*/
933 int
_dns_gethtbyname(void * rv,void * cb_data,va_list ap)934 _dns_gethtbyname(void *rv, void *cb_data, va_list ap)
935 {
936 querybuf *buf;
937 int n, type;
938 struct hostent *hp;
939 const char *name;
940 res_state res;
941 struct getnamaddr *info = rv;
942
943 _DIAGASSERT(rv != NULL);
944
945 name = va_arg(ap, char *);
946 /* NOSTRICT skip string len */(void)va_arg(ap, int);
947 info->hp->h_addrtype = va_arg(ap, int);
948
949 switch (info->hp->h_addrtype) {
950 case AF_INET:
951 info->hp->h_length = NS_INADDRSZ;
952 type = T_A;
953 break;
954 case AF_INET6:
955 info->hp->h_length = NS_IN6ADDRSZ;
956 type = T_AAAA;
957 break;
958 default:
959 return NS_UNAVAIL;
960 }
961 buf = malloc(sizeof(*buf));
962 if (buf == NULL) {
963 *info->he = NETDB_INTERNAL;
964 return NS_NOTFOUND;
965 }
966 res = __res_get_state();
967 if (res == NULL) {
968 free(buf);
969 *info->he = NETDB_INTERNAL;
970 return NS_NOTFOUND;
971 }
972 n = res_nsearch(res, name, C_IN, type, buf->buf, (int)sizeof(buf->buf));
973 if (n < 0) {
974 free(buf);
975 debugprintf("res_nsearch failed (%d)\n", res, n);
976 __res_put_state(res);
977 return NS_NOTFOUND;
978 }
979 hp = getanswer(buf, n, name, type, res, info->hp, info->buf,
980 info->buflen, info->he);
981 free(buf);
982 __res_put_state(res);
983 if (hp == NULL)
984 switch (*info->he) {
985 case HOST_NOT_FOUND:
986 return NS_NOTFOUND;
987 case TRY_AGAIN:
988 return NS_TRYAGAIN;
989 default:
990 return NS_UNAVAIL;
991 }
992 return NS_SUCCESS;
993 }
994
995 /*ARGSUSED*/
996 int
_dns_gethtbyaddr(void * rv,void * cb_data,va_list ap)997 _dns_gethtbyaddr(void *rv, void *cb_data, va_list ap)
998 {
999 char qbuf[MAXDNAME + 1], *qp, *ep;
1000 int n;
1001 querybuf *buf;
1002 struct hostent *hp;
1003 const unsigned char *uaddr;
1004 int advance;
1005 res_state res;
1006 char *bf;
1007 size_t blen;
1008 struct getnamaddr *info = rv;
1009
1010 _DIAGASSERT(rv != NULL);
1011
1012 uaddr = va_arg(ap, unsigned char *);
1013 info->hp->h_length = va_arg(ap, int);
1014 info->hp->h_addrtype = va_arg(ap, int);
1015
1016 switch (info->hp->h_addrtype) {
1017 case AF_INET:
1018 (void)snprintf(qbuf, sizeof(qbuf), "%u.%u.%u.%u.in-addr.arpa",
1019 (uaddr[3] & 0xff), (uaddr[2] & 0xff),
1020 (uaddr[1] & 0xff), (uaddr[0] & 0xff));
1021 break;
1022
1023 case AF_INET6:
1024 qp = qbuf;
1025 ep = qbuf + sizeof(qbuf) - 1;
1026 for (n = NS_IN6ADDRSZ - 1; n >= 0; n--) {
1027 advance = snprintf(qp, (size_t)(ep - qp), "%x.%x.",
1028 uaddr[n] & 0xf,
1029 ((unsigned int)uaddr[n] >> 4) & 0xf);
1030 if (advance > 0 && qp + advance < ep)
1031 qp += advance;
1032 else
1033 goto norecovery;
1034 }
1035 if (strlcat(qbuf, "ip6.arpa", sizeof(qbuf)) >= sizeof(qbuf))
1036 goto norecovery;
1037 break;
1038 default:
1039 goto norecovery;
1040 }
1041
1042 buf = malloc(sizeof(*buf));
1043 if (buf == NULL) {
1044 goto nospc;
1045 }
1046 res = __res_get_state();
1047 if (res == NULL) {
1048 free(buf);
1049 goto nospc;
1050 }
1051 n = res_nquery(res, qbuf, C_IN, T_PTR, buf->buf, (int)sizeof(buf->buf));
1052 if (n < 0) {
1053 free(buf);
1054 debugprintf("res_nquery failed (%d)\n", res, n);
1055 __res_put_state(res);
1056 *info->he = HOST_NOT_FOUND;
1057 return NS_NOTFOUND;
1058 }
1059 hp = getanswer(buf, n, qbuf, T_PTR, res, info->hp, info->buf,
1060 info->buflen, info->he);
1061 free(buf);
1062 if (hp == NULL) {
1063 __res_put_state(res);
1064 switch (*info->he) {
1065 case HOST_NOT_FOUND:
1066 return NS_NOTFOUND;
1067 case TRY_AGAIN:
1068 return NS_TRYAGAIN;
1069 default:
1070 return NS_UNAVAIL;
1071 }
1072 }
1073
1074 bf = (void *)(hp->h_addr_list + 2);
1075 blen = (size_t)(bf - info->buf);
1076 if (blen + info->hp->h_length > info->buflen)
1077 goto nospc;
1078 hp->h_addr_list[0] = bf;
1079 hp->h_addr_list[1] = NULL;
1080 (void)memcpy(bf, uaddr, (size_t)info->hp->h_length);
1081 if (info->hp->h_addrtype == AF_INET && (res->options & RES_USE_INET6)) {
1082 if (blen + NS_IN6ADDRSZ > info->buflen) {
1083 __res_put_state(res);
1084 goto nospc;
1085 }
1086 map_v4v6_address(bf, bf);
1087 hp->h_addrtype = AF_INET6;
1088 hp->h_length = NS_IN6ADDRSZ;
1089 }
1090
1091 __res_put_state(res);
1092 *info->he = NETDB_SUCCESS;
1093 return NS_SUCCESS;
1094 nospc:
1095 *info->he = NETDB_INTERNAL;
1096 return NS_UNAVAIL;
1097 norecovery:
1098 *info->he = NO_RECOVERY;
1099 return NS_UNAVAIL;
1100 }
1101
1102 #ifdef YP
1103 /*ARGSUSED*/
1104 static struct hostent *
_yp_hostent(char * line,int af,struct getnamaddr * info)1105 _yp_hostent(char *line, int af, struct getnamaddr *info)
1106 {
1107 struct in6_addr host_addrs[MAXADDRS];
1108 char **aliases;
1109 size_t maxaliases;
1110 char *p = line;
1111 char *cp, **q, *ptr;
1112 size_t len, anum, i;
1113 int addrok;
1114 int more;
1115 size_t naddrs;
1116 struct hostent *hp = info->hp;
1117
1118 _DIAGASSERT(line != NULL);
1119
1120 hp->h_name = NULL;
1121 hp->h_addrtype = af;
1122 switch (af) {
1123 case AF_INET:
1124 hp->h_length = NS_INADDRSZ;
1125 break;
1126 case AF_INET6:
1127 hp->h_length = NS_IN6ADDRSZ;
1128 break;
1129 default:
1130 return NULL;
1131 }
1132 setup(aliases, maxaliases);
1133 naddrs = 0;
1134 q = aliases;
1135
1136 nextline:
1137 /* check for host_addrs overflow */
1138 if (naddrs >= __arraycount(host_addrs))
1139 goto done;
1140
1141 more = 0;
1142 cp = strpbrk(p, " \t");
1143 if (cp == NULL)
1144 goto done;
1145 *cp++ = '\0';
1146
1147 /* p has should have an address */
1148 addrok = inet_pton(af, p, &host_addrs[naddrs]);
1149 if (addrok != 1) {
1150 /* skip to the next line */
1151 while (cp && *cp) {
1152 if (*cp == '\n') {
1153 cp++;
1154 goto nextline;
1155 }
1156 cp++;
1157 }
1158 goto done;
1159 }
1160 naddrs++;
1161
1162 while (*cp == ' ' || *cp == '\t')
1163 cp++;
1164 p = cp;
1165 cp = strpbrk(p, " \t\n");
1166 if (cp != NULL) {
1167 if (*cp == '\n')
1168 more = 1;
1169 *cp++ = '\0';
1170 }
1171 if (!hp->h_name)
1172 hp->h_name = p;
1173 else if (strcmp(hp->h_name, p) == 0)
1174 ;
1175 else
1176 addalias(q, p, aliases, maxaliases);
1177 p = cp;
1178 if (more)
1179 goto nextline;
1180
1181 while (cp && *cp) {
1182 if (*cp == ' ' || *cp == '\t') {
1183 cp++;
1184 continue;
1185 }
1186 if (*cp == '\n') {
1187 cp++;
1188 goto nextline;
1189 }
1190 addalias(q, cp, aliases, maxaliases);
1191 cp = strpbrk(cp, " \t");
1192 if (cp != NULL)
1193 *cp++ = '\0';
1194 }
1195
1196 done:
1197 if (hp->h_name == NULL) {
1198 free(aliases);
1199 return NULL;
1200 }
1201
1202 ptr = info->buf;
1203 len = info->buflen;
1204
1205 anum = (size_t)(q - aliases);
1206 HENT_ARRAY(hp->h_addr_list, naddrs, ptr, len);
1207 HENT_ARRAY(hp->h_aliases, anum, ptr, len);
1208
1209 for (i = 0; i < naddrs; i++)
1210 HENT_COPY(hp->h_addr_list[i], &host_addrs[i], hp->h_length,
1211 ptr, len);
1212 hp->h_addr_list[naddrs] = NULL;
1213
1214 HENT_SCOPY(hp->h_name, hp->h_name, ptr, len);
1215
1216 for (i = 0; i < anum; i++)
1217 HENT_SCOPY(hp->h_aliases[i], aliases[i], ptr, len);
1218 hp->h_aliases[anum] = NULL;
1219 free(aliases);
1220
1221 return hp;
1222 nospc:
1223 free(aliases);
1224 *info->he = NETDB_INTERNAL;
1225 errno = ENOSPC;
1226 return NULL;
1227 }
1228
1229 /*ARGSUSED*/
1230 int
_yp_gethtbyaddr(void * rv,void * cb_data,va_list ap)1231 _yp_gethtbyaddr(void *rv, void *cb_data, va_list ap)
1232 {
1233 struct hostent *hp = NULL;
1234 char *ypcurrent;
1235 int ypcurrentlen, r;
1236 char name[INET6_ADDRSTRLEN]; /* XXX enough? */
1237 const unsigned char *uaddr;
1238 int af;
1239 const char *map;
1240 struct getnamaddr *info = rv;
1241
1242 _DIAGASSERT(rv != NULL);
1243
1244 uaddr = va_arg(ap, unsigned char *);
1245 /* NOSTRICT skip len */(void)va_arg(ap, int);
1246 af = va_arg(ap, int);
1247
1248 if (!__ypdomain) {
1249 if (_yp_check(&__ypdomain) == 0)
1250 return NS_UNAVAIL;
1251 }
1252 /*
1253 * XXX unfortunately, we cannot support IPv6 extended scoped address
1254 * notation here. gethostbyaddr() is not scope-aware. too bad.
1255 */
1256 if (inet_ntop(af, uaddr, name, (socklen_t)sizeof(name)) == NULL)
1257 return NS_UNAVAIL;
1258 switch (af) {
1259 case AF_INET:
1260 map = "hosts.byaddr";
1261 break;
1262 default:
1263 map = "ipnodes.byaddr";
1264 break;
1265 }
1266 ypcurrent = NULL;
1267 r = yp_match(__ypdomain, map, name,
1268 (int)strlen(name), &ypcurrent, &ypcurrentlen);
1269 if (r == 0)
1270 hp = _yp_hostent(ypcurrent, af, info);
1271 else
1272 hp = NULL;
1273 free(ypcurrent);
1274 if (hp == NULL) {
1275 *info->he = HOST_NOT_FOUND;
1276 return NS_NOTFOUND;
1277 }
1278 return NS_SUCCESS;
1279 }
1280
1281 /*ARGSUSED*/
1282 int
_yp_gethtbyname(void * rv,void * cb_data,va_list ap)1283 _yp_gethtbyname(void *rv, void *cb_data, va_list ap)
1284 {
1285 struct hostent *hp;
1286 char *ypcurrent;
1287 int ypcurrentlen, r;
1288 const char *name;
1289 int af;
1290 const char *map;
1291 struct getnamaddr *info = rv;
1292
1293 _DIAGASSERT(rv != NULL);
1294
1295 name = va_arg(ap, char *);
1296 /* NOSTRICT skip string len */(void)va_arg(ap, int);
1297 af = va_arg(ap, int);
1298
1299 if (!__ypdomain) {
1300 if (_yp_check(&__ypdomain) == 0)
1301 return NS_UNAVAIL;
1302 }
1303 switch (af) {
1304 case AF_INET:
1305 map = "hosts.byname";
1306 break;
1307 default:
1308 map = "ipnodes.byname";
1309 break;
1310 }
1311 ypcurrent = NULL;
1312 r = yp_match(__ypdomain, map, name,
1313 (int)strlen(name), &ypcurrent, &ypcurrentlen);
1314 if (r == 0)
1315 hp = _yp_hostent(ypcurrent, af, info);
1316 else
1317 hp = NULL;
1318 free(ypcurrent);
1319 if (hp == NULL) {
1320 *info->he = HOST_NOT_FOUND;
1321 return NS_NOTFOUND;
1322 }
1323 return NS_SUCCESS;
1324 }
1325 #endif
1326
1327 /*
1328 * Non-reentrant versions.
1329 */
1330 FILE *_h_file;
1331 static struct hostent h_ent;
1332 static char h_buf[16384];
1333
1334 struct hostent *
gethostbyaddr(const void * addr,socklen_t len,int af)1335 gethostbyaddr(const void *addr, socklen_t len, int af) {
1336 return gethostbyaddr_r(addr, len, af, &h_ent, h_buf, sizeof(h_buf),
1337 &h_errno);
1338 }
1339
1340 struct hostent *
gethostbyname(const char * name)1341 gethostbyname(const char *name) {
1342 return gethostbyname_r(name, &h_ent, h_buf, sizeof(h_buf), &h_errno);
1343 }
1344
1345 struct hostent *
gethostbyname2(const char * name,int af)1346 gethostbyname2(const char *name, int af) {
1347 return gethostbyname2_r(name, af, &h_ent, h_buf, sizeof(h_buf),
1348 &h_errno);
1349 }
1350
1351 struct hostent *
gethostent(void)1352 gethostent(void)
1353 {
1354 if (_h_file == NULL) {
1355 sethostent_r(&_h_file);
1356 if (_h_file == NULL) {
1357 h_errno = NETDB_INTERNAL;
1358 return NULL;
1359 }
1360 }
1361 memset(&h_ent, 0, sizeof(h_ent));
1362 return gethostent_r(_h_file, &h_ent, h_buf, sizeof(h_buf), &h_errno);
1363 }
1364
1365