1 /*
2 * Copyright (c) 2000-2024 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1982, 1986, 1993, 1994, 1995
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)tcp_var.h 8.4 (Berkeley) 5/24/95
61 * $FreeBSD: src/sys/netinet/tcp_var.h,v 1.56.2.8 2001/08/22 00:59:13 silby Exp $
62 */
63
64 #ifndef _NETINET_TCP_VAR_H_
65 #define _NETINET_TCP_VAR_H_
66 #include <stdint.h>
67 #include <sys/types.h>
68 #include <sys/appleapiopts.h>
69 #include <sys/queue.h>
70 #include <netinet/in_pcb.h>
71 #include <netinet/tcp.h>
72 #include <netinet/tcp_timer.h>
73 #if !KERNEL
74 #include <TargetConditionals.h>
75 #endif
76
77 #if defined(__LP64__)
78 #define _TCPCB_PTR(x) u_int32_t
79 #define _TCPCB_LIST_HEAD(name, type) \
80 struct name { \
81 u_int32_t lh_first; \
82 }
83 #else
84 #define _TCPCB_PTR(x) x
85 #define _TCPCB_LIST_HEAD(name, type) LIST_HEAD(name, type)
86 #endif
87
88 #ifdef KERNEL_PRIVATE
89 #include <sys/tree.h>
90
91 #define TCP_RETRANSHZ 1000 /* granularity of TCP timestamps, 1ms */
92 /* Minimum time quantum within which the timers are coalesced */
93 #define TCP_TIMER_10MS_QUANTUM (TCP_RETRANSHZ/100) /* every 10ms */
94 #define TCP_TIMER_100MS_QUANTUM (TCP_RETRANSHZ/10) /* every 100ms */
95 #define TCP_TIMER_500MS_QUANTUM (TCP_RETRANSHZ/2) /* every 500ms */
96
97 #define TCP_RETRANSHZ_TO_USEC 1000
98
99 #define N_TIME_WAIT_SLOTS 128 /* must be power of 2 */
100
101 /* Always allow at least 16 packets worth of recv window when adjusting
102 * recv window using inter-packet arrival jitter.
103 */
104 #define MIN_IAJ_WIN 16
105
106 /* A variation in delay of this many milliseconds is tolerable. This limit has to
107 * be low but greater than zero. We also use standard deviation on jitter to adjust
108 * this limit for different link and connection types.
109 */
110 #define ALLOWED_IAJ 5
111
112 /* Ignore the first few packets on a connection until the ACK clock gets going
113 */
114 #define IAJ_IGNORE_PKTCNT 40
115
116 /* Let the accumulated IAJ value increase by this threshold at most. This limit
117 * will control how many ALLOWED_IAJ measurements a receiver will have to see
118 * before opening the receive window
119 */
120 #define ACC_IAJ_HIGH_THRESH 100
121
122 /* When accumulated IAJ reaches this value, the receiver starts to react by
123 * closing the window
124 */
125 #define ACC_IAJ_REACT_LIMIT 200
126
127 /* If the number of small packets (smaller than IAJ packet size) seen on a
128 * connection is more than this threshold, reset the size and learn it again.
129 * This is needed because the sender might send smaller segments after PMTU
130 * discovery and the receiver has to learn the new size.
131 */
132 #define RESET_IAJ_SIZE_THRESH 20
133
134 /*
135 * Adaptive timeout is a read/write timeout specified by the application to
136 * get a socket event when the transport layer detects a stall in data
137 * transfer. The value specified is the number of probes that can be sent
138 * to the peer before generating an event. Since it is not specified as
139 * a time value, the timeout will adjust based on the RTT seen on the link.
140 * The timeout will start only when there is an indication that the read/write
141 * operation is not making progress.
142 *
143 * If a write operation stalls, the probe will be retransmission of data.
144 * If a read operation stalls, the probe will be a keep-alive packet.
145 *
146 * The maximum value of adaptive timeout is set to 10 which will allow
147 * transmission of enough number of probes to the peer.
148 */
149 #define TCP_ADAPTIVE_TIMEOUT_MAX 10
150
151 #define TCP_CONNECTIVITY_PROBES_MAX 5
152
153 /* 3 bit mask used for Accurate ECN ACE field */
154 #define TCP_ACE_MASK (0x7)
155 /* Divisor used for Accurate ECN ACE field */
156 #define TCP_ACE_DIV (1 << 3)
157
158 /* 24 bit mask used for Accurate ECN option */
159 #define TCP_ACO_MASK (0xFFFFFF)
160 /* Divisor used for Accurate ECN options field */
161 #define TCP_ACO_DIV (1 << 24)
162
163 /*
164 * Kernel variables for tcp.
165 */
166
167 /* TCP segment queue entry */
168 struct tseg_qent {
169 LIST_ENTRY(tseg_qent) tqe_q;
170 int tqe_len; /* TCP segment data length */
171 struct tcphdr *tqe_th; /* a pointer to tcp header */
172 struct mbuf *tqe_m; /* mbuf contains packet */
173 };
174 LIST_HEAD(tsegqe_head, tseg_qent);
175
176 struct sackblk {
177 tcp_seq start; /* start seq no. of sack block */
178 tcp_seq end; /* end seq no. */
179 };
180
181 struct sackhole {
182 tcp_seq start; /* start seq no. of hole */
183 tcp_seq end; /* end seq no. */
184 tcp_seq rxmit; /* next seq. no in hole to be retransmitted */
185 u_int32_t rxmit_start; /* timestamp of first retransmission */
186 TAILQ_ENTRY(sackhole) scblink; /* scoreboard linkage */
187 };
188
189 struct sackhint {
190 struct sackhole *nexthole;
191 int sack_bytes_rexmit;
192 int sack_bytes_acked;
193 };
194
195 struct tcp_rxt_seg {
196 tcp_seq rx_start;
197 tcp_seq rx_end;
198 u_int16_t rx_count;
199 u_int16_t rx_flags;
200 #define TCP_RXT_SPURIOUS 0x1 /* received DSACK notification */
201 SLIST_ENTRY(tcp_rxt_seg) rx_link;
202 };
203
204 /* TCP state of a segment that was sent */
205 struct tcp_seg_sent {
206 tcp_seq start_seq;
207 tcp_seq end_seq; /* last seq sent + 1 */
208 uint32_t xmit_ts;
209 uint8_t flags;
210 uint8_t pad[3];
211 #define TCP_SEGMENT_SACKED 0x1
212 #define TCP_SEGMENT_LOST 0x2
213 #define TCP_RACK_RETRANSMITTED 0x4
214 #define TCP_SEGMENT_RETRANSMITTED_ATLEAST_ONCE 0x8 /* If a segment was retransmitted at least once; used for reordering detection and to avoid spurious inferences for RACK.rtt */
215 #define TCP_SEGMENT_RETRANSMITTED (TCP_RACK_RETRANSMITTED | TCP_SEGMENT_RETRANSMITTED_ATLEAST_ONCE)
216
217 TAILQ_ENTRY(tcp_seg_sent) tx_link; /* Time ordered list of segments */
218 RB_ENTRY(tcp_seg_sent) seg_link; /* RB tree to keep track of S/ACKed segments */
219 TAILQ_ENTRY(tcp_seg_sent) ack_link; /* List of ACKed segments to be deleted from time ordered list and RB tree */
220 TAILQ_ENTRY(tcp_seg_sent) free_link; /* List of free segments from the pool */
221 };
222
223 typedef struct tcp_seg_pool {
224 TAILQ_HEAD(, tcp_seg_sent) free_segs;
225 uint32_t free_segs_count;
226 char pad[4];
227 } *tcp_seg_pool_t;
228
229 #define TCP_SEG_POOL_MAX_ITEM_COUNT (64)
230
231 int tcp_seg_cmp(const struct tcp_seg_sent *, const struct tcp_seg_sent *);
232
233 RB_HEAD(tcp_seg_sent_tree_head, tcp_seg_sent);
234 RB_PROTOTYPE(tcp_seg_sent_tree_head, tcp_seg_sent, seg_link, tcp_seg_cmp)
235
236 struct tcp_notify_ack_marker {
237 tcp_seq notify_snd_una; /* Notify when snd_una crosses this seq */
238 tcp_notify_ack_id_t notify_id;
239 SLIST_ENTRY(tcp_notify_ack_marker) notify_next;
240 };
241
242 struct tcptemp {
243 u_char tt_ipgen[40]; /* the size must be of max ip header, now IPv6 */
244 struct tcphdr tt_t;
245 };
246
247 struct bwmeas {
248 tcp_seq bw_start; /* start of bw measurement */
249 uint32_t bw_ts; /* timestamp when bw measurement started */
250 uint32_t bw_size; /* burst size in bytes for this bw measurement */
251 uint32_t bw_minsizepkts; /* Min burst size as segments */
252 uint32_t bw_maxsizepkts; /* Max burst size as segments */
253 uint32_t bw_minsize; /* Min size in bytes */
254 uint32_t bw_maxsize; /* Max size in bytes */
255 uint32_t bw_sndbw; /* Measured send bandwidth */
256 uint32_t bw_sndbw_max; /* Max measured bandwidth */
257 uint32_t bw_rcvbw_max; /* Max receive bandwidth measured */
258 };
259
260 /* MPTCP Data sequence map entry */
261 struct mpt_dsn_map {
262 uint64_t mpt_dsn; /* data seq num recvd */
263 uint32_t mpt_sseq; /* relative subflow # */
264 uint16_t mpt_len; /* length of mapping */
265 uint16_t mpt_csum; /* checksum value if on */
266 uint8_t mpt_dfin; /* It's a DATA_FIN */
267 };
268 #define tcp6cb tcpcb /* for KAME src sync over BSD*'s */
269
270 struct tcp_ccstate {
271 union {
272 struct tcp_cubic_state {
273 u_int32_t tc_last_max; /* cwnd at last loss */
274 u_int32_t tc_epoch_start; /* TS of last loss */
275 u_int32_t tc_origin_point; /* window at the start of an epoch */
276 u_int32_t tc_tcp_win; /* computed tcp win */
277 u_int32_t tc_tcp_bytes_acked; /* bytes acked */
278 u_int32_t tc_avg_lastmax; /* Average of last max */
279 u_int32_t tc_mean_deviation; /* Mean absolute deviation */
280 float tc_epoch_period; /* K parameter */
281 } _cubic_state_;
282 #define cub_last_max __u__._cubic_state_.tc_last_max
283 #define cub_epoch_start __u__._cubic_state_.tc_epoch_start
284 #define cub_origin_point __u__._cubic_state_.tc_origin_point
285 #define cub_tcp_win __u__._cubic_state_.tc_tcp_win
286 #define cub_tcp_bytes_acked __u__._cubic_state_.tc_tcp_bytes_acked
287 #define cub_epoch_period __u__._cubic_state_.tc_epoch_period
288 #define cub_avg_lastmax __u__._cubic_state_.tc_avg_lastmax
289 #define cub_mean_dev __u__._cubic_state_.tc_mean_deviation
290 struct tcp_prague_state {
291 uint16_t num_cong_events_loss;
292 uint16_t num_cong_events_ce;
293 uint32_t packets_acked; /* cumulative packets ack'ed updated at round start for alpha */
294 uint32_t packets_marked; /* cumulative CE counts updated at round start for alpha */
295 uint32_t ce_counter; /* cumulative CE counts updated on every ACK,
296 * used for calculating non-CE acked and performing any CE related action */
297 uint32_t bytes_acked; /* bytes acked in this ACK that were not CE marked, used for cwnd increase */
298 uint32_t snd_nxt_alpha; /* snd_nxt at round start to track 1 RTT elapsed for alpha */
299 uint32_t snd_nxt_cwr; /* snd_nxt at round start to track 1 RTT elapsed for CWR */
300 uint8_t ever_saw_ce:1, /* To test if there is a AQM on path */
301 in_loss:1, /* Are we in loss recovery */
302 reduced_due_to_ce:1, /* Was the last reduction due to CE */
303 unused:5;
304 uint8_t pad[3];
305 uint64_t scaled_alpha; /* Scaled value of DCTCP.alpha */
306 uint64_t alpha_ai; /* AI.alpha used after CE for additive increase */
307 /* After reduction due to loss CUBIC window increase state */
308 struct tcp_cubic_state cubic_state;
309 } _prague_state_;
310 #define num_cong_events_loss __u__._prague_state_.num_cong_events_loss
311 #define num_cong_events_ce __u__._prague_state_.num_cong_events_ce
312 #define prague_packets_acked __u__._prague_state_.packets_acked
313 #define prague_packets_marked __u__._prague_state_.packets_marked
314 #define prague_ce_counter __u__._prague_state_.ce_counter
315 #define prague_bytes_acked __u__._prague_state_.bytes_acked
316 #define snd_nxt_alpha __u__._prague_state_.snd_nxt_alpha
317 #define snd_nxt_cwr __u__._prague_state_.snd_nxt_cwr
318 #define prague_scaled_alpha __u__._prague_state_.scaled_alpha
319 #define prague_alpha_ai __u__._prague_state_.alpha_ai
320 #define ever_saw_ce __u__._prague_state_.ever_saw_ce
321 #define in_loss __u__._prague_state_.in_loss
322 #define reduced_due_to_ce __u__._prague_state_.reduced_due_to_ce
323 #define cubic_K __u__._prague_state_.cubic_state.tc_epoch_period
324 #define cubic_epoch_start __u__._prague_state_.cubic_state.tc_epoch_start
325 #define cubic_origin_point __u__._prague_state_.cubic_state.tc_origin_point
326 #define cubic_W_max __u__._prague_state_.cubic_state.tc_last_max
327 #define reno_acked __u__._prague_state_.cubic_state.tc_tcp_bytes_acked
328 #define reno_cwnd __u__._prague_state_.cubic_state.tc_tcp_win
329 struct tcp_ledbat_state {
330 uint32_t num_slowdown_events;
331 uint32_t slowdown_ts;
332 uint32_t slowdown_begin;
333 uint32_t md_bytes_acked;
334 } _ledbat_state_;
335 #define ledbat_slowdown_events __u__._ledbat_state_.num_slowdown_events
336 #define ledbat_slowdown_ts __u__._ledbat_state_.slowdown_ts
337 #define ledbat_slowdown_begin __u__._ledbat_state_.slowdown_begin
338 #define ledbat_md_bytes_acked __u__._ledbat_state_.md_bytes_acked
339 } __u__;
340 };
341
342 struct tcp_rledbat_state {
343 uint32_t num_slowdown_events; /* Number of slowdown events until reset */
344 uint32_t slowdown_ts; /* Next slowdown timestamp */
345 uint32_t slowdown_begin; /* Slowdown begin time */
346 uint32_t reduction_end; /* Used to track rl_win reduction once per RTT */
347 uint32_t rcvd_bytes; /* bytes received used for byte counting */
348 uint32_t md_rcvd_bytes; /* bytes received during MD used for byte counting */
349 uint32_t win; /* receive Ledbat window size */
350 uint32_t ssthresh; /* receive Ledbat ssthresh */
351 uint32_t drained_bytes; /* bytes drained from the flight-size */
352 uint32_t win_ws; /* receive Ledbat window after avoiding window shrinking */
353 };
354
355 struct accecn {
356 /* ACE CE packet counters */
357 uint32_t t_rcv_ce_packets; /* Number of CE received packets at the receiver */
358 uint32_t t_snd_ce_packets; /* Synced number of CE received feedback at the sender */
359 uint32_t t_delta_ce_packets; /* Change in CE count between previous and current ACK */
360 uint8_t accecn_processed:1, /* Accurate ECN feedback has already been processed */
361 unused:7;
362
363 /* AccECN option byte counters */
364 uint64_t t_rcv_ect1_bytes; /* ECT1 byte counter at the receiver, used for AccECN option feedback */
365 uint64_t t_rcv_ect0_bytes; /* ECT0 byte counter at the receiver, used for AccECN option feedback */
366 uint64_t t_rcv_ce_bytes; /* CE byte counter at the receiver, used for AccECN option feedback */
367 uint64_t t_snd_ect1_bytes; /* Synced ECT1 byte counter at the sender */
368 uint64_t t_snd_ect0_bytes; /* Synced ECT0 byte counter at the sender */
369 uint64_t t_snd_ce_bytes; /* Synced CE byte counter at the sender */
370 };
371
372 struct pacer {
373 uint64_t rate;
374 uint32_t tso_burst_size; /* maximum allowed burst size, segments that fit in a burst have the same Tx timestamp */
375 uint32_t current_size; /* track how many bytes have been accumulated in a burst */
376 uint64_t packet_tx_time;
377 };
378
379 /*
380 * Tcp control block, one per tcp; fields:
381 * Organized for 16 byte cacheline efficiency.
382 */
383 struct tcpcb {
384 struct tsegqe_head t_segq;
385 uint32_t t_dupacks; /* consecutive dup acks recd */
386 int t_state; /* state of this connection */
387 uint32_t t_timer[TCPT_NTIMERS]; /* tcp timers */
388 struct tcptimerentry tentry; /* entry in timer list */
389
390 struct inpcb *t_inpcb; /* back pointer to internet pcb */
391 uint32_t t_flags;
392 #define TF_ACKNOW 0x00001 /* ack peer immediately */
393 #define TF_DELACK 0x00002 /* ack, but try to delay it */
394 #define TF_NODELAY 0x00004 /* don't delay packets to coalesce */
395 #define TF_NOOPT 0x00008 /* don't use tcp options */
396 #define TF_SENTFIN 0x00010 /* have sent FIN */
397 #define TF_REQ_SCALE 0x00020 /* have/will request window scaling */
398 #define TF_RCVD_SCALE 0x00040 /* other side has requested scaling */
399 #define TF_REQ_TSTMP 0x00080 /* have/will request timestamps */
400 #define TF_RCVD_TSTMP 0x00100 /* a timestamp was received in SYN */
401 #define TF_SACK_PERMIT 0x00200 /* other side said I could SACK */
402 #define TF_NEEDSYN 0x00400 /* send SYN (implicit state) - unused but needed for backwards compatibility */
403 #define TF_NEEDFIN 0x00800 /* send FIN (implicit state) */
404 #define TF_NOPUSH 0x01000 /* don't push */
405 #define TF_UNUSED1 0x02000 /* Unused */
406 #define TF_UNUSED2 0x04000 /* Unused */
407 #define TF_UNUSED3 0x08000 /* Unused */
408 #define TF_MORETOCOME 0x10000 /* More data to be appended to sock */
409 #define TF_LOCAL 0x20000 /* connection to a host on local link */
410 #define TF_RXWIN0SENT 0x40000 /* sent a receiver win 0 in response */
411 #define TF_SLOWLINK 0x80000 /* route is a on a modem speed link */
412 #define TF_LASTIDLE 0x100000 /* connection was previously idle */
413 #define TF_FASTRECOVERY 0x200000 /* in NewReno Fast Recovery */
414 #define TF_WASFRECOVERY 0x400000 /* was in NewReno Fast Recovery */
415 #define TF_SIGNATURE 0x800000 /* require MD5 digests (RFC2385) */
416 #define TF_MAXSEGSNT 0x1000000 /* last segment sent was a full segment */
417 #define TF_STREAMING_ON 0x2000000 /* Receiver detected streaming */
418 #define TF_PMTUD 0x4000000 /* Perform Path MTU Discovery for this connection */
419 #define TF_CLOSING 0x8000000 /* pending tcp close */
420 #define TF_TSO 0x10000000 /* TCP Segment Offloading is enable on this connection */
421 #define TF_BLACKHOLE 0x20000000 /* Path MTU Discovery Black Hole detection */
422 #define TF_TIMER_ONLIST 0x40000000 /* pcb is on tcp_timer_list */
423 #define TF_STRETCHACK 0x80000000 /* receiver is going to delay acks */
424
425 tcp_seq snd_una; /* send unacknowledged */
426 tcp_seq snd_max; /* highest sequence number sent;
427 * used to recognize retransmits
428 */
429 tcp_seq snd_nxt; /* send next */
430 tcp_seq snd_up; /* send urgent pointer */
431
432 tcp_seq snd_wl1; /* window update seg seq number */
433 tcp_seq snd_wl2; /* window update seg ack number */
434 tcp_seq iss; /* initial send sequence number */
435 tcp_seq irs; /* initial receive sequence number */
436
437 tcp_seq rcv_nxt; /* receive next */
438 tcp_seq rcv_adv; /* advertised window */
439 uint32_t rcv_wnd; /* receive window */
440 uint32_t t_last_recwin;
441 tcp_seq rcv_up; /* receive urgent pointer */
442
443 uint32_t snd_wnd; /* send window */
444 uint32_t snd_cwnd; /* congestion-controlled window */
445 uint32_t snd_ssthresh; /* snd_cwnd size threshold for
446 * for slow start exponential to
447 * linear switch
448 */
449 tcp_seq snd_recover; /* for use in NewReno Fast Recovery */
450
451 uint32_t t_maxopd; /* mss plus options */
452 uint32_t t_rcvtime; /* time at which a packet was received */
453 uint32_t t_sndtime; /* time at which we last sent new data */
454 uint32_t t_starttime; /* time connection was established */
455 int t_rtttime; /* tcp clock when rtt calculation was started */
456 tcp_seq t_rtseq; /* sequence number being timed */
457
458 uint32_t rfbuf_ts; /* recv buffer autoscaling timestamp */
459 uint32_t rfbuf_cnt; /* recv buffer autoscaling byte count */
460 uint32_t rfbuf_space; /* Current "ideal" estimate of the space */
461
462 int t_rxtcur; /* current retransmit value (ticks) */
463 unsigned int t_maxseg; /* maximum segment size */
464 int t_srtt; /* smoothed round-trip time */
465 int t_rttvar; /* variance in round-trip time */
466
467 uint64_t t_accsleep_ms; /* accumulated sleep time since last boot */
468 uint32_t t_reassqlen; /* length of reassembly queue */
469 uint32_t t_reassq_mbcnt; /* amount in bytes of mbuf space used */
470 uint16_t t_rxtshift; /* log(2) of rexmt exp. backoff */
471 uint32_t t_rttmin; /* minimum rtt allowed */
472 uint32_t t_rttbest; /* best rtt we've seen */
473 uint32_t t_rttcur; /* most recent value of rtt */
474 uint32_t t_rttupdated; /* number of times rtt sampled */
475 uint32_t t_rxt_conndroptime; /* retxmt conn gets dropped after this time, when set */
476 uint32_t t_rxtstart; /* time at which retransmission started */
477 uint32_t max_sndwnd; /* largest window peer has offered */
478
479 int t_softerror; /* possible error not yet reported */
480 /* out-of-band data */
481 char t_oobflags; /* have some */
482 char t_iobc; /* input character */
483 #define TCPOOB_HAVEDATA 0x01
484 #define TCPOOB_HADDATA 0x02
485 /* RFC 1323 variables */
486 u_int8_t snd_scale; /* window scaling for send window */
487 u_int8_t rcv_scale; /* window scaling for recv window */
488 u_int8_t request_r_scale; /* pending window scaling */
489 u_int8_t requested_s_scale;
490 u_int8_t tcp_cc_index; /* index of congestion control algorithm */
491 u_int8_t t_adaptive_rtimo; /* Read timeout used as a multiple of RTT */
492 u_int8_t t_adaptive_wtimo; /* Write timeout used as a multiple of RTT */
493 u_int8_t t_stretchack_delayed; /* stretch ack delayed */
494
495 /* State for limiting early retransmits when SACK is not enabled */
496 u_int16_t t_early_rexmt_count; /* count of early rexmts */
497 u_int32_t t_early_rexmt_win; /* window for limiting early rexmts */
498
499 u_int32_t ts_recent; /* timestamp echo data */
500
501 u_int32_t ts_recent_age; /* when last updated */
502 tcp_seq last_ack_sent;
503
504 uint32_t t_bytes_acked; /* RFC 3465 variable for ABC, used by CCA only */
505 uint32_t total_ect_packets_marked; /* Cumulative count of total ECT packets marked */
506 uint32_t total_ect_packets_acked; /* Cumulative count of total ECT packets acked */
507
508 int t_lastchain; /* amount of packets chained last time around */
509 uint16_t t_unacksegs; /* received but unacked segments for delaying acks */
510 uint16_t t_unacksegs_ce; /* received but unacked segments/pure ACKs that were CE marked */
511
512 /*
513 * Pretty arbitrary value ;-)
514 * Goal is to make sure that some ACKs are being sent more frequently
515 * to allow the other side to ramp-up.
516 */
517 #define TCP_FORCED_ACKS_COUNT 16
518 uint16_t t_forced_acks; /* count of pure ACKs that need to be forced out */
519 uint8_t t_rexmtthresh; /* duplicate ack threshold for entering fast recovery */
520 uint8_t t_rtimo_probes; /* number of adaptive rtimo probes sent */
521 uint32_t t_persist_timeout; /* ZWP persistence limit as set by PERSIST_TIMEOUT */
522 uint32_t t_persist_stop; /* persistence limit deadline if triggered by ZWP */
523 uint32_t t_notsent_lowat; /* Low water for not sent data */
524
525 /* Receiver state for stretch-ack algorithm */
526 u_int32_t rcv_unackwin; /* to measure win for stretching acks */
527 u_int32_t rcv_by_unackwin; /* bytes seen during the last ack-stretching win */
528 u_int32_t rcv_by_unackhalfwin;
529 u_int32_t rcv_nostrack_ts; /* timestamp when stretch ack was disabled automatically */
530 u_int32_t rcv_nostrack_pkts; /* pkts received since strech ack was disabled */
531 u_int16_t rcv_waitforss; /* wait for packets during slow-start */
532
533 /* ECN stats */
534 u_int32_t ecn_flags;
535 #define TE_SETUPSENT 0x00000001 /* We have sent classic ECN-SETUP SYN or SYN-ACK */
536 #define TE_SETUPRECEIVED 0x00000002 /* We have received classic ECN-SETUP SYN or SYN-ACK */
537 #define TE_SENDIPECT 0x00000004 /* We haven't sent or received non-ECN-setup SYN or SYN-ACK, set IP ECT on outbound packet */
538 #define TE_SENDCWR 0x00000008 /* Next non-retransmit should have TCP CWR set, only used for classic ECN */
539 #define TE_SENDECE 0x00000010 /* Next packet should have TCP ECE set, only used for classic ECN */
540 #define TE_INRECOVERY 0x00000020 /* connection entered recovery after receiving ECE */
541 #define TE_RECV_ECN_CE 0x00000040 /* Received IPTOS_ECN_CE marking atleast once */
542 #define TE_RECV_ECN_ECE 0x00000080 /* Received ECE marking atleast once */
543 #define TE_LOST_SYN 0x00000100 /* Lost SYN with ECN setup */
544 #define TE_LOST_SYNACK 0x00000200 /* Lost SYN-ACK with ECN setup */
545 #define TE_ECN_MODE_ENABLE 0x00000400 /* Option ECN mode set to enable */
546 #define TE_ECN_MODE_DISABLE 0x00000800 /* Option ECN mode set to disable */
547 #define TE_ENABLE_ECN 0x00001000 /* Enable negotiation of ECN */
548 #define TE_ECN_ON (TE_SETUPSENT | TE_SETUPRECEIVED) /* ECN was successfully negotiated on a connection */
549 #define TE_CEHEURI_SET 0x00002000 /* We did our CE-probing at the beginning */
550 #define TE_CLIENT_SETUP 0x00004000 /* setup from client side */
551 #define TE_RCVD_SYN_RST 0x00008000 /* Received RST to the first ECN enabled SYN */
552 #define TE_ACE_SETUP_NON_ECT 0x00010000 /* Encode received non-ECT either for SYN-ACK (server) or final ACK (client) */
553 #define TE_ACE_SETUP_ECT1 0x00020000 /* Encode received ECT1 either for SYN-ACK (server) or final ACK (client) */
554 #define TE_ACE_SETUP_ECT0 0x00040000 /* Encode received ECT0 either for SYN-ACK (server) or final ACK (client) */
555 #define TE_ACE_SETUP_CE 0x00080000 /* Encode received CE either for SYN-ACK (server) or final ACK (client) */
556 #define TE_ACE_SETUPSENT 0x00100000 /* We have sent Accurate ECN setup SYN or SYN-ACK */
557 #define TE_ACE_SETUPRECEIVED 0x00200000 /* We have received Accurate ECN setup SYN or SYN-ACK */
558 #define TE_ACC_ECN_ON (TE_ACE_SETUPSENT | TE_ACE_SETUPRECEIVED) /* Accurate ECN was negotiated */
559 #define TE_ACE_FINAL_ACK_3WHS 0x00400000 /* Client has received SYN-ACK and will now send final ACK of 3WHS, only used for AccECN */
560 #define TE_ACO_ECT1 0x00800000 /* ECT1 counter changed flag, used to decide ordering for AccECN option */
561 #define TE_ACO_ECT0 0x01000000 /* ECT0 counter changed flag, used to decide ordering for AccECN option */
562 #define TE_RETRY_WITHOUT_ACO 0x02000000 /* Data segment with AccECN option was not acknowledged, retry without AccECN option */
563 #define TE_FORCE_ECT1 0x40000000 /* Force setting ECT1 on outgoing packets for testing purpose */
564 #define TE_FORCE_ECT0 0x80000000 /* Force setting ECT0 on outgoing packets for testing purpose */
565
566 u_int32_t t_ecn_recv_ce; /* Received CE from the network */
567 u_int32_t t_ecn_recv_cwr; /* Packets received with CWR */
568 uint32_t t_client_accecn_state; /* Client's Accurate ECN state */
569 uint32_t t_server_accecn_state; /* Server's Accurate ECN state */
570 uint64_t t_ecn_capable_packets_sent; /* Packets sent with ECT */
571 uint64_t t_ecn_capable_packets_acked; /* Packets sent with ECT that were acked */
572 uint64_t t_ecn_capable_packets_marked; /* Packets sent with ECT that were marked */
573 uint64_t t_ecn_capable_packets_lost; /* Packets sent with ECT that were lost */
574
575 uint32_t t_last_ack_tsecr; /* TS Echo Reply for last ACK that acknowledged a data or control packet */
576 uint16_t t_prev_ace_flags; /* ACE flags that were sent in previous packet, used for retransmitting after timeout */
577 uint8_t t_prev_ip_ecn; /* IP ECN flag on the previous packet, used for change-triggered ACKs */
578
579 struct accecn t_aecn; /* AccECN related byte counters */
580
581 struct pacer t_pacer; /* Pacer state used to pace packets */
582
583 /* state for bad retransmit recovery */
584 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
585 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
586 tcp_seq snd_recover_prev; /* snd_recover prior to retransmit */
587 int t_srtt_prev; /* srtt prior to retransmit */
588 int t_rttvar_prev; /* rttvar prior to retransmit */
589 u_int32_t t_badrexmt_time; /* bad rexmt detection time */
590
591 /* Packet reordering metric */
592 u_int32_t t_reorderwin; /* Reordering late time offset */
593
594 /* SACK related state */
595 int16_t snd_numholes; /* number of holes seen by sender */
596 TAILQ_HEAD(sackhole_head, sackhole) snd_holes;
597 /* SACK scoreboard (sorted) */
598 tcp_seq snd_fack; /* last seq number(+1) sack'd by rcv'r*/
599 int rcv_numsacks; /* # distinct sack blks present */
600 struct sackblk sackblks[MAX_SACK_BLKS]; /* seq nos. of sack blocks */
601 struct sackhint sackhint; /* SACK scoreboard hint */
602
603 struct mbuf *t_pktlist_head; /* First packet in transmit chain */
604 struct mbuf *t_pktlist_tail; /* Last packet in transmit chain */
605 u_int32_t t_pktlist_sentlen; /* total bytes in transmit chain */
606
607 u_int32_t t_keepidle; /* keepalive idle timer (override global if > 0) */
608 u_int32_t t_keepinit; /* connection timeout, i.e. idle time
609 * in SYN_SENT or SYN_RECV state */
610 u_int32_t t_keepintvl; /* interval between keepalives */
611 u_int32_t t_keepcnt; /* number of keepalives before close */
612
613 u_int32_t tso_max_segment_size; /* TSO maximum segment unit for NIC */
614 u_int16_t t_pmtud_lastseg_size; /* size of the last sent segment */
615 u_int32_t t_pmtud_saved_maxopd; /* MSS saved before performing PMTU-D BlackHole detection */
616 u_int32_t t_pmtud_start_ts; /* Time of PMTUD blackhole detection */
617
618 struct{
619 u_int32_t rxduplicatebytes;
620 u_int32_t rxoutoforderbytes;
621 u_int32_t txretransmitbytes;
622 u_int16_t synrxtshift;
623 u_int16_t rxmitsyns;
624 u_int16_t unused_pad_to_8;
625 u_int32_t rxmitpkts;
626 uint32_t delayed_acks_sent;
627 uint32_t acks_delayed;
628 } t_stat;
629 u_int8_t t_syn_sent;
630 u_int8_t t_syn_rcvd;
631 u_int8_t t_notify_ack_count;
632 u_int8_t t_ecn_recv_ce_pkt; /* Received packet with CE-bit set (independent from last_ack_sent) */
633 u_int32_t t_cached_maxopd; /* default for MSS adjustment using link status report */
634
635 uint32_t bg_ssthresh; /* Slow start threshold until delay increases */
636 uint32_t t_flagsext; /* Another field to accommodate more flags */
637 #define TF_RXTFINDROP 0x1 /* Drop conn after retransmitting FIN 3 times */
638 #define TF_RCVUNACK_WAITSS 0x2 /* set when the receiver should not stretch acks */
639 #define TF_BWMEAS_INPROGRESS 0x4 /* Indicate BW meas is happening */
640 #define TF_MEASURESNDBW 0x8 /* Measure send bw on this connection */
641 #define TF_LAST_IS_PSH 0x10 /* Indicates whether the last packet in the rcv socket buffer had the PUSH-flag set */
642 #define TF_SACK_ENABLE 0x20 /* SACK is enabled */
643 #define TF_RECOMPUTE_RTT 0x40 /* recompute RTT after spurious retransmit */
644 #define TF_DETECT_READSTALL 0x80 /* Used to detect a stall during read operation */
645 #define TF_RECV_THROTTLE 0x100 /* Input throttling active */
646 #define TF_NOSTRETCHACK 0x200 /* ack every other packet */
647 #define TF_NOTIMEWAIT 0x800 /* Avoid going into time-wait */
648 #define TF_SENT_TLPROBE 0x1000 /* Sent data in PTO */
649 #define TF_PKTS_REORDERED 0x2000 /* Detected reordering */
650 #define TF_DELAY_RECOVERY 0x4000 /* delay fast recovery */
651 #define TF_FORCE 0x8000 /* force 1 byte out */
652 #define TF_DISABLE_STRETCHACK 0x10000 /* auto-disable stretch ack */
653 #define TF_NOBLACKHOLE_DETECTION 0x20000 /* Disable PMTU blackhole detection */
654 #define TF_RESCUE_RXT 0x80000 /* SACK rescue retransmit */
655 #define TF_CWND_NONVALIDATED 0x100000 /* cwnd non validated */
656 #define TF_IF_PROBING 0x200000 /* Trigger interface probe timeout */
657 #define TF_FASTOPEN 0x400000 /* TCP Fastopen is enabled */
658 #define TF_REASS_INPROG 0x800000 /* Reassembly is in progress */
659 #define TF_FASTOPEN_FORCE_ENABLE 0x1000000 /* Force-enable TCP Fastopen */
660 #define TF_USR_OUTPUT 0x2000000 /* In connect() or send() so tcp_output() can log */
661 #define TF_L4S_ENABLED 0x8000000 /* L4S was force enabled */
662 #define TF_L4S_DISABLED 0x10000000 /* L4S was force disabled */
663 #define TF_RACK_ENABLED 0x20000000 /* RACK is enabled */
664 #define TF_TLP_IS_RETRANS 0x40000000 /* Is TLP-probe a retransmission ? (field TLP.is_retrans in RFC 8985) */
665
666 #if TRAFFIC_MGT
667 /* Inter-arrival jitter related state */
668 uint32_t iaj_rcv_ts; /* tcp clock when the first packet was received */
669 int iaj_size; /* Size of packet for iaj measurement */
670 uint8_t iaj_small_pkt; /* Count of packets smaller than iaj_size */
671 uint8_t t_pipeack_ind; /* index for next pipeack sample */
672 uint16_t iaj_pktcnt; /* packet count, to avoid throttling initially */
673 uint32_t acc_iaj; /* Accumulated iaj */
674 uint32_t avg_iaj; /* Mean */
675 uint32_t std_dev_iaj; /* Standard deviation */
676 #endif /* TRAFFIC_MGT */
677 struct bwmeas *t_bwmeas; /* State for bandwidth measurement */
678 tcp_seq t_idleat; /* rcv_nxt at idle time */
679 uint8_t t_fin_sent;
680 uint8_t t_fin_rcvd;
681 uint8_t t_rst_sent;
682 uint8_t t_rst_rcvd;
683 TAILQ_ENTRY(tcpcb) t_twentry; /* link for time wait queue */
684 struct tcp_ccstate *t_ccstate; /* congestion control related state */
685 struct tcp_ccstate _t_ccstate; /* congestion control related state, non-allocated */
686 /* Tail loss probe related state */
687 tcp_seq t_tlphighrxt; /* snd_nxt after PTO */
688 tcp_seq t_tlphightrxt_persist; /* like t_tlphighrxt but persists over ACKs until DSACK (if any) is processed */
689 uint32_t t_tlpstart; /* timestamp at PTO */
690 /* DSACK data receiver state */
691 tcp_seq t_dsack_lseq; /* DSACK left sequence */
692 tcp_seq t_dsack_rseq; /* DSACK right sequence */
693 /* DSACK data sender state */
694 SLIST_HEAD(tcp_rxt_seghead, tcp_rxt_seg) t_rxt_segments;
695 uint32_t t_rxt_seg_count;
696 uint32_t t_rxt_seg_drop;
697 tcp_seq t_dsack_lastuna; /* snd_una when last recovery episode started */
698 /* state for congestion window validation (draft-ietf-tcpm-newcwv-07) */
699 #define TCP_PIPEACK_SAMPLE_COUNT 3
700 u_int32_t t_pipeack_sample[TCP_PIPEACK_SAMPLE_COUNT]; /* pipeack, bytes acked within RTT */
701 tcp_seq t_pipeack_lastuna; /* una when pipeack measurement started */
702 u_int32_t t_pipeack;
703 u_int32_t t_lossflightsize;
704
705 #if MPTCP
706 u_int32_t t_mpflags; /* flags for multipath TCP */
707
708 #define TMPF_PREESTABLISHED 0x00000001 /* conn in pre-established state */
709 #define TMPF_SND_KEYS 0x00000002 /* indicates that keys should be send */
710 #define TMPF_MPTCP_TRUE 0x00000004 /* negotiated MPTCP successfully */
711 /* UNUSED */
712 #define TMPF_SND_MPPRIO 0x00000010 /* send priority of subflow */
713 #define TMPF_SND_REM_ADDR 0x00000020 /* initiate address removal */
714 #define TMPF_RCVD_DACK 0x00000040 /* received a data-ack */
715 #define TMPF_JOINED_FLOW 0x00000080 /* Indicates additional flow */
716 #define TMPF_BACKUP_PATH 0x00000100 /* Indicates backup path */
717 #define TMPF_MPTCP_ACKNOW 0x00000200 /* Send Data ACK */
718 #define TMPF_SEND_DSN 0x00000400 /* Send DSN mapping */
719 #define TMPF_SEND_DFIN 0x00000800 /* Send Data FIN */
720 #define TMPF_RECV_DFIN 0x00001000 /* Recv Data FIN */
721 #define TMPF_SENT_JOIN 0x00002000 /* Sent Join */
722 #define TMPF_RECVD_JOIN 0x00004000 /* Received Join */
723 #define TMPF_RESET 0x00008000 /* Send RST */
724 #define TMPF_TCP_FALLBACK 0x00010000 /* Fallback to TCP */
725 #define TMPF_FASTCLOSERCV 0x00020000 /* Received Fastclose option */
726 #define TMPF_EMBED_DSN 0x00040000 /* tp has DSN mapping */
727 #define TMPF_MPTCP_READY 0x00080000 /* Can send DSS options on data */
728 #define TMPF_INFIN_SENT 0x00100000 /* Sent infinite mapping */
729 #define TMPF_SND_MPFAIL 0x00200000 /* Received mapping csum failure */
730 #define TMPF_SND_JACK 0x00400000 /* Send a Join-ACK */
731 #define TMPF_TFO_REQUEST 0x00800000 /* TFO Requested */
732 #define TMPF_MPTCP_ECHO_ADDR 0x01000000 /* MPTCP echoes add_addr */
733
734 #define TMPF_MPTCP_SIGNALS (TMPF_SND_MPPRIO | TMPF_SND_REM_ADDR | TMPF_SND_MPFAIL | TMPF_SND_JACK | TMPF_MPTCP_ECHO_ADDR)
735
736 tcp_seq t_mpuna; /* unacknowledged sequence */
737 struct mptcb *t_mptcb; /* pointer to MPTCP TCB */
738 struct mptsub *t_mpsub; /* pointer to the MPTCP subflow */
739 struct mpt_dsn_map t_rcv_map; /* Receive mapping list */
740 u_int8_t t_local_aid; /* Addr Id for authentication */
741 u_int8_t t_rem_aid; /* Addr ID of another subflow */
742 u_int8_t t_mprxtshift; /* join retransmission */
743 #endif /* MPTCP */
744
745 #define TFO_F_OFFER_COOKIE 0x01 /* We will offer a cookie */
746 #define TFO_F_COOKIE_VALID 0x02 /* The received cookie is valid */
747 #define TFO_F_COOKIE_REQ 0x04 /* Client requested a new cookie */
748 #define TFO_F_COOKIE_SENT 0x08 /* Client did send a cookie in the SYN */
749 #define TFO_F_SYN_LOSS 0x10 /* A SYN-loss triggered a fallback to regular TCP on the client-side */
750 #define TFO_F_NO_SNDPROBING 0x20 /* This network is guaranteed to support TFO in the upstream direction */
751 #define TFO_F_HEURISTIC_DONE 0x40 /* We have already marked this network as bad */
752 u_int8_t t_tfo_flags;
753 #define TFO_S_SYNDATA_RCV 0x01 /* SYN+data has been received */
754 #define TFO_S_COOKIEREQ_RECV 0x02 /* TFO-cookie request received */
755 #define TFO_S_COOKIE_SENT 0x04 /* TFO-cookie announced in SYN/ACK */
756 #define TFO_S_COOKIE_INVALID 0x08 /* Received TFO-cookie is invalid */
757 #define TFO_S_COOKIE_REQ 0x10 /* TFO-cookie requested within the SYN */
758 #define TFO_S_COOKIE_RCV 0x20 /* TFO-cookie received in SYN/ACK */
759 #define TFO_S_SYN_DATA_SENT 0x40 /* SYN+data sent */
760 #define TFO_S_SYN_DATA_ACKED 0x80 /* SYN+data has been acknowledged in SYN/ACK */
761 #define TFO_S_SYN_LOSS 0x0100 /* SYN+TFO has been lost - fallback to regular TCP */
762 #define TFO_S_COOKIE_WRONG 0x0200 /* Cookie we sent in the SYN was wrong */
763 #define TFO_S_NO_COOKIE_RCV 0x0400 /* We asked for a cookie but didn't get one */
764 #define TFO_S_HEURISTICS_DISABLE 0x0800 /* TFO-heuristics disabled it for this connection */
765 #define TFO_S_SEND_BLACKHOLE 0x1000 /* TFO got blackholed in the send direction */
766 #define TFO_S_RECV_BLACKHOLE 0x2000 /* TFO got blackholed in the recv direction */
767 #define TFO_S_ONE_BYTE_PROXY 0x4000 /* TFO failed because of a proxy acknowledging just one byte */
768 u_int16_t t_tfo_stats;
769
770 u_int8_t t_tfo_probes; /* TFO-probes we did send */
771 /*
772 * This here is the TFO-probing state-machine. Transitions are as follows:
773 *
774 * Current state: PROBE_NONE
775 * Event: SYN+DATA acknowledged
776 * Action: Transition to PROBE_PROBING and set keepalive-timer
777 *
778 * Current state: PROBE_PROBING (initial state)
779 * Event: Receive data
780 * Action: Transition to PROBE_NONE and cancel keepalive-timer
781 * Event: Receive ACK that does not indicate a hole
782 * Action: Transition to PROBE_NONE and cancel keepalive-timer
783 * Event: Receive ACK that indicates a hole
784 * Action: Transition to PROBE_WAIT_DATA and set a short timer
785 * to wait for the final segment.
786 * Event: Keepalive-timeout (did not receive any segment)
787 * Action: Signal ETIMEDOUT as with regular keepalive-timers
788 *
789 * Current state: PROBE_WAIT_DATA
790 * Event: Receive data
791 * Action: Transition to PROBE_NONE and cancel keepalive-timer
792 * Event: Data-timeout (did not receive the expected data)
793 * Action: Signal ENODATA up to the app and close everything.
794 */
795 #define TFO_PROBE_NONE 0 /* Not probing now */
796 #define TFO_PROBE_PROBING 1 /* Sending out TCP-keepalives waiting for reply */
797 #define TFO_PROBE_WAIT_DATA 2 /* Received reply, waiting for data */
798 u_int8_t t_tfo_probe_state;
799
800 u_int32_t t_rcvoopack; /* out-of-order packets received */
801 u_int32_t t_pawsdrop; /* segments dropped due to PAWS */
802 u_int32_t t_sack_recovery_episode; /* SACK recovery episodes */
803 uint32_t t_rack_recovery_episode; /* RACK recovery episodes */
804 uint32_t t_rack_reo_timeout_recovery_episode; /* RACK recovery triggered by reordering timeout */
805 u_int32_t t_reordered_pkts; /* packets reorderd */
806 u_int32_t t_dsack_sent; /* Sent DSACK notification */
807 u_int32_t t_dsack_recvd; /* Received a valid DSACK option */
808 SLIST_HEAD(, tcp_notify_ack_marker) t_notify_ack; /* state for notifying data acknowledgements */
809 u_int32_t t_recv_throttle_ts; /* TS for start of recv throttle */
810 u_int32_t t_rxt_minimum_timeout; /* minimum retransmit timeout in ms */
811 uint32_t t_challengeack_last; /* last time challenge ACK was sent per sec */
812 uint32_t t_challengeack_count; /* # of challenge ACKs already sent per sec */
813
814 u_int32_t t_connect_time; /* time when the connection started */
815
816 uint64_t t_rcvwnd_limited_total_time;
817 uint64_t t_rcvwnd_limited_start_time;
818
819
820 uint32_t t_comp_rxmt_gencnt; /* Current compression generation-count for segments */
821
822 uint32_t t_comp_ack_gencnt; /* Current compression generation-count for ACKs */
823 uint32_t t_comp_ack_lastinc; /* Last time the gen-count was changed - should change every TCP_COMP_CHANGE_RATE ms */
824 #define TCP_COMP_CHANGE_RATE 5 /* Intervals at which we change the gencnt. Means that worst-case we send one ACK every TCP_COMP_CHANGE_RATE ms */
825
826 uint32_t t_ts_offset; /* Randomized timestamp offset to hide on-the-wire timestamp */
827
828 #define NCURR_RTT_HIST 4 /* Number of current RTT samples (k) */
829 uint32_t curr_rtt_hist[NCURR_RTT_HIST]; /* last k current RTT samples */
830 uint32_t curr_rtt_min; /* Minimum current RTT from last k samples */
831 uint32_t curr_rtt_index; /* Index for current RTT samples */
832
833 tcp_seq rcv_high; /* highest sequence number received */
834 uint32_t tsv_high; /* timestamp value of highest received sequence number */
835 struct tcp_rledbat_state t_rlstate; /* State used by rLedbat */
836
837 uint32_t rcv_srtt; /* receiver's SRTT, coarse when Timestamp not supported */
838 uint32_t rcv_rtt_est_ts; /* start of measurement for estimating RTT when Timestamp not supported */
839 uint32_t rcv_rtt_est_seq; /* expected sequence number for completion of 1RTT when Timestamp not supported */
840
841 TAILQ_HEAD(tcp_seg_sent_head, tcp_seg_sent) t_segs_sent; /* Time ordered segment list used for RACK */
842 struct tcp_seg_sent_tree_head t_segs_sent_tree; /* RB tree to track S/ACKED segments used for RACK */
843 TAILQ_HEAD(tcp_seg_acked_head, tcp_seg_sent) t_segs_acked; /* Temporary storage for ACKed segments used for RACK */
844 struct tcp_seg_pool seg_pool;
845
846 # define TCP_RACK_RECOVERY_PERSIST_MAX (16)
847 struct tcp_rack {
848 uint32_t xmit_ts;
849 uint32_t end_seq;
850 uint32_t rtt; /* RTT of the most recently delivered segment that was not marked as invalid as a possible spurious retransmission. */
851 tcp_seq dsack_round_end;
852 uint32_t reo_wnd;
853 uint8_t reo_wnd_multi;
854 uint8_t reo_wnd_persist:5,
855 advanced:1,
856 dsack_round_seen:1,
857 segs_retransmitted:1;
858 } rack;
859
860 /*
861 * Below counters are used to estmitate current flight size,
862 * hence these counters reflect current values instead of total
863 */
864 uint32_t bytes_lost;
865 uint32_t bytes_retransmitted;
866 uint32_t bytes_sacked;
867
868 uuid_t t_fsw_uuid;
869 uuid_t t_flow_uuid;
870 };
871
872 __CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct tcpcb, tcpcb);
873
874 #define IN_FASTRECOVERY(tp) (tp->t_flags & TF_FASTRECOVERY)
875 #define SACK_ENABLED(tp) (tp->t_flagsext & TF_SACK_ENABLE)
876 #define TFO_ENABLED(tp) (tp->t_flagsext & TF_FASTOPEN)
877 #define TCP_RACK_ENABLED(tp) ((tp->t_flagsext & TF_RACK_ENABLED) && SACK_ENABLED(tp) && !TFO_ENABLED(tp))
878
879 static inline bool
tcp_sent_tlp_retrans(const struct tcpcb * tp)880 tcp_sent_tlp_retrans(const struct tcpcb *tp)
881 {
882 return (tp->t_flagsext & (TF_SENT_TLPROBE | TF_TLP_IS_RETRANS)) == (TF_SENT_TLPROBE | TF_TLP_IS_RETRANS);
883 }
884
885 /*
886 * If the connection is in a throttled state due to advisory feedback from
887 * the interface output queue, reset that state. We do this in favor
888 * of entering recovery because the data transfer during recovery
889 * should be just a trickle and it will help to improve performance.
890 * We also do not want to back off twice in the same RTT.
891 */
892 #define ENTER_FASTRECOVERY(_tp_) do { \
893 (_tp_)->t_flags |= TF_FASTRECOVERY; \
894 if (INP_IS_FLOW_CONTROLLED((_tp_)->t_inpcb)) \
895 inp_reset_fc_state((_tp_)->t_inpcb); \
896 if (!SLIST_EMPTY(&tp->t_rxt_segments)) \
897 tcp_rxtseg_clean(tp); \
898 } while(0)
899
900 #define EXIT_FASTRECOVERY(_tp_) do { \
901 (_tp_)->t_flags &= ~TF_FASTRECOVERY; \
902 (_tp_)->t_dupacks = 0; \
903 (_tp_)->t_rexmtthresh = (uint8_t)tcprexmtthresh; \
904 (_tp_)->t_bytes_acked = 0; \
905 (_tp_)->ecn_flags &= ~TE_INRECOVERY; \
906 (_tp_)->t_timer[TCPT_PTO] = 0; \
907 (_tp_)->t_flagsext &= ~TF_RESCUE_RXT; \
908 (_tp_)->t_lossflightsize = 0; \
909 (_tp_)->sackhint.sack_bytes_acked = 0; \
910 } while(0)
911
912 /*
913 * When the number of duplicate acks received is less than
914 * the retransmit threshold, use Limited Transmit algorithm
915 */
916 extern uint8_t tcprexmtthresh;
917 #define ALLOW_LIMITED_TRANSMIT(_tp_) \
918 ((_tp_)->t_dupacks > 0 && \
919 (_tp_)->t_dupacks < (_tp_)->t_rexmtthresh && \
920 ((_tp_)->t_flagsext & (TF_PKTS_REORDERED|TF_DELAY_RECOVERY)) \
921 != (TF_PKTS_REORDERED|TF_DELAY_RECOVERY))
922
923 /*
924 * This condition is true if timestamp option is supported
925 * on a connection.
926 */
927 #define TSTMP_SUPPORTED(_tp_) \
928 (((_tp_)->t_flags & (TF_REQ_TSTMP|TF_RCVD_TSTMP)) == \
929 (TF_REQ_TSTMP|TF_RCVD_TSTMP))
930
931 /*
932 * This condition is true if window scale option is supported
933 * on a connection
934 */
935 #define TCP_WINDOW_SCALE_ENABLED(_tp_) \
936 (((_tp_)->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) == \
937 (TF_RCVD_SCALE|TF_REQ_SCALE))
938
939 /* Is ECN negotiated end-to-end */
940 #define TCP_ECN_ENABLED(_tp_) \
941 (((_tp_)->ecn_flags & (TE_ECN_ON)) == (TE_ECN_ON))
942
943 extern int tcp_l4s;
944 extern int tcp_l4s_developer;
945
946 /* L4S Developer setting will override system setting */
947 typedef enum {
948 tcp_l4s_system = 0,
949 tcp_l4s_developer_enable = 1,
950 tcp_l4s_developer_disable = 2
951 } tcp_l4s_t;
952
953 /*
954 * TCP L4S is enabled if,
955 * 1. It is not disabled explicitly by developer or tcp options
956 * 2. It is enabled either by developer or A/B deployment or tcp_options,
957 * It implicitly enables Accurate ECN which supports ACE and AccECN option for ECN feedback
958 */
959
960 #define TCP_L4S_DISABLED(_tp_) \
961 (tcp_l4s_developer == tcp_l4s_developer_disable || \
962 ((_tp_)->t_flagsext & TF_L4S_DISABLED) == 1)
963
964 #define TCP_L4S_ENABLED(_tp_) \
965 (!TCP_L4S_DISABLED(tp) && \
966 (tcp_l4s_developer == tcp_l4s_developer_enable || \
967 tcp_l4s == 1 || ((_tp_)->t_flagsext & TF_L4S_ENABLED)))
968
969 /* L4S is enabled and Accurate ECN has been negotiated end-to-end */
970 #define TCP_ACC_ECN_ON(_tp_) \
971 (TCP_L4S_ENABLED(_tp_) && \
972 (((_tp_)->ecn_flags & (TE_ACC_ECN_ON)) == (TE_ACC_ECN_ON)))
973
974 /*
975 * Gives number of bytes acked by this ack
976 */
977 #define BYTES_ACKED(_th_, _tp_) \
978 ((_th_)->th_ack - (_tp_)->snd_una)
979
980 /* Returns true if a DSACK option should be sent */
981 #define TCP_SEND_DSACK_OPT(_tp_) \
982 ((_tp_)->t_dsack_lseq > 0 && (_tp_)->t_dsack_rseq > 0)
983
984 /*
985 * Returns true if a DSACK sequence is within the max send window that will
986 * be accepted. In order to set a window to validate sequence numbers, the
987 * max send window within which a DSACK option is processed is limited.
988 *
989 * We need to choose a maximum window to check if the sequence number is
990 * within the window. One arbitrary choice is 256 * MSS because if the
991 * window is as large as 256 segments it might be big enough to ignore the
992 * DSACK option. Choosing a much larger limit means that the memory for
993 * retransmit segments can be held for a longer time.
994 */
995 #define TCP_DSACK_MAX_SEND_WINDOW(_tp_) (MIN((_tp_)->snd_wnd, tcp_autosndbuf_max))
996 #define TCP_DSACK_SEQ_IN_WINDOW(_tp_, _seq_, _una_) \
997 (SEQ_LEQ((_seq_), (_tp_)->snd_max) && \
998 SEQ_GEQ((_seq_), ((_una_) - TCP_DSACK_MAX_SEND_WINDOW(_tp_))))
999
1000 #define TCP_RESET_REXMT_STATE(_tp_) do { \
1001 (_tp_)->t_rxtshift = 0; \
1002 (_tp_)->t_rxtstart = 0; \
1003 mptcp_reset_rexmit_state((_tp_)); \
1004 } while(0);
1005
1006 #define TCP_IF_STATE_CHANGED(tp, probe_if_index) \
1007 (probe_if_index > 0 && tp->t_inpcb->inp_last_outifp != NULL && \
1008 probe_if_index == tp->t_inpcb->inp_last_outifp->if_index)
1009
1010 #define TCP_RLEDBAT_ENABLED(_tp) \
1011 (tcp_rledbat == 1 && TSTMP_SUPPORTED(_tp))
1012
1013 #define TCP_RECV_BG(_so) \
1014 (tcp_recv_bg == 1 || IS_TCP_RECV_BG(_so))
1015
1016 #define TCP_USE_RLEDBAT(_tp, _so) \
1017 TCP_RLEDBAT_ENABLED(_tp) && TCP_RECV_BG(_so)
1018
1019 /*
1020 * Structure to hold TCP options that are only used during segment
1021 * processing (in tcp_input), but not held in the tcpcb.
1022 * It's basically used to reduce the number of parameters
1023 * to tcp_dooptions.
1024 */
1025 struct tcpopt {
1026 uint32_t to_flags; /* which options are present */
1027 #define TOF_TS 0x0001 /* timestamp */
1028 #define TOF_MSS 0x0010
1029 #define TOF_SCALE 0x0020
1030 #define TOF_SIGNATURE 0x0040 /* signature option present */
1031 #define TOF_SIGLEN 0x0080 /* signature length valid (RFC2385) */
1032 #define TOF_SACK 0x0100 /* Peer sent SACK option */
1033 #define TOF_MPTCP 0x0200 /* MPTCP options to be dropped */
1034 #define TOF_TFO 0x0400 /* TFO cookie option present */
1035 #define TOF_TFOREQ 0x0800 /* TFO cookie request present */
1036 uint32_t to_tsval;
1037 uint32_t to_tsecr;
1038 uint16_t to_mss;
1039 uint8_t to_requested_s_scale;
1040 uint8_t to_nsacks; /* number of SACK blocks */
1041 u_char *to_sacks __sized_by(to_sacks_size); /* pointer to the first SACK blocks */
1042 uint32_t to_sacks_size; /* boundary for to_sacks */
1043 u_char *to_tfo __sized_by(to_tfo_size); /* pointer to the TFO cookie */
1044 uint32_t to_tfo_size; /* boundary for to_tfo */
1045 uint8_t to_num_accecn; /* number of Accurate ECN counters */
1046 uint8_t *to_accecn __sized_by(to_accecn_size); /* pointer to the first Accurate ECN counter */
1047 uint32_t to_accecn_size; /* boundary for to_accecn */
1048 uint8_t to_accecn_order; /* Accurate ECN ordering */
1049 };
1050
1051 #define intotcpcb(ip) ((struct tcpcb *)(ip)->inp_ppcb)
1052 #define sototcpcb(so) (intotcpcb(sotoinpcb(so)))
1053
1054 /* TFO-specific defines */
1055 #define TFO_COOKIE_LEN_MIN 4
1056 #define TFO_COOKIE_LEN_DEFAULT 8
1057 #define TFO_COOKIE_LEN_MAX 16
1058
1059 /*
1060 * The initial retransmission should happen at rtt + 4 * rttvar.
1061 * Because of the way we do the smoothing, srtt and rttvar
1062 * will each average +1/2 tick of bias. When we compute
1063 * the retransmit timer, we want 1/2 tick of rounding and
1064 * 1 extra tick because of +-1/2 tick uncertainty in the
1065 * firing of the timer. The bias will give us exactly the
1066 * 1.5 tick we need. But, because the bias is
1067 * statistical, we have to test that we don't drop below
1068 * the minimum feasible timer (which is 2 ticks).
1069 * This version of the macro adapted from a paper by Lawrence
1070 * Brakmo and Larry Peterson which outlines a problem caused
1071 * by insufficient precision in the original implementation,
1072 * which results in inappropriately large RTO values for very
1073 * fast networks.
1074 */
1075 #define TCP_REXMTVAL(tp) \
1076 max((tp)->t_rttmin, (((tp)->t_srtt >> (TCP_RTT_SHIFT - TCP_DELTA_SHIFT)) \
1077 + (tp)->t_rttvar) >> TCP_DELTA_SHIFT)
1078
1079 /*
1080 * Jaguar compatible TCP control block, for xtcpcb
1081 * Does not have the old fields
1082 */
1083 struct otcpcb {
1084 #else
1085 struct tseg_qent;
1086 _TCPCB_LIST_HEAD(tsegqe_head, tseg_qent);
1087
1088 struct tcpcb {
1089 #endif /* KERNEL_PRIVATE */
1090 #if defined(KERNEL_PRIVATE)
1091 u_int32_t t_segq;
1092 #else
1093 struct tsegqe_head t_segq;
1094 #endif /* KERNEL_PRIVATE */
1095 int t_dupacks; /* consecutive dup acks recd */
1096 u_int32_t unused; /* unused now: was t_template */
1097
1098 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1099
1100 _TCPCB_PTR(struct inpcb *) t_inpcb; /* back pointer to internet pcb */
1101 int t_state; /* state of this connection */
1102 u_int t_flags;
1103 #define TF_ACKNOW 0x00001 /* ack peer immediately */
1104 #define TF_DELACK 0x00002 /* ack, but try to delay it */
1105 #define TF_NODELAY 0x00004 /* don't delay packets to coalesce */
1106 #define TF_NOOPT 0x00008 /* don't use tcp options */
1107 #define TF_SENTFIN 0x00010 /* have sent FIN */
1108 #define TF_REQ_SCALE 0x00020 /* have/will request window scaling */
1109 #define TF_RCVD_SCALE 0x00040 /* other side has requested scaling */
1110 #define TF_REQ_TSTMP 0x00080 /* have/will request timestamps */
1111 #define TF_RCVD_TSTMP 0x00100 /* a timestamp was received in SYN */
1112 #define TF_SACK_PERMIT 0x00200 /* other side said I could SACK */
1113 #define TF_NEEDSYN 0x00400 /* send SYN (implicit state) - unused but needed for backwards compatibility */
1114 #define TF_NEEDFIN 0x00800 /* send FIN (implicit state) */
1115 #define TF_NOPUSH 0x01000 /* don't push */
1116 #define TF_REQ_CC 0x02000 /* have/will request CC */
1117 #define TF_RCVD_CC 0x04000 /* a CC was received in SYN */
1118 #define TF_SENDCCNEW 0x08000 /* Not implemented */
1119 #define TF_MORETOCOME 0x10000 /* More data to be appended to sock */
1120 #define TF_LQ_OVERFLOW 0x20000 /* listen queue overflow */
1121 #define TF_RXWIN0SENT 0x40000 /* sent a receiver win 0 in response */
1122 #define TF_SLOWLINK 0x80000 /* route is a on a modem speed link */
1123
1124 int t_force; /* 1 if forcing out a byte */
1125
1126 tcp_seq snd_una; /* send unacknowledged */
1127 tcp_seq snd_max; /* highest sequence number sent;
1128 * used to recognize retransmits
1129 */
1130 tcp_seq snd_nxt; /* send next */
1131 tcp_seq snd_up; /* send urgent pointer */
1132
1133 tcp_seq snd_wl1; /* window update seg seq number */
1134 tcp_seq snd_wl2; /* window update seg ack number */
1135 tcp_seq iss; /* initial send sequence number */
1136 tcp_seq irs; /* initial receive sequence number */
1137
1138 tcp_seq rcv_nxt; /* receive next */
1139 tcp_seq rcv_adv; /* advertised window */
1140 u_int32_t rcv_wnd; /* receive window */
1141 tcp_seq rcv_up; /* receive urgent pointer */
1142
1143 u_int32_t snd_wnd; /* send window */
1144 u_int32_t snd_cwnd; /* congestion-controlled window */
1145 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1146 * for slow start exponential to
1147 * linear switch
1148 */
1149 u_int t_maxopd; /* mss plus options */
1150
1151 u_int32_t t_rcvtime; /* time at which a packet was received */
1152 u_int32_t t_starttime; /* time connection was established */
1153 int t_rtttime; /* round trip time */
1154 tcp_seq t_rtseq; /* sequence number being timed */
1155
1156 int t_rxtcur; /* current retransmit value (ticks) */
1157 u_int t_maxseg; /* maximum segment size */
1158 int t_srtt; /* smoothed round-trip time */
1159 int t_rttvar; /* variance in round-trip time */
1160
1161 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1162 u_int t_rttmin; /* minimum rtt allowed */
1163 u_int32_t t_rttupdated; /* number of times rtt sampled */
1164 u_int32_t max_sndwnd; /* largest window peer has offered */
1165
1166 int t_softerror; /* possible error not yet reported */
1167 /* out-of-band data */
1168 char t_oobflags; /* have some */
1169 char t_iobc; /* input character */
1170 #define TCPOOB_HAVEDATA 0x01
1171 #define TCPOOB_HADDATA 0x02
1172 /* RFC 1323 variables */
1173 u_char snd_scale; /* window scaling for send window */
1174 u_char rcv_scale; /* window scaling for recv window */
1175 u_char request_r_scale; /* pending window scaling */
1176 u_char requested_s_scale;
1177 u_int32_t ts_recent; /* timestamp echo data */
1178
1179 u_int32_t ts_recent_age; /* when last updated */
1180 tcp_seq last_ack_sent;
1181 /* RFC 1644 variables */
1182 tcp_cc cc_send; /* send connection count */
1183 tcp_cc cc_recv; /* receive connection count */
1184 tcp_seq snd_recover; /* for use in fast recovery */
1185 /* experimental */
1186 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1187 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1188 u_int32_t t_badrxtwin; /* window for retransmit recovery */
1189 };
1190
1191 #define tcps_ecn_setup tcps_ecn_client_success
1192 #define tcps_sent_cwr tcps_ecn_recv_ece
1193 #define tcps_sent_ece tcps_ecn_sent_ece
1194
1195 /*
1196 * TCP statistics.
1197 * Many of these should be kept per connection,
1198 * but that's inconvenient at the moment.
1199 */
1200 struct tcpstat {
1201 u_int32_t tcps_connattempt; /* connections initiated */
1202 u_int32_t tcps_accepts; /* connections accepted */
1203 u_int32_t tcps_connects; /* connections established */
1204 u_int32_t tcps_drops; /* connections dropped */
1205 u_int32_t tcps_conndrops; /* embryonic connections dropped */
1206 u_int32_t tcps_closed; /* conn. closed (includes drops) */
1207 u_int32_t tcps_segstimed; /* segs where we tried to get rtt */
1208 u_int32_t tcps_rttupdated; /* times we succeeded */
1209 u_int32_t tcps_delack; /* delayed acks sent */
1210 u_int32_t tcps_timeoutdrop; /* conn. dropped in rxmt timeout */
1211 u_int32_t tcps_rexmttimeo; /* retransmit timeouts */
1212 u_int32_t tcps_persisttimeo; /* persist timeouts */
1213 u_int32_t tcps_keeptimeo; /* keepalive timeouts */
1214 u_int32_t tcps_keepprobe; /* keepalive probes sent */
1215 u_int32_t tcps_keepdrops; /* connections dropped in keepalive */
1216
1217 u_int32_t tcps_sndtotal; /* total packets sent */
1218 u_int32_t tcps_sndpack; /* data packets sent */
1219 u_int32_t tcps_sndbyte; /* data bytes sent */
1220 u_int32_t tcps_sndrexmitpack; /* data packets retransmitted */
1221 u_int32_t tcps_sndrexmitbyte; /* data bytes retransmitted */
1222 u_int32_t tcps_sndacks; /* ack-only packets sent */
1223 u_int32_t tcps_sndprobe; /* window probes sent */
1224 u_int32_t tcps_sndurg; /* packets sent with URG only */
1225 u_int32_t tcps_sndwinup; /* window update-only packets sent */
1226 u_int32_t tcps_sndctrl; /* control (SYN|FIN|RST) packets sent */
1227
1228 u_int32_t tcps_rcvtotal; /* total packets received */
1229 u_int32_t tcps_rcvpack; /* packets received in sequence */
1230 u_int32_t tcps_rcvbyte; /* bytes received in sequence */
1231 u_int32_t tcps_rcvbadsum; /* packets received with ccksum errs */
1232 u_int32_t tcps_rcvbadoff; /* packets received with bad offset */
1233 u_int32_t tcps_rcvmemdrop; /* packets dropped for lack of memory */
1234 u_int32_t tcps_rcvshort; /* packets received too short */
1235 u_int32_t tcps_rcvduppack; /* duplicate-only packets received */
1236 u_int32_t tcps_rcvdupbyte; /* duplicate-only bytes received */
1237 u_int32_t tcps_rcvpartduppack; /* packets with some duplicate data */
1238 u_int32_t tcps_rcvpartdupbyte; /* dup. bytes in part-dup. packets */
1239 u_int32_t tcps_rcvoopack; /* out-of-order packets received */
1240 u_int32_t tcps_rcvoobyte; /* out-of-order bytes received */
1241 u_int32_t tcps_rcvpackafterwin; /* packets with data after window */
1242 u_int32_t tcps_rcvbyteafterwin; /* bytes rcvd after window */
1243 u_int32_t tcps_rcvafterclose; /* packets rcvd after "close" */
1244 u_int32_t tcps_rcvwinprobe; /* rcvd window probe packets */
1245 u_int32_t tcps_rcvdupack; /* rcvd duplicate acks */
1246 u_int32_t tcps_rcvacktoomuch; /* rcvd acks for unsent data */
1247 u_int32_t tcps_rcvackpack; /* rcvd ack packets */
1248 u_int32_t tcps_rcvackbyte; /* bytes acked by rcvd acks */
1249 u_int32_t tcps_rcvwinupd; /* rcvd window update packets */
1250 u_int32_t tcps_pawsdrop; /* segments dropped due to PAWS */
1251 u_int32_t tcps_predack; /* times hdr predict ok for acks */
1252 u_int32_t tcps_preddat; /* times hdr predict ok for data pkts */
1253 u_int32_t tcps_pcbcachemiss;
1254 u_int32_t tcps_cachedrtt; /* times cached RTT in route updated */
1255 u_int32_t tcps_cachedrttvar; /* times cached rttvar updated */
1256 u_int32_t tcps_cachedssthresh; /* times cached ssthresh updated */
1257 u_int32_t tcps_usedrtt; /* times RTT initialized from route */
1258 u_int32_t tcps_usedrttvar; /* times RTTVAR initialized from rt */
1259 u_int32_t tcps_usedssthresh; /* times ssthresh initialized from rt*/
1260 u_int32_t tcps_persistdrop; /* timeout in persist state */
1261 u_int32_t tcps_badsyn; /* bogus SYN, e.g. premature ACK */
1262 u_int32_t tcps_mturesent; /* resends due to MTU discovery */
1263 u_int32_t tcps_listendrop; /* listen queue overflows */
1264 u_int32_t tcps_synchallenge; /* challenge ACK due to bad SYN */
1265 u_int32_t tcps_rstchallenge; /* challenge ACK due to bad RST */
1266
1267 /* new stats from FreeBSD 5.4 sync up */
1268 u_int32_t tcps_minmssdrops; /* average minmss too low drops */
1269
1270 u_int32_t tcps_sndrexmitbad; /* unnecessary packet retransmissions */
1271 u_int32_t tcps_badrst; /* ignored RSTs in the window */
1272
1273 u_int32_t tcps_sc_added; /* entry added to syncache */
1274 u_int32_t tcps_sc_retransmitted; /* syncache entry was retransmitted */
1275 u_int32_t tcps_sc_dupsyn; /* duplicate SYN packet */
1276 u_int32_t tcps_sc_dropped; /* could not reply to packet */
1277 u_int32_t tcps_sc_completed; /* successful extraction of entry */
1278 u_int32_t tcps_sc_bucketoverflow; /* syncache per-bucket limit hit */
1279 u_int32_t tcps_sc_cacheoverflow; /* syncache cache limit hit */
1280 u_int32_t tcps_sc_reset; /* RST removed entry from syncache */
1281 u_int32_t tcps_sc_stale; /* timed out or listen socket gone */
1282 u_int32_t tcps_sc_aborted; /* syncache entry aborted */
1283 u_int32_t tcps_sc_badack; /* removed due to bad ACK */
1284 u_int32_t tcps_sc_unreach; /* ICMP unreachable received */
1285 u_int32_t tcps_sc_zonefail; /* zalloc() failed */
1286 u_int32_t tcps_sc_sendcookie; /* SYN cookie sent */
1287 u_int32_t tcps_sc_recvcookie; /* SYN cookie received */
1288
1289 u_int32_t tcps_hc_added; /* entry added to hostcache */
1290 u_int32_t tcps_hc_bucketoverflow; /* hostcache per bucket limit hit */
1291
1292 /* SACK related stats */
1293 u_int32_t tcps_sack_recovery_episode; /* SACK recovery episodes */
1294 u_int32_t tcps_sack_rexmits; /* SACK rexmit segments */
1295 u_int32_t tcps_sack_rexmit_bytes; /* SACK rexmit bytes */
1296 u_int32_t tcps_sack_rcv_blocks; /* SACK blocks (options) received */
1297 u_int32_t tcps_sack_send_blocks; /* SACK blocks (options) sent */
1298 u_int32_t tcps_sack_sboverflow; /* SACK sendblock overflow */
1299
1300 /* RACK related stats */
1301 u_int32_t tcps_rack_recovery_episode; /* RACK recovery episodes */
1302 u_int32_t tcps_rack_reordering_timeout_recovery_episode; /* RACK recovery episodes due to reordering timeout */
1303 u_int32_t tcps_rack_rexmits; /* RACK rexmit segments */
1304
1305 u_int32_t tcps_bg_rcvtotal; /* total background packets received */
1306 u_int32_t tcps_rxtfindrop; /* drop conn after retransmitting FIN */
1307 u_int32_t tcps_fcholdpacket; /* packets withheld because of flow control */
1308
1309 u_int32_t tcps_limited_txt; /* Limited transmit used */
1310 u_int32_t tcps_early_rexmt; /* Early retransmit used */
1311 u_int32_t tcps_sack_ackadv; /* Cumulative ack advanced along with sack */
1312
1313 /* Checksum related stats */
1314 u_int32_t tcps_rcv_swcsum; /* tcp swcksum (inbound), packets */
1315 u_int32_t tcps_rcv_swcsum_bytes; /* tcp swcksum (inbound), bytes */
1316 u_int32_t tcps_rcv6_swcsum; /* tcp6 swcksum (inbound), packets */
1317 u_int32_t tcps_rcv6_swcsum_bytes; /* tcp6 swcksum (inbound), bytes */
1318 u_int32_t tcps_snd_swcsum; /* tcp swcksum (outbound), packets */
1319 u_int32_t tcps_snd_swcsum_bytes; /* tcp swcksum (outbound), bytes */
1320 u_int32_t tcps_snd6_swcsum; /* tcp6 swcksum (outbound), packets */
1321 u_int32_t tcps_snd6_swcsum_bytes; /* tcp6 swcksum (outbound), bytes */
1322 u_int32_t tcps_unused_1;
1323 u_int32_t tcps_unused_2;
1324 u_int32_t tcps_unused_3;
1325
1326 /* MPTCP Related stats */
1327 u_int32_t tcps_invalid_mpcap; /* Invalid MPTCP capable opts */
1328 u_int32_t tcps_invalid_joins; /* Invalid MPTCP joins */
1329 u_int32_t tcps_mpcap_fallback; /* TCP fallback in primary */
1330 u_int32_t tcps_join_fallback; /* No MPTCP in secondary */
1331 u_int32_t tcps_estab_fallback; /* DSS option dropped */
1332 u_int32_t tcps_invalid_opt; /* Catchall error stat */
1333 u_int32_t tcps_mp_outofwin; /* Packet lies outside the
1334 * shared recv window */
1335 u_int32_t tcps_mp_reducedwin; /* Reduced subflow window */
1336 u_int32_t tcps_mp_badcsum; /* Bad DSS csum */
1337 u_int32_t tcps_mp_oodata; /* Out of order data */
1338 u_int32_t tcps_mp_switches; /* number of subflow switch */
1339 u_int32_t tcps_mp_rcvtotal; /* number of rcvd packets */
1340 u_int32_t tcps_mp_rcvbytes; /* number of bytes received */
1341 u_int32_t tcps_mp_sndpacks; /* number of data packs sent */
1342 u_int32_t tcps_mp_sndbytes; /* number of bytes sent */
1343 u_int32_t tcps_join_rxmts; /* join ack retransmits */
1344 u_int32_t tcps_tailloss_rto; /* RTO due to tail loss */
1345 u_int32_t tcps_reordered_pkts; /* packets reorderd */
1346 u_int32_t tcps_recovered_pkts; /* recovered after loss */
1347 u_int32_t tcps_pto; /* probe timeout */
1348 u_int32_t tcps_rto_after_pto; /* RTO after a probe */
1349 u_int32_t tcps_tlp_recovery; /* TLP induced fast recovery */
1350 u_int32_t tcps_tlp_recoverlastpkt; /* TLP recoverd last pkt */
1351 u_int32_t tcps_ecn_client_success; /* client-side connection negotiated ECN */
1352 u_int32_t tcps_ecn_recv_ece; /* ECE received, sent CWR */
1353 u_int32_t tcps_ecn_sent_ece; /* Sent ECE notification */
1354 u_int32_t tcps_detect_reordering; /* Detect pkt reordering */
1355 u_int32_t tcps_delay_recovery; /* Delay fast recovery */
1356 u_int32_t tcps_avoid_rxmt; /* Retransmission was avoided */
1357 u_int32_t tcps_unnecessary_rxmt; /* Retransmission was not needed */
1358 u_int32_t tcps_nostretchack; /* disabled stretch ack algorithm on a connection */
1359 u_int32_t tcps_rescue_rxmt; /* SACK rescue retransmit */
1360 u_int32_t tcps_pto_in_recovery; /* rescue retransmit in fast recovery */
1361 u_int32_t tcps_pmtudbh_reverted; /* PMTU Blackhole detection, segment size reverted */
1362
1363 /* DSACK related statistics */
1364 u_int32_t tcps_dsack_disable; /* DSACK disabled due to n/w duplication */
1365 u_int32_t tcps_dsack_ackloss; /* ignore DSACK due to ack loss */
1366 u_int32_t tcps_dsack_badrexmt; /* DSACK based bad rexmt recovery */
1367 u_int32_t tcps_dsack_sent; /* Sent DSACK notification */
1368 u_int32_t tcps_dsack_recvd; /* Received a valid DSACK option */
1369 u_int32_t tcps_dsack_recvd_old; /* Received an out of window DSACK option */
1370
1371 /* MPTCP Subflow selection stats */
1372 u_int32_t tcps_mp_sel_symtomsd; /* By symptomsd */
1373 u_int32_t tcps_mp_sel_rtt; /* By RTT comparison */
1374 u_int32_t tcps_mp_sel_rto; /* By RTO comparison */
1375 u_int32_t tcps_mp_sel_peer; /* By peer's output pattern */
1376 u_int32_t tcps_mp_num_probes; /* Number of probes sent */
1377 u_int32_t tcps_mp_verdowngrade; /* MPTCP version downgrade */
1378 u_int32_t tcps_drop_after_sleep; /* drop after long AP sleep */
1379 u_int32_t tcps_probe_if; /* probe packets after interface availability */
1380 u_int32_t tcps_probe_if_conflict; /* Can't send probe packets for interface */
1381
1382 u_int32_t tcps_ecn_client_setup; /* Attempted ECN setup from client side */
1383 u_int32_t tcps_ecn_server_setup; /* Attempted ECN setup from server side */
1384 u_int32_t tcps_ecn_server_success; /* server-side connection negotiated ECN */
1385 u_int32_t tcps_ecn_ace_syn_not_ect; /* received AccECN SYN packet with Not-ECT */
1386 u_int32_t tcps_ecn_ace_syn_ect1; /* received AccECN SYN packet with ECT1 */
1387 u_int32_t tcps_ecn_ace_syn_ect0; /* received AccECN SYN packet with ECT0 */
1388 u_int32_t tcps_ecn_ace_syn_ce; /* received AccECN SYN packet with CE */
1389 u_int32_t tcps_ecn_lost_synack; /* Lost SYN-ACK with ECN setup */
1390 u_int32_t tcps_ecn_lost_syn; /* Lost SYN with ECN setup */
1391 u_int32_t tcps_ecn_not_supported; /* Server did not support ECN setup */
1392 u_int32_t tcps_ecn_recv_ce; /* Received CE from the network */
1393 u_int32_t tcps_ecn_ace_recv_ce; /* CE count received in ACE field */
1394 u_int32_t tcps_ecn_conn_recv_ce; /* Number of connections received CE atleast once */
1395 u_int32_t tcps_ecn_conn_recv_ece; /* Number of connections received ECE atleast once */
1396 u_int32_t tcps_ecn_conn_plnoce; /* Number of connections that received no CE and sufferred packet loss */
1397 u_int32_t tcps_ecn_conn_pl_ce; /* Number of connections that received CE and sufferred packet loss */
1398 u_int32_t tcps_ecn_conn_nopl_ce; /* Number of connections that received CE and sufferred no packet loss */
1399 u_int32_t tcps_ecn_fallback_synloss; /* Number of times we did fall back due to SYN-Loss */
1400 u_int32_t tcps_ecn_fallback_reorder; /* Number of times we fallback because we detected the PAWS-issue */
1401 u_int32_t tcps_ecn_fallback_ce; /* Number of times we fallback because we received too many CEs */
1402
1403 /* TFO-related statistics */
1404 u_int32_t tcps_tfo_syn_data_rcv; /* Received a SYN+data with valid cookie */
1405 u_int32_t tcps_tfo_cookie_req_rcv;/* Received a TFO cookie-request */
1406 u_int32_t tcps_tfo_cookie_sent; /* Offered a TFO-cookie to the client */
1407 u_int32_t tcps_tfo_cookie_invalid;/* Received an invalid TFO-cookie */
1408 u_int32_t tcps_tfo_cookie_req; /* Cookie requested with the SYN */
1409 u_int32_t tcps_tfo_cookie_rcv; /* Cookie received in a SYN/ACK */
1410 u_int32_t tcps_tfo_syn_data_sent; /* SYN+data+cookie sent */
1411 u_int32_t tcps_tfo_syn_data_acked;/* SYN+data has been acknowledged */
1412 u_int32_t tcps_tfo_syn_loss; /* SYN+TFO has been lost and we fallback */
1413 u_int32_t tcps_tfo_blackhole; /* TFO got blackholed by a middlebox. */
1414 u_int32_t tcps_tfo_cookie_wrong; /* TFO-cookie we sent was wrong */
1415 u_int32_t tcps_tfo_no_cookie_rcv; /* We asked for a cookie but didn't get one */
1416 u_int32_t tcps_tfo_heuristics_disable; /* TFO got disabled due to heuristics */
1417 u_int32_t tcps_tfo_sndblackhole; /* TFO got blackholed in the sending direction */
1418 u_int32_t tcps_mss_to_default; /* Change MSS to default using link status report */
1419 u_int32_t tcps_mss_to_medium; /* Change MSS to medium using link status report */
1420 u_int32_t tcps_mss_to_low; /* Change MSS to low using link status report */
1421 u_int32_t tcps_ecn_fallback_droprst; /* ECN fallback caused by connection drop due to RST */
1422 u_int32_t tcps_ecn_fallback_droprxmt; /* ECN fallback due to drop after multiple retransmits */
1423 u_int32_t tcps_ecn_fallback_synrst; /* ECN fallback due to rst after syn */
1424
1425 u_int32_t tcps_mptcp_rcvmemdrop; /* MPTCP packets dropped for lack of memory */
1426 u_int32_t tcps_mptcp_rcvduppack; /* MPTCP duplicate-only packets received */
1427 u_int32_t tcps_mptcp_rcvpackafterwin; /* MPTCP packets with data after window */
1428
1429 /* TCP timer statistics */
1430 u_int32_t tcps_timer_drift_le_1_ms; /* Timer drift less or equal to 1 ms */
1431 u_int32_t tcps_timer_drift_le_10_ms; /* Timer drift less or equal to 10 ms */
1432 u_int32_t tcps_timer_drift_le_20_ms; /* Timer drift less or equal to 20 ms */
1433 u_int32_t tcps_timer_drift_le_50_ms; /* Timer drift less or equal to 50 ms */
1434 u_int32_t tcps_timer_drift_le_100_ms; /* Timer drift less or equal to 100 ms */
1435 u_int32_t tcps_timer_drift_le_200_ms; /* Timer drift less or equal to 200 ms */
1436 u_int32_t tcps_timer_drift_le_500_ms; /* Timer drift less or equal to 500 ms */
1437 u_int32_t tcps_timer_drift_le_1000_ms; /* Timer drift less or equal to 1000 ms */
1438 u_int32_t tcps_timer_drift_gt_1000_ms; /* Timer drift greater than 1000 ms */
1439
1440 u_int32_t tcps_mptcp_handover_attempt; /* Total number of MPTCP-attempts using handover mode */
1441 u_int32_t tcps_mptcp_interactive_attempt; /* Total number of MPTCP-attempts using interactive mode */
1442 u_int32_t tcps_mptcp_aggregate_attempt; /* Total number of MPTCP-attempts using aggregate mode */
1443 u_int32_t tcps_mptcp_fp_handover_attempt; /* Same as previous three but only for first-party apps */
1444 u_int32_t tcps_mptcp_fp_interactive_attempt;
1445 u_int32_t tcps_mptcp_fp_aggregate_attempt;
1446 u_int32_t tcps_mptcp_heuristic_fallback; /* Total number of MPTCP-connections that fell back due to heuristics */
1447 u_int32_t tcps_mptcp_fp_heuristic_fallback; /* Same as previous but for first-party apps */
1448 u_int32_t tcps_mptcp_handover_success_wifi; /* Total number of successfull handover-mode connections that *started* on WiFi */
1449 u_int32_t tcps_mptcp_handover_success_cell; /* Total number of successfull handover-mode connections that *started* on Cell */
1450 u_int32_t tcps_mptcp_interactive_success; /* Total number of interactive-mode connections that negotiated MPTCP */
1451 u_int32_t tcps_mptcp_aggregate_success; /* Same as previous but for aggregate */
1452 u_int32_t tcps_mptcp_fp_handover_success_wifi; /* Same as previous four, but for first-party apps */
1453 u_int32_t tcps_mptcp_fp_handover_success_cell;
1454 u_int32_t tcps_mptcp_fp_interactive_success;
1455 u_int32_t tcps_mptcp_fp_aggregate_success;
1456 u_int32_t tcps_mptcp_handover_cell_from_wifi; /* Total number of connections that use cell in handover-mode (coming from WiFi) */
1457 u_int32_t tcps_mptcp_handover_wifi_from_cell; /* Total number of connections that use WiFi in handover-mode (coming from cell) */
1458 u_int32_t tcps_mptcp_interactive_cell_from_wifi; /* Total number of connections that use cell in interactive mode (coming from WiFi) */
1459 u_int64_t tcps_mptcp_handover_cell_bytes; /* Total number of bytes sent on cell in handover-mode (on new subflows, ignoring initial one) */
1460 u_int64_t tcps_mptcp_interactive_cell_bytes; /* Same as previous but for interactive */
1461 u_int64_t tcps_mptcp_aggregate_cell_bytes;
1462 u_int64_t tcps_mptcp_handover_all_bytes; /* Total number of bytes sent in handover */
1463 u_int64_t tcps_mptcp_interactive_all_bytes;
1464 u_int64_t tcps_mptcp_aggregate_all_bytes;
1465 u_int32_t tcps_mptcp_back_to_wifi; /* Total number of connections that succeed to move traffic away from cell (when starting on cell) */
1466 u_int32_t tcps_mptcp_wifi_proxy; /* Total number of new subflows that fell back to regular TCP on cell */
1467 u_int32_t tcps_mptcp_cell_proxy; /* Total number of new subflows that fell back to regular TCP on WiFi */
1468
1469 /* TCP offload statistics */
1470 u_int32_t tcps_ka_offload_drops; /* Keep alive drops for timeout reported by firmware */
1471
1472 u_int32_t tcps_mptcp_triggered_cell; /* Total number of times an MPTCP-connection triggered cell bringup */
1473
1474 u_int32_t tcps_fin_timeout_drops;
1475 };
1476
1477
1478 struct tcpstat_local {
1479 u_int64_t badformat;
1480 u_int64_t unspecv6;
1481 u_int64_t synfin;
1482 u_int64_t badformatipsec;
1483 u_int64_t noconnnolist;
1484 u_int64_t noconnlist;
1485 u_int64_t listbadsyn;
1486 u_int64_t icmp6unreach;
1487 u_int64_t deprecate6;
1488 u_int64_t ooopacket;
1489 u_int64_t rstinsynrcv;
1490 u_int64_t dospacket;
1491 u_int64_t cleanup;
1492 u_int64_t synwindow;
1493 u_int64_t linkheur_stealthdrop;
1494 u_int64_t linkheur_noackpri;
1495 u_int64_t linkheur_comprxmt;
1496 u_int64_t linkheur_synrxmt;
1497 u_int64_t linkheur_rxmtfloor;
1498 };
1499
1500 #pragma pack(4)
1501
1502 /*
1503 * TCB structure exported to user-land via sysctl(3).
1504 * Evil hack: declare only if in_pcb.h and sys/socketvar.h have been
1505 * included. Not all of our clients do.
1506 */
1507
1508 struct xtcpcb {
1509 u_int32_t xt_len;
1510 #ifdef KERNEL_PRIVATE
1511 struct inpcb_compat xt_inp;
1512 #else
1513 struct inpcb xt_inp;
1514 #endif
1515 #ifdef KERNEL_PRIVATE
1516 struct otcpcb xt_tp;
1517 #else
1518 struct tcpcb xt_tp;
1519 #endif
1520 struct xsocket xt_socket;
1521 u_quad_t xt_alignment_hack;
1522 };
1523
1524 #if XNU_TARGET_OS_OSX || KERNEL || !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
1525
1526 struct xtcpcb64 {
1527 u_int32_t xt_len;
1528 struct xinpcb64 xt_inpcb;
1529
1530 u_int64_t t_segq;
1531 int t_dupacks; /* consecutive dup acks recd */
1532
1533 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1534
1535 int t_state; /* state of this connection */
1536 u_int t_flags;
1537
1538 int t_force; /* 1 if forcing out a byte */
1539
1540 tcp_seq snd_una; /* send unacknowledged */
1541 tcp_seq snd_max; /* highest sequence number sent;
1542 * used to recognize retransmits
1543 */
1544 tcp_seq snd_nxt; /* send next */
1545 tcp_seq snd_up; /* send urgent pointer */
1546
1547 tcp_seq snd_wl1; /* window update seg seq number */
1548 tcp_seq snd_wl2; /* window update seg ack number */
1549 tcp_seq iss; /* initial send sequence number */
1550 tcp_seq irs; /* initial receive sequence number */
1551
1552 tcp_seq rcv_nxt; /* receive next */
1553 tcp_seq rcv_adv; /* advertised window */
1554 u_int32_t rcv_wnd; /* receive window */
1555 tcp_seq rcv_up; /* receive urgent pointer */
1556
1557 u_int32_t snd_wnd; /* send window */
1558 u_int32_t snd_cwnd; /* congestion-controlled window */
1559 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1560 * for slow start exponential to
1561 * linear switch
1562 */
1563 u_int t_maxopd; /* mss plus options */
1564
1565 u_int32_t t_rcvtime; /* time at which a packet was received */
1566 u_int32_t t_starttime; /* time connection was established */
1567 int t_rtttime; /* round trip time */
1568 tcp_seq t_rtseq; /* sequence number being timed */
1569
1570 int t_rxtcur; /* current retransmit value (ticks) */
1571 u_int t_maxseg; /* maximum segment size */
1572 int t_srtt; /* smoothed round-trip time */
1573 int t_rttvar; /* variance in round-trip time */
1574
1575 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1576 u_int t_rttmin; /* minimum rtt allowed */
1577 u_int32_t t_rttupdated; /* number of times rtt sampled */
1578 u_int32_t max_sndwnd; /* largest window peer has offered */
1579
1580 int t_softerror; /* possible error not yet reported */
1581 /* out-of-band data */
1582 char t_oobflags; /* have some */
1583 char t_iobc; /* input character */
1584 /* RFC 1323 variables */
1585 u_char snd_scale; /* window scaling for send window */
1586 u_char rcv_scale; /* window scaling for recv window */
1587 u_char request_r_scale; /* pending window scaling */
1588 u_char requested_s_scale;
1589 u_int32_t ts_recent; /* timestamp echo data */
1590
1591 u_int32_t ts_recent_age; /* when last updated */
1592 tcp_seq last_ack_sent;
1593 /* RFC 1644 variables */
1594 tcp_cc cc_send; /* send connection count */
1595 tcp_cc cc_recv; /* receive connection count */
1596 tcp_seq snd_recover; /* for use in fast recovery */
1597 /* experimental */
1598 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1599 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1600 u_int32_t t_badrxtwin; /* window for retransmit recovery */
1601
1602 u_quad_t xt_alignment_hack;
1603 };
1604
1605 #endif /* XNU_TARGET_OS_OSX || KERNEL || !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR) */
1606
1607 #ifdef PRIVATE
1608
1609 struct xtcpcb_n {
1610 u_int32_t xt_len;
1611 u_int32_t xt_kind; /* XSO_TCPCB */
1612
1613 u_int64_t t_segq;
1614 int t_dupacks; /* consecutive dup acks recd */
1615
1616 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1617
1618 int t_state; /* state of this connection */
1619 u_int t_flags;
1620
1621 int t_force; /* 1 if forcing out a byte */
1622
1623 tcp_seq snd_una; /* send unacknowledged */
1624 tcp_seq snd_max; /* highest sequence number sent;
1625 * used to recognize retransmits
1626 */
1627 tcp_seq snd_nxt; /* send next */
1628 tcp_seq snd_up; /* send urgent pointer */
1629
1630 tcp_seq snd_wl1; /* window update seg seq number */
1631 tcp_seq snd_wl2; /* window update seg ack number */
1632 tcp_seq iss; /* initial send sequence number */
1633 tcp_seq irs; /* initial receive sequence number */
1634
1635 tcp_seq rcv_nxt; /* receive next */
1636 tcp_seq rcv_adv; /* advertised window */
1637 u_int32_t rcv_wnd; /* receive window */
1638 tcp_seq rcv_up; /* receive urgent pointer */
1639
1640 u_int32_t snd_wnd; /* send window */
1641 u_int32_t snd_cwnd; /* congestion-controlled window */
1642 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1643 * for slow start exponential to
1644 * linear switch
1645 */
1646 u_int t_maxopd; /* mss plus options */
1647
1648 u_int32_t t_rcvtime; /* time at which a packet was received */
1649 u_int32_t t_starttime; /* time connection was established */
1650 int t_rtttime; /* round trip time */
1651 tcp_seq t_rtseq; /* sequence number being timed */
1652
1653 int t_rxtcur; /* current retransmit value (ticks) */
1654 u_int t_maxseg; /* maximum segment size */
1655 int t_srtt; /* smoothed round-trip time */
1656 int t_rttvar; /* variance in round-trip time */
1657
1658 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1659 u_int t_rttmin; /* minimum rtt allowed */
1660 u_int32_t t_rttupdated; /* number of times rtt sampled */
1661 u_int32_t max_sndwnd; /* largest window peer has offered */
1662
1663 int t_softerror; /* possible error not yet reported */
1664 /* out-of-band data */
1665 char t_oobflags; /* have some */
1666 char t_iobc; /* input character */
1667 /* RFC 1323 variables */
1668 u_char snd_scale; /* window scaling for send window */
1669 u_char rcv_scale; /* window scaling for recv window */
1670 u_char request_r_scale; /* pending window scaling */
1671 u_char requested_s_scale;
1672 u_int32_t ts_recent; /* timestamp echo data */
1673
1674 u_int32_t ts_recent_age; /* when last updated */
1675 tcp_seq last_ack_sent;
1676 /* RFC 1644 variables */
1677 tcp_cc cc_send; /* send connection count */
1678 tcp_cc cc_recv; /* receive connection count */
1679 tcp_seq snd_recover; /* for use in fast recovery */
1680 /* experimental */
1681 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1682 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1683 };
1684
1685 /*
1686 * The rtt measured is in milliseconds as the timestamp granularity is
1687 * a millisecond. The smoothed round-trip time and estimated variance
1688 * are stored as fixed point numbers scaled by the values below.
1689 * For convenience, these scales are also used in smoothing the average
1690 * (smoothed = (1/scale)sample + ((scale-1)/scale)smoothed).
1691 * With these scales, srtt has 5 bits to the right of the binary point,
1692 * and thus an "ALPHA" of 0.875. rttvar has 4 bits to the right of the
1693 * binary point, and is smoothed with an ALPHA of 0.75.
1694 */
1695 #define TCP_RTT_SCALE 32 /* multiplier for srtt; 3 bits frac. */
1696 #define TCP_RTT_SHIFT 5 /* shift for srtt; 5 bits frac. */
1697 #define TCP_RTTVAR_SCALE 16 /* multiplier for rttvar; 4 bits */
1698 #define TCP_RTTVAR_SHIFT 4 /* shift for rttvar; 4 bits */
1699 #define TCP_DELTA_SHIFT 2 /* see tcp_input.c */
1700
1701 struct tcpprobereq {
1702 u_int64_t ifindex; /* Optional interface index for TCP keep-alive probing */
1703 u_int64_t enable; /* Flag to enable or disable probing (1=on, 0=off)*/
1704 u_int64_t filter_flags; /* Optional flags for filtering interfaces per ntstat.h (NSTAT_IFNET_IS_*) */
1705 u_int32_t reserved; /* Expansion */
1706 u_int32_t reserved2; /* Expansion */
1707 };
1708
1709 #endif /* PRIVATE */
1710
1711 #pragma pack()
1712
1713 /*
1714 * Names for TCP sysctl objects
1715 */
1716 #define TCPCTL_DO_RFC1323 1 /* use RFC-1323 extensions */
1717 #define TCPCTL_DO_RFC1644 2 /* use RFC-1644 extensions */
1718 #define TCPCTL_MSSDFLT 3 /* MSS default */
1719 #define TCPCTL_STATS 4 /* statistics (read-only) */
1720 #define TCPCTL_RTTDFLT 5 /* default RTT estimate */
1721 #define TCPCTL_KEEPIDLE 6 /* keepalive idle timer */
1722 #define TCPCTL_KEEPINTVL 7 /* interval to send keepalives */
1723 #define TCPCTL_SENDSPACE 8 /* send buffer space */
1724 #define TCPCTL_RECVSPACE 9 /* receive buffer space */
1725 #define TCPCTL_KEEPINIT 10 /* timeout for establishing syn */
1726 #define TCPCTL_PCBLIST 11 /* list of all outstanding PCBs */
1727 #define TCPCTL_DELACKTIME 12 /* time before sending delayed ACK */
1728 #define TCPCTL_V6MSSDFLT 13 /* MSS default for IPv6 */
1729 #define TCPCTL_MAXID 14
1730
1731 #ifdef BSD_KERNEL_PRIVATE
1732 #include <sys/bitstring.h>
1733
1734 #define TCP_PKTLIST_CLEAR(tp) { \
1735 (tp)->t_pktlist_head = (tp)->t_pktlist_tail = NULL; \
1736 (tp)->t_lastchain = (tp)->t_pktlist_sentlen = 0; \
1737 }
1738
1739 extern int tcp_TCPTV_MIN;
1740
1741 #ifdef SYSCTL_DECL
1742 SYSCTL_DECL(_net_inet_tcp);
1743 #endif /* SYSCTL_DECL */
1744
1745 extern struct inpcbhead tcb; /* head of queue of active tcpcb's */
1746 extern struct inpcbinfo tcbinfo;
1747 extern struct tcpstat tcpstat; /* tcp statistics */
1748 extern int tcp_mssdflt; /* XXX */
1749 extern int tcp_minmss;
1750 #define TCP_FASTOPEN_SERVER 0x01
1751 #define TCP_FASTOPEN_CLIENT 0x02
1752
1753 extern int tcp_tfo_halfcnt;
1754 extern int tcp_tfo_backlog;
1755 extern int tcp_fastopen;
1756 extern int ss_fltsz_local;
1757 extern int target_qdelay;
1758 extern uint32_t tcp_now; /* for RFC 1323 timestamps */
1759 extern struct timeval tcp_uptime;
1760 extern lck_spin_t tcp_uptime_lock;
1761 extern int tcp_delack_enabled;
1762 extern int maxseg_unacked;
1763 extern int tcp_ecn_outbound;
1764 extern int tcp_ecn_inbound;
1765 extern uint32_t tcp_do_autorcvbuf;
1766 extern uint32_t tcp_autorcvbuf_max;
1767 extern int tcp_recv_bg;
1768 extern int tcp_do_ack_compression;
1769 extern int tcp_randomize_timestamps;
1770 extern int tcp_rledbat;
1771 extern int tcp_use_min_curr_rtt;
1772 extern int tcp_do_timestamps;
1773
1774 /*
1775 * Feature flags for LQM heuristics
1776 * Can be useful for testing
1777 */
1778 #define TCP_LINK_HEUR_RXMT_COMP 0x0001
1779 #define TCP_LINK_HEUR_NOACKPRI 0x0002
1780 #define TCP_LINK_HEUR_SYNRMXT 0x0004
1781 #define TCP_LINK_HEUR_STEALTH 0x0008
1782 #define TCP_LINK_HEUR_RTOMIN 0x0010
1783 #define TCP_LINK_HEUR_NOTLP 0x0020
1784
1785 #define TCP_LINK_HEURISTICS_DEFAULT (\
1786 TCP_LINK_HEUR_RXMT_COMP | \
1787 TCP_LINK_HEUR_NOACKPRI | \
1788 TCP_LINK_HEUR_SYNRMXT | \
1789 TCP_LINK_HEUR_STEALTH | \
1790 TCP_LINK_HEUR_RTOMIN | \
1791 TCP_LINK_HEUR_NOTLP)
1792
1793 extern int32_t tcp_link_heuristics_flags;
1794 extern int32_t tcp_link_heuristics_rto_min;
1795
1796 #define TCP_COMP_RXMT_GENCNT_MASK 0x80000000
1797
1798 /* 3 seconds is conservative value (see RFC 2988 and RFC 6298) */
1799 #define TCP_DEFAULT_LINK_HEUR_RTOMIN 3000
1800
1801 /*
1802 * Dummy value used for when there is no flow and we want to ensure that compression
1803 * can happen.
1804 */
1805 #define TCP_ACK_COMPRESSION_DUMMY 1
1806
1807 KALLOC_TYPE_DECLARE(tcp_reass_zone);
1808 extern struct tseg_qent * tcp_reass_qent_alloc(void);
1809 extern void tcp_reass_qent_free(struct tseg_qent *te);
1810
1811 KALLOC_TYPE_DECLARE(tcp_rxt_seg_zone);
1812 extern struct tcp_rxt_seg * tcp_rxt_seg_qent_alloc(void);
1813 extern void tcp_rxt_seg_qent_free(struct tcp_rxt_seg *te);
1814
1815 KALLOC_TYPE_DECLARE(tcp_seg_sent_zone);
1816 extern struct tcp_seg_sent * tcp_seg_sent_qent_alloc(void);
1817 extern void tcp_seg_sent_qent_free(struct tcp_seg_sent *te);
1818
1819
1820 extern int tcp_do_better_lr;
1821 extern int tcp_cubic_minor_fixes;
1822 extern int tcp_cubic_rfc_compliant;
1823 extern int tcp_flow_control_response;
1824
1825 extern int tcp_rack;
1826
1827 extern int tcp_reass_total_qlen;
1828
1829 struct protosw;
1830 struct domain;
1831
1832 struct tcp_respond_args {
1833 unsigned int ifscope;
1834 unsigned int nocell:1,
1835 noexpensive:1,
1836 awdl_unrestricted:1,
1837 intcoproc_allowed:1,
1838 keep_alive:1,
1839 noconstrained:1,
1840 management_allowed:1,
1841 ultra_constrained_allowed:1;
1842 };
1843
1844 void tcp_canceltimers(struct tcpcb *);
1845 struct tcpcb *
1846 tcp_close(struct tcpcb *);
1847 void tcp_ctlinput(int, struct sockaddr *, void *, struct ifnet *);
1848 int tcp_ctloutput(struct socket *, struct sockopt *);
1849 struct tcpcb *
1850 tcp_drop(struct tcpcb *, int);
1851 void tcp_drain(void);
1852 void tcp_getrt_rtt(struct tcpcb *tp, struct rtentry *rt);
1853 void tcp_init(struct protosw *, struct domain *);
1854 void tcp_input(struct mbuf *, int);
1855 void tcp_mss(struct tcpcb *, int, unsigned int);
1856 uint32_t tcp_ceil(double a);
1857 uint32_t tcp_round_to(uint32_t val, uint32_t round);
1858 uint32_t tcp_round_up(uint32_t val, uint32_t base);
1859 uint32_t ntoh24(u_char * p __sized_by(3));
1860 uint32_t tcp_packets_this_ack(struct tcpcb *tp, uint32_t acked);
1861 int tcp_mssopt(struct tcpcb *);
1862 void tcp_drop_syn_sent(struct inpcb *, int);
1863 uint32_t tcp_get_effective_mtu(struct rtentry *, uint32_t);
1864 void tcp_mtudisc(struct inpcb *, int);
1865 struct tcpcb *
1866 tcp_newtcpcb(struct inpcb *);
1867 int tcp_output(struct tcpcb *);
1868 void tcp_respond(struct tcpcb *, void *ipgen __sized_by(ipgen_size), size_t ipgen_size, struct tcphdr *, struct mbuf *,
1869 tcp_seq, tcp_seq, uint8_t, struct tcp_respond_args *);
1870 struct rtentry *
1871 tcp_rtlookup(struct inpcb *, unsigned int);
1872 void tcp_setpersist(struct tcpcb *);
1873 void tcp_gc(struct inpcbinfo *);
1874 void tcp_itimer(struct inpcbinfo *ipi);
1875 void tcp_check_timer_state(struct tcpcb *tp);
1876 void tcp_run_timerlist(void *arg1, void *arg2);
1877 void tcp_sched_timers(struct tcpcb *tp);
1878
1879 struct tcptemp *tcp_maketemplate(struct tcpcb *, struct mbuf **);
1880 void tcp_fillheaders(struct mbuf *, struct tcpcb *, void *, void *);
1881 struct tcpcb *tcp_timers(struct tcpcb *, int);
1882 void tcp_trace(int, int, struct tcpcb *, void *, struct tcphdr *, int);
1883
1884 void tcp_fill_info(struct tcpcb *, struct tcp_info *);
1885 void tcp_sack_doack(struct tcpcb *, struct tcpopt *, struct tcphdr *,
1886 uint32_t *, uint32_t *);
1887 extern boolean_t tcp_sack_process_dsack(struct tcpcb *, struct tcpopt *,
1888 struct tcphdr *, boolean_t *);
1889 int tcp_detect_bad_rexmt(struct tcpcb *, struct tcphdr *, struct tcpopt *,
1890 u_int32_t rxtime);
1891 void tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_laststart, tcp_seq rcv_lastend);
1892 void tcp_clean_sackreport(struct tcpcb *tp);
1893 uint32_t tcp_sack_adjust(struct tcpcb *tp);
1894 struct sackhole *tcp_sack_output(struct tcpcb *tp, int *sack_bytes_rexmt);
1895 void tcp_sack_partialack(struct tcpcb *, struct tcphdr *);
1896 void tcp_free_sackholes(struct tcpcb *tp);
1897 int32_t tcp_sbspace(struct tcpcb *tp);
1898 void tcp_set_tso(struct tcpcb *tp, struct ifnet *ifp);
1899 void tcp_set_ecn(struct tcpcb *tp, struct ifnet *ifp);
1900 uint8_t tcp_get_ace(struct tcphdr *th);
1901 uint32_t tcp_flight_size(struct tcpcb *tp);
1902 void tcp_reset_stretch_ack(struct tcpcb *tp);
1903 extern void tcp_get_ports_used(ifnet_t ifp, int, u_int32_t, bitstr_t *__counted_by(bitstr_size(IP_PORTRANGE_SIZE)));
1904 uint32_t tcp_count_opportunistic(unsigned int ifindex, u_int32_t flags);
1905 uint32_t tcp_find_anypcb_byaddr(struct ifaddr *ifa);
1906 void tcp_set_max_rwinscale(struct tcpcb *tp, struct socket *so);
1907 struct bwmeas* tcp_bwmeas_alloc(struct tcpcb *tp);
1908 void tcp_bwmeas_free(struct tcpcb *tp);
1909 extern int32_t timer_diff(uint32_t t1, uint32_t toff1, uint32_t t2, uint32_t toff2);
1910
1911 /* RACK related functions */
1912 void tcp_rack_transmit_seg(struct tcpcb *tp, struct tcp_seg_sent *seg, tcp_seq start, tcp_seq end, uint32_t xmit_ts, uint8_t flags);
1913 void tcp_rack_update_reordering_window(struct tcpcb *tp, tcp_seq highest_acked_sacked);
1914 void tcp_rack_update_reordering_win_persist(struct tcpcb *tp);
1915 void tcp_rack_bad_rexmt_restore(struct tcpcb *tp);
1916 void tcp_rack_reset_segs_retransmitted(struct tcpcb *tp);
1917 void tcp_rack_update_segment_acked(struct tcpcb *tp, uint32_t tsecr, uint32_t xmit_ts, uint32_t end_seq, bool retransmitted);
1918 bool tcp_rack_detect_loss_and_arm_timer(struct tcpcb *tp, uint32_t dup_acks);
1919 void tcp_rack_reordering_timeout(struct tcpcb *tp, uint32_t dup_acks);
1920 struct tcp_seg_sent * tcp_rack_output(struct tcpcb *tp, uint32_t cwin, uint16_t *rack_seg_len);
1921 void tcp_rack_loss_on_rto(struct tcpcb *tp, bool in_rto);
1922 uint32_t tcp_rack_adjust(struct tcpcb *tp, uint32_t cwin);
1923 void tcp_rack_detect_reordering_dsack(struct tcpcb *tp, tcp_seq start, tcp_seq end);
1924 void tcp_rack_detect_reordering_acked(struct tcpcb *tp, struct tcp_seg_sent *seg);
1925 /* RACK segment related functions */
1926 uint32_t tcp_seg_len(struct tcp_seg_sent *seg);
1927 void tcp_seg_sent_insert(struct tcpcb *tp, struct tcp_seg_sent *seg, tcp_seq start, tcp_seq end, uint32_t xmit_ts, uint8_t flags);
1928 void tcp_segs_doack(struct tcpcb *tp, tcp_seq th_ack, struct tcpopt *to);
1929 void tcp_segs_dosack(struct tcpcb *tp, tcp_seq sblk_start, tcp_seq sblk_end, uint32_t tsecr, uint32_t *newbytes_sacked);
1930 void tcp_segs_clear_sacked(struct tcpcb *tp);
1931 void tcp_mark_seg_lost(struct tcpcb *tp, struct tcp_seg_sent *seg);
1932 void tcp_seg_delete(struct tcpcb *tp, struct tcp_seg_sent *seg);
1933 void tcp_segs_sent_clean(struct tcpcb *tp, bool free_segs);
1934
1935 extern void tcp_set_background_cc(struct socket *);
1936 extern void tcp_set_foreground_cc(struct socket *);
1937 extern void tcp_set_recv_bg(struct socket *);
1938 extern void tcp_clear_recv_bg(struct socket *);
1939 extern boolean_t tcp_sack_byte_islost(struct tcpcb *tp);
1940 #define IS_TCP_RECV_BG(_so) \
1941 ((_so)->so_flags1 & SOF1_TRAFFIC_MGT_TCP_RECVBG)
1942
1943 #if TRAFFIC_MGT
1944 #define CLEAR_IAJ_STATE(_tp_) (_tp_)->iaj_rcv_ts = 0
1945 void reset_acc_iaj(struct tcpcb *tp);
1946 #endif /* TRAFFIC_MGT */
1947
1948 int tcp_lock(struct socket *, int, void *);
1949 int tcp_unlock(struct socket *, int, void *);
1950 void calculate_tcp_clock(void);
1951 uint64_t microuptime_ns(void);
1952 uint64_t tcp_pacer_get_packet_tx_time(struct tcpcb *tp, uint16_t pkt_len);
1953 void tcp_set_mbuf_tx_time(struct mbuf *m, uint64_t tx_time);
1954
1955 extern void tcp_keepalive_reset(struct tcpcb *);
1956 extern uint32_t get_base_rtt(struct tcpcb *tp);
1957
1958 #ifdef _KERN_LOCKS_H_
1959 lck_mtx_t * tcp_getlock(struct socket *, int);
1960 #else
1961 void * tcp_getlock(struct socket *, int);
1962 #endif
1963
1964 extern struct pr_usrreqs tcp_usrreqs;
1965 extern uint32_t tcp_sendspace;
1966 extern uint32_t tcp_recvspace;
1967 extern tcp_seq tcp_new_isn(struct tcpcb *tp);
1968
1969 extern int tcp_input_checksum(int, struct mbuf *, struct tcphdr *, int, int);
1970 extern void tcp_getconninfo(struct socket *, struct conninfo_tcp *);
1971 extern void add_to_time_wait(struct tcpcb *, uint32_t delay);
1972 extern void add_to_time_wait_now(struct tcpcb *tp, uint32_t delay);
1973 extern void tcp_pmtud_revert_segment_size(struct tcpcb *tp);
1974 extern void tcp_rxtseg_insert(struct tcpcb *, tcp_seq, tcp_seq);
1975 extern struct tcp_rxt_seg *tcp_rxtseg_find(struct tcpcb *, tcp_seq, tcp_seq);
1976 extern void tcp_rxtseg_set_spurious(struct tcpcb *tp, tcp_seq start, tcp_seq end);
1977 extern void tcp_rxtseg_clean(struct tcpcb *);
1978 extern boolean_t tcp_rxtseg_detect_bad_rexmt(struct tcpcb *, tcp_seq);
1979 extern boolean_t tcp_rxtseg_dsack_for_tlp(struct tcpcb *);
1980 extern u_int32_t tcp_rxtseg_total_size(struct tcpcb *tp);
1981 extern void tcp_rexmt_save_state(struct tcpcb *tp);
1982 void tcp_enter_fast_recovery(struct tcpcb *tp);
1983 extern void tcp_interface_send_probe(u_int16_t if_index_available);
1984 extern void tcp_probe_connectivity(struct ifnet *ifp, u_int32_t enable);
1985 extern void tcp_get_connectivity_status(struct tcpcb *,
1986 struct tcp_conn_status *);
1987
1988 extern void tcp_clear_keep_alive_offload(struct socket *so);
1989 extern void tcp_fill_keepalive_offload_frames(struct ifnet *,
1990 struct ifnet_keepalive_offload_frame * frames_array __counted_by(frames_array_count), u_int32_t frames_array_count, size_t, u_int32_t *);
1991 extern int tcp_notify_kao_timeout(ifnet_t ifp,
1992 struct ifnet_keepalive_offload_frame *frame);
1993
1994 extern void tcp_disable_tfo(struct tcpcb *tp);
1995 extern void tcp_tfo_gen_cookie(struct inpcb *inp, u_char *out __sized_by(blk_size), size_t blk_size);
1996 #define TCP_FASTOPEN_KEYLEN 16
1997 extern int tcp_freeq(struct tcpcb *tp);
1998 extern errno_t tcp_notify_ack_id_valid(struct tcpcb *, struct socket *, u_int32_t);
1999 extern errno_t tcp_add_notify_ack_marker(struct tcpcb *, u_int32_t);
2000 extern void tcp_notify_ack_free(struct tcpcb *);
2001 extern void tcp_notify_acknowledgement(struct tcpcb *, struct socket *);
2002 extern void tcp_get_notify_ack_count(struct tcpcb *,
2003 struct tcp_notify_ack_complete *);
2004 extern void tcp_get_notify_ack_ids(struct tcpcb *tp,
2005 struct tcp_notify_ack_complete *);
2006 extern void tcp_update_mss_locked(struct socket *, struct ifnet *);
2007
2008 extern int get_tcp_inp_list(struct inpcb * __single * __counted_by(n), size_t n, inp_gen_t);
2009 extern bool tcp_notify_ack_active(struct socket *so);
2010 extern void tcp_set_finwait_timeout(struct tcpcb *);
2011
2012 #if MPTCP
2013 extern uint16_t mptcp_output_csum(struct mbuf *m, uint64_t dss_val,
2014 uint32_t sseq, uint16_t dlen);
2015 extern int mptcp_adj_mss(struct tcpcb *, boolean_t);
2016 extern void mptcp_insert_rmap(struct tcpcb *tp, struct mbuf *m, struct tcphdr *th);
2017 extern int dump_mptcp_reass_qlen(char * __sized_by(str_len), int str_len);
2018 #endif
2019
2020 extern int dump_tcp_reass_qlen(char * str __sized_by(str_len), int str_len);
2021 extern uint32_t tcp_reass_qlen_space(struct socket *);
2022
2023 __private_extern__ void tcp_update_stats_per_flow(
2024 struct ifnet_stats_per_flow *, struct ifnet *);
2025
2026 extern void tcp_set_link_heur_rtomin(struct tcpcb *tp, ifnet_t ifp);
2027
2028 #define TCP_ACK_STRATEGY_LEGACY 0
2029 #define TCP_ACK_STRATEGY_MODERN 1
2030
2031 extern int tcp_ack_strategy;
2032
2033 #if SKYWALK
2034 void tcp_add_fsw_flow(struct tcpcb *, struct ifnet *);
2035 void tcp_del_fsw_flow(struct tcpcb *);
2036 #else /* !SKYWALK */
2037 #define tcp_add_fsw_flow(...)
2038 #define tcp_del_fsw_flow(...)
2039 #endif /* !SKYWALK */
2040
2041 typedef void *__single lr_ref_t;
2042 #define TCP_INIT_LR_SAVED(lr) ((lr) == NULL \
2043 ? __unsafe_forge_single(void *, __builtin_return_address(0)) \
2044 : (lr))
2045
2046 #endif /* BSD_KERNEL_PRIVATE */
2047
2048 #endif /* _NETINET_TCP_VAR_H_ */
2049