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