dccp.h 16.5 KB
Newer Older
1 2 3 4
#ifndef _LINUX_DCCP_H
#define _LINUX_DCCP_H

#include <linux/types.h>
5
#include <asm/byteorder.h>
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/**
 * 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 {
21
	__be16	dccph_sport,
22 23 24 25 26 27 28 29 30 31 32
		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
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 43 44
#else
#error  "Adjust your <asm/byteorder.h> defines"
#endif
45 46
	__u8	dccph_seq2;
	__be16	dccph_seq;
47 48 49 50 51 52 53 54
};

/**
 * 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 {
55
	__be32	dccph_seq_low;
56 57 58
};

/**
59
 * struct dccp_hdr_request - Connection initiation request header
60 61 62 63
 *
 * @dccph_req_service - Service to which the client app wants to connect
 */
struct dccp_hdr_request {
64
	__be32	dccph_req_service;
65 66 67 68 69 70 71 72
};
/**
 * 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 {
73 74 75
	__be16	dccph_reserved1;
	__be16	dccph_ack_nr_high;
	__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 82 83 84
 * @dccph_resp_service - Echoes the Service Code on a received DCCP-Request
 */
struct dccp_hdr_response {
	struct dccp_hdr_ack_bits	dccph_resp_ack;
85
	__be32				dccph_resp_service;
86 87 88 89 90
};

/**
 * struct dccp_hdr_reset - Unconditionally shut down a connection
 *
91 92 93
 * @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
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
 */
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,
147 148

	DCCP_MAX_RESET_CODES		/* Leave at the end!  */
149 150 151 152 153 154 155 156
};

/* DCCP options */
enum {
	DCCPO_PADDING = 0,
	DCCPO_MANDATORY = 1,
	DCCPO_MIN_RESERVED = 3,
	DCCPO_MAX_RESERVED = 31,
157 158 159 160
	DCCPO_CHANGE_L = 32,
	DCCPO_CONFIRM_L = 33,
	DCCPO_CHANGE_R = 34,
	DCCPO_CONFIRM_R = 35,
161 162 163 164 165 166 167
	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,
168 169 170 171
	DCCPO_MIN_RX_CCID_SPECIFIC = 128,	/* from sender to receiver */
	DCCPO_MAX_RX_CCID_SPECIFIC = 191,
	DCCPO_MIN_TX_CCID_SPECIFIC = 192,	/* from receiver to sender */
	DCCPO_MAX_TX_CCID_SPECIFIC = 255,
172
};
173 174
/* maximum size of a single TLV-encoded DCCP option (sans type/len bytes) */
#define DCCP_SINGLE_OPT_MAXLEN	253
175

176 177 178 179 180 181
/* DCCP CCIDS */
enum {
	DCCPC_CCID2 = 2,
	DCCPC_CCID3 = 3,
};

182
/* DCCP features (RFC 4340 section 6.4) */
183
enum dccp_feature_numbers {
184 185
	DCCPF_RESERVED = 0,
	DCCPF_CCID = 1,
186
	DCCPF_SHORT_SEQNOS = 2,
187
	DCCPF_SEQUENCE_WINDOW = 3,
188
	DCCPF_ECN_INCAPABLE = 4,
189 190 191
	DCCPF_ACK_RATIO = 5,
	DCCPF_SEND_ACK_VECTOR = 6,
	DCCPF_SEND_NDP_COUNT = 7,
192
	DCCPF_MIN_CSUM_COVER = 8,
193
	DCCPF_DATA_CHECKSUM = 9,
194 195
	/* 10-127 reserved */
	DCCPF_MIN_CCID_SPECIFIC = 128,
196
	DCCPF_SEND_LEV_RATE = 192,	/* RFC 4342, sec. 8.4 */
197
	DCCPF_MAX_CCID_SPECIFIC = 255,
198 199
};

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
/* DCCP socket control message types for cmsg */
enum dccp_cmsg_type {
	DCCP_SCM_PRIORITY = 1,
	DCCP_SCM_QPOLICY_MAX = 0xFFFF,
	/* ^-- Up to here reserved exclusively for qpolicy parameters */
	DCCP_SCM_MAX
};

/* DCCP priorities for outgoing/queued packets */
enum dccp_packet_dequeueing_policy {
	DCCPQ_POLICY_SIMPLE,
	DCCPQ_POLICY_PRIO,
	DCCPQ_POLICY_MAX
};

