1 /* Establishing and handling network connections.
2 Copyright (C) 1995, 1996, 1997 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 /* A kludge, but still better than passing the host name all the way
64 static const char *connection_host_name;
67 set_connection_host_name (const char *host)
70 assert (connection_host_name == NULL);
72 assert (connection_host_name != NULL);
74 connection_host_name = host;
77 /* Connect to a remote host whose address has been resolved. */
79 connect_to_one (const unsigned char *addr, unsigned short port, int silent)
81 struct sockaddr_in sock_name;
84 /* Set port and protocol */
85 sock_name.sin_family = AF_INET;
86 sock_name.sin_port = htons (port);
87 memcpy ((unsigned char *)&sock_name.sin_addr, addr, 4);
91 char *pretty_addr = pretty_print_address (addr);
92 if (connection_host_name
93 && 0 != strcmp (connection_host_name, pretty_addr))
94 logprintf (LOG_VERBOSE, _("Connecting to %s[%s]:%hu... "),
95 connection_host_name, pretty_addr, port);
97 logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "),
101 /* Make an internet socket, stream type. */
102 sock = socket (AF_INET, SOCK_STREAM, 0);
106 if (opt.bind_address)
108 /* Bind the client side to the requested address. */
109 if (bind (sock, (struct sockaddr *)opt.bind_address,
110 sizeof (*opt.bind_address)))
118 /* Connect the socket to the remote host. */
119 if (connect (sock, (struct sockaddr *)&sock_name, sizeof (sock_name)) < 0)
131 logprintf (LOG_VERBOSE, _("connected.\n"));
132 DEBUGP (("Created socket %d.\n", sock));
138 logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
145 /* Connect to a remote host whose address has been resolved. */
147 connect_to_many (struct address_list *al, unsigned short port, int silent)
151 address_list_get_bounds (al, &start, &end);
152 for (i = start; i < end; i++)
154 unsigned char addr[4];
156 address_list_copy_one (al, i, addr);
158 sock = connect_to_one (addr, port, silent);
163 address_list_set_faulty (al, i);
165 /* The attempt to connect has failed. Continue with the loop
166 and try next address. */
173 test_socket_open (int sock)
179 /* Check if we still have a valid (non-EOF) connection. From Andrew
180 * Maholski's code in the Unix Socket FAQ. */
182 FD_ZERO (&check_set);
183 FD_SET (sock, &check_set);
185 /* Wait one microsecond */
189 /* If we get a timeout, then that means still connected */
190 if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
192 /* Connection is valid (not EOF), so continue */
198 /* Without select, it's hard to know for sure. */
203 /* Bind the local port PORT. This does all the necessary work, which
204 is creating a socket, setting SO_REUSEADDR option on it, then
205 calling bind() and listen(). If *PORT is 0, a random port is
206 chosen by the system, and its value is stored to *PORT. The
207 internal variable MPORT is set to the value of the ensuing master
208 socket. Call acceptport() to block for and accept a connection. */
210 bindport (unsigned short *port)
213 static struct sockaddr_in srv;
216 addr = (struct sockaddr *) &srv;
217 if ((msock = socket (AF_INET, SOCK_STREAM, 0)) < 0)
219 if (setsockopt (msock, SOL_SOCKET, SO_REUSEADDR,
220 (char *)&optval, sizeof (optval)) < 0)
223 if (opt.bind_address == NULL)
225 srv.sin_family = AF_INET;
226 srv.sin_addr.s_addr = htonl (INADDR_ANY);
229 srv = *opt.bind_address;
231 srv.sin_port = htons (*port);
232 if (bind (msock, addr, sizeof (struct sockaddr_in)) < 0)
238 DEBUGP (("Master socket fd %d bound.\n", msock));
241 /* #### addrlen should be a 32-bit type, which int is not
242 guaranteed to be. Oh, and don't try to make it a size_t,
243 because that can be 64-bit. */
244 int addrlen = sizeof (struct sockaddr_in);
245 if (getsockname (msock, addr, &addrlen) < 0)
251 *port = ntohs (srv.sin_port);
253 if (listen (msock, 1) < 0)
263 /* Wait for file descriptor FD to be readable, MAXTIME being the
264 timeout in seconds. If WRITEP is non-zero, checks for FD being
267 Returns 1 if FD is accessible, 0 for timeout and -1 for error in
270 select_fd (int fd, int maxtime, int writep)
272 fd_set fds, exceptfds;
273 struct timeval timeout;
277 FD_ZERO (&exceptfds);
278 FD_SET (fd, &exceptfds);
279 timeout.tv_sec = maxtime;
281 /* HPUX reportedly warns here. What is the correct incantation? */
282 return select (fd + 1, writep ? NULL : &fds, writep ? &fds : NULL,
283 &exceptfds, &timeout);
285 #endif /* HAVE_SELECT */
287 /* Call accept() on MSOCK and store the result to *SOCK. This assumes
288 that bindport() has been used to initialize MSOCK to a correct
289 value. It blocks the caller until a connection is established. If
290 no connection is established for OPT.TIMEOUT seconds, the function
291 exits with an error status. */
293 acceptport (int *sock)
295 int addrlen = sizeof (struct sockaddr_in);
298 if (select_fd (msock, opt.timeout, 0) <= 0)
301 if ((*sock = accept (msock, addr, &addrlen)) < 0)
303 DEBUGP (("Created socket fd %d.\n", *sock));
307 /* Close SOCK, as well as the most recently remembered MSOCK, created
308 via bindport(). If SOCK is -1, close MSOCK only. */
312 /*shutdown (sock, 2);*/
320 /* Return the local IP address associated with the connection on FD.
321 It is returned in a static buffer. */
325 static unsigned char res[4];
326 struct sockaddr_in mysrv;
327 struct sockaddr *myaddr;
328 int addrlen = sizeof (mysrv); /* see bindport() for discussion of
331 myaddr = (struct sockaddr *) (&mysrv);
332 if (getsockname (fd, myaddr, (int *)&addrlen) < 0)
334 memcpy (res, &mysrv.sin_addr, 4);
338 /* Read at most LEN bytes from FD, storing them to BUF. This is
339 virtually the same as read(), but takes care of EINTR braindamage
340 and uses select() to timeout the stale connections (a connection is
341 stale if more than OPT.TIMEOUT time is spent in select() or
344 iread (int fd, char *buf, int len)
355 res = select_fd (fd, opt.timeout, 0);
357 while (res == -1 && errno == EINTR);
360 /* Set errno to ETIMEDOUT on timeout. */
362 /* #### Potentially evil! */
368 res = READ (fd, buf, len);
370 while (res == -1 && errno == EINTR);
375 /* Write LEN bytes from BUF to FD. This is similar to iread(), but
376 doesn't bother with select(). Unlike iread(), it makes sure that
377 all of BUF is actually written to FD, so callers needn't bother
378 with checking that the return value equals to LEN. Instead, you
379 should simply check for -1. */
381 iwrite (int fd, char *buf, int len)
385 /* `write' may write less than LEN bytes, thus the outward loop
386 keeps trying it until all was written, or an error occurred. The
387 inner loop is reserved for the usual EINTR f*kage, and the
388 innermost loop deals with the same during select(). */
398 res = select_fd (fd, opt.timeout, 1);
400 while (res == -1 && errno == EINTR);
403 /* Set errno to ETIMEDOUT on timeout. */
405 /* #### Potentially evil! */
411 res = WRITE (fd, buf, len);
413 while (res == -1 && errno == EINTR);