sjero.net Git - wget/blob - src/connect.c

   1 /* Establishing and handling network connections.
   2    Copyright (C) 1995, 1996, 1997, 2001, 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Wget.
   5
   6 GNU Wget is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9  (at your option) any later version.
  10
  11 GNU Wget is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Wget; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 In addition, as a special exception, the Free Software Foundation
  21 gives permission to link the code of its release of Wget with the
  22 OpenSSL project's "OpenSSL" library (or with modified versions of it
  23 that use the same license as the "OpenSSL" library), and distribute
  24 the linked executables.  You must obey the GNU General Public License
  25 in all respects for all of the code used other than "OpenSSL".  If you
  26 modify this file, you may extend this exception to your version of the
  27 file, but you are not obligated to do so.  If you do not wish to do
  28 so, delete this exception statement from your version.  */
  29
  30 #include <config.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <sys/types.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 #ifdef HAVE_STRING_H
  51 # include <string.h>
  52 #else
  53 # include <strings.h>
  54 #endif /* HAVE_STRING_H */
  55 #ifdef HAVE_SYS_SELECT_H
  56 # include <sys/select.h>
  57 #endif /* HAVE_SYS_SELECT_H */
  58
  59 #include "wget.h"
  60 #include "utils.h"
  61 #include "host.h"
  62 #include "connect.h"
  63
  64 #ifndef errno
  65 extern int errno;
  66 #endif
  67
  68 \f
  69 /**
  70   * sockaddr_set_data
  71   *
  72   * This function takes a sockaddr struct and fills in the protocol
  73   * type, the port number and the address.  If ENABLE_IPV6 is defined,
  74   * SA should really point to struct sockaddr_storage; otherwise, it
  75   * should point to struct sockaddr_in.
  76   *
  77   * Input:
  78   * struct sockaddr*    The space to be filled
  79   * const ip_address    The IP address
  80   * int                 The port
  81   *
  82   * Return:
  83   * -                   Only modifies 1st parameter.
  84   */
  85 static void
  86 sockaddr_set_data (struct sockaddr *sa, const ip_address *addr, int port)
  87 {
  88   if (addr->type == IPV4_ADDRESS)
  89     {
  90       struct sockaddr_in *sin = (struct sockaddr_in *)sa;
  91       sin->sin_family = AF_INET;
  92       sin->sin_port = htons (port);
  93       if (addr == NULL)
  94         sin->sin_addr.s_addr = INADDR_ANY;
  95       else
  96         sin->sin_addr = ADDRESS_IPV4_IN_ADDR (addr);
  97     }
  98 #ifdef ENABLE_IPV6
  99   else if (addr->type == IPV6_ADDRESS)
 100     {
 101       struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 102       sin6->sin6_family = AF_INET6;
 103       sin6->sin6_port = htons (port);
 104       /* #### How can ADDR be NULL?  We have dereferenced it above by
 105          accessing addr->type!  */
 106       if (addr == NULL)
 107         {
 108           sin6->sin6_addr = in6addr_any;
 109           /* #### Should we set the scope_id here? */
 110         }
 111       else
 112         {
 113           sin6->sin6_addr = ADDRESS_IPV6_IN6_ADDR (addr);
 114 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 115           sin6->sin6_scope_id = ADDRESS_IPV6_SCOPE (addr);
 116 #endif
 117         }
 118     }
 119 #endif /* ENABLE_IPV6 */
 120   else
 121     abort ();
 122 }
 123
 124 /* Get the data of SA, specifically the IP address and the port.  If
 125    you're not interested in one or the other information, pass NULL as
 126    the pointer.  */
 127
 128 void
 129 sockaddr_get_data (const struct sockaddr *sa, ip_address *ip, int *port)
 130 {
 131   if (sa->sa_family == AF_INET)
 132     {
 133       struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 134       if (ip)
 135         {
 136           ip->type = IPV4_ADDRESS;
 137           ADDRESS_IPV4_IN_ADDR (ip) = sin->sin_addr;
 138         }
 139       if (port)
 140         *port = ntohs (sin->sin_port);
 141     }
 142 #ifdef ENABLE_IPV6
 143   else if (sa->sa_family == AF_INET6)
 144     {
 145       struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 146       if (ip)
 147         {
 148           ip->type = IPV6_ADDRESS;
 149           ADDRESS_IPV6_IN6_ADDR (ip) = sin6->sin6_addr;
 150 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 151           ADDRESS_IPV6_SCOPE (ip) = sin6->sin6_scope_id;
 152 #endif
 153         }
 154       if (port)
 155         *port = ntohs (sin6->sin6_port);
 156     }
 157 #endif
 158   else
 159     abort ();
 160 }
 161
 162 /* Return the size of the sockaddr structure depending on its
 163    family.  */
 164
 165 static socklen_t
 166 sockaddr_size (const struct sockaddr *sa)
 167 {
 168   switch (sa->sa_family)
 169     {
 170     case AF_INET:
 171       return sizeof (struct sockaddr_in);
 172 #ifdef ENABLE_IPV6
 173     case AF_INET6:
 174       return sizeof (struct sockaddr_in6);
 175 #endif
 176     default:
 177       abort ();
 178       return 0;                 /* so the compiler shuts up. */
 179     }
 180 }
 181 \f
 182 static int
 183 resolve_bind_address (const char *host, struct sockaddr *sa, int flags)
 184 {
 185   struct address_list *al;
 186
 187   /* #### Shouldn't we do this only once?  opt.bind_address won't
 188      change during a Wget run!  */
 189
 190   al = lookup_host (host, flags | LH_SILENT | LH_PASSIVE);
 191   if (al == NULL)
 192     {
 193       logprintf (LOG_NOTQUIET,
 194                  _("Unable to convert `%s' to a bind address.  Reverting to ANY.\n"),
 195                  opt.bind_address);
 196       return 0;
 197     }
 198
 199   /* Pick the first address in the list and use it as bind address.
 200      Perhaps we should try multiple addresses, but I don't think
 201      that's necessary in practice.  */
 202   sockaddr_set_data (sa, address_list_address_at (al, 0), 0);
 203   address_list_release (al);
 204   return 1;
 205 }
 206 \f
 207 struct cwt_context {
 208   int fd;
 209   const struct sockaddr *addr;
 210   socklen_t addrlen;
 211   int result;
 212 };
 213
 214 static void
 215 connect_with_timeout_callback (void *arg)
 216 {
 217   struct cwt_context *ctx = (struct cwt_context *)arg;
 218   ctx->result = connect (ctx->fd, ctx->addr, ctx->addrlen);
 219 }
 220
 221 /* Like connect, but specifies a timeout.  If connecting takes longer
 222    than TIMEOUT seconds, -1 is returned and errno is set to
 223    ETIMEDOUT.  */
 224
 225 static int
 226 connect_with_timeout (int fd, const struct sockaddr *addr, socklen_t addrlen,
 227                       double timeout)
 228 {
 229   struct cwt_context ctx;
 230   ctx.fd = fd;
 231   ctx.addr = addr;
 232   ctx.addrlen = addrlen;
 233
 234   if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
 235     {
 236       errno = ETIMEDOUT;
 237       return -1;
 238     }
 239   if (ctx.result == -1 && errno == EINTR)
 240     errno = ETIMEDOUT;
 241   return ctx.result;
 242 }
 243 \f
 244 /* Connect to a remote endpoint whose IP address is known.  */
 245
 246 int
 247 connect_to_ip (const ip_address *ip, int port, const char *print)
 248 {
 249   struct sockaddr_storage ss;
 250   struct sockaddr *sa = (struct sockaddr *)&ss;
 251   int sock, save_errno;
 252
 253   /* If PRINT is non-NULL, print the "Connecting to..." line, with
 254      PRINT being the host name we're connecting to.  */
 255   if (print)
 256     {
 257       const char *txt_addr = pretty_print_address (ip);
 258       if (print && 0 != strcmp (print, txt_addr))
 259         logprintf (LOG_VERBOSE,
 260                    _("Connecting to %s{%s}:%d... "), print, txt_addr, port);
 261       else
 262         logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port);
 263     }
 264
 265   /* Store the sockaddr info to SA.  */
 266   sockaddr_set_data (sa, ip, port);
 267
 268   /* Create the socket of the family appropriate for the address.  */
 269   sock = socket (sa->sa_family, SOCK_STREAM, 0);
 270   if (sock < 0)
 271     goto out;
 272
 273   /* For very small rate limits, set the buffer size (and hence,
 274      hopefully, the kernel's TCP window size) to the per-second limit.
 275      That way we should never have to sleep for more than 1s between
 276      network reads.  */
 277   if (opt.limit_rate && opt.limit_rate < 8192)
 278     {
 279       int bufsize = opt.limit_rate;
 280       if (bufsize < 512)
 281         bufsize = 512;          /* avoid pathologically small values */
 282 #ifdef SO_RCVBUF
 283       setsockopt (sock, SOL_SOCKET, SO_RCVBUF,
 284                   (void *)&bufsize, (socklen_t)sizeof (bufsize));
 285 #endif
 286       /* When we add limit_rate support for writing, which is useful
 287          for POST, we should also set SO_SNDBUF here.  */
 288     }
 289
 290   if (opt.bind_address)
 291     {
 292       /* Bind the client side of the socket to the requested
 293          address.  */
 294       struct sockaddr_storage bind_ss;
 295       struct sockaddr *bind_sa = (struct sockaddr *)&bind_ss;
 296       if (resolve_bind_address (opt.bind_address, bind_sa, 0))
 297         {
 298           if (bind (sock, bind_sa, sockaddr_size (bind_sa)) < 0)
 299             {
 300               CLOSE (sock);
 301               sock = -1;
 302               goto out;
 303             }
 304         }
 305     }
 306
 307   /* Connect the socket to the remote endpoint.  */
 308   if (connect_with_timeout (sock, sa, sockaddr_size (sa),
 309                             opt.connect_timeout) < 0)
 310     {
 311       CLOSE (sock);
 312       sock = -1;
 313       goto out;
 314     }
 315
 316  out:
 317   if (sock >= 0)
 318     {
 319       /* Success. */
 320       if (print)
 321         logprintf (LOG_VERBOSE, _("connected.\n"));
 322       DEBUGP (("Created socket %d.\n", sock));
 323     }
 324   else
 325     {
 326       save_errno = errno;
 327       if (print)
 328         logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
 329       errno = save_errno;
 330     }
 331
 332   return sock;
 333 }
 334
 335 /* Connect to a remote endpoint specified by host name.  */
 336
 337 int
 338 connect_to_host (const char *host, int port)
 339 {
 340   int i, start, end;
 341   struct address_list *al;
 342   int sock = -1;
 343
 344  again:
 345   al = lookup_host (host, 0);
 346   if (!al)
 347     return E_HOST;
 348
 349   address_list_get_bounds (al, &start, &end);
 350   for (i = start; i < end; i++)
 351     {
 352       const ip_address *ip = address_list_address_at (al, i);
 353       sock = connect_to_ip (ip, port, host);
 354       if (sock >= 0)
 355         /* Success. */
 356         break;
 357
 358       address_list_set_faulty (al, i);
 359
 360       /* The attempt to connect has failed.  Continue with the loop
 361          and try next address. */
 362     }
 363   address_list_release (al);
 364
 365   if (sock < 0 && address_list_cached_p (al))
 366     {
 367       /* We were unable to connect to any address in a list we've
 368          obtained from cache.  There is a possibility that the host is
 369          under dynamic DNS and has changed its address.  Resolve it
 370          again.  */
 371       forget_host_lookup (host);
 372       goto again;
 373     }
 374
 375   return sock;
 376 }
 377
 378 int
 379 test_socket_open (int sock)
 380 {
 381 #ifdef HAVE_SELECT
 382   fd_set check_set;
 383   struct timeval to;
 384
 385   /* Check if we still have a valid (non-EOF) connection.  From Andrew
 386    * Maholski's code in the Unix Socket FAQ.  */
 387
 388   FD_ZERO (&check_set);
 389   FD_SET (sock, &check_set);
 390
 391   /* Wait one microsecond */
 392   to.tv_sec = 0;
 393   to.tv_usec = 1;
 394
 395   /* If we get a timeout, then that means still connected */
 396   if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
 397     {
 398       /* Connection is valid (not EOF), so continue */
 399       return 1;
 400     }
 401   else
 402     return 0;
 403 #else
 404   /* Without select, it's hard to know for sure. */
 405   return 1;
 406 #endif
 407 }
 408
 409 /* Create a socket and bind it to PORT locally.  Calling accept() on
 410    such a socket waits for and accepts incoming TCP connections.  The
 411    resulting socket is stored to LOCAL_SOCK.  */
 412
 413 uerr_t
 414 bindport (const ip_address *bind_address, int *port, int *local_sock)
 415 {
 416   int msock;
 417   int family = AF_INET;
 418   int optval;
 419   struct sockaddr_storage ss;
 420   struct sockaddr *sa = (struct sockaddr *)&ss;
 421   memset (&ss, 0, sizeof (ss));
 422
 423 #ifdef ENABLE_IPV6
 424   if (bind_address->type == IPV6_ADDRESS)
 425     family = AF_INET6;
 426 #endif
 427
 428   if ((msock = socket (family, SOCK_STREAM, 0)) < 0)
 429     return CONSOCKERR;
 430
 431 #ifdef SO_REUSEADDR
 432   optval = 1;
 433   if (setsockopt (msock, SOL_SOCKET, SO_REUSEADDR,
 434                   (void *)&optval, (socklen_t)sizeof (optval)) < 0)
 435     {
 436       CLOSE (msock);
 437       return CONSOCKERR;
 438     }
 439 #endif
 440
 441 #ifdef ENABLE_IPV6
 442 # ifdef HAVE_IPV6_V6ONLY
 443   if (family == AF_INET6)
 444     {
 445       optval = 1;
 446       /* if setsockopt fails, go on anyway */
 447       setsockopt (msock, IPPROTO_IPV6, IPV6_V6ONLY,
 448                   (void *)&optval, (socklen_t)sizeof (optval));
 449     }
 450 # endif
 451 #endif
 452
 453   sockaddr_set_data (sa, bind_address, *port);
 454   if (bind (msock, sa, sockaddr_size (sa)) < 0)
 455     {
 456       CLOSE (msock);
 457       return BINDERR;
 458     }
 459   DEBUGP (("Local socket fd %d bound.\n", msock));
 460   if (!*port)
 461     {
 462       socklen_t sa_len = sockaddr_size (sa);
 463       if (getsockname (msock, sa, &sa_len) < 0)
 464         {
 465           CLOSE (msock);
 466           return CONPORTERR;
 467         }
 468       sockaddr_get_data (sa, NULL, port);
 469       DEBUGP (("binding to address %s using port %i.\n",
 470                pretty_print_address (bind_address), *port));
 471     }
 472   if (listen (msock, 1) < 0)
 473     {
 474       CLOSE (msock);
 475       return LISTENERR;
 476     }
 477   *local_sock = msock;
 478   return BINDOK;
 479 }
 480
 481 #ifdef HAVE_SELECT
 482 /* Wait for file descriptor FD to be available, timing out after
 483    MAXTIME seconds.  "Available" means readable if writep is 0,
 484    writeable otherwise.
 485
 486    Returns 1 if FD is available, 0 for timeout and -1 for error.  */
 487
 488 int
 489 select_fd (int fd, double maxtime, int writep)
 490 {
 491   fd_set fds;
 492   fd_set *rd = NULL, *wrt = NULL;
 493   struct timeval tmout;
 494   int result;
 495
 496   FD_ZERO (&fds);
 497   FD_SET (fd, &fds);
 498   *(writep ? &wrt : &rd) = &fds;
 499
 500   tmout.tv_sec = (long)maxtime;
 501   tmout.tv_usec = 1000000L * (maxtime - (long)maxtime);
 502
 503   do
 504     result = select (fd + 1, rd, wrt, NULL, &tmout);
 505   while (result < 0 && errno == EINTR);
 506
 507   /* When we've timed out, set errno to ETIMEDOUT for the convenience
 508      of the caller. */
 509   if (result == 0)
 510     errno = ETIMEDOUT;
 511
 512   return result;
 513 }
 514 #endif /* HAVE_SELECT */
 515
 516 /* Accept a connection on LOCAL_SOCK, and store the new socket to
 517    *SOCK.  It blocks the caller until a connection is established.  If
 518    no connection is established for opt.connect_timeout seconds, the
 519    function exits with an error status.  */
 520
 521 uerr_t
 522 acceptport (int local_sock, int *sock)
 523 {
 524   struct sockaddr_storage ss;
 525   struct sockaddr *sa = (struct sockaddr *)&ss;
 526   socklen_t addrlen = sizeof (ss);
 527
 528 #ifdef HAVE_SELECT
 529   if (select_fd (local_sock, opt.connect_timeout, 0) <= 0)
 530     return ACCEPTERR;
 531 #endif
 532   if ((*sock = accept (local_sock, sa, &addrlen)) < 0)
 533     return ACCEPTERR;
 534   DEBUGP (("Created socket fd %d.\n", *sock));
 535   return ACCEPTOK;
 536 }
 537
 538 /* Return the local IP address associated with the connection on FD.  */
 539
 540 int
 541 conaddr (int fd, ip_address *ip)
 542 {
 543   struct sockaddr_storage storage;
 544   struct sockaddr *sockaddr = (struct sockaddr *)&storage;
 545   socklen_t addrlen = sizeof (storage);
 546
 547   if (getsockname (fd, sockaddr, &addrlen) < 0)
 548     return 0;
 549
 550   switch (sockaddr->sa_family)
 551     {
 552 #ifdef ENABLE_IPV6
 553     case AF_INET6:
 554       {
 555         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&storage;
 556         ip->type = IPV6_ADDRESS;
 557         ADDRESS_IPV6_IN6_ADDR (ip) = sa6->sin6_addr;
 558 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
 559         ADDRESS_IPV6_SCOPE (ip) = sa6->sin6_scope_id;
 560 #endif
 561         DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
 562         return 1;
 563       }
 564 #endif
 565     case AF_INET:
 566       {
 567         struct sockaddr_in *sa = (struct sockaddr_in *)&storage;
 568         ip->type = IPV4_ADDRESS;
 569         ADDRESS_IPV4_IN_ADDR (ip) = sa->sin_addr;
 570         DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
 571         return 1;
 572       }
 573     default:
 574       abort ();
 575     }
 576
 577   return 0;
 578 }
 579
 580 /* Read at most LEN bytes from FD, storing them to BUF.  This is
 581    virtually the same as read(), but takes care of EINTR braindamage
 582    and uses select() to timeout the stale connections (a connection is
 583    stale if more than OPT.READ_TIMEOUT time is spent in select() or
 584    read()).  */
 585
 586 int
 587 iread (int fd, char *buf, int len)
 588 {
 589   int res;
 590
 591 #ifdef HAVE_SELECT
 592   if (opt.read_timeout)
 593     if (select_fd (fd, opt.read_timeout, 0) <= 0)
 594       return -1;
 595 #endif
 596   do
 597     res = READ (fd, buf, len);
 598   while (res == -1 && errno == EINTR);
 599
 600   return res;
 601 }
 602
 603 /* Write LEN bytes from BUF to FD.  This is similar to iread(), but
 604    unlike iread(), it makes sure that all of BUF is actually written
 605    to FD, so callers needn't bother with checking that the return
 606    value equals to LEN.  Instead, you should simply check for -1.  */
 607
 608 int
 609 iwrite (int fd, char *buf, int len)
 610 {
 611   int res = 0;
 612
 613   /* `write' may write less than LEN bytes, thus the outward loop
 614      keeps trying it until all was written, or an error occurred.  The
 615      inner loop is reserved for the usual EINTR f*kage, and the
 616      innermost loop deals with the same during select().  */
 617   while (len > 0)
 618     {
 619 #ifdef HAVE_SELECT
 620       if (opt.read_timeout)
 621         if (select_fd (fd, opt.read_timeout, 1) <= 0)
 622           return -1;
 623 #endif
 624       do
 625         res = WRITE (fd, buf, len);
 626       while (res == -1 && errno == EINTR);
 627       if (res <= 0)
 628         break;
 629       buf += res;
 630       len -= res;
 631     }
 632   return res;
 633 }