1 /* $NetBSD: hesiod.c,v 1.9 1999/02/11 06:16:38 simonb 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 0 49 static char *orig_rcsid = "$NetBSD: hesiod.c,v 1.9 1999/02/11 06:16:38 simonb Exp $"; 50 #endif 51 #include <sys/cdefs.h> 52 __FBSDID("$FreeBSD$"); 53 54 #include <sys/param.h> 55 #include <netinet/in.h> 56 #include <arpa/nameser.h> 57 58 #include <ctype.h> 59 #include <errno.h> 60 #include <hesiod.h> 61 #include <resolv.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #include <unistd.h> 66 67 struct hesiod_p { 68 char *lhs; /* normally ".ns" */ 69 char *rhs; /* AKA the default hesiod domain */ 70 int classes[2]; /* The class search order. */ 71 }; 72 73 #define MAX_HESRESP 1024 74 75 static int read_config_file(struct hesiod_p *, const char *); 76 static char **get_txt_records(int, const char *); 77 static int init_context(void); 78 static void translate_errors(void); 79 80 81 /* 82 * hesiod_init -- 83 * initialize a hesiod_p. 84 */ 85 int 86 hesiod_init(context) 87 void **context; 88 { 89 struct hesiod_p *ctx; 90 const char *p, *configname; 91 92 ctx = malloc(sizeof(struct hesiod_p)); 93 if (ctx) { 94 *context = ctx; 95 configname = secure_getenv("HESIOD_CONFIG"); 96 if (!configname) 97 configname = _PATH_HESIOD_CONF; 98 if (read_config_file(ctx, configname) >= 0) { 99 /* 100 * The default rhs can be overridden by an 101 * environment variable. 102 */ 103 p = secure_getenv("HES_DOMAIN"); 104 if (p) { 105 if (ctx->rhs) 106 free(ctx->rhs); 107 ctx->rhs = malloc(strlen(p) + 2); 108 if (ctx->rhs) { 109 *ctx->rhs = '.'; 110 strcpy(ctx->rhs + 1, 111 (*p == '.') ? p + 1 : p); 112 return 0; 113 } else 114 errno = ENOMEM; 115 } else 116 return 0; 117 } 118 } else 119 errno = ENOMEM; 120 121 if (ctx->lhs) 122 free(ctx->lhs); 123 if (ctx->rhs) 124 free(ctx->rhs); 125 if (ctx) 126 free(ctx); 127 return -1; 128 } 129 130 /* 131 * hesiod_end -- 132 * Deallocates the hesiod_p. 133 */ 134 void 135 hesiod_end(context) 136 void *context; 137 { 138 struct hesiod_p *ctx = (struct hesiod_p *) context; 139 140 free(ctx->rhs); 141 if (ctx->lhs) 142 free(ctx->lhs); 143 free(ctx); 144 } 145 146 /* 147 * hesiod_to_bind -- 148 * takes a hesiod (name, type) and returns a DNS 149 * name which is to be resolved. 150 */ 151 char * 152 hesiod_to_bind(void *context, const char *name, const char *type) 153 { 154 struct hesiod_p *ctx = (struct hesiod_p *) context; 155 char bindname[MAXDNAME], *p, *ret, **rhs_list = NULL; 156 const char *rhs; 157 int len; 158 159 if (strlcpy(bindname, name, sizeof(bindname)) >= sizeof(bindname)) { 160 errno = EMSGSIZE; 161 return NULL; 162 } 163 164 /* 165 * Find the right right hand side to use, possibly 166 * truncating bindname. 167 */ 168 p = strchr(bindname, '@'); 169 if (p) { 170 *p++ = 0; 171 if (strchr(p, '.')) 172 rhs = name + (p - bindname); 173 else { 174 rhs_list = hesiod_resolve(context, p, "rhs-extension"); 175 if (rhs_list) 176 rhs = *rhs_list; 177 else { 178 errno = ENOENT; 179 return NULL; 180 } 181 } 182 } else 183 rhs = ctx->rhs; 184 185 /* See if we have enough room. */ 186 len = strlen(bindname) + 1 + strlen(type); 187 if (ctx->lhs) 188 len += strlen(ctx->lhs) + ((ctx->lhs[0] != '.') ? 1 : 0); 189 len += strlen(rhs) + ((rhs[0] != '.') ? 1 : 0); 190 if (len > sizeof(bindname) - 1) { 191 if (rhs_list) 192 hesiod_free_list(context, rhs_list); 193 errno = EMSGSIZE; 194 return NULL; 195 } 196 /* Put together the rest of the domain. */ 197 strcat(bindname, "."); 198 strcat(bindname, type); 199 /* Only append lhs if it isn't empty. */ 200 if (ctx->lhs && ctx->lhs[0] != '\0' ) { 201 if (ctx->lhs[0] != '.') 202 strcat(bindname, "."); 203 strcat(bindname, ctx->lhs); 204 } 205 if (rhs[0] != '.') 206 strcat(bindname, "."); 207 strcat(bindname, rhs); 208 209 /* rhs_list is no longer needed, since we're done with rhs. */ 210 if (rhs_list) 211 hesiod_free_list(context, rhs_list); 212 213 /* Make a copy of the result and return it to the caller. */ 214 ret = strdup(bindname); 215 if (!ret) 216 errno = ENOMEM; 217 return ret; 218 } 219 220 /* 221 * hesiod_resolve -- 222 * Given a hesiod name and type, return an array of strings returned 223 * by the resolver. 224 */ 225 char ** 226 hesiod_resolve(context, name, type) 227 void *context; 228 const char *name; 229 const char *type; 230 { 231 struct hesiod_p *ctx = (struct hesiod_p *) context; 232 char *bindname, **retvec; 233 234 bindname = hesiod_to_bind(context, name, type); 235 if (!bindname) 236 return NULL; 237 238 retvec = get_txt_records(ctx->classes[0], bindname); 239 if (retvec == NULL && errno == ENOENT && ctx->classes[1]) 240 retvec = get_txt_records(ctx->classes[1], bindname); 241 242 free(bindname); 243 return retvec; 244 } 245 246 /*ARGSUSED*/ 247 void 248 hesiod_free_list(context, list) 249 void *context; 250 char **list; 251 { 252 char **p; 253 254 if (list == NULL) 255 return; 256 for (p = list; *p; p++) 257 free(*p); 258 free(list); 259 } 260 261 262 /* read_config_file -- 263 * Parse the /etc/hesiod.conf file. Returns 0 on success, 264 * -1 on failure. On failure, it might leave values in ctx->lhs 265 * or ctx->rhs which need to be freed by the caller. 266 */ 267 static int 268 read_config_file(ctx, filename) 269 struct hesiod_p *ctx; 270 const char *filename; 271 { 272 char *key, *data, *p, **which; 273 char buf[MAXDNAME + 7]; 274 int n; 275 FILE *fp; 276 277 /* Set default query classes. */ 278 ctx->classes[0] = C_IN; 279 ctx->classes[1] = C_HS; 280 281 /* Try to open the configuration file. */ 282 fp = fopen(filename, "re"); 283 if (!fp) { 284 /* Use compiled in default domain names. */ 285 ctx->lhs = strdup(DEF_LHS); 286 ctx->rhs = strdup(DEF_RHS); 287 if (ctx->lhs && ctx->rhs) 288 return 0; 289 else { 290 errno = ENOMEM; 291 return -1; 292 } 293 } 294 ctx->lhs = NULL; 295 ctx->rhs = NULL; 296 while (fgets(buf, sizeof(buf), fp) != NULL) { 297 p = buf; 298 if (*p == '#' || *p == '\n' || *p == '\r') 299 continue; 300 while (*p == ' ' || *p == '\t') 301 p++; 302 key = p; 303 while (*p != ' ' && *p != '\t' && *p != '=') 304 p++; 305 *p++ = 0; 306 307 while (isspace(*p) || *p == '=') 308 p++; 309 data = p; 310 while (!isspace(*p)) 311 p++; 312 *p = 0; 313 314 if (strcasecmp(key, "lhs") == 0 || 315 strcasecmp(key, "rhs") == 0) { 316 which = (strcasecmp(key, "lhs") == 0) 317 ? &ctx->lhs : &ctx->rhs; 318 *which = strdup(data); 319 if (!*which) { 320 fclose(fp); 321 errno = ENOMEM; 322 return -1; 323 } 324 } else { 325 if (strcasecmp(key, "classes") == 0) { 326 n = 0; 327 while (*data && n < 2) { 328 p = data; 329 while (*p && *p != ',') 330 p++; 331 if (*p) 332 *p++ = 0; 333 if (strcasecmp(data, "IN") == 0) 334 ctx->classes[n++] = C_IN; 335 else 336 if (strcasecmp(data, "HS") == 0) 337 ctx->classes[n++] = 338 C_HS; 339 data = p; 340 } 341 while (n < 2) 342 ctx->classes[n++] = 0; 343 } 344 } 345 } 346 fclose(fp); 347 348 if (!ctx->rhs || ctx->classes[0] == 0 || 349 ctx->classes[0] == ctx->classes[1]) { 350 errno = ENOEXEC; 351 return -1; 352 } 353 return 0; 354 } 355 356 /* 357 * get_txt_records -- 358 * Given a DNS class and a DNS name, do a lookup for TXT records, and 359 * return a list of them. 360 */ 361 static char ** 362 get_txt_records(qclass, name) 363 int qclass; 364 const char *name; 365 { 366 HEADER *hp; 367 unsigned char qbuf[PACKETSZ], abuf[MAX_HESRESP], *p, *eom, *eor; 368 char *dst, **list; 369 int ancount, qdcount, i, j, n, skip, type, class, len; 370 371 /* Make sure the resolver is initialized. */ 372 if ((_res.options & RES_INIT) == 0 && res_init() == -1) 373 return NULL; 374 375 /* Construct the query. */ 376 n = res_mkquery(QUERY, name, qclass, T_TXT, NULL, 0, 377 NULL, qbuf, PACKETSZ); 378 if (n < 0) 379 return NULL; 380 381 /* Send the query. */ 382 n = res_send(qbuf, n, abuf, MAX_HESRESP); 383 if (n < 0 || n > MAX_HESRESP) { 384 errno = ECONNREFUSED; /* XXX */ 385 return NULL; 386 } 387 /* Parse the header of the result. */ 388 hp = (HEADER *) (void *) abuf; 389 ancount = ntohs(hp->ancount); 390 qdcount = ntohs(hp->qdcount); 391 p = abuf + sizeof(HEADER); 392 eom = abuf + n; 393 394 /* 395 * Skip questions, trying to get to the answer section 396 * which follows. 397 */ 398 for (i = 0; i < qdcount; i++) { 399 skip = dn_skipname(p, eom); 400 if (skip < 0 || p + skip + QFIXEDSZ > eom) { 401 errno = EMSGSIZE; 402 return NULL; 403 } 404 p += skip + QFIXEDSZ; 405 } 406 407 /* Allocate space for the text record answers. */ 408 list = malloc((ancount + 1) * sizeof(char *)); 409 if (!list) { 410 errno = ENOMEM; 411 return NULL; 412 } 413 /* Parse the answers. */ 414 j = 0; 415 for (i = 0; i < ancount; i++) { 416 /* Parse the header of this answer. */ 417 skip = dn_skipname(p, eom); 418 if (skip < 0 || p + skip + 10 > eom) 419 break; 420 type = p[skip + 0] << 8 | p[skip + 1]; 421 class = p[skip + 2] << 8 | p[skip + 3]; 422 len = p[skip + 8] << 8 | p[skip + 9]; 423 p += skip + 10; 424 if (p + len > eom) { 425 errno = EMSGSIZE; 426 break; 427 } 428 /* Skip entries of the wrong class and type. */ 429 if (class != qclass || type != T_TXT) { 430 p += len; 431 continue; 432 } 433 /* Allocate space for this answer. */ 434 list[j] = malloc((size_t)len); 435 if (!list[j]) { 436 errno = ENOMEM; 437 break; 438 } 439 dst = list[j++]; 440 441 /* Copy answer data into the allocated area. */ 442 eor = p + len; 443 while (p < eor) { 444 n = (unsigned char) *p++; 445 if (p + n > eor) { 446 errno = EMSGSIZE; 447 break; 448 } 449 memcpy(dst, p, (size_t)n); 450 p += n; 451 dst += n; 452 } 453 if (p < eor) { 454 errno = EMSGSIZE; 455 break; 456 } 457 *dst = 0; 458 } 459 460 /* 461 * If we didn't terminate the loop normally, something 462 * went wrong. 463 */ 464 if (i < ancount) { 465 for (i = 0; i < j; i++) 466 free(list[i]); 467 free(list); 468 return NULL; 469 } 470 if (j == 0) { 471 errno = ENOENT; 472 free(list); 473 return NULL; 474 } 475 list[j] = NULL; 476 return list; 477 } 478 479 /* 480 * COMPATIBILITY FUNCTIONS 481 */ 482 483 static int inited = 0; 484 static void *context; 485 static int errval = HES_ER_UNINIT; 486 487 int 488 hes_init() 489 { 490 init_context(); 491 return errval; 492 } 493 494 char * 495 hes_to_bind(name, type) 496 const char *name; 497 const char *type; 498 { 499 static char *bindname; 500 if (init_context() < 0) 501 return NULL; 502 if (bindname) 503 free(bindname); 504 bindname = hesiod_to_bind(context, name, type); 505 if (!bindname) 506 translate_errors(); 507 return bindname; 508 } 509 510 char ** 511 hes_resolve(name, type) 512 const char *name; 513 const char *type; 514 { 515 static char **list; 516 517 if (init_context() < 0) 518 return NULL; 519 520 /* 521 * In the old Hesiod interface, the caller was responsible for 522 * freeing the returned strings but not the vector of strings itself. 523 */ 524 if (list) 525 free(list); 526 527 list = hesiod_resolve(context, name, type); 528 if (!list) 529 translate_errors(); 530 return list; 531 } 532 533 int 534 hes_error() 535 { 536 return errval; 537 } 538 539 void 540 hes_free(hp) 541 char **hp; 542 { 543 hesiod_free_list(context, hp); 544 } 545 546 static int 547 init_context() 548 { 549 if (!inited) { 550 inited = 1; 551 if (hesiod_init(&context) < 0) { 552 errval = HES_ER_CONFIG; 553 return -1; 554 } 555 errval = HES_ER_OK; 556 } 557 return 0; 558 } 559 560 static void 561 translate_errors() 562 { 563 switch (errno) { 564 case ENOENT: 565 errval = HES_ER_NOTFOUND; 566 break; 567 case ECONNREFUSED: 568 case EMSGSIZE: 569 errval = HES_ER_NET; 570 break; 571 case ENOMEM: 572 default: 573 /* Not a good match, but the best we can do. */ 574 errval = HES_ER_CONFIG; 575 break; 576 } 577 } 578