cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sctp.h (23431B)


      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2/* SCTP kernel reference Implementation
      3 * (C) Copyright IBM Corp. 2001, 2004
      4 * Copyright (c) 1999-2000 Cisco, Inc.
      5 * Copyright (c) 1999-2001 Motorola, Inc.
      6 * Copyright (c) 2001 Intel Corp.
      7 * Copyright (c) 2001 Nokia, Inc.
      8 * Copyright (c) 2001 La Monte H.P. Yarroll
      9 *
     10 * This file is part of the SCTP kernel reference Implementation
     11 *
     12 * Various protocol defined structures.
     13 *
     14 * Please send any bug reports or fixes you make to the
     15 * email address(es):
     16 *    lksctp developers <linux-sctp@vger.kernel.org>
     17 *
     18 * Or submit a bug report through the following website:
     19 *    http://www.sf.net/projects/lksctp
     20 *
     21 * Written or modified by:
     22 *    La Monte H.P. Yarroll <piggy@acm.org>
     23 *    Karl Knutson <karl@athena.chicago.il.us>
     24 *    Jon Grimm <jgrimm@us.ibm.com>
     25 *    Xingang Guo <xingang.guo@intel.com>
     26 *    randall@sctp.chicago.il.us
     27 *    kmorneau@cisco.com
     28 *    qxie1@email.mot.com
     29 *    Sridhar Samudrala <sri@us.ibm.com>
     30 *    Kevin Gao <kevin.gao@intel.com>
     31 *
     32 * Any bugs reported given to us we will try to fix... any fixes shared will
     33 * be incorporated into the next SCTP release.
     34 */
     35#ifndef __LINUX_SCTP_H__
     36#define __LINUX_SCTP_H__
     37
     38#include <linux/in.h>		/* We need in_addr.  */
     39#include <linux/in6.h>		/* We need in6_addr.  */
     40#include <linux/skbuff.h>
     41
     42#include <uapi/linux/sctp.h>
     43
     44/* Section 3.1.  SCTP Common Header Format */
     45struct sctphdr {
     46	__be16 source;
     47	__be16 dest;
     48	__be32 vtag;
     49	__le32 checksum;
     50};
     51
     52static inline struct sctphdr *sctp_hdr(const struct sk_buff *skb)
     53{
     54	return (struct sctphdr *)skb_transport_header(skb);
     55}
     56
     57/* Section 3.2.  Chunk Field Descriptions. */
     58struct sctp_chunkhdr {
     59	__u8 type;
     60	__u8 flags;
     61	__be16 length;
     62};
     63
     64
     65/* Section 3.2.  Chunk Type Values.
     66 * [Chunk Type] identifies the type of information contained in the Chunk
     67 * Value field. It takes a value from 0 to 254. The value of 255 is
     68 * reserved for future use as an extension field.
     69 */
     70enum sctp_cid {
     71	SCTP_CID_DATA			= 0,
     72        SCTP_CID_INIT			= 1,
     73        SCTP_CID_INIT_ACK		= 2,
     74        SCTP_CID_SACK			= 3,
     75        SCTP_CID_HEARTBEAT		= 4,
     76        SCTP_CID_HEARTBEAT_ACK		= 5,
     77        SCTP_CID_ABORT			= 6,
     78        SCTP_CID_SHUTDOWN		= 7,
     79        SCTP_CID_SHUTDOWN_ACK		= 8,
     80        SCTP_CID_ERROR			= 9,
     81        SCTP_CID_COOKIE_ECHO		= 10,
     82        SCTP_CID_COOKIE_ACK	        = 11,
     83        SCTP_CID_ECN_ECNE		= 12,
     84        SCTP_CID_ECN_CWR		= 13,
     85        SCTP_CID_SHUTDOWN_COMPLETE	= 14,
     86
     87	/* AUTH Extension Section 4.1 */
     88	SCTP_CID_AUTH			= 0x0F,
     89
     90	/* sctp ndata 5.1. I-DATA */
     91	SCTP_CID_I_DATA			= 0x40,
     92
     93	/* PR-SCTP Sec 3.2 */
     94	SCTP_CID_FWD_TSN		= 0xC0,
     95
     96	/* Use hex, as defined in ADDIP sec. 3.1 */
     97	SCTP_CID_ASCONF			= 0xC1,
     98	SCTP_CID_I_FWD_TSN		= 0xC2,
     99	SCTP_CID_ASCONF_ACK		= 0x80,
    100	SCTP_CID_RECONF			= 0x82,
    101	SCTP_CID_PAD			= 0x84,
    102}; /* enum */
    103
    104
    105/* Section 3.2
    106 *  Chunk Types are encoded such that the highest-order two bits specify
    107 *  the action that must be taken if the processing endpoint does not
    108 *  recognize the Chunk Type.
    109 */
    110enum {
    111	SCTP_CID_ACTION_DISCARD     = 0x00,
    112	SCTP_CID_ACTION_DISCARD_ERR = 0x40,
    113	SCTP_CID_ACTION_SKIP        = 0x80,
    114	SCTP_CID_ACTION_SKIP_ERR    = 0xc0,
    115};
    116
    117enum { SCTP_CID_ACTION_MASK = 0xc0, };
    118
    119/* This flag is used in Chunk Flags for ABORT and SHUTDOWN COMPLETE.
    120 *
    121 * 3.3.7 Abort Association (ABORT) (6):
    122 *    The T bit is set to 0 if the sender had a TCB that it destroyed.
    123 *    If the sender did not have a TCB it should set this bit to 1.
    124 */
    125enum { SCTP_CHUNK_FLAG_T = 0x01 };
    126
    127/*
    128 *  Set the T bit
    129 *
    130 *      0                   1                   2                   3
    131 *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    132 *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    133 *     |   Type = 14   |Reserved     |T|      Length = 4               |
    134 *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    135 *
    136 * Chunk Flags: 8 bits
    137 *
    138 *   Reserved:  7 bits
    139 *     Set to 0 on transmit and ignored on receipt.
    140 *
    141 *   T bit:  1 bit
    142 *     The T bit is set to 0 if the sender had a TCB that it destroyed. If
    143 *     the sender did NOT have a TCB it should set this bit to 1.
    144 *
    145 * Note: Special rules apply to this chunk for verification, please
    146 * see Section 8.5.1 for details.
    147 */
    148
    149#define sctp_test_T_bit(c)    ((c)->chunk_hdr->flags & SCTP_CHUNK_FLAG_T)
    150
    151/* RFC 2960
    152 * Section 3.2.1 Optional/Variable-length Parmaeter Format.
    153 */
    154
    155struct sctp_paramhdr {
    156	__be16 type;
    157	__be16 length;
    158};
    159
    160enum sctp_param {
    161
    162	/* RFC 2960 Section 3.3.5 */
    163	SCTP_PARAM_HEARTBEAT_INFO		= cpu_to_be16(1),
    164	/* RFC 2960 Section 3.3.2.1 */
    165	SCTP_PARAM_IPV4_ADDRESS			= cpu_to_be16(5),
    166	SCTP_PARAM_IPV6_ADDRESS			= cpu_to_be16(6),
    167	SCTP_PARAM_STATE_COOKIE			= cpu_to_be16(7),
    168	SCTP_PARAM_UNRECOGNIZED_PARAMETERS	= cpu_to_be16(8),
    169	SCTP_PARAM_COOKIE_PRESERVATIVE		= cpu_to_be16(9),
    170	SCTP_PARAM_HOST_NAME_ADDRESS		= cpu_to_be16(11),
    171	SCTP_PARAM_SUPPORTED_ADDRESS_TYPES	= cpu_to_be16(12),
    172	SCTP_PARAM_ECN_CAPABLE			= cpu_to_be16(0x8000),
    173
    174	/* AUTH Extension Section 3 */
    175	SCTP_PARAM_RANDOM			= cpu_to_be16(0x8002),
    176	SCTP_PARAM_CHUNKS			= cpu_to_be16(0x8003),
    177	SCTP_PARAM_HMAC_ALGO			= cpu_to_be16(0x8004),
    178
    179	/* Add-IP: Supported Extensions, Section 4.2 */
    180	SCTP_PARAM_SUPPORTED_EXT	= cpu_to_be16(0x8008),
    181
    182	/* PR-SCTP Sec 3.1 */
    183	SCTP_PARAM_FWD_TSN_SUPPORT	= cpu_to_be16(0xc000),
    184
    185	/* Add-IP Extension. Section 3.2 */
    186	SCTP_PARAM_ADD_IP		= cpu_to_be16(0xc001),
    187	SCTP_PARAM_DEL_IP		= cpu_to_be16(0xc002),
    188	SCTP_PARAM_ERR_CAUSE		= cpu_to_be16(0xc003),
    189	SCTP_PARAM_SET_PRIMARY		= cpu_to_be16(0xc004),
    190	SCTP_PARAM_SUCCESS_REPORT	= cpu_to_be16(0xc005),
    191	SCTP_PARAM_ADAPTATION_LAYER_IND = cpu_to_be16(0xc006),
    192
    193	/* RE-CONFIG. Section 4 */
    194	SCTP_PARAM_RESET_OUT_REQUEST		= cpu_to_be16(0x000d),
    195	SCTP_PARAM_RESET_IN_REQUEST		= cpu_to_be16(0x000e),
    196	SCTP_PARAM_RESET_TSN_REQUEST		= cpu_to_be16(0x000f),
    197	SCTP_PARAM_RESET_RESPONSE		= cpu_to_be16(0x0010),
    198	SCTP_PARAM_RESET_ADD_OUT_STREAMS	= cpu_to_be16(0x0011),
    199	SCTP_PARAM_RESET_ADD_IN_STREAMS		= cpu_to_be16(0x0012),
    200}; /* enum */
    201
    202
    203/* RFC 2960 Section 3.2.1
    204 *  The Parameter Types are encoded such that the highest-order two bits
    205 *  specify the action that must be taken if the processing endpoint does
    206 *  not recognize the Parameter Type.
    207 *
    208 */
    209enum {
    210	SCTP_PARAM_ACTION_DISCARD     = cpu_to_be16(0x0000),
    211	SCTP_PARAM_ACTION_DISCARD_ERR = cpu_to_be16(0x4000),
    212	SCTP_PARAM_ACTION_SKIP        = cpu_to_be16(0x8000),
    213	SCTP_PARAM_ACTION_SKIP_ERR    = cpu_to_be16(0xc000),
    214};
    215
    216enum { SCTP_PARAM_ACTION_MASK = cpu_to_be16(0xc000), };
    217
    218/* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */
    219
    220struct sctp_datahdr {
    221	__be32 tsn;
    222	__be16 stream;
    223	__be16 ssn;
    224	__u32 ppid;
    225	__u8  payload[];
    226};
    227
    228struct sctp_data_chunk {
    229	struct sctp_chunkhdr chunk_hdr;
    230	struct sctp_datahdr data_hdr;
    231};
    232
    233struct sctp_idatahdr {
    234	__be32 tsn;
    235	__be16 stream;
    236	__be16 reserved;
    237	__be32 mid;
    238	union {
    239		__u32 ppid;
    240		__be32 fsn;
    241	};
    242	__u8 payload[0];
    243};
    244
    245struct sctp_idata_chunk {
    246	struct sctp_chunkhdr chunk_hdr;
    247	struct sctp_idatahdr data_hdr;
    248};
    249
    250/* DATA Chuck Specific Flags */
    251enum {
    252	SCTP_DATA_MIDDLE_FRAG	= 0x00,
    253	SCTP_DATA_LAST_FRAG	= 0x01,
    254	SCTP_DATA_FIRST_FRAG	= 0x02,
    255	SCTP_DATA_NOT_FRAG	= 0x03,
    256	SCTP_DATA_UNORDERED	= 0x04,
    257	SCTP_DATA_SACK_IMM	= 0x08,
    258};
    259enum { SCTP_DATA_FRAG_MASK = 0x03, };
    260
    261
    262/* RFC 2960 Section 3.3.2 Initiation (INIT) (1)
    263 *
    264 *  This chunk is used to initiate a SCTP association between two
    265 *  endpoints.
    266 */
    267struct sctp_inithdr {
    268	__be32 init_tag;
    269	__be32 a_rwnd;
    270	__be16 num_outbound_streams;
    271	__be16 num_inbound_streams;
    272	__be32 initial_tsn;
    273	__u8  params[];
    274};
    275
    276struct sctp_init_chunk {
    277	struct sctp_chunkhdr chunk_hdr;
    278	struct sctp_inithdr init_hdr;
    279};
    280
    281
    282/* Section 3.3.2.1. IPv4 Address Parameter (5) */
    283struct sctp_ipv4addr_param {
    284	struct sctp_paramhdr param_hdr;
    285	struct in_addr addr;
    286};
    287
    288/* Section 3.3.2.1. IPv6 Address Parameter (6) */
    289struct sctp_ipv6addr_param {
    290	struct sctp_paramhdr param_hdr;
    291	struct in6_addr addr;
    292};
    293
    294/* Section 3.3.2.1 Cookie Preservative (9) */
    295struct sctp_cookie_preserve_param {
    296	struct sctp_paramhdr param_hdr;
    297	__be32 lifespan_increment;
    298};
    299
    300/* Section 3.3.2.1 Host Name Address (11) */
    301struct sctp_hostname_param {
    302	struct sctp_paramhdr param_hdr;
    303	uint8_t hostname[];
    304};
    305
    306/* Section 3.3.2.1 Supported Address Types (12) */
    307struct sctp_supported_addrs_param {
    308	struct sctp_paramhdr param_hdr;
    309	__be16 types[];
    310};
    311
    312/* ADDIP Section 3.2.6 Adaptation Layer Indication */
    313struct sctp_adaptation_ind_param {
    314	struct sctp_paramhdr param_hdr;
    315	__be32 adaptation_ind;
    316};
    317
    318/* ADDIP Section 4.2.7 Supported Extensions Parameter */
    319struct sctp_supported_ext_param {
    320	struct sctp_paramhdr param_hdr;
    321	__u8 chunks[];
    322};
    323
    324/* AUTH Section 3.1 Random */
    325struct sctp_random_param {
    326	struct sctp_paramhdr param_hdr;
    327	__u8 random_val[];
    328};
    329
    330/* AUTH Section 3.2 Chunk List */
    331struct sctp_chunks_param {
    332	struct sctp_paramhdr param_hdr;
    333	__u8 chunks[];
    334};
    335
    336/* AUTH Section 3.3 HMAC Algorithm */
    337struct sctp_hmac_algo_param {
    338	struct sctp_paramhdr param_hdr;
    339	__be16 hmac_ids[];
    340};
    341
    342/* RFC 2960.  Section 3.3.3 Initiation Acknowledgement (INIT ACK) (2):
    343 *   The INIT ACK chunk is used to acknowledge the initiation of an SCTP
    344 *   association.
    345 */
    346struct sctp_initack_chunk {
    347	struct sctp_chunkhdr chunk_hdr;
    348	struct sctp_inithdr init_hdr;
    349};
    350
    351/* Section 3.3.3.1 State Cookie (7) */
    352struct sctp_cookie_param {
    353	struct sctp_paramhdr p;
    354	__u8 body[];
    355};
    356
    357/* Section 3.3.3.1 Unrecognized Parameters (8) */
    358struct sctp_unrecognized_param {
    359	struct sctp_paramhdr param_hdr;
    360	struct sctp_paramhdr unrecognized;
    361};
    362
    363
    364
    365/*
    366 * 3.3.4 Selective Acknowledgement (SACK) (3):
    367 *
    368 *  This chunk is sent to the peer endpoint to acknowledge received DATA
    369 *  chunks and to inform the peer endpoint of gaps in the received
    370 *  subsequences of DATA chunks as represented by their TSNs.
    371 */
    372
    373struct sctp_gap_ack_block {
    374	__be16 start;
    375	__be16 end;
    376};
    377
    378union sctp_sack_variable {
    379	struct sctp_gap_ack_block gab;
    380	__be32 dup;
    381};
    382
    383struct sctp_sackhdr {
    384	__be32 cum_tsn_ack;
    385	__be32 a_rwnd;
    386	__be16 num_gap_ack_blocks;
    387	__be16 num_dup_tsns;
    388	union sctp_sack_variable variable[];
    389};
    390
    391struct sctp_sack_chunk {
    392	struct sctp_chunkhdr chunk_hdr;
    393	struct sctp_sackhdr sack_hdr;
    394};
    395
    396
    397/* RFC 2960.  Section 3.3.5 Heartbeat Request (HEARTBEAT) (4):
    398 *
    399 *  An endpoint should send this chunk to its peer endpoint to probe the
    400 *  reachability of a particular destination transport address defined in
    401 *  the present association.
    402 */
    403
    404struct sctp_heartbeathdr {
    405	struct sctp_paramhdr info;
    406};
    407
    408struct sctp_heartbeat_chunk {
    409	struct sctp_chunkhdr chunk_hdr;
    410	struct sctp_heartbeathdr hb_hdr;
    411};
    412
    413
    414/* PAD chunk could be bundled with heartbeat chunk to probe pmtu */
    415struct sctp_pad_chunk {
    416	struct sctp_chunkhdr uh;
    417};
    418
    419
    420/* For the abort and shutdown ACK we must carry the init tag in the
    421 * common header. Just the common header is all that is needed with a
    422 * chunk descriptor.
    423 */
    424struct sctp_abort_chunk {
    425	struct sctp_chunkhdr uh;
    426};
    427
    428
    429/* For the graceful shutdown we must carry the tag (in common header)
    430 * and the highest consecutive acking value.
    431 */
    432struct sctp_shutdownhdr {
    433	__be32 cum_tsn_ack;
    434};
    435
    436struct sctp_shutdown_chunk {
    437	struct sctp_chunkhdr chunk_hdr;
    438	struct sctp_shutdownhdr shutdown_hdr;
    439};
    440
    441/* RFC 2960.  Section 3.3.10 Operation Error (ERROR) (9) */
    442
    443struct sctp_errhdr {
    444	__be16 cause;
    445	__be16 length;
    446	__u8  variable[];
    447};
    448
    449struct sctp_operr_chunk {
    450	struct sctp_chunkhdr chunk_hdr;
    451	struct sctp_errhdr err_hdr;
    452};
    453
    454/* RFC 2960 3.3.10 - Operation Error
    455 *
    456 * Cause Code: 16 bits (unsigned integer)
    457 *
    458 *     Defines the type of error conditions being reported.
    459 *    Cause Code
    460 *     Value           Cause Code
    461 *     ---------      ----------------
    462 *      1              Invalid Stream Identifier
    463 *      2              Missing Mandatory Parameter
    464 *      3              Stale Cookie Error
    465 *      4              Out of Resource
    466 *      5              Unresolvable Address
    467 *      6              Unrecognized Chunk Type
    468 *      7              Invalid Mandatory Parameter
    469 *      8              Unrecognized Parameters
    470 *      9              No User Data
    471 *     10              Cookie Received While Shutting Down
    472 */
    473enum sctp_error {
    474
    475	SCTP_ERROR_NO_ERROR	   = cpu_to_be16(0x00),
    476	SCTP_ERROR_INV_STRM	   = cpu_to_be16(0x01),
    477	SCTP_ERROR_MISS_PARAM 	   = cpu_to_be16(0x02),
    478	SCTP_ERROR_STALE_COOKIE	   = cpu_to_be16(0x03),
    479	SCTP_ERROR_NO_RESOURCE 	   = cpu_to_be16(0x04),
    480	SCTP_ERROR_DNS_FAILED      = cpu_to_be16(0x05),
    481	SCTP_ERROR_UNKNOWN_CHUNK   = cpu_to_be16(0x06),
    482	SCTP_ERROR_INV_PARAM       = cpu_to_be16(0x07),
    483	SCTP_ERROR_UNKNOWN_PARAM   = cpu_to_be16(0x08),
    484	SCTP_ERROR_NO_DATA         = cpu_to_be16(0x09),
    485	SCTP_ERROR_COOKIE_IN_SHUTDOWN = cpu_to_be16(0x0a),
    486
    487
    488	/* SCTP Implementation Guide:
    489	 *  11  Restart of an association with new addresses
    490	 *  12  User Initiated Abort
    491	 *  13  Protocol Violation
    492	 *  14  Restart of an Association with New Encapsulation Port
    493	 */
    494
    495	SCTP_ERROR_RESTART         = cpu_to_be16(0x0b),
    496	SCTP_ERROR_USER_ABORT      = cpu_to_be16(0x0c),
    497	SCTP_ERROR_PROTO_VIOLATION = cpu_to_be16(0x0d),
    498	SCTP_ERROR_NEW_ENCAP_PORT  = cpu_to_be16(0x0e),
    499
    500	/* ADDIP Section 3.3  New Error Causes
    501	 *
    502	 * Four new Error Causes are added to the SCTP Operational Errors,
    503	 * primarily for use in the ASCONF-ACK chunk.
    504	 *
    505	 * Value          Cause Code
    506	 * ---------      ----------------
    507	 * 0x00A0          Request to Delete Last Remaining IP Address.
    508	 * 0x00A1          Operation Refused Due to Resource Shortage.
    509	 * 0x00A2          Request to Delete Source IP Address.
    510	 * 0x00A3          Association Aborted due to illegal ASCONF-ACK
    511	 * 0x00A4          Request refused - no authorization.
    512	 */
    513	SCTP_ERROR_DEL_LAST_IP	= cpu_to_be16(0x00A0),
    514	SCTP_ERROR_RSRC_LOW	= cpu_to_be16(0x00A1),
    515	SCTP_ERROR_DEL_SRC_IP	= cpu_to_be16(0x00A2),
    516	SCTP_ERROR_ASCONF_ACK   = cpu_to_be16(0x00A3),
    517	SCTP_ERROR_REQ_REFUSED	= cpu_to_be16(0x00A4),
    518
    519	/* AUTH Section 4.  New Error Cause
    520	 *
    521	 * This section defines a new error cause that will be sent if an AUTH
    522	 * chunk is received with an unsupported HMAC identifier.
    523	 * illustrates the new error cause.
    524	 *
    525	 * Cause Code      Error Cause Name
    526	 * --------------------------------------------------------------
    527	 * 0x0105          Unsupported HMAC Identifier
    528	 */
    529	 SCTP_ERROR_UNSUP_HMAC	= cpu_to_be16(0x0105)
    530};
    531
    532
    533
    534/* RFC 2960.  Appendix A.  Explicit Congestion Notification.
    535 *   Explicit Congestion Notification Echo (ECNE) (12)
    536 */
    537struct sctp_ecnehdr {
    538	__be32 lowest_tsn;
    539};
    540
    541struct sctp_ecne_chunk {
    542	struct sctp_chunkhdr chunk_hdr;
    543	struct sctp_ecnehdr ence_hdr;
    544};
    545
    546/* RFC 2960.  Appendix A.  Explicit Congestion Notification.
    547 *   Congestion Window Reduced (CWR) (13)
    548 */
    549struct sctp_cwrhdr {
    550	__be32 lowest_tsn;
    551};
    552
    553/* PR-SCTP
    554 * 3.2 Forward Cumulative TSN Chunk Definition (FORWARD TSN)
    555 *
    556 * Forward Cumulative TSN chunk has the following format:
    557 *
    558 *        0                   1                   2                   3
    559 *        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    560 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    561 *      |   Type = 192  |  Flags = 0x00 |        Length = Variable      |
    562 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    563 *      |                      New Cumulative TSN                       |
    564 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    565 *      |         Stream-1              |       Stream Sequence-1       |
    566 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    567 *      \                                                               /
    568 *      /                                                               \
    569 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    570 *      |         Stream-N              |       Stream Sequence-N       |
    571 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    572 *
    573 *      Chunk Flags:
    574 *
    575 *        Set to all zeros on transmit and ignored on receipt.
    576 *
    577 *      New Cumulative TSN: 32 bit u_int
    578 *
    579 *       This indicates the new cumulative TSN to the data receiver. Upon
    580 *       the reception of this value, the data receiver MUST consider
    581 *       any missing TSNs earlier than or equal to this value as received
    582 *       and stop reporting them as gaps in any subsequent SACKs.
    583 *
    584 *      Stream-N: 16 bit u_int
    585 *
    586 *       This field holds a stream number that was skipped by this
    587 *       FWD-TSN.
    588 *
    589 *      Stream Sequence-N: 16 bit u_int
    590 *       This field holds the sequence number associated with the stream
    591 *       that was skipped. The stream sequence field holds the largest stream
    592 *       sequence number in this stream being skipped.  The receiver of
    593 *       the FWD-TSN's can use the Stream-N and Stream Sequence-N fields
    594 *       to enable delivery of any stranded TSN's that remain on the stream
    595 *       re-ordering queues. This field MUST NOT report TSN's corresponding
    596 *       to DATA chunk that are marked as unordered. For ordered DATA
    597 *       chunks this field MUST be filled in.
    598 */
    599struct sctp_fwdtsn_skip {
    600	__be16 stream;
    601	__be16 ssn;
    602};
    603
    604struct sctp_fwdtsn_hdr {
    605	__be32 new_cum_tsn;
    606	struct sctp_fwdtsn_skip skip[];
    607};
    608
    609struct sctp_fwdtsn_chunk {
    610	struct sctp_chunkhdr chunk_hdr;
    611	struct sctp_fwdtsn_hdr fwdtsn_hdr;
    612};
    613
    614struct sctp_ifwdtsn_skip {
    615	__be16 stream;
    616	__u8 reserved;
    617	__u8 flags;
    618	__be32 mid;
    619};
    620
    621struct sctp_ifwdtsn_hdr {
    622	__be32 new_cum_tsn;
    623	struct sctp_ifwdtsn_skip skip[];
    624};
    625
    626struct sctp_ifwdtsn_chunk {
    627	struct sctp_chunkhdr chunk_hdr;
    628	struct sctp_ifwdtsn_hdr fwdtsn_hdr;
    629};
    630
    631/* ADDIP
    632 * Section 3.1.1 Address Configuration Change Chunk (ASCONF)
    633 *
    634 * 	Serial Number: 32 bits (unsigned integer)
    635 *	This value represents a Serial Number for the ASCONF Chunk. The
    636 *	valid range of Serial Number is from 0 to 2^32-1.
    637 *	Serial Numbers wrap back to 0 after reaching 2^32 -1.
    638 *
    639 *	Address Parameter: 8 or 20 bytes (depending on type)
    640 *	The address is an address of the sender of the ASCONF chunk,
    641 *	the address MUST be considered part of the association by the
    642 *	peer endpoint. This field may be used by the receiver of the 
    643 *	ASCONF to help in finding the association. This parameter MUST
    644 *	be present in every ASCONF message i.e. it is a mandatory TLV
    645 *	parameter.
    646 *
    647 *	ASCONF Parameter: TLV format
    648 *	Each Address configuration change is represented by a TLV
    649 *	parameter as defined in Section 3.2. One or more requests may
    650 *	be present in an ASCONF Chunk.
    651 *
    652 * Section 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
    653 * 
    654 *	Serial Number: 32 bits (unsigned integer)
    655 *	This value represents the Serial Number for the received ASCONF
    656 *	Chunk that is acknowledged by this chunk. This value is copied
    657 *	from the received ASCONF Chunk. 
    658 *
    659 *	ASCONF Parameter Response: TLV format
    660 *	The ASCONF Parameter Response is used in the ASCONF-ACK to
    661 *	report status of ASCONF processing.
    662 */
    663struct sctp_addip_param {
    664	struct sctp_paramhdr param_hdr;
    665	__be32 crr_id;
    666};
    667
    668struct sctp_addiphdr {
    669	__be32	serial;
    670	__u8	params[];
    671};
    672
    673struct sctp_addip_chunk {
    674	struct sctp_chunkhdr chunk_hdr;
    675	struct sctp_addiphdr addip_hdr;
    676};
    677
    678/* AUTH
    679 * Section 4.1  Authentication Chunk (AUTH)
    680 *
    681 *   This chunk is used to hold the result of the HMAC calculation.
    682 *
    683 *    0                   1                   2                   3
    684 *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    685 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    686 *   | Type = 0x0F   |   Flags=0     |             Length            |
    687 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    688 *   |     Shared Key Identifier     |   HMAC Identifier             |
    689 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    690 *   |                                                               |
    691 *   \                             HMAC                              /
    692 *   /                                                               \
    693 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    694 *
    695 *   Type: 1 byte (unsigned integer)
    696 *   	This value MUST be set to 0x0F for  all AUTH-chunks.
    697 *
    698 *   Flags: 1 byte (unsigned integer)
    699 *	Set to zero on transmit and ignored on receipt.
    700 *
    701 *   Length: 2 bytes (unsigned integer)
    702 *   	This value holds the length of the HMAC in bytes plus 8.
    703 *
    704 *  Shared Key Identifier: 2 bytes (unsigned integer)
    705 *	This value describes which endpoint pair shared key is used.
    706 *
    707 *   HMAC Identifier: 2 bytes (unsigned integer)
    708 *   	This value describes which message digest is being used.  Table 2
    709 *	shows the currently defined values.
    710 *
    711 *    The following Table 2 shows the currently defined values for HMAC
    712 *       identifiers.
    713 *
    714 *	 +-----------------+--------------------------+
    715 *	 | HMAC Identifier | Message Digest Algorithm |
    716 *	 +-----------------+--------------------------+
    717 *	 | 0               | Reserved                 |
    718 *	 | 1               | SHA-1 defined in [8]     |
    719 *	 | 2               | Reserved                 |
    720 *	 | 3               | SHA-256 defined in [8]   |
    721 *	 +-----------------+--------------------------+
    722 *
    723 *
    724 *   HMAC: n bytes (unsigned integer) This hold the result of the HMAC
    725 *      calculation.
    726 */
    727struct sctp_authhdr {
    728	__be16 shkey_id;
    729	__be16 hmac_id;
    730	__u8   hmac[];
    731};
    732
    733struct sctp_auth_chunk {
    734	struct sctp_chunkhdr chunk_hdr;
    735	struct sctp_authhdr auth_hdr;
    736};
    737
    738struct sctp_infox {
    739	struct sctp_info *sctpinfo;
    740	struct sctp_association *asoc;
    741};
    742
    743struct sctp_reconf_chunk {
    744	struct sctp_chunkhdr chunk_hdr;
    745	__u8 params[];
    746};
    747
    748struct sctp_strreset_outreq {
    749	struct sctp_paramhdr param_hdr;
    750	__be32 request_seq;
    751	__be32 response_seq;
    752	__be32 send_reset_at_tsn;
    753	__be16 list_of_streams[];
    754};
    755
    756struct sctp_strreset_inreq {
    757	struct sctp_paramhdr param_hdr;
    758	__be32 request_seq;
    759	__be16 list_of_streams[];
    760};
    761
    762struct sctp_strreset_tsnreq {
    763	struct sctp_paramhdr param_hdr;
    764	__be32 request_seq;
    765};
    766
    767struct sctp_strreset_addstrm {
    768	struct sctp_paramhdr param_hdr;
    769	__be32 request_seq;
    770	__be16 number_of_streams;
    771	__be16 reserved;
    772};
    773
    774enum {
    775	SCTP_STRRESET_NOTHING_TO_DO	= 0x00,
    776	SCTP_STRRESET_PERFORMED		= 0x01,
    777	SCTP_STRRESET_DENIED		= 0x02,
    778	SCTP_STRRESET_ERR_WRONG_SSN	= 0x03,
    779	SCTP_STRRESET_ERR_IN_PROGRESS	= 0x04,
    780	SCTP_STRRESET_ERR_BAD_SEQNO	= 0x05,
    781	SCTP_STRRESET_IN_PROGRESS	= 0x06,
    782};
    783
    784struct sctp_strreset_resp {
    785	struct sctp_paramhdr param_hdr;
    786	__be32 response_seq;
    787	__be32 result;
    788};
    789
    790struct sctp_strreset_resptsn {
    791	struct sctp_paramhdr param_hdr;
    792	__be32 response_seq;
    793	__be32 result;
    794	__be32 senders_next_tsn;
    795	__be32 receivers_next_tsn;
    796};
    797
    798enum {
    799	SCTP_DSCP_SET_MASK = 0x1,
    800	SCTP_DSCP_VAL_MASK = 0xfc,
    801	SCTP_FLOWLABEL_SET_MASK = 0x100000,
    802	SCTP_FLOWLABEL_VAL_MASK = 0xfffff
    803};
    804
    805/* UDP Encapsulation
    806 * draft-tuexen-tsvwg-sctp-udp-encaps-cons-03.html#section-4-4
    807 *
    808 *   The error cause indicating an "Restart of an Association with
    809 *   New Encapsulation Port"
    810 *
    811 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    812 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    813 * |        Cause Code = 14        |       Cause Length = 8        |
    814 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    815 * |   Current Encapsulation Port  |     New Encapsulation Port    |
    816 * +-------------------------------+-------------------------------+
    817 */
    818struct sctp_new_encap_port_hdr {
    819	__be16 cur_port;
    820	__be16 new_port;
    821};
    822
    823#endif /* __LINUX_SCTP_H__ */