GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>           // for NetBSD
#include <sys/ioctl.h>
#ifdef HAVE_SYS_FILIO_H
#  include <sys/filio.h>
#endif

#include <netinet/in.h>
#include <netinet/tcp.h>

#include <math.h>
#include <netdb.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

#include "vdef.h"
#include "miniobj.h"
#include "vas.h"
#include "vsa.h"
#include "vss.h"
#include "vtcp.h"
#include "vtim.h"

/*--------------------------------------------------------------------*/
static void
vtcp_sa_to_ascii(const void *sa, socklen_t l, char *abuf, unsigned alen,
    char *pbuf, unsigned plen)
{
        int i;

        assert(abuf == NULL || alen > 0);
        assert(pbuf == NULL || plen > 0);
        i = getnameinfo(sa, l, abuf, alen, pbuf, plen,
           NI_NUMERICHOST | NI_NUMERICSERV);
        if (i) {
                /*
                 * XXX this printf is shitty, but we may not have space
                 * for the gai_strerror in the buffer :-(
                 */
                fprintf(stderr, "getnameinfo = %d %s\n", i, gai_strerror(i));
                if (i == EAI_SYSTEM)
                        fprintf(stderr, "errno = %d %s\n", errno, VAS_errtxt(errno));
                if (abuf != NULL)
                        (void)snprintf(abuf, alen, "Conversion");
                if (pbuf != NULL)
                        (void)snprintf(pbuf, plen, "Failed");
                return;
        }
}

/*--------------------------------------------------------------------*/

void
VTCP_name(const struct suckaddr *addr, char *abuf, unsigned alen,
    char *pbuf, unsigned plen)
{
        const struct sockaddr *sa;
        socklen_t sl;

        sa = VSA_Get_Sockaddr(addr, &sl);
        AN(sa);
        vtcp_sa_to_ascii(sa, sl, abuf, alen, pbuf, plen);
}

/*--------------------------------------------------------------------*/

struct suckaddr *
VTCP_my_suckaddr(int sock)
{
        struct suckaddr *r;

        r = malloc(vsa_suckaddr_len);
        AN(VSA_getsockname(sock, r, vsa_suckaddr_len));
        return (r);
}

/*--------------------------------------------------------------------*/

void
VTCP_myname(int sock, char *abuf, unsigned alen, char *pbuf, unsigned plen)
{
        char buf[vsa_suckaddr_len];

        VTCP_name(VSA_getsockname(sock, buf, sizeof buf),
                  abuf, alen, pbuf, plen);
}

/*--------------------------------------------------------------------*/

void
VTCP_hisname(int sock, char *abuf, unsigned alen, char *pbuf, unsigned plen)
{
        char buf[vsa_suckaddr_len];
        const struct suckaddr *sua;

        sua = VSA_getpeername(sock, buf, sizeof buf);
        if (sua != NULL)
                VTCP_name(sua, abuf, alen, pbuf, plen);
        else {
                (void)snprintf(abuf, alen, "<none>");
                (void)snprintf(pbuf, plen, "<none>");
        }
}

/*--------------------------------------------------------------------*/

#ifdef HAVE_ACCEPT_FILTERS

int
VTCP_filter_http(int sock)
{
        int retval;
        struct accept_filter_arg afa;

        memset(&afa, 0, sizeof afa);
        bprintf(afa.af_name, "%s", "httpready");
        retval = setsockopt(sock, SOL_SOCKET, SO_ACCEPTFILTER,
            &afa, sizeof afa);
        return (retval);
}

#elif defined(__linux)

int
VTCP_filter_http(int sock)
{
        int retval;
        int defer = 1;

        retval = setsockopt(sock, SOL_TCP, TCP_DEFER_ACCEPT,
            &defer, sizeof defer);
        return (retval);
}

#else

int
VTCP_filter_http(int sock)
{
        errno = EOPNOTSUPP;
        (void)sock;
        return (-1);
}

