sys/netinet/tcp_subr.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  *      @(#)tcp_subr.c  8.2 (Berkeley) 5/24/95
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "opt_inet.h"
  38 #include "opt_inet6.h"
  39 #include "opt_ipsec.h"
  40 #include "opt_kern_tls.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/arb.h>
  45 #include <sys/callout.h>
  46 #include <sys/eventhandler.h>
  47 #ifdef TCP_HHOOK
  48 #include <sys/hhook.h>
  49 #endif
  50 #include <sys/kernel.h>
  51 #ifdef TCP_HHOOK
  52 #include <sys/khelp.h>
  53 #endif
  54 #ifdef KERN_TLS
  55 #include <sys/ktls.h>
  56 #endif
  57 #include <sys/qmath.h>
  58 #include <sys/stats.h>
  59 #include <sys/sysctl.h>
  60 #include <sys/jail.h>
  61 #include <sys/malloc.h>
  62 #include <sys/refcount.h>
  63 #include <sys/mbuf.h>
  64 #include <sys/priv.h>
  65 #include <sys/proc.h>
  66 #include <sys/sdt.h>
  67 #include <sys/socket.h>
  68 #include <sys/socketvar.h>
  69 #include <sys/protosw.h>
  70 #include <sys/random.h>
  71
  72 #include <vm/uma.h>
  73
  74 #include <net/route.h>
  75 #include <net/route/nhop.h>
  76 #include <net/if.h>
  77 #include <net/if_var.h>
  78 #include <net/if_private.h>
  79 #include <net/vnet.h>
  80
  81 #include <netinet/in.h>
  82 #include <netinet/in_fib.h>
  83 #include <netinet/in_kdtrace.h>
  84 #include <netinet/in_pcb.h>
  85 #include <netinet/in_systm.h>
  86 #include <netinet/in_var.h>
  87 #include <netinet/ip.h>
  88 #include <netinet/ip_icmp.h>
  89 #include <netinet/ip_var.h>
  90 #ifdef INET6
  91 #include <netinet/icmp6.h>
  92 #include <netinet/ip6.h>
  93 #include <netinet6/in6_fib.h>
  94 #include <netinet6/in6_pcb.h>
  95 #include <netinet6/ip6_var.h>
  96 #include <netinet6/scope6_var.h>
  97 #include <netinet6/nd6.h>
  98 #endif
  99
 100 #include <netinet/tcp.h>
 101 #ifdef INVARIANTS
 102 #define TCPSTATES
 103 #endif
 104 #include <netinet/tcp_fsm.h>
 105 #include <netinet/tcp_seq.h>
 106 #include <netinet/tcp_timer.h>
 107 #include <netinet/tcp_var.h>
 108 #include <netinet/tcp_ecn.h>
 109 #include <netinet/tcp_log_buf.h>
 110 #include <netinet/tcp_syncache.h>
 111 #include <netinet/tcp_hpts.h>
 112 #include <netinet/cc/cc.h>
 113 #include <netinet/tcpip.h>
 114 #include <netinet/tcp_fastopen.h>
 115 #ifdef TCPPCAP
 116 #include <netinet/tcp_pcap.h>
 117 #endif
 118 #ifdef TCP_OFFLOAD
 119 #include <netinet/tcp_offload.h>
 120 #endif
 121 #include <netinet/udp.h>
 122 #include <netinet/udp_var.h>
 123 #ifdef INET6
 124 #include <netinet6/tcp6_var.h>
 125 #endif
 126
 127 #include <netipsec/ipsec_support.h>
 128
 129 #include <machine/in_cksum.h>
 130 #include <crypto/siphash/siphash.h>
 131
 132 #include <security/mac/mac_framework.h>
 133
 134 #ifdef INET6
 135 static ip6proto_ctlinput_t tcp6_ctlinput;
 136 static udp_tun_icmp_t tcp6_ctlinput_viaudp;
 137 #endif
 138
 139 VNET_DEFINE(int, tcp_mssdflt) = TCP_MSS;
 140 #ifdef INET6
 141 VNET_DEFINE(int, tcp_v6mssdflt) = TCP6_MSS;
 142 #endif
 143
 144 #ifdef NETFLIX_EXP_DETECTION
 145 /*  Sack attack detection thresholds and such */
 146 SYSCTL_NODE(_net_inet_tcp, OID_AUTO, sack_attack,
 147     CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 148     "Sack Attack detection thresholds");
 149 int32_t tcp_force_detection = 0;
 150 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, force_detection,
 151     CTLFLAG_RW,
 152     &tcp_force_detection, 0,
 153     "Do we force detection even if the INP has it off?");
 154 int32_t tcp_sack_to_ack_thresh = 700;   /* 70 % */
 155 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sack_to_ack_thresh,
 156     CTLFLAG_RW,
 157     &tcp_sack_to_ack_thresh, 700,
 158     "Percentage of sacks to acks we must see above (10.1 percent is 101)?");
 159 int32_t tcp_sack_to_move_thresh = 600;  /* 60 % */
 160 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, move_thresh,
 161     CTLFLAG_RW,
 162     &tcp_sack_to_move_thresh, 600,
 163     "Percentage of sack moves we must see above (10.1 percent is 101)");
 164 int32_t tcp_restoral_thresh = 650;      /* 65 % (sack:2:ack -5%) */
 165 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, restore_thresh,
 166     CTLFLAG_RW,
 167     &tcp_restoral_thresh, 550,
 168     "Percentage of sack to ack percentage we must see below to restore(10.1 percent is 101)");
 169 int32_t tcp_sad_decay_val = 800;
 170 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, decay_per,
 171     CTLFLAG_RW,
 172     &tcp_sad_decay_val, 800,
 173     "The decay percentage (10.1 percent equals 101 )");
 174 int32_t tcp_map_minimum = 500;
 175 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, nummaps,
 176     CTLFLAG_RW,
 177     &tcp_map_minimum, 500,
 178     "Number of Map enteries before we start detection");
 179 int32_t tcp_attack_on_turns_on_logging = 0;
 180 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, attacks_logged,
 181     CTLFLAG_RW,
 182     &tcp_attack_on_turns_on_logging, 0,
 183    "When we have a positive hit on attack, do we turn on logging?");
 184 int32_t tcp_sad_pacing_interval = 2000;
 185 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sad_pacing_int,
 186     CTLFLAG_RW,
 187     &tcp_sad_pacing_interval, 2000,
 188     "What is the minimum pacing interval for a classified attacker?");
 189
 190 int32_t tcp_sad_low_pps = 100;
 191 SYSCTL_INT(_net_inet_tcp_sack_attack, OID_AUTO, sad_low_pps,
 192     CTLFLAG_RW,
 193     &tcp_sad_low_pps, 100,
 194     "What is the input pps that below which we do not decay?");
 195 #endif
 196 uint32_t tcp_ack_war_time_window = 1000;
 197 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, ack_war_timewindow,
 198     CTLFLAG_RW,
 199     &tcp_ack_war_time_window, 1000,
 200    "If the tcp_stack does ack-war prevention how many milliseconds are in its time window?");
 201 uint32_t tcp_ack_war_cnt = 5;
 202 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, ack_war_cnt,
 203     CTLFLAG_RW,
 204     &tcp_ack_war_cnt, 5,
 205    "If the tcp_stack does ack-war prevention how many acks can be sent in its time window?");
 206
 207 struct rwlock tcp_function_lock;
 208
 209 static int
 210 sysctl_net_inet_tcp_mss_check(SYSCTL_HANDLER_ARGS)
 211 {
 212         int error, new;
 213
 214         new = V_tcp_mssdflt;
 215         error = sysctl_handle_int(oidp, &new, 0, req);
 216         if (error == 0 && req->newptr) {
 217                 if (new < TCP_MINMSS)
 218                         error = EINVAL;
 219                 else
 220                         V_tcp_mssdflt = new;
 221         }
 222         return (error);
 223 }
 224
 225 SYSCTL_PROC(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt,
 226     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 227     &VNET_NAME(tcp_mssdflt), 0, &sysctl_net_inet_tcp_mss_check, "I",
 228     "Default TCP Maximum Segment Size");
 229
 230 #ifdef INET6
 231 static int
 232 sysctl_net_inet_tcp_mss_v6_check(SYSCTL_HANDLER_ARGS)
 233 {
 234         int error, new;
 235
 236         new = V_tcp_v6mssdflt;
 237         error = sysctl_handle_int(oidp, &new, 0, req);
 238         if (error == 0 && req->newptr) {
 239                 if (new < TCP_MINMSS)
 240                         error = EINVAL;
 241                 else
 242                         V_tcp_v6mssdflt = new;
 243         }
 244         return (error);
 245 }
 246
 247 SYSCTL_PROC(_net_inet_tcp, TCPCTL_V6MSSDFLT, v6mssdflt,
 248     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 249     &VNET_NAME(tcp_v6mssdflt), 0, &sysctl_net_inet_tcp_mss_v6_check, "I",
 250    "Default TCP Maximum Segment Size for IPv6");
 251 #endif /* INET6 */
 252
 253 /*
 254  * Minimum MSS we accept and use. This prevents DoS attacks where
 255  * we are forced to a ridiculous low MSS like 20 and send hundreds
 256  * of packets instead of one. The effect scales with the available
 257  * bandwidth and quickly saturates the CPU and network interface
 258  * with packet generation and sending. Set to zero to disable MINMSS
 259  * checking. This setting prevents us from sending too small packets.
 260  */
 261 VNET_DEFINE(int, tcp_minmss) = TCP_MINMSS;
 262 SYSCTL_INT(_net_inet_tcp, OID_AUTO, minmss, CTLFLAG_VNET | CTLFLAG_RW,
 263      &VNET_NAME(tcp_minmss), 0,
 264     "Minimum TCP Maximum Segment Size");
 265
 266 VNET_DEFINE(int, tcp_do_rfc1323) = 1;
 267 SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, CTLFLAG_VNET | CTLFLAG_RW,
 268     &VNET_NAME(tcp_do_rfc1323), 0,
 269     "Enable rfc1323 (high performance TCP) extensions");
 270
 271 /*
 272  * As of June 2021, several TCP stacks violate RFC 7323 from September 2014.
 273  * Some stacks negotiate TS, but never send them after connection setup. Some
 274  * stacks negotiate TS, but don't send them when sending keep-alive segments.
 275  * These include modern widely deployed TCP stacks.
 276  * Therefore tolerating violations for now...
 277  */
 278 VNET_DEFINE(int, tcp_tolerate_missing_ts) = 1;
 279 SYSCTL_INT(_net_inet_tcp, OID_AUTO, tolerate_missing_ts, CTLFLAG_VNET | CTLFLAG_RW,
 280     &VNET_NAME(tcp_tolerate_missing_ts), 0,
 281     "Tolerate missing TCP timestamps");
 282
 283 VNET_DEFINE(int, tcp_ts_offset_per_conn) = 1;
 284 SYSCTL_INT(_net_inet_tcp, OID_AUTO, ts_offset_per_conn, CTLFLAG_VNET | CTLFLAG_RW,
 285     &VNET_NAME(tcp_ts_offset_per_conn), 0,
 286     "Initialize TCP timestamps per connection instead of per host pair");
 287
 288 /* How many connections are pacing */
 289 static volatile uint32_t number_of_tcp_connections_pacing = 0;
 290 static uint32_t shadow_num_connections = 0;
 291
 292 static int tcp_pacing_limit = 10000;
 293 SYSCTL_INT(_net_inet_tcp, OID_AUTO, pacing_limit, CTLFLAG_RW,
 294     &tcp_pacing_limit, 1000,
 295     "If the TCP stack does pacing, is there a limit (-1 = no, 0 = no pacing N = number of connections)");
 296
 297 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, pacing_count, CTLFLAG_RD,
 298     &shadow_num_connections, 0, "Number of TCP connections being paced");
 299
 300 static int      tcp_log_debug = 0;
 301 SYSCTL_INT(_net_inet_tcp, OID_AUTO, log_debug, CTLFLAG_RW,
 302     &tcp_log_debug, 0, "Log errors caused by incoming TCP segments");
 303
 304 static int      tcp_tcbhashsize;
 305 SYSCTL_INT(_net_inet_tcp, OID_AUTO, tcbhashsize, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
 306     &tcp_tcbhashsize, 0, "Size of TCP control-block hashtable");
 307
 308 static int      do_tcpdrain = 1;
 309 SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_tcpdrain, CTLFLAG_RW, &do_tcpdrain, 0,
 310     "Enable tcp_drain routine for extra help when low on mbufs");
 311
 312 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_VNET | CTLFLAG_RD,
 313     &VNET_NAME(tcbinfo.ipi_count), 0, "Number of active PCBs");
 314
 315 VNET_DEFINE_STATIC(int, icmp_may_rst) = 1;
 316 #define V_icmp_may_rst                  VNET(icmp_may_rst)
 317 SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_may_rst, CTLFLAG_VNET | CTLFLAG_RW,
 318     &VNET_NAME(icmp_may_rst), 0,
 319     "Certain ICMP unreachable messages may abort connections in SYN_SENT");
 320
 321 VNET_DEFINE_STATIC(int, tcp_isn_reseed_interval) = 0;
 322 #define V_tcp_isn_reseed_interval       VNET(tcp_isn_reseed_interval)
 323 SYSCTL_INT(_net_inet_tcp, OID_AUTO, isn_reseed_interval, CTLFLAG_VNET | CTLFLAG_RW,
 324     &VNET_NAME(tcp_isn_reseed_interval), 0,
 325     "Seconds between reseeding of ISN secret");
 326
 327 static int      tcp_soreceive_stream;
 328 SYSCTL_INT(_net_inet_tcp, OID_AUTO, soreceive_stream, CTLFLAG_RDTUN,
 329     &tcp_soreceive_stream, 0, "Using soreceive_stream for TCP sockets");
 330
 331 VNET_DEFINE(uma_zone_t, sack_hole_zone);
 332 #define V_sack_hole_zone                VNET(sack_hole_zone)
 333 VNET_DEFINE(uint32_t, tcp_map_entries_limit) = 0;       /* unlimited */
 334 static int
 335 sysctl_net_inet_tcp_map_limit_check(SYSCTL_HANDLER_ARGS)
 336 {
 337         int error;
 338         uint32_t new;
 339
 340         new = V_tcp_map_entries_limit;
 341         error = sysctl_handle_int(oidp, &new, 0, req);
 342         if (error == 0 && req->newptr) {
 343                 /* only allow "0" and value > minimum */
 344                 if (new > 0 && new < TCP_MIN_MAP_ENTRIES_LIMIT)
 345                         error = EINVAL;
 346                 else
 347                         V_tcp_map_entries_limit = new;
 348         }
 349         return (error);
 350 }
 351 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, map_limit,
 352     CTLFLAG_VNET | CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 353     &VNET_NAME(tcp_map_entries_limit), 0,
 354     &sysctl_net_inet_tcp_map_limit_check, "IU",
 355     "Total sendmap entries limit");
 356
 357 VNET_DEFINE(uint32_t, tcp_map_split_limit) = 0; /* unlimited */
 358 SYSCTL_UINT(_net_inet_tcp, OID_AUTO, split_limit, CTLFLAG_VNET | CTLFLAG_RW,
 359      &VNET_NAME(tcp_map_split_limit), 0,
 360     "Total sendmap split entries limit");
 361
 362 #ifdef TCP_HHOOK
 363 VNET_DEFINE(struct hhook_head *, tcp_hhh[HHOOK_TCP_LAST+1]);
 364 #endif
 365
 366 #define TS_OFFSET_SECRET_LENGTH SIPHASH_KEY_LENGTH
 367 VNET_DEFINE_STATIC(u_char, ts_offset_secret[TS_OFFSET_SECRET_LENGTH]);
 368 #define V_ts_offset_secret      VNET(ts_offset_secret)
 369
 370 static int      tcp_default_fb_init(struct tcpcb *tp);
 371 static void     tcp_default_fb_fini(struct tcpcb *tp, int tcb_is_purged);
 372 static int      tcp_default_handoff_ok(struct tcpcb *tp);
 373 static struct inpcb *tcp_notify(struct inpcb *, int);
 374 static struct inpcb *tcp_mtudisc_notify(struct inpcb *, int);
 375 static struct inpcb *tcp_mtudisc(struct inpcb *, int);
 376 static struct inpcb *tcp_drop_syn_sent(struct inpcb *, int);
 377 static char *   tcp_log_addr(struct in_conninfo *inc, struct tcphdr *th,
 378                     const void *ip4hdr, const void *ip6hdr);
 379 static ipproto_ctlinput_t       tcp_ctlinput;
 380 static udp_tun_icmp_t           tcp_ctlinput_viaudp;
 381
 382 static struct tcp_function_block tcp_def_funcblk = {
 383         .tfb_tcp_block_name = "freebsd",
 384         .tfb_tcp_output = tcp_default_output,
 385         .tfb_tcp_do_segment = tcp_do_segment,
 386         .tfb_tcp_ctloutput = tcp_default_ctloutput,
 387         .tfb_tcp_handoff_ok = tcp_default_handoff_ok,
 388         .tfb_tcp_fb_init = tcp_default_fb_init,
 389         .tfb_tcp_fb_fini = tcp_default_fb_fini,
 390 };
 391
 392 static int tcp_fb_cnt = 0;
 393 struct tcp_funchead t_functions;
 394 static struct tcp_function_block *tcp_func_set_ptr = &tcp_def_funcblk;
 395
 396 void
 397 tcp_record_dsack(struct tcpcb *tp, tcp_seq start, tcp_seq end, int tlp)
 398 {
 399         TCPSTAT_INC(tcps_dsack_count);
 400         tp->t_dsack_pack++;
 401         if (tlp == 0) {
 402                 if (SEQ_GT(end, start)) {
 403                         tp->t_dsack_bytes += (end - start);
 404                         TCPSTAT_ADD(tcps_dsack_bytes, (end - start));
 405                 } else {
 406                         tp->t_dsack_tlp_bytes += (start - end);
 407                         TCPSTAT_ADD(tcps_dsack_bytes, (start - end));
 408                 }
 409         } else {
 410                 if (SEQ_GT(end, start)) {
 411                         tp->t_dsack_bytes += (end - start);
 412                         TCPSTAT_ADD(tcps_dsack_tlp_bytes, (end - start));
 413                 } else {
 414                         tp->t_dsack_tlp_bytes += (start - end);
 415                         TCPSTAT_ADD(tcps_dsack_tlp_bytes, (start - end));
 416                 }
 417         }
 418 }
 419
 420 static struct tcp_function_block *
 421 find_tcp_functions_locked(struct tcp_function_set *fs)
 422 {
 423         struct tcp_function *f;
 424         struct tcp_function_block *blk=NULL;
 425
 426         TAILQ_FOREACH(f, &t_functions, tf_next) {
 427                 if (strcmp(f->tf_name, fs->function_set_name) == 0) {
 428                         blk = f->tf_fb;
 429                         break;
 430                 }
 431         }
 432         return(blk);
 433 }
 434
 435 static struct tcp_function_block *
 436 find_tcp_fb_locked(struct tcp_function_block *blk, struct tcp_function **s)
 437 {
 438         struct tcp_function_block *rblk=NULL;
 439         struct tcp_function *f;
 440
 441         TAILQ_FOREACH(f, &t_functions, tf_next) {
 442                 if (f->tf_fb == blk) {
 443                         rblk = blk;
 444                         if (s) {
 445                                 *s = f;
 446                         }
 447                         break;
 448                 }
 449         }
 450         return (rblk);
 451 }
 452
 453 struct tcp_function_block *
 454 find_and_ref_tcp_functions(struct tcp_function_set *fs)
 455 {
 456         struct tcp_function_block *blk;
 457
 458         rw_rlock(&tcp_function_lock);
 459         blk = find_tcp_functions_locked(fs);
 460         if (blk)
 461                 refcount_acquire(&blk->tfb_refcnt);
 462         rw_runlock(&tcp_function_lock);
 463         return(blk);
 464 }
 465
 466 struct tcp_function_block *
 467 find_and_ref_tcp_fb(struct tcp_function_block *blk)
 468 {
 469         struct tcp_function_block *rblk;
 470
 471         rw_rlock(&tcp_function_lock);
 472         rblk = find_tcp_fb_locked(blk, NULL);
 473         if (rblk)
 474                 refcount_acquire(&rblk->tfb_refcnt);
 475         rw_runlock(&tcp_function_lock);
 476         return(rblk);
 477 }
 478
 479 /* Find a matching alias for the given tcp_function_block. */
 480 int
 481 find_tcp_function_alias(struct tcp_function_block *blk,
 482     struct tcp_function_set *fs)
 483 {
 484         struct tcp_function *f;
 485         int found;
 486
 487         found = 0;
 488         rw_rlock(&tcp_function_lock);
 489         TAILQ_FOREACH(f, &t_functions, tf_next) {
 490                 if ((f->tf_fb == blk) &&
 491                     (strncmp(f->tf_name, blk->tfb_tcp_block_name,
 492                         TCP_FUNCTION_NAME_LEN_MAX) != 0)) {
 493                         /* Matching function block with different name. */
 494                         strncpy(fs->function_set_name, f->tf_name,
 495                             TCP_FUNCTION_NAME_LEN_MAX);
 496                         found = 1;
 497                         break;
 498                 }
 499         }
 500         /* Null terminate the string appropriately. */
 501         if (found) {
 502                 fs->function_set_name[TCP_FUNCTION_NAME_LEN_MAX - 1] = '\0';
 503         } else {
 504                 fs->function_set_name[0] = '\0';
 505         }
 506         rw_runlock(&tcp_function_lock);
 507         return (found);
 508 }
 509
 510 static struct tcp_function_block *
 511 find_and_ref_tcp_default_fb(void)
 512 {
 513         struct tcp_function_block *rblk;
 514
 515         rw_rlock(&tcp_function_lock);
 516         rblk = tcp_func_set_ptr;
 517         refcount_acquire(&rblk->tfb_refcnt);
 518         rw_runlock(&tcp_function_lock);
 519         return (rblk);
 520 }
 521
 522 void
 523 tcp_switch_back_to_default(struct tcpcb *tp)
 524 {
 525         struct tcp_function_block *tfb;
 526
 527         KASSERT(tp->t_fb != &tcp_def_funcblk,
 528             ("%s: called by the built-in default stack", __func__));
 529
 530         /*
 531          * Release the old stack. This function will either find a new one
 532          * or panic.
 533          */
 534         if (tp->t_fb->tfb_tcp_fb_fini != NULL)
 535                 (*tp->t_fb->tfb_tcp_fb_fini)(tp, 0);
 536         refcount_release(&tp->t_fb->tfb_refcnt);
 537
 538         /*
 539          * Now, we'll find a new function block to use.
 540          * Start by trying the current user-selected
 541          * default, unless this stack is the user-selected
 542          * default.
 543          */
 544         tfb = find_and_ref_tcp_default_fb();
 545         if (tfb == tp->t_fb) {
 546                 refcount_release(&tfb->tfb_refcnt);
 547                 tfb = NULL;
 548         }
 549         /* Does the stack accept this connection? */
 550         if (tfb != NULL && tfb->tfb_tcp_handoff_ok != NULL &&
 551             (*tfb->tfb_tcp_handoff_ok)(tp)) {
 552                 refcount_release(&tfb->tfb_refcnt);
 553                 tfb = NULL;
 554         }
 555         /* Try to use that stack. */
 556         if (tfb != NULL) {
 557                 /* Initialize the new stack. If it succeeds, we are done. */
 558                 tp->t_fb = tfb;
 559                 if (tp->t_fb->tfb_tcp_fb_init == NULL ||
 560                     (*tp->t_fb->tfb_tcp_fb_init)(tp) == 0)
 561                         return;
 562
 563                 /*
 564                  * Initialization failed. Release the reference count on
 565                  * the stack.
 566                  */
 567                 refcount_release(&tfb->tfb_refcnt);
 568         }
 569
 570         /*
 571          * If that wasn't feasible, use the built-in default
 572          * stack which is not allowed to reject anyone.
 573          */
 574         tfb = find_and_ref_tcp_fb(&tcp_def_funcblk);
 575         if (tfb == NULL) {
 576                 /* there always should be a default */
 577                 panic("Can't refer to tcp_def_funcblk");
 578         }
 579         if (tfb->tfb_tcp_handoff_ok != NULL) {
 580                 if ((*tfb->tfb_tcp_handoff_ok) (tp)) {
 581                         /* The default stack cannot say no */
 582                         panic("Default stack rejects a new session?");
 583                 }
 584         }
 585         tp->t_fb = tfb;
 586         if (tp->t_fb->tfb_tcp_fb_init != NULL &&
 587             (*tp->t_fb->tfb_tcp_fb_init)(tp)) {
 588                 /* The default stack cannot fail */
 589                 panic("Default stack initialization failed");
 590         }
 591 }
 592
 593 static bool
 594 tcp_recv_udp_tunneled_packet(struct mbuf *m, int off, struct inpcb *inp,
 595     const struct sockaddr *sa, void *ctx)
 596 {
 597         struct ip *iph;
 598 #ifdef INET6
 599         struct ip6_hdr *ip6;
 600 #endif
 601         struct udphdr *uh;
 602         struct tcphdr *th;
 603         int thlen;
 604         uint16_t port;
 605
 606         TCPSTAT_INC(tcps_tunneled_pkts);
 607         if ((m->m_flags & M_PKTHDR) == 0) {
 608                 /* Can't handle one that is not a pkt hdr */
 609                 TCPSTAT_INC(tcps_tunneled_errs);
 610                 goto out;
 611         }
 612         thlen = sizeof(struct tcphdr);
 613         if (m->m_len < off + sizeof(struct udphdr) + thlen &&
 614             (m =  m_pullup(m, off + sizeof(struct udphdr) + thlen)) == NULL) {
 615                 TCPSTAT_INC(tcps_tunneled_errs);
 616                 goto out;
 617         }
 618         iph = mtod(m, struct ip *);
 619         uh = (struct udphdr *)((caddr_t)iph + off);
 620         th = (struct tcphdr *)(uh + 1);
 621         thlen = th->th_off << 2;
 622         if (m->m_len < off + sizeof(struct udphdr) + thlen) {
 623                 m =  m_pullup(m, off + sizeof(struct udphdr) + thlen);
 624                 if (m == NULL) {
 625                         TCPSTAT_INC(tcps_tunneled_errs);
 626                         goto out;
 627                 } else {
 628                         iph = mtod(m, struct ip *);
 629                         uh = (struct udphdr *)((caddr_t)iph + off);
 630                         th = (struct tcphdr *)(uh + 1);
 631                 }
 632         }
 633         m->m_pkthdr.tcp_tun_port = port = uh->uh_sport;
 634         bcopy(th, uh, m->m_len - off);
 635         m->m_len -= sizeof(struct udphdr);
 636         m->m_pkthdr.len -= sizeof(struct udphdr);
 637         /*
 638          * We use the same algorithm for
 639          * both UDP and TCP for c-sum. So
 640          * the code in tcp_input will skip
 641          * the checksum. So we do nothing
 642          * with the flag (m->m_pkthdr.csum_flags).
 643          */
 644         switch (iph->ip_v) {
 645 #ifdef INET
 646         case IPVERSION:
 647                 iph->ip_len = htons(ntohs(iph->ip_len) - sizeof(struct udphdr));
 648                 tcp_input_with_port(&m, &off, IPPROTO_TCP, port);
 649                 break;
 650 #endif
 651 #ifdef INET6
 652         case IPV6_VERSION >> 4:
 653                 ip6 = mtod(m, struct ip6_hdr *);
 654                 ip6->ip6_plen = htons(ntohs(ip6->ip6_plen) - sizeof(struct udphdr));
 655                 tcp6_input_with_port(&m, &off, IPPROTO_TCP, port);
 656                 break;
 657 #endif
 658         default:
 659                 goto out;
 660                 break;
 661         }
 662         return (true);
 663 out:
 664         m_freem(m);
 665
 666         return (true);
 667 }
 668
 669 static int
 670 sysctl_net_inet_default_tcp_functions(SYSCTL_HANDLER_ARGS)
 671 {
 672         int error=ENOENT;
 673         struct tcp_function_set fs;
 674         struct tcp_function_block *blk;
 675
 676         memset(&fs, 0, sizeof(fs));
 677         rw_rlock(&tcp_function_lock);
 678         blk = find_tcp_fb_locked(tcp_func_set_ptr, NULL);
 679         if (blk) {
 680                 /* Found him */
 681                 strcpy(fs.function_set_name, blk->tfb_tcp_block_name);
 682                 fs.pcbcnt = blk->tfb_refcnt;
 683         }
 684         rw_runlock(&tcp_function_lock);
 685         error = sysctl_handle_string(oidp, fs.function_set_name,
 686                                      sizeof(fs.function_set_name), req);
 687
 688         /* Check for error or no change */
 689         if (error != 0 || req->newptr == NULL)
 690                 return(error);
 691
 692         rw_wlock(&tcp_function_lock);
 693         blk = find_tcp_functions_locked(&fs);
 694         if ((blk == NULL) ||
 695             (blk->tfb_flags & TCP_FUNC_BEING_REMOVED)) {
 696                 error = ENOENT;
 697                 goto done;
 698         }
 699         tcp_func_set_ptr = blk;
 700 done:
 701         rw_wunlock(&tcp_function_lock);
 702         return (error);
 703 }
 704
 705 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_default,
 706     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 707     NULL, 0, sysctl_net_inet_default_tcp_functions, "A",
 708     "Set/get the default TCP functions");
 709
 710 static int
 711 sysctl_net_inet_list_available(SYSCTL_HANDLER_ARGS)
 712 {
 713         int error, cnt, linesz;
 714         struct tcp_function *f;
 715         char *buffer, *cp;
 716         size_t bufsz, outsz;
 717         bool alias;
 718
 719         cnt = 0;
 720         rw_rlock(&tcp_function_lock);
 721         TAILQ_FOREACH(f, &t_functions, tf_next) {
 722                 cnt++;
 723         }
 724         rw_runlock(&tcp_function_lock);
 725
 726         bufsz = (cnt+2) * ((TCP_FUNCTION_NAME_LEN_MAX * 2) + 13) + 1;
 727         buffer = malloc(bufsz, M_TEMP, M_WAITOK);
 728
 729         error = 0;
 730         cp = buffer;
 731
 732         linesz = snprintf(cp, bufsz, "\n%-32s%c %-32s %s\n", "Stack", 'D',
 733             "Alias", "PCB count");
 734         cp += linesz;
 735         bufsz -= linesz;
 736         outsz = linesz;
 737
 738         rw_rlock(&tcp_function_lock);
 739         TAILQ_FOREACH(f, &t_functions, tf_next) {
 740                 alias = (f->tf_name != f->tf_fb->tfb_tcp_block_name);
 741                 linesz = snprintf(cp, bufsz, "%-32s%c %-32s %u\n",
 742                     f->tf_fb->tfb_tcp_block_name,
 743                     (f->tf_fb == tcp_func_set_ptr) ? '*' : ' ',
 744                     alias ? f->tf_name : "-",
 745                     f->tf_fb->tfb_refcnt);
 746                 if (linesz >= bufsz) {
 747                         error = EOVERFLOW;
 748                         break;
 749                 }
 750                 cp += linesz;
 751                 bufsz -= linesz;
 752                 outsz += linesz;
 753         }
 754         rw_runlock(&tcp_function_lock);
 755         if (error == 0)
 756                 error = sysctl_handle_string(oidp, buffer, outsz + 1, req);
 757         free(buffer, M_TEMP);
 758         return (error);
 759 }
 760
 761 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_available,
 762     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 763     NULL, 0, sysctl_net_inet_list_available, "A",
 764     "list available TCP Function sets");
 765
 766 VNET_DEFINE(int, tcp_udp_tunneling_port) = TCP_TUNNELING_PORT_DEFAULT;
 767
 768 #ifdef INET
 769 VNET_DEFINE(struct socket *, udp4_tun_socket) = NULL;
 770 #define V_udp4_tun_socket       VNET(udp4_tun_socket)
 771 #endif
 772 #ifdef INET6
 773 VNET_DEFINE(struct socket *, udp6_tun_socket) = NULL;
 774 #define V_udp6_tun_socket       VNET(udp6_tun_socket)
 775 #endif
 776
 777 static struct sx tcpoudp_lock;
 778
 779 static void
 780 tcp_over_udp_stop(void)
 781 {
 782
 783         sx_assert(&tcpoudp_lock, SA_XLOCKED);
 784
 785 #ifdef INET
 786         if (V_udp4_tun_socket != NULL) {
 787                 soclose(V_udp4_tun_socket);
 788                 V_udp4_tun_socket = NULL;
 789         }
 790 #endif
 791 #ifdef INET6
 792         if (V_udp6_tun_socket != NULL) {
 793                 soclose(V_udp6_tun_socket);
 794                 V_udp6_tun_socket = NULL;
 795         }
 796 #endif
 797 }
 798
 799 static int
 800 tcp_over_udp_start(void)
 801 {
 802         uint16_t port;
 803         int ret;
 804 #ifdef INET
 805         struct sockaddr_in sin;
 806 #endif
 807 #ifdef INET6
 808         struct sockaddr_in6 sin6;
 809 #endif
 810
 811         sx_assert(&tcpoudp_lock, SA_XLOCKED);
 812
 813         port = V_tcp_udp_tunneling_port;
 814         if (ntohs(port) == 0) {
 815                 /* Must have a port set */
 816                 return (EINVAL);
 817         }
 818 #ifdef INET
 819         if (V_udp4_tun_socket != NULL) {
 820                 /* Already running -- must stop first */
 821                 return (EALREADY);
 822         }
 823 #endif
 824 #ifdef INET6
 825         if (V_udp6_tun_socket != NULL) {
 826                 /* Already running -- must stop first */
 827                 return (EALREADY);
 828         }
 829 #endif
 830 #ifdef INET
 831         if ((ret = socreate(PF_INET, &V_udp4_tun_socket,
 832             SOCK_DGRAM, IPPROTO_UDP,
 833             curthread->td_ucred, curthread))) {
 834                 tcp_over_udp_stop();
 835                 return (ret);
 836         }
 837         /* Call the special UDP hook. */
 838         if ((ret = udp_set_kernel_tunneling(V_udp4_tun_socket,
 839             tcp_recv_udp_tunneled_packet,
 840             tcp_ctlinput_viaudp,
 841             NULL))) {
 842                 tcp_over_udp_stop();
 843                 return (ret);
 844         }
 845         /* Ok, we have a socket, bind it to the port. */
 846         memset(&sin, 0, sizeof(struct sockaddr_in));
 847         sin.sin_len = sizeof(struct sockaddr_in);
 848         sin.sin_family = AF_INET;
 849         sin.sin_port = htons(port);
 850         if ((ret = sobind(V_udp4_tun_socket,
 851             (struct sockaddr *)&sin, curthread))) {
 852                 tcp_over_udp_stop();
 853                 return (ret);
 854         }
 855 #endif
 856 #ifdef INET6
 857         if ((ret = socreate(PF_INET6, &V_udp6_tun_socket,
 858             SOCK_DGRAM, IPPROTO_UDP,
 859             curthread->td_ucred, curthread))) {
 860                 tcp_over_udp_stop();
 861                 return (ret);
 862         }
 863         /* Call the special UDP hook. */
 864         if ((ret = udp_set_kernel_tunneling(V_udp6_tun_socket,
 865             tcp_recv_udp_tunneled_packet,
 866             tcp6_ctlinput_viaudp,
 867             NULL))) {
 868                 tcp_over_udp_stop();
 869                 return (ret);
 870         }
 871         /* Ok, we have a socket, bind it to the port. */
 872         memset(&sin6, 0, sizeof(struct sockaddr_in6));
 873         sin6.sin6_len = sizeof(struct sockaddr_in6);
 874         sin6.sin6_family = AF_INET6;
 875         sin6.sin6_port = htons(port);
 876         if ((ret = sobind(V_udp6_tun_socket,
 877             (struct sockaddr *)&sin6, curthread))) {
 878                 tcp_over_udp_stop();
 879                 return (ret);
 880         }
 881 #endif
 882         return (0);
 883 }
 884
 885 static int
 886 sysctl_net_inet_tcp_udp_tunneling_port_check(SYSCTL_HANDLER_ARGS)
 887 {
 888         int error;
 889         uint32_t old, new;
 890
 891         old = V_tcp_udp_tunneling_port;
 892         new = old;
 893         error = sysctl_handle_int(oidp, &new, 0, req);
 894         if ((error == 0) &&
 895             (req->newptr != NULL)) {
 896                 if ((new < TCP_TUNNELING_PORT_MIN) ||
 897                     (new > TCP_TUNNELING_PORT_MAX)) {
 898                         error = EINVAL;
 899                 } else {
 900                         sx_xlock(&tcpoudp_lock);
 901                         V_tcp_udp_tunneling_port = new;
 902                         if (old != 0) {
 903                                 tcp_over_udp_stop();
 904                         }
 905                         if (new != 0) {
 906                                 error = tcp_over_udp_start();
 907                                 if (error != 0) {
 908                                         V_tcp_udp_tunneling_port = 0;
 909                                 }
 910                         }
 911                         sx_xunlock(&tcpoudp_lock);
 912                 }
 913         }
 914         return (error);
 915 }
 916
 917 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, udp_tunneling_port,
 918     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 919     &VNET_NAME(tcp_udp_tunneling_port),
 920     0, &sysctl_net_inet_tcp_udp_tunneling_port_check, "IU",
 921     "Tunneling port for tcp over udp");
 922
 923 VNET_DEFINE(int, tcp_udp_tunneling_overhead) = TCP_TUNNELING_OVERHEAD_DEFAULT;
 924
 925 static int
 926 sysctl_net_inet_tcp_udp_tunneling_overhead_check(SYSCTL_HANDLER_ARGS)
 927 {
 928         int error, new;
 929
 930         new = V_tcp_udp_tunneling_overhead;
 931         error = sysctl_handle_int(oidp, &new, 0, req);
 932         if (error == 0 && req->newptr) {
 933                 if ((new < TCP_TUNNELING_OVERHEAD_MIN) ||
 934                     (new > TCP_TUNNELING_OVERHEAD_MAX))
 935                         error = EINVAL;
 936                 else
 937                         V_tcp_udp_tunneling_overhead = new;
 938         }
 939         return (error);
 940 }
 941
 942 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, udp_tunneling_overhead,
 943     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 944     &VNET_NAME(tcp_udp_tunneling_overhead),
 945     0, &sysctl_net_inet_tcp_udp_tunneling_overhead_check, "IU",
 946     "MSS reduction when using tcp over udp");
 947
 948 /*
 949  * Exports one (struct tcp_function_info) for each alias/name.
 950  */
 951 static int
 952 sysctl_net_inet_list_func_info(SYSCTL_HANDLER_ARGS)
 953 {
 954         int cnt, error;
 955         struct tcp_function *f;
 956         struct tcp_function_info tfi;
 957
 958         /*
 959          * We don't allow writes.
 960          */
 961         if (req->newptr != NULL)
 962                 return (EINVAL);
 963
 964         /*
 965          * Wire the old buffer so we can directly copy the functions to
 966          * user space without dropping the lock.
 967          */
 968         if (req->oldptr != NULL) {
 969                 error = sysctl_wire_old_buffer(req, 0);
 970                 if (error)
 971                         return (error);
 972         }
 973
 974         /*
 975          * Walk the list and copy out matching entries. If INVARIANTS
 976          * is compiled in, also walk the list to verify the length of
 977          * the list matches what we have recorded.
 978          */
 979         rw_rlock(&tcp_function_lock);
 980
 981         cnt = 0;
 982 #ifndef INVARIANTS
 983         if (req->oldptr == NULL) {
 984                 cnt = tcp_fb_cnt;
 985                 goto skip_loop;
 986         }
 987 #endif
 988         TAILQ_FOREACH(f, &t_functions, tf_next) {
 989 #ifdef INVARIANTS
 990                 cnt++;
 991 #endif
 992                 if (req->oldptr != NULL) {
 993                         bzero(&tfi, sizeof(tfi));
 994                         tfi.tfi_refcnt = f->tf_fb->tfb_refcnt;
 995                         tfi.tfi_id = f->tf_fb->tfb_id;
 996                         (void)strlcpy(tfi.tfi_alias, f->tf_name,
 997                             sizeof(tfi.tfi_alias));
 998                         (void)strlcpy(tfi.tfi_name,
 999                             f->tf_fb->tfb_tcp_block_name, sizeof(tfi.tfi_name));
1000                         error = SYSCTL_OUT(req, &tfi, sizeof(tfi));
1001                         /*
1002                          * Don't stop on error, as that is the
1003                          * mechanism we use to accumulate length
1004                          * information if the buffer was too short.
1005                          */
1006                 }
1007         }
1008         KASSERT(cnt == tcp_fb_cnt,
1009             ("%s: cnt (%d) != tcp_fb_cnt (%d)", __func__, cnt, tcp_fb_cnt));
1010 #ifndef INVARIANTS
1011 skip_loop:
1012 #endif
1013         rw_runlock(&tcp_function_lock);
1014         if (req->oldptr == NULL)
1015                 error = SYSCTL_OUT(req, NULL,
1016                     (cnt + 1) * sizeof(struct tcp_function_info));
1017
1018         return (error);
1019 }
1020
1021 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, function_info,
1022             CTLTYPE_OPAQUE | CTLFLAG_SKIP | CTLFLAG_RD | CTLFLAG_MPSAFE,
1023             NULL, 0, sysctl_net_inet_list_func_info, "S,tcp_function_info",
1024             "List TCP function block name-to-ID mappings");
1025
1026 /*
1027  * tfb_tcp_handoff_ok() function for the default stack.
1028  * Note that we'll basically try to take all comers.
1029  */
1030 static int
1031 tcp_default_handoff_ok(struct tcpcb *tp)
1032 {
1033
1034         return (0);
1035 }
1036
1037 /*
1038  * tfb_tcp_fb_init() function for the default stack.
1039  *
1040  * This handles making sure we have appropriate timers set if you are
1041  * transitioning a socket that has some amount of setup done.
1042  *
1043  * The init() fuction from the default can *never* return non-zero i.e.
1044  * it is required to always succeed since it is the stack of last resort!
1045  */
1046 static int
1047 tcp_default_fb_init(struct tcpcb *tp)
1048 {
1049         struct socket *so = tptosocket(tp);
1050
1051         INP_WLOCK_ASSERT(tptoinpcb(tp));
1052
1053         KASSERT(tp->t_state >= 0 && tp->t_state < TCPS_TIME_WAIT,
1054             ("%s: connection %p in unexpected state %d", __func__, tp,
1055             tp->t_state));
1056
1057         /*
1058          * Nothing to do for ESTABLISHED or LISTEN states. And, we don't
1059          * know what to do for unexpected states (which includes TIME_WAIT).
1060          */
1061         if (tp->t_state <= TCPS_LISTEN || tp->t_state >= TCPS_TIME_WAIT)
1062                 return (0);
1063
1064         /*
1065          * Make sure some kind of transmission timer is set if there is
1066          * outstanding data.
1067          */
1068         if ((!TCPS_HAVEESTABLISHED(tp->t_state) || sbavail(&so->so_snd) ||
1069             tp->snd_una != tp->snd_max) && !(tcp_timer_active(tp, TT_REXMT) ||
1070             tcp_timer_active(tp, TT_PERSIST))) {
1071                 /*
1072                  * If the session has established and it looks like it should
1073                  * be in the persist state, set the persist timer. Otherwise,
1074                  * set the retransmit timer.
1075                  */
1076                 if (TCPS_HAVEESTABLISHED(tp->t_state) && tp->snd_wnd == 0 &&
1077                     (int32_t)(tp->snd_nxt - tp->snd_una) <
1078                     (int32_t)sbavail(&so->so_snd))
1079                         tcp_setpersist(tp);
1080                 else
1081                         tcp_timer_activate(tp, TT_REXMT, tp->t_rxtcur);
1082         }
1083
1084         /* All non-embryonic sessions get a keepalive timer. */
1085         if (!tcp_timer_active(tp, TT_KEEP))
1086                 tcp_timer_activate(tp, TT_KEEP,
1087                     TCPS_HAVEESTABLISHED(tp->t_state) ? TP_KEEPIDLE(tp) :
1088                     TP_KEEPINIT(tp));
1089
1090         /*
1091          * Make sure critical variables are initialized
1092          * if transitioning while in Recovery.
1093          */
1094         if IN_FASTRECOVERY(tp->t_flags) {
1095                 if (tp->sackhint.recover_fs == 0)
1096                         tp->sackhint.recover_fs = max(1,
1097                             tp->snd_nxt - tp->snd_una);
1098         }
1099
1100         return (0);
1101 }
1102
1103 /*
1104  * tfb_tcp_fb_fini() function for the default stack.
1105  *
1106  * This changes state as necessary (or prudent) to prepare for another stack
1107  * to assume responsibility for the connection.
1108  */
1109 static void
1110 tcp_default_fb_fini(struct tcpcb *tp, int tcb_is_purged)
1111 {
1112
1113         INP_WLOCK_ASSERT(tptoinpcb(tp));
1114 }
1115
1116 /*
1117  * Target size of TCP PCB hash tables. Must be a power of two.
1118  *
1119  * Note that this can be overridden by the kernel environment
1120  * variable net.inet.tcp.tcbhashsize
1121  */
1122 #ifndef TCBHASHSIZE
1123 #define TCBHASHSIZE     0
1124 #endif
1125
1126 MALLOC_DEFINE(M_TCPLOG, "tcplog", "TCP address and flags print buffers");
1127 MALLOC_DEFINE(M_TCPFUNCTIONS, "tcpfunc", "TCP function set memory");
1128
1129 static struct mtx isn_mtx;
1130
1131 #define ISN_LOCK_INIT() mtx_init(&isn_mtx, "isn_mtx", NULL, MTX_DEF)
1132 #define ISN_LOCK()      mtx_lock(&isn_mtx)
1133 #define ISN_UNLOCK()    mtx_unlock(&isn_mtx)
1134
1135 INPCBSTORAGE_DEFINE(tcpcbstor, tcpcb, "tcpinp", "tcp_inpcb", "tcp", "tcphash");
1136
1137 /*
1138  * Take a value and get the next power of 2 that doesn't overflow.
1139  * Used to size the tcp_inpcb hash buckets.
1140  */
1141 static int
1142 maketcp_hashsize(int size)
1143 {
1144         int hashsize;
1145
1146         /*
1147          * auto tune.
1148          * get the next power of 2 higher than maxsockets.
1149          */
1150         hashsize = 1 << fls(size);
1151         /* catch overflow, and just go one power of 2 smaller */
1152         if (hashsize < size) {
1153                 hashsize = 1 << (fls(size) - 1);
1154         }
1155         return (hashsize);
1156 }
1157
1158 static volatile int next_tcp_stack_id = 1;
1159
1160 /*
1161  * Register a TCP function block with the name provided in the names
1162  * array.  (Note that this function does NOT automatically register
1163  * blk->tfb_tcp_block_name as a stack name.  Therefore, you should
1164  * explicitly include blk->tfb_tcp_block_name in the list of names if
1165  * you wish to register the stack with that name.)
1166  *
1167  * Either all name registrations will succeed or all will fail.  If
1168  * a name registration fails, the function will update the num_names
1169  * argument to point to the array index of the name that encountered
1170  * the failure.
1171  *
1172  * Returns 0 on success, or an error code on failure.
1173  */
1174 int
1175 register_tcp_functions_as_names(struct tcp_function_block *blk, int wait,
1176     const char *names[], int *num_names)
1177 {
1178         struct tcp_function *n;
1179         struct tcp_function_set fs;
1180         int error, i;
1181
1182         KASSERT(names != NULL && *num_names > 0,
1183             ("%s: Called with 0-length name list", __func__));
1184         KASSERT(names != NULL, ("%s: Called with NULL name list", __func__));
1185         KASSERT(rw_initialized(&tcp_function_lock),
1186             ("%s: called too early", __func__));
1187
1188         if ((blk->tfb_tcp_output == NULL) ||
1189             (blk->tfb_tcp_do_segment == NULL) ||
1190             (blk->tfb_tcp_ctloutput == NULL) ||
1191             (strlen(blk->tfb_tcp_block_name) == 0)) {
1192                 /*
1193                  * These functions are required and you
1194                  * need a name.
1195                  */
1196                 *num_names = 0;
1197                 return (EINVAL);
1198         }
1199
1200         if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
1201                 *num_names = 0;
1202                 return (EINVAL);
1203         }
1204
1205         refcount_init(&blk->tfb_refcnt, 0);
1206         blk->tfb_id = atomic_fetchadd_int(&next_tcp_stack_id, 1);
1207         for (i = 0; i < *num_names; i++) {
1208                 n = malloc(sizeof(struct tcp_function), M_TCPFUNCTIONS, wait);
1209                 if (n == NULL) {
1210                         error = ENOMEM;
1211                         goto cleanup;
1212                 }
1213                 n->tf_fb = blk;
1214
1215                 (void)strlcpy(fs.function_set_name, names[i],
1216                     sizeof(fs.function_set_name));
1217                 rw_wlock(&tcp_function_lock);
1218                 if (find_tcp_functions_locked(&fs) != NULL) {
1219                         /* Duplicate name space not allowed */
1220                         rw_wunlock(&tcp_function_lock);
1221                         free(n, M_TCPFUNCTIONS);
1222                         error = EALREADY;
1223                         goto cleanup;
1224                 }
1225                 (void)strlcpy(n->tf_name, names[i], sizeof(n->tf_name));
1226                 TAILQ_INSERT_TAIL(&t_functions, n, tf_next);
1227                 tcp_fb_cnt++;
1228                 rw_wunlock(&tcp_function_lock);
1229         }
1230         return(0);
1231
1232 cleanup:
1233         /*
1234          * Deregister the names we just added. Because registration failed
1235          * for names[i], we don't need to deregister that name.
1236          */
1237         *num_names = i;
1238         rw_wlock(&tcp_function_lock);
1239         while (--i >= 0) {
1240                 TAILQ_FOREACH(n, &t_functions, tf_next) {
1241                         if (!strncmp(n->tf_name, names[i],
1242                             TCP_FUNCTION_NAME_LEN_MAX)) {
1243                                 TAILQ_REMOVE(&t_functions, n, tf_next);
1244                                 tcp_fb_cnt--;
1245                                 n->tf_fb = NULL;
1246                                 free(n, M_TCPFUNCTIONS);
1247                                 break;
1248                         }
1249                 }
1250         }
1251         rw_wunlock(&tcp_function_lock);
1252         return (error);
1253 }
1254
1255 /*
1256  * Register a TCP function block using the name provided in the name
1257  * argument.
1258  *
1259  * Returns 0 on success, or an error code on failure.
1260  */
1261 int
1262 register_tcp_functions_as_name(struct tcp_function_block *blk, const char *name,
1263     int wait)
1264 {
1265         const char *name_list[1];
1266         int num_names, rv;
1267
1268         num_names = 1;
1269         if (name != NULL)
1270                 name_list[0] = name;
1271         else
1272                 name_list[0] = blk->tfb_tcp_block_name;
1273         rv = register_tcp_functions_as_names(blk, wait, name_list, &num_names);
1274         return (rv);
1275 }
1276
1277 /*
1278  * Register a TCP function block using the name defined in
1279  * blk->tfb_tcp_block_name.
1280  *
1281  * Returns 0 on success, or an error code on failure.
1282  */
1283 int
1284 register_tcp_functions(struct tcp_function_block *blk, int wait)
1285 {
1286
1287         return (register_tcp_functions_as_name(blk, NULL, wait));
1288 }
1289
1290 /*
1291  * Deregister all names associated with a function block. This
1292  * functionally removes the function block from use within the system.
1293  *
1294  * When called with a true quiesce argument, mark the function block
1295  * as being removed so no more stacks will use it and determine
1296  * whether the removal would succeed.
1297  *
1298  * When called with a false quiesce argument, actually attempt the
1299  * removal.
1300  *
1301  * When called with a force argument, attempt to switch all TCBs to
1302  * use the default stack instead of returning EBUSY.
1303  *
1304  * Returns 0 on success (or if the removal would succeed, or an error
1305  * code on failure.
1306  */
1307 int
1308 deregister_tcp_functions(struct tcp_function_block *blk, bool quiesce,
1309     bool force)
1310 {
1311         struct tcp_function *f;
1312
1313         if (blk == &tcp_def_funcblk) {
1314                 /* You can't un-register the default */
1315                 return (EPERM);
1316         }
1317         rw_wlock(&tcp_function_lock);
1318         if (blk == tcp_func_set_ptr) {
1319                 /* You can't free the current default */
1320                 rw_wunlock(&tcp_function_lock);
1321                 return (EBUSY);
1322         }
1323         /* Mark the block so no more stacks can use it. */
1324         blk->tfb_flags |= TCP_FUNC_BEING_REMOVED;
1325         /*
1326          * If TCBs are still attached to the stack, attempt to switch them
1327          * to the default stack.
1328          */
1329         if (force && blk->tfb_refcnt) {
1330                 struct inpcb_iterator inpi = INP_ALL_ITERATOR(&V_tcbinfo,
1331                     INPLOOKUP_WLOCKPCB);
1332                 struct inpcb *inp;
1333                 struct tcpcb *tp;
1334                 VNET_ITERATOR_DECL(vnet_iter);
1335
1336                 rw_wunlock(&tcp_function_lock);
1337
1338                 VNET_LIST_RLOCK();
1339                 VNET_FOREACH(vnet_iter) {
1340                         CURVNET_SET(vnet_iter);
1341                         while ((inp = inp_next(&inpi)) != NULL) {
1342                                 tp = intotcpcb(inp);
1343                                 if (tp == NULL || tp->t_fb != blk)
1344                                         continue;
1345                                 tcp_switch_back_to_default(tp);
1346                         }
1347                         CURVNET_RESTORE();
1348                 }
1349                 VNET_LIST_RUNLOCK();
1350
1351                 rw_wlock(&tcp_function_lock);
1352         }
1353         if (blk->tfb_refcnt) {
1354                 /* TCBs still attached. */
1355                 rw_wunlock(&tcp_function_lock);
1356                 return (EBUSY);
1357         }
1358         if (quiesce) {
1359                 /* Skip removal. */
1360                 rw_wunlock(&tcp_function_lock);
1361                 return (0);
1362         }
1363         /* Remove any function names that map to this function block. */
1364         while (find_tcp_fb_locked(blk, &f) != NULL) {
1365                 TAILQ_REMOVE(&t_functions, f, tf_next);
1366                 tcp_fb_cnt--;
1367                 f->tf_fb = NULL;
1368                 free(f, M_TCPFUNCTIONS);
1369         }
1370         rw_wunlock(&tcp_function_lock);
1371         return (0);
1372 }
1373
1374 static void
1375 tcp_drain(void)
1376 {
1377         struct epoch_tracker et;
1378         VNET_ITERATOR_DECL(vnet_iter);
1379
1380         if (!do_tcpdrain)
1381                 return;
1382
1383         NET_EPOCH_ENTER(et);
1384         VNET_LIST_RLOCK_NOSLEEP();
1385         VNET_FOREACH(vnet_iter) {
1386                 CURVNET_SET(vnet_iter);
1387                 struct inpcb_iterator inpi = INP_ALL_ITERATOR(&V_tcbinfo,
1388                     INPLOOKUP_WLOCKPCB);
1389                 struct inpcb *inpb;
1390                 struct tcpcb *tcpb;
1391
1392         /*
1393          * Walk the tcpbs, if existing, and flush the reassembly queue,
1394          * if there is one...
1395          * XXX: The "Net/3" implementation doesn't imply that the TCP
1396          *      reassembly queue should be flushed, but in a situation
1397          *      where we're really low on mbufs, this is potentially
1398          *      useful.
1399          */
1400                 while ((inpb = inp_next(&inpi)) != NULL) {
1401                         if ((tcpb = intotcpcb(inpb)) != NULL) {
1402                                 tcp_reass_flush(tcpb);
1403                                 tcp_clean_sackreport(tcpb);
1404 #ifdef TCP_BLACKBOX
1405                                 tcp_log_drain(tcpb);
1406 #endif
1407 #ifdef TCPPCAP
1408                                 if (tcp_pcap_aggressive_free) {
1409                                         /* Free the TCP PCAP queues. */
1410                                         tcp_pcap_drain(&(tcpb->t_inpkts));
1411                                         tcp_pcap_drain(&(tcpb->t_outpkts));
1412                                 }
1413 #endif
1414                         }
1415                 }
1416                 CURVNET_RESTORE();
1417         }
1418         VNET_LIST_RUNLOCK_NOSLEEP();
1419         NET_EPOCH_EXIT(et);
1420 }
1421
1422 static void
1423 tcp_vnet_init(void *arg __unused)
1424 {
1425
1426 #ifdef TCP_HHOOK
1427         if (hhook_head_register(HHOOK_TYPE_TCP, HHOOK_TCP_EST_IN,
1428             &V_tcp_hhh[HHOOK_TCP_EST_IN], HHOOK_NOWAIT|HHOOK_HEADISINVNET) != 0)
1429                 printf("%s: WARNING: unable to register helper hook\n", __func__);
1430         if (hhook_head_register(HHOOK_TYPE_TCP, HHOOK_TCP_EST_OUT,
1431             &V_tcp_hhh[HHOOK_TCP_EST_OUT], HHOOK_NOWAIT|HHOOK_HEADISINVNET) != 0)
1432                 printf("%s: WARNING: unable to register helper hook\n", __func__);
1433 #endif
1434 #ifdef STATS
1435         if (tcp_stats_init())
1436                 printf("%s: WARNING: unable to initialise TCP stats\n",
1437                     __func__);
1438 #endif
1439         in_pcbinfo_init(&V_tcbinfo, &tcpcbstor, tcp_tcbhashsize,
1440             tcp_tcbhashsize);
1441
1442         syncache_init();
1443         tcp_hc_init();
1444
1445         TUNABLE_INT_FETCH("net.inet.tcp.sack.enable", &V_tcp_do_sack);
1446         V_sack_hole_zone = uma_zcreate("sackhole", sizeof(struct sackhole),
1447             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
1448
1449         tcp_fastopen_init();
1450
1451         COUNTER_ARRAY_ALLOC(V_tcps_states, TCP_NSTATES, M_WAITOK);
1452         VNET_PCPUSTAT_ALLOC(tcpstat, M_WAITOK);
1453
1454         V_tcp_msl = TCPTV_MSL;
1455 }
1456 VNET_SYSINIT(tcp_vnet_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH,
1457     tcp_vnet_init, NULL);
1458
1459 static void
1460 tcp_init(void *arg __unused)
1461 {
1462         const char *tcbhash_tuneable;
1463         int hashsize;
1464
1465         tcp_reass_global_init();
1466
1467         /* XXX virtualize those below? */
1468         tcp_delacktime = TCPTV_DELACK;
1469         tcp_keepinit = TCPTV_KEEP_INIT;
1470         tcp_keepidle = TCPTV_KEEP_IDLE;
1471         tcp_keepintvl = TCPTV_KEEPINTVL;
1472         tcp_maxpersistidle = TCPTV_KEEP_IDLE;
1473         tcp_rexmit_initial = TCPTV_RTOBASE;
1474         if (tcp_rexmit_initial < 1)
1475                 tcp_rexmit_initial = 1;
1476         tcp_rexmit_min = TCPTV_MIN;
1477         if (tcp_rexmit_min < 1)
1478                 tcp_rexmit_min = 1;
1479         tcp_persmin = TCPTV_PERSMIN;
1480         tcp_persmax = TCPTV_PERSMAX;
1481         tcp_rexmit_slop = TCPTV_CPU_VAR;
1482         tcp_finwait2_timeout = TCPTV_FINWAIT2_TIMEOUT;
1483
1484         /* Setup the tcp function block list */
1485         TAILQ_INIT(&t_functions);
1486         rw_init(&tcp_function_lock, "tcp_func_lock");
1487         register_tcp_functions(&tcp_def_funcblk, M_WAITOK);
1488         sx_init(&tcpoudp_lock, "TCP over UDP configuration");
1489 #ifdef TCP_BLACKBOX
1490         /* Initialize the TCP logging data. */
1491         tcp_log_init();
1492 #endif
1493         arc4rand(&V_ts_offset_secret, sizeof(V_ts_offset_secret), 0);
1494
1495         if (tcp_soreceive_stream) {
1496 #ifdef INET
1497                 tcp_protosw.pr_soreceive = soreceive_stream;
1498 #endif
1499 #ifdef INET6
1500                 tcp6_protosw.pr_soreceive = soreceive_stream;
1501 #endif /* INET6 */
1502         }
1503
1504 #ifdef INET6
1505         max_protohdr_grow(sizeof(struct ip6_hdr) + sizeof(struct tcphdr));
1506 #else /* INET6 */
1507         max_protohdr_grow(sizeof(struct tcpiphdr));
1508 #endif /* INET6 */
1509
1510         ISN_LOCK_INIT();
1511         EVENTHANDLER_REGISTER(shutdown_pre_sync, tcp_fini, NULL,
1512                 SHUTDOWN_PRI_DEFAULT);
1513         EVENTHANDLER_REGISTER(vm_lowmem, tcp_drain, NULL, LOWMEM_PRI_DEFAULT);
1514         EVENTHANDLER_REGISTER(mbuf_lowmem, tcp_drain, NULL, LOWMEM_PRI_DEFAULT);
1515
1516         tcp_inp_lro_direct_queue = counter_u64_alloc(M_WAITOK);
1517         tcp_inp_lro_wokeup_queue = counter_u64_alloc(M_WAITOK);
1518         tcp_inp_lro_compressed = counter_u64_alloc(M_WAITOK);
1519         tcp_inp_lro_locks_taken = counter_u64_alloc(M_WAITOK);
1520         tcp_extra_mbuf = counter_u64_alloc(M_WAITOK);
1521         tcp_would_have_but = counter_u64_alloc(M_WAITOK);
1522         tcp_comp_total = counter_u64_alloc(M_WAITOK);
1523         tcp_uncomp_total = counter_u64_alloc(M_WAITOK);
1524         tcp_bad_csums = counter_u64_alloc(M_WAITOK);
1525 #ifdef TCPPCAP
1526         tcp_pcap_init();
1527 #endif
1528
1529         hashsize = TCBHASHSIZE;
1530         tcbhash_tuneable = "net.inet.tcp.tcbhashsize";
1531         TUNABLE_INT_FETCH(tcbhash_tuneable, &hashsize);
1532         if (hashsize == 0) {
1533                 /*
1534                  * Auto tune the hash size based on maxsockets.
1535                  * A perfect hash would have a 1:1 mapping
1536                  * (hashsize = maxsockets) however it's been
1537                  * suggested that O(2) average is better.
1538                  */
1539                 hashsize = maketcp_hashsize(maxsockets / 4);
1540                 /*
1541                  * Our historical default is 512,
1542                  * do not autotune lower than this.
1543                  */
1544                 if (hashsize < 512)
1545                         hashsize = 512;
1546                 if (bootverbose)
1547                         printf("%s: %s auto tuned to %d\n", __func__,
1548                             tcbhash_tuneable, hashsize);
1549         }
1550         /*
1551          * We require a hashsize to be a power of two.
1552          * Previously if it was not a power of two we would just reset it
1553          * back to 512, which could be a nasty surprise if you did not notice
1554          * the error message.
1555          * Instead what we do is clip it to the closest power of two lower
1556          * than the specified hash value.
1557          */
1558         if (!powerof2(hashsize)) {
1559                 int oldhashsize = hashsize;
1560
1561                 hashsize = maketcp_hashsize(hashsize);
1562                 /* prevent absurdly low value */
1563                 if (hashsize < 16)
1564                         hashsize = 16;
1565                 printf("%s: WARNING: TCB hash size not a power of 2, "
1566                     "clipped from %d to %d.\n", __func__, oldhashsize,
1567                     hashsize);
1568         }
1569         tcp_tcbhashsize = hashsize;
1570
1571 #ifdef INET
1572         IPPROTO_REGISTER(IPPROTO_TCP, tcp_input, tcp_ctlinput);
1573 #endif
1574 #ifdef INET6
1575         IP6PROTO_REGISTER(IPPROTO_TCP, tcp6_input, tcp6_ctlinput);
1576 #endif
1577 }
1578 SYSINIT(tcp_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, tcp_init, NULL);
1579
1580 #ifdef VIMAGE
1581 static void
1582 tcp_destroy(void *unused __unused)
1583 {
1584         int n;
1585 #ifdef TCP_HHOOK
1586         int error;
1587 #endif
1588
1589         /*
1590          * All our processes are gone, all our sockets should be cleaned
1591          * up, which means, we should be past the tcp_discardcb() calls.
1592          * Sleep to let all tcpcb timers really disappear and cleanup.
1593          */
1594         for (;;) {
1595                 INP_INFO_WLOCK(&V_tcbinfo);
1596                 n = V_tcbinfo.ipi_count;
1597                 INP_INFO_WUNLOCK(&V_tcbinfo);
1598                 if (n == 0)
1599                         break;
1600                 pause("tcpdes", hz / 10);
1601         }
1602         tcp_hc_destroy();
1603         syncache_destroy();
1604         in_pcbinfo_destroy(&V_tcbinfo);
1605         /* tcp_discardcb() clears the sack_holes up. */
1606         uma_zdestroy(V_sack_hole_zone);
1607
1608         /*
1609          * Cannot free the zone until all tcpcbs are released as we attach
1610          * the allocations to them.
1611          */
1612         tcp_fastopen_destroy();
1613
1614         COUNTER_ARRAY_FREE(V_tcps_states, TCP_NSTATES);
1615         VNET_PCPUSTAT_FREE(tcpstat);
1616
1617 #ifdef TCP_HHOOK
1618         error = hhook_head_deregister(V_tcp_hhh[HHOOK_TCP_EST_IN]);
1619         if (error != 0) {
1620                 printf("%s: WARNING: unable to deregister helper hook "
1621                     "type=%d, id=%d: error %d returned\n", __func__,
1622                     HHOOK_TYPE_TCP, HHOOK_TCP_EST_IN, error);
1623         }
1624         error = hhook_head_deregister(V_tcp_hhh[HHOOK_TCP_EST_OUT]);
1625         if (error != 0) {
1626                 printf("%s: WARNING: unable to deregister helper hook "
1627                     "type=%d, id=%d: error %d returned\n", __func__,
1628                     HHOOK_TYPE_TCP, HHOOK_TCP_EST_OUT, error);
1629         }
1630 #endif
1631 }
1632 VNET_SYSUNINIT(tcp, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH, tcp_destroy, NULL);
1633 #endif
1634
1635 void
1636 tcp_fini(void *xtp)
1637 {
1638
1639 }
1640
1641 /*
1642  * Fill in the IP and TCP headers for an outgoing packet, given the tcpcb.
1643  * tcp_template used to store this data in mbufs, but we now recopy it out
1644  * of the tcpcb each time to conserve mbufs.
1645  */
1646 void
1647 tcpip_fillheaders(struct inpcb *inp, uint16_t port, void *ip_ptr, void *tcp_ptr)
1648 {
1649         struct tcphdr *th = (struct tcphdr *)tcp_ptr;
1650
1651         INP_WLOCK_ASSERT(inp);
1652
1653 #ifdef INET6
1654         if ((inp->inp_vflag & INP_IPV6) != 0) {
1655                 struct ip6_hdr *ip6;
1656
1657                 ip6 = (struct ip6_hdr *)ip_ptr;
1658                 ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
1659                         (inp->inp_flow & IPV6_FLOWINFO_MASK);
1660                 ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
1661                         (IPV6_VERSION & IPV6_VERSION_MASK);
1662                 if (port == 0)
1663                         ip6->ip6_nxt = IPPROTO_TCP;
1664                 else
1665                         ip6->ip6_nxt = IPPROTO_UDP;
1666                 ip6->ip6_plen = htons(sizeof(struct tcphdr));
1667                 ip6->ip6_src = inp->in6p_laddr;
1668                 ip6->ip6_dst = inp->in6p_faddr;
1669         }
1670 #endif /* INET6 */
1671 #if defined(INET6) && defined(INET)
1672         else
1673 #endif
1674 #ifdef INET
1675         {
1676                 struct ip *ip;
1677
1678                 ip = (struct ip *)ip_ptr;
1679                 ip->ip_v = IPVERSION;
1680                 ip->ip_hl = 5;
1681                 ip->ip_tos = inp->inp_ip_tos;
1682                 ip->ip_len = 0;
1683                 ip->ip_id = 0;
1684                 ip->ip_off = 0;
1685                 ip->ip_ttl = inp->inp_ip_ttl;
1686                 ip->ip_sum = 0;
1687                 if (port == 0)
1688                         ip->ip_p = IPPROTO_TCP;
1689                 else
1690                         ip->ip_p = IPPROTO_UDP;
1691                 ip->ip_src = inp->inp_laddr;
1692                 ip->ip_dst = inp->inp_faddr;
1693         }
1694 #endif /* INET */
1695         th->th_sport = inp->inp_lport;
1696         th->th_dport = inp->inp_fport;
1697         th->th_seq = 0;
1698         th->th_ack = 0;
1699         th->th_off = 5;
1700         tcp_set_flags(th, 0);
1701         th->th_win = 0;
1702         th->th_urp = 0;
1703         th->th_sum = 0;         /* in_pseudo() is called later for ipv4 */
1704 }
1705
1706 /*
1707  * Create template to be used to send tcp packets on a connection.
1708  * Allocates an mbuf and fills in a skeletal tcp/ip header.  The only
1709  * use for this function is in keepalives, which use tcp_respond.
1710  */
1711 struct tcptemp *
1712 tcpip_maketemplate(struct inpcb *inp)
1713 {
1714         struct tcptemp *t;
1715
1716         t = malloc(sizeof(*t), M_TEMP, M_NOWAIT);
1717         if (t == NULL)
1718                 return (NULL);
1719         tcpip_fillheaders(inp, 0, (void *)&t->tt_ipgen, (void *)&t->tt_t);
1720         return (t);
1721 }
1722
1723 /*
1724  * Send a single message to the TCP at address specified by
1725  * the given TCP/IP header.  If m == NULL, then we make a copy
1726  * of the tcpiphdr at th and send directly to the addressed host.
1727  * This is used to force keep alive messages out using the TCP
1728  * template for a connection.  If flags are given then we send
1729  * a message back to the TCP which originated the segment th,
1730  * and discard the mbuf containing it and any other attached mbufs.
1731  *
1732  * In any case the ack and sequence number of the transmitted
1733  * segment are as specified by the parameters.
1734  *
1735  * NOTE: If m != NULL, then th must point to *inside* the mbuf.
1736  */
1737 void
1738 tcp_respond(struct tcpcb *tp, void *ipgen, struct tcphdr *th, struct mbuf *m,
1739     tcp_seq ack, tcp_seq seq, uint16_t flags)
1740 {
1741         struct tcpopt to;
1742         struct inpcb *inp;
1743         struct ip *ip;
1744         struct mbuf *optm;
1745         struct udphdr *uh = NULL;
1746         struct tcphdr *nth;
1747         struct tcp_log_buffer *lgb;
1748         u_char *optp;
1749 #ifdef INET6
1750         struct ip6_hdr *ip6;
1751         int isipv6;
1752 #endif /* INET6 */
1753         int optlen, tlen, win, ulen;
1754         int ect = 0;
1755         bool incl_opts;
1756         uint16_t port;
1757         int output_ret;
1758 #ifdef INVARIANTS
1759         int thflags = tcp_get_flags(th);
1760 #endif
1761
1762         KASSERT(tp != NULL || m != NULL, ("tcp_respond: tp and m both NULL"));
1763         NET_EPOCH_ASSERT();
1764
1765 #ifdef INET6
1766         isipv6 = ((struct ip *)ipgen)->ip_v == (IPV6_VERSION >> 4);
1767         ip6 = ipgen;
1768 #endif /* INET6 */
1769         ip = ipgen;
1770
1771         if (tp != NULL) {
1772                 inp = tptoinpcb(tp);
1773                 INP_LOCK_ASSERT(inp);
1774         } else
1775                 inp = NULL;
1776
1777         if (m != NULL) {
1778 #ifdef INET6
1779                 if (isipv6 && ip6 && (ip6->ip6_nxt == IPPROTO_UDP))
1780                         port = m->m_pkthdr.tcp_tun_port;
1781                 else
1782 #endif
1783                 if (ip && (ip->ip_p == IPPROTO_UDP))
1784                         port = m->m_pkthdr.tcp_tun_port;
1785                 else
1786                         port = 0;
1787         } else
1788                 port = tp->t_port;
1789
1790         incl_opts = false;
1791         win = 0;
1792         if (tp != NULL) {
1793                 if (!(flags & TH_RST)) {
1794                         win = sbspace(&inp->inp_socket->so_rcv);
1795                         if (win > TCP_MAXWIN << tp->rcv_scale)
1796                                 win = TCP_MAXWIN << tp->rcv_scale;
1797                 }
1798                 if ((tp->t_flags & TF_NOOPT) == 0)
1799                         incl_opts = true;
1800         }
1801         if (m == NULL) {
1802                 m = m_gethdr(M_NOWAIT, MT_DATA);
1803                 if (m == NULL)
1804                         return;
1805                 m->m_data += max_linkhdr;
1806 #ifdef INET6
1807                 if (isipv6) {
1808                         bcopy((caddr_t)ip6, mtod(m, caddr_t),
1809                               sizeof(struct ip6_hdr));
1810                         ip6 = mtod(m, struct ip6_hdr *);
1811                         nth = (struct tcphdr *)(ip6 + 1);
1812                         if (port) {
1813                                 /* Insert a UDP header */
1814                                 uh = (struct udphdr *)nth;
1815                                 uh->uh_sport = htons(V_tcp_udp_tunneling_port);
1816                                 uh->uh_dport = port;
1817                                 nth = (struct tcphdr *)(uh + 1);
1818                         }
1819                 } else
1820 #endif /* INET6 */
1821                 {
1822                         bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
1823                         ip = mtod(m, struct ip *);
1824                         nth = (struct tcphdr *)(ip + 1);
1825                         if (port) {
1826                                 /* Insert a UDP header */
1827                                 uh = (struct udphdr *)nth;
1828                                 uh->uh_sport = htons(V_tcp_udp_tunneling_port);
1829                                 uh->uh_dport = port;
1830                                 nth = (struct tcphdr *)(uh + 1);
1831                         }
1832                 }
1833                 bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
1834                 flags = TH_ACK;
1835         } else if ((!M_WRITABLE(m)) || (port != 0)) {
1836                 struct mbuf *n;
1837
1838                 /* Can't reuse 'm', allocate a new mbuf. */
1839                 n = m_gethdr(M_NOWAIT, MT_DATA);
1840                 if (n == NULL) {
1841                         m_freem(m);
1842                         return;
1843                 }
1844
1845                 if (!m_dup_pkthdr(n, m, M_NOWAIT)) {
1846                         m_freem(m);
1847                         m_freem(n);
1848                         return;
1849                 }
1850
1851                 n->m_data += max_linkhdr;
1852                 /* m_len is set later */
1853 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
1854 #ifdef INET6
1855                 if (isipv6) {
1856                         bcopy((caddr_t)ip6, mtod(n, caddr_t),
1857                               sizeof(struct ip6_hdr));
1858                         ip6 = mtod(n, struct ip6_hdr *);
1859                         xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
1860                         nth = (struct tcphdr *)(ip6 + 1);
1861                         if (port) {
1862                                 /* Insert a UDP header */
1863                                 uh = (struct udphdr *)nth;
1864                                 uh->uh_sport = htons(V_tcp_udp_tunneling_port);
1865                                 uh->uh_dport = port;
1866                                 nth = (struct tcphdr *)(uh + 1);
1867                         }
1868                 } else
1869 #endif /* INET6 */
1870                 {
1871                         bcopy((caddr_t)ip, mtod(n, caddr_t), sizeof(struct ip));
1872                         ip = mtod(n, struct ip *);
1873                         xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, uint32_t);
1874                         nth = (struct tcphdr *)(ip + 1);
1875                         if (port) {
1876                                 /* Insert a UDP header */
1877                                 uh = (struct udphdr *)nth;
1878                                 uh->uh_sport = htons(V_tcp_udp_tunneling_port);
1879                                 uh->uh_dport = port;
1880                                 nth = (struct tcphdr *)(uh + 1);
1881                         }
1882                 }
1883                 bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
1884                 xchg(nth->th_dport, nth->th_sport, uint16_t);
1885                 th = nth;
1886                 m_freem(m);
1887                 m = n;
1888         } else {
1889                 /*
1890                  *  reuse the mbuf.
1891                  * XXX MRT We inherit the FIB, which is lucky.
1892                  */
1893                 m_freem(m->m_next);
1894                 m->m_next = NULL;
1895                 m->m_data = (caddr_t)ipgen;
1896                 /* m_len is set later */
1897 #ifdef INET6
1898                 if (isipv6) {
1899                         xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
1900                         nth = (struct tcphdr *)(ip6 + 1);
1901                 } else
1902 #endif /* INET6 */
1903                 {
1904                         xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, uint32_t);
1905                         nth = (struct tcphdr *)(ip + 1);
1906                 }
1907                 if (th != nth) {
1908                         /*
1909                          * this is usually a case when an extension header
1910                          * exists between the IPv6 header and the
1911                          * TCP header.
1912                          */
1913                         nth->th_sport = th->th_sport;
1914                         nth->th_dport = th->th_dport;
1915                 }
1916                 xchg(nth->th_dport, nth->th_sport, uint16_t);
1917 #undef xchg
1918         }
1919         tlen = 0;
1920 #ifdef INET6
1921         if (isipv6)
1922                 tlen = sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
1923 #endif
1924 #if defined(INET) && defined(INET6)
1925         else
1926 #endif
1927 #ifdef INET
1928                 tlen = sizeof (struct tcpiphdr);
1929 #endif
1930         if (port)
1931                 tlen += sizeof (struct udphdr);
1932 #ifdef INVARIANTS
1933         m->m_len = 0;
1934         KASSERT(M_TRAILINGSPACE(m) >= tlen,
1935             ("Not enough trailing space for message (m=%p, need=%d, have=%ld)",
1936             m, tlen, (long)M_TRAILINGSPACE(m)));
1937 #endif
1938         m->m_len = tlen;
1939         to.to_flags = 0;
1940         if (incl_opts) {
1941                 ect = tcp_ecn_output_established(tp, &flags, 0, false);
1942                 /* Make sure we have room. */
1943                 if (M_TRAILINGSPACE(m) < TCP_MAXOLEN) {
1944                         m->m_next = m_get(M_NOWAIT, MT_DATA);
1945                         if (m->m_next) {
1946                                 optp = mtod(m->m_next, u_char *);
1947                                 optm = m->m_next;
1948                         } else
1949                                 incl_opts = false;
1950                 } else {
1951                         optp = (u_char *) (nth + 1);
1952                         optm = m;
1953                 }
1954         }
1955         if (incl_opts) {
1956                 /* Timestamps. */
1957                 if (tp->t_flags & TF_RCVD_TSTMP) {
1958                         to.to_tsval = tcp_ts_getticks() + tp->ts_offset;
1959                         to.to_tsecr = tp->ts_recent;
1960                         to.to_flags |= TOF_TS;
1961                 }
1962 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1963                 /* TCP-MD5 (RFC2385). */
1964                 if (tp->t_flags & TF_SIGNATURE)
1965                         to.to_flags |= TOF_SIGNATURE;
1966 #endif
1967                 /* Add the options. */
1968                 tlen += optlen = tcp_addoptions(&to, optp);
1969
1970                 /* Update m_len in the correct mbuf. */
1971                 optm->m_len += optlen;
1972         } else
1973                 optlen = 0;
1974 #ifdef INET6
1975         if (isipv6) {
1976                 if (uh) {
1977                         ulen = tlen - sizeof(struct ip6_hdr);
1978                         uh->uh_ulen = htons(ulen);
1979                 }
1980                 ip6->ip6_flow = htonl(ect << 20);
1981                 ip6->ip6_vfc = IPV6_VERSION;
1982                 if (port)
1983                         ip6->ip6_nxt = IPPROTO_UDP;
1984                 else
1985                         ip6->ip6_nxt = IPPROTO_TCP;
1986                 ip6->ip6_plen = htons(tlen - sizeof(*ip6));
1987         }
1988 #endif
1989 #if defined(INET) && defined(INET6)
1990         else
1991 #endif
1992 #ifdef INET
1993         {
1994                 if (uh) {
1995                         ulen = tlen - sizeof(struct ip);
1996                         uh->uh_ulen = htons(ulen);
1997                 }
1998                 ip->ip_tos = ect;
1999                 ip->ip_len = htons(tlen);
2000                 ip->ip_ttl = V_ip_defttl;
2001                 if (port) {
2002                         ip->ip_p = IPPROTO_UDP;
2003                 } else {
2004                         ip->ip_p = IPPROTO_TCP;
2005                 }
2006                 if (V_path_mtu_discovery)
2007                         ip->ip_off |= htons(IP_DF);
2008         }
2009 #endif
2010         m->m_pkthdr.len = tlen;
2011         m->m_pkthdr.rcvif = NULL;
2012 #ifdef MAC
2013         if (inp != NULL) {
2014                 /*
2015                  * Packet is associated with a socket, so allow the
2016                  * label of the response to reflect the socket label.
2017                  */
2018                 INP_LOCK_ASSERT(inp);
2019                 mac_inpcb_create_mbuf(inp, m);
2020         } else {
2021                 /*
2022                  * Packet is not associated with a socket, so possibly
2023                  * update the label in place.
2024                  */
2025                 mac_netinet_tcp_reply(m);
2026         }
2027 #endif
2028         nth->th_seq = htonl(seq);
2029         nth->th_ack = htonl(ack);
2030         nth->th_off = (sizeof (struct tcphdr) + optlen) >> 2;
2031         tcp_set_flags(nth, flags);
2032         if (tp != NULL)
2033                 nth->th_win = htons((u_short) (win >> tp->rcv_scale));
2034         else
2035                 nth->th_win = htons((u_short)win);
2036         nth->th_urp = 0;
2037
2038 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
2039         if (to.to_flags & TOF_SIGNATURE) {
2040                 if (!TCPMD5_ENABLED() ||
2041                     TCPMD5_OUTPUT(m, nth, to.to_signature) != 0) {
2042                         m_freem(m);
2043                         return;
2044                 }
2045         }
2046 #endif
2047
2048 #ifdef INET6
2049         if (isipv6) {
2050                 if (port) {
2051                         m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
2052                         m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2053                         uh->uh_sum = in6_cksum_pseudo(ip6, ulen, IPPROTO_UDP, 0);
2054                         nth->th_sum = 0;
2055                 } else {
2056                         m->m_pkthdr.csum_flags = CSUM_TCP_IPV6;
2057                         m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
2058                         nth->th_sum = in6_cksum_pseudo(ip6,
2059                             tlen - sizeof(struct ip6_hdr), IPPROTO_TCP, 0);
2060                 }
2061                 ip6->ip6_hlim = in6_selecthlim(inp, NULL);
2062         }
2063 #endif /* INET6 */
2064 #if defined(INET6) && defined(INET)
2065         else
2066 #endif
2067 #ifdef INET
2068         {
2069                 if (port) {
2070                         uh->uh_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
2071                             htons(ulen + IPPROTO_UDP));
2072                         m->m_pkthdr.csum_flags = CSUM_UDP;
2073                         m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2074                         nth->th_sum = 0;
2075                 } else {
2076                         m->m_pkthdr.csum_flags = CSUM_TCP;
2077                         m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
2078                         nth->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
2079                             htons((u_short)(tlen - sizeof(struct ip) + ip->ip_p)));
2080                 }
2081         }
2082 #endif /* INET */
2083         TCP_PROBE3(debug__output, tp, th, m);
2084         if (flags & TH_RST)
2085                 TCP_PROBE5(accept__refused, NULL, NULL, m, tp, nth);
2086         lgb = NULL;
2087         if ((tp != NULL) && (tp->t_logstate != TCP_LOG_STATE_OFF)) {
2088                 if (INP_WLOCKED(inp)) {
2089                         union tcp_log_stackspecific log;
2090                         struct timeval tv;
2091
2092                         memset(&log.u_bbr, 0, sizeof(log.u_bbr));
2093                         log.u_bbr.inhpts = inp->inp_in_hpts;
2094                         log.u_bbr.flex8 = 4;
2095                         log.u_bbr.pkts_out = tp->t_maxseg;
2096                         log.u_bbr.timeStamp = tcp_get_usecs(&tv);
2097                         log.u_bbr.delivered = 0;
2098                         lgb = tcp_log_event_(tp, nth, NULL, NULL, TCP_LOG_OUT,
2099                             ERRNO_UNK, 0, &log, false, NULL, NULL, 0, &tv);
2100                 } else {
2101                         /*
2102                          * We can not log the packet, since we only own the
2103                          * read lock, but a write lock is needed. The read lock
2104                          * is not upgraded to a write lock, since only getting
2105                          * the read lock was done intentionally to improve the
2106                          * handling of SYN flooding attacks.
2107                          * This happens only for pure SYN segments received in
2108                          * the initial CLOSED state, or received in a more
2109                          * advanced state than listen and the UDP encapsulation
2110                          * port is unexpected.
2111                          * The incoming SYN segments do not really belong to
2112                          * the TCP connection and the handling does not change
2113                          * the state of the TCP connection. Therefore, the
2114                          * sending of the RST segments is not logged. Please
2115                          * note that also the incoming SYN segments are not
2116                          * logged.
2117                          *
2118                          * The following code ensures that the above description
2119                          * is and stays correct.
2120                          */
2121                         KASSERT((thflags & (TH_ACK|TH_SYN)) == TH_SYN &&
2122                             (tp->t_state == TCPS_CLOSED ||
2123                             (tp->t_state > TCPS_LISTEN && tp->t_port != port)),
2124                             ("%s: Logging of TCP segment with flags 0x%b and "
2125                             "UDP encapsulation port %u skipped in state %s",
2126                             __func__, thflags, PRINT_TH_FLAGS,
2127                             ntohs(port), tcpstates[tp->t_state]));
2128                 }
2129         }
2130
2131         if (flags & TH_ACK)
2132                 TCPSTAT_INC(tcps_sndacks);
2133         else if (flags & (TH_SYN|TH_FIN|TH_RST))
2134                 TCPSTAT_INC(tcps_sndctrl);
2135         TCPSTAT_INC(tcps_sndtotal);
2136
2137 #ifdef INET6
2138         if (isipv6) {
2139                 TCP_PROBE5(send, NULL, tp, ip6, tp, nth);
2140                 output_ret = ip6_output(m, NULL, NULL, 0, NULL, NULL, inp);
2141         }
2142 #endif /* INET6 */
2143 #if defined(INET) && defined(INET6)
2144         else
2145 #endif
2146 #ifdef INET
2147         {
2148                 TCP_PROBE5(send, NULL, tp, ip, tp, nth);
2149                 output_ret = ip_output(m, NULL, NULL, 0, NULL, inp);
2150         }
2151 #endif
2152         if (lgb != NULL)
2153                 lgb->tlb_errno = output_ret;
2154 }
2155
2156 /*
2157  * Create a new TCP control block, making an empty reassembly queue and hooking
2158  * it to the argument protocol control block.  The `inp' parameter must have
2159  * come from the zone allocator set up by tcpcbstor declaration.
2160  */
2161 struct tcpcb *
2162 tcp_newtcpcb(struct inpcb *inp)
2163 {
2164         struct tcpcb *tp = intotcpcb(inp);
2165 #ifdef INET6
2166         int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
2167 #endif /* INET6 */
2168
2169         /*
2170          * Historically allocation was done with M_ZERO.  There is a lot of
2171          * code that rely on that.  For now take safe approach and zero whole
2172          * tcpcb.  This definitely can be optimized.
2173          */
2174         bzero(&tp->t_start_zero, t_zero_size);
2175
2176         /* Initialise cc_var struct for this tcpcb. */
2177         tp->t_ccv.type = IPPROTO_TCP;
2178         tp->t_ccv.ccvc.tcp = tp;
2179         rw_rlock(&tcp_function_lock);
2180         tp->t_fb = tcp_func_set_ptr;
2181         refcount_acquire(&tp->t_fb->tfb_refcnt);
2182         rw_runlock(&tcp_function_lock);
2183         /*
2184          * Use the current system default CC algorithm.
2185          */
2186         cc_attach(tp, CC_DEFAULT_ALGO());
2187
2188         if (CC_ALGO(tp)->cb_init != NULL)
2189                 if (CC_ALGO(tp)->cb_init(&tp->t_ccv, NULL) > 0) {
2190                         cc_detach(tp);
2191                         if (tp->t_fb->tfb_tcp_fb_fini)
2192                                 (*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
2193                         refcount_release(&tp->t_fb->tfb_refcnt);
2194                         return (NULL);
2195                 }
2196
2197 #ifdef TCP_HHOOK
2198         if (khelp_init_osd(HELPER_CLASS_TCP, &tp->t_osd)) {
2199                 if (tp->t_fb->tfb_tcp_fb_fini)
2200                         (*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
2201                 refcount_release(&tp->t_fb->tfb_refcnt);
2202                 return (NULL);
2203         }
2204 #endif
2205
2206         TAILQ_INIT(&tp->t_segq);
2207         tp->t_maxseg =
2208 #ifdef INET6
2209                 isipv6 ? V_tcp_v6mssdflt :
2210 #endif /* INET6 */
2211                 V_tcp_mssdflt;
2212
2213         callout_init_rw(&tp->t_callout, &inp->inp_lock, CALLOUT_RETURNUNLOCKED);
2214         for (int i = 0; i < TT_N; i++)
2215                 tp->t_timers[i] = SBT_MAX;
2216
2217         switch (V_tcp_do_rfc1323) {
2218                 case 0:
2219                         break;
2220                 default:
2221                 case 1:
2222                         tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP);
2223                         break;
2224                 case 2:
2225                         tp->t_flags = TF_REQ_SCALE;
2226                         break;
2227                 case 3:
2228                         tp->t_flags = TF_REQ_TSTMP;
2229                         break;
2230         }
2231         if (V_tcp_do_sack)
2232                 tp->t_flags |= TF_SACK_PERMIT;
2233         TAILQ_INIT(&tp->snd_holes);
2234
2235         /*
2236          * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
2237          * rtt estimate.  Set rttvar so that srtt + 4 * rttvar gives
2238          * reasonable initial retransmit time.
2239          */
2240         tp->t_srtt = TCPTV_SRTTBASE;
2241         tp->t_rttvar = ((tcp_rexmit_initial - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4;
2242         tp->t_rttmin = tcp_rexmit_min;
2243         tp->t_rxtcur = tcp_rexmit_initial;
2244         tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
2245         tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
2246         tp->t_rcvtime = ticks;
2247         /*
2248          * IPv4 TTL initialization is necessary for an IPv6 socket as well,
2249          * because the socket may be bound to an IPv6 wildcard address,
2250          * which may match an IPv4-mapped IPv6 address.
2251          */
2252         inp->inp_ip_ttl = V_ip_defttl;
2253 #ifdef TCPHPTS
2254         /*
2255          * If using hpts lets drop a random number in so
2256          * not all new connections fall on the same CPU.
2257          */
2258         inp->inp_hpts_cpu = hpts_random_cpu(inp);
2259 #endif
2260 #ifdef TCPPCAP
2261         /*
2262          * Init the TCP PCAP queues.
2263          */
2264         tcp_pcap_tcpcb_init(tp);
2265 #endif
2266 #ifdef TCP_BLACKBOX
2267         /* Initialize the per-TCPCB log data. */
2268         tcp_log_tcpcbinit(tp);
2269 #endif
2270         tp->t_pacing_rate = -1;
2271         if (tp->t_fb->tfb_tcp_fb_init) {
2272                 if ((*tp->t_fb->tfb_tcp_fb_init)(tp)) {
2273                         refcount_release(&tp->t_fb->tfb_refcnt);
2274                         return (NULL);
2275                 }
2276         }
2277 #ifdef STATS
2278         if (V_tcp_perconn_stats_enable == 1)
2279                 tp->t_stats = stats_blob_alloc(V_tcp_perconn_stats_dflt_tpl, 0);
2280 #endif
2281         if (V_tcp_do_lrd)
2282                 tp->t_flags |= TF_LRD;
2283
2284         return (tp);
2285 }
2286
2287 /*
2288  * Drop a TCP connection, reporting
2289  * the specified error.  If connection is synchronized,
2290  * then send a RST to peer.
2291  */
2292 struct tcpcb *
2293 tcp_drop(struct tcpcb *tp, int errno)
2294 {
2295         struct socket *so = tptosocket(tp);
2296
2297         NET_EPOCH_ASSERT();
2298         INP_WLOCK_ASSERT(tptoinpcb(tp));
2299
2300         if (TCPS_HAVERCVDSYN(tp->t_state)) {
2301                 tcp_state_change(tp, TCPS_CLOSED);
2302                 /* Don't use tcp_output() here due to possible recursion. */
2303                 (void)tcp_output_nodrop(tp);
2304                 TCPSTAT_INC(tcps_drops);
2305         } else
2306                 TCPSTAT_INC(tcps_conndrops);
2307         if (errno == ETIMEDOUT && tp->t_softerror)
2308                 errno = tp->t_softerror;
2309         so->so_error = errno;
2310         return (tcp_close(tp));
2311 }
2312
2313 void
2314 tcp_discardcb(struct tcpcb *tp)
2315 {
2316         struct inpcb *inp = tptoinpcb(tp);
2317         struct socket *so = tptosocket(tp);
2318 #ifdef INET6
2319         bool isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
2320 #endif
2321
2322         INP_WLOCK_ASSERT(inp);
2323
2324         tcp_timer_stop(tp);
2325         if (tp->t_fb->tfb_tcp_timer_stop_all) {
2326                 tp->t_fb->tfb_tcp_timer_stop_all(tp);
2327         }
2328
2329         /* free the reassembly queue, if any */
2330         tcp_reass_flush(tp);
2331
2332 #ifdef TCP_OFFLOAD
2333         /* Disconnect offload device, if any. */
2334         if (tp->t_flags & TF_TOE)
2335                 tcp_offload_detach(tp);
2336 #endif
2337
2338         tcp_free_sackholes(tp);
2339
2340 #ifdef TCPPCAP
2341         /* Free the TCP PCAP queues. */
2342         tcp_pcap_drain(&(tp->t_inpkts));
2343         tcp_pcap_drain(&(tp->t_outpkts));
2344 #endif
2345
2346         /* Allow the CC algorithm to clean up after itself. */
2347         if (CC_ALGO(tp)->cb_destroy != NULL)
2348                 CC_ALGO(tp)->cb_destroy(&tp->t_ccv);
2349         CC_DATA(tp) = NULL;
2350         /* Detach from the CC algorithm */
2351         cc_detach(tp);
2352
2353 #ifdef TCP_HHOOK
2354         khelp_destroy_osd(&tp->t_osd);
2355 #endif
2356 #ifdef STATS
2357         stats_blob_destroy(tp->t_stats);
2358 #endif
2359
2360         CC_ALGO(tp) = NULL;
2361
2362 #ifdef TCP_BLACKBOX
2363         tcp_log_tcpcbfini(tp);
2364 #endif
2365         TCPSTATES_DEC(tp->t_state);
2366         if (tp->t_fb->tfb_tcp_fb_fini)
2367                 (*tp->t_fb->tfb_tcp_fb_fini)(tp, 1);
2368
2369         /*
2370          * If we got enough samples through the srtt filter,
2371          * save the rtt and rttvar in the routing entry.
2372          * 'Enough' is arbitrarily defined as 4 rtt samples.
2373          * 4 samples is enough for the srtt filter to converge
2374          * to within enough % of the correct value; fewer samples
2375          * and we could save a bogus rtt. The danger is not high
2376          * as tcp quickly recovers from everything.
2377          * XXX: Works very well but needs some more statistics!
2378          *
2379          * XXXRRS: Updating must be after the stack fini() since
2380          * that may be converting some internal representation of
2381          * say srtt etc into the general one used by other stacks.
2382          * Lets also at least protect against the so being NULL
2383          * as RW stated below.
2384          */
2385         if ((tp->t_rttupdated >= 4) && (so != NULL)) {
2386                 struct hc_metrics_lite metrics;
2387                 uint32_t ssthresh;
2388
2389                 bzero(&metrics, sizeof(metrics));
2390                 /*
2391                  * Update the ssthresh always when the conditions below
2392                  * are satisfied. This gives us better new start value
2393                  * for the congestion avoidance for new connections.
2394                  * ssthresh is only set if packet loss occurred on a session.
2395                  *
2396                  * XXXRW: 'so' may be NULL here, and/or socket buffer may be
2397                  * being torn down.  Ideally this code would not use 'so'.
2398                  */
2399                 ssthresh = tp->snd_ssthresh;
2400                 if (ssthresh != 0 && ssthresh < so->so_snd.sb_hiwat / 2) {
2401                         /*
2402                          * convert the limit from user data bytes to
2403                          * packets then to packet data bytes.
2404                          */
2405                         ssthresh = (ssthresh + tp->t_maxseg / 2) / tp->t_maxseg;
2406                         if (ssthresh < 2)
2407                                 ssthresh = 2;
2408                         ssthresh *= (tp->t_maxseg +
2409 #ifdef INET6
2410                             (isipv6 ? sizeof (struct ip6_hdr) +
2411                             sizeof (struct tcphdr) :
2412 #endif
2413                             sizeof (struct tcpiphdr)
2414 #ifdef INET6
2415                             )
2416 #endif
2417                             );
2418                 } else
2419                         ssthresh = 0;
2420                 metrics.rmx_ssthresh = ssthresh;
2421
2422                 metrics.rmx_rtt = tp->t_srtt;
2423                 metrics.rmx_rttvar = tp->t_rttvar;
2424                 metrics.rmx_cwnd = tp->snd_cwnd;
2425                 metrics.rmx_sendpipe = 0;
2426                 metrics.rmx_recvpipe = 0;
2427
2428                 tcp_hc_update(&inp->inp_inc, &metrics);
2429         }
2430
2431         refcount_release(&tp->t_fb->tfb_refcnt);
2432 }
2433
2434 /*
2435  * Attempt to close a TCP control block, marking it as dropped, and freeing
2436  * the socket if we hold the only reference.
2437  */
2438 struct tcpcb *
2439 tcp_close(struct tcpcb *tp)
2440 {
2441         struct inpcb *inp = tptoinpcb(tp);
2442         struct socket *so = tptosocket(tp);
2443
2444         INP_WLOCK_ASSERT(inp);
2445
2446 #ifdef TCP_OFFLOAD
2447         if (tp->t_state == TCPS_LISTEN)
2448                 tcp_offload_listen_stop(tp);
2449 #endif
2450         /*
2451          * This releases the TFO pending counter resource for TFO listen
2452          * sockets as well as passively-created TFO sockets that transition
2453          * from SYN_RECEIVED to CLOSED.
2454          */
2455         if (tp->t_tfo_pending) {
2456                 tcp_fastopen_decrement_counter(tp->t_tfo_pending);
2457                 tp->t_tfo_pending = NULL;
2458         }
2459 #ifdef TCPHPTS
2460         tcp_hpts_remove(inp);
2461 #endif
2462         in_pcbdrop(inp);
2463         TCPSTAT_INC(tcps_closed);
2464         if (tp->t_state != TCPS_CLOSED)
2465                 tcp_state_change(tp, TCPS_CLOSED);
2466         KASSERT(inp->inp_socket != NULL, ("tcp_close: inp_socket NULL"));
2467         soisdisconnected(so);
2468         if (inp->inp_flags & INP_SOCKREF) {
2469                 inp->inp_flags &= ~INP_SOCKREF;
2470                 INP_WUNLOCK(inp);
2471                 sorele(so);
2472                 return (NULL);
2473         }
2474         return (tp);
2475 }
2476
2477 /*
2478  * Notify a tcp user of an asynchronous error;
2479  * store error as soft error, but wake up user
2480  * (for now, won't do anything until can select for soft error).
2481  *
2482  * Do not wake up user since there currently is no mechanism for
2483  * reporting soft errors (yet - a kqueue filter may be added).
2484  */
2485 static struct inpcb *
2486 tcp_notify(struct inpcb *inp, int error)
2487 {
2488         struct tcpcb *tp;
2489
2490         INP_WLOCK_ASSERT(inp);
2491
2492         tp = intotcpcb(inp);
2493         KASSERT(tp != NULL, ("tcp_notify: tp == NULL"));
2494
2495         /*
2496          * Ignore some errors if we are hooked up.
2497          * If connection hasn't completed, has retransmitted several times,
2498          * and receives a second error, give up now.  This is better
2499          * than waiting a long time to establish a connection that
2500          * can never complete.
2501          */
2502         if (tp->t_state == TCPS_ESTABLISHED &&
2503             (error == EHOSTUNREACH || error == ENETUNREACH ||
2504              error == EHOSTDOWN)) {
2505                 if (inp->inp_route.ro_nh) {
2506                         NH_FREE(inp->inp_route.ro_nh);
2507                         inp->inp_route.ro_nh = (struct nhop_object *)NULL;
2508                 }
2509                 return (inp);
2510         } else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 &&
2511             tp->t_softerror) {
2512                 tp = tcp_drop(tp, error);
2513                 if (tp != NULL)
2514                         return (inp);
2515                 else
2516                         return (NULL);
2517         } else {
2518                 tp->t_softerror = error;
2519                 return (inp);
2520         }
2521 #if 0
2522         wakeup( &so->so_timeo);
2523         sorwakeup(so);
2524         sowwakeup(so);
2525 #endif
2526 }
2527
2528 static int
2529 tcp_pcblist(SYSCTL_HANDLER_ARGS)
2530 {
2531         struct inpcb_iterator inpi = INP_ALL_ITERATOR(&V_tcbinfo,
2532             INPLOOKUP_RLOCKPCB);
2533         struct xinpgen xig;
2534         struct inpcb *inp;
2535         int error;
2536
2537         if (req->newptr != NULL)
2538                 return (EPERM);
2539
2540         if (req->oldptr == NULL) {
2541                 int n;
2542
2543                 n = V_tcbinfo.ipi_count +
2544                     counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2545                 n += imax(n / 8, 10);
2546                 req->oldidx = 2 * (sizeof xig) + n * sizeof(struct xtcpcb);
2547                 return (0);
2548         }
2549
2550         if ((error = sysctl_wire_old_buffer(req, 0)) != 0)
2551                 return (error);
2552
2553         bzero(&xig, sizeof(xig));
2554         xig.xig_len = sizeof xig;
2555         xig.xig_count = V_tcbinfo.ipi_count +
2556             counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2557         xig.xig_gen = V_tcbinfo.ipi_gencnt;
2558         xig.xig_sogen = so_gencnt;
2559         error = SYSCTL_OUT(req, &xig, sizeof xig);
2560         if (error)
2561                 return (error);
2562
2563         error = syncache_pcblist(req);
2564         if (error)
2565                 return (error);
2566
2567         while ((inp = inp_next(&inpi)) != NULL) {
2568                 if (inp->inp_gencnt <= xig.xig_gen &&
2569                     cr_canseeinpcb(req->td->td_ucred, inp) == 0) {
2570                         struct xtcpcb xt;
2571
2572                         tcp_inptoxtp(inp, &xt);
2573                         error = SYSCTL_OUT(req, &xt, sizeof xt);
2574                         if (error) {
2575                                 INP_RUNLOCK(inp);
2576                                 break;
2577                         } else
2578                                 continue;
2579                 }
2580         }
2581
2582         if (!error) {
2583                 /*
2584                  * Give the user an updated idea of our state.
2585                  * If the generation differs from what we told
2586                  * her before, she knows that something happened
2587                  * while we were processing this request, and it
2588                  * might be necessary to retry.
2589                  */
2590                 xig.xig_gen = V_tcbinfo.ipi_gencnt;
2591                 xig.xig_sogen = so_gencnt;
2592                 xig.xig_count = V_tcbinfo.ipi_count +
2593                     counter_u64_fetch(V_tcps_states[TCPS_SYN_RECEIVED]);
2594                 error = SYSCTL_OUT(req, &xig, sizeof xig);
2595         }
2596
2597         return (error);
2598 }
2599
2600 SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist,
2601     CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
2602     NULL, 0, tcp_pcblist, "S,xtcpcb",
2603     "List of active TCP connections");
2604
2605 #ifdef INET
2606 static int
2607 tcp_getcred(SYSCTL_HANDLER_ARGS)
2608 {
2609         struct xucred xuc;
2610         struct sockaddr_in addrs[2];
2611         struct epoch_tracker et;
2612         struct inpcb *inp;
2613         int error;
2614
2615         error = priv_check(req->td, PRIV_NETINET_GETCRED);
2616         if (error)
2617                 return (error);
2618         error = SYSCTL_IN(req, addrs, sizeof(addrs));
2619         if (error)
2620                 return (error);
2621         NET_EPOCH_ENTER(et);
2622         inp = in_pcblookup(&V_tcbinfo, addrs[1].sin_addr, addrs[1].sin_port,
2623             addrs[0].sin_addr, addrs[0].sin_port, INPLOOKUP_RLOCKPCB, NULL);
2624         NET_EPOCH_EXIT(et);
2625         if (inp != NULL) {
2626                 if (error == 0)
2627                         error = cr_canseeinpcb(req->td->td_ucred, inp);
2628                 if (error == 0)
2629                         cru2x(inp->inp_cred, &xuc);
2630                 INP_RUNLOCK(inp);
2631         } else
2632                 error = ENOENT;
2633         if (error == 0)
2634                 error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
2635         return (error);
2636 }
2637
2638 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, getcred,
2639     CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_NEEDGIANT,
2640     0, 0, tcp_getcred, "S,xucred",
2641     "Get the xucred of a TCP connection");
2642 #endif /* INET */
2643
2644 #ifdef INET6
2645 static int
2646 tcp6_getcred(SYSCTL_HANDLER_ARGS)
2647 {
2648         struct epoch_tracker et;
2649         struct xucred xuc;
2650         struct sockaddr_in6 addrs[2];
2651         struct inpcb *inp;
2652         int error;
2653 #ifdef INET
2654         int mapped = 0;
2655 #endif
2656
2657         error = priv_check(req->td, PRIV_NETINET_GETCRED);
2658         if (error)
2659                 return (error);
2660         error = SYSCTL_IN(req, addrs, sizeof(addrs));
2661         if (error)
2662                 return (error);
2663         if ((error = sa6_embedscope(&addrs[0], V_ip6_use_defzone)) != 0 ||
2664             (error = sa6_embedscope(&addrs[1], V_ip6_use_defzone)) != 0) {
2665                 return (error);
2666         }
2667         if (IN6_IS_ADDR_V4MAPPED(&addrs[0].sin6_addr)) {
2668 #ifdef INET
2669                 if (IN6_IS_ADDR_V4MAPPED(&addrs[1].sin6_addr))
2670                         mapped = 1;
2671                 else
2672 #endif
2673                         return (EINVAL);
2674         }
2675
2676         NET_EPOCH_ENTER(et);
2677 #ifdef INET
2678         if (mapped == 1)
2679                 inp = in_pcblookup(&V_tcbinfo,
2680                         *(struct in_addr *)&addrs[1].sin6_addr.s6_addr[12],
2681                         addrs[1].sin6_port,
2682                         *(struct in_addr *)&addrs[0].sin6_addr.s6_addr[12],
2683                         addrs[0].sin6_port, INPLOOKUP_RLOCKPCB, NULL);
2684         else
2685 #endif
2686                 inp = in6_pcblookup(&V_tcbinfo,
2687                         &addrs[1].sin6_addr, addrs[1].sin6_port,
2688                         &addrs[0].sin6_addr, addrs[0].sin6_port,
2689                         INPLOOKUP_RLOCKPCB, NULL);
2690         NET_EPOCH_EXIT(et);
2691         if (inp != NULL) {
2692                 if (error == 0)
2693                         error = cr_canseeinpcb(req->td->td_ucred, inp);
2694                 if (error == 0)
2695                         cru2x(inp->inp_cred, &xuc);
2696                 INP_RUNLOCK(inp);
2697         } else
2698                 error = ENOENT;
2699         if (error == 0)
2700                 error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
2701         return (error);
2702 }
2703
2704 SYSCTL_PROC(_net_inet6_tcp6, OID_AUTO, getcred,
2705     CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_NEEDGIANT,
2706     0, 0, tcp6_getcred, "S,xucred",
2707     "Get the xucred of a TCP6 connection");
2708 #endif /* INET6 */
2709
2710 #ifdef INET
2711 /* Path MTU to try next when a fragmentation-needed message is received. */
2712 static inline int
2713 tcp_next_pmtu(const struct icmp *icp, const struct ip *ip)
2714 {
2715         int mtu = ntohs(icp->icmp_nextmtu);
2716
2717         /* If no alternative MTU was proposed, try the next smaller one. */
2718         if (!mtu)
2719                 mtu = ip_next_mtu(ntohs(ip->ip_len), 1);
2720         if (mtu < V_tcp_minmss + sizeof(struct tcpiphdr))
2721                 mtu = V_tcp_minmss + sizeof(struct tcpiphdr);
2722
2723         return (mtu);
2724 }
2725
2726 static void
2727 tcp_ctlinput_with_port(struct icmp *icp, uint16_t port)
2728 {
2729         struct ip *ip;
2730         struct tcphdr *th;
2731         struct inpcb *inp;
2732         struct tcpcb *tp;
2733         struct inpcb *(*notify)(struct inpcb *, int);
2734         struct in_conninfo inc;
2735         tcp_seq icmp_tcp_seq;
2736         int errno, mtu;
2737
2738         errno = icmp_errmap(icp);
2739         switch (errno) {
2740         case 0:
2741                 return;
2742         case EMSGSIZE:
2743                 notify = tcp_mtudisc_notify;
2744                 break;
2745         case ECONNREFUSED:
2746                 if (V_icmp_may_rst)
2747                         notify = tcp_drop_syn_sent;
2748                 else
2749                         notify = tcp_notify;
2750                 break;
2751         case EHOSTUNREACH:
2752                 if (V_icmp_may_rst && icp->icmp_type == ICMP_TIMXCEED)
2753                         notify = tcp_drop_syn_sent;
2754                 else
2755                         notify = tcp_notify;
2756                 break;
2757         default:
2758                 notify = tcp_notify;
2759         }
2760
2761         ip = &icp->icmp_ip;
2762         th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
2763         icmp_tcp_seq = th->th_seq;
2764         inp = in_pcblookup(&V_tcbinfo, ip->ip_dst, th->th_dport, ip->ip_src,
2765             th->th_sport, INPLOOKUP_WLOCKPCB, NULL);
2766         if (inp != NULL)  {
2767                 tp = intotcpcb(inp);
2768 #ifdef TCP_OFFLOAD
2769                 if (tp->t_flags & TF_TOE && errno == EMSGSIZE) {
2770                         /*
2771                          * MTU discovery for offloaded connections.  Let
2772                          * the TOE driver verify seq# and process it.
2773                          */
2774                         mtu = tcp_next_pmtu(icp, ip);
2775                         tcp_offload_pmtu_update(tp, icmp_tcp_seq, mtu);
2776                         goto out;
2777                 }
2778 #endif
2779                 if (tp->t_port != port)
2780                         goto out;
2781                 if (SEQ_GEQ(ntohl(icmp_tcp_seq), tp->snd_una) &&
2782                     SEQ_LT(ntohl(icmp_tcp_seq), tp->snd_max)) {
2783                         if (errno == EMSGSIZE) {
2784                                 /*
2785                                  * MTU discovery: we got a needfrag and
2786                                  * will potentially try a lower MTU.
2787                                  */
2788                                 mtu = tcp_next_pmtu(icp, ip);
2789
2790                                 /*
2791                                  * Only process the offered MTU if it
2792                                  * is smaller than the current one.
2793                                  */
2794                                 if (mtu < tp->t_maxseg +
2795                                     sizeof(struct tcpiphdr)) {
2796                                         bzero(&inc, sizeof(inc));
2797                                         inc.inc_faddr = ip->ip_dst;
2798                                         inc.inc_fibnum =
2799                                             inp->inp_inc.inc_fibnum;
2800                                         tcp_hc_updatemtu(&inc, mtu);
2801                                         inp = tcp_mtudisc(inp, mtu);
2802                                 }
2803                         } else
2804                                 inp = (*notify)(inp, errno);
2805                 }
2806         } else {
2807                 bzero(&inc, sizeof(inc));
2808                 inc.inc_fport = th->th_dport;
2809                 inc.inc_lport = th->th_sport;
2810                 inc.inc_faddr = ip->ip_dst;
2811                 inc.inc_laddr = ip->ip_src;
2812                 syncache_unreach(&inc, icmp_tcp_seq, port);
2813         }
2814 out:
2815         if (inp != NULL)
2816                 INP_WUNLOCK(inp);
2817 }
2818
2819 static void
2820 tcp_ctlinput(struct icmp *icmp)
2821 {
2822         tcp_ctlinput_with_port(icmp, htons(0));
2823 }
2824
2825 static void
2826 tcp_ctlinput_viaudp(udp_tun_icmp_param_t param)
2827 {
2828         /* Its a tunneled TCP over UDP icmp */
2829         struct icmp *icmp = param.icmp;
2830         struct ip *outer_ip, *inner_ip;
2831         struct udphdr *udp;
2832         struct tcphdr *th, ttemp;
2833         int i_hlen, o_len;
2834         uint16_t port;
2835
2836         outer_ip = (struct ip *)((caddr_t)icmp - sizeof(struct ip));
2837         inner_ip = &icmp->icmp_ip;
2838         i_hlen = inner_ip->ip_hl << 2;
2839         o_len = ntohs(outer_ip->ip_len);
2840         if (o_len <
2841             (sizeof(struct ip) + 8 + i_hlen + sizeof(struct udphdr) + offsetof(struct tcphdr, th_ack))) {
2842                 /* Not enough data present */
2843                 return;
2844         }
2845         /* Ok lets strip out the inner udphdr header by copying up on top of it the tcp hdr */
2846         udp = (struct udphdr *)(((caddr_t)inner_ip) + i_hlen);
2847         if (ntohs(udp->uh_sport) != V_tcp_udp_tunneling_port) {
2848                 return;
2849         }
2850         port = udp->uh_dport;
2851         th = (struct tcphdr *)(udp + 1);
2852         memcpy(&ttemp, th, sizeof(struct tcphdr));
2853         memcpy(udp, &ttemp, sizeof(struct tcphdr));
2854         /* Now adjust down the size of the outer IP header */
2855         o_len -= sizeof(struct udphdr);
2856         outer_ip->ip_len = htons(o_len);
2857         /* Now call in to the normal handling code */
2858         tcp_ctlinput_with_port(icmp, port);
2859 }
2860 #endif /* INET */
2861
2862 #ifdef INET6
2863 static inline int
2864 tcp6_next_pmtu(const struct icmp6_hdr *icmp6)
2865 {
2866         int mtu = ntohl(icmp6->icmp6_mtu);
2867
2868         /*
2869          * If no alternative MTU was proposed, or the proposed MTU was too
2870          * small, set to the min.
2871          */
2872         if (mtu < IPV6_MMTU)
2873                 mtu = IPV6_MMTU - 8;    /* XXXNP: what is the adjustment for? */
2874         return (mtu);
2875 }
2876
2877 static void
2878 tcp6_ctlinput_with_port(struct ip6ctlparam *ip6cp, uint16_t port)
2879 {
2880         struct in6_addr *dst;
2881         struct inpcb *(*notify)(struct inpcb *, int);
2882         struct ip6_hdr *ip6;
2883         struct mbuf *m;
2884         struct inpcb *inp;
2885         struct tcpcb *tp;
2886         struct icmp6_hdr *icmp6;
2887         struct in_conninfo inc;
2888         struct tcp_ports {
2889                 uint16_t th_sport;
2890                 uint16_t th_dport;
2891         } t_ports;
2892         tcp_seq icmp_tcp_seq;
2893         unsigned int mtu;
2894         unsigned int off;
2895         int errno;
2896
2897         icmp6 = ip6cp->ip6c_icmp6;
2898         m = ip6cp->ip6c_m;
2899         ip6 = ip6cp->ip6c_ip6;
2900         off = ip6cp->ip6c_off;
2901         dst = &ip6cp->ip6c_finaldst->sin6_addr;
2902
2903         errno = icmp6_errmap(icmp6);
2904         switch (errno) {
2905         case 0:
2906                 return;
2907         case EMSGSIZE:
2908                 notify = tcp_mtudisc_notify;
2909                 break;
2910         case ECONNREFUSED:
2911                 if (V_icmp_may_rst)
2912                         notify = tcp_drop_syn_sent;
2913                 else
2914                         notify = tcp_notify;
2915                 break;
2916         case EHOSTUNREACH:
2917                 /*
2918                  * There are only four ICMPs that may reset connection:
2919                  * - administratively prohibited
2920                  * - port unreachable
2921                  * - time exceeded in transit
2922                  * - unknown next header
2923                  */
2924                 if (V_icmp_may_rst &&
2925                     ((icmp6->icmp6_type == ICMP6_DST_UNREACH &&
2926                      (icmp6->icmp6_code == ICMP6_DST_UNREACH_ADMIN ||
2927                       icmp6->icmp6_code == ICMP6_DST_UNREACH_NOPORT)) ||
2928                     (icmp6->icmp6_type == ICMP6_TIME_EXCEEDED &&
2929                       icmp6->icmp6_code == ICMP6_TIME_EXCEED_TRANSIT) ||
2930                     (icmp6->icmp6_type == ICMP6_PARAM_PROB &&
2931                       icmp6->icmp6_code == ICMP6_PARAMPROB_NEXTHEADER)))
2932                         notify = tcp_drop_syn_sent;
2933                 else
2934                         notify = tcp_notify;
2935                 break;
2936         default:
2937                 notify = tcp_notify;
2938         }
2939
2940         /* Check if we can safely get the ports from the tcp hdr */
2941         if (m == NULL ||
2942             (m->m_pkthdr.len <
2943                 (int32_t) (off + sizeof(struct tcp_ports)))) {
2944                 return;
2945         }
2946         bzero(&t_ports, sizeof(struct tcp_ports));
2947         m_copydata(m, off, sizeof(struct tcp_ports), (caddr_t)&t_ports);
2948         inp = in6_pcblookup(&V_tcbinfo, &ip6->ip6_dst, t_ports.th_dport,
2949             &ip6->ip6_src, t_ports.th_sport, INPLOOKUP_WLOCKPCB, NULL);
2950         off += sizeof(struct tcp_ports);
2951         if (m->m_pkthdr.len < (int32_t) (off + sizeof(tcp_seq))) {
2952                 goto out;
2953         }
2954         m_copydata(m, off, sizeof(tcp_seq), (caddr_t)&icmp_tcp_seq);
2955         if (inp != NULL)  {
2956                 tp = intotcpcb(inp);
2957 #ifdef TCP_OFFLOAD
2958                 if (tp->t_flags & TF_TOE && errno == EMSGSIZE) {
2959                         /* MTU discovery for offloaded connections. */
2960                         mtu = tcp6_next_pmtu(icmp6);
2961                         tcp_offload_pmtu_update(tp, icmp_tcp_seq, mtu);
2962                         goto out;
2963                 }
2964 #endif
2965                 if (tp->t_port != port)
2966                         goto out;
2967                 if (SEQ_GEQ(ntohl(icmp_tcp_seq), tp->snd_una) &&
2968                     SEQ_LT(ntohl(icmp_tcp_seq), tp->snd_max)) {
2969                         if (errno == EMSGSIZE) {
2970                                 /*
2971                                  * MTU discovery:
2972                                  * If we got a needfrag set the MTU
2973                                  * in the route to the suggested new
2974                                  * value (if given) and then notify.
2975                                  */
2976                                 mtu = tcp6_next_pmtu(icmp6);
2977
2978                                 bzero(&inc, sizeof(inc));
2979                                 inc.inc_fibnum = M_GETFIB(m);
2980                                 inc.inc_flags |= INC_ISIPV6;
2981                                 inc.inc6_faddr = *dst;
2982                                 if (in6_setscope(&inc.inc6_faddr,
2983                                         m->m_pkthdr.rcvif, NULL))
2984                                         goto out;
2985                                 /*
2986                                  * Only process the offered MTU if it
2987                                  * is smaller than the current one.
2988                                  */
2989                                 if (mtu < tp->t_maxseg +
2990                                     sizeof (struct tcphdr) +
2991                                     sizeof (struct ip6_hdr)) {
2992                                         tcp_hc_updatemtu(&inc, mtu);
2993                                         tcp_mtudisc(inp, mtu);
2994                                         ICMP6STAT_INC(icp6s_pmtuchg);
2995                                 }
2996                         } else
2997                                 inp = (*notify)(inp, errno);
2998                 }
2999         } else {
3000                 bzero(&inc, sizeof(inc));
3001                 inc.inc_fibnum = M_GETFIB(m);
3002                 inc.inc_flags |= INC_ISIPV6;
3003                 inc.inc_fport = t_ports.th_dport;
3004                 inc.inc_lport = t_ports.th_sport;
3005                 inc.inc6_faddr = *dst;
3006                 inc.inc6_laddr = ip6->ip6_src;
3007                 syncache_unreach(&inc, icmp_tcp_seq, port);
3008         }
3009 out:
3010         if (inp != NULL)
3011                 INP_WUNLOCK(inp);
3012 }
3013
3014 static void
3015 tcp6_ctlinput(struct ip6ctlparam *ctl)
3016 {
3017         tcp6_ctlinput_with_port(ctl, htons(0));
3018 }
3019
3020 static void
3021 tcp6_ctlinput_viaudp(udp_tun_icmp_param_t param)
3022 {
3023         struct ip6ctlparam *ip6cp = param.ip6cp;
3024         struct mbuf *m;
3025         struct udphdr *udp;
3026         uint16_t port;
3027
3028         m = m_pulldown(ip6cp->ip6c_m, ip6cp->ip6c_off, sizeof(struct udphdr), NULL);
3029         if (m == NULL) {
3030                 return;
3031         }
3032         udp = mtod(m, struct udphdr *);
3033         if (ntohs(udp->uh_sport) != V_tcp_udp_tunneling_port) {
3034                 return;
3035         }
3036         port = udp->uh_dport;
3037         m_adj(m, sizeof(struct udphdr));
3038         if ((m->m_flags & M_PKTHDR) == 0) {
3039                 ip6cp->ip6c_m->m_pkthdr.len -= sizeof(struct udphdr);
3040         }
3041         /* Now call in to the normal handling code */
3042         tcp6_ctlinput_with_port(ip6cp, port);
3043 }
3044
3045 #endif /* INET6 */
3046
3047 static uint32_t
3048 tcp_keyed_hash(struct in_conninfo *inc, u_char *key, u_int len)
3049 {
3050         SIPHASH_CTX ctx;
3051         uint32_t hash[2];
3052
3053         KASSERT(len >= SIPHASH_KEY_LENGTH,
3054             ("%s: keylen %u too short ", __func__, len));
3055         SipHash24_Init(&ctx);
3056         SipHash_SetKey(&ctx, (uint8_t *)key);
3057         SipHash_Update(&ctx, &inc->inc_fport, sizeof(uint16_t));
3058         SipHash_Update(&ctx, &inc->inc_lport, sizeof(uint16_t));
3059         switch (inc->inc_flags & INC_ISIPV6) {
3060 #ifdef INET
3061         case 0:
3062                 SipHash_Update(&ctx, &inc->inc_faddr, sizeof(struct in_addr));
3063                 SipHash_Update(&ctx, &inc->inc_laddr, sizeof(struct in_addr));
3064                 break;
3065 #endif
3066 #ifdef INET6
3067         case INC_ISIPV6:
3068                 SipHash_Update(&ctx, &inc->inc6_faddr, sizeof(struct in6_addr));
3069                 SipHash_Update(&ctx, &inc->inc6_laddr, sizeof(struct in6_addr));
3070                 break;
3071 #endif
3072         }
3073         SipHash_Final((uint8_t *)hash, &ctx);
3074
3075         return (hash[0] ^ hash[1]);
3076 }
3077
3078 uint32_t
3079 tcp_new_ts_offset(struct in_conninfo *inc)
3080 {
3081         struct in_conninfo inc_store, *local_inc;
3082
3083         if (!V_tcp_ts_offset_per_conn) {
3084                 memcpy(&inc_store, inc, sizeof(struct in_conninfo));
3085                 inc_store.inc_lport = 0;
3086                 inc_store.inc_fport = 0;
3087                 local_inc = &inc_store;
3088         } else {
3089                 local_inc = inc;
3090         }
3091         return (tcp_keyed_hash(local_inc, V_ts_offset_secret,
3092             sizeof(V_ts_offset_secret)));
3093 }
3094
3095 /*
3096  * Following is where TCP initial sequence number generation occurs.
3097  *
3098  * There are two places where we must use initial sequence numbers:
3099  * 1.  In SYN-ACK packets.
3100  * 2.  In SYN packets.
3101  *
3102  * All ISNs for SYN-ACK packets are generated by the syncache.  See
3103  * tcp_syncache.c for details.
3104  *
3105  * The ISNs in SYN packets must be monotonic; TIME_WAIT recycling
3106  * depends on this property.  In addition, these ISNs should be
3107  * unguessable so as to prevent connection hijacking.  To satisfy
3108  * the requirements of this situation, the algorithm outlined in
3109  * RFC 1948 is used, with only small modifications.
3110  *
3111  * Implementation details:
3112  *
3113  * Time is based off the system timer, and is corrected so that it
3114  * increases by one megabyte per second.  This allows for proper
3115  * recycling on high speed LANs while still leaving over an hour
3116  * before rollover.
3117  *
3118  * As reading the *exact* system time is too expensive to be done
3119  * whenever setting up a TCP connection, we increment the time
3120  * offset in two ways.  First, a small random positive increment
3121  * is added to isn_offset for each connection that is set up.
3122  * Second, the function tcp_isn_tick fires once per clock tick
3123  * and increments isn_offset as necessary so that sequence numbers
3124  * are incremented at approximately ISN_BYTES_PER_SECOND.  The
3125  * random positive increments serve only to ensure that the same
3126  * exact sequence number is never sent out twice (as could otherwise
3127  * happen when a port is recycled in less than the system tick
3128  * interval.)
3129  *
3130  * net.inet.tcp.isn_reseed_interval controls the number of seconds
3131  * between seeding of isn_secret.  This is normally set to zero,
3132  * as reseeding should not be necessary.
3133  *
3134  * Locking of the global variables isn_secret, isn_last_reseed, isn_offset,
3135  * isn_offset_old, and isn_ctx is performed using the ISN lock.  In
3136  * general, this means holding an exclusive (write) lock.
3137  */
3138
3139 #define ISN_BYTES_PER_SECOND 1048576
3140 #define ISN_STATIC_INCREMENT 4096
3141 #define ISN_RANDOM_INCREMENT (4096 - 1)
3142 #define ISN_SECRET_LENGTH    SIPHASH_KEY_LENGTH
3143
3144 VNET_DEFINE_STATIC(u_char, isn_secret[ISN_SECRET_LENGTH]);
3145 VNET_DEFINE_STATIC(int, isn_last);
3146 VNET_DEFINE_STATIC(int, isn_last_reseed);
3147 VNET_DEFINE_STATIC(u_int32_t, isn_offset);
3148 VNET_DEFINE_STATIC(u_int32_t, isn_offset_old);
3149
3150 #define V_isn_secret                    VNET(isn_secret)
3151 #define V_isn_last                      VNET(isn_last)
3152 #define V_isn_last_reseed               VNET(isn_last_reseed)
3153 #define V_isn_offset                    VNET(isn_offset)
3154 #define V_isn_offset_old                VNET(isn_offset_old)
3155
3156 tcp_seq
3157 tcp_new_isn(struct in_conninfo *inc)
3158 {
3159         tcp_seq new_isn;
3160         u_int32_t projected_offset;
3161
3162         ISN_LOCK();
3163         /* Seed if this is the first use, reseed if requested. */
3164         if ((V_isn_last_reseed == 0) || ((V_tcp_isn_reseed_interval > 0) &&
3165              (((u_int)V_isn_last_reseed + (u_int)V_tcp_isn_reseed_interval*hz)
3166                 < (u_int)ticks))) {
3167                 arc4rand(&V_isn_secret, sizeof(V_isn_secret), 0);
3168                 V_isn_last_reseed = ticks;
3169         }
3170
3171         /* Compute the hash and return the ISN. */
3172         new_isn = (tcp_seq)tcp_keyed_hash(inc, V_isn_secret,
3173             sizeof(V_isn_secret));
3174         V_isn_offset += ISN_STATIC_INCREMENT +
3175                 (arc4random() & ISN_RANDOM_INCREMENT);
3176         if (ticks != V_isn_last) {
3177                 projected_offset = V_isn_offset_old +
3178                     ISN_BYTES_PER_SECOND / hz * (ticks - V_isn_last);
3179                 if (SEQ_GT(projected_offset, V_isn_offset))
3180                         V_isn_offset = projected_offset;
3181                 V_isn_offset_old = V_isn_offset;
3182                 V_isn_last = ticks;
3183         }
3184         new_isn += V_isn_offset;
3185         ISN_UNLOCK();
3186         return (new_isn);
3187 }
3188
3189 /*
3190  * When a specific ICMP unreachable message is received and the
3191  * connection state is SYN-SENT, drop the connection.  This behavior
3192  * is controlled by the icmp_may_rst sysctl.
3193  */
3194 static struct inpcb *
3195 tcp_drop_syn_sent(struct inpcb *inp, int errno)
3196 {
3197         struct tcpcb *tp;
3198
3199         NET_EPOCH_ASSERT();
3200         INP_WLOCK_ASSERT(inp);
3201
3202         tp = intotcpcb(inp);
3203         if (tp->t_state != TCPS_SYN_SENT)
3204                 return (inp);
3205
3206         if (IS_FASTOPEN(tp->t_flags))
3207                 tcp_fastopen_disable_path(tp);
3208
3209         tp = tcp_drop(tp, errno);
3210         if (tp != NULL)
3211                 return (inp);
3212         else
3213                 return (NULL);
3214 }
3215
3216 /*
3217  * When `need fragmentation' ICMP is received, update our idea of the MSS
3218  * based on the new value. Also nudge TCP to send something, since we
3219  * know the packet we just sent was dropped.
3220  * This duplicates some code in the tcp_mss() function in tcp_input.c.
3221  */
3222 static struct inpcb *
3223 tcp_mtudisc_notify(struct inpcb *inp, int error)
3224 {
3225
3226         return (tcp_mtudisc(inp, -1));
3227 }
3228
3229 static struct inpcb *
3230 tcp_mtudisc(struct inpcb *inp, int mtuoffer)
3231 {
3232         struct tcpcb *tp;
3233         struct socket *so;
3234
3235         INP_WLOCK_ASSERT(inp);
3236
3237         tp = intotcpcb(inp);
3238         KASSERT(tp != NULL, ("tcp_mtudisc: tp == NULL"));
3239
3240         tcp_mss_update(tp, -1, mtuoffer, NULL, NULL);
3241
3242         so = inp->inp_socket;
3243         SOCKBUF_LOCK(&so->so_snd);
3244         /* If the mss is larger than the socket buffer, decrease the mss. */
3245         if (so->so_snd.sb_hiwat < tp->t_maxseg)
3246                 tp->t_maxseg = so->so_snd.sb_hiwat;
3247         SOCKBUF_UNLOCK(&so->so_snd);
3248
3249         TCPSTAT_INC(tcps_mturesent);
3250         tp->t_rtttime = 0;
3251         tp->snd_nxt = tp->snd_una;
3252         tcp_free_sackholes(tp);
3253         tp->snd_recover = tp->snd_max;
3254         if (tp->t_flags & TF_SACK_PERMIT)
3255                 EXIT_FASTRECOVERY(tp->t_flags);
3256         if (tp->t_fb->tfb_tcp_mtu_chg != NULL) {
3257                 /*
3258                  * Conceptually the snd_nxt setting
3259                  * and freeing sack holes should
3260                  * be done by the default stacks
3261                  * own tfb_tcp_mtu_chg().
3262                  */
3263                 tp->t_fb->tfb_tcp_mtu_chg(tp);
3264         }
3265         if (tcp_output(tp) < 0)
3266                 return (NULL);
3267         else
3268                 return (inp);
3269 }
3270
3271 #ifdef INET
3272 /*
3273  * Look-up the routing entry to the peer of this inpcb.  If no route
3274  * is found and it cannot be allocated, then return 0.  This routine
3275  * is called by TCP routines that access the rmx structure and by
3276  * tcp_mss_update to get the peer/interface MTU.
3277  */
3278 uint32_t
3279 tcp_maxmtu(struct in_conninfo *inc, struct tcp_ifcap *cap)
3280 {
3281         struct nhop_object *nh;
3282         struct ifnet *ifp;
3283         uint32_t maxmtu = 0;
3284
3285         KASSERT(inc != NULL, ("tcp_maxmtu with NULL in_conninfo pointer"));
3286
3287         if (inc->inc_faddr.s_addr != INADDR_ANY) {
3288                 nh = fib4_lookup(inc->inc_fibnum, inc->inc_faddr, 0, NHR_NONE, 0);
3289                 if (nh == NULL)
3290                         return (0);
3291
3292                 ifp = nh->nh_ifp;
3293                 maxmtu = nh->nh_mtu;
3294
3295                 /* Report additional interface capabilities. */
3296                 if (cap != NULL) {
3297                         if (ifp->if_capenable & IFCAP_TSO4 &&
3298                             ifp->if_hwassist & CSUM_TSO) {
3299                                 cap->ifcap |= CSUM_TSO;
3300                                 cap->tsomax = ifp->if_hw_tsomax;
3301                                 cap->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
3302                                 cap->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
3303                         }
3304                 }
3305         }
3306         return (maxmtu);
3307 }
3308 #endif /* INET */
3309
3310 #ifdef INET6
3311 uint32_t
3312 tcp_maxmtu6(struct in_conninfo *inc, struct tcp_ifcap *cap)
3313 {
3314         struct nhop_object *nh;
3315         struct in6_addr dst6;
3316         uint32_t scopeid;
3317         struct ifnet *ifp;
3318         uint32_t maxmtu = 0;
3319
3320         KASSERT(inc != NULL, ("tcp_maxmtu6 with NULL in_conninfo pointer"));
3321
3322         if (inc->inc_flags & INC_IPV6MINMTU)
3323                 return (IPV6_MMTU);
3324
3325         if (!IN6_IS_ADDR_UNSPECIFIED(&inc->inc6_faddr)) {
3326                 in6_splitscope(&inc->inc6_faddr, &dst6, &scopeid);
3327                 nh = fib6_lookup(inc->inc_fibnum, &dst6, scopeid, NHR_NONE, 0);
3328                 if (nh == NULL)
3329                         return (0);
3330
3331                 ifp = nh->nh_ifp;
3332                 maxmtu = nh->nh_mtu;
3333
3334                 /* Report additional interface capabilities. */
3335                 if (cap != NULL) {
3336                         if (ifp->if_capenable & IFCAP_TSO6 &&
3337                             ifp->if_hwassist & CSUM_TSO) {
3338                                 cap->ifcap |= CSUM_TSO;
3339                                 cap->tsomax = ifp->if_hw_tsomax;
3340                                 cap->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
3341                                 cap->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
3342                         }
3343                 }
3344         }
3345
3346         return (maxmtu);
3347 }
3348
3349 /*
3350  * Handle setsockopt(IPV6_USE_MIN_MTU) by a TCP stack.
3351  *
3352  * XXXGL: we are updating inpcb here with INC_IPV6MINMTU flag.
3353  * The right place to do that is ip6_setpktopt() that has just been
3354  * executed.  By the way it just filled ip6po_minmtu for us.
3355  */
3356 void
3357 tcp6_use_min_mtu(struct tcpcb *tp)
3358 {
3359         struct inpcb *inp = tptoinpcb(tp);
3360
3361         INP_WLOCK_ASSERT(inp);
3362         /*
3363          * In case of the IPV6_USE_MIN_MTU socket
3364          * option, the INC_IPV6MINMTU flag to announce
3365          * a corresponding MSS during the initial
3366          * handshake.  If the TCP connection is not in
3367          * the front states, just reduce the MSS being
3368          * used.  This avoids the sending of TCP
3369          * segments which will be fragmented at the
3370          * IPv6 layer.
3371          */
3372         inp->inp_inc.inc_flags |= INC_IPV6MINMTU;
3373         if ((tp->t_state >= TCPS_SYN_SENT) &&
3374             (inp->inp_inc.inc_flags & INC_ISIPV6)) {
3375                 struct ip6_pktopts *opt;
3376
3377                 opt = inp->in6p_outputopts;
3378                 if (opt != NULL && opt->ip6po_minmtu == IP6PO_MINMTU_ALL &&
3379                     tp->t_maxseg > TCP6_MSS)
3380                         tp->t_maxseg = TCP6_MSS;
3381         }
3382 }
3383 #endif /* INET6 */
3384
3385 /*
3386  * Calculate effective SMSS per RFC5681 definition for a given TCP
3387  * connection at its current state, taking into account SACK and etc.
3388  */
3389 u_int
3390 tcp_maxseg(const struct tcpcb *tp)
3391 {
3392         u_int optlen;
3393
3394         if (tp->t_flags & TF_NOOPT)
3395                 return (tp->t_maxseg);
3396
3397         /*
3398          * Here we have a simplified code from tcp_addoptions(),
3399          * without a proper loop, and having most of paddings hardcoded.
3400          * We might make mistakes with padding here in some edge cases,
3401          * but this is harmless, since result of tcp_maxseg() is used
3402          * only in cwnd and ssthresh estimations.
3403          */
3404         if (TCPS_HAVEESTABLISHED(tp->t_state)) {
3405                 if (tp->t_flags & TF_RCVD_TSTMP)
3406                         optlen = TCPOLEN_TSTAMP_APPA;
3407                 else
3408                         optlen = 0;
3409 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3410                 if (tp->t_flags & TF_SIGNATURE)
3411                         optlen += PADTCPOLEN(TCPOLEN_SIGNATURE);
3412 #endif
3413                 if ((tp->t_flags & TF_SACK_PERMIT) && tp->rcv_numsacks > 0) {
3414                         optlen += TCPOLEN_SACKHDR;
3415                         optlen += tp->rcv_numsacks * TCPOLEN_SACK;
3416                         optlen = PADTCPOLEN(optlen);
3417                 }
3418         } else {
3419                 if (tp->t_flags & TF_REQ_TSTMP)
3420                         optlen = TCPOLEN_TSTAMP_APPA;
3421                 else
3422                         optlen = PADTCPOLEN(TCPOLEN_MAXSEG);
3423                 if (tp->t_flags & TF_REQ_SCALE)
3424                         optlen += PADTCPOLEN(TCPOLEN_WINDOW);
3425 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3426                 if (tp->t_flags & TF_SIGNATURE)
3427                         optlen += PADTCPOLEN(TCPOLEN_SIGNATURE);
3428 #endif
3429                 if (tp->t_flags & TF_SACK_PERMIT)
3430                         optlen += PADTCPOLEN(TCPOLEN_SACK_PERMITTED);
3431         }
3432 #undef PAD
3433         optlen = min(optlen, TCP_MAXOLEN);
3434         return (tp->t_maxseg - optlen);
3435 }
3436
3437
3438 u_int
3439 tcp_fixed_maxseg(const struct tcpcb *tp)
3440 {
3441         int optlen;
3442
3443         if (tp->t_flags & TF_NOOPT)
3444                 return (tp->t_maxseg);
3445
3446         /*
3447          * Here we have a simplified code from tcp_addoptions(),
3448          * without a proper loop, and having most of paddings hardcoded.
3449          * We only consider fixed options that we would send every
3450          * time I.e. SACK is not considered. This is important
3451          * for cc modules to figure out what the modulo of the
3452          * cwnd should be.
3453          */
3454 #define PAD(len)        ((((len) / 4) + !!((len) % 4)) * 4)
3455         if (TCPS_HAVEESTABLISHED(tp->t_state)) {
3456                 if (tp->t_flags & TF_RCVD_TSTMP)
3457                         optlen = TCPOLEN_TSTAMP_APPA;
3458                 else
3459                         optlen = 0;
3460 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3461                 if (tp->t_flags & TF_SIGNATURE)
3462                         optlen += PAD(TCPOLEN_SIGNATURE);
3463 #endif
3464         } else {
3465                 if (tp->t_flags & TF_REQ_TSTMP)
3466                         optlen = TCPOLEN_TSTAMP_APPA;
3467                 else
3468                         optlen = PAD(TCPOLEN_MAXSEG);
3469                 if (tp->t_flags & TF_REQ_SCALE)
3470                         optlen += PAD(TCPOLEN_WINDOW);
3471 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
3472                 if (tp->t_flags & TF_SIGNATURE)
3473                         optlen += PAD(TCPOLEN_SIGNATURE);
3474 #endif
3475                 if (tp->t_flags & TF_SACK_PERMIT)
3476                         optlen += PAD(TCPOLEN_SACK_PERMITTED);
3477         }
3478 #undef PAD
3479         optlen = min(optlen, TCP_MAXOLEN);
3480         return (tp->t_maxseg - optlen);
3481 }
3482
3483
3484
3485 static int
3486 sysctl_drop(SYSCTL_HANDLER_ARGS)
3487 {
3488         /* addrs[0] is a foreign socket, addrs[1] is a local one. */
3489         struct sockaddr_storage addrs[2];
3490         struct inpcb *inp;
3491         struct tcpcb *tp;
3492 #ifdef INET
3493         struct sockaddr_in *fin = NULL, *lin = NULL;
3494 #endif
3495         struct epoch_tracker et;
3496 #ifdef INET6
3497         struct sockaddr_in6 *fin6, *lin6;
3498 #endif
3499         int error;
3500
3501         inp = NULL;
3502 #ifdef INET6
3503         fin6 = lin6 = NULL;
3504 #endif
3505         error = 0;
3506
3507         if (req->oldptr != NULL || req->oldlen != 0)
3508                 return (EINVAL);
3509         if (req->newptr == NULL)
3510                 return (EPERM);
3511         if (req->newlen < sizeof(addrs))
3512                 return (ENOMEM);
3513         error = SYSCTL_IN(req, &addrs, sizeof(addrs));
3514         if (error)
3515                 return (error);
3516
3517         switch (addrs[0].ss_family) {
3518 #ifdef INET6
3519         case AF_INET6:
3520                 fin6 = (struct sockaddr_in6 *)&addrs[0];
3521                 lin6 = (struct sockaddr_in6 *)&addrs[1];
3522                 if (fin6->sin6_len != sizeof(struct sockaddr_in6) ||
3523                     lin6->sin6_len != sizeof(struct sockaddr_in6))
3524                         return (EINVAL);
3525                 if (IN6_IS_ADDR_V4MAPPED(&fin6->sin6_addr)) {
3526                         if (!IN6_IS_ADDR_V4MAPPED(&lin6->sin6_addr))
3527                                 return (EINVAL);
3528                         in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[0]);
3529                         in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[1]);
3530 #ifdef INET
3531                         fin = (struct sockaddr_in *)&addrs[0];
3532                         lin = (struct sockaddr_in *)&addrs[1];
3533 #endif
3534                         break;
3535                 }
3536                 error = sa6_embedscope(fin6, V_ip6_use_defzone);
3537                 if (error)
3538                         return (error);
3539                 error = sa6_embedscope(lin6, V_ip6_use_defzone);
3540                 if (error)
3541                         return (error);
3542                 break;
3543 #endif
3544 #ifdef INET
3545         case AF_INET:
3546                 fin = (struct sockaddr_in *)&addrs[0];
3547                 lin = (struct sockaddr_in *)&addrs[1];
3548                 if (fin->sin_len != sizeof(struct sockaddr_in) ||
3549                     lin->sin_len != sizeof(struct sockaddr_in))
3550                         return (EINVAL);
3551                 break;
3552 #endif
3553         default:
3554                 return (EINVAL);
3555         }
3556         NET_EPOCH_ENTER(et);
3557         switch (addrs[0].ss_family) {
3558 #ifdef INET6
3559         case AF_INET6:
3560                 inp = in6_pcblookup(&V_tcbinfo, &fin6->sin6_addr,
3561                     fin6->sin6_port, &lin6->sin6_addr, lin6->sin6_port,
3562                     INPLOOKUP_WLOCKPCB, NULL);
3563                 break;
3564 #endif
3565 #ifdef INET
3566         case AF_INET:
3567                 inp = in_pcblookup(&V_tcbinfo, fin->sin_addr, fin->sin_port,
3568                     lin->sin_addr, lin->sin_port, INPLOOKUP_WLOCKPCB, NULL);
3569                 break;
3570 #endif
3571         }
3572         if (inp != NULL) {
3573                 if (!SOLISTENING(inp->inp_socket)) {
3574                         tp = intotcpcb(inp);
3575                         tp = tcp_drop(tp, ECONNABORTED);
3576                         if (tp != NULL)
3577                                 INP_WUNLOCK(inp);
3578                 } else
3579                         INP_WUNLOCK(inp);
3580         } else
3581                 error = ESRCH;
3582         NET_EPOCH_EXIT(et);
3583         return (error);
3584 }
3585
3586 SYSCTL_PROC(_net_inet_tcp, TCPCTL_DROP, drop,
3587     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP |
3588     CTLFLAG_NEEDGIANT, NULL, 0, sysctl_drop, "",
3589     "Drop TCP connection");
3590
3591 static int
3592 tcp_sysctl_setsockopt(SYSCTL_HANDLER_ARGS)
3593 {
3594         return (sysctl_setsockopt(oidp, arg1, arg2, req, &V_tcbinfo,
3595             &tcp_ctloutput_set));
3596 }
3597
3598 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, setsockopt,
3599     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP |
3600     CTLFLAG_MPSAFE, NULL, 0, tcp_sysctl_setsockopt, "",
3601     "Set socket option for TCP endpoint");
3602
3603 #ifdef KERN_TLS
3604 static int
3605 sysctl_switch_tls(SYSCTL_HANDLER_ARGS)
3606 {
3607         /* addrs[0] is a foreign socket, addrs[1] is a local one. */
3608         struct sockaddr_storage addrs[2];
3609         struct inpcb *inp;
3610 #ifdef INET
3611         struct sockaddr_in *fin = NULL, *lin = NULL;
3612 #endif
3613         struct epoch_tracker et;
3614 #ifdef INET6
3615         struct sockaddr_in6 *fin6, *lin6;
3616 #endif
3617         int error;
3618
3619         inp = NULL;
3620 #ifdef INET6
3621         fin6 = lin6 = NULL;
3622 #endif
3623         error = 0;
3624
3625         if (req->oldptr != NULL || req->oldlen != 0)
3626                 return (EINVAL);
3627         if (req->newptr == NULL)
3628                 return (EPERM);
3629         if (req->newlen < sizeof(addrs))
3630                 return (ENOMEM);
3631         error = SYSCTL_IN(req, &addrs, sizeof(addrs));
3632         if (error)
3633                 return (error);
3634
3635         switch (addrs[0].ss_family) {
3636 #ifdef INET6
3637         case AF_INET6:
3638                 fin6 = (struct sockaddr_in6 *)&addrs[0];
3639                 lin6 = (struct sockaddr_in6 *)&addrs[1];
3640                 if (fin6->sin6_len != sizeof(struct sockaddr_in6) ||
3641                     lin6->sin6_len != sizeof(struct sockaddr_in6))
3642                         return (EINVAL);
3643                 if (IN6_IS_ADDR_V4MAPPED(&fin6->sin6_addr)) {
3644                         if (!IN6_IS_ADDR_V4MAPPED(&lin6->sin6_addr))
3645                                 return (EINVAL);
3646                         in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[0]);
3647                         in6_sin6_2_sin_in_sock((struct sockaddr *)&addrs[1]);
3648 #ifdef INET
3649                         fin = (struct sockaddr_in *)&addrs[0];
3650                         lin = (struct sockaddr_in *)&addrs[1];
3651 #endif
3652                         break;
3653                 }
3654                 error = sa6_embedscope(fin6, V_ip6_use_defzone);
3655                 if (error)
3656                         return (error);
3657                 error = sa6_embedscope(lin6, V_ip6_use_defzone);
3658                 if (error)
3659                         return (error);
3660                 break;
3661 #endif
3662 #ifdef INET
3663         case AF_INET:
3664                 fin = (struct sockaddr_in *)&addrs[0];
3665                 lin = (struct sockaddr_in *)&addrs[1];
3666                 if (fin->sin_len != sizeof(struct sockaddr_in) ||
3667                     lin->sin_len != sizeof(struct sockaddr_in))
3668                         return (EINVAL);
3669                 break;
3670 #endif
3671         default:
3672                 return (EINVAL);
3673         }
3674         NET_EPOCH_ENTER(et);
3675         switch (addrs[0].ss_family) {
3676 #ifdef INET6
3677         case AF_INET6:
3678                 inp = in6_pcblookup(&V_tcbinfo, &fin6->sin6_addr,
3679                     fin6->sin6_port, &lin6->sin6_addr, lin6->sin6_port,
3680                     INPLOOKUP_WLOCKPCB, NULL);
3681                 break;
3682 #endif
3683 #ifdef INET
3684         case AF_INET:
3685                 inp = in_pcblookup(&V_tcbinfo, fin->sin_addr, fin->sin_port,
3686                     lin->sin_addr, lin->sin_port, INPLOOKUP_WLOCKPCB, NULL);
3687                 break;
3688 #endif
3689         }
3690         NET_EPOCH_EXIT(et);
3691         if (inp != NULL) {
3692                 struct socket *so;
3693
3694                 so = inp->inp_socket;
3695                 soref(so);
3696                 error = ktls_set_tx_mode(so,
3697                     arg2 == 0 ? TCP_TLS_MODE_SW : TCP_TLS_MODE_IFNET);
3698                 INP_WUNLOCK(inp);
3699                 sorele(so);
3700         } else
3701                 error = ESRCH;
3702         return (error);
3703 }
3704
3705 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_sw_tls,
3706     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP |
3707     CTLFLAG_NEEDGIANT, NULL, 0, sysctl_switch_tls, "",
3708     "Switch TCP connection to SW TLS");
3709 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_ifnet_tls,
3710     CTLFLAG_VNET | CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP |
3711     CTLFLAG_NEEDGIANT, NULL, 1, sysctl_switch_tls, "",
3712     "Switch TCP connection to ifnet TLS");
3713 #endif
3714
3715 /*
3716  * Generate a standardized TCP log line for use throughout the
3717  * tcp subsystem.  Memory allocation is done with M_NOWAIT to
3718  * allow use in the interrupt context.
3719  *
3720  * NB: The caller MUST free(s, M_TCPLOG) the returned string.
3721  * NB: The function may return NULL if memory allocation failed.
3722  *
3723  * Due to header inclusion and ordering limitations the struct ip
3724  * and ip6_hdr pointers have to be passed as void pointers.
3725  */
3726 char *
3727 tcp_log_vain(struct in_conninfo *inc, struct tcphdr *th, const void *ip4hdr,
3728     const void *ip6hdr)
3729 {
3730
3731         /* Is logging enabled? */
3732         if (V_tcp_log_in_vain == 0)
3733                 return (NULL);
3734
3735         return (tcp_log_addr(inc, th, ip4hdr, ip6hdr));
3736 }
3737
3738 char *
3739 tcp_log_addrs(struct in_conninfo *inc, struct tcphdr *th, const void *ip4hdr,
3740     const void *ip6hdr)
3741 {
3742
3743         /* Is logging enabled? */
3744         if (tcp_log_debug == 0)
3745                 return (NULL);
3746
3747         return (tcp_log_addr(inc, th, ip4hdr, ip6hdr));
3748 }
3749
3750 static char *
3751 tcp_log_addr(struct in_conninfo *inc, struct tcphdr *th, const void *ip4hdr,
3752     const void *ip6hdr)
3753 {
3754         char *s, *sp;
3755         size_t size;
3756 #ifdef INET
3757         const struct ip *ip = (const struct ip *)ip4hdr;
3758 #endif
3759 #ifdef INET6
3760         const struct ip6_hdr *ip6 = (const struct ip6_hdr *)ip6hdr;
3761 #endif /* INET6 */
3762
3763         /*
3764          * The log line looks like this:
3765          * "TCP: [1.2.3.4]:50332 to [1.2.3.4]:80 tcpflags 0x2<SYN>"
3766          */
3767         size = sizeof("TCP: []:12345 to []:12345 tcpflags 0x2<>") +
3768             sizeof(PRINT_TH_FLAGS) + 1 +
3769 #ifdef INET6
3770             2 * INET6_ADDRSTRLEN;
3771 #else
3772             2 * INET_ADDRSTRLEN;
3773 #endif /* INET6 */
3774
3775         s = malloc(size, M_TCPLOG, M_ZERO|M_NOWAIT);
3776         if (s == NULL)
3777                 return (NULL);
3778
3779         strcat(s, "TCP: [");
3780         sp = s + strlen(s);
3781
3782         if (inc && ((inc->inc_flags & INC_ISIPV6) == 0)) {
3783                 inet_ntoa_r(inc->inc_faddr, sp);
3784                 sp = s + strlen(s);
3785                 sprintf(sp, "]:%i to [", ntohs(inc->inc_fport));
3786                 sp = s + strlen(s);
3787                 inet_ntoa_r(inc->inc_laddr, sp);
3788                 sp = s + strlen(s);
3789                 sprintf(sp, "]:%i", ntohs(inc->inc_lport));
3790 #ifdef INET6
3791         } else if (inc) {
3792                 ip6_sprintf(sp, &inc->inc6_faddr);
3793                 sp = s + strlen(s);
3794                 sprintf(sp, "]:%i to [", ntohs(inc->inc_fport));
3795                 sp = s + strlen(s);
3796                 ip6_sprintf(sp, &inc->inc6_laddr);
3797                 sp = s + strlen(s);
3798                 sprintf(sp, "]:%i", ntohs(inc->inc_lport));
3799         } else if (ip6 && th) {
3800                 ip6_sprintf(sp, &ip6->ip6_src);
3801                 sp = s + strlen(s);
3802                 sprintf(sp, "]:%i to [", ntohs(th->th_sport));
3803                 sp = s + strlen(s);
3804                 ip6_sprintf(sp, &ip6->ip6_dst);
3805                 sp = s + strlen(s);
3806                 sprintf(sp, "]:%i", ntohs(th->th_dport));
3807 #endif /* INET6 */
3808 #ifdef INET
3809         } else if (ip && th) {
3810                 inet_ntoa_r(ip->ip_src, sp);
3811                 sp = s + strlen(s);
3812                 sprintf(sp, "]:%i to [", ntohs(th->th_sport));
3813                 sp = s + strlen(s);
3814                 inet_ntoa_r(ip->ip_dst, sp);
3815                 sp = s + strlen(s);
3816                 sprintf(sp, "]:%i", ntohs(th->th_dport));
3817 #endif /* INET */
3818         } else {
3819                 free(s, M_TCPLOG);
3820                 return (NULL);
3821         }
3822         sp = s + strlen(s);
3823         if (th)
3824                 sprintf(sp, " tcpflags 0x%b", tcp_get_flags(th), PRINT_TH_FLAGS);
3825         if (*(s + size - 1) != '\0')
3826                 panic("%s: string too long", __func__);
3827         return (s);
3828 }
3829
3830 /*
3831  * A subroutine which makes it easy to track TCP state changes with DTrace.
3832  * This function shouldn't be called for t_state initializations that don't
3833  * correspond to actual TCP state transitions.
3834  */
3835 void
3836 tcp_state_change(struct tcpcb *tp, int newstate)
3837 {
3838 #if defined(KDTRACE_HOOKS)
3839         int pstate = tp->t_state;
3840 #endif
3841
3842         TCPSTATES_DEC(tp->t_state);
3843         TCPSTATES_INC(newstate);
3844         tp->t_state = newstate;
3845         TCP_PROBE6(state__change, NULL, tp, NULL, tp, NULL, pstate);
3846 }
3847
3848 /*
3849  * Create an external-format (``xtcpcb'') structure using the information in
3850  * the kernel-format tcpcb structure pointed to by tp.  This is done to
3851  * reduce the spew of irrelevant information over this interface, to isolate
3852  * user code from changes in the kernel structure, and potentially to provide
3853  * information-hiding if we decide that some of this information should be
3854  * hidden from users.
3855  */
3856 void
3857 tcp_inptoxtp(const struct inpcb *inp, struct xtcpcb *xt)
3858 {
3859         struct tcpcb *tp = intotcpcb(inp);
3860         sbintime_t now;
3861
3862         bzero(xt, sizeof(*xt));
3863         xt->t_state = tp->t_state;
3864         xt->t_logstate = tp->t_logstate;
3865         xt->t_flags = tp->t_flags;
3866         xt->t_sndzerowin = tp->t_sndzerowin;
3867         xt->t_sndrexmitpack = tp->t_sndrexmitpack;
3868         xt->t_rcvoopack = tp->t_rcvoopack;
3869         xt->t_rcv_wnd = tp->rcv_wnd;
3870         xt->t_snd_wnd = tp->snd_wnd;
3871         xt->t_snd_cwnd = tp->snd_cwnd;
3872         xt->t_snd_ssthresh = tp->snd_ssthresh;
3873         xt->t_dsack_bytes = tp->t_dsack_bytes;
3874         xt->t_dsack_tlp_bytes = tp->t_dsack_tlp_bytes;
3875         xt->t_dsack_pack = tp->t_dsack_pack;
3876         xt->t_maxseg = tp->t_maxseg;
3877         xt->xt_ecn = (tp->t_flags2 & TF2_ECN_PERMIT) ? 1 : 0 +
3878                      (tp->t_flags2 & TF2_ACE_PERMIT) ? 2 : 0;
3879
3880         now = getsbinuptime();
3881 #define COPYTIMER(which,where)  do {                                    \
3882         if (tp->t_timers[which] != SBT_MAX)                             \
3883                 xt->where = (tp->t_timers[which] - now) / SBT_1MS;      \
3884         else                                                            \
3885                 xt->where = 0;                                          \
3886 } while (0)
3887         COPYTIMER(TT_DELACK, tt_delack);
3888         COPYTIMER(TT_REXMT, tt_rexmt);
3889         COPYTIMER(TT_PERSIST, tt_persist);
3890         COPYTIMER(TT_KEEP, tt_keep);
3891         COPYTIMER(TT_2MSL, tt_2msl);
3892 #undef COPYTIMER
3893         xt->t_rcvtime = 1000 * (ticks - tp->t_rcvtime) / hz;
3894
3895         xt->xt_encaps_port = tp->t_port;
3896         bcopy(tp->t_fb->tfb_tcp_block_name, xt->xt_stack,
3897             TCP_FUNCTION_NAME_LEN_MAX);
3898         bcopy(CC_ALGO(tp)->name, xt->xt_cc, TCP_CA_NAME_MAX);
3899 #ifdef TCP_BLACKBOX
3900         (void)tcp_log_get_id(tp, xt->xt_logid);
3901 #endif
3902
3903         xt->xt_len = sizeof(struct xtcpcb);
3904         in_pcbtoxinpcb(inp, &xt->xt_inp);
3905 }
3906
3907 void
3908 tcp_log_end_status(struct tcpcb *tp, uint8_t status)
3909 {
3910         uint32_t bit, i;
3911
3912         if ((tp == NULL) ||
3913             (status > TCP_EI_STATUS_MAX_VALUE) ||
3914             (status == 0)) {
3915                 /* Invalid */
3916                 return;
3917         }
3918         if (status > (sizeof(uint32_t) * 8)) {
3919                 /* Should this be a KASSERT? */
3920                 return;
3921         }
3922         bit = 1U << (status - 1);
3923         if (bit & tp->t_end_info_status) {
3924                 /* already logged */
3925                 return;
3926         }
3927         for (i = 0; i < TCP_END_BYTE_INFO; i++) {
3928                 if (tp->t_end_info_bytes[i] == TCP_EI_EMPTY_SLOT) {
3929                         tp->t_end_info_bytes[i] = status;
3930                         tp->t_end_info_status |= bit;
3931                         break;
3932                 }
3933         }
3934 }
3935
3936 int
3937 tcp_can_enable_pacing(void)
3938 {
3939
3940         if ((tcp_pacing_limit == -1) ||
3941             (tcp_pacing_limit > number_of_tcp_connections_pacing)) {
3942                 atomic_fetchadd_int(&number_of_tcp_connections_pacing, 1);
3943                 shadow_num_connections = number_of_tcp_connections_pacing;
3944                 return (1);
3945         } else {
3946                 return (0);
3947         }
3948 }
3949
3950 static uint8_t tcp_pacing_warning = 0;
3951
3952 void
3953 tcp_decrement_paced_conn(void)
3954 {
3955         uint32_t ret;
3956
3957         ret = atomic_fetchadd_int(&number_of_tcp_connections_pacing, -1);
3958         shadow_num_connections = number_of_tcp_connections_pacing;
3959         KASSERT(ret != 0, ("tcp_paced_connection_exits -1 would cause wrap?"));
3960         if (ret == 0) {
3961                 if (tcp_pacing_limit != -1) {
3962                         printf("Warning all pacing is now disabled, count decrements invalidly!\n");
3963                         tcp_pacing_limit = 0;
3964                 } else if (tcp_pacing_warning == 0) {
3965                         printf("Warning pacing count is invalid, invalid decrement\n");
3966                         tcp_pacing_warning = 1;
3967                 }
3968         }
3969 }