215
/* DCCP socket options */
216
#define DCCP_SOCKOPT_PACKET_SIZE	1 /* XXX deprecated, without effect */
217
#define DCCP_SOCKOPT_SERVICE		2
218 219
#define DCCP_SOCKOPT_CHANGE_L		3
#define DCCP_SOCKOPT_CHANGE_R		4
220
#define DCCP_SOCKOPT_GET_CUR_MPS	5
221
#define DCCP_SOCKOPT_SERVER_TIMEWAIT	6
222 223
#define DCCP_SOCKOPT_SEND_CSCOV		10
#define DCCP_SOCKOPT_RECV_CSCOV		11
224
#define DCCP_SOCKOPT_AVAILABLE_CCIDS	12
225 226 227
#define DCCP_SOCKOPT_CCID		13
#define DCCP_SOCKOPT_TX_CCID		14
#define DCCP_SOCKOPT_RX_CCID		15
228 229
#define DCCP_SOCKOPT_QPOLICY_ID		16
#define DCCP_SOCKOPT_QPOLICY_TXQLEN	17
230 231
#define DCCP_SOCKOPT_CCID_RX_INFO	128
#define DCCP_SOCKOPT_CCID_TX_INFO	192
232

233
/* maximum number of services provided on the same listening port */
234
#define DCCP_SERVICE_LIST_MAX_LEN      32
235

236 237 238
#ifdef __KERNEL__

#include <linux/in.h>
239
#include <linux/interrupt.h>
240
#include <linux/ktime.h>
241 242 243 244 245
#include <linux/list.h>
#include <linux/uio.h>
#include <linux/workqueue.h>

#include <net/inet_connection_sock.h>
246
#include <net/inet_sock.h>
247
#include <net/inet_timewait_sock.h>
248 249 250
#include <net/tcp_states.h>

enum dccp_state {
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	DCCP_OPEN	     = TCP_ESTABLISHED,
	DCCP_REQUESTING	     = TCP_SYN_SENT,
	DCCP_LISTEN	     = TCP_LISTEN,
	DCCP_RESPOND	     = TCP_SYN_RECV,
	/*
	 * States involved in closing a DCCP connection:
	 * 1) ACTIVE_CLOSEREQ is entered by a server sending a CloseReq.
	 *
	 * 2) CLOSING can have three different meanings (RFC 4340, 8.3):
	 *  a. Client has performed active-close, has sent a Close to the server
	 *     from state OPEN or PARTOPEN, and is waiting for the final Reset
	 *     (in this case, SOCK_DONE == 1).
	 *  b. Client is asked to perform passive-close, by receiving a CloseReq
	 *     in (PART)OPEN state. It sends a Close and waits for final Reset
	 *     (in this case, SOCK_DONE == 0).
	 *  c. Server performs an active-close as in (a), keeps TIMEWAIT state.
	 *
	 * 3) The following intermediate states are employed to give passively
	 *    closing nodes a chance to process their unread data:
	 *    - PASSIVE_CLOSE    (from OPEN => CLOSED) and
	 *    - PASSIVE_CLOSEREQ (from (PART)OPEN to CLOSING; case (b) above).
	 */
	DCCP_ACTIVE_CLOSEREQ = TCP_FIN_WAIT1,
	DCCP_PASSIVE_CLOSE   = TCP_CLOSE_WAIT,	/* any node receiving a Close */
	DCCP_CLOSING	     = TCP_CLOSING,
	DCCP_TIME_WAIT	     = TCP_TIME_WAIT,
	DCCP_CLOSED	     = TCP_CLOSE,
	DCCP_PARTOPEN	     = TCP_MAX_STATES,
	DCCP_PASSIVE_CLOSEREQ,			/* clients receiving CloseReq */
280
	DCCP_MAX_STATES
281 282 283
};

enum {
284 285 286 287 288 289 290 291 292
	DCCPF_OPEN	      = TCPF_ESTABLISHED,
	DCCPF_REQUESTING      = TCPF_SYN_SENT,
	DCCPF_LISTEN	      = TCPF_LISTEN,
	DCCPF_RESPOND	      = TCPF_SYN_RECV,
	DCCPF_ACTIVE_CLOSEREQ = TCPF_FIN_WAIT1,
	DCCPF_CLOSING	      = TCPF_CLOSING,
	DCCPF_TIME_WAIT	      = TCPF_TIME_WAIT,
	DCCPF_CLOSED	      = TCPF_CLOSE,
	DCCPF_PARTOPEN	      = (1 << DCCP_PARTOPEN),
293 294 295 296
};

static inline struct dccp_hdr *dccp_hdr(const struct sk_buff *skb)
{
297
	return (struct dccp_hdr *)skb_transport_header(skb);
298 299
}

