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