URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [dccp.h] - Blame information for rev 81

Go to most recent revision | Details | Compare with Previous | View Log


#ifndef _LINUX_DCCP_H
#define _LINUX_DCCP_H
 
#include <linux/types.h>
#include <asm/byteorder.h>
 
/**
 * struct dccp_hdr - generic part of DCCP packet header
 *
 * @dccph_sport - Relevant port on the endpoint that sent this packet
 * @dccph_dport - Relevant port on the other endpoint
 * @dccph_doff - Data Offset from the start of the DCCP header, in 32-bit words
 * @dccph_ccval - Used by the HC-Sender CCID
 * @dccph_cscov - Parts of the packet that are covered by the Checksum field
 * @dccph_checksum - Internet checksum, depends on dccph_cscov
 * @dccph_x - 0 = 24 bit sequence number, 1 = 48
 * @dccph_type - packet type, see DCCP_PKT_ prefixed macros
 * @dccph_seq - sequence number high or low order 24 bits, depends on dccph_x
 */
struct dccp_hdr {
        __be16  dccph_sport,
                dccph_dport;
        __u8    dccph_doff;
#if defined(__LITTLE_ENDIAN_BITFIELD)
        __u8    dccph_cscov:4,
                dccph_ccval:4;
#elif defined(__BIG_ENDIAN_BITFIELD)
        __u8    dccph_ccval:4,
                dccph_cscov:4;
#else
#error  "Adjust your <asm/byteorder.h> defines"
#endif
        __sum16 dccph_checksum;
#if defined(__LITTLE_ENDIAN_BITFIELD)
        __u8    dccph_x:1,
                dccph_type:4,
                dccph_reserved:3;
#elif defined(__BIG_ENDIAN_BITFIELD)
        __u8    dccph_reserved:3,
                dccph_type:4,
                dccph_x:1;
#else
#error  "Adjust your <asm/byteorder.h> defines"
#endif
        __u8    dccph_seq2;
        __be16  dccph_seq;
};
 
/**
 * struct dccp_hdr_ext - the low bits of a 48 bit seq packet
 *
 * @dccph_seq_low - low 24 bits of a 48 bit seq packet
 */
struct dccp_hdr_ext {
        __be32  dccph_seq_low;
};
 
/**
 * struct dccp_hdr_request - Connection initiation request header
 *
 * @dccph_req_service - Service to which the client app wants to connect
 */
struct dccp_hdr_request {
        __be32  dccph_req_service;
};
/**
 * struct dccp_hdr_ack_bits - acknowledgment bits common to most packets
 *
 * @dccph_resp_ack_nr_high - 48 bit ack number high order bits, contains GSR
 * @dccph_resp_ack_nr_low - 48 bit ack number low order bits, contains GSR
 */
struct dccp_hdr_ack_bits {
        __be16  dccph_reserved1;
        __be16  dccph_ack_nr_high;
        __be32  dccph_ack_nr_low;
};
/**
 * struct dccp_hdr_response - Connection initiation response header
 *
 * @dccph_resp_ack - 48 bit Acknowledgment Number Subheader (5.3)
 * @dccph_resp_service - Echoes the Service Code on a received DCCP-Request
 */
struct dccp_hdr_response {
        struct dccp_hdr_ack_bits        dccph_resp_ack;
        __be32                          dccph_resp_service;
};
 
/**
 * struct dccp_hdr_reset - Unconditionally shut down a connection
 *
 * @dccph_reset_ack - 48 bit Acknowledgment Number Subheader (5.6)
 * @dccph_reset_code - one of %dccp_reset_codes
 * @dccph_reset_data - the Data 1 ... Data 3 fields from 5.6
 */
struct dccp_hdr_reset {
        struct dccp_hdr_ack_bits        dccph_reset_ack;
        __u8                            dccph_reset_code,
                                        dccph_reset_data[3];
};
 
enum dccp_pkt_type {
        DCCP_PKT_REQUEST = 0,
        DCCP_PKT_RESPONSE,
        DCCP_PKT_DATA,
        DCCP_PKT_ACK,
        DCCP_PKT_DATAACK,
        DCCP_PKT_CLOSEREQ,
        DCCP_PKT_CLOSE,
        DCCP_PKT_RESET,
        DCCP_PKT_SYNC,
        DCCP_PKT_SYNCACK,
        DCCP_PKT_INVALID,
};
 
#define DCCP_NR_PKT_TYPES DCCP_PKT_INVALID
 
static inline unsigned int dccp_packet_hdr_len(const __u8 type)
{
        if (type == DCCP_PKT_DATA)
                return 0;
        if (type == DCCP_PKT_DATAACK    ||
            type == DCCP_PKT_ACK        ||
            type == DCCP_PKT_SYNC       ||
            type == DCCP_PKT_SYNCACK    ||
            type == DCCP_PKT_CLOSE      ||
            type == DCCP_PKT_CLOSEREQ)
                return sizeof(struct dccp_hdr_ack_bits);
        if (type == DCCP_PKT_REQUEST)
                return sizeof(struct dccp_hdr_request);
        if (type == DCCP_PKT_RESPONSE)
                return sizeof(struct dccp_hdr_response);
        return sizeof(struct dccp_hdr_reset);
}
enum dccp_reset_codes {
        DCCP_RESET_CODE_UNSPECIFIED = 0,
        DCCP_RESET_CODE_CLOSED,
        DCCP_RESET_CODE_ABORTED,
        DCCP_RESET_CODE_NO_CONNECTION,
        DCCP_RESET_CODE_PACKET_ERROR,
        DCCP_RESET_CODE_OPTION_ERROR,
        DCCP_RESET_CODE_MANDATORY_ERROR,
        DCCP_RESET_CODE_CONNECTION_REFUSED,
        DCCP_RESET_CODE_BAD_SERVICE_CODE,
        DCCP_RESET_CODE_TOO_BUSY,
        DCCP_RESET_CODE_BAD_INIT_COOKIE,
        DCCP_RESET_CODE_AGGRESSION_PENALTY,
 
        DCCP_MAX_RESET_CODES            /* Leave at the end!  */
};
 
