#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
{
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
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;
}
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.
-
- 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.) */
-
-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;
-}
-
-# 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);
++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
return sock_read (fd, buf, bufsize);
}
-/* The same as xread, but don't actually read the data, just copy it
- instead. */
+/* 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)