Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
422 | giacomo | 1 | /* SCTP kernel reference Implementation |
2 | * (C) Copyright IBM Corp. 2001, 2003 |
||
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 | __u16 source; |
||
61 | __u16 dest; |
||
62 | __u32 vtag; |
||
63 | __u32 checksum; |
||
64 | } sctp_sctphdr_t __attribute__((packed)); |
||
65 | |||
66 | /* Section 3.2. Chunk Field Descriptions. */ |
||
67 | typedef struct sctp_chunkhdr { |
||
68 | __u8 type; |
||
69 | __u8 flags; |
||
70 | __u16 length; |
||
71 | } sctp_chunkhdr_t __attribute__((packed)); |
||
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 | /* Use hex, as defined in ADDIP sec. 3.1 */ |
||
97 | SCTP_CID_ASCONF = 0xC1, |
||
98 | SCTP_CID_ASCONF_ACK = 0x80, |
||
99 | } sctp_cid_t; /* enum */ |
||
100 | |||
101 | |||
102 | /* Section 3.2 |
||
103 | * Chunk Types are encoded such that the highest-order two bits specify |
||
104 | * the action that must be taken if the processing endpoint does not |
||
105 | * recognize the Chunk Type. |
||
106 | */ |
||
107 | typedef enum { |
||
108 | SCTP_CID_ACTION_DISCARD = 0x00, |
||
109 | SCTP_CID_ACTION_DISCARD_ERR = 0x40, |
||
110 | SCTP_CID_ACTION_SKIP = 0x80, |
||
111 | SCTP_CID_ACTION_SKIP_ERR = 0xc0, |
||
112 | } sctp_cid_action_t; |
||
113 | |||
114 | enum { SCTP_CID_ACTION_MASK = 0xc0, }; |
||
115 | |||
116 | /* This flag is used in Chunk Flags for ABORT and SHUTDOWN COMPLETE. |
||
117 | * |
||
118 | * 3.3.7 Abort Association (ABORT) (6): |
||
119 | * The T bit is set to 0 if the sender had a TCB that it destroyed. |
||
120 | * If the sender did not have a TCB it should set this bit to 1. |
||
121 | */ |
||
122 | enum { SCTP_CHUNK_FLAG_T = 0x01 }; |
||
123 | |||
124 | /* |
||
125 | * Set the T bit |
||
126 | * |
||
127 | * 0 1 2 3 |
||
128 | * 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 |
||
129 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
130 | * | Type = 14 |Reserved |T| Length = 4 | |
||
131 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
132 | * |
||
133 | * Chunk Flags: 8 bits |
||
134 | * |
||
135 | * Reserved: 7 bits |
||
136 | * Set to 0 on transmit and ignored on receipt. |
||
137 | * |
||
138 | * T bit: 1 bit |
||
139 | * The T bit is set to 0 if the sender had a TCB that it destroyed. If |
||
140 | * the sender did NOT have a TCB it should set this bit to 1. |
||
141 | * |
||
142 | * Note: Special rules apply to this chunk for verification, please |
||
143 | * see Section 8.5.1 for details. |
||
144 | */ |
||
145 | |||
146 | #define sctp_test_T_bit(c) ((c)->chunk_hdr->flags & SCTP_CHUNK_FLAG_T) |
||
147 | |||
148 | /* RFC 2960 |
||
149 | * Section 3.2.1 Optional/Variable-length Parmaeter Format. |
||
150 | */ |
||
151 | |||
152 | typedef struct sctp_paramhdr { |
||
153 | __u16 type; |
||
154 | __u16 length; |
||
155 | } sctp_paramhdr_t __attribute((packed)); |
||
156 | |||
157 | typedef enum { |
||
158 | |||
159 | /* RFC 2960 Section 3.3.5 */ |
||
160 | SCTP_PARAM_HEARTBEAT_INFO = __constant_htons(1), |
||
161 | /* RFC 2960 Section 3.3.2.1 */ |
||
162 | SCTP_PARAM_IPV4_ADDRESS = __constant_htons(5), |
||
163 | SCTP_PARAM_IPV6_ADDRESS = __constant_htons(6), |
||
164 | SCTP_PARAM_STATE_COOKIE = __constant_htons(7), |
||
165 | SCTP_PARAM_UNRECOGNIZED_PARAMETERS = __constant_htons(8), |
||
166 | SCTP_PARAM_COOKIE_PRESERVATIVE = __constant_htons(9), |
||
167 | SCTP_PARAM_HOST_NAME_ADDRESS = __constant_htons(11), |
||
168 | SCTP_PARAM_SUPPORTED_ADDRESS_TYPES = __constant_htons(12), |
||
169 | SCTP_PARAM_ECN_CAPABLE = __constant_htons(0x8000), |
||
170 | |||
171 | /* Add-IP Extension. Section 3.2 */ |
||
172 | SCTP_PARAM_ADD_IP = __constant_htons(0xc001), |
||
173 | SCTP_PARAM_DEL_IP = __constant_htons(0xc002), |
||
174 | SCTP_PARAM_ERR_CAUSE = __constant_htons(0xc003), |
||
175 | SCTP_PARAM_SET_PRIMARY = __constant_htons(0xc004), |
||
176 | SCTP_PARAM_SUCCESS_REPORT = __constant_htons(0xc005), |
||
177 | SCTP_PARAM_ADAPTION_LAYER_IND = __constant_htons(0xc006), |
||
178 | |||
179 | } sctp_param_t; /* enum */ |
||
180 | |||
181 | |||
182 | /* RFC 2960 Section 3.2.1 |
||
183 | * The Parameter Types are encoded such that the highest-order two bits |
||
184 | * specify the action that must be taken if the processing endpoint does |
||
185 | * not recognize the Parameter Type. |
||
186 | * |
||
187 | */ |
||
188 | typedef enum { |
||
189 | SCTP_PARAM_ACTION_DISCARD = __constant_htons(0x0000), |
||
190 | SCTP_PARAM_ACTION_DISCARD_ERR = __constant_htons(0x4000), |
||
191 | SCTP_PARAM_ACTION_SKIP = __constant_htons(0x8000), |
||
192 | SCTP_PARAM_ACTION_SKIP_ERR = __constant_htons(0xc000), |
||
193 | } sctp_param_action_t; |
||
194 | |||
195 | enum { SCTP_PARAM_ACTION_MASK = __constant_htons(0xc000), }; |
||
196 | |||
197 | /* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */ |
||
198 | |||
199 | typedef struct sctp_datahdr { |
||
200 | __u32 tsn; |
||
201 | __u16 stream; |
||
202 | __u16 ssn; |
||
203 | __u32 ppid; |
||
204 | __u8 payload[0]; |
||
205 | } sctp_datahdr_t __attribute__((packed)); |
||
206 | |||
207 | typedef struct sctp_data_chunk { |
||
208 | sctp_chunkhdr_t chunk_hdr; |
||
209 | sctp_datahdr_t data_hdr; |
||
210 | } sctp_data_chunk_t __attribute__((packed)); |
||
211 | |||
212 | /* DATA Chuck Specific Flags */ |
||
213 | enum { |
||
214 | SCTP_DATA_MIDDLE_FRAG = 0x00, |
||
215 | SCTP_DATA_LAST_FRAG = 0x01, |
||
216 | SCTP_DATA_FIRST_FRAG = 0x02, |
||
217 | SCTP_DATA_NOT_FRAG = 0x03, |
||
218 | SCTP_DATA_UNORDERED = 0x04, |
||
219 | }; |
||
220 | enum { SCTP_DATA_FRAG_MASK = 0x03, }; |
||
221 | |||
222 | |||
223 | /* RFC 2960 Section 3.3.2 Initiation (INIT) (1) |
||
224 | * |
||
225 | * This chunk is used to initiate a SCTP association between two |
||
226 | * endpoints. |
||
227 | */ |
||
228 | typedef struct sctp_inithdr { |
||
229 | __u32 init_tag; |
||
230 | __u32 a_rwnd; |
||
231 | __u16 num_outbound_streams; |
||
232 | __u16 num_inbound_streams; |
||
233 | __u32 initial_tsn; |
||
234 | __u8 params[0]; |
||
235 | } sctp_inithdr_t __attribute__((packed)); |
||
236 | |||
237 | typedef struct sctp_init_chunk { |
||
238 | sctp_chunkhdr_t chunk_hdr; |
||
239 | sctp_inithdr_t init_hdr; |
||
240 | } sctp_init_chunk_t __attribute__((packed)); |
||
241 | |||
242 | |||
243 | /* Section 3.3.2.1. IPv4 Address Parameter (5) */ |
||
244 | typedef struct sctp_ipv4addr_param { |
||
245 | sctp_paramhdr_t param_hdr; |
||
246 | struct in_addr addr; |
||
247 | } sctp_ipv4addr_param_t __attribute__((packed)); |
||
248 | |||
249 | /* Section 3.3.2.1. IPv6 Address Parameter (6) */ |
||
250 | typedef struct sctp_ipv6addr_param { |
||
251 | sctp_paramhdr_t param_hdr; |
||
252 | struct in6_addr addr; |
||
253 | } sctp_ipv6addr_param_t __attribute__((packed)); |
||
254 | |||
255 | /* Section 3.3.2.1 Cookie Preservative (9) */ |
||
256 | typedef struct sctp_cookie_preserve_param { |
||
257 | sctp_paramhdr_t param_hdr; |
||
258 | uint32_t lifespan_increment; |
||
259 | } sctp_cookie_preserve_param_t __attribute__((packed)); |
||
260 | |||
261 | /* Section 3.3.2.1 Host Name Address (11) */ |
||
262 | typedef struct sctp_hostname_param { |
||
263 | sctp_paramhdr_t param_hdr; |
||
264 | uint8_t hostname[0]; |
||
265 | } sctp_hostname_param_t __attribute__((packed)); |
||
266 | |||
267 | /* Section 3.3.2.1 Supported Address Types (12) */ |
||
268 | typedef struct sctp_supported_addrs_param { |
||
269 | sctp_paramhdr_t param_hdr; |
||
270 | uint16_t types[0]; |
||
271 | } sctp_supported_addrs_param_t __attribute__((packed)); |
||
272 | |||
273 | /* Appendix A. ECN Capable (32768) */ |
||
274 | typedef struct sctp_ecn_capable_param { |
||
275 | sctp_paramhdr_t param_hdr; |
||
276 | } sctp_ecn_capable_param_t __attribute__((packed)); |
||
277 | |||
278 | |||
279 | |||
280 | /* RFC 2960. Section 3.3.3 Initiation Acknowledgement (INIT ACK) (2): |
||
281 | * The INIT ACK chunk is used to acknowledge the initiation of an SCTP |
||
282 | * association. |
||
283 | */ |
||
284 | typedef sctp_init_chunk_t sctp_initack_chunk_t; |
||
285 | |||
286 | /* Section 3.3.3.1 State Cookie (7) */ |
||
287 | typedef struct sctp_cookie_param { |
||
288 | sctp_paramhdr_t p; |
||
289 | __u8 body[0]; |
||
290 | } sctp_cookie_param_t __attribute__((packed)); |
||
291 | |||
292 | /* Section 3.3.3.1 Unrecognized Parameters (8) */ |
||
293 | typedef struct sctp_unrecognized_param { |
||
294 | sctp_paramhdr_t param_hdr; |
||
295 | sctp_paramhdr_t unrecognized; |
||
296 | } sctp_unrecognized_param_t __attribute__((packed)); |
||
297 | |||
298 | |||
299 | |||
300 | /* |
||
301 | * 3.3.4 Selective Acknowledgement (SACK) (3): |
||
302 | * |
||
303 | * This chunk is sent to the peer endpoint to acknowledge received DATA |
||
304 | * chunks and to inform the peer endpoint of gaps in the received |
||
305 | * subsequences of DATA chunks as represented by their TSNs. |
||
306 | */ |
||
307 | |||
308 | typedef struct sctp_gap_ack_block { |
||
309 | __u16 start; |
||
310 | __u16 end; |
||
311 | } sctp_gap_ack_block_t __attribute__((packed)); |
||
312 | |||
313 | typedef uint32_t sctp_dup_tsn_t; |
||
314 | |||
315 | typedef union { |
||
316 | sctp_gap_ack_block_t gab; |
||
317 | sctp_dup_tsn_t dup; |
||
318 | } sctp_sack_variable_t; |
||
319 | |||
320 | typedef struct sctp_sackhdr { |
||
321 | __u32 cum_tsn_ack; |
||
322 | __u32 a_rwnd; |
||
323 | __u16 num_gap_ack_blocks; |
||
324 | __u16 num_dup_tsns; |
||
325 | sctp_sack_variable_t variable[0]; |
||
326 | } sctp_sackhdr_t __attribute__((packed)); |
||
327 | |||
328 | typedef struct sctp_sack_chunk { |
||
329 | sctp_chunkhdr_t chunk_hdr; |
||
330 | sctp_sackhdr_t sack_hdr; |
||
331 | } sctp_sack_chunk_t __attribute__((packed)); |
||
332 | |||
333 | |||
334 | /* RFC 2960. Section 3.3.5 Heartbeat Request (HEARTBEAT) (4): |
||
335 | * |
||
336 | * An endpoint should send this chunk to its peer endpoint to probe the |
||
337 | * reachability of a particular destination transport address defined in |
||
338 | * the present association. |
||
339 | */ |
||
340 | |||
341 | typedef struct sctp_heartbeathdr { |
||
342 | sctp_paramhdr_t info; |
||
343 | } sctp_heartbeathdr_t __attribute__((packed)); |
||
344 | |||
345 | typedef struct sctp_heartbeat_chunk { |
||
346 | sctp_chunkhdr_t chunk_hdr; |
||
347 | sctp_heartbeathdr_t hb_hdr; |
||
348 | } sctp_heartbeat_chunk_t __attribute__((packed)); |
||
349 | |||
350 | |||
351 | /* For the abort and shutdown ACK we must carry the init tag in the |
||
352 | * common header. Just the common header is all that is needed with a |
||
353 | * chunk descriptor. |
||
354 | */ |
||
355 | typedef struct sctp_abort_chunk { |
||
356 | sctp_chunkhdr_t uh; |
||
357 | } sctp_abort_chunkt_t __attribute__((packed)); |
||
358 | |||
359 | |||
360 | /* For the graceful shutdown we must carry the tag (in common header) |
||
361 | * and the highest consecutive acking value. |
||
362 | */ |
||
363 | typedef struct sctp_shutdownhdr { |
||
364 | __u32 cum_tsn_ack; |
||
365 | } sctp_shutdownhdr_t __attribute__((packed)); |
||
366 | |||
367 | struct sctp_shutdown_chunk_t { |
||
368 | sctp_chunkhdr_t chunk_hdr; |
||
369 | sctp_shutdownhdr_t shutdown_hdr; |
||
370 | } __attribute__((packed)); |
||
371 | |||
372 | |||
373 | |||
374 | /* RFC 2960. Section 3.3.10 Operation Error (ERROR) (9) */ |
||
375 | |||
376 | typedef struct sctp_errhdr { |
||
377 | __u16 cause; |
||
378 | __u16 length; |
||
379 | __u8 variable[0]; |
||
380 | } sctp_errhdr_t __attribute__((packed)); |
||
381 | |||
382 | typedef struct sctp_operr_chunk { |
||
383 | sctp_chunkhdr_t chunk_hdr; |
||
384 | sctp_errhdr_t err_hdr; |
||
385 | } sctp_operr_chunk_t __attribute__((packed)); |
||
386 | |||
387 | /* RFC 2960 3.3.10 - Operation Error |
||
388 | * |
||
389 | * Cause Code: 16 bits (unsigned integer) |
||
390 | * |
||
391 | * Defines the type of error conditions being reported. |
||
392 | * Cause Code |
||
393 | * Value Cause Code |
||
394 | * --------- ---------------- |
||
395 | * 1 Invalid Stream Identifier |
||
396 | * 2 Missing Mandatory Parameter |
||
397 | * 3 Stale Cookie Error |
||
398 | * 4 Out of Resource |
||
399 | * 5 Unresolvable Address |
||
400 | * 6 Unrecognized Chunk Type |
||
401 | * 7 Invalid Mandatory Parameter |
||
402 | * 8 Unrecognized Parameters |
||
403 | * 9 No User Data |
||
404 | * 10 Cookie Received While Shutting Down |
||
405 | */ |
||
406 | typedef enum { |
||
407 | |||
408 | SCTP_ERROR_NO_ERROR = __constant_htons(0x00), |
||
409 | SCTP_ERROR_INV_STRM = __constant_htons(0x01), |
||
410 | SCTP_ERROR_MISS_PARAM = __constant_htons(0x02), |
||
411 | SCTP_ERROR_STALE_COOKIE = __constant_htons(0x03), |
||
412 | SCTP_ERROR_NO_RESOURCE = __constant_htons(0x04), |
||
413 | SCTP_ERROR_DNS_FAILED = __constant_htons(0x05), |
||
414 | SCTP_ERROR_UNKNOWN_CHUNK = __constant_htons(0x06), |
||
415 | SCTP_ERROR_INV_PARAM = __constant_htons(0x07), |
||
416 | SCTP_ERROR_UNKNOWN_PARAM = __constant_htons(0x08), |
||
417 | SCTP_ERROR_NO_DATA = __constant_htons(0x09), |
||
418 | SCTP_ERROR_COOKIE_IN_SHUTDOWN = __constant_htons(0x0a), |
||
419 | |||
420 | |||
421 | /* SCTP Implementation Guide: |
||
422 | * 11 Restart of an association with new addresses |
||
423 | * 12 User Initiated Abort |
||
424 | * 13 Protocol Violation |
||
425 | */ |
||
426 | |||
427 | SCTP_ERROR_RESTART = __constant_htons(0x0b), |
||
428 | SCTP_ERROR_USER_ABORT = __constant_htons(0x0c), |
||
429 | SCTP_ERROR_PROTO_VIOLATION = __constant_htons(0x0d), |
||
430 | |||
431 | /* ADDIP Section 3.3 New Error Causes |
||
432 | * |
||
433 | * Four new Error Causes are added to the SCTP Operational Errors, |
||
434 | * primarily for use in the ASCONF-ACK chunk. |
||
435 | * |
||
436 | * Value Cause Code |
||
437 | * --------- ---------------- |
||
438 | * 0x0100 Request to Delete Last Remaining IP Address. |
||
439 | * 0x0101 Operation Refused Due to Resource Shortage. |
||
440 | * 0x0102 Request to Delete Source IP Address. |
||
441 | * 0x0103 Association Aborted due to illegal ASCONF-ACK |
||
442 | */ |
||
443 | SCTP_ERROR_DEL_LAST_IP = __constant_htons(0x0100), |
||
444 | SCTP_ERROR_RSRC_LOW = __constant_htons(0x0101), |
||
445 | SCTP_ERROR_DEL_SRC_IP = __constant_htons(0x0102), |
||
446 | SCTP_ERROR_ASCONF_ACK = __constant_htons(0x0103), |
||
447 | |||
448 | } sctp_error_t; |
||
449 | |||
450 | |||
451 | |||
452 | /* RFC 2960. Appendix A. Explicit Congestion Notification. |
||
453 | * Explicit Congestion Notification Echo (ECNE) (12) |
||
454 | */ |
||
455 | typedef struct sctp_ecnehdr { |
||
456 | __u32 lowest_tsn; |
||
457 | } sctp_ecnehdr_t; |
||
458 | |||
459 | typedef struct sctp_ecne_chunk { |
||
460 | sctp_chunkhdr_t chunk_hdr; |
||
461 | sctp_ecnehdr_t ence_hdr; |
||
462 | } sctp_ecne_chunk_t __attribute__((packed)); |
||
463 | |||
464 | /* RFC 2960. Appendix A. Explicit Congestion Notification. |
||
465 | * Congestion Window Reduced (CWR) (13) |
||
466 | */ |
||
467 | typedef struct sctp_cwrhdr { |
||
468 | __u32 lowest_tsn; |
||
469 | } sctp_cwrhdr_t; |
||
470 | |||
471 | typedef struct sctp_cwr_chunk { |
||
472 | sctp_chunkhdr_t chunk_hdr; |
||
473 | sctp_cwrhdr_t cwr_hdr; |
||
474 | } sctp_cwr_chunk_t __attribute__((packed)); |
||
475 | |||
476 | /* |
||
477 | * ADDIP Section 3.1 New Chunk Types |
||
478 | */ |
||
479 | |||
480 | /* ADDIP |
||
481 | * Section 3.1.1 Address Configuration Change Chunk (ASCONF) |
||
482 | * |
||
483 | * Serial Number: 32 bits (unsigned integer) |
||
484 | * This value represents a Serial Number for the ASCONF Chunk. The |
||
485 | * valid range of Serial Number is from 0 to 2^32-1. |
||
486 | * Serial Numbers wrap back to 0 after reaching 2^32 -1. |
||
487 | * |
||
488 | * Address Parameter: 8 or 20 bytes (depending on type) |
||
489 | * The address is an address of the sender of the ASCONF chunk, |
||
490 | * the address MUST be considered part of the association by the |
||
491 | * peer endpoint. This field may be used by the receiver of the |
||
492 | * ASCONF to help in finding the association. This parameter MUST |
||
493 | * be present in every ASCONF message i.e. it is a mandatory TLV |
||
494 | * parameter. |
||
495 | * |
||
496 | * ASCONF Parameter: TLV format |
||
497 | * Each Address configuration change is represented by a TLV |
||
498 | * parameter as defined in Section 3.2. One or more requests may |
||
499 | * be present in an ASCONF Chunk. |
||
500 | * |
||
501 | * Section 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK) |
||
502 | * |
||
503 | * Serial Number: 32 bits (unsigned integer) |
||
504 | * This value represents the Serial Number for the received ASCONF |
||
505 | * Chunk that is acknowledged by this chunk. This value is copied |
||
506 | * from the received ASCONF Chunk. |
||
507 | * |
||
508 | * ASCONF Parameter Response: TLV format |
||
509 | * The ASCONF Parameter Response is used in the ASCONF-ACK to |
||
510 | * report status of ASCONF processing. |
||
511 | */ |
||
512 | typedef struct sctp_addip_param { |
||
513 | sctp_paramhdr_t param_hdr; |
||
514 | __u32 crr_id; |
||
515 | }sctp_addip_param_t __attribute__((packed)); |
||
516 | |||
517 | typedef struct sctp_addiphdr { |
||
518 | __u32 serial; |
||
519 | __u8 params[0]; |
||
520 | } sctp_addiphdr_t __attribute__((packed)); |
||
521 | |||
522 | typedef struct sctp_addip_chunk { |
||
523 | sctp_chunkhdr_t chunk_hdr; |
||
524 | sctp_addiphdr_t addip_hdr; |
||
525 | } sctp_addip_chunk_t __attribute__((packed)); |
||
526 | |||
527 | #endif /* __LINUX_SCTP_H__ */ |