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