11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * INET An implementation of the TCP/IP protocol suite for the LINUX 31da177e4SLinus Torvalds * operating system. INET is implemented using the BSD Socket 41da177e4SLinus Torvalds * interface as the means of communication with the user level. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Definitions for the TCP module. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Version: @(#)tcp.h 1.0.5 05/23/93 91da177e4SLinus Torvalds * 1002c30a84SJesper Juhl * Authors: Ross Biro 111da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 141da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 151da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 161da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds #ifndef _TCP_H 191da177e4SLinus Torvalds #define _TCP_H 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds #define FASTRETRANS_DEBUG 1 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds #include <linux/list.h> 241da177e4SLinus Torvalds #include <linux/tcp.h> 251da177e4SLinus Torvalds #include <linux/slab.h> 261da177e4SLinus Torvalds #include <linux/cache.h> 271da177e4SLinus Torvalds #include <linux/percpu.h> 28fb286bb2SHerbert Xu #include <linux/skbuff.h> 2997fc2f08SChris Leech #include <linux/dmaengine.h> 30cfb6eeb4SYOSHIFUJI Hideaki #include <linux/crypto.h> 31c6aefafbSGlenn Griffin #include <linux/cryptohash.h> 32435cf559SWilliam Allen Simpson #include <linux/kref.h> 333f421baaSArnaldo Carvalho de Melo 343f421baaSArnaldo Carvalho de Melo #include <net/inet_connection_sock.h> 35295ff7edSArnaldo Carvalho de Melo #include <net/inet_timewait_sock.h> 3677d8bf9cSArnaldo Carvalho de Melo #include <net/inet_hashtables.h> 371da177e4SLinus Torvalds #include <net/checksum.h> 382e6599cbSArnaldo Carvalho de Melo #include <net/request_sock.h> 391da177e4SLinus Torvalds #include <net/sock.h> 401da177e4SLinus Torvalds #include <net/snmp.h> 411da177e4SLinus Torvalds #include <net/ip.h> 42c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h> 43bdf1ee5dSIlpo Järvinen #include <net/inet_ecn.h> 440c266898SSatoru SATOH #include <net/dst.h> 45c752f073SArnaldo Carvalho de Melo 461da177e4SLinus Torvalds #include <linux/seq_file.h> 471da177e4SLinus Torvalds 480f7ff927SArnaldo Carvalho de Melo extern struct inet_hashinfo tcp_hashinfo; 491da177e4SLinus Torvalds 50dd24c001SEric Dumazet extern struct percpu_counter tcp_orphan_count; 511da177e4SLinus Torvalds extern void tcp_time_wait(struct sock *sk, int state, int timeo); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #define MAX_TCP_HEADER (128 + MAX_HEADER) 5433ad798cSAdam Langley #define MAX_TCP_OPTION_SPACE 40 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* 571da177e4SLinus Torvalds * Never offer a window over 32767 without using window scaling. Some 581da177e4SLinus Torvalds * poor stacks do signed 16bit maths! 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds #define MAX_TCP_WINDOW 32767U 611da177e4SLinus Torvalds 62356f0398SNandita Dukkipati /* Offer an initial receive window of 10 mss. */ 63356f0398SNandita Dukkipati #define TCP_DEFAULT_INIT_RCVWND 10 64356f0398SNandita Dukkipati 651da177e4SLinus Torvalds /* Minimal accepted MSS. It is (60+60+8) - (20+20). */ 661da177e4SLinus Torvalds #define TCP_MIN_MSS 88U 671da177e4SLinus Torvalds 685d424d5aSJohn Heffner /* The least MTU to use for probing */ 695d424d5aSJohn Heffner #define TCP_BASE_MSS 512 705d424d5aSJohn Heffner 711da177e4SLinus Torvalds /* After receiving this amount of duplicate ACKs fast retransmit starts. */ 721da177e4SLinus Torvalds #define TCP_FASTRETRANS_THRESH 3 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* Maximal reordering. */ 751da177e4SLinus Torvalds #define TCP_MAX_REORDERING 127 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* Maximal number of ACKs sent quickly to accelerate slow-start. */ 781da177e4SLinus Torvalds #define TCP_MAX_QUICKACKS 16U 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds /* urg_data states */ 811da177e4SLinus Torvalds #define TCP_URG_VALID 0x0100 821da177e4SLinus Torvalds #define TCP_URG_NOTYET 0x0200 831da177e4SLinus Torvalds #define TCP_URG_READ 0x0400 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds #define TCP_RETR1 3 /* 861da177e4SLinus Torvalds * This is how many retries it does before it 871da177e4SLinus Torvalds * tries to figure out if the gateway is 881da177e4SLinus Torvalds * down. Minimal RFC value is 3; it corresponds 891da177e4SLinus Torvalds * to ~3sec-8min depending on RTO. 901da177e4SLinus Torvalds */ 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #define TCP_RETR2 15 /* 931da177e4SLinus Torvalds * This should take at least 941da177e4SLinus Torvalds * 90 minutes to time out. 951da177e4SLinus Torvalds * RFC1122 says that the limit is 100 sec. 961da177e4SLinus Torvalds * 15 is ~13-30min depending on RTO. 971da177e4SLinus Torvalds */ 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds #define TCP_SYN_RETRIES 5 /* number of times to retry active opening a 100caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds #define TCP_SYNACK_RETRIES 5 /* number of times to retry passive opening a 103caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT 1061da177e4SLinus Torvalds * state, about 60 seconds */ 1071da177e4SLinus Torvalds #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN 1081da177e4SLinus Torvalds /* BSD style FIN_WAIT2 deadlock breaker. 1091da177e4SLinus Torvalds * It used to be 3min, new value is 60sec, 1101da177e4SLinus Torvalds * to combine FIN-WAIT-2 timeout with 1111da177e4SLinus Torvalds * TIME-WAIT timer. 1121da177e4SLinus Torvalds */ 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds #define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */ 1151da177e4SLinus Torvalds #if HZ >= 100 1161da177e4SLinus Torvalds #define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */ 1171da177e4SLinus Torvalds #define TCP_ATO_MIN ((unsigned)(HZ/25)) 1181da177e4SLinus Torvalds #else 1191da177e4SLinus Torvalds #define TCP_DELACK_MIN 4U 1201da177e4SLinus Torvalds #define TCP_ATO_MIN 4U 1211da177e4SLinus Torvalds #endif 1221da177e4SLinus Torvalds #define TCP_RTO_MAX ((unsigned)(120*HZ)) 1231da177e4SLinus Torvalds #define TCP_RTO_MIN ((unsigned)(HZ/5)) 1249ad7c049SJerry Chu #define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC2988bis initial RTO value */ 1259ad7c049SJerry Chu #define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value, now 1269ad7c049SJerry Chu * used as a fallback RTO for the 1279ad7c049SJerry Chu * initial data transmission if no 1289ad7c049SJerry Chu * valid RTT sample has been acquired, 1299ad7c049SJerry Chu * most likely due to retrans in 3WHS. 1309ad7c049SJerry Chu */ 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes 1331da177e4SLinus Torvalds * for local resources. 1341da177e4SLinus Torvalds */ 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds #define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ 1371da177e4SLinus Torvalds #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ 1381da177e4SLinus Torvalds #define TCP_KEEPALIVE_INTVL (75*HZ) 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds #define MAX_TCP_KEEPIDLE 32767 1411da177e4SLinus Torvalds #define MAX_TCP_KEEPINTVL 32767 1421da177e4SLinus Torvalds #define MAX_TCP_KEEPCNT 127 1431da177e4SLinus Torvalds #define MAX_TCP_SYNCNT 127 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds #define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */ 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24) 1481da177e4SLinus Torvalds #define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated 1491da177e4SLinus Torvalds * after this time. It should be equal 1501da177e4SLinus Torvalds * (or greater than) TCP_TIMEWAIT_LEN 1511da177e4SLinus Torvalds * to provide reliability equal to one 1521da177e4SLinus Torvalds * provided by timewait state. 1531da177e4SLinus Torvalds */ 1541da177e4SLinus Torvalds #define TCP_PAWS_WINDOW 1 /* Replay window for per-host 1551da177e4SLinus Torvalds * timestamps. It must be less than 1561da177e4SLinus Torvalds * minimal timewait lifetime. 1571da177e4SLinus Torvalds */ 1581da177e4SLinus Torvalds /* 1591da177e4SLinus Torvalds * TCP option 1601da177e4SLinus Torvalds */ 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds #define TCPOPT_NOP 1 /* Padding */ 1631da177e4SLinus Torvalds #define TCPOPT_EOL 0 /* End of options */ 1641da177e4SLinus Torvalds #define TCPOPT_MSS 2 /* Segment size negotiating */ 1651da177e4SLinus Torvalds #define TCPOPT_WINDOW 3 /* Window scaling */ 1661da177e4SLinus Torvalds #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ 1671da177e4SLinus Torvalds #define TCPOPT_SACK 5 /* SACK Block */ 1681da177e4SLinus Torvalds #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ 169cfb6eeb4SYOSHIFUJI Hideaki #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ 170435cf559SWilliam Allen Simpson #define TCPOPT_COOKIE 253 /* Cookie extension (experimental) */ 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* 1731da177e4SLinus Torvalds * TCP option lengths 1741da177e4SLinus Torvalds */ 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds #define TCPOLEN_MSS 4 1771da177e4SLinus Torvalds #define TCPOLEN_WINDOW 3 1781da177e4SLinus Torvalds #define TCPOLEN_SACK_PERM 2 1791da177e4SLinus Torvalds #define TCPOLEN_TIMESTAMP 10 180cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG 18 181435cf559SWilliam Allen Simpson #define TCPOLEN_COOKIE_BASE 2 /* Cookie-less header extension */ 182435cf559SWilliam Allen Simpson #define TCPOLEN_COOKIE_PAIR 3 /* Cookie pair header extension */ 183435cf559SWilliam Allen Simpson #define TCPOLEN_COOKIE_MIN (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MIN) 184435cf559SWilliam Allen Simpson #define TCPOLEN_COOKIE_MAX (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MAX) 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds /* But this is what stacks really send out. */ 1871da177e4SLinus Torvalds #define TCPOLEN_TSTAMP_ALIGNED 12 1881da177e4SLinus Torvalds #define TCPOLEN_WSCALE_ALIGNED 4 1891da177e4SLinus Torvalds #define TCPOLEN_SACKPERM_ALIGNED 4 1901da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE 2 1911da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE_ALIGNED 4 1921da177e4SLinus Torvalds #define TCPOLEN_SACK_PERBLOCK 8 193cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG_ALIGNED 20 19433ad798cSAdam Langley #define TCPOLEN_MSS_ALIGNED 4 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds /* Flags in tp->nonagle */ 1971da177e4SLinus Torvalds #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ 1981da177e4SLinus Torvalds #define TCP_NAGLE_CORK 2 /* Socket is corked */ 199caa20d9aSStephen Hemminger #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ 2001da177e4SLinus Torvalds 20136e31b0aSAndreas Petlund /* TCP thin-stream limits */ 20236e31b0aSAndreas Petlund #define TCP_THIN_LINEAR_RETRIES 6 /* After 6 linear retries, do exp. backoff */ 20336e31b0aSAndreas Petlund 2047eb38527SDavid S. Miller /* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */ 205442b9635SDavid S. Miller #define TCP_INIT_CWND 10 206442b9635SDavid S. Miller 207295ff7edSArnaldo Carvalho de Melo extern struct inet_timewait_death_row tcp_death_row; 208295ff7edSArnaldo Carvalho de Melo 2091da177e4SLinus Torvalds /* sysctl variables for tcp */ 2101da177e4SLinus Torvalds extern int sysctl_tcp_timestamps; 2111da177e4SLinus Torvalds extern int sysctl_tcp_window_scaling; 2121da177e4SLinus Torvalds extern int sysctl_tcp_sack; 2131da177e4SLinus Torvalds extern int sysctl_tcp_fin_timeout; 2141da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_time; 2151da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_probes; 2161da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_intvl; 2171da177e4SLinus Torvalds extern int sysctl_tcp_syn_retries; 2181da177e4SLinus Torvalds extern int sysctl_tcp_synack_retries; 2191da177e4SLinus Torvalds extern int sysctl_tcp_retries1; 2201da177e4SLinus Torvalds extern int sysctl_tcp_retries2; 2211da177e4SLinus Torvalds extern int sysctl_tcp_orphan_retries; 2221da177e4SLinus Torvalds extern int sysctl_tcp_syncookies; 2231da177e4SLinus Torvalds extern int sysctl_tcp_retrans_collapse; 2241da177e4SLinus Torvalds extern int sysctl_tcp_stdurg; 2251da177e4SLinus Torvalds extern int sysctl_tcp_rfc1337; 2261da177e4SLinus Torvalds extern int sysctl_tcp_abort_on_overflow; 2271da177e4SLinus Torvalds extern int sysctl_tcp_max_orphans; 2281da177e4SLinus Torvalds extern int sysctl_tcp_fack; 2291da177e4SLinus Torvalds extern int sysctl_tcp_reordering; 2301da177e4SLinus Torvalds extern int sysctl_tcp_ecn; 2311da177e4SLinus Torvalds extern int sysctl_tcp_dsack; 2328d987e5cSEric Dumazet extern long sysctl_tcp_mem[3]; 2331da177e4SLinus Torvalds extern int sysctl_tcp_wmem[3]; 2341da177e4SLinus Torvalds extern int sysctl_tcp_rmem[3]; 2351da177e4SLinus Torvalds extern int sysctl_tcp_app_win; 2361da177e4SLinus Torvalds extern int sysctl_tcp_adv_win_scale; 2371da177e4SLinus Torvalds extern int sysctl_tcp_tw_reuse; 2381da177e4SLinus Torvalds extern int sysctl_tcp_frto; 2393cfe3baaSIlpo Järvinen extern int sysctl_tcp_frto_response; 2401da177e4SLinus Torvalds extern int sysctl_tcp_low_latency; 24195937825SChris Leech extern int sysctl_tcp_dma_copybreak; 2421da177e4SLinus Torvalds extern int sysctl_tcp_nometrics_save; 2431da177e4SLinus Torvalds extern int sysctl_tcp_moderate_rcvbuf; 2441da177e4SLinus Torvalds extern int sysctl_tcp_tso_win_divisor; 2459772efb9SStephen Hemminger extern int sysctl_tcp_abc; 2465d424d5aSJohn Heffner extern int sysctl_tcp_mtu_probing; 2475d424d5aSJohn Heffner extern int sysctl_tcp_base_mss; 24815d99e02SRick Jones extern int sysctl_tcp_workaround_signed_windows; 24935089bb2SDavid S. Miller extern int sysctl_tcp_slow_start_after_idle; 250886236c1SJohn Heffner extern int sysctl_tcp_max_ssthresh; 251519855c5SWilliam Allen Simpson extern int sysctl_tcp_cookie_size; 25236e31b0aSAndreas Petlund extern int sysctl_tcp_thin_linear_timeouts; 2537e380175SAndreas Petlund extern int sysctl_tcp_thin_dupack; 2541da177e4SLinus Torvalds 2558d987e5cSEric Dumazet extern atomic_long_t tcp_memory_allocated; 2561748376bSEric Dumazet extern struct percpu_counter tcp_sockets_allocated; 2571da177e4SLinus Torvalds extern int tcp_memory_pressure; 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds /* 2601da177e4SLinus Torvalds * The next routines deal with comparing 32 bit unsigned ints 2611da177e4SLinus Torvalds * and worry about wraparound (automatic with unsigned arithmetic). 2621da177e4SLinus Torvalds */ 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds static inline int before(__u32 seq1, __u32 seq2) 2651da177e4SLinus Torvalds { 2660d630cc0SGerrit Renker return (__s32)(seq1-seq2) < 0; 2671da177e4SLinus Torvalds } 2689a036b9cSGerrit Renker #define after(seq2, seq1) before(seq1, seq2) 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds /* is s2<=s1<=s3 ? */ 2711da177e4SLinus Torvalds static inline int between(__u32 seq1, __u32 seq2, __u32 seq3) 2721da177e4SLinus Torvalds { 2731da177e4SLinus Torvalds return seq3 - seq2 >= seq1 - seq2; 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 276ad1af0feSDavid S. Miller static inline bool tcp_too_many_orphans(struct sock *sk, int shift) 277e4fd5da3SPavel Emelianov { 278ad1af0feSDavid S. Miller struct percpu_counter *ocp = sk->sk_prot->orphan_count; 279ad1af0feSDavid S. Miller int orphans = percpu_counter_read_positive(ocp); 280ad1af0feSDavid S. Miller 281ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) { 282ad1af0feSDavid S. Miller orphans = percpu_counter_sum_positive(ocp); 283ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) 284ad1af0feSDavid S. Miller return true; 285ad1af0feSDavid S. Miller } 286ad1af0feSDavid S. Miller 287ad1af0feSDavid S. Miller if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && 2888d987e5cSEric Dumazet atomic_long_read(&tcp_memory_allocated) > sysctl_tcp_mem[2]) 289ad1af0feSDavid S. Miller return true; 290ad1af0feSDavid S. Miller return false; 291e4fd5da3SPavel Emelianov } 2921da177e4SLinus Torvalds 293a0f82f64SFlorian Westphal /* syncookies: remember time of last synqueue overflow */ 294a0f82f64SFlorian Westphal static inline void tcp_synq_overflow(struct sock *sk) 295a0f82f64SFlorian Westphal { 296a0f82f64SFlorian Westphal tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies; 297a0f82f64SFlorian Westphal } 298a0f82f64SFlorian Westphal 299a0f82f64SFlorian Westphal /* syncookies: no recent synqueue overflow on this listening socket? */ 300a0f82f64SFlorian Westphal static inline int tcp_synq_no_recent_overflow(const struct sock *sk) 301a0f82f64SFlorian Westphal { 302a0f82f64SFlorian Westphal unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp; 3039ad7c049SJerry Chu return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK); 304a0f82f64SFlorian Westphal } 305a0f82f64SFlorian Westphal 3061da177e4SLinus Torvalds extern struct proto tcp_prot; 3071da177e4SLinus Torvalds 30857ef42d5SPavel Emelyanov #define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field) 30957ef42d5SPavel Emelyanov #define TCP_INC_STATS_BH(net, field) SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field) 31057ef42d5SPavel Emelyanov #define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field) 31157ef42d5SPavel Emelyanov #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val) 312aa2ea058STom Herbert #define TCP_ADD_STATS(net, field, val) SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val) 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds extern void tcp_v4_err(struct sk_buff *skb, u32); 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds extern void tcp_shutdown (struct sock *sk, int how); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds extern int tcp_v4_rcv(struct sk_buff *skb); 3191da177e4SLinus Torvalds 3203f419d2dSDavid S. Miller extern struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it); 321ccb7c410SDavid S. Miller extern void *tcp_v4_tw_get_peer(struct sock *sk); 3228feaf0c0SArnaldo Carvalho de Melo extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw); 3237ba42910SChangli Gao extern int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 3247ba42910SChangli Gao size_t size); 3257ba42910SChangli Gao extern int tcp_sendpage(struct sock *sk, struct page *page, int offset, 32653d3176bSChangli Gao size_t size, int flags); 32753d3176bSChangli Gao extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg); 32853d3176bSChangli Gao extern int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, 329cf533ea5SEric Dumazet const struct tcphdr *th, unsigned int len); 33053d3176bSChangli Gao extern int tcp_rcv_established(struct sock *sk, struct sk_buff *skb, 331cf533ea5SEric Dumazet const struct tcphdr *th, unsigned int len); 3321da177e4SLinus Torvalds extern void tcp_rcv_space_adjust(struct sock *sk); 3330e4b4992SChris Leech extern void tcp_cleanup_rbuf(struct sock *sk, int copied); 33453d3176bSChangli Gao extern int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp); 335cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_twsk_destructor(struct sock *sk); 3369c55e01cSJens Axboe extern ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos, 33753d3176bSChangli Gao struct pipe_inode_info *pipe, size_t len, 33853d3176bSChangli Gao unsigned int flags); 3399c55e01cSJens Axboe 340463c84b9SArnaldo Carvalho de Melo static inline void tcp_dec_quickack_mode(struct sock *sk, 341463c84b9SArnaldo Carvalho de Melo const unsigned int pkts) 3421da177e4SLinus Torvalds { 343463c84b9SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 344fc6415bcSDavid S. Miller 345463c84b9SArnaldo Carvalho de Melo if (icsk->icsk_ack.quick) { 346463c84b9SArnaldo Carvalho de Melo if (pkts >= icsk->icsk_ack.quick) { 347463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick = 0; 3481da177e4SLinus Torvalds /* Leaving quickack mode we deflate ATO. */ 349463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.ato = TCP_ATO_MIN; 350fc6415bcSDavid S. Miller } else 351463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick -= pkts; 3521da177e4SLinus Torvalds } 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds 355bdf1ee5dSIlpo Järvinen #define TCP_ECN_OK 1 356bdf1ee5dSIlpo Järvinen #define TCP_ECN_QUEUE_CWR 2 357bdf1ee5dSIlpo Järvinen #define TCP_ECN_DEMAND_CWR 4 3587a269ffaSEric Dumazet #define TCP_ECN_SEEN 8 359bdf1ee5dSIlpo Järvinen 360bdf1ee5dSIlpo Järvinen static __inline__ void 361bdf1ee5dSIlpo Järvinen TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th) 362bdf1ee5dSIlpo Järvinen { 363bdf1ee5dSIlpo Järvinen if (sysctl_tcp_ecn && th->ece && th->cwr) 364bdf1ee5dSIlpo Järvinen inet_rsk(req)->ecn_ok = 1; 365bdf1ee5dSIlpo Järvinen } 366bdf1ee5dSIlpo Järvinen 367fd2c3ef7SEric Dumazet enum tcp_tw_status { 3681da177e4SLinus Torvalds TCP_TW_SUCCESS = 0, 3691da177e4SLinus Torvalds TCP_TW_RST = 1, 3701da177e4SLinus Torvalds TCP_TW_ACK = 2, 3711da177e4SLinus Torvalds TCP_TW_SYN = 3 3721da177e4SLinus Torvalds }; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds 3758feaf0c0SArnaldo Carvalho de Melo extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw, 3761da177e4SLinus Torvalds struct sk_buff *skb, 3778feaf0c0SArnaldo Carvalho de Melo const struct tcphdr *th); 3781da177e4SLinus Torvalds extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb, 37960236fddSArnaldo Carvalho de Melo struct request_sock *req, 38060236fddSArnaldo Carvalho de Melo struct request_sock **prev); 38153d3176bSChangli Gao extern int tcp_child_process(struct sock *parent, struct sock *child, 3821da177e4SLinus Torvalds struct sk_buff *skb); 38346d0de4eSIlpo Järvinen extern int tcp_use_frto(struct sock *sk); 3841da177e4SLinus Torvalds extern void tcp_enter_frto(struct sock *sk); 3851da177e4SLinus Torvalds extern void tcp_enter_loss(struct sock *sk, int how); 3861da177e4SLinus Torvalds extern void tcp_clear_retrans(struct tcp_sock *tp); 3871da177e4SLinus Torvalds extern void tcp_update_metrics(struct sock *sk); 38853d3176bSChangli Gao extern void tcp_close(struct sock *sk, long timeout); 38953d3176bSChangli Gao extern unsigned int tcp_poll(struct file * file, struct socket *sock, 39053d3176bSChangli Gao struct poll_table_struct *wait); 39153d3176bSChangli Gao extern int tcp_getsockopt(struct sock *sk, int level, int optname, 3923fdadf7dSDmitry Mishin char __user *optval, int __user *optlen); 39353d3176bSChangli Gao extern int tcp_setsockopt(struct sock *sk, int level, int optname, 39453d3176bSChangli Gao char __user *optval, unsigned int optlen); 39553d3176bSChangli Gao extern int compat_tcp_getsockopt(struct sock *sk, int level, int optname, 39653d3176bSChangli Gao char __user *optval, int __user *optlen); 39753d3176bSChangli Gao extern int compat_tcp_setsockopt(struct sock *sk, int level, int optname, 398b7058842SDavid S. Miller char __user *optval, unsigned int optlen); 3991da177e4SLinus Torvalds extern void tcp_set_keepalive(struct sock *sk, int val); 40053d3176bSChangli Gao extern void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req); 40153d3176bSChangli Gao extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 40253d3176bSChangli Gao size_t len, int nonblock, int flags, int *addr_len); 403cf533ea5SEric Dumazet extern void tcp_parse_options(const struct sk_buff *skb, 404cf533ea5SEric Dumazet struct tcp_options_received *opt_rx, const u8 **hvpp, 405bb5b7c11SDavid S. Miller int estab); 406cf533ea5SEric Dumazet extern const u8 *tcp_parse_md5sig_option(const struct tcphdr *th); 4077d5d5525SYOSHIFUJI Hideaki 4081da177e4SLinus Torvalds /* 4091da177e4SLinus Torvalds * TCP v4 functions exported for the inet6 API 4101da177e4SLinus Torvalds */ 4111da177e4SLinus Torvalds 41253d3176bSChangli Gao extern void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb); 41353d3176bSChangli Gao extern int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb); 4141da177e4SLinus Torvalds extern struct sock * tcp_create_openreq_child(struct sock *sk, 41560236fddSArnaldo Carvalho de Melo struct request_sock *req, 4161da177e4SLinus Torvalds struct sk_buff *skb); 41753d3176bSChangli Gao extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, 41860236fddSArnaldo Carvalho de Melo struct request_sock *req, 4191da177e4SLinus Torvalds struct dst_entry *dst); 42053d3176bSChangli Gao extern int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb); 42153d3176bSChangli Gao extern int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, 4221da177e4SLinus Torvalds int addr_len); 4231da177e4SLinus Torvalds extern int tcp_connect(struct sock *sk); 42453d3176bSChangli Gao extern struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst, 425e6b4d113SWilliam Allen Simpson struct request_sock *req, 426e6b4d113SWilliam Allen Simpson struct request_values *rvp); 4271da177e4SLinus Torvalds extern int tcp_disconnect(struct sock *sk, int flags); 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds /* From syncookies.c */ 4312051f11fSFlorian Westphal extern __u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS]; 4321da177e4SLinus Torvalds extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 4331da177e4SLinus Torvalds struct ip_options *opt); 434e05c82d3SEric Dumazet #ifdef CONFIG_SYN_COOKIES 4351da177e4SLinus Torvalds extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, 4361da177e4SLinus Torvalds __u16 *mss); 437e05c82d3SEric Dumazet #else 438e05c82d3SEric Dumazet static inline __u32 cookie_v4_init_sequence(struct sock *sk, 439e05c82d3SEric Dumazet struct sk_buff *skb, 440e05c82d3SEric Dumazet __u16 *mss) 441e05c82d3SEric Dumazet { 442e05c82d3SEric Dumazet return 0; 443e05c82d3SEric Dumazet } 444e05c82d3SEric Dumazet #endif 4451da177e4SLinus Torvalds 4464dfc2817SFlorian Westphal extern __u32 cookie_init_timestamp(struct request_sock *req); 447172d69e6SFlorian Westphal extern bool cookie_check_timestamp(struct tcp_options_received *opt, bool *); 4484dfc2817SFlorian Westphal 449c6aefafbSGlenn Griffin /* From net/ipv6/syncookies.c */ 450c6aefafbSGlenn Griffin extern struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb); 451e05c82d3SEric Dumazet #ifdef CONFIG_SYN_COOKIES 452cf533ea5SEric Dumazet extern __u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb, 453c6aefafbSGlenn Griffin __u16 *mss); 454e05c82d3SEric Dumazet #else 455e05c82d3SEric Dumazet static inline __u32 cookie_v6_init_sequence(struct sock *sk, 456e05c82d3SEric Dumazet struct sk_buff *skb, 457e05c82d3SEric Dumazet __u16 *mss) 458e05c82d3SEric Dumazet { 459e05c82d3SEric Dumazet return 0; 460e05c82d3SEric Dumazet } 461e05c82d3SEric Dumazet #endif 4621da177e4SLinus Torvalds /* tcp_output.c */ 4631da177e4SLinus Torvalds 4649e412ba7SIlpo Järvinen extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, 4659e412ba7SIlpo Järvinen int nonagle); 4669e412ba7SIlpo Järvinen extern int tcp_may_send_now(struct sock *sk); 4671da177e4SLinus Torvalds extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); 468f1ecd5d9SDamian Lukowski extern void tcp_retransmit_timer(struct sock *sk); 4691da177e4SLinus Torvalds extern void tcp_xmit_retransmit_queue(struct sock *); 4701da177e4SLinus Torvalds extern void tcp_simple_retransmit(struct sock *); 4711da177e4SLinus Torvalds extern int tcp_trim_head(struct sock *, struct sk_buff *, u32); 4726475be16SDavid S. Miller extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int); 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds extern void tcp_send_probe0(struct sock *); 4751da177e4SLinus Torvalds extern void tcp_send_partial(struct sock *); 4761da177e4SLinus Torvalds extern int tcp_write_wakeup(struct sock *); 4771da177e4SLinus Torvalds extern void tcp_send_fin(struct sock *sk); 478dd0fc66fSAl Viro extern void tcp_send_active_reset(struct sock *sk, gfp_t priority); 4791da177e4SLinus Torvalds extern int tcp_send_synack(struct sock *); 480946cedccSEric Dumazet extern int tcp_syn_flood_action(struct sock *sk, 481946cedccSEric Dumazet const struct sk_buff *skb, 482946cedccSEric Dumazet const char *proto); 483c1b4a7e6SDavid S. Miller extern void tcp_push_one(struct sock *, unsigned int mss_now); 4841da177e4SLinus Torvalds extern void tcp_send_ack(struct sock *sk); 4851da177e4SLinus Torvalds extern void tcp_send_delayed_ack(struct sock *sk); 4861da177e4SLinus Torvalds 487a762a980SDavid S. Miller /* tcp_input.c */ 488a762a980SDavid S. Miller extern void tcp_cwnd_application_limited(struct sock *sk); 489a762a980SDavid S. Miller 4901da177e4SLinus Torvalds /* tcp_timer.c */ 4911da177e4SLinus Torvalds extern void tcp_init_xmit_timers(struct sock *); 492463c84b9SArnaldo Carvalho de Melo static inline void tcp_clear_xmit_timers(struct sock *sk) 493463c84b9SArnaldo Carvalho de Melo { 494463c84b9SArnaldo Carvalho de Melo inet_csk_clear_xmit_timers(sk); 495463c84b9SArnaldo Carvalho de Melo } 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu); 4980c54b85fSIlpo Järvinen extern unsigned int tcp_current_mss(struct sock *sk); 4990c54b85fSIlpo Järvinen 5000c54b85fSIlpo Järvinen /* Bound MSS / TSO packet size with the half of the window */ 5010c54b85fSIlpo Järvinen static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize) 5020c54b85fSIlpo Järvinen { 50301f83d69SAlexey Kuznetsov int cutoff; 50401f83d69SAlexey Kuznetsov 50501f83d69SAlexey Kuznetsov /* When peer uses tiny windows, there is no use in packetizing 50601f83d69SAlexey Kuznetsov * to sub-MSS pieces for the sake of SWS or making sure there 50701f83d69SAlexey Kuznetsov * are enough packets in the pipe for fast recovery. 50801f83d69SAlexey Kuznetsov * 50901f83d69SAlexey Kuznetsov * On the other hand, for extremely large MSS devices, handling 51001f83d69SAlexey Kuznetsov * smaller than MSS windows in this way does make sense. 51101f83d69SAlexey Kuznetsov */ 51201f83d69SAlexey Kuznetsov if (tp->max_window >= 512) 51301f83d69SAlexey Kuznetsov cutoff = (tp->max_window >> 1); 51401f83d69SAlexey Kuznetsov else 51501f83d69SAlexey Kuznetsov cutoff = tp->max_window; 51601f83d69SAlexey Kuznetsov 51701f83d69SAlexey Kuznetsov if (cutoff && pktsize > cutoff) 51801f83d69SAlexey Kuznetsov return max_t(int, cutoff, 68U - tp->tcp_header_len); 5190c54b85fSIlpo Järvinen else 5200c54b85fSIlpo Järvinen return pktsize; 5210c54b85fSIlpo Järvinen } 5221da177e4SLinus Torvalds 52317b085eaSArnaldo Carvalho de Melo /* tcp.c */ 524cf533ea5SEric Dumazet extern void tcp_get_info(const struct sock *, struct tcp_info *); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* Read 'sendfile()'-style from a TCP socket */ 5271da177e4SLinus Torvalds typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, 5281da177e4SLinus Torvalds unsigned int, size_t); 5291da177e4SLinus Torvalds extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, 5301da177e4SLinus Torvalds sk_read_actor_t recv_actor); 5311da177e4SLinus Torvalds 53240efc6faSStephen Hemminger extern void tcp_initialize_rcv_mss(struct sock *sk); 5331da177e4SLinus Torvalds 534cf533ea5SEric Dumazet extern int tcp_mtu_to_mss(const struct sock *sk, int pmtu); 535cf533ea5SEric Dumazet extern int tcp_mss_to_mtu(const struct sock *sk, int mss); 5365d424d5aSJohn Heffner extern void tcp_mtup_init(struct sock *sk); 5379ad7c049SJerry Chu extern void tcp_valid_rtt_meas(struct sock *sk, u32 seq_rtt); 5385d424d5aSJohn Heffner 539f1ecd5d9SDamian Lukowski static inline void tcp_bound_rto(const struct sock *sk) 540f1ecd5d9SDamian Lukowski { 541f1ecd5d9SDamian Lukowski if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX) 542f1ecd5d9SDamian Lukowski inet_csk(sk)->icsk_rto = TCP_RTO_MAX; 543f1ecd5d9SDamian Lukowski } 544f1ecd5d9SDamian Lukowski 545f1ecd5d9SDamian Lukowski static inline u32 __tcp_set_rto(const struct tcp_sock *tp) 546f1ecd5d9SDamian Lukowski { 547f1ecd5d9SDamian Lukowski return (tp->srtt >> 3) + tp->rttvar; 548f1ecd5d9SDamian Lukowski } 549f1ecd5d9SDamian Lukowski 55040efc6faSStephen Hemminger static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) 5511da177e4SLinus Torvalds { 5521da177e4SLinus Torvalds tp->pred_flags = htonl((tp->tcp_header_len << 26) | 5531da177e4SLinus Torvalds ntohl(TCP_FLAG_ACK) | 5541da177e4SLinus Torvalds snd_wnd); 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 55740efc6faSStephen Hemminger static inline void tcp_fast_path_on(struct tcp_sock *tp) 5581da177e4SLinus Torvalds { 5591da177e4SLinus Torvalds __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); 5601da177e4SLinus Torvalds } 5611da177e4SLinus Torvalds 5629e412ba7SIlpo Järvinen static inline void tcp_fast_path_check(struct sock *sk) 5631da177e4SLinus Torvalds { 5649e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 5659e412ba7SIlpo Järvinen 566b03efcfbSDavid S. Miller if (skb_queue_empty(&tp->out_of_order_queue) && 5671da177e4SLinus Torvalds tp->rcv_wnd && 5681da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && 5691da177e4SLinus Torvalds !tp->urg_data) 5701da177e4SLinus Torvalds tcp_fast_path_on(tp); 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds 5730c266898SSatoru SATOH /* Compute the actual rto_min value */ 5740c266898SSatoru SATOH static inline u32 tcp_rto_min(struct sock *sk) 5750c266898SSatoru SATOH { 576cf533ea5SEric Dumazet const struct dst_entry *dst = __sk_dst_get(sk); 5770c266898SSatoru SATOH u32 rto_min = TCP_RTO_MIN; 5780c266898SSatoru SATOH 5790c266898SSatoru SATOH if (dst && dst_metric_locked(dst, RTAX_RTO_MIN)) 5800c266898SSatoru SATOH rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN); 5810c266898SSatoru SATOH return rto_min; 5820c266898SSatoru SATOH } 5830c266898SSatoru SATOH 5841da177e4SLinus Torvalds /* Compute the actual receive window we are currently advertising. 5851da177e4SLinus Torvalds * Rcv_nxt can be after the window if our peer push more data 5861da177e4SLinus Torvalds * than the offered window. 5871da177e4SLinus Torvalds */ 58840efc6faSStephen Hemminger static inline u32 tcp_receive_window(const struct tcp_sock *tp) 5891da177e4SLinus Torvalds { 5901da177e4SLinus Torvalds s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds if (win < 0) 5931da177e4SLinus Torvalds win = 0; 5941da177e4SLinus Torvalds return (u32) win; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds /* Choose a new window, without checks for shrinking, and without 5981da177e4SLinus Torvalds * scaling applied to the result. The caller does these things 5991da177e4SLinus Torvalds * if necessary. This is a "raw" window selection. 6001da177e4SLinus Torvalds */ 6011da177e4SLinus Torvalds extern u32 __tcp_select_window(struct sock *sk); 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /* TCP timestamps are only 32-bits, this causes a slight 6041da177e4SLinus Torvalds * complication on 64-bit systems since we store a snapshot 60531f34269SStephen Hemminger * of jiffies in the buffer control blocks below. We decided 60631f34269SStephen Hemminger * to use only the low 32-bits of jiffies and hide the ugly 6071da177e4SLinus Torvalds * casts with the following macro. 6081da177e4SLinus Torvalds */ 6091da177e4SLinus Torvalds #define tcp_time_stamp ((__u32)(jiffies)) 6101da177e4SLinus Torvalds 611a3433f35SChangli Gao #define tcp_flag_byte(th) (((u_int8_t *)th)[13]) 612a3433f35SChangli Gao 613a3433f35SChangli Gao #define TCPHDR_FIN 0x01 614a3433f35SChangli Gao #define TCPHDR_SYN 0x02 615a3433f35SChangli Gao #define TCPHDR_RST 0x04 616a3433f35SChangli Gao #define TCPHDR_PSH 0x08 617a3433f35SChangli Gao #define TCPHDR_ACK 0x10 618a3433f35SChangli Gao #define TCPHDR_URG 0x20 619a3433f35SChangli Gao #define TCPHDR_ECE 0x40 620a3433f35SChangli Gao #define TCPHDR_CWR 0x80 621a3433f35SChangli Gao 622caa20d9aSStephen Hemminger /* This is what the send packet queuing engine uses to pass 623f86586faSEric Dumazet * TCP per-packet control information to the transmission code. 624f86586faSEric Dumazet * We also store the host-order sequence numbers in here too. 625f86586faSEric Dumazet * This is 44 bytes if IPV6 is enabled. 626f86586faSEric Dumazet * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately. 6271da177e4SLinus Torvalds */ 6281da177e4SLinus Torvalds struct tcp_skb_cb { 6291da177e4SLinus Torvalds union { 6301da177e4SLinus Torvalds struct inet_skb_parm h4; 6311da177e4SLinus Torvalds #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) 6321da177e4SLinus Torvalds struct inet6_skb_parm h6; 6331da177e4SLinus Torvalds #endif 6341da177e4SLinus Torvalds } header; /* For incoming frames */ 6351da177e4SLinus Torvalds __u32 seq; /* Starting sequence number */ 6361da177e4SLinus Torvalds __u32 end_seq; /* SEQ + FIN + SYN + datalen */ 6371da177e4SLinus Torvalds __u32 when; /* used to compute rtt's */ 6384de075e0SEric Dumazet __u8 tcp_flags; /* TCP header flags. (tcp[13]) */ 6391da177e4SLinus Torvalds __u8 sacked; /* State flags for SACK/FACK. */ 6401da177e4SLinus Torvalds #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ 6411da177e4SLinus Torvalds #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ 6421da177e4SLinus Torvalds #define TCPCB_LOST 0x04 /* SKB is lost */ 6431da177e4SLinus Torvalds #define TCPCB_TAGBITS 0x07 /* All tag bits */ 644b82d1bb4SEric Dumazet __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ 645b82d1bb4SEric Dumazet /* 1 byte hole */ 6461da177e4SLinus Torvalds #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ 6471da177e4SLinus Torvalds #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS) 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds __u32 ack_seq; /* Sequence number ACK'd */ 6501da177e4SLinus Torvalds }; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds /* Due to TSO, an SKB can be composed of multiple actual 6551da177e4SLinus Torvalds * packets. To keep these tracked properly, we use this. 6561da177e4SLinus Torvalds */ 6571da177e4SLinus Torvalds static inline int tcp_skb_pcount(const struct sk_buff *skb) 6581da177e4SLinus Torvalds { 6597967168cSHerbert Xu return skb_shinfo(skb)->gso_segs; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds /* This is valid iff tcp_skb_pcount() > 1. */ 6631da177e4SLinus Torvalds static inline int tcp_skb_mss(const struct sk_buff *skb) 6641da177e4SLinus Torvalds { 6657967168cSHerbert Xu return skb_shinfo(skb)->gso_size; 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds 668317a76f9SStephen Hemminger /* Events passed to congestion control interface */ 669317a76f9SStephen Hemminger enum tcp_ca_event { 670317a76f9SStephen Hemminger CA_EVENT_TX_START, /* first transmit when no packets in flight */ 671317a76f9SStephen Hemminger CA_EVENT_CWND_RESTART, /* congestion window restart */ 672317a76f9SStephen Hemminger CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */ 673317a76f9SStephen Hemminger CA_EVENT_FRTO, /* fast recovery timeout */ 674317a76f9SStephen Hemminger CA_EVENT_LOSS, /* loss timeout */ 675317a76f9SStephen Hemminger CA_EVENT_FAST_ACK, /* in sequence ack */ 676317a76f9SStephen Hemminger CA_EVENT_SLOW_ACK, /* other ack */ 677317a76f9SStephen Hemminger }; 678317a76f9SStephen Hemminger 679317a76f9SStephen Hemminger /* 680317a76f9SStephen Hemminger * Interface for adding new TCP congestion control handlers 681317a76f9SStephen Hemminger */ 682317a76f9SStephen Hemminger #define TCP_CA_NAME_MAX 16 6833ff825b2SStephen Hemminger #define TCP_CA_MAX 128 6843ff825b2SStephen Hemminger #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX) 6853ff825b2SStephen Hemminger 686164891aaSStephen Hemminger #define TCP_CONG_NON_RESTRICTED 0x1 687164891aaSStephen Hemminger #define TCP_CONG_RTT_STAMP 0x2 688164891aaSStephen Hemminger 689317a76f9SStephen Hemminger struct tcp_congestion_ops { 690317a76f9SStephen Hemminger struct list_head list; 691164891aaSStephen Hemminger unsigned long flags; 692317a76f9SStephen Hemminger 693317a76f9SStephen Hemminger /* initialize private data (optional) */ 6946687e988SArnaldo Carvalho de Melo void (*init)(struct sock *sk); 695317a76f9SStephen Hemminger /* cleanup private data (optional) */ 6966687e988SArnaldo Carvalho de Melo void (*release)(struct sock *sk); 697317a76f9SStephen Hemminger 698317a76f9SStephen Hemminger /* return slow start threshold (required) */ 6996687e988SArnaldo Carvalho de Melo u32 (*ssthresh)(struct sock *sk); 700317a76f9SStephen Hemminger /* lower bound for congestion window (optional) */ 70172dc5b92SStephen Hemminger u32 (*min_cwnd)(const struct sock *sk); 702317a76f9SStephen Hemminger /* do new cwnd calculation (required) */ 703c3a05c60SIlpo Järvinen void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight); 704317a76f9SStephen Hemminger /* call before changing ca_state (optional) */ 7056687e988SArnaldo Carvalho de Melo void (*set_state)(struct sock *sk, u8 new_state); 706317a76f9SStephen Hemminger /* call when cwnd event occurs (optional) */ 7076687e988SArnaldo Carvalho de Melo void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); 708317a76f9SStephen Hemminger /* new value of cwnd after loss (optional) */ 7096687e988SArnaldo Carvalho de Melo u32 (*undo_cwnd)(struct sock *sk); 710317a76f9SStephen Hemminger /* hook for packet ack accounting (optional) */ 71130cfd0baSStephen Hemminger void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); 71273c1f4a0SArnaldo Carvalho de Melo /* get info for inet_diag (optional) */ 7136687e988SArnaldo Carvalho de Melo void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb); 714317a76f9SStephen Hemminger 715317a76f9SStephen Hemminger char name[TCP_CA_NAME_MAX]; 716317a76f9SStephen Hemminger struct module *owner; 717317a76f9SStephen Hemminger }; 718317a76f9SStephen Hemminger 719317a76f9SStephen Hemminger extern int tcp_register_congestion_control(struct tcp_congestion_ops *type); 720317a76f9SStephen Hemminger extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); 721317a76f9SStephen Hemminger 7226687e988SArnaldo Carvalho de Melo extern void tcp_init_congestion_control(struct sock *sk); 7236687e988SArnaldo Carvalho de Melo extern void tcp_cleanup_congestion_control(struct sock *sk); 724317a76f9SStephen Hemminger extern int tcp_set_default_congestion_control(const char *name); 725317a76f9SStephen Hemminger extern void tcp_get_default_congestion_control(char *name); 7263ff825b2SStephen Hemminger extern void tcp_get_available_congestion_control(char *buf, size_t len); 727ce7bc3bfSStephen Hemminger extern void tcp_get_allowed_congestion_control(char *buf, size_t len); 728ce7bc3bfSStephen Hemminger extern int tcp_set_allowed_congestion_control(char *allowed); 7296687e988SArnaldo Carvalho de Melo extern int tcp_set_congestion_control(struct sock *sk, const char *name); 73040efc6faSStephen Hemminger extern void tcp_slow_start(struct tcp_sock *tp); 731758ce5c8SIlpo Järvinen extern void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w); 732317a76f9SStephen Hemminger 7335f8ef48dSStephen Hemminger extern struct tcp_congestion_ops tcp_init_congestion_ops; 7346687e988SArnaldo Carvalho de Melo extern u32 tcp_reno_ssthresh(struct sock *sk); 735c3a05c60SIlpo Järvinen extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight); 73672dc5b92SStephen Hemminger extern u32 tcp_reno_min_cwnd(const struct sock *sk); 737a8acfbacSDavid S. Miller extern struct tcp_congestion_ops tcp_reno; 738317a76f9SStephen Hemminger 7396687e988SArnaldo Carvalho de Melo static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state) 740317a76f9SStephen Hemminger { 7416687e988SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 7426687e988SArnaldo Carvalho de Melo 7436687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->set_state) 7446687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->set_state(sk, ca_state); 7456687e988SArnaldo Carvalho de Melo icsk->icsk_ca_state = ca_state; 746317a76f9SStephen Hemminger } 747317a76f9SStephen Hemminger 7486687e988SArnaldo Carvalho de Melo static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) 749317a76f9SStephen Hemminger { 7506687e988SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 7516687e988SArnaldo Carvalho de Melo 7526687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->cwnd_event) 7536687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->cwnd_event(sk, event); 754317a76f9SStephen Hemminger } 755317a76f9SStephen Hemminger 756e60402d0SIlpo Järvinen /* These functions determine how the current flow behaves in respect of SACK 757e60402d0SIlpo Järvinen * handling. SACK is negotiated with the peer, and therefore it can vary 758e60402d0SIlpo Järvinen * between different flows. 759e60402d0SIlpo Järvinen * 760e60402d0SIlpo Järvinen * tcp_is_sack - SACK enabled 761e60402d0SIlpo Järvinen * tcp_is_reno - No SACK 762e60402d0SIlpo Järvinen * tcp_is_fack - FACK enabled, implies SACK enabled 763e60402d0SIlpo Järvinen */ 764e60402d0SIlpo Järvinen static inline int tcp_is_sack(const struct tcp_sock *tp) 765e60402d0SIlpo Järvinen { 766e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok; 767e60402d0SIlpo Järvinen } 768e60402d0SIlpo Järvinen 769e60402d0SIlpo Järvinen static inline int tcp_is_reno(const struct tcp_sock *tp) 770e60402d0SIlpo Järvinen { 771e60402d0SIlpo Järvinen return !tcp_is_sack(tp); 772e60402d0SIlpo Järvinen } 773e60402d0SIlpo Järvinen 774e60402d0SIlpo Järvinen static inline int tcp_is_fack(const struct tcp_sock *tp) 775e60402d0SIlpo Järvinen { 776e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok & 2; 777e60402d0SIlpo Järvinen } 778e60402d0SIlpo Järvinen 779e60402d0SIlpo Järvinen static inline void tcp_enable_fack(struct tcp_sock *tp) 780e60402d0SIlpo Järvinen { 781e60402d0SIlpo Järvinen tp->rx_opt.sack_ok |= 2; 782e60402d0SIlpo Järvinen } 783e60402d0SIlpo Järvinen 78483ae4088SIlpo Järvinen static inline unsigned int tcp_left_out(const struct tcp_sock *tp) 78583ae4088SIlpo Järvinen { 78683ae4088SIlpo Järvinen return tp->sacked_out + tp->lost_out; 78783ae4088SIlpo Järvinen } 78883ae4088SIlpo Järvinen 7891da177e4SLinus Torvalds /* This determines how many packets are "in the network" to the best 7901da177e4SLinus Torvalds * of our knowledge. In many cases it is conservative, but where 7911da177e4SLinus Torvalds * detailed information is available from the receiver (via SACK 7921da177e4SLinus Torvalds * blocks etc.) we can make more aggressive calculations. 7931da177e4SLinus Torvalds * 7941da177e4SLinus Torvalds * Use this for decisions involving congestion control, use just 7951da177e4SLinus Torvalds * tp->packets_out to determine if the send queue is empty or not. 7961da177e4SLinus Torvalds * 7971da177e4SLinus Torvalds * Read this equation as: 7981da177e4SLinus Torvalds * 7991da177e4SLinus Torvalds * "Packets sent once on transmission queue" MINUS 8001da177e4SLinus Torvalds * "Packets left network, but not honestly ACKed yet" PLUS 8011da177e4SLinus Torvalds * "Packets fast retransmitted" 8021da177e4SLinus Torvalds */ 80340efc6faSStephen Hemminger static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 8041da177e4SLinus Torvalds { 80583ae4088SIlpo Järvinen return tp->packets_out - tcp_left_out(tp) + tp->retrans_out; 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds 8080b6a05c1SIlpo Järvinen #define TCP_INFINITE_SSTHRESH 0x7fffffff 8090b6a05c1SIlpo Järvinen 8100b6a05c1SIlpo Järvinen static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp) 8110b6a05c1SIlpo Järvinen { 8120b6a05c1SIlpo Järvinen return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH; 8130b6a05c1SIlpo Järvinen } 8140b6a05c1SIlpo Järvinen 8151da177e4SLinus Torvalds /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. 8161da177e4SLinus Torvalds * The exception is rate halving phase, when cwnd is decreasing towards 8171da177e4SLinus Torvalds * ssthresh. 8181da177e4SLinus Torvalds */ 8196687e988SArnaldo Carvalho de Melo static inline __u32 tcp_current_ssthresh(const struct sock *sk) 8201da177e4SLinus Torvalds { 8216687e988SArnaldo Carvalho de Melo const struct tcp_sock *tp = tcp_sk(sk); 822cf533ea5SEric Dumazet 8236687e988SArnaldo Carvalho de Melo if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery)) 8241da177e4SLinus Torvalds return tp->snd_ssthresh; 8251da177e4SLinus Torvalds else 8261da177e4SLinus Torvalds return max(tp->snd_ssthresh, 8271da177e4SLinus Torvalds ((tp->snd_cwnd >> 1) + 8281da177e4SLinus Torvalds (tp->snd_cwnd >> 2))); 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds 831b9c4595bSIlpo Järvinen /* Use define here intentionally to get WARN_ON location shown at the caller */ 832b9c4595bSIlpo Järvinen #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out) 8331da177e4SLinus Torvalds 8343cfe3baaSIlpo Järvinen extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh); 835cf533ea5SEric Dumazet extern __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /* Slow start with delack produces 3 packets of burst, so that 838dd9e0ddaSJohn Heffner * it is safe "de facto". This will be the default - same as 839dd9e0ddaSJohn Heffner * the default reordering threshold - but if reordering increases, 840dd9e0ddaSJohn Heffner * we must be able to allow cwnd to burst at least this much in order 841dd9e0ddaSJohn Heffner * to not pull it back when holes are filled. 8421da177e4SLinus Torvalds */ 8431da177e4SLinus Torvalds static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) 8441da177e4SLinus Torvalds { 845dd9e0ddaSJohn Heffner return tp->reordering; 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds 84890840defSIlpo Järvinen /* Returns end sequence number of the receiver's advertised window */ 84990840defSIlpo Järvinen static inline u32 tcp_wnd_end(const struct tcp_sock *tp) 85090840defSIlpo Järvinen { 85190840defSIlpo Järvinen return tp->snd_una + tp->snd_wnd; 85290840defSIlpo Järvinen } 853cea14e0eSIlpo Järvinen extern int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight); 854f4805edeSStephen Hemminger 855c1bd24b7SChuck Lever static inline void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss, 8561da177e4SLinus Torvalds const struct sk_buff *skb) 8571da177e4SLinus Torvalds { 8581da177e4SLinus Torvalds if (skb->len < mss) 8591da177e4SLinus Torvalds tp->snd_sml = TCP_SKB_CB(skb)->end_seq; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8629e412ba7SIlpo Järvinen static inline void tcp_check_probe_timer(struct sock *sk) 8631da177e4SLinus Torvalds { 864cf533ea5SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 865463c84b9SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 8669e412ba7SIlpo Järvinen 867463c84b9SArnaldo Carvalho de Melo if (!tp->packets_out && !icsk->icsk_pending) 8683f421baaSArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, 8693f421baaSArnaldo Carvalho de Melo icsk->icsk_rto, TCP_RTO_MAX); 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 872ee7537b6SHantzis Fotis static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq) 8731da177e4SLinus Torvalds { 8741da177e4SLinus Torvalds tp->snd_wl1 = seq; 8751da177e4SLinus Torvalds } 8761da177e4SLinus Torvalds 877ee7537b6SHantzis Fotis static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq) 8781da177e4SLinus Torvalds { 8791da177e4SLinus Torvalds tp->snd_wl1 = seq; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds /* 8831da177e4SLinus Torvalds * Calculate(/check) TCP checksum 8841da177e4SLinus Torvalds */ 885ba7808eaSFrederik Deweerdt static inline __sum16 tcp_v4_check(int len, __be32 saddr, 886ba7808eaSFrederik Deweerdt __be32 daddr, __wsum base) 8871da177e4SLinus Torvalds { 8881da177e4SLinus Torvalds return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); 8891da177e4SLinus Torvalds } 8901da177e4SLinus Torvalds 891b51655b9SAl Viro static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb) 8921da177e4SLinus Torvalds { 893fb286bb2SHerbert Xu return __skb_checksum_complete(skb); 8941da177e4SLinus Torvalds } 8951da177e4SLinus Torvalds 89640efc6faSStephen Hemminger static inline int tcp_checksum_complete(struct sk_buff *skb) 8971da177e4SLinus Torvalds { 89860476372SHerbert Xu return !skb_csum_unnecessary(skb) && 8991da177e4SLinus Torvalds __tcp_checksum_complete(skb); 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds /* Prequeue for VJ style copy to user, combined with checksumming. */ 9031da177e4SLinus Torvalds 90440efc6faSStephen Hemminger static inline void tcp_prequeue_init(struct tcp_sock *tp) 9051da177e4SLinus Torvalds { 9061da177e4SLinus Torvalds tp->ucopy.task = NULL; 9071da177e4SLinus Torvalds tp->ucopy.len = 0; 9081da177e4SLinus Torvalds tp->ucopy.memory = 0; 9091da177e4SLinus Torvalds skb_queue_head_init(&tp->ucopy.prequeue); 91097fc2f08SChris Leech #ifdef CONFIG_NET_DMA 91197fc2f08SChris Leech tp->ucopy.dma_chan = NULL; 91297fc2f08SChris Leech tp->ucopy.wakeup = 0; 91397fc2f08SChris Leech tp->ucopy.pinned_list = NULL; 91497fc2f08SChris Leech tp->ucopy.dma_cookie = 0; 91597fc2f08SChris Leech #endif 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds /* Packet is added to VJ-style prequeue for processing in process 9191da177e4SLinus Torvalds * context, if a reader task is waiting. Apparently, this exciting 9201da177e4SLinus Torvalds * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93) 9211da177e4SLinus Torvalds * failed somewhere. Latency? Burstiness? Well, at least now we will 9221da177e4SLinus Torvalds * see, why it failed. 8)8) --ANK 9231da177e4SLinus Torvalds * 9241da177e4SLinus Torvalds * NOTE: is this not too big to inline? 9251da177e4SLinus Torvalds */ 92640efc6faSStephen Hemminger static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) 9271da177e4SLinus Torvalds { 9281da177e4SLinus Torvalds struct tcp_sock *tp = tcp_sk(sk); 9291da177e4SLinus Torvalds 930f5f8d86bSEric Dumazet if (sysctl_tcp_low_latency || !tp->ucopy.task) 931f5f8d86bSEric Dumazet return 0; 932f5f8d86bSEric Dumazet 9331da177e4SLinus Torvalds __skb_queue_tail(&tp->ucopy.prequeue, skb); 9341da177e4SLinus Torvalds tp->ucopy.memory += skb->truesize; 9351da177e4SLinus Torvalds if (tp->ucopy.memory > sk->sk_rcvbuf) { 9361da177e4SLinus Torvalds struct sk_buff *skb1; 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds BUG_ON(sock_owned_by_user(sk)); 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) { 941c57943a1SPeter Zijlstra sk_backlog_rcv(sk, skb1); 942f5f8d86bSEric Dumazet NET_INC_STATS_BH(sock_net(sk), 943f5f8d86bSEric Dumazet LINUX_MIB_TCPPREQUEUEDROPPED); 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds tp->ucopy.memory = 0; 9471da177e4SLinus Torvalds } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) { 948aa395145SEric Dumazet wake_up_interruptible_sync_poll(sk_sleep(sk), 9497aedec2aSEric Dumazet POLLIN | POLLRDNORM | POLLRDBAND); 950463c84b9SArnaldo Carvalho de Melo if (!inet_csk_ack_scheduled(sk)) 951463c84b9SArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, 9520c266898SSatoru SATOH (3 * tcp_rto_min(sk)) / 4, 9533f421baaSArnaldo Carvalho de Melo TCP_RTO_MAX); 9541da177e4SLinus Torvalds } 9551da177e4SLinus Torvalds return 1; 9561da177e4SLinus Torvalds } 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds #undef STATE_TRACE 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds #ifdef STATE_TRACE 9621da177e4SLinus Torvalds static const char *statename[]={ 9631da177e4SLinus Torvalds "Unused","Established","Syn Sent","Syn Recv", 9641da177e4SLinus Torvalds "Fin Wait 1","Fin Wait 2","Time Wait", "Close", 9651da177e4SLinus Torvalds "Close Wait","Last ACK","Listen","Closing" 9661da177e4SLinus Torvalds }; 9671da177e4SLinus Torvalds #endif 968490d5046SIlpo Järvinen extern void tcp_set_state(struct sock *sk, int state); 9691da177e4SLinus Torvalds 9704ac02babSAndi Kleen extern void tcp_done(struct sock *sk); 9711da177e4SLinus Torvalds 97240efc6faSStephen Hemminger static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) 9731da177e4SLinus Torvalds { 9741da177e4SLinus Torvalds rx_opt->dsack = 0; 9751da177e4SLinus Torvalds rx_opt->num_sacks = 0; 9761da177e4SLinus Torvalds } 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds /* Determine a window scaling and initial window to offer. */ 9791da177e4SLinus Torvalds extern void tcp_select_initial_window(int __space, __u32 mss, 9801da177e4SLinus Torvalds __u32 *rcv_wnd, __u32 *window_clamp, 98131d12926Slaurent chavey int wscale_ok, __u8 *rcv_wscale, 98231d12926Slaurent chavey __u32 init_rcv_wnd); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds static inline int tcp_win_from_space(int space) 9851da177e4SLinus Torvalds { 9861da177e4SLinus Torvalds return sysctl_tcp_adv_win_scale<=0 ? 9871da177e4SLinus Torvalds (space>>(-sysctl_tcp_adv_win_scale)) : 9881da177e4SLinus Torvalds space - (space>>sysctl_tcp_adv_win_scale); 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds /* Note: caller must be prepared to deal with negative returns */ 9921da177e4SLinus Torvalds static inline int tcp_space(const struct sock *sk) 9931da177e4SLinus Torvalds { 9941da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf - 9951da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc)); 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds static inline int tcp_full_space(const struct sock *sk) 9991da177e4SLinus Torvalds { 10001da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf); 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds 100340efc6faSStephen Hemminger static inline void tcp_openreq_init(struct request_sock *req, 10041da177e4SLinus Torvalds struct tcp_options_received *rx_opt, 10051da177e4SLinus Torvalds struct sk_buff *skb) 10061da177e4SLinus Torvalds { 10072e6599cbSArnaldo Carvalho de Melo struct inet_request_sock *ireq = inet_rsk(req); 10082e6599cbSArnaldo Carvalho de Melo 10091da177e4SLinus Torvalds req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */ 10104dfc2817SFlorian Westphal req->cookie_ts = 0; 10112e6599cbSArnaldo Carvalho de Melo tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; 10121da177e4SLinus Torvalds req->mss = rx_opt->mss_clamp; 10131da177e4SLinus Torvalds req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0; 10142e6599cbSArnaldo Carvalho de Melo ireq->tstamp_ok = rx_opt->tstamp_ok; 10152e6599cbSArnaldo Carvalho de Melo ireq->sack_ok = rx_opt->sack_ok; 10162e6599cbSArnaldo Carvalho de Melo ireq->snd_wscale = rx_opt->snd_wscale; 10172e6599cbSArnaldo Carvalho de Melo ireq->wscale_ok = rx_opt->wscale_ok; 10182e6599cbSArnaldo Carvalho de Melo ireq->acked = 0; 10192e6599cbSArnaldo Carvalho de Melo ireq->ecn_ok = 0; 1020aa8223c7SArnaldo Carvalho de Melo ireq->rmt_port = tcp_hdr(skb)->source; 1021a3116ac5SKOVACS Krisztian ireq->loc_port = tcp_hdr(skb)->dest; 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 10245c52ba17SPavel Emelyanov extern void tcp_enter_memory_pressure(struct sock *sk); 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds static inline int keepalive_intvl_when(const struct tcp_sock *tp) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds static inline int keepalive_time_when(const struct tcp_sock *tp) 10321da177e4SLinus Torvalds { 10331da177e4SLinus Torvalds return tp->keepalive_time ? : sysctl_tcp_keepalive_time; 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 1036df19a626SEric Dumazet static inline int keepalive_probes(const struct tcp_sock *tp) 1037df19a626SEric Dumazet { 1038df19a626SEric Dumazet return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes; 1039df19a626SEric Dumazet } 1040df19a626SEric Dumazet 10416c37e5deSFlavio Leitner static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp) 10426c37e5deSFlavio Leitner { 10436c37e5deSFlavio Leitner const struct inet_connection_sock *icsk = &tp->inet_conn; 10446c37e5deSFlavio Leitner 10456c37e5deSFlavio Leitner return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime, 10466c37e5deSFlavio Leitner tcp_time_stamp - tp->rcv_tstamp); 10476c37e5deSFlavio Leitner } 10486c37e5deSFlavio Leitner 1049463c84b9SArnaldo Carvalho de Melo static inline int tcp_fin_time(const struct sock *sk) 10501da177e4SLinus Torvalds { 1051463c84b9SArnaldo Carvalho de Melo int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout; 1052463c84b9SArnaldo Carvalho de Melo const int rto = inet_csk(sk)->icsk_rto; 10531da177e4SLinus Torvalds 1054463c84b9SArnaldo Carvalho de Melo if (fin_timeout < (rto << 2) - (rto >> 1)) 1055463c84b9SArnaldo Carvalho de Melo fin_timeout = (rto << 2) - (rto >> 1); 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds return fin_timeout; 10581da177e4SLinus Torvalds } 10591da177e4SLinus Torvalds 1060c887e6d2SIlpo Järvinen static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, 1061c887e6d2SIlpo Järvinen int paws_win) 10621da177e4SLinus Torvalds { 1063c887e6d2SIlpo Järvinen if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win) 1064c887e6d2SIlpo Järvinen return 1; 1065c887e6d2SIlpo Järvinen if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)) 1066c887e6d2SIlpo Järvinen return 1; 1067bc2ce894SEric Dumazet /* 1068bc2ce894SEric Dumazet * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0, 1069bc2ce894SEric Dumazet * then following tcp messages have valid values. Ignore 0 value, 1070bc2ce894SEric Dumazet * or else 'negative' tsval might forbid us to accept their packets. 1071bc2ce894SEric Dumazet */ 1072bc2ce894SEric Dumazet if (!rx_opt->ts_recent) 1073bc2ce894SEric Dumazet return 1; 10741da177e4SLinus Torvalds return 0; 1075c887e6d2SIlpo Järvinen } 1076c887e6d2SIlpo Järvinen 1077c887e6d2SIlpo Järvinen static inline int tcp_paws_reject(const struct tcp_options_received *rx_opt, 1078c887e6d2SIlpo Järvinen int rst) 1079c887e6d2SIlpo Järvinen { 1080c887e6d2SIlpo Järvinen if (tcp_paws_check(rx_opt, 0)) 10811da177e4SLinus Torvalds return 0; 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds /* RST segments are not recommended to carry timestamp, 10841da177e4SLinus Torvalds and, if they do, it is recommended to ignore PAWS because 10851da177e4SLinus Torvalds "their cleanup function should take precedence over timestamps." 10861da177e4SLinus Torvalds Certainly, it is mistake. It is necessary to understand the reasons 10871da177e4SLinus Torvalds of this constraint to relax it: if peer reboots, clock may go 10881da177e4SLinus Torvalds out-of-sync and half-open connections will not be reset. 10891da177e4SLinus Torvalds Actually, the problem would be not existing if all 10901da177e4SLinus Torvalds the implementations followed draft about maintaining clock 10911da177e4SLinus Torvalds via reboots. Linux-2.2 DOES NOT! 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds However, we can relax time bounds for RST segments to MSL. 10941da177e4SLinus Torvalds */ 10959d729f72SJames Morris if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) 10961da177e4SLinus Torvalds return 0; 10971da177e4SLinus Torvalds return 1; 10981da177e4SLinus Torvalds } 10991da177e4SLinus Torvalds 1100a9c19329SPavel Emelyanov static inline void tcp_mib_init(struct net *net) 11011da177e4SLinus Torvalds { 11021da177e4SLinus Torvalds /* See RFC 2012 */ 1103cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1); 1104cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ); 1105cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ); 1106cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1); 11071da177e4SLinus Torvalds } 11081da177e4SLinus Torvalds 11096a438bbeSStephen Hemminger /* from STCP */ 1110ef9da47cSIlpo Järvinen static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp) 11110800f170SDavid S. Miller { 11126a438bbeSStephen Hemminger tp->lost_skb_hint = NULL; 11136a438bbeSStephen Hemminger tp->scoreboard_skb_hint = NULL; 1114ef9da47cSIlpo Järvinen } 1115ef9da47cSIlpo Järvinen 1116ef9da47cSIlpo Järvinen static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp) 1117ef9da47cSIlpo Järvinen { 1118ef9da47cSIlpo Järvinen tcp_clear_retrans_hints_partial(tp); 11196a438bbeSStephen Hemminger tp->retransmit_skb_hint = NULL; 1120b7689205SIlpo Järvinen } 1121b7689205SIlpo Järvinen 1122cfb6eeb4SYOSHIFUJI Hideaki /* MD5 Signature */ 1123cfb6eeb4SYOSHIFUJI Hideaki struct crypto_hash; 1124cfb6eeb4SYOSHIFUJI Hideaki 1125cfb6eeb4SYOSHIFUJI Hideaki /* - key database */ 1126cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key { 1127cfb6eeb4SYOSHIFUJI Hideaki u8 *key; 1128cfb6eeb4SYOSHIFUJI Hideaki u8 keylen; 1129cfb6eeb4SYOSHIFUJI Hideaki }; 1130cfb6eeb4SYOSHIFUJI Hideaki 1131cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key { 1132f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1133cfb6eeb4SYOSHIFUJI Hideaki __be32 addr; 1134cfb6eeb4SYOSHIFUJI Hideaki }; 1135cfb6eeb4SYOSHIFUJI Hideaki 1136cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key { 1137f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1138cfb6eeb4SYOSHIFUJI Hideaki #if 0 1139cfb6eeb4SYOSHIFUJI Hideaki u32 scope_id; /* XXX */ 1140cfb6eeb4SYOSHIFUJI Hideaki #endif 1141cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr addr; 1142cfb6eeb4SYOSHIFUJI Hideaki }; 1143cfb6eeb4SYOSHIFUJI Hideaki 1144cfb6eeb4SYOSHIFUJI Hideaki /* - sock block */ 1145cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_info { 1146cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key *keys4; 1147cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1148cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key *keys6; 1149cfb6eeb4SYOSHIFUJI Hideaki u32 entries6; 1150cfb6eeb4SYOSHIFUJI Hideaki u32 alloced6; 1151cfb6eeb4SYOSHIFUJI Hideaki #endif 1152cfb6eeb4SYOSHIFUJI Hideaki u32 entries4; 1153cfb6eeb4SYOSHIFUJI Hideaki u32 alloced4; 1154cfb6eeb4SYOSHIFUJI Hideaki }; 1155cfb6eeb4SYOSHIFUJI Hideaki 1156cfb6eeb4SYOSHIFUJI Hideaki /* - pseudo header */ 1157cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr { 1158cfb6eeb4SYOSHIFUJI Hideaki __be32 saddr; 1159cfb6eeb4SYOSHIFUJI Hideaki __be32 daddr; 1160cfb6eeb4SYOSHIFUJI Hideaki __u8 pad; 1161cfb6eeb4SYOSHIFUJI Hideaki __u8 protocol; 1162cfb6eeb4SYOSHIFUJI Hideaki __be16 len; 1163cfb6eeb4SYOSHIFUJI Hideaki }; 1164cfb6eeb4SYOSHIFUJI Hideaki 1165cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr { 1166cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr saddr; 1167cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr daddr; 1168cfb6eeb4SYOSHIFUJI Hideaki __be32 len; 1169cfb6eeb4SYOSHIFUJI Hideaki __be32 protocol; /* including padding */ 1170cfb6eeb4SYOSHIFUJI Hideaki }; 1171cfb6eeb4SYOSHIFUJI Hideaki 1172cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block { 1173cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr ip4; 1174cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1175cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr ip6; 1176cfb6eeb4SYOSHIFUJI Hideaki #endif 1177cfb6eeb4SYOSHIFUJI Hideaki }; 1178cfb6eeb4SYOSHIFUJI Hideaki 1179cfb6eeb4SYOSHIFUJI Hideaki /* - pool: digest algorithm, hash description and scratch buffer */ 1180cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool { 1181cfb6eeb4SYOSHIFUJI Hideaki struct hash_desc md5_desc; 1182cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block md5_blk; 1183cfb6eeb4SYOSHIFUJI Hideaki }; 1184cfb6eeb4SYOSHIFUJI Hideaki 1185cfb6eeb4SYOSHIFUJI Hideaki /* - functions */ 118653d3176bSChangli Gao extern int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key, 1187318cf7aaSEric Dumazet const struct sock *sk, 1188318cf7aaSEric Dumazet const struct request_sock *req, 1189318cf7aaSEric Dumazet const struct sk_buff *skb); 1190cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_key * tcp_v4_md5_lookup(struct sock *sk, 1191cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 119253d3176bSChangli Gao extern int tcp_v4_md5_do_add(struct sock *sk, __be32 addr, u8 *newkey, 1193cfb6eeb4SYOSHIFUJI Hideaki u8 newkeylen); 119453d3176bSChangli Gao extern int tcp_v4_md5_do_del(struct sock *sk, __be32 addr); 1195cfb6eeb4SYOSHIFUJI Hideaki 11969501f972SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 11979501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_keylen ? \ 11989501f972SYOSHIFUJI Hideaki &(struct tcp_md5sig_key) { \ 11999501f972SYOSHIFUJI Hideaki .key = (twsk)->tw_md5_key, \ 12009501f972SYOSHIFUJI Hideaki .keylen = (twsk)->tw_md5_keylen, \ 12019501f972SYOSHIFUJI Hideaki } : NULL) 12029501f972SYOSHIFUJI Hideaki #else 12039501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) NULL 12049501f972SYOSHIFUJI Hideaki #endif 12059501f972SYOSHIFUJI Hideaki 1206765cf997SEric Dumazet extern struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *); 1207cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_free_md5sig_pool(void); 1208cfb6eeb4SYOSHIFUJI Hideaki 120935790c04SEric Dumazet extern struct tcp_md5sig_pool *tcp_get_md5sig_pool(void); 121035790c04SEric Dumazet extern void tcp_put_md5sig_pool(void); 121135790c04SEric Dumazet 1212ca35a0efSEric Dumazet extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *); 1213cf533ea5SEric Dumazet extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *, 121449a72dfbSAdam Langley unsigned header_len); 121549a72dfbSAdam Langley extern int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, 1216cf533ea5SEric Dumazet const struct tcp_md5sig_key *key); 1217cfb6eeb4SYOSHIFUJI Hideaki 1218fe067e8aSDavid S. Miller /* write queue abstraction */ 1219fe067e8aSDavid S. Miller static inline void tcp_write_queue_purge(struct sock *sk) 1220fe067e8aSDavid S. Miller { 1221fe067e8aSDavid S. Miller struct sk_buff *skb; 1222fe067e8aSDavid S. Miller 1223fe067e8aSDavid S. Miller while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) 12243ab224beSHideo Aoki sk_wmem_free_skb(sk, skb); 12253ab224beSHideo Aoki sk_mem_reclaim(sk); 12268818a9d8SIlpo Järvinen tcp_clear_all_retrans_hints(tcp_sk(sk)); 1227fe067e8aSDavid S. Miller } 1228fe067e8aSDavid S. Miller 1229cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk) 1230fe067e8aSDavid S. Miller { 1231cd07a8eaSDavid S. Miller return skb_peek(&sk->sk_write_queue); 1232fe067e8aSDavid S. Miller } 1233fe067e8aSDavid S. Miller 1234cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk) 1235fe067e8aSDavid S. Miller { 1236cd07a8eaSDavid S. Miller return skb_peek_tail(&sk->sk_write_queue); 1237fe067e8aSDavid S. Miller } 1238fe067e8aSDavid S. Miller 1239cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_next(const struct sock *sk, 1240cf533ea5SEric Dumazet const struct sk_buff *skb) 1241fe067e8aSDavid S. Miller { 1242cd07a8eaSDavid S. Miller return skb_queue_next(&sk->sk_write_queue, skb); 1243fe067e8aSDavid S. Miller } 1244fe067e8aSDavid S. Miller 1245cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_prev(const struct sock *sk, 1246cf533ea5SEric Dumazet const struct sk_buff *skb) 1247832d11c5SIlpo Järvinen { 1248832d11c5SIlpo Järvinen return skb_queue_prev(&sk->sk_write_queue, skb); 1249832d11c5SIlpo Järvinen } 1250832d11c5SIlpo Järvinen 1251fe067e8aSDavid S. Miller #define tcp_for_write_queue(skb, sk) \ 1252cd07a8eaSDavid S. Miller skb_queue_walk(&(sk)->sk_write_queue, skb) 1253fe067e8aSDavid S. Miller 1254fe067e8aSDavid S. Miller #define tcp_for_write_queue_from(skb, sk) \ 1255cd07a8eaSDavid S. Miller skb_queue_walk_from(&(sk)->sk_write_queue, skb) 1256fe067e8aSDavid S. Miller 1257234b6860SIlpo Järvinen #define tcp_for_write_queue_from_safe(skb, tmp, sk) \ 1258cd07a8eaSDavid S. Miller skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp) 1259234b6860SIlpo Järvinen 1260cf533ea5SEric Dumazet static inline struct sk_buff *tcp_send_head(const struct sock *sk) 1261fe067e8aSDavid S. Miller { 1262fe067e8aSDavid S. Miller return sk->sk_send_head; 1263fe067e8aSDavid S. Miller } 1264fe067e8aSDavid S. Miller 1265cd07a8eaSDavid S. Miller static inline bool tcp_skb_is_last(const struct sock *sk, 1266cd07a8eaSDavid S. Miller const struct sk_buff *skb) 1267cd07a8eaSDavid S. Miller { 1268cd07a8eaSDavid S. Miller return skb_queue_is_last(&sk->sk_write_queue, skb); 1269cd07a8eaSDavid S. Miller } 1270cd07a8eaSDavid S. Miller 1271cf533ea5SEric Dumazet static inline void tcp_advance_send_head(struct sock *sk, const struct sk_buff *skb) 1272fe067e8aSDavid S. Miller { 1273cd07a8eaSDavid S. Miller if (tcp_skb_is_last(sk, skb)) 1274fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1275cd07a8eaSDavid S. Miller else 1276cd07a8eaSDavid S. Miller sk->sk_send_head = tcp_write_queue_next(sk, skb); 1277fe067e8aSDavid S. Miller } 1278fe067e8aSDavid S. Miller 1279fe067e8aSDavid S. Miller static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked) 1280fe067e8aSDavid S. Miller { 1281fe067e8aSDavid S. Miller if (sk->sk_send_head == skb_unlinked) 1282fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1283fe067e8aSDavid S. Miller } 1284fe067e8aSDavid S. Miller 1285fe067e8aSDavid S. Miller static inline void tcp_init_send_head(struct sock *sk) 1286fe067e8aSDavid S. Miller { 1287fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1288fe067e8aSDavid S. Miller } 1289fe067e8aSDavid S. Miller 1290fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1291fe067e8aSDavid S. Miller { 1292fe067e8aSDavid S. Miller __skb_queue_tail(&sk->sk_write_queue, skb); 1293fe067e8aSDavid S. Miller } 1294fe067e8aSDavid S. Miller 1295fe067e8aSDavid S. Miller static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1296fe067e8aSDavid S. Miller { 1297fe067e8aSDavid S. Miller __tcp_add_write_queue_tail(sk, skb); 1298fe067e8aSDavid S. Miller 1299fe067e8aSDavid S. Miller /* Queue it, remembering where we must start sending. */ 13006859d494SIlpo Järvinen if (sk->sk_send_head == NULL) { 1301fe067e8aSDavid S. Miller sk->sk_send_head = skb; 13026859d494SIlpo Järvinen 13036859d494SIlpo Järvinen if (tcp_sk(sk)->highest_sack == NULL) 13046859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = skb; 13056859d494SIlpo Järvinen } 1306fe067e8aSDavid S. Miller } 1307fe067e8aSDavid S. Miller 1308fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb) 1309fe067e8aSDavid S. Miller { 1310fe067e8aSDavid S. Miller __skb_queue_head(&sk->sk_write_queue, skb); 1311fe067e8aSDavid S. Miller } 1312fe067e8aSDavid S. Miller 1313fe067e8aSDavid S. Miller /* Insert buff after skb on the write queue of sk. */ 1314fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_after(struct sk_buff *skb, 1315fe067e8aSDavid S. Miller struct sk_buff *buff, 1316fe067e8aSDavid S. Miller struct sock *sk) 1317fe067e8aSDavid S. Miller { 13187de6c033SGerrit Renker __skb_queue_after(&sk->sk_write_queue, skb, buff); 1319fe067e8aSDavid S. Miller } 1320fe067e8aSDavid S. Miller 132143f59c89SDavid S. Miller /* Insert new before skb on the write queue of sk. */ 1322fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_before(struct sk_buff *new, 1323fe067e8aSDavid S. Miller struct sk_buff *skb, 1324fe067e8aSDavid S. Miller struct sock *sk) 1325fe067e8aSDavid S. Miller { 132643f59c89SDavid S. Miller __skb_queue_before(&sk->sk_write_queue, skb, new); 13276e421410SIlpo Järvinen 13286e421410SIlpo Järvinen if (sk->sk_send_head == skb) 13296e421410SIlpo Järvinen sk->sk_send_head = new; 1330fe067e8aSDavid S. Miller } 1331fe067e8aSDavid S. Miller 1332fe067e8aSDavid S. Miller static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk) 1333fe067e8aSDavid S. Miller { 1334fe067e8aSDavid S. Miller __skb_unlink(skb, &sk->sk_write_queue); 1335fe067e8aSDavid S. Miller } 1336fe067e8aSDavid S. Miller 1337fe067e8aSDavid S. Miller static inline int tcp_write_queue_empty(struct sock *sk) 1338fe067e8aSDavid S. Miller { 1339fe067e8aSDavid S. Miller return skb_queue_empty(&sk->sk_write_queue); 1340fe067e8aSDavid S. Miller } 1341fe067e8aSDavid S. Miller 134212d50c46SKrishna Kumar static inline void tcp_push_pending_frames(struct sock *sk) 134312d50c46SKrishna Kumar { 134412d50c46SKrishna Kumar if (tcp_send_head(sk)) { 134512d50c46SKrishna Kumar struct tcp_sock *tp = tcp_sk(sk); 134612d50c46SKrishna Kumar 134712d50c46SKrishna Kumar __tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle); 134812d50c46SKrishna Kumar } 134912d50c46SKrishna Kumar } 135012d50c46SKrishna Kumar 1351a47e5a98SIlpo Järvinen /* Start sequence of the highest skb with SACKed bit, valid only if 1352a47e5a98SIlpo Järvinen * sacked > 0 or when the caller has ensured validity by itself. 1353a47e5a98SIlpo Järvinen */ 1354a47e5a98SIlpo Järvinen static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp) 1355a47e5a98SIlpo Järvinen { 1356a47e5a98SIlpo Järvinen if (!tp->sacked_out) 1357a47e5a98SIlpo Järvinen return tp->snd_una; 13586859d494SIlpo Järvinen 13596859d494SIlpo Järvinen if (tp->highest_sack == NULL) 13606859d494SIlpo Järvinen return tp->snd_nxt; 13616859d494SIlpo Järvinen 1362a47e5a98SIlpo Järvinen return TCP_SKB_CB(tp->highest_sack)->seq; 1363a47e5a98SIlpo Järvinen } 1364a47e5a98SIlpo Järvinen 13656859d494SIlpo Järvinen static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb) 13666859d494SIlpo Järvinen { 13676859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL : 13686859d494SIlpo Järvinen tcp_write_queue_next(sk, skb); 13696859d494SIlpo Järvinen } 13706859d494SIlpo Järvinen 13716859d494SIlpo Järvinen static inline struct sk_buff *tcp_highest_sack(struct sock *sk) 13726859d494SIlpo Järvinen { 13736859d494SIlpo Järvinen return tcp_sk(sk)->highest_sack; 13746859d494SIlpo Järvinen } 13756859d494SIlpo Järvinen 13766859d494SIlpo Järvinen static inline void tcp_highest_sack_reset(struct sock *sk) 13776859d494SIlpo Järvinen { 13786859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk); 13796859d494SIlpo Järvinen } 13806859d494SIlpo Järvinen 13816859d494SIlpo Järvinen /* Called when old skb is about to be deleted (to be combined with new skb) */ 13826859d494SIlpo Järvinen static inline void tcp_highest_sack_combine(struct sock *sk, 13836859d494SIlpo Järvinen struct sk_buff *old, 13846859d494SIlpo Järvinen struct sk_buff *new) 13856859d494SIlpo Järvinen { 13866859d494SIlpo Järvinen if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack)) 13876859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = new; 13886859d494SIlpo Järvinen } 13896859d494SIlpo Järvinen 13905aa4b32fSAndreas Petlund /* Determines whether this is a thin stream (which may suffer from 13915aa4b32fSAndreas Petlund * increased latency). Used to trigger latency-reducing mechanisms. 13925aa4b32fSAndreas Petlund */ 13935aa4b32fSAndreas Petlund static inline unsigned int tcp_stream_is_thin(struct tcp_sock *tp) 13945aa4b32fSAndreas Petlund { 13955aa4b32fSAndreas Petlund return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp); 13965aa4b32fSAndreas Petlund } 13975aa4b32fSAndreas Petlund 13981da177e4SLinus Torvalds /* /proc */ 13991da177e4SLinus Torvalds enum tcp_seq_states { 14001da177e4SLinus Torvalds TCP_SEQ_STATE_LISTENING, 14011da177e4SLinus Torvalds TCP_SEQ_STATE_OPENREQ, 14021da177e4SLinus Torvalds TCP_SEQ_STATE_ESTABLISHED, 14031da177e4SLinus Torvalds TCP_SEQ_STATE_TIME_WAIT, 14041da177e4SLinus Torvalds }; 14051da177e4SLinus Torvalds 1406*73cb88ecSArjan van de Ven int tcp_seq_open(struct inode *inode, struct file *file); 1407*73cb88ecSArjan van de Ven 14081da177e4SLinus Torvalds struct tcp_seq_afinfo { 14091da177e4SLinus Torvalds char *name; 14101da177e4SLinus Torvalds sa_family_t family; 1411*73cb88ecSArjan van de Ven const struct file_operations *seq_fops; 14129427c4b3SDenis V. Lunev struct seq_operations seq_ops; 14131da177e4SLinus Torvalds }; 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds struct tcp_iter_state { 1416a4146b1bSDenis V. Lunev struct seq_net_private p; 14171da177e4SLinus Torvalds sa_family_t family; 14181da177e4SLinus Torvalds enum tcp_seq_states state; 14191da177e4SLinus Torvalds struct sock *syn_wait_sk; 1420a8b690f9STom Herbert int bucket, offset, sbucket, num, uid; 1421a8b690f9STom Herbert loff_t last_pos; 14221da177e4SLinus Torvalds }; 14231da177e4SLinus Torvalds 14246f8b13bcSDaniel Lezcano extern int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo); 14256f8b13bcSDaniel Lezcano extern void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo); 14261da177e4SLinus Torvalds 142720380731SArnaldo Carvalho de Melo extern struct request_sock_ops tcp_request_sock_ops; 1428c6aefafbSGlenn Griffin extern struct request_sock_ops tcp6_request_sock_ops; 142920380731SArnaldo Carvalho de Melo 14307d06b2e0SBrian Haley extern void tcp_v4_destroy_sock(struct sock *sk); 143120380731SArnaldo Carvalho de Melo 1432a430a43dSHerbert Xu extern int tcp_v4_gso_send_check(struct sk_buff *skb); 143304ed3e74SMichał Mirosław extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb, u32 features); 1434bf296b12SHerbert Xu extern struct sk_buff **tcp_gro_receive(struct sk_buff **head, 1435bf296b12SHerbert Xu struct sk_buff *skb); 1436bf296b12SHerbert Xu extern struct sk_buff **tcp4_gro_receive(struct sk_buff **head, 1437bf296b12SHerbert Xu struct sk_buff *skb); 1438bf296b12SHerbert Xu extern int tcp_gro_complete(struct sk_buff *skb); 1439bf296b12SHerbert Xu extern int tcp4_gro_complete(struct sk_buff *skb); 1440f4c50d99SHerbert Xu 144120380731SArnaldo Carvalho de Melo #ifdef CONFIG_PROC_FS 144220380731SArnaldo Carvalho de Melo extern int tcp4_proc_init(void); 144320380731SArnaldo Carvalho de Melo extern void tcp4_proc_exit(void); 144420380731SArnaldo Carvalho de Melo #endif 144520380731SArnaldo Carvalho de Melo 1446cfb6eeb4SYOSHIFUJI Hideaki /* TCP af-specific functions */ 1447cfb6eeb4SYOSHIFUJI Hideaki struct tcp_sock_af_ops { 1448cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1449cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1450cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1451cfb6eeb4SYOSHIFUJI Hideaki int (*calc_md5_hash) (char *location, 1452cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *md5, 1453318cf7aaSEric Dumazet const struct sock *sk, 1454318cf7aaSEric Dumazet const struct request_sock *req, 1455318cf7aaSEric Dumazet const struct sk_buff *skb); 1456cfb6eeb4SYOSHIFUJI Hideaki int (*md5_add) (struct sock *sk, 1457cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk, 1458cfb6eeb4SYOSHIFUJI Hideaki u8 *newkey, 1459cfb6eeb4SYOSHIFUJI Hideaki u8 len); 1460cfb6eeb4SYOSHIFUJI Hideaki int (*md5_parse) (struct sock *sk, 1461cfb6eeb4SYOSHIFUJI Hideaki char __user *optval, 1462cfb6eeb4SYOSHIFUJI Hideaki int optlen); 1463cfb6eeb4SYOSHIFUJI Hideaki #endif 1464cfb6eeb4SYOSHIFUJI Hideaki }; 1465cfb6eeb4SYOSHIFUJI Hideaki 1466cfb6eeb4SYOSHIFUJI Hideaki struct tcp_request_sock_ops { 1467cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1468cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1469cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req); 1470e3afe7b7SJohn Dykstra int (*calc_md5_hash) (char *location, 1471e3afe7b7SJohn Dykstra struct tcp_md5sig_key *md5, 1472318cf7aaSEric Dumazet const struct sock *sk, 1473318cf7aaSEric Dumazet const struct request_sock *req, 1474318cf7aaSEric Dumazet const struct sk_buff *skb); 1475cfb6eeb4SYOSHIFUJI Hideaki #endif 1476cfb6eeb4SYOSHIFUJI Hideaki }; 1477cfb6eeb4SYOSHIFUJI Hideaki 1478da5c78c8SWilliam Allen Simpson /* Using SHA1 for now, define some constants. 1479da5c78c8SWilliam Allen Simpson */ 1480da5c78c8SWilliam Allen Simpson #define COOKIE_DIGEST_WORDS (SHA_DIGEST_WORDS) 1481da5c78c8SWilliam Allen Simpson #define COOKIE_MESSAGE_WORDS (SHA_MESSAGE_BYTES / 4) 1482da5c78c8SWilliam Allen Simpson #define COOKIE_WORKSPACE_WORDS (COOKIE_DIGEST_WORDS + COOKIE_MESSAGE_WORDS) 1483da5c78c8SWilliam Allen Simpson 1484da5c78c8SWilliam Allen Simpson extern int tcp_cookie_generator(u32 *bakery); 1485da5c78c8SWilliam Allen Simpson 1486435cf559SWilliam Allen Simpson /** 1487435cf559SWilliam Allen Simpson * struct tcp_cookie_values - each socket needs extra space for the 1488435cf559SWilliam Allen Simpson * cookies, together with (optional) space for any SYN data. 1489435cf559SWilliam Allen Simpson * 1490435cf559SWilliam Allen Simpson * A tcp_sock contains a pointer to the current value, and this is 1491435cf559SWilliam Allen Simpson * cloned to the tcp_timewait_sock. 1492435cf559SWilliam Allen Simpson * 1493435cf559SWilliam Allen Simpson * @cookie_pair: variable data from the option exchange. 1494435cf559SWilliam Allen Simpson * 1495435cf559SWilliam Allen Simpson * @cookie_desired: user specified tcpct_cookie_desired. Zero 1496435cf559SWilliam Allen Simpson * indicates default (sysctl_tcp_cookie_size). 1497435cf559SWilliam Allen Simpson * After cookie sent, remembers size of cookie. 1498435cf559SWilliam Allen Simpson * Range 0, TCP_COOKIE_MIN to TCP_COOKIE_MAX. 1499435cf559SWilliam Allen Simpson * 1500435cf559SWilliam Allen Simpson * @s_data_desired: user specified tcpct_s_data_desired. When the 1501435cf559SWilliam Allen Simpson * constant payload is specified (@s_data_constant), 1502435cf559SWilliam Allen Simpson * holds its length instead. 1503435cf559SWilliam Allen Simpson * Range 0 to TCP_MSS_DESIRED. 1504435cf559SWilliam Allen Simpson * 1505435cf559SWilliam Allen Simpson * @s_data_payload: constant data that is to be included in the 1506435cf559SWilliam Allen Simpson * payload of SYN or SYNACK segments when the 1507435cf559SWilliam Allen Simpson * cookie option is present. 1508435cf559SWilliam Allen Simpson */ 1509435cf559SWilliam Allen Simpson struct tcp_cookie_values { 1510435cf559SWilliam Allen Simpson struct kref kref; 1511435cf559SWilliam Allen Simpson u8 cookie_pair[TCP_COOKIE_PAIR_SIZE]; 1512435cf559SWilliam Allen Simpson u8 cookie_pair_size; 1513435cf559SWilliam Allen Simpson u8 cookie_desired; 1514435cf559SWilliam Allen Simpson u16 s_data_desired:11, 1515435cf559SWilliam Allen Simpson s_data_constant:1, 1516435cf559SWilliam Allen Simpson s_data_in:1, 1517435cf559SWilliam Allen Simpson s_data_out:1, 1518435cf559SWilliam Allen Simpson s_data_unused:2; 1519435cf559SWilliam Allen Simpson u8 s_data_payload[0]; 1520435cf559SWilliam Allen Simpson }; 1521435cf559SWilliam Allen Simpson 1522435cf559SWilliam Allen Simpson static inline void tcp_cookie_values_release(struct kref *kref) 1523435cf559SWilliam Allen Simpson { 1524435cf559SWilliam Allen Simpson kfree(container_of(kref, struct tcp_cookie_values, kref)); 1525435cf559SWilliam Allen Simpson } 1526435cf559SWilliam Allen Simpson 1527435cf559SWilliam Allen Simpson /* The length of constant payload data. Note that s_data_desired is 1528435cf559SWilliam Allen Simpson * overloaded, depending on s_data_constant: either the length of constant 1529435cf559SWilliam Allen Simpson * data (returned here) or the limit on variable data. 1530435cf559SWilliam Allen Simpson */ 1531435cf559SWilliam Allen Simpson static inline int tcp_s_data_size(const struct tcp_sock *tp) 1532435cf559SWilliam Allen Simpson { 1533435cf559SWilliam Allen Simpson return (tp->cookie_values != NULL && tp->cookie_values->s_data_constant) 1534435cf559SWilliam Allen Simpson ? tp->cookie_values->s_data_desired 1535435cf559SWilliam Allen Simpson : 0; 1536435cf559SWilliam Allen Simpson } 1537435cf559SWilliam Allen Simpson 1538435cf559SWilliam Allen Simpson /** 1539435cf559SWilliam Allen Simpson * struct tcp_extend_values - tcp_ipv?.c to tcp_output.c workspace. 1540435cf559SWilliam Allen Simpson * 1541435cf559SWilliam Allen Simpson * As tcp_request_sock has already been extended in other places, the 1542435cf559SWilliam Allen Simpson * only remaining method is to pass stack values along as function 1543435cf559SWilliam Allen Simpson * parameters. These parameters are not needed after sending SYNACK. 1544435cf559SWilliam Allen Simpson * 1545435cf559SWilliam Allen Simpson * @cookie_bakery: cryptographic secret and message workspace. 1546435cf559SWilliam Allen Simpson * 1547435cf559SWilliam Allen Simpson * @cookie_plus: bytes in authenticator/cookie option, copied from 1548435cf559SWilliam Allen Simpson * struct tcp_options_received (above). 1549435cf559SWilliam Allen Simpson */ 1550435cf559SWilliam Allen Simpson struct tcp_extend_values { 1551435cf559SWilliam Allen Simpson struct request_values rv; 1552435cf559SWilliam Allen Simpson u32 cookie_bakery[COOKIE_WORKSPACE_WORDS]; 1553435cf559SWilliam Allen Simpson u8 cookie_plus:6, 1554435cf559SWilliam Allen Simpson cookie_out_never:1, 1555435cf559SWilliam Allen Simpson cookie_in_always:1; 1556435cf559SWilliam Allen Simpson }; 1557435cf559SWilliam Allen Simpson 1558435cf559SWilliam Allen Simpson static inline struct tcp_extend_values *tcp_xv(struct request_values *rvp) 1559435cf559SWilliam Allen Simpson { 1560435cf559SWilliam Allen Simpson return (struct tcp_extend_values *)rvp; 1561435cf559SWilliam Allen Simpson } 1562435cf559SWilliam Allen Simpson 15639b0f976fSDenis V. Lunev extern void tcp_v4_init(void); 156420380731SArnaldo Carvalho de Melo extern void tcp_init(void); 156520380731SArnaldo Carvalho de Melo 15661da177e4SLinus Torvalds #endif /* _TCP_H */ 1567