300 301
static inline struct dccp_hdr *dccp_zeroed_hdr(struct sk_buff *skb, int headlen)
{
302 303
	skb_push(skb, headlen);
	skb_reset_transport_header(skb);
304
	return memset(skb_transport_header(skb), 0, headlen);
305 306
}

307
static inline struct dccp_hdr_ext *dccp_hdrx(const struct dccp_hdr *dh)
308
{
309
	return (struct dccp_hdr_ext *)((unsigned char *)dh + sizeof(*dh));
310 311
}

312 313 314 315 316
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);
}

317 318 319
static inline unsigned int dccp_basic_hdr_len(const struct sk_buff *skb)
{
	const struct dccp_hdr *dh = dccp_hdr(skb);
320
	return __dccp_basic_hdr_len(dh);
321 322
}

323
static inline __u64 dccp_hdr_seq(const struct dccp_hdr *dh)
324
{
325
	__u64 seq_nr =  ntohs(dh->dccph_seq);
326 327

	if (dh->dccph_x != 0)
328
		seq_nr = (seq_nr << 32) + ntohl(dccp_hdrx(dh)->dccph_seq_low);
329 330
	else
		seq_nr += (u32)dh->dccph_seq2 << 16;
331 332 333 334 335 336

	return seq_nr;
}

static inline struct dccp_hdr_request *dccp_hdr_request(struct sk_buff *skb)
{
337 338
	return (struct dccp_hdr_request *)(skb_transport_header(skb) +
					   dccp_basic_hdr_len(skb));
339 340 341 342
}

static inline struct dccp_hdr_ack_bits *dccp_hdr_ack_bits(const struct sk_buff *skb)
{
343 344
	return (struct dccp_hdr_ack_bits *)(skb_transport_header(skb) +
					    dccp_basic_hdr_len(skb));
345 346 347 348 349
}

static inline u64 dccp_hdr_ack_seq(const struct sk_buff *skb)
{
	const struct dccp_hdr_ack_bits *dhack = dccp_hdr_ack_bits(skb);
350
	return ((u64)ntohs(dhack->dccph_ack_nr_high) << 32) + ntohl(dhack->dccph_ack_nr_low);
351 352 353 354
}

static inline struct dccp_hdr_response *dccp_hdr_response(struct sk_buff *skb)
{
355 356
	return (struct dccp_hdr_response *)(skb_transport_header(skb) +
					    dccp_basic_hdr_len(skb));
357 358 359 360
}

static inline struct dccp_hdr_reset *dccp_hdr_reset(struct sk_buff *skb)
{
361 362
	return (struct dccp_hdr_reset *)(skb_transport_header(skb) +
					 dccp_basic_hdr_len(skb));
363 364
}

365 366 367 368 369 370
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);
}

371 372
static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
{
373
	return __dccp_hdr_len(dccp_hdr(skb));
374 375
}

376 377 378 379 380 381
/**
 * struct dccp_request_sock  -  represent DCCP-specific connection request
 * @dreq_inet_rsk: structure inherited from
 * @dreq_iss: initial sequence number sent on the Response (RFC 4340, 7.1)
 * @dreq_isr: initial sequence number received on the Request
 * @dreq_service: service code present on the Request (there is just one)
382
 * @dreq_featneg: feature negotiation options for this connection
383 384 385 386
 * The following two fields are analogous to the ones in dccp_sock:
 * @dreq_timestamp_echo: last received timestamp to echo (13.1)
 * @dreq_timestamp_echo: the time of receiving the last @dreq_timestamp_echo
 */
387 388 389 390
struct dccp_request_sock {
	struct inet_request_sock dreq_inet_rsk;
	__u64			 dreq_iss;
	__u64			 dreq_isr;
391
	__be32			 dreq_service;
392
	struct list_head	 dreq_featneg;
393 394
	__u32			 dreq_timestamp_echo;
	__u32			 dreq_timestamp_time;
395 396 397 398 399 400 401
};

static inline struct dccp_request_sock *dccp_rsk(const struct request_sock *req)
{
	return (struct dccp_request_sock *)req;
}

402 403
extern struct inet_timewait_death_row dccp_death_row;

404 405 406
extern int dccp_parse_options(struct sock *sk, struct dccp_request_sock *dreq,
			      struct sk_buff *skb);

407
struct dccp_options_received {
408
	u64	dccpor_ndp:48;
409 410 411 412 413 414 415 416 417 418 419 420 421 422
	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,
};

423 424
struct dccp_service_list {
	__u32	dccpsl_nr;
425
	__be32	dccpsl_list[0];
426 427 428
};

#define DCCP_SERVICE_INVALID_VALUE htonl((__u32)-1)
429
#define DCCP_SERVICE_CODE_IS_ABSENT		0
430 431

