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