#endif

/*--------------------------------------------------------------------*/


int
VTCP_fastopen(int sock, int depth)
{
#ifdef HAVE_TCP_FASTOPEN
#  ifndef SOL_TCP
#    define SOL_TCP IPPROTO_TCP
#  endif
        return (setsockopt(sock, SOL_TCP, TCP_FASTOPEN, &depth, sizeof depth));
#else
        errno = EOPNOTSUPP;
        (void)sock;
        (void)depth;
        return (-1);
#endif
}


/*--------------------------------------------------------------------
 * Functions for controlling NONBLOCK mode.
 *
 * We use FIONBIO because it is cheaper than fcntl(2), which requires
 * us to do two syscalls, one to get and one to set, the latter of
 * which mucks about a bit before it ends up calling ioctl(FIONBIO),
 * at least on FreeBSD.
 * On Solaris ioctl(FIONBIO) can fail with connection related errnos,
 * but as long as that is how they fail, we're fine.
 */

void
VTCP_blocking(int sock)
{
        int i, j;

        i = 0;
        j = ioctl(sock, FIONBIO, &i);
        VTCP_Assert(j);
}

void
VTCP_nonblocking(int sock)
{
        int i, j;

        i = 1;
        j = ioctl(sock, FIONBIO, &i);
        VTCP_Assert(j);
}

/*--------------------------------------------------------------------
 * On TCP a connect(2) can block for a looong time, and we don't want that.
 * Unfortunately, the SocketWizards back in those days were happy to wait
 * any amount of time for a connection, so the connect(2) syscall does not
 * take an argument for patience.
 *
 * There is a little used work-around, and we employ it at our peril.
 *
 */

int
VTCP_connected(int s)
{
        int k;
        socklen_t l;

        /* Find out if we got a connection */
        l = sizeof k;
        AZ(getsockopt(s, SOL_SOCKET, SO_ERROR, &k, &l));

        /* An error means no connection established */
        errno = k;
        if (k) {
                closefd(&s);
                return (-1);
        }

        VTCP_blocking(s);
        return (s);
}

int
VTCP_connect(const struct suckaddr *name, int msec)
{
        int s, i;
        struct pollfd fds[1];
        const struct sockaddr *sa;
        socklen_t sl;
        int val;

        if (name == NULL)
                return (-1);
        /* Attempt the connect */
        AN(VSA_Sane(name));
        sa = VSA_Get_Sockaddr(name, &sl);
        AN(sa);
        AN(sl);

        s = socket(sa->sa_family, SOCK_STREAM, 0);
        if (s < 0)
                return (s);

        /* Set the socket non-blocking */
        if (msec != 0)
                VTCP_nonblocking(s);

        val = 1;
        AZ(setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &val, sizeof val));

        i = connect(s, sa, sl);
        if (i == 0 && msec > 0)
                VTCP_blocking(s);
        if (i == 0)
                return (s);
        if (errno != EINPROGRESS) {
                closefd(&s);
                return (-1);
        }

        if (msec < 0) {
                /*
                 * Caller is responsible for waiting and
                 * calling VTCP_connected
                 */
                return (s);
        }

        assert(msec > 0);
        /* Exercise our patience, polling for write */
        fds[0].fd = s;
        fds[0].events = POLLWRNORM;
        fds[0].revents = 0;
        i = poll(fds, 1, msec);

        if (i == 0) {
                /* Timeout, close and give up */
                closefd(&s);
                errno = ETIMEDOUT;
                return (-1);
        }

        return (VTCP_connected(s));
}

/*--------------------------------------------------------------------
 * When closing a TCP connection, a couple of errno's are legit, we
 * can't be held responsible for the other end wanting to talk to us.
 */

void
VTCP_close(int *s)
{
        int i;

        i = close(*s);

        VTCP_Assert(i);
        *s = -1;
}

