xref: /freebsd/sys/netinet/tcp_subr.c (revision a33774adb3e7e902ca1742227ee070b93d602fc8)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	@(#)tcp_subr.c	8.2 (Berkeley) 5/24/95
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include "opt_inet.h"
38 #include "opt_inet6.h"
39 #include "opt_ipsec.h"
40 #include "opt_kern_tls.h"
41 #include "opt_tcpdebug.h"
42 
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/arb.h>
46 #include <sys/callout.h>
47 #include <sys/eventhandler.h>
48 #ifdef TCP_HHOOK
49 #include <sys/hhook.h>
50 #endif
51 #include <sys/kernel.h>
52 #ifdef TCP_HHOOK
53 #include <sys/khelp.h>
54 #endif
55 #ifdef KERN_TLS
56 #include <sys/ktls.h>
57 #endif
58 #include <sys/qmath.h>
59 #include <sys/stats.h>
60 #include <sys/sysctl.h>
61 #include <sys/jail.h>
62 #include <sys/malloc.h>
63 #include <sys/refcount.h>
64 #include <sys/mbuf.h>
65 #ifdef INET6
66 #include <sys/domain.h>
67 #endif
68 #include <sys/priv.h>
69 #include <sys/proc.h>
70 #include <sys/sdt.h>
71 #include <sys/socket.h>
72 #include <sys/socketvar.h>
73 #include <sys/protosw.h>
74 #include <sys/random.h>
75 
76 #include <vm/uma.h>
77 
78 #include <net/route.h>
79 #include <net/if.h>
80 #include <net/if_var.h>
81 #include <net/vnet.h>
82 
83 #include <netinet/in.h>
84 #include <netinet/in_fib.h>
85 #include <netinet/in_kdtrace.h>
86 #include <netinet/in_pcb.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/in_var.h>
89 #include <netinet/ip.h>
90 #include <netinet/ip_icmp.h>
91 #include <netinet/ip_var.h>
92 #ifdef INET6
93 #include <netinet/icmp6.h>
94 #include <netinet/ip6.h>
95 #include <netinet6/in6_fib.h>
96 #include <netinet6/in6_pcb.h>
97 #include <netinet6/ip6_var.h>
98 #include <netinet6/scope6_var.h>
99 #include <netinet6/nd6.h>
100 #endif
101 
102 #include <netinet/tcp.h>
103 #include <netinet/tcp_fsm.h>
104 #include <netinet/tcp_seq.h>
105 #include <netinet/tcp_timer.h>
106 #include <netinet/tcp_var.h>
107 #include <netinet/tcp_log_buf.h>
108 #include <netinet/tcp_syncache.h>
109 #include <netinet/tcp_hpts.h>
110 #include <netinet/cc/cc.h>
111 #ifdef INET6
112 #include <netinet6/tcp6_var.h>
113 #endif
114 #include <netinet/tcpip.h>
115 #include <netinet/tcp_fastopen.h>
116 #ifdef TCPPCAP
117 #include <netinet/tcp_pcap.h>
118 #endif
119 #ifdef TCPDEBUG
120 #include <netinet/tcp_debug.h>
121 #endif
122 #ifdef INET6
123 #include <netinet6/ip6protosw.h>
124 #endif
125 #ifdef TCP_OFFLOAD
126 #include <netinet/tcp_offload.h>
127 #endif
128 
129 #include <netipsec/ipsec_support.h>
130 
131 #include <machine/in_cksum.h>
132 #include <crypto/siphash/siphash.h>
133 
134 #include <security/mac/mac_framework.h>
135 
136 VNET_DEFINE(int, tcp_mssdflt) = TCP_MSS;
137 #ifdef INET6
138 VNET_DEFINE(int, tcp_v6mssdflt) = TCP6_MSS;
139 #endif
140 
141 #ifdef NETFLIX_EXP_DETECTION
142 /*  Sack attack detection thresholds and such */
143 SYSCTL_NODE(_net_inet_tcp, OID_AUTO, sack_attack, CTLFLAG_RW, 0,
144     "Sack Attack detection thresholds");
145 int32_t tcp_force_detection = 0;
146 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, force_detection,
147     CTLFLAG_RW,
148     &tcp_force_detection, 0,
149     "Do we force detection even if the INP has it off?");
150 int32_t tcp_sack_to_ack_thresh = 700;	/* 70 % */
151 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sack_to_ack_thresh,
152     CTLFLAG_RW,
153     &tcp_sack_to_ack_thresh, 700,
154     "Percentage of sacks to acks we must see above (10.1 percent is 101)?");
155 int32_t tcp_sack_to_move_thresh = 600;	/* 60 % */
156 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, move_thresh,
157     CTLFLAG_RW,
158     &tcp_sack_to_move_thresh, 600,
159     "Percentage of sack moves we must see above (10.1 percent is 101)");
160 int32_t tcp_restoral_thresh = 650;	/* 65 % (sack:2:ack -5%) */
161 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, restore_thresh,
162     CTLFLAG_RW,
163     &tcp_restoral_thresh, 550,
164     "Percentage of sack to ack percentage we must see below to restore(10.1 percent is 101)");
165 int32_t tcp_sad_decay_val = 800;
166 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, decay_per,
167     CTLFLAG_RW,
168     &tcp_sad_decay_val, 800,
169     "The decay percentage (10.1 percent equals 101 )");
170 int32_t tcp_map_minimum = 500;
171 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, nummaps,
172     CTLFLAG_RW,
173     &tcp_map_minimum, 500,
174     "Number of Map enteries before we start detection");
175 int32_t tcp_attack_on_turns_on_logging = 0;
176 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, attacks_logged,
177     CTLFLAG_RW,
178     &tcp_attack_on_turns_on_logging, 0,
179    "When we have a positive hit on attack, do we turn on logging?");
180 int32_t tcp_sad_pacing_interval = 2000;
181 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sad_pacing_int,
182     CTLFLAG_RW,
183     &tcp_sad_pacing_interval, 2000,
184     "What is the minimum pacing interval for a classified attacker?");
185 
186 int32_t tcp_sad_low_pps = 100;
187 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sad_low_pps,
188     CTLFLAG_RW,
189     &tcp_sad_low_pps, 100,
190     "What is the input pps that below which we do not decay?");
191 #endif
192 
193 struct rwlock tcp_function_lock;
194 
195 static int
196 sysctl_net_inet_tcp_mss_check(SYSCTL_HANDLER_ARGS)
197 {
198 	int error, new;
199 
200 	new = V_tcp_mssdflt;
201 	error = sysctl_handle_int(oidp, &new, 0, req);
202 	if (error == 0 && req->newptr) {
203 		if (new < TCP_MINMSS)
204 			error = EINVAL;
205 		else
206 			V_tcp_mssdflt = new;
207 	}
208 	return (error);
209 }
210 
211 SYSCTL_PROC(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt,
212     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW, &VNET_NAME(tcp_mssdflt), 0,
213     &sysctl_net_inet_tcp_mss_check, "I",
214     "Default TCP Maximum Segment Size");
215 
216 #ifdef INET6
217 static int
218 sysctl_net_inet_tcp_mss_v6_check(SYSCTL_HANDLER_ARGS)
219 {
220 	int error, new;
221 
222 	new = V_tcp_v6mssdflt;
223 	error = sysctl_handle_int(oidp, &new, 0, req);
224 	if (error == 0 && req->newptr) {
225 		if (new < TCP_MINMSS)
226 			error = EINVAL;
227 		else
228 			V_tcp_v6mssdflt = new;
229 	}
230 	return (error);
231 }
232 
233 SYSCTL_PROC(_net_inet_tcp, TCPCTL_V6MSSDFLT, v6mssdflt,
234     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW, &VNET_NAME(tcp_v6mssdflt), 0,
235     &sysctl_net_inet_tcp_mss_v6_check, "I",
236    "Default TCP Maximum Segment Size for IPv6");
237 #endif /* INET6 */
238 
239 /*
240  * Minimum MSS we accept and use. This prevents DoS attacks where
241  * we are forced to a ridiculous low MSS like 20 and send hundreds
242  * of packets instead of one. The effect scales with the available
243  * bandwidth and quickly saturates the CPU and network interface
244  * with packet generation and sending. Set to zero to disable MINMSS
245  * checking. This setting prevents us from sending too small packets.
246  */
247 VNET_DEFINE(int, tcp_minmss) = TCP_MINMSS;
248 SYSCTL_INT(_net_inet_tcp, OID_AUTO, minmss, CTLFLAG_VNET | CTLFLAG_RW,
249      &VNET_NAME(tcp_minmss), 0,
250     "Minimum TCP Maximum Segment Size");
251 
252 VNET_DEFINE(int, tcp_do_rfc1323) = 1;
253 SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, CTLFLAG_VNET | CTLFLAG_RW,
254     &VNET_NAME(tcp_do_rfc1323), 0,
255     "Enable rfc1323 (high performance TCP) extensions");
256 
257 VNET_DEFINE(int, tcp_ts_offset_per_conn) = 1;
258 SYSCTL_INT(_net_inet_tcp, OID_AUTO, ts_offset_per_conn, CTLFLAG_VNET | CTLFLAG_RW,
259     &VNET_NAME(tcp_ts_offset_per_conn), 0,
260     "Initialize TCP timestamps per connection instead of per host pair");
261 
262 static int	tcp_log_debug = 0;
263 SYSCTL_INT(_net_inet_tcp, OID_AUTO, log_debug, CTLFLAG_RW,
264     &tcp_log_debug, 0, "Log errors caused by incoming TCP segments");
265 
266 static int	tcp_tcbhashsize;
267 SYSCTL_INT(_net_inet_tcp, OID_AUTO, tcbhashsize, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
268     &tcp_tcbhashsize, 0, "Size of TCP control-block hashtable");
269 
270 static int	do_tcpdrain = 1;
271 SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_tcpdrain, CTLFLAG_RW, &do_tcpdrain, 0,
272     "Enable tcp_drain routine for extra help when low on mbufs");
273 
274 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_VNET | CTLFLAG_RD,
275     &VNET_NAME(tcbinfo.ipi_count), 0, "Number of active PCBs");
276 
277 VNET_DEFINE_STATIC(int, icmp_may_rst) = 1;
278 #define	V_icmp_may_rst			VNET(icmp_may_rst)
279 SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_may_rst, CTLFLAG_VNET | CTLFLAG_RW,
280     &VNET_NAME(icmp_may_rst), 0,
281     "Certain ICMP unreachable messages may abort connections in SYN_SENT");
282 
283 VNET_DEFINE_STATIC(int, tcp_isn_reseed_interval) = 0;
284 #define	V_tcp_isn_reseed_interval	VNET(tcp_isn_reseed_interval)
285 SYSCTL_INT(_net_inet_tcp, OID_AUTO, isn_reseed_interval, CTLFLAG_VNET | CTLFLAG_RW,
286     &VNET_NAME(tcp_isn_reseed_interval), 0,
287     "Seconds between reseeding of ISN secret");
288 
289 static int	tcp_soreceive_stream;
290 SYSCTL_INT(_net_inet_tcp, OID_AUTO, soreceive_stream, CTLFLAG_RDTUN,
291     &tcp_soreceive_stream, 0, "Using soreceive_stream for TCP sockets");
292 
293 VNET_DEFINE(uma_zone_t, sack_hole_zone);
294 #define	V_sack_hole_zone		VNET(sack_hole_zone)
295 VNET_DEFINE(uint32_t, tcp_map_entries_limit) = 0;	/* unlimited */
296 static int
297 sysctl_net_inet_tcp_map_limit_check(SYSCTL_HANDLER_ARGS)
298 {
299 	int error;
300 	uint32_t new;
301 
302 	new = V_tcp_map_entries_limit;
303 	error = sysctl_handle_int(oidp, &new, 0, req);
304 	if (error == 0 && req->newptr) {
305 		/* only allow "0" and value > minimum */
306 		if (new > 0 && new < TCP_MIN_MAP_ENTRIES_LIMIT)
307 			error = EINVAL;
308 		else
309 			V_tcp_map_entries_limit = new;
310 	}
311 	return (error);
312 }
313 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, map_limit,
314     CTLFLAG_VNET | CTLTYPE_UINT | CTLFLAG_RW,
315     &VNET_NAME(tcp_map_entries_limit), 0,
316     &sysctl_net_inet_tcp_map_limit_check, "IU",
317     "Total sendmap entries limit");
318 
319 VNET_DEFINE(uint32_t, tcp_map_split_limit) = 0;	/* unlimited */
320 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, split_limit, CTLFLAG_VNET | CTLFLAG_RW,
321      &VNET_NAME(tcp_map_split_limit), 0,
322     "Total sendmap split entries limit");
323 
324 #ifdef TCP_HHOOK
325 VNET_DEFINE(struct hhook_head *, tcp_hhh[HHOOK_TCP_LAST+1]);
326 #endif
327 
328 #define TS_OFFSET_SECRET_LENGTH SIPHASH_KEY_LENGTH
329 VNET_DEFINE_STATIC(u_char, ts_offset_secret[TS_OFFSET_SECRET_LENGTH]);
330 #define	V_ts_offset_secret	VNET(ts_offset_secret)
331 
332 static int	tcp_default_fb_init(struct tcpcb *tp);
333 static void	tcp_default_fb_fini(struct tcpcb *tp, int tcb_is_purged);
334 static int	tcp_default_handoff_ok(struct tcpcb *tp);
335 static struct inpcb *tcp_notify(struct inpcb *, int);
336 static struct inpcb *tcp_mtudisc_notify(struct inpcb *, int);
337 static void tcp_mtudisc(struct inpcb *, int);
338 static char *	tcp_log_addr(struct in_conninfo *inc, struct tcphdr *th,
339 		    void *ip4hdr, const void *ip6hdr);
340 
341 
342 static struct tcp_function_block tcp_def_funcblk = {
343 	.tfb_tcp_block_name = "freebsd",
344 	.tfb_tcp_output = tcp_output,
345 	.tfb_tcp_do_segment = tcp_do_segment,
346 	.tfb_tcp_ctloutput = tcp_default_ctloutput,
347 	.tfb_tcp_handoff_ok = tcp_default_handoff_ok,
348 	.tfb_tcp_fb_init = tcp_default_fb_init,
349 	.tfb_tcp_fb_fini = tcp_default_fb_fini,
350 };
351 
352 static int tcp_fb_cnt = 0;
353 struct tcp_funchead t_functions;
354 static struct tcp_function_block *tcp_func_set_ptr = &tcp_def_funcblk;
355 
356 static struct tcp_function_block *
357 find_tcp_functions_locked(struct tcp_function_set *fs)
358 {
359 	struct tcp_function *f;
360 	struct tcp_function_block *blk=NULL;
361 
362 	TAILQ_FOREACH(f, &t_functions, tf_next) {
363 		if (strcmp(f->tf_name, fs->function_set_name) == 0) {
364 			blk = f->tf_fb;
365 			break;
366 		}
367 	}
368 	return(blk);
369 }
370 
371 static struct tcp_function_block *
372 find_tcp_fb_locked(struct tcp_function_block *blk, struct tcp_function **s)
373 {
374 	struct tcp_function_block *rblk=NULL;
375 	struct tcp_function *f;
376 
377 	TAILQ_FOREACH(f, &t_functions, tf_next) {
378 		if (f->tf_fb == blk) {
379 			rblk = blk;
380 			if (s) {
381 				*s = f;
382 			}
383 			break;
384 		}
385 	}
386 	return (rblk);
387 }
388 
389 struct tcp_function_block *
390 find_and_ref_tcp_functions(struct tcp_function_set *fs)
391 {
392 	struct tcp_function_block *blk;
393 
394 	rw_rlock(&tcp_function_lock);
395 	blk = find_tcp_functions_locked(fs);
396 	if (blk)
397 		refcount_acquire(&blk->tfb_refcnt);
398 	rw_runlock(&tcp_function_lock);
399 	return(blk);
400 }
401 
402 struct tcp_function_block *
403 find_and_ref_tcp_fb(struct tcp_function_block *blk)
404 {
405 	struct tcp_function_block *rblk;
406 
407 	rw_rlock(&tcp_function_lock);
408 	rblk = find_tcp_fb_locked(blk, NULL);
409 	if (rblk)
410 		refcount_acquire(&rblk->tfb_refcnt);
411 	rw_runlock(&tcp_function_lock);
412 	return(rblk);
413 }
414 
415 static struct tcp_function_block *
416 find_and_ref_tcp_default_fb(void)
417 {
418 	struct tcp_function_block *rblk;
419 
420 	rw_rlock(&tcp_function_lock);
421 	rblk = tcp_func_set_ptr;
422 	refcount_acquire(&rblk->tfb_refcnt);
423 	rw_runlock(&tcp_function_lock);
424 	return (rblk);
425 }
426 
427 void
428 tcp_switch_back_to_default(struct tcpcb *tp)
429 {
430 	struct tcp_function_block *tfb;
431 
432 	KASSERT(tp->t_fb != &tcp_def_funcblk,
433 	    ("%s: called by the built-in default stack", __func__));
434 
435 	/*
436 	 * Release the old stack. This function will either find a new one
437 	 * or panic.
438 	 */
439 	if (tp->t_fb->tfb_tcp_fb_fini != NULL)
440 		(*tp->t_fb->tfb_tcp_fb_fini)(tp, 0);
441 	refcount_release(&tp->t_fb->tfb_refcnt);
442 
443 	/*
444 	 * Now, we'll find a new function block to use.
445 	 * Start by trying the current user-selected
446 	 * default, unless this stack is the user-selected
447 	 * default.
448 	 */
449 	tfb = find_and_ref_tcp_default_fb();
450 	if (tfb == tp->t_fb) {
451 		refcount_release(&tfb->tfb_refcnt);
452 		tfb = NULL;
453 	}
454 	/* Does the stack accept this connection? */
455 	if (tfb != NULL && tfb->tfb_tcp_handoff_ok != NULL &&
456 	    (*tfb->tfb_tcp_handoff_ok)(tp)) {
457 		refcount_release(&tfb->tfb_refcnt);
458 		tfb = NULL;
459 	}
460 	/* Try to use that stack. */
461 	if (tfb != NULL) {
462 		/* Initialize the new stack. If it succeeds, we are done. */
463 		tp->t_fb = tfb;
464 		if (tp->t_fb->tfb_tcp_fb_init == NULL ||
465 		    (*tp->t_fb->tfb_tcp_fb_init)(tp) == 0)
466 			return;
467 
468 		/*
469 		 * Initialization failed. Release the reference count on
470 		 * the stack.
471 		 */
472 		refcount_release(&tfb->tfb_refcnt);
473 	}
474 
475 	/*
476 	 * If that wasn't feasible, use the built-in default
477 	 * stack which is not allowed to reject anyone.
478 	 */
479 	tfb = find_and_ref_tcp_fb(&tcp_def_funcblk);
480 	if (tfb == NULL) {
481 		/* there always should be a default */
482 		panic("Can't refer to tcp_def_funcblk");
483 	}
484 	if (tfb->tfb_tcp_handoff_ok != NULL) {
485 		if ((*tfb->tfb_tcp_handoff_ok) (tp)) {
486 			/* The default stack cannot say no */
487 			panic("Default stack rejects a new session?");
488 		}
489 	}
490 	tp->t_fb = tfb;
491 	if (tp->t_fb->tfb_tcp_fb_init != NULL &&
492 	    (*tp->t_fb->tfb_tcp_fb_init)(tp)) {
493 		/* The default stack cannot fail */
494 		panic("Default stack initialization failed");
495 	}
496 }
497 
498 static int
499 sysctl_net_inet_default_tcp_functions(SYSCTL_HANDLER_ARGS)
500 {
501 	int error=ENOENT;
502 	struct tcp_function_set fs;
503 	struct tcp_function_block *blk;
504 
505 	memset(&fs, 0, sizeof(fs));
506 	rw_rlock(&tcp_function_lock);
507 	blk = find_tcp_fb_locked(tcp_func_set_ptr, NULL);
508 	if (blk) {
509 		/* Found him */
510 		strcpy(fs.function_set_name, blk->tfb_tcp_block_name);
511 		fs.pcbcnt = blk->tfb_refcnt;
512 	}
513 	rw_runlock(&tcp_function_lock);
514 	error = sysctl_handle_string(oidp, fs.function_set_name,
515 				     sizeof(fs.function_set_name), req);
516 
517 	/* Check for error or no change */
518 	if (error != 0 || req->newptr == NULL)
519 		return(error);
520 
521 	rw_wlock(&tcp_function_lock);
522 	blk = find_tcp_functions_locked(&fs);
523 	if ((blk == NULL) ||
524 	    (blk->tfb_flags & TCP_FUNC_BEING_REMOVED)) {
525 		error = ENOENT;
526 		goto done;
527 	}
528 	tcp_func_set_ptr = blk;
529 done:
530 	rw_wunlock(&tcp_function_lock);
531 	return (error);
532 }
533 
534 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_default,
535 	    CTLTYPE_STRING | CTLFLAG_RW,
536 	    NULL, 0, sysctl_net_inet_default_tcp_functions, "A",
537 	    "Set/get the default TCP functions");
538 
539 static int
540 sysctl_net_inet_list_available(SYSCTL_HANDLER_ARGS)
541 {
542 	int error, cnt, linesz;
543 	struct tcp_function *f;
544 	char *buffer, *cp;
545 	size_t bufsz, outsz;
546 	bool alias;
547 
548 	cnt = 0;
549 	rw_rlock(&tcp_function_lock);
550 	TAILQ_FOREACH(f, &t_functions, tf_next) {
551 		cnt++;
552 	}
553 	rw_runlock(&tcp_function_lock);
554 
555 	bufsz = (cnt+2) * ((TCP_FUNCTION_NAME_LEN_MAX * 2) + 13) + 1;
556 	buffer = malloc(bufsz, M_TEMP, M_WAITOK);
557 
558 	error = 0;
559 	cp = buffer;
560 
561 	linesz = snprintf(cp, bufsz, "\n%-32s%c %-32s %s\n", "Stack", 'D',
562 	    "Alias", "PCB count");
563 	cp += linesz;
564 	bufsz -= linesz;
565 	outsz = linesz;
566 
567 	rw_rlock(&tcp_function_lock);
568 	TAILQ_FOREACH(f, &t_functions, tf_next) {
569 		alias = (f->tf_name != f->tf_fb->tfb_tcp_block_name);
570 		linesz = snprintf(cp, bufsz, "%-32s%c %-32s %u\n",
571 		    f->tf_fb->tfb_tcp_block_name,
572 		    (f->tf_fb == tcp_func_set_ptr) ? '*' : ' ',
573 		    alias ? f->tf_name : "-",
574 		    f->tf_fb->tfb_refcnt);
575 		if (linesz >= bufsz) {
576 			error = EOVERFLOW;
577 			break;
578 		}
579 		cp += linesz;
580 		bufsz -= linesz;
581 		outsz += linesz;
582 	}
583 	rw_runlock(&tcp_function_lock);
584 	if (error == 0)
585 		error = sysctl_handle_string(oidp, buffer, outsz + 1, req);
586 	free(buffer, M_TEMP);
587 	return (error);
588 }
589 
590 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_available,
591 	    CTLTYPE_STRING|CTLFLAG_RD,
592 	    NULL, 0, sysctl_net_inet_list_available, "A",
593 	    "list available TCP Function sets");
594 
595 /*
596  * Exports one (struct tcp_function_info) for each alias/name.
597  */
598 static int
599 sysctl_net_inet_list_func_info(SYSCTL_HANDLER_ARGS)
600 {
601 	int cnt, error;
602 	struct tcp_function *f;
603 	struct tcp_function_info tfi;
604 
605 	/*
606 	 * We don't allow writes.
607 	 */
608 	if (req->newptr != NULL)
609 		return (EINVAL);
610 
611 	/*
612 	 * Wire the old buffer so we can directly copy the functions to
613 	 * user space without dropping the lock.
614 	 */
615 	if (req->oldptr != NULL) {
616 		error = sysctl_wire_old_buffer(req, 0);
617 		if (error)
618 			return (error);
619 	}
620 
621 	/*
622 	 * Walk the list and copy out matching entries. If INVARIANTS
623 	 * is compiled in, also walk the list to verify the length of
624 	 * the list matches what we have recorded.
625 	 */
626 	rw_rlock(&tcp_function_lock);
627 
628 	cnt = 0;
629 #ifndef INVARIANTS
630 	if (req->oldptr == NULL) {
631 		cnt = tcp_fb_cnt;
632 		goto skip_loop;
633 	}
634 #endif
635 	TAILQ_FOREACH(f, &t_functions, tf_next) {
636 #ifdef INVARIANTS
637 		cnt++;
638 #endif
639 		if (req->oldptr != NULL) {
640 			bzero(&tfi, sizeof(tfi));
641 			tfi.tfi_refcnt = f->tf_fb->tfb_refcnt;
642 			tfi.tfi_id = f->tf_fb->tfb_id;
643 			(void)strlcpy(tfi.tfi_alias, f->tf_name,
644 			    sizeof(tfi.tfi_alias));
645 			(void)strlcpy(tfi.tfi_name,
646 			    f->tf_fb->tfb_tcp_block_name, sizeof(tfi.tfi_name));
647 			error = SYSCTL_OUT(req, &tfi, sizeof(tfi));
648 			/*
649 			 * Don't stop on error, as that is the
650 			 * mechanism we use to accumulate length
651 			 * information if the buffer was too short.
652 			 */
653 		}
654 	}
655 	KASSERT(cnt == tcp_fb_cnt,
656 	    ("%s: cnt (%d) != tcp_fb_cnt (%d)", __func__, cnt, tcp_fb_cnt));
657 #ifndef INVARIANTS
658 skip_loop:
659 #endif
660 	rw_runlock(&tcp_function_lock);
661 	if (req->oldptr == NULL)
662 		error = SYSCTL_OUT(req, NULL,
663 		    (cnt + 1) * sizeof(struct tcp_function_info));
664 
665 	return (error);
666 }
667 
668 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, function_info,
669 	    CTLTYPE_OPAQUE | CTLFLAG_SKIP | CTLFLAG_RD | CTLFLAG_MPSAFE,
670 	    NULL, 0, sysctl_net_inet_list_func_info, "S,tcp_function_info",
671 	    "List TCP function block name-to-ID mappings");
672 
673 /*
674  * tfb_tcp_handoff_ok() function for the default stack.
675  * Note that we'll basically try to take all comers.
676  */
677 static int
678 tcp_default_handoff_ok(struct tcpcb *tp)
679 {
680 
681 	return (0);
682 }
683 
684 /*
685  * tfb_tcp_fb_init() function for the default stack.
686  *
687  * This handles making sure we have appropriate timers set if you are
688  * transitioning a socket that has some amount of setup done.
689  *
690  * The init() fuction from the default can *never* return non-zero i.e.
691  * it is required to always succeed since it is the stack of last resort!
692  */
693 static int
694 tcp_default_fb_init(struct tcpcb *tp)
695 {
696 
697 	struct socket *so;
698 
699 	INP_WLOCK_ASSERT(tp->t_inpcb);
700 
701 	KASSERT(tp->t_state >= 0 && tp->t_state < TCPS_TIME_WAIT,
702 	    ("%s: connection %p in unexpected state %d", __func__, tp,
703 	    tp->t_state));
704 
705 	/*
706 	 * Nothing to do for ESTABLISHED or LISTEN states. And, we don't
707 	 * know what to do for unexpected states (which includes TIME_WAIT).
708 	 */
709 	if (tp->t_state <= TCPS_LISTEN || tp->t_state >= TCPS_TIME_WAIT)
710 		return (0);
711 
712 	/*
713 	 * Make sure some kind of transmission timer is set if there is
714 	 * outstanding data.
715 	 */
716 	so = tp->t_inpcb->inp_socket;
717 	if ((!TCPS_HAVEESTABLISHED(tp->t_state) || sbavail(&so->so_snd) ||
718 	    tp->snd_una != tp->snd_max) && !(tcp_timer_active(tp, TT_REXMT) ||
719 	    tcp_timer_active(tp, TT_PERSIST))) {
720 		/*
721 		 * If the session has established and it looks like it should
722 		 * be in the persist state, set the persist timer. Otherwise,
723 		 * set the retransmit timer.
724 		 */
725 		if (TCPS_HAVEESTABLISHED(tp->t_state) && tp->snd_wnd == 0 &&
726 		    (int32_t)(tp->snd_nxt - tp->snd_una) <
727 		    (int32_t)sbavail(&so->so_snd))
728 			tcp_setpersist(tp);
729 		else
730 			tcp_timer_activate(tp, TT_REXMT, tp->t_rxtcur);
731 	}
732 
733 	/* All non-embryonic sessions get a keepalive timer. */
734 	if (!tcp_timer_active(tp, TT_KEEP))
735 		tcp_timer_activate(tp, TT_KEEP,
736 		    TCPS_HAVEESTABLISHED(tp->t_state) ? TP_KEEPIDLE(tp) :
737 		    TP_KEEPINIT(tp));
738 
739 	return (0);
740 }
741 
742 /*
743  * tfb_tcp_fb_fini() function for the default stack.
744  *
745  * This changes state as necessary (or prudent) to prepare for another stack
746  * to assume responsibility for the connection.
747  */
748 static void
749 tcp_default_fb_fini(struct tcpcb *tp, int tcb_is_purged)
750 {
751 
752 	INP_WLOCK_ASSERT(tp->t_inpcb);
753 	return;
754 }
755 
756 /*
757  * Target size of TCP PCB hash tables. Must be a power of two.
758  *
759  * Note that this can be overridden by the kernel environment
760  * variable net.inet.tcp.tcbhashsize
761  */
762 #ifndef TCBHASHSIZE
763 #define TCBHASHSIZE	0
764 #endif
765 
766 /*
767  * XXX
768  * Callouts should be moved into struct tcp directly.  They are currently
769  * separate because the tcpcb structure is exported to userland for sysctl
770  * parsing purposes, which do not know about callouts.
771  */
772 struct tcpcb_mem {
773 	struct	tcpcb		tcb;
774 	struct	tcp_timer	tt;
775 	struct	cc_var		ccv;
776 #ifdef TCP_HHOOK
777 	struct	osd		osd;
778 #endif
779 };
780 
781 VNET_DEFINE_STATIC(uma_zone_t, tcpcb_zone);
782 #define	V_tcpcb_zone			VNET(tcpcb_zone)
783 
784 MALLOC_DEFINE(M_TCPLOG, "tcplog", "TCP address and flags print buffers");
785 MALLOC_DEFINE(M_TCPFUNCTIONS, "tcpfunc", "TCP function set memory");
786 
787 static struct mtx isn_mtx;
788 
789 #define	ISN_LOCK_INIT()	mtx_init(&isn_mtx, "isn_mtx", NULL, MTX_DEF)
790 #define	ISN_LOCK()	mtx_lock(&isn_mtx)
791 #define	ISN_UNLOCK()	mtx_unlock(&isn_mtx)
792 
793 /*
794  * TCP initialization.
795  */
796 static void
797 tcp_zone_change(void *tag)
798 {
799 
800 	uma_zone_set_max(V_tcbinfo.ipi_zone, maxsockets);
801 	uma_zone_set_max(V_tcpcb_zone, maxsockets);
802 	tcp_tw_zone_change();
803 }
804 
805 static int
806 tcp_inpcb_init(void *mem, int size, int flags)
807 {
808 	struct inpcb *inp = mem;
809 
810 	INP_LOCK_INIT(inp, "inp", "tcpinp");
811 	return (0);
812 }
813 
814 /*
815  * Take a value and get the next power of 2 that doesn't overflow.
816  * Used to size the tcp_inpcb hash buckets.
817  */
818 static int
819 maketcp_hashsize(int size)
820 {
821 	int hashsize;
822 
823 	/*
824 	 * auto tune.
825 	 * get the next power of 2 higher than maxsockets.
826 	 */
827 	hashsize = 1 << fls(size);
828 	/* catch overflow, and just go one power of 2 smaller */
829 	if (hashsize < size) {
830 		hashsize = 1 << (fls(size) - 1);
831 	}
832 	return (hashsize);
833 }
834 
835 static volatile int next_tcp_stack_id = 1;
836 
837 /*
838  * Register a TCP function block with the name provided in the names
839  * array.  (Note that this function does NOT automatically register
840  * blk->tfb_tcp_block_name as a stack name.  Therefore, you should
841  * explicitly include blk->tfb_tcp_block_name in the list of names if
842  * you wish to register the stack with that name.)
843  *
844  * Either all name registrations will succeed or all will fail.  If
845  * a name registration fails, the function will update the num_names
846  * argument to point to the array index of the name that encountered
847  * the failure.
848  *
849  * Returns 0 on success, or an error code on failure.
850  */
851 int
852 register_tcp_functions_as_names(struct tcp_function_block *blk, int wait,
853     const char *names[], int *num_names)
854 {
855 	struct tcp_function *n;
856 	struct tcp_function_set fs;
857 	int error, i;
858 
859 	KASSERT(names != NULL && *num_names > 0,
860 	    ("%s: Called with 0-length name list", __func__));
861 	KASSERT(names != NULL, ("%s: Called with NULL name list", __func__));
862 	KASSERT(rw_initialized(&tcp_function_lock),
863 	    ("%s: called too early", __func__));
864 
865 	if ((blk->tfb_tcp_output == NULL) ||
866 	    (blk->tfb_tcp_do_segment == NULL) ||
867 	    (blk->tfb_tcp_ctloutput == NULL) ||
868 	    (strlen(blk->tfb_tcp_block_name) == 0)) {
869 		/*
870 		 * These functions are required and you
871 		 * need a name.
872 		 */
873 		*num_names = 0;
874 		return (EINVAL);
875 	}
876 	if (blk->tfb_tcp_timer_stop_all ||
877 	    blk->tfb_tcp_timer_activate ||
878 	    blk->tfb_tcp_timer_active ||
879 	    blk->tfb_tcp_timer_stop) {
880 		/*
881 		 * If you define one timer function you
882 		 * must have them all.
883 		 */
884 		if ((blk->tfb_tcp_timer_stop_all == NULL) ||
885 		    (blk->tfb_tcp_timer_activate == NULL) ||
886 		    (blk->tfb_tcp_timer_active == NULL) ||
887 		    (blk->tfb_tcp_timer_stop == NULL)) {
888 			*num_names = 0;
889 			return (EINVAL);
890 		}
891 	}
892 
893 	if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
894 		*num_names = 0;
895 		return (EINVAL);
896 	}
897 
898 	refcount_init(&blk->tfb_refcnt, 0);
899 	blk->tfb_id = atomic_fetchadd_int(&next_tcp_stack_id, 1);
900 	for (i = 0; i < *num_names; i++) {
901 		n = malloc(sizeof(struct tcp_function), M_TCPFUNCTIONS, wait);
902 		if (n == NULL) {
903 			error = ENOMEM;
904 			goto cleanup;
905 		}
906 		n->tf_fb = blk;
907 
908 		(void)strlcpy(fs.function_set_name, names[i],
909 		    sizeof(fs.function_set_name));
910 		rw_wlock(&tcp_function_lock);
911 		if (find_tcp_functions_locked(&fs) != NULL) {
912 			/* Duplicate name space not allowed */
913 			rw_wunlock(&tcp_function_lock);
914 			free(n, M_TCPFUNCTIONS);
915 			error = EALREADY;
916 			goto cleanup;
917 		}
918 		(void)strlcpy(n->tf_name, names[i], sizeof(n->tf_name));
919 		TAILQ_INSERT_TAIL(&t_functions, n, tf_next);
920 		tcp_fb_cnt++;
921 		rw_wunlock(&tcp_function_lock);
922 	}
923 	return(0);
924 
925 cleanup:
926 	/*
927 	 * Deregister the names we just added. Because registration failed
928 	 * for names[i], we don't need to deregister that name.
929 	 */
930 	*num_names = i;
931 	rw_wlock(&tcp_function_lock);
932 	while (--i >= 0) {
933 		TAILQ_FOREACH(n, &t_functions, tf_next) {
934 			if (!strncmp(n->tf_name, names[i],
935 			    TCP_FUNCTION_NAME_LEN_MAX)) {
936 				TAILQ_REMOVE(&t_functions, n, tf_next);
937 				tcp_fb_cnt--;
938 				n->tf_fb = NULL;
939 				free(n, M_TCPFUNCTIONS);
940 				break;
941 			}
942 		}
943 	}
944 	rw_wunlock(&tcp_function_lock);
945 	return (error);
946 }
947 
948 /*
949  * Register a TCP function block using the name provided in the name
950  * argument.
951  *
952  * Returns 0 on success, or an error code on failure.
953  */
954 int
955 register_tcp_functions_as_name(struct tcp_function_block *blk, const char *name,
956     int wait)
957 {
958 	const char *name_list[1];
959 	int num_names, rv;
960 
961 	num_names = 1;
962 	if (name != NULL)
963 		name_list[0] = name;
964 	else
965 		name_list[0] = blk->tfb_tcp_block_name;
966 	rv = register_tcp_functions_as_names(blk, wait, name_list, &num_names);
967 	return (rv);
968 }
969 
970 /*
971  * Register a TCP function block using the name defined in
972  * blk->tfb_tcp_block_name.
973  *
974  * Returns 0 on success, or an error code on failure.
975  */
976 int
977 register_tcp_functions(struct tcp_function_block *blk, int wait)
978 {
979 
980 	return (register_tcp_functions_as_name(blk, NULL, wait));
981 }
982 
983 /*
984  * Deregister all names associated with a function block. This
985  * functionally removes the function block from use within the system.
986  *
987  * When called with a true quiesce argument, mark the function block
988  * as being removed so no more stacks will use it and determine
989  * whether the removal would succeed.
990  *
991  * When called with a false quiesce argument, actually attempt the
992  * removal.
993  *
994  * When called with a force argument, attempt to switch all TCBs to
995  * use the default stack instead of returning EBUSY.
996  *
997  * Returns 0 on success (or if the removal would succeed, or an error
998  * code on failure.
999  */
1000 int
1001 deregister_tcp_functions(struct tcp_function_block *blk, bool quiesce,
1002     bool force)
1003 {
1004 	struct tcp_function *f;
1005 
1006 	if (blk == &tcp_def_funcblk) {
1007 		/* You can't un-register the default */
1008 		return (EPERM);
1009 	}
1010 	rw_wlock(&tcp_function_lock);
1011 	if (blk == tcp_func_set_ptr) {
1012 		/* You can't free the current default */
1013 		rw_wunlock(&tcp_function_lock);
1014 		return (EBUSY);
1015 	}
1016 	/* Mark the block so no more stacks can use it. */
1017 	blk->tfb_flags |= TCP_FUNC_BEING_REMOVED;
1018 	/*
1019 	 * If TCBs are still attached to the stack, attempt to switch them
1020 	 * to the default stack.
1021 	 */
1022 	if (force && blk->tfb_refcnt) {
1023 		struct inpcb *inp;
1024 		struct tcpcb *tp;
1025 		VNET_ITERATOR_DECL(vnet_iter);
1026 
1027 		rw_wunlock(&tcp_function_lock);
1028 
1029 		VNET_LIST_RLOCK();
1030 		VNET_FOREACH(vnet_iter) {
1031 			CURVNET_SET(vnet_iter);
1032 			INP_INFO_WLOCK(&V_tcbinfo);
1033 			CK_LIST_FOREACH(inp, V_tcbinfo.ipi_listhead, inp_list) {
1034 				INP_WLOCK(inp);
1035 				if (inp->inp_flags & INP_TIMEWAIT) {
1036 					INP_WUNLOCK(inp);
1037 					continue;
1038 				}
1039 				tp = intotcpcb(inp);
1040 				if (tp == NULL || tp->t_fb != blk) {
1041 					INP_WUNLOCK(inp);
1042 					continue;
1043 				}
1044 				tcp_switch_back_to_default(tp);
1045 				INP_WUNLOCK(inp);
1046 			}
1047 			INP_INFO_WUNLOCK(&V_tcbinfo);
1048 			CURVNET_RESTORE();
1049 		}
1050 		VNET_LIST_RUNLOCK();
1051 
1052 		rw_wlock(&tcp_function_lock);
1053 	}
1054 	if (blk->tfb_refcnt) {
1055 		/* TCBs still attached. */
1056 		rw_wunlock(&tcp_function_lock);
1057 		return (EBUSY);
1058 	}
1059 	if (quiesce) {
1060 		/* Skip removal. */
1061 		rw_wunlock(&tcp_function_lock);
1062 		return (0);
1063 	}
1064 	/* Remove any function names that map to this function block. */
1065 	while (find_tcp_fb_locked(blk, &f) != NULL) {
1066 		TAILQ_REMOVE(&t_functions, f, tf_next);
1067 		tcp_fb_cnt--;
1068 		f->tf_fb = NULL;
1069 		free(f, M_TCPFUNCTIONS);
1070 	}
1071 	rw_wunlock(&tcp_function_lock);
1072 	return (0);
1073 }
1074 
1075 void
1076 tcp_init(void)
1077 {
1078 	const char *tcbhash_tuneable;
1079 	int hashsize;
1080 
1081 	tcbhash_tuneable = "net.inet.tcp.tcbhashsize";
1082 
1083 #ifdef TCP_HHOOK
1084 	if (hhook_head_register(HHOOK_TYPE_TCP, HHOOK_TCP_EST_IN,
1085 	    &V_tcp_hhh[HHOOK_TCP_EST_IN], HHOOK_NOWAIT|HHOOK_HEADISINVNET) != 0)
1086 		printf("%s: WARNING: unable to register helper hook\n", __func__);
1087 	if (hhook_head_register(HHOOK_TYPE_TCP, HHOOK_TCP_EST_OUT,
1088 	    &V_tcp_hhh[HHOOK_TCP_EST_OUT], HHOOK_NOWAIT|HHOOK_HEADISINVNET) != 0)
1089 		printf("%s: WARNING: unable to register helper hook\n", __func__);
1090 #endif
1091 #ifdef STATS
1092 	if (tcp_stats_init())
1093 		printf("%s: WARNING: unable to initialise TCP stats\n",
1094 		    __func__);
1095 #endif
1096 	hashsize = TCBHASHSIZE;
1097 	TUNABLE_INT_FETCH(tcbhash_tuneable, &hashsize);
1098 	if (hashsize == 0) {
1099 		/*
1100 		 * Auto tune the hash size based on maxsockets.
1101 		 * A perfect hash would have a 1:1 mapping
1102 		 * (hashsize = maxsockets) however it's been
1103 		 * suggested that O(2) average is better.
1104 		 */
1105 		hashsize = maketcp_hashsize(maxsockets / 4);
1106 		/*
1107 		 * Our historical default is 512,
1108 		 * do not autotune lower than this.
1109 		 */
1110 		if (hashsize < 512)
1111 			hashsize = 512;
1112 		if (bootverbose && IS_DEFAULT_VNET(curvnet))
1113 			printf("%s: %s auto tuned to %d\n", __func__,
1114 			    tcbhash_tuneable, hashsize);
1115 	}
1116 	/*
1117 	 * We require a hashsize to be a power of two.
1118 	 * Previously if it was not a power of two we would just reset it
1119 	 * back to 512, which could be a nasty surprise if you did not notice
1120 	 * the error message.
1121 	 * Instead what we do is clip it to the closest power of two lower
1122 	 * than the specified hash value.
1123 	 */
1124 	if (!powerof2(hashsize)) {
1125 		int oldhashsize = hashsize;
1126 
1127 		hashsize = maketcp_hashsize(hashsize);
1128 		/* prevent absurdly low value */
1129 		if (hashsize < 16)
1130 			hashsize = 16;
1131 		printf("%s: WARNING: TCB hash size not a power of 2, "
1132 		    "clipped from %d to %d.\n", __func__, oldhashsize,
1133 		    hashsize);
1134 	}
1135 	in_pcbinfo_init(&V_tcbinfo, "tcp", &V_tcb, hashsize, hashsize,
1136 	    "tcp_inpcb", tcp_inpcb_init, IPI_HASHFIELDS_4TUPLE);
1137 
1138 	/*
1139 	 * These have to be type stable for the benefit of the timers.
1140 	 */
1141 	V_tcpcb_zone = uma_zcreate("tcpcb", sizeof(struct tcpcb_mem),
1142 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
1143 	uma_zone_set_max(V_tcpcb_zone, maxsockets);
1144 	uma_zone_set_warning(V_tcpcb_zone, "kern.ipc.maxsockets limit reached");
1145 
1146 	tcp_tw_init();
1147 	syncache_init();
1148 	tcp_hc_init();
1149 
1150 	TUNABLE_INT_FETCH("net.inet.tcp.sack.enable", &V_tcp_do_sack);
1151 	V_sack_hole_zone = uma_zcreate("sackhole", sizeof(struct sackhole),
1152 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
1153 
1154 	tcp_fastopen_init();
1155 
1156 	/* Skip initialization of globals for non-default instances. */
1157 	if (!IS_DEFAULT_VNET(curvnet))
1158 		return;
1159 
1160 	tcp_reass_global_init();
1161 
1162 	/* XXX virtualize those bellow? */
1163 	tcp_delacktime = TCPTV_DELACK;
1164 	tcp_keepinit = TCPTV_KEEP_INIT;
1165 	tcp_keepidle = TCPTV_KEEP_IDLE;
1166 	tcp_keepintvl = TCPTV_KEEPINTVL;
1167 	tcp_maxpersistidle = TCPTV_KEEP_IDLE;
1168 	tcp_msl = TCPTV_MSL;
1169 	tcp_rexmit_initial = TCPTV_RTOBASE;
1170 	if (tcp_rexmit_initial < 1)
1171 		tcp_rexmit_initial = 1;
1172 	tcp_rexmit_min = TCPTV_MIN;
1173 	if (tcp_rexmit_min < 1)
1174 		tcp_rexmit_min = 1;
1175 	tcp_persmin = TCPTV_PERSMIN;
1176 	tcp_persmax = TCPTV_PERSMAX;
1177 	tcp_rexmit_slop = TCPTV_CPU_VAR;
1178 	tcp_finwait2_timeout = TCPTV_FINWAIT2_TIMEOUT;
1179 	tcp_tcbhashsize = hashsize;
1180 
1181 	/* Setup the tcp function block list */
1182 	TAILQ_INIT(&t_functions);
1183 	rw_init(&tcp_function_lock, "tcp_func_lock");
1184 	register_tcp_functions(&tcp_def_funcblk, M_WAITOK);
1185 #ifdef TCP_BLACKBOX
1186 	/* Initialize the TCP logging data. */
1187 	tcp_log_init();
1188 #endif
1189 	arc4rand(&V_ts_offset_secret, sizeof(V_ts_offset_secret), 0);
1190 
1191 	if (tcp_soreceive_stream) {
1192 #ifdef INET
1193 		tcp_usrreqs.pru_soreceive = soreceive_stream;
1194 #endif
1195 #ifdef INET6
1196 		tcp6_usrreqs.pru_soreceive = soreceive_stream;
1197 #endif /* INET6 */
1198 	}
1199 
1200 #ifdef INET6
1201 #define TCP_MINPROTOHDR (sizeof(struct ip6_hdr) + sizeof(struct tcphdr))
1202 #else /* INET6 */
1203 #define TCP_MINPROTOHDR (sizeof(struct tcpiphdr))
1204 #endif /* INET6 */
1205 	if (max_protohdr < TCP_MINPROTOHDR)
1206 		max_protohdr = TCP_MINPROTOHDR;
1207 	if (max_linkhdr + TCP_MINPROTOHDR > MHLEN)
1208 		panic("tcp_init");
1209 #undef TCP_MINPROTOHDR
1210 
1211 	ISN_LOCK_INIT();
1212 	EVENTHANDLER_REGISTER(shutdown_pre_sync, tcp_fini, NULL,
1213 		SHUTDOWN_PRI_DEFAULT);
1214 	EVENTHANDLER_REGISTER(maxsockets_change, tcp_zone_change, NULL,
1215 		EVENTHANDLER_PRI_ANY);
1216 
1217 	tcp_inp_lro_direct_queue = counter_u64_alloc(M_WAITOK);
1218 	tcp_inp_lro_wokeup_queue = counter_u64_alloc(M_WAITOK);
1219 	tcp_inp_lro_compressed = counter_u64_alloc(M_WAITOK);
1220 	tcp_inp_lro_single_push = counter_u64_alloc(M_WAITOK);
1221 	tcp_inp_lro_locks_taken = counter_u64_alloc(M_WAITOK);
1222 	tcp_inp_lro_sack_wake = counter_u64_alloc(M_WAITOK);
1223 #ifdef TCPPCAP
1224 	tcp_pcap_init();
1225 #endif
1226 }
1227 
1228 #ifdef VIMAGE
1229 static void
1230 tcp_destroy(void *unused __unused)
1231 {
1232 	int n;
1233 #ifdef TCP_HHOOK
1234 	int error;
1235 #endif
1236 
1237 	/*
1238 	 * All our processes are gone, all our sockets should be cleaned
1239 	 * up, which means, we should be past the tcp_discardcb() calls.
1240 	 * Sleep to let all tcpcb timers really disappear and cleanup.
1241 	 */
1242 	for (;;) {
1243 		INP_LIST_RLOCK(&V_tcbinfo);
1244 		n = V_tcbinfo.ipi_count;
1245 		INP_LIST_RUNLOCK(&V_tcbinfo);
1246 		if (n == 0)
1247 			break;
1248 		pause("tcpdes", hz / 10);
1249 	}
1250 	tcp_hc_destroy();
1251 	syncache_destroy();
1252 	tcp_tw_destroy();
1253 	in_pcbinfo_destroy(&V_tcbinfo);
1254 	/* tcp_discardcb() clears the sack_holes up. */
1255 	uma_zdestroy(V_sack_hole_zone);
1256 	uma_zdestroy(V_tcpcb_zone);
1257 
1258 	/*
1259 	 * Cannot free the zone until all tcpcbs are released as we attach
1260 	 * the allocations to them.
1261 	 */
1262 	tcp_fastopen_destroy();
1263 
1264 #ifdef TCP_HHOOK
1265 	error = hhook_head_deregister(V_tcp_hhh[HHOOK_TCP_EST_IN]);
1266 	if (error != 0) {
1267 		printf("%s: WARNING: unable to deregister helper hook "
1268 		    "type=%d, id=%d: error %d returned\n", __func__,
1269 		    HHOOK_TYPE_TCP, HHOOK_TCP_EST_IN, error);
1270 	}
1271 	error = hhook_head_deregister(V_tcp_hhh[HHOOK_TCP_EST_OUT]);
1272 	if (error != 0) {
1273 		printf("%s: WARNING: unable to deregister helper hook "
1274 		    "type=%d, id=%d: error %d returned\n", __func__,
1275 		    HHOOK_TYPE_TCP, HHOOK_TCP_EST_OUT, error);
1276 	}
1277 #endif
1278 }
1279 VNET_SYSUNINIT(tcp, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH, tcp_destroy, NULL);
1280 #endif
1281 
1282 void
1283 tcp_fini(void *xtp)
1284 {
1285 
1286 }
1287 
1288 /*
1289  * Fill in the IP and TCP headers for an outgoing packet, given the tcpcb.
1290  * tcp_template used to store this data in mbufs, but we now recopy it out
1291  * of the tcpcb each time to conserve mbufs.
1292  */
1293 void
1294 tcpip_fillheaders(struct inpcb *inp, void *ip_ptr, void *tcp_ptr)
1295 {
1296 	struct tcphdr *th = (struct tcphdr *)tcp_ptr;
1297 
1298 	INP_WLOCK_ASSERT(inp);
1299 
1300 #ifdef INET6
1301 	if ((inp->inp_vflag & INP_IPV6) != 0) {
1302 		struct ip6_hdr *ip6;
1303 
1304 		ip6 = (struct ip6_hdr *)ip_ptr;
1305 		ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
1306 			(inp->inp_flow & IPV6_FLOWINFO_MASK);
1307 		ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
1308 			(IPV6_VERSION & IPV6_VERSION_MASK);
1309 		ip6->ip6_nxt = IPPROTO_TCP;
1310 		ip6->ip6_plen = htons(sizeof(struct tcphdr));
1311 		ip6->ip6_src = inp->in6p_laddr;
1312 		ip6->ip6_dst = inp->in6p_faddr;
1313 	}
1314 #endif /* INET6 */
1315 #if defined(INET6) && defined(INET)
1316 	else
1317 #endif
1318 #ifdef INET
1319 	{
1320 		struct ip *ip;
1321 
1322 		ip = (struct ip *)ip_ptr;
1323 		ip->ip_v = IPVERSION;
1324 		ip->ip_hl = 5;
1325 		ip->ip_tos = inp->inp_ip_tos;
1326 		ip->ip_len = 0;
1327 		ip->ip_id = 0;
1328 		ip->ip_off = 0;
1329 		ip->ip_ttl = inp->inp_ip_ttl;
1330 		ip->ip_sum = 0;
1331 		ip->ip_p = IPPROTO_TCP;
1332 		ip->ip_src = inp->inp_laddr;
1333 		ip->ip_dst = inp->inp_faddr;
1334 	}
1335 #endif /* INET */
1336 	th->th_sport = inp->inp_lport;
1337 	th->th_dport = inp->inp_fport;
1338 	th->th_seq = 0;
1339 	th->th_ack = 0;
1340 	th->th_x2 = 0;
1341 	th->th_off = 5;
1342 	th->th_flags = 0;
1343 	th->th_win = 0;
1344 	th->th_urp = 0;
1345 	th->th_sum = 0;		/* in_pseudo() is called later for ipv4 */
1346 }
1347 
1348 /*
1349  * Create template to be used to send tcp packets on a connection.
1350  * Allocates an mbuf and fills in a skeletal tcp/ip header.  The only
1351  * use for this function is in keepalives, which use tcp_respond.
1352  */
1353 struct tcptemp *
1354 tcpip_maketemplate(struct inpcb *inp)
1355 {
1356 	struct tcptemp *t;
1357 
1358 	t = malloc(sizeof(*t), M_TEMP, M_NOWAIT);
1359 	if (t == NULL)
1360 		return (NULL);
1361 	tcpip_fillheaders(inp, (void *)&t->tt_ipgen, (void *)&t->tt_t);
1362 	return (t);
1363 }
1364 
1365 /*
1366  * Send a single message to the TCP at address specified by
1367  * the given TCP/IP header.  If m == NULL, then we make a copy
1368  * of the tcpiphdr at th and send directly to the addressed host.
1369  * This is used to force keep alive messages out using the TCP
1370  * template for a connection.  If flags are given then we send
1371  * a message back to the TCP which originated the segment th,
1372  * and discard the mbuf containing it and any other attached mbufs.
1373  *
1374  * In any case the ack and sequence number of the transmitted
1375  * segment are as specified by the parameters.
1376  *
1377  * NOTE: If m != NULL, then th must point to *inside* the mbuf.
1378  */
1379 void
1380 tcp_respond(struct tcpcb *tp, void *ipgen, struct tcphdr *th, struct mbuf *m,
1381     tcp_seq ack, tcp_seq seq, int flags)
1382 {
1383 	struct tcpopt to;
1384 	struct inpcb *inp;
1385 	struct ip *ip;
1386 	struct mbuf *optm;
1387 	struct tcphdr *nth;
1388 	u_char *optp;
1389 #ifdef INET6
1390 	struct ip6_hdr *ip6;
1391 	int isipv6;
1392 #endif /* INET6 */
1393 	int optlen, tlen, win;
1394 	bool incl_opts;
1395 
1396 	KASSERT(tp != NULL || m != NULL, ("tcp_respond: tp and m both NULL"));
1397 
1398 #ifdef INET6
1399 	isipv6 = ((struct ip *)ipgen)->ip_v == (IPV6_VERSION >> 4);
1400 	ip6 = ipgen;
1401 #endif /* INET6 */
1402 	ip = ipgen;
1403 
1404 	if (tp != NULL) {
1405 		inp = tp->t_inpcb;
1406 		KASSERT(inp != NULL, ("tcp control block w/o inpcb"));
1407 		INP_WLOCK_ASSERT(inp);
1408 	} else
1409 		inp = NULL;
1410 
1411 	incl_opts = false;
1412 	win = 0;
1413 	if (tp != NULL) {
1414 		if (!(flags & TH_RST)) {
1415 			win = sbspace(&inp->inp_socket->so_rcv);
1416 			if (win > TCP_MAXWIN << tp->rcv_scale)
1417 				win = TCP_MAXWIN << tp->rcv_scale;
1418 		}
1419 		if ((tp->t_flags & TF_NOOPT) == 0)
1420 			incl_opts = true;
1421 	}
1422 	if (m == NULL) {
1423 		m = m_gethdr(M_NOWAIT, MT_DATA);
1424 		if (m == NULL)
1425 			return;
1426 		m->m_data += max_linkhdr;
1427 #ifdef INET6
1428 		if (isipv6) {
1429 			bcopy((caddr_t)ip6, mtod(m, caddr_t),
1430 			      sizeof(struct ip6_hdr));
1431 			ip6 = mtod(m, struct ip6_hdr *);
1432 			nth = (struct tcphdr *)(ip6 + 1);
1433 		} else
1434 #endif /* INET6 */
1435 		{
1436 			bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
1437 			ip = mtod(m, struct ip *);
1438 			nth = (struct tcphdr *)(ip + 1);
1439 		}
1440 		bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
1441 		flags = TH_ACK;
1442 	} else if (!M_WRITABLE(m)) {
1443 		struct mbuf *n;
1444 
1445 		/* Can't reuse 'm', allocate a new mbuf. */
1446 		n = m_gethdr(M_NOWAIT, MT_DATA);
1447 		if (n == NULL) {
1448 			m_freem(m);
1449 			return;
1450 		}
1451 
1452 		if (!m_dup_pkthdr(n, m, M_NOWAIT)) {
1453 			m_freem(m);
1454 			m_freem(n);
1455 			return;
1456 		}
1457 
1458 		n->m_data += max_linkhdr;
1459 		/* m_len is set later */
1460 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
1461 #ifdef INET6
1462 		if (isipv6) {
1463 			bcopy((caddr_t)ip6, mtod(n, caddr_t),
1464 			      sizeof(struct ip6_hdr));
1465 			ip6 = mtod(n, struct ip6_hdr *);
1466 			xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
1467 			nth = (struct tcphdr *)(ip6 + 1);
1468 		} else
1469 #endif /* INET6 */
1470 		{
1471 			bcopy((caddr_t)ip, mtod(n, caddr_t), sizeof(struct ip));
1472 			ip = mtod(n, struct ip *);
1473 			xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, uint32_t);
1474 			nth = (struct tcphdr *)(ip + 1);
1475 		}
1476 		bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
1477 		xchg(nth->th_dport, nth->th_sport, uint16_t);
1478 		th = nth;
1479 		m_freem(m);
1480 		m = n;
1481 	} else {
1482 		/*
1483 		 *  reuse the mbuf.
1484 		 * XXX MRT We inherit the FIB, which is lucky.
1485 		 */
1486 		m_freem(m->m_next);
1487 		m->m_next = NULL;
1488 		m->m_data = (caddr_t)ipgen;
1489 		/* m_len is set later */
1490 #ifdef INET6
1491 		if (isipv6) {
1492 			xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
1493 			nth = (struct tcphdr *)(ip6 + 1);
1494 		} else
1495 #endif /* INET6 */
1496 		{
1497 			xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, uint32_t);
1498 			nth = (struct tcphdr *)(ip + 1);
1499 		}
1500 		if (th != nth) {
1501 			/*
1502 			 * this is usually a case when an extension header
1503 			 * exists between the IPv6 header and the
1504 			 * TCP header.
1505 			 */
1506 			nth->th_sport = th->th_sport;
1507 			nth->th_dport = th->th_dport;
1508 		}
1509 		xchg(nth->th_dport, nth->th_sport, uint16_t);
1510 #undef xchg
1511 	}
1512 	tlen = 0;
1513 #ifdef INET6
1514 	if (isipv6)
1515 		tlen = sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
1516 #endif
1517 #if defined(INET) && defined(INET6)
1518 	else
1519 #endif
1520 #ifdef INET
1521 		tlen = sizeof (struct tcpiphdr);
1522 #endif
1523 #ifdef INVARIANTS
1524 	m->m_len = 0;
1525 	KASSERT(M_TRAILINGSPACE(m) >= tlen,
1526 	    ("Not enough trailing space for message (m=%p, need=%d, have=%ld)",
1527 	    m, tlen, (long)M_TRAILINGSPACE(m)));
1528 #endif
1529 	m->m_len = tlen;
1530 	to.to_flags = 0;
1531 	if (incl_opts) {
1532 		/* Make sure we have room. */
1533 		if (M_TRAILINGSPACE(m) < TCP_MAXOLEN) {
1534 			m->m_next = m_get(M_NOWAIT, MT_DATA);
1535 			if (m->m_next) {
1536 				optp = mtod(m->m_next, u_char *);
1537 				optm = m->m_next;
1538 			} else
1539 				incl_opts = false;
1540 		} else {
1541 			optp = (u_char *) (nth + 1);
1542 			optm = m;
1543 		}
1544 	}
1545 	if (incl_opts) {
1546 		/* Timestamps. */
1547 		if (tp->t_flags & TF_RCVD_TSTMP) {
1548 			to.to_tsval = tcp_ts_getticks() + tp->ts_offset;
1549 			to.to_tsecr = tp->ts_recent;
1550 			to.to_flags |= TOF_TS;
1551 		}
1552 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1553 		/* TCP-MD5 (RFC2385). */
1554 		if (tp->t_flags & TF_SIGNATURE)
1555 			to.to_flags |= TOF_SIGNATURE;
1556 #endif
1557 		/* Add the options. */
1558 		tlen += optlen = tcp_addoptions(&to, optp);
1559 
1560 		/* Update m_len in the correct mbuf. */
1561 		optm->m_len += optlen;
1562 	} else
1563 		optlen = 0;
1564 #ifdef INET6
1565 	if (isipv6) {
1566 		ip6->ip6_flow = 0;
1567 		ip6->ip6_vfc = IPV6_VERSION;
1568 		ip6->ip6_nxt = IPPROTO_TCP;
1569 		ip6->ip6_plen = htons(tlen - sizeof(*ip6));
1570 	}
1571 #endif
1572 #if defined(INET) && defined(INET6)
1573 	else
1574 #endif
1575 #ifdef INET
1576 	{
1577 		ip->ip_len = htons(tlen);
1578 		ip->ip_ttl = V_ip_defttl;
1579 		if (V_path_mtu_discovery)
1580 			ip->ip_off |= htons(IP_DF);
1581 	}
1582 #endif
1583 	m->m_pkthdr.len = tlen;
1584 	m->m_pkthdr.rcvif = NULL;
1585 #ifdef MAC
1586 	if (inp != NULL) {
1587 		/*
1588 		 * Packet is associated with a socket, so allow the
1589 		 * label of the response to reflect the socket label.
1590 		 */
1591 		INP_WLOCK_ASSERT(inp);
1592 		mac_inpcb_create_mbuf(inp, m);
1593 	} else {
1594 		/*
1595 		 * Packet is not associated with a socket, so possibly
1596 		 * update the label in place.
1597 		 */
1598 		mac_netinet_tcp_reply(m);
1599 	}
1600 #endif
1601 	nth->th_seq = htonl(seq);
1602 	nth->th_ack = htonl(ack);
1603 	nth->th_x2 = 0;
1604 	nth->th_off = (sizeof (struct tcphdr) + optlen) >> 2;
1605 	nth->th_flags = flags;
1606 	if (tp != NULL)
1607 		nth->th_win = htons((u_short) (win >> tp->rcv_scale));
1608 	else
1609 		nth->th_win = htons((u_short)win);
1610 	nth->th_urp = 0;
1611 
1612 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1613 	if (to.to_flags & TOF_SIGNATURE) {
1614 		if (!TCPMD5_ENABLED() ||
1615 		    TCPMD5_OUTPUT(m, nth, to.to_signature) != 0) {
1616 			m_freem(m);
1617 			return;
1618 		}
1619 	}
1620 #endif
1621 
1622 	m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
1623 #ifdef INET6
1624 	if (isipv6) {
1625 		m->m_pkthdr.csum_flags = CSUM_TCP_IPV6;
1626 		nth->th_sum = in6_cksum_pseudo(ip6,
1627 		    tlen - sizeof(struct ip6_hdr), IPPROTO_TCP, 0);
1628 		ip6->ip6_hlim = in6_selecthlim(tp != NULL ? tp->t_inpcb :
1629 		    NULL, NULL);
1630 	}
1631 #endif /* INET6 */
1632 #if defined(INET6) && defined(INET)
1633 	else
1634 #endif
1635 #ifdef INET
1636 	{
1637 		m->m_pkthdr.csum_flags = CSUM_TCP;
1638 		nth->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
1639 		    htons((u_short)(tlen - sizeof(struct ip) + ip->ip_p)));
1640 	}
1641 #endif /* INET */
1642 #ifdef TCPDEBUG
1643 	if (tp == NULL || (inp->inp_socket->so_options & SO_DEBUG))
1644 		tcp_trace(TA_OUTPUT, 0, tp, mtod(m, void *), th, 0);
1645 #endif
1646 	TCP_PROBE3(debug__output, tp, th, m);
1647 	if (flags & TH_RST)
1648 		TCP_PROBE5(accept__refused, NULL, NULL, m, tp, nth);
1649 
1650 #ifdef INET6
1651 	if (isipv6) {
1652 		TCP_PROBE5(send, NULL, tp, ip6, tp, nth);
1653 		(void)ip6_output(m, NULL, NULL, 0, NULL, NULL, inp);
1654 	}
1655 #endif /* INET6 */
1656 #if defined(INET) && defined(INET6)
1657 	else
1658 #endif
1659 #ifdef INET
1660 	{
1661 		TCP_PROBE5(send, NULL, tp, ip, tp, nth);
1662 		(void)ip_output(m, NULL, NULL, 0, NULL, inp);
1663 	}
1664 #endif
1665 }
1666 
1667 /*
1668  * Create a new TCP control block, making an
1669  * empty reassembly queue and hooking it to the argument
1670  * protocol control block.  The `inp' parameter must have
1671  * come from the zone allocator set up in tcp_init().
1672  */
1673 struct tcpcb *
1674 tcp_newtcpcb(struct inpcb *inp)
1675 {
1676 	struct tcpcb_mem *tm;
1677 	struct tcpcb *tp;
1678 #ifdef INET6
1679 	int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
1680 #endif /* INET6 */
1681 
1682 	tm = uma_zalloc(V_tcpcb_zone, M_NOWAIT | M_ZERO);
1683 	if (tm == NULL)
1684 		return (NULL);
1685 	tp = &tm->tcb;
1686 
1687 	/* Initialise cc_var struct for this tcpcb. */
1688 	tp->ccv = &tm->ccv;
1689 	tp->ccv->type = IPPROTO_TCP;
1690 	tp->ccv->ccvc.tcp = tp;
1691 	rw_rlock(&tcp_function_lock);
1692 	tp->t_fb = tcp_func_set_ptr;
1693 	refcount_acquire(&tp->t_fb->tfb_refcnt);
1694 	rw_runlock(&tcp_function_lock);
1695 	/*
1696 	 * Use the current system default CC algorithm.
1697 	 */
1698 	CC_LIST_RLOCK();
1699 	KASSERT(!STAILQ_EMPTY(&cc_list), ("cc_list is empty!"));
1700 	CC_ALGO(tp) = CC_DEFAULT();
1701 	CC_LIST_RUNLOCK();
1702 
1703 	if (CC_ALGO(tp)->cb_init != NULL)
1704 		if (CC_ALGO(tp)->cb_init(tp->ccv) > 0) {
1705 			if (tp->t_fb->tfb_tcp_fb_fini)
1706 				(*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
1707 			refcount_release(&tp->t_fb->tfb_refcnt);
1708 			uma_zfree(V_tcpcb_zone, tm);
1709 			return (NULL);
1710 		}
1711 
1712 #ifdef TCP_HHOOK
1713 	tp->osd = &tm->osd;
1714 	if (khelp_init_osd(HELPER_CLASS_TCP, tp->osd)) {
1715 		if (tp->t_fb->tfb_tcp_fb_fini)
1716 			(*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
1717 		refcount_release(&tp->t_fb->tfb_refcnt);
1718 		uma_zfree(V_tcpcb_zone, tm);
1719 		return (NULL);
1720 	}
1721 #endif
1722 
1723 #ifdef VIMAGE
1724 	tp->t_vnet = inp->inp_vnet;
1725 #endif
1726 	tp->t_timers = &tm->tt;
1727 	TAILQ_INIT(&tp->t_segq);
1728 	tp->t_maxseg =
1729 #ifdef INET6
1730 		isipv6 ? V_tcp_v6mssdflt :
1731 #endif /* INET6 */
1732 		V_tcp_mssdflt;
1733 
1734 	/* Set up our timeouts. */
1735 	callout_init(&tp->t_timers->tt_rexmt, 1);
1736 	callout_init(&tp->t_timers->tt_persist, 1);
1737 	callout_init(&tp->t_timers->tt_keep, 1);
1738 	callout_init(&tp->t_timers->tt_2msl, 1);
1739 	callout_init(&tp->t_timers->tt_delack, 1);
1740 
1741 	if (V_tcp_do_rfc1323)
1742 		tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP);
1743 	if (V_tcp_do_sack)
1744 		tp->t_flags |= TF_SACK_PERMIT;
1745 	TAILQ_INIT(&tp->snd_holes);
1746 	/*
1747 	 * The tcpcb will hold a reference on its inpcb until tcp_discardcb()
1748 	 * is called.
1749 	 */
1750 	in_pcbref(inp);	/* Reference for tcpcb */
1751 	tp->t_inpcb = inp;
1752 
1753 	/*
1754 	 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
1755 	 * rtt estimate.  Set rttvar so that srtt + 4 * rttvar gives
1756 	 * reasonable initial retransmit time.
1757 	 */
1758 	tp->t_srtt = TCPTV_SRTTBASE;
1759 	tp->t_rttvar = ((tcp_rexmit_initial - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4;
1760 	tp->t_rttmin = tcp_rexmit_min;
1761 	tp->t_rxtcur = tcp_rexmit_initial;
1762 	tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
1763 	tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
1764 	tp->t_rcvtime = ticks;
1765 	/*
1766 	 * IPv4 TTL initialization is necessary for an IPv6 socket as well,
1767 	 * because the socket may be bound to an IPv6 wildcard address,
1768 	 * which may match an IPv4-mapped IPv6 address.
1769 	 */
1770 	inp->inp_ip_ttl = V_ip_defttl;
1771 	inp->inp_ppcb = tp;
1772 #ifdef TCPPCAP
1773 	/*
1774 	 * Init the TCP PCAP queues.
1775 	 */
1776 	tcp_pcap_tcpcb_init(tp);
1777 #endif
1778 #ifdef TCP_BLACKBOX
1779 	/* Initialize the per-TCPCB log data. */
1780 	tcp_log_tcpcbinit(tp);
1781 #endif
1782 	if (tp->t_fb->tfb_tcp_fb_init) {
1783 		(*tp->t_fb->tfb_tcp_fb_init)(tp);
1784 	}
1785 #ifdef STATS
1786 	if (V_tcp_perconn_stats_enable == 1)
1787 		tp->t_stats = stats_blob_alloc(V_tcp_perconn_stats_dflt_tpl, 0);
1788 #endif
1789 	return (tp);		/* XXX */
1790 }
1791 
1792 /*
1793  * Switch the congestion control algorithm back to NewReno for any active
1794  * control blocks using an algorithm which is about to go away.
1795  * This ensures the CC framework can allow the unload to proceed without leaving
1796  * any dangling pointers which would trigger a panic.
1797  * Returning non-zero would inform the CC framework that something went wrong
1798  * and it would be unsafe to allow the unload to proceed. However, there is no
1799  * way for this to occur with this implementation so we always return zero.
1800  */
1801 int
1802 tcp_ccalgounload(struct cc_algo *unload_algo)
1803 {
1804 	struct cc_algo *tmpalgo;
1805 	struct inpcb *inp;
1806 	struct tcpcb *tp;
1807 	VNET_ITERATOR_DECL(vnet_iter);
1808 
1809 	/*
1810 	 * Check all active control blocks across all network stacks and change
1811 	 * any that are using "unload_algo" back to NewReno. If "unload_algo"
1812 	 * requires cleanup code to be run, call it.
1813 	 */
1814 	VNET_LIST_RLOCK();
1815 	VNET_FOREACH(vnet_iter) {
1816 		CURVNET_SET(vnet_iter);
1817 		INP_INFO_WLOCK(&V_tcbinfo);
1818 		/*
1819 		 * New connections already part way through being initialised
1820 		 * with the CC algo we're removing will not race with this code
1821 		 * because the INP_INFO_WLOCK is held during initialisation. We
1822 		 * therefore don't enter the loop below until the connection
1823 		 * list has stabilised.
1824 		 */
1825 		CK_LIST_FOREACH(inp, &V_tcb, inp_list) {
1826 			INP_WLOCK(inp);
1827 			/* Important to skip tcptw structs. */
1828 			if (!(inp->inp_flags & INP_TIMEWAIT) &&
1829 			    (tp = intotcpcb(inp)) != NULL) {
1830 				/*
1831 				 * By holding INP_WLOCK here, we are assured
1832 				 * that the connection is not currently
1833 				 * executing inside the CC module's functions
1834 				 * i.e. it is safe to make the switch back to
1835 				 * NewReno.
1836 				 */
1837 				if (CC_ALGO(tp) == unload_algo) {
1838 					tmpalgo = CC_ALGO(tp);
1839 					if (tmpalgo->cb_destroy != NULL)
1840 						tmpalgo->cb_destroy(tp->ccv);
1841 					CC_DATA(tp) = NULL;
1842 					/*
1843 					 * NewReno may allocate memory on
1844 					 * demand for certain stateful
1845 					 * configuration as needed, but is
1846 					 * coded to never fail on memory
1847 					 * allocation failure so it is a safe
1848 					 * fallback.
1849 					 */
1850 					CC_ALGO(tp) = &newreno_cc_algo;
1851 				}
1852 			}
1853 			INP_WUNLOCK(inp);
1854 		}
1855 		INP_INFO_WUNLOCK(&V_tcbinfo);
1856 		CURVNET_RESTORE();
1857 	}
1858 	VNET_LIST_RUNLOCK();
1859 
1860 	return (0);
1861 }
1862 
1863 /*
1864  * Drop a TCP connection, reporting
1865  * the specified error.  If connection is synchronized,
1866  * then send a RST to peer.
1867  */
1868 struct tcpcb *
1869 tcp_drop(struct tcpcb *tp, int errno)
1870 {
1871 	struct socket *so = tp->t_inpcb->inp_socket;
1872 
1873 	INP_INFO_LOCK_ASSERT(&V_tcbinfo);
1874 	INP_WLOCK_ASSERT(tp->t_inpcb);
1875 
1876 	if (TCPS_HAVERCVDSYN(tp->t_state)) {
1877 		tcp_state_change(tp, TCPS_CLOSED);
1878 		(void) tp->t_fb->tfb_tcp_output(tp);
1879 		TCPSTAT_INC(tcps_drops);
1880 	} else
1881 		TCPSTAT_INC(tcps_conndrops);
1882 	if (errno == ETIMEDOUT && tp->t_softerror)
1883 		errno = tp->t_softerror;
1884 	so->so_error = errno;
1885 	return (tcp_close(tp));
1886 }
1887 
1888 void
1889 tcp_discardcb(struct tcpcb *tp)
1890 {
1891 	struct inpcb *inp = tp->t_inpcb;
1892 	struct socket *so = inp->inp_socket;
1893 #ifdef INET6
1894 	int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
1895 #endif /* INET6 */
1896 	int released __unused;
1897 
1898 	INP_WLOCK_ASSERT(inp);
1899 
1900 	/*
1901 	 * Make sure that all of our timers are stopped before we delete the
1902 	 * PCB.
1903 	 *
1904 	 * If stopping a timer fails, we schedule a discard function in same
1905 	 * callout, and the last discard function called will take care of
1906 	 * deleting the tcpcb.
1907 	 */
1908 	tp->t_timers->tt_draincnt = 0;
1909 	tcp_timer_stop(tp, TT_REXMT);
1910 	tcp_timer_stop(tp, TT_PERSIST);
1911 	tcp_timer_stop(tp, TT_KEEP);
1912 	tcp_timer_stop(tp, TT_2MSL);
1913 	tcp_timer_stop(tp, TT_DELACK);
1914 	if (tp->t_fb->tfb_tcp_timer_stop_all) {
1915 		/*
1916 		 * Call the stop-all function of the methods,
1917 		 * this function should call the tcp_timer_stop()
1918 		 * method with each of the function specific timeouts.
1919 		 * That stop will be called via the tfb_tcp_timer_stop()
1920 		 * which should use the async drain function of the
1921 		 * callout system (see tcp_var.h).
1922 		 */
1923 		tp->t_fb->tfb_tcp_timer_stop_all(tp);
1924 	}
1925 
1926 	/*
1927 	 * If we got enough samples through the srtt filter,
1928 	 * save the rtt and rttvar in the routing entry.
1929 	 * 'Enough' is arbitrarily defined as 4 rtt samples.
1930 	 * 4 samples is enough for the srtt filter to converge
1931 	 * to within enough % of the correct value; fewer samples
1932 	 * and we could save a bogus rtt. The danger is not high
1933 	 * as tcp quickly recovers from everything.
1934 	 * XXX: Works very well but needs some more statistics!
1935 	 */
1936 	if (tp->t_rttupdated >= 4) {
1937 		struct hc_metrics_lite metrics;
1938 		uint32_t ssthresh;
1939 
1940 		bzero(&metrics, sizeof(metrics));
1941 		/*
1942 		 * Update the ssthresh always when the conditions below
1943 		 * are satisfied. This gives us better new start value
1944 		 * for the congestion avoidance for new connections.
1945 		 * ssthresh is only set if packet loss occurred on a session.
1946 		 *
1947 		 * XXXRW: 'so' may be NULL here, and/or socket buffer may be
1948 		 * being torn down.  Ideally this code would not use 'so'.
1949 		 */
1950 		ssthresh = tp->snd_ssthresh;
1951 		if (ssthresh != 0 && ssthresh < so->so_snd.sb_hiwat / 2) {
1952 			/*
1953 			 * convert the limit from user data bytes to
1954 			 * packets then to packet data bytes.
1955 			 */
1956 			ssthresh = (ssthresh + tp->t_maxseg / 2) / tp->t_maxseg;
1957 			if (ssthresh < 2)
1958 				ssthresh = 2;
1959 			ssthresh *= (tp->t_maxseg +
1960 #ifdef INET6
1961 			    (isipv6 ? sizeof (struct ip6_hdr) +
1962 				sizeof (struct tcphdr) :
1963 #endif
1964 				sizeof (struct tcpiphdr)
1965 #ifdef INET6
1966 			    )
1967 #endif
1968 			    );
1969 		} else
1970 			ssthresh = 0;
1971 		metrics.rmx_ssthresh = ssthresh;
1972 
1973 		metrics.rmx_rtt = tp->t_srtt;
1974 		metrics.rmx_rttvar = tp->t_rttvar;
1975 		metrics.rmx_cwnd = tp->snd_cwnd;
1976 		metrics.rmx_sendpipe = 0;
1977 		metrics.rmx_recvpipe = 0;
1978 
1979 		tcp_hc_update(&inp->inp_inc, &metrics);
1980 	}
1981 
1982 	/* free the reassembly queue, if any */
1983 	tcp_reass_flush(tp);
1984 
1985 #ifdef TCP_OFFLOAD
1986 	/* Disconnect offload device, if any. */
1987 	if (tp->t_flags & TF_TOE)
1988 		tcp_offload_detach(tp);
1989 #endif
1990 
1991 	tcp_free_sackholes(tp);
1992 
1993 #ifdef TCPPCAP
1994 	/* Free the TCP PCAP queues. */
1995 	tcp_pcap_drain(&(tp->t_inpkts));
1996 	tcp_pcap_drain(&(tp->t_outpkts));
1997 #endif
1998 
1999 	/* Allow the CC algorithm to clean up after itself. */
2000 	if (CC_ALGO(tp)->cb_destroy != NULL)
2001 		CC_ALGO(tp)->cb_destroy(tp->ccv);
2002 	CC_DATA(tp) = NULL;
2003 
2004 #ifdef TCP_HHOOK
2005 	khelp_destroy_osd(tp->osd);
2006 #endif
2007 #ifdef STATS
2008 	stats_blob_destroy(tp->t_stats);
2009 #endif
2010 
2011 	CC_ALGO(tp) = NULL;
2012 	inp->inp_ppcb = NULL;
2013 	if (tp->t_timers->tt_draincnt == 0) {
2014 		/* We own the last reference on tcpcb, let's free it. */
2015 #ifdef TCP_BLACKBOX
2016 		tcp_log_tcpcbfini(tp);
2017 #endif
2018 		TCPSTATES_DEC(tp->t_state);
2019 		if (tp->t_fb->tfb_tcp_fb_fini)
2020 			(*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
2021 		refcount_release(&tp->t_fb->tfb_refcnt);
2022 		tp->t_inpcb = NULL;
2023 		uma_zfree(V_tcpcb_zone, tp);
2024 		released = in_pcbrele_wlocked(inp);
2025 		KASSERT(!released, ("%s: inp %p should not have been released "
2026 			"here", __func__, inp));
2027 	}
2028 }
2029 
2030 void
2031 tcp_timer_discard(void *ptp)
2032 {
2033 	struct inpcb *inp;
2034 	struct tcpcb *tp;
2035 	struct epoch_tracker et;
2036 
2037 	tp = (struct tcpcb *)ptp;
2038 	CURVNET_SET(tp->t_vnet);
2039 	NET_EPOCH_ENTER(et);
2040 	inp = tp->t_inpcb;
2041 	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL",
2042 		__func__, tp));
2043 	INP_WLOCK(inp);
2044 	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) != 0,
2045 		("%s: tcpcb has to be stopped here", __func__));
2046 	tp->t_timers->tt_draincnt--;
2047 	if (tp->t_timers->tt_draincnt == 0) {
2048 		/* We own the last reference on this tcpcb, let's free it. */
2049 #ifdef TCP_BLACKBOX
2050 		tcp_log_tcpcbfini(tp);
2051 #endif
2052 		TCPSTATES_DEC(tp->t_state);
2053 		if (tp->t_fb->tfb_tcp_fb_fini)
2054 			(*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
2055 		refcount_release(&tp->t_fb->tfb_refcnt);
2056 		tp->t_inpcb = NULL;
2057 		uma_zfree(V_tcpcb_zone, tp);
2058 		if (in_pcbrele_wlocked(inp)) {
2059 			NET_EPOCH_EXIT(et);
2060 			CURVNET_RESTORE();
2061 			return;
2062 		}
2063 	}
2064 	INP_WUNLOCK(inp);
2065 	NET_EPOCH_EXIT(et);
2066 	CURVNET_RESTORE();
2067 }
2068 
2069 /*
2070  * Attempt to close a TCP control block, marking it as dropped, and freeing
2071  * the socket if we hold the only reference.
2072  */
2073 struct tcpcb *
2074 tcp_close(struct tcpcb *tp)
2075 {
2076 	struct inpcb *inp = tp->t_inpcb;
2077 	struct socket *so;
2078 
2079 	INP_INFO_LOCK_ASSERT(&V_tcbinfo);
2080 	INP_WLOCK_ASSERT(inp);
2081 
2082 #ifdef TCP_OFFLOAD
2083 	if (tp->t_state == TCPS_LISTEN)
2084 		tcp_offload_listen_stop(tp);
2085 #endif
2086 	/*
2087 	 * This releases the TFO pending counter resource for TFO listen
2088 	 * sockets as well as passively-created TFO sockets that transition
2089 	 * from SYN_RECEIVED to CLOSED.
2090 	 */
2091 	if (tp->t_tfo_pending) {
2092 		tcp_fastopen_decrement_counter(tp->t_tfo_pending);
2093 		tp->t_tfo_pending = NULL;
2094 	}
2095 	in_pcbdrop(inp);
2096 	TCPSTAT_INC(tcps_closed);
2097 	if (tp->t_state != TCPS_CLOSED)
2098 		tcp_state_change(tp, TCPS_CLOSED);
2099 	KASSERT(inp->inp_socket != NULL, ("tcp_close: inp_socket NULL"));
2100 	so = inp->inp_socket;
2101 	soisdisconnected(so);
2102 	if (inp->inp_flags & INP_SOCKREF) {
2103 		KASSERT(so->so_state & SS_PROTOREF,
2104 		    ("tcp_close: !SS_PROTOREF"));
2105 		inp->inp_flags &= ~INP_SOCKREF;
2106 		INP_WUNLOCK(inp);
2107 		SOCK_LOCK(so);
2108 		so->so_state &= ~SS_PROTOREF;
2109 		sofree(so);
2110 		return (NULL);
2111 	}
2112 	return (tp);
2113 }
2114 
2115 void
2116 tcp_drain(void)
2117 {
2118 	VNET_ITERATOR_DECL(vnet_iter);
2119 
2120 	if (!do_tcpdrain)
2121 		return;
2122 
2123 	VNET_LIST_RLOCK_NOSLEEP();
2124 	VNET_FOREACH(vnet_iter) {
2125 		CURVNET_SET(vnet_iter);
2126 		struct inpcb *inpb;
2127 		struct tcpcb *tcpb;
2128 
2129 	/*
2130 	 * Walk the tcpbs, if existing, and flush the reassembly queue,
2131 	 * if there is one...
2132 	 * XXX: The "Net/3" implementation doesn't imply that the TCP
2133 	 *      reassembly queue should be flushed, but in a situation
2134 	 *	where we're really low on mbufs, this is potentially
2135 	 *	useful.
2136 	 */
2137 		INP_INFO_WLOCK(&V_tcbinfo);
2138 		CK_LIST_FOREACH(inpb, V_tcbinfo.ipi_listhead, inp_list) {
2139 			INP_WLOCK(inpb);
2140 			if (inpb->inp_flags & INP_TIMEWAIT) {
2141 				INP_WUNLOCK(inpb);
2142 				continue;
2143 			}
2144 			if ((tcpb = intotcpcb(inpb)) != NULL) {
2145 				tcp_reass_flush(tcpb);
2146 				tcp_clean_sackreport(tcpb);
2147 #ifdef TCP_BLACKBOX
2148 				tcp_log_drain(tcpb);
2149 #endif
2150 #ifdef TCPPCAP
2151 				if (tcp_pcap_aggressive_free) {
2152 					/* Free the TCP PCAP queues. */
2153 					tcp_pcap_drain(&(tcpb->t_inpkts));
2154 					tcp_pcap_drain(&(tcpb->t_outpkts));
2155 				}
2156 #endif
2157 			}
2158 			INP_WUNLOCK(inpb);
2159 		}
2160 		INP_INFO_WUNLOCK(&V_tcbinfo);
2161 		CURVNET_RESTORE();
2162 	}
2163 	VNET_LIST_RUNLOCK_NOSLEEP();
2164 }
2165 
2166 /*
2167  * Notify a tcp user of an asynchronous error;
2168  * store error as soft error, but wake up user
2169  * (for now, won't do anything until can select for soft error).
2170  *
2171  * Do not wake up user since there currently is no mechanism for
2172  * reporting soft errors (yet - a kqueue filter may be added).
2173  */
2174 static struct inpcb *
2175 tcp_notify(struct inpcb *inp, int error)
2176 {
2177 	struct tcpcb *tp;
2178 
2179 	INP_INFO_LOCK_ASSERT(&V_tcbinfo);
2180 	INP_WLOCK_ASSERT(inp);
2181 
2182 	if ((inp->inp_flags & INP_TIMEWAIT) ||
2183 	    (inp->inp_flags & INP_DROPPED))
2184 		return (inp);
2185 
2186 	tp = intotcpcb(inp);
2187 	KASSERT(tp != NULL, ("tcp_notify: tp == NULL"));
2188 
2189 	/*
2190 	 * Ignore some errors if we are hooked up.
2191 	 * If connection hasn't completed, has retransmitted several times,
2192 	 * and receives a second error, give up now.  This is better
2193 	 * than waiting a long time to establish a connection that
2194 	 * can never complete.
2195 	 */
2196 	if (tp->t_state == TCPS_ESTABLISHED &&
2197 	    (error == EHOSTUNREACH || error == ENETUNREACH ||
2198 	     error == EHOSTDOWN)) {
2199 		if (inp->inp_route.ro_rt) {
2200 			RTFREE(inp->inp_route.ro_rt);
2201 			inp->inp_route.ro_rt = (struct rtentry *)NULL;
2202 		}
2203 		return (inp);
2204 	} else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 &&
2205 	    tp->t_softerror) {
2206 		tp = tcp_drop(tp, error);
2207 		if (tp != NULL)
2208 			return (inp);
2209 		else
2210 			return (NULL);
2211 	} else {
2212 		tp->t_softerror = error;
2213 		return (inp);
2214 	}
2215 #if 0
2216 	wakeup( &so->so_timeo);
2217 	sorwakeup(so);
2218 	sowwakeup(so);
2219 #endif
2220 }
2221 
2222 static int
2223 tcp_pcblist(SYSCTL_HANDLER_ARGS)
2224 {
2225 	struct epoch_tracker et;
2226 	struct inpcb *inp;
2227 	struct xinpgen xig;
2228 	int error;
2229 
2230 	if (req->newptr != NULL)
2231 		return (EPERM);
2232 
2233 	if (req->oldptr == NULL) {
2234 		int n;
2235 
2236 		n = V_tcbinfo.ipi_count +
2237 		    counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2238 		n += imax(n / 8, 10);
2239 		req->oldidx = 2 * (sizeof xig) + n * sizeof(struct xtcpcb);
2240 		return (0);
2241 	}
2242 
2243 	if ((error = sysctl_wire_old_buffer(req, 0)) != 0)
2244 		return (error);
2245 
2246 	bzero(&xig, sizeof(xig));
2247 	xig.xig_len = sizeof xig;
2248 	xig.xig_count = V_tcbinfo.ipi_count +
2249 	    counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2250 	xig.xig_gen = V_tcbinfo.ipi_gencnt;
2251 	xig.xig_sogen = so_gencnt;
2252 	error = SYSCTL_OUT(req, &xig, sizeof xig);
2253 	if (error)
2254 		return (error);
2255 
2256 	error = syncache_pcblist(req);
2257 	if (error)
2258 		return (error);
2259 
2260 	NET_EPOCH_ENTER(et);
2261 	for (inp = CK_LIST_FIRST(V_tcbinfo.ipi_listhead);
2262 	    inp != NULL;
2263 	    inp = CK_LIST_NEXT(inp, inp_list)) {
2264 		INP_RLOCK(inp);
2265 		if (inp->inp_gencnt <= xig.xig_gen) {
2266 			/*
2267 			 * XXX: This use of cr_cansee(), introduced with
2268 			 * TCP state changes, is not quite right, but for
2269 			 * now, better than nothing.
2270 			 */
2271 			if (inp->inp_flags & INP_TIMEWAIT) {
2272 				if (intotw(inp) != NULL)
2273 					error = cr_cansee(req->td->td_ucred,
2274 					    intotw(inp)->tw_cred);
2275 				else
2276 					error = EINVAL;	/* Skip this inp. */
2277 			} else
2278 				error = cr_canseeinpcb(req->td->td_ucred, inp);
2279 			if (error == 0) {
2280 				struct xtcpcb xt;
2281 
2282 				tcp_inptoxtp(inp, &xt);
2283 				INP_RUNLOCK(inp);
2284 				error = SYSCTL_OUT(req, &xt, sizeof xt);
2285 				if (error)
2286 					break;
2287 				else
2288 					continue;
2289 			}
2290 		}
2291 		INP_RUNLOCK(inp);
2292 	}
2293 	NET_EPOCH_EXIT(et);
2294 
2295 	if (!error) {
2296 		/*
2297 		 * Give the user an updated idea of our state.
2298 		 * If the generation differs from what we told
2299 		 * her before, she knows that something happened
2300 		 * while we were processing this request, and it
2301 		 * might be necessary to retry.
2302 		 */
2303 		xig.xig_gen = V_tcbinfo.ipi_gencnt;
2304 		xig.xig_sogen = so_gencnt;
2305 		xig.xig_count = V_tcbinfo.ipi_count +
2306 		    counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2307 		error = SYSCTL_OUT(req, &xig, sizeof xig);
2308 	}
2309 
2310 	return (error);
2311 }
2312 
2313 SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist,
2314     CTLTYPE_OPAQUE | CTLFLAG_RD, NULL, 0,
2315     tcp_pcblist, "S,xtcpcb", "List of active TCP connections");
2316 
2317 #ifdef INET
2318 static int
2319 tcp_getcred(SYSCTL_HANDLER_ARGS)
2320 {
2321 	struct xucred xuc;
2322 	struct sockaddr_in addrs[2];
2323 	struct epoch_tracker et;
2324 	struct inpcb *inp;
2325 	int error;
2326 
2327 	error = priv_check(req->td, PRIV_NETINET_GETCRED);
2328 	if (error)
2329 		return (error);
2330 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
2331 	if (error)
2332 		return (error);
2333 	NET_EPOCH_ENTER(et);
2334 	inp = in_pcblookup(&V_tcbinfo, addrs[1].sin_addr, addrs[1].sin_port,
2335 	    addrs[0].sin_addr, addrs[0].sin_port, INPLOOKUP_RLOCKPCB, NULL);
2336 	NET_EPOCH_EXIT(et);
2337 	if (inp != NULL) {
2338 		if (inp->inp_socket == NULL)
2339 			error = ENOENT;
2340 		if (error == 0)
2341 			error = cr_canseeinpcb(req->td->td_ucred, inp);
2342 		if (error == 0)
2343 			cru2x(inp->inp_cred, &xuc);
2344 		INP_RUNLOCK(inp);
2345 	} else
2346 		error = ENOENT;
2347 	if (error == 0)
2348 		error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
2349 	return (error);
2350 }
2351 
2352 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, getcred,
2353     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
2354     tcp_getcred, "S,xucred", "Get the xucred of a TCP connection");
2355 #endif /* INET */
2356 
2357 #ifdef INET6
2358 static int
2359 tcp6_getcred(SYSCTL_HANDLER_ARGS)
2360 {
2361 	struct epoch_tracker et;
2362 	struct xucred xuc;
2363 	struct sockaddr_in6 addrs[2];
2364 	struct inpcb *inp;
2365 	int error;
2366 #ifdef INET
2367 	int mapped = 0;
2368 #endif
2369 
2370 	error = priv_check(req->td, PRIV_NETINET_GETCRED);
2371 	if (error)
2372 		return (error);
2373 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
2374 	if (error)
2375 		return (error);
2376 	if ((error = sa6_embedscope(&addrs[0], V_ip6_use_defzone)) != 0 ||
2377 	    (error = sa6_embedscope(&addrs[1], V_ip6_use_defzone)) != 0) {
2378 		return (error);
2379 	}
2380 	if (IN6_IS_ADDR_V4MAPPED(&addrs[0].sin6_addr)) {
2381 #ifdef INET
2382 		if (IN6_IS_ADDR_V4MAPPED(&addrs[1].sin6_addr))
2383 			mapped = 1;
2384 		else
2385 #endif
2386 			return (EINVAL);
2387 	}
2388 
2389 	NET_EPOCH_ENTER(et);
2390 #ifdef INET
2391 	if (mapped == 1)
2392 		inp = in_pcblookup(&V_tcbinfo,
2393 			*(struct in_addr *)&addrs[1].sin6_addr.s6_addr[12],
2394 			addrs[1].sin6_port,
2395 			*(struct in_addr *)&addrs[0].sin6_addr.s6_addr[12],
2396 			addrs[0].sin6_port, INPLOOKUP_RLOCKPCB, NULL);
2397 	else
2398 #endif
2399 		inp = in6_pcblookup(&V_tcbinfo,
2400 			&addrs[1].sin6_addr, addrs[1].sin6_port,
2401 			&addrs[0].sin6_addr, addrs[0].sin6_port,
2402 			INPLOOKUP_RLOCKPCB, NULL);
2403 	NET_EPOCH_EXIT(et);
2404 	if (inp != NULL) {
2405 		if (inp->inp_socket == NULL)
2406 			error = ENOENT;
2407 		if (error == 0)
2408 			error = cr_canseeinpcb(req->td->td_ucred, inp);
2409 		if (error == 0)
2410 			cru2x(inp->inp_cred, &xuc);
2411 		INP_RUNLOCK(inp);
2412 	} else
2413 		error = ENOENT;
2414 	if (error == 0)
2415 		error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
2416 	return (error);
2417 }
2418 
2419 SYSCTL_PROC(_net_inet6_tcp6, OID_AUTO, getcred,
2420     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
2421     tcp6_getcred, "S,xucred", "Get the xucred of a TCP6 connection");
2422 #endif /* INET6 */
2423 
2424 
2425 #ifdef INET
2426 void
2427 tcp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
2428 {
2429 	struct ip *ip = vip;
2430 	struct tcphdr *th;
2431 	struct in_addr faddr;
2432 	struct inpcb *inp;
2433 	struct tcpcb *tp;
2434 	struct inpcb *(*notify)(struct inpcb *, int) = tcp_notify;
2435 	struct icmp *icp;
2436 	struct in_conninfo inc;
2437 	tcp_seq icmp_tcp_seq;
2438 	int mtu;
2439 
2440 	faddr = ((struct sockaddr_in *)sa)->sin_addr;
2441 	if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
2442 		return;
2443 
2444 	if (cmd == PRC_MSGSIZE)
2445 		notify = tcp_mtudisc_notify;
2446 	else if (V_icmp_may_rst && (cmd == PRC_UNREACH_ADMIN_PROHIB ||
2447 		cmd == PRC_UNREACH_PORT || cmd == PRC_UNREACH_PROTOCOL ||
2448 		cmd == PRC_TIMXCEED_INTRANS) && ip)
2449 		notify = tcp_drop_syn_sent;
2450 
2451 	/*
2452 	 * Hostdead is ugly because it goes linearly through all PCBs.
2453 	 * XXX: We never get this from ICMP, otherwise it makes an
2454 	 * excellent DoS attack on machines with many connections.
2455 	 */
2456 	else if (cmd == PRC_HOSTDEAD)
2457 		ip = NULL;
2458 	else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)
2459 		return;
2460 
2461 	if (ip == NULL) {
2462 		in_pcbnotifyall(&V_tcbinfo, faddr, inetctlerrmap[cmd], notify);
2463 		return;
2464 	}
2465 
2466 	icp = (struct icmp *)((caddr_t)ip - offsetof(struct icmp, icmp_ip));
2467 	th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
2468 	inp = in_pcblookup(&V_tcbinfo, faddr, th->th_dport, ip->ip_src,
2469 	    th->th_sport, INPLOOKUP_WLOCKPCB, NULL);
2470 	if (inp != NULL && PRC_IS_REDIRECT(cmd)) {
2471 		/* signal EHOSTDOWN, as it flushes the cached route */
2472 		inp = (*notify)(inp, EHOSTDOWN);
2473 		goto out;
2474 	}
2475 	icmp_tcp_seq = th->th_seq;
2476 	if (inp != NULL)  {
2477 		if (!(inp->inp_flags & INP_TIMEWAIT) &&
2478 		    !(inp->inp_flags & INP_DROPPED) &&
2479 		    !(inp->inp_socket == NULL)) {
2480 			tp = intotcpcb(inp);
2481 			if (SEQ_GEQ(ntohl(icmp_tcp_seq), tp->snd_una) &&
2482 			    SEQ_LT(ntohl(icmp_tcp_seq), tp->snd_max)) {
2483 				if (cmd == PRC_MSGSIZE) {
2484 					/*
2485 					 * MTU discovery:
2486 					 * If we got a needfrag set the MTU
2487 					 * in the route to the suggested new
2488 					 * value (if given) and then notify.
2489 					 */
2490 					mtu = ntohs(icp->icmp_nextmtu);
2491 					/*
2492 					 * If no alternative MTU was
2493 					 * proposed, try the next smaller
2494 					 * one.
2495 					 */
2496 					if (!mtu)
2497 						mtu = ip_next_mtu(
2498 						    ntohs(ip->ip_len), 1);
2499 					if (mtu < V_tcp_minmss +
2500 					    sizeof(struct tcpiphdr))
2501 						mtu = V_tcp_minmss +
2502 						    sizeof(struct tcpiphdr);
2503 					/*
2504 					 * Only process the offered MTU if it
2505 					 * is smaller than the current one.
2506 					 */
2507 					if (mtu < tp->t_maxseg +
2508 					    sizeof(struct tcpiphdr)) {
2509 						bzero(&inc, sizeof(inc));
2510 						inc.inc_faddr = faddr;
2511 						inc.inc_fibnum =
2512 						    inp->inp_inc.inc_fibnum;
2513 						tcp_hc_updatemtu(&inc, mtu);
2514 						tcp_mtudisc(inp, mtu);
2515 					}
2516 				} else
2517 					inp = (*notify)(inp,
2518 					    inetctlerrmap[cmd]);
2519 			}
2520 		}
2521 	} else {
2522 		bzero(&inc, sizeof(inc));
2523 		inc.inc_fport = th->th_dport;
2524 		inc.inc_lport = th->th_sport;
2525 		inc.inc_faddr = faddr;
2526 		inc.inc_laddr = ip->ip_src;
2527 		syncache_unreach(&inc, icmp_tcp_seq);
2528 	}
2529 out:
2530 	if (inp != NULL)
2531 		INP_WUNLOCK(inp);
2532 }
2533 #endif /* INET */
2534 
2535 #ifdef INET6
2536 void
2537 tcp6_ctlinput(int cmd, struct sockaddr *sa, void *d)
2538 {
2539 	struct in6_addr *dst;
2540 	struct inpcb *(*notify)(struct inpcb *, int) = tcp_notify;
2541 	struct ip6_hdr *ip6;
2542 	struct mbuf *m;
2543 	struct inpcb *inp;
2544 	struct tcpcb *tp;
2545 	struct icmp6_hdr *icmp6;
2546 	struct ip6ctlparam *ip6cp = NULL;
2547 	const struct sockaddr_in6 *sa6_src = NULL;
2548 	struct in_conninfo inc;
2549 	struct tcp_ports {
2550 		uint16_t th_sport;
2551 		uint16_t th_dport;
2552 	} t_ports;
2553 	tcp_seq icmp_tcp_seq;
2554 	unsigned int mtu;
2555 	unsigned int off;
2556 
2557 	if (sa->sa_family != AF_INET6 ||
2558 	    sa->sa_len != sizeof(struct sockaddr_in6))
2559 		return;
2560 
2561 	/* if the parameter is from icmp6, decode it. */
2562 	if (d != NULL) {
2563 		ip6cp = (struct ip6ctlparam *)d;
2564 		icmp6 = ip6cp->ip6c_icmp6;
2565 		m = ip6cp->ip6c_m;
2566 		ip6 = ip6cp->ip6c_ip6;
2567 		off = ip6cp->ip6c_off;
2568 		sa6_src = ip6cp->ip6c_src;
2569 		dst = ip6cp->ip6c_finaldst;
2570 	} else {
2571 		m = NULL;
2572 		ip6 = NULL;
2573 		off = 0;	/* fool gcc */
2574 		sa6_src = &sa6_any;
2575 		dst = NULL;
2576 	}
2577 
2578 	if (cmd == PRC_MSGSIZE)
2579 		notify = tcp_mtudisc_notify;
2580 	else if (V_icmp_may_rst && (cmd == PRC_UNREACH_ADMIN_PROHIB ||
2581 		cmd == PRC_UNREACH_PORT || cmd == PRC_UNREACH_PROTOCOL ||
2582 		cmd == PRC_TIMXCEED_INTRANS) && ip6 != NULL)
2583 		notify = tcp_drop_syn_sent;
2584 
2585 	/*
2586 	 * Hostdead is ugly because it goes linearly through all PCBs.
2587 	 * XXX: We never get this from ICMP, otherwise it makes an
2588 	 * excellent DoS attack on machines with many connections.
2589 	 */
2590 	else if (cmd == PRC_HOSTDEAD)
2591 		ip6 = NULL;
2592 	else if ((unsigned)cmd >= PRC_NCMDS || inet6ctlerrmap[cmd] == 0)
2593 		return;
2594 
2595 	if (ip6 == NULL) {
2596 		in6_pcbnotify(&V_tcbinfo, sa, 0,
2597 			      (const struct sockaddr *)sa6_src,
2598 			      0, cmd, NULL, notify);
2599 		return;
2600 	}
2601 
2602 	/* Check if we can safely get the ports from the tcp hdr */
2603 	if (m == NULL ||
2604 	    (m->m_pkthdr.len <
2605 		(int32_t) (off + sizeof(struct tcp_ports)))) {
2606 		return;
2607 	}
2608 	bzero(&t_ports, sizeof(struct tcp_ports));
2609 	m_copydata(m, off, sizeof(struct tcp_ports), (caddr_t)&t_ports);
2610 	inp = in6_pcblookup(&V_tcbinfo, &ip6->ip6_dst, t_ports.th_dport,
2611 	    &ip6->ip6_src, t_ports.th_sport, INPLOOKUP_WLOCKPCB, NULL);
2612 	if (inp != NULL && PRC_IS_REDIRECT(cmd)) {
2613 		/* signal EHOSTDOWN, as it flushes the cached route */
2614 		inp = (*notify)(inp, EHOSTDOWN);
2615 		goto out;
2616 	}
2617 	off += sizeof(struct tcp_ports);
2618 	if (m->m_pkthdr.len < (int32_t) (off + sizeof(tcp_seq))) {
2619 		goto out;
2620 	}
2621 	m_copydata(m, off, sizeof(tcp_seq), (caddr_t)&icmp_tcp_seq);
2622 	if (inp != NULL)  {
2623 		if (!(inp->inp_flags & INP_TIMEWAIT) &&
2624 		    !(inp->inp_flags & INP_DROPPED) &&
2625 		    !(inp->inp_socket == NULL)) {
2626 			tp = intotcpcb(inp);
2627 			if (SEQ_GEQ(ntohl(icmp_tcp_seq), tp->snd_una) &&
2628 			    SEQ_LT(ntohl(icmp_tcp_seq), tp->snd_max)) {
2629 				if (cmd == PRC_MSGSIZE) {
2630 					/*
2631 					 * MTU discovery:
2632 					 * If we got a needfrag set the MTU
2633 					 * in the route to the suggested new
2634 					 * value (if given) and then notify.
2635 					 */
2636 					mtu = ntohl(icmp6->icmp6_mtu);
2637 					/*
2638 					 * If no alternative MTU was
2639 					 * proposed, or the proposed
2640 					 * MTU was too small, set to
2641 					 * the min.
2642 					 */
2643 					if (mtu < IPV6_MMTU)
2644 						mtu = IPV6_MMTU - 8;
2645 					bzero(&inc, sizeof(inc));
2646 					inc.inc_fibnum = M_GETFIB(m);
2647 					inc.inc_flags |= INC_ISIPV6;
2648 					inc.inc6_faddr = *dst;
2649 					if (in6_setscope(&inc.inc6_faddr,
2650 						m->m_pkthdr.rcvif, NULL))
2651 						goto out;
2652 					/*
2653 					 * Only process the offered MTU if it
2654 					 * is smaller than the current one.
2655 					 */
2656 					if (mtu < tp->t_maxseg +
2657 					    sizeof (struct tcphdr) +
2658 					    sizeof (struct ip6_hdr)) {
2659 						tcp_hc_updatemtu(&inc, mtu);
2660 						tcp_mtudisc(inp, mtu);
2661 						ICMP6STAT_INC(icp6s_pmtuchg);
2662 					}
2663 				} else
2664 					inp = (*notify)(inp,
2665 					    inet6ctlerrmap[cmd]);
2666 			}
2667 		}
2668 	} else {
2669 		bzero(&inc, sizeof(inc));
2670 		inc.inc_fibnum = M_GETFIB(m);
2671 		inc.inc_flags |= INC_ISIPV6;
2672 		inc.inc_fport = t_ports.th_dport;
2673 		inc.inc_lport = t_ports.th_sport;
2674 		inc.inc6_faddr = *dst;
2675 		inc.inc6_laddr = ip6->ip6_src;
2676 		syncache_unreach(&inc, icmp_tcp_seq);
2677 	}
2678 out:
2679 	if (inp != NULL)
2680 		INP_WUNLOCK(inp);
2681 }
2682 #endif /* INET6 */
2683 
2684 static uint32_t
2685 tcp_keyed_hash(struct in_conninfo *inc, u_char *key, u_int len)
2686 {
2687 	SIPHASH_CTX ctx;
2688 	uint32_t hash[2];
2689 
2690 	KASSERT(len >= SIPHASH_KEY_LENGTH,
2691 	    ("%s: keylen %u too short ", __func__, len));
2692 	SipHash24_Init(&ctx);
2693 	SipHash_SetKey(&ctx, (uint8_t *)key);
2694 	SipHash_Update(&ctx, &inc->inc_fport, sizeof(uint16_t));
2695 	SipHash_Update(&ctx, &inc->inc_lport, sizeof(uint16_t));
2696 	switch (inc->inc_flags & INC_ISIPV6) {
2697 #ifdef INET
2698 	case 0:
2699 		SipHash_Update(&ctx, &inc->inc_faddr, sizeof(struct in_addr));
2700 		SipHash_Update(&ctx, &inc->inc_laddr, sizeof(struct in_addr));
2701 		break;
2702 #endif
2703 #ifdef INET6
2704 	case INC_ISIPV6:
2705 		SipHash_Update(&ctx, &inc->inc6_faddr, sizeof(struct in6_addr));
2706 		SipHash_Update(&ctx, &inc->inc6_laddr, sizeof(struct in6_addr));
2707 		break;
2708 #endif
2709 	}
2710 	SipHash_Final((uint8_t *)hash, &ctx);
2711 
2712 	return (hash[0] ^ hash[1]);
2713 }
2714 
2715 uint32_t
2716 tcp_new_ts_offset(struct in_conninfo *inc)
2717 {
2718 	struct in_conninfo inc_store, *local_inc;
2719 
2720 	if (!V_tcp_ts_offset_per_conn) {
2721 		memcpy(&inc_store, inc, sizeof(struct in_conninfo));
2722 		inc_store.inc_lport = 0;
2723 		inc_store.inc_fport = 0;
2724 		local_inc = &inc_store;
2725 	} else {
2726 		local_inc = inc;
2727 	}
2728 	return (tcp_keyed_hash(local_inc, V_ts_offset_secret,
2729 	    sizeof(V_ts_offset_secret)));
2730 }
2731 
2732 /*
2733  * Following is where TCP initial sequence number generation occurs.
2734  *
2735  * There are two places where we must use initial sequence numbers:
2736  * 1.  In SYN-ACK packets.
2737  * 2.  In SYN packets.
2738  *
2739  * All ISNs for SYN-ACK packets are generated by the syncache.  See
2740  * tcp_syncache.c for details.
2741  *
2742  * The ISNs in SYN packets must be monotonic; TIME_WAIT recycling
2743  * depends on this property.  In addition, these ISNs should be
2744  * unguessable so as to prevent connection hijacking.  To satisfy
2745  * the requirements of this situation, the algorithm outlined in
2746  * RFC 1948 is used, with only small modifications.
2747  *
2748  * Implementation details:
2749  *
2750  * Time is based off the system timer, and is corrected so that it
2751  * increases by one megabyte per second.  This allows for proper
2752  * recycling on high speed LANs while still leaving over an hour
2753  * before rollover.
2754  *
2755  * As reading the *exact* system time is too expensive to be done
2756  * whenever setting up a TCP connection, we increment the time
2757  * offset in two ways.  First, a small random positive increment
2758  * is added to isn_offset for each connection that is set up.
2759  * Second, the function tcp_isn_tick fires once per clock tick
2760  * and increments isn_offset as necessary so that sequence numbers
2761  * are incremented at approximately ISN_BYTES_PER_SECOND.  The
2762  * random positive increments serve only to ensure that the same
2763  * exact sequence number is never sent out twice (as could otherwise
2764  * happen when a port is recycled in less than the system tick
2765  * interval.)
2766  *
2767  * net.inet.tcp.isn_reseed_interval controls the number of seconds
2768  * between seeding of isn_secret.  This is normally set to zero,
2769  * as reseeding should not be necessary.
2770  *
2771  * Locking of the global variables isn_secret, isn_last_reseed, isn_offset,
2772  * isn_offset_old, and isn_ctx is performed using the ISN lock.  In
2773  * general, this means holding an exclusive (write) lock.
2774  */
2775 
2776 #define ISN_BYTES_PER_SECOND 1048576
2777 #define ISN_STATIC_INCREMENT 4096
2778 #define ISN_RANDOM_INCREMENT (4096 - 1)
2779 #define ISN_SECRET_LENGTH    SIPHASH_KEY_LENGTH
2780 
2781 VNET_DEFINE_STATIC(u_char, isn_secret[ISN_SECRET_LENGTH]);
2782 VNET_DEFINE_STATIC(int, isn_last);
2783 VNET_DEFINE_STATIC(int, isn_last_reseed);
2784 VNET_DEFINE_STATIC(u_int32_t, isn_offset);
2785 VNET_DEFINE_STATIC(u_int32_t, isn_offset_old);
2786 
2787 #define	V_isn_secret			VNET(isn_secret)
2788 #define	V_isn_last			VNET(isn_last)
2789 #define	V_isn_last_reseed		VNET(isn_last_reseed)
2790 #define	V_isn_offset			VNET(isn_offset)
2791 #define	V_isn_offset_old		VNET(isn_offset_old)
2792 
2793 tcp_seq
2794 tcp_new_isn(struct in_conninfo *inc)
2795 {
2796 	tcp_seq new_isn;
2797 	u_int32_t projected_offset;
2798 
2799 	ISN_LOCK();
2800 	/* Seed if this is the first use, reseed if requested. */
2801 	if ((V_isn_last_reseed == 0) || ((V_tcp_isn_reseed_interval > 0) &&
2802 	     (((u_int)V_isn_last_reseed + (u_int)V_tcp_isn_reseed_interval*hz)
2803 		< (u_int)ticks))) {
2804 		arc4rand(&V_isn_secret, sizeof(V_isn_secret), 0);
2805 		V_isn_last_reseed = ticks;
2806 	}
2807 
2808 	/* Compute the hash and return the ISN. */
2809 	new_isn = (tcp_seq)tcp_keyed_hash(inc, V_isn_secret,
2810 	    sizeof(V_isn_secret));
2811 	V_isn_offset += ISN_STATIC_INCREMENT +
2812 		(arc4random() & ISN_RANDOM_INCREMENT);
2813 	if (ticks != V_isn_last) {
2814 		projected_offset = V_isn_offset_old +
2815 		    ISN_BYTES_PER_SECOND / hz * (ticks - V_isn_last);
2816 		if (SEQ_GT(projected_offset, V_isn_offset))
2817 			V_isn_offset = projected_offset;
2818 		V_isn_offset_old = V_isn_offset;
2819 		V_isn_last = ticks;
2820 	}
2821 	new_isn += V_isn_offset;
2822 	ISN_UNLOCK();
2823 	return (new_isn);
2824 }
2825 
2826 /*
2827  * When a specific ICMP unreachable message is received and the
2828  * connection state is SYN-SENT, drop the connection.  This behavior
2829  * is controlled by the icmp_may_rst sysctl.
2830  */
2831 struct inpcb *
2832 tcp_drop_syn_sent(struct inpcb *inp, int errno)
2833 {
2834 	struct tcpcb *tp;
2835 
2836 	NET_EPOCH_ASSERT();
2837 	INP_WLOCK_ASSERT(inp);
2838 
2839 	if ((inp->inp_flags & INP_TIMEWAIT) ||
2840 	    (inp->inp_flags & INP_DROPPED))
2841 		return (inp);
2842 
2843 	tp = intotcpcb(inp);
2844 	if (tp->t_state != TCPS_SYN_SENT)
2845 		return (inp);
2846 
2847 	if (IS_FASTOPEN(tp->t_flags))
2848 		tcp_fastopen_disable_path(tp);
2849 
2850 	tp = tcp_drop(tp, errno);
2851 	if (tp != NULL)
2852 		return (inp);
2853 	else
2854 		return (NULL);
2855 }
2856 
2857 /*
2858  * When `need fragmentation' ICMP is received, update our idea of the MSS
2859  * based on the new value. Also nudge TCP to send something, since we
2860  * know the packet we just sent was dropped.
2861  * This duplicates some code in the tcp_mss() function in tcp_input.c.
2862  */
2863 static struct inpcb *
2864 tcp_mtudisc_notify(struct inpcb *inp, int error)
2865 {
2866 
2867 	tcp_mtudisc(inp, -1);
2868 	return (inp);
2869 }
2870 
2871 static void
2872 tcp_mtudisc(struct inpcb *inp, int mtuoffer)
2873 {
2874 	struct tcpcb *tp;
2875 	struct socket *so;
2876 
2877 	INP_WLOCK_ASSERT(inp);
2878 	if ((inp->inp_flags & INP_TIMEWAIT) ||
2879 	    (inp->inp_flags & INP_DROPPED))
2880 		return;
2881 
2882 	tp = intotcpcb(inp);
2883 	KASSERT(tp != NULL, ("tcp_mtudisc: tp == NULL"));
2884 
2885 	tcp_mss_update(tp, -1, mtuoffer, NULL, NULL);
2886 
2887 	so = inp->inp_socket;
2888 	SOCKBUF_LOCK(&so->so_snd);
2889 	/* If the mss is larger than the socket buffer, decrease the mss. */
2890 	if (so->so_snd.sb_hiwat < tp->t_maxseg)
2891 		tp->t_maxseg = so->so_snd.sb_hiwat;
2892 	SOCKBUF_UNLOCK(&so->so_snd);
2893 
2894 	TCPSTAT_INC(tcps_mturesent);
2895 	tp->t_rtttime = 0;
2896 	tp->snd_nxt = tp->snd_una;
2897 	tcp_free_sackholes(tp);
2898 	tp->snd_recover = tp->snd_max;
2899 	if (tp->t_flags & TF_SACK_PERMIT)
2900 		EXIT_FASTRECOVERY(tp->t_flags);
2901 	tp->t_fb->tfb_tcp_output(tp);
2902 }
2903 
2904 #ifdef INET
2905 /*
2906  * Look-up the routing entry to the peer of this inpcb.  If no route
2907  * is found and it cannot be allocated, then return 0.  This routine
2908  * is called by TCP routines that access the rmx structure and by
2909  * tcp_mss_update to get the peer/interface MTU.
2910  */
2911 uint32_t
2912 tcp_maxmtu(struct in_conninfo *inc, struct tcp_ifcap *cap)
2913 {
2914 	struct nhop4_extended nh4;
2915 	struct ifnet *ifp;
2916 	uint32_t maxmtu = 0;
2917 
2918 	KASSERT(inc != NULL, ("tcp_maxmtu with NULL in_conninfo pointer"));
2919 
2920 	if (inc->inc_faddr.s_addr != INADDR_ANY) {
2921 
2922 		if (fib4_lookup_nh_ext(inc->inc_fibnum, inc->inc_faddr,
2923 		    NHR_REF, 0, &nh4) != 0)
2924 			return (0);
2925 
2926 		ifp = nh4.nh_ifp;
2927 		maxmtu = nh4.nh_mtu;
2928 
2929 		/* Report additional interface capabilities. */
2930 		if (cap != NULL) {
2931 			if (ifp->if_capenable & IFCAP_TSO4 &&
2932 			    ifp->if_hwassist & CSUM_TSO) {
2933 				cap->ifcap |= CSUM_TSO;
2934 				cap->tsomax = ifp->if_hw_tsomax;
2935 				cap->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
2936 				cap->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
2937 			}
2938 		}
2939 		fib4_free_nh_ext(inc->inc_fibnum, &nh4);
2940 	}
2941 	return (maxmtu);
2942 }
2943 #endif /* INET */
2944 
2945 #ifdef INET6
2946 uint32_t
2947 tcp_maxmtu6(struct in_conninfo *inc, struct tcp_ifcap *cap)
2948 {
2949 	struct nhop6_extended nh6;
2950 	struct in6_addr dst6;
2951 	uint32_t scopeid;
2952 	struct ifnet *ifp;
2953 	uint32_t maxmtu = 0;
2954 
2955 	KASSERT(inc != NULL, ("tcp_maxmtu6 with NULL in_conninfo pointer"));
2956 
2957 	if (inc->inc_flags & INC_IPV6MINMTU)
2958 		return (IPV6_MMTU);
2959 
2960 	if (!IN6_IS_ADDR_UNSPECIFIED(&inc->inc6_faddr)) {
2961 		in6_splitscope(&inc->inc6_faddr, &dst6, &scopeid);
2962 		if (fib6_lookup_nh_ext(inc->inc_fibnum, &dst6, scopeid, 0,
2963 		    0, &nh6) != 0)
2964 			return (0);
2965 
2966 		ifp = nh6.nh_ifp;
2967 		maxmtu = nh6.nh_mtu;
2968 
2969 		/* Report additional interface capabilities. */
2970 		if (cap != NULL) {
2971 			if (ifp->if_capenable & IFCAP_TSO6 &&
2972 			    ifp->if_hwassist & CSUM_TSO) {
2973 				cap->ifcap |= CSUM_TSO;
2974 				cap->tsomax = ifp->if_hw_tsomax;
2975 				cap->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
2976 				cap->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
2977 			}
2978 		}
2979 		fib6_free_nh_ext(inc->inc_fibnum, &nh6);
2980 	}
2981 
2982 	return (maxmtu);
2983 }
2984 #endif /* INET6 */
2985 
2986 /*
2987  * Calculate effective SMSS per RFC5681 definition for a given TCP
2988  * connection at its current state, taking into account SACK and etc.
2989  */
2990 u_int
2991 tcp_maxseg(const struct tcpcb *tp)
2992 {
2993 	u_int optlen;
2994 
2995 	if (tp->t_flags & TF_NOOPT)
2996 		return (tp->t_maxseg);
2997 
2998 	/*
2999 	 * Here we have a simplified code from tcp_addoptions(),
3000 	 * without a proper loop, and having most of paddings hardcoded.
3001 	 * We might make mistakes with padding here in some edge cases,
3002 	 * but this is harmless, since result of tcp_maxseg() is used
3003 	 * only in cwnd and ssthresh estimations.
3004 	 */
3005 #define	PAD(len)	((((len) / 4) + !!((len) % 4)) * 4)
3006 	if (TCPS_HAVEESTABLISHED(tp->t_state)) {
3007 		if (tp->t_flags & TF_RCVD_TSTMP)
3008 			optlen = TCPOLEN_TSTAMP_APPA;
3009 		else
3010 			optlen = 0;
3011 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3012 		if (tp->t_flags & TF_SIGNATURE)
3013 			optlen += PAD(TCPOLEN_SIGNATURE);
3014 #endif
3015 		if ((tp->t_flags & TF_SACK_PERMIT) && tp->rcv_numsacks > 0) {
3016 			optlen += TCPOLEN_SACKHDR;
3017 			optlen += tp->rcv_numsacks * TCPOLEN_SACK;
3018 			optlen = PAD(optlen);
3019 		}
3020 	} else {
3021 		if (tp->t_flags & TF_REQ_TSTMP)
3022 			optlen = TCPOLEN_TSTAMP_APPA;
3023 		else
3024 			optlen = PAD(TCPOLEN_MAXSEG);
3025 		if (tp->t_flags & TF_REQ_SCALE)
3026 			optlen += PAD(TCPOLEN_WINDOW);
3027 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3028 		if (tp->t_flags & TF_SIGNATURE)
3029 			optlen += PAD(TCPOLEN_SIGNATURE);
3030 #endif
3031 		if (tp->t_flags & TF_SACK_PERMIT)
3032 			optlen += PAD(TCPOLEN_SACK_PERMITTED);
3033 	}
3034 #undef PAD
3035 	optlen = min(optlen, TCP_MAXOLEN);
3036 	return (tp->t_maxseg - optlen);
3037 }
3038 
3039 static int
3040 sysctl_drop(SYSCTL_HANDLER_ARGS)
3041 {
3042 	/* addrs[0] is a foreign socket, addrs[1] is a local one. */
3043 	struct sockaddr_storage addrs[2];
3044 	struct inpcb *inp;
3045 	struct tcpcb *tp;
3046 	struct tcptw *tw;
3047 	struct sockaddr_in *fin, *lin;
3048 	struct epoch_tracker et;
3049 #ifdef INET6
3050 	struct sockaddr_in6 *fin6, *lin6;
3051 #endif
3052 	int error;
3053 
3054 	inp = NULL;
3055 	fin = lin = NULL;
3056 #ifdef INET6
3057 	fin6 = lin6 = NULL;
3058 #endif
3059 	error = 0;
3060 
3061 	if (req->oldptr != NULL || req->oldlen != 0)
3062 		return (EINVAL);
3063 	if (req->newptr == NULL)
3064 		return (EPERM);
3065 	if (req->newlen < sizeof(addrs))
3066 		return (ENOMEM);
3067 	error = SYSCTL_IN(req, &addrs, sizeof(addrs));
3068 	if (error)
3069 		return (error);
3070 
3071 	switch (addrs[0].ss_family) {
3072 #ifdef INET6
3073 	case AF_INET6:
3074 		fin6 = (struct sockaddr_in6 *)&addrs[0];
3075 		lin6 = (struct sockaddr_in6 *)&addrs[1];
3076 		if (fin6->sin6_len != sizeof(struct sockaddr_in6) ||
3077 		    lin6->sin6_len != sizeof(struct sockaddr_in6))
3078 			return (EINVAL);
3079 		if (IN6_IS_ADDR_V4MAPPED(&fin6->sin6_addr)) {
3080 			if (!IN6_IS_ADDR_V4MAPPED(&lin6->sin6_addr))
3081 				return (EINVAL);
3082 			in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[0]);
3083 			in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[1]);
3084 			fin = (struct sockaddr_in *)&addrs[0];
3085 			lin = (struct sockaddr_in *)&addrs[1];
3086 			break;
3087 		}
3088 		error = sa6_embedscope(fin6, V_ip6_use_defzone);
3089 		if (error)
3090 			return (error);
3091 		error = sa6_embedscope(lin6, V_ip6_use_defzone);
3092 		if (error)
3093 			return (error);
3094 		break;
3095 #endif
3096 #ifdef INET
3097 	case AF_INET:
3098 		fin = (struct sockaddr_in *)&addrs[0];
3099 		lin = (struct sockaddr_in *)&addrs[1];
3100 		if (fin->sin_len != sizeof(struct sockaddr_in) ||
3101 		    lin->sin_len != sizeof(struct sockaddr_in))
3102 			return (EINVAL);
3103 		break;
3104 #endif
3105 	default:
3106 		return (EINVAL);
3107 	}
3108 	NET_EPOCH_ENTER(et);
3109 	switch (addrs[0].ss_family) {
3110 #ifdef INET6
3111 	case AF_INET6:
3112 		inp = in6_pcblookup(&V_tcbinfo, &fin6->sin6_addr,
3113 		    fin6->sin6_port, &lin6->sin6_addr, lin6->sin6_port,
3114 		    INPLOOKUP_WLOCKPCB, NULL);
3115 		break;
3116 #endif
3117 #ifdef INET
3118 	case AF_INET:
3119 		inp = in_pcblookup(&V_tcbinfo, fin->sin_addr, fin->sin_port,
3120 		    lin->sin_addr, lin->sin_port, INPLOOKUP_WLOCKPCB, NULL);
3121 		break;
3122 #endif
3123 	}
3124 	if (inp != NULL) {
3125 		if (inp->inp_flags & INP_TIMEWAIT) {
3126 			/*
3127 			 * XXXRW: There currently exists a state where an
3128 			 * inpcb is present, but its timewait state has been
3129 			 * discarded.  For now, don't allow dropping of this
3130 			 * type of inpcb.
3131 			 */
3132 			tw = intotw(inp);
3133 			if (tw != NULL)
3134 				tcp_twclose(tw, 0);
3135 			else
3136 				INP_WUNLOCK(inp);
3137 		} else if (!(inp->inp_flags & INP_DROPPED) &&
3138 			   !(inp->inp_socket->so_options & SO_ACCEPTCONN)) {
3139 			tp = intotcpcb(inp);
3140 			tp = tcp_drop(tp, ECONNABORTED);
3141 			if (tp != NULL)
3142 				INP_WUNLOCK(inp);
3143 		} else
3144 			INP_WUNLOCK(inp);
3145 	} else
3146 		error = ESRCH;
3147 	NET_EPOCH_EXIT(et);
3148 	return (error);
3149 }
3150 
3151 SYSCTL_PROC(_net_inet_tcp, TCPCTL_DROP, drop,
3152     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP, NULL,
3153     0, sysctl_drop, "", "Drop TCP connection");
3154 
3155 #ifdef KERN_TLS
3156 static int
3157 sysctl_switch_tls(SYSCTL_HANDLER_ARGS)
3158 {
3159 	/* addrs[0] is a foreign socket, addrs[1] is a local one. */
3160 	struct sockaddr_storage addrs[2];
3161 	struct inpcb *inp;
3162 	struct sockaddr_in *fin, *lin;
3163 	struct epoch_tracker et;
3164 #ifdef INET6
3165 	struct sockaddr_in6 *fin6, *lin6;
3166 #endif
3167 	int error;
3168 
3169 	inp = NULL;
3170 	fin = lin = NULL;
3171 #ifdef INET6
3172 	fin6 = lin6 = NULL;
3173 #endif
3174 	error = 0;
3175 
3176 	if (req->oldptr != NULL || req->oldlen != 0)
3177 		return (EINVAL);
3178 	if (req->newptr == NULL)
3179 		return (EPERM);
3180 	if (req->newlen < sizeof(addrs))
3181 		return (ENOMEM);
3182 	error = SYSCTL_IN(req, &addrs, sizeof(addrs));
3183 	if (error)
3184 		return (error);
3185 
3186 	switch (addrs[0].ss_family) {
3187 #ifdef INET6
3188 	case AF_INET6:
3189 		fin6 = (struct sockaddr_in6 *)&addrs[0];
3190 		lin6 = (struct sockaddr_in6 *)&addrs[1];
3191 		if (fin6->sin6_len != sizeof(struct sockaddr_in6) ||
3192 		    lin6->sin6_len != sizeof(struct sockaddr_in6))
3193 			return (EINVAL);
3194 		if (IN6_IS_ADDR_V4MAPPED(&fin6->sin6_addr)) {
3195 			if (!IN6_IS_ADDR_V4MAPPED(&lin6->sin6_addr))
3196 				return (EINVAL);
3197 			in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[0]);
3198 			in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[1]);
3199 			fin = (struct sockaddr_in *)&addrs[0];
3200 			lin = (struct sockaddr_in *)&addrs[1];
3201 			break;
3202 		}
3203 		error = sa6_embedscope(fin6, V_ip6_use_defzone);
3204 		if (error)
3205 			return (error);
3206 		error = sa6_embedscope(lin6, V_ip6_use_defzone);
3207 		if (error)
3208 			return (error);
3209 		break;
3210 #endif
3211 #ifdef INET
3212 	case AF_INET:
3213 		fin = (struct sockaddr_in *)&addrs[0];
3214 		lin = (struct sockaddr_in *)&addrs[1];
3215 		if (fin->sin_len != sizeof(struct sockaddr_in) ||
3216 		    lin->sin_len != sizeof(struct sockaddr_in))
3217 			return (EINVAL);
3218 		break;
3219 #endif
3220 	default:
3221 		return (EINVAL);
3222 	}
3223 	NET_EPOCH_ENTER(et);
3224 	switch (addrs[0].ss_family) {
3225 #ifdef INET6
3226 	case AF_INET6:
3227 		inp = in6_pcblookup(&V_tcbinfo, &fin6->sin6_addr,
3228 		    fin6->sin6_port, &lin6->sin6_addr, lin6->sin6_port,
3229 		    INPLOOKUP_WLOCKPCB, NULL);
3230 		break;
3231 #endif
3232 #ifdef INET
3233 	case AF_INET:
3234 		inp = in_pcblookup(&V_tcbinfo, fin->sin_addr, fin->sin_port,
3235 		    lin->sin_addr, lin->sin_port, INPLOOKUP_WLOCKPCB, NULL);
3236 		break;
3237 #endif
3238 	}
3239 	NET_EPOCH_EXIT(et);
3240 	if (inp != NULL) {
3241 		if ((inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) != 0 ||
3242 		    inp->inp_socket == NULL) {
3243 			error = ECONNRESET;
3244 			INP_WUNLOCK(inp);
3245 		} else {
3246 			struct socket *so;
3247 
3248 			so = inp->inp_socket;
3249 			soref(so);
3250 			error = ktls_set_tx_mode(so,
3251 			    arg2 == 0 ? TCP_TLS_MODE_SW : TCP_TLS_MODE_IFNET);
3252 			INP_WUNLOCK(inp);
3253 			SOCK_LOCK(so);
3254 			sorele(so);
3255 		}
3256 	} else
3257 		error = ESRCH;
3258 	return (error);
3259 }
3260 
3261 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_sw_tls,
3262     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP, NULL,
3263     0, sysctl_switch_tls, "", "Switch TCP connection to SW TLS");
3264 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_ifnet_tls,
3265     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP, NULL,
3266     1, sysctl_switch_tls, "", "Switch TCP connection to ifnet TLS");
3267 #endif
3268 
3269 /*
3270  * Generate a standardized TCP log line for use throughout the
3271  * tcp subsystem.  Memory allocation is done with M_NOWAIT to
3272  * allow use in the interrupt context.
3273  *
3274  * NB: The caller MUST free(s, M_TCPLOG) the returned string.
3275  * NB: The function may return NULL if memory allocation failed.
3276  *
3277  * Due to header inclusion and ordering limitations the struct ip
3278  * and ip6_hdr pointers have to be passed as void pointers.
3279  */
3280 char *
3281 tcp_log_vain(struct in_conninfo *inc, struct tcphdr *th, void *ip4hdr,
3282     const void *ip6hdr)
3283 {
3284 
3285 	/* Is logging enabled? */
3286 	if (tcp_log_in_vain == 0)
3287 		return (NULL);
3288 
3289 	return (tcp_log_addr(inc, th, ip4hdr, ip6hdr));
3290 }
3291 
3292 char *
3293 tcp_log_addrs(struct in_conninfo *inc, struct tcphdr *th, void *ip4hdr,
3294     const void *ip6hdr)
3295 {
3296 
3297 	/* Is logging enabled? */
3298 	if (tcp_log_debug == 0)
3299 		return (NULL);
3300 
3301 	return (tcp_log_addr(inc, th, ip4hdr, ip6hdr));
3302 }
3303 
3304 static char *
3305 tcp_log_addr(struct in_conninfo *inc, struct tcphdr *th, void *ip4hdr,
3306     const void *ip6hdr)
3307 {
3308 	char *s, *sp;
3309 	size_t size;
3310 	struct ip *ip;
3311 #ifdef INET6
3312 	const struct ip6_hdr *ip6;
3313 
3314 	ip6 = (const struct ip6_hdr *)ip6hdr;
3315 #endif /* INET6 */
3316 	ip = (struct ip *)ip4hdr;
3317 
3318 	/*
3319 	 * The log line looks like this:
3320 	 * "TCP: [1.2.3.4]:50332 to [1.2.3.4]:80 tcpflags 0x2<SYN>"
3321 	 */
3322 	size = sizeof("TCP: []:12345 to []:12345 tcpflags 0x2<>") +
3323 	    sizeof(PRINT_TH_FLAGS) + 1 +
3324 #ifdef INET6
3325 	    2 * INET6_ADDRSTRLEN;
3326 #else
3327 	    2 * INET_ADDRSTRLEN;
3328 #endif /* INET6 */
3329 
3330 	s = malloc(size, M_TCPLOG, M_ZERO|M_NOWAIT);
3331 	if (s == NULL)
3332 		return (NULL);
3333 
3334 	strcat(s, "TCP: [");
3335 	sp = s + strlen(s);
3336 
3337 	if (inc && ((inc->inc_flags & INC_ISIPV6) == 0)) {
3338 		inet_ntoa_r(inc->inc_faddr, sp);
3339 		sp = s + strlen(s);
3340 		sprintf(sp, "]:%i to [", ntohs(inc->inc_fport));
3341 		sp = s + strlen(s);
3342 		inet_ntoa_r(inc->inc_laddr, sp);
3343 		sp = s + strlen(s);
3344 		sprintf(sp, "]:%i", ntohs(inc->inc_lport));
3345 #ifdef INET6
3346 	} else if (inc) {
3347 		ip6_sprintf(sp, &inc->inc6_faddr);
3348 		sp = s + strlen(s);
3349 		sprintf(sp, "]:%i to [", ntohs(inc->inc_fport));
3350 		sp = s + strlen(s);
3351 		ip6_sprintf(sp, &inc->inc6_laddr);
3352 		sp = s + strlen(s);
3353 		sprintf(sp, "]:%i", ntohs(inc->inc_lport));
3354 	} else if (ip6 && th) {
3355 		ip6_sprintf(sp, &ip6->ip6_src);
3356 		sp = s + strlen(s);
3357 		sprintf(sp, "]:%i to [", ntohs(th->th_sport));
3358 		sp = s + strlen(s);
3359 		ip6_sprintf(sp, &ip6->ip6_dst);
3360 		sp = s + strlen(s);
3361 		sprintf(sp, "]:%i", ntohs(th->th_dport));
3362 #endif /* INET6 */
3363 #ifdef INET
3364 	} else if (ip && th) {
3365 		inet_ntoa_r(ip->ip_src, sp);
3366 		sp = s + strlen(s);
3367 		sprintf(sp, "]:%i to [", ntohs(th->th_sport));
3368 		sp = s + strlen(s);
3369 		inet_ntoa_r(ip->ip_dst, sp);
3370 		sp = s + strlen(s);
3371 		sprintf(sp, "]:%i", ntohs(th->th_dport));
3372 #endif /* INET */
3373 	} else {
3374 		free(s, M_TCPLOG);
3375 		return (NULL);
3376 	}
3377 	sp = s + strlen(s);
3378 	if (th)
3379 		sprintf(sp, " tcpflags 0x%b", th->th_flags, PRINT_TH_FLAGS);
3380 	if (*(s + size - 1) != '\0')
3381 		panic("%s: string too long", __func__);
3382 	return (s);
3383 }
3384 
3385 /*
3386  * A subroutine which makes it easy to track TCP state changes with DTrace.
3387  * This function shouldn't be called for t_state initializations that don't
3388  * correspond to actual TCP state transitions.
3389  */
3390 void
3391 tcp_state_change(struct tcpcb *tp, int newstate)
3392 {
3393 #if defined(KDTRACE_HOOKS)
3394 	int pstate = tp->t_state;
3395 #endif
3396 
3397 	TCPSTATES_DEC(tp->t_state);
3398 	TCPSTATES_INC(newstate);
3399 	tp->t_state = newstate;
3400 	TCP_PROBE6(state__change, NULL, tp, NULL, tp, NULL, pstate);
3401 }
3402 
3403 /*
3404  * Create an external-format (``xtcpcb'') structure using the information in
3405  * the kernel-format tcpcb structure pointed to by tp.  This is done to
3406  * reduce the spew of irrelevant information over this interface, to isolate
3407  * user code from changes in the kernel structure, and potentially to provide
3408  * information-hiding if we decide that some of this information should be
3409  * hidden from users.
3410  */
3411 void
3412 tcp_inptoxtp(const struct inpcb *inp, struct xtcpcb *xt)
3413 {
3414 	struct tcpcb *tp = intotcpcb(inp);
3415 	sbintime_t now;
3416 
3417 	bzero(xt, sizeof(*xt));
3418 	if (inp->inp_flags & INP_TIMEWAIT) {
3419 		xt->t_state = TCPS_TIME_WAIT;
3420 	} else {
3421 		xt->t_state = tp->t_state;
3422 		xt->t_logstate = tp->t_logstate;
3423 		xt->t_flags = tp->t_flags;
3424 		xt->t_sndzerowin = tp->t_sndzerowin;
3425 		xt->t_sndrexmitpack = tp->t_sndrexmitpack;
3426 		xt->t_rcvoopack = tp->t_rcvoopack;
3427 
3428 		now = getsbinuptime();
3429 #define	COPYTIMER(ttt)	do {						\
3430 		if (callout_active(&tp->t_timers->ttt))			\
3431 			xt->ttt = (tp->t_timers->ttt.c_time - now) /	\
3432 			    SBT_1MS;					\
3433 		else							\
3434 			xt->ttt = 0;					\
3435 } while (0)
3436 		COPYTIMER(tt_delack);
3437 		COPYTIMER(tt_rexmt);
3438 		COPYTIMER(tt_persist);
3439 		COPYTIMER(tt_keep);
3440 		COPYTIMER(tt_2msl);
3441 #undef COPYTIMER
3442 		xt->t_rcvtime = 1000 * (ticks - tp->t_rcvtime) / hz;
3443 
3444 		bcopy(tp->t_fb->tfb_tcp_block_name, xt->xt_stack,
3445 		    TCP_FUNCTION_NAME_LEN_MAX);
3446 #ifdef TCP_BLACKBOX
3447 		(void)tcp_log_get_id(tp, xt->xt_logid);
3448 #endif
3449 	}
3450 
3451 	xt->xt_len = sizeof(struct xtcpcb);
3452 	in_pcbtoxinpcb(inp, &xt->xt_inp);
3453 	if (inp->inp_socket == NULL)
3454 		xt->xt_inp.xi_socket.xso_protocol = IPPROTO_TCP;
3455 }
3456