1: #if defined(LIBC_SCCS) && !defined(lint)
    2: static const char rcsid[] = "$BINDId: hesiod.c,v 1.21 2000/02/28 14:51:08 vixie Exp $";
    3: #endif
    4: 
    5: /*
    6:  * Copyright (c) 1996,1999 by Internet Software Consortium.
    7:  *
    8:  * Permission to use, copy, modify, and distribute this software for any
    9:  * purpose with or without fee is hereby granted, provided that the above
   10:  * copyright notice and this permission notice appear in all copies.
   11:  *
   12:  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
   13:  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
   14:  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
   15:  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
   16:  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
   17:  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
   18:  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
   19:  * SOFTWARE.
   20:  */
   21: 
   22: /*
   23:  * This file is primarily maintained by <tytso@mit.edu> and <ghudson@mit.edu>.
   24:  */
   25: 
   26: /*
   27:  * hesiod.c --- the core portion of the hesiod resolver.
   28:  *
   29:  * This file is derived from the hesiod library from Project Athena;
   30:  * It has been extensively rewritten by Theodore Ts'o to have a more
   31:  * thread-safe interface.
   32:  */
   33: 
   34: /* Imports */
   35: 
   36: #include <sys/types.h>
   37: #include <netinet/in.h>
   38: #include <arpa/nameser.h>
   39: 
   40: #include <errno.h>
   41: #include <netdb.h>
   42: #include <resolv.h>
   43: #include <stdio.h>
   44: #include <stdlib.h>
   45: #include <string.h>
   46: 
   47: #include "hesiod.h"
   48: #include "hesiod_p.h"
   49: #undef DEF_RHS
   50: 
   51: #define _PATH_HESIOD_CONF "/etc/hesiod.conf"
   52: 
   53: /* Forward */
   54: 
   55: int             hesiod_init(void **context);
   56: void            hesiod_end(void *context);
   57: char *          hesiod_to_bind(void *context, const char *name,
   58:                                const char *type);
   59: char **         hesiod_resolve(void *context, const char *name,
   60:                                const char *type);
   61: void            hesiod_free_list(void *context, char **list);
   62: 
   63: static int      parse_config_file(struct hesiod_p *ctx, const char *filename);
   64: static char **  get_txt_records(struct hesiod_p *ctx, int class,
   65:                                 const char *name);
   66: static int      init(struct hesiod_p *ctx);
   67: 
   68: /* Public */
   69: 
   70: /*
   71:  * This function is called to initialize a hesiod_p.
   72:  */
   73: int
   74: hesiod_init(void **context) {
   75:         struct hesiod_p *ctx;
   76:         const char *configname;
   77:         char *cp;
   78: 
   79:         ctx = malloc(sizeof(struct hesiod_p));
   80:         if (ctx == 0)
   81:                 return (-1);
   82: 
   83:         ctx->LHS = NULL;
   84:         ctx->RHS = NULL;
   85:         ctx->res = NULL;
   86:         /* Set default query classes. */
   87:         ctx->classes[0] = C_IN;
   88:         ctx->classes[1] = C_HS;
   89: 
   90:         configname = __secure_getenv("HESIOD_CONFIG");
   91:         if (!configname)
   92:           configname = _PATH_HESIOD_CONF;
   93:         if (parse_config_file(ctx, configname) < 0) {
   94: #ifdef DEF_RHS
   95:                 /*
   96:                  * Use compiled in defaults.
   97:                  */
   98:                 ctx->LHS = malloc(strlen(DEF_LHS)+1);
   99:                 ctx->RHS = malloc(strlen(DEF_RHS)+1);
  100:                 if (ctx->LHS == 0 || ctx->RHS == 0)
  101:                         goto cleanup;
  102:                 strcpy(ctx->LHS, DEF_LHS);
  103:                 strcpy(ctx->RHS, DEF_RHS);
  104: #else
  105:                 goto cleanup;
  106: #endif
  107:         }
  108:         /*
  109:          * The default RHS can be overridden by an environment
  110:          * variable.
  111:          */
  112:         if ((cp = __secure_getenv("HES_DOMAIN")) != NULL) {
  113:                 free(ctx->RHS);
  114:                 ctx->RHS = malloc(strlen(cp)+2);
  115:                 if (!ctx->RHS)
  116:                         goto cleanup;
  117:                 if (cp[0] == '.')
  118:                         strcpy(ctx->RHS, cp);
  119:                 else {
  120:                         ctx->RHS[0] = '.';
  121:                         strcpy(ctx->RHS + 1, cp);
  122:                 }
  123:         }
  124: 
  125:         /*
  126:          * If there is no default hesiod realm set, we return an
  127:          * error.
  128:          */
  129:         if (!ctx->RHS) {
  130:                 __set_errno(ENOEXEC);
  131:                 goto cleanup;
  132:         }
  133: 
  134: #if 0
  135:         if (res_ninit(ctx->res) < 0)
  136:                 goto cleanup;
  137: #endif
  138: 
  139:         *context = ctx;
  140:         return (0);
  141: 
  142:  cleanup:
  143:         hesiod_end(ctx);
  144:         return (-1);
  145: }
  146: 
  147: /*
  148:  * This function deallocates the hesiod_p
  149:  */
  150: void
  151: hesiod_end(void *context) {
  152:         struct hesiod_p *ctx = (struct hesiod_p *) context;
  153:         int save_errno = errno;
  154: 
  155:         if (ctx->res)
  156:                 res_nclose(ctx->res);
  157:         free(ctx->RHS);
  158:         free(ctx->LHS);
  159:         if (ctx->res && ctx->free_res)
  160:                 (*ctx->free_res)(ctx->res);
  161:         free(ctx);
  162:         __set_errno(save_errno);
  163: }
  164: 
  165: /*
  166:  * This function takes a hesiod (name, type) and returns a DNS
  167:  * name which is to be resolved.
  168:  */
  169: char *
  170: hesiod_to_bind(void *context, const char *name, const char *type) {
  171:         struct hesiod_p *ctx = (struct hesiod_p *) context;
  172:         char *bindname;
  173:         char **rhs_list = NULL;
  174:         const char *RHS, *cp;
  175:         char *endp;
  176: 
  177:         /* Decide what our RHS is, and set cp to the end of the actual name. */
  178:         if ((cp = strchr(name, '@')) != NULL) {
  179:                 if (strchr(cp + 1, '.'))
  180:                         RHS = cp + 1;
  181:                 else if ((rhs_list = hesiod_resolve(context, cp + 1,
  182:                     "rhs-extension")) != NULL)
  183:                         RHS = *rhs_list;
  184:                 else {
  185:                         __set_errno(ENOENT);
  186:                         return (NULL);
  187:                 }
  188:         } else {
  189:                 RHS = ctx->RHS;
  190:                 cp = name + strlen(name);
  191:         }
  192: 
  193:         /*
  194:          * Allocate the space we need, including up to three periods and
  195:          * the terminating NUL.
  196:          */
  197:         if ((bindname = malloc((cp - name) + strlen(type) + strlen(RHS) +
  198:             (ctx->LHS ? strlen(ctx->LHS) : 0) + 4)) == NULL) {
  199:                 if (rhs_list)
  200:                         hesiod_free_list(context, rhs_list);
  201:                 return NULL;
  202:         }
  203: 
  204:         /* Now put together the DNS name. */
  205:         endp = (char *) __mempcpy (bindname, name, cp - name);
  206:         *endp++ = '.';
  207:         endp = (char *) __stpcpy (endp, type);
  208:         if (ctx->LHS) {
  209:                 if (ctx->LHS[0] != '.')
  210:                         *endp++ = '.';
  211:                 endp = __stpcpy (endp, ctx->LHS);
  212:         }
  213:         if (RHS[0] != '.')
  214:                 *endp++ = '.';
  215:         strcpy (endp, RHS);
  216: 
  217:         if (rhs_list)
  218:                 hesiod_free_list(context, rhs_list);
  219: 
  220:         return (bindname);
  221: }
  222: 
  223: /*
  224:  * This is the core function.  Given a hesiod (name, type), it
  225:  * returns an array of strings returned by the resolver.
  226:  */
  227: char **
  228: hesiod_resolve(void *context, const char *name, const char *type) {
  229:         struct hesiod_p *ctx = (struct hesiod_p *) context;
  230:         char *bindname = hesiod_to_bind(context, name, type);
  231:         char **retvec;
  232: 
  233:         if (bindname == NULL)
  234:                 return (NULL);
  235:         if (init(ctx) == -1) {
  236:                 free(bindname);
  237:                 return (NULL);
  238:         }
  239: 
  240:         retvec = get_txt_records(ctx, ctx->classes[0], bindname);
  241: 
  242:         if (retvec == NULL && (errno == ENOENT || errno == ECONNREFUSED) && ctx->classes[1])
  243:                 retvec = get_txt_records(ctx, ctx->classes[1], bindname);
  244: 
  245: 
  246:         free(bindname);
  247:         return (retvec);
  248: }
  249: 
  250: void
  251: hesiod_free_list(void *context, char **list) {
  252:         char **p;
  253: 
  254:         for (p = list; *p; p++)
  255:                 free(*p);
  256:         free(list);
  257: }
  258: 
  259: /*
  260:  * This function parses the /etc/hesiod.conf file
  261:  */
  262: static int
  263: parse_config_file(struct hesiod_p *ctx, const char *filename) {
  264:         char buf[MAXDNAME+7];
  265:         FILE *fp;
  266: 
  267:         /*
  268:          * Clear the existing configuration variable, just in case
  269:          * they're set.
  270:          */
  271:         free(ctx->RHS);
  272:         free(ctx->LHS);
  273:         ctx->RHS = ctx->LHS = 0;
  274:         /* Set default query classes. */
  275:         ctx->classes[0] = C_IN;
  276:         ctx->classes[1] = C_HS;
  277: 
  278:         /*
  279:          * Now open and parse the file...
  280:          */
  281:         if (!(fp = fopen(filename, "r")))
  282:                 return (-1);
  283: 
  284:         while (fgets(buf, sizeof(buf), fp) != NULL) {
  285:                 char *key, *data, *cp, **cpp;
  286: 
  287:                 cp = buf;
  288:                 if (*cp == '#' || *cp == '\n' || *cp == '\r')
  289:                         continue;
  290:                 while(*cp == ' ' || *cp == '\t')
  291:                         cp++;
  292:                 key = cp;
  293:                 while(*cp != ' ' && *cp != '\t' && *cp != '=')
  294:                         cp++;
  295:                 *cp++ = '\0';
  296: 
  297:                 while(*cp == ' ' || *cp == '\t' || *cp == '=')
  298:                         cp++;
  299:                 data = cp;
  300:                 while(*cp != ' ' && *cp != '\n' && *cp != '\r')
  301:                         cp++;
  302:                 *cp++ = '\0';
  303: 
  304:                 cpp = NULL;
  305:                 if (strcasecmp(key, "lhs") == 0)
  306:                         cpp = &ctx->LHS;
  307:                 else if (strcasecmp(key, "rhs") == 0)
  308:                         cpp = &ctx->RHS;
  309:                 if (cpp) {
  310:                         *cpp = strdup(data);
  311:                         if (!*cpp)
  312:                                 goto cleanup;
  313:                 } else if (strcasecmp(key, "classes") == 0) {
  314:                         int n = 0;
  315:                         while (*data && n < 2) {
  316:                                 cp = strchrnul(data, ',');
  317:                                 if (*cp != '\0')
  318:                                         *cp++ = '\0';
  319:                                 if (strcasecmp(data, "IN") == 0)
  320:                                         ctx->classes[n++] = C_IN;
  321:                                 else if (strcasecmp(data, "HS") == 0)
  322:                                         ctx->classes[n++] = C_HS;
  323:                                 data = cp;
  324:                         }
  325:                         if (n == 0) {
  326:                                 /* Restore the default.  Better than
  327:                                    nother at all.  */
  328:                                 ctx->classes[0] = C_IN;
  329:                                 ctx->classes[1] = C_HS;
  330:                         } else if (n == 1
  331:                                    || ctx->classes[0] == ctx->classes[1])
  332:                                 ctx->classes[1] = 0;
  333:                 }
  334:         }
  335:         fclose(fp);
  336:         return (0);
  337: 
  338:  cleanup:
  339:         fclose(fp);
  340:         free(ctx->RHS);
  341:         free(ctx->LHS);
  342:         ctx->RHS = ctx->LHS = 0;
  343:         return (-1);
  344: }
  345: 
  346: /*
  347:  * Given a DNS class and a DNS name, do a lookup for TXT records, and
  348:  * return a list of them.
  349:  */
  350: static char **
  351: get_txt_records(struct hesiod_p *ctx, int class, const char *name) {
  352:         struct {
  353:                 int type;             /* RR type */
  354:                 int class;            /* RR class */
  355:                 int dlen;             /* len of data section */
  356:                 u_char *data;         /* pointer to data */
  357:         } rr;
  358:         HEADER *hp;
  359:         u_char qbuf[MAX_HESRESP], abuf[MAX_HESRESP];
  360:         u_char *cp, *erdata, *eom;
  361:         char *dst, *edst, **list;
  362:         int ancount, qdcount;
  363:         int i, j, n, skip;
  364: 
  365:         /*
  366:          * Construct the query and send it.
  367:          */
  368:         n = res_nmkquery(ctx->res, QUERY, name, class, T_TXT, NULL, 0,
  369:                          NULL, qbuf, MAX_HESRESP);
  370:         if (n < 0) {
  371:                 __set_errno(EMSGSIZE);
  372:                 return (NULL);
  373:         }
  374:         n = res_nsend(ctx->res, qbuf, n, abuf, MAX_HESRESP);
  375:         if (n < 0) {
  376:                 __set_errno(ECONNREFUSED);
  377:                 return (NULL);
  378:         }
  379:         if (n < HFIXEDSZ) {
  380:                 __set_errno(EMSGSIZE);
  381:                 return (NULL);
  382:         }
  383: 
  384:         /*
  385:          * OK, parse the result.
  386:          */
  387:         hp = (HEADER *) abuf;
  388:         ancount = ntohs(hp->ancount);
  389:         qdcount = ntohs(hp->qdcount);
  390:         cp = abuf + sizeof(HEADER);
  391:         eom = abuf + n;
  392: 
  393:         /* Skip query, trying to get to the answer section which follows. */
  394:         for (i = 0; i < qdcount; i++) {
  395:                 skip = dn_skipname(cp, eom);
  396:                 if (skip < 0 || cp + skip + QFIXEDSZ > eom) {
  397:                         __set_errno(EMSGSIZE);
  398:                         return (NULL);
  399:                 }
  400:                 cp += skip + QFIXEDSZ;
  401:         }
  402: 
  403:         list = malloc((ancount + 1) * sizeof(char *));
  404:         if (!list)
  405:                 return (NULL);
  406:         j = 0;
  407:         for (i = 0; i < ancount; i++) {
  408:                 skip = dn_skipname(cp, eom);
  409:                 if (skip < 0) {
  410:                         __set_errno(EMSGSIZE);
  411:                         goto cleanup;
  412:                 }
  413:                 cp += skip;
  414:                 if (cp + 3 * INT16SZ + INT32SZ > eom) {
  415:                         __set_errno(EMSGSIZE);
  416:                         goto cleanup;
  417:                 }
  418:                 rr.type = ns_get16(cp);
  419:                 cp += INT16SZ;
  420:                 rr.class = ns_get16(cp);
  421:                 cp += INT16SZ + INT32SZ;      /* skip the ttl, too */
  422:                 rr.dlen = ns_get16(cp);
  423:                 cp += INT16SZ;
  424:                 if (cp + rr.dlen > eom) {
  425:                         __set_errno(EMSGSIZE);
  426:                         goto cleanup;
  427:                 }
  428:                 rr.data = cp;
  429:                 cp += rr.dlen;
  430:                 if (rr.class != class || rr.type != T_TXT)
  431:                         continue;
  432:                 if (!(list[j] = malloc(rr.dlen)))
  433:                         goto cleanup;
  434:                 dst = list[j++];
  435:                 edst = dst + rr.dlen;
  436:                 erdata = rr.data + rr.dlen;
  437:                 cp = rr.data;
  438:                 while (cp < erdata) {
  439:                         n = (unsigned char) *cp++;
  440:                         if (cp + n > eom || dst + n > edst) {
  441:                                 __set_errno(EMSGSIZE);
  442:                                 goto cleanup;
  443:                         }
  444:                         memcpy(dst, cp, n);
  445:                         cp += n;
  446:                         dst += n;
  447:                 }
  448:                 if (cp != erdata) {
  449:                         __set_errno(EMSGSIZE);
  450:                         goto cleanup;
  451:                 }
  452:                 *dst = '\0';
  453:         }
  454:         list[j] = NULL;
  455:         if (j == 0) {
  456:                 __set_errno(ENOENT);
  457:                 goto cleanup;
  458:         }
  459:         return (list);
  460: 
  461:  cleanup:
  462:         for (i = 0; i < j; i++)
  463:                 free(list[i]);
  464:         free(list);
  465:         return (NULL);
  466: }
  467: 
  468: struct __res_state *
  469: __hesiod_res_get(void *context) {
  470:         struct hesiod_p *ctx = context;
  471: 
  472:         if (!ctx->res) {
  473:                 struct __res_state *res;
  474:                 res = (struct __res_state *)calloc(1, sizeof *res);
  475:                 if (res == NULL)
  476:                         return (NULL);
  477:                 __hesiod_res_set(ctx, res, free);
  478:         }
  479: 
  480:         return (ctx->res);
  481: }
  482: 
  483: void
  484: __hesiod_res_set(void *context, struct __res_state *res,
  485:                  void (*free_res)(void *)) {
  486:         struct hesiod_p *ctx = context;
  487: 
  488:         if (ctx->res && ctx->free_res) {
  489:                 res_nclose(ctx->res);
  490:                 (*ctx->free_res)(ctx->res);
  491:         }
  492: 
  493:         ctx->res = res;
  494:         ctx->free_res = free_res;
  495: }
  496: 
  497: static int
  498: init(struct hesiod_p *ctx) {
  499: 
  500:         if (!ctx->res && !__hesiod_res_get(ctx))
  501:                 return (-1);
  502: 
  503:         if (__res_maybe_init (ctx->res, 0) == -1)
  504:                 return (-1);
  505: 
  506:         return (0);
  507: }