1 files changed, 133 insertions, 92 deletions

diff --git a/src/lib/libc/net/res_query.c b/src/lib/libc/net/res_query.c
index 7649462e56..3cdb7a7477 100644
--- a/src/lib/libc/net/res_query.c
+++ b/src/lib/libc/net/res_query.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $        */
+/*      $OpenBSD: res_query.c,v 1.21 2003/06/02 20:18:36 millert Exp $  */
 
-/*-
+/*
+ * ++Copyright++ 1988, 1993
+ * -
  * Copyright (c) 1988, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    The Regents of the University of California.  All rights reserved.
+ * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -12,14 +14,10 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
- *
+ * 
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -56,23 +54,28 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char sccsid[] = "@(#)res_query.c 8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: res_query.c,v 1.1 1993/06/01 09:42:14 vixie Exp vixie ";
+static char rcsid[] = "$From: res_query.c,v 8.9 1996/09/22 00:13:28 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_query.c,v 1.21 2003/06/02 20:18:36 millert Exp $";
 #endif
 #endif /* LIBC_SCCS and not lint */
 
+#include <sys/types.h>
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <arpa/nameser.h>
+
+#include <stdio.h>
 #include <netdb.h>
 #include <resolv.h>
-#include <stdio.h>
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#include "thread_private.h"
 
 #if PACKETSZ > 1024
 #define MAXPACKET       PACKETSZ
@@ -80,8 +83,9 @@ static char rcsid[] = "$NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $"
 #define MAXPACKET       1024
 #endif
 
-char *__hostalias __P((const char *));
+const char *hostalias(const char *);
 int h_errno;
+extern int res_opt(int, u_char *, int, int);
 
 /*
  * Formulate a normal query, send, and await answer.
@@ -90,68 +94,79 @@ int h_errno;
  * if no error is indicated and the answer count is nonzero.
  * Return the size of the response on success, -1 on error.
  * Error number is left in h_errno.
+ *
  * Caller must parse answer and determine whether it answers the question.
  */
+int
 res_query(name, class, type, answer, anslen)
-        char *name;             /* domain name */
+        const char *name;       /* domain name */
         int class, type;        /* class and type of query */
         u_char *answer;         /* buffer to put answer */
         int anslen;             /* size of answer buffer */
 {
-        char buf[MAXPACKET];
-        HEADER *hp;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        u_char buf[MAXPACKET];
+        register HEADER *hp = (HEADER *) answer;
         int n;
 
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
+        hp->rcode = NOERROR;    /* default */
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
+                h_errno = NETDB_INTERNAL;
                 return (-1);
+        }
 #ifdef DEBUG
-        if (_res.options & RES_DEBUG)
+        if (_resp->options & RES_DEBUG)
                 printf(";; res_query(%s, %d, %d)\n", name, class, type);
 #endif
-        n = res_mkquery(QUERY, name, class, type, (char *)NULL, 0, NULL,
-            buf, sizeof(buf));
+
+        n = res_mkquery(QUERY, name, class, type, NULL, 0, NULL,
+                        buf, sizeof(buf));
+        if (n > 0 && ((_resp->options & RES_USE_EDNS0) ||
+            (_resp->options & RES_USE_DNSSEC))) {
+                n = res_opt(n, buf, sizeof(buf), anslen);
+        }
 
         if (n <= 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
+                if (_resp->options & RES_DEBUG)
                         printf(";; res_query: mkquery failed\n");
 #endif
                 h_errno = NO_RECOVERY;
                 return (n);
         }
-        n = res_send(buf, n, (char *)answer, anslen);
+        n = res_send(buf, n, answer, anslen);
         if (n < 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
+                if (_resp->options & RES_DEBUG)
                         printf(";; res_query: send error\n");
 #endif
                 h_errno = TRY_AGAIN;
                 return (n);
         }
 
-        hp = (HEADER *) answer;
         if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
-                        printf(";; rcode = %d, ancount=%d\n", hp->rcode,
+                if (_resp->options & RES_DEBUG)
+                        printf(";; rcode = %u, ancount=%u\n", hp->rcode,
                             ntohs(hp->ancount));
 #endif
                 switch (hp->rcode) {
-                        case NXDOMAIN:
-                                h_errno = HOST_NOT_FOUND;
-                                break;
-                        case SERVFAIL:
-                                h_errno = TRY_AGAIN;
-                                break;
-                        case NOERROR:
-                                h_errno = NO_DATA;
-                                break;
-                        case FORMERR:
-                        case NOTIMP:
-                        case REFUSED:
-                        default:
-                                h_errno = NO_RECOVERY;
-                                break;
+                case NXDOMAIN:
+                        h_errno = HOST_NOT_FOUND;
+                        break;
+                case SERVFAIL:
+                        h_errno = TRY_AGAIN;
+                        break;
+                case NOERROR:
+                        h_errno = NO_DATA;
+                        break;
+                case FORMERR:
+                case NOTIMP:
+                case REFUSED:
+                default:
+                        h_errno = NO_RECOVERY;
+                        break;
                 }
                 return (-1);
         }
