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