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
  99 #if PACKETSZ > 65536
 100 #define MAXPACKET       PACKETSZ
 101 #else
 102 #define MAXPACKET       65536
 103 #endif
 104
 105
 106 /* From ev_streams.c.  */
 107
 108 static inline void
 109 __attribute ((always_inline))
 110 evConsIovec(void *buf, size_t cnt, struct iovec *vec) {
 111         memset(vec, 0xf5, sizeof (*vec));
 112         vec->iov_base = buf;
 113         vec->iov_len = cnt;
 114 }
 115
 116 /* From ev_timers.c.  */
 117
 118 #define BILLION 1000000000
 119
 120 static inline void
 121 evConsTime(struct timespec *res, time_t sec, long nsec) {
 122         res->tv_sec = sec;
 123         res->tv_nsec = nsec;
 124 }
 125
 126 static inline void
 127 evAddTime(struct timespec *res, const struct timespec *addend1,
 128           const struct timespec *addend2) {
 129         res->tv_sec = addend1->tv_sec + addend2->tv_sec;
 130         res->tv_nsec = addend1->tv_nsec + addend2->tv_nsec;
 131         if (res->tv_nsec >= BILLION) {
 132                 res->tv_sec++;
 133                 res->tv_nsec -= BILLION;
 134         }
 135 }
 136
 137 static inline void
 138 evSubTime(struct timespec *res, const struct timespec *minuend,
 139           const struct timespec *subtrahend) {
 140        res->tv_sec = minuend->tv_sec - subtrahend->tv_sec;
 141         if (minuend->tv_nsec >= subtrahend->tv_nsec)
 142                 res->tv_nsec = minuend->tv_nsec - subtrahend->tv_nsec;
 143         else {
 144                 res->tv_nsec = (BILLION
 145                                 - subtrahend->tv_nsec + minuend->tv_nsec);
 146                 res->tv_sec--;
 147         }
 148 }
 149
 150 static inline int
 151 evCmpTime(struct timespec a, struct timespec b) {
 152         long x = a.tv_sec - b.tv_sec;
 153
 154         if (x == 0L)
 155                 x = a.tv_nsec - b.tv_nsec;
 156         return (x < 0L ? (-1) : x > 0L ? (1) : (0));
 157 }
 158
 159 static inline void
 160 evNowTime(struct timespec *res) {
 161         struct timeval now;
 162
 163         if (gettimeofday(&now, NULL) < 0)
 164                 evConsTime(res, 0, 0);
 165         else
 166                 TIMEVAL_TO_TIMESPEC (&now, res);
 167 }
 168
 169
 170 /* Options.  Leave them on. */
 171 /* #undef DEBUG */
 172 #include "res_debug.h"
 173
 174 #define EXT(res) ((res)->_u._ext)
 175
 176 /* Forward. */
 177
 178 static int              send_vc(res_state, const u_char *, int,
 179                                 u_char **, int *, int *, int, u_char **);
 180 static int              send_dg(res_state, const u_char *, int,
 181                                 u_char **, int *, int *, int,
 182                                 int *, int *, u_char **);
 183 #ifdef DEBUG
 184 static void             Aerror(const res_state, FILE *, const char *, int,
 185                                const struct sockaddr *);
 186 static void             Perror(const res_state, FILE *, const char *, int);
 187 #endif
 188 static int              sock_eq(struct sockaddr_in6 *, struct sockaddr_in6 *);
 189
 190 /* Reachover. */
 191
 192 static void convaddr4to6(struct sockaddr_in6 *sa);
 193 void res_pquery(const res_state, const u_char *, int, FILE *);
 194
 195 /* Public. */
 196
 197 /* int
 198  * res_isourserver(ina)
 199  *      looks up "ina" in _res.ns_addr_list[]
 200  * returns:
 201  *      0  : not found
 202  *      >0 : found
 203  * author:
 204  *      paul vixie, 29may94
 205  */
 206 int
 207 res_ourserver_p(const res_state statp, const struct sockaddr_in6 *inp)
 208 {
 209         int ns;
 210
 211         if (inp->sin6_family == AF_INET) {
 212             struct sockaddr_in *in4p = (struct sockaddr_in *) inp;
 213             in_port_t port = in4p->sin_port;
 214             in_addr_t addr = in4p->sin_addr.s_addr;
 215
 216             for (ns = 0;  ns < MAXNS;  ns++) {
 217                 const struct sockaddr_in *srv =
 218                     (struct sockaddr_in *)EXT(statp).nsaddrs[ns];
 219
 220                 if ((srv != NULL) && (srv->sin_family == AF_INET) &&
 221                     (srv->sin_port == port) &&
 222                     (srv->sin_addr.s_addr == INADDR_ANY ||
 223                      srv->sin_addr.s_addr == addr))
 224                     return (1);
 225             }
 226         } else if (inp->sin6_family == AF_INET6) {
 227             for (ns = 0;  ns < MAXNS;  ns++) {
 228                 const struct sockaddr_in6 *srv = EXT(statp).nsaddrs[ns];
 229                 if ((srv != NULL) && (srv->sin6_family == AF_INET6) &&
 230                     (srv->sin6_port == inp->sin6_port) &&
 231                     !(memcmp(&srv->sin6_addr, &in6addr_any,
 232                              sizeof (struct in6_addr)) &&
 233                       memcmp(&srv->sin6_addr, &inp->sin6_addr,
 234                              sizeof (struct in6_addr))))
 235                     return (1);
 236             }
 237         }
 238         return (0);
 239 }
 240
 241 /* int
 242  * res_nameinquery(name, type, class, buf, eom)
 243  *      look for (name,type,class) in the query section of packet (buf,eom)
 244  * requires:
 245  *      buf + HFIXEDSZ <= eom
 246  * returns:
 247  *      -1 : format error
 248  *      0  : not found
 249  *      >0 : found
 250  * author:
 251  *      paul vixie, 29may94
 252  */
 253 int
 254 res_nameinquery(const char *name, int type, int class,
 255                 const u_char *buf, const u_char *eom)
 256 {
 257         const u_char *cp = buf + HFIXEDSZ;
 258         int qdcount = ntohs(((HEADER*)buf)->qdcount);
 259
 260         while (qdcount-- > 0) {
 261                 char tname[MAXDNAME+1];
 262                 int n, ttype, tclass;
 263
 264                 n = dn_expand(buf, eom, cp, tname, sizeof tname);
 265                 if (n < 0)
 266                         return (-1);
 267                 cp += n;
 268                 if (cp + 2 * INT16SZ > eom)
 269                         return (-1);
 270                 ttype = ns_get16(cp); cp += INT16SZ;
 271                 tclass = ns_get16(cp); cp += INT16SZ;
 272                 if (ttype == type && tclass == class &&
 273                     ns_samename(tname, name) == 1)
 274                         return (1);
 275         }
 276         return (0);
 277 }
 278 libresolv_hidden_def (res_nameinquery)
 279
 280 /* int
 281  * res_queriesmatch(buf1, eom1, buf2, eom2)
 282  *      is there a 1:1 mapping of (name,type,class)
 283  *      in (buf1,eom1) and (buf2,eom2)?
 284  * returns:
 285  *      -1 : format error
 286  *      0  : not a 1:1 mapping
 287  *      >0 : is a 1:1 mapping
 288  * author:
 289  *      paul vixie, 29may94
 290  */
 291 int
 292 res_queriesmatch(const u_char *buf1, const u_char *eom1,
 293                  const u_char *buf2, const u_char *eom2)
 294 {
 295         const u_char *cp = buf1 + HFIXEDSZ;
 296         int qdcount = ntohs(((HEADER*)buf1)->qdcount);
 297
 298         if (buf1 + HFIXEDSZ > eom1 || buf2 + HFIXEDSZ > eom2)
 299                 return (-1);
 300
 301         /*
 302          * Only header section present in replies to
 303          * dynamic update packets.
 304          */
 305         if ((((HEADER *)buf1)->opcode == ns_o_update) &&
 306             (((HEADER *)buf2)->opcode == ns_o_update))
 307                 return (1);
 308
 309         if (qdcount != ntohs(((HEADER*)buf2)->qdcount))
 310                 return (0);
 311         while (qdcount-- > 0) {
 312                 char tname[MAXDNAME+1];
 313                 int n, ttype, tclass;
 314
 315                 n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
 316                 if (n < 0)
 317                         return (-1);
 318                 cp += n;
 319                 if (cp + 2 * INT16SZ > eom1)
 320                         return (-1);
 321                 ttype = ns_get16(cp);   cp += INT16SZ;
 322                 tclass = ns_get16(cp); cp += INT16SZ;
 323                 if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
 324                         return (0);
 325         }
 326         return (1);
 327 }
 328 libresolv_hidden_def (res_queriesmatch)
 329
 330 int
 331 __libc_res_nsend(res_state statp, const u_char *buf, int buflen,
 332                  u_char *ans, int anssiz, u_char **ansp)
 333 {
 334         int gotsomewhere, terrno, try, v_circuit, resplen, ns, n;
 335
 336         if (statp->nscount == 0) {
 337                 __set_errno (ESRCH);
 338                 return (-1);
 339         }
 340
 341         if (anssiz < HFIXEDSZ) {
 342                 __set_errno (EINVAL);
 343                 return (-1);
 344         }
 345
 346         if ((statp->qhook || statp->rhook) && anssiz < MAXPACKET && ansp) {
 347                 u_char *buf = malloc (MAXPACKET);
 348                 if (buf == NULL)
 349                         return (-1);
 350                 memcpy (buf, ans, HFIXEDSZ);
 351                 *ansp = buf;
 352                 ans = buf;
 353                 anssiz = MAXPACKET;
 354         }
 355
 356         DprintQ((statp->options & RES_DEBUG) || (statp->pfcode & RES_PRF_QUERY),
 357                 (stdout, ";; res_send()\n"), buf, buflen);
 358         v_circuit = (statp->options & RES_USEVC) || buflen > PACKETSZ;
 359         gotsomewhere = 0;
 360         terrno = ETIMEDOUT;
 361
 362         /*
 363          * If the ns_addr_list in the resolver context has changed, then
 364          * invalidate our cached copy and the associated timing data.
 365          */
 366         if (EXT(statp).nsinit) {
 367                 int needclose = 0;
 368
 369                 if (EXT(statp).nscount != statp->nscount)
 370                         needclose++;
 371                 else
 372                         for (ns = 0; ns < MAXNS; ns++) {
 373                                 unsigned int map = EXT(statp).nsmap[ns];
 374                                 if (map < MAXNS
 375                                     && !sock_eq((struct sockaddr_in6 *)
 376                                                 &statp->nsaddr_list[map],
 377                                                 EXT(statp).nsaddrs[ns]))
 378                                 {
 379                                         needclose++;
 380                                         break;
 381                                 }
 382                         }
 383                 if (needclose)
 384                         res_nclose(statp);
 385         }
 386
 387         /*
 388          * Maybe initialize our private copy of the ns_addr_list.
 389          */
 390         if (EXT(statp).nsinit == 0) {
 391                 unsigned char map[MAXNS];
 392
 393                 memset (map, MAXNS, sizeof (map));
 394                 for (n = 0; n < MAXNS; n++) {
 395                         ns = EXT(statp).nsmap[n];
 396                         if (ns < statp->nscount)
 397                                 map[ns] = n;
 398                         else if (ns < MAXNS) {
 399                                 free(EXT(statp).nsaddrs[n]);
 400                                 EXT(statp).nsaddrs[n] = NULL;
 401                                 EXT(statp).nsmap[n] = MAXNS;
 402                         }
 403                 }
 404                 n = statp->nscount;
 405                 if (statp->nscount > EXT(statp).nscount)
 406                         for (n = EXT(statp).nscount, ns = 0;
 407                              n < statp->nscount; n++) {
 408                                 while (ns < MAXNS
 409                                        && EXT(statp).nsmap[ns] != MAXNS)
 410                                         ns++;
 411                                 if (ns == MAXNS)
 412                                         break;
 413                                 EXT(statp).nsmap[ns] = n;
 414                                 map[n] = ns++;
 415                         }
 416                 EXT(statp).nscount = n;
 417                 for (ns = 0; ns < EXT(statp).nscount; ns++) {
 418                         n = map[ns];
 419                         if (EXT(statp).nsaddrs[n] == NULL)
 420                                 EXT(statp).nsaddrs[n] =
 421                                     malloc(sizeof (struct sockaddr_in6));
 422                         if (EXT(statp).nsaddrs[n] != NULL) {
 423                                 memcpy(EXT(statp).nsaddrs[n],
 424                                        &statp->nsaddr_list[ns],
 425                                        sizeof (struct sockaddr_in));
 426                                 EXT(statp).nssocks[n] = -1;
 427                                 n++;
 428                         }
 429                 }
 430                 EXT(statp).nsinit = 1;
 431         }
 432
 433         /*
 434          * Some resolvers want to even out the load on their nameservers.
 435          * Note that RES_BLAST overrides RES_ROTATE.
 436          */
 437         if ((statp->options & RES_ROTATE) != 0 &&
 438             (statp->options & RES_BLAST) == 0) {
 439                 struct sockaddr_in6 *ina;
 440                 unsigned int map;
 441
 442                 n = 0;
 443                 while (n < MAXNS && EXT(statp).nsmap[n] == MAXNS)
 444                         n++;
 445                 if (n < MAXNS) {
 446                         ina = EXT(statp).nsaddrs[n];
 447                         map = EXT(statp).nsmap[n];
 448                         for (;;) {
 449                                 ns = n + 1;
 450                                 while (ns < MAXNS
 451                                        && EXT(statp).nsmap[ns] == MAXNS)
 452                                         ns++;
 453                                 if (ns == MAXNS)
 454                                         break;
 455                                 EXT(statp).nsaddrs[n] = EXT(statp).nsaddrs[ns];
 456                                 EXT(statp).nsmap[n] = EXT(statp).nsmap[ns];
 457                                 n = ns;
 458                         }
 459                         EXT(statp).nsaddrs[n] = ina;
 460                         EXT(statp).nsmap[n] = map;
 461                 }
 462         }
 463
 464         /*
 465          * Send request, RETRY times, or until successful.
 466          */
 467         for (try = 0; try < statp->retry; try++) {
 468             for (ns = 0; ns < MAXNS; ns++)
 469             {
 470                 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 471
 472                 if (nsap == NULL)
 473                         goto next_ns;
 474  same_ns:
 475                 if (statp->qhook) {
 476                         int done = 0, loops = 0;
 477
 478                         do {
 479                                 res_sendhookact act;
 480
 481                                 struct sockaddr_in *nsap4;
 482                                 nsap4 = (struct sockaddr_in *) nsap;
 483                                 act = (*statp->qhook)(&nsap4, &buf, &buflen,
 484                                                       ans, anssiz, &resplen);
 485                                 nsap = (struct sockaddr_in6 *) nsap4;
 486                                 switch (act) {
 487                                 case res_goahead:
 488                                         done = 1;
 489                                         break;
 490                                 case res_nextns:
 491                                         res_nclose(statp);
 492                                         goto next_ns;
 493                                 case res_done:
 494                                         return (resplen);
 495                                 case res_modified:
 496                                         /* give the hook another try */
 497                                         if (++loops < 42) /*doug adams*/
 498                                                 break;
 499                                         /*FALLTHROUGH*/
 500                                 case res_error:
 501                                         /*FALLTHROUGH*/
 502                                 default:
 503                                         return (-1);
 504                                 }
 505                         } while (!done);
 506                 }
 507
 508 #ifdef DEBUG
 509                 char tmpbuf[40];
 510 #endif
 511                 Dprint(statp->options & RES_DEBUG,
 512                        (stdout, ";; Querying server (# %d) address = %s\n",
 513                         ns + 1, inet_ntop(AF_INET6, &nsap->sin6_addr,
 514                                           tmpbuf, sizeof (tmpbuf))));
 515
 516                 if (v_circuit) {
 517                         /* Use VC; at most one attempt per server. */
 518                         try = statp->retry;
 519                         n = send_vc(statp, buf, buflen, &ans, &anssiz, &terrno,
 520                                     ns, ansp);
 521                         if (n < 0)
 522                                 return (-1);
 523                         if (n == 0)
 524                                 goto next_ns;
 525                         resplen = n;
 526                 } else {
 527                         /* Use datagrams. */
 528                         n = send_dg(statp, buf, buflen, &ans, &anssiz, &terrno,
 529                                     ns, &v_circuit, &gotsomewhere, ansp);
 530                         if (n < 0)
 531                                 return (-1);
 532                         if (n == 0)
 533                                 goto next_ns;
 534                         if (v_circuit)
 535                                 goto same_ns;
 536                         resplen = n;
 537                 }
 538
 539                 Dprint((statp->options & RES_DEBUG) ||
 540                        ((statp->pfcode & RES_PRF_REPLY) &&
 541                         (statp->pfcode & RES_PRF_HEAD1)),
 542                        (stdout, ";; got answer:\n"));
 543
 544                 DprintQ((statp->options & RES_DEBUG) ||
 545                         (statp->pfcode & RES_PRF_REPLY),
 546                         (stdout, "%s", ""),
 547                         ans, (resplen > anssiz) ? anssiz : resplen);
 548
 549                 /*
 550                  * If we have temporarily opened a virtual circuit,
 551                  * or if we haven't been asked to keep a socket open,
 552                  * close the socket.
 553                  */
 554                 if ((v_circuit && (statp->options & RES_USEVC) == 0) ||
 555                     (statp->options & RES_STAYOPEN) == 0) {
 556                         res_nclose(statp);
 557                 }
 558                 if (statp->rhook) {
 559                         int done = 0, loops = 0;
 560
 561                         do {
 562                                 res_sendhookact act;
 563
 564                                 act = (*statp->rhook)((struct sockaddr_in *)
 565                                                       nsap, buf, buflen,
 566                                                       ans, anssiz, &resplen);
 567                                 switch (act) {
 568                                 case res_goahead:
 569                                 case res_done:
 570                                         done = 1;
 571                                         break;
 572                                 case res_nextns:
 573                                         res_nclose(statp);
 574                                         goto next_ns;
 575                                 case res_modified:
 576                                         /* give the hook another try */
 577                                         if (++loops < 42) /*doug adams*/
 578                                                 break;
 579                                         /*FALLTHROUGH*/
 580                                 case res_error:
 581                                         /*FALLTHROUGH*/
 582                                 default:
 583                                         return (-1);
 584                                 }
 585                         } while (!done);
 586
 587                 }
 588                 return (resplen);
 589  next_ns: ;
 590            } /*foreach ns*/
 591         } /*foreach retry*/
 592         res_nclose(statp);
 593         if (!v_circuit) {
 594                 if (!gotsomewhere)
 595                         __set_errno (ECONNREFUSED);     /* no nameservers found */
 596                 else
 597                         __set_errno (ETIMEDOUT);        /* no answer obtained */
 598         } else
 599                 __set_errno (terrno);
 600         return (-1);
 601 }
 602
 603 int
 604 res_nsend(res_state statp,
 605           const u_char *buf, int buflen, u_char *ans, int anssiz)
 606 {
 607         return __libc_res_nsend(statp, buf, buflen, ans, anssiz, NULL);
 608 }
 609 libresolv_hidden_def (res_nsend)
 610
 611 /* Private */
 612
 613 static int
 614 send_vc(res_state statp,
 615         const u_char *buf, int buflen, u_char **ansp, int *anssizp,
 616         int *terrno, int ns, u_char **anscp)
 617 {
 618         const HEADER *hp = (HEADER *) buf;
 619         u_char *ans = *ansp;
 620         int anssiz = *anssizp;
 621         HEADER *anhp = (HEADER *) ans;
 622         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 623         int truncating, connreset, resplen, n;
 624         struct iovec iov[2];
 625         u_short len;
 626         u_char *cp;
 627
 628         connreset = 0;
 629  same_ns:
 630         truncating = 0;
 631
 632         /* Are we still talking to whom we want to talk to? */
 633         if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
 634                 struct sockaddr_in6 peer;
 635                 socklen_t size = sizeof peer;
 636
 637                 if (getpeername(statp->_vcsock,
 638                                 (struct sockaddr *)&peer, &size) < 0 ||
 639                     !sock_eq(&peer, nsap)) {
 640                         res_nclose(statp);
 641                         statp->_flags &= ~RES_F_VC;
 642                 }
 643         }
 644
 645         if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
 646                 if (statp->_vcsock >= 0)
 647                         res_nclose(statp);
 648
 649                 statp->_vcsock = socket(nsap->sin6_family, SOCK_STREAM, 0);
 650                 if (statp->_vcsock < 0) {
 651                         *terrno = errno;
 652                         Perror(statp, stderr, "socket(vc)", errno);
 653                         return (-1);
 654                 }
 655                 __set_errno (0);
 656                 if (connect(statp->_vcsock, (struct sockaddr *)nsap,
 657                             sizeof *nsap) < 0) {
 658                         *terrno = errno;
 659                         Aerror(statp, stderr, "connect/vc", errno,
 660                                (struct sockaddr *) nsap);
 661                         res_nclose(statp);
 662                         return (0);
 663                 }
 664                 statp->_flags |= RES_F_VC;
 665         }
 666
 667         /*
 668          * Send length & message
 669          */
 670         putshort((u_short)buflen, (u_char*)&len);
 671         evConsIovec(&len, INT16SZ, &iov[0]);
 672         evConsIovec((void*)buf, buflen, &iov[1]);
 673         if (TEMP_FAILURE_RETRY (writev(statp->_vcsock, iov, 2))
 674             != (INT16SZ + buflen)) {
 675                 *terrno = errno;
 676                 Perror(statp, stderr, "write failed", errno);
 677                 res_nclose(statp);
 678                 return (0);
 679         }
 680         /*
 681          * Receive length & response
 682          */
 683  read_len:
 684         cp = ans;
 685         len = INT16SZ;
 686         while ((n = TEMP_FAILURE_RETRY (read(statp->_vcsock, (char *)cp,
 687                                              (int)len))) > 0) {
 688                 cp += n;
 689                 if ((len -= n) <= 0)
 690                         break;
 691         }
 692         if (n <= 0) {
 693                 *terrno = errno;
 694                 Perror(statp, stderr, "read failed", errno);
 695                 res_nclose(statp);
 696                 /*
 697                  * A long running process might get its TCP
 698                  * connection reset if the remote server was
 699                  * restarted.  Requery the server instead of
 700                  * trying a new one.  When there is only one
 701                  * server, this means that a query might work
 702                  * instead of failing.  We only allow one reset
 703                  * per query to prevent looping.
 704                  */
 705                 if (*terrno == ECONNRESET && !connreset) {
 706                         connreset = 1;
 707                         res_nclose(statp);
 708                         goto same_ns;
 709                 }
 710                 res_nclose(statp);
 711                 return (0);
 712         }
 713         resplen = ns_get16(ans);
 714         if (resplen > anssiz) {
 715                 if (anscp) {
 716                         ans = malloc (MAXPACKET);
 717                         if (ans == NULL) {
 718                                 *terrno = ENOMEM;
 719                                 res_nclose(statp);
 720                                 return (0);
 721                         }
 722                         anssiz = MAXPACKET;
 723                         *anssizp = MAXPACKET;
 724                         *ansp = ans;
 725                         *anscp = ans;
 726                         anhp = (HEADER *) ans;
 727                         len = resplen;
 728                 } else {
 729                         Dprint(statp->options & RES_DEBUG,
 730                                 (stdout, ";; response truncated\n")
 731                         );
 732                         truncating = 1;
 733                         len = anssiz;
 734                 }
 735         } else
 736                 len = resplen;
 737         if (len < HFIXEDSZ) {
 738                 /*
 739                  * Undersized message.
 740                  */
 741                 Dprint(statp->options & RES_DEBUG,
 742                        (stdout, ";; undersized: %d\n", len));
 743                 *terrno = EMSGSIZE;
 744                 res_nclose(statp);
 745                 return (0);
 746         }
 747         cp = ans;
 748         while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
 749                 cp += n;
 750                 len -= n;
 751         }
 752         if (n <= 0) {
 753                 *terrno = errno;
 754                 Perror(statp, stderr, "read(vc)", errno);
 755                 res_nclose(statp);
 756                 return (0);
 757         }
 758         if (truncating) {
 759                 /*
 760                  * Flush rest of answer so connection stays in synch.
 761                  */
 762                 anhp->tc = 1;
 763                 len = resplen - anssiz;
 764                 while (len != 0) {
 765                         char junk[PACKETSZ];
 766
 767                         n = read(statp->_vcsock, junk,
 768                                  (len > sizeof junk) ? sizeof junk : len);
 769                         if (n > 0)
 770                                 len -= n;
 771                         else
 772                                 break;
 773                 }
 774         }
 775         /*
 776          * If the calling applicating has bailed out of
 777          * a previous call and failed to arrange to have
 778          * the circuit closed or the server has got
 779          * itself confused, then drop the packet and
 780          * wait for the correct one.
 781          */
 782         if (hp->id != anhp->id) {
 783                 DprintQ((statp->options & RES_DEBUG) ||
 784                         (statp->pfcode & RES_PRF_REPLY),
 785                         (stdout, ";; old answer (unexpected):\n"),
 786                         ans, (resplen > anssiz) ? anssiz: resplen);
 787                 goto read_len;
 788         }
 789
 790         /*
 791          * All is well, or the error is fatal.  Signal that the
 792          * next nameserver ought not be tried.
 793          */
 794         return (resplen);
 795 }
 796
 797 static int
 798 send_dg(res_state statp,
 799         const u_char *buf, int buflen, u_char **ansp, int *anssizp,
 800         int *terrno, int ns, int *v_circuit, int *gotsomewhere, u_char **anscp)
 801 {
 802         const HEADER *hp = (HEADER *) buf;
 803         u_char *ans = *ansp;
 804         int anssiz = *anssizp;
 805         HEADER *anhp = (HEADER *) ans;
 806         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
 807         struct timespec now, timeout, finish;
 808         struct pollfd pfd[1];
 809         int ptimeout;
 810         struct sockaddr_in6 from;
 811         static int socket_pf = 0;
 812         socklen_t fromlen;
 813         int resplen, seconds, n;
 814
 815         if (EXT(statp).nssocks[ns] == -1) {
 816                 /* only try IPv6 if IPv6 NS and if not failed before */
 817                 if ((EXT(statp).nscount6 > 0) && (socket_pf != PF_INET)) {
 818                         EXT(statp).nssocks[ns] =
 819                             socket(PF_INET6, SOCK_DGRAM, 0);
 820                         socket_pf = EXT(statp).nssocks[ns] < 0 ? PF_INET
 821                                                                : PF_INET6;
 822                 }
 823                 if (EXT(statp).nssocks[ns] < 0)
 824                         EXT(statp).nssocks[ns] = socket(PF_INET, SOCK_DGRAM, 0);
 825                 if (EXT(statp).nssocks[ns] < 0) {
 826                         *terrno = errno;
 827                         Perror(statp, stderr, "socket(dg)", errno);
 828                         return (-1);
 829                 }
 830                 /* If IPv6 socket and nsap is IPv4, make it IPv4-mapped */
 831                 if ((socket_pf == PF_INET6) && (nsap->sin6_family == AF_INET))
 832                         convaddr4to6(nsap);
 833                 /*
 834                  * On a 4.3BSD+ machine (client and server,
 835                  * actually), sending to a nameserver datagram
 836                  * port with no nameserver will cause an
 837                  * ICMP port unreachable message to be returned.
 838                  * If our datagram socket is "connected" to the
 839                  * server, we get an ECONNREFUSED error on the next
 840                  * socket operation, and select returns if the
 841                  * error message is received.  We can thus detect
 842                  * the absence of a nameserver without timing out.
 843                  */
 844                 if (connect(EXT(statp).nssocks[ns], (struct sockaddr *)nsap,
 845                             sizeof *nsap) < 0) {
 846                         Aerror(statp, stderr, "connect(dg)", errno,
 847                                (struct sockaddr *) nsap);
 848                         res_nclose(statp);
 849                         return (0);
 850                 }
 851                 /* Make socket non-blocking.  */
 852                 int fl = __fcntl (EXT(statp).nssocks[ns], F_GETFL);
 853                 if  (fl != -1)
 854                         __fcntl (EXT(statp).nssocks[ns], F_SETFL,
 855                                  fl | O_NONBLOCK);
 856                 Dprint(statp->options & RES_DEBUG,
 857                        (stdout, ";; new DG socket\n"))
 858         }
 859
 860         /*
 861          * Compute time for the total operation.
 862          */
 863         seconds = (statp->retrans << ns);
 864         if (ns > 0)
 865                 seconds /= statp->nscount;
 866         if (seconds <= 0)
 867                 seconds = 1;
 868         evNowTime(&now);
 869         evConsTime(&timeout, seconds, 0);
 870         evAddTime(&finish, &now, &timeout);
 871         int need_recompute = 0;
 872         int nwritten = 0;
 873         pfd[0].fd = EXT(statp).nssocks[ns];
 874         pfd[0].events = POLLOUT;
 875  wait:
 876         if (need_recompute) {
 877                 evNowTime(&now);
 878                 if (evCmpTime(finish, now) <= 0) {
 879                         Perror(statp, stderr, "select", errno);
 880                         res_nclose(statp);
 881                         return (0);
 882                 }
 883                 evSubTime(&timeout, &finish, &now);
 884         }
 885         /* Convert struct timespec in milliseconds.  */
 886         ptimeout = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
 887
 888         n = 0;
 889         if (nwritten == 0)
 890           n = __poll (pfd, 1, 0);
 891         if (__builtin_expect (n == 0, 0)) {
 892                 n = __poll (pfd, 1, ptimeout);
 893                 need_recompute = 1;
 894         }
 895         if (n == 0) {
 896                 Dprint(statp->options & RES_DEBUG, (stdout,
 897                                                     ";; timeout sending\n"));
 898                 *gotsomewhere = 1;
 899                 return (0);
 900         }
 901         if (n < 0) {
 902                 if (errno == EINTR) {
 903                 recompute_resend:
 904                         evNowTime(&now);
 905                         if (evCmpTime(finish, now) > 0) {
 906                                 evSubTime(&timeout, &finish, &now);
 907                                 goto wait;
 908                         }
 909                 }
 910                 Perror(statp, stderr, "poll", errno);
 911                 res_nclose(statp);
 912                 return (0);
 913         }
 914         __set_errno (0);
 915         if (pfd[0].revents & POLLOUT) {
 916                 if (send(pfd[0].fd, (char*)buf, buflen, 0) != buflen) {
 917                         if (errno == EINTR || errno == EAGAIN)
 918                                 goto recompute_resend;
 919                         Perror(statp, stderr, "send", errno);
 920                         res_nclose(statp);
 921                         return (0);
 922                 }
 923                 pfd[0].events = POLLIN;
 924                 ++nwritten;
 925                 goto wait;
 926         } else if (pfd[0].revents & POLLIN) {
 927                 fromlen = sizeof(struct sockaddr_in6);
 928                 if (anssiz < MAXPACKET
 929                     && anscp
 930                     && (ioctl (pfd[0].fd, FIONREAD, &resplen) < 0
 931                 || anssiz < resplen)) {
 932                         ans = malloc (MAXPACKET);
 933                         if (ans == NULL)
 934                                 ans = *ansp;
 935                         else {
 936                                 anssiz = MAXPACKET;
 937                                 *anssizp = MAXPACKET;
 938                                 *ansp = ans;
 939                                 *anscp = ans;
 940                                 anhp = (HEADER *) ans;
 941                         }
 942                 }
 943                 resplen = recvfrom(pfd[0].fd, (char*)ans, anssiz,0,
 944                                    (struct sockaddr *)&from, &fromlen);
 945                 if (resplen <= 0) {
 946                         if (errno == EINTR || errno == EAGAIN) {
 947                                 need_recompute = 1;
 948                                 goto wait;
 949                         }
 950                         Perror(statp, stderr, "recvfrom", errno);
 951                         res_nclose(statp);
 952                         return (0);
 953                 }
 954                 *gotsomewhere = 1;
 955                 if (resplen < HFIXEDSZ) {
 956                         /*
 957                          * Undersized message.
 958                          */
 959                         Dprint(statp->options & RES_DEBUG,
 960                                (stdout, ";; undersized: %d\n",
 961                                 resplen));
 962                         *terrno = EMSGSIZE;
 963                         res_nclose(statp);
 964                         return (0);
 965                 }
 966                 if (hp->id != anhp->id) {
 967                         /*
 968                          * response from old query, ignore it.
 969                          * XXX - potential security hazard could
 970                          *       be detected here.
 971                          */
 972                         DprintQ((statp->options & RES_DEBUG) ||
 973                                 (statp->pfcode & RES_PRF_REPLY),
 974                                 (stdout, ";; old answer:\n"),
 975                                 ans, (resplen > anssiz) ? anssiz : resplen);
 976                         goto wait;
 977                 }
 978                 if (!(statp->options & RES_INSECURE1) &&
 979                     !res_ourserver_p(statp, &from)) {
 980                         /*
 981                          * response from wrong server? ignore it.
 982                          * XXX - potential security hazard could
 983                          *       be detected here.
 984                          */
 985                         DprintQ((statp->options & RES_DEBUG) ||
 986                                 (statp->pfcode & RES_PRF_REPLY),
 987                                 (stdout, ";; not our server:\n"),
 988                                 ans, (resplen > anssiz) ? anssiz : resplen);
 989                         goto wait;
 990                 }
 991                 if (!(statp->options & RES_INSECURE2) &&
 992                     !res_queriesmatch(buf, buf + buflen,
 993                                       ans, ans + anssiz)) {
 994                         /*
 995                          * response contains wrong query? ignore it.
 996                          * XXX - potential security hazard could
 997                          *       be detected here.
 998                          */
 999                         DprintQ((statp->options & RES_DEBUG) ||
1000                                 (statp->pfcode & RES_PRF_REPLY),
1001                                 (stdout, ";; wrong query name:\n"),
1002                                 ans, (resplen > anssiz) ? anssiz : resplen);
1003                         goto wait;
1004                 }
1005                 if (anhp->rcode == SERVFAIL ||
1006                     anhp->rcode == NOTIMP ||
1007                     anhp->rcode == REFUSED) {
1008                         DprintQ(statp->options & RES_DEBUG,
1009                                 (stdout, "server rejected query:\n"),
1010                                 ans, (resplen > anssiz) ? anssiz : resplen);
1011                         res_nclose(statp);
1012                         /* don't retry if called from dig */
1013                         if (!statp->pfcode)
1014                                 return (0);
1015                 }
1016                 if (!(statp->options & RES_IGNTC) && anhp->tc) {
1017                         /*
1018                          * To get the rest of answer,
1019                          * use TCP with same server.
1020                          */
1021                         Dprint(statp->options & RES_DEBUG,
1022                                (stdout, ";; truncated answer\n"));
1023                         *v_circuit = 1;
1024                         res_nclose(statp);
1025                         return (1);
1026                 }
1027                 /*
1028                  * All is well, or the error is fatal.  Signal that the
1029                  * next nameserver ought not be tried.
1030                  */
1031                 return (resplen);
1032         } else if (pfd[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
1033                 /* Something went wrong.  We can stop trying.  */
1034                 res_nclose(statp);
1035                 return (0);
1036         }
1037         else {
1038                 /* poll should not have returned > 0 in this case.  */
1039                 abort ();
1040         }
1041 }
1042
1043 #ifdef DEBUG
1044 static void
1045 Aerror(const res_state statp, FILE *file, const char *string, int error,
1046        const struct sockaddr *address)
1047 {
1048         int save = errno;
1049
1050         if ((statp->options & RES_DEBUG) != 0) {
1051                 char tmp[sizeof "xxxx.xxxx.xxxx.255.255.255.255"];
1052
1053                 fprintf(file, "res_send: %s ([%s].%u): %s\n",
1054                         string,
1055                         inet_ntop(address->sa_family, address->sa_data,
1056                                   tmp, sizeof tmp),
1057                         (address->sa_family == AF_INET
1058                          ? ntohs(((struct sockaddr_in *) address)->sin_port)
1059                          : address->sa_family == AF_INET6
1060                          ? ntohs(((struct sockaddr_in6 *) address)->sin6_port)
1061                          : 0),
1062                         strerror(error));
1063         }
1064         __set_errno (save);
1065 }
1066
1067 static void
1068 Perror(const res_state statp, FILE *file, const char *string, int error) {
1069         int save = errno;
1070
1071         if ((statp->options & RES_DEBUG) != 0)
1072                 fprintf(file, "res_send: %s: %s\n",
1073                         string, strerror(error));
1074         __set_errno (save);
1075 }
1076 #endif
1077
1078 static int
1079 sock_eq(struct sockaddr_in6 *a1, struct sockaddr_in6 *a2) {
1080         if (a1->sin6_family == a2->sin6_family) {
1081                 if (a1->sin6_family == AF_INET)
1082                         return ((((struct sockaddr_in *)a1)->sin_port ==
1083                                  ((struct sockaddr_in *)a2)->sin_port) &&
1084                                 (((struct sockaddr_in *)a1)->sin_addr.s_addr ==
1085                                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1086                 else
1087                         return ((a1->sin6_port == a2->sin6_port) &&
1088                                 !memcmp(&a1->sin6_addr, &a2->sin6_addr,
1089                                         sizeof (struct in6_addr)));
1090         }
1091         if (a1->sin6_family == AF_INET) {
1092                 struct sockaddr_in6 *sap = a1;
1093                 a1 = a2;
1094                 a2 = sap;
1095         } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1096         return ((a1->sin6_port == ((struct sockaddr_in *)a2)->sin_port) &&
1097                 IN6_IS_ADDR_V4MAPPED(&a1->sin6_addr) &&
1098                 (a1->sin6_addr.s6_addr32[3] ==
1099                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1100 }
1101
1102 /*
1103  * Converts IPv4 family, address and port to
1104  * IPv6 family, IPv4-mapped IPv6 address and port.
1105  */
1106 static void
1107 convaddr4to6(struct sockaddr_in6 *sa)
1108 {
1109     struct sockaddr_in *sa4p = (struct sockaddr_in *) sa;
1110     in_port_t port = sa4p->sin_port;
1111     in_addr_t addr = sa4p->sin_addr.s_addr;
1112
1113     sa->sin6_family = AF_INET6;
1114     sa->sin6_port = port;
1115     sa->sin6_addr.s6_addr32[0] = 0;
1116     sa->sin6_addr.s6_addr32[1] = 0;
1117     sa->sin6_addr.s6_addr32[2] = htonl(0xFFFF);
1118     sa->sin6_addr.s6_addr32[3] = addr;
1119 }