1c398230bSWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4e79adb8eSGarrett Wollman * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994, 1995 5df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 6dbc42409SLawrence Stewart * Copyright (c) 2007-2008,2010 7dbc42409SLawrence Stewart * Swinburne University of Technology, Melbourne, Australia. 8dbc42409SLawrence Stewart * Copyright (c) 2009-2010 Lawrence Stewart <lstewart@freebsd.org> 9dbc42409SLawrence Stewart * Copyright (c) 2010 The FreeBSD Foundation 10fa046d87SRobert Watson * Copyright (c) 2010-2011 Juniper Networks, Inc. 11dbc42409SLawrence Stewart * All rights reserved. 12dbc42409SLawrence Stewart * 13dbc42409SLawrence Stewart * Portions of this software were developed at the Centre for Advanced Internet 14891b8ed4SLawrence Stewart * Architectures, Swinburne University of Technology, by Lawrence Stewart, 15891b8ed4SLawrence Stewart * James Healy and David Hayes, made possible in part by a grant from the Cisco 16891b8ed4SLawrence Stewart * University Research Program Fund at Community Foundation Silicon Valley. 17dbc42409SLawrence Stewart * 18dbc42409SLawrence Stewart * Portions of this software were developed at the Centre for Advanced 19dbc42409SLawrence Stewart * Internet Architectures, Swinburne University of Technology, Melbourne, 20dbc42409SLawrence Stewart * Australia by David Hayes under sponsorship from the FreeBSD Foundation. 21df8bae1dSRodney W. Grimes * 22fa046d87SRobert Watson * Portions of this software were developed by Robert N. M. Watson under 23fa046d87SRobert Watson * contract to Juniper Networks, Inc. 24fa046d87SRobert Watson * 25df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 26df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 27df8bae1dSRodney W. Grimes * are met: 28df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 29df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 30df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 31df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 32df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 33fbbd9655SWarner Losh * 3. Neither the name of the University nor the names of its contributors 34df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 35df8bae1dSRodney W. Grimes * without specific prior written permission. 36df8bae1dSRodney W. Grimes * 37df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 38df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 39df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 40df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 41df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 42df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 43df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 45df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 46df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 47df8bae1dSRodney W. Grimes * SUCH DAMAGE. 48df8bae1dSRodney W. Grimes * 49e79adb8eSGarrett Wollman * @(#)tcp_input.c 8.12 (Berkeley) 5/24/95 50df8bae1dSRodney W. Grimes */ 51df8bae1dSRodney W. Grimes 524b421e2dSMike Silbersack #include <sys/cdefs.h> 534b421e2dSMike Silbersack __FBSDID("$FreeBSD$"); 544b421e2dSMike Silbersack 551cfd4b53SBruce M Simpson #include "opt_inet.h" 56fb59c426SYoshinobu Inoue #include "opt_inet6.h" 573a2a9f79SYoshinobu Inoue #include "opt_ipsec.h" 580cc12cc5SJoerg Wunsch #include "opt_tcpdebug.h" 590cc12cc5SJoerg Wunsch 60df8bae1dSRodney W. Grimes #include <sys/param.h> 61adc56f5aSEdward Tomasz Napierala #include <sys/arb.h> 6298163b98SPoul-Henning Kamp #include <sys/kernel.h> 63bd79708dSJonathan T. Looney #ifdef TCP_HHOOK 6439bc9de5SLawrence Stewart #include <sys/hhook.h> 65bd79708dSJonathan T. Looney #endif 66df8bae1dSRodney W. Grimes #include <sys/malloc.h> 67df8bae1dSRodney W. Grimes #include <sys/mbuf.h> 68a29f300eSGarrett Wollman #include <sys/proc.h> /* for proc0 declaration */ 69df8bae1dSRodney W. Grimes #include <sys/protosw.h> 70adc56f5aSEdward Tomasz Napierala #include <sys/qmath.h> 7157f60867SMark Johnston #include <sys/sdt.h> 72960ed29cSSeigo Tanimura #include <sys/signalvar.h> 73df8bae1dSRodney W. Grimes #include <sys/socket.h> 74df8bae1dSRodney W. Grimes #include <sys/socketvar.h> 75960ed29cSSeigo Tanimura #include <sys/sysctl.h> 76816a3d83SPoul-Henning Kamp #include <sys/syslog.h> 77960ed29cSSeigo Tanimura #include <sys/systm.h> 78adc56f5aSEdward Tomasz Napierala #include <sys/stats.h> 79df8bae1dSRodney W. Grimes 80e79adb8eSGarrett Wollman #include <machine/cpu.h> /* before tcp_seq.h, for tcp_random18() */ 81e79adb8eSGarrett Wollman 8212e2e970SAndre Oppermann #include <vm/uma.h> 8312e2e970SAndre Oppermann 84df8bae1dSRodney W. Grimes #include <net/if.h> 8576039bc8SGleb Smirnoff #include <net/if_var.h> 86df8bae1dSRodney W. Grimes #include <net/route.h> 87530c0060SRobert Watson #include <net/vnet.h> 88df8bae1dSRodney W. Grimes 89773673c1SAndre Oppermann #define TCPSTATES /* for logging */ 90773673c1SAndre Oppermann 91df8bae1dSRodney W. Grimes #include <netinet/in.h> 9257f60867SMark Johnston #include <netinet/in_kdtrace.h> 93960ed29cSSeigo Tanimura #include <netinet/in_pcb.h> 94df8bae1dSRodney W. Grimes #include <netinet/in_systm.h> 95df8bae1dSRodney W. Grimes #include <netinet/ip.h> 968e8aab7aSAndre Oppermann #include <netinet/ip_icmp.h> /* required for icmp_var.h */ 97686cdd19SJun-ichiro itojun Hagino #include <netinet/icmp_var.h> /* for ICMP_BANDLIM */ 98df8bae1dSRodney W. Grimes #include <netinet/ip_var.h> 99ef39adf0SAndre Oppermann #include <netinet/ip_options.h> 100686cdd19SJun-ichiro itojun Hagino #include <netinet/ip6.h> 101686cdd19SJun-ichiro itojun Hagino #include <netinet/icmp6.h> 102686cdd19SJun-ichiro itojun Hagino #include <netinet6/in6_pcb.h> 103b66d74c1SGleb Smirnoff #include <netinet6/in6_var.h> 104960ed29cSSeigo Tanimura #include <netinet6/ip6_var.h> 105960ed29cSSeigo Tanimura #include <netinet6/nd6.h> 1062de3e790SGleb Smirnoff #include <netinet/tcp.h> 107df8bae1dSRodney W. Grimes #include <netinet/tcp_fsm.h> 1082529f56eSJonathan T. Looney #include <netinet/tcp_log_buf.h> 109df8bae1dSRodney W. Grimes #include <netinet/tcp_seq.h> 110df8bae1dSRodney W. Grimes #include <netinet/tcp_timer.h> 111df8bae1dSRodney W. Grimes #include <netinet/tcp_var.h> 112fb59c426SYoshinobu Inoue #include <netinet6/tcp6_var.h> 113df8bae1dSRodney W. Grimes #include <netinet/tcpip.h> 1144644fda3SGleb Smirnoff #include <netinet/cc/cc.h> 115c560df6fSPatrick Kelsey #include <netinet/tcp_fastopen.h> 11686a996e6SHiren Panchasara #ifdef TCPPCAP 11786a996e6SHiren Panchasara #include <netinet/tcp_pcap.h> 11886a996e6SHiren Panchasara #endif 119c325962bSMike Silbersack #include <netinet/tcp_syncache.h> 120610ee2f9SDavid Greenman #ifdef TCPDEBUG 121df8bae1dSRodney W. Grimes #include <netinet/tcp_debug.h> 122fb59c426SYoshinobu Inoue #endif /* TCPDEBUG */ 12309fe6320SNavdeep Parhar #ifdef TCP_OFFLOAD 12409fe6320SNavdeep Parhar #include <netinet/tcp_offload.h> 12509fe6320SNavdeep Parhar #endif 126fb59c426SYoshinobu Inoue 127fcf59617SAndrey V. Elsukov #include <netipsec/ipsec_support.h> 128b9234fafSSam Leffler 129db4f9cc7SJonathan Lemon #include <machine/in_cksum.h> 130db4f9cc7SJonathan Lemon 131aed55708SRobert Watson #include <security/mac/mac_framework.h> 132aed55708SRobert Watson 133dbc42409SLawrence Stewart const int tcprexmtthresh = 3; 1340312fbe9SPoul-Henning Kamp 135334fc582SBjoern A. Zeeb VNET_DEFINE(int, tcp_log_in_vain) = 0; 136334fc582SBjoern A. Zeeb SYSCTL_INT(_net_inet_tcp, OID_AUTO, log_in_vain, CTLFLAG_VNET | CTLFLAG_RW, 137334fc582SBjoern A. Zeeb &VNET_NAME(tcp_log_in_vain), 0, 138eddfbb76SRobert Watson "Log all incoming TCP segments to closed ports"); 139816a3d83SPoul-Henning Kamp 14082cea7e6SBjoern A. Zeeb VNET_DEFINE(int, blackhole) = 0; 14182cea7e6SBjoern A. Zeeb #define V_blackhole VNET(blackhole) 1426df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, blackhole, CTLFLAG_VNET | CTLFLAG_RW, 143eddfbb76SRobert Watson &VNET_NAME(blackhole), 0, 144eddfbb76SRobert Watson "Do not send RST on segments to closed ports"); 14516f7f31fSGeoff Rehmet 14682cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_delack_enabled) = 1; 1476df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, delayed_ack, CTLFLAG_VNET | CTLFLAG_RW, 148eddfbb76SRobert Watson &VNET_NAME(tcp_delack_enabled), 0, 1493d177f46SBill Fumerola "Delay ACK to try and piggyback it onto a data packet"); 150f498eeeeSDavid Greenman 15182cea7e6SBjoern A. Zeeb VNET_DEFINE(int, drop_synfin) = 0; 1526df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, drop_synfin, CTLFLAG_VNET | CTLFLAG_RW, 153eddfbb76SRobert Watson &VNET_NAME(drop_synfin), 0, 154eddfbb76SRobert Watson "Drop TCP packets with SYN+FIN set"); 155f8613305SDag-Erling Smørgrav 1560e1d7c25SRichard Scheffenegger VNET_DEFINE(int, tcp_do_prr_conservative) = 0; 1570e1d7c25SRichard Scheffenegger SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_prr_conservative, CTLFLAG_VNET | CTLFLAG_RW, 1580e1d7c25SRichard Scheffenegger &VNET_NAME(tcp_do_prr_conservative), 0, 1590e1d7c25SRichard Scheffenegger "Do conservative Proportional Rate Reduction"); 1600e1d7c25SRichard Scheffenegger 1610e1d7c25SRichard Scheffenegger VNET_DEFINE(int, tcp_do_prr) = 1; 1620e1d7c25SRichard Scheffenegger SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_prr, CTLFLAG_VNET | CTLFLAG_RW, 1630e1d7c25SRichard Scheffenegger &VNET_NAME(tcp_do_prr), 1, 1640e1d7c25SRichard Scheffenegger "Enable Proportional Rate Reduction per RFC 6937"); 1650e1d7c25SRichard Scheffenegger 166b72e56e7SMichael Tuexen VNET_DEFINE(int, tcp_do_newcwv) = 0; 167b72e56e7SMichael Tuexen SYSCTL_INT(_net_inet_tcp, OID_AUTO, newcwv, CTLFLAG_VNET | CTLFLAG_RW, 168b72e56e7SMichael Tuexen &VNET_NAME(tcp_do_newcwv), 0, 169b72e56e7SMichael Tuexen "Enable New Congestion Window Validation per RFC7661"); 170b72e56e7SMichael Tuexen 17112eeb81fSHiren Panchasara VNET_DEFINE(int, tcp_do_rfc6675_pipe) = 0; 172054d38e3SHiren Panchasara SYSCTL_INT(_net_inet_tcp, OID_AUTO, rfc6675_pipe, CTLFLAG_VNET | CTLFLAG_RW, 17312eeb81fSHiren Panchasara &VNET_NAME(tcp_do_rfc6675_pipe), 0, 17412eeb81fSHiren Panchasara "Use calculated pipe/in-flight bytes per RFC 6675"); 17512eeb81fSHiren Panchasara 17682cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_do_rfc3042) = 1; 1776df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, rfc3042, CTLFLAG_VNET | CTLFLAG_RW, 178eddfbb76SRobert Watson &VNET_NAME(tcp_do_rfc3042), 0, 179eddfbb76SRobert Watson "Enable RFC 3042 (Limited Transmit)"); 180582a954bSJeffrey Hsu 18182cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_do_rfc3390) = 1; 1826df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, rfc3390, CTLFLAG_VNET | CTLFLAG_RW, 183eddfbb76SRobert Watson &VNET_NAME(tcp_do_rfc3390), 0, 184da3a8a1aSJeffrey Hsu "Enable RFC 3390 (Increasing TCP's Initial Congestion Window)"); 185da3a8a1aSJeffrey Hsu 186356c7958SHiren Panchasara VNET_DEFINE(int, tcp_initcwnd_segments) = 10; 187356c7958SHiren Panchasara SYSCTL_INT(_net_inet_tcp, OID_AUTO, initcwnd_segments, 188356c7958SHiren Panchasara CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(tcp_initcwnd_segments), 0, 189356c7958SHiren Panchasara "Slow-start flight size (initial congestion window) in number of segments"); 19009440655SAndre Oppermann 19182cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_do_rfc3465) = 1; 1926df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, rfc3465, CTLFLAG_VNET | CTLFLAG_RW, 193eddfbb76SRobert Watson &VNET_NAME(tcp_do_rfc3465), 0, 19424cb0f22SLawrence Stewart "Enable RFC 3465 (Appropriate Byte Counting)"); 195eddfbb76SRobert Watson 19682cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_abc_l_var) = 2; 1976df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, abc_l_var, CTLFLAG_VNET | CTLFLAG_RW, 198eddfbb76SRobert Watson &VNET_NAME(tcp_abc_l_var), 2, 19924cb0f22SLawrence Stewart "Cap the max cwnd increment during slow-start to this number of segments"); 20024cb0f22SLawrence Stewart 2017029da5cSPawel Biernacki static SYSCTL_NODE(_net_inet_tcp, OID_AUTO, ecn, 2027029da5cSPawel Biernacki CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 2037029da5cSPawel Biernacki "TCP ECN"); 204f2512ba1SRui Paulo 205883054b4SDon Lewis VNET_DEFINE(int, tcp_do_ecn) = 2; 2066df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp_ecn, OID_AUTO, enable, CTLFLAG_VNET | CTLFLAG_RW, 207eddfbb76SRobert Watson &VNET_NAME(tcp_do_ecn), 0, 208eddfbb76SRobert Watson "TCP ECN support"); 209eddfbb76SRobert Watson 21082cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_ecn_maxretries) = 1; 2116df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp_ecn, OID_AUTO, maxretries, CTLFLAG_VNET | CTLFLAG_RW, 212eddfbb76SRobert Watson &VNET_NAME(tcp_ecn_maxretries), 0, 213eddfbb76SRobert Watson "Max retries before giving up on ECN"); 214eddfbb76SRobert Watson 2153220a212SGleb Smirnoff VNET_DEFINE(int, tcp_insecure_syn) = 0; 2166df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, insecure_syn, CTLFLAG_VNET | CTLFLAG_RW, 2173220a212SGleb Smirnoff &VNET_NAME(tcp_insecure_syn), 0, 2183220a212SGleb Smirnoff "Follow RFC793 instead of RFC5961 criteria for accepting SYN packets"); 2193220a212SGleb Smirnoff 22082cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_insecure_rst) = 0; 2216df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, insecure_rst, CTLFLAG_VNET | CTLFLAG_RW, 222eddfbb76SRobert Watson &VNET_NAME(tcp_insecure_rst), 0, 2233220a212SGleb Smirnoff "Follow RFC793 instead of RFC5961 criteria for accepting RST packets"); 224a69968eeSMike Silbersack 225fba0cea1SBjoern A. Zeeb VNET_DEFINE(int, tcp_recvspace) = 1024*64; 226873789cbSAndre Oppermann #define V_tcp_recvspace VNET(tcp_recvspace) 2276df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLFLAG_VNET | CTLFLAG_RW, 228873789cbSAndre Oppermann &VNET_NAME(tcp_recvspace), 0, "Initial receive socket buffer size"); 229873789cbSAndre Oppermann 23082cea7e6SBjoern A. Zeeb VNET_DEFINE(int, tcp_do_autorcvbuf) = 1; 2316df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, recvbuf_auto, CTLFLAG_VNET | CTLFLAG_RW, 232eddfbb76SRobert Watson &VNET_NAME(tcp_do_autorcvbuf), 0, 2338b615593SMarko Zec "Enable automatic receive buffer sizing"); 2346741ecf5SAndre Oppermann 235b233773bSBjoern A. Zeeb VNET_DEFINE(int, tcp_autorcvbuf_max) = 2*1024*1024; 2366df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_tcp, OID_AUTO, recvbuf_max, CTLFLAG_VNET | CTLFLAG_RW, 237eddfbb76SRobert Watson &VNET_NAME(tcp_autorcvbuf_max), 0, 2388b615593SMarko Zec "Max size of automatic receive buffer"); 2396741ecf5SAndre Oppermann 240eddfbb76SRobert Watson VNET_DEFINE(struct inpcbhead, tcb); 24144e33a07SMarko Zec #define tcb6 tcb /* for KAME src sync over BSD*'s */ 24282cea7e6SBjoern A. Zeeb VNET_DEFINE(struct inpcbinfo, tcbinfo); 243df8bae1dSRodney W. Grimes 244315e3e38SRobert Watson /* 245bf840a17SGleb Smirnoff * TCP statistics are stored in an array of counter(9)s, which size matches 246bf840a17SGleb Smirnoff * size of struct tcpstat. TCP running connection count is a regular array. 2475923c293SGleb Smirnoff */ 2485da0521fSAndrey V. Elsukov VNET_PCPUSTAT_DEFINE(struct tcpstat, tcpstat); 2495da0521fSAndrey V. Elsukov SYSCTL_VNET_PCPUSTAT(_net_inet_tcp, TCPCTL_STATS, stats, struct tcpstat, 2505da0521fSAndrey V. Elsukov tcpstat, "TCP statistics (struct tcpstat, netinet/tcp_var.h)"); 251bf840a17SGleb Smirnoff VNET_DEFINE(counter_u64_t, tcps_states[TCP_NSTATES]); 252bf840a17SGleb Smirnoff SYSCTL_COUNTER_U64_ARRAY(_net_inet_tcp, TCPCTL_STATES, states, CTLFLAG_RD | 253d4d32b9fSHans Petter Selasky CTLFLAG_VNET, &VNET_NAME(tcps_states)[0], TCP_NSTATES, 254bf840a17SGleb Smirnoff "TCP connection counts by TCP state"); 255bf840a17SGleb Smirnoff 256bf840a17SGleb Smirnoff static void 257bf840a17SGleb Smirnoff tcp_vnet_init(const void *unused) 258bf840a17SGleb Smirnoff { 259bf840a17SGleb Smirnoff 260f59d975eSGleb Smirnoff COUNTER_ARRAY_ALLOC(V_tcps_states, TCP_NSTATES, M_WAITOK); 261bf840a17SGleb Smirnoff VNET_PCPUSTAT_ALLOC(tcpstat, M_WAITOK); 262bf840a17SGleb Smirnoff } 263bf840a17SGleb Smirnoff VNET_SYSINIT(tcp_vnet_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 264bf840a17SGleb Smirnoff tcp_vnet_init, NULL); 2655923c293SGleb Smirnoff 2665923c293SGleb Smirnoff #ifdef VIMAGE 267bf840a17SGleb Smirnoff static void 268bf840a17SGleb Smirnoff tcp_vnet_uninit(const void *unused) 269bf840a17SGleb Smirnoff { 270bf840a17SGleb Smirnoff 271f59d975eSGleb Smirnoff COUNTER_ARRAY_FREE(V_tcps_states, TCP_NSTATES); 272bf840a17SGleb Smirnoff VNET_PCPUSTAT_FREE(tcpstat); 273bf840a17SGleb Smirnoff } 274bf840a17SGleb Smirnoff VNET_SYSUNINIT(tcp_vnet_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 275bf840a17SGleb Smirnoff tcp_vnet_uninit, NULL); 2765923c293SGleb Smirnoff #endif /* VIMAGE */ 277bf840a17SGleb Smirnoff 2785923c293SGleb Smirnoff /* 2797ca6e296SMichael Tuexen * Kernel module interface for updating tcpstat. The first argument is an index 2805923c293SGleb Smirnoff * into tcpstat treated as an array. 281315e3e38SRobert Watson */ 282315e3e38SRobert Watson void 2837ca6e296SMichael Tuexen kmod_tcpstat_add(int statnum, int val) 284315e3e38SRobert Watson { 285315e3e38SRobert Watson 2867ca6e296SMichael Tuexen counter_u64_add(VNET(tcpstat)[statnum], val); 287315e3e38SRobert Watson } 288315e3e38SRobert Watson 289bd79708dSJonathan T. Looney #ifdef TCP_HHOOK 290dbc42409SLawrence Stewart /* 29139bc9de5SLawrence Stewart * Wrapper for the TCP established input helper hook. 29239bc9de5SLawrence Stewart */ 29355bceb1eSRandall Stewart void 29439bc9de5SLawrence Stewart hhook_run_tcp_est_in(struct tcpcb *tp, struct tcphdr *th, struct tcpopt *to) 29539bc9de5SLawrence Stewart { 29639bc9de5SLawrence Stewart struct tcp_hhook_data hhook_data; 29739bc9de5SLawrence Stewart 29839bc9de5SLawrence Stewart if (V_tcp_hhh[HHOOK_TCP_EST_IN]->hhh_nhooks > 0) { 29939bc9de5SLawrence Stewart hhook_data.tp = tp; 30039bc9de5SLawrence Stewart hhook_data.th = th; 30139bc9de5SLawrence Stewart hhook_data.to = to; 30239bc9de5SLawrence Stewart 30339bc9de5SLawrence Stewart hhook_run_hooks(V_tcp_hhh[HHOOK_TCP_EST_IN], &hhook_data, 30439bc9de5SLawrence Stewart tp->osd); 30539bc9de5SLawrence Stewart } 30639bc9de5SLawrence Stewart } 307bd79708dSJonathan T. Looney #endif 30839bc9de5SLawrence Stewart 30939bc9de5SLawrence Stewart /* 310dbc42409SLawrence Stewart * CC wrapper hook functions 311dbc42409SLawrence Stewart */ 31255bceb1eSRandall Stewart void 3134b7b743cSLawrence Stewart cc_ack_received(struct tcpcb *tp, struct tcphdr *th, uint16_t nsegs, 3144b7b743cSLawrence Stewart uint16_t type) 315f2512ba1SRui Paulo { 316adc56f5aSEdward Tomasz Napierala #ifdef STATS 317adc56f5aSEdward Tomasz Napierala int32_t gput; 318adc56f5aSEdward Tomasz Napierala #endif 319adc56f5aSEdward Tomasz Napierala 320dbc42409SLawrence Stewart INP_WLOCK_ASSERT(tp->t_inpcb); 321f2512ba1SRui Paulo 3224b7b743cSLawrence Stewart tp->ccv->nsegs = nsegs; 323dbc42409SLawrence Stewart tp->ccv->bytes_this_ack = BYTES_THIS_ACK(tp, th); 324b72e56e7SMichael Tuexen if ((!V_tcp_do_newcwv && (tp->snd_cwnd <= tp->snd_wnd)) || 325b72e56e7SMichael Tuexen (V_tcp_do_newcwv && (tp->snd_cwnd <= tp->snd_wnd) && 326b72e56e7SMichael Tuexen (tp->snd_cwnd < (tcp_compute_pipe(tp) * 2)))) 327dbc42409SLawrence Stewart tp->ccv->flags |= CCF_CWND_LIMITED; 328dbc42409SLawrence Stewart else 329dbc42409SLawrence Stewart tp->ccv->flags &= ~CCF_CWND_LIMITED; 330dbc42409SLawrence Stewart 331dbc42409SLawrence Stewart if (type == CC_ACK) { 332adc56f5aSEdward Tomasz Napierala #ifdef STATS 333adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_s32(tp->t_stats, VOI_TCP_CALCFRWINDIFF, 334adc56f5aSEdward Tomasz Napierala ((int32_t)tp->snd_cwnd) - tp->snd_wnd); 335adc56f5aSEdward Tomasz Napierala if (!IN_RECOVERY(tp->t_flags)) 336adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_u32(tp->t_stats, VOI_TCP_ACKLEN, 337adc56f5aSEdward Tomasz Napierala tp->ccv->bytes_this_ack / (tcp_maxseg(tp) * nsegs)); 338adc56f5aSEdward Tomasz Napierala if ((tp->t_flags & TF_GPUTINPROG) && 339adc56f5aSEdward Tomasz Napierala SEQ_GEQ(th->th_ack, tp->gput_ack)) { 340adc56f5aSEdward Tomasz Napierala /* 341adc56f5aSEdward Tomasz Napierala * Compute goodput in bits per millisecond. 342adc56f5aSEdward Tomasz Napierala */ 343adc56f5aSEdward Tomasz Napierala gput = (((int64_t)(th->th_ack - tp->gput_seq)) << 3) / 344adc56f5aSEdward Tomasz Napierala max(1, tcp_ts_getticks() - tp->gput_ts); 345adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_u32(tp->t_stats, VOI_TCP_GPUT, 346adc56f5aSEdward Tomasz Napierala gput); 347adc56f5aSEdward Tomasz Napierala /* 348adc56f5aSEdward Tomasz Napierala * XXXLAS: This is a temporary hack, and should be 349adc56f5aSEdward Tomasz Napierala * chained off VOI_TCP_GPUT when stats(9) grows an API 350adc56f5aSEdward Tomasz Napierala * to deal with chained VOIs. 351adc56f5aSEdward Tomasz Napierala */ 352adc56f5aSEdward Tomasz Napierala if (tp->t_stats_gput_prev > 0) 353adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_s32(tp->t_stats, 354adc56f5aSEdward Tomasz Napierala VOI_TCP_GPUT_ND, 355adc56f5aSEdward Tomasz Napierala ((gput - tp->t_stats_gput_prev) * 100) / 356adc56f5aSEdward Tomasz Napierala tp->t_stats_gput_prev); 357adc56f5aSEdward Tomasz Napierala tp->t_flags &= ~TF_GPUTINPROG; 358adc56f5aSEdward Tomasz Napierala tp->t_stats_gput_prev = gput; 359adc56f5aSEdward Tomasz Napierala } 360adc56f5aSEdward Tomasz Napierala #endif /* STATS */ 361dbc42409SLawrence Stewart if (tp->snd_cwnd > tp->snd_ssthresh) { 3621951fa79SMichael Tuexen tp->t_bytes_acked += tp->ccv->bytes_this_ack; 363dbc42409SLawrence Stewart if (tp->t_bytes_acked >= tp->snd_cwnd) { 364dbc42409SLawrence Stewart tp->t_bytes_acked -= tp->snd_cwnd; 365dbc42409SLawrence Stewart tp->ccv->flags |= CCF_ABC_SENTAWND; 366dbc42409SLawrence Stewart } 367dbc42409SLawrence Stewart } else { 368dbc42409SLawrence Stewart tp->ccv->flags &= ~CCF_ABC_SENTAWND; 369dbc42409SLawrence Stewart tp->t_bytes_acked = 0; 370dbc42409SLawrence Stewart } 371dbc42409SLawrence Stewart } 372dbc42409SLawrence Stewart 373dbc42409SLawrence Stewart if (CC_ALGO(tp)->ack_received != NULL) { 374dbc42409SLawrence Stewart /* XXXLAS: Find a way to live without this */ 375dbc42409SLawrence Stewart tp->ccv->curack = th->th_ack; 376dbc42409SLawrence Stewart CC_ALGO(tp)->ack_received(tp->ccv, type); 377dbc42409SLawrence Stewart } 378adc56f5aSEdward Tomasz Napierala #ifdef STATS 379adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_ulong(tp->t_stats, VOI_TCP_LCWIN, tp->snd_cwnd); 380adc56f5aSEdward Tomasz Napierala #endif 381dbc42409SLawrence Stewart } 382dbc42409SLawrence Stewart 38355bceb1eSRandall Stewart void 384dbc42409SLawrence Stewart cc_conn_init(struct tcpcb *tp) 385dbc42409SLawrence Stewart { 386dbc42409SLawrence Stewart struct hc_metrics_lite metrics; 387dbc42409SLawrence Stewart struct inpcb *inp = tp->t_inpcb; 3880c39d38dSGleb Smirnoff u_int maxseg; 389dbc42409SLawrence Stewart int rtt; 390dbc42409SLawrence Stewart 391dbc42409SLawrence Stewart INP_WLOCK_ASSERT(tp->t_inpcb); 392dbc42409SLawrence Stewart 393dbc42409SLawrence Stewart tcp_hc_get(&inp->inp_inc, &metrics); 3940c39d38dSGleb Smirnoff maxseg = tcp_maxseg(tp); 395dbc42409SLawrence Stewart 396dbc42409SLawrence Stewart if (tp->t_srtt == 0 && (rtt = metrics.rmx_rtt)) { 397dbc42409SLawrence Stewart tp->t_srtt = rtt; 398dbc42409SLawrence Stewart tp->t_rttbest = tp->t_srtt + TCP_RTT_SCALE; 399dbc42409SLawrence Stewart TCPSTAT_INC(tcps_usedrtt); 400dbc42409SLawrence Stewart if (metrics.rmx_rttvar) { 401dbc42409SLawrence Stewart tp->t_rttvar = metrics.rmx_rttvar; 402dbc42409SLawrence Stewart TCPSTAT_INC(tcps_usedrttvar); 403dbc42409SLawrence Stewart } else { 404dbc42409SLawrence Stewart /* default variation is +- 1 rtt */ 405dbc42409SLawrence Stewart tp->t_rttvar = 406dbc42409SLawrence Stewart tp->t_srtt * TCP_RTTVAR_SCALE / TCP_RTT_SCALE; 407dbc42409SLawrence Stewart } 408dbc42409SLawrence Stewart TCPT_RANGESET(tp->t_rxtcur, 409dbc42409SLawrence Stewart ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1, 410dbc42409SLawrence Stewart tp->t_rttmin, TCPTV_REXMTMAX); 411dbc42409SLawrence Stewart } 412dbc42409SLawrence Stewart if (metrics.rmx_ssthresh) { 413dbc42409SLawrence Stewart /* 414dbc42409SLawrence Stewart * There's some sort of gateway or interface 415dbc42409SLawrence Stewart * buffer limit on the path. Use this to set 416a4641f4eSPedro F. Giffuni * the slow start threshold, but set the 417dbc42409SLawrence Stewart * threshold to no less than 2*mss. 418dbc42409SLawrence Stewart */ 4190c39d38dSGleb Smirnoff tp->snd_ssthresh = max(2 * maxseg, metrics.rmx_ssthresh); 420dbc42409SLawrence Stewart TCPSTAT_INC(tcps_usedssthresh); 421dbc42409SLawrence Stewart } 422dbc42409SLawrence Stewart 423dbc42409SLawrence Stewart /* 4249ec4a4ccSAndre Oppermann * Set the initial slow-start flight size. 425dbc42409SLawrence Stewart * 426cf8f04f4SAndre Oppermann * If a SYN or SYN/ACK was lost and retransmitted, we have to 427cf8f04f4SAndre Oppermann * reduce the initial CWND to one segment as congestion is likely 428cf8f04f4SAndre Oppermann * requiring us to be cautious. 429dbc42409SLawrence Stewart */ 430cf8f04f4SAndre Oppermann if (tp->snd_cwnd == 1) 4310c39d38dSGleb Smirnoff tp->snd_cwnd = maxseg; /* SYN(-ACK) lost */ 432dbc42409SLawrence Stewart else 4337dc90a1dSMichael Tuexen tp->snd_cwnd = tcp_compute_initwnd(maxseg); 434dbc42409SLawrence Stewart 435dbc42409SLawrence Stewart if (CC_ALGO(tp)->conn_init != NULL) 436dbc42409SLawrence Stewart CC_ALGO(tp)->conn_init(tp->ccv); 437dbc42409SLawrence Stewart } 438dbc42409SLawrence Stewart 439dbc42409SLawrence Stewart void inline 440dbc42409SLawrence Stewart cc_cong_signal(struct tcpcb *tp, struct tcphdr *th, uint32_t type) 441dbc42409SLawrence Stewart { 442dbc42409SLawrence Stewart INP_WLOCK_ASSERT(tp->t_inpcb); 443dbc42409SLawrence Stewart 444adc56f5aSEdward Tomasz Napierala #ifdef STATS 445adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_u32(tp->t_stats, VOI_TCP_CSIG, type); 446adc56f5aSEdward Tomasz Napierala #endif 447adc56f5aSEdward Tomasz Napierala 448dbc42409SLawrence Stewart switch(type) { 449dbc42409SLawrence Stewart case CC_NDUPACK: 450dbc42409SLawrence Stewart if (!IN_FASTRECOVERY(tp->t_flags)) { 451f2512ba1SRui Paulo tp->snd_recover = tp->snd_max; 4523cf38784SMichael Tuexen if (tp->t_flags2 & TF2_ECN_PERMIT) 4533cf38784SMichael Tuexen tp->t_flags2 |= TF2_ECN_SND_CWR; 454f2512ba1SRui Paulo } 455dbc42409SLawrence Stewart break; 456dbc42409SLawrence Stewart case CC_ECN: 457af2fb894SRichard Scheffenegger if (!IN_CONGRECOVERY(tp->t_flags) || 458af2fb894SRichard Scheffenegger /* 459af2fb894SRichard Scheffenegger * Allow ECN reaction on ACK to CWR, if 460af2fb894SRichard Scheffenegger * that data segment was also CE marked. 461af2fb894SRichard Scheffenegger */ 462af2fb894SRichard Scheffenegger SEQ_GEQ(th->th_ack, tp->snd_recover)) { 463af2fb894SRichard Scheffenegger EXIT_CONGRECOVERY(tp->t_flags); 464dbc42409SLawrence Stewart TCPSTAT_INC(tcps_ecn_rcwnd); 465af2fb894SRichard Scheffenegger tp->snd_recover = tp->snd_max + 1; 4663cf38784SMichael Tuexen if (tp->t_flags2 & TF2_ECN_PERMIT) 4673cf38784SMichael Tuexen tp->t_flags2 |= TF2_ECN_SND_CWR; 468dbc42409SLawrence Stewart } 469dbc42409SLawrence Stewart break; 470dbc42409SLawrence Stewart case CC_RTO: 471dbc42409SLawrence Stewart tp->t_dupacks = 0; 472dbc42409SLawrence Stewart tp->t_bytes_acked = 0; 473dbc42409SLawrence Stewart EXIT_RECOVERY(tp->t_flags); 4749cc711c9SMichael Tuexen if (tp->t_flags2 & TF2_ECN_PERMIT) 4759cc711c9SMichael Tuexen tp->t_flags2 |= TF2_ECN_SND_CWR; 476dbc42409SLawrence Stewart break; 477dbc42409SLawrence Stewart case CC_RTO_ERR: 478dbc42409SLawrence Stewart TCPSTAT_INC(tcps_sndrexmitbad); 479dbc42409SLawrence Stewart /* RTO was unnecessary, so reset everything. */ 480dbc42409SLawrence Stewart tp->snd_cwnd = tp->snd_cwnd_prev; 481dbc42409SLawrence Stewart tp->snd_ssthresh = tp->snd_ssthresh_prev; 482dbc42409SLawrence Stewart tp->snd_recover = tp->snd_recover_prev; 483dbc42409SLawrence Stewart if (tp->t_flags & TF_WASFRECOVERY) 484dbc42409SLawrence Stewart ENTER_FASTRECOVERY(tp->t_flags); 485dbc42409SLawrence Stewart if (tp->t_flags & TF_WASCRECOVERY) 486dbc42409SLawrence Stewart ENTER_CONGRECOVERY(tp->t_flags); 487dbc42409SLawrence Stewart tp->snd_nxt = tp->snd_max; 488672dc4aeSJohn Baldwin tp->t_flags &= ~TF_PREVVALID; 489dbc42409SLawrence Stewart tp->t_badrxtwin = 0; 490dbc42409SLawrence Stewart break; 491dbc42409SLawrence Stewart } 492dbc42409SLawrence Stewart 493dbc42409SLawrence Stewart if (CC_ALGO(tp)->cong_signal != NULL) { 494dbc42409SLawrence Stewart if (th != NULL) 495dbc42409SLawrence Stewart tp->ccv->curack = th->th_ack; 496dbc42409SLawrence Stewart CC_ALGO(tp)->cong_signal(tp->ccv, type); 497dbc42409SLawrence Stewart } 498dbc42409SLawrence Stewart } 499dbc42409SLawrence Stewart 50055bceb1eSRandall Stewart void inline 501dbc42409SLawrence Stewart cc_post_recovery(struct tcpcb *tp, struct tcphdr *th) 502dbc42409SLawrence Stewart { 503dbc42409SLawrence Stewart INP_WLOCK_ASSERT(tp->t_inpcb); 504dbc42409SLawrence Stewart 505dbc42409SLawrence Stewart /* XXXLAS: KASSERT that we're in recovery? */ 506dbc42409SLawrence Stewart 507dbc42409SLawrence Stewart if (CC_ALGO(tp)->post_recovery != NULL) { 508dbc42409SLawrence Stewart tp->ccv->curack = th->th_ack; 509dbc42409SLawrence Stewart CC_ALGO(tp)->post_recovery(tp->ccv); 510dbc42409SLawrence Stewart } 511dbc42409SLawrence Stewart /* XXXLAS: EXIT_RECOVERY ? */ 512dbc42409SLawrence Stewart tp->t_bytes_acked = 0; 513e5313869SRichard Scheffenegger tp->sackhint.prr_out = 0; 514dbc42409SLawrence Stewart } 5150312fbe9SPoul-Henning Kamp 516df8bae1dSRodney W. Grimes /* 517262c1c1aSMatthew Dillon * Indicate whether this ack should be delayed. We can delay the ack if 51885536381SHiren Panchasara * following conditions are met: 51985536381SHiren Panchasara * - There is no delayed ack timer in progress. 52085536381SHiren Panchasara * - Our last ack wasn't a 0-sized window. We never want to delay 52185536381SHiren Panchasara * the ack that opens up a 0-sized window. 52285536381SHiren Panchasara * - LRO wasn't used for this segment. We make sure by checking that the 52385536381SHiren Panchasara * segment size is not larger than the MSS. 524d8c85a26SJonathan Lemon */ 525c1e5a6e5SAndre Oppermann #define DELAY_ACK(tp, tlen) \ 526b8152ba7SAndre Oppermann ((!tcp_timer_active(tp, TT_DELACK) && \ 527a14c749fSJonathan Lemon (tp->t_flags & TF_RXWIN0SENT) == 0) && \ 5280c39d38dSGleb Smirnoff (tlen <= tp->t_maxseg) && \ 529603724d3SBjoern A. Zeeb (V_tcp_delack_enabled || (tp->t_flags & TF_NEEDSYN))) 530d8c85a26SJonathan Lemon 5314ad24737SRandall Stewart void inline 53264807b30SHiren Panchasara cc_ecnpkt_handler(struct tcpcb *tp, struct tcphdr *th, uint8_t iptos) 53364807b30SHiren Panchasara { 53464807b30SHiren Panchasara INP_WLOCK_ASSERT(tp->t_inpcb); 53564807b30SHiren Panchasara 53664807b30SHiren Panchasara if (CC_ALGO(tp)->ecnpkt_handler != NULL) { 53764807b30SHiren Panchasara switch (iptos & IPTOS_ECN_MASK) { 53864807b30SHiren Panchasara case IPTOS_ECN_CE: 53964807b30SHiren Panchasara tp->ccv->flags |= CCF_IPHDR_CE; 54064807b30SHiren Panchasara break; 54164807b30SHiren Panchasara case IPTOS_ECN_ECT0: 54283a2839fSMichael Tuexen /* FALLTHROUGH */ 54364807b30SHiren Panchasara case IPTOS_ECN_ECT1: 54483a2839fSMichael Tuexen /* FALLTHROUGH */ 54583a2839fSMichael Tuexen case IPTOS_ECN_NOTECT: 54664807b30SHiren Panchasara tp->ccv->flags &= ~CCF_IPHDR_CE; 54764807b30SHiren Panchasara break; 54864807b30SHiren Panchasara } 54964807b30SHiren Panchasara 55064807b30SHiren Panchasara if (th->th_flags & TH_CWR) 55164807b30SHiren Panchasara tp->ccv->flags |= CCF_TCPHDR_CWR; 55264807b30SHiren Panchasara else 55364807b30SHiren Panchasara tp->ccv->flags &= ~CCF_TCPHDR_CWR; 55464807b30SHiren Panchasara 55564807b30SHiren Panchasara CC_ALGO(tp)->ecnpkt_handler(tp->ccv); 55664807b30SHiren Panchasara 557e11c9783SMichael Tuexen if (tp->ccv->flags & CCF_ACKNOW) { 55864807b30SHiren Panchasara tcp_timer_activate(tp, TT_DELACK, tcp_delacktime); 559e11c9783SMichael Tuexen tp->t_flags |= TF_ACKNOW; 560e11c9783SMichael Tuexen } 56164807b30SHiren Panchasara } 56264807b30SHiren Panchasara } 56364807b30SHiren Panchasara 564df8bae1dSRodney W. Grimes /* 5658d573cc1SAndre Oppermann * TCP input handling is split into multiple parts: 5668d573cc1SAndre Oppermann * tcp6_input is a thin wrapper around tcp_input for the extended 5678d573cc1SAndre Oppermann * ip6_protox[] call format in ip6_input 5688d573cc1SAndre Oppermann * tcp_input handles primary segment validation, inpcb lookup and 5698d573cc1SAndre Oppermann * SYN processing on listen sockets 5708d573cc1SAndre Oppermann * tcp_do_segment processes the ACK and text of the segment for 5718d573cc1SAndre Oppermann * establishing, established and closing connections 572df8bae1dSRodney W. Grimes */ 573fb59c426SYoshinobu Inoue #ifdef INET6 574fb59c426SYoshinobu Inoue int 575ad3f9ab3SAndre Oppermann tcp6_input(struct mbuf **mp, int *offp, int proto) 576fb59c426SYoshinobu Inoue { 577503f4e47SBjoern A. Zeeb struct mbuf *m; 57833841545SHajimu UMEMOTO struct in6_ifaddr *ia6; 5793e88eb90SAndrey V. Elsukov struct ip6_hdr *ip6; 580fb59c426SYoshinobu Inoue 581503f4e47SBjoern A. Zeeb m = *mp; 582a4adf6ccSBjoern A. Zeeb if (m->m_len < *offp + sizeof(struct tcphdr)) { 5834e619b17SBjoern A. Zeeb m = m_pullup(m, *offp + sizeof(struct tcphdr)); 5844e619b17SBjoern A. Zeeb if (m == NULL) { 5854e619b17SBjoern A. Zeeb *mp = m; 5864e619b17SBjoern A. Zeeb TCPSTAT_INC(tcps_rcvshort); 5874e619b17SBjoern A. Zeeb return (IPPROTO_DONE); 5884e619b17SBjoern A. Zeeb } 589a4adf6ccSBjoern A. Zeeb } 590fb59c426SYoshinobu Inoue 591fb59c426SYoshinobu Inoue /* 592fb59c426SYoshinobu Inoue * draft-itojun-ipv6-tcp-to-anycast 593fb59c426SYoshinobu Inoue * better place to put this in? 594fb59c426SYoshinobu Inoue */ 5953e88eb90SAndrey V. Elsukov ip6 = mtod(m, struct ip6_hdr *); 5968268d82cSAlexander V. Chernikov ia6 = in6ifa_ifwithaddr(&ip6->ip6_dst, 0 /* XXX */, false); 59733841545SHajimu UMEMOTO if (ia6 && (ia6->ia6_flags & IN6_IFF_ANYCAST)) { 598fb59c426SYoshinobu Inoue icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_ADDR, 599fb59c426SYoshinobu Inoue (caddr_t)&ip6->ip6_dst - (caddr_t)ip6); 600a8fe77d8SBjoern A. Zeeb *mp = NULL; 6018f5a8818SKevin Lo return (IPPROTO_DONE); 602fb59c426SYoshinobu Inoue } 603fb59c426SYoshinobu Inoue 604a8fe77d8SBjoern A. Zeeb *mp = m; 6058f5a8818SKevin Lo return (tcp_input(mp, offp, proto)); 606fb59c426SYoshinobu Inoue } 607b287c6c7SBjoern A. Zeeb #endif /* INET6 */ 608fb59c426SYoshinobu Inoue 6098f5a8818SKevin Lo int 6108f5a8818SKevin Lo tcp_input(struct mbuf **mp, int *offp, int proto) 611df8bae1dSRodney W. Grimes { 6128f5a8818SKevin Lo struct mbuf *m = *mp; 613b287c6c7SBjoern A. Zeeb struct tcphdr *th = NULL; 614ad3f9ab3SAndre Oppermann struct ip *ip = NULL; 615ad3f9ab3SAndre Oppermann struct inpcb *inp = NULL; 616302ce8d6SAndre Oppermann struct tcpcb *tp = NULL; 617302ce8d6SAndre Oppermann struct socket *so = NULL; 618e79adb8eSGarrett Wollman u_char *optp = NULL; 6198f5a8818SKevin Lo int off0; 62026f9a767SRodney W. Grimes int optlen = 0; 621b287c6c7SBjoern A. Zeeb #ifdef INET 622b287c6c7SBjoern A. Zeeb int len; 623c4556b2fSAndrey V. Elsukov uint8_t ipttl; 624b287c6c7SBjoern A. Zeeb #endif 625b287c6c7SBjoern A. Zeeb int tlen = 0, off; 626fb59c426SYoshinobu Inoue int drop_hdrlen; 627ad3f9ab3SAndre Oppermann int thflags; 628302ce8d6SAndre Oppermann int rstreason = 0; /* For badport_bandlim accounting purposes */ 6291d7ee746SKurt Lidl uint8_t iptos; 630c1de64a4SAndrey V. Elsukov struct m_tag *fwd_tag = NULL; 631c068736aSJeffrey Hsu #ifdef INET6 632302ce8d6SAndre Oppermann struct ip6_hdr *ip6 = NULL; 633c068736aSJeffrey Hsu int isipv6; 634c068736aSJeffrey Hsu #else 635a160e630SAndre Oppermann const void *ip6 = NULL; 636b287c6c7SBjoern A. Zeeb #endif /* INET6 */ 637302ce8d6SAndre Oppermann struct tcpopt to; /* options in this segment */ 638a160e630SAndre Oppermann char *s = NULL; /* address and port logging */ 639610ee2f9SDavid Greenman #ifdef TCPDEBUG 640c068736aSJeffrey Hsu /* 641c068736aSJeffrey Hsu * The size of tcp_saveipgen must be the size of the max ip header, 642c068736aSJeffrey Hsu * now IPv6. 643c068736aSJeffrey Hsu */ 64414739780SMaxim Konovalov u_char tcp_saveipgen[IP6_HDR_LEN]; 645410bb1bfSLuigi Rizzo struct tcphdr tcp_savetcp; 646610ee2f9SDavid Greenman short ostate = 0; 647610ee2f9SDavid Greenman #endif 648c068736aSJeffrey Hsu 649d40c0d47SGleb Smirnoff NET_EPOCH_ASSERT(); 650d40c0d47SGleb Smirnoff 651fb59c426SYoshinobu Inoue #ifdef INET6 652fb59c426SYoshinobu Inoue isipv6 = (mtod(m, struct ip *)->ip_v == 6) ? 1 : 0; 653fb59c426SYoshinobu Inoue #endif 654a0292f23SGarrett Wollman 6558f5a8818SKevin Lo off0 = *offp; 6568f5a8818SKevin Lo m = *mp; 6578f5a8818SKevin Lo *mp = NULL; 658302ce8d6SAndre Oppermann to.to_flags = 0; 65978b50714SRobert Watson TCPSTAT_INC(tcps_rcvtotal); 660fb59c426SYoshinobu Inoue 66104d3a452SHajimu UMEMOTO #ifdef INET6 662b287c6c7SBjoern A. Zeeb if (isipv6) { 663fb59c426SYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 66445747ba5SBjoern A. Zeeb th = (struct tcphdr *)((caddr_t)ip6 + off0); 665fb59c426SYoshinobu Inoue tlen = sizeof(*ip6) + ntohs(ip6->ip6_plen) - off0; 666356ab07eSBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID_IPV6) { 66745747ba5SBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR) 66845747ba5SBjoern A. Zeeb th->th_sum = m->m_pkthdr.csum_data; 66945747ba5SBjoern A. Zeeb else 67045747ba5SBjoern A. Zeeb th->th_sum = in6_cksum_pseudo(ip6, tlen, 67145747ba5SBjoern A. Zeeb IPPROTO_TCP, m->m_pkthdr.csum_data); 67245747ba5SBjoern A. Zeeb th->th_sum ^= 0xffff; 67345747ba5SBjoern A. Zeeb } else 67445747ba5SBjoern A. Zeeb th->th_sum = in6_cksum(m, IPPROTO_TCP, off0, tlen); 67545747ba5SBjoern A. Zeeb if (th->th_sum) { 67678b50714SRobert Watson TCPSTAT_INC(tcps_rcvbadsum); 677fb59c426SYoshinobu Inoue goto drop; 678fb59c426SYoshinobu Inoue } 67933841545SHajimu UMEMOTO 68033841545SHajimu UMEMOTO /* 68133841545SHajimu UMEMOTO * Be proactive about unspecified IPv6 address in source. 68233841545SHajimu UMEMOTO * As we use all-zero to indicate unbounded/unconnected pcb, 68333841545SHajimu UMEMOTO * unspecified IPv6 address can be used to confuse us. 68433841545SHajimu UMEMOTO * 68533841545SHajimu UMEMOTO * Note that packets with unspecified IPv6 destination is 68633841545SHajimu UMEMOTO * already dropped in ip6_input. 68733841545SHajimu UMEMOTO */ 68833841545SHajimu UMEMOTO if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) { 68933841545SHajimu UMEMOTO /* XXX stat */ 69033841545SHajimu UMEMOTO goto drop; 69133841545SHajimu UMEMOTO } 692bb4a7d94SKristof Provost iptos = IPV6_TRAFFIC_CLASS(ip6); 693b287c6c7SBjoern A. Zeeb } 69404d3a452SHajimu UMEMOTO #endif 695b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 696b287c6c7SBjoern A. Zeeb else 697b287c6c7SBjoern A. Zeeb #endif 698b287c6c7SBjoern A. Zeeb #ifdef INET 699b287c6c7SBjoern A. Zeeb { 700df8bae1dSRodney W. Grimes /* 701df8bae1dSRodney W. Grimes * Get IP and TCP header together in first mbuf. 702df8bae1dSRodney W. Grimes * Note: IP leaves IP header in first mbuf. 703df8bae1dSRodney W. Grimes */ 704fb59c426SYoshinobu Inoue if (off0 > sizeof (struct ip)) { 705105bd211SGleb Smirnoff ip_stripoptions(m); 706fb59c426SYoshinobu Inoue off0 = sizeof(struct ip); 707fb59c426SYoshinobu Inoue } 708df8bae1dSRodney W. Grimes if (m->m_len < sizeof (struct tcpiphdr)) { 7094dfdffe9SAndre Oppermann if ((m = m_pullup(m, sizeof (struct tcpiphdr))) 7104dfdffe9SAndre Oppermann == NULL) { 71178b50714SRobert Watson TCPSTAT_INC(tcps_rcvshort); 7128f5a8818SKevin Lo return (IPPROTO_DONE); 713df8bae1dSRodney W. Grimes } 714df8bae1dSRodney W. Grimes } 715fb59c426SYoshinobu Inoue ip = mtod(m, struct ip *); 716db4f9cc7SJonathan Lemon th = (struct tcphdr *)((caddr_t)ip + off0); 7178ad458a4SGleb Smirnoff tlen = ntohs(ip->ip_len) - off0; 718df8bae1dSRodney W. Grimes 7191d7ee746SKurt Lidl iptos = ip->ip_tos; 720db4f9cc7SJonathan Lemon if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) { 721db4f9cc7SJonathan Lemon if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR) 722db4f9cc7SJonathan Lemon th->th_sum = m->m_pkthdr.csum_data; 723db4f9cc7SJonathan Lemon else 724db4f9cc7SJonathan Lemon th->th_sum = in_pseudo(ip->ip_src.s_addr, 725c068736aSJeffrey Hsu ip->ip_dst.s_addr, 7268f134647SGleb Smirnoff htonl(m->m_pkthdr.csum_data + tlen + 727c068736aSJeffrey Hsu IPPROTO_TCP)); 728db4f9cc7SJonathan Lemon th->th_sum ^= 0xffff; 729db4f9cc7SJonathan Lemon } else { 7308f134647SGleb Smirnoff struct ipovly *ipov = (struct ipovly *)ip; 7318f134647SGleb Smirnoff 732df8bae1dSRodney W. Grimes /* 733df8bae1dSRodney W. Grimes * Checksum extended TCP header and data. 734df8bae1dSRodney W. Grimes */ 7358f134647SGleb Smirnoff len = off0 + tlen; 736c4556b2fSAndrey V. Elsukov ipttl = ip->ip_ttl; 737fb59c426SYoshinobu Inoue bzero(ipov->ih_x1, sizeof(ipov->ih_x1)); 7388f134647SGleb Smirnoff ipov->ih_len = htons(tlen); 739fb59c426SYoshinobu Inoue th->th_sum = in_cksum(m, len); 74057f60867SMark Johnston /* Reset length for SDT probes. */ 7411d7ee746SKurt Lidl ip->ip_len = htons(len); 7421d7ee746SKurt Lidl /* Reset TOS bits */ 7431d7ee746SKurt Lidl ip->ip_tos = iptos; 7441d7ee746SKurt Lidl /* Re-initialization for later version check */ 745c4556b2fSAndrey V. Elsukov ip->ip_ttl = ipttl; 7461d7ee746SKurt Lidl ip->ip_v = IPVERSION; 747b2fe54bcSAndrey V. Elsukov ip->ip_hl = off0 >> 2; 748db4f9cc7SJonathan Lemon } 74957f60867SMark Johnston 750fb59c426SYoshinobu Inoue if (th->th_sum) { 75178b50714SRobert Watson TCPSTAT_INC(tcps_rcvbadsum); 752df8bae1dSRodney W. Grimes goto drop; 753df8bae1dSRodney W. Grimes } 754fb59c426SYoshinobu Inoue } 755b287c6c7SBjoern A. Zeeb #endif /* INET */ 756df8bae1dSRodney W. Grimes 757df8bae1dSRodney W. Grimes /* 758df8bae1dSRodney W. Grimes * Check that TCP offset makes sense, 759df8bae1dSRodney W. Grimes * pull out TCP options and adjust length. XXX 760df8bae1dSRodney W. Grimes */ 761fb59c426SYoshinobu Inoue off = th->th_off << 2; 762df8bae1dSRodney W. Grimes if (off < sizeof (struct tcphdr) || off > tlen) { 76378b50714SRobert Watson TCPSTAT_INC(tcps_rcvbadoff); 764df8bae1dSRodney W. Grimes goto drop; 765df8bae1dSRodney W. Grimes } 766fb59c426SYoshinobu Inoue tlen -= off; /* tlen is used instead of ti->ti_len */ 767df8bae1dSRodney W. Grimes if (off > sizeof (struct tcphdr)) { 76804d3a452SHajimu UMEMOTO #ifdef INET6 769b287c6c7SBjoern A. Zeeb if (isipv6) { 770a4adf6ccSBjoern A. Zeeb if (m->m_len < off0 + off) { 7714e619b17SBjoern A. Zeeb m = m_pullup(m, off0 + off); 7724e619b17SBjoern A. Zeeb if (m == NULL) { 7734e619b17SBjoern A. Zeeb TCPSTAT_INC(tcps_rcvshort); 7744e619b17SBjoern A. Zeeb return (IPPROTO_DONE); 7754e619b17SBjoern A. Zeeb } 776a4adf6ccSBjoern A. Zeeb } 777fb59c426SYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 778fb59c426SYoshinobu Inoue th = (struct tcphdr *)((caddr_t)ip6 + off0); 779b287c6c7SBjoern A. Zeeb } 78004d3a452SHajimu UMEMOTO #endif 781b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 782b287c6c7SBjoern A. Zeeb else 783b287c6c7SBjoern A. Zeeb #endif 784b287c6c7SBjoern A. Zeeb #ifdef INET 785b287c6c7SBjoern A. Zeeb { 786df8bae1dSRodney W. Grimes if (m->m_len < sizeof(struct ip) + off) { 787c068736aSJeffrey Hsu if ((m = m_pullup(m, sizeof (struct ip) + off)) 7884dfdffe9SAndre Oppermann == NULL) { 78978b50714SRobert Watson TCPSTAT_INC(tcps_rcvshort); 7908f5a8818SKevin Lo return (IPPROTO_DONE); 791df8bae1dSRodney W. Grimes } 792fb59c426SYoshinobu Inoue ip = mtod(m, struct ip *); 793fb59c426SYoshinobu Inoue th = (struct tcphdr *)((caddr_t)ip + off0); 794fb59c426SYoshinobu Inoue } 795df8bae1dSRodney W. Grimes } 796b287c6c7SBjoern A. Zeeb #endif 797df8bae1dSRodney W. Grimes optlen = off - sizeof (struct tcphdr); 798fb59c426SYoshinobu Inoue optp = (u_char *)(th + 1); 799df8bae1dSRodney W. Grimes } 800fb59c426SYoshinobu Inoue thflags = th->th_flags; 801df8bae1dSRodney W. Grimes 802e46cd3d4SDag-Erling Smørgrav /* 803df8bae1dSRodney W. Grimes * Convert TCP protocol specific fields to host format. 804df8bae1dSRodney W. Grimes */ 8052903309aSAttilio Rao tcp_fields_to_host(th); 806df8bae1dSRodney W. Grimes 807df8bae1dSRodney W. Grimes /* 808794235b7SAndre Oppermann * Delay dropping TCP, IP headers, IPv6 ext headers, and TCP options. 809755c1f07SAndras Olah */ 810fb59c426SYoshinobu Inoue drop_hdrlen = off0 + off; 811755c1f07SAndras Olah 812755c1f07SAndras Olah /* 8138d573cc1SAndre Oppermann * Grab info from PACKET_TAG_IPFORWARD tag prepended to the chain. 8148d573cc1SAndre Oppermann */ 815b8056faeSGleb Smirnoff if ( 816b8056faeSGleb Smirnoff #ifdef INET6 817b8056faeSGleb Smirnoff (isipv6 && (m->m_flags & M_IP6_NEXTHOP)) 818b8056faeSGleb Smirnoff #ifdef INET 819b8056faeSGleb Smirnoff || (!isipv6 && (m->m_flags & M_IP_NEXTHOP)) 820b8056faeSGleb Smirnoff #endif 821b8056faeSGleb Smirnoff #endif 822b8056faeSGleb Smirnoff #if defined(INET) && !defined(INET6) 823b8056faeSGleb Smirnoff (m->m_flags & M_IP_NEXTHOP) 824b8056faeSGleb Smirnoff #endif 825b8056faeSGleb Smirnoff ) 8269b932e9eSAndre Oppermann fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL); 8279b932e9eSAndre Oppermann 828ce7ad664SEd Maste findpcb: 8298a006adbSBjoern A. Zeeb #ifdef INET6 8308a006adbSBjoern A. Zeeb if (isipv6 && fwd_tag != NULL) { 8318a006adbSBjoern A. Zeeb struct sockaddr_in6 *next_hop6; 8328a006adbSBjoern A. Zeeb 8338a006adbSBjoern A. Zeeb next_hop6 = (struct sockaddr_in6 *)(fwd_tag + 1); 8348a006adbSBjoern A. Zeeb /* 8358a006adbSBjoern A. Zeeb * Transparently forwarded. Pretend to be the destination. 8368a006adbSBjoern A. Zeeb * Already got one like this? 8378a006adbSBjoern A. Zeeb */ 8388a006adbSBjoern A. Zeeb inp = in6_pcblookup_mbuf(&V_tcbinfo, 8398a006adbSBjoern A. Zeeb &ip6->ip6_src, th->th_sport, &ip6->ip6_dst, th->th_dport, 8408a006adbSBjoern A. Zeeb INPLOOKUP_WLOCKPCB, m->m_pkthdr.rcvif, m); 8418a006adbSBjoern A. Zeeb if (!inp) { 8428a006adbSBjoern A. Zeeb /* 8438a006adbSBjoern A. Zeeb * It's new. Try to find the ambushing socket. 8448a006adbSBjoern A. Zeeb * Because we've rewritten the destination address, 8458a006adbSBjoern A. Zeeb * any hardware-generated hash is ignored. 8468a006adbSBjoern A. Zeeb */ 8478a006adbSBjoern A. Zeeb inp = in6_pcblookup(&V_tcbinfo, &ip6->ip6_src, 8488a006adbSBjoern A. Zeeb th->th_sport, &next_hop6->sin6_addr, 8498a006adbSBjoern A. Zeeb next_hop6->sin6_port ? ntohs(next_hop6->sin6_port) : 8508a006adbSBjoern A. Zeeb th->th_dport, INPLOOKUP_WILDCARD | 8518a006adbSBjoern A. Zeeb INPLOOKUP_WLOCKPCB, m->m_pkthdr.rcvif); 8528a006adbSBjoern A. Zeeb } 853c1de64a4SAndrey V. Elsukov } else if (isipv6) { 8548a006adbSBjoern A. Zeeb inp = in6_pcblookup_mbuf(&V_tcbinfo, &ip6->ip6_src, 8558a006adbSBjoern A. Zeeb th->th_sport, &ip6->ip6_dst, th->th_dport, 8568a006adbSBjoern A. Zeeb INPLOOKUP_WILDCARD | INPLOOKUP_WLOCKPCB, 8578a006adbSBjoern A. Zeeb m->m_pkthdr.rcvif, m); 8588a006adbSBjoern A. Zeeb } 8598a006adbSBjoern A. Zeeb #endif /* INET6 */ 8608a006adbSBjoern A. Zeeb #if defined(INET6) && defined(INET) 8618a006adbSBjoern A. Zeeb else 8628a006adbSBjoern A. Zeeb #endif 8638a006adbSBjoern A. Zeeb #ifdef INET 8648a006adbSBjoern A. Zeeb if (fwd_tag != NULL) { 8659b932e9eSAndre Oppermann struct sockaddr_in *next_hop; 8669b932e9eSAndre Oppermann 8679b932e9eSAndre Oppermann next_hop = (struct sockaddr_in *)(fwd_tag+1); 868f9e354dfSJulian Elischer /* 8692b25acc1SLuigi Rizzo * Transparently forwarded. Pretend to be the destination. 870f9e354dfSJulian Elischer * already got one like this? 871f9e354dfSJulian Elischer */ 872d3c1f003SRobert Watson inp = in_pcblookup_mbuf(&V_tcbinfo, ip->ip_src, th->th_sport, 873fa046d87SRobert Watson ip->ip_dst, th->th_dport, INPLOOKUP_WLOCKPCB, 874d3c1f003SRobert Watson m->m_pkthdr.rcvif, m); 875fa046d87SRobert Watson if (!inp) { 876fa046d87SRobert Watson /* 877fa046d87SRobert Watson * It's new. Try to find the ambushing socket. 878d3c1f003SRobert Watson * Because we've rewritten the destination address, 879d3c1f003SRobert Watson * any hardware-generated hash is ignored. 880fa046d87SRobert Watson */ 881fa046d87SRobert Watson inp = in_pcblookup(&V_tcbinfo, ip->ip_src, 882fa046d87SRobert Watson th->th_sport, next_hop->sin_addr, 883fa046d87SRobert Watson next_hop->sin_port ? ntohs(next_hop->sin_port) : 884fa046d87SRobert Watson th->th_dport, INPLOOKUP_WILDCARD | 885fa046d87SRobert Watson INPLOOKUP_WLOCKPCB, m->m_pkthdr.rcvif); 886f9e354dfSJulian Elischer } 887b10fbdeaSAndre Oppermann } else 888d3c1f003SRobert Watson inp = in_pcblookup_mbuf(&V_tcbinfo, ip->ip_src, 889fa046d87SRobert Watson th->th_sport, ip->ip_dst, th->th_dport, 890fa046d87SRobert Watson INPLOOKUP_WILDCARD | INPLOOKUP_WLOCKPCB, 891d3c1f003SRobert Watson m->m_pkthdr.rcvif, m); 8928a006adbSBjoern A. Zeeb #endif /* INET */ 893f9e354dfSJulian Elischer 894df8bae1dSRodney W. Grimes /* 895574b6964SAndre Oppermann * If the INPCB does not exist then all data in the incoming 896574b6964SAndre Oppermann * segment is discarded and an appropriate RST is sent back. 8978b07e49aSJulian Elischer * XXX MRT Send RST using which routing table? 898df8bae1dSRodney W. Grimes */ 899816a3d83SPoul-Henning Kamp if (inp == NULL) { 900574b6964SAndre Oppermann /* 901574b6964SAndre Oppermann * Log communication attempts to ports that are not 902574b6964SAndre Oppermann * in use. 903574b6964SAndre Oppermann */ 904334fc582SBjoern A. Zeeb if ((V_tcp_log_in_vain == 1 && (thflags & TH_SYN)) || 905334fc582SBjoern A. Zeeb V_tcp_log_in_vain == 2) { 906b7d747ecSAndre Oppermann if ((s = tcp_log_vain(NULL, th, (void *)ip, ip6))) 907df541e5fSAndre Oppermann log(LOG_INFO, "%s; %s: Connection attempt " 908df541e5fSAndre Oppermann "to closed port\n", s, __func__); 9092e4e1b4cSGeoff Rehmet } 910574b6964SAndre Oppermann /* 911574b6964SAndre Oppermann * When blackholing do not respond with a RST but 912574b6964SAndre Oppermann * completely ignore the segment and drop it. 913574b6964SAndre Oppermann */ 914603724d3SBjoern A. Zeeb if ((V_blackhole == 1 && (thflags & TH_SYN)) || 915603724d3SBjoern A. Zeeb V_blackhole == 2) 9161929eae1SAndre Oppermann goto dropunlock; 917574b6964SAndre Oppermann 918a57815efSBosko Milekic rstreason = BANDLIM_RST_CLOSEDPORT; 919a57815efSBosko Milekic goto dropwithreset; 920816a3d83SPoul-Henning Kamp } 921fa046d87SRobert Watson INP_WLOCK_ASSERT(inp); 922f5cf1e5fSJulien Charbon /* 923f5cf1e5fSJulien Charbon * While waiting for inp lock during the lookup, another thread 924f5cf1e5fSJulien Charbon * can have dropped the inpcb, in which case we need to loop back 925f5cf1e5fSJulien Charbon * and try to find a new inpcb to deliver to. 926f5cf1e5fSJulien Charbon */ 927f5cf1e5fSJulien Charbon if (inp->inp_flags & INP_DROPPED) { 928f5cf1e5fSJulien Charbon INP_WUNLOCK(inp); 929f5cf1e5fSJulien Charbon inp = NULL; 930f5cf1e5fSJulien Charbon goto findpcb; 931f5cf1e5fSJulien Charbon } 932c2529042SHans Petter Selasky if ((inp->inp_flowtype == M_HASHTYPE_NONE) && 933c2529042SHans Petter Selasky (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) && 934c2529042SHans Petter Selasky ((inp->inp_socket == NULL) || 935c2529042SHans Petter Selasky (inp->inp_socket->so_options & SO_ACCEPTCONN) == 0)) { 93680cb9f21SKip Macy inp->inp_flowid = m->m_pkthdr.flowid; 9372f719932SAdrian Chadd inp->inp_flowtype = M_HASHTYPE_GET(m); 93880cb9f21SKip Macy } 939fcf59617SAndrey V. Elsukov #if defined(IPSEC) || defined(IPSEC_SUPPORT) 940a2589465SKen Smith #ifdef INET6 941fcf59617SAndrey V. Elsukov if (isipv6 && IPSEC_ENABLED(ipv6) && 942fcf59617SAndrey V. Elsukov IPSEC_CHECK_POLICY(ipv6, m, inp) != 0) { 943a2589465SKen Smith goto dropunlock; 944a2589465SKen Smith } 945fcf59617SAndrey V. Elsukov #ifdef INET 946fcf59617SAndrey V. Elsukov else 947fcf59617SAndrey V. Elsukov #endif 948fcf59617SAndrey V. Elsukov #endif /* INET6 */ 949fcf59617SAndrey V. Elsukov #ifdef INET 950fcf59617SAndrey V. Elsukov if (IPSEC_ENABLED(ipv4) && 951fcf59617SAndrey V. Elsukov IPSEC_CHECK_POLICY(ipv4, m, inp) != 0) { 952fcf59617SAndrey V. Elsukov goto dropunlock; 953fcf59617SAndrey V. Elsukov } 954fcf59617SAndrey V. Elsukov #endif /* INET */ 955a2589465SKen Smith #endif /* IPSEC */ 956a2589465SKen Smith 9578d573cc1SAndre Oppermann /* 9588d573cc1SAndre Oppermann * Check the minimum TTL for socket. 9598d573cc1SAndre Oppermann */ 96034f83c52SGeorge V. Neville-Neil if (inp->inp_ip_minttl != 0) { 96134f83c52SGeorge V. Neville-Neil #ifdef INET6 9622d8868dbSJonathan T. Looney if (isipv6) { 9632d8868dbSJonathan T. Looney if (inp->inp_ip_minttl > ip6->ip6_hlim) 964302ce8d6SAndre Oppermann goto dropunlock; 9652d8868dbSJonathan T. Looney } else 96634f83c52SGeorge V. Neville-Neil #endif 96734f83c52SGeorge V. Neville-Neil if (inp->inp_ip_minttl > ip->ip_ttl) 968302ce8d6SAndre Oppermann goto dropunlock; 96934f83c52SGeorge V. Neville-Neil } 970936cd18dSAndre Oppermann 971340c35deSJonathan Lemon /* 972252ca428SRobert Watson * A previous connection in TIMEWAIT state is supposed to catch stray 973252ca428SRobert Watson * or duplicate segments arriving late. If this segment was a 9740989f56cSRobert Watson * legitimate new connection attempt, the old INPCB gets removed and 975252ca428SRobert Watson * we can try again to find a listening socket. 976252ca428SRobert Watson * 977fa046d87SRobert Watson * At this point, due to earlier optimism, we may hold only an inpcb 978fa046d87SRobert Watson * lock, and not the inpcbinfo write lock. If so, we need to try to 979fa046d87SRobert Watson * acquire it, or if that fails, acquire a reference on the inpcb, 980fa046d87SRobert Watson * drop all locks, acquire a global write lock, and then re-acquire 981fa046d87SRobert Watson * the inpcb lock. We may at that point discover that another thread 982fa046d87SRobert Watson * has tried to free the inpcb, in which case we need to loop back 983fa046d87SRobert Watson * and try to find a new inpcb to deliver to. 984fa046d87SRobert Watson * 985fa046d87SRobert Watson * XXXRW: It may be time to rethink timewait locking. 986340c35deSJonathan Lemon */ 987ad71fe3cSRobert Watson if (inp->inp_flags & INP_TIMEWAIT) { 988283c76c7SMichael Tuexen tcp_dooptions(&to, optp, optlen, 989283c76c7SMichael Tuexen (thflags & TH_SYN) ? TO_SYN : 0); 9908d573cc1SAndre Oppermann /* 9918d573cc1SAndre Oppermann * NB: tcp_twcheck unlocks the INP and frees the mbuf. 9928d573cc1SAndre Oppermann */ 9932104448fSAndre Oppermann if (tcp_twcheck(inp, &to, th, m, tlen)) 994340c35deSJonathan Lemon goto findpcb; 9958f5a8818SKevin Lo return (IPPROTO_DONE); 996340c35deSJonathan Lemon } 997794235b7SAndre Oppermann /* 998794235b7SAndre Oppermann * The TCPCB may no longer exist if the connection is winding 999794235b7SAndre Oppermann * down or it is in the CLOSED state. Either way we drop the 1000794235b7SAndre Oppermann * segment and send an appropriate response. 1001794235b7SAndre Oppermann */ 1002df8bae1dSRodney W. Grimes tp = intotcpcb(inp); 1003a160e630SAndre Oppermann if (tp == NULL || tp->t_state == TCPS_CLOSED) { 1004a57815efSBosko Milekic rstreason = BANDLIM_RST_CLOSEDPORT; 1005a57815efSBosko Milekic goto dropwithreset; 100609f81a46SBosko Milekic } 1007df8bae1dSRodney W. Grimes 100809fe6320SNavdeep Parhar #ifdef TCP_OFFLOAD 100909fe6320SNavdeep Parhar if (tp->t_flags & TF_TOE) { 101009fe6320SNavdeep Parhar tcp_offload_input(tp, m); 101109fe6320SNavdeep Parhar m = NULL; /* consumed by the TOE driver */ 101209fe6320SNavdeep Parhar goto dropunlock; 101309fe6320SNavdeep Parhar } 101409fe6320SNavdeep Parhar #endif 101509fe6320SNavdeep Parhar 1016c488362eSRobert Watson #ifdef MAC 10178501a69cSRobert Watson INP_WLOCK_ASSERT(inp); 101830d239bcSRobert Watson if (mac_inpcb_check_deliver(inp, m)) 1019302ce8d6SAndre Oppermann goto dropunlock; 1020c488362eSRobert Watson #endif 1021a557af22SRobert Watson so = inp->inp_socket; 1022302ce8d6SAndre Oppermann KASSERT(so != NULL, ("%s: so == NULL", __func__)); 1023610ee2f9SDavid Greenman #ifdef TCPDEBUG 1024df8bae1dSRodney W. Grimes if (so->so_options & SO_DEBUG) { 1025df8bae1dSRodney W. Grimes ostate = tp->t_state; 102610fe523eSMaxim Konovalov #ifdef INET6 10276f697424SBjoern A. Zeeb if (isipv6) { 1028540e8b7eSJeffrey Hsu bcopy((char *)ip6, (char *)tcp_saveipgen, sizeof(*ip6)); 1029d30d90dcSMaxim Konovalov } else 10306f697424SBjoern A. Zeeb #endif 1031540e8b7eSJeffrey Hsu bcopy((char *)ip, (char *)tcp_saveipgen, sizeof(*ip)); 1032fb59c426SYoshinobu Inoue tcp_savetcp = *th; 1033df8bae1dSRodney W. Grimes } 1034b287c6c7SBjoern A. Zeeb #endif /* TCPDEBUG */ 1035db33b3e6SAndre Oppermann /* 1036db33b3e6SAndre Oppermann * When the socket is accepting connections (the INPCB is in LISTEN 1037db33b3e6SAndre Oppermann * state) we look into the SYN cache if this is a new connection 1038a7c7f2a7SJohn Baldwin * attempt or the completion of a previous one. 1039db33b3e6SAndre Oppermann */ 104045274760SJonathan T. Looney KASSERT(tp->t_state == TCPS_LISTEN || !(so->so_options & SO_ACCEPTCONN), 104145274760SJonathan T. Looney ("%s: so accepting but tp %p not listening", __func__, tp)); 104245274760SJonathan T. Looney if (tp->t_state == TCPS_LISTEN && (so->so_options & SO_ACCEPTCONN)) { 1043540e8b7eSJeffrey Hsu struct in_conninfo inc; 1044540e8b7eSJeffrey Hsu 10458bfb1918SAndre Oppermann bzero(&inc, sizeof(inc)); 1046302ce8d6SAndre Oppermann #ifdef INET6 1047be2ac88cSJonathan Lemon if (isipv6) { 1048dcdb4371SBjoern A. Zeeb inc.inc_flags |= INC_ISIPV6; 10495dff1c38SMichael Tuexen if (inp->inp_inc.inc_flags & INC_IPV6MINMTU) 10505dff1c38SMichael Tuexen inc.inc_flags |= INC_IPV6MINMTU; 1051be2ac88cSJonathan Lemon inc.inc6_faddr = ip6->ip6_src; 1052be2ac88cSJonathan Lemon inc.inc6_laddr = ip6->ip6_dst; 1053302ce8d6SAndre Oppermann } else 1054302ce8d6SAndre Oppermann #endif 1055302ce8d6SAndre Oppermann { 1056be2ac88cSJonathan Lemon inc.inc_faddr = ip->ip_src; 1057be2ac88cSJonathan Lemon inc.inc_laddr = ip->ip_dst; 1058be2ac88cSJonathan Lemon } 1059be2ac88cSJonathan Lemon inc.inc_fport = th->th_sport; 1060be2ac88cSJonathan Lemon inc.inc_lport = th->th_dport; 10617973fba3SJulian Elischer inc.inc_fibnum = so->so_fibnum; 1062be2ac88cSJonathan Lemon 1063fb59c426SYoshinobu Inoue /* 10648d573cc1SAndre Oppermann * Check for an existing connection attempt in syncache if 10658d573cc1SAndre Oppermann * the flag is only ACK. A successful lookup creates a new 10668d573cc1SAndre Oppermann * socket appended to the listen queue in SYN_RECEIVED state. 1067fb59c426SYoshinobu Inoue */ 1068be2ac88cSJonathan Lemon if ((thflags & (TH_RST|TH_ACK|TH_SYN)) == TH_ACK) { 1069bf6d304aSAndre Oppermann /* 1070bf6d304aSAndre Oppermann * Parse the TCP options here because 1071bf6d304aSAndre Oppermann * syncookies need access to the reflected 1072bf6d304aSAndre Oppermann * timestamp. 1073bf6d304aSAndre Oppermann */ 1074bf6d304aSAndre Oppermann tcp_dooptions(&to, optp, optlen, 0); 10759fa198beSAndre Oppermann /* 10769fa198beSAndre Oppermann * NB: syncache_expand() doesn't unlock 10779fa198beSAndre Oppermann * inp and tcpinfo locks. 10789fa198beSAndre Oppermann */ 1079fcf59617SAndrey V. Elsukov rstreason = syncache_expand(&inc, &to, th, &so, m); 1080fcf59617SAndrey V. Elsukov if (rstreason < 0) { 1081fcf59617SAndrey V. Elsukov /* 1082fcf59617SAndrey V. Elsukov * A failing TCP MD5 signature comparison 1083fcf59617SAndrey V. Elsukov * must result in the segment being dropped 1084fcf59617SAndrey V. Elsukov * and must not produce any response back 1085fcf59617SAndrey V. Elsukov * to the sender. 1086fcf59617SAndrey V. Elsukov */ 1087fcf59617SAndrey V. Elsukov goto dropunlock; 1088fcf59617SAndrey V. Elsukov } else if (rstreason == 0) { 10894195b4afSPaul Traina /* 1090e207f800SAndre Oppermann * No syncache entry or ACK was not 1091be2ac88cSJonathan Lemon * for our SYN/ACK. Send a RST. 10928d573cc1SAndre Oppermann * NB: syncache did its own logging 10938d573cc1SAndre Oppermann * of the failure cause. 10944195b4afSPaul Traina */ 1095be2ac88cSJonathan Lemon rstreason = BANDLIM_RST_OPENPORT; 1096be2ac88cSJonathan Lemon goto dropwithreset; 1097be2ac88cSJonathan Lemon } 109809c305ebSPatrick Kelsey tfo_socket_result: 1099f76fcf6dSJeffrey Hsu if (so == NULL) { 1100be2ac88cSJonathan Lemon /* 1101e207f800SAndre Oppermann * We completed the 3-way handshake 1102e207f800SAndre Oppermann * but could not allocate a socket 1103e207f800SAndre Oppermann * either due to memory shortage, 1104e207f800SAndre Oppermann * listen queue length limits or 1105a160e630SAndre Oppermann * global socket limits. Send RST 1106a160e630SAndre Oppermann * or wait and have the remote end 1107a160e630SAndre Oppermann * retransmit the ACK for another 1108a160e630SAndre Oppermann * try. 1109be2ac88cSJonathan Lemon */ 1110a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1111a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 11128d573cc1SAndre Oppermann "Socket allocation failed due to " 11138d573cc1SAndre Oppermann "limits or memory shortage, %s\n", 1114ac957cd2SJulian Elischer s, __func__, 1115ac957cd2SJulian Elischer V_tcp_sc_rst_sock_fail ? 1116ac957cd2SJulian Elischer "sending RST" : "try again"); 1117603724d3SBjoern A. Zeeb if (V_tcp_sc_rst_sock_fail) { 1118e207f800SAndre Oppermann rstreason = BANDLIM_UNLIMITED; 1119e207f800SAndre Oppermann goto dropwithreset; 1120a160e630SAndre Oppermann } else 1121a160e630SAndre Oppermann goto dropunlock; 1122f76fcf6dSJeffrey Hsu } 1123be2ac88cSJonathan Lemon /* 1124be2ac88cSJonathan Lemon * Socket is created in state SYN_RECEIVED. 11258d573cc1SAndre Oppermann * Unlock the listen socket, lock the newly 11268d573cc1SAndre Oppermann * created socket and update the tp variable. 1127be2ac88cSJonathan Lemon */ 11288501a69cSRobert Watson INP_WUNLOCK(inp); /* listen socket */ 1129be2ac88cSJonathan Lemon inp = sotoinpcb(so); 1130ff9b006dSJulien Charbon /* 1131ff9b006dSJulien Charbon * New connection inpcb is already locked by 1132ff9b006dSJulien Charbon * syncache_expand(). 1133ff9b006dSJulien Charbon */ 1134ff9b006dSJulien Charbon INP_WLOCK_ASSERT(inp); 1135be2ac88cSJonathan Lemon tp = intotcpcb(inp); 11368d573cc1SAndre Oppermann KASSERT(tp->t_state == TCPS_SYN_RECEIVED, 11378d573cc1SAndre Oppermann ("%s: ", __func__)); 1138be2ac88cSJonathan Lemon /* 1139302ce8d6SAndre Oppermann * Process the segment and the data it 1140302ce8d6SAndre Oppermann * contains. tcp_do_segment() consumes 1141302ce8d6SAndre Oppermann * the mbuf chain and unlocks the inpcb. 1142302ce8d6SAndre Oppermann */ 11436138da62SMichael Tuexen TCP_PROBE5(receive, NULL, tp, m, tp, th); 114455bceb1eSRandall Stewart tp->t_fb->tfb_tcp_do_segment(m, th, so, tp, drop_hdrlen, tlen, 11456573d758SMatt Macy iptos); 11468f5a8818SKevin Lo return (IPPROTO_DONE); 1147be2ac88cSJonathan Lemon } 1148a160e630SAndre Oppermann /* 11498d573cc1SAndre Oppermann * Segment flag validation for new connection attempts: 11508d573cc1SAndre Oppermann * 1151a160e630SAndre Oppermann * Our (SYN|ACK) response was rejected. 1152a160e630SAndre Oppermann * Check with syncache and remove entry to prevent 1153a160e630SAndre Oppermann * retransmits. 115419bc77c5SAndre Oppermann * 115519bc77c5SAndre Oppermann * NB: syncache_chkrst does its own logging of failure 115619bc77c5SAndre Oppermann * causes. 1157a160e630SAndre Oppermann */ 1158a160e630SAndre Oppermann if (thflags & TH_RST) { 115993899d10SMichael Tuexen syncache_chkrst(&inc, th, m); 1160a160e630SAndre Oppermann goto dropunlock; 1161a160e630SAndre Oppermann } 1162a160e630SAndre Oppermann /* 1163a160e630SAndre Oppermann * We can't do anything without SYN. 1164a160e630SAndre Oppermann */ 1165a160e630SAndre Oppermann if ((thflags & TH_SYN) == 0) { 1166a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1167a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 1168773673c1SAndre Oppermann "SYN is missing, segment ignored\n", 11698d573cc1SAndre Oppermann s, __func__); 117078b50714SRobert Watson TCPSTAT_INC(tcps_badsyn); 1171a160e630SAndre Oppermann goto dropunlock; 1172a160e630SAndre Oppermann } 1173a160e630SAndre Oppermann /* 1174a160e630SAndre Oppermann * (SYN|ACK) is bogus on a listen socket. 1175a160e630SAndre Oppermann */ 1176fb59c426SYoshinobu Inoue if (thflags & TH_ACK) { 1177a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1178a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 11798d573cc1SAndre Oppermann "SYN|ACK invalid, segment rejected\n", 11808d573cc1SAndre Oppermann s, __func__); 1181a160e630SAndre Oppermann syncache_badack(&inc); /* XXX: Not needed! */ 118278b50714SRobert Watson TCPSTAT_INC(tcps_badsyn); 1183a57815efSBosko Milekic rstreason = BANDLIM_RST_OPENPORT; 1184a57815efSBosko Milekic goto dropwithreset; 11854195b4afSPaul Traina } 1186a160e630SAndre Oppermann /* 1187a160e630SAndre Oppermann * If the drop_synfin option is enabled, drop all 1188a160e630SAndre Oppermann * segments with both the SYN and FIN bits set. 1189a160e630SAndre Oppermann * This prevents e.g. nmap from identifying the 1190a160e630SAndre Oppermann * TCP/IP stack. 1191a160e630SAndre Oppermann * XXX: Poor reasoning. nmap has other methods 1192a160e630SAndre Oppermann * and is constantly refining its stack detection 1193a160e630SAndre Oppermann * strategies. 11948d573cc1SAndre Oppermann * XXX: This is a violation of the TCP specification 1195a160e630SAndre Oppermann * and was used by RFC1644. 1196a160e630SAndre Oppermann */ 1197603724d3SBjoern A. Zeeb if ((thflags & TH_FIN) && V_drop_synfin) { 1198a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1199a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 1200773673c1SAndre Oppermann "SYN|FIN segment ignored (based on " 12018d573cc1SAndre Oppermann "sysctl setting)\n", s, __func__); 120278b50714SRobert Watson TCPSTAT_INC(tcps_badsyn); 1203302ce8d6SAndre Oppermann goto dropunlock; 1204ebb0cbeaSPaul Traina } 1205be2ac88cSJonathan Lemon /* 1206be2ac88cSJonathan Lemon * Segment's flags are (SYN) or (SYN|FIN). 1207a160e630SAndre Oppermann * 1208a160e630SAndre Oppermann * TH_PUSH, TH_URG, TH_ECE, TH_CWR are ignored 1209a160e630SAndre Oppermann * as they do not affect the state of the TCP FSM. 1210a160e630SAndre Oppermann * The data pointed to by TH_URG and th_urp is ignored. 1211be2ac88cSJonathan Lemon */ 1212a160e630SAndre Oppermann KASSERT((thflags & (TH_RST|TH_ACK)) == 0, 1213a160e630SAndre Oppermann ("%s: Listen socket: TH_RST or TH_ACK set", __func__)); 1214a160e630SAndre Oppermann KASSERT(thflags & (TH_SYN), 1215a160e630SAndre Oppermann ("%s: Listen socket: TH_SYN not set", __func__)); 121633841545SHajimu UMEMOTO #ifdef INET6 121733841545SHajimu UMEMOTO /* 121833841545SHajimu UMEMOTO * If deprecated address is forbidden, 121933841545SHajimu UMEMOTO * we do not accept SYN to deprecated interface 122033841545SHajimu UMEMOTO * address to prevent any new inbound connection from 122133841545SHajimu UMEMOTO * getting established. 122233841545SHajimu UMEMOTO * When we do not accept SYN, we send a TCP RST, 122333841545SHajimu UMEMOTO * with deprecated source address (instead of dropping 122433841545SHajimu UMEMOTO * it). We compromise it as it is much better for peer 122533841545SHajimu UMEMOTO * to send a RST, and RST will be the final packet 122633841545SHajimu UMEMOTO * for the exchange. 122733841545SHajimu UMEMOTO * 122833841545SHajimu UMEMOTO * If we do not forbid deprecated addresses, we accept 122933841545SHajimu UMEMOTO * the SYN packet. RFC2462 does not suggest dropping 123033841545SHajimu UMEMOTO * SYN in this case. 123133841545SHajimu UMEMOTO * If we decipher RFC2462 5.5.4, it says like this: 123233841545SHajimu UMEMOTO * 1. use of deprecated addr with existing 123333841545SHajimu UMEMOTO * communication is okay - "SHOULD continue to be 123433841545SHajimu UMEMOTO * used" 123533841545SHajimu UMEMOTO * 2. use of it with new communication: 123633841545SHajimu UMEMOTO * (2a) "SHOULD NOT be used if alternate address 123733841545SHajimu UMEMOTO * with sufficient scope is available" 123833841545SHajimu UMEMOTO * (2b) nothing mentioned otherwise. 123933841545SHajimu UMEMOTO * Here we fall into (2b) case as we have no choice in 124033841545SHajimu UMEMOTO * our source address selection - we must obey the peer. 124133841545SHajimu UMEMOTO * 124233841545SHajimu UMEMOTO * The wording in RFC2462 is confusing, and there are 124333841545SHajimu UMEMOTO * multiple description text for deprecated address 124433841545SHajimu UMEMOTO * handling - worse, they are not exactly the same. 124533841545SHajimu UMEMOTO * I believe 5.5.4 is the best one, so we follow 5.5.4. 124633841545SHajimu UMEMOTO */ 1247603724d3SBjoern A. Zeeb if (isipv6 && !V_ip6_use_deprecated) { 124833841545SHajimu UMEMOTO struct in6_ifaddr *ia6; 124933841545SHajimu UMEMOTO 12508268d82cSAlexander V. Chernikov ia6 = in6ifa_ifwithaddr(&ip6->ip6_dst, 0 /* XXX */, false); 12518c0fec80SRobert Watson if (ia6 != NULL && 125233841545SHajimu UMEMOTO (ia6->ia6_flags & IN6_IFF_DEPRECATED)) { 1253a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1254a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 12558d573cc1SAndre Oppermann "Connection attempt to deprecated " 12568d573cc1SAndre Oppermann "IPv6 address rejected\n", 1257a160e630SAndre Oppermann s, __func__); 125833841545SHajimu UMEMOTO rstreason = BANDLIM_RST_OPENPORT; 125933841545SHajimu UMEMOTO goto dropwithreset; 126033841545SHajimu UMEMOTO } 126133841545SHajimu UMEMOTO } 1262b287c6c7SBjoern A. Zeeb #endif /* INET6 */ 126365f28919SJesper Skriver /* 1264db33b3e6SAndre Oppermann * Basic sanity checks on incoming SYN requests: 12658d573cc1SAndre Oppermann * Don't respond if the destination is a link layer 1266db33b3e6SAndre Oppermann * broadcast according to RFC1122 4.2.3.10, p. 104. 12678d573cc1SAndre Oppermann * If it is from this socket it must be forged. 12688d573cc1SAndre Oppermann * Don't respond if the source or destination is a 12698d573cc1SAndre Oppermann * global or subnet broad- or multicast address. 127093ec91baSCrist J. Clark * Note that it is quite possible to receive unicast 127193ec91baSCrist J. Clark * link-layer packets with a broadcast IP address. Use 127293ec91baSCrist J. Clark * in_broadcast() to find them. 1273be2ac88cSJonathan Lemon */ 12748d573cc1SAndre Oppermann if (m->m_flags & (M_BCAST|M_MCAST)) { 12758d573cc1SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 12768d573cc1SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 12778d573cc1SAndre Oppermann "Connection attempt from broad- or multicast " 1278773673c1SAndre Oppermann "link layer address ignored\n", s, __func__); 1279302ce8d6SAndre Oppermann goto dropunlock; 12808d573cc1SAndre Oppermann } 1281db33b3e6SAndre Oppermann #ifdef INET6 1282b287c6c7SBjoern A. Zeeb if (isipv6) { 1283db33b3e6SAndre Oppermann if (th->th_dport == th->th_sport && 1284a160e630SAndre Oppermann IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, &ip6->ip6_src)) { 1285a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1286a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 12878d573cc1SAndre Oppermann "Connection attempt to/from self " 1288773673c1SAndre Oppermann "ignored\n", s, __func__); 1289302ce8d6SAndre Oppermann goto dropunlock; 1290a160e630SAndre Oppermann } 1291be2ac88cSJonathan Lemon if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) || 1292a160e630SAndre Oppermann IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) { 1293a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1294a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 12958d573cc1SAndre Oppermann "Connection attempt from/to multicast " 1296773673c1SAndre Oppermann "address ignored\n", s, __func__); 1297302ce8d6SAndre Oppermann goto dropunlock; 1298a160e630SAndre Oppermann } 1299b287c6c7SBjoern A. Zeeb } 1300db33b3e6SAndre Oppermann #endif 1301b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 1302b287c6c7SBjoern A. Zeeb else 1303b287c6c7SBjoern A. Zeeb #endif 1304b287c6c7SBjoern A. Zeeb #ifdef INET 1305b287c6c7SBjoern A. Zeeb { 1306db33b3e6SAndre Oppermann if (th->th_dport == th->th_sport && 1307a160e630SAndre Oppermann ip->ip_dst.s_addr == ip->ip_src.s_addr) { 1308a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1309a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 13108d573cc1SAndre Oppermann "Connection attempt from/to self " 1311773673c1SAndre Oppermann "ignored\n", s, __func__); 1312302ce8d6SAndre Oppermann goto dropunlock; 1313a160e630SAndre Oppermann } 1314be2ac88cSJonathan Lemon if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || 1315be2ac88cSJonathan Lemon IN_MULTICAST(ntohl(ip->ip_src.s_addr)) || 13162ca2159fSCrist J. Clark ip->ip_src.s_addr == htonl(INADDR_BROADCAST) || 1317a160e630SAndre Oppermann in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) { 1318a160e630SAndre Oppermann if ((s = tcp_log_addrs(&inc, th, NULL, NULL))) 1319a160e630SAndre Oppermann log(LOG_DEBUG, "%s; %s: Listen socket: " 13208d573cc1SAndre Oppermann "Connection attempt from/to broad- " 1321773673c1SAndre Oppermann "or multicast address ignored\n", 1322a160e630SAndre Oppermann s, __func__); 1323302ce8d6SAndre Oppermann goto dropunlock; 1324c068736aSJeffrey Hsu } 1325a160e630SAndre Oppermann } 1326b287c6c7SBjoern A. Zeeb #endif 1327be2ac88cSJonathan Lemon /* 1328db33b3e6SAndre Oppermann * SYN appears to be valid. Create compressed TCP state 1329db33b3e6SAndre Oppermann * for syncache. 1330be2ac88cSJonathan Lemon */ 13313c653157SHartmut Brandt #ifdef TCPDEBUG 13323c653157SHartmut Brandt if (so->so_options & SO_DEBUG) 13333c653157SHartmut Brandt tcp_trace(TA_INPUT, ostate, tp, 13343c653157SHartmut Brandt (void *)tcp_saveipgen, &tcp_savetcp, 0); 13353c653157SHartmut Brandt #endif 13362b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 1337f72167f4SAndre Oppermann tcp_dooptions(&to, optp, optlen, TO_SYN); 1338fa49a964SMichael Tuexen if (syncache_add(&inc, &to, th, inp, &so, m, NULL, NULL, iptos)) 133909c305ebSPatrick Kelsey goto tfo_socket_result; 134018a75309SPatrick Kelsey 1341be2ac88cSJonathan Lemon /* 13424d6e7130SAndre Oppermann * Entry added to syncache and mbuf consumed. 1343a7c7f2a7SJohn Baldwin * Only the listen socket is unlocked by syncache_add(). 1344be2ac88cSJonathan Lemon */ 1345384a5c3cSAndrey V. Elsukov INP_INFO_WUNLOCK_ASSERT(&V_tcbinfo); 13468f5a8818SKevin Lo return (IPPROTO_DONE); 1347982c1675SAndre Oppermann } else if (tp->t_state == TCPS_LISTEN) { 1348982c1675SAndre Oppermann /* 1349982c1675SAndre Oppermann * When a listen socket is torn down the SO_ACCEPTCONN 1350982c1675SAndre Oppermann * flag is removed first while connections are drained 1351982c1675SAndre Oppermann * from the accept queue in a unlock/lock cycle of the 1352982c1675SAndre Oppermann * ACCEPT_LOCK, opening a race condition allowing a SYN 1353982c1675SAndre Oppermann * attempt go through unhandled. 1354982c1675SAndre Oppermann */ 1355982c1675SAndre Oppermann goto dropunlock; 1356f76fcf6dSJeffrey Hsu } 1357fcf59617SAndrey V. Elsukov #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE) 1358fcf59617SAndrey V. Elsukov if (tp->t_flags & TF_SIGNATURE) { 1359fcf59617SAndrey V. Elsukov tcp_dooptions(&to, optp, optlen, thflags); 1360fcf59617SAndrey V. Elsukov if ((to.to_flags & TOF_SIGNATURE) == 0) { 1361fcf59617SAndrey V. Elsukov TCPSTAT_INC(tcps_sig_err_nosigopt); 13622903309aSAttilio Rao goto dropunlock; 13632903309aSAttilio Rao } 1364fcf59617SAndrey V. Elsukov if (!TCPMD5_ENABLED() || 1365fcf59617SAndrey V. Elsukov TCPMD5_INPUT(m, th, to.to_signature) != 0) 1366fcf59617SAndrey V. Elsukov goto dropunlock; 13672903309aSAttilio Rao } 13682903309aSAttilio Rao #endif 13692b9c9984SGeorge V. Neville-Neil TCP_PROBE5(receive, NULL, tp, m, tp, th); 137057f60867SMark Johnston 1371302ce8d6SAndre Oppermann /* 13728d573cc1SAndre Oppermann * Segment belongs to a connection in SYN_SENT, ESTABLISHED or later 13738d573cc1SAndre Oppermann * state. tcp_do_segment() always consumes the mbuf chain, unlocks 13748d573cc1SAndre Oppermann * the inpcb, and unlocks pcbinfo. 1375302ce8d6SAndre Oppermann */ 13766573d758SMatt Macy tp->t_fb->tfb_tcp_do_segment(m, th, so, tp, drop_hdrlen, tlen, iptos); 13778f5a8818SKevin Lo return (IPPROTO_DONE); 1378be2ac88cSJonathan Lemon 1379302ce8d6SAndre Oppermann dropwithreset: 13802b9c9984SGeorge V. Neville-Neil TCP_PROBE5(receive, NULL, tp, m, tp, th); 138157f60867SMark Johnston 1382014ea782SRobert Watson if (inp != NULL) { 1383302ce8d6SAndre Oppermann tcp_dropwithreset(m, th, tp, tlen, rstreason); 1384014ea782SRobert Watson INP_WUNLOCK(inp); 1385dd8ac7f9SRobert Watson } else 1386014ea782SRobert Watson tcp_dropwithreset(m, th, NULL, tlen, rstreason); 1387302ce8d6SAndre Oppermann m = NULL; /* mbuf chain got consumed. */ 1388014ea782SRobert Watson goto drop; 1389014ea782SRobert Watson 1390302ce8d6SAndre Oppermann dropunlock: 139157f60867SMark Johnston if (m != NULL) 13922b9c9984SGeorge V. Neville-Neil TCP_PROBE5(receive, NULL, tp, m, tp, th); 139357f60867SMark Johnston 13949fa198beSAndre Oppermann if (inp != NULL) 13958501a69cSRobert Watson INP_WUNLOCK(inp); 1396014ea782SRobert Watson 1397302ce8d6SAndre Oppermann drop: 1398384a5c3cSAndrey V. Elsukov INP_INFO_WUNLOCK_ASSERT(&V_tcbinfo); 1399a160e630SAndre Oppermann if (s != NULL) 1400a160e630SAndre Oppermann free(s, M_TCPLOG); 1401302ce8d6SAndre Oppermann if (m != NULL) 1402302ce8d6SAndre Oppermann m_freem(m); 14038f5a8818SKevin Lo return (IPPROTO_DONE); 1404302ce8d6SAndre Oppermann } 1405302ce8d6SAndre Oppermann 1406e44c1887SSteven Hartland /* 1407e44c1887SSteven Hartland * Automatic sizing of receive socket buffer. Often the send 1408e44c1887SSteven Hartland * buffer size is not optimally adjusted to the actual network 1409e44c1887SSteven Hartland * conditions at hand (delay bandwidth product). Setting the 1410e44c1887SSteven Hartland * buffer size too small limits throughput on links with high 1411e44c1887SSteven Hartland * bandwidth and high delay (eg. trans-continental/oceanic links). 1412e44c1887SSteven Hartland * 1413e44c1887SSteven Hartland * On the receive side the socket buffer memory is only rarely 1414e44c1887SSteven Hartland * used to any significant extent. This allows us to be much 1415e44c1887SSteven Hartland * more aggressive in scaling the receive socket buffer. For 1416e44c1887SSteven Hartland * the case that the buffer space is actually used to a large 1417e44c1887SSteven Hartland * extent and we run out of kernel memory we can simply drop 1418e44c1887SSteven Hartland * the new segments; TCP on the sender will just retransmit it 1419e44c1887SSteven Hartland * later. Setting the buffer size too big may only consume too 1420e44c1887SSteven Hartland * much kernel memory if the application doesn't read() from 1421e44c1887SSteven Hartland * the socket or packet loss or reordering makes use of the 1422e44c1887SSteven Hartland * reassembly queue. 1423e44c1887SSteven Hartland * 1424e44c1887SSteven Hartland * The criteria to step up the receive buffer one notch are: 1425e44c1887SSteven Hartland * 1. Application has not set receive buffer size with 1426e44c1887SSteven Hartland * SO_RCVBUF. Setting SO_RCVBUF clears SB_AUTOSIZE. 1427560c0586SMichael Tuexen * 2. the number of bytes received during 1/2 of an sRTT 1428560c0586SMichael Tuexen * is at least 3/8 of the current socket buffer size. 1429560c0586SMichael Tuexen * 3. receive buffer size has not hit maximal automatic size; 1430e44c1887SSteven Hartland * 1431560c0586SMichael Tuexen * If all of the criteria are met we increaset the socket buffer 1432560c0586SMichael Tuexen * by a 1/2 (bounded by the max). This allows us to keep ahead 1433560c0586SMichael Tuexen * of slow-start but also makes it so our peer never gets limited 1434560c0586SMichael Tuexen * by our rwnd which we then open up causing a burst. 1435560c0586SMichael Tuexen * 1436560c0586SMichael Tuexen * This algorithm does two steps per RTT at most and only if 1437e44c1887SSteven Hartland * we receive a bulk stream w/o packet losses or reorderings. 1438e44c1887SSteven Hartland * Shrinking the buffer during idle times is not necessary as 1439e44c1887SSteven Hartland * it doesn't consume any memory when idle. 1440e44c1887SSteven Hartland * 1441e44c1887SSteven Hartland * TODO: Only step up if the application is actually serving 1442e44c1887SSteven Hartland * the buffer to better manage the socket buffer resources. 1443e44c1887SSteven Hartland */ 1444e44c1887SSteven Hartland int 1445e44c1887SSteven Hartland tcp_autorcvbuf(struct mbuf *m, struct tcphdr *th, struct socket *so, 1446e44c1887SSteven Hartland struct tcpcb *tp, int tlen) 1447e44c1887SSteven Hartland { 1448e44c1887SSteven Hartland int newsize = 0; 1449e44c1887SSteven Hartland 1450e44c1887SSteven Hartland if (V_tcp_do_autorcvbuf && (so->so_rcv.sb_flags & SB_AUTOSIZE) && 1451e44c1887SSteven Hartland tp->t_srtt != 0 && tp->rfbuf_ts != 0 && 1452e44c1887SSteven Hartland TCP_TS_TO_TICKS(tcp_ts_getticks() - tp->rfbuf_ts) > 1453560c0586SMichael Tuexen ((tp->t_srtt >> TCP_RTT_SHIFT)/2)) { 1454560c0586SMichael Tuexen if (tp->rfbuf_cnt > ((so->so_rcv.sb_hiwat / 2)/ 4 * 3) && 1455e44c1887SSteven Hartland so->so_rcv.sb_hiwat < V_tcp_autorcvbuf_max) { 1456560c0586SMichael Tuexen newsize = min((so->so_rcv.sb_hiwat + (so->so_rcv.sb_hiwat/2)), V_tcp_autorcvbuf_max); 1457e44c1887SSteven Hartland } 1458e44c1887SSteven Hartland TCP_PROBE6(receive__autoresize, NULL, tp, m, tp, th, newsize); 1459e44c1887SSteven Hartland 1460e44c1887SSteven Hartland /* Start over with next RTT. */ 1461e44c1887SSteven Hartland tp->rfbuf_ts = 0; 1462e44c1887SSteven Hartland tp->rfbuf_cnt = 0; 1463e44c1887SSteven Hartland } else { 1464e44c1887SSteven Hartland tp->rfbuf_cnt += tlen; /* add up */ 1465e44c1887SSteven Hartland } 1466e44c1887SSteven Hartland return (newsize); 1467e44c1887SSteven Hartland } 1468e44c1887SSteven Hartland 146955bceb1eSRandall Stewart void 14704d0770f1SRichard Scheffenegger tcp_handle_wakeup(struct tcpcb *tp, struct socket *so) 14714d0770f1SRichard Scheffenegger { 14724d0770f1SRichard Scheffenegger /* 14734d0770f1SRichard Scheffenegger * Since tp might be gone if the session entered 14744d0770f1SRichard Scheffenegger * the TIME_WAIT state before coming here, we need 14754d0770f1SRichard Scheffenegger * to check if the socket is still connected. 14764d0770f1SRichard Scheffenegger */ 14774d0770f1SRichard Scheffenegger if ((so->so_state & SS_ISCONNECTED) == 0) 14784d0770f1SRichard Scheffenegger return; 14794d0770f1SRichard Scheffenegger INP_LOCK_ASSERT(tp->t_inpcb); 14804d0770f1SRichard Scheffenegger if (tp->t_flags & TF_WAKESOR) { 14814d0770f1SRichard Scheffenegger tp->t_flags &= ~TF_WAKESOR; 14824d0770f1SRichard Scheffenegger SOCKBUF_UNLOCK_ASSERT(&so->so_rcv); 14834d0770f1SRichard Scheffenegger sorwakeup(so); 14844d0770f1SRichard Scheffenegger } 14854d0770f1SRichard Scheffenegger if (tp->t_flags & TF_WAKESOW) { 14864d0770f1SRichard Scheffenegger tp->t_flags &= ~TF_WAKESOW; 14874d0770f1SRichard Scheffenegger SOCKBUF_UNLOCK_ASSERT(&so->so_snd); 14884d0770f1SRichard Scheffenegger sowwakeup(so); 14894d0770f1SRichard Scheffenegger } 14904d0770f1SRichard Scheffenegger } 14914d0770f1SRichard Scheffenegger 14924d0770f1SRichard Scheffenegger void 1493302ce8d6SAndre Oppermann tcp_do_segment(struct mbuf *m, struct tcphdr *th, struct socket *so, 14946573d758SMatt Macy struct tcpcb *tp, int drop_hdrlen, int tlen, uint8_t iptos) 1495302ce8d6SAndre Oppermann { 1496021eaf79SHiren Panchasara int thflags, acked, ourfinisacked, needoutput = 0, sack_changed; 1497b2ade6b1SRichard Scheffenegger int rstreason, todrop, win, incforsyn = 0; 14983ac12506SJonathan T. Looney uint32_t tiwin; 14994b7b743cSLawrence Stewart uint16_t nsegs; 150007dacf03SAndre Oppermann char *s; 150107dacf03SAndre Oppermann struct in_conninfo *inc; 1502c11a15bfSGleb Smirnoff struct mbuf *mfree; 1503302ce8d6SAndre Oppermann struct tcpopt to; 1504281a0fd4SPatrick Kelsey int tfo_syn; 15053c40e1d5SRichard Scheffenegger u_int maxseg; 1506302ce8d6SAndre Oppermann 150714739780SMaxim Konovalov #ifdef TCPDEBUG 150814739780SMaxim Konovalov /* 150914739780SMaxim Konovalov * The size of tcp_saveipgen must be the size of the max ip header, 151014739780SMaxim Konovalov * now IPv6. 151114739780SMaxim Konovalov */ 151214739780SMaxim Konovalov u_char tcp_saveipgen[IP6_HDR_LEN]; 151314739780SMaxim Konovalov struct tcphdr tcp_savetcp; 151414739780SMaxim Konovalov short ostate = 0; 151514739780SMaxim Konovalov #endif 1516302ce8d6SAndre Oppermann thflags = th->th_flags; 151707dacf03SAndre Oppermann inc = &tp->t_inpcb->inp_inc; 1518d64a46eaSLawrence Stewart tp->sackhint.last_sack_ack = 0; 1519021eaf79SHiren Panchasara sack_changed = 0; 15204b7b743cSLawrence Stewart nsegs = max(1, m->m_pkthdr.lro_nsegs); 1521d40c0d47SGleb Smirnoff 1522d40c0d47SGleb Smirnoff NET_EPOCH_ASSERT(); 15238501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 1524679d9708SAndre Oppermann KASSERT(tp->t_state > TCPS_LISTEN, ("%s: TCPS_LISTEN", 1525679d9708SAndre Oppermann __func__)); 1526679d9708SAndre Oppermann KASSERT(tp->t_state != TCPS_TIME_WAIT, ("%s: TCPS_TIME_WAIT", 1527679d9708SAndre Oppermann __func__)); 1528df8bae1dSRodney W. Grimes 152986a996e6SHiren Panchasara #ifdef TCPPCAP 153086a996e6SHiren Panchasara /* Save segment, if requested. */ 153186a996e6SHiren Panchasara tcp_pcap_add(th, m, &(tp->t_inpkts)); 153286a996e6SHiren Panchasara #endif 15332529f56eSJonathan T. Looney TCP_LOG_EVENT(tp, th, &so->so_rcv, &so->so_snd, TCP_LOG_IN, 0, 15342529f56eSJonathan T. Looney tlen, NULL, true); 153586a996e6SHiren Panchasara 1536013f4df6SMichael Tuexen if ((thflags & TH_SYN) && (thflags & TH_FIN) && V_drop_synfin) { 1537013f4df6SMichael Tuexen if ((s = tcp_log_addrs(inc, th, NULL, NULL))) { 1538013f4df6SMichael Tuexen log(LOG_DEBUG, "%s; %s: " 1539013f4df6SMichael Tuexen "SYN|FIN segment ignored (based on " 1540013f4df6SMichael Tuexen "sysctl setting)\n", s, __func__); 1541013f4df6SMichael Tuexen free(s, M_TCPLOG); 1542013f4df6SMichael Tuexen } 1543013f4df6SMichael Tuexen goto drop; 1544013f4df6SMichael Tuexen } 1545013f4df6SMichael Tuexen 1546df8bae1dSRodney W. Grimes /* 1547ebfd7534SMichael Tuexen * If a segment with the ACK-bit set arrives in the SYN-SENT state 1548ebfd7534SMichael Tuexen * check SEQ.ACK first. 1549ebfd7534SMichael Tuexen */ 1550ebfd7534SMichael Tuexen if ((tp->t_state == TCPS_SYN_SENT) && (thflags & TH_ACK) && 1551ebfd7534SMichael Tuexen (SEQ_LEQ(th->th_ack, tp->iss) || SEQ_GT(th->th_ack, tp->snd_max))) { 1552ebfd7534SMichael Tuexen rstreason = BANDLIM_UNLIMITED; 1553ebfd7534SMichael Tuexen goto dropwithreset; 1554ebfd7534SMichael Tuexen } 1555ebfd7534SMichael Tuexen 1556ebfd7534SMichael Tuexen /* 1557df8bae1dSRodney W. Grimes * Segment received on connection. 1558df8bae1dSRodney W. Grimes * Reset idle time and keep-alive timer. 1559e8949f74SAndre Oppermann * XXX: This should be done after segment 1560e8949f74SAndre Oppermann * validation to ignore broken/spoofed segs. 1561df8bae1dSRodney W. Grimes */ 15629b8b58e0SJonathan Lemon tp->t_rcvtime = ticks; 1563df8bae1dSRodney W. Grimes 1564df8bae1dSRodney W. Grimes /* 1565c52102ddSHiren Panchasara * Scale up the window into a 32-bit value. 1566e8949f74SAndre Oppermann * For the SYN_SENT state the scale is zero. 1567464fcfbcSAndre Oppermann */ 1568464fcfbcSAndre Oppermann tiwin = th->th_win << tp->snd_scale; 1569adc56f5aSEdward Tomasz Napierala #ifdef STATS 1570adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_ulong(tp->t_stats, VOI_TCP_FRWIN, tiwin); 1571adc56f5aSEdward Tomasz Napierala #endif 1572464fcfbcSAndre Oppermann 1573464fcfbcSAndre Oppermann /* 1574f2512ba1SRui Paulo * TCP ECN processing. 1575f2512ba1SRui Paulo */ 15763cf38784SMichael Tuexen if (tp->t_flags2 & TF2_ECN_PERMIT) { 1577ee97681eSMichael Tuexen if (thflags & TH_CWR) { 15783cf38784SMichael Tuexen tp->t_flags2 &= ~TF2_ECN_SND_ECE; 1579ee97681eSMichael Tuexen tp->t_flags |= TF_ACKNOW; 1580ee97681eSMichael Tuexen } 1581f2512ba1SRui Paulo switch (iptos & IPTOS_ECN_MASK) { 1582f2512ba1SRui Paulo case IPTOS_ECN_CE: 15833cf38784SMichael Tuexen tp->t_flags2 |= TF2_ECN_SND_ECE; 158478b50714SRobert Watson TCPSTAT_INC(tcps_ecn_ce); 1585f2512ba1SRui Paulo break; 1586f2512ba1SRui Paulo case IPTOS_ECN_ECT0: 158778b50714SRobert Watson TCPSTAT_INC(tcps_ecn_ect0); 1588f2512ba1SRui Paulo break; 1589f2512ba1SRui Paulo case IPTOS_ECN_ECT1: 159078b50714SRobert Watson TCPSTAT_INC(tcps_ecn_ect1); 1591f2512ba1SRui Paulo break; 1592f2512ba1SRui Paulo } 159364807b30SHiren Panchasara 159464807b30SHiren Panchasara /* Process a packet differently from RFC3168. */ 159564807b30SHiren Panchasara cc_ecnpkt_handler(tp, th, iptos); 159664807b30SHiren Panchasara 1597dbc42409SLawrence Stewart /* Congestion experienced. */ 1598dbc42409SLawrence Stewart if (thflags & TH_ECE) { 1599dbc42409SLawrence Stewart cc_cong_signal(tp, th, CC_ECN); 1600f2512ba1SRui Paulo } 1601f2512ba1SRui Paulo } 1602f2512ba1SRui Paulo 1603f2512ba1SRui Paulo /* 1604f72167f4SAndre Oppermann * Parse options on any incoming segment. 1605f72167f4SAndre Oppermann */ 1606302ce8d6SAndre Oppermann tcp_dooptions(&to, (u_char *)(th + 1), 1607302ce8d6SAndre Oppermann (th->th_off << 2) - sizeof(struct tcphdr), 1608302ce8d6SAndre Oppermann (thflags & TH_SYN) ? TO_SYN : 0); 1609f72167f4SAndre Oppermann 1610fcf59617SAndrey V. Elsukov #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE) 1611fcf59617SAndrey V. Elsukov if ((tp->t_flags & TF_SIGNATURE) != 0 && 1612fcf59617SAndrey V. Elsukov (to.to_flags & TOF_SIGNATURE) == 0) { 1613fcf59617SAndrey V. Elsukov TCPSTAT_INC(tcps_sig_err_sigopt); 1614fcf59617SAndrey V. Elsukov /* XXX: should drop? */ 1615fcf59617SAndrey V. Elsukov } 1616fcf59617SAndrey V. Elsukov #endif 1617f72167f4SAndre Oppermann /* 1618f72167f4SAndre Oppermann * If echoed timestamp is later than the current time, 1619bf6d304aSAndre Oppermann * fall back to non RFC1323 RTT calculation. Normalize 1620bf6d304aSAndre Oppermann * timestamp if syncookies were used when this connection 1621bf6d304aSAndre Oppermann * was established. 1622f72167f4SAndre Oppermann */ 1623bf6d304aSAndre Oppermann if ((to.to_flags & TOF_TS) && (to.to_tsecr != 0)) { 1624e16fa5caSJohn-Mark Gurney to.to_tsecr -= tp->ts_offset; 1625d8951c8aSBjoern A. Zeeb if (TSTMP_GT(to.to_tsecr, tcp_ts_getticks())) 1626f72167f4SAndre Oppermann to.to_tsecr = 0; 162710d20c84SMatt Macy else if (tp->t_flags & TF_PREVVALID && 162810d20c84SMatt Macy tp->t_badrxtwin != 0 && SEQ_LT(to.to_tsecr, tp->t_badrxtwin)) 162910d20c84SMatt Macy cc_cong_signal(tp, th, CC_RTO_ERR); 1630bf6d304aSAndre Oppermann } 163107dacf03SAndre Oppermann /* 163297d8d152SAndre Oppermann * Process options only when we get SYN/ACK back. The SYN case 163397d8d152SAndre Oppermann * for incoming connections is handled in tcp_syncache. 16345396d0f8SAndre Oppermann * According to RFC1323 the window field in a SYN (i.e., a <SYN> 16355396d0f8SAndre Oppermann * or <SYN,ACK>) segment itself is never scaled. 163697d8d152SAndre Oppermann * XXX this is traditional behavior, may need to be cleaned up. 1637df8bae1dSRodney W. Grimes */ 16380a389eabSSimon L. B. Nielsen if (tp->t_state == TCPS_SYN_SENT && (thflags & TH_SYN)) { 16396e16d877SRichard Scheffenegger /* Handle parallel SYN for ECN */ 16406e16d877SRichard Scheffenegger if (!(thflags & TH_ACK) && 16416e16d877SRichard Scheffenegger ((thflags & (TH_CWR | TH_ECE)) == (TH_CWR | TH_ECE)) && 16426e16d877SRichard Scheffenegger ((V_tcp_do_ecn == 1) || (V_tcp_do_ecn == 2))) { 16436e16d877SRichard Scheffenegger tp->t_flags2 |= TF2_ECN_PERMIT; 16446e16d877SRichard Scheffenegger tp->t_flags2 |= TF2_ECN_SND_ECE; 16456e16d877SRichard Scheffenegger TCPSTAT_INC(tcps_ecn_shs); 16466e16d877SRichard Scheffenegger } 1647464fcfbcSAndre Oppermann if ((to.to_flags & TOF_SCALE) && 16482593f858SRichard Scheffenegger (tp->t_flags & TF_REQ_SCALE) && 16492593f858SRichard Scheffenegger !(tp->t_flags & TF_NOOPT)) { 1650be2ac88cSJonathan Lemon tp->t_flags |= TF_RCVD_SCALE; 165102a1a643SAndre Oppermann tp->snd_scale = to.to_wscale; 16528e051165SRichard Scheffenegger } else 16538e051165SRichard Scheffenegger tp->t_flags &= ~TF_REQ_SCALE; 16545396d0f8SAndre Oppermann /* 16555396d0f8SAndre Oppermann * Initial send window. It will be updated with 16565396d0f8SAndre Oppermann * the next incoming segment to the scaled value. 16575396d0f8SAndre Oppermann */ 16585396d0f8SAndre Oppermann tp->snd_wnd = th->th_win; 16598e051165SRichard Scheffenegger if ((to.to_flags & TOF_TS) && 16602593f858SRichard Scheffenegger (tp->t_flags & TF_REQ_TSTMP) && 16612593f858SRichard Scheffenegger !(tp->t_flags & TF_NOOPT)) { 1662be2ac88cSJonathan Lemon tp->t_flags |= TF_RCVD_TSTMP; 1663be2ac88cSJonathan Lemon tp->ts_recent = to.to_tsval; 1664d8951c8aSBjoern A. Zeeb tp->ts_recent_age = tcp_ts_getticks(); 16658e051165SRichard Scheffenegger } else 16668e051165SRichard Scheffenegger tp->t_flags &= ~TF_REQ_TSTMP; 1667be2ac88cSJonathan Lemon if (to.to_flags & TOF_MSS) 1668be2ac88cSJonathan Lemon tcp_mss(tp, to.to_mss); 16693529149eSAndre Oppermann if ((tp->t_flags & TF_SACK_PERMIT) && 16702593f858SRichard Scheffenegger (!(to.to_flags & TOF_SACKPERM) || 16712593f858SRichard Scheffenegger (tp->t_flags & TF_NOOPT))) 16723529149eSAndre Oppermann tp->t_flags &= ~TF_SACK_PERMIT; 1673c560df6fSPatrick Kelsey if (IS_FASTOPEN(tp->t_flags)) { 16742593f858SRichard Scheffenegger if ((to.to_flags & TOF_FASTOPEN) && 16752593f858SRichard Scheffenegger !(tp->t_flags & TF_NOOPT)) { 1676a026a53aSMichael Tuexen uint16_t mss; 1677a026a53aSMichael Tuexen 1678a026a53aSMichael Tuexen if (to.to_flags & TOF_MSS) 1679a026a53aSMichael Tuexen mss = to.to_mss; 1680c560df6fSPatrick Kelsey else 1681a026a53aSMichael Tuexen if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0) 1682a026a53aSMichael Tuexen mss = TCP6_MSS; 1683a026a53aSMichael Tuexen else 1684a026a53aSMichael Tuexen mss = TCP_MSS; 1685a026a53aSMichael Tuexen tcp_fastopen_update_cache(tp, mss, 1686a026a53aSMichael Tuexen to.to_tfo_len, to.to_tfo_cookie); 1687a026a53aSMichael Tuexen } else 1688c560df6fSPatrick Kelsey tcp_fastopen_disable_path(tp); 1689c560df6fSPatrick Kelsey } 16906d90faf3SPaul Saab } 16916d90faf3SPaul Saab 1692df8bae1dSRodney W. Grimes /* 1693283c76c7SMichael Tuexen * If timestamps were negotiated during SYN/ACK and a 1694283c76c7SMichael Tuexen * segment without a timestamp is received, silently drop 1695d2b3ceddSMichael Tuexen * the segment, unless it is a RST segment or missing timestamps are 1696d2b3ceddSMichael Tuexen * tolerated. 1697283c76c7SMichael Tuexen * See section 3.2 of RFC 7323. 16984da9052aSMichael Tuexen */ 16994da9052aSMichael Tuexen if ((tp->t_flags & TF_RCVD_TSTMP) && !(to.to_flags & TOF_TS)) { 1700d2b3ceddSMichael Tuexen if (((thflags & TH_RST) != 0) || V_tcp_tolerate_missing_ts) { 1701cc3c3485SMichael Tuexen if ((s = tcp_log_addrs(inc, th, NULL, NULL))) { 1702cc3c3485SMichael Tuexen log(LOG_DEBUG, "%s; %s: Timestamp missing, " 1703cc3c3485SMichael Tuexen "segment processed normally\n", 1704cc3c3485SMichael Tuexen s, __func__); 1705cc3c3485SMichael Tuexen free(s, M_TCPLOG); 1706cc3c3485SMichael Tuexen } 1707cc3c3485SMichael Tuexen } else { 17084da9052aSMichael Tuexen if ((s = tcp_log_addrs(inc, th, NULL, NULL))) { 17094da9052aSMichael Tuexen log(LOG_DEBUG, "%s; %s: Timestamp missing, " 1710283c76c7SMichael Tuexen "segment silently dropped\n", s, __func__); 17114da9052aSMichael Tuexen free(s, M_TCPLOG); 17124da9052aSMichael Tuexen } 1713283c76c7SMichael Tuexen goto drop; 17144da9052aSMichael Tuexen } 1715cc3c3485SMichael Tuexen } 1716283c76c7SMichael Tuexen /* 1717283c76c7SMichael Tuexen * If timestamps were not negotiated during SYN/ACK and a 171875fcd27aSMichael Tuexen * segment with a timestamp is received, ignore the 1719283c76c7SMichael Tuexen * timestamp and process the packet normally. 1720283c76c7SMichael Tuexen * See section 3.2 of RFC 7323. 1721283c76c7SMichael Tuexen */ 17224da9052aSMichael Tuexen if (!(tp->t_flags & TF_RCVD_TSTMP) && (to.to_flags & TOF_TS)) { 17234da9052aSMichael Tuexen if ((s = tcp_log_addrs(inc, th, NULL, NULL))) { 17244da9052aSMichael Tuexen log(LOG_DEBUG, "%s; %s: Timestamp not expected, " 1725283c76c7SMichael Tuexen "segment processed normally\n", s, __func__); 17264da9052aSMichael Tuexen free(s, M_TCPLOG); 17274da9052aSMichael Tuexen } 17284da9052aSMichael Tuexen } 17294da9052aSMichael Tuexen 17304da9052aSMichael Tuexen /* 1731df8bae1dSRodney W. Grimes * Header prediction: check for the two common cases 1732df8bae1dSRodney W. Grimes * of a uni-directional data xfer. If the packet has 1733df8bae1dSRodney W. Grimes * no control flags, is in-sequence, the window didn't 1734df8bae1dSRodney W. Grimes * change and we're not retransmitting, it's a 1735df8bae1dSRodney W. Grimes * candidate. If the length is zero and the ack moved 1736df8bae1dSRodney W. Grimes * forward, we're the sender side of the xfer. Just 1737df8bae1dSRodney W. Grimes * free the data acked & wake any higher level process 1738df8bae1dSRodney W. Grimes * that was blocked waiting for space. If the length 1739df8bae1dSRodney W. Grimes * is non-zero and the ack didn't move, we're the 1740df8bae1dSRodney W. Grimes * receiver side. If we're getting packets in-order 1741df8bae1dSRodney W. Grimes * (the reassembly queue is empty), add the data to 1742df8bae1dSRodney W. Grimes * the socket buffer and note that we need a delayed ack. 1743a0292f23SGarrett Wollman * Make sure that the hidden state-flags are also off. 1744c5ad39b9SAndre Oppermann * Since we check for TCPS_ESTABLISHED first, it can only 1745a0292f23SGarrett Wollman * be TH_NEEDSYN. 1746df8bae1dSRodney W. Grimes */ 1747df8bae1dSRodney W. Grimes if (tp->t_state == TCPS_ESTABLISHED && 1748c5ad39b9SAndre Oppermann th->th_seq == tp->rcv_nxt && 1749fb59c426SYoshinobu Inoue (thflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK && 1750c5ad39b9SAndre Oppermann tp->snd_nxt == tp->snd_max && 1751c5ad39b9SAndre Oppermann tiwin && tiwin == tp->snd_wnd && 1752a0292f23SGarrett Wollman ((tp->t_flags & (TF_NEEDSYN|TF_NEEDFIN)) == 0) && 1753c28440dbSRandall Stewart SEGQ_EMPTY(tp) && 17544741bfcbSPatrick Kelsey ((to.to_flags & TOF_TS) == 0 || 1755c5ad39b9SAndre Oppermann TSTMP_GEQ(to.to_tsval, tp->ts_recent)) ) { 1756df8bae1dSRodney W. Grimes /* 1757df8bae1dSRodney W. Grimes * If last ACK falls within this segment's sequence numbers, 1758df8bae1dSRodney W. Grimes * record the timestamp. 1759a0292f23SGarrett Wollman * NOTE that the test is modified according to the latest 1760a0292f23SGarrett Wollman * proposal of the tcplw@cray.com list (Braden 1993/04/26). 1761df8bae1dSRodney W. Grimes */ 1762be2ac88cSJonathan Lemon if ((to.to_flags & TOF_TS) != 0 && 1763fb59c426SYoshinobu Inoue SEQ_LEQ(th->th_seq, tp->last_ack_sent)) { 1764d8951c8aSBjoern A. Zeeb tp->ts_recent_age = tcp_ts_getticks(); 1765a0292f23SGarrett Wollman tp->ts_recent = to.to_tsval; 1766df8bae1dSRodney W. Grimes } 1767df8bae1dSRodney W. Grimes 1768fb59c426SYoshinobu Inoue if (tlen == 0) { 1769fb59c426SYoshinobu Inoue if (SEQ_GT(th->th_ack, tp->snd_una) && 1770fb59c426SYoshinobu Inoue SEQ_LEQ(th->th_ack, tp->snd_max) && 1771dbc42409SLawrence Stewart !IN_RECOVERY(tp->t_flags) && 1772fc30a251SAndre Oppermann (to.to_flags & TOF_SACK) == 0 && 1773dbc42409SLawrence Stewart TAILQ_EMPTY(&tp->snd_holes)) { 1774df8bae1dSRodney W. Grimes /* 1775e8949f74SAndre Oppermann * This is a pure ack for outstanding data. 1776df8bae1dSRodney W. Grimes */ 177778b50714SRobert Watson TCPSTAT_INC(tcps_predack); 1778252ca428SRobert Watson 17799b8b58e0SJonathan Lemon /* 178010d20c84SMatt Macy * "bad retransmit" recovery without timestamps. 17819b8b58e0SJonathan Lemon */ 178210d20c84SMatt Macy if ((to.to_flags & TOF_TS) == 0 && 178310d20c84SMatt Macy tp->t_rxtshift == 1 && 1784672dc4aeSJohn Baldwin tp->t_flags & TF_PREVVALID && 17856dfb8b31SJohn Baldwin (int)(ticks - tp->t_badrxtwin) < 0) { 1786dbc42409SLawrence Stewart cc_cong_signal(tp, th, CC_RTO_ERR); 17879b8b58e0SJonathan Lemon } 1788fa55172bSMatthew Dillon 1789fa55172bSMatthew Dillon /* 1790fa55172bSMatthew Dillon * Recalculate the transmit timer / rtt. 1791fa55172bSMatthew Dillon * 1792fa55172bSMatthew Dillon * Some boxes send broken timestamp replies 1793fa55172bSMatthew Dillon * during the SYN+ACK phase, ignore 1794fa55172bSMatthew Dillon * timestamps of 0 or we could calculate a 1795fa55172bSMatthew Dillon * huge RTT and blow up the retransmit timer. 1796fa55172bSMatthew Dillon */ 1797fa55172bSMatthew Dillon if ((to.to_flags & TOF_TS) != 0 && 1798fa55172bSMatthew Dillon to.to_tsecr) { 17993ac12506SJonathan T. Looney uint32_t t; 1800d8951c8aSBjoern A. Zeeb 1801d8951c8aSBjoern A. Zeeb t = tcp_ts_getticks() - to.to_tsecr; 1802d8951c8aSBjoern A. Zeeb if (!tp->t_rttlow || tp->t_rttlow > t) 1803d8951c8aSBjoern A. Zeeb tp->t_rttlow = t; 1804a0292f23SGarrett Wollman tcp_xmit_timer(tp, 1805d8951c8aSBjoern A. Zeeb TCP_TS_TO_TICKS(t) + 1); 1806fa55172bSMatthew Dillon } else if (tp->t_rtttime && 1807fa55172bSMatthew Dillon SEQ_GT(th->th_ack, tp->t_rtseq)) { 1808eaf80179SAndre Oppermann if (!tp->t_rttlow || 1809eaf80179SAndre Oppermann tp->t_rttlow > ticks - tp->t_rtttime) 1810eaf80179SAndre Oppermann tp->t_rttlow = ticks - tp->t_rtttime; 1811c068736aSJeffrey Hsu tcp_xmit_timer(tp, 1812c068736aSJeffrey Hsu ticks - tp->t_rtttime); 1813fa55172bSMatthew Dillon } 1814dbc42409SLawrence Stewart acked = BYTES_THIS_ACK(tp, th); 181539bc9de5SLawrence Stewart 1816bd79708dSJonathan T. Looney #ifdef TCP_HHOOK 181739bc9de5SLawrence Stewart /* Run HHOOK_TCP_ESTABLISHED_IN helper hooks. */ 181839bc9de5SLawrence Stewart hhook_run_tcp_est_in(tp, th, &to); 1819bd79708dSJonathan T. Looney #endif 182039bc9de5SLawrence Stewart 18214b7b743cSLawrence Stewart TCPSTAT_ADD(tcps_rcvackpack, nsegs); 182278b50714SRobert Watson TCPSTAT_ADD(tcps_rcvackbyte, acked); 1823df8bae1dSRodney W. Grimes sbdrop(&so->so_snd, acked); 18249d11646dSJeffrey Hsu if (SEQ_GT(tp->snd_una, tp->snd_recover) && 18259d11646dSJeffrey Hsu SEQ_LEQ(th->th_ack, tp->snd_recover)) 18269d11646dSJeffrey Hsu tp->snd_recover = th->th_ack - 1; 1827dbc42409SLawrence Stewart 1828dbc42409SLawrence Stewart /* 1829dbc42409SLawrence Stewart * Let the congestion control algorithm update 1830dbc42409SLawrence Stewart * congestion control related information. This 1831dbc42409SLawrence Stewart * typically means increasing the congestion 1832dbc42409SLawrence Stewart * window. 1833dbc42409SLawrence Stewart */ 18344b7b743cSLawrence Stewart cc_ack_received(tp, th, nsegs, CC_ACK); 1835dbc42409SLawrence Stewart 18369d11646dSJeffrey Hsu tp->snd_una = th->th_ack; 18371645d090SJeff Roberson /* 1838e8949f74SAndre Oppermann * Pull snd_wl2 up to prevent seq wrap relative 18391645d090SJeff Roberson * to th_ack. 18401645d090SJeff Roberson */ 1841cb942153SJeffrey Hsu tp->snd_wl2 = th->th_ack; 1842b5addd85SJeffrey Hsu tp->t_dupacks = 0; 1843df8bae1dSRodney W. Grimes m_freem(m); 1844df8bae1dSRodney W. Grimes 1845df8bae1dSRodney W. Grimes /* 1846df8bae1dSRodney W. Grimes * If all outstanding data are acked, stop 1847df8bae1dSRodney W. Grimes * retransmit timer, otherwise restart timer 1848df8bae1dSRodney W. Grimes * using current (possibly backed-off) value. 1849df8bae1dSRodney W. Grimes * If process is waiting for space, 1850df8bae1dSRodney W. Grimes * wakeup/selwakeup/signal. If data 1851df8bae1dSRodney W. Grimes * are ready to send, let tcp_output 1852df8bae1dSRodney W. Grimes * decide between more output or persist. 1853e8949f74SAndre Oppermann */ 18543c653157SHartmut Brandt #ifdef TCPDEBUG 18553c653157SHartmut Brandt if (so->so_options & SO_DEBUG) 18563c653157SHartmut Brandt tcp_trace(TA_INPUT, ostate, tp, 18573c653157SHartmut Brandt (void *)tcp_saveipgen, 18583c653157SHartmut Brandt &tcp_savetcp, 0); 18593c653157SHartmut Brandt #endif 18602b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 1861df8bae1dSRodney W. Grimes if (tp->snd_una == tp->snd_max) 1862b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 0); 1863b8152ba7SAndre Oppermann else if (!tcp_timer_active(tp, TT_PERSIST)) 1864b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 1865b8152ba7SAndre Oppermann tp->t_rxtcur); 18664d0770f1SRichard Scheffenegger tp->t_flags |= TF_WAKESOW; 1867cfa6009eSGleb Smirnoff if (sbavail(&so->so_snd)) 186855bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 1869a14c749fSJonathan Lemon goto check_delack; 1870df8bae1dSRodney W. Grimes } 1871fb59c426SYoshinobu Inoue } else if (th->th_ack == tp->snd_una && 1872fb59c426SYoshinobu Inoue tlen <= sbspace(&so->so_rcv)) { 18736741ecf5SAndre Oppermann int newsize = 0; /* automatic sockbuf scaling */ 18746741ecf5SAndre Oppermann 1875df8bae1dSRodney W. Grimes /* 1876252ca428SRobert Watson * This is a pure, in-sequence data packet with 1877252ca428SRobert Watson * nothing on the reassembly queue and we have enough 1878252ca428SRobert Watson * buffer space to take it. 1879df8bae1dSRodney W. Grimes */ 18806d90faf3SPaul Saab /* Clean receiver SACK report if present */ 18813529149eSAndre Oppermann if ((tp->t_flags & TF_SACK_PERMIT) && tp->rcv_numsacks) 18826d90faf3SPaul Saab tcp_clean_sackreport(tp); 188378b50714SRobert Watson TCPSTAT_INC(tcps_preddat); 1884fb59c426SYoshinobu Inoue tp->rcv_nxt += tlen; 1885e854dd38SRandall Stewart if (tlen && 1886e854dd38SRandall Stewart ((tp->t_flags2 & TF2_FBYTES_COMPLETE) == 0) && 1887e854dd38SRandall Stewart (tp->t_fbyte_in == 0)) { 1888e854dd38SRandall Stewart tp->t_fbyte_in = ticks; 1889e854dd38SRandall Stewart if (tp->t_fbyte_in == 0) 1890e854dd38SRandall Stewart tp->t_fbyte_in = 1; 1891e854dd38SRandall Stewart if (tp->t_fbyte_out && tp->t_fbyte_in) 1892e854dd38SRandall Stewart tp->t_flags2 |= TF2_FBYTES_COMPLETE; 1893e854dd38SRandall Stewart } 18941645d090SJeff Roberson /* 18951645d090SJeff Roberson * Pull snd_wl1 up to prevent seq wrap relative to 18961645d090SJeff Roberson * th_seq. 18971645d090SJeff Roberson */ 189860ee3bb2SAndre Oppermann tp->snd_wl1 = th->th_seq; 18991645d090SJeff Roberson /* 19001645d090SJeff Roberson * Pull rcv_up up to prevent seq wrap relative to 19011645d090SJeff Roberson * rcv_nxt. 19021645d090SJeff Roberson */ 19031645d090SJeff Roberson tp->rcv_up = tp->rcv_nxt; 19044b7b743cSLawrence Stewart TCPSTAT_ADD(tcps_rcvpack, nsegs); 190578b50714SRobert Watson TCPSTAT_ADD(tcps_rcvbyte, tlen); 19063c653157SHartmut Brandt #ifdef TCPDEBUG 19073c653157SHartmut Brandt if (so->so_options & SO_DEBUG) 19083c653157SHartmut Brandt tcp_trace(TA_INPUT, ostate, tp, 19093c653157SHartmut Brandt (void *)tcp_saveipgen, &tcp_savetcp, 0); 19103c653157SHartmut Brandt #endif 19112b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 19125d06879aSGeorge V. Neville-Neil 1913e44c1887SSteven Hartland newsize = tcp_autorcvbuf(m, th, so, tp, tlen); 19146741ecf5SAndre Oppermann 19156741ecf5SAndre Oppermann /* Add data to socket buffer. */ 19161e4d7da7SRobert Watson SOCKBUF_LOCK(&so->so_rcv); 1917c0b99ffaSRobert Watson if (so->so_rcv.sb_state & SBS_CANTRCVMORE) { 1918c1c36a2cSMike Silbersack m_freem(m); 1919c1c36a2cSMike Silbersack } else { 19206741ecf5SAndre Oppermann /* 19216741ecf5SAndre Oppermann * Set new socket buffer size. 19226741ecf5SAndre Oppermann * Give up when limit is reached. 19236741ecf5SAndre Oppermann */ 19246741ecf5SAndre Oppermann if (newsize) 19256741ecf5SAndre Oppermann if (!sbreserve_locked(&so->so_rcv, 19266c8286e4SRobert Watson newsize, so, NULL)) 19276741ecf5SAndre Oppermann so->so_rcv.sb_flags &= ~SB_AUTOSIZE; 1928fb59c426SYoshinobu Inoue m_adj(m, drop_hdrlen); /* delayed header drop */ 1929651e4e6aSGleb Smirnoff sbappendstream_locked(&so->so_rcv, m, 0); 1930c1c36a2cSMike Silbersack } 19314d0770f1SRichard Scheffenegger SOCKBUF_UNLOCK(&so->so_rcv); 19324d0770f1SRichard Scheffenegger tp->t_flags |= TF_WAKESOR; 1933c1e5a6e5SAndre Oppermann if (DELAY_ACK(tp, tlen)) { 19343bfd6421SJonathan Lemon tp->t_flags |= TF_DELACK; 1935f498eeeeSDavid Greenman } else { 1936e612a582SDavid Greenman tp->t_flags |= TF_ACKNOW; 193755bceb1eSRandall Stewart tp->t_fb->tfb_tcp_output(tp); 1938e612a582SDavid Greenman } 1939a14c749fSJonathan Lemon goto check_delack; 1940df8bae1dSRodney W. Grimes } 1941df8bae1dSRodney W. Grimes } 1942df8bae1dSRodney W. Grimes 1943df8bae1dSRodney W. Grimes /* 1944df8bae1dSRodney W. Grimes * Calculate amount of space in receive window, 1945df8bae1dSRodney W. Grimes * and then do TCP input processing. 1946df8bae1dSRodney W. Grimes * Receive window is amount of space in rcv queue, 1947df8bae1dSRodney W. Grimes * but not less than advertised window. 1948df8bae1dSRodney W. Grimes */ 1949df8bae1dSRodney W. Grimes win = sbspace(&so->so_rcv); 1950df8bae1dSRodney W. Grimes if (win < 0) 1951df8bae1dSRodney W. Grimes win = 0; 195266e39adcSJohn Polstra tp->rcv_wnd = imax(win, (int)(tp->rcv_adv - tp->rcv_nxt)); 1953df8bae1dSRodney W. Grimes 1954df8bae1dSRodney W. Grimes switch (tp->t_state) { 1955df8bae1dSRodney W. Grimes /* 1956764d8cefSBill Fenner * If the state is SYN_RECEIVED: 1957764d8cefSBill Fenner * if seg contains an ACK, but not for our SYN/ACK, send a RST. 1958764d8cefSBill Fenner */ 1959764d8cefSBill Fenner case TCPS_SYN_RECEIVED: 1960fb59c426SYoshinobu Inoue if ((thflags & TH_ACK) && 1961fb59c426SYoshinobu Inoue (SEQ_LEQ(th->th_ack, tp->snd_una) || 1962a57815efSBosko Milekic SEQ_GT(th->th_ack, tp->snd_max))) { 1963a57815efSBosko Milekic rstreason = BANDLIM_RST_OPENPORT; 1964a57815efSBosko Milekic goto dropwithreset; 1965a57815efSBosko Milekic } 196668bd7ed1SJonathan T. Looney if (IS_FASTOPEN(tp->t_flags)) { 1967281a0fd4SPatrick Kelsey /* 1968281a0fd4SPatrick Kelsey * When a TFO connection is in SYN_RECEIVED, the 1969281a0fd4SPatrick Kelsey * only valid packets are the initial SYN, a 1970281a0fd4SPatrick Kelsey * retransmit/copy of the initial SYN (possibly with 1971281a0fd4SPatrick Kelsey * a subset of the original data), a valid ACK, a 1972281a0fd4SPatrick Kelsey * FIN, or a RST. 1973281a0fd4SPatrick Kelsey */ 1974281a0fd4SPatrick Kelsey if ((thflags & (TH_SYN|TH_ACK)) == (TH_SYN|TH_ACK)) { 1975281a0fd4SPatrick Kelsey rstreason = BANDLIM_RST_OPENPORT; 1976281a0fd4SPatrick Kelsey goto dropwithreset; 1977281a0fd4SPatrick Kelsey } else if (thflags & TH_SYN) { 1978281a0fd4SPatrick Kelsey /* non-initial SYN is ignored */ 1979281a0fd4SPatrick Kelsey if ((tcp_timer_active(tp, TT_DELACK) || 1980281a0fd4SPatrick Kelsey tcp_timer_active(tp, TT_REXMT))) 1981281a0fd4SPatrick Kelsey goto drop; 1982281a0fd4SPatrick Kelsey } else if (!(thflags & (TH_ACK|TH_FIN|TH_RST))) { 1983281a0fd4SPatrick Kelsey goto drop; 1984281a0fd4SPatrick Kelsey } 1985281a0fd4SPatrick Kelsey } 1986764d8cefSBill Fenner break; 1987764d8cefSBill Fenner 1988764d8cefSBill Fenner /* 1989df8bae1dSRodney W. Grimes * If the state is SYN_SENT: 199098732609SMichael Tuexen * if seg contains a RST with valid ACK (SEQ.ACK has already 199198732609SMichael Tuexen * been verified), then drop the connection. 199298732609SMichael Tuexen * if seg contains a RST without an ACK, drop the seg. 199398732609SMichael Tuexen * if seg does not contain SYN, then drop the seg. 1994df8bae1dSRodney W. Grimes * Otherwise this is an acceptable SYN segment 1995df8bae1dSRodney W. Grimes * initialize tp->rcv_nxt and tp->irs 1996df8bae1dSRodney W. Grimes * if seg contains ack then advance tp->snd_una 1997f2512ba1SRui Paulo * if seg contains an ECE and ECN support is enabled, the stream 1998f2512ba1SRui Paulo * is ECN capable. 1999df8bae1dSRodney W. Grimes * if SYN has been acked change to ESTABLISHED else SYN_RCVD state 2000df8bae1dSRodney W. Grimes * arrange for segment to be acked (eventually) 2001df8bae1dSRodney W. Grimes * continue processing rest of data/controls, beginning with URG 2002df8bae1dSRodney W. Grimes */ 2003df8bae1dSRodney W. Grimes case TCPS_SYN_SENT: 200457f60867SMark Johnston if ((thflags & (TH_ACK|TH_RST)) == (TH_ACK|TH_RST)) { 2005d9fae5abSAndriy Gapon TCP_PROBE5(connect__refused, NULL, tp, 20062b9c9984SGeorge V. Neville-Neil m, tp, th); 2007df8bae1dSRodney W. Grimes tp = tcp_drop(tp, ECONNREFUSED); 200857f60867SMark Johnston } 20090ca3f933SAndre Oppermann if (thflags & TH_RST) 2010df8bae1dSRodney W. Grimes goto drop; 20110ca3f933SAndre Oppermann if (!(thflags & TH_SYN)) 2012df8bae1dSRodney W. Grimes goto drop; 2013464fcfbcSAndre Oppermann 2014fb59c426SYoshinobu Inoue tp->irs = th->th_seq; 2015df8bae1dSRodney W. Grimes tcp_rcvseqinit(tp); 2016fb59c426SYoshinobu Inoue if (thflags & TH_ACK) { 2017c560df6fSPatrick Kelsey int tfo_partial_ack = 0; 2018c560df6fSPatrick Kelsey 201978b50714SRobert Watson TCPSTAT_INC(tcps_connects); 2020845799c1SAndras Olah soisconnected(so); 2021c488362eSRobert Watson #ifdef MAC 202230d239bcSRobert Watson mac_socketpeer_set_from_mbuf(m, so); 2023c488362eSRobert Watson #endif 2024845799c1SAndras Olah /* Do window scaling on this connection? */ 2025845799c1SAndras Olah if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) == 2026845799c1SAndras Olah (TF_RCVD_SCALE|TF_REQ_SCALE)) { 2027845799c1SAndras Olah tp->rcv_scale = tp->request_r_scale; 2028845799c1SAndras Olah } 20293ac12506SJonathan T. Looney tp->rcv_adv += min(tp->rcv_wnd, 2030766282cbSJohn Baldwin TCP_MAXWIN << tp->rcv_scale); 2031a0292f23SGarrett Wollman tp->snd_una++; /* SYN is acked */ 2032a0292f23SGarrett Wollman /* 2033c560df6fSPatrick Kelsey * If not all the data that was sent in the TFO SYN 2034c560df6fSPatrick Kelsey * has been acked, resend the remainder right away. 2035c560df6fSPatrick Kelsey */ 2036c560df6fSPatrick Kelsey if (IS_FASTOPEN(tp->t_flags) && 2037c560df6fSPatrick Kelsey (tp->snd_una != tp->snd_max)) { 2038c560df6fSPatrick Kelsey tp->snd_nxt = th->th_ack; 2039c560df6fSPatrick Kelsey tfo_partial_ack = 1; 2040c560df6fSPatrick Kelsey } 2041c560df6fSPatrick Kelsey /* 2042a0292f23SGarrett Wollman * If there's data, delay ACK; if there's also a FIN 2043a0292f23SGarrett Wollman * ACKNOW will be turned on later. 2044a0292f23SGarrett Wollman */ 2045c560df6fSPatrick Kelsey if (DELAY_ACK(tp, tlen) && tlen != 0 && !tfo_partial_ack) 2046b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_DELACK, 2047b8152ba7SAndre Oppermann tcp_delacktime); 2048a0292f23SGarrett Wollman else 2049a0292f23SGarrett Wollman tp->t_flags |= TF_ACKNOW; 2050f2512ba1SRui Paulo 2051bf7fcdb1SMichael Tuexen if (((thflags & (TH_CWR | TH_ECE)) == TH_ECE) && 2052a2d59694SMichael Tuexen (V_tcp_do_ecn == 1)) { 20533cf38784SMichael Tuexen tp->t_flags2 |= TF2_ECN_PERMIT; 205478b50714SRobert Watson TCPSTAT_INC(tcps_ecn_shs); 2055f2512ba1SRui Paulo } 2056f2512ba1SRui Paulo 2057a0292f23SGarrett Wollman /* 2058a0292f23SGarrett Wollman * Received <SYN,ACK> in SYN_SENT[*] state. 2059a0292f23SGarrett Wollman * Transitions: 2060a0292f23SGarrett Wollman * SYN_SENT --> ESTABLISHED 2061a0292f23SGarrett Wollman * SYN_SENT* --> FIN_WAIT_1 2062a0292f23SGarrett Wollman */ 20639b8b58e0SJonathan Lemon tp->t_starttime = ticks; 2064a0292f23SGarrett Wollman if (tp->t_flags & TF_NEEDFIN) { 206557f60867SMark Johnston tcp_state_change(tp, TCPS_FIN_WAIT_1); 2066a0292f23SGarrett Wollman tp->t_flags &= ~TF_NEEDFIN; 2067fb59c426SYoshinobu Inoue thflags &= ~TH_SYN; 20687ff19458SPaul Traina } else { 206957f60867SMark Johnston tcp_state_change(tp, TCPS_ESTABLISHED); 2070d9fae5abSAndriy Gapon TCP_PROBE5(connect__established, NULL, tp, 20712b9c9984SGeorge V. Neville-Neil m, tp, th); 2072dbc42409SLawrence Stewart cc_conn_init(tp); 20739077f387SGleb Smirnoff tcp_timer_activate(tp, TT_KEEP, 20749077f387SGleb Smirnoff TP_KEEPIDLE(tp)); 20757ff19458SPaul Traina } 2076a0292f23SGarrett Wollman } else { 2077a0292f23SGarrett Wollman /* 2078c068736aSJeffrey Hsu * Received initial SYN in SYN-SENT[*] state => 2079153edc50SHiren Panchasara * simultaneous open. 2080c068736aSJeffrey Hsu * If it succeeds, connection is * half-synchronized. 2081c068736aSJeffrey Hsu * Otherwise, do 3-way handshake: 2082a0292f23SGarrett Wollman * SYN-SENT -> SYN-RECEIVED 2083a0292f23SGarrett Wollman * SYN-SENT* -> SYN-RECEIVED* 2084a0292f23SGarrett Wollman */ 20854b8e98d6SQing Li tp->t_flags |= (TF_ACKNOW | TF_NEEDSYN); 2086b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 0); 208757f60867SMark Johnston tcp_state_change(tp, TCPS_SYN_RECEIVED); 2088a0292f23SGarrett Wollman } 2089df8bae1dSRodney W. Grimes 20908501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 20917cfc6904SRobert Watson 2092df8bae1dSRodney W. Grimes /* 2093fb59c426SYoshinobu Inoue * Advance th->th_seq to correspond to first data byte. 2094df8bae1dSRodney W. Grimes * If data, trim to stay within window, 2095df8bae1dSRodney W. Grimes * dropping FIN if necessary. 2096df8bae1dSRodney W. Grimes */ 2097fb59c426SYoshinobu Inoue th->th_seq++; 2098fb59c426SYoshinobu Inoue if (tlen > tp->rcv_wnd) { 2099fb59c426SYoshinobu Inoue todrop = tlen - tp->rcv_wnd; 2100df8bae1dSRodney W. Grimes m_adj(m, -todrop); 2101fb59c426SYoshinobu Inoue tlen = tp->rcv_wnd; 2102fb59c426SYoshinobu Inoue thflags &= ~TH_FIN; 210378b50714SRobert Watson TCPSTAT_INC(tcps_rcvpackafterwin); 210478b50714SRobert Watson TCPSTAT_ADD(tcps_rcvbyteafterwin, todrop); 2105df8bae1dSRodney W. Grimes } 2106fb59c426SYoshinobu Inoue tp->snd_wl1 = th->th_seq - 1; 2107fb59c426SYoshinobu Inoue tp->rcv_up = th->th_seq; 2108a0292f23SGarrett Wollman /* 2109a0292f23SGarrett Wollman * Client side of transaction: already sent SYN and data. 2110a0292f23SGarrett Wollman * If the remote host used T/TCP to validate the SYN, 2111a0292f23SGarrett Wollman * our data will be ACK'd; if so, enter normal data segment 2112a0292f23SGarrett Wollman * processing in the middle of step 5, ack processing. 2113a0292f23SGarrett Wollman * Otherwise, goto step 6. 2114a0292f23SGarrett Wollman */ 2115fb59c426SYoshinobu Inoue if (thflags & TH_ACK) 2116a0292f23SGarrett Wollman goto process_ACK; 2117c068736aSJeffrey Hsu 2118df8bae1dSRodney W. Grimes goto step6; 2119c068736aSJeffrey Hsu 2120a0292f23SGarrett Wollman /* 2121a0292f23SGarrett Wollman * If the state is LAST_ACK or CLOSING or TIME_WAIT: 2122c94c54e4SAndre Oppermann * do normal processing. 2123a0292f23SGarrett Wollman * 2124c94c54e4SAndre Oppermann * NB: Leftover from RFC1644 T/TCP. Cases to be reused later. 2125a0292f23SGarrett Wollman */ 2126a0292f23SGarrett Wollman case TCPS_LAST_ACK: 2127a0292f23SGarrett Wollman case TCPS_CLOSING: 2128a0292f23SGarrett Wollman break; /* continue normal processing */ 2129df8bae1dSRodney W. Grimes } 2130df8bae1dSRodney W. Grimes 2131df8bae1dSRodney W. Grimes /* 2132df8bae1dSRodney W. Grimes * States other than LISTEN or SYN_SENT. 213380ab7c0eSGarrett Wollman * First check the RST flag and sequence number since reset segments 213480ab7c0eSGarrett Wollman * are exempt from the timestamp and connection count tests. This 213580ab7c0eSGarrett Wollman * fixes a bug introduced by the Stevens, vol. 2, p. 960 bugfix 213680ab7c0eSGarrett Wollman * below which allowed reset segments in half the sequence space 213780ab7c0eSGarrett Wollman * to fall though and be processed (which gives forged reset 213880ab7c0eSGarrett Wollman * segments with a random sequence number a 50 percent chance of 213980ab7c0eSGarrett Wollman * killing a connection). 214080ab7c0eSGarrett Wollman * Then check timestamp, if present. 2141a0292f23SGarrett Wollman * Then check the connection count, if present. 2142df8bae1dSRodney W. Grimes * Then check that at least some bytes of segment are within 2143df8bae1dSRodney W. Grimes * receive window. If segment begins before rcv_nxt, 2144df8bae1dSRodney W. Grimes * drop leading data (and SYN); if nothing left, just ack. 214580ab7c0eSGarrett Wollman */ 2146fb59c426SYoshinobu Inoue if (thflags & TH_RST) { 21473220a212SGleb Smirnoff /* 21483220a212SGleb Smirnoff * RFC5961 Section 3.2 21493220a212SGleb Smirnoff * 21503220a212SGleb Smirnoff * - RST drops connection only if SEG.SEQ == RCV.NXT. 21513220a212SGleb Smirnoff * - If RST is in window, we send challenge ACK. 21523220a212SGleb Smirnoff * 21533220a212SGleb Smirnoff * Note: to take into account delayed ACKs, we should 21543220a212SGleb Smirnoff * test against last_ack_sent instead of rcv_nxt. 21553220a212SGleb Smirnoff * Note 2: we handle special case of closed window, not 21563220a212SGleb Smirnoff * covered by the RFC. 21573220a212SGleb Smirnoff */ 21583220a212SGleb Smirnoff if ((SEQ_GEQ(th->th_seq, tp->last_ack_sent) && 21593220a212SGleb Smirnoff SEQ_LT(th->th_seq, tp->last_ack_sent + tp->rcv_wnd)) || 21603220a212SGleb Smirnoff (tp->rcv_wnd == 0 && tp->last_ack_sent == th->th_seq)) { 21613220a212SGleb Smirnoff KASSERT(tp->t_state != TCPS_SYN_SENT, 21623220a212SGleb Smirnoff ("%s: TH_RST for TCPS_SYN_SENT th %p tp %p", 21633220a212SGleb Smirnoff __func__, th, tp)); 21643220a212SGleb Smirnoff 21653220a212SGleb Smirnoff if (V_tcp_insecure_rst || 21663220a212SGleb Smirnoff tp->last_ack_sent == th->th_seq) { 21673220a212SGleb Smirnoff TCPSTAT_INC(tcps_drops); 21683220a212SGleb Smirnoff /* Drop the connection. */ 21693220a212SGleb Smirnoff switch (tp->t_state) { 217080ab7c0eSGarrett Wollman case TCPS_SYN_RECEIVED: 217180ab7c0eSGarrett Wollman so->so_error = ECONNREFUSED; 217280ab7c0eSGarrett Wollman goto close; 217380ab7c0eSGarrett Wollman case TCPS_ESTABLISHED: 217480ab7c0eSGarrett Wollman case TCPS_FIN_WAIT_1: 217580ab7c0eSGarrett Wollman case TCPS_FIN_WAIT_2: 217680ab7c0eSGarrett Wollman case TCPS_CLOSE_WAIT: 21776779a1a1SMichael Tuexen case TCPS_CLOSING: 21786779a1a1SMichael Tuexen case TCPS_LAST_ACK: 217980ab7c0eSGarrett Wollman so->so_error = ECONNRESET; 218080ab7c0eSGarrett Wollman close: 21813220a212SGleb Smirnoff /* FALLTHROUGH */ 21823220a212SGleb Smirnoff default: 218380ab7c0eSGarrett Wollman tp = tcp_close(tp); 21843220a212SGleb Smirnoff } 21853220a212SGleb Smirnoff } else { 21863220a212SGleb Smirnoff TCPSTAT_INC(tcps_badrst); 21873220a212SGleb Smirnoff /* Send challenge ACK. */ 21883220a212SGleb Smirnoff tcp_respond(tp, mtod(m, void *), th, m, 21893220a212SGleb Smirnoff tp->rcv_nxt, tp->snd_nxt, TH_ACK); 21903220a212SGleb Smirnoff tp->last_ack_sent = tp->rcv_nxt; 21913220a212SGleb Smirnoff m = NULL; 21923220a212SGleb Smirnoff } 21933220a212SGleb Smirnoff } 21943220a212SGleb Smirnoff goto drop; 21953220a212SGleb Smirnoff } 219680ab7c0eSGarrett Wollman 21973220a212SGleb Smirnoff /* 21983220a212SGleb Smirnoff * RFC5961 Section 4.2 21993220a212SGleb Smirnoff * Send challenge ACK for any SYN in synchronized state. 22003220a212SGleb Smirnoff */ 2201281a0fd4SPatrick Kelsey if ((thflags & TH_SYN) && tp->t_state != TCPS_SYN_SENT && 2202281a0fd4SPatrick Kelsey tp->t_state != TCPS_SYN_RECEIVED) { 22033220a212SGleb Smirnoff TCPSTAT_INC(tcps_badsyn); 22043220a212SGleb Smirnoff if (V_tcp_insecure_syn && 22053220a212SGleb Smirnoff SEQ_GEQ(th->th_seq, tp->last_ack_sent) && 22063220a212SGleb Smirnoff SEQ_LT(th->th_seq, tp->last_ack_sent + tp->rcv_wnd)) { 22073220a212SGleb Smirnoff tp = tcp_drop(tp, ECONNRESET); 22083220a212SGleb Smirnoff rstreason = BANDLIM_UNLIMITED; 22093220a212SGleb Smirnoff } else { 22103220a212SGleb Smirnoff /* Send challenge ACK. */ 22113220a212SGleb Smirnoff tcp_respond(tp, mtod(m, void *), th, m, tp->rcv_nxt, 22123220a212SGleb Smirnoff tp->snd_nxt, TH_ACK); 22133220a212SGleb Smirnoff tp->last_ack_sent = tp->rcv_nxt; 22143220a212SGleb Smirnoff m = NULL; 221580ab7c0eSGarrett Wollman } 221680ab7c0eSGarrett Wollman goto drop; 221780ab7c0eSGarrett Wollman } 221880ab7c0eSGarrett Wollman 221980ab7c0eSGarrett Wollman /* 2220df8bae1dSRodney W. Grimes * RFC 1323 PAWS: If we have a timestamp reply on this segment 2221df8bae1dSRodney W. Grimes * and it's less than ts_recent, drop it. 2222df8bae1dSRodney W. Grimes */ 2223be2ac88cSJonathan Lemon if ((to.to_flags & TOF_TS) != 0 && tp->ts_recent && 222480ab7c0eSGarrett Wollman TSTMP_LT(to.to_tsval, tp->ts_recent)) { 2225df8bae1dSRodney W. Grimes /* Check to see if ts_recent is over 24 days old. */ 2226d8951c8aSBjoern A. Zeeb if (tcp_ts_getticks() - tp->ts_recent_age > TCP_PAWS_IDLE) { 2227df8bae1dSRodney W. Grimes /* 2228df8bae1dSRodney W. Grimes * Invalidate ts_recent. If this segment updates 2229df8bae1dSRodney W. Grimes * ts_recent, the age will be reset later and ts_recent 2230df8bae1dSRodney W. Grimes * will get a valid value. If it does not, setting 2231df8bae1dSRodney W. Grimes * ts_recent to zero will at least satisfy the 2232df8bae1dSRodney W. Grimes * requirement that zero be placed in the timestamp 2233df8bae1dSRodney W. Grimes * echo reply when ts_recent isn't valid. The 2234df8bae1dSRodney W. Grimes * age isn't reset until we get a valid ts_recent 2235df8bae1dSRodney W. Grimes * because we don't want out-of-order segments to be 2236df8bae1dSRodney W. Grimes * dropped when ts_recent is old. 2237df8bae1dSRodney W. Grimes */ 2238df8bae1dSRodney W. Grimes tp->ts_recent = 0; 2239df8bae1dSRodney W. Grimes } else { 224078b50714SRobert Watson TCPSTAT_INC(tcps_rcvduppack); 224178b50714SRobert Watson TCPSTAT_ADD(tcps_rcvdupbyte, tlen); 224278b50714SRobert Watson TCPSTAT_INC(tcps_pawsdrop); 224307fd333dSMatthew Dillon if (tlen) 2244df8bae1dSRodney W. Grimes goto dropafterack; 22451ab4789dSMatthew Dillon goto drop; 22461ab4789dSMatthew Dillon } 2247df8bae1dSRodney W. Grimes } 2248df8bae1dSRodney W. Grimes 2249a0292f23SGarrett Wollman /* 225080ab7c0eSGarrett Wollman * In the SYN-RECEIVED state, validate that the packet belongs to 225180ab7c0eSGarrett Wollman * this connection before trimming the data to fit the receive 225280ab7c0eSGarrett Wollman * window. Check the sequence number versus IRS since we know 225380ab7c0eSGarrett Wollman * the sequence numbers haven't wrapped. This is a partial fix 225480ab7c0eSGarrett Wollman * for the "LAND" DoS attack. 225580ab7c0eSGarrett Wollman */ 2256a57815efSBosko Milekic if (tp->t_state == TCPS_SYN_RECEIVED && SEQ_LT(th->th_seq, tp->irs)) { 2257a57815efSBosko Milekic rstreason = BANDLIM_RST_OPENPORT; 2258a57815efSBosko Milekic goto dropwithreset; 2259a57815efSBosko Milekic } 226080ab7c0eSGarrett Wollman 2261fb59c426SYoshinobu Inoue todrop = tp->rcv_nxt - th->th_seq; 2262df8bae1dSRodney W. Grimes if (todrop > 0) { 2263831ad37eSXin LI if (thflags & TH_SYN) { 2264fb59c426SYoshinobu Inoue thflags &= ~TH_SYN; 2265fb59c426SYoshinobu Inoue th->th_seq++; 2266fb59c426SYoshinobu Inoue if (th->th_urp > 1) 2267fb59c426SYoshinobu Inoue th->th_urp--; 2268df8bae1dSRodney W. Grimes else 2269fb59c426SYoshinobu Inoue thflags &= ~TH_URG; 2270df8bae1dSRodney W. Grimes todrop--; 2271df8bae1dSRodney W. Grimes } 2272df8bae1dSRodney W. Grimes /* 2273dac20301SGarrett Wollman * Following if statement from Stevens, vol. 2, p. 960. 2274df8bae1dSRodney W. Grimes */ 2275fb59c426SYoshinobu Inoue if (todrop > tlen 2276fb59c426SYoshinobu Inoue || (todrop == tlen && (thflags & TH_FIN) == 0)) { 2277dac20301SGarrett Wollman /* 2278dac20301SGarrett Wollman * Any valid FIN must be to the left of the window. 2279dac20301SGarrett Wollman * At this point the FIN must be a duplicate or out 2280dac20301SGarrett Wollman * of sequence; drop it. 2281dac20301SGarrett Wollman */ 2282fb59c426SYoshinobu Inoue thflags &= ~TH_FIN; 2283dac20301SGarrett Wollman 2284df8bae1dSRodney W. Grimes /* 2285dac20301SGarrett Wollman * Send an ACK to resynchronize and drop any data. 2286dac20301SGarrett Wollman * But keep on processing for RST or ACK. 2287df8bae1dSRodney W. Grimes */ 2288dac20301SGarrett Wollman tp->t_flags |= TF_ACKNOW; 2289fb59c426SYoshinobu Inoue todrop = tlen; 229078b50714SRobert Watson TCPSTAT_INC(tcps_rcvduppack); 229178b50714SRobert Watson TCPSTAT_ADD(tcps_rcvdupbyte, todrop); 2292df8bae1dSRodney W. Grimes } else { 229378b50714SRobert Watson TCPSTAT_INC(tcps_rcvpartduppack); 229478b50714SRobert Watson TCPSTAT_ADD(tcps_rcvpartdupbyte, todrop); 2295df8bae1dSRodney W. Grimes } 22965acfd95cSMichael Tuexen /* 22975acfd95cSMichael Tuexen * DSACK - add SACK block for dropped range 22985acfd95cSMichael Tuexen */ 22998f63a52bSMichael Tuexen if ((todrop > 0) && (tp->t_flags & TF_SACK_PERMIT)) { 2300ecc5b1d1SMichael Tuexen tcp_update_sack_list(tp, th->th_seq, 2301ecc5b1d1SMichael Tuexen th->th_seq + todrop); 23025acfd95cSMichael Tuexen /* 23035acfd95cSMichael Tuexen * ACK now, as the next in-sequence segment 23045acfd95cSMichael Tuexen * will clear the DSACK block again 23055acfd95cSMichael Tuexen */ 23065acfd95cSMichael Tuexen tp->t_flags |= TF_ACKNOW; 23075acfd95cSMichael Tuexen } 2308fb59c426SYoshinobu Inoue drop_hdrlen += todrop; /* drop from the top afterwards */ 2309fb59c426SYoshinobu Inoue th->th_seq += todrop; 2310fb59c426SYoshinobu Inoue tlen -= todrop; 2311fb59c426SYoshinobu Inoue if (th->th_urp > todrop) 2312fb59c426SYoshinobu Inoue th->th_urp -= todrop; 2313df8bae1dSRodney W. Grimes else { 2314fb59c426SYoshinobu Inoue thflags &= ~TH_URG; 2315fb59c426SYoshinobu Inoue th->th_urp = 0; 2316df8bae1dSRodney W. Grimes } 2317df8bae1dSRodney W. Grimes } 2318df8bae1dSRodney W. Grimes 2319df8bae1dSRodney W. Grimes /* 2320df8bae1dSRodney W. Grimes * If new data are received on a connection after the 2321df8bae1dSRodney W. Grimes * user processes are gone, then RST the other end. 2322df8bae1dSRodney W. Grimes */ 2323df8bae1dSRodney W. Grimes if ((so->so_state & SS_NOFDREF) && 2324fb59c426SYoshinobu Inoue tp->t_state > TCPS_CLOSE_WAIT && tlen) { 232507dacf03SAndre Oppermann if ((s = tcp_log_addrs(inc, th, NULL, NULL))) { 232607dacf03SAndre Oppermann log(LOG_DEBUG, "%s; %s: %s: Received %d bytes of data " 232707dacf03SAndre Oppermann "after socket was closed, " 232807dacf03SAndre Oppermann "sending RST and removing tcpcb\n", 2329e31d8aa3SMike Silbersack s, __func__, tcpstates[tp->t_state], tlen); 2330773673c1SAndre Oppermann free(s, M_TCPLOG); 2331773673c1SAndre Oppermann } 2332df8bae1dSRodney W. Grimes tp = tcp_close(tp); 233378b50714SRobert Watson TCPSTAT_INC(tcps_rcvafterclose); 2334a57815efSBosko Milekic rstreason = BANDLIM_UNLIMITED; 2335df8bae1dSRodney W. Grimes goto dropwithreset; 2336df8bae1dSRodney W. Grimes } 2337df8bae1dSRodney W. Grimes 2338df8bae1dSRodney W. Grimes /* 2339df8bae1dSRodney W. Grimes * If segment ends after window, drop trailing data 2340df8bae1dSRodney W. Grimes * (and PUSH and FIN); if nothing left, just ACK. 2341df8bae1dSRodney W. Grimes */ 2342fb59c426SYoshinobu Inoue todrop = (th->th_seq + tlen) - (tp->rcv_nxt + tp->rcv_wnd); 2343df8bae1dSRodney W. Grimes if (todrop > 0) { 234478b50714SRobert Watson TCPSTAT_INC(tcps_rcvpackafterwin); 2345fb59c426SYoshinobu Inoue if (todrop >= tlen) { 234678b50714SRobert Watson TCPSTAT_ADD(tcps_rcvbyteafterwin, tlen); 2347df8bae1dSRodney W. Grimes /* 2348df8bae1dSRodney W. Grimes * If window is closed can only take segments at 2349df8bae1dSRodney W. Grimes * window edge, and have to drop data and PUSH from 2350df8bae1dSRodney W. Grimes * incoming segments. Continue processing, but 2351df8bae1dSRodney W. Grimes * remember to ack. Otherwise, drop segment 2352df8bae1dSRodney W. Grimes * and ack. 2353df8bae1dSRodney W. Grimes */ 2354fb59c426SYoshinobu Inoue if (tp->rcv_wnd == 0 && th->th_seq == tp->rcv_nxt) { 2355df8bae1dSRodney W. Grimes tp->t_flags |= TF_ACKNOW; 235678b50714SRobert Watson TCPSTAT_INC(tcps_rcvwinprobe); 2357df8bae1dSRodney W. Grimes } else 2358df8bae1dSRodney W. Grimes goto dropafterack; 2359df8bae1dSRodney W. Grimes } else 236078b50714SRobert Watson TCPSTAT_ADD(tcps_rcvbyteafterwin, todrop); 2361df8bae1dSRodney W. Grimes m_adj(m, -todrop); 2362fb59c426SYoshinobu Inoue tlen -= todrop; 2363fb59c426SYoshinobu Inoue thflags &= ~(TH_PUSH|TH_FIN); 2364df8bae1dSRodney W. Grimes } 2365df8bae1dSRodney W. Grimes 2366df8bae1dSRodney W. Grimes /* 2367df8bae1dSRodney W. Grimes * If last ACK falls within this segment's sequence numbers, 2368df8bae1dSRodney W. Grimes * record its timestamp. 2369cf09195bSPaul Saab * NOTE: 2370cf09195bSPaul Saab * 1) That the test incorporates suggestions from the latest 2371a0292f23SGarrett Wollman * proposal of the tcplw@cray.com list (Braden 1993/04/26). 2372cf09195bSPaul Saab * 2) That updating only on newer timestamps interferes with 2373cf09195bSPaul Saab * our earlier PAWS tests, so this check should be solely 2374cf09195bSPaul Saab * predicated on the sequence space of this segment. 2375cf09195bSPaul Saab * 3) That we modify the segment boundary check to be 2376cf09195bSPaul Saab * Last.ACK.Sent <= SEG.SEQ + SEG.Len 2377cf09195bSPaul Saab * instead of RFC1323's 2378cf09195bSPaul Saab * Last.ACK.Sent < SEG.SEQ + SEG.Len, 2379cf09195bSPaul Saab * This modified check allows us to overcome RFC1323's 2380cf09195bSPaul Saab * limitations as described in Stevens TCP/IP Illustrated 2381cf09195bSPaul Saab * Vol. 2 p.869. In such cases, we can still calculate the 2382cf09195bSPaul Saab * RTT correctly when RCV.NXT == Last.ACK.Sent. 2383df8bae1dSRodney W. Grimes */ 2384be2ac88cSJonathan Lemon if ((to.to_flags & TOF_TS) != 0 && 2385cf09195bSPaul Saab SEQ_LEQ(th->th_seq, tp->last_ack_sent) && 2386cf09195bSPaul Saab SEQ_LEQ(tp->last_ack_sent, th->th_seq + tlen + 2387cf09195bSPaul Saab ((thflags & (TH_SYN|TH_FIN)) != 0))) { 2388d8951c8aSBjoern A. Zeeb tp->ts_recent_age = tcp_ts_getticks(); 2389a0292f23SGarrett Wollman tp->ts_recent = to.to_tsval; 2390df8bae1dSRodney W. Grimes } 2391df8bae1dSRodney W. Grimes 2392df8bae1dSRodney W. Grimes /* 2393a0292f23SGarrett Wollman * If the ACK bit is off: if in SYN-RECEIVED state or SENDSYN 2394a0292f23SGarrett Wollman * flag is on (half-synchronized state), then queue data for 2395a0292f23SGarrett Wollman * later processing; else drop segment and return. 2396a0292f23SGarrett Wollman */ 2397fb59c426SYoshinobu Inoue if ((thflags & TH_ACK) == 0) { 2398a0292f23SGarrett Wollman if (tp->t_state == TCPS_SYN_RECEIVED || 2399281a0fd4SPatrick Kelsey (tp->t_flags & TF_NEEDSYN)) { 2400281a0fd4SPatrick Kelsey if (tp->t_state == TCPS_SYN_RECEIVED && 240168bd7ed1SJonathan T. Looney IS_FASTOPEN(tp->t_flags)) { 2402281a0fd4SPatrick Kelsey tp->snd_wnd = tiwin; 2403281a0fd4SPatrick Kelsey cc_conn_init(tp); 2404281a0fd4SPatrick Kelsey } 2405a0292f23SGarrett Wollman goto step6; 2406281a0fd4SPatrick Kelsey } else if (tp->t_flags & TF_ACKNOW) 24075e1aa279SDavid Malone goto dropafterack; 2408a0292f23SGarrett Wollman else 2409a0292f23SGarrett Wollman goto drop; 2410a0292f23SGarrett Wollman } 2411df8bae1dSRodney W. Grimes 2412df8bae1dSRodney W. Grimes /* 2413df8bae1dSRodney W. Grimes * Ack processing. 2414df8bae1dSRodney W. Grimes */ 2415df8bae1dSRodney W. Grimes switch (tp->t_state) { 2416df8bae1dSRodney W. Grimes /* 2417764d8cefSBill Fenner * In SYN_RECEIVED state, the ack ACKs our SYN, so enter 2418764d8cefSBill Fenner * ESTABLISHED state and continue processing. 2419764d8cefSBill Fenner * The ACK was checked above. 2420df8bae1dSRodney W. Grimes */ 2421df8bae1dSRodney W. Grimes case TCPS_SYN_RECEIVED: 2422a0292f23SGarrett Wollman 242378b50714SRobert Watson TCPSTAT_INC(tcps_connects); 2424df8bae1dSRodney W. Grimes soisconnected(so); 2425df8bae1dSRodney W. Grimes /* Do window scaling? */ 2426df8bae1dSRodney W. Grimes if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) == 2427df8bae1dSRodney W. Grimes (TF_RCVD_SCALE|TF_REQ_SCALE)) { 2428df8bae1dSRodney W. Grimes tp->rcv_scale = tp->request_r_scale; 2429df8bae1dSRodney W. Grimes } 2430116ef4d6SMichael Tuexen tp->snd_wnd = tiwin; 2431a0292f23SGarrett Wollman /* 2432a0292f23SGarrett Wollman * Make transitions: 2433a0292f23SGarrett Wollman * SYN-RECEIVED -> ESTABLISHED 2434a0292f23SGarrett Wollman * SYN-RECEIVED* -> FIN-WAIT-1 2435a0292f23SGarrett Wollman */ 24369b8b58e0SJonathan Lemon tp->t_starttime = ticks; 243718a75309SPatrick Kelsey if (IS_FASTOPEN(tp->t_flags) && tp->t_tfo_pending) { 2438281a0fd4SPatrick Kelsey tcp_fastopen_decrement_counter(tp->t_tfo_pending); 2439281a0fd4SPatrick Kelsey tp->t_tfo_pending = NULL; 2440281a0fd4SPatrick Kelsey } 24418db239dcSMichael Tuexen if (tp->t_flags & TF_NEEDFIN) { 24428db239dcSMichael Tuexen tcp_state_change(tp, TCPS_FIN_WAIT_1); 24438db239dcSMichael Tuexen tp->t_flags &= ~TF_NEEDFIN; 24448db239dcSMichael Tuexen } else { 24458db239dcSMichael Tuexen tcp_state_change(tp, TCPS_ESTABLISHED); 24468db239dcSMichael Tuexen TCP_PROBE5(accept__established, NULL, tp, 24478db239dcSMichael Tuexen m, tp, th); 2448281a0fd4SPatrick Kelsey /* 2449281a0fd4SPatrick Kelsey * TFO connections call cc_conn_init() during SYN 2450281a0fd4SPatrick Kelsey * processing. Calling it again here for such 2451281a0fd4SPatrick Kelsey * connections is not harmless as it would undo the 2452281a0fd4SPatrick Kelsey * snd_cwnd reduction that occurs when a TFO SYN|ACK 2453281a0fd4SPatrick Kelsey * is retransmitted. 2454281a0fd4SPatrick Kelsey */ 245568bd7ed1SJonathan T. Looney if (!IS_FASTOPEN(tp->t_flags)) 2456dbc42409SLawrence Stewart cc_conn_init(tp); 24579077f387SGleb Smirnoff tcp_timer_activate(tp, TT_KEEP, TP_KEEPIDLE(tp)); 24587ff19458SPaul Traina } 2459a0292f23SGarrett Wollman /* 2460b2ade6b1SRichard Scheffenegger * Account for the ACK of our SYN prior to 2461b2ade6b1SRichard Scheffenegger * regular ACK processing below, except for 2462b2ade6b1SRichard Scheffenegger * simultaneous SYN, which is handled later. 2463b2ade6b1SRichard Scheffenegger */ 2464b2ade6b1SRichard Scheffenegger if (SEQ_GT(th->th_ack, tp->snd_una) && !(tp->t_flags & TF_NEEDSYN)) 2465b2ade6b1SRichard Scheffenegger incforsyn = 1; 2466b2ade6b1SRichard Scheffenegger /* 2467a0292f23SGarrett Wollman * If segment contains data or ACK, will call tcp_reass() 2468a0292f23SGarrett Wollman * later; if not, do so now to pass queued data to user. 2469a0292f23SGarrett Wollman */ 2470fb59c426SYoshinobu Inoue if (tlen == 0 && (thflags & TH_FIN) == 0) 2471c28440dbSRandall Stewart (void) tcp_reass(tp, (struct tcphdr *)0, NULL, 0, 2472a0292f23SGarrett Wollman (struct mbuf *)0); 247360ee3bb2SAndre Oppermann tp->snd_wl1 = th->th_seq - 1; 247493b0017fSPhilippe Charnier /* FALLTHROUGH */ 2475df8bae1dSRodney W. Grimes 2476df8bae1dSRodney W. Grimes /* 2477df8bae1dSRodney W. Grimes * In ESTABLISHED state: drop duplicate ACKs; ACK out of range 2478df8bae1dSRodney W. Grimes * ACKs. If the ack is in the range 2479fb59c426SYoshinobu Inoue * tp->snd_una < th->th_ack <= tp->snd_max 2480fb59c426SYoshinobu Inoue * then advance tp->snd_una to th->th_ack and drop 2481df8bae1dSRodney W. Grimes * data from the retransmission queue. If this ACK reflects 2482df8bae1dSRodney W. Grimes * more up to date window information we update our window information. 2483df8bae1dSRodney W. Grimes */ 2484df8bae1dSRodney W. Grimes case TCPS_ESTABLISHED: 2485df8bae1dSRodney W. Grimes case TCPS_FIN_WAIT_1: 2486df8bae1dSRodney W. Grimes case TCPS_FIN_WAIT_2: 2487df8bae1dSRodney W. Grimes case TCPS_CLOSE_WAIT: 2488df8bae1dSRodney W. Grimes case TCPS_CLOSING: 2489df8bae1dSRodney W. Grimes case TCPS_LAST_ACK: 24905a53ca16SPaul Saab if (SEQ_GT(th->th_ack, tp->snd_max)) { 249178b50714SRobert Watson TCPSTAT_INC(tcps_rcvacktoomuch); 24925a53ca16SPaul Saab goto dropafterack; 24935a53ca16SPaul Saab } 24943529149eSAndre Oppermann if ((tp->t_flags & TF_SACK_PERMIT) && 2495fc30a251SAndre Oppermann ((to.to_flags & TOF_SACK) || 2496fc30a251SAndre Oppermann !TAILQ_EMPTY(&tp->snd_holes))) 2497021eaf79SHiren Panchasara sack_changed = tcp_sack_doack(tp, &to, th->th_ack); 249812eeb81fSHiren Panchasara else 249912eeb81fSHiren Panchasara /* 250012eeb81fSHiren Panchasara * Reset the value so that previous (valid) value 250112eeb81fSHiren Panchasara * from the last ack with SACK doesn't get used. 250212eeb81fSHiren Panchasara */ 250312eeb81fSHiren Panchasara tp->sackhint.sacked_bytes = 0; 250439bc9de5SLawrence Stewart 2505bd79708dSJonathan T. Looney #ifdef TCP_HHOOK 250639bc9de5SLawrence Stewart /* Run HHOOK_TCP_ESTABLISHED_IN helper hooks. */ 250739bc9de5SLawrence Stewart hhook_run_tcp_est_in(tp, th, &to); 2508bd79708dSJonathan T. Looney #endif 250939bc9de5SLawrence Stewart 2510fb59c426SYoshinobu Inoue if (SEQ_LEQ(th->th_ack, tp->snd_una)) { 25110c39d38dSGleb Smirnoff maxseg = tcp_maxseg(tp); 2512021eaf79SHiren Panchasara if (tlen == 0 && 2513021eaf79SHiren Panchasara (tiwin == tp->snd_wnd || 2514021eaf79SHiren Panchasara (tp->t_flags & TF_SACK_PERMIT))) { 251562b90589SPeter Wemm /* 251662b90589SPeter Wemm * If this is the first time we've seen a 251762b90589SPeter Wemm * FIN from the remote, this is not a 251862b90589SPeter Wemm * duplicate and it needs to be processed 251962b90589SPeter Wemm * normally. This happens during a 252062b90589SPeter Wemm * simultaneous close. 252162b90589SPeter Wemm */ 252262b90589SPeter Wemm if ((thflags & TH_FIN) && 252362b90589SPeter Wemm (TCPS_HAVERCVDFIN(tp->t_state) == 0)) { 252462b90589SPeter Wemm tp->t_dupacks = 0; 252562b90589SPeter Wemm break; 252662b90589SPeter Wemm } 252778b50714SRobert Watson TCPSTAT_INC(tcps_rcvdupack); 2528df8bae1dSRodney W. Grimes /* 2529df8bae1dSRodney W. Grimes * If we have outstanding data (other than 2530df8bae1dSRodney W. Grimes * a window probe), this is a completely 2531df8bae1dSRodney W. Grimes * duplicate ack (ie, window info didn't 25325f30ec9bSEitan Adler * change and FIN isn't set), 25335f30ec9bSEitan Adler * the ack is the biggest we've 2534df8bae1dSRodney W. Grimes * seen and we've seen exactly our rexmt 2535a4641f4eSPedro F. Giffuni * threshold of them, assume a packet 2536df8bae1dSRodney W. Grimes * has been dropped and retransmit it. 2537df8bae1dSRodney W. Grimes * Kludge snd_nxt & the congestion 2538df8bae1dSRodney W. Grimes * window so we send only this one 2539df8bae1dSRodney W. Grimes * packet. 2540df8bae1dSRodney W. Grimes * 2541df8bae1dSRodney W. Grimes * We know we're losing at the current 2542df8bae1dSRodney W. Grimes * window size so do congestion avoidance 2543df8bae1dSRodney W. Grimes * (set ssthresh to half the current window 2544df8bae1dSRodney W. Grimes * and pull our congestion window back to 2545df8bae1dSRodney W. Grimes * the new ssthresh). 2546df8bae1dSRodney W. Grimes * 2547df8bae1dSRodney W. Grimes * Dup acks mean that packets have left the 2548df8bae1dSRodney W. Grimes * network (they're now cached at the receiver) 2549df8bae1dSRodney W. Grimes * so bump cwnd by the amount in the receiver 2550df8bae1dSRodney W. Grimes * to keep a constant cwnd packets in the 2551df8bae1dSRodney W. Grimes * network. 2552f2512ba1SRui Paulo * 2553f2512ba1SRui Paulo * When using TCP ECN, notify the peer that 2554f2512ba1SRui Paulo * we reduced the cwnd. 2555df8bae1dSRodney W. Grimes */ 2556021eaf79SHiren Panchasara /* 2557021eaf79SHiren Panchasara * Following 2 kinds of acks should not affect 2558021eaf79SHiren Panchasara * dupack counting: 2559021eaf79SHiren Panchasara * 1) Old acks 2560021eaf79SHiren Panchasara * 2) Acks with SACK but without any new SACK 2561021eaf79SHiren Panchasara * information in them. These could result from 2562021eaf79SHiren Panchasara * any anomaly in the network like a switch 2563021eaf79SHiren Panchasara * duplicating packets or a possible DoS attack. 2564021eaf79SHiren Panchasara */ 2565021eaf79SHiren Panchasara if (th->th_ack != tp->snd_una || 2566021eaf79SHiren Panchasara ((tp->t_flags & TF_SACK_PERMIT) && 25670533fab8SRichard Scheffenegger (to.to_flags & TOF_SACK) && 2568021eaf79SHiren Panchasara !sack_changed)) 2569021eaf79SHiren Panchasara break; 2570021eaf79SHiren Panchasara else if (!tcp_timer_active(tp, TT_REXMT)) 2571df8bae1dSRodney W. Grimes tp->t_dupacks = 0; 2572cb942153SJeffrey Hsu else if (++tp->t_dupacks > tcprexmtthresh || 2573dbc42409SLawrence Stewart IN_FASTRECOVERY(tp->t_flags)) { 25744b7b743cSLawrence Stewart cc_ack_received(tp, th, nsegs, 25754b7b743cSLawrence Stewart CC_DUPACK); 25760e1d7c25SRichard Scheffenegger if (V_tcp_do_prr && 25770e1d7c25SRichard Scheffenegger IN_FASTRECOVERY(tp->t_flags) && 25780e1d7c25SRichard Scheffenegger (tp->t_flags & TF_SACK_PERMIT)) { 2579*eb3a59a8SRichard Scheffenegger tcp_do_prr_ack(tp, th); 25800e1d7c25SRichard Scheffenegger } else if ((tp->t_flags & TF_SACK_PERMIT) && 25810533fab8SRichard Scheffenegger (to.to_flags & TOF_SACK) && 2582dbc42409SLawrence Stewart IN_FASTRECOVERY(tp->t_flags)) { 2583808f11b7SPaul Saab int awnd; 258425e6f9edSPaul Saab 258525e6f9edSPaul Saab /* 258625e6f9edSPaul Saab * Compute the amount of data in flight first. 25874c3972f0SHiren Panchasara * We can inject new data into the pipe iff 258825e6f9edSPaul Saab * we have less than 1/2 the original window's 258925e6f9edSPaul Saab * worth of data in flight. 259025e6f9edSPaul Saab */ 259112eeb81fSHiren Panchasara if (V_tcp_do_rfc6675_pipe) 259212eeb81fSHiren Panchasara awnd = tcp_compute_pipe(tp); 259312eeb81fSHiren Panchasara else 2594808f11b7SPaul Saab awnd = (tp->snd_nxt - tp->snd_fack) + 25950077b016SPaul Saab tp->sackhint.sack_bytes_rexmit; 259612eeb81fSHiren Panchasara 2597808f11b7SPaul Saab if (awnd < tp->snd_ssthresh) { 25980c39d38dSGleb Smirnoff tp->snd_cwnd += maxseg; 259925e6f9edSPaul Saab if (tp->snd_cwnd > tp->snd_ssthresh) 260025e6f9edSPaul Saab tp->snd_cwnd = tp->snd_ssthresh; 260125e6f9edSPaul Saab } 260225e6f9edSPaul Saab } else 26030c39d38dSGleb Smirnoff tp->snd_cwnd += maxseg; 260455bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 260546f58482SJonathan Lemon goto drop; 26063c40e1d5SRichard Scheffenegger } else if (tp->t_dupacks == tcprexmtthresh || 26073c40e1d5SRichard Scheffenegger (tp->t_flags & TF_SACK_PERMIT && 26083c40e1d5SRichard Scheffenegger V_tcp_do_rfc6675_pipe && 26093c40e1d5SRichard Scheffenegger tp->sackhint.sacked_bytes > 26103c40e1d5SRichard Scheffenegger (tcprexmtthresh - 1) * maxseg)) { 26113c40e1d5SRichard Scheffenegger enter_recovery: 26123c40e1d5SRichard Scheffenegger /* 26133c40e1d5SRichard Scheffenegger * Above is the RFC6675 trigger condition of 26143c40e1d5SRichard Scheffenegger * more than (dupthresh-1)*maxseg sacked data. 26153c40e1d5SRichard Scheffenegger * If the count of holes in the 26163c40e1d5SRichard Scheffenegger * scoreboard is >= dupthresh, we could 26173c40e1d5SRichard Scheffenegger * also enter loss recovery, but don't 26183c40e1d5SRichard Scheffenegger * have that value readily available. 26193c40e1d5SRichard Scheffenegger */ 26203c40e1d5SRichard Scheffenegger tp->t_dupacks = tcprexmtthresh; 2621cb942153SJeffrey Hsu tcp_seq onxt = tp->snd_nxt; 2622a0445c2eSJayanth Vijayaraghavan 2623a0445c2eSJayanth Vijayaraghavan /* 26240e1d7c25SRichard Scheffenegger * If we're doing sack, or prr, check 26250e1d7c25SRichard Scheffenegger * to see if we're already in sack 2626a0445c2eSJayanth Vijayaraghavan * recovery. If we're not doing sack, 2627a0445c2eSJayanth Vijayaraghavan * check to see if we're in newreno 2628a0445c2eSJayanth Vijayaraghavan * recovery. 2629a0445c2eSJayanth Vijayaraghavan */ 26300e1d7c25SRichard Scheffenegger if (V_tcp_do_prr || 26310e1d7c25SRichard Scheffenegger (tp->t_flags & TF_SACK_PERMIT)) { 2632dbc42409SLawrence Stewart if (IN_FASTRECOVERY(tp->t_flags)) { 2633a0445c2eSJayanth Vijayaraghavan tp->t_dupacks = 0; 2634a0445c2eSJayanth Vijayaraghavan break; 2635a0445c2eSJayanth Vijayaraghavan } 2636dbc42409SLawrence Stewart } else { 2637a0445c2eSJayanth Vijayaraghavan if (SEQ_LEQ(th->th_ack, 26389d11646dSJeffrey Hsu tp->snd_recover)) { 2639cb942153SJeffrey Hsu tp->t_dupacks = 0; 2640cb942153SJeffrey Hsu break; 264146f58482SJonathan Lemon } 2642a0445c2eSJayanth Vijayaraghavan } 2643dbc42409SLawrence Stewart /* Congestion signal before ack. */ 2644dbc42409SLawrence Stewart cc_cong_signal(tp, th, CC_NDUPACK); 26454b7b743cSLawrence Stewart cc_ack_received(tp, th, nsegs, 26464b7b743cSLawrence Stewart CC_DUPACK); 2647b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 0); 26489b8b58e0SJonathan Lemon tp->t_rtttime = 0; 26490e1d7c25SRichard Scheffenegger if (V_tcp_do_prr) { 26500e1d7c25SRichard Scheffenegger /* 26510e1d7c25SRichard Scheffenegger * snd_ssthresh is already updated by 26520e1d7c25SRichard Scheffenegger * cc_cong_signal. 26530e1d7c25SRichard Scheffenegger */ 2654e9071000SRichard Scheffenegger tp->sackhint.prr_delivered = 2655e9071000SRichard Scheffenegger tp->sackhint.sacked_bytes; 2656bc7ee8e5SRichard Scheffenegger tp->sackhint.recover_fs = max(1, 2657bc7ee8e5SRichard Scheffenegger tp->snd_nxt - tp->snd_una); 26580e1d7c25SRichard Scheffenegger } 26590533fab8SRichard Scheffenegger if ((tp->t_flags & TF_SACK_PERMIT) && 26600533fab8SRichard Scheffenegger (to.to_flags & TOF_SACK)) { 266178b50714SRobert Watson TCPSTAT_INC( 266278b50714SRobert Watson tcps_sack_recovery_episode); 2663a3574665SMichael Tuexen tp->snd_recover = tp->snd_nxt; 26640c39d38dSGleb Smirnoff tp->snd_cwnd = maxseg; 266555bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 26663c40e1d5SRichard Scheffenegger if (SEQ_GT(th->th_ack, tp->snd_una)) 26673c40e1d5SRichard Scheffenegger goto resume_partialack; 26686d90faf3SPaul Saab goto drop; 26696d90faf3SPaul Saab } 2670fb59c426SYoshinobu Inoue tp->snd_nxt = th->th_ack; 26710c39d38dSGleb Smirnoff tp->snd_cwnd = maxseg; 267255bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 267348d2549cSJeffrey Hsu KASSERT(tp->snd_limited <= 2, 2674302ce8d6SAndre Oppermann ("%s: tp->snd_limited too big", 2675302ce8d6SAndre Oppermann __func__)); 2676df8bae1dSRodney W. Grimes tp->snd_cwnd = tp->snd_ssthresh + 26770c39d38dSGleb Smirnoff maxseg * 267848d2549cSJeffrey Hsu (tp->t_dupacks - tp->snd_limited); 2679df8bae1dSRodney W. Grimes if (SEQ_GT(onxt, tp->snd_nxt)) 2680df8bae1dSRodney W. Grimes tp->snd_nxt = onxt; 2681df8bae1dSRodney W. Grimes goto drop; 2682603724d3SBjoern A. Zeeb } else if (V_tcp_do_rfc3042) { 268362d4443fSHiren Panchasara /* 268462d4443fSHiren Panchasara * Process first and second duplicate 268562d4443fSHiren Panchasara * ACKs. Each indicates a segment 268662d4443fSHiren Panchasara * leaving the network, creating room 268762d4443fSHiren Panchasara * for more. Make sure we can send a 268862d4443fSHiren Panchasara * packet on reception of each duplicate 268962d4443fSHiren Panchasara * ACK by increasing snd_cwnd by one 269062d4443fSHiren Panchasara * segment. Restore the original 269162d4443fSHiren Panchasara * snd_cwnd after packet transmission. 269262d4443fSHiren Panchasara */ 26934b7b743cSLawrence Stewart cc_ack_received(tp, th, nsegs, 26944b7b743cSLawrence Stewart CC_DUPACK); 26953ac12506SJonathan T. Looney uint32_t oldcwnd = tp->snd_cwnd; 269648d2549cSJeffrey Hsu tcp_seq oldsndmax = tp->snd_max; 269748d2549cSJeffrey Hsu u_int sent; 26985628dd08SAndre Oppermann int avail; 269989c02376SJeffrey Hsu 2700582a954bSJeffrey Hsu KASSERT(tp->t_dupacks == 1 || 2701582a954bSJeffrey Hsu tp->t_dupacks == 2, 2702302ce8d6SAndre Oppermann ("%s: dupacks not 1 or 2", 2703302ce8d6SAndre Oppermann __func__)); 270461a36e3dSJeffrey Hsu if (tp->t_dupacks == 1) 270548d2549cSJeffrey Hsu tp->snd_limited = 0; 270661a36e3dSJeffrey Hsu tp->snd_cwnd = 270761a36e3dSJeffrey Hsu (tp->snd_nxt - tp->snd_una) + 270861a36e3dSJeffrey Hsu (tp->t_dupacks - tp->snd_limited) * 27090c39d38dSGleb Smirnoff maxseg; 27105628dd08SAndre Oppermann /* 27115628dd08SAndre Oppermann * Only call tcp_output when there 27125628dd08SAndre Oppermann * is new data available to be sent. 27135628dd08SAndre Oppermann * Otherwise we would send pure ACKs. 27145628dd08SAndre Oppermann */ 27155628dd08SAndre Oppermann SOCKBUF_LOCK(&so->so_snd); 2716cfa6009eSGleb Smirnoff avail = sbavail(&so->so_snd) - 27175628dd08SAndre Oppermann (tp->snd_nxt - tp->snd_una); 27185628dd08SAndre Oppermann SOCKBUF_UNLOCK(&so->so_snd); 27195628dd08SAndre Oppermann if (avail > 0) 272055bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 272148d2549cSJeffrey Hsu sent = tp->snd_max - oldsndmax; 27220c39d38dSGleb Smirnoff if (sent > maxseg) { 272389c02376SJeffrey Hsu KASSERT((tp->t_dupacks == 2 && 272489c02376SJeffrey Hsu tp->snd_limited == 0) || 27250c39d38dSGleb Smirnoff (sent == maxseg + 1 && 272689c02376SJeffrey Hsu tp->t_flags & TF_SENTFIN), 2727302ce8d6SAndre Oppermann ("%s: sent too much", 2728302ce8d6SAndre Oppermann __func__)); 272948d2549cSJeffrey Hsu tp->snd_limited = 2; 273048d2549cSJeffrey Hsu } else if (sent > 0) 273148d2549cSJeffrey Hsu ++tp->snd_limited; 2732582a954bSJeffrey Hsu tp->snd_cwnd = oldcwnd; 2733582a954bSJeffrey Hsu goto drop; 2734df8bae1dSRodney W. Grimes } 2735021eaf79SHiren Panchasara } 2736df8bae1dSRodney W. Grimes break; 2737021eaf79SHiren Panchasara } else { 2738021eaf79SHiren Panchasara /* 2739021eaf79SHiren Panchasara * This ack is advancing the left edge, reset the 2740021eaf79SHiren Panchasara * counter. 2741021eaf79SHiren Panchasara */ 2742021eaf79SHiren Panchasara tp->t_dupacks = 0; 2743021eaf79SHiren Panchasara /* 2744021eaf79SHiren Panchasara * If this ack also has new SACK info, increment the 2745f359d6ebSRichard Scheffenegger * counter as per rfc6675. The variable 2746f359d6ebSRichard Scheffenegger * sack_changed tracks all changes to the SACK 2747f359d6ebSRichard Scheffenegger * scoreboard, including when partial ACKs without 2748f359d6ebSRichard Scheffenegger * SACK options are received, and clear the scoreboard 2749f359d6ebSRichard Scheffenegger * from the left side. Such partial ACKs should not be 2750f359d6ebSRichard Scheffenegger * counted as dupacks here. 2751021eaf79SHiren Panchasara */ 2752f359d6ebSRichard Scheffenegger if ((tp->t_flags & TF_SACK_PERMIT) && 2753f359d6ebSRichard Scheffenegger (to.to_flags & TOF_SACK) && 27543c40e1d5SRichard Scheffenegger sack_changed) { 2755021eaf79SHiren Panchasara tp->t_dupacks++; 27563c40e1d5SRichard Scheffenegger /* limit overhead by setting maxseg last */ 27573c40e1d5SRichard Scheffenegger if (!IN_FASTRECOVERY(tp->t_flags) && 27583c40e1d5SRichard Scheffenegger (tp->sackhint.sacked_bytes > 27593c40e1d5SRichard Scheffenegger ((tcprexmtthresh - 1) * 27603c40e1d5SRichard Scheffenegger (maxseg = tcp_maxseg(tp))))) { 27613c40e1d5SRichard Scheffenegger goto enter_recovery; 27623c40e1d5SRichard Scheffenegger } 27633c40e1d5SRichard Scheffenegger } 2764df8bae1dSRodney W. Grimes } 2765cb942153SJeffrey Hsu 27663c40e1d5SRichard Scheffenegger resume_partialack: 2767302ce8d6SAndre Oppermann KASSERT(SEQ_GT(th->th_ack, tp->snd_una), 2768302ce8d6SAndre Oppermann ("%s: th_ack <= snd_una", __func__)); 2769cb942153SJeffrey Hsu 2770df8bae1dSRodney W. Grimes /* 2771df8bae1dSRodney W. Grimes * If the congestion window was inflated to account 2772df8bae1dSRodney W. Grimes * for the other side's cached packets, retract it. 2773df8bae1dSRodney W. Grimes */ 2774dbc42409SLawrence Stewart if (IN_FASTRECOVERY(tp->t_flags)) { 2775cb942153SJeffrey Hsu if (SEQ_LT(th->th_ack, tp->snd_recover)) { 27763529149eSAndre Oppermann if (tp->t_flags & TF_SACK_PERMIT) 2777*eb3a59a8SRichard Scheffenegger if (V_tcp_do_prr && to.to_flags & TOF_SACK) { 2778*eb3a59a8SRichard Scheffenegger tcp_timer_activate(tp, TT_REXMT, 0); 2779*eb3a59a8SRichard Scheffenegger tp->t_rtttime = 0; 2780*eb3a59a8SRichard Scheffenegger tcp_do_prr_ack(tp, th); 2781*eb3a59a8SRichard Scheffenegger tp->t_flags |= TF_ACKNOW; 2782*eb3a59a8SRichard Scheffenegger (void) tcp_output(tp); 2783*eb3a59a8SRichard Scheffenegger } else 27846d90faf3SPaul Saab tcp_sack_partialack(tp, th); 27856d90faf3SPaul Saab else 2786c068736aSJeffrey Hsu tcp_newreno_partial_ack(tp, th); 2787dbc42409SLawrence Stewart } else 2788dbc42409SLawrence Stewart cc_post_recovery(tp, th); 278946f58482SJonathan Lemon } 2790a0292f23SGarrett Wollman /* 2791a0292f23SGarrett Wollman * If we reach this point, ACK is not a duplicate, 2792a0292f23SGarrett Wollman * i.e., it ACKs something we sent. 2793a0292f23SGarrett Wollman */ 2794a0292f23SGarrett Wollman if (tp->t_flags & TF_NEEDSYN) { 2795a0292f23SGarrett Wollman /* 2796a0292f23SGarrett Wollman * T/TCP: Connection was half-synchronized, and our 2797a0292f23SGarrett Wollman * SYN has been ACK'd (so connection is now fully 279807e43e10SAndras Olah * synchronized). Go to non-starred state, 279907e43e10SAndras Olah * increment snd_una for ACK of SYN, and check if 280007e43e10SAndras Olah * we can do window scaling. 2801a0292f23SGarrett Wollman */ 2802a0292f23SGarrett Wollman tp->t_flags &= ~TF_NEEDSYN; 2803a0292f23SGarrett Wollman tp->snd_una++; 280407e43e10SAndras Olah /* Do window scaling? */ 280507e43e10SAndras Olah if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) == 280607e43e10SAndras Olah (TF_RCVD_SCALE|TF_REQ_SCALE)) { 280707e43e10SAndras Olah tp->rcv_scale = tp->request_r_scale; 2808464fcfbcSAndre Oppermann /* Send window already scaled. */ 280907e43e10SAndras Olah } 2810a0292f23SGarrett Wollman } 2811a0292f23SGarrett Wollman 2812a0292f23SGarrett Wollman process_ACK: 28138501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 28147cfc6904SRobert Watson 2815b2ade6b1SRichard Scheffenegger /* 2816b2ade6b1SRichard Scheffenegger * Adjust for the SYN bit in sequence space, 2817b2ade6b1SRichard Scheffenegger * but don't account for it in cwnd calculations. 2818b2ade6b1SRichard Scheffenegger * This is for the SYN_RECEIVED, non-simultaneous 2819b2ade6b1SRichard Scheffenegger * SYN case. SYN_SENT and simultaneous SYN are 2820b2ade6b1SRichard Scheffenegger * treated elsewhere. 2821b2ade6b1SRichard Scheffenegger */ 2822b2ade6b1SRichard Scheffenegger if (incforsyn) 2823b2ade6b1SRichard Scheffenegger tp->snd_una++; 2824dbc42409SLawrence Stewart acked = BYTES_THIS_ACK(tp, th); 2825b8c2cd15SJonathan T. Looney KASSERT(acked >= 0, ("%s: acked unexepectedly negative " 2826b8c2cd15SJonathan T. Looney "(tp->snd_una=%u, th->th_ack=%u, tp=%p, m=%p)", __func__, 2827b8c2cd15SJonathan T. Looney tp->snd_una, th->th_ack, tp, m)); 28284b7b743cSLawrence Stewart TCPSTAT_ADD(tcps_rcvackpack, nsegs); 282978b50714SRobert Watson TCPSTAT_ADD(tcps_rcvackbyte, acked); 2830df8bae1dSRodney W. Grimes 2831df8bae1dSRodney W. Grimes /* 28329b8b58e0SJonathan Lemon * If we just performed our first retransmit, and the ACK 28339b8b58e0SJonathan Lemon * arrives within our recovery window, then it was a mistake 28349b8b58e0SJonathan Lemon * to do the retransmit in the first place. Recover our 28359b8b58e0SJonathan Lemon * original cwnd and ssthresh, and proceed to transmit where 28369b8b58e0SJonathan Lemon * we left off. 28379b8b58e0SJonathan Lemon */ 283810d20c84SMatt Macy if (tp->t_rxtshift == 1 && 283910d20c84SMatt Macy tp->t_flags & TF_PREVVALID && 284010d20c84SMatt Macy tp->t_badrxtwin && 284110d20c84SMatt Macy SEQ_LT(to.to_tsecr, tp->t_badrxtwin)) 2842dbc42409SLawrence Stewart cc_cong_signal(tp, th, CC_RTO_ERR); 28439b8b58e0SJonathan Lemon 28449b8b58e0SJonathan Lemon /* 2845df8bae1dSRodney W. Grimes * If we have a timestamp reply, update smoothed 2846df8bae1dSRodney W. Grimes * round trip time. If no timestamp is present but 2847df8bae1dSRodney W. Grimes * transmit timer is running and timed sequence 2848df8bae1dSRodney W. Grimes * number was acked, update smoothed round trip time. 2849df8bae1dSRodney W. Grimes * Since we now have an rtt measurement, cancel the 2850df8bae1dSRodney W. Grimes * timer backoff (cf., Phil Karn's retransmit alg.). 2851df8bae1dSRodney W. Grimes * Recompute the initial retransmit timer. 2852fa55172bSMatthew Dillon * 2853fa55172bSMatthew Dillon * Some boxes send broken timestamp replies 2854fa55172bSMatthew Dillon * during the SYN+ACK phase, ignore 2855fa55172bSMatthew Dillon * timestamps of 0 or we could calculate a 2856fa55172bSMatthew Dillon * huge RTT and blow up the retransmit timer. 2857df8bae1dSRodney W. Grimes */ 2858d8951c8aSBjoern A. Zeeb if ((to.to_flags & TOF_TS) != 0 && to.to_tsecr) { 28593ac12506SJonathan T. Looney uint32_t t; 2860d8951c8aSBjoern A. Zeeb 2861d8951c8aSBjoern A. Zeeb t = tcp_ts_getticks() - to.to_tsecr; 2862d8951c8aSBjoern A. Zeeb if (!tp->t_rttlow || tp->t_rttlow > t) 2863d8951c8aSBjoern A. Zeeb tp->t_rttlow = t; 2864d8951c8aSBjoern A. Zeeb tcp_xmit_timer(tp, TCP_TS_TO_TICKS(t) + 1); 2865fa55172bSMatthew Dillon } else if (tp->t_rtttime && SEQ_GT(th->th_ack, tp->t_rtseq)) { 2866eaf80179SAndre Oppermann if (!tp->t_rttlow || tp->t_rttlow > ticks - tp->t_rtttime) 2867eaf80179SAndre Oppermann tp->t_rttlow = ticks - tp->t_rtttime; 28689b8b58e0SJonathan Lemon tcp_xmit_timer(tp, ticks - tp->t_rtttime); 2869fa55172bSMatthew Dillon } 2870df8bae1dSRodney W. Grimes 2871df8bae1dSRodney W. Grimes /* 2872df8bae1dSRodney W. Grimes * If all outstanding data is acked, stop retransmit 2873df8bae1dSRodney W. Grimes * timer and remember to restart (more output or persist). 2874df8bae1dSRodney W. Grimes * If there is more data to be acked, restart retransmit 2875df8bae1dSRodney W. Grimes * timer, using current (possibly backed-off) value. 2876df8bae1dSRodney W. Grimes */ 2877fb59c426SYoshinobu Inoue if (th->th_ack == tp->snd_max) { 2878b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 0); 2879df8bae1dSRodney W. Grimes needoutput = 1; 2880b8152ba7SAndre Oppermann } else if (!tcp_timer_active(tp, TT_PERSIST)) 2881b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, tp->t_rxtcur); 2882a0292f23SGarrett Wollman 2883a0292f23SGarrett Wollman /* 2884a0292f23SGarrett Wollman * If no data (only SYN) was ACK'd, 2885a0292f23SGarrett Wollman * skip rest of ACK processing. 2886a0292f23SGarrett Wollman */ 2887a0292f23SGarrett Wollman if (acked == 0) 2888a0292f23SGarrett Wollman goto step6; 2889a0292f23SGarrett Wollman 2890df8bae1dSRodney W. Grimes /* 2891dbc42409SLawrence Stewart * Let the congestion control algorithm update congestion 2892dbc42409SLawrence Stewart * control related information. This typically means increasing 2893dbc42409SLawrence Stewart * the congestion window. 2894df8bae1dSRodney W. Grimes */ 28954b7b743cSLawrence Stewart cc_ack_received(tp, th, nsegs, CC_ACK); 2896dbc42409SLawrence Stewart 28975905999bSRobert Watson SOCKBUF_LOCK(&so->so_snd); 2898cfa6009eSGleb Smirnoff if (acked > sbavail(&so->so_snd)) { 2899b8c2cd15SJonathan T. Looney if (tp->snd_wnd >= sbavail(&so->so_snd)) 2900cfa6009eSGleb Smirnoff tp->snd_wnd -= sbavail(&so->so_snd); 2901b8c2cd15SJonathan T. Looney else 2902b8c2cd15SJonathan T. Looney tp->snd_wnd = 0; 2903c11a15bfSGleb Smirnoff mfree = sbcut_locked(&so->so_snd, 2904cfa6009eSGleb Smirnoff (int)sbavail(&so->so_snd)); 2905df8bae1dSRodney W. Grimes ourfinisacked = 1; 2906df8bae1dSRodney W. Grimes } else { 2907c11a15bfSGleb Smirnoff mfree = sbcut_locked(&so->so_snd, acked); 29083ac12506SJonathan T. Looney if (tp->snd_wnd >= (uint32_t) acked) 290960ee3bb2SAndre Oppermann tp->snd_wnd -= acked; 2910b8c2cd15SJonathan T. Looney else 2911b8c2cd15SJonathan T. Looney tp->snd_wnd = 0; 2912df8bae1dSRodney W. Grimes ourfinisacked = 0; 2913df8bae1dSRodney W. Grimes } 29144d0770f1SRichard Scheffenegger SOCKBUF_UNLOCK(&so->so_snd); 29154d0770f1SRichard Scheffenegger tp->t_flags |= TF_WAKESOW; 2916c11a15bfSGleb Smirnoff m_freem(mfree); 2917e8949f74SAndre Oppermann /* Detect una wraparound. */ 2918dbc42409SLawrence Stewart if (!IN_RECOVERY(tp->t_flags) && 29199d11646dSJeffrey Hsu SEQ_GT(tp->snd_una, tp->snd_recover) && 29209d11646dSJeffrey Hsu SEQ_LEQ(th->th_ack, tp->snd_recover)) 29219d11646dSJeffrey Hsu tp->snd_recover = th->th_ack - 1; 2922dbc42409SLawrence Stewart /* XXXLAS: Can this be moved up into cc_post_recovery? */ 2923dbc42409SLawrence Stewart if (IN_RECOVERY(tp->t_flags) && 292424cb0f22SLawrence Stewart SEQ_GEQ(th->th_ack, tp->snd_recover)) { 2925dbc42409SLawrence Stewart EXIT_RECOVERY(tp->t_flags); 292624cb0f22SLawrence Stewart } 2927fb59c426SYoshinobu Inoue tp->snd_una = th->th_ack; 29283529149eSAndre Oppermann if (tp->t_flags & TF_SACK_PERMIT) { 29296d90faf3SPaul Saab if (SEQ_GT(tp->snd_una, tp->snd_recover)) 29306d90faf3SPaul Saab tp->snd_recover = tp->snd_una; 29316d90faf3SPaul Saab } 2932df8bae1dSRodney W. Grimes if (SEQ_LT(tp->snd_nxt, tp->snd_una)) 2933df8bae1dSRodney W. Grimes tp->snd_nxt = tp->snd_una; 2934df8bae1dSRodney W. Grimes 2935df8bae1dSRodney W. Grimes switch (tp->t_state) { 2936df8bae1dSRodney W. Grimes /* 2937df8bae1dSRodney W. Grimes * In FIN_WAIT_1 STATE in addition to the processing 2938df8bae1dSRodney W. Grimes * for the ESTABLISHED state if our FIN is now acknowledged 2939df8bae1dSRodney W. Grimes * then enter FIN_WAIT_2. 2940df8bae1dSRodney W. Grimes */ 2941df8bae1dSRodney W. Grimes case TCPS_FIN_WAIT_1: 2942df8bae1dSRodney W. Grimes if (ourfinisacked) { 2943df8bae1dSRodney W. Grimes /* 2944df8bae1dSRodney W. Grimes * If we can't receive any more 2945df8bae1dSRodney W. Grimes * data, then closing user can proceed. 2946df8bae1dSRodney W. Grimes * Starting the timer is contrary to the 2947df8bae1dSRodney W. Grimes * specification, but if we don't get a FIN 2948df8bae1dSRodney W. Grimes * we'll hang forever. 2949e8949f74SAndre Oppermann * 2950e8949f74SAndre Oppermann * XXXjl: 2951340c35deSJonathan Lemon * we should release the tp also, and use a 2952340c35deSJonathan Lemon * compressed state. 2953340c35deSJonathan Lemon */ 2954c0b99ffaSRobert Watson if (so->so_rcv.sb_state & SBS_CANTRCVMORE) { 295503e49181SSeigo Tanimura soisdisconnected(so); 29569077f387SGleb Smirnoff tcp_timer_activate(tp, TT_2MSL, 29579077f387SGleb Smirnoff (tcp_fast_finwait2_recycle ? 29589077f387SGleb Smirnoff tcp_finwait2_timeout : 29599077f387SGleb Smirnoff TP_MAXIDLE(tp))); 29604cc20ab1SSeigo Tanimura } 296157f60867SMark Johnston tcp_state_change(tp, TCPS_FIN_WAIT_2); 2962df8bae1dSRodney W. Grimes } 2963df8bae1dSRodney W. Grimes break; 2964df8bae1dSRodney W. Grimes 2965df8bae1dSRodney W. Grimes /* 2966df8bae1dSRodney W. Grimes * In CLOSING STATE in addition to the processing for 2967df8bae1dSRodney W. Grimes * the ESTABLISHED state if the ACK acknowledges our FIN 2968df8bae1dSRodney W. Grimes * then enter the TIME-WAIT state, otherwise ignore 2969df8bae1dSRodney W. Grimes * the segment. 2970df8bae1dSRodney W. Grimes */ 2971df8bae1dSRodney W. Grimes case TCPS_CLOSING: 2972df8bae1dSRodney W. Grimes if (ourfinisacked) { 297311a20fb8SJeffrey Hsu tcp_twstart(tp); 2974340c35deSJonathan Lemon m_freem(m); 2975679d9708SAndre Oppermann return; 2976df8bae1dSRodney W. Grimes } 2977df8bae1dSRodney W. Grimes break; 2978df8bae1dSRodney W. Grimes 2979df8bae1dSRodney W. Grimes /* 2980df8bae1dSRodney W. Grimes * In LAST_ACK, we may still be waiting for data to drain 2981df8bae1dSRodney W. Grimes * and/or to be acked, as well as for the ack of our FIN. 2982df8bae1dSRodney W. Grimes * If our FIN is now acknowledged, delete the TCB, 2983df8bae1dSRodney W. Grimes * enter the closed state and return. 2984df8bae1dSRodney W. Grimes */ 2985df8bae1dSRodney W. Grimes case TCPS_LAST_ACK: 2986df8bae1dSRodney W. Grimes if (ourfinisacked) { 2987df8bae1dSRodney W. Grimes tp = tcp_close(tp); 2988df8bae1dSRodney W. Grimes goto drop; 2989df8bae1dSRodney W. Grimes } 2990df8bae1dSRodney W. Grimes break; 2991df8bae1dSRodney W. Grimes } 2992df8bae1dSRodney W. Grimes } 2993df8bae1dSRodney W. Grimes 2994df8bae1dSRodney W. Grimes step6: 29958501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 29967cfc6904SRobert Watson 2997df8bae1dSRodney W. Grimes /* 299860ee3bb2SAndre Oppermann * Update window information. 299960ee3bb2SAndre Oppermann * Don't look at window if no ACK: TAC's send garbage on first SYN. 3000df8bae1dSRodney W. Grimes */ 300160ee3bb2SAndre Oppermann if ((thflags & TH_ACK) && 300260ee3bb2SAndre Oppermann (SEQ_LT(tp->snd_wl1, th->th_seq) || 300360ee3bb2SAndre Oppermann (tp->snd_wl1 == th->th_seq && (SEQ_LT(tp->snd_wl2, th->th_ack) || 300460ee3bb2SAndre Oppermann (tp->snd_wl2 == th->th_ack && tiwin > tp->snd_wnd))))) { 300560ee3bb2SAndre Oppermann /* keep track of pure window updates */ 300660ee3bb2SAndre Oppermann if (tlen == 0 && 300760ee3bb2SAndre Oppermann tp->snd_wl2 == th->th_ack && tiwin > tp->snd_wnd) 300878b50714SRobert Watson TCPSTAT_INC(tcps_rcvwinupd); 3009df8bae1dSRodney W. Grimes tp->snd_wnd = tiwin; 301060ee3bb2SAndre Oppermann tp->snd_wl1 = th->th_seq; 301160ee3bb2SAndre Oppermann tp->snd_wl2 = th->th_ack; 3012df8bae1dSRodney W. Grimes if (tp->snd_wnd > tp->max_sndwnd) 3013df8bae1dSRodney W. Grimes tp->max_sndwnd = tp->snd_wnd; 301460ee3bb2SAndre Oppermann needoutput = 1; 3015df8bae1dSRodney W. Grimes } 3016df8bae1dSRodney W. Grimes 3017df8bae1dSRodney W. Grimes /* 3018df8bae1dSRodney W. Grimes * Process segments with URG. 3019df8bae1dSRodney W. Grimes */ 3020fb59c426SYoshinobu Inoue if ((thflags & TH_URG) && th->th_urp && 3021df8bae1dSRodney W. Grimes TCPS_HAVERCVDFIN(tp->t_state) == 0) { 3022df8bae1dSRodney W. Grimes /* 3023df8bae1dSRodney W. Grimes * This is a kludge, but if we receive and accept 3024df8bae1dSRodney W. Grimes * random urgent pointers, we'll crash in 3025df8bae1dSRodney W. Grimes * soreceive. It's hard to imagine someone 3026df8bae1dSRodney W. Grimes * actually wanting to send this much urgent data. 3027df8bae1dSRodney W. Grimes */ 302818ad5842SRobert Watson SOCKBUF_LOCK(&so->so_rcv); 3029cfa6009eSGleb Smirnoff if (th->th_urp + sbavail(&so->so_rcv) > sb_max) { 3030fb59c426SYoshinobu Inoue th->th_urp = 0; /* XXX */ 3031fb59c426SYoshinobu Inoue thflags &= ~TH_URG; /* XXX */ 303218ad5842SRobert Watson SOCKBUF_UNLOCK(&so->so_rcv); /* XXX */ 3033df8bae1dSRodney W. Grimes goto dodata; /* XXX */ 3034df8bae1dSRodney W. Grimes } 3035df8bae1dSRodney W. Grimes /* 3036df8bae1dSRodney W. Grimes * If this segment advances the known urgent pointer, 3037df8bae1dSRodney W. Grimes * then mark the data stream. This should not happen 3038df8bae1dSRodney W. Grimes * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since 3039df8bae1dSRodney W. Grimes * a FIN has been received from the remote side. 3040df8bae1dSRodney W. Grimes * In these states we ignore the URG. 3041df8bae1dSRodney W. Grimes * 3042df8bae1dSRodney W. Grimes * According to RFC961 (Assigned Protocols), 3043df8bae1dSRodney W. Grimes * the urgent pointer points to the last octet 3044df8bae1dSRodney W. Grimes * of urgent data. We continue, however, 3045df8bae1dSRodney W. Grimes * to consider it to indicate the first octet 3046df8bae1dSRodney W. Grimes * of data past the urgent section as the original 3047df8bae1dSRodney W. Grimes * spec states (in one of two places). 3048df8bae1dSRodney W. Grimes */ 3049fb59c426SYoshinobu Inoue if (SEQ_GT(th->th_seq+th->th_urp, tp->rcv_up)) { 3050fb59c426SYoshinobu Inoue tp->rcv_up = th->th_seq + th->th_urp; 3051cfa6009eSGleb Smirnoff so->so_oobmark = sbavail(&so->so_rcv) + 3052df8bae1dSRodney W. Grimes (tp->rcv_up - tp->rcv_nxt) - 1; 3053927c5ceaSRobert Watson if (so->so_oobmark == 0) 3054c0b99ffaSRobert Watson so->so_rcv.sb_state |= SBS_RCVATMARK; 3055df8bae1dSRodney W. Grimes sohasoutofband(so); 3056df8bae1dSRodney W. Grimes tp->t_oobflags &= ~(TCPOOB_HAVEDATA | TCPOOB_HADDATA); 3057df8bae1dSRodney W. Grimes } 305818ad5842SRobert Watson SOCKBUF_UNLOCK(&so->so_rcv); 3059df8bae1dSRodney W. Grimes /* 3060df8bae1dSRodney W. Grimes * Remove out of band data so doesn't get presented to user. 3061df8bae1dSRodney W. Grimes * This can happen independent of advancing the URG pointer, 3062df8bae1dSRodney W. Grimes * but if two URG's are pending at once, some out-of-band 3063df8bae1dSRodney W. Grimes * data may creep in... ick. 3064df8bae1dSRodney W. Grimes */ 30653ac12506SJonathan T. Looney if (th->th_urp <= (uint32_t)tlen && 306630613f56SJeffrey Hsu !(so->so_options & SO_OOBINLINE)) { 306730613f56SJeffrey Hsu /* hdr drop is delayed */ 306830613f56SJeffrey Hsu tcp_pulloutofband(so, th, m, drop_hdrlen); 306930613f56SJeffrey Hsu } 3070c068736aSJeffrey Hsu } else { 3071df8bae1dSRodney W. Grimes /* 3072df8bae1dSRodney W. Grimes * If no out of band data is expected, 3073df8bae1dSRodney W. Grimes * pull receive urgent pointer along 3074df8bae1dSRodney W. Grimes * with the receive window. 3075df8bae1dSRodney W. Grimes */ 3076df8bae1dSRodney W. Grimes if (SEQ_GT(tp->rcv_nxt, tp->rcv_up)) 3077df8bae1dSRodney W. Grimes tp->rcv_up = tp->rcv_nxt; 3078c068736aSJeffrey Hsu } 3079df8bae1dSRodney W. Grimes dodata: /* XXX */ 30808501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 30817cfc6904SRobert Watson 3082df8bae1dSRodney W. Grimes /* 3083df8bae1dSRodney W. Grimes * Process the segment text, merging it into the TCP sequencing queue, 3084df8bae1dSRodney W. Grimes * and arranging for acknowledgment of receipt if necessary. 3085df8bae1dSRodney W. Grimes * This process logically involves adjusting tp->rcv_wnd as data 3086df8bae1dSRodney W. Grimes * is presented to the user (this happens in tcp_usrreq.c, 3087df8bae1dSRodney W. Grimes * case PRU_RCVD). If a FIN has already been received on this 3088df8bae1dSRodney W. Grimes * connection then we just ignore the text. 3089df8bae1dSRodney W. Grimes */ 3090281a0fd4SPatrick Kelsey tfo_syn = ((tp->t_state == TCPS_SYN_RECEIVED) && 309168bd7ed1SJonathan T. Looney IS_FASTOPEN(tp->t_flags)); 3092f1ea4e41SRandall Stewart if ((tlen || (thflags & TH_FIN) || (tfo_syn && tlen > 0)) && 3093df8bae1dSRodney W. Grimes TCPS_HAVERCVDFIN(tp->t_state) == 0) { 309469e03620SPaul Saab tcp_seq save_start = th->th_seq; 30955acfd95cSMichael Tuexen tcp_seq save_rnxt = tp->rcv_nxt; 30965acfd95cSMichael Tuexen int save_tlen = tlen; 3097fb59c426SYoshinobu Inoue m_adj(m, drop_hdrlen); /* delayed header drop */ 3098e4b64281SJesper Skriver /* 3099c068736aSJeffrey Hsu * Insert segment which includes th into TCP reassembly queue 3100c068736aSJeffrey Hsu * with control block tp. Set thflags to whether reassembly now 3101c068736aSJeffrey Hsu * includes a segment with FIN. This handles the common case 3102c068736aSJeffrey Hsu * inline (segment is the next to be received on an established 3103c068736aSJeffrey Hsu * connection, and the queue is empty), avoiding linkage into 3104c068736aSJeffrey Hsu * and removal from the queue and repetition of various 3105c068736aSJeffrey Hsu * conversions. 3106c068736aSJeffrey Hsu * Set DELACK for segments received in order, but ack 3107c068736aSJeffrey Hsu * immediately when segments are out of order (so 3108c068736aSJeffrey Hsu * fast retransmit can work). 3109e4b64281SJesper Skriver */ 31104741bfcbSPatrick Kelsey if (th->th_seq == tp->rcv_nxt && 3111c28440dbSRandall Stewart SEGQ_EMPTY(tp) && 3112281a0fd4SPatrick Kelsey (TCPS_HAVEESTABLISHED(tp->t_state) || 3113281a0fd4SPatrick Kelsey tfo_syn)) { 3114281a0fd4SPatrick Kelsey if (DELAY_ACK(tp, tlen) || tfo_syn) 31153bfd6421SJonathan Lemon tp->t_flags |= TF_DELACK; 3116e4b64281SJesper Skriver else 3117e4b64281SJesper Skriver tp->t_flags |= TF_ACKNOW; 3118e4b64281SJesper Skriver tp->rcv_nxt += tlen; 3119e854dd38SRandall Stewart if (tlen && 3120e854dd38SRandall Stewart ((tp->t_flags2 & TF2_FBYTES_COMPLETE) == 0) && 3121e854dd38SRandall Stewart (tp->t_fbyte_in == 0)) { 3122e854dd38SRandall Stewart tp->t_fbyte_in = ticks; 3123e854dd38SRandall Stewart if (tp->t_fbyte_in == 0) 3124e854dd38SRandall Stewart tp->t_fbyte_in = 1; 3125e854dd38SRandall Stewart if (tp->t_fbyte_out && tp->t_fbyte_in) 3126e854dd38SRandall Stewart tp->t_flags2 |= TF2_FBYTES_COMPLETE; 3127e854dd38SRandall Stewart } 3128e4b64281SJesper Skriver thflags = th->th_flags & TH_FIN; 312978b50714SRobert Watson TCPSTAT_INC(tcps_rcvpack); 313078b50714SRobert Watson TCPSTAT_ADD(tcps_rcvbyte, tlen); 31311e4d7da7SRobert Watson SOCKBUF_LOCK(&so->so_rcv); 3132c0b99ffaSRobert Watson if (so->so_rcv.sb_state & SBS_CANTRCVMORE) 3133c1c36a2cSMike Silbersack m_freem(m); 3134c1c36a2cSMike Silbersack else 3135651e4e6aSGleb Smirnoff sbappendstream_locked(&so->so_rcv, m, 0); 31364d0770f1SRichard Scheffenegger SOCKBUF_UNLOCK(&so->so_rcv); 31374d0770f1SRichard Scheffenegger tp->t_flags |= TF_WAKESOR; 3138e4b64281SJesper Skriver } else { 3139e8949f74SAndre Oppermann /* 3140e8949f74SAndre Oppermann * XXX: Due to the header drop above "th" is 3141e8949f74SAndre Oppermann * theoretically invalid by now. Fortunately 3142e8949f74SAndre Oppermann * m_adj() doesn't actually frees any mbufs 3143e8949f74SAndre Oppermann * when trimming from the head. 3144e8949f74SAndre Oppermann */ 31455acfd95cSMichael Tuexen tcp_seq temp = save_start; 31465acfd95cSMichael Tuexen thflags = tcp_reass(tp, th, &temp, &tlen, m); 3147e4b64281SJesper Skriver tp->t_flags |= TF_ACKNOW; 3148e4b64281SJesper Skriver } 314940f41eceSMichael Tuexen if ((tp->t_flags & TF_SACK_PERMIT) && 315040f41eceSMichael Tuexen (save_tlen > 0) && 315140f41eceSMichael Tuexen TCPS_HAVEESTABLISHED(tp->t_state)) { 31526d261981SMichael Tuexen if ((tlen == 0) && (SEQ_LT(save_start, save_rnxt))) { 3153b5a154d8SMichael Tuexen /* 3154b5a154d8SMichael Tuexen * DSACK actually handled in the fastpath 3155b5a154d8SMichael Tuexen * above. 3156b5a154d8SMichael Tuexen */ 3157ecc5b1d1SMichael Tuexen tcp_update_sack_list(tp, save_start, 3158ecc5b1d1SMichael Tuexen save_start + save_tlen); 3159ecc5b1d1SMichael Tuexen } else if ((tlen > 0) && SEQ_GT(tp->rcv_nxt, save_rnxt)) { 3160ecc5b1d1SMichael Tuexen if ((tp->rcv_numsacks >= 1) && 3161ecc5b1d1SMichael Tuexen (tp->sackblks[0].end == save_start)) { 31626d261981SMichael Tuexen /* 31636d261981SMichael Tuexen * Partial overlap, recorded at todrop 31646d261981SMichael Tuexen * above. 31656d261981SMichael Tuexen */ 31666d261981SMichael Tuexen tcp_update_sack_list(tp, 31676d261981SMichael Tuexen tp->sackblks[0].start, 3168ecc5b1d1SMichael Tuexen tp->sackblks[0].end); 3169ecc5b1d1SMichael Tuexen } else { 3170ecc5b1d1SMichael Tuexen tcp_update_dsack_list(tp, save_start, 3171ecc5b1d1SMichael Tuexen save_start + save_tlen); 3172ecc5b1d1SMichael Tuexen } 31736d261981SMichael Tuexen } else if (tlen >= save_tlen) { 3174b5a154d8SMichael Tuexen /* Update of sackblks. */ 3175ecc5b1d1SMichael Tuexen tcp_update_dsack_list(tp, save_start, 3176ecc5b1d1SMichael Tuexen save_start + save_tlen); 3177ecc5b1d1SMichael Tuexen } else if (tlen > 0) { 3178ecc5b1d1SMichael Tuexen tcp_update_dsack_list(tp, save_start, 3179ecc5b1d1SMichael Tuexen save_start + tlen); 31805acfd95cSMichael Tuexen } 31815acfd95cSMichael Tuexen } 3182302ce8d6SAndre Oppermann #if 0 3183df8bae1dSRodney W. Grimes /* 3184df8bae1dSRodney W. Grimes * Note the amount of data that peer has sent into 3185df8bae1dSRodney W. Grimes * our window, in order to estimate the sender's 3186df8bae1dSRodney W. Grimes * buffer size. 3187302ce8d6SAndre Oppermann * XXX: Unused. 3188df8bae1dSRodney W. Grimes */ 3189f701e30dSJohn Baldwin if (SEQ_GT(tp->rcv_adv, tp->rcv_nxt)) 3190df8bae1dSRodney W. Grimes len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt); 3191f701e30dSJohn Baldwin else 3192f701e30dSJohn Baldwin len = so->so_rcv.sb_hiwat; 3193302ce8d6SAndre Oppermann #endif 3194df8bae1dSRodney W. Grimes } else { 3195df8bae1dSRodney W. Grimes m_freem(m); 3196fb59c426SYoshinobu Inoue thflags &= ~TH_FIN; 3197df8bae1dSRodney W. Grimes } 3198df8bae1dSRodney W. Grimes 3199df8bae1dSRodney W. Grimes /* 3200df8bae1dSRodney W. Grimes * If FIN is received ACK the FIN and let the user know 3201df8bae1dSRodney W. Grimes * that the connection is closing. 3202df8bae1dSRodney W. Grimes */ 3203fb59c426SYoshinobu Inoue if (thflags & TH_FIN) { 3204df8bae1dSRodney W. Grimes if (TCPS_HAVERCVDFIN(tp->t_state) == 0) { 3205df8bae1dSRodney W. Grimes socantrcvmore(so); 32064d0770f1SRichard Scheffenegger /* The socket upcall is handled by socantrcvmore. */ 32074d0770f1SRichard Scheffenegger tp->t_flags &= ~TF_WAKESOR; 3208a0292f23SGarrett Wollman /* 3209a0292f23SGarrett Wollman * If connection is half-synchronized 3210d3eede9dSAndras Olah * (ie NEEDSYN flag on) then delay ACK, 3211a0292f23SGarrett Wollman * so it may be piggybacked when SYN is sent. 3212a0292f23SGarrett Wollman * Otherwise, since we received a FIN then no 3213a0292f23SGarrett Wollman * more input can be expected, send ACK now. 3214a0292f23SGarrett Wollman */ 32153bfd6421SJonathan Lemon if (tp->t_flags & TF_NEEDSYN) 32163bfd6421SJonathan Lemon tp->t_flags |= TF_DELACK; 3217a0292f23SGarrett Wollman else 3218df8bae1dSRodney W. Grimes tp->t_flags |= TF_ACKNOW; 3219df8bae1dSRodney W. Grimes tp->rcv_nxt++; 3220df8bae1dSRodney W. Grimes } 3221df8bae1dSRodney W. Grimes switch (tp->t_state) { 3222df8bae1dSRodney W. Grimes /* 3223df8bae1dSRodney W. Grimes * In SYN_RECEIVED and ESTABLISHED STATES 3224df8bae1dSRodney W. Grimes * enter the CLOSE_WAIT state. 3225df8bae1dSRodney W. Grimes */ 3226df8bae1dSRodney W. Grimes case TCPS_SYN_RECEIVED: 32279b8b58e0SJonathan Lemon tp->t_starttime = ticks; 32289b8b58e0SJonathan Lemon /* FALLTHROUGH */ 3229df8bae1dSRodney W. Grimes case TCPS_ESTABLISHED: 323057f60867SMark Johnston tcp_state_change(tp, TCPS_CLOSE_WAIT); 3231df8bae1dSRodney W. Grimes break; 3232df8bae1dSRodney W. Grimes 3233df8bae1dSRodney W. Grimes /* 3234df8bae1dSRodney W. Grimes * If still in FIN_WAIT_1 STATE FIN has not been acked so 3235df8bae1dSRodney W. Grimes * enter the CLOSING state. 3236df8bae1dSRodney W. Grimes */ 3237df8bae1dSRodney W. Grimes case TCPS_FIN_WAIT_1: 323857f60867SMark Johnston tcp_state_change(tp, TCPS_CLOSING); 3239df8bae1dSRodney W. Grimes break; 3240df8bae1dSRodney W. Grimes 3241df8bae1dSRodney W. Grimes /* 3242df8bae1dSRodney W. Grimes * In FIN_WAIT_2 state enter the TIME_WAIT state, 3243df8bae1dSRodney W. Grimes * starting the time-wait timer, turning off the other 3244df8bae1dSRodney W. Grimes * standard timers. 3245df8bae1dSRodney W. Grimes */ 3246df8bae1dSRodney W. Grimes case TCPS_FIN_WAIT_2: 3247340c35deSJonathan Lemon tcp_twstart(tp); 3248679d9708SAndre Oppermann return; 3249df8bae1dSRodney W. Grimes } 3250df8bae1dSRodney W. Grimes } 3251610ee2f9SDavid Greenman #ifdef TCPDEBUG 32524cc20ab1SSeigo Tanimura if (so->so_options & SO_DEBUG) 3253fb59c426SYoshinobu Inoue tcp_trace(TA_INPUT, ostate, tp, (void *)tcp_saveipgen, 3254fb59c426SYoshinobu Inoue &tcp_savetcp, 0); 3255610ee2f9SDavid Greenman #endif 32562b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 3257df8bae1dSRodney W. Grimes 3258df8bae1dSRodney W. Grimes /* 3259df8bae1dSRodney W. Grimes * Return any desired output. 3260df8bae1dSRodney W. Grimes */ 3261df8bae1dSRodney W. Grimes if (needoutput || (tp->t_flags & TF_ACKNOW)) 326255bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 32637792ea27SJeffrey Hsu 3264a14c749fSJonathan Lemon check_delack: 32658501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 3266252ca428SRobert Watson 3267a14c749fSJonathan Lemon if (tp->t_flags & TF_DELACK) { 32683bfd6421SJonathan Lemon tp->t_flags &= ~TF_DELACK; 3269b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_DELACK, tcp_delacktime); 32703bfd6421SJonathan Lemon } 32714d0770f1SRichard Scheffenegger tcp_handle_wakeup(tp, so); 32728501a69cSRobert Watson INP_WUNLOCK(tp->t_inpcb); 3273679d9708SAndre Oppermann return; 3274df8bae1dSRodney W. Grimes 3275df8bae1dSRodney W. Grimes dropafterack: 3276df8bae1dSRodney W. Grimes /* 3277df8bae1dSRodney W. Grimes * Generate an ACK dropping incoming segment if it occupies 3278df8bae1dSRodney W. Grimes * sequence space, where the ACK reflects our state. 327980ab7c0eSGarrett Wollman * 328080ab7c0eSGarrett Wollman * We can now skip the test for the RST flag since all 328180ab7c0eSGarrett Wollman * paths to this code happen after packets containing 328280ab7c0eSGarrett Wollman * RST have been dropped. 328380ab7c0eSGarrett Wollman * 328480ab7c0eSGarrett Wollman * In the SYN-RECEIVED state, don't send an ACK unless the 328580ab7c0eSGarrett Wollman * segment we received passes the SYN-RECEIVED ACK test. 328680ab7c0eSGarrett Wollman * If it fails send a RST. This breaks the loop in the 328780ab7c0eSGarrett Wollman * "LAND" DoS attack, and also prevents an ACK storm 328880ab7c0eSGarrett Wollman * between two listening ports that have been sent forged 328980ab7c0eSGarrett Wollman * SYN segments, each with the source address of the other. 3290df8bae1dSRodney W. Grimes */ 3291fb59c426SYoshinobu Inoue if (tp->t_state == TCPS_SYN_RECEIVED && (thflags & TH_ACK) && 3292fb59c426SYoshinobu Inoue (SEQ_GT(tp->snd_una, th->th_ack) || 3293a57815efSBosko Milekic SEQ_GT(th->th_ack, tp->snd_max)) ) { 3294a57815efSBosko Milekic rstreason = BANDLIM_RST_OPENPORT; 3295a57815efSBosko Milekic goto dropwithreset; 3296a57815efSBosko Milekic } 3297a0292f23SGarrett Wollman #ifdef TCPDEBUG 32984cc20ab1SSeigo Tanimura if (so->so_options & SO_DEBUG) 3299fb59c426SYoshinobu Inoue tcp_trace(TA_DROP, ostate, tp, (void *)tcp_saveipgen, 3300fb59c426SYoshinobu Inoue &tcp_savetcp, 0); 3301a0292f23SGarrett Wollman #endif 33022b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 3303df8bae1dSRodney W. Grimes tp->t_flags |= TF_ACKNOW; 330455bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 33054d0770f1SRichard Scheffenegger tcp_handle_wakeup(tp, so); 33068501a69cSRobert Watson INP_WUNLOCK(tp->t_inpcb); 3307d6915262SRobert Watson m_freem(m); 3308679d9708SAndre Oppermann return; 3309df8bae1dSRodney W. Grimes 3310df8bae1dSRodney W. Grimes dropwithreset: 3311a0ca0871SRobert Watson if (tp != NULL) { 3312302ce8d6SAndre Oppermann tcp_dropwithreset(m, th, tp, tlen, rstreason); 33134d0770f1SRichard Scheffenegger tcp_handle_wakeup(tp, so); 33148501a69cSRobert Watson INP_WUNLOCK(tp->t_inpcb); 3315dd8ac7f9SRobert Watson } else 3316a0ca0871SRobert Watson tcp_dropwithreset(m, th, NULL, tlen, rstreason); 3317679d9708SAndre Oppermann return; 3318df8bae1dSRodney W. Grimes 3319df8bae1dSRodney W. Grimes drop: 3320df8bae1dSRodney W. Grimes /* 3321df8bae1dSRodney W. Grimes * Drop space held by incoming segment and return. 3322df8bae1dSRodney W. Grimes */ 3323610ee2f9SDavid Greenman #ifdef TCPDEBUG 33241c53f806SRobert Watson if (tp == NULL || (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) 3325fb59c426SYoshinobu Inoue tcp_trace(TA_DROP, ostate, tp, (void *)tcp_saveipgen, 3326fb59c426SYoshinobu Inoue &tcp_savetcp, 0); 3327a0292f23SGarrett Wollman #endif 33282b9c9984SGeorge V. Neville-Neil TCP_PROBE3(debug__input, tp, th, m); 33294d0770f1SRichard Scheffenegger if (tp != NULL) { 33304d0770f1SRichard Scheffenegger tcp_handle_wakeup(tp, so); 33318501a69cSRobert Watson INP_WUNLOCK(tp->t_inpcb); 33324d0770f1SRichard Scheffenegger } 3333d6915262SRobert Watson m_freem(m); 3334302ce8d6SAndre Oppermann } 3335302ce8d6SAndre Oppermann 3336302ce8d6SAndre Oppermann /* 33370ca3f933SAndre Oppermann * Issue RST and make ACK acceptable to originator of segment. 33380ca3f933SAndre Oppermann * The mbuf must still include the original packet header. 33390ca3f933SAndre Oppermann * tp may be NULL. 3340302ce8d6SAndre Oppermann */ 334155bceb1eSRandall Stewart void 3342302ce8d6SAndre Oppermann tcp_dropwithreset(struct mbuf *m, struct tcphdr *th, struct tcpcb *tp, 3343302ce8d6SAndre Oppermann int tlen, int rstreason) 3344302ce8d6SAndre Oppermann { 3345b287c6c7SBjoern A. Zeeb #ifdef INET 3346302ce8d6SAndre Oppermann struct ip *ip; 3347b287c6c7SBjoern A. Zeeb #endif 3348302ce8d6SAndre Oppermann #ifdef INET6 3349302ce8d6SAndre Oppermann struct ip6_hdr *ip6; 3350302ce8d6SAndre Oppermann #endif 33517a3244ccSRobert Watson 33527a3244ccSRobert Watson if (tp != NULL) { 33538501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 33547a3244ccSRobert Watson } 33557a3244ccSRobert Watson 33560ca3f933SAndre Oppermann /* Don't bother if destination was broadcast/multicast. */ 3357302ce8d6SAndre Oppermann if ((th->th_flags & TH_RST) || m->m_flags & (M_BCAST|M_MCAST)) 3358302ce8d6SAndre Oppermann goto drop; 3359302ce8d6SAndre Oppermann #ifdef INET6 3360302ce8d6SAndre Oppermann if (mtod(m, struct ip *)->ip_v == 6) { 3361302ce8d6SAndre Oppermann ip6 = mtod(m, struct ip6_hdr *); 3362302ce8d6SAndre Oppermann if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) || 3363302ce8d6SAndre Oppermann IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) 3364302ce8d6SAndre Oppermann goto drop; 3365302ce8d6SAndre Oppermann /* IPv6 anycast check is done at tcp6_input() */ 3366b287c6c7SBjoern A. Zeeb } 3367302ce8d6SAndre Oppermann #endif 3368b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 3369b287c6c7SBjoern A. Zeeb else 3370b287c6c7SBjoern A. Zeeb #endif 3371b287c6c7SBjoern A. Zeeb #ifdef INET 3372302ce8d6SAndre Oppermann { 3373302ce8d6SAndre Oppermann ip = mtod(m, struct ip *); 3374302ce8d6SAndre Oppermann if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || 3375302ce8d6SAndre Oppermann IN_MULTICAST(ntohl(ip->ip_src.s_addr)) || 3376302ce8d6SAndre Oppermann ip->ip_src.s_addr == htonl(INADDR_BROADCAST) || 3377302ce8d6SAndre Oppermann in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) 3378302ce8d6SAndre Oppermann goto drop; 3379302ce8d6SAndre Oppermann } 3380b287c6c7SBjoern A. Zeeb #endif 3381302ce8d6SAndre Oppermann 3382302ce8d6SAndre Oppermann /* Perform bandwidth limiting. */ 3383302ce8d6SAndre Oppermann if (badport_bandlim(rstreason) < 0) 3384302ce8d6SAndre Oppermann goto drop; 3385302ce8d6SAndre Oppermann 3386302ce8d6SAndre Oppermann /* tcp_respond consumes the mbuf chain. */ 3387302ce8d6SAndre Oppermann if (th->th_flags & TH_ACK) { 3388302ce8d6SAndre Oppermann tcp_respond(tp, mtod(m, void *), th, m, (tcp_seq)0, 3389302ce8d6SAndre Oppermann th->th_ack, TH_RST); 3390302ce8d6SAndre Oppermann } else { 3391302ce8d6SAndre Oppermann if (th->th_flags & TH_SYN) 3392302ce8d6SAndre Oppermann tlen++; 33934ddd5aadSMichael Tuexen if (th->th_flags & TH_FIN) 33944ddd5aadSMichael Tuexen tlen++; 3395302ce8d6SAndre Oppermann tcp_respond(tp, mtod(m, void *), th, m, th->th_seq+tlen, 3396302ce8d6SAndre Oppermann (tcp_seq)0, TH_RST|TH_ACK); 3397302ce8d6SAndre Oppermann } 3398302ce8d6SAndre Oppermann return; 3399302ce8d6SAndre Oppermann drop: 3400302ce8d6SAndre Oppermann m_freem(m); 3401df8bae1dSRodney W. Grimes } 3402df8bae1dSRodney W. Grimes 3403be2ac88cSJonathan Lemon /* 3404be2ac88cSJonathan Lemon * Parse TCP options and place in tcpopt. 3405be2ac88cSJonathan Lemon */ 340655bceb1eSRandall Stewart void 3407ad3f9ab3SAndre Oppermann tcp_dooptions(struct tcpopt *to, u_char *cp, int cnt, int flags) 3408df8bae1dSRodney W. Grimes { 3409df8bae1dSRodney W. Grimes int opt, optlen; 3410df8bae1dSRodney W. Grimes 3411be2ac88cSJonathan Lemon to->to_flags = 0; 3412df8bae1dSRodney W. Grimes for (; cnt > 0; cnt -= optlen, cp += optlen) { 3413df8bae1dSRodney W. Grimes opt = cp[0]; 3414df8bae1dSRodney W. Grimes if (opt == TCPOPT_EOL) 3415df8bae1dSRodney W. Grimes break; 3416df8bae1dSRodney W. Grimes if (opt == TCPOPT_NOP) 3417df8bae1dSRodney W. Grimes optlen = 1; 3418df8bae1dSRodney W. Grimes else { 3419b474779fSJun-ichiro itojun Hagino if (cnt < 2) 3420b474779fSJun-ichiro itojun Hagino break; 3421df8bae1dSRodney W. Grimes optlen = cp[1]; 3422b474779fSJun-ichiro itojun Hagino if (optlen < 2 || optlen > cnt) 3423df8bae1dSRodney W. Grimes break; 3424df8bae1dSRodney W. Grimes } 3425df8bae1dSRodney W. Grimes switch (opt) { 3426df8bae1dSRodney W. Grimes case TCPOPT_MAXSEG: 3427df8bae1dSRodney W. Grimes if (optlen != TCPOLEN_MAXSEG) 3428df8bae1dSRodney W. Grimes continue; 3429f72167f4SAndre Oppermann if (!(flags & TO_SYN)) 3430df8bae1dSRodney W. Grimes continue; 3431be2ac88cSJonathan Lemon to->to_flags |= TOF_MSS; 3432be2ac88cSJonathan Lemon bcopy((char *)cp + 2, 3433be2ac88cSJonathan Lemon (char *)&to->to_mss, sizeof(to->to_mss)); 3434fd8e4ebcSMike Barcroft to->to_mss = ntohs(to->to_mss); 3435df8bae1dSRodney W. Grimes break; 3436df8bae1dSRodney W. Grimes case TCPOPT_WINDOW: 3437df8bae1dSRodney W. Grimes if (optlen != TCPOLEN_WINDOW) 3438df8bae1dSRodney W. Grimes continue; 3439f72167f4SAndre Oppermann if (!(flags & TO_SYN)) 3440df8bae1dSRodney W. Grimes continue; 3441be2ac88cSJonathan Lemon to->to_flags |= TOF_SCALE; 344202a1a643SAndre Oppermann to->to_wscale = min(cp[2], TCP_MAX_WINSHIFT); 3443df8bae1dSRodney W. Grimes break; 3444df8bae1dSRodney W. Grimes case TCPOPT_TIMESTAMP: 3445df8bae1dSRodney W. Grimes if (optlen != TCPOLEN_TIMESTAMP) 3446df8bae1dSRodney W. Grimes continue; 3447be2ac88cSJonathan Lemon to->to_flags |= TOF_TS; 3448a0292f23SGarrett Wollman bcopy((char *)cp + 2, 3449a0292f23SGarrett Wollman (char *)&to->to_tsval, sizeof(to->to_tsval)); 3450fd8e4ebcSMike Barcroft to->to_tsval = ntohl(to->to_tsval); 3451a0292f23SGarrett Wollman bcopy((char *)cp + 6, 3452a0292f23SGarrett Wollman (char *)&to->to_tsecr, sizeof(to->to_tsecr)); 3453fd8e4ebcSMike Barcroft to->to_tsecr = ntohl(to->to_tsecr); 3454df8bae1dSRodney W. Grimes break; 34551cfd4b53SBruce M Simpson case TCPOPT_SIGNATURE: 3456fcf59617SAndrey V. Elsukov /* 3457fcf59617SAndrey V. Elsukov * In order to reply to a host which has set the 3458fcf59617SAndrey V. Elsukov * TCP_SIGNATURE option in its initial SYN, we have 3459fcf59617SAndrey V. Elsukov * to record the fact that the option was observed 3460fcf59617SAndrey V. Elsukov * here for the syncache code to perform the correct 3461fcf59617SAndrey V. Elsukov * response. 3462fcf59617SAndrey V. Elsukov */ 34631cfd4b53SBruce M Simpson if (optlen != TCPOLEN_SIGNATURE) 34641cfd4b53SBruce M Simpson continue; 3465df47e437SAndre Oppermann to->to_flags |= TOF_SIGNATURE; 3466df47e437SAndre Oppermann to->to_signature = cp + 2; 34671cfd4b53SBruce M Simpson break; 34686d90faf3SPaul Saab case TCPOPT_SACK_PERMITTED: 3469f72167f4SAndre Oppermann if (optlen != TCPOLEN_SACK_PERMITTED) 34706d90faf3SPaul Saab continue; 3471f72167f4SAndre Oppermann if (!(flags & TO_SYN)) 3472f72167f4SAndre Oppermann continue; 3473603724d3SBjoern A. Zeeb if (!V_tcp_do_sack) 3474f72167f4SAndre Oppermann continue; 3475fc30a251SAndre Oppermann to->to_flags |= TOF_SACKPERM; 34766d90faf3SPaul Saab break; 34776d90faf3SPaul Saab case TCPOPT_SACK: 34785a53ca16SPaul Saab if (optlen <= 2 || (optlen - 2) % TCPOLEN_SACK != 0) 34796d90faf3SPaul Saab continue; 3480b728e902SAndre Oppermann if (flags & TO_SYN) 3481b728e902SAndre Oppermann continue; 3482fc30a251SAndre Oppermann to->to_flags |= TOF_SACK; 34835a53ca16SPaul Saab to->to_nsacks = (optlen - 2) / TCPOLEN_SACK; 34845a53ca16SPaul Saab to->to_sacks = cp + 2; 348578b50714SRobert Watson TCPSTAT_INC(tcps_sack_rcv_blocks); 34866d90faf3SPaul Saab break; 3487281a0fd4SPatrick Kelsey case TCPOPT_FAST_OPEN: 3488c560df6fSPatrick Kelsey /* 3489c560df6fSPatrick Kelsey * Cookie length validation is performed by the 3490c560df6fSPatrick Kelsey * server side cookie checking code or the client 3491c560df6fSPatrick Kelsey * side cookie cache update code. 3492c560df6fSPatrick Kelsey */ 3493281a0fd4SPatrick Kelsey if (!(flags & TO_SYN)) 3494281a0fd4SPatrick Kelsey continue; 3495c560df6fSPatrick Kelsey if (!V_tcp_fastopen_client_enable && 3496c560df6fSPatrick Kelsey !V_tcp_fastopen_server_enable) 3497281a0fd4SPatrick Kelsey continue; 3498281a0fd4SPatrick Kelsey to->to_flags |= TOF_FASTOPEN; 3499281a0fd4SPatrick Kelsey to->to_tfo_len = optlen - 2; 3500281a0fd4SPatrick Kelsey to->to_tfo_cookie = to->to_tfo_len ? cp + 2 : NULL; 3501281a0fd4SPatrick Kelsey break; 3502be2ac88cSJonathan Lemon default: 3503be2ac88cSJonathan Lemon continue; 3504df8bae1dSRodney W. Grimes } 3505df8bae1dSRodney W. Grimes } 3506df8bae1dSRodney W. Grimes } 3507df8bae1dSRodney W. Grimes 3508df8bae1dSRodney W. Grimes /* 3509df8bae1dSRodney W. Grimes * Pull out of band byte out of a segment so 3510df8bae1dSRodney W. Grimes * it doesn't appear in the user's data queue. 3511df8bae1dSRodney W. Grimes * It is still reflected in the segment length for 3512df8bae1dSRodney W. Grimes * sequencing purposes. 3513df8bae1dSRodney W. Grimes */ 351455bceb1eSRandall Stewart void 3515ad3f9ab3SAndre Oppermann tcp_pulloutofband(struct socket *so, struct tcphdr *th, struct mbuf *m, 3516ad3f9ab3SAndre Oppermann int off) 3517df8bae1dSRodney W. Grimes { 3518fb59c426SYoshinobu Inoue int cnt = off + th->th_urp - 1; 3519df8bae1dSRodney W. Grimes 3520df8bae1dSRodney W. Grimes while (cnt >= 0) { 3521df8bae1dSRodney W. Grimes if (m->m_len > cnt) { 3522df8bae1dSRodney W. Grimes char *cp = mtod(m, caddr_t) + cnt; 3523df8bae1dSRodney W. Grimes struct tcpcb *tp = sototcpcb(so); 3524df8bae1dSRodney W. Grimes 35258501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 35267a3244ccSRobert Watson 3527df8bae1dSRodney W. Grimes tp->t_iobc = *cp; 3528df8bae1dSRodney W. Grimes tp->t_oobflags |= TCPOOB_HAVEDATA; 3529df8bae1dSRodney W. Grimes bcopy(cp+1, cp, (unsigned)(m->m_len - cnt - 1)); 3530df8bae1dSRodney W. Grimes m->m_len--; 353169a34685SYoshinobu Inoue if (m->m_flags & M_PKTHDR) 353269a34685SYoshinobu Inoue m->m_pkthdr.len--; 3533df8bae1dSRodney W. Grimes return; 3534df8bae1dSRodney W. Grimes } 3535df8bae1dSRodney W. Grimes cnt -= m->m_len; 3536df8bae1dSRodney W. Grimes m = m->m_next; 35374dfdffe9SAndre Oppermann if (m == NULL) 3538df8bae1dSRodney W. Grimes break; 3539df8bae1dSRodney W. Grimes } 3540df8bae1dSRodney W. Grimes panic("tcp_pulloutofband"); 3541df8bae1dSRodney W. Grimes } 3542df8bae1dSRodney W. Grimes 3543df8bae1dSRodney W. Grimes /* 3544df8bae1dSRodney W. Grimes * Collect new round-trip time estimate 3545df8bae1dSRodney W. Grimes * and update averages and current timeout. 3546df8bae1dSRodney W. Grimes */ 354755bceb1eSRandall Stewart void 3548ad3f9ab3SAndre Oppermann tcp_xmit_timer(struct tcpcb *tp, int rtt) 3549df8bae1dSRodney W. Grimes { 3550ad3f9ab3SAndre Oppermann int delta; 3551233e8c18SGarrett Wollman 35528501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 35532be3bf22SRobert Watson 355478b50714SRobert Watson TCPSTAT_INC(tcps_rttupdated); 3555233e8c18SGarrett Wollman tp->t_rttupdated++; 3556adc56f5aSEdward Tomasz Napierala #ifdef STATS 3557adc56f5aSEdward Tomasz Napierala stats_voi_update_abs_u32(tp->t_stats, VOI_TCP_RTT, 3558adc56f5aSEdward Tomasz Napierala imax(0, rtt * 1000 / hz)); 3559adc56f5aSEdward Tomasz Napierala #endif 35605ede40dcSRyan Stone if ((tp->t_srtt != 0) && (tp->t_rxtshift <= TCP_RTT_INVALIDATE)) { 3561233e8c18SGarrett Wollman /* 3562233e8c18SGarrett Wollman * srtt is stored as fixed point with 5 bits after the 3563233e8c18SGarrett Wollman * binary point (i.e., scaled by 8). The following magic 3564233e8c18SGarrett Wollman * is equivalent to the smoothing algorithm in rfc793 with 3565233e8c18SGarrett Wollman * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed 3566233e8c18SGarrett Wollman * point). Adjust rtt to origin 0. 3567233e8c18SGarrett Wollman */ 3568233e8c18SGarrett Wollman delta = ((rtt - 1) << TCP_DELTA_SHIFT) 3569233e8c18SGarrett Wollman - (tp->t_srtt >> (TCP_RTT_SHIFT - TCP_DELTA_SHIFT)); 3570233e8c18SGarrett Wollman 3571233e8c18SGarrett Wollman if ((tp->t_srtt += delta) <= 0) 3572233e8c18SGarrett Wollman tp->t_srtt = 1; 3573233e8c18SGarrett Wollman 3574233e8c18SGarrett Wollman /* 3575233e8c18SGarrett Wollman * We accumulate a smoothed rtt variance (actually, a 3576233e8c18SGarrett Wollman * smoothed mean difference), then set the retransmit 3577233e8c18SGarrett Wollman * timer to smoothed rtt + 4 times the smoothed variance. 3578233e8c18SGarrett Wollman * rttvar is stored as fixed point with 4 bits after the 3579233e8c18SGarrett Wollman * binary point (scaled by 16). The following is 3580233e8c18SGarrett Wollman * equivalent to rfc793 smoothing with an alpha of .75 3581233e8c18SGarrett Wollman * (rttvar = rttvar*3/4 + |delta| / 4). This replaces 3582233e8c18SGarrett Wollman * rfc793's wired-in beta. 3583233e8c18SGarrett Wollman */ 3584233e8c18SGarrett Wollman if (delta < 0) 3585233e8c18SGarrett Wollman delta = -delta; 3586233e8c18SGarrett Wollman delta -= tp->t_rttvar >> (TCP_RTTVAR_SHIFT - TCP_DELTA_SHIFT); 3587233e8c18SGarrett Wollman if ((tp->t_rttvar += delta) <= 0) 3588233e8c18SGarrett Wollman tp->t_rttvar = 1; 35891fcc99b5SMatthew Dillon if (tp->t_rttbest > tp->t_srtt + tp->t_rttvar) 35901fcc99b5SMatthew Dillon tp->t_rttbest = tp->t_srtt + tp->t_rttvar; 3591233e8c18SGarrett Wollman } else { 3592233e8c18SGarrett Wollman /* 3593233e8c18SGarrett Wollman * No rtt measurement yet - use the unsmoothed rtt. 3594233e8c18SGarrett Wollman * Set the variance to half the rtt (so our first 3595233e8c18SGarrett Wollman * retransmit happens at 3*rtt). 3596233e8c18SGarrett Wollman */ 3597233e8c18SGarrett Wollman tp->t_srtt = rtt << TCP_RTT_SHIFT; 3598233e8c18SGarrett Wollman tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT - 1); 35991fcc99b5SMatthew Dillon tp->t_rttbest = tp->t_srtt + tp->t_rttvar; 3600233e8c18SGarrett Wollman } 36019b8b58e0SJonathan Lemon tp->t_rtttime = 0; 3602df8bae1dSRodney W. Grimes tp->t_rxtshift = 0; 3603df8bae1dSRodney W. Grimes 3604df8bae1dSRodney W. Grimes /* 3605df8bae1dSRodney W. Grimes * the retransmit should happen at rtt + 4 * rttvar. 3606df8bae1dSRodney W. Grimes * Because of the way we do the smoothing, srtt and rttvar 3607df8bae1dSRodney W. Grimes * will each average +1/2 tick of bias. When we compute 3608df8bae1dSRodney W. Grimes * the retransmit timer, we want 1/2 tick of rounding and 3609df8bae1dSRodney W. Grimes * 1 extra tick because of +-1/2 tick uncertainty in the 3610df8bae1dSRodney W. Grimes * firing of the timer. The bias will give us exactly the 3611df8bae1dSRodney W. Grimes * 1.5 tick we need. But, because the bias is 3612df8bae1dSRodney W. Grimes * statistical, we have to test that we don't drop below 3613df8bae1dSRodney W. Grimes * the minimum feasible timer (which is 2 ticks). 3614df8bae1dSRodney W. Grimes */ 3615233e8c18SGarrett Wollman TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp), 36169e2874b0SGarrett Wollman max(tp->t_rttmin, rtt + 2), TCPTV_REXMTMAX); 3617df8bae1dSRodney W. Grimes 3618df8bae1dSRodney W. Grimes /* 3619df8bae1dSRodney W. Grimes * We received an ack for a packet that wasn't retransmitted; 3620df8bae1dSRodney W. Grimes * it is probably safe to discard any error indications we've 3621df8bae1dSRodney W. Grimes * received recently. This isn't quite right, but close enough 3622df8bae1dSRodney W. Grimes * for now (a route might have failed after we sent a segment, 3623df8bae1dSRodney W. Grimes * and the return path might not be symmetrical). 3624df8bae1dSRodney W. Grimes */ 3625df8bae1dSRodney W. Grimes tp->t_softerror = 0; 3626df8bae1dSRodney W. Grimes } 3627df8bae1dSRodney W. Grimes 3628df8bae1dSRodney W. Grimes /* 3629df8bae1dSRodney W. Grimes * Determine a reasonable value for maxseg size. 3630df8bae1dSRodney W. Grimes * If the route is known, check route for mtu. 36314faaea55SAndre Oppermann * If none, use an mss that can be handled on the outgoing interface 36324faaea55SAndre Oppermann * without forcing IP to fragment. If no route is found, route has no mtu, 3633df8bae1dSRodney W. Grimes * or the destination isn't local, use a default, hopefully conservative 3634df8bae1dSRodney W. Grimes * size (usually 512 or the default IP max size, but no more than the mtu 3635df8bae1dSRodney W. Grimes * of the interface), as we can't discover anything about intervening 3636df8bae1dSRodney W. Grimes * gateways or networks. We also initialize the congestion/slow start 3637df8bae1dSRodney W. Grimes * window to be a single segment if the destination isn't local. 3638df8bae1dSRodney W. Grimes * While looking at the routing entry, we also initialize other path-dependent 3639df8bae1dSRodney W. Grimes * parameters from pre-set or cached values in the routing entry. 3640a0292f23SGarrett Wollman * 36410c39d38dSGleb Smirnoff * NOTE that resulting t_maxseg doesn't include space for TCP options or 36420c39d38dSGleb Smirnoff * IP options, e.g. IPSEC data, since length of this data may vary, and 36430c39d38dSGleb Smirnoff * thus it is calculated for every segment separately in tcp_output(). 3644a0292f23SGarrett Wollman * 364597d8d152SAndre Oppermann * NOTE that this routine is only called when we process an incoming 3646ef341ee1SGleb Smirnoff * segment, or an ICMP need fragmentation datagram. Outgoing SYN/ACK MSS 3647ef341ee1SGleb Smirnoff * settings are handled in tcp_mssopt(). 3648df8bae1dSRodney W. Grimes */ 3649a0292f23SGarrett Wollman void 3650ef341ee1SGleb Smirnoff tcp_mss_update(struct tcpcb *tp, int offer, int mtuoffer, 36513c914c54SAndre Oppermann struct hc_metrics_lite *metricptr, struct tcp_ifcap *cap) 3652df8bae1dSRodney W. Grimes { 3653b287c6c7SBjoern A. Zeeb int mss = 0; 36543ac12506SJonathan T. Looney uint32_t maxmtu = 0; 3655c068736aSJeffrey Hsu struct inpcb *inp = tp->t_inpcb; 365697d8d152SAndre Oppermann struct hc_metrics_lite metrics; 3657fb59c426SYoshinobu Inoue #ifdef INET6 3658c068736aSJeffrey Hsu int isipv6 = ((inp->inp_vflag & INP_IPV6) != 0) ? 1 : 0; 3659c068736aSJeffrey Hsu size_t min_protoh = isipv6 ? 3660c068736aSJeffrey Hsu sizeof (struct ip6_hdr) + sizeof (struct tcphdr) : 3661c068736aSJeffrey Hsu sizeof (struct tcpiphdr); 3662c068736aSJeffrey Hsu #else 3663c068736aSJeffrey Hsu const size_t min_protoh = sizeof(struct tcpiphdr); 3664fb59c426SYoshinobu Inoue #endif 3665df8bae1dSRodney W. Grimes 36668501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 36677a3244ccSRobert Watson 3668ef341ee1SGleb Smirnoff if (mtuoffer != -1) { 3669ef341ee1SGleb Smirnoff KASSERT(offer == -1, ("%s: conflict", __func__)); 3670ef341ee1SGleb Smirnoff offer = mtuoffer - min_protoh; 3671ef341ee1SGleb Smirnoff } 3672ef341ee1SGleb Smirnoff 3673e8949f74SAndre Oppermann /* Initialize. */ 367497d8d152SAndre Oppermann #ifdef INET6 367597d8d152SAndre Oppermann if (isipv6) { 36763c914c54SAndre Oppermann maxmtu = tcp_maxmtu6(&inp->inp_inc, cap); 36770c39d38dSGleb Smirnoff tp->t_maxseg = V_tcp_v6mssdflt; 3678b287c6c7SBjoern A. Zeeb } 367997d8d152SAndre Oppermann #endif 3680b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 3681b287c6c7SBjoern A. Zeeb else 3682b287c6c7SBjoern A. Zeeb #endif 3683b287c6c7SBjoern A. Zeeb #ifdef INET 368497d8d152SAndre Oppermann { 36853c914c54SAndre Oppermann maxmtu = tcp_maxmtu(&inp->inp_inc, cap); 36860c39d38dSGleb Smirnoff tp->t_maxseg = V_tcp_mssdflt; 3687df8bae1dSRodney W. Grimes } 3688b287c6c7SBjoern A. Zeeb #endif 3689df8bae1dSRodney W. Grimes 369097d8d152SAndre Oppermann /* 3691e8949f74SAndre Oppermann * No route to sender, stay with default mss and return. 369297d8d152SAndre Oppermann */ 36936f01cac6SBjoern A. Zeeb if (maxmtu == 0) { 36946f01cac6SBjoern A. Zeeb /* 36958e5c87f4SBjoern A. Zeeb * In case we return early we need to initialize metrics 36966f01cac6SBjoern A. Zeeb * to a defined state as tcp_hc_get() would do for us 36976f01cac6SBjoern A. Zeeb * if there was no cache hit. 36986f01cac6SBjoern A. Zeeb */ 36996f01cac6SBjoern A. Zeeb if (metricptr != NULL) 37006f01cac6SBjoern A. Zeeb bzero(metricptr, sizeof(struct hc_metrics_lite)); 370197d8d152SAndre Oppermann return; 37026f01cac6SBjoern A. Zeeb } 370397d8d152SAndre Oppermann 3704e8949f74SAndre Oppermann /* What have we got? */ 370597d8d152SAndre Oppermann switch (offer) { 370697d8d152SAndre Oppermann case 0: 370797d8d152SAndre Oppermann /* 370897d8d152SAndre Oppermann * Offer == 0 means that there was no MSS on the SYN 3709c3b02504SBjoern A. Zeeb * segment, in this case we use tcp_mssdflt as 37100c39d38dSGleb Smirnoff * already assigned to t_maxseg above. 371197d8d152SAndre Oppermann */ 37120c39d38dSGleb Smirnoff offer = tp->t_maxseg; 371397d8d152SAndre Oppermann break; 371497d8d152SAndre Oppermann 371597d8d152SAndre Oppermann case -1: 3716a0292f23SGarrett Wollman /* 3717c94c54e4SAndre Oppermann * Offer == -1 means that we didn't receive SYN yet. 3718a0292f23SGarrett Wollman */ 371997d8d152SAndre Oppermann /* FALLTHROUGH */ 372097d8d152SAndre Oppermann 372197d8d152SAndre Oppermann default: 3722a0292f23SGarrett Wollman /* 372353369ac9SAndre Oppermann * Prevent DoS attack with too small MSS. Round up 372453369ac9SAndre Oppermann * to at least minmss. 372553369ac9SAndre Oppermann */ 3726603724d3SBjoern A. Zeeb offer = max(offer, V_tcp_minmss); 372797d8d152SAndre Oppermann } 3728a0292f23SGarrett Wollman 3729df8bae1dSRodney W. Grimes /* 3730e8949f74SAndre Oppermann * rmx information is now retrieved from tcp_hostcache. 3731df8bae1dSRodney W. Grimes */ 373297d8d152SAndre Oppermann tcp_hc_get(&inp->inp_inc, &metrics); 37333cee92e0SBjoern A. Zeeb if (metricptr != NULL) 37343cee92e0SBjoern A. Zeeb bcopy(&metrics, metricptr, sizeof(struct hc_metrics_lite)); 373597d8d152SAndre Oppermann 3736df8bae1dSRodney W. Grimes /* 3737cc412412SHiren Panchasara * If there's a discovered mtu in tcp hostcache, use it. 3738cc412412SHiren Panchasara * Else, use the link mtu. 3739df8bae1dSRodney W. Grimes */ 374097d8d152SAndre Oppermann if (metrics.rmx_mtu) 37412d166c02SAndre Oppermann mss = min(metrics.rmx_mtu, maxmtu) - min_protoh; 3742c068736aSJeffrey Hsu else { 374331b3783cSHajimu UMEMOTO #ifdef INET6 3744fb59c426SYoshinobu Inoue if (isipv6) { 374597d8d152SAndre Oppermann mss = maxmtu - min_protoh; 3746603724d3SBjoern A. Zeeb if (!V_path_mtu_discovery && 374797d8d152SAndre Oppermann !in6_localaddr(&inp->in6p_faddr)) 3748603724d3SBjoern A. Zeeb mss = min(mss, V_tcp_v6mssdflt); 3749b287c6c7SBjoern A. Zeeb } 3750b3399803SHajimu UMEMOTO #endif 3751b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 3752b287c6c7SBjoern A. Zeeb else 3753b287c6c7SBjoern A. Zeeb #endif 3754b287c6c7SBjoern A. Zeeb #ifdef INET 375597d8d152SAndre Oppermann { 375697d8d152SAndre Oppermann mss = maxmtu - min_protoh; 3757603724d3SBjoern A. Zeeb if (!V_path_mtu_discovery && 375897d8d152SAndre Oppermann !in_localaddr(inp->inp_faddr)) 3759603724d3SBjoern A. Zeeb mss = min(mss, V_tcp_mssdflt); 3760a0292f23SGarrett Wollman } 3761b287c6c7SBjoern A. Zeeb #endif 37623cee92e0SBjoern A. Zeeb /* 37633cee92e0SBjoern A. Zeeb * XXX - The above conditional (mss = maxmtu - min_protoh) 37643cee92e0SBjoern A. Zeeb * probably violates the TCP spec. 37653cee92e0SBjoern A. Zeeb * The problem is that, since we don't know the 37663cee92e0SBjoern A. Zeeb * other end's MSS, we are supposed to use a conservative 37673cee92e0SBjoern A. Zeeb * default. But, if we do that, then MTU discovery will 37683cee92e0SBjoern A. Zeeb * never actually take place, because the conservative 37693cee92e0SBjoern A. Zeeb * default is much less than the MTUs typically seen 37703cee92e0SBjoern A. Zeeb * on the Internet today. For the moment, we'll sweep 37713cee92e0SBjoern A. Zeeb * this under the carpet. 37723cee92e0SBjoern A. Zeeb * 37733cee92e0SBjoern A. Zeeb * The conservative default might not actually be a problem 37743cee92e0SBjoern A. Zeeb * if the only case this occurs is when sending an initial 37753cee92e0SBjoern A. Zeeb * SYN with options and data to a host we've never talked 37763cee92e0SBjoern A. Zeeb * to before. Then, they will reply with an MSS value which 37773cee92e0SBjoern A. Zeeb * will get recorded and the new parameters should get 37783cee92e0SBjoern A. Zeeb * recomputed. For Further Study. 37793cee92e0SBjoern A. Zeeb */ 378097d8d152SAndre Oppermann } 3781a0292f23SGarrett Wollman mss = min(mss, offer); 378297d8d152SAndre Oppermann 3783a0292f23SGarrett Wollman /* 37840c39d38dSGleb Smirnoff * Sanity check: make sure that maxseg will be large 37853cee92e0SBjoern A. Zeeb * enough to allow some data on segments even if the 37863cee92e0SBjoern A. Zeeb * all the option space is used (40bytes). Otherwise 37873cee92e0SBjoern A. Zeeb * funny things may happen in tcp_output. 37880c39d38dSGleb Smirnoff * 37890c39d38dSGleb Smirnoff * XXXGL: shouldn't we reserve space for IP/IPv6 options? 37903cee92e0SBjoern A. Zeeb */ 37913cee92e0SBjoern A. Zeeb mss = max(mss, 64); 37923cee92e0SBjoern A. Zeeb 379397d8d152SAndre Oppermann tp->t_maxseg = mss; 37943cee92e0SBjoern A. Zeeb } 37953cee92e0SBjoern A. Zeeb 37963cee92e0SBjoern A. Zeeb void 37973cee92e0SBjoern A. Zeeb tcp_mss(struct tcpcb *tp, int offer) 37983cee92e0SBjoern A. Zeeb { 3799dbc42409SLawrence Stewart int mss; 38003ac12506SJonathan T. Looney uint32_t bufsize; 38013cee92e0SBjoern A. Zeeb struct inpcb *inp; 38023cee92e0SBjoern A. Zeeb struct socket *so; 38033cee92e0SBjoern A. Zeeb struct hc_metrics_lite metrics; 38043c914c54SAndre Oppermann struct tcp_ifcap cap; 3805dbc42409SLawrence Stewart 38063cee92e0SBjoern A. Zeeb KASSERT(tp != NULL, ("%s: tp == NULL", __func__)); 38073cee92e0SBjoern A. Zeeb 38083c914c54SAndre Oppermann bzero(&cap, sizeof(cap)); 38093c914c54SAndre Oppermann tcp_mss_update(tp, offer, -1, &metrics, &cap); 38103cee92e0SBjoern A. Zeeb 38113cee92e0SBjoern A. Zeeb mss = tp->t_maxseg; 38123cee92e0SBjoern A. Zeeb inp = tp->t_inpcb; 381397d8d152SAndre Oppermann 3814df8bae1dSRodney W. Grimes /* 381597d8d152SAndre Oppermann * If there's a pipesize, change the socket buffer to that size, 381697d8d152SAndre Oppermann * don't change if sb_hiwat is different than default (then it 381797d8d152SAndre Oppermann * has been changed on purpose with setsockopt). 381897d8d152SAndre Oppermann * Make the socket buffers an integral number of mss units; 381997d8d152SAndre Oppermann * if the mss is larger than the socket buffer, decrease the mss. 3820df8bae1dSRodney W. Grimes */ 3821c3b02504SBjoern A. Zeeb so = inp->inp_socket; 38223f11a2f3SRobert Watson SOCKBUF_LOCK(&so->so_snd); 3823e233e2acSAndre Oppermann if ((so->so_snd.sb_hiwat == V_tcp_sendspace) && metrics.rmx_sendpipe) 382497d8d152SAndre Oppermann bufsize = metrics.rmx_sendpipe; 382597d8d152SAndre Oppermann else 3826df8bae1dSRodney W. Grimes bufsize = so->so_snd.sb_hiwat; 3827df8bae1dSRodney W. Grimes if (bufsize < mss) 3828df8bae1dSRodney W. Grimes mss = bufsize; 3829df8bae1dSRodney W. Grimes else { 3830df8bae1dSRodney W. Grimes bufsize = roundup(bufsize, mss); 3831df8bae1dSRodney W. Grimes if (bufsize > sb_max) 3832df8bae1dSRodney W. Grimes bufsize = sb_max; 383388c39af3SRuslan Ermilov if (bufsize > so->so_snd.sb_hiwat) 38343f11a2f3SRobert Watson (void)sbreserve_locked(&so->so_snd, bufsize, so, NULL); 3835df8bae1dSRodney W. Grimes } 38363f11a2f3SRobert Watson SOCKBUF_UNLOCK(&so->so_snd); 3837784ce8faSHiren Panchasara /* 3838784ce8faSHiren Panchasara * Sanity check: make sure that maxseg will be large 3839784ce8faSHiren Panchasara * enough to allow some data on segments even if the 3840784ce8faSHiren Panchasara * all the option space is used (40bytes). Otherwise 3841784ce8faSHiren Panchasara * funny things may happen in tcp_output. 3842784ce8faSHiren Panchasara * 3843784ce8faSHiren Panchasara * XXXGL: shouldn't we reserve space for IP/IPv6 options? 3844784ce8faSHiren Panchasara */ 3845784ce8faSHiren Panchasara tp->t_maxseg = max(mss, 64); 3846df8bae1dSRodney W. Grimes 38473f11a2f3SRobert Watson SOCKBUF_LOCK(&so->so_rcv); 3848e233e2acSAndre Oppermann if ((so->so_rcv.sb_hiwat == V_tcp_recvspace) && metrics.rmx_recvpipe) 384997d8d152SAndre Oppermann bufsize = metrics.rmx_recvpipe; 385097d8d152SAndre Oppermann else 3851df8bae1dSRodney W. Grimes bufsize = so->so_rcv.sb_hiwat; 3852df8bae1dSRodney W. Grimes if (bufsize > mss) { 3853df8bae1dSRodney W. Grimes bufsize = roundup(bufsize, mss); 3854df8bae1dSRodney W. Grimes if (bufsize > sb_max) 3855df8bae1dSRodney W. Grimes bufsize = sb_max; 385688c39af3SRuslan Ermilov if (bufsize > so->so_rcv.sb_hiwat) 38573f11a2f3SRobert Watson (void)sbreserve_locked(&so->so_rcv, bufsize, so, NULL); 3858df8bae1dSRodney W. Grimes } 38593f11a2f3SRobert Watson SOCKBUF_UNLOCK(&so->so_rcv); 386091d6cfa6SBjoern A. Zeeb 386191d6cfa6SBjoern A. Zeeb /* Check the interface for TSO capabilities. */ 38623c914c54SAndre Oppermann if (cap.ifcap & CSUM_TSO) { 386391d6cfa6SBjoern A. Zeeb tp->t_flags |= TF_TSO; 38643c914c54SAndre Oppermann tp->t_tsomax = cap.tsomax; 38659fd573c3SHans Petter Selasky tp->t_tsomaxsegcount = cap.tsomaxsegcount; 38669fd573c3SHans Petter Selasky tp->t_tsomaxsegsize = cap.tsomaxsegsize; 38673c914c54SAndre Oppermann } 3868a0292f23SGarrett Wollman } 3869a0292f23SGarrett Wollman 3870a0292f23SGarrett Wollman /* 3871a0292f23SGarrett Wollman * Determine the MSS option to send on an outgoing SYN. 3872a0292f23SGarrett Wollman */ 3873a0292f23SGarrett Wollman int 3874ad3f9ab3SAndre Oppermann tcp_mssopt(struct in_conninfo *inc) 3875a0292f23SGarrett Wollman { 387697d8d152SAndre Oppermann int mss = 0; 38773ac12506SJonathan T. Looney uint32_t thcmtu = 0; 38783ac12506SJonathan T. Looney uint32_t maxmtu = 0; 387997d8d152SAndre Oppermann size_t min_protoh; 3880a0292f23SGarrett Wollman 388197d8d152SAndre Oppermann KASSERT(inc != NULL, ("tcp_mssopt with NULL in_conninfo pointer")); 3882a0292f23SGarrett Wollman 388331b3783cSHajimu UMEMOTO #ifdef INET6 3884dcdb4371SBjoern A. Zeeb if (inc->inc_flags & INC_ISIPV6) { 3885603724d3SBjoern A. Zeeb mss = V_tcp_v6mssdflt; 3886233dcce1SAndre Oppermann maxmtu = tcp_maxmtu6(inc, NULL); 388797d8d152SAndre Oppermann min_protoh = sizeof(struct ip6_hdr) + sizeof(struct tcphdr); 3888b287c6c7SBjoern A. Zeeb } 388931b3783cSHajimu UMEMOTO #endif 3890b287c6c7SBjoern A. Zeeb #if defined(INET) && defined(INET6) 3891b287c6c7SBjoern A. Zeeb else 3892b287c6c7SBjoern A. Zeeb #endif 3893b287c6c7SBjoern A. Zeeb #ifdef INET 389497d8d152SAndre Oppermann { 3895603724d3SBjoern A. Zeeb mss = V_tcp_mssdflt; 3896233dcce1SAndre Oppermann maxmtu = tcp_maxmtu(inc, NULL); 389797d8d152SAndre Oppermann min_protoh = sizeof(struct tcpiphdr); 389897d8d152SAndre Oppermann } 3899b287c6c7SBjoern A. Zeeb #endif 39003a9391deSBjoern A. Zeeb #if defined(INET6) || defined(INET) 39013a9391deSBjoern A. Zeeb thcmtu = tcp_hc_getmtu(inc); /* IPv4 and IPv6 */ 39023a9391deSBjoern A. Zeeb #endif 39033a9391deSBjoern A. Zeeb 390497d8d152SAndre Oppermann if (maxmtu && thcmtu) 390597d8d152SAndre Oppermann mss = min(maxmtu, thcmtu) - min_protoh; 390697d8d152SAndre Oppermann else if (maxmtu || thcmtu) 390797d8d152SAndre Oppermann mss = max(maxmtu, thcmtu) - min_protoh; 390897d8d152SAndre Oppermann 390997d8d152SAndre Oppermann return (mss); 3910df8bae1dSRodney W. Grimes } 391146f58482SJonathan Lemon 39120e1d7c25SRichard Scheffenegger void 3913*eb3a59a8SRichard Scheffenegger tcp_do_prr_ack(struct tcpcb *tp, struct tcphdr *th) 39140e1d7c25SRichard Scheffenegger { 391548396dc7SRichard Scheffenegger int snd_cnt = 0, limit = 0, del_data = 0, pipe = 0; 39160e1d7c25SRichard Scheffenegger int maxseg = tcp_maxseg(tp); 39170e1d7c25SRichard Scheffenegger 39180e1d7c25SRichard Scheffenegger INP_WLOCK_ASSERT(tp->t_inpcb); 39190e1d7c25SRichard Scheffenegger 39200e1d7c25SRichard Scheffenegger /* 39210e1d7c25SRichard Scheffenegger * Compute the amount of data that this ACK is indicating 39220e1d7c25SRichard Scheffenegger * (del_data) and an estimate of how many bytes are in the 39230e1d7c25SRichard Scheffenegger * network. 39240e1d7c25SRichard Scheffenegger */ 392531d7a27cSRichard Scheffenegger del_data = tp->sackhint.delivered_data; 3926a8e431e1SRichard Scheffenegger if (V_tcp_do_rfc6675_pipe) 3927a8e431e1SRichard Scheffenegger pipe = tcp_compute_pipe(tp); 3928a8e431e1SRichard Scheffenegger else 39290e1d7c25SRichard Scheffenegger pipe = (tp->snd_nxt - tp->snd_fack) + tp->sackhint.sack_bytes_rexmit; 39300e1d7c25SRichard Scheffenegger tp->sackhint.prr_delivered += del_data; 39310e1d7c25SRichard Scheffenegger /* 39320e1d7c25SRichard Scheffenegger * Proportional Rate Reduction 39330e1d7c25SRichard Scheffenegger */ 3934e9071000SRichard Scheffenegger if (pipe >= tp->snd_ssthresh) { 39356a376af0SRichard Scheffenegger if (tp->sackhint.recover_fs == 0) 39366a376af0SRichard Scheffenegger tp->sackhint.recover_fs = 393748396dc7SRichard Scheffenegger imax(1, tp->snd_nxt - tp->snd_una); 393848396dc7SRichard Scheffenegger snd_cnt = howmany((long)tp->sackhint.prr_delivered * 393948396dc7SRichard Scheffenegger tp->snd_ssthresh, tp->sackhint.recover_fs) - 3940e5313869SRichard Scheffenegger tp->sackhint.prr_out; 39416a376af0SRichard Scheffenegger } else { 39420e1d7c25SRichard Scheffenegger if (V_tcp_do_prr_conservative) 394384761f3dSRichard Scheffenegger limit = tp->sackhint.prr_delivered - 3944e5313869SRichard Scheffenegger tp->sackhint.prr_out; 39450e1d7c25SRichard Scheffenegger else 394648396dc7SRichard Scheffenegger limit = imax(tp->sackhint.prr_delivered - 3947e5313869SRichard Scheffenegger tp->sackhint.prr_out, del_data) + 3948e5313869SRichard Scheffenegger maxseg; 394948396dc7SRichard Scheffenegger snd_cnt = imin((tp->snd_ssthresh - pipe), limit); 39500e1d7c25SRichard Scheffenegger } 395148396dc7SRichard Scheffenegger snd_cnt = imax(snd_cnt, 0) / maxseg; 39520e1d7c25SRichard Scheffenegger /* 39530e1d7c25SRichard Scheffenegger * Send snd_cnt new data into the network in response to this ack. 39540e1d7c25SRichard Scheffenegger * If there is going to be a SACK retransmission, adjust snd_cwnd 39550e1d7c25SRichard Scheffenegger * accordingly. 39560e1d7c25SRichard Scheffenegger */ 395748396dc7SRichard Scheffenegger tp->snd_cwnd = imax(maxseg, tp->snd_nxt - tp->snd_recover + 3958853fd7a2SRichard Scheffenegger tp->sackhint.sack_bytes_rexmit + (snd_cnt * maxseg)); 39590e1d7c25SRichard Scheffenegger } 39600e1d7c25SRichard Scheffenegger 396146f58482SJonathan Lemon /* 3962c068736aSJeffrey Hsu * On a partial ack arrives, force the retransmission of the 3963c068736aSJeffrey Hsu * next unacknowledged segment. Do not clear tp->t_dupacks. 3964c068736aSJeffrey Hsu * By setting snd_nxt to ti_ack, this forces retransmission timer to 3965c068736aSJeffrey Hsu * be started again. 396646f58482SJonathan Lemon */ 396755bceb1eSRandall Stewart void 3968ad3f9ab3SAndre Oppermann tcp_newreno_partial_ack(struct tcpcb *tp, struct tcphdr *th) 396946f58482SJonathan Lemon { 397046f58482SJonathan Lemon tcp_seq onxt = tp->snd_nxt; 39713ac12506SJonathan T. Looney uint32_t ocwnd = tp->snd_cwnd; 39720c39d38dSGleb Smirnoff u_int maxseg = tcp_maxseg(tp); 397346f58482SJonathan Lemon 39748501a69cSRobert Watson INP_WLOCK_ASSERT(tp->t_inpcb); 39757a3244ccSRobert Watson 3976b8152ba7SAndre Oppermann tcp_timer_activate(tp, TT_REXMT, 0); 397746f58482SJonathan Lemon tp->t_rtttime = 0; 397846f58482SJonathan Lemon tp->snd_nxt = th->th_ack; 39796b2a5f92SJayanth Vijayaraghavan /* 3980c068736aSJeffrey Hsu * Set snd_cwnd to one segment beyond acknowledged offset. 3981c068736aSJeffrey Hsu * (tp->snd_una has not yet been updated when this function is called.) 39826b2a5f92SJayanth Vijayaraghavan */ 39830c39d38dSGleb Smirnoff tp->snd_cwnd = maxseg + BYTES_THIS_ACK(tp, th); 3984a84db8f4SMatthew Dillon tp->t_flags |= TF_ACKNOW; 398555bceb1eSRandall Stewart (void) tp->t_fb->tfb_tcp_output(tp); 398646f58482SJonathan Lemon tp->snd_cwnd = ocwnd; 398746f58482SJonathan Lemon if (SEQ_GT(onxt, tp->snd_nxt)) 398846f58482SJonathan Lemon tp->snd_nxt = onxt; 398946f58482SJonathan Lemon /* 399046f58482SJonathan Lemon * Partial window deflation. Relies on fact that tp->snd_una 399146f58482SJonathan Lemon * not updated yet. 399246f58482SJonathan Lemon */ 3993dbc42409SLawrence Stewart if (tp->snd_cwnd > BYTES_THIS_ACK(tp, th)) 3994dbc42409SLawrence Stewart tp->snd_cwnd -= BYTES_THIS_ACK(tp, th); 3995d7587117SPaul Saab else 3996d7587117SPaul Saab tp->snd_cwnd = 0; 39970c39d38dSGleb Smirnoff tp->snd_cwnd += maxseg; 399846f58482SJonathan Lemon } 399912eeb81fSHiren Panchasara 400012eeb81fSHiren Panchasara int 400112eeb81fSHiren Panchasara tcp_compute_pipe(struct tcpcb *tp) 400212eeb81fSHiren Panchasara { 400312eeb81fSHiren Panchasara return (tp->snd_max - tp->snd_una + 400412eeb81fSHiren Panchasara tp->sackhint.sack_bytes_rexmit - 400512eeb81fSHiren Panchasara tp->sackhint.sacked_bytes); 400612eeb81fSHiren Panchasara } 40077dc90a1dSMichael Tuexen 40087dc90a1dSMichael Tuexen uint32_t 40097dc90a1dSMichael Tuexen tcp_compute_initwnd(uint32_t maxseg) 40107dc90a1dSMichael Tuexen { 40117dc90a1dSMichael Tuexen /* 40127dc90a1dSMichael Tuexen * Calculate the Initial Window, also used as Restart Window 40137dc90a1dSMichael Tuexen * 40147dc90a1dSMichael Tuexen * RFC5681 Section 3.1 specifies the default conservative values. 40157dc90a1dSMichael Tuexen * RFC3390 specifies slightly more aggressive values. 40167dc90a1dSMichael Tuexen * RFC6928 increases it to ten segments. 40177dc90a1dSMichael Tuexen * Support for user specified value for initial flight size. 40187dc90a1dSMichael Tuexen */ 40197dc90a1dSMichael Tuexen if (V_tcp_initcwnd_segments) 40207dc90a1dSMichael Tuexen return min(V_tcp_initcwnd_segments * maxseg, 40217dc90a1dSMichael Tuexen max(2 * maxseg, V_tcp_initcwnd_segments * 1460)); 40227dc90a1dSMichael Tuexen else if (V_tcp_do_rfc3390) 40237dc90a1dSMichael Tuexen return min(4 * maxseg, max(2 * maxseg, 4380)); 40247dc90a1dSMichael Tuexen else { 40257dc90a1dSMichael Tuexen /* Per RFC5681 Section 3.1 */ 40267dc90a1dSMichael Tuexen if (maxseg > 2190) 40277dc90a1dSMichael Tuexen return (2 * maxseg); 40287dc90a1dSMichael Tuexen else if (maxseg > 1095) 40297dc90a1dSMichael Tuexen return (3 * maxseg); 40307dc90a1dSMichael Tuexen else 40317dc90a1dSMichael Tuexen return (4 * maxseg); 40327dc90a1dSMichael Tuexen } 40337dc90a1dSMichael Tuexen } 4034