[SCTP]: Fix typo adaption -> adaptation as per the latest API draft.
[linux-3.10.git] / include / linux / sctp.h
1 /* SCTP kernel reference Implementation
2  * (C) Copyright IBM Corp. 2001, 2004
3  * Copyright (c) 1999-2000 Cisco, Inc.
4  * Copyright (c) 1999-2001 Motorola, Inc.
5  * Copyright (c) 2001 Intel Corp.
6  * Copyright (c) 2001 Nokia, Inc.
7  * Copyright (c) 2001 La Monte H.P. Yarroll
8  *
9  * This file is part of the SCTP kernel reference Implementation
10  *
11  * Various protocol defined structures.
12  *
13  * The SCTP reference implementation is free software;
14  * you can redistribute it and/or modify it under the terms of
15  * the GNU General Public License as published by
16  * the Free Software Foundation; either version 2, or (at your option)
17  * any later version.
18  *
19  * The SCTP reference implementation is distributed in the hope that it
20  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21  *                 ************************
22  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
23  * See the GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with GNU CC; see the file COPYING.  If not, write to
27  * the Free Software Foundation, 59 Temple Place - Suite 330,
28  * Boston, MA 02111-1307, USA.
29  *
30  * Please send any bug reports or fixes you make to the
31  * email address(es):
32  *    lksctp developers <lksctp-developerst@lists.sourceforge.net>
33  *
34  * Or submit a bug report through the following website:
35  *    http://www.sf.net/projects/lksctp
36  *
37  * Written or modified by:
38  *    La Monte H.P. Yarroll <piggy@acm.org>
39  *    Karl Knutson <karl@athena.chicago.il.us>
40  *    Jon Grimm <jgrimm@us.ibm.com>
41  *    Xingang Guo <xingang.guo@intel.com>
42  *    randall@sctp.chicago.il.us
43  *    kmorneau@cisco.com
44  *    qxie1@email.mot.com
45  *    Sridhar Samudrala <sri@us.ibm.com>
46  *    Kevin Gao <kevin.gao@intel.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 #ifndef __LINUX_SCTP_H__
52 #define __LINUX_SCTP_H__
53
54 #include <linux/in.h>           /* We need in_addr.  */
55 #include <linux/in6.h>          /* We need in6_addr.  */
56
57
58 /* Section 3.1.  SCTP Common Header Format */
59 typedef struct sctphdr {
60         __be16 source;
61         __be16 dest;
62         __be32 vtag;
63         __be32 checksum;
64 } __attribute__((packed)) sctp_sctphdr_t;
65
66 /* Section 3.2.  Chunk Field Descriptions. */
67 typedef struct sctp_chunkhdr {
68         __u8 type;
69         __u8 flags;
70         __be16 length;
71 } __attribute__((packed)) sctp_chunkhdr_t;
72
73
74 /* Section 3.2.  Chunk Type Values.
75  * [Chunk Type] identifies the type of information contained in the Chunk
76  * Value field. It takes a value from 0 to 254. The value of 255 is
77  * reserved for future use as an extension field.
78  */
79 typedef enum {
80         SCTP_CID_DATA                   = 0,
81         SCTP_CID_INIT                   = 1,
82         SCTP_CID_INIT_ACK               = 2,
83         SCTP_CID_SACK                   = 3,
84         SCTP_CID_HEARTBEAT              = 4,
85         SCTP_CID_HEARTBEAT_ACK          = 5,
86         SCTP_CID_ABORT                  = 6,
87         SCTP_CID_SHUTDOWN               = 7,
88         SCTP_CID_SHUTDOWN_ACK           = 8,
89         SCTP_CID_ERROR                  = 9,
90         SCTP_CID_COOKIE_ECHO            = 10,
91         SCTP_CID_COOKIE_ACK             = 11,
92         SCTP_CID_ECN_ECNE               = 12,
93         SCTP_CID_ECN_CWR                = 13,
94         SCTP_CID_SHUTDOWN_COMPLETE      = 14,
95
96         /* PR-SCTP Sec 3.2 */
97         SCTP_CID_FWD_TSN                = 0xC0,
98
99         /* Use hex, as defined in ADDIP sec. 3.1 */
100         SCTP_CID_ASCONF                 = 0xC1,
101         SCTP_CID_ASCONF_ACK             = 0x80,
102 } sctp_cid_t; /* enum */
103
104
105 /* Section 3.2
106  *  Chunk Types are encoded such that the highest-order two bits specify
107  *  the action that must be taken if the processing endpoint does not
108  *  recognize the Chunk Type.
109  */
110 typedef enum {
111         SCTP_CID_ACTION_DISCARD     = 0x00,
112         SCTP_CID_ACTION_DISCARD_ERR = 0x40,
113         SCTP_CID_ACTION_SKIP        = 0x80,
114         SCTP_CID_ACTION_SKIP_ERR    = 0xc0,
115 } sctp_cid_action_t;
116
117 enum { SCTP_CID_ACTION_MASK = 0xc0, };
118
119 /* This flag is used in Chunk Flags for ABORT and SHUTDOWN COMPLETE.
120  *
121  * 3.3.7 Abort Association (ABORT) (6):
122  *    The T bit is set to 0 if the sender had a TCB that it destroyed.
123  *    If the sender did not have a TCB it should set this bit to 1.
124  */
125 enum { SCTP_CHUNK_FLAG_T = 0x01 };
126
127 /*
128  *  Set the T bit
129  *
130  *      0                   1                   2                   3
131  *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
132  *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
133  *     |   Type = 14   |Reserved     |T|      Length = 4               |
134  *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
135  *
136  * Chunk Flags: 8 bits
137  *
138  *   Reserved:  7 bits
139  *     Set to 0 on transmit and ignored on receipt.
140  *
141  *   T bit:  1 bit
142  *     The T bit is set to 0 if the sender had a TCB that it destroyed. If
143  *     the sender did NOT have a TCB it should set this bit to 1.
144  *
145  * Note: Special rules apply to this chunk for verification, please
146  * see Section 8.5.1 for details.
147  */
148
149 #define sctp_test_T_bit(c)    ((c)->chunk_hdr->flags & SCTP_CHUNK_FLAG_T)
150
151 /* RFC 2960
152  * Section 3.2.1 Optional/Variable-length Parmaeter Format.
153  */
154
155 typedef struct sctp_paramhdr {
156         __be16 type;
157         __be16 length;
158 } __attribute__((packed)) sctp_paramhdr_t;
159
160 typedef enum {
161
162         /* RFC 2960 Section 3.3.5 */
163         SCTP_PARAM_HEARTBEAT_INFO               = __constant_htons(1),
164         /* RFC 2960 Section 3.3.2.1 */
165         SCTP_PARAM_IPV4_ADDRESS                 = __constant_htons(5),
166         SCTP_PARAM_IPV6_ADDRESS                 = __constant_htons(6),
167         SCTP_PARAM_STATE_COOKIE                 = __constant_htons(7),
168         SCTP_PARAM_UNRECOGNIZED_PARAMETERS      = __constant_htons(8),
169         SCTP_PARAM_COOKIE_PRESERVATIVE          = __constant_htons(9),
170         SCTP_PARAM_HOST_NAME_ADDRESS            = __constant_htons(11),
171         SCTP_PARAM_SUPPORTED_ADDRESS_TYPES      = __constant_htons(12),
172         SCTP_PARAM_ECN_CAPABLE                  = __constant_htons(0x8000),
173
174         /* PR-SCTP Sec 3.1 */
175         SCTP_PARAM_FWD_TSN_SUPPORT      = __constant_htons(0xc000),
176
177         /* Add-IP Extension. Section 3.2 */
178         SCTP_PARAM_ADD_IP               = __constant_htons(0xc001),
179         SCTP_PARAM_DEL_IP               = __constant_htons(0xc002),
180         SCTP_PARAM_ERR_CAUSE            = __constant_htons(0xc003),
181         SCTP_PARAM_SET_PRIMARY          = __constant_htons(0xc004),
182         SCTP_PARAM_SUCCESS_REPORT       = __constant_htons(0xc005),
183         SCTP_PARAM_ADAPTATION_LAYER_IND = __constant_htons(0xc006),
184
185 } sctp_param_t; /* enum */
186
187
188 /* RFC 2960 Section 3.2.1
189  *  The Parameter Types are encoded such that the highest-order two bits
190  *  specify the action that must be taken if the processing endpoint does
191  *  not recognize the Parameter Type.
192  *
193  */
194 typedef enum {
195         SCTP_PARAM_ACTION_DISCARD     = __constant_htons(0x0000),
196         SCTP_PARAM_ACTION_DISCARD_ERR = __constant_htons(0x4000),
197         SCTP_PARAM_ACTION_SKIP        = __constant_htons(0x8000),
198         SCTP_PARAM_ACTION_SKIP_ERR    = __constant_htons(0xc000),
199 } sctp_param_action_t;
200
201 enum { SCTP_PARAM_ACTION_MASK = __constant_htons(0xc000), };
202
203 /* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */
204
205 typedef struct sctp_datahdr {
206         __be32 tsn;
207         __be16 stream;
208         __be16 ssn;
209         __be32 ppid;
210         __u8  payload[0];
211 } __attribute__((packed)) sctp_datahdr_t;
212
213 typedef struct sctp_data_chunk {
214         sctp_chunkhdr_t chunk_hdr;
215         sctp_datahdr_t  data_hdr;
216 } __attribute__((packed)) sctp_data_chunk_t;
217
218 /* DATA Chuck Specific Flags */
219 enum {
220         SCTP_DATA_MIDDLE_FRAG   = 0x00,
221         SCTP_DATA_LAST_FRAG     = 0x01,
222         SCTP_DATA_FIRST_FRAG    = 0x02,
223         SCTP_DATA_NOT_FRAG      = 0x03,
224         SCTP_DATA_UNORDERED     = 0x04,
225 };
226 enum { SCTP_DATA_FRAG_MASK = 0x03, };
227
228
229 /* RFC 2960 Section 3.3.2 Initiation (INIT) (1)
230  *
231  *  This chunk is used to initiate a SCTP association between two
232  *  endpoints.
233  */
234 typedef struct sctp_inithdr {
235         __be32 init_tag;
236         __be32 a_rwnd;
237         __be16 num_outbound_streams;
238         __be16 num_inbound_streams;
239         __be32 initial_tsn;
240         __u8  params[0];
241 } __attribute__((packed)) sctp_inithdr_t;
242
243 typedef struct sctp_init_chunk {
244         sctp_chunkhdr_t chunk_hdr;
245         sctp_inithdr_t init_hdr;
246 } __attribute__((packed)) sctp_init_chunk_t;
247
248
249 /* Section 3.3.2.1. IPv4 Address Parameter (5) */
250 typedef struct sctp_ipv4addr_param {
251         sctp_paramhdr_t param_hdr;
252         struct in_addr  addr;
253 } __attribute__((packed)) sctp_ipv4addr_param_t;
254
255 /* Section 3.3.2.1. IPv6 Address Parameter (6) */
256 typedef struct sctp_ipv6addr_param {
257         sctp_paramhdr_t param_hdr;
258         struct in6_addr addr;
259 } __attribute__((packed)) sctp_ipv6addr_param_t;
260
261 /* Section 3.3.2.1 Cookie Preservative (9) */
262 typedef struct sctp_cookie_preserve_param {
263         sctp_paramhdr_t param_hdr;
264         __be32          lifespan_increment;
265 } __attribute__((packed)) sctp_cookie_preserve_param_t;
266
267 /* Section 3.3.2.1 Host Name Address (11) */
268 typedef struct sctp_hostname_param {
269         sctp_paramhdr_t param_hdr;
270         uint8_t hostname[0];
271 } __attribute__((packed)) sctp_hostname_param_t;
272
273 /* Section 3.3.2.1 Supported Address Types (12) */
274 typedef struct sctp_supported_addrs_param {
275         sctp_paramhdr_t param_hdr;
276         __be16 types[0];
277 } __attribute__((packed)) sctp_supported_addrs_param_t;
278
279 /* Appendix A. ECN Capable (32768) */
280 typedef struct sctp_ecn_capable_param {
281         sctp_paramhdr_t param_hdr;
282 } __attribute__((packed)) sctp_ecn_capable_param_t;
283
284 /* ADDIP Section 3.2.6 Adaptation Layer Indication */
285 typedef struct sctp_adaptation_ind_param {
286         struct sctp_paramhdr param_hdr;
287         __be32 adaptation_ind;
288 } __attribute__((packed)) sctp_adaptation_ind_param_t;
289
290 /* RFC 2960.  Section 3.3.3 Initiation Acknowledgement (INIT ACK) (2):
291  *   The INIT ACK chunk is used to acknowledge the initiation of an SCTP
292  *   association.
293  */
294 typedef sctp_init_chunk_t sctp_initack_chunk_t;
295
296 /* Section 3.3.3.1 State Cookie (7) */
297 typedef struct sctp_cookie_param {
298         sctp_paramhdr_t p;
299         __u8 body[0];
300 } __attribute__((packed)) sctp_cookie_param_t;
301
302 /* Section 3.3.3.1 Unrecognized Parameters (8) */
303 typedef struct sctp_unrecognized_param {
304         sctp_paramhdr_t param_hdr;
305         sctp_paramhdr_t unrecognized;
306 } __attribute__((packed)) sctp_unrecognized_param_t;
307
308
309
310 /*
311  * 3.3.4 Selective Acknowledgement (SACK) (3):
312  *
313  *  This chunk is sent to the peer endpoint to acknowledge received DATA
314  *  chunks and to inform the peer endpoint of gaps in the received
315  *  subsequences of DATA chunks as represented by their TSNs.
316  */
317
318 typedef struct sctp_gap_ack_block {
319         __be16 start;
320         __be16 end;
321 } __attribute__((packed)) sctp_gap_ack_block_t;
322
323 typedef __be32 sctp_dup_tsn_t;
324
325 typedef union {
326         sctp_gap_ack_block_t    gab;
327         sctp_dup_tsn_t          dup;
328 } sctp_sack_variable_t;
329
330 typedef struct sctp_sackhdr {
331         __be32 cum_tsn_ack;
332         __be32 a_rwnd;
333         __be16 num_gap_ack_blocks;
334         __be16 num_dup_tsns;
335         sctp_sack_variable_t variable[0];
336 } __attribute__((packed)) sctp_sackhdr_t;
337
338 typedef struct sctp_sack_chunk {
339         sctp_chunkhdr_t chunk_hdr;
340         sctp_sackhdr_t sack_hdr;
341 } __attribute__((packed)) sctp_sack_chunk_t;
342
343
344 /* RFC 2960.  Section 3.3.5 Heartbeat Request (HEARTBEAT) (4):
345  *
346  *  An endpoint should send this chunk to its peer endpoint to probe the
347  *  reachability of a particular destination transport address defined in
348  *  the present association.
349  */
350
351 typedef struct sctp_heartbeathdr {
352         sctp_paramhdr_t info;
353 } __attribute__((packed)) sctp_heartbeathdr_t;
354
355 typedef struct sctp_heartbeat_chunk {
356         sctp_chunkhdr_t chunk_hdr;
357         sctp_heartbeathdr_t hb_hdr;
358 } __attribute__((packed)) sctp_heartbeat_chunk_t;
359
360
361 /* For the abort and shutdown ACK we must carry the init tag in the
362  * common header. Just the common header is all that is needed with a
363  * chunk descriptor.
364  */
365 typedef struct sctp_abort_chunk {
366         sctp_chunkhdr_t uh;
367 } __attribute__((packed)) sctp_abort_chunk_t;
368
369
370 /* For the graceful shutdown we must carry the tag (in common header)
371  * and the highest consecutive acking value.
372  */
373 typedef struct sctp_shutdownhdr {
374         __be32 cum_tsn_ack;
375 } __attribute__((packed)) sctp_shutdownhdr_t;
376
377 struct sctp_shutdown_chunk_t {
378         sctp_chunkhdr_t    chunk_hdr;
379         sctp_shutdownhdr_t shutdown_hdr;
380 } __attribute__ ((packed));
381
382 /* RFC 2960.  Section 3.3.10 Operation Error (ERROR) (9) */
383
384 typedef struct sctp_errhdr {
385         __be16 cause;
386         __be16 length;
387         __u8  variable[0];
388 } __attribute__((packed)) sctp_errhdr_t;
389
390 typedef struct sctp_operr_chunk {
391         sctp_chunkhdr_t chunk_hdr;
392         sctp_errhdr_t   err_hdr;
393 } __attribute__((packed)) sctp_operr_chunk_t;
394
395 /* RFC 2960 3.3.10 - Operation Error
396  *
397  * Cause Code: 16 bits (unsigned integer)
398  *
399  *     Defines the type of error conditions being reported.
400  *    Cause Code
401  *     Value           Cause Code
402  *     ---------      ----------------
403  *      1              Invalid Stream Identifier
404  *      2              Missing Mandatory Parameter
405  *      3              Stale Cookie Error
406  *      4              Out of Resource
407  *      5              Unresolvable Address
408  *      6              Unrecognized Chunk Type
409  *      7              Invalid Mandatory Parameter
410  *      8              Unrecognized Parameters
411  *      9              No User Data
412  *     10              Cookie Received While Shutting Down
413  */
414 typedef enum {
415
416         SCTP_ERROR_NO_ERROR        = __constant_htons(0x00),
417         SCTP_ERROR_INV_STRM        = __constant_htons(0x01),
418         SCTP_ERROR_MISS_PARAM      = __constant_htons(0x02),
419         SCTP_ERROR_STALE_COOKIE    = __constant_htons(0x03),
420         SCTP_ERROR_NO_RESOURCE     = __constant_htons(0x04),
421         SCTP_ERROR_DNS_FAILED      = __constant_htons(0x05),
422         SCTP_ERROR_UNKNOWN_CHUNK   = __constant_htons(0x06),
423         SCTP_ERROR_INV_PARAM       = __constant_htons(0x07),
424         SCTP_ERROR_UNKNOWN_PARAM   = __constant_htons(0x08),
425         SCTP_ERROR_NO_DATA         = __constant_htons(0x09),
426         SCTP_ERROR_COOKIE_IN_SHUTDOWN = __constant_htons(0x0a),
427
428
429         /* SCTP Implementation Guide:
430          *  11  Restart of an association with new addresses
431          *  12  User Initiated Abort
432          *  13  Protocol Violation
433          */
434
435         SCTP_ERROR_RESTART         = __constant_htons(0x0b),
436         SCTP_ERROR_USER_ABORT      = __constant_htons(0x0c),
437         SCTP_ERROR_PROTO_VIOLATION = __constant_htons(0x0d),
438
439         /* ADDIP Section 3.3  New Error Causes
440          *
441          * Four new Error Causes are added to the SCTP Operational Errors,
442          * primarily for use in the ASCONF-ACK chunk.
443          *
444          * Value          Cause Code
445          * ---------      ----------------
446          * 0x0100          Request to Delete Last Remaining IP Address.
447          * 0x0101          Operation Refused Due to Resource Shortage.
448          * 0x0102          Request to Delete Source IP Address.
449          * 0x0103          Association Aborted due to illegal ASCONF-ACK
450          * 0x0104          Request refused - no authorization.
451          */
452         SCTP_ERROR_DEL_LAST_IP  = __constant_htons(0x0100),
453         SCTP_ERROR_RSRC_LOW     = __constant_htons(0x0101),
454         SCTP_ERROR_DEL_SRC_IP   = __constant_htons(0x0102),
455         SCTP_ERROR_ASCONF_ACK   = __constant_htons(0x0103),
456         SCTP_ERROR_REQ_REFUSED  = __constant_htons(0x0104)
457 } sctp_error_t;
458
459
460
461 /* RFC 2960.  Appendix A.  Explicit Congestion Notification.
462  *   Explicit Congestion Notification Echo (ECNE) (12)
463  */
464 typedef struct sctp_ecnehdr {
465         __be32 lowest_tsn;
466 } sctp_ecnehdr_t;
467
468 typedef struct sctp_ecne_chunk {
469         sctp_chunkhdr_t chunk_hdr;
470         sctp_ecnehdr_t ence_hdr;
471 } __attribute__((packed)) sctp_ecne_chunk_t;
472
473 /* RFC 2960.  Appendix A.  Explicit Congestion Notification.
474  *   Congestion Window Reduced (CWR) (13)
475  */
476 typedef struct sctp_cwrhdr {
477         __be32 lowest_tsn;
478 } sctp_cwrhdr_t;
479
480 typedef struct sctp_cwr_chunk {
481         sctp_chunkhdr_t chunk_hdr;
482         sctp_cwrhdr_t cwr_hdr;
483 } __attribute__((packed)) sctp_cwr_chunk_t;
484
485 /* PR-SCTP
486  * 3.2 Forward Cumulative TSN Chunk Definition (FORWARD TSN)
487  *
488  * Forward Cumulative TSN chunk has the following format:
489  *
490  *        0                   1                   2                   3
491  *        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
492  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
493  *      |   Type = 192  |  Flags = 0x00 |        Length = Variable      |
494  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
495  *      |                      New Cumulative TSN                       |
496  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
497  *      |         Stream-1              |       Stream Sequence-1       |
498  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
499  *      \                                                               /
500  *      /                                                               \
501  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
502  *      |         Stream-N              |       Stream Sequence-N       |
503  *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
504  *
505  *      Chunk Flags:
506  *
507  *        Set to all zeros on transmit and ignored on receipt.
508  *
509  *      New Cumulative TSN: 32 bit u_int
510  *
511  *       This indicates the new cumulative TSN to the data receiver. Upon
512  *       the reception of this value, the data receiver MUST consider
513  *       any missing TSNs earlier than or equal to this value as received
514  *       and stop reporting them as gaps in any subsequent SACKs.
515  *
516  *      Stream-N: 16 bit u_int
517  *
518  *       This field holds a stream number that was skipped by this
519  *       FWD-TSN.
520  *
521  *      Stream Sequence-N: 16 bit u_int
522  *       This field holds the sequence number associated with the stream
523  *       that was skipped. The stream sequence field holds the largest stream
524  *       sequence number in this stream being skipped.  The receiver of
525  *       the FWD-TSN's can use the Stream-N and Stream Sequence-N fields
526  *       to enable delivery of any stranded TSN's that remain on the stream
527  *       re-ordering queues. This field MUST NOT report TSN's corresponding
528  *       to DATA chunk that are marked as unordered. For ordered DATA
529  *       chunks this field MUST be filled in.
530  */
531 struct sctp_fwdtsn_skip {
532         __be16 stream;
533         __be16 ssn;
534 } __attribute__((packed));
535
536 struct sctp_fwdtsn_hdr {
537         __be32 new_cum_tsn;
538         struct sctp_fwdtsn_skip skip[0];
539 } __attribute((packed));
540
541 struct sctp_fwdtsn_chunk {
542         struct sctp_chunkhdr chunk_hdr;
543         struct sctp_fwdtsn_hdr fwdtsn_hdr;
544 } __attribute((packed));
545
546
547 /* ADDIP
548  * Section 3.1.1 Address Configuration Change Chunk (ASCONF)
549  *
550  *      Serial Number: 32 bits (unsigned integer)
551  *      This value represents a Serial Number for the ASCONF Chunk. The
552  *      valid range of Serial Number is from 0 to 2^32-1.
553  *      Serial Numbers wrap back to 0 after reaching 2^32 -1.
554  *
555  *      Address Parameter: 8 or 20 bytes (depending on type)
556  *      The address is an address of the sender of the ASCONF chunk,
557  *      the address MUST be considered part of the association by the
558  *      peer endpoint. This field may be used by the receiver of the 
559  *      ASCONF to help in finding the association. This parameter MUST
560  *      be present in every ASCONF message i.e. it is a mandatory TLV
561  *      parameter.
562  *
563  *      ASCONF Parameter: TLV format
564  *      Each Address configuration change is represented by a TLV
565  *      parameter as defined in Section 3.2. One or more requests may
566  *      be present in an ASCONF Chunk.
567  *
568  * Section 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
569  * 
570  *      Serial Number: 32 bits (unsigned integer)
571  *      This value represents the Serial Number for the received ASCONF
572  *      Chunk that is acknowledged by this chunk. This value is copied
573  *      from the received ASCONF Chunk. 
574  *
575  *      ASCONF Parameter Response: TLV format
576  *      The ASCONF Parameter Response is used in the ASCONF-ACK to
577  *      report status of ASCONF processing.
578  */
579 typedef struct sctp_addip_param {
580         sctp_paramhdr_t param_hdr;
581         __be32          crr_id;
582 } __attribute__((packed)) sctp_addip_param_t;
583
584 typedef struct sctp_addiphdr {
585         __be32  serial;
586         __u8    params[0];
587 } __attribute__((packed)) sctp_addiphdr_t;
588
589 typedef struct sctp_addip_chunk {
590         sctp_chunkhdr_t chunk_hdr;
591         sctp_addiphdr_t addip_hdr;
592 } __attribute__((packed)) sctp_addip_chunk_t;
593
594 #endif /* __LINUX_SCTP_H__ */