projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / sctp / sm_make_chunk.c
CommitLineData
60c778b2 1/* SCTP kernel implementation
1da177e4
LT		 2 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999-2000 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
5 * Copyright (c) 2001-2002 Intel Corp.
6 *
60c778b2 7 * This file is part of the SCTP kernel implementation
1da177e4
LT		 8 *
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 *
60c778b2 13 * This SCTP implementation is free software;
1da177e4
LT		 14 * you can redistribute it and/or modify it under the terms of
15 * the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
17 * any later version.
18 *
60c778b2 19 * This SCTP implementation is distributed in the hope that it
1da177e4
LT		 20 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21 * ************************
22 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
23 * See the GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with GNU CC; see the file COPYING. If not, write to
27 * the Free Software Foundation, 59 Temple Place - Suite 330,
28 * Boston, MA 02111-1307, USA.
29 *
30 * Please send any bug reports or fixes you make to the
31 * email address(es):
32 * lksctp developers <lksctp-developers@lists.sourceforge.net>
33 *
34 * Or submit a bug report through the following website:
35 * http://www.sf.net/projects/lksctp
36 *
37 * Written or modified by:
38 * La Monte H.P. Yarroll <piggy@acm.org>
39 * Karl Knutson <karl@athena.chicago.il.us>
40 * C. Robin <chris@hundredacre.ac.uk>
41 * Jon Grimm <jgrimm@us.ibm.com>
42 * Xingang Guo <xingang.guo@intel.com>
43 * Dajiang Zhang <dajiang.zhang@nokia.com>
44 * Sridhar Samudrala <sri@us.ibm.com>
45 * Daisy Chang <daisyc@us.ibm.com>
46 * Ardelle Fan <ardelle.fan@intel.com>
47 * Kevin Gao <kevin.gao@intel.com>
48 *
49 * Any bugs reported given to us we will try to fix... any fixes shared will
50 * be incorporated into the next SCTP release.
51 */
52
145ce502
JP		 53#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
54
1da177e4
LT		 55#include <linux/types.h>
56#include <linux/kernel.h>
57#include <linux/ip.h>
58#include <linux/ipv6.h>
59#include <linux/net.h>
60#include <linux/inet.h>
ebc3bbcf 61#include <linux/scatterlist.h>
1da177e4 62#include <linux/crypto.h>
5a0e3ad6 63#include <linux/slab.h>
1da177e4
LT		 64#include <net/sock.h>
65
66#include <linux/skbuff.h>
67#include <linux/random.h> /* for get_random_bytes */
68#include <net/sctp/sctp.h>
69#include <net/sctp/sm.h>
70
1da177e4
LT		 71SCTP_STATIC
72struct sctp_chunk *sctp_make_chunk(const struct sctp_association *asoc,
73 __u8 type, __u8 flags, int paylen);
74static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
75 const struct sctp_association *asoc,
76 const struct sctp_chunk *init_chunk,
77 int *cookie_len,
78 const __u8 *raw_addrs, int addrs_len);
79static int sctp_process_param(struct sctp_association *asoc,
80 union sctp_params param,
81 const union sctp_addr *peer_addr,
dd0fc66f 82 gfp_t gfp);
8ee4be37
VY		 83static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
84 const void *data);
1da177e4
LT		 85
86/* What was the inbound interface for this chunk? */
87int sctp_chunk_iif(const struct sctp_chunk *chunk)
88{
89 struct sctp_af *af;
90 int iif = 0;
91
eddc9ec5 92 af = sctp_get_af_specific(ipver2af(ip_hdr(chunk->skb)->version));
1da177e4
LT		 93 if (af)
94 iif = af->skb_iif(chunk->skb);
95
96 return iif;
97}
98
99/* RFC 2960 3.3.2 Initiation (INIT) (1)
100 *
101 * Note 2: The ECN capable field is reserved for future use of
102 * Explicit Congestion Notification.
103 */
104static const struct sctp_paramhdr ecap_param = {
105 SCTP_PARAM_ECN_CAPABLE,
09640e63 106 cpu_to_be16(sizeof(struct sctp_paramhdr)),
1da177e4
LT		 107};
108static const struct sctp_paramhdr prsctp_param = {
109 SCTP_PARAM_FWD_TSN_SUPPORT,
09640e63 110 cpu_to_be16(sizeof(struct sctp_paramhdr)),
1da177e4
LT		 111};
112
5fa782c2 113/* A helper to initialize an op error inside a
1da177e4
LT		 114 * provided chunk, as most cause codes will be embedded inside an
115 * abort chunk.
116 */
5bf2db03 117void sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,
00f1c2df 118 size_t paylen)
1da177e4
LT		 119{
120 sctp_errhdr_t err;
1da177e4
LT		 121 __u16 len;
122
d808ad9a 123 /* Cause code constants are now defined in network order. */
1da177e4
LT		 124 err.cause = cause_code;
125 len = sizeof(sctp_errhdr_t) + paylen;
1da177e4 126 err.length = htons(len);
4a1c0107 127 chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err);
1da177e4
LT		 128}
129
5fa782c2
NH		 130/* A helper to initialize an op error inside a
131 * provided chunk, as most cause codes will be embedded inside an
132 * abort chunk. Differs from sctp_init_cause in that it won't oops
133 * if there isn't enough space in the op error chunk
134 */
db28aafa 135static int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,
5fa782c2
NH		 136 size_t paylen)
137{
138 sctp_errhdr_t err;
139 __u16 len;
140
141 /* Cause code constants are now defined in network order. */
142 err.cause = cause_code;
143 len = sizeof(sctp_errhdr_t) + paylen;
144 err.length = htons(len);
145
2e3219b5 146 if (skb_tailroom(chunk->skb) < len)
5fa782c2
NH		 147 return -ENOSPC;
148 chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk,
149 sizeof(sctp_errhdr_t),
150 &err);
151 return 0;
152}
1da177e4
LT		 153/* 3.3.2 Initiation (INIT) (1)
154 *
155 * This chunk is used to initiate a SCTP association between two
156 * endpoints. The format of the INIT chunk is shown below:
157 *
158 * 0 1 2 3
159 * 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
160 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
161 * | Type = 1 | Chunk Flags | Chunk Length |
162 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
163 * | Initiate Tag |
164 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
165 * | Advertised Receiver Window Credit (a_rwnd) |
166 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
167 * | Number of Outbound Streams | Number of Inbound Streams |
168 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
169 * | Initial TSN |
170 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
171 * \ \
172 * / Optional/Variable-Length Parameters /
173 * \ \
174 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
175 *
176 *
177 * The INIT chunk contains the following parameters. Unless otherwise
178 * noted, each parameter MUST only be included once in the INIT chunk.
179 *
180 * Fixed Parameters Status
181 * ----------------------------------------------
182 * Initiate Tag Mandatory
183 * Advertised Receiver Window Credit Mandatory
184 * Number of Outbound Streams Mandatory
185 * Number of Inbound Streams Mandatory
186 * Initial TSN Mandatory
187 *
188 * Variable Parameters Status Type Value
189 * -------------------------------------------------------------
190 * IPv4 Address (Note 1) Optional 5
191 * IPv6 Address (Note 1) Optional 6
192 * Cookie Preservative Optional 9
193 * Reserved for ECN Capable (Note 2) Optional 32768 (0x8000)
194 * Host Name Address (Note 3) Optional 11
195 * Supported Address Types (Note 4) Optional 12
196 */
197struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
198 const struct sctp_bind_addr *bp,
dd0fc66f 199 gfp_t gfp, int vparam_len)
1da177e4 200{
e1fc3b14 201 struct net *net = sock_net(asoc->base.sk);
e5eae4a0 202 struct sctp_endpoint *ep = asoc->ep;
1da177e4
LT		 203 sctp_inithdr_t init;
204 union sctp_params addrs;
205 size_t chunksize;
206 struct sctp_chunk *retval = NULL;
207 int num_types, addrs_len = 0;
208 struct sctp_sock *sp;
209 sctp_supported_addrs_param_t sat;
3dbe8656 210 __be16 types[2];
0f3fffd8 211 sctp_adaptation_ind_param_t aiparam;
131a47e3
VY		 212 sctp_supported_ext_param_t ext_param;
213 int num_ext = 0;
214 __u8 extensions[3];
730fc3d0
VY		 215 sctp_paramhdr_t *auth_chunks = NULL,
216 *auth_hmacs = NULL;
1da177e4
LT		 217
218 /* RFC 2960 3.3.2 Initiation (INIT) (1)
219 *
220 * Note 1: The INIT chunks can contain multiple addresses that
221 * can be IPv4 and/or IPv6 in any combination.
222 */
223 retval = NULL;
224
225 /* Convert the provided bind address list to raw format. */
226 addrs = sctp_bind_addrs_to_raw(bp, &addrs_len, gfp);
227
228 init.init_tag = htonl(asoc->c.my_vtag);
229 init.a_rwnd = htonl(asoc->rwnd);
230 init.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
231 init.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
232 init.initial_tsn = htonl(asoc->c.initial_tsn);
233
234 /* How many address types are needed? */
235 sp = sctp_sk(asoc->base.sk);
236 num_types = sp->pf->supported_addrs(sp, types);
237
a8170c35
WY		 238 chunksize = sizeof(init) + addrs_len;
239 chunksize += WORD_ROUND(SCTP_SAT_LEN(num_types));
1da177e4 240 chunksize += sizeof(ecap_param);
8ee4be37 241
e1fc3b14 242 if (net->sctp.prsctp_enable)
036b579b
VY		 243 chunksize += sizeof(prsctp_param);
244
131a47e3
VY		 245 /* ADDIP: Section 4.2.7:
246 * An implementation supporting this extension [ADDIP] MUST list
247 * the ASCONF,the ASCONF-ACK, and the AUTH chunks in its INIT and
248 * INIT-ACK parameters.
131a47e3 249 */
e1fc3b14 250 if (net->sctp.addip_enable) {
131a47e3
VY		 251 extensions[num_ext] = SCTP_CID_ASCONF;
252 extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
253 num_ext += 2;
254 }
255
6fc791ee 256 if (sp->adaptation_ind)
257 chunksize += sizeof(aiparam);
258
1da177e4
LT		 259 chunksize += vparam_len;
260
730fc3d0 261 /* Account for AUTH related parameters */
e5eae4a0 262 if (ep->auth_enable) {
730fc3d0
VY		 263 /* Add random parameter length*/
264 chunksize += sizeof(asoc->c.auth_random);
265
266 /* Add HMACS parameter length if any were defined */
267 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
268 if (auth_hmacs->length)
a8170c35 269 chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
730fc3d0
VY		 270 else
271 auth_hmacs = NULL;
272
273 /* Add CHUNKS parameter length */
274 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
275 if (auth_chunks->length)
a8170c35 276 chunksize += WORD_ROUND(ntohs(auth_chunks->length));
730fc3d0 277 else
9baffaa6 278 auth_chunks = NULL;
730fc3d0
VY		 279
280 extensions[num_ext] = SCTP_CID_AUTH;
281 num_ext += 1;
282 }
283
131a47e3
VY		 284 /* If we have any extensions to report, account for that */
285 if (num_ext)
a8170c35
WY		 286 chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
287 num_ext);
131a47e3 288
1da177e4
LT		 289 /* RFC 2960 3.3.2 Initiation (INIT) (1)
290 *
291 * Note 3: An INIT chunk MUST NOT contain more than one Host
292 * Name address parameter. Moreover, the sender of the INIT
293 * MUST NOT combine any other address types with the Host Name
294 * address in the INIT. The receiver of INIT MUST ignore any
295 * other address types if the Host Name address parameter is
296 * present in the received INIT chunk.
297 *
298 * PLEASE DO NOT FIXME [This version does not support Host Name.]
299 */
300
301 retval = sctp_make_chunk(asoc, SCTP_CID_INIT, 0, chunksize);
302 if (!retval)
303 goto nodata;
304
305 retval->subh.init_hdr =
306 sctp_addto_chunk(retval, sizeof(init), &init);
307 retval->param_hdr.v =
308 sctp_addto_chunk(retval, addrs_len, addrs.v);
309
310 /* RFC 2960 3.3.2 Initiation (INIT) (1)
311 *
312 * Note 4: This parameter, when present, specifies all the
313 * address types the sending endpoint can support. The absence
314 * of this parameter indicates that the sending endpoint can
315 * support any address type.
316 */
317 sat.param_hdr.type = SCTP_PARAM_SUPPORTED_ADDRESS_TYPES;
318 sat.param_hdr.length = htons(SCTP_SAT_LEN(num_types));
319 sctp_addto_chunk(retval, sizeof(sat), &sat);
320 sctp_addto_chunk(retval, num_types * sizeof(__u16), &types);
321
322 sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
131a47e3 323
7aa1b54b 324 /* Add the supported extensions parameter. Be nice and add this
131a47e3
VY		 325 * fist before addiding the parameters for the extensions themselves
326 */
327 if (num_ext) {
328 ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
329 ext_param.param_hdr.length =
330 htons(sizeof(sctp_supported_ext_param_t) + num_ext);
331 sctp_addto_chunk(retval, sizeof(sctp_supported_ext_param_t),
332 &ext_param);
8ee4be37 333 sctp_addto_param(retval, num_ext, extensions);
131a47e3
VY		 334 }
335
e1fc3b14 336 if (net->sctp.prsctp_enable)
1da177e4 337 sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
131a47e3 338
6fc791ee 339 if (sp->adaptation_ind) {
340 aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
341 aiparam.param_hdr.length = htons(sizeof(aiparam));
342 aiparam.adaptation_ind = htonl(sp->adaptation_ind);
343 sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
344 }
131a47e3 345
730fc3d0 346 /* Add SCTP-AUTH chunks to the parameter list */
e5eae4a0 347 if (ep->auth_enable) {
730fc3d0
VY		 348 sctp_addto_chunk(retval, sizeof(asoc->c.auth_random),
349 asoc->c.auth_random);
350 if (auth_hmacs)
351 sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
352 auth_hmacs);
353 if (auth_chunks)
354 sctp_addto_chunk(retval, ntohs(auth_chunks->length),
355 auth_chunks);
356 }
1da177e4 357nodata:
a51482bd 358 kfree(addrs.v);
1da177e4
LT		 359 return retval;
360}
361
362struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
363 const struct sctp_chunk *chunk,
dd0fc66f 364 gfp_t gfp, int unkparam_len)
1da177e4
LT		 365{
366 sctp_inithdr_t initack;
367 struct sctp_chunk *retval;
368 union sctp_params addrs;
6fc791ee 369 struct sctp_sock *sp;
1da177e4
LT		 370 int addrs_len;
371 sctp_cookie_param_t *cookie;
372 int cookie_len;
373 size_t chunksize;
0f3fffd8 374 sctp_adaptation_ind_param_t aiparam;
131a47e3
VY		 375 sctp_supported_ext_param_t ext_param;
376 int num_ext = 0;
377 __u8 extensions[3];
730fc3d0
VY		 378 sctp_paramhdr_t *auth_chunks = NULL,
379 *auth_hmacs = NULL,
380 *auth_random = NULL;
1da177e4
LT		 381
382 retval = NULL;
383
384 /* Note: there may be no addresses to embed. */
385 addrs = sctp_bind_addrs_to_raw(&asoc->base.bind_addr, &addrs_len, gfp);
386
387 initack.init_tag = htonl(asoc->c.my_vtag);
388 initack.a_rwnd = htonl(asoc->rwnd);
389 initack.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
390 initack.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
391 initack.initial_tsn = htonl(asoc->c.initial_tsn);
392
393 /* FIXME: We really ought to build the cookie right
394 * into the packet instead of allocating more fresh memory.
395 */
396 cookie = sctp_pack_cookie(asoc->ep, asoc, chunk, &cookie_len,
397 addrs.v, addrs_len);
398 if (!cookie)
399 goto nomem_cookie;
400
401 /* Calculate the total size of allocation, include the reserved
402 * space for reporting unknown parameters if it is specified.
403 */
6fc791ee 404 sp = sctp_sk(asoc->base.sk);
1da177e4
LT		 405 chunksize = sizeof(initack) + addrs_len + cookie_len + unkparam_len;
406
d808ad9a 407 /* Tell peer that we'll do ECN only if peer advertised such cap. */
1da177e4
LT		 408 if (asoc->peer.ecn_capable)
409 chunksize += sizeof(ecap_param);
410
5ffad5ac 411 if (asoc->peer.prsctp_capable)
036b579b
VY		 412 chunksize += sizeof(prsctp_param);
413
5ffad5ac 414 if (asoc->peer.asconf_capable) {
131a47e3
VY		 415 extensions[num_ext] = SCTP_CID_ASCONF;
416 extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
417 num_ext += 2;
418 }
419
6fc791ee 420 if (sp->adaptation_ind)
421 chunksize += sizeof(aiparam);
1da177e4 422
730fc3d0
VY		 423 if (asoc->peer.auth_capable) {
424 auth_random = (sctp_paramhdr_t *)asoc->c.auth_random;
425 chunksize += ntohs(auth_random->length);
426
427 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
428 if (auth_hmacs->length)
a8170c35 429 chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
730fc3d0
VY		 430 else
431 auth_hmacs = NULL;
432
433 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
434 if (auth_chunks->length)
a8170c35 435 chunksize += WORD_ROUND(ntohs(auth_chunks->length));
730fc3d0
VY		 436 else
437 auth_chunks = NULL;
438
439 extensions[num_ext] = SCTP_CID_AUTH;
440 num_ext += 1;
441 }
442
8ee4be37 443 if (num_ext)
a8170c35
WY		 444 chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
445 num_ext);
8ee4be37 446
1da177e4
LT		 447 /* Now allocate and fill out the chunk. */
448 retval = sctp_make_chunk(asoc, SCTP_CID_INIT_ACK, 0, chunksize);
449 if (!retval)
450 goto nomem_chunk;
451
b99a4d53
DC		 452 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
453 *
454 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
455 * HEARTBEAT ACK, * etc.) to the same destination transport
456 * address from which it received the DATA or control chunk
457 * to which it is replying.
458 *
459 * [INIT ACK back to where the INIT came from.]
1da177e4
LT		 460 */
461 retval->transport = chunk->transport;
b99a4d53 462
1da177e4
LT		 463 retval->subh.init_hdr =
464 sctp_addto_chunk(retval, sizeof(initack), &initack);
465 retval->param_hdr.v = sctp_addto_chunk(retval, addrs_len, addrs.v);
466 sctp_addto_chunk(retval, cookie_len, cookie);
467 if (asoc->peer.ecn_capable)
468 sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
131a47e3
VY		 469 if (num_ext) {
470 ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
471 ext_param.param_hdr.length =
472 htons(sizeof(sctp_supported_ext_param_t) + num_ext);
473 sctp_addto_chunk(retval, sizeof(sctp_supported_ext_param_t),
474 &ext_param);
8ee4be37 475 sctp_addto_param(retval, num_ext, extensions);
131a47e3 476 }
1da177e4
LT		 477 if (asoc->peer.prsctp_capable)
478 sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
479
6fc791ee 480 if (sp->adaptation_ind) {
481 aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
482 aiparam.param_hdr.length = htons(sizeof(aiparam));
483 aiparam.adaptation_ind = htonl(sp->adaptation_ind);
484 sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
485 }
1da177e4 486
730fc3d0
VY		 487 if (asoc->peer.auth_capable) {
488 sctp_addto_chunk(retval, ntohs(auth_random->length),
489 auth_random);
490 if (auth_hmacs)
491 sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
492 auth_hmacs);
493 if (auth_chunks)
494 sctp_addto_chunk(retval, ntohs(auth_chunks->length),
495 auth_chunks);
496 }
497
1da177e4
LT		 498 /* We need to remove the const qualifier at this point. */
499 retval->asoc = (struct sctp_association *) asoc;
500
1da177e4
LT		 501nomem_chunk:
502 kfree(cookie);
503nomem_cookie:
a51482bd 504 kfree(addrs.v);
1da177e4
LT		 505 return retval;
506}
507
508/* 3.3.11 Cookie Echo (COOKIE ECHO) (10):
509 *
510 * This chunk is used only during the initialization of an association.
511 * It is sent by the initiator of an association to its peer to complete
512 * the initialization process. This chunk MUST precede any DATA chunk
513 * sent within the association, but MAY be bundled with one or more DATA
514 * chunks in the same packet.
515 *
516 * 0 1 2 3
517 * 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
518 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
519 * | Type = 10 |Chunk Flags | Length |
520 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
521 * / Cookie /
522 * \ \
523 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
524 *
525 * Chunk Flags: 8 bit
526 *
527 * Set to zero on transmit and ignored on receipt.
528 *
529 * Length: 16 bits (unsigned integer)
530 *
531 * Set to the size of the chunk in bytes, including the 4 bytes of
532 * the chunk header and the size of the Cookie.
533 *
534 * Cookie: variable size
535 *
536 * This field must contain the exact cookie received in the
537 * State Cookie parameter from the previous INIT ACK.
538 *
539 * An implementation SHOULD make the cookie as small as possible
540 * to insure interoperability.
541 */
542struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *asoc,
543 const struct sctp_chunk *chunk)
544{
545 struct sctp_chunk *retval;
546 void *cookie;
547 int cookie_len;
548
549 cookie = asoc->peer.cookie;
550 cookie_len = asoc->peer.cookie_len;
551
552 /* Build a cookie echo chunk. */
553 retval = sctp_make_chunk(asoc, SCTP_CID_COOKIE_ECHO, 0, cookie_len);
554 if (!retval)
555 goto nodata;
556 retval->subh.cookie_hdr =
557 sctp_addto_chunk(retval, cookie_len, cookie);
558
559 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
560 *
561 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
562 * HEARTBEAT ACK, * etc.) to the same destination transport
563 * address from which it * received the DATA or control chunk
564 * to which it is replying.
565 *
566 * [COOKIE ECHO back to where the INIT ACK came from.]
567 */
568 if (chunk)
569 retval->transport = chunk->transport;
570
571nodata:
572 return retval;
573}
574
575/* 3.3.12 Cookie Acknowledgement (COOKIE ACK) (11):
576 *
577 * This chunk is used only during the initialization of an
578 * association. It is used to acknowledge the receipt of a COOKIE
579 * ECHO chunk. This chunk MUST precede any DATA or SACK chunk sent
580 * within the association, but MAY be bundled with one or more DATA
581 * chunks or SACK chunk in the same SCTP packet.
582 *
583 * 0 1 2 3
584 * 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
585 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
586 * | Type = 11 |Chunk Flags | Length = 4 |
587 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
588 *
589 * Chunk Flags: 8 bits
590 *
591 * Set to zero on transmit and ignored on receipt.
592 */
593struct sctp_chunk *sctp_make_cookie_ack(const struct sctp_association *asoc,
594 const struct sctp_chunk *chunk)
595{
596 struct sctp_chunk *retval;
597
598 retval = sctp_make_chunk(asoc, SCTP_CID_COOKIE_ACK, 0, 0);
599
600 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
601 *
602 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
603 * HEARTBEAT ACK, * etc.) to the same destination transport
604 * address from which it * received the DATA or control chunk
605 * to which it is replying.
606 *
607 * [COOKIE ACK back to where the COOKIE ECHO came from.]
608 */
609 if (retval && chunk)
610 retval->transport = chunk->transport;
611
612 return retval;
613}
614
615/*
616 * Appendix A: Explicit Congestion Notification:
617 * CWR:
618 *
619 * RFC 2481 details a specific bit for a sender to send in the header of
620 * its next outbound TCP segment to indicate to its peer that it has
621 * reduced its congestion window. This is termed the CWR bit. For
622 * SCTP the same indication is made by including the CWR chunk.
623 * This chunk contains one data element, i.e. the TSN number that
624 * was sent in the ECNE chunk. This element represents the lowest
625 * TSN number in the datagram that was originally marked with the
626 * CE bit.
627 *
628 * 0 1 2 3
629 * 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
630 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
631 * | Chunk Type=13 | Flags=00000000| Chunk Length = 8 |
632 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
633 * | Lowest TSN Number |
634 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
635 *
636 * Note: The CWR is considered a Control chunk.
637 */
638struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc,
639 const __u32 lowest_tsn,
640 const struct sctp_chunk *chunk)
641{
642 struct sctp_chunk *retval;
643 sctp_cwrhdr_t cwr;
644
645 cwr.lowest_tsn = htonl(lowest_tsn);
646 retval = sctp_make_chunk(asoc, SCTP_CID_ECN_CWR, 0,
647 sizeof(sctp_cwrhdr_t));
648
649 if (!retval)
650 goto nodata;
651
652 retval->subh.ecn_cwr_hdr =
653 sctp_addto_chunk(retval, sizeof(cwr), &cwr);
654
655 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
656 *
657 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
658 * HEARTBEAT ACK, * etc.) to the same destination transport
659 * address from which it * received the DATA or control chunk
660 * to which it is replying.
661 *
662 * [Report a reduced congestion window back to where the ECNE
663 * came from.]
664 */
665 if (chunk)
666 retval->transport = chunk->transport;
667
668nodata:
669 return retval;
670}
671
672/* Make an ECNE chunk. This is a congestion experienced report. */
673struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc,
674 const __u32 lowest_tsn)
675{
676 struct sctp_chunk *retval;
677 sctp_ecnehdr_t ecne;
678
679 ecne.lowest_tsn = htonl(lowest_tsn);
680 retval = sctp_make_chunk(asoc, SCTP_CID_ECN_ECNE, 0,
681 sizeof(sctp_ecnehdr_t));
682 if (!retval)
683 goto nodata;
684 retval->subh.ecne_hdr =
685 sctp_addto_chunk(retval, sizeof(ecne), &ecne);
686
687nodata:
688 return retval;
689}
690
691/* Make a DATA chunk for the given association from the provided
692 * parameters. However, do not populate the data payload.
693 */
694struct sctp_chunk *sctp_make_datafrag_empty(struct sctp_association *asoc,
695 const struct sctp_sndrcvinfo *sinfo,
696 int data_len, __u8 flags, __u16 ssn)
697{
698 struct sctp_chunk *retval;
699 struct sctp_datahdr dp;
700 int chunk_len;
701
702 /* We assign the TSN as LATE as possible, not here when
703 * creating the chunk.
704 */
705 dp.tsn = 0;
706 dp.stream = htons(sinfo->sinfo_stream);
707 dp.ppid = sinfo->sinfo_ppid;
708
709 /* Set the flags for an unordered send. */
eaa5c54d 710 if (sinfo->sinfo_flags & SCTP_UNORDERED) {
1da177e4
LT		 711 flags |= SCTP_DATA_UNORDERED;
712 dp.ssn = 0;
713 } else
714 dp.ssn = htons(ssn);
715
716 chunk_len = sizeof(dp) + data_len;
717 retval = sctp_make_chunk(asoc, SCTP_CID_DATA, flags, chunk_len);
718 if (!retval)
719 goto nodata;
720
721 retval->subh.data_hdr = sctp_addto_chunk(retval, sizeof(dp), &dp);
722 memcpy(&retval->sinfo, sinfo, sizeof(struct sctp_sndrcvinfo));
723
724nodata:
725 return retval;
726}
727
728/* Create a selective ackowledgement (SACK) for the given
729 * association. This reports on which TSN's we've seen to date,
730 * including duplicates and gaps.
731 */
732struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc)
733{
734 struct sctp_chunk *retval;
735 struct sctp_sackhdr sack;
736 int len;
737 __u32 ctsn;
738 __u16 num_gabs, num_dup_tsns;
4244854d 739 struct sctp_association *aptr = (struct sctp_association *)asoc;
1da177e4 740 struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
02015180 741 struct sctp_gap_ack_block gabs[SCTP_MAX_GABS];
4244854d 742 struct sctp_transport *trans;
1da177e4 743
02015180 744 memset(gabs, 0, sizeof(gabs));
1da177e4
LT		 745 ctsn = sctp_tsnmap_get_ctsn(map);
746 SCTP_DEBUG_PRINTK("sackCTSNAck sent: 0x%x.\n", ctsn);
747
748 /* How much room is needed in the chunk? */
02015180 749 num_gabs = sctp_tsnmap_num_gabs(map, gabs);
1da177e4
LT		 750 num_dup_tsns = sctp_tsnmap_num_dups(map);
751
752 /* Initialize the SACK header. */
753 sack.cum_tsn_ack = htonl(ctsn);
754 sack.a_rwnd = htonl(asoc->a_rwnd);
755 sack.num_gap_ack_blocks = htons(num_gabs);
756 sack.num_dup_tsns = htons(num_dup_tsns);
757
758 len = sizeof(sack)
759 + sizeof(struct sctp_gap_ack_block) * num_gabs
760 + sizeof(__u32) * num_dup_tsns;
761
762 /* Create the chunk. */
763 retval = sctp_make_chunk(asoc, SCTP_CID_SACK, 0, len);
764 if (!retval)
765 goto nodata;
766
767 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
768 *
769 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
770 * HEARTBEAT ACK, etc.) to the same destination transport
771 * address from which it received the DATA or control chunk to
772 * which it is replying. This rule should also be followed if
773 * the endpoint is bundling DATA chunks together with the
774 * reply chunk.
775 *
776 * However, when acknowledging multiple DATA chunks received
777 * in packets from different source addresses in a single
778 * SACK, the SACK chunk may be transmitted to one of the
779 * destination transport addresses from which the DATA or
780 * control chunks being acknowledged were received.
781 *
782 * [BUG: We do not implement the following paragraph.
783 * Perhaps we should remember the last transport we used for a
784 * SACK and avoid that (if possible) if we have seen any
785 * duplicates. --piggy]
786 *
787 * When a receiver of a duplicate DATA chunk sends a SACK to a
788 * multi- homed endpoint it MAY be beneficial to vary the
789 * destination address and not use the source address of the
790 * DATA chunk. The reason being that receiving a duplicate
791 * from a multi-homed endpoint might indicate that the return
792 * path (as specified in the source address of the DATA chunk)
793 * for the SACK is broken.
794 *
795 * [Send to the address from which we last received a DATA chunk.]
796 */
797 retval->transport = asoc->peer.last_data_from;
798
799 retval->subh.sack_hdr =
800 sctp_addto_chunk(retval, sizeof(sack), &sack);
801
802 /* Add the gap ack block information. */
803 if (num_gabs)
804 sctp_addto_chunk(retval, sizeof(__u32) * num_gabs,
02015180 805 gabs);
1da177e4
LT		 806
807 /* Add the duplicate TSN information. */
196d6759
MB		 808 if (num_dup_tsns) {
809 aptr->stats.idupchunks += num_dup_tsns;
1da177e4
LT		 810 sctp_addto_chunk(retval, sizeof(__u32) * num_dup_tsns,
811 sctp_tsnmap_get_dups(map));
196d6759 812 }
4244854d
NH		 813 /* Once we have a sack generated, check to see what our sack
814 * generation is, if its 0, reset the transports to 0, and reset
815 * the association generation to 1
816 *
817 * The idea is that zero is never used as a valid generation for the
818 * association so no transport will match after a wrap event like this,
819 * Until the next sack
820 */
821 if (++aptr->peer.sack_generation == 0) {
822 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
823 transports)
824 trans->sack_generation = 0;
825 aptr->peer.sack_generation = 1;
826 }
1da177e4
LT		 827nodata:
828 return retval;
829}
830
831/* Make a SHUTDOWN chunk. */
832struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,
833 const struct sctp_chunk *chunk)
834{
835 struct sctp_chunk *retval;
836 sctp_shutdownhdr_t shut;
837 __u32 ctsn;
838
839 ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
840 shut.cum_tsn_ack = htonl(ctsn);
841
842 retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN, 0,
843 sizeof(sctp_shutdownhdr_t));
844 if (!retval)
845 goto nodata;
846
847 retval->subh.shutdown_hdr =
848 sctp_addto_chunk(retval, sizeof(shut), &shut);
849
850 if (chunk)
851 retval->transport = chunk->transport;
852nodata:
853 return retval;
854}
855
856struct sctp_chunk *sctp_make_shutdown_ack(const struct sctp_association *asoc,
857 const struct sctp_chunk *chunk)
858{
859 struct sctp_chunk *retval;
860
861 retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0);
862
863 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
864 *
865 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
866 * HEARTBEAT ACK, * etc.) to the same destination transport
867 * address from which it * received the DATA or control chunk
868 * to which it is replying.
869 *
870 * [ACK back to where the SHUTDOWN came from.]
871 */
872 if (retval && chunk)
873 retval->transport = chunk->transport;
874
875 return retval;
876}
877
878struct sctp_chunk *sctp_make_shutdown_complete(
879 const struct sctp_association *asoc,
880 const struct sctp_chunk *chunk)
881{
882 struct sctp_chunk *retval;
883 __u8 flags = 0;
884
047a2428
JF		 885 /* Set the T-bit if we have no association (vtag will be
886 * reflected)
887 */
1da177e4
LT		 888 flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
889
890 retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags, 0);
891
892 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
893 *
894 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
895 * HEARTBEAT ACK, * etc.) to the same destination transport
896 * address from which it * received the DATA or control chunk
897 * to which it is replying.
898 *
899 * [Report SHUTDOWN COMPLETE back to where the SHUTDOWN ACK
900 * came from.]
901 */
902 if (retval && chunk)
903 retval->transport = chunk->transport;
904
d808ad9a 905 return retval;
1da177e4
LT		 906}
907
908/* Create an ABORT. Note that we set the T bit if we have no
047a2428 909 * association, except when responding to an INIT (sctpimpguide 2.41).
1da177e4
LT		 910 */
911struct sctp_chunk *sctp_make_abort(const struct sctp_association *asoc,
912 const struct sctp_chunk *chunk,
913 const size_t hint)
914{
915 struct sctp_chunk *retval;
916 __u8 flags = 0;
917
047a2428
JF		 918 /* Set the T-bit if we have no association and 'chunk' is not
919 * an INIT (vtag will be reflected).
920 */
921 if (!asoc) {
922 if (chunk && chunk->chunk_hdr &&
923 chunk->chunk_hdr->type == SCTP_CID_INIT)
924 flags = 0;
925 else
926 flags = SCTP_CHUNK_FLAG_T;
927 }
1da177e4
LT		 928
929 retval = sctp_make_chunk(asoc, SCTP_CID_ABORT, flags, hint);
930
931 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
932 *
933 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
934 * HEARTBEAT ACK, * etc.) to the same destination transport
935 * address from which it * received the DATA or control chunk
936 * to which it is replying.
937 *
938 * [ABORT back to where the offender came from.]
939 */
940 if (retval && chunk)
941 retval->transport = chunk->transport;
942
943 return retval;
944}
945
946/* Helper to create ABORT with a NO_USER_DATA error. */
947struct sctp_chunk *sctp_make_abort_no_data(
948 const struct sctp_association *asoc,
949 const struct sctp_chunk *chunk, __u32 tsn)
950{
951 struct sctp_chunk *retval;
9f81bcd9 952 __be32 payload;
1da177e4
LT		 953
954 retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t)
955 + sizeof(tsn));
956
957 if (!retval)
958 goto no_mem;
959
960 /* Put the tsn back into network byte order. */
961 payload = htonl(tsn);
00f1c2df
WY		 962 sctp_init_cause(retval, SCTP_ERROR_NO_DATA, sizeof(payload));
963 sctp_addto_chunk(retval, sizeof(payload), (const void *)&payload);
1da177e4
LT		 964
965 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
966 *
967 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
968 * HEARTBEAT ACK, * etc.) to the same destination transport
969 * address from which it * received the DATA or control chunk
970 * to which it is replying.
971 *
972 * [ABORT back to where the offender came from.]
973 */
974 if (chunk)
975 retval->transport = chunk->transport;
976
977no_mem:
978 return retval;
979}
980
981/* Helper to create ABORT with a SCTP_ERROR_USER_ABORT error. */
982struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc,
c164a9ba
SS		 983 const struct msghdr *msg,
984 size_t paylen)
1da177e4
LT		 985{
986 struct sctp_chunk *retval;
c164a9ba
SS		 987 void *payload = NULL;
988 int err;
1da177e4 989
c164a9ba 990 retval = sctp_make_abort(asoc, NULL, sizeof(sctp_errhdr_t) + paylen);
1da177e4
LT		 991 if (!retval)
992 goto err_chunk;
993
994 if (paylen) {
995 /* Put the msg_iov together into payload. */
c164a9ba 996 payload = kmalloc(paylen, GFP_KERNEL);
1da177e4
LT		 997 if (!payload)
998 goto err_payload;
c164a9ba
SS		 999
1000 err = memcpy_fromiovec(payload, msg->msg_iov, paylen);
1001 if (err < 0)
1002 goto err_copy;
1da177e4
LT		 1003 }
1004
00f1c2df
WY		 1005 sctp_init_cause(retval, SCTP_ERROR_USER_ABORT, paylen);
1006 sctp_addto_chunk(retval, paylen, payload);
1da177e4
LT		 1007
1008 if (paylen)
1009 kfree(payload);
1010
1011 return retval;
1012
1013err_copy:
1014 kfree(payload);
1015err_payload:
1016 sctp_chunk_free(retval);
1017 retval = NULL;
1018err_chunk:
1019 return retval;
1020}
1021
5c94bf86
AB		 1022/* Append bytes to the end of a parameter. Will panic if chunk is not big
1023 * enough.
1024 */
1025static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
1026 const void *data)
1027{
1028 void *target;
1029 int chunklen = ntohs(chunk->chunk_hdr->length);
1030
1031 target = skb_put(chunk->skb, len);
1032
6383cfb3
VY		 1033 if (data)
1034 memcpy(target, data, len);
1035 else
1036 memset(target, 0, len);
5c94bf86
AB		 1037
1038 /* Adjust the chunk length field. */
1039 chunk->chunk_hdr->length = htons(chunklen + len);
1040 chunk->chunk_end = skb_tail_pointer(chunk->skb);
1041
1042 return target;
1043}
1044
d808ad9a 1045/* Make an ABORT chunk with a PROTOCOL VIOLATION cause code. */
1da177e4
LT		 1046struct sctp_chunk *sctp_make_abort_violation(
1047 const struct sctp_association *asoc,
1048 const struct sctp_chunk *chunk,
1049 const __u8 *payload,
1050 const size_t paylen)
1051{
1052 struct sctp_chunk *retval;
1053 struct sctp_paramhdr phdr;
1054
1055 retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t) + paylen
00f1c2df 1056 + sizeof(sctp_paramhdr_t));
1da177e4
LT		 1057 if (!retval)
1058 goto end;
1059
00f1c2df
WY		 1060 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, paylen
1061 + sizeof(sctp_paramhdr_t));
1da177e4
LT		 1062
1063 phdr.type = htons(chunk->chunk_hdr->type);
1064 phdr.length = chunk->chunk_hdr->length;
00f1c2df
WY		 1065 sctp_addto_chunk(retval, paylen, payload);
1066 sctp_addto_param(retval, sizeof(sctp_paramhdr_t), &phdr);
1da177e4
LT		 1067
1068end:
1069 return retval;
1070}
1071
ba016670
WY		 1072struct sctp_chunk *sctp_make_violation_paramlen(
1073 const struct sctp_association *asoc,
1074 const struct sctp_chunk *chunk,
1075 struct sctp_paramhdr *param)
1076{
1077 struct sctp_chunk *retval;
1078 static const char error[] = "The following parameter had invalid length:";
1079 size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t) +
1080 sizeof(sctp_paramhdr_t);
1081
1082 retval = sctp_make_abort(asoc, chunk, payload_len);
1083 if (!retval)
1084 goto nodata;
1085
1086 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION,
1087 sizeof(error) + sizeof(sctp_paramhdr_t));
1088 sctp_addto_chunk(retval, sizeof(error), error);
1089 sctp_addto_param(retval, sizeof(sctp_paramhdr_t), param);
1090
1091nodata:
1092 return retval;
1093}
1094
de4594a5
NH		 1095struct sctp_chunk *sctp_make_violation_max_retrans(
1096 const struct sctp_association *asoc,
1097 const struct sctp_chunk *chunk)
1098{
1099 struct sctp_chunk *retval;
1100 static const char error[] = "Association exceeded its max_retans count";
1101 size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t);
1102
1103 retval = sctp_make_abort(asoc, chunk, payload_len);
1104 if (!retval)
1105 goto nodata;
1106
1107 sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, sizeof(error));
1108 sctp_addto_chunk(retval, sizeof(error), error);
1109
1110nodata:
1111 return retval;
1112}
1113
1da177e4
LT		 1114/* Make a HEARTBEAT chunk. */
1115struct sctp_chunk *sctp_make_heartbeat(const struct sctp_association *asoc,
92c73af5 1116 const struct sctp_transport *transport)
1da177e4 1117{
92c73af5
WY		 1118 struct sctp_chunk *retval;
1119 sctp_sender_hb_info_t hbinfo;
1120
1121 retval = sctp_make_chunk(asoc, SCTP_CID_HEARTBEAT, 0, sizeof(hbinfo));
1da177e4
LT		 1122
1123 if (!retval)
1124 goto nodata;
1125
92c73af5
WY		 1126 hbinfo.param_hdr.type = SCTP_PARAM_HEARTBEAT_INFO;
1127 hbinfo.param_hdr.length = htons(sizeof(sctp_sender_hb_info_t));
1128 hbinfo.daddr = transport->ipaddr;
1129 hbinfo.sent_at = jiffies;
1130 hbinfo.hb_nonce = transport->hb_nonce;
1131
1da177e4
LT		 1132 /* Cast away the 'const', as this is just telling the chunk
1133 * what transport it belongs to.
1134 */
1135 retval->transport = (struct sctp_transport *) transport;
92c73af5
WY		 1136 retval->subh.hbs_hdr = sctp_addto_chunk(retval, sizeof(hbinfo),
1137 &hbinfo);
1da177e4
LT		 1138
1139nodata:
1140 return retval;
1141}
1142
1143struct sctp_chunk *sctp_make_heartbeat_ack(const struct sctp_association *asoc,
1144 const struct sctp_chunk *chunk,
1145 const void *payload, const size_t paylen)
1146{
1147 struct sctp_chunk *retval;
1148
1149 retval = sctp_make_chunk(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen);
1150 if (!retval)
1151 goto nodata;
1152
1153 retval->subh.hbs_hdr = sctp_addto_chunk(retval, paylen, payload);
1154
1155 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1156 *
1157 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1158 * HEARTBEAT ACK, * etc.) to the same destination transport
1159 * address from which it * received the DATA or control chunk
1160 * to which it is replying.
1161 *
1162 * [HBACK back to where the HEARTBEAT came from.]
1163 */
1164 if (chunk)
1165 retval->transport = chunk->transport;
1166
1167nodata:
1168 return retval;
1169}
1170
1171/* Create an Operation Error chunk with the specified space reserved.
1172 * This routine can be used for containing multiple causes in the chunk.
1173 */
1174static struct sctp_chunk *sctp_make_op_error_space(
1175 const struct sctp_association *asoc,
1176 const struct sctp_chunk *chunk,
1177 size_t size)
1178{
1179 struct sctp_chunk *retval;
1180
1181 retval = sctp_make_chunk(asoc, SCTP_CID_ERROR, 0,
1182 sizeof(sctp_errhdr_t) + size);
1183 if (!retval)
1184 goto nodata;
1185
1186 /* RFC 2960 6.4 Multi-homed SCTP Endpoints
1187 *
1188 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
1189 * HEARTBEAT ACK, etc.) to the same destination transport
1190 * address from which it received the DATA or control chunk
1191 * to which it is replying.
1192 *
1193 */
1194 if (chunk)
1195 retval->transport = chunk->transport;
1196
1197nodata:
1198 return retval;
1199}
1200
5fa782c2
NH		 1201/* Create an Operation Error chunk of a fixed size,
1202 * specifically, max(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT)
1203 * This is a helper function to allocate an error chunk for
1204 * for those invalid parameter codes in which we may not want
d82603c6 1205 * to report all the errors, if the incoming chunk is large
5fa782c2
NH		 1206 */
1207static inline struct sctp_chunk *sctp_make_op_error_fixed(
1208 const struct sctp_association *asoc,
1209 const struct sctp_chunk *chunk)
1210{
1211 size_t size = asoc ? asoc->pathmtu : 0;
1212
1213 if (!size)
1214 size = SCTP_DEFAULT_MAXSEGMENT;
1215
1216 return sctp_make_op_error_space(asoc, chunk, size);
1217}
1218
1da177e4
LT		 1219/* Create an Operation Error chunk. */
1220struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc,
1221 const struct sctp_chunk *chunk,
63706c5c 1222 __be16 cause_code, const void *payload,
6383cfb3 1223 size_t paylen, size_t reserve_tail)
1da177e4
LT		 1224{
1225 struct sctp_chunk *retval;
1226
6383cfb3 1227 retval = sctp_make_op_error_space(asoc, chunk, paylen + reserve_tail);
1da177e4
LT		 1228 if (!retval)
1229 goto nodata;
1230
6383cfb3 1231 sctp_init_cause(retval, cause_code, paylen + reserve_tail);
00f1c2df 1232 sctp_addto_chunk(retval, paylen, payload);
6383cfb3
VY		 1233 if (reserve_tail)
1234 sctp_addto_param(retval, reserve_tail, NULL);
1da177e4
LT		 1235
1236nodata:
1237 return retval;
1238}
1239
4cd57c80
VY		 1240struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc)
1241{
1242 struct sctp_chunk *retval;
1243 struct sctp_hmac *hmac_desc;
1244 struct sctp_authhdr auth_hdr;
1245 __u8 *hmac;
1246
1247 /* Get the first hmac that the peer told us to use */
1248 hmac_desc = sctp_auth_asoc_get_hmac(asoc);
1249 if (unlikely(!hmac_desc))
1250 return NULL;
1251
1252 retval = sctp_make_chunk(asoc, SCTP_CID_AUTH, 0,
1253 hmac_desc->hmac_len + sizeof(sctp_authhdr_t));
1254 if (!retval)
1255 return NULL;
1256
1257 auth_hdr.hmac_id = htons(hmac_desc->hmac_id);
1258 auth_hdr.shkey_id = htons(asoc->active_key_id);
1259
1260 retval->subh.auth_hdr = sctp_addto_chunk(retval, sizeof(sctp_authhdr_t),
1261 &auth_hdr);
1262
1263 hmac = skb_put(retval->skb, hmac_desc->hmac_len);
1264 memset(hmac, 0, hmac_desc->hmac_len);
1265
1266 /* Adjust the chunk header to include the empty MAC */
1267 retval->chunk_hdr->length =
1268 htons(ntohs(retval->chunk_hdr->length) + hmac_desc->hmac_len);
1269 retval->chunk_end = skb_tail_pointer(retval->skb);
1270
1271 return retval;
1272}
1273
1274
1da177e4
LT		 1275/********************************************************************
1276 * 2nd Level Abstractions
1277 ********************************************************************/
1278
1279/* Turn an skb into a chunk.
1280 * FIXME: Eventually move the structure directly inside the skb->cb[].
1281 */
1282struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
1283 const struct sctp_association *asoc,
1284 struct sock *sk)
1285{
1286 struct sctp_chunk *retval;
1287
c3762229 1288 retval = kmem_cache_zalloc(sctp_chunk_cachep, GFP_ATOMIC);
1da177e4
LT		 1289
1290 if (!retval)
1291 goto nodata;
1da177e4
LT		 1292
1293 if (!sk) {
1294 SCTP_DEBUG_PRINTK("chunkifying skb %p w/o an sk\n", skb);
1295 }
1296
79af02c2 1297 INIT_LIST_HEAD(&retval->list);
1da177e4
LT		 1298 retval->skb = skb;
1299 retval->asoc = (struct sctp_association *)asoc;
1da177e4
LT		 1300 retval->has_tsn = 0;
1301 retval->has_ssn = 0;
1302 retval->rtt_in_progress = 0;
1303 retval->sent_at = 0;
1304 retval->singleton = 1;
1305 retval->end_of_packet = 0;
1306 retval->ecn_ce_done = 0;
1307 retval->pdiscard = 0;
1308
1309 /* sctpimpguide-05.txt Section 2.8.2
1310 * M1) Each time a new DATA chunk is transmitted
1311 * set the 'TSN.Missing.Report' count for that TSN to 0. The
1312 * 'TSN.Missing.Report' count will be used to determine missing chunks
1313 * and when to fast retransmit.
1314 */
1315 retval->tsn_missing_report = 0;
1316 retval->tsn_gap_acked = 0;
c226ef9b 1317 retval->fast_retransmit = SCTP_CAN_FRTX;
1da177e4
LT		 1318
1319 /* If this is a fragmented message, track all fragments
1320 * of the message (for SEND_FAILED).
1321 */
1322 retval->msg = NULL;
1323
1324 /* Polish the bead hole. */
1325 INIT_LIST_HEAD(&retval->transmitted_list);
1326 INIT_LIST_HEAD(&retval->frag_list);
1327 SCTP_DBG_OBJCNT_INC(chunk);
1328 atomic_set(&retval->refcnt, 1);
1329
1330nodata:
1331 return retval;
1332}
1333
1334/* Set chunk->source and dest based on the IP header in chunk->skb. */
1335void sctp_init_addrs(struct sctp_chunk *chunk, union sctp_addr *src,
1336 union sctp_addr *dest)
1337{
f235fca3 1338 memcpy(&chunk->source, src, sizeof(union sctp_addr));
16b0a030 1339 memcpy(&chunk->dest, dest, sizeof(union sctp_addr));
1da177e4
LT		 1340}
1341
1342/* Extract the source address from a chunk. */
1343const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)
1344{
1345 /* If we have a known transport, use that. */
1346 if (chunk->transport) {
6a1e5f33 1347 return &chunk->transport->ipaddr;
1da177e4
LT		 1348 } else {
1349 /* Otherwise, extract it from the IP header. */
6a1e5f33 1350 return &chunk->source;
1da177e4
LT		 1351 }
1352}
1353
1354/* Create a new chunk, setting the type and flags headers from the
1355 * arguments, reserving enough space for a 'paylen' byte payload.
1356 */
1357SCTP_STATIC
1358struct sctp_chunk *sctp_make_chunk(const struct sctp_association *asoc,
1359 __u8 type, __u8 flags, int paylen)
1360{
1361 struct sctp_chunk *retval;
1362 sctp_chunkhdr_t *chunk_hdr;
1363 struct sk_buff *skb;
1364 struct sock *sk;
1365
1366 /* No need to allocate LL here, as this is only a chunk. */
1367 skb = alloc_skb(WORD_ROUND(sizeof(sctp_chunkhdr_t) + paylen),
1368 GFP_ATOMIC);
1369 if (!skb)
1370 goto nodata;
1371
1372 /* Make room for the chunk header. */
1373 chunk_hdr = (sctp_chunkhdr_t *)skb_put(skb, sizeof(sctp_chunkhdr_t));
1374 chunk_hdr->type = type;
1375 chunk_hdr->flags = flags;
1376 chunk_hdr->length = htons(sizeof(sctp_chunkhdr_t));
1377
1378 sk = asoc ? asoc->base.sk : NULL;
1379 retval = sctp_chunkify(skb, asoc, sk);
1380 if (!retval) {
1381 kfree_skb(skb);
1382 goto nodata;
1383 }
1384
1385 retval->chunk_hdr = chunk_hdr;
1386 retval->chunk_end = ((__u8 *)chunk_hdr) + sizeof(struct sctp_chunkhdr);
1387
4cd57c80
VY		 1388 /* Determine if the chunk needs to be authenticated */
1389 if (sctp_auth_send_cid(type, asoc))
1390 retval->auth = 1;
1391
1da177e4
LT		 1392 /* Set the skb to the belonging sock for accounting. */
1393 skb->sk = sk;
1394
1395 return retval;
1396nodata:
1397 return NULL;
1398}
1399
1400
1401/* Release the memory occupied by a chunk. */
1402static void sctp_chunk_destroy(struct sctp_chunk *chunk)
1403{
a08de64d
VY		 1404 BUG_ON(!list_empty(&chunk->list));
1405 list_del_init(&chunk->transmitted_list);
1406
ec494e10
DB		 1407 consume_skb(chunk->skb);
1408 consume_skb(chunk->auth_chunk);
1da177e4
LT		 1409
1410 SCTP_DBG_OBJCNT_DEC(chunk);
1411 kmem_cache_free(sctp_chunk_cachep, chunk);
1412}
1413
1414/* Possibly, free the chunk. */
1415void sctp_chunk_free(struct sctp_chunk *chunk)
1416{
1da177e4
LT		 1417 /* Release our reference on the message tracker. */
1418 if (chunk->msg)
1419 sctp_datamsg_put(chunk->msg);
1420
1421 sctp_chunk_put(chunk);
1422}
1423
1424/* Grab a reference to the chunk. */
1425void sctp_chunk_hold(struct sctp_chunk *ch)
1426{
1427 atomic_inc(&ch->refcnt);
1428}
1429
1430/* Release a reference to the chunk. */
1431void sctp_chunk_put(struct sctp_chunk *ch)
1432{
1433 if (atomic_dec_and_test(&ch->refcnt))
1434 sctp_chunk_destroy(ch);
1435}
1436
1437/* Append bytes to the end of a chunk. Will panic if chunk is not big
1438 * enough.
1439 */
1440void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)
1441{
1442 void *target;
1443 void *padding;
1444 int chunklen = ntohs(chunk->chunk_hdr->length);
8d614ade 1445 int padlen = WORD_ROUND(chunklen) - chunklen;
1da177e4
LT		 1446
1447 padding = skb_put(chunk->skb, padlen);
1448 target = skb_put(chunk->skb, len);
1449
1450 memset(padding, 0, padlen);
1451 memcpy(target, data, len);
1452
1453 /* Adjust the chunk length field. */
1454 chunk->chunk_hdr->length = htons(chunklen + padlen + len);
27a884dc 1455 chunk->chunk_end = skb_tail_pointer(chunk->skb);
1da177e4
LT		 1456
1457 return target;
1458}
1459
5fa782c2
NH		 1460/* Append bytes to the end of a chunk. Returns NULL if there isn't sufficient
1461 * space in the chunk
1462 */
1463void *sctp_addto_chunk_fixed(struct sctp_chunk *chunk,
1464 int len, const void *data)
1465{
2e3219b5 1466 if (skb_tailroom(chunk->skb) >= len)
5fa782c2
NH		 1467 return sctp_addto_chunk(chunk, len, data);
1468 else
1469 return NULL;
1470}
1471
1da177e4
LT		 1472/* Append bytes from user space to the end of a chunk. Will panic if
1473 * chunk is not big enough.
1474 * Returns a kernel err value.
1475 */
1476int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len,
1477 struct iovec *data)
1478{
1479 __u8 *target;
1480 int err = 0;
1481
1482 /* Make room in chunk for data. */
1483 target = skb_put(chunk->skb, len);
1484
1485 /* Copy data (whole iovec) into chunk */
1486 if ((err = memcpy_fromiovecend(target, data, off, len)))
1487 goto out;
1488
1489 /* Adjust the chunk length field. */
1490 chunk->chunk_hdr->length =
1491 htons(ntohs(chunk->chunk_hdr->length) + len);
27a884dc 1492 chunk->chunk_end = skb_tail_pointer(chunk->skb);
1da177e4
LT		 1493
1494out:
1495 return err;
1496}
1497
1498/* Helper function to assign a TSN if needed. This assumes that both
1499 * the data_hdr and association have already been assigned.
1500 */
1501void sctp_chunk_assign_ssn(struct sctp_chunk *chunk)
1502{
ab3e5e7b
VY		 1503 struct sctp_datamsg *msg;
1504 struct sctp_chunk *lchunk;
1505 struct sctp_stream *stream;
1da177e4
LT		 1506 __u16 ssn;
1507 __u16 sid;
1508
1509 if (chunk->has_ssn)
1510 return;
1511
ab3e5e7b
VY		 1512 /* All fragments will be on the same stream */
1513 sid = ntohs(chunk->subh.data_hdr->stream);
1514 stream = &chunk->asoc->ssnmap->out;
1da177e4 1515
ab3e5e7b
VY		 1516 /* Now assign the sequence number to the entire message.
1517 * All fragments must have the same stream sequence number.
1518 */
1519 msg = chunk->msg;
1520 list_for_each_entry(lchunk, &msg->chunks, frag_list) {
1521 if (lchunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
1522 ssn = 0;
1523 } else {
1524 if (lchunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG)
1525 ssn = sctp_ssn_next(stream, sid);
1526 else
1527 ssn = sctp_ssn_peek(stream, sid);
1528 }
1529
1530 lchunk->subh.data_hdr->ssn = htons(ssn);
1531 lchunk->has_ssn = 1;
1532 }
1da177e4
LT		 1533}
1534
1535/* Helper function to assign a TSN if needed. This assumes that both
1536 * the data_hdr and association have already been assigned.
1537 */
1538void sctp_chunk_assign_tsn(struct sctp_chunk *chunk)
1539{
1540 if (!chunk->has_tsn) {
1541 /* This is the last possible instant to
1542 * assign a TSN.
1543 */
1544 chunk->subh.data_hdr->tsn =
1545 htonl(sctp_association_get_next_tsn(chunk->asoc));
1546 chunk->has_tsn = 1;
1547 }
1548}
1549
1550/* Create a CLOSED association to use with an incoming packet. */
1551struct sctp_association *sctp_make_temp_asoc(const struct sctp_endpoint *ep,
3182cd84 1552 struct sctp_chunk *chunk,
dd0fc66f 1553 gfp_t gfp)
1da177e4
LT		 1554{
1555 struct sctp_association *asoc;
1556 struct sk_buff *skb;
1557 sctp_scope_t scope;
1558 struct sctp_af *af;
1559
1560 /* Create the bare association. */
1561 scope = sctp_scope(sctp_source(chunk));
1562 asoc = sctp_association_new(ep, ep->base.sk, scope, gfp);
1563 if (!asoc)
1564 goto nodata;
1565 asoc->temp = 1;
1566 skb = chunk->skb;
1567 /* Create an entry for the source address of the packet. */
eddc9ec5 1568 af = sctp_get_af_specific(ipver2af(ip_hdr(skb)->version));
1da177e4
LT		 1569 if (unlikely(!af))
1570 goto fail;
d55c41b1 1571 af->from_skb(&asoc->c.peer_addr, skb, 1);
1da177e4
LT		 1572nodata:
1573 return asoc;
1574
1575fail:
1576 sctp_association_free(asoc);
1577 return NULL;
1578}
1579
1580/* Build a cookie representing asoc.
1581 * This INCLUDES the param header needed to put the cookie in the INIT ACK.
1582 */
1583static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
1584 const struct sctp_association *asoc,
1585 const struct sctp_chunk *init_chunk,
1586 int *cookie_len,
1587 const __u8 *raw_addrs, int addrs_len)
1588{
1589 sctp_cookie_param_t *retval;
1590 struct sctp_signed_cookie *cookie;
1591 struct scatterlist sg;
1592 int headersize, bodysize;
1da177e4 1593
9834a2bb
VY		 1594 /* Header size is static data prior to the actual cookie, including
1595 * any padding.
1596 */
d808ad9a
YH		 1597 headersize = sizeof(sctp_paramhdr_t) +
1598 (sizeof(struct sctp_signed_cookie) -
9834a2bb 1599 sizeof(struct sctp_cookie));
1da177e4
LT		 1600 bodysize = sizeof(struct sctp_cookie)
1601 + ntohs(init_chunk->chunk_hdr->length) + addrs_len;
1602
1603 /* Pad out the cookie to a multiple to make the signature
1604 * functions simpler to write.
1605 */
1606 if (bodysize % SCTP_COOKIE_MULTIPLE)
1607 bodysize += SCTP_COOKIE_MULTIPLE
1608 - (bodysize % SCTP_COOKIE_MULTIPLE);
1609 *cookie_len = headersize + bodysize;
1610
1da177e4
LT		 1611 /* Clear this memory since we are sending this data structure
1612 * out on the network.
1613 */
af997d8c
ACM		 1614 retval = kzalloc(*cookie_len, GFP_ATOMIC);
1615 if (!retval)
1616 goto nodata;
1617
1da177e4
LT		 1618 cookie = (struct sctp_signed_cookie *) retval->body;
1619
1620 /* Set up the parameter header. */
1621 retval->p.type = SCTP_PARAM_STATE_COOKIE;
1622 retval->p.length = htons(*cookie_len);
1623
1624 /* Copy the cookie part of the association itself. */
1625 cookie->c = asoc->c;
1626 /* Save the raw address list length in the cookie. */
1627 cookie->c.raw_addr_list_len = addrs_len;
1628
1629 /* Remember PR-SCTP capability. */
1630 cookie->c.prsctp_capable = asoc->peer.prsctp_capable;
1631
0f3fffd8
ISJ		 1632 /* Save adaptation indication in the cookie. */
1633 cookie->c.adaptation_ind = asoc->peer.adaptation_ind;
1da177e4
LT		 1634
1635 /* Set an expiration time for the cookie. */
1636 do_gettimeofday(&cookie->c.expiration);
1637 TIMEVAL_ADD(asoc->cookie_life, cookie->c.expiration);
1638
1639 /* Copy the peer's init packet. */
1640 memcpy(&cookie->c.peer_init[0], init_chunk->chunk_hdr,
1641 ntohs(init_chunk->chunk_hdr->length));
1642
1643 /* Copy the raw local address list of the association. */
1644 memcpy((__u8 *)&cookie->c.peer_init[0] +
1645 ntohs(init_chunk->chunk_hdr->length), raw_addrs, addrs_len);
1646
d808ad9a 1647 if (sctp_sk(ep->base.sk)->hmac) {
1b489e11
HX		 1648 struct hash_desc desc;
1649
1da177e4 1650 /* Sign the message. */
68e3f5dd 1651 sg_init_one(&sg, &cookie->c, bodysize);
d808ad9a
YH		 1652 desc.tfm = sctp_sk(ep->base.sk)->hmac;
1653 desc.flags = 0;
1da177e4 1654
570617e7
DB		 1655 if (crypto_hash_setkey(desc.tfm, ep->secret_key,
1656 sizeof(ep->secret_key)) ||
1b489e11
HX		 1657 crypto_hash_digest(&desc, &sg, bodysize, cookie->signature))
1658 goto free_cookie;
1da177e4
LT		 1659 }
1660
1da177e4 1661 return retval;
1b489e11
HX		 1662
1663free_cookie:
1664 kfree(retval);
1665nodata:
1666 *cookie_len = 0;
1667 return NULL;
1da177e4
LT		 1668}
1669
1670/* Unpack the cookie from COOKIE ECHO chunk, recreating the association. */
1671struct sctp_association *sctp_unpack_cookie(
1672 const struct sctp_endpoint *ep,
1673 const struct sctp_association *asoc,
dd0fc66f 1674 struct sctp_chunk *chunk, gfp_t gfp,
1da177e4
LT		 1675 int *error, struct sctp_chunk **errp)
1676{
1677 struct sctp_association *retval = NULL;
1678 struct sctp_signed_cookie *cookie;
1679 struct sctp_cookie *bear_cookie;
1680 int headersize, bodysize, fixed_size;
313e7b4d 1681 __u8 *digest = ep->digest;
1da177e4 1682 struct scatterlist sg;
570617e7 1683 unsigned int len;
1da177e4
LT		 1684 sctp_scope_t scope;
1685 struct sk_buff *skb = chunk->skb;
a61bbcf2 1686 struct timeval tv;
1b489e11 1687 struct hash_desc desc;
1da177e4 1688
9834a2bb
VY		 1689 /* Header size is static data prior to the actual cookie, including
1690 * any padding.
1691 */
1692 headersize = sizeof(sctp_chunkhdr_t) +
d808ad9a 1693 (sizeof(struct sctp_signed_cookie) -
9834a2bb 1694 sizeof(struct sctp_cookie));
1da177e4
LT		 1695 bodysize = ntohs(chunk->chunk_hdr->length) - headersize;
1696 fixed_size = headersize + sizeof(struct sctp_cookie);
1697
1698 /* Verify that the chunk looks like it even has a cookie.
1699 * There must be enough room for our cookie and our peer's
1700 * INIT chunk.
1701 */
1702 len = ntohs(chunk->chunk_hdr->length);
1703 if (len < fixed_size + sizeof(struct sctp_chunkhdr))
1704 goto malformed;
1705
1706 /* Verify that the cookie has been padded out. */
1707 if (bodysize % SCTP_COOKIE_MULTIPLE)
1708 goto malformed;
1709
1710 /* Process the cookie. */
1711 cookie = chunk->subh.cookie_hdr;
1712 bear_cookie = &cookie->c;
1713
1714 if (!sctp_sk(ep->base.sk)->hmac)
1715 goto no_hmac;
1716
1717 /* Check the signature. */
68e3f5dd 1718 sg_init_one(&sg, bear_cookie, bodysize);
1b489e11
HX		 1719 desc.tfm = sctp_sk(ep->base.sk)->hmac;
1720 desc.flags = 0;
1da177e4 1721
8ca84481 1722 memset(digest, 0x00, SCTP_SIGNATURE_SIZE);
570617e7
DB		 1723 if (crypto_hash_setkey(desc.tfm, ep->secret_key,
1724 sizeof(ep->secret_key)) ||
1b489e11
HX		 1725 crypto_hash_digest(&desc, &sg, bodysize, digest)) {
1726 *error = -SCTP_IERROR_NOMEM;
1727 goto fail;
1728 }
1da177e4
LT		 1729
1730 if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
570617e7
DB		 1731 *error = -SCTP_IERROR_BAD_SIG;
1732 goto fail;
1da177e4
LT		 1733 }
1734
1735no_hmac:
1736 /* IG Section 2.35.2:
1737 * 3) Compare the port numbers and the verification tag contained
1738 * within the COOKIE ECHO chunk to the actual port numbers and the
1739 * verification tag within the SCTP common header of the received
1740 * packet. If these values do not match the packet MUST be silently
1741 * discarded,
1742 */
1743 if (ntohl(chunk->sctp_hdr->vtag) != bear_cookie->my_vtag) {
1744 *error = -SCTP_IERROR_BAD_TAG;
1745 goto fail;
1746 }
1747
9b1dfad0 1748 if (chunk->sctp_hdr->source != bear_cookie->peer_addr.v4.sin_port ||
1da177e4
LT		 1749 ntohs(chunk->sctp_hdr->dest) != bear_cookie->my_port) {
1750 *error = -SCTP_IERROR_BAD_PORTS;
1751 goto fail;
1752 }
1753
1754 /* Check to see if the cookie is stale. If there is already
1755 * an association, there is no need to check cookie's expiration
1756 * for init collision case of lost COOKIE ACK.
f236218b
VY		 1757 * If skb has been timestamped, then use the stamp, otherwise
1758 * use current time. This introduces a small possibility that
1759 * that a cookie may be considered expired, but his would only slow
1760 * down the new association establishment instead of every packet.
1da177e4 1761 */
f236218b
VY		 1762 if (sock_flag(ep->base.sk, SOCK_TIMESTAMP))
1763 skb_get_timestamp(skb, &tv);
1764 else
1765 do_gettimeofday(&tv);
1766
a61bbcf2 1767 if (!asoc && tv_lt(bear_cookie->expiration, tv)) {
1da177e4
LT		 1768 /*
1769 * Section 3.3.10.3 Stale Cookie Error (3)
1770 *
1771 * Cause of error
1772 * ---------------
1773 * Stale Cookie Error: Indicates the receipt of a valid State
1774 * Cookie that has expired.
1775 */
1776 len = ntohs(chunk->chunk_hdr->length);
1777 *errp = sctp_make_op_error_space(asoc, chunk, len);
1778 if (*errp) {
a61bbcf2 1779 suseconds_t usecs = (tv.tv_sec -
1da177e4 1780 bear_cookie->expiration.tv_sec) * 1000000L +
a61bbcf2 1781 tv.tv_usec - bear_cookie->expiration.tv_usec;
34bcca28 1782 __be32 n = htonl(usecs);
1da177e4 1783
1da177e4 1784 sctp_init_cause(*errp, SCTP_ERROR_STALE_COOKIE,
00f1c2df
WY		 1785 sizeof(n));
1786 sctp_addto_chunk(*errp, sizeof(n), &n);
1da177e4
LT		 1787 *error = -SCTP_IERROR_STALE_COOKIE;
1788 } else
1789 *error = -SCTP_IERROR_NOMEM;
1790
1791 goto fail;
1792 }
1793
1794 /* Make a new base association. */
1795 scope = sctp_scope(sctp_source(chunk));
1796 retval = sctp_association_new(ep, ep->base.sk, scope, gfp);
1797 if (!retval) {
1798 *error = -SCTP_IERROR_NOMEM;
1799 goto fail;
1800 }
1801
1802 /* Set up our peer's port number. */
1803 retval->peer.port = ntohs(chunk->sctp_hdr->source);
1804
1805 /* Populate the association from the cookie. */
1806 memcpy(&retval->c, bear_cookie, sizeof(*bear_cookie));
1807
1808 if (sctp_assoc_set_bind_addr_from_cookie(retval, bear_cookie,
1809 GFP_ATOMIC) < 0) {
1810 *error = -SCTP_IERROR_NOMEM;
1811 goto fail;
1812 }
1813
1814 /* Also, add the destination address. */
1815 if (list_empty(&retval->base.bind_addr.address_list)) {
f57d96b2
VY		 1816 sctp_add_bind_addr(&retval->base.bind_addr, &chunk->dest,
1817 SCTP_ADDR_SRC, GFP_ATOMIC);
1da177e4
LT		 1818 }
1819
1820 retval->next_tsn = retval->c.initial_tsn;
1821 retval->ctsn_ack_point = retval->next_tsn - 1;
1822 retval->addip_serial = retval->c.initial_tsn;
1823 retval->adv_peer_ack_point = retval->ctsn_ack_point;
1824 retval->peer.prsctp_capable = retval->c.prsctp_capable;
0f3fffd8 1825 retval->peer.adaptation_ind = retval->c.adaptation_ind;
1da177e4
LT		 1826
1827 /* The INIT stuff will be done by the side effects. */
1828 return retval;
1829
1830fail:
1831 if (retval)
1832 sctp_association_free(retval);
1833
1834 return NULL;
1835
1836malformed:
1837 /* Yikes! The packet is either corrupt or deliberately
1838 * malformed.
1839 */
1840 *error = -SCTP_IERROR_MALFORMED;
1841 goto fail;
1842}
1843
1844/********************************************************************
1845 * 3rd Level Abstractions
1846 ********************************************************************/
1847
1848struct __sctp_missing {
9f81bcd9
AV		 1849 __be32 num_missing;
1850 __be16 type;
bc10502d 1851} __packed;
1da177e4
LT		 1852
1853/*
1854 * Report a missing mandatory parameter.
1855 */
1856static int sctp_process_missing_param(const struct sctp_association *asoc,
1857 sctp_param_t paramtype,
1858 struct sctp_chunk *chunk,
1859 struct sctp_chunk **errp)
1860{
1861 struct __sctp_missing report;
1862 __u16 len;
1863
1864 len = WORD_ROUND(sizeof(report));
1865
1866 /* Make an ERROR chunk, preparing enough room for
1867 * returning multiple unknown parameters.
1868 */
1869 if (!*errp)
1870 *errp = sctp_make_op_error_space(asoc, chunk, len);
1871
1872 if (*errp) {
1873 report.num_missing = htonl(1);
1874 report.type = paramtype;
ebdfcad4 1875 sctp_init_cause(*errp, SCTP_ERROR_MISS_PARAM,
00f1c2df
WY		 1876 sizeof(report));
1877 sctp_addto_chunk(*errp, sizeof(report), &report);
1da177e4
LT		 1878 }
1879
1880 /* Stop processing this chunk. */
1881 return 0;
1882}
1883
1884/* Report an Invalid Mandatory Parameter. */
1885static int sctp_process_inv_mandatory(const struct sctp_association *asoc,
1886 struct sctp_chunk *chunk,
1887 struct sctp_chunk **errp)
1888{
1889 /* Invalid Mandatory Parameter Error has no payload. */
1890
1891 if (!*errp)
1892 *errp = sctp_make_op_error_space(asoc, chunk, 0);
1893
1894 if (*errp)
00f1c2df 1895 sctp_init_cause(*errp, SCTP_ERROR_INV_PARAM, 0);
1da177e4
LT		 1896
1897 /* Stop processing this chunk. */
1898 return 0;
1899}
1900
1901static int sctp_process_inv_paramlength(const struct sctp_association *asoc,
1902 struct sctp_paramhdr *param,
1903 const struct sctp_chunk *chunk,
1904 struct sctp_chunk **errp)
1905{
7ab90804
VY		 1906 /* This is a fatal error. Any accumulated non-fatal errors are
1907 * not reported.
1908 */
1909 if (*errp)
1910 sctp_chunk_free(*errp);
1911
1da177e4 1912 /* Create an error chunk and fill it in with our payload. */
ba016670 1913 *errp = sctp_make_violation_paramlen(asoc, chunk, param);
1da177e4
LT		 1914
1915 return 0;
1916}
1917
1918
1919/* Do not attempt to handle the HOST_NAME parm. However, do
1920 * send back an indicator to the peer.
1921 */
1922static int sctp_process_hn_param(const struct sctp_association *asoc,
1923 union sctp_params param,
1924 struct sctp_chunk *chunk,
1925 struct sctp_chunk **errp)
1926{
1927 __u16 len = ntohs(param.p->length);
1928
7ab90804
VY		 1929 /* Processing of the HOST_NAME parameter will generate an
1930 * ABORT. If we've accumulated any non-fatal errors, they
1931 * would be unrecognized parameters and we should not include
1932 * them in the ABORT.
1933 */
1934 if (*errp)
1935 sctp_chunk_free(*errp);
1936
1937 *errp = sctp_make_op_error_space(asoc, chunk, len);
1da177e4 1938
00f1c2df
WY		 1939 if (*errp) {
1940 sctp_init_cause(*errp, SCTP_ERROR_DNS_FAILED, len);
1941 sctp_addto_chunk(*errp, len, param.v);
1942 }
1da177e4
LT		 1943
1944 /* Stop processing this chunk. */
1945 return 0;
1946}
1947
f53b5b09 1948static int sctp_verify_ext_param(struct net *net, union sctp_params param)
d6701191
VY		 1949{
1950 __u16 num_ext = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
1951 int have_auth = 0;
1952 int have_asconf = 0;
1953 int i;
1954
1955 for (i = 0; i < num_ext; i++) {
1956 switch (param.ext->chunks[i]) {
1957 case SCTP_CID_AUTH:
1958 have_auth = 1;
1959 break;
1960 case SCTP_CID_ASCONF:
1961 case SCTP_CID_ASCONF_ACK:
1962 have_asconf = 1;
1963 break;
1964 }
1965 }
1966
1967 /* ADD-IP Security: The draft requires us to ABORT or ignore the
1968 * INIT/INIT-ACK if ADD-IP is listed, but AUTH is not. Do this
1969 * only if ADD-IP is turned on and we are not backward-compatible
1970 * mode.
1971 */
e1fc3b14 1972 if (net->sctp.addip_noauth)
d6701191
VY		 1973 return 1;
1974
e1fc3b14 1975 if (net->sctp.addip_enable && !have_auth && have_asconf)
d6701191
VY		 1976 return 0;
1977
1978 return 1;
1979}
1980
131a47e3
VY		 1981static void sctp_process_ext_param(struct sctp_association *asoc,
1982 union sctp_params param)
1983{
e1fc3b14 1984 struct net *net = sock_net(asoc->base.sk);
131a47e3
VY		 1985 __u16 num_ext = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
1986 int i;
1987
1988 for (i = 0; i < num_ext; i++) {
1989 switch (param.ext->chunks[i]) {
1990 case SCTP_CID_FWD_TSN:
e1fc3b14 1991 if (net->sctp.prsctp_enable &&
131a47e3
VY		 1992 !asoc->peer.prsctp_capable)
1993 asoc->peer.prsctp_capable = 1;
1994 break;
730fc3d0
VY		 1995 case SCTP_CID_AUTH:
1996 /* if the peer reports AUTH, assume that he
1997 * supports AUTH.
1998 */
e5eae4a0 1999 if (asoc->ep->auth_enable)
0ef46e28 2000 asoc->peer.auth_capable = 1;
730fc3d0 2001 break;
131a47e3
VY		 2002 case SCTP_CID_ASCONF:
2003 case SCTP_CID_ASCONF_ACK:
e1fc3b14 2004 if (net->sctp.addip_enable)
0ef46e28 2005 asoc->peer.asconf_capable = 1;
6b2f9cb6 2006 break;
131a47e3
VY		 2007 default:
2008 break;
2009 }
2010 }
2011}
2012
1da177e4
LT		 2013/* RFC 3.2.1 & the Implementers Guide 2.2.
2014 *
2015 * The Parameter Types are encoded such that the
2016 * highest-order two bits specify the action that must be
2017 * taken if the processing endpoint does not recognize the
2018 * Parameter Type.
2019 *
7ab90804
VY		 2020 * 00 - Stop processing this parameter; do not process any further
2021 * parameters within this chunk
1da177e4 2022 *
7ab90804
VY		 2023 * 01 - Stop processing this parameter, do not process any further
2024 * parameters within this chunk, and report the unrecognized
2025 * parameter in an 'Unrecognized Parameter' ERROR chunk.
1da177e4
LT		 2026 *
2027 * 10 - Skip this parameter and continue processing.
2028 *
2029 * 11 - Skip this parameter and continue processing but
2030 * report the unrecognized parameter in an
7ab90804 2031 * 'Unrecognized Parameter' ERROR chunk.
1da177e4
LT		 2032 *
2033 * Return value:
7ab90804
VY		 2034 * SCTP_IERROR_NO_ERROR - continue with the chunk
2035 * SCTP_IERROR_ERROR - stop and report an error.
2036 * SCTP_IERROR_NOMEME - out of memory.
1da177e4 2037 */
7ab90804
VY		 2038static sctp_ierror_t sctp_process_unk_param(const struct sctp_association *asoc,
2039 union sctp_params param,
2040 struct sctp_chunk *chunk,
2041 struct sctp_chunk **errp)
1da177e4 2042{
7ab90804 2043 int retval = SCTP_IERROR_NO_ERROR;
1da177e4
LT		 2044
2045 switch (param.p->type & SCTP_PARAM_ACTION_MASK) {
2046 case SCTP_PARAM_ACTION_DISCARD:
7ab90804 2047 retval = SCTP_IERROR_ERROR;
1da177e4
LT		 2048 break;
2049 case SCTP_PARAM_ACTION_SKIP:
2050 break;
7ab90804
VY		 2051 case SCTP_PARAM_ACTION_DISCARD_ERR:
2052 retval = SCTP_IERROR_ERROR;
2053 /* Fall through */
1da177e4
LT		 2054 case SCTP_PARAM_ACTION_SKIP_ERR:
2055 /* Make an ERROR chunk, preparing enough room for
2056 * returning multiple unknown parameters.
2057 */
2058 if (NULL == *errp)
5fa782c2 2059 *errp = sctp_make_op_error_fixed(asoc, chunk);
1da177e4
LT		 2060
2061 if (*errp) {
2205a6ea
JB		 2062 if (!sctp_init_cause_fixed(*errp, SCTP_ERROR_UNKNOWN_PARAM,
2063 WORD_ROUND(ntohs(param.p->length))))
2064 sctp_addto_chunk_fixed(*errp,
2065 WORD_ROUND(ntohs(param.p->length)),
2066 param.v);
1da177e4
LT		 2067 } else {
2068 /* If there is no memory for generating the ERROR
2069 * report as specified, an ABORT will be triggered
2070 * to the peer and the association won't be
2071 * established.
2072 */
7ab90804 2073 retval = SCTP_IERROR_NOMEM;
1da177e4 2074 }
1da177e4
LT		 2075 break;
2076 default:
2077 break;
2078 }
2079
2080 return retval;
2081}
2082
7ab90804 2083/* Verify variable length parameters
1da177e4 2084 * Return values:
7ab90804
VY		 2085 * SCTP_IERROR_ABORT - trigger an ABORT
2086 * SCTP_IERROR_NOMEM - out of memory (abort)
2087 * SCTP_IERROR_ERROR - stop processing, trigger an ERROR
2088 * SCTP_IERROR_NO_ERROR - continue with the chunk
1da177e4 2089 */
f53b5b09 2090static sctp_ierror_t sctp_verify_param(struct net *net,
e5eae4a0 2091 const struct sctp_endpoint *ep,
f53b5b09 2092 const struct sctp_association *asoc,
7ab90804
VY		 2093 union sctp_params param,
2094 sctp_cid_t cid,
2095 struct sctp_chunk *chunk,
2096 struct sctp_chunk **err_chunk)
1da177e4 2097{
72da7b38 2098 struct sctp_hmac_algo_param *hmacs;
7ab90804 2099 int retval = SCTP_IERROR_NO_ERROR;
72da7b38
WY		 2100 __u16 n_elt, id = 0;
2101 int i;
1da177e4
LT		 2102
2103 /* FIXME - This routine is not looking at each parameter per the
2104 * chunk type, i.e., unrecognized parameters should be further
2105 * identified based on the chunk id.
2106 */
2107
2108 switch (param.p->type) {
2109 case SCTP_PARAM_IPV4_ADDRESS:
2110 case SCTP_PARAM_IPV6_ADDRESS:
2111 case SCTP_PARAM_COOKIE_PRESERVATIVE:
2112 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
2113 case SCTP_PARAM_STATE_COOKIE:
2114 case SCTP_PARAM_HEARTBEAT_INFO:
2115 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
2116 case SCTP_PARAM_ECN_CAPABLE:
0f3fffd8 2117 case SCTP_PARAM_ADAPTATION_LAYER_IND:
d6701191
VY		 2118 break;
2119
131a47e3 2120 case SCTP_PARAM_SUPPORTED_EXT:
f53b5b09 2121 if (!sctp_verify_ext_param(net, param))
d6701191 2122 return SCTP_IERROR_ABORT;
1da177e4
LT		 2123 break;
2124
d6de3097 2125 case SCTP_PARAM_SET_PRIMARY:
e1fc3b14 2126 if (net->sctp.addip_enable)
d6de3097
VY		 2127 break;
2128 goto fallthrough;
2129
1da177e4
LT		 2130 case SCTP_PARAM_HOST_NAME_ADDRESS:
2131 /* Tell the peer, we won't support this param. */
7ab90804
VY		 2132 sctp_process_hn_param(asoc, param, chunk, err_chunk);
2133 retval = SCTP_IERROR_ABORT;
2134 break;
131a47e3 2135
1da177e4 2136 case SCTP_PARAM_FWD_TSN_SUPPORT:
e1fc3b14 2137 if (net->sctp.prsctp_enable)
1da177e4 2138 break;
730fc3d0
VY		 2139 goto fallthrough;
2140
2141 case SCTP_PARAM_RANDOM:
e5eae4a0 2142 if (!ep->auth_enable)
730fc3d0
VY		 2143 goto fallthrough;
2144
2145 /* SCTP-AUTH: Secion 6.1
2146 * If the random number is not 32 byte long the association
2147 * MUST be aborted. The ABORT chunk SHOULD contain the error
2148 * cause 'Protocol Violation'.
2149 */
2150 if (SCTP_AUTH_RANDOM_LENGTH !=
7ab90804
VY		 2151 ntohs(param.p->length) - sizeof(sctp_paramhdr_t)) {
2152 sctp_process_inv_paramlength(asoc, param.p,
730fc3d0 2153 chunk, err_chunk);
7ab90804
VY		 2154 retval = SCTP_IERROR_ABORT;
2155 }
730fc3d0
VY		 2156 break;
2157
2158 case SCTP_PARAM_CHUNKS:
e5eae4a0 2159 if (!ep->auth_enable)
730fc3d0
VY		 2160 goto fallthrough;
2161
2162 /* SCTP-AUTH: Section 3.2
2163 * The CHUNKS parameter MUST be included once in the INIT or
2164 * INIT-ACK chunk if the sender wants to receive authenticated
2165 * chunks. Its maximum length is 260 bytes.
2166 */
7ab90804
VY		 2167 if (260 < ntohs(param.p->length)) {
2168 sctp_process_inv_paramlength(asoc, param.p,
2169 chunk, err_chunk);
2170 retval = SCTP_IERROR_ABORT;
2171 }
730fc3d0
VY		 2172 break;
2173
2174 case SCTP_PARAM_HMAC_ALGO:
e5eae4a0 2175 if (!ep->auth_enable)
72da7b38
WY		 2176 goto fallthrough;
2177
2178 hmacs = (struct sctp_hmac_algo_param *)param.p;
2179 n_elt = (ntohs(param.p->length) - sizeof(sctp_paramhdr_t)) >> 1;
2180
2181 /* SCTP-AUTH: Section 6.1
2182 * The HMAC algorithm based on SHA-1 MUST be supported and
2183 * included in the HMAC-ALGO parameter.
2184 */
2185 for (i = 0; i < n_elt; i++) {
2186 id = ntohs(hmacs->hmac_ids[i]);
2187
2188 if (id == SCTP_AUTH_HMAC_ID_SHA1)
2189 break;
2190 }
2191
2192 if (id != SCTP_AUTH_HMAC_ID_SHA1) {
2193 sctp_process_inv_paramlength(asoc, param.p, chunk,
2194 err_chunk);
2195 retval = SCTP_IERROR_ABORT;
2196 }
2197 break;
730fc3d0 2198fallthrough:
1da177e4
LT		 2199 default:
2200 SCTP_DEBUG_PRINTK("Unrecognized param: %d for chunk %d.\n",
2201 ntohs(param.p->type), cid);
7ab90804 2202 retval = sctp_process_unk_param(asoc, param, chunk, err_chunk);
1da177e4
LT		 2203 break;
2204 }
2205 return retval;
2206}
2207
2208/* Verify the INIT packet before we process it. */
e5eae4a0
VY		 2209int sctp_verify_init(struct net *net, const struct sctp_endpoint *ep,
2210 const struct sctp_association *asoc, sctp_cid_t cid,
2211 sctp_init_chunk_t *peer_init, struct sctp_chunk *chunk,
1da177e4
LT		 2212 struct sctp_chunk **errp)
2213{
2214 union sctp_params param;
2215 int has_cookie = 0;
7ab90804 2216 int result;
1da177e4
LT		 2217
2218 /* Verify stream values are non-zero. */
2219 if ((0 == peer_init->init_hdr.num_outbound_streams) ||
d023f629
VY		 2220 (0 == peer_init->init_hdr.num_inbound_streams) ||
2221 (0 == peer_init->init_hdr.init_tag) ||
2222 (SCTP_DEFAULT_MINWINDOW > ntohl(peer_init->init_hdr.a_rwnd))) {
1da177e4 2223
7ab90804 2224 return sctp_process_inv_mandatory(asoc, chunk, errp);
1da177e4
LT		 2225 }
2226
2227 /* Check for missing mandatory parameters. */
2228 sctp_walk_params(param, peer_init, init_hdr.params) {
2229
2230 if (SCTP_PARAM_STATE_COOKIE == param.p->type)
2231 has_cookie = 1;
2232
2233 } /* for (loop through all parameters) */
2234
2235 /* There is a possibility that a parameter length was bad and
2236 * in that case we would have stoped walking the parameters.
2237 * The current param.p would point at the bad one.
2238 * Current consensus on the mailing list is to generate a PROTOCOL
2239 * VIOLATION error. We build the ERROR chunk here and let the normal
2240 * error handling code build and send the packet.
2241 */
7ab90804
VY		 2242 if (param.v != (void*)chunk->chunk_end)
2243 return sctp_process_inv_paramlength(asoc, param.p, chunk, errp);
1da177e4
LT		 2244
2245 /* The only missing mandatory param possible today is
2246 * the state cookie for an INIT-ACK chunk.
2247 */
7ab90804
VY		 2248 if ((SCTP_CID_INIT_ACK == cid) && !has_cookie)
2249 return sctp_process_missing_param(asoc, SCTP_PARAM_STATE_COOKIE,
2250 chunk, errp);
1da177e4 2251
7ab90804 2252 /* Verify all the variable length parameters */
1da177e4 2253 sctp_walk_params(param, peer_init, init_hdr.params) {
e5eae4a0
VY		 2254 result = sctp_verify_param(net, ep, asoc, param, cid,
2255 chunk, errp);
7ab90804
VY		 2256 switch (result) {
2257 case SCTP_IERROR_ABORT:
2258 case SCTP_IERROR_NOMEM:
1da177e4 2259 return 0;
7ab90804 2260 case SCTP_IERROR_ERROR:
1da177e4 2261 return 1;
7ab90804
VY		 2262 case SCTP_IERROR_NO_ERROR:
2263 default:
2264 break;
1da177e4
LT		 2265 }
2266
2267 } /* for (loop through all parameters) */
2268
2269 return 1;
2270}
2271
2272/* Unpack the parameters in an INIT packet into an association.
2273 * Returns 0 on failure, else success.
2274 * FIXME: This is an association method.
2275 */
de6becdc 2276int sctp_process_init(struct sctp_association *asoc, struct sctp_chunk *chunk,
1da177e4 2277 const union sctp_addr *peer_addr,
dd0fc66f 2278 sctp_init_chunk_t *peer_init, gfp_t gfp)
1da177e4 2279{
e1fc3b14 2280 struct net *net = sock_net(asoc->base.sk);
1da177e4
LT		 2281 union sctp_params param;
2282 struct sctp_transport *transport;
2283 struct list_head *pos, *temp;
de6becdc
WY		 2284 struct sctp_af *af;
2285 union sctp_addr addr;
1da177e4 2286 char *cookie;
de6becdc 2287 int src_match = 0;
1da177e4
LT		 2288
2289 /* We must include the address that the INIT packet came from.
2290 * This is the only address that matters for an INIT packet.
2291 * When processing a COOKIE ECHO, we retrieve the from address
2292 * of the INIT from the cookie.
2293 */
2294
2295 /* This implementation defaults to making the first transport
2296 * added as the primary transport. The source address seems to
2297 * be a a better choice than any of the embedded addresses.
2298 */
de6becdc
WY		 2299 if(!sctp_assoc_add_peer(asoc, peer_addr, gfp, SCTP_ACTIVE))
2300 goto nomem;
2301
2302 if (sctp_cmp_addr_exact(sctp_source(chunk), peer_addr))
2303 src_match = 1;
1da177e4
LT		 2304
2305 /* Process the initialization parameters. */
1da177e4 2306 sctp_walk_params(param, peer_init, init_hdr.params) {
de6becdc
WY		 2307 if (!src_match && (param.p->type == SCTP_PARAM_IPV4_ADDRESS ||
2308 param.p->type == SCTP_PARAM_IPV6_ADDRESS)) {
2309 af = sctp_get_af_specific(param_type2af(param.p->type));
2310 af->from_addr_param(&addr, param.addr,
2311 chunk->sctp_hdr->source, 0);
2312 if (sctp_cmp_addr_exact(sctp_source(chunk), &addr))
2313 src_match = 1;
2314 }
1da177e4
LT		 2315
2316 if (!sctp_process_param(asoc, param, peer_addr, gfp))
d808ad9a 2317 goto clean_up;
1da177e4
LT		 2318 }
2319
de6becdc
WY		 2320 /* source address of chunk may not match any valid address */
2321 if (!src_match)
2322 goto clean_up;
2323
730fc3d0
VY		 2324 /* AUTH: After processing the parameters, make sure that we
2325 * have all the required info to potentially do authentications.
2326 */
2327 if (asoc->peer.auth_capable && (!asoc->peer.peer_random ||
2328 !asoc->peer.peer_hmacs))
2329 asoc->peer.auth_capable = 0;
2330
d6701191
VY		 2331 /* In a non-backward compatible mode, if the peer claims
2332 * support for ADD-IP but not AUTH, the ADD-IP spec states
2333 * that we MUST ABORT the association. Section 6. The section
2334 * also give us an option to silently ignore the packet, which
2335 * is what we'll do here.
6b2f9cb6 2336 */
e1fc3b14 2337 if (!net->sctp.addip_noauth &&
73d9c4fd 2338 (asoc->peer.asconf_capable && !asoc->peer.auth_capable)) {
6b2f9cb6
VY		 2339 asoc->peer.addip_disabled_mask |= (SCTP_PARAM_ADD_IP |
2340 SCTP_PARAM_DEL_IP |
2341 SCTP_PARAM_SET_PRIMARY);
88799fe5 2342 asoc->peer.asconf_capable = 0;
d6701191 2343 goto clean_up;
6b2f9cb6
VY		 2344 }
2345
3f7a87d2
FF		 2346 /* Walk list of transports, removing transports in the UNKNOWN state. */
2347 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
2348 transport = list_entry(pos, struct sctp_transport, transports);
2349 if (transport->state == SCTP_UNKNOWN) {
2350 sctp_assoc_rm_peer(asoc, transport);
2351 }
2352 }
2353
1da177e4
LT		 2354 /* The fixed INIT headers are always in network byte
2355 * order.
2356 */
2357 asoc->peer.i.init_tag =
2358 ntohl(peer_init->init_hdr.init_tag);
2359 asoc->peer.i.a_rwnd =
2360 ntohl(peer_init->init_hdr.a_rwnd);
2361 asoc->peer.i.num_outbound_streams =
2362 ntohs(peer_init->init_hdr.num_outbound_streams);
2363 asoc->peer.i.num_inbound_streams =
2364 ntohs(peer_init->init_hdr.num_inbound_streams);
2365 asoc->peer.i.initial_tsn =
2366 ntohl(peer_init->init_hdr.initial_tsn);
2367
2368 /* Apply the upper bounds for output streams based on peer's
2369 * number of inbound streams.
2370 */
2371 if (asoc->c.sinit_num_ostreams >
2372 ntohs(peer_init->init_hdr.num_inbound_streams)) {
2373 asoc->c.sinit_num_ostreams =
2374 ntohs(peer_init->init_hdr.num_inbound_streams);
2375 }
2376
2377 if (asoc->c.sinit_max_instreams >
2378 ntohs(peer_init->init_hdr.num_outbound_streams)) {
2379 asoc->c.sinit_max_instreams =
2380 ntohs(peer_init->init_hdr.num_outbound_streams);
2381 }
2382
2383 /* Copy Initiation tag from INIT to VT_peer in cookie. */
2384 asoc->c.peer_vtag = asoc->peer.i.init_tag;
2385
2386 /* Peer Rwnd : Current calculated value of the peer's rwnd. */
2387 asoc->peer.rwnd = asoc->peer.i.a_rwnd;
2388
2389 /* Copy cookie in case we need to resend COOKIE-ECHO. */
2390 cookie = asoc->peer.cookie;
2391 if (cookie) {
af997d8c 2392 asoc->peer.cookie = kmemdup(cookie, asoc->peer.cookie_len, gfp);
1da177e4
LT		 2393 if (!asoc->peer.cookie)
2394 goto clean_up;
1da177e4
LT		 2395 }
2396
2397 /* RFC 2960 7.2.1 The initial value of ssthresh MAY be arbitrarily
2398 * high (for example, implementations MAY use the size of the receiver
2399 * advertised window).
2400 */
9dbc15f0
RD		 2401 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
2402 transports) {
1da177e4
LT		 2403 transport->ssthresh = asoc->peer.i.a_rwnd;
2404 }
2405
2406 /* Set up the TSN tracking pieces. */
8e1ee18c
VY		 2407 if (!sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
2408 asoc->peer.i.initial_tsn, gfp))
2409 goto clean_up;
1da177e4
LT		 2410
2411 /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
2412 *
2413 * The stream sequence number in all the streams shall start
2414 * from 0 when the association is established. Also, when the
2415 * stream sequence number reaches the value 65535 the next
2416 * stream sequence number shall be set to 0.
2417 */
2418
3f7a87d2 2419 /* Allocate storage for the negotiated streams if it is not a temporary
d808ad9a 2420 * association.
1da177e4
LT		 2421 */
2422 if (!asoc->temp) {
1da177e4
LT		 2423 int error;
2424
2425 asoc->ssnmap = sctp_ssnmap_new(asoc->c.sinit_max_instreams,
2426 asoc->c.sinit_num_ostreams, gfp);
2427 if (!asoc->ssnmap)
2428 goto clean_up;
2429
07d93967
VY		 2430 error = sctp_assoc_set_id(asoc, gfp);
2431 if (error)
1da177e4 2432 goto clean_up;
1da177e4
LT		 2433 }
2434
2435 /* ADDIP Section 4.1 ASCONF Chunk Procedures
2436 *
2437 * When an endpoint has an ASCONF signaled change to be sent to the
2438 * remote endpoint it should do the following:
2439 * ...
2440 * A2) A serial number should be assigned to the Chunk. The serial
2441 * number should be a monotonically increasing number. All serial
2442 * numbers are defined to be initialized at the start of the
2443 * association to the same value as the Initial TSN.
2444 */
2445 asoc->peer.addip_serial = asoc->peer.i.initial_tsn - 1;
2446 return 1;
2447
2448clean_up:
2449 /* Release the transport structures. */
2450 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
2451 transport = list_entry(pos, struct sctp_transport, transports);
add52379
VY		 2452 if (transport->state != SCTP_ACTIVE)
2453 sctp_assoc_rm_peer(asoc, transport);
1da177e4 2454 }
3f7a87d2 2455
1da177e4
LT		 2456nomem:
2457 return 0;
2458}
2459
2460
2461/* Update asoc with the option described in param.
2462 *
2463 * RFC2960 3.3.2.1 Optional/Variable Length Parameters in INIT
2464 *
2465 * asoc is the association to update.
2466 * param is the variable length parameter to use for update.
2467 * cid tells us if this is an INIT, INIT ACK or COOKIE ECHO.
2468 * If the current packet is an INIT we want to minimize the amount of
2469 * work we do. In particular, we should not build transport
2470 * structures for the addresses.
2471 */
2472static int sctp_process_param(struct sctp_association *asoc,
2473 union sctp_params param,
2474 const union sctp_addr *peer_addr,
dd0fc66f 2475 gfp_t gfp)
1da177e4 2476{
e7ff4a70 2477 struct net *net = sock_net(asoc->base.sk);
1da177e4
LT		 2478 union sctp_addr addr;
2479 int i;
2480 __u16 sat;
2481 int retval = 1;
2482 sctp_scope_t scope;
2483 time_t stale;
2484 struct sctp_af *af;
d6de3097
VY		 2485 union sctp_addr_param *addr_param;
2486 struct sctp_transport *t;
e5eae4a0 2487 struct sctp_endpoint *ep = asoc->ep;
1da177e4
LT		 2488
2489 /* We maintain all INIT parameters in network byte order all the
2490 * time. This allows us to not worry about whether the parameters
2491 * came from a fresh INIT, and INIT ACK, or were stored in a cookie.
2492 */
2493 switch (param.p->type) {
2494 case SCTP_PARAM_IPV6_ADDRESS:
2495 if (PF_INET6 != asoc->base.sk->sk_family)
2496 break;
7dab83de
VY		 2497 goto do_addr_param;
2498
1da177e4 2499 case SCTP_PARAM_IPV4_ADDRESS:
7dab83de
VY		 2500 /* v4 addresses are not allowed on v6-only socket */
2501 if (ipv6_only_sock(asoc->base.sk))
2502 break;
2503do_addr_param:
1da177e4 2504 af = sctp_get_af_specific(param_type2af(param.p->type));
dd86d136 2505 af->from_addr_param(&addr, param.addr, htons(asoc->peer.port), 0);
1da177e4 2506 scope = sctp_scope(peer_addr);
e7ff4a70 2507 if (sctp_in_scope(net, &addr, scope))
dd86d136 2508 if (!sctp_assoc_add_peer(asoc, &addr, gfp, SCTP_UNCONFIRMED))
1da177e4
LT		 2509 return 0;
2510 break;
2511
2512 case SCTP_PARAM_COOKIE_PRESERVATIVE:
e1fc3b14 2513 if (!net->sctp.cookie_preserve_enable)
1da177e4
LT		 2514 break;
2515
2516 stale = ntohl(param.life->lifespan_increment);
2517
2518 /* Suggested Cookie Life span increment's unit is msec,
2519 * (1/1000sec).
2520 */
2521 asoc->cookie_life.tv_sec += stale / 1000;
2522 asoc->cookie_life.tv_usec += (stale % 1000) * 1000;
2523 break;
2524
2525 case SCTP_PARAM_HOST_NAME_ADDRESS:
2526 SCTP_DEBUG_PRINTK("unimplemented SCTP_HOST_NAME_ADDRESS\n");
2527 break;
2528
2529 case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
2530 /* Turn off the default values first so we'll know which
2531 * ones are really set by the peer.
2532 */
2533 asoc->peer.ipv4_address = 0;
2534 asoc->peer.ipv6_address = 0;
2535
140ee960
GJ		 2536 /* Assume that peer supports the address family
2537 * by which it sends a packet.
2538 */
2539 if (peer_addr->sa.sa_family == AF_INET6)
2540 asoc->peer.ipv6_address = 1;
2541 else if (peer_addr->sa.sa_family == AF_INET)
2542 asoc->peer.ipv4_address = 1;
2543
1da177e4
LT		 2544 /* Cycle through address types; avoid divide by 0. */
2545 sat = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
2546 if (sat)
2547 sat /= sizeof(__u16);
2548
2549 for (i = 0; i < sat; ++i) {
2550 switch (param.sat->types[i]) {
2551 case SCTP_PARAM_IPV4_ADDRESS:
2552 asoc->peer.ipv4_address = 1;
2553 break;
2554
2555 case SCTP_PARAM_IPV6_ADDRESS:
6e40a915
WY		 2556 if (PF_INET6 == asoc->base.sk->sk_family)
2557 asoc->peer.ipv6_address = 1;
1da177e4
LT		 2558 break;
2559
2560 case SCTP_PARAM_HOST_NAME_ADDRESS:
2561 asoc->peer.hostname_address = 1;
2562 break;
2563
2564 default: /* Just ignore anything else. */
2565 break;
3ff50b79 2566 }
1da177e4
LT		 2567 }
2568 break;
2569
2570 case SCTP_PARAM_STATE_COOKIE:
2571 asoc->peer.cookie_len =
2572 ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
2573 asoc->peer.cookie = param.cookie->body;
2574 break;
2575
2576 case SCTP_PARAM_HEARTBEAT_INFO:
2577 /* Would be odd to receive, but it causes no problems. */
2578 break;
2579
2580 case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
2581 /* Rejected during verify stage. */
2582 break;
2583
2584 case SCTP_PARAM_ECN_CAPABLE:
2585 asoc->peer.ecn_capable = 1;
2586 break;
2587
0f3fffd8 2588 case SCTP_PARAM_ADAPTATION_LAYER_IND:
e69c4e0f 2589 asoc->peer.adaptation_ind = ntohl(param.aind->adaptation_ind);
1da177e4
LT		 2590 break;
2591
d6de3097 2592 case SCTP_PARAM_SET_PRIMARY:
e1fc3b14 2593 if (!net->sctp.addip_enable)
0ef46e28
VY		 2594 goto fall_through;
2595
d6de3097
VY		 2596 addr_param = param.v + sizeof(sctp_addip_param_t);
2597
2598 af = sctp_get_af_specific(param_type2af(param.p->type));
2599 af->from_addr_param(&addr, addr_param,
2600 htons(asoc->peer.port), 0);
2601
2602 /* if the address is invalid, we can't process it.
2603 * XXX: see spec for what to do.
2604 */
2605 if (!af->addr_valid(&addr, NULL, NULL))
2606 break;
2607
2608 t = sctp_assoc_lookup_paddr(asoc, &addr);
2609 if (!t)
2610 break;
2611
2612 sctp_assoc_set_primary(asoc, t);
2613 break;
2614
131a47e3
VY		 2615 case SCTP_PARAM_SUPPORTED_EXT:
2616 sctp_process_ext_param(asoc, param);
2617 break;
2618
1da177e4 2619 case SCTP_PARAM_FWD_TSN_SUPPORT:
e1fc3b14 2620 if (net->sctp.prsctp_enable) {
1da177e4
LT		 2621 asoc->peer.prsctp_capable = 1;
2622 break;
2623 }
d808ad9a 2624 /* Fall Through */
730fc3d0
VY		 2625 goto fall_through;
2626
2627 case SCTP_PARAM_RANDOM:
e5eae4a0 2628 if (!ep->auth_enable)
730fc3d0
VY		 2629 goto fall_through;
2630
2631 /* Save peer's random parameter */
2632 asoc->peer.peer_random = kmemdup(param.p,
2633 ntohs(param.p->length), gfp);
2634 if (!asoc->peer.peer_random) {
2635 retval = 0;
2636 break;
2637 }
2638 break;
2639
2640 case SCTP_PARAM_HMAC_ALGO:
e5eae4a0 2641 if (!ep->auth_enable)
730fc3d0
VY		 2642 goto fall_through;
2643
2644 /* Save peer's HMAC list */
2645 asoc->peer.peer_hmacs = kmemdup(param.p,
2646 ntohs(param.p->length), gfp);
2647 if (!asoc->peer.peer_hmacs) {
2648 retval = 0;
2649 break;
2650 }
2651
2652 /* Set the default HMAC the peer requested*/
2653 sctp_auth_asoc_set_default_hmac(asoc, param.hmac_algo);
2654 break;
2655
2656 case SCTP_PARAM_CHUNKS:
e5eae4a0 2657 if (!ep->auth_enable)
730fc3d0
VY		 2658 goto fall_through;
2659
2660 asoc->peer.peer_chunks = kmemdup(param.p,
2661 ntohs(param.p->length), gfp);
2662 if (!asoc->peer.peer_chunks)
2663 retval = 0;
2664 break;
2665fall_through:
1da177e4
LT		 2666 default:
2667 /* Any unrecognized parameters should have been caught
2668 * and handled by sctp_verify_param() which should be
2669 * called prior to this routine. Simply log the error
2670 * here.
2671 */
2672 SCTP_DEBUG_PRINTK("Ignoring param: %d for association %p.\n",
2673 ntohs(param.p->type), asoc);
2674 break;
3ff50b79 2675 }
1da177e4
LT		 2676
2677 return retval;
2678}
2679
2680/* Select a new verification tag. */
2681__u32 sctp_generate_tag(const struct sctp_endpoint *ep)
2682{
2683 /* I believe that this random number generator complies with RFC1750.
2684 * A tag of 0 is reserved for special cases (e.g. INIT).
2685 */
2686 __u32 x;
2687
2688 do {
2689 get_random_bytes(&x, sizeof(__u32));
2690 } while (x == 0);
2691
2692 return x;
2693}
2694
2695/* Select an initial TSN to send during startup. */
2696__u32 sctp_generate_tsn(const struct sctp_endpoint *ep)
2697{
2698 __u32 retval;
2699
2700 get_random_bytes(&retval, sizeof(__u32));
2701 return retval;
2702}
2703
2704/*
2705 * ADDIP 3.1.1 Address Configuration Change Chunk (ASCONF)
2706 * 0 1 2 3
2707 * 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
2708 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2709 * | Type = 0xC1 | Chunk Flags | Chunk Length |
2710 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2711 * | Serial Number |
2712 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2713 * | Address Parameter |
2714 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2715 * | ASCONF Parameter #1 |
2716 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2717 * \ \
2718 * / .... /
2719 * \ \
2720 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2721 * | ASCONF Parameter #N |
2722 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2723 *
d808ad9a 2724 * Address Parameter and other parameter will not be wrapped in this function
1da177e4
LT		 2725 */
2726static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc,
2727 union sctp_addr *addr,
2728 int vparam_len)
2729{
2730 sctp_addiphdr_t asconf;
2731 struct sctp_chunk *retval;
2732 int length = sizeof(asconf) + vparam_len;
2733 union sctp_addr_param addrparam;
2734 int addrlen;
2735 struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
2736
2737 addrlen = af->to_addr_param(addr, &addrparam);
2738 if (!addrlen)
2739 return NULL;
2740 length += addrlen;
2741
2742 /* Create the chunk. */
2743 retval = sctp_make_chunk(asoc, SCTP_CID_ASCONF, 0, length);
2744 if (!retval)
2745 return NULL;
2746
2747 asconf.serial = htonl(asoc->addip_serial++);
2748
2749 retval->subh.addip_hdr =
2750 sctp_addto_chunk(retval, sizeof(asconf), &asconf);
2751 retval->param_hdr.v =
2752 sctp_addto_chunk(retval, addrlen, &addrparam);
2753
2754 return retval;
2755}
2756
2757/* ADDIP
2758 * 3.2.1 Add IP Address
2759 * 0 1 2 3
2760 * 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
2761 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2762 * | Type = 0xC001 | Length = Variable |
2763 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2764 * | ASCONF-Request Correlation ID |
2765 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2766 * | Address Parameter |
2767 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2768 *
2769 * 3.2.2 Delete IP Address
2770 * 0 1 2 3
2771 * 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
2772 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2773 * | Type = 0xC002 | Length = Variable |
2774 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2775 * | ASCONF-Request Correlation ID |
2776 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2777 * | Address Parameter |
2778 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2779 *
2780 */
2781struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc,
2782 union sctp_addr *laddr,
2783 struct sockaddr *addrs,
2784 int addrcnt,
dbc16db1 2785 __be16 flags)
1da177e4
LT		 2786{
2787 sctp_addip_param_t param;
2788 struct sctp_chunk *retval;
2789 union sctp_addr_param addr_param;
2790 union sctp_addr *addr;
2791 void *addr_buf;
2792 struct sctp_af *af;
2793 int paramlen = sizeof(param);
2794 int addr_param_len = 0;
2795 int totallen = 0;
2796 int i;
8a07eb0a 2797 int del_pickup = 0;
1da177e4
LT		 2798
2799 /* Get total length of all the address parameters. */
2800 addr_buf = addrs;
2801 for (i = 0; i < addrcnt; i++) {
ea110733 2802 addr = addr_buf;
1da177e4
LT		 2803 af = sctp_get_af_specific(addr->v4.sin_family);
2804 addr_param_len = af->to_addr_param(addr, &addr_param);
2805
2806 totallen += paramlen;
2807 totallen += addr_param_len;
2808
2809 addr_buf += af->sockaddr_len;
8a07eb0a
MH		 2810 if (asoc->asconf_addr_del_pending && !del_pickup) {
2811 /* reuse the parameter length from the same scope one */
2812 totallen += paramlen;
2813 totallen += addr_param_len;
2814 del_pickup = 1;
2815 SCTP_DEBUG_PRINTK("mkasconf_update_ip: picked same-scope del_pending addr, totallen for all addresses is %d\n", totallen);
2816 }
1da177e4
LT		 2817 }
2818
2819 /* Create an asconf chunk with the required length. */
2820 retval = sctp_make_asconf(asoc, laddr, totallen);
2821 if (!retval)
2822 return NULL;
2823
2824 /* Add the address parameters to the asconf chunk. */
2825 addr_buf = addrs;
2826 for (i = 0; i < addrcnt; i++) {
ea110733 2827 addr = addr_buf;
1da177e4
LT		 2828 af = sctp_get_af_specific(addr->v4.sin_family);
2829 addr_param_len = af->to_addr_param(addr, &addr_param);
2830 param.param_hdr.type = flags;
2831 param.param_hdr.length = htons(paramlen + addr_param_len);
2832 param.crr_id = i;
2833
2834 sctp_addto_chunk(retval, paramlen, &param);
2835 sctp_addto_chunk(retval, addr_param_len, &addr_param);
2836
2837 addr_buf += af->sockaddr_len;
2838 }
8a07eb0a
MH		 2839 if (flags == SCTP_PARAM_ADD_IP && del_pickup) {
2840 addr = asoc->asconf_addr_del_pending;
2841 af = sctp_get_af_specific(addr->v4.sin_family);
2842 addr_param_len = af->to_addr_param(addr, &addr_param);
2843 param.param_hdr.type = SCTP_PARAM_DEL_IP;
2844 param.param_hdr.length = htons(paramlen + addr_param_len);
2845 param.crr_id = i;
2846
2847 sctp_addto_chunk(retval, paramlen, &param);
2848 sctp_addto_chunk(retval, addr_param_len, &addr_param);
2849 }
1da177e4
LT		 2850 return retval;
2851}
2852
2853/* ADDIP
2854 * 3.2.4 Set Primary IP Address
2855 * 0 1 2 3
2856 * 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
2857 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2858 * | Type =0xC004 | Length = Variable |
2859 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2860 * | ASCONF-Request Correlation ID |
2861 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2862 * | Address Parameter |
2863 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2864 *
d808ad9a 2865 * Create an ASCONF chunk with Set Primary IP address parameter.
1da177e4
LT		 2866 */
2867struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc,
2868 union sctp_addr *addr)
2869{
2870 sctp_addip_param_t param;
2871 struct sctp_chunk *retval;
2872 int len = sizeof(param);
2873 union sctp_addr_param addrparam;
2874 int addrlen;
2875 struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
2876
2877 addrlen = af->to_addr_param(addr, &addrparam);
2878 if (!addrlen)
2879 return NULL;
2880 len += addrlen;
2881
2882 /* Create the chunk and make asconf header. */
2883 retval = sctp_make_asconf(asoc, addr, len);
2884 if (!retval)
2885 return NULL;
2886
2887 param.param_hdr.type = SCTP_PARAM_SET_PRIMARY;
2888 param.param_hdr.length = htons(len);
2889 param.crr_id = 0;
2890
2891 sctp_addto_chunk(retval, sizeof(param), &param);
2892 sctp_addto_chunk(retval, addrlen, &addrparam);
2893
2894 return retval;
2895}
2896
2897/* ADDIP 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
2898 * 0 1 2 3
2899 * 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
2900 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2901 * | Type = 0x80 | Chunk Flags | Chunk Length |
2902 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2903 * | Serial Number |
2904 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2905 * | ASCONF Parameter Response#1 |
2906 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2907 * \ \
2908 * / .... /
2909 * \ \
2910 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2911 * | ASCONF Parameter Response#N |
2912 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2913 *
d808ad9a 2914 * Create an ASCONF_ACK chunk with enough space for the parameter responses.
1da177e4
LT		 2915 */
2916static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *asoc,
2917 __u32 serial, int vparam_len)
2918{
2919 sctp_addiphdr_t asconf;
2920 struct sctp_chunk *retval;
2921 int length = sizeof(asconf) + vparam_len;
2922
2923 /* Create the chunk. */
2924 retval = sctp_make_chunk(asoc, SCTP_CID_ASCONF_ACK, 0, length);
2925 if (!retval)
2926 return NULL;
2927
2928 asconf.serial = htonl(serial);
2929
2930 retval->subh.addip_hdr =
2931 sctp_addto_chunk(retval, sizeof(asconf), &asconf);
2932
2933 return retval;
2934}
2935
2936/* Add response parameters to an ASCONF_ACK chunk. */
9f81bcd9 2937static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id,
dbc16db1 2938 __be16 err_code, sctp_addip_param_t *asconf_param)
1da177e4
LT		 2939{
2940 sctp_addip_param_t ack_param;
2941 sctp_errhdr_t err_param;
2942 int asconf_param_len = 0;
2943 int err_param_len = 0;
dbc16db1 2944 __be16 response_type;
1da177e4
LT		 2945
2946 if (SCTP_ERROR_NO_ERROR == err_code) {
2947 response_type = SCTP_PARAM_SUCCESS_REPORT;
2948 } else {
2949 response_type = SCTP_PARAM_ERR_CAUSE;
2950 err_param_len = sizeof(err_param);
2951 if (asconf_param)
2952 asconf_param_len =
2953 ntohs(asconf_param->param_hdr.length);
2954 }
2955
d808ad9a 2956 /* Add Success Indication or Error Cause Indication parameter. */
1da177e4
LT		 2957 ack_param.param_hdr.type = response_type;
2958 ack_param.param_hdr.length = htons(sizeof(ack_param) +
2959 err_param_len +
2960 asconf_param_len);
2961 ack_param.crr_id = crr_id;
2962 sctp_addto_chunk(chunk, sizeof(ack_param), &ack_param);
2963
2964 if (SCTP_ERROR_NO_ERROR == err_code)
2965 return;
2966
2967 /* Add Error Cause parameter. */
2968 err_param.cause = err_code;
2969 err_param.length = htons(err_param_len + asconf_param_len);
2970 sctp_addto_chunk(chunk, err_param_len, &err_param);
2971
2972 /* Add the failed TLV copied from ASCONF chunk. */
2973 if (asconf_param)
2974 sctp_addto_chunk(chunk, asconf_param_len, asconf_param);
2975}
2976
2977/* Process a asconf parameter. */
dbc16db1 2978static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
1da177e4
LT		 2979 struct sctp_chunk *asconf,
2980 sctp_addip_param_t *asconf_param)
2981{
2982 struct sctp_transport *peer;
2983 struct sctp_af *af;
2984 union sctp_addr addr;
1da177e4 2985 union sctp_addr_param *addr_param;
5f242a13 2986
ea110733 2987 addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);
c1cc678a 2988
44e65c1e
WY		 2989 if (asconf_param->param_hdr.type != SCTP_PARAM_ADD_IP &&
2990 asconf_param->param_hdr.type != SCTP_PARAM_DEL_IP &&
2991 asconf_param->param_hdr.type != SCTP_PARAM_SET_PRIMARY)
2992 return SCTP_ERROR_UNKNOWN_PARAM;
2993
6a435732 2994 switch (addr_param->p.type) {
c4492586
WY		 2995 case SCTP_PARAM_IPV6_ADDRESS:
2996 if (!asoc->peer.ipv6_address)
945e5abc 2997 return SCTP_ERROR_DNS_FAILED;
c4492586
WY		 2998 break;
2999 case SCTP_PARAM_IPV4_ADDRESS:
3000 if (!asoc->peer.ipv4_address)
945e5abc 3001 return SCTP_ERROR_DNS_FAILED;
c4492586
WY		 3002 break;
3003 default:
945e5abc 3004 return SCTP_ERROR_DNS_FAILED;
c4492586
WY		 3005 }
3006
6a435732 3007 af = sctp_get_af_specific(param_type2af(addr_param->p.type));
1da177e4 3008 if (unlikely(!af))
945e5abc 3009 return SCTP_ERROR_DNS_FAILED;
1da177e4 3010
dd86d136 3011 af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0);
42e30bf3
VY		 3012
3013 /* ADDIP 4.2.1 This parameter MUST NOT contain a broadcast
3014 * or multicast address.
3015 * (note: wildcard is permitted and requires special handling so
3016 * make sure we check for that)
3017 */
3018 if (!af->is_any(&addr) && !af->addr_valid(&addr, NULL, asconf->skb))
945e5abc 3019 return SCTP_ERROR_DNS_FAILED;
42e30bf3 3020
1da177e4
LT		 3021 switch (asconf_param->param_hdr.type) {
3022 case SCTP_PARAM_ADD_IP:
42e30bf3
VY		 3023 /* Section 4.2.1:
3024 * If the address 0.0.0.0 or ::0 is provided, the source
3025 * address of the packet MUST be added.
3026 */
3027 if (af->is_any(&addr))
3028 memcpy(&addr, &asconf->source, sizeof(addr));
3029
1da177e4 3030 /* ADDIP 4.3 D9) If an endpoint receives an ADD IP address
d808ad9a
YH		 3031 * request and does not have the local resources to add this
3032 * new address to the association, it MUST return an Error
3033 * Cause TLV set to the new error code 'Operation Refused
3034 * Due to Resource Shortage'.
3035 */
1da177e4 3036
dd86d136 3037 peer = sctp_assoc_add_peer(asoc, &addr, GFP_ATOMIC, SCTP_UNCONFIRMED);
1da177e4
LT		 3038 if (!peer)
3039 return SCTP_ERROR_RSRC_LOW;
3040
3041 /* Start the heartbeat timer. */
3042 if (!mod_timer(&peer->hb_timer, sctp_transport_timeout(peer)))
3043 sctp_transport_hold(peer);
6af29ccc 3044 asoc->new_transport = peer;
1da177e4
LT		 3045 break;
3046 case SCTP_PARAM_DEL_IP:
3047 /* ADDIP 4.3 D7) If a request is received to delete the
d808ad9a
YH		 3048 * last remaining IP address of a peer endpoint, the receiver
3049 * MUST send an Error Cause TLV with the error cause set to the
3050 * new error code 'Request to Delete Last Remaining IP Address'.
3051 */
42e30bf3 3052 if (asoc->peer.transport_count == 1)
1da177e4
LT		 3053 return SCTP_ERROR_DEL_LAST_IP;
3054
3055 /* ADDIP 4.3 D8) If a request is received to delete an IP
3056 * address which is also the source address of the IP packet
3057 * which contained the ASCONF chunk, the receiver MUST reject
3058 * this request. To reject the request the receiver MUST send
3059 * an Error Cause TLV set to the new error code 'Request to
3060 * Delete Source IP Address'
3061 */
b1364104 3062 if (sctp_cmp_addr_exact(&asconf->source, &addr))
1da177e4
LT		 3063 return SCTP_ERROR_DEL_SRC_IP;
3064
42e30bf3
VY		 3065 /* Section 4.2.2
3066 * If the address 0.0.0.0 or ::0 is provided, all
3067 * addresses of the peer except the source address of the
3068 * packet MUST be deleted.
3069 */
3070 if (af->is_any(&addr)) {
3071 sctp_assoc_set_primary(asoc, asconf->transport);
3072 sctp_assoc_del_nonprimary_peers(asoc,
3073 asconf->transport);
3074 } else
3075 sctp_assoc_del_peer(asoc, &addr);
1da177e4
LT		 3076 break;
3077 case SCTP_PARAM_SET_PRIMARY:
42e30bf3
VY		 3078 /* ADDIP Section 4.2.4
3079 * If the address 0.0.0.0 or ::0 is provided, the receiver
3080 * MAY mark the source address of the packet as its
3081 * primary.
3082 */
3083 if (af->is_any(&addr))
3084 memcpy(&addr.v4, sctp_source(asconf), sizeof(addr));
3085
dd86d136 3086 peer = sctp_assoc_lookup_paddr(asoc, &addr);
1da177e4 3087 if (!peer)
945e5abc 3088 return SCTP_ERROR_DNS_FAILED;
1da177e4
LT		 3089
3090 sctp_assoc_set_primary(asoc, peer);
3091 break;
1da177e4
LT		 3092 }
3093
3094 return SCTP_ERROR_NO_ERROR;
3095}
3096
6f4c618d
WY		 3097/* Verify the ASCONF packet before we process it. */
3098int sctp_verify_asconf(const struct sctp_association *asoc,
3099 struct sctp_paramhdr *param_hdr, void *chunk_end,
3100 struct sctp_paramhdr **errp) {
3101 sctp_addip_param_t *asconf_param;
3102 union sctp_params param;
3103 int length, plen;
3104
3105 param.v = (sctp_paramhdr_t *) param_hdr;
3106 while (param.v <= chunk_end - sizeof(sctp_paramhdr_t)) {
3107 length = ntohs(param.p->length);
3108 *errp = param.p;
3109
3110 if (param.v > chunk_end - length ||
3111 length < sizeof(sctp_paramhdr_t))
3112 return 0;
3113
3114 switch (param.p->type) {
3115 case SCTP_PARAM_ADD_IP:
3116 case SCTP_PARAM_DEL_IP:
3117 case SCTP_PARAM_SET_PRIMARY:
3118 asconf_param = (sctp_addip_param_t *)param.v;
3119 plen = ntohs(asconf_param->param_hdr.length);
3120 if (plen < sizeof(sctp_addip_param_t) +
3121 sizeof(sctp_paramhdr_t))
3122 return 0;
3123 break;
3124 case SCTP_PARAM_SUCCESS_REPORT:
3125 case SCTP_PARAM_ADAPTATION_LAYER_IND:
3126 if (length != sizeof(sctp_addip_param_t))
3127 return 0;
3128
3129 break;
3130 default:
3131 break;
3132 }
3133
3134 param.v += WORD_ROUND(length);
3135 }
3136
3137 if (param.v != chunk_end)
3138 return 0;
3139
3140 return 1;
3141}
3142
d808ad9a 3143/* Process an incoming ASCONF chunk with the next expected serial no. and
1da177e4
LT		 3144 * return an ASCONF_ACK chunk to be sent in response.
3145 */
3146struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc,
3147 struct sctp_chunk *asconf)
3148{
3149 sctp_addiphdr_t *hdr;
3150 union sctp_addr_param *addr_param;
3151 sctp_addip_param_t *asconf_param;
3152 struct sctp_chunk *asconf_ack;
3153
dbc16db1 3154 __be16 err_code;
1da177e4 3155 int length = 0;
f3830ccc 3156 int chunk_len;
1da177e4
LT		 3157 __u32 serial;
3158 int all_param_pass = 1;
3159
f3830ccc 3160 chunk_len = ntohs(asconf->chunk_hdr->length) - sizeof(sctp_chunkhdr_t);
1da177e4
LT		 3161 hdr = (sctp_addiphdr_t *)asconf->skb->data;
3162 serial = ntohl(hdr->serial);
3163
d808ad9a 3164 /* Skip the addiphdr and store a pointer to address parameter. */
1da177e4
LT		 3165 length = sizeof(sctp_addiphdr_t);
3166 addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
3167 chunk_len -= length;
3168
3169 /* Skip the address parameter and store a pointer to the first
7aa1b54b 3170 * asconf parameter.
d808ad9a 3171 */
6a435732 3172 length = ntohs(addr_param->p.length);
ea110733 3173 asconf_param = (void *)addr_param + length;
1da177e4
LT		 3174 chunk_len -= length;
3175
d808ad9a 3176 /* create an ASCONF_ACK chunk.
1da177e4 3177 * Based on the definitions of parameters, we know that the size of
2cab86be 3178 * ASCONF_ACK parameters are less than or equal to the fourfold of ASCONF
7aa1b54b 3179 * parameters.
1da177e4 3180 */
2cab86be 3181 asconf_ack = sctp_make_asconf_ack(asoc, serial, chunk_len * 4);
1da177e4
LT		 3182 if (!asconf_ack)
3183 goto done;
3184
3185 /* Process the TLVs contained within the ASCONF chunk. */
3186 while (chunk_len > 0) {
3187 err_code = sctp_process_asconf_param(asoc, asconf,
3188 asconf_param);
3189 /* ADDIP 4.1 A7)
3190 * If an error response is received for a TLV parameter,
3191 * all TLVs with no response before the failed TLV are
3192 * considered successful if not reported. All TLVs after
3193 * the failed response are considered unsuccessful unless
3194 * a specific success indication is present for the parameter.
3195 */
3196 if (SCTP_ERROR_NO_ERROR != err_code)
3197 all_param_pass = 0;
3198
3199 if (!all_param_pass)
3200 sctp_add_asconf_response(asconf_ack,
3201 asconf_param->crr_id, err_code,
3202 asconf_param);
3203
3204 /* ADDIP 4.3 D11) When an endpoint receiving an ASCONF to add
3205 * an IP address sends an 'Out of Resource' in its response, it
3206 * MUST also fail any subsequent add or delete requests bundled
d808ad9a 3207 * in the ASCONF.
1da177e4
LT		 3208 */
3209 if (SCTP_ERROR_RSRC_LOW == err_code)
3210 goto done;
3211
3212 /* Move to the next ASCONF param. */
3213 length = ntohs(asconf_param->param_hdr.length);
ea110733 3214 asconf_param = (void *)asconf_param + length;
1da177e4
LT		 3215 chunk_len -= length;
3216 }
d808ad9a 3217
1da177e4
LT		 3218done:
3219 asoc->peer.addip_serial++;
3220
3221 /* If we are sending a new ASCONF_ACK hold a reference to it in assoc
d808ad9a 3222 * after freeing the reference to old asconf ack if any.
1da177e4
LT		 3223 */
3224 if (asconf_ack) {
1da177e4 3225 sctp_chunk_hold(asconf_ack);
a08de64d
VY		 3226 list_add_tail(&asconf_ack->transmitted_list,
3227 &asoc->asconf_ack_list);
1da177e4
LT		 3228 }
3229
3230 return asconf_ack;
3231}
3232
3233/* Process a asconf parameter that is successfully acked. */
425e0f68 3234static void sctp_asconf_param_success(struct sctp_association *asoc,
1da177e4
LT		 3235 sctp_addip_param_t *asconf_param)
3236{
3237 struct sctp_af *af;
3238 union sctp_addr addr;
3239 struct sctp_bind_addr *bp = &asoc->base.bind_addr;
3240 union sctp_addr_param *addr_param;
1da177e4 3241 struct sctp_transport *transport;
dc022a98 3242 struct sctp_sockaddr_entry *saddr;
1da177e4 3243
ea110733 3244 addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);
1da177e4
LT		 3245
3246 /* We have checked the packet before, so we do not check again. */
6a435732 3247 af = sctp_get_af_specific(param_type2af(addr_param->p.type));
dd86d136 3248 af->from_addr_param(&addr, addr_param, htons(bp->port), 0);
1da177e4
LT		 3249
3250 switch (asconf_param->param_hdr.type) {
3251 case SCTP_PARAM_ADD_IP:
559cf710
VY		 3252 /* This is always done in BH context with a socket lock
3253 * held, so the list can not change.
3254 */
0ed90fb0 3255 local_bh_disable();
559cf710 3256 list_for_each_entry(saddr, &bp->address_list, list) {
dd86d136 3257 if (sctp_cmp_addr_exact(&saddr->a, &addr))
f57d96b2 3258 saddr->state = SCTP_ADDR_SRC;
dc022a98 3259 }
0ed90fb0 3260 local_bh_enable();
3cd9749c
WY		 3261 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
3262 transports) {
3cd9749c 3263 dst_release(transport->dst);
c6ef006b 3264 transport->dst = NULL;
3cd9749c 3265 }
1da177e4
LT		 3266 break;
3267 case SCTP_PARAM_DEL_IP:
0ed90fb0 3268 local_bh_disable();
425e0f68 3269 sctp_del_bind_addr(bp, &addr);
8a07eb0a
MH		 3270 if (asoc->asconf_addr_del_pending != NULL &&
3271 sctp_cmp_addr_exact(asoc->asconf_addr_del_pending, &addr)) {
3272 kfree(asoc->asconf_addr_del_pending);
3273 asoc->asconf_addr_del_pending = NULL;
3274 }
0ed90fb0 3275 local_bh_enable();
9dbc15f0
RD		 3276 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
3277 transports) {
dc022a98 3278 dst_release(transport->dst);
c6ef006b 3279 transport->dst = NULL;
1da177e4
LT		 3280 }
3281 break;
3282 default:
3283 break;
3284 }
1da177e4
LT		 3285}
3286
3287/* Get the corresponding ASCONF response error code from the ASCONF_ACK chunk
3288 * for the given asconf parameter. If there is no response for this parameter,
d808ad9a 3289 * return the error code based on the third argument 'no_err'.
1da177e4
LT		 3290 * ADDIP 4.1
3291 * A7) If an error response is received for a TLV parameter, all TLVs with no
3292 * response before the failed TLV are considered successful if not reported.
3293 * All TLVs after the failed response are considered unsuccessful unless a
3294 * specific success indication is present for the parameter.
3295 */
dbc16db1 3296static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack,
1da177e4
LT		 3297 sctp_addip_param_t *asconf_param,
3298 int no_err)
3299{
3300 sctp_addip_param_t *asconf_ack_param;
3301 sctp_errhdr_t *err_param;
3302 int length;
f3830ccc 3303 int asconf_ack_len;
dbc16db1 3304 __be16 err_code;
1da177e4
LT		 3305
3306 if (no_err)
3307 err_code = SCTP_ERROR_NO_ERROR;
3308 else
3309 err_code = SCTP_ERROR_REQ_REFUSED;
3310
f3830ccc
WY		 3311 asconf_ack_len = ntohs(asconf_ack->chunk_hdr->length) -
3312 sizeof(sctp_chunkhdr_t);
3313
1da177e4
LT		 3314 /* Skip the addiphdr from the asconf_ack chunk and store a pointer to
3315 * the first asconf_ack parameter.
d808ad9a 3316 */
1da177e4
LT		 3317 length = sizeof(sctp_addiphdr_t);
3318 asconf_ack_param = (sctp_addip_param_t *)(asconf_ack->skb->data +
3319 length);
3320 asconf_ack_len -= length;
3321
3322 while (asconf_ack_len > 0) {
3323 if (asconf_ack_param->crr_id == asconf_param->crr_id) {
3324 switch(asconf_ack_param->param_hdr.type) {
3325 case SCTP_PARAM_SUCCESS_REPORT:
3326 return SCTP_ERROR_NO_ERROR;
3327 case SCTP_PARAM_ERR_CAUSE:
3328 length = sizeof(sctp_addip_param_t);
ea110733 3329 err_param = (void *)asconf_ack_param + length;
1da177e4
LT		 3330 asconf_ack_len -= length;
3331 if (asconf_ack_len > 0)
3332 return err_param->cause;
3333 else
3334 return SCTP_ERROR_INV_PARAM;
3335 break;
3336 default:
3337 return SCTP_ERROR_INV_PARAM;
3338 }
3339 }
3340
3341 length = ntohs(asconf_ack_param->param_hdr.length);
ea110733 3342 asconf_ack_param = (void *)asconf_ack_param + length;
1da177e4
LT		 3343 asconf_ack_len -= length;
3344 }
3345
3346 return err_code;
3347}
3348
3349/* Process an incoming ASCONF_ACK chunk against the cached last ASCONF chunk. */
3350int sctp_process_asconf_ack(struct sctp_association *asoc,
3351 struct sctp_chunk *asconf_ack)
3352{
3353 struct sctp_chunk *asconf = asoc->addip_last_asconf;
3354 union sctp_addr_param *addr_param;
3355 sctp_addip_param_t *asconf_param;
3356 int length = 0;
3357 int asconf_len = asconf->skb->len;
3358 int all_param_pass = 0;
3359 int no_err = 1;
3360 int retval = 0;
dbc16db1 3361 __be16 err_code = SCTP_ERROR_NO_ERROR;
1da177e4
LT		 3362
3363 /* Skip the chunkhdr and addiphdr from the last asconf sent and store
3364 * a pointer to address parameter.
d808ad9a 3365 */
1da177e4
LT		 3366 length = sizeof(sctp_addip_chunk_t);
3367 addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
3368 asconf_len -= length;
3369
3370 /* Skip the address parameter in the last asconf sent and store a
7aa1b54b 3371 * pointer to the first asconf parameter.
d808ad9a 3372 */
6a435732 3373 length = ntohs(addr_param->p.length);
ea110733 3374 asconf_param = (void *)addr_param + length;
1da177e4
LT		 3375 asconf_len -= length;
3376
3377 /* ADDIP 4.1
3378 * A8) If there is no response(s) to specific TLV parameter(s), and no
3379 * failures are indicated, then all request(s) are considered
3380 * successful.
3381 */
3382 if (asconf_ack->skb->len == sizeof(sctp_addiphdr_t))
3383 all_param_pass = 1;
3384
3385 /* Process the TLVs contained in the last sent ASCONF chunk. */
3386 while (asconf_len > 0) {
3387 if (all_param_pass)
3388 err_code = SCTP_ERROR_NO_ERROR;
3389 else {
3390 err_code = sctp_get_asconf_response(asconf_ack,
3391 asconf_param,
3392 no_err);
3393 if (no_err && (SCTP_ERROR_NO_ERROR != err_code))
3394 no_err = 0;
3395 }
3396
3397 switch (err_code) {
3398 case SCTP_ERROR_NO_ERROR:
425e0f68 3399 sctp_asconf_param_success(asoc, asconf_param);
1da177e4
LT		 3400 break;
3401
3402 case SCTP_ERROR_RSRC_LOW:
3403 retval = 1;
3404 break;
3405
a987f762 3406 case SCTP_ERROR_UNKNOWN_PARAM:
1da177e4
LT		 3407 /* Disable sending this type of asconf parameter in
3408 * future.
d808ad9a 3409 */
1da177e4
LT		 3410 asoc->peer.addip_disabled_mask |=
3411 asconf_param->param_hdr.type;
3412 break;
3413
3414 case SCTP_ERROR_REQ_REFUSED:
3415 case SCTP_ERROR_DEL_LAST_IP:
3416 case SCTP_ERROR_DEL_SRC_IP:
3417 default:
3418 break;
3419 }
3420
3421 /* Skip the processed asconf parameter and move to the next
3422 * one.
d808ad9a 3423 */
1da177e4 3424 length = ntohs(asconf_param->param_hdr.length);
ea110733 3425 asconf_param = (void *)asconf_param + length;
1da177e4
LT		 3426 asconf_len -= length;
3427 }
3428
ddc4bbee 3429 if (no_err && asoc->src_out_of_asoc_ok) {
8a07eb0a 3430 asoc->src_out_of_asoc_ok = 0;
ddc4bbee
MH		 3431 sctp_transport_immediate_rtx(asoc->peer.primary_path);
3432 }
8a07eb0a 3433
1da177e4 3434 /* Free the cached last sent asconf chunk. */
5f9646c3 3435 list_del_init(&asconf->transmitted_list);
1da177e4
LT		 3436 sctp_chunk_free(asconf);
3437 asoc->addip_last_asconf = NULL;
3438
1da177e4
LT		 3439 return retval;
3440}
3441
d808ad9a 3442/* Make a FWD TSN chunk. */
1da177e4
LT		 3443struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
3444 __u32 new_cum_tsn, size_t nstreams,
3445 struct sctp_fwdtsn_skip *skiplist)
3446{
3447 struct sctp_chunk *retval = NULL;
d808ad9a 3448 struct sctp_fwdtsn_hdr ftsn_hdr;
1da177e4
LT		 3449 struct sctp_fwdtsn_skip skip;
3450 size_t hint;
3451 int i;
3452
3453 hint = (nstreams + 1) * sizeof(__u32);
3454
1da177e4
LT		 3455 retval = sctp_make_chunk(asoc, SCTP_CID_FWD_TSN, 0, hint);
3456
3457 if (!retval)
3458 return NULL;
3459
1da177e4
LT		 3460 ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
3461 retval->subh.fwdtsn_hdr =
3462 sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
3463
3464 for (i = 0; i < nstreams; i++) {
3465 skip.stream = skiplist[i].stream;
3466 skip.ssn = skiplist[i].ssn;
3467 sctp_addto_chunk(retval, sizeof(skip), &skip);
3468 }
3469
3470 return retval;
3471}
kernel source for telekom puls (alcatel/mediatek)