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 TCP_DEBUG 1 221da177e4SLinus Torvalds #define FASTRETRANS_DEBUG 1 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #include <linux/list.h> 251da177e4SLinus Torvalds #include <linux/tcp.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/cache.h> 281da177e4SLinus Torvalds #include <linux/percpu.h> 29fb286bb2SHerbert Xu #include <linux/skbuff.h> 3097fc2f08SChris Leech #include <linux/dmaengine.h> 31cfb6eeb4SYOSHIFUJI Hideaki #include <linux/crypto.h> 32c6aefafbSGlenn Griffin #include <linux/cryptohash.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> 44c752f073SArnaldo Carvalho de Melo 451da177e4SLinus Torvalds #include <linux/seq_file.h> 461da177e4SLinus Torvalds 470f7ff927SArnaldo Carvalho de Melo extern struct inet_hashinfo tcp_hashinfo; 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds extern atomic_t tcp_orphan_count; 501da177e4SLinus Torvalds extern void tcp_time_wait(struct sock *sk, int state, int timeo); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #define MAX_TCP_HEADER (128 + MAX_HEADER) 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds /* 551da177e4SLinus Torvalds * Never offer a window over 32767 without using window scaling. Some 561da177e4SLinus Torvalds * poor stacks do signed 16bit maths! 571da177e4SLinus Torvalds */ 581da177e4SLinus Torvalds #define MAX_TCP_WINDOW 32767U 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds /* Minimal accepted MSS. It is (60+60+8) - (20+20). */ 611da177e4SLinus Torvalds #define TCP_MIN_MSS 88U 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* Minimal RCV_MSS. */ 641da177e4SLinus Torvalds #define TCP_MIN_RCVMSS 536U 651da177e4SLinus Torvalds 665d424d5aSJohn Heffner /* The least MTU to use for probing */ 675d424d5aSJohn Heffner #define TCP_BASE_MSS 512 685d424d5aSJohn Heffner 691da177e4SLinus Torvalds /* After receiving this amount of duplicate ACKs fast retransmit starts. */ 701da177e4SLinus Torvalds #define TCP_FASTRETRANS_THRESH 3 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds /* Maximal reordering. */ 731da177e4SLinus Torvalds #define TCP_MAX_REORDERING 127 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* Maximal number of ACKs sent quickly to accelerate slow-start. */ 761da177e4SLinus Torvalds #define TCP_MAX_QUICKACKS 16U 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds /* urg_data states */ 791da177e4SLinus Torvalds #define TCP_URG_VALID 0x0100 801da177e4SLinus Torvalds #define TCP_URG_NOTYET 0x0200 811da177e4SLinus Torvalds #define TCP_URG_READ 0x0400 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds #define TCP_RETR1 3 /* 841da177e4SLinus Torvalds * This is how many retries it does before it 851da177e4SLinus Torvalds * tries to figure out if the gateway is 861da177e4SLinus Torvalds * down. Minimal RFC value is 3; it corresponds 871da177e4SLinus Torvalds * to ~3sec-8min depending on RTO. 881da177e4SLinus Torvalds */ 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds #define TCP_RETR2 15 /* 911da177e4SLinus Torvalds * This should take at least 921da177e4SLinus Torvalds * 90 minutes to time out. 931da177e4SLinus Torvalds * RFC1122 says that the limit is 100 sec. 941da177e4SLinus Torvalds * 15 is ~13-30min depending on RTO. 951da177e4SLinus Torvalds */ 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds #define TCP_SYN_RETRIES 5 /* number of times to retry active opening a 98caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds #define TCP_SYNACK_RETRIES 5 /* number of times to retry passive opening a 101caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds #define TCP_ORPHAN_RETRIES 7 /* number of times to retry on an orphaned 1051da177e4SLinus Torvalds * socket. 7 is ~50sec-16min. 1061da177e4SLinus Torvalds */ 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT 1101da177e4SLinus Torvalds * state, about 60 seconds */ 1111da177e4SLinus Torvalds #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN 1121da177e4SLinus Torvalds /* BSD style FIN_WAIT2 deadlock breaker. 1131da177e4SLinus Torvalds * It used to be 3min, new value is 60sec, 1141da177e4SLinus Torvalds * to combine FIN-WAIT-2 timeout with 1151da177e4SLinus Torvalds * TIME-WAIT timer. 1161da177e4SLinus Torvalds */ 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds #define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */ 1191da177e4SLinus Torvalds #if HZ >= 100 1201da177e4SLinus Torvalds #define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */ 1211da177e4SLinus Torvalds #define TCP_ATO_MIN ((unsigned)(HZ/25)) 1221da177e4SLinus Torvalds #else 1231da177e4SLinus Torvalds #define TCP_DELACK_MIN 4U 1241da177e4SLinus Torvalds #define TCP_ATO_MIN 4U 1251da177e4SLinus Torvalds #endif 1261da177e4SLinus Torvalds #define TCP_RTO_MAX ((unsigned)(120*HZ)) 1271da177e4SLinus Torvalds #define TCP_RTO_MIN ((unsigned)(HZ/5)) 1281da177e4SLinus Torvalds #define TCP_TIMEOUT_INIT ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value */ 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes 1311da177e4SLinus Torvalds * for local resources. 1321da177e4SLinus Torvalds */ 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds #define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ 1351da177e4SLinus Torvalds #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ 1361da177e4SLinus Torvalds #define TCP_KEEPALIVE_INTVL (75*HZ) 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds #define MAX_TCP_KEEPIDLE 32767 1391da177e4SLinus Torvalds #define MAX_TCP_KEEPINTVL 32767 1401da177e4SLinus Torvalds #define MAX_TCP_KEEPCNT 127 1411da177e4SLinus Torvalds #define MAX_TCP_SYNCNT 127 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds #define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */ 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24) 1461da177e4SLinus Torvalds #define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated 1471da177e4SLinus Torvalds * after this time. It should be equal 1481da177e4SLinus Torvalds * (or greater than) TCP_TIMEWAIT_LEN 1491da177e4SLinus Torvalds * to provide reliability equal to one 1501da177e4SLinus Torvalds * provided by timewait state. 1511da177e4SLinus Torvalds */ 1521da177e4SLinus Torvalds #define TCP_PAWS_WINDOW 1 /* Replay window for per-host 1531da177e4SLinus Torvalds * timestamps. It must be less than 1541da177e4SLinus Torvalds * minimal timewait lifetime. 1551da177e4SLinus Torvalds */ 1561da177e4SLinus Torvalds /* 1571da177e4SLinus Torvalds * TCP option 1581da177e4SLinus Torvalds */ 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds #define TCPOPT_NOP 1 /* Padding */ 1611da177e4SLinus Torvalds #define TCPOPT_EOL 0 /* End of options */ 1621da177e4SLinus Torvalds #define TCPOPT_MSS 2 /* Segment size negotiating */ 1631da177e4SLinus Torvalds #define TCPOPT_WINDOW 3 /* Window scaling */ 1641da177e4SLinus Torvalds #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ 1651da177e4SLinus Torvalds #define TCPOPT_SACK 5 /* SACK Block */ 1661da177e4SLinus Torvalds #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ 167cfb6eeb4SYOSHIFUJI Hideaki #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds /* 1701da177e4SLinus Torvalds * TCP option lengths 1711da177e4SLinus Torvalds */ 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds #define TCPOLEN_MSS 4 1741da177e4SLinus Torvalds #define TCPOLEN_WINDOW 3 1751da177e4SLinus Torvalds #define TCPOLEN_SACK_PERM 2 1761da177e4SLinus Torvalds #define TCPOLEN_TIMESTAMP 10 177cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG 18 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds /* But this is what stacks really send out. */ 1801da177e4SLinus Torvalds #define TCPOLEN_TSTAMP_ALIGNED 12 1811da177e4SLinus Torvalds #define TCPOLEN_WSCALE_ALIGNED 4 1821da177e4SLinus Torvalds #define TCPOLEN_SACKPERM_ALIGNED 4 1831da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE 2 1841da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE_ALIGNED 4 1851da177e4SLinus Torvalds #define TCPOLEN_SACK_PERBLOCK 8 186cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG_ALIGNED 20 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /* Flags in tp->nonagle */ 1891da177e4SLinus Torvalds #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ 1901da177e4SLinus Torvalds #define TCP_NAGLE_CORK 2 /* Socket is corked */ 191caa20d9aSStephen Hemminger #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ 1921da177e4SLinus Torvalds 193295ff7edSArnaldo Carvalho de Melo extern struct inet_timewait_death_row tcp_death_row; 194295ff7edSArnaldo Carvalho de Melo 1951da177e4SLinus Torvalds /* sysctl variables for tcp */ 1961da177e4SLinus Torvalds extern int sysctl_tcp_timestamps; 1971da177e4SLinus Torvalds extern int sysctl_tcp_window_scaling; 1981da177e4SLinus Torvalds extern int sysctl_tcp_sack; 1991da177e4SLinus Torvalds extern int sysctl_tcp_fin_timeout; 2001da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_time; 2011da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_probes; 2021da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_intvl; 2031da177e4SLinus Torvalds extern int sysctl_tcp_syn_retries; 2041da177e4SLinus Torvalds extern int sysctl_tcp_synack_retries; 2051da177e4SLinus Torvalds extern int sysctl_tcp_retries1; 2061da177e4SLinus Torvalds extern int sysctl_tcp_retries2; 2071da177e4SLinus Torvalds extern int sysctl_tcp_orphan_retries; 2081da177e4SLinus Torvalds extern int sysctl_tcp_syncookies; 2091da177e4SLinus Torvalds extern int sysctl_tcp_retrans_collapse; 2101da177e4SLinus Torvalds extern int sysctl_tcp_stdurg; 2111da177e4SLinus Torvalds extern int sysctl_tcp_rfc1337; 2121da177e4SLinus Torvalds extern int sysctl_tcp_abort_on_overflow; 2131da177e4SLinus Torvalds extern int sysctl_tcp_max_orphans; 2141da177e4SLinus Torvalds extern int sysctl_tcp_fack; 2151da177e4SLinus Torvalds extern int sysctl_tcp_reordering; 2161da177e4SLinus Torvalds extern int sysctl_tcp_ecn; 2171da177e4SLinus Torvalds extern int sysctl_tcp_dsack; 2181da177e4SLinus Torvalds extern int sysctl_tcp_mem[3]; 2191da177e4SLinus Torvalds extern int sysctl_tcp_wmem[3]; 2201da177e4SLinus Torvalds extern int sysctl_tcp_rmem[3]; 2211da177e4SLinus Torvalds extern int sysctl_tcp_app_win; 2221da177e4SLinus Torvalds extern int sysctl_tcp_adv_win_scale; 2231da177e4SLinus Torvalds extern int sysctl_tcp_tw_reuse; 2241da177e4SLinus Torvalds extern int sysctl_tcp_frto; 2253cfe3baaSIlpo Järvinen extern int sysctl_tcp_frto_response; 2261da177e4SLinus Torvalds extern int sysctl_tcp_low_latency; 22795937825SChris Leech extern int sysctl_tcp_dma_copybreak; 2281da177e4SLinus Torvalds extern int sysctl_tcp_nometrics_save; 2291da177e4SLinus Torvalds extern int sysctl_tcp_moderate_rcvbuf; 2301da177e4SLinus Torvalds extern int sysctl_tcp_tso_win_divisor; 2319772efb9SStephen Hemminger extern int sysctl_tcp_abc; 2325d424d5aSJohn Heffner extern int sysctl_tcp_mtu_probing; 2335d424d5aSJohn Heffner extern int sysctl_tcp_base_mss; 23415d99e02SRick Jones extern int sysctl_tcp_workaround_signed_windows; 23535089bb2SDavid S. Miller extern int sysctl_tcp_slow_start_after_idle; 236886236c1SJohn Heffner extern int sysctl_tcp_max_ssthresh; 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds extern atomic_t tcp_memory_allocated; 2391da177e4SLinus Torvalds extern atomic_t tcp_sockets_allocated; 2401da177e4SLinus Torvalds extern int tcp_memory_pressure; 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* 2431da177e4SLinus Torvalds * The next routines deal with comparing 32 bit unsigned ints 2441da177e4SLinus Torvalds * and worry about wraparound (automatic with unsigned arithmetic). 2451da177e4SLinus Torvalds */ 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds static inline int before(__u32 seq1, __u32 seq2) 2481da177e4SLinus Torvalds { 2490d630cc0SGerrit Renker return (__s32)(seq1-seq2) < 0; 2501da177e4SLinus Torvalds } 2519a036b9cSGerrit Renker #define after(seq2, seq1) before(seq1, seq2) 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* is s2<=s1<=s3 ? */ 2541da177e4SLinus Torvalds static inline int between(__u32 seq1, __u32 seq2, __u32 seq3) 2551da177e4SLinus Torvalds { 2561da177e4SLinus Torvalds return seq3 - seq2 >= seq1 - seq2; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 259e4fd5da3SPavel Emelianov static inline int tcp_too_many_orphans(struct sock *sk, int num) 260e4fd5da3SPavel Emelianov { 261e4fd5da3SPavel Emelianov return (num > sysctl_tcp_max_orphans) || 262e4fd5da3SPavel Emelianov (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && 263e4fd5da3SPavel Emelianov atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2]); 264e4fd5da3SPavel Emelianov } 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds extern struct proto tcp_prot; 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds DECLARE_SNMP_STAT(struct tcp_mib, tcp_statistics); 269*81cc8a75SPavel Emelyanov #define TCP_INC_STATS(net, field) do { (void)net; SNMP_INC_STATS(tcp_statistics, field); } while (0) 2701da177e4SLinus Torvalds #define TCP_INC_STATS_BH(field) SNMP_INC_STATS_BH(tcp_statistics, field) 2711da177e4SLinus Torvalds #define TCP_DEC_STATS(field) SNMP_DEC_STATS(tcp_statistics, field) 2721da177e4SLinus Torvalds #define TCP_ADD_STATS_USER(field, val) SNMP_ADD_STATS_USER(tcp_statistics, field, val) 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds extern void tcp_v4_err(struct sk_buff *skb, u32); 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds extern void tcp_shutdown (struct sock *sk, int how); 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds extern int tcp_v4_rcv(struct sk_buff *skb); 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds extern int tcp_v4_remember_stamp(struct sock *sk); 2811da177e4SLinus Torvalds 2828feaf0c0SArnaldo Carvalho de Melo extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw); 2831da177e4SLinus Torvalds 2843516ffb0SDavid S. Miller extern int tcp_sendmsg(struct kiocb *iocb, struct socket *sock, 2851da177e4SLinus Torvalds struct msghdr *msg, size_t size); 2861da177e4SLinus Torvalds extern ssize_t tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags); 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds extern int tcp_ioctl(struct sock *sk, 2891da177e4SLinus Torvalds int cmd, 2901da177e4SLinus Torvalds unsigned long arg); 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds extern int tcp_rcv_state_process(struct sock *sk, 2931da177e4SLinus Torvalds struct sk_buff *skb, 2941da177e4SLinus Torvalds struct tcphdr *th, 2951da177e4SLinus Torvalds unsigned len); 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds extern int tcp_rcv_established(struct sock *sk, 2981da177e4SLinus Torvalds struct sk_buff *skb, 2991da177e4SLinus Torvalds struct tcphdr *th, 3001da177e4SLinus Torvalds unsigned len); 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds extern void tcp_rcv_space_adjust(struct sock *sk); 3031da177e4SLinus Torvalds 3040e4b4992SChris Leech extern void tcp_cleanup_rbuf(struct sock *sk, int copied); 3050e4b4992SChris Leech 3066d6ee43eSArnaldo Carvalho de Melo extern int tcp_twsk_unique(struct sock *sk, 3076d6ee43eSArnaldo Carvalho de Melo struct sock *sktw, void *twp); 3086d6ee43eSArnaldo Carvalho de Melo 309cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_twsk_destructor(struct sock *sk); 310cfb6eeb4SYOSHIFUJI Hideaki 3119c55e01cSJens Axboe extern ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos, 3129c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, unsigned int flags); 3139c55e01cSJens Axboe 314463c84b9SArnaldo Carvalho de Melo static inline void tcp_dec_quickack_mode(struct sock *sk, 315463c84b9SArnaldo Carvalho de Melo const unsigned int pkts) 3161da177e4SLinus Torvalds { 317463c84b9SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 318fc6415bcSDavid S. Miller 319463c84b9SArnaldo Carvalho de Melo if (icsk->icsk_ack.quick) { 320463c84b9SArnaldo Carvalho de Melo if (pkts >= icsk->icsk_ack.quick) { 321463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick = 0; 3221da177e4SLinus Torvalds /* Leaving quickack mode we deflate ATO. */ 323463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.ato = TCP_ATO_MIN; 324fc6415bcSDavid S. Miller } else 325463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick -= pkts; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds } 3281da177e4SLinus Torvalds 329463c84b9SArnaldo Carvalho de Melo extern void tcp_enter_quickack_mode(struct sock *sk); 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds static inline void tcp_clear_options(struct tcp_options_received *rx_opt) 3321da177e4SLinus Torvalds { 3331da177e4SLinus Torvalds rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 336bdf1ee5dSIlpo Järvinen #define TCP_ECN_OK 1 337bdf1ee5dSIlpo Järvinen #define TCP_ECN_QUEUE_CWR 2 338bdf1ee5dSIlpo Järvinen #define TCP_ECN_DEMAND_CWR 4 339bdf1ee5dSIlpo Järvinen 340bdf1ee5dSIlpo Järvinen static __inline__ void 341bdf1ee5dSIlpo Järvinen TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th) 342bdf1ee5dSIlpo Järvinen { 343bdf1ee5dSIlpo Järvinen if (sysctl_tcp_ecn && th->ece && th->cwr) 344bdf1ee5dSIlpo Järvinen inet_rsk(req)->ecn_ok = 1; 345bdf1ee5dSIlpo Järvinen } 346bdf1ee5dSIlpo Järvinen 3471da177e4SLinus Torvalds enum tcp_tw_status 3481da177e4SLinus Torvalds { 3491da177e4SLinus Torvalds TCP_TW_SUCCESS = 0, 3501da177e4SLinus Torvalds TCP_TW_RST = 1, 3511da177e4SLinus Torvalds TCP_TW_ACK = 2, 3521da177e4SLinus Torvalds TCP_TW_SYN = 3 3531da177e4SLinus Torvalds }; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds 3568feaf0c0SArnaldo Carvalho de Melo extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw, 3571da177e4SLinus Torvalds struct sk_buff *skb, 3588feaf0c0SArnaldo Carvalho de Melo const struct tcphdr *th); 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb, 36160236fddSArnaldo Carvalho de Melo struct request_sock *req, 36260236fddSArnaldo Carvalho de Melo struct request_sock **prev); 3631da177e4SLinus Torvalds extern int tcp_child_process(struct sock *parent, 3641da177e4SLinus Torvalds struct sock *child, 3651da177e4SLinus Torvalds struct sk_buff *skb); 36646d0de4eSIlpo Järvinen extern int tcp_use_frto(struct sock *sk); 3671da177e4SLinus Torvalds extern void tcp_enter_frto(struct sock *sk); 3681da177e4SLinus Torvalds extern void tcp_enter_loss(struct sock *sk, int how); 3691da177e4SLinus Torvalds extern void tcp_clear_retrans(struct tcp_sock *tp); 3701da177e4SLinus Torvalds extern void tcp_update_metrics(struct sock *sk); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds extern void tcp_close(struct sock *sk, 3731da177e4SLinus Torvalds long timeout); 3741da177e4SLinus Torvalds extern unsigned int tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait); 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds extern int tcp_getsockopt(struct sock *sk, int level, 3771da177e4SLinus Torvalds int optname, 3781da177e4SLinus Torvalds char __user *optval, 3791da177e4SLinus Torvalds int __user *optlen); 3801da177e4SLinus Torvalds extern int tcp_setsockopt(struct sock *sk, int level, 3811da177e4SLinus Torvalds int optname, char __user *optval, 3821da177e4SLinus Torvalds int optlen); 3833fdadf7dSDmitry Mishin extern int compat_tcp_getsockopt(struct sock *sk, 3843fdadf7dSDmitry Mishin int level, int optname, 3853fdadf7dSDmitry Mishin char __user *optval, int __user *optlen); 3863fdadf7dSDmitry Mishin extern int compat_tcp_setsockopt(struct sock *sk, 3873fdadf7dSDmitry Mishin int level, int optname, 3883fdadf7dSDmitry Mishin char __user *optval, int optlen); 3891da177e4SLinus Torvalds extern void tcp_set_keepalive(struct sock *sk, int val); 3901da177e4SLinus Torvalds extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, 3911da177e4SLinus Torvalds struct msghdr *msg, 3921da177e4SLinus Torvalds size_t len, int nonblock, 3931da177e4SLinus Torvalds int flags, int *addr_len); 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds extern void tcp_parse_options(struct sk_buff *skb, 3961da177e4SLinus Torvalds struct tcp_options_received *opt_rx, 3971da177e4SLinus Torvalds int estab); 3981da177e4SLinus Torvalds 3997d5d5525SYOSHIFUJI Hideaki extern u8 *tcp_parse_md5sig_option(struct tcphdr *th); 4007d5d5525SYOSHIFUJI Hideaki 4011da177e4SLinus Torvalds /* 4021da177e4SLinus Torvalds * TCP v4 functions exported for the inet6 API 4031da177e4SLinus Torvalds */ 4041da177e4SLinus Torvalds 4058292a17aSArnaldo Carvalho de Melo extern void tcp_v4_send_check(struct sock *sk, int len, 4061da177e4SLinus Torvalds struct sk_buff *skb); 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds extern int tcp_v4_conn_request(struct sock *sk, 4091da177e4SLinus Torvalds struct sk_buff *skb); 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds extern struct sock * tcp_create_openreq_child(struct sock *sk, 41260236fddSArnaldo Carvalho de Melo struct request_sock *req, 4131da177e4SLinus Torvalds struct sk_buff *skb); 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, 4161da177e4SLinus Torvalds struct sk_buff *skb, 41760236fddSArnaldo Carvalho de Melo struct request_sock *req, 4181da177e4SLinus Torvalds struct dst_entry *dst); 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds extern int tcp_v4_do_rcv(struct sock *sk, 4211da177e4SLinus Torvalds struct sk_buff *skb); 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds extern int tcp_v4_connect(struct sock *sk, 4241da177e4SLinus Torvalds struct sockaddr *uaddr, 4251da177e4SLinus Torvalds int addr_len); 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds extern int tcp_connect(struct sock *sk); 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds extern struct sk_buff * tcp_make_synack(struct sock *sk, 4301da177e4SLinus Torvalds struct dst_entry *dst, 43160236fddSArnaldo Carvalho de Melo struct request_sock *req); 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds extern int tcp_disconnect(struct sock *sk, int flags); 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds /* From syncookies.c */ 4372051f11fSFlorian Westphal extern __u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS]; 4381da177e4SLinus Torvalds extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 4391da177e4SLinus Torvalds struct ip_options *opt); 4401da177e4SLinus Torvalds extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, 4411da177e4SLinus Torvalds __u16 *mss); 4421da177e4SLinus Torvalds 4434dfc2817SFlorian Westphal extern __u32 cookie_init_timestamp(struct request_sock *req); 4444dfc2817SFlorian Westphal extern void cookie_check_timestamp(struct tcp_options_received *tcp_opt); 4454dfc2817SFlorian Westphal 446c6aefafbSGlenn Griffin /* From net/ipv6/syncookies.c */ 447c6aefafbSGlenn Griffin extern struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb); 448c6aefafbSGlenn Griffin extern __u32 cookie_v6_init_sequence(struct sock *sk, struct sk_buff *skb, 449c6aefafbSGlenn Griffin __u16 *mss); 450c6aefafbSGlenn Griffin 4511da177e4SLinus Torvalds /* tcp_output.c */ 4521da177e4SLinus Torvalds 4539e412ba7SIlpo Järvinen extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, 4549e412ba7SIlpo Järvinen int nonagle); 4559e412ba7SIlpo Järvinen extern int tcp_may_send_now(struct sock *sk); 4561da177e4SLinus Torvalds extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); 4571da177e4SLinus Torvalds extern void tcp_xmit_retransmit_queue(struct sock *); 4581da177e4SLinus Torvalds extern void tcp_simple_retransmit(struct sock *); 4591da177e4SLinus Torvalds extern int tcp_trim_head(struct sock *, struct sk_buff *, u32); 4606475be16SDavid S. Miller extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int); 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds extern void tcp_send_probe0(struct sock *); 4631da177e4SLinus Torvalds extern void tcp_send_partial(struct sock *); 4641da177e4SLinus Torvalds extern int tcp_write_wakeup(struct sock *); 4651da177e4SLinus Torvalds extern void tcp_send_fin(struct sock *sk); 466dd0fc66fSAl Viro extern void tcp_send_active_reset(struct sock *sk, gfp_t priority); 4671da177e4SLinus Torvalds extern int tcp_send_synack(struct sock *); 468c1b4a7e6SDavid S. Miller extern void tcp_push_one(struct sock *, unsigned int mss_now); 4691da177e4SLinus Torvalds extern void tcp_send_ack(struct sock *sk); 4701da177e4SLinus Torvalds extern void tcp_send_delayed_ack(struct sock *sk); 4711da177e4SLinus Torvalds 472a762a980SDavid S. Miller /* tcp_input.c */ 473a762a980SDavid S. Miller extern void tcp_cwnd_application_limited(struct sock *sk); 474a762a980SDavid S. Miller 4751da177e4SLinus Torvalds /* tcp_timer.c */ 4761da177e4SLinus Torvalds extern void tcp_init_xmit_timers(struct sock *); 477463c84b9SArnaldo Carvalho de Melo static inline void tcp_clear_xmit_timers(struct sock *sk) 478463c84b9SArnaldo Carvalho de Melo { 479463c84b9SArnaldo Carvalho de Melo inet_csk_clear_xmit_timers(sk); 480463c84b9SArnaldo Carvalho de Melo } 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu); 4831da177e4SLinus Torvalds extern unsigned int tcp_current_mss(struct sock *sk, int large); 4841da177e4SLinus Torvalds 48517b085eaSArnaldo Carvalho de Melo /* tcp.c */ 4861da177e4SLinus Torvalds extern void tcp_get_info(struct sock *, struct tcp_info *); 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds /* Read 'sendfile()'-style from a TCP socket */ 4891da177e4SLinus Torvalds typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, 4901da177e4SLinus Torvalds unsigned int, size_t); 4911da177e4SLinus Torvalds extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, 4921da177e4SLinus Torvalds sk_read_actor_t recv_actor); 4931da177e4SLinus Torvalds 49440efc6faSStephen Hemminger extern void tcp_initialize_rcv_mss(struct sock *sk); 4951da177e4SLinus Torvalds 4965d424d5aSJohn Heffner extern int tcp_mtu_to_mss(struct sock *sk, int pmtu); 4975d424d5aSJohn Heffner extern int tcp_mss_to_mtu(struct sock *sk, int mss); 4985d424d5aSJohn Heffner extern void tcp_mtup_init(struct sock *sk); 4995d424d5aSJohn Heffner 50040efc6faSStephen Hemminger static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) 5011da177e4SLinus Torvalds { 5021da177e4SLinus Torvalds tp->pred_flags = htonl((tp->tcp_header_len << 26) | 5031da177e4SLinus Torvalds ntohl(TCP_FLAG_ACK) | 5041da177e4SLinus Torvalds snd_wnd); 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds 50740efc6faSStephen Hemminger static inline void tcp_fast_path_on(struct tcp_sock *tp) 5081da177e4SLinus Torvalds { 5091da177e4SLinus Torvalds __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds 5129e412ba7SIlpo Järvinen static inline void tcp_fast_path_check(struct sock *sk) 5131da177e4SLinus Torvalds { 5149e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 5159e412ba7SIlpo Järvinen 516b03efcfbSDavid S. Miller if (skb_queue_empty(&tp->out_of_order_queue) && 5171da177e4SLinus Torvalds tp->rcv_wnd && 5181da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && 5191da177e4SLinus Torvalds !tp->urg_data) 5201da177e4SLinus Torvalds tcp_fast_path_on(tp); 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds /* Compute the actual receive window we are currently advertising. 5241da177e4SLinus Torvalds * Rcv_nxt can be after the window if our peer push more data 5251da177e4SLinus Torvalds * than the offered window. 5261da177e4SLinus Torvalds */ 52740efc6faSStephen Hemminger static inline u32 tcp_receive_window(const struct tcp_sock *tp) 5281da177e4SLinus Torvalds { 5291da177e4SLinus Torvalds s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds if (win < 0) 5321da177e4SLinus Torvalds win = 0; 5331da177e4SLinus Torvalds return (u32) win; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds /* Choose a new window, without checks for shrinking, and without 5371da177e4SLinus Torvalds * scaling applied to the result. The caller does these things 5381da177e4SLinus Torvalds * if necessary. This is a "raw" window selection. 5391da177e4SLinus Torvalds */ 5401da177e4SLinus Torvalds extern u32 __tcp_select_window(struct sock *sk); 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds /* TCP timestamps are only 32-bits, this causes a slight 5431da177e4SLinus Torvalds * complication on 64-bit systems since we store a snapshot 54431f34269SStephen Hemminger * of jiffies in the buffer control blocks below. We decided 54531f34269SStephen Hemminger * to use only the low 32-bits of jiffies and hide the ugly 5461da177e4SLinus Torvalds * casts with the following macro. 5471da177e4SLinus Torvalds */ 5481da177e4SLinus Torvalds #define tcp_time_stamp ((__u32)(jiffies)) 5491da177e4SLinus Torvalds 550caa20d9aSStephen Hemminger /* This is what the send packet queuing engine uses to pass 5511da177e4SLinus Torvalds * TCP per-packet control information to the transmission 5521da177e4SLinus Torvalds * code. We also store the host-order sequence numbers in 5531da177e4SLinus Torvalds * here too. This is 36 bytes on 32-bit architectures, 5541da177e4SLinus Torvalds * 40 bytes on 64-bit machines, if this grows please adjust 5551da177e4SLinus Torvalds * skbuff.h:skbuff->cb[xxx] size appropriately. 5561da177e4SLinus Torvalds */ 5571da177e4SLinus Torvalds struct tcp_skb_cb { 5581da177e4SLinus Torvalds union { 5591da177e4SLinus Torvalds struct inet_skb_parm h4; 5601da177e4SLinus Torvalds #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) 5611da177e4SLinus Torvalds struct inet6_skb_parm h6; 5621da177e4SLinus Torvalds #endif 5631da177e4SLinus Torvalds } header; /* For incoming frames */ 5641da177e4SLinus Torvalds __u32 seq; /* Starting sequence number */ 5651da177e4SLinus Torvalds __u32 end_seq; /* SEQ + FIN + SYN + datalen */ 5661da177e4SLinus Torvalds __u32 when; /* used to compute rtt's */ 5671da177e4SLinus Torvalds __u8 flags; /* TCP header flags. */ 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* NOTE: These must match up to the flags byte in a 5701da177e4SLinus Torvalds * real TCP header. 5711da177e4SLinus Torvalds */ 5721da177e4SLinus Torvalds #define TCPCB_FLAG_FIN 0x01 5731da177e4SLinus Torvalds #define TCPCB_FLAG_SYN 0x02 5741da177e4SLinus Torvalds #define TCPCB_FLAG_RST 0x04 5751da177e4SLinus Torvalds #define TCPCB_FLAG_PSH 0x08 5761da177e4SLinus Torvalds #define TCPCB_FLAG_ACK 0x10 5771da177e4SLinus Torvalds #define TCPCB_FLAG_URG 0x20 5781da177e4SLinus Torvalds #define TCPCB_FLAG_ECE 0x40 5791da177e4SLinus Torvalds #define TCPCB_FLAG_CWR 0x80 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds __u8 sacked; /* State flags for SACK/FACK. */ 5821da177e4SLinus Torvalds #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ 5831da177e4SLinus Torvalds #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ 5841da177e4SLinus Torvalds #define TCPCB_LOST 0x04 /* SKB is lost */ 5851da177e4SLinus Torvalds #define TCPCB_TAGBITS 0x07 /* All tag bits */ 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ 5881da177e4SLinus Torvalds #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS) 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds __u16 urg_ptr; /* Valid w/URG flags is set. */ 5911da177e4SLinus Torvalds __u32 ack_seq; /* Sequence number ACK'd */ 5921da177e4SLinus Torvalds }; 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds /* Due to TSO, an SKB can be composed of multiple actual 5971da177e4SLinus Torvalds * packets. To keep these tracked properly, we use this. 5981da177e4SLinus Torvalds */ 5991da177e4SLinus Torvalds static inline int tcp_skb_pcount(const struct sk_buff *skb) 6001da177e4SLinus Torvalds { 6017967168cSHerbert Xu return skb_shinfo(skb)->gso_segs; 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds /* This is valid iff tcp_skb_pcount() > 1. */ 6051da177e4SLinus Torvalds static inline int tcp_skb_mss(const struct sk_buff *skb) 6061da177e4SLinus Torvalds { 6077967168cSHerbert Xu return skb_shinfo(skb)->gso_size; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 610af610b4cSIlpo Järvinen static inline void tcp_dec_pcount_approx_int(__u32 *count, const int decr) 6111da177e4SLinus Torvalds { 6121da177e4SLinus Torvalds if (*count) { 613af610b4cSIlpo Järvinen *count -= decr; 6141da177e4SLinus Torvalds if ((int)*count < 0) 6151da177e4SLinus Torvalds *count = 0; 6161da177e4SLinus Torvalds } 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 619af610b4cSIlpo Järvinen static inline void tcp_dec_pcount_approx(__u32 *count, 620af610b4cSIlpo Järvinen const struct sk_buff *skb) 621af610b4cSIlpo Järvinen { 622af610b4cSIlpo Järvinen tcp_dec_pcount_approx_int(count, tcp_skb_pcount(skb)); 623af610b4cSIlpo Järvinen } 624af610b4cSIlpo Järvinen 625317a76f9SStephen Hemminger /* Events passed to congestion control interface */ 626317a76f9SStephen Hemminger enum tcp_ca_event { 627317a76f9SStephen Hemminger CA_EVENT_TX_START, /* first transmit when no packets in flight */ 628317a76f9SStephen Hemminger CA_EVENT_CWND_RESTART, /* congestion window restart */ 629317a76f9SStephen Hemminger CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */ 630317a76f9SStephen Hemminger CA_EVENT_FRTO, /* fast recovery timeout */ 631317a76f9SStephen Hemminger CA_EVENT_LOSS, /* loss timeout */ 632317a76f9SStephen Hemminger CA_EVENT_FAST_ACK, /* in sequence ack */ 633317a76f9SStephen Hemminger CA_EVENT_SLOW_ACK, /* other ack */ 634317a76f9SStephen Hemminger }; 635317a76f9SStephen Hemminger 636317a76f9SStephen Hemminger /* 637317a76f9SStephen Hemminger * Interface for adding new TCP congestion control handlers 638317a76f9SStephen Hemminger */ 639317a76f9SStephen Hemminger #define TCP_CA_NAME_MAX 16 6403ff825b2SStephen Hemminger #define TCP_CA_MAX 128 6413ff825b2SStephen Hemminger #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX) 6423ff825b2SStephen Hemminger 643164891aaSStephen Hemminger #define TCP_CONG_NON_RESTRICTED 0x1 644164891aaSStephen Hemminger #define TCP_CONG_RTT_STAMP 0x2 645164891aaSStephen Hemminger 646317a76f9SStephen Hemminger struct tcp_congestion_ops { 647317a76f9SStephen Hemminger struct list_head list; 648164891aaSStephen Hemminger unsigned long flags; 649317a76f9SStephen Hemminger 650317a76f9SStephen Hemminger /* initialize private data (optional) */ 6516687e988SArnaldo Carvalho de Melo void (*init)(struct sock *sk); 652317a76f9SStephen Hemminger /* cleanup private data (optional) */ 6536687e988SArnaldo Carvalho de Melo void (*release)(struct sock *sk); 654317a76f9SStephen Hemminger 655317a76f9SStephen Hemminger /* return slow start threshold (required) */ 6566687e988SArnaldo Carvalho de Melo u32 (*ssthresh)(struct sock *sk); 657317a76f9SStephen Hemminger /* lower bound for congestion window (optional) */ 65872dc5b92SStephen Hemminger u32 (*min_cwnd)(const struct sock *sk); 659317a76f9SStephen Hemminger /* do new cwnd calculation (required) */ 660c3a05c60SIlpo Järvinen void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight); 661317a76f9SStephen Hemminger /* call before changing ca_state (optional) */ 6626687e988SArnaldo Carvalho de Melo void (*set_state)(struct sock *sk, u8 new_state); 663317a76f9SStephen Hemminger /* call when cwnd event occurs (optional) */ 6646687e988SArnaldo Carvalho de Melo void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); 665317a76f9SStephen Hemminger /* new value of cwnd after loss (optional) */ 6666687e988SArnaldo Carvalho de Melo u32 (*undo_cwnd)(struct sock *sk); 667317a76f9SStephen Hemminger /* hook for packet ack accounting (optional) */ 66830cfd0baSStephen Hemminger void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); 66973c1f4a0SArnaldo Carvalho de Melo /* get info for inet_diag (optional) */ 6706687e988SArnaldo Carvalho de Melo void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb); 671317a76f9SStephen Hemminger 672317a76f9SStephen Hemminger char name[TCP_CA_NAME_MAX]; 673317a76f9SStephen Hemminger struct module *owner; 674317a76f9SStephen Hemminger }; 675317a76f9SStephen Hemminger 676317a76f9SStephen Hemminger extern int tcp_register_congestion_control(struct tcp_congestion_ops *type); 677317a76f9SStephen Hemminger extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); 678317a76f9SStephen Hemminger 6796687e988SArnaldo Carvalho de Melo extern void tcp_init_congestion_control(struct sock *sk); 6806687e988SArnaldo Carvalho de Melo extern void tcp_cleanup_congestion_control(struct sock *sk); 681317a76f9SStephen Hemminger extern int tcp_set_default_congestion_control(const char *name); 682317a76f9SStephen Hemminger extern void tcp_get_default_congestion_control(char *name); 6833ff825b2SStephen Hemminger extern void tcp_get_available_congestion_control(char *buf, size_t len); 684ce7bc3bfSStephen Hemminger extern void tcp_get_allowed_congestion_control(char *buf, size_t len); 685ce7bc3bfSStephen Hemminger extern int tcp_set_allowed_congestion_control(char *allowed); 6866687e988SArnaldo Carvalho de Melo extern int tcp_set_congestion_control(struct sock *sk, const char *name); 68740efc6faSStephen Hemminger extern void tcp_slow_start(struct tcp_sock *tp); 688317a76f9SStephen Hemminger 6895f8ef48dSStephen Hemminger extern struct tcp_congestion_ops tcp_init_congestion_ops; 6906687e988SArnaldo Carvalho de Melo extern u32 tcp_reno_ssthresh(struct sock *sk); 691c3a05c60SIlpo Järvinen extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight); 69272dc5b92SStephen Hemminger extern u32 tcp_reno_min_cwnd(const struct sock *sk); 693a8acfbacSDavid S. Miller extern struct tcp_congestion_ops tcp_reno; 694317a76f9SStephen Hemminger 6956687e988SArnaldo Carvalho de Melo static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state) 696317a76f9SStephen Hemminger { 6976687e988SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 6986687e988SArnaldo Carvalho de Melo 6996687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->set_state) 7006687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->set_state(sk, ca_state); 7016687e988SArnaldo Carvalho de Melo icsk->icsk_ca_state = ca_state; 702317a76f9SStephen Hemminger } 703317a76f9SStephen Hemminger 7046687e988SArnaldo Carvalho de Melo static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) 705317a76f9SStephen Hemminger { 7066687e988SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 7076687e988SArnaldo Carvalho de Melo 7086687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->cwnd_event) 7096687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->cwnd_event(sk, event); 710317a76f9SStephen Hemminger } 711317a76f9SStephen Hemminger 712e60402d0SIlpo Järvinen /* These functions determine how the current flow behaves in respect of SACK 713e60402d0SIlpo Järvinen * handling. SACK is negotiated with the peer, and therefore it can vary 714e60402d0SIlpo Järvinen * between different flows. 715e60402d0SIlpo Järvinen * 716e60402d0SIlpo Järvinen * tcp_is_sack - SACK enabled 717e60402d0SIlpo Järvinen * tcp_is_reno - No SACK 718e60402d0SIlpo Järvinen * tcp_is_fack - FACK enabled, implies SACK enabled 719e60402d0SIlpo Järvinen */ 720e60402d0SIlpo Järvinen static inline int tcp_is_sack(const struct tcp_sock *tp) 721e60402d0SIlpo Järvinen { 722e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok; 723e60402d0SIlpo Järvinen } 724e60402d0SIlpo Järvinen 725e60402d0SIlpo Järvinen static inline int tcp_is_reno(const struct tcp_sock *tp) 726e60402d0SIlpo Järvinen { 727e60402d0SIlpo Järvinen return !tcp_is_sack(tp); 728e60402d0SIlpo Järvinen } 729e60402d0SIlpo Järvinen 730e60402d0SIlpo Järvinen static inline int tcp_is_fack(const struct tcp_sock *tp) 731e60402d0SIlpo Järvinen { 732e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok & 2; 733e60402d0SIlpo Järvinen } 734e60402d0SIlpo Järvinen 735e60402d0SIlpo Järvinen static inline void tcp_enable_fack(struct tcp_sock *tp) 736e60402d0SIlpo Järvinen { 737e60402d0SIlpo Järvinen tp->rx_opt.sack_ok |= 2; 738e60402d0SIlpo Järvinen } 739e60402d0SIlpo Järvinen 74083ae4088SIlpo Järvinen static inline unsigned int tcp_left_out(const struct tcp_sock *tp) 74183ae4088SIlpo Järvinen { 74283ae4088SIlpo Järvinen return tp->sacked_out + tp->lost_out; 74383ae4088SIlpo Järvinen } 74483ae4088SIlpo Järvinen 7451da177e4SLinus Torvalds /* This determines how many packets are "in the network" to the best 7461da177e4SLinus Torvalds * of our knowledge. In many cases it is conservative, but where 7471da177e4SLinus Torvalds * detailed information is available from the receiver (via SACK 7481da177e4SLinus Torvalds * blocks etc.) we can make more aggressive calculations. 7491da177e4SLinus Torvalds * 7501da177e4SLinus Torvalds * Use this for decisions involving congestion control, use just 7511da177e4SLinus Torvalds * tp->packets_out to determine if the send queue is empty or not. 7521da177e4SLinus Torvalds * 7531da177e4SLinus Torvalds * Read this equation as: 7541da177e4SLinus Torvalds * 7551da177e4SLinus Torvalds * "Packets sent once on transmission queue" MINUS 7561da177e4SLinus Torvalds * "Packets left network, but not honestly ACKed yet" PLUS 7571da177e4SLinus Torvalds * "Packets fast retransmitted" 7581da177e4SLinus Torvalds */ 75940efc6faSStephen Hemminger static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 7601da177e4SLinus Torvalds { 76183ae4088SIlpo Järvinen return tp->packets_out - tcp_left_out(tp) + tp->retrans_out; 7621da177e4SLinus Torvalds } 7631da177e4SLinus Torvalds 764882bebaaSIlpo Järvinen extern int tcp_limit_reno_sacked(struct tcp_sock *tp); 765882bebaaSIlpo Järvinen 7661da177e4SLinus Torvalds /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. 7671da177e4SLinus Torvalds * The exception is rate halving phase, when cwnd is decreasing towards 7681da177e4SLinus Torvalds * ssthresh. 7691da177e4SLinus Torvalds */ 7706687e988SArnaldo Carvalho de Melo static inline __u32 tcp_current_ssthresh(const struct sock *sk) 7711da177e4SLinus Torvalds { 7726687e988SArnaldo Carvalho de Melo const struct tcp_sock *tp = tcp_sk(sk); 7736687e988SArnaldo Carvalho de Melo if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery)) 7741da177e4SLinus Torvalds return tp->snd_ssthresh; 7751da177e4SLinus Torvalds else 7761da177e4SLinus Torvalds return max(tp->snd_ssthresh, 7771da177e4SLinus Torvalds ((tp->snd_cwnd >> 1) + 7781da177e4SLinus Torvalds (tp->snd_cwnd >> 2))); 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 781b9c4595bSIlpo Järvinen /* Use define here intentionally to get WARN_ON location shown at the caller */ 782b9c4595bSIlpo Järvinen #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out) 7831da177e4SLinus Torvalds 7843cfe3baaSIlpo Järvinen extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh); 7851da177e4SLinus Torvalds extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst); 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds /* Slow start with delack produces 3 packets of burst, so that 788dd9e0ddaSJohn Heffner * it is safe "de facto". This will be the default - same as 789dd9e0ddaSJohn Heffner * the default reordering threshold - but if reordering increases, 790dd9e0ddaSJohn Heffner * we must be able to allow cwnd to burst at least this much in order 791dd9e0ddaSJohn Heffner * to not pull it back when holes are filled. 7921da177e4SLinus Torvalds */ 7931da177e4SLinus Torvalds static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) 7941da177e4SLinus Torvalds { 795dd9e0ddaSJohn Heffner return tp->reordering; 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds 79890840defSIlpo Järvinen /* Returns end sequence number of the receiver's advertised window */ 79990840defSIlpo Järvinen static inline u32 tcp_wnd_end(const struct tcp_sock *tp) 80090840defSIlpo Järvinen { 80190840defSIlpo Järvinen return tp->snd_una + tp->snd_wnd; 80290840defSIlpo Järvinen } 803cea14e0eSIlpo Järvinen extern int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight); 804f4805edeSStephen Hemminger 805c1bd24b7SChuck Lever static inline void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss, 8061da177e4SLinus Torvalds const struct sk_buff *skb) 8071da177e4SLinus Torvalds { 8081da177e4SLinus Torvalds if (skb->len < mss) 8091da177e4SLinus Torvalds tp->snd_sml = TCP_SKB_CB(skb)->end_seq; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds 8129e412ba7SIlpo Järvinen static inline void tcp_check_probe_timer(struct sock *sk) 8131da177e4SLinus Torvalds { 8149e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 815463c84b9SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 8169e412ba7SIlpo Järvinen 817463c84b9SArnaldo Carvalho de Melo if (!tp->packets_out && !icsk->icsk_pending) 8183f421baaSArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, 8193f421baaSArnaldo Carvalho de Melo icsk->icsk_rto, TCP_RTO_MAX); 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 8229e412ba7SIlpo Järvinen static inline void tcp_push_pending_frames(struct sock *sk) 8231da177e4SLinus Torvalds { 8249e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 8259e412ba7SIlpo Järvinen 8269e412ba7SIlpo Järvinen __tcp_push_pending_frames(sk, tcp_current_mss(sk, 1), tp->nonagle); 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds 82940efc6faSStephen Hemminger static inline void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq) 8301da177e4SLinus Torvalds { 8311da177e4SLinus Torvalds tp->snd_wl1 = seq; 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds 83440efc6faSStephen Hemminger static inline void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq) 8351da177e4SLinus Torvalds { 8361da177e4SLinus Torvalds tp->snd_wl1 = seq; 8371da177e4SLinus Torvalds } 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds /* 8401da177e4SLinus Torvalds * Calculate(/check) TCP checksum 8411da177e4SLinus Torvalds */ 842ba7808eaSFrederik Deweerdt static inline __sum16 tcp_v4_check(int len, __be32 saddr, 843ba7808eaSFrederik Deweerdt __be32 daddr, __wsum base) 8441da177e4SLinus Torvalds { 8451da177e4SLinus Torvalds return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds 848b51655b9SAl Viro static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb) 8491da177e4SLinus Torvalds { 850fb286bb2SHerbert Xu return __skb_checksum_complete(skb); 8511da177e4SLinus Torvalds } 8521da177e4SLinus Torvalds 85340efc6faSStephen Hemminger static inline int tcp_checksum_complete(struct sk_buff *skb) 8541da177e4SLinus Torvalds { 85560476372SHerbert Xu return !skb_csum_unnecessary(skb) && 8561da177e4SLinus Torvalds __tcp_checksum_complete(skb); 8571da177e4SLinus Torvalds } 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds /* Prequeue for VJ style copy to user, combined with checksumming. */ 8601da177e4SLinus Torvalds 86140efc6faSStephen Hemminger static inline void tcp_prequeue_init(struct tcp_sock *tp) 8621da177e4SLinus Torvalds { 8631da177e4SLinus Torvalds tp->ucopy.task = NULL; 8641da177e4SLinus Torvalds tp->ucopy.len = 0; 8651da177e4SLinus Torvalds tp->ucopy.memory = 0; 8661da177e4SLinus Torvalds skb_queue_head_init(&tp->ucopy.prequeue); 86797fc2f08SChris Leech #ifdef CONFIG_NET_DMA 86897fc2f08SChris Leech tp->ucopy.dma_chan = NULL; 86997fc2f08SChris Leech tp->ucopy.wakeup = 0; 87097fc2f08SChris Leech tp->ucopy.pinned_list = NULL; 87197fc2f08SChris Leech tp->ucopy.dma_cookie = 0; 87297fc2f08SChris Leech #endif 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds /* Packet is added to VJ-style prequeue for processing in process 8761da177e4SLinus Torvalds * context, if a reader task is waiting. Apparently, this exciting 8771da177e4SLinus Torvalds * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93) 8781da177e4SLinus Torvalds * failed somewhere. Latency? Burstiness? Well, at least now we will 8791da177e4SLinus Torvalds * see, why it failed. 8)8) --ANK 8801da177e4SLinus Torvalds * 8811da177e4SLinus Torvalds * NOTE: is this not too big to inline? 8821da177e4SLinus Torvalds */ 88340efc6faSStephen Hemminger static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) 8841da177e4SLinus Torvalds { 8851da177e4SLinus Torvalds struct tcp_sock *tp = tcp_sk(sk); 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds if (!sysctl_tcp_low_latency && tp->ucopy.task) { 8881da177e4SLinus Torvalds __skb_queue_tail(&tp->ucopy.prequeue, skb); 8891da177e4SLinus Torvalds tp->ucopy.memory += skb->truesize; 8901da177e4SLinus Torvalds if (tp->ucopy.memory > sk->sk_rcvbuf) { 8911da177e4SLinus Torvalds struct sk_buff *skb1; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds BUG_ON(sock_owned_by_user(sk)); 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) { 8961da177e4SLinus Torvalds sk->sk_backlog_rcv(sk, skb1); 8971da177e4SLinus Torvalds NET_INC_STATS_BH(LINUX_MIB_TCPPREQUEUEDROPPED); 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds tp->ucopy.memory = 0; 9011da177e4SLinus Torvalds } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) { 9021da177e4SLinus Torvalds wake_up_interruptible(sk->sk_sleep); 903463c84b9SArnaldo Carvalho de Melo if (!inet_csk_ack_scheduled(sk)) 904463c84b9SArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, 9053f421baaSArnaldo Carvalho de Melo (3 * TCP_RTO_MIN) / 4, 9063f421baaSArnaldo Carvalho de Melo TCP_RTO_MAX); 9071da177e4SLinus Torvalds } 9081da177e4SLinus Torvalds return 1; 9091da177e4SLinus Torvalds } 9101da177e4SLinus Torvalds return 0; 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds #undef STATE_TRACE 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds #ifdef STATE_TRACE 9171da177e4SLinus Torvalds static const char *statename[]={ 9181da177e4SLinus Torvalds "Unused","Established","Syn Sent","Syn Recv", 9191da177e4SLinus Torvalds "Fin Wait 1","Fin Wait 2","Time Wait", "Close", 9201da177e4SLinus Torvalds "Close Wait","Last ACK","Listen","Closing" 9211da177e4SLinus Torvalds }; 9221da177e4SLinus Torvalds #endif 923490d5046SIlpo Järvinen extern void tcp_set_state(struct sock *sk, int state); 9241da177e4SLinus Torvalds 9254ac02babSAndi Kleen extern void tcp_done(struct sock *sk); 9261da177e4SLinus Torvalds 92740efc6faSStephen Hemminger static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) 9281da177e4SLinus Torvalds { 9291da177e4SLinus Torvalds rx_opt->dsack = 0; 9301da177e4SLinus Torvalds rx_opt->eff_sacks = 0; 9311da177e4SLinus Torvalds rx_opt->num_sacks = 0; 9321da177e4SLinus Torvalds } 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds /* Determine a window scaling and initial window to offer. */ 9351da177e4SLinus Torvalds extern void tcp_select_initial_window(int __space, __u32 mss, 9361da177e4SLinus Torvalds __u32 *rcv_wnd, __u32 *window_clamp, 9371da177e4SLinus Torvalds int wscale_ok, __u8 *rcv_wscale); 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds static inline int tcp_win_from_space(int space) 9401da177e4SLinus Torvalds { 9411da177e4SLinus Torvalds return sysctl_tcp_adv_win_scale<=0 ? 9421da177e4SLinus Torvalds (space>>(-sysctl_tcp_adv_win_scale)) : 9431da177e4SLinus Torvalds space - (space>>sysctl_tcp_adv_win_scale); 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds /* Note: caller must be prepared to deal with negative returns */ 9471da177e4SLinus Torvalds static inline int tcp_space(const struct sock *sk) 9481da177e4SLinus Torvalds { 9491da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf - 9501da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc)); 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds static inline int tcp_full_space(const struct sock *sk) 9541da177e4SLinus Torvalds { 9551da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf); 9561da177e4SLinus Torvalds } 9571da177e4SLinus Torvalds 95840efc6faSStephen Hemminger static inline void tcp_openreq_init(struct request_sock *req, 9591da177e4SLinus Torvalds struct tcp_options_received *rx_opt, 9601da177e4SLinus Torvalds struct sk_buff *skb) 9611da177e4SLinus Torvalds { 9622e6599cbSArnaldo Carvalho de Melo struct inet_request_sock *ireq = inet_rsk(req); 9632e6599cbSArnaldo Carvalho de Melo 9641da177e4SLinus Torvalds req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */ 9654dfc2817SFlorian Westphal req->cookie_ts = 0; 9662e6599cbSArnaldo Carvalho de Melo tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; 9671da177e4SLinus Torvalds req->mss = rx_opt->mss_clamp; 9681da177e4SLinus Torvalds req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0; 9692e6599cbSArnaldo Carvalho de Melo ireq->tstamp_ok = rx_opt->tstamp_ok; 9702e6599cbSArnaldo Carvalho de Melo ireq->sack_ok = rx_opt->sack_ok; 9712e6599cbSArnaldo Carvalho de Melo ireq->snd_wscale = rx_opt->snd_wscale; 9722e6599cbSArnaldo Carvalho de Melo ireq->wscale_ok = rx_opt->wscale_ok; 9732e6599cbSArnaldo Carvalho de Melo ireq->acked = 0; 9742e6599cbSArnaldo Carvalho de Melo ireq->ecn_ok = 0; 975aa8223c7SArnaldo Carvalho de Melo ireq->rmt_port = tcp_hdr(skb)->source; 9761da177e4SLinus Torvalds } 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds extern void tcp_enter_memory_pressure(void); 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds static inline int keepalive_intvl_when(const struct tcp_sock *tp) 9811da177e4SLinus Torvalds { 9821da177e4SLinus Torvalds return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl; 9831da177e4SLinus Torvalds } 9841da177e4SLinus Torvalds 9851da177e4SLinus Torvalds static inline int keepalive_time_when(const struct tcp_sock *tp) 9861da177e4SLinus Torvalds { 9871da177e4SLinus Torvalds return tp->keepalive_time ? : sysctl_tcp_keepalive_time; 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds 990463c84b9SArnaldo Carvalho de Melo static inline int tcp_fin_time(const struct sock *sk) 9911da177e4SLinus Torvalds { 992463c84b9SArnaldo Carvalho de Melo int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout; 993463c84b9SArnaldo Carvalho de Melo const int rto = inet_csk(sk)->icsk_rto; 9941da177e4SLinus Torvalds 995463c84b9SArnaldo Carvalho de Melo if (fin_timeout < (rto << 2) - (rto >> 1)) 996463c84b9SArnaldo Carvalho de Melo fin_timeout = (rto << 2) - (rto >> 1); 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds return fin_timeout; 9991da177e4SLinus Torvalds } 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, int rst) 10021da177e4SLinus Torvalds { 10031da177e4SLinus Torvalds if ((s32)(rx_opt->rcv_tsval - rx_opt->ts_recent) >= 0) 10041da177e4SLinus Torvalds return 0; 10059d729f72SJames Morris if (get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS) 10061da177e4SLinus Torvalds return 0; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds /* RST segments are not recommended to carry timestamp, 10091da177e4SLinus Torvalds and, if they do, it is recommended to ignore PAWS because 10101da177e4SLinus Torvalds "their cleanup function should take precedence over timestamps." 10111da177e4SLinus Torvalds Certainly, it is mistake. It is necessary to understand the reasons 10121da177e4SLinus Torvalds of this constraint to relax it: if peer reboots, clock may go 10131da177e4SLinus Torvalds out-of-sync and half-open connections will not be reset. 10141da177e4SLinus Torvalds Actually, the problem would be not existing if all 10151da177e4SLinus Torvalds the implementations followed draft about maintaining clock 10161da177e4SLinus Torvalds via reboots. Linux-2.2 DOES NOT! 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds However, we can relax time bounds for RST segments to MSL. 10191da177e4SLinus Torvalds */ 10209d729f72SJames Morris if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) 10211da177e4SLinus Torvalds return 0; 10221da177e4SLinus Torvalds return 1; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds #define TCP_CHECK_TIMER(sk) do { } while (0) 10261da177e4SLinus Torvalds 1027a9c19329SPavel Emelyanov static inline void tcp_mib_init(struct net *net) 10281da177e4SLinus Torvalds { 10291da177e4SLinus Torvalds /* See RFC 2012 */ 10301da177e4SLinus Torvalds TCP_ADD_STATS_USER(TCP_MIB_RTOALGORITHM, 1); 10311da177e4SLinus Torvalds TCP_ADD_STATS_USER(TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ); 10321da177e4SLinus Torvalds TCP_ADD_STATS_USER(TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ); 10331da177e4SLinus Torvalds TCP_ADD_STATS_USER(TCP_MIB_MAXCONN, -1); 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 10366a438bbeSStephen Hemminger /* from STCP */ 10370800f170SDavid S. Miller static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp) 10380800f170SDavid S. Miller { 10396a438bbeSStephen Hemminger tp->lost_skb_hint = NULL; 10406a438bbeSStephen Hemminger tp->scoreboard_skb_hint = NULL; 10416a438bbeSStephen Hemminger tp->retransmit_skb_hint = NULL; 10426a438bbeSStephen Hemminger tp->forward_skb_hint = NULL; 1043b7689205SIlpo Järvinen } 1044b7689205SIlpo Järvinen 10450800f170SDavid S. Miller static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp) 10460800f170SDavid S. Miller { 1047b7689205SIlpo Järvinen tcp_clear_retrans_hints_partial(tp); 10486a438bbeSStephen Hemminger } 10496a438bbeSStephen Hemminger 1050cfb6eeb4SYOSHIFUJI Hideaki /* MD5 Signature */ 1051cfb6eeb4SYOSHIFUJI Hideaki struct crypto_hash; 1052cfb6eeb4SYOSHIFUJI Hideaki 1053cfb6eeb4SYOSHIFUJI Hideaki /* - key database */ 1054cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key { 1055cfb6eeb4SYOSHIFUJI Hideaki u8 *key; 1056cfb6eeb4SYOSHIFUJI Hideaki u8 keylen; 1057cfb6eeb4SYOSHIFUJI Hideaki }; 1058cfb6eeb4SYOSHIFUJI Hideaki 1059cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key { 1060f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1061cfb6eeb4SYOSHIFUJI Hideaki __be32 addr; 1062cfb6eeb4SYOSHIFUJI Hideaki }; 1063cfb6eeb4SYOSHIFUJI Hideaki 1064cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key { 1065f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1066cfb6eeb4SYOSHIFUJI Hideaki #if 0 1067cfb6eeb4SYOSHIFUJI Hideaki u32 scope_id; /* XXX */ 1068cfb6eeb4SYOSHIFUJI Hideaki #endif 1069cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr addr; 1070cfb6eeb4SYOSHIFUJI Hideaki }; 1071cfb6eeb4SYOSHIFUJI Hideaki 1072cfb6eeb4SYOSHIFUJI Hideaki /* - sock block */ 1073cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_info { 1074cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key *keys4; 1075cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1076cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key *keys6; 1077cfb6eeb4SYOSHIFUJI Hideaki u32 entries6; 1078cfb6eeb4SYOSHIFUJI Hideaki u32 alloced6; 1079cfb6eeb4SYOSHIFUJI Hideaki #endif 1080cfb6eeb4SYOSHIFUJI Hideaki u32 entries4; 1081cfb6eeb4SYOSHIFUJI Hideaki u32 alloced4; 1082cfb6eeb4SYOSHIFUJI Hideaki }; 1083cfb6eeb4SYOSHIFUJI Hideaki 1084cfb6eeb4SYOSHIFUJI Hideaki /* - pseudo header */ 1085cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr { 1086cfb6eeb4SYOSHIFUJI Hideaki __be32 saddr; 1087cfb6eeb4SYOSHIFUJI Hideaki __be32 daddr; 1088cfb6eeb4SYOSHIFUJI Hideaki __u8 pad; 1089cfb6eeb4SYOSHIFUJI Hideaki __u8 protocol; 1090cfb6eeb4SYOSHIFUJI Hideaki __be16 len; 1091cfb6eeb4SYOSHIFUJI Hideaki }; 1092cfb6eeb4SYOSHIFUJI Hideaki 1093cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr { 1094cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr saddr; 1095cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr daddr; 1096cfb6eeb4SYOSHIFUJI Hideaki __be32 len; 1097cfb6eeb4SYOSHIFUJI Hideaki __be32 protocol; /* including padding */ 1098cfb6eeb4SYOSHIFUJI Hideaki }; 1099cfb6eeb4SYOSHIFUJI Hideaki 1100cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block { 1101cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr ip4; 1102cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1103cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr ip6; 1104cfb6eeb4SYOSHIFUJI Hideaki #endif 1105cfb6eeb4SYOSHIFUJI Hideaki }; 1106cfb6eeb4SYOSHIFUJI Hideaki 1107cfb6eeb4SYOSHIFUJI Hideaki /* - pool: digest algorithm, hash description and scratch buffer */ 1108cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool { 1109cfb6eeb4SYOSHIFUJI Hideaki struct hash_desc md5_desc; 1110cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block md5_blk; 1111cfb6eeb4SYOSHIFUJI Hideaki }; 1112cfb6eeb4SYOSHIFUJI Hideaki 1113cfb6eeb4SYOSHIFUJI Hideaki #define TCP_MD5SIG_MAXKEYS (~(u32)0) /* really?! */ 1114cfb6eeb4SYOSHIFUJI Hideaki 1115cfb6eeb4SYOSHIFUJI Hideaki /* - functions */ 11168d26d76dSYOSHIFUJI Hideaki extern int tcp_calc_md5_hash(char *md5_hash, 11178d26d76dSYOSHIFUJI Hideaki struct tcp_md5sig_key *key, 11188d26d76dSYOSHIFUJI Hideaki int bplen, 11198d26d76dSYOSHIFUJI Hideaki struct tcphdr *th, 11208d26d76dSYOSHIFUJI Hideaki unsigned int tcplen, 11218d26d76dSYOSHIFUJI Hideaki struct tcp_md5sig_pool *hp); 11228d26d76dSYOSHIFUJI Hideaki 1123cfb6eeb4SYOSHIFUJI Hideaki extern int tcp_v4_calc_md5_hash(char *md5_hash, 1124cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *key, 1125cfb6eeb4SYOSHIFUJI Hideaki struct sock *sk, 1126cfb6eeb4SYOSHIFUJI Hideaki struct dst_entry *dst, 1127cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req, 1128cfb6eeb4SYOSHIFUJI Hideaki struct tcphdr *th, 11299cb5734eSYOSHIFUJI Hideaki unsigned int tcplen); 1130cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk, 1131cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1132cfb6eeb4SYOSHIFUJI Hideaki 1133cfb6eeb4SYOSHIFUJI Hideaki extern int tcp_v4_md5_do_add(struct sock *sk, 1134cfb6eeb4SYOSHIFUJI Hideaki __be32 addr, 1135cfb6eeb4SYOSHIFUJI Hideaki u8 *newkey, 1136cfb6eeb4SYOSHIFUJI Hideaki u8 newkeylen); 1137cfb6eeb4SYOSHIFUJI Hideaki 1138cfb6eeb4SYOSHIFUJI Hideaki extern int tcp_v4_md5_do_del(struct sock *sk, 11398e5200f5SAl Viro __be32 addr); 1140cfb6eeb4SYOSHIFUJI Hideaki 11419501f972SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 11429501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_keylen ? \ 11439501f972SYOSHIFUJI Hideaki &(struct tcp_md5sig_key) { \ 11449501f972SYOSHIFUJI Hideaki .key = (twsk)->tw_md5_key, \ 11459501f972SYOSHIFUJI Hideaki .keylen = (twsk)->tw_md5_keylen, \ 11469501f972SYOSHIFUJI Hideaki } : NULL) 11479501f972SYOSHIFUJI Hideaki #else 11489501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) NULL 11499501f972SYOSHIFUJI Hideaki #endif 11509501f972SYOSHIFUJI Hideaki 1151cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_pool **tcp_alloc_md5sig_pool(void); 1152cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_free_md5sig_pool(void); 1153cfb6eeb4SYOSHIFUJI Hideaki 1154cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_pool *__tcp_get_md5sig_pool(int cpu); 1155cfb6eeb4SYOSHIFUJI Hideaki extern void __tcp_put_md5sig_pool(void); 1156cfb6eeb4SYOSHIFUJI Hideaki 1157cfb6eeb4SYOSHIFUJI Hideaki static inline 1158cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool *tcp_get_md5sig_pool(void) 1159cfb6eeb4SYOSHIFUJI Hideaki { 1160cfb6eeb4SYOSHIFUJI Hideaki int cpu = get_cpu(); 1161cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool *ret = __tcp_get_md5sig_pool(cpu); 1162cfb6eeb4SYOSHIFUJI Hideaki if (!ret) 1163cfb6eeb4SYOSHIFUJI Hideaki put_cpu(); 1164cfb6eeb4SYOSHIFUJI Hideaki return ret; 1165cfb6eeb4SYOSHIFUJI Hideaki } 1166cfb6eeb4SYOSHIFUJI Hideaki 1167cfb6eeb4SYOSHIFUJI Hideaki static inline void tcp_put_md5sig_pool(void) 1168cfb6eeb4SYOSHIFUJI Hideaki { 1169cfb6eeb4SYOSHIFUJI Hideaki __tcp_put_md5sig_pool(); 1170cfb6eeb4SYOSHIFUJI Hideaki put_cpu(); 1171cfb6eeb4SYOSHIFUJI Hideaki } 1172cfb6eeb4SYOSHIFUJI Hideaki 1173fe067e8aSDavid S. Miller /* write queue abstraction */ 1174fe067e8aSDavid S. Miller static inline void tcp_write_queue_purge(struct sock *sk) 1175fe067e8aSDavid S. Miller { 1176fe067e8aSDavid S. Miller struct sk_buff *skb; 1177fe067e8aSDavid S. Miller 1178fe067e8aSDavid S. Miller while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) 11793ab224beSHideo Aoki sk_wmem_free_skb(sk, skb); 11803ab224beSHideo Aoki sk_mem_reclaim(sk); 1181fe067e8aSDavid S. Miller } 1182fe067e8aSDavid S. Miller 1183fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_head(struct sock *sk) 1184fe067e8aSDavid S. Miller { 1185fe067e8aSDavid S. Miller struct sk_buff *skb = sk->sk_write_queue.next; 1186fe067e8aSDavid S. Miller if (skb == (struct sk_buff *) &sk->sk_write_queue) 1187fe067e8aSDavid S. Miller return NULL; 1188fe067e8aSDavid S. Miller return skb; 1189fe067e8aSDavid S. Miller } 1190fe067e8aSDavid S. Miller 1191fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_tail(struct sock *sk) 1192fe067e8aSDavid S. Miller { 1193fe067e8aSDavid S. Miller struct sk_buff *skb = sk->sk_write_queue.prev; 1194fe067e8aSDavid S. Miller if (skb == (struct sk_buff *) &sk->sk_write_queue) 1195fe067e8aSDavid S. Miller return NULL; 1196fe067e8aSDavid S. Miller return skb; 1197fe067e8aSDavid S. Miller } 1198fe067e8aSDavid S. Miller 1199fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_next(struct sock *sk, struct sk_buff *skb) 1200fe067e8aSDavid S. Miller { 1201fe067e8aSDavid S. Miller return skb->next; 1202fe067e8aSDavid S. Miller } 1203fe067e8aSDavid S. Miller 1204fe067e8aSDavid S. Miller #define tcp_for_write_queue(skb, sk) \ 1205fe067e8aSDavid S. Miller for (skb = (sk)->sk_write_queue.next; \ 1206fe067e8aSDavid S. Miller (skb != (struct sk_buff *)&(sk)->sk_write_queue); \ 1207fe067e8aSDavid S. Miller skb = skb->next) 1208fe067e8aSDavid S. Miller 1209fe067e8aSDavid S. Miller #define tcp_for_write_queue_from(skb, sk) \ 1210fe067e8aSDavid S. Miller for (; (skb != (struct sk_buff *)&(sk)->sk_write_queue);\ 1211fe067e8aSDavid S. Miller skb = skb->next) 1212fe067e8aSDavid S. Miller 1213234b6860SIlpo Järvinen #define tcp_for_write_queue_from_safe(skb, tmp, sk) \ 1214234b6860SIlpo Järvinen for (tmp = skb->next; \ 1215234b6860SIlpo Järvinen (skb != (struct sk_buff *)&(sk)->sk_write_queue); \ 1216234b6860SIlpo Järvinen skb = tmp, tmp = skb->next) 1217234b6860SIlpo Järvinen 1218fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_send_head(struct sock *sk) 1219fe067e8aSDavid S. Miller { 1220fe067e8aSDavid S. Miller return sk->sk_send_head; 1221fe067e8aSDavid S. Miller } 1222fe067e8aSDavid S. Miller 1223fe067e8aSDavid S. Miller static inline void tcp_advance_send_head(struct sock *sk, struct sk_buff *skb) 1224fe067e8aSDavid S. Miller { 1225fe067e8aSDavid S. Miller sk->sk_send_head = skb->next; 1226fe067e8aSDavid S. Miller if (sk->sk_send_head == (struct sk_buff *)&sk->sk_write_queue) 1227fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1228fe067e8aSDavid S. Miller } 1229fe067e8aSDavid S. Miller 1230fe067e8aSDavid S. Miller static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked) 1231fe067e8aSDavid S. Miller { 1232fe067e8aSDavid S. Miller if (sk->sk_send_head == skb_unlinked) 1233fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1234fe067e8aSDavid S. Miller } 1235fe067e8aSDavid S. Miller 1236fe067e8aSDavid S. Miller static inline void tcp_init_send_head(struct sock *sk) 1237fe067e8aSDavid S. Miller { 1238fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1239fe067e8aSDavid S. Miller } 1240fe067e8aSDavid S. Miller 1241fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1242fe067e8aSDavid S. Miller { 1243fe067e8aSDavid S. Miller __skb_queue_tail(&sk->sk_write_queue, skb); 1244fe067e8aSDavid S. Miller } 1245fe067e8aSDavid S. Miller 1246fe067e8aSDavid S. Miller static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1247fe067e8aSDavid S. Miller { 1248fe067e8aSDavid S. Miller __tcp_add_write_queue_tail(sk, skb); 1249fe067e8aSDavid S. Miller 1250fe067e8aSDavid S. Miller /* Queue it, remembering where we must start sending. */ 12516859d494SIlpo Järvinen if (sk->sk_send_head == NULL) { 1252fe067e8aSDavid S. Miller sk->sk_send_head = skb; 12536859d494SIlpo Järvinen 12546859d494SIlpo Järvinen if (tcp_sk(sk)->highest_sack == NULL) 12556859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = skb; 12566859d494SIlpo Järvinen } 1257fe067e8aSDavid S. Miller } 1258fe067e8aSDavid S. Miller 1259fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb) 1260fe067e8aSDavid S. Miller { 1261fe067e8aSDavid S. Miller __skb_queue_head(&sk->sk_write_queue, skb); 1262fe067e8aSDavid S. Miller } 1263fe067e8aSDavid S. Miller 1264fe067e8aSDavid S. Miller /* Insert buff after skb on the write queue of sk. */ 1265fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_after(struct sk_buff *skb, 1266fe067e8aSDavid S. Miller struct sk_buff *buff, 1267fe067e8aSDavid S. Miller struct sock *sk) 1268fe067e8aSDavid S. Miller { 12697de6c033SGerrit Renker __skb_queue_after(&sk->sk_write_queue, skb, buff); 1270fe067e8aSDavid S. Miller } 1271fe067e8aSDavid S. Miller 1272fe067e8aSDavid S. Miller /* Insert skb between prev and next on the write queue of sk. */ 1273fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_before(struct sk_buff *new, 1274fe067e8aSDavid S. Miller struct sk_buff *skb, 1275fe067e8aSDavid S. Miller struct sock *sk) 1276fe067e8aSDavid S. Miller { 1277fe067e8aSDavid S. Miller __skb_insert(new, skb->prev, skb, &sk->sk_write_queue); 12786e421410SIlpo Järvinen 12796e421410SIlpo Järvinen if (sk->sk_send_head == skb) 12806e421410SIlpo Järvinen sk->sk_send_head = new; 1281fe067e8aSDavid S. Miller } 1282fe067e8aSDavid S. Miller 1283fe067e8aSDavid S. Miller static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk) 1284fe067e8aSDavid S. Miller { 1285fe067e8aSDavid S. Miller __skb_unlink(skb, &sk->sk_write_queue); 1286fe067e8aSDavid S. Miller } 1287fe067e8aSDavid S. Miller 1288fe067e8aSDavid S. Miller static inline int tcp_skb_is_last(const struct sock *sk, 1289fe067e8aSDavid S. Miller const struct sk_buff *skb) 1290fe067e8aSDavid S. Miller { 1291fe067e8aSDavid S. Miller return skb->next == (struct sk_buff *)&sk->sk_write_queue; 1292fe067e8aSDavid S. Miller } 1293fe067e8aSDavid S. Miller 1294fe067e8aSDavid S. Miller static inline int tcp_write_queue_empty(struct sock *sk) 1295fe067e8aSDavid S. Miller { 1296fe067e8aSDavid S. Miller return skb_queue_empty(&sk->sk_write_queue); 1297fe067e8aSDavid S. Miller } 1298fe067e8aSDavid S. Miller 1299a47e5a98SIlpo Järvinen /* Start sequence of the highest skb with SACKed bit, valid only if 1300a47e5a98SIlpo Järvinen * sacked > 0 or when the caller has ensured validity by itself. 1301a47e5a98SIlpo Järvinen */ 1302a47e5a98SIlpo Järvinen static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp) 1303a47e5a98SIlpo Järvinen { 1304a47e5a98SIlpo Järvinen if (!tp->sacked_out) 1305a47e5a98SIlpo Järvinen return tp->snd_una; 13066859d494SIlpo Järvinen 13076859d494SIlpo Järvinen if (tp->highest_sack == NULL) 13086859d494SIlpo Järvinen return tp->snd_nxt; 13096859d494SIlpo Järvinen 1310a47e5a98SIlpo Järvinen return TCP_SKB_CB(tp->highest_sack)->seq; 1311a47e5a98SIlpo Järvinen } 1312a47e5a98SIlpo Järvinen 13136859d494SIlpo Järvinen static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb) 13146859d494SIlpo Järvinen { 13156859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL : 13166859d494SIlpo Järvinen tcp_write_queue_next(sk, skb); 13176859d494SIlpo Järvinen } 13186859d494SIlpo Järvinen 13196859d494SIlpo Järvinen static inline struct sk_buff *tcp_highest_sack(struct sock *sk) 13206859d494SIlpo Järvinen { 13216859d494SIlpo Järvinen return tcp_sk(sk)->highest_sack; 13226859d494SIlpo Järvinen } 13236859d494SIlpo Järvinen 13246859d494SIlpo Järvinen static inline void tcp_highest_sack_reset(struct sock *sk) 13256859d494SIlpo Järvinen { 13266859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk); 13276859d494SIlpo Järvinen } 13286859d494SIlpo Järvinen 13296859d494SIlpo Järvinen /* Called when old skb is about to be deleted (to be combined with new skb) */ 13306859d494SIlpo Järvinen static inline void tcp_highest_sack_combine(struct sock *sk, 13316859d494SIlpo Järvinen struct sk_buff *old, 13326859d494SIlpo Järvinen struct sk_buff *new) 13336859d494SIlpo Järvinen { 13346859d494SIlpo Järvinen if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack)) 13356859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = new; 13366859d494SIlpo Järvinen } 13376859d494SIlpo Järvinen 13381da177e4SLinus Torvalds /* /proc */ 13391da177e4SLinus Torvalds enum tcp_seq_states { 13401da177e4SLinus Torvalds TCP_SEQ_STATE_LISTENING, 13411da177e4SLinus Torvalds TCP_SEQ_STATE_OPENREQ, 13421da177e4SLinus Torvalds TCP_SEQ_STATE_ESTABLISHED, 13431da177e4SLinus Torvalds TCP_SEQ_STATE_TIME_WAIT, 13441da177e4SLinus Torvalds }; 13451da177e4SLinus Torvalds 13461da177e4SLinus Torvalds struct tcp_seq_afinfo { 13471da177e4SLinus Torvalds char *name; 13481da177e4SLinus Torvalds sa_family_t family; 134968fcadd1SDenis V. Lunev struct file_operations seq_fops; 13509427c4b3SDenis V. Lunev struct seq_operations seq_ops; 13511da177e4SLinus Torvalds }; 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds struct tcp_iter_state { 1354a4146b1bSDenis V. Lunev struct seq_net_private p; 13551da177e4SLinus Torvalds sa_family_t family; 13561da177e4SLinus Torvalds enum tcp_seq_states state; 13571da177e4SLinus Torvalds struct sock *syn_wait_sk; 13581da177e4SLinus Torvalds int bucket, sbucket, num, uid; 13591da177e4SLinus Torvalds }; 13601da177e4SLinus Torvalds 13616f8b13bcSDaniel Lezcano extern int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo); 13626f8b13bcSDaniel Lezcano extern void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo); 13631da177e4SLinus Torvalds 136420380731SArnaldo Carvalho de Melo extern struct request_sock_ops tcp_request_sock_ops; 1365c6aefafbSGlenn Griffin extern struct request_sock_ops tcp6_request_sock_ops; 136620380731SArnaldo Carvalho de Melo 13677d06b2e0SBrian Haley extern void tcp_v4_destroy_sock(struct sock *sk); 136820380731SArnaldo Carvalho de Melo 1369a430a43dSHerbert Xu extern int tcp_v4_gso_send_check(struct sk_buff *skb); 1370576a30ebSHerbert Xu extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features); 1371f4c50d99SHerbert Xu 137220380731SArnaldo Carvalho de Melo #ifdef CONFIG_PROC_FS 137320380731SArnaldo Carvalho de Melo extern int tcp4_proc_init(void); 137420380731SArnaldo Carvalho de Melo extern void tcp4_proc_exit(void); 137520380731SArnaldo Carvalho de Melo #endif 137620380731SArnaldo Carvalho de Melo 1377cfb6eeb4SYOSHIFUJI Hideaki /* TCP af-specific functions */ 1378cfb6eeb4SYOSHIFUJI Hideaki struct tcp_sock_af_ops { 1379cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1380cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1381cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1382cfb6eeb4SYOSHIFUJI Hideaki int (*calc_md5_hash) (char *location, 1383cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *md5, 1384cfb6eeb4SYOSHIFUJI Hideaki struct sock *sk, 1385cfb6eeb4SYOSHIFUJI Hideaki struct dst_entry *dst, 1386cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req, 1387cfb6eeb4SYOSHIFUJI Hideaki struct tcphdr *th, 13889cb5734eSYOSHIFUJI Hideaki unsigned int len); 1389cfb6eeb4SYOSHIFUJI Hideaki int (*md5_add) (struct sock *sk, 1390cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk, 1391cfb6eeb4SYOSHIFUJI Hideaki u8 *newkey, 1392cfb6eeb4SYOSHIFUJI Hideaki u8 len); 1393cfb6eeb4SYOSHIFUJI Hideaki int (*md5_parse) (struct sock *sk, 1394cfb6eeb4SYOSHIFUJI Hideaki char __user *optval, 1395cfb6eeb4SYOSHIFUJI Hideaki int optlen); 1396cfb6eeb4SYOSHIFUJI Hideaki #endif 1397cfb6eeb4SYOSHIFUJI Hideaki }; 1398cfb6eeb4SYOSHIFUJI Hideaki 1399cfb6eeb4SYOSHIFUJI Hideaki struct tcp_request_sock_ops { 1400cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1401cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1402cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req); 1403cfb6eeb4SYOSHIFUJI Hideaki #endif 1404cfb6eeb4SYOSHIFUJI Hideaki }; 1405cfb6eeb4SYOSHIFUJI Hideaki 14069b0f976fSDenis V. Lunev extern void tcp_v4_init(void); 140720380731SArnaldo Carvalho de Melo extern void tcp_init(void); 140820380731SArnaldo Carvalho de Melo 14091da177e4SLinus Torvalds #endif /* _TCP_H */ 1410