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. */
23 #include <sys/types.h>
32 # include <sys/socket.h>
34 # include <netinet/in.h>
36 # include <arpa/inet.h>
45 #endif /* HAVE_STRING_H */
46 #ifdef HAVE_SYS_SELECT_H
47 # include <sys/select.h>
48 #endif /* HAVE_SYS_SELECT_H */
59 /* Variables shared by bindport and acceptport: */
60 static int msock = -1;
61 static struct sockaddr *addr;
63 static ip_address bind_address;
64 static int bind_address_resolved;
67 resolve_bind_address (void)
69 struct address_list *al;
71 if (bind_address_resolved || opt.bind_address == NULL)
75 al = lookup_host (opt.bind_address, 1);
78 logprintf (LOG_NOTQUIET,
79 _("Unable to convert `%s' to a bind address. Reverting to ANY.\n"),
84 address_list_copy_one (al, 0, &bind_address);
85 address_list_release (al);
86 bind_address_resolved = 1;
91 const struct sockaddr *addr;
97 connect_with_timeout_callback (void *arg)
99 struct cwt_context *ctx = (struct cwt_context *)arg;
100 ctx->result = connect (ctx->fd, ctx->addr, ctx->addrlen);
103 /* Like connect, but specifies a timeout. If connecting takes longer
104 than TIMEOUT seconds, -1 is returned and errno is set to
108 connect_with_timeout (int fd, const struct sockaddr *addr, int addrlen,
111 struct cwt_context ctx;
114 ctx.addrlen = addrlen;
116 if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
121 if (ctx.result == -1 && errno == EINTR)
126 /* A kludge, but still better than passing the host name all the way
127 to connect_to_one. */
128 static const char *connection_host_name;
131 set_connection_host_name (const char *host)
134 assert (connection_host_name == NULL);
136 assert (connection_host_name != NULL);
138 connection_host_name = host;
141 /* Connect to a remote host whose address has been resolved. */
143 connect_to_one (ip_address *addr, unsigned short port, int silent)
146 int sock, save_errno;
148 /* Set port and protocol */
149 wget_sockaddr_set_address (&sa, ip_default_family, port, addr);
153 char *pretty_addr = pretty_print_address (addr);
154 if (connection_host_name
155 && 0 != strcmp (connection_host_name, pretty_addr))
156 logprintf (LOG_VERBOSE, _("Connecting to %s[%s]:%hu... "),
157 connection_host_name, pretty_addr, port);
159 logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "),
163 /* Make an internet socket, stream type. */
164 sock = socket (ip_default_family, SOCK_STREAM, 0);
168 resolve_bind_address ();
169 if (bind_address_resolved)
171 /* Bind the client side to the requested address. */
173 wget_sockaddr_set_address (&bsa, ip_default_family, 0, &bind_address);
174 if (bind (sock, &bsa.sa, sockaddr_len ()))
182 /* Connect the socket to the remote host. */
183 if (connect_with_timeout (sock, &sa.sa, sockaddr_len (), opt.timeout) < 0)
195 logprintf (LOG_VERBOSE, _("connected.\n"));
196 DEBUGP (("Created socket %d.\n", sock));
202 logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
209 /* Connect to a remote host whose address has been resolved. */
211 connect_to_many (struct address_list *al, unsigned short port, int silent)
215 address_list_get_bounds (al, &start, &end);
216 for (i = start; i < end; i++)
220 address_list_copy_one (al, i, &addr);
222 sock = connect_to_one (&addr, port, silent);
227 address_list_set_faulty (al, i);
229 /* The attempt to connect has failed. Continue with the loop
230 and try next address. */
237 test_socket_open (int sock)
243 /* Check if we still have a valid (non-EOF) connection. From Andrew
244 * Maholski's code in the Unix Socket FAQ. */
246 FD_ZERO (&check_set);
247 FD_SET (sock, &check_set);
249 /* Wait one microsecond */
253 /* If we get a timeout, then that means still connected */
254 if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
256 /* Connection is valid (not EOF), so continue */
262 /* Without select, it's hard to know for sure. */
267 /* Bind the local port PORT. This does all the necessary work, which
268 is creating a socket, setting SO_REUSEADDR option on it, then
269 calling bind() and listen(). If *PORT is 0, a random port is
270 chosen by the system, and its value is stored to *PORT. The
271 internal variable MPORT is set to the value of the ensuing master
272 socket. Call acceptport() to block for and accept a connection. */
274 bindport (unsigned short *port, int family)
278 memset (&srv, 0, sizeof (wget_sockaddr));
282 if ((msock = socket (family, SOCK_STREAM, 0)) < 0)
284 if (setsockopt (msock, SOL_SOCKET, SO_REUSEADDR,
285 (char *)&optval, sizeof (optval)) < 0)
288 resolve_bind_address ();
289 wget_sockaddr_set_address (&srv, ip_default_family, htons (*port),
290 bind_address_resolved ? &bind_address : NULL);
291 if (bind (msock, &srv.sa, sockaddr_len ()) < 0)
297 DEBUGP (("Master socket fd %d bound.\n", msock));
300 /* #### addrlen should be a 32-bit type, which int is not
301 guaranteed to be. Oh, and don't try to make it a size_t,
302 because that can be 64-bit. */
303 int sa_len = sockaddr_len ();
304 if (getsockname (msock, &srv.sa, &sa_len) < 0)
310 *port = wget_sockaddr_get_port (&srv);
311 DEBUGP (("using port %i.\n", *port));
313 if (listen (msock, 1) < 0)
323 /* Wait for file descriptor FD to be readable, MAXTIME being the
324 timeout in seconds. If WRITEP is non-zero, checks for FD being
327 Returns 1 if FD is accessible, 0 for timeout and -1 for error in
330 select_fd (int fd, int maxtime, int writep)
332 fd_set fds, exceptfds;
333 struct timeval timeout;
337 FD_ZERO (&exceptfds);
338 FD_SET (fd, &exceptfds);
339 timeout.tv_sec = maxtime;
341 /* HPUX reportedly warns here. What is the correct incantation? */
342 return select (fd + 1, writep ? NULL : &fds, writep ? &fds : NULL,
343 &exceptfds, &timeout);
345 #endif /* HAVE_SELECT */
347 /* Call accept() on MSOCK and store the result to *SOCK. This assumes
348 that bindport() has been used to initialize MSOCK to a correct
349 value. It blocks the caller until a connection is established. If
350 no connection is established for OPT.TIMEOUT seconds, the function
351 exits with an error status. */
353 acceptport (int *sock)
355 int addrlen = sockaddr_len ();
358 if (select_fd (msock, opt.timeout, 0) <= 0)
361 if ((*sock = accept (msock, addr, &addrlen)) < 0)
363 DEBUGP (("Created socket fd %d.\n", *sock));
367 /* Close SOCK, as well as the most recently remembered MSOCK, created
368 via bindport(). If SOCK is -1, close MSOCK only. */
372 /*shutdown (sock, 2);*/
380 /* Return the local IP address associated with the connection on FD. */
383 conaddr (int fd, ip_address *ip)
387 /* see bindport() for discussion of using `int' here. */
388 int addrlen = sizeof (mysrv);
390 if (getsockname (fd, &mysrv.sa, (int *)&addrlen) < 0)
393 switch (mysrv.sa.sa_family)
397 memcpy (ip, &mysrv.sin6.sin6_addr, 16);
401 map_ipv4_to_ip ((ip4_address *)&mysrv.sin.sin_addr, ip);
409 /* Read at most LEN bytes from FD, storing them to BUF. This is
410 virtually the same as read(), but takes care of EINTR braindamage
411 and uses select() to timeout the stale connections (a connection is
412 stale if more than OPT.TIMEOUT time is spent in select() or
415 iread (int fd, char *buf, int len)
426 res = select_fd (fd, opt.timeout, 0);
428 while (res == -1 && errno == EINTR);
431 /* Set errno to ETIMEDOUT on timeout. */
433 /* #### Potentially evil! */
439 res = READ (fd, buf, len);
441 while (res == -1 && errno == EINTR);
446 /* Write LEN bytes from BUF to FD. This is similar to iread(), but
447 doesn't bother with select(). Unlike iread(), it makes sure that
448 all of BUF is actually written to FD, so callers needn't bother
449 with checking that the return value equals to LEN. Instead, you
450 should simply check for -1. */
452 iwrite (int fd, char *buf, int len)
456 /* `write' may write less than LEN bytes, thus the outward loop
457 keeps trying it until all was written, or an error occurred. The
458 inner loop is reserved for the usual EINTR f*kage, and the
459 innermost loop deals with the same during select(). */
469 res = select_fd (fd, opt.timeout, 1);
471 while (res == -1 && errno == EINTR);
474 /* Set errno to ETIMEDOUT on timeout. */
481 res = WRITE (fd, buf, len);
483 while (res == -1 && errno == EINTR);