void
VTCP_set_read_timeout(int s, vtim_dur seconds)
{
        struct timeval timeout = VTIM_timeval_sock(seconds);

        /*
         * Solaris bug (present at least in snv_151 and older): If this fails
         * with EINVAL, the socket is half-closed (SS_CANTSENDMORE) and the
         * timeout does not get set. Needs to be fixed in Solaris, there is
         * nothing we can do about this.
         */
        VTCP_Assert(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO,
            &timeout, sizeof timeout));
}

/*--------------------------------------------------------------------
 */

struct vto_priv {
        unsigned                magic;
#define VTO_PRIV_MAGIC          0xca70b0e7
        int                     latest_errno;
        int                     fd;
        double                  timeout;
};

static int v_matchproto_(vss_resolved_f)
vtcp_open_callback(void *priv, const struct suckaddr *sa)
{
        struct vto_priv *vto;
        int fd;

        CAST_OBJ_NOTNULL(vto, priv, VTO_PRIV_MAGIC);

        errno = 0;
        fd = VTCP_connect(sa, (int)floor(vto->timeout * 1e3));
        if (fd >= 0) {
                vto->fd = fd;
                vto->latest_errno = 0;
                return (1);
        }
        vto->latest_errno = errno;
        return (0);
}

int
VTCP_open(const char *addr, const char *def_port, vtim_dur timeout,
    const char **errp)
{
        struct vto_priv vto[1];

        AN(errp);
        assert(timeout >= 0);
        INIT_OBJ(vto, VTO_PRIV_MAGIC);
        vto->fd = -1;
        vto->timeout = timeout;

        if (VSS_resolver(addr, def_port, vtcp_open_callback, vto, errp) < 0)
                return (-1);
        if (vto->fd < 0)
                *errp = strerror(vto->latest_errno);
        return (vto->fd);
}

/*--------------------------------------------------------------------
 * Given a struct suckaddr, open a socket of the appropriate type, and bind
 * it to the requested address.
 *
 * If the address is an IPv6 address, the IPV6_V6ONLY option is set to
 * avoid conflicts between INADDR_ANY and IN6ADDR_ANY.
 */

int
VTCP_bind(const struct suckaddr *sa, const char **errp)
{
        int sd, val, e;
        socklen_t sl;
        const struct sockaddr *so;
        int proto;

        if (errp != NULL)
                *errp = NULL;

        proto = VSA_Get_Proto(sa);
        sd = socket(proto, SOCK_STREAM, 0);
        if (sd < 0) {
                if (errp != NULL)
                        *errp = "socket(2)";
                return (-1);
        }
        val = 1;
        if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val) != 0) {
                if (errp != NULL)
                        *errp = "setsockopt(SO_REUSEADDR, 1)";
                e = errno;
                closefd(&sd);
                errno = e;
                return (-1);
        }
#ifdef IPV6_V6ONLY
        /* forcibly use separate sockets for IPv4 and IPv6 */
        val = 1;
        if (proto == AF_INET6 &&
            setsockopt(sd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof val) != 0) {
                if (errp != NULL)
                        *errp = "setsockopt(IPV6_V6ONLY, 1)";
                e = errno;
                closefd(&sd);
                errno = e;
                return (-1);
        }
#endif
        so = VSA_Get_Sockaddr(sa, &sl);
        if (bind(sd, so, sl) != 0) {
                if (errp != NULL)
                        *errp = "bind(2)";
                e = errno;
                closefd(&sd);
                errno = e;
                return (-1);
        }
        return (sd);
}

/*--------------------------------------------------------------------
 * Given a struct suckaddr, open a socket of the appropriate type, bind it
 * to the requested address, and start listening.
 */

int
VTCP_listen(const struct suckaddr *sa, int depth, const char **errp)
{
        int sd;
        int e;

        if (errp != NULL)
                *errp = NULL;
        sd = VTCP_bind(sa, errp);
        if (sd >= 0)  {
                if (listen(sd, depth) != 0) {
                        e = errno;
                        closefd(&sd);
                        errno = e;
                        if (errp != NULL)
                                *errp = "listen(2)";
                        return (-1);
                }
        }
        return (sd);
}

