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