include/linux/sctp.h

   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 */
  45 struct sctphdr {
  46         __be16 source;
  47         __be16 dest;
  48         __be32 vtag;
  49         __le32 checksum;
  50 };
  51
  52 static 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. */
  58 struct 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  */
  70 enum 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  */
 110 enum {
 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
 117 enum { 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  */
 125 enum { 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
 155 struct sctp_paramhdr {
 156         __be16 type;
 157         __be16 length;
 158 };
 159
 160 enum 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  */
 209 enum {
 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
 216 enum { SCTP_PARAM_ACTION_MASK = cpu_to_be16(0xc000), };
 217
 218 /* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */
 219
 220 struct sctp_datahdr {
 221         __be32 tsn;
 222         __be16 stream;
 223         __be16 ssn;
 224         __u32 ppid;
 225         __u8  payload[];
 226 };
 227
 228 struct sctp_data_chunk {
 229         struct sctp_chunkhdr chunk_hdr;
 230         struct sctp_datahdr data_hdr;
 231 };
 232
 233 struct 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
 245 struct sctp_idata_chunk {
 246         struct sctp_chunkhdr chunk_hdr;
 247         struct sctp_idatahdr data_hdr;
 248 };
 249
 250 /* DATA Chuck Specific Flags */
 251 enum {
 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 };
 259 enum { 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  */
 267 struct 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
 276 struct 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) */
 283 struct 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) */
 289 struct 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) */
 295 struct 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) */
 301 struct 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) */
 307 struct sctp_supported_addrs_param {
 308         struct sctp_paramhdr param_hdr;
 309         __be16 types[];
 310 };
 311
 312 /* ADDIP Section 3.2.6 Adaptation Layer Indication */
 313 struct 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 */
 319 struct sctp_supported_ext_param {
 320         struct sctp_paramhdr param_hdr;
 321         __u8 chunks[];
 322 };
 323
 324 /* AUTH Section 3.1 Random */
 325 struct sctp_random_param {
 326         struct sctp_paramhdr param_hdr;
 327         __u8 random_val[];
 328 };
 329
 330 /* AUTH Section 3.2 Chunk List */
 331 struct sctp_chunks_param {
 332         struct sctp_paramhdr param_hdr;
 333         __u8 chunks[];
 334 };
 335
 336 /* AUTH Section 3.3 HMAC Algorithm */
 337 struct 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  */
 346 struct 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) */
 352 struct sctp_cookie_param {
 353         struct sctp_paramhdr p;
 354         __u8 body[];
 355 };
 356
 357 /* Section 3.3.3.1 Unrecognized Parameters (8) */
 358 struct 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
 373 struct sctp_gap_ack_block {
 374         __be16 start;
 375         __be16 end;
 376 };
 377
 378 union sctp_sack_variable {
 379         struct sctp_gap_ack_block gab;
 380         __be32 dup;
 381 };
 382
 383 struct 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
 391 struct 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
 404 struct sctp_heartbeathdr {
 405         struct sctp_paramhdr info;
 406 };
 407
 408 struct 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 */
 415 struct 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  */
 424 struct 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  */
 432 struct sctp_shutdownhdr {
 433         __be32 cum_tsn_ack;
 434 };
 435
 436 struct 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
 443 struct sctp_errhdr {
 444         __be16 cause;
 445         __be16 length;
 446         __u8  variable[];
 447 };
 448
 449 struct 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  */
 473 enum 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  */
 537 struct sctp_ecnehdr {
 538         __be32 lowest_tsn;
 539 };
 540
 541 struct 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  */
 549 struct 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  */
 599 struct sctp_fwdtsn_skip {
 600         __be16 stream;
 601         __be16 ssn;
 602 };
 603
 604 struct sctp_fwdtsn_hdr {
 605         __be32 new_cum_tsn;
 606         struct sctp_fwdtsn_skip skip[];
 607 };
 608
 609 struct sctp_fwdtsn_chunk {
 610         struct sctp_chunkhdr chunk_hdr;
 611         struct sctp_fwdtsn_hdr fwdtsn_hdr;
 612 };
 613
 614 struct sctp_ifwdtsn_skip {
 615         __be16 stream;
 616         __u8 reserved;
 617         __u8 flags;
 618         __be32 mid;
 619 };
 620
 621 struct sctp_ifwdtsn_hdr {
 622         __be32 new_cum_tsn;
 623         struct sctp_ifwdtsn_skip skip[];
 624 };
 625
 626 struct 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  */
 663 struct sctp_addip_param {
 664         struct sctp_paramhdr param_hdr;
 665         __be32 crr_id;
 666 };
 667
 668 struct sctp_addiphdr {
 669         __be32  serial;
 670         __u8    params[];
 671 };
 672
 673 struct 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  */
 727 struct sctp_authhdr {
 728         __be16 shkey_id;
 729         __be16 hmac_id;
 730         __u8   hmac[];
 731 };
 732
 733 struct sctp_auth_chunk {
 734         struct sctp_chunkhdr chunk_hdr;
 735         struct sctp_authhdr auth_hdr;
 736 };
 737
 738 struct sctp_infox {
 739         struct sctp_info *sctpinfo;
 740         struct sctp_association *asoc;
 741 };
 742
 743 struct sctp_reconf_chunk {
 744         struct sctp_chunkhdr chunk_hdr;
 745         __u8 params[];
 746 };
 747
 748 struct 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
 756 struct sctp_strreset_inreq {
 757         struct sctp_paramhdr param_hdr;
 758         __be32 request_seq;
 759         __be16 list_of_streams[];
 760 };
 761
 762 struct sctp_strreset_tsnreq {
 763         struct sctp_paramhdr param_hdr;
 764         __be32 request_seq;
 765 };
 766
 767 struct sctp_strreset_addstrm {
 768         struct sctp_paramhdr param_hdr;
 769         __be32 request_seq;
 770         __be16 number_of_streams;
 771         __be16 reserved;
 772 };
 773
 774 enum {
 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
 784 struct sctp_strreset_resp {
 785         struct sctp_paramhdr param_hdr;
 786         __be32 response_seq;
 787         __be32 result;
 788 };
 789
 790 struct 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
 798 enum {
 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  */
 818 struct sctp_new_encap_port_hdr {
 819         __be16 cur_port;
 820         __be16 new_port;
 821 };
 822
 823 #endif /* __LINUX_SCTP_H__ */