/*--------------------------------------------------------------------*/

struct helper {
        int             depth;
        const char      **errp;
};

static int v_matchproto_(vss_resolved_f)
vtcp_lo_cb(void *priv, const struct suckaddr *sa)
{
        int sock;
        struct helper *hp = priv;

        sock = VTCP_listen(sa, hp->depth, hp->errp);
        if (sock >= 0) {
                *hp->errp = NULL;
                return (sock);
        }
        AN(*hp->errp);
        return (0);
}

int
VTCP_listen_on(const char *addr, const char *def_port, int depth,
    const char **errp)
{
        struct helper h;
        int sock;

        AN(errp);
        h.depth = depth;
        h.errp = errp;

        sock = VSS_resolver(addr, def_port, vtcp_lo_cb, &h, errp);
        if (*errp != NULL)
                return (-1);
        return (sock);
}

/*--------------------------------------------------------------------
 * Set or reset SO_LINGER flag
 */

int
VTCP_linger(int sock, int linger)
{
        struct linger lin;
        int i;

        memset(&lin, 0, sizeof lin);
        lin.l_onoff = linger;
        i = setsockopt(sock, SOL_SOCKET, SO_LINGER, &lin, sizeof lin);
        VTCP_Assert(i);
        return (i);
}

/*--------------------------------------------------------------------
 * Do a poll to check for remote HUP
 */

int
VTCP_check_hup(int sock)
{
        struct pollfd pfd;

        assert(sock > 0);
        pfd.fd = sock;
        pfd.events = POLLOUT;
        pfd.revents = 0;

        if (poll(&pfd, 1, 0) == 1 && pfd.revents & POLLHUP)
                return (1);
        return (0);
}

/*--------------------------------------------------------------------
 * Check if a TCP syscall return value is fatal
 */

int
VTCP_Check(ssize_t a)
{
        if (a == 0)
                return (1);
        if (a > 0)
                return (1);
        if (errno == ECONNRESET || errno == ENOTCONN || errno == EPIPE)
                return (1);
        /* Accept EAGAIN (and EWOULDBLOCK in case they are not the same)
         * as errno values. Even though our sockets are all non-blocking,
         * when a SO_{SND|RCV}TIMEO expires, read() or write() on the
         * socket will return (-1) and errno set to EAGAIN. (This is not
         * documented in the read(2) and write(2) manpages, but is
         * described in the socket(7) manpage.) */
        if (errno == EAGAIN || errno == EWOULDBLOCK)
                return (1);
        /* tcp(7): The other end didn't acknowledge retransmitted data after
         * some time. */
        if (errno == ETIMEDOUT)
                return (1);
        /* #3539 various errnos documented on linux as POSIX.1 */
        if (errno == ENETDOWN || errno == ENETUNREACH || errno == ENETRESET ||
            errno == ECONNABORTED || /* ECONNRESET see above */
            errno == EHOSTUNREACH || errno == EHOSTDOWN) {
                return (1);
        }

#if (defined (__SVR4) && defined (__sun))
        if (errno == ECONNREFUSED)      // in r02702.vtc
                return (1);
        if (errno == EPROTO)
                return (1);
#endif
#if (defined (__SVR4) && defined (__sun)) ||            \
    defined (__NetBSD__) ||                             \
    defined (__APPLE__)
        /*
         * Solaris and macOS returns EINVAL if the other end unexpectedly reset
         * the connection.
         *
         * On NetBSD it is documented behaviour.
         */
        if (errno == EINVAL)
                return (1);
#endif
#if defined(ENABLE_SANITIZER)
        if (errno == EINTR)
                return (1);
#endif
        return (0);
}

/*--------------------------------------------------------------------
 *
 */

