lib/libc/net/hesiod.c

   1 /*      $NetBSD: hesiod.c,v 1.23 2005/02/28 01:25:24 lukem 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.23 2005/02/28 01:25:24 lukem 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 __P((struct hesiod_p *, const char *));
  96 static char     **get_txt_records __P((int, const char *));
  97 static int        init_context __P((void));
  98 static void       translate_errors __P((void));
  99
 100
 101 /*
 102  * hesiod_init --
 103  *      initialize a hesiod_p.
 104  */
 105 int
 106 hesiod_init(context)
 107         void    **context;
 108 {
 109         struct hesiod_p *ctx;
 110         const char      *p, *configname;
 111         int serrno;
 112
 113         _DIAGASSERT(context != NULL);
 114
 115         ctx = calloc(1, sizeof(struct hesiod_p));
 116         if (ctx) {
 117                 *context = ctx;
 118                 /*
 119                  * don't permit overrides from environment
 120                  * for set.id programs
 121                  */
 122                 if (issetugid())
 123                         configname = NULL;
 124                 else
 125                         configname = getenv("HESIOD_CONFIG");
 126                 if (!configname)
 127                         configname = _PATH_HESIOD_CONF;
 128                 if (read_config_file(ctx, configname) >= 0) {
 129                         /*
 130                          * The default rhs can be overridden by an
 131                          * environment variable, unless set.id.
 132                          */
 133                         if (issetugid())
 134                                 p = NULL;
 135                         else
 136                                 p = getenv("HES_DOMAIN");
 137                         if (p) {
 138                                 if (ctx->rhs)
 139                                         free(ctx->rhs);
 140                                 ctx->rhs = malloc(strlen(p) + 2);
 141                                 if (ctx->rhs) {
 142                                         *ctx->rhs = '.';
 143                                         strcpy(ctx->rhs + 1,
 144                                             (*p == '.') ? p + 1 : p);
 145                                         return 0;
 146                                 } else
 147                                         errno = ENOMEM;
 148                         } else
 149                                 return 0;
 150                 }
 151         } else
 152                 errno = ENOMEM;
 153
 154         serrno = errno;
 155         if (ctx) {
 156                 if (ctx->lhs)
 157                         free(ctx->lhs);
 158                 if (ctx->rhs)
 159                         free(ctx->rhs);
 160                 free(ctx);
 161         }
 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         size_t           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         strlcat(bindname, ".", sizeof(bindname));
 240         strlcat(bindname, type, sizeof(bindname));
 241         /* Only append lhs if it isn't empty. */
 242         if (ctx->lhs && ctx->lhs[0] != '\0' ) {
 243                 if (ctx->lhs[0] != '.')
 244                         strlcat(bindname, ".", sizeof(bindname));
 245                 strlcat(bindname, ctx->lhs, sizeof(bindname));
 246         }
 247         if (rhs[0] != '.')
 248                 strlcat(bindname, ".", sizeof(bindname));
 249         strlcat(bindname, rhs, sizeof(bindname));
 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         res_state        res = __res_get_state();
 430
 431         if (res == NULL)
 432                 return NULL;
 433
 434         _DIAGASSERT(name != NULL);
 435
 436         /* Construct the query. */
 437         n = res_nmkquery(res, QUERY, name, qclass, T_TXT, NULL, 0,
 438             NULL, qbuf, PACKETSZ);
 439         if (n < 0) {
 440                 errno = EMSGSIZE;
 441                 __res_put_state(res);
 442                 return NULL;
 443         }
 444
 445         /* Send the query. */
 446         n = res_nsend(res, qbuf, n, abuf, MAX_HESRESP);
 447         __res_put_state(res);
 448         if (n < 0) {
 449                 errno = ECONNREFUSED;
 450                 return NULL;
 451         }
 452         /* Parse the header of the result. */
 453         hp = (HEADER *) (void *) abuf;
 454         ancount = ntohs(hp->ancount);
 455         qdcount = ntohs(hp->qdcount);
 456         p = abuf + sizeof(HEADER);
 457         eom = abuf + n;
 458
 459         /*
 460          * Skip questions, trying to get to the answer section
 461          * which follows.
 462          */
 463         for (i = 0; i < qdcount; i++) {
 464                 skip = dn_skipname(p, eom);
 465                 if (skip < 0 || p + skip + QFIXEDSZ > eom) {
 466                         errno = EMSGSIZE;
 467                         return NULL;
 468                 }
 469                 p += skip + QFIXEDSZ;
 470         }
 471
 472         /* Allocate space for the text record answers. */
 473         list = malloc((ancount + 1) * sizeof(char *));
 474         if (!list) {
 475                 errno = ENOMEM;
 476                 return NULL;
 477         }
 478         /* Parse the answers. */
 479         j = 0;
 480         for (i = 0; i < ancount; i++) {
 481                 /* Parse the header of this answer. */
 482                 skip = dn_skipname(p, eom);
 483                 if (skip < 0 || p + skip + 10 > eom)
 484                         break;
 485                 type = p[skip + 0] << 8 | p[skip + 1];
 486                 class = p[skip + 2] << 8 | p[skip + 3];
 487                 len = p[skip + 8] << 8 | p[skip + 9];
 488                 p += skip + 10;
 489                 if (p + len > eom) {
 490                         errno = EMSGSIZE;
 491                         break;
 492                 }
 493                 /* Skip entries of the wrong class and type. */
 494                 if (class != qclass || type != T_TXT) {
 495                         p += len;
 496                         continue;
 497                 }
 498                 /* Allocate space for this answer. */
 499                 list[j] = malloc((size_t)len);
 500                 if (!list[j]) {
 501                         errno = ENOMEM;
 502                         break;
 503                 }
 504                 dst = list[j++];
 505
 506                 /* Copy answer data into the allocated area. */
 507                 eor = p + len;
 508                 while (p < eor) {
 509                         n = (unsigned char) *p++;
 510                         if (p + n > eor) {
 511                                 errno = EMSGSIZE;
 512                                 break;
 513                         }
 514                         memcpy(dst, p, (size_t)n);
 515                         p += n;
 516                         dst += n;
 517                 }
 518                 if (p < eor) {
 519                         errno = EMSGSIZE;
 520                         break;
 521                 }
 522                 *dst = 0;
 523         }
 524
 525         /*
 526          * If we didn't terminate the loop normally, something
 527          * went wrong.
 528          */
 529         if (i < ancount) {
 530                 for (i = 0; i < j; i++)
 531                         free(list[i]);
 532                 free(list);
 533                 return NULL;
 534         }
 535         if (j == 0) {
 536                 errno = ENOENT;
 537                 free(list);
 538                 return NULL;
 539         }
 540         list[j] = NULL;
 541         return list;
 542 }
 543
 544 /*
 545  * COMPATIBILITY FUNCTIONS
 546  */
 547
 548 static int        inited = 0;
 549 static void      *context;
 550 static int        errval = HES_ER_UNINIT;
 551
 552 int
 553 hes_init()
 554 {
 555         init_context();
 556         return errval;
 557 }
 558
 559 char *
 560 hes_to_bind(name, type)
 561         const char      *name;
 562         const char      *type;
 563 {
 564         static  char    *bindname;
 565
 566         _DIAGASSERT(name != NULL);
 567         _DIAGASSERT(type != NULL);
 568
 569         if (init_context() < 0)
 570                 return NULL;
 571         if (bindname)
 572                 free(bindname);
 573         bindname = hesiod_to_bind(context, name, type);
 574         if (!bindname)
 575                 translate_errors();
 576         return bindname;
 577 }
 578
 579 char **
 580 hes_resolve(name, type)
 581         const char      *name;
 582         const char      *type;
 583 {
 584         static char     **list;
 585
 586         _DIAGASSERT(name != NULL);
 587         _DIAGASSERT(type != NULL);
 588
 589         if (init_context() < 0)
 590                 return NULL;
 591
 592         /*
 593          * In the old Hesiod interface, the caller was responsible for
 594          * freeing the returned strings but not the vector of strings itself.
 595          */
 596         if (list)
 597                 free(list);
 598
 599         list = hesiod_resolve(context, name, type);
 600         if (!list)
 601                 translate_errors();
 602         return list;
 603 }
 604
 605 int
 606 hes_error()
 607 {
 608         return errval;
 609 }
 610
 611 void
 612 hes_free(hp)
 613         char **hp;
 614 {
 615         hesiod_free_list(context, hp);
 616 }
 617
 618 static int
 619 init_context()
 620 {
 621         if (!inited) {
 622                 inited = 1;
 623                 if (hesiod_init(&context) < 0) {
 624                         errval = HES_ER_CONFIG;
 625                         return -1;
 626                 }
 627                 errval = HES_ER_OK;
 628         }
 629         return 0;
 630 }
 631
 632 static void
 633 translate_errors()
 634 {
 635         switch (errno) {
 636         case ENOENT:
 637                 errval = HES_ER_NOTFOUND;
 638                 break;
 639         case ECONNREFUSED:
 640         case EMSGSIZE:
 641                 errval = HES_ER_NET;
 642                 break;
 643         default:
 644                 /* Not a good match, but the best we can do. */
 645                 errval = HES_ER_CONFIG;
 646                 break;
 647         }
 648 }