err.no Git - linux-2.6/blob - net/sctp/sm_statefuns.c

   1 /* SCTP kernel reference Implementation
   2  * (C) Copyright IBM Corp. 2001, 2004
   3  * Copyright (c) 1999-2000 Cisco, Inc.
   4  * Copyright (c) 1999-2001 Motorola, Inc.
   5  * Copyright (c) 2001-2002 Intel Corp.
   6  * Copyright (c) 2002      Nokia Corp.
   7  *
   8  * This file is part of the SCTP kernel reference Implementation
   9  *
  10  * This is part of the SCTP Linux Kernel Reference Implementation.
  11  *
  12  * These are the state functions for the state machine.
  13  *
  14  * The SCTP reference implementation is free software;
  15  * you can redistribute it and/or modify it under the terms of
  16  * the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2, or (at your option)
  18  * any later version.
  19  *
  20  * The SCTP reference implementation is distributed in the hope that it
  21  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  22  *                 ************************
  23  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  24  * See the GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with GNU CC; see the file COPYING.  If not, write to
  28  * the Free Software Foundation, 59 Temple Place - Suite 330,
  29  * Boston, MA 02111-1307, USA.
  30  *
  31  * Please send any bug reports or fixes you make to the
  32  * email address(es):
  33  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
  34  *
  35  * Or submit a bug report through the following website:
  36  *    http://www.sf.net/projects/lksctp
  37  *
  38  * Written or modified by:
  39  *    La Monte H.P. Yarroll <piggy@acm.org>
  40  *    Karl Knutson          <karl@athena.chicago.il.us>
  41  *    Mathew Kotowsky       <kotowsky@sctp.org>
  42  *    Sridhar Samudrala     <samudrala@us.ibm.com>
  43  *    Jon Grimm             <jgrimm@us.ibm.com>
  44  *    Hui Huang             <hui.huang@nokia.com>
  45  *    Dajiang Zhang         <dajiang.zhang@nokia.com>
  46  *    Daisy Chang           <daisyc@us.ibm.com>
  47  *    Ardelle Fan           <ardelle.fan@intel.com>
  48  *    Ryan Layer            <rmlayer@us.ibm.com>
  49  *    Kevin Gao             <kevin.gao@intel.com>
  50  *
  51  * Any bugs reported given to us we will try to fix... any fixes shared will
  52  * be incorporated into the next SCTP release.
  53  */
  54
  55 #include <linux/types.h>
  56 #include <linux/kernel.h>
  57 #include <linux/ip.h>
  58 #include <linux/ipv6.h>
  59 #include <linux/net.h>
  60 #include <linux/inet.h>
  61 #include <net/sock.h>
  62 #include <net/inet_ecn.h>
  63 #include <linux/skbuff.h>
  64 #include <net/sctp/sctp.h>
  65 #include <net/sctp/sm.h>
  66 #include <net/sctp/structs.h>
  67
  68 static struct sctp_packet *sctp_abort_pkt_new(const struct sctp_endpoint *ep,
  69                                   const struct sctp_association *asoc,
  70                                   struct sctp_chunk *chunk,
  71                                   const void *payload,
  72                                   size_t paylen);
  73 static int sctp_eat_data(const struct sctp_association *asoc,
  74                          struct sctp_chunk *chunk,
  75                          sctp_cmd_seq_t *commands);
  76 static struct sctp_packet *sctp_ootb_pkt_new(const struct sctp_association *asoc,
  77                                              const struct sctp_chunk *chunk);
  78 static void sctp_send_stale_cookie_err(const struct sctp_endpoint *ep,
  79                                        const struct sctp_association *asoc,
  80                                        const struct sctp_chunk *chunk,
  81                                        sctp_cmd_seq_t *commands,
  82                                        struct sctp_chunk *err_chunk);
  83 static sctp_disposition_t sctp_sf_do_5_2_6_stale(const struct sctp_endpoint *ep,
  84                                                  const struct sctp_association *asoc,
  85                                                  const sctp_subtype_t type,
  86                                                  void *arg,
  87                                                  sctp_cmd_seq_t *commands);
  88 static sctp_disposition_t sctp_sf_shut_8_4_5(const struct sctp_endpoint *ep,
  89                                              const struct sctp_association *asoc,
  90                                              const sctp_subtype_t type,
  91                                              void *arg,
  92                                              sctp_cmd_seq_t *commands);
  93 static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk);
  94
  95 static sctp_disposition_t sctp_stop_t1_and_abort(sctp_cmd_seq_t *commands,
  96                                            __u16 error,
  97                                            const struct sctp_association *asoc,
  98                                            struct sctp_transport *transport);
  99
 100 static sctp_disposition_t sctp_sf_violation_chunklen(
 101                                      const struct sctp_endpoint *ep,
 102                                      const struct sctp_association *asoc,
 103                                      const sctp_subtype_t type,
 104                                      void *arg,
 105                                      sctp_cmd_seq_t *commands);
 106
 107 /* Small helper function that checks if the chunk length
 108  * is of the appropriate length.  The 'required_length' argument
 109  * is set to be the size of a specific chunk we are testing.
 110  * Return Values:  1 = Valid length
 111  *                 0 = Invalid length
 112  *
 113  */
 114 static inline int
 115 sctp_chunk_length_valid(struct sctp_chunk *chunk,
 116                            __u16 required_length)
 117 {
 118         __u16 chunk_length = ntohs(chunk->chunk_hdr->length);
 119
 120         if (unlikely(chunk_length < required_length))
 121                 return 0;
 122
 123         return 1;
 124 }
 125
 126 /**********************************************************
 127  * These are the state functions for handling chunk events.
 128  **********************************************************/
 129
 130 /*
 131  * Process the final SHUTDOWN COMPLETE.
 132  *
 133  * Section: 4 (C) (diagram), 9.2
 134  * Upon reception of the SHUTDOWN COMPLETE chunk the endpoint will verify
 135  * that it is in SHUTDOWN-ACK-SENT state, if it is not the chunk should be
 136  * discarded. If the endpoint is in the SHUTDOWN-ACK-SENT state the endpoint
 137  * should stop the T2-shutdown timer and remove all knowledge of the
 138  * association (and thus the association enters the CLOSED state).
 139  *
 140  * Verification Tag: 8.5.1(C), sctpimpguide 2.41.
 141  * C) Rules for packet carrying SHUTDOWN COMPLETE:
 142  * ...
 143  * - The receiver of a SHUTDOWN COMPLETE shall accept the packet
 144  *   if the Verification Tag field of the packet matches its own tag and
 145  *   the T bit is not set
 146  *   OR
 147  *   it is set to its peer's tag and the T bit is set in the Chunk
 148  *   Flags.
 149  *   Otherwise, the receiver MUST silently discard the packet
 150  *   and take no further action.  An endpoint MUST ignore the
 151  *   SHUTDOWN COMPLETE if it is not in the SHUTDOWN-ACK-SENT state.
 152  *
 153  * Inputs
 154  * (endpoint, asoc, chunk)
 155  *
 156  * Outputs
 157  * (asoc, reply_msg, msg_up, timers, counters)
 158  *
 159  * The return value is the disposition of the chunk.
 160  */
 161 sctp_disposition_t sctp_sf_do_4_C(const struct sctp_endpoint *ep,
 162                                   const struct sctp_association *asoc,
 163                                   const sctp_subtype_t type,
 164                                   void *arg,
 165                                   sctp_cmd_seq_t *commands)
 166 {
 167         struct sctp_chunk *chunk = arg;
 168         struct sctp_ulpevent *ev;
 169
 170         /* RFC 2960 6.10 Bundling
 171          *
 172          * An endpoint MUST NOT bundle INIT, INIT ACK or
 173          * SHUTDOWN COMPLETE with any other chunks.
 174          */
 175         if (!chunk->singleton)
 176                 return SCTP_DISPOSITION_VIOLATION;
 177
 178         if (!sctp_vtag_verify_either(chunk, asoc))
 179                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 180
 181         /* RFC 2960 10.2 SCTP-to-ULP
 182          *
 183          * H) SHUTDOWN COMPLETE notification
 184          *
 185          * When SCTP completes the shutdown procedures (section 9.2) this
 186          * notification is passed to the upper layer.
 187          */
 188         ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_SHUTDOWN_COMP,
 189                                              0, 0, 0, GFP_ATOMIC);
 190         if (!ev)
 191                 goto nomem;
 192
 193         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
 194
 195         /* Upon reception of the SHUTDOWN COMPLETE chunk the endpoint
 196          * will verify that it is in SHUTDOWN-ACK-SENT state, if it is
 197          * not the chunk should be discarded. If the endpoint is in
 198          * the SHUTDOWN-ACK-SENT state the endpoint should stop the
 199          * T2-shutdown timer and remove all knowledge of the
 200          * association (and thus the association enters the CLOSED
 201          * state).
 202          */
 203         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
 204                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
 205
 206         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
 207                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
 208
 209         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 210                         SCTP_STATE(SCTP_STATE_CLOSED));
 211
 212         SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
 213         SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
 214
 215         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
 216
 217         return SCTP_DISPOSITION_DELETE_TCB;
 218
 219 nomem:
 220         return SCTP_DISPOSITION_NOMEM;
 221 }
 222
 223 /*
 224  * Respond to a normal INIT chunk.
 225  * We are the side that is being asked for an association.
 226  *
 227  * Section: 5.1 Normal Establishment of an Association, B
 228  * B) "Z" shall respond immediately with an INIT ACK chunk.  The
 229  *    destination IP address of the INIT ACK MUST be set to the source
 230  *    IP address of the INIT to which this INIT ACK is responding.  In
 231  *    the response, besides filling in other parameters, "Z" must set the
 232  *    Verification Tag field to Tag_A, and also provide its own
 233  *    Verification Tag (Tag_Z) in the Initiate Tag field.
 234  *
 235  * Verification Tag: Must be 0.
 236  *
 237  * Inputs
 238  * (endpoint, asoc, chunk)
 239  *
 240  * Outputs
 241  * (asoc, reply_msg, msg_up, timers, counters)
 242  *
 243  * The return value is the disposition of the chunk.
 244  */
 245 sctp_disposition_t sctp_sf_do_5_1B_init(const struct sctp_endpoint *ep,
 246                                         const struct sctp_association *asoc,
 247                                         const sctp_subtype_t type,
 248                                         void *arg,
 249                                         sctp_cmd_seq_t *commands)
 250 {
 251         struct sctp_chunk *chunk = arg;
 252         struct sctp_chunk *repl;
 253         struct sctp_association *new_asoc;
 254         struct sctp_chunk *err_chunk;
 255         struct sctp_packet *packet;
 256         sctp_unrecognized_param_t *unk_param;
 257         struct sock *sk;
 258         int len;
 259
 260         /* 6.10 Bundling
 261          * An endpoint MUST NOT bundle INIT, INIT ACK or
 262          * SHUTDOWN COMPLETE with any other chunks.
 263          *
 264          * IG Section 2.11.2
 265          * Furthermore, we require that the receiver of an INIT chunk MUST
 266          * enforce these rules by silently discarding an arriving packet
 267          * with an INIT chunk that is bundled with other chunks.
 268          */
 269         if (!chunk->singleton)
 270                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 271
 272         /* If the packet is an OOTB packet which is temporarily on the
 273          * control endpoint, respond with an ABORT.
 274          */
 275         if (ep == sctp_sk((sctp_get_ctl_sock()))->ep)
 276                 return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
 277
 278         sk = ep->base.sk;
 279         /* If the endpoint is not listening or if the number of associations
 280          * on the TCP-style socket exceed the max backlog, respond with an
 281          * ABORT.
 282          */
 283         if (!sctp_sstate(sk, LISTENING) ||
 284             (sctp_style(sk, TCP) &&
 285              sk_acceptq_is_full(sk)))
 286                 return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
 287
 288         /* 3.1 A packet containing an INIT chunk MUST have a zero Verification
 289          * Tag.
 290          */
 291         if (chunk->sctp_hdr->vtag != 0)
 292                 return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
 293
 294         /* Make sure that the INIT chunk has a valid length.
 295          * Normally, this would cause an ABORT with a Protocol Violation
 296          * error, but since we don't have an association, we'll
 297          * just discard the packet.
 298          */
 299         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_init_chunk_t)))
 300                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 301
 302         /* Verify the INIT chunk before processing it. */
 303         err_chunk = NULL;
 304         if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
 305                               (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
 306                               &err_chunk)) {
 307                 /* This chunk contains fatal error. It is to be discarded.
 308                  * Send an ABORT, with causes if there is any.
 309                  */
 310                 if (err_chunk) {
 311                         packet = sctp_abort_pkt_new(ep, asoc, arg,
 312                                         (__u8 *)(err_chunk->chunk_hdr) +
 313                                         sizeof(sctp_chunkhdr_t),
 314                                         ntohs(err_chunk->chunk_hdr->length) -
 315                                         sizeof(sctp_chunkhdr_t));
 316
 317                         sctp_chunk_free(err_chunk);
 318
 319                         if (packet) {
 320                                 sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
 321                                                 SCTP_PACKET(packet));
 322                                 SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
 323                                 return SCTP_DISPOSITION_CONSUME;
 324                         } else {
 325                                 return SCTP_DISPOSITION_NOMEM;
 326                         }
 327                 } else {
 328                         return sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
 329                                                     commands);
 330                 }
 331         }
 332
 333         /* Grab the INIT header.  */
 334         chunk->subh.init_hdr = (sctp_inithdr_t *)chunk->skb->data;
 335
 336         /* Tag the variable length parameters.  */
 337         chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
 338
 339         new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);
 340         if (!new_asoc)
 341                 goto nomem;
 342
 343         /* The call, sctp_process_init(), can fail on memory allocation.  */
 344         if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
 345                                sctp_source(chunk),
 346                                (sctp_init_chunk_t *)chunk->chunk_hdr,
 347                                GFP_ATOMIC))
 348                 goto nomem_init;
 349
 350         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
 351
 352         /* B) "Z" shall respond immediately with an INIT ACK chunk.  */
 353
 354         /* If there are errors need to be reported for unknown parameters,
 355          * make sure to reserve enough room in the INIT ACK for them.
 356          */
 357         len = 0;
 358         if (err_chunk)
 359                 len = ntohs(err_chunk->chunk_hdr->length) -
 360                         sizeof(sctp_chunkhdr_t);
 361
 362         if (sctp_assoc_set_bind_addr_from_ep(new_asoc, GFP_ATOMIC) < 0)
 363                 goto nomem_ack;
 364
 365         repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);
 366         if (!repl)
 367                 goto nomem_ack;
 368
 369         /* If there are errors need to be reported for unknown parameters,
 370          * include them in the outgoing INIT ACK as "Unrecognized parameter"
 371          * parameter.
 372          */
 373         if (err_chunk) {
 374                 /* Get the "Unrecognized parameter" parameter(s) out of the
 375                  * ERROR chunk generated by sctp_verify_init(). Since the
 376                  * error cause code for "unknown parameter" and the
 377                  * "Unrecognized parameter" type is the same, we can
 378                  * construct the parameters in INIT ACK by copying the
 379                  * ERROR causes over.
 380                  */
 381                 unk_param = (sctp_unrecognized_param_t *)
 382                             ((__u8 *)(err_chunk->chunk_hdr) +
 383                             sizeof(sctp_chunkhdr_t));
 384                 /* Replace the cause code with the "Unrecognized parameter"
 385                  * parameter type.
 386                  */
 387                 sctp_addto_chunk(repl, len, unk_param);
 388                 sctp_chunk_free(err_chunk);
 389         }
 390
 391         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
 392
 393         /*
 394          * Note:  After sending out INIT ACK with the State Cookie parameter,
 395          * "Z" MUST NOT allocate any resources, nor keep any states for the
 396          * new association.  Otherwise, "Z" will be vulnerable to resource
 397          * attacks.
 398          */
 399         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
 400
 401         return SCTP_DISPOSITION_DELETE_TCB;
 402
 403 nomem_ack:
 404         if (err_chunk)
 405                 sctp_chunk_free(err_chunk);
 406 nomem_init:
 407         sctp_association_free(new_asoc);
 408 nomem:
 409         return SCTP_DISPOSITION_NOMEM;
 410 }
 411
 412 /*
 413  * Respond to a normal INIT ACK chunk.
 414  * We are the side that is initiating the association.
 415  *
 416  * Section: 5.1 Normal Establishment of an Association, C
 417  * C) Upon reception of the INIT ACK from "Z", "A" shall stop the T1-init
 418  *    timer and leave COOKIE-WAIT state. "A" shall then send the State
 419  *    Cookie received in the INIT ACK chunk in a COOKIE ECHO chunk, start
 420  *    the T1-cookie timer, and enter the COOKIE-ECHOED state.
 421  *
 422  *    Note: The COOKIE ECHO chunk can be bundled with any pending outbound
 423  *    DATA chunks, but it MUST be the first chunk in the packet and
 424  *    until the COOKIE ACK is returned the sender MUST NOT send any
 425  *    other packets to the peer.
 426  *
 427  * Verification Tag: 3.3.3
 428  *   If the value of the Initiate Tag in a received INIT ACK chunk is
 429  *   found to be 0, the receiver MUST treat it as an error and close the
 430  *   association by transmitting an ABORT.
 431  *
 432  * Inputs
 433  * (endpoint, asoc, chunk)
 434  *
 435  * Outputs
 436  * (asoc, reply_msg, msg_up, timers, counters)
 437  *
 438  * The return value is the disposition of the chunk.
 439  */
 440 sctp_disposition_t sctp_sf_do_5_1C_ack(const struct sctp_endpoint *ep,
 441                                        const struct sctp_association *asoc,
 442                                        const sctp_subtype_t type,
 443                                        void *arg,
 444                                        sctp_cmd_seq_t *commands)
 445 {
 446         struct sctp_chunk *chunk = arg;
 447         sctp_init_chunk_t *initchunk;
 448         __u32 init_tag;
 449         struct sctp_chunk *err_chunk;
 450         struct sctp_packet *packet;
 451         sctp_disposition_t ret;
 452
 453         if (!sctp_vtag_verify(chunk, asoc))
 454                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 455
 456         /* Make sure that the INIT-ACK chunk has a valid length */
 457         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_initack_chunk_t)))
 458                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
 459                                                   commands);
 460         /* 6.10 Bundling
 461          * An endpoint MUST NOT bundle INIT, INIT ACK or
 462          * SHUTDOWN COMPLETE with any other chunks.
 463          */
 464         if (!chunk->singleton)
 465                 return SCTP_DISPOSITION_VIOLATION;
 466
 467         /* Grab the INIT header.  */
 468         chunk->subh.init_hdr = (sctp_inithdr_t *) chunk->skb->data;
 469
 470         init_tag = ntohl(chunk->subh.init_hdr->init_tag);
 471
 472         /* Verification Tag: 3.3.3
 473          *   If the value of the Initiate Tag in a received INIT ACK
 474          *   chunk is found to be 0, the receiver MUST treat it as an
 475          *   error and close the association by transmitting an ABORT.
 476          */
 477         if (!init_tag) {
 478                 struct sctp_chunk *reply = sctp_make_abort(asoc, chunk, 0);
 479                 if (!reply)
 480                         goto nomem;
 481
 482                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
 483                 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 484                                 SCTP_STATE(SCTP_STATE_CLOSED));
 485                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
 486                 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
 487                 return SCTP_DISPOSITION_DELETE_TCB;
 488         }
 489
 490         /* Verify the INIT chunk before processing it. */
 491         err_chunk = NULL;
 492         if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
 493                               (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
 494                               &err_chunk)) {
 495
 496                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
 497
 498                 /* This chunk contains fatal error. It is to be discarded.
 499                  * Send an ABORT, with causes if there is any.
 500                  */
 501                 if (err_chunk) {
 502                         packet = sctp_abort_pkt_new(ep, asoc, arg,
 503                                         (__u8 *)(err_chunk->chunk_hdr) +
 504                                         sizeof(sctp_chunkhdr_t),
 505                                         ntohs(err_chunk->chunk_hdr->length) -
 506                                         sizeof(sctp_chunkhdr_t));
 507
 508                         sctp_chunk_free(err_chunk);
 509
 510                         if (packet) {
 511                                 sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
 512                                                 SCTP_PACKET(packet));
 513                                 SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
 514                                 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 515                                                 SCTP_STATE(SCTP_STATE_CLOSED));
 516                                 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
 517                                                 SCTP_NULL());
 518                                 return SCTP_DISPOSITION_CONSUME;
 519                         } else {
 520                                 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 521                                                 SCTP_STATE(SCTP_STATE_CLOSED));
 522                                 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
 523                                                 SCTP_NULL());
 524                                 return SCTP_DISPOSITION_NOMEM;
 525                         }
 526                 } else {
 527                         ret = sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
 528                                                    commands);
 529                         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 530                                         SCTP_STATE(SCTP_STATE_CLOSED));
 531                         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
 532                                         SCTP_NULL());
 533                         return ret;
 534                 }
 535         }
 536
 537         /* Tag the variable length parameters.  Note that we never
 538          * convert the parameters in an INIT chunk.
 539          */
 540         chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
 541
 542         initchunk = (sctp_init_chunk_t *) chunk->chunk_hdr;
 543
 544         sctp_add_cmd_sf(commands, SCTP_CMD_PEER_INIT,
 545                         SCTP_PEER_INIT(initchunk));
 546
 547         /* Reset init error count upon receipt of INIT-ACK.  */
 548         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_COUNTER_RESET, SCTP_NULL());
 549
 550         /* 5.1 C) "A" shall stop the T1-init timer and leave
 551          * COOKIE-WAIT state.  "A" shall then ... start the T1-cookie
 552          * timer, and enter the COOKIE-ECHOED state.
 553          */
 554         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
 555                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
 556         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
 557                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
 558         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 559                         SCTP_STATE(SCTP_STATE_COOKIE_ECHOED));
 560
 561         /* 5.1 C) "A" shall then send the State Cookie received in the
 562          * INIT ACK chunk in a COOKIE ECHO chunk, ...
 563          */
 564         /* If there is any errors to report, send the ERROR chunk generated
 565          * for unknown parameters as well.
 566          */
 567         sctp_add_cmd_sf(commands, SCTP_CMD_GEN_COOKIE_ECHO,
 568                         SCTP_CHUNK(err_chunk));
 569
 570         return SCTP_DISPOSITION_CONSUME;
 571
 572 nomem:
 573         return SCTP_DISPOSITION_NOMEM;
 574 }
 575
 576 /*
 577  * Respond to a normal COOKIE ECHO chunk.
 578  * We are the side that is being asked for an association.
 579  *
 580  * Section: 5.1 Normal Establishment of an Association, D
 581  * D) Upon reception of the COOKIE ECHO chunk, Endpoint "Z" will reply
 582  *    with a COOKIE ACK chunk after building a TCB and moving to
 583  *    the ESTABLISHED state. A COOKIE ACK chunk may be bundled with
 584  *    any pending DATA chunks (and/or SACK chunks), but the COOKIE ACK
 585  *    chunk MUST be the first chunk in the packet.
 586  *
 587  *   IMPLEMENTATION NOTE: An implementation may choose to send the
 588  *   Communication Up notification to the SCTP user upon reception
 589  *   of a valid COOKIE ECHO chunk.
 590  *
 591  * Verification Tag: 8.5.1 Exceptions in Verification Tag Rules
 592  * D) Rules for packet carrying a COOKIE ECHO
 593  *
 594  * - When sending a COOKIE ECHO, the endpoint MUST use the value of the
 595  *   Initial Tag received in the INIT ACK.
 596  *
 597  * - The receiver of a COOKIE ECHO follows the procedures in Section 5.
 598  *
 599  * Inputs
 600  * (endpoint, asoc, chunk)
 601  *
 602  * Outputs
 603  * (asoc, reply_msg, msg_up, timers, counters)
 604  *
 605  * The return value is the disposition of the chunk.
 606  */
 607 sctp_disposition_t sctp_sf_do_5_1D_ce(const struct sctp_endpoint *ep,
 608                                       const struct sctp_association *asoc,
 609                                       const sctp_subtype_t type, void *arg,
 610                                       sctp_cmd_seq_t *commands)
 611 {
 612         struct sctp_chunk *chunk = arg;
 613         struct sctp_association *new_asoc;
 614         sctp_init_chunk_t *peer_init;
 615         struct sctp_chunk *repl;
 616         struct sctp_ulpevent *ev;
 617         int error = 0;
 618         struct sctp_chunk *err_chk_p;
 619
 620         /* If the packet is an OOTB packet which is temporarily on the
 621          * control endpoint, respond with an ABORT.
 622          */
 623         if (ep == sctp_sk((sctp_get_ctl_sock()))->ep)
 624                 return sctp_sf_ootb(ep, asoc, type, arg, commands);
 625
 626         /* Make sure that the COOKIE_ECHO chunk has a valid length.
 627          * In this case, we check that we have enough for at least a
 628          * chunk header.  More detailed verification is done
 629          * in sctp_unpack_cookie().
 630          */
 631         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
 632                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 633
 634         /* "Decode" the chunk.  We have no optional parameters so we
 635          * are in good shape.
 636          */
 637         chunk->subh.cookie_hdr =
 638                 (struct sctp_signed_cookie *)chunk->skb->data;
 639         skb_pull(chunk->skb,
 640                  ntohs(chunk->chunk_hdr->length) - sizeof(sctp_chunkhdr_t));
 641
 642         /* 5.1 D) Upon reception of the COOKIE ECHO chunk, Endpoint
 643          * "Z" will reply with a COOKIE ACK chunk after building a TCB
 644          * and moving to the ESTABLISHED state.
 645          */
 646         new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,
 647                                       &err_chk_p);
 648
 649         /* FIXME:
 650          * If the re-build failed, what is the proper error path
 651          * from here?
 652          *
 653          * [We should abort the association. --piggy]
 654          */
 655         if (!new_asoc) {
 656                 /* FIXME: Several errors are possible.  A bad cookie should
 657                  * be silently discarded, but think about logging it too.
 658                  */
 659                 switch (error) {
 660                 case -SCTP_IERROR_NOMEM:
 661                         goto nomem;
 662
 663                 case -SCTP_IERROR_STALE_COOKIE:
 664                         sctp_send_stale_cookie_err(ep, asoc, chunk, commands,
 665                                                    err_chk_p);
 666                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 667
 668                 case -SCTP_IERROR_BAD_SIG:
 669                 default:
 670                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 671                 };
 672         }
 673
 674         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
 675         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 676                         SCTP_STATE(SCTP_STATE_ESTABLISHED));
 677         SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
 678         SCTP_INC_STATS(SCTP_MIB_PASSIVEESTABS);
 679         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
 680
 681         if (new_asoc->autoclose)
 682                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
 683                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
 684
 685         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
 686
 687         /* Re-build the bind address for the association is done in
 688          * the sctp_unpack_cookie() already.
 689          */
 690         /* This is a brand-new association, so these are not yet side
 691          * effects--it is safe to run them here.
 692          */
 693         peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
 694
 695         if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
 696                                &chunk->subh.cookie_hdr->c.peer_addr,
 697                                peer_init, GFP_ATOMIC))
 698                 goto nomem_init;
 699
 700         repl = sctp_make_cookie_ack(new_asoc, chunk);
 701         if (!repl)
 702                 goto nomem_repl;
 703
 704         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
 705
 706         /* RFC 2960 5.1 Normal Establishment of an Association
 707          *
 708          * D) IMPLEMENTATION NOTE: An implementation may choose to
 709          * send the Communication Up notification to the SCTP user
 710          * upon reception of a valid COOKIE ECHO chunk.
 711          */
 712         ev = sctp_ulpevent_make_assoc_change(new_asoc, 0, SCTP_COMM_UP, 0,
 713                                              new_asoc->c.sinit_num_ostreams,
 714                                              new_asoc->c.sinit_max_instreams,
 715                                              GFP_ATOMIC);
 716         if (!ev)
 717                 goto nomem_ev;
 718
 719         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
 720
 721         /* Sockets API Draft Section 5.3.1.6
 722          * When a peer sends a Adaption Layer Indication parameter , SCTP
 723          * delivers this notification to inform the application that of the
 724          * peers requested adaption layer.
 725          */
 726         if (new_asoc->peer.adaption_ind) {
 727                 ev = sctp_ulpevent_make_adaption_indication(new_asoc,
 728                                                             GFP_ATOMIC);
 729                 if (!ev)
 730                         goto nomem_ev;
 731
 732                 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
 733                                 SCTP_ULPEVENT(ev));
 734         }
 735
 736         return SCTP_DISPOSITION_CONSUME;
 737
 738 nomem_ev:
 739         sctp_chunk_free(repl);
 740 nomem_repl:
 741 nomem_init:
 742         sctp_association_free(new_asoc);
 743 nomem:
 744         return SCTP_DISPOSITION_NOMEM;
 745 }
 746
 747 /*
 748  * Respond to a normal COOKIE ACK chunk.
 749  * We are the side that is being asked for an association.
 750  *
 751  * RFC 2960 5.1 Normal Establishment of an Association
 752  *
 753  * E) Upon reception of the COOKIE ACK, endpoint "A" will move from the
 754  *    COOKIE-ECHOED state to the ESTABLISHED state, stopping the T1-cookie
 755  *    timer. It may also notify its ULP about the successful
 756  *    establishment of the association with a Communication Up
 757  *    notification (see Section 10).
 758  *
 759  * Verification Tag:
 760  * Inputs
 761  * (endpoint, asoc, chunk)
 762  *
 763  * Outputs
 764  * (asoc, reply_msg, msg_up, timers, counters)
 765  *
 766  * The return value is the disposition of the chunk.
 767  */
 768 sctp_disposition_t sctp_sf_do_5_1E_ca(const struct sctp_endpoint *ep,
 769                                       const struct sctp_association *asoc,
 770                                       const sctp_subtype_t type, void *arg,
 771                                       sctp_cmd_seq_t *commands)
 772 {
 773         struct sctp_chunk *chunk = arg;
 774         struct sctp_ulpevent *ev;
 775
 776         if (!sctp_vtag_verify(chunk, asoc))
 777                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 778
 779         /* Verify that the chunk length for the COOKIE-ACK is OK.
 780          * If we don't do this, any bundled chunks may be junked.
 781          */
 782         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
 783                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
 784                                                   commands);
 785
 786         /* Reset init error count upon receipt of COOKIE-ACK,
 787          * to avoid problems with the managemement of this
 788          * counter in stale cookie situations when a transition back
 789          * from the COOKIE-ECHOED state to the COOKIE-WAIT
 790          * state is performed.
 791          */
 792         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_COUNTER_RESET, SCTP_NULL());
 793
 794         /* RFC 2960 5.1 Normal Establishment of an Association
 795          *
 796          * E) Upon reception of the COOKIE ACK, endpoint "A" will move
 797          * from the COOKIE-ECHOED state to the ESTABLISHED state,
 798          * stopping the T1-cookie timer.
 799          */
 800         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
 801                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
 802         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
 803                         SCTP_STATE(SCTP_STATE_ESTABLISHED));
 804         SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
 805         SCTP_INC_STATS(SCTP_MIB_ACTIVEESTABS);
 806         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
 807         if (asoc->autoclose)
 808                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
 809                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
 810         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
 811
 812         /* It may also notify its ULP about the successful
 813          * establishment of the association with a Communication Up
 814          * notification (see Section 10).
 815          */
 816         ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_UP,
 817                                              0, asoc->c.sinit_num_ostreams,
 818                                              asoc->c.sinit_max_instreams,
 819                                              GFP_ATOMIC);
 820
 821         if (!ev)
 822                 goto nomem;
 823
 824         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
 825
 826         /* Sockets API Draft Section 5.3.1.6
 827          * When a peer sends a Adaption Layer Indication parameter , SCTP
 828          * delivers this notification to inform the application that of the
 829          * peers requested adaption layer.
 830          */
 831         if (asoc->peer.adaption_ind) {
 832                 ev = sctp_ulpevent_make_adaption_indication(asoc, GFP_ATOMIC);
 833                 if (!ev)
 834                         goto nomem;
 835
 836                 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
 837                                 SCTP_ULPEVENT(ev));
 838         }
 839
 840         return SCTP_DISPOSITION_CONSUME;
 841 nomem:
 842         return SCTP_DISPOSITION_NOMEM;
 843 }
 844
 845 /* Generate and sendout a heartbeat packet.  */
 846 static sctp_disposition_t sctp_sf_heartbeat(const struct sctp_endpoint *ep,
 847                                             const struct sctp_association *asoc,
 848                                             const sctp_subtype_t type,
 849                                             void *arg,
 850                                             sctp_cmd_seq_t *commands)
 851 {
 852         struct sctp_transport *transport = (struct sctp_transport *) arg;
 853         struct sctp_chunk *reply;
 854         sctp_sender_hb_info_t hbinfo;
 855         size_t paylen = 0;
 856
 857         hbinfo.param_hdr.type = SCTP_PARAM_HEARTBEAT_INFO;
 858         hbinfo.param_hdr.length = htons(sizeof(sctp_sender_hb_info_t));
 859         hbinfo.daddr = transport->ipaddr;
 860         hbinfo.sent_at = jiffies;
 861
 862         /* Send a heartbeat to our peer.  */
 863         paylen = sizeof(sctp_sender_hb_info_t);
 864         reply = sctp_make_heartbeat(asoc, transport, &hbinfo, paylen);
 865         if (!reply)
 866                 return SCTP_DISPOSITION_NOMEM;
 867
 868         /* Set rto_pending indicating that an RTT measurement
 869          * is started with this heartbeat chunk.
 870          */
 871         sctp_add_cmd_sf(commands, SCTP_CMD_RTO_PENDING,
 872                         SCTP_TRANSPORT(transport));
 873
 874         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
 875         return SCTP_DISPOSITION_CONSUME;
 876 }
 877
 878 /* Generate a HEARTBEAT packet on the given transport.  */
 879 sctp_disposition_t sctp_sf_sendbeat_8_3(const struct sctp_endpoint *ep,
 880                                         const struct sctp_association *asoc,
 881                                         const sctp_subtype_t type,
 882                                         void *arg,
 883                                         sctp_cmd_seq_t *commands)
 884 {
 885         struct sctp_transport *transport = (struct sctp_transport *) arg;
 886
 887         if (asoc->overall_error_count >= asoc->max_retrans) {
 888                 /* CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
 889                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
 890                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
 891                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
 892                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
 893                 return SCTP_DISPOSITION_DELETE_TCB;
 894         }
 895
 896         /* Section 3.3.5.
 897          * The Sender-specific Heartbeat Info field should normally include
 898          * information about the sender's current time when this HEARTBEAT
 899          * chunk is sent and the destination transport address to which this
 900          * HEARTBEAT is sent (see Section 8.3).
 901          */
 902
 903         if (transport->param_flags & SPP_HB_ENABLE) {
 904                 if (SCTP_DISPOSITION_NOMEM ==
 905                                 sctp_sf_heartbeat(ep, asoc, type, arg,
 906                                                   commands))
 907                         return SCTP_DISPOSITION_NOMEM;
 908                 /* Set transport error counter and association error counter
 909                  * when sending heartbeat.
 910                  */
 911                 sctp_add_cmd_sf(commands, SCTP_CMD_TRANSPORT_RESET,
 912                                 SCTP_TRANSPORT(transport));
 913         }
 914         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMER_UPDATE,
 915                         SCTP_TRANSPORT(transport));
 916
 917         return SCTP_DISPOSITION_CONSUME;
 918 }
 919
 920 /*
 921  * Process an heartbeat request.
 922  *
 923  * Section: 8.3 Path Heartbeat
 924  * The receiver of the HEARTBEAT should immediately respond with a
 925  * HEARTBEAT ACK that contains the Heartbeat Information field copied
 926  * from the received HEARTBEAT chunk.
 927  *
 928  * Verification Tag:  8.5 Verification Tag [Normal verification]
 929  * When receiving an SCTP packet, the endpoint MUST ensure that the
 930  * value in the Verification Tag field of the received SCTP packet
 931  * matches its own Tag. If the received Verification Tag value does not
 932  * match the receiver's own tag value, the receiver shall silently
 933  * discard the packet and shall not process it any further except for
 934  * those cases listed in Section 8.5.1 below.
 935  *
 936  * Inputs
 937  * (endpoint, asoc, chunk)
 938  *
 939  * Outputs
 940  * (asoc, reply_msg, msg_up, timers, counters)
 941  *
 942  * The return value is the disposition of the chunk.
 943  */
 944 sctp_disposition_t sctp_sf_beat_8_3(const struct sctp_endpoint *ep,
 945                                     const struct sctp_association *asoc,
 946                                     const sctp_subtype_t type,
 947                                     void *arg,
 948                                     sctp_cmd_seq_t *commands)
 949 {
 950         struct sctp_chunk *chunk = arg;
 951         struct sctp_chunk *reply;
 952         size_t paylen = 0;
 953
 954         if (!sctp_vtag_verify(chunk, asoc))
 955                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
 956
 957         /* Make sure that the HEARTBEAT chunk has a valid length. */
 958         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_heartbeat_chunk_t)))
 959                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
 960                                                   commands);
 961
 962         /* 8.3 The receiver of the HEARTBEAT should immediately
 963          * respond with a HEARTBEAT ACK that contains the Heartbeat
 964          * Information field copied from the received HEARTBEAT chunk.
 965          */
 966         chunk->subh.hb_hdr = (sctp_heartbeathdr_t *) chunk->skb->data;
 967         paylen = ntohs(chunk->chunk_hdr->length) - sizeof(sctp_chunkhdr_t);
 968         skb_pull(chunk->skb, paylen);
 969
 970         reply = sctp_make_heartbeat_ack(asoc, chunk,
 971                                         chunk->subh.hb_hdr, paylen);
 972         if (!reply)
 973                 goto nomem;
 974
 975         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
 976         return SCTP_DISPOSITION_CONSUME;
 977
 978 nomem:
 979         return SCTP_DISPOSITION_NOMEM;
 980 }
 981
 982 /*
 983  * Process the returning HEARTBEAT ACK.
 984  *
 985  * Section: 8.3 Path Heartbeat
 986  * Upon the receipt of the HEARTBEAT ACK, the sender of the HEARTBEAT
 987  * should clear the error counter of the destination transport
 988  * address to which the HEARTBEAT was sent, and mark the destination
 989  * transport address as active if it is not so marked. The endpoint may
 990  * optionally report to the upper layer when an inactive destination
 991  * address is marked as active due to the reception of the latest
 992  * HEARTBEAT ACK. The receiver of the HEARTBEAT ACK must also
 993  * clear the association overall error count as well (as defined
 994  * in section 8.1).
 995  *
 996  * The receiver of the HEARTBEAT ACK should also perform an RTT
 997  * measurement for that destination transport address using the time
 998  * value carried in the HEARTBEAT ACK chunk.
 999  *
1000  * Verification Tag:  8.5 Verification Tag [Normal verification]
1001  *
1002  * Inputs
1003  * (endpoint, asoc, chunk)
1004  *
1005  * Outputs
1006  * (asoc, reply_msg, msg_up, timers, counters)
1007  *
1008  * The return value is the disposition of the chunk.
1009  */
1010 sctp_disposition_t sctp_sf_backbeat_8_3(const struct sctp_endpoint *ep,
1011                                         const struct sctp_association *asoc,
1012                                         const sctp_subtype_t type,
1013                                         void *arg,
1014                                         sctp_cmd_seq_t *commands)
1015 {
1016         struct sctp_chunk *chunk = arg;
1017         union sctp_addr from_addr;
1018         struct sctp_transport *link;
1019         sctp_sender_hb_info_t *hbinfo;
1020         unsigned long max_interval;
1021
1022         if (!sctp_vtag_verify(chunk, asoc))
1023                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1024
1025         /* Make sure that the HEARTBEAT-ACK chunk has a valid length.  */
1026         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_heartbeat_chunk_t)))
1027                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
1028                                                   commands);
1029
1030         hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
1031         from_addr = hbinfo->daddr;
1032         link = sctp_assoc_lookup_paddr(asoc, &from_addr);
1033
1034         /* This should never happen, but lets log it if so.  */
1035         if (unlikely(!link)) {
1036                 if (from_addr.sa.sa_family == AF_INET6) {
1037                         printk(KERN_WARNING
1038                                "%s association %p could not find address "
1039                                NIP6_FMT "\n",
1040                                __FUNCTION__,
1041                                asoc,
1042                                NIP6(from_addr.v6.sin6_addr));
1043                 } else {
1044                         printk(KERN_WARNING
1045                                "%s association %p could not find address "
1046                                NIPQUAD_FMT "\n",
1047                                __FUNCTION__,
1048                                asoc,
1049                                NIPQUAD(from_addr.v4.sin_addr.s_addr));
1050                 }
1051                 return SCTP_DISPOSITION_DISCARD;
1052         }
1053
1054         max_interval = link->hbinterval + link->rto;
1055
1056         /* Check if the timestamp looks valid.  */
1057         if (time_after(hbinfo->sent_at, jiffies) ||
1058             time_after(jiffies, hbinfo->sent_at + max_interval)) {
1059                 SCTP_DEBUG_PRINTK("%s: HEARTBEAT ACK with invalid timestamp"
1060                                   "received for transport: %p\n",
1061                                    __FUNCTION__, link);
1062                 return SCTP_DISPOSITION_DISCARD;
1063         }
1064
1065         /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of
1066          * the HEARTBEAT should clear the error counter of the
1067          * destination transport address to which the HEARTBEAT was
1068          * sent and mark the destination transport address as active if
1069          * it is not so marked.
1070          */
1071         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSPORT_ON, SCTP_TRANSPORT(link));
1072
1073         return SCTP_DISPOSITION_CONSUME;
1074 }
1075
1076 /* Helper function to send out an abort for the restart
1077  * condition.
1078  */
1079 static int sctp_sf_send_restart_abort(union sctp_addr *ssa,
1080                                       struct sctp_chunk *init,
1081                                       sctp_cmd_seq_t *commands)
1082 {
1083         int len;
1084         struct sctp_packet *pkt;
1085         union sctp_addr_param *addrparm;
1086         struct sctp_errhdr *errhdr;
1087         struct sctp_endpoint *ep;
1088         char buffer[sizeof(struct sctp_errhdr)+sizeof(union sctp_addr_param)];
1089         struct sctp_af *af = sctp_get_af_specific(ssa->v4.sin_family);
1090
1091         /* Build the error on the stack.   We are way to malloc crazy
1092          * throughout the code today.
1093          */
1094         errhdr = (struct sctp_errhdr *)buffer;
1095         addrparm = (union sctp_addr_param *)errhdr->variable;
1096
1097         /* Copy into a parm format. */
1098         len = af->to_addr_param(ssa, addrparm);
1099         len += sizeof(sctp_errhdr_t);
1100
1101         errhdr->cause = SCTP_ERROR_RESTART;
1102         errhdr->length = htons(len);
1103
1104         /* Assign to the control socket. */
1105         ep = sctp_sk((sctp_get_ctl_sock()))->ep;
1106
1107         /* Association is NULL since this may be a restart attack and we
1108          * want to send back the attacker's vtag.
1109          */
1110         pkt = sctp_abort_pkt_new(ep, NULL, init, errhdr, len);
1111
1112         if (!pkt)
1113                 goto out;
1114         sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT, SCTP_PACKET(pkt));
1115
1116         SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
1117
1118         /* Discard the rest of the inbound packet. */
1119         sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
1120
1121 out:
1122         /* Even if there is no memory, treat as a failure so
1123          * the packet will get dropped.
1124          */
1125         return 0;
1126 }
1127
1128 /* A restart is occurring, check to make sure no new addresses
1129  * are being added as we may be under a takeover attack.
1130  */
1131 static int sctp_sf_check_restart_addrs(const struct sctp_association *new_asoc,
1132                                        const struct sctp_association *asoc,
1133                                        struct sctp_chunk *init,
1134                                        sctp_cmd_seq_t *commands)
1135 {
1136         struct sctp_transport *new_addr, *addr;
1137         struct list_head *pos, *pos2;
1138         int found;
1139
1140         /* Implementor's Guide - Sectin 5.2.2
1141          * ...
1142          * Before responding the endpoint MUST check to see if the
1143          * unexpected INIT adds new addresses to the association. If new
1144          * addresses are added to the association, the endpoint MUST respond
1145          * with an ABORT..
1146          */
1147
1148         /* Search through all current addresses and make sure
1149          * we aren't adding any new ones.
1150          */
1151         new_addr = NULL;
1152         found = 0;
1153
1154         list_for_each(pos, &new_asoc->peer.transport_addr_list) {
1155                 new_addr = list_entry(pos, struct sctp_transport, transports);
1156                 found = 0;
1157                 list_for_each(pos2, &asoc->peer.transport_addr_list) {
1158                         addr = list_entry(pos2, struct sctp_transport,
1159                                           transports);
1160                         if (sctp_cmp_addr_exact(&new_addr->ipaddr,
1161                                                 &addr->ipaddr)) {
1162                                 found = 1;
1163                                 break;
1164                         }
1165                 }
1166                 if (!found)
1167                         break;
1168         }
1169
1170         /* If a new address was added, ABORT the sender. */
1171         if (!found && new_addr) {
1172                 sctp_sf_send_restart_abort(&new_addr->ipaddr, init, commands);
1173         }
1174
1175         /* Return success if all addresses were found. */
1176         return found;
1177 }
1178
1179 /* Populate the verification/tie tags based on overlapping INIT
1180  * scenario.
1181  *
1182  * Note: Do not use in CLOSED or SHUTDOWN-ACK-SENT state.
1183  */
1184 static void sctp_tietags_populate(struct sctp_association *new_asoc,
1185                                   const struct sctp_association *asoc)
1186 {
1187         switch (asoc->state) {
1188
1189         /* 5.2.1 INIT received in COOKIE-WAIT or COOKIE-ECHOED State */
1190
1191         case SCTP_STATE_COOKIE_WAIT:
1192                 new_asoc->c.my_vtag     = asoc->c.my_vtag;
1193                 new_asoc->c.my_ttag     = asoc->c.my_vtag;
1194                 new_asoc->c.peer_ttag   = 0;
1195                 break;
1196
1197         case SCTP_STATE_COOKIE_ECHOED:
1198                 new_asoc->c.my_vtag     = asoc->c.my_vtag;
1199                 new_asoc->c.my_ttag     = asoc->c.my_vtag;
1200                 new_asoc->c.peer_ttag   = asoc->c.peer_vtag;
1201                 break;
1202
1203         /* 5.2.2 Unexpected INIT in States Other than CLOSED, COOKIE-ECHOED,
1204          * COOKIE-WAIT and SHUTDOWN-ACK-SENT
1205          */
1206         default:
1207                 new_asoc->c.my_ttag   = asoc->c.my_vtag;
1208                 new_asoc->c.peer_ttag = asoc->c.peer_vtag;
1209                 break;
1210         };
1211
1212         /* Other parameters for the endpoint SHOULD be copied from the
1213          * existing parameters of the association (e.g. number of
1214          * outbound streams) into the INIT ACK and cookie.
1215          */
1216         new_asoc->rwnd                  = asoc->rwnd;
1217         new_asoc->c.sinit_num_ostreams  = asoc->c.sinit_num_ostreams;
1218         new_asoc->c.sinit_max_instreams = asoc->c.sinit_max_instreams;
1219         new_asoc->c.initial_tsn         = asoc->c.initial_tsn;
1220 }
1221
1222 /*
1223  * Compare vtag/tietag values to determine unexpected COOKIE-ECHO
1224  * handling action.
1225  *
1226  * RFC 2960 5.2.4 Handle a COOKIE ECHO when a TCB exists.
1227  *
1228  * Returns value representing action to be taken.   These action values
1229  * correspond to Action/Description values in RFC 2960, Table 2.
1230  */
1231 static char sctp_tietags_compare(struct sctp_association *new_asoc,
1232                                  const struct sctp_association *asoc)
1233 {
1234         /* In this case, the peer may have restarted.  */
1235         if ((asoc->c.my_vtag != new_asoc->c.my_vtag) &&
1236             (asoc->c.peer_vtag != new_asoc->c.peer_vtag) &&
1237             (asoc->c.my_vtag == new_asoc->c.my_ttag) &&
1238             (asoc->c.peer_vtag == new_asoc->c.peer_ttag))
1239                 return 'A';
1240
1241         /* Collision case B. */
1242         if ((asoc->c.my_vtag == new_asoc->c.my_vtag) &&
1243             ((asoc->c.peer_vtag != new_asoc->c.peer_vtag) ||
1244              (0 == asoc->c.peer_vtag))) {
1245                 return 'B';
1246         }
1247
1248         /* Collision case D. */
1249         if ((asoc->c.my_vtag == new_asoc->c.my_vtag) &&
1250             (asoc->c.peer_vtag == new_asoc->c.peer_vtag))
1251                 return 'D';
1252
1253         /* Collision case C. */
1254         if ((asoc->c.my_vtag != new_asoc->c.my_vtag) &&
1255             (asoc->c.peer_vtag == new_asoc->c.peer_vtag) &&
1256             (0 == new_asoc->c.my_ttag) &&
1257             (0 == new_asoc->c.peer_ttag))
1258                 return 'C';
1259
1260         /* No match to any of the special cases; discard this packet. */
1261         return 'E';
1262 }
1263
1264 /* Common helper routine for both duplicate and simulataneous INIT
1265  * chunk handling.
1266  */
1267 static sctp_disposition_t sctp_sf_do_unexpected_init(
1268         const struct sctp_endpoint *ep,
1269         const struct sctp_association *asoc,
1270         const sctp_subtype_t type,
1271         void *arg, sctp_cmd_seq_t *commands)
1272 {
1273         sctp_disposition_t retval;
1274         struct sctp_chunk *chunk = arg;
1275         struct sctp_chunk *repl;
1276         struct sctp_association *new_asoc;
1277         struct sctp_chunk *err_chunk;
1278         struct sctp_packet *packet;
1279         sctp_unrecognized_param_t *unk_param;
1280         int len;
1281
1282         /* 6.10 Bundling
1283          * An endpoint MUST NOT bundle INIT, INIT ACK or
1284          * SHUTDOWN COMPLETE with any other chunks.
1285          *
1286          * IG Section 2.11.2
1287          * Furthermore, we require that the receiver of an INIT chunk MUST
1288          * enforce these rules by silently discarding an arriving packet
1289          * with an INIT chunk that is bundled with other chunks.
1290          */
1291         if (!chunk->singleton)
1292                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1293
1294         /* 3.1 A packet containing an INIT chunk MUST have a zero Verification
1295          * Tag.
1296          */
1297         if (chunk->sctp_hdr->vtag != 0)
1298                 return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
1299
1300         /* Make sure that the INIT chunk has a valid length.
1301          * In this case, we generate a protocol violation since we have
1302          * an association established.
1303          */
1304         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_init_chunk_t)))
1305                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
1306                                                   commands);
1307         /* Grab the INIT header.  */
1308         chunk->subh.init_hdr = (sctp_inithdr_t *) chunk->skb->data;
1309
1310         /* Tag the variable length parameters.  */
1311         chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
1312
1313         /* Verify the INIT chunk before processing it. */
1314         err_chunk = NULL;
1315         if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
1316                               (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
1317                               &err_chunk)) {
1318                 /* This chunk contains fatal error. It is to be discarded.
1319                  * Send an ABORT, with causes if there is any.
1320                  */
1321                 if (err_chunk) {
1322                         packet = sctp_abort_pkt_new(ep, asoc, arg,
1323                                         (__u8 *)(err_chunk->chunk_hdr) +
1324                                         sizeof(sctp_chunkhdr_t),
1325                                         ntohs(err_chunk->chunk_hdr->length) -
1326                                         sizeof(sctp_chunkhdr_t));
1327
1328                         if (packet) {
1329                                 sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
1330                                                 SCTP_PACKET(packet));
1331                                 SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
1332                                 retval = SCTP_DISPOSITION_CONSUME;
1333                         } else {
1334                                 retval = SCTP_DISPOSITION_NOMEM;
1335                         }
1336                         goto cleanup;
1337                 } else {
1338                         return sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
1339                                                     commands);
1340                 }
1341         }
1342
1343         /*
1344          * Other parameters for the endpoint SHOULD be copied from the
1345          * existing parameters of the association (e.g. number of
1346          * outbound streams) into the INIT ACK and cookie.
1347          * FIXME:  We are copying parameters from the endpoint not the
1348          * association.
1349          */
1350         new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);
1351         if (!new_asoc)
1352                 goto nomem;
1353
1354         /* In the outbound INIT ACK the endpoint MUST copy its current
1355          * Verification Tag and Peers Verification tag into a reserved
1356          * place (local tie-tag and per tie-tag) within the state cookie.
1357          */
1358         if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
1359                                sctp_source(chunk),
1360                                (sctp_init_chunk_t *)chunk->chunk_hdr,
1361                                GFP_ATOMIC)) {
1362                 retval = SCTP_DISPOSITION_NOMEM;
1363                 goto nomem_init;
1364         }
1365
1366         /* Make sure no new addresses are being added during the
1367          * restart.   Do not do this check for COOKIE-WAIT state,
1368          * since there are no peer addresses to check against.
1369          * Upon return an ABORT will have been sent if needed.
1370          */
1371         if (!sctp_state(asoc, COOKIE_WAIT)) {
1372                 if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk,
1373                                                  commands)) {
1374                         retval = SCTP_DISPOSITION_CONSUME;
1375                         goto cleanup_asoc;
1376                 }
1377         }
1378
1379         sctp_tietags_populate(new_asoc, asoc);
1380
1381         /* B) "Z" shall respond immediately with an INIT ACK chunk.  */
1382
1383         /* If there are errors need to be reported for unknown parameters,
1384          * make sure to reserve enough room in the INIT ACK for them.
1385          */
1386         len = 0;
1387         if (err_chunk) {
1388                 len = ntohs(err_chunk->chunk_hdr->length) -
1389                         sizeof(sctp_chunkhdr_t);
1390         }
1391
1392         if (sctp_assoc_set_bind_addr_from_ep(new_asoc, GFP_ATOMIC) < 0)
1393                 goto nomem;
1394
1395         repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);
1396         if (!repl)
1397                 goto nomem;
1398
1399         /* If there are errors need to be reported for unknown parameters,
1400          * include them in the outgoing INIT ACK as "Unrecognized parameter"
1401          * parameter.
1402          */
1403         if (err_chunk) {
1404                 /* Get the "Unrecognized parameter" parameter(s) out of the
1405                  * ERROR chunk generated by sctp_verify_init(). Since the
1406                  * error cause code for "unknown parameter" and the
1407                  * "Unrecognized parameter" type is the same, we can
1408                  * construct the parameters in INIT ACK by copying the
1409                  * ERROR causes over.
1410                  */
1411                 unk_param = (sctp_unrecognized_param_t *)
1412                             ((__u8 *)(err_chunk->chunk_hdr) +
1413                             sizeof(sctp_chunkhdr_t));
1414                 /* Replace the cause code with the "Unrecognized parameter"
1415                  * parameter type.
1416                  */
1417                 sctp_addto_chunk(repl, len, unk_param);
1418         }
1419
1420         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
1421         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
1422
1423         /*
1424          * Note: After sending out INIT ACK with the State Cookie parameter,
1425          * "Z" MUST NOT allocate any resources for this new association.
1426          * Otherwise, "Z" will be vulnerable to resource attacks.
1427          */
1428         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
1429         retval = SCTP_DISPOSITION_CONSUME;
1430
1431 cleanup:
1432         if (err_chunk)
1433                 sctp_chunk_free(err_chunk);
1434         return retval;
1435 nomem:
1436         retval = SCTP_DISPOSITION_NOMEM;
1437         goto cleanup;
1438 nomem_init:
1439 cleanup_asoc:
1440         sctp_association_free(new_asoc);
1441         goto cleanup;
1442 }
1443
1444 /*
1445  * Handle simultanous INIT.
1446  * This means we started an INIT and then we got an INIT request from
1447  * our peer.
1448  *
1449  * Section: 5.2.1 INIT received in COOKIE-WAIT or COOKIE-ECHOED State (Item B)
1450  * This usually indicates an initialization collision, i.e., each
1451  * endpoint is attempting, at about the same time, to establish an
1452  * association with the other endpoint.
1453  *
1454  * Upon receipt of an INIT in the COOKIE-WAIT or COOKIE-ECHOED state, an
1455  * endpoint MUST respond with an INIT ACK using the same parameters it
1456  * sent in its original INIT chunk (including its Verification Tag,
1457  * unchanged). These original parameters are combined with those from the
1458  * newly received INIT chunk. The endpoint shall also generate a State
1459  * Cookie with the INIT ACK. The endpoint uses the parameters sent in its
1460  * INIT to calculate the State Cookie.
1461  *
1462  * After that, the endpoint MUST NOT change its state, the T1-init
1463  * timer shall be left running and the corresponding TCB MUST NOT be
1464  * destroyed. The normal procedures for handling State Cookies when
1465  * a TCB exists will resolve the duplicate INITs to a single association.
1466  *
1467  * For an endpoint that is in the COOKIE-ECHOED state it MUST populate
1468  * its Tie-Tags with the Tag information of itself and its peer (see
1469  * section 5.2.2 for a description of the Tie-Tags).
1470  *
1471  * Verification Tag: Not explicit, but an INIT can not have a valid
1472  * verification tag, so we skip the check.
1473  *
1474  * Inputs
1475  * (endpoint, asoc, chunk)
1476  *
1477  * Outputs
1478  * (asoc, reply_msg, msg_up, timers, counters)
1479  *
1480  * The return value is the disposition of the chunk.
1481  */
1482 sctp_disposition_t sctp_sf_do_5_2_1_siminit(const struct sctp_endpoint *ep,
1483                                     const struct sctp_association *asoc,
1484                                     const sctp_subtype_t type,
1485                                     void *arg,
1486                                     sctp_cmd_seq_t *commands)
1487 {
1488         /* Call helper to do the real work for both simulataneous and
1489          * duplicate INIT chunk handling.
1490          */
1491         return sctp_sf_do_unexpected_init(ep, asoc, type, arg, commands);
1492 }
1493
1494 /*
1495  * Handle duplicated INIT messages.  These are usually delayed
1496  * restransmissions.
1497  *
1498  * Section: 5.2.2 Unexpected INIT in States Other than CLOSED,
1499  * COOKIE-ECHOED and COOKIE-WAIT
1500  *
1501  * Unless otherwise stated, upon reception of an unexpected INIT for
1502  * this association, the endpoint shall generate an INIT ACK with a
1503  * State Cookie.  In the outbound INIT ACK the endpoint MUST copy its
1504  * current Verification Tag and peer's Verification Tag into a reserved
1505  * place within the state cookie.  We shall refer to these locations as
1506  * the Peer's-Tie-Tag and the Local-Tie-Tag.  The outbound SCTP packet
1507  * containing this INIT ACK MUST carry a Verification Tag value equal to
1508  * the Initiation Tag found in the unexpected INIT.  And the INIT ACK
1509  * MUST contain a new Initiation Tag (randomly generated see Section
1510  * 5.3.1).  Other parameters for the endpoint SHOULD be copied from the
1511  * existing parameters of the association (e.g. number of outbound
1512  * streams) into the INIT ACK and cookie.
1513  *
1514  * After sending out the INIT ACK, the endpoint shall take no further
1515  * actions, i.e., the existing association, including its current state,
1516  * and the corresponding TCB MUST NOT be changed.
1517  *
1518  * Note: Only when a TCB exists and the association is not in a COOKIE-
1519  * WAIT state are the Tie-Tags populated.  For a normal association INIT
1520  * (i.e. the endpoint is in a COOKIE-WAIT state), the Tie-Tags MUST be
1521  * set to 0 (indicating that no previous TCB existed).  The INIT ACK and
1522  * State Cookie are populated as specified in section 5.2.1.
1523  *
1524  * Verification Tag: Not specified, but an INIT has no way of knowing
1525  * what the verification tag could be, so we ignore it.
1526  *
1527  * Inputs
1528  * (endpoint, asoc, chunk)
1529  *
1530  * Outputs
1531  * (asoc, reply_msg, msg_up, timers, counters)
1532  *
1533  * The return value is the disposition of the chunk.
1534  */
1535 sctp_disposition_t sctp_sf_do_5_2_2_dupinit(const struct sctp_endpoint *ep,
1536                                         const struct sctp_association *asoc,
1537                                         const sctp_subtype_t type,
1538                                         void *arg,
1539                                         sctp_cmd_seq_t *commands)
1540 {
1541         /* Call helper to do the real work for both simulataneous and
1542          * duplicate INIT chunk handling.
1543          */
1544         return sctp_sf_do_unexpected_init(ep, asoc, type, arg, commands);
1545 }
1546
1547
1548
1549 /* Unexpected COOKIE-ECHO handler for peer restart (Table 2, action 'A')
1550  *
1551  * Section 5.2.4
1552  *  A)  In this case, the peer may have restarted.
1553  */
1554 static sctp_disposition_t sctp_sf_do_dupcook_a(const struct sctp_endpoint *ep,
1555                                         const struct sctp_association *asoc,
1556                                         struct sctp_chunk *chunk,
1557                                         sctp_cmd_seq_t *commands,
1558                                         struct sctp_association *new_asoc)
1559 {
1560         sctp_init_chunk_t *peer_init;
1561         struct sctp_ulpevent *ev;
1562         struct sctp_chunk *repl;
1563         struct sctp_chunk *err;
1564         sctp_disposition_t disposition;
1565
1566         /* new_asoc is a brand-new association, so these are not yet
1567          * side effects--it is safe to run them here.
1568          */
1569         peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
1570
1571         if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
1572                                sctp_source(chunk), peer_init,
1573                                GFP_ATOMIC))
1574                 goto nomem;
1575
1576         /* Make sure no new addresses are being added during the
1577          * restart.  Though this is a pretty complicated attack
1578          * since you'd have to get inside the cookie.
1579          */
1580         if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk, commands)) {
1581                 return SCTP_DISPOSITION_CONSUME;
1582         }
1583
1584         /* If the endpoint is in the SHUTDOWN-ACK-SENT state and recognizes
1585          * the peer has restarted (Action A), it MUST NOT setup a new
1586          * association but instead resend the SHUTDOWN ACK and send an ERROR
1587          * chunk with a "Cookie Received while Shutting Down" error cause to
1588          * its peer.
1589         */
1590         if (sctp_state(asoc, SHUTDOWN_ACK_SENT)) {
1591                 disposition = sctp_sf_do_9_2_reshutack(ep, asoc,
1592                                 SCTP_ST_CHUNK(chunk->chunk_hdr->type),
1593                                 chunk, commands);
1594                 if (SCTP_DISPOSITION_NOMEM == disposition)
1595                         goto nomem;
1596
1597                 err = sctp_make_op_error(asoc, chunk,
1598                                          SCTP_ERROR_COOKIE_IN_SHUTDOWN,
1599                                          NULL, 0);
1600                 if (err)
1601                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1602                                         SCTP_CHUNK(err));
1603
1604                 return SCTP_DISPOSITION_CONSUME;
1605         }
1606
1607         /* For now, fail any unsent/unacked data.  Consider the optional
1608          * choice of resending of this data.
1609          */
1610         sctp_add_cmd_sf(commands, SCTP_CMD_PURGE_OUTQUEUE, SCTP_NULL());
1611
1612         /* Update the content of current association. */
1613         sctp_add_cmd_sf(commands, SCTP_CMD_UPDATE_ASSOC, SCTP_ASOC(new_asoc));
1614
1615         repl = sctp_make_cookie_ack(new_asoc, chunk);
1616         if (!repl)
1617                 goto nomem;
1618
1619         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
1620
1621         /* Report association restart to upper layer. */
1622         ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_RESTART, 0,
1623                                              new_asoc->c.sinit_num_ostreams,
1624                                              new_asoc->c.sinit_max_instreams,
1625                                              GFP_ATOMIC);
1626         if (!ev)
1627                 goto nomem_ev;
1628
1629         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
1630         return SCTP_DISPOSITION_CONSUME;
1631
1632 nomem_ev:
1633         sctp_chunk_free(repl);
1634 nomem:
1635         return SCTP_DISPOSITION_NOMEM;
1636 }
1637
1638 /* Unexpected COOKIE-ECHO handler for setup collision (Table 2, action 'B')
1639  *
1640  * Section 5.2.4
1641  *   B) In this case, both sides may be attempting to start an association
1642  *      at about the same time but the peer endpoint started its INIT
1643  *      after responding to the local endpoint's INIT
1644  */
1645 /* This case represents an initialization collision.  */
1646 static sctp_disposition_t sctp_sf_do_dupcook_b(const struct sctp_endpoint *ep,
1647                                         const struct sctp_association *asoc,
1648                                         struct sctp_chunk *chunk,
1649                                         sctp_cmd_seq_t *commands,
1650                                         struct sctp_association *new_asoc)
1651 {
1652         sctp_init_chunk_t *peer_init;
1653         struct sctp_ulpevent *ev;
1654         struct sctp_chunk *repl;
1655
1656         /* new_asoc is a brand-new association, so these are not yet
1657          * side effects--it is safe to run them here.
1658          */
1659         peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
1660         if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
1661                                sctp_source(chunk), peer_init,
1662                                GFP_ATOMIC))
1663                 goto nomem;
1664
1665         /* Update the content of current association.  */
1666         sctp_add_cmd_sf(commands, SCTP_CMD_UPDATE_ASSOC, SCTP_ASOC(new_asoc));
1667         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
1668                         SCTP_STATE(SCTP_STATE_ESTABLISHED));
1669         SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
1670         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
1671
1672         repl = sctp_make_cookie_ack(new_asoc, chunk);
1673         if (!repl)
1674                 goto nomem;
1675
1676         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
1677         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
1678
1679         /* RFC 2960 5.1 Normal Establishment of an Association
1680          *
1681          * D) IMPLEMENTATION NOTE: An implementation may choose to
1682          * send the Communication Up notification to the SCTP user
1683          * upon reception of a valid COOKIE ECHO chunk.
1684          */
1685         ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_UP, 0,
1686                                              new_asoc->c.sinit_num_ostreams,
1687                                              new_asoc->c.sinit_max_instreams,
1688                                              GFP_ATOMIC);
1689         if (!ev)
1690                 goto nomem_ev;
1691
1692         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
1693
1694         /* Sockets API Draft Section 5.3.1.6
1695          * When a peer sends a Adaption Layer Indication parameter , SCTP
1696          * delivers this notification to inform the application that of the
1697          * peers requested adaption layer.
1698          */
1699         if (asoc->peer.adaption_ind) {
1700                 ev = sctp_ulpevent_make_adaption_indication(asoc, GFP_ATOMIC);
1701                 if (!ev)
1702                         goto nomem_ev;
1703
1704                 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
1705                                 SCTP_ULPEVENT(ev));
1706         }
1707
1708         return SCTP_DISPOSITION_CONSUME;
1709
1710 nomem_ev:
1711         sctp_chunk_free(repl);
1712 nomem:
1713         return SCTP_DISPOSITION_NOMEM;
1714 }
1715
1716 /* Unexpected COOKIE-ECHO handler for setup collision (Table 2, action 'C')
1717  *
1718  * Section 5.2.4
1719  *  C) In this case, the local endpoint's cookie has arrived late.
1720  *     Before it arrived, the local endpoint sent an INIT and received an
1721  *     INIT-ACK and finally sent a COOKIE ECHO with the peer's same tag
1722  *     but a new tag of its own.
1723  */
1724 /* This case represents an initialization collision.  */
1725 static sctp_disposition_t sctp_sf_do_dupcook_c(const struct sctp_endpoint *ep,
1726                                         const struct sctp_association *asoc,
1727                                         struct sctp_chunk *chunk,
1728                                         sctp_cmd_seq_t *commands,
1729                                         struct sctp_association *new_asoc)
1730 {
1731         /* The cookie should be silently discarded.
1732          * The endpoint SHOULD NOT change states and should leave
1733          * any timers running.
1734          */
1735         return SCTP_DISPOSITION_DISCARD;
1736 }
1737
1738 /* Unexpected COOKIE-ECHO handler lost chunk (Table 2, action 'D')
1739  *
1740  * Section 5.2.4
1741  *
1742  * D) When both local and remote tags match the endpoint should always
1743  *    enter the ESTABLISHED state, if it has not already done so.
1744  */
1745 /* This case represents an initialization collision.  */
1746 static sctp_disposition_t sctp_sf_do_dupcook_d(const struct sctp_endpoint *ep,
1747                                         const struct sctp_association *asoc,
1748                                         struct sctp_chunk *chunk,
1749                                         sctp_cmd_seq_t *commands,
1750                                         struct sctp_association *new_asoc)
1751 {
1752         struct sctp_ulpevent *ev = NULL;
1753         struct sctp_chunk *repl;
1754
1755         /* Clarification from Implementor's Guide:
1756          * D) When both local and remote tags match the endpoint should
1757          * enter the ESTABLISHED state, if it is in the COOKIE-ECHOED state.
1758          * It should stop any cookie timer that may be running and send
1759          * a COOKIE ACK.
1760          */
1761
1762         /* Don't accidentally move back into established state. */
1763         if (asoc->state < SCTP_STATE_ESTABLISHED) {
1764                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
1765                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1766                 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
1767                                 SCTP_STATE(SCTP_STATE_ESTABLISHED));
1768                 SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
1769                 sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START,
1770                                 SCTP_NULL());
1771
1772                 /* RFC 2960 5.1 Normal Establishment of an Association
1773                  *
1774                  * D) IMPLEMENTATION NOTE: An implementation may choose
1775                  * to send the Communication Up notification to the
1776                  * SCTP user upon reception of a valid COOKIE
1777                  * ECHO chunk.
1778                  */
1779                 ev = sctp_ulpevent_make_assoc_change(new_asoc, 0,
1780                                              SCTP_COMM_UP, 0,
1781                                              new_asoc->c.sinit_num_ostreams,
1782                                              new_asoc->c.sinit_max_instreams,
1783                                              GFP_ATOMIC);
1784                 if (!ev)
1785                         goto nomem;
1786                 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
1787                                 SCTP_ULPEVENT(ev));
1788
1789                 /* Sockets API Draft Section 5.3.1.6
1790                  * When a peer sends a Adaption Layer Indication parameter,
1791                  * SCTP delivers this notification to inform the application
1792                  * that of the peers requested adaption layer.
1793                  */
1794                 if (new_asoc->peer.adaption_ind) {
1795                         ev = sctp_ulpevent_make_adaption_indication(new_asoc,
1796                                                                  GFP_ATOMIC);
1797                         if (!ev)
1798                                 goto nomem;
1799
1800                         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
1801                                         SCTP_ULPEVENT(ev));
1802                 }
1803         }
1804         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
1805
1806         repl = sctp_make_cookie_ack(new_asoc, chunk);
1807         if (!repl)
1808                 goto nomem;
1809
1810         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
1811         sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
1812
1813         return SCTP_DISPOSITION_CONSUME;
1814
1815 nomem:
1816         if (ev)
1817                 sctp_ulpevent_free(ev);
1818         return SCTP_DISPOSITION_NOMEM;
1819 }
1820
1821 /*
1822  * Handle a duplicate COOKIE-ECHO.  This usually means a cookie-carrying
1823  * chunk was retransmitted and then delayed in the network.
1824  *
1825  * Section: 5.2.4 Handle a COOKIE ECHO when a TCB exists
1826  *
1827  * Verification Tag: None.  Do cookie validation.
1828  *
1829  * Inputs
1830  * (endpoint, asoc, chunk)
1831  *
1832  * Outputs
1833  * (asoc, reply_msg, msg_up, timers, counters)
1834  *
1835  * The return value is the disposition of the chunk.
1836  */
1837 sctp_disposition_t sctp_sf_do_5_2_4_dupcook(const struct sctp_endpoint *ep,
1838                                         const struct sctp_association *asoc,
1839                                         const sctp_subtype_t type,
1840                                         void *arg,
1841                                         sctp_cmd_seq_t *commands)
1842 {
1843         sctp_disposition_t retval;
1844         struct sctp_chunk *chunk = arg;
1845         struct sctp_association *new_asoc;
1846         int error = 0;
1847         char action;
1848         struct sctp_chunk *err_chk_p;
1849
1850         /* Make sure that the chunk has a valid length from the protocol
1851          * perspective.  In this case check to make sure we have at least
1852          * enough for the chunk header.  Cookie length verification is
1853          * done later.
1854          */
1855         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
1856                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
1857                                                   commands);
1858
1859         /* "Decode" the chunk.  We have no optional parameters so we
1860          * are in good shape.
1861          */
1862         chunk->subh.cookie_hdr = (struct sctp_signed_cookie *)chunk->skb->data;
1863         skb_pull(chunk->skb, ntohs(chunk->chunk_hdr->length) -
1864                  sizeof(sctp_chunkhdr_t));
1865
1866         /* In RFC 2960 5.2.4 3, if both Verification Tags in the State Cookie
1867          * of a duplicate COOKIE ECHO match the Verification Tags of the
1868          * current association, consider the State Cookie valid even if
1869          * the lifespan is exceeded.
1870          */
1871         new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,
1872                                       &err_chk_p);
1873
1874         /* FIXME:
1875          * If the re-build failed, what is the proper error path
1876          * from here?
1877          *
1878          * [We should abort the association. --piggy]
1879          */
1880         if (!new_asoc) {
1881                 /* FIXME: Several errors are possible.  A bad cookie should
1882                  * be silently discarded, but think about logging it too.
1883                  */
1884                 switch (error) {
1885                 case -SCTP_IERROR_NOMEM:
1886                         goto nomem;
1887
1888                 case -SCTP_IERROR_STALE_COOKIE:
1889                         sctp_send_stale_cookie_err(ep, asoc, chunk, commands,
1890                                                    err_chk_p);
1891                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1892                 case -SCTP_IERROR_BAD_SIG:
1893                 default:
1894                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1895                 };
1896         }
1897
1898         /* Compare the tie_tag in cookie with the verification tag of
1899          * current association.
1900          */
1901         action = sctp_tietags_compare(new_asoc, asoc);
1902
1903         switch (action) {
1904         case 'A': /* Association restart. */
1905                 retval = sctp_sf_do_dupcook_a(ep, asoc, chunk, commands,
1906                                               new_asoc);
1907                 break;
1908
1909         case 'B': /* Collision case B. */
1910                 retval = sctp_sf_do_dupcook_b(ep, asoc, chunk, commands,
1911                                               new_asoc);
1912                 break;
1913
1914         case 'C': /* Collision case C. */
1915                 retval = sctp_sf_do_dupcook_c(ep, asoc, chunk, commands,
1916                                               new_asoc);
1917                 break;
1918
1919         case 'D': /* Collision case D. */
1920                 retval = sctp_sf_do_dupcook_d(ep, asoc, chunk, commands,
1921                                               new_asoc);
1922                 break;
1923
1924         default: /* Discard packet for all others. */
1925                 retval = sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1926                 break;
1927         };
1928
1929         /* Delete the tempory new association. */
1930         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
1931         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
1932
1933         return retval;
1934
1935 nomem:
1936         return SCTP_DISPOSITION_NOMEM;
1937 }
1938
1939 /*
1940  * Process an ABORT.  (SHUTDOWN-PENDING state)
1941  *
1942  * See sctp_sf_do_9_1_abort().
1943  */
1944 sctp_disposition_t sctp_sf_shutdown_pending_abort(
1945         const struct sctp_endpoint *ep,
1946         const struct sctp_association *asoc,
1947         const sctp_subtype_t type,
1948         void *arg,
1949         sctp_cmd_seq_t *commands)
1950 {
1951         struct sctp_chunk *chunk = arg;
1952
1953         if (!sctp_vtag_verify_either(chunk, asoc))
1954                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1955
1956         /* Make sure that the ABORT chunk has a valid length.
1957          * Since this is an ABORT chunk, we have to discard it
1958          * because of the following text:
1959          * RFC 2960, Section 3.3.7
1960          *    If an endpoint receives an ABORT with a format error or for an
1961          *    association that doesn't exist, it MUST silently discard it.
1962          * Becasue the length is "invalid", we can't really discard just
1963          * as we do not know its true length.  So, to be safe, discard the
1964          * packet.
1965          */
1966         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
1967                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1968
1969         /* Stop the T5-shutdown guard timer.  */
1970         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
1971                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
1972
1973         return sctp_sf_do_9_1_abort(ep, asoc, type, arg, commands);
1974 }
1975
1976 /*
1977  * Process an ABORT.  (SHUTDOWN-SENT state)
1978  *
1979  * See sctp_sf_do_9_1_abort().
1980  */
1981 sctp_disposition_t sctp_sf_shutdown_sent_abort(const struct sctp_endpoint *ep,
1982                                         const struct sctp_association *asoc,
1983                                         const sctp_subtype_t type,
1984                                         void *arg,
1985                                         sctp_cmd_seq_t *commands)
1986 {
1987         struct sctp_chunk *chunk = arg;
1988
1989         if (!sctp_vtag_verify_either(chunk, asoc))
1990                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
1991
1992         /* Make sure that the ABORT chunk has a valid length.
1993          * Since this is an ABORT chunk, we have to discard it
1994          * because of the following text:
1995          * RFC 2960, Section 3.3.7
1996          *    If an endpoint receives an ABORT with a format error or for an
1997          *    association that doesn't exist, it MUST silently discard it.
1998          * Becasue the length is "invalid", we can't really discard just
1999          * as we do not know its true length.  So, to be safe, discard the
2000          * packet.
2001          */
2002         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
2003                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2004
2005         /* Stop the T2-shutdown timer. */
2006         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
2007                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
2008
2009         /* Stop the T5-shutdown guard timer.  */
2010         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
2011                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
2012
2013         return sctp_sf_do_9_1_abort(ep, asoc, type, arg, commands);
2014 }
2015
2016 /*
2017  * Process an ABORT.  (SHUTDOWN-ACK-SENT state)
2018  *
2019  * See sctp_sf_do_9_1_abort().
2020  */
2021 sctp_disposition_t sctp_sf_shutdown_ack_sent_abort(
2022         const struct sctp_endpoint *ep,
2023         const struct sctp_association *asoc,
2024         const sctp_subtype_t type,
2025         void *arg,
2026         sctp_cmd_seq_t *commands)
2027 {
2028         /* The same T2 timer, so we should be able to use
2029          * common function with the SHUTDOWN-SENT state.
2030          */
2031         return sctp_sf_shutdown_sent_abort(ep, asoc, type, arg, commands);
2032 }
2033
2034 /*
2035  * Handle an Error received in COOKIE_ECHOED state.
2036  *
2037  * Only handle the error type of stale COOKIE Error, the other errors will
2038  * be ignored.
2039  *
2040  * Inputs
2041  * (endpoint, asoc, chunk)
2042  *
2043  * Outputs
2044  * (asoc, reply_msg, msg_up, timers, counters)
2045  *
2046  * The return value is the disposition of the chunk.
2047  */
2048 sctp_disposition_t sctp_sf_cookie_echoed_err(const struct sctp_endpoint *ep,
2049                                         const struct sctp_association *asoc,
2050                                         const sctp_subtype_t type,
2051                                         void *arg,
2052                                         sctp_cmd_seq_t *commands)
2053 {
2054         struct sctp_chunk *chunk = arg;
2055         sctp_errhdr_t *err;
2056
2057         if (!sctp_vtag_verify(chunk, asoc))
2058                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2059
2060         /* Make sure that the ERROR chunk has a valid length.
2061          * The parameter walking depends on this as well.
2062          */
2063         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_operr_chunk_t)))
2064                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2065                                                   commands);
2066
2067         /* Process the error here */
2068         /* FUTURE FIXME:  When PR-SCTP related and other optional
2069          * parms are emitted, this will have to change to handle multiple
2070          * errors.
2071          */
2072         sctp_walk_errors(err, chunk->chunk_hdr) {
2073                 if (SCTP_ERROR_STALE_COOKIE == err->cause)
2074                         return sctp_sf_do_5_2_6_stale(ep, asoc, type,
2075                                                         arg, commands);
2076         }
2077
2078         /* It is possible to have malformed error causes, and that
2079          * will cause us to end the walk early.  However, since
2080          * we are discarding the packet, there should be no adverse
2081          * affects.
2082          */
2083         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2084 }
2085
2086 /*
2087  * Handle a Stale COOKIE Error
2088  *
2089  * Section: 5.2.6 Handle Stale COOKIE Error
2090  * If the association is in the COOKIE-ECHOED state, the endpoint may elect
2091  * one of the following three alternatives.
2092  * ...
2093  * 3) Send a new INIT chunk to the endpoint, adding a Cookie
2094  *    Preservative parameter requesting an extension to the lifetime of
2095  *    the State Cookie. When calculating the time extension, an
2096  *    implementation SHOULD use the RTT information measured based on the
2097  *    previous COOKIE ECHO / ERROR exchange, and should add no more
2098  *    than 1 second beyond the measured RTT, due to long State Cookie
2099  *    lifetimes making the endpoint more subject to a replay attack.
2100  *
2101  * Verification Tag:  Not explicit, but safe to ignore.
2102  *
2103  * Inputs
2104  * (endpoint, asoc, chunk)
2105  *
2106  * Outputs
2107  * (asoc, reply_msg, msg_up, timers, counters)
2108  *
2109  * The return value is the disposition of the chunk.
2110  */
2111 static sctp_disposition_t sctp_sf_do_5_2_6_stale(const struct sctp_endpoint *ep,
2112                                                  const struct sctp_association *asoc,
2113                                                  const sctp_subtype_t type,
2114                                                  void *arg,
2115                                                  sctp_cmd_seq_t *commands)
2116 {
2117         struct sctp_chunk *chunk = arg;
2118         time_t stale;
2119         sctp_cookie_preserve_param_t bht;
2120         sctp_errhdr_t *err;
2121         struct sctp_chunk *reply;
2122         struct sctp_bind_addr *bp;
2123         int attempts = asoc->init_err_counter + 1;
2124
2125         if (attempts > asoc->max_init_attempts) {
2126                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
2127                                 SCTP_U32(SCTP_ERROR_STALE_COOKIE));
2128                 return SCTP_DISPOSITION_DELETE_TCB;
2129         }
2130
2131         err = (sctp_errhdr_t *)(chunk->skb->data);
2132
2133         /* When calculating the time extension, an implementation
2134          * SHOULD use the RTT information measured based on the
2135          * previous COOKIE ECHO / ERROR exchange, and should add no
2136          * more than 1 second beyond the measured RTT, due to long
2137          * State Cookie lifetimes making the endpoint more subject to
2138          * a replay attack.
2139          * Measure of Staleness's unit is usec. (1/1000000 sec)
2140          * Suggested Cookie Life-span Increment's unit is msec.
2141          * (1/1000 sec)
2142          * In general, if you use the suggested cookie life, the value
2143          * found in the field of measure of staleness should be doubled
2144          * to give ample time to retransmit the new cookie and thus
2145          * yield a higher probability of success on the reattempt.
2146          */
2147         stale = ntohl(*(suseconds_t *)((u8 *)err + sizeof(sctp_errhdr_t)));
2148         stale = (stale * 2) / 1000;
2149
2150         bht.param_hdr.type = SCTP_PARAM_COOKIE_PRESERVATIVE;
2151         bht.param_hdr.length = htons(sizeof(bht));
2152         bht.lifespan_increment = htonl(stale);
2153
2154         /* Build that new INIT chunk.  */
2155         bp = (struct sctp_bind_addr *) &asoc->base.bind_addr;
2156         reply = sctp_make_init(asoc, bp, GFP_ATOMIC, sizeof(bht));
2157         if (!reply)
2158                 goto nomem;
2159
2160         sctp_addto_chunk(reply, sizeof(bht), &bht);
2161
2162         /* Clear peer's init_tag cached in assoc as we are sending a new INIT */
2163         sctp_add_cmd_sf(commands, SCTP_CMD_CLEAR_INIT_TAG, SCTP_NULL());
2164
2165         /* Stop pending T3-rtx and heartbeat timers */
2166         sctp_add_cmd_sf(commands, SCTP_CMD_T3_RTX_TIMERS_STOP, SCTP_NULL());
2167         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
2168
2169         /* Delete non-primary peer ip addresses since we are transitioning
2170          * back to the COOKIE-WAIT state
2171          */
2172         sctp_add_cmd_sf(commands, SCTP_CMD_DEL_NON_PRIMARY, SCTP_NULL());
2173
2174         /* If we've sent any data bundled with COOKIE-ECHO we will need to
2175          * resend
2176          */
2177         sctp_add_cmd_sf(commands, SCTP_CMD_RETRAN,
2178                         SCTP_TRANSPORT(asoc->peer.primary_path));
2179
2180         /* Cast away the const modifier, as we want to just
2181          * rerun it through as a sideffect.
2182          */
2183         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_COUNTER_INC, SCTP_NULL());
2184
2185         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
2186                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
2187         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
2188                         SCTP_STATE(SCTP_STATE_COOKIE_WAIT));
2189         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
2190                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
2191
2192         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
2193
2194         return SCTP_DISPOSITION_CONSUME;
2195
2196 nomem:
2197         return SCTP_DISPOSITION_NOMEM;
2198 }
2199
2200 /*
2201  * Process an ABORT.
2202  *
2203  * Section: 9.1
2204  * After checking the Verification Tag, the receiving endpoint shall
2205  * remove the association from its record, and shall report the
2206  * termination to its upper layer.
2207  *
2208  * Verification Tag: 8.5.1 Exceptions in Verification Tag Rules
2209  * B) Rules for packet carrying ABORT:
2210  *
2211  *  - The endpoint shall always fill in the Verification Tag field of the
2212  *    outbound packet with the destination endpoint's tag value if it
2213  *    is known.
2214  *
2215  *  - If the ABORT is sent in response to an OOTB packet, the endpoint
2216  *    MUST follow the procedure described in Section 8.4.
2217  *
2218  *  - The receiver MUST accept the packet if the Verification Tag
2219  *    matches either its own tag, OR the tag of its peer. Otherwise, the
2220  *    receiver MUST silently discard the packet and take no further
2221  *    action.
2222  *
2223  * Inputs
2224  * (endpoint, asoc, chunk)
2225  *
2226  * Outputs
2227  * (asoc, reply_msg, msg_up, timers, counters)
2228  *
2229  * The return value is the disposition of the chunk.
2230  */
2231 sctp_disposition_t sctp_sf_do_9_1_abort(const struct sctp_endpoint *ep,
2232                                         const struct sctp_association *asoc,
2233                                         const sctp_subtype_t type,
2234                                         void *arg,
2235                                         sctp_cmd_seq_t *commands)
2236 {
2237         struct sctp_chunk *chunk = arg;
2238         unsigned len;
2239         __u16 error = SCTP_ERROR_NO_ERROR;
2240
2241         if (!sctp_vtag_verify_either(chunk, asoc))
2242                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2243
2244         /* Make sure that the ABORT chunk has a valid length.
2245          * Since this is an ABORT chunk, we have to discard it
2246          * because of the following text:
2247          * RFC 2960, Section 3.3.7
2248          *    If an endpoint receives an ABORT with a format error or for an
2249          *    association that doesn't exist, it MUST silently discard it.
2250          * Becasue the length is "invalid", we can't really discard just
2251          * as we do not know its true length.  So, to be safe, discard the
2252          * packet.
2253          */
2254         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
2255                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2256
2257         /* See if we have an error cause code in the chunk.  */
2258         len = ntohs(chunk->chunk_hdr->length);
2259         if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr))
2260                 error = ((sctp_errhdr_t *)chunk->skb->data)->cause;
2261
2262         /* ASSOC_FAILED will DELETE_TCB. */
2263         sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED, SCTP_U32(error));
2264         SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
2265         SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
2266
2267         return SCTP_DISPOSITION_ABORT;
2268 }
2269
2270 /*
2271  * Process an ABORT.  (COOKIE-WAIT state)
2272  *
2273  * See sctp_sf_do_9_1_abort() above.
2274  */
2275 sctp_disposition_t sctp_sf_cookie_wait_abort(const struct sctp_endpoint *ep,
2276                                      const struct sctp_association *asoc,
2277                                      const sctp_subtype_t type,
2278                                      void *arg,
2279                                      sctp_cmd_seq_t *commands)
2280 {
2281         struct sctp_chunk *chunk = arg;
2282         unsigned len;
2283         __u16 error = SCTP_ERROR_NO_ERROR;
2284
2285         if (!sctp_vtag_verify_either(chunk, asoc))
2286                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2287
2288         /* Make sure that the ABORT chunk has a valid length.
2289          * Since this is an ABORT chunk, we have to discard it
2290          * because of the following text:
2291          * RFC 2960, Section 3.3.7
2292          *    If an endpoint receives an ABORT with a format error or for an
2293          *    association that doesn't exist, it MUST silently discard it.
2294          * Becasue the length is "invalid", we can't really discard just
2295          * as we do not know its true length.  So, to be safe, discard the
2296          * packet.
2297          */
2298         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
2299                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2300
2301         /* See if we have an error cause code in the chunk.  */
2302         len = ntohs(chunk->chunk_hdr->length);
2303         if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr))
2304                 error = ((sctp_errhdr_t *)chunk->skb->data)->cause;
2305
2306         return sctp_stop_t1_and_abort(commands, error, asoc, chunk->transport);
2307 }
2308
2309 /*
2310  * Process an incoming ICMP as an ABORT.  (COOKIE-WAIT state)
2311  */
2312 sctp_disposition_t sctp_sf_cookie_wait_icmp_abort(const struct sctp_endpoint *ep,
2313                                         const struct sctp_association *asoc,
2314                                         const sctp_subtype_t type,
2315                                         void *arg,
2316                                         sctp_cmd_seq_t *commands)
2317 {
2318         return sctp_stop_t1_and_abort(commands, SCTP_ERROR_NO_ERROR, asoc,
2319                                       (struct sctp_transport *)arg);
2320 }
2321
2322 /*
2323  * Process an ABORT.  (COOKIE-ECHOED state)
2324  */
2325 sctp_disposition_t sctp_sf_cookie_echoed_abort(const struct sctp_endpoint *ep,
2326                                                const struct sctp_association *asoc,
2327                                                const sctp_subtype_t type,
2328                                                void *arg,
2329                                                sctp_cmd_seq_t *commands)
2330 {
2331         /* There is a single T1 timer, so we should be able to use
2332          * common function with the COOKIE-WAIT state.
2333          */
2334         return sctp_sf_cookie_wait_abort(ep, asoc, type, arg, commands);
2335 }
2336
2337 /*
2338  * Stop T1 timer and abort association with "INIT failed".
2339  *
2340  * This is common code called by several sctp_sf_*_abort() functions above.
2341  */
2342 static sctp_disposition_t sctp_stop_t1_and_abort(sctp_cmd_seq_t *commands,
2343                                            __u16 error,
2344                                            const struct sctp_association *asoc,
2345                                            struct sctp_transport *transport)
2346 {
2347         SCTP_DEBUG_PRINTK("ABORT received (INIT).\n");
2348         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
2349                         SCTP_STATE(SCTP_STATE_CLOSED));
2350         SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
2351         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
2352                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
2353         /* CMD_INIT_FAILED will DELETE_TCB. */
2354         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
2355                         SCTP_U32(error));
2356         return SCTP_DISPOSITION_ABORT;
2357 }
2358
2359 /*
2360  * sctp_sf_do_9_2_shut
2361  *
2362  * Section: 9.2
2363  * Upon the reception of the SHUTDOWN, the peer endpoint shall
2364  *  - enter the SHUTDOWN-RECEIVED state,
2365  *
2366  *  - stop accepting new data from its SCTP user
2367  *
2368  *  - verify, by checking the Cumulative TSN Ack field of the chunk,
2369  *    that all its outstanding DATA chunks have been received by the
2370  *    SHUTDOWN sender.
2371  *
2372  * Once an endpoint as reached the SHUTDOWN-RECEIVED state it MUST NOT
2373  * send a SHUTDOWN in response to a ULP request. And should discard
2374  * subsequent SHUTDOWN chunks.
2375  *
2376  * If there are still outstanding DATA chunks left, the SHUTDOWN
2377  * receiver shall continue to follow normal data transmission
2378  * procedures defined in Section 6 until all outstanding DATA chunks
2379  * are acknowledged; however, the SHUTDOWN receiver MUST NOT accept
2380  * new data from its SCTP user.
2381  *
2382  * Verification Tag:  8.5 Verification Tag [Normal verification]
2383  *
2384  * Inputs
2385  * (endpoint, asoc, chunk)
2386  *
2387  * Outputs
2388  * (asoc, reply_msg, msg_up, timers, counters)
2389  *
2390  * The return value is the disposition of the chunk.
2391  */
2392 sctp_disposition_t sctp_sf_do_9_2_shutdown(const struct sctp_endpoint *ep,
2393                                            const struct sctp_association *asoc,
2394                                            const sctp_subtype_t type,
2395                                            void *arg,
2396                                            sctp_cmd_seq_t *commands)
2397 {
2398         struct sctp_chunk *chunk = arg;
2399         sctp_shutdownhdr_t *sdh;
2400         sctp_disposition_t disposition;
2401         struct sctp_ulpevent *ev;
2402
2403         if (!sctp_vtag_verify(chunk, asoc))
2404                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2405
2406         /* Make sure that the SHUTDOWN chunk has a valid length. */
2407         if (!sctp_chunk_length_valid(chunk,
2408                                       sizeof(struct sctp_shutdown_chunk_t)))
2409                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2410                                                   commands);
2411
2412         /* Convert the elaborate header.  */
2413         sdh = (sctp_shutdownhdr_t *)chunk->skb->data;
2414         skb_pull(chunk->skb, sizeof(sctp_shutdownhdr_t));
2415         chunk->subh.shutdown_hdr = sdh;
2416
2417         /* API 5.3.1.5 SCTP_SHUTDOWN_EVENT
2418          * When a peer sends a SHUTDOWN, SCTP delivers this notification to
2419          * inform the application that it should cease sending data.
2420          */
2421         ev = sctp_ulpevent_make_shutdown_event(asoc, 0, GFP_ATOMIC);
2422         if (!ev) {
2423                 disposition = SCTP_DISPOSITION_NOMEM;
2424                 goto out;
2425         }
2426         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
2427
2428         /* Upon the reception of the SHUTDOWN, the peer endpoint shall
2429          *  - enter the SHUTDOWN-RECEIVED state,
2430          *  - stop accepting new data from its SCTP user
2431          *
2432          * [This is implicit in the new state.]
2433          */
2434         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
2435                         SCTP_STATE(SCTP_STATE_SHUTDOWN_RECEIVED));
2436         disposition = SCTP_DISPOSITION_CONSUME;
2437
2438         if (sctp_outq_is_empty(&asoc->outqueue)) {
2439                 disposition = sctp_sf_do_9_2_shutdown_ack(ep, asoc, type,
2440                                                           arg, commands);
2441         }
2442
2443         if (SCTP_DISPOSITION_NOMEM == disposition)
2444                 goto out;
2445
2446         /*  - verify, by checking the Cumulative TSN Ack field of the
2447          *    chunk, that all its outstanding DATA chunks have been
2448          *    received by the SHUTDOWN sender.
2449          */
2450         sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_CTSN,
2451                         SCTP_U32(chunk->subh.shutdown_hdr->cum_tsn_ack));
2452
2453 out:
2454         return disposition;
2455 }
2456
2457 /* RFC 2960 9.2
2458  * If an endpoint is in SHUTDOWN-ACK-SENT state and receives an INIT chunk
2459  * (e.g., if the SHUTDOWN COMPLETE was lost) with source and destination
2460  * transport addresses (either in the IP addresses or in the INIT chunk)
2461  * that belong to this association, it should discard the INIT chunk and
2462  * retransmit the SHUTDOWN ACK chunk.
2463  */
2464 sctp_disposition_t sctp_sf_do_9_2_reshutack(const struct sctp_endpoint *ep,
2465                                     const struct sctp_association *asoc,
2466                                     const sctp_subtype_t type,
2467                                     void *arg,
2468                                     sctp_cmd_seq_t *commands)
2469 {
2470         struct sctp_chunk *chunk = (struct sctp_chunk *) arg;
2471         struct sctp_chunk *reply;
2472
2473         /* Since we are not going to really process this INIT, there
2474          * is no point in verifying chunk boundries.  Just generate
2475          * the SHUTDOWN ACK.
2476          */
2477         reply = sctp_make_shutdown_ack(asoc, chunk);
2478         if (NULL == reply)
2479                 goto nomem;
2480
2481         /* Set the transport for the SHUTDOWN ACK chunk and the timeout for
2482          * the T2-SHUTDOWN timer.
2483          */
2484         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
2485
2486         /* and restart the T2-shutdown timer. */
2487         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
2488                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
2489
2490         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
2491
2492         return SCTP_DISPOSITION_CONSUME;
2493 nomem:
2494         return SCTP_DISPOSITION_NOMEM;
2495 }
2496
2497 /*
2498  * sctp_sf_do_ecn_cwr
2499  *
2500  * Section:  Appendix A: Explicit Congestion Notification
2501  *
2502  * CWR:
2503  *
2504  * RFC 2481 details a specific bit for a sender to send in the header of
2505  * its next outbound TCP segment to indicate to its peer that it has
2506  * reduced its congestion window.  This is termed the CWR bit.  For
2507  * SCTP the same indication is made by including the CWR chunk.
2508  * This chunk contains one data element, i.e. the TSN number that
2509  * was sent in the ECNE chunk.  This element represents the lowest
2510  * TSN number in the datagram that was originally marked with the
2511  * CE bit.
2512  *
2513  * Verification Tag: 8.5 Verification Tag [Normal verification]
2514  * Inputs
2515  * (endpoint, asoc, chunk)
2516  *
2517  * Outputs
2518  * (asoc, reply_msg, msg_up, timers, counters)
2519  *
2520  * The return value is the disposition of the chunk.
2521  */
2522 sctp_disposition_t sctp_sf_do_ecn_cwr(const struct sctp_endpoint *ep,
2523                                       const struct sctp_association *asoc,
2524                                       const sctp_subtype_t type,
2525                                       void *arg,
2526                                       sctp_cmd_seq_t *commands)
2527 {
2528         sctp_cwrhdr_t *cwr;
2529         struct sctp_chunk *chunk = arg;
2530
2531         if (!sctp_vtag_verify(chunk, asoc))
2532                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2533
2534         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_ecne_chunk_t)))
2535                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2536                                                   commands);
2537
2538         cwr = (sctp_cwrhdr_t *) chunk->skb->data;
2539         skb_pull(chunk->skb, sizeof(sctp_cwrhdr_t));
2540
2541         cwr->lowest_tsn = ntohl(cwr->lowest_tsn);
2542
2543         /* Does this CWR ack the last sent congestion notification? */
2544         if (TSN_lte(asoc->last_ecne_tsn, cwr->lowest_tsn)) {
2545                 /* Stop sending ECNE. */
2546                 sctp_add_cmd_sf(commands,
2547                                 SCTP_CMD_ECN_CWR,
2548                                 SCTP_U32(cwr->lowest_tsn));
2549         }
2550         return SCTP_DISPOSITION_CONSUME;
2551 }
2552
2553 /*
2554  * sctp_sf_do_ecne
2555  *
2556  * Section:  Appendix A: Explicit Congestion Notification
2557  *
2558  * ECN-Echo
2559  *
2560  * RFC 2481 details a specific bit for a receiver to send back in its
2561  * TCP acknowledgements to notify the sender of the Congestion
2562  * Experienced (CE) bit having arrived from the network.  For SCTP this
2563  * same indication is made by including the ECNE chunk.  This chunk
2564  * contains one data element, i.e. the lowest TSN associated with the IP
2565  * datagram marked with the CE bit.....
2566  *
2567  * Verification Tag: 8.5 Verification Tag [Normal verification]
2568  * Inputs
2569  * (endpoint, asoc, chunk)
2570  *
2571  * Outputs
2572  * (asoc, reply_msg, msg_up, timers, counters)
2573  *
2574  * The return value is the disposition of the chunk.
2575  */
2576 sctp_disposition_t sctp_sf_do_ecne(const struct sctp_endpoint *ep,
2577                                    const struct sctp_association *asoc,
2578                                    const sctp_subtype_t type,
2579                                    void *arg,
2580                                    sctp_cmd_seq_t *commands)
2581 {
2582         sctp_ecnehdr_t *ecne;
2583         struct sctp_chunk *chunk = arg;
2584
2585         if (!sctp_vtag_verify(chunk, asoc))
2586                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2587
2588         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_ecne_chunk_t)))
2589                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2590                                                   commands);
2591
2592         ecne = (sctp_ecnehdr_t *) chunk->skb->data;
2593         skb_pull(chunk->skb, sizeof(sctp_ecnehdr_t));
2594
2595         /* If this is a newer ECNE than the last CWR packet we sent out */
2596         sctp_add_cmd_sf(commands, SCTP_CMD_ECN_ECNE,
2597                         SCTP_U32(ntohl(ecne->lowest_tsn)));
2598
2599         return SCTP_DISPOSITION_CONSUME;
2600 }
2601
2602 /*
2603  * Section: 6.2  Acknowledgement on Reception of DATA Chunks
2604  *
2605  * The SCTP endpoint MUST always acknowledge the reception of each valid
2606  * DATA chunk.
2607  *
2608  * The guidelines on delayed acknowledgement algorithm specified in
2609  * Section 4.2 of [RFC2581] SHOULD be followed. Specifically, an
2610  * acknowledgement SHOULD be generated for at least every second packet
2611  * (not every second DATA chunk) received, and SHOULD be generated within
2612  * 200 ms of the arrival of any unacknowledged DATA chunk. In some
2613  * situations it may be beneficial for an SCTP transmitter to be more
2614  * conservative than the algorithms detailed in this document allow.
2615  * However, an SCTP transmitter MUST NOT be more aggressive than the
2616  * following algorithms allow.
2617  *
2618  * A SCTP receiver MUST NOT generate more than one SACK for every
2619  * incoming packet, other than to update the offered window as the
2620  * receiving application consumes new data.
2621  *
2622  * Verification Tag:  8.5 Verification Tag [Normal verification]
2623  *
2624  * Inputs
2625  * (endpoint, asoc, chunk)
2626  *
2627  * Outputs
2628  * (asoc, reply_msg, msg_up, timers, counters)
2629  *
2630  * The return value is the disposition of the chunk.
2631  */
2632 sctp_disposition_t sctp_sf_eat_data_6_2(const struct sctp_endpoint *ep,
2633                                         const struct sctp_association *asoc,
2634                                         const sctp_subtype_t type,
2635                                         void *arg,
2636                                         sctp_cmd_seq_t *commands)
2637 {
2638         struct sctp_chunk *chunk = arg;
2639         int error;
2640
2641         if (!sctp_vtag_verify(chunk, asoc)) {
2642                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
2643                                 SCTP_NULL());
2644                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2645         }
2646
2647         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_data_chunk_t)))
2648                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2649                                                   commands);
2650
2651         error = sctp_eat_data(asoc, chunk, commands );
2652         switch (error) {
2653         case SCTP_IERROR_NO_ERROR:
2654                 break;
2655         case SCTP_IERROR_HIGH_TSN:
2656         case SCTP_IERROR_BAD_STREAM:
2657                 goto discard_noforce;
2658         case SCTP_IERROR_DUP_TSN:
2659         case SCTP_IERROR_IGNORE_TSN:
2660                 goto discard_force;
2661         case SCTP_IERROR_NO_DATA:
2662                 goto consume;
2663         default:
2664                 BUG();
2665         }
2666
2667         if (asoc->autoclose) {
2668                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
2669                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
2670         }
2671
2672         /* If this is the last chunk in a packet, we need to count it
2673          * toward sack generation.  Note that we need to SACK every
2674          * OTHER packet containing data chunks, EVEN IF WE DISCARD
2675          * THEM.  We elect to NOT generate SACK's if the chunk fails
2676          * the verification tag test.
2677          *
2678          * RFC 2960 6.2 Acknowledgement on Reception of DATA Chunks
2679          *
2680          * The SCTP endpoint MUST always acknowledge the reception of
2681          * each valid DATA chunk.
2682          *
2683          * The guidelines on delayed acknowledgement algorithm
2684          * specified in  Section 4.2 of [RFC2581] SHOULD be followed.
2685          * Specifically, an acknowledgement SHOULD be generated for at
2686          * least every second packet (not every second DATA chunk)
2687          * received, and SHOULD be generated within 200 ms of the
2688          * arrival of any unacknowledged DATA chunk.  In some
2689          * situations it may be beneficial for an SCTP transmitter to
2690          * be more conservative than the algorithms detailed in this
2691          * document allow. However, an SCTP transmitter MUST NOT be
2692          * more aggressive than the following algorithms allow.
2693          */
2694         if (chunk->end_of_packet)
2695                 sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
2696
2697         return SCTP_DISPOSITION_CONSUME;
2698
2699 discard_force:
2700         /* RFC 2960 6.2 Acknowledgement on Reception of DATA Chunks
2701          *
2702          * When a packet arrives with duplicate DATA chunk(s) and with
2703          * no new DATA chunk(s), the endpoint MUST immediately send a
2704          * SACK with no delay.  If a packet arrives with duplicate
2705          * DATA chunk(s) bundled with new DATA chunks, the endpoint
2706          * MAY immediately send a SACK.  Normally receipt of duplicate
2707          * DATA chunks will occur when the original SACK chunk was lost
2708          * and the peer's RTO has expired.  The duplicate TSN number(s)
2709          * SHOULD be reported in the SACK as duplicate.
2710          */
2711         /* In our case, we split the MAY SACK advice up whether or not
2712          * the last chunk is a duplicate.'
2713          */
2714         if (chunk->end_of_packet)
2715                 sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
2716         return SCTP_DISPOSITION_DISCARD;
2717
2718 discard_noforce:
2719         if (chunk->end_of_packet)
2720                 sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
2721
2722         return SCTP_DISPOSITION_DISCARD;
2723 consume:
2724         return SCTP_DISPOSITION_CONSUME;
2725
2726 }
2727
2728 /*
2729  * sctp_sf_eat_data_fast_4_4
2730  *
2731  * Section: 4 (4)
2732  * (4) In SHUTDOWN-SENT state the endpoint MUST acknowledge any received
2733  *    DATA chunks without delay.
2734  *
2735  * Verification Tag:  8.5 Verification Tag [Normal verification]
2736  * Inputs
2737  * (endpoint, asoc, chunk)
2738  *
2739  * Outputs
2740  * (asoc, reply_msg, msg_up, timers, counters)
2741  *
2742  * The return value is the disposition of the chunk.
2743  */
2744 sctp_disposition_t sctp_sf_eat_data_fast_4_4(const struct sctp_endpoint *ep,
2745                                      const struct sctp_association *asoc,
2746                                      const sctp_subtype_t type,
2747                                      void *arg,
2748                                      sctp_cmd_seq_t *commands)
2749 {
2750         struct sctp_chunk *chunk = arg;
2751         int error;
2752
2753         if (!sctp_vtag_verify(chunk, asoc)) {
2754                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
2755                                 SCTP_NULL());
2756                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2757         }
2758
2759         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_data_chunk_t)))
2760                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2761                                                   commands);
2762
2763         error = sctp_eat_data(asoc, chunk, commands );
2764         switch (error) {
2765         case SCTP_IERROR_NO_ERROR:
2766         case SCTP_IERROR_HIGH_TSN:
2767         case SCTP_IERROR_DUP_TSN:
2768         case SCTP_IERROR_IGNORE_TSN:
2769         case SCTP_IERROR_BAD_STREAM:
2770                 break;
2771         case SCTP_IERROR_NO_DATA:
2772                 goto consume;
2773         default:
2774                 BUG();
2775         }
2776
2777         /* Go a head and force a SACK, since we are shutting down. */
2778
2779         /* Implementor's Guide.
2780          *
2781          * While in SHUTDOWN-SENT state, the SHUTDOWN sender MUST immediately
2782          * respond to each received packet containing one or more DATA chunk(s)
2783          * with a SACK, a SHUTDOWN chunk, and restart the T2-shutdown timer
2784          */
2785         if (chunk->end_of_packet) {
2786                 /* We must delay the chunk creation since the cumulative
2787                  * TSN has not been updated yet.
2788                  */
2789                 sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SHUTDOWN, SCTP_NULL());
2790                 sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
2791                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
2792                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
2793         }
2794
2795 consume:
2796         return SCTP_DISPOSITION_CONSUME;
2797 }
2798
2799 /*
2800  * Section: 6.2  Processing a Received SACK
2801  * D) Any time a SACK arrives, the endpoint performs the following:
2802  *
2803  *     i) If Cumulative TSN Ack is less than the Cumulative TSN Ack Point,
2804  *     then drop the SACK.   Since Cumulative TSN Ack is monotonically
2805  *     increasing, a SACK whose Cumulative TSN Ack is less than the
2806  *     Cumulative TSN Ack Point indicates an out-of-order SACK.
2807  *
2808  *     ii) Set rwnd equal to the newly received a_rwnd minus the number
2809  *     of bytes still outstanding after processing the Cumulative TSN Ack
2810  *     and the Gap Ack Blocks.
2811  *
2812  *     iii) If the SACK is missing a TSN that was previously
2813  *     acknowledged via a Gap Ack Block (e.g., the data receiver
2814  *     reneged on the data), then mark the corresponding DATA chunk
2815  *     as available for retransmit:  Mark it as missing for fast
2816  *     retransmit as described in Section 7.2.4 and if no retransmit
2817  *     timer is running for the destination address to which the DATA
2818  *     chunk was originally transmitted, then T3-rtx is started for
2819  *     that destination address.
2820  *
2821  * Verification Tag:  8.5 Verification Tag [Normal verification]
2822  *
2823  * Inputs
2824  * (endpoint, asoc, chunk)
2825  *
2826  * Outputs
2827  * (asoc, reply_msg, msg_up, timers, counters)
2828  *
2829  * The return value is the disposition of the chunk.
2830  */
2831 sctp_disposition_t sctp_sf_eat_sack_6_2(const struct sctp_endpoint *ep,
2832                                         const struct sctp_association *asoc,
2833                                         const sctp_subtype_t type,
2834                                         void *arg,
2835                                         sctp_cmd_seq_t *commands)
2836 {
2837         struct sctp_chunk *chunk = arg;
2838         sctp_sackhdr_t *sackh;
2839         __u32 ctsn;
2840
2841         if (!sctp_vtag_verify(chunk, asoc))
2842                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2843
2844         /* Make sure that the SACK chunk has a valid length. */
2845         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_sack_chunk_t)))
2846                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2847                                                   commands);
2848
2849         /* Pull the SACK chunk from the data buffer */
2850         sackh = sctp_sm_pull_sack(chunk);
2851         /* Was this a bogus SACK? */
2852         if (!sackh)
2853                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2854         chunk->subh.sack_hdr = sackh;
2855         ctsn = ntohl(sackh->cum_tsn_ack);
2856
2857         /* i) If Cumulative TSN Ack is less than the Cumulative TSN
2858          *     Ack Point, then drop the SACK.  Since Cumulative TSN
2859          *     Ack is monotonically increasing, a SACK whose
2860          *     Cumulative TSN Ack is less than the Cumulative TSN Ack
2861          *     Point indicates an out-of-order SACK.
2862          */
2863         if (TSN_lt(ctsn, asoc->ctsn_ack_point)) {
2864                 SCTP_DEBUG_PRINTK("ctsn %x\n", ctsn);
2865                 SCTP_DEBUG_PRINTK("ctsn_ack_point %x\n", asoc->ctsn_ack_point);
2866                 return SCTP_DISPOSITION_DISCARD;
2867         }
2868
2869         /* Return this SACK for further processing.  */
2870         sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK, SCTP_SACKH(sackh));
2871
2872         /* Note: We do the rest of the work on the PROCESS_SACK
2873          * sideeffect.
2874          */
2875         return SCTP_DISPOSITION_CONSUME;
2876 }
2877
2878 /*
2879  * Generate an ABORT in response to a packet.
2880  *
2881  * Section: 8.4 Handle "Out of the blue" Packets, sctpimpguide 2.41
2882  *
2883  * 8) The receiver should respond to the sender of the OOTB packet with
2884  *    an ABORT.  When sending the ABORT, the receiver of the OOTB packet
2885  *    MUST fill in the Verification Tag field of the outbound packet
2886  *    with the value found in the Verification Tag field of the OOTB
2887  *    packet and set the T-bit in the Chunk Flags to indicate that the
2888  *    Verification Tag is reflected.  After sending this ABORT, the
2889  *    receiver of the OOTB packet shall discard the OOTB packet and take
2890  *    no further action.
2891  *
2892  * Verification Tag:
2893  *
2894  * The return value is the disposition of the chunk.
2895 */
2896 sctp_disposition_t sctp_sf_tabort_8_4_8(const struct sctp_endpoint *ep,
2897                                         const struct sctp_association *asoc,
2898                                         const sctp_subtype_t type,
2899                                         void *arg,
2900                                         sctp_cmd_seq_t *commands)
2901 {
2902         struct sctp_packet *packet = NULL;
2903         struct sctp_chunk *chunk = arg;
2904         struct sctp_chunk *abort;
2905
2906         packet = sctp_ootb_pkt_new(asoc, chunk);
2907
2908         if (packet) {
2909                 /* Make an ABORT. The T bit will be set if the asoc
2910                  * is NULL.
2911                  */
2912                 abort = sctp_make_abort(asoc, chunk, 0);
2913                 if (!abort) {
2914                         sctp_ootb_pkt_free(packet);
2915                         return SCTP_DISPOSITION_NOMEM;
2916                 }
2917
2918                 /* Reflect vtag if T-Bit is set */
2919                 if (sctp_test_T_bit(abort))
2920                         packet->vtag = ntohl(chunk->sctp_hdr->vtag);
2921
2922                 /* Set the skb to the belonging sock for accounting.  */
2923                 abort->skb->sk = ep->base.sk;
2924
2925                 sctp_packet_append_chunk(packet, abort);
2926
2927                 sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
2928                                 SCTP_PACKET(packet));
2929
2930                 SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
2931
2932                 return SCTP_DISPOSITION_CONSUME;
2933         }
2934
2935         return SCTP_DISPOSITION_NOMEM;
2936 }
2937
2938 /*
2939  * Received an ERROR chunk from peer.  Generate SCTP_REMOTE_ERROR
2940  * event as ULP notification for each cause included in the chunk.
2941  *
2942  * API 5.3.1.3 - SCTP_REMOTE_ERROR
2943  *
2944  * The return value is the disposition of the chunk.
2945 */
2946 sctp_disposition_t sctp_sf_operr_notify(const struct sctp_endpoint *ep,
2947                                         const struct sctp_association *asoc,
2948                                         const sctp_subtype_t type,
2949                                         void *arg,
2950                                         sctp_cmd_seq_t *commands)
2951 {
2952         struct sctp_chunk *chunk = arg;
2953         struct sctp_ulpevent *ev;
2954
2955         if (!sctp_vtag_verify(chunk, asoc))
2956                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
2957
2958         /* Make sure that the ERROR chunk has a valid length. */
2959         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_operr_chunk_t)))
2960                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
2961                                                   commands);
2962
2963         while (chunk->chunk_end > chunk->skb->data) {
2964                 ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,
2965                                                      GFP_ATOMIC);
2966                 if (!ev)
2967                         goto nomem;
2968
2969                 if (!sctp_add_cmd(commands, SCTP_CMD_EVENT_ULP,
2970                                   SCTP_ULPEVENT(ev))) {
2971                         sctp_ulpevent_free(ev);
2972                         goto nomem;
2973                 }
2974
2975                 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_OPERR,
2976                                 SCTP_CHUNK(chunk));
2977         }
2978         return SCTP_DISPOSITION_CONSUME;
2979
2980 nomem:
2981         return SCTP_DISPOSITION_NOMEM;
2982 }
2983
2984 /*
2985  * Process an inbound SHUTDOWN ACK.
2986  *
2987  * From Section 9.2:
2988  * Upon the receipt of the SHUTDOWN ACK, the SHUTDOWN sender shall
2989  * stop the T2-shutdown timer, send a SHUTDOWN COMPLETE chunk to its
2990  * peer, and remove all record of the association.
2991  *
2992  * The return value is the disposition.
2993  */
2994 sctp_disposition_t sctp_sf_do_9_2_final(const struct sctp_endpoint *ep,
2995                                         const struct sctp_association *asoc,
2996                                         const sctp_subtype_t type,
2997                                         void *arg,
2998                                         sctp_cmd_seq_t *commands)
2999 {
3000         struct sctp_chunk *chunk = arg;
3001         struct sctp_chunk *reply;
3002         struct sctp_ulpevent *ev;
3003
3004         if (!sctp_vtag_verify(chunk, asoc))
3005                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3006
3007         /* Make sure that the SHUTDOWN_ACK chunk has a valid length. */
3008         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
3009                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3010                                                   commands);
3011
3012         /* 10.2 H) SHUTDOWN COMPLETE notification
3013          *
3014          * When SCTP completes the shutdown procedures (section 9.2) this
3015          * notification is passed to the upper layer.
3016          */
3017         ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_SHUTDOWN_COMP,
3018                                              0, 0, 0, GFP_ATOMIC);
3019         if (!ev)
3020                 goto nomem;
3021
3022         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
3023
3024         /* Upon the receipt of the SHUTDOWN ACK, the SHUTDOWN sender shall
3025          * stop the T2-shutdown timer,
3026          */
3027         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
3028                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
3029
3030         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
3031                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
3032
3033         /* ...send a SHUTDOWN COMPLETE chunk to its peer, */
3034         reply = sctp_make_shutdown_complete(asoc, chunk);
3035         if (!reply)
3036                 goto nomem;
3037
3038         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
3039                         SCTP_STATE(SCTP_STATE_CLOSED));
3040         SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
3041         SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
3042         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
3043
3044         /* ...and remove all record of the association. */
3045         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
3046         return SCTP_DISPOSITION_DELETE_TCB;
3047
3048 nomem:
3049         return SCTP_DISPOSITION_NOMEM;
3050 }
3051
3052 /*
3053  * RFC 2960, 8.4 - Handle "Out of the blue" Packets, sctpimpguide 2.41.
3054  *
3055  * 5) If the packet contains a SHUTDOWN ACK chunk, the receiver should
3056  *    respond to the sender of the OOTB packet with a SHUTDOWN COMPLETE.
3057  *    When sending the SHUTDOWN COMPLETE, the receiver of the OOTB
3058  *    packet must fill in the Verification Tag field of the outbound
3059  *    packet with the Verification Tag received in the SHUTDOWN ACK and
3060  *    set the T-bit in the Chunk Flags to indicate that the Verification
3061  *    Tag is reflected.
3062  *
3063  * 8) The receiver should respond to the sender of the OOTB packet with
3064  *    an ABORT.  When sending the ABORT, the receiver of the OOTB packet
3065  *    MUST fill in the Verification Tag field of the outbound packet
3066  *    with the value found in the Verification Tag field of the OOTB
3067  *    packet and set the T-bit in the Chunk Flags to indicate that the
3068  *    Verification Tag is reflected.  After sending this ABORT, the
3069  *    receiver of the OOTB packet shall discard the OOTB packet and take
3070  *    no further action.
3071  */
3072 sctp_disposition_t sctp_sf_ootb(const struct sctp_endpoint *ep,
3073                                 const struct sctp_association *asoc,
3074                                 const sctp_subtype_t type,
3075                                 void *arg,
3076                                 sctp_cmd_seq_t *commands)
3077 {
3078         struct sctp_chunk *chunk = arg;
3079         struct sk_buff *skb = chunk->skb;
3080         sctp_chunkhdr_t *ch;
3081         __u8 *ch_end;
3082         int ootb_shut_ack = 0;
3083
3084         SCTP_INC_STATS(SCTP_MIB_OUTOFBLUES);
3085
3086         ch = (sctp_chunkhdr_t *) chunk->chunk_hdr;
3087         do {
3088                 /* Break out if chunk length is less then minimal. */
3089                 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
3090                         break;
3091
3092                 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
3093                 if (ch_end > skb->tail)
3094                         break;
3095
3096                 if (SCTP_CID_SHUTDOWN_ACK == ch->type)
3097                         ootb_shut_ack = 1;
3098
3099                 /* RFC 2960, Section 3.3.7
3100                  *   Moreover, under any circumstances, an endpoint that
3101                  *   receives an ABORT  MUST NOT respond to that ABORT by
3102                  *   sending an ABORT of its own.
3103                  */
3104                 if (SCTP_CID_ABORT == ch->type)
3105                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3106
3107                 ch = (sctp_chunkhdr_t *) ch_end;
3108         } while (ch_end < skb->tail);
3109
3110         if (ootb_shut_ack)
3111                 sctp_sf_shut_8_4_5(ep, asoc, type, arg, commands);
3112         else
3113                 sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
3114
3115         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3116 }
3117
3118 /*
3119  * Handle an "Out of the blue" SHUTDOWN ACK.
3120  *
3121  * Section: 8.4 5, sctpimpguide 2.41.
3122  *
3123  * 5) If the packet contains a SHUTDOWN ACK chunk, the receiver should
3124  *    respond to the sender of the OOTB packet with a SHUTDOWN COMPLETE.
3125  *    When sending the SHUTDOWN COMPLETE, the receiver of the OOTB
3126  *    packet must fill in the Verification Tag field of the outbound
3127  *    packet with the Verification Tag received in the SHUTDOWN ACK and
3128  *    set the T-bit in the Chunk Flags to indicate that the Verification
3129  *    Tag is reflected.
3130  *
3131  * Inputs
3132  * (endpoint, asoc, type, arg, commands)
3133  *
3134  * Outputs
3135  * (sctp_disposition_t)
3136  *
3137  * The return value is the disposition of the chunk.
3138  */
3139 static sctp_disposition_t sctp_sf_shut_8_4_5(const struct sctp_endpoint *ep,
3140                                              const struct sctp_association *asoc,
3141                                              const sctp_subtype_t type,
3142                                              void *arg,
3143                                              sctp_cmd_seq_t *commands)
3144 {
3145         struct sctp_packet *packet = NULL;
3146         struct sctp_chunk *chunk = arg;
3147         struct sctp_chunk *shut;
3148
3149         packet = sctp_ootb_pkt_new(asoc, chunk);
3150
3151         if (packet) {
3152                 /* Make an SHUTDOWN_COMPLETE.
3153                  * The T bit will be set if the asoc is NULL.
3154                  */
3155                 shut = sctp_make_shutdown_complete(asoc, chunk);
3156                 if (!shut) {
3157                         sctp_ootb_pkt_free(packet);
3158                         return SCTP_DISPOSITION_NOMEM;
3159                 }
3160
3161                 /* Reflect vtag if T-Bit is set */
3162                 if (sctp_test_T_bit(shut))
3163                         packet->vtag = ntohl(chunk->sctp_hdr->vtag);
3164
3165                 /* Set the skb to the belonging sock for accounting.  */
3166                 shut->skb->sk = ep->base.sk;
3167
3168                 sctp_packet_append_chunk(packet, shut);
3169
3170                 sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
3171                                 SCTP_PACKET(packet));
3172
3173                 SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
3174
3175                 /* If the chunk length is invalid, we don't want to process
3176                  * the reset of the packet.
3177                  */
3178                 if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
3179                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3180
3181                 return SCTP_DISPOSITION_CONSUME;
3182         }
3183
3184         return SCTP_DISPOSITION_NOMEM;
3185 }
3186
3187 /*
3188  * Handle SHUTDOWN ACK in COOKIE_ECHOED or COOKIE_WAIT state.
3189  *
3190  * Verification Tag:  8.5.1 E) Rules for packet carrying a SHUTDOWN ACK
3191  *   If the receiver is in COOKIE-ECHOED or COOKIE-WAIT state the
3192  *   procedures in section 8.4 SHOULD be followed, in other words it
3193  *   should be treated as an Out Of The Blue packet.
3194  *   [This means that we do NOT check the Verification Tag on these
3195  *   chunks. --piggy ]
3196  *
3197  */
3198 sctp_disposition_t sctp_sf_do_8_5_1_E_sa(const struct sctp_endpoint *ep,
3199                                       const struct sctp_association *asoc,
3200                                       const sctp_subtype_t type,
3201                                       void *arg,
3202                                       sctp_cmd_seq_t *commands)
3203 {
3204         /* Although we do have an association in this case, it corresponds
3205          * to a restarted association. So the packet is treated as an OOTB
3206          * packet and the state function that handles OOTB SHUTDOWN_ACK is
3207          * called with a NULL association.
3208          */
3209         return sctp_sf_shut_8_4_5(ep, NULL, type, arg, commands);
3210 }
3211
3212 /* ADDIP Section 4.2 Upon reception of an ASCONF Chunk.  */
3213 sctp_disposition_t sctp_sf_do_asconf(const struct sctp_endpoint *ep,
3214                                      const struct sctp_association *asoc,
3215                                      const sctp_subtype_t type, void *arg,
3216                                      sctp_cmd_seq_t *commands)
3217 {
3218         struct sctp_chunk       *chunk = arg;
3219         struct sctp_chunk       *asconf_ack = NULL;
3220         sctp_addiphdr_t         *hdr;
3221         __u32                   serial;
3222
3223         if (!sctp_vtag_verify(chunk, asoc)) {
3224                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
3225                                 SCTP_NULL());
3226                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3227         }
3228
3229         /* Make sure that the ASCONF ADDIP chunk has a valid length.  */
3230         if (!sctp_chunk_length_valid(chunk, sizeof(sctp_addip_chunk_t)))
3231                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3232                                                   commands);
3233
3234         hdr = (sctp_addiphdr_t *)chunk->skb->data;
3235         serial = ntohl(hdr->serial);
3236
3237         /* ADDIP 4.2 C1) Compare the value of the serial number to the value
3238          * the endpoint stored in a new association variable
3239          * 'Peer-Serial-Number'.
3240          */
3241         if (serial == asoc->peer.addip_serial + 1) {
3242                 /* ADDIP 4.2 C2) If the value found in the serial number is
3243                  * equal to the ('Peer-Serial-Number' + 1), the endpoint MUST
3244                  * do V1-V5.
3245                  */
3246                 asconf_ack = sctp_process_asconf((struct sctp_association *)
3247                                                  asoc, chunk);
3248                 if (!asconf_ack)
3249                         return SCTP_DISPOSITION_NOMEM;
3250         } else if (serial == asoc->peer.addip_serial) {
3251                 /* ADDIP 4.2 C3) If the value found in the serial number is
3252                  * equal to the value stored in the 'Peer-Serial-Number'
3253                  * IMPLEMENTATION NOTE: As an optimization a receiver may wish
3254                  * to save the last ASCONF-ACK for some predetermined period of
3255                  * time and instead of re-processing the ASCONF (with the same
3256                  * serial number) it may just re-transmit the ASCONF-ACK.
3257                  */
3258                 if (asoc->addip_last_asconf_ack)
3259                         asconf_ack = asoc->addip_last_asconf_ack;
3260                 else
3261                         return SCTP_DISPOSITION_DISCARD;
3262         } else {
3263                 /* ADDIP 4.2 C4) Otherwise, the ASCONF Chunk is discarded since
3264                  * it must be either a stale packet or from an attacker.
3265                  */
3266                 return SCTP_DISPOSITION_DISCARD;
3267         }
3268
3269         /* ADDIP 4.2 C5) In both cases C2 and C3 the ASCONF-ACK MUST be sent
3270          * back to the source address contained in the IP header of the ASCONF
3271          * being responded to.
3272          */
3273         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(asconf_ack));
3274
3275         return SCTP_DISPOSITION_CONSUME;
3276 }
3277
3278 /*
3279  * ADDIP Section 4.3 General rules for address manipulation
3280  * When building TLV parameters for the ASCONF Chunk that will add or
3281  * delete IP addresses the D0 to D13 rules should be applied:
3282  */
3283 sctp_disposition_t sctp_sf_do_asconf_ack(const struct sctp_endpoint *ep,
3284                                          const struct sctp_association *asoc,
3285                                          const sctp_subtype_t type, void *arg,
3286                                          sctp_cmd_seq_t *commands)
3287 {
3288         struct sctp_chunk       *asconf_ack = arg;
3289         struct sctp_chunk       *last_asconf = asoc->addip_last_asconf;
3290         struct sctp_chunk       *abort;
3291         sctp_addiphdr_t         *addip_hdr;
3292         __u32                   sent_serial, rcvd_serial;
3293
3294         if (!sctp_vtag_verify(asconf_ack, asoc)) {
3295                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
3296                                 SCTP_NULL());
3297                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3298         }
3299
3300         /* Make sure that the ADDIP chunk has a valid length.  */
3301         if (!sctp_chunk_length_valid(asconf_ack, sizeof(sctp_addip_chunk_t)))
3302                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3303                                                   commands);
3304
3305         addip_hdr = (sctp_addiphdr_t *)asconf_ack->skb->data;
3306         rcvd_serial = ntohl(addip_hdr->serial);
3307
3308         if (last_asconf) {
3309                 addip_hdr = (sctp_addiphdr_t *)last_asconf->subh.addip_hdr;
3310                 sent_serial = ntohl(addip_hdr->serial);
3311         } else {
3312                 sent_serial = asoc->addip_serial - 1;
3313         }
3314
3315         /* D0) If an endpoint receives an ASCONF-ACK that is greater than or
3316          * equal to the next serial number to be used but no ASCONF chunk is
3317          * outstanding the endpoint MUST ABORT the association. Note that a
3318          * sequence number is greater than if it is no more than 2^^31-1
3319          * larger than the current sequence number (using serial arithmetic).
3320          */
3321         if (ADDIP_SERIAL_gte(rcvd_serial, sent_serial + 1) &&
3322             !(asoc->addip_last_asconf)) {
3323                 abort = sctp_make_abort(asoc, asconf_ack,
3324                                         sizeof(sctp_errhdr_t));
3325                 if (abort) {
3326                         sctp_init_cause(abort, SCTP_ERROR_ASCONF_ACK, NULL, 0);
3327                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
3328                                         SCTP_CHUNK(abort));
3329                 }
3330                 /* We are going to ABORT, so we might as well stop
3331                  * processing the rest of the chunks in the packet.
3332                  */
3333                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
3334                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
3335                 sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
3336                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
3337                                 SCTP_U32(SCTP_ERROR_ASCONF_ACK));
3338                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
3339                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
3340                 return SCTP_DISPOSITION_ABORT;
3341         }
3342
3343         if ((rcvd_serial == sent_serial) && asoc->addip_last_asconf) {
3344                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
3345                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
3346
3347                 if (!sctp_process_asconf_ack((struct sctp_association *)asoc,
3348                                              asconf_ack))
3349                         return SCTP_DISPOSITION_CONSUME;
3350
3351                 abort = sctp_make_abort(asoc, asconf_ack,
3352                                         sizeof(sctp_errhdr_t));
3353                 if (abort) {
3354                         sctp_init_cause(abort, SCTP_ERROR_RSRC_LOW, NULL, 0);
3355                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
3356                                         SCTP_CHUNK(abort));
3357                 }
3358                 /* We are going to ABORT, so we might as well stop
3359                  * processing the rest of the chunks in the packet.
3360                  */
3361                 sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
3362                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
3363                                 SCTP_U32(SCTP_ERROR_ASCONF_ACK));
3364                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
3365                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
3366                 return SCTP_DISPOSITION_ABORT;
3367         }
3368
3369         return SCTP_DISPOSITION_DISCARD;
3370 }
3371
3372 /*
3373  * PR-SCTP Section 3.6 Receiver Side Implementation of PR-SCTP
3374  *
3375  * When a FORWARD TSN chunk arrives, the data receiver MUST first update
3376  * its cumulative TSN point to the value carried in the FORWARD TSN
3377  * chunk, and then MUST further advance its cumulative TSN point locally
3378  * if possible.
3379  * After the above processing, the data receiver MUST stop reporting any
3380  * missing TSNs earlier than or equal to the new cumulative TSN point.
3381  *
3382  * Verification Tag:  8.5 Verification Tag [Normal verification]
3383  *
3384  * The return value is the disposition of the chunk.
3385  */
3386 sctp_disposition_t sctp_sf_eat_fwd_tsn(const struct sctp_endpoint *ep,
3387                                        const struct sctp_association *asoc,
3388                                        const sctp_subtype_t type,
3389                                        void *arg,
3390                                        sctp_cmd_seq_t *commands)
3391 {
3392         struct sctp_chunk *chunk = arg;
3393         struct sctp_fwdtsn_hdr *fwdtsn_hdr;
3394         __u16 len;
3395         __u32 tsn;
3396
3397         if (!sctp_vtag_verify(chunk, asoc)) {
3398                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
3399                                 SCTP_NULL());
3400                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3401         }
3402
3403         /* Make sure that the FORWARD_TSN chunk has valid length.  */
3404         if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_fwdtsn_chunk)))
3405                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3406                                                   commands);
3407
3408         fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;
3409         chunk->subh.fwdtsn_hdr = fwdtsn_hdr;
3410         len = ntohs(chunk->chunk_hdr->length);
3411         len -= sizeof(struct sctp_chunkhdr);
3412         skb_pull(chunk->skb, len);
3413
3414         tsn = ntohl(fwdtsn_hdr->new_cum_tsn);
3415         SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __FUNCTION__, tsn);
3416
3417         /* The TSN is too high--silently discard the chunk and count on it
3418          * getting retransmitted later.
3419          */
3420         if (sctp_tsnmap_check(&asoc->peer.tsn_map, tsn) < 0)
3421                 goto discard_noforce;
3422
3423         sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_FWDTSN, SCTP_U32(tsn));
3424         if (len > sizeof(struct sctp_fwdtsn_hdr))
3425                 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_FWDTSN,
3426                                 SCTP_CHUNK(chunk));
3427
3428         /* Count this as receiving DATA. */
3429         if (asoc->autoclose) {
3430                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
3431                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
3432         }
3433
3434         /* FIXME: For now send a SACK, but DATA processing may
3435          * send another.
3436          */
3437         sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
3438
3439         return SCTP_DISPOSITION_CONSUME;
3440
3441 discard_noforce:
3442         return SCTP_DISPOSITION_DISCARD;
3443 }
3444
3445 sctp_disposition_t sctp_sf_eat_fwd_tsn_fast(
3446         const struct sctp_endpoint *ep,
3447         const struct sctp_association *asoc,
3448         const sctp_subtype_t type,
3449         void *arg,
3450         sctp_cmd_seq_t *commands)
3451 {
3452         struct sctp_chunk *chunk = arg;
3453         struct sctp_fwdtsn_hdr *fwdtsn_hdr;
3454         __u16 len;
3455         __u32 tsn;
3456
3457         if (!sctp_vtag_verify(chunk, asoc)) {
3458                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
3459                                 SCTP_NULL());
3460                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3461         }
3462
3463         /* Make sure that the FORWARD_TSN chunk has a valid length.  */
3464         if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_fwdtsn_chunk)))
3465                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3466                                                   commands);
3467
3468         fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;
3469         chunk->subh.fwdtsn_hdr = fwdtsn_hdr;
3470         len = ntohs(chunk->chunk_hdr->length);
3471         len -= sizeof(struct sctp_chunkhdr);
3472         skb_pull(chunk->skb, len);
3473
3474         tsn = ntohl(fwdtsn_hdr->new_cum_tsn);
3475         SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __FUNCTION__, tsn);
3476
3477         /* The TSN is too high--silently discard the chunk and count on it
3478          * getting retransmitted later.
3479          */
3480         if (sctp_tsnmap_check(&asoc->peer.tsn_map, tsn) < 0)
3481                 goto gen_shutdown;
3482
3483         sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_FWDTSN, SCTP_U32(tsn));
3484         if (len > sizeof(struct sctp_fwdtsn_hdr))
3485                 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_FWDTSN,
3486                                 SCTP_CHUNK(chunk));
3487
3488         /* Go a head and force a SACK, since we are shutting down. */
3489 gen_shutdown:
3490         /* Implementor's Guide.
3491          *
3492          * While in SHUTDOWN-SENT state, the SHUTDOWN sender MUST immediately
3493          * respond to each received packet containing one or more DATA chunk(s)
3494          * with a SACK, a SHUTDOWN chunk, and restart the T2-shutdown timer
3495          */
3496         sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SHUTDOWN, SCTP_NULL());
3497         sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
3498         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
3499                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
3500
3501         return SCTP_DISPOSITION_CONSUME;
3502 }
3503
3504 /*
3505  * Process an unknown chunk.
3506  *
3507  * Section: 3.2. Also, 2.1 in the implementor's guide.
3508  *
3509  * Chunk Types are encoded such that the highest-order two bits specify
3510  * the action that must be taken if the processing endpoint does not
3511  * recognize the Chunk Type.
3512  *
3513  * 00 - Stop processing this SCTP packet and discard it, do not process
3514  *      any further chunks within it.
3515  *
3516  * 01 - Stop processing this SCTP packet and discard it, do not process
3517  *      any further chunks within it, and report the unrecognized
3518  *      chunk in an 'Unrecognized Chunk Type'.
3519  *
3520  * 10 - Skip this chunk and continue processing.
3521  *
3522  * 11 - Skip this chunk and continue processing, but report in an ERROR
3523  *      Chunk using the 'Unrecognized Chunk Type' cause of error.
3524  *
3525  * The return value is the disposition of the chunk.
3526  */
3527 sctp_disposition_t sctp_sf_unk_chunk(const struct sctp_endpoint *ep,
3528                                      const struct sctp_association *asoc,
3529                                      const sctp_subtype_t type,
3530                                      void *arg,
3531                                      sctp_cmd_seq_t *commands)
3532 {
3533         struct sctp_chunk *unk_chunk = arg;
3534         struct sctp_chunk *err_chunk;
3535         sctp_chunkhdr_t *hdr;
3536
3537         SCTP_DEBUG_PRINTK("Processing the unknown chunk id %d.\n", type.chunk);
3538
3539         if (!sctp_vtag_verify(unk_chunk, asoc))
3540                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3541
3542         /* Make sure that the chunk has a valid length.
3543          * Since we don't know the chunk type, we use a general
3544          * chunkhdr structure to make a comparison.
3545          */
3546         if (!sctp_chunk_length_valid(unk_chunk, sizeof(sctp_chunkhdr_t)))
3547                 return sctp_sf_violation_chunklen(ep, asoc, type, arg,
3548                                                   commands);
3549
3550         switch (type.chunk & SCTP_CID_ACTION_MASK) {
3551         case SCTP_CID_ACTION_DISCARD:
3552                 /* Discard the packet.  */
3553                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3554                 break;
3555         case SCTP_CID_ACTION_DISCARD_ERR:
3556                 /* Discard the packet.  */
3557                 sctp_sf_pdiscard(ep, asoc, type, arg, commands);
3558
3559                 /* Generate an ERROR chunk as response. */
3560                 hdr = unk_chunk->chunk_hdr;
3561                 err_chunk = sctp_make_op_error(asoc, unk_chunk,
3562                                                SCTP_ERROR_UNKNOWN_CHUNK, hdr,
3563                                                WORD_ROUND(ntohs(hdr->length)));
3564                 if (err_chunk) {
3565                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
3566                                         SCTP_CHUNK(err_chunk));
3567                 }
3568                 return SCTP_DISPOSITION_CONSUME;
3569                 break;
3570         case SCTP_CID_ACTION_SKIP:
3571                 /* Skip the chunk.  */
3572                 return SCTP_DISPOSITION_DISCARD;
3573                 break;
3574         case SCTP_CID_ACTION_SKIP_ERR:
3575                 /* Generate an ERROR chunk as response. */
3576                 hdr = unk_chunk->chunk_hdr;
3577                 err_chunk = sctp_make_op_error(asoc, unk_chunk,
3578                                                SCTP_ERROR_UNKNOWN_CHUNK, hdr,
3579                                                WORD_ROUND(ntohs(hdr->length)));
3580                 if (err_chunk) {
3581                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
3582                                         SCTP_CHUNK(err_chunk));
3583                 }
3584                 /* Skip the chunk.  */
3585                 return SCTP_DISPOSITION_CONSUME;
3586                 break;
3587         default:
3588                 break;
3589         }
3590
3591         return SCTP_DISPOSITION_DISCARD;
3592 }
3593
3594 /*
3595  * Discard the chunk.
3596  *
3597  * Section: 0.2, 5.2.3, 5.2.5, 5.2.6, 6.0, 8.4.6, 8.5.1c, 9.2
3598  * [Too numerous to mention...]
3599  * Verification Tag: No verification needed.
3600  * Inputs
3601  * (endpoint, asoc, chunk)
3602  *
3603  * Outputs
3604  * (asoc, reply_msg, msg_up, timers, counters)
3605  *
3606  * The return value is the disposition of the chunk.
3607  */
3608 sctp_disposition_t sctp_sf_discard_chunk(const struct sctp_endpoint *ep,
3609                                          const struct sctp_association *asoc,
3610                                          const sctp_subtype_t type,
3611                                          void *arg,
3612                                          sctp_cmd_seq_t *commands)
3613 {
3614         SCTP_DEBUG_PRINTK("Chunk %d is discarded\n", type.chunk);
3615         return SCTP_DISPOSITION_DISCARD;
3616 }
3617
3618 /*
3619  * Discard the whole packet.
3620  *
3621  * Section: 8.4 2)
3622  *
3623  * 2) If the OOTB packet contains an ABORT chunk, the receiver MUST
3624  *    silently discard the OOTB packet and take no further action.
3625  *
3626  * Verification Tag: No verification necessary
3627  *
3628  * Inputs
3629  * (endpoint, asoc, chunk)
3630  *
3631  * Outputs
3632  * (asoc, reply_msg, msg_up, timers, counters)
3633  *
3634  * The return value is the disposition of the chunk.
3635  */
3636 sctp_disposition_t sctp_sf_pdiscard(const struct sctp_endpoint *ep,
3637                                     const struct sctp_association *asoc,
3638                                     const sctp_subtype_t type,
3639                                     void *arg,
3640                                     sctp_cmd_seq_t *commands)
3641 {
3642         sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
3643
3644         return SCTP_DISPOSITION_CONSUME;
3645 }
3646
3647
3648 /*
3649  * The other end is violating protocol.
3650  *
3651  * Section: Not specified
3652  * Verification Tag: Not specified
3653  * Inputs
3654  * (endpoint, asoc, chunk)
3655  *
3656  * Outputs
3657  * (asoc, reply_msg, msg_up, timers, counters)
3658  *
3659  * We simply tag the chunk as a violation.  The state machine will log
3660  * the violation and continue.
3661  */
3662 sctp_disposition_t sctp_sf_violation(const struct sctp_endpoint *ep,
3663                                      const struct sctp_association *asoc,
3664                                      const sctp_subtype_t type,
3665                                      void *arg,
3666                                      sctp_cmd_seq_t *commands)
3667 {
3668         return SCTP_DISPOSITION_VIOLATION;
3669 }
3670
3671
3672 /*
3673  * Handle a protocol violation when the chunk length is invalid.
3674  * "Invalid" length is identified as smaller then the minimal length a
3675  * given chunk can be.  For example, a SACK chunk has invalid length
3676  * if it's length is set to be smaller then the size of sctp_sack_chunk_t.
3677  *
3678  * We inform the other end by sending an ABORT with a Protocol Violation
3679  * error code.
3680  *
3681  * Section: Not specified
3682  * Verification Tag:  Nothing to do
3683  * Inputs
3684  * (endpoint, asoc, chunk)
3685  *
3686  * Outputs
3687  * (reply_msg, msg_up, counters)
3688  *
3689  * Generate an  ABORT chunk and terminate the association.
3690  */
3691 static sctp_disposition_t sctp_sf_violation_chunklen(
3692                                      const struct sctp_endpoint *ep,
3693                                      const struct sctp_association *asoc,
3694                                      const sctp_subtype_t type,
3695                                      void *arg,
3696                                      sctp_cmd_seq_t *commands)
3697 {
3698         struct sctp_chunk *chunk =  arg;
3699         struct sctp_chunk *abort = NULL;
3700         char               err_str[]="The following chunk had invalid length:";
3701
3702         /* Make the abort chunk. */
3703         abort = sctp_make_abort_violation(asoc, chunk, err_str,
3704                                           sizeof(err_str));
3705         if (!abort)
3706                 goto nomem;
3707
3708         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
3709         SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
3710
3711         if (asoc->state <= SCTP_STATE_COOKIE_ECHOED) {
3712                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
3713                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
3714                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
3715                                 SCTP_U32(SCTP_ERROR_PROTO_VIOLATION));
3716         } else {
3717                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
3718                                 SCTP_U32(SCTP_ERROR_PROTO_VIOLATION));
3719                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
3720         }
3721
3722         sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
3723
3724         SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
3725
3726         return SCTP_DISPOSITION_ABORT;
3727
3728 nomem:
3729         return SCTP_DISPOSITION_NOMEM;
3730 }
3731
3732 /***************************************************************************
3733  * These are the state functions for handling primitive (Section 10) events.
3734  ***************************************************************************/
3735 /*
3736  * sctp_sf_do_prm_asoc
3737  *
3738  * Section: 10.1 ULP-to-SCTP
3739  * B) Associate
3740  *
3741  * Format: ASSOCIATE(local SCTP instance name, destination transport addr,
3742  * outbound stream count)
3743  * -> association id [,destination transport addr list] [,outbound stream
3744  * count]
3745  *
3746  * This primitive allows the upper layer to initiate an association to a
3747  * specific peer endpoint.
3748  *
3749  * The peer endpoint shall be specified by one of the transport addresses
3750  * which defines the endpoint (see Section 1.4).  If the local SCTP
3751  * instance has not been initialized, the ASSOCIATE is considered an
3752  * error.
3753  * [This is not relevant for the kernel implementation since we do all
3754  * initialization at boot time.  It we hadn't initialized we wouldn't
3755  * get anywhere near this code.]
3756  *
3757  * An association id, which is a local handle to the SCTP association,
3758  * will be returned on successful establishment of the association. If
3759  * SCTP is not able to open an SCTP association with the peer endpoint,
3760  * an error is returned.
3761  * [In the kernel implementation, the struct sctp_association needs to
3762  * be created BEFORE causing this primitive to run.]
3763  *
3764  * Other association parameters may be returned, including the
3765  * complete destination transport addresses of the peer as well as the
3766  * outbound stream count of the local endpoint. One of the transport
3767  * address from the returned destination addresses will be selected by
3768  * the local endpoint as default primary path for sending SCTP packets
3769  * to this peer.  The returned "destination transport addr list" can
3770  * be used by the ULP to change the default primary path or to force
3771  * sending a packet to a specific transport address.  [All of this
3772  * stuff happens when the INIT ACK arrives.  This is a NON-BLOCKING
3773  * function.]
3774  *
3775  * Mandatory attributes:
3776  *
3777  * o local SCTP instance name - obtained from the INITIALIZE operation.
3778  *   [This is the argument asoc.]
3779  * o destination transport addr - specified as one of the transport
3780  * addresses of the peer endpoint with which the association is to be
3781  * established.
3782  *  [This is asoc->peer.active_path.]
3783  * o outbound stream count - the number of outbound streams the ULP
3784  * would like to open towards this peer endpoint.
3785  * [BUG: This is not currently implemented.]
3786  * Optional attributes:
3787  *
3788  * None.
3789  *
3790  * The return value is a disposition.
3791  */
3792 sctp_disposition_t sctp_sf_do_prm_asoc(const struct sctp_endpoint *ep,
3793                                        const struct sctp_association *asoc,
3794                                        const sctp_subtype_t type,
3795                                        void *arg,
3796                                        sctp_cmd_seq_t *commands)
3797 {
3798         struct sctp_chunk *repl;
3799
3800         /* The comment below says that we enter COOKIE-WAIT AFTER
3801          * sending the INIT, but that doesn't actually work in our
3802          * implementation...
3803          */
3804         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
3805                         SCTP_STATE(SCTP_STATE_COOKIE_WAIT));
3806
3807         /* RFC 2960 5.1 Normal Establishment of an Association
3808          *
3809          * A) "A" first sends an INIT chunk to "Z".  In the INIT, "A"
3810          * must provide its Verification Tag (Tag_A) in the Initiate
3811          * Tag field.  Tag_A SHOULD be a random number in the range of
3812          * 1 to 4294967295 (see 5.3.1 for Tag value selection). ...
3813          */
3814
3815         repl = sctp_make_init(asoc, &asoc->base.bind_addr, GFP_ATOMIC, 0);
3816         if (!repl)
3817                 goto nomem;
3818
3819         /* Cast away the const modifier, as we want to just
3820          * rerun it through as a sideffect.
3821          */
3822         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC,
3823                         SCTP_ASOC((struct sctp_association *) asoc));
3824
3825         /* Choose transport for INIT. */
3826         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_CHOOSE_TRANSPORT,
3827                         SCTP_CHUNK(repl));
3828
3829         /* After sending the INIT, "A" starts the T1-init timer and
3830          * enters the COOKIE-WAIT state.
3831          */
3832         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
3833                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
3834         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
3835         return SCTP_DISPOSITION_CONSUME;
3836
3837 nomem:
3838         return SCTP_DISPOSITION_NOMEM;
3839 }
3840
3841 /*
3842  * Process the SEND primitive.
3843  *
3844  * Section: 10.1 ULP-to-SCTP
3845  * E) Send
3846  *
3847  * Format: SEND(association id, buffer address, byte count [,context]
3848  *         [,stream id] [,life time] [,destination transport address]
3849  *         [,unorder flag] [,no-bundle flag] [,payload protocol-id] )
3850  * -> result
3851  *
3852  * This is the main method to send user data via SCTP.
3853  *
3854  * Mandatory attributes:
3855  *
3856  *  o association id - local handle to the SCTP association
3857  *
3858  *  o buffer address - the location where the user message to be
3859  *    transmitted is stored;
3860  *
3861  *  o byte count - The size of the user data in number of bytes;
3862  *
3863  * Optional attributes:
3864  *
3865  *  o context - an optional 32 bit integer that will be carried in the
3866  *    sending failure notification to the ULP if the transportation of
3867  *    this User Message fails.
3868  *
3869  *  o stream id - to indicate which stream to send the data on. If not
3870  *    specified, stream 0 will be used.
3871  *
3872  *  o life time - specifies the life time of the user data. The user data
3873  *    will not be sent by SCTP after the life time expires. This
3874  *    parameter can be used to avoid efforts to transmit stale
3875  *    user messages. SCTP notifies the ULP if the data cannot be
3876  *    initiated to transport (i.e. sent to the destination via SCTP's
3877  *    send primitive) within the life time variable. However, the
3878  *    user data will be transmitted if SCTP has attempted to transmit a
3879  *    chunk before the life time expired.
3880  *
3881  *  o destination transport address - specified as one of the destination
3882  *    transport addresses of the peer endpoint to which this packet
3883  *    should be sent. Whenever possible, SCTP should use this destination
3884  *    transport address for sending the packets, instead of the current
3885  *    primary path.
3886  *
3887  *  o unorder flag - this flag, if present, indicates that the user
3888  *    would like the data delivered in an unordered fashion to the peer
3889  *    (i.e., the U flag is set to 1 on all DATA chunks carrying this
3890  *    message).
3891  *
3892  *  o no-bundle flag - instructs SCTP not to bundle this user data with
3893  *    other outbound DATA chunks. SCTP MAY still bundle even when
3894  *    this flag is present, when faced with network congestion.
3895  *
3896  *  o payload protocol-id - A 32 bit unsigned integer that is to be
3897  *    passed to the peer indicating the type of payload protocol data
3898  *    being transmitted. This value is passed as opaque data by SCTP.
3899  *
3900  * The return value is the disposition.
3901  */
3902 sctp_disposition_t sctp_sf_do_prm_send(const struct sctp_endpoint *ep,
3903                                        const struct sctp_association *asoc,
3904                                        const sctp_subtype_t type,
3905                                        void *arg,
3906                                        sctp_cmd_seq_t *commands)
3907 {
3908         struct sctp_chunk *chunk = arg;
3909
3910         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));
3911         return SCTP_DISPOSITION_CONSUME;
3912 }
3913
3914 /*
3915  * Process the SHUTDOWN primitive.
3916  *
3917  * Section: 10.1:
3918  * C) Shutdown
3919  *
3920  * Format: SHUTDOWN(association id)
3921  * -> result
3922  *
3923  * Gracefully closes an association. Any locally queued user data
3924  * will be delivered to the peer. The association will be terminated only
3925  * after the peer acknowledges all the SCTP packets sent.  A success code
3926  * will be returned on successful termination of the association. If
3927  * attempting to terminate the association results in a failure, an error
3928  * code shall be returned.
3929  *
3930  * Mandatory attributes:
3931  *
3932  *  o association id - local handle to the SCTP association
3933  *
3934  * Optional attributes:
3935  *
3936  * None.
3937  *
3938  * The return value is the disposition.
3939  */
3940 sctp_disposition_t sctp_sf_do_9_2_prm_shutdown(
3941         const struct sctp_endpoint *ep,
3942         const struct sctp_association *asoc,
3943         const sctp_subtype_t type,
3944         void *arg,
3945         sctp_cmd_seq_t *commands)
3946 {
3947         int disposition;
3948
3949         /* From 9.2 Shutdown of an Association
3950          * Upon receipt of the SHUTDOWN primitive from its upper
3951          * layer, the endpoint enters SHUTDOWN-PENDING state and
3952          * remains there until all outstanding data has been
3953          * acknowledged by its peer. The endpoint accepts no new data
3954          * from its upper layer, but retransmits data to the far end
3955          * if necessary to fill gaps.
3956          */
3957         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
3958                         SCTP_STATE(SCTP_STATE_SHUTDOWN_PENDING));
3959
3960         /* sctpimpguide-05 Section 2.12.2
3961          * The sender of the SHUTDOWN MAY also start an overall guard timer
3962          * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
3963          */
3964         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
3965                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
3966
3967         disposition = SCTP_DISPOSITION_CONSUME;
3968         if (sctp_outq_is_empty(&asoc->outqueue)) {
3969                 disposition = sctp_sf_do_9_2_start_shutdown(ep, asoc, type,
3970                                                             arg, commands);
3971         }
3972         return disposition;
3973 }
3974
3975 /*
3976  * Process the ABORT primitive.
3977  *
3978  * Section: 10.1:
3979  * C) Abort
3980  *
3981  * Format: Abort(association id [, cause code])
3982  * -> result
3983  *
3984  * Ungracefully closes an association. Any locally queued user data
3985  * will be discarded and an ABORT chunk is sent to the peer.  A success code
3986  * will be returned on successful abortion of the association. If
3987  * attempting to abort the association results in a failure, an error
3988  * code shall be returned.
3989  *
3990  * Mandatory attributes:
3991  *
3992  *  o association id - local handle to the SCTP association
3993  *
3994  * Optional attributes:
3995  *
3996  *  o cause code - reason of the abort to be passed to the peer
3997  *
3998  * None.
3999  *
4000  * The return value is the disposition.
4001  */
4002 sctp_disposition_t sctp_sf_do_9_1_prm_abort(
4003         const struct sctp_endpoint *ep,
4004         const struct sctp_association *asoc,
4005         const sctp_subtype_t type,
4006         void *arg,
4007         sctp_cmd_seq_t *commands)
4008 {
4009         /* From 9.1 Abort of an Association
4010          * Upon receipt of the ABORT primitive from its upper
4011          * layer, the endpoint enters CLOSED state and
4012          * discard all outstanding data has been
4013          * acknowledged by its peer. The endpoint accepts no new data
4014          * from its upper layer, but retransmits data to the far end
4015          * if necessary to fill gaps.
4016          */
4017         struct msghdr *msg = arg;
4018         struct sctp_chunk *abort;
4019         sctp_disposition_t retval;
4020
4021         retval = SCTP_DISPOSITION_CONSUME;
4022
4023         /* Generate ABORT chunk to send the peer.  */
4024         abort = sctp_make_abort_user(asoc, NULL, msg);
4025         if (!abort)
4026                 retval = SCTP_DISPOSITION_NOMEM;
4027         else
4028                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
4029
4030         /* Even if we can't send the ABORT due to low memory delete the
4031          * TCB.  This is a departure from our typical NOMEM handling.
4032          */
4033
4034         /* Delete the established association. */
4035         sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
4036                         SCTP_U32(SCTP_ERROR_USER_ABORT));
4037
4038         SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
4039         SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
4040
4041         return retval;
4042 }
4043
4044 /* We tried an illegal operation on an association which is closed.  */
4045 sctp_disposition_t sctp_sf_error_closed(const struct sctp_endpoint *ep,
4046                                         const struct sctp_association *asoc,
4047                                         const sctp_subtype_t type,
4048                                         void *arg,
4049                                         sctp_cmd_seq_t *commands)
4050 {
4051         sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_ERROR, SCTP_ERROR(-EINVAL));
4052         return SCTP_DISPOSITION_CONSUME;
4053 }
4054
4055 /* We tried an illegal operation on an association which is shutting
4056  * down.
4057  */
4058 sctp_disposition_t sctp_sf_error_shutdown(const struct sctp_endpoint *ep,
4059                                           const struct sctp_association *asoc,
4060                                           const sctp_subtype_t type,
4061                                           void *arg,
4062                                           sctp_cmd_seq_t *commands)
4063 {
4064         sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_ERROR,
4065                         SCTP_ERROR(-ESHUTDOWN));
4066         return SCTP_DISPOSITION_CONSUME;
4067 }
4068
4069 /*
4070  * sctp_cookie_wait_prm_shutdown
4071  *
4072  * Section: 4 Note: 2
4073  * Verification Tag:
4074  * Inputs
4075  * (endpoint, asoc)
4076  *
4077  * The RFC does not explicitly address this issue, but is the route through the
4078  * state table when someone issues a shutdown while in COOKIE_WAIT state.
4079  *
4080  * Outputs
4081  * (timers)
4082  */
4083 sctp_disposition_t sctp_sf_cookie_wait_prm_shutdown(
4084         const struct sctp_endpoint *ep,
4085         const struct sctp_association *asoc,
4086         const sctp_subtype_t type,
4087         void *arg,
4088         sctp_cmd_seq_t *commands)
4089 {
4090         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4091                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
4092
4093         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
4094                         SCTP_STATE(SCTP_STATE_CLOSED));
4095
4096         SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
4097
4098         sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
4099
4100         return SCTP_DISPOSITION_DELETE_TCB;
4101 }
4102
4103 /*
4104  * sctp_cookie_echoed_prm_shutdown
4105  *
4106  * Section: 4 Note: 2
4107  * Verification Tag:
4108  * Inputs
4109  * (endpoint, asoc)
4110  *
4111  * The RFC does not explcitly address this issue, but is the route through the
4112  * state table when someone issues a shutdown while in COOKIE_ECHOED state.
4113  *
4114  * Outputs
4115  * (timers)
4116  */
4117 sctp_disposition_t sctp_sf_cookie_echoed_prm_shutdown(
4118         const struct sctp_endpoint *ep,
4119         const struct sctp_association *asoc,
4120         const sctp_subtype_t type,
4121         void *arg, sctp_cmd_seq_t *commands)
4122 {
4123         /* There is a single T1 timer, so we should be able to use
4124          * common function with the COOKIE-WAIT state.
4125          */
4126         return sctp_sf_cookie_wait_prm_shutdown(ep, asoc, type, arg, commands);
4127 }
4128
4129 /*
4130  * sctp_sf_cookie_wait_prm_abort
4131  *
4132  * Section: 4 Note: 2
4133  * Verification Tag:
4134  * Inputs
4135  * (endpoint, asoc)
4136  *
4137  * The RFC does not explicitly address this issue, but is the route through the
4138  * state table when someone issues an abort while in COOKIE_WAIT state.
4139  *
4140  * Outputs
4141  * (timers)
4142  */
4143 sctp_disposition_t sctp_sf_cookie_wait_prm_abort(
4144         const struct sctp_endpoint *ep,
4145         const struct sctp_association *asoc,
4146         const sctp_subtype_t type,
4147         void *arg,
4148         sctp_cmd_seq_t *commands)
4149 {
4150         struct msghdr *msg = arg;
4151         struct sctp_chunk *abort;
4152         sctp_disposition_t retval;
4153
4154         /* Stop T1-init timer */
4155         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4156                         SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
4157         retval = SCTP_DISPOSITION_CONSUME;
4158
4159         /* Generate ABORT chunk to send the peer */
4160         abort = sctp_make_abort_user(asoc, NULL, msg);
4161         if (!abort)
4162                 retval = SCTP_DISPOSITION_NOMEM;
4163         else
4164                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
4165
4166         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
4167                         SCTP_STATE(SCTP_STATE_CLOSED));
4168
4169         SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
4170
4171         /* Even if we can't send the ABORT due to low memory delete the
4172          * TCB.  This is a departure from our typical NOMEM handling.
4173          */
4174
4175         /* Delete the established association. */
4176         sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
4177                         SCTP_U32(SCTP_ERROR_USER_ABORT));
4178
4179         return retval;
4180 }
4181
4182 /*
4183  * sctp_sf_cookie_echoed_prm_abort
4184  *
4185  * Section: 4 Note: 3
4186  * Verification Tag:
4187  * Inputs
4188  * (endpoint, asoc)
4189  *
4190  * The RFC does not explcitly address this issue, but is the route through the
4191  * state table when someone issues an abort while in COOKIE_ECHOED state.
4192  *
4193  * Outputs
4194  * (timers)
4195  */
4196 sctp_disposition_t sctp_sf_cookie_echoed_prm_abort(
4197         const struct sctp_endpoint *ep,
4198         const struct sctp_association *asoc,
4199         const sctp_subtype_t type,
4200         void *arg,
4201         sctp_cmd_seq_t *commands)
4202 {
4203         /* There is a single T1 timer, so we should be able to use
4204          * common function with the COOKIE-WAIT state.
4205          */
4206         return sctp_sf_cookie_wait_prm_abort(ep, asoc, type, arg, commands);
4207 }
4208
4209 /*
4210  * sctp_sf_shutdown_pending_prm_abort
4211  *
4212  * Inputs
4213  * (endpoint, asoc)
4214  *
4215  * The RFC does not explicitly address this issue, but is the route through the
4216  * state table when someone issues an abort while in SHUTDOWN-PENDING state.
4217  *
4218  * Outputs
4219  * (timers)
4220  */
4221 sctp_disposition_t sctp_sf_shutdown_pending_prm_abort(
4222         const struct sctp_endpoint *ep,
4223         const struct sctp_association *asoc,
4224         const sctp_subtype_t type,
4225         void *arg,
4226         sctp_cmd_seq_t *commands)
4227 {
4228         /* Stop the T5-shutdown guard timer.  */
4229         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4230                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
4231
4232         return sctp_sf_do_9_1_prm_abort(ep, asoc, type, arg, commands);
4233 }
4234
4235 /*
4236  * sctp_sf_shutdown_sent_prm_abort
4237  *
4238  * Inputs
4239  * (endpoint, asoc)
4240  *
4241  * The RFC does not explicitly address this issue, but is the route through the
4242  * state table when someone issues an abort while in SHUTDOWN-SENT state.
4243  *
4244  * Outputs
4245  * (timers)
4246  */
4247 sctp_disposition_t sctp_sf_shutdown_sent_prm_abort(
4248         const struct sctp_endpoint *ep,
4249         const struct sctp_association *asoc,
4250         const sctp_subtype_t type,
4251         void *arg,
4252         sctp_cmd_seq_t *commands)
4253 {
4254         /* Stop the T2-shutdown timer.  */
4255         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4256                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
4257
4258         /* Stop the T5-shutdown guard timer.  */
4259         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4260                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
4261
4262         return sctp_sf_do_9_1_prm_abort(ep, asoc, type, arg, commands);
4263 }
4264
4265 /*
4266  * sctp_sf_cookie_echoed_prm_abort
4267  *
4268  * Inputs
4269  * (endpoint, asoc)
4270  *
4271  * The RFC does not explcitly address this issue, but is the route through the
4272  * state table when someone issues an abort while in COOKIE_ECHOED state.
4273  *
4274  * Outputs
4275  * (timers)
4276  */
4277 sctp_disposition_t sctp_sf_shutdown_ack_sent_prm_abort(
4278         const struct sctp_endpoint *ep,
4279         const struct sctp_association *asoc,
4280         const sctp_subtype_t type,
4281         void *arg,
4282         sctp_cmd_seq_t *commands)
4283 {
4284         /* The same T2 timer, so we should be able to use
4285          * common function with the SHUTDOWN-SENT state.
4286          */
4287         return sctp_sf_shutdown_sent_prm_abort(ep, asoc, type, arg, commands);
4288 }
4289
4290 /*
4291  * Process the REQUESTHEARTBEAT primitive
4292  *
4293  * 10.1 ULP-to-SCTP
4294  * J) Request Heartbeat
4295  *
4296  * Format: REQUESTHEARTBEAT(association id, destination transport address)
4297  *
4298  * -> result
4299  *
4300  * Instructs the local endpoint to perform a HeartBeat on the specified
4301  * destination transport address of the given association. The returned
4302  * result should indicate whether the transmission of the HEARTBEAT
4303  * chunk to the destination address is successful.
4304  *
4305  * Mandatory attributes:
4306  *
4307  * o association id - local handle to the SCTP association
4308  *
4309  * o destination transport address - the transport address of the
4310  *   association on which a heartbeat should be issued.
4311  */
4312 sctp_disposition_t sctp_sf_do_prm_requestheartbeat(
4313                                         const struct sctp_endpoint *ep,
4314                                         const struct sctp_association *asoc,
4315                                         const sctp_subtype_t type,
4316                                         void *arg,
4317                                         sctp_cmd_seq_t *commands)
4318 {
4319         return sctp_sf_heartbeat(ep, asoc, type, (struct sctp_transport *)arg,
4320                                  commands);
4321 }
4322
4323 /*
4324  * ADDIP Section 4.1 ASCONF Chunk Procedures
4325  * When an endpoint has an ASCONF signaled change to be sent to the
4326  * remote endpoint it should do A1 to A9
4327  */
4328 sctp_disposition_t sctp_sf_do_prm_asconf(const struct sctp_endpoint *ep,
4329                                         const struct sctp_association *asoc,
4330                                         const sctp_subtype_t type,
4331                                         void *arg,
4332                                         sctp_cmd_seq_t *commands)
4333 {
4334         struct sctp_chunk *chunk = arg;
4335
4336         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));
4337         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
4338                         SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
4339         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));
4340         return SCTP_DISPOSITION_CONSUME;
4341 }
4342
4343 /*
4344  * Ignore the primitive event
4345  *
4346  * The return value is the disposition of the primitive.
4347  */
4348 sctp_disposition_t sctp_sf_ignore_primitive(
4349         const struct sctp_endpoint *ep,
4350         const struct sctp_association *asoc,
4351         const sctp_subtype_t type,
4352         void *arg,
4353         sctp_cmd_seq_t *commands)
4354 {
4355         SCTP_DEBUG_PRINTK("Primitive type %d is ignored.\n", type.primitive);
4356         return SCTP_DISPOSITION_DISCARD;
4357 }
4358
4359 /***************************************************************************
4360  * These are the state functions for the OTHER events.
4361  ***************************************************************************/
4362
4363 /*
4364  * Start the shutdown negotiation.
4365  *
4366  * From Section 9.2:
4367  * Once all its outstanding data has been acknowledged, the endpoint
4368  * shall send a SHUTDOWN chunk to its peer including in the Cumulative
4369  * TSN Ack field the last sequential TSN it has received from the peer.
4370  * It shall then start the T2-shutdown timer and enter the SHUTDOWN-SENT
4371  * state. If the timer expires, the endpoint must re-send the SHUTDOWN
4372  * with the updated last sequential TSN received from its peer.
4373  *
4374  * The return value is the disposition.
4375  */
4376 sctp_disposition_t sctp_sf_do_9_2_start_shutdown(
4377         const struct sctp_endpoint *ep,
4378         const struct sctp_association *asoc,
4379         const sctp_subtype_t type,
4380         void *arg,
4381         sctp_cmd_seq_t *commands)
4382 {
4383         struct sctp_chunk *reply;
4384
4385         /* Once all its outstanding data has been acknowledged, the
4386          * endpoint shall send a SHUTDOWN chunk to its peer including
4387          * in the Cumulative TSN Ack field the last sequential TSN it
4388          * has received from the peer.
4389          */
4390         reply = sctp_make_shutdown(asoc, NULL);
4391         if (!reply)
4392                 goto nomem;
4393
4394         /* Set the transport for the SHUTDOWN chunk and the timeout for the
4395          * T2-shutdown timer.
4396          */
4397         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
4398
4399         /* It shall then start the T2-shutdown timer */
4400         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
4401                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
4402
4403         if (asoc->autoclose)
4404                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4405                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
4406
4407         /* and enter the SHUTDOWN-SENT state.  */
4408         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
4409                         SCTP_STATE(SCTP_STATE_SHUTDOWN_SENT));
4410
4411         /* sctp-implguide 2.10 Issues with Heartbeating and failover
4412          *
4413          * HEARTBEAT ... is discontinued after sending either SHUTDOWN
4414          * or SHUTDOWN-ACK.
4415          */
4416         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
4417
4418         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
4419
4420         return SCTP_DISPOSITION_CONSUME;
4421
4422 nomem:
4423         return SCTP_DISPOSITION_NOMEM;
4424 }
4425
4426 /*
4427  * Generate a SHUTDOWN ACK now that everything is SACK'd.
4428  *
4429  * From Section 9.2:
4430  *
4431  * If it has no more outstanding DATA chunks, the SHUTDOWN receiver
4432  * shall send a SHUTDOWN ACK and start a T2-shutdown timer of its own,
4433  * entering the SHUTDOWN-ACK-SENT state. If the timer expires, the
4434  * endpoint must re-send the SHUTDOWN ACK.
4435  *
4436  * The return value is the disposition.
4437  */
4438 sctp_disposition_t sctp_sf_do_9_2_shutdown_ack(
4439         const struct sctp_endpoint *ep,
4440         const struct sctp_association *asoc,
4441         const sctp_subtype_t type,
4442         void *arg,
4443         sctp_cmd_seq_t *commands)
4444 {
4445         struct sctp_chunk *chunk = (struct sctp_chunk *) arg;
4446         struct sctp_chunk *reply;
4447
4448         /* There are 2 ways of getting here:
4449          *    1) called in response to a SHUTDOWN chunk
4450          *    2) called when SCTP_EVENT_NO_PENDING_TSN event is issued.
4451          *
4452          * For the case (2), the arg parameter is set to NULL.  We need
4453          * to check that we have a chunk before accessing it's fields.
4454          */
4455         if (chunk) {
4456                 if (!sctp_vtag_verify(chunk, asoc))
4457                         return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
4458
4459                 /* Make sure that the SHUTDOWN chunk has a valid length. */
4460                 if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_shutdown_chunk_t)))
4461                         return sctp_sf_violation_chunklen(ep, asoc, type, arg,
4462                                                           commands);
4463         }
4464
4465         /* If it has no more outstanding DATA chunks, the SHUTDOWN receiver
4466          * shall send a SHUTDOWN ACK ...
4467          */
4468         reply = sctp_make_shutdown_ack(asoc, chunk);
4469         if (!reply)
4470                 goto nomem;
4471
4472         /* Set the transport for the SHUTDOWN ACK chunk and the timeout for
4473          * the T2-shutdown timer.
4474          */
4475         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
4476
4477         /* and start/restart a T2-shutdown timer of its own, */
4478         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
4479                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
4480
4481         if (asoc->autoclose)
4482                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4483                                 SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
4484
4485         /* Enter the SHUTDOWN-ACK-SENT state.  */
4486         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
4487                         SCTP_STATE(SCTP_STATE_SHUTDOWN_ACK_SENT));
4488
4489         /* sctp-implguide 2.10 Issues with Heartbeating and failover
4490          *
4491          * HEARTBEAT ... is discontinued after sending either SHUTDOWN
4492          * or SHUTDOWN-ACK.
4493          */
4494         sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
4495
4496         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
4497
4498         return SCTP_DISPOSITION_CONSUME;
4499
4500 nomem:
4501         return SCTP_DISPOSITION_NOMEM;
4502 }
4503
4504 /*
4505  * Ignore the event defined as other
4506  *
4507  * The return value is the disposition of the event.
4508  */
4509 sctp_disposition_t sctp_sf_ignore_other(const struct sctp_endpoint *ep,
4510                                         const struct sctp_association *asoc,
4511                                         const sctp_subtype_t type,
4512                                         void *arg,
4513                                         sctp_cmd_seq_t *commands)
4514 {
4515         SCTP_DEBUG_PRINTK("The event other type %d is ignored\n", type.other);
4516         return SCTP_DISPOSITION_DISCARD;
4517 }
4518
4519 /************************************************************
4520  * These are the state functions for handling timeout events.
4521  ************************************************************/
4522
4523 /*
4524  * RTX Timeout
4525  *
4526  * Section: 6.3.3 Handle T3-rtx Expiration
4527  *
4528  * Whenever the retransmission timer T3-rtx expires for a destination
4529  * address, do the following:
4530  * [See below]
4531  *
4532  * The return value is the disposition of the chunk.
4533  */
4534 sctp_disposition_t sctp_sf_do_6_3_3_rtx(const struct sctp_endpoint *ep,
4535                                         const struct sctp_association *asoc,
4536                                         const sctp_subtype_t type,
4537                                         void *arg,
4538                                         sctp_cmd_seq_t *commands)
4539 {
4540         struct sctp_transport *transport = arg;
4541
4542         if (asoc->overall_error_count >= asoc->max_retrans) {
4543                 /* CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
4544                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
4545                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
4546                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
4547                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
4548                 return SCTP_DISPOSITION_DELETE_TCB;
4549         }
4550
4551         /* E1) For the destination address for which the timer
4552          * expires, adjust its ssthresh with rules defined in Section
4553          * 7.2.3 and set the cwnd <- MTU.
4554          */
4555
4556         /* E2) For the destination address for which the timer
4557          * expires, set RTO <- RTO * 2 ("back off the timer").  The
4558          * maximum value discussed in rule C7 above (RTO.max) may be
4559          * used to provide an upper bound to this doubling operation.
4560          */
4561
4562         /* E3) Determine how many of the earliest (i.e., lowest TSN)
4563          * outstanding DATA chunks for the address for which the
4564          * T3-rtx has expired will fit into a single packet, subject
4565          * to the MTU constraint for the path corresponding to the
4566          * destination transport address to which the retransmission
4567          * is being sent (this may be different from the address for
4568          * which the timer expires [see Section 6.4]).  Call this
4569          * value K. Bundle and retransmit those K DATA chunks in a
4570          * single packet to the destination endpoint.
4571          *
4572          * Note: Any DATA chunks that were sent to the address for
4573          * which the T3-rtx timer expired but did not fit in one MTU
4574          * (rule E3 above), should be marked for retransmission and
4575          * sent as soon as cwnd allows (normally when a SACK arrives).
4576          */
4577
4578         /* NB: Rules E4 and F1 are implicit in R1.  */
4579         sctp_add_cmd_sf(commands, SCTP_CMD_RETRAN, SCTP_TRANSPORT(transport));
4580
4581         /* Do some failure management (Section 8.2). */
4582         sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE, SCTP_TRANSPORT(transport));
4583
4584         return SCTP_DISPOSITION_CONSUME;
4585 }
4586
4587 /*
4588  * Generate delayed SACK on timeout
4589  *
4590  * Section: 6.2  Acknowledgement on Reception of DATA Chunks
4591  *
4592  * The guidelines on delayed acknowledgement algorithm specified in
4593  * Section 4.2 of [RFC2581] SHOULD be followed.  Specifically, an
4594  * acknowledgement SHOULD be generated for at least every second packet
4595  * (not every second DATA chunk) received, and SHOULD be generated
4596  * within 200 ms of the arrival of any unacknowledged DATA chunk.  In
4597  * some situations it may be beneficial for an SCTP transmitter to be
4598  * more conservative than the algorithms detailed in this document
4599  * allow. However, an SCTP transmitter MUST NOT be more aggressive than
4600  * the following algorithms allow.
4601  */
4602 sctp_disposition_t sctp_sf_do_6_2_sack(const struct sctp_endpoint *ep,
4603                                        const struct sctp_association *asoc,
4604                                        const sctp_subtype_t type,
4605                                        void *arg,
4606                                        sctp_cmd_seq_t *commands)
4607 {
4608         sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
4609         return SCTP_DISPOSITION_CONSUME;
4610 }
4611
4612 /*
4613  * sctp_sf_t1_init_timer_expire
4614  *
4615  * Section: 4 Note: 2
4616  * Verification Tag:
4617  * Inputs
4618  * (endpoint, asoc)
4619  *
4620  *  RFC 2960 Section 4 Notes
4621  *  2) If the T1-init timer expires, the endpoint MUST retransmit INIT
4622  *     and re-start the T1-init timer without changing state.  This MUST
4623  *     be repeated up to 'Max.Init.Retransmits' times.  After that, the
4624  *     endpoint MUST abort the initialization process and report the
4625  *     error to SCTP user.
4626  *
4627  * Outputs
4628  * (timers, events)
4629  *
4630  */
4631 sctp_disposition_t sctp_sf_t1_init_timer_expire(const struct sctp_endpoint *ep,
4632                                            const struct sctp_association *asoc,
4633                                            const sctp_subtype_t type,
4634                                            void *arg,
4635                                            sctp_cmd_seq_t *commands)
4636 {
4637         struct sctp_chunk *repl = NULL;
4638         struct sctp_bind_addr *bp;
4639         int attempts = asoc->init_err_counter + 1;
4640
4641         SCTP_DEBUG_PRINTK("Timer T1 expired (INIT).\n");
4642
4643         if (attempts <= asoc->max_init_attempts) {
4644                 bp = (struct sctp_bind_addr *) &asoc->base.bind_addr;
4645                 repl = sctp_make_init(asoc, bp, GFP_ATOMIC, 0);
4646                 if (!repl)
4647                         return SCTP_DISPOSITION_NOMEM;
4648
4649                 /* Choose transport for INIT. */
4650                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_CHOOSE_TRANSPORT,
4651                                 SCTP_CHUNK(repl));
4652
4653                 /* Issue a sideeffect to do the needed accounting. */
4654                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_RESTART,
4655                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
4656
4657                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
4658         } else {
4659                 SCTP_DEBUG_PRINTK("Giving up on INIT, attempts: %d"
4660                                   " max_init_attempts: %d\n",
4661                                   attempts, asoc->max_init_attempts);
4662                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
4663                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
4664                 return SCTP_DISPOSITION_DELETE_TCB;
4665         }
4666
4667         return SCTP_DISPOSITION_CONSUME;
4668 }
4669
4670 /*
4671  * sctp_sf_t1_cookie_timer_expire
4672  *
4673  * Section: 4 Note: 2
4674  * Verification Tag:
4675  * Inputs
4676  * (endpoint, asoc)
4677  *
4678  *  RFC 2960 Section 4 Notes
4679  *  3) If the T1-cookie timer expires, the endpoint MUST retransmit
4680  *     COOKIE ECHO and re-start the T1-cookie timer without changing
4681  *     state.  This MUST be repeated up to 'Max.Init.Retransmits' times.
4682  *     After that, the endpoint MUST abort the initialization process and
4683  *     report the error to SCTP user.
4684  *
4685  * Outputs
4686  * (timers, events)
4687  *
4688  */
4689 sctp_disposition_t sctp_sf_t1_cookie_timer_expire(const struct sctp_endpoint *ep,
4690                                            const struct sctp_association *asoc,
4691                                            const sctp_subtype_t type,
4692                                            void *arg,
4693                                            sctp_cmd_seq_t *commands)
4694 {
4695         struct sctp_chunk *repl = NULL;
4696         int attempts = asoc->init_err_counter + 1;
4697
4698         SCTP_DEBUG_PRINTK("Timer T1 expired (COOKIE-ECHO).\n");
4699
4700         if (attempts <= asoc->max_init_attempts) {
4701                 repl = sctp_make_cookie_echo(asoc, NULL);
4702                 if (!repl)
4703                         return SCTP_DISPOSITION_NOMEM;
4704
4705                 /* Issue a sideeffect to do the needed accounting. */
4706                 sctp_add_cmd_sf(commands, SCTP_CMD_COOKIEECHO_RESTART,
4707                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
4708
4709                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
4710         } else {
4711                 sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
4712                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
4713                 return SCTP_DISPOSITION_DELETE_TCB;
4714         }
4715
4716         return SCTP_DISPOSITION_CONSUME;
4717 }
4718
4719 /* RFC2960 9.2 If the timer expires, the endpoint must re-send the SHUTDOWN
4720  * with the updated last sequential TSN received from its peer.
4721  *
4722  * An endpoint should limit the number of retransmissions of the
4723  * SHUTDOWN chunk to the protocol parameter 'Association.Max.Retrans'.
4724  * If this threshold is exceeded the endpoint should destroy the TCB and
4725  * MUST report the peer endpoint unreachable to the upper layer (and
4726  * thus the association enters the CLOSED state).  The reception of any
4727  * packet from its peer (i.e. as the peer sends all of its queued DATA
4728  * chunks) should clear the endpoint's retransmission count and restart
4729  * the T2-Shutdown timer,  giving its peer ample opportunity to transmit
4730  * all of its queued DATA chunks that have not yet been sent.
4731  */
4732 sctp_disposition_t sctp_sf_t2_timer_expire(const struct sctp_endpoint *ep,
4733                                            const struct sctp_association *asoc,
4734                                            const sctp_subtype_t type,
4735                                            void *arg,
4736                                            sctp_cmd_seq_t *commands)
4737 {
4738         struct sctp_chunk *reply = NULL;
4739
4740         SCTP_DEBUG_PRINTK("Timer T2 expired.\n");
4741         if (asoc->overall_error_count >= asoc->max_retrans) {
4742                 /* Note:  CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
4743                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
4744                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
4745                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
4746                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
4747                 return SCTP_DISPOSITION_DELETE_TCB;
4748         }
4749
4750         switch (asoc->state) {
4751         case SCTP_STATE_SHUTDOWN_SENT:
4752                 reply = sctp_make_shutdown(asoc, NULL);
4753                 break;
4754
4755         case SCTP_STATE_SHUTDOWN_ACK_SENT:
4756                 reply = sctp_make_shutdown_ack(asoc, NULL);
4757                 break;
4758
4759         default:
4760                 BUG();
4761                 break;
4762         };
4763
4764         if (!reply)
4765                 goto nomem;
4766
4767         /* Do some failure management (Section 8.2). */
4768         sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE,
4769                         SCTP_TRANSPORT(asoc->shutdown_last_sent_to));
4770
4771         /* Set the transport for the SHUTDOWN/ACK chunk and the timeout for
4772          * the T2-shutdown timer.
4773          */
4774         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
4775
4776         /* Restart the T2-shutdown timer.  */
4777         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
4778                         SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
4779         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
4780         return SCTP_DISPOSITION_CONSUME;
4781
4782 nomem:
4783         return SCTP_DISPOSITION_NOMEM;
4784 }
4785
4786 /*
4787  * ADDIP Section 4.1 ASCONF CHunk Procedures
4788  * If the T4 RTO timer expires the endpoint should do B1 to B5
4789  */
4790 sctp_disposition_t sctp_sf_t4_timer_expire(
4791         const struct sctp_endpoint *ep,
4792         const struct sctp_association *asoc,
4793         const sctp_subtype_t type,
4794         void *arg,
4795         sctp_cmd_seq_t *commands)
4796 {
4797         struct sctp_chunk *chunk = asoc->addip_last_asconf;
4798         struct sctp_transport *transport = chunk->transport;
4799
4800         /* ADDIP 4.1 B1) Increment the error counters and perform path failure
4801          * detection on the appropriate destination address as defined in
4802          * RFC2960 [5] section 8.1 and 8.2.
4803          */
4804         sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE, SCTP_TRANSPORT(transport));
4805
4806         /* Reconfig T4 timer and transport. */
4807         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));
4808
4809         /* ADDIP 4.1 B2) Increment the association error counters and perform
4810          * endpoint failure detection on the association as defined in
4811          * RFC2960 [5] section 8.1 and 8.2.
4812          * association error counter is incremented in SCTP_CMD_STRIKE.
4813          */
4814         if (asoc->overall_error_count >= asoc->max_retrans) {
4815                 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
4816                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
4817                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
4818                                 SCTP_U32(SCTP_ERROR_NO_ERROR));
4819                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
4820                 SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
4821                 return SCTP_DISPOSITION_ABORT;
4822         }
4823
4824         /* ADDIP 4.1 B3) Back-off the destination address RTO value to which
4825          * the ASCONF chunk was sent by doubling the RTO timer value.
4826          * This is done in SCTP_CMD_STRIKE.
4827          */
4828
4829         /* ADDIP 4.1 B4) Re-transmit the ASCONF Chunk last sent and if possible
4830          * choose an alternate destination address (please refer to RFC2960
4831          * [5] section 6.4.1). An endpoint MUST NOT add new parameters to this
4832          * chunk, it MUST be the same (including its serial number) as the last
4833          * ASCONF sent.
4834          */
4835         sctp_chunk_hold(asoc->addip_last_asconf);
4836         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
4837                         SCTP_CHUNK(asoc->addip_last_asconf));
4838
4839         /* ADDIP 4.1 B5) Restart the T-4 RTO timer. Note that if a different
4840          * destination is selected, then the RTO used will be that of the new
4841          * destination address.
4842          */
4843         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
4844                         SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
4845
4846         return SCTP_DISPOSITION_CONSUME;
4847 }
4848
4849 /* sctpimpguide-05 Section 2.12.2
4850  * The sender of the SHUTDOWN MAY also start an overall guard timer
4851  * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
4852  * At the expiration of this timer the sender SHOULD abort the association
4853  * by sending an ABORT chunk.
4854  */
4855 sctp_disposition_t sctp_sf_t5_timer_expire(const struct sctp_endpoint *ep,
4856                                            const struct sctp_association *asoc,
4857                                            const sctp_subtype_t type,
4858                                            void *arg,
4859                                            sctp_cmd_seq_t *commands)
4860 {
4861         struct sctp_chunk *reply = NULL;
4862
4863         SCTP_DEBUG_PRINTK("Timer T5 expired.\n");
4864
4865         reply = sctp_make_abort(asoc, NULL, 0);
4866         if (!reply)
4867                 goto nomem;
4868
4869         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
4870         sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
4871                         SCTP_U32(SCTP_ERROR_NO_ERROR));
4872
4873         return SCTP_DISPOSITION_DELETE_TCB;
4874 nomem:
4875         return SCTP_DISPOSITION_NOMEM;
4876 }
4877
4878 /* Handle expiration of AUTOCLOSE timer.  When the autoclose timer expires,
4879  * the association is automatically closed by starting the shutdown process.
4880  * The work that needs to be done is same as when SHUTDOWN is initiated by
4881  * the user.  So this routine looks same as sctp_sf_do_9_2_prm_shutdown().
4882  */
4883 sctp_disposition_t sctp_sf_autoclose_timer_expire(
4884         const struct sctp_endpoint *ep,
4885         const struct sctp_association *asoc,
4886         const sctp_subtype_t type,
4887         void *arg,
4888         sctp_cmd_seq_t *commands)
4889 {
4890         int disposition;
4891
4892         /* From 9.2 Shutdown of an Association
4893          * Upon receipt of the SHUTDOWN primitive from its upper
4894          * layer, the endpoint enters SHUTDOWN-PENDING state and
4895          * remains there until all outstanding data has been
4896          * acknowledged by its peer. The endpoint accepts no new data
4897          * from its upper layer, but retransmits data to the far end
4898          * if necessary to fill gaps.
4899          */
4900         sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
4901                         SCTP_STATE(SCTP_STATE_SHUTDOWN_PENDING));
4902
4903         /* sctpimpguide-05 Section 2.12.2
4904          * The sender of the SHUTDOWN MAY also start an overall guard timer
4905          * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
4906          */
4907         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
4908                         SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
4909         disposition = SCTP_DISPOSITION_CONSUME;
4910         if (sctp_outq_is_empty(&asoc->outqueue)) {
4911                 disposition = sctp_sf_do_9_2_start_shutdown(ep, asoc, type,
4912                                                             arg, commands);
4913         }
4914         return disposition;
4915 }
4916
4917 /*****************************************************************************
4918  * These are sa state functions which could apply to all types of events.
4919  ****************************************************************************/
4920
4921 /*
4922  * This table entry is not implemented.
4923  *
4924  * Inputs
4925  * (endpoint, asoc, chunk)
4926  *
4927  * The return value is the disposition of the chunk.
4928  */
4929 sctp_disposition_t sctp_sf_not_impl(const struct sctp_endpoint *ep,
4930                                     const struct sctp_association *asoc,
4931                                     const sctp_subtype_t type,
4932                                     void *arg,
4933                                     sctp_cmd_seq_t *commands)
4934 {
4935         return SCTP_DISPOSITION_NOT_IMPL;
4936 }
4937
4938 /*
4939  * This table entry represents a bug.
4940  *
4941  * Inputs
4942  * (endpoint, asoc, chunk)
4943  *
4944  * The return value is the disposition of the chunk.
4945  */
4946 sctp_disposition_t sctp_sf_bug(const struct sctp_endpoint *ep,
4947                                const struct sctp_association *asoc,
4948                                const sctp_subtype_t type,
4949                                void *arg,
4950                                sctp_cmd_seq_t *commands)
4951 {
4952         return SCTP_DISPOSITION_BUG;
4953 }
4954
4955 /*
4956  * This table entry represents the firing of a timer in the wrong state.
4957  * Since timer deletion cannot be guaranteed a timer 'may' end up firing
4958  * when the association is in the wrong state.   This event should
4959  * be ignored, so as to prevent any rearming of the timer.
4960  *
4961  * Inputs
4962  * (endpoint, asoc, chunk)
4963  *
4964  * The return value is the disposition of the chunk.
4965  */
4966 sctp_disposition_t sctp_sf_timer_ignore(const struct sctp_endpoint *ep,
4967                                         const struct sctp_association *asoc,
4968                                         const sctp_subtype_t type,
4969                                         void *arg,
4970                                         sctp_cmd_seq_t *commands)
4971 {
4972         SCTP_DEBUG_PRINTK("Timer %d ignored.\n", type.chunk);
4973         return SCTP_DISPOSITION_CONSUME;
4974 }
4975
4976 /********************************************************************
4977  * 2nd Level Abstractions
4978  ********************************************************************/
4979
4980 /* Pull the SACK chunk based on the SACK header. */
4981 static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk)
4982 {
4983         struct sctp_sackhdr *sack;
4984         unsigned int len;
4985         __u16 num_blocks;
4986         __u16 num_dup_tsns;
4987
4988         /* Protect ourselves from reading too far into
4989          * the skb from a bogus sender.
4990          */
4991         sack = (struct sctp_sackhdr *) chunk->skb->data;
4992
4993         num_blocks = ntohs(sack->num_gap_ack_blocks);
4994         num_dup_tsns = ntohs(sack->num_dup_tsns);
4995         len = sizeof(struct sctp_sackhdr);
4996         len += (num_blocks + num_dup_tsns) * sizeof(__u32);
4997         if (len > chunk->skb->len)
4998                 return NULL;
4999
5000         skb_pull(chunk->skb, len);
5001
5002         return sack;
5003 }
5004
5005 /* Create an ABORT packet to be sent as a response, with the specified
5006  * error causes.
5007  */
5008 static struct sctp_packet *sctp_abort_pkt_new(const struct sctp_endpoint *ep,
5009                                   const struct sctp_association *asoc,
5010                                   struct sctp_chunk *chunk,
5011                                   const void *payload,
5012                                   size_t paylen)
5013 {
5014         struct sctp_packet *packet;
5015         struct sctp_chunk *abort;
5016
5017         packet = sctp_ootb_pkt_new(asoc, chunk);
5018
5019         if (packet) {
5020                 /* Make an ABORT.
5021                  * The T bit will be set if the asoc is NULL.
5022                  */
5023                 abort = sctp_make_abort(asoc, chunk, paylen);
5024                 if (!abort) {
5025                         sctp_ootb_pkt_free(packet);
5026                         return NULL;
5027                 }
5028
5029                 /* Reflect vtag if T-Bit is set */
5030                 if (sctp_test_T_bit(abort))
5031                         packet->vtag = ntohl(chunk->sctp_hdr->vtag);
5032
5033                 /* Add specified error causes, i.e., payload, to the
5034                  * end of the chunk.
5035                  */
5036                 sctp_addto_chunk(abort, paylen, payload);
5037
5038                 /* Set the skb to the belonging sock for accounting.  */
5039                 abort->skb->sk = ep->base.sk;
5040
5041                 sctp_packet_append_chunk(packet, abort);
5042
5043         }
5044
5045         return packet;
5046 }
5047
5048 /* Allocate a packet for responding in the OOTB conditions.  */
5049 static struct sctp_packet *sctp_ootb_pkt_new(const struct sctp_association *asoc,
5050                                              const struct sctp_chunk *chunk)
5051 {
5052         struct sctp_packet *packet;
5053         struct sctp_transport *transport;
5054         __u16 sport;
5055         __u16 dport;
5056         __u32 vtag;
5057
5058         /* Get the source and destination port from the inbound packet.  */
5059         sport = ntohs(chunk->sctp_hdr->dest);
5060         dport = ntohs(chunk->sctp_hdr->source);
5061
5062         /* The V-tag is going to be the same as the inbound packet if no
5063          * association exists, otherwise, use the peer's vtag.
5064          */
5065         if (asoc) {
5066                 vtag = asoc->peer.i.init_tag;
5067         } else {
5068                 /* Special case the INIT and stale COOKIE_ECHO as there is no
5069                  * vtag yet.
5070                  */
5071                 switch(chunk->chunk_hdr->type) {
5072                 case SCTP_CID_INIT:
5073                 {
5074                         sctp_init_chunk_t *init;
5075
5076                         init = (sctp_init_chunk_t *)chunk->chunk_hdr;
5077                         vtag = ntohl(init->init_hdr.init_tag);
5078                         break;
5079                 }
5080                 default:
5081                         vtag = ntohl(chunk->sctp_hdr->vtag);
5082                         break;
5083                 }
5084         }
5085
5086         /* Make a transport for the bucket, Eliza... */
5087         transport = sctp_transport_new(sctp_source(chunk), GFP_ATOMIC);
5088         if (!transport)
5089                 goto nomem;
5090
5091         /* Cache a route for the transport with the chunk's destination as
5092          * the source address.
5093          */
5094         sctp_transport_route(transport, (union sctp_addr *)&chunk->dest,
5095                              sctp_sk(sctp_get_ctl_sock()));
5096
5097         packet = sctp_packet_init(&transport->packet, transport, sport, dport);
5098         packet = sctp_packet_config(packet, vtag, 0);
5099
5100         return packet;
5101
5102 nomem:
5103         return NULL;
5104 }
5105
5106 /* Free the packet allocated earlier for responding in the OOTB condition.  */
5107 void sctp_ootb_pkt_free(struct sctp_packet *packet)
5108 {
5109         sctp_transport_free(packet->transport);
5110 }
5111
5112 /* Send a stale cookie error when a invalid COOKIE ECHO chunk is found  */
5113 static void sctp_send_stale_cookie_err(const struct sctp_endpoint *ep,
5114                                        const struct sctp_association *asoc,
5115                                        const struct sctp_chunk *chunk,
5116                                        sctp_cmd_seq_t *commands,
5117                                        struct sctp_chunk *err_chunk)
5118 {
5119         struct sctp_packet *packet;
5120
5121         if (err_chunk) {
5122                 packet = sctp_ootb_pkt_new(asoc, chunk);
5123                 if (packet) {
5124                         struct sctp_signed_cookie *cookie;
5125
5126                         /* Override the OOTB vtag from the cookie. */
5127                         cookie = chunk->subh.cookie_hdr;
5128                         packet->vtag = cookie->c.peer_vtag;
5129
5130                         /* Set the skb to the belonging sock for accounting. */
5131                         err_chunk->skb->sk = ep->base.sk;
5132                         sctp_packet_append_chunk(packet, err_chunk);
5133                         sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
5134                                         SCTP_PACKET(packet));
5135                         SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
5136                 } else
5137                         sctp_chunk_free (err_chunk);
5138         }
5139 }
5140
5141
5142 /* Process a data chunk */
5143 static int sctp_eat_data(const struct sctp_association *asoc,
5144                          struct sctp_chunk *chunk,
5145                          sctp_cmd_seq_t *commands)
5146 {
5147         sctp_datahdr_t *data_hdr;
5148         struct sctp_chunk *err;
5149         size_t datalen;
5150         sctp_verb_t deliver;
5151         int tmp;
5152         __u32 tsn;
5153         int account_value;
5154         struct sock *sk = asoc->base.sk;
5155
5156         data_hdr = chunk->subh.data_hdr = (sctp_datahdr_t *)chunk->skb->data;
5157         skb_pull(chunk->skb, sizeof(sctp_datahdr_t));
5158
5159         tsn = ntohl(data_hdr->tsn);
5160         SCTP_DEBUG_PRINTK("eat_data: TSN 0x%x.\n", tsn);
5161
5162         /* ASSERT:  Now skb->data is really the user data.  */
5163
5164         /*
5165          * if we are established, and we have used up our receive
5166          * buffer memory, drop the frame
5167          */
5168         if (asoc->state == SCTP_STATE_ESTABLISHED) {
5169                 /*
5170                  * If the receive buffer policy is 1, then each
5171                  * association can allocate up to sk_rcvbuf bytes
5172                  * otherwise, all the associations in aggregate
5173                  * may allocate up to sk_rcvbuf bytes
5174                  */
5175                 if (asoc->ep->rcvbuf_policy)
5176                         account_value = atomic_read(&asoc->rmem_alloc);
5177                 else
5178                         account_value = atomic_read(&sk->sk_rmem_alloc);
5179
5180                 if (account_value > sk->sk_rcvbuf)
5181                         return SCTP_IERROR_IGNORE_TSN;
5182         }
5183
5184         /* Process ECN based congestion.
5185          *
5186          * Since the chunk structure is reused for all chunks within
5187          * a packet, we use ecn_ce_done to track if we've already
5188          * done CE processing for this packet.
5189          *
5190          * We need to do ECN processing even if we plan to discard the
5191          * chunk later.
5192          */
5193
5194         if (!chunk->ecn_ce_done) {
5195                 struct sctp_af *af;
5196                 chunk->ecn_ce_done = 1;
5197
5198                 af = sctp_get_af_specific(
5199                         ipver2af(chunk->skb->nh.iph->version));
5200
5201                 if (af && af->is_ce(chunk->skb) && asoc->peer.ecn_capable) {
5202                         /* Do real work as sideffect. */
5203                         sctp_add_cmd_sf(commands, SCTP_CMD_ECN_CE,
5204                                         SCTP_U32(tsn));
5205                 }
5206         }
5207
5208         tmp = sctp_tsnmap_check(&asoc->peer.tsn_map, tsn);
5209         if (tmp < 0) {
5210                 /* The TSN is too high--silently discard the chunk and
5211                  * count on it getting retransmitted later.
5212                  */
5213                 return SCTP_IERROR_HIGH_TSN;
5214         } else if (tmp > 0) {
5215                 /* This is a duplicate.  Record it.  */
5216                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_DUP, SCTP_U32(tsn));
5217                 return SCTP_IERROR_DUP_TSN;
5218         }
5219
5220         /* This is a new TSN.  */
5221
5222         /* Discard if there is no room in the receive window.
5223          * Actually, allow a little bit of overflow (up to a MTU).
5224          */
5225         datalen = ntohs(chunk->chunk_hdr->length);
5226         datalen -= sizeof(sctp_data_chunk_t);
5227
5228         deliver = SCTP_CMD_CHUNK_ULP;
5229
5230         /* Think about partial delivery. */
5231         if ((datalen >= asoc->rwnd) && (!asoc->ulpq.pd_mode)) {
5232
5233                 /* Even if we don't accept this chunk there is
5234                  * memory pressure.
5235                  */
5236                 sctp_add_cmd_sf(commands, SCTP_CMD_PART_DELIVER, SCTP_NULL());
5237         }
5238
5239         /* Spill over rwnd a little bit.  Note: While allowed, this spill over
5240          * seems a bit troublesome in that frag_point varies based on
5241          * PMTU.  In cases, such as loopback, this might be a rather
5242          * large spill over.
5243          */
5244         if (!asoc->rwnd || asoc->rwnd_over ||
5245             (datalen > asoc->rwnd + asoc->frag_point)) {
5246
5247                 /* If this is the next TSN, consider reneging to make
5248                  * room.   Note: Playing nice with a confused sender.  A
5249                  * malicious sender can still eat up all our buffer
5250                  * space and in the future we may want to detect and
5251                  * do more drastic reneging.
5252                  */
5253                 if (sctp_tsnmap_has_gap(&asoc->peer.tsn_map) &&
5254                     (sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map) + 1) == tsn) {
5255                         SCTP_DEBUG_PRINTK("Reneging for tsn:%u\n", tsn);
5256                         deliver = SCTP_CMD_RENEGE;
5257                 } else {
5258                         SCTP_DEBUG_PRINTK("Discard tsn: %u len: %Zd, "
5259                                           "rwnd: %d\n", tsn, datalen,
5260                                           asoc->rwnd);
5261                         return SCTP_IERROR_IGNORE_TSN;
5262                 }
5263         }
5264
5265         /*
5266          * Section 3.3.10.9 No User Data (9)
5267          *
5268          * Cause of error
5269          * ---------------
5270          * No User Data:  This error cause is returned to the originator of a
5271          * DATA chunk if a received DATA chunk has no user data.
5272          */
5273         if (unlikely(0 == datalen)) {
5274                 err = sctp_make_abort_no_data(asoc, chunk, tsn);
5275                 if (err) {
5276                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
5277                                         SCTP_CHUNK(err));
5278                 }
5279                 /* We are going to ABORT, so we might as well stop
5280                  * processing the rest of the chunks in the packet.
5281                  */
5282                 sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
5283                 sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
5284                                 SCTP_U32(SCTP_ERROR_NO_DATA));
5285                 SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
5286                 SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
5287                 return SCTP_IERROR_NO_DATA;
5288         }
5289
5290         /* If definately accepting the DATA chunk, record its TSN, otherwise
5291          * wait for renege processing.
5292          */
5293         if (SCTP_CMD_CHUNK_ULP == deliver)
5294                 sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_TSN, SCTP_U32(tsn));
5295
5296         /* Note: Some chunks may get overcounted (if we drop) or overcounted
5297          * if we renege and the chunk arrives again.
5298          */
5299         if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
5300                 SCTP_INC_STATS(SCTP_MIB_INUNORDERCHUNKS);
5301         else
5302                 SCTP_INC_STATS(SCTP_MIB_INORDERCHUNKS);
5303
5304         /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
5305          *
5306          * If an endpoint receive a DATA chunk with an invalid stream
5307          * identifier, it shall acknowledge the reception of the DATA chunk
5308          * following the normal procedure, immediately send an ERROR chunk
5309          * with cause set to "Invalid Stream Identifier" (See Section 3.3.10)
5310          * and discard the DATA chunk.
5311          */
5312         if (ntohs(data_hdr->stream) >= asoc->c.sinit_max_instreams) {
5313                 err = sctp_make_op_error(asoc, chunk, SCTP_ERROR_INV_STRM,
5314                                          &data_hdr->stream,
5315                                          sizeof(data_hdr->stream));
5316                 if (err)
5317                         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
5318                                         SCTP_CHUNK(err));
5319                 return SCTP_IERROR_BAD_STREAM;
5320         }
5321
5322         /* Send the data up to the user.  Note:  Schedule  the
5323          * SCTP_CMD_CHUNK_ULP cmd before the SCTP_CMD_GEN_SACK, as the SACK
5324          * chunk needs the updated rwnd.
5325          */
5326         sctp_add_cmd_sf(commands, deliver, SCTP_CHUNK(chunk));
5327
5328         return SCTP_IERROR_NO_ERROR;
5329 }