1 /*
2 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 *
5 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
6 */
7
8
9 /*
10 * Portions Copyright (C) 2004-2009 Internet Systems Consortium, Inc. ("ISC")
11 * Portions Copyright (C) 1996-2003 Internet Software Consortium.
12 *
13 * Permission to use, copy, modify, and/or distribute this software for any
14 * purpose with or without fee is hereby granted, provided that the above
15 * copyright notice and this permission notice appear in all copies.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
18 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
19 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
20 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
21 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
23 * PERFORMANCE OF THIS SOFTWARE.
24 */
25
26 /*
27 * Copyright (c) 1985, 1989, 1993
28 * The Regents of the University of California. All rights reserved.
29 *
30 * Redistribution and use in source and binary forms, with or without
31 * modification, are permitted provided that the following conditions
32 * are met:
33 * 1. Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * 2. Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in the
37 * documentation and/or other materials provided with the distribution.
38 * 3. All advertising materials mentioning features or use of this software
39 * must display the following acknowledgement:
40 * This product includes software developed by the University of
41 * California, Berkeley and its contributors.
42 * 4. Neither the name of the University nor the names of its contributors
43 * may be used to endorse or promote products derived from this software
44 * without specific prior written permission.
45 *
46 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 * SUCH DAMAGE.
57 */
58
59 /*
60 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
61 *
62 * Permission to use, copy, modify, and distribute this software for any
63 * purpose with or without fee is hereby granted, provided that the above
64 * copyright notice and this permission notice appear in all copies, and that
65 * the name of Digital Equipment Corporation not be used in advertising or
66 * publicity pertaining to distribution of the document or software without
67 * specific, written prior permission.
68 *
69 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
70 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
71 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
72 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
73 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
74 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
75 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
76 * SOFTWARE.
77 */
78
79 #if defined(LIBC_SCCS) && !defined(lint)
80 static const char sccsid[] = "@(#)res_send.c 8.1 (Berkeley) 6/4/93";
81 static const char rcsid[] = "$Id: res_send.c,v 1.22 2009/01/22 23:49:23 tbox Exp $";
82 #endif /* LIBC_SCCS and not lint */
83
84 /*! \file
85 * \brief
86 * Send query to name server and wait for reply.
87 */
88
89 #include "port_before.h"
90 #include "fd_setsize.h"
91
92 #include <sys/types.h>
93 #include <sys/param.h>
94 #include <sys/time.h>
95 #include <sys/socket.h>
96 #include <sys/uio.h>
97
98 #include <netinet/in.h>
99 #include <netinet/tcp.h>
100 #include <arpa/nameser.h>
101 #include <arpa/inet.h>
102
103 #include <errno.h>
104 #include <netdb.h>
105 #include <resolv.h>
106 #include <signal.h>
107 #include <stdio.h>
108 #include <stdlib.h>
109 #include <string.h>
110 #include <unistd.h>
111
112 #include <isc/eventlib.h>
113
114 #include "port_after.h"
115
116 #ifdef USE_POLL
117 #ifdef HAVE_STROPTS_H
118 #include <stropts.h>
119 #endif
120 #include <poll.h>
121 #endif /* USE_POLL */
122
123 /* Options. Leave them on. */
124 #define DEBUG
125 #include "res_debug.h"
126 #include "res_private.h"
127
128 #define EXT(res) ((res)->_u._ext)
129
130 #ifndef USE_POLL
131 static const int highestFD = FD_SETSIZE - 1;
132 #else
133 static int highestFD = 0;
134 #endif
135
136 /* Forward. */
137
138 static int get_salen __P((const struct sockaddr *));
139 static struct sockaddr * get_nsaddr __P((res_state, size_t));
140 static int send_vc(res_state, const u_char *, int,
141 u_char *, int, int *, int);
142 static int send_dg(res_state, const u_char *, int,
143 u_char *, int, int *, int, int,
144 int *, int *);
145 static void Aerror(const res_state, FILE *, const char *, int,
146 const struct sockaddr *, int);
147 static void Perror(const res_state, FILE *, const char *, int);
148 static int sock_eq(struct sockaddr *, struct sockaddr *);
149 #if defined(NEED_PSELECT) && !defined(USE_POLL)
150 static int pselect(int, void *, void *, void *,
151 struct timespec *,
152 const sigset_t *);
153 #endif
154 void res_pquery(const res_state, const u_char *, int, FILE *);
155
156 #ifndef ORIGINAL_ISC_CODE
157 #pragma weak __res_nameinquery = res_nameinquery
158 #pragma weak __res_queriesmatch = res_queriesmatch
159 #pragma weak res_nisourserver = res_ourserver_p
160 #endif /* ORIGINAL_ISC_CODE */
161
162 static const int niflags = NI_NUMERICHOST | NI_NUMERICSERV;
163
164 /* Public. */
165
166 /*%
167 * looks up "ina" in _res.ns_addr_list[]
168 *
169 * returns:
170 *\li 0 : not found
171 *\li >0 : found
172 *
173 * author:
174 *\li paul vixie, 29may94
175 */
176 int
res_ourserver_p(const res_state statp,const struct sockaddr * sa)177 res_ourserver_p(const res_state statp, const struct sockaddr *sa) {
178 const struct sockaddr_in *inp, *srv;
179 const struct sockaddr_in6 *in6p, *srv6;
180 int ns;
181
182 switch (sa->sa_family) {
183 case AF_INET:
184 inp = (const struct sockaddr_in *)sa;
185 for (ns = 0; ns < statp->nscount; ns++) {
186 srv = (struct sockaddr_in *)get_nsaddr(statp, ns);
187 if (srv->sin_family == inp->sin_family &&
188 srv->sin_port == inp->sin_port &&
189 (srv->sin_addr.s_addr == INADDR_ANY ||
190 srv->sin_addr.s_addr == inp->sin_addr.s_addr))
191 return (1);
192 }
193 break;
194 case AF_INET6:
195 if (EXT(statp).ext == NULL)
196 break;
197 in6p = (const struct sockaddr_in6 *)sa;
198 for (ns = 0; ns < statp->nscount; ns++) {
199 srv6 = (struct sockaddr_in6 *)get_nsaddr(statp, ns);
200 if (srv6->sin6_family == in6p->sin6_family &&
201 srv6->sin6_port == in6p->sin6_port &&
202 #ifdef HAVE_SIN6_SCOPE_ID
203 (srv6->sin6_scope_id == 0 ||
204 srv6->sin6_scope_id == in6p->sin6_scope_id) &&
205 #endif
206 (IN6_IS_ADDR_UNSPECIFIED(&srv6->sin6_addr) ||
207 IN6_ARE_ADDR_EQUAL(&srv6->sin6_addr, &in6p->sin6_addr)))
208 return (1);
209 }
210 break;
211 default:
212 break;
213 }
214 return (0);
215 }
216
217 /*%
218 * look for (name,type,class) in the query section of packet (buf,eom)
219 *
220 * requires:
221 *\li buf + HFIXEDSZ <= eom
222 *
223 * returns:
224 *\li -1 : format error
225 *\li 0 : not found
226 *\li >0 : found
227 *
228 * author:
229 *\li paul vixie, 29may94
230 */
231 int
res_nameinquery(const char * name,int type,int class,const u_char * buf,const u_char * eom)232 res_nameinquery(const char *name, int type, int class,
233 const u_char *buf, const u_char *eom)
234 {
235 const u_char *cp = buf + HFIXEDSZ;
236 int qdcount = ntohs(((const HEADER*)buf)->qdcount);
237
238 while (qdcount-- > 0) {
239 char tname[MAXDNAME+1];
240 int n, ttype, tclass;
241
242 n = dn_expand(buf, eom, cp, tname, sizeof tname);
243 if (n < 0)
244 return (-1);
245 cp += n;
246 if (cp + 2 * INT16SZ > eom)
247 return (-1);
248 ttype = ns_get16(cp); cp += INT16SZ;
249 tclass = ns_get16(cp); cp += INT16SZ;
250 if (ttype == type && tclass == class &&
251 ns_samename(tname, name) == 1)
252 return (1);
253 }
254 return (0);
255 }
256
257 /*%
258 * is there a 1:1 mapping of (name,type,class)
259 * in (buf1,eom1) and (buf2,eom2)?
260 *
261 * returns:
262 *\li -1 : format error
263 *\li 0 : not a 1:1 mapping
264 *\li >0 : is a 1:1 mapping
265 *
266 * author:
267 *\li paul vixie, 29may94
268 */
269 int
res_queriesmatch(const u_char * buf1,const u_char * eom1,const u_char * buf2,const u_char * eom2)270 res_queriesmatch(const u_char *buf1, const u_char *eom1,
271 const u_char *buf2, const u_char *eom2)
272 {
273 const u_char *cp = buf1 + HFIXEDSZ;
274 int qdcount = ntohs(((const HEADER*)buf1)->qdcount);
275
276 if (buf1 + HFIXEDSZ > eom1 || buf2 + HFIXEDSZ > eom2)
277 return (-1);
278
279 /*
280 * Only header section present in replies to
281 * dynamic update packets.
282 */
283 if ((((const HEADER *)buf1)->opcode == ns_o_update) &&
284 (((const HEADER *)buf2)->opcode == ns_o_update))
285 return (1);
286
287 if (qdcount != ntohs(((const HEADER*)buf2)->qdcount))
288 return (0);
289 while (qdcount-- > 0) {
290 char tname[MAXDNAME+1];
291 int n, ttype, tclass;
292
293 n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
294 if (n < 0)
295 return (-1);
296 cp += n;
297 if (cp + 2 * INT16SZ > eom1)
298 return (-1);
299 ttype = ns_get16(cp); cp += INT16SZ;
300 tclass = ns_get16(cp); cp += INT16SZ;
301 if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
302 return (0);
303 }
304 return (1);
305 }
306
307 int
res_nsend(res_state statp,const u_char * buf,int buflen,u_char * ans,int anssiz)308 res_nsend(res_state statp,
309 const u_char *buf, int buflen, u_char *ans, int anssiz)
310 {
311 int gotsomewhere, terrno, tries, v_circuit, resplen, ns, n;
312 char abuf[NI_MAXHOST];
313
314 #ifdef USE_POLL
315 highestFD = sysconf(_SC_OPEN_MAX) - 1;
316 #endif
317
318 /* No name servers or res_init() failure */
319 if (statp->nscount == 0 || EXT(statp).ext == NULL) {
320 errno = ESRCH;
321 return (-1);
322 }
323 if (anssiz < HFIXEDSZ) {
324 errno = EINVAL;
325 return (-1);
326 }
327 DprintQ((statp->options & RES_DEBUG) || (statp->pfcode & RES_PRF_QUERY),
328 (stdout, ";; res_send()\n"), buf, buflen);
329 v_circuit = (statp->options & RES_USEVC) || buflen > PACKETSZ;
330 gotsomewhere = 0;
331 terrno = ETIMEDOUT;
332
333 /*
334 * If the ns_addr_list in the resolver context has changed, then
335 * invalidate our cached copy and the associated timing data.
336 */
337 if (EXT(statp).nscount != 0) {
338 int needclose = 0;
339 struct sockaddr_storage peer;
340 ISC_SOCKLEN_T peerlen;
341
342 if (EXT(statp).nscount != statp->nscount)
343 needclose++;
344 else
345 for (ns = 0; ns < statp->nscount; ns++) {
346 if (statp->nsaddr_list[ns].sin_family &&
347 !sock_eq((struct sockaddr *)&statp->nsaddr_list[ns],
348 (struct sockaddr *)&EXT(statp).ext->nsaddrs[ns])) {
349 needclose++;
350 break;
351 }
352
353 if (EXT(statp).nssocks[ns] == -1)
354 continue;
355 peerlen = sizeof(peer);
356 if (getpeername(EXT(statp).nssocks[ns],
357 (struct sockaddr *)&peer, &peerlen) < 0) {
358 needclose++;
359 break;
360 }
361 if (!sock_eq((struct sockaddr *)&peer,
362 get_nsaddr(statp, ns))) {
363 needclose++;
364 break;
365 }
366 }
367 if (needclose) {
368 res_nclose(statp);
369 EXT(statp).nscount = 0;
370 }
371 }
372
373 /*
374 * Maybe initialize our private copy of the ns_addr_list.
375 */
376 if (EXT(statp).nscount == 0) {
377 for (ns = 0; ns < statp->nscount; ns++) {
378 EXT(statp).nstimes[ns] = RES_MAXTIME;
379 EXT(statp).nssocks[ns] = -1;
380 if (!statp->nsaddr_list[ns].sin_family)
381 continue;
382 EXT(statp).ext->nsaddrs[ns].sin =
383 statp->nsaddr_list[ns];
384 }
385 EXT(statp).nscount = statp->nscount;
386 }
387
388 /*
389 * Some resolvers want to even out the load on their nameservers.
390 * Note that RES_BLAST overrides RES_ROTATE.
391 */
392 if ((statp->options & RES_ROTATE) != 0U &&
393 (statp->options & RES_BLAST) == 0U) {
394 union res_sockaddr_union inu;
395 struct sockaddr_in ina;
396 int lastns = statp->nscount - 1;
397 int fd;
398 u_int16_t nstime;
399
400 if (EXT(statp).ext != NULL)
401 inu = EXT(statp).ext->nsaddrs[0];
402 ina = statp->nsaddr_list[0];
403 fd = EXT(statp).nssocks[0];
404 nstime = EXT(statp).nstimes[0];
405 for (ns = 0; ns < lastns; ns++) {
406 if (EXT(statp).ext != NULL)
407 EXT(statp).ext->nsaddrs[ns] =
408 EXT(statp).ext->nsaddrs[ns + 1];
409 statp->nsaddr_list[ns] = statp->nsaddr_list[ns + 1];
410 EXT(statp).nssocks[ns] = EXT(statp).nssocks[ns + 1];
411 EXT(statp).nstimes[ns] = EXT(statp).nstimes[ns + 1];
412 }
413 if (EXT(statp).ext != NULL)
414 EXT(statp).ext->nsaddrs[lastns] = inu;
415 statp->nsaddr_list[lastns] = ina;
416 EXT(statp).nssocks[lastns] = fd;
417 EXT(statp).nstimes[lastns] = nstime;
418 }
419
420 /*
421 * Send request, RETRY times, or until successful.
422 */
423 for (tries = 0; tries < statp->retry; tries++) {
424 for (ns = 0; ns < statp->nscount; ns++) {
425 struct sockaddr *nsap;
426 int nsaplen;
427 nsap = get_nsaddr(statp, ns);
428 nsaplen = get_salen(nsap);
429 statp->_flags &= ~RES_F_LASTMASK;
430 statp->_flags |= (ns << RES_F_LASTSHIFT);
431 same_ns:
432 if (statp->qhook) {
433 int done = 0, loops = 0;
434
435 do {
436 res_sendhookact act;
437
438 act = (*statp->qhook)(&nsap, &buf, &buflen,
439 ans, anssiz, &resplen);
440 switch (act) {
441 case res_goahead:
442 done = 1;
443 break;
444 case res_nextns:
445 res_nclose(statp);
446 goto next_ns;
447 case res_done:
448 return (resplen);
449 case res_modified:
450 /* give the hook another try */
451 if (++loops < 42) /*doug adams*/
452 break;
453 /*FALLTHROUGH*/
454 case res_error:
455 /*FALLTHROUGH*/
456 default:
457 goto fail;
458 }
459 } while (!done);
460 }
461
462 Dprint(((statp->options & RES_DEBUG) &&
463 getnameinfo(nsap, nsaplen, abuf, sizeof(abuf),
464 NULL, 0, niflags) == 0),
465 (stdout, ";; Querying server (# %d) address = %s\n",
466 ns + 1, abuf));
467
468
469 if (v_circuit) {
470 /* Use VC; at most one attempt per server. */
471 tries = statp->retry;
472 n = send_vc(statp, buf, buflen, ans, anssiz, &terrno,
473 ns);
474 if (n < 0)
475 goto fail;
476 if (n == 0)
477 goto next_ns;
478 resplen = n;
479 } else {
480 /* Use datagrams. */
481 n = send_dg(statp, buf, buflen, ans, anssiz, &terrno,
482 ns, tries, &v_circuit, &gotsomewhere);
483 if (n < 0)
484 goto fail;
485 if (n == 0)
486 goto next_ns;
487 if (v_circuit)
488 goto same_ns;
489 resplen = n;
490 }
491
492 Dprint((statp->options & RES_DEBUG) ||
493 ((statp->pfcode & RES_PRF_REPLY) &&
494 (statp->pfcode & RES_PRF_HEAD1)),
495 (stdout, ";; got answer:\n"));
496
497 DprintQ((statp->options & RES_DEBUG) ||
498 (statp->pfcode & RES_PRF_REPLY),
499 (stdout, "%s", ""),
500 ans, (resplen > anssiz) ? anssiz : resplen);
501
502 /*
503 * If we have temporarily opened a virtual circuit,
504 * or if we haven't been asked to keep a socket open,
505 * close the socket.
506 */
507 if ((v_circuit && (statp->options & RES_USEVC) == 0U) ||
508 (statp->options & RES_STAYOPEN) == 0U) {
509 res_nclose(statp);
510 }
511 if (statp->rhook) {
512 int done = 0, loops = 0;
513
514 do {
515 res_sendhookact act;
516
517 act = (*statp->rhook)(nsap, buf, buflen,
518 ans, anssiz, &resplen);
519 switch (act) {
520 case res_goahead:
521 case res_done:
522 done = 1;
523 break;
524 case res_nextns:
525 res_nclose(statp);
526 goto next_ns;
527 case res_modified:
528 /* give the hook another try */
529 if (++loops < 42) /*doug adams*/
530 break;
531 /*FALLTHROUGH*/
532 case res_error:
533 /*FALLTHROUGH*/
534 default:
535 goto fail;
536 }
537 } while (!done);
538
539 }
540 return (resplen);
541 next_ns: ;
542 } /*foreach ns*/
543 } /*foreach retry*/
544 res_nclose(statp);
545 if (!v_circuit) {
546 if (!gotsomewhere)
547 errno = ECONNREFUSED; /*%< no nameservers found */
548 else
549 errno = ETIMEDOUT; /*%< no answer obtained */
550 } else
551 errno = terrno;
552 return (-1);
553 fail:
554 res_nclose(statp);
555 return (-1);
556 }
557
558 /* Private */
559
560 static int
get_salen(sa)561 get_salen(sa)
562 const struct sockaddr *sa;
563 {
564
565 #ifdef HAVE_SA_LEN
566 /* There are people do not set sa_len. Be forgiving to them. */
567 if (sa->sa_len)
568 return (sa->sa_len);
569 #endif
570
571 if (sa->sa_family == AF_INET)
572 return (sizeof(struct sockaddr_in));
573 else if (sa->sa_family == AF_INET6)
574 return (sizeof(struct sockaddr_in6));
575 else
576 return (0); /*%< unknown, die on connect */
577 }
578
579 /*%
580 * pick appropriate nsaddr_list for use. see res_init() for initialization.
581 */
582 static struct sockaddr *
get_nsaddr(statp,n)583 get_nsaddr(statp, n)
584 res_state statp;
585 size_t n;
586 {
587
588 if (!statp->nsaddr_list[n].sin_family && EXT(statp).ext) {
589 /*
590 * - EXT(statp).ext->nsaddrs[n] holds an address that is larger
591 * than struct sockaddr, and
592 * - user code did not update statp->nsaddr_list[n].
593 */
594 return (struct sockaddr *)(void *)&EXT(statp).ext->nsaddrs[n];
595 } else {
596 /*
597 * - user code updated statp->nsaddr_list[n], or
598 * - statp->nsaddr_list[n] has the same content as
599 * EXT(statp).ext->nsaddrs[n].
600 */
601 return (struct sockaddr *)(void *)&statp->nsaddr_list[n];
602 }
603 }
604
605 static int
send_vc(res_state statp,const u_char * buf,int buflen,u_char * ans,int anssiz,int * terrno,int ns)606 send_vc(res_state statp,
607 const u_char *buf, int buflen, u_char *ans, int anssiz,
608 int *terrno, int ns)
609 {
610 const HEADER *hp = (const HEADER *) buf;
611 HEADER *anhp = (HEADER *) ans;
612 struct sockaddr *nsap;
613 int nsaplen;
614 int truncating, connreset, resplen, n;
615 struct iovec iov[2];
616 u_short len;
617 u_char *cp;
618 void *tmp;
619 #ifdef SO_NOSIGPIPE
620 int on = 1;
621 #endif
622
623 nsap = get_nsaddr(statp, ns);
624 nsaplen = get_salen(nsap);
625
626 connreset = 0;
627 same_ns:
628 truncating = 0;
629
630 /* Are we still talking to whom we want to talk to? */
631 if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
632 struct sockaddr_storage peer;
633 ISC_SOCKLEN_T size = sizeof peer;
634
635 if (getpeername(statp->_vcsock,
636 (struct sockaddr *)&peer, &size) < 0 ||
637 !sock_eq((struct sockaddr *)&peer, nsap)) {
638 res_nclose(statp);
639 statp->_flags &= ~RES_F_VC;
640 }
641 }
642
643 if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
644 if (statp->_vcsock >= 0)
645 res_nclose(statp);
646
647 statp->_vcsock = socket(nsap->sa_family, SOCK_STREAM, 0);
648 if (statp->_vcsock > highestFD) {
649 res_nclose(statp);
650 errno = ENOTSOCK;
651 }
652 if (statp->_vcsock < 0) {
653 switch (errno) {
654 case EPROTONOSUPPORT:
655 #ifdef EPFNOSUPPORT
656 case EPFNOSUPPORT:
657 #endif
658 case EAFNOSUPPORT:
659 Perror(statp, stderr, "socket(vc)", errno);
660 return (0);
661 default:
662 *terrno = errno;
663 Perror(statp, stderr, "socket(vc)", errno);
664 return (-1);
665 }
666 }
667 #ifdef SO_NOSIGPIPE
668 /*
669 * Disable generation of SIGPIPE when writing to a closed
670 * socket. Write should return -1 and set errno to EPIPE
671 * instead.
672 *
673 * Push on even if setsockopt(SO_NOSIGPIPE) fails.
674 */
675 (void)setsockopt(statp->_vcsock, SOL_SOCKET, SO_NOSIGPIPE, &on,
676 sizeof(on));
677 #endif
678 #ifdef TCP_CONN_ABORT_THRESHOLD
679 /*
680 * The default connection timeout is over two minutes.
681 * We need something more reasonable here. The default
682 * retrans value is 5 sec., then 10, 20, 40, on retries.
683 * TCP connect does its own retries, so we want just one
684 * reasonable timeout value. Using 2X retrans, which
685 * gives us a 10 sec. connect timeout. If we're waiting
686 * that long to connect, we probably want to give up and
687 * try the next DNS server in our list.
688 *
689 * It might be reasonable to do this for all callers,
690 * but for now do it only when we see MS_INTEROP in the
691 * environment (set in smbd and idmapd)
692 */
693 if (getenv("MS_INTEROP") != NULL) {
694 int conn_tmo;
695 conn_tmo = statp->retrans * 2000; /* mSec */
696 (void)setsockopt(statp->_vcsock, IPPROTO_TCP,
697 TCP_CONN_ABORT_THRESHOLD, &conn_tmo,
698 sizeof(conn_tmo));
699 }
700 #endif
701 errno = 0;
702 if (connect(statp->_vcsock, nsap, nsaplen) < 0) {
703 *terrno = errno;
704 Aerror(statp, stderr, "connect/vc", errno, nsap,
705 nsaplen);
706 res_nclose(statp);
707 return (0);
708 }
709 statp->_flags |= RES_F_VC;
710 }
711
712 /*
713 * Send length & message
714 */
715 ns_put16((u_short)buflen, (u_char*)&len);
716 iov[0] = evConsIovec(&len, INT16SZ);
717 DE_CONST(buf, tmp);
718 iov[1] = evConsIovec(tmp, buflen);
719 if (writev(statp->_vcsock, iov, 2) != (INT16SZ + buflen)) {
720 *terrno = errno;
721 Perror(statp, stderr, "write failed", errno);
722 res_nclose(statp);
723 return (0);
724 }
725 /*
726 * Receive length & response
727 */
728 read_len:
729 cp = ans;
730 len = INT16SZ;
731 while ((n = read(statp->_vcsock, (char *)cp, (int)len)) > 0) {
732 cp += n;
733 if ((len -= n) == 0)
734 break;
735 }
736 if (n <= 0) {
737 *terrno = errno;
738 Perror(statp, stderr, "read failed", errno);
739 res_nclose(statp);
740 /*
741 * A long running process might get its TCP
742 * connection reset if the remote server was
743 * restarted. Requery the server instead of
744 * trying a new one. When there is only one
745 * server, this means that a query might work
746 * instead of failing. We only allow one reset
747 * per query to prevent looping.
748 */
749 if (*terrno == ECONNRESET && !connreset) {
750 connreset = 1;
751 res_nclose(statp);
752 goto same_ns;
753 }
754 res_nclose(statp);
755 return (0);
756 }
757 resplen = ns_get16(ans);
758 if (resplen > anssiz) {
759 Dprint(statp->options & RES_DEBUG,
760 (stdout, ";; response truncated\n")
761 );
762 truncating = 1;
763 len = anssiz;
764 } else
765 len = resplen;
766 if (len < HFIXEDSZ) {
767 /*
768 * Undersized message.
769 */
770 Dprint(statp->options & RES_DEBUG,
771 (stdout, ";; undersized: %d\n", len));
772 *terrno = EMSGSIZE;
773 res_nclose(statp);
774 return (0);
775 }
776 cp = ans;
777 while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
778 cp += n;
779 len -= n;
780 }
781 if (n <= 0) {
782 *terrno = errno;
783 Perror(statp, stderr, "read(vc)", errno);
784 res_nclose(statp);
785 return (0);
786 }
787 if (truncating) {
788 /*
789 * Flush rest of answer so connection stays in synch.
790 */
791 anhp->tc = 1;
792 len = resplen - anssiz;
793 while (len != 0) {
794 char junk[PACKETSZ];
795
796 n = read(statp->_vcsock, junk,
797 (len > sizeof junk) ? sizeof junk : len);
798 if (n > 0)
799 len -= n;
800 else
801 break;
802 }
803 }
804 /*
805 * If the calling applicating has bailed out of
806 * a previous call and failed to arrange to have
807 * the circuit closed or the server has got
808 * itself confused, then drop the packet and
809 * wait for the correct one.
810 */
811 if (hp->id != anhp->id) {
812 DprintQ((statp->options & RES_DEBUG) ||
813 (statp->pfcode & RES_PRF_REPLY),
814 (stdout, ";; old answer (unexpected):\n"),
815 ans, (resplen > anssiz) ? anssiz: resplen);
816 goto read_len;
817 }
818
819 /*
820 * All is well, or the error is fatal. Signal that the
821 * next nameserver ought not be tried.
822 */
823 return (resplen);
824 }
825
826 static int
send_dg(res_state statp,const u_char * buf,int buflen,u_char * ans,int anssiz,int * terrno,int ns,int tries,int * v_circuit,int * gotsomewhere)827 send_dg(res_state statp, const u_char *buf, int buflen, u_char *ans,
828 int anssiz, int *terrno, int ns, int tries, int *v_circuit,
829 int *gotsomewhere)
830 {
831 const HEADER *hp = (const HEADER *) buf;
832 HEADER *anhp = (HEADER *) ans;
833 const struct sockaddr *nsap;
834 int nsaplen;
835 struct timespec now, timeout, finish;
836 struct sockaddr_storage from;
837 ISC_SOCKLEN_T fromlen;
838 int resplen, seconds, n, s;
839 #ifdef USE_POLL
840 int polltimeout;
841 struct pollfd pollfd;
842 #else
843 fd_set dsmask;
844 #endif
845
846 nsap = get_nsaddr(statp, ns);
847 nsaplen = get_salen(nsap);
848 if (EXT(statp).nssocks[ns] == -1) {
849 EXT(statp).nssocks[ns] = socket(nsap->sa_family, SOCK_DGRAM, 0);
850 if (EXT(statp).nssocks[ns] > highestFD) {
851 res_nclose(statp);
852 errno = ENOTSOCK;
853 }
854 if (EXT(statp).nssocks[ns] < 0) {
855 switch (errno) {
856 case EPROTONOSUPPORT:
857 #ifdef EPFNOSUPPORT
858 case EPFNOSUPPORT:
859 #endif
860 case EAFNOSUPPORT:
861 Perror(statp, stderr, "socket(dg)", errno);
862 return (0);
863 default:
864 *terrno = errno;
865 Perror(statp, stderr, "socket(dg)", errno);
866 return (-1);
867 }
868 }
869 #ifndef CANNOT_CONNECT_DGRAM
870 /*
871 * On a 4.3BSD+ machine (client and server,
872 * actually), sending to a nameserver datagram
873 * port with no nameserver will cause an
874 * ICMP port unreachable message to be returned.
875 * If our datagram socket is "connected" to the
876 * server, we get an ECONNREFUSED error on the next
877 * socket operation, and select returns if the
878 * error message is received. We can thus detect
879 * the absence of a nameserver without timing out.
880 */
881 if (connect(EXT(statp).nssocks[ns], nsap, nsaplen) < 0) {
882 Aerror(statp, stderr, "connect(dg)", errno, nsap,
883 nsaplen);
884 res_nclose(statp);
885 return (0);
886 }
887 #endif /* !CANNOT_CONNECT_DGRAM */
888 Dprint(statp->options & RES_DEBUG,
889 (stdout, ";; new DG socket\n"))
890 }
891 s = EXT(statp).nssocks[ns];
892 #ifndef CANNOT_CONNECT_DGRAM
893 if (send(s, (const char*)buf, buflen, 0) != buflen) {
894 Perror(statp, stderr, "send", errno);
895 res_nclose(statp);
896 return (0);
897 }
898 #else /* !CANNOT_CONNECT_DGRAM */
899 if (sendto(s, (const char*)buf, buflen, 0, nsap, nsaplen) != buflen)
900 {
901 Aerror(statp, stderr, "sendto", errno, nsap, nsaplen);
902 res_nclose(statp);
903 return (0);
904 }
905 #endif /* !CANNOT_CONNECT_DGRAM */
906
907 /*
908 * Wait for reply.
909 */
910 seconds = (statp->retrans << tries);
911 if (ns > 0)
912 seconds /= statp->nscount;
913 if (seconds <= 0)
914 seconds = 1;
915 now = evNowTime();
916 timeout = evConsTime(seconds, 0);
917 finish = evAddTime(now, timeout);
918 goto nonow;
919 wait:
920 now = evNowTime();
921 nonow:
922 #ifndef USE_POLL
923 FD_ZERO(&dsmask);
924 FD_SET(s, &dsmask);
925 if (evCmpTime(finish, now) > 0)
926 timeout = evSubTime(finish, now);
927 else
928 timeout = evConsTime(0, 0);
929 n = pselect(s + 1, &dsmask, NULL, NULL, &timeout, NULL);
930 #else
931 timeout = evSubTime(finish, now);
932 if (timeout.tv_sec < 0)
933 timeout = evConsTime(0, 0);
934 polltimeout = 1000*timeout.tv_sec +
935 timeout.tv_nsec/1000000;
936 pollfd.fd = s;
937 pollfd.events = POLLRDNORM;
938 n = poll(&pollfd, 1, polltimeout);
939 #endif /* USE_POLL */
940
941 if (n == 0) {
942 Dprint(statp->options & RES_DEBUG, (stdout, ";; timeout\n"));
943 *gotsomewhere = 1;
944 return (0);
945 }
946 if (n < 0) {
947 if (errno == EINTR)
948 goto wait;
949 #ifndef USE_POLL
950 Perror(statp, stderr, "select", errno);
951 #else
952 Perror(statp, stderr, "poll", errno);
953 #endif /* USE_POLL */
954 res_nclose(statp);
955 return (0);
956 }
957 errno = 0;
958 fromlen = sizeof(from);
959 resplen = recvfrom(s, (char*)ans, anssiz,0,
960 (struct sockaddr *)&from, &fromlen);
961 if (resplen <= 0) {
962 Perror(statp, stderr, "recvfrom", errno);
963 res_nclose(statp);
964 return (0);
965 }
966 *gotsomewhere = 1;
967 if (resplen < HFIXEDSZ) {
968 /*
969 * Undersized message.
970 */
971 Dprint(statp->options & RES_DEBUG,
972 (stdout, ";; undersized: %d\n",
973 resplen));
974 *terrno = EMSGSIZE;
975 res_nclose(statp);
976 return (0);
977 }
978 if (hp->id != anhp->id) {
979 /*
980 * response from old query, ignore it.
981 * XXX - potential security hazard could
982 * be detected here.
983 */
984 DprintQ((statp->options & RES_DEBUG) ||
985 (statp->pfcode & RES_PRF_REPLY),
986 (stdout, ";; old answer:\n"),
987 ans, (resplen > anssiz) ? anssiz : resplen);
988 goto wait;
989 }
990 if (!(statp->options & RES_INSECURE1) &&
991 !res_ourserver_p(statp, (struct sockaddr *)&from)) {
992 /*
993 * response from wrong server? ignore it.
994 * XXX - potential security hazard could
995 * be detected here.
996 */
997 DprintQ((statp->options & RES_DEBUG) ||
998 (statp->pfcode & RES_PRF_REPLY),
999 (stdout, ";; not our server:\n"),
1000 ans, (resplen > anssiz) ? anssiz : resplen);
1001 goto wait;
1002 }
1003 #ifdef RES_USE_EDNS0
1004 if (anhp->rcode == FORMERR && (statp->options & RES_USE_EDNS0) != 0U) {
1005 /*
1006 * Do not retry if the server do not understand EDNS0.
1007 * The case has to be captured here, as FORMERR packet do not
1008 * carry query section, hence res_queriesmatch() returns 0.
1009 */
1010 DprintQ(statp->options & RES_DEBUG,
1011 (stdout, "server rejected query with EDNS0:\n"),
1012 ans, (resplen > anssiz) ? anssiz : resplen);
1013 /* record the error */
1014 statp->_flags |= RES_F_EDNS0ERR;
1015 res_nclose(statp);
1016 return (0);
1017 }
1018 #endif
1019 if (!(statp->options & RES_INSECURE2) &&
1020 !res_queriesmatch(buf, buf + buflen,
1021 ans, ans + anssiz)) {
1022 /*
1023 * response contains wrong query? ignore it.
1024 * XXX - potential security hazard could
1025 * be detected here.
1026 */
1027 DprintQ((statp->options & RES_DEBUG) ||
1028 (statp->pfcode & RES_PRF_REPLY),
1029 (stdout, ";; wrong query name:\n"),
1030 ans, (resplen > anssiz) ? anssiz : resplen);
1031 goto wait;
1032 }
1033 if (anhp->rcode == SERVFAIL ||
1034 anhp->rcode == NOTIMP ||
1035 anhp->rcode == REFUSED) {
1036 DprintQ(statp->options & RES_DEBUG,
1037 (stdout, "server rejected query:\n"),
1038 ans, (resplen > anssiz) ? anssiz : resplen);
1039 res_nclose(statp);
1040 /* don't retry if called from dig */
1041 if (!statp->pfcode)
1042 return (0);
1043 }
1044 if (!(statp->options & RES_IGNTC) && anhp->tc) {
1045 /*
1046 * To get the rest of answer,
1047 * use TCP with same server.
1048 */
1049 Dprint(statp->options & RES_DEBUG,
1050 (stdout, ";; truncated answer\n"));
1051 *v_circuit = 1;
1052 res_nclose(statp);
1053 return (1);
1054 }
1055 /*
1056 * All is well, or the error is fatal. Signal that the
1057 * next nameserver ought not be tried.
1058 */
1059 return (resplen);
1060 }
1061
1062 static void
Aerror(const res_state statp,FILE * file,const char * string,int error,const struct sockaddr * address,int alen)1063 Aerror(const res_state statp, FILE *file, const char *string, int error,
1064 const struct sockaddr *address, int alen)
1065 {
1066 int save = errno;
1067 char hbuf[NI_MAXHOST];
1068 char sbuf[NI_MAXSERV];
1069
1070 alen = alen;
1071
1072 if ((statp->options & RES_DEBUG) != 0U) {
1073 if (getnameinfo(address, alen, hbuf, sizeof(hbuf),
1074 sbuf, sizeof(sbuf), niflags)) {
1075 strncpy(hbuf, "?", sizeof(hbuf) - 1);
1076 hbuf[sizeof(hbuf) - 1] = '\0';
1077 strncpy(sbuf, "?", sizeof(sbuf) - 1);
1078 sbuf[sizeof(sbuf) - 1] = '\0';
1079 }
1080 fprintf(file, "res_send: %s ([%s].%s): %s\n",
1081 string, hbuf, sbuf, strerror(error));
1082 }
1083 errno = save;
1084 }
1085
1086 static void
Perror(const res_state statp,FILE * file,const char * string,int error)1087 Perror(const res_state statp, FILE *file, const char *string, int error) {
1088 int save = errno;
1089
1090 if ((statp->options & RES_DEBUG) != 0U)
1091 fprintf(file, "res_send: %s: %s\n",
1092 string, strerror(error));
1093 errno = save;
1094 }
1095
1096 static int
sock_eq(struct sockaddr * a,struct sockaddr * b)1097 sock_eq(struct sockaddr *a, struct sockaddr *b) {
1098 struct sockaddr_in *a4, *b4;
1099 struct sockaddr_in6 *a6, *b6;
1100
1101 if (a->sa_family != b->sa_family)
1102 return 0;
1103 switch (a->sa_family) {
1104 case AF_INET:
1105 a4 = (struct sockaddr_in *)a;
1106 b4 = (struct sockaddr_in *)b;
1107 return a4->sin_port == b4->sin_port &&
1108 a4->sin_addr.s_addr == b4->sin_addr.s_addr;
1109 case AF_INET6:
1110 a6 = (struct sockaddr_in6 *)a;
1111 b6 = (struct sockaddr_in6 *)b;
1112 return a6->sin6_port == b6->sin6_port &&
1113 #ifdef HAVE_SIN6_SCOPE_ID
1114 a6->sin6_scope_id == b6->sin6_scope_id &&
1115 #endif
1116 IN6_ARE_ADDR_EQUAL(&a6->sin6_addr, &b6->sin6_addr);
1117 default:
1118 return 0;
1119 }
1120 }
1121
1122 #if defined(NEED_PSELECT) && !defined(USE_POLL)
1123 /* XXX needs to move to the porting library. */
1124 static int
pselect(int nfds,void * rfds,void * wfds,void * efds,struct timespec * tsp,const sigset_t * sigmask)1125 pselect(int nfds, void *rfds, void *wfds, void *efds,
1126 struct timespec *tsp, const sigset_t *sigmask)
1127 {
1128 struct timeval tv, *tvp;
1129 sigset_t sigs;
1130 int n;
1131
1132 if (tsp) {
1133 tvp = &tv;
1134 tv = evTimeVal(*tsp);
1135 } else
1136 tvp = NULL;
1137 if (sigmask)
1138 sigprocmask(SIG_SETMASK, sigmask, &sigs);
1139 n = select(nfds, rfds, wfds, efds, tvp);
1140 if (sigmask)
1141 sigprocmask(SIG_SETMASK, &sigs, NULL);
1142 if (tsp)
1143 *tsp = evTimeSpec(tv);
1144 return (n);
1145 }
1146 #endif
1147