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