1 /*
2 * Copyright (c) 1985, 1988, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. 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
34 /*
35 * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
36 * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
37 *
38 * Permission to use, copy, modify, and distribute this software for any
39 * purpose with or without fee is hereby granted, provided that the above
40 * copyright notice and this permission notice appear in all copies.
41 *
42 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
43 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
44 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
45 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
46 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
47 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
48 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
49 */
50
51 /* from gethostnamadr.c 8.1 (Berkeley) 6/4/93 */
52 /* BIND Id: gethnamaddr.c,v 8.15 1996/05/22 04:56:30 vixie Exp $ */
53
54 #if defined(LIBC_SCCS) && !defined(lint)
55 static const char rcsid[] = "$Id: lcl_ho.c,v 1.5 2006/03/09 23:57:56 marka Exp $";
56 #endif /* LIBC_SCCS and not lint */
57
58 /* Imports. */
59
60 #include "port_before.h"
61
62 #include <sys/types.h>
63 #include <sys/param.h>
64 #include <sys/socket.h>
65
66 #include <netinet/in.h>
67 #include <arpa/inet.h>
68 #include <arpa/nameser.h>
69
70 #include <ctype.h>
71 #include <errno.h>
72 #include <fcntl.h>
73 #include <netdb.h>
74 #include <resolv.h>
75 #include <stdio.h>
76 #include <stdlib.h>
77 #include <string.h>
78
79 #include <irs.h>
80 #include <isc/memcluster.h>
81
82 #include "port_after.h"
83
84 #include "irs_p.h"
85 #include "dns_p.h"
86 #include "lcl_p.h"
87
88 #ifdef SPRINTF_CHAR
89 # define SPRINTF(x) strlen(sprintf/**/x)
90 #else
91 # define SPRINTF(x) sprintf x
92 #endif
93
94 /* Definitions. */
95
96 #define MAXALIASES 35
97 #define MAXADDRS 35
98 #define Max(a,b) ((a) > (b) ? (a) : (b))
99
100 #if PACKETSZ > 1024
101 #define MAXPACKET PACKETSZ
102 #else
103 #define MAXPACKET 1024
104 #endif
105
106 struct pvt {
107 FILE * fp;
108 struct hostent host;
109 char * h_addr_ptrs[MAXADDRS + 1];
110 char * host_aliases[MAXALIASES];
111 char hostbuf[8*1024];
112 u_char host_addr[16]; /*%< IPv4 or IPv6 */
113 struct __res_state *res;
114 void (*free_res)(void *);
115 };
116
117 typedef union {
118 int32_t al;
119 char ac;
120 } align;
121
122 static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
123 static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
124
125 /* Forward. */
126
127 static void ho_close(struct irs_ho *this);
128 static struct hostent * ho_byname(struct irs_ho *this, const char *name);
129 static struct hostent * ho_byname2(struct irs_ho *this, const char *name,
130 int af);
131 static struct hostent * ho_byaddr(struct irs_ho *this, const void *addr,
132 int len, int af);
133 static struct hostent * ho_next(struct irs_ho *this);
134 static void ho_rewind(struct irs_ho *this);
135 static void ho_minimize(struct irs_ho *this);
136 static struct __res_state * ho_res_get(struct irs_ho *this);
137 static void ho_res_set(struct irs_ho *this,
138 struct __res_state *res,
139 void (*free_res)(void *));
140 static struct addrinfo * ho_addrinfo(struct irs_ho *this, const char *name,
141 const struct addrinfo *pai);
142
143 static size_t ns_namelen(const char *);
144 static int init(struct irs_ho *this);
145
146 /* Portability. */
147
148 #ifndef SEEK_SET
149 # define SEEK_SET 0
150 #endif
151
152 /* Public. */
153
154 struct irs_ho *
irs_lcl_ho(struct irs_acc * this)155 irs_lcl_ho(struct irs_acc *this) {
156 struct irs_ho *ho;
157 struct pvt *pvt;
158
159 UNUSED(this);
160
161 if (!(pvt = memget(sizeof *pvt))) {
162 errno = ENOMEM;
163 return (NULL);
164 }
165 memset(pvt, 0, sizeof *pvt);
166 if (!(ho = memget(sizeof *ho))) {
167 memput(pvt, sizeof *pvt);
168 errno = ENOMEM;
169 return (NULL);
170 }
171 memset(ho, 0x5e, sizeof *ho);
172 ho->private = pvt;
173 ho->close = ho_close;
174 ho->byname = ho_byname;
175 ho->byname2 = ho_byname2;
176 ho->byaddr = ho_byaddr;
177 ho->next = ho_next;
178 ho->rewind = ho_rewind;
179 ho->minimize = ho_minimize;
180 ho->res_get = ho_res_get;
181 ho->res_set = ho_res_set;
182 ho->addrinfo = ho_addrinfo;
183 return (ho);
184 }
185
186 /* Methods. */
187
188 static void
ho_close(struct irs_ho * this)189 ho_close(struct irs_ho *this) {
190 struct pvt *pvt = (struct pvt *)this->private;
191
192 ho_minimize(this);
193 if (pvt->fp)
194 (void) fclose(pvt->fp);
195 if (pvt->res && pvt->free_res)
196 (*pvt->free_res)(pvt->res);
197 memput(pvt, sizeof *pvt);
198 memput(this, sizeof *this);
199 }
200
201 static struct hostent *
ho_byname(struct irs_ho * this,const char * name)202 ho_byname(struct irs_ho *this, const char *name) {
203 struct pvt *pvt = (struct pvt *)this->private;
204 struct hostent *hp;
205
206 if (init(this) == -1)
207 return (NULL);
208
209 if (pvt->res->options & RES_USE_INET6) {
210 hp = ho_byname2(this, name, AF_INET6);
211 if (hp)
212 return (hp);
213 }
214 return (ho_byname2(this, name, AF_INET));
215 }
216
217 static struct hostent *
ho_byname2(struct irs_ho * this,const char * name,int af)218 ho_byname2(struct irs_ho *this, const char *name, int af) {
219 struct pvt *pvt = (struct pvt *)this->private;
220 struct hostent *hp;
221 char **hap;
222 size_t n;
223
224 if (init(this) == -1)
225 return (NULL);
226
227 ho_rewind(this);
228 n = ns_namelen(name);
229 while ((hp = ho_next(this)) != NULL) {
230 size_t nn;
231
232 if (hp->h_addrtype != af)
233 continue;
234 nn = ns_namelen(hp->h_name);
235 if (strncasecmp(hp->h_name, name, Max(n, nn)) == 0)
236 goto found;
237 for (hap = hp->h_aliases; *hap; hap++) {
238 nn = ns_namelen(*hap);
239 if (strncasecmp(*hap, name, Max(n, nn)) == 0)
240 goto found;
241 }
242 }
243 found:
244 if (!hp) {
245 RES_SET_H_ERRNO(pvt->res, HOST_NOT_FOUND);
246 return (NULL);
247 }
248 RES_SET_H_ERRNO(pvt->res, NETDB_SUCCESS);
249 return (hp);
250 }
251
252 static struct hostent *
ho_byaddr(struct irs_ho * this,const void * addr,int len,int af)253 ho_byaddr(struct irs_ho *this, const void *addr, int len, int af) {
254 struct pvt *pvt = (struct pvt *)this->private;
255 const u_char *uaddr = addr;
256 struct hostent *hp;
257 int size;
258
259 if (init(this) == -1)
260 return (NULL);
261
262 if (af == AF_INET6 && len == IN6ADDRSZ &&
263 (!memcmp(uaddr, mapped, sizeof mapped) ||
264 !memcmp(uaddr, tunnelled, sizeof tunnelled))) {
265 /* Unmap. */
266 addr = (const u_char *)addr + sizeof mapped;
267 uaddr += sizeof mapped;
268 af = AF_INET;
269 len = INADDRSZ;
270 }
271 switch (af) {
272 case AF_INET:
273 size = INADDRSZ;
274 break;
275 case AF_INET6:
276 size = IN6ADDRSZ;
277 break;
278 default:
279 errno = EAFNOSUPPORT;
280 RES_SET_H_ERRNO(pvt->res, NETDB_INTERNAL);
281 return (NULL);
282 }
283 if (size > len) {
284 errno = EINVAL;
285 RES_SET_H_ERRNO(pvt->res, NETDB_INTERNAL);
286 return (NULL);
287 }
288
289 /*
290 * Do the search.
291 */
292 ho_rewind(this);
293 while ((hp = ho_next(this)) != NULL) {
294 char **hap;
295
296 for (hap = hp->h_addr_list; *hap; hap++) {
297 const u_char *taddr = (const u_char *)*hap;
298 int taf = hp->h_addrtype;
299 int tlen = hp->h_length;
300
301 if (taf == AF_INET6 && tlen == IN6ADDRSZ &&
302 (!memcmp(taddr, mapped, sizeof mapped) ||
303 !memcmp(taddr, tunnelled, sizeof tunnelled))) {
304 /* Unmap. */
305 taddr += sizeof mapped;
306 taf = AF_INET;
307 tlen = INADDRSZ;
308 }
309 if (taf == af && tlen == len &&
310 !memcmp(taddr, uaddr, tlen))
311 goto found;
312 }
313 }
314 found:
315 if (!hp) {
316 RES_SET_H_ERRNO(pvt->res, HOST_NOT_FOUND);
317 return (NULL);
318 }
319 RES_SET_H_ERRNO(pvt->res, NETDB_SUCCESS);
320 return (hp);
321 }
322
323 static struct hostent *
ho_next(struct irs_ho * this)324 ho_next(struct irs_ho *this) {
325 struct pvt *pvt = (struct pvt *)this->private;
326 char *cp, **q, *p;
327 char *bufp, *ndbuf, *dbuf = NULL;
328 int c, af, len, bufsiz, offset;
329
330 if (init(this) == -1)
331 return (NULL);
332
333 if (!pvt->fp)
334 ho_rewind(this);
335 if (!pvt->fp) {
336 RES_SET_H_ERRNO(pvt->res, NETDB_INTERNAL);
337 return (NULL);
338 }
339 bufp = pvt->hostbuf;
340 bufsiz = sizeof pvt->hostbuf;
341 offset = 0;
342 again:
343 if (!(p = fgets(bufp + offset, bufsiz - offset, pvt->fp))) {
344 RES_SET_H_ERRNO(pvt->res, HOST_NOT_FOUND);
345 if (dbuf)
346 free(dbuf);
347 return (NULL);
348 }
349 if (!strchr(p, '\n') && !feof(pvt->fp)) {
350 #define GROWBUF 1024
351 /* allocate space for longer line */
352 if (dbuf == NULL) {
353 if ((ndbuf = malloc(bufsiz + GROWBUF)) != NULL)
354 strcpy(ndbuf, bufp);
355 } else
356 ndbuf = realloc(dbuf, bufsiz + GROWBUF);
357 if (ndbuf) {
358 dbuf = ndbuf;
359 bufp = dbuf;
360 bufsiz += GROWBUF;
361 offset = strlen(dbuf);
362 } else {
363 /* allocation failed; skip this long line */
364 while ((c = getc(pvt->fp)) != EOF)
365 if (c == '\n')
366 break;
367 if (c != EOF)
368 ungetc(c, pvt->fp);
369 }
370 goto again;
371 }
372
373 p -= offset;
374 offset = 0;
375
376 if (*p == '#')
377 goto again;
378 if ((cp = strpbrk(p, "#\n")) != NULL)
379 *cp = '\0';
380 if (!(cp = strpbrk(p, " \t")))
381 goto again;
382 *cp++ = '\0';
383 if (inet_pton(AF_INET6, p, pvt->host_addr) > 0) {
384 af = AF_INET6;
385 len = IN6ADDRSZ;
386 } else if (inet_aton(p, (struct in_addr *)pvt->host_addr) > 0) {
387 if (pvt->res->options & RES_USE_INET6) {
388 map_v4v6_address((char*)pvt->host_addr,
389 (char*)pvt->host_addr);
390 af = AF_INET6;
391 len = IN6ADDRSZ;
392 } else {
393 af = AF_INET;
394 len = INADDRSZ;
395 }
396 } else {
397 goto again;
398 }
399 pvt->h_addr_ptrs[0] = (char *)pvt->host_addr;
400 pvt->h_addr_ptrs[1] = NULL;
401 pvt->host.h_addr_list = pvt->h_addr_ptrs;
402 pvt->host.h_length = len;
403 pvt->host.h_addrtype = af;
404 while (*cp == ' ' || *cp == '\t')
405 cp++;
406 pvt->host.h_name = cp;
407 q = pvt->host.h_aliases = pvt->host_aliases;
408 if ((cp = strpbrk(cp, " \t")) != NULL)
409 *cp++ = '\0';
410 while (cp && *cp) {
411 if (*cp == ' ' || *cp == '\t') {
412 cp++;
413 continue;
414 }
415 if (q < &pvt->host_aliases[MAXALIASES - 1])
416 *q++ = cp;
417 if ((cp = strpbrk(cp, " \t")) != NULL)
418 *cp++ = '\0';
419 }
420 *q = NULL;
421 if (dbuf)
422 free(dbuf);
423 RES_SET_H_ERRNO(pvt->res, NETDB_SUCCESS);
424 return (&pvt->host);
425 }
426
427 static void
ho_rewind(struct irs_ho * this)428 ho_rewind(struct irs_ho *this) {
429 struct pvt *pvt = (struct pvt *)this->private;
430
431 if (pvt->fp) {
432 if (fseek(pvt->fp, 0L, SEEK_SET) == 0)
433 return;
434 (void)fclose(pvt->fp);
435 }
436 if (!(pvt->fp = fopen(_PATH_HOSTS, "r")))
437 return;
438 if (fcntl(fileno(pvt->fp), F_SETFD, 1) < 0) {
439 (void)fclose(pvt->fp);
440 pvt->fp = NULL;
441 }
442 }
443
444 static void
ho_minimize(struct irs_ho * this)445 ho_minimize(struct irs_ho *this) {
446 struct pvt *pvt = (struct pvt *)this->private;
447
448 if (pvt->fp != NULL) {
449 (void)fclose(pvt->fp);
450 pvt->fp = NULL;
451 }
452 if (pvt->res)
453 res_nclose(pvt->res);
454 }
455
456 static struct __res_state *
ho_res_get(struct irs_ho * this)457 ho_res_get(struct irs_ho *this) {
458 struct pvt *pvt = (struct pvt *)this->private;
459
460 if (!pvt->res) {
461 struct __res_state *res;
462 res = (struct __res_state *)malloc(sizeof *res);
463 if (!res) {
464 errno = ENOMEM;
465 return (NULL);
466 }
467 memset(res, 0, sizeof *res);
468 ho_res_set(this, res, free);
469 }
470
471 return (pvt->res);
472 }
473
474 static void
ho_res_set(struct irs_ho * this,struct __res_state * res,void (* free_res)(void *))475 ho_res_set(struct irs_ho *this, struct __res_state *res,
476 void (*free_res)(void *)) {
477 struct pvt *pvt = (struct pvt *)this->private;
478
479 if (pvt->res && pvt->free_res) {
480 res_nclose(pvt->res);
481 (*pvt->free_res)(pvt->res);
482 }
483
484 pvt->res = res;
485 pvt->free_res = free_res;
486 }
487
488 struct lcl_res_target {
489 struct lcl_res_target *next;
490 int family;
491 };
492
493 /* XXX */
494 extern struct addrinfo *hostent2addrinfo __P((struct hostent *,
495 const struct addrinfo *pai));
496
497 static struct addrinfo *
ho_addrinfo(struct irs_ho * this,const char * name,const struct addrinfo * pai)498 ho_addrinfo(struct irs_ho *this, const char *name, const struct addrinfo *pai)
499 {
500 struct pvt *pvt = (struct pvt *)this->private;
501 struct hostent *hp;
502 struct lcl_res_target q, q2, *p;
503 struct addrinfo sentinel, *cur;
504
505 memset(&q, 0, sizeof(q2));
506 memset(&q2, 0, sizeof(q2));
507 memset(&sentinel, 0, sizeof(sentinel));
508 cur = &sentinel;
509
510 switch(pai->ai_family) {
511 case AF_UNSPEC: /*%< INET6 then INET4 */
512 q.family = AF_INET6;
513 q.next = &q2;
514 q2.family = AF_INET;
515 break;
516 case AF_INET6:
517 q.family = AF_INET6;
518 break;
519 case AF_INET:
520 q.family = AF_INET;
521 break;
522 default:
523 RES_SET_H_ERRNO(pvt->res, NO_RECOVERY); /*%< ??? */
524 return(NULL);
525 }
526
527 for (p = &q; p; p = p->next) {
528 struct addrinfo *ai;
529
530 hp = (*this->byname2)(this, name, p->family);
531 if (hp == NULL) {
532 /* byname2 should've set an appropriate error */
533 continue;
534 }
535 if ((hp->h_name == NULL) || (hp->h_name[0] == 0) ||
536 (hp->h_addr_list[0] == NULL)) {
537 RES_SET_H_ERRNO(pvt->res, NO_RECOVERY);
538 continue;
539 }
540
541 ai = hostent2addrinfo(hp, pai);
542 if (ai) {
543 cur->ai_next = ai;
544 while (cur->ai_next)
545 cur = cur->ai_next;
546 }
547 }
548
549 if (sentinel.ai_next == NULL)
550 RES_SET_H_ERRNO(pvt->res, HOST_NOT_FOUND);
551
552 return(sentinel.ai_next);
553 }
554
555 /* Private. */
556
557 static size_t
ns_namelen(const char * s)558 ns_namelen(const char *s) {
559 int i;
560
561 for (i = strlen(s); i > 0 && s[i-1] == '.'; i--)
562 (void)NULL;
563 return ((size_t) i);
564 }
565
566 static int
init(struct irs_ho * this)567 init(struct irs_ho *this) {
568 struct pvt *pvt = (struct pvt *)this->private;
569
570 if (!pvt->res && !ho_res_get(this))
571 return (-1);
572 if (((pvt->res->options & RES_INIT) == 0U) &&
573 res_ninit(pvt->res) == -1)
574 return (-1);
575 return (0);
576 }
577
578 /*! \file */
579