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) 2001-2002 Intel Corp.
7 * This file is part of the SCTP kernel implementation
9 * These functions work with the state functions in sctp_sm_statefuns.c
10 * to implement the state operations. These functions implement the
11 * steps which require modifying existing data structures.
13 * This SCTP 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)
19 * This SCTP 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.
25 * You should have received a copy of the GNU General Public License
26 * along with GNU CC; see the file COPYING. If not, see
27 * <http://www.gnu.org/licenses/>.
29 * Please send any bug reports or fixes you make to the
31 * lksctp developers <linux-sctp@vger.kernel.org>
33 * Written or modified by:
34 * La Monte H.P. Yarroll <piggy@acm.org>
35 * Karl Knutson <karl@athena.chicago.il.us>
36 * C. Robin <chris@hundredacre.ac.uk>
37 * Jon Grimm <jgrimm@us.ibm.com>
38 * Xingang Guo <xingang.guo@intel.com>
39 * Dajiang Zhang <dajiang.zhang@nokia.com>
40 * Sridhar Samudrala <sri@us.ibm.com>
41 * Daisy Chang <daisyc@us.ibm.com>
42 * Ardelle Fan <ardelle.fan@intel.com>
43 * Kevin Gao <kevin.gao@intel.com>
46 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
48 #include <crypto/hash.h>
49 #include <linux/types.h>
50 #include <linux/kernel.h>
52 #include <linux/ipv6.h>
53 #include <linux/net.h>
54 #include <linux/inet.h>
55 #include <linux/scatterlist.h>
56 #include <linux/slab.h>
59 #include <linux/skbuff.h>
60 #include <linux/random.h> /* for get_random_bytes */
61 #include <net/sctp/sctp.h>
62 #include <net/sctp/sm.h>
64 static struct sctp_chunk
*sctp_make_control(const struct sctp_association
*asoc
,
65 __u8 type
, __u8 flags
, int paylen
,
67 static struct sctp_chunk
*sctp_make_data(const struct sctp_association
*asoc
,
68 __u8 flags
, int paylen
, gfp_t gfp
);
69 static struct sctp_chunk
*_sctp_make_chunk(const struct sctp_association
*asoc
,
70 __u8 type
, __u8 flags
, int paylen
,
72 static struct sctp_cookie_param
*sctp_pack_cookie(
73 const struct sctp_endpoint
*ep
,
74 const struct sctp_association
*asoc
,
75 const struct sctp_chunk
*init_chunk
,
77 const __u8
*raw_addrs
, int addrs_len
);
78 static int sctp_process_param(struct sctp_association
*asoc
,
79 union sctp_params param
,
80 const union sctp_addr
*peer_addr
,
82 static void *sctp_addto_param(struct sctp_chunk
*chunk
, int len
,
85 /* Control chunk destructor */
86 static void sctp_control_release_owner(struct sk_buff
*skb
)
88 struct sctp_chunk
*chunk
= skb_shinfo(skb
)->destructor_arg
;
91 struct sctp_shared_key
*shkey
= chunk
->shkey
;
92 struct sctp_association
*asoc
= chunk
->asoc
;
94 /* refcnt == 2 and !list_empty mean after this release, it's
95 * not being used anywhere, and it's time to notify userland
96 * that this shkey can be freed if it's been deactivated.
98 if (shkey
->deactivated
&& !list_empty(&shkey
->key_list
) &&
99 refcount_read(&shkey
->refcnt
) == 2) {
100 struct sctp_ulpevent
*ev
;
102 ev
= sctp_ulpevent_make_authkey(asoc
, shkey
->key_id
,
106 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, ev
);
108 sctp_auth_shkey_release(chunk
->shkey
);
112 static void sctp_control_set_owner_w(struct sctp_chunk
*chunk
)
114 struct sctp_association
*asoc
= chunk
->asoc
;
115 struct sk_buff
*skb
= chunk
->skb
;
117 /* TODO: properly account for control chunks.
118 * To do it right we'll need:
119 * 1) endpoint if association isn't known.
120 * 2) proper memory accounting.
122 * For now don't do anything for now.
125 chunk
->shkey
= asoc
->shkey
;
126 sctp_auth_shkey_hold(chunk
->shkey
);
128 skb
->sk
= asoc
? asoc
->base
.sk
: NULL
;
129 skb_shinfo(skb
)->destructor_arg
= chunk
;
130 skb
->destructor
= sctp_control_release_owner
;
133 /* What was the inbound interface for this chunk? */
134 int sctp_chunk_iif(const struct sctp_chunk
*chunk
)
136 struct sk_buff
*skb
= chunk
->skb
;
138 return SCTP_INPUT_CB(skb
)->af
->skb_iif(skb
);
141 /* RFC 2960 3.3.2 Initiation (INIT) (1)
143 * Note 2: The ECN capable field is reserved for future use of
144 * Explicit Congestion Notification.
146 static const struct sctp_paramhdr ecap_param
= {
147 SCTP_PARAM_ECN_CAPABLE
,
148 cpu_to_be16(sizeof(struct sctp_paramhdr
)),
150 static const struct sctp_paramhdr prsctp_param
= {
151 SCTP_PARAM_FWD_TSN_SUPPORT
,
152 cpu_to_be16(sizeof(struct sctp_paramhdr
)),
155 /* A helper to initialize an op error inside a provided chunk, as most
156 * cause codes will be embedded inside an abort chunk.
158 int sctp_init_cause(struct sctp_chunk
*chunk
, __be16 cause_code
,
161 struct sctp_errhdr err
;
164 /* Cause code constants are now defined in network order. */
165 err
.cause
= cause_code
;
166 len
= sizeof(err
) + paylen
;
167 err
.length
= htons(len
);
169 if (skb_tailroom(chunk
->skb
) < len
)
172 chunk
->subh
.err_hdr
= sctp_addto_chunk(chunk
, sizeof(err
), &err
);
177 /* 3.3.2 Initiation (INIT) (1)
179 * This chunk is used to initiate a SCTP association between two
180 * endpoints. The format of the INIT chunk is shown below:
183 * 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
184 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
185 * | Type = 1 | Chunk Flags | Chunk Length |
186 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
188 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
189 * | Advertised Receiver Window Credit (a_rwnd) |
190 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
191 * | Number of Outbound Streams | Number of Inbound Streams |
192 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
194 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
196 * / Optional/Variable-Length Parameters /
198 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
201 * The INIT chunk contains the following parameters. Unless otherwise
202 * noted, each parameter MUST only be included once in the INIT chunk.
204 * Fixed Parameters Status
205 * ----------------------------------------------
206 * Initiate Tag Mandatory
207 * Advertised Receiver Window Credit Mandatory
208 * Number of Outbound Streams Mandatory
209 * Number of Inbound Streams Mandatory
210 * Initial TSN Mandatory
212 * Variable Parameters Status Type Value
213 * -------------------------------------------------------------
214 * IPv4 Address (Note 1) Optional 5
215 * IPv6 Address (Note 1) Optional 6
216 * Cookie Preservative Optional 9
217 * Reserved for ECN Capable (Note 2) Optional 32768 (0x8000)
218 * Host Name Address (Note 3) Optional 11
219 * Supported Address Types (Note 4) Optional 12
221 struct sctp_chunk
*sctp_make_init(const struct sctp_association
*asoc
,
222 const struct sctp_bind_addr
*bp
,
223 gfp_t gfp
, int vparam_len
)
225 struct net
*net
= sock_net(asoc
->base
.sk
);
226 struct sctp_supported_ext_param ext_param
;
227 struct sctp_adaptation_ind_param aiparam
;
228 struct sctp_paramhdr
*auth_chunks
= NULL
;
229 struct sctp_paramhdr
*auth_hmacs
= NULL
;
230 struct sctp_supported_addrs_param sat
;
231 struct sctp_endpoint
*ep
= asoc
->ep
;
232 struct sctp_chunk
*retval
= NULL
;
233 int num_types
, addrs_len
= 0;
234 struct sctp_inithdr init
;
235 union sctp_params addrs
;
236 struct sctp_sock
*sp
;
242 /* RFC 2960 3.3.2 Initiation (INIT) (1)
244 * Note 1: The INIT chunks can contain multiple addresses that
245 * can be IPv4 and/or IPv6 in any combination.
248 /* Convert the provided bind address list to raw format. */
249 addrs
= sctp_bind_addrs_to_raw(bp
, &addrs_len
, gfp
);
251 init
.init_tag
= htonl(asoc
->c
.my_vtag
);
252 init
.a_rwnd
= htonl(asoc
->rwnd
);
253 init
.num_outbound_streams
= htons(asoc
->c
.sinit_num_ostreams
);
254 init
.num_inbound_streams
= htons(asoc
->c
.sinit_max_instreams
);
255 init
.initial_tsn
= htonl(asoc
->c
.initial_tsn
);
257 /* How many address types are needed? */
258 sp
= sctp_sk(asoc
->base
.sk
);
259 num_types
= sp
->pf
->supported_addrs(sp
, types
);
261 chunksize
= sizeof(init
) + addrs_len
;
262 chunksize
+= SCTP_PAD4(SCTP_SAT_LEN(num_types
));
263 chunksize
+= sizeof(ecap_param
);
265 if (asoc
->prsctp_enable
)
266 chunksize
+= sizeof(prsctp_param
);
268 /* ADDIP: Section 4.2.7:
269 * An implementation supporting this extension [ADDIP] MUST list
270 * the ASCONF,the ASCONF-ACK, and the AUTH chunks in its INIT and
271 * INIT-ACK parameters.
273 if (net
->sctp
.addip_enable
) {
274 extensions
[num_ext
] = SCTP_CID_ASCONF
;
275 extensions
[num_ext
+1] = SCTP_CID_ASCONF_ACK
;
279 if (asoc
->reconf_enable
) {
280 extensions
[num_ext
] = SCTP_CID_RECONF
;
284 if (sp
->adaptation_ind
)
285 chunksize
+= sizeof(aiparam
);
287 if (sp
->strm_interleave
) {
288 extensions
[num_ext
] = SCTP_CID_I_DATA
;
292 chunksize
+= vparam_len
;
294 /* Account for AUTH related parameters */
295 if (ep
->auth_enable
) {
296 /* Add random parameter length*/
297 chunksize
+= sizeof(asoc
->c
.auth_random
);
299 /* Add HMACS parameter length if any were defined */
300 auth_hmacs
= (struct sctp_paramhdr
*)asoc
->c
.auth_hmacs
;
301 if (auth_hmacs
->length
)
302 chunksize
+= SCTP_PAD4(ntohs(auth_hmacs
->length
));
306 /* Add CHUNKS parameter length */
307 auth_chunks
= (struct sctp_paramhdr
*)asoc
->c
.auth_chunks
;
308 if (auth_chunks
->length
)
309 chunksize
+= SCTP_PAD4(ntohs(auth_chunks
->length
));
313 extensions
[num_ext
] = SCTP_CID_AUTH
;
317 /* If we have any extensions to report, account for that */
319 chunksize
+= SCTP_PAD4(sizeof(ext_param
) + num_ext
);
321 /* RFC 2960 3.3.2 Initiation (INIT) (1)
323 * Note 3: An INIT chunk MUST NOT contain more than one Host
324 * Name address parameter. Moreover, the sender of the INIT
325 * MUST NOT combine any other address types with the Host Name
326 * address in the INIT. The receiver of INIT MUST ignore any
327 * other address types if the Host Name address parameter is
328 * present in the received INIT chunk.
330 * PLEASE DO NOT FIXME [This version does not support Host Name.]
333 retval
= sctp_make_control(asoc
, SCTP_CID_INIT
, 0, chunksize
, gfp
);
337 retval
->subh
.init_hdr
=
338 sctp_addto_chunk(retval
, sizeof(init
), &init
);
339 retval
->param_hdr
.v
=
340 sctp_addto_chunk(retval
, addrs_len
, addrs
.v
);
342 /* RFC 2960 3.3.2 Initiation (INIT) (1)
344 * Note 4: This parameter, when present, specifies all the
345 * address types the sending endpoint can support. The absence
346 * of this parameter indicates that the sending endpoint can
347 * support any address type.
349 sat
.param_hdr
.type
= SCTP_PARAM_SUPPORTED_ADDRESS_TYPES
;
350 sat
.param_hdr
.length
= htons(SCTP_SAT_LEN(num_types
));
351 sctp_addto_chunk(retval
, sizeof(sat
), &sat
);
352 sctp_addto_chunk(retval
, num_types
* sizeof(__u16
), &types
);
354 sctp_addto_chunk(retval
, sizeof(ecap_param
), &ecap_param
);
356 /* Add the supported extensions parameter. Be nice and add this
357 * fist before addiding the parameters for the extensions themselves
360 ext_param
.param_hdr
.type
= SCTP_PARAM_SUPPORTED_EXT
;
361 ext_param
.param_hdr
.length
= htons(sizeof(ext_param
) + num_ext
);
362 sctp_addto_chunk(retval
, sizeof(ext_param
), &ext_param
);
363 sctp_addto_param(retval
, num_ext
, extensions
);
366 if (asoc
->prsctp_enable
)
367 sctp_addto_chunk(retval
, sizeof(prsctp_param
), &prsctp_param
);
369 if (sp
->adaptation_ind
) {
370 aiparam
.param_hdr
.type
= SCTP_PARAM_ADAPTATION_LAYER_IND
;
371 aiparam
.param_hdr
.length
= htons(sizeof(aiparam
));
372 aiparam
.adaptation_ind
= htonl(sp
->adaptation_ind
);
373 sctp_addto_chunk(retval
, sizeof(aiparam
), &aiparam
);
376 /* Add SCTP-AUTH chunks to the parameter list */
377 if (ep
->auth_enable
) {
378 sctp_addto_chunk(retval
, sizeof(asoc
->c
.auth_random
),
379 asoc
->c
.auth_random
);
381 sctp_addto_chunk(retval
, ntohs(auth_hmacs
->length
),
384 sctp_addto_chunk(retval
, ntohs(auth_chunks
->length
),
392 struct sctp_chunk
*sctp_make_init_ack(const struct sctp_association
*asoc
,
393 const struct sctp_chunk
*chunk
,
394 gfp_t gfp
, int unkparam_len
)
396 struct sctp_supported_ext_param ext_param
;
397 struct sctp_adaptation_ind_param aiparam
;
398 struct sctp_paramhdr
*auth_chunks
= NULL
;
399 struct sctp_paramhdr
*auth_random
= NULL
;
400 struct sctp_paramhdr
*auth_hmacs
= NULL
;
401 struct sctp_chunk
*retval
= NULL
;
402 struct sctp_cookie_param
*cookie
;
403 struct sctp_inithdr initack
;
404 union sctp_params addrs
;
405 struct sctp_sock
*sp
;
412 /* Note: there may be no addresses to embed. */
413 addrs
= sctp_bind_addrs_to_raw(&asoc
->base
.bind_addr
, &addrs_len
, gfp
);
415 initack
.init_tag
= htonl(asoc
->c
.my_vtag
);
416 initack
.a_rwnd
= htonl(asoc
->rwnd
);
417 initack
.num_outbound_streams
= htons(asoc
->c
.sinit_num_ostreams
);
418 initack
.num_inbound_streams
= htons(asoc
->c
.sinit_max_instreams
);
419 initack
.initial_tsn
= htonl(asoc
->c
.initial_tsn
);
421 /* FIXME: We really ought to build the cookie right
422 * into the packet instead of allocating more fresh memory.
424 cookie
= sctp_pack_cookie(asoc
->ep
, asoc
, chunk
, &cookie_len
,
429 /* Calculate the total size of allocation, include the reserved
430 * space for reporting unknown parameters if it is specified.
432 sp
= sctp_sk(asoc
->base
.sk
);
433 chunksize
= sizeof(initack
) + addrs_len
+ cookie_len
+ unkparam_len
;
435 /* Tell peer that we'll do ECN only if peer advertised such cap. */
436 if (asoc
->peer
.ecn_capable
)
437 chunksize
+= sizeof(ecap_param
);
439 if (asoc
->peer
.prsctp_capable
)
440 chunksize
+= sizeof(prsctp_param
);
442 if (asoc
->peer
.asconf_capable
) {
443 extensions
[num_ext
] = SCTP_CID_ASCONF
;
444 extensions
[num_ext
+1] = SCTP_CID_ASCONF_ACK
;
448 if (asoc
->peer
.reconf_capable
) {
449 extensions
[num_ext
] = SCTP_CID_RECONF
;
453 if (sp
->adaptation_ind
)
454 chunksize
+= sizeof(aiparam
);
456 if (asoc
->intl_enable
) {
457 extensions
[num_ext
] = SCTP_CID_I_DATA
;
461 if (asoc
->peer
.auth_capable
) {
462 auth_random
= (struct sctp_paramhdr
*)asoc
->c
.auth_random
;
463 chunksize
+= ntohs(auth_random
->length
);
465 auth_hmacs
= (struct sctp_paramhdr
*)asoc
->c
.auth_hmacs
;
466 if (auth_hmacs
->length
)
467 chunksize
+= SCTP_PAD4(ntohs(auth_hmacs
->length
));
471 auth_chunks
= (struct sctp_paramhdr
*)asoc
->c
.auth_chunks
;
472 if (auth_chunks
->length
)
473 chunksize
+= SCTP_PAD4(ntohs(auth_chunks
->length
));
477 extensions
[num_ext
] = SCTP_CID_AUTH
;
482 chunksize
+= SCTP_PAD4(sizeof(ext_param
) + num_ext
);
484 /* Now allocate and fill out the chunk. */
485 retval
= sctp_make_control(asoc
, SCTP_CID_INIT_ACK
, 0, chunksize
, gfp
);
489 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
491 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
492 * HEARTBEAT ACK, * etc.) to the same destination transport
493 * address from which it received the DATA or control chunk
494 * to which it is replying.
496 * [INIT ACK back to where the INIT came from.]
498 if (chunk
->transport
)
500 sctp_assoc_lookup_paddr(asoc
,
501 &chunk
->transport
->ipaddr
);
503 retval
->subh
.init_hdr
=
504 sctp_addto_chunk(retval
, sizeof(initack
), &initack
);
505 retval
->param_hdr
.v
= sctp_addto_chunk(retval
, addrs_len
, addrs
.v
);
506 sctp_addto_chunk(retval
, cookie_len
, cookie
);
507 if (asoc
->peer
.ecn_capable
)
508 sctp_addto_chunk(retval
, sizeof(ecap_param
), &ecap_param
);
510 ext_param
.param_hdr
.type
= SCTP_PARAM_SUPPORTED_EXT
;
511 ext_param
.param_hdr
.length
= htons(sizeof(ext_param
) + num_ext
);
512 sctp_addto_chunk(retval
, sizeof(ext_param
), &ext_param
);
513 sctp_addto_param(retval
, num_ext
, extensions
);
515 if (asoc
->peer
.prsctp_capable
)
516 sctp_addto_chunk(retval
, sizeof(prsctp_param
), &prsctp_param
);
518 if (sp
->adaptation_ind
) {
519 aiparam
.param_hdr
.type
= SCTP_PARAM_ADAPTATION_LAYER_IND
;
520 aiparam
.param_hdr
.length
= htons(sizeof(aiparam
));
521 aiparam
.adaptation_ind
= htonl(sp
->adaptation_ind
);
522 sctp_addto_chunk(retval
, sizeof(aiparam
), &aiparam
);
525 if (asoc
->peer
.auth_capable
) {
526 sctp_addto_chunk(retval
, ntohs(auth_random
->length
),
529 sctp_addto_chunk(retval
, ntohs(auth_hmacs
->length
),
532 sctp_addto_chunk(retval
, ntohs(auth_chunks
->length
),
536 /* We need to remove the const qualifier at this point. */
537 retval
->asoc
= (struct sctp_association
*) asoc
;
546 /* 3.3.11 Cookie Echo (COOKIE ECHO) (10):
548 * This chunk is used only during the initialization of an association.
549 * It is sent by the initiator of an association to its peer to complete
550 * the initialization process. This chunk MUST precede any DATA chunk
551 * sent within the association, but MAY be bundled with one or more DATA
552 * chunks in the same packet.
555 * 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
556 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
557 * | Type = 10 |Chunk Flags | Length |
558 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
561 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
565 * Set to zero on transmit and ignored on receipt.
567 * Length: 16 bits (unsigned integer)
569 * Set to the size of the chunk in bytes, including the 4 bytes of
570 * the chunk header and the size of the Cookie.
572 * Cookie: variable size
574 * This field must contain the exact cookie received in the
575 * State Cookie parameter from the previous INIT ACK.
577 * An implementation SHOULD make the cookie as small as possible
578 * to insure interoperability.
580 struct sctp_chunk
*sctp_make_cookie_echo(const struct sctp_association
*asoc
,
581 const struct sctp_chunk
*chunk
)
583 struct sctp_chunk
*retval
;
587 cookie
= asoc
->peer
.cookie
;
588 cookie_len
= asoc
->peer
.cookie_len
;
590 /* Build a cookie echo chunk. */
591 retval
= sctp_make_control(asoc
, SCTP_CID_COOKIE_ECHO
, 0,
592 cookie_len
, GFP_ATOMIC
);
595 retval
->subh
.cookie_hdr
=
596 sctp_addto_chunk(retval
, cookie_len
, cookie
);
598 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
600 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
601 * HEARTBEAT ACK, * etc.) to the same destination transport
602 * address from which it * received the DATA or control chunk
603 * to which it is replying.
605 * [COOKIE ECHO back to where the INIT ACK came from.]
608 retval
->transport
= chunk
->transport
;
614 /* 3.3.12 Cookie Acknowledgement (COOKIE ACK) (11):
616 * This chunk is used only during the initialization of an
617 * association. It is used to acknowledge the receipt of a COOKIE
618 * ECHO chunk. This chunk MUST precede any DATA or SACK chunk sent
619 * within the association, but MAY be bundled with one or more DATA
620 * chunks or SACK chunk in the same SCTP packet.
623 * 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
624 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
625 * | Type = 11 |Chunk Flags | Length = 4 |
626 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
628 * Chunk Flags: 8 bits
630 * Set to zero on transmit and ignored on receipt.
632 struct sctp_chunk
*sctp_make_cookie_ack(const struct sctp_association
*asoc
,
633 const struct sctp_chunk
*chunk
)
635 struct sctp_chunk
*retval
;
637 retval
= sctp_make_control(asoc
, SCTP_CID_COOKIE_ACK
, 0, 0, GFP_ATOMIC
);
639 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
641 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
642 * HEARTBEAT ACK, * etc.) to the same destination transport
643 * address from which it * received the DATA or control chunk
644 * to which it is replying.
646 * [COOKIE ACK back to where the COOKIE ECHO came from.]
648 if (retval
&& chunk
&& chunk
->transport
)
650 sctp_assoc_lookup_paddr(asoc
,
651 &chunk
->transport
->ipaddr
);
657 * Appendix A: Explicit Congestion Notification:
660 * RFC 2481 details a specific bit for a sender to send in the header of
661 * its next outbound TCP segment to indicate to its peer that it has
662 * reduced its congestion window. This is termed the CWR bit. For
663 * SCTP the same indication is made by including the CWR chunk.
664 * This chunk contains one data element, i.e. the TSN number that
665 * was sent in the ECNE chunk. This element represents the lowest
666 * TSN number in the datagram that was originally marked with the
670 * 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
671 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
672 * | Chunk Type=13 | Flags=00000000| Chunk Length = 8 |
673 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
674 * | Lowest TSN Number |
675 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
677 * Note: The CWR is considered a Control chunk.
679 struct sctp_chunk
*sctp_make_cwr(const struct sctp_association
*asoc
,
680 const __u32 lowest_tsn
,
681 const struct sctp_chunk
*chunk
)
683 struct sctp_chunk
*retval
;
684 struct sctp_cwrhdr cwr
;
686 cwr
.lowest_tsn
= htonl(lowest_tsn
);
687 retval
= sctp_make_control(asoc
, SCTP_CID_ECN_CWR
, 0,
688 sizeof(cwr
), GFP_ATOMIC
);
693 retval
->subh
.ecn_cwr_hdr
=
694 sctp_addto_chunk(retval
, sizeof(cwr
), &cwr
);
696 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
698 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
699 * HEARTBEAT ACK, * etc.) to the same destination transport
700 * address from which it * received the DATA or control chunk
701 * to which it is replying.
703 * [Report a reduced congestion window back to where the ECNE
707 retval
->transport
= chunk
->transport
;
713 /* Make an ECNE chunk. This is a congestion experienced report. */
714 struct sctp_chunk
*sctp_make_ecne(const struct sctp_association
*asoc
,
715 const __u32 lowest_tsn
)
717 struct sctp_chunk
*retval
;
718 struct sctp_ecnehdr ecne
;
720 ecne
.lowest_tsn
= htonl(lowest_tsn
);
721 retval
= sctp_make_control(asoc
, SCTP_CID_ECN_ECNE
, 0,
722 sizeof(ecne
), GFP_ATOMIC
);
725 retval
->subh
.ecne_hdr
=
726 sctp_addto_chunk(retval
, sizeof(ecne
), &ecne
);
732 /* Make a DATA chunk for the given association from the provided
733 * parameters. However, do not populate the data payload.
735 struct sctp_chunk
*sctp_make_datafrag_empty(const struct sctp_association
*asoc
,
736 const struct sctp_sndrcvinfo
*sinfo
,
737 int len
, __u8 flags
, gfp_t gfp
)
739 struct sctp_chunk
*retval
;
740 struct sctp_datahdr dp
;
742 /* We assign the TSN as LATE as possible, not here when
743 * creating the chunk.
745 memset(&dp
, 0, sizeof(dp
));
746 dp
.ppid
= sinfo
->sinfo_ppid
;
747 dp
.stream
= htons(sinfo
->sinfo_stream
);
749 /* Set the flags for an unordered send. */
750 if (sinfo
->sinfo_flags
& SCTP_UNORDERED
)
751 flags
|= SCTP_DATA_UNORDERED
;
753 retval
= sctp_make_data(asoc
, flags
, sizeof(dp
) + len
, gfp
);
757 retval
->subh
.data_hdr
= sctp_addto_chunk(retval
, sizeof(dp
), &dp
);
758 memcpy(&retval
->sinfo
, sinfo
, sizeof(struct sctp_sndrcvinfo
));
763 /* Create a selective ackowledgement (SACK) for the given
764 * association. This reports on which TSN's we've seen to date,
765 * including duplicates and gaps.
767 struct sctp_chunk
*sctp_make_sack(struct sctp_association
*asoc
)
769 struct sctp_tsnmap
*map
= (struct sctp_tsnmap
*)&asoc
->peer
.tsn_map
;
770 struct sctp_gap_ack_block gabs
[SCTP_MAX_GABS
];
771 __u16 num_gabs
, num_dup_tsns
;
772 struct sctp_transport
*trans
;
773 struct sctp_chunk
*retval
;
774 struct sctp_sackhdr sack
;
778 memset(gabs
, 0, sizeof(gabs
));
779 ctsn
= sctp_tsnmap_get_ctsn(map
);
781 pr_debug("%s: sackCTSNAck sent:0x%x\n", __func__
, ctsn
);
783 /* How much room is needed in the chunk? */
784 num_gabs
= sctp_tsnmap_num_gabs(map
, gabs
);
785 num_dup_tsns
= sctp_tsnmap_num_dups(map
);
787 /* Initialize the SACK header. */
788 sack
.cum_tsn_ack
= htonl(ctsn
);
789 sack
.a_rwnd
= htonl(asoc
->a_rwnd
);
790 sack
.num_gap_ack_blocks
= htons(num_gabs
);
791 sack
.num_dup_tsns
= htons(num_dup_tsns
);
794 + sizeof(struct sctp_gap_ack_block
) * num_gabs
795 + sizeof(__u32
) * num_dup_tsns
;
797 /* Create the chunk. */
798 retval
= sctp_make_control(asoc
, SCTP_CID_SACK
, 0, len
, GFP_ATOMIC
);
802 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
804 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
805 * HEARTBEAT ACK, etc.) to the same destination transport
806 * address from which it received the DATA or control chunk to
807 * which it is replying. This rule should also be followed if
808 * the endpoint is bundling DATA chunks together with the
811 * However, when acknowledging multiple DATA chunks received
812 * in packets from different source addresses in a single
813 * SACK, the SACK chunk may be transmitted to one of the
814 * destination transport addresses from which the DATA or
815 * control chunks being acknowledged were received.
817 * [BUG: We do not implement the following paragraph.
818 * Perhaps we should remember the last transport we used for a
819 * SACK and avoid that (if possible) if we have seen any
820 * duplicates. --piggy]
822 * When a receiver of a duplicate DATA chunk sends a SACK to a
823 * multi- homed endpoint it MAY be beneficial to vary the
824 * destination address and not use the source address of the
825 * DATA chunk. The reason being that receiving a duplicate
826 * from a multi-homed endpoint might indicate that the return
827 * path (as specified in the source address of the DATA chunk)
828 * for the SACK is broken.
830 * [Send to the address from which we last received a DATA chunk.]
832 retval
->transport
= asoc
->peer
.last_data_from
;
834 retval
->subh
.sack_hdr
=
835 sctp_addto_chunk(retval
, sizeof(sack
), &sack
);
837 /* Add the gap ack block information. */
839 sctp_addto_chunk(retval
, sizeof(__u32
) * num_gabs
,
842 /* Add the duplicate TSN information. */
844 asoc
->stats
.idupchunks
+= num_dup_tsns
;
845 sctp_addto_chunk(retval
, sizeof(__u32
) * num_dup_tsns
,
846 sctp_tsnmap_get_dups(map
));
848 /* Once we have a sack generated, check to see what our sack
849 * generation is, if its 0, reset the transports to 0, and reset
850 * the association generation to 1
852 * The idea is that zero is never used as a valid generation for the
853 * association so no transport will match after a wrap event like this,
854 * Until the next sack
856 if (++asoc
->peer
.sack_generation
== 0) {
857 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
859 trans
->sack_generation
= 0;
860 asoc
->peer
.sack_generation
= 1;
866 /* Make a SHUTDOWN chunk. */
867 struct sctp_chunk
*sctp_make_shutdown(const struct sctp_association
*asoc
,
868 const struct sctp_chunk
*chunk
)
870 struct sctp_shutdownhdr shut
;
871 struct sctp_chunk
*retval
;
874 ctsn
= sctp_tsnmap_get_ctsn(&asoc
->peer
.tsn_map
);
875 shut
.cum_tsn_ack
= htonl(ctsn
);
877 retval
= sctp_make_control(asoc
, SCTP_CID_SHUTDOWN
, 0,
878 sizeof(shut
), GFP_ATOMIC
);
882 retval
->subh
.shutdown_hdr
=
883 sctp_addto_chunk(retval
, sizeof(shut
), &shut
);
886 retval
->transport
= chunk
->transport
;
891 struct sctp_chunk
*sctp_make_shutdown_ack(const struct sctp_association
*asoc
,
892 const struct sctp_chunk
*chunk
)
894 struct sctp_chunk
*retval
;
896 retval
= sctp_make_control(asoc
, SCTP_CID_SHUTDOWN_ACK
, 0, 0,
899 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
901 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
902 * HEARTBEAT ACK, * etc.) to the same destination transport
903 * address from which it * received the DATA or control chunk
904 * to which it is replying.
906 * [ACK back to where the SHUTDOWN came from.]
909 retval
->transport
= chunk
->transport
;
914 struct sctp_chunk
*sctp_make_shutdown_complete(
915 const struct sctp_association
*asoc
,
916 const struct sctp_chunk
*chunk
)
918 struct sctp_chunk
*retval
;
921 /* Set the T-bit if we have no association (vtag will be
924 flags
|= asoc
? 0 : SCTP_CHUNK_FLAG_T
;
926 retval
= sctp_make_control(asoc
, SCTP_CID_SHUTDOWN_COMPLETE
, flags
,
929 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
931 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
932 * HEARTBEAT ACK, * etc.) to the same destination transport
933 * address from which it * received the DATA or control chunk
934 * to which it is replying.
936 * [Report SHUTDOWN COMPLETE back to where the SHUTDOWN ACK
940 retval
->transport
= chunk
->transport
;
945 /* Create an ABORT. Note that we set the T bit if we have no
946 * association, except when responding to an INIT (sctpimpguide 2.41).
948 struct sctp_chunk
*sctp_make_abort(const struct sctp_association
*asoc
,
949 const struct sctp_chunk
*chunk
,
952 struct sctp_chunk
*retval
;
955 /* Set the T-bit if we have no association and 'chunk' is not
956 * an INIT (vtag will be reflected).
959 if (chunk
&& chunk
->chunk_hdr
&&
960 chunk
->chunk_hdr
->type
== SCTP_CID_INIT
)
963 flags
= SCTP_CHUNK_FLAG_T
;
966 retval
= sctp_make_control(asoc
, SCTP_CID_ABORT
, flags
, hint
,
969 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
971 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
972 * HEARTBEAT ACK, * etc.) to the same destination transport
973 * address from which it * received the DATA or control chunk
974 * to which it is replying.
976 * [ABORT back to where the offender came from.]
979 retval
->transport
= chunk
->transport
;
984 /* Helper to create ABORT with a NO_USER_DATA error. */
985 struct sctp_chunk
*sctp_make_abort_no_data(
986 const struct sctp_association
*asoc
,
987 const struct sctp_chunk
*chunk
,
990 struct sctp_chunk
*retval
;
993 retval
= sctp_make_abort(asoc
, chunk
,
994 sizeof(struct sctp_errhdr
) + sizeof(tsn
));
999 /* Put the tsn back into network byte order. */
1000 payload
= htonl(tsn
);
1001 sctp_init_cause(retval
, SCTP_ERROR_NO_DATA
, sizeof(payload
));
1002 sctp_addto_chunk(retval
, sizeof(payload
), (const void *)&payload
);
1004 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1006 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1007 * HEARTBEAT ACK, * etc.) to the same destination transport
1008 * address from which it * received the DATA or control chunk
1009 * to which it is replying.
1011 * [ABORT back to where the offender came from.]
1014 retval
->transport
= chunk
->transport
;
1020 /* Helper to create ABORT with a SCTP_ERROR_USER_ABORT error. */
1021 struct sctp_chunk
*sctp_make_abort_user(const struct sctp_association
*asoc
,
1025 struct sctp_chunk
*retval
;
1026 void *payload
= NULL
;
1029 retval
= sctp_make_abort(asoc
, NULL
,
1030 sizeof(struct sctp_errhdr
) + paylen
);
1035 /* Put the msg_iov together into payload. */
1036 payload
= kmalloc(paylen
, GFP_KERNEL
);
1040 err
= memcpy_from_msg(payload
, msg
, paylen
);
1045 sctp_init_cause(retval
, SCTP_ERROR_USER_ABORT
, paylen
);
1046 sctp_addto_chunk(retval
, paylen
, payload
);
1056 sctp_chunk_free(retval
);
1062 /* Append bytes to the end of a parameter. Will panic if chunk is not big
1065 static void *sctp_addto_param(struct sctp_chunk
*chunk
, int len
,
1068 int chunklen
= ntohs(chunk
->chunk_hdr
->length
);
1071 target
= skb_put(chunk
->skb
, len
);
1074 memcpy(target
, data
, len
);
1076 memset(target
, 0, len
);
1078 /* Adjust the chunk length field. */
1079 chunk
->chunk_hdr
->length
= htons(chunklen
+ len
);
1080 chunk
->chunk_end
= skb_tail_pointer(chunk
->skb
);
1085 /* Make an ABORT chunk with a PROTOCOL VIOLATION cause code. */
1086 struct sctp_chunk
*sctp_make_abort_violation(
1087 const struct sctp_association
*asoc
,
1088 const struct sctp_chunk
*chunk
,
1089 const __u8
*payload
,
1090 const size_t paylen
)
1092 struct sctp_chunk
*retval
;
1093 struct sctp_paramhdr phdr
;
1095 retval
= sctp_make_abort(asoc
, chunk
, sizeof(struct sctp_errhdr
) +
1096 paylen
+ sizeof(phdr
));
1100 sctp_init_cause(retval
, SCTP_ERROR_PROTO_VIOLATION
, paylen
+
1103 phdr
.type
= htons(chunk
->chunk_hdr
->type
);
1104 phdr
.length
= chunk
->chunk_hdr
->length
;
1105 sctp_addto_chunk(retval
, paylen
, payload
);
1106 sctp_addto_param(retval
, sizeof(phdr
), &phdr
);
1112 struct sctp_chunk
*sctp_make_violation_paramlen(
1113 const struct sctp_association
*asoc
,
1114 const struct sctp_chunk
*chunk
,
1115 struct sctp_paramhdr
*param
)
1117 static const char error
[] = "The following parameter had invalid length:";
1118 size_t payload_len
= sizeof(error
) + sizeof(struct sctp_errhdr
) +
1120 struct sctp_chunk
*retval
;
1122 retval
= sctp_make_abort(asoc
, chunk
, payload_len
);
1126 sctp_init_cause(retval
, SCTP_ERROR_PROTO_VIOLATION
,
1127 sizeof(error
) + sizeof(*param
));
1128 sctp_addto_chunk(retval
, sizeof(error
), error
);
1129 sctp_addto_param(retval
, sizeof(*param
), param
);
1135 struct sctp_chunk
*sctp_make_violation_max_retrans(
1136 const struct sctp_association
*asoc
,
1137 const struct sctp_chunk
*chunk
)
1139 static const char error
[] = "Association exceeded its max_retrans count";
1140 size_t payload_len
= sizeof(error
) + sizeof(struct sctp_errhdr
);
1141 struct sctp_chunk
*retval
;
1143 retval
= sctp_make_abort(asoc
, chunk
, payload_len
);
1147 sctp_init_cause(retval
, SCTP_ERROR_PROTO_VIOLATION
, sizeof(error
));
1148 sctp_addto_chunk(retval
, sizeof(error
), error
);
1154 /* Make a HEARTBEAT chunk. */
1155 struct sctp_chunk
*sctp_make_heartbeat(const struct sctp_association
*asoc
,
1156 const struct sctp_transport
*transport
)
1158 struct sctp_sender_hb_info hbinfo
;
1159 struct sctp_chunk
*retval
;
1161 retval
= sctp_make_control(asoc
, SCTP_CID_HEARTBEAT
, 0,
1162 sizeof(hbinfo
), GFP_ATOMIC
);
1167 hbinfo
.param_hdr
.type
= SCTP_PARAM_HEARTBEAT_INFO
;
1168 hbinfo
.param_hdr
.length
= htons(sizeof(hbinfo
));
1169 hbinfo
.daddr
= transport
->ipaddr
;
1170 hbinfo
.sent_at
= jiffies
;
1171 hbinfo
.hb_nonce
= transport
->hb_nonce
;
1173 /* Cast away the 'const', as this is just telling the chunk
1174 * what transport it belongs to.
1176 retval
->transport
= (struct sctp_transport
*) transport
;
1177 retval
->subh
.hbs_hdr
= sctp_addto_chunk(retval
, sizeof(hbinfo
),
1184 struct sctp_chunk
*sctp_make_heartbeat_ack(const struct sctp_association
*asoc
,
1185 const struct sctp_chunk
*chunk
,
1186 const void *payload
,
1187 const size_t paylen
)
1189 struct sctp_chunk
*retval
;
1191 retval
= sctp_make_control(asoc
, SCTP_CID_HEARTBEAT_ACK
, 0, paylen
,
1196 retval
->subh
.hbs_hdr
= sctp_addto_chunk(retval
, paylen
, payload
);
1198 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1200 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1201 * HEARTBEAT ACK, * etc.) to the same destination transport
1202 * address from which it * received the DATA or control chunk
1203 * to which it is replying.
1205 * [HBACK back to where the HEARTBEAT came from.]
1208 retval
->transport
= chunk
->transport
;
1214 /* Create an Operation Error chunk with the specified space reserved.
1215 * This routine can be used for containing multiple causes in the chunk.
1217 static struct sctp_chunk
*sctp_make_op_error_space(
1218 const struct sctp_association
*asoc
,
1219 const struct sctp_chunk
*chunk
,
1222 struct sctp_chunk
*retval
;
1224 retval
= sctp_make_control(asoc
, SCTP_CID_ERROR
, 0,
1225 sizeof(struct sctp_errhdr
) + size
,
1230 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1232 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1233 * HEARTBEAT ACK, etc.) to the same destination transport
1234 * address from which it received the DATA or control chunk
1235 * to which it is replying.
1239 retval
->transport
= chunk
->transport
;
1245 /* Create an Operation Error chunk of a fixed size, specifically,
1246 * min(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT) - overheads.
1247 * This is a helper function to allocate an error chunk for for those
1248 * invalid parameter codes in which we may not want to report all the
1249 * errors, if the incoming chunk is large. If it can't fit in a single
1250 * packet, we ignore it.
1252 static inline struct sctp_chunk
*sctp_make_op_error_limited(
1253 const struct sctp_association
*asoc
,
1254 const struct sctp_chunk
*chunk
)
1256 size_t size
= SCTP_DEFAULT_MAXSEGMENT
;
1257 struct sctp_sock
*sp
= NULL
;
1260 size
= min_t(size_t, size
, asoc
->pathmtu
);
1261 sp
= sctp_sk(asoc
->base
.sk
);
1264 size
= sctp_mtu_payload(sp
, size
, sizeof(struct sctp_errhdr
));
1266 return sctp_make_op_error_space(asoc
, chunk
, size
);
1269 /* Create an Operation Error chunk. */
1270 struct sctp_chunk
*sctp_make_op_error(const struct sctp_association
*asoc
,
1271 const struct sctp_chunk
*chunk
,
1272 __be16 cause_code
, const void *payload
,
1273 size_t paylen
, size_t reserve_tail
)
1275 struct sctp_chunk
*retval
;
1277 retval
= sctp_make_op_error_space(asoc
, chunk
, paylen
+ reserve_tail
);
1281 sctp_init_cause(retval
, cause_code
, paylen
+ reserve_tail
);
1282 sctp_addto_chunk(retval
, paylen
, payload
);
1284 sctp_addto_param(retval
, reserve_tail
, NULL
);
1290 struct sctp_chunk
*sctp_make_auth(const struct sctp_association
*asoc
,
1293 struct sctp_authhdr auth_hdr
;
1294 struct sctp_hmac
*hmac_desc
;
1295 struct sctp_chunk
*retval
;
1297 /* Get the first hmac that the peer told us to use */
1298 hmac_desc
= sctp_auth_asoc_get_hmac(asoc
);
1299 if (unlikely(!hmac_desc
))
1302 retval
= sctp_make_control(asoc
, SCTP_CID_AUTH
, 0,
1303 hmac_desc
->hmac_len
+ sizeof(auth_hdr
),
1308 auth_hdr
.hmac_id
= htons(hmac_desc
->hmac_id
);
1309 auth_hdr
.shkey_id
= htons(key_id
);
1311 retval
->subh
.auth_hdr
= sctp_addto_chunk(retval
, sizeof(auth_hdr
),
1314 skb_put_zero(retval
->skb
, hmac_desc
->hmac_len
);
1316 /* Adjust the chunk header to include the empty MAC */
1317 retval
->chunk_hdr
->length
=
1318 htons(ntohs(retval
->chunk_hdr
->length
) + hmac_desc
->hmac_len
);
1319 retval
->chunk_end
= skb_tail_pointer(retval
->skb
);
1325 /********************************************************************
1326 * 2nd Level Abstractions
1327 ********************************************************************/
1329 /* Turn an skb into a chunk.
1330 * FIXME: Eventually move the structure directly inside the skb->cb[].
1332 * sctpimpguide-05.txt Section 2.8.2
1333 * M1) Each time a new DATA chunk is transmitted
1334 * set the 'TSN.Missing.Report' count for that TSN to 0. The
1335 * 'TSN.Missing.Report' count will be used to determine missing chunks
1336 * and when to fast retransmit.
1339 struct sctp_chunk
*sctp_chunkify(struct sk_buff
*skb
,
1340 const struct sctp_association
*asoc
,
1341 struct sock
*sk
, gfp_t gfp
)
1343 struct sctp_chunk
*retval
;
1345 retval
= kmem_cache_zalloc(sctp_chunk_cachep
, gfp
);
1350 pr_debug("%s: chunkifying skb:%p w/o an sk\n", __func__
, skb
);
1352 INIT_LIST_HEAD(&retval
->list
);
1354 retval
->asoc
= (struct sctp_association
*)asoc
;
1355 retval
->singleton
= 1;
1357 retval
->fast_retransmit
= SCTP_CAN_FRTX
;
1359 /* Polish the bead hole. */
1360 INIT_LIST_HEAD(&retval
->transmitted_list
);
1361 INIT_LIST_HEAD(&retval
->frag_list
);
1362 SCTP_DBG_OBJCNT_INC(chunk
);
1363 refcount_set(&retval
->refcnt
, 1);
1369 /* Set chunk->source and dest based on the IP header in chunk->skb. */
1370 void sctp_init_addrs(struct sctp_chunk
*chunk
, union sctp_addr
*src
,
1371 union sctp_addr
*dest
)
1373 memcpy(&chunk
->source
, src
, sizeof(union sctp_addr
));
1374 memcpy(&chunk
->dest
, dest
, sizeof(union sctp_addr
));
1377 /* Extract the source address from a chunk. */
1378 const union sctp_addr
*sctp_source(const struct sctp_chunk
*chunk
)
1380 /* If we have a known transport, use that. */
1381 if (chunk
->transport
) {
1382 return &chunk
->transport
->ipaddr
;
1384 /* Otherwise, extract it from the IP header. */
1385 return &chunk
->source
;
1389 /* Create a new chunk, setting the type and flags headers from the
1390 * arguments, reserving enough space for a 'paylen' byte payload.
1392 static struct sctp_chunk
*_sctp_make_chunk(const struct sctp_association
*asoc
,
1393 __u8 type
, __u8 flags
, int paylen
,
1396 struct sctp_chunkhdr
*chunk_hdr
;
1397 struct sctp_chunk
*retval
;
1398 struct sk_buff
*skb
;
1402 chunklen
= SCTP_PAD4(sizeof(*chunk_hdr
) + paylen
);
1403 if (chunklen
> SCTP_MAX_CHUNK_LEN
)
1406 /* No need to allocate LL here, as this is only a chunk. */
1407 skb
= alloc_skb(chunklen
, gfp
);
1411 /* Make room for the chunk header. */
1412 chunk_hdr
= (struct sctp_chunkhdr
*)skb_put(skb
, sizeof(*chunk_hdr
));
1413 chunk_hdr
->type
= type
;
1414 chunk_hdr
->flags
= flags
;
1415 chunk_hdr
->length
= htons(sizeof(*chunk_hdr
));
1417 sk
= asoc
? asoc
->base
.sk
: NULL
;
1418 retval
= sctp_chunkify(skb
, asoc
, sk
, gfp
);
1424 retval
->chunk_hdr
= chunk_hdr
;
1425 retval
->chunk_end
= ((__u8
*)chunk_hdr
) + sizeof(*chunk_hdr
);
1427 /* Determine if the chunk needs to be authenticated */
1428 if (sctp_auth_send_cid(type
, asoc
))
1436 static struct sctp_chunk
*sctp_make_data(const struct sctp_association
*asoc
,
1437 __u8 flags
, int paylen
, gfp_t gfp
)
1439 return _sctp_make_chunk(asoc
, SCTP_CID_DATA
, flags
, paylen
, gfp
);
1442 struct sctp_chunk
*sctp_make_idata(const struct sctp_association
*asoc
,
1443 __u8 flags
, int paylen
, gfp_t gfp
)
1445 return _sctp_make_chunk(asoc
, SCTP_CID_I_DATA
, flags
, paylen
, gfp
);
1448 static struct sctp_chunk
*sctp_make_control(const struct sctp_association
*asoc
,
1449 __u8 type
, __u8 flags
, int paylen
,
1452 struct sctp_chunk
*chunk
;
1454 chunk
= _sctp_make_chunk(asoc
, type
, flags
, paylen
, gfp
);
1456 sctp_control_set_owner_w(chunk
);
1461 /* Release the memory occupied by a chunk. */
1462 static void sctp_chunk_destroy(struct sctp_chunk
*chunk
)
1464 BUG_ON(!list_empty(&chunk
->list
));
1465 list_del_init(&chunk
->transmitted_list
);
1467 consume_skb(chunk
->skb
);
1468 consume_skb(chunk
->auth_chunk
);
1470 SCTP_DBG_OBJCNT_DEC(chunk
);
1471 kmem_cache_free(sctp_chunk_cachep
, chunk
);
1474 /* Possibly, free the chunk. */
1475 void sctp_chunk_free(struct sctp_chunk
*chunk
)
1477 /* Release our reference on the message tracker. */
1479 sctp_datamsg_put(chunk
->msg
);
1481 sctp_chunk_put(chunk
);
1484 /* Grab a reference to the chunk. */
1485 void sctp_chunk_hold(struct sctp_chunk
*ch
)
1487 refcount_inc(&ch
->refcnt
);
1490 /* Release a reference to the chunk. */
1491 void sctp_chunk_put(struct sctp_chunk
*ch
)
1493 if (refcount_dec_and_test(&ch
->refcnt
))
1494 sctp_chunk_destroy(ch
);
1497 /* Append bytes to the end of a chunk. Will panic if chunk is not big
1500 void *sctp_addto_chunk(struct sctp_chunk
*chunk
, int len
, const void *data
)
1502 int chunklen
= ntohs(chunk
->chunk_hdr
->length
);
1503 int padlen
= SCTP_PAD4(chunklen
) - chunklen
;
1506 skb_put_zero(chunk
->skb
, padlen
);
1507 target
= skb_put_data(chunk
->skb
, data
, len
);
1509 /* Adjust the chunk length field. */
1510 chunk
->chunk_hdr
->length
= htons(chunklen
+ padlen
+ len
);
1511 chunk
->chunk_end
= skb_tail_pointer(chunk
->skb
);
1516 /* Append bytes from user space to the end of a chunk. Will panic if
1517 * chunk is not big enough.
1518 * Returns a kernel err value.
1520 int sctp_user_addto_chunk(struct sctp_chunk
*chunk
, int len
,
1521 struct iov_iter
*from
)
1525 /* Make room in chunk for data. */
1526 target
= skb_put(chunk
->skb
, len
);
1528 /* Copy data (whole iovec) into chunk */
1529 if (!copy_from_iter_full(target
, len
, from
))
1532 /* Adjust the chunk length field. */
1533 chunk
->chunk_hdr
->length
=
1534 htons(ntohs(chunk
->chunk_hdr
->length
) + len
);
1535 chunk
->chunk_end
= skb_tail_pointer(chunk
->skb
);
1540 /* Helper function to assign a TSN if needed. This assumes that both
1541 * the data_hdr and association have already been assigned.
1543 void sctp_chunk_assign_ssn(struct sctp_chunk
*chunk
)
1545 struct sctp_stream
*stream
;
1546 struct sctp_chunk
*lchunk
;
1547 struct sctp_datamsg
*msg
;
1553 /* All fragments will be on the same stream */
1554 sid
= ntohs(chunk
->subh
.data_hdr
->stream
);
1555 stream
= &chunk
->asoc
->stream
;
1557 /* Now assign the sequence number to the entire message.
1558 * All fragments must have the same stream sequence number.
1561 list_for_each_entry(lchunk
, &msg
->chunks
, frag_list
) {
1562 if (lchunk
->chunk_hdr
->flags
& SCTP_DATA_UNORDERED
) {
1565 if (lchunk
->chunk_hdr
->flags
& SCTP_DATA_LAST_FRAG
)
1566 ssn
= sctp_ssn_next(stream
, out
, sid
);
1568 ssn
= sctp_ssn_peek(stream
, out
, sid
);
1571 lchunk
->subh
.data_hdr
->ssn
= htons(ssn
);
1572 lchunk
->has_ssn
= 1;
1576 /* Helper function to assign a TSN if needed. This assumes that both
1577 * the data_hdr and association have already been assigned.
1579 void sctp_chunk_assign_tsn(struct sctp_chunk
*chunk
)
1581 if (!chunk
->has_tsn
) {
1582 /* This is the last possible instant to
1585 chunk
->subh
.data_hdr
->tsn
=
1586 htonl(sctp_association_get_next_tsn(chunk
->asoc
));
1591 /* Create a CLOSED association to use with an incoming packet. */
1592 struct sctp_association
*sctp_make_temp_asoc(const struct sctp_endpoint
*ep
,
1593 struct sctp_chunk
*chunk
,
1596 struct sctp_association
*asoc
;
1597 enum sctp_scope scope
;
1598 struct sk_buff
*skb
;
1600 /* Create the bare association. */
1601 scope
= sctp_scope(sctp_source(chunk
));
1602 asoc
= sctp_association_new(ep
, ep
->base
.sk
, scope
, gfp
);
1607 /* Create an entry for the source address of the packet. */
1608 SCTP_INPUT_CB(skb
)->af
->from_skb(&asoc
->c
.peer_addr
, skb
, 1);
1614 /* Build a cookie representing asoc.
1615 * This INCLUDES the param header needed to put the cookie in the INIT ACK.
1617 static struct sctp_cookie_param
*sctp_pack_cookie(
1618 const struct sctp_endpoint
*ep
,
1619 const struct sctp_association
*asoc
,
1620 const struct sctp_chunk
*init_chunk
,
1621 int *cookie_len
, const __u8
*raw_addrs
,
1624 struct sctp_signed_cookie
*cookie
;
1625 struct sctp_cookie_param
*retval
;
1626 int headersize
, bodysize
;
1628 /* Header size is static data prior to the actual cookie, including
1631 headersize
= sizeof(struct sctp_paramhdr
) +
1632 (sizeof(struct sctp_signed_cookie
) -
1633 sizeof(struct sctp_cookie
));
1634 bodysize
= sizeof(struct sctp_cookie
)
1635 + ntohs(init_chunk
->chunk_hdr
->length
) + addrs_len
;
1637 /* Pad out the cookie to a multiple to make the signature
1638 * functions simpler to write.
1640 if (bodysize
% SCTP_COOKIE_MULTIPLE
)
1641 bodysize
+= SCTP_COOKIE_MULTIPLE
1642 - (bodysize
% SCTP_COOKIE_MULTIPLE
);
1643 *cookie_len
= headersize
+ bodysize
;
1645 /* Clear this memory since we are sending this data structure
1646 * out on the network.
1648 retval
= kzalloc(*cookie_len
, GFP_ATOMIC
);
1652 cookie
= (struct sctp_signed_cookie
*) retval
->body
;
1654 /* Set up the parameter header. */
1655 retval
->p
.type
= SCTP_PARAM_STATE_COOKIE
;
1656 retval
->p
.length
= htons(*cookie_len
);
1658 /* Copy the cookie part of the association itself. */
1659 cookie
->c
= asoc
->c
;
1660 /* Save the raw address list length in the cookie. */
1661 cookie
->c
.raw_addr_list_len
= addrs_len
;
1663 /* Remember PR-SCTP capability. */
1664 cookie
->c
.prsctp_capable
= asoc
->peer
.prsctp_capable
;
1666 /* Save adaptation indication in the cookie. */
1667 cookie
->c
.adaptation_ind
= asoc
->peer
.adaptation_ind
;
1669 /* Set an expiration time for the cookie. */
1670 cookie
->c
.expiration
= ktime_add(asoc
->cookie_life
,
1673 /* Copy the peer's init packet. */
1674 memcpy(&cookie
->c
.peer_init
[0], init_chunk
->chunk_hdr
,
1675 ntohs(init_chunk
->chunk_hdr
->length
));
1677 /* Copy the raw local address list of the association. */
1678 memcpy((__u8
*)&cookie
->c
.peer_init
[0] +
1679 ntohs(init_chunk
->chunk_hdr
->length
), raw_addrs
, addrs_len
);
1681 if (sctp_sk(ep
->base
.sk
)->hmac
) {
1682 SHASH_DESC_ON_STACK(desc
, sctp_sk(ep
->base
.sk
)->hmac
);
1685 /* Sign the message. */
1686 desc
->tfm
= sctp_sk(ep
->base
.sk
)->hmac
;
1689 err
= crypto_shash_setkey(desc
->tfm
, ep
->secret_key
,
1690 sizeof(ep
->secret_key
)) ?:
1691 crypto_shash_digest(desc
, (u8
*)&cookie
->c
, bodysize
,
1693 shash_desc_zero(desc
);
1707 /* Unpack the cookie from COOKIE ECHO chunk, recreating the association. */
1708 struct sctp_association
*sctp_unpack_cookie(
1709 const struct sctp_endpoint
*ep
,
1710 const struct sctp_association
*asoc
,
1711 struct sctp_chunk
*chunk
, gfp_t gfp
,
1712 int *error
, struct sctp_chunk
**errp
)
1714 struct sctp_association
*retval
= NULL
;
1715 int headersize
, bodysize
, fixed_size
;
1716 struct sctp_signed_cookie
*cookie
;
1717 struct sk_buff
*skb
= chunk
->skb
;
1718 struct sctp_cookie
*bear_cookie
;
1719 __u8
*digest
= ep
->digest
;
1720 enum sctp_scope scope
;
1724 /* Header size is static data prior to the actual cookie, including
1727 headersize
= sizeof(struct sctp_chunkhdr
) +
1728 (sizeof(struct sctp_signed_cookie
) -
1729 sizeof(struct sctp_cookie
));
1730 bodysize
= ntohs(chunk
->chunk_hdr
->length
) - headersize
;
1731 fixed_size
= headersize
+ sizeof(struct sctp_cookie
);
1733 /* Verify that the chunk looks like it even has a cookie.
1734 * There must be enough room for our cookie and our peer's
1737 len
= ntohs(chunk
->chunk_hdr
->length
);
1738 if (len
< fixed_size
+ sizeof(struct sctp_chunkhdr
))
1741 /* Verify that the cookie has been padded out. */
1742 if (bodysize
% SCTP_COOKIE_MULTIPLE
)
1745 /* Process the cookie. */
1746 cookie
= chunk
->subh
.cookie_hdr
;
1747 bear_cookie
= &cookie
->c
;
1749 if (!sctp_sk(ep
->base
.sk
)->hmac
)
1752 /* Check the signature. */
1754 SHASH_DESC_ON_STACK(desc
, sctp_sk(ep
->base
.sk
)->hmac
);
1757 desc
->tfm
= sctp_sk(ep
->base
.sk
)->hmac
;
1760 err
= crypto_shash_setkey(desc
->tfm
, ep
->secret_key
,
1761 sizeof(ep
->secret_key
)) ?:
1762 crypto_shash_digest(desc
, (u8
*)bear_cookie
, bodysize
,
1764 shash_desc_zero(desc
);
1767 *error
= -SCTP_IERROR_NOMEM
;
1772 if (memcmp(digest
, cookie
->signature
, SCTP_SIGNATURE_SIZE
)) {
1773 *error
= -SCTP_IERROR_BAD_SIG
;
1778 /* IG Section 2.35.2:
1779 * 3) Compare the port numbers and the verification tag contained
1780 * within the COOKIE ECHO chunk to the actual port numbers and the
1781 * verification tag within the SCTP common header of the received
1782 * packet. If these values do not match the packet MUST be silently
1785 if (ntohl(chunk
->sctp_hdr
->vtag
) != bear_cookie
->my_vtag
) {
1786 *error
= -SCTP_IERROR_BAD_TAG
;
1790 if (chunk
->sctp_hdr
->source
!= bear_cookie
->peer_addr
.v4
.sin_port
||
1791 ntohs(chunk
->sctp_hdr
->dest
) != bear_cookie
->my_port
) {
1792 *error
= -SCTP_IERROR_BAD_PORTS
;
1796 /* Check to see if the cookie is stale. If there is already
1797 * an association, there is no need to check cookie's expiration
1798 * for init collision case of lost COOKIE ACK.
1799 * If skb has been timestamped, then use the stamp, otherwise
1800 * use current time. This introduces a small possibility that
1801 * that a cookie may be considered expired, but his would only slow
1802 * down the new association establishment instead of every packet.
1804 if (sock_flag(ep
->base
.sk
, SOCK_TIMESTAMP
))
1805 kt
= skb_get_ktime(skb
);
1807 kt
= ktime_get_real();
1809 if (!asoc
&& ktime_before(bear_cookie
->expiration
, kt
)) {
1810 suseconds_t usecs
= ktime_to_us(ktime_sub(kt
, bear_cookie
->expiration
));
1811 __be32 n
= htonl(usecs
);
1814 * Section 3.3.10.3 Stale Cookie Error (3)
1818 * Stale Cookie Error: Indicates the receipt of a valid State
1819 * Cookie that has expired.
1821 *errp
= sctp_make_op_error(asoc
, chunk
,
1822 SCTP_ERROR_STALE_COOKIE
, &n
,
1825 *error
= -SCTP_IERROR_STALE_COOKIE
;
1827 *error
= -SCTP_IERROR_NOMEM
;
1832 /* Make a new base association. */
1833 scope
= sctp_scope(sctp_source(chunk
));
1834 retval
= sctp_association_new(ep
, ep
->base
.sk
, scope
, gfp
);
1836 *error
= -SCTP_IERROR_NOMEM
;
1840 /* Set up our peer's port number. */
1841 retval
->peer
.port
= ntohs(chunk
->sctp_hdr
->source
);
1843 /* Populate the association from the cookie. */
1844 memcpy(&retval
->c
, bear_cookie
, sizeof(*bear_cookie
));
1846 if (sctp_assoc_set_bind_addr_from_cookie(retval
, bear_cookie
,
1848 *error
= -SCTP_IERROR_NOMEM
;
1852 /* Also, add the destination address. */
1853 if (list_empty(&retval
->base
.bind_addr
.address_list
)) {
1854 sctp_add_bind_addr(&retval
->base
.bind_addr
, &chunk
->dest
,
1855 sizeof(chunk
->dest
), SCTP_ADDR_SRC
,
1859 retval
->next_tsn
= retval
->c
.initial_tsn
;
1860 retval
->ctsn_ack_point
= retval
->next_tsn
- 1;
1861 retval
->addip_serial
= retval
->c
.initial_tsn
;
1862 retval
->strreset_outseq
= retval
->c
.initial_tsn
;
1863 retval
->adv_peer_ack_point
= retval
->ctsn_ack_point
;
1864 retval
->peer
.prsctp_capable
= retval
->c
.prsctp_capable
;
1865 retval
->peer
.adaptation_ind
= retval
->c
.adaptation_ind
;
1867 /* The INIT stuff will be done by the side effects. */
1872 sctp_association_free(retval
);
1877 /* Yikes! The packet is either corrupt or deliberately
1880 *error
= -SCTP_IERROR_MALFORMED
;
1884 /********************************************************************
1885 * 3rd Level Abstractions
1886 ********************************************************************/
1888 struct __sctp_missing
{
1894 * Report a missing mandatory parameter.
1896 static int sctp_process_missing_param(const struct sctp_association
*asoc
,
1897 enum sctp_param paramtype
,
1898 struct sctp_chunk
*chunk
,
1899 struct sctp_chunk
**errp
)
1901 struct __sctp_missing report
;
1904 len
= SCTP_PAD4(sizeof(report
));
1906 /* Make an ERROR chunk, preparing enough room for
1907 * returning multiple unknown parameters.
1910 *errp
= sctp_make_op_error_space(asoc
, chunk
, len
);
1913 report
.num_missing
= htonl(1);
1914 report
.type
= paramtype
;
1915 sctp_init_cause(*errp
, SCTP_ERROR_MISS_PARAM
,
1917 sctp_addto_chunk(*errp
, sizeof(report
), &report
);
1920 /* Stop processing this chunk. */
1924 /* Report an Invalid Mandatory Parameter. */
1925 static int sctp_process_inv_mandatory(const struct sctp_association
*asoc
,
1926 struct sctp_chunk
*chunk
,
1927 struct sctp_chunk
**errp
)
1929 /* Invalid Mandatory Parameter Error has no payload. */
1932 *errp
= sctp_make_op_error_space(asoc
, chunk
, 0);
1935 sctp_init_cause(*errp
, SCTP_ERROR_INV_PARAM
, 0);
1937 /* Stop processing this chunk. */
1941 static int sctp_process_inv_paramlength(const struct sctp_association
*asoc
,
1942 struct sctp_paramhdr
*param
,
1943 const struct sctp_chunk
*chunk
,
1944 struct sctp_chunk
**errp
)
1946 /* This is a fatal error. Any accumulated non-fatal errors are
1950 sctp_chunk_free(*errp
);
1952 /* Create an error chunk and fill it in with our payload. */
1953 *errp
= sctp_make_violation_paramlen(asoc
, chunk
, param
);
1959 /* Do not attempt to handle the HOST_NAME parm. However, do
1960 * send back an indicator to the peer.
1962 static int sctp_process_hn_param(const struct sctp_association
*asoc
,
1963 union sctp_params param
,
1964 struct sctp_chunk
*chunk
,
1965 struct sctp_chunk
**errp
)
1967 __u16 len
= ntohs(param
.p
->length
);
1969 /* Processing of the HOST_NAME parameter will generate an
1970 * ABORT. If we've accumulated any non-fatal errors, they
1971 * would be unrecognized parameters and we should not include
1972 * them in the ABORT.
1975 sctp_chunk_free(*errp
);
1977 *errp
= sctp_make_op_error(asoc
, chunk
, SCTP_ERROR_DNS_FAILED
,
1980 /* Stop processing this chunk. */
1984 static int sctp_verify_ext_param(struct net
*net
, union sctp_params param
)
1986 __u16 num_ext
= ntohs(param
.p
->length
) - sizeof(struct sctp_paramhdr
);
1987 int have_asconf
= 0;
1991 for (i
= 0; i
< num_ext
; i
++) {
1992 switch (param
.ext
->chunks
[i
]) {
1996 case SCTP_CID_ASCONF
:
1997 case SCTP_CID_ASCONF_ACK
:
2003 /* ADD-IP Security: The draft requires us to ABORT or ignore the
2004 * INIT/INIT-ACK if ADD-IP is listed, but AUTH is not. Do this
2005 * only if ADD-IP is turned on and we are not backward-compatible
2008 if (net
->sctp
.addip_noauth
)
2011 if (net
->sctp
.addip_enable
&& !have_auth
&& have_asconf
)
2017 static void sctp_process_ext_param(struct sctp_association
*asoc
,
2018 union sctp_params param
)
2020 __u16 num_ext
= ntohs(param
.p
->length
) - sizeof(struct sctp_paramhdr
);
2021 struct net
*net
= sock_net(asoc
->base
.sk
);
2024 for (i
= 0; i
< num_ext
; i
++) {
2025 switch (param
.ext
->chunks
[i
]) {
2026 case SCTP_CID_RECONF
:
2027 if (asoc
->reconf_enable
&&
2028 !asoc
->peer
.reconf_capable
)
2029 asoc
->peer
.reconf_capable
= 1;
2031 case SCTP_CID_FWD_TSN
:
2032 if (asoc
->prsctp_enable
&& !asoc
->peer
.prsctp_capable
)
2033 asoc
->peer
.prsctp_capable
= 1;
2036 /* if the peer reports AUTH, assume that he
2039 if (asoc
->ep
->auth_enable
)
2040 asoc
->peer
.auth_capable
= 1;
2042 case SCTP_CID_ASCONF
:
2043 case SCTP_CID_ASCONF_ACK
:
2044 if (net
->sctp
.addip_enable
)
2045 asoc
->peer
.asconf_capable
= 1;
2047 case SCTP_CID_I_DATA
:
2048 if (sctp_sk(asoc
->base
.sk
)->strm_interleave
)
2049 asoc
->intl_enable
= 1;
2057 /* RFC 3.2.1 & the Implementers Guide 2.2.
2059 * The Parameter Types are encoded such that the
2060 * highest-order two bits specify the action that must be
2061 * taken if the processing endpoint does not recognize the
2064 * 00 - Stop processing this parameter; do not process any further
2065 * parameters within this chunk
2067 * 01 - Stop processing this parameter, do not process any further
2068 * parameters within this chunk, and report the unrecognized
2069 * parameter in an 'Unrecognized Parameter' ERROR chunk.
2071 * 10 - Skip this parameter and continue processing.
2073 * 11 - Skip this parameter and continue processing but
2074 * report the unrecognized parameter in an
2075 * 'Unrecognized Parameter' ERROR chunk.
2078 * SCTP_IERROR_NO_ERROR - continue with the chunk
2079 * SCTP_IERROR_ERROR - stop and report an error.
2080 * SCTP_IERROR_NOMEME - out of memory.
2082 static enum sctp_ierror
sctp_process_unk_param(
2083 const struct sctp_association
*asoc
,
2084 union sctp_params param
,
2085 struct sctp_chunk
*chunk
,
2086 struct sctp_chunk
**errp
)
2088 int retval
= SCTP_IERROR_NO_ERROR
;
2090 switch (param
.p
->type
& SCTP_PARAM_ACTION_MASK
) {
2091 case SCTP_PARAM_ACTION_DISCARD
:
2092 retval
= SCTP_IERROR_ERROR
;
2094 case SCTP_PARAM_ACTION_SKIP
:
2096 case SCTP_PARAM_ACTION_DISCARD_ERR
:
2097 retval
= SCTP_IERROR_ERROR
;
2099 case SCTP_PARAM_ACTION_SKIP_ERR
:
2100 /* Make an ERROR chunk, preparing enough room for
2101 * returning multiple unknown parameters.
2104 *errp
= sctp_make_op_error_limited(asoc
, chunk
);
2106 /* If there is no memory for generating the
2107 * ERROR report as specified, an ABORT will be
2108 * triggered to the peer and the association
2109 * won't be established.
2111 retval
= SCTP_IERROR_NOMEM
;
2116 if (!sctp_init_cause(*errp
, SCTP_ERROR_UNKNOWN_PARAM
,
2117 ntohs(param
.p
->length
)))
2118 sctp_addto_chunk(*errp
, ntohs(param
.p
->length
),
2128 /* Verify variable length parameters
2130 * SCTP_IERROR_ABORT - trigger an ABORT
2131 * SCTP_IERROR_NOMEM - out of memory (abort)
2132 * SCTP_IERROR_ERROR - stop processing, trigger an ERROR
2133 * SCTP_IERROR_NO_ERROR - continue with the chunk
2135 static enum sctp_ierror
sctp_verify_param(struct net
*net
,
2136 const struct sctp_endpoint
*ep
,
2137 const struct sctp_association
*asoc
,
2138 union sctp_params param
,
2140 struct sctp_chunk
*chunk
,
2141 struct sctp_chunk
**err_chunk
)
2143 struct sctp_hmac_algo_param
*hmacs
;
2144 int retval
= SCTP_IERROR_NO_ERROR
;
2145 __u16 n_elt
, id
= 0;
2148 /* FIXME - This routine is not looking at each parameter per the
2149 * chunk type, i.e., unrecognized parameters should be further
2150 * identified based on the chunk id.
2153 switch (param
.p
->type
) {
2154 case SCTP_PARAM_IPV4_ADDRESS
:
2155 case SCTP_PARAM_IPV6_ADDRESS
:
2156 case SCTP_PARAM_COOKIE_PRESERVATIVE
:
2157 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES
:
2158 case SCTP_PARAM_STATE_COOKIE
:
2159 case SCTP_PARAM_HEARTBEAT_INFO
:
2160 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS
:
2161 case SCTP_PARAM_ECN_CAPABLE
:
2162 case SCTP_PARAM_ADAPTATION_LAYER_IND
:
2165 case SCTP_PARAM_SUPPORTED_EXT
:
2166 if (!sctp_verify_ext_param(net
, param
))
2167 return SCTP_IERROR_ABORT
;
2170 case SCTP_PARAM_SET_PRIMARY
:
2171 if (net
->sctp
.addip_enable
)
2175 case SCTP_PARAM_HOST_NAME_ADDRESS
:
2176 /* Tell the peer, we won't support this param. */
2177 sctp_process_hn_param(asoc
, param
, chunk
, err_chunk
);
2178 retval
= SCTP_IERROR_ABORT
;
2181 case SCTP_PARAM_FWD_TSN_SUPPORT
:
2182 if (ep
->prsctp_enable
)
2186 case SCTP_PARAM_RANDOM
:
2187 if (!ep
->auth_enable
)
2190 /* SCTP-AUTH: Secion 6.1
2191 * If the random number is not 32 byte long the association
2192 * MUST be aborted. The ABORT chunk SHOULD contain the error
2193 * cause 'Protocol Violation'.
2195 if (SCTP_AUTH_RANDOM_LENGTH
!= ntohs(param
.p
->length
) -
2196 sizeof(struct sctp_paramhdr
)) {
2197 sctp_process_inv_paramlength(asoc
, param
.p
,
2199 retval
= SCTP_IERROR_ABORT
;
2203 case SCTP_PARAM_CHUNKS
:
2204 if (!ep
->auth_enable
)
2207 /* SCTP-AUTH: Section 3.2
2208 * The CHUNKS parameter MUST be included once in the INIT or
2209 * INIT-ACK chunk if the sender wants to receive authenticated
2210 * chunks. Its maximum length is 260 bytes.
2212 if (260 < ntohs(param
.p
->length
)) {
2213 sctp_process_inv_paramlength(asoc
, param
.p
,
2215 retval
= SCTP_IERROR_ABORT
;
2219 case SCTP_PARAM_HMAC_ALGO
:
2220 if (!ep
->auth_enable
)
2223 hmacs
= (struct sctp_hmac_algo_param
*)param
.p
;
2224 n_elt
= (ntohs(param
.p
->length
) -
2225 sizeof(struct sctp_paramhdr
)) >> 1;
2227 /* SCTP-AUTH: Section 6.1
2228 * The HMAC algorithm based on SHA-1 MUST be supported and
2229 * included in the HMAC-ALGO parameter.
2231 for (i
= 0; i
< n_elt
; i
++) {
2232 id
= ntohs(hmacs
->hmac_ids
[i
]);
2234 if (id
== SCTP_AUTH_HMAC_ID_SHA1
)
2238 if (id
!= SCTP_AUTH_HMAC_ID_SHA1
) {
2239 sctp_process_inv_paramlength(asoc
, param
.p
, chunk
,
2241 retval
= SCTP_IERROR_ABORT
;
2246 pr_debug("%s: unrecognized param:%d for chunk:%d\n",
2247 __func__
, ntohs(param
.p
->type
), cid
);
2249 retval
= sctp_process_unk_param(asoc
, param
, chunk
, err_chunk
);
2255 /* Verify the INIT packet before we process it. */
2256 int sctp_verify_init(struct net
*net
, const struct sctp_endpoint
*ep
,
2257 const struct sctp_association
*asoc
, enum sctp_cid cid
,
2258 struct sctp_init_chunk
*peer_init
,
2259 struct sctp_chunk
*chunk
, struct sctp_chunk
**errp
)
2261 union sctp_params param
;
2262 bool has_cookie
= false;
2265 /* Check for missing mandatory parameters. Note: Initial TSN is
2266 * also mandatory, but is not checked here since the valid range
2267 * is 0..2**32-1. RFC4960, section 3.3.3.
2269 if (peer_init
->init_hdr
.num_outbound_streams
== 0 ||
2270 peer_init
->init_hdr
.num_inbound_streams
== 0 ||
2271 peer_init
->init_hdr
.init_tag
== 0 ||
2272 ntohl(peer_init
->init_hdr
.a_rwnd
) < SCTP_DEFAULT_MINWINDOW
)
2273 return sctp_process_inv_mandatory(asoc
, chunk
, errp
);
2275 sctp_walk_params(param
, peer_init
, init_hdr
.params
) {
2276 if (param
.p
->type
== SCTP_PARAM_STATE_COOKIE
)
2280 /* There is a possibility that a parameter length was bad and
2281 * in that case we would have stoped walking the parameters.
2282 * The current param.p would point at the bad one.
2283 * Current consensus on the mailing list is to generate a PROTOCOL
2284 * VIOLATION error. We build the ERROR chunk here and let the normal
2285 * error handling code build and send the packet.
2287 if (param
.v
!= (void *)chunk
->chunk_end
)
2288 return sctp_process_inv_paramlength(asoc
, param
.p
, chunk
, errp
);
2290 /* The only missing mandatory param possible today is
2291 * the state cookie for an INIT-ACK chunk.
2293 if ((SCTP_CID_INIT_ACK
== cid
) && !has_cookie
)
2294 return sctp_process_missing_param(asoc
, SCTP_PARAM_STATE_COOKIE
,
2297 /* Verify all the variable length parameters */
2298 sctp_walk_params(param
, peer_init
, init_hdr
.params
) {
2299 result
= sctp_verify_param(net
, ep
, asoc
, param
, cid
,
2302 case SCTP_IERROR_ABORT
:
2303 case SCTP_IERROR_NOMEM
:
2305 case SCTP_IERROR_ERROR
:
2307 case SCTP_IERROR_NO_ERROR
:
2312 } /* for (loop through all parameters) */
2317 /* Unpack the parameters in an INIT packet into an association.
2318 * Returns 0 on failure, else success.
2319 * FIXME: This is an association method.
2321 int sctp_process_init(struct sctp_association
*asoc
, struct sctp_chunk
*chunk
,
2322 const union sctp_addr
*peer_addr
,
2323 struct sctp_init_chunk
*peer_init
, gfp_t gfp
)
2325 struct net
*net
= sock_net(asoc
->base
.sk
);
2326 struct sctp_transport
*transport
;
2327 struct list_head
*pos
, *temp
;
2328 union sctp_params param
;
2329 union sctp_addr addr
;
2333 /* We must include the address that the INIT packet came from.
2334 * This is the only address that matters for an INIT packet.
2335 * When processing a COOKIE ECHO, we retrieve the from address
2336 * of the INIT from the cookie.
2339 /* This implementation defaults to making the first transport
2340 * added as the primary transport. The source address seems to
2341 * be a a better choice than any of the embedded addresses.
2343 if (!sctp_assoc_add_peer(asoc
, peer_addr
, gfp
, SCTP_ACTIVE
))
2346 if (sctp_cmp_addr_exact(sctp_source(chunk
), peer_addr
))
2349 /* Process the initialization parameters. */
2350 sctp_walk_params(param
, peer_init
, init_hdr
.params
) {
2351 if (!src_match
&& (param
.p
->type
== SCTP_PARAM_IPV4_ADDRESS
||
2352 param
.p
->type
== SCTP_PARAM_IPV6_ADDRESS
)) {
2353 af
= sctp_get_af_specific(param_type2af(param
.p
->type
));
2354 af
->from_addr_param(&addr
, param
.addr
,
2355 chunk
->sctp_hdr
->source
, 0);
2356 if (sctp_cmp_addr_exact(sctp_source(chunk
), &addr
))
2360 if (!sctp_process_param(asoc
, param
, peer_addr
, gfp
))
2364 /* source address of chunk may not match any valid address */
2368 /* AUTH: After processing the parameters, make sure that we
2369 * have all the required info to potentially do authentications.
2371 if (asoc
->peer
.auth_capable
&& (!asoc
->peer
.peer_random
||
2372 !asoc
->peer
.peer_hmacs
))
2373 asoc
->peer
.auth_capable
= 0;
2375 /* In a non-backward compatible mode, if the peer claims
2376 * support for ADD-IP but not AUTH, the ADD-IP spec states
2377 * that we MUST ABORT the association. Section 6. The section
2378 * also give us an option to silently ignore the packet, which
2379 * is what we'll do here.
2381 if (!net
->sctp
.addip_noauth
&&
2382 (asoc
->peer
.asconf_capable
&& !asoc
->peer
.auth_capable
)) {
2383 asoc
->peer
.addip_disabled_mask
|= (SCTP_PARAM_ADD_IP
|
2385 SCTP_PARAM_SET_PRIMARY
);
2386 asoc
->peer
.asconf_capable
= 0;
2390 /* Walk list of transports, removing transports in the UNKNOWN state. */
2391 list_for_each_safe(pos
, temp
, &asoc
->peer
.transport_addr_list
) {
2392 transport
= list_entry(pos
, struct sctp_transport
, transports
);
2393 if (transport
->state
== SCTP_UNKNOWN
) {
2394 sctp_assoc_rm_peer(asoc
, transport
);
2398 /* The fixed INIT headers are always in network byte
2401 asoc
->peer
.i
.init_tag
=
2402 ntohl(peer_init
->init_hdr
.init_tag
);
2403 asoc
->peer
.i
.a_rwnd
=
2404 ntohl(peer_init
->init_hdr
.a_rwnd
);
2405 asoc
->peer
.i
.num_outbound_streams
=
2406 ntohs(peer_init
->init_hdr
.num_outbound_streams
);
2407 asoc
->peer
.i
.num_inbound_streams
=
2408 ntohs(peer_init
->init_hdr
.num_inbound_streams
);
2409 asoc
->peer
.i
.initial_tsn
=
2410 ntohl(peer_init
->init_hdr
.initial_tsn
);
2412 asoc
->strreset_inseq
= asoc
->peer
.i
.initial_tsn
;
2414 /* Apply the upper bounds for output streams based on peer's
2415 * number of inbound streams.
2417 if (asoc
->c
.sinit_num_ostreams
>
2418 ntohs(peer_init
->init_hdr
.num_inbound_streams
)) {
2419 asoc
->c
.sinit_num_ostreams
=
2420 ntohs(peer_init
->init_hdr
.num_inbound_streams
);
2423 if (asoc
->c
.sinit_max_instreams
>
2424 ntohs(peer_init
->init_hdr
.num_outbound_streams
)) {
2425 asoc
->c
.sinit_max_instreams
=
2426 ntohs(peer_init
->init_hdr
.num_outbound_streams
);
2429 /* Copy Initiation tag from INIT to VT_peer in cookie. */
2430 asoc
->c
.peer_vtag
= asoc
->peer
.i
.init_tag
;
2432 /* Peer Rwnd : Current calculated value of the peer's rwnd. */
2433 asoc
->peer
.rwnd
= asoc
->peer
.i
.a_rwnd
;
2435 /* RFC 2960 7.2.1 The initial value of ssthresh MAY be arbitrarily
2436 * high (for example, implementations MAY use the size of the receiver
2437 * advertised window).
2439 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
2441 transport
->ssthresh
= asoc
->peer
.i
.a_rwnd
;
2444 /* Set up the TSN tracking pieces. */
2445 if (!sctp_tsnmap_init(&asoc
->peer
.tsn_map
, SCTP_TSN_MAP_INITIAL
,
2446 asoc
->peer
.i
.initial_tsn
, gfp
))
2449 /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
2451 * The stream sequence number in all the streams shall start
2452 * from 0 when the association is established. Also, when the
2453 * stream sequence number reaches the value 65535 the next
2454 * stream sequence number shall be set to 0.
2457 if (sctp_stream_init(&asoc
->stream
, asoc
->c
.sinit_num_ostreams
,
2458 asoc
->c
.sinit_max_instreams
, gfp
))
2461 /* Update frag_point when stream_interleave may get changed. */
2462 sctp_assoc_update_frag_point(asoc
);
2464 if (!asoc
->temp
&& sctp_assoc_set_id(asoc
, gfp
))
2467 /* ADDIP Section 4.1 ASCONF Chunk Procedures
2469 * When an endpoint has an ASCONF signaled change to be sent to the
2470 * remote endpoint it should do the following:
2472 * A2) A serial number should be assigned to the Chunk. The serial
2473 * number should be a monotonically increasing number. All serial
2474 * numbers are defined to be initialized at the start of the
2475 * association to the same value as the Initial TSN.
2477 asoc
->peer
.addip_serial
= asoc
->peer
.i
.initial_tsn
- 1;
2481 /* Release the transport structures. */
2482 list_for_each_safe(pos
, temp
, &asoc
->peer
.transport_addr_list
) {
2483 transport
= list_entry(pos
, struct sctp_transport
, transports
);
2484 if (transport
->state
!= SCTP_ACTIVE
)
2485 sctp_assoc_rm_peer(asoc
, transport
);
2493 /* Update asoc with the option described in param.
2495 * RFC2960 3.3.2.1 Optional/Variable Length Parameters in INIT
2497 * asoc is the association to update.
2498 * param is the variable length parameter to use for update.
2499 * cid tells us if this is an INIT, INIT ACK or COOKIE ECHO.
2500 * If the current packet is an INIT we want to minimize the amount of
2501 * work we do. In particular, we should not build transport
2502 * structures for the addresses.
2504 static int sctp_process_param(struct sctp_association
*asoc
,
2505 union sctp_params param
,
2506 const union sctp_addr
*peer_addr
,
2509 struct net
*net
= sock_net(asoc
->base
.sk
);
2510 struct sctp_endpoint
*ep
= asoc
->ep
;
2511 union sctp_addr_param
*addr_param
;
2512 struct sctp_transport
*t
;
2513 enum sctp_scope scope
;
2514 union sctp_addr addr
;
2520 /* We maintain all INIT parameters in network byte order all the
2521 * time. This allows us to not worry about whether the parameters
2522 * came from a fresh INIT, and INIT ACK, or were stored in a cookie.
2524 switch (param
.p
->type
) {
2525 case SCTP_PARAM_IPV6_ADDRESS
:
2526 if (PF_INET6
!= asoc
->base
.sk
->sk_family
)
2530 case SCTP_PARAM_IPV4_ADDRESS
:
2531 /* v4 addresses are not allowed on v6-only socket */
2532 if (ipv6_only_sock(asoc
->base
.sk
))
2535 af
= sctp_get_af_specific(param_type2af(param
.p
->type
));
2536 af
->from_addr_param(&addr
, param
.addr
, htons(asoc
->peer
.port
), 0);
2537 scope
= sctp_scope(peer_addr
);
2538 if (sctp_in_scope(net
, &addr
, scope
))
2539 if (!sctp_assoc_add_peer(asoc
, &addr
, gfp
, SCTP_UNCONFIRMED
))
2543 case SCTP_PARAM_COOKIE_PRESERVATIVE
:
2544 if (!net
->sctp
.cookie_preserve_enable
)
2547 stale
= ntohl(param
.life
->lifespan_increment
);
2549 /* Suggested Cookie Life span increment's unit is msec,
2552 asoc
->cookie_life
= ktime_add_ms(asoc
->cookie_life
, stale
);
2555 case SCTP_PARAM_HOST_NAME_ADDRESS
:
2556 pr_debug("%s: unimplemented SCTP_HOST_NAME_ADDRESS\n", __func__
);
2559 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES
:
2560 /* Turn off the default values first so we'll know which
2561 * ones are really set by the peer.
2563 asoc
->peer
.ipv4_address
= 0;
2564 asoc
->peer
.ipv6_address
= 0;
2566 /* Assume that peer supports the address family
2567 * by which it sends a packet.
2569 if (peer_addr
->sa
.sa_family
== AF_INET6
)
2570 asoc
->peer
.ipv6_address
= 1;
2571 else if (peer_addr
->sa
.sa_family
== AF_INET
)
2572 asoc
->peer
.ipv4_address
= 1;
2574 /* Cycle through address types; avoid divide by 0. */
2575 sat
= ntohs(param
.p
->length
) - sizeof(struct sctp_paramhdr
);
2577 sat
/= sizeof(__u16
);
2579 for (i
= 0; i
< sat
; ++i
) {
2580 switch (param
.sat
->types
[i
]) {
2581 case SCTP_PARAM_IPV4_ADDRESS
:
2582 asoc
->peer
.ipv4_address
= 1;
2585 case SCTP_PARAM_IPV6_ADDRESS
:
2586 if (PF_INET6
== asoc
->base
.sk
->sk_family
)
2587 asoc
->peer
.ipv6_address
= 1;
2590 case SCTP_PARAM_HOST_NAME_ADDRESS
:
2591 asoc
->peer
.hostname_address
= 1;
2594 default: /* Just ignore anything else. */
2600 case SCTP_PARAM_STATE_COOKIE
:
2601 asoc
->peer
.cookie_len
=
2602 ntohs(param
.p
->length
) - sizeof(struct sctp_paramhdr
);
2603 asoc
->peer
.cookie
= kmemdup(param
.cookie
->body
, asoc
->peer
.cookie_len
, gfp
);
2604 if (!asoc
->peer
.cookie
)
2608 case SCTP_PARAM_HEARTBEAT_INFO
:
2609 /* Would be odd to receive, but it causes no problems. */
2612 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS
:
2613 /* Rejected during verify stage. */
2616 case SCTP_PARAM_ECN_CAPABLE
:
2617 asoc
->peer
.ecn_capable
= 1;
2620 case SCTP_PARAM_ADAPTATION_LAYER_IND
:
2621 asoc
->peer
.adaptation_ind
= ntohl(param
.aind
->adaptation_ind
);
2624 case SCTP_PARAM_SET_PRIMARY
:
2625 if (!net
->sctp
.addip_enable
)
2628 addr_param
= param
.v
+ sizeof(struct sctp_addip_param
);
2630 af
= sctp_get_af_specific(param_type2af(addr_param
->p
.type
));
2634 af
->from_addr_param(&addr
, addr_param
,
2635 htons(asoc
->peer
.port
), 0);
2637 /* if the address is invalid, we can't process it.
2638 * XXX: see spec for what to do.
2640 if (!af
->addr_valid(&addr
, NULL
, NULL
))
2643 t
= sctp_assoc_lookup_paddr(asoc
, &addr
);
2647 sctp_assoc_set_primary(asoc
, t
);
2650 case SCTP_PARAM_SUPPORTED_EXT
:
2651 sctp_process_ext_param(asoc
, param
);
2654 case SCTP_PARAM_FWD_TSN_SUPPORT
:
2655 if (asoc
->prsctp_enable
) {
2656 asoc
->peer
.prsctp_capable
= 1;
2662 case SCTP_PARAM_RANDOM
:
2663 if (!ep
->auth_enable
)
2666 /* Save peer's random parameter */
2667 asoc
->peer
.peer_random
= kmemdup(param
.p
,
2668 ntohs(param
.p
->length
), gfp
);
2669 if (!asoc
->peer
.peer_random
) {
2675 case SCTP_PARAM_HMAC_ALGO
:
2676 if (!ep
->auth_enable
)
2679 /* Save peer's HMAC list */
2680 asoc
->peer
.peer_hmacs
= kmemdup(param
.p
,
2681 ntohs(param
.p
->length
), gfp
);
2682 if (!asoc
->peer
.peer_hmacs
) {
2687 /* Set the default HMAC the peer requested*/
2688 sctp_auth_asoc_set_default_hmac(asoc
, param
.hmac_algo
);
2691 case SCTP_PARAM_CHUNKS
:
2692 if (!ep
->auth_enable
)
2695 asoc
->peer
.peer_chunks
= kmemdup(param
.p
,
2696 ntohs(param
.p
->length
), gfp
);
2697 if (!asoc
->peer
.peer_chunks
)
2702 /* Any unrecognized parameters should have been caught
2703 * and handled by sctp_verify_param() which should be
2704 * called prior to this routine. Simply log the error
2707 pr_debug("%s: ignoring param:%d for association:%p.\n",
2708 __func__
, ntohs(param
.p
->type
), asoc
);
2715 /* Select a new verification tag. */
2716 __u32
sctp_generate_tag(const struct sctp_endpoint
*ep
)
2718 /* I believe that this random number generator complies with RFC1750.
2719 * A tag of 0 is reserved for special cases (e.g. INIT).
2724 get_random_bytes(&x
, sizeof(__u32
));
2730 /* Select an initial TSN to send during startup. */
2731 __u32
sctp_generate_tsn(const struct sctp_endpoint
*ep
)
2735 get_random_bytes(&retval
, sizeof(__u32
));
2740 * ADDIP 3.1.1 Address Configuration Change Chunk (ASCONF)
2742 * 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
2743 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2744 * | Type = 0xC1 | Chunk Flags | Chunk Length |
2745 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2747 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2748 * | Address Parameter |
2749 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2750 * | ASCONF Parameter #1 |
2751 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2755 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2756 * | ASCONF Parameter #N |
2757 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2759 * Address Parameter and other parameter will not be wrapped in this function
2761 static struct sctp_chunk
*sctp_make_asconf(struct sctp_association
*asoc
,
2762 union sctp_addr
*addr
,
2765 struct sctp_addiphdr asconf
;
2766 struct sctp_chunk
*retval
;
2767 int length
= sizeof(asconf
) + vparam_len
;
2768 union sctp_addr_param addrparam
;
2770 struct sctp_af
*af
= sctp_get_af_specific(addr
->v4
.sin_family
);
2772 addrlen
= af
->to_addr_param(addr
, &addrparam
);
2777 /* Create the chunk. */
2778 retval
= sctp_make_control(asoc
, SCTP_CID_ASCONF
, 0, length
,
2783 asconf
.serial
= htonl(asoc
->addip_serial
++);
2785 retval
->subh
.addip_hdr
=
2786 sctp_addto_chunk(retval
, sizeof(asconf
), &asconf
);
2787 retval
->param_hdr
.v
=
2788 sctp_addto_chunk(retval
, addrlen
, &addrparam
);
2794 * 3.2.1 Add IP Address
2796 * 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
2797 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2798 * | Type = 0xC001 | Length = Variable |
2799 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2800 * | ASCONF-Request Correlation ID |
2801 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2802 * | Address Parameter |
2803 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2805 * 3.2.2 Delete IP Address
2807 * 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
2808 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2809 * | Type = 0xC002 | Length = Variable |
2810 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2811 * | ASCONF-Request Correlation ID |
2812 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2813 * | Address Parameter |
2814 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2817 struct sctp_chunk
*sctp_make_asconf_update_ip(struct sctp_association
*asoc
,
2818 union sctp_addr
*laddr
,
2819 struct sockaddr
*addrs
,
2820 int addrcnt
, __be16 flags
)
2822 union sctp_addr_param addr_param
;
2823 struct sctp_addip_param param
;
2824 int paramlen
= sizeof(param
);
2825 struct sctp_chunk
*retval
;
2826 int addr_param_len
= 0;
2827 union sctp_addr
*addr
;
2828 int totallen
= 0, i
;
2833 /* Get total length of all the address parameters. */
2835 for (i
= 0; i
< addrcnt
; i
++) {
2837 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
2838 addr_param_len
= af
->to_addr_param(addr
, &addr_param
);
2840 totallen
+= paramlen
;
2841 totallen
+= addr_param_len
;
2843 addr_buf
+= af
->sockaddr_len
;
2844 if (asoc
->asconf_addr_del_pending
&& !del_pickup
) {
2845 /* reuse the parameter length from the same scope one */
2846 totallen
+= paramlen
;
2847 totallen
+= addr_param_len
;
2850 pr_debug("%s: picked same-scope del_pending addr, "
2851 "totallen for all addresses is %d\n",
2852 __func__
, totallen
);
2856 /* Create an asconf chunk with the required length. */
2857 retval
= sctp_make_asconf(asoc
, laddr
, totallen
);
2861 /* Add the address parameters to the asconf chunk. */
2863 for (i
= 0; i
< addrcnt
; i
++) {
2865 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
2866 addr_param_len
= af
->to_addr_param(addr
, &addr_param
);
2867 param
.param_hdr
.type
= flags
;
2868 param
.param_hdr
.length
= htons(paramlen
+ addr_param_len
);
2869 param
.crr_id
= htonl(i
);
2871 sctp_addto_chunk(retval
, paramlen
, ¶m
);
2872 sctp_addto_chunk(retval
, addr_param_len
, &addr_param
);
2874 addr_buf
+= af
->sockaddr_len
;
2876 if (flags
== SCTP_PARAM_ADD_IP
&& del_pickup
) {
2877 addr
= asoc
->asconf_addr_del_pending
;
2878 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
2879 addr_param_len
= af
->to_addr_param(addr
, &addr_param
);
2880 param
.param_hdr
.type
= SCTP_PARAM_DEL_IP
;
2881 param
.param_hdr
.length
= htons(paramlen
+ addr_param_len
);
2882 param
.crr_id
= htonl(i
);
2884 sctp_addto_chunk(retval
, paramlen
, ¶m
);
2885 sctp_addto_chunk(retval
, addr_param_len
, &addr_param
);
2891 * 3.2.4 Set Primary IP Address
2893 * 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
2894 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2895 * | Type =0xC004 | Length = Variable |
2896 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2897 * | ASCONF-Request Correlation ID |
2898 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2899 * | Address Parameter |
2900 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2902 * Create an ASCONF chunk with Set Primary IP address parameter.
2904 struct sctp_chunk
*sctp_make_asconf_set_prim(struct sctp_association
*asoc
,
2905 union sctp_addr
*addr
)
2907 struct sctp_af
*af
= sctp_get_af_specific(addr
->v4
.sin_family
);
2908 union sctp_addr_param addrparam
;
2909 struct sctp_addip_param param
;
2910 struct sctp_chunk
*retval
;
2911 int len
= sizeof(param
);
2914 addrlen
= af
->to_addr_param(addr
, &addrparam
);
2919 /* Create the chunk and make asconf header. */
2920 retval
= sctp_make_asconf(asoc
, addr
, len
);
2924 param
.param_hdr
.type
= SCTP_PARAM_SET_PRIMARY
;
2925 param
.param_hdr
.length
= htons(len
);
2928 sctp_addto_chunk(retval
, sizeof(param
), ¶m
);
2929 sctp_addto_chunk(retval
, addrlen
, &addrparam
);
2934 /* ADDIP 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
2936 * 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
2937 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2938 * | Type = 0x80 | Chunk Flags | Chunk Length |
2939 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2941 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2942 * | ASCONF Parameter Response#1 |
2943 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2947 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2948 * | ASCONF Parameter Response#N |
2949 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2951 * Create an ASCONF_ACK chunk with enough space for the parameter responses.
2953 static struct sctp_chunk
*sctp_make_asconf_ack(const struct sctp_association
*asoc
,
2954 __u32 serial
, int vparam_len
)
2956 struct sctp_addiphdr asconf
;
2957 struct sctp_chunk
*retval
;
2958 int length
= sizeof(asconf
) + vparam_len
;
2960 /* Create the chunk. */
2961 retval
= sctp_make_control(asoc
, SCTP_CID_ASCONF_ACK
, 0, length
,
2966 asconf
.serial
= htonl(serial
);
2968 retval
->subh
.addip_hdr
=
2969 sctp_addto_chunk(retval
, sizeof(asconf
), &asconf
);
2974 /* Add response parameters to an ASCONF_ACK chunk. */
2975 static void sctp_add_asconf_response(struct sctp_chunk
*chunk
, __be32 crr_id
,
2977 struct sctp_addip_param
*asconf_param
)
2979 struct sctp_addip_param ack_param
;
2980 struct sctp_errhdr err_param
;
2981 int asconf_param_len
= 0;
2982 int err_param_len
= 0;
2983 __be16 response_type
;
2985 if (SCTP_ERROR_NO_ERROR
== err_code
) {
2986 response_type
= SCTP_PARAM_SUCCESS_REPORT
;
2988 response_type
= SCTP_PARAM_ERR_CAUSE
;
2989 err_param_len
= sizeof(err_param
);
2992 ntohs(asconf_param
->param_hdr
.length
);
2995 /* Add Success Indication or Error Cause Indication parameter. */
2996 ack_param
.param_hdr
.type
= response_type
;
2997 ack_param
.param_hdr
.length
= htons(sizeof(ack_param
) +
3000 ack_param
.crr_id
= crr_id
;
3001 sctp_addto_chunk(chunk
, sizeof(ack_param
), &ack_param
);
3003 if (SCTP_ERROR_NO_ERROR
== err_code
)
3006 /* Add Error Cause parameter. */
3007 err_param
.cause
= err_code
;
3008 err_param
.length
= htons(err_param_len
+ asconf_param_len
);
3009 sctp_addto_chunk(chunk
, err_param_len
, &err_param
);
3011 /* Add the failed TLV copied from ASCONF chunk. */
3013 sctp_addto_chunk(chunk
, asconf_param_len
, asconf_param
);
3016 /* Process a asconf parameter. */
3017 static __be16
sctp_process_asconf_param(struct sctp_association
*asoc
,
3018 struct sctp_chunk
*asconf
,
3019 struct sctp_addip_param
*asconf_param
)
3021 union sctp_addr_param
*addr_param
;
3022 struct sctp_transport
*peer
;
3023 union sctp_addr addr
;
3026 addr_param
= (void *)asconf_param
+ sizeof(*asconf_param
);
3028 if (asconf_param
->param_hdr
.type
!= SCTP_PARAM_ADD_IP
&&
3029 asconf_param
->param_hdr
.type
!= SCTP_PARAM_DEL_IP
&&
3030 asconf_param
->param_hdr
.type
!= SCTP_PARAM_SET_PRIMARY
)
3031 return SCTP_ERROR_UNKNOWN_PARAM
;
3033 switch (addr_param
->p
.type
) {
3034 case SCTP_PARAM_IPV6_ADDRESS
:
3035 if (!asoc
->peer
.ipv6_address
)
3036 return SCTP_ERROR_DNS_FAILED
;
3038 case SCTP_PARAM_IPV4_ADDRESS
:
3039 if (!asoc
->peer
.ipv4_address
)
3040 return SCTP_ERROR_DNS_FAILED
;
3043 return SCTP_ERROR_DNS_FAILED
;
3046 af
= sctp_get_af_specific(param_type2af(addr_param
->p
.type
));
3048 return SCTP_ERROR_DNS_FAILED
;
3050 af
->from_addr_param(&addr
, addr_param
, htons(asoc
->peer
.port
), 0);
3052 /* ADDIP 4.2.1 This parameter MUST NOT contain a broadcast
3053 * or multicast address.
3054 * (note: wildcard is permitted and requires special handling so
3055 * make sure we check for that)
3057 if (!af
->is_any(&addr
) && !af
->addr_valid(&addr
, NULL
, asconf
->skb
))
3058 return SCTP_ERROR_DNS_FAILED
;
3060 switch (asconf_param
->param_hdr
.type
) {
3061 case SCTP_PARAM_ADD_IP
:
3063 * If the address 0.0.0.0 or ::0 is provided, the source
3064 * address of the packet MUST be added.
3066 if (af
->is_any(&addr
))
3067 memcpy(&addr
, &asconf
->source
, sizeof(addr
));
3069 if (security_sctp_bind_connect(asoc
->ep
->base
.sk
,
3071 (struct sockaddr
*)&addr
,
3073 return SCTP_ERROR_REQ_REFUSED
;
3075 /* ADDIP 4.3 D9) If an endpoint receives an ADD IP address
3076 * request and does not have the local resources to add this
3077 * new address to the association, it MUST return an Error
3078 * Cause TLV set to the new error code 'Operation Refused
3079 * Due to Resource Shortage'.
3082 peer
= sctp_assoc_add_peer(asoc
, &addr
, GFP_ATOMIC
, SCTP_UNCONFIRMED
);
3084 return SCTP_ERROR_RSRC_LOW
;
3086 /* Start the heartbeat timer. */
3087 sctp_transport_reset_hb_timer(peer
);
3088 asoc
->new_transport
= peer
;
3090 case SCTP_PARAM_DEL_IP
:
3091 /* ADDIP 4.3 D7) If a request is received to delete the
3092 * last remaining IP address of a peer endpoint, the receiver
3093 * MUST send an Error Cause TLV with the error cause set to the
3094 * new error code 'Request to Delete Last Remaining IP Address'.
3096 if (asoc
->peer
.transport_count
== 1)
3097 return SCTP_ERROR_DEL_LAST_IP
;
3099 /* ADDIP 4.3 D8) If a request is received to delete an IP
3100 * address which is also the source address of the IP packet
3101 * which contained the ASCONF chunk, the receiver MUST reject
3102 * this request. To reject the request the receiver MUST send
3103 * an Error Cause TLV set to the new error code 'Request to
3104 * Delete Source IP Address'
3106 if (sctp_cmp_addr_exact(&asconf
->source
, &addr
))
3107 return SCTP_ERROR_DEL_SRC_IP
;
3110 * If the address 0.0.0.0 or ::0 is provided, all
3111 * addresses of the peer except the source address of the
3112 * packet MUST be deleted.
3114 if (af
->is_any(&addr
)) {
3115 sctp_assoc_set_primary(asoc
, asconf
->transport
);
3116 sctp_assoc_del_nonprimary_peers(asoc
,
3118 return SCTP_ERROR_NO_ERROR
;
3121 /* If the address is not part of the association, the
3122 * ASCONF-ACK with Error Cause Indication Parameter
3123 * which including cause of Unresolvable Address should
3126 peer
= sctp_assoc_lookup_paddr(asoc
, &addr
);
3128 return SCTP_ERROR_DNS_FAILED
;
3130 sctp_assoc_rm_peer(asoc
, peer
);
3132 case SCTP_PARAM_SET_PRIMARY
:
3133 /* ADDIP Section 4.2.4
3134 * If the address 0.0.0.0 or ::0 is provided, the receiver
3135 * MAY mark the source address of the packet as its
3138 if (af
->is_any(&addr
))
3139 memcpy(&addr
.v4
, sctp_source(asconf
), sizeof(addr
));
3141 if (security_sctp_bind_connect(asoc
->ep
->base
.sk
,
3142 SCTP_PARAM_SET_PRIMARY
,
3143 (struct sockaddr
*)&addr
,
3145 return SCTP_ERROR_REQ_REFUSED
;
3147 peer
= sctp_assoc_lookup_paddr(asoc
, &addr
);
3149 return SCTP_ERROR_DNS_FAILED
;
3151 sctp_assoc_set_primary(asoc
, peer
);
3155 return SCTP_ERROR_NO_ERROR
;
3158 /* Verify the ASCONF packet before we process it. */
3159 bool sctp_verify_asconf(const struct sctp_association
*asoc
,
3160 struct sctp_chunk
*chunk
, bool addr_param_needed
,
3161 struct sctp_paramhdr
**errp
)
3163 struct sctp_addip_chunk
*addip
;
3164 bool addr_param_seen
= false;
3165 union sctp_params param
;
3167 addip
= (struct sctp_addip_chunk
*)chunk
->chunk_hdr
;
3168 sctp_walk_params(param
, addip
, addip_hdr
.params
) {
3169 size_t length
= ntohs(param
.p
->length
);
3172 switch (param
.p
->type
) {
3173 case SCTP_PARAM_ERR_CAUSE
:
3175 case SCTP_PARAM_IPV4_ADDRESS
:
3176 if (length
!= sizeof(struct sctp_ipv4addr_param
))
3178 /* ensure there is only one addr param and it's in the
3179 * beginning of addip_hdr params, or we reject it.
3181 if (param
.v
!= addip
->addip_hdr
.params
)
3183 addr_param_seen
= true;
3185 case SCTP_PARAM_IPV6_ADDRESS
:
3186 if (length
!= sizeof(struct sctp_ipv6addr_param
))
3188 if (param
.v
!= addip
->addip_hdr
.params
)
3190 addr_param_seen
= true;
3192 case SCTP_PARAM_ADD_IP
:
3193 case SCTP_PARAM_DEL_IP
:
3194 case SCTP_PARAM_SET_PRIMARY
:
3195 /* In ASCONF chunks, these need to be first. */
3196 if (addr_param_needed
&& !addr_param_seen
)
3198 length
= ntohs(param
.addip
->param_hdr
.length
);
3199 if (length
< sizeof(struct sctp_addip_param
) +
3203 case SCTP_PARAM_SUCCESS_REPORT
:
3204 case SCTP_PARAM_ADAPTATION_LAYER_IND
:
3205 if (length
!= sizeof(struct sctp_addip_param
))
3209 /* This is unkown to us, reject! */
3214 /* Remaining sanity checks. */
3215 if (addr_param_needed
&& !addr_param_seen
)
3217 if (!addr_param_needed
&& addr_param_seen
)
3219 if (param
.v
!= chunk
->chunk_end
)
3225 /* Process an incoming ASCONF chunk with the next expected serial no. and
3226 * return an ASCONF_ACK chunk to be sent in response.
3228 struct sctp_chunk
*sctp_process_asconf(struct sctp_association
*asoc
,
3229 struct sctp_chunk
*asconf
)
3231 union sctp_addr_param
*addr_param
;
3232 struct sctp_addip_chunk
*addip
;
3233 struct sctp_chunk
*asconf_ack
;
3234 bool all_param_pass
= true;
3235 struct sctp_addiphdr
*hdr
;
3236 int length
= 0, chunk_len
;
3237 union sctp_params param
;
3241 addip
= (struct sctp_addip_chunk
*)asconf
->chunk_hdr
;
3242 chunk_len
= ntohs(asconf
->chunk_hdr
->length
) -
3243 sizeof(struct sctp_chunkhdr
);
3244 hdr
= (struct sctp_addiphdr
*)asconf
->skb
->data
;
3245 serial
= ntohl(hdr
->serial
);
3247 /* Skip the addiphdr and store a pointer to address parameter. */
3248 length
= sizeof(*hdr
);
3249 addr_param
= (union sctp_addr_param
*)(asconf
->skb
->data
+ length
);
3250 chunk_len
-= length
;
3252 /* Skip the address parameter and store a pointer to the first
3255 length
= ntohs(addr_param
->p
.length
);
3256 chunk_len
-= length
;
3258 /* create an ASCONF_ACK chunk.
3259 * Based on the definitions of parameters, we know that the size of
3260 * ASCONF_ACK parameters are less than or equal to the fourfold of ASCONF
3263 asconf_ack
= sctp_make_asconf_ack(asoc
, serial
, chunk_len
* 4);
3267 /* Process the TLVs contained within the ASCONF chunk. */
3268 sctp_walk_params(param
, addip
, addip_hdr
.params
) {
3269 /* Skip preceeding address parameters. */
3270 if (param
.p
->type
== SCTP_PARAM_IPV4_ADDRESS
||
3271 param
.p
->type
== SCTP_PARAM_IPV6_ADDRESS
)
3274 err_code
= sctp_process_asconf_param(asoc
, asconf
,
3277 * If an error response is received for a TLV parameter,
3278 * all TLVs with no response before the failed TLV are
3279 * considered successful if not reported. All TLVs after
3280 * the failed response are considered unsuccessful unless
3281 * a specific success indication is present for the parameter.
3283 if (err_code
!= SCTP_ERROR_NO_ERROR
)
3284 all_param_pass
= false;
3285 if (!all_param_pass
)
3286 sctp_add_asconf_response(asconf_ack
, param
.addip
->crr_id
,
3287 err_code
, param
.addip
);
3289 /* ADDIP 4.3 D11) When an endpoint receiving an ASCONF to add
3290 * an IP address sends an 'Out of Resource' in its response, it
3291 * MUST also fail any subsequent add or delete requests bundled
3294 if (err_code
== SCTP_ERROR_RSRC_LOW
)
3298 asoc
->peer
.addip_serial
++;
3300 /* If we are sending a new ASCONF_ACK hold a reference to it in assoc
3301 * after freeing the reference to old asconf ack if any.
3304 sctp_chunk_hold(asconf_ack
);
3305 list_add_tail(&asconf_ack
->transmitted_list
,
3306 &asoc
->asconf_ack_list
);
3312 /* Process a asconf parameter that is successfully acked. */
3313 static void sctp_asconf_param_success(struct sctp_association
*asoc
,
3314 struct sctp_addip_param
*asconf_param
)
3316 struct sctp_bind_addr
*bp
= &asoc
->base
.bind_addr
;
3317 union sctp_addr_param
*addr_param
;
3318 struct sctp_sockaddr_entry
*saddr
;
3319 struct sctp_transport
*transport
;
3320 union sctp_addr addr
;
3323 addr_param
= (void *)asconf_param
+ sizeof(*asconf_param
);
3325 /* We have checked the packet before, so we do not check again. */
3326 af
= sctp_get_af_specific(param_type2af(addr_param
->p
.type
));
3327 af
->from_addr_param(&addr
, addr_param
, htons(bp
->port
), 0);
3329 switch (asconf_param
->param_hdr
.type
) {
3330 case SCTP_PARAM_ADD_IP
:
3331 /* This is always done in BH context with a socket lock
3332 * held, so the list can not change.
3335 list_for_each_entry(saddr
, &bp
->address_list
, list
) {
3336 if (sctp_cmp_addr_exact(&saddr
->a
, &addr
))
3337 saddr
->state
= SCTP_ADDR_SRC
;
3340 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
3342 sctp_transport_dst_release(transport
);
3345 case SCTP_PARAM_DEL_IP
:
3347 sctp_del_bind_addr(bp
, &addr
);
3348 if (asoc
->asconf_addr_del_pending
!= NULL
&&
3349 sctp_cmp_addr_exact(asoc
->asconf_addr_del_pending
, &addr
)) {
3350 kfree(asoc
->asconf_addr_del_pending
);
3351 asoc
->asconf_addr_del_pending
= NULL
;
3354 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
3356 sctp_transport_dst_release(transport
);
3364 /* Get the corresponding ASCONF response error code from the ASCONF_ACK chunk
3365 * for the given asconf parameter. If there is no response for this parameter,
3366 * return the error code based on the third argument 'no_err'.
3368 * A7) If an error response is received for a TLV parameter, all TLVs with no
3369 * response before the failed TLV are considered successful if not reported.
3370 * All TLVs after the failed response are considered unsuccessful unless a
3371 * specific success indication is present for the parameter.
3373 static __be16
sctp_get_asconf_response(struct sctp_chunk
*asconf_ack
,
3374 struct sctp_addip_param
*asconf_param
,
3377 struct sctp_addip_param
*asconf_ack_param
;
3378 struct sctp_errhdr
*err_param
;
3384 err_code
= SCTP_ERROR_NO_ERROR
;
3386 err_code
= SCTP_ERROR_REQ_REFUSED
;
3388 asconf_ack_len
= ntohs(asconf_ack
->chunk_hdr
->length
) -
3389 sizeof(struct sctp_chunkhdr
);
3391 /* Skip the addiphdr from the asconf_ack chunk and store a pointer to
3392 * the first asconf_ack parameter.
3394 length
= sizeof(struct sctp_addiphdr
);
3395 asconf_ack_param
= (struct sctp_addip_param
*)(asconf_ack
->skb
->data
+
3397 asconf_ack_len
-= length
;
3399 while (asconf_ack_len
> 0) {
3400 if (asconf_ack_param
->crr_id
== asconf_param
->crr_id
) {
3401 switch (asconf_ack_param
->param_hdr
.type
) {
3402 case SCTP_PARAM_SUCCESS_REPORT
:
3403 return SCTP_ERROR_NO_ERROR
;
3404 case SCTP_PARAM_ERR_CAUSE
:
3405 length
= sizeof(*asconf_ack_param
);
3406 err_param
= (void *)asconf_ack_param
+ length
;
3407 asconf_ack_len
-= length
;
3408 if (asconf_ack_len
> 0)
3409 return err_param
->cause
;
3411 return SCTP_ERROR_INV_PARAM
;
3414 return SCTP_ERROR_INV_PARAM
;
3418 length
= ntohs(asconf_ack_param
->param_hdr
.length
);
3419 asconf_ack_param
= (void *)asconf_ack_param
+ length
;
3420 asconf_ack_len
-= length
;
3426 /* Process an incoming ASCONF_ACK chunk against the cached last ASCONF chunk. */
3427 int sctp_process_asconf_ack(struct sctp_association
*asoc
,
3428 struct sctp_chunk
*asconf_ack
)
3430 struct sctp_chunk
*asconf
= asoc
->addip_last_asconf
;
3431 struct sctp_addip_param
*asconf_param
;
3432 __be16 err_code
= SCTP_ERROR_NO_ERROR
;
3433 union sctp_addr_param
*addr_param
;
3434 int asconf_len
= asconf
->skb
->len
;
3435 int all_param_pass
= 0;
3440 /* Skip the chunkhdr and addiphdr from the last asconf sent and store
3441 * a pointer to address parameter.
3443 length
= sizeof(struct sctp_addip_chunk
);
3444 addr_param
= (union sctp_addr_param
*)(asconf
->skb
->data
+ length
);
3445 asconf_len
-= length
;
3447 /* Skip the address parameter in the last asconf sent and store a
3448 * pointer to the first asconf parameter.
3450 length
= ntohs(addr_param
->p
.length
);
3451 asconf_param
= (void *)addr_param
+ length
;
3452 asconf_len
-= length
;
3455 * A8) If there is no response(s) to specific TLV parameter(s), and no
3456 * failures are indicated, then all request(s) are considered
3459 if (asconf_ack
->skb
->len
== sizeof(struct sctp_addiphdr
))
3462 /* Process the TLVs contained in the last sent ASCONF chunk. */
3463 while (asconf_len
> 0) {
3465 err_code
= SCTP_ERROR_NO_ERROR
;
3467 err_code
= sctp_get_asconf_response(asconf_ack
,
3470 if (no_err
&& (SCTP_ERROR_NO_ERROR
!= err_code
))
3475 case SCTP_ERROR_NO_ERROR
:
3476 sctp_asconf_param_success(asoc
, asconf_param
);
3479 case SCTP_ERROR_RSRC_LOW
:
3483 case SCTP_ERROR_UNKNOWN_PARAM
:
3484 /* Disable sending this type of asconf parameter in
3487 asoc
->peer
.addip_disabled_mask
|=
3488 asconf_param
->param_hdr
.type
;
3491 case SCTP_ERROR_REQ_REFUSED
:
3492 case SCTP_ERROR_DEL_LAST_IP
:
3493 case SCTP_ERROR_DEL_SRC_IP
:
3498 /* Skip the processed asconf parameter and move to the next
3501 length
= ntohs(asconf_param
->param_hdr
.length
);
3502 asconf_param
= (void *)asconf_param
+ length
;
3503 asconf_len
-= length
;
3506 if (no_err
&& asoc
->src_out_of_asoc_ok
) {
3507 asoc
->src_out_of_asoc_ok
= 0;
3508 sctp_transport_immediate_rtx(asoc
->peer
.primary_path
);
3511 /* Free the cached last sent asconf chunk. */
3512 list_del_init(&asconf
->transmitted_list
);
3513 sctp_chunk_free(asconf
);
3514 asoc
->addip_last_asconf
= NULL
;
3519 /* Make a FWD TSN chunk. */
3520 struct sctp_chunk
*sctp_make_fwdtsn(const struct sctp_association
*asoc
,
3521 __u32 new_cum_tsn
, size_t nstreams
,
3522 struct sctp_fwdtsn_skip
*skiplist
)
3524 struct sctp_chunk
*retval
= NULL
;
3525 struct sctp_fwdtsn_hdr ftsn_hdr
;
3526 struct sctp_fwdtsn_skip skip
;
3530 hint
= (nstreams
+ 1) * sizeof(__u32
);
3532 retval
= sctp_make_control(asoc
, SCTP_CID_FWD_TSN
, 0, hint
, GFP_ATOMIC
);
3537 ftsn_hdr
.new_cum_tsn
= htonl(new_cum_tsn
);
3538 retval
->subh
.fwdtsn_hdr
=
3539 sctp_addto_chunk(retval
, sizeof(ftsn_hdr
), &ftsn_hdr
);
3541 for (i
= 0; i
< nstreams
; i
++) {
3542 skip
.stream
= skiplist
[i
].stream
;
3543 skip
.ssn
= skiplist
[i
].ssn
;
3544 sctp_addto_chunk(retval
, sizeof(skip
), &skip
);
3550 struct sctp_chunk
*sctp_make_ifwdtsn(const struct sctp_association
*asoc
,
3551 __u32 new_cum_tsn
, size_t nstreams
,
3552 struct sctp_ifwdtsn_skip
*skiplist
)
3554 struct sctp_chunk
*retval
= NULL
;
3555 struct sctp_ifwdtsn_hdr ftsn_hdr
;
3558 hint
= (nstreams
+ 1) * sizeof(__u32
);
3560 retval
= sctp_make_control(asoc
, SCTP_CID_I_FWD_TSN
, 0, hint
,
3565 ftsn_hdr
.new_cum_tsn
= htonl(new_cum_tsn
);
3566 retval
->subh
.ifwdtsn_hdr
=
3567 sctp_addto_chunk(retval
, sizeof(ftsn_hdr
), &ftsn_hdr
);
3569 sctp_addto_chunk(retval
, nstreams
* sizeof(skiplist
[0]), skiplist
);
3574 /* RE-CONFIG 3.1 (RE-CONFIG chunk)
3576 * 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
3577 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3578 * | Type = 130 | Chunk Flags | Chunk Length |
3579 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3581 * / Re-configuration Parameter /
3583 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3585 * / Re-configuration Parameter (optional) /
3587 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3589 static struct sctp_chunk
*sctp_make_reconf(const struct sctp_association
*asoc
,
3592 struct sctp_reconf_chunk
*reconf
;
3593 struct sctp_chunk
*retval
;
3595 retval
= sctp_make_control(asoc
, SCTP_CID_RECONF
, 0, length
,
3600 reconf
= (struct sctp_reconf_chunk
*)retval
->chunk_hdr
;
3601 retval
->param_hdr
.v
= reconf
->params
;
3606 /* RE-CONFIG 4.1 (STREAM OUT RESET)
3608 * 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
3609 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3610 * | Parameter Type = 13 | Parameter Length = 16 + 2 * N |
3611 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3612 * | Re-configuration Request Sequence Number |
3613 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3614 * | Re-configuration Response Sequence Number |
3615 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3616 * | Sender's Last Assigned TSN |
3617 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3618 * | Stream Number 1 (optional) | Stream Number 2 (optional) |
3619 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3621 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3622 * | Stream Number N-1 (optional) | Stream Number N (optional) |
3623 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3625 * RE-CONFIG 4.2 (STREAM IN RESET)
3627 * 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
3628 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3629 * | Parameter Type = 14 | Parameter Length = 8 + 2 * N |
3630 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3631 * | Re-configuration Request Sequence Number |
3632 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3633 * | Stream Number 1 (optional) | Stream Number 2 (optional) |
3634 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3636 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3637 * | Stream Number N-1 (optional) | Stream Number N (optional) |
3638 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3640 struct sctp_chunk
*sctp_make_strreset_req(
3641 const struct sctp_association
*asoc
,
3642 __u16 stream_num
, __be16
*stream_list
,
3645 __u16 stream_len
= stream_num
* sizeof(__u16
);
3646 struct sctp_strreset_outreq outreq
;
3647 struct sctp_strreset_inreq inreq
;
3648 struct sctp_chunk
*retval
;
3649 __u16 outlen
, inlen
;
3651 outlen
= (sizeof(outreq
) + stream_len
) * out
;
3652 inlen
= (sizeof(inreq
) + stream_len
) * in
;
3654 retval
= sctp_make_reconf(asoc
, outlen
+ inlen
);
3659 outreq
.param_hdr
.type
= SCTP_PARAM_RESET_OUT_REQUEST
;
3660 outreq
.param_hdr
.length
= htons(outlen
);
3661 outreq
.request_seq
= htonl(asoc
->strreset_outseq
);
3662 outreq
.response_seq
= htonl(asoc
->strreset_inseq
- 1);
3663 outreq
.send_reset_at_tsn
= htonl(asoc
->next_tsn
- 1);
3665 sctp_addto_chunk(retval
, sizeof(outreq
), &outreq
);
3668 sctp_addto_chunk(retval
, stream_len
, stream_list
);
3672 inreq
.param_hdr
.type
= SCTP_PARAM_RESET_IN_REQUEST
;
3673 inreq
.param_hdr
.length
= htons(inlen
);
3674 inreq
.request_seq
= htonl(asoc
->strreset_outseq
+ out
);
3676 sctp_addto_chunk(retval
, sizeof(inreq
), &inreq
);
3679 sctp_addto_chunk(retval
, stream_len
, stream_list
);
3685 /* RE-CONFIG 4.3 (SSN/TSN RESET ALL)
3687 * 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
3688 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3689 * | Parameter Type = 15 | Parameter Length = 8 |
3690 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3691 * | Re-configuration Request Sequence Number |
3692 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3694 struct sctp_chunk
*sctp_make_strreset_tsnreq(
3695 const struct sctp_association
*asoc
)
3697 struct sctp_strreset_tsnreq tsnreq
;
3698 __u16 length
= sizeof(tsnreq
);
3699 struct sctp_chunk
*retval
;
3701 retval
= sctp_make_reconf(asoc
, length
);
3705 tsnreq
.param_hdr
.type
= SCTP_PARAM_RESET_TSN_REQUEST
;
3706 tsnreq
.param_hdr
.length
= htons(length
);
3707 tsnreq
.request_seq
= htonl(asoc
->strreset_outseq
);
3709 sctp_addto_chunk(retval
, sizeof(tsnreq
), &tsnreq
);
3714 /* RE-CONFIG 4.5/4.6 (ADD STREAM)
3716 * 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
3717 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3718 * | Parameter Type = 17 | Parameter Length = 12 |
3719 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3720 * | Re-configuration Request Sequence Number |
3721 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3722 * | Number of new streams | Reserved |
3723 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3725 struct sctp_chunk
*sctp_make_strreset_addstrm(
3726 const struct sctp_association
*asoc
,
3727 __u16 out
, __u16 in
)
3729 struct sctp_strreset_addstrm addstrm
;
3730 __u16 size
= sizeof(addstrm
);
3731 struct sctp_chunk
*retval
;
3733 retval
= sctp_make_reconf(asoc
, (!!out
+ !!in
) * size
);
3738 addstrm
.param_hdr
.type
= SCTP_PARAM_RESET_ADD_OUT_STREAMS
;
3739 addstrm
.param_hdr
.length
= htons(size
);
3740 addstrm
.number_of_streams
= htons(out
);
3741 addstrm
.request_seq
= htonl(asoc
->strreset_outseq
);
3742 addstrm
.reserved
= 0;
3744 sctp_addto_chunk(retval
, size
, &addstrm
);
3748 addstrm
.param_hdr
.type
= SCTP_PARAM_RESET_ADD_IN_STREAMS
;
3749 addstrm
.param_hdr
.length
= htons(size
);
3750 addstrm
.number_of_streams
= htons(in
);
3751 addstrm
.request_seq
= htonl(asoc
->strreset_outseq
+ !!out
);
3752 addstrm
.reserved
= 0;
3754 sctp_addto_chunk(retval
, size
, &addstrm
);
3760 /* RE-CONFIG 4.4 (RESP)
3762 * 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
3763 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3764 * | Parameter Type = 16 | Parameter Length |
3765 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3766 * | Re-configuration Response Sequence Number |
3767 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3769 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3771 struct sctp_chunk
*sctp_make_strreset_resp(const struct sctp_association
*asoc
,
3772 __u32 result
, __u32 sn
)
3774 struct sctp_strreset_resp resp
;
3775 __u16 length
= sizeof(resp
);
3776 struct sctp_chunk
*retval
;
3778 retval
= sctp_make_reconf(asoc
, length
);
3782 resp
.param_hdr
.type
= SCTP_PARAM_RESET_RESPONSE
;
3783 resp
.param_hdr
.length
= htons(length
);
3784 resp
.response_seq
= htonl(sn
);
3785 resp
.result
= htonl(result
);
3787 sctp_addto_chunk(retval
, sizeof(resp
), &resp
);
3792 /* RE-CONFIG 4.4 OPTIONAL (TSNRESP)
3794 * 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
3795 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3796 * | Parameter Type = 16 | Parameter Length |
3797 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3798 * | Re-configuration Response Sequence Number |
3799 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3801 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3802 * | Sender's Next TSN (optional) |
3803 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3804 * | Receiver's Next TSN (optional) |
3805 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3807 struct sctp_chunk
*sctp_make_strreset_tsnresp(struct sctp_association
*asoc
,
3808 __u32 result
, __u32 sn
,
3812 struct sctp_strreset_resptsn tsnresp
;
3813 __u16 length
= sizeof(tsnresp
);
3814 struct sctp_chunk
*retval
;
3816 retval
= sctp_make_reconf(asoc
, length
);
3820 tsnresp
.param_hdr
.type
= SCTP_PARAM_RESET_RESPONSE
;
3821 tsnresp
.param_hdr
.length
= htons(length
);
3823 tsnresp
.response_seq
= htonl(sn
);
3824 tsnresp
.result
= htonl(result
);
3825 tsnresp
.senders_next_tsn
= htonl(sender_tsn
);
3826 tsnresp
.receivers_next_tsn
= htonl(receiver_tsn
);
3828 sctp_addto_chunk(retval
, sizeof(tsnresp
), &tsnresp
);
3833 bool sctp_verify_reconf(const struct sctp_association
*asoc
,
3834 struct sctp_chunk
*chunk
,
3835 struct sctp_paramhdr
**errp
)
3837 struct sctp_reconf_chunk
*hdr
;
3838 union sctp_params param
;
3842 hdr
= (struct sctp_reconf_chunk
*)chunk
->chunk_hdr
;
3843 sctp_walk_params(param
, hdr
, params
) {
3844 __u16 length
= ntohs(param
.p
->length
);
3849 switch (param
.p
->type
) {
3850 case SCTP_PARAM_RESET_OUT_REQUEST
:
3851 if (length
< sizeof(struct sctp_strreset_outreq
) ||
3852 (last
&& last
!= SCTP_PARAM_RESET_RESPONSE
&&
3853 last
!= SCTP_PARAM_RESET_IN_REQUEST
))
3856 case SCTP_PARAM_RESET_IN_REQUEST
:
3857 if (length
< sizeof(struct sctp_strreset_inreq
) ||
3858 (last
&& last
!= SCTP_PARAM_RESET_OUT_REQUEST
))
3861 case SCTP_PARAM_RESET_RESPONSE
:
3862 if ((length
!= sizeof(struct sctp_strreset_resp
) &&
3863 length
!= sizeof(struct sctp_strreset_resptsn
)) ||
3864 (last
&& last
!= SCTP_PARAM_RESET_RESPONSE
&&
3865 last
!= SCTP_PARAM_RESET_OUT_REQUEST
))
3868 case SCTP_PARAM_RESET_TSN_REQUEST
:
3870 sizeof(struct sctp_strreset_tsnreq
) || last
)
3873 case SCTP_PARAM_RESET_ADD_IN_STREAMS
:
3874 if (length
!= sizeof(struct sctp_strreset_addstrm
) ||
3875 (last
&& last
!= SCTP_PARAM_RESET_ADD_OUT_STREAMS
))
3878 case SCTP_PARAM_RESET_ADD_OUT_STREAMS
:
3879 if (length
!= sizeof(struct sctp_strreset_addstrm
) ||
3880 (last
&& last
!= SCTP_PARAM_RESET_ADD_IN_STREAMS
))
3887 last
= param
.p
->type
;