/* Establishing and handling network connections.
- Copyright (C) 1995, 1996, 1997, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1996-2005 Free Software Foundation, Inc.
This file is part of GNU Wget.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with Wget; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+along with Wget; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
In addition, as a special exception, the Free Software Foundation
gives permission to link the code of its release of Wget with the
#include <stdio.h>
#include <stdlib.h>
-#include <sys/types.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#endif /* not WINDOWS */
#include <errno.h>
-#ifdef HAVE_STRING_H
-# include <string.h>
-#else
-# include <strings.h>
-#endif /* HAVE_STRING_H */
+#include <string.h>
#ifdef HAVE_SYS_SELECT_H
# include <sys/select.h>
#endif /* HAVE_SYS_SELECT_H */
#include "connect.h"
#include "hash.h"
-#ifndef errno
-extern int errno;
-#endif
-
/* Define sockaddr_storage where unavailable (presumably on IPv4-only
hosts). */
#endif
default:
abort ();
- return 0; /* so the compiler shuts up. */
}
}
\f
-static int
+/* Resolve the bind address specified via --bind-address and store it
+ to SA. The resolved value is stored in a static variable and
+ reused after the first invocation of this function.
+
+ Returns true on success, false on failure. */
+
+static bool
resolve_bind_address (struct sockaddr *sa)
{
struct address_list *al;
/* Make sure this is called only once. opt.bind_address doesn't
change during a Wget run. */
- static int called, should_bind;
+ static bool called, should_bind;
static ip_address ip;
if (called)
{
sockaddr_set_data (sa, &ip, 0);
return should_bind;
}
- called = 1;
+ called = true;
al = lookup_host (opt.bind_address, LH_BIND | LH_SILENT);
if (!al)
logprintf (LOG_NOTQUIET,
_("%s: unable to resolve bind address `%s'; disabling bind.\n"),
exec_name, opt.bind_address);
- should_bind = 0;
- return 0;
+ should_bind = false;
+ return false;
}
/* Pick the first address in the list and use it as bind address.
address_list_release (al);
sockaddr_set_data (sa, &ip, 0);
- should_bind = 1;
- return 1;
+ should_bind = true;
+ return true;
}
\f
struct cwt_context {
PRINT being the host name we're connecting to. */
if (print)
{
- const char *txt_addr = pretty_print_address (ip);
+ const char *txt_addr = print_address (ip);
if (print && 0 != strcmp (print, txt_addr))
logprintf (LOG_VERBOSE, _("Connecting to %s|%s|:%d... "),
escnonprint (print), txt_addr, port);
int on = 1;
/* In case of error, we will go on anyway... */
int err = setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on));
-#ifdef ENABLE_DEBUG
- if (err < 0)
- DEBUGP (("Failed setting IPV6_V6ONLY: %s", strerror (errno)));
-#endif
+ IF_DEBUG
+ if (err < 0)
+ DEBUGP (("Failed setting IPV6_V6ONLY: %s", strerror (errno)));
}
#endif
if (sock >= 0)
fd_close (sock);
if (print)
- logprintf (LOG_VERBOSE, "failed: %s.\n", strerror (errno));
+ logprintf (LOG_VERBOSE, _("failed: %s.\n"), strerror (errno));
errno = save_errno;
return -1;
}
return -1;
}
sockaddr_get_data (sa, NULL, port);
- DEBUGP (("binding to address %s using port %i.\n",
- pretty_print_address (bind_address), *port));
+ DEBUGP (("binding to address %s using port %i.\n",
+ print_address (bind_address), *port));
}
if (listen (sock, 1) < 0)
{
}
/* Get the IP address associated with the connection on FD and store
- it to IP. Return 1 on success, 0 otherwise.
+ it to IP. Return true on success, false otherwise.
If ENDPOINT is ENDPOINT_LOCAL, it returns the address of the local
(client) side of the socket. Else if ENDPOINT is ENDPOINT_PEER, it
returns the address of the remote (peer's) side of the socket. */
-int
+bool
socket_ip_address (int sock, ip_address *ip, int endpoint)
{
struct sockaddr_storage storage;
else
abort ();
if (ret < 0)
- return 0;
+ return false;
switch (sockaddr->sa_family)
{
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
ADDRESS_IPV6_SCOPE (ip) = sa6->sin6_scope_id;
#endif
- DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
- return 1;
+ DEBUGP (("conaddr is: %s\n", print_address (ip)));
+ return true;
}
#endif
case AF_INET:
struct sockaddr_in *sa = (struct sockaddr_in *)&storage;
ip->type = IPV4_ADDRESS;
ADDRESS_IPV4_IN_ADDR (ip) = sa->sin_addr;
- DEBUGP (("conaddr is: %s\n", pretty_print_address (ip)));
- return 1;
+ DEBUGP (("conaddr is: %s\n", print_address (ip)));
+ return true;
}
default:
abort ();
}
-
- return 0;
}
-/* Return non-zero if the error from the connect code can be
- considered retryable. Wget normally retries after errors, but the
- exception are the "unsupported protocol" type errors (possible on
- IPv4/IPv6 dual family systems) and "connection refused". */
+/* Return true if the error from the connect code can be considered
+ retryable. Wget normally retries after errors, but the exception
+ are the "unsupported protocol" type errors (possible on IPv4/IPv6
+ dual family systems) and "connection refused". */
-int
+bool
retryable_socket_connect_error (int err)
{
/* Have to guard against some of these values not being defined.
Cannot use a switch statement because some of the values might be
equal. */
- if (0
+ if (false
#ifdef EAFNOSUPPORT
|| err == EAFNOSUPPORT
#endif
instead of EAFNOSUPPORT and such. */
|| err == EINVAL
)
- return 0;
-
- if (err == ECONNREFUSED && !opt.retry_connrefused)
- return 0;
+ return false;
- return 1;
-}
-
-#ifdef ENABLE_IPV6
-# ifndef HAVE_GETADDRINFO_AI_ADDRCONFIG
-
-/* Return non-zero if the INET6 socket family is supported on the
- system.
-
- This doesn't guarantee that we're able to connect to IPv6 hosts,
- but it's better than nothing. It is only used on systems where
- getaddrinfo doesn't support AI_ADDRCONFIG. (See lookup_host.) */
+ if (!opt.retry_connrefused)
+ if (err == ECONNREFUSED
+#ifdef ENETUNREACH
+ || err == ENETUNREACH /* network is unreachable */
+#endif
+#ifdef EHOSTUNREACH
+ || err == EHOSTUNREACH /* host is unreachable */
+#endif
+ )
+ return false;
-int
-socket_has_inet6 (void)
-{
- static int supported = -1;
- if (supported == -1)
- {
- int sock = socket (AF_INET6, SOCK_STREAM, 0);
- if (sock < 0)
- supported = 0;
- else
- {
- fd_close (sock);
- supported = 1;
- }
- }
- return supported;
+ return true;
}
-# endif/* not HAVE_GETADDRINFO_AI_ADDRCONFIG */
-#endif /* ENABLE_IPV6 */
-
/* Wait for a single descriptor to become available, timing out after
MAXTIME seconds. Returns 1 if FD is available, 0 for timeout and
-1 for error. The argument WAIT_FOR can be a combination of
int
select_fd (int fd, double maxtime, int wait_for)
{
-#ifdef HAVE_SELECT
fd_set fdset;
fd_set *rd = NULL, *wr = NULL;
struct timeval tmout;
while (result < 0 && errno == EINTR);
return result;
+}
-#else /* not HAVE_SELECT */
-
- /* If select() unavailable, just return 1. In most usages in Wget,
- this is the appropriate response -- "if we can't poll, go ahead
- with the blocking operation". If a specific part of code needs
- different behavior, it can use #ifdef HAVE_SELECT to test whether
- polling really occurs. */
- return 1;
+/* Return true iff the connection to the remote site established
+ through SOCK is still open.
-#endif /* not HAVE_SELECT */
-}
+ Specifically, this function returns true if SOCK is not ready for
+ reading. This is because, when the connection closes, the socket
+ is ready for reading because EOF is about to be delivered. A side
+ effect of this method is that sockets that have pending data are
+ considered non-open. This is actually a good thing for callers of
+ this function, where such pending data can only be unwanted
+ leftover from a previous request. */
-int
+bool
test_socket_open (int sock)
{
-#ifdef HAVE_SELECT
fd_set check_set;
struct timeval to;
to.tv_sec = 0;
to.tv_usec = 1;
- /* If we get a timeout, then that means still connected */
if (select (sock + 1, &check_set, NULL, NULL, &to) == 0)
- {
- /* Connection is valid (not EOF), so continue */
- return 1;
- }
+ /* We got a timeout, it means we're still connected. */
+ return true;
else
- return 0;
-#else
- /* Without select, it's hard to know for sure. */
- return 1;
-#endif
+ /* Read now would not wait, it means we have either pending data
+ or EOF/error. */
+ return false;
}
\f
/* Basic socket operations, mostly EINTR wrappers. */
or SSL_read or whatever is necessary. */
static struct hash_table *transport_map;
-static int transport_map_modified_tick;
+static unsigned int transport_map_modified_tick;
struct transport_info {
- fd_reader_t reader;
- fd_writer_t writer;
- fd_poller_t poller;
- fd_peeker_t peeker;
- fd_closer_t closer;
+ struct transport_implementation *imp;
void *ctx;
};
call getpeername, etc. */
void
-fd_register_transport (int fd, fd_reader_t reader, fd_writer_t writer,
- fd_poller_t poller, fd_peeker_t peeker,
- fd_closer_t closer, void *ctx)
+fd_register_transport (int fd, struct transport_implementation *imp, void *ctx)
{
struct transport_info *info;
assert (fd >= 0);
info = xnew (struct transport_info);
- info->reader = reader;
- info->writer = writer;
- info->poller = poller;
- info->peeker = peeker;
- info->closer = closer;
+ info->imp = imp;
info->ctx = ctx;
if (!transport_map)
transport_map = hash_table_new (0, NULL, NULL);
++transport_map_modified_tick;
}
+/* Return context of the transport registered with
+ fd_register_transport. This assumes fd_register_transport was
+ previously called on FD. */
+
+void *
+fd_transport_context (int fd)
+{
+ struct transport_info *info = hash_table_get (transport_map, (void *) fd);
+ return info->ctx;
+}
+
/* When fd_read/fd_write are called multiple times in a loop, they should
remember the INFO pointer instead of fetching it every time. It is
not enough to compare FD to LAST_FD because FD might have been
#define LAZY_RETRIEVE_INFO(info) do { \
static struct transport_info *last_info; \
- static int last_fd = -1, last_tick; \
+ static int last_fd = -1; \
+ static unsigned int last_tick; \
if (!transport_map) \
info = NULL; \
else if (last_fd == fd && last_tick == transport_map_modified_tick) \
} \
} while (0)
-static int
+static bool
poll_internal (int fd, struct transport_info *info, int wf, double timeout)
{
if (timeout == -1)
if (timeout)
{
int test;
- if (info && info->poller)
- test = info->poller (fd, timeout, wf, info->ctx);
+ if (info && info->imp->poller)
+ test = info->imp->poller (fd, timeout, wf, info->ctx);
else
test = sock_poll (fd, timeout, wf);
if (test == 0)
errno = ETIMEDOUT;
if (test <= 0)
- return 0;
+ return false;
}
- return 1;
+ return true;
}
/* Read no more than BUFSIZE bytes of data from FD, storing them to
LAZY_RETRIEVE_INFO (info);
if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
return -1;
- if (info && info->reader)
- return info->reader (fd, buf, bufsize, info->ctx);
+ if (info && info->imp->reader)
+ return info->imp->reader (fd, buf, bufsize, info->ctx);
else
return sock_read (fd, buf, bufsize);
}
LAZY_RETRIEVE_INFO (info);
if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
return -1;
- if (info && info->peeker)
- return info->peeker (fd, buf, bufsize, info->ctx);
+ if (info && info->imp->peeker)
+ return info->imp->peeker (fd, buf, bufsize, info->ctx);
else
return sock_peek (fd, buf, bufsize);
}
{
if (!poll_internal (fd, info, WAIT_FOR_WRITE, timeout))
return -1;
- if (info && info->writer)
- res = info->writer (fd, buf, bufsize, info->ctx);
+ if (info && info->imp->writer)
+ res = info->imp->writer (fd, buf, bufsize, info->ctx);
else
res = sock_write (fd, buf, bufsize);
if (res <= 0)
return res;
}
+/* Report the most recent error(s) on FD. This should only be called
+ after fd_* functions, such as fd_read and fd_write, and only if
+ they return a negative result. For errors coming from other calls
+ such as setsockopt or fopen, strerror should continue to be
+ used.
+
+ If the transport doesn't support error messages or doesn't supply
+ one, strerror(errno) is returned. The returned error message
+ should not be used after fd_close has been called. */
+
+const char *
+fd_errstr (int fd)
+{
+ /* Don't bother with LAZY_RETRIEVE_INFO, as this will only be called
+ in case of error, never in a tight loop. */
+ struct transport_info *info = NULL;
+ if (transport_map)
+ info = hash_table_get (transport_map, (void *) fd);
+
+ if (info && info->imp->errstr)
+ {
+ const char *err = info->imp->errstr (fd, info->ctx);
+ if (err)
+ return err;
+ /* else, fall through and print the system error. */
+ }
+ return strerror (errno);
+}
+
/* Close the file descriptor FD. */
void
if (transport_map)
info = hash_table_get (transport_map, (void *) fd);
- if (info && info->closer)
- info->closer (fd, info->ctx);
+ if (info && info->imp->closer)
+ info->imp->closer (fd, info->ctx);
else
sock_close (fd);