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