1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
33 * All Rights Reserved
34 *
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
37 * contributors.
38 */
39
40 #pragma ident "%Z%%M% %I% %E% SMI"
41
42 /*
43 * Send query to name server and wait for reply.
44 */
45
46 #include <sys/param.h>
47 #include <sys/time.h>
48 #include <sys/socket.h>
49 #include <sys/uio.h>
50 #include <sys/stat.h>
51 #include <netinet/in.h>
52 #include <stdio.h>
53 #include <errno.h>
54 #include <arpa/nameser.h>
55 #include <resolv.h>
56
57
58 static int s = -1; /* socket used for communications */
59 static struct sockaddr no_addr;
60
61
62 #ifndef FD_SET
63 #define NFDBITS 32
64 #define FD_SETSIZE 32
65 #define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
66 #define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
67 #define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
68 #ifdef SYSV
69 #define FD_ZERO(p) memset((void *)(p), 0, sizeof (*(p)))
70 #else
71 #define FD_ZERO(p) bzero((char *)(p), sizeof (*(p)))
72 #endif
73 #endif
74
75 /*
76 * 1247019: Kludge to time out quickly if there is no /etc/resolv.conf
77 * and a TCP connection to the local DNS server fails.
78 */
79
80 static int _confcheck()
81 {
82 int ns;
83 struct stat rc_stat;
84 struct sockaddr_in ns_sin;
85
86
87 /* First, we check to see if /etc/resolv.conf exists.
88 * If it doesn't, then localhost is mostlikely to be
89 * the nameserver.
90 */
91 if (stat(_PATH_RESCONF, &rc_stat) == -1 && errno == ENOENT) {
92
93 /* Next, we check to see if _res.nsaddr is set to loopback.
94 * If it isn't, it has been altered by the application
95 * explicitly and we then want to bail with success.
96 */
97 if (_res.nsaddr.sin_addr.S_un.S_addr == htonl(INADDR_LOOPBACK)) {
98
99 /* Lastly, we try to connect to the TCP port of the
100 * nameserver. If this fails, then we know that
101 * DNS is misconfigured and we can quickly exit.
102 */
103 ns = socket(AF_INET, SOCK_STREAM, 0);
104 IN_SET_LOOPBACK_ADDR(&ns_sin);
105 ns_sin.sin_port = htons(NAMESERVER_PORT);
106 if (connect(ns, (struct sockaddr *) &ns_sin,
107 sizeof ns_sin) == -1) {
108 close(ns);
109 return(-1);
110 }
111 else {
112 close(ns);
113 return(0);
114 }
115 }
116
117 return(0);
118 }
119
120 return (0);
121 }
122
123 int
124 res_send(buf, buflen, answer, anslen)
125 char *buf;
126 int buflen;
127 char *answer;
128 int anslen;
129 {
130 register int n;
131 int try, v_circuit, resplen, ns;
132 int gotsomewhere = 0, connected = 0;
133 int connreset = 0;
134 u_short id, len;
135 char *cp;
136 fd_set dsmask;
137 struct timeval timeout;
138 HEADER *hp = (HEADER *) buf;
139 HEADER *anhp = (HEADER *) answer;
140 struct iovec iov[2];
141 int terrno = ETIMEDOUT;
142 char junk[512];
143
144 #ifdef DEBUG
145 if (_res.options & RES_DEBUG) {
146 printf("res_send()\n");
147 p_query(buf);
148 }
149 #endif
150 if (!(_res.options & RES_INIT))
151 if (res_init() == -1) {
152 return (-1);
153 }
154
155 /* 1247019: Check to see if we can bailout quickly. */
156 if (_confcheck() == -1)
157 return(-1);
158
159 v_circuit = (_res.options & RES_USEVC) || buflen > PACKETSZ;
160 id = hp->id;
161 /*
162 * Send request, RETRY times, or until successful
163 */
164 for (try = 0; try < _res.retry; try++) {
165 for (ns = 0; ns < _res.nscount; ns++) {
166 #ifdef DEBUG
167 if (_res.options & RES_DEBUG)
168 printf("Querying server (# %d) address = %s\n",
169 ns+1, inet_ntoa(_res.nsaddr_list[ns].sin_addr));
170 #endif
171 usevc:
172 if (v_circuit) {
173 int truncated = 0;
174
175 /*
176 * Use virtual circuit;
177 * at most one attempt per server.
178 */
179 try = _res.retry;
180 if (s < 0) {
181 s = _socket(AF_INET, SOCK_STREAM, 0);
182 if (s < 0) {
183 terrno = errno;
184 #ifdef DEBUG
185 if (_res.options & RES_DEBUG) {
186 perror("socket (vc) failed");
187 }
188 #endif
189 continue;
190 }
191 if (connect(s, (struct sockaddr *) &_res.nsaddr_list[ns],
192 sizeof (struct sockaddr)) < 0) {
193 terrno = errno;
194 #ifdef DEBUG
195 if (_res.options & RES_DEBUG) {
196 perror("connect failed");
197 }
198 #endif
199 (void) close(s);
200 s = -1;
201 continue;
202 }
203 }
204 /*
205 * Send length & message
206 */
207 len = htons((u_short)buflen);
208 iov[0].iov_base = (caddr_t)&len;
209 iov[0].iov_len = sizeof (len);
210 iov[1].iov_base = buf;
211 iov[1].iov_len = buflen;
212 if (writev(s, iov, 2) != sizeof (len) +
213 buflen) {
214 terrno = errno;
215 #ifdef DEBUG
216 if (_res.options & RES_DEBUG)
217 perror("write failed");
218 #endif
219 (void) close(s);
220 s = -1;
221 continue;
222 }
223 /*
224 * Receive length & response
225 */
226 cp = answer;
227 len = sizeof (short);
228 while (len != 0 && (n = read
229 (s, (char *)cp, (int)len)) > 0) {
230 cp += n;
231 len -= n;
232 }
233 if (n <= 0) {
234 terrno = errno;
235 #ifdef DEBUG
236 if (_res.options & RES_DEBUG)
237 perror("read failed");
238 #endif
239 (void) close(s);
240 s = -1;
241 /*
242 * A long running process might get its TCP
243 * connection reset if the remote server was
244 * restarted. Requery the server instead of
245 * trying a new one. When there is only one
246 * server, this means that a query might work
247 * instead of failing. We only allow one reset
248 * per query to prevent looping.
249 */
250 if (terrno == ECONNRESET &&
251 !connreset) {
252 connreset = 1;
253 ns--;
254 }
255 continue;
256 }
257 cp = answer;
258 if ((resplen = ntohs(*(u_short *)cp)) >
259 anslen) {
260 #ifdef DEBUG
261 if (_res.options & RES_DEBUG)
262 fprintf(stderr,
263 "response truncated\n");
264 #endif
265 len = anslen;
266 truncated = 1;
267 } else
268 len = resplen;
269 while (len != 0 &&
270 (n = read(s, (char *)cp,
271 (int)len)) > 0) {
272 cp += n;
273 len -= n;
274 }
275 if (n <= 0) {
276 terrno = errno;
277 #ifdef DEBUG
278 if (_res.options & RES_DEBUG)
279 perror("read failed");
280 #endif
281 (void) close(s);
282 s = -1;
283 continue;
284 }
285 if (truncated) {
286 /*
287 * Flush rest of answer
288 * so connection stays in synch.
289 */
290 anhp->tc = 1;
291 len = resplen - anslen;
292 /*
293 * set the value of resplen to anslen,
294 * this is done because the caller
295 * assumes resplen contains the size of
296 * message read into the "answer" buffer
297 * passed in.
298 */
299 resplen = anslen;
300
301 while (len != 0) {
302 n = (len > sizeof (junk) ?
303 sizeof (junk) : len);
304 if ((n = read(s, junk, n)) > 0)
305 len -= n;
306 else
307 break;
308 }
309 }
310 } else {
311 /*
312 * Use datagrams.
313 */
314 if (s < 0) {
315 s = _socket(AF_INET, SOCK_DGRAM, 0);
316 if (s < 0) {
317 terrno = errno;
318 #ifdef DEBUG
319 if (_res.options & RES_DEBUG) {
320 perror("socket (dg) failed");
321 }
322 #endif
323 continue;
324 }
325 }
326 #if BSD >= 43
327 /*
328 * I'm tired of answering this question, so:
329 * On a 4.3BSD+ machine (client and server,
330 * actually), sending to a nameserver datagram
331 * port with no nameserver will cause an
332 * ICMP port unreachable message to be returned.
333 * If our datagram socket is "connected" to the
334 * server, we get an ECONNREFUSED error on the next
335 * socket operation, and select returns if the
336 * error message is received. We can thus detect
337 * the absence of a nameserver without timing out.
338 * If we have sent queries to at least two servers,
339 * however, we don't want to remain connected,
340 * as we wish to receive answers from the first
341 * server to respond.
342 */
343 if (_res.nscount == 1 ||
344 (try == 0 && ns == 0)) {
345 /*
346 * Don't use connect if we might
347 * still receive a response
348 * from another server.
349 */
350 if (connected == 0) {
351 if (connect(s,
352 (struct sockaddr *) &_res.nsaddr_list[ns],
353 sizeof (struct sockaddr)) < 0) {
354 #ifdef DEBUG
355 if (_res.options &
356 RES_DEBUG) {
357 perror("connect");
358 }
359 #endif
360 continue;
361 }
362 connected = 1;
363 }
364 if (send(s, buf, buflen, 0) != buflen) {
365 #ifdef DEBUG
366 if (_res.options & RES_DEBUG)
367 perror("send");
368 #endif
369 continue;
370 }
371 } else {
372 /*
373 * Disconnect if we want to listen for
374 * responses from more than one server.
375 */
376 if (connected) {
377 (void) connect(s, &no_addr,
378 sizeof (no_addr));
379 connected = 0;
380 }
381 #endif /* BSD */
382 if (sendto(s, buf, buflen, 0,
383 (struct sockaddr *) &_res.nsaddr_list[ns],
384 sizeof (struct sockaddr)) != buflen) {
385 #ifdef DEBUG
386 if (_res.options & RES_DEBUG)
387 perror("sendto");
388 #endif
389 continue;
390 }
391 #if BSD >= 43
392 }
393 #endif
394
395 /*
396 * Wait for reply
397 */
398 timeout.tv_sec = (_res.retrans << try);
399 if (try > 0)
400 timeout.tv_sec /= _res.nscount;
401 if (timeout.tv_sec <= 0)
402 timeout.tv_sec = 1;
403 timeout.tv_usec = 0;
404 wait:
405 FD_ZERO(&dsmask);
406 FD_SET(s, &dsmask);
407 n = select(s+1, &dsmask, (fd_set *)NULL,
408 (fd_set *)NULL, &timeout);
409 if (n < 0) {
410 #ifdef DEBUG
411 if (_res.options & RES_DEBUG)
412 perror("select");
413 #endif
414 continue;
415 }
416 if (n == 0) {
417 /*
418 * timeout
419 */
420 #ifdef DEBUG
421 if (_res.options & RES_DEBUG)
422 printf("timeout\n");
423 #endif
424 #if BSD >= 43
425 gotsomewhere = 1;
426 #endif
427 continue;
428 }
429 if ((resplen = recv(s, answer, anslen, 0))
430 <= 0) {
431 #ifdef DEBUG
432 if (_res.options & RES_DEBUG)
433 perror("recvfrom");
434 #endif
435 continue;
436 }
437 gotsomewhere = 1;
438 if (id != anhp->id) {
439 /*
440 * response from old query, ignore it
441 */
442 #ifdef DEBUG
443 if (_res.options & RES_DEBUG) {
444 printf("old answer:\n");
445 p_query(answer);
446 }
447 #endif
448 goto wait;
449 }
450 if (!(_res.options & RES_IGNTC) && anhp->tc) {
451 /*
452 * get rest of answer;
453 * use TCP with same server.
454 */
455 #ifdef DEBUG
456 if (_res.options & RES_DEBUG)
457 printf("truncated answer\n");
458 #endif
459 (void) close(s);
460 s = -1;
461 v_circuit = 1;
462 goto usevc;
463 }
464 }
465 #ifdef DEBUG
466 if (_res.options & RES_DEBUG) {
467 printf("got answer:\n");
468 p_query(answer);
469 }
470 #endif
471 /*
472 * If using virtual circuits, we assume that the first server
473 * is preferred * over the rest (i.e. it is on the local
474 * machine) and only keep that one open.
475 * If we have temporarily opened a virtual circuit,
476 * or if we haven't been asked to keep a socket open,
477 * close the socket.
478 */
479 if ((v_circuit &&
480 ((_res.options & RES_USEVC) == 0 || ns != 0)) ||
481 (_res.options & RES_STAYOPEN) == 0) {
482 (void) close(s);
483 s = -1;
484 }
485 return (resplen);
486 }
487 }
488 if (s >= 0) {
489 (void) close(s);
490 s = -1;
491 }
492 if (v_circuit == 0)
493 if (gotsomewhere == 0)
494 errno = ECONNREFUSED; /* no nameservers found */
495 else
496 errno = ETIMEDOUT; /* no answer obtained */
497 else
498 errno = terrno;
499 return (-1);
500 }
501
502 /*
503 * This routine is for closing the socket if a virtual circuit is used and
504 * the program wants to close it. This provides support for endhostent()
505 * which expects to close the socket.
506 *
507 * This routine is not expected to be user visible.
508 */
509 void
510 _res_close()
511 {
512 if (s != -1) {
513 (void) close(s);
514 s = -1;
515 }
516 }