libc/dns/resolv/res_send.c

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