lib/libc/net/hesiod.c

   1 /*      $NetBSD: hesiod.c,v 1.27 2012/03/20 17:44:18 matt 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.27 2012/03/20 17:44:18 matt 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, "r");
 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 }