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