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 #include <sys/socket.h>
  40 #include <sys/select.h>
  41
  42 #ifndef WINDOWS
  43 # ifdef __VMS
  44 #  include "vms_ip.h"
  45 # else /* def __VMS */
  46 #  include <netdb.h>
  47 # endif /* def __VMS [else] */
  48 # include <netinet/in.h>
  49 # ifndef __BEOS__
  50 #  include <arpa/inet.h>
  51 # endif
  52 #endif /* not WINDOWS */
  53
  54 #include <errno.h>
  55 #include <string.h>
  56 #include <sys/time.h>
  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         {
 295            if (ip->family == AF_INET)
 296                logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port);
 297 #ifdef ENABLE_IPV6
 298            else if (ip->family == AF_INET6)
 299                logprintf (LOG_VERBOSE, _("Connecting to [%s]:%d... "), txt_addr, port);
 300 #endif
 301         }
 302     }
 303
 304   /* Store the sockaddr info to SA.  */
 305   sockaddr_set_data (sa, ip, port);
 306
 307   /* Create the socket of the family appropriate for the address.  */
 308   sock = socket (sa->sa_family, SOCK_STREAM, 0);
 309   if (sock < 0)
 310     goto err;
 311
 312 #if defined(ENABLE_IPV6) && defined(IPV6_V6ONLY)
 313   if (opt.ipv6_only) {
 314     int on = 1;
 315     /* In case of error, we will go on anyway... */
 316     int err = setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on));
 317     IF_DEBUG
 318       if (err < 0)
 319         DEBUGP (("Failed setting IPV6_V6ONLY: %s", strerror (errno)));
 320   }
 321 #endif
 322
 323   /* For very small rate limits, set the buffer size (and hence,
 324      hopefully, the kernel's TCP window size) to the per-second limit.
 325      That way we should never have to sleep for more than 1s between
 326      network reads.  */
 327   if (opt.limit_rate && opt.limit_rate < 8192)
 328     {
 329       int bufsize = opt.limit_rate;
 330       if (bufsize < 512)
 331         bufsize = 512;          /* avoid pathologically small values */
 332 #ifdef SO_RCVBUF
 333       setsockopt (sock, SOL_SOCKET, SO_RCVBUF,
 334                   (void *)&bufsize, (socklen_t)sizeof (bufsize));
 335 #endif
 336       /* When we add limit_rate support for writing, which is useful
 337          for POST, we should also set SO_SNDBUF here.  */
 338     }
 339
 340   if (opt.bind_address)
 341     {
 342       /* Bind the client side of the socket to the requested
 343          address.  */
 344       struct sockaddr_storage bind_ss;
 345       struct sockaddr *bind_sa = (struct sockaddr *)&bind_ss;
 346       if (resolve_bind_address (bind_sa))
 347         {
 348           if (bind (sock, bind_sa, sockaddr_size (bind_sa)) < 0)
 349             goto err;
 350         }
 351     }
 352
 353   /* Connect the socket to the remote endpoint.  */
 354   if (connect_with_timeout (sock, sa, sockaddr_size (sa),
 355                             opt.connect_timeout) < 0)
 356     goto err;
 357
 358   /* Success. */
 359   assert (sock >= 0);
 360   if (print)
 361     logprintf (LOG_VERBOSE, _("connected.\n"));
 362   DEBUGP (("Created socket %d.\n", sock));
 363   return sock;
 364
 365  err:
 366   {
 367     /* Protect errno from possible modifications by close and
 368        logprintf.  */
 369     int save_errno = errno;
 370     if (sock >= 0)
 371       fd_close (sock);
 372     if (print)
 373       logprintf (LOG_VERBOSE, _("failed: %s.\n"), strerror (errno));
 374     errno = save_errno;
 375     return -1;
 376   }
 377 }
 378
 379 /* Connect via TCP to a remote host on the specified port.
 380
 381    HOST is resolved as an Internet host name.  If HOST resolves to
 382    more than one IP address, they are tried in the order returned by
 383    DNS until connecting to one of them succeeds.  */
 384
 385 int
 386 connect_to_host (const char *host, int port)
 387 {
 388   int i, start, end;
 389   int sock;
 390
 391   struct address_list *al = lookup_host (host, 0);
 392
 393  retry:
 394   if (!al)
 395     {
 396       logprintf (LOG_NOTQUIET,
 397                  _("%s: unable to resolve host address %s\n"),
 398                  exec_name, quote (host));
 399       return E_HOST;
 400     }
 401
 402   address_list_get_bounds (al, &start, &end);
 403   for (i = start; i < end; i++)
 404     {
 405       const ip_address *ip = address_list_address_at (al, i);
 406       sock = connect_to_ip (ip, port, host);
 407       if (sock >= 0)
 408         {
 409           /* Success. */
 410           address_list_set_connected (al);
 411           address_list_release (al);
 412           return sock;
 413         }
 414
 415       /* The attempt to connect has failed.  Continue with the loop
 416          and try next address. */
 417
 418       address_list_set_faulty (al, i);
 419     }
 420
 421   /* Failed to connect to any of the addresses in AL. */
 422
 423   if (address_list_connected_p (al))
 424     {
 425       /* We connected to AL before, but cannot do so now.  That might
 426          indicate that our DNS cache entry for HOST has expired.  */
 427       address_list_release (al);
 428       al = lookup_host (host, LH_REFRESH);
 429       goto retry;
 430     }
 431   address_list_release (al);
 432
 433   return -1;
 434 }
 435 \f
 436 /* Create a socket, bind it to local interface BIND_ADDRESS on port
 437    *PORT, set up a listen backlog, and return the resulting socket, or
 438    -1 in case of error.
 439
 440    BIND_ADDRESS is the address of the interface to bind to.  If it is
 441    NULL, the socket is bound to the default address.  PORT should
 442    point to the port number that will be used for the binding.  If
 443    that number is 0, the system will choose a suitable port, and the
 444    chosen value will be written to *PORT.
 445
 446    Calling accept() on such a socket waits for and accepts incoming
 447    TCP connections.  */
 448
 449 int
 450 bind_local (const ip_address *bind_address, int *port)
 451 {
 452   int sock;
 453   struct sockaddr_storage ss;
 454   struct sockaddr *sa = (struct sockaddr *)&ss;
 455
 456   /* For setting options with setsockopt. */
 457   int setopt_val = 1;
 458   void *setopt_ptr = (void *)&setopt_val;
 459   socklen_t setopt_size = sizeof (setopt_val);
 460
 461   sock = socket (bind_address->family, SOCK_STREAM, 0);
 462   if (sock < 0)
 463     return -1;
 464
 465 #ifdef SO_REUSEADDR
 466   setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, setopt_ptr, setopt_size);
 467 #endif
 468
 469   xzero (ss);
 470   sockaddr_set_data (sa, bind_address, *port);
 471   if (bind (sock, sa, sockaddr_size (sa)) < 0)
 472     {
 473       fd_close (sock);
 474       return -1;
 475     }
 476   DEBUGP (("Local socket fd %d bound.\n", sock));
 477
 478   /* If *PORT is 0, find out which port we've bound to.  */
 479   if (*port == 0)
 480     {
 481       socklen_t addrlen = sockaddr_size (sa);
 482       if (getsockname (sock, sa, &addrlen) < 0)
 483         {
 484           /* If we can't find out the socket's local address ("name"),
 485              something is seriously wrong with the socket, and it's
 486              unusable for us anyway because we must know the chosen
 487              port.  */
 488           fd_close (sock);
 489           return -1;
 490         }
 491       sockaddr_get_data (sa, NULL, port);
 492       DEBUGP (("binding to address %s using port %i.\n",
 493                print_address (bind_address), *port));
 494     }
 495   if (listen (sock, 1) < 0)
 496     {
 497       fd_close (sock);
 498       return -1;
 499     }
 500   return sock;
 501 }
 502
 503 /* Like a call to accept(), but with the added check for timeout.
 504
 505    In other words, accept a client connection on LOCAL_SOCK, and
 506    return the new socket used for communication with the client.
 507    LOCAL_SOCK should have been bound, e.g. using bind_local().
 508
 509    The caller is blocked until a connection is established.  If no
 510    connection is established for opt.connect_timeout seconds, the
 511    function exits with an error status.  */
 512
 513 int
 514 accept_connection (int local_sock)
 515 {
 516   int sock;
 517
 518   /* We don't need the values provided by accept, but accept
 519      apparently requires them to be present.  */
 520   struct sockaddr_storage ss;
 521   struct sockaddr *sa = (struct sockaddr *)&ss;
 522   socklen_t addrlen = sizeof (ss);
 523
 524   if (opt.connect_timeout)
 525     {
 526       int test = select_fd (local_sock, opt.connect_timeout, WAIT_FOR_READ);
 527       if (test == 0)
 528         errno = ETIMEDOUT;
 529       if (test <= 0)
 530         return -1;
 531     }
 532   sock = accept (local_sock, sa, &addrlen);
 533   DEBUGP (("Accepted client at socket %d.\n", sock));
 534   return sock;
 535 }
 536
 537 /* Get the IP address associated with the connection on FD and store
 538    it to IP.  Return true on success, false otherwise.
 539
 540    If ENDPOINT is ENDPOINT_LOCAL, it returns the address of the local
 541    (client) side of the socket.  Else if ENDPOINT is ENDPOINT_PEER, it
 542    returns the address of the remote (peer's) side of the socket.  */
 543
 544 bool
 545 socket_ip_address (int sock, ip_address *ip, int endpoint)
 546 {
 547   struct sockaddr_storage storage;
 548   struct sockaddr *sockaddr = (struct sockaddr *) &storage;
 549   socklen_t addrlen = sizeof (storage);
 550   int ret;
 551
 552   memset (sockaddr, 0, addrlen);
 553   if (endpoint == ENDPOINT_LOCAL)
 554     ret = getsockname (sock, sockaddr, &addrlen);
 555   else if (endpoint == ENDPOINT_PEER)
 556     ret = getpeername (sock, sockaddr, &addrlen);
 557   else
 558     abort ();
 559   if (ret < 0)
 560     return false;
 561
 562   memset(ip, 0, sizeof(ip_address));
 563   ip->family = sockaddr->sa_family;
 564   switch (sockaddr->sa_family)
 565     {
 566 #ifdef ENABLE_IPV6
 567     case AF_INET6:
 568       {
 569         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&storage;
 570         ip->data.d6 = sa6->sin6_addr;
 571 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 572         ip->ipv6_scope = sa6->sin6_scope_id;
 573 #endif
 574         DEBUGP (("conaddr is: %s\n", print_address (ip)));
 575         return true;
 576       }
 577 #endif
 578     case AF_INET:
 579       {
 580         struct sockaddr_in *sa = (struct sockaddr_in *)&storage;
 581         ip->data.d4 = sa->sin_addr;
 582         DEBUGP (("conaddr is: %s\n", print_address (ip)));
 583         return true;
 584       }
 585     default:
 586       abort ();
 587     }
 588 }
 589
 590 /* Get the socket family of connection on FD and store
 591    Return family type on success, -1 otherwise.
 592
 593    If ENDPOINT is ENDPOINT_LOCAL, it returns the sock family of the local
 594    (client) side of the socket.  Else if ENDPOINT is ENDPOINT_PEER, it
 595    returns the sock family of the remote (peer's) side of the socket.  */
 596
 597 int
 598 socket_family (int sock, int endpoint)
 599 {
 600   struct sockaddr_storage storage;
 601   struct sockaddr *sockaddr = (struct sockaddr *) &storage;
 602   socklen_t addrlen = sizeof (storage);
 603   int ret;
 604
 605   memset (sockaddr, 0, addrlen);
 606
 607   if (endpoint == ENDPOINT_LOCAL)
 608     ret = getsockname (sock, sockaddr, &addrlen);
 609   else if (endpoint == ENDPOINT_PEER)
 610     ret = getpeername (sock, sockaddr, &addrlen);
 611   else
 612     abort ();
 613
 614   if (ret < 0)
 615     return -1;
 616
 617   return sockaddr->sa_family;
 618 }
 619
 620 /* Return true if the error from the connect code can be considered
 621    retryable.  Wget normally retries after errors, but the exception
 622    are the "unsupported protocol" type errors (possible on IPv4/IPv6
 623    dual family systems) and "connection refused".  */
 624
 625 bool
 626 retryable_socket_connect_error (int err)
 627 {
 628   /* Have to guard against some of these values not being defined.
 629      Cannot use a switch statement because some of the values might be
 630      equal.  */
 631   if (false
 632 #ifdef EAFNOSUPPORT
 633       || err == EAFNOSUPPORT
 634 #endif
 635 #ifdef EPFNOSUPPORT
 636       || err == EPFNOSUPPORT
 637 #endif
 638 #ifdef ESOCKTNOSUPPORT          /* no, "sockt" is not a typo! */
 639       || err == ESOCKTNOSUPPORT
 640 #endif
 641 #ifdef EPROTONOSUPPORT
 642       || err == EPROTONOSUPPORT
 643 #endif
 644 #ifdef ENOPROTOOPT
 645       || err == ENOPROTOOPT
 646 #endif
 647       /* Apparently, older versions of Linux and BSD used EINVAL
 648          instead of EAFNOSUPPORT and such.  */
 649       || err == EINVAL
 650       )
 651     return false;
 652
 653   if (!opt.retry_connrefused)
 654     if (err == ECONNREFUSED
 655 #ifdef ENETUNREACH
 656         || err == ENETUNREACH   /* network is unreachable */
 657 #endif
 658 #ifdef EHOSTUNREACH
 659         || err == EHOSTUNREACH  /* host is unreachable */
 660 #endif
 661         )
 662       return false;
 663
 664   return true;
 665 }
 666
 667 /* Wait for a single descriptor to become available, timing out after
 668    MAXTIME seconds.  Returns 1 if FD is available, 0 for timeout and
 669    -1 for error.  The argument WAIT_FOR can be a combination of
 670    WAIT_FOR_READ and WAIT_FOR_WRITE.
 671
 672    This is a mere convenience wrapper around the select call, and
 673    should be taken as such (for example, it doesn't implement Wget's
 674    0-timeout-means-no-timeout semantics.)  */
 675
 676 int
 677 select_fd (int fd, double maxtime, int wait_for)
 678 {
 679   fd_set fdset;
 680   fd_set *rd = NULL, *wr = NULL;
 681   struct timeval tmout;
 682   int result;
 683
 684   FD_ZERO (&fdset);
 685   FD_SET (fd, &fdset);
 686   if (wait_for & WAIT_FOR_READ)
 687     rd = &fdset;
 688   if (wait_for & WAIT_FOR_WRITE)
 689     wr = &fdset;
 690
 691   tmout.tv_sec = (long) maxtime;
 692   tmout.tv_usec = 1000000 * (maxtime - (long) maxtime);
 693
 694   do
 695   {
 696     result = select (fd + 1, rd, wr, NULL, &tmout);
 697 #ifdef WINDOWS
 698     /* gnulib select() converts blocking sockets to nonblocking in windows.
 699        wget uses blocking sockets so we must convert them back to blocking.  */
 700     set_windows_fd_as_blocking_socket (fd);
 701 #endif
 702   }
 703   while (result < 0 && errno == EINTR);
 704
 705   return result;
 706 }
 707
 708 /* Return true iff the connection to the remote site established
 709    through SOCK is still open.
 710
 711    Specifically, this function returns true if SOCK is not ready for
 712    reading.  This is because, when the connection closes, the socket
 713    is ready for reading because EOF is about to be delivered.  A side
 714    effect of this method is that sockets that have pending data are
 715    considered non-open.  This is actually a good thing for callers of
 716    this function, where such pending data can only be unwanted
 717    leftover from a previous request.  */
 718
 719 bool
 720 test_socket_open (int sock)
 721 {
 722   fd_set check_set;
 723   struct timeval to;
 724   int ret = 0;
 725
 726   /* Check if we still have a valid (non-EOF) connection.  From Andrew
 727    * Maholski's code in the Unix Socket FAQ.  */
 728
 729   FD_ZERO (&check_set);
 730   FD_SET (sock, &check_set);
 731
 732   /* Wait one microsecond */
 733   to.tv_sec = 0;
 734   to.tv_usec = 1;
 735
 736   ret = select (sock + 1, &check_set, NULL, NULL, &to);
 737 #ifdef WINDOWS
 738 /* gnulib select() converts blocking sockets to nonblocking in windows.
 739 wget uses blocking sockets so we must convert them back to blocking
 740 */
 741   set_windows_fd_as_blocking_socket ( sock );
 742 #endif
 743
 744   if ( !ret )
 745     /* We got a timeout, it means we're still connected. */
 746     return true;
 747   else
 748     /* Read now would not wait, it means we have either pending data
 749        or EOF/error. */
 750     return false;
 751 }
 752 \f
 753 /* Basic socket operations, mostly EINTR wrappers.  */
 754
 755 static int
 756 sock_read (int fd, char *buf, int bufsize)
 757 {
 758   int res;
 759   do
 760     res = read (fd, buf, bufsize);
 761   while (res == -1 && errno == EINTR);
 762   return res;
 763 }
 764
 765 static int
 766 sock_write (int fd, char *buf, int bufsize)
 767 {
 768   int res;
 769   do
 770     res = write (fd, buf, bufsize);
 771   while (res == -1 && errno == EINTR);
 772   return res;
 773 }
 774
 775 static int
 776 sock_poll (int fd, double timeout, int wait_for)
 777 {
 778   return select_fd (fd, timeout, wait_for);
 779 }
 780
 781 static int
 782 sock_peek (int fd, char *buf, int bufsize)
 783 {
 784   int res;
 785   do
 786     res = recv (fd, buf, bufsize, MSG_PEEK);
 787   while (res == -1 && errno == EINTR);
 788   return res;
 789 }
 790
 791 static void
 792 sock_close (int fd)
 793 {
 794   close (fd);
 795   DEBUGP (("Closed fd %d\n", fd));
 796 }
 797 #undef read
 798 #undef write
 799 #undef close
 800 \f
 801 /* Reading and writing from the network.  We build around the socket
 802    (file descriptor) API, but support "extended" operations for things
 803    that are not mere file descriptors under the hood, such as SSL
 804    sockets.
 805
 806    That way the user code can call fd_read(fd, ...) and we'll run read
 807    or SSL_read or whatever is necessary.  */
 808
 809 static struct hash_table *transport_map;
 810 static unsigned int transport_map_modified_tick;
 811
 812 struct transport_info {
 813   struct transport_implementation *imp;
 814   void *ctx;
 815 };
 816
 817 /* Register the transport layer operations that will be used when
 818    reading, writing, and polling FD.
 819
 820    This should be used for transport layers like SSL that piggyback on
 821    sockets.  FD should otherwise be a real socket, on which you can
 822    call getpeername, etc.  */
 823
 824 void
 825 fd_register_transport (int fd, struct transport_implementation *imp, void *ctx)
 826 {
 827   struct transport_info *info;
 828
 829   /* The file descriptor must be non-negative to be registered.
 830      Negative values are ignored by fd_close(), and -1 cannot be used as
 831      hash key.  */
 832   assert (fd >= 0);
 833
 834   info = xnew (struct transport_info);
 835   info->imp = imp;
 836   info->ctx = ctx;
 837   if (!transport_map)
 838     transport_map = hash_table_new (0, NULL, NULL);
 839   hash_table_put (transport_map, (void *)(intptr_t) fd, info);
 840   ++transport_map_modified_tick;
 841 }
 842
 843 /* Return context of the transport registered with
 844    fd_register_transport.  This assumes fd_register_transport was
 845    previously called on FD.  */
 846
 847 void *
 848 fd_transport_context (int fd)
 849 {
 850   struct transport_info *info = hash_table_get (transport_map, (void *)(intptr_t) fd);
 851   return info->ctx;
 852 }
 853
 854 /* When fd_read/fd_write are called multiple times in a loop, they should
 855    remember the INFO pointer instead of fetching it every time.  It is
 856    not enough to compare FD to LAST_FD because FD might have been
 857    closed and reopened.  modified_tick ensures that changes to
 858    transport_map will not be unnoticed.
 859
 860    This is a macro because we want the static storage variables to be
 861    per-function.  */
 862
 863 #define LAZY_RETRIEVE_INFO(info) do {                                   \
 864   static struct transport_info *last_info;                              \
 865   static int last_fd = -1;                                              \
 866   static unsigned int last_tick;                                        \
 867   if (!transport_map)                                                   \
 868     info = NULL;                                                        \
 869   else if (last_fd == fd && last_tick == transport_map_modified_tick)   \
 870     info = last_info;                                                   \
 871   else                                                                  \
 872     {                                                                   \
 873       info = hash_table_get (transport_map, (void *)(intptr_t) fd);     \
 874       last_fd = fd;                                                     \
 875       last_info = info;                                                 \
 876       last_tick = transport_map_modified_tick;                          \
 877     }                                                                   \
 878 } while (0)
 879
 880 static bool
 881 poll_internal (int fd, struct transport_info *info, int wf, double timeout)
 882 {
 883   if (timeout == -1)
 884     timeout = opt.read_timeout;
 885   if (timeout)
 886     {
 887       int test;
 888       if (info && info->imp->poller)
 889         test = info->imp->poller (fd, timeout, wf, info->ctx);
 890       else
 891         test = sock_poll (fd, timeout, wf);
 892       if (test == 0)
 893         errno = ETIMEDOUT;
 894       if (test <= 0)
 895         return false;
 896     }
 897   return true;
 898 }
 899
 900 /* Read no more than BUFSIZE bytes of data from FD, storing them to
 901    BUF.  If TIMEOUT is non-zero, the operation aborts if no data is
 902    received after that many seconds.  If TIMEOUT is -1, the value of
 903    opt.timeout is used for TIMEOUT.  */
 904
 905 int
 906 fd_read (int fd, char *buf, int bufsize, double timeout)
 907 {
 908   struct transport_info *info;
 909   LAZY_RETRIEVE_INFO (info);
 910   if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
 911     return -1;
 912   if (info && info->imp->reader)
 913     return info->imp->reader (fd, buf, bufsize, info->ctx);
 914   else
 915     return sock_read (fd, buf, bufsize);
 916 }
 917
 918 /* Like fd_read, except it provides a "preview" of the data that will
 919    be read by subsequent calls to fd_read.  Specifically, it copies no
 920    more than BUFSIZE bytes of the currently available data to BUF and
 921    returns the number of bytes copied.  Return values and timeout
 922    semantics are the same as those of fd_read.
 923
 924    CAVEAT: Do not assume that the first subsequent call to fd_read
 925    will retrieve the same amount of data.  Reading can return more or
 926    less data, depending on the TCP implementation and other
 927    circumstances.  However, barring an error, it can be expected that
 928    all the peeked data will eventually be read by fd_read.  */
 929
 930 int
 931 fd_peek (int fd, char *buf, int bufsize, double timeout)
 932 {
 933   struct transport_info *info;
 934   LAZY_RETRIEVE_INFO (info);
 935   if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
 936     return -1;
 937   if (info && info->imp->peeker)
 938     return info->imp->peeker (fd, buf, bufsize, info->ctx);
 939   else
 940     return sock_peek (fd, buf, bufsize);
 941 }
 942
 943 /* Write the entire contents of BUF to FD.  If TIMEOUT is non-zero,
 944    the operation aborts if no data is received after that many
 945    seconds.  If TIMEOUT is -1, the value of opt.timeout is used for
 946    TIMEOUT.  */
 947
 948 int
 949 fd_write (int fd, char *buf, int bufsize, double timeout)
 950 {
 951   int res;
 952   struct transport_info *info;
 953   LAZY_RETRIEVE_INFO (info);
 954
 955   /* `write' may write less than LEN bytes, thus the loop keeps trying
 956      it until all was written, or an error occurred.  */
 957   res = 0;
 958   while (bufsize > 0)
 959     {
 960       if (!poll_internal (fd, info, WAIT_FOR_WRITE, timeout))
 961         return -1;
 962       if (info && info->imp->writer)
 963         res = info->imp->writer (fd, buf, bufsize, info->ctx);
 964       else
 965         res = sock_write (fd, buf, bufsize);
 966       if (res <= 0)
 967         break;
 968       buf += res;
 969       bufsize -= res;
 970     }
 971   return res;
 972 }
 973
 974 /* Report the most recent error(s) on FD.  This should only be called
 975    after fd_* functions, such as fd_read and fd_write, and only if
 976    they return a negative result.  For errors coming from other calls
 977    such as setsockopt or fopen, strerror should continue to be
 978    used.
 979
 980    If the transport doesn't support error messages or doesn't supply
 981    one, strerror(errno) is returned.  The returned error message
 982    should not be used after fd_close has been called.  */
 983
 984 const char *
 985 fd_errstr (int fd)
 986 {
 987   /* Don't bother with LAZY_RETRIEVE_INFO, as this will only be called
 988      in case of error, never in a tight loop.  */
 989   struct transport_info *info = NULL;
 990   if (transport_map)
 991     info = hash_table_get (transport_map, (void *)(intptr_t) fd);
 992
 993   if (info && info->imp->errstr)
 994     {
 995       const char *err = info->imp->errstr (fd, info->ctx);
 996       if (err)
 997         return err;
 998       /* else, fall through and print the system error. */
 999     }
1000   return strerror (errno);
1001 }
1002
1003 /* Close the file descriptor FD.  */
1004
1005 void
1006 fd_close (int fd)
1007 {
1008   struct transport_info *info;
1009   if (fd < 0)
1010     return;
1011
1012   /* Don't use LAZY_RETRIEVE_INFO because fd_close() is only called once
1013      per socket, so that particular optimization wouldn't work.  */
1014   info = NULL;
1015   if (transport_map)
1016     info = hash_table_get (transport_map, (void *)(intptr_t) fd);
1017
1018   if (info && info->imp->closer)
1019     info->imp->closer (fd, info->ctx);
1020   else
1021     sock_close (fd);
1022
1023   if (info)
1024     {
1025       hash_table_remove (transport_map, (void *)(intptr_t) fd);
1026       xfree (info);
1027       ++transport_map_modified_tick;
1028     }
1029 }