usr/src/lib/libresolv/res_send.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 #pragma ident   "%Z%%M% %I%     %E% SMI"
  41
  42 /*
  43  * Send query to name server and wait for reply.
  44  */
  45
  46 #include <sys/param.h>
  47 #include <sys/time.h>
  48 #include <sys/socket.h>
  49 #include <sys/uio.h>
  50 #include <sys/stat.h>
  51 #include <netinet/in.h>
  52 #include <stdio.h>
  53 #include <errno.h>
  54 #include <arpa/nameser.h>
  55 #include <resolv.h>
  56
  57
  58 static int s = -1;      /* socket used for communications */
  59 static struct sockaddr no_addr;
  60
  61
  62 #ifndef FD_SET
  63 #define NFDBITS         32
  64 #define FD_SETSIZE      32
  65 #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
  66 #define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
  67 #define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
  68 #ifdef SYSV
  69 #define FD_ZERO(p)      memset((void *)(p), 0, sizeof (*(p)))
  70 #else
  71 #define FD_ZERO(p)      bzero((char *)(p), sizeof (*(p)))
  72 #endif
  73 #endif
  74
  75 /*
  76  * 1247019: Kludge to time out quickly if there is no /etc/resolv.conf
  77  * and a TCP connection to the local DNS server fails.
  78  */
  79
  80 static int _confcheck()
  81 {
  82         int ns;
  83         struct stat rc_stat;
  84         struct sockaddr_in ns_sin;
  85
  86
  87         /* First, we check to see if /etc/resolv.conf exists.
  88          * If it doesn't, then localhost is mostlikely to be
  89          * the nameserver.
  90          */
  91         if (stat(_PATH_RESCONF, &rc_stat) == -1 && errno == ENOENT) {
  92
  93                 /* Next, we check to see if _res.nsaddr is set to loopback.
  94                  * If it isn't, it has been altered by the application
  95                  * explicitly and we then want to bail with success.
  96                  */
  97                 if (_res.nsaddr.sin_addr.S_un.S_addr == htonl(INADDR_LOOPBACK)) {
  98
  99                         /* Lastly, we try to connect to the TCP port of the
 100                          * nameserver.  If this fails, then we know that
 101                          * DNS is misconfigured and we can quickly exit.
 102                          */
 103                         ns = socket(AF_INET, SOCK_STREAM, 0);
 104                         IN_SET_LOOPBACK_ADDR(&ns_sin);
 105                         ns_sin.sin_port = htons(NAMESERVER_PORT);
 106                         if (connect(ns, (struct sockaddr *) &ns_sin,
 107                                     sizeof ns_sin) == -1) {
 108                                 close(ns);
 109                                 return(-1);
 110                         }
 111                         else {
 112                                 close(ns);
 113                                 return(0);
 114                         }
 115                 }
 116
 117                 return(0);
 118         }
 119
 120         return (0);
 121 }
 122
 123 int
 124 res_send(buf, buflen, answer, anslen)
 125         char *buf;
 126         int buflen;
 127         char *answer;
 128         int anslen;
 129 {
 130         register int n;
 131         int try, v_circuit, resplen, ns;
 132         int gotsomewhere = 0, connected = 0;
 133         int connreset = 0;
 134         u_short id, len;
 135         char *cp;
 136         fd_set dsmask;
 137         struct timeval timeout;
 138         HEADER *hp = (HEADER *) buf;
 139         HEADER *anhp = (HEADER *) answer;
 140         struct iovec iov[2];
 141         int terrno = ETIMEDOUT;
 142         char junk[512];
 143
 144 #ifdef DEBUG
 145         if (_res.options & RES_DEBUG) {
 146                 printf("res_send()\n");
 147                 p_query(buf);
 148         }
 149 #endif
 150         if (!(_res.options & RES_INIT))
 151                 if (res_init() == -1) {
 152                         return (-1);
 153                 }
 154
 155         /* 1247019: Check to see if we can bailout quickly. */
 156         if (_confcheck() == -1)
 157             return(-1);
 158
 159         v_circuit = (_res.options & RES_USEVC) || buflen > PACKETSZ;
 160         id = hp->id;
 161         /*
 162          * Send request, RETRY times, or until successful
 163          */
 164         for (try = 0; try < _res.retry; try++) {
 165                 for (ns = 0; ns < _res.nscount; ns++) {
 166 #ifdef DEBUG
 167                         if (_res.options & RES_DEBUG)
 168                                 printf("Querying server (# %d) address = %s\n",
 169                                 ns+1, inet_ntoa(_res.nsaddr_list[ns].sin_addr));
 170 #endif
 171                 usevc:
 172                         if (v_circuit) {
 173                                 int truncated = 0;
 174
 175                                 /*
 176                                  * Use virtual circuit;
 177                                  * at most one attempt per server.
 178                                  */
 179                                 try = _res.retry;
 180                                 if (s < 0) {
 181                                         s = _socket(AF_INET, SOCK_STREAM, 0);
 182                                         if (s < 0) {
 183                                                 terrno = errno;
 184 #ifdef DEBUG
 185                                                 if (_res.options & RES_DEBUG) {
 186                                                 perror("socket (vc) failed");
 187                                                 }
 188 #endif
 189                                                 continue;
 190                                         }
 191                                         if (connect(s, (struct sockaddr *) &_res.nsaddr_list[ns],
 192                                                 sizeof (struct sockaddr)) < 0) {
 193                                                 terrno = errno;
 194 #ifdef DEBUG
 195                                                 if (_res.options & RES_DEBUG) {
 196                                                 perror("connect failed");
 197                                                 }
 198 #endif
 199                                                 (void) close(s);
 200                                                 s = -1;
 201                                                 continue;
 202                                         }
 203                                 }
 204                                 /*
 205                                  * Send length & message
 206                                  */
 207                                 len = htons((u_short)buflen);
 208                                 iov[0].iov_base = (caddr_t)&len;
 209                                 iov[0].iov_len = sizeof (len);
 210                                 iov[1].iov_base = buf;
 211                                 iov[1].iov_len = buflen;
 212                                 if (writev(s, iov, 2) != sizeof (len) +
 213                                                                 buflen) {
 214                                         terrno = errno;
 215 #ifdef DEBUG
 216                                         if (_res.options & RES_DEBUG)
 217                                                 perror("write failed");
 218 #endif
 219                                         (void) close(s);
 220                                         s = -1;
 221                                         continue;
 222                                 }
 223                                 /*
 224                                  * Receive length & response
 225                                  */
 226                                 cp = answer;
 227                                 len = sizeof (short);
 228                                 while (len != 0 && (n = read
 229                                         (s, (char *)cp, (int)len)) > 0) {
 230                                         cp += n;
 231                                         len -= n;
 232                                 }
 233                                 if (n <= 0) {
 234                                         terrno = errno;
 235 #ifdef DEBUG
 236                                         if (_res.options & RES_DEBUG)
 237                                                 perror("read failed");
 238 #endif
 239                                         (void) close(s);
 240                                         s = -1;
 241                                 /*
 242                                  * A long running process might get its TCP
 243                                  * connection reset if the remote server was
 244                                  * restarted.  Requery the server instead of
 245                                  * trying a new one.  When there is only one
 246                                  * server, this means that a query might work
 247                                  * instead of failing.  We only allow one reset
 248                                  * per query to prevent looping.
 249                                  */
 250                                         if (terrno == ECONNRESET &&
 251                                                         !connreset) {
 252                                                 connreset = 1;
 253                                                 ns--;
 254                                         }
 255                                         continue;
 256                                 }
 257                                 cp = answer;
 258                                 if ((resplen = ntohs(*(u_short *)cp)) >
 259                                                                 anslen) {
 260 #ifdef DEBUG
 261                                         if (_res.options & RES_DEBUG)
 262                                                 fprintf(stderr,
 263                                                         "response truncated\n");
 264 #endif
 265                                         len = anslen;
 266                                         truncated = 1;
 267                                 } else
 268                                         len = resplen;
 269                                 while (len != 0 &&
 270                                         (n = read(s, (char *)cp,
 271                                                         (int)len)) > 0) {
 272                                         cp += n;
 273                                         len -= n;
 274                                 }
 275                                 if (n <= 0) {
 276                                         terrno = errno;
 277 #ifdef DEBUG
 278                                         if (_res.options & RES_DEBUG)
 279                                                 perror("read failed");
 280 #endif
 281                                         (void) close(s);
 282                                         s = -1;
 283                                         continue;
 284                                 }
 285                                 if (truncated) {
 286                                         /*
 287                                          * Flush rest of answer
 288                                          * so connection stays in synch.
 289                                          */
 290                                         anhp->tc = 1;
 291                                         len = resplen - anslen;
 292                                         /*
 293                                          * set the value of resplen to anslen,
 294                                          * this is done because the caller
 295                                          * assumes resplen contains the size of
 296                                          * message read into the "answer" buffer
 297                                          * passed in.
 298                                          */
 299                                         resplen = anslen;
 300
 301                                         while (len != 0) {
 302                                                 n = (len > sizeof (junk) ?
 303                                                         sizeof (junk) : len);
 304                                                 if ((n = read(s, junk, n)) > 0)
 305                                                         len -= n;
 306                                                 else
 307                                                         break;
 308                                         }
 309                                 }
 310                         } else {
 311                                 /*
 312                                  * Use datagrams.
 313                                  */
 314                                 if (s < 0) {
 315                                         s = _socket(AF_INET, SOCK_DGRAM, 0);
 316                                         if (s < 0) {
 317                                                 terrno = errno;
 318 #ifdef DEBUG
 319                                                 if (_res.options & RES_DEBUG) {
 320                                                 perror("socket (dg) failed");
 321                                                 }
 322 #endif
 323                                                 continue;
 324                                         }
 325                                 }
 326 #if     BSD >= 43
 327                         /*
 328                          * I'm tired of answering this question, so:
 329                          * On a 4.3BSD+ machine (client and server,
 330                          * actually), sending to a nameserver datagram
 331                          * port with no nameserver will cause an
 332                          * ICMP port unreachable message to be returned.
 333                          * If our datagram socket is "connected" to the
 334                          * server, we get an ECONNREFUSED error on the next
 335                          * socket operation, and select returns if the
 336                          * error message is received.  We can thus detect
 337                          * the absence of a nameserver without timing out.
 338                          * If we have sent queries to at least two servers,
 339                          * however, we don't want to remain connected,
 340                          * as we wish to receive answers from the first
 341                          * server to respond.
 342                          */
 343                                 if (_res.nscount == 1 ||
 344                                                 (try == 0 && ns == 0)) {
 345                                         /*
 346                                          * Don't use connect if we might
 347                                          * still receive a response
 348                                          * from another server.
 349                                          */
 350                                         if (connected == 0) {
 351                                                 if (connect(s,
 352                                                 (struct sockaddr *) &_res.nsaddr_list[ns],
 353                                                 sizeof (struct sockaddr)) < 0) {
 354 #ifdef DEBUG
 355                                                         if (_res.options &
 356                                                                 RES_DEBUG) {
 357                                                         perror("connect");
 358                                                         }
 359 #endif
 360                                                         continue;
 361                                                 }
 362                                                 connected = 1;
 363                                         }
 364                                         if (send(s, buf, buflen, 0) != buflen) {
 365 #ifdef DEBUG
 366                                                 if (_res.options & RES_DEBUG)
 367                                                         perror("send");
 368 #endif
 369                                                 continue;
 370                                         }
 371                                 } else {
 372                                         /*
 373                                          * Disconnect if we want to listen for
 374                                          * responses from more than one server.
 375                                          */
 376                                         if (connected) {
 377                                                 (void) connect(s, &no_addr,
 378                                                         sizeof (no_addr));
 379                                                 connected = 0;
 380                                         }
 381 #endif /* BSD */
 382                                         if (sendto(s, buf, buflen, 0,
 383                                                 (struct sockaddr *) &_res.nsaddr_list[ns],
 384                                         sizeof (struct sockaddr)) != buflen) {
 385 #ifdef DEBUG
 386                                                 if (_res.options & RES_DEBUG)
 387                                                         perror("sendto");
 388 #endif
 389                                                 continue;
 390                                         }
 391 #if     BSD >= 43
 392                                 }
 393 #endif
 394
 395                                 /*
 396                                  * Wait for reply
 397                                  */
 398                                 timeout.tv_sec = (_res.retrans << try);
 399                                 if (try > 0)
 400                                         timeout.tv_sec /= _res.nscount;
 401                                 if (timeout.tv_sec <= 0)
 402                                         timeout.tv_sec = 1;
 403                                 timeout.tv_usec = 0;
 404 wait:
 405                                 FD_ZERO(&dsmask);
 406                                 FD_SET(s, &dsmask);
 407                                 n = select(s+1, &dsmask, (fd_set *)NULL,
 408                                                 (fd_set *)NULL, &timeout);
 409                                 if (n < 0) {
 410 #ifdef DEBUG
 411                                         if (_res.options & RES_DEBUG)
 412                                                 perror("select");
 413 #endif
 414                                         continue;
 415                                 }
 416                                 if (n == 0) {
 417                                         /*
 418                                          * timeout
 419                                          */
 420 #ifdef DEBUG
 421                                         if (_res.options & RES_DEBUG)
 422                                                 printf("timeout\n");
 423 #endif
 424 #if BSD >= 43
 425                                         gotsomewhere = 1;
 426 #endif
 427                                         continue;
 428                                 }
 429                                 if ((resplen = recv(s, answer, anslen, 0))
 430                                                                         <= 0) {
 431 #ifdef DEBUG
 432                                         if (_res.options & RES_DEBUG)
 433                                                 perror("recvfrom");
 434 #endif
 435                                         continue;
 436                                 }
 437                                 gotsomewhere = 1;
 438                                 if (id != anhp->id) {
 439                                         /*
 440                                          * response from old query, ignore it
 441                                          */
 442 #ifdef DEBUG
 443                                         if (_res.options & RES_DEBUG) {
 444                                                 printf("old answer:\n");
 445                                                 p_query(answer);
 446                                         }
 447 #endif
 448                                         goto wait;
 449                                 }
 450                                 if (!(_res.options & RES_IGNTC) && anhp->tc) {
 451                                         /*
 452                                          * get rest of answer;
 453                                          * use TCP with same server.
 454                                          */
 455 #ifdef DEBUG
 456                                         if (_res.options & RES_DEBUG)
 457                                                 printf("truncated answer\n");
 458 #endif
 459                                         (void) close(s);
 460                                         s = -1;
 461                                         v_circuit = 1;
 462                                         goto usevc;
 463                                 }
 464                         }
 465 #ifdef DEBUG
 466                         if (_res.options & RES_DEBUG) {
 467                                 printf("got answer:\n");
 468                                 p_query(answer);
 469                         }
 470 #endif
 471                 /*
 472                  * If using virtual circuits, we assume that the first server
 473                  * is preferred * over the rest (i.e. it is on the local
 474                  * machine) and only keep that one open.
 475                  * If we have temporarily opened a virtual circuit,
 476                  * or if we haven't been asked to keep a socket open,
 477                  * close the socket.
 478                  */
 479                         if ((v_circuit &&
 480                                 ((_res.options & RES_USEVC) == 0 || ns != 0)) ||
 481                                 (_res.options & RES_STAYOPEN) == 0) {
 482                                 (void) close(s);
 483                                 s = -1;
 484                         }
 485                         return (resplen);
 486                 }
 487         }
 488         if (s >= 0) {
 489                 (void) close(s);
 490                 s = -1;
 491         }
 492         if (v_circuit == 0)
 493                 if (gotsomewhere == 0)
 494                         errno = ECONNREFUSED;   /* no nameservers found */
 495                 else
 496                         errno = ETIMEDOUT;      /* no answer obtained */
 497         else
 498                 errno = terrno;
 499         return (-1);
 500 }
 501
 502 /*
 503  * This routine is for closing the socket if a virtual circuit is used and
 504  * the program wants to close it.  This provides support for endhostent()
 505  * which expects to close the socket.
 506  *
 507  * This routine is not expected to be user visible.
 508  */
 509 void
 510 _res_close()
 511 {
 512         if (s != -1) {
 513                 (void) close(s);
 514                 s = -1;
 515         }
 516 }