/* DCCP options */
enum {
        DCCPO_PADDING = 0,
        DCCPO_MANDATORY = 1,
        DCCPO_MIN_RESERVED = 3,
        DCCPO_MAX_RESERVED = 31,
        DCCPO_CHANGE_L = 32,
        DCCPO_CONFIRM_L = 33,
        DCCPO_CHANGE_R = 34,
        DCCPO_CONFIRM_R = 35,
        DCCPO_NDP_COUNT = 37,
        DCCPO_ACK_VECTOR_0 = 38,
        DCCPO_ACK_VECTOR_1 = 39,
        DCCPO_TIMESTAMP = 41,
        DCCPO_TIMESTAMP_ECHO = 42,
        DCCPO_ELAPSED_TIME = 43,
        DCCPO_MAX = 45,
        DCCPO_MIN_CCID_SPECIFIC = 128,
        DCCPO_MAX_CCID_SPECIFIC = 255,
};
 
/* DCCP CCIDS */
enum {
        DCCPC_CCID2 = 2,
        DCCPC_CCID3 = 3,
};
 
/* DCCP features (RFC 4340 section 6.4) */
enum {
        DCCPF_RESERVED = 0,
        DCCPF_CCID = 1,
        DCCPF_SHORT_SEQNOS = 2,         /* XXX: not yet implemented */
        DCCPF_SEQUENCE_WINDOW = 3,
        DCCPF_ECN_INCAPABLE = 4,        /* XXX: not yet implemented */
        DCCPF_ACK_RATIO = 5,
        DCCPF_SEND_ACK_VECTOR = 6,
        DCCPF_SEND_NDP_COUNT = 7,
        DCCPF_MIN_CSUM_COVER = 8,
        DCCPF_DATA_CHECKSUM = 9,        /* XXX: not yet implemented */
        /* 10-127 reserved */
        DCCPF_MIN_CCID_SPECIFIC = 128,
        DCCPF_MAX_CCID_SPECIFIC = 255,
};
 
/* this structure is argument to DCCP_SOCKOPT_CHANGE_X */
struct dccp_so_feat {
        __u8 dccpsf_feat;
        __u8 __user *dccpsf_val;
        __u8 dccpsf_len;
};
 
/* DCCP socket options */
#define DCCP_SOCKOPT_PACKET_SIZE        1 /* XXX deprecated, without effect */
#define DCCP_SOCKOPT_SERVICE            2
#define DCCP_SOCKOPT_CHANGE_L           3
#define DCCP_SOCKOPT_CHANGE_R           4
#define DCCP_SOCKOPT_GET_CUR_MPS        5
#define DCCP_SOCKOPT_SEND_CSCOV         10
#define DCCP_SOCKOPT_RECV_CSCOV         11
#define DCCP_SOCKOPT_CCID_RX_INFO       128
#define DCCP_SOCKOPT_CCID_TX_INFO       192
 
/* maximum number of services provided on the same listening port */
#define DCCP_SERVICE_LIST_MAX_LEN      32
 
#ifdef __KERNEL__
 
#include <linux/in.h>
#include <linux/ktime.h>
#include <linux/list.h>
#include <linux/uio.h>
#include <linux/workqueue.h>
 
#include <net/inet_connection_sock.h>
#include <net/inet_sock.h>
#include <net/inet_timewait_sock.h>
#include <net/tcp_states.h>
 
enum dccp_state {
        DCCP_OPEN       = TCP_ESTABLISHED,
        DCCP_REQUESTING = TCP_SYN_SENT,
        DCCP_PARTOPEN   = TCP_FIN_WAIT1, /* FIXME:
                                            This mapping is horrible, but TCP has
                                            no matching state for DCCP_PARTOPEN,
                                            as TCP_SYN_RECV is already used by
                                            DCCP_RESPOND, why don't stop using TCP
                                            mapping of states? OK, now we don't use
                                            sk_stream_sendmsg anymore, so doesn't
                                            seem to exist any reason for us to
                                            do the TCP mapping here */
        DCCP_LISTEN     = TCP_LISTEN,
        DCCP_RESPOND    = TCP_SYN_RECV,
        DCCP_CLOSING    = TCP_CLOSING,
        DCCP_TIME_WAIT  = TCP_TIME_WAIT,
        DCCP_CLOSED     = TCP_CLOSE,
        DCCP_MAX_STATES = TCP_MAX_STATES,
};
 
#define DCCP_STATE_MASK 0xf
#define DCCP_ACTION_FIN (1<<7)
 
enum {
        DCCPF_OPEN       = TCPF_ESTABLISHED,
        DCCPF_REQUESTING = TCPF_SYN_SENT,
        DCCPF_PARTOPEN   = TCPF_FIN_WAIT1,
        DCCPF_LISTEN     = TCPF_LISTEN,
        DCCPF_RESPOND    = TCPF_SYN_RECV,
        DCCPF_CLOSING    = TCPF_CLOSING,
        DCCPF_TIME_WAIT  = TCPF_TIME_WAIT,
        DCCPF_CLOSED     = TCPF_CLOSE,
};
 
static inline struct dccp_hdr *dccp_hdr(const struct sk_buff *skb)
{
        return (struct dccp_hdr *)skb_transport_header(skb);
}
 
static inline struct dccp_hdr *dccp_zeroed_hdr(struct sk_buff *skb, int headlen)
{
        skb_push(skb, headlen);
        skb_reset_transport_header(skb);
        return memset(skb_transport_header(skb), 0, headlen);
}
 
static inline struct dccp_hdr_ext *dccp_hdrx(const struct dccp_hdr *dh)
{
        return (struct dccp_hdr_ext *)((unsigned char *)dh + sizeof(*dh));
}
 
static inline unsigned int __dccp_basic_hdr_len(const struct dccp_hdr *dh)
{
        return sizeof(*dh) + (dh->dccph_x ? sizeof(struct dccp_hdr_ext) : 0);
}
 
static inline unsigned int dccp_basic_hdr_len(const struct sk_buff *skb)
{
        const struct dccp_hdr *dh = dccp_hdr(skb);
        return __dccp_basic_hdr_len(dh);
}
 
