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