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