1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-10-03 16:54:17 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
|
1994-05-24 10:09:53 +00:00
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1995-10-03 16:54:17 +00:00
|
|
|
* @(#)tcp_subr.c 8.2 (Berkeley) 5/24/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-25 04:23:33 +00:00
|
|
|
#include "opt_compat.h"
|
1999-12-07 17:39:16 +00:00
|
|
|
#include "opt_inet6.h"
|
2000-01-15 14:56:38 +00:00
|
|
|
#include "opt_ipsec.h"
|
1997-09-16 18:36:06 +00:00
|
|
|
#include "opt_tcpdebug.h"
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1999-08-30 21:17:07 +00:00
|
|
|
#include <sys/callout.h>
|
1995-11-09 20:23:09 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <sys/domain.h>
|
|
|
|
#endif
|
1999-07-11 18:32:46 +00:00
|
|
|
#include <sys/proc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
|
|
|
#include <sys/protosw.h>
|
1998-03-28 10:18:26 +00:00
|
|
|
|
1998-03-24 18:06:34 +00:00
|
|
|
#include <vm/vm_zone.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <net/if.h>
|
|
|
|
|
1996-07-24 18:46:19 +00:00
|
|
|
#define _IP_VHL
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_systm.h>
|
|
|
|
#include <netinet/ip.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet/ip6.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/in_pcb.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/in6_pcb.h>
|
|
|
|
#endif
|
1995-03-16 18:17:34 +00:00
|
|
|
#include <netinet/in_var.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/ip_var.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/ip6_var.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <netinet/tcp_fsm.h>
|
|
|
|
#include <netinet/tcp_seq.h>
|
|
|
|
#include <netinet/tcp_timer.h>
|
|
|
|
#include <netinet/tcp_var.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/tcp6_var.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/tcpip.h>
|
1995-02-09 23:13:27 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
#include <netinet/tcp_debug.h>
|
|
|
|
#endif
|
2000-01-09 19:17:30 +00:00
|
|
|
#include <netinet6/ip6protosw.h>
|
|
|
|
|
|
|
|
#ifdef IPSEC
|
|
|
|
#include <netinet6/ipsec.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/ipsec6.h>
|
|
|
|
#endif
|
2000-01-09 19:17:30 +00:00
|
|
|
#endif /*IPSEC*/
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-03-27 19:14:27 +00:00
|
|
|
#include <machine/in_cksum.h>
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
int tcp_mssdflt = TCP_MSS;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt, CTLFLAG_RW,
|
|
|
|
&tcp_mssdflt , 0, "Default TCP Maximum Segment Size");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
1999-11-05 14:41:39 +00:00
|
|
|
#ifdef INET6
|
|
|
|
int tcp_v6mssdflt = TCP6_MSS;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, TCPCTL_V6MSSDFLT, v6mssdflt,
|
2000-01-09 19:17:30 +00:00
|
|
|
CTLFLAG_RW, &tcp_v6mssdflt , 0,
|
|
|
|
"Default TCP Maximum Segment Size for IPv6");
|
1999-11-05 14:41:39 +00:00
|
|
|
#endif
|
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
#if 0
|
1995-11-14 20:34:56 +00:00
|
|
|
static int tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, TCPCTL_RTTDFLT, rttdflt, CTLFLAG_RW,
|
|
|
|
&tcp_rttdflt , 0, "Default maximum TCP Round Trip Time");
|
1999-08-30 21:17:07 +00:00
|
|
|
#endif
|
1995-11-14 20:34:56 +00:00
|
|
|
|
|
|
|
static int tcp_do_rfc1323 = 1;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, CTLFLAG_RW,
|
|
|
|
&tcp_do_rfc1323 , 0, "Enable rfc1323 (high performance TCP) extensions");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
1998-09-06 08:17:35 +00:00
|
|
|
static int tcp_do_rfc1644 = 0;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1644, rfc1644, CTLFLAG_RW,
|
|
|
|
&tcp_do_rfc1644 , 0, "Enable rfc1644 (TTCP) extensions");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
1999-08-26 19:52:17 +00:00
|
|
|
static int tcp_tcbhashsize = 0;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, tcbhashsize, CTLFLAG_RD,
|
|
|
|
&tcp_tcbhashsize, 0, "Size of TCP control-block hashtable");
|
|
|
|
|
1999-12-28 23:18:33 +00:00
|
|
|
static int do_tcpdrain = 1;
|
2000-09-25 23:40:22 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_tcpdrain, CTLFLAG_RW, &do_tcpdrain, 0,
|
|
|
|
"Enable tcp_drain routine for extra help when low on mbufs");
|
1999-12-28 23:18:33 +00:00
|
|
|
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_RD,
|
|
|
|
&tcbinfo.ipi_count, 0, "Number of active PCBs");
|
1998-05-15 20:11:40 +00:00
|
|
|
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
/*
|
2001-02-18 09:34:55 +00:00
|
|
|
* Treat ICMP unreachables like a TCP RST as required by rfc1122 section 3.2.2.1
|
|
|
|
*
|
|
|
|
* Administatively prohibited kill's sessions regardless of
|
|
|
|
* their current state, other unreachable by default only kill
|
|
|
|
* sessions if they are in SYN-SENT state, this ensure temporary
|
|
|
|
* routing problems doesn't kill existing TCP sessions.
|
|
|
|
* This can be overridden by icmp_like_rst_syn_sent_only.
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
*/
|
|
|
|
|
2001-02-18 09:34:55 +00:00
|
|
|
static int icmp_unreach_like_rst = 1;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_unreach_like_rst, CTLFLAG_RW,
|
|
|
|
&icmp_unreach_like_rst, 0,
|
|
|
|
"Treat ICMP unreachable messages like TCP RST, rfc1122 section 3.2.2.1");
|
2000-12-24 10:57:21 +00:00
|
|
|
|
|
|
|
/*
|
2001-02-18 09:34:55 +00:00
|
|
|
* Control if ICMP unreachable messages other that administratively prohibited
|
|
|
|
* ones will kill sessions not in SYN-SENT state.
|
|
|
|
*
|
|
|
|
* Has no effect unless icmp_unreach_like_rst is enabled.
|
2000-12-24 10:57:21 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int icmp_like_rst_syn_sent_only = 1;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_like_rst_syn_sent_only, CTLFLAG_RW,
|
|
|
|
&icmp_like_rst_syn_sent_only, 0,
|
2001-02-18 09:34:55 +00:00
|
|
|
"When icmp_unreach_like_rst is enabled, only act on sessions in SYN-SENT state");
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
|
1997-09-16 11:44:05 +00:00
|
|
|
static void tcp_cleartaocache __P((void));
|
1995-11-14 20:34:56 +00:00
|
|
|
static void tcp_notify __P((struct inpcb *, int));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-04-09 01:29:31 +00:00
|
|
|
/*
|
Improved connection establishment performance by doing local port lookups via
a hashed port list. In the new scheme, in_pcblookup() goes away and is
replaced by a new routine, in_pcblookup_local() for doing the local port
check. Note that this implementation is space inefficient in that the PCB
struct is now too large to fit into 128 bytes. I might deal with this in the
future by using the new zone allocator, but I wanted these changes to be
extensively tested in their current form first.
Also:
1) Fixed off-by-one errors in the port lookup loops in in_pcbbind().
2) Got rid of some unneeded rehashing. Adding a new routine, in_pcbinshash()
to do the initialial hash insertion.
3) Renamed in_pcblookuphash() to in_pcblookup_hash() for easier readability.
4) Added a new routine, in_pcbremlists() to remove the PCB from the various
hash lists.
5) Added/deleted comments where appropriate.
6) Removed unnecessary splnet() locking. In general, the PCB functions should
be called at splnet()...there are unfortunately a few exceptions, however.
7) Reorganized a few structs for better cache line behavior.
8) Killed my TCP_ACK_HACK kludge. It may come back in a different form in
the future, however.
These changes have been tested on wcarchive for more than a month. In tests
done here, connection establishment overhead is reduced by more than 50
times, thus getting rid of one of the major networking scalability problems.
Still to do: make tcp_fastimo/tcp_slowtimo scale well for systems with a
large number of connections. tcp_fastimo is easy; tcp_slowtimo is difficult.
WARNING: Anything that knows about inpcb and tcpcb structs will have to be
recompiled; at the very least, this includes netstat(1).
1998-01-27 09:15:13 +00:00
|
|
|
* Target size of TCP PCB hash tables. Must be a power of two.
|
1999-02-03 08:59:30 +00:00
|
|
|
*
|
|
|
|
* Note that this can be overridden by the kernel environment
|
|
|
|
* variable net.inet.tcp.tcbhashsize
|
1995-04-09 01:29:31 +00:00
|
|
|
*/
|
|
|
|
#ifndef TCBHASHSIZE
|
Improved connection establishment performance by doing local port lookups via
a hashed port list. In the new scheme, in_pcblookup() goes away and is
replaced by a new routine, in_pcblookup_local() for doing the local port
check. Note that this implementation is space inefficient in that the PCB
struct is now too large to fit into 128 bytes. I might deal with this in the
future by using the new zone allocator, but I wanted these changes to be
extensively tested in their current form first.
Also:
1) Fixed off-by-one errors in the port lookup loops in in_pcbbind().
2) Got rid of some unneeded rehashing. Adding a new routine, in_pcbinshash()
to do the initialial hash insertion.
3) Renamed in_pcblookuphash() to in_pcblookup_hash() for easier readability.
4) Added a new routine, in_pcbremlists() to remove the PCB from the various
hash lists.
5) Added/deleted comments where appropriate.
6) Removed unnecessary splnet() locking. In general, the PCB functions should
be called at splnet()...there are unfortunately a few exceptions, however.
7) Reorganized a few structs for better cache line behavior.
8) Killed my TCP_ACK_HACK kludge. It may come back in a different form in
the future, however.
These changes have been tested on wcarchive for more than a month. In tests
done here, connection establishment overhead is reduced by more than 50
times, thus getting rid of one of the major networking scalability problems.
Still to do: make tcp_fastimo/tcp_slowtimo scale well for systems with a
large number of connections. tcp_fastimo is easy; tcp_slowtimo is difficult.
WARNING: Anything that knows about inpcb and tcpcb structs will have to be
recompiled; at the very least, this includes netstat(1).
1998-01-27 09:15:13 +00:00
|
|
|
#define TCBHASHSIZE 512
|
1995-04-09 01:29:31 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-03-24 18:06:34 +00:00
|
|
|
/*
|
|
|
|
* This is the actual shape of what we allocate using the zone
|
|
|
|
* allocator. Doing it this way allows us to protect both structures
|
|
|
|
* using the same generation count, and also eliminates the overhead
|
|
|
|
* of allocating tcpcbs separately. By hiding the structure here,
|
|
|
|
* we avoid changing most of the rest of the code (although it needs
|
|
|
|
* to be changed, eventually, for greater efficiency).
|
|
|
|
*/
|
1998-03-28 10:18:26 +00:00
|
|
|
#define ALIGNMENT 32
|
|
|
|
#define ALIGNM1 (ALIGNMENT - 1)
|
1998-03-24 18:06:34 +00:00
|
|
|
struct inp_tp {
|
|
|
|
union {
|
|
|
|
struct inpcb inp;
|
|
|
|
char align[(sizeof(struct inpcb) + ALIGNM1) & ~ALIGNM1];
|
|
|
|
} inp_tp_u;
|
|
|
|
struct tcpcb tcb;
|
1999-08-30 21:17:07 +00:00
|
|
|
struct callout inp_tp_rexmt, inp_tp_persist, inp_tp_keep, inp_tp_2msl;
|
|
|
|
struct callout inp_tp_delack;
|
1998-03-24 18:06:34 +00:00
|
|
|
};
|
|
|
|
#undef ALIGNMENT
|
|
|
|
#undef ALIGNM1
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Tcp initialization
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
tcp_init()
|
|
|
|
{
|
1999-02-03 08:59:30 +00:00
|
|
|
int hashsize;
|
|
|
|
|
2000-09-29 01:37:19 +00:00
|
|
|
tcp_iss = arc4random(); /* wrong, but better than a constant */
|
1995-02-09 23:13:27 +00:00
|
|
|
tcp_ccgen = 1;
|
|
|
|
tcp_cleartaocache();
|
1999-08-30 21:17:07 +00:00
|
|
|
|
|
|
|
tcp_delacktime = TCPTV_DELACK;
|
|
|
|
tcp_keepinit = TCPTV_KEEP_INIT;
|
|
|
|
tcp_keepidle = TCPTV_KEEP_IDLE;
|
|
|
|
tcp_keepintvl = TCPTV_KEEPINTVL;
|
|
|
|
tcp_maxpersistidle = TCPTV_KEEP_IDLE;
|
|
|
|
tcp_msl = TCPTV_MSL;
|
|
|
|
|
1995-04-09 01:29:31 +00:00
|
|
|
LIST_INIT(&tcb);
|
|
|
|
tcbinfo.listhead = &tcb;
|
1999-07-05 08:46:55 +00:00
|
|
|
TUNABLE_INT_FETCH("net.inet.tcp.tcbhashsize", TCBHASHSIZE, hashsize);
|
1999-02-04 03:27:43 +00:00
|
|
|
if (!powerof2(hashsize)) {
|
1999-02-03 08:59:30 +00:00
|
|
|
printf("WARNING: TCB hash size not a power of 2\n");
|
|
|
|
hashsize = 512; /* safe default */
|
|
|
|
}
|
1999-08-26 19:52:17 +00:00
|
|
|
tcp_tcbhashsize = hashsize;
|
1999-02-03 08:59:30 +00:00
|
|
|
tcbinfo.hashbase = hashinit(hashsize, M_PCB, &tcbinfo.hashmask);
|
|
|
|
tcbinfo.porthashbase = hashinit(hashsize, M_PCB,
|
1998-03-28 10:18:26 +00:00
|
|
|
&tcbinfo.porthashmask);
|
1998-05-15 20:11:40 +00:00
|
|
|
tcbinfo.ipi_zone = zinit("tcpcb", sizeof(struct inp_tp), maxsockets,
|
1998-03-24 18:06:34 +00:00
|
|
|
ZONE_INTERRUPT, 0);
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#define TCP_MINPROTOHDR (sizeof(struct ip6_hdr) + sizeof(struct tcphdr))
|
|
|
|
#else /* INET6 */
|
|
|
|
#define TCP_MINPROTOHDR (sizeof(struct tcpiphdr))
|
|
|
|
#endif /* INET6 */
|
|
|
|
if (max_protohdr < TCP_MINPROTOHDR)
|
|
|
|
max_protohdr = TCP_MINPROTOHDR;
|
|
|
|
if (max_linkhdr + TCP_MINPROTOHDR > MHLEN)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("tcp_init");
|
2000-01-09 19:17:30 +00:00
|
|
|
#undef TCP_MINPROTOHDR
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create template to be used to send tcp packets on a connection.
|
|
|
|
* Call after host entry created, allocates an mbuf and fills
|
|
|
|
* in a skeletal tcp/ip header, minimizing the amount of work
|
|
|
|
* necessary when the connection is used.
|
|
|
|
*/
|
2000-01-09 19:17:30 +00:00
|
|
|
struct tcptemp *
|
1994-05-24 10:09:53 +00:00
|
|
|
tcp_template(tp)
|
|
|
|
struct tcpcb *tp;
|
|
|
|
{
|
|
|
|
register struct inpcb *inp = tp->t_inpcb;
|
|
|
|
register struct mbuf *m;
|
2000-01-09 19:17:30 +00:00
|
|
|
register struct tcptemp *n;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if ((n = tp->t_template) == 0) {
|
|
|
|
m = m_get(M_DONTWAIT, MT_HEADER);
|
|
|
|
if (m == NULL)
|
|
|
|
return (0);
|
2000-01-09 19:17:30 +00:00
|
|
|
m->m_len = sizeof (struct tcptemp);
|
|
|
|
n = mtod(m, struct tcptemp *);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if ((inp->inp_vflag & INP_IPV6) != 0) {
|
|
|
|
register struct ip6_hdr *ip6;
|
|
|
|
|
|
|
|
ip6 = (struct ip6_hdr *)n->tt_ipgen;
|
|
|
|
ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
|
|
|
|
(inp->in6p_flowinfo & IPV6_FLOWINFO_MASK);
|
|
|
|
ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
|
|
|
|
(IPV6_VERSION & IPV6_VERSION_MASK);
|
|
|
|
ip6->ip6_nxt = IPPROTO_TCP;
|
|
|
|
ip6->ip6_plen = sizeof(struct tcphdr);
|
|
|
|
ip6->ip6_src = inp->in6p_laddr;
|
|
|
|
ip6->ip6_dst = inp->in6p_faddr;
|
2000-03-27 19:14:27 +00:00
|
|
|
n->tt_t.th_sum = 0;
|
2000-01-09 19:17:30 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2000-03-27 19:14:27 +00:00
|
|
|
struct ip *ip = (struct ip *)n->tt_ipgen;
|
2000-01-09 19:17:30 +00:00
|
|
|
|
2000-03-27 19:14:27 +00:00
|
|
|
bzero(ip, sizeof(struct ip)); /* XXX overkill? */
|
|
|
|
ip->ip_vhl = IP_VHL_BORING;
|
|
|
|
ip->ip_p = IPPROTO_TCP;
|
|
|
|
ip->ip_src = inp->inp_laddr;
|
|
|
|
ip->ip_dst = inp->inp_faddr;
|
|
|
|
n->tt_t.th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
|
|
|
|
htons(sizeof(struct tcphdr) + IPPROTO_TCP));
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
|
|
|
n->tt_t.th_sport = inp->inp_lport;
|
|
|
|
n->tt_t.th_dport = inp->inp_fport;
|
|
|
|
n->tt_t.th_seq = 0;
|
|
|
|
n->tt_t.th_ack = 0;
|
|
|
|
n->tt_t.th_x2 = 0;
|
|
|
|
n->tt_t.th_off = 5;
|
|
|
|
n->tt_t.th_flags = 0;
|
|
|
|
n->tt_t.th_win = 0;
|
|
|
|
n->tt_t.th_urp = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send a single message to the TCP at address specified by
|
|
|
|
* the given TCP/IP header. If m == 0, then we make a copy
|
|
|
|
* of the tcpiphdr at ti and send directly to the addressed host.
|
|
|
|
* This is used to force keep alive messages out using the TCP
|
|
|
|
* template for a connection tp->t_template. If flags are given
|
|
|
|
* then we send a message back to the TCP which originated the
|
|
|
|
* segment ti, and discard the mbuf containing it and any other
|
|
|
|
* attached mbufs.
|
|
|
|
*
|
|
|
|
* In any case the ack and sequence number of the transmitted
|
|
|
|
* segment are as specified by the parameters.
|
1997-12-19 03:36:15 +00:00
|
|
|
*
|
|
|
|
* NOTE: If m != NULL, then ti must point to *inside* the mbuf.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
2000-01-09 19:17:30 +00:00
|
|
|
tcp_respond(tp, ipgen, th, m, ack, seq, flags)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct tcpcb *tp;
|
2000-01-09 19:17:30 +00:00
|
|
|
void *ipgen;
|
|
|
|
register struct tcphdr *th;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct mbuf *m;
|
|
|
|
tcp_seq ack, seq;
|
|
|
|
int flags;
|
|
|
|
{
|
|
|
|
register int tlen;
|
|
|
|
int win = 0;
|
|
|
|
struct route *ro = 0;
|
1996-03-22 18:11:25 +00:00
|
|
|
struct route sro;
|
2000-01-09 19:17:30 +00:00
|
|
|
struct ip *ip;
|
|
|
|
struct tcphdr *nth;
|
|
|
|
#ifdef INET6
|
|
|
|
struct route_in6 *ro6 = 0;
|
|
|
|
struct route_in6 sro6;
|
|
|
|
struct ip6_hdr *ip6;
|
|
|
|
int isipv6;
|
|
|
|
#endif /* INET6 */
|
|
|
|
int ipflags = 0;
|
|
|
|
|
|
|
|
#ifdef INET6
|
|
|
|
isipv6 = IP_VHL_V(((struct ip *)ipgen)->ip_vhl) == 6;
|
|
|
|
ip6 = ipgen;
|
|
|
|
#endif /* INET6 */
|
|
|
|
ip = ipgen;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (tp) {
|
2000-02-28 21:18:21 +00:00
|
|
|
if (!(flags & TH_RST)) {
|
1998-11-15 21:35:09 +00:00
|
|
|
win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
|
2000-02-28 21:18:21 +00:00
|
|
|
if (win > (long)TCP_MAXWIN << tp->rcv_scale)
|
|
|
|
win = (long)TCP_MAXWIN << tp->rcv_scale;
|
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6)
|
|
|
|
ro6 = &tp->t_inpcb->in6p_route;
|
|
|
|
else
|
|
|
|
#endif /* INET6 */
|
1994-05-24 10:09:53 +00:00
|
|
|
ro = &tp->t_inpcb->inp_route;
|
1996-03-22 18:11:25 +00:00
|
|
|
} else {
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
ro6 = &sro6;
|
|
|
|
bzero(ro6, sizeof *ro6);
|
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
1996-03-22 18:11:25 +00:00
|
|
|
ro = &sro;
|
|
|
|
bzero(ro, sizeof *ro);
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (m == 0) {
|
|
|
|
m = m_gethdr(M_DONTWAIT, MT_HEADER);
|
|
|
|
if (m == NULL)
|
|
|
|
return;
|
|
|
|
#ifdef TCP_COMPAT_42
|
|
|
|
tlen = 1;
|
|
|
|
#else
|
|
|
|
tlen = 0;
|
|
|
|
#endif
|
|
|
|
m->m_data += max_linkhdr;
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
bcopy((caddr_t)ip6, mtod(m, caddr_t),
|
|
|
|
sizeof(struct ip6_hdr));
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
nth = (struct tcphdr *)(ip6 + 1);
|
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
|
|
|
bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
nth = (struct tcphdr *)(ip + 1);
|
|
|
|
}
|
|
|
|
bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
|
1994-05-24 10:09:53 +00:00
|
|
|
flags = TH_ACK;
|
|
|
|
} else {
|
|
|
|
m_freem(m->m_next);
|
|
|
|
m->m_next = 0;
|
2000-01-09 19:17:30 +00:00
|
|
|
m->m_data = (caddr_t)ipgen;
|
|
|
|
/* m_len is set later */
|
1994-05-24 10:09:53 +00:00
|
|
|
tlen = 0;
|
|
|
|
#define xchg(a,b,type) { type t; t=a; a=b; b=t; }
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
|
|
|
|
nth = (struct tcphdr *)(ip6 + 1);
|
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
|
|
|
xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, n_long);
|
|
|
|
nth = (struct tcphdr *)(ip + 1);
|
|
|
|
}
|
|
|
|
if (th != nth) {
|
|
|
|
/*
|
|
|
|
* this is usually a case when an extension header
|
|
|
|
* exists between the IPv6 header and the
|
|
|
|
* TCP header.
|
|
|
|
*/
|
|
|
|
nth->th_sport = th->th_sport;
|
|
|
|
nth->th_dport = th->th_dport;
|
|
|
|
}
|
|
|
|
xchg(nth->th_dport, nth->th_sport, n_short);
|
1994-05-24 10:09:53 +00:00
|
|
|
#undef xchg
|
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
ip6->ip6_plen = htons((u_short)(sizeof (struct tcphdr) +
|
|
|
|
tlen));
|
|
|
|
tlen += sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
|
2000-01-15 14:34:56 +00:00
|
|
|
} else
|
2000-01-09 19:17:30 +00:00
|
|
|
#endif
|
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
tlen += sizeof (struct tcpiphdr);
|
2000-03-27 19:14:27 +00:00
|
|
|
ip->ip_len = tlen;
|
|
|
|
ip->ip_ttl = ip_defttl;
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
m->m_len = tlen;
|
|
|
|
m->m_pkthdr.len = tlen;
|
|
|
|
m->m_pkthdr.rcvif = (struct ifnet *) 0;
|
2000-01-09 19:17:30 +00:00
|
|
|
nth->th_seq = htonl(seq);
|
|
|
|
nth->th_ack = htonl(ack);
|
|
|
|
nth->th_x2 = 0;
|
|
|
|
nth->th_off = sizeof (struct tcphdr) >> 2;
|
|
|
|
nth->th_flags = flags;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (tp)
|
2000-01-09 19:17:30 +00:00
|
|
|
nth->th_win = htons((u_short) (win >> tp->rcv_scale));
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2000-01-09 19:17:30 +00:00
|
|
|
nth->th_win = htons((u_short)win);
|
|
|
|
nth->th_urp = 0;
|
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
2000-04-19 15:05:00 +00:00
|
|
|
nth->th_sum = 0;
|
2000-01-09 19:17:30 +00:00
|
|
|
nth->th_sum = in6_cksum(m, IPPROTO_TCP,
|
|
|
|
sizeof(struct ip6_hdr),
|
|
|
|
tlen - sizeof(struct ip6_hdr));
|
|
|
|
ip6->ip6_hlim = in6_selecthlim(tp ? tp->t_inpcb : NULL,
|
|
|
|
ro6 && ro6->ro_rt ?
|
|
|
|
ro6->ro_rt->rt_ifp :
|
|
|
|
NULL);
|
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
2000-03-27 19:14:27 +00:00
|
|
|
nth->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
|
|
|
|
htons((u_short)(tlen - sizeof(struct ip) + ip->ip_p)));
|
|
|
|
m->m_pkthdr.csum_flags = CSUM_TCP;
|
|
|
|
m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
1995-02-09 23:13:27 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
if (tp == NULL || (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
|
2000-01-09 19:17:30 +00:00
|
|
|
tcp_trace(TA_OUTPUT, 0, tp, mtod(m, void *), th, 0);
|
|
|
|
#endif
|
|
|
|
#ifdef IPSEC
|
2000-07-04 16:35:15 +00:00
|
|
|
ipsec_setsocket(m, tp ? tp->t_inpcb->inp_socket : NULL);
|
1995-02-09 23:13:27 +00:00
|
|
|
#endif
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
(void)ip6_output(m, NULL, ro6, ipflags, NULL, NULL);
|
2000-01-13 14:21:30 +00:00
|
|
|
if (ro6 == &sro6 && ro6->ro_rt) {
|
2000-01-09 19:17:30 +00:00
|
|
|
RTFREE(ro6->ro_rt);
|
2000-01-13 14:21:30 +00:00
|
|
|
ro6->ro_rt = NULL;
|
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
|
|
|
(void) ip_output(m, NULL, ro, ipflags, NULL);
|
1996-03-27 18:23:16 +00:00
|
|
|
if (ro == &sro && ro->ro_rt) {
|
1996-03-22 18:11:25 +00:00
|
|
|
RTFREE(ro->ro_rt);
|
2000-01-13 14:21:30 +00:00
|
|
|
ro->ro_rt = NULL;
|
1996-03-22 18:11:25 +00:00
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new TCP control block, making an
|
|
|
|
* empty reassembly queue and hooking it to the argument
|
1998-03-24 18:06:34 +00:00
|
|
|
* protocol control block. The `inp' parameter must have
|
|
|
|
* come from the zone allocator set up in tcp_init().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
struct tcpcb *
|
|
|
|
tcp_newtcpcb(inp)
|
|
|
|
struct inpcb *inp;
|
|
|
|
{
|
1998-03-28 10:18:26 +00:00
|
|
|
struct inp_tp *it;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct tcpcb *tp;
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
|
|
|
|
#endif /* INET6 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-03-24 18:06:34 +00:00
|
|
|
it = (struct inp_tp *)inp;
|
|
|
|
tp = &it->tcb;
|
1994-05-24 10:09:53 +00:00
|
|
|
bzero((char *) tp, sizeof(struct tcpcb));
|
2000-01-09 19:17:30 +00:00
|
|
|
LIST_INIT(&tp->t_segq);
|
|
|
|
tp->t_maxseg = tp->t_maxopd =
|
|
|
|
#ifdef INET6
|
|
|
|
isipv6 ? tcp_v6mssdflt :
|
|
|
|
#endif /* INET6 */
|
|
|
|
tcp_mssdflt;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
/* Set up our timeouts. */
|
2000-11-25 06:22:16 +00:00
|
|
|
callout_init(tp->tt_rexmt = &it->inp_tp_rexmt, 0);
|
|
|
|
callout_init(tp->tt_persist = &it->inp_tp_persist, 0);
|
|
|
|
callout_init(tp->tt_keep = &it->inp_tp_keep, 0);
|
|
|
|
callout_init(tp->tt_2msl = &it->inp_tp_2msl, 0);
|
|
|
|
callout_init(tp->tt_delack = &it->inp_tp_delack, 0);
|
1999-08-30 21:17:07 +00:00
|
|
|
|
1995-02-09 23:13:27 +00:00
|
|
|
if (tcp_do_rfc1323)
|
|
|
|
tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP);
|
|
|
|
if (tcp_do_rfc1644)
|
|
|
|
tp->t_flags |= TF_REQ_CC;
|
1998-03-24 18:06:34 +00:00
|
|
|
tp->t_inpcb = inp; /* XXX */
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
|
1996-06-14 17:17:32 +00:00
|
|
|
* rtt estimate. Set rttvar so that srtt + 4 * rttvar gives
|
1994-05-24 10:09:53 +00:00
|
|
|
* reasonable initial retransmit time.
|
|
|
|
*/
|
|
|
|
tp->t_srtt = TCPTV_SRTTBASE;
|
1996-06-14 17:17:32 +00:00
|
|
|
tp->t_rttvar = ((TCPTV_RTOBASE - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4;
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_rttmin = TCPTV_MIN;
|
1996-06-14 17:17:32 +00:00
|
|
|
tp->t_rxtcur = TCPTV_RTOBASE;
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
|
|
|
|
tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->t_rcvtime = ticks;
|
2000-01-25 01:05:18 +00:00
|
|
|
/*
|
|
|
|
* IPv4 TTL initialization is necessary for an IPv6 socket as well,
|
|
|
|
* because the socket may be bound to an IPv6 wildcard address,
|
|
|
|
* which may match an IPv4-mapped IPv6 address.
|
|
|
|
*/
|
1997-04-03 05:14:45 +00:00
|
|
|
inp->inp_ip_ttl = ip_defttl;
|
1994-05-24 10:09:53 +00:00
|
|
|
inp->inp_ppcb = (caddr_t)tp;
|
1998-03-24 18:06:34 +00:00
|
|
|
return (tp); /* XXX */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop a TCP connection, reporting
|
|
|
|
* the specified error. If connection is synchronized,
|
|
|
|
* then send a RST to peer.
|
|
|
|
*/
|
|
|
|
struct tcpcb *
|
|
|
|
tcp_drop(tp, errno)
|
|
|
|
register struct tcpcb *tp;
|
|
|
|
int errno;
|
|
|
|
{
|
|
|
|
struct socket *so = tp->t_inpcb->inp_socket;
|
|
|
|
|
|
|
|
if (TCPS_HAVERCVDSYN(tp->t_state)) {
|
|
|
|
tp->t_state = TCPS_CLOSED;
|
|
|
|
(void) tcp_output(tp);
|
|
|
|
tcpstat.tcps_drops++;
|
|
|
|
} else
|
|
|
|
tcpstat.tcps_conndrops++;
|
|
|
|
if (errno == ETIMEDOUT && tp->t_softerror)
|
|
|
|
errno = tp->t_softerror;
|
|
|
|
so->so_error = errno;
|
|
|
|
return (tcp_close(tp));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close a TCP control block:
|
|
|
|
* discard all space held by the tcp
|
|
|
|
* discard internet protocol block
|
|
|
|
* wake up any sleepers
|
|
|
|
*/
|
|
|
|
struct tcpcb *
|
|
|
|
tcp_close(tp)
|
|
|
|
register struct tcpcb *tp;
|
|
|
|
{
|
2000-01-09 19:17:30 +00:00
|
|
|
register struct tseg_qent *q;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct inpcb *inp = tp->t_inpcb;
|
|
|
|
struct socket *so = inp->inp_socket;
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
|
|
|
|
#endif /* INET6 */
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct rtentry *rt;
|
1997-02-14 18:15:53 +00:00
|
|
|
int dosavessthresh;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
/*
|
|
|
|
* Make sure that all of our timers are stopped before we
|
|
|
|
* delete the PCB.
|
|
|
|
*/
|
|
|
|
callout_stop(tp->tt_rexmt);
|
|
|
|
callout_stop(tp->tt_persist);
|
|
|
|
callout_stop(tp->tt_keep);
|
|
|
|
callout_stop(tp->tt_2msl);
|
|
|
|
callout_stop(tp->tt_delack);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-06-29 18:11:24 +00:00
|
|
|
* If we got enough samples through the srtt filter,
|
|
|
|
* save the rtt and rttvar in the routing entry.
|
|
|
|
* 'Enough' is arbitrarily defined as the 16 samples.
|
|
|
|
* 16 samples is enough for the srtt filter to converge
|
|
|
|
* to within 5% of the correct value; fewer samples and
|
|
|
|
* we could save a very bogus rtt.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
* Don't update the default route's characteristics and don't
|
|
|
|
* update anything that the user "locked".
|
|
|
|
*/
|
2000-01-09 19:17:30 +00:00
|
|
|
if (tp->t_rttupdated >= 16) {
|
1994-05-25 09:21:21 +00:00
|
|
|
register u_long i = 0;
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
if ((rt = inp->in6p_route.ro_rt) == NULL)
|
|
|
|
goto no_valid_rt;
|
|
|
|
sin6 = (struct sockaddr_in6 *)rt_key(rt);
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
|
|
|
|
goto no_valid_rt;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif /* INET6 */
|
|
|
|
if ((rt = inp->inp_route.ro_rt) == NULL ||
|
|
|
|
((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr
|
|
|
|
== INADDR_ANY)
|
|
|
|
goto no_valid_rt;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if ((rt->rt_rmx.rmx_locks & RTV_RTT) == 0) {
|
|
|
|
i = tp->t_srtt *
|
1999-08-30 21:17:07 +00:00
|
|
|
(RTM_RTTUNIT / (hz * TCP_RTT_SCALE));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_rmx.rmx_rtt && i)
|
|
|
|
/*
|
|
|
|
* filter this update to half the old & half
|
|
|
|
* the new values, converting scale.
|
|
|
|
* See route.h and tcp_var.h for a
|
|
|
|
* description of the scaling constants.
|
|
|
|
*/
|
|
|
|
rt->rt_rmx.rmx_rtt =
|
|
|
|
(rt->rt_rmx.rmx_rtt + i) / 2;
|
|
|
|
else
|
|
|
|
rt->rt_rmx.rmx_rtt = i;
|
1995-06-19 16:45:33 +00:00
|
|
|
tcpstat.tcps_cachedrtt++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if ((rt->rt_rmx.rmx_locks & RTV_RTTVAR) == 0) {
|
|
|
|
i = tp->t_rttvar *
|
1999-08-30 21:17:07 +00:00
|
|
|
(RTM_RTTUNIT / (hz * TCP_RTTVAR_SCALE));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_rmx.rmx_rttvar && i)
|
|
|
|
rt->rt_rmx.rmx_rttvar =
|
|
|
|
(rt->rt_rmx.rmx_rttvar + i) / 2;
|
|
|
|
else
|
|
|
|
rt->rt_rmx.rmx_rttvar = i;
|
1995-06-19 16:45:33 +00:00
|
|
|
tcpstat.tcps_cachedrttvar++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
1997-02-14 18:15:53 +00:00
|
|
|
* The old comment here said:
|
1994-05-24 10:09:53 +00:00
|
|
|
* update the pipelimit (ssthresh) if it has been updated
|
|
|
|
* already or if a pipesize was specified & the threshhold
|
|
|
|
* got below half the pipesize. I.e., wait for bad news
|
|
|
|
* before we start updating, then update on both good
|
|
|
|
* and bad news.
|
1997-02-14 18:15:53 +00:00
|
|
|
*
|
|
|
|
* But we want to save the ssthresh even if no pipesize is
|
|
|
|
* specified explicitly in the route, because such
|
|
|
|
* connections still have an implicit pipesize specified
|
|
|
|
* by the global tcp_sendspace. In the absence of a reliable
|
|
|
|
* way to calculate the pipesize, it will have to do.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-02-14 18:15:53 +00:00
|
|
|
i = tp->snd_ssthresh;
|
|
|
|
if (rt->rt_rmx.rmx_sendpipe != 0)
|
|
|
|
dosavessthresh = (i < rt->rt_rmx.rmx_sendpipe / 2);
|
|
|
|
else
|
|
|
|
dosavessthresh = (i < so->so_snd.sb_hiwat / 2);
|
1994-10-08 22:39:58 +00:00
|
|
|
if (((rt->rt_rmx.rmx_locks & RTV_SSTHRESH) == 0 &&
|
1997-02-14 18:15:53 +00:00
|
|
|
i != 0 && rt->rt_rmx.rmx_ssthresh != 0)
|
|
|
|
|| dosavessthresh) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* convert the limit from user data bytes to
|
|
|
|
* packets then to packet data bytes.
|
|
|
|
*/
|
|
|
|
i = (i + tp->t_maxseg / 2) / tp->t_maxseg;
|
|
|
|
if (i < 2)
|
|
|
|
i = 2;
|
2000-01-09 19:17:30 +00:00
|
|
|
i *= (u_long)(tp->t_maxseg +
|
|
|
|
#ifdef INET6
|
|
|
|
(isipv6 ? sizeof (struct ip6_hdr) +
|
|
|
|
sizeof (struct tcphdr) :
|
|
|
|
#endif
|
|
|
|
sizeof (struct tcpiphdr)
|
|
|
|
#ifdef INET6
|
|
|
|
)
|
|
|
|
#endif
|
|
|
|
);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_rmx.rmx_ssthresh)
|
|
|
|
rt->rt_rmx.rmx_ssthresh =
|
|
|
|
(rt->rt_rmx.rmx_ssthresh + i) / 2;
|
|
|
|
else
|
|
|
|
rt->rt_rmx.rmx_ssthresh = i;
|
1995-06-19 16:45:33 +00:00
|
|
|
tcpstat.tcps_cachedssthresh++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2000-07-21 23:26:37 +00:00
|
|
|
rt = inp->inp_route.ro_rt;
|
|
|
|
if (rt) {
|
|
|
|
/*
|
|
|
|
* mark route for deletion if no information is
|
|
|
|
* cached.
|
|
|
|
*/
|
|
|
|
if ((tp->t_flags & TF_LQ_OVERFLOW) &&
|
|
|
|
((rt->rt_rmx.rmx_locks & RTV_RTT) == 0)){
|
|
|
|
if (rt->rt_rmx.rmx_rtt == 0)
|
|
|
|
rt->rt_flags |= RTF_DELCLONE;
|
|
|
|
}
|
|
|
|
}
|
2000-01-09 19:17:30 +00:00
|
|
|
no_valid_rt:
|
1994-05-24 10:09:53 +00:00
|
|
|
/* free the reassembly queue, if any */
|
2000-01-09 19:17:30 +00:00
|
|
|
while((q = LIST_FIRST(&tp->t_segq)) != NULL) {
|
|
|
|
LIST_REMOVE(q, tqe_q);
|
|
|
|
m_freem(q->tqe_m);
|
|
|
|
FREE(q, M_TSEGQ);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (tp->t_template)
|
|
|
|
(void) m_free(dtom(tp->t_template));
|
Improved connection establishment performance by doing local port lookups via
a hashed port list. In the new scheme, in_pcblookup() goes away and is
replaced by a new routine, in_pcblookup_local() for doing the local port
check. Note that this implementation is space inefficient in that the PCB
struct is now too large to fit into 128 bytes. I might deal with this in the
future by using the new zone allocator, but I wanted these changes to be
extensively tested in their current form first.
Also:
1) Fixed off-by-one errors in the port lookup loops in in_pcbbind().
2) Got rid of some unneeded rehashing. Adding a new routine, in_pcbinshash()
to do the initialial hash insertion.
3) Renamed in_pcblookuphash() to in_pcblookup_hash() for easier readability.
4) Added a new routine, in_pcbremlists() to remove the PCB from the various
hash lists.
5) Added/deleted comments where appropriate.
6) Removed unnecessary splnet() locking. In general, the PCB functions should
be called at splnet()...there are unfortunately a few exceptions, however.
7) Reorganized a few structs for better cache line behavior.
8) Killed my TCP_ACK_HACK kludge. It may come back in a different form in
the future, however.
These changes have been tested on wcarchive for more than a month. In tests
done here, connection establishment overhead is reduced by more than 50
times, thus getting rid of one of the major networking scalability problems.
Still to do: make tcp_fastimo/tcp_slowtimo scale well for systems with a
large number of connections. tcp_fastimo is easy; tcp_slowtimo is difficult.
WARNING: Anything that knows about inpcb and tcpcb structs will have to be
recompiled; at the very least, this includes netstat(1).
1998-01-27 09:15:13 +00:00
|
|
|
inp->inp_ppcb = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
soisdisconnected(so);
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (INP_CHECK_SOCKAF(so, AF_INET6))
|
|
|
|
in6_pcbdetach(inp);
|
|
|
|
else
|
|
|
|
#endif /* INET6 */
|
1994-05-24 10:09:53 +00:00
|
|
|
in_pcbdetach(inp);
|
|
|
|
tcpstat.tcps_closed++;
|
|
|
|
return ((struct tcpcb *)0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tcp_drain()
|
|
|
|
{
|
1999-12-28 23:18:33 +00:00
|
|
|
if (do_tcpdrain)
|
|
|
|
{
|
|
|
|
struct inpcb *inpb;
|
|
|
|
struct tcpcb *tcpb;
|
2000-01-09 19:17:30 +00:00
|
|
|
struct tseg_qent *te;
|
1999-12-28 23:18:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk the tcpbs, if existing, and flush the reassembly queue,
|
|
|
|
* if there is one...
|
|
|
|
* XXX: The "Net/3" implementation doesn't imply that the TCP
|
|
|
|
* reassembly queue should be flushed, but in a situation
|
|
|
|
* where we're really low on mbufs, this is potentially
|
|
|
|
* usefull.
|
|
|
|
*/
|
2001-02-04 13:13:25 +00:00
|
|
|
for (inpb = LIST_FIRST(tcbinfo.listhead); inpb;
|
|
|
|
inpb = LIST_NEXT(inpb, inp_list)) {
|
1999-12-28 23:18:33 +00:00
|
|
|
if ((tcpb = intotcpcb(inpb))) {
|
2000-01-09 19:17:30 +00:00
|
|
|
while ((te = LIST_FIRST(&tcpb->t_segq))
|
|
|
|
!= NULL) {
|
|
|
|
LIST_REMOVE(te, tqe_q);
|
|
|
|
m_freem(te->tqe_m);
|
|
|
|
FREE(te, M_TSEGQ);
|
1999-12-28 23:18:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-12-28 23:18:33 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify a tcp user of an asynchronous error;
|
|
|
|
* store error as soft error, but wake up user
|
|
|
|
* (for now, won't do anything until can select for soft error).
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
tcp_notify(inp, error)
|
|
|
|
struct inpcb *inp;
|
|
|
|
int error;
|
|
|
|
{
|
|
|
|
register struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
|
|
|
|
register struct socket *so = inp->inp_socket;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ignore some errors if we are hooked up.
|
|
|
|
* If connection hasn't completed, has retransmitted several times,
|
|
|
|
* and receives a second error, give up now. This is better
|
|
|
|
* than waiting a long time to establish a connection that
|
|
|
|
* can never complete.
|
|
|
|
*/
|
|
|
|
if (tp->t_state == TCPS_ESTABLISHED &&
|
|
|
|
(error == EHOSTUNREACH || error == ENETUNREACH ||
|
|
|
|
error == EHOSTDOWN)) {
|
|
|
|
return;
|
|
|
|
} else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 &&
|
|
|
|
tp->t_softerror)
|
|
|
|
so->so_error = error;
|
1995-05-30 08:16:23 +00:00
|
|
|
else
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_softerror = error;
|
|
|
|
wakeup((caddr_t) &so->so_timeo);
|
|
|
|
sorwakeup(so);
|
|
|
|
sowwakeup(so);
|
|
|
|
}
|
|
|
|
|
1998-05-15 20:11:40 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
tcp_pcblist(SYSCTL_HANDLER_ARGS)
|
1998-05-15 20:11:40 +00:00
|
|
|
{
|
|
|
|
int error, i, n, s;
|
|
|
|
struct inpcb *inp, **inp_list;
|
|
|
|
inp_gen_t gencnt;
|
|
|
|
struct xinpgen xig;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The process of preparing the TCB list is too time-consuming and
|
|
|
|
* resource-intensive to repeat twice on every request.
|
|
|
|
*/
|
|
|
|
if (req->oldptr == 0) {
|
|
|
|
n = tcbinfo.ipi_count;
|
|
|
|
req->oldidx = 2 * (sizeof xig)
|
|
|
|
+ (n + n/8) * sizeof(struct xtcpcb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->newptr != 0)
|
|
|
|
return EPERM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, now we're committed to doing something.
|
|
|
|
*/
|
|
|
|
s = splnet();
|
|
|
|
gencnt = tcbinfo.ipi_gencnt;
|
|
|
|
n = tcbinfo.ipi_count;
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
xig.xig_len = sizeof xig;
|
|
|
|
xig.xig_count = n;
|
|
|
|
xig.xig_gen = gencnt;
|
|
|
|
xig.xig_sogen = so_gencnt;
|
|
|
|
error = SYSCTL_OUT(req, &xig, sizeof xig);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
inp_list = malloc(n * sizeof *inp_list, M_TEMP, M_WAITOK);
|
|
|
|
if (inp_list == 0)
|
|
|
|
return ENOMEM;
|
|
|
|
|
|
|
|
s = splnet();
|
2001-02-04 13:13:25 +00:00
|
|
|
for (inp = LIST_FIRST(tcbinfo.listhead), i = 0; inp && i < n;
|
|
|
|
inp = LIST_NEXT(inp, inp_list)) {
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
if (inp->inp_gencnt <= gencnt && !prison_xinpcb(req->p, inp))
|
1998-05-15 20:11:40 +00:00
|
|
|
inp_list[i++] = inp;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
n = i;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
inp = inp_list[i];
|
|
|
|
if (inp->inp_gencnt <= gencnt) {
|
|
|
|
struct xtcpcb xt;
|
1999-06-16 19:05:17 +00:00
|
|
|
caddr_t inp_ppcb;
|
1998-05-15 20:11:40 +00:00
|
|
|
xt.xt_len = sizeof xt;
|
|
|
|
/* XXX should avoid extra copy */
|
|
|
|
bcopy(inp, &xt.xt_inp, sizeof *inp);
|
1999-06-16 19:05:17 +00:00
|
|
|
inp_ppcb = inp->inp_ppcb;
|
|
|
|
if (inp_ppcb != NULL)
|
|
|
|
bcopy(inp_ppcb, &xt.xt_tp, sizeof xt.xt_tp);
|
|
|
|
else
|
|
|
|
bzero((char *) &xt.xt_tp, sizeof xt.xt_tp);
|
1998-05-15 20:11:40 +00:00
|
|
|
if (inp->inp_socket)
|
|
|
|
sotoxsocket(inp->inp_socket, &xt.xt_socket);
|
|
|
|
error = SYSCTL_OUT(req, &xt, sizeof xt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!error) {
|
|
|
|
/*
|
|
|
|
* Give the user an updated idea of our state.
|
|
|
|
* If the generation differs from what we told
|
|
|
|
* her before, she knows that something happened
|
|
|
|
* while we were processing this request, and it
|
|
|
|
* might be necessary to retry.
|
|
|
|
*/
|
|
|
|
s = splnet();
|
|
|
|
xig.xig_gen = tcbinfo.ipi_gencnt;
|
|
|
|
xig.xig_sogen = so_gencnt;
|
|
|
|
xig.xig_count = tcbinfo.ipi_count;
|
|
|
|
splx(s);
|
|
|
|
error = SYSCTL_OUT(req, &xig, sizeof xig);
|
|
|
|
}
|
|
|
|
free(inp_list, M_TEMP);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist, CTLFLAG_RD, 0, 0,
|
|
|
|
tcp_pcblist, "S,xtcpcb", "List of active TCP connections");
|
|
|
|
|
1999-07-11 18:32:46 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
tcp_getcred(SYSCTL_HANDLER_ARGS)
|
1999-07-11 18:32:46 +00:00
|
|
|
{
|
2001-02-18 13:30:20 +00:00
|
|
|
struct xucred xuc;
|
1999-07-11 18:32:46 +00:00
|
|
|
struct sockaddr_in addrs[2];
|
|
|
|
struct inpcb *inp;
|
|
|
|
int error, s;
|
|
|
|
|
|
|
|
error = suser(req->p);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = SYSCTL_IN(req, addrs, sizeof(addrs));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
s = splnet();
|
|
|
|
inp = in_pcblookup_hash(&tcbinfo, addrs[1].sin_addr, addrs[1].sin_port,
|
1999-12-07 17:39:16 +00:00
|
|
|
addrs[0].sin_addr, addrs[0].sin_port, 0, NULL);
|
1999-09-19 02:17:02 +00:00
|
|
|
if (inp == NULL || inp->inp_socket == NULL) {
|
1999-07-11 18:32:46 +00:00
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2001-02-18 13:30:20 +00:00
|
|
|
bzero(&xuc, sizeof(xuc));
|
|
|
|
xuc.cr_uid = inp->inp_socket->so_cred->cr_uid;
|
|
|
|
xuc.cr_ngroups = inp->inp_socket->so_cred->cr_ngroups;
|
|
|
|
bcopy(inp->inp_socket->so_cred->cr_groups, xuc.cr_groups,
|
|
|
|
sizeof(xuc.cr_groups));
|
|
|
|
error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
|
1999-07-11 18:32:46 +00:00
|
|
|
out:
|
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_net_inet_tcp, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW,
|
2001-02-18 13:30:20 +00:00
|
|
|
0, 0, tcp_getcred, "S,xucred", "Get the xucred of a TCP connection");
|
1999-07-11 18:32:46 +00:00
|
|
|
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
tcp6_getcred(SYSCTL_HANDLER_ARGS)
|
2000-01-09 19:17:30 +00:00
|
|
|
{
|
2001-02-18 13:30:20 +00:00
|
|
|
struct xucred xuc;
|
2000-01-09 19:17:30 +00:00
|
|
|
struct sockaddr_in6 addrs[2];
|
|
|
|
struct inpcb *inp;
|
|
|
|
int error, s, mapped = 0;
|
|
|
|
|
|
|
|
error = suser(req->p);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = SYSCTL_IN(req, addrs, sizeof(addrs));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&addrs[0].sin6_addr)) {
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&addrs[1].sin6_addr))
|
|
|
|
mapped = 1;
|
|
|
|
else
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
s = splnet();
|
|
|
|
if (mapped == 1)
|
|
|
|
inp = in_pcblookup_hash(&tcbinfo,
|
|
|
|
*(struct in_addr *)&addrs[1].sin6_addr.s6_addr[12],
|
|
|
|
addrs[1].sin6_port,
|
|
|
|
*(struct in_addr *)&addrs[0].sin6_addr.s6_addr[12],
|
|
|
|
addrs[0].sin6_port,
|
|
|
|
0, NULL);
|
|
|
|
else
|
|
|
|
inp = in6_pcblookup_hash(&tcbinfo, &addrs[1].sin6_addr,
|
|
|
|
addrs[1].sin6_port,
|
|
|
|
&addrs[0].sin6_addr, addrs[0].sin6_port,
|
|
|
|
0, NULL);
|
|
|
|
if (inp == NULL || inp->inp_socket == NULL) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2001-02-18 13:30:20 +00:00
|
|
|
bzero(&xuc, sizeof(xuc));
|
|
|
|
xuc.cr_uid = inp->inp_socket->so_cred->cr_uid;
|
|
|
|
xuc.cr_ngroups = inp->inp_socket->so_cred->cr_ngroups;
|
|
|
|
bcopy(inp->inp_socket->so_cred->cr_groups, xuc.cr_groups,
|
|
|
|
sizeof(xuc.cr_groups));
|
|
|
|
error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
|
2000-01-09 19:17:30 +00:00
|
|
|
out:
|
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_net_inet6_tcp6, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW,
|
|
|
|
0, 0,
|
2001-02-18 13:30:20 +00:00
|
|
|
tcp6_getcred, "S,xucred", "Get the xucred of a TCP6 connection");
|
2000-01-09 19:17:30 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
void
|
1995-12-16 02:14:44 +00:00
|
|
|
tcp_ctlinput(cmd, sa, vip)
|
1994-05-24 10:09:53 +00:00
|
|
|
int cmd;
|
|
|
|
struct sockaddr *sa;
|
1995-12-16 02:14:44 +00:00
|
|
|
void *vip;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1995-12-16 02:14:44 +00:00
|
|
|
register struct ip *ip = vip;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct tcphdr *th;
|
|
|
|
void (*notify) __P((struct inpcb *, int)) = tcp_notify;
|
2000-12-24 10:57:21 +00:00
|
|
|
tcp_seq tcp_sequence = 0;
|
|
|
|
int tcp_seq_check = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (cmd == PRC_QUENCH)
|
|
|
|
notify = tcp_quench;
|
2001-02-18 09:34:55 +00:00
|
|
|
else if ((icmp_unreach_like_rst == 1) && ((cmd == PRC_UNREACH_HOST) ||
|
|
|
|
(cmd == PRC_UNREACH_ADMIN_PROHIB)) && (ip) &&
|
|
|
|
((IP_VHL_HL(ip->ip_vhl) << 2) == sizeof(struct ip))) {
|
2000-12-24 10:57:21 +00:00
|
|
|
/*
|
|
|
|
* Only go here if the length of the IP header in the ICMP packet
|
|
|
|
* is 20 bytes, that is it doesn't have options, if it does have
|
|
|
|
* options, we will not have the first 8 bytes of the TCP header,
|
|
|
|
* and thus we cannot match against TCP source/destination port
|
|
|
|
* numbers and TCP sequence number.
|
2001-02-18 09:34:55 +00:00
|
|
|
*
|
|
|
|
* If PRC_UNREACH_ADMIN_PROHIB drop session regardsless of current
|
|
|
|
* state, else we check the sysctl icmp_like_rst_syn_sent_only to
|
|
|
|
* see if we should drop the session only in SYN-SENT state, or
|
|
|
|
* in all states.
|
2000-12-24 10:57:21 +00:00
|
|
|
*/
|
|
|
|
tcp_seq_check = 1;
|
2001-02-18 09:34:55 +00:00
|
|
|
if (cmd == PRC_UNREACH_ADMIN_PROHIB) {
|
|
|
|
notify = tcp_drop_all_states;
|
|
|
|
} else {
|
|
|
|
notify = tcp_drop_syn_sent;
|
|
|
|
}
|
2000-12-24 10:57:21 +00:00
|
|
|
} else if (cmd == PRC_MSGSIZE)
|
1995-09-18 15:51:40 +00:00
|
|
|
notify = tcp_mtudisc;
|
1994-05-24 10:09:53 +00:00
|
|
|
else if (!PRC_IS_REDIRECT(cmd) &&
|
|
|
|
((unsigned)cmd > PRC_NCMDS || inetctlerrmap[cmd] == 0))
|
|
|
|
return;
|
|
|
|
if (ip) {
|
1996-07-24 18:46:19 +00:00
|
|
|
th = (struct tcphdr *)((caddr_t)ip
|
|
|
|
+ (IP_VHL_HL(ip->ip_vhl) << 2));
|
2000-12-24 10:57:21 +00:00
|
|
|
if (tcp_seq_check == 1)
|
|
|
|
tcp_sequence = ntohl(th->th_seq);
|
2001-02-20 23:25:04 +00:00
|
|
|
/*
|
|
|
|
* Only call in_pcbnotify if the src port number != 0, as we
|
|
|
|
* treat 0 as a wildcard in src/sys/in_pbc.c:in_pcbnotify()
|
|
|
|
*
|
|
|
|
* It's sufficient to check for src|local port, as we'll have no
|
|
|
|
* sessions with src|local port == 0
|
|
|
|
*
|
|
|
|
* Without this a attacker sending ICMP messages, where the attached
|
|
|
|
* IP header (+ 8 bytes) has the address and port numbers == 0, would
|
|
|
|
* have the ICMP message applied to all sessions (modulo TCP sequence
|
|
|
|
* number check).
|
|
|
|
*/
|
|
|
|
if (th->th_sport == 0)
|
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
in_pcbnotify(&tcb, sa, th->th_dport, ip->ip_src, th->th_sport,
|
2000-12-24 10:57:21 +00:00
|
|
|
cmd, notify, tcp_sequence, tcp_seq_check);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
2000-12-24 10:57:21 +00:00
|
|
|
in_pcbnotify(&tcb, sa, 0, zeroin_addr, 0, cmd, notify, 0, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
void
|
|
|
|
tcp6_ctlinput(cmd, sa, d)
|
|
|
|
int cmd;
|
|
|
|
struct sockaddr *sa;
|
|
|
|
void *d;
|
|
|
|
{
|
|
|
|
register struct tcphdr *thp;
|
|
|
|
struct tcphdr th;
|
|
|
|
void (*notify) __P((struct inpcb *, int)) = tcp_notify;
|
|
|
|
struct sockaddr_in6 sa6;
|
|
|
|
struct ip6_hdr *ip6;
|
|
|
|
struct mbuf *m;
|
|
|
|
int off;
|
|
|
|
|
|
|
|
if (sa->sa_family != AF_INET6 ||
|
|
|
|
sa->sa_len != sizeof(struct sockaddr_in6))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (cmd == PRC_QUENCH)
|
|
|
|
notify = tcp_quench;
|
|
|
|
else if (cmd == PRC_MSGSIZE)
|
|
|
|
notify = tcp_mtudisc;
|
|
|
|
else if (!PRC_IS_REDIRECT(cmd) &&
|
|
|
|
((unsigned)cmd > PRC_NCMDS || inet6ctlerrmap[cmd] == 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* if the parameter is from icmp6, decode it. */
|
|
|
|
if (d != NULL) {
|
|
|
|
struct ip6ctlparam *ip6cp = (struct ip6ctlparam *)d;
|
|
|
|
m = ip6cp->ip6c_m;
|
|
|
|
ip6 = ip6cp->ip6c_ip6;
|
|
|
|
off = ip6cp->ip6c_off;
|
|
|
|
} else {
|
|
|
|
m = NULL;
|
|
|
|
ip6 = NULL;
|
2000-10-23 07:11:01 +00:00
|
|
|
off = 0; /* fool gcc */
|
2000-01-09 19:17:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Translate addresses into internal form.
|
|
|
|
* Sa check if it is AF_INET6 is done at the top of this funciton.
|
|
|
|
*/
|
|
|
|
sa6 = *(struct sockaddr_in6 *)sa;
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sa6.sin6_addr) != 0 && m != NULL &&
|
|
|
|
m->m_pkthdr.rcvif != NULL)
|
|
|
|
sa6.sin6_addr.s6_addr16[1] = htons(m->m_pkthdr.rcvif->if_index);
|
|
|
|
|
|
|
|
if (ip6) {
|
|
|
|
/*
|
|
|
|
* XXX: We assume that when IPV6 is non NULL,
|
|
|
|
* M and OFF are valid.
|
|
|
|
*/
|
|
|
|
struct in6_addr s;
|
|
|
|
|
|
|
|
/* translate addresses into internal form */
|
|
|
|
memcpy(&s, &ip6->ip6_src, sizeof(s));
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&s) != 0 && m != NULL &&
|
|
|
|
m->m_pkthdr.rcvif != NULL)
|
|
|
|
s.s6_addr16[1] = htons(m->m_pkthdr.rcvif->if_index);
|
|
|
|
|
2000-10-23 07:11:01 +00:00
|
|
|
/* check if we can safely examine src and dst ports */
|
|
|
|
if (m->m_pkthdr.len < off + sizeof(th))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (m->m_len < off + sizeof(th)) {
|
2000-01-09 19:17:30 +00:00
|
|
|
/*
|
|
|
|
* this should be rare case
|
|
|
|
* because now MINCLSIZE is "(MHLEN + 1)",
|
|
|
|
* so we compromise on this copy...
|
|
|
|
*/
|
|
|
|
m_copydata(m, off, sizeof(th), (caddr_t)&th);
|
|
|
|
thp = &th;
|
|
|
|
} else
|
|
|
|
thp = (struct tcphdr *)(mtod(m, caddr_t) + off);
|
|
|
|
in6_pcbnotify(&tcb, (struct sockaddr *)&sa6, thp->th_dport,
|
|
|
|
&s, thp->th_sport, cmd, notify);
|
|
|
|
} else
|
|
|
|
in6_pcbnotify(&tcb, (struct sockaddr *)&sa6, 0, &zeroin6_addr,
|
|
|
|
0, cmd, notify);
|
|
|
|
}
|
|
|
|
#endif /* INET6 */
|
|
|
|
|
2000-12-24 10:57:21 +00:00
|
|
|
/*
|
|
|
|
* Check if the supplied TCP sequence number is a sequence number
|
|
|
|
* for a sent but unacknowledged packet on the given TCP session.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
tcp_seq_vs_sess(inp, tcp_sequence)
|
|
|
|
struct inpcb *inp;
|
|
|
|
tcp_seq tcp_sequence;
|
|
|
|
{
|
|
|
|
struct tcpcb *tp = intotcpcb(inp);
|
|
|
|
/*
|
|
|
|
* If the sequence number is less than that of the last
|
|
|
|
* unacknowledged packet, or greater than that of the
|
|
|
|
* last sent, the given sequence number is not that
|
|
|
|
* of a sent but unacknowledged packet for this session.
|
|
|
|
*/
|
|
|
|
if (SEQ_LT(tcp_sequence, tp->snd_una) ||
|
|
|
|
SEQ_GT(tcp_sequence, tp->snd_max)) {
|
|
|
|
return(0);
|
|
|
|
} else {
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* When a source quench is received, close congestion window
|
|
|
|
* to one segment. We will gradually open it again as we proceed.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
tcp_quench(inp, errno)
|
|
|
|
struct inpcb *inp;
|
|
|
|
int errno;
|
|
|
|
{
|
|
|
|
struct tcpcb *tp = intotcpcb(inp);
|
|
|
|
|
|
|
|
if (tp)
|
|
|
|
tp->snd_cwnd = tp->t_maxseg;
|
|
|
|
}
|
1995-02-09 23:13:27 +00:00
|
|
|
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
/*
|
|
|
|
* When a ICMP unreachable is recieved, drop the
|
2000-12-24 10:57:21 +00:00
|
|
|
* TCP connection, depending on the sysctl
|
|
|
|
* icmp_like_rst_syn_sent_only, it only drops
|
|
|
|
* the session if it's in SYN-SENT state
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
tcp_drop_syn_sent(inp, errno)
|
|
|
|
struct inpcb *inp;
|
|
|
|
int errno;
|
|
|
|
{
|
|
|
|
struct tcpcb *tp = intotcpcb(inp);
|
2000-12-24 10:57:21 +00:00
|
|
|
if((tp) && ((icmp_like_rst_syn_sent_only == 0) ||
|
|
|
|
(tp->t_state == TCPS_SYN_SENT)))
|
|
|
|
tcp_drop(tp, errno);
|
We currently does not react to ICMP administratively prohibited
messages send by routers when they deny our traffic, this causes
a timeout when trying to connect to TCP ports/services on a remote
host, which is blocked by routers or firewalls.
rfc1122 (Requirements for Internet Hosts) section 3.2.2.1 actually
requi re that we treat such a message for a TCP session, that we
treat it like if we had recieved a RST.
quote begin.
A Destination Unreachable message that is received MUST be
reported to the transport layer. The transport layer SHOULD
use the information appropriately; for example, see Sections
4.1.3.3, 4.2.3.9, and 4.2.4 below. A transport protocol
that has its own mechanism for notifying the sender that a
port is unreachable (e.g., TCP, which sends RST segments)
MUST nevertheless accept an ICMP Port Unreachable for the
same purpose.
quote end.
I've written a small extension that implement this, it also create
a sysctl "net.inet.tcp.icmp_admin_prohib_like_rst" to control if
this new behaviour is activated.
When it's activated (set to 1) we'll treat a ICMP administratively
prohibited message (icmp type 3 code 9, 10 and 13) for a TCP
sessions, as if we recived a TCP RST, but only if the TCP session
is in SYN_SENT state.
The reason for only reacting when in SYN_SENT state, is that this
will solve the problem, and at the same time minimize the risk of
this being abused.
I suggest that we enable this new behaviour by default, but it
would be a change of current behaviour, so if people prefer to
leave it disabled by default, at least for now, this would be ok
for me, the attached diff actually have the sysctl set to 0 by
default.
PR: 23086
Submitted by: Jesper Skriver <jesper@skriver.dk>
2000-12-16 19:42:06 +00:00
|
|
|
}
|
|
|
|
|
2001-02-18 09:34:55 +00:00
|
|
|
/*
|
|
|
|
* When a ICMP unreachable is recieved, drop the
|
|
|
|
* TCP connection, regardless of the state.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
tcp_drop_all_states(inp, errno)
|
|
|
|
struct inpcb *inp;
|
|
|
|
int errno;
|
|
|
|
{
|
|
|
|
struct tcpcb *tp = intotcpcb(inp);
|
|
|
|
if(tp)
|
|
|
|
tcp_drop(tp, errno);
|
|
|
|
}
|
|
|
|
|
1995-09-18 15:51:40 +00:00
|
|
|
/*
|
|
|
|
* When `need fragmentation' ICMP is received, update our idea of the MSS
|
|
|
|
* based on the new value in the route. Also nudge TCP to send something,
|
|
|
|
* since we know the packet we just sent was dropped.
|
1995-09-20 21:00:59 +00:00
|
|
|
* This duplicates some code in the tcp_mss() function in tcp_input.c.
|
1995-09-18 15:51:40 +00:00
|
|
|
*/
|
1995-10-16 18:21:26 +00:00
|
|
|
void
|
1995-09-18 15:51:40 +00:00
|
|
|
tcp_mtudisc(inp, errno)
|
|
|
|
struct inpcb *inp;
|
|
|
|
int errno;
|
|
|
|
{
|
|
|
|
struct tcpcb *tp = intotcpcb(inp);
|
1995-09-20 21:00:59 +00:00
|
|
|
struct rtentry *rt;
|
|
|
|
struct rmxp_tao *taop;
|
|
|
|
struct socket *so = inp->inp_socket;
|
|
|
|
int offered;
|
|
|
|
int mss;
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
int isipv6 = (tp->t_inpcb->inp_vflag & INP_IPV6) != 0;
|
|
|
|
#endif /* INET6 */
|
1995-09-18 15:51:40 +00:00
|
|
|
|
1995-09-20 21:00:59 +00:00
|
|
|
if (tp) {
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if (isipv6)
|
|
|
|
rt = tcp_rtlookup6(inp);
|
|
|
|
else
|
|
|
|
#endif /* INET6 */
|
1995-09-20 21:00:59 +00:00
|
|
|
rt = tcp_rtlookup(inp);
|
|
|
|
if (!rt || !rt->rt_rmx.rmx_mtu) {
|
2000-01-09 19:17:30 +00:00
|
|
|
tp->t_maxopd = tp->t_maxseg =
|
|
|
|
#ifdef INET6
|
|
|
|
isipv6 ? tcp_v6mssdflt :
|
|
|
|
#endif /* INET6 */
|
|
|
|
tcp_mssdflt;
|
1995-09-20 21:00:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
taop = rmx_taop(rt->rt_rmx);
|
|
|
|
offered = taop->tao_mssopt;
|
2000-01-09 19:17:30 +00:00
|
|
|
mss = rt->rt_rmx.rmx_mtu -
|
|
|
|
#ifdef INET6
|
|
|
|
(isipv6 ?
|
|
|
|
sizeof(struct ip6_hdr) + sizeof(struct tcphdr) :
|
|
|
|
#endif /* INET6 */
|
|
|
|
sizeof(struct tcpiphdr)
|
|
|
|
#ifdef INET6
|
|
|
|
)
|
|
|
|
#endif /* INET6 */
|
|
|
|
;
|
|
|
|
|
1995-12-20 17:42:28 +00:00
|
|
|
if (offered)
|
|
|
|
mss = min(mss, offered);
|
|
|
|
/*
|
|
|
|
* XXX - The above conditional probably violates the TCP
|
|
|
|
* spec. The problem is that, since we don't know the
|
|
|
|
* other end's MSS, we are supposed to use a conservative
|
|
|
|
* default. But, if we do that, then MTU discovery will
|
|
|
|
* never actually take place, because the conservative
|
|
|
|
* default is much less than the MTUs typically seen
|
|
|
|
* on the Internet today. For the moment, we'll sweep
|
|
|
|
* this under the carpet.
|
|
|
|
*
|
|
|
|
* The conservative default might not actually be a problem
|
|
|
|
* if the only case this occurs is when sending an initial
|
|
|
|
* SYN with options and data to a host we've never talked
|
|
|
|
* to before. Then, they will reply with an MSS value which
|
|
|
|
* will get recorded and the new parameters should get
|
|
|
|
* recomputed. For Further Study.
|
|
|
|
*/
|
1995-10-10 17:45:43 +00:00
|
|
|
if (tp->t_maxopd <= mss)
|
|
|
|
return;
|
1995-09-20 21:00:59 +00:00
|
|
|
tp->t_maxopd = mss;
|
|
|
|
|
|
|
|
if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
|
|
|
|
(tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP)
|
|
|
|
mss -= TCPOLEN_TSTAMP_APPA;
|
|
|
|
if ((tp->t_flags & (TF_REQ_CC|TF_NOOPT)) == TF_REQ_CC &&
|
|
|
|
(tp->t_flags & TF_RCVD_CC) == TF_RCVD_CC)
|
|
|
|
mss -= TCPOLEN_CC_APPA;
|
|
|
|
#if (MCLBYTES & (MCLBYTES - 1)) == 0
|
|
|
|
if (mss > MCLBYTES)
|
|
|
|
mss &= ~(MCLBYTES-1);
|
|
|
|
#else
|
|
|
|
if (mss > MCLBYTES)
|
|
|
|
mss = mss / MCLBYTES * MCLBYTES;
|
1995-09-18 15:51:40 +00:00
|
|
|
#endif
|
1995-09-20 21:00:59 +00:00
|
|
|
if (so->so_snd.sb_hiwat < mss)
|
|
|
|
mss = so->so_snd.sb_hiwat;
|
|
|
|
|
|
|
|
tp->t_maxseg = mss;
|
|
|
|
|
1995-10-12 17:37:25 +00:00
|
|
|
tcpstat.tcps_mturesent++;
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->t_rtttime = 0;
|
1995-10-12 17:37:25 +00:00
|
|
|
tp->snd_nxt = tp->snd_una;
|
|
|
|
tcp_output(tp);
|
1995-09-20 21:00:59 +00:00
|
|
|
}
|
1995-09-18 15:51:40 +00:00
|
|
|
}
|
|
|
|
|
1995-02-09 23:13:27 +00:00
|
|
|
/*
|
|
|
|
* Look-up the routing entry to the peer of this inpcb. If no route
|
|
|
|
* is found and it cannot be allocated the return NULL. This routine
|
|
|
|
* is called by TCP routines that access the rmx structure and by tcp_mss
|
|
|
|
* to get the interface MTU.
|
|
|
|
*/
|
|
|
|
struct rtentry *
|
|
|
|
tcp_rtlookup(inp)
|
|
|
|
struct inpcb *inp;
|
|
|
|
{
|
|
|
|
struct route *ro;
|
|
|
|
struct rtentry *rt;
|
|
|
|
|
|
|
|
ro = &inp->inp_route;
|
|
|
|
rt = ro->ro_rt;
|
|
|
|
if (rt == NULL || !(rt->rt_flags & RTF_UP)) {
|
|
|
|
/* No route yet, so try to acquire one */
|
|
|
|
if (inp->inp_faddr.s_addr != INADDR_ANY) {
|
|
|
|
ro->ro_dst.sa_family = AF_INET;
|
|
|
|
ro->ro_dst.sa_len = sizeof(ro->ro_dst);
|
|
|
|
((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
|
|
|
|
inp->inp_faddr;
|
|
|
|
rtalloc(ro);
|
|
|
|
rt = ro->ro_rt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rt;
|
|
|
|
}
|
|
|
|
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
struct rtentry *
|
|
|
|
tcp_rtlookup6(inp)
|
|
|
|
struct inpcb *inp;
|
|
|
|
{
|
|
|
|
struct route_in6 *ro6;
|
|
|
|
struct rtentry *rt;
|
|
|
|
|
|
|
|
ro6 = &inp->in6p_route;
|
|
|
|
rt = ro6->ro_rt;
|
|
|
|
if (rt == NULL || !(rt->rt_flags & RTF_UP)) {
|
|
|
|
/* No route yet, so try to acquire one */
|
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
|
|
|
|
ro6->ro_dst.sin6_family = AF_INET6;
|
|
|
|
ro6->ro_dst.sin6_len = sizeof(ro6->ro_dst);
|
|
|
|
ro6->ro_dst.sin6_addr = inp->in6p_faddr;
|
|
|
|
rtalloc((struct route *)ro6);
|
|
|
|
rt = ro6->ro_rt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rt;
|
|
|
|
}
|
|
|
|
#endif /* INET6 */
|
|
|
|
|
|
|
|
#ifdef IPSEC
|
|
|
|
/* compute ESP/AH header size for TCP, including outer IP header. */
|
|
|
|
size_t
|
|
|
|
ipsec_hdrsiz_tcp(tp)
|
|
|
|
struct tcpcb *tp;
|
|
|
|
{
|
|
|
|
struct inpcb *inp;
|
|
|
|
struct mbuf *m;
|
|
|
|
size_t hdrsiz;
|
|
|
|
struct ip *ip;
|
|
|
|
#ifdef INET6
|
|
|
|
struct ip6_hdr *ip6;
|
|
|
|
#endif /* INET6 */
|
|
|
|
struct tcphdr *th;
|
|
|
|
|
|
|
|
if (!tp || !tp->t_template || !(inp = tp->t_inpcb))
|
|
|
|
return 0;
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
|
|
if (!m)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef INET6
|
|
|
|
if ((inp->inp_vflag & INP_IPV6) != 0) {
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
th = (struct tcphdr *)(ip6 + 1);
|
|
|
|
m->m_pkthdr.len = m->m_len =
|
|
|
|
sizeof(struct ip6_hdr) + sizeof(struct tcphdr);
|
2000-01-15 05:39:28 +00:00
|
|
|
bcopy((caddr_t)tp->t_template->tt_ipgen, (caddr_t)ip6,
|
2000-01-09 19:17:30 +00:00
|
|
|
sizeof(struct ip6_hdr));
|
|
|
|
bcopy((caddr_t)&tp->t_template->tt_t, (caddr_t)th,
|
|
|
|
sizeof(struct tcphdr));
|
|
|
|
hdrsiz = ipsec6_hdrsiz(m, IPSEC_DIR_OUTBOUND, inp);
|
|
|
|
} else
|
|
|
|
#endif /* INET6 */
|
|
|
|
{
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
th = (struct tcphdr *)(ip + 1);
|
|
|
|
m->m_pkthdr.len = m->m_len = sizeof(struct tcpiphdr);
|
2000-01-15 05:39:28 +00:00
|
|
|
bcopy((caddr_t)tp->t_template->tt_ipgen, (caddr_t)ip,
|
2000-01-09 19:17:30 +00:00
|
|
|
sizeof(struct ip));
|
|
|
|
bcopy((caddr_t)&tp->t_template->tt_t, (caddr_t)th,
|
|
|
|
sizeof(struct tcphdr));
|
|
|
|
hdrsiz = ipsec4_hdrsiz(m, IPSEC_DIR_OUTBOUND, inp);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_free(m);
|
|
|
|
return hdrsiz;
|
|
|
|
}
|
|
|
|
#endif /*IPSEC*/
|
|
|
|
|
1995-02-09 23:13:27 +00:00
|
|
|
/*
|
|
|
|
* Return a pointer to the cached information about the remote host.
|
|
|
|
* The cached information is stored in the protocol specific part of
|
|
|
|
* the route metrics.
|
|
|
|
*/
|
|
|
|
struct rmxp_tao *
|
|
|
|
tcp_gettaocache(inp)
|
|
|
|
struct inpcb *inp;
|
|
|
|
{
|
2000-01-09 19:17:30 +00:00
|
|
|
struct rtentry *rt;
|
|
|
|
|
|
|
|
#ifdef INET6
|
|
|
|
if ((inp->inp_vflag & INP_IPV6) != 0)
|
|
|
|
rt = tcp_rtlookup6(inp);
|
|
|
|
else
|
|
|
|
#endif /* INET6 */
|
|
|
|
rt = tcp_rtlookup(inp);
|
1995-02-09 23:13:27 +00:00
|
|
|
|
|
|
|
/* Make sure this is a host route and is up. */
|
|
|
|
if (rt == NULL ||
|
|
|
|
(rt->rt_flags & (RTF_UP|RTF_HOST)) != (RTF_UP|RTF_HOST))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return rmx_taop(rt->rt_rmx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear all the TAO cache entries, called from tcp_init.
|
|
|
|
*
|
|
|
|
* XXX
|
|
|
|
* This routine is just an empty one, because we assume that the routing
|
|
|
|
* routing tables are initialized at the same time when TCP, so there is
|
|
|
|
* nothing in the cache left over.
|
|
|
|
*/
|
|
|
|
static void
|
1997-09-16 11:44:05 +00:00
|
|
|
tcp_cleartaocache()
|
|
|
|
{
|
|
|
|
}
|