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