| /* Copyright (C) 1997-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* |
| * Copyright (c) 1996,1999 by Internet Software Consortium. |
| * |
| * Permission to use, copy, modify, and distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS |
| * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE |
| * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
| * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
| * SOFTWARE. |
| */ |
| |
| /* |
| * This file is primarily maintained by <tytso@mit.edu> and <ghudson@mit.edu>. |
| */ |
| |
| /* |
| * hesiod.c --- the core portion of the hesiod resolver. |
| * |
| * This file is derived from the hesiod library from Project Athena; |
| * It has been extensively rewritten by Theodore Ts'o to have a more |
| * thread-safe interface. |
| */ |
| |
| /* Imports */ |
| |
| #include <sys/types.h> |
| #include <netinet/in.h> |
| #include <arpa/nameser.h> |
| |
| #include <errno.h> |
| #include <netdb.h> |
| #include <resolv.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "hesiod.h" |
| #include "hesiod_p.h" |
| |
| #define _PATH_HESIOD_CONF "/etc/hesiod.conf" |
| |
| /* Forward */ |
| |
| static int parse_config_file(struct hesiod_p *ctx, const char *filename); |
| static char ** get_txt_records(struct hesiod_p *ctx, int class, |
| const char *name); |
| |
| /* Public */ |
| |
| /* |
| * This function is called to initialize a hesiod_p. |
| */ |
| int |
| hesiod_init(void **context) { |
| struct hesiod_p *ctx; |
| const char *configname; |
| char *cp; |
| |
| ctx = malloc(sizeof(struct hesiod_p)); |
| if (ctx == 0) |
| return (-1); |
| |
| ctx->LHS = NULL; |
| ctx->RHS = NULL; |
| /* Set default query classes. */ |
| ctx->classes[0] = C_IN; |
| ctx->classes[1] = C_HS; |
| |
| configname = __libc_secure_getenv("HESIOD_CONFIG"); |
| if (!configname) |
| configname = _PATH_HESIOD_CONF; |
| if (parse_config_file(ctx, configname) < 0) { |
| goto cleanup; |
| } |
| /* |
| * The default RHS can be overridden by an environment |
| * variable. |
| */ |
| if ((cp = __libc_secure_getenv("HES_DOMAIN")) != NULL) { |
| free(ctx->RHS); |
| ctx->RHS = malloc(strlen(cp)+2); |
| if (!ctx->RHS) |
| goto cleanup; |
| if (cp[0] == '.') |
| strcpy(ctx->RHS, cp); |
| else { |
| ctx->RHS[0] = '.'; |
| strcpy(ctx->RHS + 1, cp); |
| } |
| } |
| |
| /* |
| * If there is no default hesiod realm set, we return an |
| * error. |
| */ |
| if (!ctx->RHS) { |
| __set_errno(ENOEXEC); |
| goto cleanup; |
| } |
| |
| *context = ctx; |
| return (0); |
| |
| cleanup: |
| hesiod_end(ctx); |
| return (-1); |
| } |
| |
| /* |
| * This function deallocates the hesiod_p |
| */ |
| void |
| hesiod_end(void *context) { |
| struct hesiod_p *ctx = (struct hesiod_p *) context; |
| int save_errno = errno; |
| |
| free(ctx->RHS); |
| free(ctx->LHS); |
| free(ctx); |
| __set_errno(save_errno); |
| } |
| |
| /* |
| * This function takes a hesiod (name, type) and returns a DNS |
| * name which is to be resolved. |
| */ |
| char * |
| hesiod_to_bind(void *context, const char *name, const char *type) { |
| struct hesiod_p *ctx = (struct hesiod_p *) context; |
| char *bindname; |
| char **rhs_list = NULL; |
| const char *RHS, *cp; |
| char *endp; |
| |
| /* Decide what our RHS is, and set cp to the end of the actual name. */ |
| if ((cp = strchr(name, '@')) != NULL) { |
| if (strchr(cp + 1, '.')) |
| RHS = cp + 1; |
| else if ((rhs_list = hesiod_resolve(context, cp + 1, |
| "rhs-extension")) != NULL) |
| RHS = *rhs_list; |
| else { |
| __set_errno(ENOENT); |
| return (NULL); |
| } |
| } else { |
| RHS = ctx->RHS; |
| cp = name + strlen(name); |
| } |
| |
| /* |
| * Allocate the space we need, including up to three periods and |
| * the terminating NUL. |
| */ |
| if ((bindname = malloc((cp - name) + strlen(type) + strlen(RHS) + |
| (ctx->LHS ? strlen(ctx->LHS) : 0) + 4)) == NULL) { |
| if (rhs_list) |
| hesiod_free_list(context, rhs_list); |
| return NULL; |
| } |
| |
| /* Now put together the DNS name. */ |
| endp = (char *) __mempcpy (bindname, name, cp - name); |
| *endp++ = '.'; |
| endp = (char *) __stpcpy (endp, type); |
| if (ctx->LHS) { |
| if (ctx->LHS[0] != '.') |
| *endp++ = '.'; |
| endp = __stpcpy (endp, ctx->LHS); |
| } |
| if (RHS[0] != '.') |
| *endp++ = '.'; |
| strcpy (endp, RHS); |
| |
| if (rhs_list) |
| hesiod_free_list(context, rhs_list); |
| |
| return (bindname); |
| } |
| |
| /* |
| * This is the core function. Given a hesiod (name, type), it |
| * returns an array of strings returned by the resolver. |
| */ |
| char ** |
| hesiod_resolve(void *context, const char *name, const char *type) { |
| struct hesiod_p *ctx = (struct hesiod_p *) context; |
| char *bindname = hesiod_to_bind(context, name, type); |
| char **retvec; |
| |
| if (bindname == NULL) |
| return (NULL); |
| |
| retvec = get_txt_records(ctx, ctx->classes[0], bindname); |
| |
| if (retvec == NULL && (errno == ENOENT || errno == ECONNREFUSED) && ctx->classes[1]) |
| retvec = get_txt_records(ctx, ctx->classes[1], bindname); |
| |
| |
| free(bindname); |
| return (retvec); |
| } |
| |
| void |
| hesiod_free_list(void *context, char **list) { |
| char **p; |
| |
| for (p = list; *p; p++) |
| free(*p); |
| free(list); |
| } |
| |
| /* |
| * This function parses the /etc/hesiod.conf file |
| */ |
| static int |
| parse_config_file(struct hesiod_p *ctx, const char *filename) { |
| char buf[MAXDNAME+7]; |
| FILE *fp; |
| |
| /* |
| * Clear the existing configuration variable, just in case |
| * they're set. |
| */ |
| free(ctx->RHS); |
| free(ctx->LHS); |
| ctx->RHS = ctx->LHS = 0; |
| /* Set default query classes. */ |
| ctx->classes[0] = C_IN; |
| ctx->classes[1] = C_HS; |
| |
| /* |
| * Now open and parse the file... |
| */ |
| if (!(fp = fopen(filename, "rce"))) |
| return (-1); |
| |
| while (fgets(buf, sizeof(buf), fp) != NULL) { |
| char *key, *data, *cp, **cpp; |
| |
| cp = buf; |
| if (*cp == '#' || *cp == '\n' || *cp == '\r') |
| continue; |
| while(*cp == ' ' || *cp == '\t') |
| cp++; |
| key = cp; |
| while(*cp != ' ' && *cp != '\t' && *cp != '=') |
| cp++; |
| *cp++ = '\0'; |
| |
| while(*cp == ' ' || *cp == '\t' || *cp == '=') |
| cp++; |
| data = cp; |
| while(*cp != ' ' && *cp != '\n' && *cp != '\r') |
| cp++; |
| *cp++ = '\0'; |
| |
| cpp = NULL; |
| if (strcasecmp(key, "lhs") == 0) |
| cpp = &ctx->LHS; |
| else if (strcasecmp(key, "rhs") == 0) |
| cpp = &ctx->RHS; |
| if (cpp) { |
| *cpp = strdup(data); |
| if (!*cpp) |
| goto cleanup; |
| } else if (strcasecmp(key, "classes") == 0) { |
| int n = 0; |
| while (*data && n < 2) { |
| cp = strchrnul(data, ','); |
| if (*cp != '\0') |
| *cp++ = '\0'; |
| if (strcasecmp(data, "IN") == 0) |
| ctx->classes[n++] = C_IN; |
| else if (strcasecmp(data, "HS") == 0) |
| ctx->classes[n++] = C_HS; |
| data = cp; |
| } |
| if (n == 0) { |
| /* Restore the default. Better than |
| nother at all. */ |
| ctx->classes[0] = C_IN; |
| ctx->classes[1] = C_HS; |
| } else if (n == 1 |
| || ctx->classes[0] == ctx->classes[1]) |
| ctx->classes[1] = 0; |
| } |
| } |
| fclose(fp); |
| return (0); |
| |
| cleanup: |
| fclose(fp); |
| free(ctx->RHS); |
| free(ctx->LHS); |
| ctx->RHS = ctx->LHS = 0; |
| return (-1); |
| } |
| |
| /* |
| * Given a DNS class and a DNS name, do a lookup for TXT records, and |
| * return a list of them. |
| */ |
| static char ** |
| get_txt_records(struct hesiod_p *ctx, int class, const char *name) { |
| struct { |
| int type; /* RR type */ |
| int class; /* RR class */ |
| int dlen; /* len of data section */ |
| u_char *data; /* pointer to data */ |
| } rr; |
| HEADER *hp; |
| u_char qbuf[MAX_HESRESP], abuf[MAX_HESRESP]; |
| u_char *cp, *erdata, *eom; |
| char *dst, *edst, **list; |
| int ancount, qdcount; |
| int i, j, n, skip; |
| |
| /* |
| * Construct the query and send it. |
| */ |
| n = res_mkquery(QUERY, name, class, T_TXT, NULL, 0, |
| NULL, qbuf, MAX_HESRESP); |
| if (n < 0) { |
| __set_errno(EMSGSIZE); |
| return (NULL); |
| } |
| n = res_send(qbuf, n, abuf, MAX_HESRESP); |
| if (n < 0) { |
| __set_errno(ECONNREFUSED); |
| return (NULL); |
| } |
| if (n < HFIXEDSZ) { |
| __set_errno(EMSGSIZE); |
| return (NULL); |
| } |
| |
| /* |
| * OK, parse the result. |
| */ |
| hp = (HEADER *) abuf; |
| ancount = ntohs(hp->ancount); |
| qdcount = ntohs(hp->qdcount); |
| cp = abuf + sizeof(HEADER); |
| eom = abuf + n; |
| |
| /* Skip query, trying to get to the answer section which follows. */ |
| for (i = 0; i < qdcount; i++) { |
| skip = dn_skipname(cp, eom); |
| if (skip < 0 || cp + skip + QFIXEDSZ > eom) { |
| __set_errno(EMSGSIZE); |
| return (NULL); |
| } |
| cp += skip + QFIXEDSZ; |
| } |
| |
| list = malloc((ancount + 1) * sizeof(char *)); |
| if (!list) |
| return (NULL); |
| j = 0; |
| for (i = 0; i < ancount; i++) { |
| skip = dn_skipname(cp, eom); |
| if (skip < 0) { |
| __set_errno(EMSGSIZE); |
| goto cleanup; |
| } |
| cp += skip; |
| if (cp + 3 * INT16SZ + INT32SZ > eom) { |
| __set_errno(EMSGSIZE); |
| goto cleanup; |
| } |
| rr.type = ns_get16(cp); |
| cp += INT16SZ; |
| rr.class = ns_get16(cp); |
| cp += INT16SZ + INT32SZ; /* skip the ttl, too */ |
| rr.dlen = ns_get16(cp); |
| cp += INT16SZ; |
| if (rr.dlen == 0 || cp + rr.dlen > eom) { |
| __set_errno(EMSGSIZE); |
| goto cleanup; |
| } |
| rr.data = cp; |
| cp += rr.dlen; |
| if (rr.class != class || rr.type != T_TXT) |
| continue; |
| if (!(list[j] = malloc(rr.dlen))) |
| goto cleanup; |
| dst = list[j++]; |
| edst = dst + rr.dlen; |
| erdata = rr.data + rr.dlen; |
| cp = rr.data; |
| while (cp < erdata) { |
| n = (unsigned char) *cp++; |
| if (cp + n > eom || dst + n > edst) { |
| __set_errno(EMSGSIZE); |
| goto cleanup; |
| } |
| memcpy(dst, cp, n); |
| cp += n; |
| dst += n; |
| } |
| if (cp != erdata) { |
| __set_errno(EMSGSIZE); |
| goto cleanup; |
| } |
| *dst = '\0'; |
| } |
| list[j] = NULL; |
| if (j == 0) { |
| __set_errno(ENOENT); |
| goto cleanup; |
| } |
| return (list); |
| |
| cleanup: |
| for (i = 0; i < j; i++) |
| free(list[i]); |
| free(list); |
| return (NULL); |
| } |