xref: /illumos-gate/usr/src/lib/libresolv2/common/irs/hesiod.c (revision 55fea89dcaa64928bed4327112404dcb3e07b79f)
1 /*
2  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
3  * Copyright (c) 1996,1999 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 ISC DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 
19 /*! \file
20  * \brief
21  * hesiod.c --- the core portion of the hesiod resolver.
22  *
23  * This file is derived from the hesiod library from Project Athena;
24  * It has been extensively rewritten by Theodore Ts'o to have a more
25  * thread-safe interface.
26  * \author
27  * This file is primarily maintained by <tytso@mit.edu> and <ghudson@mit.edu>.
28  */
29 
30 /* Imports */
31 
32 #include "port_before.h"
33 
34 #include <sys/types.h>
35 #include <netinet/in.h>
36 #include <arpa/nameser.h>
37 
38 #include <errno.h>
39 #include <netdb.h>
40 #include <resolv.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 
45 #include "port_after.h"
46 
47 #include "pathnames.h"
48 #include "hesiod.h"
49 #include "hesiod_p.h"
50 
51 /* Forward */
52 
53 int		hesiod_init(void **context);
54 void		hesiod_end(void *context);
55 char *		hesiod_to_bind(void *context, const char *name,
56 			       const char *type);
57 char **		hesiod_resolve(void *context, const char *name,
58 			       const char *type);
59 void		hesiod_free_list(void *context, char **list);
60 
61 static int	parse_config_file(struct hesiod_p *ctx, const char *filename);
62 static char **	get_txt_records(struct hesiod_p *ctx, int class,
63 				const char *name);
64 static int	init(struct hesiod_p *ctx);
65 
66 /* Public */
67 
68 /*%
69  * This function is called to initialize a hesiod_p.
70  */
71 int
hesiod_init(void ** context)72 hesiod_init(void **context) {
73 	struct hesiod_p *ctx;
74 	char *cp;
75 
76 	ctx = malloc(sizeof(struct hesiod_p));
77 	if (ctx == 0) {
78 		errno = ENOMEM;
79 		return (-1);
80 	}
81 
82 	memset(ctx, 0, sizeof (*ctx));
83 
84 	if (parse_config_file(ctx, _PATH_HESIOD_CONF) < 0) {
85 #ifdef DEF_RHS
86 		/*
87 		 * Use compiled in defaults.
88 		 */
89 		ctx->LHS = malloc(strlen(DEF_LHS) + 1);
90 		ctx->RHS = malloc(strlen(DEF_RHS) + 1);
91 		if (ctx->LHS == NULL || ctx->RHS == NULL) {
92 			errno = ENOMEM;
93 			goto cleanup;
94 		}
95 		strcpy(ctx->LHS, DEF_LHS);	/* (checked) */
96 		strcpy(ctx->RHS, DEF_RHS);	/* (checked) */
97 #else
98 		goto cleanup;
99 #endif
100 	}
101 	/*
102 	 * The default RHS can be overridden by an environment
103 	 * variable.
104 	 */
105 	if ((cp = getenv("HES_DOMAIN")) != NULL) {
106 		size_t RHSlen = strlen(cp) + 2;
107 		if (ctx->RHS)
108 			free(ctx->RHS);
109 		ctx->RHS = malloc(RHSlen);
110 		if (!ctx->RHS) {
111 			errno = ENOMEM;
112 			goto cleanup;
113 		}
114 		if (cp[0] == '.') {
115 			strcpy(ctx->RHS, cp);	/* (checked) */
116 		} else {
117 			strcpy(ctx->RHS, ".");	/* (checked) */
118 			strcat(ctx->RHS, cp);	/* (checked) */
119 		}
120 	}
121 
122 	/*
123 	 * If there is no default hesiod realm set, we return an
124 	 * error.
125 	 */
126 	if (!ctx->RHS) {
127 		errno = ENOEXEC;
128 		goto cleanup;
129 	}
130 
131 #if 0
132 	if (res_ninit(ctx->res) < 0)
133 		goto cleanup;
134 #endif
135 
136 	*context = ctx;
137 	return (0);
138 
139  cleanup:
140 	hesiod_end(ctx);
141 	return (-1);
142 }
143 
144 /*%
145  * This function deallocates the hesiod_p
146  */
147 void
hesiod_end(void * context)148 hesiod_end(void *context) {
149 	struct hesiod_p *ctx = (struct hesiod_p *) context;
150 	int save_errno = errno;
151 
152 	if (ctx->res)
153 		res_nclose(ctx->res);
154 	if (ctx->RHS)
155 		free(ctx->RHS);
156 	if (ctx->LHS)
157 		free(ctx->LHS);
158 	if (ctx->res && ctx->free_res)
159 		(*ctx->free_res)(ctx->res);
160 	free(ctx);
161 	errno = save_errno;
162 }
163 
164 /*%
165  * This function takes a hesiod (name, type) and returns a DNS
166  * name which is to be resolved.
167  */
168 char *
hesiod_to_bind(void * context,const char * name,const char * type)169 hesiod_to_bind(void *context, const char *name, const char *type) {
170 	struct hesiod_p *ctx = (struct hesiod_p *) context;
171 	char *bindname;
172 	char **rhs_list = NULL;
173 	const char *RHS, *cp;
174 
175 	/* Decide what our RHS is, and set cp to the end of the actual name. */
176 	if ((cp = strchr(name, '@')) != NULL) {
177 		if (strchr(cp + 1, '.'))
178 			RHS = cp + 1;
179 		else if ((rhs_list = hesiod_resolve(context, cp + 1,
180 		    "rhs-extension")) != NULL)
181 			RHS = *rhs_list;
182 		else {
183 			errno = ENOENT;
184 			return (NULL);
185 		}
186 	} else {
187 		RHS = ctx->RHS;
188 		cp = name + strlen(name);
189 	}
190 
191 	/*
192 	 * Allocate the space we need, including up to three periods and
193 	 * the terminating NUL.
194 	 */
195 	if ((bindname = malloc((cp - name) + strlen(type) + strlen(RHS) +
196 	    (ctx->LHS ? strlen(ctx->LHS) : 0) + 4)) == NULL) {
197 		errno = ENOMEM;
198 		if (rhs_list)
199 			hesiod_free_list(context, rhs_list);
200 		return NULL;
201 	}
202 
203 	/* Now put together the DNS name. */
204 	memcpy(bindname, name, cp - name);
205 	bindname[cp - name] = '\0';
206 	strcat(bindname, ".");
207 	strcat(bindname, type);
208 	if (ctx->LHS) {
209 		if (ctx->LHS[0] != '.')
210 			strcat(bindname, ".");
211 		strcat(bindname, ctx->LHS);
212 	}
213 	if (RHS[0] != '.')
214 		strcat(bindname, ".");
215 	strcat(bindname, RHS);
216 
217 	if (rhs_list)
218 		hesiod_free_list(context, rhs_list);
219 
220 	return (bindname);
221 }
222 
223 /*%
224  * This is the core function.  Given a hesiod (name, type), it
225  * returns an array of strings returned by the resolver.
226  */
227 char **
hesiod_resolve(void * context,const char * name,const char * type)228 hesiod_resolve(void *context, const char *name, const char *type) {
229 	struct hesiod_p *ctx = (struct hesiod_p *) context;
230 	char *bindname = hesiod_to_bind(context, name, type);
231 	char **retvec;
232 
233 	if (bindname == NULL)
234 		return (NULL);
235 	if (init(ctx) == -1) {
236 		free(bindname);
237 		return (NULL);
238 	}
239 
240 	if ((retvec = get_txt_records(ctx, C_IN, bindname))) {
241 		free(bindname);
242 		return (retvec);
243 	}
244 
245 	if (errno != ENOENT)
246 		return (NULL);
247 
248 	retvec = get_txt_records(ctx, C_HS, bindname);
249 	free(bindname);
250 	return (retvec);
251 }
252 
253 void
hesiod_free_list(void * context,char ** list)254 hesiod_free_list(void *context, char **list) {
255 	char **p;
256 
257 	UNUSED(context);
258 
259 	for (p = list; *p; p++)
260 		free(*p);
261 	free(list);
262 }
263 
264 /*%
265  * This function parses the /etc/hesiod.conf file
266  */
267 static int
parse_config_file(struct hesiod_p * ctx,const char * filename)268 parse_config_file(struct hesiod_p *ctx, const char *filename) {
269 	char *key, *data, *cp, **cpp;
270 	char buf[MAXDNAME+7];
271 	FILE *fp;
272 
273 	/*
274 	 * Clear the existing configuration variable, just in case
275 	 * they're set.
276 	 */
277 	if (ctx->RHS)
278 		free(ctx->RHS);
279 	if (ctx->LHS)
280 		free(ctx->LHS);
281 	ctx->RHS = ctx->LHS = 0;
282 
283 	/*
284 	 * Now open and parse the file...
285 	 */
286 	if (!(fp = fopen(filename, "r")))
287 		return (-1);
288 
289 	while (fgets(buf, sizeof(buf), fp) != NULL) {
290 		cp = buf;
291 		if (*cp == '#' || *cp == '\n' || *cp == '\r')
292 			continue;
293 		while(*cp == ' ' || *cp == '\t')
294 			cp++;
295 		key = cp;
296 		while(*cp != ' ' && *cp != '\t' && *cp != '=')
297 			cp++;
298 		*cp++ = '\0';
299 
300 		while(*cp == ' ' || *cp == '\t' || *cp == '=')
301 			cp++;
302 		data = cp;
303 		while(*cp != ' ' && *cp != '\n' && *cp != '\r')
304 			cp++;
305 		*cp++ = '\0';
306 
307 		if (strcmp(key, "lhs") == 0)
308 			cpp = &ctx->LHS;
309 		else if (strcmp(key, "rhs") == 0)
310 			cpp = &ctx->RHS;
311 		else
312 			continue;
313 
314 		*cpp = malloc(strlen(data) + 1);
315 		if (!*cpp) {
316 			errno = ENOMEM;
317 			goto cleanup;
318 		}
319 		strcpy(*cpp, data);
320 	}
321 	fclose(fp);
322 	return (0);
323 
324  cleanup:
325 	fclose(fp);
326 	if (ctx->RHS)
327 		free(ctx->RHS);
328 	if (ctx->LHS)
329 		free(ctx->LHS);
330 	ctx->RHS = ctx->LHS = 0;
331 	return (-1);
332 }
333 
334 /*%
335  * Given a DNS class and a DNS name, do a lookup for TXT records, and
336  * return a list of them.
337  */
338 static char **
get_txt_records(struct hesiod_p * ctx,int class,const char * name)339 get_txt_records(struct hesiod_p *ctx, int class, const char *name) {
340 	struct {
341 		int type;		/*%< RR type */
342 		int class;		/*%< RR class */
343 		int dlen;		/*%< len of data section */
344 		u_char *data;		/*%< pointer to data */
345 	} rr;
346 	HEADER *hp;
347 	u_char qbuf[MAX_HESRESP], abuf[MAX_HESRESP];
348 	u_char *cp, *erdata, *eom;
349 	char *dst, *edst, **list;
350 	int ancount, qdcount;
351 	int i, j, n, skip;
352 
353 	/*
354 	 * Construct the query and send it.
355 	 */
356 	n = res_nmkquery(ctx->res, QUERY, name, class, T_TXT, NULL, 0,
357 			 NULL, qbuf, MAX_HESRESP);
358 	if (n < 0) {
359 		errno = EMSGSIZE;
360 		return (NULL);
361 	}
362 	n = res_nsend(ctx->res, qbuf, n, abuf, MAX_HESRESP);
363 	if (n < 0) {
364 		errno = ECONNREFUSED;
365 		return (NULL);
366 	}
367 	if (n < HFIXEDSZ) {
368 		errno = EMSGSIZE;
369 		return (NULL);
370 	}
371 
372 	/*
373 	 * OK, parse the result.
374 	 */
375 	hp = (HEADER *) abuf;
376 	ancount = ntohs(hp->ancount);
377 	qdcount = ntohs(hp->qdcount);
378 	cp = abuf + sizeof(HEADER);
379 	eom = abuf + n;
380 
381 	/* Skip query, trying to get to the answer section which follows. */
382 	for (i = 0; i < qdcount; i++) {
383 		skip = dn_skipname(cp, eom);
384 		if (skip < 0 || cp + skip + QFIXEDSZ > eom) {
385 			errno = EMSGSIZE;
386 			return (NULL);
387 		}
388 		cp += skip + QFIXEDSZ;
389 	}
390 
391 	list = malloc((ancount + 1) * sizeof(char *));
392 	if (!list) {
393 		errno = ENOMEM;
394 		return (NULL);
395 	}
396 	j = 0;
397 	for (i = 0; i < ancount; i++) {
398 		skip = dn_skipname(cp, eom);
399 		if (skip < 0) {
400 			errno = EMSGSIZE;
401 			goto cleanup;
402 		}
403 		cp += skip;
404 		if (cp + 3 * INT16SZ + INT32SZ > eom) {
405 			errno = EMSGSIZE;
406 			goto cleanup;
407 		}
408 		rr.type = ns_get16(cp);
409 		cp += INT16SZ;
410 		rr.class = ns_get16(cp);
411 		cp += INT16SZ + INT32SZ;	/*%< skip the ttl, too */
412 		rr.dlen = ns_get16(cp);
413 		cp += INT16SZ;
414 		if (cp + rr.dlen > eom) {
415 			errno = EMSGSIZE;
416 			goto cleanup;
417 		}
418 		rr.data = cp;
419 		cp += rr.dlen;
420 		if (rr.class != class || rr.type != T_TXT)
421 			continue;
422 		if (!(list[j] = malloc(rr.dlen)))
423 			goto cleanup;
424 		dst = list[j++];
425 		edst = dst + rr.dlen;
426 		erdata = rr.data + rr.dlen;
427 		cp = rr.data;
428 		while (cp < erdata) {
429 			n = (unsigned char) *cp++;
430 			if (cp + n > eom || dst + n > edst) {
431 				errno = EMSGSIZE;
432 				goto cleanup;
433 			}
434 			memcpy(dst, cp, n);
435 			cp += n;
436 			dst += n;
437 		}
438 		if (cp != erdata) {
439 			errno = EMSGSIZE;
440 			goto cleanup;
441 		}
442 		*dst = '\0';
443 	}
444 	list[j] = NULL;
445 	if (j == 0) {
446 		errno = ENOENT;
447 		goto cleanup;
448 	}
449 	return (list);
450 
451  cleanup:
452 	for (i = 0; i < j; i++)
453 		free(list[i]);
454 	free(list);
455 	return (NULL);
456 }
457 
458 struct __res_state *
__hesiod_res_get(void * context)459 __hesiod_res_get(void *context) {
460 	struct hesiod_p *ctx = context;
461 
462 	if (!ctx->res) {
463 		struct __res_state *res;
464 		res = (struct __res_state *)malloc(sizeof *res);
465 		if (res == NULL) {
466 			errno = ENOMEM;
467 			return (NULL);
468 		}
469 		memset(res, 0, sizeof *res);
470 		__hesiod_res_set(ctx, res, free);
471 	}
472 
473 	return (ctx->res);
474 }
475 
476 void
__hesiod_res_set(void * context,struct __res_state * res,void (* free_res)(void *))477 __hesiod_res_set(void *context, struct __res_state *res,
478 	         void (*free_res)(void *)) {
479 	struct hesiod_p *ctx = context;
480 
481 	if (ctx->res && ctx->free_res) {
482 		res_nclose(ctx->res);
483 		(*ctx->free_res)(ctx->res);
484 	}
485 
486 	ctx->res = res;
487 	ctx->free_res = free_res;
488 }
489 
490 static int
init(struct hesiod_p * ctx)491 init(struct hesiod_p *ctx) {
492 
493 	if (!ctx->res && !__hesiod_res_get(ctx))
494 		return (-1);
495 
496 	if (((ctx->res->options & RES_INIT) == 0U) &&
497 	    (res_ninit(ctx->res) == -1))
498 		return (-1);
499 
500 	return (0);
501 }
502