1 /*
2  * INET		An implementation of the TCP/IP protocol suite for the LINUX
3  *		operating system.  INET is implemented using the  BSD Socket
4  *		interface as the means of communication with the user level.
5  *
6  *		Definitions for the TCP module.
7  *
8  * Version:	@(#)tcp.h	1.0.5	05/23/93
9  *
10  * Authors:	Ross Biro
11  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *
13  *		This program is free software; you can redistribute it and/or
14  *		modify it under the terms of the GNU General Public License
15  *		as published by the Free Software Foundation; either version
16  *		2 of the License, or (at your option) any later version.
17  */
18 #ifndef _TCP_H
19 #define _TCP_H
20 
21 #define FASTRETRANS_DEBUG 1
22 
23 #include <linux/list.h>
24 #include <linux/tcp.h>
25 #include <linux/bug.h>
26 #include <linux/slab.h>
27 #include <linux/cache.h>
28 #include <linux/percpu.h>
29 #include <linux/skbuff.h>
30 #include <linux/dmaengine.h>
31 #include <linux/crypto.h>
32 #include <linux/cryptohash.h>
33 #include <linux/kref.h>
34 
35 #include <net/inet_connection_sock.h>
36 #include <net/inet_timewait_sock.h>
37 #include <net/inet_hashtables.h>
38 #include <net/checksum.h>
39 #include <net/request_sock.h>
40 #include <net/sock.h>
41 #include <net/snmp.h>
42 #include <net/ip.h>
43 #include <net/tcp_states.h>
44 #include <net/inet_ecn.h>
45 #include <net/dst.h>
46 
47 #include <linux/seq_file.h>
48 #include <linux/memcontrol.h>
49 
50 extern struct inet_hashinfo tcp_hashinfo;
51 
52 extern struct percpu_counter tcp_orphan_count;
53 extern void tcp_time_wait(struct sock *sk, int state, int timeo);
54 
55 #define MAX_TCP_HEADER	(128 + MAX_HEADER)
56 #define MAX_TCP_OPTION_SPACE 40
57 
58 /*
59  * Never offer a window over 32767 without using window scaling. Some
60  * poor stacks do signed 16bit maths!
61  */
62 #define MAX_TCP_WINDOW		32767U
63 
64 /* Offer an initial receive window of 10 mss. */
65 #define TCP_DEFAULT_INIT_RCVWND	10
66 
67 /* Minimal accepted MSS. It is (60+60+8) - (20+20). */
68 #define TCP_MIN_MSS		88U
69 
70 /* The least MTU to use for probing */
71 #define TCP_BASE_MSS		512
72 
73 /* After receiving this amount of duplicate ACKs fast retransmit starts. */
74 #define TCP_FASTRETRANS_THRESH 3
75 
76 /* Maximal reordering. */
77 #define TCP_MAX_REORDERING	127
78 
79 /* Maximal number of ACKs sent quickly to accelerate slow-start. */
80 #define TCP_MAX_QUICKACKS	16U
81 
82 /* urg_data states */
83 #define TCP_URG_VALID	0x0100
84 #define TCP_URG_NOTYET	0x0200
85 #define TCP_URG_READ	0x0400
86 
87 #define TCP_RETR1	3	/*
88 				 * This is how many retries it does before it
89 				 * tries to figure out if the gateway is
90 				 * down. Minimal RFC value is 3; it corresponds
91 				 * to ~3sec-8min depending on RTO.
92 				 */
93 
94 #define TCP_RETR2	15	/*
95 				 * This should take at least
96 				 * 90 minutes to time out.
97 				 * RFC1122 says that the limit is 100 sec.
98 				 * 15 is ~13-30min depending on RTO.
99 				 */
100 
101 #define TCP_SYN_RETRIES	 5	/* number of times to retry active opening a
102 				 * connection: ~180sec is RFC minimum	*/
103 
104 #define TCP_SYNACK_RETRIES 5	/* number of times to retry passive opening a
105 				 * connection: ~180sec is RFC minimum	*/
106 
107 #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
108 				  * state, about 60 seconds	*/
109 #define TCP_FIN_TIMEOUT	TCP_TIMEWAIT_LEN
110                                  /* BSD style FIN_WAIT2 deadlock breaker.
111 				  * It used to be 3min, new value is 60sec,
112 				  * to combine FIN-WAIT-2 timeout with
113 				  * TIME-WAIT timer.
114 				  */
115 
116 #define TCP_DELACK_MAX	((unsigned)(HZ/5))	/* maximal time to delay before sending an ACK */
117 #if HZ >= 100
118 #define TCP_DELACK_MIN	((unsigned)(HZ/25))	/* minimal time to delay before sending an ACK */
119 #define TCP_ATO_MIN	((unsigned)(HZ/25))
120 #else
121 #define TCP_DELACK_MIN	4U
122 #define TCP_ATO_MIN	4U
123 #endif
124 #define TCP_RTO_MAX	((unsigned)(120*HZ))
125 #define TCP_RTO_MIN	((unsigned)(HZ/5))
126 #define TCP_TIMEOUT_INIT ((unsigned)(1*HZ))	/* RFC2988bis initial RTO value	*/
127 #define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ))	/* RFC 1122 initial RTO value, now
128 						 * used as a fallback RTO for the
129 						 * initial data transmission if no
130 						 * valid RTT sample has been acquired,
131 						 * most likely due to retrans in 3WHS.
132 						 */
133 
134 #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
135 					                 * for local resources.
136 					                 */
137 
138 #define TCP_KEEPALIVE_TIME	(120*60*HZ)	/* two hours */
139 #define TCP_KEEPALIVE_PROBES	9		/* Max of 9 keepalive probes	*/
140 #define TCP_KEEPALIVE_INTVL	(75*HZ)
141 
142 #define MAX_TCP_KEEPIDLE	32767
143 #define MAX_TCP_KEEPINTVL	32767
144 #define MAX_TCP_KEEPCNT		127
145 #define MAX_TCP_SYNCNT		127
146 
147 #define TCP_SYNQ_INTERVAL	(HZ/5)	/* Period of SYNACK timer */
148 
149 #define TCP_PAWS_24DAYS	(60 * 60 * 24 * 24)
150 #define TCP_PAWS_MSL	60		/* Per-host timestamps are invalidated
151 					 * after this time. It should be equal
152 					 * (or greater than) TCP_TIMEWAIT_LEN
153 					 * to provide reliability equal to one
154 					 * provided by timewait state.
155 					 */
156 #define TCP_PAWS_WINDOW	1		/* Replay window for per-host
157 					 * timestamps. It must be less than
158 					 * minimal timewait lifetime.
159 					 */
160 /*
161  *	TCP option
162  */
163 
164 #define TCPOPT_NOP		1	/* Padding */
165 #define TCPOPT_EOL		0	/* End of options */
166 #define TCPOPT_MSS		2	/* Segment size negotiating */
167 #define TCPOPT_WINDOW		3	/* Window scaling */
168 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
169 #define TCPOPT_SACK             5       /* SACK Block */
170 #define TCPOPT_TIMESTAMP	8	/* Better RTT estimations/PAWS */
171 #define TCPOPT_MD5SIG		19	/* MD5 Signature (RFC2385) */
172 #define TCPOPT_COOKIE		253	/* Cookie extension (experimental) */
173 
174 /*
175  *     TCP option lengths
176  */
177 
178 #define TCPOLEN_MSS            4
179 #define TCPOLEN_WINDOW         3
180 #define TCPOLEN_SACK_PERM      2
181 #define TCPOLEN_TIMESTAMP      10
182 #define TCPOLEN_MD5SIG         18
183 #define TCPOLEN_COOKIE_BASE    2	/* Cookie-less header extension */
184 #define TCPOLEN_COOKIE_PAIR    3	/* Cookie pair header extension */
185 #define TCPOLEN_COOKIE_MIN     (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MIN)
186 #define TCPOLEN_COOKIE_MAX     (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MAX)
187 
188 /* But this is what stacks really send out. */
189 #define TCPOLEN_TSTAMP_ALIGNED		12
190 #define TCPOLEN_WSCALE_ALIGNED		4
191 #define TCPOLEN_SACKPERM_ALIGNED	4
192 #define TCPOLEN_SACK_BASE		2
193 #define TCPOLEN_SACK_BASE_ALIGNED	4
194 #define TCPOLEN_SACK_PERBLOCK		8
195 #define TCPOLEN_MD5SIG_ALIGNED		20
196 #define TCPOLEN_MSS_ALIGNED		4
197 
198 /* Flags in tp->nonagle */
199 #define TCP_NAGLE_OFF		1	/* Nagle's algo is disabled */
200 #define TCP_NAGLE_CORK		2	/* Socket is corked	    */
201 #define TCP_NAGLE_PUSH		4	/* Cork is overridden for already queued data */
202 
203 /* TCP thin-stream limits */
204 #define TCP_THIN_LINEAR_RETRIES 6       /* After 6 linear retries, do exp. backoff */
205 
206 /* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */
207 #define TCP_INIT_CWND		10
208 
209 extern struct inet_timewait_death_row tcp_death_row;
210 
211 /* sysctl variables for tcp */
212 extern int sysctl_tcp_timestamps;
213 extern int sysctl_tcp_window_scaling;
214 extern int sysctl_tcp_sack;
215 extern int sysctl_tcp_fin_timeout;
216 extern int sysctl_tcp_keepalive_time;
217 extern int sysctl_tcp_keepalive_probes;
218 extern int sysctl_tcp_keepalive_intvl;
219 extern int sysctl_tcp_syn_retries;
220 extern int sysctl_tcp_synack_retries;
221 extern int sysctl_tcp_retries1;
222 extern int sysctl_tcp_retries2;
223 extern int sysctl_tcp_orphan_retries;
224 extern int sysctl_tcp_syncookies;
225 extern int sysctl_tcp_retrans_collapse;
226 extern int sysctl_tcp_stdurg;
227 extern int sysctl_tcp_rfc1337;
228 extern int sysctl_tcp_abort_on_overflow;
229 extern int sysctl_tcp_max_orphans;
230 extern int sysctl_tcp_fack;
231 extern int sysctl_tcp_reordering;
232 extern int sysctl_tcp_ecn;
233 extern int sysctl_tcp_dsack;
234 extern int sysctl_tcp_wmem[3];
235 extern int sysctl_tcp_rmem[3];
236 extern int sysctl_tcp_app_win;
237 extern int sysctl_tcp_adv_win_scale;
238 extern int sysctl_tcp_tw_reuse;
239 extern int sysctl_tcp_frto;
240 extern int sysctl_tcp_frto_response;
241 extern int sysctl_tcp_low_latency;
242 extern int sysctl_tcp_dma_copybreak;
243 extern int sysctl_tcp_nometrics_save;
244 extern int sysctl_tcp_moderate_rcvbuf;
245 extern int sysctl_tcp_tso_win_divisor;
246 extern int sysctl_tcp_abc;
247 extern int sysctl_tcp_mtu_probing;
248 extern int sysctl_tcp_base_mss;
249 extern int sysctl_tcp_workaround_signed_windows;
250 extern int sysctl_tcp_slow_start_after_idle;
251 extern int sysctl_tcp_max_ssthresh;
252 extern int sysctl_tcp_cookie_size;
253 extern int sysctl_tcp_thin_linear_timeouts;
254 extern int sysctl_tcp_thin_dupack;
255 extern int sysctl_tcp_challenge_ack_limit;
256 
257 extern atomic_long_t tcp_memory_allocated;
258 extern struct percpu_counter tcp_sockets_allocated;
259 extern int tcp_memory_pressure;
260 
261 /*
262  * The next routines deal with comparing 32 bit unsigned ints
263  * and worry about wraparound (automatic with unsigned arithmetic).
264  */
265 
before(__u32 seq1,__u32 seq2)266 static inline int before(__u32 seq1, __u32 seq2)
267 {
268         return (__s32)(seq1-seq2) < 0;
269 }
270 #define after(seq2, seq1) 	before(seq1, seq2)
271 
272 /* is s2<=s1<=s3 ? */
between(__u32 seq1,__u32 seq2,__u32 seq3)273 static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
274 {
275 	return seq3 - seq2 >= seq1 - seq2;
276 }
277 
tcp_out_of_memory(struct sock * sk)278 static inline bool tcp_out_of_memory(struct sock *sk)
279 {
280 	if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
281 	    sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
282 		return true;
283 	return false;
284 }
285 
tcp_too_many_orphans(struct sock * sk,int shift)286 static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
287 {
288 	struct percpu_counter *ocp = sk->sk_prot->orphan_count;
289 	int orphans = percpu_counter_read_positive(ocp);
290 
291 	if (orphans << shift > sysctl_tcp_max_orphans) {
292 		orphans = percpu_counter_sum_positive(ocp);
293 		if (orphans << shift > sysctl_tcp_max_orphans)
294 			return true;
295 	}
296 	return false;
297 }
298 
299 extern bool tcp_check_oom(struct sock *sk, int shift);
300 
301 /* syncookies: remember time of last synqueue overflow */
tcp_synq_overflow(struct sock * sk)302 static inline void tcp_synq_overflow(struct sock *sk)
303 {
304 	tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
305 }
306 
307 /* syncookies: no recent synqueue overflow on this listening socket? */
tcp_synq_no_recent_overflow(const struct sock * sk)308 static inline int tcp_synq_no_recent_overflow(const struct sock *sk)
309 {
310 	unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
311 	return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK);
312 }
313 
314 extern struct proto tcp_prot;
315 
316 #define TCP_INC_STATS(net, field)	SNMP_INC_STATS((net)->mib.tcp_statistics, field)
317 #define TCP_INC_STATS_BH(net, field)	SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field)
318 #define TCP_DEC_STATS(net, field)	SNMP_DEC_STATS((net)->mib.tcp_statistics, field)
319 #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val)
320 #define TCP_ADD_STATS(net, field, val)	SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)
321 
322 extern void tcp_init_mem(struct net *net);
323 
324 extern void tcp_v4_err(struct sk_buff *skb, u32);
325 
326 extern void tcp_shutdown (struct sock *sk, int how);
327 
328 extern int tcp_v4_rcv(struct sk_buff *skb);
329 
330 extern struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it);
331 extern void *tcp_v4_tw_get_peer(struct sock *sk);
332 extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
333 extern int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
334 		       size_t size);
335 extern int tcp_sendpage(struct sock *sk, struct page *page, int offset,
336 			size_t size, int flags);
337 extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
338 extern int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
339 				 const struct tcphdr *th, unsigned int len);
340 extern int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
341 			       const struct tcphdr *th, unsigned int len);
342 extern void tcp_rcv_space_adjust(struct sock *sk);
343 extern void tcp_cleanup_rbuf(struct sock *sk, int copied);
344 extern int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp);
345 extern void tcp_twsk_destructor(struct sock *sk);
346 extern ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos,
347 			       struct pipe_inode_info *pipe, size_t len,
348 			       unsigned int flags);
349 
tcp_dec_quickack_mode(struct sock * sk,const unsigned int pkts)350 static inline void tcp_dec_quickack_mode(struct sock *sk,
351 					 const unsigned int pkts)
352 {
353 	struct inet_connection_sock *icsk = inet_csk(sk);
354 
355 	if (icsk->icsk_ack.quick) {
356 		if (pkts >= icsk->icsk_ack.quick) {
357 			icsk->icsk_ack.quick = 0;
358 			/* Leaving quickack mode we deflate ATO. */
359 			icsk->icsk_ack.ato   = TCP_ATO_MIN;
360 		} else
361 			icsk->icsk_ack.quick -= pkts;
362 	}
363 }
364 
365 #define	TCP_ECN_OK		1
366 #define	TCP_ECN_QUEUE_CWR	2
367 #define	TCP_ECN_DEMAND_CWR	4
368 #define	TCP_ECN_SEEN		8
369 
370 static __inline__ void
TCP_ECN_create_request(struct request_sock * req,struct tcphdr * th)371 TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th)
372 {
373 	if (sysctl_tcp_ecn && th->ece && th->cwr)
374 		inet_rsk(req)->ecn_ok = 1;
375 }
376 
377 enum tcp_tw_status {
378 	TCP_TW_SUCCESS = 0,
379 	TCP_TW_RST = 1,
380 	TCP_TW_ACK = 2,
381 	TCP_TW_SYN = 3
382 };
383 
384 
385 extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,
386 						     struct sk_buff *skb,
387 						     const struct tcphdr *th);
388 extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb,
389 				   struct request_sock *req,
390 				   struct request_sock **prev);
391 extern int tcp_child_process(struct sock *parent, struct sock *child,
392 			     struct sk_buff *skb);
393 extern int tcp_use_frto(struct sock *sk);
394 extern void tcp_enter_frto(struct sock *sk);
395 extern void tcp_enter_loss(struct sock *sk, int how);
396 extern void tcp_clear_retrans(struct tcp_sock *tp);
397 extern void tcp_update_metrics(struct sock *sk);
398 extern void tcp_close(struct sock *sk, long timeout);
399 extern unsigned int tcp_poll(struct file * file, struct socket *sock,
400 			     struct poll_table_struct *wait);
401 extern int tcp_getsockopt(struct sock *sk, int level, int optname,
402 			  char __user *optval, int __user *optlen);
403 extern int tcp_setsockopt(struct sock *sk, int level, int optname,
404 			  char __user *optval, unsigned int optlen);
405 extern int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
406 				 char __user *optval, int __user *optlen);
407 extern int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
408 				 char __user *optval, unsigned int optlen);
409 extern void tcp_set_keepalive(struct sock *sk, int val);
410 extern void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req);
411 extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
412 		       size_t len, int nonblock, int flags, int *addr_len);
413 extern void tcp_parse_options(const struct sk_buff *skb,
414 			      struct tcp_options_received *opt_rx, const u8 **hvpp,
415 			      int estab);
416 extern const u8 *tcp_parse_md5sig_option(const struct tcphdr *th);
417 
418 /*
419  *	TCP v4 functions exported for the inet6 API
420  */
421 
422 extern void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb);
423 extern int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb);
424 extern struct sock * tcp_create_openreq_child(struct sock *sk,
425 					      struct request_sock *req,
426 					      struct sk_buff *skb);
427 extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
428 					  struct request_sock *req,
429 					  struct dst_entry *dst);
430 extern int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
431 extern int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr,
432 			  int addr_len);
433 extern int tcp_connect(struct sock *sk);
434 extern struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
435 					struct request_sock *req,
436 					struct request_values *rvp);
437 extern int tcp_disconnect(struct sock *sk, int flags);
438 
439 
440 /* From syncookies.c */
441 extern __u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS];
442 extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
443 				    struct ip_options *opt);
444 #ifdef CONFIG_SYN_COOKIES
445 extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
446 				     __u16 *mss);
447 #else
cookie_v4_init_sequence(struct sock * sk,struct sk_buff * skb,__u16 * mss)448 static inline __u32 cookie_v4_init_sequence(struct sock *sk,
449 					    struct sk_buff *skb,
450 					    __u16 *mss)
451 {
452 	return 0;
453 }
454 #endif
455 
456 extern __u32 cookie_init_timestamp(struct request_sock *req);
457 extern bool cookie_check_timestamp(struct tcp_options_received *opt, bool *);
458 
459 /* From net/ipv6/syncookies.c */
460 extern struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);
461 #ifdef CONFIG_SYN_COOKIES
462 extern __u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb,
463 				     __u16 *mss);
464 #else
cookie_v6_init_sequence(struct sock * sk,struct sk_buff * skb,__u16 * mss)465 static inline __u32 cookie_v6_init_sequence(struct sock *sk,
466 					    struct sk_buff *skb,
467 					    __u16 *mss)
468 {
469 	return 0;
470 }
471 #endif
472 /* tcp_output.c */
473 
474 extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
475 				      int nonagle);
476 extern int tcp_may_send_now(struct sock *sk);
477 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
478 extern void tcp_retransmit_timer(struct sock *sk);
479 extern void tcp_xmit_retransmit_queue(struct sock *);
480 extern void tcp_simple_retransmit(struct sock *);
481 extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
482 extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int);
483 
484 extern void tcp_send_probe0(struct sock *);
485 extern void tcp_send_partial(struct sock *);
486 extern int tcp_write_wakeup(struct sock *);
487 extern void tcp_send_fin(struct sock *sk);
488 extern void tcp_send_active_reset(struct sock *sk, gfp_t priority);
489 extern int tcp_send_synack(struct sock *);
490 extern int tcp_syn_flood_action(struct sock *sk,
491 				const struct sk_buff *skb,
492 				const char *proto);
493 extern void tcp_push_one(struct sock *, unsigned int mss_now);
494 extern void tcp_send_ack(struct sock *sk);
495 extern void tcp_send_delayed_ack(struct sock *sk);
496 
497 /* tcp_input.c */
498 extern void tcp_cwnd_application_limited(struct sock *sk);
499 
500 /* tcp_timer.c */
501 extern void tcp_init_xmit_timers(struct sock *);
tcp_clear_xmit_timers(struct sock * sk)502 static inline void tcp_clear_xmit_timers(struct sock *sk)
503 {
504 	inet_csk_clear_xmit_timers(sk);
505 }
506 
507 extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
508 extern unsigned int tcp_current_mss(struct sock *sk);
509 
510 /* Bound MSS / TSO packet size with the half of the window */
tcp_bound_to_half_wnd(struct tcp_sock * tp,int pktsize)511 static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)
512 {
513 	int cutoff;
514 
515 	/* When peer uses tiny windows, there is no use in packetizing
516 	 * to sub-MSS pieces for the sake of SWS or making sure there
517 	 * are enough packets in the pipe for fast recovery.
518 	 *
519 	 * On the other hand, for extremely large MSS devices, handling
520 	 * smaller than MSS windows in this way does make sense.
521 	 */
522 	if (tp->max_window >= 512)
523 		cutoff = (tp->max_window >> 1);
524 	else
525 		cutoff = tp->max_window;
526 
527 	if (cutoff && pktsize > cutoff)
528 		return max_t(int, cutoff, 68U - tp->tcp_header_len);
529 	else
530 		return pktsize;
531 }
532 
533 /* tcp.c */
534 extern void tcp_get_info(const struct sock *, struct tcp_info *);
535 
536 /* Read 'sendfile()'-style from a TCP socket */
537 typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
538 				unsigned int, size_t);
539 extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
540 			 sk_read_actor_t recv_actor);
541 
542 extern void tcp_initialize_rcv_mss(struct sock *sk);
543 
544 extern int tcp_mtu_to_mss(const struct sock *sk, int pmtu);
545 extern int tcp_mss_to_mtu(const struct sock *sk, int mss);
546 extern void tcp_mtup_init(struct sock *sk);
547 extern void tcp_valid_rtt_meas(struct sock *sk, u32 seq_rtt);
548 
tcp_bound_rto(const struct sock * sk)549 static inline void tcp_bound_rto(const struct sock *sk)
550 {
551 	if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
552 		inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
553 }
554 
__tcp_set_rto(const struct tcp_sock * tp)555 static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
556 {
557 	return (tp->srtt >> 3) + tp->rttvar;
558 }
559 
__tcp_fast_path_on(struct tcp_sock * tp,u32 snd_wnd)560 static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
561 {
562 	tp->pred_flags = htonl((tp->tcp_header_len << 26) |
563 			       ntohl(TCP_FLAG_ACK) |
564 			       snd_wnd);
565 }
566 
tcp_fast_path_on(struct tcp_sock * tp)567 static inline void tcp_fast_path_on(struct tcp_sock *tp)
568 {
569 	__tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
570 }
571 
tcp_fast_path_check(struct sock * sk)572 static inline void tcp_fast_path_check(struct sock *sk)
573 {
574 	struct tcp_sock *tp = tcp_sk(sk);
575 
576 	if (skb_queue_empty(&tp->out_of_order_queue) &&
577 	    tp->rcv_wnd &&
578 	    atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
579 	    !tp->urg_data)
580 		tcp_fast_path_on(tp);
581 }
582 
583 /* Compute the actual rto_min value */
tcp_rto_min(struct sock * sk)584 static inline u32 tcp_rto_min(struct sock *sk)
585 {
586 	const struct dst_entry *dst = __sk_dst_get(sk);
587 	u32 rto_min = TCP_RTO_MIN;
588 
589 	if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
590 		rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
591 	return rto_min;
592 }
593 
594 /* Compute the actual receive window we are currently advertising.
595  * Rcv_nxt can be after the window if our peer push more data
596  * than the offered window.
597  */
tcp_receive_window(const struct tcp_sock * tp)598 static inline u32 tcp_receive_window(const struct tcp_sock *tp)
599 {
600 	s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
601 
602 	if (win < 0)
603 		win = 0;
604 	return (u32) win;
605 }
606 
607 /* Choose a new window, without checks for shrinking, and without
608  * scaling applied to the result.  The caller does these things
609  * if necessary.  This is a "raw" window selection.
610  */
611 extern u32 __tcp_select_window(struct sock *sk);
612 
613 /* TCP timestamps are only 32-bits, this causes a slight
614  * complication on 64-bit systems since we store a snapshot
615  * of jiffies in the buffer control blocks below.  We decided
616  * to use only the low 32-bits of jiffies and hide the ugly
617  * casts with the following macro.
618  */
619 #define tcp_time_stamp		((__u32)(jiffies))
620 
621 #define tcp_flag_byte(th) (((u_int8_t *)th)[13])
622 
623 #define TCPHDR_FIN 0x01
624 #define TCPHDR_SYN 0x02
625 #define TCPHDR_RST 0x04
626 #define TCPHDR_PSH 0x08
627 #define TCPHDR_ACK 0x10
628 #define TCPHDR_URG 0x20
629 #define TCPHDR_ECE 0x40
630 #define TCPHDR_CWR 0x80
631 
632 /* This is what the send packet queuing engine uses to pass
633  * TCP per-packet control information to the transmission code.
634  * We also store the host-order sequence numbers in here too.
635  * This is 44 bytes if IPV6 is enabled.
636  * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately.
637  */
638 struct tcp_skb_cb {
639 	union {
640 		struct inet_skb_parm	h4;
641 #if IS_ENABLED(CONFIG_IPV6)
642 		struct inet6_skb_parm	h6;
643 #endif
644 	} header;	/* For incoming frames		*/
645 	__u32		seq;		/* Starting sequence number	*/
646 	__u32		end_seq;	/* SEQ + FIN + SYN + datalen	*/
647 	__u32		when;		/* used to compute rtt's	*/
648 	__u8		tcp_flags;	/* TCP header flags. (tcp[13])	*/
649 	__u8		sacked;		/* State flags for SACK/FACK.	*/
650 #define TCPCB_SACKED_ACKED	0x01	/* SKB ACK'd by a SACK block	*/
651 #define TCPCB_SACKED_RETRANS	0x02	/* SKB retransmitted		*/
652 #define TCPCB_LOST		0x04	/* SKB is lost			*/
653 #define TCPCB_TAGBITS		0x07	/* All tag bits			*/
654 	__u8		ip_dsfield;	/* IPv4 tos or IPv6 dsfield	*/
655 	/* 1 byte hole */
656 #define TCPCB_EVER_RETRANS	0x80	/* Ever retransmitted frame	*/
657 #define TCPCB_RETRANS		(TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
658 
659 	__u32		ack_seq;	/* Sequence number ACK'd	*/
660 };
661 
662 #define TCP_SKB_CB(__skb)	((struct tcp_skb_cb *)&((__skb)->cb[0]))
663 
664 /* Due to TSO, an SKB can be composed of multiple actual
665  * packets.  To keep these tracked properly, we use this.
666  */
tcp_skb_pcount(const struct sk_buff * skb)667 static inline int tcp_skb_pcount(const struct sk_buff *skb)
668 {
669 	return skb_shinfo(skb)->gso_segs;
670 }
671 
672 /* This is valid iff tcp_skb_pcount() > 1. */
tcp_skb_mss(const struct sk_buff * skb)673 static inline int tcp_skb_mss(const struct sk_buff *skb)
674 {
675 	return skb_shinfo(skb)->gso_size;
676 }
677 
678 /* Events passed to congestion control interface */
679 enum tcp_ca_event {
680 	CA_EVENT_TX_START,	/* first transmit when no packets in flight */
681 	CA_EVENT_CWND_RESTART,	/* congestion window restart */
682 	CA_EVENT_COMPLETE_CWR,	/* end of congestion recovery */
683 	CA_EVENT_FRTO,		/* fast recovery timeout */
684 	CA_EVENT_LOSS,		/* loss timeout */
685 	CA_EVENT_FAST_ACK,	/* in sequence ack */
686 	CA_EVENT_SLOW_ACK,	/* other ack */
687 };
688 
689 /*
690  * Interface for adding new TCP congestion control handlers
691  */
692 #define TCP_CA_NAME_MAX	16
693 #define TCP_CA_MAX	128
694 #define TCP_CA_BUF_MAX	(TCP_CA_NAME_MAX*TCP_CA_MAX)
695 
696 #define TCP_CONG_NON_RESTRICTED 0x1
697 #define TCP_CONG_RTT_STAMP	0x2
698 
699 struct tcp_congestion_ops {
700 	struct list_head	list;
701 	unsigned long flags;
702 
703 	/* initialize private data (optional) */
704 	void (*init)(struct sock *sk);
705 	/* cleanup private data  (optional) */
706 	void (*release)(struct sock *sk);
707 
708 	/* return slow start threshold (required) */
709 	u32 (*ssthresh)(struct sock *sk);
710 	/* lower bound for congestion window (optional) */
711 	u32 (*min_cwnd)(const struct sock *sk);
712 	/* do new cwnd calculation (required) */
713 	void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight);
714 	/* call before changing ca_state (optional) */
715 	void (*set_state)(struct sock *sk, u8 new_state);
716 	/* call when cwnd event occurs (optional) */
717 	void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
718 	/* new value of cwnd after loss (optional) */
719 	u32  (*undo_cwnd)(struct sock *sk);
720 	/* hook for packet ack accounting (optional) */
721 	void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us);
722 	/* get info for inet_diag (optional) */
723 	void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);
724 
725 	char 		name[TCP_CA_NAME_MAX];
726 	struct module 	*owner;
727 };
728 
729 extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
730 extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
731 
732 extern void tcp_init_congestion_control(struct sock *sk);
733 extern void tcp_cleanup_congestion_control(struct sock *sk);
734 extern int tcp_set_default_congestion_control(const char *name);
735 extern void tcp_get_default_congestion_control(char *name);
736 extern void tcp_get_available_congestion_control(char *buf, size_t len);
737 extern void tcp_get_allowed_congestion_control(char *buf, size_t len);
738 extern int tcp_set_allowed_congestion_control(char *allowed);
739 extern int tcp_set_congestion_control(struct sock *sk, const char *name);
740 extern void tcp_slow_start(struct tcp_sock *tp);
741 extern void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w);
742 
743 extern struct tcp_congestion_ops tcp_init_congestion_ops;
744 extern u32 tcp_reno_ssthresh(struct sock *sk);
745 extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight);
746 extern u32 tcp_reno_min_cwnd(const struct sock *sk);
747 extern struct tcp_congestion_ops tcp_reno;
748 
tcp_set_ca_state(struct sock * sk,const u8 ca_state)749 static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
750 {
751 	struct inet_connection_sock *icsk = inet_csk(sk);
752 
753 	if (icsk->icsk_ca_ops->set_state)
754 		icsk->icsk_ca_ops->set_state(sk, ca_state);
755 	icsk->icsk_ca_state = ca_state;
756 }
757 
tcp_ca_event(struct sock * sk,const enum tcp_ca_event event)758 static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
759 {
760 	const struct inet_connection_sock *icsk = inet_csk(sk);
761 
762 	if (icsk->icsk_ca_ops->cwnd_event)
763 		icsk->icsk_ca_ops->cwnd_event(sk, event);
764 }
765 
766 /* These functions determine how the current flow behaves in respect of SACK
767  * handling. SACK is negotiated with the peer, and therefore it can vary
768  * between different flows.
769  *
770  * tcp_is_sack - SACK enabled
771  * tcp_is_reno - No SACK
772  * tcp_is_fack - FACK enabled, implies SACK enabled
773  */
tcp_is_sack(const struct tcp_sock * tp)774 static inline int tcp_is_sack(const struct tcp_sock *tp)
775 {
776 	return tp->rx_opt.sack_ok;
777 }
778 
tcp_is_reno(const struct tcp_sock * tp)779 static inline int tcp_is_reno(const struct tcp_sock *tp)
780 {
781 	return !tcp_is_sack(tp);
782 }
783 
tcp_is_fack(const struct tcp_sock * tp)784 static inline int tcp_is_fack(const struct tcp_sock *tp)
785 {
786 	return tp->rx_opt.sack_ok & TCP_FACK_ENABLED;
787 }
788 
tcp_enable_fack(struct tcp_sock * tp)789 static inline void tcp_enable_fack(struct tcp_sock *tp)
790 {
791 	tp->rx_opt.sack_ok |= TCP_FACK_ENABLED;
792 }
793 
tcp_left_out(const struct tcp_sock * tp)794 static inline unsigned int tcp_left_out(const struct tcp_sock *tp)
795 {
796 	return tp->sacked_out + tp->lost_out;
797 }
798 
799 /* This determines how many packets are "in the network" to the best
800  * of our knowledge.  In many cases it is conservative, but where
801  * detailed information is available from the receiver (via SACK
802  * blocks etc.) we can make more aggressive calculations.
803  *
804  * Use this for decisions involving congestion control, use just
805  * tp->packets_out to determine if the send queue is empty or not.
806  *
807  * Read this equation as:
808  *
809  *	"Packets sent once on transmission queue" MINUS
810  *	"Packets left network, but not honestly ACKed yet" PLUS
811  *	"Packets fast retransmitted"
812  */
tcp_packets_in_flight(const struct tcp_sock * tp)813 static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
814 {
815 	return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
816 }
817 
818 #define TCP_INFINITE_SSTHRESH	0x7fffffff
819 
tcp_in_initial_slowstart(const struct tcp_sock * tp)820 static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp)
821 {
822 	return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;
823 }
824 
825 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
826  * The exception is rate halving phase, when cwnd is decreasing towards
827  * ssthresh.
828  */
tcp_current_ssthresh(const struct sock * sk)829 static inline __u32 tcp_current_ssthresh(const struct sock *sk)
830 {
831 	const struct tcp_sock *tp = tcp_sk(sk);
832 
833 	if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery))
834 		return tp->snd_ssthresh;
835 	else
836 		return max(tp->snd_ssthresh,
837 			   ((tp->snd_cwnd >> 1) +
838 			    (tp->snd_cwnd >> 2)));
839 }
840 
841 /* Use define here intentionally to get WARN_ON location shown at the caller */
842 #define tcp_verify_left_out(tp)	WARN_ON(tcp_left_out(tp) > tp->packets_out)
843 
844 extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh);
845 extern __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst);
846 
847 /* The maximum number of MSS of available cwnd for which TSO defers
848  * sending if not using sysctl_tcp_tso_win_divisor.
849  */
tcp_max_tso_deferred_mss(const struct tcp_sock * tp)850 static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp)
851 {
852 	return 3;
853 }
854 
855 /* Slow start with delack produces 3 packets of burst, so that
856  * it is safe "de facto".  This will be the default - same as
857  * the default reordering threshold - but if reordering increases,
858  * we must be able to allow cwnd to burst at least this much in order
859  * to not pull it back when holes are filled.
860  */
tcp_max_burst(const struct tcp_sock * tp)861 static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
862 {
863 	return tp->reordering;
864 }
865 
866 /* Returns end sequence number of the receiver's advertised window */
tcp_wnd_end(const struct tcp_sock * tp)867 static inline u32 tcp_wnd_end(const struct tcp_sock *tp)
868 {
869 	return tp->snd_una + tp->snd_wnd;
870 }
871 extern int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight);
872 
tcp_minshall_update(struct tcp_sock * tp,unsigned int mss,const struct sk_buff * skb)873 static inline void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss,
874 				       const struct sk_buff *skb)
875 {
876 	if (skb->len < mss)
877 		tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
878 }
879 
tcp_check_probe_timer(struct sock * sk)880 static inline void tcp_check_probe_timer(struct sock *sk)
881 {
882 	const struct tcp_sock *tp = tcp_sk(sk);
883 	const struct inet_connection_sock *icsk = inet_csk(sk);
884 
885 	if (!tp->packets_out && !icsk->icsk_pending)
886 		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
887 					  icsk->icsk_rto, TCP_RTO_MAX);
888 }
889 
tcp_init_wl(struct tcp_sock * tp,u32 seq)890 static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq)
891 {
892 	tp->snd_wl1 = seq;
893 }
894 
tcp_update_wl(struct tcp_sock * tp,u32 seq)895 static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq)
896 {
897 	tp->snd_wl1 = seq;
898 }
899 
900 /*
901  * Calculate(/check) TCP checksum
902  */
tcp_v4_check(int len,__be32 saddr,__be32 daddr,__wsum base)903 static inline __sum16 tcp_v4_check(int len, __be32 saddr,
904 				   __be32 daddr, __wsum base)
905 {
906 	return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
907 }
908 
__tcp_checksum_complete(struct sk_buff * skb)909 static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb)
910 {
911 	return __skb_checksum_complete(skb);
912 }
913 
tcp_checksum_complete(struct sk_buff * skb)914 static inline int tcp_checksum_complete(struct sk_buff *skb)
915 {
916 	return !skb_csum_unnecessary(skb) &&
917 		__tcp_checksum_complete(skb);
918 }
919 
920 /* Prequeue for VJ style copy to user, combined with checksumming. */
921 
tcp_prequeue_init(struct tcp_sock * tp)922 static inline void tcp_prequeue_init(struct tcp_sock *tp)
923 {
924 	tp->ucopy.task = NULL;
925 	tp->ucopy.len = 0;
926 	tp->ucopy.memory = 0;
927 	skb_queue_head_init(&tp->ucopy.prequeue);
928 #ifdef CONFIG_NET_DMA
929 	tp->ucopy.dma_chan = NULL;
930 	tp->ucopy.wakeup = 0;
931 	tp->ucopy.pinned_list = NULL;
932 	tp->ucopy.dma_cookie = 0;
933 #endif
934 }
935 
936 /* Packet is added to VJ-style prequeue for processing in process
937  * context, if a reader task is waiting. Apparently, this exciting
938  * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
939  * failed somewhere. Latency? Burstiness? Well, at least now we will
940  * see, why it failed. 8)8)				  --ANK
941  *
942  * NOTE: is this not too big to inline?
943  */
tcp_prequeue(struct sock * sk,struct sk_buff * skb)944 static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
945 {
946 	struct tcp_sock *tp = tcp_sk(sk);
947 
948 	if (sysctl_tcp_low_latency || !tp->ucopy.task)
949 		return 0;
950 
951 	skb_dst_force(skb);
952 	__skb_queue_tail(&tp->ucopy.prequeue, skb);
953 	tp->ucopy.memory += skb->truesize;
954 	if (tp->ucopy.memory > sk->sk_rcvbuf) {
955 		struct sk_buff *skb1;
956 
957 		BUG_ON(sock_owned_by_user(sk));
958 
959 		while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
960 			sk_backlog_rcv(sk, skb1);
961 			NET_INC_STATS_BH(sock_net(sk),
962 					 LINUX_MIB_TCPPREQUEUEDROPPED);
963 		}
964 
965 		tp->ucopy.memory = 0;
966 	} else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
967 		wake_up_interruptible_sync_poll(sk_sleep(sk),
968 					   POLLIN | POLLRDNORM | POLLRDBAND);
969 		if (!inet_csk_ack_scheduled(sk))
970 			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
971 						  (3 * tcp_rto_min(sk)) / 4,
972 						  TCP_RTO_MAX);
973 	}
974 	return 1;
975 }
976 
977 
978 #undef STATE_TRACE
979 
980 #ifdef STATE_TRACE
981 static const char *statename[]={
982 	"Unused","Established","Syn Sent","Syn Recv",
983 	"Fin Wait 1","Fin Wait 2","Time Wait", "Close",
984 	"Close Wait","Last ACK","Listen","Closing"
985 };
986 #endif
987 extern void tcp_set_state(struct sock *sk, int state);
988 
989 extern void tcp_done(struct sock *sk);
990 
tcp_sack_reset(struct tcp_options_received * rx_opt)991 static inline void tcp_sack_reset(struct tcp_options_received *rx_opt)
992 {
993 	rx_opt->dsack = 0;
994 	rx_opt->num_sacks = 0;
995 }
996 
997 /* Determine a window scaling and initial window to offer. */
998 extern void tcp_select_initial_window(int __space, __u32 mss,
999 				      __u32 *rcv_wnd, __u32 *window_clamp,
1000 				      int wscale_ok, __u8 *rcv_wscale,
1001 				      __u32 init_rcv_wnd);
1002 
tcp_win_from_space(int space)1003 static inline int tcp_win_from_space(int space)
1004 {
1005 	return sysctl_tcp_adv_win_scale<=0 ?
1006 		(space>>(-sysctl_tcp_adv_win_scale)) :
1007 		space - (space>>sysctl_tcp_adv_win_scale);
1008 }
1009 
1010 /* Note: caller must be prepared to deal with negative returns */
tcp_space(const struct sock * sk)1011 static inline int tcp_space(const struct sock *sk)
1012 {
1013 	return tcp_win_from_space(sk->sk_rcvbuf -
1014 				  atomic_read(&sk->sk_rmem_alloc));
1015 }
1016 
tcp_full_space(const struct sock * sk)1017 static inline int tcp_full_space(const struct sock *sk)
1018 {
1019 	return tcp_win_from_space(sk->sk_rcvbuf);
1020 }
1021 
tcp_openreq_init(struct request_sock * req,struct tcp_options_received * rx_opt,struct sk_buff * skb)1022 static inline void tcp_openreq_init(struct request_sock *req,
1023 				    struct tcp_options_received *rx_opt,
1024 				    struct sk_buff *skb)
1025 {
1026 	struct inet_request_sock *ireq = inet_rsk(req);
1027 
1028 	req->rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
1029 	req->cookie_ts = 0;
1030 	tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1031 	req->mss = rx_opt->mss_clamp;
1032 	req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
1033 	ireq->tstamp_ok = rx_opt->tstamp_ok;
1034 	ireq->sack_ok = rx_opt->sack_ok;
1035 	ireq->snd_wscale = rx_opt->snd_wscale;
1036 	ireq->wscale_ok = rx_opt->wscale_ok;
1037 	ireq->acked = 0;
1038 	ireq->ecn_ok = 0;
1039 	ireq->rmt_port = tcp_hdr(skb)->source;
1040 	ireq->loc_port = tcp_hdr(skb)->dest;
1041 }
1042 
1043 extern void tcp_enter_memory_pressure(struct sock *sk);
1044 
keepalive_intvl_when(const struct tcp_sock * tp)1045 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1046 {
1047 	return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1048 }
1049 
keepalive_time_when(const struct tcp_sock * tp)1050 static inline int keepalive_time_when(const struct tcp_sock *tp)
1051 {
1052 	return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1053 }
1054 
keepalive_probes(const struct tcp_sock * tp)1055 static inline int keepalive_probes(const struct tcp_sock *tp)
1056 {
1057 	return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes;
1058 }
1059 
keepalive_time_elapsed(const struct tcp_sock * tp)1060 static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)
1061 {
1062 	const struct inet_connection_sock *icsk = &tp->inet_conn;
1063 
1064 	return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime,
1065 			  tcp_time_stamp - tp->rcv_tstamp);
1066 }
1067 
tcp_fin_time(const struct sock * sk)1068 static inline int tcp_fin_time(const struct sock *sk)
1069 {
1070 	int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
1071 	const int rto = inet_csk(sk)->icsk_rto;
1072 
1073 	if (fin_timeout < (rto << 2) - (rto >> 1))
1074 		fin_timeout = (rto << 2) - (rto >> 1);
1075 
1076 	return fin_timeout;
1077 }
1078 
tcp_paws_check(const struct tcp_options_received * rx_opt,int paws_win)1079 static inline int tcp_paws_check(const struct tcp_options_received *rx_opt,
1080 				 int paws_win)
1081 {
1082 	if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win)
1083 		return 1;
1084 	if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS))
1085 		return 1;
1086 	/*
1087 	 * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0,
1088 	 * then following tcp messages have valid values. Ignore 0 value,
1089 	 * or else 'negative' tsval might forbid us to accept their packets.
1090 	 */
1091 	if (!rx_opt->ts_recent)
1092 		return 1;
1093 	return 0;
1094 }
1095 
tcp_paws_reject(const struct tcp_options_received * rx_opt,int rst)1096 static inline int tcp_paws_reject(const struct tcp_options_received *rx_opt,
1097 				  int rst)
1098 {
1099 	if (tcp_paws_check(rx_opt, 0))
1100 		return 0;
1101 
1102 	/* RST segments are not recommended to carry timestamp,
1103 	   and, if they do, it is recommended to ignore PAWS because
1104 	   "their cleanup function should take precedence over timestamps."
1105 	   Certainly, it is mistake. It is necessary to understand the reasons
1106 	   of this constraint to relax it: if peer reboots, clock may go
1107 	   out-of-sync and half-open connections will not be reset.
1108 	   Actually, the problem would be not existing if all
1109 	   the implementations followed draft about maintaining clock
1110 	   via reboots. Linux-2.2 DOES NOT!
1111 
1112 	   However, we can relax time bounds for RST segments to MSL.
1113 	 */
1114 	if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1115 		return 0;
1116 	return 1;
1117 }
1118 
tcp_mib_init(struct net * net)1119 static inline void tcp_mib_init(struct net *net)
1120 {
1121 	/* See RFC 2012 */
1122 	TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1);
1123 	TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1124 	TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1125 	TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1);
1126 }
1127 
1128 /* from STCP */
tcp_clear_retrans_hints_partial(struct tcp_sock * tp)1129 static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp)
1130 {
1131 	tp->lost_skb_hint = NULL;
1132 	tp->scoreboard_skb_hint = NULL;
1133 }
1134 
tcp_clear_all_retrans_hints(struct tcp_sock * tp)1135 static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)
1136 {
1137 	tcp_clear_retrans_hints_partial(tp);
1138 	tp->retransmit_skb_hint = NULL;
1139 }
1140 
1141 /* MD5 Signature */
1142 struct crypto_hash;
1143 
1144 union tcp_md5_addr {
1145 	struct in_addr  a4;
1146 #if IS_ENABLED(CONFIG_IPV6)
1147 	struct in6_addr	a6;
1148 #endif
1149 };
1150 
1151 /* - key database */
1152 struct tcp_md5sig_key {
1153 	struct hlist_node	node;
1154 	u8			keylen;
1155 	u8			family; /* AF_INET or AF_INET6 */
1156 	union tcp_md5_addr	addr;
1157 	u8			key[TCP_MD5SIG_MAXKEYLEN];
1158 	struct rcu_head		rcu;
1159 };
1160 
1161 /* - sock block */
1162 struct tcp_md5sig_info {
1163 	struct hlist_head	head;
1164 	struct rcu_head		rcu;
1165 };
1166 
1167 /* - pseudo header */
1168 struct tcp4_pseudohdr {
1169 	__be32		saddr;
1170 	__be32		daddr;
1171 	__u8		pad;
1172 	__u8		protocol;
1173 	__be16		len;
1174 };
1175 
1176 struct tcp6_pseudohdr {
1177 	struct in6_addr	saddr;
1178 	struct in6_addr daddr;
1179 	__be32		len;
1180 	__be32		protocol;	/* including padding */
1181 };
1182 
1183 union tcp_md5sum_block {
1184 	struct tcp4_pseudohdr ip4;
1185 #if IS_ENABLED(CONFIG_IPV6)
1186 	struct tcp6_pseudohdr ip6;
1187 #endif
1188 };
1189 
1190 /* - pool: digest algorithm, hash description and scratch buffer */
1191 struct tcp_md5sig_pool {
1192 	struct hash_desc	md5_desc;
1193 	union tcp_md5sum_block	md5_blk;
1194 };
1195 
1196 /* - functions */
1197 extern int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1198 			       const struct sock *sk,
1199 			       const struct request_sock *req,
1200 			       const struct sk_buff *skb);
1201 extern int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
1202 			  int family, const u8 *newkey,
1203 			  u8 newkeylen, gfp_t gfp);
1204 extern int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr,
1205 			  int family);
1206 extern struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
1207 					 struct sock *addr_sk);
1208 
1209 #ifdef CONFIG_TCP_MD5SIG
1210 extern struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
1211 			const union tcp_md5_addr *addr, int family);
1212 #define tcp_twsk_md5_key(twsk)	((twsk)->tw_md5_key)
1213 #else
tcp_md5_do_lookup(struct sock * sk,const union tcp_md5_addr * addr,int family)1214 static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
1215 					 const union tcp_md5_addr *addr,
1216 					 int family)
1217 {
1218 	return NULL;
1219 }
1220 #define tcp_twsk_md5_key(twsk)	NULL
1221 #endif
1222 
1223 extern struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *);
1224 extern void tcp_free_md5sig_pool(void);
1225 
1226 extern struct tcp_md5sig_pool	*tcp_get_md5sig_pool(void);
1227 extern void tcp_put_md5sig_pool(void);
1228 
1229 extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *);
1230 extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *,
1231 				 unsigned header_len);
1232 extern int tcp_md5_hash_key(struct tcp_md5sig_pool *hp,
1233 			    const struct tcp_md5sig_key *key);
1234 
1235 /* write queue abstraction */
tcp_write_queue_purge(struct sock * sk)1236 static inline void tcp_write_queue_purge(struct sock *sk)
1237 {
1238 	struct sk_buff *skb;
1239 
1240 	while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL)
1241 		sk_wmem_free_skb(sk, skb);
1242 	sk_mem_reclaim(sk);
1243 	tcp_clear_all_retrans_hints(tcp_sk(sk));
1244 }
1245 
tcp_write_queue_head(const struct sock * sk)1246 static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk)
1247 {
1248 	return skb_peek(&sk->sk_write_queue);
1249 }
1250 
tcp_write_queue_tail(const struct sock * sk)1251 static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk)
1252 {
1253 	return skb_peek_tail(&sk->sk_write_queue);
1254 }
1255 
tcp_write_queue_next(const struct sock * sk,const struct sk_buff * skb)1256 static inline struct sk_buff *tcp_write_queue_next(const struct sock *sk,
1257 						   const struct sk_buff *skb)
1258 {
1259 	return skb_queue_next(&sk->sk_write_queue, skb);
1260 }
1261 
tcp_write_queue_prev(const struct sock * sk,const struct sk_buff * skb)1262 static inline struct sk_buff *tcp_write_queue_prev(const struct sock *sk,
1263 						   const struct sk_buff *skb)
1264 {
1265 	return skb_queue_prev(&sk->sk_write_queue, skb);
1266 }
1267 
1268 #define tcp_for_write_queue(skb, sk)					\
1269 	skb_queue_walk(&(sk)->sk_write_queue, skb)
1270 
1271 #define tcp_for_write_queue_from(skb, sk)				\
1272 	skb_queue_walk_from(&(sk)->sk_write_queue, skb)
1273 
1274 #define tcp_for_write_queue_from_safe(skb, tmp, sk)			\
1275 	skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp)
1276 
tcp_send_head(const struct sock * sk)1277 static inline struct sk_buff *tcp_send_head(const struct sock *sk)
1278 {
1279 	return sk->sk_send_head;
1280 }
1281 
tcp_skb_is_last(const struct sock * sk,const struct sk_buff * skb)1282 static inline bool tcp_skb_is_last(const struct sock *sk,
1283 				   const struct sk_buff *skb)
1284 {
1285 	return skb_queue_is_last(&sk->sk_write_queue, skb);
1286 }
1287 
tcp_advance_send_head(struct sock * sk,const struct sk_buff * skb)1288 static inline void tcp_advance_send_head(struct sock *sk, const struct sk_buff *skb)
1289 {
1290 	if (tcp_skb_is_last(sk, skb))
1291 		sk->sk_send_head = NULL;
1292 	else
1293 		sk->sk_send_head = tcp_write_queue_next(sk, skb);
1294 }
1295 
tcp_check_send_head(struct sock * sk,struct sk_buff * skb_unlinked)1296 static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked)
1297 {
1298 	if (sk->sk_send_head == skb_unlinked)
1299 		sk->sk_send_head = NULL;
1300 }
1301 
tcp_init_send_head(struct sock * sk)1302 static inline void tcp_init_send_head(struct sock *sk)
1303 {
1304 	sk->sk_send_head = NULL;
1305 }
1306 
__tcp_add_write_queue_tail(struct sock * sk,struct sk_buff * skb)1307 static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)
1308 {
1309 	__skb_queue_tail(&sk->sk_write_queue, skb);
1310 }
1311 
tcp_add_write_queue_tail(struct sock * sk,struct sk_buff * skb)1312 static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)
1313 {
1314 	__tcp_add_write_queue_tail(sk, skb);
1315 
1316 	/* Queue it, remembering where we must start sending. */
1317 	if (sk->sk_send_head == NULL) {
1318 		sk->sk_send_head = skb;
1319 
1320 		if (tcp_sk(sk)->highest_sack == NULL)
1321 			tcp_sk(sk)->highest_sack = skb;
1322 	}
1323 }
1324 
__tcp_add_write_queue_head(struct sock * sk,struct sk_buff * skb)1325 static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb)
1326 {
1327 	__skb_queue_head(&sk->sk_write_queue, skb);
1328 }
1329 
1330 /* Insert buff after skb on the write queue of sk.  */
tcp_insert_write_queue_after(struct sk_buff * skb,struct sk_buff * buff,struct sock * sk)1331 static inline void tcp_insert_write_queue_after(struct sk_buff *skb,
1332 						struct sk_buff *buff,
1333 						struct sock *sk)
1334 {
1335 	__skb_queue_after(&sk->sk_write_queue, skb, buff);
1336 }
1337 
1338 /* Insert new before skb on the write queue of sk.  */
tcp_insert_write_queue_before(struct sk_buff * new,struct sk_buff * skb,struct sock * sk)1339 static inline void tcp_insert_write_queue_before(struct sk_buff *new,
1340 						  struct sk_buff *skb,
1341 						  struct sock *sk)
1342 {
1343 	__skb_queue_before(&sk->sk_write_queue, skb, new);
1344 
1345 	if (sk->sk_send_head == skb)
1346 		sk->sk_send_head = new;
1347 }
1348 
tcp_unlink_write_queue(struct sk_buff * skb,struct sock * sk)1349 static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk)
1350 {
1351 	__skb_unlink(skb, &sk->sk_write_queue);
1352 }
1353 
tcp_write_queue_empty(struct sock * sk)1354 static inline int tcp_write_queue_empty(struct sock *sk)
1355 {
1356 	return skb_queue_empty(&sk->sk_write_queue);
1357 }
1358 
tcp_push_pending_frames(struct sock * sk)1359 static inline void tcp_push_pending_frames(struct sock *sk)
1360 {
1361 	if (tcp_send_head(sk)) {
1362 		struct tcp_sock *tp = tcp_sk(sk);
1363 
1364 		__tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle);
1365 	}
1366 }
1367 
1368 /* Start sequence of the skb just after the highest skb with SACKed
1369  * bit, valid only if sacked_out > 0 or when the caller has ensured
1370  * validity by itself.
1371  */
tcp_highest_sack_seq(struct tcp_sock * tp)1372 static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp)
1373 {
1374 	if (!tp->sacked_out)
1375 		return tp->snd_una;
1376 
1377 	if (tp->highest_sack == NULL)
1378 		return tp->snd_nxt;
1379 
1380 	return TCP_SKB_CB(tp->highest_sack)->seq;
1381 }
1382 
tcp_advance_highest_sack(struct sock * sk,struct sk_buff * skb)1383 static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb)
1384 {
1385 	tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL :
1386 						tcp_write_queue_next(sk, skb);
1387 }
1388 
tcp_highest_sack(struct sock * sk)1389 static inline struct sk_buff *tcp_highest_sack(struct sock *sk)
1390 {
1391 	return tcp_sk(sk)->highest_sack;
1392 }
1393 
tcp_highest_sack_reset(struct sock * sk)1394 static inline void tcp_highest_sack_reset(struct sock *sk)
1395 {
1396 	tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk);
1397 }
1398 
1399 /* Called when old skb is about to be deleted (to be combined with new skb) */
tcp_highest_sack_combine(struct sock * sk,struct sk_buff * old,struct sk_buff * new)1400 static inline void tcp_highest_sack_combine(struct sock *sk,
1401 					    struct sk_buff *old,
1402 					    struct sk_buff *new)
1403 {
1404 	if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack))
1405 		tcp_sk(sk)->highest_sack = new;
1406 }
1407 
1408 /* Determines whether this is a thin stream (which may suffer from
1409  * increased latency). Used to trigger latency-reducing mechanisms.
1410  */
tcp_stream_is_thin(struct tcp_sock * tp)1411 static inline unsigned int tcp_stream_is_thin(struct tcp_sock *tp)
1412 {
1413 	return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp);
1414 }
1415 
1416 /* /proc */
1417 enum tcp_seq_states {
1418 	TCP_SEQ_STATE_LISTENING,
1419 	TCP_SEQ_STATE_OPENREQ,
1420 	TCP_SEQ_STATE_ESTABLISHED,
1421 	TCP_SEQ_STATE_TIME_WAIT,
1422 };
1423 
1424 int tcp_seq_open(struct inode *inode, struct file *file);
1425 
1426 struct tcp_seq_afinfo {
1427 	char				*name;
1428 	sa_family_t			family;
1429 	const struct file_operations	*seq_fops;
1430 	struct seq_operations		seq_ops;
1431 };
1432 
1433 struct tcp_iter_state {
1434 	struct seq_net_private	p;
1435 	sa_family_t		family;
1436 	enum tcp_seq_states	state;
1437 	struct sock		*syn_wait_sk;
1438 	int			bucket, offset, sbucket, num, uid;
1439 	loff_t			last_pos;
1440 };
1441 
1442 extern int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo);
1443 extern void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo);
1444 
1445 extern struct request_sock_ops tcp_request_sock_ops;
1446 extern struct request_sock_ops tcp6_request_sock_ops;
1447 
1448 extern void tcp_v4_destroy_sock(struct sock *sk);
1449 
1450 extern int tcp_v4_gso_send_check(struct sk_buff *skb);
1451 extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb,
1452 				       netdev_features_t features);
1453 extern struct sk_buff **tcp_gro_receive(struct sk_buff **head,
1454 					struct sk_buff *skb);
1455 extern struct sk_buff **tcp4_gro_receive(struct sk_buff **head,
1456 					 struct sk_buff *skb);
1457 extern int tcp_gro_complete(struct sk_buff *skb);
1458 extern int tcp4_gro_complete(struct sk_buff *skb);
1459 
1460 #ifdef CONFIG_PROC_FS
1461 extern int tcp4_proc_init(void);
1462 extern void tcp4_proc_exit(void);
1463 #endif
1464 
1465 /* TCP af-specific functions */
1466 struct tcp_sock_af_ops {
1467 #ifdef CONFIG_TCP_MD5SIG
1468 	struct tcp_md5sig_key	*(*md5_lookup) (struct sock *sk,
1469 						struct sock *addr_sk);
1470 	int			(*calc_md5_hash) (char *location,
1471 						  struct tcp_md5sig_key *md5,
1472 						  const struct sock *sk,
1473 						  const struct request_sock *req,
1474 						  const struct sk_buff *skb);
1475 	int			(*md5_parse) (struct sock *sk,
1476 					      char __user *optval,
1477 					      int optlen);
1478 #endif
1479 };
1480 
1481 struct tcp_request_sock_ops {
1482 #ifdef CONFIG_TCP_MD5SIG
1483 	struct tcp_md5sig_key	*(*md5_lookup) (struct sock *sk,
1484 						struct request_sock *req);
1485 	int			(*calc_md5_hash) (char *location,
1486 						  struct tcp_md5sig_key *md5,
1487 						  const struct sock *sk,
1488 						  const struct request_sock *req,
1489 						  const struct sk_buff *skb);
1490 #endif
1491 };
1492 
1493 /* Using SHA1 for now, define some constants.
1494  */
1495 #define COOKIE_DIGEST_WORDS (SHA_DIGEST_WORDS)
1496 #define COOKIE_MESSAGE_WORDS (SHA_MESSAGE_BYTES / 4)
1497 #define COOKIE_WORKSPACE_WORDS (COOKIE_DIGEST_WORDS + COOKIE_MESSAGE_WORDS)
1498 
1499 extern int tcp_cookie_generator(u32 *bakery);
1500 
1501 /**
1502  *	struct tcp_cookie_values - each socket needs extra space for the
1503  *	cookies, together with (optional) space for any SYN data.
1504  *
1505  *	A tcp_sock contains a pointer to the current value, and this is
1506  *	cloned to the tcp_timewait_sock.
1507  *
1508  * @cookie_pair:	variable data from the option exchange.
1509  *
1510  * @cookie_desired:	user specified tcpct_cookie_desired.  Zero
1511  *			indicates default (sysctl_tcp_cookie_size).
1512  *			After cookie sent, remembers size of cookie.
1513  *			Range 0, TCP_COOKIE_MIN to TCP_COOKIE_MAX.
1514  *
1515  * @s_data_desired:	user specified tcpct_s_data_desired.  When the
1516  *			constant payload is specified (@s_data_constant),
1517  *			holds its length instead.
1518  *			Range 0 to TCP_MSS_DESIRED.
1519  *
1520  * @s_data_payload:	constant data that is to be included in the
1521  *			payload of SYN or SYNACK segments when the
1522  *			cookie option is present.
1523  */
1524 struct tcp_cookie_values {
1525 	struct kref	kref;
1526 	u8		cookie_pair[TCP_COOKIE_PAIR_SIZE];
1527 	u8		cookie_pair_size;
1528 	u8		cookie_desired;
1529 	u16		s_data_desired:11,
1530 			s_data_constant:1,
1531 			s_data_in:1,
1532 			s_data_out:1,
1533 			s_data_unused:2;
1534 	u8		s_data_payload[0];
1535 };
1536 
tcp_cookie_values_release(struct kref * kref)1537 static inline void tcp_cookie_values_release(struct kref *kref)
1538 {
1539 	kfree(container_of(kref, struct tcp_cookie_values, kref));
1540 }
1541 
1542 /* The length of constant payload data.  Note that s_data_desired is
1543  * overloaded, depending on s_data_constant: either the length of constant
1544  * data (returned here) or the limit on variable data.
1545  */
tcp_s_data_size(const struct tcp_sock * tp)1546 static inline int tcp_s_data_size(const struct tcp_sock *tp)
1547 {
1548 	return (tp->cookie_values != NULL && tp->cookie_values->s_data_constant)
1549 		? tp->cookie_values->s_data_desired
1550 		: 0;
1551 }
1552 
1553 /**
1554  *	struct tcp_extend_values - tcp_ipv?.c to tcp_output.c workspace.
1555  *
1556  *	As tcp_request_sock has already been extended in other places, the
1557  *	only remaining method is to pass stack values along as function
1558  *	parameters.  These parameters are not needed after sending SYNACK.
1559  *
1560  * @cookie_bakery:	cryptographic secret and message workspace.
1561  *
1562  * @cookie_plus:	bytes in authenticator/cookie option, copied from
1563  *			struct tcp_options_received (above).
1564  */
1565 struct tcp_extend_values {
1566 	struct request_values		rv;
1567 	u32				cookie_bakery[COOKIE_WORKSPACE_WORDS];
1568 	u8				cookie_plus:6,
1569 					cookie_out_never:1,
1570 					cookie_in_always:1;
1571 };
1572 
tcp_xv(struct request_values * rvp)1573 static inline struct tcp_extend_values *tcp_xv(struct request_values *rvp)
1574 {
1575 	return (struct tcp_extend_values *)rvp;
1576 }
1577 
1578 extern void tcp_v4_init(void);
1579 extern void tcp_init(void);
1580 
1581 #endif	/* _TCP_H */
1582