static inline int dccp_list_has_service(const struct dccp_service_list *sl,
432
					const __be32 service)
433 434 435 436 437
{
	if (likely(sl != NULL)) {
		u32 i = sl->dccpsl_nr;
		while (i--)
			if (sl->dccpsl_list[i] == service)
438
				return 1;
439 440 441 442
	}
	return 0;
}

443 444
struct dccp_ackvec;

445 446 447 448 449 450 451 452 453 454 455 456 457
/**
 * 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
458 459
 * @dccps_service - first (passive sock) or unique (active sock) service code
 * @dccps_service_list - second .. last service code on passive socket
460
 * @dccps_timestamp_echo - latest timestamp received on a TIMESTAMP option
461
 * @dccps_timestamp_time - time of receiving latest @dccps_timestamp_echo
462 463
 * @dccps_l_ack_ratio - feature-local Ack Ratio
 * @dccps_r_ack_ratio - feature-remote Ack Ratio
464 465
 * @dccps_l_seq_win - local Sequence Window (influences ack number validity)
 * @dccps_r_seq_win - remote Sequence Window (influences seq number validity)
466 467
 * @dccps_pcslen - sender   partial checksum coverage (via sockopt)
 * @dccps_pcrlen - receiver partial checksum coverage (via sockopt)
468
 * @dccps_send_ndp_count - local Send NDP Count feature (7.7.2)
469
 * @dccps_ndp_count - number of Non Data Packets since last data packet
470
 * @dccps_mss_cache - current value of MSS (path MTU minus header sizes)
471
 * @dccps_rate_last - timestamp for rate-limiting DCCP-Sync (RFC 4340, 7.5.4)
472
 * @dccps_featneg - tracks feature-negotiation state (mostly during handshake)
473
 * @dccps_hc_rx_ackvec - rx half connection ack vector
474 475 476
 * @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
477 478
 * @dccps_qpolicy - TX dequeueing policy, one of %dccp_packet_dequeueing_policy
 * @dccps_tx_qlen - maximum length of the TX queue
479 480 481
 * @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
482
 * @dccps_server_timewait - server holds timewait state on close (RFC 4340, 8.3)
483
 * @dccps_sync_scheduled - flag which signals "send out-of-band message soon"
484 485
 * @dccps_xmitlet - tasklet scheduled by the TX CCID to dequeue data packets
 * @dccps_xmit_timer - used by the TX CCID to delay sending (rate-based pacing)
486
 * @dccps_syn_rtt - RTT sample from Request/Response exchange (in usecs)
487 488 489 490
 */
struct dccp_sock {
	/* inet_connection_sock has to be the first member of dccp_sock */
	struct inet_connection_sock	dccps_inet_connection;
491
#define dccps_syn_rtt			dccps_inet_connection.icsk_ack.lrcvtime
492 493 494 495 496 497 498 499 500 501
	__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;
502
	__be32				dccps_service;
503
	__u32				dccps_mss_cache;
504
	struct dccp_service_list	*dccps_service_list;
505
	__u32				dccps_timestamp_echo;
506
	__u32				dccps_timestamp_time;
507 508
	__u16				dccps_l_ack_ratio;
	__u16				dccps_r_ack_ratio;
509 510
	__u64				dccps_l_seq_win:48;
	__u64				dccps_r_seq_win:48;
511 512
	__u8				dccps_pcslen:4;
	__u8				dccps_pcrlen:4;
513
	__u8				dccps_send_ndp_count:1;
514
	__u64				dccps_ndp_count:48;
515
	unsigned long			dccps_rate_last;
516
	struct list_head		dccps_featneg;
517
	struct dccp_ackvec		*dccps_hc_rx_ackvec;
518 519 520
	struct ccid			*dccps_hc_rx_ccid;
	struct ccid			*dccps_hc_tx_ccid;
	struct dccp_options_received	dccps_options_received;
521 522
	__u8				dccps_qpolicy;
	__u32				dccps_tx_qlen;
523
	enum dccp_role			dccps_role:2;
524 525
	__u8				dccps_hc_rx_insert_options:1;
	__u8				dccps_hc_tx_insert_options:1;
526
	__u8				dccps_server_timewait:1;
527
	__u8				dccps_sync_scheduled:1;
528
	struct tasklet_struct		dccps_xmitlet;
529
	struct timer_list		dccps_xmit_timer;
530
};
531

532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
static inline struct dccp_sock *dccp_sk(const struct sock *sk)
{
	return (struct dccp_sock *)sk;
}

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;
}

548 549
#endif /* __KERNEL__ */

550
#endif /* _LINUX_DCCP_H */