LCOV - code coverage report
Current view: top level - include/linux - sctp.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 0 2 0.0 %
Date: 2021-04-22 12:43:58 Functions: 0 0 -

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

Generated by: LCOV version 1.14