static inline __u64 dccp_hdr_seq(const struct dccp_hdr *dh)
{
        __u64 seq_nr =  ntohs(dh->dccph_seq);
 
        if (dh->dccph_x != 0)
                seq_nr = (seq_nr << 32) + ntohl(dccp_hdrx(dh)->dccph_seq_low);
        else
                seq_nr += (u32)dh->dccph_seq2 << 16;
 
        return seq_nr;
}
 
static inline struct dccp_hdr_request *dccp_hdr_request(struct sk_buff *skb)
{
        return (struct dccp_hdr_request *)(skb_transport_header(skb) +
                                           dccp_basic_hdr_len(skb));
}
 
static inline struct dccp_hdr_ack_bits *dccp_hdr_ack_bits(const struct sk_buff *skb)
{
        return (struct dccp_hdr_ack_bits *)(skb_transport_header(skb) +
                                            dccp_basic_hdr_len(skb));
}
 
static inline u64 dccp_hdr_ack_seq(const struct sk_buff *skb)
{
        const struct dccp_hdr_ack_bits *dhack = dccp_hdr_ack_bits(skb);
        return ((u64)ntohs(dhack->dccph_ack_nr_high) << 32) + ntohl(dhack->dccph_ack_nr_low);
}
 
static inline struct dccp_hdr_response *dccp_hdr_response(struct sk_buff *skb)
{
        return (struct dccp_hdr_response *)(skb_transport_header(skb) +
                                            dccp_basic_hdr_len(skb));
}
 
static inline struct dccp_hdr_reset *dccp_hdr_reset(struct sk_buff *skb)
{
        return (struct dccp_hdr_reset *)(skb_transport_header(skb) +
                                         dccp_basic_hdr_len(skb));
}
 
static inline unsigned int __dccp_hdr_len(const struct dccp_hdr *dh)
{
        return __dccp_basic_hdr_len(dh) +
               dccp_packet_hdr_len(dh->dccph_type);
}
 
static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
{
        return __dccp_hdr_len(dccp_hdr(skb));
}
 
 
/* initial values for each feature */
#define DCCPF_INITIAL_SEQUENCE_WINDOW           100
#define DCCPF_INITIAL_ACK_RATIO                 2
#define DCCPF_INITIAL_CCID                      DCCPC_CCID2
#define DCCPF_INITIAL_SEND_ACK_VECTOR           1
/* FIXME: for now we're default to 1 but it should really be 0 */
#define DCCPF_INITIAL_SEND_NDP_COUNT            1
 
#define DCCP_NDP_LIMIT 0xFFFFFF
 
/**
  * struct dccp_minisock - Minimal DCCP connection representation
  *
  * Will be used to pass the state from dccp_request_sock to dccp_sock.
  *
  * @dccpms_sequence_window - Sequence Window Feature (section 7.5.2)
  * @dccpms_ccid - Congestion Control Id (CCID) (section 10)
  * @dccpms_send_ack_vector - Send Ack Vector Feature (section 11.5)
  * @dccpms_send_ndp_count - Send NDP Count Feature (7.7.2)
  * @dccpms_ack_ratio - Ack Ratio Feature (section 11.3)
  * @dccpms_pending - List of features being negotiated
  * @dccpms_conf -
  */
struct dccp_minisock {
        __u64                   dccpms_sequence_window;
        __u8                    dccpms_rx_ccid;
        __u8                    dccpms_tx_ccid;
        __u8                    dccpms_send_ack_vector;
        __u8                    dccpms_send_ndp_count;
        __u8                    dccpms_ack_ratio;
        struct list_head        dccpms_pending;
        struct list_head        dccpms_conf;
};
 
struct dccp_opt_conf {
        __u8                    *dccpoc_val;
        __u8                    dccpoc_len;
};
 
struct dccp_opt_pend {
        struct list_head        dccpop_node;
        __u8                    dccpop_type;
        __u8                    dccpop_feat;
        __u8                    *dccpop_val;
        __u8                    dccpop_len;
        int                     dccpop_conf;
        struct dccp_opt_conf    *dccpop_sc;
};
 
extern void dccp_minisock_init(struct dccp_minisock *dmsk);
 
extern int dccp_parse_options(struct sock *sk, struct sk_buff *skb);
 
struct dccp_request_sock {
        struct inet_request_sock dreq_inet_rsk;
        __u64                    dreq_iss;
        __u64                    dreq_isr;
        __be32                   dreq_service;
};
 
static inline struct dccp_request_sock *dccp_rsk(const struct request_sock *req)
{
        return (struct dccp_request_sock *)req;
}
 
extern struct inet_timewait_death_row dccp_death_row;
 
struct dccp_options_received {
        u32     dccpor_ndp; /* only 24 bits */
        u32     dccpor_timestamp;
        u32     dccpor_timestamp_echo;
        u32     dccpor_elapsed_time;
};
 
struct ccid;
 
enum dccp_role {
        DCCP_ROLE_UNDEFINED,
        DCCP_ROLE_LISTEN,
        DCCP_ROLE_CLIENT,
        DCCP_ROLE_SERVER,
};
 
struct dccp_service_list {
        __u32   dccpsl_nr;
        __be32  dccpsl_list[0];
};
 
#define DCCP_SERVICE_INVALID_VALUE htonl((__u32)-1)
#define DCCP_SERVICE_CODE_IS_ABSENT             0
 
static inline int dccp_list_has_service(const struct dccp_service_list *sl,
                                        const __be32 service)
{
        if (likely(sl != NULL)) {
                u32 i = sl->dccpsl_nr;
                while (i--)
                        if (sl->dccpsl_list[i] == service)
                                return 1;
        }
        return 0;
}
 
struct dccp_ackvec;
 
