]>
Commit | Line | Data |
---|---|---|
28f540f4 RM |
1 | /* |
2 | * ++Copyright++ 1988, 1993 | |
3 | * - | |
4 | * Copyright (c) 1988, 1993 | |
5 | * The Regents of the University of California. All rights reserved. | |
df21c858 | 6 | * |
28f540f4 RM |
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. | |
28f540f4 RM |
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. | |
df21c858 | 18 | * |
28f540f4 RM |
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 | * Portions Copyright (c) 1993 by Digital Equipment Corporation. | |
df21c858 | 32 | * |
28f540f4 RM |
33 | * Permission to use, copy, modify, and distribute this software for any |
34 | * purpose with or without fee is hereby granted, provided that the above | |
35 | * copyright notice and this permission notice appear in all copies, and that | |
36 | * the name of Digital Equipment Corporation not be used in advertising or | |
37 | * publicity pertaining to distribution of the document or software without | |
38 | * specific, written prior permission. | |
df21c858 | 39 | * |
28f540f4 RM |
40 | * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL |
41 | * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES | |
42 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT | |
43 | * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL | |
44 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR | |
45 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS | |
46 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS | |
47 | * SOFTWARE. | |
48 | * - | |
49 | * --Copyright-- | |
50 | */ | |
51 | ||
52 | #if defined(LIBC_SCCS) && !defined(lint) | |
53 | static char sccsid[] = "@(#)res_query.c 8.1 (Berkeley) 6/4/93"; | |
54 | static char rcsid[] = "$Id$"; | |
55 | #endif /* LIBC_SCCS and not lint */ | |
56 | ||
df21c858 | 57 | #include <sys/types.h> |
28f540f4 RM |
58 | #include <sys/param.h> |
59 | #include <netinet/in.h> | |
60 | #include <arpa/inet.h> | |
61 | #include <arpa/nameser.h> | |
62 | ||
63 | #include <stdio.h> | |
64 | #include <netdb.h> | |
65 | #include <resolv.h> | |
66 | #include <ctype.h> | |
67 | #include <errno.h> | |
68 | #if defined(BSD) && (BSD >= 199306) | |
69 | # include <stdlib.h> | |
70 | # include <string.h> | |
71 | #else | |
72 | # include "../conf/portability.h" | |
73 | #endif | |
74 | ||
75 | #if defined(USE_OPTIONS_H) | |
76 | # include <../conf/options.h> | |
77 | #endif | |
78 | ||
79 | #if PACKETSZ > 1024 | |
80 | #define MAXPACKET PACKETSZ | |
81 | #else | |
82 | #define MAXPACKET 1024 | |
83 | #endif | |
84 | ||
845dcb57 | 85 | const char *hostalias __P((const char *)); |
edf5b2d7 | 86 | |
28f540f4 RM |
87 | |
88 | /* | |
89 | * Formulate a normal query, send, and await answer. | |
90 | * Returned answer is placed in supplied buffer "answer". | |
91 | * Perform preliminary check of answer, returning success only | |
92 | * if no error is indicated and the answer count is nonzero. | |
93 | * Return the size of the response on success, -1 on error. | |
94 | * Error number is left in h_errno. | |
95 | * | |
96 | * Caller must parse answer and determine whether it answers the question. | |
97 | */ | |
98 | int | |
99 | res_query(name, class, type, answer, anslen) | |
100 | const char *name; /* domain name */ | |
101 | int class, type; /* class and type of query */ | |
102 | u_char *answer; /* buffer to put answer */ | |
103 | int anslen; /* size of answer buffer */ | |
104 | { | |
105 | u_char buf[MAXPACKET]; | |
106 | register HEADER *hp = (HEADER *) answer; | |
107 | int n; | |
108 | ||
109 | hp->rcode = NOERROR; /* default */ | |
110 | ||
111 | if ((_res.options & RES_INIT) == 0 && res_init() == -1) { | |
a68b0d31 | 112 | __set_h_errno (NETDB_INTERNAL); |
28f540f4 RM |
113 | return (-1); |
114 | } | |
115 | #ifdef DEBUG | |
116 | if (_res.options & RES_DEBUG) | |
117 | printf(";; res_query(%s, %d, %d)\n", name, class, type); | |
118 | #endif | |
119 | ||
120 | n = res_mkquery(QUERY, name, class, type, NULL, 0, NULL, | |
121 | buf, sizeof(buf)); | |
122 | if (n <= 0) { | |
123 | #ifdef DEBUG | |
124 | if (_res.options & RES_DEBUG) | |
125 | printf(";; res_query: mkquery failed\n"); | |
126 | #endif | |
a68b0d31 | 127 | __set_h_errno (NO_RECOVERY); |
28f540f4 RM |
128 | return (n); |
129 | } | |
130 | n = res_send(buf, n, answer, anslen); | |
131 | if (n < 0) { | |
132 | #ifdef DEBUG | |
133 | if (_res.options & RES_DEBUG) | |
134 | printf(";; res_query: send error\n"); | |
135 | #endif | |
a68b0d31 | 136 | __set_h_errno (TRY_AGAIN); |
28f540f4 RM |
137 | return (n); |
138 | } | |
139 | ||
140 | if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) { | |
141 | #ifdef DEBUG | |
142 | if (_res.options & RES_DEBUG) | |
143 | printf(";; rcode = %d, ancount=%d\n", hp->rcode, | |
144 | ntohs(hp->ancount)); | |
145 | #endif | |
146 | switch (hp->rcode) { | |
147 | case NXDOMAIN: | |
a68b0d31 | 148 | __set_h_errno (HOST_NOT_FOUND); |
28f540f4 RM |
149 | break; |
150 | case SERVFAIL: | |
a68b0d31 | 151 | __set_h_errno (TRY_AGAIN); |
28f540f4 RM |
152 | break; |
153 | case NOERROR: | |
a68b0d31 | 154 | __set_h_errno (NO_DATA); |
28f540f4 RM |
155 | break; |
156 | case FORMERR: | |
157 | case NOTIMP: | |
158 | case REFUSED: | |
159 | default: | |
a68b0d31 | 160 | __set_h_errno (NO_RECOVERY); |
28f540f4 RM |
161 | break; |
162 | } | |
163 | return (-1); | |
164 | } | |
165 | return (n); | |
166 | } | |
167 | ||
168 | /* | |
169 | * Formulate a normal query, send, and retrieve answer in supplied buffer. | |
170 | * Return the size of the response on success, -1 on error. | |
171 | * If enabled, implement search rules until answer or unrecoverable failure | |
172 | * is detected. Error code, if any, is left in h_errno. | |
173 | */ | |
174 | int | |
175 | res_search(name, class, type, answer, anslen) | |
176 | const char *name; /* domain name */ | |
177 | int class, type; /* class and type of query */ | |
178 | u_char *answer; /* buffer to put answer */ | |
179 | int anslen; /* size of answer */ | |
180 | { | |
181 | register const char *cp, * const *domain; | |
182 | HEADER *hp = (HEADER *) answer; | |
183 | u_int dots; | |
184 | int trailing_dot, ret, saved_herrno; | |
185 | int got_nodata = 0, got_servfail = 0, tried_as_is = 0; | |
186 | ||
187 | if ((_res.options & RES_INIT) == 0 && res_init() == -1) { | |
a68b0d31 | 188 | __set_h_errno (NETDB_INTERNAL); |
28f540f4 RM |
189 | return (-1); |
190 | } | |
c4029823 | 191 | __set_errno (0); |
a68b0d31 | 192 | __set_h_errno (HOST_NOT_FOUND); /* default, if we never query */ |
28f540f4 RM |
193 | dots = 0; |
194 | for (cp = name; *cp; cp++) | |
195 | dots += (*cp == '.'); | |
196 | trailing_dot = 0; | |
197 | if (cp > name && *--cp == '.') | |
198 | trailing_dot++; | |
199 | ||
200 | /* | |
201 | * if there aren't any dots, it could be a user-level alias | |
202 | */ | |
203 | if (!dots && (cp = __hostalias(name)) != NULL) | |
204 | return (res_query(cp, class, type, answer, anslen)); | |
205 | ||
206 | /* | |
207 | * If there are dots in the name already, let's just give it a try | |
208 | * 'as is'. The threshold can be set with the "ndots" option. | |
209 | */ | |
210 | saved_herrno = -1; | |
211 | if (dots >= _res.ndots) { | |
212 | ret = res_querydomain(name, NULL, class, type, answer, anslen); | |
213 | if (ret > 0) | |
214 | return (ret); | |
215 | saved_herrno = h_errno; | |
216 | tried_as_is++; | |
217 | } | |
218 | ||
219 | /* | |
220 | * We do at least one level of search if | |
221 | * - there is no dot and RES_DEFNAME is set, or | |
222 | * - there is at least one dot, there is no trailing dot, | |
223 | * and RES_DNSRCH is set. | |
224 | */ | |
225 | if ((!dots && (_res.options & RES_DEFNAMES)) || | |
226 | (dots && !trailing_dot && (_res.options & RES_DNSRCH))) { | |
227 | int done = 0; | |
228 | ||
229 | for (domain = (const char * const *)_res.dnsrch; | |
230 | *domain && !done; | |
231 | domain++) { | |
232 | ||
233 | ret = res_querydomain(name, *domain, class, type, | |
234 | answer, anslen); | |
235 | if (ret > 0) | |
236 | return (ret); | |
237 | ||
238 | /* | |
239 | * If no server present, give up. | |
240 | * If name isn't found in this domain, | |
241 | * keep trying higher domains in the search list | |
242 | * (if that's enabled). | |
243 | * On a NO_DATA error, keep trying, otherwise | |
244 | * a wildcard entry of another type could keep us | |
245 | * from finding this entry higher in the domain. | |
246 | * If we get some other error (negative answer or | |
247 | * server failure), then stop searching up, | |
248 | * but try the input name below in case it's | |
249 | * fully-qualified. | |
250 | */ | |
251 | if (errno == ECONNREFUSED) { | |
a68b0d31 | 252 | __set_h_errno (TRY_AGAIN); |
28f540f4 RM |
253 | return (-1); |
254 | } | |
255 | ||
256 | switch (h_errno) { | |
257 | case NO_DATA: | |
258 | got_nodata++; | |
259 | /* FALLTHROUGH */ | |
260 | case HOST_NOT_FOUND: | |
261 | /* keep trying */ | |
262 | break; | |
263 | case TRY_AGAIN: | |
264 | if (hp->rcode == SERVFAIL) { | |
265 | /* try next search element, if any */ | |
266 | got_servfail++; | |
267 | break; | |
268 | } | |
269 | /* FALLTHROUGH */ | |
270 | default: | |
271 | /* anything else implies that we're done */ | |
272 | done++; | |
273 | } | |
274 | ||
275 | /* if we got here for some reason other than DNSRCH, | |
276 | * we only wanted one iteration of the loop, so stop. | |
277 | */ | |
278 | if (!(_res.options & RES_DNSRCH)) | |
279 | done++; | |
280 | } | |
281 | } | |
282 | ||
283 | /* if we have not already tried the name "as is", do that now. | |
284 | * note that we do this regardless of how many dots were in the | |
285 | * name or whether it ends with a dot. | |
286 | */ | |
287 | if (!tried_as_is) { | |
288 | ret = res_querydomain(name, NULL, class, type, answer, anslen); | |
289 | if (ret > 0) | |
290 | return (ret); | |
291 | } | |
292 | ||
293 | /* if we got here, we didn't satisfy the search. | |
294 | * if we did an initial full query, return that query's h_errno | |
295 | * (note that we wouldn't be here if that query had succeeded). | |
296 | * else if we ever got a nodata, send that back as the reason. | |
297 | * else send back meaningless h_errno, that being the one from | |
298 | * the last DNSRCH we did. | |
299 | */ | |
300 | if (saved_herrno != -1) | |
a68b0d31 | 301 | __set_h_errno (saved_herrno); |
28f540f4 | 302 | else if (got_nodata) |
a68b0d31 | 303 | __set_h_errno (NO_DATA); |
28f540f4 | 304 | else if (got_servfail) |
a68b0d31 | 305 | __set_h_errno (TRY_AGAIN); |
28f540f4 RM |
306 | return (-1); |
307 | } | |
308 | ||
309 | /* | |
310 | * Perform a call on res_query on the concatenation of name and domain, | |
311 | * removing a trailing dot from name if domain is NULL. | |
312 | */ | |
313 | int | |
314 | res_querydomain(name, domain, class, type, answer, anslen) | |
315 | const char *name, *domain; | |
316 | int class, type; /* class and type of query */ | |
317 | u_char *answer; /* buffer to put answer */ | |
318 | int anslen; /* size of answer */ | |
319 | { | |
0501d603 | 320 | char nbuf[MAXDNAME * 2 + 2]; |
28f540f4 RM |
321 | const char *longname = nbuf; |
322 | int n; | |
323 | ||
3d61b63c | 324 | if ((_res.options & RES_INIT) == 0 && res_init() == -1) { |
a68b0d31 | 325 | __set_h_errno (NETDB_INTERNAL); |
3d61b63c RM |
326 | return (-1); |
327 | } | |
28f540f4 RM |
328 | #ifdef DEBUG |
329 | if (_res.options & RES_DEBUG) | |
330 | printf(";; res_querydomain(%s, %s, %d, %d)\n", | |
331 | name, domain?domain:"<Nil>", class, type); | |
332 | #endif | |
333 | if (domain == NULL) { | |
334 | /* | |
335 | * Check for trailing '.'; | |
336 | * copy without '.' if present. | |
337 | */ | |
338 | n = strlen(name) - 1; | |
df4ef2ab UD |
339 | if (n != (0 - 1) && name[n] == '.' |
340 | && n < (int) (sizeof(nbuf) - 1)) { | |
28f540f4 RM |
341 | bcopy(name, nbuf, n); |
342 | nbuf[n] = '\0'; | |
343 | } else | |
344 | longname = name; | |
345 | } else | |
346 | sprintf(nbuf, "%.*s.%.*s", MAXDNAME, name, MAXDNAME, domain); | |
347 | ||
348 | return (res_query(longname, class, type, answer, anslen)); | |
349 | } | |
350 | ||
845dcb57 UD |
351 | const char * |
352 | hostalias(name) | |
28f540f4 RM |
353 | register const char *name; |
354 | { | |
355 | register char *cp1, *cp2; | |
356 | FILE *fp; | |
357 | char *file; | |
358 | char buf[BUFSIZ]; | |
359 | static char abuf[MAXDNAME]; | |
360 | ||
3d61b63c RM |
361 | if (_res.options & RES_NOALIASES) |
362 | return (NULL); | |
d68171ed | 363 | file = __secure_getenv("HOSTALIASES"); |
28f540f4 RM |
364 | if (file == NULL || (fp = fopen(file, "r")) == NULL) |
365 | return (NULL); | |
3d61b63c | 366 | setbuf(fp, NULL); |
28f540f4 RM |
367 | buf[sizeof(buf) - 1] = '\0'; |
368 | while (fgets(buf, sizeof(buf), fp)) { | |
369 | for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1) | |
370 | ; | |
371 | if (!*cp1) | |
372 | break; | |
373 | *cp1 = '\0'; | |
374 | if (!strcasecmp(buf, name)) { | |
375 | while (isspace(*++cp1)) | |
376 | ; | |
377 | if (!*cp1) | |
378 | break; | |
379 | for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2) | |
380 | ; | |
381 | abuf[sizeof(abuf) - 1] = *cp2 = '\0'; | |
382 | strncpy(abuf, cp1, sizeof(abuf) - 1); | |
383 | fclose(fp); | |
384 | return (abuf); | |
385 | } | |
386 | } | |
387 | fclose(fp); | |
388 | return (NULL); | |
389 | } |