extern int errno;
#endif
-\f
+/* Define sockaddr_storage where unavailable (presumably on IPv4-only
+ hosts). */
+
+#ifndef ENABLE_IPV6
+# ifndef HAVE_STRUCT_SOCKADDR_STORAGE
+# define sockaddr_storage sockaddr_in
+# endif
+#endif /* ENABLE_IPV6 */
+
/* Fill SA as per the data in IP and PORT. SA shoult point to struct
sockaddr_storage if ENABLE_IPV6 is defined, to struct sockaddr_in
otherwise. */
case IPV4_ADDRESS:
{
struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+ xzero (*sin);
sin->sin_family = AF_INET;
sin->sin_port = htons (port);
sin->sin_addr = ADDRESS_IPV4_IN_ADDR (ip);
case IPV6_ADDRESS:
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
+ xzero (*sin6);
sin6->sin6_family = AF_INET6;
sin6->sin6_port = htons (port);
sin6->sin6_addr = ADDRESS_IPV6_IN6_ADDR (ip);
#endif
default:
abort ();
- return 0; /* so the compiler shuts up. */
}
}
\f
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
- int sock = -1;
+ int sock;
/* If PRINT is non-NULL, print the "Connecting to..." line, with
PRINT being the host name we're connecting to. */
{
const char *txt_addr = pretty_print_address (ip);
if (print && 0 != strcmp (print, txt_addr))
- logprintf (LOG_VERBOSE,
- _("Connecting to %s|%s|:%d... "), print, txt_addr, port);
+ logprintf (LOG_VERBOSE, _("Connecting to %s|%s|:%d... "),
+ escnonprint (print), txt_addr, port);
else
logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port);
}
if (sock < 0)
goto err;
+#if defined(ENABLE_IPV6) && defined(IPV6_V6ONLY)
+ if (opt.ipv6_only) {
+ 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
+ }
+#endif
+
/* For very small rate limits, set the buffer size (and hence,
hopefully, the kernel's TCP window size) to the per-second limit.
That way we should never have to sleep for more than 1s between
logprintf. */
int save_errno = errno;
if (sock >= 0)
- xclose (sock);
+ 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;
}
setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, setopt_ptr, setopt_size);
#endif
-#ifdef ENABLE_IPV6
-# ifdef HAVE_IPV6_V6ONLY
- if (family == AF_INET6)
- setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, setopt_ptr, setopt_size);
-# endif
-#endif
-
xzero (ss);
sockaddr_set_data (sa, bind_address, *port);
if (bind (sock, sa, sockaddr_size (sa)) < 0)
{
- xclose (sock);
+ fd_close (sock);
return -1;
}
DEBUGP (("Local socket fd %d bound.\n", sock));
/* If *PORT is 0, find out which port we've bound to. */
if (*port == 0)
{
- socklen_t sa_len = sockaddr_size (sa);
- if (getsockname (sock, sa, &sa_len) < 0)
+ socklen_t addrlen = sockaddr_size (sa);
+ if (getsockname (sock, sa, &addrlen) < 0)
{
/* If we can't find out the socket's local address ("name"),
something is seriously wrong with the socket, and it's
unusable for us anyway because we must know the chosen
port. */
- xclose (sock);
+ fd_close (sock);
return -1;
}
sockaddr_get_data (sa, NULL, port);
}
if (listen (sock, 1) < 0)
{
- xclose (sock);
+ fd_close (sock);
return -1;
}
return sock;
default:
abort ();
}
-
- return 0;
}
/* Return non-zero if the error from the connect code can be
)
return 0;
- if (err == ECONNREFUSED && !opt.retry_connrefused)
- return 0;
+ if (!opt.retry_connrefused)
+ if (err == ECONNREFUSED
+#ifdef ENETUNREACH
+ || err == ENETUNREACH /* network is unreachable */
+#endif
+#ifdef EHOSTUNREACH
+ || err == EHOSTUNREACH /* host is unreachable */
+#endif
+ )
+ return 0;
return 1;
}
+#ifdef ENABLE_IPV6
+# ifndef HAVE_GETADDRINFO_AI_ADDRCONFIG
+
/* Return non-zero if the INET6 socket family is supported on the
system.
supported = 0;
else
{
- xclose (sock);
+ fd_close (sock);
supported = 1;
}
}
return supported;
}
+# 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
wr = &fdset;
tmout.tv_sec = (long) maxtime;
- tmout.tv_usec = 1000000L * (maxtime - (long) maxtime);
+ tmout.tv_usec = 1000000 * (maxtime - (long) maxtime);
do
result = select (fd + 1, rd, wr, NULL, &tmout);
static int
sock_write (int fd, char *buf, int bufsize)
{
- int res = 0;
+ int res;
do
res = write (fd, buf, bufsize);
while (res == -1 && errno == EINTR);
return select_fd (fd, timeout, wait_for);
}
+static int
+sock_peek (int fd, char *buf, int bufsize)
+{
+ int res;
+ do
+ res = recv (fd, buf, bufsize, MSG_PEEK);
+ while (res == -1 && errno == EINTR);
+ return res;
+}
+
static void
sock_close (int fd)
{
that are not mere file descriptors under the hood, such as SSL
sockets.
- That way the user code can call xread(fd, ...) and we'll run read
+ That way the user code can call fd_read(fd, ...) and we'll run read
or SSL_read or whatever is necessary. */
static struct hash_table *transport_map;
static int transport_map_modified_tick;
struct transport_info {
- xreader_t reader;
- xwriter_t writer;
- xpoller_t poller;
- xcloser_t closer;
+ fd_reader_t reader;
+ fd_writer_t writer;
+ fd_poller_t poller;
+ fd_peeker_t peeker;
+ fd_closer_t closer;
void *ctx;
};
call getpeername, etc. */
void
-register_transport (int fd, xreader_t reader, xwriter_t writer,
- xpoller_t poller, xcloser_t closer, void *ctx)
+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)
{
struct transport_info *info;
/* The file descriptor must be non-negative to be registered.
- Negative values are ignored by xclose(), and -1 cannot be used as
+ Negative values are ignored by fd_close(), and -1 cannot be used as
hash key. */
assert (fd >= 0);
info->reader = reader;
info->writer = writer;
info->poller = poller;
+ info->peeker = peeker;
info->closer = closer;
info->ctx = ctx;
if (!transport_map)
++transport_map_modified_tick;
}
-/* When xread/xwrite are called multiple times in a loop, they should
+/* 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
closed and reopened. modified_tick ensures that changes to
} \
} while (0)
-/* Read no more than BUFSIZE bytes of data from FD, storing them to
- BUF. If TIMEOUT is non-zero, the operation aborts if no data is
- received after that many seconds. If TIMEOUT is -1, the value of
- opt.timeout is used for TIMEOUT. */
-
-int
-xread (int fd, char *buf, int bufsize, double timeout)
+static int
+poll_internal (int fd, struct transport_info *info, int wf, double timeout)
{
- struct transport_info *info;
- LAZY_RETRIEVE_INFO (info);
if (timeout == -1)
timeout = opt.read_timeout;
if (timeout)
{
int test;
if (info && info->poller)
- test = info->poller (fd, timeout, WAIT_FOR_READ, info->ctx);
+ test = info->poller (fd, timeout, wf, info->ctx);
else
- test = sock_poll (fd, timeout, WAIT_FOR_READ);
+ test = sock_poll (fd, timeout, wf);
if (test == 0)
errno = ETIMEDOUT;
if (test <= 0)
- return -1;
+ return 0;
}
+ return 1;
+}
+
+/* Read no more than BUFSIZE bytes of data from FD, storing them to
+ BUF. If TIMEOUT is non-zero, the operation aborts if no data is
+ received after that many seconds. If TIMEOUT is -1, the value of
+ opt.timeout is used for TIMEOUT. */
+
+int
+fd_read (int fd, char *buf, int bufsize, double timeout)
+{
+ struct transport_info *info;
+ 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);
else
return sock_read (fd, buf, bufsize);
}
+/* Like fd_read, except it provides a "preview" of the data that will
+ be read by subsequent calls to fd_read. Specifically, it copies no
+ more than BUFSIZE bytes of the currently available data to BUF and
+ returns the number of bytes copied. Return values and timeout
+ semantics are the same as those of fd_read.
+
+ CAVEAT: Do not assume that the first subsequent call to fd_read
+ will retrieve the same amount of data. Reading can return more or
+ less data, depending on the TCP implementation and other
+ circumstances. However, barring an error, it can be expected that
+ all the peeked data will eventually be read by fd_read. */
+
+int
+fd_peek (int fd, char *buf, int bufsize, double timeout)
+{
+ struct transport_info *info;
+ 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);
+ else
+ return sock_peek (fd, buf, bufsize);
+}
+
/* Write the entire contents of BUF to FD. If TIMEOUT is non-zero,
the operation aborts if no data is received after that many
seconds. If TIMEOUT is -1, the value of opt.timeout is used for
TIMEOUT. */
int
-xwrite (int fd, char *buf, int bufsize, double timeout)
+fd_write (int fd, char *buf, int bufsize, double timeout)
{
int res;
struct transport_info *info;
LAZY_RETRIEVE_INFO (info);
- if (timeout == -1)
- timeout = opt.read_timeout;
/* `write' may write less than LEN bytes, thus the loop keeps trying
it until all was written, or an error occurred. */
res = 0;
while (bufsize > 0)
{
- if (timeout)
- {
- int test;
- if (info && info->poller)
- test = info->poller (fd, timeout, WAIT_FOR_WRITE, info->ctx);
- else
- test = sock_poll (fd, timeout, WAIT_FOR_WRITE);
- if (test == 0)
- errno = ETIMEDOUT;
- if (test <= 0)
- return -1;
- }
+ if (!poll_internal (fd, info, WAIT_FOR_WRITE, timeout))
+ return -1;
if (info && info->writer)
res = info->writer (fd, buf, bufsize, info->ctx);
else
/* Close the file descriptor FD. */
void
-xclose (int fd)
+fd_close (int fd)
{
struct transport_info *info;
if (fd < 0)
return;
- /* Don't use LAZY_RETRIEVE_INFO because xclose() is only called once
+ /* Don't use LAZY_RETRIEVE_INFO because fd_close() is only called once
per socket, so that particular optimization wouldn't work. */
info = NULL;
if (transport_map)
projects / wget / blobdiff