sys/netinet/tcp_timewait.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #include "opt_inet.h"
  34 #include "opt_inet6.h"
  35 #include "opt_ipsec.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/callout.h>
  40 #include <sys/kernel.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/malloc.h>
  43 #include <sys/mbuf.h>
  44 #include <sys/priv.h>
  45 #include <sys/proc.h>
  46 #include <sys/socket.h>
  47 #include <sys/socketvar.h>
  48 #include <sys/syslog.h>
  49 #include <sys/protosw.h>
  50 #include <sys/random.h>
  51
  52 #include <vm/uma.h>
  53
  54 #include <net/route.h>
  55 #include <net/if.h>
  56 #include <net/if_var.h>
  57 #include <net/vnet.h>
  58
  59 #include <netinet/in.h>
  60 #include <netinet/in_kdtrace.h>
  61 #include <netinet/in_pcb.h>
  62 #include <netinet/in_systm.h>
  63 #include <netinet/in_var.h>
  64 #include <netinet/ip.h>
  65 #include <netinet/ip_icmp.h>
  66 #include <netinet/ip_var.h>
  67 #ifdef INET6
  68 #include <netinet/ip6.h>
  69 #include <netinet6/in6_pcb.h>
  70 #include <netinet6/ip6_var.h>
  71 #include <netinet6/scope6_var.h>
  72 #include <netinet6/nd6.h>
  73 #endif
  74 #include <netinet/tcp.h>
  75 #include <netinet/tcp_fsm.h>
  76 #include <netinet/tcp_seq.h>
  77 #include <netinet/tcp_timer.h>
  78 #include <netinet/tcp_var.h>
  79 #include <netinet/tcpip.h>
  80
  81 #include <netinet/udp.h>
  82 #include <netinet/udp_var.h>
  83
  84 #include <netipsec/ipsec_support.h>
  85
  86 #include <machine/in_cksum.h>
  87
  88 #include <security/mac/mac_framework.h>
  89
  90 VNET_DEFINE_STATIC(bool, nolocaltimewait) = true;
  91 #define V_nolocaltimewait       VNET(nolocaltimewait)
  92 SYSCTL_BOOL(_net_inet_tcp, OID_AUTO, nolocaltimewait,
  93     CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nolocaltimewait), true,
  94     "Do not create TCP TIME_WAIT state for local connections");
  95
  96 /*
  97  * Move a TCP connection into TIME_WAIT state.
  98  *    inp is locked, and is unlocked before returning.
  99  *
 100  * This function used to free tcpcb and allocate a compressed TCP time-wait
 101  * structure tcptw.  This served well for 20 years but is no longer relevant
 102  * on modern machines in the modern internet.  However, the function remains
 103  * so that TCP stacks require less modification and we don't burn the bridge
 104  * to go back to using compressed time-wait.
 105  */
 106 void
 107 tcp_twstart(struct tcpcb *tp)
 108 {
 109         struct inpcb *inp = tptoinpcb(tp);
 110 #ifdef INET6
 111         bool isipv6 = inp->inp_inc.inc_flags & INC_ISIPV6;
 112 #endif
 113
 114         NET_EPOCH_ASSERT();
 115         INP_WLOCK_ASSERT(inp);
 116
 117         /* A dropped inp should never transition to TIME_WAIT state. */
 118         KASSERT((inp->inp_flags & INP_DROPPED) == 0, ("tcp_twstart: "
 119             "(inp->inp_flags & INP_DROPPED) != 0"));
 120
 121         tcp_state_change(tp, TCPS_TIME_WAIT);
 122         tcp_free_sackholes(tp);
 123         soisdisconnected(inp->inp_socket);
 124
 125         if (tp->t_flags & TF_ACKNOW)
 126                 (void) tcp_output(tp);
 127
 128         if (V_nolocaltimewait && (
 129 #ifdef INET6
 130             isipv6 ? in6_localaddr(&inp->in6p_faddr) :
 131 #endif
 132 #ifdef INET
 133             in_localip(inp->inp_faddr)
 134 #else
 135             false
 136 #endif
 137             )) {
 138                 if ((tp = tcp_close(tp)) != NULL)
 139                         INP_WUNLOCK(inp);
 140                 return;
 141         }
 142
 143         tcp_timer_activate(tp, TT_2MSL, 2 * V_tcp_msl);
 144         INP_WUNLOCK(inp);
 145 }
 146
 147 /*
 148  * Returns true if the TIME_WAIT state was killed and we should start over,
 149  * looking for a pcb in the listen state.  Otherwise returns false and frees
 150  * the mbuf.
 151  *
 152  * For pure SYN-segments the PCB shall be read-locked and the tcpopt pointer
 153  * may be NULL.  For the rest write-lock and valid tcpopt.
 154  */
 155 bool
 156 tcp_twcheck(struct inpcb *inp, struct tcpopt *to, struct tcphdr *th,
 157     struct mbuf *m, int tlen)
 158 {
 159         struct tcpcb *tp = intotcpcb(inp);
 160         char *s;
 161         int thflags;
 162         tcp_seq seq;
 163
 164         NET_EPOCH_ASSERT();
 165         INP_LOCK_ASSERT(inp);
 166
 167         thflags = tcp_get_flags(th);
 168 #ifdef INVARIANTS
 169         if ((thflags & (TH_SYN | TH_ACK)) == TH_SYN)
 170                 INP_RLOCK_ASSERT(inp);
 171         else {
 172                 INP_WLOCK_ASSERT(inp);
 173                 KASSERT(to != NULL,
 174                     ("%s: called without options on a non-SYN segment",
 175                     __func__));
 176         }
 177 #endif
 178
 179         /*
 180          * NOTE: for FIN_WAIT_2 (to be added later),
 181          * must validate sequence number before accepting RST
 182          */
 183
 184         /*
 185          * If the segment contains RST:
 186          *      Drop the segment - see Stevens, vol. 2, p. 964 and
 187          *      RFC 1337.
 188          */
 189         if (thflags & TH_RST)
 190                 goto drop;
 191
 192 #if 0
 193 /* PAWS not needed at the moment */
 194         /*
 195          * RFC 1323 PAWS: If we have a timestamp reply on this segment
 196          * and it's less than ts_recent, drop it.
 197          */
 198         if ((to.to_flags & TOF_TS) != 0 && tp->ts_recent &&
 199             TSTMP_LT(to.to_tsval, tp->ts_recent)) {
 200                 if ((thflags & TH_ACK) == 0)
 201                         goto drop;
 202                 goto ack;
 203         }
 204         /*
 205          * ts_recent is never updated because we never accept new segments.
 206          */
 207 #endif
 208
 209         /* Honor the drop_synfin sysctl variable. */
 210         if ((thflags & TH_SYN) && (thflags & TH_FIN) && V_drop_synfin) {
 211                 if ((s = tcp_log_addrs(&inp->inp_inc, th, NULL, NULL))) {
 212                         log(LOG_DEBUG, "%s; %s: "
 213                             "SYN|FIN segment ignored (based on "
 214                             "sysctl setting)\n", s, __func__);
 215                         free(s, M_TCPLOG);
 216                 }
 217                 goto drop;
 218         }
 219
 220         /*
 221          * If a new connection request is received
 222          * while in TIME_WAIT, drop the old connection
 223          * and start over if the sequence numbers
 224          * are above the previous ones.
 225          * Allow UDP port number changes in this case.
 226          */
 227         if (((thflags & (TH_SYN | TH_ACK)) == TH_SYN) &&
 228             SEQ_GT(th->th_seq, tp->rcv_nxt)) {
 229                 /*
 230                  * In case we can't upgrade our lock just pretend we have
 231                  * lost this packet.
 232                  */
 233                 if (INP_TRY_UPGRADE(inp) == 0)
 234                         goto drop;
 235                 if ((tp = tcp_close(tp)) != NULL)
 236                         INP_WUNLOCK(inp);
 237                 TCPSTAT_INC(tcps_tw_recycles);
 238                 return (true);
 239         }
 240
 241         /*
 242          * Send RST if UDP port numbers don't match
 243          */
 244         if (tp->t_port != m->m_pkthdr.tcp_tun_port) {
 245                 if (tcp_get_flags(th) & TH_ACK) {
 246                         tcp_respond(tp, mtod(m, void *), th, m,
 247                             (tcp_seq)0, th->th_ack, TH_RST);
 248                 } else {
 249                         if (tcp_get_flags(th) & TH_SYN)
 250                                 tlen++;
 251                         if (tcp_get_flags(th) & TH_FIN)
 252                                 tlen++;
 253                         tcp_respond(tp, mtod(m, void *), th, m,
 254                             th->th_seq+tlen, (tcp_seq)0, TH_RST|TH_ACK);
 255                 }
 256                 INP_UNLOCK(inp);
 257                 TCPSTAT_INC(tcps_tw_resets);
 258                 return (false);
 259         }
 260
 261         /*
 262          * Drop the segment if it does not contain an ACK.
 263          */
 264         if ((thflags & TH_ACK) == 0)
 265                 goto drop;
 266
 267         INP_WLOCK_ASSERT(inp);
 268
 269         /*
 270          * If timestamps were negotiated during SYN/ACK and a
 271          * segment without a timestamp is received, silently drop
 272          * the segment, unless the missing timestamps are tolerated.
 273          * See section 3.2 of RFC 7323.
 274          */
 275         if (((to->to_flags & TOF_TS) == 0) && (tp->ts_recent != 0) &&
 276             (V_tcp_tolerate_missing_ts == 0)) {
 277                 goto drop;
 278         }
 279
 280         /*
 281          * Reset the 2MSL timer if this is a duplicate FIN.
 282          */
 283         if (thflags & TH_FIN) {
 284                 seq = th->th_seq + tlen + (thflags & TH_SYN ? 1 : 0);
 285                 if (seq + 1 == tp->rcv_nxt)
 286                         tcp_timer_activate(tp, TT_2MSL, 2 * V_tcp_msl);
 287         }
 288
 289         /*
 290          * Acknowledge the segment if it has data or is not a duplicate ACK.
 291          */
 292         if (thflags != TH_ACK || tlen != 0 ||
 293             th->th_seq != tp->rcv_nxt || th->th_ack != tp->snd_nxt) {
 294                 TCP_PROBE5(receive, NULL, NULL, m, NULL, th);
 295                 tcp_respond(tp, mtod(m, void *), th, m, tp->rcv_nxt,
 296                     tp->snd_nxt, TH_ACK);
 297                 INP_UNLOCK(inp);
 298                 TCPSTAT_INC(tcps_tw_responds);
 299                 return (false);
 300         }
 301 drop:
 302         TCP_PROBE5(receive, NULL, NULL, m, NULL, th);
 303         INP_UNLOCK(inp);
 304         m_freem(m);
 305         return (false);
 306 }