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