resolv/res_send.c

   1 /*
   2  * Copyright (c) 1985, 1989, 1993
   3  *    The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  32  *
  33  * Permission to use, copy, modify, and distribute this software for any
  34  * purpose with or without fee is hereby granted, provided that the above
  35  * copyright notice and this permission notice appear in all copies, and that
  36  * the name of Digital Equipment Corporation not be used in advertising or
  37  * publicity pertaining to distribution of the document or software without
  38  * specific, written prior permission.
  39  *
  40  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  41  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  42  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  43  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  44  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  45  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  46  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  47  * SOFTWARE.
  48  */
  49
  50 /*
  51  * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
  52  *
  53  * Permission to use, copy, modify, and distribute this software for any
  54  * purpose with or without fee is hereby granted, provided that the above
  55  * copyright notice and this permission notice appear in all copies.
  56  *
  57  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
  58  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  59  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  60  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  61  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  62  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  63  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  64  * SOFTWARE.
  65  */
  66
  67 #if defined(LIBC_SCCS) && !defined(lint)
  68 static const char sccsid[] = "@(#)res_send.c    8.1 (Berkeley) 6/4/93";
  69 static const char rcsid[] = "$BINDId: res_send.c,v 8.38 2000/03/30 20:16:51 vixie Exp $";
  70 #endif /* LIBC_SCCS and not lint */
  71
  72 /*
  73  * Send query to name server and wait for reply.
  74  */
  75
  76 #include <assert.h>
  77 #include <sys/types.h>
  78 #include <sys/param.h>
  79 #include <sys/time.h>
  80 #include <sys/socket.h>
  81 #include <sys/uio.h>
  82 #include <sys/poll.h>
  83
  84 #include <netinet/in.h>
  85 #include <arpa/nameser.h>
  86 #include <arpa/inet.h>
  87 #include <sys/ioctl.h>
  88
  89 #include <errno.h>
  90 #include <fcntl.h>
  91 #include <netdb.h>
  92 #include <resolv.h>
  93 #include <signal.h>
  94 #include <stdio.h>
  95 #include <stdlib.h>
  96 #include <string.h>
  97 #include <unistd.h>
  98 #include <kernel-features.h>
  99
 100 #if PACKETSZ > 65536
 101 #define MAXPACKET       PACKETSZ
 102 #else
 103 #define MAXPACKET       65536
 104 #endif
 105
 106
 107 #ifndef __ASSUME_SOCK_CLOEXEC
 108 static int __have_o_nonblock;
 109 #else
 110 # define __have_o_nonblock 0
 111 #endif
 112
 113
 114 /* From ev_streams.c.  */
 115
 116 static inline void
 117 __attribute ((always_inline))
 118 evConsIovec(void *buf, size_t cnt, struct iovec *vec) {
 119         memset(vec, 0xf5, sizeof (*vec));
 120         vec->iov_base = buf;
 121         vec->iov_len = cnt;
 122 }
 123
 124 /* From ev_timers.c.  */
 125
 126 #define BILLION 1000000000
 127
 128 static inline void
 129 evConsTime(struct timespec *res, time_t sec, long nsec) {
 130         res->tv_sec = sec;
 131         res->tv_nsec = nsec;
 132 }
 133
 134 static inline void
 135 evAddTime(struct timespec *res, const struct timespec *addend1,
 136           const struct timespec *addend2) {
 137         res->tv_sec = addend1->tv_sec + addend2->tv_sec;
 138         res->tv_nsec = addend1->tv_nsec + addend2->tv_nsec;
 139         if (res->tv_nsec >= BILLION) {
 140                 res->tv_sec++;
 141                 res->tv_nsec -= BILLION;
 142         }
 143 }
 144
 145 static inline void
 146 evSubTime(struct timespec *res, const struct timespec *minuend,
 147           const struct timespec *subtrahend) {
 148        res->tv_sec = minuend->tv_sec - subtrahend->tv_sec;
 149         if (minuend->tv_nsec >= subtrahend->tv_nsec)
 150                 res->tv_nsec = minuend->tv_nsec - subtrahend->tv_nsec;
 151         else {
 152                 res->tv_nsec = (BILLION
 153                                 - subtrahend->tv_nsec + minuend->tv_nsec);
 154                 res->tv_sec--;
 155         }
 156 }
 157
 158 static inline int
 159 evCmpTime(struct timespec a, struct timespec b) {
 160         long x = a.tv_sec - b.tv_sec;
 161
 162         if (x == 0L)
 163                 x = a.tv_nsec - b.tv_nsec;
 164         return (x < 0L ? (-1) : x > 0L ? (1) : (0));
 165 }
 166
 167 static inline void
 168 evNowTime(struct timespec *res) {
 169         struct timeval now;
 170
 171         if (gettimeofday(&now, NULL) < 0)
 172                 evConsTime(res, 0, 0);
 173         else
 174                 TIMEVAL_TO_TIMESPEC (&now, res);
 175 }
 176
 177
 178 /* Options.  Leave them on. */
 179 /* #undef DEBUG */
 180 #include "res_debug.h"
 181
 182 #define EXT(res) ((res)->_u._ext)
 183
 184 /* Forward. */
 185
 186 static int              send_vc(res_state, const u_char *, int,
 187                                 const u_char *, int,
 188                                 u_char **, int *, int *, int, u_char **,
 189                                 u_char **, int *, int *);
 190 static int              send_dg(res_state, const u_char *, int,
 191                                 const u_char *, int,
 192                                 u_char **, int *, int *, int,
 193                                 int *, int *, u_char **,
 194                                 u_char **, int *, int *);
 195 #ifdef DEBUG
 196 static void             Aerror(const res_state, FILE *, const char *, int,
 197                                const struct sockaddr *);
 198 static void             Perror(const res_state, FILE *, const char *, int);
 199 #endif
 200 static int              sock_eq(struct sockaddr_in6 *, struct sockaddr_in6 *);
 201
 202 /* Reachover. */
 203
 204 static void convaddr4to6(struct sockaddr_in6 *sa);
 205
 206 /* Public. */
 207
 208 /* int
 209  * res_isourserver(ina)
 210  *      looks up "ina" in _res.ns_addr_list[]
 211  * returns:
 212  *      0  : not found
 213  *      >0 : found
 214  * author:
 215  *      paul vixie, 29may94
 216  */
 217 int
 218 res_ourserver_p(const res_state statp, const struct sockaddr_in6 *inp)
 219 {
 220         int ns;
 221
 222         if (inp->sin6_family == AF_INET) {
 223             struct sockaddr_in *in4p = (struct sockaddr_in *) inp;
 224             in_port_t port = in4p->sin_port;
 225             in_addr_t addr = in4p->sin_addr.s_addr;
 226
 227             for (ns = 0;  ns < MAXNS;  ns++) {
 228                 const struct sockaddr_in *srv =
 229                     (struct sockaddr_in *)EXT(statp).nsaddrs[ns];
 230
 231                 if ((srv != NULL) && (srv->sin_family == AF_INET) &&
 232                     (srv->sin_port == port) &&
 233                     (srv->sin_addr.s_addr == INADDR_ANY ||
 234                      srv->sin_addr.s_addr == addr))
 235                     return (1);
 236             }
 237         } else if (inp->sin6_family == AF_INET6) {
 238             for (ns = 0;  ns < MAXNS;  ns++) {
 239                 const struct sockaddr_in6 *srv = EXT(statp).nsaddrs[ns];
 240                 if ((srv != NULL) && (srv->sin6_family == AF_INET6) &&
 241                     (srv->sin6_port == inp->sin6_port) &&
 242                     !(memcmp(&srv->sin6_addr, &in6addr_any,
 243                              sizeof (struct in6_addr)) &&
 244                       memcmp(&srv->sin6_addr, &inp->sin6_addr,
 245                              sizeof (struct in6_addr))))
 246                     return (1);
 247             }
 248         }
 249         return (0);
 250 }
 251
 252 /* int
 253  * res_nameinquery(name, type, class, buf, eom)
 254  *      look for (name,type,class) in the query section of packet (buf,eom)
 255  * requires:
 256  *      buf + HFIXEDSZ <= eom
 257  * returns:
 258  *      -1 : format error
 259  *      0  : not found
 260  *      >0 : found
 261  * author:
 262  *      paul vixie, 29may94
 263  */
 264 int
 265 res_nameinquery(const char *name, int type, int class,
 266                 const u_char *buf, const u_char *eom)
 267 {
 268         const u_char *cp = buf + HFIXEDSZ;
 269         int qdcount = ntohs(((HEADER*)buf)->qdcount);
 270
 271         while (qdcount-- > 0) {
 272                 char tname[MAXDNAME+1];
 273                 int n, ttype, tclass;
 274
 275                 n = dn_expand(buf, eom, cp, tname, sizeof tname);
 276                 if (n < 0)
 277                         return (-1);
 278                 cp += n;
 279                 if (cp + 2 * INT16SZ > eom)
 280                         return (-1);
 281                 NS_GET16(ttype, cp);
 282                 NS_GET16(tclass, cp);
 283                 if (ttype == type && tclass == class &&
 284                     ns_samename(tname, name) == 1)
 285                         return (1);
 286         }
 287         return (0);
 288 }
 289 libresolv_hidden_def (res_nameinquery)
 290
 291 /* int
 292  * res_queriesmatch(buf1, eom1, buf2, eom2)
 293  *      is there a 1:1 mapping of (name,type,class)
 294  *      in (buf1,eom1) and (buf2,eom2)?
 295  * returns:
 296  *      -1 : format error
 297  *      0  : not a 1:1 mapping
 298  *      >0 : is a 1:1 mapping
 299  * author:
 300  *      paul vixie, 29may94
 301  */
 302 int
 303 res_queriesmatch(const u_char *buf1, const u_char *eom1,
 304                  const u_char *buf2, const u_char *eom2)
 305 {
 306         if (buf1 + HFIXEDSZ > eom1 || buf2 + HFIXEDSZ > eom2)
 307                 return (-1);
 308
 309         /*
 310          * Only header section present in replies to
 311          * dynamic update packets.
 312          */
 313         if ((((HEADER *)buf1)->opcode == ns_o_update) &&
 314             (((HEADER *)buf2)->opcode == ns_o_update))
 315                 return (1);
 316
 317         /* Note that we initially do not convert QDCOUNT to the host byte
 318            order.  We can compare it with the second buffer's QDCOUNT
 319            value without doing this.  */
 320         int qdcount = ((HEADER*)buf1)->qdcount;
 321         if (qdcount != ((HEADER*)buf2)->qdcount)
 322                 return (0);
 323
 324         qdcount = htons (qdcount);
 325         const u_char *cp = buf1 + HFIXEDSZ;
 326
 327         while (qdcount-- > 0) {
 328                 char tname[MAXDNAME+1];
 329                 int n, ttype, tclass;
 330
 331                 n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
 332                 if (n < 0)
 333                         return (-1);
 334                 cp += n;
 335                 if (cp + 2 * INT16SZ > eom1)
 336                         return (-1);
 337                 NS_GET16(ttype, cp);
 338                 NS_GET16(tclass, cp);
 339                 if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
 340                         return (0);
 341         }
 342         return (1);
 343 }
 344 libresolv_hidden_def (res_queriesmatch)
 345
 346 int
 347 __libc_res_nsend(res_state statp, const u_char *buf, int buflen,
 348                  const u_char *buf2, int buflen2,
 349                  u_char *ans, int anssiz, u_char **ansp, u_char **ansp2,
 350                  int *nansp2, int *resplen2)
 351 {
 352   int gotsomewhere, terrno, try, v_circuit, resplen, ns, n;
 353
 354         if (statp->nscount == 0) {
 355                 __set_errno (ESRCH);
 356                 return (-1);
 357         }
 358
 359         if (anssiz < (buf2 == NULL ? 1 : 2) * HFIXEDSZ) {
 360                 __set_errno (EINVAL);
 361                 return (-1);
 362         }
 363
 364 #ifdef USE_HOOKS
 365         if (__builtin_expect (statp->qhook || statp->rhook, 0)) {
 366                 if (anssiz < MAXPACKET && ansp) {
 367                         u_char *buf = malloc (MAXPACKET);
 368                         if (buf == NULL)
 369                                 return (-1);
 370                         memcpy (buf, ans, HFIXEDSZ);
 371                         *ansp = buf;
 372                         ans = buf;
 373                         anssiz = MAXPACKET;
 374                 }
 375         }
 376 #endif
 377
 378         DprintQ((statp->options & RES_DEBUG) || (statp->pfcode & RES_PRF_QUERY),
 379                 (stdout, ";; res_send()\n"), buf, buflen);
 380         v_circuit = ((statp->options & RES_USEVC)
 381                      || buflen > PACKETSZ
 382                      || buflen2 > PACKETSZ);
 383         gotsomewhere = 0;
 384         terrno = ETIMEDOUT;
 385
 386         /*
 387          * If the ns_addr_list in the resolver context has changed, then
 388          * invalidate our cached copy and the associated timing data.
 389          */
 390         if (EXT(statp).nsinit) {
 391                 int needclose = 0;
 392
 393                 if (EXT(statp).nscount != statp->nscount)
 394                         needclose++;
 395                 else
 396                         for (ns = 0; ns < MAXNS; ns++) {
 397                                 unsigned int map = EXT(statp).nsmap[ns];
 398                                 if (map < MAXNS
 399                                     && !sock_eq((struct sockaddr_in6 *)
 400                                                 &statp->nsaddr_list[map],
 401                                                 EXT(statp).nsaddrs[ns]))
 402                                 {
 403                                         needclose++;
 404                                         break;
 405                                 }
 406                         }
 407                 if (needclose)
 408                         __res_iclose(statp, false);
 409         }
 410
 411         /*
 412          * Maybe initialize our private copy of the ns_addr_list.
 413          */
 414         if (EXT(statp).nsinit == 0) {
 415                 unsigned char map[MAXNS];
 416
 417                 memset (map, MAXNS, sizeof (map));
 418                 for (n = 0; n < MAXNS; n++) {
 419                         ns = EXT(statp).nsmap[n];
 420                         if (ns < statp->nscount)
 421                                 map[ns] = n;
 422                         else if (ns < MAXNS) {
 423                                 free(EXT(statp).nsaddrs[n]);
 424                                 EXT(statp).nsaddrs[n] = NULL;
 425                                 EXT(statp).nsmap[n] = MAXNS;
 426                         }
 427                 }
 428                 n = statp->nscount;
 429                 if (statp->nscount > EXT(statp).nscount)
 430                         for (n = EXT(statp).nscount, ns = 0;
 431                              n < statp->nscount; n++) {
 432                                 while (ns < MAXNS
 433                                        && EXT(statp).nsmap[ns] != MAXNS)
 434                                         ns++;
 435                                 if (ns == MAXNS)
 436                                         break;
 437                                 EXT(statp).nsmap[ns] = n;
 438                                 map[n] = ns++;
 439                         }
 440                 EXT(statp).nscount = n;
 441                 for (ns = 0; ns < EXT(statp).nscount; ns++) {
 442                         n = map[ns];
 443                         if (EXT(statp).nsaddrs[n] == NULL)
 444                                 EXT(statp).nsaddrs[n] =
 445                                     malloc(sizeof (struct sockaddr_in6));
 446                         if (EXT(statp).nsaddrs[n] != NULL) {
 447                                 memset (mempcpy(EXT(statp).nsaddrs[n],
 448                                                 &statp->nsaddr_list[n],
 449                                                 sizeof (struct sockaddr_in)),
 450                                         '\0',
 451                                         sizeof (struct sockaddr_in6)
 452                                         - sizeof (struct sockaddr_in));
 453                                 EXT(statp).nssocks[n] = -1;
 454                                 n++;
 455                         }
 456                 }
 457                 EXT(statp).nsinit = 1;
 458         }
 459
 460         /*
 461          * Some resolvers want to even out the load on their nameservers.
 462          * Note that RES_BLAST overrides RES_ROTATE.
 463          */
 464         if (__builtin_expect ((statp->options & RES_ROTATE) != 0, 0) &&
 465             (statp->options & RES_BLAST) == 0) {
 466                 struct sockaddr_in6 *ina;
 467                 unsigned int map;
 468
 469                 n = 0;
 470                 while (n < MAXNS && EXT(statp).nsmap[n] == MAXNS)
 471                         n++;
 472                 if (n < MAXNS) {
 473                         ina = EXT(statp).nsaddrs[n];
 474                         map = EXT(statp).nsmap[n];
 475                         for (;;) {
 476                                 ns = n + 1;
 477                                 while (ns < MAXNS
 478                                        && EXT(statp).nsmap[ns] == MAXNS)
 479                                         ns++;
 480                                 if (ns == MAXNS)
 481                                         break;
 482                                 EXT(statp).nsaddrs[n] = EXT(statp).nsaddrs[ns];
 483                                 EXT(statp).nsmap[n] = EXT(statp).nsmap[ns];
 484                                 n = ns;
 485                         }
 486                         EXT(statp).nsaddrs[n] = ina;
 487                         EXT(statp).nsmap[n] = map;
 488                 }
 489         }
 490
 491         /*
 492          * Send request, RETRY times, or until successful.
 493          */
 494         for (try = 0; try < statp->retry; try++) {
 495             for (ns = 0; ns < MAXNS; ns++)
 496             {
 497                 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 498
 499                 if (nsap == NULL)
 500                         goto next_ns;
 501             same_ns:
 502 #ifdef USE_HOOKS
 503                 if (__builtin_expect (statp->qhook != NULL, 0)) {
 504                         int done = 0, loops = 0;
 505
 506                         do {
 507                                 res_sendhookact act;
 508
 509                                 struct sockaddr_in *nsap4;
 510                                 nsap4 = (struct sockaddr_in *) nsap;
 511                                 act = (*statp->qhook)(&nsap4, &buf, &buflen,
 512                                                       ans, anssiz, &resplen);
 513                                 nsap = (struct sockaddr_in6 *) nsap4;
 514                                 switch (act) {
 515                                 case res_goahead:
 516                                         done = 1;
 517                                         break;
 518                                 case res_nextns:
 519                                         __res_iclose(statp, false);
 520                                         goto next_ns;
 521                                 case res_done:
 522                                         return (resplen);
 523                                 case res_modified:
 524                                         /* give the hook another try */
 525                                         if (++loops < 42) /*doug adams*/
 526                                                 break;
 527                                         /*FALLTHROUGH*/
 528                                 case res_error:
 529                                         /*FALLTHROUGH*/
 530                                 default:
 531                                         return (-1);
 532                                 }
 533                         } while (!done);
 534                 }
 535 #endif
 536
 537 #ifdef DEBUG
 538                 char tmpbuf[40];
 539 #endif
 540                 Dprint(statp->options & RES_DEBUG,
 541                        (stdout, ";; Querying server (# %d) address = %s\n",
 542                         ns + 1, inet_ntop(AF_INET6, &nsap->sin6_addr,
 543                                           tmpbuf, sizeof (tmpbuf))));
 544
 545                 if (__builtin_expect (v_circuit, 0)) {
 546                         /* Use VC; at most one attempt per server. */
 547                         try = statp->retry;
 548                         n = send_vc(statp, buf, buflen, buf2, buflen2,
 549                                     &ans, &anssiz, &terrno,
 550                                     ns, ansp, ansp2, nansp2, resplen2);
 551                         if (n < 0)
 552                                 return (-1);
 553                         if (n == 0)
 554                                 goto next_ns;
 555                 } else {
 556                         /* Use datagrams. */
 557                         n = send_dg(statp, buf, buflen, buf2, buflen2,
 558                                     &ans, &anssiz, &terrno,
 559                                     ns, &v_circuit, &gotsomewhere, ansp,
 560                                     ansp2, nansp2, resplen2);
 561                         if (n < 0)
 562                                 return (-1);
 563                         if (n == 0)
 564                                 goto next_ns;
 565                         if (v_circuit)
 566                           // XXX Check whether both requests failed or
 567                           // XXX whether one has been answered successfully
 568                                 goto same_ns;
 569                 }
 570
 571                 resplen = n;
 572
 573                 Dprint((statp->options & RES_DEBUG) ||
 574                        ((statp->pfcode & RES_PRF_REPLY) &&
 575                         (statp->pfcode & RES_PRF_HEAD1)),
 576                        (stdout, ";; got answer:\n"));
 577
 578                 DprintQ((statp->options & RES_DEBUG) ||
 579                         (statp->pfcode & RES_PRF_REPLY),
 580                         (stdout, "%s", ""),
 581                         ans, (resplen > anssiz) ? anssiz : resplen);
 582                 if (buf2 != NULL)
 583                   DprintQ((statp->options & RES_DEBUG) ||
 584                           (statp->pfcode & RES_PRF_REPLY),
 585                           (stdout, "%s", ""),
 586                           *ansp2, (*resplen2 > *nansp2) ? *nansp2 : *resplen2);
 587
 588                 /*
 589                  * If we have temporarily opened a virtual circuit,
 590                  * or if we haven't been asked to keep a socket open,
 591                  * close the socket.
 592                  */
 593                 if ((v_circuit && (statp->options & RES_USEVC) == 0) ||
 594                     (statp->options & RES_STAYOPEN) == 0) {
 595                         __res_iclose(statp, false);
 596                 }
 597 #ifdef USE_HOOKS
 598                 if (__builtin_expect (statp->rhook, 0)) {
 599                         int done = 0, loops = 0;
 600
 601                         do {
 602                                 res_sendhookact act;
 603
 604                                 act = (*statp->rhook)((struct sockaddr_in *)
 605                                                       nsap, buf, buflen,
 606                                                       ans, anssiz, &resplen);
 607                                 switch (act) {
 608                                 case res_goahead:
 609                                 case res_done:
 610                                         done = 1;
 611                                         break;
 612                                 case res_nextns:
 613                                         __res_iclose(statp, false);
 614                                         goto next_ns;
 615                                 case res_modified:
 616                                         /* give the hook another try */
 617                                         if (++loops < 42) /*doug adams*/
 618                                                 break;
 619                                         /*FALLTHROUGH*/
 620                                 case res_error:
 621                                         /*FALLTHROUGH*/
 622                                 default:
 623                                         return (-1);
 624                                 }
 625                         } while (!done);
 626
 627                 }
 628 #endif
 629                 return (resplen);
 630  next_ns: ;
 631            } /*foreach ns*/
 632         } /*foreach retry*/
 633         __res_iclose(statp, false);
 634         if (!v_circuit) {
 635                 if (!gotsomewhere)
 636                         __set_errno (ECONNREFUSED);     /* no nameservers found */
 637                 else
 638                         __set_errno (ETIMEDOUT);        /* no answer obtained */
 639         } else
 640                 __set_errno (terrno);
 641         return (-1);
 642 }
 643
 644 int
 645 res_nsend(res_state statp,
 646           const u_char *buf, int buflen, u_char *ans, int anssiz)
 647 {
 648   return __libc_res_nsend(statp, buf, buflen, NULL, 0, ans, anssiz,
 649                           NULL, NULL, NULL, NULL);
 650 }
 651 libresolv_hidden_def (res_nsend)
 652
 653 /* Private */
 654
 655 static int
 656 send_vc(res_state statp,
 657         const u_char *buf, int buflen, const u_char *buf2, int buflen2,
 658         u_char **ansp, int *anssizp,
 659         int *terrno, int ns, u_char **anscp, u_char **ansp2, int *anssizp2,
 660         int *resplen2)
 661 {
 662         const HEADER *hp = (HEADER *) buf;
 663         const HEADER *hp2 = (HEADER *) buf2;
 664         u_char *ans = *ansp;
 665         int orig_anssizp = *anssizp;
 666         // XXX REMOVE
 667         // int anssiz = *anssizp;
 668         HEADER *anhp = (HEADER *) ans;
 669         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 670         int truncating, connreset, resplen, n;
 671         struct iovec iov[4];
 672         u_short len;
 673         u_short len2;
 674         u_char *cp;
 675
 676         if (resplen2 != NULL)
 677           *resplen2 = 0;
 678         connreset = 0;
 679  same_ns:
 680         truncating = 0;
 681
 682         /* Are we still talking to whom we want to talk to? */
 683         if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
 684                 struct sockaddr_in6 peer;
 685                 socklen_t size = sizeof peer;
 686
 687                 if (getpeername(statp->_vcsock,
 688                                 (struct sockaddr *)&peer, &size) < 0 ||
 689                     !sock_eq(&peer, nsap)) {
 690                   __res_iclose(statp, false);
 691                         statp->_flags &= ~RES_F_VC;
 692                 }
 693         }
 694
 695         if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
 696                 if (statp->_vcsock >= 0)
 697                   __res_iclose(statp, false);
 698
 699                 statp->_vcsock = socket(nsap->sin6_family, SOCK_STREAM, 0);
 700                 if (statp->_vcsock < 0) {
 701                         *terrno = errno;
 702                         Perror(statp, stderr, "socket(vc)", errno);
 703                         return (-1);
 704                 }
 705                 __set_errno (0);
 706                 if (connect(statp->_vcsock, (struct sockaddr *)nsap,
 707                             nsap->sin6_family == AF_INET
 708                             ? sizeof (struct sockaddr_in)
 709                             : sizeof (struct sockaddr_in6)) < 0) {
 710                         *terrno = errno;
 711                         Aerror(statp, stderr, "connect/vc", errno,
 712                                (struct sockaddr *) nsap);
 713                         __res_iclose(statp, false);
 714                         return (0);
 715                 }
 716                 statp->_flags |= RES_F_VC;
 717         }
 718
 719         /*
 720          * Send length & message
 721          */
 722         len = htons ((u_short) buflen);
 723         evConsIovec(&len, INT16SZ, &iov[0]);
 724         evConsIovec((void*)buf, buflen, &iov[1]);
 725         int niov = 2;
 726         ssize_t explen = INT16SZ + buflen;
 727         if (buf2 != NULL) {
 728                 len2 = htons ((u_short) buflen2);
 729                 evConsIovec(&len2, INT16SZ, &iov[2]);
 730                 evConsIovec((void*)buf2, buflen2, &iov[3]);
 731                 niov = 4;
 732                 explen += INT16SZ + buflen2;
 733         }
 734         if (TEMP_FAILURE_RETRY (writev(statp->_vcsock, iov, niov)) != explen) {
 735                 *terrno = errno;
 736                 Perror(statp, stderr, "write failed", errno);
 737                 __res_iclose(statp, false);
 738                 return (0);
 739         }
 740         /*
 741          * Receive length & response
 742          */
 743         int recvresp1 = 0;
 744         int recvresp2 = buf2 == NULL;
 745         uint16_t rlen16;
 746  read_len:
 747         cp = (u_char *)&rlen16;
 748         len = sizeof(rlen16);
 749         while ((n = TEMP_FAILURE_RETRY (read(statp->_vcsock, cp,
 750                                              (int)len))) > 0) {
 751                 cp += n;
 752                 if ((len -= n) <= 0)
 753                         break;
 754         }
 755         if (n <= 0) {
 756                 *terrno = errno;
 757                 Perror(statp, stderr, "read failed", errno);
 758                 __res_iclose(statp, false);
 759                 /*
 760                  * A long running process might get its TCP
 761                  * connection reset if the remote server was
 762                  * restarted.  Requery the server instead of
 763                  * trying a new one.  When there is only one
 764                  * server, this means that a query might work
 765                  * instead of failing.  We only allow one reset
 766                  * per query to prevent looping.
 767                  */
 768                 if (*terrno == ECONNRESET && !connreset) {
 769                         connreset = 1;
 770                         goto same_ns;
 771                 }
 772                 return (0);
 773         }
 774         int rlen = ntohs (rlen16);
 775
 776         int *thisanssizp;
 777         u_char **thisansp;
 778         int *thisresplenp;
 779         if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) {
 780                 thisanssizp = anssizp;
 781                 thisansp = anscp ?: ansp;
 782                 assert (anscp != NULL || ansp2 == NULL);
 783                 thisresplenp = &resplen;
 784         } else {
 785                 if (*anssizp != MAXPACKET) {
 786                         /* No buffer allocated for the first
 787                            reply.  We can try to use the rest
 788                            of the user-provided buffer.  */
 789 #ifdef _STRING_ARCH_unaligned
 790                         *anssizp2 = orig_anssizp - resplen;
 791                         *ansp2 = *ansp + resplen;
 792 #else
 793                         int aligned_resplen
 794                           = ((resplen + __alignof__ (HEADER) - 1)
 795                              & ~(__alignof__ (HEADER) - 1));
 796                         *anssizp2 = orig_anssizp - aligned_resplen;
 797                         *ansp2 = *ansp + aligned_resplen;
 798 #endif
 799                 } else {
 800                         /* The first reply did not fit into the
 801                            user-provided buffer.  Maybe the second
 802                            answer will.  */
 803                         *anssizp2 = orig_anssizp;
 804                         *ansp2 = *ansp;
 805                 }
 806
 807                 thisanssizp = anssizp2;
 808                 thisansp = ansp2;
 809                 thisresplenp = resplen2;
 810         }
 811         anhp = (HEADER *) *thisansp;
 812
 813         *thisresplenp = rlen;
 814         if (rlen > *thisanssizp) {
 815                 /* Yes, we test ANSCP here.  If we have two buffers
 816                    both will be allocatable.  */
 817                 if (__builtin_expect (anscp != NULL, 1)) {
 818                         u_char *newp = malloc (MAXPACKET);
 819                         if (newp == NULL) {
 820                                 *terrno = ENOMEM;
 821                                 __res_iclose(statp, false);
 822                                 return (0);
 823                         }
 824                         *thisanssizp = MAXPACKET;
 825                         *thisansp = newp;
 826                         anhp = (HEADER *) newp;
 827                         len = rlen;
 828                 } else {
 829                         Dprint(statp->options & RES_DEBUG,
 830                                 (stdout, ";; response truncated\n")
 831                         );
 832                         truncating = 1;
 833                         len = *thisanssizp;
 834                 }
 835         } else
 836                 len = rlen;
 837
 838         if (__builtin_expect (len < HFIXEDSZ, 0)) {
 839                 /*
 840                  * Undersized message.
 841                  */
 842                 Dprint(statp->options & RES_DEBUG,
 843                        (stdout, ";; undersized: %d\n", len));
 844                 *terrno = EMSGSIZE;
 845                 __res_iclose(statp, false);
 846                 return (0);
 847         }
 848
 849         cp = *thisansp;
 850         while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
 851                 cp += n;
 852                 len -= n;
 853         }
 854         if (__builtin_expect (n <= 0, 0)) {
 855                 *terrno = errno;
 856                 Perror(statp, stderr, "read(vc)", errno);
 857                 __res_iclose(statp, false);
 858                 return (0);
 859         }
 860         if (__builtin_expect (truncating, 0)) {
 861                 /*
 862                  * Flush rest of answer so connection stays in synch.
 863                  */
 864                 anhp->tc = 1;
 865                 len = rlen - *thisanssizp;
 866                 while (len != 0) {
 867                         char junk[PACKETSZ];
 868
 869                         n = read(statp->_vcsock, junk,
 870                                  (len > sizeof junk) ? sizeof junk : len);
 871                         if (n > 0)
 872                                 len -= n;
 873                         else
 874                                 break;
 875                 }
 876         }
 877         /*
 878          * If the calling applicating has bailed out of
 879          * a previous call and failed to arrange to have
 880          * the circuit closed or the server has got
 881          * itself confused, then drop the packet and
 882          * wait for the correct one.
 883          */
 884         if ((recvresp1 || hp->id != anhp->id)
 885             && (recvresp2 || hp2->id != anhp->id)) {
 886                 DprintQ((statp->options & RES_DEBUG) ||
 887                         (statp->pfcode & RES_PRF_REPLY),
 888                         (stdout, ";; old answer (unexpected):\n"),
 889                         *thisansp,
 890                         (rlen > *thisanssiz) ? *thisanssiz: rlen);
 891                 goto read_len;
 892         }
 893
 894         /* Mark which reply we received.  */
 895         if (recvresp1 == 0 && hp->id == anhp->id)
 896           recvresp1 = 1;
 897         else
 898           recvresp2 = 1;
 899         /* Repeat waiting if we have a second answer to arrive.  */
 900         if ((recvresp1 & recvresp2) == 0)
 901                 goto read_len;
 902
 903         /*
 904          * All is well, or the error is fatal.  Signal that the
 905          * next nameserver ought not be tried.
 906          */
 907         return resplen;
 908 }
 909
 910 static int
 911 reopen (res_state statp, int *terrno, int ns)
 912 {
 913         if (EXT(statp).nssocks[ns] == -1) {
 914                 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 915
 916                 /* only try IPv6 if IPv6 NS and if not failed before */
 917                 if ((EXT(statp).nscount6 > 0) && !statp->ipv6_unavail) {
 918                         if (__builtin_expect (__have_o_nonblock >= 0, 1)) {
 919                                 EXT(statp).nssocks[ns] =
 920                                   socket(PF_INET6, SOCK_DGRAM|SOCK_NONBLOCK,
 921                                          0);
 922 #ifndef __ASSUME_SOCK_CLOEXEC
 923                                 if (__have_o_nonblock == 0)
 924                                         __have_o_nonblock
 925                                           = (EXT(statp).nssocks[ns] == -1
 926                                              && errno == EINVAL ? -1 : 1);
 927 #endif
 928                         }
 929                         if (__builtin_expect (__have_o_nonblock < 0, 0))
 930                                 EXT(statp).nssocks[ns] =
 931                                   socket(PF_INET6, SOCK_DGRAM, 0);
 932                         if (EXT(statp).nssocks[ns] < 0)
 933                             statp->ipv6_unavail = errno == EAFNOSUPPORT;
 934                         /* If IPv6 socket and nsap is IPv4, make it
 935                            IPv4-mapped */
 936                         else if (nsap->sin6_family == AF_INET)
 937                             convaddr4to6(nsap);
 938                 }
 939                 if (EXT(statp).nssocks[ns] < 0) {
 940                         if (__builtin_expect (__have_o_nonblock >= 0, 1)) {
 941                                 EXT(statp).nssocks[ns]
 942                                   = socket(PF_INET, SOCK_DGRAM|SOCK_NONBLOCK,
 943                                            0);
 944 #ifndef __ASSUME_SOCK_CLOEXEC
 945                                 if (__have_o_nonblock == 0)
 946                                         __have_o_nonblock
 947                                           = (EXT(statp).nssocks[ns] == -1
 948                                              && errno == EINVAL ? -1 : 1);
 949 #endif
 950                         }
 951                         if (__builtin_expect (__have_o_nonblock < 0, 0))
 952                                 EXT(statp).nssocks[ns]
 953                                   = socket(PF_INET, SOCK_DGRAM, 0);
 954                 }
 955                 if (EXT(statp).nssocks[ns] < 0) {
 956                         *terrno = errno;
 957                         Perror(statp, stderr, "socket(dg)", errno);
 958                         return (-1);
 959                 }
 960
 961                 /*
 962                  * On a 4.3BSD+ machine (client and server,
 963                  * actually), sending to a nameserver datagram
 964                  * port with no nameserver will cause an
 965                  * ICMP port unreachable message to be returned.
 966                  * If our datagram socket is "connected" to the
 967                  * server, we get an ECONNREFUSED error on the next
 968                  * socket operation, and select returns if the
 969                  * error message is received.  We can thus detect
 970                  * the absence of a nameserver without timing out.
 971                  */
 972                 if (connect(EXT(statp).nssocks[ns], (struct sockaddr *)nsap,
 973                             sizeof *nsap) < 0) {
 974                         Aerror(statp, stderr, "connect(dg)", errno,
 975                                (struct sockaddr *) nsap);
 976                         __res_iclose(statp, false);
 977                         return (0);
 978                 }
 979                 if (__builtin_expect (__have_o_nonblock < 0, 0)) {
 980                         /* Make socket non-blocking.  */
 981                         int fl = __fcntl (EXT(statp).nssocks[ns], F_GETFL);
 982                         if  (fl != -1)
 983                                 __fcntl (EXT(statp).nssocks[ns], F_SETFL,
 984                                          fl | O_NONBLOCK);
 985                         Dprint(statp->options & RES_DEBUG,
 986                                (stdout, ";; new DG socket\n"))
 987                 }
 988         }
 989
 990         return 1;
 991 }
 992
 993 static int
 994 send_dg(res_state statp,
 995         const u_char *buf, int buflen, const u_char *buf2, int buflen2,
 996         u_char **ansp, int *anssizp,
 997         int *terrno, int ns, int *v_circuit, int *gotsomewhere, u_char **anscp,
 998         u_char **ansp2, int *anssizp2, int *resplen2)
 999 {
1000         const HEADER *hp = (HEADER *) buf;
1001         const HEADER *hp2 = (HEADER *) buf2;
1002         u_char *ans = *ansp;
1003         int orig_anssizp = *anssizp;
1004         struct timespec now, timeout, finish;
1005         struct pollfd pfd[1];
1006         int ptimeout;
1007         struct sockaddr_in6 from;
1008         int resplen = 0;
1009         int n;
1010
1011         /*
1012          * Compute time for the total operation.
1013          */
1014         int seconds = (statp->retrans << ns);
1015         if (ns > 0)
1016                 seconds /= statp->nscount;
1017         if (seconds <= 0)
1018                 seconds = 1;
1019         bool single_request = (statp->options & RES_SNGLKUP) != 0;
1020         bool single_request_reopen = (statp->options & RES_SNGLKUPREOP) != 0;
1021         int save_gotsomewhere = *gotsomewhere;
1022
1023         int retval;
1024  retry_reopen:
1025         retval = reopen (statp, terrno, ns);
1026         if (retval <= 0)
1027                 return retval;
1028  retry:
1029         evNowTime(&now);
1030         evConsTime(&timeout, seconds, 0);
1031         evAddTime(&finish, &now, &timeout);
1032         int need_recompute = 0;
1033         int nwritten = 0;
1034         int recvresp1 = 0;
1035         int recvresp2 = buf2 == NULL;
1036         pfd[0].fd = EXT(statp).nssocks[ns];
1037         pfd[0].events = POLLOUT;
1038         if (resplen2 != NULL)
1039           *resplen2 = 0;
1040  wait:
1041         if (need_recompute) {
1042         recompute_resend:
1043                 evNowTime(&now);
1044                 if (evCmpTime(finish, now) <= 0) {
1045                 poll_err_out:
1046                         Perror(statp, stderr, "poll", errno);
1047                 err_out:
1048                         __res_iclose(statp, false);
1049                         return (0);
1050                 }
1051                 evSubTime(&timeout, &finish, &now);
1052                 need_recompute = 0;
1053         }
1054         /* Convert struct timespec in milliseconds.  */
1055         ptimeout = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
1056
1057         n = 0;
1058         if (nwritten == 0)
1059           n = __poll (pfd, 1, 0);
1060         if (__builtin_expect (n == 0, 0)) {
1061                 n = __poll (pfd, 1, ptimeout);
1062                 need_recompute = 1;
1063         }
1064         if (n == 0) {
1065                 Dprint(statp->options & RES_DEBUG, (stdout, ";; timeout\n"));
1066                 if (resplen > 1 && (recvresp1 || (buf2 != NULL && recvresp2)))
1067                   {
1068                     /* There are quite a few broken name servers out
1069                        there which don't handle two outstanding
1070                        requests from the same source.  There are also
1071                        broken firewall settings.  If we time out after
1072                        having received one answer switch to the mode
1073                        where we send the second request only once we
1074                        have received the first answer.  */
1075                     if (!single_request)
1076                       {
1077                         statp->options |= RES_SNGLKUP;
1078                         single_request = true;
1079                         *gotsomewhere = save_gotsomewhere;
1080                         goto retry;
1081                       }
1082                     else if (!single_request_reopen)
1083                       {
1084                         statp->options |= RES_SNGLKUPREOP;
1085                         single_request_reopen = true;
1086                         *gotsomewhere = save_gotsomewhere;
1087                         __res_iclose (statp, false);
1088                         goto retry_reopen;
1089                       }
1090
1091                     *resplen2 = 1;
1092                     return resplen;
1093                   }
1094
1095                 *gotsomewhere = 1;
1096                 return (0);
1097         }
1098         if (n < 0) {
1099                 if (errno == EINTR)
1100                         goto recompute_resend;
1101
1102                 goto poll_err_out;
1103         }
1104         __set_errno (0);
1105         if (pfd[0].revents & POLLOUT) {
1106                 ssize_t sr;
1107                 if (nwritten != 0)
1108                   sr = send (pfd[0].fd, buf2, buflen2, MSG_NOSIGNAL);
1109                 else
1110                   sr = send (pfd[0].fd, buf, buflen, MSG_NOSIGNAL);
1111
1112                 if (sr != buflen) {
1113                         if (errno == EINTR || errno == EAGAIN)
1114                                 goto recompute_resend;
1115                         Perror(statp, stderr, "send", errno);
1116                         goto err_out;
1117                 }
1118                 if (nwritten != 0 || buf2 == NULL
1119                     || single_request || single_request_reopen)
1120                   pfd[0].events = POLLIN;
1121                 else
1122                   pfd[0].events = POLLIN | POLLOUT;
1123                 ++nwritten;
1124                 goto wait;
1125         } else if (pfd[0].revents & POLLIN) {
1126                 int *thisanssizp;
1127                 u_char **thisansp;
1128                 int *thisresplenp;
1129
1130                 if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) {
1131                         thisanssizp = anssizp;
1132                         thisansp = anscp ?: ansp;
1133                         assert (anscp != NULL || ansp2 == NULL);
1134                         thisresplenp = &resplen;
1135                 } else {
1136                         if (*anssizp != MAXPACKET) {
1137                                 /* No buffer allocated for the first
1138                                    reply.  We can try to use the rest
1139                                    of the user-provided buffer.  */
1140 #ifdef _STRING_ARCH_unaligned
1141                                 *anssizp2 = orig_anssizp - resplen;
1142                                 *ansp2 = *ansp + resplen;
1143 #else
1144                                 int aligned_resplen
1145                                   = ((resplen + __alignof__ (HEADER) - 1)
1146                                      & ~(__alignof__ (HEADER) - 1));
1147                                 *anssizp2 = orig_anssizp - aligned_resplen;
1148                                 *ansp2 = *ansp + aligned_resplen;
1149 #endif
1150                         } else {
1151                                 /* The first reply did not fit into the
1152                                    user-provided buffer.  Maybe the second
1153                                    answer will.  */
1154                                 *anssizp2 = orig_anssizp;
1155                                 *ansp2 = *ansp;
1156                         }
1157
1158                         thisanssizp = anssizp2;
1159                         thisansp = ansp2;
1160                         thisresplenp = resplen2;
1161                 }
1162
1163                 if (*thisanssizp < MAXPACKET
1164                     /* Yes, we test ANSCP here.  If we have two buffers
1165                        both will be allocatable.  */
1166                     && anscp
1167                     && (ioctl (pfd[0].fd, FIONREAD, thisresplenp) < 0
1168                         || *thisanssizp < *thisresplenp)) {
1169                         u_char *newp = malloc (MAXPACKET);
1170                         if (newp != NULL) {
1171                                 *anssizp = MAXPACKET;
1172                                 *thisansp = ans = newp;
1173                         }
1174                 }
1175                 HEADER *anhp = (HEADER *) *thisansp;
1176                 socklen_t fromlen = sizeof(struct sockaddr_in6);
1177                 assert (sizeof(from) <= fromlen);
1178                 *thisresplenp = recvfrom(pfd[0].fd, (char*)*thisansp,
1179                                          *thisanssizp, 0,
1180                                         (struct sockaddr *)&from, &fromlen);
1181                 if (__builtin_expect (*thisresplenp <= 0, 0)) {
1182                         if (errno == EINTR || errno == EAGAIN) {
1183                                 need_recompute = 1;
1184                                 goto wait;
1185                         }
1186                         Perror(statp, stderr, "recvfrom", errno);
1187                         goto err_out;
1188                 }
1189                 *gotsomewhere = 1;
1190                 if (__builtin_expect (*thisresplenp < HFIXEDSZ, 0)) {
1191                         /*
1192                          * Undersized message.
1193                          */
1194                         Dprint(statp->options & RES_DEBUG,
1195                                (stdout, ";; undersized: %d\n",
1196                                 *thisresplen));
1197                         *terrno = EMSGSIZE;
1198                         goto err_out;
1199                 }
1200                 if ((recvresp1 || hp->id != anhp->id)
1201                     && (recvresp2 || hp2->id != anhp->id)) {
1202                         /*
1203                          * response from old query, ignore it.
1204                          * XXX - potential security hazard could
1205                          *       be detected here.
1206                          */
1207                         DprintQ((statp->options & RES_DEBUG) ||
1208                                 (statp->pfcode & RES_PRF_REPLY),
1209                                 (stdout, ";; old answer:\n"),
1210                                 thisansp,
1211                                 (*thisresplen > *thisanssiz)
1212                                 ? *thisanssiz : *thisresplen);
1213                         goto wait;
1214                 }
1215                 if (!(statp->options & RES_INSECURE1) &&
1216                     !res_ourserver_p(statp, &from)) {
1217                         /*
1218                          * response from wrong server? ignore it.
1219                          * XXX - potential security hazard could
1220                          *       be detected here.
1221                          */
1222                         DprintQ((statp->options & RES_DEBUG) ||
1223                                 (statp->pfcode & RES_PRF_REPLY),
1224                                 (stdout, ";; not our server:\n"),
1225                                 thisansp,
1226                                 (*thisresplen > *thisanssiz)
1227                                 ? *thisanssiz : *thisresplen);
1228                         goto wait;
1229                 }
1230 #ifdef RES_USE_EDNS0
1231                 if (anhp->rcode == FORMERR
1232                     && (statp->options & RES_USE_EDNS0) != 0U) {
1233                         /*
1234                          * Do not retry if the server does not understand
1235                          * EDNS0.  The case has to be captured here, as
1236                          * FORMERR packet do not carry query section, hence
1237                          * res_queriesmatch() returns 0.
1238                          */
1239                         DprintQ(statp->options & RES_DEBUG,
1240                                 (stdout,
1241                                  "server rejected query with EDNS0:\n"),
1242                                 thisans,
1243                                 (*thisresplen > *thisanssiz)
1244                                 ? *thisanssiz : *thisresplen);
1245                         /* record the error */
1246                         statp->_flags |= RES_F_EDNS0ERR;
1247                         goto err_out;
1248         }
1249 #endif
1250                 if (!(statp->options & RES_INSECURE2)
1251                     && (recvresp1 || !res_queriesmatch(buf, buf + buflen,
1252                                                        *thisansp,
1253                                                        *thisansp
1254                                                        + *thisanssizp))
1255                     && (recvresp2 || !res_queriesmatch(buf2, buf2 + buflen2,
1256                                                        *thisansp,
1257                                                        *thisansp
1258                                                        + *thisanssizp))) {
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                                 thisansp,
1268                                 (*thisresplen > *thisanssiz)
1269                                 ? *thisanssiz : *thisresplen);
1270                         goto wait;
1271                 }
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                                 thisansp,
1278                                 (*thisresplen > *thisanssiz)
1279                                 ? *thisanssiz : *thisresplen);
1280
1281                         if (recvresp1 || (buf2 != NULL && recvresp2))
1282                           return resplen;
1283                         if (buf2 != NULL)
1284                           {
1285                             /* We are waiting for a possible second reply.  */
1286                             if (hp->id == anhp->id)
1287                               recvresp1 = 1;
1288                             else
1289                               recvresp2 = 1;
1290
1291                             goto wait;
1292                           }
1293
1294                 next_ns:
1295                         __res_iclose(statp, false);
1296                         /* don't retry if called from dig */
1297                         if (!statp->pfcode)
1298                                 return (0);
1299                 }
1300                 if (anhp->rcode == NOERROR && anhp->ancount == 0
1301                     && anhp->aa == 0 && anhp->ra == 0 && anhp->arcount == 0) {
1302                         DprintQ(statp->options & RES_DEBUG,
1303                                 (stdout, "referred query:\n"),
1304                                 thisansp,
1305                                 (*thisresplen > *thisanssiz)
1306                                 ? *thisanssiz : *thisresplen);
1307                         goto next_ns;
1308                 }
1309                 if (!(statp->options & RES_IGNTC) && anhp->tc) {
1310                         /*
1311                          * To get the rest of answer,
1312                          * use TCP with same server.
1313                          */
1314                         Dprint(statp->options & RES_DEBUG,
1315                                (stdout, ";; truncated answer\n"));
1316                         *v_circuit = 1;
1317                         __res_iclose(statp, false);
1318                         // XXX if we have received one reply we could
1319                         // XXX use it and not repeat it over TCP...
1320                         return (1);
1321                 }
1322                 /* Mark which reply we received.  */
1323                 if (recvresp1 == 0 && hp->id == anhp->id)
1324                         recvresp1 = 1;
1325                 else
1326                         recvresp2 = 1;
1327                 /* Repeat waiting if we have a second answer to arrive.  */
1328                 if ((recvresp1 & recvresp2) == 0) {
1329                         if (single_request || single_request_reopen) {
1330                                 pfd[0].events = POLLOUT;
1331                                 if (single_request_reopen) {
1332                                         __res_iclose (statp, false);
1333                                         retval = reopen (statp, terrno, ns);
1334                                         if (retval <= 0)
1335                                                 return retval;
1336                                 }
1337                         }
1338                         goto wait;
1339                 }
1340                 /*
1341                  * All is well, or the error is fatal.  Signal that the
1342                  * next nameserver ought not be tried.
1343                  */
1344                 return (resplen);
1345         } else if (pfd[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
1346                 /* Something went wrong.  We can stop trying.  */
1347                 goto err_out;
1348         }
1349         else {
1350                 /* poll should not have returned > 0 in this case.  */
1351                 abort ();
1352         }
1353 }
1354
1355 #ifdef DEBUG
1356 static void
1357 Aerror(const res_state statp, FILE *file, const char *string, int error,
1358        const struct sockaddr *address)
1359 {
1360         int save = errno;
1361
1362         if ((statp->options & RES_DEBUG) != 0) {
1363                 char tmp[sizeof "xxxx.xxxx.xxxx.255.255.255.255"];
1364
1365                 fprintf(file, "res_send: %s ([%s].%u): %s\n",
1366                         string,
1367                         (address->sa_family == AF_INET
1368                          ? inet_ntop(address->sa_family,
1369                                      &((const struct sockaddr_in *) address)->sin_addr,
1370                                      tmp, sizeof tmp)
1371                          : inet_ntop(address->sa_family,
1372                                      &((const struct sockaddr_in6 *) address)->sin6_addr,
1373                                      tmp, sizeof tmp)),
1374                         (address->sa_family == AF_INET
1375                          ? ntohs(((struct sockaddr_in *) address)->sin_port)
1376                          : address->sa_family == AF_INET6
1377                          ? ntohs(((struct sockaddr_in6 *) address)->sin6_port)
1378                          : 0),
1379                         strerror(error));
1380         }
1381         __set_errno (save);
1382 }
1383
1384 static void
1385 Perror(const res_state statp, FILE *file, const char *string, int error) {
1386         int save = errno;
1387
1388         if ((statp->options & RES_DEBUG) != 0)
1389                 fprintf(file, "res_send: %s: %s\n",
1390                         string, strerror(error));
1391         __set_errno (save);
1392 }
1393 #endif
1394
1395 static int
1396 sock_eq(struct sockaddr_in6 *a1, struct sockaddr_in6 *a2) {
1397         if (a1->sin6_family == a2->sin6_family) {
1398                 if (a1->sin6_family == AF_INET)
1399                         return ((((struct sockaddr_in *)a1)->sin_port ==
1400                                  ((struct sockaddr_in *)a2)->sin_port) &&
1401                                 (((struct sockaddr_in *)a1)->sin_addr.s_addr ==
1402                                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1403                 else
1404                         return ((a1->sin6_port == a2->sin6_port) &&
1405                                 !memcmp(&a1->sin6_addr, &a2->sin6_addr,
1406                                         sizeof (struct in6_addr)));
1407         }
1408         if (a1->sin6_family == AF_INET) {
1409                 struct sockaddr_in6 *sap = a1;
1410                 a1 = a2;
1411                 a2 = sap;
1412         } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1413         return ((a1->sin6_port == ((struct sockaddr_in *)a2)->sin_port) &&
1414                 IN6_IS_ADDR_V4MAPPED(&a1->sin6_addr) &&
1415                 (a1->sin6_addr.s6_addr32[3] ==
1416                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1417 }
1418
1419 /*
1420  * Converts IPv4 family, address and port to
1421  * IPv6 family, IPv4-mapped IPv6 address and port.
1422  */
1423 static void
1424 convaddr4to6(struct sockaddr_in6 *sa)
1425 {
1426     struct sockaddr_in *sa4p = (struct sockaddr_in *) sa;
1427     in_port_t port = sa4p->sin_port;
1428     in_addr_t addr = sa4p->sin_addr.s_addr;
1429
1430     sa->sin6_family = AF_INET6;
1431     sa->sin6_port = port;
1432     sa->sin6_addr.s6_addr32[0] = 0;
1433     sa->sin6_addr.s6_addr32[1] = 0;
1434     sa->sin6_addr.s6_addr32[2] = htonl(0xFFFF);
1435     sa->sin6_addr.s6_addr32[3] = addr;
1436 }