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 sctp_hdr(const struct sk_buff * skb)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 /* Round an int up to the next multiple of 4. */ 824 #define SCTP_PAD4(s) (((s)+3)&~3) 825 /* Truncate to the previous multiple of 4. */ 826 #define SCTP_TRUNC4(s) ((s)&~3) 827 828 #endif /* __LINUX_SCTP_H__ */ 829