Home | History | Annotate | Line # | Download | only in net
hesiod.c revision 1.18 
      1 /*	$NetBSD: hesiod.c,v 1.18 2002/08/16 11:48:25 itojun Exp $	*/
      2 
      3 /* Copyright (c) 1996 by Internet Software Consortium.
      4  *
      5  * Permission to use, copy, modify, and distribute this software for any
      6  * purpose with or without fee is hereby granted, provided that the above
      7  * copyright notice and this permission notice appear in all copies.
      8  *
      9  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
     10  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
     11  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
     12  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
     13  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
     14  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
     15  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
     16  * SOFTWARE.
     17  */
     18 
     19 /* Copyright 1996 by the Massachusetts Institute of Technology.
     20  *
     21  * Permission to use, copy, modify, and distribute this
     22  * software and its documentation for any purpose and without
     23  * fee is hereby granted, provided that the above copyright
     24  * notice appear in all copies and that both that copyright
     25  * notice and this permission notice appear in supporting
     26  * documentation, and that the name of M.I.T. not be used in
     27  * advertising or publicity pertaining to distribution of the
     28  * software without specific, written prior permission.
     29  * M.I.T. makes no representations about the suitability of
     30  * this software for any purpose.  It is provided "as is"
     31  * without express or implied warranty.
     32  */
     33 
     34 /* This file is part of the hesiod library.  It implements the core
     35  * portion of the hesiod resolver.
     36  *
     37  * This file is loosely based on an interim version of hesiod.c from
     38  * the BIND IRS library, which was in turn based on an earlier version
     39  * of this file.  Extensive changes have been made on each step of the
     40  * path.
     41  *
     42  * This implementation is not truly thread-safe at the moment because
     43  * it uses res_send() and accesses _res.
     44  */
     45 
     46 #include <sys/cdefs.h>
     47 
     48 #if defined(LIBC_SCCS) && !defined(lint)
     49 __IDSTRING(rcsid_hesiod_c,
     50     "#Id: hesiod.c,v 1.18.2.1 1997/01/03 20:48:20 ghudson Exp #");
     51 __IDSTRING(rcsid_hesiod_p_h,
     52     "#Id: hesiod_p.h,v 1.1 1996/12/08 21:39:37 ghudson Exp #");
     53 __IDSTRING(rcsid_hescompat_c,
     54     "#Id: hescompat.c,v 1.1.2.1 1996/12/16 08:37:45 ghudson Exp #");
     55 __RCSID("$NetBSD: hesiod.c,v 1.18 2002/08/16 11:48:25 itojun Exp $");
     56 #endif /* LIBC_SCCS and not lint */
     57 
     58 #include "namespace.h"
     59 
     60 #include <sys/types.h>
     61 #include <sys/param.h>
     62 #include <netinet/in.h>
     63 #include <arpa/nameser.h>
     64 
     65 #include <assert.h>
     66 #include <ctype.h>
     67 #include <errno.h>
     68 #include <hesiod.h>
     69 #include <resolv.h>
     70 #include <stdio.h>
     71 #include <stdlib.h>
     72 #include <string.h>
     73 #include <unistd.h>
     74 
     75 #ifdef __weak_alias
     76 __weak_alias(hesiod_init,_hesiod_init)
     77 __weak_alias(hesiod_end,_hesiod_end)
     78 __weak_alias(hesiod_to_bind,_hesiod_to_bind)
     79 __weak_alias(hesiod_resolve,_hesiod_resolve)
     80 __weak_alias(hesiod_free_list,_hesiod_free_list)
     81 __weak_alias(hes_init,_hes_init)
     82 __weak_alias(hes_to_bind,_hes_to_bind)
     83 __weak_alias(hes_resolve,_hes_resolve)
     84 __weak_alias(hes_error,_hes_error)
     85 __weak_alias(hes_free,_hes_free)
     86 #endif
     87 
     88 struct hesiod_p {
     89 	char	*lhs;			/* normally ".ns" */
     90 	char	*rhs;			/* AKA the default hesiod domain */
     91 	int	 classes[2];		/* The class search order. */
     92 };
     93 
     94 #define	MAX_HESRESP	1024
     95 
     96 static int	  read_config_file __P((struct hesiod_p *, const char *));
     97 static char	**get_txt_records __P((int, const char *));
     98 static int	  init_context __P((void));
     99 static void	  translate_errors __P((void));
    100 
    101 
    102 /*
    103  * hesiod_init --
    104  *	initialize a hesiod_p.
    105  */
    106 int
    107 hesiod_init(context)
    108 	void	**context;
    109 {
    110 	struct hesiod_p	*ctx;
    111 	const char	*p, *configname;
    112 	int serrno;
    113 
    114 	_DIAGASSERT(context != NULL);
    115 
    116 	ctx = malloc(sizeof(struct hesiod_p));
    117 	if (ctx) {
    118 		*context = ctx;
    119 		/*
    120 		 * don't permit overrides from environment
    121 		 * for set.id programs
    122 		 */
    123 		if (issetugid())
    124 			configname = NULL;
    125 		else
    126 			configname = getenv("HESIOD_CONFIG");
    127 		if (!configname)
    128 			configname = _PATH_HESIOD_CONF;
    129 		if (read_config_file(ctx, configname) >= 0) {
    130 			/*
    131 			 * The default rhs can be overridden by an
    132 			 * environment variable, unless set.id.
    133 			 */
    134 			if (issetugid())
    135 				p = NULL;
    136 			else
    137 				p = getenv("HES_DOMAIN");
    138 			if (p) {
    139 				if (ctx->rhs)
    140 					free(ctx->rhs);
    141 				ctx->rhs = malloc(strlen(p) + 2);
    142 				if (ctx->rhs) {
    143 					*ctx->rhs = '.';
    144 					strcpy(ctx->rhs + 1,
    145 					    (*p == '.') ? p + 1 : p);
    146 					return 0;
    147 				} else
    148 					errno = ENOMEM;
    149 			} else
    150 				return 0;
    151 		}
    152 	} else
    153 		errno = ENOMEM;
    154 
    155 	serrno = errno;
    156 	if (ctx->lhs)
    157 		free(ctx->lhs);
    158 	if (ctx->rhs)
    159 		free(ctx->rhs);
    160 	if (ctx)
    161 		free(ctx);
    162 	errno = serrno;
    163 	return -1;
    164 }
    165 
    166 /*
    167  * hesiod_end --
    168  *	Deallocates the hesiod_p.
    169  */
    170 void
    171 hesiod_end(context)
    172 	void	*context;
    173 {
    174 	struct hesiod_p *ctx = (struct hesiod_p *) context;
    175 
    176 	_DIAGASSERT(context != NULL);
    177 
    178 	free(ctx->rhs);
    179 	if (ctx->lhs)
    180 		free(ctx->lhs);
    181 	free(ctx);
    182 }
    183 
    184 /*
    185  * hesiod_to_bind --
    186  * 	takes a hesiod (name, type) and returns a DNS
    187  *	name which is to be resolved.
    188  */
    189 char *
    190 hesiod_to_bind(void *context, const char *name, const char *type)
    191 {
    192 	struct hesiod_p *ctx = (struct hesiod_p *) context;
    193 	char		 bindname[MAXDNAME], *p, *ret, **rhs_list = NULL;
    194 	const char	*rhs;
    195 	int		 len;
    196 
    197 	_DIAGASSERT(context != NULL);
    198 	_DIAGASSERT(name != NULL);
    199 	_DIAGASSERT(type != NULL);
    200 
    201         if (strlcpy(bindname, name, sizeof(bindname)) >= sizeof(bindname)) {
    202                 errno = EMSGSIZE;
    203                 return NULL;
    204         }
    205 
    206 	/*
    207 	 * Find the right right hand side to use, possibly
    208 	 * truncating bindname.
    209 	 */
    210 	p = strchr(bindname, '@');
    211 	if (p) {
    212 		*p++ = 0;
    213 		if (strchr(p, '.'))
    214 			rhs = name + (p - bindname);
    215 		else {
    216 			rhs_list = hesiod_resolve(context, p, "rhs-extension");
    217 			if (rhs_list)
    218 				rhs = *rhs_list;
    219 			else {
    220 				errno = ENOENT;
    221 				return NULL;
    222 			}
    223 		}
    224 	} else
    225 		rhs = ctx->rhs;
    226 
    227 	/* See if we have enough room. */
    228 	len = strlen(bindname) + 1 + strlen(type);
    229 	if (ctx->lhs)
    230 		len += strlen(ctx->lhs) + ((ctx->lhs[0] != '.') ? 1 : 0);
    231 	len += strlen(rhs) + ((rhs[0] != '.') ? 1 : 0);
    232 	if (len > sizeof(bindname) - 1) {
    233 		if (rhs_list)
    234 			hesiod_free_list(context, rhs_list);
    235 		errno = EMSGSIZE;
    236 		return NULL;
    237 	}
    238 	/* Put together the rest of the domain. */
    239 	strcat(bindname, ".");
    240 	strcat(bindname, type);
    241 	/* Only append lhs if it isn't empty. */
    242 	if (ctx->lhs && ctx->lhs[0] != '\0' ) {
    243 		if (ctx->lhs[0] != '.')
    244 			strcat(bindname, ".");
    245 		strcat(bindname, ctx->lhs);
    246 	}
    247 	if (rhs[0] != '.')
    248 		strcat(bindname, ".");
    249 	strcat(bindname, rhs);
    250 
    251 	/* rhs_list is no longer needed, since we're done with rhs. */
    252 	if (rhs_list)
    253 		hesiod_free_list(context, rhs_list);
    254 
    255 	/* Make a copy of the result and return it to the caller. */
    256 	ret = strdup(bindname);
    257 	if (ret == NULL)
    258 		errno = ENOMEM;
    259 	return ret;
    260 }
    261 
    262 /*
    263  * hesiod_resolve --
    264  *	Given a hesiod name and type, return an array of strings returned
    265  *	by the resolver.
    266  */
    267 char **
    268 hesiod_resolve(context, name, type)
    269 	void		*context;
    270 	const char	*name;
    271 	const char	*type;
    272 {
    273 	struct hesiod_p	*ctx = (struct hesiod_p *) context;
    274 	char		*bindname, **retvec;
    275 
    276 	_DIAGASSERT(context != NULL);
    277 	_DIAGASSERT(name != NULL);
    278 	_DIAGASSERT(type != NULL);
    279 
    280 	bindname = hesiod_to_bind(context, name, type);
    281 	if (!bindname)
    282 		return NULL;
    283 
    284 	retvec = get_txt_records(ctx->classes[0], bindname);
    285 	if (retvec == NULL && errno == ENOENT && ctx->classes[1])
    286 		retvec = get_txt_records(ctx->classes[1], bindname);
    287 
    288 	free(bindname);
    289 	return retvec;
    290 }
    291 
    292 /*ARGSUSED*/
    293 void
    294 hesiod_free_list(context, list)
    295 	void	 *context;
    296 	char	**list;
    297 {
    298 	char  **p;
    299 
    300 	_DIAGASSERT(context != NULL);
    301 
    302 	if (list == NULL)
    303 		return;
    304 	for (p = list; *p; p++)
    305 		free(*p);
    306 	free(list);
    307 }
    308 
    309 
    310 /* read_config_file --
    311  *	Parse the /etc/hesiod.conf file.  Returns 0 on success,
    312  *	-1 on failure.  On failure, it might leave values in ctx->lhs
    313  *	or ctx->rhs which need to be freed by the caller.
    314  */
    315 static int
    316 read_config_file(ctx, filename)
    317 	struct hesiod_p	*ctx;
    318 	const char	*filename;
    319 {
    320 	char	*key, *data, *p, **which;
    321 	char	 buf[MAXDNAME + 7];
    322 	int	 n;
    323 	FILE	*fp;
    324 
    325 	_DIAGASSERT(ctx != NULL);
    326 	_DIAGASSERT(filename != NULL);
    327 
    328 	/* Set default query classes. */
    329 	ctx->classes[0] = C_IN;
    330 	ctx->classes[1] = C_HS;
    331 
    332 	/* Try to open the configuration file. */
    333 	fp = fopen(filename, "r");
    334 	if (!fp) {
    335 		/* Use compiled in default domain names. */
    336 		ctx->lhs = strdup(DEF_LHS);
    337 		ctx->rhs = strdup(DEF_RHS);
    338 		if (ctx->lhs && ctx->rhs)
    339 			return 0;
    340 		else {
    341 			errno = ENOMEM;
    342 			return -1;
    343 		}
    344 	}
    345 	ctx->lhs = NULL;
    346 	ctx->rhs = NULL;
    347 	while (fgets(buf, sizeof(buf), fp) != NULL) {
    348 		p = buf;
    349 		if (*p == '#' || *p == '\n' || *p == '\r')
    350 			continue;
    351 		while (*p == ' ' || *p == '\t')
    352 			p++;
    353 		key = p;
    354 		while (*p != ' ' && *p != '\t' && *p != '=' && *p)
    355 			p++;
    356 
    357 		if (*p == '\0')
    358 			continue;
    359 
    360 		*p++ = 0;
    361 
    362 		while (isspace((u_char) *p) || *p == '=')
    363 			p++;
    364 
    365 		if (*p == '\0')
    366 			continue;
    367 
    368 		data = p;
    369 		while (!isspace((u_char) *p) && *p)
    370 			p++;
    371 
    372 		*p = 0;
    373 
    374 		if (strcasecmp(key, "lhs") == 0 ||
    375 		    strcasecmp(key, "rhs") == 0) {
    376 			which = (strcasecmp(key, "lhs") == 0)
    377 			    ? &ctx->lhs : &ctx->rhs;
    378 			*which = strdup(data);
    379 			if (!*which) {
    380 				errno = ENOMEM;
    381 				return -1;
    382 			}
    383 		} else {
    384 			if (strcasecmp(key, "classes") == 0) {
    385 				n = 0;
    386 				while (*data && n < 2) {
    387 					p = data;
    388 					while (*p && *p != ',')
    389 						p++;
    390 					if (*p)
    391 						*p++ = 0;
    392 					if (strcasecmp(data, "IN") == 0)
    393 						ctx->classes[n++] = C_IN;
    394 					else
    395 						if (strcasecmp(data, "HS") == 0)
    396 							ctx->classes[n++] =
    397 							    C_HS;
    398 					data = p;
    399 				}
    400 				while (n < 2)
    401 					ctx->classes[n++] = 0;
    402 			}
    403 		}
    404 	}
    405 	fclose(fp);
    406 
    407 	if (!ctx->rhs || ctx->classes[0] == 0 ||
    408 	    ctx->classes[0] == ctx->classes[1]) {
    409 		errno = ENOEXEC;
    410 		return -1;
    411 	}
    412 	return 0;
    413 }
    414 
    415 /*
    416  * get_txt_records --
    417  *	Given a DNS class and a DNS name, do a lookup for TXT records, and
    418  *	return a list of them.
    419  */
    420 static char **
    421 get_txt_records(qclass, name)
    422 	int		 qclass;
    423 	const char	*name;
    424 {
    425 	HEADER		*hp;
    426 	unsigned char	 qbuf[PACKETSZ], abuf[MAX_HESRESP], *p, *eom, *eor;
    427 	char		*dst, **list;
    428 	int		 ancount, qdcount, i, j, n, skip, type, class, len;
    429 
    430 	_DIAGASSERT(name != NULL);
    431 
    432 	/* Make sure the resolver is initialized. */
    433 	if ((_res.options & RES_INIT) == 0 && res_init() == -1)
    434 		return NULL;
    435 
    436 	/* Construct the query. */
    437 	n = res_mkquery(QUERY, name, qclass, T_TXT, NULL, 0,
    438 	    NULL, qbuf, PACKETSZ);
    439 	if (n < 0) {
    440 		errno = EMSGSIZE;
    441 		return NULL;
    442 	}
    443 
    444 	/* Send the query. */
    445 	n = res_send(qbuf, n, abuf, MAX_HESRESP);
    446 	if (n < 0) {
    447 		errno = ECONNREFUSED;
    448 		return NULL;
    449 	}
    450 	/* Parse the header of the result. */
    451 	hp = (HEADER *) (void *) abuf;
    452 	ancount = ntohs(hp->ancount);
    453 	qdcount = ntohs(hp->qdcount);
    454 	p = abuf + sizeof(HEADER);
    455 	eom = abuf + n;
    456 
    457 	/*
    458 	 * Skip questions, trying to get to the answer section
    459 	 * which follows.
    460 	 */
    461 	for (i = 0; i < qdcount; i++) {
    462 		skip = dn_skipname(p, eom);
    463 		if (skip < 0 || p + skip + QFIXEDSZ > eom) {
    464 			errno = EMSGSIZE;
    465 			return NULL;
    466 		}
    467 		p += skip + QFIXEDSZ;
    468 	}
    469 
    470 	/* Allocate space for the text record answers. */
    471 	list = malloc((ancount + 1) * sizeof(char *));
    472 	if (!list) {
    473 		errno = ENOMEM;
    474 		return NULL;
    475 	}
    476 	/* Parse the answers. */
    477 	j = 0;
    478 	for (i = 0; i < ancount; i++) {
    479 		/* Parse the header of this answer. */
    480 		skip = dn_skipname(p, eom);
    481 		if (skip < 0 || p + skip + 10 > eom)
    482 			break;
    483 		type = p[skip + 0] << 8 | p[skip + 1];
    484 		class = p[skip + 2] << 8 | p[skip + 3];
    485 		len = p[skip + 8] << 8 | p[skip + 9];
    486 		p += skip + 10;
    487 		if (p + len > eom) {
    488 			errno = EMSGSIZE;
    489 			break;
    490 		}
    491 		/* Skip entries of the wrong class and type. */
    492 		if (class != qclass || type != T_TXT) {
    493 			p += len;
    494 			continue;
    495 		}
    496 		/* Allocate space for this answer. */
    497 		list[j] = malloc((size_t)len);
    498 		if (!list[j]) {
    499 			errno = ENOMEM;
    500 			break;
    501 		}
    502 		dst = list[j++];
    503 
    504 		/* Copy answer data into the allocated area. */
    505 		eor = p + len;
    506 		while (p < eor) {
    507 			n = (unsigned char) *p++;
    508 			if (p + n > eor) {
    509 				errno = EMSGSIZE;
    510 				break;
    511 			}
    512 			memcpy(dst, p, (size_t)n);
    513 			p += n;
    514 			dst += n;
    515 		}
    516 		if (p < eor) {
    517 			errno = EMSGSIZE;
    518 			break;
    519 		}
    520 		*dst = 0;
    521 	}
    522 
    523 	/*
    524 	 * If we didn't terminate the loop normally, something
    525 	 * went wrong.
    526 	 */
    527 	if (i < ancount) {
    528 		for (i = 0; i < j; i++)
    529 			free(list[i]);
    530 		free(list);
    531 		return NULL;
    532 	}
    533 	if (j == 0) {
    534 		errno = ENOENT;
    535 		free(list);
    536 		return NULL;
    537 	}
    538 	list[j] = NULL;
    539 	return list;
    540 }
    541 
    542 /*
    543  * COMPATIBILITY FUNCTIONS
    544  */
    545 
    546 static int	  inited = 0;
    547 static void	 *context;
    548 static int	  errval = HES_ER_UNINIT;
    549 
    550 int
    551 hes_init()
    552 {
    553 	init_context();
    554 	return errval;
    555 }
    556 
    557 char *
    558 hes_to_bind(name, type)
    559 	const char	*name;
    560 	const char	*type;
    561 {
    562 	static	char	*bindname;
    563 
    564 	_DIAGASSERT(name != NULL);
    565 	_DIAGASSERT(type != NULL);
    566 
    567 	if (init_context() < 0)
    568 		return NULL;
    569 	if (bindname)
    570 		free(bindname);
    571 	bindname = hesiod_to_bind(context, name, type);
    572 	if (!bindname)
    573 		translate_errors();
    574 	return bindname;
    575 }
    576 
    577 char **
    578 hes_resolve(name, type)
    579 	const char	*name;
    580 	const char	*type;
    581 {
    582 	static char	**list;
    583 
    584 	_DIAGASSERT(name != NULL);
    585 	_DIAGASSERT(type != NULL);
    586 
    587 	if (init_context() < 0)
    588 		return NULL;
    589 
    590 	/*
    591 	 * In the old Hesiod interface, the caller was responsible for
    592 	 * freeing the returned strings but not the vector of strings itself.
    593 	 */
    594 	if (list)
    595 		free(list);
    596 
    597 	list = hesiod_resolve(context, name, type);
    598 	if (!list)
    599 		translate_errors();
    600 	return list;
    601 }
    602 
    603 int
    604 hes_error()
    605 {
    606 	return errval;
    607 }
    608 
    609 void
    610 hes_free(hp)
    611 	char **hp;
    612 {
    613 	hesiod_free_list(context, hp);
    614 }
    615 
    616 static int
    617 init_context()
    618 {
    619 	if (!inited) {
    620 		inited = 1;
    621 		if (hesiod_init(&context) < 0) {
    622 			errval = HES_ER_CONFIG;
    623 			return -1;
    624 		}
    625 		errval = HES_ER_OK;
    626 	}
    627 	return 0;
    628 }
    629 
    630 static void
    631 translate_errors()
    632 {
    633 	switch (errno) {
    634 	case ENOENT:
    635 		errval = HES_ER_NOTFOUND;
    636 		break;
    637 	case ECONNREFUSED:
    638 	case EMSGSIZE:
    639 		errval = HES_ER_NET;
    640 		break;
    641 	case EFAULT:
    642 	case ENOMEM:
    643 	default:
    644 		/* Not a good match, but the best we can do. */
    645 		errval = HES_ER_CONFIG;
    646 		break;
    647 	}
    648 }
    649