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