source: rtems-libbsd/freebsd-userspace/lib/libc/resolv/res_query.c @ 028aaaf

4.1155-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since 028aaaf was 028aaaf, checked in by Joel Sherrill <joel.sherrill@…>, on Jul 11, 2012 at 9:01:37 PM

freebsd-userspace: All files in old libnetworking/libc now present

But they don't all compile. Multiple issues left to address.

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