1 /*-
2  * Copyright (c) 2009-2010 The FreeBSD Foundation
3  * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>
4  * All rights reserved.
5  *
6  * This software was developed by Pawel Jakub Dawidek under sponsorship from
7  * the FreeBSD Foundation.
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 AUTHORS 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 THE AUTHORS 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/config.h>
32 
33 #include <sys/param.h>	/* MAXHOSTNAMELEN */
34 #include <sys/socket.h>
35 
36 #include <arpa/inet.h>
37 
38 #include <netinet/in.h>
39 #include <netinet/tcp.h>
40 
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <netdb.h>
44 #include <stdbool.h>
45 #include <stdint.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <unistd.h>
50 
51 #ifndef HAVE_STRLCPY
52 #include <compat/strlcpy.h>
53 #endif
54 
55 #include "pjdlog.h"
56 #include "proto_impl.h"
57 #include "subr.h"
58 
59 #define	TCP_CTX_MAGIC	0x7c41c
60 struct tcp_ctx {
61 	int			tc_magic;
62 	struct sockaddr_storage	tc_sa;
63 	int			tc_fd;
64 	int			tc_side;
65 #define	TCP_SIDE_CLIENT		0
66 #define	TCP_SIDE_SERVER_LISTEN	1
67 #define	TCP_SIDE_SERVER_WORK	2
68 	bool			tc_wait_called;
69 };
70 
71 static int tcp_connect_wait(void *ctx, int timeout);
72 static void tcp_close(void *ctx);
73 
74 /*
75  * Function converts the given string to unsigned number.
76  */
77 static int
78 numfromstr(const char *str, intmax_t minnum, intmax_t maxnum, intmax_t *nump)
79 {
80 	intmax_t digit, num;
81 
82 	if (str[0] == '\0')
83 		goto invalid;	/* Empty string. */
84 	num = 0;
85 	for (; *str != '\0'; str++) {
86 		if (*str < '0' || *str > '9')
87 			goto invalid;	/* Non-digit character. */
88 		digit = *str - '0';
89 		if (num > num * 10 + digit)
90 			goto invalid;	/* Overflow. */
91 		num = num * 10 + digit;
92 		if (num > maxnum)
93 			goto invalid;	/* Too big. */
94 	}
95 	if (num < minnum)
96 		goto invalid;	/* Too small. */
97 	*nump = num;
98 	return (0);
99 invalid:
100 	errno = EINVAL;
101 	return (-1);
102 }
103 
104 static int
105 tcp_addr(const char *addr, int defport, struct sockaddr_storage *sap)
106 {
107 	char iporhost[MAXHOSTNAMELEN], portstr[6];
108 	struct addrinfo hints;
109 	struct addrinfo *res;
110 	const char *pp;
111 	intmax_t port;
112 	size_t size;
113 	int error;
114 
115 	if (addr == NULL)
116 		return (-1);
117 
118 	bzero(&hints, sizeof(hints));
119 	hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
120 	hints.ai_family = PF_UNSPEC;
121 	hints.ai_socktype = SOCK_STREAM;
122 	hints.ai_protocol = IPPROTO_TCP;
123 
124 	if (strncasecmp(addr, "tcp4://", 7) == 0) {
125 		addr += 7;
126 		hints.ai_family = PF_INET;
127 	} else if (strncasecmp(addr, "tcp6://", 7) == 0) {
128 		addr += 7;
129 		hints.ai_family = PF_INET6;
130 	} else if (strncasecmp(addr, "tcp://", 6) == 0) {
131 		addr += 6;
132 	} else {
133 		/*
134 		 * Because TCP is the default assume IP or host is given without
135 		 * prefix.
136 		 */
137 	}
138 
139 	/*
140 	 * Extract optional port.
141 	 * There are three cases to consider.
142 	 * 1. hostname with port, eg. freefall.freebsd.org:8457
143 	 * 2. IPv4 address with port, eg. 192.168.0.101:8457
144 	 * 3. IPv6 address with port, eg. [fe80::1]:8457
145 	 * We discover IPv6 address by checking for two colons and if port is
146 	 * given, the address has to start with [.
147 	 */
148 	pp = NULL;
149 	if (strchr(addr, ':') != strrchr(addr, ':')) {
150 		if (addr[0] == '[')
151 			pp = strrchr(addr, ':');
152 	} else {
153 		pp = strrchr(addr, ':');
154 	}
155 	if (pp == NULL) {
156 		/* Port not given, use the default. */
157 		port = defport;
158 	} else {
159 		if (numfromstr(pp + 1, 1, 65535, &port) < 0)
160 			return (errno);
161 	}
162 	(void)snprintf(portstr, sizeof(portstr), "%jd", (intmax_t)port);
163 	/* Extract host name or IP address. */
164 	if (pp == NULL) {
165 		size = sizeof(iporhost);
166 		if (strlcpy(iporhost, addr, size) >= size)
167 			return (ENAMETOOLONG);
168 	} else if (addr[0] == '[' && pp[-1] == ']') {
169 		size = (size_t)(pp - addr - 2 + 1);
170 		if (size > sizeof(iporhost))
171 			return (ENAMETOOLONG);
172 		(void)strlcpy(iporhost, addr + 1, size);
173 	} else {
174 		size = (size_t)(pp - addr + 1);
175 		if (size > sizeof(iporhost))
176 			return (ENAMETOOLONG);
177 		(void)strlcpy(iporhost, addr, size);
178 	}
179 
180 	error = getaddrinfo(iporhost, portstr, &hints, &res);
181 	if (error != 0) {
182 		pjdlog_debug(1, "getaddrinfo(%s, %s) failed: %s.", iporhost,
183 		    portstr, gai_strerror(error));
184 		return (EINVAL);
185 	}
186 	if (res == NULL)
187 		return (ENOENT);
188 
189 	memcpy(sap, res->ai_addr, res->ai_addrlen);
190 
191 	freeaddrinfo(res);
192 
193 	return (0);
194 }
195 
196 static int
197 tcp_setup_new(const char *addr, int side, struct tcp_ctx **tctxp)
198 {
199 	struct tcp_ctx *tctx;
200 	int error, nodelay;
201 
202 	PJDLOG_ASSERT(addr != NULL);
203 	PJDLOG_ASSERT(side == TCP_SIDE_CLIENT ||
204 	    side == TCP_SIDE_SERVER_LISTEN);
205 	PJDLOG_ASSERT(tctxp != NULL);
206 
207 	tctx = malloc(sizeof(*tctx));
208 	if (tctx == NULL)
209 		return (errno);
210 
211 	/* Parse given address. */
212 	error = tcp_addr(addr, atoi(proto_get("tcp:port")), &tctx->tc_sa);
213 	if (error != 0) {
214 		free(tctx);
215 		return (error);
216 	}
217 
218 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
219 
220 	tctx->tc_fd = socket(tctx->tc_sa.ss_family, SOCK_STREAM, 0);
221 	if (tctx->tc_fd == -1) {
222 		error = errno;
223 		free(tctx);
224 		return (error);
225 	}
226 
227 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
228 
229 	/* Socket settings. */
230 	nodelay = 1;
231 	if (setsockopt(tctx->tc_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay,
232 	    sizeof(nodelay)) == -1) {
233 		pjdlog_errno(LOG_WARNING, "Unable to set TCP_NOELAY");
234 	}
235 
236 	tctx->tc_wait_called = (side == TCP_SIDE_CLIENT ? false : true);
237 	tctx->tc_side = side;
238 	tctx->tc_magic = TCP_CTX_MAGIC;
239 	*tctxp = tctx;
240 
241 	return (0);
242 }
243 
244 static socklen_t
245 sockaddr_len(const struct sockaddr_storage *ss)
246 {
247 
248 #ifdef HAVE_SOCKADDR_STORAGE_SS_LEN
249 	return (ss->ss_len);
250 #else
251 	switch (ss->ss_family) {
252 	case AF_INET:
253 		return (sizeof(struct sockaddr_in));
254 	case AF_INET6:
255 		return (sizeof(struct sockaddr_in6));
256 	default:
257 		PJDLOG_ABORT("Unexpected family %hhu.", ss->ss_family);
258 	}
259 #endif
260 }
261 
262 static int
263 tcp_connect(const char *srcaddr, const char *dstaddr, int timeout, void **ctxp)
264 {
265 	struct tcp_ctx *tctx;
266 	struct sockaddr_storage sa;
267 	int error, flags, ret;
268 
269 	PJDLOG_ASSERT(srcaddr == NULL || srcaddr[0] != '\0');
270 	PJDLOG_ASSERT(dstaddr != NULL);
271 	PJDLOG_ASSERT(timeout >= -1);
272 
273 	error = tcp_setup_new(dstaddr, TCP_SIDE_CLIENT, &tctx);
274 	if (error != 0)
275 		return (error);
276 	if (srcaddr != NULL) {
277 		error = tcp_addr(srcaddr, 0, &sa);
278 		if (error != 0)
279 			goto fail;
280 		if (bind(tctx->tc_fd, (struct sockaddr *)&sa,
281 		    sockaddr_len(&sa)) == -1) {
282 			error = errno;
283 			goto fail;
284 		}
285 	}
286 
287 	flags = fcntl(tctx->tc_fd, F_GETFL);
288 	if (flags == -1) {
289 		error = errno;
290 		pjdlog_common(LOG_DEBUG, 1, errno, "fcntl(F_GETFL) failed");
291 		goto fail;
292 	}
293 	/*
294 	 * We make socket non-blocking so we can handle connection timeout
295 	 * manually.
296 	 */
297 	flags |= O_NONBLOCK;
298 	if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
299 		error = errno;
300 		pjdlog_common(LOG_DEBUG, 1, errno,
301 		    "fcntl(F_SETFL, O_NONBLOCK) failed");
302 		goto fail;
303 	}
304 
305 	ret = connect(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
306 	    sockaddr_len(&tctx->tc_sa));
307 	if (ret == -1 && errno != EINPROGRESS) {
308 		error = errno;
309 		pjdlog_common(LOG_DEBUG, 1, errno, "connect() failed");
310 		goto fail;
311 	}
312 
313 	if (timeout >= 0) {
314 		if (ret == -1) {
315 			/* Connection still in progress. Wait for it. */
316 			error = tcp_connect_wait(tctx, timeout);
317 			if (error != 0)
318 				goto fail;
319 		} else {
320 			/* Connection already complete. */
321 			flags &= ~O_NONBLOCK;
322 			if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
323 				error = errno;
324 				pjdlog_common(LOG_DEBUG, 1, errno,
325 				    "fcntl(F_SETFL, ~O_NONBLOCK) failed");
326 				goto fail;
327 			}
328 		}
329 	}
330 
331 	*ctxp = tctx;
332 	return (0);
333 fail:
334 	tcp_close(tctx);
335 	return (error);
336 }
337 
338 static int
339 tcp_connect_wait(void *ctx, int timeout)
340 {
341 	struct tcp_ctx *tctx = ctx;
342 	struct timeval tv;
343 	fd_set fdset;
344 	socklen_t esize;
345 	int error, flags, ret;
346 
347 	PJDLOG_ASSERT(tctx != NULL);
348 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
349 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT);
350 	PJDLOG_ASSERT(!tctx->tc_wait_called);
351 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
352 	PJDLOG_ASSERT(timeout >= 0);
353 
354 	tv.tv_sec = timeout;
355 	tv.tv_usec = 0;
356 again:
357 	FD_ZERO(&fdset);
358 	FD_SET(tctx->tc_fd, &fdset);
359 	ret = select(tctx->tc_fd + 1, NULL, &fdset, NULL, &tv);
360 	if (ret == 0) {
361 		error = ETIMEDOUT;
362 		goto done;
363 	} else if (ret == -1) {
364 		if (errno == EINTR)
365 			goto again;
366 		error = errno;
367 		pjdlog_common(LOG_DEBUG, 1, errno, "select() failed");
368 		goto done;
369 	}
370 	PJDLOG_ASSERT(ret > 0);
371 	PJDLOG_ASSERT(FD_ISSET(tctx->tc_fd, &fdset));
372 	esize = sizeof(error);
373 	if (getsockopt(tctx->tc_fd, SOL_SOCKET, SO_ERROR, &error,
374 	    &esize) == -1) {
375 		error = errno;
376 		pjdlog_common(LOG_DEBUG, 1, errno,
377 		    "getsockopt(SO_ERROR) failed");
378 		goto done;
379 	}
380 	if (error != 0) {
381 		pjdlog_common(LOG_DEBUG, 1, error,
382 		    "getsockopt(SO_ERROR) returned error");
383 		goto done;
384 	}
385 	error = 0;
386 	tctx->tc_wait_called = true;
387 done:
388 	flags = fcntl(tctx->tc_fd, F_GETFL);
389 	if (flags == -1) {
390 		if (error == 0)
391 			error = errno;
392 		pjdlog_common(LOG_DEBUG, 1, errno, "fcntl(F_GETFL) failed");
393 		return (error);
394 	}
395 	flags &= ~O_NONBLOCK;
396 	if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
397 		if (error == 0)
398 			error = errno;
399 		pjdlog_common(LOG_DEBUG, 1, errno,
400 		    "fcntl(F_SETFL, ~O_NONBLOCK) failed");
401 	}
402 	return (error);
403 }
404 
405 static int
406 tcp_server(const char *addr, void **ctxp)
407 {
408 	struct tcp_ctx *tctx;
409 	int error, val;
410 
411 	error = tcp_setup_new(addr, TCP_SIDE_SERVER_LISTEN, &tctx);
412 	if (error != 0)
413 		return (error);
414 
415 	val = 1;
416 	/* Ignore failure. */
417 	(void)setsockopt(tctx->tc_fd, SOL_SOCKET, SO_REUSEADDR, &val,
418 	   sizeof(val));
419 
420 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
421 
422 	if (bind(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
423 	    sockaddr_len(&tctx->tc_sa)) == -1) {
424 		error = errno;
425 		tcp_close(tctx);
426 		return (error);
427 	}
428 	if (listen(tctx->tc_fd, 8) == -1) {
429 		error = errno;
430 		tcp_close(tctx);
431 		return (error);
432 	}
433 
434 	*ctxp = tctx;
435 
436 	return (0);
437 }
438 
439 static int
440 tcp_accept(void *ctx, void **newctxp)
441 {
442 	struct tcp_ctx *tctx = ctx;
443 	struct tcp_ctx *newtctx;
444 	socklen_t fromlen;
445 	int ret;
446 
447 	PJDLOG_ASSERT(tctx != NULL);
448 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
449 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_SERVER_LISTEN);
450 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
451 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
452 
453 	newtctx = malloc(sizeof(*newtctx));
454 	if (newtctx == NULL)
455 		return (errno);
456 
457 	fromlen = sockaddr_len(&tctx->tc_sa);
458 	newtctx->tc_fd = accept(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
459 	    &fromlen);
460 	if (newtctx->tc_fd < 0) {
461 		ret = errno;
462 		free(newtctx);
463 		return (ret);
464 	}
465 
466 	newtctx->tc_wait_called = true;
467 	newtctx->tc_side = TCP_SIDE_SERVER_WORK;
468 	newtctx->tc_magic = TCP_CTX_MAGIC;
469 	*newctxp = newtctx;
470 
471 	return (0);
472 }
473 
474 static int
475 tcp_wrap(int fd, bool client, void **ctxp)
476 {
477 	struct tcp_ctx *tctx;
478 
479 	PJDLOG_ASSERT(fd >= 0);
480 	PJDLOG_ASSERT(ctxp != NULL);
481 
482 	tctx = malloc(sizeof(*tctx));
483 	if (tctx == NULL)
484 		return (errno);
485 
486 	tctx->tc_fd = fd;
487 	tctx->tc_sa.ss_family = AF_UNSPEC;
488 	tctx->tc_wait_called = (client ? false : true);
489 	tctx->tc_side = (client ? TCP_SIDE_CLIENT : TCP_SIDE_SERVER_WORK);
490 	tctx->tc_magic = TCP_CTX_MAGIC;
491 	*ctxp = tctx;
492 
493 	return (0);
494 }
495 
496 static int
497 tcp_send(void *ctx, const unsigned char *data, size_t size, int fd)
498 {
499 	struct tcp_ctx *tctx = ctx;
500 
501 	PJDLOG_ASSERT(tctx != NULL);
502 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
503 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT ||
504 	    tctx->tc_side == TCP_SIDE_SERVER_WORK);
505 	PJDLOG_ASSERT(tctx->tc_wait_called);
506 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
507 	PJDLOG_ASSERT(fd == -1);
508 
509 	return (proto_common_send(tctx->tc_fd, data, size, -1));
510 }
511 
512 static int
513 tcp_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
514 {
515 	struct tcp_ctx *tctx = ctx;
516 
517 	PJDLOG_ASSERT(tctx != NULL);
518 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
519 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT ||
520 	    tctx->tc_side == TCP_SIDE_SERVER_WORK);
521 	PJDLOG_ASSERT(tctx->tc_wait_called);
522 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
523 	PJDLOG_ASSERT(fdp == NULL);
524 
525 	return (proto_common_recv(tctx->tc_fd, data, size, NULL));
526 }
527 
528 static int
529 tcp_descriptor(const void *ctx)
530 {
531 	const struct tcp_ctx *tctx = ctx;
532 
533 	PJDLOG_ASSERT(tctx != NULL);
534 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
535 
536 	return (tctx->tc_fd);
537 }
538 
539 static bool
540 tcp_address_match(const void *ctx, const char *addr)
541 {
542 	const struct tcp_ctx *tctx = ctx;
543 	struct sockaddr_storage sa1, sa2;
544 	socklen_t salen;
545 
546 	PJDLOG_ASSERT(tctx != NULL);
547 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
548 
549 	if (tcp_addr(addr, atoi(proto_get("tcp:port")), &sa1) != 0)
550 		return (false);
551 
552 	salen = sizeof(sa2);
553 	if (getpeername(tctx->tc_fd, (struct sockaddr *)&sa2, &salen) < 0)
554 		return (false);
555 
556 	if (sa1.ss_family != sa2.ss_family)
557 		return (false);
558 
559 #ifdef HAVE_SOCKADDR_STORAGE_SS_LEN
560 	if (sa1.ss_len != sa2.ss_len)
561 		return (false);
562 #endif
563 
564 	switch (sa1.ss_family) {
565 	case AF_INET:
566 	    {
567 		struct sockaddr_in *sin1, *sin2;
568 
569 		sin1 = (struct sockaddr_in *)&sa1;
570 		sin2 = (struct sockaddr_in *)&sa2;
571 
572 		return (memcmp(&sin1->sin_addr, &sin2->sin_addr,
573 		    sizeof(sin1->sin_addr)) == 0);
574 	    }
575 	case AF_INET6:
576 	    {
577 		struct sockaddr_in6 *sin1, *sin2;
578 
579 		sin1 = (struct sockaddr_in6 *)&sa1;
580 		sin2 = (struct sockaddr_in6 *)&sa2;
581 
582 		return (memcmp(&sin1->sin6_addr, &sin2->sin6_addr,
583 		    sizeof(sin1->sin6_addr)) == 0);
584 	    }
585 	default:
586 		return (false);
587 	}
588 }
589 
590 #ifndef __FreeBSD__
591 static void
592 sockaddr_to_string(const void *sa, char *buf, size_t size)
593 {
594 	const struct sockaddr_storage *ss;
595 
596 	ss = (const struct sockaddr_storage * const *)sa;
597 	switch (ss->ss_family) {
598 	case AF_INET:
599 	    {
600 		char addr[INET_ADDRSTRLEN];
601 		const struct sockaddr_in *sin;
602 		unsigned int port;
603 
604 		sin = (const struct sockaddr_in *)ss;
605 		port = ntohs(sin->sin_port);
606 		if (inet_ntop(ss->ss_family, &sin->sin_addr, addr,
607 		    sizeof(addr)) == NULL) {
608 			PJDLOG_ABORT("inet_ntop(AF_INET) failed: %s.",
609 			    strerror(errno));
610 		}
611 		snprintf(buf, size, "%s:%u", addr, port);
612 		break;
613 	    }
614 	case AF_INET6:
615 	    {
616 		char addr[INET6_ADDRSTRLEN];
617 		const struct sockaddr_in6 *sin;
618 		unsigned int port;
619 
620 		sin = (const struct sockaddr_in6 *)ss;
621 		port = ntohs(sin->sin6_port);
622 		if (inet_ntop(ss->ss_family, &sin->sin6_addr, addr,
623 		    sizeof(addr)) == NULL) {
624 			PJDLOG_ABORT("inet_ntop(AF_INET6) failed: %s.",
625 			    strerror(errno));
626 		}
627 		snprintf(buf, size, "[%s]:%u", addr, port);
628 		break;
629 	    }
630 	default:
631 		snprintf(buf, size, "[unsupported family %hhu]",
632 		    ss->ss_family);
633 		break;
634 	}
635 }
636 #endif	/* !__FreeBSD__ */
637 
638 static void
639 tcp_local_address(const void *ctx, char *addr, size_t size)
640 {
641 	const struct tcp_ctx *tctx = ctx;
642 	struct sockaddr_storage sa;
643 	socklen_t salen;
644 
645 	PJDLOG_ASSERT(tctx != NULL);
646 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
647 
648 	salen = sizeof(sa);
649 	if (getsockname(tctx->tc_fd, (struct sockaddr *)&sa, &salen) < 0) {
650 		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
651 		return;
652 	}
653 #ifdef __FreeBSD__
654 	PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sa) < (ssize_t)size);
655 #else
656 	strlcpy(addr, "tcp://", size);
657 	if (size > 6)
658 		sockaddr_to_string(&sa, addr + 6, size - 6);
659 #endif
660 }
661 
662 static void
663 tcp_remote_address(const void *ctx, char *addr, size_t size)
664 {
665 	const struct tcp_ctx *tctx = ctx;
666 	struct sockaddr_storage sa;
667 	socklen_t salen;
668 
669 	PJDLOG_ASSERT(tctx != NULL);
670 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
671 
672 	salen = sizeof(sa);
673 	if (getpeername(tctx->tc_fd, (struct sockaddr *)&sa, &salen) < 0) {
674 		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
675 		return;
676 	}
677 #ifdef __FreeBSD__
678 	PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sa) < (ssize_t)size);
679 #else
680 	strlcpy(addr, "tcp://", size);
681 	if (size > 6)
682 		sockaddr_to_string(&sa, addr + 6, size - 6);
683 #endif
684 }
685 
686 static void
687 tcp_close(void *ctx)
688 {
689 	struct tcp_ctx *tctx = ctx;
690 
691 	PJDLOG_ASSERT(tctx != NULL);
692 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
693 
694 	if (tctx->tc_fd >= 0)
695 		close(tctx->tc_fd);
696 	tctx->tc_magic = 0;
697 	free(tctx);
698 }
699 
700 static struct proto tcp_proto = {
701 	.prt_name = "tcp",
702 	.prt_connect = tcp_connect,
703 	.prt_connect_wait = tcp_connect_wait,
704 	.prt_server = tcp_server,
705 	.prt_accept = tcp_accept,
706 	.prt_wrap = tcp_wrap,
707 	.prt_send = tcp_send,
708 	.prt_recv = tcp_recv,
709 	.prt_descriptor = tcp_descriptor,
710 	.prt_address_match = tcp_address_match,
711 	.prt_local_address = tcp_local_address,
712 	.prt_remote_address = tcp_remote_address,
713 	.prt_close = tcp_close
714 };
715 
716 static __constructor void
717 tcp_ctor(void)
718 {
719 
720 	proto_register(&tcp_proto, true);
721 }
722