• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*	$NetBSD: gethnamaddr.c,v 1.70 2006/03/22 00:03:51 christos 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 #include <sys/types.h>
56 
57 #include <sys/param.h>
58 #include <sys/socket.h>
59 #include <netinet/in.h>
60 #include <arpa/inet.h>
61 #include "arpa_nameser.h"
62 #include "resolv_private.h"
63 #include "resolv_cache.h"
64 #include <assert.h>
65 #include <ctype.h>
66 #include <errno.h>
67 #include <netdb.h>
68 #include <stdarg.h>
69 #include <stdio.h>
70 #include <syslog.h>
71 
72 #ifndef LOG_AUTH
73 # define LOG_AUTH 0
74 #endif
75 
76 #define MULTI_PTRS_ARE_ALIASES 1	/* XXX - experimental */
77 
78 #include "nsswitch.h"
79 #include <stdlib.h>
80 #include <string.h>
81 
82 static const char const AskedForGot[] =
83 			  "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
84 
85 #define	MAXPACKET	(64*1024)
86 
87 typedef union {
88     HEADER hdr;
89     u_char buf[MAXPACKET];
90 } querybuf;
91 
92 typedef union {
93     int32_t al;
94     char ac;
95 } align;
96 
97 #ifdef DEBUG
98 static void dprintf(const char *, res_state, ...)
99 	__attribute__((__format__(__printf__, 1, 3)));
100 #endif
101 static struct hostent *getanswer(const querybuf *, int, const char *, int,
102     res_state);
103 static void map_v4v6_address(const char *, char *);
104 static void map_v4v6_hostent(struct hostent *, char **, char *);
105 static void addrsort(char **, int, res_state);
106 
107 void _sethtent(int);
108 void _endhtent(void);
109 struct hostent *_gethtent(void);
110 void ht_sethostent(int);
111 void ht_endhostent(void);
112 struct hostent *ht_gethostbyname(char *);
113 struct hostent *ht_gethostbyaddr(const char *, int, int);
114 void dns_service(void);
115 #undef dn_skipname
116 int dn_skipname(const u_char *, const u_char *);
117 int _gethtbyaddr(void *, void *, va_list);
118 int _gethtbyname(void *, void *, va_list);
119 struct hostent *_gethtbyname2(const char *, int);
120 int _dns_gethtbyaddr(void *, void *, va_list);
121 int _dns_gethtbyname(void *, void *, va_list);
122 
123 static struct hostent *gethostbyname_internal(const char *, int, res_state);
124 
125 static const ns_src default_dns_files[] = {
126 	{ NSSRC_FILES, 	NS_SUCCESS },
127 	{ NSSRC_DNS, 	NS_SUCCESS },
128 	{ 0, 0 }
129 };
130 
131 
132 #ifdef DEBUG
133 static void
dprintf(const char * msg,res_state res,...)134 dprintf(const char *msg, res_state res, ...)
135 {
136 	assert(msg != NULL);
137 
138 	if (res->options & RES_DEBUG) {
139 		int save = errno;
140 		va_list ap;
141 
142 		va_start (ap, res);
143 		vprintf(msg, ap);
144 		va_end (ap);
145 
146 		errno = save;
147 	}
148 }
149 #else
150 # define dprintf(msg, res, num) ((void)0) /*nada*/
151 #endif
152 
153 #define BOUNDED_INCR(x) \
154 	do { \
155 		cp += (x); \
156 		if (cp > eom) { \
157 			h_errno = NO_RECOVERY; \
158 			return NULL; \
159 		} \
160 	} while (/*CONSTCOND*/0)
161 
162 #define BOUNDS_CHECK(ptr, count) \
163 	do { \
164 		if ((ptr) + (count) > eom) { \
165 			h_errno = NO_RECOVERY; \
166 			return NULL; \
167 		} \
168 	} while (/*CONSTCOND*/0)
169 
170 static struct hostent *
getanswer(const querybuf * answer,int anslen,const char * qname,int qtype,res_state res)171 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
172     res_state res)
173 {
174 	const HEADER *hp;
175 	const u_char *cp;
176 	int n;
177 	const u_char *eom, *erdata;
178 	char *bp, **ap, **hap, *ep;
179 	int type, class, ancount, qdcount;
180 	int haveanswer, had_error;
181 	int toobig = 0;
182 	char tbuf[MAXDNAME];
183 	const char *tname;
184 	int (*name_ok)(const char *);
185 	res_static  rs = __res_get_static();
186 
187 	assert(answer != NULL);
188 	assert(qname != NULL);
189 
190 	tname = qname;
191 	rs->host.h_name = NULL;
192 	eom = answer->buf + anslen;
193 	switch (qtype) {
194 	case T_A:
195 	case T_AAAA:
196 		name_ok = res_hnok;
197 		break;
198 	case T_PTR:
199 		name_ok = res_dnok;
200 		break;
201 	default:
202 		return NULL;	/* XXX should be abort(); */
203 	}
204 	/*
205 	 * find first satisfactory answer
206 	 */
207 	hp = &answer->hdr;
208 	ancount = ntohs(hp->ancount);
209 	qdcount = ntohs(hp->qdcount);
210 	bp = rs->hostbuf;
211 	ep = rs->hostbuf + sizeof rs->hostbuf;
212 	cp = answer->buf;
213 	BOUNDED_INCR(HFIXEDSZ);
214 	if (qdcount != 1) {
215 		h_errno = NO_RECOVERY;
216 		return NULL;
217 	}
218 	n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
219 	if ((n < 0) || !(*name_ok)(bp)) {
220 		h_errno = NO_RECOVERY;
221 		return NULL;
222 	}
223 	BOUNDED_INCR(n + QFIXEDSZ);
224 	if (qtype == T_A || qtype == T_AAAA) {
225 		/* res_send() has already verified that the query name is the
226 		 * same as the one we sent; this just gets the expanded name
227 		 * (i.e., with the succeeding search-domain tacked on).
228 		 */
229 		n = strlen(bp) + 1;		/* for the \0 */
230 		if (n >= MAXHOSTNAMELEN) {
231 			h_errno = NO_RECOVERY;
232 			return NULL;
233 		}
234 		rs->host.h_name = bp;
235 		bp += n;
236 		/* The qname can be abbreviated, but h_name is now absolute. */
237 		qname = rs->host.h_name;
238 	}
239 	ap = rs->host_aliases;
240 	*ap = NULL;
241 	rs->host.h_aliases = rs->host_aliases;
242 	hap = rs->h_addr_ptrs;
243 	*hap = NULL;
244 	rs->host.h_addr_list = rs->h_addr_ptrs;
245 	haveanswer = 0;
246 	had_error = 0;
247 	while (ancount-- > 0 && cp < eom && !had_error) {
248 		n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
249 		if ((n < 0) || !(*name_ok)(bp)) {
250 			had_error++;
251 			continue;
252 		}
253 		cp += n;			/* name */
254 		BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
255 		type = _getshort(cp);
256  		cp += INT16SZ;			/* type */
257 		class = _getshort(cp);
258  		cp += INT16SZ + INT32SZ;	/* class, TTL */
259 		n = _getshort(cp);
260 		cp += INT16SZ;			/* len */
261 		BOUNDS_CHECK(cp, n);
262 		erdata = cp + n;
263 		if (class != C_IN) {
264 			/* XXX - debug? syslog? */
265 			cp += n;
266 			continue;		/* XXX - had_error++ ? */
267 		}
268 		if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
269 			if (ap >= &rs->host_aliases[MAXALIASES-1])
270 				continue;
271 			n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
272 			if ((n < 0) || !(*name_ok)(tbuf)) {
273 				had_error++;
274 				continue;
275 			}
276 			cp += n;
277 			if (cp != erdata) {
278 				h_errno = NO_RECOVERY;
279 				return NULL;
280 			}
281 			/* Store alias. */
282 			*ap++ = bp;
283 			n = strlen(bp) + 1;	/* for the \0 */
284 			if (n >= MAXHOSTNAMELEN) {
285 				had_error++;
286 				continue;
287 			}
288 			bp += n;
289 			/* Get canonical name. */
290 			n = strlen(tbuf) + 1;	/* for the \0 */
291 			if (n > ep - bp || n >= MAXHOSTNAMELEN) {
292 				had_error++;
293 				continue;
294 			}
295 			strlcpy(bp, tbuf, (size_t)(ep - bp));
296 			rs->host.h_name = bp;
297 			bp += n;
298 			continue;
299 		}
300 		if (qtype == T_PTR && type == T_CNAME) {
301 			n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
302 			if (n < 0 || !res_dnok(tbuf)) {
303 				had_error++;
304 				continue;
305 			}
306 			cp += n;
307 			if (cp != erdata) {
308 				h_errno = NO_RECOVERY;
309 				return NULL;
310 			}
311 			/* Get canonical name. */
312 			n = strlen(tbuf) + 1;	/* for the \0 */
313 			if (n > ep - bp || n >= MAXHOSTNAMELEN) {
314 				had_error++;
315 				continue;
316 			}
317 			strlcpy(bp, tbuf, (size_t)(ep - bp));
318 			tname = bp;
319 			bp += n;
320 			continue;
321 		}
322 		if (type != qtype) {
323 			if (type != T_KEY && type != T_SIG)
324 				syslog(LOG_NOTICE|LOG_AUTH,
325 	       "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
326 				       qname, p_class(C_IN), p_type(qtype),
327 				       p_type(type));
328 			cp += n;
329 			continue;		/* XXX - had_error++ ? */
330 		}
331 		switch (type) {
332 		case T_PTR:
333 			if (strcasecmp(tname, bp) != 0) {
334 				syslog(LOG_NOTICE|LOG_AUTH,
335 				       AskedForGot, qname, bp);
336 				cp += n;
337 				continue;	/* XXX - had_error++ ? */
338 			}
339 			n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
340 			if ((n < 0) || !res_hnok(bp)) {
341 				had_error++;
342 				break;
343 			}
344 #if MULTI_PTRS_ARE_ALIASES
345 			cp += n;
346 			if (cp != erdata) {
347 				h_errno = NO_RECOVERY;
348 				return NULL;
349 			}
350 			if (!haveanswer)
351 				rs->host.h_name = bp;
352 			else if (ap < &rs->host_aliases[MAXALIASES-1])
353 				*ap++ = bp;
354 			else
355 				n = -1;
356 			if (n != -1) {
357 				n = strlen(bp) + 1;	/* for the \0 */
358 				if (n >= MAXHOSTNAMELEN) {
359 					had_error++;
360 					break;
361 				}
362 				bp += n;
363 			}
364 			break;
365 #else
366 			rs->host.h_name = bp;
367 			if (res->options & RES_USE_INET6) {
368 				n = strlen(bp) + 1;	/* for the \0 */
369 				if (n >= MAXHOSTNAMELEN) {
370 					had_error++;
371 					break;
372 				}
373 				bp += n;
374 				map_v4v6_hostent(&rs->host, &bp, ep);
375 			}
376 			h_errno = NETDB_SUCCESS;
377 			return &rs->host;
378 #endif
379 		case T_A:
380 		case T_AAAA:
381 			if (strcasecmp(rs->host.h_name, bp) != 0) {
382 				syslog(LOG_NOTICE|LOG_AUTH,
383 				       AskedForGot, rs->host.h_name, bp);
384 				cp += n;
385 				continue;	/* XXX - had_error++ ? */
386 			}
387 			if (n != rs->host.h_length) {
388 				cp += n;
389 				continue;
390 			}
391 			if (type == T_AAAA) {
392 				struct in6_addr in6;
393 				memcpy(&in6, cp, IN6ADDRSZ);
394 				if (IN6_IS_ADDR_V4MAPPED(&in6)) {
395 					cp += n;
396 					continue;
397 				}
398 			}
399 			if (!haveanswer) {
400 				int nn;
401 
402 				rs->host.h_name = bp;
403 				nn = strlen(bp) + 1;	/* for the \0 */
404 				bp += nn;
405 			}
406 
407 			bp += sizeof(align) -
408 			    (size_t)((u_long)bp % sizeof(align));
409 
410 			if (bp + n >= &rs->hostbuf[sizeof rs->hostbuf]) {
411 				dprintf("size (%d) too big\n", res, n);
412 				had_error++;
413 				continue;
414 			}
415 			if (hap >= &rs->h_addr_ptrs[MAXADDRS-1]) {
416 				if (!toobig++)
417 					dprintf("Too many addresses (%d)\n",
418 						res, MAXADDRS);
419 				cp += n;
420 				continue;
421 			}
422 			(void)memcpy(*hap++ = bp, cp, (size_t)n);
423 			bp += n;
424 			cp += n;
425 			if (cp != erdata) {
426 				h_errno = NO_RECOVERY;
427 				return NULL;
428 			}
429 			break;
430 		default:
431 			abort();
432 		}
433 		if (!had_error)
434 			haveanswer++;
435 	}
436 	if (haveanswer) {
437 		*ap = NULL;
438 		*hap = NULL;
439 		/*
440 		 * Note: we sort even if host can take only one address
441 		 * in its return structures - should give it the "best"
442 		 * address in that case, not some random one
443 		 */
444 		if (res->nsort && haveanswer > 1 && qtype == T_A)
445 			addrsort(rs->h_addr_ptrs, haveanswer, res);
446 		if (!rs->host.h_name) {
447 			n = strlen(qname) + 1;	/* for the \0 */
448 			if (n > ep - bp || n >= MAXHOSTNAMELEN)
449 				goto no_recovery;
450 			strlcpy(bp, qname, (size_t)(ep - bp));
451 			rs->host.h_name = bp;
452 			bp += n;
453 		}
454 		if (res->options & RES_USE_INET6)
455 			map_v4v6_hostent(&rs->host, &bp, ep);
456 		h_errno = NETDB_SUCCESS;
457 		return &rs->host;
458 	}
459  no_recovery:
460 	h_errno = NO_RECOVERY;
461 	return NULL;
462 }
463 
464 int
gethostbyname_r(const char * name,struct hostent * hp,char * buf,size_t buflen,struct hostent ** result,int * errorp)465 gethostbyname_r(const char *name, struct hostent *hp, char *buf, size_t buflen,
466     struct hostent**result, int *errorp)
467 {
468         struct hostent *res;
469 
470         res = gethostbyname(name);
471         *errorp = h_errno;
472         if (res == NULL) {
473                 *result = NULL;
474                 return -1;
475         }
476         memcpy(hp, res, sizeof *hp);
477         *result = hp;
478         return 0;
479 }
480 
481 struct hostent *
gethostbyname(const char * name)482 gethostbyname(const char *name)
483 {
484 	struct hostent *hp;
485 	res_state res = __res_get_state();
486 
487 	if (res == NULL)
488 		return NULL;
489 
490 	assert(name != NULL);
491 
492 	if (res->options & RES_USE_INET6) {
493 		hp = gethostbyname_internal(name, AF_INET6, res);
494 		if (hp) {
495 			__res_put_state(res);
496 			return hp;
497 		}
498 	}
499 	hp = gethostbyname_internal(name, AF_INET, res);
500 	__res_put_state(res);
501 	return hp;
502 }
503 
504 struct hostent *
gethostbyname2(const char * name,int af)505 gethostbyname2(const char *name, int af)
506 {
507 	struct hostent *hp;
508 	res_state res = __res_get_state();
509 
510 	if (res == NULL)
511 		return NULL;
512 	hp = gethostbyname_internal(name, af, res);
513 	__res_put_state(res);
514 	return hp;
515 }
516 
517 static struct hostent *
gethostbyname_internal(const char * name,int af,res_state res)518 gethostbyname_internal(const char *name, int af, res_state res)
519 {
520 	const char *cp;
521 	char *bp, *ep;
522 	int size;
523 	struct hostent *hp;
524         struct resolv_cache*  cache;
525         res_static  rs = __res_get_static();
526 
527 	static const ns_dtab dtab[] = {
528 		NS_FILES_CB(_gethtbyname, NULL)
529 		{ NSSRC_DNS, _dns_gethtbyname, NULL },	/* force -DHESIOD */
530 		{ 0, 0, 0 }
531 	};
532 
533 	assert(name != NULL);
534 
535 	switch (af) {
536 	case AF_INET:
537 		size = INADDRSZ;
538 		break;
539 	case AF_INET6:
540 		size = IN6ADDRSZ;
541 		break;
542 	default:
543 		h_errno = NETDB_INTERNAL;
544 		errno = EAFNOSUPPORT;
545 		return NULL;
546 	}
547 
548 	rs->host.h_addrtype = af;
549 	rs->host.h_length = size;
550 
551 	/*
552 	 * if there aren't any dots, it could be a user-level alias.
553 	 * this is also done in res_nquery() since we are not the only
554 	 * function that looks up host names.
555 	 */
556 	if (!strchr(name, '.') && (cp = __hostalias(name)))
557 		name = cp;
558 
559 	/*
560 	 * disallow names consisting only of digits/dots, unless
561 	 * they end in a dot.
562 	 */
563 	if (isdigit((u_char) name[0]))
564 		for (cp = name;; ++cp) {
565 			if (!*cp) {
566 				if (*--cp == '.')
567 					break;
568 				/*
569 				 * All-numeric, no dot at the end.
570 				 * Fake up a hostent as if we'd actually
571 				 * done a lookup.
572 				 */
573 				if (inet_pton(af, name,
574 				    (char *)(void *)rs->host_addr) <= 0) {
575 					h_errno = HOST_NOT_FOUND;
576 					return NULL;
577 				}
578 				strncpy(rs->hostbuf, name, MAXDNAME);
579 				rs->hostbuf[MAXDNAME] = '\0';
580 				bp = rs->hostbuf + MAXDNAME;
581 				ep = rs->hostbuf + sizeof rs->hostbuf;
582 				rs->host.h_name = rs->hostbuf;
583 				rs->host.h_aliases = rs->host_aliases;
584 				rs->host_aliases[0] = NULL;
585 				rs->h_addr_ptrs[0] = (char *)(void *)rs->host_addr;
586 				rs->h_addr_ptrs[1] = NULL;
587 				rs->host.h_addr_list = rs->h_addr_ptrs;
588 				if (res->options & RES_USE_INET6)
589 					map_v4v6_hostent(&rs->host, &bp, ep);
590 				h_errno = NETDB_SUCCESS;
591 				return &rs->host;
592 			}
593 			if (!isdigit((u_char) *cp) && *cp != '.')
594 				break;
595 		}
596 	if ((isxdigit((u_char) name[0]) && strchr(name, ':') != NULL) ||
597 	    name[0] == ':')
598 		for (cp = name;; ++cp) {
599 			if (!*cp) {
600 				if (*--cp == '.')
601 					break;
602 				/*
603 				 * All-IPv6-legal, no dot at the end.
604 				 * Fake up a hostent as if we'd actually
605 				 * done a lookup.
606 				 */
607 				if (inet_pton(af, name,
608 				    (char *)(void *)rs->host_addr) <= 0) {
609 					h_errno = HOST_NOT_FOUND;
610 					return NULL;
611 				}
612 				strncpy(rs->hostbuf, name, MAXDNAME);
613 				rs->hostbuf[MAXDNAME] = '\0';
614 				bp = rs->hostbuf + MAXDNAME;
615 				ep = rs->hostbuf + sizeof rs->hostbuf;
616 				rs->host.h_name = rs->hostbuf;
617 				rs->host.h_aliases = rs->host_aliases;
618 				rs->host_aliases[0] = NULL;
619 				rs->h_addr_ptrs[0] = (char *)(void *)rs->host_addr;
620 				rs->h_addr_ptrs[1] = NULL;
621 				rs->host.h_addr_list = rs->h_addr_ptrs;
622 				h_errno = NETDB_SUCCESS;
623 				return &rs->host;
624 			}
625 			if (!isxdigit((u_char) *cp) && *cp != ':' && *cp != '.')
626 				break;
627 		}
628 
629 	hp = NULL;
630 	h_errno = NETDB_INTERNAL;
631 	if (nsdispatch(&hp, dtab, NSDB_HOSTS, "gethostbyname",
632 	    default_dns_files, name, strlen(name), af) != NS_SUCCESS) {
633 		return NULL;
634         }
635 	h_errno = NETDB_SUCCESS;
636 	return hp;
637 }
638 
639 struct hostent *
gethostbyaddr(const char * addr,socklen_t len,int af)640 gethostbyaddr(const char *addr,	/* XXX should have been def'd as u_char! */
641     socklen_t len, int af)
642 {
643 	const u_char *uaddr = (const u_char *)addr;
644 	socklen_t size;
645 	struct hostent *hp;
646 	static const ns_dtab dtab[] = {
647 		NS_FILES_CB(_gethtbyaddr, NULL)
648 		{ NSSRC_DNS, _dns_gethtbyaddr, NULL },	/* force -DHESIOD */
649 		{ 0, 0, 0 }
650 	};
651 
652 	assert(addr != NULL);
653 
654 	if (af == AF_INET6 && len == IN6ADDRSZ &&
655 	    (IN6_IS_ADDR_LINKLOCAL((const struct in6_addr *)(const void *)uaddr) ||
656 	     IN6_IS_ADDR_SITELOCAL((const struct in6_addr *)(const void *)uaddr))) {
657 		h_errno = HOST_NOT_FOUND;
658 		return NULL;
659 	}
660 	if (af == AF_INET6 && len == IN6ADDRSZ &&
661 	    (IN6_IS_ADDR_V4MAPPED((const struct in6_addr *)(const void *)uaddr) ||
662 	     IN6_IS_ADDR_V4COMPAT((const struct in6_addr *)(const void *)uaddr))) {
663 		/* Unmap. */
664 		addr += IN6ADDRSZ - INADDRSZ;
665 		uaddr += IN6ADDRSZ - INADDRSZ;
666 		af = AF_INET;
667 		len = INADDRSZ;
668 	}
669 	switch (af) {
670 	case AF_INET:
671 		size = INADDRSZ;
672 		break;
673 	case AF_INET6:
674 		size = IN6ADDRSZ;
675 		break;
676 	default:
677 		errno = EAFNOSUPPORT;
678 		h_errno = NETDB_INTERNAL;
679 		return NULL;
680 	}
681 	if (size != len) {
682 		errno = EINVAL;
683 		h_errno = NETDB_INTERNAL;
684 		return NULL;
685 	}
686 	hp = NULL;
687 	h_errno = NETDB_INTERNAL;
688 	if (nsdispatch(&hp, dtab, NSDB_HOSTS, "gethostbyaddr",
689 	    default_dns_files, uaddr, len, af) != NS_SUCCESS)
690 		return NULL;
691 	h_errno = NETDB_SUCCESS;
692 	return hp;
693 }
694 
695 void
_sethtent(int f)696 _sethtent(int f)
697 {
698     res_static  rs = __res_get_static();
699     if (rs == NULL) return;
700 	if (!rs->hostf)
701 		rs->hostf = fopen(_PATH_HOSTS, "r" );
702 	else
703 		rewind(rs->hostf);
704 	rs->stayopen = f;
705 }
706 
707 void
_endhtent(void)708 _endhtent(void)
709 {
710     res_static  rs = __res_get_static();
711     if (rs == NULL) return;
712 
713 	if (rs->hostf && !rs->stayopen) {
714 		(void) fclose(rs->hostf);
715 		rs->hostf = NULL;
716 	}
717 }
718 
719 struct hostent *
_gethtent(void)720 _gethtent(void)
721 {
722 	char *p;
723 	char *cp, **q;
724 	int af, len;
725 	res_static  rs = __res_get_static();
726 
727 	if (!rs->hostf && !(rs->hostf = fopen(_PATH_HOSTS, "r" ))) {
728 		h_errno = NETDB_INTERNAL;
729 		return NULL;
730 	}
731  again:
732 	if (!(p = fgets(rs->hostbuf, sizeof rs->hostbuf, rs->hostf))) {
733 		h_errno = HOST_NOT_FOUND;
734 		return NULL;
735 	}
736 	if (*p == '#')
737 		goto again;
738 	if (!(cp = strpbrk(p, "#\n")))
739 		goto again;
740 	*cp = '\0';
741 	if (!(cp = strpbrk(p, " \t")))
742 		goto again;
743 	*cp++ = '\0';
744 	if (inet_pton(AF_INET6, p, (char *)(void *)rs->host_addr) > 0) {
745 		af = AF_INET6;
746 		len = IN6ADDRSZ;
747 	} else if (inet_pton(AF_INET, p, (char *)(void *)rs->host_addr) > 0) {
748 		res_state res = __res_get_state();
749 		if (res == NULL)
750 			return NULL;
751 		if (res->options & RES_USE_INET6) {
752 			map_v4v6_address((char *)(void *)rs->host_addr,
753 			    (char *)(void *)rs->host_addr);
754 			af = AF_INET6;
755 			len = IN6ADDRSZ;
756 		} else {
757 			af = AF_INET;
758 			len = INADDRSZ;
759 		}
760 		__res_put_state(res);
761 	} else {
762 		goto again;
763 	}
764 	/* if this is not something we're looking for, skip it. */
765 	if (rs->host.h_addrtype != 0 && rs->host.h_addrtype != af)
766 		goto again;
767 	if (rs->host.h_length != 0 && rs->host.h_length != len)
768 		goto again;
769 	rs->h_addr_ptrs[0] = (char *)(void *)rs->host_addr;
770 	rs->h_addr_ptrs[1] = NULL;
771 	rs->host.h_addr_list = rs->h_addr_ptrs;
772 	rs->host.h_length = len;
773 	rs->host.h_addrtype = af;
774 	while (*cp == ' ' || *cp == '\t')
775 		cp++;
776 	rs->host.h_name = cp;
777 	q = rs->host.h_aliases = rs->host_aliases;
778 	if ((cp = strpbrk(cp, " \t")) != NULL)
779 		*cp++ = '\0';
780 	while (cp && *cp) {
781 		if (*cp == ' ' || *cp == '\t') {
782 			cp++;
783 			continue;
784 		}
785 		if (q < &rs->host_aliases[MAXALIASES - 1])
786 			*q++ = cp;
787 		if ((cp = strpbrk(cp, " \t")) != NULL)
788 			*cp++ = '\0';
789 	}
790 	*q = NULL;
791 	h_errno = NETDB_SUCCESS;
792 	return &rs->host;
793 }
794 
795 /*ARGSUSED*/
796 int
_gethtbyname(void * rv,void * cb_data,va_list ap)797 _gethtbyname(void *rv, void *cb_data, va_list ap)
798 {
799 	struct hostent *hp;
800 	const char *name;
801 	int af;
802 
803 	assert(rv != NULL);
804 
805 	name = va_arg(ap, char *);
806 	/* NOSTRICT skip len */(void)va_arg(ap, int);
807 	af = va_arg(ap, int);
808 
809 	hp = NULL;
810 #if 0
811 	{
812 		res_state res = __res_get_state();
813 		if (res == NULL)
814 			return NS_NOTFOUND;
815 		if (res->options & RES_USE_INET6)
816 			hp = _gethtbyname2(name, AF_INET6);
817 		if (hp==NULL)
818 			hp = _gethtbyname2(name, AF_INET);
819 		__res_put_state(res);
820 	}
821 #else
822 	hp = _gethtbyname2(name, af);
823 #endif
824 	*((struct hostent **)rv) = hp;
825 	if (hp == NULL) {
826 		h_errno = HOST_NOT_FOUND;
827 		return NS_NOTFOUND;
828 	}
829 	return NS_SUCCESS;
830 }
831 
832 struct hostent *
_gethtbyname2(const char * name,int af)833 _gethtbyname2(const char *name, int af)
834 {
835 	struct hostent *p;
836 	char *tmpbuf, *ptr, **cp;
837 	int num;
838 	size_t len;
839 	res_static rs = __res_get_static();
840 
841 	assert(name != NULL);
842 
843 	_sethtent(rs->stayopen);
844 	ptr = tmpbuf = NULL;
845 	num = 0;
846 	while ((p = _gethtent()) != NULL && num < MAXADDRS) {
847 		if (p->h_addrtype != af)
848 			continue;
849 		if (strcasecmp(p->h_name, name) != 0) {
850 			for (cp = p->h_aliases; *cp != NULL; cp++)
851 				if (strcasecmp(*cp, name) == 0)
852 					break;
853 			if (*cp == NULL) continue;
854 		}
855 
856 		if (num == 0) {
857 			size_t bufsize;
858 			char *src;
859 
860 			bufsize = strlen(p->h_name) + 2 +
861 				  MAXADDRS * p->h_length +
862 				  ALIGNBYTES;
863 			for (cp = p->h_aliases; *cp != NULL; cp++)
864 				bufsize += strlen(*cp) + 1;
865 
866 			if ((tmpbuf = malloc(bufsize)) == NULL) {
867 				h_errno = NETDB_INTERNAL;
868 				return NULL;
869 			}
870 
871 			ptr = tmpbuf;
872 			src = p->h_name;
873 			while ((*ptr++ = *src++) != '\0');
874 			for (cp = p->h_aliases; *cp != NULL; cp++) {
875 				src = *cp;
876 				while ((*ptr++ = *src++) != '\0');
877 			}
878 			*ptr++ = '\0';
879 
880 			ptr = (char *)(void *)ALIGN(ptr);
881 		}
882 
883 		(void)memcpy(ptr, p->h_addr_list[0], (size_t)p->h_length);
884 		ptr += p->h_length;
885 		num++;
886 	}
887 	_endhtent();
888 	if (num == 0) return NULL;
889 
890 	len = ptr - tmpbuf;
891 	if (len > (sizeof(rs->hostbuf) - ALIGNBYTES)) {
892 		free(tmpbuf);
893 		errno = ENOSPC;
894 		h_errno = NETDB_INTERNAL;
895 		return NULL;
896 	}
897 	ptr = memcpy((void *)ALIGN(rs->hostbuf), tmpbuf, len);
898 	free(tmpbuf);
899 
900 	rs->host.h_name = ptr;
901 	while (*ptr++);
902 
903 	cp = rs->host_aliases;
904 	while (*ptr) {
905 		*cp++ = ptr;
906 		while (*ptr++);
907 	}
908 	ptr++;
909 	*cp = NULL;
910 
911 	ptr = (char *)(void *)ALIGN(ptr);
912 	cp = rs->h_addr_ptrs;
913 	while (num--) {
914 		*cp++ = ptr;
915 		ptr += rs->host.h_length;
916 	}
917 	*cp = NULL;
918 
919 	return &rs->host;
920 }
921 
922 /*ARGSUSED*/
923 int
_gethtbyaddr(void * rv,void * cb_data,va_list ap)924 _gethtbyaddr(void *rv, void *cb_data, va_list ap)
925 {
926 	struct hostent *p;
927 	const unsigned char *addr;
928 	int len, af;
929 	res_static  rs = __res_get_static();
930 
931 	assert(rv != NULL);
932 
933 	addr = va_arg(ap, unsigned char *);
934 	len = va_arg(ap, int);
935 	af = va_arg(ap, int);
936 
937 	rs->host.h_length = len;
938 	rs->host.h_addrtype = af;
939 
940 	_sethtent(rs->stayopen);
941 	while ((p = _gethtent()) != NULL)
942 		if (p->h_addrtype == af && !memcmp(p->h_addr, addr,
943 		    (size_t)len))
944 			break;
945 	_endhtent();
946 	*((struct hostent **)rv) = p;
947 	if (p==NULL) {
948 		h_errno = HOST_NOT_FOUND;
949 		return NS_NOTFOUND;
950 	}
951 	return NS_SUCCESS;
952 }
953 
954 static void
map_v4v6_address(const char * src,char * dst)955 map_v4v6_address(const char *src, char *dst)
956 {
957 	u_char *p = (u_char *)dst;
958 	char tmp[INADDRSZ];
959 	int i;
960 
961 	assert(src != NULL);
962 	assert(dst != NULL);
963 
964 	/* Stash a temporary copy so our caller can update in place. */
965 	(void)memcpy(tmp, src, INADDRSZ);
966 	/* Mark this ipv6 addr as a mapped ipv4. */
967 	for (i = 0; i < 10; i++)
968 		*p++ = 0x00;
969 	*p++ = 0xff;
970 	*p++ = 0xff;
971 	/* Retrieve the saved copy and we're done. */
972 	(void)memcpy((void *)p, tmp, INADDRSZ);
973 }
974 
975 static void
map_v4v6_hostent(struct hostent * hp,char ** bpp,char * ep)976 map_v4v6_hostent(struct hostent *hp, char **bpp, char *ep)
977 {
978 	char **ap;
979 
980 	assert(hp != NULL);
981 	assert(bpp != NULL);
982 	assert(ep != NULL);
983 
984 	if (hp->h_addrtype != AF_INET || hp->h_length != INADDRSZ)
985 		return;
986 	hp->h_addrtype = AF_INET6;
987 	hp->h_length = IN6ADDRSZ;
988 	for (ap = hp->h_addr_list; *ap; ap++) {
989 		int i = sizeof(align) - (size_t)((u_long)*bpp % sizeof(align));
990 
991 		if (ep - *bpp < (i + IN6ADDRSZ)) {
992 			/* Out of memory.  Truncate address list here.  XXX */
993 			*ap = NULL;
994 			return;
995 		}
996 		*bpp += i;
997 		map_v4v6_address(*ap, *bpp);
998 		*ap = *bpp;
999 		*bpp += IN6ADDRSZ;
1000 	}
1001 }
1002 
1003 static void
addrsort(char ** ap,int num,res_state res)1004 addrsort(char **ap, int num, res_state res)
1005 {
1006 	int i, j;
1007 	char **p;
1008 	short aval[MAXADDRS];
1009 	int needsort = 0;
1010 
1011 	assert(ap != NULL);
1012 
1013 	p = ap;
1014 	for (i = 0; i < num; i++, p++) {
1015 	    for (j = 0 ; (unsigned)j < res->nsort; j++)
1016 		if (res->sort_list[j].addr.s_addr ==
1017 		    (((struct in_addr *)(void *)(*p))->s_addr &
1018 		    res->sort_list[j].mask))
1019 			break;
1020 	    aval[i] = j;
1021 	    if (needsort == 0 && i > 0 && j < aval[i-1])
1022 		needsort = i;
1023 	}
1024 	if (!needsort)
1025 	    return;
1026 
1027 	while (needsort < num) {
1028 	    for (j = needsort - 1; j >= 0; j--) {
1029 		if (aval[j] > aval[j+1]) {
1030 		    char *hp;
1031 
1032 		    i = aval[j];
1033 		    aval[j] = aval[j+1];
1034 		    aval[j+1] = i;
1035 
1036 		    hp = ap[j];
1037 		    ap[j] = ap[j+1];
1038 		    ap[j+1] = hp;
1039 		} else
1040 		    break;
1041 	    }
1042 	    needsort++;
1043 	}
1044 }
1045 
1046 struct hostent *
gethostent(void)1047 gethostent(void)
1048 {
1049     res_static  rs = __res_get_static();
1050 	rs->host.h_addrtype = 0;
1051 	rs->host.h_length = 0;
1052 	return _gethtent();
1053 }
1054 
1055 /*ARGSUSED*/
1056 int
_dns_gethtbyname(void * rv,void * cb_data,va_list ap)1057 _dns_gethtbyname(void *rv, void *cb_data, va_list ap)
1058 {
1059 	querybuf *buf;
1060 	int n, type;
1061 	struct hostent *hp;
1062 	const char *name;
1063 	int af;
1064 	res_state res;
1065 
1066 	assert(rv != NULL);
1067 
1068 	name = va_arg(ap, char *);
1069 	/* NOSTRICT skip len */(void)va_arg(ap, int);
1070 	af = va_arg(ap, int);
1071 
1072 	switch (af) {
1073 	case AF_INET:
1074 		type = T_A;
1075 		break;
1076 	case AF_INET6:
1077 		type = T_AAAA;
1078 		break;
1079 	default:
1080 		return NS_UNAVAIL;
1081 	}
1082 	buf = malloc(sizeof(*buf));
1083 	if (buf == NULL) {
1084 		h_errno = NETDB_INTERNAL;
1085 		return NS_NOTFOUND;
1086 	}
1087 	res = __res_get_state();
1088 	if (res == NULL) {
1089 		free(buf);
1090 		return NS_NOTFOUND;
1091 	}
1092 	n = res_nsearch(res, name, C_IN, type, buf->buf, sizeof(buf->buf));
1093 	if (n < 0) {
1094 		free(buf);
1095 		dprintf("res_nsearch failed (%d)\n", res, n);
1096 		__res_put_state(res);
1097 		return NS_NOTFOUND;
1098 	}
1099 	hp = getanswer(buf, n, name, type, res);
1100 	free(buf);
1101 	__res_put_state(res);
1102 	if (hp == NULL)
1103 		switch (h_errno) {
1104 		case HOST_NOT_FOUND:
1105 			return NS_NOTFOUND;
1106 		case TRY_AGAIN:
1107 			return NS_TRYAGAIN;
1108 		default:
1109 			return NS_UNAVAIL;
1110 		}
1111 	*((struct hostent **)rv) = hp;
1112 	return NS_SUCCESS;
1113 }
1114 
1115 /*ARGSUSED*/
1116 int
_dns_gethtbyaddr(void * rv,void * cb_data,va_list ap)1117 _dns_gethtbyaddr(void *rv, void	*cb_data, va_list ap)
1118 {
1119 	char qbuf[MAXDNAME + 1], *qp, *ep;
1120 	int n;
1121 	querybuf *buf;
1122 	struct hostent *hp;
1123 	const unsigned char *uaddr;
1124 	int len, af, advance;
1125 	res_state res;
1126 	res_static rs = __res_get_static();
1127 
1128 	assert(rv != NULL);
1129 
1130 	uaddr = va_arg(ap, unsigned char *);
1131 	len = va_arg(ap, int);
1132 	af = va_arg(ap, int);
1133 
1134 	switch (af) {
1135 	case AF_INET:
1136 		(void)snprintf(qbuf, sizeof(qbuf), "%u.%u.%u.%u.in-addr.arpa",
1137 		    (uaddr[3] & 0xff), (uaddr[2] & 0xff),
1138 		    (uaddr[1] & 0xff), (uaddr[0] & 0xff));
1139 		break;
1140 
1141 	case AF_INET6:
1142 		qp = qbuf;
1143 		ep = qbuf + sizeof(qbuf) - 1;
1144 		for (n = IN6ADDRSZ - 1; n >= 0; n--) {
1145 			advance = snprintf(qp, (size_t)(ep - qp), "%x.%x.",
1146 			    uaddr[n] & 0xf,
1147 			    ((unsigned int)uaddr[n] >> 4) & 0xf);
1148 			if (advance > 0 && qp + advance < ep)
1149 				qp += advance;
1150 			else {
1151 				h_errno = NETDB_INTERNAL;
1152 				return NS_NOTFOUND;
1153 			}
1154 		}
1155 		if (strlcat(qbuf, "ip6.arpa", sizeof(qbuf)) >= sizeof(qbuf)) {
1156 			h_errno = NETDB_INTERNAL;
1157 			return NS_NOTFOUND;
1158 		}
1159 		break;
1160 	default:
1161 		abort();
1162 	}
1163 
1164 	buf = malloc(sizeof(*buf));
1165 	if (buf == NULL) {
1166 		h_errno = NETDB_INTERNAL;
1167 		return NS_NOTFOUND;
1168 	}
1169 	res = __res_get_state();
1170 	if (res == NULL) {
1171 		free(buf);
1172 		return NS_NOTFOUND;
1173 	}
1174 	n = res_nquery(res, qbuf, C_IN, T_PTR, buf->buf, sizeof(buf->buf));
1175 	if (n < 0) {
1176 		free(buf);
1177 		dprintf("res_nquery failed (%d)\n", res, n);
1178 		__res_put_state(res);
1179 		return NS_NOTFOUND;
1180 	}
1181 	hp = getanswer(buf, n, qbuf, T_PTR, res);
1182 	free(buf);
1183 	if (hp == NULL) {
1184 		__res_put_state(res);
1185 		switch (h_errno) {
1186 		case HOST_NOT_FOUND:
1187 			return NS_NOTFOUND;
1188 		case TRY_AGAIN:
1189 			return NS_TRYAGAIN;
1190 		default:
1191 			return NS_UNAVAIL;
1192 		}
1193 	}
1194 	hp->h_addrtype = af;
1195 	hp->h_length = len;
1196 	(void)memcpy(rs->host_addr, uaddr, (size_t)len);
1197 	rs->h_addr_ptrs[0] = (char *)(void *)rs->host_addr;
1198 	rs->h_addr_ptrs[1] = NULL;
1199 	if (af == AF_INET && (res->options & RES_USE_INET6)) {
1200 		map_v4v6_address((char *)(void *)rs->host_addr,
1201 		    (char *)(void *)rs->host_addr);
1202 		hp->h_addrtype = AF_INET6;
1203 		hp->h_length = IN6ADDRSZ;
1204 	}
1205 
1206 	__res_put_state(res);
1207 	*((struct hostent **)rv) = hp;
1208 	h_errno = NETDB_SUCCESS;
1209 	return NS_SUCCESS;
1210 }
1211