@@ -162,9 +177,7 @@ res_query(name, class, type, answer, anslen)
  * Formulate a normal query, send, and retrieve answer in supplied buffer.
  * Return the size of the response on success, -1 on error.
  * If enabled, implement search rules until answer or unrecoverable failure
- * is detected.  Error number is left in h_errno.
- * Only useful for queries in the same name hierarchy as the local host
- * (not, for example, for host address-to-name lookups in domain in-addr.arpa).
+ * is detected.  Error code, if any, is left in h_errno.
  */
 int
 res_search(name, class, type, answer, anslen)
@@ -173,28 +186,30 @@ res_search(name, class, type, answer, anslen)
         u_char *answer;         /* buffer to put answer */
         int anslen;             /* size of answer */
 {
-        register char *cp, **domain;
-        int dots, trailing_dot, ret, got_nodata, saved_herrno, tried_as_is;
+        register const char *cp, * const *domain;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        HEADER *hp = (HEADER *) answer;
+        u_int dots;
+        int trailing_dot, ret, saved_herrno;
+        int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
 
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
+                h_errno = NETDB_INTERNAL;
                 return (-1);
-
-        got_nodata = 0;
+        }
         errno = 0;
         h_errno = HOST_NOT_FOUND;       /* default, if we never query */
         dots = 0;
-        for (cp = (char *)name; *cp; cp++) {
-                if (*cp == '.')
-                        dots++;
-        }
+        for (cp = name; *cp; cp++)
+                dots += (*cp == '.');
         trailing_dot = 0;
-        if ((cp > name) && (*--cp == '.'))
+        if (cp > name && *--cp == '.')
                 trailing_dot++;
 
         /*
          * if there aren't any dots, it could be a user-level alias
          */
-        if (!dots && (cp = __hostalias(name)))
+        if (!dots && (cp = __hostalias(name)) != NULL)
                 return (res_query(cp, class, type, answer, anslen));
 
         /*
@@ -202,8 +217,7 @@ res_search(name, class, type, answer, anslen)
          * 'as is'.  The threshold can be set with the "ndots" option.
          */
         saved_herrno = -1;
