From 61eb22d3a8e9bb9c339bdbe907a85656823f4c7e Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Tue, 16 Sep 1997 00:42:43 +0000 Subject: Update. 1997-09-16 02:14 Ulrich Drepper Implementation of Hesiod NSS module by Mark Kettenis. * hesiod/Makefile: New file. * hesiod/hesiod.c: New file. * hesiod/hesiod.h: New file. * hesiod/hesiod_p.h: New file. * hesiod/libnss_hesiod.map: New file. * hesiod/nss_hesiod/hesiod-grp.c: New file. * hesiod/nss_hesiod/hesiod-pwd.c: New file. * hesiod/nss_hesiod/hesiod-service.c: New file. * sysdeps/unix/inet/Subdirs: Add hesiod. * shlib-versions: Add version number for libnss_hesiod. * libio/iolibio.h: Remove definition of _IO_* macros. * libio/fileops.c: Define close, fstat, lseek, read, and write as macros to use __ protected versions. Use those functions instead of _IO_* functions. * libio/iopopen.c: Define _IO_close to close. * manual/math.texi: Explain the use of the optimizing inline functions. Describe rand_r function and tell about SysV RNGs in introduction. * resolv/res_send.c (res_send): Use socklen_t type for `fromlen' variable. * string/Makefile (tests): Add noinl-tester. * string/noinl-tester.c: New file. * string/tester.c: Add more stpcpy tests for constant arguments for all short lengths. * string/string.h: Always declare __bzero. Describe __NO_STRING_INLINES. Always include . * string/bits/string2.h: Add warning about direct use. Change __strcpy_small and __stpcpy_small implementation to use macros and provide alternative for platforms which cannot do unaligned stores. * sysdeps/i386/bits/string.h: Don't define anything is __NO_STRING_INLINES is defined. * sysdeps/i386/i486/bits/string.h: Change __strcpy_small and __stpcpy_small implementation to use macros and provide alternative for platforms which cannot do unaligned stores. * sysdeps/alpha/bzero.S: Define bzero as weak alias of __bzero. * sysdeps/generic/bzero.c: Likewise. * sysdeps/i386/bzero.c: Likewise. * sysdeps/i386/i586/bzero.S: Likewise. * sysdeps/vax/bzero.s: Likewise. * sysdeps/generic/bits/select.h: Don't use ugly casts to access array. * sysdeps/i386/bits/select.h: Likewise. * sysdeps/i386/fpu/bits/mathinline.c (__finite): Relax register constraints a bit. Don't define and test for _BITS_MATHINLINE_H. Emit warning if used directly and not through math.h. * sysdeps/i386/i486/atomicity.h: Change return type of compare_and_swap to char to get better code. Fix typo. * sysdeps/stub/atomicity.h: Fix typo. 1997-09-14 Andreas Schwab * sysdeps/generic/stpcpy.c: #undef stpcpy and __stpcpy. 1997-09-14 Andreas Schwab * string/bits/string2.h: Add prototypes to avoid warning. 1997-09-14 Andreas Schwab * string/bits/string2.h (strsep): Fix handling of empty REJECT. (__strsep_1c): Handle NULL and empty string. (__strsep_g): Likewise. 1997-09-13 Andreas Schwab * catgets/Makefile (extra-objs): Set this instead of generated. * md5-crypt/Makefile (extra-objs): Add all object file variants of onlymd5-entry. 1997-09-12 Andreas Schwab * sysdeps/generic/sysd-stdio.c (__stdio_read): Fix typo in last change. 1997-09-12 Andreas Schwab * sysdeps/m68k/m68020/atomicity.h: New file. 1997-09-15 05:11 Ulrich Drepper * posix/Makefile (distribute): Add globtest.c and globtest.sh. Compile and run globtest if not cross-compiling. * posix/globtest.c: New file. * posix/globtest.sh: New file. * posix/glob.c: Pretty print preprocessor stuff. (glob_in_dir): If PATTERN is not really a pattern still check whether it is a real file in the current directory and return error if not. Reported by Eugene Mamchits . * libio/fileops.c (_IO_file_sync): Acquire lock before doing the work. * libio/ioseekoff.c (_IO_seekoff): Likewise. * libio/ioseekpos.c (_IO_seekpos): Likewise. 1997-09-13 18:06 Ulrich Drepper * configure.in: Prevent configuration for unsupported platforms. 1997-09-13 04:07 Ulrich Drepper * elf/rtld.c (dl_main): Make sure we always have a file argument by testing for < 2 arguments after recognizing the options. 1997-09-12 11:47 Fila Kolodny * string/bits/string2.h (__strsep_1c): Cast out const from __retval. (__strsep_g): Likewise. --- hesiod/hesiod.c | 470 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 470 insertions(+) create mode 100644 hesiod/hesiod.c (limited to 'hesiod/hesiod.c') diff --git a/hesiod/hesiod.c b/hesiod/hesiod.c new file mode 100644 index 0000000000..8e95dfb393 --- /dev/null +++ b/hesiod/hesiod.c @@ -0,0 +1,470 @@ +/* Copyright (c) 1996 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. + */ + +/* Copyright 1996 by the Massachusetts Institute of Technology. + * + * Permission to use, copy, modify, and distribute this + * software and its documentation for any purpose and without + * fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting + * documentation, and that the name of M.I.T. not be used in + * advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. + * M.I.T. makes no representations about the suitability of + * this software for any purpose. It is provided "as is" + * without express or implied warranty. + */ + +/* This file is part of the hesiod library. It implements the core + * portion of the hesiod resolver. + * + * This file is loosely based on an interim version of hesiod.c from + * the BIND IRS library, which was in turn based on an earlier version + * of this file. Extensive changes have been made on each step of the + * path. + * + * This implementation is not truly thread-safe at the moment because + * it uses res_send() and accesses _res. + */ + +static const char rcsid[] = "$Id$"; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "hesiod.h" +#include "hesiod_p.h" + +/* A few operating systems don't define these. */ +#ifndef C_HS +#define C_HS 4 +#endif +#ifndef T_TXT +#define T_TXT 16 +#endif + +static int read_config_file(struct hesiod_p *ctx, const char *filename); +static char **get_txt_records(struct hesiod_p *ctx, int class, + const char *name); +static int cistrcmp(const char *s1, const char *s2); + +/* This function is called to initialize a hesiod_p. */ +int hesiod_init(void **context) +{ + struct hesiod_p *ctx; + const char *p, *configname; + + ctx = malloc(sizeof(struct hesiod_p)); + if (ctx) + { + *context = ctx; + configname = __secure_getenv("HESIOD_CONFIG"); + if (!configname) + configname = SYSCONFDIR "/hesiod.conf"; + if (read_config_file(ctx, configname) >= 0) + { + /* The default rhs can be overridden by an environment variable. */ + p = __secure_getenv("HES_DOMAIN"); + if (p) + { + if (ctx->rhs) + free(ctx->rhs); + ctx->rhs = malloc(strlen(p) + 2); + if (ctx->rhs) + { + *ctx->rhs = '.'; + strcpy(ctx->rhs + 1, (*p == '.') ? p + 1 : p); + return 0; + } + else + __set_errno (ENOMEM); + } + else + return 0; + } + } + else + __set_errno (ENOMEM); + + if (ctx->lhs) + free(ctx->lhs); + if (ctx->rhs) + free(ctx->rhs); + if (ctx) + free(ctx); + return -1; +} + +/* This function deallocates the hesiod_p. */ +void hesiod_end(void *context) +{ + struct hesiod_p *ctx = (struct hesiod_p *) context; + + free(ctx->rhs); + if (ctx->lhs) + free(ctx->lhs); + free(ctx); +} + +/* 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[MAXDNAME], *p, *ret, **rhs_list = NULL; + const char *rhs; + int len; + + strcpy(bindname, name); + + /* Find the right right hand side to use, possibly truncating bindname. */ + p = strchr(bindname, '@'); + if (p) + { + *p++ = 0; + if (strchr(p, '.')) + rhs = name + (p - bindname); + else + { + rhs_list = hesiod_resolve(context, p, "rhs-extension"); + if (rhs_list) + rhs = *rhs_list; + else + { + __set_errno (ENOENT); + return NULL; + } + } + } else + rhs = ctx->rhs; + + /* See if we have enough room. */ + len = strlen(bindname) + 1 + strlen(type); + if (ctx->lhs) + len += strlen(ctx->lhs) + ((ctx->lhs[0] != '.') ? 1 : 0); + len += strlen(rhs) + ((rhs[0] != '.') ? 1 : 0); + if (len > sizeof(bindname) - 1) + { + if (rhs_list) + hesiod_free_list(context, rhs_list); + __set_errno (EMSGSIZE); + return NULL; + } + + /* Put together the rest of the domain. */ + strcat(bindname, "."); + strcat(bindname, type); + if (ctx->lhs) + { + if (ctx->lhs[0] != '.') + strcat(bindname, "."); + strcat(bindname, ctx->lhs); + } + if (rhs[0] != '.') + strcat(bindname, "."); + strcat(bindname, rhs); + + /* rhs_list is no longer needed, since we're done with rhs. */ + if (rhs_list) + hesiod_free_list(context, rhs_list); + + /* Make a copy of the result and return it to the caller. */ + ret = malloc(strlen(bindname) + 1); + if (!ret) + { + __set_errno (ENOMEM); + return NULL; + } + strcpy(ret, bindname); + return ret; +} + +/* This is the core function. Given a hesiod name and 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, **retvec; + + bindname = hesiod_to_bind(context, name, type); + if (!bindname) + return NULL; + + retvec = get_txt_records(ctx, ctx->classes[0], bindname); + if (retvec == NULL && errno == ENOENT && 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. Returns 0 on success, + * -1 on failure. On failure, it might leave values in ctx->lhs or + * ctx->rhs which need to be freed by the caller. */ +static int read_config_file(struct hesiod_p *ctx, const char *filename) +{ + char *key, *data, *p, **which; + char buf[MAXDNAME + 7]; + int n; + FILE *fp; + + /* Set default query classes. */ + ctx->classes[0] = C_IN; + ctx->classes[1] = C_HS; + + /* Try to open the configuration file. */ + fp = fopen(filename, "r"); + if (!fp) + { + /* Use compiled in default domain names. */ + ctx->lhs = malloc(strlen(DEF_LHS) + 1); + ctx->rhs = malloc(strlen(DEF_RHS) + 1); + if (ctx->lhs && ctx->rhs) + { + strcpy(ctx->lhs, DEF_LHS); + strcpy(ctx->rhs, DEF_RHS); + return 0; + } + else + { + __set_errno (ENOMEM); + return -1; + } + } + + ctx->lhs = NULL; + ctx->rhs = NULL; + while (fgets(buf, sizeof(buf), fp) != NULL) + { + p = buf; + if (*p == '#' || *p == '\n' || *p == '\r') + continue; + while(*p == ' ' || *p == '\t') + p++; + key = p; + while(*p != ' ' && *p != '\t' && *p != '=') + p++; + *p++ = 0; + + while(isspace(*p) || *p == '=') + p++; + data = p; + while(!isspace(*p)) + p++; + *p = 0; + + if (cistrcmp(key, "lhs") == 0 || cistrcmp(key, "rhs") == 0) + { + which = (strcmp(key, "lhs") == 0) ? &ctx->lhs : &ctx->rhs; + *which = malloc(strlen(data) + 1); + if (!*which) + { + __set_errno (ENOMEM); + return -1; + } + strcpy(*which, data); + } + else if (cistrcmp(key, "classes") == 0) + { + n = 0; + while (*data && n < 2) + { + p = data; + while (*p && *p != ',') + p++; + if (*p) + *p++ = 0; + if (cistrcmp(data, "IN") == 0) + ctx->classes[n++] = C_IN; + else if (cistrcmp(data, "HS") == 0) + ctx->classes[n++] = C_HS; + data = p; + } + while (n < 2) + ctx->classes[n++] = 0; + } + } + fclose(fp); + + if (!ctx->rhs || ctx->classes[0] == 0 || ctx->classes[0] == ctx->classes[1]) + { + __set_errno (ENOEXEC); + return -1; + } + + return 0; +} + +/* 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 qclass, + const char *name) +{ + HEADER *hp; + unsigned char qbuf[PACKETSZ], abuf[MAX_HESRESP], *p, *eom, *eor; + char *dst, **list; + int ancount, qdcount, i, j, n, skip, type, class, len; + + /* Make sure the resolver is initialized. */ + if ((_res.options & RES_INIT) == 0 && res_init() == -1) + return NULL; + + /* Construct the query. */ + n = res_mkquery(QUERY, name, qclass, T_TXT, NULL, 0, + NULL, qbuf, PACKETSZ); + if (n < 0) + return NULL; + + /* Send the query. */ + n = res_send(qbuf, n, abuf, MAX_HESRESP); + if (n < 0) + { + __set_errno (ECONNREFUSED); + return NULL; + } + + /* Parse the header of the result. */ + hp = (HEADER *) abuf; + ancount = ntohs(hp->ancount); + qdcount = ntohs(hp->qdcount); + p = abuf + sizeof(HEADER); + eom = abuf + n; + + /* Skip questions, trying to get to the answer section which follows. */ + for (i = 0; i < qdcount; i++) + { + skip = dn_skipname(p, eom); + if (skip < 0 || p + skip + QFIXEDSZ > eom) + { + __set_errno (EMSGSIZE); + return NULL; + } + p += skip + QFIXEDSZ; + } + + /* Allocate space for the text record answers. */ + list = malloc((ancount + 1) * sizeof(char *)); + if (!list) + { + __set_errno (ENOMEM); + return NULL; + } + + /* Parse the answers. */ + j = 0; + for (i = 0; i < ancount; i++) + { + /* Parse the header of this answer. */ + skip = dn_skipname(p, eom); + if (skip < 0 || p + skip + 10 > eom) + break; + type = p[skip + 0] << 8 | p[skip + 1]; + class = p[skip + 2] << 8 | p[skip + 3]; + len = p[skip + 8] << 8 | p[skip + 9]; + p += skip + 10; + if (p + len > eom) + { + __set_errno (EMSGSIZE); + break; + } + + /* Skip entries of the wrong class and type. */ + if (class != qclass || type != T_TXT) + { + p += len; + continue; + } + + /* Allocate space for this answer. */ + list[j] = malloc(len); + if (!list[j]) + { + __set_errno (ENOMEM); + break; + } + dst = list[j++]; + + /* Copy answer data into the allocated area. */ + eor = p + len; + while (p < eor) + { + n = (unsigned char) *p++; + if (p + n > eor) + { + __set_errno (EMSGSIZE); + break; + } + memcpy(dst, p, n); + p += n; + dst += n; + } + if (p < eor) + { + __set_errno (EMSGSIZE); + break; + } + *dst = 0; + } + + /* If we didn't terminate the loop normally, something went wrong. */ + if (i < ancount) + { + for (i = 0; i < j; i++) + free(list[i]); + free(list); + return NULL; + } + + if (j == 0) + { + __set_errno (ENOENT); + free(list); + return NULL; + } + + list[j] = NULL; + return list; +} + +static int cistrcmp(const char *s1, const char *s2) +{ + while (*s1 && tolower(*s1) == tolower(*s2)) + { + s1++; + s2++; + } + return tolower(*s1) - tolower(*s2); +} -- cgit 1.4.1