Home | History | Annotate | Line # | Download | only in netinet
tcp_usrreq.c revision 1.216.2.2
      1 /*	$NetBSD: tcp_usrreq.c,v 1.216.2.2 2018/04/16 02:00:09 pgoyette Exp $	*/
      2 
      3 /*
      4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      5  * 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 project 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 PROJECT 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 PROJECT 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 
     32 /*-
     33  * Copyright (c) 1997, 1998, 2005, 2006 The NetBSD Foundation, Inc.
     34  * All rights reserved.
     35  *
     36  * This code is derived from software contributed to The NetBSD Foundation
     37  * by Jason R. Thorpe and Kevin M. Lahey of the Numerical Aerospace Simulation
     38  * Facility, NASA Ames Research Center.
     39  * This code is derived from software contributed to The NetBSD Foundation
     40  * by Charles M. Hannum.
     41  * This code is derived from software contributed to The NetBSD Foundation
     42  * by Rui Paulo.
     43  *
     44  * Redistribution and use in source and binary forms, with or without
     45  * modification, are permitted provided that the following conditions
     46  * are met:
     47  * 1. Redistributions of source code must retain the above copyright
     48  *    notice, this list of conditions and the following disclaimer.
     49  * 2. Redistributions in binary form must reproduce the above copyright
     50  *    notice, this list of conditions and the following disclaimer in the
     51  *    documentation and/or other materials provided with the distribution.
     52  *
     53  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     54  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     55  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     56  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     57  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     58  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     59  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     60  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     61  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     62  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     63  * POSSIBILITY OF SUCH DAMAGE.
     64  */
     65 
     66 /*
     67  * Copyright (c) 1982, 1986, 1988, 1993, 1995
     68  *	The Regents of the University of California.  All rights reserved.
     69  *
     70  * Redistribution and use in source and binary forms, with or without
     71  * modification, are permitted provided that the following conditions
     72  * are met:
     73  * 1. Redistributions of source code must retain the above copyright
     74  *    notice, this list of conditions and the following disclaimer.
     75  * 2. Redistributions in binary form must reproduce the above copyright
     76  *    notice, this list of conditions and the following disclaimer in the
     77  *    documentation and/or other materials provided with the distribution.
     78  * 3. Neither the name of the University nor the names of its contributors
     79  *    may be used to endorse or promote products derived from this software
     80  *    without specific prior written permission.
     81  *
     82  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     83  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     84  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     85  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     86  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     87  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     88  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     89  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     90  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     91  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     92  * SUCH DAMAGE.
     93  *
     94  *	@(#)tcp_usrreq.c	8.5 (Berkeley) 6/21/95
     95  */
     96 
     97 /*
     98  * TCP protocol interface to socket abstraction.
     99  */
    100 
    101 #include <sys/cdefs.h>
    102 __KERNEL_RCSID(0, "$NetBSD: tcp_usrreq.c,v 1.216.2.2 2018/04/16 02:00:09 pgoyette Exp $");
    103 
    104 #ifdef _KERNEL_OPT
    105 #include "opt_inet.h"
    106 #include "opt_tcp_debug.h"
    107 #include "opt_mbuftrace.h"
    108 #include "opt_tcp_space.h"
    109 #include "opt_net_mpsafe.h"
    110 #endif
    111 
    112 #include <sys/param.h>
    113 #include <sys/systm.h>
    114 #include <sys/kernel.h>
    115 #include <sys/mbuf.h>
    116 #include <sys/socket.h>
    117 #include <sys/socketvar.h>
    118 #include <sys/protosw.h>
    119 #include <sys/errno.h>
    120 #include <sys/stat.h>
    121 #include <sys/proc.h>
    122 #include <sys/domain.h>
    123 #include <sys/sysctl.h>
    124 #include <sys/kauth.h>
    125 #include <sys/kernel.h>
    126 #include <sys/uidinfo.h>
    127 
    128 #include <net/if.h>
    129 
    130 #include <netinet/in.h>
    131 #include <netinet/in_systm.h>
    132 #include <netinet/in_var.h>
    133 #include <netinet/ip.h>
    134 #include <netinet/in_pcb.h>
    135 #include <netinet/ip_var.h>
    136 #include <netinet/in_offload.h>
    137 
    138 #ifdef INET6
    139 #include <netinet/ip6.h>
    140 #include <netinet6/in6_pcb.h>
    141 #include <netinet6/ip6_var.h>
    142 #include <netinet6/scope6_var.h>
    143 #endif
    144 
    145 #include <netinet/tcp.h>
    146 #include <netinet/tcp_fsm.h>
    147 #include <netinet/tcp_seq.h>
    148 #include <netinet/tcp_timer.h>
    149 #include <netinet/tcp_var.h>
    150 #include <netinet/tcp_private.h>
    151 #include <netinet/tcp_congctl.h>
    152 #include <netinet/tcpip.h>
    153 #include <netinet/tcp_debug.h>
    154 #include <netinet/tcp_vtw.h>
    155 
    156 static int
    157 tcp_debug_capture(struct tcpcb *tp, int req)
    158 {
    159 #ifdef TCP_DEBUG
    160 	return tp->t_state;
    161 #endif
    162 	return 0;
    163 }
    164 
    165 static inline void
    166 tcp_debug_trace(struct socket *so, struct tcpcb *tp, int ostate, int req)
    167 {
    168 #ifdef TCP_DEBUG
    169 	if (tp && (so->so_options & SO_DEBUG))
    170 		tcp_trace(TA_USER, ostate, tp, NULL, req);
    171 #endif
    172 }
    173 
    174 static int
    175 tcp_getpcb(struct socket *so, struct inpcb **inp,
    176     struct in6pcb **in6p, struct tcpcb **tp)
    177 {
    178 
    179 	KASSERT(solocked(so));
    180 
    181 	/*
    182 	 * When a TCP is attached to a socket, then there will be
    183 	 * a (struct inpcb) pointed at by the socket, and this
    184 	 * structure will point at a subsidary (struct tcpcb).
    185 	 */
    186 	switch (so->so_proto->pr_domain->dom_family) {
    187 	case PF_INET:
    188 		*inp = sotoinpcb(so);
    189 		if (*inp == NULL)
    190 			return EINVAL;
    191 		*tp = intotcpcb(*inp);
    192 		break;
    193 #ifdef INET6
    194 	case PF_INET6:
    195 		*in6p = sotoin6pcb(so);
    196 		if (*in6p == NULL)
    197 			return EINVAL;
    198 		*tp = in6totcpcb(*in6p);
    199 		break;
    200 #endif
    201 	default:
    202 		return EAFNOSUPPORT;
    203 	}
    204 
    205 	KASSERT(tp != NULL);
    206 
    207 	return 0;
    208 }
    209 
    210 static void
    211 change_keepalive(struct socket *so, struct tcpcb *tp)
    212 {
    213 	tp->t_maxidle = tp->t_keepcnt * tp->t_keepintvl;
    214 	TCP_TIMER_DISARM(tp, TCPT_KEEP);
    215 	TCP_TIMER_DISARM(tp, TCPT_2MSL);
    216 
    217 	if (tp->t_state == TCPS_SYN_RECEIVED ||
    218 	    tp->t_state == TCPS_SYN_SENT) {
    219 		TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepinit);
    220 	} else if (so->so_options & SO_KEEPALIVE &&
    221 	    tp->t_state <= TCPS_CLOSE_WAIT) {
    222 		TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepintvl);
    223 	} else {
    224 		TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepidle);
    225 	}
    226 
    227 	if ((tp->t_state == TCPS_FIN_WAIT_2) && (tp->t_maxidle > 0))
    228 		TCP_TIMER_ARM(tp, TCPT_2MSL, tp->t_maxidle);
    229 }
    230 
    231 /*
    232  * Export TCP internal state information via a struct tcp_info, based on the
    233  * Linux 2.6 API.  Not ABI compatible as our constants are mapped differently
    234  * (TCP state machine, etc).  We export all information using FreeBSD-native
    235  * constants -- for example, the numeric values for tcpi_state will differ
    236  * from Linux.
    237  */
    238 static void
    239 tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
    240 {
    241 
    242 	bzero(ti, sizeof(*ti));
    243 
    244 	ti->tcpi_state = tp->t_state;
    245 	if ((tp->t_flags & TF_REQ_TSTMP) && (tp->t_flags & TF_RCVD_TSTMP))
    246 		ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;
    247 	if (tp->t_flags & TF_SACK_PERMIT)
    248 		ti->tcpi_options |= TCPI_OPT_SACK;
    249 	if ((tp->t_flags & TF_REQ_SCALE) && (tp->t_flags & TF_RCVD_SCALE)) {
    250 		ti->tcpi_options |= TCPI_OPT_WSCALE;
    251 		ti->tcpi_snd_wscale = tp->snd_scale;
    252 		ti->tcpi_rcv_wscale = tp->rcv_scale;
    253 	}
    254 	if (tp->t_flags & TF_ECN_PERMIT) {
    255 		ti->tcpi_options |= TCPI_OPT_ECN;
    256 	}
    257 
    258 	ti->tcpi_rto = tp->t_rxtcur * tick;
    259 	ti->tcpi_last_data_recv = (long)(hardclock_ticks -
    260 					 (int)tp->t_rcvtime) * tick;
    261 	ti->tcpi_rtt = ((u_int64_t)tp->t_srtt * tick) >> TCP_RTT_SHIFT;
    262 	ti->tcpi_rttvar = ((u_int64_t)tp->t_rttvar * tick) >> TCP_RTTVAR_SHIFT;
    263 
    264 	ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
    265 	/* Linux API wants these in # of segments, apparently */
    266 	ti->tcpi_snd_cwnd = tp->snd_cwnd / tp->t_segsz;
    267 	ti->tcpi_snd_wnd = tp->snd_wnd / tp->t_segsz;
    268 
    269 	/*
    270 	 * FreeBSD-specific extension fields for tcp_info.
    271 	 */
    272 	ti->tcpi_rcv_space = tp->rcv_wnd;
    273 	ti->tcpi_rcv_nxt = tp->rcv_nxt;
    274 	ti->tcpi_snd_bwnd = 0;		/* Unused, kept for compat. */
    275 	ti->tcpi_snd_nxt = tp->snd_nxt;
    276 	ti->tcpi_snd_mss = tp->t_segsz;
    277 	ti->tcpi_rcv_mss = tp->t_segsz;
    278 #ifdef TF_TOE
    279 	if (tp->t_flags & TF_TOE)
    280 		ti->tcpi_options |= TCPI_OPT_TOE;
    281 #endif
    282 	/* From the redundant department of redundancies... */
    283 	ti->__tcpi_retransmits = ti->__tcpi_retrans =
    284 		ti->tcpi_snd_rexmitpack = tp->t_sndrexmitpack;
    285 
    286 	ti->tcpi_rcv_ooopack = tp->t_rcvoopack;
    287 	ti->tcpi_snd_zerowin = tp->t_sndzerowin;
    288 }
    289 
    290 int
    291 tcp_ctloutput(int op, struct socket *so, struct sockopt *sopt)
    292 {
    293 	int error = 0, s;
    294 	struct inpcb *inp;
    295 #ifdef INET6
    296 	struct in6pcb *in6p;
    297 #endif
    298 	struct tcpcb *tp;
    299 	struct tcp_info ti;
    300 	u_int ui;
    301 	int family;	/* family of the socket */
    302 	int level, optname, optval;
    303 
    304 	level = sopt->sopt_level;
    305 	optname = sopt->sopt_name;
    306 
    307 	family = so->so_proto->pr_domain->dom_family;
    308 
    309 	s = splsoftnet();
    310 	switch (family) {
    311 	case PF_INET:
    312 		inp = sotoinpcb(so);
    313 #ifdef INET6
    314 		in6p = NULL;
    315 #endif
    316 		break;
    317 #ifdef INET6
    318 	case PF_INET6:
    319 		inp = NULL;
    320 		in6p = sotoin6pcb(so);
    321 		break;
    322 #endif
    323 	default:
    324 		splx(s);
    325 		panic("%s: af %d", __func__, family);
    326 	}
    327 #ifndef INET6
    328 	if (inp == NULL)
    329 #else
    330 	if (inp == NULL && in6p == NULL)
    331 #endif
    332 	{
    333 		splx(s);
    334 		return (ECONNRESET);
    335 	}
    336 	if (level != IPPROTO_TCP) {
    337 		switch (family) {
    338 		case PF_INET:
    339 			error = ip_ctloutput(op, so, sopt);
    340 			break;
    341 #ifdef INET6
    342 		case PF_INET6:
    343 			error = ip6_ctloutput(op, so, sopt);
    344 			break;
    345 #endif
    346 		}
    347 		splx(s);
    348 		return (error);
    349 	}
    350 	if (inp)
    351 		tp = intotcpcb(inp);
    352 #ifdef INET6
    353 	else if (in6p)
    354 		tp = in6totcpcb(in6p);
    355 #endif
    356 	else
    357 		tp = NULL;
    358 
    359 	switch (op) {
    360 	case PRCO_SETOPT:
    361 		switch (optname) {
    362 #ifdef TCP_SIGNATURE
    363 		case TCP_MD5SIG:
    364 			error = sockopt_getint(sopt, &optval);
    365 			if (error)
    366 				break;
    367 			if (optval > 0)
    368 				tp->t_flags |= TF_SIGNATURE;
    369 			else
    370 				tp->t_flags &= ~TF_SIGNATURE;
    371 			break;
    372 #endif /* TCP_SIGNATURE */
    373 
    374 		case TCP_NODELAY:
    375 			error = sockopt_getint(sopt, &optval);
    376 			if (error)
    377 				break;
    378 			if (optval)
    379 				tp->t_flags |= TF_NODELAY;
    380 			else
    381 				tp->t_flags &= ~TF_NODELAY;
    382 			break;
    383 
    384 		case TCP_MAXSEG:
    385 			error = sockopt_getint(sopt, &optval);
    386 			if (error)
    387 				break;
    388 			if (optval > 0 && optval <= tp->t_peermss)
    389 				tp->t_peermss = optval; /* limit on send size */
    390 			else
    391 				error = EINVAL;
    392 			break;
    393 #ifdef notyet
    394 		case TCP_CONGCTL:
    395 			/* XXX string overflow XXX */
    396 			error = tcp_congctl_select(tp, sopt->sopt_data);
    397 			break;
    398 #endif
    399 
    400 		case TCP_KEEPIDLE:
    401 			error = sockopt_get(sopt, &ui, sizeof(ui));
    402 			if (error)
    403 				break;
    404 			if (ui > 0) {
    405 				tp->t_keepidle = ui;
    406 				change_keepalive(so, tp);
    407 			} else
    408 				error = EINVAL;
    409 			break;
    410 
    411 		case TCP_KEEPINTVL:
    412 			error = sockopt_get(sopt, &ui, sizeof(ui));
    413 			if (error)
    414 				break;
    415 			if (ui > 0) {
    416 				tp->t_keepintvl = ui;
    417 				change_keepalive(so, tp);
    418 			} else
    419 				error = EINVAL;
    420 			break;
    421 
    422 		case TCP_KEEPCNT:
    423 			error = sockopt_get(sopt, &ui, sizeof(ui));
    424 			if (error)
    425 				break;
    426 			if (ui > 0) {
    427 				tp->t_keepcnt = ui;
    428 				change_keepalive(so, tp);
    429 			} else
    430 				error = EINVAL;
    431 			break;
    432 
    433 		case TCP_KEEPINIT:
    434 			error = sockopt_get(sopt, &ui, sizeof(ui));
    435 			if (error)
    436 				break;
    437 			if (ui > 0) {
    438 				tp->t_keepinit = ui;
    439 				change_keepalive(so, tp);
    440 			} else
    441 				error = EINVAL;
    442 			break;
    443 
    444 		default:
    445 			error = ENOPROTOOPT;
    446 			break;
    447 		}
    448 		break;
    449 
    450 	case PRCO_GETOPT:
    451 		switch (optname) {
    452 #ifdef TCP_SIGNATURE
    453 		case TCP_MD5SIG:
    454 			optval = (tp->t_flags & TF_SIGNATURE) ? 1 : 0;
    455 			goto setval;
    456 #endif
    457 		case TCP_NODELAY:
    458 			optval = tp->t_flags & TF_NODELAY;
    459 			goto setval;
    460 		case TCP_MAXSEG:
    461 			optval = tp->t_peermss;
    462 			goto setval;
    463 		case TCP_INFO:
    464 			tcp_fill_info(tp, &ti);
    465 			error = sockopt_set(sopt, &ti, sizeof ti);
    466 			break;
    467 #ifdef notyet
    468 		case TCP_CONGCTL:
    469 			break;
    470 #endif
    471 		case TCP_KEEPIDLE:
    472 			optval = tp->t_keepidle;
    473 			goto setval;
    474 		case TCP_KEEPINTVL:
    475 			optval = tp->t_keepintvl;
    476 			goto setval;
    477 		case TCP_KEEPCNT:
    478 			optval = tp->t_keepcnt;
    479 			goto setval;
    480 		case TCP_KEEPINIT:
    481 			optval = tp->t_keepcnt;
    482 setval:			error = sockopt_set(sopt, &optval, sizeof(optval));
    483 			break;
    484 		default:
    485 			error = ENOPROTOOPT;
    486 			break;
    487 		}
    488 		break;
    489 	}
    490 	splx(s);
    491 	return (error);
    492 }
    493 
    494 #ifndef TCP_SENDSPACE
    495 #define	TCP_SENDSPACE	1024*32
    496 #endif
    497 int	tcp_sendspace = TCP_SENDSPACE;
    498 #ifndef TCP_RECVSPACE
    499 #define	TCP_RECVSPACE	1024*32
    500 #endif
    501 int	tcp_recvspace = TCP_RECVSPACE;
    502 
    503 /*
    504  * tcp_attach: attach TCP protocol to socket, allocating internet protocol
    505  * control block, TCP control block, buffer space and entering LISTEN state
    506  * if to accept connections.
    507  */
    508 static int
    509 tcp_attach(struct socket *so, int proto)
    510 {
    511 	struct tcpcb *tp;
    512 	struct inpcb *inp;
    513 #ifdef INET6
    514 	struct in6pcb *in6p;
    515 #endif
    516 	int s, error, family;
    517 
    518 	/* Assign the lock (must happen even if we will error out). */
    519 	s = splsoftnet();
    520 	sosetlock(so);
    521 	KASSERT(solocked(so));
    522 
    523 	family = so->so_proto->pr_domain->dom_family;
    524 	switch (family) {
    525 	case PF_INET:
    526 		inp = sotoinpcb(so);
    527 #ifdef INET6
    528 		in6p = NULL;
    529 #endif
    530 		break;
    531 #ifdef INET6
    532 	case PF_INET6:
    533 		inp = NULL;
    534 		in6p = sotoin6pcb(so);
    535 		break;
    536 #endif
    537 	default:
    538 		error = EAFNOSUPPORT;
    539 		goto out;
    540 	}
    541 
    542 	KASSERT(inp == NULL);
    543 #ifdef INET6
    544 	KASSERT(in6p == NULL);
    545 #endif
    546 
    547 #ifdef MBUFTRACE
    548 	so->so_mowner = &tcp_sock_mowner;
    549 	so->so_rcv.sb_mowner = &tcp_sock_rx_mowner;
    550 	so->so_snd.sb_mowner = &tcp_sock_tx_mowner;
    551 #endif
    552 	if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
    553 		error = soreserve(so, tcp_sendspace, tcp_recvspace);
    554 		if (error)
    555 			goto out;
    556 	}
    557 
    558 	so->so_rcv.sb_flags |= SB_AUTOSIZE;
    559 	so->so_snd.sb_flags |= SB_AUTOSIZE;
    560 
    561 	switch (family) {
    562 	case PF_INET:
    563 		error = in_pcballoc(so, &tcbtable);
    564 		if (error)
    565 			goto out;
    566 		inp = sotoinpcb(so);
    567 #ifdef INET6
    568 		in6p = NULL;
    569 #endif
    570 		break;
    571 #ifdef INET6
    572 	case PF_INET6:
    573 		error = in6_pcballoc(so, &tcbtable);
    574 		if (error)
    575 			goto out;
    576 		inp = NULL;
    577 		in6p = sotoin6pcb(so);
    578 		break;
    579 #endif
    580 	default:
    581 		error = EAFNOSUPPORT;
    582 		goto out;
    583 	}
    584 	if (inp)
    585 		tp = tcp_newtcpcb(family, (void *)inp);
    586 #ifdef INET6
    587 	else if (in6p)
    588 		tp = tcp_newtcpcb(family, (void *)in6p);
    589 #endif
    590 	else
    591 		tp = NULL;
    592 
    593 	if (tp == NULL) {
    594 		int nofd = so->so_state & SS_NOFDREF;	/* XXX */
    595 
    596 		so->so_state &= ~SS_NOFDREF;	/* don't free the socket yet */
    597 		if (inp)
    598 			in_pcbdetach(inp);
    599 #ifdef INET6
    600 		if (in6p)
    601 			in6_pcbdetach(in6p);
    602 #endif
    603 		so->so_state |= nofd;
    604 		error = ENOBUFS;
    605 		goto out;
    606 	}
    607 	tp->t_state = TCPS_CLOSED;
    608 	if ((so->so_options & SO_LINGER) && so->so_linger == 0) {
    609 		so->so_linger = TCP_LINGERTIME;
    610 	}
    611 out:
    612 	KASSERT(solocked(so));
    613 	splx(s);
    614 	return error;
    615 }
    616 
    617 static void
    618 tcp_detach(struct socket *so)
    619 {
    620 	struct inpcb *inp = NULL;
    621 	struct in6pcb *in6p = NULL;
    622 	struct tcpcb *tp = NULL;
    623 	int s;
    624 
    625 	if (tcp_getpcb(so, &inp, &in6p, &tp) != 0)
    626 		return;
    627 
    628 	s = splsoftnet();
    629 	(void)tcp_disconnect1(tp);
    630 	splx(s);
    631 }
    632 
    633 static int
    634 tcp_accept(struct socket *so, struct sockaddr *nam)
    635 {
    636 	struct inpcb *inp = NULL;
    637 	struct in6pcb *in6p = NULL;
    638 	struct tcpcb *tp = NULL;
    639 	int ostate = 0;
    640 	int error = 0;
    641 	int s;
    642 
    643 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    644 		return error;
    645 
    646 	ostate = tcp_debug_capture(tp, PRU_ACCEPT);
    647 
    648 	/*
    649 	 * Accept a connection.  Essentially all the work is
    650 	 * done at higher levels; just return the address
    651 	 * of the peer, storing through addr.
    652 	 */
    653 	s = splsoftnet();
    654 	if (inp) {
    655 		in_setpeeraddr(inp, (struct sockaddr_in *)nam);
    656 	}
    657 #ifdef INET6
    658 	if (in6p) {
    659 		in6_setpeeraddr(in6p, (struct sockaddr_in6 *)nam);
    660 	}
    661 #endif
    662 	tcp_debug_trace(so, tp, ostate, PRU_ACCEPT);
    663 	splx(s);
    664 
    665 	return 0;
    666 }
    667 
    668 static int
    669 tcp_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
    670 {
    671 	struct inpcb *inp = NULL;
    672 	struct in6pcb *in6p = NULL;
    673 	struct sockaddr_in *sin = (struct sockaddr_in *)nam;
    674 #ifdef INET6
    675 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
    676 #endif /* INET6 */
    677 	struct tcpcb *tp = NULL;
    678 	int s;
    679 	int error = 0;
    680 	int ostate = 0;
    681 
    682 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    683 		return error;
    684 
    685 	ostate = tcp_debug_capture(tp, PRU_BIND);
    686 
    687 	/*
    688 	 * Give the socket an address.
    689 	 */
    690 	s = splsoftnet();
    691 	switch (so->so_proto->pr_domain->dom_family) {
    692 	case PF_INET:
    693 		error = in_pcbbind(inp, sin, l);
    694 		break;
    695 #ifdef INET6
    696 	case PF_INET6:
    697 		error = in6_pcbbind(in6p, sin6, l);
    698 		if (!error) {
    699 			/* mapped addr case */
    700 			if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr))
    701 				tp->t_family = AF_INET;
    702 			else
    703 				tp->t_family = AF_INET6;
    704 		}
    705 		break;
    706 #endif
    707 	}
    708 	tcp_debug_trace(so, tp, ostate, PRU_BIND);
    709 	splx(s);
    710 
    711 	return error;
    712 }
    713 
    714 static int
    715 tcp_listen(struct socket *so, struct lwp *l)
    716 {
    717 	struct inpcb *inp = NULL;
    718 	struct in6pcb *in6p = NULL;
    719 	struct tcpcb *tp = NULL;
    720 	int error = 0;
    721 	int ostate = 0;
    722 	int s;
    723 
    724 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    725 		return error;
    726 
    727 	ostate = tcp_debug_capture(tp, PRU_LISTEN);
    728 
    729 	/*
    730 	 * Prepare to accept connections.
    731 	 */
    732 	s = splsoftnet();
    733 	if (inp && inp->inp_lport == 0) {
    734 		error = in_pcbbind(inp, NULL, l);
    735 		if (error)
    736 			goto release;
    737 	}
    738 #ifdef INET6
    739 	if (in6p && in6p->in6p_lport == 0) {
    740 		error = in6_pcbbind(in6p, NULL, l);
    741 		if (error)
    742 			goto release;
    743 	}
    744 #endif
    745 	tp->t_state = TCPS_LISTEN;
    746 
    747 release:
    748 	tcp_debug_trace(so, tp, ostate, PRU_LISTEN);
    749 	splx(s);
    750 
    751 	return error;
    752 }
    753 
    754 static int
    755 tcp_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
    756 {
    757 	struct inpcb *inp = NULL;
    758 	struct in6pcb *in6p = NULL;
    759 	struct tcpcb *tp = NULL;
    760 	int s;
    761 	int error = 0;
    762 	int ostate = 0;
    763 
    764 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    765 		return error;
    766 
    767 	ostate = tcp_debug_capture(tp, PRU_CONNECT);
    768 
    769 	/*
    770 	 * Initiate connection to peer.
    771 	 * Create a template for use in transmissions on this connection.
    772 	 * Enter SYN_SENT state, and mark socket as connecting.
    773 	 * Start keep-alive timer, and seed output sequence space.
    774 	 * Send initial segment on connection.
    775 	 */
    776 	s = splsoftnet();
    777 
    778 	if (inp) {
    779 		if (inp->inp_lport == 0) {
    780 			error = in_pcbbind(inp, NULL, l);
    781 			if (error)
    782 				goto release;
    783 		}
    784 		error = in_pcbconnect(inp, (struct sockaddr_in *)nam, l);
    785 	}
    786 #ifdef INET6
    787 	if (in6p) {
    788 		if (in6p->in6p_lport == 0) {
    789 			error = in6_pcbbind(in6p, NULL, l);
    790 			if (error)
    791 				goto release;
    792 		}
    793 		error = in6_pcbconnect(in6p, (struct sockaddr_in6 *)nam, l);
    794 		if (!error) {
    795 			/* mapped addr case */
    796 			if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr))
    797 				tp->t_family = AF_INET;
    798 			else
    799 				tp->t_family = AF_INET6;
    800 		}
    801 	}
    802 #endif
    803 	if (error)
    804 		goto release;
    805 	tp->t_template = tcp_template(tp);
    806 	if (tp->t_template == 0) {
    807 		if (inp)
    808 			in_pcbdisconnect(inp);
    809 #ifdef INET6
    810 		if (in6p)
    811 			in6_pcbdisconnect(in6p);
    812 #endif
    813 		error = ENOBUFS;
    814 		goto release;
    815 	}
    816 	/*
    817 	 * Compute window scaling to request.
    818 	 * XXX: This should be moved to tcp_output().
    819 	 */
    820 	while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
    821 	    (TCP_MAXWIN << tp->request_r_scale) < sb_max)
    822 		tp->request_r_scale++;
    823 	soisconnecting(so);
    824 	TCP_STATINC(TCP_STAT_CONNATTEMPT);
    825 	tp->t_state = TCPS_SYN_SENT;
    826 	TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepinit);
    827 	tp->iss = tcp_new_iss(tp, 0);
    828 	tcp_sendseqinit(tp);
    829 	error = tcp_output(tp);
    830 
    831 release:
    832 	tcp_debug_trace(so, tp, ostate, PRU_CONNECT);
    833 	splx(s);
    834 
    835 	return error;
    836 }
    837 
    838 static int
    839 tcp_connect2(struct socket *so, struct socket *so2)
    840 {
    841 	struct inpcb *inp = NULL;
    842 	struct in6pcb *in6p = NULL;
    843 	struct tcpcb *tp = NULL;
    844 	int error = 0;
    845 	int ostate = 0;
    846 
    847 	KASSERT(solocked(so));
    848 
    849 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    850 		return error;
    851 
    852 	ostate = tcp_debug_capture(tp, PRU_CONNECT2);
    853 
    854 	tcp_debug_trace(so, tp, ostate, PRU_CONNECT2);
    855 
    856 	return EOPNOTSUPP;
    857 }
    858 
    859 static int
    860 tcp_disconnect(struct socket *so)
    861 {
    862 	struct inpcb *inp = NULL;
    863 	struct in6pcb *in6p = NULL;
    864 	struct tcpcb *tp = NULL;
    865 	int error = 0;
    866 	int ostate = 0;
    867 	int s;
    868 
    869 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    870 		return error;
    871 
    872 	ostate = tcp_debug_capture(tp, PRU_DISCONNECT);
    873 
    874 	/*
    875 	 * Initiate disconnect from peer.
    876 	 * If connection never passed embryonic stage, just drop;
    877 	 * else if don't need to let data drain, then can just drop anyways,
    878 	 * else have to begin TCP shutdown process: mark socket disconnecting,
    879 	 * drain unread data, state switch to reflect user close, and
    880 	 * send segment (e.g. FIN) to peer.  Socket will be really disconnected
    881 	 * when peer sends FIN and acks ours.
    882 	 *
    883 	 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
    884 	 */
    885 	s = splsoftnet();
    886 	tp = tcp_disconnect1(tp);
    887 	tcp_debug_trace(so, tp, ostate, PRU_DISCONNECT);
    888 	splx(s);
    889 
    890 	return error;
    891 }
    892 
    893 static int
    894 tcp_shutdown(struct socket *so)
    895 {
    896 	struct inpcb *inp = NULL;
    897 	struct in6pcb *in6p = NULL;
    898 	struct tcpcb *tp = NULL;
    899 	int error = 0;
    900 	int ostate = 0;
    901 	int s;
    902 
    903 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    904 		return error;
    905 
    906 	ostate = tcp_debug_capture(tp, PRU_SHUTDOWN);
    907 	/*
    908 	 * Mark the connection as being incapable of further output.
    909 	 */
    910 	s = splsoftnet();
    911 	socantsendmore(so);
    912 	tp = tcp_usrclosed(tp);
    913 	if (tp)
    914 		error = tcp_output(tp);
    915 	tcp_debug_trace(so, tp, ostate, PRU_SHUTDOWN);
    916 	splx(s);
    917 
    918 	return error;
    919 }
    920 
    921 static int
    922 tcp_abort(struct socket *so)
    923 {
    924 	struct inpcb *inp = NULL;
    925 	struct in6pcb *in6p = NULL;
    926 	struct tcpcb *tp = NULL;
    927 	int error = 0;
    928 	int ostate = 0;
    929 	int s;
    930 
    931 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    932 		return error;
    933 
    934 	ostate = tcp_debug_capture(tp, PRU_ABORT);
    935 
    936 	/*
    937 	 * Abort the TCP.
    938 	 */
    939 	s = splsoftnet();
    940 	tp = tcp_drop(tp, ECONNABORTED);
    941 	tcp_debug_trace(so, tp, ostate, PRU_ABORT);
    942 	splx(s);
    943 
    944 	return error;
    945 }
    946 
    947 static int
    948 tcp_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
    949 {
    950 	switch (so->so_proto->pr_domain->dom_family) {
    951 	case PF_INET:
    952 		return in_control(so, cmd, nam, ifp);
    953 #ifdef INET6
    954 	case PF_INET6:
    955 		return in6_control(so, cmd, nam, ifp);
    956 #endif
    957 	default:
    958 		return EAFNOSUPPORT;
    959 	}
    960 }
    961 
    962 static int
    963 tcp_stat(struct socket *so, struct stat *ub)
    964 {
    965 	KASSERT(solocked(so));
    966 
    967 	/* stat: don't bother with a blocksize.  */
    968 	return 0;
    969 }
    970 
    971 static int
    972 tcp_peeraddr(struct socket *so, struct sockaddr *nam)
    973 {
    974 	struct inpcb *inp = NULL;
    975 	struct in6pcb *in6p = NULL;
    976 	struct tcpcb *tp = NULL;
    977 	int ostate = 0;
    978 	int error = 0;
    979 	int s;
    980 
    981 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
    982 		return error;
    983 
    984 	ostate = tcp_debug_capture(tp, PRU_PEERADDR);
    985 
    986 	s = splsoftnet();
    987 	if (inp) {
    988 		in_setpeeraddr(inp, (struct sockaddr_in *)nam);
    989 	}
    990 #ifdef INET6
    991 	if (in6p) {
    992 		in6_setpeeraddr(in6p, (struct sockaddr_in6 *)nam);
    993 	}
    994 #endif
    995 	tcp_debug_trace(so, tp, ostate, PRU_PEERADDR);
    996 	splx(s);
    997 
    998 	return 0;
    999 }
   1000 
   1001 static int
   1002 tcp_sockaddr(struct socket *so, struct sockaddr *nam)
   1003 {
   1004 	struct inpcb *inp = NULL;
   1005 	struct in6pcb *in6p = NULL;
   1006 	struct tcpcb *tp = NULL;
   1007 	int ostate = 0;
   1008 	int error = 0;
   1009 	int s;
   1010 
   1011 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
   1012 		return error;
   1013 
   1014 	ostate = tcp_debug_capture(tp, PRU_SOCKADDR);
   1015 
   1016 	s = splsoftnet();
   1017 	if (inp) {
   1018 		in_setsockaddr(inp, (struct sockaddr_in *)nam);
   1019 	}
   1020 #ifdef INET6
   1021 	if (in6p) {
   1022 		in6_setsockaddr(in6p, (struct sockaddr_in6 *)nam);
   1023 	}
   1024 #endif
   1025 	tcp_debug_trace(so, tp, ostate, PRU_SOCKADDR);
   1026 	splx(s);
   1027 
   1028 	return 0;
   1029 }
   1030 
   1031 static int
   1032 tcp_rcvd(struct socket *so, int flags, struct lwp *l)
   1033 {
   1034 	struct inpcb *inp = NULL;
   1035 	struct in6pcb *in6p = NULL;
   1036 	struct tcpcb *tp = NULL;
   1037 	int ostate = 0;
   1038 	int error = 0;
   1039 	int s;
   1040 
   1041 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
   1042 		return error;
   1043 
   1044 	ostate = tcp_debug_capture(tp, PRU_RCVD);
   1045 
   1046 	/*
   1047 	 * After a receive, possibly send window update to peer.
   1048 	 *
   1049 	 * soreceive() calls this function when a user receives
   1050 	 * ancillary data on a listening socket. We don't call
   1051 	 * tcp_output in such a case, since there is no header
   1052 	 * template for a listening socket and hence the kernel
   1053 	 * will panic.
   1054 	 */
   1055 	s = splsoftnet();
   1056 	if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) != 0)
   1057 		(void) tcp_output(tp);
   1058 	splx(s);
   1059 
   1060 	tcp_debug_trace(so, tp, ostate, PRU_RCVD);
   1061 
   1062 	return 0;
   1063 }
   1064 
   1065 static int
   1066 tcp_recvoob(struct socket *so, struct mbuf *m, int flags)
   1067 {
   1068 	struct inpcb *inp = NULL;
   1069 	struct in6pcb *in6p = NULL;
   1070 	struct tcpcb *tp = NULL;
   1071 	int ostate = 0;
   1072 	int error = 0;
   1073 	int s;
   1074 
   1075 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
   1076 		return error;
   1077 
   1078 	ostate = tcp_debug_capture(tp, PRU_RCVOOB);
   1079 
   1080 	s = splsoftnet();
   1081 	if ((so->so_oobmark == 0 &&
   1082 	    (so->so_state & SS_RCVATMARK) == 0) ||
   1083 	    so->so_options & SO_OOBINLINE ||
   1084 	    tp->t_oobflags & TCPOOB_HADDATA) {
   1085 		splx(s);
   1086 		return EINVAL;
   1087 	}
   1088 
   1089 	if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
   1090 		splx(s);
   1091 		return EWOULDBLOCK;
   1092 	}
   1093 
   1094 	m->m_len = 1;
   1095 	*mtod(m, char *) = tp->t_iobc;
   1096 	if ((flags & MSG_PEEK) == 0)
   1097 		tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
   1098 
   1099 	tcp_debug_trace(so, tp, ostate, PRU_RCVOOB);
   1100 	splx(s);
   1101 
   1102 	return 0;
   1103 }
   1104 
   1105 static int
   1106 tcp_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
   1107     struct mbuf *control, struct lwp *l)
   1108 {
   1109 	struct inpcb *inp = NULL;
   1110 	struct in6pcb *in6p = NULL;
   1111 	struct tcpcb *tp = NULL;
   1112 	int ostate = 0;
   1113 	int error = 0;
   1114 	int s;
   1115 
   1116 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
   1117 		return error;
   1118 
   1119 	ostate = tcp_debug_capture(tp, PRU_SEND);
   1120 
   1121 	/*
   1122 	 * Do a send by putting data in output queue and updating urgent
   1123 	 * marker if URG set.  Possibly send more data.
   1124 	 */
   1125 	s = splsoftnet();
   1126 	if (control && control->m_len) {
   1127 		m_freem(control);
   1128 		m_freem(m);
   1129 		tcp_debug_trace(so, tp, ostate, PRU_SEND);
   1130 		splx(s);
   1131 		return EINVAL;
   1132 	}
   1133 
   1134 	sbappendstream(&so->so_snd, m);
   1135 	error = tcp_output(tp);
   1136 	tcp_debug_trace(so, tp, ostate, PRU_SEND);
   1137 	splx(s);
   1138 
   1139 	return error;
   1140 }
   1141 
   1142 static int
   1143 tcp_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
   1144 {
   1145 	struct inpcb *inp = NULL;
   1146 	struct in6pcb *in6p = NULL;
   1147 	struct tcpcb *tp = NULL;
   1148 	int ostate = 0;
   1149 	int error = 0;
   1150 	int s;
   1151 
   1152 	if ((error = tcp_getpcb(so, &inp, &in6p, &tp)) != 0)
   1153 		return error;
   1154 
   1155 	ostate = tcp_debug_capture(tp, PRU_SENDOOB);
   1156 
   1157 	s = splsoftnet();
   1158 	if (sbspace(&so->so_snd) < -512) {
   1159 		m_freem(m);
   1160 		splx(s);
   1161 		return ENOBUFS;
   1162 	}
   1163 	/*
   1164 	 * According to RFC961 (Assigned Protocols),
   1165 	 * the urgent pointer points to the last octet
   1166 	 * of urgent data.  We continue, however,
   1167 	 * to consider it to indicate the first octet
   1168 	 * of data past the urgent section.
   1169 	 * Otherwise, snd_up should be one lower.
   1170 	 */
   1171 	sbappendstream(&so->so_snd, m);
   1172 	tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
   1173 	tp->t_force = 1;
   1174 	error = tcp_output(tp);
   1175 	tp->t_force = 0;
   1176 	tcp_debug_trace(so, tp, ostate, PRU_SENDOOB);
   1177 	splx(s);
   1178 
   1179 	return error;
   1180 }
   1181 
   1182 static int
   1183 tcp_purgeif(struct socket *so, struct ifnet *ifp)
   1184 {
   1185 	int s;
   1186 	int error = 0;
   1187 
   1188 	s = splsoftnet();
   1189 
   1190 	mutex_enter(softnet_lock);
   1191 	switch (so->so_proto->pr_domain->dom_family) {
   1192 	case PF_INET:
   1193 		in_pcbpurgeif0(&tcbtable, ifp);
   1194 #ifdef NET_MPSAFE
   1195 		mutex_exit(softnet_lock);
   1196 #endif
   1197 		in_purgeif(ifp);
   1198 #ifdef NET_MPSAFE
   1199 		mutex_enter(softnet_lock);
   1200 #endif
   1201 		in_pcbpurgeif(&tcbtable, ifp);
   1202 		break;
   1203 #ifdef INET6
   1204 	case PF_INET6:
   1205 		in6_pcbpurgeif0(&tcbtable, ifp);
   1206 #ifdef NET_MPSAFE
   1207 		mutex_exit(softnet_lock);
   1208 #endif
   1209 		in6_purgeif(ifp);
   1210 #ifdef NET_MPSAFE
   1211 		mutex_enter(softnet_lock);
   1212 #endif
   1213 		in6_pcbpurgeif(&tcbtable, ifp);
   1214 		break;
   1215 #endif
   1216 	default:
   1217 		error = EAFNOSUPPORT;
   1218 		break;
   1219 	}
   1220 	mutex_exit(softnet_lock);
   1221 	splx(s);
   1222 
   1223 	return error;
   1224 }
   1225 
   1226 /*
   1227  * Initiate (or continue) disconnect.
   1228  * If embryonic state, just send reset (once).
   1229  * If in ``let data drain'' option and linger null, just drop.
   1230  * Otherwise (hard), mark socket disconnecting and drop
   1231  * current input data; switch states based on user close, and
   1232  * send segment to peer (with FIN).
   1233  */
   1234 struct tcpcb *
   1235 tcp_disconnect1(struct tcpcb *tp)
   1236 {
   1237 	struct socket *so;
   1238 
   1239 	if (tp->t_inpcb)
   1240 		so = tp->t_inpcb->inp_socket;
   1241 #ifdef INET6
   1242 	else if (tp->t_in6pcb)
   1243 		so = tp->t_in6pcb->in6p_socket;
   1244 #endif
   1245 	else
   1246 		so = NULL;
   1247 
   1248 	if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
   1249 		tp = tcp_close(tp);
   1250 	else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
   1251 		tp = tcp_drop(tp, 0);
   1252 	else {
   1253 		soisdisconnecting(so);
   1254 		sbflush(&so->so_rcv);
   1255 		tp = tcp_usrclosed(tp);
   1256 		if (tp)
   1257 			(void) tcp_output(tp);
   1258 	}
   1259 	return (tp);
   1260 }
   1261 
   1262 /*
   1263  * User issued close, and wish to trail through shutdown states:
   1264  * if never received SYN, just forget it.  If got a SYN from peer,
   1265  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
   1266  * If already got a FIN from peer, then almost done; go to LAST_ACK
   1267  * state.  In all other cases, have already sent FIN to peer (e.g.
   1268  * after PRU_SHUTDOWN), and just have to play tedious game waiting
   1269  * for peer to send FIN or not respond to keep-alives, etc.
   1270  * We can let the user exit from the close as soon as the FIN is acked.
   1271  */
   1272 struct tcpcb *
   1273 tcp_usrclosed(struct tcpcb *tp)
   1274 {
   1275 
   1276 	switch (tp->t_state) {
   1277 
   1278 	case TCPS_CLOSED:
   1279 	case TCPS_LISTEN:
   1280 	case TCPS_SYN_SENT:
   1281 		tp->t_state = TCPS_CLOSED;
   1282 		tp = tcp_close(tp);
   1283 		break;
   1284 
   1285 	case TCPS_SYN_RECEIVED:
   1286 	case TCPS_ESTABLISHED:
   1287 		tp->t_state = TCPS_FIN_WAIT_1;
   1288 		break;
   1289 
   1290 	case TCPS_CLOSE_WAIT:
   1291 		tp->t_state = TCPS_LAST_ACK;
   1292 		break;
   1293 	}
   1294 	if (tp && tp->t_state >= TCPS_FIN_WAIT_2) {
   1295 		struct socket *so;
   1296 		if (tp->t_inpcb)
   1297 			so = tp->t_inpcb->inp_socket;
   1298 #ifdef INET6
   1299 		else if (tp->t_in6pcb)
   1300 			so = tp->t_in6pcb->in6p_socket;
   1301 #endif
   1302 		else
   1303 			so = NULL;
   1304 		if (so)
   1305 			soisdisconnected(so);
   1306 		/*
   1307 		 * If we are in FIN_WAIT_2, we arrived here because the
   1308 		 * application did a shutdown of the send side.  Like the
   1309 		 * case of a transition from FIN_WAIT_1 to FIN_WAIT_2 after
   1310 		 * a full close, we start a timer to make sure sockets are
   1311 		 * not left in FIN_WAIT_2 forever.
   1312 		 */
   1313 		if ((tp->t_state == TCPS_FIN_WAIT_2) && (tp->t_maxidle > 0))
   1314 			TCP_TIMER_ARM(tp, TCPT_2MSL, tp->t_maxidle);
   1315 		else if (tp->t_state == TCPS_TIME_WAIT
   1316 			 && ((tp->t_inpcb
   1317 			      && (tcp4_vtw_enable & 1)
   1318 			      && vtw_add(AF_INET, tp))
   1319 			     ||
   1320 			     (tp->t_in6pcb
   1321 			      && (tcp6_vtw_enable & 1)
   1322 			      && vtw_add(AF_INET6, tp)))) {
   1323 			tp = 0;
   1324 		}
   1325 	}
   1326 	return (tp);
   1327 }
   1328 
   1329 /*
   1330  * sysctl helper routine for net.inet.ip.mssdflt.  it can't be less
   1331  * than 32.
   1332  */
   1333 static int
   1334 sysctl_net_inet_tcp_mssdflt(SYSCTLFN_ARGS)
   1335 {
   1336 	int error, mssdflt;
   1337 	struct sysctlnode node;
   1338 
   1339 	mssdflt = tcp_mssdflt;
   1340 	node = *rnode;
   1341 	node.sysctl_data = &mssdflt;
   1342 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1343 	if (error || newp == NULL)
   1344 		return (error);
   1345 
   1346 	if (mssdflt < 32)
   1347 		return (EINVAL);
   1348 	tcp_mssdflt = mssdflt;
   1349 
   1350 	mutex_enter(softnet_lock);
   1351 	tcp_tcpcb_template();
   1352 	mutex_exit(softnet_lock);
   1353 
   1354 	return (0);
   1355 }
   1356 
   1357 /*
   1358  * sysctl helper for TCP CB template update
   1359  */
   1360 static int
   1361 sysctl_update_tcpcb_template(SYSCTLFN_ARGS)
   1362 {
   1363 	int t, error;
   1364 	struct sysctlnode node;
   1365 
   1366 	/* follow procedures in sysctl(9) manpage */
   1367 	t = *(int *)rnode->sysctl_data;
   1368 	node = *rnode;
   1369 	node.sysctl_data = &t;
   1370 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1371 	if (error || newp == NULL)
   1372 		return error;
   1373 
   1374 	if (t < 0)
   1375 		return EINVAL;
   1376 
   1377 	*(int *)rnode->sysctl_data = t;
   1378 
   1379 	mutex_enter(softnet_lock);
   1380 	tcp_tcpcb_template();
   1381 	mutex_exit(softnet_lock);
   1382 
   1383 	return 0;
   1384 }
   1385 
   1386 /*
   1387  * sysctl helper routine for setting port related values under
   1388  * net.inet.ip and net.inet6.ip6.  does basic range checking and does
   1389  * additional checks for each type.  this code has placed in
   1390  * tcp_input.c since INET and INET6 both use the same tcp code.
   1391  *
   1392  * this helper is not static so that both inet and inet6 can use it.
   1393  */
   1394 int
   1395 sysctl_net_inet_ip_ports(SYSCTLFN_ARGS)
   1396 {
   1397 	int error, tmp;
   1398 	int apmin, apmax;
   1399 #ifndef IPNOPRIVPORTS
   1400 	int lpmin, lpmax;
   1401 #endif /* IPNOPRIVPORTS */
   1402 	struct sysctlnode node;
   1403 
   1404 	if (namelen != 0)
   1405 		return (EINVAL);
   1406 
   1407 	switch (name[-3]) {
   1408 	    case PF_INET:
   1409 		apmin = anonportmin;
   1410 		apmax = anonportmax;
   1411 #ifndef IPNOPRIVPORTS
   1412 		lpmin = lowportmin;
   1413 		lpmax = lowportmax;
   1414 #endif /* IPNOPRIVPORTS */
   1415 		break;
   1416 #ifdef INET6
   1417 	    case PF_INET6:
   1418 		apmin = ip6_anonportmin;
   1419 		apmax = ip6_anonportmax;
   1420 #ifndef IPNOPRIVPORTS
   1421 		lpmin = ip6_lowportmin;
   1422 		lpmax = ip6_lowportmax;
   1423 #endif /* IPNOPRIVPORTS */
   1424 		break;
   1425 #endif /* INET6 */
   1426 	    default:
   1427 		return (EINVAL);
   1428 	}
   1429 
   1430 	/*
   1431 	 * insert temporary copy into node, perform lookup on
   1432 	 * temporary, then restore pointer
   1433 	 */
   1434 	node = *rnode;
   1435 	tmp = *(int*)rnode->sysctl_data;
   1436 	node.sysctl_data = &tmp;
   1437 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1438 	if (error || newp == NULL)
   1439 		return (error);
   1440 
   1441 	/*
   1442 	 * simple port range check
   1443 	 */
   1444 	if (tmp < 0 || tmp > 65535)
   1445 		return (EINVAL);
   1446 
   1447 	/*
   1448 	 * per-node range checks
   1449 	 */
   1450 	switch (rnode->sysctl_num) {
   1451 	case IPCTL_ANONPORTMIN:
   1452 	case IPV6CTL_ANONPORTMIN:
   1453 		if (tmp >= apmax)
   1454 			return (EINVAL);
   1455 #ifndef IPNOPRIVPORTS
   1456 		if (tmp < IPPORT_RESERVED)
   1457                         return (EINVAL);
   1458 #endif /* IPNOPRIVPORTS */
   1459 		break;
   1460 
   1461 	case IPCTL_ANONPORTMAX:
   1462 	case IPV6CTL_ANONPORTMAX:
   1463                 if (apmin >= tmp)
   1464 			return (EINVAL);
   1465 #ifndef IPNOPRIVPORTS
   1466 		if (tmp < IPPORT_RESERVED)
   1467                         return (EINVAL);
   1468 #endif /* IPNOPRIVPORTS */
   1469 		break;
   1470 
   1471 #ifndef IPNOPRIVPORTS
   1472 	case IPCTL_LOWPORTMIN:
   1473 	case IPV6CTL_LOWPORTMIN:
   1474 		if (tmp >= lpmax ||
   1475 		    tmp > IPPORT_RESERVEDMAX ||
   1476 		    tmp < IPPORT_RESERVEDMIN)
   1477 			return (EINVAL);
   1478 		break;
   1479 
   1480 	case IPCTL_LOWPORTMAX:
   1481 	case IPV6CTL_LOWPORTMAX:
   1482 		if (lpmin >= tmp ||
   1483 		    tmp > IPPORT_RESERVEDMAX ||
   1484 		    tmp < IPPORT_RESERVEDMIN)
   1485 			return (EINVAL);
   1486 		break;
   1487 #endif /* IPNOPRIVPORTS */
   1488 
   1489 	default:
   1490 		return (EINVAL);
   1491 	}
   1492 
   1493 	*(int*)rnode->sysctl_data = tmp;
   1494 
   1495 	return (0);
   1496 }
   1497 
   1498 static inline int
   1499 copyout_uid(struct socket *sockp, void *oldp, size_t *oldlenp)
   1500 {
   1501 	if (oldp) {
   1502 		size_t sz;
   1503 		uid_t uid;
   1504 		int error;
   1505 
   1506 		if (sockp->so_cred == NULL)
   1507 			return EPERM;
   1508 
   1509 		uid = kauth_cred_geteuid(sockp->so_cred);
   1510 		sz = MIN(sizeof(uid), *oldlenp);
   1511 		if ((error = copyout(&uid, oldp, sz)) != 0)
   1512 			return error;
   1513 	}
   1514 	*oldlenp = sizeof(uid_t);
   1515 	return 0;
   1516 }
   1517 
   1518 static inline int
   1519 inet4_ident_core(struct in_addr raddr, u_int rport,
   1520     struct in_addr laddr, u_int lport,
   1521     void *oldp, size_t *oldlenp,
   1522     struct lwp *l, int dodrop)
   1523 {
   1524 	struct inpcb *inp;
   1525 	struct socket *sockp;
   1526 
   1527 	inp = in_pcblookup_connect(&tcbtable, raddr, rport, laddr, lport, 0);
   1528 
   1529 	if (inp == NULL || (sockp = inp->inp_socket) == NULL)
   1530 		return ESRCH;
   1531 
   1532 	if (dodrop) {
   1533 		struct tcpcb *tp;
   1534 		int error;
   1535 
   1536 		if (inp == NULL || (tp = intotcpcb(inp)) == NULL ||
   1537 		    (inp->inp_socket->so_options & SO_ACCEPTCONN) != 0)
   1538 			return ESRCH;
   1539 
   1540 		error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
   1541 		    KAUTH_REQ_NETWORK_SOCKET_DROP, inp->inp_socket, tp, NULL);
   1542 		if (error)
   1543 			return (error);
   1544 
   1545 		(void)tcp_drop(tp, ECONNABORTED);
   1546 		return 0;
   1547 	}
   1548 	else
   1549 		return copyout_uid(sockp, oldp, oldlenp);
   1550 }
   1551 
   1552 #ifdef INET6
   1553 static inline int
   1554 inet6_ident_core(struct in6_addr *raddr, u_int rport,
   1555     struct in6_addr *laddr, u_int lport,
   1556     void *oldp, size_t *oldlenp,
   1557     struct lwp *l, int dodrop)
   1558 {
   1559 	struct in6pcb *in6p;
   1560 	struct socket *sockp;
   1561 
   1562 	in6p = in6_pcblookup_connect(&tcbtable, raddr, rport, laddr, lport, 0, 0);
   1563 
   1564 	if (in6p == NULL || (sockp = in6p->in6p_socket) == NULL)
   1565 		return ESRCH;
   1566 
   1567 	if (dodrop) {
   1568 		struct tcpcb *tp;
   1569 		int error;
   1570 
   1571 		if (in6p == NULL || (tp = in6totcpcb(in6p)) == NULL ||
   1572 		    (in6p->in6p_socket->so_options & SO_ACCEPTCONN) != 0)
   1573 			return ESRCH;
   1574 
   1575 		error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
   1576 		    KAUTH_REQ_NETWORK_SOCKET_DROP, in6p->in6p_socket, tp, NULL);
   1577 		if (error)
   1578 			return (error);
   1579 
   1580 		(void)tcp_drop(tp, ECONNABORTED);
   1581 		return 0;
   1582 	}
   1583 	else
   1584 		return copyout_uid(sockp, oldp, oldlenp);
   1585 }
   1586 #endif
   1587 
   1588 /*
   1589  * sysctl helper routine for the net.inet.tcp.drop and
   1590  * net.inet6.tcp6.drop nodes.
   1591  */
   1592 #define sysctl_net_inet_tcp_drop sysctl_net_inet_tcp_ident
   1593 
   1594 /*
   1595  * sysctl helper routine for the net.inet.tcp.ident and
   1596  * net.inet6.tcp6.ident nodes.  contains backwards compat code for the
   1597  * old way of looking up the ident information for ipv4 which involves
   1598  * stuffing the port/addr pairs into the mib lookup.
   1599  */
   1600 static int
   1601 sysctl_net_inet_tcp_ident(SYSCTLFN_ARGS)
   1602 {
   1603 	struct sockaddr_in *si4[2];
   1604 #ifdef INET6
   1605 	struct sockaddr_in6 *si6[2];
   1606 #endif
   1607 	struct sockaddr_storage sa[2];
   1608 	int error, pf, dodrop;
   1609 
   1610 	dodrop = name[-1] == TCPCTL_DROP;
   1611 	if (dodrop) {
   1612 		if (oldp != NULL || *oldlenp != 0)
   1613 			return EINVAL;
   1614 		if (newp == NULL)
   1615 			return EPERM;
   1616 		if (newlen < sizeof(sa))
   1617 			return ENOMEM;
   1618 	}
   1619 	if (namelen != 4 && namelen != 0)
   1620 		return EINVAL;
   1621 	if (name[-2] != IPPROTO_TCP)
   1622 		return EINVAL;
   1623 	pf = name[-3];
   1624 
   1625 	/* old style lookup, ipv4 only */
   1626 	if (namelen == 4) {
   1627 		struct in_addr laddr, raddr;
   1628 		u_int lport, rport;
   1629 
   1630 		if (pf != PF_INET)
   1631 			return EPROTONOSUPPORT;
   1632 		raddr.s_addr = (uint32_t)name[0];
   1633 		rport = (u_int)name[1];
   1634 		laddr.s_addr = (uint32_t)name[2];
   1635 		lport = (u_int)name[3];
   1636 
   1637 		mutex_enter(softnet_lock);
   1638 		error = inet4_ident_core(raddr, rport, laddr, lport,
   1639 		    oldp, oldlenp, l, dodrop);
   1640 		mutex_exit(softnet_lock);
   1641 		return error;
   1642 	}
   1643 
   1644 	if (newp == NULL || newlen != sizeof(sa))
   1645 		return EINVAL;
   1646 	error = copyin(newp, &sa, newlen);
   1647 	if (error)
   1648 		return error;
   1649 
   1650 	/*
   1651 	 * requested families must match
   1652 	 */
   1653 	if (pf != sa[0].ss_family || sa[0].ss_family != sa[1].ss_family)
   1654 		return EINVAL;
   1655 
   1656 	switch (pf) {
   1657 #ifdef INET6
   1658 	case PF_INET6:
   1659 		si6[0] = (struct sockaddr_in6*)&sa[0];
   1660 		si6[1] = (struct sockaddr_in6*)&sa[1];
   1661 		if (si6[0]->sin6_len != sizeof(*si6[0]) ||
   1662 		    si6[1]->sin6_len != sizeof(*si6[1]))
   1663 			return EINVAL;
   1664 
   1665 		if (!IN6_IS_ADDR_V4MAPPED(&si6[0]->sin6_addr) &&
   1666 		    !IN6_IS_ADDR_V4MAPPED(&si6[1]->sin6_addr)) {
   1667 			error = sa6_embedscope(si6[0], ip6_use_defzone);
   1668 			if (error)
   1669 				return error;
   1670 			error = sa6_embedscope(si6[1], ip6_use_defzone);
   1671 			if (error)
   1672 				return error;
   1673 
   1674 			mutex_enter(softnet_lock);
   1675 			error = inet6_ident_core(&si6[0]->sin6_addr,
   1676 			    si6[0]->sin6_port, &si6[1]->sin6_addr,
   1677 			    si6[1]->sin6_port, oldp, oldlenp, l, dodrop);
   1678 			mutex_exit(softnet_lock);
   1679 			return error;
   1680 		}
   1681 
   1682 		if (IN6_IS_ADDR_V4MAPPED(&si6[0]->sin6_addr) !=
   1683 		    IN6_IS_ADDR_V4MAPPED(&si6[1]->sin6_addr))
   1684 			return EINVAL;
   1685 
   1686 		in6_sin6_2_sin_in_sock((struct sockaddr *)&sa[0]);
   1687 		in6_sin6_2_sin_in_sock((struct sockaddr *)&sa[1]);
   1688 		/*FALLTHROUGH*/
   1689 #endif /* INET6 */
   1690 	case PF_INET:
   1691 		si4[0] = (struct sockaddr_in*)&sa[0];
   1692 		si4[1] = (struct sockaddr_in*)&sa[1];
   1693 		if (si4[0]->sin_len != sizeof(*si4[0]) ||
   1694 		    si4[0]->sin_len != sizeof(*si4[1]))
   1695 			return EINVAL;
   1696 
   1697 		mutex_enter(softnet_lock);
   1698 		error = inet4_ident_core(si4[0]->sin_addr, si4[0]->sin_port,
   1699 		    si4[1]->sin_addr, si4[1]->sin_port,
   1700 		    oldp, oldlenp, l, dodrop);
   1701 		mutex_exit(softnet_lock);
   1702 		return error;
   1703 	default:
   1704 		return EPROTONOSUPPORT;
   1705 	}
   1706 }
   1707 
   1708 /*
   1709  * sysctl helper for the inet and inet6 pcblists.  handles tcp/udp and
   1710  * inet/inet6, as well as raw pcbs for each.  specifically not
   1711  * declared static so that raw sockets and udp/udp6 can use it as
   1712  * well.
   1713  */
   1714 int
   1715 sysctl_inpcblist(SYSCTLFN_ARGS)
   1716 {
   1717 	struct sockaddr_in *in;
   1718 	const struct inpcb *inp;
   1719 #ifdef INET6
   1720 	struct sockaddr_in6 *in6;
   1721 	const struct in6pcb *in6p;
   1722 #endif
   1723 	struct inpcbtable *pcbtbl = __UNCONST(rnode->sysctl_data);
   1724 	const struct inpcb_hdr *inph;
   1725 	struct tcpcb *tp;
   1726 	struct kinfo_pcb pcb;
   1727 	char *dp;
   1728 	size_t len, needed, elem_size, out_size;
   1729 	int error, elem_count, pf, proto, pf2;
   1730 
   1731 	if (namelen != 4)
   1732 		return (EINVAL);
   1733 
   1734 	if (oldp != NULL) {
   1735 		    len = *oldlenp;
   1736 		    elem_size = name[2];
   1737 		    elem_count = name[3];
   1738 		    if (elem_size != sizeof(pcb))
   1739 			    return EINVAL;
   1740 	} else {
   1741 		    len = 0;
   1742 		    elem_count = INT_MAX;
   1743 		    elem_size = sizeof(pcb);
   1744 	}
   1745 	error = 0;
   1746 	dp = oldp;
   1747 	out_size = elem_size;
   1748 	needed = 0;
   1749 
   1750 	if (namelen == 1 && name[0] == CTL_QUERY)
   1751 		return (sysctl_query(SYSCTLFN_CALL(rnode)));
   1752 
   1753 	if (name - oname != 4)
   1754 		return (EINVAL);
   1755 
   1756 	pf = oname[1];
   1757 	proto = oname[2];
   1758 	pf2 = (oldp != NULL) ? pf : 0;
   1759 
   1760 	mutex_enter(softnet_lock);
   1761 
   1762 	TAILQ_FOREACH(inph, &pcbtbl->inpt_queue, inph_queue) {
   1763 		inp = (const struct inpcb *)inph;
   1764 #ifdef INET6
   1765 		in6p = (const struct in6pcb *)inph;
   1766 #endif
   1767 
   1768 		if (inph->inph_af != pf)
   1769 			continue;
   1770 
   1771 		if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
   1772 		    KAUTH_REQ_NETWORK_SOCKET_CANSEE, inph->inph_socket, NULL,
   1773 		    NULL) != 0)
   1774 			continue;
   1775 
   1776 		memset(&pcb, 0, sizeof(pcb));
   1777 
   1778 		pcb.ki_family = pf;
   1779 		pcb.ki_type = proto;
   1780 
   1781 		switch (pf2) {
   1782 		case 0:
   1783 			/* just probing for size */
   1784 			break;
   1785 		case PF_INET:
   1786 			pcb.ki_family = inp->inp_socket->so_proto->
   1787 			    pr_domain->dom_family;
   1788 			pcb.ki_type = inp->inp_socket->so_proto->
   1789 			    pr_type;
   1790 			pcb.ki_protocol = inp->inp_socket->so_proto->
   1791 			    pr_protocol;
   1792 			pcb.ki_pflags = inp->inp_flags;
   1793 
   1794 			pcb.ki_sostate = inp->inp_socket->so_state;
   1795 			pcb.ki_prstate = inp->inp_state;
   1796 			if (proto == IPPROTO_TCP) {
   1797 				tp = intotcpcb(inp);
   1798 				pcb.ki_tstate = tp->t_state;
   1799 				pcb.ki_tflags = tp->t_flags;
   1800 			}
   1801 
   1802 			pcb.ki_pcbaddr = PTRTOUINT64(inp);
   1803 			pcb.ki_ppcbaddr = PTRTOUINT64(inp->inp_ppcb);
   1804 			pcb.ki_sockaddr = PTRTOUINT64(inp->inp_socket);
   1805 
   1806 			pcb.ki_rcvq = inp->inp_socket->so_rcv.sb_cc;
   1807 			pcb.ki_sndq = inp->inp_socket->so_snd.sb_cc;
   1808 
   1809 			in = satosin(&pcb.ki_src);
   1810 			in->sin_len = sizeof(*in);
   1811 			in->sin_family = pf;
   1812 			in->sin_port = inp->inp_lport;
   1813 			in->sin_addr = inp->inp_laddr;
   1814 			if (pcb.ki_prstate >= INP_CONNECTED) {
   1815 				in = satosin(&pcb.ki_dst);
   1816 				in->sin_len = sizeof(*in);
   1817 				in->sin_family = pf;
   1818 				in->sin_port = inp->inp_fport;
   1819 				in->sin_addr = inp->inp_faddr;
   1820 			}
   1821 			break;
   1822 #ifdef INET6
   1823 		case PF_INET6:
   1824 			pcb.ki_family = in6p->in6p_socket->so_proto->
   1825 			    pr_domain->dom_family;
   1826 			pcb.ki_type = in6p->in6p_socket->so_proto->pr_type;
   1827 			pcb.ki_protocol = in6p->in6p_socket->so_proto->
   1828 			    pr_protocol;
   1829 			pcb.ki_pflags = in6p->in6p_flags;
   1830 
   1831 			pcb.ki_sostate = in6p->in6p_socket->so_state;
   1832 			pcb.ki_prstate = in6p->in6p_state;
   1833 			if (proto == IPPROTO_TCP) {
   1834 				tp = in6totcpcb(in6p);
   1835 				pcb.ki_tstate = tp->t_state;
   1836 				pcb.ki_tflags = tp->t_flags;
   1837 			}
   1838 
   1839 			pcb.ki_pcbaddr = PTRTOUINT64(in6p);
   1840 			pcb.ki_ppcbaddr = PTRTOUINT64(in6p->in6p_ppcb);
   1841 			pcb.ki_sockaddr = PTRTOUINT64(in6p->in6p_socket);
   1842 
   1843 			pcb.ki_rcvq = in6p->in6p_socket->so_rcv.sb_cc;
   1844 			pcb.ki_sndq = in6p->in6p_socket->so_snd.sb_cc;
   1845 
   1846 			in6 = satosin6(&pcb.ki_src);
   1847 			in6->sin6_len = sizeof(*in6);
   1848 			in6->sin6_family = pf;
   1849 			in6->sin6_port = in6p->in6p_lport;
   1850 			in6->sin6_flowinfo = in6p->in6p_flowinfo;
   1851 			in6->sin6_addr = in6p->in6p_laddr;
   1852 			in6->sin6_scope_id = 0; /* XXX? */
   1853 
   1854 			if (pcb.ki_prstate >= IN6P_CONNECTED) {
   1855 				in6 = satosin6(&pcb.ki_dst);
   1856 				in6->sin6_len = sizeof(*in6);
   1857 				in6->sin6_family = pf;
   1858 				in6->sin6_port = in6p->in6p_fport;
   1859 				in6->sin6_flowinfo = in6p->in6p_flowinfo;
   1860 				in6->sin6_addr = in6p->in6p_faddr;
   1861 				in6->sin6_scope_id = 0; /* XXX? */
   1862 			}
   1863 			break;
   1864 #endif
   1865 		}
   1866 
   1867 		if (len >= elem_size && elem_count > 0) {
   1868 			error = copyout(&pcb, dp, out_size);
   1869 			if (error) {
   1870 				mutex_exit(softnet_lock);
   1871 				return (error);
   1872 			}
   1873 			dp += elem_size;
   1874 			len -= elem_size;
   1875 		}
   1876 		needed += elem_size;
   1877 		if (elem_count > 0 && elem_count != INT_MAX)
   1878 			elem_count--;
   1879 	}
   1880 
   1881 	*oldlenp = needed;
   1882 	if (oldp == NULL)
   1883 		*oldlenp += PCB_SLOP * sizeof(struct kinfo_pcb);
   1884 
   1885 	mutex_exit(softnet_lock);
   1886 
   1887 	return (error);
   1888 }
   1889 
   1890 static int
   1891 sysctl_tcp_congctl(SYSCTLFN_ARGS)
   1892 {
   1893 	struct sysctlnode node;
   1894 	int error;
   1895 	char newname[TCPCC_MAXLEN];
   1896 
   1897 	strlcpy(newname, tcp_congctl_global_name, sizeof(newname) - 1);
   1898 
   1899 	node = *rnode;
   1900 	node.sysctl_data = newname;
   1901 	node.sysctl_size = sizeof(newname);
   1902 
   1903 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1904 
   1905 	if (error ||
   1906 	    newp == NULL ||
   1907 	    strncmp(newname, tcp_congctl_global_name, sizeof(newname)) == 0)
   1908 		return error;
   1909 
   1910 	mutex_enter(softnet_lock);
   1911 	error = tcp_congctl_select(NULL, newname);
   1912 	mutex_exit(softnet_lock);
   1913 
   1914 	return error;
   1915 }
   1916 
   1917 static int
   1918 sysctl_tcp_init_win(SYSCTLFN_ARGS)
   1919 {
   1920 	int error;
   1921 	u_int iw;
   1922 	struct sysctlnode node;
   1923 
   1924 	iw = *(u_int *)rnode->sysctl_data;
   1925 	node = *rnode;
   1926 	node.sysctl_data = &iw;
   1927 	node.sysctl_size = sizeof(iw);
   1928 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1929 	if (error || newp == NULL)
   1930 		return error;
   1931 
   1932 	if (iw >= __arraycount(tcp_init_win_max))
   1933 		return EINVAL;
   1934 	*(u_int *)rnode->sysctl_data = iw;
   1935 	return 0;
   1936 }
   1937 
   1938 static int
   1939 sysctl_tcp_keep(SYSCTLFN_ARGS)
   1940 {
   1941 	int error;
   1942 	u_int tmp;
   1943 	struct sysctlnode node;
   1944 
   1945 	node = *rnode;
   1946 	tmp = *(u_int *)rnode->sysctl_data;
   1947 	node.sysctl_data = &tmp;
   1948 
   1949 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1950 	if (error || newp == NULL)
   1951 		return error;
   1952 
   1953 	mutex_enter(softnet_lock);
   1954 
   1955 	*(u_int *)rnode->sysctl_data = tmp;
   1956 	tcp_tcpcb_template();	/* update the template */
   1957 
   1958 	mutex_exit(softnet_lock);
   1959 	return 0;
   1960 }
   1961 
   1962 static int
   1963 sysctl_net_inet_tcp_stats(SYSCTLFN_ARGS)
   1964 {
   1965 
   1966 	return (NETSTAT_SYSCTL(tcpstat_percpu, TCP_NSTATS));
   1967 }
   1968 
   1969 /*
   1970  * this (second stage) setup routine is a replacement for tcp_sysctl()
   1971  * (which is currently used for ipv4 and ipv6)
   1972  */
   1973 static void
   1974 sysctl_net_inet_tcp_setup2(struct sysctllog **clog, int pf, const char *pfname,
   1975 			   const char *tcpname)
   1976 {
   1977 	const struct sysctlnode *sack_node;
   1978 	const struct sysctlnode *abc_node;
   1979 	const struct sysctlnode *ecn_node;
   1980 	const struct sysctlnode *congctl_node;
   1981 	const struct sysctlnode *mslt_node;
   1982 	const struct sysctlnode *vtw_node;
   1983 #ifdef TCP_DEBUG
   1984 	extern struct tcp_debug tcp_debug[TCP_NDEBUG];
   1985 	extern int tcp_debx;
   1986 #endif
   1987 
   1988 	sysctl_createv(clog, 0, NULL, NULL,
   1989 		       CTLFLAG_PERMANENT,
   1990 		       CTLTYPE_NODE, pfname, NULL,
   1991 		       NULL, 0, NULL, 0,
   1992 		       CTL_NET, pf, CTL_EOL);
   1993 	sysctl_createv(clog, 0, NULL, NULL,
   1994 		       CTLFLAG_PERMANENT,
   1995 		       CTLTYPE_NODE, tcpname,
   1996 		       SYSCTL_DESCR("TCP related settings"),
   1997 		       NULL, 0, NULL, 0,
   1998 		       CTL_NET, pf, IPPROTO_TCP, CTL_EOL);
   1999 
   2000 	sysctl_createv(clog, 0, NULL, NULL,
   2001 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2002 		       CTLTYPE_INT, "rfc1323",
   2003 		       SYSCTL_DESCR("Enable RFC1323 TCP extensions"),
   2004 		       sysctl_update_tcpcb_template, 0, &tcp_do_rfc1323, 0,
   2005 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_RFC1323, CTL_EOL);
   2006 	sysctl_createv(clog, 0, NULL, NULL,
   2007 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2008 		       CTLTYPE_INT, "sendspace",
   2009 		       SYSCTL_DESCR("Default TCP send buffer size"),
   2010 		       NULL, 0, &tcp_sendspace, 0,
   2011 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SENDSPACE, CTL_EOL);
   2012 	sysctl_createv(clog, 0, NULL, NULL,
   2013 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2014 		       CTLTYPE_INT, "recvspace",
   2015 		       SYSCTL_DESCR("Default TCP receive buffer size"),
   2016 		       NULL, 0, &tcp_recvspace, 0,
   2017 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_RECVSPACE, CTL_EOL);
   2018 	sysctl_createv(clog, 0, NULL, NULL,
   2019 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2020 		       CTLTYPE_INT, "mssdflt",
   2021 		       SYSCTL_DESCR("Default maximum segment size"),
   2022 		       sysctl_net_inet_tcp_mssdflt, 0, &tcp_mssdflt, 0,
   2023 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_MSSDFLT, CTL_EOL);
   2024 	sysctl_createv(clog, 0, NULL, NULL,
   2025 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2026 		       CTLTYPE_INT, "minmss",
   2027 		       SYSCTL_DESCR("Lower limit for TCP maximum segment size"),
   2028 		       NULL, 0, &tcp_minmss, 0,
   2029 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2030 	sysctl_createv(clog, 0, NULL, NULL,
   2031 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2032 		       CTLTYPE_INT, "msl",
   2033 		       SYSCTL_DESCR("Maximum Segment Life"),
   2034 		       NULL, 0, &tcp_msl, 0,
   2035 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_MSL, CTL_EOL);
   2036 	sysctl_createv(clog, 0, NULL, NULL,
   2037 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2038 		       CTLTYPE_INT, "syn_cache_limit",
   2039 		       SYSCTL_DESCR("Maximum number of entries in the TCP "
   2040 				    "compressed state engine"),
   2041 		       NULL, 0, &tcp_syn_cache_limit, 0,
   2042 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_CACHE_LIMIT,
   2043 		       CTL_EOL);
   2044 	sysctl_createv(clog, 0, NULL, NULL,
   2045 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2046 		       CTLTYPE_INT, "syn_bucket_limit",
   2047 		       SYSCTL_DESCR("Maximum number of entries per hash "
   2048 				    "bucket in the TCP compressed state "
   2049 				    "engine"),
   2050 		       NULL, 0, &tcp_syn_bucket_limit, 0,
   2051 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_BUCKET_LIMIT,
   2052 		       CTL_EOL);
   2053 #if 0 /* obsoleted */
   2054 	sysctl_createv(clog, 0, NULL, NULL,
   2055 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2056 		       CTLTYPE_INT, "syn_cache_interval",
   2057 		       SYSCTL_DESCR("TCP compressed state engine's timer interval"),
   2058 		       NULL, 0, &tcp_syn_cache_interval, 0,
   2059 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_CACHE_INTER,
   2060 		       CTL_EOL);
   2061 #endif
   2062 	sysctl_createv(clog, 0, NULL, NULL,
   2063 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2064 		       CTLTYPE_INT, "init_win",
   2065 		       SYSCTL_DESCR("Initial TCP congestion window"),
   2066 		       sysctl_tcp_init_win, 0, &tcp_init_win, 0,
   2067 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_INIT_WIN, CTL_EOL);
   2068 	sysctl_createv(clog, 0, NULL, NULL,
   2069 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2070 		       CTLTYPE_INT, "mss_ifmtu",
   2071 		       SYSCTL_DESCR("Use interface MTU for calculating MSS"),
   2072 		       NULL, 0, &tcp_mss_ifmtu, 0,
   2073 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_MSS_IFMTU, CTL_EOL);
   2074 	sysctl_createv(clog, 0, NULL, &sack_node,
   2075 		       CTLFLAG_PERMANENT,
   2076 		       CTLTYPE_NODE, "sack",
   2077 		       SYSCTL_DESCR("RFC2018 Selective ACKnowledgement tunables"),
   2078 		       NULL, 0, NULL, 0,
   2079 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_EOL);
   2080 
   2081 	/* Congctl subtree */
   2082 	sysctl_createv(clog, 0, NULL, &congctl_node,
   2083 		       CTLFLAG_PERMANENT,
   2084 		       CTLTYPE_NODE, "congctl",
   2085 		       SYSCTL_DESCR("TCP Congestion Control"),
   2086 	    	       NULL, 0, NULL, 0,
   2087 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2088 	sysctl_createv(clog, 0, &congctl_node, NULL,
   2089 		       CTLFLAG_PERMANENT,
   2090 		       CTLTYPE_STRING, "available",
   2091 		       SYSCTL_DESCR("Available Congestion Control Mechanisms"),
   2092 		       NULL, 0, tcp_congctl_avail, 0, CTL_CREATE, CTL_EOL);
   2093 	sysctl_createv(clog, 0, &congctl_node, NULL,
   2094 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2095 		       CTLTYPE_STRING, "selected",
   2096 		       SYSCTL_DESCR("Selected Congestion Control Mechanism"),
   2097 		       sysctl_tcp_congctl, 0, NULL, TCPCC_MAXLEN,
   2098 		       CTL_CREATE, CTL_EOL);
   2099 
   2100 	sysctl_createv(clog, 0, NULL, NULL,
   2101 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2102 		       CTLTYPE_INT, "win_scale",
   2103 		       SYSCTL_DESCR("Use RFC1323 window scale options"),
   2104 		       sysctl_update_tcpcb_template, 0, &tcp_do_win_scale, 0,
   2105 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_WSCALE, CTL_EOL);
   2106 	sysctl_createv(clog, 0, NULL, NULL,
   2107 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2108 		       CTLTYPE_INT, "timestamps",
   2109 		       SYSCTL_DESCR("Use RFC1323 time stamp options"),
   2110 		       sysctl_update_tcpcb_template, 0, &tcp_do_timestamps, 0,
   2111 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_TSTAMP, CTL_EOL);
   2112 	sysctl_createv(clog, 0, NULL, NULL,
   2113 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2114 		       CTLTYPE_INT, "cwm",
   2115 		       SYSCTL_DESCR("Hughes/Touch/Heidemann Congestion Window "
   2116 				    "Monitoring"),
   2117 		       NULL, 0, &tcp_cwm, 0,
   2118 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_CWM, CTL_EOL);
   2119 	sysctl_createv(clog, 0, NULL, NULL,
   2120 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2121 		       CTLTYPE_INT, "cwm_burstsize",
   2122 		       SYSCTL_DESCR("Congestion Window Monitoring allowed "
   2123 				    "burst count in packets"),
   2124 		       NULL, 0, &tcp_cwm_burstsize, 0,
   2125 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_CWM_BURSTSIZE,
   2126 		       CTL_EOL);
   2127 	sysctl_createv(clog, 0, NULL, NULL,
   2128 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2129 		       CTLTYPE_INT, "ack_on_push",
   2130 		       SYSCTL_DESCR("Immediately return ACK when PSH is "
   2131 				    "received"),
   2132 		       NULL, 0, &tcp_ack_on_push, 0,
   2133 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_ACK_ON_PUSH, CTL_EOL);
   2134 	sysctl_createv(clog, 0, NULL, NULL,
   2135 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2136 		       CTLTYPE_INT, "keepidle",
   2137 		       SYSCTL_DESCR("Allowed connection idle ticks before a "
   2138 				    "keepalive probe is sent"),
   2139 		       sysctl_tcp_keep, 0, &tcp_keepidle, 0,
   2140 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPIDLE, CTL_EOL);
   2141 	sysctl_createv(clog, 0, NULL, NULL,
   2142 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2143 		       CTLTYPE_INT, "keepintvl",
   2144 		       SYSCTL_DESCR("Ticks before next keepalive probe is sent"),
   2145 		       sysctl_tcp_keep, 0, &tcp_keepintvl, 0,
   2146 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPINTVL, CTL_EOL);
   2147 	sysctl_createv(clog, 0, NULL, NULL,
   2148 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2149 		       CTLTYPE_INT, "keepcnt",
   2150 		       SYSCTL_DESCR("Number of keepalive probes to send"),
   2151 		       sysctl_tcp_keep, 0, &tcp_keepcnt, 0,
   2152 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPCNT, CTL_EOL);
   2153 	sysctl_createv(clog, 0, NULL, NULL,
   2154 		       CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
   2155 		       CTLTYPE_INT, "slowhz",
   2156 		       SYSCTL_DESCR("Keepalive ticks per second"),
   2157 		       NULL, PR_SLOWHZ, NULL, 0,
   2158 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SLOWHZ, CTL_EOL);
   2159 	sysctl_createv(clog, 0, NULL, NULL,
   2160 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2161 		       CTLTYPE_INT, "log_refused",
   2162 		       SYSCTL_DESCR("Log refused TCP connections"),
   2163 		       NULL, 0, &tcp_log_refused, 0,
   2164 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_LOG_REFUSED, CTL_EOL);
   2165 #if 0 /* obsoleted */
   2166 	sysctl_createv(clog, 0, NULL, NULL,
   2167 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2168 		       CTLTYPE_INT, "rstratelimit", NULL,
   2169 		       NULL, 0, &tcp_rst_ratelim, 0,
   2170 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_RSTRATELIMIT, CTL_EOL);
   2171 #endif
   2172 	sysctl_createv(clog, 0, NULL, NULL,
   2173 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2174 		       CTLTYPE_INT, "rstppslimit",
   2175 		       SYSCTL_DESCR("Maximum number of RST packets to send "
   2176 				    "per second"),
   2177 		       NULL, 0, &tcp_rst_ppslim, 0,
   2178 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_RSTPPSLIMIT, CTL_EOL);
   2179 	sysctl_createv(clog, 0, NULL, NULL,
   2180 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2181 		       CTLTYPE_INT, "delack_ticks",
   2182 		       SYSCTL_DESCR("Number of ticks to delay sending an ACK"),
   2183 		       NULL, 0, &tcp_delack_ticks, 0,
   2184 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_DELACK_TICKS, CTL_EOL);
   2185 	sysctl_createv(clog, 0, NULL, NULL,
   2186 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2187 		       CTLTYPE_INT, "init_win_local",
   2188 		       SYSCTL_DESCR("Initial TCP window size (in segments)"),
   2189 		       sysctl_tcp_init_win, 0, &tcp_init_win_local, 0,
   2190 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_INIT_WIN_LOCAL,
   2191 		       CTL_EOL);
   2192 	sysctl_createv(clog, 0, NULL, NULL,
   2193 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2194 		       CTLTYPE_STRUCT, "ident",
   2195 		       SYSCTL_DESCR("RFC1413 Identification Protocol lookups"),
   2196 		       sysctl_net_inet_tcp_ident, 0, NULL, sizeof(uid_t),
   2197 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_IDENT, CTL_EOL);
   2198 	sysctl_createv(clog, 0, NULL, NULL,
   2199 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2200 		       CTLTYPE_INT, "do_loopback_cksum",
   2201 		       SYSCTL_DESCR("Perform TCP checksum on loopback"),
   2202 		       NULL, 0, &tcp_do_loopback_cksum, 0,
   2203 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_LOOPBACKCKSUM,
   2204 		       CTL_EOL);
   2205 	sysctl_createv(clog, 0, NULL, NULL,
   2206 		       CTLFLAG_PERMANENT,
   2207 		       CTLTYPE_STRUCT, "pcblist",
   2208 		       SYSCTL_DESCR("TCP protocol control block list"),
   2209 		       sysctl_inpcblist, 0, &tcbtable, 0,
   2210 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE,
   2211 		       CTL_EOL);
   2212 	sysctl_createv(clog, 0, NULL, NULL,
   2213 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2214 		       CTLTYPE_INT, "keepinit",
   2215 		       SYSCTL_DESCR("Ticks before initial tcp connection times out"),
   2216 		       sysctl_tcp_keep, 0, &tcp_keepinit, 0,
   2217 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2218 
   2219 	/* TCP socket buffers auto-sizing nodes */
   2220 	sysctl_createv(clog, 0, NULL, NULL,
   2221 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2222 		       CTLTYPE_INT, "recvbuf_auto",
   2223 		       SYSCTL_DESCR("Enable automatic receive "
   2224 		           "buffer sizing (experimental)"),
   2225 		       NULL, 0, &tcp_do_autorcvbuf, 0,
   2226 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2227 	sysctl_createv(clog, 0, NULL, NULL,
   2228 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2229 		       CTLTYPE_INT, "recvbuf_inc",
   2230 		       SYSCTL_DESCR("Incrementor step size of "
   2231 		           "automatic receive buffer"),
   2232 		       NULL, 0, &tcp_autorcvbuf_inc, 0,
   2233 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2234 	sysctl_createv(clog, 0, NULL, NULL,
   2235 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2236 		       CTLTYPE_INT, "recvbuf_max",
   2237 		       SYSCTL_DESCR("Max size of automatic receive buffer"),
   2238 		       NULL, 0, &tcp_autorcvbuf_max, 0,
   2239 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2240 
   2241 	sysctl_createv(clog, 0, NULL, NULL,
   2242 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2243 		       CTLTYPE_INT, "sendbuf_auto",
   2244 		       SYSCTL_DESCR("Enable automatic send "
   2245 		           "buffer sizing (experimental)"),
   2246 		       NULL, 0, &tcp_do_autosndbuf, 0,
   2247 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2248 	sysctl_createv(clog, 0, NULL, NULL,
   2249 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2250 		       CTLTYPE_INT, "sendbuf_inc",
   2251 		       SYSCTL_DESCR("Incrementor step size of "
   2252 		           "automatic send buffer"),
   2253 		       NULL, 0, &tcp_autosndbuf_inc, 0,
   2254 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2255 	sysctl_createv(clog, 0, NULL, NULL,
   2256 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2257 		       CTLTYPE_INT, "sendbuf_max",
   2258 		       SYSCTL_DESCR("Max size of automatic send buffer"),
   2259 		       NULL, 0, &tcp_autosndbuf_max, 0,
   2260 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2261 
   2262 	/* ECN subtree */
   2263 	sysctl_createv(clog, 0, NULL, &ecn_node,
   2264 	    	       CTLFLAG_PERMANENT,
   2265 		       CTLTYPE_NODE, "ecn",
   2266 	    	       SYSCTL_DESCR("RFC3168 Explicit Congestion Notification"),
   2267 	    	       NULL, 0, NULL, 0,
   2268 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2269 	sysctl_createv(clog, 0, &ecn_node, NULL,
   2270 	    	       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2271 		       CTLTYPE_INT, "enable",
   2272 		       SYSCTL_DESCR("Enable TCP Explicit Congestion "
   2273 			   "Notification"),
   2274 	    	       NULL, 0, &tcp_do_ecn, 0, CTL_CREATE, CTL_EOL);
   2275 	sysctl_createv(clog, 0, &ecn_node, NULL,
   2276 	    	       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2277 		       CTLTYPE_INT, "maxretries",
   2278 		       SYSCTL_DESCR("Number of times to retry ECN setup "
   2279 			       "before disabling ECN on the connection"),
   2280 	    	       NULL, 0, &tcp_ecn_maxretries, 0, CTL_CREATE, CTL_EOL);
   2281 
   2282 	/* SACK gets its own little subtree. */
   2283 	sysctl_createv(clog, 0, NULL, &sack_node,
   2284 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2285 		       CTLTYPE_INT, "enable",
   2286 		       SYSCTL_DESCR("Enable RFC2018 Selective ACKnowledgement"),
   2287 		       NULL, 0, &tcp_do_sack, 0,
   2288 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
   2289 	sysctl_createv(clog, 0, NULL, &sack_node,
   2290 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2291 		       CTLTYPE_INT, "maxholes",
   2292 		       SYSCTL_DESCR("Maximum number of TCP SACK holes allowed per connection"),
   2293 		       NULL, 0, &tcp_sack_tp_maxholes, 0,
   2294 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
   2295 	sysctl_createv(clog, 0, NULL, &sack_node,
   2296 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2297 		       CTLTYPE_INT, "globalmaxholes",
   2298 		       SYSCTL_DESCR("Global maximum number of TCP SACK holes"),
   2299 		       NULL, 0, &tcp_sack_globalmaxholes, 0,
   2300 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
   2301 	sysctl_createv(clog, 0, NULL, &sack_node,
   2302 		       CTLFLAG_PERMANENT,
   2303 		       CTLTYPE_INT, "globalholes",
   2304 		       SYSCTL_DESCR("Global number of TCP SACK holes"),
   2305 		       NULL, 0, &tcp_sack_globalholes, 0,
   2306 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
   2307 
   2308 	sysctl_createv(clog, 0, NULL, NULL,
   2309 		       CTLFLAG_PERMANENT,
   2310 		       CTLTYPE_STRUCT, "stats",
   2311 		       SYSCTL_DESCR("TCP statistics"),
   2312 		       sysctl_net_inet_tcp_stats, 0, NULL, 0,
   2313 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_STATS,
   2314 		       CTL_EOL);
   2315         sysctl_createv(clog, 0, NULL, NULL,
   2316                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2317                        CTLTYPE_INT, "local_by_rtt",
   2318                        SYSCTL_DESCR("Use RTT estimator to decide which hosts "
   2319 				    "are local"),
   2320 		       NULL, 0, &tcp_rttlocal, 0,
   2321 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2322 #ifdef TCP_DEBUG
   2323 	sysctl_createv(clog, 0, NULL, NULL,
   2324 		       CTLFLAG_PERMANENT,
   2325 		       CTLTYPE_STRUCT, "debug",
   2326 		       SYSCTL_DESCR("TCP sockets debug information"),
   2327 		       NULL, 0, &tcp_debug, sizeof(tcp_debug),
   2328 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_DEBUG,
   2329 		       CTL_EOL);
   2330 	sysctl_createv(clog, 0, NULL, NULL,
   2331 		       CTLFLAG_PERMANENT,
   2332 		       CTLTYPE_INT, "debx",
   2333 		       SYSCTL_DESCR("Number of TCP debug sockets messages"),
   2334 		       NULL, 0, &tcp_debx, sizeof(tcp_debx),
   2335 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_DEBX,
   2336 		       CTL_EOL);
   2337 #endif
   2338 	sysctl_createv(clog, 0, NULL, NULL,
   2339 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2340 		       CTLTYPE_STRUCT, "drop",
   2341 		       SYSCTL_DESCR("TCP drop connection"),
   2342 		       sysctl_net_inet_tcp_drop, 0, NULL, 0,
   2343 		       CTL_NET, pf, IPPROTO_TCP, TCPCTL_DROP, CTL_EOL);
   2344 	sysctl_createv(clog, 0, NULL, NULL,
   2345 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2346 		       CTLTYPE_INT, "iss_hash",
   2347 		       SYSCTL_DESCR("Enable RFC 1948 ISS by cryptographic "
   2348 				    "hash computation"),
   2349 		       NULL, 0, &tcp_do_rfc1948, sizeof(tcp_do_rfc1948),
   2350 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE,
   2351 		       CTL_EOL);
   2352 
   2353 	/* ABC subtree */
   2354 
   2355 	sysctl_createv(clog, 0, NULL, &abc_node,
   2356 		       CTLFLAG_PERMANENT, CTLTYPE_NODE, "abc",
   2357 		       SYSCTL_DESCR("RFC3465 Appropriate Byte Counting (ABC)"),
   2358 		       NULL, 0, NULL, 0,
   2359 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2360 	sysctl_createv(clog, 0, &abc_node, NULL,
   2361 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2362 		       CTLTYPE_INT, "enable",
   2363 		       SYSCTL_DESCR("Enable RFC3465 Appropriate Byte Counting"),
   2364 		       NULL, 0, &tcp_do_abc, 0, CTL_CREATE, CTL_EOL);
   2365 	sysctl_createv(clog, 0, &abc_node, NULL,
   2366 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2367 		       CTLTYPE_INT, "aggressive",
   2368 		       SYSCTL_DESCR("1: L=2*SMSS 0: L=1*SMSS"),
   2369 		       NULL, 0, &tcp_abc_aggressive, 0, CTL_CREATE, CTL_EOL);
   2370 
   2371 	/* MSL tuning subtree */
   2372 
   2373 	sysctl_createv(clog, 0, NULL, &mslt_node,
   2374 		       CTLFLAG_PERMANENT, CTLTYPE_NODE, "mslt",
   2375 		       SYSCTL_DESCR("MSL Tuning for TIME_WAIT truncation"),
   2376 		       NULL, 0, NULL, 0,
   2377 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2378 	sysctl_createv(clog, 0, &mslt_node, NULL,
   2379 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2380 		       CTLTYPE_INT, "enable",
   2381 		       SYSCTL_DESCR("Enable TIME_WAIT truncation"),
   2382 		       NULL, 0, &tcp_msl_enable, 0, CTL_CREATE, CTL_EOL);
   2383 	sysctl_createv(clog, 0, &mslt_node, NULL,
   2384 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2385 		       CTLTYPE_INT, "loopback",
   2386 		       SYSCTL_DESCR("MSL value to use for loopback connections"),
   2387 		       NULL, 0, &tcp_msl_loop, 0, CTL_CREATE, CTL_EOL);
   2388 	sysctl_createv(clog, 0, &mslt_node, NULL,
   2389 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2390 		       CTLTYPE_INT, "local",
   2391 		       SYSCTL_DESCR("MSL value to use for local connections"),
   2392 		       NULL, 0, &tcp_msl_local, 0, CTL_CREATE, CTL_EOL);
   2393 	sysctl_createv(clog, 0, &mslt_node, NULL,
   2394 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2395 		       CTLTYPE_INT, "remote",
   2396 		       SYSCTL_DESCR("MSL value to use for remote connections"),
   2397 		       NULL, 0, &tcp_msl_remote, 0, CTL_CREATE, CTL_EOL);
   2398 	sysctl_createv(clog, 0, &mslt_node, NULL,
   2399 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2400 		       CTLTYPE_INT, "remote_threshold",
   2401 		       SYSCTL_DESCR("RTT estimate value to promote local to remote"),
   2402 		       NULL, 0, &tcp_msl_remote_threshold, 0, CTL_CREATE, CTL_EOL);
   2403 
   2404 	/* vestigial TIME_WAIT tuning subtree */
   2405 
   2406 	sysctl_createv(clog, 0, NULL, &vtw_node,
   2407 		       CTLFLAG_PERMANENT, CTLTYPE_NODE, "vtw",
   2408 		       SYSCTL_DESCR("Tuning for Vestigial TIME_WAIT"),
   2409 		       NULL, 0, NULL, 0,
   2410 		       CTL_NET, pf, IPPROTO_TCP, CTL_CREATE, CTL_EOL);
   2411 	sysctl_createv(clog, 0, &vtw_node, NULL,
   2412 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2413 		       CTLTYPE_INT, "enable",
   2414 		       SYSCTL_DESCR("Enable Vestigial TIME_WAIT"),
   2415 		       sysctl_tcp_vtw_enable, 0,
   2416 	               (pf == AF_INET) ? &tcp4_vtw_enable : &tcp6_vtw_enable,
   2417 		       0, CTL_CREATE, CTL_EOL);
   2418 	sysctl_createv(clog, 0, &vtw_node, NULL,
   2419 		       CTLFLAG_PERMANENT|CTLFLAG_READONLY,
   2420 		       CTLTYPE_INT, "entries",
   2421 		       SYSCTL_DESCR("Maximum number of vestigial TIME_WAIT entries"),
   2422 		       NULL, 0, &tcp_vtw_entries, 0, CTL_CREATE, CTL_EOL);
   2423 }
   2424 
   2425 void
   2426 tcp_usrreq_init(void)
   2427 {
   2428 
   2429 	sysctl_net_inet_tcp_setup2(NULL, PF_INET, "inet", "tcp");
   2430 #ifdef INET6
   2431 	sysctl_net_inet_tcp_setup2(NULL, PF_INET6, "inet6", "tcp6");
   2432 #endif
   2433 }
   2434 
   2435 PR_WRAP_USRREQS(tcp)
   2436 #define	tcp_attach	tcp_attach_wrapper
   2437 #define	tcp_detach	tcp_detach_wrapper
   2438 #define	tcp_accept	tcp_accept_wrapper
   2439 #define	tcp_bind	tcp_bind_wrapper
   2440 #define	tcp_listen	tcp_listen_wrapper
   2441 #define	tcp_connect	tcp_connect_wrapper
   2442 #define	tcp_connect2	tcp_connect2_wrapper
   2443 #define	tcp_disconnect	tcp_disconnect_wrapper
   2444 #define	tcp_shutdown	tcp_shutdown_wrapper
   2445 #define	tcp_abort	tcp_abort_wrapper
   2446 #define	tcp_ioctl	tcp_ioctl_wrapper
   2447 #define	tcp_stat	tcp_stat_wrapper
   2448 #define	tcp_peeraddr	tcp_peeraddr_wrapper
   2449 #define	tcp_sockaddr	tcp_sockaddr_wrapper
   2450 #define	tcp_rcvd	tcp_rcvd_wrapper
   2451 #define	tcp_recvoob	tcp_recvoob_wrapper
   2452 #define	tcp_send	tcp_send_wrapper
   2453 #define	tcp_sendoob	tcp_sendoob_wrapper
   2454 #define	tcp_purgeif	tcp_purgeif_wrapper
   2455 
   2456 const struct pr_usrreqs tcp_usrreqs = {
   2457 	.pr_attach	= tcp_attach,
   2458 	.pr_detach	= tcp_detach,
   2459 	.pr_accept	= tcp_accept,
   2460 	.pr_bind	= tcp_bind,
   2461 	.pr_listen	= tcp_listen,
   2462 	.pr_connect	= tcp_connect,
   2463 	.pr_connect2	= tcp_connect2,
   2464 	.pr_disconnect	= tcp_disconnect,
   2465 	.pr_shutdown	= tcp_shutdown,
   2466 	.pr_abort	= tcp_abort,
   2467 	.pr_ioctl	= tcp_ioctl,
   2468 	.pr_stat	= tcp_stat,
   2469 	.pr_peeraddr	= tcp_peeraddr,
   2470 	.pr_sockaddr	= tcp_sockaddr,
   2471 	.pr_rcvd	= tcp_rcvd,
   2472 	.pr_recvoob	= tcp_recvoob,
   2473 	.pr_send	= tcp_send,
   2474 	.pr_sendoob	= tcp_sendoob,
   2475 	.pr_purgeif	= tcp_purgeif,
   2476 };
   2477