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