blob: d244a23ab8d33c95e0b8133e212c35bc4a47875a [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * (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.
6 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05007 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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.
12 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050013 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * you can redistribute it and/or modify it under the terms of
15 * the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
17 * any later version.
18 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050019 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21 * ************************
22 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
23 * See the GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with GNU CC; see the file COPYING. If not, write to
27 * the Free Software Foundation, 59 Temple Place - Suite 330,
28 * Boston, MA 02111-1307, USA.
29 *
30 * Please send any bug reports or fixes you make to the
31 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020032 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 * Written or modified by:
35 * La Monte H.P. Yarroll <piggy@acm.org>
36 * Karl Knutson <karl@athena.chicago.il.us>
37 * C. Robin <chris@hundredacre.ac.uk>
38 * Jon Grimm <jgrimm@us.ibm.com>
39 * Xingang Guo <xingang.guo@intel.com>
40 * Dajiang Zhang <dajiang.zhang@nokia.com>
41 * Sridhar Samudrala <sri@us.ibm.com>
42 * Daisy Chang <daisyc@us.ibm.com>
43 * Ardelle Fan <ardelle.fan@intel.com>
44 * Kevin Gao <kevin.gao@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 */
46
Joe Perches145ce502010-08-24 13:21:08 +000047#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/types.h>
50#include <linux/kernel.h>
51#include <linux/ip.h>
52#include <linux/ipv6.h>
53#include <linux/net.h>
54#include <linux/inet.h>
Christian Borntraegerebc3bbc2007-10-23 12:46:32 +020055#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/crypto.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090057#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <net/sock.h>
59
60#include <linux/skbuff.h>
61#include <linux/random.h> /* for get_random_bytes */
62#include <net/sctp/sctp.h>
63#include <net/sctp/sm.h>
64
Vlad Yasevich072017b2013-08-09 22:05:36 -040065static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
66 __u8 type, __u8 flags, int paylen);
67static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
68 __u8 flags, int paylen);
69static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
70 __u8 type, __u8 flags, int paylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
72 const struct sctp_association *asoc,
73 const struct sctp_chunk *init_chunk,
74 int *cookie_len,
75 const __u8 *raw_addrs, int addrs_len);
76static int sctp_process_param(struct sctp_association *asoc,
77 union sctp_params param,
78 const union sctp_addr *peer_addr,
Al Virodd0fc662005-10-07 07:46:04 +010079 gfp_t gfp);
Vlad Yasevich8ee4be32007-11-29 08:50:35 -050080static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
81 const void *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Vlad Yasevich072017b2013-08-09 22:05:36 -040083/* Control chunk destructor */
84static void sctp_control_release_owner(struct sk_buff *skb)
85{
86 /*TODO: do memory release */
87}
88
89static void sctp_control_set_owner_w(struct sctp_chunk *chunk)
90{
91 struct sctp_association *asoc = chunk->asoc;
92 struct sk_buff *skb = chunk->skb;
93
94 /* TODO: properly account for control chunks.
95 * To do it right we'll need:
96 * 1) endpoint if association isn't known.
97 * 2) proper memory accounting.
98 *
99 * For now don't do anything for now.
100 */
101 skb->sk = asoc ? asoc->base.sk : NULL;
102 skb->destructor = sctp_control_release_owner;
103}
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105/* What was the inbound interface for this chunk? */
106int sctp_chunk_iif(const struct sctp_chunk *chunk)
107{
108 struct sctp_af *af;
109 int iif = 0;
110
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700111 af = sctp_get_af_specific(ipver2af(ip_hdr(chunk->skb)->version));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 if (af)
113 iif = af->skb_iif(chunk->skb);
114
115 return iif;
116}
117
118/* RFC 2960 3.3.2 Initiation (INIT) (1)
119 *
120 * Note 2: The ECN capable field is reserved for future use of
121 * Explicit Congestion Notification.
122 */
123static const struct sctp_paramhdr ecap_param = {
124 SCTP_PARAM_ECN_CAPABLE,
Harvey Harrison09640e62009-02-01 00:45:17 -0800125 cpu_to_be16(sizeof(struct sctp_paramhdr)),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126};
127static const struct sctp_paramhdr prsctp_param = {
128 SCTP_PARAM_FWD_TSN_SUPPORT,
Harvey Harrison09640e62009-02-01 00:45:17 -0800129 cpu_to_be16(sizeof(struct sctp_paramhdr)),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
Neil Horman5fa782c2010-04-28 10:30:59 +0000132/* A helper to initialize an op error inside a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * provided chunk, as most cause codes will be embedded inside an
134 * abort chunk.
135 */
Al Viro5bf2db02006-11-20 16:59:45 -0800136void sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,
Wei Yongjun00f1c2d2007-08-21 15:50:01 +0800137 size_t paylen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 sctp_errhdr_t err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 __u16 len;
141
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900142 /* Cause code constants are now defined in network order. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 err.cause = cause_code;
144 len = sizeof(sctp_errhdr_t) + paylen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 err.length = htons(len);
Vlad Yasevich4a1c0102007-01-09 14:35:51 -0800146 chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Neil Horman5fa782c2010-04-28 10:30:59 +0000149/* A helper to initialize an op error inside a
150 * provided chunk, as most cause codes will be embedded inside an
151 * abort chunk. Differs from sctp_init_cause in that it won't oops
152 * if there isn't enough space in the op error chunk
153 */
Ioan Orghicidb28aaf2012-07-13 07:16:37 +0000154static int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,
Neil Horman5fa782c2010-04-28 10:30:59 +0000155 size_t paylen)
156{
157 sctp_errhdr_t err;
158 __u16 len;
159
160 /* Cause code constants are now defined in network order. */
161 err.cause = cause_code;
162 len = sizeof(sctp_errhdr_t) + paylen;
163 err.length = htons(len);
164
Wei Yongjun2e3219b2010-05-17 22:51:58 -0700165 if (skb_tailroom(chunk->skb) < len)
Neil Horman5fa782c2010-04-28 10:30:59 +0000166 return -ENOSPC;
167 chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk,
168 sizeof(sctp_errhdr_t),
169 &err);
170 return 0;
171}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172/* 3.3.2 Initiation (INIT) (1)
173 *
174 * This chunk is used to initiate a SCTP association between two
175 * endpoints. The format of the INIT chunk is shown below:
176 *
177 * 0 1 2 3
178 * 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
179 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
180 * | Type = 1 | Chunk Flags | Chunk Length |
181 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
182 * | Initiate Tag |
183 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
184 * | Advertised Receiver Window Credit (a_rwnd) |
185 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
186 * | Number of Outbound Streams | Number of Inbound Streams |
187 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
188 * | Initial TSN |
189 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
190 * \ \
191 * / Optional/Variable-Length Parameters /
192 * \ \
193 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
194 *
195 *
196 * The INIT chunk contains the following parameters. Unless otherwise
197 * noted, each parameter MUST only be included once in the INIT chunk.
198 *
199 * Fixed Parameters Status
200 * ----------------------------------------------
201 * Initiate Tag Mandatory
202 * Advertised Receiver Window Credit Mandatory
203 * Number of Outbound Streams Mandatory
204 * Number of Inbound Streams Mandatory
205 * Initial TSN Mandatory
206 *
207 * Variable Parameters Status Type Value
208 * -------------------------------------------------------------
209 * IPv4 Address (Note 1) Optional 5
210 * IPv6 Address (Note 1) Optional 6
211 * Cookie Preservative Optional 9
212 * Reserved for ECN Capable (Note 2) Optional 32768 (0x8000)
213 * Host Name Address (Note 3) Optional 11
214 * Supported Address Types (Note 4) Optional 12
215 */
216struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
217 const struct sctp_bind_addr *bp,
Al Virodd0fc662005-10-07 07:46:04 +0100218 gfp_t gfp, int vparam_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000220 struct net *net = sock_net(asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 sctp_inithdr_t init;
222 union sctp_params addrs;
223 size_t chunksize;
224 struct sctp_chunk *retval = NULL;
225 int num_types, addrs_len = 0;
226 struct sctp_sock *sp;
227 sctp_supported_addrs_param_t sat;
Al Viro3dbe8652006-11-20 17:25:49 -0800228 __be16 types[2];
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -0800229 sctp_adaptation_ind_param_t aiparam;
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700230 sctp_supported_ext_param_t ext_param;
231 int num_ext = 0;
232 __u8 extensions[3];
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700233 sctp_paramhdr_t *auth_chunks = NULL,
234 *auth_hmacs = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 /* RFC 2960 3.3.2 Initiation (INIT) (1)
237 *
238 * Note 1: The INIT chunks can contain multiple addresses that
239 * can be IPv4 and/or IPv6 in any combination.
240 */
241 retval = NULL;
242
243 /* Convert the provided bind address list to raw format. */
244 addrs = sctp_bind_addrs_to_raw(bp, &addrs_len, gfp);
245
246 init.init_tag = htonl(asoc->c.my_vtag);
247 init.a_rwnd = htonl(asoc->rwnd);
248 init.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
249 init.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
250 init.initial_tsn = htonl(asoc->c.initial_tsn);
251
252 /* How many address types are needed? */
253 sp = sctp_sk(asoc->base.sk);
254 num_types = sp->pf->supported_addrs(sp, types);
255
Wei Yongjuna8170c32010-04-28 08:47:21 +0000256 chunksize = sizeof(init) + addrs_len;
257 chunksize += WORD_ROUND(SCTP_SAT_LEN(num_types));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 chunksize += sizeof(ecap_param);
Vlad Yasevich8ee4be32007-11-29 08:50:35 -0500259
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000260 if (net->sctp.prsctp_enable)
Vlad Yasevich036b5792008-01-07 00:28:16 -0800261 chunksize += sizeof(prsctp_param);
262
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700263 /* ADDIP: Section 4.2.7:
264 * An implementation supporting this extension [ADDIP] MUST list
265 * the ASCONF,the ASCONF-ACK, and the AUTH chunks in its INIT and
266 * INIT-ACK parameters.
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700267 */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000268 if (net->sctp.addip_enable) {
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700269 extensions[num_ext] = SCTP_CID_ASCONF;
270 extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
271 num_ext += 2;
272 }
273
malc6fc791e2009-03-12 09:49:20 +0000274 if (sp->adaptation_ind)
275 chunksize += sizeof(aiparam);
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 chunksize += vparam_len;
278
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700279 /* Account for AUTH related parameters */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000280 if (net->sctp.auth_enable) {
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700281 /* Add random parameter length*/
282 chunksize += sizeof(asoc->c.auth_random);
283
284 /* Add HMACS parameter length if any were defined */
285 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
286 if (auth_hmacs->length)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000287 chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700288 else
289 auth_hmacs = NULL;
290
291 /* Add CHUNKS parameter length */
292 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
293 if (auth_chunks->length)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000294 chunksize += WORD_ROUND(ntohs(auth_chunks->length));
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700295 else
Vlad Yasevich9baffaa2007-11-29 08:44:34 -0500296 auth_chunks = NULL;
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700297
298 extensions[num_ext] = SCTP_CID_AUTH;
299 num_ext += 1;
300 }
301
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700302 /* If we have any extensions to report, account for that */
303 if (num_ext)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000304 chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
305 num_ext);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 /* RFC 2960 3.3.2 Initiation (INIT) (1)
308 *
309 * Note 3: An INIT chunk MUST NOT contain more than one Host
310 * Name address parameter. Moreover, the sender of the INIT
311 * MUST NOT combine any other address types with the Host Name
312 * address in the INIT. The receiver of INIT MUST ignore any
313 * other address types if the Host Name address parameter is
314 * present in the received INIT chunk.
315 *
316 * PLEASE DO NOT FIXME [This version does not support Host Name.]
317 */
318
Vlad Yasevich072017b2013-08-09 22:05:36 -0400319 retval = sctp_make_control(asoc, SCTP_CID_INIT, 0, chunksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 if (!retval)
321 goto nodata;
322
323 retval->subh.init_hdr =
324 sctp_addto_chunk(retval, sizeof(init), &init);
325 retval->param_hdr.v =
326 sctp_addto_chunk(retval, addrs_len, addrs.v);
327
328 /* RFC 2960 3.3.2 Initiation (INIT) (1)
329 *
330 * Note 4: This parameter, when present, specifies all the
331 * address types the sending endpoint can support. The absence
332 * of this parameter indicates that the sending endpoint can
333 * support any address type.
334 */
335 sat.param_hdr.type = SCTP_PARAM_SUPPORTED_ADDRESS_TYPES;
336 sat.param_hdr.length = htons(SCTP_SAT_LEN(num_types));
337 sctp_addto_chunk(retval, sizeof(sat), &sat);
338 sctp_addto_chunk(retval, num_types * sizeof(__u16), &types);
339
340 sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700341
Joe Perches7aa1b542007-12-20 14:03:52 -0800342 /* Add the supported extensions parameter. Be nice and add this
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700343 * fist before addiding the parameters for the extensions themselves
344 */
345 if (num_ext) {
346 ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
347 ext_param.param_hdr.length =
348 htons(sizeof(sctp_supported_ext_param_t) + num_ext);
349 sctp_addto_chunk(retval, sizeof(sctp_supported_ext_param_t),
350 &ext_param);
Vlad Yasevich8ee4be32007-11-29 08:50:35 -0500351 sctp_addto_param(retval, num_ext, extensions);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700352 }
353
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000354 if (net->sctp.prsctp_enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700356
malc6fc791e2009-03-12 09:49:20 +0000357 if (sp->adaptation_ind) {
358 aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
359 aiparam.param_hdr.length = htons(sizeof(aiparam));
360 aiparam.adaptation_ind = htonl(sp->adaptation_ind);
361 sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
362 }
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700363
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700364 /* Add SCTP-AUTH chunks to the parameter list */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000365 if (net->sctp.auth_enable) {
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700366 sctp_addto_chunk(retval, sizeof(asoc->c.auth_random),
367 asoc->c.auth_random);
368 if (auth_hmacs)
369 sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
370 auth_hmacs);
371 if (auth_chunks)
372 sctp_addto_chunk(retval, ntohs(auth_chunks->length),
373 auth_chunks);
374 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375nodata:
Jesper Juhla51482b2005-11-08 09:41:34 -0800376 kfree(addrs.v);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return retval;
378}
379
380struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
381 const struct sctp_chunk *chunk,
Al Virodd0fc662005-10-07 07:46:04 +0100382 gfp_t gfp, int unkparam_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
384 sctp_inithdr_t initack;
385 struct sctp_chunk *retval;
386 union sctp_params addrs;
malc6fc791e2009-03-12 09:49:20 +0000387 struct sctp_sock *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 int addrs_len;
389 sctp_cookie_param_t *cookie;
390 int cookie_len;
391 size_t chunksize;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -0800392 sctp_adaptation_ind_param_t aiparam;
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700393 sctp_supported_ext_param_t ext_param;
394 int num_ext = 0;
395 __u8 extensions[3];
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700396 sctp_paramhdr_t *auth_chunks = NULL,
397 *auth_hmacs = NULL,
398 *auth_random = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
400 retval = NULL;
401
402 /* Note: there may be no addresses to embed. */
403 addrs = sctp_bind_addrs_to_raw(&asoc->base.bind_addr, &addrs_len, gfp);
404
405 initack.init_tag = htonl(asoc->c.my_vtag);
406 initack.a_rwnd = htonl(asoc->rwnd);
407 initack.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
408 initack.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
409 initack.initial_tsn = htonl(asoc->c.initial_tsn);
410
411 /* FIXME: We really ought to build the cookie right
412 * into the packet instead of allocating more fresh memory.
413 */
414 cookie = sctp_pack_cookie(asoc->ep, asoc, chunk, &cookie_len,
415 addrs.v, addrs_len);
416 if (!cookie)
417 goto nomem_cookie;
418
419 /* Calculate the total size of allocation, include the reserved
420 * space for reporting unknown parameters if it is specified.
421 */
malc6fc791e2009-03-12 09:49:20 +0000422 sp = sctp_sk(asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 chunksize = sizeof(initack) + addrs_len + cookie_len + unkparam_len;
424
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900425 /* Tell peer that we'll do ECN only if peer advertised such cap. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 if (asoc->peer.ecn_capable)
427 chunksize += sizeof(ecap_param);
428
Wei Yongjun5ffad5a2009-03-12 09:49:18 +0000429 if (asoc->peer.prsctp_capable)
Vlad Yasevich036b5792008-01-07 00:28:16 -0800430 chunksize += sizeof(prsctp_param);
431
Wei Yongjun5ffad5a2009-03-12 09:49:18 +0000432 if (asoc->peer.asconf_capable) {
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700433 extensions[num_ext] = SCTP_CID_ASCONF;
434 extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
435 num_ext += 2;
436 }
437
malc6fc791e2009-03-12 09:49:20 +0000438 if (sp->adaptation_ind)
439 chunksize += sizeof(aiparam);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700441 if (asoc->peer.auth_capable) {
442 auth_random = (sctp_paramhdr_t *)asoc->c.auth_random;
443 chunksize += ntohs(auth_random->length);
444
445 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
446 if (auth_hmacs->length)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000447 chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700448 else
449 auth_hmacs = NULL;
450
451 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
452 if (auth_chunks->length)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000453 chunksize += WORD_ROUND(ntohs(auth_chunks->length));
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700454 else
455 auth_chunks = NULL;
456
457 extensions[num_ext] = SCTP_CID_AUTH;
458 num_ext += 1;
459 }
460
Vlad Yasevich8ee4be32007-11-29 08:50:35 -0500461 if (num_ext)
Wei Yongjuna8170c32010-04-28 08:47:21 +0000462 chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
463 num_ext);
Vlad Yasevich8ee4be32007-11-29 08:50:35 -0500464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 /* Now allocate and fill out the chunk. */
Vlad Yasevich072017b2013-08-09 22:05:36 -0400466 retval = sctp_make_control(asoc, SCTP_CID_INIT_ACK, 0, chunksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (!retval)
468 goto nomem_chunk;
469
Dan Carpenterb99a4d52010-04-30 22:41:09 -0400470 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
471 *
472 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
473 * HEARTBEAT ACK, * etc.) to the same destination transport
474 * address from which it received the DATA or control chunk
475 * to which it is replying.
476 *
477 * [INIT ACK back to where the INIT came from.]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 */
479 retval->transport = chunk->transport;
Dan Carpenterb99a4d52010-04-30 22:41:09 -0400480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 retval->subh.init_hdr =
482 sctp_addto_chunk(retval, sizeof(initack), &initack);
483 retval->param_hdr.v = sctp_addto_chunk(retval, addrs_len, addrs.v);
484 sctp_addto_chunk(retval, cookie_len, cookie);
485 if (asoc->peer.ecn_capable)
486 sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700487 if (num_ext) {
488 ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
489 ext_param.param_hdr.length =
490 htons(sizeof(sctp_supported_ext_param_t) + num_ext);
491 sctp_addto_chunk(retval, sizeof(sctp_supported_ext_param_t),
492 &ext_param);
Vlad Yasevich8ee4be32007-11-29 08:50:35 -0500493 sctp_addto_param(retval, num_ext, extensions);
Vlad Yasevich131a47e2007-09-16 15:53:56 -0700494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (asoc->peer.prsctp_capable)
496 sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
497
malc6fc791e2009-03-12 09:49:20 +0000498 if (sp->adaptation_ind) {
499 aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
500 aiparam.param_hdr.length = htons(sizeof(aiparam));
501 aiparam.adaptation_ind = htonl(sp->adaptation_ind);
502 sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Vlad Yasevich730fc3d2007-09-16 19:32:11 -0700505 if (asoc->peer.auth_capable) {
506 sctp_addto_chunk(retval, ntohs(auth_random->length),
507 auth_random);
508 if (auth_hmacs)
509 sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
510 auth_hmacs);
511 if (auth_chunks)
512 sctp_addto_chunk(retval, ntohs(auth_chunks->length),
513 auth_chunks);
514 }
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 /* We need to remove the const qualifier at this point. */
517 retval->asoc = (struct sctp_association *) asoc;
518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519nomem_chunk:
520 kfree(cookie);
521nomem_cookie:
Jesper Juhla51482b2005-11-08 09:41:34 -0800522 kfree(addrs.v);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return retval;
524}
525
526/* 3.3.11 Cookie Echo (COOKIE ECHO) (10):
527 *
528 * This chunk is used only during the initialization of an association.
529 * It is sent by the initiator of an association to its peer to complete
530 * the initialization process. This chunk MUST precede any DATA chunk
531 * sent within the association, but MAY be bundled with one or more DATA
532 * chunks in the same packet.
533 *
534 * 0 1 2 3
535 * 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
536 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
537 * | Type = 10 |Chunk Flags | Length |
538 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
539 * / Cookie /
540 * \ \
541 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
542 *
543 * Chunk Flags: 8 bit
544 *
545 * Set to zero on transmit and ignored on receipt.
546 *
547 * Length: 16 bits (unsigned integer)
548 *
549 * Set to the size of the chunk in bytes, including the 4 bytes of
550 * the chunk header and the size of the Cookie.
551 *
552 * Cookie: variable size
553 *
554 * This field must contain the exact cookie received in the
555 * State Cookie parameter from the previous INIT ACK.
556 *
557 * An implementation SHOULD make the cookie as small as possible
558 * to insure interoperability.
559 */
560struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *asoc,
561 const struct sctp_chunk *chunk)
562{
563 struct sctp_chunk *retval;
564 void *cookie;
565 int cookie_len;
566
567 cookie = asoc->peer.cookie;
568 cookie_len = asoc->peer.cookie_len;
569
570 /* Build a cookie echo chunk. */
Vlad Yasevich072017b2013-08-09 22:05:36 -0400571 retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ECHO, 0, cookie_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (!retval)
573 goto nodata;
574 retval->subh.cookie_hdr =
575 sctp_addto_chunk(retval, cookie_len, cookie);
576
577 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
578 *
579 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
580 * HEARTBEAT ACK, * etc.) to the same destination transport
581 * address from which it * received the DATA or control chunk
582 * to which it is replying.
583 *
584 * [COOKIE ECHO back to where the INIT ACK came from.]
585 */
586 if (chunk)
587 retval->transport = chunk->transport;
588
589nodata:
590 return retval;
591}
592
593/* 3.3.12 Cookie Acknowledgement (COOKIE ACK) (11):
594 *
595 * This chunk is used only during the initialization of an
596 * association. It is used to acknowledge the receipt of a COOKIE
597 * ECHO chunk. This chunk MUST precede any DATA or SACK chunk sent
598 * within the association, but MAY be bundled with one or more DATA
599 * chunks or SACK chunk in the same SCTP packet.
600 *
601 * 0 1 2 3
602 * 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
603 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
604 * | Type = 11 |Chunk Flags | Length = 4 |
605 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
606 *
607 * Chunk Flags: 8 bits
608 *
609 * Set to zero on transmit and ignored on receipt.
610 */
611struct sctp_chunk *sctp_make_cookie_ack(const struct sctp_association *asoc,
612 const struct sctp_chunk *chunk)
613{
614 struct sctp_chunk *retval;
615
Vlad Yasevich072017b2013-08-09 22:05:36 -0400616 retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ACK, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
619 *
620 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
621 * HEARTBEAT ACK, * etc.) to the same destination transport
622 * address from which it * received the DATA or control chunk
623 * to which it is replying.
624 *
625 * [COOKIE ACK back to where the COOKIE ECHO came from.]
626 */
627 if (retval && chunk)
628 retval->transport = chunk->transport;
629
630 return retval;
631}
632
633/*
634 * Appendix A: Explicit Congestion Notification:
635 * CWR:
636 *
637 * RFC 2481 details a specific bit for a sender to send in the header of
638 * its next outbound TCP segment to indicate to its peer that it has
639 * reduced its congestion window. This is termed the CWR bit. For
640 * SCTP the same indication is made by including the CWR chunk.
641 * This chunk contains one data element, i.e. the TSN number that
642 * was sent in the ECNE chunk. This element represents the lowest
643 * TSN number in the datagram that was originally marked with the
644 * CE bit.
645 *
646 * 0 1 2 3
647 * 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
648 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
649 * | Chunk Type=13 | Flags=00000000| Chunk Length = 8 |
650 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
651 * | Lowest TSN Number |
652 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
653 *
654 * Note: The CWR is considered a Control chunk.
655 */
656struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc,
657 const __u32 lowest_tsn,
658 const struct sctp_chunk *chunk)
659{
660 struct sctp_chunk *retval;
661 sctp_cwrhdr_t cwr;
662
663 cwr.lowest_tsn = htonl(lowest_tsn);
Vlad Yasevich072017b2013-08-09 22:05:36 -0400664 retval = sctp_make_control(asoc, SCTP_CID_ECN_CWR, 0,
665 sizeof(sctp_cwrhdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
667 if (!retval)
668 goto nodata;
669
670 retval->subh.ecn_cwr_hdr =
671 sctp_addto_chunk(retval, sizeof(cwr), &cwr);
672
673 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
674 *
675 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
676 * HEARTBEAT ACK, * etc.) to the same destination transport
677 * address from which it * received the DATA or control chunk
678 * to which it is replying.
679 *
680 * [Report a reduced congestion window back to where the ECNE
681 * came from.]
682 */
683 if (chunk)
684 retval->transport = chunk->transport;
685
686nodata:
687 return retval;
688}
689
690/* Make an ECNE chunk. This is a congestion experienced report. */
691struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc,
692 const __u32 lowest_tsn)
693{
694 struct sctp_chunk *retval;
695 sctp_ecnehdr_t ecne;
696
697 ecne.lowest_tsn = htonl(lowest_tsn);
Vlad Yasevich072017b2013-08-09 22:05:36 -0400698 retval = sctp_make_control(asoc, SCTP_CID_ECN_ECNE, 0,
699 sizeof(sctp_ecnehdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (!retval)
701 goto nodata;
702 retval->subh.ecne_hdr =
703 sctp_addto_chunk(retval, sizeof(ecne), &ecne);
704
705nodata:
706 return retval;
707}
708
709/* Make a DATA chunk for the given association from the provided
710 * parameters. However, do not populate the data payload.
711 */
712struct sctp_chunk *sctp_make_datafrag_empty(struct sctp_association *asoc,
713 const struct sctp_sndrcvinfo *sinfo,
714 int data_len, __u8 flags, __u16 ssn)
715{
716 struct sctp_chunk *retval;
717 struct sctp_datahdr dp;
718 int chunk_len;
719
720 /* We assign the TSN as LATE as possible, not here when
721 * creating the chunk.
722 */
723 dp.tsn = 0;
724 dp.stream = htons(sinfo->sinfo_stream);
725 dp.ppid = sinfo->sinfo_ppid;
726
727 /* Set the flags for an unordered send. */
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -0700728 if (sinfo->sinfo_flags & SCTP_UNORDERED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 flags |= SCTP_DATA_UNORDERED;
730 dp.ssn = 0;
731 } else
732 dp.ssn = htons(ssn);
733
734 chunk_len = sizeof(dp) + data_len;
Vlad Yasevich072017b2013-08-09 22:05:36 -0400735 retval = sctp_make_data(asoc, flags, chunk_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 if (!retval)
737 goto nodata;
738
739 retval->subh.data_hdr = sctp_addto_chunk(retval, sizeof(dp), &dp);
740 memcpy(&retval->sinfo, sinfo, sizeof(struct sctp_sndrcvinfo));
741
742nodata:
743 return retval;
744}
745
746/* Create a selective ackowledgement (SACK) for the given
747 * association. This reports on which TSN's we've seen to date,
748 * including duplicates and gaps.
749 */
750struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc)
751{
752 struct sctp_chunk *retval;
753 struct sctp_sackhdr sack;
754 int len;
755 __u32 ctsn;
756 __u16 num_gabs, num_dup_tsns;
Neil Horman42448542012-06-30 03:04:26 +0000757 struct sctp_association *aptr = (struct sctp_association *)asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
Vlad Yasevich02015182008-10-08 14:19:01 -0700759 struct sctp_gap_ack_block gabs[SCTP_MAX_GABS];
Neil Horman42448542012-06-30 03:04:26 +0000760 struct sctp_transport *trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Vlad Yasevich02015182008-10-08 14:19:01 -0700762 memset(gabs, 0, sizeof(gabs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 ctsn = sctp_tsnmap_get_ctsn(map);
Daniel Borkmannbb333812013-06-28 19:49:40 +0200764
765 pr_debug("%s: sackCTSNAck sent:0x%x\n", __func__, ctsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 /* How much room is needed in the chunk? */
Vlad Yasevich02015182008-10-08 14:19:01 -0700768 num_gabs = sctp_tsnmap_num_gabs(map, gabs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 num_dup_tsns = sctp_tsnmap_num_dups(map);
770
771 /* Initialize the SACK header. */
772 sack.cum_tsn_ack = htonl(ctsn);
773 sack.a_rwnd = htonl(asoc->a_rwnd);
774 sack.num_gap_ack_blocks = htons(num_gabs);
775 sack.num_dup_tsns = htons(num_dup_tsns);
776
777 len = sizeof(sack)
778 + sizeof(struct sctp_gap_ack_block) * num_gabs
779 + sizeof(__u32) * num_dup_tsns;
780
781 /* Create the chunk. */
Vlad Yasevich072017b2013-08-09 22:05:36 -0400782 retval = sctp_make_control(asoc, SCTP_CID_SACK, 0, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 if (!retval)
784 goto nodata;
785
786 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
787 *
788 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
789 * HEARTBEAT ACK, etc.) to the same destination transport
790 * address from which it received the DATA or control chunk to
791 * which it is replying. This rule should also be followed if
792 * the endpoint is bundling DATA chunks together with the
793 * reply chunk.
794 *
795 * However, when acknowledging multiple DATA chunks received
796 * in packets from different source addresses in a single
797 * SACK, the SACK chunk may be transmitted to one of the
798 * destination transport addresses from which the DATA or
799 * control chunks being acknowledged were received.
800 *
801 * [BUG: We do not implement the following paragraph.
802 * Perhaps we should remember the last transport we used for a
803 * SACK and avoid that (if possible) if we have seen any
804 * duplicates. --piggy]
805 *
806 * When a receiver of a duplicate DATA chunk sends a SACK to a
807 * multi- homed endpoint it MAY be beneficial to vary the
808 * destination address and not use the source address of the
809 * DATA chunk. The reason being that receiving a duplicate
810 * from a multi-homed endpoint might indicate that the return
811 * path (as specified in the source address of the DATA chunk)
812 * for the SACK is broken.
813 *
814 * [Send to the address from which we last received a DATA chunk.]
815 */
816 retval->transport = asoc->peer.last_data_from;
817
818 retval->subh.sack_hdr =
819 sctp_addto_chunk(retval, sizeof(sack), &sack);
820
821 /* Add the gap ack block information. */
822 if (num_gabs)
823 sctp_addto_chunk(retval, sizeof(__u32) * num_gabs,
Vlad Yasevich02015182008-10-08 14:19:01 -0700824 gabs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 /* Add the duplicate TSN information. */
Michele Baldessari196d6752012-12-01 04:49:42 +0000827 if (num_dup_tsns) {
828 aptr->stats.idupchunks += num_dup_tsns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 sctp_addto_chunk(retval, sizeof(__u32) * num_dup_tsns,
830 sctp_tsnmap_get_dups(map));
Michele Baldessari196d6752012-12-01 04:49:42 +0000831 }
Neil Horman42448542012-06-30 03:04:26 +0000832 /* Once we have a sack generated, check to see what our sack
833 * generation is, if its 0, reset the transports to 0, and reset
834 * the association generation to 1
835 *
836 * The idea is that zero is never used as a valid generation for the
837 * association so no transport will match after a wrap event like this,
838 * Until the next sack
839 */
840 if (++aptr->peer.sack_generation == 0) {
841 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
842 transports)
843 trans->sack_generation = 0;
844 aptr->peer.sack_generation = 1;
845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846nodata:
847 return retval;
848}
849
850/* Make a SHUTDOWN chunk. */
851struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,
852 const struct sctp_chunk *chunk)
853{
854 struct sctp_chunk *retval;
855 sctp_shutdownhdr_t shut;
856 __u32 ctsn;
857
858 ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
859 shut.cum_tsn_ack = htonl(ctsn);
860
Vlad Yasevich072017b2013-08-09 22:05:36 -0400861 retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN, 0,
862 sizeof(sctp_shutdownhdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 if (!retval)
864 goto nodata;
865
866 retval->subh.shutdown_hdr =
867 sctp_addto_chunk(retval, sizeof(shut), &shut);
868
869 if (chunk)
870 retval->transport = chunk->transport;
871nodata:
872 return retval;
873}
874
875struct sctp_chunk *sctp_make_shutdown_ack(const struct sctp_association *asoc,
876 const struct sctp_chunk *chunk)
877{
878 struct sctp_chunk *retval;
879
Vlad Yasevich072017b2013-08-09 22:05:36 -0400880 retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
883 *
884 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
885 * HEARTBEAT ACK, * etc.) to the same destination transport
886 * address from which it * received the DATA or control chunk
887 * to which it is replying.
888 *
889 * [ACK back to where the SHUTDOWN came from.]
890 */
891 if (retval && chunk)
892 retval->transport = chunk->transport;
893
894 return retval;
895}
896
897struct sctp_chunk *sctp_make_shutdown_complete(
898 const struct sctp_association *asoc,
899 const struct sctp_chunk *chunk)
900{
901 struct sctp_chunk *retval;
902 __u8 flags = 0;
903
Jerome Forissier047a2422005-04-28 11:58:43 -0700904 /* Set the T-bit if we have no association (vtag will be
905 * reflected)
906 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
908
Vlad Yasevich072017b2013-08-09 22:05:36 -0400909 retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
911 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
912 *
913 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
914 * HEARTBEAT ACK, * etc.) to the same destination transport
915 * address from which it * received the DATA or control chunk
916 * to which it is replying.
917 *
918 * [Report SHUTDOWN COMPLETE back to where the SHUTDOWN ACK
919 * came from.]
920 */
921 if (retval && chunk)
922 retval->transport = chunk->transport;
923
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900924 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925}
926
927/* Create an ABORT. Note that we set the T bit if we have no
Jerome Forissier047a2422005-04-28 11:58:43 -0700928 * association, except when responding to an INIT (sctpimpguide 2.41).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 */
930struct sctp_chunk *sctp_make_abort(const struct sctp_association *asoc,
931 const struct sctp_chunk *chunk,
932 const size_t hint)
933{
934 struct sctp_chunk *retval;
935 __u8 flags = 0;
936
Jerome Forissier047a2422005-04-28 11:58:43 -0700937 /* Set the T-bit if we have no association and 'chunk' is not
938 * an INIT (vtag will be reflected).
939 */
940 if (!asoc) {
941 if (chunk && chunk->chunk_hdr &&
942 chunk->chunk_hdr->type == SCTP_CID_INIT)
943 flags = 0;
944 else
945 flags = SCTP_CHUNK_FLAG_T;
946 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
Vlad Yasevich072017b2013-08-09 22:05:36 -0400948 retval = sctp_make_control(asoc, SCTP_CID_ABORT, flags, hint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
951 *
952 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
953 * HEARTBEAT ACK, * etc.) to the same destination transport
954 * address from which it * received the DATA or control chunk
955 * to which it is replying.
956 *
957 * [ABORT back to where the offender came from.]
958 */
959 if (retval && chunk)
960 retval->transport = chunk->transport;
961
962 return retval;
963}
964
965/* Helper to create ABORT with a NO_USER_DATA error. */
966struct sctp_chunk *sctp_make_abort_no_data(
967 const struct sctp_association *asoc,
968 const struct sctp_chunk *chunk, __u32 tsn)
969{
970 struct sctp_chunk *retval;
Al Viro9f81bcd2006-11-20 17:26:34 -0800971 __be32 payload;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t)
974 + sizeof(tsn));
975
976 if (!retval)
977 goto no_mem;
978
979 /* Put the tsn back into network byte order. */
980 payload = htonl(tsn);
Wei Yongjun00f1c2d2007-08-21 15:50:01 +0800981 sctp_init_cause(retval, SCTP_ERROR_NO_DATA, sizeof(payload));
982 sctp_addto_chunk(retval, sizeof(payload), (const void *)&payload);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
985 *
986 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
987 * HEARTBEAT ACK, * etc.) to the same destination transport
988 * address from which it * received the DATA or control chunk
989 * to which it is replying.
990 *
991 * [ABORT back to where the offender came from.]
992 */
993 if (chunk)
994 retval->transport = chunk->transport;
995
996no_mem:
997 return retval;
998}
999
1000/* Helper to create ABORT with a SCTP_ERROR_USER_ABORT error. */
1001struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc,
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001002 const struct msghdr *msg,
1003 size_t paylen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004{
1005 struct sctp_chunk *retval;
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001006 void *payload = NULL;
1007 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001009 retval = sctp_make_abort(asoc, NULL, sizeof(sctp_errhdr_t) + paylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 if (!retval)
1011 goto err_chunk;
1012
1013 if (paylen) {
1014 /* Put the msg_iov together into payload. */
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001015 payload = kmalloc(paylen, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 if (!payload)
1017 goto err_payload;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001019 err = memcpy_fromiovec(payload, msg->msg_iov, paylen);
1020 if (err < 0)
1021 goto err_copy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001024 sctp_init_cause(retval, SCTP_ERROR_USER_ABORT, paylen);
1025 sctp_addto_chunk(retval, paylen, payload);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 if (paylen)
1028 kfree(payload);
1029
1030 return retval;
1031
1032err_copy:
1033 kfree(payload);
1034err_payload:
1035 sctp_chunk_free(retval);
1036 retval = NULL;
1037err_chunk:
1038 return retval;
1039}
1040
Adrian Bunk5c94bf82007-09-12 15:16:21 +02001041/* Append bytes to the end of a parameter. Will panic if chunk is not big
1042 * enough.
1043 */
1044static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
1045 const void *data)
1046{
1047 void *target;
1048 int chunklen = ntohs(chunk->chunk_hdr->length);
1049
1050 target = skb_put(chunk->skb, len);
1051
Vlad Yasevich6383cfb2009-11-23 15:53:56 -05001052 if (data)
1053 memcpy(target, data, len);
1054 else
1055 memset(target, 0, len);
Adrian Bunk5c94bf82007-09-12 15:16:21 +02001056
1057 /* Adjust the chunk length field. */
1058 chunk->chunk_hdr->length = htons(chunklen + len);
1059 chunk->chunk_end = skb_tail_pointer(chunk->skb);
1060
1061 return target;
1062}
1063
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001064/* Make an ABORT chunk with a PROTOCOL VIOLATION cause code. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065struct sctp_chunk *sctp_make_abort_violation(
1066 const struct sctp_association *asoc,
1067 const struct sctp_chunk *chunk,
1068 const __u8 *payload,
1069 const size_t paylen)
1070{
1071 struct sctp_chunk *retval;
1072 struct sctp_paramhdr phdr;
1073
1074 retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t) + paylen
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001075 + sizeof(sctp_paramhdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 if (!retval)
1077 goto end;
1078
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001079 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, paylen
1080 + sizeof(sctp_paramhdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
1082 phdr.type = htons(chunk->chunk_hdr->type);
1083 phdr.length = chunk->chunk_hdr->length;
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001084 sctp_addto_chunk(retval, paylen, payload);
1085 sctp_addto_param(retval, sizeof(sctp_paramhdr_t), &phdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
1087end:
1088 return retval;
1089}
1090
Wei Yongjunba016672008-09-30 05:32:24 -07001091struct sctp_chunk *sctp_make_violation_paramlen(
1092 const struct sctp_association *asoc,
1093 const struct sctp_chunk *chunk,
1094 struct sctp_paramhdr *param)
1095{
1096 struct sctp_chunk *retval;
1097 static const char error[] = "The following parameter had invalid length:";
1098 size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t) +
1099 sizeof(sctp_paramhdr_t);
1100
1101 retval = sctp_make_abort(asoc, chunk, payload_len);
1102 if (!retval)
1103 goto nodata;
1104
1105 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION,
1106 sizeof(error) + sizeof(sctp_paramhdr_t));
1107 sctp_addto_chunk(retval, sizeof(error), error);
1108 sctp_addto_param(retval, sizeof(sctp_paramhdr_t), param);
1109
1110nodata:
1111 return retval;
1112}
1113
Neil Hormande4594a2012-11-20 10:14:30 +00001114struct sctp_chunk *sctp_make_violation_max_retrans(
1115 const struct sctp_association *asoc,
1116 const struct sctp_chunk *chunk)
1117{
1118 struct sctp_chunk *retval;
1119 static const char error[] = "Association exceeded its max_retans count";
1120 size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t);
1121
1122 retval = sctp_make_abort(asoc, chunk, payload_len);
1123 if (!retval)
1124 goto nodata;
1125
1126 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, sizeof(error));
1127 sctp_addto_chunk(retval, sizeof(error), error);
1128
1129nodata:
1130 return retval;
1131}
1132
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133/* Make a HEARTBEAT chunk. */
1134struct sctp_chunk *sctp_make_heartbeat(const struct sctp_association *asoc,
Wei Yongjun92c73af2011-04-19 21:31:47 +00001135 const struct sctp_transport *transport)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136{
Wei Yongjun92c73af2011-04-19 21:31:47 +00001137 struct sctp_chunk *retval;
1138 sctp_sender_hb_info_t hbinfo;
1139
Vlad Yasevich072017b2013-08-09 22:05:36 -04001140 retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT, 0, sizeof(hbinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 if (!retval)
1143 goto nodata;
1144
Wei Yongjun92c73af2011-04-19 21:31:47 +00001145 hbinfo.param_hdr.type = SCTP_PARAM_HEARTBEAT_INFO;
1146 hbinfo.param_hdr.length = htons(sizeof(sctp_sender_hb_info_t));
1147 hbinfo.daddr = transport->ipaddr;
1148 hbinfo.sent_at = jiffies;
1149 hbinfo.hb_nonce = transport->hb_nonce;
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 /* Cast away the 'const', as this is just telling the chunk
1152 * what transport it belongs to.
1153 */
1154 retval->transport = (struct sctp_transport *) transport;
Wei Yongjun92c73af2011-04-19 21:31:47 +00001155 retval->subh.hbs_hdr = sctp_addto_chunk(retval, sizeof(hbinfo),
1156 &hbinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158nodata:
1159 return retval;
1160}
1161
1162struct sctp_chunk *sctp_make_heartbeat_ack(const struct sctp_association *asoc,
1163 const struct sctp_chunk *chunk,
1164 const void *payload, const size_t paylen)
1165{
1166 struct sctp_chunk *retval;
1167
Vlad Yasevich072017b2013-08-09 22:05:36 -04001168 retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 if (!retval)
1170 goto nodata;
1171
1172 retval->subh.hbs_hdr = sctp_addto_chunk(retval, paylen, payload);
1173
1174 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1175 *
1176 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1177 * HEARTBEAT ACK, * etc.) to the same destination transport
1178 * address from which it * received the DATA or control chunk
1179 * to which it is replying.
1180 *
1181 * [HBACK back to where the HEARTBEAT came from.]
1182 */
1183 if (chunk)
1184 retval->transport = chunk->transport;
1185
1186nodata:
1187 return retval;
1188}
1189
1190/* Create an Operation Error chunk with the specified space reserved.
1191 * This routine can be used for containing multiple causes in the chunk.
1192 */
1193static struct sctp_chunk *sctp_make_op_error_space(
1194 const struct sctp_association *asoc,
1195 const struct sctp_chunk *chunk,
1196 size_t size)
1197{
1198 struct sctp_chunk *retval;
1199
Vlad Yasevich072017b2013-08-09 22:05:36 -04001200 retval = sctp_make_control(asoc, SCTP_CID_ERROR, 0,
1201 sizeof(sctp_errhdr_t) + size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 if (!retval)
1203 goto nodata;
1204
1205 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1206 *
1207 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1208 * HEARTBEAT ACK, etc.) to the same destination transport
1209 * address from which it received the DATA or control chunk
1210 * to which it is replying.
1211 *
1212 */
1213 if (chunk)
1214 retval->transport = chunk->transport;
1215
1216nodata:
1217 return retval;
1218}
1219
Neil Horman5fa782c2010-04-28 10:30:59 +00001220/* Create an Operation Error chunk of a fixed size,
1221 * specifically, max(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT)
1222 * This is a helper function to allocate an error chunk for
1223 * for those invalid parameter codes in which we may not want
Jorrit Schippersd82603c2012-12-27 17:33:02 +01001224 * to report all the errors, if the incoming chunk is large
Neil Horman5fa782c2010-04-28 10:30:59 +00001225 */
1226static inline struct sctp_chunk *sctp_make_op_error_fixed(
1227 const struct sctp_association *asoc,
1228 const struct sctp_chunk *chunk)
1229{
1230 size_t size = asoc ? asoc->pathmtu : 0;
1231
1232 if (!size)
1233 size = SCTP_DEFAULT_MAXSEGMENT;
1234
1235 return sctp_make_op_error_space(asoc, chunk, size);
1236}
1237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238/* Create an Operation Error chunk. */
1239struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc,
1240 const struct sctp_chunk *chunk,
Al Viro63706c52006-11-20 17:00:05 -08001241 __be16 cause_code, const void *payload,
Vlad Yasevich6383cfb2009-11-23 15:53:56 -05001242 size_t paylen, size_t reserve_tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243{
1244 struct sctp_chunk *retval;
1245
Vlad Yasevich6383cfb2009-11-23 15:53:56 -05001246 retval = sctp_make_op_error_space(asoc, chunk, paylen + reserve_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 if (!retval)
1248 goto nodata;
1249
Vlad Yasevich6383cfb2009-11-23 15:53:56 -05001250 sctp_init_cause(retval, cause_code, paylen + reserve_tail);
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001251 sctp_addto_chunk(retval, paylen, payload);
Vlad Yasevich6383cfb2009-11-23 15:53:56 -05001252 if (reserve_tail)
1253 sctp_addto_param(retval, reserve_tail, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
1255nodata:
1256 return retval;
1257}
1258
Vlad Yasevich4cd57c82007-09-16 19:32:45 -07001259struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc)
1260{
1261 struct sctp_chunk *retval;
1262 struct sctp_hmac *hmac_desc;
1263 struct sctp_authhdr auth_hdr;
1264 __u8 *hmac;
1265
1266 /* Get the first hmac that the peer told us to use */
1267 hmac_desc = sctp_auth_asoc_get_hmac(asoc);
1268 if (unlikely(!hmac_desc))
1269 return NULL;
1270
Vlad Yasevich072017b2013-08-09 22:05:36 -04001271 retval = sctp_make_control(asoc, SCTP_CID_AUTH, 0,
Vlad Yasevich4cd57c82007-09-16 19:32:45 -07001272 hmac_desc->hmac_len + sizeof(sctp_authhdr_t));
1273 if (!retval)
1274 return NULL;
1275
1276 auth_hdr.hmac_id = htons(hmac_desc->hmac_id);
1277 auth_hdr.shkey_id = htons(asoc->active_key_id);
1278
1279 retval->subh.auth_hdr = sctp_addto_chunk(retval, sizeof(sctp_authhdr_t),
1280 &auth_hdr);
1281
1282 hmac = skb_put(retval->skb, hmac_desc->hmac_len);
1283 memset(hmac, 0, hmac_desc->hmac_len);
1284
1285 /* Adjust the chunk header to include the empty MAC */
1286 retval->chunk_hdr->length =
1287 htons(ntohs(retval->chunk_hdr->length) + hmac_desc->hmac_len);
1288 retval->chunk_end = skb_tail_pointer(retval->skb);
1289
1290 return retval;
1291}
1292
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294/********************************************************************
1295 * 2nd Level Abstractions
1296 ********************************************************************/
1297
1298/* Turn an skb into a chunk.
1299 * FIXME: Eventually move the structure directly inside the skb->cb[].
1300 */
1301struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
1302 const struct sctp_association *asoc,
1303 struct sock *sk)
1304{
1305 struct sctp_chunk *retval;
1306
Robert P. J. Dayc3762222007-02-10 01:45:03 -08001307 retval = kmem_cache_zalloc(sctp_chunk_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 if (!retval)
1310 goto nodata;
Daniel Borkmannbb333812013-06-28 19:49:40 +02001311 if (!sk)
1312 pr_debug("%s: chunkifying skb:%p w/o an sk\n", __func__, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
David S. Miller79af02c2005-07-08 21:47:49 -07001314 INIT_LIST_HEAD(&retval->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 retval->skb = skb;
1316 retval->asoc = (struct sctp_association *)asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 retval->has_tsn = 0;
1318 retval->has_ssn = 0;
1319 retval->rtt_in_progress = 0;
1320 retval->sent_at = 0;
1321 retval->singleton = 1;
1322 retval->end_of_packet = 0;
1323 retval->ecn_ce_done = 0;
1324 retval->pdiscard = 0;
1325
1326 /* sctpimpguide-05.txt Section 2.8.2
1327 * M1) Each time a new DATA chunk is transmitted
1328 * set the 'TSN.Missing.Report' count for that TSN to 0. The
1329 * 'TSN.Missing.Report' count will be used to determine missing chunks
1330 * and when to fast retransmit.
1331 */
1332 retval->tsn_missing_report = 0;
1333 retval->tsn_gap_acked = 0;
Neil Hormanc226ef92008-07-25 12:44:09 -04001334 retval->fast_retransmit = SCTP_CAN_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
1336 /* If this is a fragmented message, track all fragments
1337 * of the message (for SEND_FAILED).
1338 */
1339 retval->msg = NULL;
1340
1341 /* Polish the bead hole. */
1342 INIT_LIST_HEAD(&retval->transmitted_list);
1343 INIT_LIST_HEAD(&retval->frag_list);
1344 SCTP_DBG_OBJCNT_INC(chunk);
1345 atomic_set(&retval->refcnt, 1);
1346
1347nodata:
1348 return retval;
1349}
1350
1351/* Set chunk->source and dest based on the IP header in chunk->skb. */
1352void sctp_init_addrs(struct sctp_chunk *chunk, union sctp_addr *src,
1353 union sctp_addr *dest)
1354{
Al Virof235fca2006-11-20 17:09:01 -08001355 memcpy(&chunk->source, src, sizeof(union sctp_addr));
Al Viro16b0a032006-11-20 17:13:38 -08001356 memcpy(&chunk->dest, dest, sizeof(union sctp_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
1358
1359/* Extract the source address from a chunk. */
1360const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)
1361{
1362 /* If we have a known transport, use that. */
1363 if (chunk->transport) {
Al Viro6a1e5f32006-11-20 17:12:25 -08001364 return &chunk->transport->ipaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 } else {
1366 /* Otherwise, extract it from the IP header. */
Al Viro6a1e5f32006-11-20 17:12:25 -08001367 return &chunk->source;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369}
1370
1371/* Create a new chunk, setting the type and flags headers from the
1372 * arguments, reserving enough space for a 'paylen' byte payload.
1373 */
Vlad Yasevich072017b2013-08-09 22:05:36 -04001374static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
1375 __u8 type, __u8 flags, int paylen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376{
1377 struct sctp_chunk *retval;
1378 sctp_chunkhdr_t *chunk_hdr;
1379 struct sk_buff *skb;
1380 struct sock *sk;
1381
1382 /* No need to allocate LL here, as this is only a chunk. */
1383 skb = alloc_skb(WORD_ROUND(sizeof(sctp_chunkhdr_t) + paylen),
1384 GFP_ATOMIC);
1385 if (!skb)
1386 goto nodata;
1387
1388 /* Make room for the chunk header. */
1389 chunk_hdr = (sctp_chunkhdr_t *)skb_put(skb, sizeof(sctp_chunkhdr_t));
1390 chunk_hdr->type = type;
1391 chunk_hdr->flags = flags;
1392 chunk_hdr->length = htons(sizeof(sctp_chunkhdr_t));
1393
1394 sk = asoc ? asoc->base.sk : NULL;
1395 retval = sctp_chunkify(skb, asoc, sk);
1396 if (!retval) {
1397 kfree_skb(skb);
1398 goto nodata;
1399 }
1400
1401 retval->chunk_hdr = chunk_hdr;
1402 retval->chunk_end = ((__u8 *)chunk_hdr) + sizeof(struct sctp_chunkhdr);
1403
Vlad Yasevich4cd57c82007-09-16 19:32:45 -07001404 /* Determine if the chunk needs to be authenticated */
1405 if (sctp_auth_send_cid(type, asoc))
1406 retval->auth = 1;
1407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 return retval;
1409nodata:
1410 return NULL;
1411}
1412
Vlad Yasevich072017b2013-08-09 22:05:36 -04001413static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
1414 __u8 flags, int paylen)
1415{
1416 return _sctp_make_chunk(asoc, SCTP_CID_DATA, flags, paylen);
1417}
1418
1419static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
1420 __u8 type, __u8 flags, int paylen)
1421{
1422 struct sctp_chunk *chunk = _sctp_make_chunk(asoc, type, flags, paylen);
1423
1424 if (chunk)
1425 sctp_control_set_owner_w(chunk);
1426
1427 return chunk;
1428}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430/* Release the memory occupied by a chunk. */
1431static void sctp_chunk_destroy(struct sctp_chunk *chunk)
1432{
Vlad Yasevicha08de642007-12-20 14:11:47 -08001433 BUG_ON(!list_empty(&chunk->list));
1434 list_del_init(&chunk->transmitted_list);
1435
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 /* Free the chunk skb data and the SCTP_chunk stub itself. */
1437 dev_kfree_skb(chunk->skb);
1438
1439 SCTP_DBG_OBJCNT_DEC(chunk);
1440 kmem_cache_free(sctp_chunk_cachep, chunk);
1441}
1442
1443/* Possibly, free the chunk. */
1444void sctp_chunk_free(struct sctp_chunk *chunk)
1445{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 /* Release our reference on the message tracker. */
1447 if (chunk->msg)
1448 sctp_datamsg_put(chunk->msg);
1449
1450 sctp_chunk_put(chunk);
1451}
1452
1453/* Grab a reference to the chunk. */
1454void sctp_chunk_hold(struct sctp_chunk *ch)
1455{
1456 atomic_inc(&ch->refcnt);
1457}
1458
1459/* Release a reference to the chunk. */
1460void sctp_chunk_put(struct sctp_chunk *ch)
1461{
1462 if (atomic_dec_and_test(&ch->refcnt))
1463 sctp_chunk_destroy(ch);
1464}
1465
1466/* Append bytes to the end of a chunk. Will panic if chunk is not big
1467 * enough.
1468 */
1469void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)
1470{
1471 void *target;
1472 void *padding;
1473 int chunklen = ntohs(chunk->chunk_hdr->length);
Wei Yongjun8d614ad2007-08-06 13:55:47 +08001474 int padlen = WORD_ROUND(chunklen) - chunklen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
1476 padding = skb_put(chunk->skb, padlen);
1477 target = skb_put(chunk->skb, len);
1478
1479 memset(padding, 0, padlen);
1480 memcpy(target, data, len);
1481
1482 /* Adjust the chunk length field. */
1483 chunk->chunk_hdr->length = htons(chunklen + padlen + len);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001484 chunk->chunk_end = skb_tail_pointer(chunk->skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
1486 return target;
1487}
1488
Neil Horman5fa782c2010-04-28 10:30:59 +00001489/* Append bytes to the end of a chunk. Returns NULL if there isn't sufficient
1490 * space in the chunk
1491 */
1492void *sctp_addto_chunk_fixed(struct sctp_chunk *chunk,
1493 int len, const void *data)
1494{
Wei Yongjun2e3219b2010-05-17 22:51:58 -07001495 if (skb_tailroom(chunk->skb) >= len)
Neil Horman5fa782c2010-04-28 10:30:59 +00001496 return sctp_addto_chunk(chunk, len, data);
1497 else
1498 return NULL;
1499}
1500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501/* Append bytes from user space to the end of a chunk. Will panic if
1502 * chunk is not big enough.
1503 * Returns a kernel err value.
1504 */
1505int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len,
1506 struct iovec *data)
1507{
1508 __u8 *target;
1509 int err = 0;
1510
1511 /* Make room in chunk for data. */
1512 target = skb_put(chunk->skb, len);
1513
1514 /* Copy data (whole iovec) into chunk */
1515 if ((err = memcpy_fromiovecend(target, data, off, len)))
1516 goto out;
1517
1518 /* Adjust the chunk length field. */
1519 chunk->chunk_hdr->length =
1520 htons(ntohs(chunk->chunk_hdr->length) + len);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001521 chunk->chunk_end = skb_tail_pointer(chunk->skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
1523out:
1524 return err;
1525}
1526
1527/* Helper function to assign a TSN if needed. This assumes that both
1528 * the data_hdr and association have already been assigned.
1529 */
1530void sctp_chunk_assign_ssn(struct sctp_chunk *chunk)
1531{
Vlad Yasevichab3e5e72007-08-02 16:51:42 -04001532 struct sctp_datamsg *msg;
1533 struct sctp_chunk *lchunk;
1534 struct sctp_stream *stream;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 __u16 ssn;
1536 __u16 sid;
1537
1538 if (chunk->has_ssn)
1539 return;
1540
Vlad Yasevichab3e5e72007-08-02 16:51:42 -04001541 /* All fragments will be on the same stream */
1542 sid = ntohs(chunk->subh.data_hdr->stream);
1543 stream = &chunk->asoc->ssnmap->out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544
Vlad Yasevichab3e5e72007-08-02 16:51:42 -04001545 /* Now assign the sequence number to the entire message.
1546 * All fragments must have the same stream sequence number.
1547 */
1548 msg = chunk->msg;
1549 list_for_each_entry(lchunk, &msg->chunks, frag_list) {
1550 if (lchunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
1551 ssn = 0;
1552 } else {
1553 if (lchunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG)
1554 ssn = sctp_ssn_next(stream, sid);
1555 else
1556 ssn = sctp_ssn_peek(stream, sid);
1557 }
1558
1559 lchunk->subh.data_hdr->ssn = htons(ssn);
1560 lchunk->has_ssn = 1;
1561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562}
1563
1564/* Helper function to assign a TSN if needed. This assumes that both
1565 * the data_hdr and association have already been assigned.
1566 */
1567void sctp_chunk_assign_tsn(struct sctp_chunk *chunk)
1568{
1569 if (!chunk->has_tsn) {
1570 /* This is the last possible instant to
1571 * assign a TSN.
1572 */
1573 chunk->subh.data_hdr->tsn =
1574 htonl(sctp_association_get_next_tsn(chunk->asoc));
1575 chunk->has_tsn = 1;
1576 }
1577}
1578
1579/* Create a CLOSED association to use with an incoming packet. */
1580struct sctp_association *sctp_make_temp_asoc(const struct sctp_endpoint *ep,
Alexey Dobriyan3182cd82005-07-11 20:57:47 -07001581 struct sctp_chunk *chunk,
Al Virodd0fc662005-10-07 07:46:04 +01001582 gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583{
1584 struct sctp_association *asoc;
1585 struct sk_buff *skb;
1586 sctp_scope_t scope;
1587 struct sctp_af *af;
1588
1589 /* Create the bare association. */
1590 scope = sctp_scope(sctp_source(chunk));
1591 asoc = sctp_association_new(ep, ep->base.sk, scope, gfp);
1592 if (!asoc)
1593 goto nodata;
1594 asoc->temp = 1;
1595 skb = chunk->skb;
1596 /* Create an entry for the source address of the packet. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001597 af = sctp_get_af_specific(ipver2af(ip_hdr(skb)->version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 if (unlikely(!af))
1599 goto fail;
Al Virod55c41b2006-11-20 17:09:40 -08001600 af->from_skb(&asoc->c.peer_addr, skb, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601nodata:
1602 return asoc;
1603
1604fail:
1605 sctp_association_free(asoc);
1606 return NULL;
1607}
1608
1609/* Build a cookie representing asoc.
1610 * This INCLUDES the param header needed to put the cookie in the INIT ACK.
1611 */
1612static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
1613 const struct sctp_association *asoc,
1614 const struct sctp_chunk *init_chunk,
1615 int *cookie_len,
1616 const __u8 *raw_addrs, int addrs_len)
1617{
1618 sctp_cookie_param_t *retval;
1619 struct sctp_signed_cookie *cookie;
1620 struct scatterlist sg;
1621 int headersize, bodysize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
Vlad Yasevich9834a2b2006-01-17 11:52:12 -08001623 /* Header size is static data prior to the actual cookie, including
1624 * any padding.
1625 */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001626 headersize = sizeof(sctp_paramhdr_t) +
1627 (sizeof(struct sctp_signed_cookie) -
Vlad Yasevich9834a2b2006-01-17 11:52:12 -08001628 sizeof(struct sctp_cookie));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 bodysize = sizeof(struct sctp_cookie)
1630 + ntohs(init_chunk->chunk_hdr->length) + addrs_len;
1631
1632 /* Pad out the cookie to a multiple to make the signature
1633 * functions simpler to write.
1634 */
1635 if (bodysize % SCTP_COOKIE_MULTIPLE)
1636 bodysize += SCTP_COOKIE_MULTIPLE
1637 - (bodysize % SCTP_COOKIE_MULTIPLE);
1638 *cookie_len = headersize + bodysize;
1639
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 /* Clear this memory since we are sending this data structure
1641 * out on the network.
1642 */
Arnaldo Carvalho de Meloaf997d82006-11-21 01:20:33 -02001643 retval = kzalloc(*cookie_len, GFP_ATOMIC);
1644 if (!retval)
1645 goto nodata;
1646
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 cookie = (struct sctp_signed_cookie *) retval->body;
1648
1649 /* Set up the parameter header. */
1650 retval->p.type = SCTP_PARAM_STATE_COOKIE;
1651 retval->p.length = htons(*cookie_len);
1652
1653 /* Copy the cookie part of the association itself. */
1654 cookie->c = asoc->c;
1655 /* Save the raw address list length in the cookie. */
1656 cookie->c.raw_addr_list_len = addrs_len;
1657
1658 /* Remember PR-SCTP capability. */
1659 cookie->c.prsctp_capable = asoc->peer.prsctp_capable;
1660
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08001661 /* Save adaptation indication in the cookie. */
1662 cookie->c.adaptation_ind = asoc->peer.adaptation_ind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 /* Set an expiration time for the cookie. */
Daniel Borkmann52db8822013-06-25 18:17:27 +02001665 cookie->c.expiration = ktime_add(asoc->cookie_life,
1666 ktime_get());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668 /* Copy the peer's init packet. */
1669 memcpy(&cookie->c.peer_init[0], init_chunk->chunk_hdr,
1670 ntohs(init_chunk->chunk_hdr->length));
1671
1672 /* Copy the raw local address list of the association. */
1673 memcpy((__u8 *)&cookie->c.peer_init[0] +
1674 ntohs(init_chunk->chunk_hdr->length), raw_addrs, addrs_len);
1675
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001676 if (sctp_sk(ep->base.sk)->hmac) {
Herbert Xu1b489e12006-08-20 15:07:14 +10001677 struct hash_desc desc;
1678
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 /* Sign the message. */
Herbert Xu68e3f5d2007-10-27 00:52:07 -07001680 sg_init_one(&sg, &cookie->c, bodysize);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001681 desc.tfm = sctp_sk(ep->base.sk)->hmac;
1682 desc.flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683
Daniel Borkmann570617e2013-02-12 05:15:33 +00001684 if (crypto_hash_setkey(desc.tfm, ep->secret_key,
1685 sizeof(ep->secret_key)) ||
Herbert Xu1b489e12006-08-20 15:07:14 +10001686 crypto_hash_digest(&desc, &sg, bodysize, cookie->signature))
1687 goto free_cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 }
1689
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 return retval;
Herbert Xu1b489e12006-08-20 15:07:14 +10001691
1692free_cookie:
1693 kfree(retval);
1694nodata:
1695 *cookie_len = 0;
1696 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697}
1698
1699/* Unpack the cookie from COOKIE ECHO chunk, recreating the association. */
1700struct sctp_association *sctp_unpack_cookie(
1701 const struct sctp_endpoint *ep,
1702 const struct sctp_association *asoc,
Al Virodd0fc662005-10-07 07:46:04 +01001703 struct sctp_chunk *chunk, gfp_t gfp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 int *error, struct sctp_chunk **errp)
1705{
1706 struct sctp_association *retval = NULL;
1707 struct sctp_signed_cookie *cookie;
1708 struct sctp_cookie *bear_cookie;
1709 int headersize, bodysize, fixed_size;
Vlad Yasevich313e7b42006-01-17 11:55:57 -08001710 __u8 *digest = ep->digest;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 struct scatterlist sg;
Daniel Borkmann570617e2013-02-12 05:15:33 +00001712 unsigned int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 sctp_scope_t scope;
1714 struct sk_buff *skb = chunk->skb;
Daniel Borkmann52db8822013-06-25 18:17:27 +02001715 ktime_t kt;
Herbert Xu1b489e12006-08-20 15:07:14 +10001716 struct hash_desc desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
Vlad Yasevich9834a2b2006-01-17 11:52:12 -08001718 /* Header size is static data prior to the actual cookie, including
1719 * any padding.
1720 */
1721 headersize = sizeof(sctp_chunkhdr_t) +
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001722 (sizeof(struct sctp_signed_cookie) -
Vlad Yasevich9834a2b2006-01-17 11:52:12 -08001723 sizeof(struct sctp_cookie));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 bodysize = ntohs(chunk->chunk_hdr->length) - headersize;
1725 fixed_size = headersize + sizeof(struct sctp_cookie);
1726
1727 /* Verify that the chunk looks like it even has a cookie.
1728 * There must be enough room for our cookie and our peer's
1729 * INIT chunk.
1730 */
1731 len = ntohs(chunk->chunk_hdr->length);
1732 if (len < fixed_size + sizeof(struct sctp_chunkhdr))
1733 goto malformed;
1734
1735 /* Verify that the cookie has been padded out. */
1736 if (bodysize % SCTP_COOKIE_MULTIPLE)
1737 goto malformed;
1738
1739 /* Process the cookie. */
1740 cookie = chunk->subh.cookie_hdr;
1741 bear_cookie = &cookie->c;
1742
1743 if (!sctp_sk(ep->base.sk)->hmac)
1744 goto no_hmac;
1745
1746 /* Check the signature. */
Herbert Xu68e3f5d2007-10-27 00:52:07 -07001747 sg_init_one(&sg, bear_cookie, bodysize);
Herbert Xu1b489e12006-08-20 15:07:14 +10001748 desc.tfm = sctp_sk(ep->base.sk)->hmac;
1749 desc.flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
Al Viro8ca84482006-06-20 03:26:14 -07001751 memset(digest, 0x00, SCTP_SIGNATURE_SIZE);
Daniel Borkmann570617e2013-02-12 05:15:33 +00001752 if (crypto_hash_setkey(desc.tfm, ep->secret_key,
1753 sizeof(ep->secret_key)) ||
Herbert Xu1b489e12006-08-20 15:07:14 +10001754 crypto_hash_digest(&desc, &sg, bodysize, digest)) {
1755 *error = -SCTP_IERROR_NOMEM;
1756 goto fail;
1757 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758
1759 if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
Daniel Borkmann570617e2013-02-12 05:15:33 +00001760 *error = -SCTP_IERROR_BAD_SIG;
1761 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
1763
1764no_hmac:
1765 /* IG Section 2.35.2:
1766 * 3) Compare the port numbers and the verification tag contained
1767 * within the COOKIE ECHO chunk to the actual port numbers and the
1768 * verification tag within the SCTP common header of the received
1769 * packet. If these values do not match the packet MUST be silently
1770 * discarded,
1771 */
1772 if (ntohl(chunk->sctp_hdr->vtag) != bear_cookie->my_vtag) {
1773 *error = -SCTP_IERROR_BAD_TAG;
1774 goto fail;
1775 }
1776
Al Viro9b1dfad2006-11-20 17:09:17 -08001777 if (chunk->sctp_hdr->source != bear_cookie->peer_addr.v4.sin_port ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 ntohs(chunk->sctp_hdr->dest) != bear_cookie->my_port) {
1779 *error = -SCTP_IERROR_BAD_PORTS;
1780 goto fail;
1781 }
1782
1783 /* Check to see if the cookie is stale. If there is already
1784 * an association, there is no need to check cookie's expiration
1785 * for init collision case of lost COOKIE ACK.
Vlad Yasevichf236218b2006-09-29 17:10:03 -07001786 * If skb has been timestamped, then use the stamp, otherwise
1787 * use current time. This introduces a small possibility that
1788 * that a cookie may be considered expired, but his would only slow
1789 * down the new association establishment instead of every packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 */
Vlad Yasevichf236218b2006-09-29 17:10:03 -07001791 if (sock_flag(ep->base.sk, SOCK_TIMESTAMP))
Daniel Borkmann52db8822013-06-25 18:17:27 +02001792 kt = skb_get_ktime(skb);
Vlad Yasevichf236218b2006-09-29 17:10:03 -07001793 else
Daniel Borkmann52db8822013-06-25 18:17:27 +02001794 kt = ktime_get();
Vlad Yasevichf236218b2006-09-29 17:10:03 -07001795
Daniel Borkmann52db8822013-06-25 18:17:27 +02001796 if (!asoc && ktime_compare(bear_cookie->expiration, kt) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 /*
1798 * Section 3.3.10.3 Stale Cookie Error (3)
1799 *
1800 * Cause of error
1801 * ---------------
1802 * Stale Cookie Error: Indicates the receipt of a valid State
1803 * Cookie that has expired.
1804 */
1805 len = ntohs(chunk->chunk_hdr->length);
1806 *errp = sctp_make_op_error_space(asoc, chunk, len);
1807 if (*errp) {
Daniel Borkmann52db8822013-06-25 18:17:27 +02001808 suseconds_t usecs = ktime_to_us(ktime_sub(kt, bear_cookie->expiration));
Al Viro34bcca22006-11-20 17:27:15 -08001809 __be32 n = htonl(usecs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 sctp_init_cause(*errp, SCTP_ERROR_STALE_COOKIE,
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001812 sizeof(n));
1813 sctp_addto_chunk(*errp, sizeof(n), &n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 *error = -SCTP_IERROR_STALE_COOKIE;
1815 } else
1816 *error = -SCTP_IERROR_NOMEM;
1817
1818 goto fail;
1819 }
1820
1821 /* Make a new base association. */
1822 scope = sctp_scope(sctp_source(chunk));
1823 retval = sctp_association_new(ep, ep->base.sk, scope, gfp);
1824 if (!retval) {
1825 *error = -SCTP_IERROR_NOMEM;
1826 goto fail;
1827 }
1828
1829 /* Set up our peer's port number. */
1830 retval->peer.port = ntohs(chunk->sctp_hdr->source);
1831
1832 /* Populate the association from the cookie. */
1833 memcpy(&retval->c, bear_cookie, sizeof(*bear_cookie));
1834
1835 if (sctp_assoc_set_bind_addr_from_cookie(retval, bear_cookie,
1836 GFP_ATOMIC) < 0) {
1837 *error = -SCTP_IERROR_NOMEM;
1838 goto fail;
1839 }
1840
1841 /* Also, add the destination address. */
1842 if (list_empty(&retval->base.bind_addr.address_list)) {
Vlad Yasevichf57d96b2007-12-20 14:12:24 -08001843 sctp_add_bind_addr(&retval->base.bind_addr, &chunk->dest,
1844 SCTP_ADDR_SRC, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 }
1846
1847 retval->next_tsn = retval->c.initial_tsn;
1848 retval->ctsn_ack_point = retval->next_tsn - 1;
1849 retval->addip_serial = retval->c.initial_tsn;
1850 retval->adv_peer_ack_point = retval->ctsn_ack_point;
1851 retval->peer.prsctp_capable = retval->c.prsctp_capable;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08001852 retval->peer.adaptation_ind = retval->c.adaptation_ind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853
1854 /* The INIT stuff will be done by the side effects. */
1855 return retval;
1856
1857fail:
1858 if (retval)
1859 sctp_association_free(retval);
1860
1861 return NULL;
1862
1863malformed:
1864 /* Yikes! The packet is either corrupt or deliberately
1865 * malformed.
1866 */
1867 *error = -SCTP_IERROR_MALFORMED;
1868 goto fail;
1869}
1870
1871/********************************************************************
1872 * 3rd Level Abstractions
1873 ********************************************************************/
1874
1875struct __sctp_missing {
Al Viro9f81bcd2006-11-20 17:26:34 -08001876 __be32 num_missing;
1877 __be16 type;
Eric Dumazetbc105022010-06-03 03:21:52 -07001878} __packed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879
1880/*
1881 * Report a missing mandatory parameter.
1882 */
1883static int sctp_process_missing_param(const struct sctp_association *asoc,
1884 sctp_param_t paramtype,
1885 struct sctp_chunk *chunk,
1886 struct sctp_chunk **errp)
1887{
1888 struct __sctp_missing report;
1889 __u16 len;
1890
1891 len = WORD_ROUND(sizeof(report));
1892
1893 /* Make an ERROR chunk, preparing enough room for
1894 * returning multiple unknown parameters.
1895 */
1896 if (!*errp)
1897 *errp = sctp_make_op_error_space(asoc, chunk, len);
1898
1899 if (*errp) {
1900 report.num_missing = htonl(1);
1901 report.type = paramtype;
Vlad Yasevichebdfcad2007-01-15 19:12:31 -08001902 sctp_init_cause(*errp, SCTP_ERROR_MISS_PARAM,
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001903 sizeof(report));
1904 sctp_addto_chunk(*errp, sizeof(report), &report);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 }
1906
1907 /* Stop processing this chunk. */
1908 return 0;
1909}
1910
1911/* Report an Invalid Mandatory Parameter. */
1912static int sctp_process_inv_mandatory(const struct sctp_association *asoc,
1913 struct sctp_chunk *chunk,
1914 struct sctp_chunk **errp)
1915{
1916 /* Invalid Mandatory Parameter Error has no payload. */
1917
1918 if (!*errp)
1919 *errp = sctp_make_op_error_space(asoc, chunk, 0);
1920
1921 if (*errp)
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001922 sctp_init_cause(*errp, SCTP_ERROR_INV_PARAM, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
1924 /* Stop processing this chunk. */
1925 return 0;
1926}
1927
1928static int sctp_process_inv_paramlength(const struct sctp_association *asoc,
1929 struct sctp_paramhdr *param,
1930 const struct sctp_chunk *chunk,
1931 struct sctp_chunk **errp)
1932{
Vlad Yasevich7ab90802007-11-09 11:43:41 -05001933 /* This is a fatal error. Any accumulated non-fatal errors are
1934 * not reported.
1935 */
1936 if (*errp)
1937 sctp_chunk_free(*errp);
1938
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 /* Create an error chunk and fill it in with our payload. */
Wei Yongjunba016672008-09-30 05:32:24 -07001940 *errp = sctp_make_violation_paramlen(asoc, chunk, param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
1942 return 0;
1943}
1944
1945
1946/* Do not attempt to handle the HOST_NAME parm. However, do
1947 * send back an indicator to the peer.
1948 */
1949static int sctp_process_hn_param(const struct sctp_association *asoc,
1950 union sctp_params param,
1951 struct sctp_chunk *chunk,
1952 struct sctp_chunk **errp)
1953{
1954 __u16 len = ntohs(param.p->length);
1955
Vlad Yasevich7ab90802007-11-09 11:43:41 -05001956 /* Processing of the HOST_NAME parameter will generate an
1957 * ABORT. If we've accumulated any non-fatal errors, they
1958 * would be unrecognized parameters and we should not include
1959 * them in the ABORT.
1960 */
1961 if (*errp)
1962 sctp_chunk_free(*errp);
1963
1964 *errp = sctp_make_op_error_space(asoc, chunk, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
Wei Yongjun00f1c2d2007-08-21 15:50:01 +08001966 if (*errp) {
1967 sctp_init_cause(*errp, SCTP_ERROR_DNS_FAILED, len);
1968 sctp_addto_chunk(*errp, len, param.v);
1969 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970
1971 /* Stop processing this chunk. */
1972 return 0;
1973}
1974
Eric W. Biedermanf53b5b02012-08-07 07:29:08 +00001975static int sctp_verify_ext_param(struct net *net, union sctp_params param)
Vlad Yasevichd6701192007-12-20 14:13:31 -08001976{
1977 __u16 num_ext = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
1978 int have_auth = 0;
1979 int have_asconf = 0;
1980 int i;
1981
1982 for (i = 0; i < num_ext; i++) {
1983 switch (param.ext->chunks[i]) {
1984 case SCTP_CID_AUTH:
1985 have_auth = 1;
1986 break;
1987 case SCTP_CID_ASCONF:
1988 case SCTP_CID_ASCONF_ACK:
1989 have_asconf = 1;
1990 break;
1991 }
1992 }
1993
1994 /* ADD-IP Security: The draft requires us to ABORT or ignore the
1995 * INIT/INIT-ACK if ADD-IP is listed, but AUTH is not. Do this
1996 * only if ADD-IP is turned on and we are not backward-compatible
1997 * mode.
1998 */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00001999 if (net->sctp.addip_noauth)
Vlad Yasevichd6701192007-12-20 14:13:31 -08002000 return 1;
2001
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002002 if (net->sctp.addip_enable && !have_auth && have_asconf)
Vlad Yasevichd6701192007-12-20 14:13:31 -08002003 return 0;
2004
2005 return 1;
2006}
2007
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002008static void sctp_process_ext_param(struct sctp_association *asoc,
2009 union sctp_params param)
2010{
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002011 struct net *net = sock_net(asoc->base.sk);
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002012 __u16 num_ext = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
2013 int i;
2014
2015 for (i = 0; i < num_ext; i++) {
2016 switch (param.ext->chunks[i]) {
2017 case SCTP_CID_FWD_TSN:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002018 if (net->sctp.prsctp_enable &&
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002019 !asoc->peer.prsctp_capable)
2020 asoc->peer.prsctp_capable = 1;
2021 break;
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002022 case SCTP_CID_AUTH:
2023 /* if the peer reports AUTH, assume that he
2024 * supports AUTH.
2025 */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002026 if (net->sctp.auth_enable)
Vlad Yasevich0ef46e22008-09-18 16:27:38 -07002027 asoc->peer.auth_capable = 1;
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002028 break;
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002029 case SCTP_CID_ASCONF:
2030 case SCTP_CID_ASCONF_ACK:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002031 if (net->sctp.addip_enable)
Vlad Yasevich0ef46e22008-09-18 16:27:38 -07002032 asoc->peer.asconf_capable = 1;
Vlad Yasevich6b2f9cb2007-09-16 19:35:39 -07002033 break;
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002034 default:
2035 break;
2036 }
2037 }
2038}
2039
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040/* RFC 3.2.1 & the Implementers Guide 2.2.
2041 *
2042 * The Parameter Types are encoded such that the
2043 * highest-order two bits specify the action that must be
2044 * taken if the processing endpoint does not recognize the
2045 * Parameter Type.
2046 *
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002047 * 00 - Stop processing this parameter; do not process any further
2048 * parameters within this chunk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 *
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002050 * 01 - Stop processing this parameter, do not process any further
2051 * parameters within this chunk, and report the unrecognized
2052 * parameter in an 'Unrecognized Parameter' ERROR chunk.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 *
2054 * 10 - Skip this parameter and continue processing.
2055 *
2056 * 11 - Skip this parameter and continue processing but
2057 * report the unrecognized parameter in an
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002058 * 'Unrecognized Parameter' ERROR chunk.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 *
2060 * Return value:
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002061 * SCTP_IERROR_NO_ERROR - continue with the chunk
2062 * SCTP_IERROR_ERROR - stop and report an error.
2063 * SCTP_IERROR_NOMEME - out of memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002065static sctp_ierror_t sctp_process_unk_param(const struct sctp_association *asoc,
2066 union sctp_params param,
2067 struct sctp_chunk *chunk,
2068 struct sctp_chunk **errp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069{
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002070 int retval = SCTP_IERROR_NO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071
2072 switch (param.p->type & SCTP_PARAM_ACTION_MASK) {
2073 case SCTP_PARAM_ACTION_DISCARD:
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002074 retval = SCTP_IERROR_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 break;
2076 case SCTP_PARAM_ACTION_SKIP:
2077 break;
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002078 case SCTP_PARAM_ACTION_DISCARD_ERR:
2079 retval = SCTP_IERROR_ERROR;
2080 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 case SCTP_PARAM_ACTION_SKIP_ERR:
2082 /* Make an ERROR chunk, preparing enough room for
2083 * returning multiple unknown parameters.
2084 */
2085 if (NULL == *errp)
Neil Horman5fa782c2010-04-28 10:30:59 +00002086 *errp = sctp_make_op_error_fixed(asoc, chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087
2088 if (*errp) {
Jiri Bohac2205a6e2011-02-17 13:12:08 +00002089 if (!sctp_init_cause_fixed(*errp, SCTP_ERROR_UNKNOWN_PARAM,
2090 WORD_ROUND(ntohs(param.p->length))))
2091 sctp_addto_chunk_fixed(*errp,
2092 WORD_ROUND(ntohs(param.p->length)),
2093 param.v);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 } else {
2095 /* If there is no memory for generating the ERROR
2096 * report as specified, an ABORT will be triggered
2097 * to the peer and the association won't be
2098 * established.
2099 */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002100 retval = SCTP_IERROR_NOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 break;
2103 default:
2104 break;
2105 }
2106
2107 return retval;
2108}
2109
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002110/* Verify variable length parameters
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 * Return values:
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002112 * SCTP_IERROR_ABORT - trigger an ABORT
2113 * SCTP_IERROR_NOMEM - out of memory (abort)
2114 * SCTP_IERROR_ERROR - stop processing, trigger an ERROR
2115 * SCTP_IERROR_NO_ERROR - continue with the chunk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 */
Eric W. Biedermanf53b5b02012-08-07 07:29:08 +00002117static sctp_ierror_t sctp_verify_param(struct net *net,
2118 const struct sctp_association *asoc,
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002119 union sctp_params param,
2120 sctp_cid_t cid,
2121 struct sctp_chunk *chunk,
2122 struct sctp_chunk **err_chunk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123{
Wei Yongjun72da7b32008-04-12 18:39:19 -07002124 struct sctp_hmac_algo_param *hmacs;
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002125 int retval = SCTP_IERROR_NO_ERROR;
Wei Yongjun72da7b32008-04-12 18:39:19 -07002126 __u16 n_elt, id = 0;
2127 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
2129 /* FIXME - This routine is not looking at each parameter per the
2130 * chunk type, i.e., unrecognized parameters should be further
2131 * identified based on the chunk id.
2132 */
2133
2134 switch (param.p->type) {
2135 case SCTP_PARAM_IPV4_ADDRESS:
2136 case SCTP_PARAM_IPV6_ADDRESS:
2137 case SCTP_PARAM_COOKIE_PRESERVATIVE:
2138 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
2139 case SCTP_PARAM_STATE_COOKIE:
2140 case SCTP_PARAM_HEARTBEAT_INFO:
2141 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
2142 case SCTP_PARAM_ECN_CAPABLE:
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002143 case SCTP_PARAM_ADAPTATION_LAYER_IND:
Vlad Yasevichd6701192007-12-20 14:13:31 -08002144 break;
2145
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002146 case SCTP_PARAM_SUPPORTED_EXT:
Eric W. Biedermanf53b5b02012-08-07 07:29:08 +00002147 if (!sctp_verify_ext_param(net, param))
Vlad Yasevichd6701192007-12-20 14:13:31 -08002148 return SCTP_IERROR_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 break;
2150
Vlad Yasevichd6de3092007-12-20 14:10:00 -08002151 case SCTP_PARAM_SET_PRIMARY:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002152 if (net->sctp.addip_enable)
Vlad Yasevichd6de3092007-12-20 14:10:00 -08002153 break;
2154 goto fallthrough;
2155
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 case SCTP_PARAM_HOST_NAME_ADDRESS:
2157 /* Tell the peer, we won't support this param. */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002158 sctp_process_hn_param(asoc, param, chunk, err_chunk);
2159 retval = SCTP_IERROR_ABORT;
2160 break;
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 case SCTP_PARAM_FWD_TSN_SUPPORT:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002163 if (net->sctp.prsctp_enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 break;
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002165 goto fallthrough;
2166
2167 case SCTP_PARAM_RANDOM:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002168 if (!net->sctp.auth_enable)
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002169 goto fallthrough;
2170
2171 /* SCTP-AUTH: Secion 6.1
2172 * If the random number is not 32 byte long the association
2173 * MUST be aborted. The ABORT chunk SHOULD contain the error
2174 * cause 'Protocol Violation'.
2175 */
2176 if (SCTP_AUTH_RANDOM_LENGTH !=
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002177 ntohs(param.p->length) - sizeof(sctp_paramhdr_t)) {
2178 sctp_process_inv_paramlength(asoc, param.p,
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002179 chunk, err_chunk);
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002180 retval = SCTP_IERROR_ABORT;
2181 }
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002182 break;
2183
2184 case SCTP_PARAM_CHUNKS:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002185 if (!net->sctp.auth_enable)
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002186 goto fallthrough;
2187
2188 /* SCTP-AUTH: Section 3.2
2189 * The CHUNKS parameter MUST be included once in the INIT or
2190 * INIT-ACK chunk if the sender wants to receive authenticated
2191 * chunks. Its maximum length is 260 bytes.
2192 */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002193 if (260 < ntohs(param.p->length)) {
2194 sctp_process_inv_paramlength(asoc, param.p,
2195 chunk, err_chunk);
2196 retval = SCTP_IERROR_ABORT;
2197 }
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002198 break;
2199
2200 case SCTP_PARAM_HMAC_ALGO:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002201 if (!net->sctp.auth_enable)
Wei Yongjun72da7b32008-04-12 18:39:19 -07002202 goto fallthrough;
2203
2204 hmacs = (struct sctp_hmac_algo_param *)param.p;
2205 n_elt = (ntohs(param.p->length) - sizeof(sctp_paramhdr_t)) >> 1;
2206
2207 /* SCTP-AUTH: Section 6.1
2208 * The HMAC algorithm based on SHA-1 MUST be supported and
2209 * included in the HMAC-ALGO parameter.
2210 */
2211 for (i = 0; i < n_elt; i++) {
2212 id = ntohs(hmacs->hmac_ids[i]);
2213
2214 if (id == SCTP_AUTH_HMAC_ID_SHA1)
2215 break;
2216 }
2217
2218 if (id != SCTP_AUTH_HMAC_ID_SHA1) {
2219 sctp_process_inv_paramlength(asoc, param.p, chunk,
2220 err_chunk);
2221 retval = SCTP_IERROR_ABORT;
2222 }
2223 break;
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002224fallthrough:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 default:
Daniel Borkmannbb333812013-06-28 19:49:40 +02002226 pr_debug("%s: unrecognized param:%d for chunk:%d\n",
2227 __func__, ntohs(param.p->type), cid);
2228
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002229 retval = sctp_process_unk_param(asoc, param, chunk, err_chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 break;
2231 }
2232 return retval;
2233}
2234
2235/* Verify the INIT packet before we process it. */
Eric W. Biedermanf53b5b02012-08-07 07:29:08 +00002236int sctp_verify_init(struct net *net, const struct sctp_association *asoc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 sctp_cid_t cid,
2238 sctp_init_chunk_t *peer_init,
2239 struct sctp_chunk *chunk,
2240 struct sctp_chunk **errp)
2241{
2242 union sctp_params param;
Daniel Borkmann7613f5f2013-08-27 16:53:52 +02002243 bool has_cookie = false;
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002244 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245
Daniel Borkmann7613f5f2013-08-27 16:53:52 +02002246 /* Check for missing mandatory parameters. Note: Initial TSN is
2247 * also mandatory, but is not checked here since the valid range
2248 * is 0..2**32-1. RFC4960, section 3.3.3.
2249 */
2250 if (peer_init->init_hdr.num_outbound_streams == 0 ||
2251 peer_init->init_hdr.num_inbound_streams == 0 ||
2252 peer_init->init_hdr.init_tag == 0 ||
2253 ntohl(peer_init->init_hdr.a_rwnd) < SCTP_DEFAULT_MINWINDOW)
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002254 return sctp_process_inv_mandatory(asoc, chunk, errp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 sctp_walk_params(param, peer_init, init_hdr.params) {
Daniel Borkmann7613f5f2013-08-27 16:53:52 +02002257 if (param.p->type == SCTP_PARAM_STATE_COOKIE)
2258 has_cookie = true;
2259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260
2261 /* There is a possibility that a parameter length was bad and
2262 * in that case we would have stoped walking the parameters.
2263 * The current param.p would point at the bad one.
2264 * Current consensus on the mailing list is to generate a PROTOCOL
2265 * VIOLATION error. We build the ERROR chunk here and let the normal
2266 * error handling code build and send the packet.
2267 */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002268 if (param.v != (void*)chunk->chunk_end)
2269 return sctp_process_inv_paramlength(asoc, param.p, chunk, errp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270
2271 /* The only missing mandatory param possible today is
2272 * the state cookie for an INIT-ACK chunk.
2273 */
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002274 if ((SCTP_CID_INIT_ACK == cid) && !has_cookie)
2275 return sctp_process_missing_param(asoc, SCTP_PARAM_STATE_COOKIE,
2276 chunk, errp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002278 /* Verify all the variable length parameters */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 sctp_walk_params(param, peer_init, init_hdr.params) {
2280
Eric W. Biedermanf53b5b02012-08-07 07:29:08 +00002281 result = sctp_verify_param(net, asoc, param, cid, chunk, errp);
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002282 switch (result) {
2283 case SCTP_IERROR_ABORT:
2284 case SCTP_IERROR_NOMEM:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 return 0;
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002286 case SCTP_IERROR_ERROR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 return 1;
Vlad Yasevich7ab90802007-11-09 11:43:41 -05002288 case SCTP_IERROR_NO_ERROR:
2289 default:
2290 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 }
2292
2293 } /* for (loop through all parameters) */
2294
2295 return 1;
2296}
2297
2298/* Unpack the parameters in an INIT packet into an association.
2299 * Returns 0 on failure, else success.
2300 * FIXME: This is an association method.
2301 */
Wei Yongjunde6becd2011-04-19 21:30:51 +00002302int sctp_process_init(struct sctp_association *asoc, struct sctp_chunk *chunk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 const union sctp_addr *peer_addr,
Al Virodd0fc662005-10-07 07:46:04 +01002304 sctp_init_chunk_t *peer_init, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305{
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002306 struct net *net = sock_net(asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 union sctp_params param;
2308 struct sctp_transport *transport;
2309 struct list_head *pos, *temp;
Wei Yongjunde6becd2011-04-19 21:30:51 +00002310 struct sctp_af *af;
2311 union sctp_addr addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 char *cookie;
Wei Yongjunde6becd2011-04-19 21:30:51 +00002313 int src_match = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314
2315 /* We must include the address that the INIT packet came from.
2316 * This is the only address that matters for an INIT packet.
2317 * When processing a COOKIE ECHO, we retrieve the from address
2318 * of the INIT from the cookie.
2319 */
2320
2321 /* This implementation defaults to making the first transport
2322 * added as the primary transport. The source address seems to
2323 * be a a better choice than any of the embedded addresses.
2324 */
Wei Yongjunde6becd2011-04-19 21:30:51 +00002325 if(!sctp_assoc_add_peer(asoc, peer_addr, gfp, SCTP_ACTIVE))
2326 goto nomem;
2327
2328 if (sctp_cmp_addr_exact(sctp_source(chunk), peer_addr))
2329 src_match = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
2331 /* Process the initialization parameters. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 sctp_walk_params(param, peer_init, init_hdr.params) {
Wei Yongjunde6becd2011-04-19 21:30:51 +00002333 if (!src_match && (param.p->type == SCTP_PARAM_IPV4_ADDRESS ||
2334 param.p->type == SCTP_PARAM_IPV6_ADDRESS)) {
2335 af = sctp_get_af_specific(param_type2af(param.p->type));
2336 af->from_addr_param(&addr, param.addr,
2337 chunk->sctp_hdr->source, 0);
2338 if (sctp_cmp_addr_exact(sctp_source(chunk), &addr))
2339 src_match = 1;
2340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341
2342 if (!sctp_process_param(asoc, param, peer_addr, gfp))
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002343 goto clean_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 }
2345
Wei Yongjunde6becd2011-04-19 21:30:51 +00002346 /* source address of chunk may not match any valid address */
2347 if (!src_match)
2348 goto clean_up;
2349
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002350 /* AUTH: After processing the parameters, make sure that we
2351 * have all the required info to potentially do authentications.
2352 */
2353 if (asoc->peer.auth_capable && (!asoc->peer.peer_random ||
2354 !asoc->peer.peer_hmacs))
2355 asoc->peer.auth_capable = 0;
2356
Vlad Yasevichd6701192007-12-20 14:13:31 -08002357 /* In a non-backward compatible mode, if the peer claims
2358 * support for ADD-IP but not AUTH, the ADD-IP spec states
2359 * that we MUST ABORT the association. Section 6. The section
2360 * also give us an option to silently ignore the packet, which
2361 * is what we'll do here.
Vlad Yasevich6b2f9cb2007-09-16 19:35:39 -07002362 */
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002363 if (!net->sctp.addip_noauth &&
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -04002364 (asoc->peer.asconf_capable && !asoc->peer.auth_capable)) {
Vlad Yasevich6b2f9cb2007-09-16 19:35:39 -07002365 asoc->peer.addip_disabled_mask |= (SCTP_PARAM_ADD_IP |
2366 SCTP_PARAM_DEL_IP |
2367 SCTP_PARAM_SET_PRIMARY);
Vlad Yasevich88799fe2007-10-24 17:24:23 -04002368 asoc->peer.asconf_capable = 0;
Vlad Yasevichd6701192007-12-20 14:13:31 -08002369 goto clean_up;
Vlad Yasevich6b2f9cb2007-09-16 19:35:39 -07002370 }
2371
Frank Filz3f7a87d2005-06-20 13:14:57 -07002372 /* Walk list of transports, removing transports in the UNKNOWN state. */
2373 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
2374 transport = list_entry(pos, struct sctp_transport, transports);
2375 if (transport->state == SCTP_UNKNOWN) {
2376 sctp_assoc_rm_peer(asoc, transport);
2377 }
2378 }
2379
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 /* The fixed INIT headers are always in network byte
2381 * order.
2382 */
2383 asoc->peer.i.init_tag =
2384 ntohl(peer_init->init_hdr.init_tag);
2385 asoc->peer.i.a_rwnd =
2386 ntohl(peer_init->init_hdr.a_rwnd);
2387 asoc->peer.i.num_outbound_streams =
2388 ntohs(peer_init->init_hdr.num_outbound_streams);
2389 asoc->peer.i.num_inbound_streams =
2390 ntohs(peer_init->init_hdr.num_inbound_streams);
2391 asoc->peer.i.initial_tsn =
2392 ntohl(peer_init->init_hdr.initial_tsn);
2393
2394 /* Apply the upper bounds for output streams based on peer's
2395 * number of inbound streams.
2396 */
2397 if (asoc->c.sinit_num_ostreams >
2398 ntohs(peer_init->init_hdr.num_inbound_streams)) {
2399 asoc->c.sinit_num_ostreams =
2400 ntohs(peer_init->init_hdr.num_inbound_streams);
2401 }
2402
2403 if (asoc->c.sinit_max_instreams >
2404 ntohs(peer_init->init_hdr.num_outbound_streams)) {
2405 asoc->c.sinit_max_instreams =
2406 ntohs(peer_init->init_hdr.num_outbound_streams);
2407 }
2408
2409 /* Copy Initiation tag from INIT to VT_peer in cookie. */
2410 asoc->c.peer_vtag = asoc->peer.i.init_tag;
2411
2412 /* Peer Rwnd : Current calculated value of the peer's rwnd. */
2413 asoc->peer.rwnd = asoc->peer.i.a_rwnd;
2414
2415 /* Copy cookie in case we need to resend COOKIE-ECHO. */
2416 cookie = asoc->peer.cookie;
2417 if (cookie) {
Arnaldo Carvalho de Meloaf997d82006-11-21 01:20:33 -02002418 asoc->peer.cookie = kmemdup(cookie, asoc->peer.cookie_len, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419 if (!asoc->peer.cookie)
2420 goto clean_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 }
2422
2423 /* RFC 2960 7.2.1 The initial value of ssthresh MAY be arbitrarily
2424 * high (for example, implementations MAY use the size of the receiver
2425 * advertised window).
2426 */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07002427 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
2428 transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 transport->ssthresh = asoc->peer.i.a_rwnd;
2430 }
2431
2432 /* Set up the TSN tracking pieces. */
Vlad Yasevich8e1ee182008-10-08 14:18:39 -07002433 if (!sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
2434 asoc->peer.i.initial_tsn, gfp))
2435 goto clean_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
2437 /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
2438 *
2439 * The stream sequence number in all the streams shall start
2440 * from 0 when the association is established. Also, when the
2441 * stream sequence number reaches the value 65535 the next
2442 * stream sequence number shall be set to 0.
2443 */
2444
Frank Filz3f7a87d2005-06-20 13:14:57 -07002445 /* Allocate storage for the negotiated streams if it is not a temporary
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002446 * association.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 */
2448 if (!asoc->temp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 int error;
2450
2451 asoc->ssnmap = sctp_ssnmap_new(asoc->c.sinit_max_instreams,
2452 asoc->c.sinit_num_ostreams, gfp);
2453 if (!asoc->ssnmap)
2454 goto clean_up;
2455
Vlad Yasevich07d93962007-05-04 13:55:27 -07002456 error = sctp_assoc_set_id(asoc, gfp);
2457 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 goto clean_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 }
2460
2461 /* ADDIP Section 4.1 ASCONF Chunk Procedures
2462 *
2463 * When an endpoint has an ASCONF signaled change to be sent to the
2464 * remote endpoint it should do the following:
2465 * ...
2466 * A2) A serial number should be assigned to the Chunk. The serial
2467 * number should be a monotonically increasing number. All serial
2468 * numbers are defined to be initialized at the start of the
2469 * association to the same value as the Initial TSN.
2470 */
2471 asoc->peer.addip_serial = asoc->peer.i.initial_tsn - 1;
2472 return 1;
2473
2474clean_up:
2475 /* Release the transport structures. */
2476 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
2477 transport = list_entry(pos, struct sctp_transport, transports);
Vlad Yasevichadd52372008-09-18 16:28:27 -07002478 if (transport->state != SCTP_ACTIVE)
2479 sctp_assoc_rm_peer(asoc, transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 }
Frank Filz3f7a87d2005-06-20 13:14:57 -07002481
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482nomem:
2483 return 0;
2484}
2485
2486
2487/* Update asoc with the option described in param.
2488 *
2489 * RFC2960 3.3.2.1 Optional/Variable Length Parameters in INIT
2490 *
2491 * asoc is the association to update.
2492 * param is the variable length parameter to use for update.
2493 * cid tells us if this is an INIT, INIT ACK or COOKIE ECHO.
2494 * If the current packet is an INIT we want to minimize the amount of
2495 * work we do. In particular, we should not build transport
2496 * structures for the addresses.
2497 */
2498static int sctp_process_param(struct sctp_association *asoc,
2499 union sctp_params param,
2500 const union sctp_addr *peer_addr,
Al Virodd0fc662005-10-07 07:46:04 +01002501 gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502{
Eric W. Biedermane7ff4a72012-08-07 07:27:02 +00002503 struct net *net = sock_net(asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 union sctp_addr addr;
2505 int i;
2506 __u16 sat;
2507 int retval = 1;
2508 sctp_scope_t scope;
2509 time_t stale;
2510 struct sctp_af *af;
Vlad Yasevichd6de3092007-12-20 14:10:00 -08002511 union sctp_addr_param *addr_param;
2512 struct sctp_transport *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513
2514 /* We maintain all INIT parameters in network byte order all the
2515 * time. This allows us to not worry about whether the parameters
2516 * came from a fresh INIT, and INIT ACK, or were stored in a cookie.
2517 */
2518 switch (param.p->type) {
2519 case SCTP_PARAM_IPV6_ADDRESS:
2520 if (PF_INET6 != asoc->base.sk->sk_family)
2521 break;
Vlad Yasevich7dab83d2008-07-18 23:05:40 -07002522 goto do_addr_param;
2523
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 case SCTP_PARAM_IPV4_ADDRESS:
Vlad Yasevich7dab83d2008-07-18 23:05:40 -07002525 /* v4 addresses are not allowed on v6-only socket */
2526 if (ipv6_only_sock(asoc->base.sk))
2527 break;
2528do_addr_param:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 af = sctp_get_af_specific(param_type2af(param.p->type));
Al Virodd86d132006-11-20 17:11:13 -08002530 af->from_addr_param(&addr, param.addr, htons(asoc->peer.port), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 scope = sctp_scope(peer_addr);
Eric W. Biedermane7ff4a72012-08-07 07:27:02 +00002532 if (sctp_in_scope(net, &addr, scope))
Al Virodd86d132006-11-20 17:11:13 -08002533 if (!sctp_assoc_add_peer(asoc, &addr, gfp, SCTP_UNCONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 return 0;
2535 break;
2536
2537 case SCTP_PARAM_COOKIE_PRESERVATIVE:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002538 if (!net->sctp.cookie_preserve_enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 break;
2540
2541 stale = ntohl(param.life->lifespan_increment);
2542
2543 /* Suggested Cookie Life span increment's unit is msec,
2544 * (1/1000sec).
2545 */
Daniel Borkmann52db8822013-06-25 18:17:27 +02002546 asoc->cookie_life = ktime_add_ms(asoc->cookie_life, stale);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 break;
2548
2549 case SCTP_PARAM_HOST_NAME_ADDRESS:
Daniel Borkmannbb333812013-06-28 19:49:40 +02002550 pr_debug("%s: unimplemented SCTP_HOST_NAME_ADDRESS\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 break;
2552
2553 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
2554 /* Turn off the default values first so we'll know which
2555 * ones are really set by the peer.
2556 */
2557 asoc->peer.ipv4_address = 0;
2558 asoc->peer.ipv6_address = 0;
2559
Gui Jianfeng140ee962008-03-05 13:43:32 -08002560 /* Assume that peer supports the address family
2561 * by which it sends a packet.
2562 */
2563 if (peer_addr->sa.sa_family == AF_INET6)
2564 asoc->peer.ipv6_address = 1;
2565 else if (peer_addr->sa.sa_family == AF_INET)
2566 asoc->peer.ipv4_address = 1;
2567
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 /* Cycle through address types; avoid divide by 0. */
2569 sat = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
2570 if (sat)
2571 sat /= sizeof(__u16);
2572
2573 for (i = 0; i < sat; ++i) {
2574 switch (param.sat->types[i]) {
2575 case SCTP_PARAM_IPV4_ADDRESS:
2576 asoc->peer.ipv4_address = 1;
2577 break;
2578
2579 case SCTP_PARAM_IPV6_ADDRESS:
Wei Yongjun6e40a912008-05-09 15:11:17 -07002580 if (PF_INET6 == asoc->base.sk->sk_family)
2581 asoc->peer.ipv6_address = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 break;
2583
2584 case SCTP_PARAM_HOST_NAME_ADDRESS:
2585 asoc->peer.hostname_address = 1;
2586 break;
2587
2588 default: /* Just ignore anything else. */
2589 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002590 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 }
2592 break;
2593
2594 case SCTP_PARAM_STATE_COOKIE:
2595 asoc->peer.cookie_len =
2596 ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
2597 asoc->peer.cookie = param.cookie->body;
2598 break;
2599
2600 case SCTP_PARAM_HEARTBEAT_INFO:
2601 /* Would be odd to receive, but it causes no problems. */
2602 break;
2603
2604 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
2605 /* Rejected during verify stage. */
2606 break;
2607
2608 case SCTP_PARAM_ECN_CAPABLE:
2609 asoc->peer.ecn_capable = 1;
2610 break;
2611
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002612 case SCTP_PARAM_ADAPTATION_LAYER_IND:
Vlad Yaseviche69c4e02008-09-15 16:29:49 -04002613 asoc->peer.adaptation_ind = ntohl(param.aind->adaptation_ind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 break;
2615
Vlad Yasevichd6de3092007-12-20 14:10:00 -08002616 case SCTP_PARAM_SET_PRIMARY:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002617 if (!net->sctp.addip_enable)
Vlad Yasevich0ef46e22008-09-18 16:27:38 -07002618 goto fall_through;
2619
Vlad Yasevichd6de3092007-12-20 14:10:00 -08002620 addr_param = param.v + sizeof(sctp_addip_param_t);
2621
2622 af = sctp_get_af_specific(param_type2af(param.p->type));
2623 af->from_addr_param(&addr, addr_param,
2624 htons(asoc->peer.port), 0);
2625
2626 /* if the address is invalid, we can't process it.
2627 * XXX: see spec for what to do.
2628 */
2629 if (!af->addr_valid(&addr, NULL, NULL))
2630 break;
2631
2632 t = sctp_assoc_lookup_paddr(asoc, &addr);
2633 if (!t)
2634 break;
2635
2636 sctp_assoc_set_primary(asoc, t);
2637 break;
2638
Vlad Yasevich131a47e2007-09-16 15:53:56 -07002639 case SCTP_PARAM_SUPPORTED_EXT:
2640 sctp_process_ext_param(asoc, param);
2641 break;
2642
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 case SCTP_PARAM_FWD_TSN_SUPPORT:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002644 if (net->sctp.prsctp_enable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 asoc->peer.prsctp_capable = 1;
2646 break;
2647 }
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002648 /* Fall Through */
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002649 goto fall_through;
2650
2651 case SCTP_PARAM_RANDOM:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002652 if (!net->sctp.auth_enable)
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002653 goto fall_through;
2654
2655 /* Save peer's random parameter */
2656 asoc->peer.peer_random = kmemdup(param.p,
2657 ntohs(param.p->length), gfp);
2658 if (!asoc->peer.peer_random) {
2659 retval = 0;
2660 break;
2661 }
2662 break;
2663
2664 case SCTP_PARAM_HMAC_ALGO:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002665 if (!net->sctp.auth_enable)
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002666 goto fall_through;
2667
2668 /* Save peer's HMAC list */
2669 asoc->peer.peer_hmacs = kmemdup(param.p,
2670 ntohs(param.p->length), gfp);
2671 if (!asoc->peer.peer_hmacs) {
2672 retval = 0;
2673 break;
2674 }
2675
2676 /* Set the default HMAC the peer requested*/
2677 sctp_auth_asoc_set_default_hmac(asoc, param.hmac_algo);
2678 break;
2679
2680 case SCTP_PARAM_CHUNKS:
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00002681 if (!net->sctp.auth_enable)
Vlad Yasevich730fc3d2007-09-16 19:32:11 -07002682 goto fall_through;
2683
2684 asoc->peer.peer_chunks = kmemdup(param.p,
2685 ntohs(param.p->length), gfp);
2686 if (!asoc->peer.peer_chunks)
2687 retval = 0;
2688 break;
2689fall_through:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 default:
2691 /* Any unrecognized parameters should have been caught
2692 * and handled by sctp_verify_param() which should be
2693 * called prior to this routine. Simply log the error
2694 * here.
2695 */
Daniel Borkmannbb333812013-06-28 19:49:40 +02002696 pr_debug("%s: ignoring param:%d for association:%p.\n",
2697 __func__, ntohs(param.p->type), asoc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002699 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700
2701 return retval;
2702}
2703
2704/* Select a new verification tag. */
2705__u32 sctp_generate_tag(const struct sctp_endpoint *ep)
2706{
2707 /* I believe that this random number generator complies with RFC1750.
2708 * A tag of 0 is reserved for special cases (e.g. INIT).
2709 */
2710 __u32 x;
2711
2712 do {
2713 get_random_bytes(&x, sizeof(__u32));
2714 } while (x == 0);
2715
2716 return x;
2717}
2718
2719/* Select an initial TSN to send during startup. */
2720__u32 sctp_generate_tsn(const struct sctp_endpoint *ep)
2721{
2722 __u32 retval;
2723
2724 get_random_bytes(&retval, sizeof(__u32));
2725 return retval;
2726}
2727
2728/*
2729 * ADDIP 3.1.1 Address Configuration Change Chunk (ASCONF)
2730 * 0 1 2 3
2731 * 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
2732 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2733 * | Type = 0xC1 | Chunk Flags | Chunk Length |
2734 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2735 * | Serial Number |
2736 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2737 * | Address Parameter |
2738 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2739 * | ASCONF Parameter #1 |
2740 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2741 * \ \
2742 * / .... /
2743 * \ \
2744 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2745 * | ASCONF Parameter #N |
2746 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2747 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002748 * Address Parameter and other parameter will not be wrapped in this function
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 */
2750static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc,
2751 union sctp_addr *addr,
2752 int vparam_len)
2753{
2754 sctp_addiphdr_t asconf;
2755 struct sctp_chunk *retval;
2756 int length = sizeof(asconf) + vparam_len;
2757 union sctp_addr_param addrparam;
2758 int addrlen;
2759 struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
2760
2761 addrlen = af->to_addr_param(addr, &addrparam);
2762 if (!addrlen)
2763 return NULL;
2764 length += addrlen;
2765
2766 /* Create the chunk. */
Vlad Yasevich072017b2013-08-09 22:05:36 -04002767 retval = sctp_make_control(asoc, SCTP_CID_ASCONF, 0, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 if (!retval)
2769 return NULL;
2770
2771 asconf.serial = htonl(asoc->addip_serial++);
2772
2773 retval->subh.addip_hdr =
2774 sctp_addto_chunk(retval, sizeof(asconf), &asconf);
2775 retval->param_hdr.v =
2776 sctp_addto_chunk(retval, addrlen, &addrparam);
2777
2778 return retval;
2779}
2780
2781/* ADDIP
2782 * 3.2.1 Add IP Address
2783 * 0 1 2 3
2784 * 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
2785 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2786 * | Type = 0xC001 | Length = Variable |
2787 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2788 * | ASCONF-Request Correlation ID |
2789 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2790 * | Address Parameter |
2791 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2792 *
2793 * 3.2.2 Delete IP Address
2794 * 0 1 2 3
2795 * 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
2796 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2797 * | Type = 0xC002 | Length = Variable |
2798 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2799 * | ASCONF-Request Correlation ID |
2800 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2801 * | Address Parameter |
2802 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2803 *
2804 */
2805struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc,
2806 union sctp_addr *laddr,
2807 struct sockaddr *addrs,
2808 int addrcnt,
Al Virodbc16db2006-11-20 17:01:42 -08002809 __be16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810{
2811 sctp_addip_param_t param;
2812 struct sctp_chunk *retval;
2813 union sctp_addr_param addr_param;
2814 union sctp_addr *addr;
2815 void *addr_buf;
2816 struct sctp_af *af;
2817 int paramlen = sizeof(param);
2818 int addr_param_len = 0;
2819 int totallen = 0;
2820 int i;
Michio Honda8a07eb02011-04-26 20:19:36 +09002821 int del_pickup = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822
2823 /* Get total length of all the address parameters. */
2824 addr_buf = addrs;
2825 for (i = 0; i < addrcnt; i++) {
Joe Perchesea110732011-06-13 16:21:26 +00002826 addr = addr_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 af = sctp_get_af_specific(addr->v4.sin_family);
2828 addr_param_len = af->to_addr_param(addr, &addr_param);
2829
2830 totallen += paramlen;
2831 totallen += addr_param_len;
2832
2833 addr_buf += af->sockaddr_len;
Michio Honda8a07eb02011-04-26 20:19:36 +09002834 if (asoc->asconf_addr_del_pending && !del_pickup) {
2835 /* reuse the parameter length from the same scope one */
2836 totallen += paramlen;
2837 totallen += addr_param_len;
2838 del_pickup = 1;
Daniel Borkmannbb333812013-06-28 19:49:40 +02002839
2840 pr_debug("%s: picked same-scope del_pending addr, "
2841 "totallen for all addresses is %d\n",
2842 __func__, totallen);
Michio Honda8a07eb02011-04-26 20:19:36 +09002843 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 }
2845
2846 /* Create an asconf chunk with the required length. */
2847 retval = sctp_make_asconf(asoc, laddr, totallen);
2848 if (!retval)
2849 return NULL;
2850
2851 /* Add the address parameters to the asconf chunk. */
2852 addr_buf = addrs;
2853 for (i = 0; i < addrcnt; i++) {
Joe Perchesea110732011-06-13 16:21:26 +00002854 addr = addr_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 af = sctp_get_af_specific(addr->v4.sin_family);
2856 addr_param_len = af->to_addr_param(addr, &addr_param);
2857 param.param_hdr.type = flags;
2858 param.param_hdr.length = htons(paramlen + addr_param_len);
2859 param.crr_id = i;
2860
2861 sctp_addto_chunk(retval, paramlen, &param);
2862 sctp_addto_chunk(retval, addr_param_len, &addr_param);
2863
2864 addr_buf += af->sockaddr_len;
2865 }
Michio Honda8a07eb02011-04-26 20:19:36 +09002866 if (flags == SCTP_PARAM_ADD_IP && del_pickup) {
2867 addr = asoc->asconf_addr_del_pending;
2868 af = sctp_get_af_specific(addr->v4.sin_family);
2869 addr_param_len = af->to_addr_param(addr, &addr_param);
2870 param.param_hdr.type = SCTP_PARAM_DEL_IP;
2871 param.param_hdr.length = htons(paramlen + addr_param_len);
2872 param.crr_id = i;
2873
2874 sctp_addto_chunk(retval, paramlen, &param);
2875 sctp_addto_chunk(retval, addr_param_len, &addr_param);
2876 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 return retval;
2878}
2879
2880/* ADDIP
2881 * 3.2.4 Set Primary IP Address
2882 * 0 1 2 3
2883 * 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
2884 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2885 * | Type =0xC004 | Length = Variable |
2886 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2887 * | ASCONF-Request Correlation ID |
2888 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2889 * | Address Parameter |
2890 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2891 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002892 * Create an ASCONF chunk with Set Primary IP address parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 */
2894struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc,
2895 union sctp_addr *addr)
2896{
2897 sctp_addip_param_t param;
2898 struct sctp_chunk *retval;
2899 int len = sizeof(param);
2900 union sctp_addr_param addrparam;
2901 int addrlen;
2902 struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
2903
2904 addrlen = af->to_addr_param(addr, &addrparam);
2905 if (!addrlen)
2906 return NULL;
2907 len += addrlen;
2908
2909 /* Create the chunk and make asconf header. */
2910 retval = sctp_make_asconf(asoc, addr, len);
2911 if (!retval)
2912 return NULL;
2913
2914 param.param_hdr.type = SCTP_PARAM_SET_PRIMARY;
2915 param.param_hdr.length = htons(len);
2916 param.crr_id = 0;
2917
2918 sctp_addto_chunk(retval, sizeof(param), &param);
2919 sctp_addto_chunk(retval, addrlen, &addrparam);
2920
2921 return retval;
2922}
2923
2924/* ADDIP 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
2925 * 0 1 2 3
2926 * 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
2927 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2928 * | Type = 0x80 | Chunk Flags | Chunk Length |
2929 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2930 * | Serial Number |
2931 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2932 * | ASCONF Parameter Response#1 |
2933 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2934 * \ \
2935 * / .... /
2936 * \ \
2937 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2938 * | ASCONF Parameter Response#N |
2939 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2940 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002941 * Create an ASCONF_ACK chunk with enough space for the parameter responses.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 */
2943static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *asoc,
2944 __u32 serial, int vparam_len)
2945{
2946 sctp_addiphdr_t asconf;
2947 struct sctp_chunk *retval;
2948 int length = sizeof(asconf) + vparam_len;
2949
2950 /* Create the chunk. */
Vlad Yasevich072017b2013-08-09 22:05:36 -04002951 retval = sctp_make_control(asoc, SCTP_CID_ASCONF_ACK, 0, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 if (!retval)
2953 return NULL;
2954
2955 asconf.serial = htonl(serial);
2956
2957 retval->subh.addip_hdr =
2958 sctp_addto_chunk(retval, sizeof(asconf), &asconf);
2959
2960 return retval;
2961}
2962
2963/* Add response parameters to an ASCONF_ACK chunk. */
Al Viro9f81bcd2006-11-20 17:26:34 -08002964static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id,
Al Virodbc16db2006-11-20 17:01:42 -08002965 __be16 err_code, sctp_addip_param_t *asconf_param)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966{
2967 sctp_addip_param_t ack_param;
2968 sctp_errhdr_t err_param;
2969 int asconf_param_len = 0;
2970 int err_param_len = 0;
Al Virodbc16db2006-11-20 17:01:42 -08002971 __be16 response_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972
2973 if (SCTP_ERROR_NO_ERROR == err_code) {
2974 response_type = SCTP_PARAM_SUCCESS_REPORT;
2975 } else {
2976 response_type = SCTP_PARAM_ERR_CAUSE;
2977 err_param_len = sizeof(err_param);
2978 if (asconf_param)
2979 asconf_param_len =
2980 ntohs(asconf_param->param_hdr.length);
2981 }
2982
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002983 /* Add Success Indication or Error Cause Indication parameter. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 ack_param.param_hdr.type = response_type;
2985 ack_param.param_hdr.length = htons(sizeof(ack_param) +
2986 err_param_len +
2987 asconf_param_len);
2988 ack_param.crr_id = crr_id;
2989 sctp_addto_chunk(chunk, sizeof(ack_param), &ack_param);
2990
2991 if (SCTP_ERROR_NO_ERROR == err_code)
2992 return;
2993
2994 /* Add Error Cause parameter. */
2995 err_param.cause = err_code;
2996 err_param.length = htons(err_param_len + asconf_param_len);
2997 sctp_addto_chunk(chunk, err_param_len, &err_param);
2998
2999 /* Add the failed TLV copied from ASCONF chunk. */
3000 if (asconf_param)
3001 sctp_addto_chunk(chunk, asconf_param_len, asconf_param);
3002}
3003
3004/* Process a asconf parameter. */
Al Virodbc16db2006-11-20 17:01:42 -08003005static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 struct sctp_chunk *asconf,
3007 sctp_addip_param_t *asconf_param)
3008{
3009 struct sctp_transport *peer;
3010 struct sctp_af *af;
3011 union sctp_addr addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 union sctp_addr_param *addr_param;
Al Viro5f242a12006-11-20 17:05:23 -08003013
Joe Perchesea110732011-06-13 16:21:26 +00003014 addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);
Patrick McHardyc1cc6782008-05-13 23:25:00 -07003015
Wei Yongjun44e65c12009-06-16 14:48:24 +08003016 if (asconf_param->param_hdr.type != SCTP_PARAM_ADD_IP &&
3017 asconf_param->param_hdr.type != SCTP_PARAM_DEL_IP &&
3018 asconf_param->param_hdr.type != SCTP_PARAM_SET_PRIMARY)
3019 return SCTP_ERROR_UNKNOWN_PARAM;
3020
Shan Wei6a435732011-04-18 19:11:47 +00003021 switch (addr_param->p.type) {
Wei Yongjunc4492582008-05-09 15:11:53 -07003022 case SCTP_PARAM_IPV6_ADDRESS:
3023 if (!asoc->peer.ipv6_address)
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003024 return SCTP_ERROR_DNS_FAILED;
Wei Yongjunc4492582008-05-09 15:11:53 -07003025 break;
3026 case SCTP_PARAM_IPV4_ADDRESS:
3027 if (!asoc->peer.ipv4_address)
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003028 return SCTP_ERROR_DNS_FAILED;
Wei Yongjunc4492582008-05-09 15:11:53 -07003029 break;
3030 default:
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003031 return SCTP_ERROR_DNS_FAILED;
Wei Yongjunc4492582008-05-09 15:11:53 -07003032 }
3033
Shan Wei6a435732011-04-18 19:11:47 +00003034 af = sctp_get_af_specific(param_type2af(addr_param->p.type));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 if (unlikely(!af))
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003036 return SCTP_ERROR_DNS_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037
Al Virodd86d132006-11-20 17:11:13 -08003038 af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0);
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003039
3040 /* ADDIP 4.2.1 This parameter MUST NOT contain a broadcast
3041 * or multicast address.
3042 * (note: wildcard is permitted and requires special handling so
3043 * make sure we check for that)
3044 */
3045 if (!af->is_any(&addr) && !af->addr_valid(&addr, NULL, asconf->skb))
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003046 return SCTP_ERROR_DNS_FAILED;
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003047
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 switch (asconf_param->param_hdr.type) {
3049 case SCTP_PARAM_ADD_IP:
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003050 /* Section 4.2.1:
3051 * If the address 0.0.0.0 or ::0 is provided, the source
3052 * address of the packet MUST be added.
3053 */
3054 if (af->is_any(&addr))
3055 memcpy(&addr, &asconf->source, sizeof(addr));
3056
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057 /* ADDIP 4.3 D9) If an endpoint receives an ADD IP address
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003058 * request and does not have the local resources to add this
3059 * new address to the association, it MUST return an Error
3060 * Cause TLV set to the new error code 'Operation Refused
3061 * Due to Resource Shortage'.
3062 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063
Al Virodd86d132006-11-20 17:11:13 -08003064 peer = sctp_assoc_add_peer(asoc, &addr, GFP_ATOMIC, SCTP_UNCONFIRMED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065 if (!peer)
3066 return SCTP_ERROR_RSRC_LOW;
3067
3068 /* Start the heartbeat timer. */
3069 if (!mod_timer(&peer->hb_timer, sctp_transport_timeout(peer)))
3070 sctp_transport_hold(peer);
Michio Honda6af29cc2011-06-16 17:14:34 +09003071 asoc->new_transport = peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 break;
3073 case SCTP_PARAM_DEL_IP:
3074 /* ADDIP 4.3 D7) If a request is received to delete the
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003075 * last remaining IP address of a peer endpoint, the receiver
3076 * MUST send an Error Cause TLV with the error cause set to the
3077 * new error code 'Request to Delete Last Remaining IP Address'.
3078 */
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003079 if (asoc->peer.transport_count == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 return SCTP_ERROR_DEL_LAST_IP;
3081
3082 /* ADDIP 4.3 D8) If a request is received to delete an IP
3083 * address which is also the source address of the IP packet
3084 * which contained the ASCONF chunk, the receiver MUST reject
3085 * this request. To reject the request the receiver MUST send
3086 * an Error Cause TLV set to the new error code 'Request to
3087 * Delete Source IP Address'
3088 */
Michio Hondab1364102011-04-26 17:37:02 +09003089 if (sctp_cmp_addr_exact(&asconf->source, &addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 return SCTP_ERROR_DEL_SRC_IP;
3091
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003092 /* Section 4.2.2
3093 * If the address 0.0.0.0 or ::0 is provided, all
3094 * addresses of the peer except the source address of the
3095 * packet MUST be deleted.
3096 */
3097 if (af->is_any(&addr)) {
3098 sctp_assoc_set_primary(asoc, asconf->transport);
3099 sctp_assoc_del_nonprimary_peers(asoc,
3100 asconf->transport);
3101 } else
3102 sctp_assoc_del_peer(asoc, &addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 break;
3104 case SCTP_PARAM_SET_PRIMARY:
Vlad Yasevich42e30bf2007-12-20 14:08:56 -08003105 /* ADDIP Section 4.2.4
3106 * If the address 0.0.0.0 or ::0 is provided, the receiver
3107 * MAY mark the source address of the packet as its
3108 * primary.
3109 */
3110 if (af->is_any(&addr))
3111 memcpy(&addr.v4, sctp_source(asconf), sizeof(addr));
3112
Al Virodd86d132006-11-20 17:11:13 -08003113 peer = sctp_assoc_lookup_paddr(asoc, &addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 if (!peer)
Wei Yongjun945e5ab2009-04-16 14:21:02 +08003115 return SCTP_ERROR_DNS_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116
3117 sctp_assoc_set_primary(asoc, peer);
3118 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119 }
3120
3121 return SCTP_ERROR_NO_ERROR;
3122}
3123
Wei Yongjun6f4c6182007-09-19 17:19:52 +08003124/* Verify the ASCONF packet before we process it. */
3125int sctp_verify_asconf(const struct sctp_association *asoc,
3126 struct sctp_paramhdr *param_hdr, void *chunk_end,
3127 struct sctp_paramhdr **errp) {
3128 sctp_addip_param_t *asconf_param;
3129 union sctp_params param;
3130 int length, plen;
3131
3132 param.v = (sctp_paramhdr_t *) param_hdr;
3133 while (param.v <= chunk_end - sizeof(sctp_paramhdr_t)) {
3134 length = ntohs(param.p->length);
3135 *errp = param.p;
3136
3137 if (param.v > chunk_end - length ||
3138 length < sizeof(sctp_paramhdr_t))
3139 return 0;
3140
3141 switch (param.p->type) {
3142 case SCTP_PARAM_ADD_IP:
3143 case SCTP_PARAM_DEL_IP:
3144 case SCTP_PARAM_SET_PRIMARY:
3145 asconf_param = (sctp_addip_param_t *)param.v;
3146 plen = ntohs(asconf_param->param_hdr.length);
3147 if (plen < sizeof(sctp_addip_param_t) +
3148 sizeof(sctp_paramhdr_t))
3149 return 0;
3150 break;
3151 case SCTP_PARAM_SUCCESS_REPORT:
3152 case SCTP_PARAM_ADAPTATION_LAYER_IND:
3153 if (length != sizeof(sctp_addip_param_t))
3154 return 0;
3155
3156 break;
3157 default:
3158 break;
3159 }
3160
3161 param.v += WORD_ROUND(length);
3162 }
3163
3164 if (param.v != chunk_end)
3165 return 0;
3166
3167 return 1;
3168}
3169
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003170/* Process an incoming ASCONF chunk with the next expected serial no. and
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 * return an ASCONF_ACK chunk to be sent in response.
3172 */
3173struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc,
3174 struct sctp_chunk *asconf)
3175{
3176 sctp_addiphdr_t *hdr;
3177 union sctp_addr_param *addr_param;
3178 sctp_addip_param_t *asconf_param;
3179 struct sctp_chunk *asconf_ack;
3180
Al Virodbc16db2006-11-20 17:01:42 -08003181 __be16 err_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 int length = 0;
Wei Yongjunf3830cc2007-10-15 11:51:03 +09003183 int chunk_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184 __u32 serial;
3185 int all_param_pass = 1;
3186
Wei Yongjunf3830cc2007-10-15 11:51:03 +09003187 chunk_len = ntohs(asconf->chunk_hdr->length) - sizeof(sctp_chunkhdr_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003188 hdr = (sctp_addiphdr_t *)asconf->skb->data;
3189 serial = ntohl(hdr->serial);
3190
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003191 /* Skip the addiphdr and store a pointer to address parameter. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003192 length = sizeof(sctp_addiphdr_t);
3193 addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
3194 chunk_len -= length;
3195
3196 /* Skip the address parameter and store a pointer to the first
Joe Perches7aa1b542007-12-20 14:03:52 -08003197 * asconf parameter.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003198 */
Shan Wei6a435732011-04-18 19:11:47 +00003199 length = ntohs(addr_param->p.length);
Joe Perchesea110732011-06-13 16:21:26 +00003200 asconf_param = (void *)addr_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 chunk_len -= length;
3202
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003203 /* create an ASCONF_ACK chunk.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 * Based on the definitions of parameters, we know that the size of
Wei Yongjun2cab86b2011-03-31 23:42:55 +00003205 * ASCONF_ACK parameters are less than or equal to the fourfold of ASCONF
Joe Perches7aa1b542007-12-20 14:03:52 -08003206 * parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 */
Wei Yongjun2cab86b2011-03-31 23:42:55 +00003208 asconf_ack = sctp_make_asconf_ack(asoc, serial, chunk_len * 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209 if (!asconf_ack)
3210 goto done;
3211
3212 /* Process the TLVs contained within the ASCONF chunk. */
3213 while (chunk_len > 0) {
3214 err_code = sctp_process_asconf_param(asoc, asconf,
3215 asconf_param);
3216 /* ADDIP 4.1 A7)
3217 * If an error response is received for a TLV parameter,
3218 * all TLVs with no response before the failed TLV are
3219 * considered successful if not reported. All TLVs after
3220 * the failed response are considered unsuccessful unless
3221 * a specific success indication is present for the parameter.
3222 */
3223 if (SCTP_ERROR_NO_ERROR != err_code)
3224 all_param_pass = 0;
3225
3226 if (!all_param_pass)
3227 sctp_add_asconf_response(asconf_ack,
3228 asconf_param->crr_id, err_code,
3229 asconf_param);
3230
3231 /* ADDIP 4.3 D11) When an endpoint receiving an ASCONF to add
3232 * an IP address sends an 'Out of Resource' in its response, it
3233 * MUST also fail any subsequent add or delete requests bundled
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003234 * in the ASCONF.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 */
3236 if (SCTP_ERROR_RSRC_LOW == err_code)
3237 goto done;
3238
3239 /* Move to the next ASCONF param. */
3240 length = ntohs(asconf_param->param_hdr.length);
Joe Perchesea110732011-06-13 16:21:26 +00003241 asconf_param = (void *)asconf_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 chunk_len -= length;
3243 }
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003244
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245done:
3246 asoc->peer.addip_serial++;
3247
3248 /* If we are sending a new ASCONF_ACK hold a reference to it in assoc
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003249 * after freeing the reference to old asconf ack if any.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250 */
3251 if (asconf_ack) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252 sctp_chunk_hold(asconf_ack);
Vlad Yasevicha08de642007-12-20 14:11:47 -08003253 list_add_tail(&asconf_ack->transmitted_list,
3254 &asoc->asconf_ack_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 }
3256
3257 return asconf_ack;
3258}
3259
3260/* Process a asconf parameter that is successfully acked. */
Wei Yongjun425e0f62009-06-16 14:47:30 +08003261static void sctp_asconf_param_success(struct sctp_association *asoc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 sctp_addip_param_t *asconf_param)
3263{
3264 struct sctp_af *af;
3265 union sctp_addr addr;
3266 struct sctp_bind_addr *bp = &asoc->base.bind_addr;
3267 union sctp_addr_param *addr_param;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268 struct sctp_transport *transport;
Sridhar Samudraladc022a92006-07-21 14:49:25 -07003269 struct sctp_sockaddr_entry *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270
Joe Perchesea110732011-06-13 16:21:26 +00003271 addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272
3273 /* We have checked the packet before, so we do not check again. */
Shan Wei6a435732011-04-18 19:11:47 +00003274 af = sctp_get_af_specific(param_type2af(addr_param->p.type));
Al Virodd86d132006-11-20 17:11:13 -08003275 af->from_addr_param(&addr, addr_param, htons(bp->port), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276
3277 switch (asconf_param->param_hdr.type) {
3278 case SCTP_PARAM_ADD_IP:
Vlad Yasevich559cf712007-09-16 16:03:28 -07003279 /* This is always done in BH context with a socket lock
3280 * held, so the list can not change.
3281 */
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -04003282 local_bh_disable();
Vlad Yasevich559cf712007-09-16 16:03:28 -07003283 list_for_each_entry(saddr, &bp->address_list, list) {
Al Virodd86d132006-11-20 17:11:13 -08003284 if (sctp_cmp_addr_exact(&saddr->a, &addr))
Vlad Yasevichf57d96b2007-12-20 14:12:24 -08003285 saddr->state = SCTP_ADDR_SRC;
Sridhar Samudraladc022a92006-07-21 14:49:25 -07003286 }
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -04003287 local_bh_enable();
Wei Yongjun3cd97492009-06-16 10:07:23 +08003288 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
3289 transports) {
Wei Yongjun3cd97492009-06-16 10:07:23 +08003290 dst_release(transport->dst);
Vlad Yasevichc6ef0062011-04-18 19:15:22 +00003291 transport->dst = NULL;
Wei Yongjun3cd97492009-06-16 10:07:23 +08003292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293 break;
3294 case SCTP_PARAM_DEL_IP:
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -04003295 local_bh_disable();
Wei Yongjun425e0f62009-06-16 14:47:30 +08003296 sctp_del_bind_addr(bp, &addr);
Michio Honda8a07eb02011-04-26 20:19:36 +09003297 if (asoc->asconf_addr_del_pending != NULL &&
3298 sctp_cmp_addr_exact(asoc->asconf_addr_del_pending, &addr)) {
3299 kfree(asoc->asconf_addr_del_pending);
3300 asoc->asconf_addr_del_pending = NULL;
3301 }
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -04003302 local_bh_enable();
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07003303 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
3304 transports) {
Sridhar Samudraladc022a92006-07-21 14:49:25 -07003305 dst_release(transport->dst);
Vlad Yasevichc6ef0062011-04-18 19:15:22 +00003306 transport->dst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307 }
3308 break;
3309 default:
3310 break;
3311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312}
3313
3314/* Get the corresponding ASCONF response error code from the ASCONF_ACK chunk
3315 * for the given asconf parameter. If there is no response for this parameter,
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003316 * return the error code based on the third argument 'no_err'.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317 * ADDIP 4.1
3318 * A7) If an error response is received for a TLV parameter, all TLVs with no
3319 * response before the failed TLV are considered successful if not reported.
3320 * All TLVs after the failed response are considered unsuccessful unless a
3321 * specific success indication is present for the parameter.
3322 */
Al Virodbc16db2006-11-20 17:01:42 -08003323static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 sctp_addip_param_t *asconf_param,
3325 int no_err)
3326{
3327 sctp_addip_param_t *asconf_ack_param;
3328 sctp_errhdr_t *err_param;
3329 int length;
Wei Yongjunf3830cc2007-10-15 11:51:03 +09003330 int asconf_ack_len;
Al Virodbc16db2006-11-20 17:01:42 -08003331 __be16 err_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332
3333 if (no_err)
3334 err_code = SCTP_ERROR_NO_ERROR;
3335 else
3336 err_code = SCTP_ERROR_REQ_REFUSED;
3337
Wei Yongjunf3830cc2007-10-15 11:51:03 +09003338 asconf_ack_len = ntohs(asconf_ack->chunk_hdr->length) -
3339 sizeof(sctp_chunkhdr_t);
3340
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 /* Skip the addiphdr from the asconf_ack chunk and store a pointer to
3342 * the first asconf_ack parameter.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003343 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344 length = sizeof(sctp_addiphdr_t);
3345 asconf_ack_param = (sctp_addip_param_t *)(asconf_ack->skb->data +
3346 length);
3347 asconf_ack_len -= length;
3348
3349 while (asconf_ack_len > 0) {
3350 if (asconf_ack_param->crr_id == asconf_param->crr_id) {
3351 switch(asconf_ack_param->param_hdr.type) {
3352 case SCTP_PARAM_SUCCESS_REPORT:
3353 return SCTP_ERROR_NO_ERROR;
3354 case SCTP_PARAM_ERR_CAUSE:
3355 length = sizeof(sctp_addip_param_t);
Joe Perchesea110732011-06-13 16:21:26 +00003356 err_param = (void *)asconf_ack_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357 asconf_ack_len -= length;
3358 if (asconf_ack_len > 0)
3359 return err_param->cause;
3360 else
3361 return SCTP_ERROR_INV_PARAM;
3362 break;
3363 default:
3364 return SCTP_ERROR_INV_PARAM;
3365 }
3366 }
3367
3368 length = ntohs(asconf_ack_param->param_hdr.length);
Joe Perchesea110732011-06-13 16:21:26 +00003369 asconf_ack_param = (void *)asconf_ack_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370 asconf_ack_len -= length;
3371 }
3372
3373 return err_code;
3374}
3375
3376/* Process an incoming ASCONF_ACK chunk against the cached last ASCONF chunk. */
3377int sctp_process_asconf_ack(struct sctp_association *asoc,
3378 struct sctp_chunk *asconf_ack)
3379{
3380 struct sctp_chunk *asconf = asoc->addip_last_asconf;
3381 union sctp_addr_param *addr_param;
3382 sctp_addip_param_t *asconf_param;
3383 int length = 0;
3384 int asconf_len = asconf->skb->len;
3385 int all_param_pass = 0;
3386 int no_err = 1;
3387 int retval = 0;
Al Virodbc16db2006-11-20 17:01:42 -08003388 __be16 err_code = SCTP_ERROR_NO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389
3390 /* Skip the chunkhdr and addiphdr from the last asconf sent and store
3391 * a pointer to address parameter.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003392 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 length = sizeof(sctp_addip_chunk_t);
3394 addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
3395 asconf_len -= length;
3396
3397 /* Skip the address parameter in the last asconf sent and store a
Joe Perches7aa1b542007-12-20 14:03:52 -08003398 * pointer to the first asconf parameter.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003399 */
Shan Wei6a435732011-04-18 19:11:47 +00003400 length = ntohs(addr_param->p.length);
Joe Perchesea110732011-06-13 16:21:26 +00003401 asconf_param = (void *)addr_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 asconf_len -= length;
3403
3404 /* ADDIP 4.1
3405 * A8) If there is no response(s) to specific TLV parameter(s), and no
3406 * failures are indicated, then all request(s) are considered
3407 * successful.
3408 */
3409 if (asconf_ack->skb->len == sizeof(sctp_addiphdr_t))
3410 all_param_pass = 1;
3411
3412 /* Process the TLVs contained in the last sent ASCONF chunk. */
3413 while (asconf_len > 0) {
3414 if (all_param_pass)
3415 err_code = SCTP_ERROR_NO_ERROR;
3416 else {
3417 err_code = sctp_get_asconf_response(asconf_ack,
3418 asconf_param,
3419 no_err);
3420 if (no_err && (SCTP_ERROR_NO_ERROR != err_code))
3421 no_err = 0;
3422 }
3423
3424 switch (err_code) {
3425 case SCTP_ERROR_NO_ERROR:
Wei Yongjun425e0f62009-06-16 14:47:30 +08003426 sctp_asconf_param_success(asoc, asconf_param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 break;
3428
3429 case SCTP_ERROR_RSRC_LOW:
3430 retval = 1;
3431 break;
3432
Wei Yongjuna987f762009-04-07 15:44:29 +08003433 case SCTP_ERROR_UNKNOWN_PARAM:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434 /* Disable sending this type of asconf parameter in
3435 * future.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003436 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 asoc->peer.addip_disabled_mask |=
3438 asconf_param->param_hdr.type;
3439 break;
3440
3441 case SCTP_ERROR_REQ_REFUSED:
3442 case SCTP_ERROR_DEL_LAST_IP:
3443 case SCTP_ERROR_DEL_SRC_IP:
3444 default:
3445 break;
3446 }
3447
3448 /* Skip the processed asconf parameter and move to the next
3449 * one.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003450 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 length = ntohs(asconf_param->param_hdr.length);
Joe Perchesea110732011-06-13 16:21:26 +00003452 asconf_param = (void *)asconf_param + length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 asconf_len -= length;
3454 }
3455
Michio Hondaddc4bbe2011-06-17 11:03:23 +09003456 if (no_err && asoc->src_out_of_asoc_ok) {
Michio Honda8a07eb02011-04-26 20:19:36 +09003457 asoc->src_out_of_asoc_ok = 0;
Michio Hondaddc4bbe2011-06-17 11:03:23 +09003458 sctp_transport_immediate_rtx(asoc->peer.primary_path);
3459 }
Michio Honda8a07eb02011-04-26 20:19:36 +09003460
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 /* Free the cached last sent asconf chunk. */
Vlad Yasevich5f9646c2008-02-05 14:23:44 -05003462 list_del_init(&asconf->transmitted_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 sctp_chunk_free(asconf);
3464 asoc->addip_last_asconf = NULL;
3465
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466 return retval;
3467}
3468
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003469/* Make a FWD TSN chunk. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003470struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
3471 __u32 new_cum_tsn, size_t nstreams,
3472 struct sctp_fwdtsn_skip *skiplist)
3473{
3474 struct sctp_chunk *retval = NULL;
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003475 struct sctp_fwdtsn_hdr ftsn_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476 struct sctp_fwdtsn_skip skip;
3477 size_t hint;
3478 int i;
3479
3480 hint = (nstreams + 1) * sizeof(__u32);
3481
Vlad Yasevich072017b2013-08-09 22:05:36 -04003482 retval = sctp_make_control(asoc, SCTP_CID_FWD_TSN, 0, hint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483
3484 if (!retval)
3485 return NULL;
3486
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
3488 retval->subh.fwdtsn_hdr =
3489 sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
3490
3491 for (i = 0; i < nstreams; i++) {
3492 skip.stream = skiplist[i].stream;
3493 skip.ssn = skiplist[i].ssn;
3494 sctp_addto_chunk(retval, sizeof(skip), &skip);
3495 }
3496
3497 return retval;
3498}