1 /* $NetBSD: tcp_usrreq.c,v 1.100.2.2 2005/05/06 08:35:27 tron 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 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 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. All advertising materials mentioning features or use of this software
51 * must display the following acknowledgement:
52 * This product includes software developed by the NetBSD
53 * Foundation, Inc. and its contributors.
54 * 4. Neither the name of The NetBSD Foundation nor the names of its
55 * contributors may be used to endorse or promote products derived
56 * from this software without specific prior written permission.
57 *
58 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
59 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
60 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
61 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
62 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
63 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
64 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
65 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
66 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
67 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
68 * POSSIBILITY OF SUCH DAMAGE.
69 */
70
71 /*
72 * Copyright (c) 1982, 1986, 1988, 1993, 1995
73 * The Regents of the University of California. All rights reserved.
74 *
75 * Redistribution and use in source and binary forms, with or without
76 * modification, are permitted provided that the following conditions
77 * are met:
78 * 1. Redistributions of source code must retain the above copyright
79 * notice, this list of conditions and the following disclaimer.
80 * 2. Redistributions in binary form must reproduce the above copyright
81 * notice, this list of conditions and the following disclaimer in the
82 * documentation and/or other materials provided with the distribution.
83 * 3. Neither the name of the University nor the names of its contributors
84 * may be used to endorse or promote products derived from this software
85 * without specific prior written permission.
86 *
87 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
88 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
89 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
90 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
91 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
92 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
93 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
94 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
95 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
96 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
97 * SUCH DAMAGE.
98 *
99 * @(#)tcp_usrreq.c 8.5 (Berkeley) 6/21/95
100 */
101
102 #include <sys/cdefs.h>
103 __KERNEL_RCSID(0, "$NetBSD: tcp_usrreq.c,v 1.100.2.2 2005/05/06 08:35:27 tron Exp $");
104
105 #include "opt_inet.h"
106 #include "opt_ipsec.h"
107 #include "opt_tcp_debug.h"
108 #include "opt_mbuftrace.h"
109
110 #include <sys/param.h>
111 #include <sys/systm.h>
112 #include <sys/kernel.h>
113 #include <sys/malloc.h>
114 #include <sys/mbuf.h>
115 #include <sys/socket.h>
116 #include <sys/socketvar.h>
117 #include <sys/protosw.h>
118 #include <sys/errno.h>
119 #include <sys/stat.h>
120 #include <sys/proc.h>
121 #include <sys/domain.h>
122 #include <sys/sysctl.h>
123
124 #include <net/if.h>
125 #include <net/route.h>
126
127 #include <netinet/in.h>
128 #include <netinet/in_systm.h>
129 #include <netinet/in_var.h>
130 #include <netinet/ip.h>
131 #include <netinet/in_pcb.h>
132 #include <netinet/ip_var.h>
133
134 #ifdef INET6
135 #ifndef INET
136 #include <netinet/in.h>
137 #endif
138 #include <netinet/ip6.h>
139 #include <netinet6/in6_pcb.h>
140 #include <netinet6/ip6_var.h>
141 #endif
142
143 #include <netinet/tcp.h>
144 #include <netinet/tcp_fsm.h>
145 #include <netinet/tcp_seq.h>
146 #include <netinet/tcp_timer.h>
147 #include <netinet/tcp_var.h>
148 #include <netinet/tcpip.h>
149 #include <netinet/tcp_debug.h>
150
151 #include "opt_tcp_space.h"
152
153 #ifdef IPSEC
154 #include <netinet6/ipsec.h>
155 #endif /*IPSEC*/
156
157 /*
158 * TCP protocol interface to socket abstraction.
159 */
160
161 /*
162 * Process a TCP user request for TCP tb. If this is a send request
163 * then m is the mbuf chain of send data. If this is a timer expiration
164 * (called from the software clock routine), then timertype tells which timer.
165 */
166 /*ARGSUSED*/
167 int
168 tcp_usrreq(struct socket *so, int req,
169 struct mbuf *m, struct mbuf *nam, struct mbuf *control, struct proc *p)
170 {
171 struct inpcb *inp;
172 #ifdef INET6
173 struct in6pcb *in6p;
174 #endif
175 struct tcpcb *tp = NULL;
176 int s;
177 int error = 0;
178 #ifdef TCP_DEBUG
179 int ostate = 0;
180 #endif
181 int family; /* family of the socket */
182
183 family = so->so_proto->pr_domain->dom_family;
184
185 if (req == PRU_CONTROL) {
186 switch (family) {
187 #ifdef INET
188 case PF_INET:
189 return (in_control(so, (long)m, (caddr_t)nam,
190 (struct ifnet *)control, p));
191 #endif
192 #ifdef INET6
193 case PF_INET6:
194 return (in6_control(so, (long)m, (caddr_t)nam,
195 (struct ifnet *)control, p));
196 #endif
197 default:
198 return EAFNOSUPPORT;
199 }
200 }
201
202 if (req == PRU_PURGEIF) {
203 switch (family) {
204 #ifdef INET
205 case PF_INET:
206 in_pcbpurgeif0(&tcbtable, (struct ifnet *)control);
207 in_purgeif((struct ifnet *)control);
208 in_pcbpurgeif(&tcbtable, (struct ifnet *)control);
209 break;
210 #endif
211 #ifdef INET6
212 case PF_INET6:
213 in6_pcbpurgeif0(&tcbtable, (struct ifnet *)control);
214 in6_purgeif((struct ifnet *)control);
215 in6_pcbpurgeif(&tcbtable, (struct ifnet *)control);
216 break;
217 #endif
218 default:
219 return (EAFNOSUPPORT);
220 }
221 return (0);
222 }
223
224 s = splsoftnet();
225 switch (family) {
226 #ifdef INET
227 case PF_INET:
228 inp = sotoinpcb(so);
229 #ifdef INET6
230 in6p = NULL;
231 #endif
232 break;
233 #endif
234 #ifdef INET6
235 case PF_INET6:
236 inp = NULL;
237 in6p = sotoin6pcb(so);
238 break;
239 #endif
240 default:
241 splx(s);
242 return EAFNOSUPPORT;
243 }
244
245 #ifdef DIAGNOSTIC
246 #ifdef INET6
247 if (inp && in6p)
248 panic("tcp_usrreq: both inp and in6p set to non-NULL");
249 #endif
250 if (req != PRU_SEND && req != PRU_SENDOOB && control)
251 panic("tcp_usrreq: unexpected control mbuf");
252 #endif
253 /*
254 * When a TCP is attached to a socket, then there will be
255 * a (struct inpcb) pointed at by the socket, and this
256 * structure will point at a subsidary (struct tcpcb).
257 */
258 #ifndef INET6
259 if (inp == 0 && req != PRU_ATTACH)
260 #else
261 if ((inp == 0 && in6p == 0) && req != PRU_ATTACH)
262 #endif
263 {
264 error = EINVAL;
265 goto release;
266 }
267 #ifdef INET
268 if (inp) {
269 tp = intotcpcb(inp);
270 /* WHAT IF TP IS 0? */
271 #ifdef KPROF
272 tcp_acounts[tp->t_state][req]++;
273 #endif
274 #ifdef TCP_DEBUG
275 ostate = tp->t_state;
276 #endif
277 }
278 #endif
279 #ifdef INET6
280 if (in6p) {
281 tp = in6totcpcb(in6p);
282 /* WHAT IF TP IS 0? */
283 #ifdef KPROF
284 tcp_acounts[tp->t_state][req]++;
285 #endif
286 #ifdef TCP_DEBUG
287 ostate = tp->t_state;
288 #endif
289 }
290 #endif
291
292 switch (req) {
293
294 /*
295 * TCP attaches to socket via PRU_ATTACH, reserving space,
296 * and an internet control block.
297 */
298 case PRU_ATTACH:
299 #ifndef INET6
300 if (inp != 0)
301 #else
302 if (inp != 0 || in6p != 0)
303 #endif
304 {
305 error = EISCONN;
306 break;
307 }
308 error = tcp_attach(so);
309 if (error)
310 break;
311 if ((so->so_options & SO_LINGER) && so->so_linger == 0)
312 so->so_linger = TCP_LINGERTIME;
313 tp = sototcpcb(so);
314 break;
315
316 /*
317 * PRU_DETACH detaches the TCP protocol from the socket.
318 */
319 case PRU_DETACH:
320 tp = tcp_disconnect(tp);
321 break;
322
323 /*
324 * Give the socket an address.
325 */
326 case PRU_BIND:
327 switch (family) {
328 #ifdef INET
329 case PF_INET:
330 error = in_pcbbind(inp, nam, p);
331 break;
332 #endif
333 #ifdef INET6
334 case PF_INET6:
335 error = in6_pcbbind(in6p, nam, p);
336 if (!error) {
337 /* mapped addr case */
338 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr))
339 tp->t_family = AF_INET;
340 else
341 tp->t_family = AF_INET6;
342 }
343 break;
344 #endif
345 }
346 break;
347
348 /*
349 * Prepare to accept connections.
350 */
351 case PRU_LISTEN:
352 #ifdef INET
353 if (inp && inp->inp_lport == 0) {
354 error = in_pcbbind(inp, (struct mbuf *)0,
355 (struct proc *)0);
356 if (error)
357 break;
358 }
359 #endif
360 #ifdef INET6
361 if (in6p && in6p->in6p_lport == 0) {
362 error = in6_pcbbind(in6p, (struct mbuf *)0,
363 (struct proc *)0);
364 if (error)
365 break;
366 }
367 #endif
368 tp->t_state = TCPS_LISTEN;
369 break;
370
371 /*
372 * Initiate connection to peer.
373 * Create a template for use in transmissions on this connection.
374 * Enter SYN_SENT state, and mark socket as connecting.
375 * Start keep-alive timer, and seed output sequence space.
376 * Send initial segment on connection.
377 */
378 case PRU_CONNECT:
379 #ifdef INET
380 if (inp) {
381 if (inp->inp_lport == 0) {
382 error = in_pcbbind(inp, (struct mbuf *)0,
383 (struct proc *)0);
384 if (error)
385 break;
386 }
387 error = in_pcbconnect(inp, nam);
388 }
389 #endif
390 #ifdef INET6
391 if (in6p) {
392 if (in6p->in6p_lport == 0) {
393 error = in6_pcbbind(in6p, (struct mbuf *)0,
394 (struct proc *)0);
395 if (error)
396 break;
397 }
398 error = in6_pcbconnect(in6p, nam);
399 if (!error) {
400 /* mapped addr case */
401 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr))
402 tp->t_family = AF_INET;
403 else
404 tp->t_family = AF_INET6;
405 }
406 }
407 #endif
408 if (error)
409 break;
410 tp->t_template = tcp_template(tp);
411 if (tp->t_template == 0) {
412 #ifdef INET
413 if (inp)
414 in_pcbdisconnect(inp);
415 #endif
416 #ifdef INET6
417 if (in6p)
418 in6_pcbdisconnect(in6p);
419 #endif
420 error = ENOBUFS;
421 break;
422 }
423 /* Compute window scaling to request. */
424 while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
425 (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
426 tp->request_r_scale++;
427 soisconnecting(so);
428 tcpstat.tcps_connattempt++;
429 tp->t_state = TCPS_SYN_SENT;
430 TCP_TIMER_ARM(tp, TCPT_KEEP, TCPTV_KEEP_INIT);
431 tp->iss = tcp_new_iss(tp, 0);
432 tcp_sendseqinit(tp);
433 error = tcp_output(tp);
434 break;
435
436 /*
437 * Create a TCP connection between two sockets.
438 */
439 case PRU_CONNECT2:
440 error = EOPNOTSUPP;
441 break;
442
443 /*
444 * Initiate disconnect from peer.
445 * If connection never passed embryonic stage, just drop;
446 * else if don't need to let data drain, then can just drop anyways,
447 * else have to begin TCP shutdown process: mark socket disconnecting,
448 * drain unread data, state switch to reflect user close, and
449 * send segment (e.g. FIN) to peer. Socket will be really disconnected
450 * when peer sends FIN and acks ours.
451 *
452 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
453 */
454 case PRU_DISCONNECT:
455 tp = tcp_disconnect(tp);
456 break;
457
458 /*
459 * Accept a connection. Essentially all the work is
460 * done at higher levels; just return the address
461 * of the peer, storing through addr.
462 */
463 case PRU_ACCEPT:
464 #ifdef INET
465 if (inp)
466 in_setpeeraddr(inp, nam);
467 #endif
468 #ifdef INET6
469 if (in6p)
470 in6_setpeeraddr(in6p, nam);
471 #endif
472 break;
473
474 /*
475 * Mark the connection as being incapable of further output.
476 */
477 case PRU_SHUTDOWN:
478 socantsendmore(so);
479 tp = tcp_usrclosed(tp);
480 if (tp)
481 error = tcp_output(tp);
482 break;
483
484 /*
485 * After a receive, possibly send window update to peer.
486 */
487 case PRU_RCVD:
488 /*
489 * soreceive() calls this function when a user receives
490 * ancillary data on a listening socket. We don't call
491 * tcp_output in such a case, since there is no header
492 * template for a listening socket and hence the kernel
493 * will panic.
494 */
495 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) != 0)
496 (void) tcp_output(tp);
497 break;
498
499 /*
500 * Do a send by putting data in output queue and updating urgent
501 * marker if URG set. Possibly send more data.
502 */
503 case PRU_SEND:
504 if (control && control->m_len) {
505 m_freem(control);
506 m_freem(m);
507 error = EINVAL;
508 break;
509 }
510 sbappendstream(&so->so_snd, m);
511 error = tcp_output(tp);
512 break;
513
514 /*
515 * Abort the TCP.
516 */
517 case PRU_ABORT:
518 tp = tcp_drop(tp, ECONNABORTED);
519 break;
520
521 case PRU_SENSE:
522 /*
523 * stat: don't bother with a blocksize.
524 */
525 splx(s);
526 return (0);
527
528 case PRU_RCVOOB:
529 if (control && control->m_len) {
530 m_freem(control);
531 m_freem(m);
532 error = EINVAL;
533 break;
534 }
535 if ((so->so_oobmark == 0 &&
536 (so->so_state & SS_RCVATMARK) == 0) ||
537 so->so_options & SO_OOBINLINE ||
538 tp->t_oobflags & TCPOOB_HADDATA) {
539 error = EINVAL;
540 break;
541 }
542 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
543 error = EWOULDBLOCK;
544 break;
545 }
546 m->m_len = 1;
547 *mtod(m, caddr_t) = tp->t_iobc;
548 if (((long)nam & MSG_PEEK) == 0)
549 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
550 break;
551
552 case PRU_SENDOOB:
553 if (sbspace(&so->so_snd) < -512) {
554 m_freem(m);
555 error = ENOBUFS;
556 break;
557 }
558 /*
559 * According to RFC961 (Assigned Protocols),
560 * the urgent pointer points to the last octet
561 * of urgent data. We continue, however,
562 * to consider it to indicate the first octet
563 * of data past the urgent section.
564 * Otherwise, snd_up should be one lower.
565 */
566 sbappendstream(&so->so_snd, m);
567 tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
568 tp->t_force = 1;
569 error = tcp_output(tp);
570 tp->t_force = 0;
571 break;
572
573 case PRU_SOCKADDR:
574 #ifdef INET
575 if (inp)
576 in_setsockaddr(inp, nam);
577 #endif
578 #ifdef INET6
579 if (in6p)
580 in6_setsockaddr(in6p, nam);
581 #endif
582 break;
583
584 case PRU_PEERADDR:
585 #ifdef INET
586 if (inp)
587 in_setpeeraddr(inp, nam);
588 #endif
589 #ifdef INET6
590 if (in6p)
591 in6_setpeeraddr(in6p, nam);
592 #endif
593 break;
594
595 default:
596 panic("tcp_usrreq");
597 }
598 #ifdef TCP_DEBUG
599 if (tp && (so->so_options & SO_DEBUG))
600 tcp_trace(TA_USER, ostate, tp, NULL, req);
601 #endif
602
603 release:
604 splx(s);
605 return (error);
606 }
607
608 int
609 tcp_ctloutput(int op, struct socket *so, int level, int optname,
610 struct mbuf **mp)
611 {
612 int error = 0, s;
613 struct inpcb *inp;
614 #ifdef INET6
615 struct in6pcb *in6p;
616 #endif
617 struct tcpcb *tp;
618 struct mbuf *m;
619 int i;
620 int family; /* family of the socket */
621
622 family = so->so_proto->pr_domain->dom_family;
623
624 s = splsoftnet();
625 switch (family) {
626 #ifdef INET
627 case PF_INET:
628 inp = sotoinpcb(so);
629 #ifdef INET6
630 in6p = NULL;
631 #endif
632 break;
633 #endif
634 #ifdef INET6
635 case PF_INET6:
636 inp = NULL;
637 in6p = sotoin6pcb(so);
638 break;
639 #endif
640 default:
641 splx(s);
642 return EAFNOSUPPORT;
643 }
644 #ifndef INET6
645 if (inp == NULL)
646 #else
647 if (inp == NULL && in6p == NULL)
648 #endif
649 {
650 splx(s);
651 if (op == PRCO_SETOPT && *mp)
652 (void) m_free(*mp);
653 return (ECONNRESET);
654 }
655 if (level != IPPROTO_TCP) {
656 switch (family) {
657 #ifdef INET
658 case PF_INET:
659 error = ip_ctloutput(op, so, level, optname, mp);
660 break;
661 #endif
662 #ifdef INET6
663 case PF_INET6:
664 error = ip6_ctloutput(op, so, level, optname, mp);
665 break;
666 #endif
667 }
668 splx(s);
669 return (error);
670 }
671 if (inp)
672 tp = intotcpcb(inp);
673 #ifdef INET6
674 else if (in6p)
675 tp = in6totcpcb(in6p);
676 #endif
677 else
678 tp = NULL;
679
680 switch (op) {
681
682 case PRCO_SETOPT:
683 m = *mp;
684 switch (optname) {
685
686 #ifdef TCP_SIGNATURE
687 case TCP_MD5SIG:
688 if (m == NULL || m->m_len < sizeof (int))
689 error = EINVAL;
690 if (error)
691 break;
692 if (*mtod(m, int *) > 0)
693 tp->t_flags |= TF_SIGNATURE;
694 else
695 tp->t_flags &= ~TF_SIGNATURE;
696 break;
697 #endif /* TCP_SIGNATURE */
698
699 case TCP_NODELAY:
700 if (m == NULL || m->m_len < sizeof (int))
701 error = EINVAL;
702 else if (*mtod(m, int *))
703 tp->t_flags |= TF_NODELAY;
704 else
705 tp->t_flags &= ~TF_NODELAY;
706 break;
707
708 case TCP_MAXSEG:
709 if (m && (i = *mtod(m, int *)) > 0 &&
710 i <= tp->t_peermss)
711 tp->t_peermss = i; /* limit on send size */
712 else
713 error = EINVAL;
714 break;
715
716 default:
717 error = ENOPROTOOPT;
718 break;
719 }
720 if (m)
721 (void) m_free(m);
722 break;
723
724 case PRCO_GETOPT:
725 *mp = m = m_get(M_WAIT, MT_SOOPTS);
726 m->m_len = sizeof(int);
727 MCLAIM(m, so->so_mowner);
728
729 switch (optname) {
730 #ifdef TCP_SIGNATURE
731 case TCP_MD5SIG:
732 *mtod(m, int *) = (tp->t_flags & TF_SIGNATURE) ? 1 : 0;
733 break;
734 #endif
735 case TCP_NODELAY:
736 *mtod(m, int *) = tp->t_flags & TF_NODELAY;
737 break;
738 case TCP_MAXSEG:
739 *mtod(m, int *) = tp->t_peermss;
740 break;
741 default:
742 error = ENOPROTOOPT;
743 break;
744 }
745 break;
746 }
747 splx(s);
748 return (error);
749 }
750
751 #ifndef TCP_SENDSPACE
752 #define TCP_SENDSPACE 1024*32
753 #endif
754 int tcp_sendspace = TCP_SENDSPACE;
755 #ifndef TCP_RECVSPACE
756 #define TCP_RECVSPACE 1024*32
757 #endif
758 int tcp_recvspace = TCP_RECVSPACE;
759
760 /*
761 * Attach TCP protocol to socket, allocating
762 * internet protocol control block, tcp control block,
763 * bufer space, and entering LISTEN state if to accept connections.
764 */
765 int
766 tcp_attach(struct socket *so)
767 {
768 struct tcpcb *tp;
769 struct inpcb *inp;
770 #ifdef INET6
771 struct in6pcb *in6p;
772 #endif
773 int error;
774 int family; /* family of the socket */
775
776 family = so->so_proto->pr_domain->dom_family;
777
778 #ifdef MBUFTRACE
779 so->so_mowner = &tcp_mowner;
780 so->so_rcv.sb_mowner = &tcp_rx_mowner;
781 so->so_snd.sb_mowner = &tcp_tx_mowner;
782 #endif
783 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
784 error = soreserve(so, tcp_sendspace, tcp_recvspace);
785 if (error)
786 return (error);
787 }
788 switch (family) {
789 #ifdef INET
790 case PF_INET:
791 error = in_pcballoc(so, &tcbtable);
792 if (error)
793 return (error);
794 inp = sotoinpcb(so);
795 #ifdef INET6
796 in6p = NULL;
797 #endif
798 break;
799 #endif
800 #ifdef INET6
801 case PF_INET6:
802 error = in6_pcballoc(so, &tcbtable);
803 if (error)
804 return (error);
805 inp = NULL;
806 in6p = sotoin6pcb(so);
807 break;
808 #endif
809 default:
810 return EAFNOSUPPORT;
811 }
812 if (inp)
813 tp = tcp_newtcpcb(family, (void *)inp);
814 #ifdef INET6
815 else if (in6p)
816 tp = tcp_newtcpcb(family, (void *)in6p);
817 #endif
818 else
819 tp = NULL;
820
821 if (tp == 0) {
822 int nofd = so->so_state & SS_NOFDREF; /* XXX */
823
824 so->so_state &= ~SS_NOFDREF; /* don't free the socket yet */
825 #ifdef INET
826 if (inp)
827 in_pcbdetach(inp);
828 #endif
829 #ifdef INET6
830 if (in6p)
831 in6_pcbdetach(in6p);
832 #endif
833 so->so_state |= nofd;
834 return (ENOBUFS);
835 }
836 tp->t_state = TCPS_CLOSED;
837 return (0);
838 }
839
840 /*
841 * Initiate (or continue) disconnect.
842 * If embryonic state, just send reset (once).
843 * If in ``let data drain'' option and linger null, just drop.
844 * Otherwise (hard), mark socket disconnecting and drop
845 * current input data; switch states based on user close, and
846 * send segment to peer (with FIN).
847 */
848 struct tcpcb *
849 tcp_disconnect(struct tcpcb *tp)
850 {
851 struct socket *so;
852
853 if (tp->t_inpcb)
854 so = tp->t_inpcb->inp_socket;
855 #ifdef INET6
856 else if (tp->t_in6pcb)
857 so = tp->t_in6pcb->in6p_socket;
858 #endif
859 else
860 so = NULL;
861
862 if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
863 tp = tcp_close(tp);
864 else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
865 tp = tcp_drop(tp, 0);
866 else {
867 soisdisconnecting(so);
868 sbflush(&so->so_rcv);
869 tp = tcp_usrclosed(tp);
870 if (tp)
871 (void) tcp_output(tp);
872 }
873 return (tp);
874 }
875
876 /*
877 * User issued close, and wish to trail through shutdown states:
878 * if never received SYN, just forget it. If got a SYN from peer,
879 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
880 * If already got a FIN from peer, then almost done; go to LAST_ACK
881 * state. In all other cases, have already sent FIN to peer (e.g.
882 * after PRU_SHUTDOWN), and just have to play tedious game waiting
883 * for peer to send FIN or not respond to keep-alives, etc.
884 * We can let the user exit from the close as soon as the FIN is acked.
885 */
886 struct tcpcb *
887 tcp_usrclosed(struct tcpcb *tp)
888 {
889
890 switch (tp->t_state) {
891
892 case TCPS_CLOSED:
893 case TCPS_LISTEN:
894 case TCPS_SYN_SENT:
895 tp->t_state = TCPS_CLOSED;
896 tp = tcp_close(tp);
897 break;
898
899 case TCPS_SYN_RECEIVED:
900 case TCPS_ESTABLISHED:
901 tp->t_state = TCPS_FIN_WAIT_1;
902 break;
903
904 case TCPS_CLOSE_WAIT:
905 tp->t_state = TCPS_LAST_ACK;
906 break;
907 }
908 if (tp && tp->t_state >= TCPS_FIN_WAIT_2) {
909 struct socket *so;
910 if (tp->t_inpcb)
911 so = tp->t_inpcb->inp_socket;
912 #ifdef INET6
913 else if (tp->t_in6pcb)
914 so = tp->t_in6pcb->in6p_socket;
915 #endif
916 else
917 so = NULL;
918 soisdisconnected(so);
919 /*
920 * If we are in FIN_WAIT_2, we arrived here because the
921 * application did a shutdown of the send side. Like the
922 * case of a transition from FIN_WAIT_1 to FIN_WAIT_2 after
923 * a full close, we start a timer to make sure sockets are
924 * not left in FIN_WAIT_2 forever.
925 */
926 if ((tp->t_state == TCPS_FIN_WAIT_2) && (tcp_maxidle > 0))
927 TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_maxidle);
928 }
929 return (tp);
930 }
931
932 /*
933 * sysctl helper routine for net.inet.ip.mssdflt. it can't be less
934 * than 32.
935 */
936 static int
937 sysctl_net_inet_tcp_mssdflt(SYSCTLFN_ARGS)
938 {
939 int error, mssdflt;
940 struct sysctlnode node;
941
942 mssdflt = tcp_mssdflt;
943 node = *rnode;
944 node.sysctl_data = &mssdflt;
945 error = sysctl_lookup(SYSCTLFN_CALL(&node));
946 if (error || newp == NULL)
947 return (error);
948
949 if (mssdflt < 32)
950 return (EINVAL);
951 tcp_mssdflt = mssdflt;
952
953 return (0);
954 }
955
956 /*
957 * sysctl helper routine for setting port related values under
958 * net.inet.ip and net.inet6.ip6. does basic range checking and does
959 * additional checks for each type. this code has placed in
960 * tcp_input.c since INET and INET6 both use the same tcp code.
961 *
962 * this helper is not static so that both inet and inet6 can use it.
963 */
964 int
965 sysctl_net_inet_ip_ports(SYSCTLFN_ARGS)
966 {
967 int error, tmp;
968 int apmin, apmax;
969 #ifndef IPNOPRIVPORTS
970 int lpmin, lpmax;
971 #endif /* IPNOPRIVPORTS */
972 struct sysctlnode node;
973
974 if (namelen != 0)
975 return (EINVAL);
976
977 switch (name[-3]) {
978 #ifdef INET
979 case PF_INET:
980 apmin = anonportmin;
981 apmax = anonportmax;
982 #ifndef IPNOPRIVPORTS
983 lpmin = lowportmin;
984 lpmax = lowportmax;
985 #endif /* IPNOPRIVPORTS */
986 break;
987 #endif /* INET */
988 #ifdef INET6
989 case PF_INET6:
990 apmin = ip6_anonportmin;
991 apmax = ip6_anonportmax;
992 #ifndef IPNOPRIVPORTS
993 lpmin = ip6_lowportmin;
994 lpmax = ip6_lowportmax;
995 #endif /* IPNOPRIVPORTS */
996 break;
997 #endif /* INET6 */
998 default:
999 return (EINVAL);
1000 }
1001
1002 /*
1003 * insert temporary copy into node, perform lookup on
1004 * temporary, then restore pointer
1005 */
1006 node = *rnode;
1007 tmp = *(int*)rnode->sysctl_data;
1008 node.sysctl_data = &tmp;
1009 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1010 if (error || newp == NULL)
1011 return (error);
1012
1013 /*
1014 * simple port range check
1015 */
1016 if (tmp < 0 || tmp > 65535)
1017 return (EINVAL);
1018
1019 /*
1020 * per-node range checks
1021 */
1022 switch (rnode->sysctl_num) {
1023 case IPCTL_ANONPORTMIN:
1024 if (tmp >= apmax)
1025 return (EINVAL);
1026 #ifndef IPNOPRIVPORTS
1027 if (tmp < IPPORT_RESERVED)
1028 return (EINVAL);
1029 #endif /* IPNOPRIVPORTS */
1030 break;
1031
1032 case IPCTL_ANONPORTMAX:
1033 if (apmin >= tmp)
1034 return (EINVAL);
1035 #ifndef IPNOPRIVPORTS
1036 if (tmp < IPPORT_RESERVED)
1037 return (EINVAL);
1038 #endif /* IPNOPRIVPORTS */
1039 break;
1040
1041 #ifndef IPNOPRIVPORTS
1042 case IPCTL_LOWPORTMIN:
1043 if (tmp >= lpmax ||
1044 tmp > IPPORT_RESERVEDMAX ||
1045 tmp < IPPORT_RESERVEDMIN)
1046 return (EINVAL);
1047 break;
1048
1049 case IPCTL_LOWPORTMAX:
1050 if (lpmin >= tmp ||
1051 tmp > IPPORT_RESERVEDMAX ||
1052 tmp < IPPORT_RESERVEDMIN)
1053 return (EINVAL);
1054 break;
1055 #endif /* IPNOPRIVPORTS */
1056
1057 default:
1058 return (EINVAL);
1059 }
1060
1061 *(int*)rnode->sysctl_data = tmp;
1062
1063 return (0);
1064 }
1065
1066 /*
1067 * sysctl helper routine for the net.inet.tcp.ident and
1068 * net.inet6.tcp6.ident nodes. contains backwards compat code for the
1069 * old way of looking up the ident information for ipv4 which involves
1070 * stuffing the port/addr pairs into the mib lookup.
1071 */
1072 static int
1073 sysctl_net_inet_tcp_ident(SYSCTLFN_ARGS)
1074 {
1075 #ifdef INET
1076 struct inpcb *inb;
1077 struct sockaddr_in *si4[2];
1078 #endif /* INET */
1079 #ifdef INET6
1080 struct in6pcb *in6b;
1081 struct sockaddr_in6 *si6[2];
1082 #endif /* INET6 */
1083 struct sockaddr_storage sa[2];
1084 struct socket *sockp;
1085 size_t sz;
1086 uid_t uid;
1087 int error, pf;
1088
1089 if (namelen != 4 && namelen != 0)
1090 return (EINVAL);
1091 if (name[-2] != IPPROTO_TCP)
1092 return (EINVAL);
1093 pf = name[-3];
1094
1095 /* old style lookup, ipv4 only */
1096 if (namelen == 4) {
1097 #ifdef INET
1098 struct in_addr laddr, raddr;
1099 u_int lport, rport;
1100
1101 if (pf != PF_INET)
1102 return (EPROTONOSUPPORT);
1103 raddr.s_addr = (uint32_t)name[0];
1104 rport = (u_int)name[1];
1105 laddr.s_addr = (uint32_t)name[2];
1106 lport = (u_int)name[3];
1107 inb = in_pcblookup_connect(&tcbtable, raddr, rport,
1108 laddr, lport);
1109 if (inb == NULL || (sockp = inb->inp_socket) == NULL)
1110 return (ESRCH);
1111 uid = sockp->so_uid;
1112 if (oldp) {
1113 sz = MIN(sizeof(uid), *oldlenp);
1114 error = copyout(&uid, oldp, sz);
1115 if (error)
1116 return (error);
1117 }
1118 *oldlenp = sizeof(uid);
1119 return (0);
1120 #else /* INET */
1121 return (EINVAL);
1122 #endif /* INET */
1123 }
1124
1125 if (newp == NULL || newlen != sizeof(sa))
1126 return (EINVAL);
1127 error = copyin(newp, &sa, newlen);
1128 if (error)
1129 return (error);
1130
1131 /*
1132 * requested families must match
1133 */
1134 if (pf != sa[0].ss_family || sa[0].ss_family != sa[1].ss_family)
1135 return (EINVAL);
1136
1137 switch (pf) {
1138 #ifdef INET
1139 case PF_INET:
1140 si4[0] = (struct sockaddr_in*)&sa[0];
1141 si4[1] = (struct sockaddr_in*)&sa[1];
1142 if (si4[0]->sin_len != sizeof(*si4[0]) ||
1143 si4[0]->sin_len != si4[1]->sin_len)
1144 return (EINVAL);
1145 inb = in_pcblookup_connect(&tcbtable,
1146 si4[0]->sin_addr, si4[0]->sin_port,
1147 si4[1]->sin_addr, si4[1]->sin_port);
1148 if (inb == NULL || (sockp = inb->inp_socket) == NULL)
1149 return (ESRCH);
1150 break;
1151 #endif /* INET */
1152 #ifdef INET6
1153 case PF_INET6:
1154 si6[0] = (struct sockaddr_in6*)&sa[0];
1155 si6[1] = (struct sockaddr_in6*)&sa[1];
1156 if (si6[0]->sin6_len != sizeof(*si6[0]) ||
1157 si6[0]->sin6_len != si6[1]->sin6_len)
1158 return (EINVAL);
1159 in6b = in6_pcblookup_connect(&tcbtable,
1160 &si6[0]->sin6_addr, si6[0]->sin6_port,
1161 &si6[1]->sin6_addr, si6[1]->sin6_port, 0);
1162 if (in6b == NULL || (sockp = in6b->in6p_socket) == NULL)
1163 return (ESRCH);
1164 break;
1165 #endif /* INET6 */
1166 default:
1167 return (EPROTONOSUPPORT);
1168 }
1169
1170 uid = sockp->so_uid;
1171 if (oldp) {
1172 sz = MIN(sizeof(uid), *oldlenp);
1173 error = copyout(&uid, oldp, sz);
1174 if (error)
1175 return (error);
1176 }
1177 *oldlenp = sizeof(uid);
1178
1179 return (0);
1180 }
1181
1182 /*
1183 * sysctl helper for the inet and inet6 pcblists. handles tcp/udp and
1184 * inet/inet6, as well as raw pcbs for each. specifically not
1185 * declared static so that raw sockets and udp/udp6 can use it as
1186 * well.
1187 */
1188 int
1189 sysctl_inpcblist(SYSCTLFN_ARGS)
1190 {
1191 #ifdef INET
1192 struct sockaddr_in *in;
1193 struct inpcb *inp;
1194 #endif
1195 #ifdef INET6
1196 struct sockaddr_in6 *in6;
1197 struct in6pcb *in6p;
1198 #endif
1199 const struct inpcbtable *pcbtbl = rnode->sysctl_data;
1200 struct inpcb_hdr *inph;
1201 struct tcpcb *tp;
1202 struct kinfo_pcb pcb;
1203 char *dp;
1204 u_int op, arg;
1205 size_t len, needed, elem_size, out_size;
1206 int error, elem_count, pf, proto, pf2;
1207
1208 if (namelen != 4)
1209 return (EINVAL);
1210
1211 error = 0;
1212 dp = oldp;
1213 len = (oldp != NULL) ? *oldlenp : 0;
1214 op = name[0];
1215 arg = name[1];
1216 elem_size = name[2];
1217 elem_count = name[3];
1218 out_size = MIN(sizeof(pcb), elem_size);
1219 needed = 0;
1220
1221 elem_count = INT_MAX;
1222 elem_size = out_size = sizeof(pcb);
1223
1224 if (namelen == 1 && name[0] == CTL_QUERY)
1225 return (sysctl_query(SYSCTLFN_CALL(rnode)));
1226
1227 if (name - oname != 4)
1228 return (EINVAL);
1229
1230 pf = oname[1];
1231 proto = oname[2];
1232 pf2 = (oldp == NULL) ? 0 : pf;
1233
1234 CIRCLEQ_FOREACH(inph, &pcbtbl->inpt_queue, inph_queue) {
1235 #ifdef INET
1236 inp = (struct inpcb *)inph;
1237 #endif
1238 #ifdef INET6
1239 in6p = (struct in6pcb *)inph;
1240 #endif
1241
1242 if (inph->inph_af != pf)
1243 continue;
1244
1245 memset(&pcb, 0, sizeof(pcb));
1246
1247 pcb.ki_family = pf;
1248 pcb.ki_type = proto;
1249
1250 switch (pf2) {
1251 case 0:
1252 /* just probing for size */
1253 break;
1254 #ifdef INET
1255 case PF_INET:
1256 pcb.ki_family = inp->inp_socket->so_proto->
1257 pr_domain->dom_family;
1258 pcb.ki_type = inp->inp_socket->so_proto->
1259 pr_type;
1260 pcb.ki_protocol = inp->inp_socket->so_proto->
1261 pr_protocol;
1262 pcb.ki_pflags = inp->inp_flags;
1263
1264 pcb.ki_sostate = inp->inp_socket->so_state;
1265 pcb.ki_prstate = inp->inp_state;
1266 if (proto == IPPROTO_TCP) {
1267 tp = intotcpcb(inp);
1268 pcb.ki_tstate = tp->t_state;
1269 pcb.ki_tflags = tp->t_flags;
1270 }
1271
1272 pcb.ki_pcbaddr = PTRTOUINT64(inp);
1273 pcb.ki_ppcbaddr = PTRTOUINT64(inp->inp_ppcb);
1274 pcb.ki_sockaddr = PTRTOUINT64(inp->inp_socket);
1275
1276 pcb.ki_rcvq = inp->inp_socket->so_rcv.sb_cc;
1277 pcb.ki_sndq = inp->inp_socket->so_snd.sb_cc;
1278
1279 in = satosin(&pcb.ki_src);
1280 in->sin_len = sizeof(*in);
1281 in->sin_family = pf;
1282 in->sin_port = inp->inp_lport;
1283 in->sin_addr = inp->inp_laddr;
1284 if (pcb.ki_prstate >= INP_CONNECTED) {
1285 in = satosin(&pcb.ki_dst);
1286 in->sin_len = sizeof(*in);
1287 in->sin_family = pf;
1288 in->sin_port = inp->inp_fport;
1289 in->sin_addr = inp->inp_faddr;
1290 }
1291 break;
1292 #endif
1293 #ifdef INET6
1294 case PF_INET6:
1295 pcb.ki_family = in6p->in6p_socket->so_proto->
1296 pr_domain->dom_family;
1297 pcb.ki_type = in6p->in6p_socket->so_proto->pr_type;
1298 pcb.ki_protocol = in6p->in6p_socket->so_proto->
1299 pr_protocol;
1300 pcb.ki_pflags = in6p->in6p_flags;
1301
1302 pcb.ki_sostate = in6p->in6p_socket->so_state;
1303 pcb.ki_prstate = in6p->in6p_state;
1304 if (proto == IPPROTO_TCP) {
1305 tp = in6totcpcb(in6p);
1306 pcb.ki_tstate = tp->t_state;
1307 pcb.ki_tflags = tp->t_flags;
1308 }
1309
1310 pcb.ki_pcbaddr = PTRTOUINT64(in6p);
1311 pcb.ki_ppcbaddr = PTRTOUINT64(in6p->in6p_ppcb);
1312 pcb.ki_sockaddr = PTRTOUINT64(in6p->in6p_socket);
1313
1314 pcb.ki_rcvq = in6p->in6p_socket->so_rcv.sb_cc;
1315 pcb.ki_sndq = in6p->in6p_socket->so_snd.sb_cc;
1316
1317 in6 = satosin6(&pcb.ki_src);
1318 in6->sin6_len = sizeof(*in6);
1319 in6->sin6_family = pf;
1320 in6->sin6_port = in6p->in6p_lport;
1321 in6->sin6_flowinfo = in6p->in6p_flowinfo;
1322 in6->sin6_addr = in6p->in6p_laddr;
1323 in6->sin6_scope_id = 0; /* XXX? */
1324
1325 if (pcb.ki_prstate >= IN6P_CONNECTED) {
1326 in6 = satosin6(&pcb.ki_dst);
1327 in6->sin6_len = sizeof(*in6);
1328 in6->sin6_family = pf;
1329 in6->sin6_port = in6p->in6p_fport;
1330 in6->sin6_flowinfo = in6p->in6p_flowinfo;
1331 in6->sin6_addr = in6p->in6p_faddr;
1332 in6->sin6_scope_id = 0; /* XXX? */
1333 }
1334 break;
1335 #endif
1336 }
1337
1338 if (len >= elem_size && elem_count > 0) {
1339 error = copyout(&pcb, dp, out_size);
1340 if (error)
1341 return (error);
1342 dp += elem_size;
1343 len -= elem_size;
1344 }
1345 if (elem_count > 0) {
1346 needed += elem_size;
1347 if (elem_count != INT_MAX)
1348 elem_count--;
1349 }
1350 }
1351
1352 *oldlenp = needed;
1353 if (oldp == NULL)
1354 *oldlenp += PCB_SLOP * sizeof(struct kinfo_pcb);
1355
1356 return (error);
1357 }
1358
1359 /*
1360 * this (second stage) setup routine is a replacement for tcp_sysctl()
1361 * (which is currently used for ipv4 and ipv6)
1362 */
1363 static void
1364 sysctl_net_inet_tcp_setup2(struct sysctllog **clog, int pf, const char *pfname,
1365 const char *tcpname)
1366 {
1367 struct sysctlnode *sack_node;
1368
1369 sysctl_createv(clog, 0, NULL, NULL,
1370 CTLFLAG_PERMANENT,
1371 CTLTYPE_NODE, "net", NULL,
1372 NULL, 0, NULL, 0,
1373 CTL_NET, CTL_EOL);
1374 sysctl_createv(clog, 0, NULL, NULL,
1375 CTLFLAG_PERMANENT,
1376 CTLTYPE_NODE, pfname, NULL,
1377 NULL, 0, NULL, 0,
1378 CTL_NET, pf, CTL_EOL);
1379 sysctl_createv(clog, 0, NULL, NULL,
1380 CTLFLAG_PERMANENT,
1381 CTLTYPE_NODE, tcpname,
1382 SYSCTL_DESCR("TCP related settings"),
1383 NULL, 0, NULL, 0,
1384 CTL_NET, pf, IPPROTO_TCP, CTL_EOL);
1385
1386 sysctl_createv(clog, 0, NULL, NULL,
1387 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1388 CTLTYPE_INT, "rfc1323",
1389 SYSCTL_DESCR("Enable RFC1323 TCP extensions"),
1390 NULL, 0, &tcp_do_rfc1323, 0,
1391 CTL_NET, pf, IPPROTO_TCP, TCPCTL_RFC1323, CTL_EOL);
1392 sysctl_createv(clog, 0, NULL, NULL,
1393 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1394 CTLTYPE_INT, "sendspace",
1395 SYSCTL_DESCR("Default TCP send buffer size"),
1396 NULL, 0, &tcp_sendspace, 0,
1397 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SENDSPACE, CTL_EOL);
1398 sysctl_createv(clog, 0, NULL, NULL,
1399 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1400 CTLTYPE_INT, "recvspace",
1401 SYSCTL_DESCR("Default TCP receive buffer size"),
1402 NULL, 0, &tcp_recvspace, 0,
1403 CTL_NET, pf, IPPROTO_TCP, TCPCTL_RECVSPACE, CTL_EOL);
1404 sysctl_createv(clog, 0, NULL, NULL,
1405 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1406 CTLTYPE_INT, "mssdflt",
1407 SYSCTL_DESCR("Default maximum segment size"),
1408 sysctl_net_inet_tcp_mssdflt, 0, &tcp_mssdflt, 0,
1409 CTL_NET, pf, IPPROTO_TCP, TCPCTL_MSSDFLT, CTL_EOL);
1410 sysctl_createv(clog, 0, NULL, NULL,
1411 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1412 CTLTYPE_INT, "syn_cache_limit",
1413 SYSCTL_DESCR("Maximum number of entries in the TCP "
1414 "compressed state engine"),
1415 NULL, 0, &tcp_syn_cache_limit, 0,
1416 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_CACHE_LIMIT,
1417 CTL_EOL);
1418 sysctl_createv(clog, 0, NULL, NULL,
1419 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1420 CTLTYPE_INT, "syn_bucket_limit",
1421 SYSCTL_DESCR("Maximum number of entries per hash "
1422 "bucket in the TCP compressed state "
1423 "engine"),
1424 NULL, 0, &tcp_syn_bucket_limit, 0,
1425 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_BUCKET_LIMIT,
1426 CTL_EOL);
1427 #if 0 /* obsoleted */
1428 sysctl_createv(clog, 0, NULL, NULL,
1429 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1430 CTLTYPE_INT, "syn_cache_interval",
1431 SYSCTL_DESCR("TCP compressed state engine's timer interval"),
1432 NULL, 0, &tcp_syn_cache_interval, 0,
1433 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SYN_CACHE_INTER,
1434 CTL_EOL);
1435 #endif
1436 sysctl_createv(clog, 0, NULL, NULL,
1437 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1438 CTLTYPE_INT, "init_win",
1439 SYSCTL_DESCR("Initial TCP congestion window"),
1440 NULL, 0, &tcp_init_win, 0,
1441 CTL_NET, pf, IPPROTO_TCP, TCPCTL_INIT_WIN, CTL_EOL);
1442 sysctl_createv(clog, 0, NULL, NULL,
1443 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1444 CTLTYPE_INT, "mss_ifmtu",
1445 SYSCTL_DESCR("Use interface MTU for calculating MSS"),
1446 NULL, 0, &tcp_mss_ifmtu, 0,
1447 CTL_NET, pf, IPPROTO_TCP, TCPCTL_MSS_IFMTU, CTL_EOL);
1448 sysctl_createv(clog, 0, NULL, &sack_node,
1449 CTLFLAG_PERMANENT,
1450 CTLTYPE_NODE, "sack",
1451 SYSCTL_DESCR("RFC2018 Selective ACKnowledgement tunables"),
1452 NULL, 0, NULL, 0,
1453 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_EOL);
1454 sysctl_createv(clog, 0, NULL, NULL,
1455 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1456 CTLTYPE_INT, "win_scale",
1457 SYSCTL_DESCR("Use RFC1323 window scale options"),
1458 NULL, 0, &tcp_do_win_scale, 0,
1459 CTL_NET, pf, IPPROTO_TCP, TCPCTL_WSCALE, CTL_EOL);
1460 sysctl_createv(clog, 0, NULL, NULL,
1461 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1462 CTLTYPE_INT, "timestamps",
1463 SYSCTL_DESCR("Use RFC1323 time stamp options"),
1464 NULL, 0, &tcp_do_timestamps, 0,
1465 CTL_NET, pf, IPPROTO_TCP, TCPCTL_TSTAMP, CTL_EOL);
1466 sysctl_createv(clog, 0, NULL, NULL,
1467 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1468 CTLTYPE_INT, "compat_42",
1469 SYSCTL_DESCR("Enable workarounds for 4.2BSD TCP bugs"),
1470 NULL, 0, &tcp_compat_42, 0,
1471 CTL_NET, pf, IPPROTO_TCP, TCPCTL_COMPAT_42, CTL_EOL);
1472 sysctl_createv(clog, 0, NULL, NULL,
1473 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1474 CTLTYPE_INT, "cwm",
1475 SYSCTL_DESCR("Hughes/Touch/Heidemann Congestion Window "
1476 "Monitoring"),
1477 NULL, 0, &tcp_cwm, 0,
1478 CTL_NET, pf, IPPROTO_TCP, TCPCTL_CWM, CTL_EOL);
1479 sysctl_createv(clog, 0, NULL, NULL,
1480 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1481 CTLTYPE_INT, "cwm_burstsize",
1482 SYSCTL_DESCR("Congestion Window Monitoring allowed "
1483 "burst count in packets"),
1484 NULL, 0, &tcp_cwm_burstsize, 0,
1485 CTL_NET, pf, IPPROTO_TCP, TCPCTL_CWM_BURSTSIZE,
1486 CTL_EOL);
1487 sysctl_createv(clog, 0, NULL, NULL,
1488 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1489 CTLTYPE_INT, "ack_on_push",
1490 SYSCTL_DESCR("Immediately return ACK when PSH is "
1491 "received"),
1492 NULL, 0, &tcp_ack_on_push, 0,
1493 CTL_NET, pf, IPPROTO_TCP, TCPCTL_ACK_ON_PUSH, CTL_EOL);
1494 sysctl_createv(clog, 0, NULL, NULL,
1495 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1496 CTLTYPE_INT, "keepidle",
1497 SYSCTL_DESCR("Allowed connection idle ticks before a "
1498 "keepalive probe is sent"),
1499 NULL, 0, &tcp_keepidle, 0,
1500 CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPIDLE, CTL_EOL);
1501 sysctl_createv(clog, 0, NULL, NULL,
1502 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1503 CTLTYPE_INT, "keepintvl",
1504 SYSCTL_DESCR("Ticks before next keepalive probe is sent"),
1505 NULL, 0, &tcp_keepintvl, 0,
1506 CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPINTVL, CTL_EOL);
1507 sysctl_createv(clog, 0, NULL, NULL,
1508 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1509 CTLTYPE_INT, "keepcnt",
1510 SYSCTL_DESCR("Number of keepalive probes to send"),
1511 NULL, 0, &tcp_keepcnt, 0,
1512 CTL_NET, pf, IPPROTO_TCP, TCPCTL_KEEPCNT, CTL_EOL);
1513 sysctl_createv(clog, 0, NULL, NULL,
1514 CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
1515 CTLTYPE_INT, "slowhz",
1516 SYSCTL_DESCR("Keepalive ticks per second"),
1517 NULL, PR_SLOWHZ, NULL, 0,
1518 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SLOWHZ, CTL_EOL);
1519 sysctl_createv(clog, 0, NULL, NULL,
1520 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1521 CTLTYPE_INT, "newreno",
1522 SYSCTL_DESCR("NewReno congestion control algorithm"),
1523 NULL, 0, &tcp_do_newreno, 0,
1524 CTL_NET, pf, IPPROTO_TCP, TCPCTL_NEWRENO, CTL_EOL);
1525 sysctl_createv(clog, 0, NULL, NULL,
1526 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1527 CTLTYPE_INT, "log_refused",
1528 SYSCTL_DESCR("Log refused TCP connections"),
1529 NULL, 0, &tcp_log_refused, 0,
1530 CTL_NET, pf, IPPROTO_TCP, TCPCTL_LOG_REFUSED, CTL_EOL);
1531 #if 0 /* obsoleted */
1532 sysctl_createv(clog, 0, NULL, NULL,
1533 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1534 CTLTYPE_INT, "rstratelimit", NULL,
1535 NULL, 0, &tcp_rst_ratelim, 0,
1536 CTL_NET, pf, IPPROTO_TCP, TCPCTL_RSTRATELIMIT, CTL_EOL);
1537 #endif
1538 sysctl_createv(clog, 0, NULL, NULL,
1539 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1540 CTLTYPE_INT, "rstppslimit",
1541 SYSCTL_DESCR("Maximum number of RST packets to send "
1542 "per second"),
1543 NULL, 0, &tcp_rst_ppslim, 0,
1544 CTL_NET, pf, IPPROTO_TCP, TCPCTL_RSTPPSLIMIT, CTL_EOL);
1545 sysctl_createv(clog, 0, NULL, NULL,
1546 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1547 CTLTYPE_INT, "delack_ticks",
1548 SYSCTL_DESCR("Number of ticks to delay sending an ACK"),
1549 NULL, 0, &tcp_delack_ticks, 0,
1550 CTL_NET, pf, IPPROTO_TCP, TCPCTL_DELACK_TICKS, CTL_EOL);
1551 sysctl_createv(clog, 0, NULL, NULL,
1552 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1553 CTLTYPE_INT, "init_win_local",
1554 SYSCTL_DESCR("Initial TCP window size (in segments)"),
1555 NULL, 0, &tcp_init_win_local, 0,
1556 CTL_NET, pf, IPPROTO_TCP, TCPCTL_INIT_WIN_LOCAL,
1557 CTL_EOL);
1558 sysctl_createv(clog, 0, NULL, NULL,
1559 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1560 CTLTYPE_STRUCT, "ident",
1561 SYSCTL_DESCR("RFC1413 Identification Protocol lookups"),
1562 sysctl_net_inet_tcp_ident, 0, NULL, sizeof(uid_t),
1563 CTL_NET, pf, IPPROTO_TCP, TCPCTL_IDENT, CTL_EOL);
1564 sysctl_createv(clog, 0, NULL, NULL,
1565 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1566 CTLTYPE_INT, "do_loopback_cksum",
1567 SYSCTL_DESCR("Perform TCP checksum on loopback"),
1568 NULL, 0, &tcp_do_loopback_cksum, 0,
1569 CTL_NET, pf, IPPROTO_TCP, TCPCTL_LOOPBACKCKSUM,
1570 CTL_EOL);
1571 sysctl_createv(clog, 0, NULL, NULL,
1572 CTLFLAG_PERMANENT,
1573 CTLTYPE_STRUCT, "pcblist",
1574 SYSCTL_DESCR("TCP protocol control block list"),
1575 sysctl_inpcblist, 0, &tcbtable, 0,
1576 CTL_NET, pf, IPPROTO_TCP, CTL_CREATE,
1577 CTL_EOL);
1578
1579 /* SACK gets it's own little subtree. */
1580 sysctl_createv(clog, 0, NULL, &sack_node,
1581 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1582 CTLTYPE_INT, "enable",
1583 SYSCTL_DESCR("Enable RFC2018 Selective ACKnowledgement"),
1584 NULL, 0, &tcp_do_sack, 0,
1585 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
1586 sysctl_createv(clog, 0, NULL, &sack_node,
1587 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1588 CTLTYPE_INT, "maxholes",
1589 SYSCTL_DESCR("Maximum number of TCP SACK holes allowed per connection"),
1590 NULL, 0, &tcp_sack_tp_maxholes, 0,
1591 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
1592 sysctl_createv(clog, 0, NULL, &sack_node,
1593 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1594 CTLTYPE_INT, "globalmaxholes",
1595 SYSCTL_DESCR("Global maximum number of TCP SACK holes"),
1596 NULL, 0, &tcp_sack_globalmaxholes, 0,
1597 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
1598 sysctl_createv(clog, 0, NULL, &sack_node,
1599 CTLFLAG_PERMANENT,
1600 CTLTYPE_INT, "globalholes",
1601 SYSCTL_DESCR("Global number of TCP SACK holes"),
1602 NULL, 0, &tcp_sack_globalholes, 0,
1603 CTL_NET, pf, IPPROTO_TCP, TCPCTL_SACK, CTL_CREATE, CTL_EOL);
1604 }
1605
1606 /*
1607 * Sysctl for tcp variables.
1608 */
1609 #ifdef INET
1610 SYSCTL_SETUP(sysctl_net_inet_tcp_setup, "sysctl net.inet.tcp subtree setup")
1611 {
1612
1613 sysctl_net_inet_tcp_setup2(clog, PF_INET, "inet", "tcp");
1614 }
1615 #endif /* INET */
1616
1617 #ifdef INET6
1618 SYSCTL_SETUP(sysctl_net_inet6_tcp6_setup, "sysctl net.inet6.tcp6 subtree setup")
1619 {
1620
1621 sysctl_net_inet_tcp_setup2(clog, PF_INET6, "inet6", "tcp6");
1622 }
1623 #endif /* INET6 */
Cache object: b83289cba832280a40188f3f2a8cf877
|