sjero.net Git - wget/blob - src/connect.c

   1 /* Establishing and handling network connections.
   2    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Wget.
   6
   7 GNU Wget is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or
  10  (at your option) any later version.
  11
  12 GNU Wget is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 Additional permission under GNU GPL version 3 section 7
  21
  22 If you modify this program, or any covered work, by linking or
  23 combining it with the OpenSSL project's OpenSSL library (or a
  24 modified version of that library), containing parts covered by the
  25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  26 grants you additional permission to convey the resulting work.
  27 Corresponding Source for a non-source form of such a combination
  28 shall include the source code for the parts of OpenSSL used as well
  29 as that of the covered work.  */
  30
  31 #include <config.h>
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif
  38 #include <assert.h>
  39
  40 #ifndef WINDOWS
  41 # include <sys/socket.h>
  42 # include <netdb.h>
  43 # include <netinet/in.h>
  44 # ifndef __BEOS__
  45 #  include <arpa/inet.h>
  46 # endif
  47 #endif /* not WINDOWS */
  48
  49 #include <errno.h>
  50 #include <string.h>
  51 #ifdef HAVE_SYS_SELECT_H
  52 # include <sys/select.h>
  53 #endif /* HAVE_SYS_SELECT_H */
  54
  55 #include "wget.h"
  56 #include "utils.h"
  57 #include "host.h"
  58 #include "connect.h"
  59 #include "hash.h"
  60
  61 /* Define sockaddr_storage where unavailable (presumably on IPv4-only
  62    hosts).  */
  63
  64 #ifndef ENABLE_IPV6
  65 # ifndef HAVE_STRUCT_SOCKADDR_STORAGE
  66 #  define sockaddr_storage sockaddr_in
  67 # endif
  68 #endif /* ENABLE_IPV6 */
  69
  70 /* Fill SA as per the data in IP and PORT.  SA shoult point to struct
  71    sockaddr_storage if ENABLE_IPV6 is defined, to struct sockaddr_in
  72    otherwise.  */
  73
  74 static void
  75 sockaddr_set_data (struct sockaddr *sa, const ip_address *ip, int port)
  76 {
  77   switch (ip->family)
  78     {
  79     case AF_INET:
  80       {
  81         struct sockaddr_in *sin = (struct sockaddr_in *)sa;
  82         xzero (*sin);
  83         sin->sin_family = AF_INET;
  84         sin->sin_port = htons (port);
  85         sin->sin_addr = ip->data.d4;
  86         break;
  87       }
  88 #ifdef ENABLE_IPV6
  89     case AF_INET6:
  90       {
  91         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
  92         xzero (*sin6);
  93         sin6->sin6_family = AF_INET6;
  94         sin6->sin6_port = htons (port);
  95         sin6->sin6_addr = ip->data.d6;
  96 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
  97         sin6->sin6_scope_id = ip->ipv6_scope;
  98 #endif
  99         break;
 100       }
 101 #endif /* ENABLE_IPV6 */
 102     default:
 103       abort ();
 104     }
 105 }
 106
 107 /* Get the data of SA, specifically the IP address and the port.  If
 108    you're not interested in one or the other information, pass NULL as
 109    the pointer.  */
 110
 111 static void
 112 sockaddr_get_data (const struct sockaddr *sa, ip_address *ip, int *port)
 113 {
 114   switch (sa->sa_family)
 115     {
 116     case AF_INET:
 117       {
 118         struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 119         if (ip)
 120           {
 121             ip->family = AF_INET;
 122             ip->data.d4 = sin->sin_addr;
 123           }
 124         if (port)
 125           *port = ntohs (sin->sin_port);
 126         break;
 127       }
 128 #ifdef ENABLE_IPV6
 129     case AF_INET6:
 130       {
 131         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 132         if (ip)
 133           {
 134             ip->family = AF_INET6;
 135             ip->data.d6 = sin6->sin6_addr;
 136 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 137             ip->ipv6_scope = sin6->sin6_scope_id;
 138 #endif
 139           }
 140         if (port)
 141           *port = ntohs (sin6->sin6_port);
 142         break;
 143       }
 144 #endif
 145     default:
 146       abort ();
 147     }
 148 }
 149
 150 /* Return the size of the sockaddr structure depending on its
 151    family.  */
 152
 153 static socklen_t
 154 sockaddr_size (const struct sockaddr *sa)
 155 {
 156   switch (sa->sa_family)
 157     {
 158     case AF_INET:
 159       return sizeof (struct sockaddr_in);
 160 #ifdef ENABLE_IPV6
 161     case AF_INET6:
 162       return sizeof (struct sockaddr_in6);
 163 #endif
 164     default:
 165       abort ();
 166     }
 167 }
 168 \f
 169 /* Resolve the bind address specified via --bind-address and store it
 170    to SA.  The resolved value is stored in a static variable and
 171    reused after the first invocation of this function.
 172
 173    Returns true on success, false on failure.  */
 174
 175 static bool
 176 resolve_bind_address (struct sockaddr *sa)
 177 {
 178   struct address_list *al;
 179
 180   /* Make sure this is called only once.  opt.bind_address doesn't
 181      change during a Wget run.  */
 182   static bool called, should_bind;
 183   static ip_address ip;
 184   if (called)
 185     {
 186       if (should_bind)
 187         sockaddr_set_data (sa, &ip, 0);
 188       return should_bind;
 189     }
 190   called = true;
 191
 192   al = lookup_host (opt.bind_address, LH_BIND | LH_SILENT);
 193   if (!al)
 194     {
 195       /* #### We should be able to print the error message here. */
 196       logprintf (LOG_NOTQUIET,
 197                  _("%s: unable to resolve bind address `%s'; disabling bind.\n"),
 198                  exec_name, opt.bind_address);
 199       should_bind = false;
 200       return false;
 201     }
 202
 203   /* Pick the first address in the list and use it as bind address.
 204      Perhaps we should try multiple addresses in succession, but I
 205      don't think that's necessary in practice.  */
 206   ip = *address_list_address_at (al, 0);
 207   address_list_release (al);
 208
 209   sockaddr_set_data (sa, &ip, 0);
 210   should_bind = true;
 211   return true;
 212 }
 213 \f
 214 struct cwt_context {
 215   int fd;
 216   const struct sockaddr *addr;
 217   socklen_t addrlen;
 218   int result;
 219 };
 220
 221 static void
 222 connect_with_timeout_callback (void *arg)
 223 {
 224   struct cwt_context *ctx = (struct cwt_context *)arg;
 225   ctx->result = connect (ctx->fd, ctx->addr, ctx->addrlen);
 226 }
 227
 228 /* Like connect, but specifies a timeout.  If connecting takes longer
 229    than TIMEOUT seconds, -1 is returned and errno is set to
 230    ETIMEDOUT.  */
 231
 232 static int
 233 connect_with_timeout (int fd, const struct sockaddr *addr, socklen_t addrlen,
 234                       double timeout)
 235 {
 236   struct cwt_context ctx;
 237   ctx.fd = fd;
 238   ctx.addr = addr;
 239   ctx.addrlen = addrlen;
 240
 241   if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
 242     {
 243       errno = ETIMEDOUT;
 244       return -1;
 245     }
 246   if (ctx.result == -1 && errno == EINTR)
 247     errno = ETIMEDOUT;
 248   return ctx.result;
 249 }
 250 \f
 251 /* Connect via TCP to the specified address and port.
 252
 253    If PRINT is non-NULL, it is the host name to print that we're
 254    connecting to.  */
 255
 256 int
 257 connect_to_ip (const ip_address *ip, int port, const char *print)
 258 {
 259   struct sockaddr_storage ss;
 260   struct sockaddr *sa = (struct sockaddr *)&ss;
 261   int sock;
 262
 263   /* If PRINT is non-NULL, print the "Connecting to..." line, with
 264      PRINT being the host name we're connecting to.  */
 265   if (print)
 266     {
 267       const char *txt_addr = print_address (ip);
 268       if (print && 0 != strcmp (print, txt_addr))
 269         logprintf (LOG_VERBOSE, _("Connecting to %s|%s|:%d... "),
 270                    escnonprint (print), txt_addr, port);
 271       else
 272         logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port);
 273     }
 274
 275   /* Store the sockaddr info to SA.  */
 276   sockaddr_set_data (sa, ip, port);
 277
 278   /* Create the socket of the family appropriate for the address.  */
 279   sock = socket (sa->sa_family, SOCK_STREAM, 0);
 280   if (sock < 0)
 281     goto err;
 282
 283 #if defined(ENABLE_IPV6) && defined(IPV6_V6ONLY)
 284   if (opt.ipv6_only) {
 285     int on = 1;
 286     /* In case of error, we will go on anyway... */
 287     int err = setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on));
 288     IF_DEBUG
 289       if (err < 0)
 290         DEBUGP (("Failed setting IPV6_V6ONLY: %s", strerror (errno)));
 291   }
 292 #endif
 293
 294   /* For very small rate limits, set the buffer size (and hence,
 295      hopefully, the kernel's TCP window size) to the per-second limit.
 296      That way we should never have to sleep for more than 1s between
 297      network reads.  */
 298   if (opt.limit_rate && opt.limit_rate < 8192)
 299     {
 300       int bufsize = opt.limit_rate;
 301       if (bufsize < 512)
 302         bufsize = 512;          /* avoid pathologically small values */
 303 #ifdef SO_RCVBUF
 304       setsockopt (sock, SOL_SOCKET, SO_RCVBUF,
 305                   (void *)&bufsize, (socklen_t)sizeof (bufsize));
 306 #endif
 307       /* When we add limit_rate support for writing, which is useful
 308          for POST, we should also set SO_SNDBUF here.  */
 309     }
 310
 311   if (opt.bind_address)
 312     {
 313       /* Bind the client side of the socket to the requested
 314          address.  */
 315       struct sockaddr_storage bind_ss;
 316       struct sockaddr *bind_sa = (struct sockaddr *)&bind_ss;
 317       if (resolve_bind_address (bind_sa))
 318         {
 319           if (bind (sock, bind_sa, sockaddr_size (bind_sa)) < 0)
 320             goto err;
 321         }
 322     }
 323
 324   /* Connect the socket to the remote endpoint.  */
 325   if (connect_with_timeout (sock, sa, sockaddr_size (sa),
 326                             opt.connect_timeout) < 0)
 327     goto err;
 328
 329   /* Success. */
 330   assert (sock >= 0);
 331   if (print)
 332     logprintf (LOG_VERBOSE, _("connected.\n"));
 333   DEBUGP (("Created socket %d.\n", sock));
 334   return sock;
 335
 336  err:
 337   {
 338     /* Protect errno from possible modifications by close and
 339        logprintf.  */
 340     int save_errno = errno;
 341     if (sock >= 0)
 342       fd_close (sock);
 343     if (print)
 344       logprintf (LOG_VERBOSE, _("failed: %s.\n"), strerror (errno));
 345     errno = save_errno;
 346     return -1;
 347   }
 348 }
 349
 350 /* Connect via TCP to a remote host on the specified port.
 351
 352    HOST is resolved as an Internet host name.  If HOST resolves to
 353    more than one IP address, they are tried in the order returned by
 354    DNS until connecting to one of them succeeds.  */
 355
 356 int
 357 connect_to_host (const char *host, int port)
 358 {
 359   int i, start, end;
 360   int sock;
 361
 362   struct address_list *al = lookup_host (host, 0);
 363
 364  retry:
 365   if (!al)
 366     {
 367       logprintf (LOG_NOTQUIET,
 368                  _("%s: unable to resolve host address `%s'\n"),
 369                  exec_name, host);
 370       return E_HOST;
 371     }
 372
 373   address_list_get_bounds (al, &start, &end);
 374   for (i = start; i < end; i++)
 375     {
 376       const ip_address *ip = address_list_address_at (al, i);
 377       sock = connect_to_ip (ip, port, host);
 378       if (sock >= 0)
 379         {
 380           /* Success. */
 381           address_list_set_connected (al);
 382           address_list_release (al);
 383           return sock;
 384         }
 385
 386       /* The attempt to connect has failed.  Continue with the loop
 387          and try next address. */
 388
 389       address_list_set_faulty (al, i);
 390     }
 391
 392   /* Failed to connect to any of the addresses in AL. */
 393
 394   if (address_list_connected_p (al))
 395     {
 396       /* We connected to AL before, but cannot do so now.  That might
 397          indicate that our DNS cache entry for HOST has expired.  */
 398       address_list_release (al);
 399       al = lookup_host (host, LH_REFRESH);
 400       goto retry;
 401     }
 402   address_list_release (al);
 403
 404   return -1;
 405 }
 406 \f
 407 /* Create a socket, bind it to local interface BIND_ADDRESS on port
 408    *PORT, set up a listen backlog, and return the resulting socket, or
 409    -1 in case of error.
 410
 411    BIND_ADDRESS is the address of the interface to bind to.  If it is
 412    NULL, the socket is bound to the default address.  PORT should
 413    point to the port number that will be used for the binding.  If
 414    that number is 0, the system will choose a suitable port, and the
 415    chosen value will be written to *PORT.
 416
 417    Calling accept() on such a socket waits for and accepts incoming
 418    TCP connections.  */
 419
 420 int
 421 bind_local (const ip_address *bind_address, int *port)
 422 {
 423   int sock;
 424   struct sockaddr_storage ss;
 425   struct sockaddr *sa = (struct sockaddr *)&ss;
 426
 427   /* For setting options with setsockopt. */
 428   int setopt_val = 1;
 429   void *setopt_ptr = (void *)&setopt_val;
 430   socklen_t setopt_size = sizeof (setopt_val);
 431
 432   sock = socket (bind_address->family, SOCK_STREAM, 0);
 433   if (sock < 0)
 434     return -1;
 435
 436 #ifdef SO_REUSEADDR
 437   setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, setopt_ptr, setopt_size);
 438 #endif
 439
 440   xzero (ss);
 441   sockaddr_set_data (sa, bind_address, *port);
 442   if (bind (sock, sa, sockaddr_size (sa)) < 0)
 443     {
 444       fd_close (sock);
 445       return -1;
 446     }
 447   DEBUGP (("Local socket fd %d bound.\n", sock));
 448
 449   /* If *PORT is 0, find out which port we've bound to.  */
 450   if (*port == 0)
 451     {
 452       socklen_t addrlen = sockaddr_size (sa);
 453       if (getsockname (sock, sa, &addrlen) < 0)
 454         {
 455           /* If we can't find out the socket's local address ("name"),
 456              something is seriously wrong with the socket, and it's
 457              unusable for us anyway because we must know the chosen
 458              port.  */
 459           fd_close (sock);
 460           return -1;
 461         }
 462       sockaddr_get_data (sa, NULL, port);
 463       DEBUGP (("binding to address %s using port %i.\n",
 464                print_address (bind_address), *port));
 465     }
 466   if (listen (sock, 1) < 0)
 467     {
 468       fd_close (sock);
 469       return -1;
 470     }
 471   return sock;
 472 }
 473
 474 /* Like a call to accept(), but with the added check for timeout.
 475
 476    In other words, accept a client connection on LOCAL_SOCK, and
 477    return the new socket used for communication with the client.
 478    LOCAL_SOCK should have been bound, e.g. using bind_local().
 479
 480    The caller is blocked until a connection is established.  If no
 481    connection is established for opt.connect_timeout seconds, the
 482    function exits with an error status.  */
 483
 484 int
 485 accept_connection (int local_sock)
 486 {
 487   int sock;
 488
 489   /* We don't need the values provided by accept, but accept
 490      apparently requires them to be present.  */
 491   struct sockaddr_storage ss;
 492   struct sockaddr *sa = (struct sockaddr *)&ss;
 493   socklen_t addrlen = sizeof (ss);
 494
 495   if (opt.connect_timeout)
 496     {
 497       int test = select_fd (local_sock, opt.connect_timeout, WAIT_FOR_READ);
 498       if (test == 0)
 499         errno = ETIMEDOUT;
 500       if (test <= 0)
 501         return -1;
 502     }
 503   sock = accept (local_sock, sa, &addrlen);
 504   DEBUGP (("Accepted client at socket %d.\n", sock));
 505   return sock;
 506 }
 507
 508 /* Get the IP address associated with the connection on FD and store
 509    it to IP.  Return true on success, false otherwise.
 510
 511    If ENDPOINT is ENDPOINT_LOCAL, it returns the address of the local
 512    (client) side of the socket.  Else if ENDPOINT is ENDPOINT_PEER, it
 513    returns the address of the remote (peer's) side of the socket.  */
 514
 515 bool
 516 socket_ip_address (int sock, ip_address *ip, int endpoint)
 517 {
 518   struct sockaddr_storage storage;
 519   struct sockaddr *sockaddr = (struct sockaddr *)&storage;
 520   socklen_t addrlen = sizeof (storage);
 521   int ret;
 522
 523   if (endpoint == ENDPOINT_LOCAL)
 524     ret = getsockname (sock, sockaddr, &addrlen);
 525   else if (endpoint == ENDPOINT_PEER)
 526     ret = getpeername (sock, sockaddr, &addrlen);
 527   else
 528     abort ();
 529   if (ret < 0)
 530     return false;
 531
 532   ip->family = sockaddr->sa_family;
 533   switch (sockaddr->sa_family)
 534     {
 535 #ifdef ENABLE_IPV6
 536     case AF_INET6:
 537       {
 538         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&storage;
 539         ip->data.d6 = sa6->sin6_addr;
 540 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 541         ip->ipv6_scope = sa6->sin6_scope_id;
 542 #endif
 543         DEBUGP (("conaddr is: %s\n", print_address (ip)));
 544         return true;
 545       }
 546 #endif
 547     case AF_INET:
 548       {
 549         struct sockaddr_in *sa = (struct sockaddr_in *)&storage;
 550         ip->data.d4 = sa->sin_addr;
 551         DEBUGP (("conaddr is: %s\n", print_address (ip)));
 552         return true;
 553       }
 554     default:
 555       abort ();
 556     }
 557 }
 558
 559 /* Return true if the error from the connect code can be considered
 560    retryable.  Wget normally retries after errors, but the exception
 561    are the "unsupported protocol" type errors (possible on IPv4/IPv6
 562    dual family systems) and "connection refused".  */
 563
 564 bool
 565 retryable_socket_connect_error (int err)
 566 {
 567   /* Have to guard against some of these values not being defined.
 568      Cannot use a switch statement because some of the values might be
 569      equal.  */
 570   if (false
 571 #ifdef EAFNOSUPPORT
 572       || err == EAFNOSUPPORT
 573 #endif
 574 #ifdef EPFNOSUPPORT
 575       || err == EPFNOSUPPORT
 576 #endif
 577 #ifdef ESOCKTNOSUPPORT          /* no, "sockt" is not a typo! */
 578       || err == ESOCKTNOSUPPORT
 579 #endif
 580 #ifdef EPROTONOSUPPORT
 581       || err == EPROTONOSUPPORT
 582 #endif
 583 #ifdef ENOPROTOOPT
 584       || err == ENOPROTOOPT
 585 #endif
 586       /* Apparently, older versions of Linux and BSD used EINVAL
 587          instead of EAFNOSUPPORT and such.  */
 588       || err == EINVAL
 589       )
 590     return false;
 591
 592   if (!opt.retry_connrefused)
 593     if (err == ECONNREFUSED
 594 #ifdef ENETUNREACH
 595         || err == ENETUNREACH   /* network is unreachable */
 596 #endif
 597 #ifdef EHOSTUNREACH
 598         || err == EHOSTUNREACH  /* host is unreachable */
 599 #endif
 600         )
 601       return false;
 602
 603   return true;
 604 }
 605
 606 /* Wait for a single descriptor to become available, timing out after
 607    MAXTIME seconds.  Returns 1 if FD is available, 0 for timeout and
 608    -1 for error.  The argument WAIT_FOR can be a combination of
 609    WAIT_FOR_READ and WAIT_FOR_WRITE.
 610
 611    This is a mere convenience wrapper around the select call, and
 612    should be taken as such (for example, it doesn't implement Wget's
 613    0-timeout-means-no-timeout semantics.)  */
 614
 615 int
 616 select_fd (int fd, double maxtime, int wait_for)
 617 {
 618   fd_set fdset;
 619   fd_set *rd = NULL, *wr = NULL;
 620   struct timeval tmout;
 621   int result;
 622
 623   FD_ZERO (&fdset);
 624   FD_SET (fd, &fdset);
 625   if (wait_for & WAIT_FOR_READ)
 626     rd = &fdset;
 627   if (wait_for & WAIT_FOR_WRITE)
 628     wr = &fdset;
 629
 630   tmout.tv_sec = (long) maxtime;
 631   tmout.tv_usec = 1000000 * (maxtime - (long) maxtime);
 632
 633   do
 634     result = select (fd + 1, rd, wr, NULL, &tmout);
 635   while (result < 0 && errno == EINTR);
 636
 637   return result;
 638 }
 639
 640 /* Return true iff the connection to the remote site established
 641    through SOCK is still open.
 642
 643    Specifically, this function returns true if SOCK is not ready for
 644    reading.  This is because, when the connection closes, the socket
 645    is ready for reading because EOF is about to be delivered.  A side
 646    effect of this method is that sockets that have pending data are
 647    considered non-open.  This is actually a good thing for callers of
 648    this function, where such pending data can only be unwanted
 649    leftover from a previous request.  */
 650
 651 bool
 652 test_socket_open (int sock)
 653 {
 654   fd_set check_set;
 655   struct timeval to;
 656
 657   /* Check if we still have a valid (non-EOF) connection.  From Andrew
 658    * Maholski's code in the Unix Socket FAQ.  */
 659
 660   FD_ZERO (&check_set);
 661   FD_SET (sock, &check_set);
 662
 663   /* Wait one microsecond */
 664   to.tv_sec = 0;
 665   to.tv_usec = 1;
 666
 667   if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
 668     /* We got a timeout, it means we're still connected. */
 669     return true;
 670   else
 671     /* Read now would not wait, it means we have either pending data
 672        or EOF/error. */
 673     return false;
 674 }
 675 \f
 676 /* Basic socket operations, mostly EINTR wrappers.  */
 677
 678 #if defined(WINDOWS) || defined(MSDOS)
 679 # define read(fd, buf, cnt) recv (fd, buf, cnt, 0)
 680 # define write(fd, buf, cnt) send (fd, buf, cnt, 0)
 681 # define close(fd) closesocket (fd)
 682 #endif
 683
 684 #ifdef __BEOS__
 685 # define read(fd, buf, cnt) recv (fd, buf, cnt, 0)
 686 # define write(fd, buf, cnt) send (fd, buf, cnt, 0)
 687 #endif
 688
 689 static int
 690 sock_read (int fd, char *buf, int bufsize)
 691 {
 692   int res;
 693   do
 694     res = read (fd, buf, bufsize);
 695   while (res == -1 && errno == EINTR);
 696   return res;
 697 }
 698
 699 static int
 700 sock_write (int fd, char *buf, int bufsize)
 701 {
 702   int res;
 703   do
 704     res = write (fd, buf, bufsize);
 705   while (res == -1 && errno == EINTR);
 706   return res;
 707 }
 708
 709 static int
 710 sock_poll (int fd, double timeout, int wait_for)
 711 {
 712   return select_fd (fd, timeout, wait_for);
 713 }
 714
 715 static int
 716 sock_peek (int fd, char *buf, int bufsize)
 717 {
 718   int res;
 719   do
 720     res = recv (fd, buf, bufsize, MSG_PEEK);
 721   while (res == -1 && errno == EINTR);
 722   return res;
 723 }
 724
 725 static void
 726 sock_close (int fd)
 727 {
 728   close (fd);
 729   DEBUGP (("Closed fd %d\n", fd));
 730 }
 731 #undef read
 732 #undef write
 733 #undef close
 734 \f
 735 /* Reading and writing from the network.  We build around the socket
 736    (file descriptor) API, but support "extended" operations for things
 737    that are not mere file descriptors under the hood, such as SSL
 738    sockets.
 739
 740    That way the user code can call fd_read(fd, ...) and we'll run read
 741    or SSL_read or whatever is necessary.  */
 742
 743 static struct hash_table *transport_map;
 744 static unsigned int transport_map_modified_tick;
 745
 746 struct transport_info {
 747   struct transport_implementation *imp;
 748   void *ctx;
 749 };
 750
 751 /* Register the transport layer operations that will be used when
 752    reading, writing, and polling FD.
 753
 754    This should be used for transport layers like SSL that piggyback on
 755    sockets.  FD should otherwise be a real socket, on which you can
 756    call getpeername, etc.  */
 757
 758 void
 759 fd_register_transport (int fd, struct transport_implementation *imp, void *ctx)
 760 {
 761   struct transport_info *info;
 762
 763   /* The file descriptor must be non-negative to be registered.
 764      Negative values are ignored by fd_close(), and -1 cannot be used as
 765      hash key.  */
 766   assert (fd >= 0);
 767
 768   info = xnew (struct transport_info);
 769   info->imp = imp;
 770   info->ctx = ctx;
 771   if (!transport_map)
 772     transport_map = hash_table_new (0, NULL, NULL);
 773   hash_table_put (transport_map, (void *)(intptr_t) fd, info);
 774   ++transport_map_modified_tick;
 775 }
 776
 777 /* Return context of the transport registered with
 778    fd_register_transport.  This assumes fd_register_transport was
 779    previously called on FD.  */
 780
 781 void *
 782 fd_transport_context (int fd)
 783 {
 784   struct transport_info *info = hash_table_get (transport_map, (void *)(intptr_t) fd);
 785   return info->ctx;
 786 }
 787
 788 /* When fd_read/fd_write are called multiple times in a loop, they should
 789    remember the INFO pointer instead of fetching it every time.  It is
 790    not enough to compare FD to LAST_FD because FD might have been
 791    closed and reopened.  modified_tick ensures that changes to
 792    transport_map will not be unnoticed.
 793
 794    This is a macro because we want the static storage variables to be
 795    per-function.  */
 796
 797 #define LAZY_RETRIEVE_INFO(info) do {                                   \
 798   static struct transport_info *last_info;                              \
 799   static int last_fd = -1;                                              \
 800   static unsigned int last_tick;                                        \
 801   if (!transport_map)                                                   \
 802     info = NULL;                                                        \
 803   else if (last_fd == fd && last_tick == transport_map_modified_tick)   \
 804     info = last_info;                                                   \
 805   else                                                                  \
 806     {                                                                   \
 807       info = hash_table_get (transport_map, (void *)(intptr_t) fd);     \
 808       last_fd = fd;                                                     \
 809       last_info = info;                                                 \
 810       last_tick = transport_map_modified_tick;                          \
 811     }                                                                   \
 812 } while (0)
 813
 814 static bool
 815 poll_internal (int fd, struct transport_info *info, int wf, double timeout)
 816 {
 817   if (timeout == -1)
 818     timeout = opt.read_timeout;
 819   if (timeout)
 820     {
 821       int test;
 822       if (info && info->imp->poller)
 823         test = info->imp->poller (fd, timeout, wf, info->ctx);
 824       else
 825         test = sock_poll (fd, timeout, wf);
 826       if (test == 0)
 827         errno = ETIMEDOUT;
 828       if (test <= 0)
 829         return false;
 830     }
 831   return true;
 832 }
 833
 834 /* Read no more than BUFSIZE bytes of data from FD, storing them to
 835    BUF.  If TIMEOUT is non-zero, the operation aborts if no data is
 836    received after that many seconds.  If TIMEOUT is -1, the value of
 837    opt.timeout is used for TIMEOUT.  */
 838
 839 int
 840 fd_read (int fd, char *buf, int bufsize, double timeout)
 841 {
 842   struct transport_info *info;
 843   LAZY_RETRIEVE_INFO (info);
 844   if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
 845     return -1;
 846   if (info && info->imp->reader)
 847     return info->imp->reader (fd, buf, bufsize, info->ctx);
 848   else
 849     return sock_read (fd, buf, bufsize);
 850 }
 851
 852 /* Like fd_read, except it provides a "preview" of the data that will
 853    be read by subsequent calls to fd_read.  Specifically, it copies no
 854    more than BUFSIZE bytes of the currently available data to BUF and
 855    returns the number of bytes copied.  Return values and timeout
 856    semantics are the same as those of fd_read.
 857
 858    CAVEAT: Do not assume that the first subsequent call to fd_read
 859    will retrieve the same amount of data.  Reading can return more or
 860    less data, depending on the TCP implementation and other
 861    circumstances.  However, barring an error, it can be expected that
 862    all the peeked data will eventually be read by fd_read.  */
 863
 864 int
 865 fd_peek (int fd, char *buf, int bufsize, double timeout)
 866 {
 867   struct transport_info *info;
 868   LAZY_RETRIEVE_INFO (info);
 869   if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
 870     return -1;
 871   if (info && info->imp->peeker)
 872     return info->imp->peeker (fd, buf, bufsize, info->ctx);
 873   else
 874     return sock_peek (fd, buf, bufsize);
 875 }
 876
 877 /* Write the entire contents of BUF to FD.  If TIMEOUT is non-zero,
 878    the operation aborts if no data is received after that many
 879    seconds.  If TIMEOUT is -1, the value of opt.timeout is used for
 880    TIMEOUT.  */
 881
 882 int
 883 fd_write (int fd, char *buf, int bufsize, double timeout)
 884 {
 885   int res;
 886   struct transport_info *info;
 887   LAZY_RETRIEVE_INFO (info);
 888
 889   /* `write' may write less than LEN bytes, thus the loop keeps trying
 890      it until all was written, or an error occurred.  */
 891   res = 0;
 892   while (bufsize > 0)
 893     {
 894       if (!poll_internal (fd, info, WAIT_FOR_WRITE, timeout))
 895         return -1;
 896       if (info && info->imp->writer)
 897         res = info->imp->writer (fd, buf, bufsize, info->ctx);
 898       else
 899         res = sock_write (fd, buf, bufsize);
 900       if (res <= 0)
 901         break;
 902       buf += res;
 903       bufsize -= res;
 904     }
 905   return res;
 906 }
 907
 908 /* Report the most recent error(s) on FD.  This should only be called
 909    after fd_* functions, such as fd_read and fd_write, and only if
 910    they return a negative result.  For errors coming from other calls
 911    such as setsockopt or fopen, strerror should continue to be
 912    used.
 913
 914    If the transport doesn't support error messages or doesn't supply
 915    one, strerror(errno) is returned.  The returned error message
 916    should not be used after fd_close has been called.  */
 917
 918 const char *
 919 fd_errstr (int fd)
 920 {
 921   /* Don't bother with LAZY_RETRIEVE_INFO, as this will only be called
 922      in case of error, never in a tight loop.  */
 923   struct transport_info *info = NULL;
 924   if (transport_map)
 925     info = hash_table_get (transport_map, (void *)(intptr_t) fd);
 926
 927   if (info && info->imp->errstr)
 928     {
 929       const char *err = info->imp->errstr (fd, info->ctx);
 930       if (err)
 931         return err;
 932       /* else, fall through and print the system error. */
 933     }
 934   return strerror (errno);
 935 }
 936
 937 /* Close the file descriptor FD.  */
 938
 939 void
 940 fd_close (int fd)
 941 {
 942   struct transport_info *info;
 943   if (fd < 0)
 944     return;
 945
 946   /* Don't use LAZY_RETRIEVE_INFO because fd_close() is only called once
 947      per socket, so that particular optimization wouldn't work.  */
 948   info = NULL;
 949   if (transport_map)
 950     info = hash_table_get (transport_map, (void *)(intptr_t) fd);
 951
 952   if (info && info->imp->closer)
 953     info->imp->closer (fd, info->ctx);
 954   else
 955     sock_close (fd);
 956
 957   if (info)
 958     {
 959       hash_table_remove (transport_map, (void *)(intptr_t) fd);
 960       xfree (info);
 961       ++transport_map_modified_tick;
 962     }
 963 }