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