]>
git.ipfire.org Git - thirdparty/glibc.git/blob - resolv/res_send.c
1 /* Copyright (C) 2016-2019 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
19 * Copyright (c) 1985, 1989, 1993
20 * The Regents of the University of California. All rights reserved.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
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 * 4. 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.
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
48 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
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.
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
68 * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
70 * Permission to use, copy, modify, and distribute this software for any
71 * purpose with or without fee is hereby granted, provided that the above
72 * copyright notice and this permission notice appear in all copies.
74 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
75 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
76 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
77 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
78 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
79 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
80 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
85 * Send query to name server and wait for reply.
89 #include <sys/types.h>
90 #include <sys/param.h>
92 #include <sys/socket.h>
96 #include <netinet/in.h>
97 #include <arpa/nameser.h>
98 #include <arpa/inet.h>
99 #include <sys/ioctl.h>
104 #include <resolv/resolv-internal.h>
105 #include <resolv/resolv_context.h>
110 #include <kernel-features.h>
111 #include <libc-diag.h>
112 #include <random-bits.h>
115 #define MAXPACKET PACKETSZ
117 #define MAXPACKET 65536
120 /* From ev_streams.c. */
123 __attribute ((always_inline
))
124 evConsIovec(void *buf
, size_t cnt
, struct iovec
*vec
) {
125 memset(vec
, 0xf5, sizeof (*vec
));
130 /* From ev_timers.c. */
132 #define BILLION 1000000000
135 evConsTime(struct timespec
*res
, time_t sec
, long nsec
) {
141 evAddTime(struct timespec
*res
, const struct timespec
*addend1
,
142 const struct timespec
*addend2
) {
143 res
->tv_sec
= addend1
->tv_sec
+ addend2
->tv_sec
;
144 res
->tv_nsec
= addend1
->tv_nsec
+ addend2
->tv_nsec
;
145 if (res
->tv_nsec
>= BILLION
) {
147 res
->tv_nsec
-= BILLION
;
152 evSubTime(struct timespec
*res
, const struct timespec
*minuend
,
153 const struct timespec
*subtrahend
) {
154 res
->tv_sec
= minuend
->tv_sec
- subtrahend
->tv_sec
;
155 if (minuend
->tv_nsec
>= subtrahend
->tv_nsec
)
156 res
->tv_nsec
= minuend
->tv_nsec
- subtrahend
->tv_nsec
;
158 res
->tv_nsec
= (BILLION
159 - subtrahend
->tv_nsec
+ minuend
->tv_nsec
);
165 evCmpTime(struct timespec a
, struct timespec b
) {
166 long x
= a
.tv_sec
- b
.tv_sec
;
169 x
= a
.tv_nsec
- b
.tv_nsec
;
170 return (x
< 0L ? (-1) : x
> 0L ? (1) : (0));
174 evNowTime(struct timespec
*res
) {
177 if (gettimeofday(&now
, NULL
) < 0)
178 evConsTime(res
, 0, 0);
180 TIMEVAL_TO_TIMESPEC (&now
, res
);
184 #define EXT(res) ((res)->_u._ext)
188 static struct sockaddr
*get_nsaddr (res_state
, unsigned int);
189 static int send_vc(res_state
, const u_char
*, int,
191 u_char
**, int *, int *, int, u_char
**,
192 u_char
**, int *, int *, int *);
193 static int send_dg(res_state
, const u_char
*, int,
195 u_char
**, int *, int *, int,
196 int *, int *, u_char
**,
197 u_char
**, int *, int *, int *);
198 static int sock_eq(struct sockaddr_in6
*, struct sockaddr_in6
*);
203 * res_isourserver(ina)
204 * looks up "ina" in _res.ns_addr_list[]
209 * paul vixie, 29may94
212 res_ourserver_p(const res_state statp
, const struct sockaddr_in6
*inp
)
216 if (inp
->sin6_family
== AF_INET
) {
217 struct sockaddr_in
*in4p
= (struct sockaddr_in
*) inp
;
218 in_port_t port
= in4p
->sin_port
;
219 in_addr_t addr
= in4p
->sin_addr
.s_addr
;
221 for (ns
= 0; ns
< statp
->nscount
; ns
++) {
222 const struct sockaddr_in
*srv
=
223 (struct sockaddr_in
*) get_nsaddr (statp
, ns
);
225 if ((srv
->sin_family
== AF_INET
) &&
226 (srv
->sin_port
== port
) &&
227 (srv
->sin_addr
.s_addr
== INADDR_ANY
||
228 srv
->sin_addr
.s_addr
== addr
))
231 } else if (inp
->sin6_family
== AF_INET6
) {
232 for (ns
= 0; ns
< statp
->nscount
; ns
++) {
233 const struct sockaddr_in6
*srv
234 = (struct sockaddr_in6
*) get_nsaddr (statp
, ns
);
235 if ((srv
->sin6_family
== AF_INET6
) &&
236 (srv
->sin6_port
== inp
->sin6_port
) &&
237 !(memcmp(&srv
->sin6_addr
, &in6addr_any
,
238 sizeof (struct in6_addr
)) &&
239 memcmp(&srv
->sin6_addr
, &inp
->sin6_addr
,
240 sizeof (struct in6_addr
))))
248 res_isourserver (const struct sockaddr_in
*inp
)
250 return res_ourserver_p (&_res
, (const struct sockaddr_in6
*) inp
);
254 * res_nameinquery(name, type, class, buf, eom)
255 * look for (name,type,class) in the query section of packet (buf,eom)
257 * buf + HFIXEDSZ <= eom
263 * paul vixie, 29may94
266 res_nameinquery(const char *name
, int type
, int class,
267 const u_char
*buf
, const u_char
*eom
)
269 const u_char
*cp
= buf
+ HFIXEDSZ
;
270 int qdcount
= ntohs(((HEADER
*)buf
)->qdcount
);
272 while (qdcount
-- > 0) {
273 char tname
[MAXDNAME
+1];
274 int n
, ttype
, tclass
;
276 n
= dn_expand(buf
, eom
, cp
, tname
, sizeof tname
);
280 if (cp
+ 2 * INT16SZ
> eom
)
283 NS_GET16(tclass
, cp
);
284 if (ttype
== type
&& tclass
== class &&
285 ns_samename(tname
, name
) == 1)
290 libresolv_hidden_def (res_nameinquery
)
292 /* Returns a shift value for the name server index. Used to implement
295 nameserver_offset (struct __res_state
*statp
)
297 /* If we only have one name server or rotation is disabled, return
298 offset 0 (no rotation). */
299 unsigned int nscount
= statp
->nscount
;
300 if (nscount
<= 1 || !(statp
->options
& RES_ROTATE
))
303 /* Global offset. The lowest bit indicates whether the offset has
304 been initialized with a random value. Use relaxed MO to access
305 global_offset because all we need is a sequence of roughly
307 static unsigned int global_offset
;
308 unsigned int offset
= atomic_fetch_add_relaxed (&global_offset
, 2);
309 if ((offset
& 1) == 0)
311 /* Initialization is required. */
312 offset
= random_bits ();
313 /* The lowest bit is the most random. Preserve it. */
316 /* Store the new starting value. atomic_fetch_add_relaxed
317 returns the old value, so emulate that by storing the new
318 (incremented) value. Concurrent initialization with
319 different random values is harmless. */
320 atomic_store_relaxed (&global_offset
, (offset
| 1) + 2);
323 /* Remove the initialization bit. */
326 /* Avoid the division in the most common cases. */
336 return offset
% nscount
;
341 * res_queriesmatch(buf1, eom1, buf2, eom2)
342 * is there a 1:1 mapping of (name,type,class)
343 * in (buf1,eom1) and (buf2,eom2)?
346 * 0 : not a 1:1 mapping
347 * >0 : is a 1:1 mapping
349 * paul vixie, 29may94
352 res_queriesmatch(const u_char
*buf1
, const u_char
*eom1
,
353 const u_char
*buf2
, const u_char
*eom2
)
355 if (buf1
+ HFIXEDSZ
> eom1
|| buf2
+ HFIXEDSZ
> eom2
)
359 * Only header section present in replies to
360 * dynamic update packets.
362 if ((((HEADER
*)buf1
)->opcode
== ns_o_update
) &&
363 (((HEADER
*)buf2
)->opcode
== ns_o_update
))
366 /* Note that we initially do not convert QDCOUNT to the host byte
367 order. We can compare it with the second buffer's QDCOUNT
368 value without doing this. */
369 int qdcount
= ((HEADER
*)buf1
)->qdcount
;
370 if (qdcount
!= ((HEADER
*)buf2
)->qdcount
)
373 qdcount
= htons (qdcount
);
374 const u_char
*cp
= buf1
+ HFIXEDSZ
;
376 while (qdcount
-- > 0) {
377 char tname
[MAXDNAME
+1];
378 int n
, ttype
, tclass
;
380 n
= dn_expand(buf1
, eom1
, cp
, tname
, sizeof tname
);
384 if (cp
+ 2 * INT16SZ
> eom1
)
387 NS_GET16(tclass
, cp
);
388 if (!res_nameinquery(tname
, ttype
, tclass
, buf2
, eom2
))
393 libresolv_hidden_def (res_queriesmatch
)
396 __res_context_send (struct resolv_context
*ctx
,
397 const unsigned char *buf
, int buflen
,
398 const unsigned char *buf2
, int buflen2
,
399 unsigned char *ans
, int anssiz
,
400 unsigned char **ansp
, unsigned char **ansp2
,
401 int *nansp2
, int *resplen2
, int *ansp2_malloced
)
403 struct __res_state
*statp
= ctx
->resp
;
404 int gotsomewhere
, terrno
, try, v_circuit
, resplen
, n
;
406 if (statp
->nscount
== 0) {
411 if (anssiz
< (buf2
== NULL
? 1 : 2) * HFIXEDSZ
) {
412 __set_errno (EINVAL
);
416 v_circuit
= ((statp
->options
& RES_USEVC
)
418 || buflen2
> PACKETSZ
);
423 * If the ns_addr_list in the resolver context has changed, then
424 * invalidate our cached copy and the associated timing data.
426 if (EXT(statp
).nscount
!= 0) {
429 if (EXT(statp
).nscount
!= statp
->nscount
)
432 for (unsigned int ns
= 0; ns
< statp
->nscount
; ns
++) {
433 if (statp
->nsaddr_list
[ns
].sin_family
!= 0
434 && !sock_eq((struct sockaddr_in6
*)
435 &statp
->nsaddr_list
[ns
],
436 EXT(statp
).nsaddrs
[ns
]))
443 __res_iclose(statp
, false);
444 EXT(statp
).nscount
= 0;
449 * Maybe initialize our private copy of the ns_addr_list.
451 if (EXT(statp
).nscount
== 0) {
452 for (unsigned int ns
= 0; ns
< statp
->nscount
; ns
++) {
453 EXT(statp
).nssocks
[ns
] = -1;
454 if (statp
->nsaddr_list
[ns
].sin_family
== 0)
456 if (EXT(statp
).nsaddrs
[ns
] == NULL
)
457 EXT(statp
).nsaddrs
[ns
] =
458 malloc(sizeof (struct sockaddr_in6
));
459 if (EXT(statp
).nsaddrs
[ns
] != NULL
)
460 memset (mempcpy(EXT(statp
).nsaddrs
[ns
],
461 &statp
->nsaddr_list
[ns
],
462 sizeof (struct sockaddr_in
)),
464 sizeof (struct sockaddr_in6
)
465 - sizeof (struct sockaddr_in
));
469 EXT(statp
).nscount
= statp
->nscount
;
472 /* Name server index offset. Used to implement
474 unsigned int ns_offset
= nameserver_offset (statp
);
477 * Send request, RETRY times, or until successful.
479 for (try = 0; try < statp
->retry
; try++) {
480 for (unsigned ns_shift
= 0; ns_shift
< statp
->nscount
; ns_shift
++)
482 /* The actual name server index. This implements
484 unsigned int ns
= ns_shift
+ ns_offset
;
485 if (ns
>= statp
->nscount
)
486 ns
-= statp
->nscount
;
489 if (__glibc_unlikely (v_circuit
)) {
490 /* Use VC; at most one attempt per server. */
492 n
= send_vc(statp
, buf
, buflen
, buf2
, buflen2
,
493 &ans
, &anssiz
, &terrno
,
494 ns
, ansp
, ansp2
, nansp2
, resplen2
,
498 if (n
== 0 && (buf2
== NULL
|| *resplen2
== 0))
502 n
= send_dg(statp
, buf
, buflen
, buf2
, buflen2
,
503 &ans
, &anssiz
, &terrno
,
504 ns
, &v_circuit
, &gotsomewhere
, ansp
,
505 ansp2
, nansp2
, resplen2
, ansp2_malloced
);
508 if (n
== 0 && (buf2
== NULL
|| *resplen2
== 0))
511 // XXX Check whether both requests failed or
512 // XXX whether one has been answered successfully
519 * If we have temporarily opened a virtual circuit,
520 * or if we haven't been asked to keep a socket open,
523 if ((v_circuit
&& (statp
->options
& RES_USEVC
) == 0) ||
524 (statp
->options
& RES_STAYOPEN
) == 0) {
525 __res_iclose(statp
, false);
531 __res_iclose(statp
, false);
534 __set_errno (ECONNREFUSED
); /* no nameservers found */
536 __set_errno (ETIMEDOUT
); /* no answer obtained */
538 __set_errno (terrno
);
542 /* Common part of res_nsend and res_send. */
544 context_send_common (struct resolv_context
*ctx
,
545 const unsigned char *buf
, int buflen
,
546 unsigned char *ans
, int anssiz
)
550 RES_SET_H_ERRNO (&_res
, NETDB_INTERNAL
);
553 int result
= __res_context_send (ctx
, buf
, buflen
, NULL
, 0, ans
, anssiz
,
554 NULL
, NULL
, NULL
, NULL
, NULL
);
555 __resolv_context_put (ctx
);
560 res_nsend (res_state statp
, const unsigned char *buf
, int buflen
,
561 unsigned char *ans
, int anssiz
)
563 return context_send_common
564 (__resolv_context_get_override (statp
), buf
, buflen
, ans
, anssiz
);
568 res_send (const unsigned char *buf
, int buflen
, unsigned char *ans
, int anssiz
)
570 return context_send_common
571 (__resolv_context_get (), buf
, buflen
, ans
, anssiz
);
576 static struct sockaddr
*
577 get_nsaddr (res_state statp
, unsigned int n
)
579 assert (n
< statp
->nscount
);
581 if (statp
->nsaddr_list
[n
].sin_family
== 0 && EXT(statp
).nsaddrs
[n
] != NULL
)
582 /* EXT(statp).nsaddrs[n] holds an address that is larger than
583 struct sockaddr, and user code did not update
584 statp->nsaddr_list[n]. */
585 return (struct sockaddr
*) EXT(statp
).nsaddrs
[n
];
587 /* User code updated statp->nsaddr_list[n], or statp->nsaddr_list[n]
588 has the same content as EXT(statp).nsaddrs[n]. */
589 return (struct sockaddr
*) (void *) &statp
->nsaddr_list
[n
];
592 /* Close the resolver structure, assign zero to *RESPLEN2 if RESPLEN2
593 is not NULL, and return zero. */
595 __attribute__ ((warn_unused_result
))
596 close_and_return_error (res_state statp
, int *resplen2
)
598 __res_iclose(statp
, false);
599 if (resplen2
!= NULL
)
604 /* The send_vc function is responsible for sending a DNS query over TCP
605 to the nameserver numbered NS from the res_state STATP i.e.
606 EXT(statp).nssocks[ns]. The function supports sending both IPv4 and
607 IPv6 queries at the same serially on the same socket.
609 Please note that for TCP there is no way to disable sending both
610 queries, unlike UDP, which honours RES_SNGLKUP and RES_SNGLKUPREOP
611 and sends the queries serially and waits for the result after each
612 sent query. This implementation should be corrected to honour these
615 Please also note that for TCP we send both queries over the same
616 socket one after another. This technically violates best practice
617 since the server is allowed to read the first query, respond, and
618 then close the socket (to service another client). If the server
619 does this, then the remaining second query in the socket data buffer
620 will cause the server to send the client an RST which will arrive
621 asynchronously and the client's OS will likely tear down the socket
622 receive buffer resulting in a potentially short read and lost
623 response data. This will force the client to retry the query again,
624 and this process may repeat until all servers and connection resets
625 are exhausted and then the query will fail. It's not known if this
626 happens with any frequency in real DNS server implementations. This
627 implementation should be corrected to use two sockets by default for
630 The query stored in BUF of BUFLEN length is sent first followed by
631 the query stored in BUF2 of BUFLEN2 length. Queries are sent
632 serially on the same socket.
634 Answers to the query are stored firstly in *ANSP up to a max of
635 *ANSSIZP bytes. If more than *ANSSIZP bytes are needed and ANSCP
636 is non-NULL (to indicate that modifying the answer buffer is allowed)
637 then malloc is used to allocate a new response buffer and ANSCP and
638 ANSP will both point to the new buffer. If more than *ANSSIZP bytes
639 are needed but ANSCP is NULL, then as much of the response as
640 possible is read into the buffer, but the results will be truncated.
641 When truncation happens because of a small answer buffer the DNS
642 packets header field TC will bet set to 1, indicating a truncated
643 message and the rest of the socket data will be read and discarded.
645 Answers to the query are stored secondly in *ANSP2 up to a max of
646 *ANSSIZP2 bytes, with the actual response length stored in
647 *RESPLEN2. If more than *ANSSIZP bytes are needed and ANSP2
648 is non-NULL (required for a second query) then malloc is used to
649 allocate a new response buffer, *ANSSIZP2 is set to the new buffer
650 size and *ANSP2_MALLOCED is set to 1.
652 The ANSP2_MALLOCED argument will eventually be removed as the
653 change in buffer pointer can be used to detect the buffer has
654 changed and that the caller should use free on the new buffer.
656 Note that the answers may arrive in any order from the server and
657 therefore the first and second answer buffers may not correspond to
658 the first and second queries.
660 It is not supported to call this function with a non-NULL ANSP2
661 but a NULL ANSCP. Put another way, you can call send_vc with a
662 single unmodifiable buffer or two modifiable buffers, but no other
663 combination is supported.
665 It is the caller's responsibility to free the malloc allocated
666 buffers by detecting that the pointers have changed from their
667 original values i.e. *ANSCP or *ANSP2 has changed.
669 If errors are encountered then *TERRNO is set to an appropriate
670 errno value and a zero result is returned for a recoverable error,
671 and a less-than zero result is returned for a non-recoverable error.
673 If no errors are encountered then *TERRNO is left unmodified and
674 a the length of the first response in bytes is returned. */
676 send_vc(res_state statp
,
677 const u_char
*buf
, int buflen
, const u_char
*buf2
, int buflen2
,
678 u_char
**ansp
, int *anssizp
,
679 int *terrno
, int ns
, u_char
**anscp
, u_char
**ansp2
, int *anssizp2
,
680 int *resplen2
, int *ansp2_malloced
)
682 const HEADER
*hp
= (HEADER
*) buf
;
683 const HEADER
*hp2
= (HEADER
*) buf2
;
684 HEADER
*anhp
= (HEADER
*) *ansp
;
685 struct sockaddr
*nsap
= get_nsaddr (statp
, ns
);
686 int truncating
, connreset
, n
;
687 /* On some architectures compiler might emit a warning indicating
688 'resplen' may be used uninitialized. However if buf2 == NULL
689 then this code won't be executed; if buf2 != NULL, then first
690 time round the loop recvresp1 and recvresp2 will be 0 so this
691 code won't be executed but "thisresplenp = &resplen;" followed
692 by "*thisresplenp = rlen;" will be executed so that subsequent
693 times round the loop resplen has been initialized. So this is
696 DIAG_PUSH_NEEDS_COMMENT
;
697 DIAG_IGNORE_NEEDS_COMMENT (5, "-Wmaybe-uninitialized");
699 DIAG_POP_NEEDS_COMMENT
;
709 /* Are we still talking to whom we want to talk to? */
710 if (statp
->_vcsock
>= 0 && (statp
->_flags
& RES_F_VC
) != 0) {
711 struct sockaddr_in6 peer
;
712 socklen_t size
= sizeof peer
;
714 if (getpeername(statp
->_vcsock
,
715 (struct sockaddr
*)&peer
, &size
) < 0 ||
716 !sock_eq(&peer
, (struct sockaddr_in6
*) nsap
)) {
717 __res_iclose(statp
, false);
718 statp
->_flags
&= ~RES_F_VC
;
722 if (statp
->_vcsock
< 0 || (statp
->_flags
& RES_F_VC
) == 0) {
723 if (statp
->_vcsock
>= 0)
724 __res_iclose(statp
, false);
726 statp
->_vcsock
= socket
727 (nsap
->sa_family
, SOCK_STREAM
| SOCK_CLOEXEC
, 0);
728 if (statp
->_vcsock
< 0) {
730 if (resplen2
!= NULL
)
735 if (connect(statp
->_vcsock
, nsap
,
736 nsap
->sa_family
== AF_INET
737 ? sizeof (struct sockaddr_in
)
738 : sizeof (struct sockaddr_in6
)) < 0) {
740 return close_and_return_error (statp
, resplen2
);
742 statp
->_flags
|= RES_F_VC
;
746 * Send length & message
748 len
= htons ((u_short
) buflen
);
749 evConsIovec(&len
, INT16SZ
, &iov
[0]);
750 evConsIovec((void*)buf
, buflen
, &iov
[1]);
752 ssize_t explen
= INT16SZ
+ buflen
;
754 len2
= htons ((u_short
) buflen2
);
755 evConsIovec(&len2
, INT16SZ
, &iov
[2]);
756 evConsIovec((void*)buf2
, buflen2
, &iov
[3]);
758 explen
+= INT16SZ
+ buflen2
;
760 if (TEMP_FAILURE_RETRY (writev(statp
->_vcsock
, iov
, niov
)) != explen
) {
762 return close_and_return_error (statp
, resplen2
);
765 * Receive length & response
768 /* Skip the second response if there is no second query.
769 To do that we mark the second response as received. */
770 int recvresp2
= buf2
== NULL
;
773 cp
= (u_char
*)&rlen16
;
774 len
= sizeof(rlen16
);
775 while ((n
= TEMP_FAILURE_RETRY (read(statp
->_vcsock
, cp
,
784 * A long running process might get its TCP
785 * connection reset if the remote server was
786 * restarted. Requery the server instead of
787 * trying a new one. When there is only one
788 * server, this means that a query might work
789 * instead of failing. We only allow one reset
790 * per query to prevent looping.
792 if (*terrno
== ECONNRESET
&& !connreset
)
794 __res_iclose (statp
, false);
798 return close_and_return_error (statp
, resplen2
);
800 int rlen
= ntohs (rlen16
);
805 if ((recvresp1
| recvresp2
) == 0 || buf2
== NULL
) {
806 /* We have not received any responses
807 yet or we only have one response to
809 thisanssizp
= anssizp
;
810 thisansp
= anscp
?: ansp
;
811 assert (anscp
!= NULL
|| ansp2
== NULL
);
812 thisresplenp
= &resplen
;
814 thisanssizp
= anssizp2
;
816 thisresplenp
= resplen2
;
818 anhp
= (HEADER
*) *thisansp
;
820 *thisresplenp
= rlen
;
821 /* Is the answer buffer too small? */
822 if (*thisanssizp
< rlen
) {
823 /* If the current buffer is not the the static
824 user-supplied buffer then we can reallocate
826 if (thisansp
!= NULL
&& thisansp
!= ansp
) {
827 /* Always allocate MAXPACKET, callers expect
828 this specific size. */
829 u_char
*newp
= malloc (MAXPACKET
);
833 return close_and_return_error (statp
, resplen2
);
835 *thisanssizp
= MAXPACKET
;
837 if (thisansp
== ansp2
)
839 anhp
= (HEADER
*) newp
;
840 /* A uint16_t can't be larger than MAXPACKET
841 thus it's safe to allocate MAXPACKET but
842 read RLEN bytes instead. */
851 if (__glibc_unlikely (len
< HFIXEDSZ
)) {
853 * Undersized message.
856 return close_and_return_error (statp
, resplen2
);
860 while (len
!= 0 && (n
= read(statp
->_vcsock
, (char *)cp
, (int)len
)) > 0){
864 if (__glibc_unlikely (n
<= 0)) {
866 return close_and_return_error (statp
, resplen2
);
868 if (__glibc_unlikely (truncating
)) {
870 * Flush rest of answer so connection stays in synch.
873 len
= rlen
- *thisanssizp
;
877 n
= read(statp
->_vcsock
, junk
,
878 (len
> sizeof junk
) ? sizeof junk
: len
);
886 * If the calling application has bailed out of
887 * a previous call and failed to arrange to have
888 * the circuit closed or the server has got
889 * itself confused, then drop the packet and
890 * wait for the correct one.
892 if ((recvresp1
|| hp
->id
!= anhp
->id
)
893 && (recvresp2
|| hp2
->id
!= anhp
->id
))
896 /* Mark which reply we received. */
897 if (recvresp1
== 0 && hp
->id
== anhp
->id
)
901 /* Repeat waiting if we have a second answer to arrive. */
902 if ((recvresp1
& recvresp2
) == 0)
906 * All is well, or the error is fatal. Signal that the
907 * next nameserver ought not be tried.
913 reopen (res_state statp
, int *terrno
, int ns
)
915 if (EXT(statp
).nssocks
[ns
] == -1) {
916 struct sockaddr
*nsap
= get_nsaddr (statp
, ns
);
919 /* only try IPv6 if IPv6 NS and if not failed before */
920 if (nsap
->sa_family
== AF_INET6
&& !statp
->ipv6_unavail
) {
921 EXT(statp
).nssocks
[ns
] = socket
923 SOCK_DGRAM
| SOCK_NONBLOCK
| SOCK_CLOEXEC
, 0);
924 if (EXT(statp
).nssocks
[ns
] < 0)
925 statp
->ipv6_unavail
= errno
== EAFNOSUPPORT
;
926 slen
= sizeof (struct sockaddr_in6
);
927 } else if (nsap
->sa_family
== AF_INET
) {
928 EXT(statp
).nssocks
[ns
] = socket
930 SOCK_DGRAM
| SOCK_NONBLOCK
| SOCK_CLOEXEC
, 0);
931 slen
= sizeof (struct sockaddr_in
);
933 if (EXT(statp
).nssocks
[ns
] < 0) {
938 /* Enable full ICMP error reporting for this
940 if (__res_enable_icmp (nsap
->sa_family
,
941 EXT (statp
).nssocks
[ns
]) < 0)
943 int saved_errno
= errno
;
944 __res_iclose (statp
, false);
945 __set_errno (saved_errno
);
946 *terrno
= saved_errno
;
951 * On a 4.3BSD+ machine (client and server,
952 * actually), sending to a nameserver datagram
953 * port with no nameserver will cause an
954 * ICMP port unreachable message to be returned.
955 * If our datagram socket is "connected" to the
956 * server, we get an ECONNREFUSED error on the next
957 * socket operation, and select returns if the
958 * error message is received. We can thus detect
959 * the absence of a nameserver without timing out.
961 /* With GCC 5.3 when compiling with -Os the compiler
962 emits a warning that slen may be used uninitialized,
963 but that is never true. Both slen and
964 EXT(statp).nssocks[ns] are initialized together or
965 the function return -1 before control flow reaches
966 the call to connect with slen. */
967 DIAG_PUSH_NEEDS_COMMENT
;
968 DIAG_IGNORE_Os_NEEDS_COMMENT (5, "-Wmaybe-uninitialized");
969 if (connect(EXT(statp
).nssocks
[ns
], nsap
, slen
) < 0) {
970 DIAG_POP_NEEDS_COMMENT
;
971 __res_iclose(statp
, false);
979 /* The send_dg function is responsible for sending a DNS query over UDP
980 to the nameserver numbered NS from the res_state STATP i.e.
981 EXT(statp).nssocks[ns]. The function supports IPv4 and IPv6 queries
982 along with the ability to send the query in parallel for both stacks
983 (default) or serially (RES_SINGLKUP). It also supports serial lookup
984 with a close and reopen of the socket used to talk to the server
985 (RES_SNGLKUPREOP) to work around broken name servers.
987 The query stored in BUF of BUFLEN length is sent first followed by
988 the query stored in BUF2 of BUFLEN2 length. Queries are sent
989 in parallel (default) or serially (RES_SINGLKUP or RES_SNGLKUPREOP).
991 Answers to the query are stored firstly in *ANSP up to a max of
992 *ANSSIZP bytes. If more than *ANSSIZP bytes are needed and ANSCP
993 is non-NULL (to indicate that modifying the answer buffer is allowed)
994 then malloc is used to allocate a new response buffer and ANSCP and
995 ANSP will both point to the new buffer. If more than *ANSSIZP bytes
996 are needed but ANSCP is NULL, then as much of the response as
997 possible is read into the buffer, but the results will be truncated.
998 When truncation happens because of a small answer buffer the DNS
999 packets header field TC will bet set to 1, indicating a truncated
1000 message, while the rest of the UDP packet is discarded.
1002 Answers to the query are stored secondly in *ANSP2 up to a max of
1003 *ANSSIZP2 bytes, with the actual response length stored in
1004 *RESPLEN2. If more than *ANSSIZP bytes are needed and ANSP2
1005 is non-NULL (required for a second query) then malloc is used to
1006 allocate a new response buffer, *ANSSIZP2 is set to the new buffer
1007 size and *ANSP2_MALLOCED is set to 1.
1009 The ANSP2_MALLOCED argument will eventually be removed as the
1010 change in buffer pointer can be used to detect the buffer has
1011 changed and that the caller should use free on the new buffer.
1013 Note that the answers may arrive in any order from the server and
1014 therefore the first and second answer buffers may not correspond to
1015 the first and second queries.
1017 It is not supported to call this function with a non-NULL ANSP2
1018 but a NULL ANSCP. Put another way, you can call send_vc with a
1019 single unmodifiable buffer or two modifiable buffers, but no other
1020 combination is supported.
1022 It is the caller's responsibility to free the malloc allocated
1023 buffers by detecting that the pointers have changed from their
1024 original values i.e. *ANSCP or *ANSP2 has changed.
1026 If an answer is truncated because of UDP datagram DNS limits then
1027 *V_CIRCUIT is set to 1 and the return value non-zero to indicate to
1028 the caller to retry with TCP. The value *GOTSOMEWHERE is set to 1
1029 if any progress was made reading a response from the nameserver and
1030 is used by the caller to distinguish between ECONNREFUSED and
1031 ETIMEDOUT (the latter if *GOTSOMEWHERE is 1).
1033 If errors are encountered then *TERRNO is set to an appropriate
1034 errno value and a zero result is returned for a recoverable error,
1035 and a less-than zero result is returned for a non-recoverable error.
1037 If no errors are encountered then *TERRNO is left unmodified and
1038 a the length of the first response in bytes is returned. */
1040 send_dg(res_state statp
,
1041 const u_char
*buf
, int buflen
, const u_char
*buf2
, int buflen2
,
1042 u_char
**ansp
, int *anssizp
,
1043 int *terrno
, int ns
, int *v_circuit
, int *gotsomewhere
, u_char
**anscp
,
1044 u_char
**ansp2
, int *anssizp2
, int *resplen2
, int *ansp2_malloced
)
1046 const HEADER
*hp
= (HEADER
*) buf
;
1047 const HEADER
*hp2
= (HEADER
*) buf2
;
1048 struct timespec now
, timeout
, finish
;
1049 struct pollfd pfd
[1];
1051 struct sockaddr_in6 from
;
1056 * Compute time for the total operation.
1058 int seconds
= (statp
->retrans
<< ns
);
1060 seconds
/= statp
->nscount
;
1063 bool single_request_reopen
= (statp
->options
& RES_SNGLKUPREOP
) != 0;
1064 bool single_request
= (((statp
->options
& RES_SNGLKUP
) != 0)
1065 | single_request_reopen
);
1066 int save_gotsomewhere
= *gotsomewhere
;
1070 retval
= reopen (statp
, terrno
, ns
);
1073 if (resplen2
!= NULL
)
1079 evConsTime(&timeout
, seconds
, 0);
1080 evAddTime(&finish
, &now
, &timeout
);
1081 int need_recompute
= 0;
1084 /* Skip the second response if there is no second query.
1085 To do that we mark the second response as received. */
1086 int recvresp2
= buf2
== NULL
;
1087 pfd
[0].fd
= EXT(statp
).nssocks
[ns
];
1088 pfd
[0].events
= POLLOUT
;
1090 if (need_recompute
) {
1093 if (evCmpTime(finish
, now
) <= 0) {
1095 return close_and_return_error (statp
, resplen2
);
1097 evSubTime(&timeout
, &finish
, &now
);
1100 /* Convert struct timespec in milliseconds. */
1101 ptimeout
= timeout
.tv_sec
* 1000 + timeout
.tv_nsec
/ 1000000;
1105 n
= __poll (pfd
, 1, 0);
1106 if (__glibc_unlikely (n
== 0)) {
1107 n
= __poll (pfd
, 1, ptimeout
);
1111 if (resplen
> 1 && (recvresp1
|| (buf2
!= NULL
&& recvresp2
)))
1113 /* There are quite a few broken name servers out
1114 there which don't handle two outstanding
1115 requests from the same source. There are also
1116 broken firewall settings. If we time out after
1117 having received one answer switch to the mode
1118 where we send the second request only once we
1119 have received the first answer. */
1120 if (!single_request
)
1122 statp
->options
|= RES_SNGLKUP
;
1123 single_request
= true;
1124 *gotsomewhere
= save_gotsomewhere
;
1127 else if (!single_request_reopen
)
1129 statp
->options
|= RES_SNGLKUPREOP
;
1130 single_request_reopen
= true;
1131 *gotsomewhere
= save_gotsomewhere
;
1132 __res_iclose (statp
, false);
1141 if (resplen2
!= NULL
)
1147 goto recompute_resend
;
1152 if (pfd
[0].revents
& POLLOUT
) {
1153 #ifndef __ASSUME_SENDMMSG
1154 static int have_sendmmsg
;
1156 # define have_sendmmsg 1
1158 if (have_sendmmsg
>= 0 && nwritten
== 0 && buf2
!= NULL
1162 { .iov_base
= (void *) buf
, .iov_len
= buflen
};
1164 { .iov_base
= (void *) buf2
, .iov_len
= buflen2
};
1165 struct mmsghdr reqs
[2] =
1183 int ndg
= __sendmmsg (pfd
[0].fd
, reqs
, 2, MSG_NOSIGNAL
);
1184 if (__glibc_likely (ndg
== 2))
1186 if (reqs
[0].msg_len
!= buflen
1187 || reqs
[1].msg_len
!= buflen2
)
1190 pfd
[0].events
= POLLIN
;
1193 else if (ndg
== 1 && reqs
[0].msg_len
== buflen
)
1195 else if (ndg
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
1196 goto recompute_resend
;
1199 #ifndef __ASSUME_SENDMMSG
1200 if (__glibc_unlikely (have_sendmmsg
== 0))
1202 if (ndg
< 0 && errno
== ENOSYS
)
1212 return close_and_return_error (statp
, resplen2
);
1218 #ifndef __ASSUME_SENDMMSG
1222 sr
= send (pfd
[0].fd
, buf2
, buflen2
, MSG_NOSIGNAL
);
1224 sr
= send (pfd
[0].fd
, buf
, buflen
, MSG_NOSIGNAL
);
1226 if (sr
!= (nwritten
!= 0 ? buflen2
: buflen
)) {
1227 if (errno
== EINTR
|| errno
== EAGAIN
)
1228 goto recompute_resend
;
1229 return close_and_return_error (statp
, resplen2
);
1232 if (nwritten
!= 0 || buf2
== NULL
|| single_request
)
1233 pfd
[0].events
= POLLIN
;
1235 pfd
[0].events
= POLLIN
| POLLOUT
;
1239 } else if (pfd
[0].revents
& POLLIN
) {
1244 if ((recvresp1
| recvresp2
) == 0 || buf2
== NULL
) {
1245 /* We have not received any responses
1246 yet or we only have one response to
1248 thisanssizp
= anssizp
;
1249 thisansp
= anscp
?: ansp
;
1250 assert (anscp
!= NULL
|| ansp2
== NULL
);
1251 thisresplenp
= &resplen
;
1253 thisanssizp
= anssizp2
;
1255 thisresplenp
= resplen2
;
1258 if (*thisanssizp
< MAXPACKET
1259 /* If the current buffer is not the the static
1260 user-supplied buffer then we can reallocate
1262 && (thisansp
!= NULL
&& thisansp
!= ansp
)
1264 /* Is the size too small? */
1265 && (ioctl (pfd
[0].fd
, FIONREAD
, thisresplenp
) < 0
1266 || *thisanssizp
< *thisresplenp
)
1269 /* Always allocate MAXPACKET, callers expect
1270 this specific size. */
1271 u_char
*newp
= malloc (MAXPACKET
);
1273 *thisanssizp
= MAXPACKET
;
1275 if (thisansp
== ansp2
)
1276 *ansp2_malloced
= 1;
1279 /* We could end up with truncation if anscp was NULL
1280 (not allowed to change caller's buffer) and the
1281 response buffer size is too small. This isn't a
1282 reliable way to detect truncation because the ioctl
1283 may be an inaccurate report of the UDP message size.
1284 Therefore we use this only to issue debug output.
1285 To do truncation accurately with UDP we need
1286 MSG_TRUNC which is only available on Linux. We
1287 can abstract out the Linux-specific feature in the
1288 future to detect truncation. */
1289 HEADER
*anhp
= (HEADER
*) *thisansp
;
1290 socklen_t fromlen
= sizeof(struct sockaddr_in6
);
1291 assert (sizeof(from
) <= fromlen
);
1292 *thisresplenp
= recvfrom(pfd
[0].fd
, (char*)*thisansp
,
1294 (struct sockaddr
*)&from
, &fromlen
);
1295 if (__glibc_unlikely (*thisresplenp
<= 0)) {
1296 if (errno
== EINTR
|| errno
== EAGAIN
) {
1300 return close_and_return_error (statp
, resplen2
);
1303 if (__glibc_unlikely (*thisresplenp
< HFIXEDSZ
)) {
1305 * Undersized message.
1308 return close_and_return_error (statp
, resplen2
);
1310 if ((recvresp1
|| hp
->id
!= anhp
->id
)
1311 && (recvresp2
|| hp2
->id
!= anhp
->id
)) {
1313 * response from old query, ignore it.
1314 * XXX - potential security hazard could
1320 /* Paranoia check. Due to the connected UDP socket,
1321 the kernel has already filtered invalid addresses
1323 if (!res_ourserver_p(statp
, &from
))
1326 /* Check for the correct header layout and a matching
1328 if ((recvresp1
|| !res_queriesmatch(buf
, buf
+ buflen
,
1332 && (recvresp2
|| !res_queriesmatch(buf2
, buf2
+ buflen2
,
1338 if (anhp
->rcode
== SERVFAIL
||
1339 anhp
->rcode
== NOTIMP
||
1340 anhp
->rcode
== REFUSED
) {
1342 if (recvresp1
|| (buf2
!= NULL
&& recvresp2
)) {
1348 /* No data from the first reply. */
1350 /* We are waiting for a possible second reply. */
1351 if (hp
->id
== anhp
->id
)
1359 /* don't retry if called from dig */
1361 return close_and_return_error (statp
, resplen2
);
1362 __res_iclose(statp
, false);
1364 if (anhp
->rcode
== NOERROR
&& anhp
->ancount
== 0
1365 && anhp
->aa
== 0 && anhp
->ra
== 0 && anhp
->arcount
== 0) {
1368 if (!(statp
->options
& RES_IGNTC
) && anhp
->tc
) {
1370 * To get the rest of answer,
1371 * use TCP with same server.
1374 __res_iclose(statp
, false);
1375 // XXX if we have received one reply we could
1376 // XXX use it and not repeat it over TCP...
1377 if (resplen2
!= NULL
)
1381 /* Mark which reply we received. */
1382 if (recvresp1
== 0 && hp
->id
== anhp
->id
)
1386 /* Repeat waiting if we have a second answer to arrive. */
1387 if ((recvresp1
& recvresp2
) == 0) {
1388 if (single_request
) {
1389 pfd
[0].events
= POLLOUT
;
1390 if (single_request_reopen
) {
1391 __res_iclose (statp
, false);
1392 retval
= reopen (statp
, terrno
, ns
);
1395 if (resplen2
!= NULL
)
1399 pfd
[0].fd
= EXT(statp
).nssocks
[ns
];
1404 /* All is well. We have received both responses (if
1405 two responses were requested). */
1407 } else if (pfd
[0].revents
& (POLLERR
| POLLHUP
| POLLNVAL
))
1408 /* Something went wrong. We can stop trying. */
1409 return close_and_return_error (statp
, resplen2
);
1411 /* poll should not have returned > 0 in this case. */
1417 sock_eq(struct sockaddr_in6
*a1
, struct sockaddr_in6
*a2
) {
1418 if (a1
->sin6_family
== a2
->sin6_family
) {
1419 if (a1
->sin6_family
== AF_INET
)
1420 return ((((struct sockaddr_in
*)a1
)->sin_port
==
1421 ((struct sockaddr_in
*)a2
)->sin_port
) &&
1422 (((struct sockaddr_in
*)a1
)->sin_addr
.s_addr
==
1423 ((struct sockaddr_in
*)a2
)->sin_addr
.s_addr
));
1425 return ((a1
->sin6_port
== a2
->sin6_port
) &&
1426 !memcmp(&a1
->sin6_addr
, &a2
->sin6_addr
,
1427 sizeof (struct in6_addr
)));
1429 if (a1
->sin6_family
== AF_INET
) {
1430 struct sockaddr_in6
*sap
= a1
;
1433 } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1434 return ((a1
->sin6_port
== ((struct sockaddr_in
*)a2
)->sin_port
) &&
1435 IN6_IS_ADDR_V4MAPPED(&a1
->sin6_addr
) &&
1436 (a1
->sin6_addr
.s6_addr32
[3] ==
1437 ((struct sockaddr_in
*)a2
)->sin_addr
.s_addr
));