home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / tcp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  10.5 KB  |  375 lines
  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.  
  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/skbuff.h>
  163. #include <net/sock.h>
  164. #include <net/inet_connection_sock.h>
  165. #include <net/inet_timewait_sock.h>
  166.  
  167. /* This defines a selective acknowledgement block. */
  168. struct tcp_sack_block {
  169.     __u32    start_seq;
  170.     __u32    end_seq;
  171. };
  172.  
  173. struct tcp_options_received {
  174. /*    PAWS/RTTM data    */
  175.     long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
  176.     __u32    ts_recent;    /* Time stamp to echo next        */
  177.     __u32    rcv_tsval;    /* Time stamp value                 */
  178.     __u32    rcv_tsecr;    /* Time stamp echo reply            */
  179.     __u16     saw_tstamp : 1,    /* Saw TIMESTAMP on last packet        */
  180.         tstamp_ok : 1,    /* TIMESTAMP seen on SYN packet        */
  181.         dsack : 1,    /* D-SACK is scheduled            */
  182.         wscale_ok : 1,    /* Wscale seen on SYN packet        */
  183.         sack_ok : 4,    /* SACK seen on SYN packet        */
  184.         snd_wscale : 4,    /* Window scaling received from sender    */
  185.         rcv_wscale : 4;    /* Window scaling to send to receiver    */
  186. /*    SACKs data    */
  187.     __u8    eff_sacks;    /* Size of SACK array to send with next packet */
  188.     __u8    num_sacks;    /* Number of SACK blocks        */
  189.     __u16    user_mss;      /* mss requested by user in ioctl */
  190.     __u16    mss_clamp;    /* Maximal mss, negotiated at connection setup */
  191. };
  192.  
  193. struct tcp_request_sock {
  194.     struct inet_request_sock req;
  195.     __u32             rcv_isn;
  196.     __u32             snt_isn;
  197. };
  198.  
  199. static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
  200. {
  201.     return (struct tcp_request_sock *)req;
  202. }
  203.  
  204. struct tcp_sock {
  205.     /* inet_connection_sock has to be the first member of tcp_sock */
  206.     struct inet_connection_sock    inet_conn;
  207.     int    tcp_header_len;    /* Bytes of tcp header to send        */
  208.  
  209. /*
  210.  *    Header prediction flags
  211.  *    0x5?10 << 16 + snd_wnd in net byte order
  212.  */
  213.     __u32    pred_flags;
  214.  
  215. /*
  216.  *    RFC793 variables by their proper names. This means you can
  217.  *    read the code and the spec side by side (and laugh ...)
  218.  *    See RFC793 and RFC1122. The RFC writes these in capitals.
  219.  */
  220.      __u32    rcv_nxt;    /* What we want to receive next     */
  221.      __u32    snd_nxt;    /* Next sequence we send        */
  222.  
  223.      __u32    snd_una;    /* First byte we want an ack for    */
  224.      __u32    snd_sml;    /* Last byte of the most recently transmitted small packet */
  225.     __u32    rcv_tstamp;    /* timestamp of last received ACK (for keepalives) */
  226.     __u32    lsndtime;    /* timestamp of last sent data packet (for restart window) */
  227.  
  228.     /* Data for direct copy to user */
  229.     struct {
  230.         struct sk_buff_head    prequeue;
  231.         struct task_struct    *task;
  232.         struct iovec        *iov;
  233.         int            memory;
  234.         int            len;
  235.     } ucopy;
  236.  
  237.     __u32    snd_wl1;    /* Sequence for window update        */
  238.     __u32    snd_wnd;    /* The window we expect to receive    */
  239.     __u32    max_window;    /* Maximal window ever seen from peer    */
  240.     __u32    mss_cache;    /* Cached effective mss, not including SACKS */
  241.     __u16    xmit_size_goal;    /* Goal for segmenting output packets    */
  242.     /* XXX Two bytes hole, try to pack */
  243.  
  244.     __u32    window_clamp;    /* Maximal window to advertise        */
  245.     __u32    rcv_ssthresh;    /* Current window clamp            */
  246.  
  247.     __u32    frto_highmark;    /* snd_nxt when RTO occurred */
  248.     __u8    reordering;    /* Packet reordering metric.        */
  249.     __u8    frto_counter;    /* Number of new acks after RTO */
  250.     __u8    nonagle;    /* Disable Nagle algorithm?             */
  251.     __u8    keepalive_probes; /* num of allowed keep alive probes    */
  252.  
  253. /* RTT measurement */
  254.     __u32    srtt;        /* smoothed round trip time << 3    */
  255.     __u32    mdev;        /* medium deviation            */
  256.     __u32    mdev_max;    /* maximal mdev for the last rtt period    */
  257.     __u32    rttvar;        /* smoothed mdev_max            */
  258.     __u32    rtt_seq;    /* sequence number to update rttvar    */
  259.  
  260.     __u32    packets_out;    /* Packets which are "in flight"    */
  261.     __u32    left_out;    /* Packets which leaved network    */
  262.     __u32    retrans_out;    /* Retransmitted packets out        */
  263. /*
  264.  *      Options received (usually on last packet, some only on SYN packets).
  265.  */
  266.     struct tcp_options_received rx_opt;
  267.  
  268. /*
  269.  *    Slow start and congestion control (see also Nagle, and Karn & Partridge)
  270.  */
  271.      __u32    snd_ssthresh;    /* Slow start size threshold        */
  272.      __u32    snd_cwnd;    /* Sending congestion window        */
  273.      __u16    snd_cwnd_cnt;    /* Linear increase counter        */
  274.     __u16    snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */
  275.     __u32    snd_cwnd_used;
  276.     __u32    snd_cwnd_stamp;
  277.  
  278.     struct sk_buff_head    out_of_order_queue; /* Out of order segments go here */
  279.  
  280.      __u32    rcv_wnd;    /* Current receiver window        */
  281.     __u32    rcv_wup;    /* rcv_nxt on last window update sent    */
  282.     __u32    write_seq;    /* Tail(+1) of data held in tcp send buffer */
  283.     __u32    pushed_seq;    /* Last pushed seq, required to talk to windows */
  284.     __u32    copied_seq;    /* Head of yet unread data        */
  285.  
  286. /*    SACKs data    */
  287.     struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
  288.     struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
  289.  
  290.     struct tcp_sack_block recv_sack_cache[4];
  291.  
  292.     /* from STCP, retrans queue hinting */
  293.     struct sk_buff* lost_skb_hint;
  294.  
  295.     struct sk_buff *scoreboard_skb_hint;
  296.     struct sk_buff *retransmit_skb_hint;
  297.     struct sk_buff *forward_skb_hint;
  298.     struct sk_buff *fastpath_skb_hint;
  299.  
  300.     int     fastpath_cnt_hint;
  301.     int     lost_cnt_hint;
  302.     int     retransmit_cnt_hint;
  303.     int     forward_cnt_hint;
  304.  
  305.     __u16    advmss;        /* Advertised MSS            */
  306.     __u16    prior_ssthresh; /* ssthresh saved at recovery start    */
  307.     __u32    lost_out;    /* Lost packets            */
  308.     __u32    sacked_out;    /* SACK'd packets            */
  309.     __u32    fackets_out;    /* FACK'd packets            */
  310.     __u32    high_seq;    /* snd_nxt at onset of congestion    */
  311.  
  312.     __u32    retrans_stamp;    /* Timestamp of the last retransmit,
  313.                  * also used in SYN-SENT to remember stamp of
  314.                  * the first SYN. */
  315.     __u32    undo_marker;    /* tracking retrans started here. */
  316.     int    undo_retrans;    /* number of undoable retransmissions. */
  317.     __u32    urg_seq;    /* Seq of received urgent pointer */
  318.     __u16    urg_data;    /* Saved octet of OOB data and control flags */
  319.     __u8    urg_mode;    /* In urgent mode        */
  320.     __u8    ecn_flags;    /* ECN status bits.            */
  321.     __u32    snd_up;        /* Urgent pointer        */
  322.  
  323.     __u32    total_retrans;    /* Total retransmits for entire connection */
  324.     __u32    bytes_acked;    /* Appropriate Byte Counting - RFC3465 */
  325.  
  326.     unsigned int        keepalive_time;      /* time before keep alive takes place */
  327.     unsigned int        keepalive_intvl;  /* time interval between keep alive probes */
  328.     int            linger2;
  329.  
  330.     unsigned long last_synq_overflow; 
  331.  
  332. /* Receiver side RTT estimation */
  333.     struct {
  334.         __u32    rtt;
  335.         __u32    seq;
  336.         __u32    time;
  337.     } rcv_rtt_est;
  338.  
  339. /* Receiver queue space */
  340.     struct {
  341.         int    space;
  342.         __u32    seq;
  343.         __u32    time;
  344.     } rcvq_space;
  345.  
  346. /* TCP-specific MTU probe information. */
  347.     struct {
  348.         __u32          probe_seq_start;
  349.         __u32          probe_seq_end;
  350.     } mtu_probe;
  351. };
  352.  
  353. static inline struct tcp_sock *tcp_sk(const struct sock *sk)
  354. {
  355.     return (struct tcp_sock *)sk;
  356. }
  357.  
  358. struct tcp_timewait_sock {
  359.     struct inet_timewait_sock tw_sk;
  360.     __u32              tw_rcv_nxt;
  361.     __u32              tw_snd_nxt;
  362.     __u32              tw_rcv_wnd;
  363.     __u32              tw_ts_recent;
  364.     long              tw_ts_recent_stamp;
  365. };
  366.  
  367. static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk)
  368. {
  369.     return (struct tcp_timewait_sock *)sk;
  370. }
  371.  
  372. #endif
  373.  
  374. #endif    /* _LINUX_TCP_H */
  375.