net/sctp/sm_make_chunk.c

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