xref: /freebsd/sbin/hastd/proto_tcp.c (revision 3494f7c0) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2009-2010 The FreeBSD Foundation
5  * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>
6  * All rights reserved.
7  *
8  * This software was developed by Pawel Jakub Dawidek under sponsorship from
9  * the FreeBSD Foundation.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
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 <string.h>
48 #include <unistd.h>
49 
50 #include "pjdlog.h"
51 #include "proto_impl.h"
52 #include "subr.h"
53 
54 #define	TCP_CTX_MAGIC	0x7c41c
55 struct tcp_ctx {
56 	int			tc_magic;
57 	struct sockaddr_storage	tc_sa;
58 	int			tc_fd;
59 	int			tc_side;
60 #define	TCP_SIDE_CLIENT		0
61 #define	TCP_SIDE_SERVER_LISTEN	1
62 #define	TCP_SIDE_SERVER_WORK	2
63 };
64 
65 static int tcp_connect_wait(void *ctx, int timeout);
66 static void tcp_close(void *ctx);
67 
68 /*
69  * Function converts the given string to unsigned number.
70  */
71 static int
72 numfromstr(const char *str, intmax_t minnum, intmax_t maxnum, intmax_t *nump)
73 {
74 	intmax_t digit, num;
75 
76 	if (str[0] == '\0')
77 		goto invalid;	/* Empty string. */
78 	num = 0;
79 	for (; *str != '\0'; str++) {
80 		if (*str < '0' || *str > '9')
81 			goto invalid;	/* Non-digit character. */
82 		digit = *str - '0';
83 		if (num > num * 10 + digit)
84 			goto invalid;	/* Overflow. */
85 		num = num * 10 + digit;
86 		if (num > maxnum)
87 			goto invalid;	/* Too big. */
88 	}
89 	if (num < minnum)
90 		goto invalid;	/* Too small. */
91 	*nump = num;
92 	return (0);
93 invalid:
94 	errno = EINVAL;
95 	return (-1);
96 }
97 
98 static int
99 tcp_addr(const char *addr, int defport, struct sockaddr_storage *sap)
100 {
101 	char iporhost[MAXHOSTNAMELEN], portstr[6];
102 	struct addrinfo hints;
103 	struct addrinfo *res;
104 	const char *pp;
105 	intmax_t port;
106 	size_t size;
107 	int error;
108 
109 	if (addr == NULL)
110 		return (-1);
111 
112 	bzero(&hints, sizeof(hints));
113 	hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
114 	hints.ai_family = PF_UNSPEC;
115 	hints.ai_socktype = SOCK_STREAM;
116 	hints.ai_protocol = IPPROTO_TCP;
117 
118 	if (strncasecmp(addr, "tcp4://", 7) == 0) {
119 		addr += 7;
120 		hints.ai_family = PF_INET;
121 	} else if (strncasecmp(addr, "tcp6://", 7) == 0) {
122 		addr += 7;
123 		hints.ai_family = PF_INET6;
124 	} else if (strncasecmp(addr, "tcp://", 6) == 0) {
125 		addr += 6;
126 	} else {
127 		/*
128 		 * Because TCP is the default assume IP or host is given without
129 		 * prefix.
130 		 */
131 	}
132 
133 	/*
134 	 * Extract optional port.
135 	 * There are three cases to consider.
136 	 * 1. hostname with port, eg. freefall.freebsd.org:8457
137 	 * 2. IPv4 address with port, eg. 192.168.0.101:8457
138 	 * 3. IPv6 address with port, eg. [fe80::1]:8457
139 	 * We discover IPv6 address by checking for two colons and if port is
140 	 * given, the address has to start with [.
141 	 */
142 	pp = NULL;
143 	if (strchr(addr, ':') != strrchr(addr, ':')) {
144 		if (addr[0] == '[')
145 			pp = strrchr(addr, ':');
146 	} else {
147 		pp = strrchr(addr, ':');
148 	}
149 	if (pp == NULL) {
150 		/* Port not given, use the default. */
151 		port = defport;
152 	} else {
153 		if (numfromstr(pp + 1, 1, 65535, &port) == -1)
154 			return (errno);
155 	}
156 	(void)snprintf(portstr, sizeof(portstr), "%jd", (intmax_t)port);
157 	/* Extract host name or IP address. */
158 	if (pp == NULL) {
159 		size = sizeof(iporhost);
160 		if (strlcpy(iporhost, addr, size) >= size)
161 			return (ENAMETOOLONG);
162 	} else if (addr[0] == '[' && pp[-1] == ']') {
163 		size = (size_t)(pp - addr - 2 + 1);
164 		if (size > sizeof(iporhost))
165 			return (ENAMETOOLONG);
166 		(void)strlcpy(iporhost, addr + 1, size);
167 	} else {
168 		size = (size_t)(pp - addr + 1);
169 		if (size > sizeof(iporhost))
170 			return (ENAMETOOLONG);
171 		(void)strlcpy(iporhost, addr, size);
172 	}
173 
174 	error = getaddrinfo(iporhost, portstr, &hints, &res);
175 	if (error != 0) {
176 		pjdlog_debug(1, "getaddrinfo(%s, %s) failed: %s.", iporhost,
177 		    portstr, gai_strerror(error));
178 		return (EINVAL);
179 	}
180 	if (res == NULL)
181 		return (ENOENT);
182 
183 	memcpy(sap, res->ai_addr, res->ai_addrlen);
184 
185 	freeaddrinfo(res);
186 
187 	return (0);
188 }
189 
190 static int
191 tcp_setup_new(const char *addr, int side, void **ctxp)
192 {
193 	struct tcp_ctx *tctx;
194 	int ret, nodelay;
195 
196 	PJDLOG_ASSERT(addr != NULL);
197 	PJDLOG_ASSERT(side == TCP_SIDE_CLIENT ||
198 	    side == TCP_SIDE_SERVER_LISTEN);
199 	PJDLOG_ASSERT(ctxp != NULL);
200 
201 	tctx = malloc(sizeof(*tctx));
202 	if (tctx == NULL)
203 		return (errno);
204 
205 	/* Parse given address. */
206 	if ((ret = tcp_addr(addr, PROTO_TCP_DEFAULT_PORT, &tctx->tc_sa)) != 0) {
207 		free(tctx);
208 		return (ret);
209 	}
210 
211 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
212 
213 	tctx->tc_fd = socket(tctx->tc_sa.ss_family, SOCK_STREAM, 0);
214 	if (tctx->tc_fd == -1) {
215 		ret = errno;
216 		free(tctx);
217 		return (ret);
218 	}
219 
220 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
221 
222 	/* Socket settings. */
223 	nodelay = 1;
224 	if (setsockopt(tctx->tc_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay,
225 	    sizeof(nodelay)) == -1) {
226 		pjdlog_errno(LOG_WARNING, "Unable to set TCP_NOELAY");
227 	}
228 
229 	tctx->tc_side = side;
230 	tctx->tc_magic = TCP_CTX_MAGIC;
231 	*ctxp = tctx;
232 
233 	return (0);
234 }
235 
236 static int
237 tcp_setup_wrap(int fd, int side, void **ctxp)
238 {
239 	struct tcp_ctx *tctx;
240 
241 	PJDLOG_ASSERT(fd >= 0);
242 	PJDLOG_ASSERT(side == TCP_SIDE_CLIENT ||
243 	    side == TCP_SIDE_SERVER_WORK);
244 	PJDLOG_ASSERT(ctxp != NULL);
245 
246 	tctx = malloc(sizeof(*tctx));
247 	if (tctx == NULL)
248 		return (errno);
249 
250 	tctx->tc_fd = fd;
251 	tctx->tc_sa.ss_family = AF_UNSPEC;
252 	tctx->tc_side = side;
253 	tctx->tc_magic = TCP_CTX_MAGIC;
254 	*ctxp = tctx;
255 
256 	return (0);
257 }
258 
259 static int
260 tcp_client(const char *srcaddr, const char *dstaddr, void **ctxp)
261 {
262 	struct tcp_ctx *tctx;
263 	struct sockaddr_storage sa;
264 	int ret;
265 
266 	ret = tcp_setup_new(dstaddr, TCP_SIDE_CLIENT, ctxp);
267 	if (ret != 0)
268 		return (ret);
269 	tctx = *ctxp;
270 	if (srcaddr == NULL)
271 		return (0);
272 	ret = tcp_addr(srcaddr, 0, &sa);
273 	if (ret != 0) {
274 		tcp_close(tctx);
275 		return (ret);
276 	}
277 	if (bind(tctx->tc_fd, (struct sockaddr *)&sa, sa.ss_len) == -1) {
278 		ret = errno;
279 		tcp_close(tctx);
280 		return (ret);
281 	}
282 	return (0);
283 }
284 
285 static int
286 tcp_connect(void *ctx, int timeout)
287 {
288 	struct tcp_ctx *tctx = ctx;
289 	int error, flags;
290 
291 	PJDLOG_ASSERT(tctx != NULL);
292 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
293 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT);
294 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
295 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
296 	PJDLOG_ASSERT(timeout >= -1);
297 
298 	flags = fcntl(tctx->tc_fd, F_GETFL);
299 	if (flags == -1) {
300 		pjdlog_common(LOG_DEBUG, 1, errno, "fcntl(F_GETFL) failed");
301 		return (errno);
302 	}
303 	/*
304 	 * We make socket non-blocking so we can handle connection timeout
305 	 * manually.
306 	 */
307 	flags |= O_NONBLOCK;
308 	if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
309 		pjdlog_common(LOG_DEBUG, 1, errno,
310 		    "fcntl(F_SETFL, O_NONBLOCK) failed");
311 		return (errno);
312 	}
313 
314 	if (connect(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
315 	    tctx->tc_sa.ss_len) == 0) {
316 		if (timeout == -1)
317 			return (0);
318 		error = 0;
319 		goto done;
320 	}
321 	if (errno != EINPROGRESS) {
322 		error = errno;
323 		pjdlog_common(LOG_DEBUG, 1, errno, "connect() failed");
324 		goto done;
325 	}
326 	if (timeout == -1)
327 		return (0);
328 	return (tcp_connect_wait(ctx, timeout));
329 done:
330 	flags &= ~O_NONBLOCK;
331 	if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
332 		if (error == 0)
333 			error = errno;
334 		pjdlog_common(LOG_DEBUG, 1, errno,
335 		    "fcntl(F_SETFL, ~O_NONBLOCK) failed");
336 	}
337 	return (error);
338 }
339 
340 static int
341 tcp_connect_wait(void *ctx, int timeout)
342 {
343 	struct tcp_ctx *tctx = ctx;
344 	struct timeval tv;
345 	fd_set fdset;
346 	socklen_t esize;
347 	int error, flags, ret;
348 
349 	PJDLOG_ASSERT(tctx != NULL);
350 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
351 	PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT);
352 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
353 	PJDLOG_ASSERT(timeout >= 0);
354 
355 	tv.tv_sec = timeout;
356 	tv.tv_usec = 0;
357 again:
358 	FD_ZERO(&fdset);
359 	FD_SET(tctx->tc_fd, &fdset);
360 	ret = select(tctx->tc_fd + 1, NULL, &fdset, NULL, &tv);
361 	if (ret == 0) {
362 		error = ETIMEDOUT;
363 		goto done;
364 	} else if (ret == -1) {
365 		if (errno == EINTR)
366 			goto again;
367 		error = errno;
368 		pjdlog_common(LOG_DEBUG, 1, errno, "select() failed");
369 		goto done;
370 	}
371 	PJDLOG_ASSERT(ret > 0);
372 	PJDLOG_ASSERT(FD_ISSET(tctx->tc_fd, &fdset));
373 	esize = sizeof(error);
374 	if (getsockopt(tctx->tc_fd, SOL_SOCKET, SO_ERROR, &error,
375 	    &esize) == -1) {
376 		error = errno;
377 		pjdlog_common(LOG_DEBUG, 1, errno,
378 		    "getsockopt(SO_ERROR) failed");
379 		goto done;
380 	}
381 	if (error != 0) {
382 		pjdlog_common(LOG_DEBUG, 1, error,
383 		    "getsockopt(SO_ERROR) returned error");
384 		goto done;
385 	}
386 	error = 0;
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 ret, val;
410 
411 	ret = tcp_setup_new(addr, TCP_SIDE_SERVER_LISTEN, ctxp);
412 	if (ret != 0)
413 		return (ret);
414 
415 	tctx = *ctxp;
416 
417 	val = 1;
418 	/* Ignore failure. */
419 	(void)setsockopt(tctx->tc_fd, SOL_SOCKET, SO_REUSEADDR, &val,
420 	   sizeof(val));
421 
422 	PJDLOG_ASSERT(tctx->tc_sa.ss_family != AF_UNSPEC);
423 
424 	if (bind(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
425 	    tctx->tc_sa.ss_len) == -1) {
426 		ret = errno;
427 		tcp_close(tctx);
428 		return (ret);
429 	}
430 	if (listen(tctx->tc_fd, 8) == -1) {
431 		ret = errno;
432 		tcp_close(tctx);
433 		return (ret);
434 	}
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 = tctx->tc_sa.ss_len;
458 	newtctx->tc_fd = accept(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sa,
459 	    &fromlen);
460 	if (newtctx->tc_fd == -1) {
461 		ret = errno;
462 		free(newtctx);
463 		return (ret);
464 	}
465 
466 	newtctx->tc_side = TCP_SIDE_SERVER_WORK;
467 	newtctx->tc_magic = TCP_CTX_MAGIC;
468 	*newctxp = newtctx;
469 
470 	return (0);
471 }
472 
473 static int
474 tcp_wrap(int fd, bool client, void **ctxp)
475 {
476 
477 	return (tcp_setup_wrap(fd,
478 	    client ? TCP_SIDE_CLIENT : TCP_SIDE_SERVER_WORK, ctxp));
479 }
480 
481 static int
482 tcp_send(void *ctx, const unsigned char *data, size_t size, int fd)
483 {
484 	struct tcp_ctx *tctx = ctx;
485 
486 	PJDLOG_ASSERT(tctx != NULL);
487 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
488 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
489 	PJDLOG_ASSERT(fd == -1);
490 
491 	return (proto_common_send(tctx->tc_fd, data, size, -1));
492 }
493 
494 static int
495 tcp_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
496 {
497 	struct tcp_ctx *tctx = ctx;
498 
499 	PJDLOG_ASSERT(tctx != NULL);
500 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
501 	PJDLOG_ASSERT(tctx->tc_fd >= 0);
502 	PJDLOG_ASSERT(fdp == NULL);
503 
504 	return (proto_common_recv(tctx->tc_fd, data, size, NULL));
505 }
506 
507 static int
508 tcp_descriptor(const void *ctx)
509 {
510 	const struct tcp_ctx *tctx = ctx;
511 
512 	PJDLOG_ASSERT(tctx != NULL);
513 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
514 
515 	return (tctx->tc_fd);
516 }
517 
518 static bool
519 tcp_address_match(const void *ctx, const char *addr)
520 {
521 	const struct tcp_ctx *tctx = ctx;
522 	struct sockaddr_storage sa1, sa2;
523 	socklen_t salen;
524 
525 	PJDLOG_ASSERT(tctx != NULL);
526 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
527 
528 	if (tcp_addr(addr, PROTO_TCP_DEFAULT_PORT, &sa1) != 0)
529 		return (false);
530 
531 	salen = sizeof(sa2);
532 	if (getpeername(tctx->tc_fd, (struct sockaddr *)&sa2, &salen) == -1)
533 		return (false);
534 
535 	if (sa1.ss_family != sa2.ss_family || sa1.ss_len != sa2.ss_len)
536 		return (false);
537 
538 	switch (sa1.ss_family) {
539 	case AF_INET:
540 	    {
541 		struct sockaddr_in *sin1, *sin2;
542 
543 		sin1 = (struct sockaddr_in *)&sa1;
544 		sin2 = (struct sockaddr_in *)&sa2;
545 
546 		return (memcmp(&sin1->sin_addr, &sin2->sin_addr,
547 		    sizeof(sin1->sin_addr)) == 0);
548 	    }
549 	case AF_INET6:
550 	    {
551 		struct sockaddr_in6 *sin1, *sin2;
552 
553 		sin1 = (struct sockaddr_in6 *)&sa1;
554 		sin2 = (struct sockaddr_in6 *)&sa2;
555 
556 		return (memcmp(&sin1->sin6_addr, &sin2->sin6_addr,
557 		    sizeof(sin1->sin6_addr)) == 0);
558 	    }
559 	default:
560 		return (false);
561 	}
562 }
563 
564 static void
565 tcp_local_address(const void *ctx, char *addr, size_t size)
566 {
567 	const struct tcp_ctx *tctx = ctx;
568 	struct sockaddr_storage sa;
569 	socklen_t salen;
570 
571 	PJDLOG_ASSERT(tctx != NULL);
572 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
573 
574 	salen = sizeof(sa);
575 	if (getsockname(tctx->tc_fd, (struct sockaddr *)&sa, &salen) == -1) {
576 		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
577 		return;
578 	}
579 	PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sa) < (ssize_t)size);
580 }
581 
582 static void
583 tcp_remote_address(const void *ctx, char *addr, size_t size)
584 {
585 	const struct tcp_ctx *tctx = ctx;
586 	struct sockaddr_storage sa;
587 	socklen_t salen;
588 
589 	PJDLOG_ASSERT(tctx != NULL);
590 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
591 
592 	salen = sizeof(sa);
593 	if (getpeername(tctx->tc_fd, (struct sockaddr *)&sa, &salen) == -1) {
594 		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
595 		return;
596 	}
597 	PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sa) < (ssize_t)size);
598 }
599 
600 static void
601 tcp_close(void *ctx)
602 {
603 	struct tcp_ctx *tctx = ctx;
604 
605 	PJDLOG_ASSERT(tctx != NULL);
606 	PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
607 
608 	if (tctx->tc_fd >= 0)
609 		close(tctx->tc_fd);
610 	tctx->tc_magic = 0;
611 	free(tctx);
612 }
613 
614 static struct proto tcp_proto = {
615 	.prt_name = "tcp",
616 	.prt_client = tcp_client,
617 	.prt_connect = tcp_connect,
618 	.prt_connect_wait = tcp_connect_wait,
619 	.prt_server = tcp_server,
620 	.prt_accept = tcp_accept,
621 	.prt_wrap = tcp_wrap,
622 	.prt_send = tcp_send,
623 	.prt_recv = tcp_recv,
624 	.prt_descriptor = tcp_descriptor,
625 	.prt_address_match = tcp_address_match,
626 	.prt_local_address = tcp_local_address,
627 	.prt_remote_address = tcp_remote_address,
628 	.prt_close = tcp_close
629 };
630 
631 static __constructor void
632 tcp_ctor(void)
633 {
634 
635 	proto_register(&tcp_proto, true);
636 }
637