2 * Copyright (c) 1985, 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
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.
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
51 * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
53 * Permission to use, copy, modify, and distribute this software for any
54 * purpose with or without fee is hereby granted, provided that the above
55 * copyright notice and this permission notice appear in all copies.
57 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
58 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
59 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
60 * CONSORTIUM 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
67 #if defined(LIBC_SCCS) && !defined(lint)
68 static const char sccsid[] = "@(#)res_send.c 8.1 (Berkeley) 6/4/93";
69 static const char rcsid[] = "$BINDId: res_send.c,v 8.38 2000/03/30 20:16:51 vixie Exp $";
70 #endif /* LIBC_SCCS and not lint */
73 * Send query to name server and wait for reply.
77 #include <sys/types.h>
78 #include <sys/param.h>
80 #include <sys/socket.h>
84 #include <netinet/in.h>
85 #include <arpa/nameser.h>
86 #include <arpa/inet.h>
87 #include <sys/ioctl.h>
98 #include <kernel-features.h>
101 #define MAXPACKET PACKETSZ
103 #define MAXPACKET 65536
107 #ifndef __ASSUME_SOCK_CLOEXEC
108 static int __have_o_nonblock;
110 # define __have_o_nonblock 0
114 /* From ev_streams.c. */
117 __attribute ((always_inline))
118 evConsIovec(void *buf, size_t cnt, struct iovec *vec) {
119 memset(vec, 0xf5, sizeof (*vec));
124 /* From ev_timers.c. */
126 #define BILLION 1000000000
129 evConsTime(struct timespec *res, time_t sec, long nsec) {
135 evAddTime(struct timespec *res, const struct timespec *addend1,
136 const struct timespec *addend2) {
137 res->tv_sec = addend1->tv_sec + addend2->tv_sec;
138 res->tv_nsec = addend1->tv_nsec + addend2->tv_nsec;
139 if (res->tv_nsec >= BILLION) {
141 res->tv_nsec -= BILLION;
146 evSubTime(struct timespec *res, const struct timespec *minuend,
147 const struct timespec *subtrahend) {
148 res->tv_sec = minuend->tv_sec - subtrahend->tv_sec;
149 if (minuend->tv_nsec >= subtrahend->tv_nsec)
150 res->tv_nsec = minuend->tv_nsec - subtrahend->tv_nsec;
152 res->tv_nsec = (BILLION
153 - subtrahend->tv_nsec + minuend->tv_nsec);
159 evCmpTime(struct timespec a, struct timespec b) {
160 long x = a.tv_sec - b.tv_sec;
163 x = a.tv_nsec - b.tv_nsec;
164 return (x < 0L ? (-1) : x > 0L ? (1) : (0));
168 evNowTime(struct timespec *res) {
171 if (gettimeofday(&now, NULL) < 0)
172 evConsTime(res, 0, 0);
174 TIMEVAL_TO_TIMESPEC (&now, res);
178 /* Options. Leave them on. */
180 #include "res_debug.h"
182 #define EXT(res) ((res)->_u._ext)
186 static int send_vc(res_state, const u_char *, int,
188 u_char **, int *, int *, int, u_char **,
189 u_char **, int *, int *);
190 static int send_dg(res_state, const u_char *, int,
192 u_char **, int *, int *, int,
193 int *, int *, u_char **,
194 u_char **, int *, int *);
196 static void Aerror(const res_state, FILE *, const char *, int,
197 const struct sockaddr *);
198 static void Perror(const res_state, FILE *, const char *, int);
200 static int sock_eq(struct sockaddr_in6 *, struct sockaddr_in6 *);
205 * res_isourserver(ina)
206 * looks up "ina" in _res.ns_addr_list[]
211 * paul vixie, 29may94
214 res_ourserver_p(const res_state statp, const struct sockaddr_in6 *inp)
218 if (inp->sin6_family == AF_INET) {
219 struct sockaddr_in *in4p = (struct sockaddr_in *) inp;
220 in_port_t port = in4p->sin_port;
221 in_addr_t addr = in4p->sin_addr.s_addr;
223 for (ns = 0; ns < MAXNS; ns++) {
224 const struct sockaddr_in *srv =
225 (struct sockaddr_in *)EXT(statp).nsaddrs[ns];
227 if ((srv != NULL) && (srv->sin_family == AF_INET) &&
228 (srv->sin_port == port) &&
229 (srv->sin_addr.s_addr == INADDR_ANY ||
230 srv->sin_addr.s_addr == addr))
233 } else if (inp->sin6_family == AF_INET6) {
234 for (ns = 0; ns < MAXNS; ns++) {
235 const struct sockaddr_in6 *srv = EXT(statp).nsaddrs[ns];
236 if ((srv != NULL) && (srv->sin6_family == AF_INET6) &&
237 (srv->sin6_port == inp->sin6_port) &&
238 !(memcmp(&srv->sin6_addr, &in6addr_any,
239 sizeof (struct in6_addr)) &&
240 memcmp(&srv->sin6_addr, &inp->sin6_addr,
241 sizeof (struct in6_addr))))
249 * res_nameinquery(name, type, class, buf, eom)
250 * look for (name,type,class) in the query section of packet (buf,eom)
252 * buf + HFIXEDSZ <= eom
258 * paul vixie, 29may94
261 res_nameinquery(const char *name, int type, int class,
262 const u_char *buf, const u_char *eom)
264 const u_char *cp = buf + HFIXEDSZ;
265 int qdcount = ntohs(((HEADER*)buf)->qdcount);
267 while (qdcount-- > 0) {
268 char tname[MAXDNAME+1];
269 int n, ttype, tclass;
271 n = dn_expand(buf, eom, cp, tname, sizeof tname);
275 if (cp + 2 * INT16SZ > eom)
278 NS_GET16(tclass, cp);
279 if (ttype == type && tclass == class &&
280 ns_samename(tname, name) == 1)
285 libresolv_hidden_def (res_nameinquery)
288 * res_queriesmatch(buf1, eom1, buf2, eom2)
289 * is there a 1:1 mapping of (name,type,class)
290 * in (buf1,eom1) and (buf2,eom2)?
293 * 0 : not a 1:1 mapping
294 * >0 : is a 1:1 mapping
296 * paul vixie, 29may94
299 res_queriesmatch(const u_char *buf1, const u_char *eom1,
300 const u_char *buf2, const u_char *eom2)
302 if (buf1 + HFIXEDSZ > eom1 || buf2 + HFIXEDSZ > eom2)
306 * Only header section present in replies to
307 * dynamic update packets.
309 if ((((HEADER *)buf1)->opcode == ns_o_update) &&
310 (((HEADER *)buf2)->opcode == ns_o_update))
313 /* Note that we initially do not convert QDCOUNT to the host byte
314 order. We can compare it with the second buffer's QDCOUNT
315 value without doing this. */
316 int qdcount = ((HEADER*)buf1)->qdcount;
317 if (qdcount != ((HEADER*)buf2)->qdcount)
320 qdcount = htons (qdcount);
321 const u_char *cp = buf1 + HFIXEDSZ;
323 while (qdcount-- > 0) {
324 char tname[MAXDNAME+1];
325 int n, ttype, tclass;
327 n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
331 if (cp + 2 * INT16SZ > eom1)
334 NS_GET16(tclass, cp);
335 if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
340 libresolv_hidden_def (res_queriesmatch)
343 __libc_res_nsend(res_state statp, const u_char *buf, int buflen,
344 const u_char *buf2, int buflen2,
345 u_char *ans, int anssiz, u_char **ansp, u_char **ansp2,
346 int *nansp2, int *resplen2)
348 int gotsomewhere, terrno, try, v_circuit, resplen, ns, n;
350 if (statp->nscount == 0) {
355 if (anssiz < (buf2 == NULL ? 1 : 2) * HFIXEDSZ) {
356 __set_errno (EINVAL);
361 if (__builtin_expect (statp->qhook || statp->rhook, 0)) {
362 if (anssiz < MAXPACKET && ansp) {
363 u_char *buf = malloc (MAXPACKET);
366 memcpy (buf, ans, HFIXEDSZ);
374 DprintQ((statp->options & RES_DEBUG) || (statp->pfcode & RES_PRF_QUERY),
375 (stdout, ";; res_send()\n"), buf, buflen);
376 v_circuit = ((statp->options & RES_USEVC)
378 || buflen2 > PACKETSZ);
383 * If the ns_addr_list in the resolver context has changed, then
384 * invalidate our cached copy and the associated timing data.
386 if (EXT(statp).nsinit) {
389 if (EXT(statp).nscount != statp->nscount)
392 for (ns = 0; ns < MAXNS; ns++) {
393 unsigned int map = EXT(statp).nsmap[ns];
395 && !sock_eq((struct sockaddr_in6 *)
396 &statp->nsaddr_list[map],
397 EXT(statp).nsaddrs[ns]))
404 __res_iclose(statp, false);
408 * Maybe initialize our private copy of the ns_addr_list.
410 if (EXT(statp).nsinit == 0) {
411 unsigned char map[MAXNS];
413 memset (map, MAXNS, sizeof (map));
414 for (n = 0; n < MAXNS; n++) {
415 ns = EXT(statp).nsmap[n];
416 if (ns < statp->nscount)
418 else if (ns < MAXNS) {
419 free(EXT(statp).nsaddrs[n]);
420 EXT(statp).nsaddrs[n] = NULL;
421 EXT(statp).nsmap[n] = MAXNS;
425 if (statp->nscount > EXT(statp).nscount)
426 for (n = EXT(statp).nscount, ns = 0;
427 n < statp->nscount; n++) {
429 && EXT(statp).nsmap[ns] != MAXNS)
433 EXT(statp).nsmap[ns] = n;
436 EXT(statp).nscount = n;
437 for (ns = 0; ns < EXT(statp).nscount; ns++) {
439 if (EXT(statp).nsaddrs[n] == NULL)
440 EXT(statp).nsaddrs[n] =
441 malloc(sizeof (struct sockaddr_in6));
442 if (EXT(statp).nsaddrs[n] != NULL) {
443 memset (mempcpy(EXT(statp).nsaddrs[n],
444 &statp->nsaddr_list[n],
445 sizeof (struct sockaddr_in)),
447 sizeof (struct sockaddr_in6)
448 - sizeof (struct sockaddr_in));
449 EXT(statp).nssocks[n] = -1;
453 EXT(statp).nsinit = 1;
457 * Some resolvers want to even out the load on their nameservers.
458 * Note that RES_BLAST overrides RES_ROTATE.
460 if (__builtin_expect ((statp->options & RES_ROTATE) != 0, 0) &&
461 (statp->options & RES_BLAST) == 0) {
462 struct sockaddr_in6 *ina;
466 while (n < MAXNS && EXT(statp).nsmap[n] == MAXNS)
469 ina = EXT(statp).nsaddrs[n];
470 map = EXT(statp).nsmap[n];
474 && EXT(statp).nsmap[ns] == MAXNS)
478 EXT(statp).nsaddrs[n] = EXT(statp).nsaddrs[ns];
479 EXT(statp).nsmap[n] = EXT(statp).nsmap[ns];
482 EXT(statp).nsaddrs[n] = ina;
483 EXT(statp).nsmap[n] = map;
488 * Send request, RETRY times, or until successful.
490 for (try = 0; try < statp->retry; try++) {
491 for (ns = 0; ns < MAXNS; ns++)
496 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
502 if (__builtin_expect (statp->qhook != NULL, 0)) {
503 int done = 0, loops = 0;
508 struct sockaddr_in *nsap4;
509 nsap4 = (struct sockaddr_in *) nsap;
510 act = (*statp->qhook)(&nsap4, &buf, &buflen,
511 ans, anssiz, &resplen);
512 nsap = (struct sockaddr_in6 *) nsap4;
518 __res_iclose(statp, false);
523 /* give the hook another try */
524 if (++loops < 42) /*doug adams*/
536 Dprint(statp->options & RES_DEBUG,
537 (stdout, ";; Querying server (# %d) address = %s\n",
538 ns + 1, inet_ntop(nsap->sin6_family,
539 (nsap->sin6_family == AF_INET6
541 : &((struct sockaddr_in *) nsap)->sin_addr),
542 tmpbuf, sizeof (tmpbuf))));
544 if (__builtin_expect (v_circuit, 0)) {
545 /* Use VC; at most one attempt per server. */
547 n = send_vc(statp, buf, buflen, buf2, buflen2,
548 &ans, &anssiz, &terrno,
549 ns, ansp, ansp2, nansp2, resplen2);
556 n = send_dg(statp, buf, buflen, buf2, buflen2,
557 &ans, &anssiz, &terrno,
558 ns, &v_circuit, &gotsomewhere, ansp,
559 ansp2, nansp2, resplen2);
565 // XXX Check whether both requests failed or
566 // XXX whether one has been answered successfully
572 Dprint((statp->options & RES_DEBUG) ||
573 ((statp->pfcode & RES_PRF_REPLY) &&
574 (statp->pfcode & RES_PRF_HEAD1)),
575 (stdout, ";; got answer:\n"));
577 DprintQ((statp->options & RES_DEBUG) ||
578 (statp->pfcode & RES_PRF_REPLY),
580 ans, (resplen > anssiz) ? anssiz : resplen);
582 DprintQ((statp->options & RES_DEBUG) ||
583 (statp->pfcode & RES_PRF_REPLY),
585 *ansp2, (*resplen2 > *nansp2) ? *nansp2 : *resplen2);
589 * If we have temporarily opened a virtual circuit,
590 * or if we haven't been asked to keep a socket open,
593 if ((v_circuit && (statp->options & RES_USEVC) == 0) ||
594 (statp->options & RES_STAYOPEN) == 0) {
595 __res_iclose(statp, false);
598 if (__builtin_expect (statp->rhook, 0)) {
599 int done = 0, loops = 0;
604 act = (*statp->rhook)((struct sockaddr_in *)
606 ans, anssiz, &resplen);
613 __res_iclose(statp, false);
616 /* give the hook another try */
617 if (++loops < 42) /*doug adams*/
633 __res_iclose(statp, false);
636 __set_errno (ECONNREFUSED); /* no nameservers found */
638 __set_errno (ETIMEDOUT); /* no answer obtained */
640 __set_errno (terrno);
645 res_nsend(res_state statp,
646 const u_char *buf, int buflen, u_char *ans, int anssiz)
648 return __libc_res_nsend(statp, buf, buflen, NULL, 0, ans, anssiz,
649 NULL, NULL, NULL, NULL);
651 libresolv_hidden_def (res_nsend)
656 send_vc(res_state statp,
657 const u_char *buf, int buflen, const u_char *buf2, int buflen2,
658 u_char **ansp, int *anssizp,
659 int *terrno, int ns, u_char **anscp, u_char **ansp2, int *anssizp2,
662 const HEADER *hp = (HEADER *) buf;
663 const HEADER *hp2 = (HEADER *) buf2;
665 int orig_anssizp = *anssizp;
667 // int anssiz = *anssizp;
668 HEADER *anhp = (HEADER *) ans;
669 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
670 int truncating, connreset, resplen, n;
676 if (resplen2 != NULL)
682 /* Are we still talking to whom we want to talk to? */
683 if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
684 struct sockaddr_in6 peer;
685 socklen_t size = sizeof peer;
687 if (getpeername(statp->_vcsock,
688 (struct sockaddr *)&peer, &size) < 0 ||
689 !sock_eq(&peer, nsap)) {
690 __res_iclose(statp, false);
691 statp->_flags &= ~RES_F_VC;
695 if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
696 if (statp->_vcsock >= 0)
697 __res_iclose(statp, false);
699 statp->_vcsock = socket(nsap->sin6_family, SOCK_STREAM, 0);
700 if (statp->_vcsock < 0) {
702 Perror(statp, stderr, "socket(vc)", errno);
706 if (connect(statp->_vcsock, (struct sockaddr *)nsap,
707 nsap->sin6_family == AF_INET
708 ? sizeof (struct sockaddr_in)
709 : sizeof (struct sockaddr_in6)) < 0) {
711 Aerror(statp, stderr, "connect/vc", errno,
712 (struct sockaddr *) nsap);
713 __res_iclose(statp, false);
716 statp->_flags |= RES_F_VC;
720 * Send length & message
722 len = htons ((u_short) buflen);
723 evConsIovec(&len, INT16SZ, &iov[0]);
724 evConsIovec((void*)buf, buflen, &iov[1]);
726 ssize_t explen = INT16SZ + buflen;
728 len2 = htons ((u_short) buflen2);
729 evConsIovec(&len2, INT16SZ, &iov[2]);
730 evConsIovec((void*)buf2, buflen2, &iov[3]);
732 explen += INT16SZ + buflen2;
734 if (TEMP_FAILURE_RETRY (writev(statp->_vcsock, iov, niov)) != explen) {
736 Perror(statp, stderr, "write failed", errno);
737 __res_iclose(statp, false);
741 * Receive length & response
744 int recvresp2 = buf2 == NULL;
747 cp = (u_char *)&rlen16;
748 len = sizeof(rlen16);
749 while ((n = TEMP_FAILURE_RETRY (read(statp->_vcsock, cp,
757 Perror(statp, stderr, "read failed", errno);
758 __res_iclose(statp, false);
760 * A long running process might get its TCP
761 * connection reset if the remote server was
762 * restarted. Requery the server instead of
763 * trying a new one. When there is only one
764 * server, this means that a query might work
765 * instead of failing. We only allow one reset
766 * per query to prevent looping.
768 if (*terrno == ECONNRESET && !connreset) {
774 int rlen = ntohs (rlen16);
779 if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) {
780 thisanssizp = anssizp;
781 thisansp = anscp ?: ansp;
782 assert (anscp != NULL || ansp2 == NULL);
783 thisresplenp = &resplen;
785 if (*anssizp != MAXPACKET) {
786 /* No buffer allocated for the first
787 reply. We can try to use the rest
788 of the user-provided buffer. */
789 #ifdef _STRING_ARCH_unaligned
790 *anssizp2 = orig_anssizp - resplen;
791 *ansp2 = *ansp + resplen;
794 = ((resplen + __alignof__ (HEADER) - 1)
795 & ~(__alignof__ (HEADER) - 1));
796 *anssizp2 = orig_anssizp - aligned_resplen;
797 *ansp2 = *ansp + aligned_resplen;
800 /* The first reply did not fit into the
801 user-provided buffer. Maybe the second
803 *anssizp2 = orig_anssizp;
807 thisanssizp = anssizp2;
809 thisresplenp = resplen2;
811 anhp = (HEADER *) *thisansp;
813 *thisresplenp = rlen;
814 if (rlen > *thisanssizp) {
815 /* Yes, we test ANSCP here. If we have two buffers
816 both will be allocatable. */
817 if (__builtin_expect (anscp != NULL, 1)) {
818 u_char *newp = malloc (MAXPACKET);
821 __res_iclose(statp, false);
824 *thisanssizp = MAXPACKET;
826 anhp = (HEADER *) newp;
829 Dprint(statp->options & RES_DEBUG,
830 (stdout, ";; response truncated\n")
838 if (__builtin_expect (len < HFIXEDSZ, 0)) {
840 * Undersized message.
842 Dprint(statp->options & RES_DEBUG,
843 (stdout, ";; undersized: %d\n", len));
845 __res_iclose(statp, false);
850 while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
854 if (__builtin_expect (n <= 0, 0)) {
856 Perror(statp, stderr, "read(vc)", errno);
857 __res_iclose(statp, false);
860 if (__builtin_expect (truncating, 0)) {
862 * Flush rest of answer so connection stays in synch.
865 len = rlen - *thisanssizp;
869 n = read(statp->_vcsock, junk,
870 (len > sizeof junk) ? sizeof junk : len);
878 * If the calling applicating has bailed out of
879 * a previous call and failed to arrange to have
880 * the circuit closed or the server has got
881 * itself confused, then drop the packet and
882 * wait for the correct one.
884 if ((recvresp1 || hp->id != anhp->id)
885 && (recvresp2 || hp2->id != anhp->id)) {
886 DprintQ((statp->options & RES_DEBUG) ||
887 (statp->pfcode & RES_PRF_REPLY),
888 (stdout, ";; old answer (unexpected):\n"),
890 (rlen > *thisanssizp) ? *thisanssizp: rlen);
894 /* Mark which reply we received. */
895 if (recvresp1 == 0 && hp->id == anhp->id)
899 /* Repeat waiting if we have a second answer to arrive. */
900 if ((recvresp1 & recvresp2) == 0)
904 * All is well, or the error is fatal. Signal that the
905 * next nameserver ought not be tried.
911 reopen (res_state statp, int *terrno, int ns)
913 if (EXT(statp).nssocks[ns] == -1) {
914 struct sockaddr *nsap
915 = (struct sockaddr *) EXT(statp).nsaddrs[ns];
918 /* only try IPv6 if IPv6 NS and if not failed before */
919 if (nsap->sa_family == AF_INET6 && !statp->ipv6_unavail) {
920 if (__builtin_expect (__have_o_nonblock >= 0, 1)) {
921 EXT(statp).nssocks[ns] =
922 socket(PF_INET6, SOCK_DGRAM|SOCK_NONBLOCK,
924 #ifndef __ASSUME_SOCK_CLOEXEC
925 if (__have_o_nonblock == 0)
927 = (EXT(statp).nssocks[ns] == -1
928 && errno == EINVAL ? -1 : 1);
931 if (__builtin_expect (__have_o_nonblock < 0, 0))
932 EXT(statp).nssocks[ns] =
933 socket(PF_INET6, SOCK_DGRAM, 0);
934 if (EXT(statp).nssocks[ns] < 0)
935 statp->ipv6_unavail = errno == EAFNOSUPPORT;
936 slen = sizeof (struct sockaddr_in6);
937 } else if (nsap->sa_family == AF_INET) {
938 if (__builtin_expect (__have_o_nonblock >= 0, 1)) {
939 EXT(statp).nssocks[ns]
940 = socket(PF_INET, SOCK_DGRAM|SOCK_NONBLOCK,
942 #ifndef __ASSUME_SOCK_CLOEXEC
943 if (__have_o_nonblock == 0)
945 = (EXT(statp).nssocks[ns] == -1
946 && errno == EINVAL ? -1 : 1);
949 if (__builtin_expect (__have_o_nonblock < 0, 0))
950 EXT(statp).nssocks[ns]
951 = socket(PF_INET, SOCK_DGRAM, 0);
952 slen = sizeof (struct sockaddr_in);
954 if (EXT(statp).nssocks[ns] < 0) {
956 Perror(statp, stderr, "socket(dg)", errno);
961 * On a 4.3BSD+ machine (client and server,
962 * actually), sending to a nameserver datagram
963 * port with no nameserver will cause an
964 * ICMP port unreachable message to be returned.
965 * If our datagram socket is "connected" to the
966 * server, we get an ECONNREFUSED error on the next
967 * socket operation, and select returns if the
968 * error message is received. We can thus detect
969 * the absence of a nameserver without timing out.
971 if (connect(EXT(statp).nssocks[ns], nsap, slen) < 0) {
972 Aerror(statp, stderr, "connect(dg)", errno, nsap);
973 __res_iclose(statp, false);
976 if (__builtin_expect (__have_o_nonblock < 0, 0)) {
977 /* Make socket non-blocking. */
978 int fl = __fcntl (EXT(statp).nssocks[ns], F_GETFL);
980 __fcntl (EXT(statp).nssocks[ns], F_SETFL,
982 Dprint(statp->options & RES_DEBUG,
983 (stdout, ";; new DG socket\n"))
991 send_dg(res_state statp,
992 const u_char *buf, int buflen, const u_char *buf2, int buflen2,
993 u_char **ansp, int *anssizp,
994 int *terrno, int ns, int *v_circuit, int *gotsomewhere, u_char **anscp,
995 u_char **ansp2, int *anssizp2, int *resplen2)
997 const HEADER *hp = (HEADER *) buf;
998 const HEADER *hp2 = (HEADER *) buf2;
1000 int orig_anssizp = *anssizp;
1001 struct timespec now, timeout, finish;
1002 struct pollfd pfd[1];
1004 struct sockaddr_in6 from;
1009 * Compute time for the total operation.
1011 int seconds = (statp->retrans << ns);
1013 seconds /= statp->nscount;
1016 bool single_request = (statp->options & RES_SNGLKUP) != 0;
1017 bool single_request_reopen = (statp->options & RES_SNGLKUPREOP) != 0;
1018 int save_gotsomewhere = *gotsomewhere;
1022 retval = reopen (statp, terrno, ns);
1027 evConsTime(&timeout, seconds, 0);
1028 evAddTime(&finish, &now, &timeout);
1029 int need_recompute = 0;
1032 int recvresp2 = buf2 == NULL;
1033 pfd[0].fd = EXT(statp).nssocks[ns];
1034 pfd[0].events = POLLOUT;
1035 if (resplen2 != NULL)
1038 if (need_recompute) {
1041 if (evCmpTime(finish, now) <= 0) {
1043 Perror(statp, stderr, "poll", errno);
1045 __res_iclose(statp, false);
1048 evSubTime(&timeout, &finish, &now);
1051 /* Convert struct timespec in milliseconds. */
1052 ptimeout = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
1056 n = __poll (pfd, 1, 0);
1057 if (__builtin_expect (n == 0, 0)) {
1058 n = __poll (pfd, 1, ptimeout);
1062 Dprint(statp->options & RES_DEBUG, (stdout, ";; timeout\n"));
1063 if (resplen > 1 && (recvresp1 || (buf2 != NULL && recvresp2)))
1065 /* There are quite a few broken name servers out
1066 there which don't handle two outstanding
1067 requests from the same source. There are also
1068 broken firewall settings. If we time out after
1069 having received one answer switch to the mode
1070 where we send the second request only once we
1071 have received the first answer. */
1072 if (!single_request)
1074 statp->options |= RES_SNGLKUP;
1075 single_request = true;
1076 *gotsomewhere = save_gotsomewhere;
1079 else if (!single_request_reopen)
1081 statp->options |= RES_SNGLKUPREOP;
1082 single_request_reopen = true;
1083 *gotsomewhere = save_gotsomewhere;
1084 __res_iclose (statp, false);
1097 goto recompute_resend;
1102 if (pfd[0].revents & POLLOUT) {
1105 sr = send (pfd[0].fd, buf2, buflen2, MSG_NOSIGNAL);
1107 sr = send (pfd[0].fd, buf, buflen, MSG_NOSIGNAL);
1110 if (errno == EINTR || errno == EAGAIN)
1111 goto recompute_resend;
1112 Perror(statp, stderr, "send", errno);
1115 if (nwritten != 0 || buf2 == NULL
1116 || single_request || single_request_reopen)
1117 pfd[0].events = POLLIN;
1119 pfd[0].events = POLLIN | POLLOUT;
1122 } else if (pfd[0].revents & POLLIN) {
1127 if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) {
1128 thisanssizp = anssizp;
1129 thisansp = anscp ?: ansp;
1130 assert (anscp != NULL || ansp2 == NULL);
1131 thisresplenp = &resplen;
1133 if (*anssizp != MAXPACKET) {
1134 /* No buffer allocated for the first
1135 reply. We can try to use the rest
1136 of the user-provided buffer. */
1137 #ifdef _STRING_ARCH_unaligned
1138 *anssizp2 = orig_anssizp - resplen;
1139 *ansp2 = *ansp + resplen;
1142 = ((resplen + __alignof__ (HEADER) - 1)
1143 & ~(__alignof__ (HEADER) - 1));
1144 *anssizp2 = orig_anssizp - aligned_resplen;
1145 *ansp2 = *ansp + aligned_resplen;
1148 /* The first reply did not fit into the
1149 user-provided buffer. Maybe the second
1151 *anssizp2 = orig_anssizp;
1155 thisanssizp = anssizp2;
1157 thisresplenp = resplen2;
1160 if (*thisanssizp < MAXPACKET
1161 /* Yes, we test ANSCP here. If we have two buffers
1162 both will be allocatable. */
1164 && (ioctl (pfd[0].fd, FIONREAD, thisresplenp) < 0
1165 || *thisanssizp < *thisresplenp)) {
1166 u_char *newp = malloc (MAXPACKET);
1168 *anssizp = MAXPACKET;
1169 *thisansp = ans = newp;
1172 HEADER *anhp = (HEADER *) *thisansp;
1173 socklen_t fromlen = sizeof(struct sockaddr_in6);
1174 assert (sizeof(from) <= fromlen);
1175 *thisresplenp = recvfrom(pfd[0].fd, (char*)*thisansp,
1177 (struct sockaddr *)&from, &fromlen);
1178 if (__builtin_expect (*thisresplenp <= 0, 0)) {
1179 if (errno == EINTR || errno == EAGAIN) {
1183 Perror(statp, stderr, "recvfrom", errno);
1187 if (__builtin_expect (*thisresplenp < HFIXEDSZ, 0)) {
1189 * Undersized message.
1191 Dprint(statp->options & RES_DEBUG,
1192 (stdout, ";; undersized: %d\n",
1197 if ((recvresp1 || hp->id != anhp->id)
1198 && (recvresp2 || hp2->id != anhp->id)) {
1200 * response from old query, ignore it.
1201 * XXX - potential security hazard could
1204 DprintQ((statp->options & RES_DEBUG) ||
1205 (statp->pfcode & RES_PRF_REPLY),
1206 (stdout, ";; old answer:\n"),
1208 (*thisresplenp > *thisanssizp)
1209 ? *thisanssizp : *thisresplenp);
1212 if (!(statp->options & RES_INSECURE1) &&
1213 !res_ourserver_p(statp, &from)) {
1215 * response from wrong server? ignore it.
1216 * XXX - potential security hazard could
1219 DprintQ((statp->options & RES_DEBUG) ||
1220 (statp->pfcode & RES_PRF_REPLY),
1221 (stdout, ";; not our server:\n"),
1223 (*thisresplenp > *thisanssizp)
1224 ? *thisanssizp : *thisresplenp);
1227 #ifdef RES_USE_EDNS0
1228 if (anhp->rcode == FORMERR
1229 && (statp->options & RES_USE_EDNS0) != 0U) {
1231 * Do not retry if the server does not understand
1232 * EDNS0. The case has to be captured here, as
1233 * FORMERR packet do not carry query section, hence
1234 * res_queriesmatch() returns 0.
1236 DprintQ(statp->options & RES_DEBUG,
1238 "server rejected query with EDNS0:\n"),
1240 (*thisresplenp > *thisanssizp)
1241 ? *thisanssizp : *thisresplenp);
1242 /* record the error */
1243 statp->_flags |= RES_F_EDNS0ERR;
1247 if (!(statp->options & RES_INSECURE2)
1248 && (recvresp1 || !res_queriesmatch(buf, buf + buflen,
1252 && (recvresp2 || !res_queriesmatch(buf2, buf2 + buflen2,
1257 * response contains wrong query? ignore it.
1258 * XXX - potential security hazard could
1261 DprintQ((statp->options & RES_DEBUG) ||
1262 (statp->pfcode & RES_PRF_REPLY),
1263 (stdout, ";; wrong query name:\n"),
1265 (*thisresplenp > *thisanssizp)
1266 ? *thisanssizp : *thisresplenp);
1269 if (anhp->rcode == SERVFAIL ||
1270 anhp->rcode == NOTIMP ||
1271 anhp->rcode == REFUSED) {
1272 DprintQ(statp->options & RES_DEBUG,
1273 (stdout, "server rejected query:\n"),
1275 (*thisresplenp > *thisanssizp)
1276 ? *thisanssizp : *thisresplenp);
1278 if (recvresp1 || (buf2 != NULL && recvresp2))
1282 /* We are waiting for a possible second reply. */
1283 if (hp->id == anhp->id)
1292 __res_iclose(statp, false);
1293 /* don't retry if called from dig */
1297 if (anhp->rcode == NOERROR && anhp->ancount == 0
1298 && anhp->aa == 0 && anhp->ra == 0 && anhp->arcount == 0) {
1299 DprintQ(statp->options & RES_DEBUG,
1300 (stdout, "referred query:\n"),
1302 (*thisresplenp > *thisanssizp)
1303 ? *thisanssizp : *thisresplenp);
1306 if (!(statp->options & RES_IGNTC) && anhp->tc) {
1308 * To get the rest of answer,
1309 * use TCP with same server.
1311 Dprint(statp->options & RES_DEBUG,
1312 (stdout, ";; truncated answer\n"));
1314 __res_iclose(statp, false);
1315 // XXX if we have received one reply we could
1316 // XXX use it and not repeat it over TCP...
1319 /* Mark which reply we received. */
1320 if (recvresp1 == 0 && hp->id == anhp->id)
1324 /* Repeat waiting if we have a second answer to arrive. */
1325 if ((recvresp1 & recvresp2) == 0) {
1326 if (single_request || single_request_reopen) {
1327 pfd[0].events = POLLOUT;
1328 if (single_request_reopen) {
1329 __res_iclose (statp, false);
1330 retval = reopen (statp, terrno, ns);
1338 * All is well, or the error is fatal. Signal that the
1339 * next nameserver ought not be tried.
1342 } else if (pfd[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
1343 /* Something went wrong. We can stop trying. */
1347 /* poll should not have returned > 0 in this case. */
1354 Aerror(const res_state statp, FILE *file, const char *string, int error,
1355 const struct sockaddr *address)
1359 if ((statp->options & RES_DEBUG) != 0) {
1360 char tmp[sizeof "xxxx.xxxx.xxxx.255.255.255.255"];
1362 fprintf(file, "res_send: %s ([%s].%u): %s\n",
1364 (address->sa_family == AF_INET
1365 ? inet_ntop(address->sa_family,
1366 &((const struct sockaddr_in *) address)->sin_addr,
1368 : inet_ntop(address->sa_family,
1369 &((const struct sockaddr_in6 *) address)->sin6_addr,
1371 (address->sa_family == AF_INET
1372 ? ntohs(((struct sockaddr_in *) address)->sin_port)
1373 : address->sa_family == AF_INET6
1374 ? ntohs(((struct sockaddr_in6 *) address)->sin6_port)
1382 Perror(const res_state statp, FILE *file, const char *string, int error) {
1385 if ((statp->options & RES_DEBUG) != 0)
1386 fprintf(file, "res_send: %s: %s\n",
1387 string, strerror(error));
1393 sock_eq(struct sockaddr_in6 *a1, struct sockaddr_in6 *a2) {
1394 if (a1->sin6_family == a2->sin6_family) {
1395 if (a1->sin6_family == AF_INET)
1396 return ((((struct sockaddr_in *)a1)->sin_port ==
1397 ((struct sockaddr_in *)a2)->sin_port) &&
1398 (((struct sockaddr_in *)a1)->sin_addr.s_addr ==
1399 ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1401 return ((a1->sin6_port == a2->sin6_port) &&
1402 !memcmp(&a1->sin6_addr, &a2->sin6_addr,
1403 sizeof (struct in6_addr)));
1405 if (a1->sin6_family == AF_INET) {
1406 struct sockaddr_in6 *sap = a1;
1409 } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1410 return ((a1->sin6_port == ((struct sockaddr_in *)a2)->sin_port) &&
1411 IN6_IS_ADDR_V4MAPPED(&a1->sin6_addr) &&
1412 (a1->sin6_addr.s6_addr32[3] ==
1413 ((struct sockaddr_in *)a2)->sin_addr.s_addr));