int
VTCP_read(int fd, void *ptr, size_t len, vtim_dur tmo)
{
        struct pollfd pfd[1];
        int i, j;

        if (tmo > 0.0) {
                pfd[0].fd = fd;
                pfd[0].events = POLLIN;
                pfd[0].revents = 0;
                j = poll(pfd, 1, VTIM_poll_tmo(tmo));
                if (j == 0)
                        return (-2);
        }
        i = read(fd, ptr, len);
        VTCP_Assert(i);
        return (i < 0 ? -1 : i);
}

		vinyl-cache/lib/libvinyl/vtcp.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*/
30
31		#include "config.h"
32
33		#include <sys/types.h>
34		#include <sys/socket.h>
35		#include <sys/time.h> // for NetBSD
36		#include <sys/ioctl.h>
37		#ifdef HAVE_SYS_FILIO_H
38		# include <sys/filio.h>
39		#endif
40
41		#include <netinet/in.h>
42		#include <netinet/tcp.h>
43
44		#include <math.h>
45		#include <netdb.h>
46		#include <poll.h>
47		#include <stdio.h>
48		#include <string.h>
49		#include <unistd.h>
50		#include <stdlib.h>
51
52		#include "vdef.h"
53		#include "miniobj.h"
54		#include "vas.h"
55		#include "vsa.h"
56		#include "vss.h"
57		#include "vtcp.h"
58		#include "vtim.h"
59
60		/--------------------------------------------------------------------/
61		static void
62	89857	vtcp_sa_to_ascii(const void sa, socklen_t l, char abuf, unsigned alen,
63		char *pbuf, unsigned plen)
64		{
65		int i;
66
67	89857	assert(abuf == NULL \|\| alen > 0);
68	89857	assert(pbuf == NULL \|\| plen > 0);
69	89857	i = getnameinfo(sa, l, abuf, alen, pbuf, plen,
70		NI_NUMERICHOST \| NI_NUMERICSERV);
71	89857	if (i) {
72		/*
73		* XXX this printf is shitty, but we may not have space
74		* for the gai_strerror in the buffer :-(
75		*/
76	0	fprintf(stderr, "getnameinfo = %d %s\n", i, gai_strerror(i));
77	0	if (i == EAI_SYSTEM)
78	0	fprintf(stderr, "errno = %d %s\n", errno, VAS_errtxt(errno));
79	0	if (abuf != NULL)
80	0	(void)snprintf(abuf, alen, "Conversion");
81	0	if (pbuf != NULL)
82	0	(void)snprintf(pbuf, plen, "Failed");
83	0	return;
84		}
85	89857	}
86
87		/--------------------------------------------------------------------/
88
89		void
90	89857	VTCP_name(const struct suckaddr addr, char abuf, unsigned alen,
91		char *pbuf, unsigned plen)
92		{
93		const struct sockaddr *sa;
94		socklen_t sl;
95
96	89857	sa = VSA_Get_Sockaddr(addr, &sl);
97	89857	AN(sa);
98	89857	vtcp_sa_to_ascii(sa, sl, abuf, alen, pbuf, plen);
99	89857	}
100
101		/--------------------------------------------------------------------/
102
103		struct suckaddr *
104	3036	VTCP_my_suckaddr(int sock)
105		{
106		struct suckaddr *r;
107
108	3036	r = malloc(vsa_suckaddr_len);
109	3036	AN(VSA_getsockname(sock, r, vsa_suckaddr_len));
110	3036	return (r);
111		}
112
113		/--------------------------------------------------------------------/
114
115		void
116	39728	VTCP_myname(int sock, char abuf, unsigned alen, char pbuf, unsigned plen)
117		{
118	39728	char buf[vsa_suckaddr_len];
119
120	79456	VTCP_name(VSA_getsockname(sock, buf, sizeof buf),
121	39728	abuf, alen, pbuf, plen);
122	39728	}
123
124		/--------------------------------------------------------------------/
125
126		void
127	24945	VTCP_hisname(int sock, char abuf, unsigned alen, char pbuf, unsigned plen)
128		{
129	24945	char buf[vsa_suckaddr_len];
130		const struct suckaddr *sua;
131
132	24945	sua = VSA_getpeername(sock, buf, sizeof buf);
133	24945	if (sua != NULL)
134	24945	VTCP_name(sua, abuf, alen, pbuf, plen);
135		else {
136	0	(void)snprintf(abuf, alen, "<none>");
137	0	(void)snprintf(pbuf, plen, "<none>");
138		}
139	24945	}
140
141		/--------------------------------------------------------------------/
142
143		#ifdef HAVE_ACCEPT_FILTERS
144
145		int
146	2907	VTCP_filter_http(int sock)
147		{
148		int retval;
149		struct accept_filter_arg afa;
150
151	2907	memset(&afa, 0, sizeof afa);
152	2907	bprintf(afa.af_name, "%s", "httpready");
153	2907	retval = setsockopt(sock, SOL_SOCKET, SO_ACCEPTFILTER,
154		&afa, sizeof afa);
155	2907	return (retval);
156		}
157
158		#elif defined(__linux)
159
160		int
161		VTCP_filter_http(int sock)
162		{
163		int retval;
164		int defer = 1;
165
166		retval = setsockopt(sock, SOL_TCP, TCP_DEFER_ACCEPT,
167		&defer, sizeof defer);
168		return (retval);
169		}
170
171		#else
172
173		int
174		VTCP_filter_http(int sock)
175		{
176		errno = EOPNOTSUPP;
177		(void)sock;
178		return (-1);
179		}
180
181		#endif
182
183		/--------------------------------------------------------------------/
184
185
186		int
187	0	VTCP_fastopen(int sock, int depth)
188		{
189		#ifdef HAVE_TCP_FASTOPEN
190		# ifndef SOL_TCP
191		# define SOL_TCP IPPROTO_TCP
192		# endif
193	0	return (setsockopt(sock, SOL_TCP, TCP_FASTOPEN, &depth, sizeof depth));
194		#else
195		errno = EOPNOTSUPP;
196		(void)sock;
197		(void)depth;
198		return (-1);
199		#endif
200		}
201
202
203		/*--------------------------------------------------------------------
204		* Functions for controlling NONBLOCK mode.
205		*
206		* We use FIONBIO because it is cheaper than fcntl(2), which requires
207		* us to do two syscalls, one to get and one to set, the latter of
208		* which mucks about a bit before it ends up calling ioctl(FIONBIO),
209		* at least on FreeBSD.
210		* On Solaris ioctl(FIONBIO) can fail with connection related errnos,
211		* but as long as that is how they fail, we're fine.
212		*/
213
214		void
215	45208	VTCP_blocking(int sock)
216		{
217		int i, j;
218
219	45208	i = 0;
220	45208	j = ioctl(sock, FIONBIO, &i);
221	45208	VTCP_Assert(j);
222	45208	}
223
224		void
225	15933	VTCP_nonblocking(int sock)
226		{
227		int i, j;
228
229	15933	i = 1;
230	15933	j = ioctl(sock, FIONBIO, &i);
231	15933	VTCP_Assert(j);
232	15933	}
233
234		/*--------------------------------------------------------------------
235		* On TCP a connect(2) can block for a looong time, and we don't want that.
236		* Unfortunately, the SocketWizards back in those days were happy to wait
237		* any amount of time for a connection, so the connect(2) syscall does not
238		* take an argument for patience.
239		*
240		* There is a little used work-around, and we employ it at our peril.
241		*
242		*/
243
244		int
245	13767	VTCP_connected(int s)
246		{
247		int k;
248		socklen_t l;
249
250		/* Find out if we got a connection */
251	13767	l = sizeof k;
252	13767	AZ(getsockopt(s, SOL_SOCKET, SO_ERROR, &k, &l));
253
254		/* An error means no connection established */
255	13767	errno = k;
256	13767	if (k) {
257	76	closefd(&s);
258	76	return (-1);
259		}
260
261	13691	VTCP_blocking(s);
262	13691	return (s);
263	13767	}
264
265		int
266	14465	VTCP_connect(const struct suckaddr *name, int msec)
267		{
268		int s, i;
269		struct pollfd fds[1];
270		const struct sockaddr *sa;
271		socklen_t sl;
272		int val;
273
274	14465	if (name == NULL)
275	85	return (-1);
276		/* Attempt the connect */
277	14380	AN(VSA_Sane(name));
278	14380	sa = VSA_Get_Sockaddr(name, &sl);
279	14380	AN(sa);
280	14380	AN(sl);
281
282	14380	s = socket(sa->sa_family, SOCK_STREAM, 0);
283	14380	if (s < 0)
284	0	return (s);
285
286		/* Set the socket non-blocking */
287	14380	if (msec != 0)
288	13772	VTCP_nonblocking(s);
289
290	14380	val = 1;
291	14380	AZ(setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &val, sizeof val));
292
293	14380	i = connect(s, sa, sl);
294	14380	if (i == 0 && msec > 0)
295	0	VTCP_blocking(s);
296	14380	if (i == 0)
297	609	return (s);
298	13771	if (errno != EINPROGRESS) {
299	0	closefd(&s);
300	0	return (-1);
301		}
302
303	13771	if (msec < 0) {
304		/*
305		* Caller is responsible for waiting and
306		* calling VTCP_connected
307		*/
308	2982	return (s);
309		}
310
311	10789	assert(msec > 0);
312		/* Exercise our patience, polling for write */
313	10789	fds[0].fd = s;
314	10789	fds[0].events = POLLWRNORM;
315	10789	fds[0].revents = 0;
316	10789	i = poll(fds, 1, msec);
317
318	10789	if (i == 0) {
319		/* Timeout, close and give up */
320	3	closefd(&s);
321	3	errno = ETIMEDOUT;
322	3	return (-1);
323		}
324
325	10786	return (VTCP_connected(s));
326	14465	}
327
328		/*--------------------------------------------------------------------
329		* When closing a TCP connection, a couple of errno's are legit, we
330		* can't be held responsible for the other end wanting to talk to us.
331		*/
332
333		void
334	20471	VTCP_close(int *s)
335		{
336		int i;
337
338	20471	i = close(*s);
339
340	20471	VTCP_Assert(i);
341	20471	*s = -1;
342	20471	}
343
344		void
345	6435	VTCP_set_read_timeout(int s, vtim_dur seconds)
346		{
347	6435	struct timeval timeout = VTIM_timeval_sock(seconds);
348
349		/*
350		* Solaris bug (present at least in snv_151 and older): If this fails
351		* with EINVAL, the socket is half-closed (SS_CANTSENDMORE) and the
352		* timeout does not get set. Needs to be fixed in Solaris, there is
353		* nothing we can do about this.
354		*/
355	6435	VTCP_Assert(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO,
356		&timeout, sizeof timeout));
357	6435	}
358
359		/*--------------------------------------------------------------------
360		*/
361
362		struct vto_priv {
363		unsigned magic;
364		#define VTO_PRIV_MAGIC 0xca70b0e7
365		int latest_errno;
366		int fd;
367		double timeout;
368		};
369
370		static int v_matchproto_(vss_resolved_f)
371	6867	vtcp_open_callback(void priv, const struct suckaddr sa)
372		{
373		struct vto_priv *vto;
374		int fd;
375
376	6867	CAST_OBJ_NOTNULL(vto, priv, VTO_PRIV_MAGIC);
377
378	6867	errno = 0;
379	6867	fd = VTCP_connect(sa, (int)floor(vto->timeout * 1e3));
380	6867	if (fd >= 0) {
381	6864	vto->fd = fd;
382	6864	vto->latest_errno = 0;
383	6864	return (1);
384		}
385	3	vto->latest_errno = errno;
386	3	return (0);
387	6867	}
388
389		int
390	6865	VTCP_open(const char addr, const char def_port, vtim_dur timeout,
391		const char **errp)
392		{
393		struct vto_priv vto[1];
394
395	6865	AN(errp);
396	6865	assert(timeout >= 0);
397	6865	INIT_OBJ(vto, VTO_PRIV_MAGIC);
398	6865	vto->fd = -1;
399	6865	vto->timeout = timeout;
400
401	6865	if (VSS_resolver(addr, def_port, vtcp_open_callback, vto, errp) < 0)
402	0	return (-1);
403	6865	if (vto->fd < 0)
404	3	*errp = strerror(vto->latest_errno);
405	6865	return (vto->fd);
406	6865	}
407
408		/*--------------------------------------------------------------------
409		* Given a struct suckaddr, open a socket of the appropriate type, and bind
410		* it to the requested address.
411		*
412		* If the address is an IPv6 address, the IPV6_V6ONLY option is set to
413		* avoid conflicts between INADDR_ANY and IN6ADDR_ANY.
414		*/
415
416		int
417	28344	VTCP_bind(const struct suckaddr sa, const char *errp)
418		{
419		int sd, val, e;
420		socklen_t sl;
421		const struct sockaddr *so;
422		int proto;
423
424	28344	if (errp != NULL)
425	15927	*errp = NULL;
426
427	28344	proto = VSA_Get_Proto(sa);
428	28344	sd = socket(proto, SOCK_STREAM, 0);
429	28344	if (sd < 0) {
430	0	if (errp != NULL)
431	0	*errp = "socket(2)";
432	0	return (-1);
433		}
434	28344	val = 1;
435	28344	if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val) != 0) {
436	0	if (errp != NULL)
437	0	*errp = "setsockopt(SO_REUSEADDR, 1)";
438	0	e = errno;
439	0	closefd(&sd);
440	0	errno = e;
441	0	return (-1);
442		}
443		#ifdef IPV6_V6ONLY
444		/* forcibly use separate sockets for IPv4 and IPv6 */
445	28344	val = 1;
446	28344	if (proto == AF_INET6 &&
447	6429	setsockopt(sd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof val) != 0) {
448	0	if (errp != NULL)
449	0	*errp = "setsockopt(IPV6_V6ONLY, 1)";
450	0	e = errno;
451	0	closefd(&sd);
452	0	errno = e;
453	0	return (-1);
454		}
455		#endif
456	28344	so = VSA_Get_Sockaddr(sa, &sl);
457	28344	if (bind(sd, so, sl) != 0) {
458	3	if (errp != NULL)
459	0	*errp = "bind(2)";
460	3	e = errno;
461	3	closefd(&sd);
462	3	errno = e;
463	3	return (-1);
464		}
465	28341	return (sd);
466	28344	}
467
468		/*--------------------------------------------------------------------
469		* Given a struct suckaddr, open a socket of the appropriate type, bind it
470		* to the requested address, and start listening.
471		*/
472
473		int
474	15927	VTCP_listen(const struct suckaddr sa, int depth, const char *errp)
475		{
476		int sd;
477		int e;
478
479	15927	if (errp != NULL)
480	15927	*errp = NULL;
481	15927	sd = VTCP_bind(sa, errp);
482	15927	if (sd >= 0) {
483	15927	if (listen(sd, depth) != 0) {
484	0	e = errno;
485	0	closefd(&sd);
486	0	errno = e;
487	0	if (errp != NULL)
488	0	*errp = "listen(2)";
489	0	return (-1);
490		}
491	15927	}
492	15927	return (sd);
493	15927	}
494
495		/--------------------------------------------------------------------/
496
497		struct helper {
498		int depth;
499		const char **errp;