home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / net / sctp / user.h < prev   
Encoding:
C/C++ Source or Header  |  2006-08-11  |  18.4 KB  |  632 lines

  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) 2002 Intel Corp.
  6.  *
  7.  * This file is part of the SCTP kernel reference Implementation
  8.  *
  9.  * This header represents the structures and constants needed to support
  10.  * the SCTP Extension to the Sockets API.
  11.  *
  12.  * The SCTP reference 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.  * The SCTP reference 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_ADAPTION_LAYER,      
  79. #define SCTP_ADAPTION_LAYER SCTP_ADAPTION_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_TIME,
  97. #define SCTP_DELAYED_ACK_TIME SCTP_DELAYED_ACK_TIME
  98.  
  99.     /* Internal Socket Options. Some of the sctp library functions are 
  100.      * implemented using these socket options.
  101.      */
  102.     SCTP_SOCKOPT_BINDX_ADD = 100,/* BINDX requests for adding addresses. */
  103. #define SCTP_SOCKOPT_BINDX_ADD    SCTP_SOCKOPT_BINDX_ADD
  104.     SCTP_SOCKOPT_BINDX_REM, /* BINDX requests for removing addresses. */
  105. #define SCTP_SOCKOPT_BINDX_REM    SCTP_SOCKOPT_BINDX_REM
  106.     SCTP_SOCKOPT_PEELOFF,     /* peel off association. */
  107. #define SCTP_SOCKOPT_PEELOFF    SCTP_SOCKOPT_PEELOFF
  108.     SCTP_GET_PEER_ADDRS_NUM_OLD,     /* Get number of peer addresss. */
  109. #define SCTP_GET_PEER_ADDRS_NUM_OLD    SCTP_GET_PEER_ADDRS_NUM_OLD
  110.     SCTP_GET_PEER_ADDRS_OLD,     /* Get all peer addresss. */
  111. #define SCTP_GET_PEER_ADDRS_OLD    SCTP_GET_PEER_ADDRS_OLD
  112.     SCTP_GET_LOCAL_ADDRS_NUM_OLD,     /* Get number of local addresss. */
  113. #define SCTP_GET_LOCAL_ADDRS_NUM_OLD    SCTP_GET_LOCAL_ADDRS_NUM_OLD
  114.     SCTP_GET_LOCAL_ADDRS_OLD,     /* Get all local addresss. */
  115. #define SCTP_GET_LOCAL_ADDRS_OLD    SCTP_GET_LOCAL_ADDRS_OLD
  116.     SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
  117. #define SCTP_SOCKOPT_CONNECTX    SCTP_SOCKOPT_CONNECTX
  118.     SCTP_GET_PEER_ADDRS,     /* Get all peer addresss. */
  119. #define SCTP_GET_PEER_ADDRS    SCTP_GET_PEER_ADDRS
  120.     SCTP_GET_LOCAL_ADDRS,     /* Get all local addresss. */
  121. #define SCTP_GET_LOCAL_ADDRS    SCTP_GET_LOCAL_ADDRS
  122. };
  123.  
  124. /*
  125.  * 5.2.1 SCTP Initiation Structure (SCTP_INIT)
  126.  *
  127.  *   This cmsghdr structure provides information for initializing new
  128.  *   SCTP associations with sendmsg().  The SCTP_INITMSG socket option
  129.  *   uses this same data structure.  This structure is not used for
  130.  *   recvmsg().
  131.  *
  132.  *   cmsg_level    cmsg_type      cmsg_data[]
  133.  *   ------------  ------------   ----------------------
  134.  *   IPPROTO_SCTP  SCTP_INIT      struct sctp_initmsg
  135.  *
  136.  */
  137. struct sctp_initmsg {
  138.     __u16 sinit_num_ostreams;
  139.     __u16 sinit_max_instreams;
  140.     __u16 sinit_max_attempts;
  141.     __u16 sinit_max_init_timeo;
  142. };
  143.  
  144. /*
  145.  * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
  146.  *
  147.  *   This cmsghdr structure specifies SCTP options for sendmsg() and
  148.  *   describes SCTP header information about a received message through
  149.  *   recvmsg().
  150.  *
  151.  *   cmsg_level    cmsg_type      cmsg_data[]
  152.  *   ------------  ------------   ----------------------
  153.  *   IPPROTO_SCTP  SCTP_SNDRCV    struct sctp_sndrcvinfo
  154.  *
  155.  */
  156. struct sctp_sndrcvinfo {
  157.     __u16 sinfo_stream;
  158.     __u16 sinfo_ssn;
  159.     __u16 sinfo_flags;
  160.     __u32 sinfo_ppid;
  161.     __u32 sinfo_context;
  162.     __u32 sinfo_timetolive;
  163.     __u32 sinfo_tsn;
  164.     __u32 sinfo_cumtsn;
  165.     sctp_assoc_t sinfo_assoc_id;
  166. };
  167.  
  168. /*
  169.  *  sinfo_flags: 16 bits (unsigned integer)
  170.  *
  171.  *   This field may contain any of the following flags and is composed of
  172.  *   a bitwise OR of these values.
  173.  */
  174.  
  175. enum sctp_sinfo_flags {
  176.     SCTP_UNORDERED = 1,  /* Send/receive message unordered. */
  177.     SCTP_ADDR_OVER = 2,  /* Override the primary destination. */
  178.     SCTP_ABORT=4,        /* Send an ABORT message to the peer. */
  179.     SCTP_EOF=MSG_FIN,    /* Initiate graceful shutdown process. */    
  180. };
  181.  
  182.  
  183. typedef union {
  184.     __u8               raw;
  185.     struct sctp_initmsg    init;
  186.     struct sctp_sndrcvinfo    sndrcv;
  187. } sctp_cmsg_data_t;
  188.  
  189. /* These are cmsg_types.  */
  190. typedef enum sctp_cmsg_type {
  191.     SCTP_INIT,              /* 5.2.1 SCTP Initiation Structure */
  192.     SCTP_SNDRCV,            /* 5.2.2 SCTP Header Information Structure */
  193. } sctp_cmsg_t;
  194.  
  195.  
  196. /*
  197.  * 5.3.1.1 SCTP_ASSOC_CHANGE
  198.  *
  199.  *   Communication notifications inform the ULP that an SCTP association
  200.  *   has either begun or ended. The identifier for a new association is
  201.  *   provided by this notificaion. The notification information has the
  202.  *   following format:
  203.  *
  204.  */
  205. struct sctp_assoc_change {
  206.     __u16 sac_type;
  207.     __u16 sac_flags;
  208.     __u32 sac_length;
  209.     __u16 sac_state;
  210.     __u16 sac_error;
  211.     __u16 sac_outbound_streams;
  212.     __u16 sac_inbound_streams;
  213.     sctp_assoc_t sac_assoc_id;
  214. };
  215.  
  216. /*
  217.  *   sac_state: 32 bits (signed integer)
  218.  *
  219.  *   This field holds one of a number of values that communicate the
  220.  *   event that happened to the association.  They include:
  221.  *
  222.  *   Note:  The following state names deviate from the API draft as
  223.  *   the names clash too easily with other kernel symbols.
  224.  */
  225. enum sctp_sac_state {
  226.     SCTP_COMM_UP,
  227.     SCTP_COMM_LOST,
  228.     SCTP_RESTART,
  229.     SCTP_SHUTDOWN_COMP,
  230.     SCTP_CANT_STR_ASSOC,
  231. };
  232.  
  233. /*
  234.  * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
  235.  *
  236.  *   When a destination address on a multi-homed peer encounters a change
  237.  *   an interface details event is sent.  The information has the
  238.  *   following structure:
  239.  */
  240. struct sctp_paddr_change {
  241.     __u16 spc_type;
  242.     __u16 spc_flags;
  243.     __u32 spc_length;
  244.     struct sockaddr_storage spc_aaddr;
  245.     int spc_state;
  246.     int spc_error;
  247.     sctp_assoc_t spc_assoc_id;
  248. } __attribute__((packed, aligned(4)));
  249.  
  250. /*
  251.  *    spc_state:  32 bits (signed integer)
  252.  *
  253.  *   This field holds one of a number of values that communicate the
  254.  *   event that happened to the address.  They include:
  255.  */
  256. enum sctp_spc_state {
  257.     SCTP_ADDR_AVAILABLE,
  258.     SCTP_ADDR_UNREACHABLE,
  259.     SCTP_ADDR_REMOVED,
  260.     SCTP_ADDR_ADDED,
  261.     SCTP_ADDR_MADE_PRIM,
  262. };
  263.  
  264.  
  265. /*
  266.  * 5.3.1.3 SCTP_REMOTE_ERROR
  267.  *
  268.  *   A remote peer may send an Operational Error message to its peer.
  269.  *   This message indicates a variety of error conditions on an
  270.  *   association. The entire error TLV as it appears on the wire is
  271.  *   included in a SCTP_REMOTE_ERROR event.  Please refer to the SCTP
  272.  *   specification [SCTP] and any extensions for a list of possible
  273.  *   error formats. SCTP error TLVs have the format:
  274.  */
  275. struct sctp_remote_error {
  276.     __u16 sre_type;
  277.     __u16 sre_flags;
  278.     __u32 sre_length;
  279.     __u16 sre_error;
  280.     sctp_assoc_t sre_assoc_id;
  281.     __u8 sre_data[0];
  282. };
  283.  
  284.  
  285. /*
  286.  * 5.3.1.4 SCTP_SEND_FAILED
  287.  *
  288.  *   If SCTP cannot deliver a message it may return the message as a
  289.  *   notification.
  290.  */
  291. struct sctp_send_failed {
  292.     __u16 ssf_type;
  293.     __u16 ssf_flags;
  294.     __u32 ssf_length;
  295.     __u32 ssf_error;
  296.     struct sctp_sndrcvinfo ssf_info;
  297.     sctp_assoc_t ssf_assoc_id;
  298.     __u8 ssf_data[0];
  299. };
  300.  
  301. /*
  302.  *   ssf_flags: 16 bits (unsigned integer)
  303.  *
  304.  *   The flag value will take one of the following values
  305.  *
  306.  *   SCTP_DATA_UNSENT  - Indicates that the data was never put on
  307.  *                       the wire.
  308.  *
  309.  *   SCTP_DATA_SENT    - Indicates that the data was put on the wire.
  310.  *                       Note that this does not necessarily mean that the
  311.  *                       data was (or was not) successfully delivered.
  312.  */
  313. enum sctp_ssf_flags {
  314.     SCTP_DATA_UNSENT,
  315.     SCTP_DATA_SENT,
  316. };
  317.  
  318. /*
  319.  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
  320.  *
  321.  *   When a peer sends a SHUTDOWN, SCTP delivers this notification to
  322.  *   inform the application that it should cease sending data.
  323.  */
  324. struct sctp_shutdown_event {
  325.     __u16 sse_type;
  326.     __u16 sse_flags;
  327.     __u32 sse_length;
  328.     sctp_assoc_t sse_assoc_id;
  329. };
  330.  
  331. /*
  332.  * 5.3.1.6 SCTP_ADAPTION_INDICATION
  333.  *
  334.  *   When a peer sends a Adaption Layer Indication parameter , SCTP
  335.  *   delivers this notification to inform the application
  336.  *   that of the peers requested adaption layer.
  337.  */
  338. struct sctp_adaption_event {
  339.     __u16 sai_type;
  340.     __u16 sai_flags;
  341.     __u32 sai_length;
  342.     __u32 sai_adaption_ind;
  343.     sctp_assoc_t sai_assoc_id;
  344. };
  345.  
  346. /*
  347.  * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
  348.  *
  349.  *   When a receiver is engaged in a partial delivery of a
  350.  *   message this notification will be used to indicate
  351.  *   various events.
  352.  */
  353. struct sctp_pdapi_event {
  354.     __u16 pdapi_type;
  355.     __u16 pdapi_flags;
  356.     __u32 pdapi_length;
  357.     __u32 pdapi_indication;
  358.     sctp_assoc_t pdapi_assoc_id;
  359. };
  360.  
  361. enum { SCTP_PARTIAL_DELIVERY_ABORTED=0, };
  362.  
  363. /*
  364.  * Described in Section 7.3
  365.  *   Ancillary Data and Notification Interest Options
  366.  */
  367. struct sctp_event_subscribe {
  368.     __u8 sctp_data_io_event;
  369.     __u8 sctp_association_event;
  370.     __u8 sctp_address_event;
  371.     __u8 sctp_send_failure_event;
  372.     __u8 sctp_peer_error_event;
  373.     __u8 sctp_shutdown_event;
  374.     __u8 sctp_partial_delivery_event;
  375.     __u8 sctp_adaption_layer_event;
  376. };
  377.  
  378. /*
  379.  * 5.3.1 SCTP Notification Structure
  380.  *
  381.  *   The notification structure is defined as the union of all
  382.  *   notification types.
  383.  *
  384.  */
  385. union sctp_notification {
  386.     struct {
  387.         __u16 sn_type;             /* Notification type. */
  388.         __u16 sn_flags;
  389.         __u32 sn_length;
  390.     } sn_header;
  391.     struct sctp_assoc_change sn_assoc_change;
  392.     struct sctp_paddr_change sn_paddr_change;
  393.     struct sctp_remote_error sn_remote_error;
  394.     struct sctp_send_failed sn_send_failed;
  395.     struct sctp_shutdown_event sn_shutdown_event;
  396.     struct sctp_adaption_event sn_adaption_event;
  397.     struct sctp_pdapi_event sn_pdapi_event;
  398. };
  399.  
  400. /* Section 5.3.1
  401.  * All standard values for sn_type flags are greater than 2^15.
  402.  * Values from 2^15 and down are reserved.
  403.  */
  404.  
  405. enum sctp_sn_type {
  406.     SCTP_SN_TYPE_BASE     = (1<<15),
  407.     SCTP_ASSOC_CHANGE,
  408.     SCTP_PEER_ADDR_CHANGE,
  409.     SCTP_SEND_FAILED,
  410.     SCTP_REMOTE_ERROR,
  411.     SCTP_SHUTDOWN_EVENT,
  412.     SCTP_PARTIAL_DELIVERY_EVENT,
  413.     SCTP_ADAPTION_INDICATION,
  414. };
  415.  
  416. /* Notification error codes used to fill up the error fields in some
  417.  * notifications.
  418.  * SCTP_PEER_ADDRESS_CHAGE     : spc_error
  419.  * SCTP_ASSOC_CHANGE        : sac_error
  420.  * These names should be potentially included in the draft 04 of the SCTP
  421.  * sockets API specification.
  422.  */
  423. typedef enum sctp_sn_error {
  424.     SCTP_FAILED_THRESHOLD,
  425.     SCTP_RECEIVED_SACK,
  426.     SCTP_HEARTBEAT_SUCCESS,
  427.     SCTP_RESPONSE_TO_USER_REQ,
  428.     SCTP_INTERNAL_ERROR,
  429.     SCTP_SHUTDOWN_GUARD_EXPIRES,
  430.     SCTP_PEER_FAULTY,
  431. } sctp_sn_error_t;
  432.  
  433. /*
  434.  * 7.1.1 Retransmission Timeout Parameters (SCTP_RTOINFO)
  435.  *
  436.  *   The protocol parameters used to initialize and bound retransmission
  437.  *   timeout (RTO) are tunable.  See [SCTP] for more information on how
  438.  *   these parameters are used in RTO calculation. 
  439.  */
  440. struct sctp_rtoinfo {
  441.     sctp_assoc_t    srto_assoc_id;
  442.     __u32        srto_initial;
  443.     __u32        srto_max;
  444.     __u32        srto_min;
  445. };
  446.  
  447. /*
  448.  * 7.1.2 Association Parameters (SCTP_ASSOCINFO)
  449.  *
  450.  *   This option is used to both examine and set various association and
  451.  *   endpoint parameters.
  452.  */
  453. struct sctp_assocparams {
  454.     sctp_assoc_t    sasoc_assoc_id;
  455.     __u16        sasoc_asocmaxrxt;
  456.     __u16        sasoc_number_peer_destinations;
  457.     __u32        sasoc_peer_rwnd;
  458.     __u32        sasoc_local_rwnd;
  459.     __u32        sasoc_cookie_life;
  460. };
  461.  
  462. /*
  463.  * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
  464.  *
  465.  *  Requests that the peer mark the enclosed address as the association
  466.  *  primary. The enclosed address must be one of the association's
  467.  *  locally bound addresses. The following structure is used to make a
  468.  *   set primary request:
  469.  */
  470. struct sctp_setpeerprim {
  471.     sctp_assoc_t            sspp_assoc_id;
  472.     struct sockaddr_storage sspp_addr;
  473. } __attribute__((packed, aligned(4)));
  474.  
  475. /*
  476.  * 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
  477.  *
  478.  *  Requests that the local SCTP stack use the enclosed peer address as
  479.  *  the association primary. The enclosed address must be one of the
  480.  *  association peer's addresses. The following structure is used to
  481.  *  make a set peer primary request:
  482.  */
  483. struct sctp_prim {
  484.     sctp_assoc_t            ssp_assoc_id;
  485.     struct sockaddr_storage ssp_addr;
  486. } __attribute__((packed, aligned(4)));
  487.  
  488. /*
  489.  * 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)
  490.  *
  491.  * Requests that the local endpoint set the specified Adaption Layer
  492.  * Indication parameter for all future INIT and INIT-ACK exchanges.
  493.  */
  494. struct sctp_setadaption {
  495.     __u32    ssb_adaption_ind;
  496. };
  497.  
  498. /*
  499.  * 7.1.13 Peer Address Parameters  (SCTP_PEER_ADDR_PARAMS)
  500.  *
  501.  *   Applications can enable or disable heartbeats for any peer address
  502.  *   of an association, modify an address's heartbeat interval, force a
  503.  *   heartbeat to be sent immediately, and adjust the address's maximum
  504.  *   number of retransmissions sent before an address is considered
  505.  *   unreachable. The following structure is used to access and modify an
  506.  *   address's parameters:
  507.  */
  508. enum  sctp_spp_flags {
  509.     SPP_HB_ENABLE = 1,        /*Enable heartbeats*/
  510.     SPP_HB_DISABLE = 2,        /*Disable heartbeats*/
  511.     SPP_HB = SPP_HB_ENABLE | SPP_HB_DISABLE,
  512.     SPP_HB_DEMAND = 4,        /*Send heartbeat immediately*/
  513.     SPP_PMTUD_ENABLE = 8,        /*Enable PMTU discovery*/
  514.     SPP_PMTUD_DISABLE = 16,        /*Disable PMTU discovery*/
  515.     SPP_PMTUD = SPP_PMTUD_ENABLE | SPP_PMTUD_DISABLE,
  516.     SPP_SACKDELAY_ENABLE = 32,    /*Enable SACK*/
  517.     SPP_SACKDELAY_DISABLE = 64,    /*Disable SACK*/
  518.     SPP_SACKDELAY = SPP_SACKDELAY_ENABLE | SPP_SACKDELAY_DISABLE,
  519. };
  520.  
  521. struct sctp_paddrparams {
  522.     sctp_assoc_t        spp_assoc_id;
  523.     struct sockaddr_storage    spp_address;
  524.     __u32            spp_hbinterval;
  525.     __u16            spp_pathmaxrxt;
  526.     __u32            spp_pathmtu;
  527.     __u32            spp_sackdelay;
  528.     __u32            spp_flags;
  529. } __attribute__((packed, aligned(4)));
  530.  
  531. /* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)
  532.  *
  533.  *   This options will get or set the delayed ack timer.  The time is set
  534.  *   in milliseconds.  If the assoc_id is 0, then this sets or gets the
  535.  *   endpoints default delayed ack timer value.  If the assoc_id field is
  536.  *   non-zero, then the set or get effects the specified association.
  537.  */
  538. struct sctp_assoc_value {
  539.     sctp_assoc_t            assoc_id;
  540.     uint32_t                assoc_value;
  541. };
  542.  
  543. /*
  544.  * 7.2.2 Peer Address Information
  545.  *
  546.  *   Applications can retrieve information about a specific peer address
  547.  *   of an association, including its reachability state, congestion
  548.  *   window, and retransmission timer values.  This information is
  549.  *   read-only. The following structure is used to access this
  550.  *   information:
  551.  */
  552. struct sctp_paddrinfo {
  553.     sctp_assoc_t        spinfo_assoc_id;
  554.     struct sockaddr_storage    spinfo_address;
  555.     __s32            spinfo_state;
  556.     __u32            spinfo_cwnd;
  557.     __u32            spinfo_srtt;
  558.     __u32            spinfo_rto;
  559.     __u32            spinfo_mtu;
  560. } __attribute__((packed, aligned(4)));
  561.  
  562. /* Peer addresses's state. */
  563. enum sctp_spinfo_state {
  564.     SCTP_INACTIVE,
  565.     SCTP_ACTIVE,
  566.     SCTP_UNKNOWN = 0xffff  /* Value used for transport state unknown */
  567. };
  568.  
  569. /*
  570.  * 7.2.1 Association Status (SCTP_STATUS)
  571.  *
  572.  *   Applications can retrieve current status information about an
  573.  *   association, including association state, peer receiver window size,
  574.  *   number of unacked data chunks, and number of data chunks pending
  575.  *   receipt.  This information is read-only.  The following structure is
  576.  *   used to access this information:
  577.  */
  578. struct sctp_status {
  579.     sctp_assoc_t        sstat_assoc_id;
  580.     __s32            sstat_state;
  581.     __u32            sstat_rwnd;
  582.     __u16            sstat_unackdata;
  583.     __u16            sstat_penddata;
  584.     __u16            sstat_instrms;
  585.     __u16            sstat_outstrms;
  586.     __u32            sstat_fragmentation_point;
  587.     struct sctp_paddrinfo    sstat_primary;
  588. };
  589.  
  590. /*
  591.  * 8.3, 8.5 get all peer/local addresses in an association.
  592.  * This parameter struct is used by SCTP_GET_PEER_ADDRS and 
  593.  * SCTP_GET_LOCAL_ADDRS socket options used internally to implement
  594.  * sctp_getpaddrs() and sctp_getladdrs() API. 
  595.  */
  596. struct sctp_getaddrs_old {
  597.     sctp_assoc_t            assoc_id;
  598.     int            addr_num;
  599.     struct sockaddr        __user *addrs;
  600. };
  601. struct sctp_getaddrs {
  602.     sctp_assoc_t        assoc_id; /*input*/
  603.     __u32            addr_num; /*output*/
  604.     __u8            addrs[0]; /*output, variable size*/
  605. };
  606.  
  607. /* These are bit fields for msghdr->msg_flags.  See section 5.1.  */
  608. /* On user space Linux, these live in <bits/socket.h> as an enum.  */
  609. enum sctp_msg_flags {
  610.     MSG_NOTIFICATION = 0x8000,
  611. #define MSG_NOTIFICATION MSG_NOTIFICATION
  612. };
  613.  
  614. /*
  615.  * 8.1 sctp_bindx()
  616.  *
  617.  * The flags parameter is formed from the bitwise OR of zero or more of the
  618.  * following currently defined flags:
  619.  */
  620. #define SCTP_BINDX_ADD_ADDR 0x01
  621. #define SCTP_BINDX_REM_ADDR 0x02
  622.  
  623. /* This is the structure that is passed as an argument(optval) to
  624.  * getsockopt(SCTP_SOCKOPT_PEELOFF).
  625.  */
  626. typedef struct {
  627.     sctp_assoc_t associd;
  628.     int sd;
  629. } sctp_peeloff_arg_t;
  630.  
  631. #endif /* __net_sctp_user_h__ */
  632.