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