147505b8bSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
260c778b2SVlad Yasevich /* SCTP kernel implementation
31da177e4SLinus Torvalds * (C) Copyright IBM Corp. 2001, 2004
41da177e4SLinus Torvalds * Copyright (c) 1999-2000 Cisco, Inc.
51da177e4SLinus Torvalds * Copyright (c) 1999-2001 Motorola, Inc.
61da177e4SLinus Torvalds * Copyright (c) 2001-2002 Intel Corp.
71da177e4SLinus Torvalds *
860c778b2SVlad Yasevich * This file is part of the SCTP kernel implementation
91da177e4SLinus Torvalds *
101da177e4SLinus Torvalds * These functions work with the state functions in sctp_sm_statefuns.c
111da177e4SLinus Torvalds * to implement the state operations. These functions implement the
121da177e4SLinus Torvalds * steps which require modifying existing data structures.
131da177e4SLinus Torvalds *
141da177e4SLinus Torvalds * Please send any bug reports or fixes you make to the
151da177e4SLinus Torvalds * email address(es):
1691705c61SDaniel Borkmann * lksctp developers <linux-sctp@vger.kernel.org>
171da177e4SLinus Torvalds *
181da177e4SLinus Torvalds * Written or modified by:
191da177e4SLinus Torvalds * La Monte H.P. Yarroll <piggy@acm.org>
201da177e4SLinus Torvalds * Karl Knutson <karl@athena.chicago.il.us>
211da177e4SLinus Torvalds * C. Robin <chris@hundredacre.ac.uk>
221da177e4SLinus Torvalds * Jon Grimm <jgrimm@us.ibm.com>
231da177e4SLinus Torvalds * Xingang Guo <xingang.guo@intel.com>
241da177e4SLinus Torvalds * Dajiang Zhang <dajiang.zhang@nokia.com>
251da177e4SLinus Torvalds * Sridhar Samudrala <sri@us.ibm.com>
261da177e4SLinus Torvalds * Daisy Chang <daisyc@us.ibm.com>
271da177e4SLinus Torvalds * Ardelle Fan <ardelle.fan@intel.com>
281da177e4SLinus Torvalds * Kevin Gao <kevin.gao@intel.com>
291da177e4SLinus Torvalds */
301da177e4SLinus Torvalds
31145ce502SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32145ce502SJoe Perches
335821c769SHerbert Xu #include <crypto/hash.h>
341da177e4SLinus Torvalds #include <linux/types.h>
351da177e4SLinus Torvalds #include <linux/kernel.h>
361da177e4SLinus Torvalds #include <linux/ip.h>
371da177e4SLinus Torvalds #include <linux/ipv6.h>
381da177e4SLinus Torvalds #include <linux/net.h>
391da177e4SLinus Torvalds #include <linux/inet.h>
40ebc3bbcfSChristian Borntraeger #include <linux/scatterlist.h>
415a0e3ad6STejun Heo #include <linux/slab.h>
421da177e4SLinus Torvalds #include <net/sock.h>
431da177e4SLinus Torvalds
441da177e4SLinus Torvalds #include <linux/skbuff.h>
451da177e4SLinus Torvalds #include <linux/random.h> /* for get_random_bytes */
461da177e4SLinus Torvalds #include <net/sctp/sctp.h>
471da177e4SLinus Torvalds #include <net/sctp/sm.h>
481da177e4SLinus Torvalds
49072017b4SVlad Yasevich static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
50cea8768fSMarcelo Ricardo Leitner __u8 type, __u8 flags, int paylen,
51cea8768fSMarcelo Ricardo Leitner gfp_t gfp);
52072017b4SVlad Yasevich static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
53cea8768fSMarcelo Ricardo Leitner __u8 flags, int paylen, gfp_t gfp);
54072017b4SVlad Yasevich static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
55cea8768fSMarcelo Ricardo Leitner __u8 type, __u8 flags, int paylen,
56cea8768fSMarcelo Ricardo Leitner gfp_t gfp);
57f48ef4c7SXin Long static struct sctp_cookie_param *sctp_pack_cookie(
58f48ef4c7SXin Long const struct sctp_endpoint *ep,
591da177e4SLinus Torvalds const struct sctp_association *asoc,
601da177e4SLinus Torvalds const struct sctp_chunk *init_chunk,
611da177e4SLinus Torvalds int *cookie_len,
621da177e4SLinus Torvalds const __u8 *raw_addrs, int addrs_len);
631da177e4SLinus Torvalds static int sctp_process_param(struct sctp_association *asoc,
641da177e4SLinus Torvalds union sctp_params param,
651da177e4SLinus Torvalds const union sctp_addr *peer_addr,
66dd0fc66fSAl Viro gfp_t gfp);
678ee4be37SVlad Yasevich static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
688ee4be37SVlad Yasevich const void *data);
691da177e4SLinus Torvalds
70072017b4SVlad Yasevich /* Control chunk destructor */
sctp_control_release_owner(struct sk_buff * skb)71072017b4SVlad Yasevich static void sctp_control_release_owner(struct sk_buff *skb)
72072017b4SVlad Yasevich {
731b1e0bc9SXin Long struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
741b1e0bc9SXin Long
75ec2e506cSXin Long if (chunk->shkey) {
76ec2e506cSXin Long struct sctp_shared_key *shkey = chunk->shkey;
77ec2e506cSXin Long struct sctp_association *asoc = chunk->asoc;
78ec2e506cSXin Long
79ec2e506cSXin Long /* refcnt == 2 and !list_empty mean after this release, it's
80ec2e506cSXin Long * not being used anywhere, and it's time to notify userland
81ec2e506cSXin Long * that this shkey can be freed if it's been deactivated.
82ec2e506cSXin Long */
83ec2e506cSXin Long if (shkey->deactivated && !list_empty(&shkey->key_list) &&
84ec2e506cSXin Long refcount_read(&shkey->refcnt) == 2) {
85ec2e506cSXin Long struct sctp_ulpevent *ev;
86ec2e506cSXin Long
87ec2e506cSXin Long ev = sctp_ulpevent_make_authkey(asoc, shkey->key_id,
88ec2e506cSXin Long SCTP_AUTH_FREE_KEY,
89ec2e506cSXin Long GFP_KERNEL);
90ec2e506cSXin Long if (ev)
91ec2e506cSXin Long asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
92ec2e506cSXin Long }
931b1e0bc9SXin Long sctp_auth_shkey_release(chunk->shkey);
94072017b4SVlad Yasevich }
95ec2e506cSXin Long }
96072017b4SVlad Yasevich
sctp_control_set_owner_w(struct sctp_chunk * chunk)97072017b4SVlad Yasevich static void sctp_control_set_owner_w(struct sctp_chunk *chunk)
98072017b4SVlad Yasevich {
99072017b4SVlad Yasevich struct sctp_association *asoc = chunk->asoc;
100072017b4SVlad Yasevich struct sk_buff *skb = chunk->skb;
101072017b4SVlad Yasevich
102072017b4SVlad Yasevich /* TODO: properly account for control chunks.
103072017b4SVlad Yasevich * To do it right we'll need:
104072017b4SVlad Yasevich * 1) endpoint if association isn't known.
105072017b4SVlad Yasevich * 2) proper memory accounting.
106072017b4SVlad Yasevich *
107072017b4SVlad Yasevich * For now don't do anything for now.
108072017b4SVlad Yasevich */
1091b1e0bc9SXin Long if (chunk->auth) {
1101b1e0bc9SXin Long chunk->shkey = asoc->shkey;
1111b1e0bc9SXin Long sctp_auth_shkey_hold(chunk->shkey);
1121b1e0bc9SXin Long }
113072017b4SVlad Yasevich skb->sk = asoc ? asoc->base.sk : NULL;
1141b1e0bc9SXin Long skb_shinfo(skb)->destructor_arg = chunk;
115072017b4SVlad Yasevich skb->destructor = sctp_control_release_owner;
116072017b4SVlad Yasevich }
117072017b4SVlad Yasevich
1181da177e4SLinus Torvalds /* What was the inbound interface for this chunk? */
sctp_chunk_iif(const struct sctp_chunk * chunk)1191da177e4SLinus Torvalds int sctp_chunk_iif(const struct sctp_chunk *chunk)
1201da177e4SLinus Torvalds {
121e7487c86SMarcelo Ricardo Leitner struct sk_buff *skb = chunk->skb;
1221da177e4SLinus Torvalds
123e7487c86SMarcelo Ricardo Leitner return SCTP_INPUT_CB(skb)->af->skb_iif(skb);
1241da177e4SLinus Torvalds }
1251da177e4SLinus Torvalds
1261da177e4SLinus Torvalds /* RFC 2960 3.3.2 Initiation (INIT) (1)
1271da177e4SLinus Torvalds *
1281da177e4SLinus Torvalds * Note 2: The ECN capable field is reserved for future use of
1291da177e4SLinus Torvalds * Explicit Congestion Notification.
1301da177e4SLinus Torvalds */
1311da177e4SLinus Torvalds static const struct sctp_paramhdr ecap_param = {
1321da177e4SLinus Torvalds SCTP_PARAM_ECN_CAPABLE,
13309640e63SHarvey Harrison cpu_to_be16(sizeof(struct sctp_paramhdr)),
1341da177e4SLinus Torvalds };
1351da177e4SLinus Torvalds static const struct sctp_paramhdr prsctp_param = {
1361da177e4SLinus Torvalds SCTP_PARAM_FWD_TSN_SUPPORT,
13709640e63SHarvey Harrison cpu_to_be16(sizeof(struct sctp_paramhdr)),
1381da177e4SLinus Torvalds };
1391da177e4SLinus Torvalds
1408914f4baSMarcelo Ricardo Leitner /* A helper to initialize an op error inside a provided chunk, as most
1418914f4baSMarcelo Ricardo Leitner * cause codes will be embedded inside an abort chunk.
1421da177e4SLinus Torvalds */
sctp_init_cause(struct sctp_chunk * chunk,__be16 cause_code,size_t paylen)1436d3e8aa8SMarcelo Ricardo Leitner int sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,
14400f1c2dfSWei Yongjun size_t paylen)
1451da177e4SLinus Torvalds {
146d8238d9dSXin Long struct sctp_errhdr err;
1471da177e4SLinus Torvalds __u16 len;
1481da177e4SLinus Torvalds
1491da177e4SLinus Torvalds /* Cause code constants are now defined in network order. */
1501da177e4SLinus Torvalds err.cause = cause_code;
151d8238d9dSXin Long len = sizeof(err) + paylen;
1521da177e4SLinus Torvalds err.length = htons(len);
1536d3e8aa8SMarcelo Ricardo Leitner
1546d3e8aa8SMarcelo Ricardo Leitner if (skb_tailroom(chunk->skb) < len)
1556d3e8aa8SMarcelo Ricardo Leitner return -ENOSPC;
1566d3e8aa8SMarcelo Ricardo Leitner
157d8238d9dSXin Long chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(err), &err);
1586d3e8aa8SMarcelo Ricardo Leitner
1596d3e8aa8SMarcelo Ricardo Leitner return 0;
1601da177e4SLinus Torvalds }
1611da177e4SLinus Torvalds
1621da177e4SLinus Torvalds /* 3.3.2 Initiation (INIT) (1)
1631da177e4SLinus Torvalds *
1641da177e4SLinus Torvalds * This chunk is used to initiate a SCTP association between two
1651da177e4SLinus Torvalds * endpoints. The format of the INIT chunk is shown below:
1661da177e4SLinus Torvalds *
1671da177e4SLinus Torvalds * 0 1 2 3
1681da177e4SLinus Torvalds * 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
1691da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1701da177e4SLinus Torvalds * | Type = 1 | Chunk Flags | Chunk Length |
1711da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1721da177e4SLinus Torvalds * | Initiate Tag |
1731da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1741da177e4SLinus Torvalds * | Advertised Receiver Window Credit (a_rwnd) |
1751da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1761da177e4SLinus Torvalds * | Number of Outbound Streams | Number of Inbound Streams |
1771da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1781da177e4SLinus Torvalds * | Initial TSN |
1791da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1801da177e4SLinus Torvalds * \ \
1811da177e4SLinus Torvalds * / Optional/Variable-Length Parameters /
1821da177e4SLinus Torvalds * \ \
1831da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1841da177e4SLinus Torvalds *
1851da177e4SLinus Torvalds *
1861da177e4SLinus Torvalds * The INIT chunk contains the following parameters. Unless otherwise
1871da177e4SLinus Torvalds * noted, each parameter MUST only be included once in the INIT chunk.
1881da177e4SLinus Torvalds *
1891da177e4SLinus Torvalds * Fixed Parameters Status
1901da177e4SLinus Torvalds * ----------------------------------------------
1911da177e4SLinus Torvalds * Initiate Tag Mandatory
1921da177e4SLinus Torvalds * Advertised Receiver Window Credit Mandatory
1931da177e4SLinus Torvalds * Number of Outbound Streams Mandatory
1941da177e4SLinus Torvalds * Number of Inbound Streams Mandatory
1951da177e4SLinus Torvalds * Initial TSN Mandatory
1961da177e4SLinus Torvalds *
1971da177e4SLinus Torvalds * Variable Parameters Status Type Value
1981da177e4SLinus Torvalds * -------------------------------------------------------------
1991da177e4SLinus Torvalds * IPv4 Address (Note 1) Optional 5
2001da177e4SLinus Torvalds * IPv6 Address (Note 1) Optional 6
2011da177e4SLinus Torvalds * Cookie Preservative Optional 9
2021da177e4SLinus Torvalds * Reserved for ECN Capable (Note 2) Optional 32768 (0x8000)
2031da177e4SLinus Torvalds * Host Name Address (Note 3) Optional 11
2041da177e4SLinus Torvalds * Supported Address Types (Note 4) Optional 12
2051da177e4SLinus Torvalds */
sctp_make_init(const struct sctp_association * asoc,const struct sctp_bind_addr * bp,gfp_t gfp,int vparam_len)2061da177e4SLinus Torvalds struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
2071da177e4SLinus Torvalds const struct sctp_bind_addr *bp,
208dd0fc66fSAl Viro gfp_t gfp, int vparam_len)
2091da177e4SLinus Torvalds {
210327c0dabSXin Long struct sctp_supported_ext_param ext_param;
211327c0dabSXin Long struct sctp_adaptation_ind_param aiparam;
212327c0dabSXin Long struct sctp_paramhdr *auth_chunks = NULL;
213327c0dabSXin Long struct sctp_paramhdr *auth_hmacs = NULL;
214327c0dabSXin Long struct sctp_supported_addrs_param sat;
215b14878ccSVlad Yasevich struct sctp_endpoint *ep = asoc->ep;
2161da177e4SLinus Torvalds struct sctp_chunk *retval = NULL;
2171da177e4SLinus Torvalds int num_types, addrs_len = 0;
218327c0dabSXin Long struct sctp_inithdr init;
219327c0dabSXin Long union sctp_params addrs;
2201da177e4SLinus Torvalds struct sctp_sock *sp;
22196b120b3SXin Long __u8 extensions[5];
222327c0dabSXin Long size_t chunksize;
223327c0dabSXin Long __be16 types[2];
224327c0dabSXin Long int num_ext = 0;
2251da177e4SLinus Torvalds
2261da177e4SLinus Torvalds /* RFC 2960 3.3.2 Initiation (INIT) (1)
2271da177e4SLinus Torvalds *
2281da177e4SLinus Torvalds * Note 1: The INIT chunks can contain multiple addresses that
2291da177e4SLinus Torvalds * can be IPv4 and/or IPv6 in any combination.
2301da177e4SLinus Torvalds */
2311da177e4SLinus Torvalds
2321da177e4SLinus Torvalds /* Convert the provided bind address list to raw format. */
2331da177e4SLinus Torvalds addrs = sctp_bind_addrs_to_raw(bp, &addrs_len, gfp);
2341da177e4SLinus Torvalds
2351da177e4SLinus Torvalds init.init_tag = htonl(asoc->c.my_vtag);
2361da177e4SLinus Torvalds init.a_rwnd = htonl(asoc->rwnd);
2371da177e4SLinus Torvalds init.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
2381da177e4SLinus Torvalds init.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
2391da177e4SLinus Torvalds init.initial_tsn = htonl(asoc->c.initial_tsn);
2401da177e4SLinus Torvalds
2411da177e4SLinus Torvalds /* How many address types are needed? */
2421da177e4SLinus Torvalds sp = sctp_sk(asoc->base.sk);
2431da177e4SLinus Torvalds num_types = sp->pf->supported_addrs(sp, types);
2441da177e4SLinus Torvalds
245a8170c35SWei Yongjun chunksize = sizeof(init) + addrs_len;
246e2f036a9SMarcelo Ricardo Leitner chunksize += SCTP_PAD4(SCTP_SAT_LEN(num_types));
2471b0b8114SXin Long
2481b0b8114SXin Long if (asoc->ep->ecn_enable)
2491da177e4SLinus Torvalds chunksize += sizeof(ecap_param);
2508ee4be37SVlad Yasevich
2511c134753SXin Long if (asoc->ep->prsctp_enable)
252036b579bSVlad Yasevich chunksize += sizeof(prsctp_param);
253036b579bSVlad Yasevich
254131a47e3SVlad Yasevich /* ADDIP: Section 4.2.7:
255131a47e3SVlad Yasevich * An implementation supporting this extension [ADDIP] MUST list
256131a47e3SVlad Yasevich * the ASCONF,the ASCONF-ACK, and the AUTH chunks in its INIT and
257131a47e3SVlad Yasevich * INIT-ACK parameters.
258131a47e3SVlad Yasevich */
2594e27428fSXin Long if (asoc->ep->asconf_enable) {
260131a47e3SVlad Yasevich extensions[num_ext] = SCTP_CID_ASCONF;
261131a47e3SVlad Yasevich extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
262131a47e3SVlad Yasevich num_ext += 2;
263131a47e3SVlad Yasevich }
264131a47e3SVlad Yasevich
265a96701fbSXin Long if (asoc->ep->reconf_enable) {
266c28445c3SXin Long extensions[num_ext] = SCTP_CID_RECONF;
267c28445c3SXin Long num_ext += 1;
268c28445c3SXin Long }
269c28445c3SXin Long
2706fc791eeSmalc if (sp->adaptation_ind)
2711da177e4SLinus Torvalds chunksize += sizeof(aiparam);
2726fc791eeSmalc
273e55f4b8bSXin Long if (asoc->ep->intl_enable) {
27496b120b3SXin Long extensions[num_ext] = SCTP_CID_I_DATA;
27596b120b3SXin Long num_ext += 1;
27696b120b3SXin Long }
27796b120b3SXin Long
2781da177e4SLinus Torvalds chunksize += vparam_len;
2791da177e4SLinus Torvalds
280730fc3d0SVlad Yasevich /* Account for AUTH related parameters */
281b14878ccSVlad Yasevich if (ep->auth_enable) {
282730fc3d0SVlad Yasevich /* Add random parameter length*/
283730fc3d0SVlad Yasevich chunksize += sizeof(asoc->c.auth_random);
284730fc3d0SVlad Yasevich
285730fc3d0SVlad Yasevich /* Add HMACS parameter length if any were defined */
2863c918704SXin Long auth_hmacs = (struct sctp_paramhdr *)asoc->c.auth_hmacs;
287730fc3d0SVlad Yasevich if (auth_hmacs->length)
288e2f036a9SMarcelo Ricardo Leitner chunksize += SCTP_PAD4(ntohs(auth_hmacs->length));
289730fc3d0SVlad Yasevich else
290730fc3d0SVlad Yasevich auth_hmacs = NULL;
291730fc3d0SVlad Yasevich
292730fc3d0SVlad Yasevich /* Add CHUNKS parameter length */
2933c918704SXin Long auth_chunks = (struct sctp_paramhdr *)asoc->c.auth_chunks;
294730fc3d0SVlad Yasevich if (auth_chunks->length)
295e2f036a9SMarcelo Ricardo Leitner chunksize += SCTP_PAD4(ntohs(auth_chunks->length));
296730fc3d0SVlad Yasevich else
2979baffaa6SVlad Yasevich auth_chunks = NULL;
298730fc3d0SVlad Yasevich
299730fc3d0SVlad Yasevich extensions[num_ext] = SCTP_CID_AUTH;
300730fc3d0SVlad Yasevich num_ext += 1;
301730fc3d0SVlad Yasevich }
302730fc3d0SVlad Yasevich
303131a47e3SVlad Yasevich /* If we have any extensions to report, account for that */
304131a47e3SVlad Yasevich if (num_ext)
30515328d9fSXin Long chunksize += SCTP_PAD4(sizeof(ext_param) + num_ext);
306131a47e3SVlad Yasevich
3071da177e4SLinus Torvalds /* RFC 2960 3.3.2 Initiation (INIT) (1)
3081da177e4SLinus Torvalds *
3091da177e4SLinus Torvalds * Note 3: An INIT chunk MUST NOT contain more than one Host
3101da177e4SLinus Torvalds * Name address parameter. Moreover, the sender of the INIT
3111da177e4SLinus Torvalds * MUST NOT combine any other address types with the Host Name
3121da177e4SLinus Torvalds * address in the INIT. The receiver of INIT MUST ignore any
3131da177e4SLinus Torvalds * other address types if the Host Name address parameter is
3141da177e4SLinus Torvalds * present in the received INIT chunk.
3151da177e4SLinus Torvalds *
3161da177e4SLinus Torvalds * PLEASE DO NOT FIXME [This version does not support Host Name.]
3171da177e4SLinus Torvalds */
3181da177e4SLinus Torvalds
319cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_INIT, 0, chunksize, gfp);
3201da177e4SLinus Torvalds if (!retval)
3211da177e4SLinus Torvalds goto nodata;
3221da177e4SLinus Torvalds
3231da177e4SLinus Torvalds retval->subh.init_hdr =
3241da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(init), &init);
3251da177e4SLinus Torvalds retval->param_hdr.v =
3261da177e4SLinus Torvalds sctp_addto_chunk(retval, addrs_len, addrs.v);
3271da177e4SLinus Torvalds
3281da177e4SLinus Torvalds /* RFC 2960 3.3.2 Initiation (INIT) (1)
3291da177e4SLinus Torvalds *
3301da177e4SLinus Torvalds * Note 4: This parameter, when present, specifies all the
3311da177e4SLinus Torvalds * address types the sending endpoint can support. The absence
3321da177e4SLinus Torvalds * of this parameter indicates that the sending endpoint can
3331da177e4SLinus Torvalds * support any address type.
3341da177e4SLinus Torvalds */
3351da177e4SLinus Torvalds sat.param_hdr.type = SCTP_PARAM_SUPPORTED_ADDRESS_TYPES;
3361da177e4SLinus Torvalds sat.param_hdr.length = htons(SCTP_SAT_LEN(num_types));
3371da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(sat), &sat);
3381da177e4SLinus Torvalds sctp_addto_chunk(retval, num_types * sizeof(__u16), &types);
3391da177e4SLinus Torvalds
3401b0b8114SXin Long if (asoc->ep->ecn_enable)
3411da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
342131a47e3SVlad Yasevich
3437aa1b54bSJoe Perches /* Add the supported extensions parameter. Be nice and add this
344131a47e3SVlad Yasevich * fist before addiding the parameters for the extensions themselves
345131a47e3SVlad Yasevich */
346131a47e3SVlad Yasevich if (num_ext) {
347131a47e3SVlad Yasevich ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
34815328d9fSXin Long ext_param.param_hdr.length = htons(sizeof(ext_param) + num_ext);
34915328d9fSXin Long sctp_addto_chunk(retval, sizeof(ext_param), &ext_param);
3508ee4be37SVlad Yasevich sctp_addto_param(retval, num_ext, extensions);
351131a47e3SVlad Yasevich }
352131a47e3SVlad Yasevich
3531c134753SXin Long if (asoc->ep->prsctp_enable)
3541da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
355131a47e3SVlad Yasevich
3566fc791eeSmalc if (sp->adaptation_ind) {
3570f3fffd8SIvan Skytte Jorgensen aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
3581da177e4SLinus Torvalds aiparam.param_hdr.length = htons(sizeof(aiparam));
3590f3fffd8SIvan Skytte Jorgensen aiparam.adaptation_ind = htonl(sp->adaptation_ind);
3601da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
3616fc791eeSmalc }
362131a47e3SVlad Yasevich
363730fc3d0SVlad Yasevich /* Add SCTP-AUTH chunks to the parameter list */
364b14878ccSVlad Yasevich if (ep->auth_enable) {
365730fc3d0SVlad Yasevich sctp_addto_chunk(retval, sizeof(asoc->c.auth_random),
366730fc3d0SVlad Yasevich asoc->c.auth_random);
367730fc3d0SVlad Yasevich if (auth_hmacs)
368730fc3d0SVlad Yasevich sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
369730fc3d0SVlad Yasevich auth_hmacs);
370730fc3d0SVlad Yasevich if (auth_chunks)
371730fc3d0SVlad Yasevich sctp_addto_chunk(retval, ntohs(auth_chunks->length),
372730fc3d0SVlad Yasevich auth_chunks);
373730fc3d0SVlad Yasevich }
3741da177e4SLinus Torvalds nodata:
3751da177e4SLinus Torvalds kfree(addrs.v);
3761da177e4SLinus Torvalds return retval;
3771da177e4SLinus Torvalds }
3781da177e4SLinus Torvalds
sctp_make_init_ack(const struct sctp_association * asoc,const struct sctp_chunk * chunk,gfp_t gfp,int unkparam_len)3791da177e4SLinus Torvalds struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
3801da177e4SLinus Torvalds const struct sctp_chunk *chunk,
381dd0fc66fSAl Viro gfp_t gfp, int unkparam_len)
3821da177e4SLinus Torvalds {
383327c0dabSXin Long struct sctp_supported_ext_param ext_param;
384327c0dabSXin Long struct sctp_adaptation_ind_param aiparam;
385327c0dabSXin Long struct sctp_paramhdr *auth_chunks = NULL;
386327c0dabSXin Long struct sctp_paramhdr *auth_random = NULL;
387327c0dabSXin Long struct sctp_paramhdr *auth_hmacs = NULL;
388327c0dabSXin Long struct sctp_chunk *retval = NULL;
389327c0dabSXin Long struct sctp_cookie_param *cookie;
3904ae70c08SXin Long struct sctp_inithdr initack;
3911da177e4SLinus Torvalds union sctp_params addrs;
3926fc791eeSmalc struct sctp_sock *sp;
39396b120b3SXin Long __u8 extensions[5];
394327c0dabSXin Long size_t chunksize;
395327c0dabSXin Long int num_ext = 0;
396327c0dabSXin Long int cookie_len;
397327c0dabSXin Long int addrs_len;
3981da177e4SLinus Torvalds
3991da177e4SLinus Torvalds /* Note: there may be no addresses to embed. */
4001da177e4SLinus Torvalds addrs = sctp_bind_addrs_to_raw(&asoc->base.bind_addr, &addrs_len, gfp);
4011da177e4SLinus Torvalds
4021da177e4SLinus Torvalds initack.init_tag = htonl(asoc->c.my_vtag);
4031da177e4SLinus Torvalds initack.a_rwnd = htonl(asoc->rwnd);
4041da177e4SLinus Torvalds initack.num_outbound_streams = htons(asoc->c.sinit_num_ostreams);
4051da177e4SLinus Torvalds initack.num_inbound_streams = htons(asoc->c.sinit_max_instreams);
4061da177e4SLinus Torvalds initack.initial_tsn = htonl(asoc->c.initial_tsn);
4071da177e4SLinus Torvalds
4081da177e4SLinus Torvalds /* FIXME: We really ought to build the cookie right
4091da177e4SLinus Torvalds * into the packet instead of allocating more fresh memory.
4101da177e4SLinus Torvalds */
4111da177e4SLinus Torvalds cookie = sctp_pack_cookie(asoc->ep, asoc, chunk, &cookie_len,
4121da177e4SLinus Torvalds addrs.v, addrs_len);
4131da177e4SLinus Torvalds if (!cookie)
4141da177e4SLinus Torvalds goto nomem_cookie;
4151da177e4SLinus Torvalds
4161da177e4SLinus Torvalds /* Calculate the total size of allocation, include the reserved
4171da177e4SLinus Torvalds * space for reporting unknown parameters if it is specified.
4181da177e4SLinus Torvalds */
4196fc791eeSmalc sp = sctp_sk(asoc->base.sk);
4201da177e4SLinus Torvalds chunksize = sizeof(initack) + addrs_len + cookie_len + unkparam_len;
4211da177e4SLinus Torvalds
4221da177e4SLinus Torvalds /* Tell peer that we'll do ECN only if peer advertised such cap. */
4231da177e4SLinus Torvalds if (asoc->peer.ecn_capable)
4241da177e4SLinus Torvalds chunksize += sizeof(ecap_param);
4251da177e4SLinus Torvalds
4265ffad5acSWei Yongjun if (asoc->peer.prsctp_capable)
427036b579bSVlad Yasevich chunksize += sizeof(prsctp_param);
428036b579bSVlad Yasevich
4295ffad5acSWei Yongjun if (asoc->peer.asconf_capable) {
430131a47e3SVlad Yasevich extensions[num_ext] = SCTP_CID_ASCONF;
431131a47e3SVlad Yasevich extensions[num_ext+1] = SCTP_CID_ASCONF_ACK;
432131a47e3SVlad Yasevich num_ext += 2;
433131a47e3SVlad Yasevich }
434131a47e3SVlad Yasevich
435c28445c3SXin Long if (asoc->peer.reconf_capable) {
436c28445c3SXin Long extensions[num_ext] = SCTP_CID_RECONF;
437c28445c3SXin Long num_ext += 1;
438c28445c3SXin Long }
439c28445c3SXin Long
4406fc791eeSmalc if (sp->adaptation_ind)
4411da177e4SLinus Torvalds chunksize += sizeof(aiparam);
4421da177e4SLinus Torvalds
443da1f6d4dSXin Long if (asoc->peer.intl_capable) {
44496b120b3SXin Long extensions[num_ext] = SCTP_CID_I_DATA;
44596b120b3SXin Long num_ext += 1;
44696b120b3SXin Long }
44796b120b3SXin Long
448730fc3d0SVlad Yasevich if (asoc->peer.auth_capable) {
4493c918704SXin Long auth_random = (struct sctp_paramhdr *)asoc->c.auth_random;
450730fc3d0SVlad Yasevich chunksize += ntohs(auth_random->length);
451730fc3d0SVlad Yasevich
4523c918704SXin Long auth_hmacs = (struct sctp_paramhdr *)asoc->c.auth_hmacs;
453730fc3d0SVlad Yasevich if (auth_hmacs->length)
454e2f036a9SMarcelo Ricardo Leitner chunksize += SCTP_PAD4(ntohs(auth_hmacs->length));
455730fc3d0SVlad Yasevich else
456730fc3d0SVlad Yasevich auth_hmacs = NULL;
457730fc3d0SVlad Yasevich
4583c918704SXin Long auth_chunks = (struct sctp_paramhdr *)asoc->c.auth_chunks;
459730fc3d0SVlad Yasevich if (auth_chunks->length)
460e2f036a9SMarcelo Ricardo Leitner chunksize += SCTP_PAD4(ntohs(auth_chunks->length));
461730fc3d0SVlad Yasevich else
462730fc3d0SVlad Yasevich auth_chunks = NULL;
463730fc3d0SVlad Yasevich
464730fc3d0SVlad Yasevich extensions[num_ext] = SCTP_CID_AUTH;
465730fc3d0SVlad Yasevich num_ext += 1;
466730fc3d0SVlad Yasevich }
467730fc3d0SVlad Yasevich
4688ee4be37SVlad Yasevich if (num_ext)
46915328d9fSXin Long chunksize += SCTP_PAD4(sizeof(ext_param) + num_ext);
4708ee4be37SVlad Yasevich
4711da177e4SLinus Torvalds /* Now allocate and fill out the chunk. */
472cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_INIT_ACK, 0, chunksize, gfp);
4731da177e4SLinus Torvalds if (!retval)
4741da177e4SLinus Torvalds goto nomem_chunk;
4751da177e4SLinus Torvalds
476b99a4d53SDan Carpenter /* RFC 2960 6.4 Multi-homed SCTP Endpoints
477b99a4d53SDan Carpenter *
478b99a4d53SDan Carpenter * An endpoint SHOULD transmit reply chunks (e.g., SACK,
479b99a4d53SDan Carpenter * HEARTBEAT ACK, * etc.) to the same destination transport
480b99a4d53SDan Carpenter * address from which it received the DATA or control chunk
481b99a4d53SDan Carpenter * to which it is replying.
482b99a4d53SDan Carpenter *
483b99a4d53SDan Carpenter * [INIT ACK back to where the INIT came from.]
4841da177e4SLinus Torvalds */
4854ff40b86SXin Long if (chunk->transport)
4864ff40b86SXin Long retval->transport =
4874ff40b86SXin Long sctp_assoc_lookup_paddr(asoc,
4884ff40b86SXin Long &chunk->transport->ipaddr);
489b99a4d53SDan Carpenter
4901da177e4SLinus Torvalds retval->subh.init_hdr =
4911da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(initack), &initack);
4921da177e4SLinus Torvalds retval->param_hdr.v = sctp_addto_chunk(retval, addrs_len, addrs.v);
4931da177e4SLinus Torvalds sctp_addto_chunk(retval, cookie_len, cookie);
4941da177e4SLinus Torvalds if (asoc->peer.ecn_capable)
4951da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
496131a47e3SVlad Yasevich if (num_ext) {
497131a47e3SVlad Yasevich ext_param.param_hdr.type = SCTP_PARAM_SUPPORTED_EXT;
49815328d9fSXin Long ext_param.param_hdr.length = htons(sizeof(ext_param) + num_ext);
49915328d9fSXin Long sctp_addto_chunk(retval, sizeof(ext_param), &ext_param);
5008ee4be37SVlad Yasevich sctp_addto_param(retval, num_ext, extensions);
501131a47e3SVlad Yasevich }
5021da177e4SLinus Torvalds if (asoc->peer.prsctp_capable)
5031da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
5041da177e4SLinus Torvalds
5056fc791eeSmalc if (sp->adaptation_ind) {
5060f3fffd8SIvan Skytte Jorgensen aiparam.param_hdr.type = SCTP_PARAM_ADAPTATION_LAYER_IND;
5071da177e4SLinus Torvalds aiparam.param_hdr.length = htons(sizeof(aiparam));
5086fc791eeSmalc aiparam.adaptation_ind = htonl(sp->adaptation_ind);
5091da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
5106fc791eeSmalc }
5111da177e4SLinus Torvalds
512730fc3d0SVlad Yasevich if (asoc->peer.auth_capable) {
513730fc3d0SVlad Yasevich sctp_addto_chunk(retval, ntohs(auth_random->length),
514730fc3d0SVlad Yasevich auth_random);
515730fc3d0SVlad Yasevich if (auth_hmacs)
516730fc3d0SVlad Yasevich sctp_addto_chunk(retval, ntohs(auth_hmacs->length),
517730fc3d0SVlad Yasevich auth_hmacs);
518730fc3d0SVlad Yasevich if (auth_chunks)
519730fc3d0SVlad Yasevich sctp_addto_chunk(retval, ntohs(auth_chunks->length),
520730fc3d0SVlad Yasevich auth_chunks);
521730fc3d0SVlad Yasevich }
522730fc3d0SVlad Yasevich
5231da177e4SLinus Torvalds /* We need to remove the const qualifier at this point. */
5241da177e4SLinus Torvalds retval->asoc = (struct sctp_association *) asoc;
5251da177e4SLinus Torvalds
5261da177e4SLinus Torvalds nomem_chunk:
5271da177e4SLinus Torvalds kfree(cookie);
5281da177e4SLinus Torvalds nomem_cookie:
5291da177e4SLinus Torvalds kfree(addrs.v);
5301da177e4SLinus Torvalds return retval;
5311da177e4SLinus Torvalds }
5321da177e4SLinus Torvalds
5331da177e4SLinus Torvalds /* 3.3.11 Cookie Echo (COOKIE ECHO) (10):
5341da177e4SLinus Torvalds *
5351da177e4SLinus Torvalds * This chunk is used only during the initialization of an association.
5361da177e4SLinus Torvalds * It is sent by the initiator of an association to its peer to complete
5371da177e4SLinus Torvalds * the initialization process. This chunk MUST precede any DATA chunk
5381da177e4SLinus Torvalds * sent within the association, but MAY be bundled with one or more DATA
5391da177e4SLinus Torvalds * chunks in the same packet.
5401da177e4SLinus Torvalds *
5411da177e4SLinus Torvalds * 0 1 2 3
5421da177e4SLinus Torvalds * 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
5431da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
5441da177e4SLinus Torvalds * | Type = 10 |Chunk Flags | Length |
5451da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
5461da177e4SLinus Torvalds * / Cookie /
5471da177e4SLinus Torvalds * \ \
5481da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
5491da177e4SLinus Torvalds *
5501da177e4SLinus Torvalds * Chunk Flags: 8 bit
5511da177e4SLinus Torvalds *
5521da177e4SLinus Torvalds * Set to zero on transmit and ignored on receipt.
5531da177e4SLinus Torvalds *
5541da177e4SLinus Torvalds * Length: 16 bits (unsigned integer)
5551da177e4SLinus Torvalds *
5561da177e4SLinus Torvalds * Set to the size of the chunk in bytes, including the 4 bytes of
5571da177e4SLinus Torvalds * the chunk header and the size of the Cookie.
5581da177e4SLinus Torvalds *
5591da177e4SLinus Torvalds * Cookie: variable size
5601da177e4SLinus Torvalds *
5611da177e4SLinus Torvalds * This field must contain the exact cookie received in the
5621da177e4SLinus Torvalds * State Cookie parameter from the previous INIT ACK.
5631da177e4SLinus Torvalds *
5641da177e4SLinus Torvalds * An implementation SHOULD make the cookie as small as possible
5651da177e4SLinus Torvalds * to insure interoperability.
5661da177e4SLinus Torvalds */
sctp_make_cookie_echo(const struct sctp_association * asoc,const struct sctp_chunk * chunk)5671da177e4SLinus Torvalds struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *asoc,
5681da177e4SLinus Torvalds const struct sctp_chunk *chunk)
5691da177e4SLinus Torvalds {
5701da177e4SLinus Torvalds struct sctp_chunk *retval;
5711da177e4SLinus Torvalds int cookie_len;
572327c0dabSXin Long void *cookie;
5731da177e4SLinus Torvalds
5741da177e4SLinus Torvalds cookie = asoc->peer.cookie;
5751da177e4SLinus Torvalds cookie_len = asoc->peer.cookie_len;
5761da177e4SLinus Torvalds
5771da177e4SLinus Torvalds /* Build a cookie echo chunk. */
578cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ECHO, 0,
579cea8768fSMarcelo Ricardo Leitner cookie_len, GFP_ATOMIC);
5801da177e4SLinus Torvalds if (!retval)
5811da177e4SLinus Torvalds goto nodata;
5821da177e4SLinus Torvalds retval->subh.cookie_hdr =
5831da177e4SLinus Torvalds sctp_addto_chunk(retval, cookie_len, cookie);
5841da177e4SLinus Torvalds
5851da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
5861da177e4SLinus Torvalds *
5871da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
5881da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
5891da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
5901da177e4SLinus Torvalds * to which it is replying.
5911da177e4SLinus Torvalds *
5921da177e4SLinus Torvalds * [COOKIE ECHO back to where the INIT ACK came from.]
5931da177e4SLinus Torvalds */
5941da177e4SLinus Torvalds if (chunk)
5951da177e4SLinus Torvalds retval->transport = chunk->transport;
5961da177e4SLinus Torvalds
5971da177e4SLinus Torvalds nodata:
5981da177e4SLinus Torvalds return retval;
5991da177e4SLinus Torvalds }
6001da177e4SLinus Torvalds
6011da177e4SLinus Torvalds /* 3.3.12 Cookie Acknowledgement (COOKIE ACK) (11):
6021da177e4SLinus Torvalds *
6031da177e4SLinus Torvalds * This chunk is used only during the initialization of an
6041da177e4SLinus Torvalds * association. It is used to acknowledge the receipt of a COOKIE
6051da177e4SLinus Torvalds * ECHO chunk. This chunk MUST precede any DATA or SACK chunk sent
6061da177e4SLinus Torvalds * within the association, but MAY be bundled with one or more DATA
6071da177e4SLinus Torvalds * chunks or SACK chunk in the same SCTP packet.
6081da177e4SLinus Torvalds *
6091da177e4SLinus Torvalds * 0 1 2 3
6101da177e4SLinus Torvalds * 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
6111da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6121da177e4SLinus Torvalds * | Type = 11 |Chunk Flags | Length = 4 |
6131da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6141da177e4SLinus Torvalds *
6151da177e4SLinus Torvalds * Chunk Flags: 8 bits
6161da177e4SLinus Torvalds *
6171da177e4SLinus Torvalds * Set to zero on transmit and ignored on receipt.
6181da177e4SLinus Torvalds */
sctp_make_cookie_ack(const struct sctp_association * asoc,const struct sctp_chunk * chunk)6191da177e4SLinus Torvalds struct sctp_chunk *sctp_make_cookie_ack(const struct sctp_association *asoc,
6201da177e4SLinus Torvalds const struct sctp_chunk *chunk)
6211da177e4SLinus Torvalds {
6221da177e4SLinus Torvalds struct sctp_chunk *retval;
6231da177e4SLinus Torvalds
624cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ACK, 0, 0, GFP_ATOMIC);
6251da177e4SLinus Torvalds
6261da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
6271da177e4SLinus Torvalds *
6281da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
6291da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
6301da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
6311da177e4SLinus Torvalds * to which it is replying.
6321da177e4SLinus Torvalds *
6331da177e4SLinus Torvalds * [COOKIE ACK back to where the COOKIE ECHO came from.]
6341da177e4SLinus Torvalds */
6354ff40b86SXin Long if (retval && chunk && chunk->transport)
6364ff40b86SXin Long retval->transport =
6374ff40b86SXin Long sctp_assoc_lookup_paddr(asoc,
6384ff40b86SXin Long &chunk->transport->ipaddr);
6391da177e4SLinus Torvalds
6401da177e4SLinus Torvalds return retval;
6411da177e4SLinus Torvalds }
6421da177e4SLinus Torvalds
6431da177e4SLinus Torvalds /*
6441da177e4SLinus Torvalds * Appendix A: Explicit Congestion Notification:
6451da177e4SLinus Torvalds * CWR:
6461da177e4SLinus Torvalds *
6471da177e4SLinus Torvalds * RFC 2481 details a specific bit for a sender to send in the header of
6481da177e4SLinus Torvalds * its next outbound TCP segment to indicate to its peer that it has
6491da177e4SLinus Torvalds * reduced its congestion window. This is termed the CWR bit. For
6501da177e4SLinus Torvalds * SCTP the same indication is made by including the CWR chunk.
6511da177e4SLinus Torvalds * This chunk contains one data element, i.e. the TSN number that
6521da177e4SLinus Torvalds * was sent in the ECNE chunk. This element represents the lowest
6531da177e4SLinus Torvalds * TSN number in the datagram that was originally marked with the
6541da177e4SLinus Torvalds * CE bit.
6551da177e4SLinus Torvalds *
6561da177e4SLinus Torvalds * 0 1 2 3
6571da177e4SLinus Torvalds * 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
6581da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6591da177e4SLinus Torvalds * | Chunk Type=13 | Flags=00000000| Chunk Length = 8 |
6601da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6611da177e4SLinus Torvalds * | Lowest TSN Number |
6621da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6631da177e4SLinus Torvalds *
6641da177e4SLinus Torvalds * Note: The CWR is considered a Control chunk.
6651da177e4SLinus Torvalds */
sctp_make_cwr(const struct sctp_association * asoc,const __u32 lowest_tsn,const struct sctp_chunk * chunk)6661da177e4SLinus Torvalds struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc,
6671da177e4SLinus Torvalds const __u32 lowest_tsn,
6681da177e4SLinus Torvalds const struct sctp_chunk *chunk)
6691da177e4SLinus Torvalds {
6701da177e4SLinus Torvalds struct sctp_chunk *retval;
67165f77105SXin Long struct sctp_cwrhdr cwr;
6721da177e4SLinus Torvalds
6731da177e4SLinus Torvalds cwr.lowest_tsn = htonl(lowest_tsn);
674072017b4SVlad Yasevich retval = sctp_make_control(asoc, SCTP_CID_ECN_CWR, 0,
67565f77105SXin Long sizeof(cwr), GFP_ATOMIC);
6761da177e4SLinus Torvalds
6771da177e4SLinus Torvalds if (!retval)
6781da177e4SLinus Torvalds goto nodata;
6791da177e4SLinus Torvalds
6801da177e4SLinus Torvalds retval->subh.ecn_cwr_hdr =
6811da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(cwr), &cwr);
6821da177e4SLinus Torvalds
6831da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
6841da177e4SLinus Torvalds *
6851da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
6861da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
6871da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
6881da177e4SLinus Torvalds * to which it is replying.
6891da177e4SLinus Torvalds *
6901da177e4SLinus Torvalds * [Report a reduced congestion window back to where the ECNE
6911da177e4SLinus Torvalds * came from.]
6921da177e4SLinus Torvalds */
6931da177e4SLinus Torvalds if (chunk)
6941da177e4SLinus Torvalds retval->transport = chunk->transport;
6951da177e4SLinus Torvalds
6961da177e4SLinus Torvalds nodata:
6971da177e4SLinus Torvalds return retval;
6981da177e4SLinus Torvalds }
6991da177e4SLinus Torvalds
7001da177e4SLinus Torvalds /* Make an ECNE chunk. This is a congestion experienced report. */
sctp_make_ecne(const struct sctp_association * asoc,const __u32 lowest_tsn)7011da177e4SLinus Torvalds struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc,
7021da177e4SLinus Torvalds const __u32 lowest_tsn)
7031da177e4SLinus Torvalds {
7041da177e4SLinus Torvalds struct sctp_chunk *retval;
7051fb6d83bSXin Long struct sctp_ecnehdr ecne;
7061da177e4SLinus Torvalds
7071da177e4SLinus Torvalds ecne.lowest_tsn = htonl(lowest_tsn);
708072017b4SVlad Yasevich retval = sctp_make_control(asoc, SCTP_CID_ECN_ECNE, 0,
7091fb6d83bSXin Long sizeof(ecne), GFP_ATOMIC);
7101da177e4SLinus Torvalds if (!retval)
7111da177e4SLinus Torvalds goto nodata;
7121da177e4SLinus Torvalds retval->subh.ecne_hdr =
7131da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(ecne), &ecne);
7141da177e4SLinus Torvalds
7151da177e4SLinus Torvalds nodata:
7161da177e4SLinus Torvalds return retval;
7171da177e4SLinus Torvalds }
7181da177e4SLinus Torvalds
7191da177e4SLinus Torvalds /* Make a DATA chunk for the given association from the provided
7201da177e4SLinus Torvalds * parameters. However, do not populate the data payload.
7211da177e4SLinus Torvalds */
sctp_make_datafrag_empty(const struct sctp_association * asoc,const struct sctp_sndrcvinfo * sinfo,int len,__u8 flags,gfp_t gfp)7220c3f6f65SXin Long struct sctp_chunk *sctp_make_datafrag_empty(const struct sctp_association *asoc,
7231da177e4SLinus Torvalds const struct sctp_sndrcvinfo *sinfo,
7240c3f6f65SXin Long int len, __u8 flags, gfp_t gfp)
7251da177e4SLinus Torvalds {
7261da177e4SLinus Torvalds struct sctp_chunk *retval;
7271da177e4SLinus Torvalds struct sctp_datahdr dp;
7281da177e4SLinus Torvalds
7291da177e4SLinus Torvalds /* We assign the TSN as LATE as possible, not here when
7301da177e4SLinus Torvalds * creating the chunk.
7311da177e4SLinus Torvalds */
7320c3f6f65SXin Long memset(&dp, 0, sizeof(dp));
7331da177e4SLinus Torvalds dp.ppid = sinfo->sinfo_ppid;
7340c3f6f65SXin Long dp.stream = htons(sinfo->sinfo_stream);
7351da177e4SLinus Torvalds
7361da177e4SLinus Torvalds /* Set the flags for an unordered send. */
7370c3f6f65SXin Long if (sinfo->sinfo_flags & SCTP_UNORDERED)
7381da177e4SLinus Torvalds flags |= SCTP_DATA_UNORDERED;
7391da177e4SLinus Torvalds
7400c3f6f65SXin Long retval = sctp_make_data(asoc, flags, sizeof(dp) + len, gfp);
7411da177e4SLinus Torvalds if (!retval)
7420c3f6f65SXin Long return NULL;
7431da177e4SLinus Torvalds
7441da177e4SLinus Torvalds retval->subh.data_hdr = sctp_addto_chunk(retval, sizeof(dp), &dp);
7451da177e4SLinus Torvalds memcpy(&retval->sinfo, sinfo, sizeof(struct sctp_sndrcvinfo));
7461da177e4SLinus Torvalds
7471da177e4SLinus Torvalds return retval;
7481da177e4SLinus Torvalds }
7491da177e4SLinus Torvalds
7501da177e4SLinus Torvalds /* Create a selective ackowledgement (SACK) for the given
7511da177e4SLinus Torvalds * association. This reports on which TSN's we've seen to date,
7521da177e4SLinus Torvalds * including duplicates and gaps.
7531da177e4SLinus Torvalds */
sctp_make_sack(struct sctp_association * asoc)75447b3ba51SMarcelo Ricardo Leitner struct sctp_chunk *sctp_make_sack(struct sctp_association *asoc)
7551da177e4SLinus Torvalds {
756327c0dabSXin Long struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
757327c0dabSXin Long struct sctp_gap_ack_block gabs[SCTP_MAX_GABS];
758327c0dabSXin Long __u16 num_gabs, num_dup_tsns;
759327c0dabSXin Long struct sctp_transport *trans;
7601da177e4SLinus Torvalds struct sctp_chunk *retval;
7611da177e4SLinus Torvalds struct sctp_sackhdr sack;
7621da177e4SLinus Torvalds __u32 ctsn;
763327c0dabSXin Long int len;
7641da177e4SLinus Torvalds
76502015180SVlad Yasevich memset(gabs, 0, sizeof(gabs));
7661da177e4SLinus Torvalds ctsn = sctp_tsnmap_get_ctsn(map);
767bb33381dSDaniel Borkmann
768bb33381dSDaniel Borkmann pr_debug("%s: sackCTSNAck sent:0x%x\n", __func__, ctsn);
7691da177e4SLinus Torvalds
7701da177e4SLinus Torvalds /* How much room is needed in the chunk? */
77102015180SVlad Yasevich num_gabs = sctp_tsnmap_num_gabs(map, gabs);
7721da177e4SLinus Torvalds num_dup_tsns = sctp_tsnmap_num_dups(map);
7731da177e4SLinus Torvalds
7741da177e4SLinus Torvalds /* Initialize the SACK header. */
7751da177e4SLinus Torvalds sack.cum_tsn_ack = htonl(ctsn);
7761da177e4SLinus Torvalds sack.a_rwnd = htonl(asoc->a_rwnd);
7771da177e4SLinus Torvalds sack.num_gap_ack_blocks = htons(num_gabs);
7781da177e4SLinus Torvalds sack.num_dup_tsns = htons(num_dup_tsns);
7791da177e4SLinus Torvalds
7801da177e4SLinus Torvalds len = sizeof(sack)
7811da177e4SLinus Torvalds + sizeof(struct sctp_gap_ack_block) * num_gabs
7821da177e4SLinus Torvalds + sizeof(__u32) * num_dup_tsns;
7831da177e4SLinus Torvalds
7841da177e4SLinus Torvalds /* Create the chunk. */
785cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_SACK, 0, len, GFP_ATOMIC);
7861da177e4SLinus Torvalds if (!retval)
7871da177e4SLinus Torvalds goto nodata;
7881da177e4SLinus Torvalds
7891da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
7901da177e4SLinus Torvalds *
7911da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
7921da177e4SLinus Torvalds * HEARTBEAT ACK, etc.) to the same destination transport
7931da177e4SLinus Torvalds * address from which it received the DATA or control chunk to
7941da177e4SLinus Torvalds * which it is replying. This rule should also be followed if
7951da177e4SLinus Torvalds * the endpoint is bundling DATA chunks together with the
7961da177e4SLinus Torvalds * reply chunk.
7971da177e4SLinus Torvalds *
7981da177e4SLinus Torvalds * However, when acknowledging multiple DATA chunks received
7991da177e4SLinus Torvalds * in packets from different source addresses in a single
8001da177e4SLinus Torvalds * SACK, the SACK chunk may be transmitted to one of the
8011da177e4SLinus Torvalds * destination transport addresses from which the DATA or
8021da177e4SLinus Torvalds * control chunks being acknowledged were received.
8031da177e4SLinus Torvalds *
8041da177e4SLinus Torvalds * [BUG: We do not implement the following paragraph.
8051da177e4SLinus Torvalds * Perhaps we should remember the last transport we used for a
8061da177e4SLinus Torvalds * SACK and avoid that (if possible) if we have seen any
8071da177e4SLinus Torvalds * duplicates. --piggy]
8081da177e4SLinus Torvalds *
8091da177e4SLinus Torvalds * When a receiver of a duplicate DATA chunk sends a SACK to a
8101da177e4SLinus Torvalds * multi- homed endpoint it MAY be beneficial to vary the
8111da177e4SLinus Torvalds * destination address and not use the source address of the
8121da177e4SLinus Torvalds * DATA chunk. The reason being that receiving a duplicate
8131da177e4SLinus Torvalds * from a multi-homed endpoint might indicate that the return
8141da177e4SLinus Torvalds * path (as specified in the source address of the DATA chunk)
8151da177e4SLinus Torvalds * for the SACK is broken.
8161da177e4SLinus Torvalds *
8171da177e4SLinus Torvalds * [Send to the address from which we last received a DATA chunk.]
8181da177e4SLinus Torvalds */
8191da177e4SLinus Torvalds retval->transport = asoc->peer.last_data_from;
8201da177e4SLinus Torvalds
8211da177e4SLinus Torvalds retval->subh.sack_hdr =
8221da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(sack), &sack);
8231da177e4SLinus Torvalds
8241da177e4SLinus Torvalds /* Add the gap ack block information. */
8251da177e4SLinus Torvalds if (num_gabs)
8261da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(__u32) * num_gabs,
82702015180SVlad Yasevich gabs);
8281da177e4SLinus Torvalds
8291da177e4SLinus Torvalds /* Add the duplicate TSN information. */
830196d6759SMichele Baldessari if (num_dup_tsns) {
83147b3ba51SMarcelo Ricardo Leitner asoc->stats.idupchunks += num_dup_tsns;
8321da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(__u32) * num_dup_tsns,
8331da177e4SLinus Torvalds sctp_tsnmap_get_dups(map));
834196d6759SMichele Baldessari }
8354244854dSNeil Horman /* Once we have a sack generated, check to see what our sack
8364244854dSNeil Horman * generation is, if its 0, reset the transports to 0, and reset
8374244854dSNeil Horman * the association generation to 1
8384244854dSNeil Horman *
8394244854dSNeil Horman * The idea is that zero is never used as a valid generation for the
8404244854dSNeil Horman * association so no transport will match after a wrap event like this,
8414244854dSNeil Horman * Until the next sack
8424244854dSNeil Horman */
84347b3ba51SMarcelo Ricardo Leitner if (++asoc->peer.sack_generation == 0) {
8444244854dSNeil Horman list_for_each_entry(trans, &asoc->peer.transport_addr_list,
8454244854dSNeil Horman transports)
8464244854dSNeil Horman trans->sack_generation = 0;
84747b3ba51SMarcelo Ricardo Leitner asoc->peer.sack_generation = 1;
8484244854dSNeil Horman }
8491da177e4SLinus Torvalds nodata:
8501da177e4SLinus Torvalds return retval;
8511da177e4SLinus Torvalds }
8521da177e4SLinus Torvalds
8531da177e4SLinus Torvalds /* Make a SHUTDOWN chunk. */
sctp_make_shutdown(const struct sctp_association * asoc,const struct sctp_chunk * chunk)8541da177e4SLinus Torvalds struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,
8551da177e4SLinus Torvalds const struct sctp_chunk *chunk)
8561da177e4SLinus Torvalds {
857e61e4055SXin Long struct sctp_shutdownhdr shut;
8581da177e4SLinus Torvalds struct sctp_chunk *retval;
8591da177e4SLinus Torvalds __u32 ctsn;
8601da177e4SLinus Torvalds
8611da177e4SLinus Torvalds ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
8621da177e4SLinus Torvalds shut.cum_tsn_ack = htonl(ctsn);
8631da177e4SLinus Torvalds
864072017b4SVlad Yasevich retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN, 0,
865e61e4055SXin Long sizeof(shut), GFP_ATOMIC);
8661da177e4SLinus Torvalds if (!retval)
8671da177e4SLinus Torvalds goto nodata;
8681da177e4SLinus Torvalds
8691da177e4SLinus Torvalds retval->subh.shutdown_hdr =
8701da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(shut), &shut);
8711da177e4SLinus Torvalds
8721da177e4SLinus Torvalds if (chunk)
8731da177e4SLinus Torvalds retval->transport = chunk->transport;
8741da177e4SLinus Torvalds nodata:
8751da177e4SLinus Torvalds return retval;
8761da177e4SLinus Torvalds }
8771da177e4SLinus Torvalds
sctp_make_shutdown_ack(const struct sctp_association * asoc,const struct sctp_chunk * chunk)8781da177e4SLinus Torvalds struct sctp_chunk *sctp_make_shutdown_ack(const struct sctp_association *asoc,
8791da177e4SLinus Torvalds const struct sctp_chunk *chunk)
8801da177e4SLinus Torvalds {
8811da177e4SLinus Torvalds struct sctp_chunk *retval;
8821da177e4SLinus Torvalds
883cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0,
884cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
8851da177e4SLinus Torvalds
8861da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
8871da177e4SLinus Torvalds *
8881da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
8891da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
8901da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
8911da177e4SLinus Torvalds * to which it is replying.
8921da177e4SLinus Torvalds *
8931da177e4SLinus Torvalds * [ACK back to where the SHUTDOWN came from.]
8941da177e4SLinus Torvalds */
8951da177e4SLinus Torvalds if (retval && chunk)
8961da177e4SLinus Torvalds retval->transport = chunk->transport;
8971da177e4SLinus Torvalds
8981da177e4SLinus Torvalds return retval;
8991da177e4SLinus Torvalds }
9001da177e4SLinus Torvalds
sctp_make_shutdown_complete(const struct sctp_association * asoc,const struct sctp_chunk * chunk)9011da177e4SLinus Torvalds struct sctp_chunk *sctp_make_shutdown_complete(
9021da177e4SLinus Torvalds const struct sctp_association *asoc,
9031da177e4SLinus Torvalds const struct sctp_chunk *chunk)
9041da177e4SLinus Torvalds {
9051da177e4SLinus Torvalds struct sctp_chunk *retval;
9061da177e4SLinus Torvalds __u8 flags = 0;
9071da177e4SLinus Torvalds
908047a2428SJerome Forissier /* Set the T-bit if we have no association (vtag will be
909047a2428SJerome Forissier * reflected)
910047a2428SJerome Forissier */
9111da177e4SLinus Torvalds flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
9121da177e4SLinus Torvalds
913cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags,
914cea8768fSMarcelo Ricardo Leitner 0, GFP_ATOMIC);
9151da177e4SLinus Torvalds
9161da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
9171da177e4SLinus Torvalds *
9181da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
9191da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
9201da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
9211da177e4SLinus Torvalds * to which it is replying.
9221da177e4SLinus Torvalds *
9231da177e4SLinus Torvalds * [Report SHUTDOWN COMPLETE back to where the SHUTDOWN ACK
9241da177e4SLinus Torvalds * came from.]
9251da177e4SLinus Torvalds */
9261da177e4SLinus Torvalds if (retval && chunk)
9271da177e4SLinus Torvalds retval->transport = chunk->transport;
9281da177e4SLinus Torvalds
9291da177e4SLinus Torvalds return retval;
9301da177e4SLinus Torvalds }
9311da177e4SLinus Torvalds
9321da177e4SLinus Torvalds /* Create an ABORT. Note that we set the T bit if we have no
933047a2428SJerome Forissier * association, except when responding to an INIT (sctpimpguide 2.41).
9341da177e4SLinus Torvalds */
sctp_make_abort(const struct sctp_association * asoc,const struct sctp_chunk * chunk,const size_t hint)9351da177e4SLinus Torvalds struct sctp_chunk *sctp_make_abort(const struct sctp_association *asoc,
9361da177e4SLinus Torvalds const struct sctp_chunk *chunk,
9371da177e4SLinus Torvalds const size_t hint)
9381da177e4SLinus Torvalds {
9391da177e4SLinus Torvalds struct sctp_chunk *retval;
9401da177e4SLinus Torvalds __u8 flags = 0;
9411da177e4SLinus Torvalds
942047a2428SJerome Forissier /* Set the T-bit if we have no association and 'chunk' is not
943047a2428SJerome Forissier * an INIT (vtag will be reflected).
944047a2428SJerome Forissier */
945047a2428SJerome Forissier if (!asoc) {
946047a2428SJerome Forissier if (chunk && chunk->chunk_hdr &&
947047a2428SJerome Forissier chunk->chunk_hdr->type == SCTP_CID_INIT)
948047a2428SJerome Forissier flags = 0;
949047a2428SJerome Forissier else
950047a2428SJerome Forissier flags = SCTP_CHUNK_FLAG_T;
951047a2428SJerome Forissier }
9521da177e4SLinus Torvalds
953cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_ABORT, flags, hint,
954cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
9551da177e4SLinus Torvalds
9561da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
9571da177e4SLinus Torvalds *
9581da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
9591da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
9601da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
9611da177e4SLinus Torvalds * to which it is replying.
9621da177e4SLinus Torvalds *
9631da177e4SLinus Torvalds * [ABORT back to where the offender came from.]
9641da177e4SLinus Torvalds */
9651da177e4SLinus Torvalds if (retval && chunk)
9661da177e4SLinus Torvalds retval->transport = chunk->transport;
9671da177e4SLinus Torvalds
9681da177e4SLinus Torvalds return retval;
9691da177e4SLinus Torvalds }
9701da177e4SLinus Torvalds
9711da177e4SLinus Torvalds /* Helper to create ABORT with a NO_USER_DATA error. */
sctp_make_abort_no_data(const struct sctp_association * asoc,const struct sctp_chunk * chunk,__u32 tsn)9721da177e4SLinus Torvalds struct sctp_chunk *sctp_make_abort_no_data(
9731da177e4SLinus Torvalds const struct sctp_association *asoc,
974327c0dabSXin Long const struct sctp_chunk *chunk,
975327c0dabSXin Long __u32 tsn)
9761da177e4SLinus Torvalds {
9771da177e4SLinus Torvalds struct sctp_chunk *retval;
9789f81bcd9SAl Viro __be32 payload;
9791da177e4SLinus Torvalds
980d8238d9dSXin Long retval = sctp_make_abort(asoc, chunk,
981d8238d9dSXin Long sizeof(struct sctp_errhdr) + sizeof(tsn));
9821da177e4SLinus Torvalds
9831da177e4SLinus Torvalds if (!retval)
9841da177e4SLinus Torvalds goto no_mem;
9851da177e4SLinus Torvalds
9861da177e4SLinus Torvalds /* Put the tsn back into network byte order. */
9871da177e4SLinus Torvalds payload = htonl(tsn);
98800f1c2dfSWei Yongjun sctp_init_cause(retval, SCTP_ERROR_NO_DATA, sizeof(payload));
98900f1c2dfSWei Yongjun sctp_addto_chunk(retval, sizeof(payload), (const void *)&payload);
9901da177e4SLinus Torvalds
9911da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
9921da177e4SLinus Torvalds *
9931da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
9941da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
9951da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
9961da177e4SLinus Torvalds * to which it is replying.
9971da177e4SLinus Torvalds *
9981da177e4SLinus Torvalds * [ABORT back to where the offender came from.]
9991da177e4SLinus Torvalds */
10001da177e4SLinus Torvalds if (chunk)
10011da177e4SLinus Torvalds retval->transport = chunk->transport;
10021da177e4SLinus Torvalds
10031da177e4SLinus Torvalds no_mem:
10041da177e4SLinus Torvalds return retval;
10051da177e4SLinus Torvalds }
10061da177e4SLinus Torvalds
10071da177e4SLinus Torvalds /* Helper to create ABORT with a SCTP_ERROR_USER_ABORT error. */
sctp_make_abort_user(const struct sctp_association * asoc,struct msghdr * msg,size_t paylen)10081da177e4SLinus Torvalds struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc,
10096ce8e9ceSAl Viro struct msghdr *msg,
1010c164a9baSSridhar Samudrala size_t paylen)
10111da177e4SLinus Torvalds {
10121da177e4SLinus Torvalds struct sctp_chunk *retval;
1013c164a9baSSridhar Samudrala void *payload = NULL;
1014c164a9baSSridhar Samudrala int err;
10151da177e4SLinus Torvalds
1016d8238d9dSXin Long retval = sctp_make_abort(asoc, NULL,
1017d8238d9dSXin Long sizeof(struct sctp_errhdr) + paylen);
10181da177e4SLinus Torvalds if (!retval)
10191da177e4SLinus Torvalds goto err_chunk;
10201da177e4SLinus Torvalds
10211da177e4SLinus Torvalds if (paylen) {
10221da177e4SLinus Torvalds /* Put the msg_iov together into payload. */
1023c164a9baSSridhar Samudrala payload = kmalloc(paylen, GFP_KERNEL);
10241da177e4SLinus Torvalds if (!payload)
10251da177e4SLinus Torvalds goto err_payload;
10261da177e4SLinus Torvalds
10276ce8e9ceSAl Viro err = memcpy_from_msg(payload, msg, paylen);
1028c164a9baSSridhar Samudrala if (err < 0)
10291da177e4SLinus Torvalds goto err_copy;
10301da177e4SLinus Torvalds }
10311da177e4SLinus Torvalds
103200f1c2dfSWei Yongjun sctp_init_cause(retval, SCTP_ERROR_USER_ABORT, paylen);
103300f1c2dfSWei Yongjun sctp_addto_chunk(retval, paylen, payload);
10341da177e4SLinus Torvalds
10351da177e4SLinus Torvalds if (paylen)
10361da177e4SLinus Torvalds kfree(payload);
10371da177e4SLinus Torvalds
10381da177e4SLinus Torvalds return retval;
10391da177e4SLinus Torvalds
10401da177e4SLinus Torvalds err_copy:
10411da177e4SLinus Torvalds kfree(payload);
10421da177e4SLinus Torvalds err_payload:
10431da177e4SLinus Torvalds sctp_chunk_free(retval);
10441da177e4SLinus Torvalds retval = NULL;
10451da177e4SLinus Torvalds err_chunk:
10461da177e4SLinus Torvalds return retval;
10471da177e4SLinus Torvalds }
10481da177e4SLinus Torvalds
10495c94bf86SAdrian Bunk /* Append bytes to the end of a parameter. Will panic if chunk is not big
10505c94bf86SAdrian Bunk * enough.
10515c94bf86SAdrian Bunk */
sctp_addto_param(struct sctp_chunk * chunk,int len,const void * data)10525c94bf86SAdrian Bunk static void *sctp_addto_param(struct sctp_chunk *chunk, int len,
10535c94bf86SAdrian Bunk const void *data)
10545c94bf86SAdrian Bunk {
10555c94bf86SAdrian Bunk int chunklen = ntohs(chunk->chunk_hdr->length);
1056327c0dabSXin Long void *target;
10575c94bf86SAdrian Bunk
10585c94bf86SAdrian Bunk target = skb_put(chunk->skb, len);
10595c94bf86SAdrian Bunk
10606383cfb3SVlad Yasevich if (data)
10615c94bf86SAdrian Bunk memcpy(target, data, len);
10626383cfb3SVlad Yasevich else
10636383cfb3SVlad Yasevich memset(target, 0, len);
10645c94bf86SAdrian Bunk
10655c94bf86SAdrian Bunk /* Adjust the chunk length field. */
10665c94bf86SAdrian Bunk chunk->chunk_hdr->length = htons(chunklen + len);
10675c94bf86SAdrian Bunk chunk->chunk_end = skb_tail_pointer(chunk->skb);
10685c94bf86SAdrian Bunk
10695c94bf86SAdrian Bunk return target;
10705c94bf86SAdrian Bunk }
10715c94bf86SAdrian Bunk
10721da177e4SLinus Torvalds /* Make an ABORT chunk with a PROTOCOL VIOLATION cause code. */
sctp_make_abort_violation(const struct sctp_association * asoc,const struct sctp_chunk * chunk,const __u8 * payload,const size_t paylen)10731da177e4SLinus Torvalds struct sctp_chunk *sctp_make_abort_violation(
10741da177e4SLinus Torvalds const struct sctp_association *asoc,
10751da177e4SLinus Torvalds const struct sctp_chunk *chunk,
10761da177e4SLinus Torvalds const __u8 *payload,
10771da177e4SLinus Torvalds const size_t paylen)
10781da177e4SLinus Torvalds {
10791da177e4SLinus Torvalds struct sctp_chunk *retval;
10801da177e4SLinus Torvalds struct sctp_paramhdr phdr;
10811da177e4SLinus Torvalds
1082d8238d9dSXin Long retval = sctp_make_abort(asoc, chunk, sizeof(struct sctp_errhdr) +
1083d8238d9dSXin Long paylen + sizeof(phdr));
10841da177e4SLinus Torvalds if (!retval)
10851da177e4SLinus Torvalds goto end;
10861da177e4SLinus Torvalds
10873c918704SXin Long sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, paylen +
10883c918704SXin Long sizeof(phdr));
10891da177e4SLinus Torvalds
10901da177e4SLinus Torvalds phdr.type = htons(chunk->chunk_hdr->type);
10911da177e4SLinus Torvalds phdr.length = chunk->chunk_hdr->length;
109200f1c2dfSWei Yongjun sctp_addto_chunk(retval, paylen, payload);
10933c918704SXin Long sctp_addto_param(retval, sizeof(phdr), &phdr);
10941da177e4SLinus Torvalds
10951da177e4SLinus Torvalds end:
10961da177e4SLinus Torvalds return retval;
10971da177e4SLinus Torvalds }
10981da177e4SLinus Torvalds
sctp_make_violation_paramlen(const struct sctp_association * asoc,const struct sctp_chunk * chunk,struct sctp_paramhdr * param)1099ba016670SWei Yongjun struct sctp_chunk *sctp_make_violation_paramlen(
1100ba016670SWei Yongjun const struct sctp_association *asoc,
1101ba016670SWei Yongjun const struct sctp_chunk *chunk,
1102ba016670SWei Yongjun struct sctp_paramhdr *param)
1103ba016670SWei Yongjun {
1104ba016670SWei Yongjun static const char error[] = "The following parameter had invalid length:";
1105d8238d9dSXin Long size_t payload_len = sizeof(error) + sizeof(struct sctp_errhdr) +
11063c918704SXin Long sizeof(*param);
1107327c0dabSXin Long struct sctp_chunk *retval;
1108ba016670SWei Yongjun
1109ba016670SWei Yongjun retval = sctp_make_abort(asoc, chunk, payload_len);
1110ba016670SWei Yongjun if (!retval)
1111ba016670SWei Yongjun goto nodata;
1112ba016670SWei Yongjun
1113ba016670SWei Yongjun sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION,
11143c918704SXin Long sizeof(error) + sizeof(*param));
1115ba016670SWei Yongjun sctp_addto_chunk(retval, sizeof(error), error);
11163c918704SXin Long sctp_addto_param(retval, sizeof(*param), param);
1117ba016670SWei Yongjun
1118ba016670SWei Yongjun nodata:
1119ba016670SWei Yongjun return retval;
1120ba016670SWei Yongjun }
1121ba016670SWei Yongjun
sctp_make_violation_max_retrans(const struct sctp_association * asoc,const struct sctp_chunk * chunk)1122de4594a5SNeil Horman struct sctp_chunk *sctp_make_violation_max_retrans(
1123de4594a5SNeil Horman const struct sctp_association *asoc,
1124de4594a5SNeil Horman const struct sctp_chunk *chunk)
1125de4594a5SNeil Horman {
112639a2d5cbSColin Ian King static const char error[] = "Association exceeded its max_retrans count";
1127d8238d9dSXin Long size_t payload_len = sizeof(error) + sizeof(struct sctp_errhdr);
1128327c0dabSXin Long struct sctp_chunk *retval;
1129de4594a5SNeil Horman
1130de4594a5SNeil Horman retval = sctp_make_abort(asoc, chunk, payload_len);
1131de4594a5SNeil Horman if (!retval)
1132de4594a5SNeil Horman goto nodata;
1133de4594a5SNeil Horman
1134de4594a5SNeil Horman sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, sizeof(error));
1135de4594a5SNeil Horman sctp_addto_chunk(retval, sizeof(error), error);
1136de4594a5SNeil Horman
1137de4594a5SNeil Horman nodata:
1138de4594a5SNeil Horman return retval;
1139de4594a5SNeil Horman }
1140de4594a5SNeil Horman
sctp_make_new_encap_port(const struct sctp_association * asoc,const struct sctp_chunk * chunk)1141e38d86b3SXin Long struct sctp_chunk *sctp_make_new_encap_port(const struct sctp_association *asoc,
1142e38d86b3SXin Long const struct sctp_chunk *chunk)
1143e38d86b3SXin Long {
1144e38d86b3SXin Long struct sctp_new_encap_port_hdr nep;
1145e38d86b3SXin Long struct sctp_chunk *retval;
1146e38d86b3SXin Long
1147e38d86b3SXin Long retval = sctp_make_abort(asoc, chunk,
1148e38d86b3SXin Long sizeof(struct sctp_errhdr) + sizeof(nep));
1149e38d86b3SXin Long if (!retval)
1150e38d86b3SXin Long goto nodata;
1151e38d86b3SXin Long
1152e38d86b3SXin Long sctp_init_cause(retval, SCTP_ERROR_NEW_ENCAP_PORT, sizeof(nep));
1153e38d86b3SXin Long nep.cur_port = SCTP_INPUT_CB(chunk->skb)->encap_port;
1154e38d86b3SXin Long nep.new_port = chunk->transport->encap_port;
1155e38d86b3SXin Long sctp_addto_chunk(retval, sizeof(nep), &nep);
1156e38d86b3SXin Long
1157e38d86b3SXin Long nodata:
1158e38d86b3SXin Long return retval;
1159e38d86b3SXin Long }
1160e38d86b3SXin Long
11611da177e4SLinus Torvalds /* Make a HEARTBEAT chunk. */
sctp_make_heartbeat(const struct sctp_association * asoc,const struct sctp_transport * transport,__u32 probe_size)11621da177e4SLinus Torvalds struct sctp_chunk *sctp_make_heartbeat(const struct sctp_association *asoc,
1163fe59379bSXin Long const struct sctp_transport *transport,
1164fe59379bSXin Long __u32 probe_size)
11651da177e4SLinus Torvalds {
1166a34dcbfaSDan Carpenter struct sctp_sender_hb_info hbinfo = {};
116792c73af5SWei Yongjun struct sctp_chunk *retval;
116892c73af5SWei Yongjun
1169cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT, 0,
1170cea8768fSMarcelo Ricardo Leitner sizeof(hbinfo), GFP_ATOMIC);
11711da177e4SLinus Torvalds
11721da177e4SLinus Torvalds if (!retval)
11731da177e4SLinus Torvalds goto nodata;
11741da177e4SLinus Torvalds
117592c73af5SWei Yongjun hbinfo.param_hdr.type = SCTP_PARAM_HEARTBEAT_INFO;
1176edf903f8SXin Long hbinfo.param_hdr.length = htons(sizeof(hbinfo));
117792c73af5SWei Yongjun hbinfo.daddr = transport->ipaddr;
117892c73af5SWei Yongjun hbinfo.sent_at = jiffies;
117992c73af5SWei Yongjun hbinfo.hb_nonce = transport->hb_nonce;
1180fe59379bSXin Long hbinfo.probe_size = probe_size;
118192c73af5SWei Yongjun
11821da177e4SLinus Torvalds /* Cast away the 'const', as this is just telling the chunk
11831da177e4SLinus Torvalds * what transport it belongs to.
11841da177e4SLinus Torvalds */
11851da177e4SLinus Torvalds retval->transport = (struct sctp_transport *) transport;
118692c73af5SWei Yongjun retval->subh.hbs_hdr = sctp_addto_chunk(retval, sizeof(hbinfo),
118792c73af5SWei Yongjun &hbinfo);
1188fe59379bSXin Long retval->pmtu_probe = !!probe_size;
11891da177e4SLinus Torvalds
11901da177e4SLinus Torvalds nodata:
11911da177e4SLinus Torvalds return retval;
11921da177e4SLinus Torvalds }
11931da177e4SLinus Torvalds
sctp_make_heartbeat_ack(const struct sctp_association * asoc,const struct sctp_chunk * chunk,const void * payload,const size_t paylen)11941da177e4SLinus Torvalds struct sctp_chunk *sctp_make_heartbeat_ack(const struct sctp_association *asoc,
11951da177e4SLinus Torvalds const struct sctp_chunk *chunk,
1196327c0dabSXin Long const void *payload,
1197327c0dabSXin Long const size_t paylen)
11981da177e4SLinus Torvalds {
11991da177e4SLinus Torvalds struct sctp_chunk *retval;
12001da177e4SLinus Torvalds
1201cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen,
1202cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
12031da177e4SLinus Torvalds if (!retval)
12041da177e4SLinus Torvalds goto nodata;
12051da177e4SLinus Torvalds
12061da177e4SLinus Torvalds retval->subh.hbs_hdr = sctp_addto_chunk(retval, paylen, payload);
12071da177e4SLinus Torvalds
12081da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
12091da177e4SLinus Torvalds *
12101da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
12111da177e4SLinus Torvalds * HEARTBEAT ACK, * etc.) to the same destination transport
12121da177e4SLinus Torvalds * address from which it * received the DATA or control chunk
12131da177e4SLinus Torvalds * to which it is replying.
12141da177e4SLinus Torvalds *
12151da177e4SLinus Torvalds * [HBACK back to where the HEARTBEAT came from.]
12161da177e4SLinus Torvalds */
12171da177e4SLinus Torvalds if (chunk)
12181da177e4SLinus Torvalds retval->transport = chunk->transport;
12191da177e4SLinus Torvalds
12201da177e4SLinus Torvalds nodata:
12211da177e4SLinus Torvalds return retval;
12221da177e4SLinus Torvalds }
12231da177e4SLinus Torvalds
1224745a3211SXin Long /* RFC4820 3. Padding Chunk (PAD)
1225745a3211SXin Long * 0 1 2 3
1226745a3211SXin Long * 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
1227745a3211SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1228745a3211SXin Long * | Type = 0x84 | Flags=0 | Length |
1229745a3211SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1230745a3211SXin Long * | |
1231745a3211SXin Long * \ Padding Data /
1232745a3211SXin Long * / \
1233745a3211SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1234745a3211SXin Long */
sctp_make_pad(const struct sctp_association * asoc,int len)1235745a3211SXin Long struct sctp_chunk *sctp_make_pad(const struct sctp_association *asoc, int len)
1236745a3211SXin Long {
1237745a3211SXin Long struct sctp_chunk *retval;
1238745a3211SXin Long
1239745a3211SXin Long retval = sctp_make_control(asoc, SCTP_CID_PAD, 0, len, GFP_ATOMIC);
1240745a3211SXin Long if (!retval)
1241745a3211SXin Long return NULL;
1242745a3211SXin Long
1243745a3211SXin Long skb_put_zero(retval->skb, len);
1244745a3211SXin Long retval->chunk_hdr->length = htons(ntohs(retval->chunk_hdr->length) + len);
1245745a3211SXin Long retval->chunk_end = skb_tail_pointer(retval->skb);
1246745a3211SXin Long
1247745a3211SXin Long return retval;
1248745a3211SXin Long }
1249745a3211SXin Long
12501da177e4SLinus Torvalds /* Create an Operation Error chunk with the specified space reserved.
12511da177e4SLinus Torvalds * This routine can be used for containing multiple causes in the chunk.
12521da177e4SLinus Torvalds */
sctp_make_op_error_space(const struct sctp_association * asoc,const struct sctp_chunk * chunk,size_t size)12531da177e4SLinus Torvalds static struct sctp_chunk *sctp_make_op_error_space(
12541da177e4SLinus Torvalds const struct sctp_association *asoc,
12551da177e4SLinus Torvalds const struct sctp_chunk *chunk,
12561da177e4SLinus Torvalds size_t size)
12571da177e4SLinus Torvalds {
12581da177e4SLinus Torvalds struct sctp_chunk *retval;
12591da177e4SLinus Torvalds
1260072017b4SVlad Yasevich retval = sctp_make_control(asoc, SCTP_CID_ERROR, 0,
1261d8238d9dSXin Long sizeof(struct sctp_errhdr) + size,
1262d8238d9dSXin Long GFP_ATOMIC);
12631da177e4SLinus Torvalds if (!retval)
12641da177e4SLinus Torvalds goto nodata;
12651da177e4SLinus Torvalds
12661da177e4SLinus Torvalds /* RFC 2960 6.4 Multi-homed SCTP Endpoints
12671da177e4SLinus Torvalds *
12681da177e4SLinus Torvalds * An endpoint SHOULD transmit reply chunks (e.g., SACK,
12691da177e4SLinus Torvalds * HEARTBEAT ACK, etc.) to the same destination transport
12701da177e4SLinus Torvalds * address from which it received the DATA or control chunk
12711da177e4SLinus Torvalds * to which it is replying.
12721da177e4SLinus Torvalds *
12731da177e4SLinus Torvalds */
12741da177e4SLinus Torvalds if (chunk)
12751da177e4SLinus Torvalds retval->transport = chunk->transport;
12761da177e4SLinus Torvalds
12771da177e4SLinus Torvalds nodata:
12781da177e4SLinus Torvalds return retval;
12791da177e4SLinus Torvalds }
12801da177e4SLinus Torvalds
12818914f4baSMarcelo Ricardo Leitner /* Create an Operation Error chunk of a fixed size, specifically,
12828914f4baSMarcelo Ricardo Leitner * min(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT) - overheads.
128314f45bb7SRandy Dunlap * This is a helper function to allocate an error chunk for those
12848914f4baSMarcelo Ricardo Leitner * invalid parameter codes in which we may not want to report all the
12858914f4baSMarcelo Ricardo Leitner * errors, if the incoming chunk is large. If it can't fit in a single
12868914f4baSMarcelo Ricardo Leitner * packet, we ignore it.
12875fa782c2SNeil Horman */
sctp_make_op_error_limited(const struct sctp_association * asoc,const struct sctp_chunk * chunk)12888914f4baSMarcelo Ricardo Leitner static inline struct sctp_chunk *sctp_make_op_error_limited(
12895fa782c2SNeil Horman const struct sctp_association *asoc,
12905fa782c2SNeil Horman const struct sctp_chunk *chunk)
12915fa782c2SNeil Horman {
12928914f4baSMarcelo Ricardo Leitner size_t size = SCTP_DEFAULT_MAXSEGMENT;
12938914f4baSMarcelo Ricardo Leitner struct sctp_sock *sp = NULL;
12945fa782c2SNeil Horman
12958914f4baSMarcelo Ricardo Leitner if (asoc) {
12968914f4baSMarcelo Ricardo Leitner size = min_t(size_t, size, asoc->pathmtu);
12978914f4baSMarcelo Ricardo Leitner sp = sctp_sk(asoc->base.sk);
12988914f4baSMarcelo Ricardo Leitner }
12998914f4baSMarcelo Ricardo Leitner
13008914f4baSMarcelo Ricardo Leitner size = sctp_mtu_payload(sp, size, sizeof(struct sctp_errhdr));
13015fa782c2SNeil Horman
13025fa782c2SNeil Horman return sctp_make_op_error_space(asoc, chunk, size);
13035fa782c2SNeil Horman }
13045fa782c2SNeil Horman
13051da177e4SLinus Torvalds /* Create an Operation Error chunk. */
sctp_make_op_error(const struct sctp_association * asoc,const struct sctp_chunk * chunk,__be16 cause_code,const void * payload,size_t paylen,size_t reserve_tail)13061da177e4SLinus Torvalds struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc,
13071da177e4SLinus Torvalds const struct sctp_chunk *chunk,
130863706c5cSAl Viro __be16 cause_code, const void *payload,
13096383cfb3SVlad Yasevich size_t paylen, size_t reserve_tail)
13101da177e4SLinus Torvalds {
13111da177e4SLinus Torvalds struct sctp_chunk *retval;
13121da177e4SLinus Torvalds
13136383cfb3SVlad Yasevich retval = sctp_make_op_error_space(asoc, chunk, paylen + reserve_tail);
13141da177e4SLinus Torvalds if (!retval)
13151da177e4SLinus Torvalds goto nodata;
13161da177e4SLinus Torvalds
13176383cfb3SVlad Yasevich sctp_init_cause(retval, cause_code, paylen + reserve_tail);
131800f1c2dfSWei Yongjun sctp_addto_chunk(retval, paylen, payload);
13196383cfb3SVlad Yasevich if (reserve_tail)
13206383cfb3SVlad Yasevich sctp_addto_param(retval, reserve_tail, NULL);
13211da177e4SLinus Torvalds
13221da177e4SLinus Torvalds nodata:
13231da177e4SLinus Torvalds return retval;
13241da177e4SLinus Torvalds }
13251da177e4SLinus Torvalds
sctp_make_auth(const struct sctp_association * asoc,__u16 key_id)13261b1e0bc9SXin Long struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc,
13271b1e0bc9SXin Long __u16 key_id)
13284cd57c80SVlad Yasevich {
13294cd57c80SVlad Yasevich struct sctp_authhdr auth_hdr;
1330327c0dabSXin Long struct sctp_hmac *hmac_desc;
1331327c0dabSXin Long struct sctp_chunk *retval;
13324cd57c80SVlad Yasevich
13334cd57c80SVlad Yasevich /* Get the first hmac that the peer told us to use */
13344cd57c80SVlad Yasevich hmac_desc = sctp_auth_asoc_get_hmac(asoc);
13354cd57c80SVlad Yasevich if (unlikely(!hmac_desc))
13364cd57c80SVlad Yasevich return NULL;
13374cd57c80SVlad Yasevich
1338072017b4SVlad Yasevich retval = sctp_make_control(asoc, SCTP_CID_AUTH, 0,
133996f7ef4dSXin Long hmac_desc->hmac_len + sizeof(auth_hdr),
1340cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
13414cd57c80SVlad Yasevich if (!retval)
13424cd57c80SVlad Yasevich return NULL;
13434cd57c80SVlad Yasevich
13444cd57c80SVlad Yasevich auth_hdr.hmac_id = htons(hmac_desc->hmac_id);
13451b1e0bc9SXin Long auth_hdr.shkey_id = htons(key_id);
13464cd57c80SVlad Yasevich
134796f7ef4dSXin Long retval->subh.auth_hdr = sctp_addto_chunk(retval, sizeof(auth_hdr),
13484cd57c80SVlad Yasevich &auth_hdr);
13494cd57c80SVlad Yasevich
1350594831a8SMarcelo Ricardo Leitner skb_put_zero(retval->skb, hmac_desc->hmac_len);
13514cd57c80SVlad Yasevich
13524cd57c80SVlad Yasevich /* Adjust the chunk header to include the empty MAC */
13534cd57c80SVlad Yasevich retval->chunk_hdr->length =
13544cd57c80SVlad Yasevich htons(ntohs(retval->chunk_hdr->length) + hmac_desc->hmac_len);
13554cd57c80SVlad Yasevich retval->chunk_end = skb_tail_pointer(retval->skb);
13564cd57c80SVlad Yasevich
13574cd57c80SVlad Yasevich return retval;
13584cd57c80SVlad Yasevich }
13594cd57c80SVlad Yasevich
13604cd57c80SVlad Yasevich
13611da177e4SLinus Torvalds /********************************************************************
13621da177e4SLinus Torvalds * 2nd Level Abstractions
13631da177e4SLinus Torvalds ********************************************************************/
13641da177e4SLinus Torvalds
13651da177e4SLinus Torvalds /* Turn an skb into a chunk.
13661da177e4SLinus Torvalds * FIXME: Eventually move the structure directly inside the skb->cb[].
13673dc0a548Swangweidong *
13683dc0a548Swangweidong * sctpimpguide-05.txt Section 2.8.2
13693dc0a548Swangweidong * M1) Each time a new DATA chunk is transmitted
13703dc0a548Swangweidong * set the 'TSN.Missing.Report' count for that TSN to 0. The
13713dc0a548Swangweidong * 'TSN.Missing.Report' count will be used to determine missing chunks
13723dc0a548Swangweidong * and when to fast retransmit.
13733dc0a548Swangweidong *
13741da177e4SLinus Torvalds */
sctp_chunkify(struct sk_buff * skb,const struct sctp_association * asoc,struct sock * sk,gfp_t gfp)13751da177e4SLinus Torvalds struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
13761da177e4SLinus Torvalds const struct sctp_association *asoc,
1377cea8768fSMarcelo Ricardo Leitner struct sock *sk, gfp_t gfp)
13781da177e4SLinus Torvalds {
13791da177e4SLinus Torvalds struct sctp_chunk *retval;
13801da177e4SLinus Torvalds
1381cea8768fSMarcelo Ricardo Leitner retval = kmem_cache_zalloc(sctp_chunk_cachep, gfp);
13821da177e4SLinus Torvalds
13831da177e4SLinus Torvalds if (!retval)
13841da177e4SLinus Torvalds goto nodata;
1385bb33381dSDaniel Borkmann if (!sk)
1386bb33381dSDaniel Borkmann pr_debug("%s: chunkifying skb:%p w/o an sk\n", __func__, skb);
13871da177e4SLinus Torvalds
138879af02c2SDavid S. Miller INIT_LIST_HEAD(&retval->list);
13891da177e4SLinus Torvalds retval->skb = skb;
13901da177e4SLinus Torvalds retval->asoc = (struct sctp_association *)asoc;
13911da177e4SLinus Torvalds retval->singleton = 1;
13921da177e4SLinus Torvalds
1393c226ef9bSNeil Horman retval->fast_retransmit = SCTP_CAN_FRTX;
13941da177e4SLinus Torvalds
13951da177e4SLinus Torvalds /* Polish the bead hole. */
13961da177e4SLinus Torvalds INIT_LIST_HEAD(&retval->transmitted_list);
13971da177e4SLinus Torvalds INIT_LIST_HEAD(&retval->frag_list);
13981da177e4SLinus Torvalds SCTP_DBG_OBJCNT_INC(chunk);
1399e7f02796SReshetova, Elena refcount_set(&retval->refcnt, 1);
14001da177e4SLinus Torvalds
14011da177e4SLinus Torvalds nodata:
14021da177e4SLinus Torvalds return retval;
14031da177e4SLinus Torvalds }
14041da177e4SLinus Torvalds
14051da177e4SLinus Torvalds /* Set chunk->source and dest based on the IP header in chunk->skb. */
sctp_init_addrs(struct sctp_chunk * chunk,union sctp_addr * src,union sctp_addr * dest)14061da177e4SLinus Torvalds void sctp_init_addrs(struct sctp_chunk *chunk, union sctp_addr *src,
14071da177e4SLinus Torvalds union sctp_addr *dest)
14081da177e4SLinus Torvalds {
1409f235fca3SAl Viro memcpy(&chunk->source, src, sizeof(union sctp_addr));
141016b0a030SAl Viro memcpy(&chunk->dest, dest, sizeof(union sctp_addr));
14111da177e4SLinus Torvalds }
14121da177e4SLinus Torvalds
14131da177e4SLinus Torvalds /* Extract the source address from a chunk. */
sctp_source(const struct sctp_chunk * chunk)14141da177e4SLinus Torvalds const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)
14151da177e4SLinus Torvalds {
14161da177e4SLinus Torvalds /* If we have a known transport, use that. */
14171da177e4SLinus Torvalds if (chunk->transport) {
14186a1e5f33SAl Viro return &chunk->transport->ipaddr;
14191da177e4SLinus Torvalds } else {
14201da177e4SLinus Torvalds /* Otherwise, extract it from the IP header. */
14216a1e5f33SAl Viro return &chunk->source;
14221da177e4SLinus Torvalds }
14231da177e4SLinus Torvalds }
14241da177e4SLinus Torvalds
14251da177e4SLinus Torvalds /* Create a new chunk, setting the type and flags headers from the
14261da177e4SLinus Torvalds * arguments, reserving enough space for a 'paylen' byte payload.
14271da177e4SLinus Torvalds */
_sctp_make_chunk(const struct sctp_association * asoc,__u8 type,__u8 flags,int paylen,gfp_t gfp)1428072017b4SVlad Yasevich static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
1429cea8768fSMarcelo Ricardo Leitner __u8 type, __u8 flags, int paylen,
1430cea8768fSMarcelo Ricardo Leitner gfp_t gfp)
14311da177e4SLinus Torvalds {
1432922dbc5bSXin Long struct sctp_chunkhdr *chunk_hdr;
1433327c0dabSXin Long struct sctp_chunk *retval;
14341da177e4SLinus Torvalds struct sk_buff *skb;
14351da177e4SLinus Torvalds struct sock *sk;
143607f2c7abSAlexey Kodanev int chunklen;
143707f2c7abSAlexey Kodanev
143807f2c7abSAlexey Kodanev chunklen = SCTP_PAD4(sizeof(*chunk_hdr) + paylen);
143907f2c7abSAlexey Kodanev if (chunklen > SCTP_MAX_CHUNK_LEN)
144007f2c7abSAlexey Kodanev goto nodata;
14411da177e4SLinus Torvalds
14421da177e4SLinus Torvalds /* No need to allocate LL here, as this is only a chunk. */
144307f2c7abSAlexey Kodanev skb = alloc_skb(chunklen, gfp);
14441da177e4SLinus Torvalds if (!skb)
14451da177e4SLinus Torvalds goto nodata;
14461da177e4SLinus Torvalds
14471da177e4SLinus Torvalds /* Make room for the chunk header. */
1448922dbc5bSXin Long chunk_hdr = (struct sctp_chunkhdr *)skb_put(skb, sizeof(*chunk_hdr));
14491da177e4SLinus Torvalds chunk_hdr->type = type;
14501da177e4SLinus Torvalds chunk_hdr->flags = flags;
1451922dbc5bSXin Long chunk_hdr->length = htons(sizeof(*chunk_hdr));
14521da177e4SLinus Torvalds
14531da177e4SLinus Torvalds sk = asoc ? asoc->base.sk : NULL;
1454cea8768fSMarcelo Ricardo Leitner retval = sctp_chunkify(skb, asoc, sk, gfp);
14551da177e4SLinus Torvalds if (!retval) {
14561da177e4SLinus Torvalds kfree_skb(skb);
14571da177e4SLinus Torvalds goto nodata;
14581da177e4SLinus Torvalds }
14591da177e4SLinus Torvalds
14601da177e4SLinus Torvalds retval->chunk_hdr = chunk_hdr;
1461922dbc5bSXin Long retval->chunk_end = ((__u8 *)chunk_hdr) + sizeof(*chunk_hdr);
14621da177e4SLinus Torvalds
14634cd57c80SVlad Yasevich /* Determine if the chunk needs to be authenticated */
14644cd57c80SVlad Yasevich if (sctp_auth_send_cid(type, asoc))
14654cd57c80SVlad Yasevich retval->auth = 1;
14664cd57c80SVlad Yasevich
14671da177e4SLinus Torvalds return retval;
14681da177e4SLinus Torvalds nodata:
14691da177e4SLinus Torvalds return NULL;
14701da177e4SLinus Torvalds }
14711da177e4SLinus Torvalds
sctp_make_data(const struct sctp_association * asoc,__u8 flags,int paylen,gfp_t gfp)1472072017b4SVlad Yasevich static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
1473cea8768fSMarcelo Ricardo Leitner __u8 flags, int paylen, gfp_t gfp)
1474072017b4SVlad Yasevich {
1475cea8768fSMarcelo Ricardo Leitner return _sctp_make_chunk(asoc, SCTP_CID_DATA, flags, paylen, gfp);
1476072017b4SVlad Yasevich }
1477072017b4SVlad Yasevich
sctp_make_idata(const struct sctp_association * asoc,__u8 flags,int paylen,gfp_t gfp)1478ad05a7a0SXin Long struct sctp_chunk *sctp_make_idata(const struct sctp_association *asoc,
1479ad05a7a0SXin Long __u8 flags, int paylen, gfp_t gfp)
1480ad05a7a0SXin Long {
1481ad05a7a0SXin Long return _sctp_make_chunk(asoc, SCTP_CID_I_DATA, flags, paylen, gfp);
1482ad05a7a0SXin Long }
1483ad05a7a0SXin Long
sctp_make_control(const struct sctp_association * asoc,__u8 type,__u8 flags,int paylen,gfp_t gfp)1484072017b4SVlad Yasevich static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
1485cea8768fSMarcelo Ricardo Leitner __u8 type, __u8 flags, int paylen,
1486cea8768fSMarcelo Ricardo Leitner gfp_t gfp)
1487072017b4SVlad Yasevich {
1488cea8768fSMarcelo Ricardo Leitner struct sctp_chunk *chunk;
1489072017b4SVlad Yasevich
1490cea8768fSMarcelo Ricardo Leitner chunk = _sctp_make_chunk(asoc, type, flags, paylen, gfp);
1491072017b4SVlad Yasevich if (chunk)
1492072017b4SVlad Yasevich sctp_control_set_owner_w(chunk);
1493072017b4SVlad Yasevich
1494072017b4SVlad Yasevich return chunk;
1495072017b4SVlad Yasevich }
14961da177e4SLinus Torvalds
14971da177e4SLinus Torvalds /* Release the memory occupied by a chunk. */
sctp_chunk_destroy(struct sctp_chunk * chunk)14981da177e4SLinus Torvalds static void sctp_chunk_destroy(struct sctp_chunk *chunk)
14991da177e4SLinus Torvalds {
1500a08de64dSVlad Yasevich BUG_ON(!list_empty(&chunk->list));
1501a08de64dSVlad Yasevich list_del_init(&chunk->transmitted_list);
1502a08de64dSVlad Yasevich
1503c485658bSDaniel Borkmann consume_skb(chunk->skb);
1504c485658bSDaniel Borkmann consume_skb(chunk->auth_chunk);
15051da177e4SLinus Torvalds
15061da177e4SLinus Torvalds SCTP_DBG_OBJCNT_DEC(chunk);
15071da177e4SLinus Torvalds kmem_cache_free(sctp_chunk_cachep, chunk);
15081da177e4SLinus Torvalds }
15091da177e4SLinus Torvalds
15101da177e4SLinus Torvalds /* Possibly, free the chunk. */
sctp_chunk_free(struct sctp_chunk * chunk)15111da177e4SLinus Torvalds void sctp_chunk_free(struct sctp_chunk *chunk)
15121da177e4SLinus Torvalds {
15131da177e4SLinus Torvalds /* Release our reference on the message tracker. */
15141da177e4SLinus Torvalds if (chunk->msg)
15151da177e4SLinus Torvalds sctp_datamsg_put(chunk->msg);
15161da177e4SLinus Torvalds
15171da177e4SLinus Torvalds sctp_chunk_put(chunk);
15181da177e4SLinus Torvalds }
15191da177e4SLinus Torvalds
15201da177e4SLinus Torvalds /* Grab a reference to the chunk. */
sctp_chunk_hold(struct sctp_chunk * ch)15211da177e4SLinus Torvalds void sctp_chunk_hold(struct sctp_chunk *ch)
15221da177e4SLinus Torvalds {
1523e7f02796SReshetova, Elena refcount_inc(&ch->refcnt);
15241da177e4SLinus Torvalds }
15251da177e4SLinus Torvalds
15261da177e4SLinus Torvalds /* Release a reference to the chunk. */
sctp_chunk_put(struct sctp_chunk * ch)15271da177e4SLinus Torvalds void sctp_chunk_put(struct sctp_chunk *ch)
15281da177e4SLinus Torvalds {
1529e7f02796SReshetova, Elena if (refcount_dec_and_test(&ch->refcnt))
15301da177e4SLinus Torvalds sctp_chunk_destroy(ch);
15311da177e4SLinus Torvalds }
15321da177e4SLinus Torvalds
15331da177e4SLinus Torvalds /* Append bytes to the end of a chunk. Will panic if chunk is not big
15341da177e4SLinus Torvalds * enough.
15351da177e4SLinus Torvalds */
sctp_addto_chunk(struct sctp_chunk * chunk,int len,const void * data)15361da177e4SLinus Torvalds void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)
15371da177e4SLinus Torvalds {
15381da177e4SLinus Torvalds int chunklen = ntohs(chunk->chunk_hdr->length);
1539e2f036a9SMarcelo Ricardo Leitner int padlen = SCTP_PAD4(chunklen) - chunklen;
1540327c0dabSXin Long void *target;
15411da177e4SLinus Torvalds
1542b952f4dfSyuan linyu skb_put_zero(chunk->skb, padlen);
154359ae1d12SJohannes Berg target = skb_put_data(chunk->skb, data, len);
15441da177e4SLinus Torvalds
15451da177e4SLinus Torvalds /* Adjust the chunk length field. */
15461da177e4SLinus Torvalds chunk->chunk_hdr->length = htons(chunklen + padlen + len);
154727a884dcSArnaldo Carvalho de Melo chunk->chunk_end = skb_tail_pointer(chunk->skb);
15481da177e4SLinus Torvalds
15491da177e4SLinus Torvalds return target;
15501da177e4SLinus Torvalds }
15511da177e4SLinus Torvalds
15521da177e4SLinus Torvalds /* Append bytes from user space to the end of a chunk. Will panic if
15531da177e4SLinus Torvalds * chunk is not big enough.
15541da177e4SLinus Torvalds * Returns a kernel err value.
15551da177e4SLinus Torvalds */
sctp_user_addto_chunk(struct sctp_chunk * chunk,int len,struct iov_iter * from)1556e0eb093eSAl Viro int sctp_user_addto_chunk(struct sctp_chunk *chunk, int len,
1557e0eb093eSAl Viro struct iov_iter *from)
15581da177e4SLinus Torvalds {
1559e0eb093eSAl Viro void *target;
15601da177e4SLinus Torvalds
15611da177e4SLinus Torvalds /* Make room in chunk for data. */
15621da177e4SLinus Torvalds target = skb_put(chunk->skb, len);
15631da177e4SLinus Torvalds
15641da177e4SLinus Torvalds /* Copy data (whole iovec) into chunk */
15653b6d4dbfSAl Viro if (!copy_from_iter_full(target, len, from))
1566e0eb093eSAl Viro return -EFAULT;
15671da177e4SLinus Torvalds
15681da177e4SLinus Torvalds /* Adjust the chunk length field. */
15691da177e4SLinus Torvalds chunk->chunk_hdr->length =
15701da177e4SLinus Torvalds htons(ntohs(chunk->chunk_hdr->length) + len);
157127a884dcSArnaldo Carvalho de Melo chunk->chunk_end = skb_tail_pointer(chunk->skb);
15721da177e4SLinus Torvalds
1573e0eb093eSAl Viro return 0;
15741da177e4SLinus Torvalds }
15751da177e4SLinus Torvalds
15761da177e4SLinus Torvalds /* Helper function to assign a TSN if needed. This assumes that both
15771da177e4SLinus Torvalds * the data_hdr and association have already been assigned.
15781da177e4SLinus Torvalds */
sctp_chunk_assign_ssn(struct sctp_chunk * chunk)15791da177e4SLinus Torvalds void sctp_chunk_assign_ssn(struct sctp_chunk *chunk)
15801da177e4SLinus Torvalds {
1581ab3e5e7bSVlad Yasevich struct sctp_stream *stream;
1582327c0dabSXin Long struct sctp_chunk *lchunk;
1583327c0dabSXin Long struct sctp_datamsg *msg;
1584327c0dabSXin Long __u16 ssn, sid;
15851da177e4SLinus Torvalds
15861da177e4SLinus Torvalds if (chunk->has_ssn)
15871da177e4SLinus Torvalds return;
15881da177e4SLinus Torvalds
1589ab3e5e7bSVlad Yasevich /* All fragments will be on the same stream */
1590ab3e5e7bSVlad Yasevich sid = ntohs(chunk->subh.data_hdr->stream);
1591cee360abSXin Long stream = &chunk->asoc->stream;
1592ab3e5e7bSVlad Yasevich
1593ab3e5e7bSVlad Yasevich /* Now assign the sequence number to the entire message.
1594ab3e5e7bSVlad Yasevich * All fragments must have the same stream sequence number.
1595ab3e5e7bSVlad Yasevich */
1596ab3e5e7bSVlad Yasevich msg = chunk->msg;
1597ab3e5e7bSVlad Yasevich list_for_each_entry(lchunk, &msg->chunks, frag_list) {
1598ab3e5e7bSVlad Yasevich if (lchunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
15991da177e4SLinus Torvalds ssn = 0;
16001da177e4SLinus Torvalds } else {
1601ab3e5e7bSVlad Yasevich if (lchunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG)
1602a8386317SXin Long ssn = sctp_ssn_next(stream, out, sid);
16031da177e4SLinus Torvalds else
1604a8386317SXin Long ssn = sctp_ssn_peek(stream, out, sid);
16051da177e4SLinus Torvalds }
16061da177e4SLinus Torvalds
1607ab3e5e7bSVlad Yasevich lchunk->subh.data_hdr->ssn = htons(ssn);
1608ab3e5e7bSVlad Yasevich lchunk->has_ssn = 1;
1609ab3e5e7bSVlad Yasevich }
16101da177e4SLinus Torvalds }
16111da177e4SLinus Torvalds
16121da177e4SLinus Torvalds /* Helper function to assign a TSN if needed. This assumes that both
16131da177e4SLinus Torvalds * the data_hdr and association have already been assigned.
16141da177e4SLinus Torvalds */
sctp_chunk_assign_tsn(struct sctp_chunk * chunk)16151da177e4SLinus Torvalds void sctp_chunk_assign_tsn(struct sctp_chunk *chunk)
16161da177e4SLinus Torvalds {
16171da177e4SLinus Torvalds if (!chunk->has_tsn) {
16181da177e4SLinus Torvalds /* This is the last possible instant to
16191da177e4SLinus Torvalds * assign a TSN.
16201da177e4SLinus Torvalds */
16211da177e4SLinus Torvalds chunk->subh.data_hdr->tsn =
16221da177e4SLinus Torvalds htonl(sctp_association_get_next_tsn(chunk->asoc));
16231da177e4SLinus Torvalds chunk->has_tsn = 1;
16241da177e4SLinus Torvalds }
16251da177e4SLinus Torvalds }
16261da177e4SLinus Torvalds
16271da177e4SLinus Torvalds /* Create a CLOSED association to use with an incoming packet. */
sctp_make_temp_asoc(const struct sctp_endpoint * ep,struct sctp_chunk * chunk,gfp_t gfp)16281da177e4SLinus Torvalds struct sctp_association *sctp_make_temp_asoc(const struct sctp_endpoint *ep,
16293182cd84SAlexey Dobriyan struct sctp_chunk *chunk,
1630dd0fc66fSAl Viro gfp_t gfp)
16311da177e4SLinus Torvalds {
16321da177e4SLinus Torvalds struct sctp_association *asoc;
16331c662018SXin Long enum sctp_scope scope;
16341da177e4SLinus Torvalds struct sk_buff *skb;
16351da177e4SLinus Torvalds
16361da177e4SLinus Torvalds /* Create the bare association. */
16371da177e4SLinus Torvalds scope = sctp_scope(sctp_source(chunk));
16381da177e4SLinus Torvalds asoc = sctp_association_new(ep, ep->base.sk, scope, gfp);
16391da177e4SLinus Torvalds if (!asoc)
16401da177e4SLinus Torvalds goto nodata;
16411da177e4SLinus Torvalds asoc->temp = 1;
16421da177e4SLinus Torvalds skb = chunk->skb;
16431da177e4SLinus Torvalds /* Create an entry for the source address of the packet. */
1644e7487c86SMarcelo Ricardo Leitner SCTP_INPUT_CB(skb)->af->from_skb(&asoc->c.peer_addr, skb, 1);
1645e7487c86SMarcelo Ricardo Leitner
16461da177e4SLinus Torvalds nodata:
16471da177e4SLinus Torvalds return asoc;
16481da177e4SLinus Torvalds }
16491da177e4SLinus Torvalds
16501da177e4SLinus Torvalds /* Build a cookie representing asoc.
16511da177e4SLinus Torvalds * This INCLUDES the param header needed to put the cookie in the INIT ACK.
16521da177e4SLinus Torvalds */
sctp_pack_cookie(const struct sctp_endpoint * ep,const struct sctp_association * asoc,const struct sctp_chunk * init_chunk,int * cookie_len,const __u8 * raw_addrs,int addrs_len)1653f48ef4c7SXin Long static struct sctp_cookie_param *sctp_pack_cookie(
1654f48ef4c7SXin Long const struct sctp_endpoint *ep,
16551da177e4SLinus Torvalds const struct sctp_association *asoc,
16561da177e4SLinus Torvalds const struct sctp_chunk *init_chunk,
1657327c0dabSXin Long int *cookie_len, const __u8 *raw_addrs,
1658327c0dabSXin Long int addrs_len)
16591da177e4SLinus Torvalds {
16601da177e4SLinus Torvalds struct sctp_signed_cookie *cookie;
1661f48ef4c7SXin Long struct sctp_cookie_param *retval;
16621da177e4SLinus Torvalds int headersize, bodysize;
16631da177e4SLinus Torvalds
16649834a2bbSVlad Yasevich /* Header size is static data prior to the actual cookie, including
16659834a2bbSVlad Yasevich * any padding.
16669834a2bbSVlad Yasevich */
16673c918704SXin Long headersize = sizeof(struct sctp_paramhdr) +
16689834a2bbSVlad Yasevich (sizeof(struct sctp_signed_cookie) -
16699834a2bbSVlad Yasevich sizeof(struct sctp_cookie));
16701da177e4SLinus Torvalds bodysize = sizeof(struct sctp_cookie)
16711da177e4SLinus Torvalds + ntohs(init_chunk->chunk_hdr->length) + addrs_len;
16721da177e4SLinus Torvalds
16731da177e4SLinus Torvalds /* Pad out the cookie to a multiple to make the signature
16741da177e4SLinus Torvalds * functions simpler to write.
16751da177e4SLinus Torvalds */
16761da177e4SLinus Torvalds if (bodysize % SCTP_COOKIE_MULTIPLE)
16771da177e4SLinus Torvalds bodysize += SCTP_COOKIE_MULTIPLE
16781da177e4SLinus Torvalds - (bodysize % SCTP_COOKIE_MULTIPLE);
16791da177e4SLinus Torvalds *cookie_len = headersize + bodysize;
16801da177e4SLinus Torvalds
16811da177e4SLinus Torvalds /* Clear this memory since we are sending this data structure
16821da177e4SLinus Torvalds * out on the network.
16831da177e4SLinus Torvalds */
1684af997d8cSArnaldo Carvalho de Melo retval = kzalloc(*cookie_len, GFP_ATOMIC);
1685af997d8cSArnaldo Carvalho de Melo if (!retval)
1686af997d8cSArnaldo Carvalho de Melo goto nodata;
1687af997d8cSArnaldo Carvalho de Melo
16881da177e4SLinus Torvalds cookie = (struct sctp_signed_cookie *) retval->body;
16891da177e4SLinus Torvalds
16901da177e4SLinus Torvalds /* Set up the parameter header. */
16911da177e4SLinus Torvalds retval->p.type = SCTP_PARAM_STATE_COOKIE;
16921da177e4SLinus Torvalds retval->p.length = htons(*cookie_len);
16931da177e4SLinus Torvalds
16941da177e4SLinus Torvalds /* Copy the cookie part of the association itself. */
16951da177e4SLinus Torvalds cookie->c = asoc->c;
16961da177e4SLinus Torvalds /* Save the raw address list length in the cookie. */
16971da177e4SLinus Torvalds cookie->c.raw_addr_list_len = addrs_len;
16981da177e4SLinus Torvalds
16991da177e4SLinus Torvalds /* Remember PR-SCTP capability. */
17001da177e4SLinus Torvalds cookie->c.prsctp_capable = asoc->peer.prsctp_capable;
17011da177e4SLinus Torvalds
17020f3fffd8SIvan Skytte Jorgensen /* Save adaptation indication in the cookie. */
17030f3fffd8SIvan Skytte Jorgensen cookie->c.adaptation_ind = asoc->peer.adaptation_ind;
17041da177e4SLinus Torvalds
17051da177e4SLinus Torvalds /* Set an expiration time for the cookie. */
170652db882fSDaniel Borkmann cookie->c.expiration = ktime_add(asoc->cookie_life,
1707cb5e173eSMarcelo Ricardo Leitner ktime_get_real());
17081da177e4SLinus Torvalds
17091da177e4SLinus Torvalds /* Copy the peer's init packet. */
1710*f97278ffSXin Long memcpy(cookie + 1, init_chunk->chunk_hdr,
17111da177e4SLinus Torvalds ntohs(init_chunk->chunk_hdr->length));
17121da177e4SLinus Torvalds
17131da177e4SLinus Torvalds /* Copy the raw local address list of the association. */
1714*f97278ffSXin Long memcpy((__u8 *)(cookie + 1) +
17151da177e4SLinus Torvalds ntohs(init_chunk->chunk_hdr->length), raw_addrs, addrs_len);
17161da177e4SLinus Torvalds
17171da177e4SLinus Torvalds if (sctp_sk(ep->base.sk)->hmac) {
171875b93c63SEric Biggers struct crypto_shash *tfm = sctp_sk(ep->base.sk)->hmac;
17195821c769SHerbert Xu int err;
17201b489e11SHerbert Xu
17211da177e4SLinus Torvalds /* Sign the message. */
172275b93c63SEric Biggers err = crypto_shash_setkey(tfm, ep->secret_key,
17235821c769SHerbert Xu sizeof(ep->secret_key)) ?:
172475b93c63SEric Biggers crypto_shash_tfm_digest(tfm, (u8 *)&cookie->c, bodysize,
17255821c769SHerbert Xu cookie->signature);
17265821c769SHerbert Xu if (err)
17271b489e11SHerbert Xu goto free_cookie;
17281da177e4SLinus Torvalds }
17291da177e4SLinus Torvalds
17301da177e4SLinus Torvalds return retval;
17311b489e11SHerbert Xu
17321b489e11SHerbert Xu free_cookie:
17331b489e11SHerbert Xu kfree(retval);
17341b489e11SHerbert Xu nodata:
17351b489e11SHerbert Xu *cookie_len = 0;
17361b489e11SHerbert Xu return NULL;
17371da177e4SLinus Torvalds }
17381da177e4SLinus Torvalds
17391da177e4SLinus Torvalds /* Unpack the cookie from COOKIE ECHO chunk, recreating the association. */
sctp_unpack_cookie(const struct sctp_endpoint * ep,const struct sctp_association * asoc,struct sctp_chunk * chunk,gfp_t gfp,int * error,struct sctp_chunk ** errp)17401da177e4SLinus Torvalds struct sctp_association *sctp_unpack_cookie(
17411da177e4SLinus Torvalds const struct sctp_endpoint *ep,
17421da177e4SLinus Torvalds const struct sctp_association *asoc,
1743dd0fc66fSAl Viro struct sctp_chunk *chunk, gfp_t gfp,
17441da177e4SLinus Torvalds int *error, struct sctp_chunk **errp)
17451da177e4SLinus Torvalds {
17461da177e4SLinus Torvalds struct sctp_association *retval = NULL;
17471da177e4SLinus Torvalds int headersize, bodysize, fixed_size;
1748327c0dabSXin Long struct sctp_signed_cookie *cookie;
17491da177e4SLinus Torvalds struct sk_buff *skb = chunk->skb;
1750327c0dabSXin Long struct sctp_cookie *bear_cookie;
1751327c0dabSXin Long __u8 *digest = ep->digest;
1752327c0dabSXin Long enum sctp_scope scope;
1753327c0dabSXin Long unsigned int len;
175452db882fSDaniel Borkmann ktime_t kt;
17551da177e4SLinus Torvalds
17569834a2bbSVlad Yasevich /* Header size is static data prior to the actual cookie, including
17579834a2bbSVlad Yasevich * any padding.
17589834a2bbSVlad Yasevich */
1759922dbc5bSXin Long headersize = sizeof(struct sctp_chunkhdr) +
17609834a2bbSVlad Yasevich (sizeof(struct sctp_signed_cookie) -
17619834a2bbSVlad Yasevich sizeof(struct sctp_cookie));
17621da177e4SLinus Torvalds bodysize = ntohs(chunk->chunk_hdr->length) - headersize;
17631da177e4SLinus Torvalds fixed_size = headersize + sizeof(struct sctp_cookie);
17641da177e4SLinus Torvalds
17651da177e4SLinus Torvalds /* Verify that the chunk looks like it even has a cookie.
17661da177e4SLinus Torvalds * There must be enough room for our cookie and our peer's
17671da177e4SLinus Torvalds * INIT chunk.
17681da177e4SLinus Torvalds */
17691da177e4SLinus Torvalds len = ntohs(chunk->chunk_hdr->length);
17701da177e4SLinus Torvalds if (len < fixed_size + sizeof(struct sctp_chunkhdr))
17711da177e4SLinus Torvalds goto malformed;
17721da177e4SLinus Torvalds
17731da177e4SLinus Torvalds /* Verify that the cookie has been padded out. */
17741da177e4SLinus Torvalds if (bodysize % SCTP_COOKIE_MULTIPLE)
17751da177e4SLinus Torvalds goto malformed;
17761da177e4SLinus Torvalds
17771da177e4SLinus Torvalds /* Process the cookie. */
17781da177e4SLinus Torvalds cookie = chunk->subh.cookie_hdr;
17791da177e4SLinus Torvalds bear_cookie = &cookie->c;
17801da177e4SLinus Torvalds
17811da177e4SLinus Torvalds if (!sctp_sk(ep->base.sk)->hmac)
17821da177e4SLinus Torvalds goto no_hmac;
17831da177e4SLinus Torvalds
17841da177e4SLinus Torvalds /* Check the signature. */
17855821c769SHerbert Xu {
178675b93c63SEric Biggers struct crypto_shash *tfm = sctp_sk(ep->base.sk)->hmac;
17875821c769SHerbert Xu int err;
17881da177e4SLinus Torvalds
178975b93c63SEric Biggers err = crypto_shash_setkey(tfm, ep->secret_key,
17905821c769SHerbert Xu sizeof(ep->secret_key)) ?:
179175b93c63SEric Biggers crypto_shash_tfm_digest(tfm, (u8 *)bear_cookie, bodysize,
17925821c769SHerbert Xu digest);
17935821c769SHerbert Xu if (err) {
17941b489e11SHerbert Xu *error = -SCTP_IERROR_NOMEM;
17951b489e11SHerbert Xu goto fail;
17961b489e11SHerbert Xu }
17975821c769SHerbert Xu }
17981da177e4SLinus Torvalds
17991da177e4SLinus Torvalds if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
18001da177e4SLinus Torvalds *error = -SCTP_IERROR_BAD_SIG;
18011da177e4SLinus Torvalds goto fail;
18021da177e4SLinus Torvalds }
18031da177e4SLinus Torvalds
18041da177e4SLinus Torvalds no_hmac:
18051da177e4SLinus Torvalds /* IG Section 2.35.2:
18061da177e4SLinus Torvalds * 3) Compare the port numbers and the verification tag contained
18071da177e4SLinus Torvalds * within the COOKIE ECHO chunk to the actual port numbers and the
18081da177e4SLinus Torvalds * verification tag within the SCTP common header of the received
18091da177e4SLinus Torvalds * packet. If these values do not match the packet MUST be silently
18101da177e4SLinus Torvalds * discarded,
18111da177e4SLinus Torvalds */
18121da177e4SLinus Torvalds if (ntohl(chunk->sctp_hdr->vtag) != bear_cookie->my_vtag) {
18131da177e4SLinus Torvalds *error = -SCTP_IERROR_BAD_TAG;
18141da177e4SLinus Torvalds goto fail;
18151da177e4SLinus Torvalds }
18161da177e4SLinus Torvalds
18179b1dfad0SAl Viro if (chunk->sctp_hdr->source != bear_cookie->peer_addr.v4.sin_port ||
18181da177e4SLinus Torvalds ntohs(chunk->sctp_hdr->dest) != bear_cookie->my_port) {
18191da177e4SLinus Torvalds *error = -SCTP_IERROR_BAD_PORTS;
18201da177e4SLinus Torvalds goto fail;
18211da177e4SLinus Torvalds }
18221da177e4SLinus Torvalds
18231da177e4SLinus Torvalds /* Check to see if the cookie is stale. If there is already
18241da177e4SLinus Torvalds * an association, there is no need to check cookie's expiration
18251da177e4SLinus Torvalds * for init collision case of lost COOKIE ACK.
1826f236218bSVlad Yasevich * If skb has been timestamped, then use the stamp, otherwise
1827f236218bSVlad Yasevich * use current time. This introduces a small possibility that
182814f45bb7SRandy Dunlap * a cookie may be considered expired, but this would only slow
1829f236218bSVlad Yasevich * down the new association establishment instead of every packet.
18301da177e4SLinus Torvalds */
1831f236218bSVlad Yasevich if (sock_flag(ep->base.sk, SOCK_TIMESTAMP))
183252db882fSDaniel Borkmann kt = skb_get_ktime(skb);
1833f236218bSVlad Yasevich else
1834cb5e173eSMarcelo Ricardo Leitner kt = ktime_get_real();
1835f236218bSVlad Yasevich
183667cb9366SDaniel Borkmann if (!asoc && ktime_before(bear_cookie->expiration, kt)) {
18378914f4baSMarcelo Ricardo Leitner suseconds_t usecs = ktime_to_us(ktime_sub(kt, bear_cookie->expiration));
18388914f4baSMarcelo Ricardo Leitner __be32 n = htonl(usecs);
18398914f4baSMarcelo Ricardo Leitner
18401da177e4SLinus Torvalds /*
18411da177e4SLinus Torvalds * Section 3.3.10.3 Stale Cookie Error (3)
18421da177e4SLinus Torvalds *
18431da177e4SLinus Torvalds * Cause of error
18441da177e4SLinus Torvalds * ---------------
18451da177e4SLinus Torvalds * Stale Cookie Error: Indicates the receipt of a valid State
18461da177e4SLinus Torvalds * Cookie that has expired.
18471da177e4SLinus Torvalds */
18488914f4baSMarcelo Ricardo Leitner *errp = sctp_make_op_error(asoc, chunk,
18498914f4baSMarcelo Ricardo Leitner SCTP_ERROR_STALE_COOKIE, &n,
18508914f4baSMarcelo Ricardo Leitner sizeof(n), 0);
18518914f4baSMarcelo Ricardo Leitner if (*errp)
18521da177e4SLinus Torvalds *error = -SCTP_IERROR_STALE_COOKIE;
18538914f4baSMarcelo Ricardo Leitner else
18541da177e4SLinus Torvalds *error = -SCTP_IERROR_NOMEM;
18551da177e4SLinus Torvalds
18561da177e4SLinus Torvalds goto fail;
18571da177e4SLinus Torvalds }
18581da177e4SLinus Torvalds
18591da177e4SLinus Torvalds /* Make a new base association. */
18601da177e4SLinus Torvalds scope = sctp_scope(sctp_source(chunk));
18611da177e4SLinus Torvalds retval = sctp_association_new(ep, ep->base.sk, scope, gfp);
18621da177e4SLinus Torvalds if (!retval) {
18631da177e4SLinus Torvalds *error = -SCTP_IERROR_NOMEM;
18641da177e4SLinus Torvalds goto fail;
18651da177e4SLinus Torvalds }
18661da177e4SLinus Torvalds
18671da177e4SLinus Torvalds /* Set up our peer's port number. */
18681da177e4SLinus Torvalds retval->peer.port = ntohs(chunk->sctp_hdr->source);
18691da177e4SLinus Torvalds
18701da177e4SLinus Torvalds /* Populate the association from the cookie. */
18711da177e4SLinus Torvalds memcpy(&retval->c, bear_cookie, sizeof(*bear_cookie));
18721da177e4SLinus Torvalds
18731da177e4SLinus Torvalds if (sctp_assoc_set_bind_addr_from_cookie(retval, bear_cookie,
18741da177e4SLinus Torvalds GFP_ATOMIC) < 0) {
18751da177e4SLinus Torvalds *error = -SCTP_IERROR_NOMEM;
18761da177e4SLinus Torvalds goto fail;
18771da177e4SLinus Torvalds }
18781da177e4SLinus Torvalds
18791da177e4SLinus Torvalds /* Also, add the destination address. */
18801da177e4SLinus Torvalds if (list_empty(&retval->base.bind_addr.address_list)) {
1881f57d96b2SVlad Yasevich sctp_add_bind_addr(&retval->base.bind_addr, &chunk->dest,
1882133800d1SMarcelo Ricardo Leitner sizeof(chunk->dest), SCTP_ADDR_SRC,
1883133800d1SMarcelo Ricardo Leitner GFP_ATOMIC);
18841da177e4SLinus Torvalds }
18851da177e4SLinus Torvalds
18861da177e4SLinus Torvalds retval->next_tsn = retval->c.initial_tsn;
18871da177e4SLinus Torvalds retval->ctsn_ack_point = retval->next_tsn - 1;
18881da177e4SLinus Torvalds retval->addip_serial = retval->c.initial_tsn;
1889cc16f00fSXin Long retval->strreset_outseq = retval->c.initial_tsn;
18901da177e4SLinus Torvalds retval->adv_peer_ack_point = retval->ctsn_ack_point;
18911da177e4SLinus Torvalds retval->peer.prsctp_capable = retval->c.prsctp_capable;
18920f3fffd8SIvan Skytte Jorgensen retval->peer.adaptation_ind = retval->c.adaptation_ind;
18931da177e4SLinus Torvalds
18941da177e4SLinus Torvalds /* The INIT stuff will be done by the side effects. */
18951da177e4SLinus Torvalds return retval;
18961da177e4SLinus Torvalds
18971da177e4SLinus Torvalds fail:
18981da177e4SLinus Torvalds if (retval)
18991da177e4SLinus Torvalds sctp_association_free(retval);
19001da177e4SLinus Torvalds
19011da177e4SLinus Torvalds return NULL;
19021da177e4SLinus Torvalds
19031da177e4SLinus Torvalds malformed:
19041da177e4SLinus Torvalds /* Yikes! The packet is either corrupt or deliberately
19051da177e4SLinus Torvalds * malformed.
19061da177e4SLinus Torvalds */
19071da177e4SLinus Torvalds *error = -SCTP_IERROR_MALFORMED;
19081da177e4SLinus Torvalds goto fail;
19091da177e4SLinus Torvalds }
19101da177e4SLinus Torvalds
19111da177e4SLinus Torvalds /********************************************************************
19121da177e4SLinus Torvalds * 3rd Level Abstractions
19131da177e4SLinus Torvalds ********************************************************************/
19141da177e4SLinus Torvalds
19151da177e4SLinus Torvalds struct __sctp_missing {
19169f81bcd9SAl Viro __be32 num_missing;
19179f81bcd9SAl Viro __be16 type;
1918bc10502dSEric Dumazet } __packed;
19191da177e4SLinus Torvalds
19201da177e4SLinus Torvalds /*
19211da177e4SLinus Torvalds * Report a missing mandatory parameter.
19221da177e4SLinus Torvalds */
sctp_process_missing_param(const struct sctp_association * asoc,enum sctp_param paramtype,struct sctp_chunk * chunk,struct sctp_chunk ** errp)19231da177e4SLinus Torvalds static int sctp_process_missing_param(const struct sctp_association *asoc,
192434b4e29bSXin Long enum sctp_param paramtype,
19251da177e4SLinus Torvalds struct sctp_chunk *chunk,
19261da177e4SLinus Torvalds struct sctp_chunk **errp)
19271da177e4SLinus Torvalds {
19281da177e4SLinus Torvalds struct __sctp_missing report;
19291da177e4SLinus Torvalds __u16 len;
19301da177e4SLinus Torvalds
1931e2f036a9SMarcelo Ricardo Leitner len = SCTP_PAD4(sizeof(report));
19321da177e4SLinus Torvalds
19331da177e4SLinus Torvalds /* Make an ERROR chunk, preparing enough room for
19341da177e4SLinus Torvalds * returning multiple unknown parameters.
19351da177e4SLinus Torvalds */
19361da177e4SLinus Torvalds if (!*errp)
19371da177e4SLinus Torvalds *errp = sctp_make_op_error_space(asoc, chunk, len);
19381da177e4SLinus Torvalds
19391da177e4SLinus Torvalds if (*errp) {
19401da177e4SLinus Torvalds report.num_missing = htonl(1);
19411da177e4SLinus Torvalds report.type = paramtype;
1942ebdfcad4SVlad Yasevich sctp_init_cause(*errp, SCTP_ERROR_MISS_PARAM,
194300f1c2dfSWei Yongjun sizeof(report));
194400f1c2dfSWei Yongjun sctp_addto_chunk(*errp, sizeof(report), &report);
19451da177e4SLinus Torvalds }
19461da177e4SLinus Torvalds
19471da177e4SLinus Torvalds /* Stop processing this chunk. */
19481da177e4SLinus Torvalds return 0;
19491da177e4SLinus Torvalds }
19501da177e4SLinus Torvalds
19511da177e4SLinus Torvalds /* Report an Invalid Mandatory Parameter. */
sctp_process_inv_mandatory(const struct sctp_association * asoc,struct sctp_chunk * chunk,struct sctp_chunk ** errp)19521da177e4SLinus Torvalds static int sctp_process_inv_mandatory(const struct sctp_association *asoc,
19531da177e4SLinus Torvalds struct sctp_chunk *chunk,
19541da177e4SLinus Torvalds struct sctp_chunk **errp)
19551da177e4SLinus Torvalds {
19561da177e4SLinus Torvalds /* Invalid Mandatory Parameter Error has no payload. */
19571da177e4SLinus Torvalds
19581da177e4SLinus Torvalds if (!*errp)
19591da177e4SLinus Torvalds *errp = sctp_make_op_error_space(asoc, chunk, 0);
19601da177e4SLinus Torvalds
19611da177e4SLinus Torvalds if (*errp)
196200f1c2dfSWei Yongjun sctp_init_cause(*errp, SCTP_ERROR_INV_PARAM, 0);
19631da177e4SLinus Torvalds
19641da177e4SLinus Torvalds /* Stop processing this chunk. */
19651da177e4SLinus Torvalds return 0;
19661da177e4SLinus Torvalds }
19671da177e4SLinus Torvalds
sctp_process_inv_paramlength(const struct sctp_association * asoc,struct sctp_paramhdr * param,const struct sctp_chunk * chunk,struct sctp_chunk ** errp)19681da177e4SLinus Torvalds static int sctp_process_inv_paramlength(const struct sctp_association *asoc,
19691da177e4SLinus Torvalds struct sctp_paramhdr *param,
19701da177e4SLinus Torvalds const struct sctp_chunk *chunk,
19711da177e4SLinus Torvalds struct sctp_chunk **errp)
19721da177e4SLinus Torvalds {
19737ab90804SVlad Yasevich /* This is a fatal error. Any accumulated non-fatal errors are
19747ab90804SVlad Yasevich * not reported.
19757ab90804SVlad Yasevich */
19767ab90804SVlad Yasevich if (*errp)
19777ab90804SVlad Yasevich sctp_chunk_free(*errp);
19787ab90804SVlad Yasevich
19791da177e4SLinus Torvalds /* Create an error chunk and fill it in with our payload. */
1980ba016670SWei Yongjun *errp = sctp_make_violation_paramlen(asoc, chunk, param);
19811da177e4SLinus Torvalds
19821da177e4SLinus Torvalds return 0;
19831da177e4SLinus Torvalds }
19841da177e4SLinus Torvalds
19851da177e4SLinus Torvalds
19861da177e4SLinus Torvalds /* Do not attempt to handle the HOST_NAME parm. However, do
19871da177e4SLinus Torvalds * send back an indicator to the peer.
19881da177e4SLinus Torvalds */
sctp_process_hn_param(const struct sctp_association * asoc,union sctp_params param,struct sctp_chunk * chunk,struct sctp_chunk ** errp)19891da177e4SLinus Torvalds static int sctp_process_hn_param(const struct sctp_association *asoc,
19901da177e4SLinus Torvalds union sctp_params param,
19911da177e4SLinus Torvalds struct sctp_chunk *chunk,
19921da177e4SLinus Torvalds struct sctp_chunk **errp)
19931da177e4SLinus Torvalds {
19941da177e4SLinus Torvalds __u16 len = ntohs(param.p->length);
19951da177e4SLinus Torvalds
19967ab90804SVlad Yasevich /* Processing of the HOST_NAME parameter will generate an
19977ab90804SVlad Yasevich * ABORT. If we've accumulated any non-fatal errors, they
19987ab90804SVlad Yasevich * would be unrecognized parameters and we should not include
19997ab90804SVlad Yasevich * them in the ABORT.
20007ab90804SVlad Yasevich */
20017ab90804SVlad Yasevich if (*errp)
20027ab90804SVlad Yasevich sctp_chunk_free(*errp);
20037ab90804SVlad Yasevich
20048914f4baSMarcelo Ricardo Leitner *errp = sctp_make_op_error(asoc, chunk, SCTP_ERROR_DNS_FAILED,
20058914f4baSMarcelo Ricardo Leitner param.v, len, 0);
20061da177e4SLinus Torvalds
20071da177e4SLinus Torvalds /* Stop processing this chunk. */
20081da177e4SLinus Torvalds return 0;
20091da177e4SLinus Torvalds }
20101da177e4SLinus Torvalds
sctp_verify_ext_param(struct net * net,const struct sctp_endpoint * ep,union sctp_params param)20114e27428fSXin Long static int sctp_verify_ext_param(struct net *net,
20124e27428fSXin Long const struct sctp_endpoint *ep,
20134e27428fSXin Long union sctp_params param)
2014d6701191SVlad Yasevich {
20153c918704SXin Long __u16 num_ext = ntohs(param.p->length) - sizeof(struct sctp_paramhdr);
2016d6701191SVlad Yasevich int have_asconf = 0;
2017327c0dabSXin Long int have_auth = 0;
2018d6701191SVlad Yasevich int i;
2019d6701191SVlad Yasevich
2020d6701191SVlad Yasevich for (i = 0; i < num_ext; i++) {
2021d6701191SVlad Yasevich switch (param.ext->chunks[i]) {
2022d6701191SVlad Yasevich case SCTP_CID_AUTH:
2023d6701191SVlad Yasevich have_auth = 1;
2024d6701191SVlad Yasevich break;
2025d6701191SVlad Yasevich case SCTP_CID_ASCONF:
2026d6701191SVlad Yasevich case SCTP_CID_ASCONF_ACK:
2027d6701191SVlad Yasevich have_asconf = 1;
2028d6701191SVlad Yasevich break;
2029d6701191SVlad Yasevich }
2030d6701191SVlad Yasevich }
2031d6701191SVlad Yasevich
2032d6701191SVlad Yasevich /* ADD-IP Security: The draft requires us to ABORT or ignore the
2033d6701191SVlad Yasevich * INIT/INIT-ACK if ADD-IP is listed, but AUTH is not. Do this
2034d6701191SVlad Yasevich * only if ADD-IP is turned on and we are not backward-compatible
2035d6701191SVlad Yasevich * mode.
2036d6701191SVlad Yasevich */
2037e1fc3b14SEric W. Biederman if (net->sctp.addip_noauth)
2038d6701191SVlad Yasevich return 1;
2039d6701191SVlad Yasevich
20404e27428fSXin Long if (ep->asconf_enable && !have_auth && have_asconf)
2041d6701191SVlad Yasevich return 0;
2042d6701191SVlad Yasevich
2043d6701191SVlad Yasevich return 1;
2044d6701191SVlad Yasevich }
2045d6701191SVlad Yasevich
sctp_process_ext_param(struct sctp_association * asoc,union sctp_params param)2046131a47e3SVlad Yasevich static void sctp_process_ext_param(struct sctp_association *asoc,
2047131a47e3SVlad Yasevich union sctp_params param)
2048131a47e3SVlad Yasevich {
20493c918704SXin Long __u16 num_ext = ntohs(param.p->length) - sizeof(struct sctp_paramhdr);
2050131a47e3SVlad Yasevich int i;
2051131a47e3SVlad Yasevich
2052131a47e3SVlad Yasevich for (i = 0; i < num_ext; i++) {
2053131a47e3SVlad Yasevich switch (param.ext->chunks[i]) {
2054c28445c3SXin Long case SCTP_CID_RECONF:
2055a96701fbSXin Long if (asoc->ep->reconf_enable)
2056c28445c3SXin Long asoc->peer.reconf_capable = 1;
2057c28445c3SXin Long break;
2058131a47e3SVlad Yasevich case SCTP_CID_FWD_TSN:
20591c134753SXin Long if (asoc->ep->prsctp_enable)
2060131a47e3SVlad Yasevich asoc->peer.prsctp_capable = 1;
2061131a47e3SVlad Yasevich break;
2062730fc3d0SVlad Yasevich case SCTP_CID_AUTH:
2063730fc3d0SVlad Yasevich /* if the peer reports AUTH, assume that he
2064730fc3d0SVlad Yasevich * supports AUTH.
2065730fc3d0SVlad Yasevich */
2066b14878ccSVlad Yasevich if (asoc->ep->auth_enable)
2067730fc3d0SVlad Yasevich asoc->peer.auth_capable = 1;
2068730fc3d0SVlad Yasevich break;
2069131a47e3SVlad Yasevich case SCTP_CID_ASCONF:
2070131a47e3SVlad Yasevich case SCTP_CID_ASCONF_ACK:
20714e27428fSXin Long if (asoc->ep->asconf_enable)
207288799fe5SVlad Yasevich asoc->peer.asconf_capable = 1;
20736b2f9cb6SVlad Yasevich break;
207496b120b3SXin Long case SCTP_CID_I_DATA:
2075e55f4b8bSXin Long if (asoc->ep->intl_enable)
2076da1f6d4dSXin Long asoc->peer.intl_capable = 1;
207796b120b3SXin Long break;
2078131a47e3SVlad Yasevich default:
2079131a47e3SVlad Yasevich break;
2080131a47e3SVlad Yasevich }
2081131a47e3SVlad Yasevich }
2082131a47e3SVlad Yasevich }
2083131a47e3SVlad Yasevich
20841da177e4SLinus Torvalds /* RFC 3.2.1 & the Implementers Guide 2.2.
20851da177e4SLinus Torvalds *
20861da177e4SLinus Torvalds * The Parameter Types are encoded such that the
20871da177e4SLinus Torvalds * highest-order two bits specify the action that must be
20881da177e4SLinus Torvalds * taken if the processing endpoint does not recognize the
20891da177e4SLinus Torvalds * Parameter Type.
20901da177e4SLinus Torvalds *
20917ab90804SVlad Yasevich * 00 - Stop processing this parameter; do not process any further
20927ab90804SVlad Yasevich * parameters within this chunk
20931da177e4SLinus Torvalds *
20947ab90804SVlad Yasevich * 01 - Stop processing this parameter, do not process any further
20957ab90804SVlad Yasevich * parameters within this chunk, and report the unrecognized
20967ab90804SVlad Yasevich * parameter in an 'Unrecognized Parameter' ERROR chunk.
20971da177e4SLinus Torvalds *
20981da177e4SLinus Torvalds * 10 - Skip this parameter and continue processing.
20991da177e4SLinus Torvalds *
21001da177e4SLinus Torvalds * 11 - Skip this parameter and continue processing but
21011da177e4SLinus Torvalds * report the unrecognized parameter in an
21027ab90804SVlad Yasevich * 'Unrecognized Parameter' ERROR chunk.
21031da177e4SLinus Torvalds *
21041da177e4SLinus Torvalds * Return value:
21057ab90804SVlad Yasevich * SCTP_IERROR_NO_ERROR - continue with the chunk
21067ab90804SVlad Yasevich * SCTP_IERROR_ERROR - stop and report an error.
21077ab90804SVlad Yasevich * SCTP_IERROR_NOMEME - out of memory.
21081da177e4SLinus Torvalds */
sctp_process_unk_param(const struct sctp_association * asoc,union sctp_params param,struct sctp_chunk * chunk,struct sctp_chunk ** errp)21094785c7aeSXin Long static enum sctp_ierror sctp_process_unk_param(
21104785c7aeSXin Long const struct sctp_association *asoc,
21111da177e4SLinus Torvalds union sctp_params param,
21121da177e4SLinus Torvalds struct sctp_chunk *chunk,
21131da177e4SLinus Torvalds struct sctp_chunk **errp)
21141da177e4SLinus Torvalds {
21157ab90804SVlad Yasevich int retval = SCTP_IERROR_NO_ERROR;
21161da177e4SLinus Torvalds
21171da177e4SLinus Torvalds switch (param.p->type & SCTP_PARAM_ACTION_MASK) {
21181da177e4SLinus Torvalds case SCTP_PARAM_ACTION_DISCARD:
21197ab90804SVlad Yasevich retval = SCTP_IERROR_ERROR;
21201da177e4SLinus Torvalds break;
21211da177e4SLinus Torvalds case SCTP_PARAM_ACTION_SKIP:
21221da177e4SLinus Torvalds break;
21237ab90804SVlad Yasevich case SCTP_PARAM_ACTION_DISCARD_ERR:
21247ab90804SVlad Yasevich retval = SCTP_IERROR_ERROR;
2125df561f66SGustavo A. R. Silva fallthrough;
21261da177e4SLinus Torvalds case SCTP_PARAM_ACTION_SKIP_ERR:
21271da177e4SLinus Torvalds /* Make an ERROR chunk, preparing enough room for
21281da177e4SLinus Torvalds * returning multiple unknown parameters.
21291da177e4SLinus Torvalds */
21308914f4baSMarcelo Ricardo Leitner if (!*errp) {
21318914f4baSMarcelo Ricardo Leitner *errp = sctp_make_op_error_limited(asoc, chunk);
21328914f4baSMarcelo Ricardo Leitner if (!*errp) {
21338914f4baSMarcelo Ricardo Leitner /* If there is no memory for generating the
21348914f4baSMarcelo Ricardo Leitner * ERROR report as specified, an ABORT will be
21358914f4baSMarcelo Ricardo Leitner * triggered to the peer and the association
21368914f4baSMarcelo Ricardo Leitner * won't be established.
21371da177e4SLinus Torvalds */
21387ab90804SVlad Yasevich retval = SCTP_IERROR_NOMEM;
21398914f4baSMarcelo Ricardo Leitner break;
21401da177e4SLinus Torvalds }
21418914f4baSMarcelo Ricardo Leitner }
21428914f4baSMarcelo Ricardo Leitner
21438914f4baSMarcelo Ricardo Leitner if (!sctp_init_cause(*errp, SCTP_ERROR_UNKNOWN_PARAM,
21448914f4baSMarcelo Ricardo Leitner ntohs(param.p->length)))
21458914f4baSMarcelo Ricardo Leitner sctp_addto_chunk(*errp, ntohs(param.p->length),
21468914f4baSMarcelo Ricardo Leitner param.v);
21471da177e4SLinus Torvalds break;
21481da177e4SLinus Torvalds default:
21491da177e4SLinus Torvalds break;
21501da177e4SLinus Torvalds }
21511da177e4SLinus Torvalds
21521da177e4SLinus Torvalds return retval;
21531da177e4SLinus Torvalds }
21541da177e4SLinus Torvalds
21557ab90804SVlad Yasevich /* Verify variable length parameters
21561da177e4SLinus Torvalds * Return values:
21577ab90804SVlad Yasevich * SCTP_IERROR_ABORT - trigger an ABORT
21587ab90804SVlad Yasevich * SCTP_IERROR_NOMEM - out of memory (abort)
21597ab90804SVlad Yasevich * SCTP_IERROR_ERROR - stop processing, trigger an ERROR
21607ab90804SVlad Yasevich * SCTP_IERROR_NO_ERROR - continue with the chunk
21611da177e4SLinus Torvalds */
sctp_verify_param(struct net * net,const struct sctp_endpoint * ep,const struct sctp_association * asoc,union sctp_params param,enum sctp_cid cid,struct sctp_chunk * chunk,struct sctp_chunk ** err_chunk)21624785c7aeSXin Long static enum sctp_ierror sctp_verify_param(struct net *net,
2163b14878ccSVlad Yasevich const struct sctp_endpoint *ep,
2164f53b5b09SEric W. Biederman const struct sctp_association *asoc,
21651da177e4SLinus Torvalds union sctp_params param,
21666d85e68fSXin Long enum sctp_cid cid,
21671da177e4SLinus Torvalds struct sctp_chunk *chunk,
21681da177e4SLinus Torvalds struct sctp_chunk **err_chunk)
21691da177e4SLinus Torvalds {
217072da7b38SWei Yongjun struct sctp_hmac_algo_param *hmacs;
21717ab90804SVlad Yasevich int retval = SCTP_IERROR_NO_ERROR;
217272da7b38SWei Yongjun __u16 n_elt, id = 0;
217372da7b38SWei Yongjun int i;
21741da177e4SLinus Torvalds
21751da177e4SLinus Torvalds /* FIXME - This routine is not looking at each parameter per the
21761da177e4SLinus Torvalds * chunk type, i.e., unrecognized parameters should be further
21771da177e4SLinus Torvalds * identified based on the chunk id.
21781da177e4SLinus Torvalds */
21791da177e4SLinus Torvalds
21801da177e4SLinus Torvalds switch (param.p->type) {
21811da177e4SLinus Torvalds case SCTP_PARAM_IPV4_ADDRESS:
21821da177e4SLinus Torvalds case SCTP_PARAM_IPV6_ADDRESS:
21831da177e4SLinus Torvalds case SCTP_PARAM_COOKIE_PRESERVATIVE:
21841da177e4SLinus Torvalds case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
21851da177e4SLinus Torvalds case SCTP_PARAM_STATE_COOKIE:
21861da177e4SLinus Torvalds case SCTP_PARAM_HEARTBEAT_INFO:
21871da177e4SLinus Torvalds case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
21881da177e4SLinus Torvalds case SCTP_PARAM_ECN_CAPABLE:
21890f3fffd8SIvan Skytte Jorgensen case SCTP_PARAM_ADAPTATION_LAYER_IND:
2190d6701191SVlad Yasevich break;
2191d6701191SVlad Yasevich
2192131a47e3SVlad Yasevich case SCTP_PARAM_SUPPORTED_EXT:
21934e27428fSXin Long if (!sctp_verify_ext_param(net, ep, param))
2194d6701191SVlad Yasevich return SCTP_IERROR_ABORT;
21951da177e4SLinus Torvalds break;
21961da177e4SLinus Torvalds
2197d6de3097SVlad Yasevich case SCTP_PARAM_SET_PRIMARY:
2198ef6c8d6cSMarcelo Ricardo Leitner if (!ep->asconf_enable)
219948f9bcf9SJoe Perches goto unhandled;
2200d6de3097SVlad Yasevich
2201ef6c8d6cSMarcelo Ricardo Leitner if (ntohs(param.p->length) < sizeof(struct sctp_addip_param) +
2202ef6c8d6cSMarcelo Ricardo Leitner sizeof(struct sctp_paramhdr)) {
2203ef6c8d6cSMarcelo Ricardo Leitner sctp_process_inv_paramlength(asoc, param.p,
2204ef6c8d6cSMarcelo Ricardo Leitner chunk, err_chunk);
2205ef6c8d6cSMarcelo Ricardo Leitner retval = SCTP_IERROR_ABORT;
2206ef6c8d6cSMarcelo Ricardo Leitner }
2207ef6c8d6cSMarcelo Ricardo Leitner break;
2208ef6c8d6cSMarcelo Ricardo Leitner
22091da177e4SLinus Torvalds case SCTP_PARAM_HOST_NAME_ADDRESS:
2210bd4b2818SXin Long /* This param has been Deprecated, send ABORT. */
22117ab90804SVlad Yasevich sctp_process_hn_param(asoc, param, chunk, err_chunk);
22127ab90804SVlad Yasevich retval = SCTP_IERROR_ABORT;
22137ab90804SVlad Yasevich break;
2214131a47e3SVlad Yasevich
22151da177e4SLinus Torvalds case SCTP_PARAM_FWD_TSN_SUPPORT:
221628aa4c26SXin Long if (ep->prsctp_enable)
22171da177e4SLinus Torvalds break;
221848f9bcf9SJoe Perches goto unhandled;
2219730fc3d0SVlad Yasevich
2220730fc3d0SVlad Yasevich case SCTP_PARAM_RANDOM:
2221b14878ccSVlad Yasevich if (!ep->auth_enable)
222248f9bcf9SJoe Perches goto unhandled;
2223730fc3d0SVlad Yasevich
2224730fc3d0SVlad Yasevich /* SCTP-AUTH: Secion 6.1
2225730fc3d0SVlad Yasevich * If the random number is not 32 byte long the association
2226730fc3d0SVlad Yasevich * MUST be aborted. The ABORT chunk SHOULD contain the error
2227730fc3d0SVlad Yasevich * cause 'Protocol Violation'.
2228730fc3d0SVlad Yasevich */
22298914f4baSMarcelo Ricardo Leitner if (SCTP_AUTH_RANDOM_LENGTH != ntohs(param.p->length) -
22308914f4baSMarcelo Ricardo Leitner sizeof(struct sctp_paramhdr)) {
22317ab90804SVlad Yasevich sctp_process_inv_paramlength(asoc, param.p,
2232730fc3d0SVlad Yasevich chunk, err_chunk);
22337ab90804SVlad Yasevich retval = SCTP_IERROR_ABORT;
22347ab90804SVlad Yasevich }
2235730fc3d0SVlad Yasevich break;
2236730fc3d0SVlad Yasevich
2237730fc3d0SVlad Yasevich case SCTP_PARAM_CHUNKS:
2238b14878ccSVlad Yasevich if (!ep->auth_enable)
223948f9bcf9SJoe Perches goto unhandled;
2240730fc3d0SVlad Yasevich
2241730fc3d0SVlad Yasevich /* SCTP-AUTH: Section 3.2
2242730fc3d0SVlad Yasevich * The CHUNKS parameter MUST be included once in the INIT or
2243730fc3d0SVlad Yasevich * INIT-ACK chunk if the sender wants to receive authenticated
2244730fc3d0SVlad Yasevich * chunks. Its maximum length is 260 bytes.
2245730fc3d0SVlad Yasevich */
22467ab90804SVlad Yasevich if (260 < ntohs(param.p->length)) {
22477ab90804SVlad Yasevich sctp_process_inv_paramlength(asoc, param.p,
2248730fc3d0SVlad Yasevich chunk, err_chunk);
22497ab90804SVlad Yasevich retval = SCTP_IERROR_ABORT;
22507ab90804SVlad Yasevich }
2251730fc3d0SVlad Yasevich break;
2252730fc3d0SVlad Yasevich
2253730fc3d0SVlad Yasevich case SCTP_PARAM_HMAC_ALGO:
2254b14878ccSVlad Yasevich if (!ep->auth_enable)
225548f9bcf9SJoe Perches goto unhandled;
225672da7b38SWei Yongjun
225772da7b38SWei Yongjun hmacs = (struct sctp_hmac_algo_param *)param.p;
22583c918704SXin Long n_elt = (ntohs(param.p->length) -
22593c918704SXin Long sizeof(struct sctp_paramhdr)) >> 1;
226072da7b38SWei Yongjun
226172da7b38SWei Yongjun /* SCTP-AUTH: Section 6.1
226272da7b38SWei Yongjun * The HMAC algorithm based on SHA-1 MUST be supported and
226372da7b38SWei Yongjun * included in the HMAC-ALGO parameter.
226472da7b38SWei Yongjun */
226572da7b38SWei Yongjun for (i = 0; i < n_elt; i++) {
226672da7b38SWei Yongjun id = ntohs(hmacs->hmac_ids[i]);
226772da7b38SWei Yongjun
226872da7b38SWei Yongjun if (id == SCTP_AUTH_HMAC_ID_SHA1)
2269730fc3d0SVlad Yasevich break;
227072da7b38SWei Yongjun }
227172da7b38SWei Yongjun
227272da7b38SWei Yongjun if (id != SCTP_AUTH_HMAC_ID_SHA1) {
227372da7b38SWei Yongjun sctp_process_inv_paramlength(asoc, param.p, chunk,
227472da7b38SWei Yongjun err_chunk);
227572da7b38SWei Yongjun retval = SCTP_IERROR_ABORT;
227672da7b38SWei Yongjun }
227772da7b38SWei Yongjun break;
227848f9bcf9SJoe Perches unhandled:
22791da177e4SLinus Torvalds default:
2280bb33381dSDaniel Borkmann pr_debug("%s: unrecognized param:%d for chunk:%d\n",
2281bb33381dSDaniel Borkmann __func__, ntohs(param.p->type), cid);
2282bb33381dSDaniel Borkmann
22837ab90804SVlad Yasevich retval = sctp_process_unk_param(asoc, param, chunk, err_chunk);
22841da177e4SLinus Torvalds break;
22851da177e4SLinus Torvalds }
22861da177e4SLinus Torvalds return retval;
22871da177e4SLinus Torvalds }
22881da177e4SLinus Torvalds
22891da177e4SLinus Torvalds /* Verify the INIT packet before we process it. */
sctp_verify_init(struct net * net,const struct sctp_endpoint * ep,const struct sctp_association * asoc,enum sctp_cid cid,struct sctp_init_chunk * peer_init,struct sctp_chunk * chunk,struct sctp_chunk ** errp)2290b14878ccSVlad Yasevich int sctp_verify_init(struct net *net, const struct sctp_endpoint *ep,
22916d85e68fSXin Long const struct sctp_association *asoc, enum sctp_cid cid,
229201a992beSXin Long struct sctp_init_chunk *peer_init,
229301a992beSXin Long struct sctp_chunk *chunk, struct sctp_chunk **errp)
22941da177e4SLinus Torvalds {
22951da177e4SLinus Torvalds union sctp_params param;
22967613f5feSDaniel Borkmann bool has_cookie = false;
22977ab90804SVlad Yasevich int result;
22981da177e4SLinus Torvalds
22997613f5feSDaniel Borkmann /* Check for missing mandatory parameters. Note: Initial TSN is
23007613f5feSDaniel Borkmann * also mandatory, but is not checked here since the valid range
23017613f5feSDaniel Borkmann * is 0..2**32-1. RFC4960, section 3.3.3.
23027613f5feSDaniel Borkmann */
23037613f5feSDaniel Borkmann if (peer_init->init_hdr.num_outbound_streams == 0 ||
23047613f5feSDaniel Borkmann peer_init->init_hdr.num_inbound_streams == 0 ||
23057613f5feSDaniel Borkmann peer_init->init_hdr.init_tag == 0 ||
23067613f5feSDaniel Borkmann ntohl(peer_init->init_hdr.a_rwnd) < SCTP_DEFAULT_MINWINDOW)
23077ab90804SVlad Yasevich return sctp_process_inv_mandatory(asoc, chunk, errp);
23081da177e4SLinus Torvalds
2309add7370aSXin Long sctp_walk_params(param, peer_init) {
23107613f5feSDaniel Borkmann if (param.p->type == SCTP_PARAM_STATE_COOKIE)
23117613f5feSDaniel Borkmann has_cookie = true;
23127613f5feSDaniel Borkmann }
23131da177e4SLinus Torvalds
23141da177e4SLinus Torvalds /* There is a possibility that a parameter length was bad and
23151da177e4SLinus Torvalds * in that case we would have stoped walking the parameters.
23161da177e4SLinus Torvalds * The current param.p would point at the bad one.
23171da177e4SLinus Torvalds * Current consensus on the mailing list is to generate a PROTOCOL
23181da177e4SLinus Torvalds * VIOLATION error. We build the ERROR chunk here and let the normal
23191da177e4SLinus Torvalds * error handling code build and send the packet.
23201da177e4SLinus Torvalds */
23217ab90804SVlad Yasevich if (param.v != (void *)chunk->chunk_end)
23227ab90804SVlad Yasevich return sctp_process_inv_paramlength(asoc, param.p, chunk, errp);
23231da177e4SLinus Torvalds
23241da177e4SLinus Torvalds /* The only missing mandatory param possible today is
23251da177e4SLinus Torvalds * the state cookie for an INIT-ACK chunk.
23261da177e4SLinus Torvalds */
23277ab90804SVlad Yasevich if ((SCTP_CID_INIT_ACK == cid) && !has_cookie)
23287ab90804SVlad Yasevich return sctp_process_missing_param(asoc, SCTP_PARAM_STATE_COOKIE,
23291da177e4SLinus Torvalds chunk, errp);
23301da177e4SLinus Torvalds
23317ab90804SVlad Yasevich /* Verify all the variable length parameters */
2332add7370aSXin Long sctp_walk_params(param, peer_init) {
2333b14878ccSVlad Yasevich result = sctp_verify_param(net, ep, asoc, param, cid,
2334b14878ccSVlad Yasevich chunk, errp);
23357ab90804SVlad Yasevich switch (result) {
23367ab90804SVlad Yasevich case SCTP_IERROR_ABORT:
23377ab90804SVlad Yasevich case SCTP_IERROR_NOMEM:
23381da177e4SLinus Torvalds return 0;
23397ab90804SVlad Yasevich case SCTP_IERROR_ERROR:
23401da177e4SLinus Torvalds return 1;
23417ab90804SVlad Yasevich case SCTP_IERROR_NO_ERROR:
23427ab90804SVlad Yasevich default:
23437ab90804SVlad Yasevich break;
23441da177e4SLinus Torvalds }
23451da177e4SLinus Torvalds
23461da177e4SLinus Torvalds } /* for (loop through all parameters) */
23471da177e4SLinus Torvalds
23481da177e4SLinus Torvalds return 1;
23491da177e4SLinus Torvalds }
23501da177e4SLinus Torvalds
23511da177e4SLinus Torvalds /* Unpack the parameters in an INIT packet into an association.
23521da177e4SLinus Torvalds * Returns 0 on failure, else success.
23531da177e4SLinus Torvalds * FIXME: This is an association method.
23541da177e4SLinus Torvalds */
sctp_process_init(struct sctp_association * asoc,struct sctp_chunk * chunk,const union sctp_addr * peer_addr,struct sctp_init_chunk * peer_init,gfp_t gfp)2355de6becdcSWei Yongjun int sctp_process_init(struct sctp_association *asoc, struct sctp_chunk *chunk,
23561da177e4SLinus Torvalds const union sctp_addr *peer_addr,
235701a992beSXin Long struct sctp_init_chunk *peer_init, gfp_t gfp)
23581da177e4SLinus Torvalds {
23591da177e4SLinus Torvalds struct sctp_transport *transport;
23601da177e4SLinus Torvalds struct list_head *pos, *temp;
2361327c0dabSXin Long union sctp_params param;
2362de6becdcSWei Yongjun union sctp_addr addr;
2363327c0dabSXin Long struct sctp_af *af;
2364de6becdcSWei Yongjun int src_match = 0;
23651da177e4SLinus Torvalds
23661da177e4SLinus Torvalds /* We must include the address that the INIT packet came from.
23671da177e4SLinus Torvalds * This is the only address that matters for an INIT packet.
23681da177e4SLinus Torvalds * When processing a COOKIE ECHO, we retrieve the from address
23691da177e4SLinus Torvalds * of the INIT from the cookie.
23701da177e4SLinus Torvalds */
23711da177e4SLinus Torvalds
23721da177e4SLinus Torvalds /* This implementation defaults to making the first transport
23731da177e4SLinus Torvalds * added as the primary transport. The source address seems to
237414f45bb7SRandy Dunlap * be a better choice than any of the embedded addresses.
23751da177e4SLinus Torvalds */
2376a1dd2cf2SXin Long asoc->encap_port = SCTP_INPUT_CB(chunk->skb)->encap_port;
23776a1e5f33SAl Viro if (!sctp_assoc_add_peer(asoc, peer_addr, gfp, SCTP_ACTIVE))
23781da177e4SLinus Torvalds goto nomem;
2379de6becdcSWei Yongjun
2380de6becdcSWei Yongjun if (sctp_cmp_addr_exact(sctp_source(chunk), peer_addr))
2381de6becdcSWei Yongjun src_match = 1;
23821da177e4SLinus Torvalds
23831da177e4SLinus Torvalds /* Process the initialization parameters. */
2384add7370aSXin Long sctp_walk_params(param, peer_init) {
23850c5dc070SMarcelo Ricardo Leitner if (!src_match &&
23860c5dc070SMarcelo Ricardo Leitner (param.p->type == SCTP_PARAM_IPV4_ADDRESS ||
2387de6becdcSWei Yongjun param.p->type == SCTP_PARAM_IPV6_ADDRESS)) {
2388de6becdcSWei Yongjun af = sctp_get_af_specific(param_type2af(param.p->type));
23890c5dc070SMarcelo Ricardo Leitner if (!af->from_addr_param(&addr, param.addr,
23900c5dc070SMarcelo Ricardo Leitner chunk->sctp_hdr->source, 0))
23910c5dc070SMarcelo Ricardo Leitner continue;
2392de6becdcSWei Yongjun if (sctp_cmp_addr_exact(sctp_source(chunk), &addr))
2393de6becdcSWei Yongjun src_match = 1;
2394de6becdcSWei Yongjun }
23951da177e4SLinus Torvalds
23961da177e4SLinus Torvalds if (!sctp_process_param(asoc, param, peer_addr, gfp))
23971da177e4SLinus Torvalds goto clean_up;
23981da177e4SLinus Torvalds }
23991da177e4SLinus Torvalds
2400de6becdcSWei Yongjun /* source address of chunk may not match any valid address */
2401de6becdcSWei Yongjun if (!src_match)
2402de6becdcSWei Yongjun goto clean_up;
2403de6becdcSWei Yongjun
2404730fc3d0SVlad Yasevich /* AUTH: After processing the parameters, make sure that we
2405730fc3d0SVlad Yasevich * have all the required info to potentially do authentications.
2406730fc3d0SVlad Yasevich */
2407730fc3d0SVlad Yasevich if (asoc->peer.auth_capable && (!asoc->peer.peer_random ||
2408730fc3d0SVlad Yasevich !asoc->peer.peer_hmacs))
2409730fc3d0SVlad Yasevich asoc->peer.auth_capable = 0;
2410730fc3d0SVlad Yasevich
2411d6701191SVlad Yasevich /* In a non-backward compatible mode, if the peer claims
2412d6701191SVlad Yasevich * support for ADD-IP but not AUTH, the ADD-IP spec states
2413d6701191SVlad Yasevich * that we MUST ABORT the association. Section 6. The section
2414d6701191SVlad Yasevich * also give us an option to silently ignore the packet, which
2415d6701191SVlad Yasevich * is what we'll do here.
24166b2f9cb6SVlad Yasevich */
24174e7696d9SXin Long if (!asoc->base.net->sctp.addip_noauth &&
241873d9c4fdSVlad Yasevich (asoc->peer.asconf_capable && !asoc->peer.auth_capable)) {
24196b2f9cb6SVlad Yasevich asoc->peer.addip_disabled_mask |= (SCTP_PARAM_ADD_IP |
24206b2f9cb6SVlad Yasevich SCTP_PARAM_DEL_IP |
24216b2f9cb6SVlad Yasevich SCTP_PARAM_SET_PRIMARY);
242288799fe5SVlad Yasevich asoc->peer.asconf_capable = 0;
2423d6701191SVlad Yasevich goto clean_up;
24246b2f9cb6SVlad Yasevich }
24256b2f9cb6SVlad Yasevich
24263f7a87d2SFrank Filz /* Walk list of transports, removing transports in the UNKNOWN state. */
24273f7a87d2SFrank Filz list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
24283f7a87d2SFrank Filz transport = list_entry(pos, struct sctp_transport, transports);
24293f7a87d2SFrank Filz if (transport->state == SCTP_UNKNOWN) {
24303f7a87d2SFrank Filz sctp_assoc_rm_peer(asoc, transport);
24313f7a87d2SFrank Filz }
24323f7a87d2SFrank Filz }
24333f7a87d2SFrank Filz
24341da177e4SLinus Torvalds /* The fixed INIT headers are always in network byte
24351da177e4SLinus Torvalds * order.
24361da177e4SLinus Torvalds */
24371da177e4SLinus Torvalds asoc->peer.i.init_tag =
24381da177e4SLinus Torvalds ntohl(peer_init->init_hdr.init_tag);
24391da177e4SLinus Torvalds asoc->peer.i.a_rwnd =
24401da177e4SLinus Torvalds ntohl(peer_init->init_hdr.a_rwnd);
24411da177e4SLinus Torvalds asoc->peer.i.num_outbound_streams =
24421da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_outbound_streams);
24431da177e4SLinus Torvalds asoc->peer.i.num_inbound_streams =
24441da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_inbound_streams);
24451da177e4SLinus Torvalds asoc->peer.i.initial_tsn =
24461da177e4SLinus Torvalds ntohl(peer_init->init_hdr.initial_tsn);
24471da177e4SLinus Torvalds
2448cc16f00fSXin Long asoc->strreset_inseq = asoc->peer.i.initial_tsn;
2449cc16f00fSXin Long
24501da177e4SLinus Torvalds /* Apply the upper bounds for output streams based on peer's
24511da177e4SLinus Torvalds * number of inbound streams.
24521da177e4SLinus Torvalds */
24531da177e4SLinus Torvalds if (asoc->c.sinit_num_ostreams >
24541da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_inbound_streams)) {
24551da177e4SLinus Torvalds asoc->c.sinit_num_ostreams =
24561da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_inbound_streams);
24571da177e4SLinus Torvalds }
24581da177e4SLinus Torvalds
24591da177e4SLinus Torvalds if (asoc->c.sinit_max_instreams >
24601da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_outbound_streams)) {
24611da177e4SLinus Torvalds asoc->c.sinit_max_instreams =
24621da177e4SLinus Torvalds ntohs(peer_init->init_hdr.num_outbound_streams);
24631da177e4SLinus Torvalds }
24641da177e4SLinus Torvalds
24651da177e4SLinus Torvalds /* Copy Initiation tag from INIT to VT_peer in cookie. */
24661da177e4SLinus Torvalds asoc->c.peer_vtag = asoc->peer.i.init_tag;
24671da177e4SLinus Torvalds
24681da177e4SLinus Torvalds /* Peer Rwnd : Current calculated value of the peer's rwnd. */
24691da177e4SLinus Torvalds asoc->peer.rwnd = asoc->peer.i.a_rwnd;
24701da177e4SLinus Torvalds
24711da177e4SLinus Torvalds /* RFC 2960 7.2.1 The initial value of ssthresh MAY be arbitrarily
24721da177e4SLinus Torvalds * high (for example, implementations MAY use the size of the receiver
24731da177e4SLinus Torvalds * advertised window).
24741da177e4SLinus Torvalds */
24759dbc15f0SRobert P. J. Day list_for_each_entry(transport, &asoc->peer.transport_addr_list,
24769dbc15f0SRobert P. J. Day transports) {
24771da177e4SLinus Torvalds transport->ssthresh = asoc->peer.i.a_rwnd;
24781da177e4SLinus Torvalds }
24791da177e4SLinus Torvalds
24801da177e4SLinus Torvalds /* Set up the TSN tracking pieces. */
24818e1ee18cSVlad Yasevich if (!sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
24828e1ee18cSVlad Yasevich asoc->peer.i.initial_tsn, gfp))
24838e1ee18cSVlad Yasevich goto clean_up;
24841da177e4SLinus Torvalds
24851da177e4SLinus Torvalds /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
24861da177e4SLinus Torvalds *
24871da177e4SLinus Torvalds * The stream sequence number in all the streams shall start
24881da177e4SLinus Torvalds * from 0 when the association is established. Also, when the
24891da177e4SLinus Torvalds * stream sequence number reaches the value 65535 the next
24901da177e4SLinus Torvalds * stream sequence number shall be set to 0.
24911da177e4SLinus Torvalds */
24921da177e4SLinus Torvalds
2493ff356414SXin Long if (sctp_stream_init(&asoc->stream, asoc->c.sinit_num_ostreams,
2494ff356414SXin Long asoc->c.sinit_max_instreams, gfp))
24951da177e4SLinus Torvalds goto clean_up;
24961da177e4SLinus Torvalds
24974135cce7SXin Long /* Update frag_point when stream_interleave may get changed. */
24984135cce7SXin Long sctp_assoc_update_frag_point(asoc);
24994135cce7SXin Long
25007e062977SXin Long if (!asoc->temp && sctp_assoc_set_id(asoc, gfp))
25011da177e4SLinus Torvalds goto clean_up;
25021da177e4SLinus Torvalds
25031da177e4SLinus Torvalds /* ADDIP Section 4.1 ASCONF Chunk Procedures
25041da177e4SLinus Torvalds *
25051da177e4SLinus Torvalds * When an endpoint has an ASCONF signaled change to be sent to the
25061da177e4SLinus Torvalds * remote endpoint it should do the following:
25071da177e4SLinus Torvalds * ...
25081da177e4SLinus Torvalds * A2) A serial number should be assigned to the Chunk. The serial
25091da177e4SLinus Torvalds * number should be a monotonically increasing number. All serial
25101da177e4SLinus Torvalds * numbers are defined to be initialized at the start of the
25111da177e4SLinus Torvalds * association to the same value as the Initial TSN.
25121da177e4SLinus Torvalds */
25131da177e4SLinus Torvalds asoc->peer.addip_serial = asoc->peer.i.initial_tsn - 1;
25141da177e4SLinus Torvalds return 1;
25151da177e4SLinus Torvalds
25161da177e4SLinus Torvalds clean_up:
25171da177e4SLinus Torvalds /* Release the transport structures. */
25181da177e4SLinus Torvalds list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
25191da177e4SLinus Torvalds transport = list_entry(pos, struct sctp_transport, transports);
2520add52379SVlad Yasevich if (transport->state != SCTP_ACTIVE)
2521add52379SVlad Yasevich sctp_assoc_rm_peer(asoc, transport);
25221da177e4SLinus Torvalds }
25233f7a87d2SFrank Filz
25241da177e4SLinus Torvalds nomem:
25251da177e4SLinus Torvalds return 0;
25261da177e4SLinus Torvalds }
25271da177e4SLinus Torvalds
25281da177e4SLinus Torvalds
25291da177e4SLinus Torvalds /* Update asoc with the option described in param.
25301da177e4SLinus Torvalds *
25311da177e4SLinus Torvalds * RFC2960 3.3.2.1 Optional/Variable Length Parameters in INIT
25321da177e4SLinus Torvalds *
25331da177e4SLinus Torvalds * asoc is the association to update.
25341da177e4SLinus Torvalds * param is the variable length parameter to use for update.
25351da177e4SLinus Torvalds * cid tells us if this is an INIT, INIT ACK or COOKIE ECHO.
25361da177e4SLinus Torvalds * If the current packet is an INIT we want to minimize the amount of
25371da177e4SLinus Torvalds * work we do. In particular, we should not build transport
25381da177e4SLinus Torvalds * structures for the addresses.
25391da177e4SLinus Torvalds */
sctp_process_param(struct sctp_association * asoc,union sctp_params param,const union sctp_addr * peer_addr,gfp_t gfp)25401da177e4SLinus Torvalds static int sctp_process_param(struct sctp_association *asoc,
25411da177e4SLinus Torvalds union sctp_params param,
25421da177e4SLinus Torvalds const union sctp_addr *peer_addr,
2543dd0fc66fSAl Viro gfp_t gfp)
25441da177e4SLinus Torvalds {
2545327c0dabSXin Long struct sctp_endpoint *ep = asoc->ep;
2546d6de3097SVlad Yasevich union sctp_addr_param *addr_param;
25474e7696d9SXin Long struct net *net = asoc->base.net;
2548d6de3097SVlad Yasevich struct sctp_transport *t;
2549327c0dabSXin Long enum sctp_scope scope;
2550327c0dabSXin Long union sctp_addr addr;
2551327c0dabSXin Long struct sctp_af *af;
2552327c0dabSXin Long int retval = 1, i;
2553327c0dabSXin Long u32 stale;
2554327c0dabSXin Long __u16 sat;
25551da177e4SLinus Torvalds
25561da177e4SLinus Torvalds /* We maintain all INIT parameters in network byte order all the
25571da177e4SLinus Torvalds * time. This allows us to not worry about whether the parameters
25581da177e4SLinus Torvalds * came from a fresh INIT, and INIT ACK, or were stored in a cookie.
25591da177e4SLinus Torvalds */
25601da177e4SLinus Torvalds switch (param.p->type) {
25611da177e4SLinus Torvalds case SCTP_PARAM_IPV6_ADDRESS:
25621da177e4SLinus Torvalds if (PF_INET6 != asoc->base.sk->sk_family)
25631da177e4SLinus Torvalds break;
25647dab83deSVlad Yasevich goto do_addr_param;
25657dab83deSVlad Yasevich
25661da177e4SLinus Torvalds case SCTP_PARAM_IPV4_ADDRESS:
25677dab83deSVlad Yasevich /* v4 addresses are not allowed on v6-only socket */
25687dab83deSVlad Yasevich if (ipv6_only_sock(asoc->base.sk))
25697dab83deSVlad Yasevich break;
25707dab83deSVlad Yasevich do_addr_param:
25711da177e4SLinus Torvalds af = sctp_get_af_specific(param_type2af(param.p->type));
25720c5dc070SMarcelo Ricardo Leitner if (!af->from_addr_param(&addr, param.addr, htons(asoc->peer.port), 0))
25730c5dc070SMarcelo Ricardo Leitner break;
25741da177e4SLinus Torvalds scope = sctp_scope(peer_addr);
2575e7ff4a70SEric W. Biederman if (sctp_in_scope(net, &addr, scope))
2576dd86d136SAl Viro if (!sctp_assoc_add_peer(asoc, &addr, gfp, SCTP_UNCONFIRMED))
25771da177e4SLinus Torvalds return 0;
25781da177e4SLinus Torvalds break;
25791da177e4SLinus Torvalds
25801da177e4SLinus Torvalds case SCTP_PARAM_COOKIE_PRESERVATIVE:
2581e1fc3b14SEric W. Biederman if (!net->sctp.cookie_preserve_enable)
25821da177e4SLinus Torvalds break;
25831da177e4SLinus Torvalds
25841da177e4SLinus Torvalds stale = ntohl(param.life->lifespan_increment);
25851da177e4SLinus Torvalds
25861da177e4SLinus Torvalds /* Suggested Cookie Life span increment's unit is msec,
25871da177e4SLinus Torvalds * (1/1000sec).
25881da177e4SLinus Torvalds */
258952db882fSDaniel Borkmann asoc->cookie_life = ktime_add_ms(asoc->cookie_life, stale);
25901da177e4SLinus Torvalds break;
25911da177e4SLinus Torvalds
25921da177e4SLinus Torvalds case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
25931da177e4SLinus Torvalds /* Turn off the default values first so we'll know which
25941da177e4SLinus Torvalds * ones are really set by the peer.
25951da177e4SLinus Torvalds */
25961da177e4SLinus Torvalds asoc->peer.ipv4_address = 0;
25971da177e4SLinus Torvalds asoc->peer.ipv6_address = 0;
25981da177e4SLinus Torvalds
2599140ee960SGui Jianfeng /* Assume that peer supports the address family
2600140ee960SGui Jianfeng * by which it sends a packet.
2601140ee960SGui Jianfeng */
2602140ee960SGui Jianfeng if (peer_addr->sa.sa_family == AF_INET6)
2603140ee960SGui Jianfeng asoc->peer.ipv6_address = 1;
2604140ee960SGui Jianfeng else if (peer_addr->sa.sa_family == AF_INET)
2605140ee960SGui Jianfeng asoc->peer.ipv4_address = 1;
2606140ee960SGui Jianfeng
26071da177e4SLinus Torvalds /* Cycle through address types; avoid divide by 0. */
26083c918704SXin Long sat = ntohs(param.p->length) - sizeof(struct sctp_paramhdr);
26091da177e4SLinus Torvalds if (sat)
26101da177e4SLinus Torvalds sat /= sizeof(__u16);
26111da177e4SLinus Torvalds
26121da177e4SLinus Torvalds for (i = 0; i < sat; ++i) {
26131da177e4SLinus Torvalds switch (param.sat->types[i]) {
26141da177e4SLinus Torvalds case SCTP_PARAM_IPV4_ADDRESS:
26151da177e4SLinus Torvalds asoc->peer.ipv4_address = 1;
26161da177e4SLinus Torvalds break;
26171da177e4SLinus Torvalds
26181da177e4SLinus Torvalds case SCTP_PARAM_IPV6_ADDRESS:
26196e40a915SWei Yongjun if (PF_INET6 == asoc->base.sk->sk_family)
26201da177e4SLinus Torvalds asoc->peer.ipv6_address = 1;
26211da177e4SLinus Torvalds break;
26221da177e4SLinus Torvalds
26231da177e4SLinus Torvalds default: /* Just ignore anything else. */
26241da177e4SLinus Torvalds break;
26253ff50b79SStephen Hemminger }
26261da177e4SLinus Torvalds }
26271da177e4SLinus Torvalds break;
26281da177e4SLinus Torvalds
26291da177e4SLinus Torvalds case SCTP_PARAM_STATE_COOKIE:
26301da177e4SLinus Torvalds asoc->peer.cookie_len =
26313c918704SXin Long ntohs(param.p->length) - sizeof(struct sctp_paramhdr);
2632ce950f10SNeil Horman kfree(asoc->peer.cookie);
26330a8dd9f6SNeil Horman asoc->peer.cookie = kmemdup(param.cookie->body, asoc->peer.cookie_len, gfp);
26340a8dd9f6SNeil Horman if (!asoc->peer.cookie)
26350a8dd9f6SNeil Horman retval = 0;
26361da177e4SLinus Torvalds break;
26371da177e4SLinus Torvalds
26381da177e4SLinus Torvalds case SCTP_PARAM_HEARTBEAT_INFO:
26391da177e4SLinus Torvalds /* Would be odd to receive, but it causes no problems. */
26401da177e4SLinus Torvalds break;
26411da177e4SLinus Torvalds
26421da177e4SLinus Torvalds case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
26431da177e4SLinus Torvalds /* Rejected during verify stage. */
26441da177e4SLinus Torvalds break;
26451da177e4SLinus Torvalds
26461da177e4SLinus Torvalds case SCTP_PARAM_ECN_CAPABLE:
26471b0b8114SXin Long if (asoc->ep->ecn_enable) {
26481da177e4SLinus Torvalds asoc->peer.ecn_capable = 1;
26491da177e4SLinus Torvalds break;
26501b0b8114SXin Long }
26511b0b8114SXin Long /* Fall Through */
26521b0b8114SXin Long goto fall_through;
26531b0b8114SXin Long
26541da177e4SLinus Torvalds
26550f3fffd8SIvan Skytte Jorgensen case SCTP_PARAM_ADAPTATION_LAYER_IND:
2656e69c4e0fSVlad Yasevich asoc->peer.adaptation_ind = ntohl(param.aind->adaptation_ind);
26571da177e4SLinus Torvalds break;
26581da177e4SLinus Torvalds
2659d6de3097SVlad Yasevich case SCTP_PARAM_SET_PRIMARY:
26604e27428fSXin Long if (!ep->asconf_enable)
26610ef46e28SVlad Yasevich goto fall_through;
26620ef46e28SVlad Yasevich
26638b32f234SXin Long addr_param = param.v + sizeof(struct sctp_addip_param);
2664d6de3097SVlad Yasevich
2665cfbf654eSSaran Maruti Ramanara af = sctp_get_af_specific(param_type2af(addr_param->p.type));
26660c5dc070SMarcelo Ricardo Leitner if (!af)
2667e40607cbSDaniel Borkmann break;
2668e40607cbSDaniel Borkmann
26690c5dc070SMarcelo Ricardo Leitner if (!af->from_addr_param(&addr, addr_param,
26700c5dc070SMarcelo Ricardo Leitner htons(asoc->peer.port), 0))
26710c5dc070SMarcelo Ricardo Leitner break;
2672d6de3097SVlad Yasevich
2673d6de3097SVlad Yasevich if (!af->addr_valid(&addr, NULL, NULL))
2674d6de3097SVlad Yasevich break;
2675d6de3097SVlad Yasevich
2676d6de3097SVlad Yasevich t = sctp_assoc_lookup_paddr(asoc, &addr);
2677d6de3097SVlad Yasevich if (!t)
2678d6de3097SVlad Yasevich break;
2679d6de3097SVlad Yasevich
2680d6de3097SVlad Yasevich sctp_assoc_set_primary(asoc, t);
2681d6de3097SVlad Yasevich break;
2682d6de3097SVlad Yasevich
2683131a47e3SVlad Yasevich case SCTP_PARAM_SUPPORTED_EXT:
2684131a47e3SVlad Yasevich sctp_process_ext_param(asoc, param);
2685131a47e3SVlad Yasevich break;
2686131a47e3SVlad Yasevich
26871da177e4SLinus Torvalds case SCTP_PARAM_FWD_TSN_SUPPORT:
26881c134753SXin Long if (asoc->ep->prsctp_enable) {
26891da177e4SLinus Torvalds asoc->peer.prsctp_capable = 1;
26901da177e4SLinus Torvalds break;
26911da177e4SLinus Torvalds }
26921da177e4SLinus Torvalds /* Fall Through */
2693730fc3d0SVlad Yasevich goto fall_through;
2694730fc3d0SVlad Yasevich
2695730fc3d0SVlad Yasevich case SCTP_PARAM_RANDOM:
2696b14878ccSVlad Yasevich if (!ep->auth_enable)
2697730fc3d0SVlad Yasevich goto fall_through;
2698730fc3d0SVlad Yasevich
2699730fc3d0SVlad Yasevich /* Save peer's random parameter */
2700ce950f10SNeil Horman kfree(asoc->peer.peer_random);
2701730fc3d0SVlad Yasevich asoc->peer.peer_random = kmemdup(param.p,
2702730fc3d0SVlad Yasevich ntohs(param.p->length), gfp);
2703730fc3d0SVlad Yasevich if (!asoc->peer.peer_random) {
2704730fc3d0SVlad Yasevich retval = 0;
2705730fc3d0SVlad Yasevich break;
2706730fc3d0SVlad Yasevich }
2707730fc3d0SVlad Yasevich break;
2708730fc3d0SVlad Yasevich
2709730fc3d0SVlad Yasevich case SCTP_PARAM_HMAC_ALGO:
2710b14878ccSVlad Yasevich if (!ep->auth_enable)
2711730fc3d0SVlad Yasevich goto fall_through;
2712730fc3d0SVlad Yasevich
2713730fc3d0SVlad Yasevich /* Save peer's HMAC list */
2714ce950f10SNeil Horman kfree(asoc->peer.peer_hmacs);
2715730fc3d0SVlad Yasevich asoc->peer.peer_hmacs = kmemdup(param.p,
2716730fc3d0SVlad Yasevich ntohs(param.p->length), gfp);
2717730fc3d0SVlad Yasevich if (!asoc->peer.peer_hmacs) {
2718730fc3d0SVlad Yasevich retval = 0;
2719730fc3d0SVlad Yasevich break;
2720730fc3d0SVlad Yasevich }
2721730fc3d0SVlad Yasevich
2722730fc3d0SVlad Yasevich /* Set the default HMAC the peer requested*/
2723730fc3d0SVlad Yasevich sctp_auth_asoc_set_default_hmac(asoc, param.hmac_algo);
2724730fc3d0SVlad Yasevich break;
2725730fc3d0SVlad Yasevich
2726730fc3d0SVlad Yasevich case SCTP_PARAM_CHUNKS:
2727b14878ccSVlad Yasevich if (!ep->auth_enable)
2728730fc3d0SVlad Yasevich goto fall_through;
2729730fc3d0SVlad Yasevich
2730ce950f10SNeil Horman kfree(asoc->peer.peer_chunks);
2731730fc3d0SVlad Yasevich asoc->peer.peer_chunks = kmemdup(param.p,
2732730fc3d0SVlad Yasevich ntohs(param.p->length), gfp);
2733730fc3d0SVlad Yasevich if (!asoc->peer.peer_chunks)
2734730fc3d0SVlad Yasevich retval = 0;
2735730fc3d0SVlad Yasevich break;
2736730fc3d0SVlad Yasevich fall_through:
27371da177e4SLinus Torvalds default:
27381da177e4SLinus Torvalds /* Any unrecognized parameters should have been caught
27391da177e4SLinus Torvalds * and handled by sctp_verify_param() which should be
27401da177e4SLinus Torvalds * called prior to this routine. Simply log the error
27411da177e4SLinus Torvalds * here.
27421da177e4SLinus Torvalds */
2743bb33381dSDaniel Borkmann pr_debug("%s: ignoring param:%d for association:%p.\n",
2744bb33381dSDaniel Borkmann __func__, ntohs(param.p->type), asoc);
27451da177e4SLinus Torvalds break;
27463ff50b79SStephen Hemminger }
27471da177e4SLinus Torvalds
27481da177e4SLinus Torvalds return retval;
27491da177e4SLinus Torvalds }
27501da177e4SLinus Torvalds
27511da177e4SLinus Torvalds /* Select a new verification tag. */
sctp_generate_tag(const struct sctp_endpoint * ep)27521da177e4SLinus Torvalds __u32 sctp_generate_tag(const struct sctp_endpoint *ep)
27531da177e4SLinus Torvalds {
27541da177e4SLinus Torvalds /* I believe that this random number generator complies with RFC1750.
27551da177e4SLinus Torvalds * A tag of 0 is reserved for special cases (e.g. INIT).
27561da177e4SLinus Torvalds */
27571da177e4SLinus Torvalds __u32 x;
27581da177e4SLinus Torvalds
27591da177e4SLinus Torvalds do {
27601da177e4SLinus Torvalds get_random_bytes(&x, sizeof(__u32));
27611da177e4SLinus Torvalds } while (x == 0);
27621da177e4SLinus Torvalds
27631da177e4SLinus Torvalds return x;
27641da177e4SLinus Torvalds }
27651da177e4SLinus Torvalds
27661da177e4SLinus Torvalds /* Select an initial TSN to send during startup. */
sctp_generate_tsn(const struct sctp_endpoint * ep)27671da177e4SLinus Torvalds __u32 sctp_generate_tsn(const struct sctp_endpoint *ep)
27681da177e4SLinus Torvalds {
27691da177e4SLinus Torvalds __u32 retval;
27701da177e4SLinus Torvalds
27711da177e4SLinus Torvalds get_random_bytes(&retval, sizeof(__u32));
27721da177e4SLinus Torvalds return retval;
27731da177e4SLinus Torvalds }
27741da177e4SLinus Torvalds
27751da177e4SLinus Torvalds /*
27761da177e4SLinus Torvalds * ADDIP 3.1.1 Address Configuration Change Chunk (ASCONF)
27771da177e4SLinus Torvalds * 0 1 2 3
27781da177e4SLinus Torvalds * 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
27791da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27801da177e4SLinus Torvalds * | Type = 0xC1 | Chunk Flags | Chunk Length |
27811da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27821da177e4SLinus Torvalds * | Serial Number |
27831da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27841da177e4SLinus Torvalds * | Address Parameter |
27851da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27861da177e4SLinus Torvalds * | ASCONF Parameter #1 |
27871da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27881da177e4SLinus Torvalds * \ \
27891da177e4SLinus Torvalds * / .... /
27901da177e4SLinus Torvalds * \ \
27911da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27921da177e4SLinus Torvalds * | ASCONF Parameter #N |
27931da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
27941da177e4SLinus Torvalds *
27951da177e4SLinus Torvalds * Address Parameter and other parameter will not be wrapped in this function
27961da177e4SLinus Torvalds */
sctp_make_asconf(struct sctp_association * asoc,union sctp_addr * addr,int vparam_len)27971da177e4SLinus Torvalds static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc,
27981da177e4SLinus Torvalds union sctp_addr *addr,
27991da177e4SLinus Torvalds int vparam_len)
28001da177e4SLinus Torvalds {
280165205cc4SXin Long struct sctp_addiphdr asconf;
28021da177e4SLinus Torvalds struct sctp_chunk *retval;
28031da177e4SLinus Torvalds int length = sizeof(asconf) + vparam_len;
28041da177e4SLinus Torvalds union sctp_addr_param addrparam;
28051da177e4SLinus Torvalds int addrlen;
28061da177e4SLinus Torvalds struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
28071da177e4SLinus Torvalds
28081da177e4SLinus Torvalds addrlen = af->to_addr_param(addr, &addrparam);
28091da177e4SLinus Torvalds if (!addrlen)
28101da177e4SLinus Torvalds return NULL;
28111da177e4SLinus Torvalds length += addrlen;
28121da177e4SLinus Torvalds
28131da177e4SLinus Torvalds /* Create the chunk. */
2814cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_ASCONF, 0, length,
2815cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
28161da177e4SLinus Torvalds if (!retval)
28171da177e4SLinus Torvalds return NULL;
28181da177e4SLinus Torvalds
28191da177e4SLinus Torvalds asconf.serial = htonl(asoc->addip_serial++);
28201da177e4SLinus Torvalds
28211da177e4SLinus Torvalds retval->subh.addip_hdr =
28221da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(asconf), &asconf);
28231da177e4SLinus Torvalds retval->param_hdr.v =
28241da177e4SLinus Torvalds sctp_addto_chunk(retval, addrlen, &addrparam);
28251da177e4SLinus Torvalds
28261da177e4SLinus Torvalds return retval;
28271da177e4SLinus Torvalds }
28281da177e4SLinus Torvalds
28291da177e4SLinus Torvalds /* ADDIP
28301da177e4SLinus Torvalds * 3.2.1 Add IP Address
28311da177e4SLinus Torvalds * 0 1 2 3
28321da177e4SLinus Torvalds * 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
28331da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28341da177e4SLinus Torvalds * | Type = 0xC001 | Length = Variable |
28351da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28361da177e4SLinus Torvalds * | ASCONF-Request Correlation ID |
28371da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28381da177e4SLinus Torvalds * | Address Parameter |
28391da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28401da177e4SLinus Torvalds *
28411da177e4SLinus Torvalds * 3.2.2 Delete IP Address
28421da177e4SLinus Torvalds * 0 1 2 3
28431da177e4SLinus Torvalds * 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
28441da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28451da177e4SLinus Torvalds * | Type = 0xC002 | Length = Variable |
28461da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28471da177e4SLinus Torvalds * | ASCONF-Request Correlation ID |
28481da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28491da177e4SLinus Torvalds * | Address Parameter |
28501da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
28511da177e4SLinus Torvalds *
28521da177e4SLinus Torvalds */
sctp_make_asconf_update_ip(struct sctp_association * asoc,union sctp_addr * laddr,struct sockaddr * addrs,int addrcnt,__be16 flags)28531da177e4SLinus Torvalds struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc,
28541da177e4SLinus Torvalds union sctp_addr *laddr,
28551da177e4SLinus Torvalds struct sockaddr *addrs,
2856327c0dabSXin Long int addrcnt, __be16 flags)
28571da177e4SLinus Torvalds {
28581da177e4SLinus Torvalds union sctp_addr_param addr_param;
2859327c0dabSXin Long struct sctp_addip_param param;
28601da177e4SLinus Torvalds int paramlen = sizeof(param);
2861327c0dabSXin Long struct sctp_chunk *retval;
28621da177e4SLinus Torvalds int addr_param_len = 0;
2863327c0dabSXin Long union sctp_addr *addr;
2864327c0dabSXin Long int totallen = 0, i;
28658a07eb0aSMichio Honda int del_pickup = 0;
2866327c0dabSXin Long struct sctp_af *af;
2867327c0dabSXin Long void *addr_buf;
28681da177e4SLinus Torvalds
28691da177e4SLinus Torvalds /* Get total length of all the address parameters. */
28701da177e4SLinus Torvalds addr_buf = addrs;
28711da177e4SLinus Torvalds for (i = 0; i < addrcnt; i++) {
2872ea110733SJoe Perches addr = addr_buf;
28731da177e4SLinus Torvalds af = sctp_get_af_specific(addr->v4.sin_family);
28741da177e4SLinus Torvalds addr_param_len = af->to_addr_param(addr, &addr_param);
28751da177e4SLinus Torvalds
28761da177e4SLinus Torvalds totallen += paramlen;
28771da177e4SLinus Torvalds totallen += addr_param_len;
28781da177e4SLinus Torvalds
28791da177e4SLinus Torvalds addr_buf += af->sockaddr_len;
28808a07eb0aSMichio Honda if (asoc->asconf_addr_del_pending && !del_pickup) {
28818a07eb0aSMichio Honda /* reuse the parameter length from the same scope one */
28828a07eb0aSMichio Honda totallen += paramlen;
28838a07eb0aSMichio Honda totallen += addr_param_len;
28848a07eb0aSMichio Honda del_pickup = 1;
2885bb33381dSDaniel Borkmann
2886bb33381dSDaniel Borkmann pr_debug("%s: picked same-scope del_pending addr, "
2887bb33381dSDaniel Borkmann "totallen for all addresses is %d\n",
2888bb33381dSDaniel Borkmann __func__, totallen);
28898a07eb0aSMichio Honda }
28901da177e4SLinus Torvalds }
28911da177e4SLinus Torvalds
28921da177e4SLinus Torvalds /* Create an asconf chunk with the required length. */
28931da177e4SLinus Torvalds retval = sctp_make_asconf(asoc, laddr, totallen);
28941da177e4SLinus Torvalds if (!retval)
28951da177e4SLinus Torvalds return NULL;
28961da177e4SLinus Torvalds
28971da177e4SLinus Torvalds /* Add the address parameters to the asconf chunk. */
28981da177e4SLinus Torvalds addr_buf = addrs;
28991da177e4SLinus Torvalds for (i = 0; i < addrcnt; i++) {
2900ea110733SJoe Perches addr = addr_buf;
29011da177e4SLinus Torvalds af = sctp_get_af_specific(addr->v4.sin_family);
29021da177e4SLinus Torvalds addr_param_len = af->to_addr_param(addr, &addr_param);
29031da177e4SLinus Torvalds param.param_hdr.type = flags;
29041da177e4SLinus Torvalds param.param_hdr.length = htons(paramlen + addr_param_len);
2905978aa047SXin Long param.crr_id = htonl(i);
29061da177e4SLinus Torvalds
29071da177e4SLinus Torvalds sctp_addto_chunk(retval, paramlen, ¶m);
29081da177e4SLinus Torvalds sctp_addto_chunk(retval, addr_param_len, &addr_param);
29091da177e4SLinus Torvalds
29101da177e4SLinus Torvalds addr_buf += af->sockaddr_len;
29111da177e4SLinus Torvalds }
29128a07eb0aSMichio Honda if (flags == SCTP_PARAM_ADD_IP && del_pickup) {
29138a07eb0aSMichio Honda addr = asoc->asconf_addr_del_pending;
29148a07eb0aSMichio Honda af = sctp_get_af_specific(addr->v4.sin_family);
29158a07eb0aSMichio Honda addr_param_len = af->to_addr_param(addr, &addr_param);
29168a07eb0aSMichio Honda param.param_hdr.type = SCTP_PARAM_DEL_IP;
29178a07eb0aSMichio Honda param.param_hdr.length = htons(paramlen + addr_param_len);
2918978aa047SXin Long param.crr_id = htonl(i);
29198a07eb0aSMichio Honda
29208a07eb0aSMichio Honda sctp_addto_chunk(retval, paramlen, ¶m);
29218a07eb0aSMichio Honda sctp_addto_chunk(retval, addr_param_len, &addr_param);
29228a07eb0aSMichio Honda }
29231da177e4SLinus Torvalds return retval;
29241da177e4SLinus Torvalds }
29251da177e4SLinus Torvalds
29261da177e4SLinus Torvalds /* ADDIP
29271da177e4SLinus Torvalds * 3.2.4 Set Primary IP Address
29281da177e4SLinus Torvalds * 0 1 2 3
29291da177e4SLinus Torvalds * 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
29301da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29311da177e4SLinus Torvalds * | Type =0xC004 | Length = Variable |
29321da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29331da177e4SLinus Torvalds * | ASCONF-Request Correlation ID |
29341da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29351da177e4SLinus Torvalds * | Address Parameter |
29361da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29371da177e4SLinus Torvalds *
29381da177e4SLinus Torvalds * Create an ASCONF chunk with Set Primary IP address parameter.
29391da177e4SLinus Torvalds */
sctp_make_asconf_set_prim(struct sctp_association * asoc,union sctp_addr * addr)29401da177e4SLinus Torvalds struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc,
29411da177e4SLinus Torvalds union sctp_addr *addr)
29421da177e4SLinus Torvalds {
2943327c0dabSXin Long struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
2944327c0dabSXin Long union sctp_addr_param addrparam;
29458b32f234SXin Long struct sctp_addip_param param;
29461da177e4SLinus Torvalds struct sctp_chunk *retval;
29471da177e4SLinus Torvalds int len = sizeof(param);
29481da177e4SLinus Torvalds int addrlen;
29491da177e4SLinus Torvalds
29501da177e4SLinus Torvalds addrlen = af->to_addr_param(addr, &addrparam);
29511da177e4SLinus Torvalds if (!addrlen)
29521da177e4SLinus Torvalds return NULL;
29531da177e4SLinus Torvalds len += addrlen;
29541da177e4SLinus Torvalds
29551da177e4SLinus Torvalds /* Create the chunk and make asconf header. */
29561da177e4SLinus Torvalds retval = sctp_make_asconf(asoc, addr, len);
29571da177e4SLinus Torvalds if (!retval)
29581da177e4SLinus Torvalds return NULL;
29591da177e4SLinus Torvalds
29601da177e4SLinus Torvalds param.param_hdr.type = SCTP_PARAM_SET_PRIMARY;
29611da177e4SLinus Torvalds param.param_hdr.length = htons(len);
29621da177e4SLinus Torvalds param.crr_id = 0;
29631da177e4SLinus Torvalds
29641da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(param), ¶m);
29651da177e4SLinus Torvalds sctp_addto_chunk(retval, addrlen, &addrparam);
29661da177e4SLinus Torvalds
29671da177e4SLinus Torvalds return retval;
29681da177e4SLinus Torvalds }
29691da177e4SLinus Torvalds
29701da177e4SLinus Torvalds /* ADDIP 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
29711da177e4SLinus Torvalds * 0 1 2 3
29721da177e4SLinus Torvalds * 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
29731da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29741da177e4SLinus Torvalds * | Type = 0x80 | Chunk Flags | Chunk Length |
29751da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29761da177e4SLinus Torvalds * | Serial Number |
29771da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29781da177e4SLinus Torvalds * | ASCONF Parameter Response#1 |
29791da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29801da177e4SLinus Torvalds * \ \
29811da177e4SLinus Torvalds * / .... /
29821da177e4SLinus Torvalds * \ \
29831da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29841da177e4SLinus Torvalds * | ASCONF Parameter Response#N |
29851da177e4SLinus Torvalds * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
29861da177e4SLinus Torvalds *
29871da177e4SLinus Torvalds * Create an ASCONF_ACK chunk with enough space for the parameter responses.
29881da177e4SLinus Torvalds */
sctp_make_asconf_ack(const struct sctp_association * asoc,__u32 serial,int vparam_len)29891da177e4SLinus Torvalds static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *asoc,
29901da177e4SLinus Torvalds __u32 serial, int vparam_len)
29911da177e4SLinus Torvalds {
299265205cc4SXin Long struct sctp_addiphdr asconf;
29931da177e4SLinus Torvalds struct sctp_chunk *retval;
29941da177e4SLinus Torvalds int length = sizeof(asconf) + vparam_len;
29951da177e4SLinus Torvalds
29961da177e4SLinus Torvalds /* Create the chunk. */
2997cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_ASCONF_ACK, 0, length,
2998cea8768fSMarcelo Ricardo Leitner GFP_ATOMIC);
29991da177e4SLinus Torvalds if (!retval)
30001da177e4SLinus Torvalds return NULL;
30011da177e4SLinus Torvalds
30021da177e4SLinus Torvalds asconf.serial = htonl(serial);
30031da177e4SLinus Torvalds
30041da177e4SLinus Torvalds retval->subh.addip_hdr =
30051da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(asconf), &asconf);
30061da177e4SLinus Torvalds
30071da177e4SLinus Torvalds return retval;
30081da177e4SLinus Torvalds }
30091da177e4SLinus Torvalds
30101da177e4SLinus Torvalds /* Add response parameters to an ASCONF_ACK chunk. */
sctp_add_asconf_response(struct sctp_chunk * chunk,__be32 crr_id,__be16 err_code,struct sctp_addip_param * asconf_param)30119f81bcd9SAl Viro static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id,
30128b32f234SXin Long __be16 err_code,
30138b32f234SXin Long struct sctp_addip_param *asconf_param)
30141da177e4SLinus Torvalds {
30158b32f234SXin Long struct sctp_addip_param ack_param;
3016d8238d9dSXin Long struct sctp_errhdr err_param;
30171da177e4SLinus Torvalds int asconf_param_len = 0;
30181da177e4SLinus Torvalds int err_param_len = 0;
3019dbc16db1SAl Viro __be16 response_type;
30201da177e4SLinus Torvalds
30211da177e4SLinus Torvalds if (SCTP_ERROR_NO_ERROR == err_code) {
30221da177e4SLinus Torvalds response_type = SCTP_PARAM_SUCCESS_REPORT;
30231da177e4SLinus Torvalds } else {
30241da177e4SLinus Torvalds response_type = SCTP_PARAM_ERR_CAUSE;
30251da177e4SLinus Torvalds err_param_len = sizeof(err_param);
30261da177e4SLinus Torvalds if (asconf_param)
30271da177e4SLinus Torvalds asconf_param_len =
30281da177e4SLinus Torvalds ntohs(asconf_param->param_hdr.length);
30291da177e4SLinus Torvalds }
30301da177e4SLinus Torvalds
30311da177e4SLinus Torvalds /* Add Success Indication or Error Cause Indication parameter. */
30321da177e4SLinus Torvalds ack_param.param_hdr.type = response_type;
30331da177e4SLinus Torvalds ack_param.param_hdr.length = htons(sizeof(ack_param) +
30341da177e4SLinus Torvalds err_param_len +
30351da177e4SLinus Torvalds asconf_param_len);
30361da177e4SLinus Torvalds ack_param.crr_id = crr_id;
30371da177e4SLinus Torvalds sctp_addto_chunk(chunk, sizeof(ack_param), &ack_param);
30381da177e4SLinus Torvalds
30391da177e4SLinus Torvalds if (SCTP_ERROR_NO_ERROR == err_code)
30401da177e4SLinus Torvalds return;
30411da177e4SLinus Torvalds
30421da177e4SLinus Torvalds /* Add Error Cause parameter. */
30431da177e4SLinus Torvalds err_param.cause = err_code;
30441da177e4SLinus Torvalds err_param.length = htons(err_param_len + asconf_param_len);
30451da177e4SLinus Torvalds sctp_addto_chunk(chunk, err_param_len, &err_param);
30461da177e4SLinus Torvalds
30471da177e4SLinus Torvalds /* Add the failed TLV copied from ASCONF chunk. */
30481da177e4SLinus Torvalds if (asconf_param)
30491da177e4SLinus Torvalds sctp_addto_chunk(chunk, asconf_param_len, asconf_param);
30501da177e4SLinus Torvalds }
30511da177e4SLinus Torvalds
30521da177e4SLinus Torvalds /* Process a asconf parameter. */
sctp_process_asconf_param(struct sctp_association * asoc,struct sctp_chunk * asconf,struct sctp_addip_param * asconf_param)3053dbc16db1SAl Viro static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
30541da177e4SLinus Torvalds struct sctp_chunk *asconf,
30558b32f234SXin Long struct sctp_addip_param *asconf_param)
30561da177e4SLinus Torvalds {
30571da177e4SLinus Torvalds union sctp_addr_param *addr_param;
3058327c0dabSXin Long struct sctp_transport *peer;
3059327c0dabSXin Long union sctp_addr addr;
3060327c0dabSXin Long struct sctp_af *af;
30611da177e4SLinus Torvalds
30628b32f234SXin Long addr_param = (void *)asconf_param + sizeof(*asconf_param);
3063c1cc678aSPatrick McHardy
306444e65c1eSWei Yongjun if (asconf_param->param_hdr.type != SCTP_PARAM_ADD_IP &&
306544e65c1eSWei Yongjun asconf_param->param_hdr.type != SCTP_PARAM_DEL_IP &&
306644e65c1eSWei Yongjun asconf_param->param_hdr.type != SCTP_PARAM_SET_PRIMARY)
306744e65c1eSWei Yongjun return SCTP_ERROR_UNKNOWN_PARAM;
306844e65c1eSWei Yongjun
30696a435732SShan Wei switch (addr_param->p.type) {
3070c4492586SWei Yongjun case SCTP_PARAM_IPV6_ADDRESS:
3071c4492586SWei Yongjun if (!asoc->peer.ipv6_address)
3072945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
3073c4492586SWei Yongjun break;
3074c4492586SWei Yongjun case SCTP_PARAM_IPV4_ADDRESS:
3075c4492586SWei Yongjun if (!asoc->peer.ipv4_address)
3076945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
3077c4492586SWei Yongjun break;
3078c4492586SWei Yongjun default:
3079945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
3080c4492586SWei Yongjun }
3081c4492586SWei Yongjun
30826a435732SShan Wei af = sctp_get_af_specific(param_type2af(addr_param->p.type));
30831da177e4SLinus Torvalds if (unlikely(!af))
3084945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
30851da177e4SLinus Torvalds
30860c5dc070SMarcelo Ricardo Leitner if (!af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0))
30870c5dc070SMarcelo Ricardo Leitner return SCTP_ERROR_DNS_FAILED;
308842e30bf3SVlad Yasevich
308942e30bf3SVlad Yasevich /* ADDIP 4.2.1 This parameter MUST NOT contain a broadcast
309042e30bf3SVlad Yasevich * or multicast address.
309142e30bf3SVlad Yasevich * (note: wildcard is permitted and requires special handling so
309242e30bf3SVlad Yasevich * make sure we check for that)
309342e30bf3SVlad Yasevich */
309442e30bf3SVlad Yasevich if (!af->is_any(&addr) && !af->addr_valid(&addr, NULL, asconf->skb))
3095945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
309642e30bf3SVlad Yasevich
30971da177e4SLinus Torvalds switch (asconf_param->param_hdr.type) {
30981da177e4SLinus Torvalds case SCTP_PARAM_ADD_IP:
309942e30bf3SVlad Yasevich /* Section 4.2.1:
310042e30bf3SVlad Yasevich * If the address 0.0.0.0 or ::0 is provided, the source
310142e30bf3SVlad Yasevich * address of the packet MUST be added.
310242e30bf3SVlad Yasevich */
310342e30bf3SVlad Yasevich if (af->is_any(&addr))
310442e30bf3SVlad Yasevich memcpy(&addr, &asconf->source, sizeof(addr));
310542e30bf3SVlad Yasevich
31062277c7cdSRichard Haines if (security_sctp_bind_connect(asoc->ep->base.sk,
31072277c7cdSRichard Haines SCTP_PARAM_ADD_IP,
31082277c7cdSRichard Haines (struct sockaddr *)&addr,
31092277c7cdSRichard Haines af->sockaddr_len))
31102277c7cdSRichard Haines return SCTP_ERROR_REQ_REFUSED;
31112277c7cdSRichard Haines
31121da177e4SLinus Torvalds /* ADDIP 4.3 D9) If an endpoint receives an ADD IP address
31131da177e4SLinus Torvalds * request and does not have the local resources to add this
31141da177e4SLinus Torvalds * new address to the association, it MUST return an Error
31151da177e4SLinus Torvalds * Cause TLV set to the new error code 'Operation Refused
31161da177e4SLinus Torvalds * Due to Resource Shortage'.
31171da177e4SLinus Torvalds */
31181da177e4SLinus Torvalds
3119dd86d136SAl Viro peer = sctp_assoc_add_peer(asoc, &addr, GFP_ATOMIC, SCTP_UNCONFIRMED);
31201da177e4SLinus Torvalds if (!peer)
31211da177e4SLinus Torvalds return SCTP_ERROR_RSRC_LOW;
31221da177e4SLinus Torvalds
31231da177e4SLinus Torvalds /* Start the heartbeat timer. */
3124ba6f5e33SMarcelo Ricardo Leitner sctp_transport_reset_hb_timer(peer);
31256af29cccSMichio Honda asoc->new_transport = peer;
31261da177e4SLinus Torvalds break;
31271da177e4SLinus Torvalds case SCTP_PARAM_DEL_IP:
31281da177e4SLinus Torvalds /* ADDIP 4.3 D7) If a request is received to delete the
31291da177e4SLinus Torvalds * last remaining IP address of a peer endpoint, the receiver
31301da177e4SLinus Torvalds * MUST send an Error Cause TLV with the error cause set to the
31311da177e4SLinus Torvalds * new error code 'Request to Delete Last Remaining IP Address'.
31321da177e4SLinus Torvalds */
313342e30bf3SVlad Yasevich if (asoc->peer.transport_count == 1)
31341da177e4SLinus Torvalds return SCTP_ERROR_DEL_LAST_IP;
31351da177e4SLinus Torvalds
31361da177e4SLinus Torvalds /* ADDIP 4.3 D8) If a request is received to delete an IP
31371da177e4SLinus Torvalds * address which is also the source address of the IP packet
31381da177e4SLinus Torvalds * which contained the ASCONF chunk, the receiver MUST reject
31391da177e4SLinus Torvalds * this request. To reject the request the receiver MUST send
31401da177e4SLinus Torvalds * an Error Cause TLV set to the new error code 'Request to
31411da177e4SLinus Torvalds * Delete Source IP Address'
31421da177e4SLinus Torvalds */
3143b1364104SMichio Honda if (sctp_cmp_addr_exact(&asconf->source, &addr))
31441da177e4SLinus Torvalds return SCTP_ERROR_DEL_SRC_IP;
31451da177e4SLinus Torvalds
314642e30bf3SVlad Yasevich /* Section 4.2.2
314742e30bf3SVlad Yasevich * If the address 0.0.0.0 or ::0 is provided, all
314842e30bf3SVlad Yasevich * addresses of the peer except the source address of the
314942e30bf3SVlad Yasevich * packet MUST be deleted.
315042e30bf3SVlad Yasevich */
315142e30bf3SVlad Yasevich if (af->is_any(&addr)) {
315242e30bf3SVlad Yasevich sctp_assoc_set_primary(asoc, asconf->transport);
315342e30bf3SVlad Yasevich sctp_assoc_del_nonprimary_peers(asoc,
315442e30bf3SVlad Yasevich asconf->transport);
31557c5a9461Slucien return SCTP_ERROR_NO_ERROR;
31567c5a9461Slucien }
31577c5a9461Slucien
31587c5a9461Slucien /* If the address is not part of the association, the
31597c5a9461Slucien * ASCONF-ACK with Error Cause Indication Parameter
31607c5a9461Slucien * which including cause of Unresolvable Address should
31617c5a9461Slucien * be sent.
31627c5a9461Slucien */
31637c5a9461Slucien peer = sctp_assoc_lookup_paddr(asoc, &addr);
31647c5a9461Slucien if (!peer)
31657c5a9461Slucien return SCTP_ERROR_DNS_FAILED;
31667c5a9461Slucien
31677c5a9461Slucien sctp_assoc_rm_peer(asoc, peer);
31681da177e4SLinus Torvalds break;
31691da177e4SLinus Torvalds case SCTP_PARAM_SET_PRIMARY:
317042e30bf3SVlad Yasevich /* ADDIP Section 4.2.4
317142e30bf3SVlad Yasevich * If the address 0.0.0.0 or ::0 is provided, the receiver
317242e30bf3SVlad Yasevich * MAY mark the source address of the packet as its
317342e30bf3SVlad Yasevich * primary.
317442e30bf3SVlad Yasevich */
317542e30bf3SVlad Yasevich if (af->is_any(&addr))
3176e5272ad4SGustavo A. R. Silva memcpy(&addr, sctp_source(asconf), sizeof(addr));
317742e30bf3SVlad Yasevich
31782277c7cdSRichard Haines if (security_sctp_bind_connect(asoc->ep->base.sk,
31792277c7cdSRichard Haines SCTP_PARAM_SET_PRIMARY,
31802277c7cdSRichard Haines (struct sockaddr *)&addr,
31812277c7cdSRichard Haines af->sockaddr_len))
31822277c7cdSRichard Haines return SCTP_ERROR_REQ_REFUSED;
31832277c7cdSRichard Haines
3184dd86d136SAl Viro peer = sctp_assoc_lookup_paddr(asoc, &addr);
31851da177e4SLinus Torvalds if (!peer)
3186945e5abcSWei Yongjun return SCTP_ERROR_DNS_FAILED;
31871da177e4SLinus Torvalds
31881da177e4SLinus Torvalds sctp_assoc_set_primary(asoc, peer);
31891da177e4SLinus Torvalds break;
31901da177e4SLinus Torvalds }
31911da177e4SLinus Torvalds
31921da177e4SLinus Torvalds return SCTP_ERROR_NO_ERROR;
31931da177e4SLinus Torvalds }
31941da177e4SLinus Torvalds
31956f4c618dSWei Yongjun /* Verify the ASCONF packet before we process it. */
sctp_verify_asconf(const struct sctp_association * asoc,struct sctp_chunk * chunk,bool addr_param_needed,struct sctp_paramhdr ** errp)31969de7922bSDaniel Borkmann bool sctp_verify_asconf(const struct sctp_association *asoc,
31979de7922bSDaniel Borkmann struct sctp_chunk *chunk, bool addr_param_needed,
31989de7922bSDaniel Borkmann struct sctp_paramhdr **errp)
31999de7922bSDaniel Borkmann {
320068d75469SXin Long struct sctp_addip_chunk *addip;
32019de7922bSDaniel Borkmann bool addr_param_seen = false;
3202327c0dabSXin Long union sctp_params param;
32036f4c618dSWei Yongjun
320468d75469SXin Long addip = (struct sctp_addip_chunk *)chunk->chunk_hdr;
3205add7370aSXin Long sctp_walk_params(param, addip) {
32069de7922bSDaniel Borkmann size_t length = ntohs(param.p->length);
32079de7922bSDaniel Borkmann
32086f4c618dSWei Yongjun *errp = param.p;
32096f4c618dSWei Yongjun switch (param.p->type) {
32109de7922bSDaniel Borkmann case SCTP_PARAM_ERR_CAUSE:
32119de7922bSDaniel Borkmann break;
32129de7922bSDaniel Borkmann case SCTP_PARAM_IPV4_ADDRESS:
3213a38905e6SXin Long if (length != sizeof(struct sctp_ipv4addr_param))
32149de7922bSDaniel Borkmann return false;
3215ce7b4cccSlucien /* ensure there is only one addr param and it's in the
3216ce7b4cccSlucien * beginning of addip_hdr params, or we reject it.
3217ce7b4cccSlucien */
3218add7370aSXin Long if (param.v != (addip + 1))
3219ce7b4cccSlucien return false;
32209de7922bSDaniel Borkmann addr_param_seen = true;
32219de7922bSDaniel Borkmann break;
32229de7922bSDaniel Borkmann case SCTP_PARAM_IPV6_ADDRESS:
322300987cc0SXin Long if (length != sizeof(struct sctp_ipv6addr_param))
32249de7922bSDaniel Borkmann return false;
3225add7370aSXin Long if (param.v != (addip + 1))
3226ce7b4cccSlucien return false;
32279de7922bSDaniel Borkmann addr_param_seen = true;
32289de7922bSDaniel Borkmann break;
32296f4c618dSWei Yongjun case SCTP_PARAM_ADD_IP:
32306f4c618dSWei Yongjun case SCTP_PARAM_DEL_IP:
32316f4c618dSWei Yongjun case SCTP_PARAM_SET_PRIMARY:
32329de7922bSDaniel Borkmann /* In ASCONF chunks, these need to be first. */
32339de7922bSDaniel Borkmann if (addr_param_needed && !addr_param_seen)
32349de7922bSDaniel Borkmann return false;
32359de7922bSDaniel Borkmann length = ntohs(param.addip->param_hdr.length);
32368b32f234SXin Long if (length < sizeof(struct sctp_addip_param) +
32373c918704SXin Long sizeof(**errp))
32389de7922bSDaniel Borkmann return false;
32396f4c618dSWei Yongjun break;
32406f4c618dSWei Yongjun case SCTP_PARAM_SUCCESS_REPORT:
32416f4c618dSWei Yongjun case SCTP_PARAM_ADAPTATION_LAYER_IND:
32428b32f234SXin Long if (length != sizeof(struct sctp_addip_param))
32439de7922bSDaniel Borkmann return false;
32446f4c618dSWei Yongjun break;
32456f4c618dSWei Yongjun default:
324621c00a18SLu Wei /* This is unknown to us, reject! */
32479de7922bSDaniel Borkmann return false;
32489de7922bSDaniel Borkmann }
32496f4c618dSWei Yongjun }
32506f4c618dSWei Yongjun
32519de7922bSDaniel Borkmann /* Remaining sanity checks. */
32529de7922bSDaniel Borkmann if (addr_param_needed && !addr_param_seen)
32539de7922bSDaniel Borkmann return false;
32549de7922bSDaniel Borkmann if (!addr_param_needed && addr_param_seen)
32559de7922bSDaniel Borkmann return false;
32569de7922bSDaniel Borkmann if (param.v != chunk->chunk_end)
32579de7922bSDaniel Borkmann return false;
32586f4c618dSWei Yongjun
32599de7922bSDaniel Borkmann return true;
32606f4c618dSWei Yongjun }
32616f4c618dSWei Yongjun
32621da177e4SLinus Torvalds /* Process an incoming ASCONF chunk with the next expected serial no. and
32631da177e4SLinus Torvalds * return an ASCONF_ACK chunk to be sent in response.
32641da177e4SLinus Torvalds */
sctp_process_asconf(struct sctp_association * asoc,struct sctp_chunk * asconf)32651da177e4SLinus Torvalds struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc,
32661da177e4SLinus Torvalds struct sctp_chunk *asconf)
32671da177e4SLinus Torvalds {
32681da177e4SLinus Torvalds union sctp_addr_param *addr_param;
3269327c0dabSXin Long struct sctp_addip_chunk *addip;
32701da177e4SLinus Torvalds struct sctp_chunk *asconf_ack;
3271327c0dabSXin Long bool all_param_pass = true;
3272327c0dabSXin Long struct sctp_addiphdr *hdr;
3273327c0dabSXin Long int length = 0, chunk_len;
3274327c0dabSXin Long union sctp_params param;
3275dbc16db1SAl Viro __be16 err_code;
32761da177e4SLinus Torvalds __u32 serial;
32771da177e4SLinus Torvalds
327868d75469SXin Long addip = (struct sctp_addip_chunk *)asconf->chunk_hdr;
3279922dbc5bSXin Long chunk_len = ntohs(asconf->chunk_hdr->length) -
3280922dbc5bSXin Long sizeof(struct sctp_chunkhdr);
328165205cc4SXin Long hdr = (struct sctp_addiphdr *)asconf->skb->data;
32821da177e4SLinus Torvalds serial = ntohl(hdr->serial);
32831da177e4SLinus Torvalds
32841da177e4SLinus Torvalds /* Skip the addiphdr and store a pointer to address parameter. */
328565205cc4SXin Long length = sizeof(*hdr);
32861da177e4SLinus Torvalds addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
32871da177e4SLinus Torvalds chunk_len -= length;
32881da177e4SLinus Torvalds
32891da177e4SLinus Torvalds /* Skip the address parameter and store a pointer to the first
32907aa1b54bSJoe Perches * asconf parameter.
32911da177e4SLinus Torvalds */
32926a435732SShan Wei length = ntohs(addr_param->p.length);
32931da177e4SLinus Torvalds chunk_len -= length;
32941da177e4SLinus Torvalds
32951da177e4SLinus Torvalds /* create an ASCONF_ACK chunk.
32961da177e4SLinus Torvalds * Based on the definitions of parameters, we know that the size of
32972cab86beSWei Yongjun * ASCONF_ACK parameters are less than or equal to the fourfold of ASCONF
32987aa1b54bSJoe Perches * parameters.
32991da177e4SLinus Torvalds */
33002cab86beSWei Yongjun asconf_ack = sctp_make_asconf_ack(asoc, serial, chunk_len * 4);
33011da177e4SLinus Torvalds if (!asconf_ack)
33021da177e4SLinus Torvalds goto done;
33031da177e4SLinus Torvalds
33041da177e4SLinus Torvalds /* Process the TLVs contained within the ASCONF chunk. */
3305add7370aSXin Long sctp_walk_params(param, addip) {
33069de7922bSDaniel Borkmann /* Skip preceeding address parameters. */
33079de7922bSDaniel Borkmann if (param.p->type == SCTP_PARAM_IPV4_ADDRESS ||
33089de7922bSDaniel Borkmann param.p->type == SCTP_PARAM_IPV6_ADDRESS)
33099de7922bSDaniel Borkmann continue;
33109de7922bSDaniel Borkmann
33111da177e4SLinus Torvalds err_code = sctp_process_asconf_param(asoc, asconf,
33129de7922bSDaniel Borkmann param.addip);
33131da177e4SLinus Torvalds /* ADDIP 4.1 A7)
33141da177e4SLinus Torvalds * If an error response is received for a TLV parameter,
33151da177e4SLinus Torvalds * all TLVs with no response before the failed TLV are
33161da177e4SLinus Torvalds * considered successful if not reported. All TLVs after
33171da177e4SLinus Torvalds * the failed response are considered unsuccessful unless
33181da177e4SLinus Torvalds * a specific success indication is present for the parameter.
33191da177e4SLinus Torvalds */
33209de7922bSDaniel Borkmann if (err_code != SCTP_ERROR_NO_ERROR)
33219de7922bSDaniel Borkmann all_param_pass = false;
33221da177e4SLinus Torvalds if (!all_param_pass)
33239de7922bSDaniel Borkmann sctp_add_asconf_response(asconf_ack, param.addip->crr_id,
33249de7922bSDaniel Borkmann err_code, param.addip);
33251da177e4SLinus Torvalds
33261da177e4SLinus Torvalds /* ADDIP 4.3 D11) When an endpoint receiving an ASCONF to add
33271da177e4SLinus Torvalds * an IP address sends an 'Out of Resource' in its response, it
33281da177e4SLinus Torvalds * MUST also fail any subsequent add or delete requests bundled
33291da177e4SLinus Torvalds * in the ASCONF.
33301da177e4SLinus Torvalds */
33319de7922bSDaniel Borkmann if (err_code == SCTP_ERROR_RSRC_LOW)
33321da177e4SLinus Torvalds goto done;
33331da177e4SLinus Torvalds }
33341da177e4SLinus Torvalds done:
33351da177e4SLinus Torvalds asoc->peer.addip_serial++;
33361da177e4SLinus Torvalds
33371da177e4SLinus Torvalds /* If we are sending a new ASCONF_ACK hold a reference to it in assoc
33381da177e4SLinus Torvalds * after freeing the reference to old asconf ack if any.
33391da177e4SLinus Torvalds */
33401da177e4SLinus Torvalds if (asconf_ack) {
33411da177e4SLinus Torvalds sctp_chunk_hold(asconf_ack);
3342a08de64dSVlad Yasevich list_add_tail(&asconf_ack->transmitted_list,
3343a08de64dSVlad Yasevich &asoc->asconf_ack_list);
33441da177e4SLinus Torvalds }
33451da177e4SLinus Torvalds
33461da177e4SLinus Torvalds return asconf_ack;
33471da177e4SLinus Torvalds }
33481da177e4SLinus Torvalds
33491da177e4SLinus Torvalds /* Process a asconf parameter that is successfully acked. */
sctp_asconf_param_success(struct sctp_association * asoc,struct sctp_addip_param * asconf_param)3350425e0f68SWei Yongjun static void sctp_asconf_param_success(struct sctp_association *asoc,
33518b32f234SXin Long struct sctp_addip_param *asconf_param)
33521da177e4SLinus Torvalds {
33531da177e4SLinus Torvalds struct sctp_bind_addr *bp = &asoc->base.bind_addr;
33541da177e4SLinus Torvalds union sctp_addr_param *addr_param;
3355dc022a98SSridhar Samudrala struct sctp_sockaddr_entry *saddr;
3356327c0dabSXin Long struct sctp_transport *transport;
3357327c0dabSXin Long union sctp_addr addr;
3358327c0dabSXin Long struct sctp_af *af;
33591da177e4SLinus Torvalds
33608b32f234SXin Long addr_param = (void *)asconf_param + sizeof(*asconf_param);
33611da177e4SLinus Torvalds
33621da177e4SLinus Torvalds /* We have checked the packet before, so we do not check again. */
33636a435732SShan Wei af = sctp_get_af_specific(param_type2af(addr_param->p.type));
33640c5dc070SMarcelo Ricardo Leitner if (!af->from_addr_param(&addr, addr_param, htons(bp->port), 0))
33650c5dc070SMarcelo Ricardo Leitner return;
33661da177e4SLinus Torvalds
33671da177e4SLinus Torvalds switch (asconf_param->param_hdr.type) {
33681da177e4SLinus Torvalds case SCTP_PARAM_ADD_IP:
3369559cf710SVlad Yasevich /* This is always done in BH context with a socket lock
3370559cf710SVlad Yasevich * held, so the list can not change.
3371559cf710SVlad Yasevich */
33720ed90fb0SVlad Yasevich local_bh_disable();
3373559cf710SVlad Yasevich list_for_each_entry(saddr, &bp->address_list, list) {
3374dd86d136SAl Viro if (sctp_cmp_addr_exact(&saddr->a, &addr))
3375f57d96b2SVlad Yasevich saddr->state = SCTP_ADDR_SRC;
3376dc022a98SSridhar Samudrala }
33770ed90fb0SVlad Yasevich local_bh_enable();
33783cd9749cSWei Yongjun list_for_each_entry(transport, &asoc->peer.transport_addr_list,
33793cd9749cSWei Yongjun transports) {
3380c86a773cSJulian Anastasov sctp_transport_dst_release(transport);
33813cd9749cSWei Yongjun }
33821da177e4SLinus Torvalds break;
33831da177e4SLinus Torvalds case SCTP_PARAM_DEL_IP:
33840ed90fb0SVlad Yasevich local_bh_disable();
3385425e0f68SWei Yongjun sctp_del_bind_addr(bp, &addr);
33868a07eb0aSMichio Honda if (asoc->asconf_addr_del_pending != NULL &&
33878a07eb0aSMichio Honda sctp_cmp_addr_exact(asoc->asconf_addr_del_pending, &addr)) {
33888a07eb0aSMichio Honda kfree(asoc->asconf_addr_del_pending);
33898a07eb0aSMichio Honda asoc->asconf_addr_del_pending = NULL;
33908a07eb0aSMichio Honda }
33910ed90fb0SVlad Yasevich local_bh_enable();
33929dbc15f0SRobert P. J. Day list_for_each_entry(transport, &asoc->peer.transport_addr_list,
33939dbc15f0SRobert P. J. Day transports) {
3394c86a773cSJulian Anastasov sctp_transport_dst_release(transport);
33951da177e4SLinus Torvalds }
33961da177e4SLinus Torvalds break;
33971da177e4SLinus Torvalds default:
33981da177e4SLinus Torvalds break;
33991da177e4SLinus Torvalds }
34001da177e4SLinus Torvalds }
34011da177e4SLinus Torvalds
34021da177e4SLinus Torvalds /* Get the corresponding ASCONF response error code from the ASCONF_ACK chunk
34031da177e4SLinus Torvalds * for the given asconf parameter. If there is no response for this parameter,
34041da177e4SLinus Torvalds * return the error code based on the third argument 'no_err'.
34051da177e4SLinus Torvalds * ADDIP 4.1
34061da177e4SLinus Torvalds * A7) If an error response is received for a TLV parameter, all TLVs with no
34071da177e4SLinus Torvalds * response before the failed TLV are considered successful if not reported.
34081da177e4SLinus Torvalds * All TLVs after the failed response are considered unsuccessful unless a
34091da177e4SLinus Torvalds * specific success indication is present for the parameter.
34101da177e4SLinus Torvalds */
sctp_get_asconf_response(struct sctp_chunk * asconf_ack,struct sctp_addip_param * asconf_param,int no_err)3411dbc16db1SAl Viro static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack,
34128b32f234SXin Long struct sctp_addip_param *asconf_param,
34131da177e4SLinus Torvalds int no_err)
34141da177e4SLinus Torvalds {
34158b32f234SXin Long struct sctp_addip_param *asconf_ack_param;
3416d8238d9dSXin Long struct sctp_errhdr *err_param;
3417f3830cccSWei Yongjun int asconf_ack_len;
3418dbc16db1SAl Viro __be16 err_code;
3419327c0dabSXin Long int length;
34201da177e4SLinus Torvalds
34211da177e4SLinus Torvalds if (no_err)
34221da177e4SLinus Torvalds err_code = SCTP_ERROR_NO_ERROR;
34231da177e4SLinus Torvalds else
34241da177e4SLinus Torvalds err_code = SCTP_ERROR_REQ_REFUSED;
34251da177e4SLinus Torvalds
3426f3830cccSWei Yongjun asconf_ack_len = ntohs(asconf_ack->chunk_hdr->length) -
3427922dbc5bSXin Long sizeof(struct sctp_chunkhdr);
3428f3830cccSWei Yongjun
34291da177e4SLinus Torvalds /* Skip the addiphdr from the asconf_ack chunk and store a pointer to
34301da177e4SLinus Torvalds * the first asconf_ack parameter.
34311da177e4SLinus Torvalds */
343265205cc4SXin Long length = sizeof(struct sctp_addiphdr);
34338b32f234SXin Long asconf_ack_param = (struct sctp_addip_param *)(asconf_ack->skb->data +
34341da177e4SLinus Torvalds length);
34351da177e4SLinus Torvalds asconf_ack_len -= length;
34361da177e4SLinus Torvalds
34371da177e4SLinus Torvalds while (asconf_ack_len > 0) {
34381da177e4SLinus Torvalds if (asconf_ack_param->crr_id == asconf_param->crr_id) {
34391da177e4SLinus Torvalds switch (asconf_ack_param->param_hdr.type) {
34401da177e4SLinus Torvalds case SCTP_PARAM_SUCCESS_REPORT:
34411da177e4SLinus Torvalds return SCTP_ERROR_NO_ERROR;
34421da177e4SLinus Torvalds case SCTP_PARAM_ERR_CAUSE:
34438b32f234SXin Long length = sizeof(*asconf_ack_param);
3444ea110733SJoe Perches err_param = (void *)asconf_ack_param + length;
34451da177e4SLinus Torvalds asconf_ack_len -= length;
34461da177e4SLinus Torvalds if (asconf_ack_len > 0)
34471da177e4SLinus Torvalds return err_param->cause;
34481da177e4SLinus Torvalds else
34491da177e4SLinus Torvalds return SCTP_ERROR_INV_PARAM;
34501da177e4SLinus Torvalds break;
34511da177e4SLinus Torvalds default:
34521da177e4SLinus Torvalds return SCTP_ERROR_INV_PARAM;
34531da177e4SLinus Torvalds }
34541da177e4SLinus Torvalds }
34551da177e4SLinus Torvalds
34561da177e4SLinus Torvalds length = ntohs(asconf_ack_param->param_hdr.length);
3457ea110733SJoe Perches asconf_ack_param = (void *)asconf_ack_param + length;
34581da177e4SLinus Torvalds asconf_ack_len -= length;
34591da177e4SLinus Torvalds }
34601da177e4SLinus Torvalds
34611da177e4SLinus Torvalds return err_code;
34621da177e4SLinus Torvalds }
34631da177e4SLinus Torvalds
34641da177e4SLinus Torvalds /* Process an incoming ASCONF_ACK chunk against the cached last ASCONF chunk. */
sctp_process_asconf_ack(struct sctp_association * asoc,struct sctp_chunk * asconf_ack)34651da177e4SLinus Torvalds int sctp_process_asconf_ack(struct sctp_association *asoc,
34661da177e4SLinus Torvalds struct sctp_chunk *asconf_ack)
34671da177e4SLinus Torvalds {
34681da177e4SLinus Torvalds struct sctp_chunk *asconf = asoc->addip_last_asconf;
34698b32f234SXin Long struct sctp_addip_param *asconf_param;
3470327c0dabSXin Long __be16 err_code = SCTP_ERROR_NO_ERROR;
3471327c0dabSXin Long union sctp_addr_param *addr_param;
34721da177e4SLinus Torvalds int asconf_len = asconf->skb->len;
34731da177e4SLinus Torvalds int all_param_pass = 0;
3474327c0dabSXin Long int length = 0;
34751da177e4SLinus Torvalds int no_err = 1;
34761da177e4SLinus Torvalds int retval = 0;
34771da177e4SLinus Torvalds
34781da177e4SLinus Torvalds /* Skip the chunkhdr and addiphdr from the last asconf sent and store
34791da177e4SLinus Torvalds * a pointer to address parameter.
34801da177e4SLinus Torvalds */
348168d75469SXin Long length = sizeof(struct sctp_addip_chunk);
34821da177e4SLinus Torvalds addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
34831da177e4SLinus Torvalds asconf_len -= length;
34841da177e4SLinus Torvalds
34851da177e4SLinus Torvalds /* Skip the address parameter in the last asconf sent and store a
34867aa1b54bSJoe Perches * pointer to the first asconf parameter.
34871da177e4SLinus Torvalds */
34886a435732SShan Wei length = ntohs(addr_param->p.length);
3489ea110733SJoe Perches asconf_param = (void *)addr_param + length;
34901da177e4SLinus Torvalds asconf_len -= length;
34911da177e4SLinus Torvalds
34921da177e4SLinus Torvalds /* ADDIP 4.1
34931da177e4SLinus Torvalds * A8) If there is no response(s) to specific TLV parameter(s), and no
34941da177e4SLinus Torvalds * failures are indicated, then all request(s) are considered
34951da177e4SLinus Torvalds * successful.
34961da177e4SLinus Torvalds */
349765205cc4SXin Long if (asconf_ack->skb->len == sizeof(struct sctp_addiphdr))
34981da177e4SLinus Torvalds all_param_pass = 1;
34991da177e4SLinus Torvalds
35001da177e4SLinus Torvalds /* Process the TLVs contained in the last sent ASCONF chunk. */
35011da177e4SLinus Torvalds while (asconf_len > 0) {
35021da177e4SLinus Torvalds if (all_param_pass)
35031da177e4SLinus Torvalds err_code = SCTP_ERROR_NO_ERROR;
35041da177e4SLinus Torvalds else {
35051da177e4SLinus Torvalds err_code = sctp_get_asconf_response(asconf_ack,
35061da177e4SLinus Torvalds asconf_param,
35071da177e4SLinus Torvalds no_err);
35081da177e4SLinus Torvalds if (no_err && (SCTP_ERROR_NO_ERROR != err_code))
35091da177e4SLinus Torvalds no_err = 0;
35101da177e4SLinus Torvalds }
35111da177e4SLinus Torvalds
35121da177e4SLinus Torvalds switch (err_code) {
35131da177e4SLinus Torvalds case SCTP_ERROR_NO_ERROR:
3514425e0f68SWei Yongjun sctp_asconf_param_success(asoc, asconf_param);
35151da177e4SLinus Torvalds break;
35161da177e4SLinus Torvalds
35171da177e4SLinus Torvalds case SCTP_ERROR_RSRC_LOW:
35181da177e4SLinus Torvalds retval = 1;
35191da177e4SLinus Torvalds break;
35201da177e4SLinus Torvalds
3521a987f762SWei Yongjun case SCTP_ERROR_UNKNOWN_PARAM:
35221da177e4SLinus Torvalds /* Disable sending this type of asconf parameter in
35231da177e4SLinus Torvalds * future.
35241da177e4SLinus Torvalds */
35251da177e4SLinus Torvalds asoc->peer.addip_disabled_mask |=
35261da177e4SLinus Torvalds asconf_param->param_hdr.type;
35271da177e4SLinus Torvalds break;
35281da177e4SLinus Torvalds
35291da177e4SLinus Torvalds case SCTP_ERROR_REQ_REFUSED:
35301da177e4SLinus Torvalds case SCTP_ERROR_DEL_LAST_IP:
35311da177e4SLinus Torvalds case SCTP_ERROR_DEL_SRC_IP:
35321da177e4SLinus Torvalds default:
35331da177e4SLinus Torvalds break;
35341da177e4SLinus Torvalds }
35351da177e4SLinus Torvalds
35361da177e4SLinus Torvalds /* Skip the processed asconf parameter and move to the next
35371da177e4SLinus Torvalds * one.
35381da177e4SLinus Torvalds */
35391da177e4SLinus Torvalds length = ntohs(asconf_param->param_hdr.length);
3540ea110733SJoe Perches asconf_param = (void *)asconf_param + length;
35411da177e4SLinus Torvalds asconf_len -= length;
35421da177e4SLinus Torvalds }
35431da177e4SLinus Torvalds
3544ddc4bbeeSMichio Honda if (no_err && asoc->src_out_of_asoc_ok) {
35458a07eb0aSMichio Honda asoc->src_out_of_asoc_ok = 0;
3546ddc4bbeeSMichio Honda sctp_transport_immediate_rtx(asoc->peer.primary_path);
3547ddc4bbeeSMichio Honda }
35488a07eb0aSMichio Honda
35491da177e4SLinus Torvalds /* Free the cached last sent asconf chunk. */
35505f9646c3SVlad Yasevich list_del_init(&asconf->transmitted_list);
35511da177e4SLinus Torvalds sctp_chunk_free(asconf);
35521da177e4SLinus Torvalds asoc->addip_last_asconf = NULL;
35531da177e4SLinus Torvalds
35541da177e4SLinus Torvalds return retval;
35551da177e4SLinus Torvalds }
35561da177e4SLinus Torvalds
35571da177e4SLinus Torvalds /* Make a FWD TSN chunk. */
sctp_make_fwdtsn(const struct sctp_association * asoc,__u32 new_cum_tsn,size_t nstreams,struct sctp_fwdtsn_skip * skiplist)35581da177e4SLinus Torvalds struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
35591da177e4SLinus Torvalds __u32 new_cum_tsn, size_t nstreams,
35601da177e4SLinus Torvalds struct sctp_fwdtsn_skip *skiplist)
35611da177e4SLinus Torvalds {
35621da177e4SLinus Torvalds struct sctp_chunk *retval = NULL;
35631da177e4SLinus Torvalds struct sctp_fwdtsn_hdr ftsn_hdr;
35641da177e4SLinus Torvalds struct sctp_fwdtsn_skip skip;
35651da177e4SLinus Torvalds size_t hint;
35661da177e4SLinus Torvalds int i;
35671da177e4SLinus Torvalds
35681da177e4SLinus Torvalds hint = (nstreams + 1) * sizeof(__u32);
35691da177e4SLinus Torvalds
3570cea8768fSMarcelo Ricardo Leitner retval = sctp_make_control(asoc, SCTP_CID_FWD_TSN, 0, hint, GFP_ATOMIC);
35711da177e4SLinus Torvalds
35721da177e4SLinus Torvalds if (!retval)
35731da177e4SLinus Torvalds return NULL;
35741da177e4SLinus Torvalds
35751da177e4SLinus Torvalds ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
35761da177e4SLinus Torvalds retval->subh.fwdtsn_hdr =
35771da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
35781da177e4SLinus Torvalds
35791da177e4SLinus Torvalds for (i = 0; i < nstreams; i++) {
35801da177e4SLinus Torvalds skip.stream = skiplist[i].stream;
35811da177e4SLinus Torvalds skip.ssn = skiplist[i].ssn;
35821da177e4SLinus Torvalds sctp_addto_chunk(retval, sizeof(skip), &skip);
35831da177e4SLinus Torvalds }
35841da177e4SLinus Torvalds
35851da177e4SLinus Torvalds return retval;
35861da177e4SLinus Torvalds }
3587cc16f00fSXin Long
sctp_make_ifwdtsn(const struct sctp_association * asoc,__u32 new_cum_tsn,size_t nstreams,struct sctp_ifwdtsn_skip * skiplist)35882d07a49aSXin Long struct sctp_chunk *sctp_make_ifwdtsn(const struct sctp_association *asoc,
35892d07a49aSXin Long __u32 new_cum_tsn, size_t nstreams,
35902d07a49aSXin Long struct sctp_ifwdtsn_skip *skiplist)
35912d07a49aSXin Long {
35922d07a49aSXin Long struct sctp_chunk *retval = NULL;
35932d07a49aSXin Long struct sctp_ifwdtsn_hdr ftsn_hdr;
35942d07a49aSXin Long size_t hint;
35952d07a49aSXin Long
35962d07a49aSXin Long hint = (nstreams + 1) * sizeof(__u32);
35972d07a49aSXin Long
35982d07a49aSXin Long retval = sctp_make_control(asoc, SCTP_CID_I_FWD_TSN, 0, hint,
35992d07a49aSXin Long GFP_ATOMIC);
36002d07a49aSXin Long if (!retval)
36012d07a49aSXin Long return NULL;
36022d07a49aSXin Long
36032d07a49aSXin Long ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
36042d07a49aSXin Long retval->subh.ifwdtsn_hdr =
36052d07a49aSXin Long sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
36062d07a49aSXin Long
36072d07a49aSXin Long sctp_addto_chunk(retval, nstreams * sizeof(skiplist[0]), skiplist);
36082d07a49aSXin Long
36092d07a49aSXin Long return retval;
36102d07a49aSXin Long }
36112d07a49aSXin Long
3612cc16f00fSXin Long /* RE-CONFIG 3.1 (RE-CONFIG chunk)
3613cc16f00fSXin Long * 0 1 2 3
3614cc16f00fSXin Long * 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
3615cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3616cc16f00fSXin Long * | Type = 130 | Chunk Flags | Chunk Length |
3617cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3618cc16f00fSXin Long * \ \
3619cc16f00fSXin Long * / Re-configuration Parameter /
3620cc16f00fSXin Long * \ \
3621cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3622cc16f00fSXin Long * \ \
3623cc16f00fSXin Long * / Re-configuration Parameter (optional) /
3624cc16f00fSXin Long * \ \
3625cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3626cc16f00fSXin Long */
sctp_make_reconf(const struct sctp_association * asoc,int length)3627327c0dabSXin Long static struct sctp_chunk *sctp_make_reconf(const struct sctp_association *asoc,
3628cc16f00fSXin Long int length)
3629cc16f00fSXin Long {
3630cc16f00fSXin Long struct sctp_reconf_chunk *reconf;
3631cc16f00fSXin Long struct sctp_chunk *retval;
3632cc16f00fSXin Long
3633cc16f00fSXin Long retval = sctp_make_control(asoc, SCTP_CID_RECONF, 0, length,
3634cc16f00fSXin Long GFP_ATOMIC);
3635cc16f00fSXin Long if (!retval)
3636cc16f00fSXin Long return NULL;
3637cc16f00fSXin Long
3638cc16f00fSXin Long reconf = (struct sctp_reconf_chunk *)retval->chunk_hdr;
3639add7370aSXin Long retval->param_hdr.v = (u8 *)(reconf + 1);
3640cc16f00fSXin Long
3641cc16f00fSXin Long return retval;
3642cc16f00fSXin Long }
3643cc16f00fSXin Long
3644cc16f00fSXin Long /* RE-CONFIG 4.1 (STREAM OUT RESET)
3645cc16f00fSXin Long * 0 1 2 3
3646cc16f00fSXin Long * 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
3647cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3648cc16f00fSXin Long * | Parameter Type = 13 | Parameter Length = 16 + 2 * N |
3649cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3650cc16f00fSXin Long * | Re-configuration Request Sequence Number |
3651cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3652cc16f00fSXin Long * | Re-configuration Response Sequence Number |
3653cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3654cc16f00fSXin Long * | Sender's Last Assigned TSN |
3655cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3656cc16f00fSXin Long * | Stream Number 1 (optional) | Stream Number 2 (optional) |
3657cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3658cc16f00fSXin Long * / ...... /
3659cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3660cc16f00fSXin Long * | Stream Number N-1 (optional) | Stream Number N (optional) |
3661cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3662cc16f00fSXin Long *
3663cc16f00fSXin Long * RE-CONFIG 4.2 (STREAM IN RESET)
3664cc16f00fSXin Long * 0 1 2 3
3665cc16f00fSXin Long * 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
3666cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3667cc16f00fSXin Long * | Parameter Type = 14 | Parameter Length = 8 + 2 * N |
3668cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3669cc16f00fSXin Long * | Re-configuration Request Sequence Number |
3670cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3671cc16f00fSXin Long * | Stream Number 1 (optional) | Stream Number 2 (optional) |
3672cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3673cc16f00fSXin Long * / ...... /
3674cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3675cc16f00fSXin Long * | Stream Number N-1 (optional) | Stream Number N (optional) |
3676cc16f00fSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3677cc16f00fSXin Long */
sctp_make_strreset_req(const struct sctp_association * asoc,__u16 stream_num,__be16 * stream_list,bool out,bool in)3678cc16f00fSXin Long struct sctp_chunk *sctp_make_strreset_req(
3679cc16f00fSXin Long const struct sctp_association *asoc,
36801da4fc97SXin Long __u16 stream_num, __be16 *stream_list,
3681cc16f00fSXin Long bool out, bool in)
3682cc16f00fSXin Long {
3683423852f8SXin Long __u16 stream_len = stream_num * sizeof(__u16);
3684cc16f00fSXin Long struct sctp_strreset_outreq outreq;
3685cc16f00fSXin Long struct sctp_strreset_inreq inreq;
3686cc16f00fSXin Long struct sctp_chunk *retval;
368716e1a919SXin Long __u16 outlen, inlen;
3688cc16f00fSXin Long
3689cc16f00fSXin Long outlen = (sizeof(outreq) + stream_len) * out;
3690cc16f00fSXin Long inlen = (sizeof(inreq) + stream_len) * in;
3691cc16f00fSXin Long
3692a2d859e3SEiichi Tsukata retval = sctp_make_reconf(asoc, SCTP_PAD4(outlen) + SCTP_PAD4(inlen));
3693cc16f00fSXin Long if (!retval)
3694cc16f00fSXin Long return NULL;
3695cc16f00fSXin Long
3696cc16f00fSXin Long if (outlen) {
3697cc16f00fSXin Long outreq.param_hdr.type = SCTP_PARAM_RESET_OUT_REQUEST;
3698cc16f00fSXin Long outreq.param_hdr.length = htons(outlen);
3699cc16f00fSXin Long outreq.request_seq = htonl(asoc->strreset_outseq);
3700cc16f00fSXin Long outreq.response_seq = htonl(asoc->strreset_inseq - 1);
3701cc16f00fSXin Long outreq.send_reset_at_tsn = htonl(asoc->next_tsn - 1);
3702cc16f00fSXin Long
3703cc16f00fSXin Long sctp_addto_chunk(retval, sizeof(outreq), &outreq);
3704cc16f00fSXin Long
3705cc16f00fSXin Long if (stream_len)
3706cc16f00fSXin Long sctp_addto_chunk(retval, stream_len, stream_list);
3707cc16f00fSXin Long }
3708cc16f00fSXin Long
3709cc16f00fSXin Long if (inlen) {
3710cc16f00fSXin Long inreq.param_hdr.type = SCTP_PARAM_RESET_IN_REQUEST;
3711cc16f00fSXin Long inreq.param_hdr.length = htons(inlen);
3712cc16f00fSXin Long inreq.request_seq = htonl(asoc->strreset_outseq + out);
3713cc16f00fSXin Long
3714cc16f00fSXin Long sctp_addto_chunk(retval, sizeof(inreq), &inreq);
3715cc16f00fSXin Long
3716cc16f00fSXin Long if (stream_len)
3717cc16f00fSXin Long sctp_addto_chunk(retval, stream_len, stream_list);
3718cc16f00fSXin Long }
3719cc16f00fSXin Long
3720cc16f00fSXin Long return retval;
3721cc16f00fSXin Long }
3722c56480a1SXin Long
3723c56480a1SXin Long /* RE-CONFIG 4.3 (SSN/TSN RESET ALL)
3724c56480a1SXin Long * 0 1 2 3
3725c56480a1SXin Long * 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
3726c56480a1SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3727c56480a1SXin Long * | Parameter Type = 15 | Parameter Length = 8 |
3728c56480a1SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3729c56480a1SXin Long * | Re-configuration Request Sequence Number |
3730c56480a1SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3731c56480a1SXin Long */
sctp_make_strreset_tsnreq(const struct sctp_association * asoc)3732c56480a1SXin Long struct sctp_chunk *sctp_make_strreset_tsnreq(
3733c56480a1SXin Long const struct sctp_association *asoc)
3734c56480a1SXin Long {
3735c56480a1SXin Long struct sctp_strreset_tsnreq tsnreq;
3736c56480a1SXin Long __u16 length = sizeof(tsnreq);
3737c56480a1SXin Long struct sctp_chunk *retval;
3738c56480a1SXin Long
3739c56480a1SXin Long retval = sctp_make_reconf(asoc, length);
3740c56480a1SXin Long if (!retval)
3741c56480a1SXin Long return NULL;
3742c56480a1SXin Long
3743c56480a1SXin Long tsnreq.param_hdr.type = SCTP_PARAM_RESET_TSN_REQUEST;
3744c56480a1SXin Long tsnreq.param_hdr.length = htons(length);
3745c56480a1SXin Long tsnreq.request_seq = htonl(asoc->strreset_outseq);
3746c56480a1SXin Long
3747c56480a1SXin Long sctp_addto_chunk(retval, sizeof(tsnreq), &tsnreq);
3748c56480a1SXin Long
3749c56480a1SXin Long return retval;
3750c56480a1SXin Long }
375178098117SXin Long
375278098117SXin Long /* RE-CONFIG 4.5/4.6 (ADD STREAM)
375378098117SXin Long * 0 1 2 3
375478098117SXin Long * 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
375578098117SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
375678098117SXin Long * | Parameter Type = 17 | Parameter Length = 12 |
375778098117SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
375878098117SXin Long * | Re-configuration Request Sequence Number |
375978098117SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
376078098117SXin Long * | Number of new streams | Reserved |
376178098117SXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
376278098117SXin Long */
sctp_make_strreset_addstrm(const struct sctp_association * asoc,__u16 out,__u16 in)376378098117SXin Long struct sctp_chunk *sctp_make_strreset_addstrm(
376478098117SXin Long const struct sctp_association *asoc,
376578098117SXin Long __u16 out, __u16 in)
376678098117SXin Long {
376778098117SXin Long struct sctp_strreset_addstrm addstrm;
376878098117SXin Long __u16 size = sizeof(addstrm);
376978098117SXin Long struct sctp_chunk *retval;
377078098117SXin Long
377178098117SXin Long retval = sctp_make_reconf(asoc, (!!out + !!in) * size);
377278098117SXin Long if (!retval)
377378098117SXin Long return NULL;
377478098117SXin Long
377578098117SXin Long if (out) {
377678098117SXin Long addstrm.param_hdr.type = SCTP_PARAM_RESET_ADD_OUT_STREAMS;
377778098117SXin Long addstrm.param_hdr.length = htons(size);
377878098117SXin Long addstrm.number_of_streams = htons(out);
377978098117SXin Long addstrm.request_seq = htonl(asoc->strreset_outseq);
378078098117SXin Long addstrm.reserved = 0;
378178098117SXin Long
378278098117SXin Long sctp_addto_chunk(retval, size, &addstrm);
378378098117SXin Long }
378478098117SXin Long
378578098117SXin Long if (in) {
378678098117SXin Long addstrm.param_hdr.type = SCTP_PARAM_RESET_ADD_IN_STREAMS;
378778098117SXin Long addstrm.param_hdr.length = htons(size);
378878098117SXin Long addstrm.number_of_streams = htons(in);
378978098117SXin Long addstrm.request_seq = htonl(asoc->strreset_outseq + !!out);
379078098117SXin Long addstrm.reserved = 0;
379178098117SXin Long
379278098117SXin Long sctp_addto_chunk(retval, size, &addstrm);
379378098117SXin Long }
379478098117SXin Long
379578098117SXin Long return retval;
379678098117SXin Long }
3797bd4b9f8bSXin Long
3798bd4b9f8bSXin Long /* RE-CONFIG 4.4 (RESP)
3799bd4b9f8bSXin Long * 0 1 2 3
3800bd4b9f8bSXin Long * 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
3801bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3802bd4b9f8bSXin Long * | Parameter Type = 16 | Parameter Length |
3803bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3804bd4b9f8bSXin Long * | Re-configuration Response Sequence Number |
3805bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3806bd4b9f8bSXin Long * | Result |
3807bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3808bd4b9f8bSXin Long */
sctp_make_strreset_resp(const struct sctp_association * asoc,__u32 result,__u32 sn)3809327c0dabSXin Long struct sctp_chunk *sctp_make_strreset_resp(const struct sctp_association *asoc,
3810bd4b9f8bSXin Long __u32 result, __u32 sn)
3811bd4b9f8bSXin Long {
3812bd4b9f8bSXin Long struct sctp_strreset_resp resp;
3813bd4b9f8bSXin Long __u16 length = sizeof(resp);
3814bd4b9f8bSXin Long struct sctp_chunk *retval;
3815bd4b9f8bSXin Long
3816bd4b9f8bSXin Long retval = sctp_make_reconf(asoc, length);
3817bd4b9f8bSXin Long if (!retval)
3818bd4b9f8bSXin Long return NULL;
3819bd4b9f8bSXin Long
3820bd4b9f8bSXin Long resp.param_hdr.type = SCTP_PARAM_RESET_RESPONSE;
3821bd4b9f8bSXin Long resp.param_hdr.length = htons(length);
3822bd4b9f8bSXin Long resp.response_seq = htonl(sn);
3823bd4b9f8bSXin Long resp.result = htonl(result);
3824bd4b9f8bSXin Long
3825bd4b9f8bSXin Long sctp_addto_chunk(retval, sizeof(resp), &resp);
3826bd4b9f8bSXin Long
3827bd4b9f8bSXin Long return retval;
3828bd4b9f8bSXin Long }
3829bd4b9f8bSXin Long
3830bd4b9f8bSXin Long /* RE-CONFIG 4.4 OPTIONAL (TSNRESP)
3831bd4b9f8bSXin Long * 0 1 2 3
3832bd4b9f8bSXin Long * 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
3833bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3834bd4b9f8bSXin Long * | Parameter Type = 16 | Parameter Length |
3835bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3836bd4b9f8bSXin Long * | Re-configuration Response Sequence Number |
3837bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3838bd4b9f8bSXin Long * | Result |
3839bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3840bd4b9f8bSXin Long * | Sender's Next TSN (optional) |
3841bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3842bd4b9f8bSXin Long * | Receiver's Next TSN (optional) |
3843bd4b9f8bSXin Long * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3844bd4b9f8bSXin Long */
sctp_make_strreset_tsnresp(struct sctp_association * asoc,__u32 result,__u32 sn,__u32 sender_tsn,__u32 receiver_tsn)3845327c0dabSXin Long struct sctp_chunk *sctp_make_strreset_tsnresp(struct sctp_association *asoc,
3846bd4b9f8bSXin Long __u32 result, __u32 sn,
3847327c0dabSXin Long __u32 sender_tsn,
3848327c0dabSXin Long __u32 receiver_tsn)
3849bd4b9f8bSXin Long {
3850bd4b9f8bSXin Long struct sctp_strreset_resptsn tsnresp;
3851bd4b9f8bSXin Long __u16 length = sizeof(tsnresp);
3852bd4b9f8bSXin Long struct sctp_chunk *retval;
3853bd4b9f8bSXin Long
3854bd4b9f8bSXin Long retval = sctp_make_reconf(asoc, length);
3855bd4b9f8bSXin Long if (!retval)
3856bd4b9f8bSXin Long return NULL;
3857bd4b9f8bSXin Long
3858bd4b9f8bSXin Long tsnresp.param_hdr.type = SCTP_PARAM_RESET_RESPONSE;
3859bd4b9f8bSXin Long tsnresp.param_hdr.length = htons(length);
3860bd4b9f8bSXin Long
3861bd4b9f8bSXin Long tsnresp.response_seq = htonl(sn);
3862bd4b9f8bSXin Long tsnresp.result = htonl(result);
3863bd4b9f8bSXin Long tsnresp.senders_next_tsn = htonl(sender_tsn);
3864bd4b9f8bSXin Long tsnresp.receivers_next_tsn = htonl(receiver_tsn);
3865bd4b9f8bSXin Long
3866bd4b9f8bSXin Long sctp_addto_chunk(retval, sizeof(tsnresp), &tsnresp);
3867bd4b9f8bSXin Long
3868bd4b9f8bSXin Long return retval;
3869bd4b9f8bSXin Long }
3870ea625043SXin Long
sctp_verify_reconf(const struct sctp_association * asoc,struct sctp_chunk * chunk,struct sctp_paramhdr ** errp)3871ea625043SXin Long bool sctp_verify_reconf(const struct sctp_association *asoc,
3872ea625043SXin Long struct sctp_chunk *chunk,
3873ea625043SXin Long struct sctp_paramhdr **errp)
3874ea625043SXin Long {
3875ea625043SXin Long struct sctp_reconf_chunk *hdr;
3876ea625043SXin Long union sctp_params param;
38771da4fc97SXin Long __be16 last = 0;
38781da4fc97SXin Long __u16 cnt = 0;
3879ea625043SXin Long
3880ea625043SXin Long hdr = (struct sctp_reconf_chunk *)chunk->chunk_hdr;
3881add7370aSXin Long sctp_walk_params(param, hdr) {
3882ea625043SXin Long __u16 length = ntohs(param.p->length);
3883ea625043SXin Long
3884ea625043SXin Long *errp = param.p;
3885ea625043SXin Long if (cnt++ > 2)
3886ea625043SXin Long return false;
3887ea625043SXin Long switch (param.p->type) {
3888ea625043SXin Long case SCTP_PARAM_RESET_OUT_REQUEST:
3889ea625043SXin Long if (length < sizeof(struct sctp_strreset_outreq) ||
3890ea625043SXin Long (last && last != SCTP_PARAM_RESET_RESPONSE &&
3891ea625043SXin Long last != SCTP_PARAM_RESET_IN_REQUEST))
3892ea625043SXin Long return false;
3893ea625043SXin Long break;
3894ea625043SXin Long case SCTP_PARAM_RESET_IN_REQUEST:
3895ea625043SXin Long if (length < sizeof(struct sctp_strreset_inreq) ||
3896ea625043SXin Long (last && last != SCTP_PARAM_RESET_OUT_REQUEST))
3897ea625043SXin Long return false;
3898ea625043SXin Long break;
3899ea625043SXin Long case SCTP_PARAM_RESET_RESPONSE:
3900ea625043SXin Long if ((length != sizeof(struct sctp_strreset_resp) &&
3901ea625043SXin Long length != sizeof(struct sctp_strreset_resptsn)) ||
3902ea625043SXin Long (last && last != SCTP_PARAM_RESET_RESPONSE &&
3903ea625043SXin Long last != SCTP_PARAM_RESET_OUT_REQUEST))
3904ea625043SXin Long return false;
3905ea625043SXin Long break;
3906ea625043SXin Long case SCTP_PARAM_RESET_TSN_REQUEST:
3907ea625043SXin Long if (length !=
3908ea625043SXin Long sizeof(struct sctp_strreset_tsnreq) || last)
3909ea625043SXin Long return false;
3910ea625043SXin Long break;
3911ea625043SXin Long case SCTP_PARAM_RESET_ADD_IN_STREAMS:
3912ea625043SXin Long if (length != sizeof(struct sctp_strreset_addstrm) ||
3913ea625043SXin Long (last && last != SCTP_PARAM_RESET_ADD_OUT_STREAMS))
3914ea625043SXin Long return false;
3915ea625043SXin Long break;
3916ea625043SXin Long case SCTP_PARAM_RESET_ADD_OUT_STREAMS:
3917ea625043SXin Long if (length != sizeof(struct sctp_strreset_addstrm) ||
3918ea625043SXin Long (last && last != SCTP_PARAM_RESET_ADD_IN_STREAMS))
3919ea625043SXin Long return false;
3920ea625043SXin Long break;
3921ea625043SXin Long default:
3922ea625043SXin Long return false;
3923ea625043SXin Long }
3924ea625043SXin Long
3925ea625043SXin Long last = param.p->type;
3926ea625043SXin Long }
3927ea625043SXin Long
3928ea625043SXin Long return true;
3929ea625043SXin Long }
3930