/**
 * struct dccp_sock - DCCP socket state
 *
 * @dccps_swl - sequence number window low
 * @dccps_swh - sequence number window high
 * @dccps_awl - acknowledgement number window low
 * @dccps_awh - acknowledgement number window high
 * @dccps_iss - initial sequence number sent
 * @dccps_isr - initial sequence number received
 * @dccps_osr - first OPEN sequence number received
 * @dccps_gss - greatest sequence number sent
 * @dccps_gsr - greatest valid sequence number received
 * @dccps_gar - greatest valid ack number received on a non-Sync; initialized to %dccps_iss
 * @dccps_service - first (passive sock) or unique (active sock) service code
 * @dccps_service_list - second .. last service code on passive socket
 * @dccps_timestamp_time - time of latest TIMESTAMP option
 * @dccps_timestamp_echo - latest timestamp received on a TIMESTAMP option
 * @dccps_l_ack_ratio - feature-local Ack Ratio
 * @dccps_r_ack_ratio - feature-remote Ack Ratio
 * @dccps_pcslen - sender   partial checksum coverage (via sockopt)
 * @dccps_pcrlen - receiver partial checksum coverage (via sockopt)
 * @dccps_ndp_count - number of Non Data Packets since last data packet
 * @dccps_mss_cache - current value of MSS (path MTU minus header sizes)
 * @dccps_rate_last - timestamp for rate-limiting DCCP-Sync (RFC 4340, 7.5.4)
 * @dccps_minisock - associated minisock (accessed via dccp_msk)
 * @dccps_hc_rx_ackvec - rx half connection ack vector
 * @dccps_hc_rx_ccid - CCID used for the receiver (or receiving half-connection)
 * @dccps_hc_tx_ccid - CCID used for the sender (or sending half-connection)
 * @dccps_options_received - parsed set of retrieved options
 * @dccps_role - role of this sock, one of %dccp_role
 * @dccps_hc_rx_insert_options - receiver wants to add options when acking
 * @dccps_hc_tx_insert_options - sender wants to add options when sending
 * @dccps_xmit_timer - timer for when CCID is not ready to send
 * @dccps_syn_rtt - RTT sample from Request/Response exchange (in usecs)
 */
struct dccp_sock {
        /* inet_connection_sock has to be the first member of dccp_sock */
        struct inet_connection_sock     dccps_inet_connection;
#define dccps_syn_rtt                   dccps_inet_connection.icsk_ack.lrcvtime
        __u64                           dccps_swl;
        __u64                           dccps_swh;
        __u64                           dccps_awl;
        __u64                           dccps_awh;
        __u64                           dccps_iss;
        __u64                           dccps_isr;
        __u64                           dccps_osr;
        __u64                           dccps_gss;
        __u64                           dccps_gsr;
        __u64                           dccps_gar;
        __be32                          dccps_service;
        struct dccp_service_list        *dccps_service_list;
        ktime_t                         dccps_timestamp_time;
        __u32                           dccps_timestamp_echo;
        __u16                           dccps_l_ack_ratio;
        __u16                           dccps_r_ack_ratio;
        __u16                           dccps_pcslen;
        __u16                           dccps_pcrlen;
        unsigned long                   dccps_ndp_count;
        __u32                           dccps_mss_cache;
        unsigned long                   dccps_rate_last;
        struct dccp_minisock            dccps_minisock;
        struct dccp_ackvec              *dccps_hc_rx_ackvec;
        struct ccid                     *dccps_hc_rx_ccid;
        struct ccid                     *dccps_hc_tx_ccid;
        struct dccp_options_received    dccps_options_received;
        enum dccp_role                  dccps_role:2;
        __u8                            dccps_hc_rx_insert_options:1;
        __u8                            dccps_hc_tx_insert_options:1;
        struct timer_list               dccps_xmit_timer;
};
 
static inline struct dccp_sock *dccp_sk(const struct sock *sk)
{
        return (struct dccp_sock *)sk;
}
 
static inline struct dccp_minisock *dccp_msk(const struct sock *sk)
{
        return (struct dccp_minisock *)&dccp_sk(sk)->dccps_minisock;
}
 
static inline const char *dccp_role(const struct sock *sk)
{
        switch (dccp_sk(sk)->dccps_role) {
        case DCCP_ROLE_UNDEFINED: return "undefined";
        case DCCP_ROLE_LISTEN:    return "listen";
        case DCCP_ROLE_SERVER:    return "server";
        case DCCP_ROLE_CLIENT:    return "client";
        }
        return NULL;
}
 
#endif /* __KERNEL__ */
 
#endif /* _LINUX_DCCP_H */

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [dccp.h] - Blame information for rev 81

