Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 : : /* 3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX 4 : : * operating system. INET is implemented using the BSD Socket 5 : : * interface as the means of communication with the user level. 6 : : * 7 : : * Definitions for the TCP protocol. 8 : : * 9 : : * Version: @(#)tcp.h 1.0.2 04/28/93 10 : : * 11 : : * Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 : : */ 13 : : #ifndef _LINUX_TCP_H 14 : : #define _LINUX_TCP_H 15 : : 16 : : 17 : : #include <linux/skbuff.h> 18 : : #include <linux/win_minmax.h> 19 : : #include <net/sock.h> 20 : : #include <net/inet_connection_sock.h> 21 : : #include <net/inet_timewait_sock.h> 22 : : #include <uapi/linux/tcp.h> 23 : : 24 : : static inline struct tcphdr *tcp_hdr(const struct sk_buff *skb) 25 : : { 26 : : return (struct tcphdr *)skb_transport_header(skb); 27 : : } 28 : : 29 : : static inline unsigned int __tcp_hdrlen(const struct tcphdr *th) 30 : : { 31 : 3 : return th->doff * 4; 32 : : } 33 : : 34 : : static inline unsigned int tcp_hdrlen(const struct sk_buff *skb) 35 : : { 36 : : return __tcp_hdrlen(tcp_hdr(skb)); 37 : : } 38 : : 39 : : static inline struct tcphdr *inner_tcp_hdr(const struct sk_buff *skb) 40 : : { 41 : : return (struct tcphdr *)skb_inner_transport_header(skb); 42 : : } 43 : : 44 : : static inline unsigned int inner_tcp_hdrlen(const struct sk_buff *skb) 45 : : { 46 : 0 : return inner_tcp_hdr(skb)->doff * 4; 47 : : } 48 : : 49 : : static inline unsigned int tcp_optlen(const struct sk_buff *skb) 50 : : { 51 : : return (tcp_hdr(skb)->doff - 5) * 4; 52 : : } 53 : : 54 : : /* TCP Fast Open */ 55 : : #define TCP_FASTOPEN_COOKIE_MIN 4 /* Min Fast Open Cookie size in bytes */ 56 : : #define TCP_FASTOPEN_COOKIE_MAX 16 /* Max Fast Open Cookie size in bytes */ 57 : : #define TCP_FASTOPEN_COOKIE_SIZE 8 /* the size employed by this impl. */ 58 : : 59 : : /* TCP Fast Open Cookie as stored in memory */ 60 : : struct tcp_fastopen_cookie { 61 : : __le64 val[DIV_ROUND_UP(TCP_FASTOPEN_COOKIE_MAX, sizeof(u64))]; 62 : : s8 len; 63 : : bool exp; /* In RFC6994 experimental option format */ 64 : : }; 65 : : 66 : : /* This defines a selective acknowledgement block. */ 67 : : struct tcp_sack_block_wire { 68 : : __be32 start_seq; 69 : : __be32 end_seq; 70 : : }; 71 : : 72 : : struct tcp_sack_block { 73 : : u32 start_seq; 74 : : u32 end_seq; 75 : : }; 76 : : 77 : : /*These are used to set the sack_ok field in struct tcp_options_received */ 78 : : #define TCP_SACK_SEEN (1 << 0) /*1 = peer is SACK capable, */ 79 : : #define TCP_DSACK_SEEN (1 << 2) /*1 = DSACK was received from peer*/ 80 : : 81 : : struct tcp_options_received { 82 : : /* PAWS/RTTM data */ 83 : : int ts_recent_stamp;/* Time we stored ts_recent (for aging) */ 84 : : u32 ts_recent; /* Time stamp to echo next */ 85 : : u32 rcv_tsval; /* Time stamp value */ 86 : : u32 rcv_tsecr; /* Time stamp echo reply */ 87 : : u16 saw_tstamp : 1, /* Saw TIMESTAMP on last packet */ 88 : : tstamp_ok : 1, /* TIMESTAMP seen on SYN packet */ 89 : : dsack : 1, /* D-SACK is scheduled */ 90 : : wscale_ok : 1, /* Wscale seen on SYN packet */ 91 : : sack_ok : 3, /* SACK seen on SYN packet */ 92 : : smc_ok : 1, /* SMC seen on SYN packet */ 93 : : snd_wscale : 4, /* Window scaling received from sender */ 94 : : rcv_wscale : 4; /* Window scaling to send to receiver */ 95 : : u8 num_sacks; /* Number of SACK blocks */ 96 : : u16 user_mss; /* mss requested by user in ioctl */ 97 : : u16 mss_clamp; /* Maximal mss, negotiated at connection setup */ 98 : : }; 99 : : 100 : : static inline void tcp_clear_options(struct tcp_options_received *rx_opt) 101 : : { 102 : 0 : rx_opt->tstamp_ok = rx_opt->sack_ok = 0; 103 : 0 : rx_opt->wscale_ok = rx_opt->snd_wscale = 0; 104 : : #if IS_ENABLED(CONFIG_SMC) 105 : : rx_opt->smc_ok = 0; 106 : : #endif 107 : : } 108 : : 109 : : /* This is the max number of SACKS that we'll generate and process. It's safe 110 : : * to increase this, although since: 111 : : * size = TCPOLEN_SACK_BASE_ALIGNED (4) + n * TCPOLEN_SACK_PERBLOCK (8) 112 : : * only four options will fit in a standard TCP header */ 113 : : #define TCP_NUM_SACKS 4 114 : : 115 : : struct tcp_request_sock_ops; 116 : : 117 : : struct tcp_request_sock { 118 : : struct inet_request_sock req; 119 : : const struct tcp_request_sock_ops *af_specific; 120 : : u64 snt_synack; /* first SYNACK sent time */ 121 : : bool tfo_listener; 122 : : u32 txhash; 123 : : u32 rcv_isn; 124 : : u32 snt_isn; 125 : : u32 ts_off; 126 : : u32 last_oow_ack_time; /* last SYNACK */ 127 : : u32 rcv_nxt; /* the ack # by SYNACK. For 128 : : * FastOpen it's the seq# 129 : : * after data-in-SYN. 130 : : */ 131 : : }; 132 : : 133 : : static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req) 134 : : { 135 : : return (struct tcp_request_sock *)req; 136 : : } 137 : : 138 : : struct tcp_sock { 139 : : /* inet_connection_sock has to be the first member of tcp_sock */ 140 : : struct inet_connection_sock inet_conn; 141 : : u16 tcp_header_len; /* Bytes of tcp header to send */ 142 : : u16 gso_segs; /* Max number of segs per GSO packet */ 143 : : 144 : : /* 145 : : * Header prediction flags 146 : : * 0x5?10 << 16 + snd_wnd in net byte order 147 : : */ 148 : : __be32 pred_flags; 149 : : 150 : : /* 151 : : * RFC793 variables by their proper names. This means you can 152 : : * read the code and the spec side by side (and laugh ...) 153 : : * See RFC793 and RFC1122. The RFC writes these in capitals. 154 : : */ 155 : : u64 bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived 156 : : * sum(delta(rcv_nxt)), or how many bytes 157 : : * were acked. 158 : : */ 159 : : u32 segs_in; /* RFC4898 tcpEStatsPerfSegsIn 160 : : * total number of segments in. 161 : : */ 162 : : u32 data_segs_in; /* RFC4898 tcpEStatsPerfDataSegsIn 163 : : * total number of data segments in. 164 : : */ 165 : : u32 rcv_nxt; /* What we want to receive next */ 166 : : u32 copied_seq; /* Head of yet unread data */ 167 : : u32 rcv_wup; /* rcv_nxt on last window update sent */ 168 : : u32 snd_nxt; /* Next sequence we send */ 169 : : u32 segs_out; /* RFC4898 tcpEStatsPerfSegsOut 170 : : * The total number of segments sent. 171 : : */ 172 : : u32 data_segs_out; /* RFC4898 tcpEStatsPerfDataSegsOut 173 : : * total number of data segments sent. 174 : : */ 175 : : u64 bytes_sent; /* RFC4898 tcpEStatsPerfHCDataOctetsOut 176 : : * total number of data bytes sent. 177 : : */ 178 : : u64 bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked 179 : : * sum(delta(snd_una)), or how many bytes 180 : : * were acked. 181 : : */ 182 : : u32 dsack_dups; /* RFC4898 tcpEStatsStackDSACKDups 183 : : * total number of DSACK blocks received 184 : : */ 185 : : u32 snd_una; /* First byte we want an ack for */ 186 : : u32 snd_sml; /* Last byte of the most recently transmitted small packet */ 187 : : u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */ 188 : : u32 lsndtime; /* timestamp of last sent data packet (for restart window) */ 189 : : u32 last_oow_ack_time; /* timestamp of last out-of-window ACK */ 190 : : u32 compressed_ack_rcv_nxt; 191 : : 192 : : u32 tsoffset; /* timestamp offset */ 193 : : 194 : : struct list_head tsq_node; /* anchor in tsq_tasklet.head list */ 195 : : struct list_head tsorted_sent_queue; /* time-sorted sent but un-SACKed skbs */ 196 : : 197 : : u32 snd_wl1; /* Sequence for window update */ 198 : : u32 snd_wnd; /* The window we expect to receive */ 199 : : u32 max_window; /* Maximal window ever seen from peer */ 200 : : u32 mss_cache; /* Cached effective mss, not including SACKS */ 201 : : 202 : : u32 window_clamp; /* Maximal window to advertise */ 203 : : u32 rcv_ssthresh; /* Current window clamp */ 204 : : 205 : : /* Information of the most recently (s)acked skb */ 206 : : struct tcp_rack { 207 : : u64 mstamp; /* (Re)sent time of the skb */ 208 : : u32 rtt_us; /* Associated RTT */ 209 : : u32 end_seq; /* Ending TCP sequence of the skb */ 210 : : u32 last_delivered; /* tp->delivered at last reo_wnd adj */ 211 : : u8 reo_wnd_steps; /* Allowed reordering window */ 212 : : #define TCP_RACK_RECOVERY_THRESH 16 213 : : u8 reo_wnd_persist:5, /* No. of recovery since last adj */ 214 : : dsack_seen:1, /* Whether DSACK seen after last adj */ 215 : : advanced:1; /* mstamp advanced since last lost marking */ 216 : : } rack; 217 : : u16 advmss; /* Advertised MSS */ 218 : : u8 compressed_ack; 219 : : u8 tlp_retrans:1, /* TLP is a retransmission */ 220 : : unused_1:7; 221 : : u32 chrono_start; /* Start time in jiffies of a TCP chrono */ 222 : : u32 chrono_stat[3]; /* Time in jiffies for chrono_stat stats */ 223 : : u8 chrono_type:2, /* current chronograph type */ 224 : : rate_app_limited:1, /* rate_{delivered,interval_us} limited? */ 225 : : fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */ 226 : : fastopen_no_cookie:1, /* Allow send/recv SYN+data without a cookie */ 227 : : is_sack_reneg:1, /* in recovery from loss with SACK reneg? */ 228 : : unused:2; 229 : : u8 nonagle : 4,/* Disable Nagle algorithm? */ 230 : : thin_lto : 1,/* Use linear timeouts for thin streams */ 231 : : recvmsg_inq : 1,/* Indicate # of bytes in queue upon recvmsg */ 232 : : repair : 1, 233 : : frto : 1;/* F-RTO (RFC5682) activated in CA_Loss */ 234 : : u8 repair_queue; 235 : : u8 syn_data:1, /* SYN includes data */ 236 : : syn_fastopen:1, /* SYN includes Fast Open option */ 237 : : syn_fastopen_exp:1,/* SYN includes Fast Open exp. option */ 238 : : syn_fastopen_ch:1, /* Active TFO re-enabling probe */ 239 : : syn_data_acked:1,/* data in SYN is acked by SYN-ACK */ 240 : : save_syn:1, /* Save headers of SYN packet */ 241 : : is_cwnd_limited:1,/* forward progress limited by snd_cwnd? */ 242 : : syn_smc:1; /* SYN includes SMC */ 243 : : u32 tlp_high_seq; /* snd_nxt at the time of TLP */ 244 : : 245 : : u32 tcp_tx_delay; /* delay (in usec) added to TX packets */ 246 : : u64 tcp_wstamp_ns; /* departure time for next sent data packet */ 247 : : u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */ 248 : : 249 : : /* RTT measurement */ 250 : : u64 tcp_mstamp; /* most recent packet received/sent */ 251 : : u32 srtt_us; /* smoothed round trip time << 3 in usecs */ 252 : : u32 mdev_us; /* medium deviation */ 253 : : u32 mdev_max_us; /* maximal mdev for the last rtt period */ 254 : : u32 rttvar_us; /* smoothed mdev_max */ 255 : : u32 rtt_seq; /* sequence number to update rttvar */ 256 : : struct minmax rtt_min; 257 : : 258 : : u32 packets_out; /* Packets which are "in flight" */ 259 : : u32 retrans_out; /* Retransmitted packets out */ 260 : : u32 max_packets_out; /* max packets_out in last window */ 261 : : u32 max_packets_seq; /* right edge of max_packets_out flight */ 262 : : 263 : : u16 urg_data; /* Saved octet of OOB data and control flags */ 264 : : u8 ecn_flags; /* ECN status bits. */ 265 : : u8 keepalive_probes; /* num of allowed keep alive probes */ 266 : : u32 reordering; /* Packet reordering metric. */ 267 : : u32 reord_seen; /* number of data packet reordering events */ 268 : : u32 snd_up; /* Urgent pointer */ 269 : : 270 : : /* 271 : : * Options received (usually on last packet, some only on SYN packets). 272 : : */ 273 : : struct tcp_options_received rx_opt; 274 : : 275 : : /* 276 : : * Slow start and congestion control (see also Nagle, and Karn & Partridge) 277 : : */ 278 : : u32 snd_ssthresh; /* Slow start size threshold */ 279 : : u32 snd_cwnd; /* Sending congestion window */ 280 : : u32 snd_cwnd_cnt; /* Linear increase counter */ 281 : : u32 snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */ 282 : : u32 snd_cwnd_used; 283 : : u32 snd_cwnd_stamp; 284 : : u32 prior_cwnd; /* cwnd right before starting loss recovery */ 285 : : u32 prr_delivered; /* Number of newly delivered packets to 286 : : * receiver in Recovery. */ 287 : : u32 prr_out; /* Total number of pkts sent during Recovery. */ 288 : : u32 delivered; /* Total data packets delivered incl. rexmits */ 289 : : u32 delivered_ce; /* Like the above but only ECE marked packets */ 290 : : u32 lost; /* Total data packets lost incl. rexmits */ 291 : : u32 app_limited; /* limited until "delivered" reaches this val */ 292 : : u64 first_tx_mstamp; /* start of window send phase */ 293 : : u64 delivered_mstamp; /* time we reached "delivered" */ 294 : : u32 rate_delivered; /* saved rate sample: packets delivered */ 295 : : u32 rate_interval_us; /* saved rate sample: time elapsed */ 296 : : 297 : : u32 rcv_wnd; /* Current receiver window */ 298 : : u32 write_seq; /* Tail(+1) of data held in tcp send buffer */ 299 : : u32 notsent_lowat; /* TCP_NOTSENT_LOWAT */ 300 : : u32 pushed_seq; /* Last pushed seq, required to talk to windows */ 301 : : u32 lost_out; /* Lost packets */ 302 : : u32 sacked_out; /* SACK'd packets */ 303 : : 304 : : struct hrtimer pacing_timer; 305 : : struct hrtimer compressed_ack_timer; 306 : : 307 : : /* from STCP, retrans queue hinting */ 308 : : struct sk_buff* lost_skb_hint; 309 : : struct sk_buff *retransmit_skb_hint; 310 : : 311 : : /* OOO segments go in this rbtree. Socket lock must be held. */ 312 : : struct rb_root out_of_order_queue; 313 : : struct sk_buff *ooo_last_skb; /* cache rb_last(out_of_order_queue) */ 314 : : 315 : : /* SACKs data, these 2 need to be together (see tcp_options_write) */ 316 : : struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */ 317 : : struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/ 318 : : 319 : : struct tcp_sack_block recv_sack_cache[4]; 320 : : 321 : : struct sk_buff *highest_sack; /* skb just after the highest 322 : : * skb with SACKed bit set 323 : : * (validity guaranteed only if 324 : : * sacked_out > 0) 325 : : */ 326 : : 327 : : int lost_cnt_hint; 328 : : 329 : : u32 prior_ssthresh; /* ssthresh saved at recovery start */ 330 : : u32 high_seq; /* snd_nxt at onset of congestion */ 331 : : 332 : : u32 retrans_stamp; /* Timestamp of the last retransmit, 333 : : * also used in SYN-SENT to remember stamp of 334 : : * the first SYN. */ 335 : : u32 undo_marker; /* snd_una upon a new recovery episode. */ 336 : : int undo_retrans; /* number of undoable retransmissions. */ 337 : : u64 bytes_retrans; /* RFC4898 tcpEStatsPerfOctetsRetrans 338 : : * Total data bytes retransmitted 339 : : */ 340 : : u32 total_retrans; /* Total retransmits for entire connection */ 341 : : 342 : : u32 urg_seq; /* Seq of received urgent pointer */ 343 : : unsigned int keepalive_time; /* time before keep alive takes place */ 344 : : unsigned int keepalive_intvl; /* time interval between keep alive probes */ 345 : : 346 : : int linger2; 347 : : 348 : : 349 : : /* Sock_ops bpf program related variables */ 350 : : #ifdef CONFIG_BPF 351 : : u8 bpf_sock_ops_cb_flags; /* Control calling BPF programs 352 : : * values defined in uapi/linux/tcp.h 353 : : */ 354 : : #define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) (TP->bpf_sock_ops_cb_flags & ARG) 355 : : #else 356 : : #define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) 0 357 : : #endif 358 : : 359 : : u32 rcv_ooopack; /* Received out-of-order packets, for tcpinfo */ 360 : : 361 : : /* Receiver side RTT estimation */ 362 : : u32 rcv_rtt_last_tsecr; 363 : : struct { 364 : : u32 rtt_us; 365 : : u32 seq; 366 : : u64 time; 367 : : } rcv_rtt_est; 368 : : 369 : : /* Receiver queue space */ 370 : : struct { 371 : : u32 space; 372 : : u32 seq; 373 : : u64 time; 374 : : } rcvq_space; 375 : : 376 : : /* TCP-specific MTU probe information. */ 377 : : struct { 378 : : u32 probe_seq_start; 379 : : u32 probe_seq_end; 380 : : } mtu_probe; 381 : : u32 mtu_info; /* We received an ICMP_FRAG_NEEDED / ICMPV6_PKT_TOOBIG 382 : : * while socket was owned by user. 383 : : */ 384 : : 385 : : #ifdef CONFIG_TCP_MD5SIG 386 : : /* TCP AF-Specific parts; only used by MD5 Signature support so far */ 387 : : const struct tcp_sock_af_ops *af_specific; 388 : : 389 : : /* TCP MD5 Signature Option information */ 390 : : struct tcp_md5sig_info __rcu *md5sig_info; 391 : : #endif 392 : : 393 : : /* TCP fastopen related information */ 394 : : struct tcp_fastopen_request *fastopen_req; 395 : : /* fastopen_rsk points to request_sock that resulted in this big 396 : : * socket. Used to retransmit SYNACKs etc. 397 : : */ 398 : : struct request_sock __rcu *fastopen_rsk; 399 : : u32 *saved_syn; 400 : : }; 401 : : 402 : : enum tsq_enum { 403 : : TSQ_THROTTLED, 404 : : TSQ_QUEUED, 405 : : TCP_TSQ_DEFERRED, /* tcp_tasklet_func() found socket was owned */ 406 : : TCP_WRITE_TIMER_DEFERRED, /* tcp_write_timer() found socket was owned */ 407 : : TCP_DELACK_TIMER_DEFERRED, /* tcp_delack_timer() found socket was owned */ 408 : : TCP_MTU_REDUCED_DEFERRED, /* tcp_v{4|6}_err() could not call 409 : : * tcp_v{4|6}_mtu_reduced() 410 : : */ 411 : : }; 412 : : 413 : : enum tsq_flags { 414 : : TSQF_THROTTLED = (1UL << TSQ_THROTTLED), 415 : : TSQF_QUEUED = (1UL << TSQ_QUEUED), 416 : : TCPF_TSQ_DEFERRED = (1UL << TCP_TSQ_DEFERRED), 417 : : TCPF_WRITE_TIMER_DEFERRED = (1UL << TCP_WRITE_TIMER_DEFERRED), 418 : : TCPF_DELACK_TIMER_DEFERRED = (1UL << TCP_DELACK_TIMER_DEFERRED), 419 : : TCPF_MTU_REDUCED_DEFERRED = (1UL << TCP_MTU_REDUCED_DEFERRED), 420 : : }; 421 : : 422 : 0 : static inline struct tcp_sock *tcp_sk(const struct sock *sk) 423 : : { 424 : 0 : return (struct tcp_sock *)sk; 425 : : } 426 : : 427 : : struct tcp_timewait_sock { 428 : : struct inet_timewait_sock tw_sk; 429 : : #define tw_rcv_nxt tw_sk.__tw_common.skc_tw_rcv_nxt 430 : : #define tw_snd_nxt tw_sk.__tw_common.skc_tw_snd_nxt 431 : : u32 tw_rcv_wnd; 432 : : u32 tw_ts_offset; 433 : : u32 tw_ts_recent; 434 : : 435 : : /* The time we sent the last out-of-window ACK: */ 436 : : u32 tw_last_oow_ack_time; 437 : : 438 : : int tw_ts_recent_stamp; 439 : : u32 tw_tx_delay; 440 : : #ifdef CONFIG_TCP_MD5SIG 441 : : struct tcp_md5sig_key *tw_md5_key; 442 : : #endif 443 : : }; 444 : : 445 : : static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk) 446 : : { 447 : : return (struct tcp_timewait_sock *)sk; 448 : : } 449 : : 450 : : static inline bool tcp_passive_fastopen(const struct sock *sk) 451 : : { 452 : 0 : return sk->sk_state == TCP_SYN_RECV && 453 : 0 : rcu_access_pointer(tcp_sk(sk)->fastopen_rsk) != NULL; 454 : : } 455 : : 456 : : static inline void fastopen_queue_tune(struct sock *sk, int backlog) 457 : : { 458 : : struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; 459 : : int somaxconn = READ_ONCE(sock_net(sk)->core.sysctl_somaxconn); 460 : : 461 : 0 : queue->fastopenq.max_qlen = min_t(unsigned int, backlog, somaxconn); 462 : : } 463 : : 464 : : static inline void tcp_move_syn(struct tcp_sock *tp, 465 : : struct request_sock *req) 466 : : { 467 : 0 : tp->saved_syn = req->saved_syn; 468 : 0 : req->saved_syn = NULL; 469 : : } 470 : : 471 : : static inline void tcp_saved_syn_free(struct tcp_sock *tp) 472 : : { 473 : 1 : kfree(tp->saved_syn); 474 : 1 : tp->saved_syn = NULL; 475 : : } 476 : : 477 : : struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk); 478 : : 479 : : static inline u16 tcp_mss_clamp(const struct tcp_sock *tp, u16 mss) 480 : : { 481 : : /* We use READ_ONCE() here because socket might not be locked. 482 : : * This happens for listeners. 483 : : */ 484 : : u16 user_mss = READ_ONCE(tp->rx_opt.user_mss); 485 : : 486 : 1 : return (user_mss && user_mss < mss) ? user_mss : mss; 487 : : } 488 : : 489 : : int tcp_skb_shift(struct sk_buff *to, struct sk_buff *from, int pcount, 490 : : int shiftlen); 491 : : 492 : : #endif /* _LINUX_TCP_H */