workbench/network/stacks/AROSTCP/dhcp/minires/res_query.c

   1 /*
   2  * Copyright (c) 1988, 1993
   3  *    The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  36  *
  37  * Permission to use, copy, modify, and distribute this software for any
  38  * purpose with or without fee is hereby granted, provided that the above
  39  * copyright notice and this permission notice appear in all copies, and that
  40  * the name of Digital Equipment Corporation not be used in advertising or
  41  * publicity pertaining to distribution of the document or software without
  42  * specific, written prior permission.
  43  *
  44  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  45  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  46  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  47  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  48  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  49  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  50  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  51  * SOFTWARE.
  52  */
  53
  54 /*
  55  * Portions Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
  56  * Portions Copyright (c) 1996-2003 by Internet Software Consortium
  57  *
  58  * Permission to use, copy, modify, and distribute this software for any
  59  * purpose with or without fee is hereby granted, provided that the above
  60  * copyright notice and this permission notice appear in all copies.
  61  *
  62  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  63  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  64  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  65  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  66  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  67  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  68  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  69  *
  70  *   Internet Systems Consortium, Inc.
  71  *   950 Charter Street
  72  *   Redwood City, CA 94063
  73  *   <info@isc.org>
  74  *   http://www.isc.org/
  75  */
  76
  77 #if defined(LIBC_SCCS) && !defined(lint) && !defined(__AROS__)
  78 static const char sccsid[] = "@(#)res_query.c   8.1 (Berkeley) 6/4/93";
  79 static const char rcsid[] = "$Id$";
  80 #endif /* LIBC_SCCS and not lint */
  81
  82 #include <sys/types.h>
  83 #include <sys/param.h>
  84 #include <netinet/in.h>
  85 #include <arpa/inet.h>
  86 #include <ctype.h>
  87 #include <errno.h>
  88 #include <netdb.h>
  89 #include <stdio.h>
  90 #include <stdlib.h>
  91 #include <string.h>
  92 #include <sys/socket.h>
  93
  94 #include "minires/minires.h"
  95 #include "arpa/nameser.h"
  96
  97 /* Options.  Leave them on. */
  98 #define DEBUG
  99
 100 #if PACKETSZ > 1024
 101 #define MAXPACKET       PACKETSZ
 102 #else
 103 #define MAXPACKET       1024
 104 #endif
 105
 106 /*
 107  * Formulate a normal query, send, and await answer.
 108  * Returned answer is placed in supplied buffer "answer".
 109  * Perform preliminary check of answer, returning success only
 110  * if no error is indicated and the answer count is nonzero.
 111  * Return the size of the response on success, -1 on error.
 112  * Error number is left in H_ERRNO.
 113  *
 114  * Caller must parse answer and determine whether it answers the question.
 115  */
 116 isc_result_t
 117 res_nquery(res_state statp,
 118            const char *name,    /* domain name */
 119            ns_class class, ns_type type, /* class and type of query */
 120            double *answer,      /* buffer to put answer */
 121            unsigned anslen,
 122            unsigned *ansret)    /* size of answer buffer */
 123 {
 124         double buf[MAXPACKET / sizeof (double)];
 125         HEADER *hp = (HEADER *) answer;
 126         unsigned n;
 127         isc_result_t rcode;
 128
 129         hp->rcode = NOERROR;    /* default */
 130
 131 #ifdef DEBUG
 132         if (statp->options & RES_DEBUG)
 133                 printf(";; res_query(%s, %d, %d)\n", name, class, type);
 134 #endif
 135
 136         rcode = res_nmkquery(statp, QUERY, name, class, type, NULL, 0, NULL,
 137                              buf, sizeof(buf), &n);
 138         if (rcode != ISC_R_SUCCESS) {
 139 #ifdef DEBUG
 140                 if (statp->options & RES_DEBUG)
 141                         printf(";; res_query: mkquery failed\n");
 142 #endif
 143                 RES_SET_H_ERRNO(statp, NO_RECOVERY);
 144                 return rcode;
 145         }
 146         rcode = res_nsend(statp, buf, n, answer, anslen, &n);
 147         if (rcode != ISC_R_SUCCESS) {
 148 #ifdef DEBUG
 149                 if (statp->options & RES_DEBUG)
 150                         printf(";; res_query: send error\n");
 151 #endif
 152                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 153                 return rcode;
 154         }
 155
 156         if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
 157 #ifdef DEBUG
 158                 if (statp->options & RES_DEBUG)
 159                         printf(";; rcode = %d, ancount=%d\n", hp->rcode,
 160                             ntohs(hp->ancount));
 161 #endif
 162                 switch (hp->rcode) {
 163                 case NXDOMAIN:
 164                         RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
 165                         break;
 166                 case SERVFAIL:
 167                         RES_SET_H_ERRNO(statp, TRY_AGAIN);
 168                         break;
 169                 case NOERROR:
 170                         RES_SET_H_ERRNO(statp, NO_DATA);
 171                         break;
 172                 case FORMERR:
 173                 case NOTIMP:
 174                 case REFUSED:
 175                 default:
 176                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 177                         break;
 178                 }
 179                 return ns_rcode_to_isc (hp -> rcode);
 180         }
 181         *ansret = n;
 182         return ISC_R_SUCCESS;
 183 }
 184
 185 #if 0
 186 /*
 187  * Formulate a normal query, send, and retrieve answer in supplied buffer.
 188  * Return the size of the response on success, -1 on error.
 189  * If enabled, implement search rules until answer or unrecoverable failure
 190  * is detected.  Error code, if any, is left in H_ERRNO.
 191  */
 192 isc_result_t
 193 res_nsearch(res_state statp,
 194             const char *name,   /* domain name */
 195             ns_class class, ns_type type, /* class and type of query */
 196             double *answer,     /* buffer to put answer */
 197             unsigned anslen,
 198             unsigned *ansret)           /* size of answer */
 199 {
 200         const char *cp, * const *domain;
 201         HEADER *hp = (HEADER *) answer;
 202         char tmp[NS_MAXDNAME];
 203         u_int dots;
 204         int trailing_dot, ret;
 205         int got_nodata = 0, got_servfail = 0, root_on_list = 0;
 206         isc_result_t rcode;
 207
 208         errno = 0;
 209         RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);  /* True if we never query. */
 210
 211         dots = 0;
 212         for (cp = name; *cp != '\0'; cp++)
 213                 dots += (*cp == '.');
 214         trailing_dot = 0;
 215         if (cp > name && *--cp == '.')
 216                 trailing_dot++;
 217
 218         /* If there aren't any dots, it could be a user-level alias. */
 219         if (!dots && (cp = res_hostalias(statp, name, tmp, sizeof tmp))!= NULL)
 220                 return res_nquery(statp, cp, class, type,
 221                                   answer, anslen, ansret);
 222
 223         /*
 224          * If there are enough dots in the name, do no searching.
 225          * (The threshold can be set with the "ndots" option.)
 226          */
 227         if (dots >= statp->ndots || trailing_dot)
 228                 return res_nquerydomain(statp, name, NULL, class, type,
 229                                         answer, anslen, ansret);
 230
 231         /*
 232          * We do at least one level of search if
 233          *      - there is no dot and RES_DEFNAME is set, or
 234          *      - there is at least one dot, there is no trailing dot,
 235          *        and RES_DNSRCH is set.
 236          */
 237         if ((!dots && (statp->options & RES_DEFNAMES) != 0) ||
 238             (dots && !trailing_dot && (statp->options & RES_DNSRCH) != 0)) {
 239                 int done = 0;
 240
 241                 for (domain = (const char * const *)statp->dnsrch;
 242                      *domain && !done;
 243                      domain++) {
 244
 245                         if (domain[0][0] == '\0' ||
 246                             (domain[0][0] == '.' && domain[0][1] == '\0'))
 247                                 root_on_list++;
 248
 249                         rcode = res_nquerydomain(statp, name, *domain,
 250                                                  class, type,
 251                                                  answer, anslen, &ret);
 252                         if (rcode == ISC_R_SUCCESS && ret > 0) {
 253                                 *ansret = ret;
 254                                 return rcode;
 255                         }
 256
 257                         /*
 258                          * If no server present, give up.
 259                          * If name isn't found in this domain,
 260                          * keep trying higher domains in the search list
 261                          * (if that's enabled).
 262                          * On a NO_DATA error, keep trying, otherwise
 263                          * a wildcard entry of another type could keep us
 264                          * from finding this entry higher in the domain.
 265                          * If we get some other error (negative answer or
 266                          * server failure), then stop searching up,
 267                          * but try the input name below in case it's
 268                          * fully-qualified.
 269                          */
 270                         if (errno == ECONNREFUSED) {
 271                                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 272                                 return ISC_R_CONNREFUSED;
 273                         }
 274
 275                         switch (statp->res_h_errno) {
 276                         case NO_DATA:
 277                                 got_nodata++;
 278                                 /* FALLTHROUGH */
 279                         case HOST_NOT_FOUND:
 280                                 /* keep trying */
 281                                 break;
 282                         case TRY_AGAIN:
 283                                 if (hp->rcode == SERVFAIL) {
 284                                         /* try next search element, if any */
 285                                         got_servfail++;
 286                                         break;
 287                                 }
 288                                 /* FALLTHROUGH */
 289                         default:
 290                                 /* anything else implies that we're done */
 291                                 done++;
 292                         }
 293
 294                         /* if we got here for some reason other than DNSRCH,
 295                          * we only wanted one iteration of the loop, so stop.
 296                          */
 297                         if ((statp->options & RES_DNSRCH) == 0)
 298                                 done++;
 299                 }
 300         }
 301
 302         /*
 303          * If the name has any dots at all, and "." is not on the search
 304          * list, then try an as-is query now.
 305          */
 306         if (statp->ndots) {
 307                 rcode = res_nquerydomain(statp, name, NULL, class, type,
 308                                          answer, anslen, &ret);
 309                 if (rcode == ISC_R_SUCCESS && ret > 0) {
 310                         *ansret = ret;
 311                         return rcode;
 312                 }
 313         }
 314
 315         /* if we got here, we didn't satisfy the search.
 316          * if we did an initial full query, return that query's H_ERRNO
 317          * (note that we wouldn't be here if that query had succeeded).
 318          * else if we ever got a nodata, send that back as the reason.
 319          * else send back meaningless H_ERRNO, that being the one from
 320          * the last DNSRCH we did.
 321          */
 322         if (got_nodata) {
 323                 RES_SET_H_ERRNO(statp, NO_DATA);
 324                 return ISC_R_NOTFOUND;
 325         } else if (got_servfail) {
 326                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 327                 return ISC_R_TIMEDOUT;
 328         }
 329         return ISC_R_UNEXPECTED;
 330 }
 331 #endif
 332
 333 /*
 334  * Perform a call on res_query on the concatenation of name and domain,
 335  * removing a trailing dot from name if domain is NULL.
 336  */
 337 isc_result_t
 338 res_nquerydomain(res_state statp,
 339                  const char *name,
 340                  const char *domain,
 341                  ns_class class, ns_type type,
 342                  double *answer,
 343                  unsigned anslen,
 344                  unsigned *ansret)
 345 {
 346         char nbuf[MAXDNAME];
 347         const char *longname = nbuf;
 348         int n, d;
 349
 350 #ifdef DEBUG
 351         if (statp->options & RES_DEBUG)
 352                 printf(";; res_nquerydomain(%s, %s, %d, %d)\n",
 353                        name, domain?domain:"<Nil>", class, type);
 354 #endif
 355         if (domain == NULL) {
 356                 /*
 357                  * Check for trailing '.';
 358                  * copy without '.' if present.
 359                  */
 360                 n = strlen(name);
 361                 if (n >= MAXDNAME) {
 362                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 363                         return ISC_R_NOSPACE;
 364                 }
 365                 n--;
 366                 if (n >= 0 && name[n] == '.') {
 367                         strncpy(nbuf, name, (unsigned)n);
 368                         nbuf[n] = '\0';
 369                 } else
 370                         longname = name;
 371         } else {
 372                 n = strlen(name);
 373                 d = strlen(domain);
 374                 if (n + d + 1 >= MAXDNAME) {
 375                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 376                         return ISC_R_NOSPACE;
 377                 }
 378                 sprintf(nbuf, "%s.%s", name, domain);
 379         }
 380         return res_nquery(statp,
 381                           longname, class, type, answer, anslen, ansret);
 382 }
 383
 384 const char *
 385 res_hostalias(const res_state statp, const char *name, char *dst, size_t siz) {
 386         char *file, *cp1, *cp2;
 387         char buf[BUFSIZ];
 388         FILE *fp;
 389
 390         if (statp->options & RES_NOALIASES)
 391                 return (NULL);
 392         file = getenv("HOSTALIASES");
 393         if (file == NULL || (fp = fopen(file, "r")) == NULL)
 394                 return (NULL);
 395         setbuf(fp, NULL);
 396         buf[sizeof(buf) - 1] = '\0';
 397         while (fgets(buf, sizeof(buf), fp)) {
 398                 for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1)
 399                         ;
 400                 if (!*cp1)
 401                         break;
 402                 *cp1 = '\0';
 403                 if (ns_samename(buf, name) == 1) {
 404                         while (isspace(*++cp1))
 405                                 ;
 406                         if (!*cp1)
 407                                 break;
 408                         for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2)
 409                                 ;
 410                         *cp2 = '\0';
 411                         strncpy(dst, cp1, siz - 1);
 412                         dst[siz - 1] = '\0';
 413                         fclose(fp);
 414                         return (dst);
 415                 }
 416         }
 417         fclose(fp);
 418         return (NULL);
 419 }