hesiod/hesiod.c

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