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