1 /* $NetBSD: hesiod.c,v 1.17 2002/04/16 19:12:40 groo 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.17 2002/04/16 19:12:40 groo 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