Line No.	Rev	Author	Line
1	62	marcus.erl	`#ifndef _LINUX_DCCP_H`
2			`#define _LINUX_DCCP_H`
3
4			`#include <linux/types.h>`
5			`#include <asm/byteorder.h>`
6
7			`/**`
8			`* struct dccp_hdr - generic part of DCCP packet header`
9			`*`
10			`* @dccph_sport - Relevant port on the endpoint that sent this packet`
11			`* @dccph_dport - Relevant port on the other endpoint`
12			`* @dccph_doff - Data Offset from the start of the DCCP header, in 32-bit words`
13			`* @dccph_ccval - Used by the HC-Sender CCID`
14			`* @dccph_cscov - Parts of the packet that are covered by the Checksum field`
15			`* @dccph_checksum - Internet checksum, depends on dccph_cscov`
16			`* @dccph_x - 0 = 24 bit sequence number, 1 = 48`
17			`* @dccph_type - packet type, see DCCP_PKT_ prefixed macros`
18			`* @dccph_seq - sequence number high or low order 24 bits, depends on dccph_x`
19			`*/`
20			`struct dccp_hdr {`
21			`__be16 dccph_sport,`
22			`dccph_dport;`
23			`__u8 dccph_doff;`
24			`#if defined(__LITTLE_ENDIAN_BITFIELD)`
25			`__u8 dccph_cscov:4,`
26			`dccph_ccval:4;`
27			`#elif defined(__BIG_ENDIAN_BITFIELD)`
28			`__u8 dccph_ccval:4,`
29			`dccph_cscov:4;`
30			`#else`
31			`#error "Adjust your <asm/byteorder.h> defines"`
32			`#endif`
33			`__sum16 dccph_checksum;`
34			`#if defined(__LITTLE_ENDIAN_BITFIELD)`
35			`__u8 dccph_x:1,`
36			`dccph_type:4,`
37			`dccph_reserved:3;`
38			`#elif defined(__BIG_ENDIAN_BITFIELD)`
39			`__u8 dccph_reserved:3,`
40			`dccph_type:4,`
41			`dccph_x:1;`
42			`#else`
43			`#error "Adjust your <asm/byteorder.h> defines"`
44			`#endif`
45			`__u8 dccph_seq2;`
46			`__be16 dccph_seq;`
47			`};`
48
49			`/**`
50			`* struct dccp_hdr_ext - the low bits of a 48 bit seq packet`
51			`*`
52			`* @dccph_seq_low - low 24 bits of a 48 bit seq packet`
53			`*/`
54			`struct dccp_hdr_ext {`
55			`__be32 dccph_seq_low;`
56			`};`
57
58			`/**`
59			`* struct dccp_hdr_request - Connection initiation request header`
60			`*`
61			`* @dccph_req_service - Service to which the client app wants to connect`
62			`*/`
63			`struct dccp_hdr_request {`
64			`__be32 dccph_req_service;`
65			`};`
66			`/**`
67			`* struct dccp_hdr_ack_bits - acknowledgment bits common to most packets`
68			`*`
69			`* @dccph_resp_ack_nr_high - 48 bit ack number high order bits, contains GSR`
70			`* @dccph_resp_ack_nr_low - 48 bit ack number low order bits, contains GSR`
71			`*/`
72			`struct dccp_hdr_ack_bits {`
73			`__be16 dccph_reserved1;`
74			`__be16 dccph_ack_nr_high;`
75			`__be32 dccph_ack_nr_low;`
76			`};`
77			`/**`
78			`* struct dccp_hdr_response - Connection initiation response header`
79			`*`
80			`* @dccph_resp_ack - 48 bit Acknowledgment Number Subheader (5.3)`
81			`* @dccph_resp_service - Echoes the Service Code on a received DCCP-Request`
82			`*/`
83			`struct dccp_hdr_response {`
84			`struct dccp_hdr_ack_bits dccph_resp_ack;`
85			`__be32 dccph_resp_service;`
86			`};`
87
88			`/**`
89			`* struct dccp_hdr_reset - Unconditionally shut down a connection`
90			`*`
91			`* @dccph_reset_ack - 48 bit Acknowledgment Number Subheader (5.6)`
92			`* @dccph_reset_code - one of %dccp_reset_codes`
93			`* @dccph_reset_data - the Data 1 ... Data 3 fields from 5.6`
94			`*/`
95			`struct dccp_hdr_reset {`
96			`struct dccp_hdr_ack_bits dccph_reset_ack;`
97			`__u8 dccph_reset_code,`
98			`dccph_reset_data[3];`
99			`};`
100
101			`enum dccp_pkt_type {`
102			`DCCP_PKT_REQUEST = 0,`
103			`DCCP_PKT_RESPONSE,`
104			`DCCP_PKT_DATA,`
105			`DCCP_PKT_ACK,`
106			`DCCP_PKT_DATAACK,`
107			`DCCP_PKT_CLOSEREQ,`
108			`DCCP_PKT_CLOSE,`
109			`DCCP_PKT_RESET,`
110			`DCCP_PKT_SYNC,`
111			`DCCP_PKT_SYNCACK,`
112			`DCCP_PKT_INVALID,`
113			`};`
114
115			`#define DCCP_NR_PKT_TYPES DCCP_PKT_INVALID`
116
117			`static inline unsigned int dccp_packet_hdr_len(const __u8 type)`
118			`{`
119			`if (type == DCCP_PKT_DATA)`
120			`return 0;`
121			`if (type == DCCP_PKT_DATAACK \|\|`
122			`type == DCCP_PKT_ACK \|\|`
123			`type == DCCP_PKT_SYNC \|\|`
124			`type == DCCP_PKT_SYNCACK \|\|`
125			`type == DCCP_PKT_CLOSE \|\|`
126			`type == DCCP_PKT_CLOSEREQ)`
127			`return sizeof(struct dccp_hdr_ack_bits);`
128			`if (type == DCCP_PKT_REQUEST)`
129			`return sizeof(struct dccp_hdr_request);`
130			`if (type == DCCP_PKT_RESPONSE)`
131			`return sizeof(struct dccp_hdr_response);`
132			`return sizeof(struct dccp_hdr_reset);`
133			`}`
134			`enum dccp_reset_codes {`
135			`DCCP_RESET_CODE_UNSPECIFIED = 0,`
136			`DCCP_RESET_CODE_CLOSED,`
137			`DCCP_RESET_CODE_ABORTED,`
138			`DCCP_RESET_CODE_NO_CONNECTION,`
139			`DCCP_RESET_CODE_PACKET_ERROR,`
140			`DCCP_RESET_CODE_OPTION_ERROR,`
141			`DCCP_RESET_CODE_MANDATORY_ERROR,`
142			`DCCP_RESET_CODE_CONNECTION_REFUSED,`
143			`DCCP_RESET_CODE_BAD_SERVICE_CODE,`
144			`DCCP_RESET_CODE_TOO_BUSY,`
145			`DCCP_RESET_CODE_BAD_INIT_COOKIE,`
146			`DCCP_RESET_CODE_AGGRESSION_PENALTY,`
147
148			`DCCP_MAX_RESET_CODES /* Leave at the end! */`
149			`};`
150
151			`/* DCCP options */`
152			`enum {`
153			`DCCPO_PADDING = 0,`
154			`DCCPO_MANDATORY = 1,`
155			`DCCPO_MIN_RESERVED = 3,`
156			`DCCPO_MAX_RESERVED = 31,`
157			`DCCPO_CHANGE_L = 32,`
158			`DCCPO_CONFIRM_L = 33,`
159			`DCCPO_CHANGE_R = 34,`
160			`DCCPO_CONFIRM_R = 35,`
161			`DCCPO_NDP_COUNT = 37,`
162			`DCCPO_ACK_VECTOR_0 = 38,`
163			`DCCPO_ACK_VECTOR_1 = 39,`
164			`DCCPO_TIMESTAMP = 41,`
165			`DCCPO_TIMESTAMP_ECHO = 42,`
166			`DCCPO_ELAPSED_TIME = 43,`
167			`DCCPO_MAX = 45,`
168			`DCCPO_MIN_CCID_SPECIFIC = 128,`
169			`DCCPO_MAX_CCID_SPECIFIC = 255,`
170			`};`
171
172			`/* DCCP CCIDS */`
173			`enum {`
174			`DCCPC_CCID2 = 2,`
175			`DCCPC_CCID3 = 3,`
176			`};`
177
178			`/* DCCP features (RFC 4340 section 6.4) */`
179			`enum {`
180			`DCCPF_RESERVED = 0,`
181			`DCCPF_CCID = 1,`
182			`DCCPF_SHORT_SEQNOS = 2, /* XXX: not yet implemented */`
183			`DCCPF_SEQUENCE_WINDOW = 3,`
184			`DCCPF_ECN_INCAPABLE = 4, /* XXX: not yet implemented */`
185			`DCCPF_ACK_RATIO = 5,`
186			`DCCPF_SEND_ACK_VECTOR = 6,`
187			`DCCPF_SEND_NDP_COUNT = 7,`
188			`DCCPF_MIN_CSUM_COVER = 8,`
189			`DCCPF_DATA_CHECKSUM = 9, /* XXX: not yet implemented */`
190			`/* 10-127 reserved */`
191			`DCCPF_MIN_CCID_SPECIFIC = 128,`
192			`DCCPF_MAX_CCID_SPECIFIC = 255,`
193			`};`
194
195			`/* this structure is argument to DCCP_SOCKOPT_CHANGE_X */`
196			`struct dccp_so_feat {`
197			`__u8 dccpsf_feat;`
198			`__u8 __user *dccpsf_val;`
199			`__u8 dccpsf_len;`
200			`};`
201
202			`/* DCCP socket options */`
203			`#define DCCP_SOCKOPT_PACKET_SIZE 1 /* XXX deprecated, without effect */`
204			`#define DCCP_SOCKOPT_SERVICE 2`
205			`#define DCCP_SOCKOPT_CHANGE_L 3`
206			`#define DCCP_SOCKOPT_CHANGE_R 4`
207			`#define DCCP_SOCKOPT_GET_CUR_MPS 5`
208			`#define DCCP_SOCKOPT_SEND_CSCOV 10`
209			`#define DCCP_SOCKOPT_RECV_CSCOV 11`
210			`#define DCCP_SOCKOPT_CCID_RX_INFO 128`
211			`#define DCCP_SOCKOPT_CCID_TX_INFO 192`
212
213			`/* maximum number of services provided on the same listening port */`
214			`#define DCCP_SERVICE_LIST_MAX_LEN 32`
215
216			`#ifdef __KERNEL__`
217
218			`#include <linux/in.h>`
219			`#include <linux/ktime.h>`
220			`#include <linux/list.h>`
221			`#include <linux/uio.h>`
222			`#include <linux/workqueue.h>`
223
224			`#include <net/inet_connection_sock.h>`
225			`#include <net/inet_sock.h>`
226			`#include <net/inet_timewait_sock.h>`
227			`#include <net/tcp_states.h>`
228
229			`enum dccp_state {`
230			`DCCP_OPEN = TCP_ESTABLISHED,`
231			`DCCP_REQUESTING = TCP_SYN_SENT,`
232			`DCCP_PARTOPEN = TCP_FIN_WAIT1, /* FIXME:`
233			`This mapping is horrible, but TCP has`
234			`no matching state for DCCP_PARTOPEN,`
235			`as TCP_SYN_RECV is already used by`
236			`DCCP_RESPOND, why don't stop using TCP`
237			`mapping of states? OK, now we don't use`
238			`sk_stream_sendmsg anymore, so doesn't`
239			`seem to exist any reason for us to`
240			`do the TCP mapping here */`
241			`DCCP_LISTEN = TCP_LISTEN,`
242			`DCCP_RESPOND = TCP_SYN_RECV,`
243			`DCCP_CLOSING = TCP_CLOSING,`
244			`DCCP_TIME_WAIT = TCP_TIME_WAIT,`
245			`DCCP_CLOSED = TCP_CLOSE,`
246			`DCCP_MAX_STATES = TCP_MAX_STATES,`
247			`};`
248
249			`#define DCCP_STATE_MASK 0xf`
250			`#define DCCP_ACTION_FIN (1<<7)`
251
252			`enum {`
253			`DCCPF_OPEN = TCPF_ESTABLISHED,`
254			`DCCPF_REQUESTING = TCPF_SYN_SENT,`
255			`DCCPF_PARTOPEN = TCPF_FIN_WAIT1,`
256			`DCCPF_LISTEN = TCPF_LISTEN,`
257			`DCCPF_RESPOND = TCPF_SYN_RECV,`
258			`DCCPF_CLOSING = TCPF_CLOSING,`
259			`DCCPF_TIME_WAIT = TCPF_TIME_WAIT,`
260			`DCCPF_CLOSED = TCPF_CLOSE,`
261			`};`
262
263			`static inline struct dccp_hdr dccp_hdr(const struct sk_buff skb)`
264			`{`
265			`return (struct dccp_hdr *)skb_transport_header(skb);`
266			`}`
267
268			`static inline struct dccp_hdr dccp_zeroed_hdr(struct sk_buff skb, int headlen)`
269			`{`
270			`skb_push(skb, headlen);`
271			`skb_reset_transport_header(skb);`
272			`return memset(skb_transport_header(skb), 0, headlen);`
273			`}`
274
275			`static inline struct dccp_hdr_ext dccp_hdrx(const struct dccp_hdr dh)`
276			`{`
277			`return (struct dccp_hdr_ext )((unsigned char )dh + sizeof(*dh));`
278			`}`
279
280			`static inline unsigned int __dccp_basic_hdr_len(const struct dccp_hdr *dh)`
281			`{`
282			`return sizeof(*dh) + (dh->dccph_x ? sizeof(struct dccp_hdr_ext) : 0);`
283			`}`
284
285			`static inline unsigned int dccp_basic_hdr_len(const struct sk_buff *skb)`
286			`{`
287			`const struct dccp_hdr *dh = dccp_hdr(skb);`
288			`return __dccp_basic_hdr_len(dh);`
289			`}`
290
291			`static inline __u64 dccp_hdr_seq(const struct dccp_hdr *dh)`
292			`{`
293			`__u64 seq_nr = ntohs(dh->dccph_seq);`
294
295			`if (dh->dccph_x != 0)`
296			`seq_nr = (seq_nr << 32) + ntohl(dccp_hdrx(dh)->dccph_seq_low);`
297			`else`
298			`seq_nr += (u32)dh->dccph_seq2 << 16;`
299
300			`return seq_nr;`
301			`}`
302
303			`static inline struct dccp_hdr_request dccp_hdr_request(struct sk_buff skb)`
304			`{`
305			`return (struct dccp_hdr_request *)(skb_transport_header(skb) +`
306			`dccp_basic_hdr_len(skb));`
307			`}`
308
309			`static inline struct dccp_hdr_ack_bits dccp_hdr_ack_bits(const struct sk_buff skb)`
310			`{`
311			`return (struct dccp_hdr_ack_bits *)(skb_transport_header(skb) +`
312			`dccp_basic_hdr_len(skb));`
313			`}`
314
315			`static inline u64 dccp_hdr_ack_seq(const struct sk_buff *skb)`
316			`{`
317			`const struct dccp_hdr_ack_bits *dhack = dccp_hdr_ack_bits(skb);`
318			`return ((u64)ntohs(dhack->dccph_ack_nr_high) << 32) + ntohl(dhack->dccph_ack_nr_low);`
319			`}`
320
321			`static inline struct dccp_hdr_response dccp_hdr_response(struct sk_buff skb)`
322			`{`
323			`return (struct dccp_hdr_response *)(skb_transport_header(skb) +`
324			`dccp_basic_hdr_len(skb));`
325			`}`
326
327			`static inline struct dccp_hdr_reset dccp_hdr_reset(struct sk_buff skb)`
328			`{`
329			`return (struct dccp_hdr_reset *)(skb_transport_header(skb) +`
330			`dccp_basic_hdr_len(skb));`
331			`}`
332
333			`static inline unsigned int __dccp_hdr_len(const struct dccp_hdr *dh)`
334			`{`
335			`return __dccp_basic_hdr_len(dh) +`
336			`dccp_packet_hdr_len(dh->dccph_type);`
337			`}`
338
339			`static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)`
340			`{`
341			`return __dccp_hdr_len(dccp_hdr(skb));`
342			`}`
343
344
345			`/* initial values for each feature */`
346			`#define DCCPF_INITIAL_SEQUENCE_WINDOW 100`
347			`#define DCCPF_INITIAL_ACK_RATIO 2`
348			`#define DCCPF_INITIAL_CCID DCCPC_CCID2`
349			`#define DCCPF_INITIAL_SEND_ACK_VECTOR 1`
350			`/* FIXME: for now we're default to 1 but it should really be 0 */`
351			`#define DCCPF_INITIAL_SEND_NDP_COUNT 1`
352
353			`#define DCCP_NDP_LIMIT 0xFFFFFF`
354
355			`/**`
356			`* struct dccp_minisock - Minimal DCCP connection representation`
357			`*`
358			`* Will be used to pass the state from dccp_request_sock to dccp_sock.`
359			`*`
360			`* @dccpms_sequence_window - Sequence Window Feature (section 7.5.2)`
361			`* @dccpms_ccid - Congestion Control Id (CCID) (section 10)`
362			`* @dccpms_send_ack_vector - Send Ack Vector Feature (section 11.5)`
363			`* @dccpms_send_ndp_count - Send NDP Count Feature (7.7.2)`
364			`* @dccpms_ack_ratio - Ack Ratio Feature (section 11.3)`
365			`* @dccpms_pending - List of features being negotiated`
366			`* @dccpms_conf -`
367			`*/`
368			`struct dccp_minisock {`
369			`__u64 dccpms_sequence_window;`
370			`__u8 dccpms_rx_ccid;`
371			`__u8 dccpms_tx_ccid;`
372			`__u8 dccpms_send_ack_vector;`
373			`__u8 dccpms_send_ndp_count;`
374			`__u8 dccpms_ack_ratio;`
375			`struct list_head dccpms_pending;`
376			`struct list_head dccpms_conf;`
377			`};`
378
379			`struct dccp_opt_conf {`
380			`__u8 *dccpoc_val;`
381			`__u8 dccpoc_len;`
382			`};`
383
384			`struct dccp_opt_pend {`
385			`struct list_head dccpop_node;`
386			`__u8 dccpop_type;`
387			`__u8 dccpop_feat;`
388			`__u8 *dccpop_val;`
389			`__u8 dccpop_len;`
390			`int dccpop_conf;`
391			`struct dccp_opt_conf *dccpop_sc;`
392			`};`
393
394			`extern void dccp_minisock_init(struct dccp_minisock *dmsk);`
395
396			`extern int dccp_parse_options(struct sock sk, struct sk_buff skb);`
397
398			`struct dccp_request_sock {`
399			`struct inet_request_sock dreq_inet_rsk;`
400			`__u64 dreq_iss;`
401			`__u64 dreq_isr;`
402			`__be32 dreq_service;`
403			`};`
404
405			`static inline struct dccp_request_sock dccp_rsk(const struct request_sock req)`
406			`{`
407			`return (struct dccp_request_sock *)req;`
408			`}`
409
410			`extern struct inet_timewait_death_row dccp_death_row;`
411
412			`struct dccp_options_received {`
413			`u32 dccpor_ndp; /* only 24 bits */`
414			`u32 dccpor_timestamp;`
415			`u32 dccpor_timestamp_echo;`
416			`u32 dccpor_elapsed_time;`
417			`};`
418
419			`struct ccid;`
420
421			`enum dccp_role {`
422			`DCCP_ROLE_UNDEFINED,`
423			`DCCP_ROLE_LISTEN,`
424			`DCCP_ROLE_CLIENT,`
425			`DCCP_ROLE_SERVER,`
426			`};`
427
428			`struct dccp_service_list {`
429			`__u32 dccpsl_nr;`
430			`__be32 dccpsl_list[0];`
431			`};`
432
433			`#define DCCP_SERVICE_INVALID_VALUE htonl((__u32)-1)`
434			`#define DCCP_SERVICE_CODE_IS_ABSENT 0`
435
436			`static inline int dccp_list_has_service(const struct dccp_service_list *sl,`
437			`const __be32 service)`
438			`{`
439			`if (likely(sl != NULL)) {`
440			`u32 i = sl->dccpsl_nr;`
441			`while (i--)`
442			`if (sl->dccpsl_list[i] == service)`
443			`return 1;`
444			`}`
445			`return 0;`
446			`}`
447
448			`struct dccp_ackvec;`
449
450			`/**`
451			`* struct dccp_sock - DCCP socket state`
452			`*`
453			`* @dccps_swl - sequence number window low`
454			`* @dccps_swh - sequence number window high`
455			`* @dccps_awl - acknowledgement number window low`
456			`* @dccps_awh - acknowledgement number window high`
457			`* @dccps_iss - initial sequence number sent`
458			`* @dccps_isr - initial sequence number received`
459			`* @dccps_osr - first OPEN sequence number received`
460			`* @dccps_gss - greatest sequence number sent`
461			`* @dccps_gsr - greatest valid sequence number received`
462			`* @dccps_gar - greatest valid ack number received on a non-Sync; initialized to %dccps_iss`
463			`* @dccps_service - first (passive sock) or unique (active sock) service code`
464			`* @dccps_service_list - second .. last service code on passive socket`
465			`* @dccps_timestamp_time - time of latest TIMESTAMP option`
466			`* @dccps_timestamp_echo - latest timestamp received on a TIMESTAMP option`
467			`* @dccps_l_ack_ratio - feature-local Ack Ratio`
468			`* @dccps_r_ack_ratio - feature-remote Ack Ratio`
469			`* @dccps_pcslen - sender partial checksum coverage (via sockopt)`
470			`* @dccps_pcrlen - receiver partial checksum coverage (via sockopt)`
471			`* @dccps_ndp_count - number of Non Data Packets since last data packet`
472			`* @dccps_mss_cache - current value of MSS (path MTU minus header sizes)`
473			`* @dccps_rate_last - timestamp for rate-limiting DCCP-Sync (RFC 4340, 7.5.4)`
474			`* @dccps_minisock - associated minisock (accessed via dccp_msk)`
475			`* @dccps_hc_rx_ackvec - rx half connection ack vector`
476			`* @dccps_hc_rx_ccid - CCID used for the receiver (or receiving half-connection)`
477			`* @dccps_hc_tx_ccid - CCID used for the sender (or sending half-connection)`
478			`* @dccps_options_received - parsed set of retrieved options`
479			`* @dccps_role - role of this sock, one of %dccp_role`
480			`* @dccps_hc_rx_insert_options - receiver wants to add options when acking`
481			`* @dccps_hc_tx_insert_options - sender wants to add options when sending`
482			`* @dccps_xmit_timer - timer for when CCID is not ready to send`
483			`* @dccps_syn_rtt - RTT sample from Request/Response exchange (in usecs)`
484			`*/`
485			`struct dccp_sock {`
486			`/* inet_connection_sock has to be the first member of dccp_sock */`
487			`struct inet_connection_sock dccps_inet_connection;`
488			`#define dccps_syn_rtt dccps_inet_connection.icsk_ack.lrcvtime`
489			`__u64 dccps_swl;`
490			`__u64 dccps_swh;`
491			`__u64 dccps_awl;`
492			`__u64 dccps_awh;`
493			`__u64 dccps_iss;`
494			`__u64 dccps_isr;`
495			`__u64 dccps_osr;`
496			`__u64 dccps_gss;`
497			`__u64 dccps_gsr;`
498			`__u64 dccps_gar;`
499			`__be32 dccps_service;`
500			`struct dccp_service_list *dccps_service_list;`
501			`ktime_t dccps_timestamp_time;`
502			`__u32 dccps_timestamp_echo;`
503			`__u16 dccps_l_ack_ratio;`
504			`__u16 dccps_r_ack_ratio;`
505			`__u16 dccps_pcslen;`
506			`__u16 dccps_pcrlen;`
507			`unsigned long dccps_ndp_count;`
508			`__u32 dccps_mss_cache;`
509			`unsigned long dccps_rate_last;`
510			`struct dccp_minisock dccps_minisock;`
511			`struct dccp_ackvec *dccps_hc_rx_ackvec;`
512			`struct ccid *dccps_hc_rx_ccid;`
513			`struct ccid *dccps_hc_tx_ccid;`
514			`struct dccp_options_received dccps_options_received;`
515			`enum dccp_role dccps_role:2;`
516			`__u8 dccps_hc_rx_insert_options:1;`
517			`__u8 dccps_hc_tx_insert_options:1;`
518			`struct timer_list dccps_xmit_timer;`
519			`};`
520
521			`static inline struct dccp_sock dccp_sk(const struct sock sk)`
522			`{`
523			`return (struct dccp_sock *)sk;`
524			`}`
525
526			`static inline struct dccp_minisock dccp_msk(const struct sock sk)`
527			`{`
528			`return (struct dccp_minisock *)&dccp_sk(sk)->dccps_minisock;`
529			`}`
530
531			`static inline const char dccp_role(const struct sock sk)`
532			`{`
533			`switch (dccp_sk(sk)->dccps_role) {`
534			`case DCCP_ROLE_UNDEFINED: return "undefined";`
535			`case DCCP_ROLE_LISTEN: return "listen";`
536			`case DCCP_ROLE_SERVER: return "server";`
537			`case DCCP_ROLE_CLIENT: return "client";`
538			`}`
539			`return NULL;`
540			`}`
541
542			`#endif /* __KERNEL__ */`
543
544			`#endif /* _LINUX_DCCP_H */`