-/* Copyright (c) 1996 by Internet Software Consortium.
+/* Copyright (C) 1997-2019 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
+ <https://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
* 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 primarily maintained by <tytso@mit.edu> and <ghudson@mit.edu>.
*/
-/* 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.
+/*
+ * hesiod.c --- the core portion of the hesiod resolver.
*
- * This implementation is not truly thread-safe at the moment because
- * it uses res_send() and accesses _res.
+ * 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.
*/
-static const char rcsid[] = "$Id$";
+/* 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 <ctype.h>
+
#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);
-#ifdef _LIBC
-# define cistrcmp(s1, s2) strcasecmp (s1, s2)
-#else
-static int cistrcmp(const char *s1, const char *s2);
-#endif
-
-/* 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;
+#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);
}
- 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;
+ /*
+ * If there is no default hesiod realm set, we return an
+ * error.
+ */
+ if (!ctx->RHS) {
+ __set_errno(ENOEXEC);
+ goto cleanup;
+ }
+
+ *context = ctx;
+ return (0);
- free(ctx->rhs);
- if (ctx->lhs)
- free(ctx->lhs);
- free(ctx);
+ cleanup:
+ hesiod_end(ctx);
+ return (-1);
}
-/* This function takes a hesiod (name, type) and returns a DNS
+/*
+ * 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[MAXDNAME], *p, *endp, *ret, **rhs_list = NULL;
- const char *rhs;
- size_t len;
-
- endp = stpcpy(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;
- }
+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;
}
- } else
- rhs = ctx->rhs;
-
- /* See if we have enough room. */
- len = (endp - 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. */
- endp = __stpcpy (__stpcpy (endp, "."), type);
- if (ctx->lhs)
- {
- if (ctx->lhs[0] != '.')
- endp = __stpcpy (endp, ".");
- endp = __stpcpy (endp, ctx->lhs);
- }
- if (rhs[0] != '.')
- endp = __stpcpy (endp, ".");
- endp = __stpcpy (endp, 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((endp - bindname) + 1);
- if (!ret)
- {
- __set_errno (ENOMEM);
- return NULL;
- }
- strcpy(ret, bindname);
- return ret;
+
+ /* 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 and type, it
+/*
+ * 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, **retvec;
+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;
- bindname = hesiod_to_bind(context, name, type);
- if (!bindname)
- return NULL;
+ if (bindname == NULL)
+ 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);
+ retvec = get_txt_records(ctx, ctx->classes[0], bindname);
- free(bindname);
- return retvec;
-}
+ if (retvec == NULL && (errno == ENOENT || errno == ECONNREFUSED) && ctx->classes[1])
+ retvec = get_txt_records(ctx, ctx->classes[1], bindname);
-void hesiod_free_list(void *context, char **list)
-{
- char **p;
- for (p = list; *p; p++)
- free(*p);
- free(list);
+ free(bindname);
+ return (retvec);
}
-/* 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);
+void
+hesiod_free_list(void *context, char **list) {
+ char **p;
- if (!ctx->rhs || ctx->classes[0] == 0 || ctx->classes[0] == ctx->classes[1])
- {
- __set_errno (ENOEXEC);
- return -1;
- }
+ for (p = list; *p; p++)
+ free(*p);
+ free(list);
+}
- return 0;
+/*
+ * 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
+/*
+ * 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;
+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);
}
- 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;
+ n = res_send(qbuf, n, abuf, MAX_HESRESP);
+ if (n < 0) {
+ __set_errno(ECONNREFUSED);
+ return (NULL);
}
-
- /* Skip entries of the wrong class and type. */
- if (class != qclass || type != T_TXT)
- {
- p += len;
- continue;
+ if (n < HFIXEDSZ) {
+ __set_errno(EMSGSIZE);
+ return (NULL);
}
- /* Allocate space for this answer. */
- list[j] = malloc(len);
- if (!list[j])
- {
- __set_errno (ENOMEM);
- break;
+ /*
+ * 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;
}
- 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;
+
+ 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';
}
- if (p < eor)
- {
- __set_errno (EMSGSIZE);
- break;
+ list[j] = NULL;
+ if (j == 0) {
+ __set_errno(ENOENT);
+ goto cleanup;
}
- *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;
-}
+ return (list);
-#ifndef _LIBC
-static int cistrcmp(const char *s1, const char *s2)
-{
- while (*s1 && tolower(*s1) == tolower(*s2))
- {
- s1++;
- s2++;
- }
- return tolower(*s1) - tolower(*s2);
+ cleanup:
+ for (i = 0; i < j; i++)
+ free(list[i]);
+ free(list);
+ return (NULL);
}
-#endif
projects / thirdparty / glibc.git / blobdiff