tcp.h
上传用户:szlgq88
上传日期:2009-04-28
资源大小:48287k
文件大小:11k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

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