2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved.
5 * This code is derived from software contributed to The DragonFly Project
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of The DragonFly Project nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific, prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * Copyright (c) 1982, 1986, 1988, 1993
36 * The Regents of the University of California. All rights reserved.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. Neither the name of the University nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * From: @(#)tcp_usrreq.c 8.2 (Berkeley) 1/3/94
63 * $FreeBSD: src/sys/netinet/tcp_usrreq.c,v 1.51.2.17 2002/10/11 11:46:44 ume Exp $
66 #include "opt_ipsec.h"
68 #include "opt_inet6.h"
69 #include "opt_tcpdebug.h"
71 #include <sys/param.h>
72 #include <sys/systm.h>
73 #include <sys/kernel.h>
74 #include <sys/malloc.h>
75 #include <sys/sysctl.h>
76 #include <sys/globaldata.h>
77 #include <sys/thread.h>
81 #include <sys/domain.h>
83 #include <sys/socket.h>
84 #include <sys/socketvar.h>
85 #include <sys/socketops.h>
86 #include <sys/protosw.h>
88 #include <sys/thread2.h>
89 #include <sys/msgport2.h>
90 #include <sys/socketvar2.h>
93 #include <net/netisr.h>
94 #include <net/route.h>
96 #include <net/netmsg2.h>
97 #include <net/netisr2.h>
99 #include <netinet/in.h>
100 #include <netinet/in_systm.h>
102 #include <netinet/ip6.h>
104 #include <netinet/in_pcb.h>
106 #include <netinet6/in6_pcb.h>
108 #include <netinet/in_var.h>
109 #include <netinet/ip_var.h>
111 #include <netinet6/ip6_var.h>
112 #include <netinet6/tcp6_var.h>
114 #include <netinet/tcp.h>
115 #include <netinet/tcp_fsm.h>
116 #include <netinet/tcp_seq.h>
117 #include <netinet/tcp_timer.h>
118 #include <netinet/tcp_timer2.h>
119 #include <netinet/tcp_var.h>
120 #include <netinet/tcpip.h>
122 #include <netinet/tcp_debug.h>
126 #include <netinet6/ipsec.h>
130 * TCP protocol interface to socket abstraction.
132 extern char *tcpstates
[]; /* XXX ??? */
134 static int tcp_attach (struct socket
*, struct pru_attach_info
*);
135 static void tcp_connect (netmsg_t msg
);
137 static void tcp6_connect (netmsg_t msg
);
138 static int tcp6_connect_oncpu(struct tcpcb
*tp
, int flags
,
140 struct sockaddr_in6
*sin6
,
141 struct in6_addr
*addr6
);
143 static struct tcpcb
*
144 tcp_disconnect (struct tcpcb
*);
145 static struct tcpcb
*
146 tcp_usrclosed (struct tcpcb
*);
149 #define TCPDEBUG0 int ostate = 0
150 #define TCPDEBUG1() ostate = tp ? tp->t_state : 0
151 #define TCPDEBUG2(req) if (tp && (so->so_options & SO_DEBUG)) \
152 tcp_trace(TA_USER, ostate, tp, 0, 0, req)
156 #define TCPDEBUG2(req)
159 static int tcp_lport_extension
= 1;
160 SYSCTL_INT(_net_inet_tcp
, OID_AUTO
, lportext
, CTLFLAG_RW
,
161 &tcp_lport_extension
, 0, "");
164 * For some ill optimized programs, which try to use TCP_NOPUSH
165 * to improve performance, will have small amount of data sits
166 * in the sending buffer. These small amount of data will _not_
167 * be pushed into the network until more data are written into
168 * the socket or the socket write side is shutdown.
170 static int tcp_disable_nopush
= 1;
171 SYSCTL_INT(_net_inet_tcp
, OID_AUTO
, disable_nopush
, CTLFLAG_RW
,
172 &tcp_disable_nopush
, 0, "TCP_NOPUSH socket option will have no effect");
175 * TCP attaches to socket via pru_attach(), reserving space,
176 * and an internet control block. This is likely occuring on
177 * cpu0 and may have to move later when we bind/connect.
180 tcp_usr_attach(netmsg_t msg
)
182 struct socket
*so
= msg
->base
.nm_so
;
183 struct pru_attach_info
*ai
= msg
->attach
.nm_ai
;
186 struct tcpcb
*tp
= NULL
;
197 error
= tcp_attach(so
, ai
);
201 if ((so
->so_options
& SO_LINGER
) && so
->so_linger
== 0)
202 so
->so_linger
= TCP_LINGERTIME
;
205 sofree(so
); /* from ref above */
206 TCPDEBUG2(PRU_ATTACH
);
207 lwkt_replymsg(&msg
->lmsg
, error
);
211 * pru_detach() detaches the TCP protocol from the socket.
212 * If the protocol state is non-embryonic, then can't
213 * do this directly: have to initiate a pru_disconnect(),
214 * which may finish later; embryonic TCB's can just
218 tcp_usr_detach(netmsg_t msg
)
220 struct socket
*so
= msg
->base
.nm_so
;
229 * If the inp is already detached it may have been due to an async
230 * close. Just return as if no error occured.
232 * It's possible for the tcpcb (tp) to disconnect from the inp due
233 * to tcp_drop()->tcp_close() being called. This may occur *after*
234 * the detach message has been queued so we may find a NULL tp here.
237 if ((tp
= intotcpcb(inp
)) != NULL
) {
239 tp
= tcp_disconnect(tp
);
240 TCPDEBUG2(PRU_DETACH
);
243 lwkt_replymsg(&msg
->lmsg
, error
);
247 * NOTE: ignore_error is non-zero for certain disconnection races
248 * which we want to silently allow, otherwise close() may return
249 * an unexpected error.
251 * NOTE: The variables (msg) and (tp) are assumed.
253 #define COMMON_START(so, inp, ignore_error) \
259 error = ignore_error ? 0 : EINVAL; \
263 tp = intotcpcb(inp); \
267 #define COMMON_END1(req, noreply) \
271 lwkt_replymsg(&msg->lmsg, error); \
275 #define COMMON_END(req) COMMON_END1((req), 0)
278 * Give the socket an address.
281 tcp_usr_bind(netmsg_t msg
)
283 struct socket
*so
= msg
->bind
.base
.nm_so
;
284 struct sockaddr
*nam
= msg
->bind
.nm_nam
;
285 struct thread
*td
= msg
->bind
.nm_td
;
289 struct sockaddr_in
*sinp
;
291 COMMON_START(so
, inp
, 0);
294 * Must check for multicast addresses and disallow binding
297 sinp
= (struct sockaddr_in
*)nam
;
298 if (sinp
->sin_family
== AF_INET
&&
299 IN_MULTICAST(ntohl(sinp
->sin_addr
.s_addr
))) {
300 error
= EAFNOSUPPORT
;
303 error
= in_pcbbind(inp
, nam
, td
);
306 COMMON_END(PRU_BIND
);
313 tcp6_usr_bind(netmsg_t msg
)
315 struct socket
*so
= msg
->bind
.base
.nm_so
;
316 struct sockaddr
*nam
= msg
->bind
.nm_nam
;
317 struct thread
*td
= msg
->bind
.nm_td
;
321 struct sockaddr_in6
*sin6p
;
323 COMMON_START(so
, inp
, 0);
326 * Must check for multicast addresses and disallow binding
329 sin6p
= (struct sockaddr_in6
*)nam
;
330 if (sin6p
->sin6_family
== AF_INET6
&&
331 IN6_IS_ADDR_MULTICAST(&sin6p
->sin6_addr
)) {
332 error
= EAFNOSUPPORT
;
335 error
= in6_pcbbind(inp
, nam
, td
);
338 COMMON_END(PRU_BIND
);
342 struct netmsg_inswildcard
{
343 struct netmsg_base base
;
344 struct inpcb
*nm_inp
;
348 in_pcbinswildcardhash_handler(netmsg_t msg
)
350 struct netmsg_inswildcard
*nm
= (struct netmsg_inswildcard
*)msg
;
351 int cpu
= mycpuid
, nextcpu
;
353 in_pcbinswildcardhash_oncpu(nm
->nm_inp
, &tcbinfo
[cpu
]);
356 if (nextcpu
< ncpus2
)
357 lwkt_forwardmsg(netisr_cpuport(nextcpu
), &nm
->base
.lmsg
);
359 lwkt_replymsg(&nm
->base
.lmsg
, 0);
363 tcp_sosetport(struct lwkt_msg
*msg
, lwkt_port_t port
)
365 sosetport(((struct netmsg_base
*)msg
)->nm_so
, port
);
369 * Prepare to accept connections.
372 tcp_usr_listen(netmsg_t msg
)
374 struct socket
*so
= msg
->listen
.base
.nm_so
;
375 struct thread
*td
= msg
->listen
.nm_td
;
379 struct netmsg_inswildcard nm
;
380 lwkt_port_t port0
= netisr_cpuport(0);
382 COMMON_START(so
, inp
, 0);
384 if (&curthread
->td_msgport
!= port0
) {
385 lwkt_msg_t lmsg
= &msg
->listen
.base
.lmsg
;
387 KASSERT((msg
->listen
.nm_flags
& PRUL_RELINK
) == 0,
388 ("already asked to relink"));
390 in_pcbunlink(so
->so_pcb
, &tcbinfo
[mycpuid
]);
391 msg
->listen
.nm_flags
|= PRUL_RELINK
;
393 /* See the related comment in tcp_connect() */
394 lwkt_setmsg_receipt(lmsg
, tcp_sosetport
);
395 lwkt_forwardmsg(port0
, lmsg
);
396 /* msg invalid now */
399 KASSERT(so
->so_port
== port0
, ("so_port is not netisr0"));
401 if (msg
->listen
.nm_flags
& PRUL_RELINK
) {
402 msg
->listen
.nm_flags
&= ~PRUL_RELINK
;
403 in_pcblink(so
->so_pcb
, &tcbinfo
[mycpuid
]);
405 KASSERT(inp
->inp_pcbinfo
== &tcbinfo
[0], ("pcbinfo is not tcbinfo0"));
407 if (tp
->t_flags
& TF_LISTEN
)
410 if (inp
->inp_lport
== 0) {
411 error
= in_pcbbind(inp
, NULL
, td
);
416 tp
->t_state
= TCPS_LISTEN
;
417 tp
->t_flags
|= TF_LISTEN
;
418 tp
->tt_msg
= NULL
; /* Catch any invalid timer usage */
422 * Put this inpcb into wildcard hash on other cpus.
424 ASSERT_INP_NOTINHASH(inp
);
425 netmsg_init(&nm
.base
, NULL
, &curthread
->td_msgport
,
426 MSGF_PRIORITY
, in_pcbinswildcardhash_handler
);
428 lwkt_domsg(netisr_cpuport(1), &nm
.base
.lmsg
, 0);
430 in_pcbinswildcardhash(inp
);
431 COMMON_END(PRU_LISTEN
);
437 tcp6_usr_listen(netmsg_t msg
)
439 struct socket
*so
= msg
->listen
.base
.nm_so
;
440 struct thread
*td
= msg
->listen
.nm_td
;
444 struct netmsg_inswildcard nm
;
446 COMMON_START(so
, inp
, 0);
448 if (tp
->t_flags
& TF_LISTEN
)
451 if (inp
->inp_lport
== 0) {
452 error
= in6_pcbbind(inp
, NULL
, td
);
457 tp
->t_state
= TCPS_LISTEN
;
458 tp
->t_flags
|= TF_LISTEN
;
459 tp
->tt_msg
= NULL
; /* Catch any invalid timer usage */
463 * Put this inpcb into wildcard hash on other cpus.
465 KKASSERT(so
->so_port
== netisr_cpuport(0));
466 KKASSERT(&curthread
->td_msgport
== netisr_cpuport(0));
467 KKASSERT(inp
->inp_pcbinfo
== &tcbinfo
[0]);
468 ASSERT_INP_NOTINHASH(inp
);
470 netmsg_init(&nm
.base
, NULL
, &curthread
->td_msgport
,
471 MSGF_PRIORITY
, in_pcbinswildcardhash_handler
);
473 lwkt_domsg(netisr_cpuport(1), &nm
.base
.lmsg
, 0);
475 in_pcbinswildcardhash(inp
);
476 COMMON_END(PRU_LISTEN
);
481 * Initiate connection to peer.
482 * Create a template for use in transmissions on this connection.
483 * Enter SYN_SENT state, and mark socket as connecting.
484 * Start keep-alive timer, and seed output sequence space.
485 * Send initial segment on connection.
488 tcp_usr_connect(netmsg_t msg
)
490 struct socket
*so
= msg
->connect
.base
.nm_so
;
491 struct sockaddr
*nam
= msg
->connect
.nm_nam
;
492 struct thread
*td
= msg
->connect
.nm_td
;
496 struct sockaddr_in
*sinp
;
498 COMMON_START(so
, inp
, 0);
501 * Must disallow TCP ``connections'' to multicast addresses.
503 sinp
= (struct sockaddr_in
*)nam
;
504 if (sinp
->sin_family
== AF_INET
505 && IN_MULTICAST(ntohl(sinp
->sin_addr
.s_addr
))) {
506 error
= EAFNOSUPPORT
;
510 if (!prison_remote_ip(td
, (struct sockaddr
*)sinp
)) {
511 error
= EAFNOSUPPORT
; /* IPv6 only jail */
516 /* msg is invalid now */
519 if (msg
->connect
.nm_m
) {
520 m_freem(msg
->connect
.nm_m
);
521 msg
->connect
.nm_m
= NULL
;
523 if (msg
->connect
.nm_flags
& PRUC_HELDTD
)
525 if (error
&& (msg
->connect
.nm_flags
& PRUC_ASYNC
)) {
526 so
->so_error
= error
;
527 soisdisconnected(so
);
529 lwkt_replymsg(&msg
->lmsg
, error
);
535 tcp6_usr_connect(netmsg_t msg
)
537 struct socket
*so
= msg
->connect
.base
.nm_so
;
538 struct sockaddr
*nam
= msg
->connect
.nm_nam
;
539 struct thread
*td
= msg
->connect
.nm_td
;
543 struct sockaddr_in6
*sin6p
;
545 COMMON_START(so
, inp
, 0);
548 * Must disallow TCP ``connections'' to multicast addresses.
550 sin6p
= (struct sockaddr_in6
*)nam
;
551 if (sin6p
->sin6_family
== AF_INET6
552 && IN6_IS_ADDR_MULTICAST(&sin6p
->sin6_addr
)) {
553 error
= EAFNOSUPPORT
;
557 if (!prison_remote_ip(td
, nam
)) {
558 error
= EAFNOSUPPORT
; /* IPv4 only jail */
562 /* Reject v4-mapped address */
563 if (IN6_IS_ADDR_V4MAPPED(&sin6p
->sin6_addr
)) {
564 error
= EADDRNOTAVAIL
;
568 inp
->inp_inc
.inc_isipv6
= 1;
570 /* msg is invalid now */
573 if (msg
->connect
.nm_m
) {
574 m_freem(msg
->connect
.nm_m
);
575 msg
->connect
.nm_m
= NULL
;
577 lwkt_replymsg(&msg
->lmsg
, error
);
583 * Initiate disconnect from peer.
584 * If connection never passed embryonic stage, just drop;
585 * else if don't need to let data drain, then can just drop anyways,
586 * else have to begin TCP shutdown process: mark socket disconnecting,
587 * drain unread data, state switch to reflect user close, and
588 * send segment (e.g. FIN) to peer. Socket will be really disconnected
589 * when peer sends FIN and acks ours.
591 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
594 tcp_usr_disconnect(netmsg_t msg
)
596 struct socket
*so
= msg
->disconnect
.base
.nm_so
;
601 COMMON_START(so
, inp
, 1);
602 tp
= tcp_disconnect(tp
);
603 COMMON_END(PRU_DISCONNECT
);
607 * Accept a connection. Essentially all the work is
608 * done at higher levels; just return the address
609 * of the peer, storing through addr.
612 tcp_usr_accept(netmsg_t msg
)
614 struct socket
*so
= msg
->accept
.base
.nm_so
;
615 struct sockaddr
**nam
= msg
->accept
.nm_nam
;
618 struct tcpcb
*tp
= NULL
;
622 if (so
->so_state
& SS_ISDISCONNECTED
) {
623 error
= ECONNABORTED
;
633 in_setpeeraddr(so
, nam
);
634 COMMON_END(PRU_ACCEPT
);
639 tcp6_usr_accept(netmsg_t msg
)
641 struct socket
*so
= msg
->accept
.base
.nm_so
;
642 struct sockaddr
**nam
= msg
->accept
.nm_nam
;
645 struct tcpcb
*tp
= NULL
;
650 if (so
->so_state
& SS_ISDISCONNECTED
) {
651 error
= ECONNABORTED
;
660 in6_setpeeraddr(so
, nam
);
661 COMMON_END(PRU_ACCEPT
);
665 * Mark the connection as being incapable of further output.
668 tcp_usr_shutdown(netmsg_t msg
)
670 struct socket
*so
= msg
->shutdown
.base
.nm_so
;
675 COMMON_START(so
, inp
, 0);
677 tp
= tcp_usrclosed(tp
);
679 error
= tcp_output(tp
);
680 COMMON_END(PRU_SHUTDOWN
);
684 * After a receive, possibly send window update to peer.
687 tcp_usr_rcvd(netmsg_t msg
)
689 struct socket
*so
= msg
->rcvd
.base
.nm_so
;
690 int error
= 0, noreply
= 0;
694 COMMON_START(so
, inp
, 0);
696 if (msg
->rcvd
.nm_pru_flags
& PRUR_ASYNC
) {
698 so_async_rcvd_reply(so
);
702 COMMON_END1(PRU_RCVD
, noreply
);
706 * Do a send by putting data in output queue and updating urgent
707 * marker if URG set. Possibly send more data. Unlike the other
708 * pru_*() routines, the mbuf chains are our responsibility. We
709 * must either enqueue them or free them. The other pru_* routines
710 * generally are caller-frees.
713 tcp_usr_send(netmsg_t msg
)
715 struct socket
*so
= msg
->send
.base
.nm_so
;
716 int flags
= msg
->send
.nm_flags
;
717 struct mbuf
*m
= msg
->send
.nm_m
;
723 KKASSERT(msg
->send
.nm_control
== NULL
);
724 KKASSERT(msg
->send
.nm_addr
== NULL
);
725 KKASSERT((flags
& PRUS_FREEADDR
) == 0);
731 * OOPS! we lost a race, the TCP session got reset after
732 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a
733 * network interrupt in the non-critical section of sosend().
736 error
= ECONNRESET
; /* XXX EPIPE? */
746 * This is no longer necessary, since:
747 * - sosendtcp() has already checked it for us
748 * - It does not work with asynchronized send
752 * Don't let too much OOB data build up
754 if (flags
& PRUS_OOB
) {
755 if (ssb_space(&so
->so_snd
) < -512) {
764 * Pump the data into the socket.
767 ssb_appendstream(&so
->so_snd
, m
);
770 if (flags
& PRUS_OOB
) {
772 * According to RFC961 (Assigned Protocols),
773 * the urgent pointer points to the last octet
774 * of urgent data. We continue, however,
775 * to consider it to indicate the first octet
776 * of data past the urgent section.
777 * Otherwise, snd_up should be one lower.
779 tp
->snd_up
= tp
->snd_una
+ so
->so_snd
.ssb_cc
;
780 tp
->t_flags
|= TF_FORCE
;
781 error
= tcp_output(tp
);
782 tp
->t_flags
&= ~TF_FORCE
;
784 if (flags
& PRUS_EOF
) {
786 * Close the send side of the connection after
790 tp
= tcp_usrclosed(tp
);
792 if (tp
!= NULL
&& !tcp_output_pending(tp
)) {
793 if (flags
& PRUS_MORETOCOME
)
794 tp
->t_flags
|= TF_MORETOCOME
;
795 error
= tcp_output_fair(tp
);
796 if (flags
& PRUS_MORETOCOME
)
797 tp
->t_flags
&= ~TF_MORETOCOME
;
800 COMMON_END1((flags
& PRUS_OOB
) ? PRU_SENDOOB
:
801 ((flags
& PRUS_EOF
) ? PRU_SEND_EOF
: PRU_SEND
),
802 (flags
& PRUS_NOREPLY
));
806 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
807 * will sofree() it when we return.
810 tcp_usr_abort(netmsg_t msg
)
812 struct socket
*so
= msg
->abort
.base
.nm_so
;
817 COMMON_START(so
, inp
, 1);
818 tp
= tcp_drop(tp
, ECONNABORTED
);
819 COMMON_END(PRU_ABORT
);
823 * Receive out-of-band data.
826 tcp_usr_rcvoob(netmsg_t msg
)
828 struct socket
*so
= msg
->rcvoob
.base
.nm_so
;
829 struct mbuf
*m
= msg
->rcvoob
.nm_m
;
830 int flags
= msg
->rcvoob
.nm_flags
;
835 COMMON_START(so
, inp
, 0);
836 if ((so
->so_oobmark
== 0 &&
837 (so
->so_state
& SS_RCVATMARK
) == 0) ||
838 so
->so_options
& SO_OOBINLINE
||
839 tp
->t_oobflags
& TCPOOB_HADDATA
) {
843 if ((tp
->t_oobflags
& TCPOOB_HAVEDATA
) == 0) {
848 *mtod(m
, caddr_t
) = tp
->t_iobc
;
849 if ((flags
& MSG_PEEK
) == 0)
850 tp
->t_oobflags
^= (TCPOOB_HAVEDATA
| TCPOOB_HADDATA
);
851 COMMON_END(PRU_RCVOOB
);
855 tcp_usr_savefaddr(struct socket
*so
, const struct sockaddr
*faddr
)
857 in_savefaddr(so
, faddr
);
862 tcp6_usr_savefaddr(struct socket
*so
, const struct sockaddr
*faddr
)
864 in6_savefaddr(so
, faddr
);
869 tcp_usr_preconnect(struct socket
*so
, const struct sockaddr
*nam
,
870 struct thread
*td __unused
)
872 const struct sockaddr_in
*sinp
;
874 sinp
= (const struct sockaddr_in
*)nam
;
875 if (sinp
->sin_family
== AF_INET
&&
876 IN_MULTICAST(ntohl(sinp
->sin_addr
.s_addr
)))
883 /* xxx - should be const */
884 struct pr_usrreqs tcp_usrreqs
= {
885 .pru_abort
= tcp_usr_abort
,
886 .pru_accept
= tcp_usr_accept
,
887 .pru_attach
= tcp_usr_attach
,
888 .pru_bind
= tcp_usr_bind
,
889 .pru_connect
= tcp_usr_connect
,
890 .pru_connect2
= pr_generic_notsupp
,
891 .pru_control
= in_control_dispatch
,
892 .pru_detach
= tcp_usr_detach
,
893 .pru_disconnect
= tcp_usr_disconnect
,
894 .pru_listen
= tcp_usr_listen
,
895 .pru_peeraddr
= in_setpeeraddr_dispatch
,
896 .pru_rcvd
= tcp_usr_rcvd
,
897 .pru_rcvoob
= tcp_usr_rcvoob
,
898 .pru_send
= tcp_usr_send
,
899 .pru_sense
= pru_sense_null
,
900 .pru_shutdown
= tcp_usr_shutdown
,
901 .pru_sockaddr
= in_setsockaddr_dispatch
,
902 .pru_sosend
= sosendtcp
,
903 .pru_soreceive
= sorecvtcp
,
904 .pru_savefaddr
= tcp_usr_savefaddr
,
905 .pru_preconnect
= tcp_usr_preconnect
909 struct pr_usrreqs tcp6_usrreqs
= {
910 .pru_abort
= tcp_usr_abort
,
911 .pru_accept
= tcp6_usr_accept
,
912 .pru_attach
= tcp_usr_attach
,
913 .pru_bind
= tcp6_usr_bind
,
914 .pru_connect
= tcp6_usr_connect
,
915 .pru_connect2
= pr_generic_notsupp
,
916 .pru_control
= in6_control_dispatch
,
917 .pru_detach
= tcp_usr_detach
,
918 .pru_disconnect
= tcp_usr_disconnect
,
919 .pru_listen
= tcp6_usr_listen
,
920 .pru_peeraddr
= in6_setpeeraddr_dispatch
,
921 .pru_rcvd
= tcp_usr_rcvd
,
922 .pru_rcvoob
= tcp_usr_rcvoob
,
923 .pru_send
= tcp_usr_send
,
924 .pru_sense
= pru_sense_null
,
925 .pru_shutdown
= tcp_usr_shutdown
,
926 .pru_sockaddr
= in6_setsockaddr_dispatch
,
927 .pru_sosend
= sosendtcp
,
928 .pru_soreceive
= sorecvtcp
,
929 .pru_savefaddr
= tcp6_usr_savefaddr
934 tcp_connect_oncpu(struct tcpcb
*tp
, int flags
, struct mbuf
*m
,
935 struct sockaddr_in
*sin
, struct sockaddr_in
*if_sin
)
937 struct inpcb
*inp
= tp
->t_inpcb
, *oinp
;
938 struct socket
*so
= inp
->inp_socket
;
939 struct route
*ro
= &inp
->inp_route
;
941 KASSERT(inp
->inp_pcbinfo
== &tcbinfo
[mycpu
->gd_cpuid
],
942 ("pcbinfo mismatch"));
944 oinp
= in_pcblookup_hash(inp
->inp_pcbinfo
,
945 sin
->sin_addr
, sin
->sin_port
,
946 (inp
->inp_laddr
.s_addr
!= INADDR_ANY
?
947 inp
->inp_laddr
: if_sin
->sin_addr
),
948 inp
->inp_lport
, 0, NULL
);
953 if (inp
->inp_laddr
.s_addr
== INADDR_ANY
)
954 inp
->inp_laddr
= if_sin
->sin_addr
;
955 inp
->inp_faddr
= sin
->sin_addr
;
956 inp
->inp_fport
= sin
->sin_port
;
957 in_pcbinsconnhash(inp
);
960 * We are now on the inpcb's owner CPU, if the cached route was
961 * freed because the rtentry's owner CPU is not the current CPU
962 * (e.g. in tcp_connect()), then we try to reallocate it here with
963 * the hope that a rtentry may be cloned from a RTF_PRCLONING
966 if (!(inp
->inp_socket
->so_options
& SO_DONTROUTE
) && /*XXX*/
968 bzero(&ro
->ro_dst
, sizeof(struct sockaddr_in
));
969 ro
->ro_dst
.sa_family
= AF_INET
;
970 ro
->ro_dst
.sa_len
= sizeof(struct sockaddr_in
);
971 ((struct sockaddr_in
*)&ro
->ro_dst
)->sin_addr
=
977 * Now that no more errors can occur, change the protocol processing
978 * port to the current thread (which is the correct thread).
980 * Create TCP timer message now; we are on the tcpcb's owner
983 tcp_create_timermsg(tp
, &curthread
->td_msgport
);
986 * Compute window scaling to request. Use a larger scaling then
987 * needed for the initial receive buffer in case the receive buffer
990 if (tp
->request_r_scale
< TCP_MIN_WINSHIFT
)
991 tp
->request_r_scale
= TCP_MIN_WINSHIFT
;
992 while (tp
->request_r_scale
< TCP_MAX_WINSHIFT
&&
993 (TCP_MAXWIN
<< tp
->request_r_scale
) < so
->so_rcv
.ssb_hiwat
995 tp
->request_r_scale
++;
999 tcpstat
.tcps_connattempt
++;
1000 tp
->t_state
= TCPS_SYN_SENT
;
1001 tcp_callout_reset(tp
, tp
->tt_keep
, tp
->t_keepinit
, tcp_timer_keep
);
1002 tp
->iss
= tcp_new_isn(tp
);
1003 tcp_sendseqinit(tp
);
1005 ssb_appendstream(&so
->so_snd
, m
);
1007 if (flags
& PRUS_OOB
)
1008 tp
->snd_up
= tp
->snd_una
+ so
->so_snd
.ssb_cc
;
1012 * Close the send side of the connection after
1013 * the data is sent if flagged.
1015 if ((flags
& (PRUS_OOB
|PRUS_EOF
)) == PRUS_EOF
) {
1017 tp
= tcp_usrclosed(tp
);
1019 return (tcp_output(tp
));
1023 * Common subroutine to open a TCP connection to remote host specified
1024 * by struct sockaddr_in in mbuf *nam. Call in_pcbbind to assign a local
1025 * port number if needed. Call in_pcbladdr to do the routing and to choose
1026 * a local host address (interface).
1027 * Initialize connection parameters and enter SYN-SENT state.
1030 tcp_connect(netmsg_t msg
)
1032 struct socket
*so
= msg
->connect
.base
.nm_so
;
1033 struct sockaddr
*nam
= msg
->connect
.nm_nam
;
1034 struct thread
*td
= msg
->connect
.nm_td
;
1035 struct sockaddr_in
*sin
= (struct sockaddr_in
*)nam
;
1036 struct sockaddr_in
*if_sin
= NULL
;
1042 COMMON_START(so
, inp
, 0);
1045 * Reconnect our pcb if we have to
1047 if (msg
->connect
.nm_flags
& PRUC_RECONNECT
) {
1048 msg
->connect
.nm_flags
&= ~PRUC_RECONNECT
;
1049 in_pcblink(so
->so_pcb
, &tcbinfo
[mycpu
->gd_cpuid
]);
1053 * Bind if we have to
1055 if (inp
->inp_lport
== 0) {
1056 if (tcp_lport_extension
) {
1057 KKASSERT(inp
->inp_laddr
.s_addr
== INADDR_ANY
);
1059 error
= in_pcbladdr(inp
, nam
, &if_sin
, td
);
1062 inp
->inp_laddr
.s_addr
= if_sin
->sin_addr
.s_addr
;
1064 error
= in_pcbbind_remote(inp
, nam
, td
);
1068 msg
->connect
.nm_flags
|= PRUC_HASLADDR
;
1070 error
= in_pcbbind(inp
, NULL
, td
);
1076 if ((msg
->connect
.nm_flags
& PRUC_HASLADDR
) == 0) {
1078 * Calculate the correct protocol processing thread. The
1079 * connect operation must run there. Set the forwarding
1080 * port before we forward the message or it will get bounced
1083 error
= in_pcbladdr(inp
, nam
, &if_sin
, td
);
1087 KKASSERT(inp
->inp_socket
== so
);
1089 port
= tcp_addrport(sin
->sin_addr
.s_addr
, sin
->sin_port
,
1090 (inp
->inp_laddr
.s_addr
!= INADDR_ANY
?
1091 inp
->inp_laddr
.s_addr
: if_sin
->sin_addr
.s_addr
),
1094 if (port
!= &curthread
->td_msgport
) {
1095 lwkt_msg_t lmsg
= &msg
->connect
.base
.lmsg
;
1098 * in_pcbladdr() may have allocated a route entry for us
1099 * on the current CPU, but we need a route entry on the
1100 * inpcb's owner CPU, so free it here.
1102 in_pcbresetroute(inp
);
1105 * We are moving the protocol processing port the socket
1106 * is on, we have to unlink here and re-link on the
1109 in_pcbunlink(so
->so_pcb
, &tcbinfo
[mycpu
->gd_cpuid
]);
1110 msg
->connect
.nm_flags
|= PRUC_RECONNECT
;
1111 msg
->connect
.base
.nm_dispatch
= tcp_connect
;
1114 * Use message put done receipt to change this socket's
1115 * so_port, i.e. _after_ this message was put onto the
1116 * target netisr's msgport but _before_ the message could
1117 * be pulled from the target netisr's msgport, so that:
1118 * - The upper half (socket code) will not see the new
1119 * msgport before this message reaches the new msgport
1120 * and messages for this socket will be ordered.
1121 * - This message will see the new msgport, when its
1122 * handler is called in the target netisr.
1125 * We MUST use messege put done receipt to change this
1127 * If we changed the so_port in this netisr after the
1128 * lwkt_forwardmsg (so messages for this socket will be
1129 * ordered) and changed the so_port in the target netisr
1130 * at the very beginning of this message's handler, we
1131 * would suffer so_port overwritten race, given this
1132 * message might be forwarded again.
1135 * This mechanism depends on that the netisr's msgport
1136 * is spin msgport (currently it is :).
1138 * If the upper half saw the new msgport before this
1139 * message reached the target netisr's msgport, the
1140 * messages sent from the upper half could reach the new
1141 * msgport before this message, thus there would be
1142 * message reordering. The worst case could be soclose()
1143 * saw the new msgport and the detach message could reach
1144 * the new msgport before this message, i.e. the inpcb
1145 * could have been destroyed when this message was still
1146 * pending on or on its way to the new msgport. Other
1147 * weird cases could also happen, e.g. inpcb->inp_pcbinfo,
1148 * since we have unlinked this inpcb from the current
1151 lwkt_setmsg_receipt(lmsg
, tcp_sosetport
);
1152 lwkt_forwardmsg(port
, lmsg
);
1153 /* msg invalid now */
1155 } else if (msg
->connect
.nm_flags
& PRUC_HELDTD
) {
1157 * The original thread is no longer needed; release it.
1160 msg
->connect
.nm_flags
&= ~PRUC_HELDTD
;
1162 error
= tcp_connect_oncpu(tp
, msg
->connect
.nm_sndflags
,
1163 msg
->connect
.nm_m
, sin
, if_sin
);
1164 msg
->connect
.nm_m
= NULL
;
1166 if (msg
->connect
.nm_m
) {
1167 m_freem(msg
->connect
.nm_m
);
1168 msg
->connect
.nm_m
= NULL
;
1170 if (msg
->connect
.nm_flags
& PRUC_HELDTD
)
1172 if (error
&& (msg
->connect
.nm_flags
& PRUC_ASYNC
)) {
1173 so
->so_error
= error
;
1174 soisdisconnected(so
);
1176 lwkt_replymsg(&msg
->connect
.base
.lmsg
, error
);
1177 /* msg invalid now */
1183 tcp6_connect(netmsg_t msg
)
1186 struct socket
*so
= msg
->connect
.base
.nm_so
;
1187 struct sockaddr
*nam
= msg
->connect
.nm_nam
;
1188 struct thread
*td
= msg
->connect
.nm_td
;
1190 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)nam
;
1191 struct in6_addr
*addr6
;
1195 COMMON_START(so
, inp
, 0);
1198 * Reconnect our pcb if we have to
1200 if (msg
->connect
.nm_flags
& PRUC_RECONNECT
) {
1201 msg
->connect
.nm_flags
&= ~PRUC_RECONNECT
;
1202 in_pcblink(so
->so_pcb
, &tcbinfo
[mycpu
->gd_cpuid
]);
1206 * Bind if we have to
1208 if (inp
->inp_lport
== 0) {
1209 error
= in6_pcbbind(inp
, NULL
, td
);
1215 * Cannot simply call in_pcbconnect, because there might be an
1216 * earlier incarnation of this same connection still in
1217 * TIME_WAIT state, creating an ADDRINUSE error.
1219 error
= in6_pcbladdr(inp
, nam
, &addr6
, td
);
1223 port
= tcp6_addrport(); /* XXX hack for now, always cpu0 */
1225 if (port
!= &curthread
->td_msgport
) {
1226 lwkt_msg_t lmsg
= &msg
->connect
.base
.lmsg
;
1229 * in_pcbladdr() may have allocated a route entry for us
1230 * on the current CPU, but we need a route entry on the
1231 * inpcb's owner CPU, so free it here.
1233 in_pcbresetroute(inp
);
1235 in_pcbunlink(so
->so_pcb
, &tcbinfo
[mycpu
->gd_cpuid
]);
1236 msg
->connect
.nm_flags
|= PRUC_RECONNECT
;
1237 msg
->connect
.base
.nm_dispatch
= tcp6_connect
;
1239 /* See the related comment in tcp_connect() */
1240 lwkt_setmsg_receipt(lmsg
, tcp_sosetport
);
1241 lwkt_forwardmsg(port
, lmsg
);
1242 /* msg invalid now */
1245 error
= tcp6_connect_oncpu(tp
, msg
->connect
.nm_sndflags
,
1246 &msg
->connect
.nm_m
, sin6
, addr6
);
1247 /* nm_m may still be intact */
1249 if (msg
->connect
.nm_m
) {
1250 m_freem(msg
->connect
.nm_m
);
1251 msg
->connect
.nm_m
= NULL
;
1253 lwkt_replymsg(&msg
->connect
.base
.lmsg
, error
);
1254 /* msg invalid now */
1258 tcp6_connect_oncpu(struct tcpcb
*tp
, int flags
, struct mbuf
**mp
,
1259 struct sockaddr_in6
*sin6
, struct in6_addr
*addr6
)
1261 struct mbuf
*m
= *mp
;
1262 struct inpcb
*inp
= tp
->t_inpcb
;
1263 struct socket
*so
= inp
->inp_socket
;
1267 * Cannot simply call in_pcbconnect, because there might be an
1268 * earlier incarnation of this same connection still in
1269 * TIME_WAIT state, creating an ADDRINUSE error.
1271 oinp
= in6_pcblookup_hash(inp
->inp_pcbinfo
,
1272 &sin6
->sin6_addr
, sin6
->sin6_port
,
1273 (IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_laddr
) ?
1274 addr6
: &inp
->in6p_laddr
),
1275 inp
->inp_lport
, 0, NULL
);
1277 return (EADDRINUSE
);
1279 if (IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_laddr
))
1280 inp
->in6p_laddr
= *addr6
;
1281 inp
->in6p_faddr
= sin6
->sin6_addr
;
1282 inp
->inp_fport
= sin6
->sin6_port
;
1283 if ((sin6
->sin6_flowinfo
& IPV6_FLOWINFO_MASK
) != 0)
1284 inp
->in6p_flowinfo
= sin6
->sin6_flowinfo
;
1285 in_pcbinsconnhash(inp
);
1288 * Now that no more errors can occur, change the protocol processing
1289 * port to the current thread (which is the correct thread).
1291 * Create TCP timer message now; we are on the tcpcb's owner
1294 tcp_create_timermsg(tp
, &curthread
->td_msgport
);
1296 /* Compute window scaling to request. */
1297 if (tp
->request_r_scale
< TCP_MIN_WINSHIFT
)
1298 tp
->request_r_scale
= TCP_MIN_WINSHIFT
;
1299 while (tp
->request_r_scale
< TCP_MAX_WINSHIFT
&&
1300 (TCP_MAXWIN
<< tp
->request_r_scale
) < so
->so_rcv
.ssb_hiwat
) {
1301 tp
->request_r_scale
++;
1305 tcpstat
.tcps_connattempt
++;
1306 tp
->t_state
= TCPS_SYN_SENT
;
1307 tcp_callout_reset(tp
, tp
->tt_keep
, tp
->t_keepinit
, tcp_timer_keep
);
1308 tp
->iss
= tcp_new_isn(tp
);
1309 tcp_sendseqinit(tp
);
1311 ssb_appendstream(&so
->so_snd
, m
);
1313 if (flags
& PRUS_OOB
)
1314 tp
->snd_up
= tp
->snd_una
+ so
->so_snd
.ssb_cc
;
1318 * Close the send side of the connection after
1319 * the data is sent if flagged.
1321 if ((flags
& (PRUS_OOB
|PRUS_EOF
)) == PRUS_EOF
) {
1323 tp
= tcp_usrclosed(tp
);
1325 return (tcp_output(tp
));
1331 * The new sockopt interface makes it possible for us to block in the
1332 * copyin/out step (if we take a page fault). Taking a page fault while
1333 * in a critical section is probably a Bad Thing. (Since sockets and pcbs
1334 * both now use TSM, there probably isn't any need for this function to
1335 * run in a critical section any more. This needs more examination.)
1338 tcp_ctloutput(netmsg_t msg
)
1340 struct socket
*so
= msg
->base
.nm_so
;
1341 struct sockopt
*sopt
= msg
->ctloutput
.nm_sopt
;
1342 int error
, opt
, optval
, opthz
;
1352 tp
= intotcpcb(inp
);
1354 /* Get socket's owner cpuid hint */
1355 if (sopt
->sopt_level
== SOL_SOCKET
&&
1356 sopt
->sopt_dir
== SOPT_GET
&&
1357 sopt
->sopt_name
== SO_CPUHINT
) {
1358 if (tp
->t_flags
& TF_LISTEN
) {
1360 * Listen sockets owner cpuid is always 0,
1361 * which does not make sense if SO_REUSEPORT
1364 if (so
->so_options
& SO_REUSEPORT
)
1365 optval
= (inp
->inp_lgrpindex
& ncpus2_mask
);
1367 optval
= -1; /* no hint */
1371 soopt_from_kbuf(sopt
, &optval
, sizeof(optval
));
1375 if (sopt
->sopt_level
!= IPPROTO_TCP
) {
1376 if (sopt
->sopt_level
== IPPROTO_IP
) {
1377 switch (sopt
->sopt_name
) {
1378 case IP_MULTICAST_IF
:
1379 case IP_MULTICAST_VIF
:
1380 case IP_MULTICAST_TTL
:
1381 case IP_MULTICAST_LOOP
:
1382 case IP_ADD_MEMBERSHIP
:
1383 case IP_DROP_MEMBERSHIP
:
1385 * Multicast does not make sense on
1393 if (INP_CHECK_SOCKAF(so
, AF_INET6
))
1394 ip6_ctloutput_dispatch(msg
);
1398 /* msg invalid now */
1402 switch (sopt
->sopt_dir
) {
1404 error
= soopt_to_kbuf(sopt
, &optval
, sizeof optval
,
1408 switch (sopt
->sopt_name
) {
1411 tp
->t_keepidle
= tp
->t_keepintvl
;
1413 tp
->t_keepidle
= tcp_keepidle
;
1414 tcp_timer_keep_activity(tp
, 0);
1416 #ifdef TCP_SIGNATURE
1417 case TCP_SIGNATURE_ENABLE
:
1418 if (tp
->t_state
== TCPS_CLOSED
) {
1420 * This is the only safe state that this
1421 * option could be changed. Some segments
1422 * could already have been sent in other
1426 tp
->t_flags
|= TF_SIGNATURE
;
1428 tp
->t_flags
&= ~TF_SIGNATURE
;
1433 #endif /* TCP_SIGNATURE */
1436 switch (sopt
->sopt_name
) {
1444 opt
= 0; /* dead code to fool gcc */
1451 tp
->t_flags
&= ~opt
;
1455 if (tcp_disable_nopush
)
1458 tp
->t_flags
|= TF_NOPUSH
;
1460 tp
->t_flags
&= ~TF_NOPUSH
;
1461 error
= tcp_output(tp
);
1467 * Must be between 0 and maxseg. If the requested
1468 * maxseg is too small to satisfy the desired minmss,
1469 * pump it up (silently so sysctl modifications of
1470 * minmss do not create unexpected program failures).
1471 * Handle degenerate cases.
1473 if (optval
> 0 && optval
<= tp
->t_maxseg
) {
1474 if (optval
+ 40 < tcp_minmss
) {
1475 optval
= tcp_minmss
- 40;
1479 tp
->t_maxseg
= optval
;
1486 opthz
= ((int64_t)optval
* hz
) / 1000;
1488 tp
->t_keepinit
= opthz
;
1494 opthz
= ((int64_t)optval
* hz
) / 1000;
1496 tp
->t_keepidle
= opthz
;
1497 tcp_timer_keep_activity(tp
, 0);
1504 opthz
= ((int64_t)optval
* hz
) / 1000;
1506 tp
->t_keepintvl
= opthz
;
1507 tp
->t_maxidle
= tp
->t_keepintvl
* tp
->t_keepcnt
;
1515 tp
->t_keepcnt
= optval
;
1516 tp
->t_maxidle
= tp
->t_keepintvl
* tp
->t_keepcnt
;
1523 error
= ENOPROTOOPT
;
1529 switch (sopt
->sopt_name
) {
1530 #ifdef TCP_SIGNATURE
1531 case TCP_SIGNATURE_ENABLE
:
1532 optval
= (tp
->t_flags
& TF_SIGNATURE
) ? 1 : 0;
1534 #endif /* TCP_SIGNATURE */
1536 optval
= tp
->t_flags
& TF_NODELAY
;
1539 optval
= tp
->t_maxseg
;
1542 optval
= tp
->t_flags
& TF_NOOPT
;
1545 optval
= tp
->t_flags
& TF_NOPUSH
;
1548 optval
= ((int64_t)tp
->t_keepinit
* 1000) / hz
;
1551 optval
= ((int64_t)tp
->t_keepidle
* 1000) / hz
;
1554 optval
= ((int64_t)tp
->t_keepintvl
* 1000) / hz
;
1557 optval
= tp
->t_keepcnt
;
1560 error
= ENOPROTOOPT
;
1564 soopt_from_kbuf(sopt
, &optval
, sizeof optval
);
1568 lwkt_replymsg(&msg
->lmsg
, error
);
1572 * tcp_sendspace and tcp_recvspace are the default send and receive window
1573 * sizes, respectively. These are obsolescent (this information should
1574 * be set by the route).
1576 * Use a default that does not require tcp window scaling to be turned
1577 * on. Individual programs or the administrator can increase the default.
1579 u_long tcp_sendspace
= 57344; /* largest multiple of PAGE_SIZE < 64k */
1580 SYSCTL_INT(_net_inet_tcp
, TCPCTL_SENDSPACE
, sendspace
, CTLFLAG_RW
,
1581 &tcp_sendspace
, 0, "Maximum outgoing TCP datagram size");
1582 u_long tcp_recvspace
= 57344; /* largest multiple of PAGE_SIZE < 64k */
1583 SYSCTL_INT(_net_inet_tcp
, TCPCTL_RECVSPACE
, recvspace
, CTLFLAG_RW
,
1584 &tcp_recvspace
, 0, "Maximum incoming TCP datagram size");
1587 * Attach TCP protocol to socket, allocating internet protocol control
1588 * block, tcp control block, buffer space, and entering CLOSED state.
1591 tcp_attach(struct socket
*so
, struct pru_attach_info
*ai
)
1598 boolean_t isipv6
= INP_CHECK_SOCKAF(so
, AF_INET6
);
1601 if (so
->so_snd
.ssb_hiwat
== 0 || so
->so_rcv
.ssb_hiwat
== 0) {
1602 lwkt_gettoken(&so
->so_rcv
.ssb_token
);
1603 error
= soreserve(so
, tcp_sendspace
, tcp_recvspace
,
1605 lwkt_reltoken(&so
->so_rcv
.ssb_token
);
1609 atomic_set_int(&so
->so_rcv
.ssb_flags
, SSB_AUTOSIZE
| SSB_PREALLOC
);
1610 atomic_set_int(&so
->so_snd
.ssb_flags
, SSB_AUTOSIZE
| SSB_PREALLOC
);
1611 cpu
= mycpu
->gd_cpuid
;
1614 * Set the default port for protocol processing. This will likely
1615 * change when we connect.
1617 error
= in_pcballoc(so
, &tcbinfo
[cpu
]);
1623 inp
->in6p_hops
= -1; /* use kernel default */
1625 tp
= tcp_newtcpcb(inp
);
1628 * Make sure the socket is destroyed by the pcbdetach.
1637 sofree(so
); /* from ref above */
1640 tp
->t_state
= TCPS_CLOSED
;
1641 /* Keep a reference for asynchronized pru_rcvd */
1647 * Initiate (or continue) disconnect.
1648 * If embryonic state, just send reset (once).
1649 * If in ``let data drain'' option and linger null, just drop.
1650 * Otherwise (hard), mark socket disconnecting and drop
1651 * current input data; switch states based on user close, and
1652 * send segment to peer (with FIN).
1654 static struct tcpcb
*
1655 tcp_disconnect(struct tcpcb
*tp
)
1657 struct socket
*so
= tp
->t_inpcb
->inp_socket
;
1659 if (tp
->t_state
< TCPS_ESTABLISHED
) {
1661 } else if ((so
->so_options
& SO_LINGER
) && so
->so_linger
== 0) {
1662 tp
= tcp_drop(tp
, 0);
1664 lwkt_gettoken(&so
->so_rcv
.ssb_token
);
1665 soisdisconnecting(so
);
1666 sbflush(&so
->so_rcv
.sb
);
1667 tp
= tcp_usrclosed(tp
);
1670 lwkt_reltoken(&so
->so_rcv
.ssb_token
);
1676 * User issued close, and wish to trail through shutdown states:
1677 * if never received SYN, just forget it. If got a SYN from peer,
1678 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
1679 * If already got a FIN from peer, then almost done; go to LAST_ACK
1680 * state. In all other cases, have already sent FIN to peer (e.g.
1681 * after PRU_SHUTDOWN), and just have to play tedious game waiting
1682 * for peer to send FIN or not respond to keep-alives, etc.
1683 * We can let the user exit from the close as soon as the FIN is acked.
1685 static struct tcpcb
*
1686 tcp_usrclosed(struct tcpcb
*tp
)
1689 switch (tp
->t_state
) {
1693 tp
->t_state
= TCPS_CLOSED
;
1698 case TCPS_SYN_RECEIVED
:
1699 tp
->t_flags
|= TF_NEEDFIN
;
1702 case TCPS_ESTABLISHED
:
1703 tp
->t_state
= TCPS_FIN_WAIT_1
;
1706 case TCPS_CLOSE_WAIT
:
1707 tp
->t_state
= TCPS_LAST_ACK
;
1710 if (tp
&& tp
->t_state
>= TCPS_FIN_WAIT_2
) {
1711 soisdisconnected(tp
->t_inpcb
->inp_socket
);
1712 /* To prevent the connection hanging in FIN_WAIT_2 forever. */
1713 if (tp
->t_state
== TCPS_FIN_WAIT_2
) {
1714 tcp_callout_reset(tp
, tp
->tt_2msl
, tp
->t_maxidle
,