-        tried_as_is = 0;
-        if (dots >= _res.ndots) {
+        if (dots >= _resp->ndots) {
                 ret = res_querydomain(name, NULL, class, type, answer, anslen);
                 if (ret > 0)
                         return (ret);
@@ -217,15 +231,19 @@ res_search(name, class, type, answer, anslen)
          *      - there is at least one dot, there is no trailing dot,
          *        and RES_DNSRCH is set.
          */
-        if ((!dots && (_res.options & RES_DEFNAMES)) ||
-            (dots && !trailing_dot && (_res.options & RES_DNSRCH))) {
-                for (domain = _res.dnsrch; *domain; domain++) {
-                        int done = 0;
+        if ((!dots && (_resp->options & RES_DEFNAMES)) ||
+            (dots && !trailing_dot && (_resp->options & RES_DNSRCH))) {
+                int done = 0;
+
+                for (domain = (const char * const *)_resp->dnsrch;
+                     *domain && !done;
+                     domain++) {
 
                         ret = res_querydomain(name, *domain, class, type,
-                            answer, anslen);
+                                              answer, anslen);
                         if (ret > 0)
                                 return (ret);
+
                         /*
                          * If no server present, give up.
                          * If name isn't found in this domain,
@@ -251,24 +269,27 @@ res_search(name, class, type, answer, anslen)
                         case HOST_NOT_FOUND:
                                 /* keep trying */
                                 break;
+                        case TRY_AGAIN:
+                                if (hp->rcode == SERVFAIL) {
+                                        /* try next search element, if any */
+                                        got_servfail++;
+                                        break;
+                                }
+                                /* FALLTHROUGH */
                         default:
                                 /* anything else implies that we're done */
                                 done++;
                         }
-                        /*
-                         * if we got here for some reason other than DNSRCH,
+
+                        /* if we got here for some reason other than DNSRCH,
                          * we only wanted one iteration of the loop, so stop.
                          */
-                        if (!(_res.options & RES_DNSRCH))
-                                done++;
-
-                        if (done)
-                                break;
+                        if (!(_resp->options & RES_DNSRCH))
+                                done++;
                 }
         }
 
-        /*
-         * if we have not already tried the name "as is", do that now.
+        /* if we have not already tried the name "as is", do that now.
          * note that we do this regardless of how many dots were in the
          * name or whether it ends with a dot.
          */
@@ -276,11 +297,9 @@ res_search(name, class, type, answer, anslen)
                 ret = res_querydomain(name, NULL, class, type, answer, anslen);
                 if (ret > 0)
                         return (ret);
-                saved_herrno = h_errno;
         }
 
-        /*
-         * if we got here, we didn't satisfy the search.
+        /* if we got here, we didn't satisfy the search.
          * if we did an initial full query, return that query's h_errno
          * (note that we wouldn't be here if that query had succeeded).
          * else if we ever got a nodata, send that back as the reason.
@@ -291,6 +310,8 @@ res_search(name, class, type, answer, anslen)
                 h_errno = saved_herrno;
         else if (got_nodata)
                 h_errno = NO_DATA;
+        else if (got_servfail)
+                h_errno = TRY_AGAIN;
         return (-1);
 }
 
@@ -298,20 +319,26 @@ res_search(name, class, type, answer, anslen)
  * Perform a call on res_query on the concatenation of name and domain,
  * removing a trailing dot from name if domain is NULL.
  */
+int
 res_querydomain(name, domain, class, type, answer, anslen)
-        char *name, *domain;
+        const char *name, *domain;
         int class, type;        /* class and type of query */
         u_char *answer;         /* buffer to put answer */
         int anslen;             /* size of answer */
 {
-        char nbuf[2*MAXDNAME+2];
-        char *longname = nbuf;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char nbuf[MAXDNAME*2+1+1];
+        const char *longname = nbuf;
         int n;
 
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
 #ifdef DEBUG
-        if (_res.options & RES_DEBUG)
+        if (_resp->options & RES_DEBUG)
                 printf(";; res_querydomain(%s, %s, %d, %d)\n",
-                    name, domain, class, type);
+                       name, domain?domain:"<Nil>", class, type);
 #endif
         if (domain == NULL) {
                 /*
@@ -325,38 +352,52 @@ res_querydomain(name, domain, class, type, answer, anslen)
                 } else
                         longname = name;
         } else
-                (void)sprintf(nbuf, "%.*s.%.*s",
+                snprintf(nbuf, sizeof nbuf, "%.*s.%.*s",
                     MAXDNAME, name, MAXDNAME, domain);
 
         return (res_query(longname, class, type, answer, anslen));
 }
 
-char *
-__hostalias(name)
+const char *
+hostalias(name)
         register const char *name;
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
         register char *cp1, *cp2;
         FILE *fp;
-        char *file, *getenv(), *strcpy(), *strncpy();
+        char *file;
         char buf[BUFSIZ];
         static char abuf[MAXDNAME];
+        size_t len;
 
+        if (_resp->options & RES_NOALIASES)
+                return (NULL);
         file = getenv("HOSTALIASES");
-        if (file == NULL || (fp = fopen(file, "r")) == NULL)
+        if (issetugid() != 0 || file == NULL || (fp = fopen(file, "r")) == NULL)
                 return (NULL);
-        buf[sizeof(buf) - 1] = '\0';
-        while (fgets(buf, sizeof(buf), fp)) {
-                for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1);
+        setbuf(fp, NULL);
+        while ((cp1 = fgetln(fp, &len)) != NULL) {
+                if (cp1[len-1] == '\n')
+                        len--;
+                if (len >= sizeof(buf) || len == 0)
+                        continue;
+                (void)memcpy(buf, cp1, len);
+                buf[len] = '\0';
+                
+                for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1)
+                        ;
                 if (!*cp1)
                         break;
                 *cp1 = '\0';
                 if (!strcasecmp(buf, name)) {
-                        while (isspace(*++cp1));
+                        while (isspace(*++cp1))
+                                ;
                         if (!*cp1)
                                 break;
-                        for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2);
-                        abuf[sizeof(abuf) - 1] = *cp2 = '\0';
-                        (void)strncpy(abuf, cp1, sizeof(abuf) - 1);
+                        for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2)
+                                ;
+                        *cp2 = '\0';
+                        strlcpy(abuf, cp1, sizeof(abuf));
                         fclose(fp);
                         return (abuf);
                 }