1 /* $NetBSD: hesiod.c,v 1.9 1999/02/11 06:16:38 simonb Exp $ */
3 /* Copyright (c) 1996 by Internet Software Consortium.
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.
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
19 /* Copyright 1996 by the Massachusetts Institute of Technology.
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.
34 /* This file is part of the hesiod library. It implements the core
35 * portion of the hesiod resolver.
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
42 * This implementation is not truly thread-safe at the moment because
43 * it uses res_send() and accesses _res.
46 #include <sys/cdefs.h>
49 static char *orig_rcsid = "$NetBSD: hesiod.c,v 1.9 1999/02/11 06:16:38 simonb Exp $";
51 #include <sys/cdefs.h>
52 __FBSDID("$FreeBSD$");
54 #include <sys/types.h>
55 #include <sys/param.h>
56 #include <netinet/in.h>
57 #include <arpa/nameser.h>
69 char *lhs; /* normally ".ns" */
70 char *rhs; /* AKA the default hesiod domain */
71 int classes[2]; /* The class search order. */
74 #define MAX_HESRESP 1024
76 static int read_config_file(struct hesiod_p *, const char *);
77 static char **get_txt_records(int, const char *);
78 static int init_context(void);
79 static void translate_errors(void);
84 * initialize a hesiod_p.
91 const char *p, *configname;
93 ctx = malloc(sizeof(struct hesiod_p));
97 configname = getenv("HESIOD_CONFIG");
101 configname = _PATH_HESIOD_CONF;
102 if (read_config_file(ctx, configname) >= 0) {
104 * The default rhs can be overridden by an
105 * environment variable.
108 p = getenv("HES_DOMAIN");
114 ctx->rhs = malloc(strlen(p) + 2);
118 (*p == '.') ? p + 1 : p);
139 * Deallocates the hesiod_p.
145 struct hesiod_p *ctx = (struct hesiod_p *) context;
155 * takes a hesiod (name, type) and returns a DNS
156 * name which is to be resolved.
159 hesiod_to_bind(void *context, const char *name, const char *type)
161 struct hesiod_p *ctx = (struct hesiod_p *) context;
162 char bindname[MAXDNAME], *p, *ret, **rhs_list = NULL;
166 if (strlcpy(bindname, name, sizeof(bindname)) >= sizeof(bindname)) {
172 * Find the right right hand side to use, possibly
173 * truncating bindname.
175 p = strchr(bindname, '@');
179 rhs = name + (p - bindname);
181 rhs_list = hesiod_resolve(context, p, "rhs-extension");
192 /* See if we have enough room. */
193 len = strlen(bindname) + 1 + strlen(type);
195 len += strlen(ctx->lhs) + ((ctx->lhs[0] != '.') ? 1 : 0);
196 len += strlen(rhs) + ((rhs[0] != '.') ? 1 : 0);
197 if (len > sizeof(bindname) - 1) {
199 hesiod_free_list(context, rhs_list);
203 /* Put together the rest of the domain. */
204 strcat(bindname, ".");
205 strcat(bindname, type);
206 /* Only append lhs if it isn't empty. */
207 if (ctx->lhs && ctx->lhs[0] != '\0' ) {
208 if (ctx->lhs[0] != '.')
209 strcat(bindname, ".");
210 strcat(bindname, ctx->lhs);
213 strcat(bindname, ".");
214 strcat(bindname, rhs);
216 /* rhs_list is no longer needed, since we're done with rhs. */
218 hesiod_free_list(context, rhs_list);
220 /* Make a copy of the result and return it to the caller. */
221 ret = strdup(bindname);
229 * Given a hesiod name and type, return an array of strings returned
233 hesiod_resolve(context, name, type)
238 struct hesiod_p *ctx = (struct hesiod_p *) context;
239 char *bindname, **retvec;
241 bindname = hesiod_to_bind(context, name, type);
245 retvec = get_txt_records(ctx->classes[0], bindname);
246 if (retvec == NULL && errno == ENOENT && ctx->classes[1])
247 retvec = get_txt_records(ctx->classes[1], bindname);
255 hesiod_free_list(context, list)
263 for (p = list; *p; p++)
269 /* read_config_file --
270 * Parse the /etc/hesiod.conf file. Returns 0 on success,
271 * -1 on failure. On failure, it might leave values in ctx->lhs
272 * or ctx->rhs which need to be freed by the caller.
275 read_config_file(ctx, filename)
276 struct hesiod_p *ctx;
277 const char *filename;
279 char *key, *data, *p, **which;
280 char buf[MAXDNAME + 7];
284 /* Set default query classes. */
285 ctx->classes[0] = C_IN;
286 ctx->classes[1] = C_HS;
288 /* Try to open the configuration file. */
289 fp = fopen(filename, "r");
291 /* Use compiled in default domain names. */
292 ctx->lhs = strdup(DEF_LHS);
293 ctx->rhs = strdup(DEF_RHS);
294 if (ctx->lhs && ctx->rhs)
303 while (fgets(buf, sizeof(buf), fp) != NULL) {
305 if (*p == '#' || *p == '\n' || *p == '\r')
307 while (*p == ' ' || *p == '\t')
310 while (*p != ' ' && *p != '\t' && *p != '=')
314 while (isspace(*p) || *p == '=')
321 if (strcasecmp(key, "lhs") == 0 ||
322 strcasecmp(key, "rhs") == 0) {
323 which = (strcasecmp(key, "lhs") == 0)
324 ? &ctx->lhs : &ctx->rhs;
325 *which = strdup(data);
331 if (strcasecmp(key, "classes") == 0) {
333 while (*data && n < 2) {
335 while (*p && *p != ',')
339 if (strcasecmp(data, "IN") == 0)
340 ctx->classes[n++] = C_IN;
342 if (strcasecmp(data, "HS") == 0)
348 ctx->classes[n++] = 0;
354 if (!ctx->rhs || ctx->classes[0] == 0 ||
355 ctx->classes[0] == ctx->classes[1]) {
364 * Given a DNS class and a DNS name, do a lookup for TXT records, and
365 * return a list of them.
368 get_txt_records(qclass, name)
373 unsigned char qbuf[PACKETSZ], abuf[MAX_HESRESP], *p, *eom, *eor;
375 int ancount, qdcount, i, j, n, skip, type, class, len;
377 /* Make sure the resolver is initialized. */
378 if ((_res.options & RES_INIT) == 0 && res_init() == -1)
381 /* Construct the query. */
382 n = res_mkquery(QUERY, name, qclass, T_TXT, NULL, 0,
383 NULL, qbuf, PACKETSZ);
387 /* Send the query. */
388 n = res_send(qbuf, n, abuf, MAX_HESRESP);
389 if (n < 0 || n > MAX_HESRESP) {
390 errno = ECONNREFUSED; /* XXX */
393 /* Parse the header of the result. */
394 hp = (HEADER *) (void *) abuf;
395 ancount = ntohs(hp->ancount);
396 qdcount = ntohs(hp->qdcount);
397 p = abuf + sizeof(HEADER);
401 * Skip questions, trying to get to the answer section
404 for (i = 0; i < qdcount; i++) {
405 skip = dn_skipname(p, eom);
406 if (skip < 0 || p + skip + QFIXEDSZ > eom) {
410 p += skip + QFIXEDSZ;
413 /* Allocate space for the text record answers. */
414 list = malloc((ancount + 1) * sizeof(char *));
419 /* Parse the answers. */
421 for (i = 0; i < ancount; i++) {
422 /* Parse the header of this answer. */
423 skip = dn_skipname(p, eom);
424 if (skip < 0 || p + skip + 10 > eom)
426 type = p[skip + 0] << 8 | p[skip + 1];
427 class = p[skip + 2] << 8 | p[skip + 3];
428 len = p[skip + 8] << 8 | p[skip + 9];
434 /* Skip entries of the wrong class and type. */
435 if (class != qclass || type != T_TXT) {
439 /* Allocate space for this answer. */
440 list[j] = malloc((size_t)len);
447 /* Copy answer data into the allocated area. */
450 n = (unsigned char) *p++;
455 memcpy(dst, p, (size_t)n);
467 * If we didn't terminate the loop normally, something
471 for (i = 0; i < j; i++)
486 * COMPATIBILITY FUNCTIONS
489 static int inited = 0;
490 static void *context;
491 static int errval = HES_ER_UNINIT;
501 hes_to_bind(name, type)
505 static char *bindname;
506 if (init_context() < 0)
510 bindname = hesiod_to_bind(context, name, type);
517 hes_resolve(name, type)
523 if (init_context() < 0)
527 * In the old Hesiod interface, the caller was responsible for
528 * freeing the returned strings but not the vector of strings itself.
533 list = hesiod_resolve(context, name, type);
549 hesiod_free_list(context, hp);
557 if (hesiod_init(&context) < 0) {
558 errval = HES_ER_CONFIG;
571 errval = HES_ER_NOTFOUND;
579 /* Not a good match, but the best we can do. */
580 errval = HES_ER_CONFIG;