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