1 /* Establishing and handling network connections.
2 Copyright (C) 1995, 1996, 1997, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of GNU Wget.
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.
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.
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.
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. */
34 #include <sys/types.h>
41 # include <sys/socket.h>
43 # include <netinet/in.h>
45 # include <arpa/inet.h>
47 #endif /* not WINDOWS */
54 #endif /* HAVE_STRING_H */
55 #ifdef HAVE_SYS_SELECT_H
56 # include <sys/select.h>
57 #endif /* HAVE_SYS_SELECT_H */
70 /* Fill SA as per the data in IP and PORT. SA shoult point to struct
71 sockaddr_storage if ENABLE_IPV6 is defined, to struct sockaddr_in
75 sockaddr_set_data (struct sockaddr *sa, const ip_address *ip, int port)
81 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
82 sin->sin_family = AF_INET;
83 sin->sin_port = htons (port);
84 sin->sin_addr = ADDRESS_IPV4_IN_ADDR (ip);
90 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
91 sin6->sin6_family = AF_INET6;
92 sin6->sin6_port = htons (port);
93 sin6->sin6_addr = ADDRESS_IPV6_IN6_ADDR (ip);
94 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
95 sin6->sin6_scope_id = ADDRESS_IPV6_SCOPE (ip);
99 #endif /* ENABLE_IPV6 */
105 /* Get the data of SA, specifically the IP address and the port. If
106 you're not interested in one or the other information, pass NULL as
110 sockaddr_get_data (const struct sockaddr *sa, ip_address *ip, int *port)
112 switch (sa->sa_family)
116 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
119 ip->type = IPV4_ADDRESS;
120 ADDRESS_IPV4_IN_ADDR (ip) = sin->sin_addr;
123 *port = ntohs (sin->sin_port);
129 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
132 ip->type = IPV6_ADDRESS;
133 ADDRESS_IPV6_IN6_ADDR (ip) = sin6->sin6_addr;
134 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
135 ADDRESS_IPV6_SCOPE (ip) = sin6->sin6_scope_id;
139 *port = ntohs (sin6->sin6_port);
148 /* Return the size of the sockaddr structure depending on its
152 sockaddr_size (const struct sockaddr *sa)
154 switch (sa->sa_family)
157 return sizeof (struct sockaddr_in);
160 return sizeof (struct sockaddr_in6);
164 return 0; /* so the compiler shuts up. */
169 resolve_bind_address (const char *host, struct sockaddr *sa, int flags)
171 struct address_list *al;
173 /* #### Shouldn't we do this only once? opt.bind_address won't
174 change during a Wget run! */
176 al = lookup_host (host, flags | LH_SILENT | LH_PASSIVE);
179 /* #### We should print the error message here. */
180 logprintf (LOG_NOTQUIET,
181 _("%s: unable to resolve bind address `%s'; disabling bind.\n"),
182 exec_name, opt.bind_address);
186 /* Pick the first address in the list and use it as bind address.
187 Perhaps we should try multiple addresses, but I don't think
188 that's necessary in practice. */
189 sockaddr_set_data (sa, address_list_address_at (al, 0), 0);
190 address_list_release (al);
196 const struct sockaddr *addr;
202 connect_with_timeout_callback (void *arg)
204 struct cwt_context *ctx = (struct cwt_context *)arg;
205 ctx->result = connect (ctx->fd, ctx->addr, ctx->addrlen);
208 /* Like connect, but specifies a timeout. If connecting takes longer
209 than TIMEOUT seconds, -1 is returned and errno is set to
213 connect_with_timeout (int fd, const struct sockaddr *addr, socklen_t addrlen,
216 struct cwt_context ctx;
219 ctx.addrlen = addrlen;
221 if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
226 if (ctx.result == -1 && errno == EINTR)
231 /* Connect to a remote endpoint whose IP address is known. */
234 connect_to_ip (const ip_address *ip, int port, const char *print)
236 struct sockaddr_storage ss;
237 struct sockaddr *sa = (struct sockaddr *)&ss;
240 /* If PRINT is non-NULL, print the "Connecting to..." line, with
241 PRINT being the host name we're connecting to. */
244 const char *txt_addr = pretty_print_address (ip);
245 if (print && 0 != strcmp (print, txt_addr))
246 logprintf (LOG_VERBOSE,
247 _("Connecting to %s|%s|:%d... "), print, txt_addr, port);
249 logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port);
252 /* Store the sockaddr info to SA. */
253 sockaddr_set_data (sa, ip, port);
255 /* Create the socket of the family appropriate for the address. */
256 sock = socket (sa->sa_family, SOCK_STREAM, 0);
260 /* For very small rate limits, set the buffer size (and hence,
261 hopefully, the kernel's TCP window size) to the per-second limit.
262 That way we should never have to sleep for more than 1s between
264 if (opt.limit_rate && opt.limit_rate < 8192)
266 int bufsize = opt.limit_rate;
268 bufsize = 512; /* avoid pathologically small values */
270 setsockopt (sock, SOL_SOCKET, SO_RCVBUF,
271 (void *)&bufsize, (socklen_t)sizeof (bufsize));
273 /* When we add limit_rate support for writing, which is useful
274 for POST, we should also set SO_SNDBUF here. */
277 if (opt.bind_address)
279 /* Bind the client side of the socket to the requested
281 struct sockaddr_storage bind_ss;
282 struct sockaddr *bind_sa = (struct sockaddr *)&bind_ss;
283 if (resolve_bind_address (opt.bind_address, bind_sa, 0))
285 if (bind (sock, bind_sa, sockaddr_size (bind_sa)) < 0)
290 /* Connect the socket to the remote endpoint. */
291 if (connect_with_timeout (sock, sa, sockaddr_size (sa),
292 opt.connect_timeout) < 0)
298 logprintf (LOG_VERBOSE, _("connected.\n"));
299 DEBUGP (("Created socket %d.\n", sock));
304 /* Protect errno from possible modifications by close and
306 int save_errno = errno;
310 logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
316 /* Connect to a remote endpoint specified by host name. */
319 connect_to_host (const char *host, int port)
322 struct address_list *al;
326 al = lookup_host (host, 0);
330 address_list_get_bounds (al, &start, &end);
331 for (i = start; i < end; i++)
333 const ip_address *ip = address_list_address_at (al, i);
334 sock = connect_to_ip (ip, port, host);
339 address_list_set_faulty (al, i);
341 /* The attempt to connect has failed. Continue with the loop
342 and try next address. */
344 address_list_release (al);
346 if (sock < 0 && address_list_cached_p (al))
348 /* We were unable to connect to any address in a list we've
349 obtained from cache. There is a possibility that the host is
350 under dynamic DNS and has changed its address. Resolve it
352 forget_host_lookup (host);
360 test_socket_open (int sock)
366 /* Check if we still have a valid (non-EOF) connection. From Andrew
367 * Maholski's code in the Unix Socket FAQ. */
369 FD_ZERO (&check_set);
370 FD_SET (sock, &check_set);
372 /* Wait one microsecond */
376 /* If we get a timeout, then that means still connected */
377 if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
379 /* Connection is valid (not EOF), so continue */
385 /* Without select, it's hard to know for sure. */
390 /* Create a socket and bind it to PORT locally. Calling accept() on
391 such a socket waits for and accepts incoming TCP connections. The
392 resulting socket is stored to LOCAL_SOCK. */
395 bindport (const ip_address *bind_address, int *port, int *local_sock)
398 int family = AF_INET;
399 struct sockaddr_storage ss;
400 struct sockaddr *sa = (struct sockaddr *)&ss;
402 /* For setting options with setsockopt. */
404 void *setopt_ptr = (void *)&setopt_val;
405 socklen_t setopt_size = sizeof (setopt_val);
408 if (bind_address->type == IPV6_ADDRESS)
412 if ((sock = socket (family, SOCK_STREAM, 0)) < 0)
416 setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, setopt_ptr, setopt_size);
420 # ifdef HAVE_IPV6_V6ONLY
421 if (family == AF_INET6)
422 setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, setopt_ptr, setopt_size);
427 sockaddr_set_data (sa, bind_address, *port);
428 if (bind (sock, sa, sockaddr_size (sa)) < 0)
433 DEBUGP (("Local socket fd %d bound.\n", sock));
436 socklen_t sa_len = sockaddr_size (sa);
437 if (getsockname (sock, sa, &sa_len) < 0)
442 sockaddr_get_data (sa, NULL, port);
443 DEBUGP (("binding to address %s using port %i.\n",
444 pretty_print_address (bind_address), *port));
446 if (listen (sock, 1) < 0)
456 /* Wait for file descriptor FD to be readable or writable or both,
457 timing out after MAXTIME seconds. Returns 1 if FD is available, 0
458 for timeout and -1 for error. The argument WAIT_FOR can be a
459 combination of WAIT_READ and WAIT_WRITE.
461 This is a mere convenience wrapper around the select call, and
462 should be taken as such. */
465 select_fd (int fd, double maxtime, int wait_for)
468 fd_set *rd = NULL, *wr = NULL;
469 struct timeval tmout;
474 if (wait_for & WAIT_FOR_READ)
476 if (wait_for & WAIT_FOR_WRITE)
479 tmout.tv_sec = (long) maxtime;
480 tmout.tv_usec = 1000000L * (maxtime - (long) maxtime);
483 result = select (fd + 1, rd, wr, NULL, &tmout);
484 while (result < 0 && errno == EINTR);
488 #endif /* HAVE_SELECT */
490 /* Accept a connection on LOCAL_SOCK, and store the new socket to
491 *SOCK. It blocks the caller until a connection is established. If
492 no connection is established for opt.connect_timeout seconds, the
493 function exits with an error status. */
496 acceptport (int local_sock, int *sock)
498 struct sockaddr_storage ss;
499 struct sockaddr *sa = (struct sockaddr *)&ss;
500 socklen_t addrlen = sizeof (ss);
503 if (opt.connect_timeout)
504 if (select_fd (local_sock, opt.connect_timeout, WAIT_FOR_READ) <= 0)
507 if ((*sock = accept (local_sock, sa, &addrlen)) < 0)
509 DEBUGP (("Created socket fd %d.\n", *sock));
513 /* Get the IP address associated with the connection on FD and store
514 it to IP. Return 1 on success, 0 otherwise.
516 If ENDPOINT is ENDPOINT_LOCAL, it returns the address of the local
517 (client) side of the socket. Else if ENDPOINT is ENDPOINT_PEER, it
518 returns the address of the remote (peer's) side of the socket. */
521 socket_ip_address (int sock, ip_address *ip, int endpoint)
523 struct sockaddr_storage storage;
524 struct sockaddr *sockaddr = (struct sockaddr *)&storage;
525 socklen_t addrlen = sizeof (storage);
528 if (endpoint == ENDPOINT_LOCAL)
529 ret = getsockname (sock, sockaddr, &addrlen);
530 else if (endpoint == ENDPOINT_PEER)
531 ret = getpeername (sock, sockaddr, &addrlen);
537 switch (sockaddr->sa_family)
542 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&storage;
543 ip->type = IPV6_ADDRESS;
544 ADDRESS_IPV6_IN6_ADDR (ip) = sa6->sin6_addr;
545 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
546 ADDRESS_IPV6_SCOPE (ip) = sa6->sin6_scope_id;
548 DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
554 struct sockaddr_in *sa = (struct sockaddr_in *)&storage;
555 ip->type = IPV4_ADDRESS;
556 ADDRESS_IPV4_IN_ADDR (ip) = sa->sin_addr;
557 DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
567 /* Basic socket operations, mostly EINTR wrappers. */
570 # define read(fd, buf, cnt) recv (fd, buf, cnt, 0)
571 # define write(fd, buf, cnt) send (fd, buf, cnt, 0)
572 # define close(fd) closesocket (fd)
576 # define read(fd, buf, cnt) recv (fd, buf, cnt, 0)
577 # define write(fd, buf, cnt) send (fd, buf, cnt, 0)
581 sock_read (int fd, char *buf, int bufsize)
585 res = read (fd, buf, bufsize);
586 while (res == -1 && errno == EINTR);
591 sock_write (int fd, char *buf, int bufsize)
595 res = write (fd, buf, bufsize);
596 while (res == -1 && errno == EINTR);
601 sock_poll (int fd, double timeout, int wait_for)
604 return select_fd (fd, timeout, wait_for);
614 DEBUGP (("Closed fd %d\n", fd));
620 /* Reading and writing from the network. We build around the socket
621 (file descriptor) API, but support "extended" operations for things
622 that are not mere file descriptors under the hood, such as SSL
625 That way the user code can call xread(fd, ...) and we'll run read
626 or SSL_read or whatever is necessary. */
628 static struct hash_table *extended_map;
629 static int extended_map_modified_tick;
631 struct extended_info {
640 register_extended (int fd, xreader_t reader, xwriter_t writer,
641 xpoller_t poller, xcloser_t closer, void *ctx)
643 struct extended_info *info;
645 /* The file descriptor must be non-negative to be registered.
646 Negative values are ignored by xclose(), and -1 cannot be used as
650 info = xnew (struct extended_info);
651 info->reader = reader;
652 info->writer = writer;
653 info->poller = poller;
654 info->closer = closer;
657 extended_map = hash_table_new (0, NULL, NULL);
658 hash_table_put (extended_map, (void *) fd, info);
659 ++extended_map_modified_tick;
662 /* When xread/xwrite are called multiple times in a loop, they should
663 remember the INFO pointer instead of fetching it every time. It is
664 not enough to compare FD to LAST_FD because FD might have been
665 closed and reopened. modified_tick ensures that changes to
666 extended_map will not be unnoticed.
668 This is a macro because we want the static storage variables to be
671 #define LAZY_RETRIEVE_INFO(info) do { \
672 static struct extended_info *last_info; \
673 static int last_fd = -1, last_tick; \
676 else if (last_fd == fd && last_tick == extended_map_modified_tick) \
680 info = hash_table_get (extended_map, (void *) fd); \
683 last_tick = extended_map_modified_tick; \
687 /* Read no more than BUFSIZE bytes of data from FD, storing them to
688 BUF. If TIMEOUT is non-zero, the operation aborts if no data is
689 received after that many seconds. If TIMEOUT is -1, the value of
690 opt.timeout is used for TIMEOUT. */
693 xread (int fd, char *buf, int bufsize, double timeout)
695 struct extended_info *info;
696 LAZY_RETRIEVE_INFO (info);
698 timeout = opt.read_timeout;
702 if (info && info->poller)
703 test = info->poller (fd, timeout, WAIT_FOR_READ, info->ctx);
705 test = sock_poll (fd, timeout, WAIT_FOR_READ);
711 if (info && info->reader)
712 return info->reader (fd, buf, bufsize, info->ctx);
714 return sock_read (fd, buf, bufsize);
717 /* Write the entire contents of BUF to FD. If TIMEOUT is non-zero,
718 the operation aborts if no data is received after that many
719 seconds. If TIMEOUT is -1, the value of opt.timeout is used for
723 xwrite (int fd, char *buf, int bufsize, double timeout)
726 struct extended_info *info;
727 LAZY_RETRIEVE_INFO (info);
729 timeout = opt.read_timeout;
731 /* `write' may write less than LEN bytes, thus the loop keeps trying
732 it until all was written, or an error occurred. */
739 if (info && info->poller)
740 test = info->poller (fd, timeout, WAIT_FOR_WRITE, info->ctx);
742 test = sock_poll (fd, timeout, WAIT_FOR_WRITE);
748 if (info && info->writer)
749 res = info->writer (fd, buf, bufsize, info->ctx);
751 res = sock_write (fd, buf, bufsize);
760 /* Close the file descriptor FD. */
765 struct extended_info *info;
769 /* We don't need to be extra-fast here, so save some code by
770 avoiding LAZY_RETRIEVE_INFO. */
773 info = hash_table_get (extended_map, (void *) fd);
775 if (info && info->closer)
776 info->closer (fd, info->ctx);
782 hash_table_remove (extended_map, (void *) fd);
784 ++extended_map_modified_tick;