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