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. */
33 #include <sys/types.h>
42 # include <sys/socket.h>
44 # include <netinet/in.h>
46 # include <arpa/inet.h>
55 #endif /* HAVE_STRING_H */
56 #ifdef HAVE_SYS_SELECT_H
57 # include <sys/select.h>
58 #endif /* HAVE_SYS_SELECT_H */
69 /* Variables shared by bindport and acceptport: */
70 static int msock = -1;
71 static struct sockaddr *addr;
73 static ip_address bind_address;
74 static int bind_address_resolved;
77 resolve_bind_address (void)
79 struct address_list *al;
81 if (bind_address_resolved || opt.bind_address == NULL)
85 al = lookup_host (opt.bind_address, 1);
88 logprintf (LOG_NOTQUIET,
89 _("Unable to convert `%s' to a bind address. Reverting to ANY.\n"),
94 address_list_copy_one (al, 0, &bind_address);
95 address_list_release (al);
96 bind_address_resolved = 1;
101 const struct sockaddr *addr;
107 connect_with_timeout_callback (void *arg)
109 struct cwt_context *ctx = (struct cwt_context *)arg;
110 ctx->result = connect (ctx->fd, ctx->addr, ctx->addrlen);
113 /* Like connect, but specifies a timeout. If connecting takes longer
114 than TIMEOUT seconds, -1 is returned and errno is set to
118 connect_with_timeout (int fd, const struct sockaddr *addr, int addrlen,
121 struct cwt_context ctx;
124 ctx.addrlen = addrlen;
126 if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
131 if (ctx.result == -1 && errno == EINTR)
136 /* A kludge, but still better than passing the host name all the way
137 to connect_to_one. */
138 static const char *connection_host_name;
141 set_connection_host_name (const char *host)
144 assert (connection_host_name == NULL);
146 assert (connection_host_name != NULL);
148 connection_host_name = host;
151 /* Connect to a remote host whose address has been resolved. */
153 connect_to_one (ip_address *addr, unsigned short port, int silent)
156 int sock, save_errno;
158 /* Set port and protocol */
159 wget_sockaddr_set_address (&sa, ip_default_family, port, addr);
163 char *pretty_addr = pretty_print_address (addr);
164 if (connection_host_name
165 && 0 != strcmp (connection_host_name, pretty_addr))
166 logprintf (LOG_VERBOSE, _("Connecting to %s[%s]:%hu... "),
167 connection_host_name, pretty_addr, port);
169 logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "),
173 /* Make an internet socket, stream type. */
174 sock = socket (ip_default_family, SOCK_STREAM, 0);
178 resolve_bind_address ();
179 if (bind_address_resolved)
181 /* Bind the client side to the requested address. */
183 wget_sockaddr_set_address (&bsa, ip_default_family, 0, &bind_address);
184 if (bind (sock, &bsa.sa, sockaddr_len ()))
192 /* Connect the socket to the remote host. */
193 if (connect_with_timeout (sock, &sa.sa, sockaddr_len (), opt.timeout) < 0)
205 logprintf (LOG_VERBOSE, _("connected.\n"));
206 DEBUGP (("Created socket %d.\n", sock));
212 logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
219 /* Connect to a remote host whose address has been resolved. */
221 connect_to_many (struct address_list *al, unsigned short port, int silent)
225 address_list_get_bounds (al, &start, &end);
226 for (i = start; i < end; i++)
230 address_list_copy_one (al, i, &addr);
232 sock = connect_to_one (&addr, port, silent);
237 address_list_set_faulty (al, i);
239 /* The attempt to connect has failed. Continue with the loop
240 and try next address. */
247 test_socket_open (int sock)
253 /* Check if we still have a valid (non-EOF) connection. From Andrew
254 * Maholski's code in the Unix Socket FAQ. */
256 FD_ZERO (&check_set);
257 FD_SET (sock, &check_set);
259 /* Wait one microsecond */
263 /* If we get a timeout, then that means still connected */
264 if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
266 /* Connection is valid (not EOF), so continue */
272 /* Without select, it's hard to know for sure. */
277 /* Bind the local port PORT. This does all the necessary work, which
278 is creating a socket, setting SO_REUSEADDR option on it, then
279 calling bind() and listen(). If *PORT is 0, a random port is
280 chosen by the system, and its value is stored to *PORT. The
281 internal variable MPORT is set to the value of the ensuing master
282 socket. Call acceptport() to block for and accept a connection. */
284 bindport (unsigned short *port, int family)
288 memset (&srv, 0, sizeof (wget_sockaddr));
292 if ((msock = socket (family, SOCK_STREAM, 0)) < 0)
294 if (setsockopt (msock, SOL_SOCKET, SO_REUSEADDR,
295 (char *)&optval, sizeof (optval)) < 0)
298 resolve_bind_address ();
299 wget_sockaddr_set_address (&srv, ip_default_family, htons (*port),
300 bind_address_resolved ? &bind_address : NULL);
301 if (bind (msock, &srv.sa, sockaddr_len ()) < 0)
307 DEBUGP (("Master socket fd %d bound.\n", msock));
310 /* #### addrlen should be a 32-bit type, which int is not
311 guaranteed to be. Oh, and don't try to make it a size_t,
312 because that can be 64-bit. */
313 int sa_len = sockaddr_len ();
314 if (getsockname (msock, &srv.sa, &sa_len) < 0)
320 *port = wget_sockaddr_get_port (&srv);
321 DEBUGP (("using port %i.\n", *port));
323 if (listen (msock, 1) < 0)
333 /* Wait for file descriptor FD to be available, timing out after
334 MAXTIME seconds. "Available" means readable if writep is 0,
337 Returns 1 if FD is available, 0 for timeout and -1 for error. */
340 select_fd (int fd, int maxtime, int writep)
343 fd_set *rd = NULL, *wrt = NULL;
344 struct timeval tmout;
349 *(writep ? &wrt : &rd) = &fds;
351 tmout.tv_sec = maxtime;
355 result = select (fd + 1, rd, wrt, NULL, &tmout);
356 while (result < 0 && errno == EINTR);
358 /* When we've timed out, set errno to ETIMEDOUT for the convenience
365 #endif /* HAVE_SELECT */
367 /* Call accept() on MSOCK and store the result to *SOCK. This assumes
368 that bindport() has been used to initialize MSOCK to a correct
369 value. It blocks the caller until a connection is established. If
370 no connection is established for OPT.TIMEOUT seconds, the function
371 exits with an error status. */
373 acceptport (int *sock)
375 int addrlen = sockaddr_len ();
378 if (select_fd (msock, opt.timeout, 0) <= 0)
381 if ((*sock = accept (msock, addr, &addrlen)) < 0)
383 DEBUGP (("Created socket fd %d.\n", *sock));
387 /* Close SOCK, as well as the most recently remembered MSOCK, created
388 via bindport(). If SOCK is -1, close MSOCK only. */
392 /*shutdown (sock, 2);*/
400 /* Return the local IP address associated with the connection on FD. */
403 conaddr (int fd, ip_address *ip)
407 /* see bindport() for discussion of using `int' here. */
408 int addrlen = sizeof (mysrv);
410 if (getsockname (fd, &mysrv.sa, (int *)&addrlen) < 0)
413 switch (mysrv.sa.sa_family)
417 memcpy (ip, &mysrv.sin6.sin6_addr, 16);
421 map_ipv4_to_ip ((ip4_address *)&mysrv.sin.sin_addr, ip);
429 /* Read at most LEN bytes from FD, storing them to BUF. This is
430 virtually the same as read(), but takes care of EINTR braindamage
431 and uses select() to timeout the stale connections (a connection is
432 stale if more than OPT.TIMEOUT time is spent in select() or
436 iread (int fd, char *buf, int len)
442 if (select_fd (fd, opt.timeout, 0) <= 0)
446 res = READ (fd, buf, len);
447 while (res == -1 && errno == EINTR);
452 /* Write LEN bytes from BUF to FD. This is similar to iread(), but
453 unlike iread(), it makes sure that all of BUF is actually written
454 to FD, so callers needn't bother with checking that the return
455 value equals to LEN. Instead, you should simply check for -1. */
458 iwrite (int fd, char *buf, int len)
462 /* `write' may write less than LEN bytes, thus the outward loop
463 keeps trying it until all was written, or an error occurred. The
464 inner loop is reserved for the usual EINTR f*kage, and the
465 innermost loop deals with the same during select(). */
470 if (select_fd (fd, opt.timeout, 1) <= 0)
474 res = WRITE (fd, buf, len);
475 while (res == -1 && errno == EINTR);