1/* SCTP kernel 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) 2002 Intel Corp. 6 * 7 * This file is part of the SCTP kernel implementation 8 * 9 * This header represents the structures and constants needed to support 10 * the SCTP Extension to the Sockets API. 11 * 12 * This SCTP implementation is free software; 13 * you can redistribute it and/or modify it under the terms of 14 * the GNU General Public License as published by 15 * the Free Software Foundation; either version 2, or (at your option) 16 * any later version. 17 * 18 * This SCTP implementation is distributed in the hope that it 19 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 20 * ************************ 21 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 22 * See the GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with GNU CC; see the file COPYING. If not, write to 26 * the Free Software Foundation, 59 Temple Place - Suite 330, 27 * Boston, MA 02111-1307, USA. 28 * 29 * Please send any bug reports or fixes you make to the 30 * email address(es): 31 * lksctp developers <lksctp-developers@lists.sourceforge.net> 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 * R. Stewart <randall@sctp.chicago.il.us> 39 * K. Morneau <kmorneau@cisco.com> 40 * Q. Xie <qxie1@email.mot.com> 41 * Karl Knutson <karl@athena.chicago.il.us> 42 * Jon Grimm <jgrimm@us.ibm.com> 43 * Daisy Chang <daisyc@us.ibm.com> 44 * Ryan Layer <rmlayer@us.ibm.com> 45 * Ardelle Fan <ardelle.fan@intel.com> 46 * Sridhar Samudrala <sri@us.ibm.com> 47 * 48 * Any bugs reported given to us we will try to fix... any fixes shared will 49 * be incorporated into the next SCTP release. 50 */ 51 52#ifndef __net_sctp_user_h__ 53#define __net_sctp_user_h__ 54 55#include <linux/types.h> 56#include <linux/socket.h> 57 58typedef __s32 sctp_assoc_t; 59 60/* The following symbols come from the Sockets API Extensions for 61 * SCTP <draft-ietf-tsvwg-sctpsocket-07.txt>. 62 */ 63#define SCTP_RTOINFO 0 64#define SCTP_ASSOCINFO 1 65#define SCTP_INITMSG 2 66#define SCTP_NODELAY 3 /* Get/set nodelay option. */ 67#define SCTP_AUTOCLOSE 4 68#define SCTP_SET_PEER_PRIMARY_ADDR 5 69#define SCTP_PRIMARY_ADDR 6 70#define SCTP_ADAPTATION_LAYER 7 71#define SCTP_DISABLE_FRAGMENTS 8 72#define SCTP_PEER_ADDR_PARAMS 9 73#define SCTP_DEFAULT_SEND_PARAM 10 74#define SCTP_EVENTS 11 75#define SCTP_I_WANT_MAPPED_V4_ADDR 12 /* Turn on/off mapped v4 addresses */ 76#define SCTP_MAXSEG 13 /* Get/set maximum fragment. */ 77#define SCTP_STATUS 14 78#define SCTP_GET_PEER_ADDR_INFO 15 79#define SCTP_DELAYED_ACK_TIME 16 80#define SCTP_DELAYED_ACK SCTP_DELAYED_ACK_TIME 81#define SCTP_CONTEXT 17 82#define SCTP_FRAGMENT_INTERLEAVE 18 83#define SCTP_PARTIAL_DELIVERY_POINT 19 /* Set/Get partial delivery point */ 84#define SCTP_MAX_BURST 20 /* Set/Get max burst */ 85#define SCTP_AUTH_CHUNK 21 /* Set only: add a chunk type to authenticate */ 86#define SCTP_HMAC_IDENT 22 87#define SCTP_AUTH_KEY 23 88#define SCTP_AUTH_ACTIVE_KEY 24 89#define SCTP_AUTH_DELETE_KEY 25 90#define SCTP_PEER_AUTH_CHUNKS 26 /* Read only */ 91#define SCTP_LOCAL_AUTH_CHUNKS 27 /* Read only */ 92#define SCTP_GET_ASSOC_NUMBER 28 /* Read only */ 93 94/* Internal Socket Options. Some of the sctp library functions are 95 * implemented using these socket options. 96 */ 97#define SCTP_SOCKOPT_BINDX_ADD 100 /* BINDX requests for adding addrs */ 98#define SCTP_SOCKOPT_BINDX_REM 101 /* BINDX requests for removing addrs. */ 99#define SCTP_SOCKOPT_PEELOFF 102 /* peel off association. */ 100/* Options 104-106 are deprecated and removed. Do not use this space */ 101#define SCTP_SOCKOPT_CONNECTX_OLD 107 /* CONNECTX old requests. */ 102#define SCTP_GET_PEER_ADDRS 108 /* Get all peer addresss. */ 103#define SCTP_GET_LOCAL_ADDRS 109 /* Get all local addresss. */ 104#define SCTP_SOCKOPT_CONNECTX 110 /* CONNECTX requests. */ 105#define SCTP_SOCKOPT_CONNECTX3 111 /* CONNECTX requests (updated) */ 106 107/* 108 * 5.2.1 SCTP Initiation Structure (SCTP_INIT) 109 * 110 * This cmsghdr structure provides information for initializing new 111 * SCTP associations with sendmsg(). The SCTP_INITMSG socket option 112 * uses this same data structure. This structure is not used for 113 * recvmsg(). 114 * 115 * cmsg_level cmsg_type cmsg_data[] 116 * ------------ ------------ ---------------------- 117 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg 118 * 119 */ 120struct sctp_initmsg { 121 __u16 sinit_num_ostreams; 122 __u16 sinit_max_instreams; 123 __u16 sinit_max_attempts; 124 __u16 sinit_max_init_timeo; 125}; 126 127/* 128 * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV) 129 * 130 * This cmsghdr structure specifies SCTP options for sendmsg() and 131 * describes SCTP header information about a received message through 132 * recvmsg(). 133 * 134 * cmsg_level cmsg_type cmsg_data[] 135 * ------------ ------------ ---------------------- 136 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo 137 * 138 */ 139struct sctp_sndrcvinfo { 140 __u16 sinfo_stream; 141 __u16 sinfo_ssn; 142 __u16 sinfo_flags; 143 __u32 sinfo_ppid; 144 __u32 sinfo_context; 145 __u32 sinfo_timetolive; 146 __u32 sinfo_tsn; 147 __u32 sinfo_cumtsn; 148 sctp_assoc_t sinfo_assoc_id; 149}; 150 151/* 152 * sinfo_flags: 16 bits (unsigned integer) 153 * 154 * This field may contain any of the following flags and is composed of 155 * a bitwise OR of these values. 156 */ 157 158enum sctp_sinfo_flags { 159 SCTP_UNORDERED = 1, /* Send/receive message unordered. */ 160 SCTP_ADDR_OVER = 2, /* Override the primary destination. */ 161 SCTP_ABORT=4, /* Send an ABORT message to the peer. */ 162 SCTP_SACK_IMMEDIATELY = 8, /* SACK should be sent without delay */ 163 SCTP_EOF=MSG_FIN, /* Initiate graceful shutdown process. */ 164}; 165 166 167/* These are cmsg_types. */ 168typedef enum sctp_cmsg_type { 169 SCTP_INIT, /* 5.2.1 SCTP Initiation Structure */ 170 SCTP_SNDRCV, /* 5.2.2 SCTP Header Information Structure */ 171} sctp_cmsg_t; 172 173 174/* 175 * 5.3.1.1 SCTP_ASSOC_CHANGE 176 * 177 * Communication notifications inform the ULP that an SCTP association 178 * has either begun or ended. The identifier for a new association is 179 * provided by this notificaion. The notification information has the 180 * following format: 181 * 182 */ 183struct sctp_assoc_change { 184 __u16 sac_type; 185 __u16 sac_flags; 186 __u32 sac_length; 187 __u16 sac_state; 188 __u16 sac_error; 189 __u16 sac_outbound_streams; 190 __u16 sac_inbound_streams; 191 sctp_assoc_t sac_assoc_id; 192 __u8 sac_info[0]; 193}; 194 195/* 196 * sac_state: 32 bits (signed integer) 197 * 198 * This field holds one of a number of values that communicate the 199 * event that happened to the association. They include: 200 * 201 * Note: The following state names deviate from the API draft as 202 * the names clash too easily with other kernel symbols. 203 */ 204enum sctp_sac_state { 205 SCTP_COMM_UP, 206 SCTP_COMM_LOST, 207 SCTP_RESTART, 208 SCTP_SHUTDOWN_COMP, 209 SCTP_CANT_STR_ASSOC, 210}; 211 212/* 213 * 5.3.1.2 SCTP_PEER_ADDR_CHANGE 214 * 215 * When a destination address on a multi-homed peer encounters a change 216 * an interface details event is sent. The information has the 217 * following structure: 218 */ 219struct sctp_paddr_change { 220 __u16 spc_type; 221 __u16 spc_flags; 222 __u32 spc_length; 223 struct sockaddr_storage spc_aaddr; 224 int spc_state; 225 int spc_error; 226 sctp_assoc_t spc_assoc_id; 227} __attribute__((packed, aligned(4))); 228 229/* 230 * spc_state: 32 bits (signed integer) 231 * 232 * This field holds one of a number of values that communicate the 233 * event that happened to the address. They include: 234 */ 235enum sctp_spc_state { 236 SCTP_ADDR_AVAILABLE, 237 SCTP_ADDR_UNREACHABLE, 238 SCTP_ADDR_REMOVED, 239 SCTP_ADDR_ADDED, 240 SCTP_ADDR_MADE_PRIM, 241 SCTP_ADDR_CONFIRMED, 242}; 243 244 245/* 246 * 5.3.1.3 SCTP_REMOTE_ERROR 247 * 248 * A remote peer may send an Operational Error message to its peer. 249 * This message indicates a variety of error conditions on an 250 * association. The entire error TLV as it appears on the wire is 251 * included in a SCTP_REMOTE_ERROR event. Please refer to the SCTP 252 * specification [SCTP] and any extensions for a list of possible 253 * error formats. SCTP error TLVs have the format: 254 */ 255struct sctp_remote_error { 256 __u16 sre_type; 257 __u16 sre_flags; 258 __u32 sre_length; 259 __u16 sre_error; 260 sctp_assoc_t sre_assoc_id; 261 __u8 sre_data[0]; 262}; 263 264 265/* 266 * 5.3.1.4 SCTP_SEND_FAILED 267 * 268 * If SCTP cannot deliver a message it may return the message as a 269 * notification. 270 */ 271struct sctp_send_failed { 272 __u16 ssf_type; 273 __u16 ssf_flags; 274 __u32 ssf_length; 275 __u32 ssf_error; 276 struct sctp_sndrcvinfo ssf_info; 277 sctp_assoc_t ssf_assoc_id; 278 __u8 ssf_data[0]; 279}; 280 281/* 282 * ssf_flags: 16 bits (unsigned integer) 283 * 284 * The flag value will take one of the following values 285 * 286 * SCTP_DATA_UNSENT - Indicates that the data was never put on 287 * the wire. 288 * 289 * SCTP_DATA_SENT - Indicates that the data was put on the wire. 290 * Note that this does not necessarily mean that the 291 * data was (or was not) successfully delivered. 292 */ 293enum sctp_ssf_flags { 294 SCTP_DATA_UNSENT, 295 SCTP_DATA_SENT, 296}; 297 298/* 299 * 5.3.1.5 SCTP_SHUTDOWN_EVENT 300 * 301 * When a peer sends a SHUTDOWN, SCTP delivers this notification to 302 * inform the application that it should cease sending data. 303 */ 304struct sctp_shutdown_event { 305 __u16 sse_type; 306 __u16 sse_flags; 307 __u32 sse_length; 308 sctp_assoc_t sse_assoc_id; 309}; 310 311/* 312 * 5.3.1.6 SCTP_ADAPTATION_INDICATION 313 * 314 * When a peer sends a Adaptation Layer Indication parameter , SCTP 315 * delivers this notification to inform the application 316 * that of the peers requested adaptation layer. 317 */ 318struct sctp_adaptation_event { 319 __u16 sai_type; 320 __u16 sai_flags; 321 __u32 sai_length; 322 __u32 sai_adaptation_ind; 323 sctp_assoc_t sai_assoc_id; 324}; 325 326/* 327 * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT 328 * 329 * When a receiver is engaged in a partial delivery of a 330 * message this notification will be used to indicate 331 * various events. 332 */ 333struct sctp_pdapi_event { 334 __u16 pdapi_type; 335 __u16 pdapi_flags; 336 __u32 pdapi_length; 337 __u32 pdapi_indication; 338 sctp_assoc_t pdapi_assoc_id; 339}; 340 341enum { SCTP_PARTIAL_DELIVERY_ABORTED=0, }; 342 343struct sctp_authkey_event { 344 __u16 auth_type; 345 __u16 auth_flags; 346 __u32 auth_length; 347 __u16 auth_keynumber; 348 __u16 auth_altkeynumber; 349 __u32 auth_indication; 350 sctp_assoc_t auth_assoc_id; 351}; 352 353enum { SCTP_AUTH_NEWKEY = 0, }; 354 355 356/* 357 * Described in Section 7.3 358 * Ancillary Data and Notification Interest Options 359 */ 360struct sctp_event_subscribe { 361 __u8 sctp_data_io_event; 362 __u8 sctp_association_event; 363 __u8 sctp_address_event; 364 __u8 sctp_send_failure_event; 365 __u8 sctp_peer_error_event; 366 __u8 sctp_shutdown_event; 367 __u8 sctp_partial_delivery_event; 368 __u8 sctp_adaptation_layer_event; 369 __u8 sctp_authentication_event; 370}; 371 372/* 373 * 5.3.1 SCTP Notification Structure 374 * 375 * The notification structure is defined as the union of all 376 * notification types. 377 * 378 */ 379union sctp_notification { 380 struct { 381 __u16 sn_type; /* Notification type. */ 382 __u16 sn_flags; 383 __u32 sn_length; 384 } sn_header; 385 struct sctp_assoc_change sn_assoc_change; 386 struct sctp_paddr_change sn_paddr_change; 387 struct sctp_remote_error sn_remote_error; 388 struct sctp_send_failed sn_send_failed; 389 struct sctp_shutdown_event sn_shutdown_event; 390 struct sctp_adaptation_event sn_adaptation_event; 391 struct sctp_pdapi_event sn_pdapi_event; 392 struct sctp_authkey_event sn_authkey_event; 393}; 394 395/* Section 5.3.1 396 * All standard values for sn_type flags are greater than 2^15. 397 * Values from 2^15 and down are reserved. 398 */ 399 400enum sctp_sn_type { 401 SCTP_SN_TYPE_BASE = (1<<15), 402 SCTP_ASSOC_CHANGE, 403 SCTP_PEER_ADDR_CHANGE, 404 SCTP_SEND_FAILED, 405 SCTP_REMOTE_ERROR, 406 SCTP_SHUTDOWN_EVENT, 407 SCTP_PARTIAL_DELIVERY_EVENT, 408 SCTP_ADAPTATION_INDICATION, 409 SCTP_AUTHENTICATION_INDICATION, 410}; 411 412/* Notification error codes used to fill up the error fields in some 413 * notifications. 414 * SCTP_PEER_ADDRESS_CHAGE : spc_error 415 * SCTP_ASSOC_CHANGE : sac_error 416 * These names should be potentially included in the draft 04 of the SCTP 417 * sockets API specification. 418 */ 419typedef enum sctp_sn_error { 420 SCTP_FAILED_THRESHOLD, 421 SCTP_RECEIVED_SACK, 422 SCTP_HEARTBEAT_SUCCESS, 423 SCTP_RESPONSE_TO_USER_REQ, 424 SCTP_INTERNAL_ERROR, 425 SCTP_SHUTDOWN_GUARD_EXPIRES, 426 SCTP_PEER_FAULTY, 427} sctp_sn_error_t; 428 429/* 430 * 7.1.1 Retransmission Timeout Parameters (SCTP_RTOINFO) 431 * 432 * The protocol parameters used to initialize and bound retransmission 433 * timeout (RTO) are tunable. See [SCTP] for more information on how 434 * these parameters are used in RTO calculation. 435 */ 436struct sctp_rtoinfo { 437 sctp_assoc_t srto_assoc_id; 438 __u32 srto_initial; 439 __u32 srto_max; 440 __u32 srto_min; 441}; 442 443/* 444 * 7.1.2 Association Parameters (SCTP_ASSOCINFO) 445 * 446 * This option is used to both examine and set various association and 447 * endpoint parameters. 448 */ 449struct sctp_assocparams { 450 sctp_assoc_t sasoc_assoc_id; 451 __u16 sasoc_asocmaxrxt; 452 __u16 sasoc_number_peer_destinations; 453 __u32 sasoc_peer_rwnd; 454 __u32 sasoc_local_rwnd; 455 __u32 sasoc_cookie_life; 456}; 457 458/* 459 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR) 460 * 461 * Requests that the peer mark the enclosed address as the association 462 * primary. The enclosed address must be one of the association's 463 * locally bound addresses. The following structure is used to make a 464 * set primary request: 465 */ 466struct sctp_setpeerprim { 467 sctp_assoc_t sspp_assoc_id; 468 struct sockaddr_storage sspp_addr; 469} __attribute__((packed, aligned(4))); 470 471/* 472 * 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR) 473 * 474 * Requests that the local SCTP stack use the enclosed peer address as 475 * the association primary. The enclosed address must be one of the 476 * association peer's addresses. The following structure is used to 477 * make a set peer primary request: 478 */ 479struct sctp_prim { 480 sctp_assoc_t ssp_assoc_id; 481 struct sockaddr_storage ssp_addr; 482} __attribute__((packed, aligned(4))); 483 484/* 485 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER) 486 * 487 * Requests that the local endpoint set the specified Adaptation Layer 488 * Indication parameter for all future INIT and INIT-ACK exchanges. 489 */ 490struct sctp_setadaptation { 491 __u32 ssb_adaptation_ind; 492}; 493 494/* 495 * 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS) 496 * 497 * Applications can enable or disable heartbeats for any peer address 498 * of an association, modify an address's heartbeat interval, force a 499 * heartbeat to be sent immediately, and adjust the address's maximum 500 * number of retransmissions sent before an address is considered 501 * unreachable. The following structure is used to access and modify an 502 * address's parameters: 503 */ 504enum sctp_spp_flags { 505 SPP_HB_ENABLE = 1<<0, /*Enable heartbeats*/ 506 SPP_HB_DISABLE = 1<<1, /*Disable heartbeats*/ 507 SPP_HB = SPP_HB_ENABLE | SPP_HB_DISABLE, 508 SPP_HB_DEMAND = 1<<2, /*Send heartbeat immediately*/ 509 SPP_PMTUD_ENABLE = 1<<3, /*Enable PMTU discovery*/ 510 SPP_PMTUD_DISABLE = 1<<4, /*Disable PMTU discovery*/ 511 SPP_PMTUD = SPP_PMTUD_ENABLE | SPP_PMTUD_DISABLE, 512 SPP_SACKDELAY_ENABLE = 1<<5, /*Enable SACK*/ 513 SPP_SACKDELAY_DISABLE = 1<<6, /*Disable SACK*/ 514 SPP_SACKDELAY = SPP_SACKDELAY_ENABLE | SPP_SACKDELAY_DISABLE, 515 SPP_HB_TIME_IS_ZERO = 1<<7, /* Set HB delay to 0 */ 516}; 517 518struct sctp_paddrparams { 519 sctp_assoc_t spp_assoc_id; 520 struct sockaddr_storage spp_address; 521 __u32 spp_hbinterval; 522 __u16 spp_pathmaxrxt; 523 __u32 spp_pathmtu; 524 __u32 spp_sackdelay; 525 __u32 spp_flags; 526} __attribute__((packed, aligned(4))); 527 528/* 529 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK) 530 * 531 * This set option adds a chunk type that the user is requesting to be 532 * received only in an authenticated way. Changes to the list of chunks 533 * will only effect future associations on the socket. 534 */ 535struct sctp_authchunk { 536 __u8 sauth_chunk; 537}; 538 539/* 540 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT) 541 * 542 * This option gets or sets the list of HMAC algorithms that the local 543 * endpoint requires the peer to use. 544*/ 545struct sctp_hmacalgo { 546 __u32 shmac_num_idents; 547 __u16 shmac_idents[]; 548}; 549 550/* 551 * 7.1.20. Set a shared key (SCTP_AUTH_KEY) 552 * 553 * This option will set a shared secret key which is used to build an 554 * association shared key. 555 */ 556struct sctp_authkey { 557 sctp_assoc_t sca_assoc_id; 558 __u16 sca_keynumber; 559 __u16 sca_keylength; 560 __u8 sca_key[]; 561}; 562 563/* 564 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY) 565 * 566 * This option will get or set the active shared key to be used to build 567 * the association shared key. 568 */ 569 570struct sctp_authkeyid { 571 sctp_assoc_t scact_assoc_id; 572 __u16 scact_keynumber; 573}; 574 575 576/* 577 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK) 578 * 579 * This option will effect the way delayed acks are performed. This 580 * option allows you to get or set the delayed ack time, in 581 * milliseconds. It also allows changing the delayed ack frequency. 582 * Changing the frequency to 1 disables the delayed sack algorithm. If 583 * the assoc_id is 0, then this sets or gets the endpoints default 584 * values. If the assoc_id field is non-zero, then the set or get 585 * effects the specified association for the one to many model (the 586 * assoc_id field is ignored by the one to one model). Note that if 587 * sack_delay or sack_freq are 0 when setting this option, then the 588 * current values will remain unchanged. 589 */ 590struct sctp_sack_info { 591 sctp_assoc_t sack_assoc_id; 592 uint32_t sack_delay; 593 uint32_t sack_freq; 594}; 595 596struct sctp_assoc_value { 597 sctp_assoc_t assoc_id; 598 uint32_t assoc_value; 599}; 600 601/* 602 * 7.2.2 Peer Address Information 603 * 604 * Applications can retrieve information about a specific peer address 605 * of an association, including its reachability state, congestion 606 * window, and retransmission timer values. This information is 607 * read-only. The following structure is used to access this 608 * information: 609 */ 610struct sctp_paddrinfo { 611 sctp_assoc_t spinfo_assoc_id; 612 struct sockaddr_storage spinfo_address; 613 __s32 spinfo_state; 614 __u32 spinfo_cwnd; 615 __u32 spinfo_srtt; 616 __u32 spinfo_rto; 617 __u32 spinfo_mtu; 618} __attribute__((packed, aligned(4))); 619 620/* Peer addresses's state. */ 621/* UNKNOWN: Peer address passed by the upper layer in sendmsg or connect[x] 622 * calls. 623 * UNCONFIRMED: Peer address received in INIT/INIT-ACK address parameters. 624 * Not yet confirmed by a heartbeat and not available for data 625 * transfers. 626 * ACTIVE : Peer address confirmed, active and available for data transfers. 627 * INACTIVE: Peer address inactive and not available for data transfers. 628 */ 629enum sctp_spinfo_state { 630 SCTP_INACTIVE, 631 SCTP_ACTIVE, 632 SCTP_UNCONFIRMED, 633 SCTP_UNKNOWN = 0xffff /* Value used for transport state unknown */ 634}; 635 636/* 637 * 7.2.1 Association Status (SCTP_STATUS) 638 * 639 * Applications can retrieve current status information about an 640 * association, including association state, peer receiver window size, 641 * number of unacked data chunks, and number of data chunks pending 642 * receipt. This information is read-only. The following structure is 643 * used to access this information: 644 */ 645struct sctp_status { 646 sctp_assoc_t sstat_assoc_id; 647 __s32 sstat_state; 648 __u32 sstat_rwnd; 649 __u16 sstat_unackdata; 650 __u16 sstat_penddata; 651 __u16 sstat_instrms; 652 __u16 sstat_outstrms; 653 __u32 sstat_fragmentation_point; 654 struct sctp_paddrinfo sstat_primary; 655}; 656 657/* 658 * 7.2.3. Get the list of chunks the peer requires to be authenticated 659 * (SCTP_PEER_AUTH_CHUNKS) 660 * 661 * This option gets a list of chunks for a specified association that 662 * the peer requires to be received authenticated only. 663 */ 664struct sctp_authchunks { 665 sctp_assoc_t gauth_assoc_id; 666 __u32 gauth_number_of_chunks; 667 uint8_t gauth_chunks[]; 668}; 669 670/* 671 * 8.3, 8.5 get all peer/local addresses in an association. 672 * This parameter struct is used by SCTP_GET_PEER_ADDRS and 673 * SCTP_GET_LOCAL_ADDRS socket options used internally to implement 674 * sctp_getpaddrs() and sctp_getladdrs() API. 675 */ 676struct sctp_getaddrs_old { 677 sctp_assoc_t assoc_id; 678 int addr_num; 679 struct sockaddr __user *addrs; 680}; 681struct sctp_getaddrs { 682 sctp_assoc_t assoc_id; /*input*/ 683 __u32 addr_num; /*output*/ 684 __u8 addrs[0]; /*output, variable size*/ 685}; 686 687/* These are bit fields for msghdr->msg_flags. See section 5.1. */ 688/* On user space Linux, these live in <bits/socket.h> as an enum. */ 689enum sctp_msg_flags { 690 MSG_NOTIFICATION = 0x8000, 691#define MSG_NOTIFICATION MSG_NOTIFICATION 692}; 693 694/* 695 * 8.1 sctp_bindx() 696 * 697 * The flags parameter is formed from the bitwise OR of zero or more of the 698 * following currently defined flags: 699 */ 700#define SCTP_BINDX_ADD_ADDR 0x01 701#define SCTP_BINDX_REM_ADDR 0x02 702 703/* This is the structure that is passed as an argument(optval) to 704 * getsockopt(SCTP_SOCKOPT_PEELOFF). 705 */ 706typedef struct { 707 sctp_assoc_t associd; 708 int sd; 709} sctp_peeloff_arg_t; 710 711#endif /* __net_sctp_user_h__ */ 712