tcp.h 17 KB

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