1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Definitions for the TCP protocol. 7 * 8 * Version: @(#)tcp.h 1.0.2 04/28/93 9 * 10 * Author: Fred N. van Kempen, <[email protected]> 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 */ 17 #ifndef _LINUX_TCP_H 18 #define _LINUX_TCP_H 19 20 #include <linux/types.h> 21 #include <asm/byteorder.h> 22 23 struct tcphdr { 24 __u16 source; 25 __u16 dest; 26 __u32 seq; 27 __u32 ack_seq; 28 #if defined(__LITTLE_ENDIAN_BITFIELD) 29 __u16 res1:4, 30 doff:4, 31 fin:1, 32 syn:1, 33 rst:1, 34 psh:1, 35 ack:1, 36 urg:1, 37 ece:1, 38 cwr:1; 39 #elif defined(__BIG_ENDIAN_BITFIELD) 40 __u16 doff:4, 41 res1:4, 42 cwr:1, 43 ece:1, 44 urg:1, 45 ack:1, 46 psh:1, 47 rst:1, 48 syn:1, 49 fin:1; 50 #else 51 #error "Adjust your <asm/byteorder.h> defines" 52 #endif 53 __u16 window; 54 __u16 check; 55 __u16 urg_ptr; 56 }; 57 58 /* 59 * The union cast uses a gcc extension to avoid aliasing problems 60 * (union is compatible to any of its members) 61 * This means this part of the code is -fstrict-aliasing safe now. 62 */ 63 union tcp_word_hdr { 64 struct tcphdr hdr; 65 __u32 words[5]; 66 }; 67 68 #define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words [3]) 69 70 enum { 71 TCP_FLAG_CWR = __constant_htonl(0x00800000), 72 TCP_FLAG_ECE = __constant_htonl(0x00400000), 73 TCP_FLAG_URG = __constant_htonl(0x00200000), 74 TCP_FLAG_ACK = __constant_htonl(0x00100000), 75 TCP_FLAG_PSH = __constant_htonl(0x00080000), 76 TCP_FLAG_RST = __constant_htonl(0x00040000), 77 TCP_FLAG_SYN = __constant_htonl(0x00020000), 78 TCP_FLAG_FIN = __constant_htonl(0x00010000), 79 TCP_RESERVED_BITS = __constant_htonl(0x0F000000), 80 TCP_DATA_OFFSET = __constant_htonl(0xF0000000) 81 }; 82 83 /* TCP socket options */ 84 #define TCP_NODELAY 1 /* Turn off Nagle's algorithm. */ 85 #define TCP_MAXSEG 2 /* Limit MSS */ 86 #define TCP_CORK 3 /* Never send partially complete segments */ 87 #define TCP_KEEPIDLE 4 /* Start keeplives after this period */ 88 #define TCP_KEEPINTVL 5 /* Interval between keepalives */ 89 #define TCP_KEEPCNT 6 /* Number of keepalives before death */ 90 #define TCP_SYNCNT 7 /* Number of SYN retransmits */ 91 #define TCP_LINGER2 8 /* Life time of orphaned FIN-WAIT-2 state */ 92 #define TCP_DEFER_ACCEPT 9 /* Wake up listener only when data arrive */ 93 #define TCP_WINDOW_CLAMP 10 /* Bound advertised window */ 94 #define TCP_INFO 11 /* Information about this connection. */ 95 #define TCP_QUICKACK 12 /* Block/reenable quick acks */ 96 #define TCP_CONGESTION 13 /* Congestion control algorithm */ 97 98 #define TCPI_OPT_TIMESTAMPS 1 99 #define TCPI_OPT_SACK 2 100 #define TCPI_OPT_WSCALE 4 101 #define TCPI_OPT_ECN 8 102 103 enum tcp_ca_state 104 { 105 TCP_CA_Open = 0, 106 #define TCPF_CA_Open (1<<TCP_CA_Open) 107 TCP_CA_Disorder = 1, 108 #define TCPF_CA_Disorder (1<<TCP_CA_Disorder) 109 TCP_CA_CWR = 2, 110 #define TCPF_CA_CWR (1<<TCP_CA_CWR) 111 TCP_CA_Recovery = 3, 112 #define TCPF_CA_Recovery (1<<TCP_CA_Recovery) 113 TCP_CA_Loss = 4 114 #define TCPF_CA_Loss (1<<TCP_CA_Loss) 115 }; 116 117 struct tcp_info 118 { 119 __u8 tcpi_state; 120 __u8 tcpi_ca_state; 121 __u8 tcpi_retransmits; 122 __u8 tcpi_probes; 123 __u8 tcpi_backoff; 124 __u8 tcpi_options; 125 __u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4; 126 127 __u32 tcpi_rto; 128 __u32 tcpi_ato; 129 __u32 tcpi_snd_mss; 130 __u32 tcpi_rcv_mss; 131 132 __u32 tcpi_unacked; 133 __u32 tcpi_sacked; 134 __u32 tcpi_lost; 135 __u32 tcpi_retrans; 136 __u32 tcpi_fackets; 137 138 /* Times. */ 139 __u32 tcpi_last_data_sent; 140 __u32 tcpi_last_ack_sent; /* Not remembered, sorry. */ 141 __u32 tcpi_last_data_recv; 142 __u32 tcpi_last_ack_recv; 143 144 /* Metrics. */ 145 __u32 tcpi_pmtu; 146 __u32 tcpi_rcv_ssthresh; 147 __u32 tcpi_rtt; 148 __u32 tcpi_rttvar; 149 __u32 tcpi_snd_ssthresh; 150 __u32 tcpi_snd_cwnd; 151 __u32 tcpi_advmss; 152 __u32 tcpi_reordering; 153 154 __u32 tcpi_rcv_rtt; 155 __u32 tcpi_rcv_space; 156 157 __u32 tcpi_total_retrans; 158 }; 159 160 #ifdef __KERNEL__ 161 162 #include <linux/config.h> 163 #include <linux/skbuff.h> 164 #include <net/sock.h> 165 #include <net/inet_connection_sock.h> 166 #include <net/inet_timewait_sock.h> 167 168 /* This defines a selective acknowledgement block. */ 169 struct tcp_sack_block { 170 __u32 start_seq; 171 __u32 end_seq; 172 }; 173 174 struct tcp_options_received { 175 /* PAWS/RTTM data */ 176 long ts_recent_stamp;/* Time we stored ts_recent (for aging) */ 177 __u32 ts_recent; /* Time stamp to echo next */ 178 __u32 rcv_tsval; /* Time stamp value */ 179 __u32 rcv_tsecr; /* Time stamp echo reply */ 180 __u16 saw_tstamp : 1, /* Saw TIMESTAMP on last packet */ 181 tstamp_ok : 1, /* TIMESTAMP seen on SYN packet */ 182 dsack : 1, /* D-SACK is scheduled */ 183 wscale_ok : 1, /* Wscale seen on SYN packet */ 184 sack_ok : 4, /* SACK seen on SYN packet */ 185 snd_wscale : 4, /* Window scaling received from sender */ 186 rcv_wscale : 4; /* Window scaling to send to receiver */ 187 /* SACKs data */ 188 __u8 eff_sacks; /* Size of SACK array to send with next packet */ 189 __u8 num_sacks; /* Number of SACK blocks */ 190 __u16 user_mss; /* mss requested by user in ioctl */ 191 __u16 mss_clamp; /* Maximal mss, negotiated at connection setup */ 192 }; 193 194 struct tcp_request_sock { 195 struct inet_request_sock req; 196 __u32 rcv_isn; 197 __u32 snt_isn; 198 }; 199 200 static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req) 201 { 202 return (struct tcp_request_sock *)req; 203 } 204 205 struct tcp_sock { 206 /* inet_connection_sock has to be the first member of tcp_sock */ 207 struct inet_connection_sock inet_conn; 208 int tcp_header_len; /* Bytes of tcp header to send */ 209 210 /* 211 * Header prediction flags 212 * 0x5?10 << 16 + snd_wnd in net byte order 213 */ 214 __u32 pred_flags; 215 216 /* 217 * RFC793 variables by their proper names. This means you can 218 * read the code and the spec side by side (and laugh ...) 219 * See RFC793 and RFC1122. The RFC writes these in capitals. 220 */ 221 __u32 rcv_nxt; /* What we want to receive next */ 222 __u32 snd_nxt; /* Next sequence we send */ 223 224 __u32 snd_una; /* First byte we want an ack for */ 225 __u32 snd_sml; /* Last byte of the most recently transmitted small packet */ 226 __u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */ 227 __u32 lsndtime; /* timestamp of last sent data packet (for restart window) */ 228 229 /* Data for direct copy to user */ 230 struct { 231 struct sk_buff_head prequeue; 232 struct task_struct *task; 233 struct iovec *iov; 234 int memory; 235 int len; 236 } ucopy; 237 238 __u32 snd_wl1; /* Sequence for window update */ 239 __u32 snd_wnd; /* The window we expect to receive */ 240 __u32 max_window; /* Maximal window ever seen from peer */ 241 __u32 mss_cache; /* Cached effective mss, not including SACKS */ 242 __u16 xmit_size_goal; /* Goal for segmenting output packets */ 243 /* XXX Two bytes hole, try to pack */ 244 245 __u32 window_clamp; /* Maximal window to advertise */ 246 __u32 rcv_ssthresh; /* Current window clamp */ 247 248 __u32 frto_highmark; /* snd_nxt when RTO occurred */ 249 __u8 reordering; /* Packet reordering metric. */ 250 __u8 frto_counter; /* Number of new acks after RTO */ 251 __u8 nonagle; /* Disable Nagle algorithm? */ 252 __u8 keepalive_probes; /* num of allowed keep alive probes */ 253 254 /* RTT measurement */ 255 __u32 srtt; /* smoothed round trip time << 3 */ 256 __u32 mdev; /* medium deviation */ 257 __u32 mdev_max; /* maximal mdev for the last rtt period */ 258 __u32 rttvar; /* smoothed mdev_max */ 259 __u32 rtt_seq; /* sequence number to update rttvar */ 260 261 __u32 packets_out; /* Packets which are "in flight" */ 262 __u32 left_out; /* Packets which leaved network */ 263 __u32 retrans_out; /* Retransmitted packets out */ 264 /* 265 * Options received (usually on last packet, some only on SYN packets). 266 */ 267 struct tcp_options_received rx_opt; 268 269 /* 270 * Slow start and congestion control (see also Nagle, and Karn & Partridge) 271 */ 272 __u32 snd_ssthresh; /* Slow start size threshold */ 273 __u32 snd_cwnd; /* Sending congestion window */ 274 __u16 snd_cwnd_cnt; /* Linear increase counter */ 275 __u16 snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */ 276 __u32 snd_cwnd_used; 277 __u32 snd_cwnd_stamp; 278 279 struct sk_buff_head out_of_order_queue; /* Out of order segments go here */ 280 281 __u32 rcv_wnd; /* Current receiver window */ 282 __u32 rcv_wup; /* rcv_nxt on last window update sent */ 283 __u32 write_seq; /* Tail(+1) of data held in tcp send buffer */ 284 __u32 pushed_seq; /* Last pushed seq, required to talk to windows */ 285 __u32 copied_seq; /* Head of yet unread data */ 286 287 /* SACKs data */ 288 struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */ 289 struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/ 290 291 struct tcp_sack_block recv_sack_cache[4]; 292 293 /* from STCP, retrans queue hinting */ 294 struct sk_buff* lost_skb_hint; 295 296 struct sk_buff *scoreboard_skb_hint; 297 struct sk_buff *retransmit_skb_hint; 298 struct sk_buff *forward_skb_hint; 299 struct sk_buff *fastpath_skb_hint; 300 301 int fastpath_cnt_hint; 302 int lost_cnt_hint; 303 int retransmit_cnt_hint; 304 int forward_cnt_hint; 305 306 __u16 advmss; /* Advertised MSS */ 307 __u16 prior_ssthresh; /* ssthresh saved at recovery start */ 308 __u32 lost_out; /* Lost packets */ 309 __u32 sacked_out; /* SACK'd packets */ 310 __u32 fackets_out; /* FACK'd packets */ 311 __u32 high_seq; /* snd_nxt at onset of congestion */ 312 313 __u32 retrans_stamp; /* Timestamp of the last retransmit, 314 * also used in SYN-SENT to remember stamp of 315 * the first SYN. */ 316 __u32 undo_marker; /* tracking retrans started here. */ 317 int undo_retrans; /* number of undoable retransmissions. */ 318 __u32 urg_seq; /* Seq of received urgent pointer */ 319 __u16 urg_data; /* Saved octet of OOB data and control flags */ 320 __u8 urg_mode; /* In urgent mode */ 321 __u8 ecn_flags; /* ECN status bits. */ 322 __u32 snd_up; /* Urgent pointer */ 323 324 __u32 total_retrans; /* Total retransmits for entire connection */ 325 __u32 bytes_acked; /* Appropriate Byte Counting - RFC3465 */ 326 327 unsigned int keepalive_time; /* time before keep alive takes place */ 328 unsigned int keepalive_intvl; /* time interval between keep alive probes */ 329 int linger2; 330 331 unsigned long last_synq_overflow; 332 333 /* Receiver side RTT estimation */ 334 struct { 335 __u32 rtt; 336 __u32 seq; 337 __u32 time; 338 } rcv_rtt_est; 339 340 /* Receiver queue space */ 341 struct { 342 int space; 343 __u32 seq; 344 __u32 time; 345 } rcvq_space; 346 }; 347 348 static inline struct tcp_sock *tcp_sk(const struct sock *sk) 349 { 350 return (struct tcp_sock *)sk; 351 } 352 353 struct tcp_timewait_sock { 354 struct inet_timewait_sock tw_sk; 355 __u32 tw_rcv_nxt; 356 __u32 tw_snd_nxt; 357 __u32 tw_rcv_wnd; 358 __u32 tw_ts_recent; 359 long tw_ts_recent_stamp; 360 }; 361 362 static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk) 363 { 364 return (struct tcp_timewait_sock *)sk; 365 } 366 367 #endif 368 369 #endif /* _LINUX_TCP_H */ 370