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 */
58 /* Variables shared by bindport and acceptport: */
59 static int msock = -1;
60 static struct sockaddr *addr;
62 static ip_address bind_address;
63 static int bind_address_resolved;
66 resolve_bind_address (void)
68 struct address_list *al;
70 if (bind_address_resolved || opt.bind_address == NULL)
74 al = lookup_host (opt.bind_address, 1);
77 logprintf (LOG_NOTQUIET,
78 _("Unable to convert `%s' to a bind address. Reverting to ANY.\n"),
83 address_list_copy_one (al, 0, &bind_address);
84 address_list_release (al);
85 bind_address_resolved = 1;
88 /* A kludge, but still better than passing the host name all the way
90 static const char *connection_host_name;
93 set_connection_host_name (const char *host)
96 assert (connection_host_name == NULL);
98 assert (connection_host_name != NULL);
100 connection_host_name = host;
103 /* Connect to a remote host whose address has been resolved. */
105 connect_to_one (ip_address *addr, unsigned short port, int silent)
108 int sock, save_errno;
110 /* Set port and protocol */
111 wget_sockaddr_set_address (&sa, ip_default_family, port, addr);
115 char *pretty_addr = pretty_print_address (addr);
116 if (connection_host_name
117 && 0 != strcmp (connection_host_name, pretty_addr))
118 logprintf (LOG_VERBOSE, _("Connecting to %s[%s]:%hu... "),
119 connection_host_name, pretty_addr, port);
121 logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "),
125 /* Make an internet socket, stream type. */
126 sock = socket (ip_default_family, SOCK_STREAM, 0);
130 resolve_bind_address ();
131 if (bind_address_resolved)
133 /* Bind the client side to the requested address. */
135 wget_sockaddr_set_address (&bsa, ip_default_family, 0, &bind_address);
136 if (bind (sock, &bsa.sa, sockaddr_len ()))
144 /* Connect the socket to the remote host. */
145 if (connect (sock, &sa.sa, sockaddr_len ()) < 0)
157 logprintf (LOG_VERBOSE, _("connected.\n"));
158 DEBUGP (("Created socket %d.\n", sock));
164 logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
171 /* Connect to a remote host whose address has been resolved. */
173 connect_to_many (struct address_list *al, unsigned short port, int silent)
177 address_list_get_bounds (al, &start, &end);
178 for (i = start; i < end; i++)
182 address_list_copy_one (al, i, &addr);
184 sock = connect_to_one (&addr, port, silent);
189 address_list_set_faulty (al, i);
191 /* The attempt to connect has failed. Continue with the loop
192 and try next address. */
199 test_socket_open (int sock)
205 /* Check if we still have a valid (non-EOF) connection. From Andrew
206 * Maholski's code in the Unix Socket FAQ. */
208 FD_ZERO (&check_set);
209 FD_SET (sock, &check_set);
211 /* Wait one microsecond */
215 /* If we get a timeout, then that means still connected */
216 if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
218 /* Connection is valid (not EOF), so continue */
224 /* Without select, it's hard to know for sure. */
229 /* Bind the local port PORT. This does all the necessary work, which
230 is creating a socket, setting SO_REUSEADDR option on it, then
231 calling bind() and listen(). If *PORT is 0, a random port is
232 chosen by the system, and its value is stored to *PORT. The
233 internal variable MPORT is set to the value of the ensuing master
234 socket. Call acceptport() to block for and accept a connection. */
236 bindport (unsigned short *port, int family)
240 memset (&srv, 0, sizeof (wget_sockaddr));
244 if ((msock = socket (family, SOCK_STREAM, 0)) < 0)
246 if (setsockopt (msock, SOL_SOCKET, SO_REUSEADDR,
247 (char *)&optval, sizeof (optval)) < 0)
250 resolve_bind_address ();
251 wget_sockaddr_set_address (&srv, ip_default_family, htons (*port),
252 bind_address_resolved ? &bind_address : NULL);
253 if (bind (msock, &srv.sa, sockaddr_len ()) < 0)
259 DEBUGP (("Master socket fd %d bound.\n", msock));
262 /* #### addrlen should be a 32-bit type, which int is not
263 guaranteed to be. Oh, and don't try to make it a size_t,
264 because that can be 64-bit. */
265 int sa_len = sockaddr_len ();
266 if (getsockname (msock, &srv.sa, &sa_len) < 0)
272 *port = wget_sockaddr_get_port (&srv);
273 DEBUGP (("using port %i.\n", *port));
275 if (listen (msock, 1) < 0)
285 /* Wait for file descriptor FD to be readable, MAXTIME being the
286 timeout in seconds. If WRITEP is non-zero, checks for FD being
289 Returns 1 if FD is accessible, 0 for timeout and -1 for error in
292 select_fd (int fd, int maxtime, int writep)
294 fd_set fds, exceptfds;
295 struct timeval timeout;
299 FD_ZERO (&exceptfds);
300 FD_SET (fd, &exceptfds);
301 timeout.tv_sec = maxtime;
303 /* HPUX reportedly warns here. What is the correct incantation? */
304 return select (fd + 1, writep ? NULL : &fds, writep ? &fds : NULL,
305 &exceptfds, &timeout);
307 #endif /* HAVE_SELECT */
309 /* Call accept() on MSOCK and store the result to *SOCK. This assumes
310 that bindport() has been used to initialize MSOCK to a correct
311 value. It blocks the caller until a connection is established. If
312 no connection is established for OPT.TIMEOUT seconds, the function
313 exits with an error status. */
315 acceptport (int *sock)
317 int addrlen = sockaddr_len ();
320 if (select_fd (msock, opt.timeout, 0) <= 0)
323 if ((*sock = accept (msock, addr, &addrlen)) < 0)
325 DEBUGP (("Created socket fd %d.\n", *sock));
329 /* Close SOCK, as well as the most recently remembered MSOCK, created
330 via bindport(). If SOCK is -1, close MSOCK only. */
334 /*shutdown (sock, 2);*/
342 /* Return the local IP address associated with the connection on FD. */
345 conaddr (int fd, ip_address *ip)
349 /* see bindport() for discussion of using `int' here. */
350 int addrlen = sizeof (mysrv);
352 if (getsockname (fd, &mysrv.sa, (int *)&addrlen) < 0)
355 switch (mysrv.sa.sa_family)
359 memcpy (ip, &mysrv.sin6.sin6_addr, 16);
363 map_ipv4_to_ip ((ip4_address *)&mysrv.sin.sin_addr, ip);
371 /* Read at most LEN bytes from FD, storing them to BUF. This is
372 virtually the same as read(), but takes care of EINTR braindamage
373 and uses select() to timeout the stale connections (a connection is
374 stale if more than OPT.TIMEOUT time is spent in select() or
377 iread (int fd, char *buf, int len)
388 res = select_fd (fd, opt.timeout, 0);
390 while (res == -1 && errno == EINTR);
393 /* Set errno to ETIMEDOUT on timeout. */
395 /* #### Potentially evil! */
401 res = READ (fd, buf, len);
403 while (res == -1 && errno == EINTR);
408 /* Write LEN bytes from BUF to FD. This is similar to iread(), but
409 doesn't bother with select(). Unlike iread(), it makes sure that
410 all of BUF is actually written to FD, so callers needn't bother
411 with checking that the return value equals to LEN. Instead, you
412 should simply check for -1. */
414 iwrite (int fd, char *buf, int len)
418 /* `write' may write less than LEN bytes, thus the outward loop
419 keeps trying it until all was written, or an error occurred. The
420 inner loop is reserved for the usual EINTR f*kage, and the
421 innermost loop deals with the same during select(). */
431 res = select_fd (fd, opt.timeout, 1);
433 while (res == -1 && errno == EINTR);
436 /* Set errno to ETIMEDOUT on timeout. */
438 /* #### Potentially evil! */
444 res = WRITE (fd, buf, len);
446 while (res == -1 && errno == EINTR);