Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

29 files changed, 27634 insertions, 0 deletions

diff --git a/net/sctp/Kconfig b/net/sctp/Kconfig
new file mode 100644
index 000000000000..9cba49e2ad43
--- /dev/null
+++ b/net/sctp/Kconfig
@@ -0,0 +1,89 @@
+#
+# SCTP configuration
+#
+
+menu "SCTP Configuration (EXPERIMENTAL)"
+        depends on INET && EXPERIMENTAL
+
+config IP_SCTP
+        tristate "The SCTP Protocol (EXPERIMENTAL)"
+        depends on IPV6 || IPV6=n
+        select CRYPTO if SCTP_HMAC_SHA1 || SCTP_HMAC_MD5
+        select CRYPTO_HMAC if SCTP_HMAC_SHA1 || SCTP_HMAC_MD5
+        select CRYPTO_SHA1 if SCTP_HMAC_SHA1
+        select CRYPTO_MD5 if SCTP_HMAC_MD5
+        ---help---
+          Stream Control Transmission Protocol
+
+          From RFC 2960 <http://www.ietf.org/rfc/rfc2960.txt>.
+
+          "SCTP is a reliable transport protocol operating on top of a
+          connectionless packet network such as IP.  It offers the following
+          services to its users:
+
+          -- acknowledged error-free non-duplicated transfer of user data,
+          -- data fragmentation to conform to discovered path MTU size,
+          -- sequenced delivery of user messages within multiple streams,
+          with an option for order-of-arrival delivery of individual user
+          messages,
+          -- optional bundling of multiple user messages into a single SCTP
+          packet, and
+          -- network-level fault tolerance through supporting of multi-
+          homing at either or both ends of an association."
+
+          To compile this protocol support as a module, choose M here: the
+          module will be called sctp.
+
+          If in doubt, say N.
+
+config SCTP_DBG_MSG
+        bool "SCTP: Debug messages"
+        depends on IP_SCTP
+        help
+          If you say Y, this will enable verbose debugging messages. 
+
+          If unsure, say N.  However, if you are running into problems, use 
+          this option to gather detailed trace information
+
+config SCTP_DBG_OBJCNT
+        bool "SCTP: Debug object counts"
+        depends on IP_SCTP
+        help
+          If you say Y, this will enable debugging support for counting the 
+          type of objects that are currently allocated.  This is useful for 
+          identifying memory leaks.   If the /proc filesystem is enabled this 
+          debug information can be viewed by 
+          'cat /proc/net/sctp/sctp_dbg_objcnt'
+
+          If unsure, say N
+
+choice
+        prompt "SCTP: Cookie HMAC Algorithm"
+        depends on IP_SCTP
+        default SCTP_HMAC_MD5
+        help
+          HMAC algorithm to be used during association initialization.  It
+          is strongly recommended to use HMAC-SHA1 or HMAC-MD5.  See 
+          configuration for Cryptographic API and enable those algorithms
+          to make usable by SCTP. 
+
+config SCTP_HMAC_NONE
+        bool "None"
+        help 
+          Choosing this disables the use of an HMAC during association 
+          establishment.  It is advised to use either HMAC-MD5 or HMAC-SHA1.
+
+config SCTP_HMAC_SHA1
+        bool "HMAC-SHA1"
+        help 
+          Enable the use of HMAC-SHA1 during association establishment.  It 
+          is advised to use either HMAC-MD5 or HMAC-SHA1.
+
+config SCTP_HMAC_MD5
+        bool "HMAC-MD5"
+        help
+          Enable the use of HMAC-MD5 during association establishment.  It is 
+          advised to use either HMAC-MD5 or HMAC-SHA1.
+
+endchoice
+endmenu
diff --git a/net/sctp/Makefile b/net/sctp/Makefile
new file mode 100644
index 000000000000..70c828bbe444
--- /dev/null
+++ b/net/sctp/Makefile
@@ -0,0 +1,17 @@
+#
+# Makefile for SCTP support code.
+#
+
+obj-$(CONFIG_IP_SCTP) += sctp.o
+
+sctp-y := sm_statetable.o sm_statefuns.o sm_sideeffect.o \
+          protocol.o endpointola.o associola.o \
+          transport.o chunk.o sm_make_chunk.o ulpevent.o \
+          inqueue.o outqueue.o ulpqueue.o command.o \
+          tsnmap.o bind_addr.o socket.o primitive.o \
+          output.o input.o debug.o ssnmap.o proc.o crc32c.o
+
+sctp-$(CONFIG_SCTP_DBG_OBJCNT) += objcnt.o
+sctp-$(CONFIG_SYSCTL) += sysctl.o
+
+sctp-$(subst m,y,$(CONFIG_IPV6))        += ipv6.o
diff --git a/net/sctp/associola.c b/net/sctp/associola.c
new file mode 100644
index 000000000000..663843d97a92
--- /dev/null
+++ b/net/sctp/associola.c
@@ -0,0 +1,1205 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * This module provides the abstraction for an SCTP association.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Ryan Layer            <rmlayer@us.ibm.com>
+ *    Kevin Gao             <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/fcntl.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+
+#include <linux/slab.h>
+#include <linux/in.h>
+#include <net/ipv6.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for internal functions. */
+static void sctp_assoc_bh_rcv(struct sctp_association *asoc);
+
+
+/* 1st Level Abstractions. */
+
+/* Initialize a new association from provided memory. */
+static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
+                                          const struct sctp_endpoint *ep,
+                                          const struct sock *sk,
+                                          sctp_scope_t scope,
+                                          int gfp)
+{
+        struct sctp_sock *sp;
+        int i;
+
+        /* Retrieve the SCTP per socket area.  */
+        sp = sctp_sk((struct sock *)sk);
+
+        /* Init all variables to a known value.  */
+        memset(asoc, 0, sizeof(struct sctp_association));
+
+        /* Discarding const is appropriate here.  */
+        asoc->ep = (struct sctp_endpoint *)ep;
+        sctp_endpoint_hold(asoc->ep);
+
+        /* Hold the sock.  */
+        asoc->base.sk = (struct sock *)sk;
+        sock_hold(asoc->base.sk);
+
+        /* Initialize the common base substructure.  */
+        asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;
+
+        /* Initialize the object handling fields.  */
+        atomic_set(&asoc->base.refcnt, 1);
+        asoc->base.dead = 0;
+        asoc->base.malloced = 0;
+
+        /* Initialize the bind addr area.  */
+        sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);
+        rwlock_init(&asoc->base.addr_lock);
+
+        asoc->state = SCTP_STATE_CLOSED;
+
+        /* Set these values from the socket values, a conversion between
+         * millsecons to seconds/microseconds must also be done.
+         */
+        asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000;
+        asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000)
+                                        * 1000;
+        asoc->pmtu = 0;
+        asoc->frag_point = 0;
+
+        /* Set the association max_retrans and RTO values from the
+         * socket values.
+         */
+        asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
+        asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
+        asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
+        asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);
+
+        asoc->overall_error_count = 0;
+
+        /* Initialize the maximum mumber of new data packets that can be sent
+         * in a burst.
+         */
+        asoc->max_burst = sctp_max_burst;
+
+        /* Copy things from the endpoint.  */
+        for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
+                asoc->timeouts[i] = ep->timeouts[i];
+                init_timer(&asoc->timers[i]);
+                asoc->timers[i].function = sctp_timer_events[i];
+                asoc->timers[i].data = (unsigned long) asoc;
+        }
+
+        /* Pull default initialization values from the sock options.
+         * Note: This assumes that the values have already been
+         * validated in the sock.
+         */
+        asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;
+        asoc->c.sinit_num_ostreams  = sp->initmsg.sinit_num_ostreams;
+        asoc->max_init_attempts = sp->initmsg.sinit_max_attempts;
+
+        asoc->max_init_timeo =
+                 msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);
+
+        /* Allocate storage for the ssnmap after the inbound and outbound
+         * streams have been negotiated during Init.
+         */
+        asoc->ssnmap = NULL;
+
+        /* Set the local window size for receive.
+         * This is also the rcvbuf space per association.
+         * RFC 6 - A SCTP receiver MUST be able to receive a minimum of
+         * 1500 bytes in one SCTP packet.
+         */
+        if (sk->sk_rcvbuf < SCTP_DEFAULT_MINWINDOW)
+                asoc->rwnd = SCTP_DEFAULT_MINWINDOW;
+        else
+                asoc->rwnd = sk->sk_rcvbuf;
+
+        asoc->a_rwnd = asoc->rwnd;
+
+        asoc->rwnd_over = 0;
+
+        /* Use my own max window until I learn something better.  */
+        asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;
+
+        /* Set the sndbuf size for transmit.  */
+        asoc->sndbuf_used = 0;
+
+        init_waitqueue_head(&asoc->wait);
+
+        asoc->c.my_vtag = sctp_generate_tag(ep);
+        asoc->peer.i.init_tag = 0;     /* INIT needs a vtag of 0. */
+        asoc->c.peer_vtag = 0;
+        asoc->c.my_ttag   = 0;
+        asoc->c.peer_ttag = 0;
+        asoc->c.my_port = ep->base.bind_addr.port;
+
+        asoc->c.initial_tsn = sctp_generate_tsn(ep);
+
+        asoc->next_tsn = asoc->c.initial_tsn;
+
+        asoc->ctsn_ack_point = asoc->next_tsn - 1;
+        asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
+        asoc->highest_sacked = asoc->ctsn_ack_point;
+        asoc->last_cwr_tsn = asoc->ctsn_ack_point;
+        asoc->unack_data = 0;
+
+        SCTP_DEBUG_PRINTK("myctsnap for %s INIT as 0x%x.\n",
+                          asoc->ep->debug_name,
+                          asoc->ctsn_ack_point);
+
+        /* ADDIP Section 4.1 Asconf Chunk Procedures
+         *
+         * When an endpoint has an ASCONF signaled change to be sent to the
+         * remote endpoint it should do the following:
+         * ...
+         * A2) a serial number should be assigned to the chunk. The serial
+         * number SHOULD be a monotonically increasing number. The serial
+         * numbers SHOULD be initialized at the start of the
+         * association to the same value as the initial TSN.
+         */
+        asoc->addip_serial = asoc->c.initial_tsn;
+
+        skb_queue_head_init(&asoc->addip_chunks);
+
+        /* Make an empty list of remote transport addresses.  */
+        INIT_LIST_HEAD(&asoc->peer.transport_addr_list);
+
+        /* RFC 2960 5.1 Normal Establishment of an Association
+         *
+         * After the reception of the first data chunk in an
+         * association the endpoint must immediately respond with a
+         * sack to acknowledge the data chunk.  Subsequent
+         * acknowledgements should be done as described in Section
+         * 6.2.
+         *
+         * [We implement this by telling a new association that it
+         * already received one packet.]
+         */
+        asoc->peer.sack_needed = 1;
+
+        /* Assume that the peer recongizes ASCONF until reported otherwise
+         * via an ERROR chunk.
+         */
+        asoc->peer.asconf_capable = 1;
+
+        /* Create an input queue.  */
+        sctp_inq_init(&asoc->base.inqueue);
+        sctp_inq_set_th_handler(&asoc->base.inqueue,
+                                    (void (*)(void *))sctp_assoc_bh_rcv,
+                                    asoc);
+
+        /* Create an output queue.  */
+        sctp_outq_init(asoc, &asoc->outqueue);
+
+        if (!sctp_ulpq_init(&asoc->ulpq, asoc))
+                goto fail_init;
+
+        /* Set up the tsn tracking. */
+        sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE, 0);
+
+        asoc->need_ecne = 0;
+
+        asoc->assoc_id = 0;
+
+        /* Assume that peer would support both address types unless we are
+         * told otherwise.
+         */
+        asoc->peer.ipv4_address = 1;
+        asoc->peer.ipv6_address = 1;
+        INIT_LIST_HEAD(&asoc->asocs);
+
+        asoc->autoclose = sp->autoclose;
+
+        asoc->default_stream = sp->default_stream;
+        asoc->default_ppid = sp->default_ppid;
+        asoc->default_flags = sp->default_flags;
+        asoc->default_context = sp->default_context;
+        asoc->default_timetolive = sp->default_timetolive;
+
+        return asoc;
+
+fail_init:
+        sctp_endpoint_put(asoc->ep);
+        sock_put(asoc->base.sk);
+        return NULL;
+}
+
+/* Allocate and initialize a new association */
+struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
+                                         const struct sock *sk,
+                                         sctp_scope_t scope, int gfp)
+{
+        struct sctp_association *asoc;
+
+        asoc = t_new(struct sctp_association, gfp);
+        if (!asoc)
+                goto fail;
+
+        if (!sctp_association_init(asoc, ep, sk, scope, gfp))
+                goto fail_init;
+
+        asoc->base.malloced = 1;
+        SCTP_DBG_OBJCNT_INC(assoc);
+
+        return asoc;
+
+fail_init:
+        kfree(asoc);
+fail:
+        return NULL;
+}
+
+/* Free this association if possible.  There may still be users, so
+ * the actual deallocation may be delayed.
+ */
+void sctp_association_free(struct sctp_association *asoc)
+{
+        struct sock *sk = asoc->base.sk;
+        struct sctp_transport *transport;
+        struct list_head *pos, *temp;
+        int i;
+
+        list_del(&asoc->asocs);
+
+        /* Decrement the backlog value for a TCP-style listening socket. */
+        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
+                sk->sk_ack_backlog--;
+
+        /* Mark as dead, so other users can know this structure is
+         * going away.
+         */
+        asoc->base.dead = 1;
+
+        /* Dispose of any data lying around in the outqueue. */
+        sctp_outq_free(&asoc->outqueue);
+
+        /* Dispose of any pending messages for the upper layer. */
+        sctp_ulpq_free(&asoc->ulpq);
+
+        /* Dispose of any pending chunks on the inqueue. */
+        sctp_inq_free(&asoc->base.inqueue);
+
+        /* Free ssnmap storage. */
+        sctp_ssnmap_free(asoc->ssnmap);
+
+        /* Clean up the bound address list. */
+        sctp_bind_addr_free(&asoc->base.bind_addr);
+
+        /* Do we need to go through all of our timers and
+         * delete them?   To be safe we will try to delete all, but we
+         * should be able to go through and make a guess based
+         * on our state.
+         */
+        for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
+                if (timer_pending(&asoc->timers[i]) &&
+                    del_timer(&asoc->timers[i]))
+                        sctp_association_put(asoc);
+        }
+
+        /* Free peer's cached cookie. */
+        if (asoc->peer.cookie) {
+                kfree(asoc->peer.cookie);
+        }
+
+        /* Release the transport structures. */
+        list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                list_del(pos);
+                sctp_transport_free(transport);
+        }
+
+        /* Free any cached ASCONF_ACK chunk. */
+        if (asoc->addip_last_asconf_ack)
+                sctp_chunk_free(asoc->addip_last_asconf_ack);
+
+        /* Free any cached ASCONF chunk. */
+        if (asoc->addip_last_asconf)
+                sctp_chunk_free(asoc->addip_last_asconf);
+
+        sctp_association_put(asoc);
+}
+
+/* Cleanup and free up an association. */
+static void sctp_association_destroy(struct sctp_association *asoc)
+{
+        SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return);
+
+        sctp_endpoint_put(asoc->ep);
+        sock_put(asoc->base.sk);
+
+        if (asoc->assoc_id != 0) {
+                spin_lock_bh(&sctp_assocs_id_lock);
+                idr_remove(&sctp_assocs_id, asoc->assoc_id);
+                spin_unlock_bh(&sctp_assocs_id_lock);
+        }
+
+        if (asoc->base.malloced) {
+                kfree(asoc);
+                SCTP_DBG_OBJCNT_DEC(assoc);
+        }
+}
+
+/* Change the primary destination address for the peer. */
+void sctp_assoc_set_primary(struct sctp_association *asoc,
+                            struct sctp_transport *transport)
+{
+        asoc->peer.primary_path = transport;
+
+        /* Set a default msg_name for events. */
+        memcpy(&asoc->peer.primary_addr, &transport->ipaddr,
+               sizeof(union sctp_addr));
+
+        /* If the primary path is changing, assume that the
+         * user wants to use this new path.
+         */
+        if (transport->active)
+                asoc->peer.active_path = transport;
+
+        /*
+         * SFR-CACC algorithm:
+         * Upon the receipt of a request to change the primary
+         * destination address, on the data structure for the new
+         * primary destination, the sender MUST do the following:
+         *
+         * 1) If CHANGEOVER_ACTIVE is set, then there was a switch
+         * to this destination address earlier. The sender MUST set
+         * CYCLING_CHANGEOVER to indicate that this switch is a
+         * double switch to the same destination address.
+         */
+        if (transport->cacc.changeover_active)
+                transport->cacc.cycling_changeover = 1;
+
+        /* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that
+         * a changeover has occurred.
+         */
+        transport->cacc.changeover_active = 1;
+
+        /* 3) The sender MUST store the next TSN to be sent in
+         * next_tsn_at_change.
+         */
+        transport->cacc.next_tsn_at_change = asoc->next_tsn;
+}
+
+/* Add a transport address to an association.  */
+struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
+                                           const union sctp_addr *addr,
+                                           int gfp)
+{
+        struct sctp_transport *peer;
+        struct sctp_sock *sp;
+        unsigned short port;
+
+        sp = sctp_sk(asoc->base.sk);
+
+        /* AF_INET and AF_INET6 share common port field. */
+        port = addr->v4.sin_port;
+
+        /* Set the port if it has not been set yet.  */
+        if (0 == asoc->peer.port)
+                asoc->peer.port = port;
+
+        /* Check to see if this is a duplicate. */
+        peer = sctp_assoc_lookup_paddr(asoc, addr);
+        if (peer)
+                return peer;
+
+        peer = sctp_transport_new(addr, gfp);
+        if (!peer)
+                return NULL;
+
+        sctp_transport_set_owner(peer, asoc);
+
+        /* Initialize the pmtu of the transport. */
+        sctp_transport_pmtu(peer);
+
+        /* If this is the first transport addr on this association,
+         * initialize the association PMTU to the peer's PMTU.
+         * If not and the current association PMTU is higher than the new
+         * peer's PMTU, reset the association PMTU to the new peer's PMTU.
+         */
+        if (asoc->pmtu)
+                asoc->pmtu = min_t(int, peer->pmtu, asoc->pmtu);
+        else
+                asoc->pmtu = peer->pmtu;
+
+        SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to "
+                          "%d\n", asoc, asoc->pmtu);
+
+        asoc->frag_point = sctp_frag_point(sp, asoc->pmtu);
+
+        /* The asoc->peer.port might not be meaningful yet, but
+         * initialize the packet structure anyway.
+         */
+        sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,
+                         asoc->peer.port);
+
+        /* 7.2.1 Slow-Start
+         *
+         * o The initial cwnd before DATA transmission or after a sufficiently
+         *   long idle period MUST be set to
+         *      min(4*MTU, max(2*MTU, 4380 bytes))
+         *
+         * o The initial value of ssthresh MAY be arbitrarily high
+         *   (for example, implementations MAY use the size of the
+         *   receiver advertised window).
+         */
+        peer->cwnd = min(4*asoc->pmtu, max_t(__u32, 2*asoc->pmtu, 4380));
+
+        /* At this point, we may not have the receiver's advertised window,
+         * so initialize ssthresh to the default value and it will be set
+         * later when we process the INIT.
+         */
+        peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;
+
+        peer->partial_bytes_acked = 0;
+        peer->flight_size = 0;
+
+        /* By default, enable heartbeat for peer address. */
+        peer->hb_allowed = 1;
+
+        /* Initialize the peer's heartbeat interval based on the
+         * sock configured value.
+         */
+        peer->hb_interval = msecs_to_jiffies(sp->paddrparam.spp_hbinterval);
+
+        /* Set the path max_retrans.  */
+        peer->max_retrans = sp->paddrparam.spp_pathmaxrxt;
+
+        /* Set the transport's RTO.initial value */
+        peer->rto = asoc->rto_initial;
+
+        /* Attach the remote transport to our asoc.  */
+        list_add_tail(&peer->transports, &asoc->peer.transport_addr_list);
+
+        /* If we do not yet have a primary path, set one.  */
+        if (!asoc->peer.primary_path) {
+                sctp_assoc_set_primary(asoc, peer);
+                asoc->peer.retran_path = peer;
+        }
+
+        if (asoc->peer.active_path == asoc->peer.retran_path)
+                asoc->peer.retran_path = peer;
+
+        return peer;
+}
+
+/* Delete a transport address from an association.  */
+void sctp_assoc_del_peer(struct sctp_association *asoc,
+                         const union sctp_addr *addr)
+{
+        struct list_head        *pos;
+        struct list_head        *temp;
+        struct sctp_transport   *peer = NULL;
+        struct sctp_transport   *transport;
+
+        list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {
+                        peer = transport;
+                        list_del(pos);
+                        break;
+                }
+        }
+
+        /* The address we want delete is not in the association. */
+        if (!peer)
+                return;
+
+        /* Get the first transport of asoc. */ 
+        pos = asoc->peer.transport_addr_list.next;
+        transport = list_entry(pos, struct sctp_transport, transports);
+
+        /* Update any entries that match the peer to be deleted. */  
+        if (asoc->peer.primary_path == peer)
+                sctp_assoc_set_primary(asoc, transport);
+        if (asoc->peer.active_path == peer)
+                asoc->peer.active_path = transport;
+        if (asoc->peer.retran_path == peer)
+                asoc->peer.retran_path = transport;
+        if (asoc->peer.last_data_from == peer)
+                asoc->peer.last_data_from = transport;
+
+        sctp_transport_free(peer);
+}
+
+/* Lookup a transport by address. */
+struct sctp_transport *sctp_assoc_lookup_paddr(
+                                        const struct sctp_association *asoc,
+                                        const union sctp_addr *address)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+
+        /* Cycle through all transports searching for a peer address. */
+
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+                if (sctp_cmp_addr_exact(address, &t->ipaddr))
+                        return t;
+        }
+
+        return NULL;
+}
+
+/* Engage in transport control operations.
+ * Mark the transport up or down and send a notification to the user.
+ * Select and update the new active and retran paths.
+ */
+void sctp_assoc_control_transport(struct sctp_association *asoc,
+                                  struct sctp_transport *transport,
+                                  sctp_transport_cmd_t command,
+                                  sctp_sn_error_t error)
+{
+        struct sctp_transport *t = NULL;
+        struct sctp_transport *first;
+        struct sctp_transport *second;
+        struct sctp_ulpevent *event;
+        struct list_head *pos;
+        int spc_state = 0;
+
+        /* Record the transition on the transport.  */
+        switch (command) {
+        case SCTP_TRANSPORT_UP:
+                transport->active = SCTP_ACTIVE;
+                spc_state = SCTP_ADDR_AVAILABLE;
+                break;
+
+        case SCTP_TRANSPORT_DOWN:
+                transport->active = SCTP_INACTIVE;
+                spc_state = SCTP_ADDR_UNREACHABLE;
+                break;
+
+        default:
+                return;
+        };
+
+        /* Generate and send a SCTP_PEER_ADDR_CHANGE notification to the
+         * user.
+         */
+        event = sctp_ulpevent_make_peer_addr_change(asoc,
+                                (struct sockaddr_storage *) &transport->ipaddr,
+                                0, spc_state, error, GFP_ATOMIC);
+        if (event)
+                sctp_ulpq_tail_event(&asoc->ulpq, event);
+
+        /* Select new active and retran paths. */
+
+        /* Look for the two most recently used active transports.
+         *
+         * This code produces the wrong ordering whenever jiffies
+         * rolls over, but we still get usable transports, so we don't
+         * worry about it.
+         */
+        first = NULL; second = NULL;
+
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+
+                if (!t->active)
+                        continue;
+                if (!first || t->last_time_heard > first->last_time_heard) {
+                        second = first;
+                        first = t;
+                }
+                if (!second || t->last_time_heard > second->last_time_heard)
+                        second = t;
+        }
+
+        /* RFC 2960 6.4 Multi-Homed SCTP Endpoints
+         *
+         * By default, an endpoint should always transmit to the
+         * primary path, unless the SCTP user explicitly specifies the
+         * destination transport address (and possibly source
+         * transport address) to use.
+         *
+         * [If the primary is active but not most recent, bump the most
+         * recently used transport.]
+         */
+        if (asoc->peer.primary_path->active &&
+            first != asoc->peer.primary_path) {
+                second = first;
+                first = asoc->peer.primary_path;
+        }
+
+        /* If we failed to find a usable transport, just camp on the
+         * primary, even if it is inactive.
+         */
+        if (!first) {
+                first = asoc->peer.primary_path;
+                second = asoc->peer.primary_path;
+        }
+
+        /* Set the active and retran transports.  */
+        asoc->peer.active_path = first;
+        asoc->peer.retran_path = second;
+}
+
+/* Hold a reference to an association. */
+void sctp_association_hold(struct sctp_association *asoc)
+{
+        atomic_inc(&asoc->base.refcnt);
+}
+
+/* Release a reference to an association and cleanup
+ * if there are no more references.
+ */
+void sctp_association_put(struct sctp_association *asoc)
+{
+        if (atomic_dec_and_test(&asoc->base.refcnt))
+                sctp_association_destroy(asoc);
+}
+
+/* Allocate the next TSN, Transmission Sequence Number, for the given
+ * association.
+ */
+__u32 sctp_association_get_next_tsn(struct sctp_association *asoc)
+{
+        /* From Section 1.6 Serial Number Arithmetic:
+         * Transmission Sequence Numbers wrap around when they reach
+         * 2**32 - 1.  That is, the next TSN a DATA chunk MUST use
+         * after transmitting TSN = 2*32 - 1 is TSN = 0.
+         */
+        __u32 retval = asoc->next_tsn;
+        asoc->next_tsn++;
+        asoc->unack_data++;
+
+        return retval;
+}
+
+/* Compare two addresses to see if they match.  Wildcard addresses
+ * only match themselves.
+ */
+int sctp_cmp_addr_exact(const union sctp_addr *ss1,
+                        const union sctp_addr *ss2)
+{
+        struct sctp_af *af;
+
+        af = sctp_get_af_specific(ss1->sa.sa_family);
+        if (unlikely(!af))
+                return 0;
+
+        return af->cmp_addr(ss1, ss2);
+}
+
+/* Return an ecne chunk to get prepended to a packet.
+ * Note:  We are sly and return a shared, prealloced chunk.  FIXME:
+ * No we don't, but we could/should.
+ */
+struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)
+{
+        struct sctp_chunk *chunk;
+
+        /* Send ECNE if needed.
+         * Not being able to allocate a chunk here is not deadly.
+         */
+        if (asoc->need_ecne)
+                chunk = sctp_make_ecne(asoc, asoc->last_ecne_tsn);
+        else
+                chunk = NULL;
+
+        return chunk;
+}
+
+/*
+ * Find which transport this TSN was sent on.
+ */
+struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
+                                             __u32 tsn)
+{
+        struct sctp_transport *active;
+        struct sctp_transport *match;
+        struct list_head *entry, *pos;
+        struct sctp_transport *transport;
+        struct sctp_chunk *chunk;
+        __u32 key = htonl(tsn);
+
+        match = NULL;
+
+        /*
+         * FIXME: In general, find a more efficient data structure for
+         * searching.
+         */
+
+        /*
+         * The general strategy is to search each transport's transmitted
+         * list.   Return which transport this TSN lives on.
+         *
+         * Let's be hopeful and check the active_path first.
+         * Another optimization would be to know if there is only one
+         * outbound path and not have to look for the TSN at all.
+         *
+         */
+
+        active = asoc->peer.active_path;
+
+        list_for_each(entry, &active->transmitted) {
+                chunk = list_entry(entry, struct sctp_chunk, transmitted_list);
+
+                if (key == chunk->subh.data_hdr->tsn) {
+                        match = active;
+                        goto out;
+                }
+        }
+
+        /* If not found, go search all the other transports. */
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+
+                if (transport == active)
+                        break;
+                list_for_each(entry, &transport->transmitted) {
+                        chunk = list_entry(entry, struct sctp_chunk,
+                                           transmitted_list);
+                        if (key == chunk->subh.data_hdr->tsn) {
+                                match = transport;
+                                goto out;
+                        }
+                }
+        }
+out:
+        return match;
+}
+
+/* Is this the association we are looking for? */
+struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,
+                                           const union sctp_addr *laddr,
+                                           const union sctp_addr *paddr)
+{
+        struct sctp_transport *transport;
+
+        sctp_read_lock(&asoc->base.addr_lock);
+
+        if ((asoc->base.bind_addr.port == laddr->v4.sin_port) &&
+            (asoc->peer.port == paddr->v4.sin_port)) {
+                transport = sctp_assoc_lookup_paddr(asoc, paddr);
+                if (!transport)
+                        goto out;
+
+                if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
+                                         sctp_sk(asoc->base.sk)))
+                        goto out;
+        }
+        transport = NULL;
+
+out:
+        sctp_read_unlock(&asoc->base.addr_lock);
+        return transport;
+}
+
+/* Do delayed input processing.  This is scheduled by sctp_rcv(). */
+static void sctp_assoc_bh_rcv(struct sctp_association *asoc)
+{
+        struct sctp_endpoint *ep;
+        struct sctp_chunk *chunk;
+        struct sock *sk;
+        struct sctp_inq *inqueue;
+        int state;
+        sctp_subtype_t subtype;
+        int error = 0;
+
+        /* The association should be held so we should be safe. */
+        ep = asoc->ep;
+        sk = asoc->base.sk;
+
+        inqueue = &asoc->base.inqueue;
+        sctp_association_hold(asoc);
+        while (NULL != (chunk = sctp_inq_pop(inqueue))) {
+                state = asoc->state;
+                subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
+
+                /* Remember where the last DATA chunk came from so we
+                 * know where to send the SACK.
+                 */
+                if (sctp_chunk_is_data(chunk))
+                        asoc->peer.last_data_from = chunk->transport;
+                else
+                        SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS);
+
+                if (chunk->transport)
+                        chunk->transport->last_time_heard = jiffies;
+
+                /* Run through the state machine. */
+                error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype,
+                                   state, ep, asoc, chunk, GFP_ATOMIC);
+
+                /* Check to see if the association is freed in response to
+                 * the incoming chunk.  If so, get out of the while loop.
+                 */
+                if (asoc->base.dead)
+                        break;
+
+                /* If there is an error on chunk, discard this packet. */
+                if (error && chunk)
+                        chunk->pdiscard = 1;
+        }
+        sctp_association_put(asoc);
+}
+
+/* This routine moves an association from its old sk to a new sk.  */
+void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)
+{
+        struct sctp_sock *newsp = sctp_sk(newsk);
+        struct sock *oldsk = assoc->base.sk;
+
+        /* Delete the association from the old endpoint's list of
+         * associations.
+         */
+        list_del_init(&assoc->asocs);
+
+        /* Decrement the backlog value for a TCP-style socket. */
+        if (sctp_style(oldsk, TCP))
+                oldsk->sk_ack_backlog--;
+
+        /* Release references to the old endpoint and the sock.  */
+        sctp_endpoint_put(assoc->ep);
+        sock_put(assoc->base.sk);
+
+        /* Get a reference to the new endpoint.  */
+        assoc->ep = newsp->ep;
+        sctp_endpoint_hold(assoc->ep);
+
+        /* Get a reference to the new sock.  */
+        assoc->base.sk = newsk;
+        sock_hold(assoc->base.sk);
+
+        /* Add the association to the new endpoint's list of associations.  */
+        sctp_endpoint_add_asoc(newsp->ep, assoc);
+}
+
+/* Update an association (possibly from unexpected COOKIE-ECHO processing).  */
+void sctp_assoc_update(struct sctp_association *asoc,
+                       struct sctp_association *new)
+{
+        struct sctp_transport *trans;
+        struct list_head *pos, *temp;
+
+        /* Copy in new parameters of peer. */
+        asoc->c = new->c;
+        asoc->peer.rwnd = new->peer.rwnd;
+        asoc->peer.sack_needed = new->peer.sack_needed;
+        asoc->peer.i = new->peer.i;
+        sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE,
+                         asoc->peer.i.initial_tsn);
+
+        /* Remove any peer addresses not present in the new association. */
+        list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
+                trans = list_entry(pos, struct sctp_transport, transports);
+                if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr))
+                        sctp_assoc_del_peer(asoc, &trans->ipaddr);
+        }
+
+        /* If the case is A (association restart), use
+         * initial_tsn as next_tsn. If the case is B, use
+         * current next_tsn in case data sent to peer
+         * has been discarded and needs retransmission.
+         */
+        if (asoc->state >= SCTP_STATE_ESTABLISHED) {
+                asoc->next_tsn = new->next_tsn;
+                asoc->ctsn_ack_point = new->ctsn_ack_point;
+                asoc->adv_peer_ack_point = new->adv_peer_ack_point;
+
+                /* Reinitialize SSN for both local streams
+                 * and peer's streams.
+                 */
+                sctp_ssnmap_clear(asoc->ssnmap);
+
+        } else {
+                /* Add any peer addresses from the new association. */
+                list_for_each(pos, &new->peer.transport_addr_list) {
+                        trans = list_entry(pos, struct sctp_transport,
+                                           transports);
+                        if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))
+                                sctp_assoc_add_peer(asoc, &trans->ipaddr,
+                                                    GFP_ATOMIC);
+                }
+
+                asoc->ctsn_ack_point = asoc->next_tsn - 1;
+                asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
+                if (!asoc->ssnmap) {
+                        /* Move the ssnmap. */
+                        asoc->ssnmap = new->ssnmap;
+                        new->ssnmap = NULL;
+                }
+        }
+}
+
+/* Update the retran path for sending a retransmitted packet.
+ * Round-robin through the active transports, else round-robin
+ * through the inactive transports as this is the next best thing
+ * we can try.
+ */
+void sctp_assoc_update_retran_path(struct sctp_association *asoc)
+{
+        struct sctp_transport *t, *next;
+        struct list_head *head = &asoc->peer.transport_addr_list;
+        struct list_head *pos;
+
+        /* Find the next transport in a round-robin fashion. */
+        t = asoc->peer.retran_path;
+        pos = &t->transports;
+        next = NULL;
+
+        while (1) {
+                /* Skip the head. */
+                if (pos->next == head)
+                        pos = head->next;
+                else
+                        pos = pos->next;
+
+                t = list_entry(pos, struct sctp_transport, transports);
+
+                /* Try to find an active transport. */
+
+                if (t->active) {
+                        break;
+                } else {
+                        /* Keep track of the next transport in case
+                         * we don't find any active transport.
+                         */
+                        if (!next)
+                                next = t;
+                }
+
+                /* We have exhausted the list, but didn't find any
+                 * other active transports.  If so, use the next
+                 * transport.
+                 */
+                if (t == asoc->peer.retran_path) {
+                        t = next;
+                        break;
+                }
+        }
+
+        asoc->peer.retran_path = t;
+}
+
+/* Choose the transport for sending a SHUTDOWN packet.  */
+struct sctp_transport *sctp_assoc_choose_shutdown_transport(
+        struct sctp_association *asoc)
+{
+        /* If this is the first time SHUTDOWN is sent, use the active path,
+         * else use the retran path. If the last SHUTDOWN was sent over the
+         * retran path, update the retran path and use it.
+         */
+        if (!asoc->shutdown_last_sent_to)
+                return asoc->peer.active_path;
+        else {
+                if (asoc->shutdown_last_sent_to == asoc->peer.retran_path)
+                        sctp_assoc_update_retran_path(asoc);
+                return asoc->peer.retran_path;
+        }
+
+}
+
+/* Update the association's pmtu and frag_point by going through all the
+ * transports. This routine is called when a transport's PMTU has changed.
+ */
+void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+        __u32 pmtu = 0;
+
+        if (!asoc)
+                return;
+
+        /* Get the lowest pmtu of all the transports. */
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+                if (!pmtu || (t->pmtu < pmtu))
+                        pmtu = t->pmtu;
+        }
+
+        if (pmtu) {
+                struct sctp_sock *sp = sctp_sk(asoc->base.sk);
+                asoc->pmtu = pmtu;
+                asoc->frag_point = sctp_frag_point(sp, pmtu);
+        }
+
+        SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n",
+                          __FUNCTION__, asoc, asoc->pmtu, asoc->frag_point);
+}
+
+/* Should we send a SACK to update our peer? */
+static inline int sctp_peer_needs_update(struct sctp_association *asoc)
+{
+        switch (asoc->state) {
+        case SCTP_STATE_ESTABLISHED:
+        case SCTP_STATE_SHUTDOWN_PENDING:
+        case SCTP_STATE_SHUTDOWN_RECEIVED:
+        case SCTP_STATE_SHUTDOWN_SENT:
+                if ((asoc->rwnd > asoc->a_rwnd) &&
+                    ((asoc->rwnd - asoc->a_rwnd) >=
+                     min_t(__u32, (asoc->base.sk->sk_rcvbuf >> 1), asoc->pmtu)))
+                        return 1;
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
+
+/* Increase asoc's rwnd by len and send any window update SACK if needed. */
+void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned len)
+{
+        struct sctp_chunk *sack;
+        struct timer_list *timer;
+
+        if (asoc->rwnd_over) {
+                if (asoc->rwnd_over >= len) {
+                        asoc->rwnd_over -= len;
+                } else {
+                        asoc->rwnd += (len - asoc->rwnd_over);
+                        asoc->rwnd_over = 0;
+                }
+        } else {
+                asoc->rwnd += len;
+        }
+
+        SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) "
+                          "- %u\n", __FUNCTION__, asoc, len, asoc->rwnd,
+                          asoc->rwnd_over, asoc->a_rwnd);
+
+        /* Send a window update SACK if the rwnd has increased by at least the
+         * minimum of the association's PMTU and half of the receive buffer.
+         * The algorithm used is similar to the one described in
+         * Section 4.2.3.3 of RFC 1122.
+         */
+        if (sctp_peer_needs_update(asoc)) {
+                asoc->a_rwnd = asoc->rwnd;
+                SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p "
+                                  "rwnd: %u a_rwnd: %u\n", __FUNCTION__,
+                                  asoc, asoc->rwnd, asoc->a_rwnd);
+                sack = sctp_make_sack(asoc);
+                if (!sack)
+                        return;
+
+                asoc->peer.sack_needed = 0;
+
+                sctp_outq_tail(&asoc->outqueue, sack);
+
+                /* Stop the SACK timer.  */
+                timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
+                if (timer_pending(timer) && del_timer(timer))
+                        sctp_association_put(asoc);
+        }
+}
+
+/* Decrease asoc's rwnd by len. */
+void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned len)
+{
+        SCTP_ASSERT(asoc->rwnd, "rwnd zero", return);
+        SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return);
+        if (asoc->rwnd >= len) {
+                asoc->rwnd -= len;
+        } else {
+                asoc->rwnd_over = len - asoc->rwnd;
+                asoc->rwnd = 0;
+        }
+        SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u)\n",
+                          __FUNCTION__, asoc, len, asoc->rwnd,
+                          asoc->rwnd_over);
+}
+
+/* Build the bind address list for the association based on info from the
+ * local endpoint and the remote peer.
+ */
+int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc, int gfp)
+{
+        sctp_scope_t scope;
+        int flags;
+
+        /* Use scoping rules to determine the subset of addresses from
+         * the endpoint.
+         */
+        scope = sctp_scope(&asoc->peer.active_path->ipaddr);
+        flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
+        if (asoc->peer.ipv4_address)
+                flags |= SCTP_ADDR4_PEERSUPP;
+        if (asoc->peer.ipv6_address)
+                flags |= SCTP_ADDR6_PEERSUPP;
+
+        return sctp_bind_addr_copy(&asoc->base.bind_addr,
+                                   &asoc->ep->base.bind_addr,
+                                   scope, gfp, flags);
+}
+
+/* Build the association's bind address list from the cookie.  */
+int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,
+                                         struct sctp_cookie *cookie, int gfp)
+{
+        int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);
+        int var_size3 = cookie->raw_addr_list_len;
+        __u8 *raw = (__u8 *)cookie->peer_init + var_size2;
+
+        return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,
+                                      asoc->ep->base.bind_addr.port, gfp);
+}
+
+/* Lookup laddr in the bind address list of an association. */ 
+int sctp_assoc_lookup_laddr(struct sctp_association *asoc, 
+                            const union sctp_addr *laddr)
+{
+        int found;
+
+        sctp_read_lock(&asoc->base.addr_lock);
+        if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&
+            sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
+                                 sctp_sk(asoc->base.sk))) {
+                found = 1;
+                goto out;
+        }
+
+        found = 0;
+out:
+        sctp_read_unlock(&asoc->base.addr_lock);
+        return found;
+}
diff --git a/net/sctp/bind_addr.c b/net/sctp/bind_addr.c
new file mode 100644
index 000000000000..f90eadfb60a2
--- /dev/null
+++ b/net/sctp/bind_addr.c
@@ -0,0 +1,417 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2003
+ * Copyright (c) Cisco 1999,2000
+ * Copyright (c) Motorola 1999,2000,2001
+ * Copyright (c) La Monte H.P. Yarroll 2001
+ *
+ * This file is part of the SCTP kernel reference implementation.
+ *
+ * A collection class to handle the storage of transport addresses.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/in.h>
+#include <net/sock.h>
+#include <net/ipv6.h>
+#include <net/if_inet6.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for internal helpers. */
+static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *,
+                              sctp_scope_t scope, int gfp, int flags);
+static void sctp_bind_addr_clean(struct sctp_bind_addr *);
+
+/* First Level Abstractions. */
+
+/* Copy 'src' to 'dest' taking 'scope' into account.  Omit addresses
+ * in 'src' which have a broader scope than 'scope'.
+ */
+int sctp_bind_addr_copy(struct sctp_bind_addr *dest, 
+                        const struct sctp_bind_addr *src,
+                        sctp_scope_t scope, int gfp, int flags)
+{
+        struct sctp_sockaddr_entry *addr;
+        struct list_head *pos;
+        int error = 0;
+
+        /* All addresses share the same port.  */
+        dest->port = src->port;
+
+        /* Extract the addresses which are relevant for this scope.  */
+        list_for_each(pos, &src->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                error = sctp_copy_one_addr(dest, &addr->a, scope,
+                                           gfp, flags);
+                if (error < 0)
+                        goto out;
+        }
+
+        /* If there are no addresses matching the scope and
+         * this is global scope, try to get a link scope address, with
+         * the assumption that we must be sitting behind a NAT.
+         */
+        if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
+                list_for_each(pos, &src->address_list) {
+                        addr = list_entry(pos, struct sctp_sockaddr_entry,
+                                          list);
+                        error = sctp_copy_one_addr(dest, &addr->a,
+                                                   SCTP_SCOPE_LINK, gfp,
+                                                   flags);
+                        if (error < 0)
+                                goto out;
+                }
+        }
+
+out:
+        if (error)
+                sctp_bind_addr_clean(dest);
+
+        return error;
+}
+
+/* Initialize the SCTP_bind_addr structure for either an endpoint or
+ * an association.
+ */
+void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
+{
+        bp->malloced = 0;
+
+        INIT_LIST_HEAD(&bp->address_list);
+        bp->port = port;
+}
+
+/* Dispose of the address list. */
+static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
+{
+        struct sctp_sockaddr_entry *addr;
+        struct list_head *pos, *temp;
+
+        /* Empty the bind address list. */
+        list_for_each_safe(pos, temp, &bp->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                list_del(pos);
+                kfree(addr);
+                SCTP_DBG_OBJCNT_DEC(addr);
+        }
+}
+
+/* Dispose of an SCTP_bind_addr structure  */
+void sctp_bind_addr_free(struct sctp_bind_addr *bp)
+{
+        /* Empty the bind address list. */
+        sctp_bind_addr_clean(bp);
+
+        if (bp->malloced) {
+                kfree(bp);
+                SCTP_DBG_OBJCNT_DEC(bind_addr);
+        }
+}
+
+/* Add an address to the bind address list in the SCTP_bind_addr structure. */
+int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
+                       int gfp)
+{
+        struct sctp_sockaddr_entry *addr;
+
+        /* Add the address to the bind address list.  */
+        addr = t_new(struct sctp_sockaddr_entry, gfp);
+        if (!addr)
+                return -ENOMEM;
+
+        memcpy(&addr->a, new, sizeof(*new));
+
+        /* Fix up the port if it has not yet been set.
+         * Both v4 and v6 have the port at the same offset.
+         */
+        if (!addr->a.v4.sin_port)
+                addr->a.v4.sin_port = bp->port;
+
+        INIT_LIST_HEAD(&addr->list);
+        list_add_tail(&addr->list, &bp->address_list);
+        SCTP_DBG_OBJCNT_INC(addr);
+
+        return 0;
+}
+
+/* Delete an address from the bind address list in the SCTP_bind_addr
+ * structure.
+ */
+int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
+{
+        struct list_head *pos, *temp;
+        struct sctp_sockaddr_entry *addr;
+
+        list_for_each_safe(pos, temp, &bp->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
+                        /* Found the exact match. */
+                        list_del(pos);
+                        kfree(addr);
+                        SCTP_DBG_OBJCNT_DEC(addr);
+
+                        return 0;
+                }
+        }
+
+        return -EINVAL;
+}
+
+/* Create a network byte-order representation of all the addresses
+ * formated as SCTP parameters.
+ *
+ * The second argument is the return value for the length.
+ */
+union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
+                                         int *addrs_len, int gfp)
+{
+        union sctp_params addrparms;
+        union sctp_params retval;
+        int addrparms_len;
+        union sctp_addr_param rawaddr;
+        int len;
+        struct sctp_sockaddr_entry *addr;
+        struct list_head *pos;
+        struct sctp_af *af;
+
+        addrparms_len = 0;
+        len = 0;
+
+        /* Allocate enough memory at once. */
+        list_for_each(pos, &bp->address_list) {
+                len += sizeof(union sctp_addr_param);
+        }
+
+        /* Don't even bother embedding an address if there
+         * is only one.
+         */
+        if (len == sizeof(union sctp_addr_param)) {
+                retval.v = NULL;
+                goto end_raw;
+        }
+
+        retval.v = kmalloc(len, gfp);
+        if (!retval.v)
+                goto end_raw;
+
+        addrparms = retval;
+
+        list_for_each(pos, &bp->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                af = sctp_get_af_specific(addr->a.v4.sin_family);
+                len = af->to_addr_param(&addr->a, &rawaddr);
+                memcpy(addrparms.v, &rawaddr, len);
+                addrparms.v += len;
+                addrparms_len += len;
+        }
+
+end_raw:
+        *addrs_len = addrparms_len;
+        return retval;
+}
+
+/*
+ * Create an address list out of the raw address list format (IPv4 and IPv6
+ * address parameters).
+ */
+int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
+                           int addrs_len, __u16 port, int gfp)
+{
+        union sctp_addr_param *rawaddr;
+        struct sctp_paramhdr *param;
+        union sctp_addr addr;
+        int retval = 0;
+        int len;
+        struct sctp_af *af;
+
+        /* Convert the raw address to standard address format */
+        while (addrs_len) {
+                param = (struct sctp_paramhdr *)raw_addr_list;
+                rawaddr = (union sctp_addr_param *)raw_addr_list;
+
+                af = sctp_get_af_specific(param_type2af(param->type));
+                if (unlikely(!af)) {
+                        retval = -EINVAL;
+                        sctp_bind_addr_clean(bp);
+                        break;
+                }
+
+                af->from_addr_param(&addr, rawaddr, port, 0);
+                retval = sctp_add_bind_addr(bp, &addr, gfp);
+                if (retval) {
+                        /* Can't finish building the list, clean up. */
+                        sctp_bind_addr_clean(bp);
+                        break;
+                }
+
+                len = ntohs(param->length);
+                addrs_len -= len;
+                raw_addr_list += len;
+        }
+
+        return retval;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* Does this contain a specified address?  Allow wildcarding. */
+int sctp_bind_addr_match(struct sctp_bind_addr *bp, 
+                         const union sctp_addr *addr,
+                         struct sctp_sock *opt)
+{
+        struct sctp_sockaddr_entry *laddr;
+        struct list_head *pos;
+
+        list_for_each(pos, &bp->address_list) {
+                laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if (opt->pf->cmp_addr(&laddr->a, addr, opt))
+                        return 1;
+        }
+
+        return 0;
+}
+
+/* Find the first address in the bind address list that is not present in
+ * the addrs packed array.
+ */
+union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr   *bp,
+                                        const union sctp_addr   *addrs,
+                                        int                     addrcnt,
+                                        struct sctp_sock        *opt)
+{
+        struct sctp_sockaddr_entry      *laddr;
+        union sctp_addr                 *addr;
+        void                            *addr_buf;
+        struct sctp_af                  *af;
+        struct list_head                *pos;
+        int                             i;
+
+        list_for_each(pos, &bp->address_list) {
+                laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                
+                addr_buf = (union sctp_addr *)addrs;
+                for (i = 0; i < addrcnt; i++) {
+                        addr = (union sctp_addr *)addr_buf;
+                        af = sctp_get_af_specific(addr->v4.sin_family);
+                        if (!af) 
+                                return NULL;
+
+                        if (opt->pf->cmp_addr(&laddr->a, addr, opt))
+                                break;
+
+                        addr_buf += af->sockaddr_len;
+                }
+                if (i == addrcnt)
+                        return &laddr->a;
+        }
+
+        return NULL;
+}
+
+/* Copy out addresses from the global local address list. */
+static int sctp_copy_one_addr(struct sctp_bind_addr *dest, 
+                              union sctp_addr *addr,
+                              sctp_scope_t scope, int gfp, int flags)
+{
+        int error = 0;
+
+        if (sctp_is_any(addr)) {
+                error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
+        } else if (sctp_in_scope(addr, scope)) {
+                /* Now that the address is in scope, check to see if
+                 * the address type is supported by local sock as
+                 * well as the remote peer.
+                 */
+                if ((((AF_INET == addr->sa.sa_family) &&
+                      (flags & SCTP_ADDR4_PEERSUPP))) ||
+                    (((AF_INET6 == addr->sa.sa_family) &&
+                      (flags & SCTP_ADDR6_ALLOWED) &&
+                      (flags & SCTP_ADDR6_PEERSUPP))))
+                        error = sctp_add_bind_addr(dest, addr, gfp);
+        }
+
+        return error;
+}
+
+/* Is this a wildcard address?  */
+int sctp_is_any(const union sctp_addr *addr)
+{
+        struct sctp_af *af = sctp_get_af_specific(addr->sa.sa_family);
+        if (!af)
+                return 0;
+        return af->is_any(addr);
+}
+
+/* Is 'addr' valid for 'scope'?  */
+int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
+{
+        sctp_scope_t addr_scope = sctp_scope(addr);
+
+        /* The unusable SCTP addresses will not be considered with
+         * any defined scopes.
+         */
+        if (SCTP_SCOPE_UNUSABLE == addr_scope)
+                return 0;
+        /*
+         * For INIT and INIT-ACK address list, let L be the level of
+         * of requested destination address, sender and receiver
+         * SHOULD include all of its addresses with level greater
+         * than or equal to L.
+         */
+        if (addr_scope <= scope)
+                return 1;
+
+        return 0;
+}
+
+/********************************************************************
+ * 3rd Level Abstractions
+ ********************************************************************/
+
+/* What is the scope of 'addr'?  */
+sctp_scope_t sctp_scope(const union sctp_addr *addr)
+{
+        struct sctp_af *af;
+
+        af = sctp_get_af_specific(addr->sa.sa_family);
+        if (!af)
+                return SCTP_SCOPE_UNUSABLE;
+
+        return af->scope((union sctp_addr *)addr);
+}
diff --git a/net/sctp/chunk.c b/net/sctp/chunk.c
new file mode 100644
index 000000000000..0c2ab7885058
--- /dev/null
+++ b/net/sctp/chunk.c
@@ -0,0 +1,309 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * This file contains the code relating the the chunk abstraction.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/net.h>
+#include <linux/inet.h>
+#include <linux/skbuff.h>
+#include <net/sock.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* This file is mostly in anticipation of future work, but initially
+ * populate with fragment tracking for an outbound message.
+ */
+
+/* Initialize datamsg from memory. */
+static void sctp_datamsg_init(struct sctp_datamsg *msg)
+{
+        atomic_set(&msg->refcnt, 1);
+        msg->send_failed = 0;
+        msg->send_error = 0;
+        msg->can_abandon = 0;
+        msg->expires_at = 0;
+        INIT_LIST_HEAD(&msg->chunks);
+}
+
+/* Allocate and initialize datamsg. */
+SCTP_STATIC struct sctp_datamsg *sctp_datamsg_new(int gfp)
+{
+        struct sctp_datamsg *msg;
+        msg = kmalloc(sizeof(struct sctp_datamsg), gfp);
+        if (msg)
+                sctp_datamsg_init(msg);
+        SCTP_DBG_OBJCNT_INC(datamsg);
+        return msg;
+}
+
+/* Final destructruction of datamsg memory. */
+static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
+{
+        struct list_head *pos, *temp;
+        struct sctp_chunk *chunk;
+        struct sctp_sock *sp;
+        struct sctp_ulpevent *ev;
+        struct sctp_association *asoc = NULL;
+        int error = 0, notify;
+
+        /* If we failed, we may need to notify. */
+        notify = msg->send_failed ? -1 : 0;
+
+        /* Release all references. */
+        list_for_each_safe(pos, temp, &msg->chunks) {
+                list_del_init(pos);
+                chunk = list_entry(pos, struct sctp_chunk, frag_list);
+                /* Check whether we _really_ need to notify. */
+                if (notify < 0) {
+                        asoc = chunk->asoc;
+                        if (msg->send_error)
+                                error = msg->send_error;
+                        else
+                                error = asoc->outqueue.error;
+
+                        sp = sctp_sk(asoc->base.sk);
+                        notify = sctp_ulpevent_type_enabled(SCTP_SEND_FAILED,
+                                                            &sp->subscribe);
+                }
+
+                /* Generate a SEND FAILED event only if enabled. */
+                if (notify > 0) {
+                        int sent;
+                        if (chunk->has_tsn)
+                                sent = SCTP_DATA_SENT;
+                        else
+                                sent = SCTP_DATA_UNSENT;
+
+                        ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent,
+                                                            error, GFP_ATOMIC);
+                        if (ev)
+                                sctp_ulpq_tail_event(&asoc->ulpq, ev);
+                }
+
+                sctp_chunk_put(chunk);
+        }
+
+        SCTP_DBG_OBJCNT_DEC(datamsg);
+        kfree(msg);
+}
+
+/* Hold a reference. */
+static void sctp_datamsg_hold(struct sctp_datamsg *msg)
+{
+        atomic_inc(&msg->refcnt);
+}
+
+/* Release a reference. */
+void sctp_datamsg_put(struct sctp_datamsg *msg)
+{
+        if (atomic_dec_and_test(&msg->refcnt))
+                sctp_datamsg_destroy(msg);
+}
+
+/* Free a message.  Really just give up a reference, the
+ * really free happens in sctp_datamsg_destroy().
+ */
+void sctp_datamsg_free(struct sctp_datamsg *msg)
+{
+        sctp_datamsg_put(msg);
+}
+
+/* Hold on to all the fragments until all chunks have been sent. */
+void sctp_datamsg_track(struct sctp_chunk *chunk)
+{
+        sctp_chunk_hold(chunk);
+}
+
+/* Assign a chunk to this datamsg. */
+static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk)
+{
+        sctp_datamsg_hold(msg);
+        chunk->msg = msg;
+}
+
+
+/* A data chunk can have a maximum payload of (2^16 - 20).  Break
+ * down any such message into smaller chunks.  Opportunistically, fragment
+ * the chunks down to the current MTU constraints.  We may get refragmented
+ * later if the PMTU changes, but it is _much better_ to fragment immediately
+ * with a reasonable guess than always doing our fragmentation on the
+ * soft-interrupt.
+ */
+struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
+                                            struct sctp_sndrcvinfo *sinfo,
+                                            struct msghdr *msgh, int msg_len)
+{
+        int max, whole, i, offset, over, err;
+        int len, first_len;
+        struct sctp_chunk *chunk;
+        struct sctp_datamsg *msg;
+        struct list_head *pos, *temp;
+        __u8 frag;
+
+        msg = sctp_datamsg_new(GFP_KERNEL);
+        if (!msg)
+                return NULL;
+
+        /* Note: Calculate this outside of the loop, so that all fragments
+         * have the same expiration.
+         */
+        if (sinfo->sinfo_timetolive) {
+                /* sinfo_timetolive is in milliseconds */
+                msg->expires_at = jiffies +
+                                    msecs_to_jiffies(sinfo->sinfo_timetolive);
+                msg->can_abandon = 1;
+                SCTP_DEBUG_PRINTK("%s: msg:%p expires_at: %ld jiffies:%ld\n",
+                                  __FUNCTION__, msg, msg->expires_at, jiffies);
+        }
+
+        max = asoc->frag_point;
+
+        whole = 0;
+        first_len = max;
+
+        /* Encourage Cookie-ECHO bundling. */
+        if (asoc->state < SCTP_STATE_COOKIE_ECHOED) {
+                whole = msg_len / (max - SCTP_ARBITRARY_COOKIE_ECHO_LEN);
+
+                /* Account for the DATA to be bundled with the COOKIE-ECHO. */
+                if (whole) {
+                        first_len = max - SCTP_ARBITRARY_COOKIE_ECHO_LEN;
+                        msg_len -= first_len;
+                        whole = 1;
+                }
+        }
+
+        /* How many full sized?  How many bytes leftover? */
+        whole += msg_len / max;
+        over = msg_len % max;
+        offset = 0;
+
+        if ((whole > 1) || (whole && over))
+                SCTP_INC_STATS_USER(SCTP_MIB_FRAGUSRMSGS);
+
+        /* Create chunks for all the full sized DATA chunks. */
+        for (i=0, len=first_len; i < whole; i++) {
+                frag = SCTP_DATA_MIDDLE_FRAG;
+
+                if (0 == i)
+                        frag |= SCTP_DATA_FIRST_FRAG;
+
+                if ((i == (whole - 1)) && !over)
+                        frag |= SCTP_DATA_LAST_FRAG;
+
+                chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag, 0);
+
+                if (!chunk)
+                        goto errout;
+                err = sctp_user_addto_chunk(chunk, offset, len, msgh->msg_iov);
+                if (err < 0)
+                        goto errout;
+
+                offset += len;
+
+                /* Put the chunk->skb back into the form expected by send.  */
+                __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
+                           - (__u8 *)chunk->skb->data);
+
+                sctp_datamsg_assign(msg, chunk);
+                list_add_tail(&chunk->frag_list, &msg->chunks);
+
+                /* The first chunk, the first chunk was likely short
+                 * to allow bundling, so reset to full size.
+                 */
+                if (0 == i)
+                        len = max;
+        }
+
+        /* .. now the leftover bytes. */
+        if (over) {
+                if (!whole)
+                        frag = SCTP_DATA_NOT_FRAG;
+                else
+                        frag = SCTP_DATA_LAST_FRAG;
+
+                chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag, 0);
+
+                if (!chunk)
+                        goto errout;
+
+                err = sctp_user_addto_chunk(chunk, offset, over,msgh->msg_iov);
+
+                /* Put the chunk->skb back into the form expected by send.  */
+                __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
+                           - (__u8 *)chunk->skb->data);
+                if (err < 0)
+                        goto errout;
+
+                sctp_datamsg_assign(msg, chunk);
+                list_add_tail(&chunk->frag_list, &msg->chunks);
+        }
+
+        return msg;
+
+errout:
+        list_for_each_safe(pos, temp, &msg->chunks) {
+                list_del_init(pos);
+                chunk = list_entry(pos, struct sctp_chunk, frag_list);
+                sctp_chunk_free(chunk);
+        }
+        sctp_datamsg_free(msg);
+        return NULL;
+}
+
+/* Check whether this message has expired. */
+int sctp_chunk_abandoned(struct sctp_chunk *chunk)
+{
+        struct sctp_datamsg *msg = chunk->msg;
+
+        if (!msg->can_abandon)
+                return 0;
+
+        if (time_after(jiffies, msg->expires_at))
+                return 1;
+
+        return 0;
+}
+
+/* This chunk (and consequently entire message) has failed in its sending. */
+void sctp_chunk_fail(struct sctp_chunk *chunk, int error)
+{
+        chunk->msg->send_failed = 1;
+        chunk->msg->send_error = error;
+}
diff --git a/net/sctp/command.c b/net/sctp/command.c
new file mode 100644
index 000000000000..3ff804757f4a
--- /dev/null
+++ b/net/sctp/command.c
@@ -0,0 +1,81 @@
+/* SCTP kernel reference Implementation Copyright (C) 1999-2001
+ * Cisco, Motorola, and IBM
+ * Copyright 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions manipulate sctp command sequences.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Initialize a block of memory as a command sequence. */
+int sctp_init_cmd_seq(sctp_cmd_seq_t *seq)
+{
+        memset(seq, 0, sizeof(sctp_cmd_seq_t));
+        return 1;               /* We always succeed.  */
+}
+
+/* Add a command to a sctp_cmd_seq_t.
+ * Return 0 if the command sequence is full.
+ */
+int sctp_add_cmd(sctp_cmd_seq_t *seq, sctp_verb_t verb, sctp_arg_t obj)
+{
+        if (seq->next_free_slot >= SCTP_MAX_NUM_COMMANDS)
+                goto fail;
+
+        seq->cmds[seq->next_free_slot].verb = verb;
+        seq->cmds[seq->next_free_slot++].obj = obj;
+
+        return 1;
+
+fail:
+        return 0;
+}
+
+/* Return the next command structure in a sctp_cmd_seq.
+ * Returns NULL at the end of the sequence.
+ */
+sctp_cmd_t *sctp_next_cmd(sctp_cmd_seq_t *seq)
+{
+        sctp_cmd_t *retval = NULL;
+
+        if (seq->next_cmd < seq->next_free_slot)
+                retval = &seq->cmds[seq->next_cmd++];
+
+        return retval;
+}
+
diff --git a/net/sctp/crc32c.c b/net/sctp/crc32c.c
new file mode 100644
index 000000000000..31f05ec8e1d3
--- /dev/null
+++ b/net/sctp/crc32c.c
@@ -0,0 +1,220 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 International Business Machines, Corp.
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * SCTP Checksum functions
+ * 
+ * The SCTP reference implementation is free software; 
+ * you can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * The SCTP reference implementation is distributed in the hope that it 
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.  
+ * 
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ * 
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by: 
+ *    Dinakaran Joseph 
+ *    Jon Grimm <jgrimm@us.ibm.com>
+ *    Sridhar Samudrala <sri@us.ibm.com>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+/* The following code has been taken directly from
+ * draft-ietf-tsvwg-sctpcsum-03.txt
+ *
+ * The code has now been modified specifically for SCTP knowledge.
+ */
+
+#include <linux/types.h>
+#include <net/sctp/sctp.h>
+
+#define CRC32C_POLY 0x1EDC6F41
+#define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* Copyright 2001, D. Otis.  Use this program, code or tables    */
+/* extracted from it, as desired without restriction.            */
+/*                                                               */
+/* 32 Bit Reflected CRC table generation for SCTP.               */
+/* To accommodate serial byte data being shifted out least       */
+/* significant bit first, the table's 32 bit words are reflected */
+/* which flips both byte and bit MS and LS positions.  The CRC   */
+/* is calculated MS bits first from the perspective of the serial*/
+/* stream.  The x^32 term is implied and the x^0 term may also   */
+/* be shown as +1.  The polynomial code used is 0x1EDC6F41.      */
+/* Castagnoli93                                                  */
+/* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+  */
+/* x^11+x^10+x^9+x^8+x^6+x^0                                     */
+/* Guy Castagnoli Stefan Braeuer and Martin Herrman              */
+/* "Optimization of Cyclic Redundancy-Check Codes                */
+/* with 24 and 32 Parity Bits",                                  */
+/* IEEE Transactions on Communications, Vol.41, No.6, June 1993  */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+static const __u32 crc_c[256] = {
+        0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
+        0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+        0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
+        0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+        0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
+        0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+        0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
+        0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+        0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
+        0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+        0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
+        0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+        0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
+        0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+        0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
+        0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+        0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
+        0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+        0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
+        0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+        0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
+        0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+        0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
+        0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+        0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
+        0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+        0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
+        0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+        0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
+        0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+        0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
+        0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+        0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
+        0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+        0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
+        0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+        0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
+        0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+        0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
+        0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+        0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
+        0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+        0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
+        0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+        0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
+        0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+        0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
+        0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+        0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
+        0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+        0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
+        0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+        0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
+        0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+        0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
+        0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+        0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
+        0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+        0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
+        0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+        0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
+        0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+        0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
+        0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
+};
+     
+__u32 sctp_start_cksum(__u8 *buffer, __u16 length)
+{
+        __u32 crc32 = ~(__u32) 0;
+        __u32 i;
+
+        /* Optimize this routine to be SCTP specific, knowing how
+         * to skip the checksum field of the SCTP header.
+         */
+
+        /* Calculate CRC up to the checksum. */
+        for (i = 0; i < (sizeof(struct sctphdr) - sizeof(__u32)); i++)
+                CRC32C(crc32, buffer[i]);
+
+        /* Skip checksum field of the header. */
+        for (i = 0; i < sizeof(__u32); i++)
+                CRC32C(crc32, 0);
+
+        /* Calculate the rest of the CRC. */
+        for (i = sizeof(struct sctphdr); i < length ; i++)
+                CRC32C(crc32, buffer[i]);
+
+        return crc32;
+}
+
+__u32 sctp_update_cksum(__u8 *buffer, __u16 length, __u32 crc32)
+{
+        __u32 i;
+
+        for (i = 0; i < length ; i++)
+                CRC32C(crc32, buffer[i]);
+
+        return crc32;
+}
+
+__u32 sctp_update_copy_cksum(__u8 *to, __u8 *from, __u16 length, __u32 crc32)
+{
+        __u32 i;
+        __u32 *_to = (__u32 *)to;
+        __u32 *_from = (__u32 *)from;
+        
+        for (i = 0; i < (length/4); i++) {
+                _to[i] = _from[i];
+                CRC32C(crc32, from[i*4]);
+                CRC32C(crc32, from[i*4+1]);
+                CRC32C(crc32, from[i*4+2]);
+                CRC32C(crc32, from[i*4+3]);     
+        }
+
+        return crc32;
+}
+
+__u32 sctp_end_cksum(__u32 crc32)
+{
+        __u32 result;
+        __u8 byte0, byte1, byte2, byte3;
+
+        result = ~crc32;
+
+        /*  result  now holds the negated polynomial remainder;
+         *  since the table and algorithm is "reflected" [williams95].
+         *  That is,  result has the same value as if we mapped the message
+         *  to a polyomial, computed the host-bit-order polynomial
+         *  remainder, performed final negation, then did an end-for-end
+         *  bit-reversal.
+         *  Note that a 32-bit bit-reversal is identical to four inplace
+         *  8-bit reversals followed by an end-for-end byteswap.
+         *  In other words, the bytes of each bit are in the right order,
+         *  but the bytes have been byteswapped.  So we now do an explicit
+         *  byteswap.  On a little-endian machine, this byteswap and
+         *  the final ntohl cancel out and could be elided.
+         */
+        byte0 = result & 0xff;
+        byte1 = (result>>8) & 0xff;
+        byte2 = (result>>16) & 0xff;
+        byte3 = (result>>24) & 0xff;
+
+        crc32 = ((byte0 << 24) |
+                 (byte1 << 16) |
+                 (byte2 << 8)  |
+                 byte3);
+        return crc32;
+}
diff --git a/net/sctp/debug.c b/net/sctp/debug.c
new file mode 100644
index 000000000000..aa8340373af7
--- /dev/null
+++ b/net/sctp/debug.c
@@ -0,0 +1,191 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * This file is part of the implementation of the add-IP extension,
+ * based on <draft-ietf-tsvwg-addip-sctp-02.txt> June 29, 2001,
+ * for the SCTP kernel reference Implementation.
+ * 
+ * This file converts numerical ID value to alphabetical names for SCTP
+ * terms such as chunk type, parameter time, event type, etc.
+ * 
+ * The SCTP reference implementation is free software; 
+ * you can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * The SCTP reference implementation is distributed in the hope that it 
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.  
+ * 
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ * 
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by: 
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <net/sctp/sctp.h>
+
+#if SCTP_DEBUG
+int sctp_debug_flag = 1;        /* Initially enable DEBUG */
+#endif  /* SCTP_DEBUG */
+
+/* These are printable forms of Chunk ID's from section 3.1.  */
+static const char *sctp_cid_tbl[SCTP_NUM_BASE_CHUNK_TYPES] = {
+        "DATA",
+        "INIT",
+        "INIT_ACK",
+        "SACK",
+        "HEARTBEAT",
+        "HEARTBEAT_ACK",
+        "ABORT",
+        "SHUTDOWN",
+        "SHUTDOWN_ACK",
+        "ERROR",
+        "COOKIE_ECHO",
+        "COOKIE_ACK",
+        "ECN_ECNE",
+        "ECN_CWR",
+        "SHUTDOWN_COMPLETE",
+};
+
+/* Lookup "chunk type" debug name. */
+const char *sctp_cname(const sctp_subtype_t cid)
+{
+        if (cid.chunk < 0)
+                return "illegal chunk id";
+        if (cid.chunk <= SCTP_CID_BASE_MAX)
+                return sctp_cid_tbl[cid.chunk];
+        
+        switch (cid.chunk) {
+        case SCTP_CID_ASCONF:
+                return "ASCONF";
+
+        case SCTP_CID_ASCONF_ACK:
+                return "ASCONF_ACK";
+
+        case SCTP_CID_FWD_TSN:
+                return "FWD_TSN";
+
+        default:
+                return "unknown chunk";
+        };
+        return "unknown chunk";
+}
+
+/* These are printable forms of the states.  */
+const char *sctp_state_tbl[SCTP_STATE_NUM_STATES] = {
+        "STATE_EMPTY",
+        "STATE_CLOSED",
+        "STATE_COOKIE_WAIT",
+        "STATE_COOKIE_ECHOED",
+        "STATE_ESTABLISHED",
+        "STATE_SHUTDOWN_PENDING",
+        "STATE_SHUTDOWN_SENT",
+        "STATE_SHUTDOWN_RECEIVED",
+        "STATE_SHUTDOWN_ACK_SENT",
+};
+
+/* Events that could change the state of an association.  */
+const char *sctp_evttype_tbl[] = {
+        "EVENT_T_unknown",
+        "EVENT_T_CHUNK",
+        "EVENT_T_TIMEOUT",
+        "EVENT_T_OTHER",
+        "EVENT_T_PRIMITIVE"
+};
+
+/* Return value of a state function */
+const char *sctp_status_tbl[] = {
+        "DISPOSITION_DISCARD",
+        "DISPOSITION_CONSUME",
+        "DISPOSITION_NOMEM",
+        "DISPOSITION_DELETE_TCB",
+        "DISPOSITION_ABORT",
+        "DISPOSITION_VIOLATION",
+        "DISPOSITION_NOT_IMPL",
+        "DISPOSITION_ERROR",
+        "DISPOSITION_BUG"
+};
+
+/* Printable forms of primitives */
+static const char *sctp_primitive_tbl[SCTP_NUM_PRIMITIVE_TYPES] = {
+        "PRIMITIVE_ASSOCIATE",
+        "PRIMITIVE_SHUTDOWN",
+        "PRIMITIVE_ABORT",
+        "PRIMITIVE_SEND",
+        "PRIMITIVE_REQUESTHEARTBEAT",
+};
+
+/* Lookup primitive debug name. */
+const char *sctp_pname(const sctp_subtype_t id)
+{
+        if (id.primitive < 0)
+                return "illegal primitive";
+        if (id.primitive <= SCTP_EVENT_PRIMITIVE_MAX)
+                return sctp_primitive_tbl[id.primitive];
+        return "unknown_primitive";
+}
+
+static const char *sctp_other_tbl[] = {
+        "NO_PENDING_TSN",
+        "ICMP_PROTO_UNREACH",
+};
+
+/* Lookup "other" debug name. */
+const char *sctp_oname(const sctp_subtype_t id)
+{
+        if (id.other < 0)
+                return "illegal 'other' event";
+        if (id.other <= SCTP_EVENT_OTHER_MAX)
+                return sctp_other_tbl[id.other];
+        return "unknown 'other' event";
+}
+
+static const char *sctp_timer_tbl[] = {
+        "TIMEOUT_NONE",
+        "TIMEOUT_T1_COOKIE",
+        "TIMEOUT_T1_INIT",
+        "TIMEOUT_T2_SHUTDOWN",
+        "TIMEOUT_T3_RTX",
+        "TIMEOUT_T4_RTO",
+        "TIMEOUT_T5_SHUTDOWN_GUARD",
+        "TIMEOUT_HEARTBEAT",
+        "TIMEOUT_SACK",
+        "TIMEOUT_AUTOCLOSE",
+};
+
+/* Lookup timer debug name. */
+const char *sctp_tname(const sctp_subtype_t id)
+{
+        if (id.timeout < 0)
+                return "illegal 'timer' event";
+        if (id.timeout <= SCTP_EVENT_TIMEOUT_MAX)
+                return sctp_timer_tbl[id.timeout];
+        return "unknown_timer";
+}
diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c
new file mode 100644
index 000000000000..544b75077dbd
--- /dev/null
+++ b/net/sctp/endpointola.c
@@ -0,0 +1,389 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2002 International Business Machines, Corp.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * This abstraction represents an SCTP endpoint.
+ *
+ * This file is part of the implementation of the add-IP extension,
+ * based on <draft-ietf-tsvwg-addip-sctp-02.txt> June 29, 2001,
+ * for the SCTP kernel reference Implementation.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ *    Jon Grimm <jgrimm@austin.ibm.com>
+ *    Daisy Chang <daisyc@us.ibm.com>
+ *    Dajiang Zhang <dajiang.zhang@nokia.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/in.h>
+#include <linux/random.h>       /* get_random_bytes() */
+#include <linux/crypto.h>
+#include <net/sock.h>
+#include <net/ipv6.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for internal helpers. */
+static void sctp_endpoint_bh_rcv(struct sctp_endpoint *ep);
+
+/*
+ * Initialize the base fields of the endpoint structure.
+ */
+static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
+                                                struct sock *sk, int gfp)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+        memset(ep, 0, sizeof(struct sctp_endpoint));
+
+        /* Initialize the base structure. */
+        /* What type of endpoint are we?  */
+        ep->base.type = SCTP_EP_TYPE_SOCKET;
+
+        /* Initialize the basic object fields. */
+        atomic_set(&ep->base.refcnt, 1);
+        ep->base.dead = 0;
+        ep->base.malloced = 1;
+
+        /* Create an input queue.  */
+        sctp_inq_init(&ep->base.inqueue);
+
+        /* Set its top-half handler */
+        sctp_inq_set_th_handler(&ep->base.inqueue,
+                                (void (*)(void *))sctp_endpoint_bh_rcv, ep);
+
+        /* Initialize the bind addr area */
+        sctp_bind_addr_init(&ep->base.bind_addr, 0);
+        rwlock_init(&ep->base.addr_lock);
+
+        /* Remember who we are attached to.  */
+        ep->base.sk = sk;
+        sock_hold(ep->base.sk);
+
+        /* Create the lists of associations.  */
+        INIT_LIST_HEAD(&ep->asocs);
+
+        /* Set up the base timeout information.  */
+        ep->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
+                SCTP_DEFAULT_TIMEOUT_T1_COOKIE;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
+                SCTP_DEFAULT_TIMEOUT_T1_INIT;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] =
+                msecs_to_jiffies(sp->rtoinfo.srto_initial);
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = 0;
+
+        /* sctpimpguide-05 Section 2.12.2
+         * If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the
+         * recommended value of 5 times 'RTO.Max'.
+         */
+        ep->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
+                = 5 * msecs_to_jiffies(sp->rtoinfo.srto_max);
+
+        ep->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] =
+                SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
+                SCTP_DEFAULT_TIMEOUT_SACK;
+        ep->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] =
+                sp->autoclose * HZ;
+
+        /* Use SCTP specific send buffer space queues.  */
+        sk->sk_write_space = sctp_write_space;
+        sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
+
+        /* Initialize the secret key used with cookie. */
+        get_random_bytes(&ep->secret_key[0], SCTP_SECRET_SIZE);
+        ep->last_key = ep->current_key = 0;
+        ep->key_changed_at = jiffies;
+
+        ep->debug_name = "unnamedEndpoint";
+        return ep;
+}
+
+/* Create a sctp_endpoint with all that boring stuff initialized.
+ * Returns NULL if there isn't enough memory.
+ */
+struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, int gfp)
+{
+        struct sctp_endpoint *ep;
+
+        /* Build a local endpoint. */
+        ep = t_new(struct sctp_endpoint, gfp);
+        if (!ep)
+                goto fail;
+        if (!sctp_endpoint_init(ep, sk, gfp))
+                goto fail_init;
+        ep->base.malloced = 1;
+        SCTP_DBG_OBJCNT_INC(ep);
+        return ep;
+
+fail_init:
+        kfree(ep);
+fail:
+        return NULL;
+}
+
+/* Add an association to an endpoint.  */
+void sctp_endpoint_add_asoc(struct sctp_endpoint *ep,
+                            struct sctp_association *asoc)
+{
+        struct sock *sk = ep->base.sk;
+
+        /* Now just add it to our list of asocs */
+        list_add_tail(&asoc->asocs, &ep->asocs);
+
+        /* Increment the backlog value for a TCP-style listening socket. */
+        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
+                sk->sk_ack_backlog++;
+}
+
+/* Free the endpoint structure.  Delay cleanup until
+ * all users have released their reference count on this structure.
+ */
+void sctp_endpoint_free(struct sctp_endpoint *ep)
+{
+        ep->base.dead = 1;
+        sctp_endpoint_put(ep);
+}
+
+/* Final destructor for endpoint.  */
+static void sctp_endpoint_destroy(struct sctp_endpoint *ep)
+{
+        SCTP_ASSERT(ep->base.dead, "Endpoint is not dead", return);
+
+        ep->base.sk->sk_state = SCTP_SS_CLOSED;
+
+        /* Unlink this endpoint, so we can't find it again! */
+        sctp_unhash_endpoint(ep);
+
+        /* Free up the HMAC transform. */
+        if (sctp_sk(ep->base.sk)->hmac)
+                sctp_crypto_free_tfm(sctp_sk(ep->base.sk)->hmac);
+
+        /* Cleanup. */
+        sctp_inq_free(&ep->base.inqueue);
+        sctp_bind_addr_free(&ep->base.bind_addr);
+
+        /* Remove and free the port */
+        if (sctp_sk(ep->base.sk)->bind_hash)
+                sctp_put_port(ep->base.sk);
+
+        /* Give up our hold on the sock. */
+        if (ep->base.sk)
+                sock_put(ep->base.sk);
+
+        /* Finally, free up our memory. */
+        if (ep->base.malloced) {
+                kfree(ep);
+                SCTP_DBG_OBJCNT_DEC(ep);
+        }
+}
+
+/* Hold a reference to an endpoint. */
+void sctp_endpoint_hold(struct sctp_endpoint *ep)
+{
+        atomic_inc(&ep->base.refcnt);
+}
+
+/* Release a reference to an endpoint and clean up if there are
+ * no more references.
+ */
+void sctp_endpoint_put(struct sctp_endpoint *ep)
+{
+        if (atomic_dec_and_test(&ep->base.refcnt))
+                sctp_endpoint_destroy(ep);
+}
+
+/* Is this the endpoint we are looking for?  */
+struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *ep,
+                                               const union sctp_addr *laddr)
+{
+        struct sctp_endpoint *retval;
+
+        sctp_read_lock(&ep->base.addr_lock);
+        if (ep->base.bind_addr.port == laddr->v4.sin_port) {
+                if (sctp_bind_addr_match(&ep->base.bind_addr, laddr,
+                                         sctp_sk(ep->base.sk))) {
+                        retval = ep;
+                        goto out;
+                }
+        }
+
+        retval = NULL;
+
+out:
+        sctp_read_unlock(&ep->base.addr_lock);
+        return retval;
+}
+
+/* Find the association that goes with this chunk.
+ * We do a linear search of the associations for this endpoint.
+ * We return the matching transport address too.
+ */
+static struct sctp_association *__sctp_endpoint_lookup_assoc(
+        const struct sctp_endpoint *ep,
+        const union sctp_addr *paddr,
+        struct sctp_transport **transport)
+{
+        int rport;
+        struct sctp_association *asoc;
+        struct list_head *pos;
+
+        rport = paddr->v4.sin_port;
+
+        list_for_each(pos, &ep->asocs) {
+                asoc = list_entry(pos, struct sctp_association, asocs);
+                if (rport == asoc->peer.port) {
+                        sctp_read_lock(&asoc->base.addr_lock);
+                        *transport = sctp_assoc_lookup_paddr(asoc, paddr);
+                        sctp_read_unlock(&asoc->base.addr_lock);
+
+                        if (*transport)
+                                return asoc;
+                }
+        }
+
+        *transport = NULL;
+        return NULL;
+}
+
+/* Lookup association on an endpoint based on a peer address.  BH-safe.  */
+struct sctp_association *sctp_endpoint_lookup_assoc(
+        const struct sctp_endpoint *ep,
+        const union sctp_addr *paddr,
+        struct sctp_transport **transport)
+{
+        struct sctp_association *asoc;
+
+        sctp_local_bh_disable();
+        asoc = __sctp_endpoint_lookup_assoc(ep, paddr, transport);
+        sctp_local_bh_enable();
+
+        return asoc;
+}
+
+/* Look for any peeled off association from the endpoint that matches the
+ * given peer address.
+ */
+int sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep,
+                                const union sctp_addr *paddr)
+{
+        struct list_head *pos;
+        struct sctp_sockaddr_entry *addr;
+        struct sctp_bind_addr *bp;
+
+        sctp_read_lock(&ep->base.addr_lock);
+        bp = &ep->base.bind_addr;
+        list_for_each(pos, &bp->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if (sctp_has_association(&addr->a, paddr)) {
+                        sctp_read_unlock(&ep->base.addr_lock);
+                        return 1;
+                }
+        }
+        sctp_read_unlock(&ep->base.addr_lock);
+
+        return 0;
+}
+
+/* Do delayed input processing.  This is scheduled by sctp_rcv().
+ * This may be called on BH or task time.
+ */
+static void sctp_endpoint_bh_rcv(struct sctp_endpoint *ep)
+{
+        struct sctp_association *asoc;
+        struct sock *sk;
+        struct sctp_transport *transport;
+        struct sctp_chunk *chunk;
+        struct sctp_inq *inqueue;
+        sctp_subtype_t subtype;
+        sctp_state_t state;
+        int error = 0;
+
+        if (ep->base.dead)
+                return;
+
+        asoc = NULL;
+        inqueue = &ep->base.inqueue;
+        sk = ep->base.sk;
+
+        while (NULL != (chunk = sctp_inq_pop(inqueue))) {
+                subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
+
+                /* We might have grown an association since last we
+                 * looked, so try again.
+                 *
+                 * This happens when we've just processed our
+                 * COOKIE-ECHO chunk.
+                 */
+                if (NULL == chunk->asoc) {
+                        asoc = sctp_endpoint_lookup_assoc(ep,
+                                                          sctp_source(chunk),
+                                                          &transport);
+                        chunk->asoc = asoc;
+                        chunk->transport = transport;
+                }
+
+                state = asoc ? asoc->state : SCTP_STATE_CLOSED;
+
+                /* Remember where the last DATA chunk came from so we
+                 * know where to send the SACK.
+                 */
+                if (asoc && sctp_chunk_is_data(chunk))
+                        asoc->peer.last_data_from = chunk->transport;
+                else
+                        SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS);
+
+                if (chunk->transport)
+                        chunk->transport->last_time_heard = jiffies;
+
+                error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype, state,
+                                   ep, asoc, chunk, GFP_ATOMIC);
+
+                if (error && chunk)
+                        chunk->pdiscard = 1;
+
+                /* Check to see if the endpoint is freed in response to
+                 * the incoming chunk. If so, get out of the while loop.
+                 */
+                if (!sctp_sk(sk)->ep)
+                        break;
+        }
+}
diff --git a/net/sctp/input.c b/net/sctp/input.c
new file mode 100644
index 000000000000..b719a77d66b4
--- /dev/null
+++ b/net/sctp/input.c
@@ -0,0 +1,913 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 International Business Machines, Corp.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions handle all input from the IP layer into SCTP.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ *    Xingang Guo <xingang.guo@intel.com>
+ *    Jon Grimm <jgrimm@us.ibm.com>
+ *    Hui Huang <hui.huang@nokia.com>
+ *    Daisy Chang <daisyc@us.ibm.com>
+ *    Sridhar Samudrala <sri@us.ibm.com>
+ *    Ardelle Fan <ardelle.fan@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/list.h> /* For struct list_head */
+#include <linux/socket.h>
+#include <linux/ip.h>
+#include <linux/time.h> /* For struct timeval */
+#include <net/ip.h>
+#include <net/icmp.h>
+#include <net/snmp.h>
+#include <net/sock.h>
+#include <net/xfrm.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for internal helpers. */
+static int sctp_rcv_ootb(struct sk_buff *);
+static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
+                                      const union sctp_addr *laddr,
+                                      const union sctp_addr *paddr,
+                                      struct sctp_transport **transportp);
+static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr);
+static struct sctp_association *__sctp_lookup_association(
+                                        const union sctp_addr *local,
+                                        const union sctp_addr *peer,
+                                        struct sctp_transport **pt);
+
+
+/* Calculate the SCTP checksum of an SCTP packet.  */
+static inline int sctp_rcv_checksum(struct sk_buff *skb)
+{
+        struct sctphdr *sh;
+        __u32 cmp, val;
+        struct sk_buff *list = skb_shinfo(skb)->frag_list;
+
+        sh = (struct sctphdr *) skb->h.raw;
+        cmp = ntohl(sh->checksum);
+
+        val = sctp_start_cksum((__u8 *)sh, skb_headlen(skb));
+
+        for (; list; list = list->next)
+                val = sctp_update_cksum((__u8 *)list->data, skb_headlen(list),
+                                        val);
+
+        val = sctp_end_cksum(val);
+
+        if (val != cmp) {
+                /* CRC failure, dump it. */
+                SCTP_INC_STATS_BH(SCTP_MIB_CHECKSUMERRORS);
+                return -1;
+        }
+        return 0;
+}
+
+/* The free routine for skbuffs that sctp receives */
+static void sctp_rfree(struct sk_buff *skb)
+{
+        atomic_sub(sizeof(struct sctp_chunk),&skb->sk->sk_rmem_alloc);
+        sock_rfree(skb);
+}
+
+/* The ownership wrapper routine to do receive buffer accounting */
+static void sctp_rcv_set_owner_r(struct sk_buff *skb, struct sock *sk)
+{
+        skb_set_owner_r(skb,sk);
+        skb->destructor = sctp_rfree;
+        atomic_add(sizeof(struct sctp_chunk),&sk->sk_rmem_alloc);
+}
+
+/*
+ * This is the routine which IP calls when receiving an SCTP packet.
+ */
+int sctp_rcv(struct sk_buff *skb)
+{
+        struct sock *sk;
+        struct sctp_association *asoc;
+        struct sctp_endpoint *ep = NULL;
+        struct sctp_ep_common *rcvr;
+        struct sctp_transport *transport = NULL;
+        struct sctp_chunk *chunk;
+        struct sctphdr *sh;
+        union sctp_addr src;
+        union sctp_addr dest;
+        int family;
+        struct sctp_af *af;
+        int ret = 0;
+
+        if (skb->pkt_type!=PACKET_HOST)
+                goto discard_it;
+
+        SCTP_INC_STATS_BH(SCTP_MIB_INSCTPPACKS);
+
+        sh = (struct sctphdr *) skb->h.raw;
+
+        /* Pull up the IP and SCTP headers. */
+        __skb_pull(skb, skb->h.raw - skb->data);
+        if (skb->len < sizeof(struct sctphdr))
+                goto discard_it;
+        if (sctp_rcv_checksum(skb) < 0)
+                goto discard_it;
+
+        skb_pull(skb, sizeof(struct sctphdr));
+
+        /* Make sure we at least have chunk headers worth of data left. */
+        if (skb->len < sizeof(struct sctp_chunkhdr))
+                goto discard_it;
+
+        family = ipver2af(skb->nh.iph->version);
+        af = sctp_get_af_specific(family);
+        if (unlikely(!af))
+                goto discard_it;
+
+        /* Initialize local addresses for lookups. */
+        af->from_skb(&src, skb, 1);
+        af->from_skb(&dest, skb, 0);
+
+        /* If the packet is to or from a non-unicast address,
+         * silently discard the packet.
+         *
+         * This is not clearly defined in the RFC except in section
+         * 8.4 - OOTB handling.  However, based on the book "Stream Control
+         * Transmission Protocol" 2.1, "It is important to note that the
+         * IP address of an SCTP transport address must be a routable
+         * unicast address.  In other words, IP multicast addresses and
+         * IP broadcast addresses cannot be used in an SCTP transport
+         * address."
+         */
+        if (!af->addr_valid(&src, NULL) || !af->addr_valid(&dest, NULL))
+                goto discard_it;
+
+        asoc = __sctp_rcv_lookup(skb, &src, &dest, &transport);
+
+        /*
+         * RFC 2960, 8.4 - Handle "Out of the blue" Packets.
+         * An SCTP packet is called an "out of the blue" (OOTB)
+         * packet if it is correctly formed, i.e., passed the
+         * receiver's checksum check, but the receiver is not
+         * able to identify the association to which this
+         * packet belongs.
+         */
+        if (!asoc) {
+                ep = __sctp_rcv_lookup_endpoint(&dest);
+                if (sctp_rcv_ootb(skb)) {
+                        SCTP_INC_STATS_BH(SCTP_MIB_OUTOFBLUES);
+                        goto discard_release;
+                }
+        }
+
+        /* Retrieve the common input handling substructure. */
+        rcvr = asoc ? &asoc->base : &ep->base;
+        sk = rcvr->sk;
+
+        if ((sk) && (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)) {
+                goto discard_release;
+        }
+
+
+        /* SCTP seems to always need a timestamp right now (FIXME) */
+        if (skb->stamp.tv_sec == 0) {
+                do_gettimeofday(&skb->stamp);
+                sock_enable_timestamp(sk); 
+        }
+
+        if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
+                goto discard_release;
+
+        ret = sk_filter(sk, skb, 1);
+        if (ret)
+                goto discard_release;
+
+        /* Create an SCTP packet structure. */
+        chunk = sctp_chunkify(skb, asoc, sk);
+        if (!chunk) {
+                ret = -ENOMEM;
+                goto discard_release;
+        }
+
+        sctp_rcv_set_owner_r(skb,sk);
+
+        /* Remember what endpoint is to handle this packet. */
+        chunk->rcvr = rcvr;
+
+        /* Remember the SCTP header. */
+        chunk->sctp_hdr = sh;
+
+        /* Set the source and destination addresses of the incoming chunk.  */
+        sctp_init_addrs(chunk, &src, &dest);
+
+        /* Remember where we came from.  */
+        chunk->transport = transport;
+
+        /* Acquire access to the sock lock. Note: We are safe from other
+         * bottom halves on this lock, but a user may be in the lock too,
+         * so check if it is busy.
+         */
+        sctp_bh_lock_sock(sk);
+
+        if (sock_owned_by_user(sk))
+                sk_add_backlog(sk, (struct sk_buff *) chunk);
+        else
+                sctp_backlog_rcv(sk, (struct sk_buff *) chunk);
+
+        /* Release the sock and any reference counts we took in the
+         * lookup calls.
+         */
+        sctp_bh_unlock_sock(sk);
+        if (asoc)
+                sctp_association_put(asoc);
+        else
+                sctp_endpoint_put(ep);
+        sock_put(sk);
+        return ret;
+
+discard_it:
+        kfree_skb(skb);
+        return ret;
+
+discard_release:
+        /* Release any structures we may be holding. */
+        if (asoc) {
+                sock_put(asoc->base.sk);
+                sctp_association_put(asoc);
+        } else {
+                sock_put(ep->base.sk);
+                sctp_endpoint_put(ep);
+        }
+
+        goto discard_it;
+}
+
+/* Handle second half of inbound skb processing.  If the sock was busy,
+ * we may have need to delay processing until later when the sock is
+ * released (on the backlog).   If not busy, we call this routine
+ * directly from the bottom half.
+ */
+int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
+{
+        struct sctp_chunk *chunk;
+        struct sctp_inq *inqueue;
+
+        /* One day chunk will live inside the skb, but for
+         * now this works.
+         */
+        chunk = (struct sctp_chunk *) skb;
+        inqueue = &chunk->rcvr->inqueue;
+
+        sctp_inq_push(inqueue, chunk);
+        return 0;
+}
+
+/* Handle icmp frag needed error. */
+void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
+                           struct sctp_transport *t, __u32 pmtu)
+{
+        if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) {
+                printk(KERN_WARNING "%s: Reported pmtu %d too low, "
+                       "using default minimum of %d\n", __FUNCTION__, pmtu,
+                       SCTP_DEFAULT_MINSEGMENT);
+                pmtu = SCTP_DEFAULT_MINSEGMENT;
+        }
+
+        if (!sock_owned_by_user(sk) && t && (t->pmtu != pmtu)) {
+                t->pmtu = pmtu;
+                sctp_assoc_sync_pmtu(asoc);
+                sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
+        }
+}
+
+/*
+ * SCTP Implementer's Guide, 2.37 ICMP handling procedures
+ *
+ * ICMP8) If the ICMP code is a "Unrecognized next header type encountered"
+ *        or a "Protocol Unreachable" treat this message as an abort
+ *        with the T bit set.
+ *
+ * This function sends an event to the state machine, which will abort the
+ * association.
+ *
+ */
+void sctp_icmp_proto_unreachable(struct sock *sk,
+                           struct sctp_endpoint *ep,
+                           struct sctp_association *asoc,
+                           struct sctp_transport *t)
+{
+        SCTP_DEBUG_PRINTK("%s\n",  __FUNCTION__);
+
+        sctp_do_sm(SCTP_EVENT_T_OTHER,
+                   SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
+                   asoc->state, asoc->ep, asoc, NULL,
+                   GFP_ATOMIC);
+
+}
+
+/* Common lookup code for icmp/icmpv6 error handler. */
+struct sock *sctp_err_lookup(int family, struct sk_buff *skb,
+                             struct sctphdr *sctphdr,
+                             struct sctp_endpoint **epp,
+                             struct sctp_association **app,
+                             struct sctp_transport **tpp)
+{
+        union sctp_addr saddr;
+        union sctp_addr daddr;
+        struct sctp_af *af;
+        struct sock *sk = NULL;
+        struct sctp_endpoint *ep = NULL;
+        struct sctp_association *asoc = NULL;
+        struct sctp_transport *transport = NULL;
+
+        *app = NULL; *epp = NULL; *tpp = NULL;
+
+        af = sctp_get_af_specific(family);
+        if (unlikely(!af)) {
+                return NULL;
+        }
+
+        /* Initialize local addresses for lookups. */
+        af->from_skb(&saddr, skb, 1);
+        af->from_skb(&daddr, skb, 0);
+
+        /* Look for an association that matches the incoming ICMP error
+         * packet.
+         */
+        asoc = __sctp_lookup_association(&saddr, &daddr, &transport);
+        if (!asoc) {
+                /* If there is no matching association, see if it matches any
+                 * endpoint. This may happen for an ICMP error generated in
+                 * response to an INIT_ACK.
+                 */
+                ep = __sctp_rcv_lookup_endpoint(&daddr);
+                if (!ep) {
+                        return NULL;
+                }
+        }
+
+        if (asoc) {
+                sk = asoc->base.sk;
+
+                if (ntohl(sctphdr->vtag) != asoc->c.peer_vtag) {
+                        ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
+                        goto out;
+                }
+        } else
+                sk = ep->base.sk;
+
+        sctp_bh_lock_sock(sk);
+
+        /* If too many ICMPs get dropped on busy
+         * servers this needs to be solved differently.
+         */
+        if (sock_owned_by_user(sk))
+                NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
+
+        *epp = ep;
+        *app = asoc;
+        *tpp = transport;
+        return sk;
+
+out:
+        sock_put(sk);
+        if (asoc)
+                sctp_association_put(asoc);
+        if (ep)
+                sctp_endpoint_put(ep);
+        return NULL;
+}
+
+/* Common cleanup code for icmp/icmpv6 error handler. */
+void sctp_err_finish(struct sock *sk, struct sctp_endpoint *ep,
+                     struct sctp_association *asoc)
+{
+        sctp_bh_unlock_sock(sk);
+        sock_put(sk);
+        if (asoc)
+                sctp_association_put(asoc);
+        if (ep)
+                sctp_endpoint_put(ep);
+}
+
+/*
+ * This routine is called by the ICMP module when it gets some
+ * sort of error condition.  If err < 0 then the socket should
+ * be closed and the error returned to the user.  If err > 0
+ * it's just the icmp type << 8 | icmp code.  After adjustment
+ * header points to the first 8 bytes of the sctp header.  We need
+ * to find the appropriate port.
+ *
+ * The locking strategy used here is very "optimistic". When
+ * someone else accesses the socket the ICMP is just dropped
+ * and for some paths there is no check at all.
+ * A more general error queue to queue errors for later handling
+ * is probably better.
+ *
+ */
+void sctp_v4_err(struct sk_buff *skb, __u32 info)
+{
+        struct iphdr *iph = (struct iphdr *)skb->data;
+        struct sctphdr *sh = (struct sctphdr *)(skb->data + (iph->ihl <<2));
+        int type = skb->h.icmph->type;
+        int code = skb->h.icmph->code;
+        struct sock *sk;
+        struct sctp_endpoint *ep;
+        struct sctp_association *asoc;
+        struct sctp_transport *transport;
+        struct inet_sock *inet;
+        char *saveip, *savesctp;
+        int err;
+
+        if (skb->len < ((iph->ihl << 2) + 8)) {
+                ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
+                return;
+        }
+
+        /* Fix up skb to look at the embedded net header. */
+        saveip = skb->nh.raw;
+        savesctp  = skb->h.raw;
+        skb->nh.iph = iph;
+        skb->h.raw = (char *)sh;
+        sk = sctp_err_lookup(AF_INET, skb, sh, &ep, &asoc, &transport);
+        /* Put back, the original pointers. */
+        skb->nh.raw = saveip;
+        skb->h.raw = savesctp;
+        if (!sk) {
+                ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
+                return;
+        }
+        /* Warning:  The sock lock is held.  Remember to call
+         * sctp_err_finish!
+         */
+
+        switch (type) {
+        case ICMP_PARAMETERPROB:
+                err = EPROTO;
+                break;
+        case ICMP_DEST_UNREACH:
+                if (code > NR_ICMP_UNREACH)
+                        goto out_unlock;
+
+                /* PMTU discovery (RFC1191) */
+                if (ICMP_FRAG_NEEDED == code) {
+                        sctp_icmp_frag_needed(sk, asoc, transport, info);
+                        goto out_unlock;
+                }
+                else {
+                        if (ICMP_PROT_UNREACH == code) {
+                                sctp_icmp_proto_unreachable(sk, ep, asoc,
+                                                            transport);
+                                goto out_unlock;
+                        }
+                }
+                err = icmp_err_convert[code].errno;
+                break;
+        case ICMP_TIME_EXCEEDED:
+                /* Ignore any time exceeded errors due to fragment reassembly
+                 * timeouts.
+                 */
+                if (ICMP_EXC_FRAGTIME == code)
+                        goto out_unlock;
+
+                err = EHOSTUNREACH;
+                break;
+        default:
+                goto out_unlock;
+        }
+
+        inet = inet_sk(sk);
+        if (!sock_owned_by_user(sk) && inet->recverr) {
+                sk->sk_err = err;
+                sk->sk_error_report(sk);
+        } else {  /* Only an error on timeout */
+                sk->sk_err_soft = err;
+        }
+
+out_unlock:
+        sctp_err_finish(sk, ep, asoc);
+}
+
+/*
+ * RFC 2960, 8.4 - Handle "Out of the blue" Packets.
+ *
+ * This function scans all the chunks in the OOTB packet to determine if
+ * the packet should be discarded right away.  If a response might be needed
+ * for this packet, or, if further processing is possible, the packet will
+ * be queued to a proper inqueue for the next phase of handling.
+ *
+ * Output:
+ * Return 0 - If further processing is needed.
+ * Return 1 - If the packet can be discarded right away.
+ */
+int sctp_rcv_ootb(struct sk_buff *skb)
+{
+        sctp_chunkhdr_t *ch;
+        __u8 *ch_end;
+        sctp_errhdr_t *err;
+
+        ch = (sctp_chunkhdr_t *) skb->data;
+        ch_end = ((__u8 *) ch) + WORD_ROUND(ntohs(ch->length));
+
+        /* Scan through all the chunks in the packet.  */
+        while (ch_end > (__u8 *)ch && ch_end < skb->tail) {
+
+                /* RFC 8.4, 2) If the OOTB packet contains an ABORT chunk, the
+                 * receiver MUST silently discard the OOTB packet and take no
+                 * further action.
+                 */
+                if (SCTP_CID_ABORT == ch->type)
+                        goto discard;
+
+                /* RFC 8.4, 6) If the packet contains a SHUTDOWN COMPLETE
+                 * chunk, the receiver should silently discard the packet
+                 * and take no further action.
+                 */
+                if (SCTP_CID_SHUTDOWN_COMPLETE == ch->type)
+                        goto discard;
+
+                /* RFC 8.4, 7) If the packet contains a "Stale cookie" ERROR
+                 * or a COOKIE ACK the SCTP Packet should be silently
+                 * discarded.
+                 */
+                if (SCTP_CID_COOKIE_ACK == ch->type)
+                        goto discard;
+
+                if (SCTP_CID_ERROR == ch->type) {
+                        sctp_walk_errors(err, ch) {
+                                if (SCTP_ERROR_STALE_COOKIE == err->cause)
+                                        goto discard;
+                        }
+                }
+
+                ch = (sctp_chunkhdr_t *) ch_end;
+                ch_end = ((__u8 *) ch) + WORD_ROUND(ntohs(ch->length));
+        }
+
+        return 0;
+
+discard:
+        return 1;
+}
+
+/* Insert endpoint into the hash table.  */
+static void __sctp_hash_endpoint(struct sctp_endpoint *ep)
+{
+        struct sctp_ep_common **epp;
+        struct sctp_ep_common *epb;
+        struct sctp_hashbucket *head;
+
+        epb = &ep->base;
+
+        epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
+        head = &sctp_ep_hashtable[epb->hashent];
+
+        sctp_write_lock(&head->lock);
+        epp = &head->chain;
+        epb->next = *epp;
+        if (epb->next)
+                (*epp)->pprev = &epb->next;
+        *epp = epb;
+        epb->pprev = epp;
+        sctp_write_unlock(&head->lock);
+}
+
+/* Add an endpoint to the hash. Local BH-safe. */
+void sctp_hash_endpoint(struct sctp_endpoint *ep)
+{
+        sctp_local_bh_disable();
+        __sctp_hash_endpoint(ep);
+        sctp_local_bh_enable();
+}
+
+/* Remove endpoint from the hash table.  */
+static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+
+        epb = &ep->base;
+
+        epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
+
+        head = &sctp_ep_hashtable[epb->hashent];
+
+        sctp_write_lock(&head->lock);
+
+        if (epb->pprev) {
+                if (epb->next)
+                        epb->next->pprev = epb->pprev;
+                *epb->pprev = epb->next;
+                epb->pprev = NULL;
+        }
+
+        sctp_write_unlock(&head->lock);
+}
+
+/* Remove endpoint from the hash.  Local BH-safe. */
+void sctp_unhash_endpoint(struct sctp_endpoint *ep)
+{
+        sctp_local_bh_disable();
+        __sctp_unhash_endpoint(ep);
+        sctp_local_bh_enable();
+}
+
+/* Look up an endpoint. */
+static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+        struct sctp_endpoint *ep;
+        int hash;
+
+        hash = sctp_ep_hashfn(laddr->v4.sin_port);
+        head = &sctp_ep_hashtable[hash];
+        read_lock(&head->lock);
+        for (epb = head->chain; epb; epb = epb->next) {
+                ep = sctp_ep(epb);
+                if (sctp_endpoint_is_match(ep, laddr))
+                        goto hit;
+        }
+
+        ep = sctp_sk((sctp_get_ctl_sock()))->ep;
+        epb = &ep->base;
+
+hit:
+        sctp_endpoint_hold(ep);
+        sock_hold(epb->sk);
+        read_unlock(&head->lock);
+        return ep;
+}
+
+/* Insert association into the hash table.  */
+static void __sctp_hash_established(struct sctp_association *asoc)
+{
+        struct sctp_ep_common **epp;
+        struct sctp_ep_common *epb;
+        struct sctp_hashbucket *head;
+
+        epb = &asoc->base;
+
+        /* Calculate which chain this entry will belong to. */
+        epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port, asoc->peer.port);
+
+        head = &sctp_assoc_hashtable[epb->hashent];
+
+        sctp_write_lock(&head->lock);
+        epp = &head->chain;
+        epb->next = *epp;
+        if (epb->next)
+                (*epp)->pprev = &epb->next;
+        *epp = epb;
+        epb->pprev = epp;
+        sctp_write_unlock(&head->lock);
+}
+
+/* Add an association to the hash. Local BH-safe. */
+void sctp_hash_established(struct sctp_association *asoc)
+{
+        sctp_local_bh_disable();
+        __sctp_hash_established(asoc);
+        sctp_local_bh_enable();
+}
+
+/* Remove association from the hash table.  */
+static void __sctp_unhash_established(struct sctp_association *asoc)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+
+        epb = &asoc->base;
+
+        epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port,
+                                         asoc->peer.port);
+
+        head = &sctp_assoc_hashtable[epb->hashent];
+
+        sctp_write_lock(&head->lock);
+
+        if (epb->pprev) {
+                if (epb->next)
+                        epb->next->pprev = epb->pprev;
+                *epb->pprev = epb->next;
+                epb->pprev = NULL;
+        }
+
+        sctp_write_unlock(&head->lock);
+}
+
+/* Remove association from the hash table.  Local BH-safe. */
+void sctp_unhash_established(struct sctp_association *asoc)
+{
+        sctp_local_bh_disable();
+        __sctp_unhash_established(asoc);
+        sctp_local_bh_enable();
+}
+
+/* Look up an association. */
+static struct sctp_association *__sctp_lookup_association(
+                                        const union sctp_addr *local,
+                                        const union sctp_addr *peer,
+                                        struct sctp_transport **pt)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+        struct sctp_association *asoc;
+        struct sctp_transport *transport;
+        int hash;
+
+        /* Optimize here for direct hit, only listening connections can
+         * have wildcards anyways.
+         */
+        hash = sctp_assoc_hashfn(local->v4.sin_port, peer->v4.sin_port);
+        head = &sctp_assoc_hashtable[hash];
+        read_lock(&head->lock);
+        for (epb = head->chain; epb; epb = epb->next) {
+                asoc = sctp_assoc(epb);
+                transport = sctp_assoc_is_match(asoc, local, peer);
+                if (transport)
+                        goto hit;
+        }
+
+        read_unlock(&head->lock);
+
+        return NULL;
+
+hit:
+        *pt = transport;
+        sctp_association_hold(asoc);
+        sock_hold(epb->sk);
+        read_unlock(&head->lock);
+        return asoc;
+}
+
+/* Look up an association. BH-safe. */
+SCTP_STATIC
+struct sctp_association *sctp_lookup_association(const union sctp_addr *laddr,
+                                                 const union sctp_addr *paddr,
+                                            struct sctp_transport **transportp)
+{
+        struct sctp_association *asoc;
+
+        sctp_local_bh_disable();
+        asoc = __sctp_lookup_association(laddr, paddr, transportp);
+        sctp_local_bh_enable();
+
+        return asoc;
+}
+
+/* Is there an association matching the given local and peer addresses? */
+int sctp_has_association(const union sctp_addr *laddr,
+                         const union sctp_addr *paddr)
+{
+        struct sctp_association *asoc;
+        struct sctp_transport *transport;
+
+        if ((asoc = sctp_lookup_association(laddr, paddr, &transport))) {
+                sock_put(asoc->base.sk);
+                sctp_association_put(asoc);
+                return 1;
+        }
+
+        return 0;
+}
+
+/*
+ * SCTP Implementors Guide, 2.18 Handling of address
+ * parameters within the INIT or INIT-ACK.
+ *
+ * D) When searching for a matching TCB upon reception of an INIT
+ *    or INIT-ACK chunk the receiver SHOULD use not only the
+ *    source address of the packet (containing the INIT or
+ *    INIT-ACK) but the receiver SHOULD also use all valid
+ *    address parameters contained within the chunk.
+ *
+ * 2.18.3 Solution description
+ *
+ * This new text clearly specifies to an implementor the need
+ * to look within the INIT or INIT-ACK. Any implementation that
+ * does not do this, may not be able to establish associations
+ * in certain circumstances.
+ *
+ */
+static struct sctp_association *__sctp_rcv_init_lookup(struct sk_buff *skb,
+        const union sctp_addr *laddr, struct sctp_transport **transportp)
+{
+        struct sctp_association *asoc;
+        union sctp_addr addr;
+        union sctp_addr *paddr = &addr;
+        struct sctphdr *sh = (struct sctphdr *) skb->h.raw;
+        sctp_chunkhdr_t *ch;
+        union sctp_params params;
+        sctp_init_chunk_t *init;
+        struct sctp_transport *transport;
+        struct sctp_af *af;
+
+        ch = (sctp_chunkhdr_t *) skb->data;
+
+        /* If this is INIT/INIT-ACK look inside the chunk too. */
+        switch (ch->type) {
+        case SCTP_CID_INIT:
+        case SCTP_CID_INIT_ACK:
+                break;
+        default:
+                return NULL;
+        }
+
+        /* The code below will attempt to walk the chunk and extract
+         * parameter information.  Before we do that, we need to verify
+         * that the chunk length doesn't cause overflow.  Otherwise, we'll
+         * walk off the end.
+         */
+        if (WORD_ROUND(ntohs(ch->length)) > skb->len)
+                return NULL;
+
+        /*
+         * This code will NOT touch anything inside the chunk--it is
+         * strictly READ-ONLY.
+         *
+         * RFC 2960 3  SCTP packet Format
+         *
+         * Multiple chunks can be bundled into one SCTP packet up to
+         * the MTU size, except for the INIT, INIT ACK, and SHUTDOWN
+         * COMPLETE chunks.  These chunks MUST NOT be bundled with any
+         * other chunk in a packet.  See Section 6.10 for more details
+         * on chunk bundling.
+         */
+
+        /* Find the start of the TLVs and the end of the chunk.  This is
+         * the region we search for address parameters.
+         */
+        init = (sctp_init_chunk_t *)skb->data;
+
+        /* Walk the parameters looking for embedded addresses. */
+        sctp_walk_params(params, init, init_hdr.params) {
+
+                /* Note: Ignoring hostname addresses. */
+                af = sctp_get_af_specific(param_type2af(params.p->type));
+                if (!af)
+                        continue;
+
+                af->from_addr_param(paddr, params.addr, ntohs(sh->source), 0);
+
+                asoc = __sctp_lookup_association(laddr, paddr, &transport);
+                if (asoc)
+                        return asoc;
+        }
+
+        return NULL;
+}
+
+/* Lookup an association for an inbound skb. */
+static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
+                                      const union sctp_addr *paddr,
+                                      const union sctp_addr *laddr,
+                                      struct sctp_transport **transportp)
+{
+        struct sctp_association *asoc;
+
+        asoc = __sctp_lookup_association(laddr, paddr, transportp);
+
+        /* Further lookup for INIT/INIT-ACK packets.
+         * SCTP Implementors Guide, 2.18 Handling of address
+         * parameters within the INIT or INIT-ACK.
+         */
+        if (!asoc)
+                asoc = __sctp_rcv_init_lookup(skb, laddr, transportp);
+
+        return asoc;
+}
diff --git a/net/sctp/inqueue.c b/net/sctp/inqueue.c
new file mode 100644
index 000000000000..cedf4351556c
--- /dev/null
+++ b/net/sctp/inqueue.c
@@ -0,0 +1,204 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2002 International Business Machines, Corp.
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * These functions are the methods for accessing the SCTP inqueue.
+ *
+ * An SCTP inqueue is a queue into which you push SCTP packets
+ * (which might be bundles or fragments of chunks) and out of which you
+ * pop SCTP whole chunks.
+ * 
+ * The SCTP reference implementation is free software; 
+ * you can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * The SCTP reference implementation is distributed in the hope that it 
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.  
+ * 
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ * 
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by: 
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+#include <linux/interrupt.h>
+
+/* Initialize an SCTP inqueue.  */
+void sctp_inq_init(struct sctp_inq *queue)
+{
+        skb_queue_head_init(&queue->in);
+        queue->in_progress = NULL;
+
+        /* Create a task for delivering data.  */
+        INIT_WORK(&queue->immediate, NULL, NULL);
+
+        queue->malloced = 0;
+}
+
+/* Release the memory associated with an SCTP inqueue.  */
+void sctp_inq_free(struct sctp_inq *queue)
+{
+        struct sctp_chunk *chunk;
+
+        /* Empty the queue.  */
+        while ((chunk = (struct sctp_chunk *) skb_dequeue(&queue->in)) != NULL)
+                sctp_chunk_free(chunk);
+
+        /* If there is a packet which is currently being worked on,
+         * free it as well.
+         */
+        if (queue->in_progress)
+                sctp_chunk_free(queue->in_progress);
+
+        if (queue->malloced) {
+                /* Dump the master memory segment.  */
+                kfree(queue);
+        }
+}
+
+/* Put a new packet in an SCTP inqueue.
+ * We assume that packet->sctp_hdr is set and in host byte order.
+ */
+void sctp_inq_push(struct sctp_inq *q, struct sctp_chunk *packet)
+{
+        /* Directly call the packet handling routine. */
+
+        /* We are now calling this either from the soft interrupt
+         * or from the backlog processing.
+         * Eventually, we should clean up inqueue to not rely
+         * on the BH related data structures.
+         */
+        skb_queue_tail(&(q->in), (struct sk_buff *) packet);
+        q->immediate.func(q->immediate.data);
+}
+
+/* Extract a chunk from an SCTP inqueue.
+ *
+ * WARNING:  If you need to put the chunk on another queue, you need to
+ * make a shallow copy (clone) of it.
+ */
+struct sctp_chunk *sctp_inq_pop(struct sctp_inq *queue)
+{
+        struct sctp_chunk *chunk;
+        sctp_chunkhdr_t *ch = NULL;
+
+        /* The assumption is that we are safe to process the chunks
+         * at this time.
+         */
+
+        if ((chunk = queue->in_progress)) {
+                /* There is a packet that we have been working on.
+                 * Any post processing work to do before we move on?
+                 */
+                if (chunk->singleton ||
+                    chunk->end_of_packet ||
+                    chunk->pdiscard) {
+                        sctp_chunk_free(chunk);
+                        chunk = queue->in_progress = NULL;
+                } else {
+                        /* Nothing to do. Next chunk in the packet, please. */
+                        ch = (sctp_chunkhdr_t *) chunk->chunk_end;
+
+                        /* Force chunk->skb->data to chunk->chunk_end.  */
+                        skb_pull(chunk->skb,
+                                 chunk->chunk_end - chunk->skb->data);
+                }
+        }
+
+        /* Do we need to take the next packet out of the queue to process? */
+        if (!chunk) {
+                /* Is the queue empty?  */
+                if (skb_queue_empty(&queue->in))
+                        return NULL;
+
+                chunk = queue->in_progress =
+                        (struct sctp_chunk *) skb_dequeue(&queue->in);
+
+                /* This is the first chunk in the packet.  */
+                chunk->singleton = 1;
+                ch = (sctp_chunkhdr_t *) chunk->skb->data;
+        }
+
+        chunk->chunk_hdr = ch;
+        chunk->chunk_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
+        /* In the unlikely case of an IP reassembly, the skb could be
+         * non-linear. If so, update chunk_end so that it doesn't go past
+         * the skb->tail.
+         */
+        if (unlikely(skb_is_nonlinear(chunk->skb))) {
+                if (chunk->chunk_end > chunk->skb->tail)
+                        chunk->chunk_end = chunk->skb->tail;
+        }
+        skb_pull(chunk->skb, sizeof(sctp_chunkhdr_t));
+        chunk->subh.v = NULL; /* Subheader is no longer valid.  */
+
+        if (chunk->chunk_end < chunk->skb->tail) {
+                /* This is not a singleton */
+                chunk->singleton = 0;
+        } else if (chunk->chunk_end > chunk->skb->tail) {
+                /* RFC 2960, Section 6.10  Bundling
+                 *
+                 * Partial chunks MUST NOT be placed in an SCTP packet.
+                 * If the receiver detects a partial chunk, it MUST drop
+                 * the chunk.  
+                 *
+                 * Since the end of the chunk is past the end of our buffer
+                 * (which contains the whole packet, we can freely discard
+                 * the whole packet.
+                 */
+                sctp_chunk_free(chunk);
+                chunk = queue->in_progress = NULL;
+
+                return NULL;
+        } else {
+                /* We are at the end of the packet, so mark the chunk
+                 * in case we need to send a SACK.
+                 */
+                chunk->end_of_packet = 1;
+        }
+
+        SCTP_DEBUG_PRINTK("+++sctp_inq_pop+++ chunk %p[%s],"
+                          " length %d, skb->len %d\n",chunk,
+                          sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)),
+                          ntohs(chunk->chunk_hdr->length), chunk->skb->len);
+        return chunk;
+}
+
+/* Set a top-half handler.
+ *
+ * Originally, we the top-half handler was scheduled as a BH.  We now
+ * call the handler directly in sctp_inq_push() at a time that
+ * we know we are lock safe.
+ * The intent is that this routine will pull stuff out of the
+ * inqueue and process it.
+ */
+void sctp_inq_set_th_handler(struct sctp_inq *q,
+                                 void (*callback)(void *), void *arg)
+{
+        INIT_WORK(&q->immediate, callback, arg);
+}
+
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
new file mode 100644
index 000000000000..e42c74e3ec1e
--- /dev/null
+++ b/net/sctp/ipv6.c
@@ -0,0 +1,1013 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2002, 2004
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ * Copyright (c) 2002-2003 Intel Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * SCTP over IPv6.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Le Yanqun             <yanqun.le@nokia.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *
+ * Based on:
+ *      linux/net/ipv6/tcp_ipv6.c
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/socket.h>
+#include <linux/sockios.h>
+#include <linux/net.h>
+#include <linux/sched.h>
+#include <linux/in.h>
+#include <linux/in6.h>
+#include <linux/netdevice.h>
+#include <linux/init.h>
+#include <linux/ipsec.h>
+
+#include <linux/ipv6.h>
+#include <linux/icmpv6.h>
+#include <linux/random.h>
+#include <linux/seq_file.h>
+
+#include <net/protocol.h>
+#include <net/tcp.h>
+#include <net/ndisc.h>
+#include <net/ipv6.h>
+#include <net/transp_v6.h>
+#include <net/addrconf.h>
+#include <net/ip6_route.h>
+#include <net/inet_common.h>
+#include <net/inet_ecn.h>
+#include <net/sctp/sctp.h>
+
+#include <asm/uaccess.h>
+
+extern int sctp_inetaddr_event(struct notifier_block *, unsigned long, void *);
+static struct notifier_block sctp_inet6addr_notifier = {
+        .notifier_call = sctp_inetaddr_event,
+};
+
+/* ICMP error handler. */
+SCTP_STATIC void sctp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
+                             int type, int code, int offset, __u32 info)
+{
+        struct inet6_dev *idev;
+        struct ipv6hdr *iph = (struct ipv6hdr *)skb->data;
+        struct sctphdr *sh = (struct sctphdr *)(skb->data + offset);
+        struct sock *sk;
+        struct sctp_endpoint *ep;
+        struct sctp_association *asoc;
+        struct sctp_transport *transport;
+        struct ipv6_pinfo *np;
+        char *saveip, *savesctp;
+        int err;
+
+        idev = in6_dev_get(skb->dev);
+
+        /* Fix up skb to look at the embedded net header. */
+        saveip = skb->nh.raw;
+        savesctp  = skb->h.raw;
+        skb->nh.ipv6h = iph;
+        skb->h.raw = (char *)sh;
+        sk = sctp_err_lookup(AF_INET6, skb, sh, &ep, &asoc, &transport);
+        /* Put back, the original pointers. */
+        skb->nh.raw = saveip;
+        skb->h.raw = savesctp;
+        if (!sk) {
+                ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
+                goto out;
+        }
+
+        /* Warning:  The sock lock is held.  Remember to call
+         * sctp_err_finish!
+         */
+
+        switch (type) {
+        case ICMPV6_PKT_TOOBIG:
+                sctp_icmp_frag_needed(sk, asoc, transport, ntohl(info));
+                goto out_unlock;
+        case ICMPV6_PARAMPROB:
+                if (ICMPV6_UNK_NEXTHDR == code) {
+                        sctp_icmp_proto_unreachable(sk, ep, asoc, transport);
+                        goto out_unlock;
+                }
+                break;
+        default:
+                break;
+        }
+
+        np = inet6_sk(sk);
+        icmpv6_err_convert(type, code, &err);
+        if (!sock_owned_by_user(sk) && np->recverr) {
+                sk->sk_err = err;
+                sk->sk_error_report(sk);
+        } else {  /* Only an error on timeout */
+                sk->sk_err_soft = err;
+        }
+
+out_unlock:
+        sctp_err_finish(sk, ep, asoc);
+out:
+        if (likely(idev != NULL))
+                in6_dev_put(idev);
+}
+
+/* Based on tcp_v6_xmit() in tcp_ipv6.c. */
+static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport,
+                        int ipfragok)
+{
+        struct sock *sk = skb->sk;
+        struct ipv6_pinfo *np = inet6_sk(sk);
+        struct flowi fl;
+
+        memset(&fl, 0, sizeof(fl));
+
+        fl.proto = sk->sk_protocol;
+
+        /* Fill in the dest address from the route entry passed with the skb
+         * and the source address from the transport.
+         */
+        ipv6_addr_copy(&fl.fl6_dst, &transport->ipaddr.v6.sin6_addr);
+        ipv6_addr_copy(&fl.fl6_src, &transport->saddr.v6.sin6_addr);
+
+        fl.fl6_flowlabel = np->flow_label;
+        IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
+        if (ipv6_addr_type(&fl.fl6_src) & IPV6_ADDR_LINKLOCAL)
+                fl.oif = transport->saddr.v6.sin6_scope_id;
+        else
+                fl.oif = sk->sk_bound_dev_if;
+        fl.fl_ip_sport = inet_sk(sk)->sport;
+        fl.fl_ip_dport = transport->ipaddr.v6.sin6_port;
+
+        if (np->opt && np->opt->srcrt) {
+                struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
+                ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
+        }
+
+        SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, "
+                          "src:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x "
+                          "dst:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                          __FUNCTION__, skb, skb->len,
+                          NIP6(fl.fl6_src), NIP6(fl.fl6_dst));
+
+        SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
+
+        return ip6_xmit(sk, skb, &fl, np->opt, ipfragok);
+}
+
+/* Returns the dst cache entry for the given source and destination ip
+ * addresses.
+ */
+static struct dst_entry *sctp_v6_get_dst(struct sctp_association *asoc,
+                                         union sctp_addr *daddr,
+                                         union sctp_addr *saddr)
+{
+        struct dst_entry *dst;
+        struct flowi fl;
+
+        memset(&fl, 0, sizeof(fl));
+        ipv6_addr_copy(&fl.fl6_dst, &daddr->v6.sin6_addr);
+        if (ipv6_addr_type(&daddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
+                fl.oif = daddr->v6.sin6_scope_id;
+        
+
+        SCTP_DEBUG_PRINTK("%s: DST=%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x ",
+                          __FUNCTION__, NIP6(fl.fl6_dst));
+
+        if (saddr) {
+                ipv6_addr_copy(&fl.fl6_src, &saddr->v6.sin6_addr);
+                SCTP_DEBUG_PRINTK(
+                        "SRC=%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x - ",
+                        NIP6(fl.fl6_src));
+        }
+
+        dst = ip6_route_output(NULL, &fl);
+        if (dst) {
+                struct rt6_info *rt;
+                rt = (struct rt6_info *)dst;
+                SCTP_DEBUG_PRINTK(
+                        "rt6_dst:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x "
+                        "rt6_src:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                        NIP6(rt->rt6i_dst.addr), NIP6(rt->rt6i_src.addr));
+        } else {
+                SCTP_DEBUG_PRINTK("NO ROUTE\n");
+        }
+
+        return dst;
+}
+
+/* Returns the number of consecutive initial bits that match in the 2 ipv6
+ * addresses.
+ */
+static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
+                                         union sctp_addr *s2)
+{
+        struct in6_addr *a1 = &s1->v6.sin6_addr;
+        struct in6_addr *a2 = &s2->v6.sin6_addr;
+        int i, j;
+
+        for (i = 0; i < 4 ; i++) {
+                __u32 a1xora2;
+
+                a1xora2 = a1->s6_addr32[i] ^ a2->s6_addr32[i];
+
+                if ((j = fls(ntohl(a1xora2))))
+                        return (i * 32 + 32 - j);
+        }
+
+        return (i*32);
+}
+
+/* Fills in the source address(saddr) based on the destination address(daddr)
+ * and asoc's bind address list.
+ */
+static void sctp_v6_get_saddr(struct sctp_association *asoc,
+                              struct dst_entry *dst,
+                              union sctp_addr *daddr,
+                              union sctp_addr *saddr)
+{
+        struct sctp_bind_addr *bp;
+        rwlock_t *addr_lock;
+        struct sctp_sockaddr_entry *laddr;
+        struct list_head *pos;
+        sctp_scope_t scope;
+        union sctp_addr *baddr = NULL;
+        __u8 matchlen = 0;
+        __u8 bmatchlen;
+
+        SCTP_DEBUG_PRINTK("%s: asoc:%p dst:%p "
+                          "daddr:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x ",
+                          __FUNCTION__, asoc, dst, NIP6(daddr->v6.sin6_addr));
+
+        if (!asoc) {
+                ipv6_get_saddr(dst, &daddr->v6.sin6_addr,&saddr->v6.sin6_addr);
+                SCTP_DEBUG_PRINTK("saddr from ipv6_get_saddr: "
+                                  "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                                  NIP6(saddr->v6.sin6_addr));
+                return;
+        }
+
+        scope = sctp_scope(daddr);
+
+        bp = &asoc->base.bind_addr;
+        addr_lock = &asoc->base.addr_lock;
+
+        /* Go through the bind address list and find the best source address
+         * that matches the scope of the destination address.
+         */
+        sctp_read_lock(addr_lock);
+        list_for_each(pos, &bp->address_list) {
+                laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if ((laddr->a.sa.sa_family == AF_INET6) &&
+                    (scope <= sctp_scope(&laddr->a))) {
+                        bmatchlen = sctp_v6_addr_match_len(daddr, &laddr->a);
+                        if (!baddr || (matchlen < bmatchlen)) {
+                                baddr = &laddr->a;
+                                matchlen = bmatchlen;
+                        }
+                }
+        }
+
+        if (baddr) {
+                memcpy(saddr, baddr, sizeof(union sctp_addr));
+                SCTP_DEBUG_PRINTK("saddr: "
+                                  "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                                  NIP6(saddr->v6.sin6_addr));
+        } else {
+                printk(KERN_ERR "%s: asoc:%p Could not find a valid source "
+                       "address for the "
+                       "dest:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                       __FUNCTION__, asoc, NIP6(daddr->v6.sin6_addr));
+        }
+
+        sctp_read_unlock(addr_lock);
+}
+
+/* Make a copy of all potential local addresses. */
+static void sctp_v6_copy_addrlist(struct list_head *addrlist,
+                                  struct net_device *dev)
+{
+        struct inet6_dev *in6_dev;
+        struct inet6_ifaddr *ifp;
+        struct sctp_sockaddr_entry *addr;
+
+        read_lock(&addrconf_lock);
+        if ((in6_dev = __in6_dev_get(dev)) == NULL) {
+                read_unlock(&addrconf_lock);
+                return;
+        }
+
+        read_lock(&in6_dev->lock);
+        for (ifp = in6_dev->addr_list; ifp; ifp = ifp->if_next) {
+                /* Add the address to the local list.  */
+                addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
+                if (addr) {
+                        addr->a.v6.sin6_family = AF_INET6;
+                        addr->a.v6.sin6_port = 0;
+                        addr->a.v6.sin6_addr = ifp->addr;
+                        addr->a.v6.sin6_scope_id = dev->ifindex;
+                        INIT_LIST_HEAD(&addr->list);
+                        list_add_tail(&addr->list, addrlist);
+                }
+        }
+
+        read_unlock(&in6_dev->lock);
+        read_unlock(&addrconf_lock);
+}
+
+/* Initialize a sockaddr_storage from in incoming skb. */
+static void sctp_v6_from_skb(union sctp_addr *addr,struct sk_buff *skb,
+                             int is_saddr)
+{
+        void *from;
+        __u16 *port;
+        struct sctphdr *sh;
+
+        port = &addr->v6.sin6_port;
+        addr->v6.sin6_family = AF_INET6;
+        addr->v6.sin6_flowinfo = 0; /* FIXME */
+        addr->v6.sin6_scope_id = ((struct inet6_skb_parm *)skb->cb)->iif;
+
+        sh = (struct sctphdr *) skb->h.raw;
+        if (is_saddr) {
+                *port  = ntohs(sh->source);
+                from = &skb->nh.ipv6h->saddr;
+        } else {
+                *port = ntohs(sh->dest);
+                from = &skb->nh.ipv6h->daddr;
+        }
+        ipv6_addr_copy(&addr->v6.sin6_addr, from);
+}
+
+/* Initialize an sctp_addr from a socket. */
+static void sctp_v6_from_sk(union sctp_addr *addr, struct sock *sk)
+{
+        addr->v6.sin6_family = AF_INET6;
+        addr->v6.sin6_port = inet_sk(sk)->num;
+        addr->v6.sin6_addr = inet6_sk(sk)->rcv_saddr;
+}
+
+/* Initialize sk->sk_rcv_saddr from sctp_addr. */
+static void sctp_v6_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
+{
+        if (addr->sa.sa_family == AF_INET && sctp_sk(sk)->v4mapped) {
+                inet6_sk(sk)->rcv_saddr.s6_addr32[0] = 0;
+                inet6_sk(sk)->rcv_saddr.s6_addr32[1] = 0;
+                inet6_sk(sk)->rcv_saddr.s6_addr32[2] = htonl(0x0000ffff);
+                inet6_sk(sk)->rcv_saddr.s6_addr32[3] =
+                        addr->v4.sin_addr.s_addr;
+        } else {
+                inet6_sk(sk)->rcv_saddr = addr->v6.sin6_addr;
+        }
+}
+
+/* Initialize sk->sk_daddr from sctp_addr. */
+static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
+{
+        if (addr->sa.sa_family == AF_INET && sctp_sk(sk)->v4mapped) {
+                inet6_sk(sk)->daddr.s6_addr32[0] = 0;
+                inet6_sk(sk)->daddr.s6_addr32[1] = 0;
+                inet6_sk(sk)->daddr.s6_addr32[2] = htonl(0x0000ffff);
+                inet6_sk(sk)->daddr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
+        } else {
+                inet6_sk(sk)->daddr = addr->v6.sin6_addr;
+        }
+}
+
+/* Initialize a sctp_addr from an address parameter. */
+static void sctp_v6_from_addr_param(union sctp_addr *addr,
+                                    union sctp_addr_param *param,
+                                    __u16 port, int iif)
+{
+        addr->v6.sin6_family = AF_INET6;
+        addr->v6.sin6_port = port;
+        addr->v6.sin6_flowinfo = 0; /* BUG */
+        ipv6_addr_copy(&addr->v6.sin6_addr, &param->v6.addr);
+        addr->v6.sin6_scope_id = iif;
+}
+
+/* Initialize an address parameter from a sctp_addr and return the length
+ * of the address parameter.
+ */
+static int sctp_v6_to_addr_param(const union sctp_addr *addr,
+                                 union sctp_addr_param *param)
+{
+        int length = sizeof(sctp_ipv6addr_param_t);
+
+        param->v6.param_hdr.type = SCTP_PARAM_IPV6_ADDRESS;
+        param->v6.param_hdr.length = ntohs(length);
+        ipv6_addr_copy(&param->v6.addr, &addr->v6.sin6_addr);
+
+        return length;
+}
+
+/* Initialize a sctp_addr from a dst_entry. */
+static void sctp_v6_dst_saddr(union sctp_addr *addr, struct dst_entry *dst,
+                              unsigned short port)
+{
+        struct rt6_info *rt = (struct rt6_info *)dst;
+        addr->sa.sa_family = AF_INET6;
+        addr->v6.sin6_port = port;
+        ipv6_addr_copy(&addr->v6.sin6_addr, &rt->rt6i_src.addr);
+}
+
+/* Compare addresses exactly.
+ * v4-mapped-v6 is also in consideration.
+ */
+static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
+                            const union sctp_addr *addr2)
+{
+        if (addr1->sa.sa_family != addr2->sa.sa_family) {
+                if (addr1->sa.sa_family == AF_INET &&
+                    addr2->sa.sa_family == AF_INET6 &&
+                    IPV6_ADDR_MAPPED == ipv6_addr_type(&addr2->v6.sin6_addr)) {
+                        if (addr2->v6.sin6_port == addr1->v4.sin_port &&
+                            addr2->v6.sin6_addr.s6_addr32[3] ==
+                            addr1->v4.sin_addr.s_addr)
+                                return 1;
+                }
+                if (addr2->sa.sa_family == AF_INET &&
+                    addr1->sa.sa_family == AF_INET6 &&
+                    IPV6_ADDR_MAPPED == ipv6_addr_type(&addr1->v6.sin6_addr)) {
+                        if (addr1->v6.sin6_port == addr2->v4.sin_port &&
+                            addr1->v6.sin6_addr.s6_addr32[3] ==
+                            addr2->v4.sin_addr.s_addr)
+                                return 1;
+                }
+                return 0;
+        }
+        if (!ipv6_addr_equal(&addr1->v6.sin6_addr, &addr2->v6.sin6_addr))
+                return 0;
+        /* If this is a linklocal address, compare the scope_id. */
+        if (ipv6_addr_type(&addr1->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL) {
+                if (addr1->v6.sin6_scope_id && addr2->v6.sin6_scope_id &&
+                    (addr1->v6.sin6_scope_id != addr2->v6.sin6_scope_id)) {
+                        return 0;
+                }
+        }
+
+        return 1;
+}
+
+/* Initialize addr struct to INADDR_ANY. */
+static void sctp_v6_inaddr_any(union sctp_addr *addr, unsigned short port)
+{
+        memset(addr, 0x00, sizeof(union sctp_addr));
+        addr->v6.sin6_family = AF_INET6;
+        addr->v6.sin6_port = port;
+}
+
+/* Is this a wildcard address? */
+static int sctp_v6_is_any(const union sctp_addr *addr)
+{
+        int type;
+        type = ipv6_addr_type((struct in6_addr *)&addr->v6.sin6_addr);
+        return IPV6_ADDR_ANY == type;
+}
+
+/* Should this be available for binding?   */
+static int sctp_v6_available(union sctp_addr *addr, struct sctp_sock *sp)
+{
+        int type;
+        struct in6_addr *in6 = (struct in6_addr *)&addr->v6.sin6_addr;
+
+        type = ipv6_addr_type(in6);
+        if (IPV6_ADDR_ANY == type)
+                return 1;
+        if (type == IPV6_ADDR_MAPPED) {
+                if (sp && !sp->v4mapped)
+                        return 0;
+                if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
+                        return 0;
+                sctp_v6_map_v4(addr);
+                return sctp_get_af_specific(AF_INET)->available(addr, sp);
+        }
+        if (!(type & IPV6_ADDR_UNICAST))
+                return 0;
+
+        return ipv6_chk_addr(in6, NULL, 0);
+}
+
+/* This function checks if the address is a valid address to be used for
+ * SCTP.
+ *
+ * Output:
+ * Return 0 - If the address is a non-unicast or an illegal address.
+ * Return 1 - If the address is a unicast.
+ */
+static int sctp_v6_addr_valid(union sctp_addr *addr, struct sctp_sock *sp)
+{
+        int ret = ipv6_addr_type(&addr->v6.sin6_addr);
+
+        /* Support v4-mapped-v6 address. */
+        if (ret == IPV6_ADDR_MAPPED) {
+                /* Note: This routine is used in input, so v4-mapped-v6
+                 * are disallowed here when there is no sctp_sock.
+                 */
+                if (!sp || !sp->v4mapped)
+                        return 0;
+                if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
+                        return 0;
+                sctp_v6_map_v4(addr);
+                return sctp_get_af_specific(AF_INET)->addr_valid(addr, sp);
+        }
+
+        /* Is this a non-unicast address */
+        if (!(ret & IPV6_ADDR_UNICAST))
+                return 0;
+
+        return 1;
+}
+
+/* What is the scope of 'addr'?  */
+static sctp_scope_t sctp_v6_scope(union sctp_addr *addr)
+{
+        int v6scope;
+        sctp_scope_t retval;
+
+        /* The IPv6 scope is really a set of bit fields.
+         * See IFA_* in <net/if_inet6.h>.  Map to a generic SCTP scope.
+         */
+
+        v6scope = ipv6_addr_scope(&addr->v6.sin6_addr);
+        switch (v6scope) {
+        case IFA_HOST:
+                retval = SCTP_SCOPE_LOOPBACK;
+                break;
+        case IFA_LINK:
+                retval = SCTP_SCOPE_LINK;
+                break;
+        case IFA_SITE:
+                retval = SCTP_SCOPE_PRIVATE;
+                break;
+        default:
+                retval = SCTP_SCOPE_GLOBAL;
+                break;
+        };
+
+        return retval;
+}
+
+/* Create and initialize a new sk for the socket to be returned by accept(). */
+static struct sock *sctp_v6_create_accept_sk(struct sock *sk,
+                                             struct sctp_association *asoc)
+{
+        struct inet_sock *inet = inet_sk(sk);
+        struct sock *newsk;
+        struct inet_sock *newinet;
+        struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
+        struct sctp6_sock *newsctp6sk;
+
+        newsk = sk_alloc(PF_INET6, GFP_KERNEL, sk->sk_prot, 1);
+        if (!newsk)
+                goto out;
+
+        sock_init_data(NULL, newsk);
+
+        newsk->sk_type = SOCK_STREAM;
+
+        newsk->sk_prot = sk->sk_prot;
+        newsk->sk_no_check = sk->sk_no_check;
+        newsk->sk_reuse = sk->sk_reuse;
+
+        newsk->sk_destruct = inet_sock_destruct;
+        newsk->sk_family = PF_INET6;
+        newsk->sk_protocol = IPPROTO_SCTP;
+        newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
+        newsk->sk_shutdown = sk->sk_shutdown;
+        sock_reset_flag(sk, SOCK_ZAPPED);
+
+        newsctp6sk = (struct sctp6_sock *)newsk;
+        inet_sk(newsk)->pinet6 = &newsctp6sk->inet6;
+
+        newinet = inet_sk(newsk);
+        newnp = inet6_sk(newsk);
+
+        memcpy(newnp, np, sizeof(struct ipv6_pinfo));
+
+        /* Initialize sk's sport, dport, rcv_saddr and daddr for getsockname()
+         * and getpeername().
+         */
+        newinet->sport = inet->sport;
+        newnp->saddr = np->saddr;
+        newnp->rcv_saddr = np->rcv_saddr;
+        newinet->dport = htons(asoc->peer.port);
+        sctp_v6_to_sk_daddr(&asoc->peer.primary_addr, newsk);
+
+        /* Init the ipv4 part of the socket since we can have sockets
+         * using v6 API for ipv4.
+         */
+        newinet->uc_ttl = -1;
+        newinet->mc_loop = 1;
+        newinet->mc_ttl = 1;
+        newinet->mc_index = 0;
+        newinet->mc_list = NULL;
+
+        if (ipv4_config.no_pmtu_disc)
+                newinet->pmtudisc = IP_PMTUDISC_DONT;
+        else
+                newinet->pmtudisc = IP_PMTUDISC_WANT;
+
+#ifdef INET_REFCNT_DEBUG
+        atomic_inc(&inet6_sock_nr);
+        atomic_inc(&inet_sock_nr);
+#endif
+
+        if (newsk->sk_prot->init(newsk)) {
+                sk_common_release(newsk);
+                newsk = NULL;
+        }
+
+out:
+        return newsk;
+}
+
+/* Map v4 address to mapped v6 address */
+static void sctp_v6_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
+{
+        if (sp->v4mapped && AF_INET == addr->sa.sa_family)
+                sctp_v4_map_v6(addr);
+}
+
+/* Where did this skb come from?  */
+static int sctp_v6_skb_iif(const struct sk_buff *skb)
+{
+        struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
+        return opt->iif;
+}
+
+/* Was this packet marked by Explicit Congestion Notification? */
+static int sctp_v6_is_ce(const struct sk_buff *skb)
+{
+        return *((__u32 *)(skb->nh.ipv6h)) & htonl(1<<20);
+}
+
+/* Dump the v6 addr to the seq file. */
+static void sctp_v6_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
+{
+        seq_printf(seq, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x ",
+                   NIP6(addr->v6.sin6_addr));
+}
+
+/* Initialize a PF_INET6 socket msg_name. */
+static void sctp_inet6_msgname(char *msgname, int *addr_len)
+{
+        struct sockaddr_in6 *sin6;
+
+        sin6 = (struct sockaddr_in6 *)msgname;
+        sin6->sin6_family = AF_INET6;
+        sin6->sin6_flowinfo = 0;
+        sin6->sin6_scope_id = 0; /*FIXME */
+        *addr_len = sizeof(struct sockaddr_in6);
+}
+
+/* Initialize a PF_INET msgname from a ulpevent. */
+static void sctp_inet6_event_msgname(struct sctp_ulpevent *event,
+                                     char *msgname, int *addrlen)
+{
+        struct sockaddr_in6 *sin6, *sin6from;
+
+        if (msgname) {
+                union sctp_addr *addr;
+                struct sctp_association *asoc;
+
+                asoc = event->asoc;
+                sctp_inet6_msgname(msgname, addrlen);
+                sin6 = (struct sockaddr_in6 *)msgname;
+                sin6->sin6_port = htons(asoc->peer.port);
+                addr = &asoc->peer.primary_addr;
+
+                /* Note: If we go to a common v6 format, this code
+                 * will change.
+                 */
+
+                /* Map ipv4 address into v4-mapped-on-v6 address.  */
+                if (sctp_sk(asoc->base.sk)->v4mapped &&
+                    AF_INET == addr->sa.sa_family) {
+                        sctp_v4_map_v6((union sctp_addr *)sin6);
+                        sin6->sin6_addr.s6_addr32[3] =
+                                addr->v4.sin_addr.s_addr;
+                        return;
+                }
+
+                sin6from = &asoc->peer.primary_addr.v6;
+                ipv6_addr_copy(&sin6->sin6_addr, &sin6from->sin6_addr);
+                if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
+                        sin6->sin6_scope_id = sin6from->sin6_scope_id;
+        }
+}
+
+/* Initialize a msg_name from an inbound skb. */
+static void sctp_inet6_skb_msgname(struct sk_buff *skb, char *msgname,
+                                   int *addr_len)
+{
+        struct sctphdr *sh;
+        struct sockaddr_in6 *sin6;
+
+        if (msgname) {
+                sctp_inet6_msgname(msgname, addr_len);
+                sin6 = (struct sockaddr_in6 *)msgname;
+                sh = (struct sctphdr *)skb->h.raw;
+                sin6->sin6_port = sh->source;
+
+                /* Map ipv4 address into v4-mapped-on-v6 address. */
+                if (sctp_sk(skb->sk)->v4mapped &&
+                    skb->nh.iph->version == 4) {
+                        sctp_v4_map_v6((union sctp_addr *)sin6);
+                        sin6->sin6_addr.s6_addr32[3] = skb->nh.iph->saddr;
+                        return;
+                }
+
+                /* Otherwise, just copy the v6 address. */
+                ipv6_addr_copy(&sin6->sin6_addr, &skb->nh.ipv6h->saddr);
+                if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) {
+                        struct sctp_ulpevent *ev = sctp_skb2event(skb);
+                        sin6->sin6_scope_id = ev->iif;
+                }
+        }
+}
+
+/* Do we support this AF? */
+static int sctp_inet6_af_supported(sa_family_t family, struct sctp_sock *sp)
+{
+        switch (family) {
+        case AF_INET6:
+                return 1;
+        /* v4-mapped-v6 addresses */
+        case AF_INET:
+                if (!__ipv6_only_sock(sctp_opt2sk(sp)) && sp->v4mapped)
+                        return 1;
+        default:
+                return 0;
+        }
+}
+
+/* Address matching with wildcards allowed.  This extra level
+ * of indirection lets us choose whether a PF_INET6 should
+ * disallow any v4 addresses if we so choose.
+ */
+static int sctp_inet6_cmp_addr(const union sctp_addr *addr1,
+                               const union sctp_addr *addr2,
+                               struct sctp_sock *opt)
+{
+        struct sctp_af *af1, *af2;
+
+        af1 = sctp_get_af_specific(addr1->sa.sa_family);
+        af2 = sctp_get_af_specific(addr2->sa.sa_family);
+
+        if (!af1 || !af2)
+                return 0;
+        /* Today, wildcard AF_INET/AF_INET6. */
+        if (sctp_is_any(addr1) || sctp_is_any(addr2))
+                return 1;
+
+        if (addr1->sa.sa_family != addr2->sa.sa_family)
+                return 0;
+
+        return af1->cmp_addr(addr1, addr2);
+}
+
+/* Verify that the provided sockaddr looks bindable.   Common verification,
+ * has already been taken care of.
+ */
+static int sctp_inet6_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
+{
+        struct sctp_af *af;
+
+        /* ASSERT: address family has already been verified. */
+        if (addr->sa.sa_family != AF_INET6)
+                af = sctp_get_af_specific(addr->sa.sa_family);
+        else {
+                struct sock *sk;
+                int type = ipv6_addr_type(&addr->v6.sin6_addr);
+                sk = sctp_opt2sk(opt);
+                if (type & IPV6_ADDR_LINKLOCAL) {
+                        /* Note: Behavior similar to af_inet6.c:
+                         *  1) Overrides previous bound_dev_if
+                         *  2) Destructive even if bind isn't successful.
+                         */
+
+                        if (addr->v6.sin6_scope_id)
+                                sk->sk_bound_dev_if = addr->v6.sin6_scope_id;
+                        if (!sk->sk_bound_dev_if)
+                                return 0;
+                }
+                af = opt->pf->af;
+        }
+        return af->available(addr, opt);
+}
+
+/* Verify that the provided sockaddr looks bindable.   Common verification,
+ * has already been taken care of.
+ */
+static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
+{
+        struct sctp_af *af = NULL;
+
+        /* ASSERT: address family has already been verified. */
+        if (addr->sa.sa_family != AF_INET6)
+                af = sctp_get_af_specific(addr->sa.sa_family);
+        else {
+                struct sock *sk;
+                int type = ipv6_addr_type(&addr->v6.sin6_addr);
+                sk = sctp_opt2sk(opt);
+                if (type & IPV6_ADDR_LINKLOCAL) {
+                        /* Note: Behavior similar to af_inet6.c:
+                         *  1) Overrides previous bound_dev_if
+                         *  2) Destructive even if bind isn't successful.
+                         */
+
+                        if (addr->v6.sin6_scope_id)
+                                sk->sk_bound_dev_if = addr->v6.sin6_scope_id;
+                        if (!sk->sk_bound_dev_if)
+                                return 0;
+                }
+                af = opt->pf->af;
+        }
+
+        return af != NULL;
+}
+
+/* Fill in Supported Address Type information for INIT and INIT-ACK
+ * chunks.   Note: In the future, we may want to look at sock options
+ * to determine whether a PF_INET6 socket really wants to have IPV4
+ * addresses.
+ * Returns number of addresses supported.
+ */
+static int sctp_inet6_supported_addrs(const struct sctp_sock *opt,
+                                      __u16 *types)
+{
+        types[0] = SCTP_PARAM_IPV4_ADDRESS;
+        types[1] = SCTP_PARAM_IPV6_ADDRESS;
+        return 2;
+}
+
+static struct proto_ops inet6_seqpacket_ops = {
+        .family     = PF_INET6,
+        .owner      = THIS_MODULE,
+        .release    = inet6_release,
+        .bind       = inet6_bind,
+        .connect    = inet_dgram_connect,
+        .socketpair = sock_no_socketpair,
+        .accept     = inet_accept,
+        .getname    = inet6_getname,
+        .poll       = sctp_poll,
+        .ioctl      = inet6_ioctl,
+        .listen     = sctp_inet_listen,
+        .shutdown   = inet_shutdown,
+        .setsockopt = sock_common_setsockopt,
+        .getsockopt = sock_common_getsockopt,
+        .sendmsg    = inet_sendmsg,
+        .recvmsg    = sock_common_recvmsg,
+        .mmap       = sock_no_mmap,
+};
+
+static struct inet_protosw sctpv6_seqpacket_protosw = {
+        .type          = SOCK_SEQPACKET,
+        .protocol      = IPPROTO_SCTP,
+        .prot          = &sctpv6_prot,
+        .ops           = &inet6_seqpacket_ops,
+        .capability    = -1,
+        .no_check      = 0,
+        .flags         = SCTP_PROTOSW_FLAG
+};
+static struct inet_protosw sctpv6_stream_protosw = {
+        .type          = SOCK_STREAM,
+        .protocol      = IPPROTO_SCTP,
+        .prot          = &sctpv6_prot,
+        .ops           = &inet6_seqpacket_ops,
+        .capability    = -1,
+        .no_check      = 0,
+        .flags         = SCTP_PROTOSW_FLAG,
+};
+
+static int sctp6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
+{
+        return sctp_rcv(*pskb) ? -1 : 0;
+}
+
+static struct inet6_protocol sctpv6_protocol = {
+        .handler      = sctp6_rcv,
+        .err_handler  = sctp_v6_err,
+        .flags        = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
+};
+
+static struct sctp_af sctp_ipv6_specific = {
+        .sctp_xmit       = sctp_v6_xmit,
+        .setsockopt      = ipv6_setsockopt,
+        .getsockopt      = ipv6_getsockopt,
+        .get_dst         = sctp_v6_get_dst,
+        .get_saddr       = sctp_v6_get_saddr,
+        .copy_addrlist   = sctp_v6_copy_addrlist,
+        .from_skb        = sctp_v6_from_skb,
+        .from_sk         = sctp_v6_from_sk,
+        .to_sk_saddr     = sctp_v6_to_sk_saddr,
+        .to_sk_daddr     = sctp_v6_to_sk_daddr,
+        .from_addr_param = sctp_v6_from_addr_param,
+        .to_addr_param   = sctp_v6_to_addr_param,
+        .dst_saddr       = sctp_v6_dst_saddr,
+        .cmp_addr        = sctp_v6_cmp_addr,
+        .scope           = sctp_v6_scope,
+        .addr_valid      = sctp_v6_addr_valid,
+        .inaddr_any      = sctp_v6_inaddr_any,
+        .is_any          = sctp_v6_is_any,
+        .available       = sctp_v6_available,
+        .skb_iif         = sctp_v6_skb_iif,
+        .is_ce           = sctp_v6_is_ce,
+        .seq_dump_addr   = sctp_v6_seq_dump_addr,
+        .net_header_len  = sizeof(struct ipv6hdr),
+        .sockaddr_len    = sizeof(struct sockaddr_in6),
+        .sa_family       = AF_INET6,
+};
+
+static struct sctp_pf sctp_pf_inet6_specific = {
+        .event_msgname = sctp_inet6_event_msgname,
+        .skb_msgname   = sctp_inet6_skb_msgname,
+        .af_supported  = sctp_inet6_af_supported,
+        .cmp_addr      = sctp_inet6_cmp_addr,
+        .bind_verify   = sctp_inet6_bind_verify,
+        .send_verify   = sctp_inet6_send_verify,
+        .supported_addrs = sctp_inet6_supported_addrs,
+        .create_accept_sk = sctp_v6_create_accept_sk,
+        .addr_v4map    = sctp_v6_addr_v4map,
+        .af            = &sctp_ipv6_specific,
+};
+
+/* Initialize IPv6 support and register with inet6 stack.  */
+int sctp_v6_init(void)
+{
+        int rc = proto_register(&sctpv6_prot, 1);
+
+        if (rc)
+                goto out;
+        /* Register inet6 protocol. */
+        rc = -EAGAIN;
+        if (inet6_add_protocol(&sctpv6_protocol, IPPROTO_SCTP) < 0)
+                goto out_unregister_sctp_proto;
+
+        /* Add SCTPv6(UDP and TCP style) to inetsw6 linked list. */
+        inet6_register_protosw(&sctpv6_seqpacket_protosw);
+        inet6_register_protosw(&sctpv6_stream_protosw);
+
+        /* Register the SCTP specific PF_INET6 functions. */
+        sctp_register_pf(&sctp_pf_inet6_specific, PF_INET6);
+
+        /* Register the SCTP specific AF_INET6 functions. */
+        sctp_register_af(&sctp_ipv6_specific);
+
+        /* Register notifier for inet6 address additions/deletions. */
+        register_inet6addr_notifier(&sctp_inet6addr_notifier);
+        rc = 0;
+out:
+        return rc;
+out_unregister_sctp_proto:
+        proto_unregister(&sctpv6_prot);
+        goto out;
+}
+
+/* IPv6 specific exit support. */
+void sctp_v6_exit(void)
+{
+        list_del(&sctp_ipv6_specific.list);
+        inet6_del_protocol(&sctpv6_protocol, IPPROTO_SCTP);
+        inet6_unregister_protosw(&sctpv6_seqpacket_protosw);
+        inet6_unregister_protosw(&sctpv6_stream_protosw);
+        unregister_inet6addr_notifier(&sctp_inet6addr_notifier);
+        proto_unregister(&sctpv6_prot);
+}
diff --git a/net/sctp/objcnt.c b/net/sctp/objcnt.c
new file mode 100644
index 000000000000..0781e5d509fd
--- /dev/null
+++ b/net/sctp/objcnt.c
@@ -0,0 +1,140 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * Support for memory object debugging.  This allows one to monitor the
+ * object allocations/deallocations for types instrumented for this 
+ * via the proc fs. 
+ * 
+ * The SCTP reference implementation is free software; 
+ * you can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * The SCTP reference implementation is distributed in the hope that it 
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.  
+ * 
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ * 
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by: 
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/kernel.h>
+#include <net/sctp/sctp.h>
+
+/*
+ * Global counters to count raw object allocation counts.
+ * To add new counters, choose a unique suffix for the variable
+ * name as the helper macros key off this suffix to make
+ * life easier for the programmer.
+ */
+
+SCTP_DBG_OBJCNT(sock);
+SCTP_DBG_OBJCNT(ep);
+SCTP_DBG_OBJCNT(transport);
+SCTP_DBG_OBJCNT(assoc);
+SCTP_DBG_OBJCNT(bind_addr);
+SCTP_DBG_OBJCNT(bind_bucket);
+SCTP_DBG_OBJCNT(chunk);
+SCTP_DBG_OBJCNT(addr);
+SCTP_DBG_OBJCNT(ssnmap);
+SCTP_DBG_OBJCNT(datamsg);
+
+/* An array to make it easy to pretty print the debug information
+ * to the proc fs.
+ */
+static sctp_dbg_objcnt_entry_t sctp_dbg_objcnt[] = {
+        SCTP_DBG_OBJCNT_ENTRY(sock),
+        SCTP_DBG_OBJCNT_ENTRY(ep),
+        SCTP_DBG_OBJCNT_ENTRY(assoc),
+        SCTP_DBG_OBJCNT_ENTRY(transport),
+        SCTP_DBG_OBJCNT_ENTRY(chunk),
+        SCTP_DBG_OBJCNT_ENTRY(bind_addr),
+        SCTP_DBG_OBJCNT_ENTRY(bind_bucket),
+        SCTP_DBG_OBJCNT_ENTRY(addr),
+        SCTP_DBG_OBJCNT_ENTRY(ssnmap),
+        SCTP_DBG_OBJCNT_ENTRY(datamsg),
+};
+
+/* Callback from procfs to read out objcount information.
+ * Walk through the entries in the sctp_dbg_objcnt array, dumping
+ * the raw object counts for each monitored type.
+ *
+ * This code was modified from similar code in route.c
+ */
+static int sctp_dbg_objcnt_read(char *buffer, char **start, off_t offset,
+                                int length, int *eof, void *data)
+{
+        int len = 0;
+        off_t pos = 0;
+        int entries;
+        int i;
+        char temp[128];
+
+        /* How many entries? */
+        entries = ARRAY_SIZE(sctp_dbg_objcnt);
+
+        /* Walk the entries and print out the debug information
+         * for proc fs.
+         */
+        for (i = 0; i < entries; i++) {
+                pos += 128;
+
+                /* Skip ahead. */
+                if (pos <= offset) {
+                        len = 0;
+                        continue;
+                }
+                /* Print out each entry. */
+                sprintf(temp, "%s: %d",
+                        sctp_dbg_objcnt[i].label,
+                        atomic_read(sctp_dbg_objcnt[i].counter));
+
+                sprintf(buffer + len, "%-127s\n", temp);
+                len += 128;
+                if (pos >= offset+length)
+                        goto done;
+        }
+
+done:
+        *start = buffer + len - (pos - offset);
+        len = pos - offset;
+        if (len > length)
+                len = length;
+
+        return len;
+}
+
+/* Initialize the objcount in the proc filesystem.  */
+void sctp_dbg_objcnt_init(void)
+{
+        create_proc_read_entry("sctp_dbg_objcnt", 0, proc_net_sctp,
+                               sctp_dbg_objcnt_read, NULL);
+}
+
+/* Cleanup the objcount entry in the proc filesystem.  */
+void sctp_dbg_objcnt_exit(void)
+{
+        remove_proc_entry("sctp_dbg_objcnt", proc_net_sctp);
+}
+
+
diff --git a/net/sctp/output.c b/net/sctp/output.c
new file mode 100644
index 000000000000..9013f64f5219
--- /dev/null
+++ b/net/sctp/output.c
@@ -0,0 +1,646 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions handle output processing.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@austin.ibm.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/time.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/init.h>
+#include <net/inet_ecn.h>
+#include <net/icmp.h>
+
+#ifndef TEST_FRAME
+#include <net/tcp.h>
+#endif /* TEST_FRAME (not defined) */
+
+#include <linux/socket.h> /* for sa_family_t */
+#include <net/sock.h>
+
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for private helpers. */
+static sctp_xmit_t sctp_packet_append_data(struct sctp_packet *packet,
+                                           struct sctp_chunk *chunk);
+
+/* Config a packet.
+ * This appears to be a followup set of initializations.
+ */
+struct sctp_packet *sctp_packet_config(struct sctp_packet *packet,
+                                       __u32 vtag, int ecn_capable)
+{
+        struct sctp_chunk *chunk = NULL;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p vtag:0x%x\n", __FUNCTION__,
+                          packet, vtag);
+
+        packet->vtag = vtag;
+        packet->has_cookie_echo = 0;
+        packet->has_sack = 0;
+        packet->ipfragok = 0;
+
+        if (ecn_capable && sctp_packet_empty(packet)) {
+                chunk = sctp_get_ecne_prepend(packet->transport->asoc);
+
+                /* If there a is a prepend chunk stick it on the list before
+                 * any other chunks get appended.
+                 */
+                if (chunk)
+                        sctp_packet_append_chunk(packet, chunk);
+        }
+
+        return packet;
+}
+
+/* Initialize the packet structure. */
+struct sctp_packet *sctp_packet_init(struct sctp_packet *packet,
+                                     struct sctp_transport *transport,
+                                     __u16 sport, __u16 dport)
+{
+        struct sctp_association *asoc = transport->asoc;
+        size_t overhead;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p transport:%p\n", __FUNCTION__,
+                          packet, transport);
+
+        packet->transport = transport;
+        packet->source_port = sport;
+        packet->destination_port = dport;
+        skb_queue_head_init(&packet->chunks);
+        if (asoc) {
+                struct sctp_sock *sp = sctp_sk(asoc->base.sk);  
+                overhead = sp->pf->af->net_header_len; 
+        } else {
+                overhead = sizeof(struct ipv6hdr);
+        }
+        overhead += sizeof(struct sctphdr);
+        packet->overhead = overhead;
+        packet->size = overhead;
+        packet->vtag = 0;
+        packet->has_cookie_echo = 0;
+        packet->has_sack = 0;
+        packet->ipfragok = 0;
+        packet->malloced = 0;
+        return packet;
+}
+
+/* Free a packet.  */
+void sctp_packet_free(struct sctp_packet *packet)
+{
+        struct sctp_chunk *chunk;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p\n", __FUNCTION__, packet);
+
+        while ((chunk = (struct sctp_chunk *)__skb_dequeue(&packet->chunks)) != NULL)
+                sctp_chunk_free(chunk);
+
+        if (packet->malloced)
+                kfree(packet);
+}
+
+/* This routine tries to append the chunk to the offered packet. If adding
+ * the chunk causes the packet to exceed the path MTU and COOKIE_ECHO chunk
+ * is not present in the packet, it transmits the input packet.
+ * Data can be bundled with a packet containing a COOKIE_ECHO chunk as long
+ * as it can fit in the packet, but any more data that does not fit in this
+ * packet can be sent only after receiving the COOKIE_ACK.
+ */
+sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
+                                       struct sctp_chunk *chunk)
+{
+        sctp_xmit_t retval;
+        int error = 0;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __FUNCTION__,
+                          packet, chunk);
+
+        switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
+        case SCTP_XMIT_PMTU_FULL:
+                if (!packet->has_cookie_echo) {
+                        error = sctp_packet_transmit(packet);
+                        if (error < 0)
+                                chunk->skb->sk->sk_err = -error;
+
+                        /* If we have an empty packet, then we can NOT ever
+                         * return PMTU_FULL.
+                         */
+                        retval = sctp_packet_append_chunk(packet, chunk);
+                }
+                break;
+
+        case SCTP_XMIT_RWND_FULL:
+        case SCTP_XMIT_OK:
+        case SCTP_XMIT_NAGLE_DELAY:
+                break;
+        };
+
+        return retval;
+}
+
+/* Try to bundle a SACK with the packet. */
+static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt,
+                                           struct sctp_chunk *chunk)
+{
+        sctp_xmit_t retval = SCTP_XMIT_OK;
+
+        /* If sending DATA and haven't aleady bundled a SACK, try to
+         * bundle one in to the packet.
+         */
+        if (sctp_chunk_is_data(chunk) && !pkt->has_sack &&
+            !pkt->has_cookie_echo) {
+                struct sctp_association *asoc;
+                asoc = pkt->transport->asoc;
+
+                if (asoc->a_rwnd > asoc->rwnd) {
+                        struct sctp_chunk *sack;
+                        asoc->a_rwnd = asoc->rwnd;
+                        sack = sctp_make_sack(asoc);
+                        if (sack) {
+                                struct timer_list *timer;
+                                retval = sctp_packet_append_chunk(pkt, sack);
+                                asoc->peer.sack_needed = 0;
+                                timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
+                                if (timer_pending(timer) && del_timer(timer))
+                                        sctp_association_put(asoc);
+                        }
+                }
+        }
+        return retval;
+}
+
+/* Append a chunk to the offered packet reporting back any inability to do
+ * so.
+ */
+sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
+                                     struct sctp_chunk *chunk)
+{
+        sctp_xmit_t retval = SCTP_XMIT_OK;
+        __u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));
+        size_t psize;
+        size_t pmtu;
+        int too_big;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __FUNCTION__, packet,
+                          chunk);
+
+        retval = sctp_packet_bundle_sack(packet, chunk);
+        psize = packet->size;
+
+        if (retval != SCTP_XMIT_OK)
+                goto finish;
+
+        pmtu  = ((packet->transport->asoc) ?
+                 (packet->transport->asoc->pmtu) :
+                 (packet->transport->pmtu));
+
+        too_big = (psize + chunk_len > pmtu);
+
+        /* Decide if we need to fragment or resubmit later. */
+        if (too_big) {
+                /* Both control chunks and data chunks with TSNs are
+                 * non-fragmentable.
+                 */
+                if (sctp_packet_empty(packet) || !sctp_chunk_is_data(chunk)) {
+                        /* We no longer do re-fragmentation.
+                         * Just fragment at the IP layer, if we
+                         * actually hit this condition
+                         */
+                        packet->ipfragok = 1;
+                        goto append;
+
+                } else {
+                        retval = SCTP_XMIT_PMTU_FULL;
+                        goto finish;
+                }
+        }
+
+append:
+        /* We believe that this chunk is OK to add to the packet (as
+         * long as we have the cwnd for it).
+         */
+
+        /* DATA is a special case since we must examine both rwnd and cwnd
+         * before we send DATA.
+         */
+        if (sctp_chunk_is_data(chunk)) {
+                retval = sctp_packet_append_data(packet, chunk);
+                /* Disallow SACK bundling after DATA. */
+                packet->has_sack = 1;
+                if (SCTP_XMIT_OK != retval)
+                        goto finish;
+        } else if (SCTP_CID_COOKIE_ECHO == chunk->chunk_hdr->type)
+                packet->has_cookie_echo = 1;
+        else if (SCTP_CID_SACK == chunk->chunk_hdr->type)
+                packet->has_sack = 1;
+
+        /* It is OK to send this chunk.  */
+        __skb_queue_tail(&packet->chunks, (struct sk_buff *)chunk);
+        packet->size += chunk_len;
+        chunk->transport = packet->transport;
+finish:
+        return retval;
+}
+
+/* All packets are sent to the network through this function from
+ * sctp_outq_tail().
+ *
+ * The return value is a normal kernel error return value.
+ */
+int sctp_packet_transmit(struct sctp_packet *packet)
+{
+        struct sctp_transport *tp = packet->transport;
+        struct sctp_association *asoc = tp->asoc;
+        struct sctphdr *sh;
+        __u32 crc32;
+        struct sk_buff *nskb;
+        struct sctp_chunk *chunk;
+        struct sock *sk;
+        int err = 0;
+        int padding;            /* How much padding do we need?  */
+        __u8 has_data = 0;
+        struct dst_entry *dst;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p\n", __FUNCTION__, packet);
+
+        /* Do NOT generate a chunkless packet. */
+        chunk = (struct sctp_chunk *)skb_peek(&packet->chunks);
+        if (unlikely(!chunk))
+                return err;
+
+        /* Set up convenience variables... */
+        sk = chunk->skb->sk;
+
+        /* Allocate the new skb.  */
+        nskb = dev_alloc_skb(packet->size);
+        if (!nskb)
+                goto nomem;
+
+        /* Make sure the outbound skb has enough header room reserved. */
+        skb_reserve(nskb, packet->overhead);
+
+        /* Set the owning socket so that we know where to get the
+         * destination IP address.
+         */
+        skb_set_owner_w(nskb, sk);
+
+        /* Build the SCTP header.  */
+        sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr));
+        sh->source = htons(packet->source_port);
+        sh->dest   = htons(packet->destination_port);
+
+        /* From 6.8 Adler-32 Checksum Calculation:
+         * After the packet is constructed (containing the SCTP common
+         * header and one or more control or DATA chunks), the
+         * transmitter shall:
+         *
+         * 1) Fill in the proper Verification Tag in the SCTP common
+         *    header and initialize the checksum field to 0's.
+         */
+        sh->vtag     = htonl(packet->vtag);
+        sh->checksum = 0;
+
+        /* 2) Calculate the Adler-32 checksum of the whole packet,
+         *    including the SCTP common header and all the
+         *    chunks.
+         *
+         * Note: Adler-32 is no longer applicable, as has been replaced
+         * by CRC32-C as described in <draft-ietf-tsvwg-sctpcsum-02.txt>.
+         */
+        crc32 = sctp_start_cksum((__u8 *)sh, sizeof(struct sctphdr));
+
+        /**
+         * 6.10 Bundling
+         *
+         *    An endpoint bundles chunks by simply including multiple
+         *    chunks in one outbound SCTP packet.  ...
+         */
+
+        /**
+         * 3.2  Chunk Field Descriptions
+         *
+         * The total length of a chunk (including Type, Length and
+         * Value fields) MUST be a multiple of 4 bytes.  If the length
+         * of the chunk is not a multiple of 4 bytes, the sender MUST
+         * pad the chunk with all zero bytes and this padding is not
+         * included in the chunk length field.  The sender should
+         * never pad with more than 3 bytes.
+         *
+         * [This whole comment explains WORD_ROUND() below.]
+         */
+        SCTP_DEBUG_PRINTK("***sctp_transmit_packet***\n");
+        while ((chunk = (struct sctp_chunk *)__skb_dequeue(&packet->chunks)) != NULL) {
+                if (sctp_chunk_is_data(chunk)) {
+
+                        if (!chunk->has_tsn) {
+                                sctp_chunk_assign_ssn(chunk);
+                                sctp_chunk_assign_tsn(chunk);
+
+                        /* 6.3.1 C4) When data is in flight and when allowed
+                         * by rule C5, a new RTT measurement MUST be made each
+                         * round trip.  Furthermore, new RTT measurements
+                         * SHOULD be made no more than once per round-trip
+                         * for a given destination transport address.
+                         */
+
+                                if (!tp->rto_pending) {
+                                        chunk->rtt_in_progress = 1;
+                                        tp->rto_pending = 1;
+                                }
+                        } else
+                                chunk->resent = 1;
+
+                        chunk->sent_at = jiffies;
+                        has_data = 1;
+                }
+
+                padding = WORD_ROUND(chunk->skb->len) - chunk->skb->len;
+                if (padding)
+                        memset(skb_put(chunk->skb, padding), 0, padding);
+
+                crc32 = sctp_update_copy_cksum(skb_put(nskb, chunk->skb->len),
+                                               chunk->skb->data,
+                                               chunk->skb->len, crc32);
+
+                SCTP_DEBUG_PRINTK("%s %p[%s] %s 0x%x, %s %d, %s %d, %s %d\n",
+                                  "*** Chunk", chunk,
+                                  sctp_cname(SCTP_ST_CHUNK(
+                                          chunk->chunk_hdr->type)),
+                                  chunk->has_tsn ? "TSN" : "No TSN",
+                                  chunk->has_tsn ?
+                                  ntohl(chunk->subh.data_hdr->tsn) : 0,
+                                  "length", ntohs(chunk->chunk_hdr->length),
+                                  "chunk->skb->len", chunk->skb->len,
+                                  "rtt_in_progress", chunk->rtt_in_progress);
+
+                /*
+                 * If this is a control chunk, this is our last
+                 * reference. Free data chunks after they've been
+                 * acknowledged or have failed.
+                 */
+                if (!sctp_chunk_is_data(chunk))
+                        sctp_chunk_free(chunk);
+        }
+
+        /* Perform final transformation on checksum. */
+        crc32 = sctp_end_cksum(crc32);
+
+        /* 3) Put the resultant value into the checksum field in the
+         *    common header, and leave the rest of the bits unchanged.
+         */
+        sh->checksum = htonl(crc32);
+
+        /* IP layer ECN support
+         * From RFC 2481
+         *  "The ECN-Capable Transport (ECT) bit would be set by the
+         *   data sender to indicate that the end-points of the
+         *   transport protocol are ECN-capable."
+         *
+         * Now setting the ECT bit all the time, as it should not cause
+         * any problems protocol-wise even if our peer ignores it.
+         *
+         * Note: The works for IPv6 layer checks this bit too later
+         * in transmission.  See IP6_ECN_flow_xmit().
+         */
+        INET_ECN_xmit(nskb->sk);
+
+        /* Set up the IP options.  */
+        /* BUG: not implemented
+         * For v4 this all lives somewhere in sk->sk_opt...
+         */
+
+        /* Dump that on IP!  */
+        if (asoc && asoc->peer.last_sent_to != tp) {
+                /* Considering the multiple CPU scenario, this is a
+                 * "correcter" place for last_sent_to.  --xguo
+                 */
+                asoc->peer.last_sent_to = tp;
+        }
+
+        if (has_data) {
+                struct timer_list *timer;
+                unsigned long timeout;
+
+                tp->last_time_used = jiffies;
+
+                /* Restart the AUTOCLOSE timer when sending data. */
+                if (sctp_state(asoc, ESTABLISHED) && asoc->autoclose) {
+                        timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
+                        timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
+
+                        if (!mod_timer(timer, jiffies + timeout))
+                                sctp_association_hold(asoc);
+                }
+        }
+
+        dst = tp->dst;
+        /* The 'obsolete' field of dst is set to 2 when a dst is freed. */
+        if (!dst || (dst->obsolete > 1)) {
+                dst_release(dst);
+                sctp_transport_route(tp, NULL, sctp_sk(sk));
+                sctp_assoc_sync_pmtu(asoc);
+        }
+
+        nskb->dst = dst_clone(tp->dst);
+        if (!nskb->dst)
+                goto no_route;
+
+        SCTP_DEBUG_PRINTK("***sctp_transmit_packet*** skb len %d\n",
+                          nskb->len);
+
+        (*tp->af_specific->sctp_xmit)(nskb, tp, packet->ipfragok);
+
+out:
+        packet->size = packet->overhead;
+        return err;
+no_route:
+        kfree_skb(nskb);
+        IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
+
+        /* FIXME: Returning the 'err' will effect all the associations
+         * associated with a socket, although only one of the paths of the
+         * association is unreachable.
+         * The real failure of a transport or association can be passed on
+         * to the user via notifications. So setting this error may not be
+         * required.
+         */
+         /* err = -EHOSTUNREACH; */
+err:
+        /* Control chunks are unreliable so just drop them.  DATA chunks
+         * will get resent or dropped later.
+         */
+
+        while ((chunk = (struct sctp_chunk *)__skb_dequeue(&packet->chunks)) != NULL) {
+                if (!sctp_chunk_is_data(chunk))
+                        sctp_chunk_free(chunk);
+        }
+        goto out;
+nomem:
+        err = -ENOMEM;
+        goto err;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* This private function handles the specifics of appending DATA chunks.  */
+static sctp_xmit_t sctp_packet_append_data(struct sctp_packet *packet,
+                                           struct sctp_chunk *chunk)
+{
+        sctp_xmit_t retval = SCTP_XMIT_OK;
+        size_t datasize, rwnd, inflight;
+        struct sctp_transport *transport = packet->transport;
+        __u32 max_burst_bytes;
+        struct sctp_association *asoc = transport->asoc;
+        struct sctp_sock *sp = sctp_sk(asoc->base.sk);
+        struct sctp_outq *q = &asoc->outqueue;
+
+        /* RFC 2960 6.1  Transmission of DATA Chunks
+         *
+         * A) At any given time, the data sender MUST NOT transmit new data to
+         * any destination transport address if its peer's rwnd indicates
+         * that the peer has no buffer space (i.e. rwnd is 0, see Section
+         * 6.2.1).  However, regardless of the value of rwnd (including if it
+         * is 0), the data sender can always have one DATA chunk in flight to
+         * the receiver if allowed by cwnd (see rule B below).  This rule
+         * allows the sender to probe for a change in rwnd that the sender
+         * missed due to the SACK having been lost in transit from the data
+         * receiver to the data sender.
+         */
+
+        rwnd = asoc->peer.rwnd;
+        inflight = asoc->outqueue.outstanding_bytes;
+
+        datasize = sctp_data_size(chunk);
+
+        if (datasize > rwnd) {
+                if (inflight > 0) {
+                        /* We have (at least) one data chunk in flight,
+                         * so we can't fall back to rule 6.1 B).
+                         */
+                        retval = SCTP_XMIT_RWND_FULL;
+                        goto finish;
+                }
+        }
+
+        /* sctpimpguide-05 2.14.2
+         * D) When the time comes for the sender to
+         * transmit new DATA chunks, the protocol parameter Max.Burst MUST
+         * first be applied to limit how many new DATA chunks may be sent.
+         * The limit is applied by adjusting cwnd as follows:
+         *      if ((flightsize + Max.Burst * MTU) < cwnd)
+         *              cwnd = flightsize + Max.Burst * MTU
+         */
+        max_burst_bytes = asoc->max_burst * asoc->pmtu;
+        if ((transport->flight_size + max_burst_bytes) < transport->cwnd) {
+                transport->cwnd = transport->flight_size + max_burst_bytes;
+                SCTP_DEBUG_PRINTK("%s: cwnd limited by max_burst: "
+                                  "transport: %p, cwnd: %d, "
+                                  "ssthresh: %d, flight_size: %d, "
+                                  "pba: %d\n",
+                                  __FUNCTION__, transport,
+                                  transport->cwnd,
+                                  transport->ssthresh,
+                                  transport->flight_size,
+                                  transport->partial_bytes_acked);
+        }
+
+        /* RFC 2960 6.1  Transmission of DATA Chunks
+         *
+         * B) At any given time, the sender MUST NOT transmit new data
+         * to a given transport address if it has cwnd or more bytes
+         * of data outstanding to that transport address.
+         */
+        /* RFC 7.2.4 & the Implementers Guide 2.8.
+         *
+         * 3) ...
+         *    When a Fast Retransmit is being performed the sender SHOULD
+         *    ignore the value of cwnd and SHOULD NOT delay retransmission.
+         */
+        if (!chunk->fast_retransmit)
+                if (transport->flight_size >= transport->cwnd) {
+                        retval = SCTP_XMIT_RWND_FULL;
+                        goto finish;
+                }
+
+        /* Nagle's algorithm to solve small-packet problem:
+         * Inhibit the sending of new chunks when new outgoing data arrives
+         * if any previously transmitted data on the connection remains
+         * unacknowledged.
+         */
+        if (!sp->nodelay && sctp_packet_empty(packet) &&
+            q->outstanding_bytes && sctp_state(asoc, ESTABLISHED)) {
+                unsigned len = datasize + q->out_qlen;
+
+                /* Check whether this chunk and all the rest of pending
+                 * data will fit or delay in hopes of bundling a full
+                 * sized packet.
+                 */
+                if (len < asoc->pmtu - packet->overhead) {
+                        retval = SCTP_XMIT_NAGLE_DELAY;
+                        goto finish;
+                }
+        }
+
+        /* Keep track of how many bytes are in flight over this transport. */
+        transport->flight_size += datasize;
+
+        /* Keep track of how many bytes are in flight to the receiver. */
+        asoc->outqueue.outstanding_bytes += datasize;
+
+        /* Update our view of the receiver's rwnd. */
+        if (datasize < rwnd)
+                rwnd -= datasize;
+        else
+                rwnd = 0;
+
+        asoc->peer.rwnd = rwnd;
+        /* Has been accepted for transmission. */
+        if (!asoc->peer.prsctp_capable)
+                chunk->msg->can_abandon = 0;
+
+finish:
+        return retval;
+}
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
new file mode 100644
index 000000000000..1b2d4adc4ddb
--- /dev/null
+++ b/net/sctp/outqueue.c
@@ -0,0 +1,1734 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 Intel Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions implement the sctp_outq class.   The outqueue handles
+ * bundling and queueing of outgoing SCTP chunks.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Perry Melange         <pmelange@null.cc.uic.edu>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/list.h>   /* For struct list_head */
+#include <linux/socket.h>
+#include <linux/ip.h>
+#include <net/sock.h>     /* For skb_set_owner_w */
+
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Declare internal functions here.  */
+static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
+static void sctp_check_transmitted(struct sctp_outq *q,
+                                   struct list_head *transmitted_queue,
+                                   struct sctp_transport *transport,
+                                   struct sctp_sackhdr *sack,
+                                   __u32 highest_new_tsn);
+
+static void sctp_mark_missing(struct sctp_outq *q,
+                              struct list_head *transmitted_queue,
+                              struct sctp_transport *transport,
+                              __u32 highest_new_tsn,
+                              int count_of_newacks);
+
+static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
+
+/* Add data to the front of the queue. */
+static inline void sctp_outq_head_data(struct sctp_outq *q,
+                                        struct sctp_chunk *ch)
+{
+        __skb_queue_head(&q->out, (struct sk_buff *)ch);
+        q->out_qlen += ch->skb->len;
+        return;
+}
+
+/* Take data from the front of the queue. */
+static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
+{
+        struct sctp_chunk *ch;
+        ch = (struct sctp_chunk *)__skb_dequeue(&q->out);
+        if (ch)
+                q->out_qlen -= ch->skb->len;
+        return ch;
+}
+/* Add data chunk to the end of the queue. */
+static inline void sctp_outq_tail_data(struct sctp_outq *q,
+                                       struct sctp_chunk *ch)
+{
+        __skb_queue_tail(&q->out, (struct sk_buff *)ch);
+        q->out_qlen += ch->skb->len;
+        return;
+}
+
+/*
+ * SFR-CACC algorithm:
+ * D) If count_of_newacks is greater than or equal to 2
+ * and t was not sent to the current primary then the
+ * sender MUST NOT increment missing report count for t.
+ */
+static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
+                                       struct sctp_transport *transport,
+                                       int count_of_newacks)
+{
+        if (count_of_newacks >=2 && transport != primary)
+                return 1;
+        return 0;
+}
+
+/*
+ * SFR-CACC algorithm:
+ * F) If count_of_newacks is less than 2, let d be the
+ * destination to which t was sent. If cacc_saw_newack
+ * is 0 for destination d, then the sender MUST NOT
+ * increment missing report count for t.
+ */
+static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
+                                       int count_of_newacks)
+{
+        if (count_of_newacks < 2 && !transport->cacc.cacc_saw_newack)
+                return 1;
+        return 0;
+}
+
+/*
+ * SFR-CACC algorithm:
+ * 3.1) If CYCLING_CHANGEOVER is 0, the sender SHOULD
+ * execute steps C, D, F.
+ *
+ * C has been implemented in sctp_outq_sack
+ */
+static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary,
+                                     struct sctp_transport *transport,
+                                     int count_of_newacks)
+{
+        if (!primary->cacc.cycling_changeover) {
+                if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks))
+                        return 1;
+                if (sctp_cacc_skip_3_1_f(transport, count_of_newacks))
+                        return 1;
+                return 0;
+        }
+        return 0;
+}
+
+/*
+ * SFR-CACC algorithm:
+ * 3.2) Else if CYCLING_CHANGEOVER is 1, and t is less
+ * than next_tsn_at_change of the current primary, then
+ * the sender MUST NOT increment missing report count
+ * for t.
+ */
+static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn)
+{
+        if (primary->cacc.cycling_changeover &&
+            TSN_lt(tsn, primary->cacc.next_tsn_at_change))
+                return 1;
+        return 0;
+}
+
+/*
+ * SFR-CACC algorithm:
+ * 3) If the missing report count for TSN t is to be
+ * incremented according to [RFC2960] and
+ * [SCTP_STEWART-2002], and CHANGEOVER_ACTIVE is set,
+ * then the sender MUST futher execute steps 3.1 and
+ * 3.2 to determine if the missing report count for
+ * TSN t SHOULD NOT be incremented.
+ *
+ * 3.3) If 3.1 and 3.2 do not dictate that the missing
+ * report count for t should not be incremented, then
+ * the sender SOULD increment missing report count for
+ * t (according to [RFC2960] and [SCTP_STEWART_2002]).
+ */
+static inline int sctp_cacc_skip(struct sctp_transport *primary,
+                                 struct sctp_transport *transport,
+                                 int count_of_newacks,
+                                 __u32 tsn)
+{
+        if (primary->cacc.changeover_active &&
+            (sctp_cacc_skip_3_1(primary, transport, count_of_newacks)
+             || sctp_cacc_skip_3_2(primary, tsn)))
+                return 1;
+        return 0;
+}
+
+/* Initialize an existing sctp_outq.  This does the boring stuff.
+ * You still need to define handlers if you really want to DO
+ * something with this structure...
+ */
+void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
+{
+        q->asoc = asoc;
+        skb_queue_head_init(&q->out);
+        skb_queue_head_init(&q->control);
+        INIT_LIST_HEAD(&q->retransmit);
+        INIT_LIST_HEAD(&q->sacked);
+        INIT_LIST_HEAD(&q->abandoned);
+
+        q->outstanding_bytes = 0;
+        q->empty = 1;
+        q->cork  = 0;
+
+        q->malloced = 0;
+        q->out_qlen = 0;
+}
+
+/* Free the outqueue structure and any related pending chunks.
+ */
+void sctp_outq_teardown(struct sctp_outq *q)
+{
+        struct sctp_transport *transport;
+        struct list_head *lchunk, *pos, *temp;
+        struct sctp_chunk *chunk;
+
+        /* Throw away unacknowledged chunks. */
+        list_for_each(pos, &q->asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) {
+                        chunk = list_entry(lchunk, struct sctp_chunk,
+                                           transmitted_list);
+                        /* Mark as part of a failed message. */
+                        sctp_chunk_fail(chunk, q->error);
+                        sctp_chunk_free(chunk);
+                }
+        }
+
+        /* Throw away chunks that have been gap ACKed.  */
+        list_for_each_safe(lchunk, temp, &q->sacked) {
+                list_del_init(lchunk);
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                   transmitted_list);
+                sctp_chunk_fail(chunk, q->error);
+                sctp_chunk_free(chunk);
+        }
+
+        /* Throw away any chunks in the retransmit queue. */
+        list_for_each_safe(lchunk, temp, &q->retransmit) {
+                list_del_init(lchunk);
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                   transmitted_list);
+                sctp_chunk_fail(chunk, q->error);
+                sctp_chunk_free(chunk);
+        }
+
+        /* Throw away any chunks that are in the abandoned queue. */
+        list_for_each_safe(lchunk, temp, &q->abandoned) {
+                list_del_init(lchunk);
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                   transmitted_list);
+                sctp_chunk_fail(chunk, q->error);
+                sctp_chunk_free(chunk);
+        }
+
+        /* Throw away any leftover data chunks. */
+        while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
+
+                /* Mark as send failure. */
+                sctp_chunk_fail(chunk, q->error);
+                sctp_chunk_free(chunk);
+        }
+
+        q->error = 0;
+
+        /* Throw away any leftover control chunks. */
+        while ((chunk = (struct sctp_chunk *) skb_dequeue(&q->control)) != NULL)
+                sctp_chunk_free(chunk);
+}
+
+/* Free the outqueue structure and any related pending chunks.  */
+void sctp_outq_free(struct sctp_outq *q)
+{
+        /* Throw away leftover chunks. */
+        sctp_outq_teardown(q);
+
+        /* If we were kmalloc()'d, free the memory.  */
+        if (q->malloced)
+                kfree(q);
+}
+
+/* Put a new chunk in an sctp_outq.  */
+int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk)
+{
+        int error = 0;
+
+        SCTP_DEBUG_PRINTK("sctp_outq_tail(%p, %p[%s])\n",
+                          q, chunk, chunk && chunk->chunk_hdr ?
+                          sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type))
+                          : "Illegal Chunk");
+
+        /* If it is data, queue it up, otherwise, send it
+         * immediately.
+         */
+        if (SCTP_CID_DATA == chunk->chunk_hdr->type) {
+                /* Is it OK to queue data chunks?  */
+                /* From 9. Termination of Association
+                 *
+                 * When either endpoint performs a shutdown, the
+                 * association on each peer will stop accepting new
+                 * data from its user and only deliver data in queue
+                 * at the time of sending or receiving the SHUTDOWN
+                 * chunk.
+                 */
+                switch (q->asoc->state) {
+                case SCTP_STATE_EMPTY:
+                case SCTP_STATE_CLOSED:
+                case SCTP_STATE_SHUTDOWN_PENDING:
+                case SCTP_STATE_SHUTDOWN_SENT:
+                case SCTP_STATE_SHUTDOWN_RECEIVED:
+                case SCTP_STATE_SHUTDOWN_ACK_SENT:
+                        /* Cannot send after transport endpoint shutdown */
+                        error = -ESHUTDOWN;
+                        break;
+
+                default:
+                        SCTP_DEBUG_PRINTK("outqueueing (%p, %p[%s])\n",
+                          q, chunk, chunk && chunk->chunk_hdr ?
+                          sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type))
+                          : "Illegal Chunk");
+
+                        sctp_outq_tail_data(q, chunk);
+                        if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
+                                SCTP_INC_STATS(SCTP_MIB_OUTUNORDERCHUNKS);
+                        else
+                                SCTP_INC_STATS(SCTP_MIB_OUTORDERCHUNKS);
+                        q->empty = 0;
+                        break;
+                };
+        } else {
+                __skb_queue_tail(&q->control, (struct sk_buff *) chunk);
+                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+        }
+
+        if (error < 0)
+                return error;
+
+        if (!q->cork)
+                error = sctp_outq_flush(q, 0);
+
+        return error;
+}
+
+/* Insert a chunk into the sorted list based on the TSNs.  The retransmit list
+ * and the abandoned list are in ascending order.
+ */
+static void sctp_insert_list(struct list_head *head, struct list_head *new)
+{
+        struct list_head *pos;
+        struct sctp_chunk *nchunk, *lchunk;
+        __u32 ntsn, ltsn;
+        int done = 0;
+
+        nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
+        ntsn = ntohl(nchunk->subh.data_hdr->tsn);
+
+        list_for_each(pos, head) {
+                lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
+                ltsn = ntohl(lchunk->subh.data_hdr->tsn);
+                if (TSN_lt(ntsn, ltsn)) {
+                        list_add(new, pos->prev);
+                        done = 1;
+                        break;
+                }
+        }
+        if (!done)
+                list_add_tail(new, head); 
+}
+
+/* Mark all the eligible packets on a transport for retransmission.  */
+void sctp_retransmit_mark(struct sctp_outq *q,
+                          struct sctp_transport *transport,
+                          __u8 fast_retransmit)
+{
+        struct list_head *lchunk, *ltemp;
+        struct sctp_chunk *chunk;
+
+        /* Walk through the specified transmitted queue.  */
+        list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                   transmitted_list);
+
+                /* If the chunk is abandoned, move it to abandoned list. */
+                if (sctp_chunk_abandoned(chunk)) {
+                        list_del_init(lchunk);
+                        sctp_insert_list(&q->abandoned, lchunk);
+                        continue;
+                }
+
+                /* If we are doing retransmission due to a fast retransmit,
+                 * only the chunk's that are marked for fast retransmit
+                 * should be added to the retransmit queue.  If we are doing
+                 * retransmission due to a timeout or pmtu discovery, only the
+                 * chunks that are not yet acked should be added to the
+                 * retransmit queue.
+                 */
+                if ((fast_retransmit && chunk->fast_retransmit) ||
+                   (!fast_retransmit && !chunk->tsn_gap_acked)) {
+                        /* RFC 2960 6.2.1 Processing a Received SACK
+                         *
+                         * C) Any time a DATA chunk is marked for
+                         * retransmission (via either T3-rtx timer expiration
+                         * (Section 6.3.3) or via fast retransmit
+                         * (Section 7.2.4)), add the data size of those
+                         * chunks to the rwnd.
+                         */
+                        q->asoc->peer.rwnd += sctp_data_size(chunk);
+                        q->outstanding_bytes -= sctp_data_size(chunk);
+                        transport->flight_size -= sctp_data_size(chunk);
+
+                        /* sctpimpguide-05 Section 2.8.2
+                         * M5) If a T3-rtx timer expires, the
+                         * 'TSN.Missing.Report' of all affected TSNs is set
+                         * to 0.
+                         */
+                        chunk->tsn_missing_report = 0;
+
+                        /* If a chunk that is being used for RTT measurement
+                         * has to be retransmitted, we cannot use this chunk
+                         * anymore for RTT measurements. Reset rto_pending so
+                         * that a new RTT measurement is started when a new
+                         * data chunk is sent.
+                         */
+                        if (chunk->rtt_in_progress) {
+                                chunk->rtt_in_progress = 0;
+                                transport->rto_pending = 0;
+                        }
+
+                        /* Move the chunk to the retransmit queue. The chunks
+                         * on the retransmit queue are always kept in order.
+                         */
+                        list_del_init(lchunk);
+                        sctp_insert_list(&q->retransmit, lchunk);
+                }
+        }
+
+        SCTP_DEBUG_PRINTK("%s: transport: %p, fast_retransmit: %d, "
+                          "cwnd: %d, ssthresh: %d, flight_size: %d, "
+                          "pba: %d\n", __FUNCTION__,
+                          transport, fast_retransmit,
+                          transport->cwnd, transport->ssthresh,
+                          transport->flight_size,
+                          transport->partial_bytes_acked);
+
+}
+
+/* Mark all the eligible packets on a transport for retransmission and force
+ * one packet out.
+ */
+void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
+                     sctp_retransmit_reason_t reason)
+{
+        int error = 0;
+        __u8 fast_retransmit = 0;
+
+        switch(reason) {
+        case SCTP_RTXR_T3_RTX:
+                sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
+                /* Update the retran path if the T3-rtx timer has expired for
+                 * the current retran path.
+                 */
+                if (transport == transport->asoc->peer.retran_path)
+                        sctp_assoc_update_retran_path(transport->asoc);
+                break;
+        case SCTP_RTXR_FAST_RTX:
+                sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
+                fast_retransmit = 1;
+                break;
+        case SCTP_RTXR_PMTUD:
+        default:
+                break;
+        }
+
+        sctp_retransmit_mark(q, transport, fast_retransmit);
+
+        /* PR-SCTP A5) Any time the T3-rtx timer expires, on any destination,
+         * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by
+         * following the procedures outlined in C1 - C5.
+         */
+        sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
+
+        error = sctp_outq_flush(q, /* rtx_timeout */ 1);
+
+        if (error)
+                q->asoc->base.sk->sk_err = -error;
+}
+
+/*
+ * Transmit DATA chunks on the retransmit queue.  Upon return from
+ * sctp_outq_flush_rtx() the packet 'pkt' may contain chunks which
+ * need to be transmitted by the caller.
+ * We assume that pkt->transport has already been set.
+ *
+ * The return value is a normal kernel error return value.
+ */
+static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
+                               int rtx_timeout, int *start_timer)
+{
+        struct list_head *lqueue;
+        struct list_head *lchunk, *lchunk1;
+        struct sctp_transport *transport = pkt->transport;
+        sctp_xmit_t status;
+        struct sctp_chunk *chunk, *chunk1;
+        struct sctp_association *asoc;
+        int error = 0;
+
+        asoc = q->asoc;
+        lqueue = &q->retransmit;
+
+        /* RFC 2960 6.3.3 Handle T3-rtx Expiration
+         *
+         * E3) Determine how many of the earliest (i.e., lowest TSN)
+         * outstanding DATA chunks for the address for which the
+         * T3-rtx has expired will fit into a single packet, subject
+         * to the MTU constraint for the path corresponding to the
+         * destination transport address to which the retransmission
+         * is being sent (this may be different from the address for
+         * which the timer expires [see Section 6.4]). Call this value
+         * K. Bundle and retransmit those K DATA chunks in a single
+         * packet to the destination endpoint.
+         *
+         * [Just to be painfully clear, if we are retransmitting
+         * because a timeout just happened, we should send only ONE
+         * packet of retransmitted data.]
+         */
+        lchunk = sctp_list_dequeue(lqueue);
+
+        while (lchunk) {
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                   transmitted_list);
+
+                /* Make sure that Gap Acked TSNs are not retransmitted.  A
+                 * simple approach is just to move such TSNs out of the
+                 * way and into a 'transmitted' queue and skip to the
+                 * next chunk.
+                 */
+                if (chunk->tsn_gap_acked) {
+                        list_add_tail(lchunk, &transport->transmitted);
+                        lchunk = sctp_list_dequeue(lqueue);
+                        continue;
+                }
+
+                /* Attempt to append this chunk to the packet. */
+                status = sctp_packet_append_chunk(pkt, chunk);
+
+                switch (status) {
+                case SCTP_XMIT_PMTU_FULL:
+                        /* Send this packet.  */
+                        if ((error = sctp_packet_transmit(pkt)) == 0)
+                                *start_timer = 1;
+
+                        /* If we are retransmitting, we should only
+                         * send a single packet.
+                         */
+                        if (rtx_timeout) {
+                                list_add(lchunk, lqueue);
+                                lchunk = NULL;
+                        }
+
+                        /* Bundle lchunk in the next round.  */
+                        break;
+
+                case SCTP_XMIT_RWND_FULL:
+                        /* Send this packet. */
+                        if ((error = sctp_packet_transmit(pkt)) == 0)
+                                *start_timer = 1;
+
+                        /* Stop sending DATA as there is no more room
+                         * at the receiver.
+                         */
+                        list_add(lchunk, lqueue);
+                        lchunk = NULL;
+                        break;
+
+                case SCTP_XMIT_NAGLE_DELAY:
+                        /* Send this packet. */
+                        if ((error = sctp_packet_transmit(pkt)) == 0)
+                                *start_timer = 1;
+
+                        /* Stop sending DATA because of nagle delay. */
+                        list_add(lchunk, lqueue);
+                        lchunk = NULL;
+                        break;
+
+                default:
+                        /* The append was successful, so add this chunk to
+                         * the transmitted list.
+                         */
+                        list_add_tail(lchunk, &transport->transmitted);
+
+                        /* Mark the chunk as ineligible for fast retransmit 
+                         * after it is retransmitted.
+                         */
+                        chunk->fast_retransmit = 0;
+
+                        *start_timer = 1;
+                        q->empty = 0;
+
+                        /* Retrieve a new chunk to bundle. */
+                        lchunk = sctp_list_dequeue(lqueue);
+                        break;
+                };
+
+                /* If we are here due to a retransmit timeout or a fast
+                 * retransmit and if there are any chunks left in the retransmit
+                 * queue that could not fit in the PMTU sized packet, they need                  * to be marked as ineligible for a subsequent fast retransmit.
+                 */
+                if (rtx_timeout && !lchunk) {
+                        list_for_each(lchunk1, lqueue) {
+                                chunk1 = list_entry(lchunk1, struct sctp_chunk,
+                                                    transmitted_list);
+                                chunk1->fast_retransmit = 0;
+                        }
+                }
+        }
+
+        return error;
+}
+
+/* Cork the outqueue so queued chunks are really queued. */
+int sctp_outq_uncork(struct sctp_outq *q)
+{
+        int error = 0;
+        if (q->cork) {
+                q->cork = 0;
+                error = sctp_outq_flush(q, 0);
+        }
+        return error;
+}
+
+/*
+ * Try to flush an outqueue.
+ *
+ * Description: Send everything in q which we legally can, subject to
+ * congestion limitations.
+ * * Note: This function can be called from multiple contexts so appropriate
+ * locking concerns must be made.  Today we use the sock lock to protect
+ * this function.
+ */
+int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
+{
+        struct sctp_packet *packet;
+        struct sctp_packet singleton;
+        struct sctp_association *asoc = q->asoc;
+        __u16 sport = asoc->base.bind_addr.port;
+        __u16 dport = asoc->peer.port;
+        __u32 vtag = asoc->peer.i.init_tag;
+        struct sk_buff_head *queue;
+        struct sctp_transport *transport = NULL;
+        struct sctp_transport *new_transport;
+        struct sctp_chunk *chunk;
+        sctp_xmit_t status;
+        int error = 0;
+        int start_timer = 0;
+
+        /* These transports have chunks to send. */
+        struct list_head transport_list;
+        struct list_head *ltransport;
+
+        INIT_LIST_HEAD(&transport_list);
+        packet = NULL;
+
+        /*
+         * 6.10 Bundling
+         *   ...
+         *   When bundling control chunks with DATA chunks, an
+         *   endpoint MUST place control chunks first in the outbound
+         *   SCTP packet.  The transmitter MUST transmit DATA chunks
+         *   within a SCTP packet in increasing order of TSN.
+         *   ...
+         */
+
+        queue = &q->control;
+        while ((chunk = (struct sctp_chunk *)skb_dequeue(queue)) != NULL) {
+                /* Pick the right transport to use. */
+                new_transport = chunk->transport;
+
+                if (!new_transport) {
+                        new_transport = asoc->peer.active_path;
+                } else if (!new_transport->active) {
+                        /* If the chunk is Heartbeat or Heartbeat Ack, 
+                         * send it to chunk->transport, even if it's 
+                         * inactive.
+                         *
+                         * 3.3.6 Heartbeat Acknowledgement:
+                         * ...  
+                         * A HEARTBEAT ACK is always sent to the source IP
+                         * address of the IP datagram containing the
+                         * HEARTBEAT chunk to which this ack is responding.
+                         * ...  
+                         */
+                        if (chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT &&
+                            chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT_ACK)
+                                new_transport = asoc->peer.active_path;
+                }
+
+                /* Are we switching transports?
+                 * Take care of transport locks.
+                 */
+                if (new_transport != transport) {
+                        transport = new_transport;
+                        if (list_empty(&transport->send_ready)) {
+                                list_add_tail(&transport->send_ready,
+                                              &transport_list);
+                        }
+                        packet = &transport->packet;
+                        sctp_packet_config(packet, vtag,
+                                           asoc->peer.ecn_capable);
+                }
+
+                switch (chunk->chunk_hdr->type) {
+                /*
+                 * 6.10 Bundling
+                 *   ...
+                 *   An endpoint MUST NOT bundle INIT, INIT ACK or SHUTDOWN
+                 *   COMPLETE with any other chunks.  [Send them immediately.]
+                 */
+                case SCTP_CID_INIT:
+                case SCTP_CID_INIT_ACK:
+                case SCTP_CID_SHUTDOWN_COMPLETE:
+                        sctp_packet_init(&singleton, transport, sport, dport);
+                        sctp_packet_config(&singleton, vtag, 0);
+                        sctp_packet_append_chunk(&singleton, chunk);
+                        error = sctp_packet_transmit(&singleton);
+                        if (error < 0)
+                                return error;
+                        break;
+
+                case SCTP_CID_ABORT:
+                case SCTP_CID_SACK:
+                case SCTP_CID_HEARTBEAT:
+                case SCTP_CID_HEARTBEAT_ACK:
+                case SCTP_CID_SHUTDOWN:
+                case SCTP_CID_SHUTDOWN_ACK:
+                case SCTP_CID_ERROR:
+                case SCTP_CID_COOKIE_ECHO:
+                case SCTP_CID_COOKIE_ACK:
+                case SCTP_CID_ECN_ECNE:
+                case SCTP_CID_ECN_CWR:
+                case SCTP_CID_ASCONF:
+                case SCTP_CID_ASCONF_ACK:
+                case SCTP_CID_FWD_TSN:
+                        sctp_packet_transmit_chunk(packet, chunk);
+                        break;
+
+                default:
+                        /* We built a chunk with an illegal type! */
+                        BUG();
+                };
+        }
+
+        /* Is it OK to send data chunks?  */
+        switch (asoc->state) {
+        case SCTP_STATE_COOKIE_ECHOED:
+                /* Only allow bundling when this packet has a COOKIE-ECHO
+                 * chunk.
+                 */
+                if (!packet || !packet->has_cookie_echo)
+                        break;
+
+                /* fallthru */
+        case SCTP_STATE_ESTABLISHED:
+        case SCTP_STATE_SHUTDOWN_PENDING:
+        case SCTP_STATE_SHUTDOWN_RECEIVED:
+                /*
+                 * RFC 2960 6.1  Transmission of DATA Chunks
+                 *
+                 * C) When the time comes for the sender to transmit,
+                 * before sending new DATA chunks, the sender MUST
+                 * first transmit any outstanding DATA chunks which
+                 * are marked for retransmission (limited by the
+                 * current cwnd).
+                 */
+                if (!list_empty(&q->retransmit)) {
+                        if (transport == asoc->peer.retran_path)
+                                goto retran;
+
+                        /* Switch transports & prepare the packet.  */
+
+                        transport = asoc->peer.retran_path;
+
+                        if (list_empty(&transport->send_ready)) {
+                                list_add_tail(&transport->send_ready,
+                                              &transport_list);
+                        }
+
+                        packet = &transport->packet;
+                        sctp_packet_config(packet, vtag,
+                                           asoc->peer.ecn_capable);
+                retran:
+                        error = sctp_outq_flush_rtx(q, packet,
+                                                    rtx_timeout, &start_timer);
+
+                        if (start_timer)
+                                sctp_transport_reset_timers(transport);
+
+                        /* This can happen on COOKIE-ECHO resend.  Only
+                         * one chunk can get bundled with a COOKIE-ECHO.
+                         */
+                        if (packet->has_cookie_echo)
+                                goto sctp_flush_out;
+
+                        /* Don't send new data if there is still data
+                         * waiting to retransmit.
+                         */
+                        if (!list_empty(&q->retransmit))
+                                goto sctp_flush_out;
+                }
+
+                /* Finally, transmit new packets.  */
+                start_timer = 0;
+                queue = &q->out;
+
+                while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
+                        /* RFC 2960 6.5 Every DATA chunk MUST carry a valid
+                         * stream identifier.
+                         */
+                        if (chunk->sinfo.sinfo_stream >=
+                            asoc->c.sinit_num_ostreams) {
+
+                                /* Mark as failed send. */
+                                sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
+                                sctp_chunk_free(chunk);
+                                continue;
+                        }
+
+                        /* Has this chunk expired? */
+                        if (sctp_chunk_abandoned(chunk)) {
+                                sctp_chunk_fail(chunk, 0);
+                                sctp_chunk_free(chunk);
+                                continue;
+                        }
+
+                        /* If there is a specified transport, use it.
+                         * Otherwise, we want to use the active path.
+                         */
+                        new_transport = chunk->transport;
+                        if (!new_transport || !new_transport->active)
+                                new_transport = asoc->peer.active_path;
+
+                        /* Change packets if necessary.  */
+                        if (new_transport != transport) {
+                                transport = new_transport;
+
+                                /* Schedule to have this transport's
+                                 * packet flushed.
+                                 */
+                                if (list_empty(&transport->send_ready)) {
+                                        list_add_tail(&transport->send_ready,
+                                                      &transport_list);
+                                }
+
+                                packet = &transport->packet;
+                                sctp_packet_config(packet, vtag,
+                                                   asoc->peer.ecn_capable);
+                        }
+
+                        SCTP_DEBUG_PRINTK("sctp_outq_flush(%p, %p[%s]), ",
+                                          q, chunk,
+                                          chunk && chunk->chunk_hdr ?
+                                          sctp_cname(SCTP_ST_CHUNK(
+                                                  chunk->chunk_hdr->type))
+                                          : "Illegal Chunk");
+
+                        SCTP_DEBUG_PRINTK("TX TSN 0x%x skb->head "
+                                        "%p skb->users %d.\n",
+                                        ntohl(chunk->subh.data_hdr->tsn),
+                                        chunk->skb ?chunk->skb->head : NULL,
+                                        chunk->skb ?
+                                        atomic_read(&chunk->skb->users) : -1);
+
+                        /* Add the chunk to the packet.  */
+                        status = sctp_packet_transmit_chunk(packet, chunk);
+
+                        switch (status) {
+                        case SCTP_XMIT_PMTU_FULL:
+                        case SCTP_XMIT_RWND_FULL:
+                        case SCTP_XMIT_NAGLE_DELAY:
+                                /* We could not append this chunk, so put
+                                 * the chunk back on the output queue.
+                                 */
+                                SCTP_DEBUG_PRINTK("sctp_outq_flush: could "
+                                        "not transmit TSN: 0x%x, status: %d\n",
+                                        ntohl(chunk->subh.data_hdr->tsn),
+                                        status);
+                                sctp_outq_head_data(q, chunk);
+                                goto sctp_flush_out;
+                                break;
+
+                        case SCTP_XMIT_OK:
+                                break;
+
+                        default:
+                                BUG();
+                        }
+
+                        /* BUG: We assume that the sctp_packet_transmit() 
+                         * call below will succeed all the time and add the
+                         * chunk to the transmitted list and restart the
+                         * timers.
+                         * It is possible that the call can fail under OOM
+                         * conditions.
+                         *
+                         * Is this really a problem?  Won't this behave
+                         * like a lost TSN?
+                         */
+                        list_add_tail(&chunk->transmitted_list,
+                                      &transport->transmitted);
+
+                        sctp_transport_reset_timers(transport);
+
+                        q->empty = 0;
+
+                        /* Only let one DATA chunk get bundled with a
+                         * COOKIE-ECHO chunk.
+                         */
+                        if (packet->has_cookie_echo)
+                                goto sctp_flush_out;
+                }
+                break;
+
+        default:
+                /* Do nothing.  */
+                break;
+        }
+
+sctp_flush_out:
+
+        /* Before returning, examine all the transports touched in
+         * this call.  Right now, we bluntly force clear all the
+         * transports.  Things might change after we implement Nagle.
+         * But such an examination is still required.
+         *
+         * --xguo
+         */
+        while ((ltransport = sctp_list_dequeue(&transport_list)) != NULL ) {
+                struct sctp_transport *t = list_entry(ltransport,
+                                                      struct sctp_transport,
+                                                      send_ready);
+                packet = &t->packet;
+                if (!sctp_packet_empty(packet))
+                        error = sctp_packet_transmit(packet);
+        }
+
+        return error;
+}
+
+/* Update unack_data based on the incoming SACK chunk */
+static void sctp_sack_update_unack_data(struct sctp_association *assoc,
+                                        struct sctp_sackhdr *sack)
+{
+        sctp_sack_variable_t *frags;
+        __u16 unack_data;
+        int i;
+
+        unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
+
+        frags = sack->variable;
+        for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
+                unack_data -= ((ntohs(frags[i].gab.end) -
+                                ntohs(frags[i].gab.start) + 1));
+        }
+
+        assoc->unack_data = unack_data;
+}
+
+/* Return the highest new tsn that is acknowledged by the given SACK chunk. */
+static __u32 sctp_highest_new_tsn(struct sctp_sackhdr *sack,
+                                  struct sctp_association *asoc)
+{
+        struct list_head *ltransport, *lchunk;
+        struct sctp_transport *transport;
+        struct sctp_chunk *chunk;
+        __u32 highest_new_tsn, tsn;
+        struct list_head *transport_list = &asoc->peer.transport_addr_list;
+
+        highest_new_tsn = ntohl(sack->cum_tsn_ack);
+
+        list_for_each(ltransport, transport_list) {
+                transport = list_entry(ltransport, struct sctp_transport,
+                                       transports);
+                list_for_each(lchunk, &transport->transmitted) {
+                        chunk = list_entry(lchunk, struct sctp_chunk,
+                                           transmitted_list);
+                        tsn = ntohl(chunk->subh.data_hdr->tsn);
+
+                        if (!chunk->tsn_gap_acked &&
+                            TSN_lt(highest_new_tsn, tsn) &&
+                            sctp_acked(sack, tsn))
+                                highest_new_tsn = tsn;
+                }
+        }
+
+        return highest_new_tsn;
+}
+
+/* This is where we REALLY process a SACK.
+ *
+ * Process the SACK against the outqueue.  Mostly, this just frees
+ * things off the transmitted queue.
+ */
+int sctp_outq_sack(struct sctp_outq *q, struct sctp_sackhdr *sack)
+{
+        struct sctp_association *asoc = q->asoc;
+        struct sctp_transport *transport;
+        struct sctp_chunk *tchunk = NULL;
+        struct list_head *lchunk, *transport_list, *pos, *temp;
+        sctp_sack_variable_t *frags = sack->variable;
+        __u32 sack_ctsn, ctsn, tsn;
+        __u32 highest_tsn, highest_new_tsn;
+        __u32 sack_a_rwnd;
+        unsigned outstanding;
+        struct sctp_transport *primary = asoc->peer.primary_path;
+        int count_of_newacks = 0;
+
+        /* Grab the association's destination address list. */
+        transport_list = &asoc->peer.transport_addr_list;
+
+        sack_ctsn = ntohl(sack->cum_tsn_ack);
+
+        /*
+         * SFR-CACC algorithm:
+         * On receipt of a SACK the sender SHOULD execute the
+         * following statements.
+         *
+         * 1) If the cumulative ack in the SACK passes next tsn_at_change
+         * on the current primary, the CHANGEOVER_ACTIVE flag SHOULD be
+         * cleared. The CYCLING_CHANGEOVER flag SHOULD also be cleared for
+         * all destinations.
+         */
+        if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
+                primary->cacc.changeover_active = 0;
+                list_for_each(pos, transport_list) {
+                        transport = list_entry(pos, struct sctp_transport,
+                                        transports);
+                        transport->cacc.cycling_changeover = 0;
+                }
+        }
+
+        /*
+         * SFR-CACC algorithm:
+         * 2) If the SACK contains gap acks and the flag CHANGEOVER_ACTIVE
+         * is set the receiver of the SACK MUST take the following actions:
+         *
+         * A) Initialize the cacc_saw_newack to 0 for all destination
+         * addresses.
+         */
+        if (sack->num_gap_ack_blocks > 0 &&
+            primary->cacc.changeover_active) {
+                list_for_each(pos, transport_list) {
+                        transport = list_entry(pos, struct sctp_transport,
+                                        transports);
+                        transport->cacc.cacc_saw_newack = 0;
+                }
+        }
+
+        /* Get the highest TSN in the sack. */
+        highest_tsn = sack_ctsn;
+        if (sack->num_gap_ack_blocks)
+                highest_tsn +=
+                    ntohs(frags[ntohs(sack->num_gap_ack_blocks) - 1].gab.end);
+
+        if (TSN_lt(asoc->highest_sacked, highest_tsn)) {
+                highest_new_tsn = highest_tsn;
+                asoc->highest_sacked = highest_tsn;
+        } else {
+                highest_new_tsn = sctp_highest_new_tsn(sack, asoc);
+        }
+
+        /* Run through the retransmit queue.  Credit bytes received
+         * and free those chunks that we can.
+         */
+        sctp_check_transmitted(q, &q->retransmit, NULL, sack, highest_new_tsn);
+        sctp_mark_missing(q, &q->retransmit, NULL, highest_new_tsn, 0);
+
+        /* Run through the transmitted queue.
+         * Credit bytes received and free those chunks which we can.
+         *
+         * This is a MASSIVE candidate for optimization.
+         */
+        list_for_each(pos, transport_list) {
+                transport  = list_entry(pos, struct sctp_transport,
+                                        transports);
+                sctp_check_transmitted(q, &transport->transmitted,
+                                       transport, sack, highest_new_tsn);
+                /*
+                 * SFR-CACC algorithm:
+                 * C) Let count_of_newacks be the number of
+                 * destinations for which cacc_saw_newack is set.
+                 */
+                if (transport->cacc.cacc_saw_newack)
+                        count_of_newacks ++;
+        }
+
+        list_for_each(pos, transport_list) {
+                transport  = list_entry(pos, struct sctp_transport,
+                                        transports);
+                sctp_mark_missing(q, &transport->transmitted, transport,
+                                  highest_new_tsn, count_of_newacks);
+        }
+
+        /* Move the Cumulative TSN Ack Point if appropriate.  */
+        if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn))
+                asoc->ctsn_ack_point = sack_ctsn;
+
+        /* Update unack_data field in the assoc. */
+        sctp_sack_update_unack_data(asoc, sack);
+
+        ctsn = asoc->ctsn_ack_point;
+
+        /* Throw away stuff rotting on the sack queue.  */
+        list_for_each_safe(lchunk, temp, &q->sacked) {
+                tchunk = list_entry(lchunk, struct sctp_chunk,
+                                    transmitted_list);
+                tsn = ntohl(tchunk->subh.data_hdr->tsn);
+                if (TSN_lte(tsn, ctsn))
+                        sctp_chunk_free(tchunk);
+        }
+
+        /* ii) Set rwnd equal to the newly received a_rwnd minus the
+         *     number of bytes still outstanding after processing the
+         *     Cumulative TSN Ack and the Gap Ack Blocks.
+         */
+
+        sack_a_rwnd = ntohl(sack->a_rwnd);
+        outstanding = q->outstanding_bytes;
+
+        if (outstanding < sack_a_rwnd)
+                sack_a_rwnd -= outstanding;
+        else
+                sack_a_rwnd = 0;
+
+        asoc->peer.rwnd = sack_a_rwnd;
+
+        sctp_generate_fwdtsn(q, sack_ctsn);
+
+        SCTP_DEBUG_PRINTK("%s: sack Cumulative TSN Ack is 0x%x.\n",
+                          __FUNCTION__, sack_ctsn);
+        SCTP_DEBUG_PRINTK("%s: Cumulative TSN Ack of association, "
+                          "%p is 0x%x. Adv peer ack point: 0x%x\n",
+                          __FUNCTION__, asoc, ctsn, asoc->adv_peer_ack_point);
+
+        /* See if all chunks are acked.
+         * Make sure the empty queue handler will get run later.
+         */
+        q->empty = skb_queue_empty(&q->out) && skb_queue_empty(&q->control) &&
+                        list_empty(&q->retransmit);
+        if (!q->empty)
+                goto finish;
+
+        list_for_each(pos, transport_list) {
+                transport  = list_entry(pos, struct sctp_transport,
+                                        transports);
+                q->empty = q->empty && list_empty(&transport->transmitted);
+                if (!q->empty)
+                        goto finish;
+        }
+
+        SCTP_DEBUG_PRINTK("sack queue is empty.\n");
+finish:
+        return q->empty;
+}
+
+/* Is the outqueue empty?  */
+int sctp_outq_is_empty(const struct sctp_outq *q)
+{
+        return q->empty;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* Go through a transport's transmitted list or the association's retransmit
+ * list and move chunks that are acked by the Cumulative TSN Ack to q->sacked.
+ * The retransmit list will not have an associated transport.
+ *
+ * I added coherent debug information output.   --xguo
+ *
+ * Instead of printing 'sacked' or 'kept' for each TSN on the
+ * transmitted_queue, we print a range: SACKED: TSN1-TSN2, TSN3, TSN4-TSN5.
+ * KEPT TSN6-TSN7, etc.
+ */
+static void sctp_check_transmitted(struct sctp_outq *q,
+                                   struct list_head *transmitted_queue,
+                                   struct sctp_transport *transport,
+                                   struct sctp_sackhdr *sack,
+                                   __u32 highest_new_tsn_in_sack)
+{
+        struct list_head *lchunk;
+        struct sctp_chunk *tchunk;
+        struct list_head tlist;
+        __u32 tsn;
+        __u32 sack_ctsn;
+        __u32 rtt;
+        __u8 restart_timer = 0;
+        int bytes_acked = 0;
+
+        /* These state variables are for coherent debug output. --xguo */
+
+#if SCTP_DEBUG
+        __u32 dbg_ack_tsn = 0;  /* An ACKed TSN range starts here... */
+        __u32 dbg_last_ack_tsn = 0;  /* ...and finishes here.        */
+        __u32 dbg_kept_tsn = 0; /* An un-ACKed range starts here...  */
+        __u32 dbg_last_kept_tsn = 0; /* ...and finishes here.        */
+
+        /* 0 : The last TSN was ACKed.
+         * 1 : The last TSN was NOT ACKed (i.e. KEPT).
+         * -1: We need to initialize.
+         */
+        int dbg_prt_state = -1;
+#endif /* SCTP_DEBUG */
+
+        sack_ctsn = ntohl(sack->cum_tsn_ack);
+
+        INIT_LIST_HEAD(&tlist);
+
+        /* The while loop will skip empty transmitted queues. */
+        while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
+                tchunk = list_entry(lchunk, struct sctp_chunk,
+                                    transmitted_list);
+
+                if (sctp_chunk_abandoned(tchunk)) {
+                        /* Move the chunk to abandoned list. */
+                        sctp_insert_list(&q->abandoned, lchunk);
+                        continue;
+                }
+
+                tsn = ntohl(tchunk->subh.data_hdr->tsn);
+                if (sctp_acked(sack, tsn)) {
+                        /* If this queue is the retransmit queue, the
+                         * retransmit timer has already reclaimed
+                         * the outstanding bytes for this chunk, so only
+                         * count bytes associated with a transport.
+                         */
+                        if (transport) {
+                                /* If this chunk is being used for RTT
+                                 * measurement, calculate the RTT and update
+                                 * the RTO using this value.
+                                 *
+                                 * 6.3.1 C5) Karn's algorithm: RTT measurements
+                                 * MUST NOT be made using packets that were
+                                 * retransmitted (and thus for which it is
+                                 * ambiguous whether the reply was for the
+                                 * first instance of the packet or a later
+                                 * instance).
+                                 */
+                                if (!tchunk->tsn_gap_acked &&
+                                    !tchunk->resent &&
+                                    tchunk->rtt_in_progress) {
+                                        rtt = jiffies - tchunk->sent_at;
+                                        sctp_transport_update_rto(transport,
+                                                                  rtt);
+                                }
+                        }
+                        if (TSN_lte(tsn, sack_ctsn)) {
+                                /* RFC 2960  6.3.2 Retransmission Timer Rules
+                                 *
+                                 * R3) Whenever a SACK is received
+                                 * that acknowledges the DATA chunk
+                                 * with the earliest outstanding TSN
+                                 * for that address, restart T3-rtx
+                                 * timer for that address with its
+                                 * current RTO.
+                                 */
+                                restart_timer = 1;
+
+                                if (!tchunk->tsn_gap_acked) {
+                                        tchunk->tsn_gap_acked = 1;
+                                        bytes_acked += sctp_data_size(tchunk);
+                                        /*
+                                         * SFR-CACC algorithm:
+                                         * 2) If the SACK contains gap acks
+                                         * and the flag CHANGEOVER_ACTIVE is
+                                         * set the receiver of the SACK MUST
+                                         * take the following action:
+                                         *
+                                         * B) For each TSN t being acked that
+                                         * has not been acked in any SACK so
+                                         * far, set cacc_saw_newack to 1 for
+                                         * the destination that the TSN was
+                                         * sent to.
+                                         */
+                                        if (transport &&
+                                            sack->num_gap_ack_blocks &&
+                                            q->asoc->peer.primary_path->cacc.
+                                            changeover_active)
+                                                transport->cacc.cacc_saw_newack
+                                                        = 1;
+                                }
+
+                                list_add_tail(&tchunk->transmitted_list,
+                                              &q->sacked);
+                        } else {
+                                /* RFC2960 7.2.4, sctpimpguide-05 2.8.2
+                                 * M2) Each time a SACK arrives reporting
+                                 * 'Stray DATA chunk(s)' record the highest TSN
+                                 * reported as newly acknowledged, call this
+                                 * value 'HighestTSNinSack'. A newly
+                                 * acknowledged DATA chunk is one not
+                                 * previously acknowledged in a SACK.
+                                 *
+                                 * When the SCTP sender of data receives a SACK
+                                 * chunk that acknowledges, for the first time,
+                                 * the receipt of a DATA chunk, all the still
+                                 * unacknowledged DATA chunks whose TSN is
+                                 * older than that newly acknowledged DATA
+                                 * chunk, are qualified as 'Stray DATA chunks'.
+                                 */
+                                if (!tchunk->tsn_gap_acked) {
+                                        tchunk->tsn_gap_acked = 1;
+                                        bytes_acked += sctp_data_size(tchunk);
+                                }
+                                list_add_tail(lchunk, &tlist);
+                        }
+
+#if SCTP_DEBUG
+                        switch (dbg_prt_state) {
+                        case 0: /* last TSN was ACKed */
+                                if (dbg_last_ack_tsn + 1 == tsn) {
+                                        /* This TSN belongs to the
+                                         * current ACK range.
+                                         */
+                                        break;
+                                }
+
+                                if (dbg_last_ack_tsn != dbg_ack_tsn) {
+                                        /* Display the end of the
+                                         * current range.
+                                         */
+                                        SCTP_DEBUG_PRINTK("-%08x",
+                                                          dbg_last_ack_tsn);
+                                }
+
+                                /* Start a new range.  */
+                                SCTP_DEBUG_PRINTK(",%08x", tsn);
+                                dbg_ack_tsn = tsn;
+                                break;
+
+                        case 1: /* The last TSN was NOT ACKed. */
+                                if (dbg_last_kept_tsn != dbg_kept_tsn) {
+                                        /* Display the end of current range. */
+                                        SCTP_DEBUG_PRINTK("-%08x",
+                                                          dbg_last_kept_tsn);
+                                }
+
+                                SCTP_DEBUG_PRINTK("\n");
+
+                                /* FALL THROUGH... */
+                        default:
+                                /* This is the first-ever TSN we examined.  */
+                                /* Start a new range of ACK-ed TSNs.  */
+                                SCTP_DEBUG_PRINTK("ACKed: %08x", tsn);
+                                dbg_prt_state = 0;
+                                dbg_ack_tsn = tsn;
+                        };
+
+                        dbg_last_ack_tsn = tsn;
+#endif /* SCTP_DEBUG */
+
+                } else {
+                        if (tchunk->tsn_gap_acked) {
+                                SCTP_DEBUG_PRINTK("%s: Receiver reneged on "
+                                                  "data TSN: 0x%x\n",
+                                                  __FUNCTION__,
+                                                  tsn);
+                                tchunk->tsn_gap_acked = 0;
+
+                                bytes_acked -= sctp_data_size(tchunk);
+
+                                /* RFC 2960 6.3.2 Retransmission Timer Rules
+                                 *
+                                 * R4) Whenever a SACK is received missing a
+                                 * TSN that was previously acknowledged via a
+                                 * Gap Ack Block, start T3-rtx for the
+                                 * destination address to which the DATA
+                                 * chunk was originally
+                                 * transmitted if it is not already running.
+                                 */
+                                restart_timer = 1;
+                        }
+
+                        list_add_tail(lchunk, &tlist);
+
+#if SCTP_DEBUG
+                        /* See the above comments on ACK-ed TSNs. */
+                        switch (dbg_prt_state) {
+                        case 1:
+                                if (dbg_last_kept_tsn + 1 == tsn)
+                                        break;
+
+                                if (dbg_last_kept_tsn != dbg_kept_tsn)
+                                        SCTP_DEBUG_PRINTK("-%08x",
+                                                          dbg_last_kept_tsn);
+
+                                SCTP_DEBUG_PRINTK(",%08x", tsn);
+                                dbg_kept_tsn = tsn;
+                                break;
+
+                        case 0:
+                                if (dbg_last_ack_tsn != dbg_ack_tsn)
+                                        SCTP_DEBUG_PRINTK("-%08x",
+                                                          dbg_last_ack_tsn);
+                                SCTP_DEBUG_PRINTK("\n");
+
+                                /* FALL THROUGH... */
+                        default:
+                                SCTP_DEBUG_PRINTK("KEPT: %08x",tsn);
+                                dbg_prt_state = 1;
+                                dbg_kept_tsn = tsn;
+                        };
+
+                        dbg_last_kept_tsn = tsn;
+#endif /* SCTP_DEBUG */
+                }
+        }
+
+#if SCTP_DEBUG
+        /* Finish off the last range, displaying its ending TSN.  */
+        switch (dbg_prt_state) {
+        case 0:
+                if (dbg_last_ack_tsn != dbg_ack_tsn) {
+                        SCTP_DEBUG_PRINTK("-%08x\n", dbg_last_ack_tsn);
+                } else {
+                        SCTP_DEBUG_PRINTK("\n");
+                }
+        break;
+
+        case 1:
+                if (dbg_last_kept_tsn != dbg_kept_tsn) {
+                        SCTP_DEBUG_PRINTK("-%08x\n", dbg_last_kept_tsn);
+                } else {
+                        SCTP_DEBUG_PRINTK("\n");
+                }
+        };
+#endif /* SCTP_DEBUG */
+        if (transport) {
+                if (bytes_acked) {
+                        /* 8.2. When an outstanding TSN is acknowledged,
+                         * the endpoint shall clear the error counter of
+                         * the destination transport address to which the
+                         * DATA chunk was last sent.
+                         * The association's overall error counter is
+                         * also cleared.
+                         */
+                        transport->error_count = 0;
+                        transport->asoc->overall_error_count = 0;
+
+                        /* Mark the destination transport address as
+                         * active if it is not so marked.
+                         */
+                        if (!transport->active) {
+                                sctp_assoc_control_transport(
+                                        transport->asoc,
+                                        transport,
+                                        SCTP_TRANSPORT_UP,
+                                        SCTP_RECEIVED_SACK);
+                        }
+
+                        sctp_transport_raise_cwnd(transport, sack_ctsn,
+                                                  bytes_acked);
+
+                        transport->flight_size -= bytes_acked;
+                        q->outstanding_bytes -= bytes_acked;
+                } else {
+                        /* RFC 2960 6.1, sctpimpguide-06 2.15.2
+                         * When a sender is doing zero window probing, it
+                         * should not timeout the association if it continues
+                         * to receive new packets from the receiver. The
+                         * reason is that the receiver MAY keep its window
+                         * closed for an indefinite time.
+                         * A sender is doing zero window probing when the
+                         * receiver's advertised window is zero, and there is
+                         * only one data chunk in flight to the receiver.
+                         */
+                        if (!q->asoc->peer.rwnd &&
+                            !list_empty(&tlist) &&
+                            (sack_ctsn+2 == q->asoc->next_tsn)) {
+                                SCTP_DEBUG_PRINTK("%s: SACK received for zero "
+                                                  "window probe: %u\n",
+                                                  __FUNCTION__, sack_ctsn);
+                                q->asoc->overall_error_count = 0;
+                                transport->error_count = 0;
+                        }
+                }
+
+                /* RFC 2960 6.3.2 Retransmission Timer Rules
+                 *
+                 * R2) Whenever all outstanding data sent to an address have
+                 * been acknowledged, turn off the T3-rtx timer of that
+                 * address.
+                 */
+                if (!transport->flight_size) {
+                        if (timer_pending(&transport->T3_rtx_timer) &&
+                            del_timer(&transport->T3_rtx_timer)) {
+                                sctp_transport_put(transport);
+                        }
+                } else if (restart_timer) {
+                        if (!mod_timer(&transport->T3_rtx_timer,
+                                       jiffies + transport->rto))
+                                sctp_transport_hold(transport);
+                }
+        }
+
+        list_splice(&tlist, transmitted_queue);
+}
+
+/* Mark chunks as missing and consequently may get retransmitted. */
+static void sctp_mark_missing(struct sctp_outq *q,
+                              struct list_head *transmitted_queue,
+                              struct sctp_transport *transport,
+                              __u32 highest_new_tsn_in_sack,
+                              int count_of_newacks)
+{
+        struct sctp_chunk *chunk;
+        struct list_head *pos;
+        __u32 tsn;
+        char do_fast_retransmit = 0;
+        struct sctp_transport *primary = q->asoc->peer.primary_path;
+
+        list_for_each(pos, transmitted_queue) {
+
+                chunk = list_entry(pos, struct sctp_chunk, transmitted_list);
+                tsn = ntohl(chunk->subh.data_hdr->tsn);
+
+                /* RFC 2960 7.2.4, sctpimpguide-05 2.8.2 M3) Examine all
+                 * 'Unacknowledged TSN's', if the TSN number of an
+                 * 'Unacknowledged TSN' is smaller than the 'HighestTSNinSack'
+                 * value, increment the 'TSN.Missing.Report' count on that
+                 * chunk if it has NOT been fast retransmitted or marked for
+                 * fast retransmit already.
+                 */
+                if (!chunk->fast_retransmit &&
+                    !chunk->tsn_gap_acked &&
+                    TSN_lt(tsn, highest_new_tsn_in_sack)) {
+
+                        /* SFR-CACC may require us to skip marking
+                         * this chunk as missing.
+                         */
+                        if (!transport || !sctp_cacc_skip(primary, transport,
+                                            count_of_newacks, tsn)) {
+                                chunk->tsn_missing_report++;
+
+                                SCTP_DEBUG_PRINTK(
+                                        "%s: TSN 0x%x missing counter: %d\n",
+                                        __FUNCTION__, tsn,
+                                        chunk->tsn_missing_report);
+                        }
+                }
+                /*
+                 * M4) If any DATA chunk is found to have a
+                 * 'TSN.Missing.Report'
+                 * value larger than or equal to 4, mark that chunk for
+                 * retransmission and start the fast retransmit procedure.
+                 */
+
+                if (chunk->tsn_missing_report >= 4) {
+                        chunk->fast_retransmit = 1;
+                        do_fast_retransmit = 1;
+                }
+        }
+
+        if (transport) {
+                if (do_fast_retransmit)
+                        sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
+
+                SCTP_DEBUG_PRINTK("%s: transport: %p, cwnd: %d, "
+                                  "ssthresh: %d, flight_size: %d, pba: %d\n",
+                                  __FUNCTION__, transport, transport->cwnd,
+                                  transport->ssthresh, transport->flight_size,
+                                  transport->partial_bytes_acked);
+        }
+}
+
+/* Is the given TSN acked by this packet?  */
+static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
+{
+        int i;
+        sctp_sack_variable_t *frags;
+        __u16 gap;
+        __u32 ctsn = ntohl(sack->cum_tsn_ack);
+
+        if (TSN_lte(tsn, ctsn))
+                goto pass;
+
+        /* 3.3.4 Selective Acknowledgement (SACK) (3):
+         *
+         * Gap Ack Blocks:
+         *  These fields contain the Gap Ack Blocks. They are repeated
+         *  for each Gap Ack Block up to the number of Gap Ack Blocks
+         *  defined in the Number of Gap Ack Blocks field. All DATA
+         *  chunks with TSNs greater than or equal to (Cumulative TSN
+         *  Ack + Gap Ack Block Start) and less than or equal to
+         *  (Cumulative TSN Ack + Gap Ack Block End) of each Gap Ack
+         *  Block are assumed to have been received correctly.
+         */
+
+        frags = sack->variable;
+        gap = tsn - ctsn;
+        for (i = 0; i < ntohs(sack->num_gap_ack_blocks); ++i) {
+                if (TSN_lte(ntohs(frags[i].gab.start), gap) &&
+                    TSN_lte(gap, ntohs(frags[i].gab.end)))
+                        goto pass;
+        }
+
+        return 0;
+pass:
+        return 1;
+}
+
+static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
+                                    int nskips, __u16 stream)
+{
+        int i;
+
+        for (i = 0; i < nskips; i++) {
+                if (skiplist[i].stream == stream)
+                        return i;
+        }
+        return i;
+}
+
+/* Create and add a fwdtsn chunk to the outq's control queue if needed. */
+static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
+{
+        struct sctp_association *asoc = q->asoc;
+        struct sctp_chunk *ftsn_chunk = NULL;
+        struct sctp_fwdtsn_skip ftsn_skip_arr[10];
+        int nskips = 0;
+        int skip_pos = 0;
+        __u32 tsn;
+        struct sctp_chunk *chunk;
+        struct list_head *lchunk, *temp;
+
+        /* PR-SCTP C1) Let SackCumAck be the Cumulative TSN ACK carried in the
+         * received SACK.
+         * 
+         * If (Advanced.Peer.Ack.Point < SackCumAck), then update
+         * Advanced.Peer.Ack.Point to be equal to SackCumAck.
+         */
+        if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
+                asoc->adv_peer_ack_point = ctsn;
+
+        /* PR-SCTP C2) Try to further advance the "Advanced.Peer.Ack.Point"
+         * locally, that is, to move "Advanced.Peer.Ack.Point" up as long as
+         * the chunk next in the out-queue space is marked as "abandoned" as
+         * shown in the following example:
+         *
+         * Assuming that a SACK arrived with the Cumulative TSN ACK 102
+         * and the Advanced.Peer.Ack.Point is updated to this value:
+         * 
+         *   out-queue at the end of  ==>   out-queue after Adv.Ack.Point
+         *   normal SACK processing           local advancement
+         *                ...                           ...
+         *   Adv.Ack.Pt-> 102 acked                     102 acked
+         *                103 abandoned                 103 abandoned
+         *                104 abandoned     Adv.Ack.P-> 104 abandoned
+         *                105                           105
+         *                106 acked                     106 acked
+         *                ...                           ...
+         *
+         * In this example, the data sender successfully advanced the
+         * "Advanced.Peer.Ack.Point" from 102 to 104 locally.
+         */
+        list_for_each_safe(lchunk, temp, &q->abandoned) {
+                chunk = list_entry(lchunk, struct sctp_chunk,
+                                        transmitted_list);
+                tsn = ntohl(chunk->subh.data_hdr->tsn);
+
+                /* Remove any chunks in the abandoned queue that are acked by
+                 * the ctsn.
+                 */ 
+                if (TSN_lte(tsn, ctsn)) {
+                        list_del_init(lchunk);
+                        if (!chunk->tsn_gap_acked) {
+                        chunk->transport->flight_size -=
+                                                 sctp_data_size(chunk);
+                        q->outstanding_bytes -= sctp_data_size(chunk);
+                        }
+                        sctp_chunk_free(chunk);
+                } else {
+                        if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
+                                asoc->adv_peer_ack_point = tsn;
+                                if (chunk->chunk_hdr->flags &
+                                         SCTP_DATA_UNORDERED)
+                                        continue;
+                                skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
+                                                nskips,
+                                                chunk->subh.data_hdr->stream);
+                                ftsn_skip_arr[skip_pos].stream =
+                                        chunk->subh.data_hdr->stream;
+                                ftsn_skip_arr[skip_pos].ssn =
+                                         chunk->subh.data_hdr->ssn;
+                                if (skip_pos == nskips)
+                                        nskips++;
+                                if (nskips == 10)
+                                        break;
+                        } else
+                                break;
+                }
+        }
+
+        /* PR-SCTP C3) If, after step C1 and C2, the "Advanced.Peer.Ack.Point"
+         * is greater than the Cumulative TSN ACK carried in the received
+         * SACK, the data sender MUST send the data receiver a FORWARD TSN
+         * chunk containing the latest value of the
+         * "Advanced.Peer.Ack.Point".
+         *
+         * C4) For each "abandoned" TSN the sender of the FORWARD TSN SHOULD
+         * list each stream and sequence number in the forwarded TSN. This
+         * information will enable the receiver to easily find any
+         * stranded TSN's waiting on stream reorder queues. Each stream
+         * SHOULD only be reported once; this means that if multiple
+         * abandoned messages occur in the same stream then only the
+         * highest abandoned stream sequence number is reported. If the
+         * total size of the FORWARD TSN does NOT fit in a single MTU then
+         * the sender of the FORWARD TSN SHOULD lower the
+         * Advanced.Peer.Ack.Point to the last TSN that will fit in a
+         * single MTU.
+         */
+        if (asoc->adv_peer_ack_point > ctsn)
+                ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
+                                              nskips, &ftsn_skip_arr[0]); 
+
+        if (ftsn_chunk) {
+                __skb_queue_tail(&q->control, (struct sk_buff *)ftsn_chunk);
+                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+        }
+}
diff --git a/net/sctp/primitive.c b/net/sctp/primitive.c
new file mode 100644
index 000000000000..3a7ebfcc1fdb
--- /dev/null
+++ b/net/sctp/primitive.c
@@ -0,0 +1,219 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions implement the SCTP primitive functions from Section 10.
+ *
+ * Note that the descriptions from the specification are USER level
+ * functions--this file is the functions which populate the struct proto
+ * for SCTP which is the BOTTOM of the sockets interface.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Narasimha Budihal     <narasimha@refcode.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Kevin Gao             <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/list.h> /* For struct list_head */
+#include <linux/socket.h>
+#include <linux/ip.h>
+#include <linux/time.h> /* For struct timeval */
+#include <net/sock.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+#define DECLARE_PRIMITIVE(name) \
+/* This is called in the code as sctp_primitive_ ## name.  */ \
+int sctp_primitive_ ## name(struct sctp_association *asoc, \
+                            void *arg) { \
+        int error = 0; \
+        sctp_event_t event_type; sctp_subtype_t subtype; \
+        sctp_state_t state; \
+        struct sctp_endpoint *ep; \
+        \
+        event_type = SCTP_EVENT_T_PRIMITIVE; \
+        subtype = SCTP_ST_PRIMITIVE(SCTP_PRIMITIVE_ ## name); \
+        state = asoc ? asoc->state : SCTP_STATE_CLOSED; \
+        ep = asoc ? asoc->ep : NULL; \
+        \
+        error = sctp_do_sm(event_type, subtype, state, ep, asoc, \
+                           arg, GFP_KERNEL); \
+        return error; \
+}
+
+/* 10.1 ULP-to-SCTP
+ * B) Associate
+ *
+ * Format: ASSOCIATE(local SCTP instance name, destination transport addr,
+ *         outbound stream count)
+ * -> association id [,destination transport addr list] [,outbound stream
+ *    count]
+ *
+ * This primitive allows the upper layer to initiate an association to a
+ * specific peer endpoint.
+ *
+ * This version assumes that asoc is fully populated with the initial
+ * parameters.  We then return a traditional kernel indicator of
+ * success or failure.
+ */
+
+/* This is called in the code as sctp_primitive_ASSOCIATE.  */
+
+DECLARE_PRIMITIVE(ASSOCIATE)
+
+/* 10.1 ULP-to-SCTP
+ * C) Shutdown
+ *
+ * Format: SHUTDOWN(association id)
+ * -> result
+ *
+ * Gracefully closes an association. Any locally queued user data
+ * will be delivered to the peer. The association will be terminated only
+ * after the peer acknowledges all the SCTP packets sent.  A success code
+ * will be returned on successful termination of the association. If
+ * attempting to terminate the association results in a failure, an error
+ * code shall be returned.
+ */
+
+DECLARE_PRIMITIVE(SHUTDOWN);
+
+/* 10.1 ULP-to-SCTP
+ * C) Abort
+ *
+ * Format: Abort(association id [, cause code])
+ * -> result
+ *
+ * Ungracefully closes an association. Any locally queued user data
+ * will be discarded and an ABORT chunk is sent to the peer. A success
+ * code will be returned on successful abortion of the association. If
+ * attempting to abort the association results in a failure, an error
+ * code shall be returned.
+ */
+
+DECLARE_PRIMITIVE(ABORT);
+
+/* 10.1 ULP-to-SCTP
+ * E) Send
+ *
+ * Format: SEND(association id, buffer address, byte count [,context]
+ *         [,stream id] [,life time] [,destination transport address]
+ *         [,unorder flag] [,no-bundle flag] [,payload protocol-id] )
+ * -> result
+ *
+ * This is the main method to send user data via SCTP.
+ *
+ * Mandatory attributes:
+ *
+ *  o association id - local handle to the SCTP association
+ *
+ *  o buffer address - the location where the user message to be
+ *    transmitted is stored;
+ *
+ *  o byte count - The size of the user data in number of bytes;
+ *
+ * Optional attributes:
+ *
+ *  o context - an optional 32 bit integer that will be carried in the
+ *    sending failure notification to the ULP if the transportation of
+ *    this User Message fails.
+ *
+ *  o stream id - to indicate which stream to send the data on. If not
+ *    specified, stream 0 will be used.
+ *
+ *  o life time - specifies the life time of the user data. The user data
+ *    will not be sent by SCTP after the life time expires. This
+ *    parameter can be used to avoid efforts to transmit stale
+ *    user messages. SCTP notifies the ULP if the data cannot be
+ *    initiated to transport (i.e. sent to the destination via SCTP's
+ *    send primitive) within the life time variable. However, the
+ *    user data will be transmitted if SCTP has attempted to transmit a
+ *    chunk before the life time expired.
+ *
+ *  o destination transport address - specified as one of the destination
+ *    transport addresses of the peer endpoint to which this packet
+ *    should be sent. Whenever possible, SCTP should use this destination
+ *    transport address for sending the packets, instead of the current
+ *    primary path.
+ *
+ *  o unorder flag - this flag, if present, indicates that the user
+ *    would like the data delivered in an unordered fashion to the peer
+ *    (i.e., the U flag is set to 1 on all DATA chunks carrying this
+ *    message).
+ *
+ *  o no-bundle flag - instructs SCTP not to bundle this user data with
+ *    other outbound DATA chunks. SCTP MAY still bundle even when
+ *    this flag is present, when faced with network congestion.
+ *
+ *  o payload protocol-id - A 32 bit unsigned integer that is to be
+ *    passed to the peer indicating the type of payload protocol data
+ *    being transmitted. This value is passed as opaque data by SCTP.
+ */
+
+DECLARE_PRIMITIVE(SEND);
+
+/* 10.1 ULP-to-SCTP
+ * J) Request Heartbeat
+ *
+ * Format: REQUESTHEARTBEAT(association id, destination transport address)
+ *
+ * -> result
+ *
+ * Instructs the local endpoint to perform a HeartBeat on the specified
+ * destination transport address of the given association. The returned
+ * result should indicate whether the transmission of the HEARTBEAT
+ * chunk to the destination address is successful.
+ *
+ * Mandatory attributes:
+ *
+ * o association id - local handle to the SCTP association
+ *
+ * o destination transport address - the transport address of the
+ *   association on which a heartbeat should be issued.
+ */
+
+DECLARE_PRIMITIVE(REQUESTHEARTBEAT);
+
+/* ADDIP
+* 3.1.1 Address Configuration Change Chunk (ASCONF)
+* 
+* This chunk is used to communicate to the remote endpoint one of the
+* configuration change requests that MUST be acknowledged.  The
+* information carried in the ASCONF Chunk uses the form of a
+* Type-Length-Value (TLV), as described in "3.2.1 Optional/
+* Variable-length Parameter Format" in RFC2960 [5], forall variable
+* parameters.
+*/
+
+DECLARE_PRIMITIVE(ASCONF);
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
new file mode 100644
index 000000000000..e42fd8c2916b
--- /dev/null
+++ b/net/sctp/proc.c
@@ -0,0 +1,288 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 2003 International Business Machines, Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Sridhar Samudrala <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/seq_file.h>
+#include <linux/init.h>
+#include <net/sctp/sctp.h>
+
+static struct snmp_mib sctp_snmp_list[] = {
+        SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
+        SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
+        SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
+        SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
+        SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
+        SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
+        SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
+        SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
+        SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
+        SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
+        SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
+        SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
+        SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
+        SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
+        SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
+        SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
+        SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
+};
+
+/* Return the current value of a particular entry in the mib by adding its
+ * per cpu counters.
+ */ 
+static unsigned long
+fold_field(void *mib[], int nr)
+{
+        unsigned long res = 0;
+        int i;
+
+        for (i = 0; i < NR_CPUS; i++) {
+                if (!cpu_possible(i))
+                        continue;
+                res +=
+                    *((unsigned long *) (((void *) per_cpu_ptr(mib[0], i)) +
+                                         sizeof (unsigned long) * nr));
+                res +=
+                    *((unsigned long *) (((void *) per_cpu_ptr(mib[1], i)) +
+                                         sizeof (unsigned long) * nr));
+        }
+        return res;
+}
+
+/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
+static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
+{
+        int i;
+
+        for (i = 0; sctp_snmp_list[i].name != NULL; i++)
+                seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
+                           fold_field((void **)sctp_statistics, 
+                                      sctp_snmp_list[i].entry));
+
+        return 0;
+}
+
+/* Initialize the seq file operations for 'snmp' object. */
+static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, sctp_snmp_seq_show, NULL);
+}
+
+static struct file_operations sctp_snmp_seq_fops = {
+        .owner   = THIS_MODULE,
+        .open    = sctp_snmp_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+};
+
+/* Set up the proc fs entry for 'snmp' object. */
+int __init sctp_snmp_proc_init(void)
+{
+        struct proc_dir_entry *p;
+
+        p = create_proc_entry("snmp", S_IRUGO, proc_net_sctp);
+        if (!p)
+                return -ENOMEM;
+
+        p->proc_fops = &sctp_snmp_seq_fops;
+
+        return 0;
+}
+
+/* Cleanup the proc fs entry for 'snmp' object. */
+void sctp_snmp_proc_exit(void)
+{
+        remove_proc_entry("snmp", proc_net_sctp);
+}
+
+/* Dump local addresses of an association/endpoint. */
+static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
+{
+        struct list_head *pos;
+        struct sctp_sockaddr_entry *laddr;
+        union sctp_addr *addr;
+        struct sctp_af *af;
+
+        list_for_each(pos, &epb->bind_addr.address_list) {
+                laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                addr = (union sctp_addr *)&laddr->a;
+                af = sctp_get_af_specific(addr->sa.sa_family);
+                af->seq_dump_addr(seq, addr);
+        }
+}
+
+/* Dump remote addresses of an association. */
+static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
+{
+        struct list_head *pos;
+        struct sctp_transport *transport;
+        union sctp_addr *addr;
+        struct sctp_af *af;
+
+        list_for_each(pos, &assoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                addr = (union sctp_addr *)&transport->ipaddr;
+                af = sctp_get_af_specific(addr->sa.sa_family);
+                af->seq_dump_addr(seq, addr);
+        }
+}
+
+/* Display sctp endpoints (/proc/net/sctp/eps). */
+static int sctp_eps_seq_show(struct seq_file *seq, void *v)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+        struct sctp_endpoint *ep;
+        struct sock *sk;
+        int hash;
+
+        seq_printf(seq, " ENDPT     SOCK   STY SST HBKT LPORT LADDRS\n");
+        for (hash = 0; hash < sctp_ep_hashsize; hash++) {
+                head = &sctp_ep_hashtable[hash];
+                read_lock(&head->lock);
+                for (epb = head->chain; epb; epb = epb->next) {
+                        ep = sctp_ep(epb);
+                        sk = epb->sk;
+                        seq_printf(seq, "%8p %8p %-3d %-3d %-4d %-5d ", ep, sk,
+                                   sctp_sk(sk)->type, sk->sk_state, hash,
+                                   epb->bind_addr.port);
+                        sctp_seq_dump_local_addrs(seq, epb);
+                        seq_printf(seq, "\n");
+                }
+                read_unlock(&head->lock);
+        }
+
+        return 0;
+}
+
+/* Initialize the seq file operations for 'eps' object. */
+static int sctp_eps_seq_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, sctp_eps_seq_show, NULL);
+}
+
+static struct file_operations sctp_eps_seq_fops = {
+        .open    = sctp_eps_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+};
+
+/* Set up the proc fs entry for 'eps' object. */
+int __init sctp_eps_proc_init(void)
+{
+        struct proc_dir_entry *p;
+
+        p = create_proc_entry("eps", S_IRUGO, proc_net_sctp);
+        if (!p)
+                return -ENOMEM;
+
+        p->proc_fops = &sctp_eps_seq_fops;
+
+        return 0;
+}
+
+/* Cleanup the proc fs entry for 'eps' object. */
+void sctp_eps_proc_exit(void)
+{
+        remove_proc_entry("eps", proc_net_sctp);
+}
+
+/* Display sctp associations (/proc/net/sctp/assocs). */
+static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
+{
+        struct sctp_hashbucket *head;
+        struct sctp_ep_common *epb;
+        struct sctp_association *assoc;
+        struct sock *sk;
+        int hash;
+
+        seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT LPORT RPORT "
+                        "LADDRS <-> RADDRS\n");
+        for (hash = 0; hash < sctp_assoc_hashsize; hash++) {
+                head = &sctp_assoc_hashtable[hash];
+                read_lock(&head->lock);
+                for (epb = head->chain; epb; epb = epb->next) {
+                        assoc = sctp_assoc(epb);
+                        sk = epb->sk;
+                        seq_printf(seq,
+                                   "%8p %8p %-3d %-3d %-2d %-4d %-5d %-5d ",
+                                   assoc, sk, sctp_sk(sk)->type, sk->sk_state,
+                                   assoc->state, hash, epb->bind_addr.port,
+                                   assoc->peer.port);
+                        sctp_seq_dump_local_addrs(seq, epb);
+                        seq_printf(seq, "<-> ");
+                        sctp_seq_dump_remote_addrs(seq, assoc);
+                        seq_printf(seq, "\n");
+                }
+                read_unlock(&head->lock);
+        }
+
+        return 0;
+}
+
+/* Initialize the seq file operations for 'assocs' object. */
+static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, sctp_assocs_seq_show, NULL);
+}
+
+static struct file_operations sctp_assocs_seq_fops = {
+        .open    = sctp_assocs_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+};
+
+/* Set up the proc fs entry for 'assocs' object. */
+int __init sctp_assocs_proc_init(void)
+{
+        struct proc_dir_entry *p;
+
+        p = create_proc_entry("assocs", S_IRUGO, proc_net_sctp);
+        if (!p)
+                return -ENOMEM;
+
+        p->proc_fops = &sctp_assocs_seq_fops;
+
+        return 0;
+}
+
+/* Cleanup the proc fs entry for 'assocs' object. */
+void sctp_assocs_proc_exit(void)
+{
+        remove_proc_entry("assocs", proc_net_sctp);
+}
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
new file mode 100644
index 000000000000..b9813cf3d91c
--- /dev/null
+++ b/net/sctp/protocol.c
@@ -0,0 +1,1240 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * Initialization/cleanup for SCTP protocol support.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ *    Jon Grimm <jgrimm@us.ibm.com>
+ *    Sridhar Samudrala <sri@us.ibm.com>
+ *    Daisy Chang <daisyc@us.ibm.com>
+ *    Ardelle Fan <ardelle.fan@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <linux/seq_file.h>
+#include <net/protocol.h>
+#include <net/ip.h>
+#include <net/ipv6.h>
+#include <net/sctp/sctp.h>
+#include <net/addrconf.h>
+#include <net/inet_common.h>
+#include <net/inet_ecn.h>
+
+/* Global data structures. */
+struct sctp_globals sctp_globals;
+struct proc_dir_entry   *proc_net_sctp;
+DEFINE_SNMP_STAT(struct sctp_mib, sctp_statistics);
+
+struct idr sctp_assocs_id;
+DEFINE_SPINLOCK(sctp_assocs_id_lock);
+
+/* This is the global socket data structure used for responding to
+ * the Out-of-the-blue (OOTB) packets.  A control sock will be created
+ * for this socket at the initialization time.
+ */
+static struct socket *sctp_ctl_socket;
+
+static struct sctp_pf *sctp_pf_inet6_specific;
+static struct sctp_pf *sctp_pf_inet_specific;
+static struct sctp_af *sctp_af_v4_specific;
+static struct sctp_af *sctp_af_v6_specific;
+
+kmem_cache_t *sctp_chunk_cachep;
+kmem_cache_t *sctp_bucket_cachep;
+
+extern int sctp_snmp_proc_init(void);
+extern int sctp_snmp_proc_exit(void);
+extern int sctp_eps_proc_init(void);
+extern int sctp_eps_proc_exit(void);
+extern int sctp_assocs_proc_init(void);
+extern int sctp_assocs_proc_exit(void);
+
+/* Return the address of the control sock. */
+struct sock *sctp_get_ctl_sock(void)
+{
+        return sctp_ctl_socket->sk;
+}
+
+/* Set up the proc fs entry for the SCTP protocol. */
+static __init int sctp_proc_init(void)
+{
+        if (!proc_net_sctp) {
+                struct proc_dir_entry *ent;
+                ent = proc_mkdir("net/sctp", NULL);
+                if (ent) {
+                        ent->owner = THIS_MODULE;
+                        proc_net_sctp = ent;
+                } else
+                        goto out_nomem;
+        }
+
+        if (sctp_snmp_proc_init())
+                goto out_nomem; 
+        if (sctp_eps_proc_init())
+                goto out_nomem; 
+        if (sctp_assocs_proc_init())
+                goto out_nomem; 
+
+        return 0;
+
+out_nomem:
+        return -ENOMEM;
+}
+
+/* Clean up the proc fs entry for the SCTP protocol. 
+ * Note: Do not make this __exit as it is used in the init error
+ * path.
+ */
+static void sctp_proc_exit(void)
+{
+        sctp_snmp_proc_exit();
+        sctp_eps_proc_exit();
+        sctp_assocs_proc_exit();
+
+        if (proc_net_sctp) {
+                proc_net_sctp = NULL;
+                remove_proc_entry("net/sctp", NULL);
+        }
+}
+
+/* Private helper to extract ipv4 address and stash them in
+ * the protocol structure.
+ */
+static void sctp_v4_copy_addrlist(struct list_head *addrlist,
+                                  struct net_device *dev)
+{
+        struct in_device *in_dev;
+        struct in_ifaddr *ifa;
+        struct sctp_sockaddr_entry *addr;
+
+        rcu_read_lock();
+        if ((in_dev = __in_dev_get(dev)) == NULL) {
+                rcu_read_unlock();
+                return;
+        }
+
+        for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
+                /* Add the address to the local list.  */
+                addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
+                if (addr) {
+                        addr->a.v4.sin_family = AF_INET;
+                        addr->a.v4.sin_port = 0;
+                        addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
+                        list_add_tail(&addr->list, addrlist);
+                }
+        }
+
+        rcu_read_unlock();
+}
+
+/* Extract our IP addresses from the system and stash them in the
+ * protocol structure.
+ */
+static void __sctp_get_local_addr_list(void)
+{
+        struct net_device *dev;
+        struct list_head *pos;
+        struct sctp_af *af;
+
+        read_lock(&dev_base_lock);
+        for (dev = dev_base; dev; dev = dev->next) {
+                __list_for_each(pos, &sctp_address_families) {
+                        af = list_entry(pos, struct sctp_af, list);
+                        af->copy_addrlist(&sctp_local_addr_list, dev);
+                }
+        }
+        read_unlock(&dev_base_lock);
+}
+
+static void sctp_get_local_addr_list(void)
+{
+        unsigned long flags;
+
+        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+        __sctp_get_local_addr_list();
+        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
+}
+
+/* Free the existing local addresses.  */
+static void __sctp_free_local_addr_list(void)
+{
+        struct sctp_sockaddr_entry *addr;
+        struct list_head *pos, *temp;
+
+        list_for_each_safe(pos, temp, &sctp_local_addr_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                list_del(pos);
+                kfree(addr);
+        }
+}
+
+/* Free the existing local addresses.  */
+static void sctp_free_local_addr_list(void)
+{
+        unsigned long flags;
+
+        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+        __sctp_free_local_addr_list();
+        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
+}
+
+/* Copy the local addresses which are valid for 'scope' into 'bp'.  */
+int sctp_copy_local_addr_list(struct sctp_bind_addr *bp, sctp_scope_t scope,
+                              int gfp, int copy_flags)
+{
+        struct sctp_sockaddr_entry *addr;
+        int error = 0;
+        struct list_head *pos;
+        unsigned long flags;
+
+        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+        list_for_each(pos, &sctp_local_addr_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if (sctp_in_scope(&addr->a, scope)) {
+                        /* Now that the address is in scope, check to see if
+                         * the address type is really supported by the local
+                         * sock as well as the remote peer.
+                         */
+                        if ((((AF_INET == addr->a.sa.sa_family) &&
+                              (copy_flags & SCTP_ADDR4_PEERSUPP))) ||
+                            (((AF_INET6 == addr->a.sa.sa_family) &&
+                              (copy_flags & SCTP_ADDR6_ALLOWED) &&
+                              (copy_flags & SCTP_ADDR6_PEERSUPP)))) {
+                                error = sctp_add_bind_addr(bp, &addr->a, 
+                                                           GFP_ATOMIC);
+                                if (error)
+                                        goto end_copy;
+                        }
+                }
+        }
+
+end_copy:
+        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
+        return error;
+}
+
+/* Initialize a sctp_addr from in incoming skb.  */
+static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
+                             int is_saddr)
+{
+        void *from;
+        __u16 *port;
+        struct sctphdr *sh;
+
+        port = &addr->v4.sin_port;
+        addr->v4.sin_family = AF_INET;
+
+        sh = (struct sctphdr *) skb->h.raw;
+        if (is_saddr) {
+                *port  = ntohs(sh->source);
+                from = &skb->nh.iph->saddr;
+        } else {
+                *port = ntohs(sh->dest);
+                from = &skb->nh.iph->daddr;
+        }
+        memcpy(&addr->v4.sin_addr.s_addr, from, sizeof(struct in_addr));
+}
+
+/* Initialize an sctp_addr from a socket. */
+static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
+{
+        addr->v4.sin_family = AF_INET;
+        addr->v4.sin_port = inet_sk(sk)->num;
+        addr->v4.sin_addr.s_addr = inet_sk(sk)->rcv_saddr;
+}
+
+/* Initialize sk->sk_rcv_saddr from sctp_addr. */
+static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
+{
+        inet_sk(sk)->rcv_saddr = addr->v4.sin_addr.s_addr;
+}
+
+/* Initialize sk->sk_daddr from sctp_addr. */
+static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
+{
+        inet_sk(sk)->daddr = addr->v4.sin_addr.s_addr;
+}
+
+/* Initialize a sctp_addr from an address parameter. */
+static void sctp_v4_from_addr_param(union sctp_addr *addr,
+                                    union sctp_addr_param *param,
+                                    __u16 port, int iif)
+{
+        addr->v4.sin_family = AF_INET;
+        addr->v4.sin_port = port;
+        addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
+}
+
+/* Initialize an address parameter from a sctp_addr and return the length
+ * of the address parameter.
+ */
+static int sctp_v4_to_addr_param(const union sctp_addr *addr,
+                                 union sctp_addr_param *param)
+{
+        int length = sizeof(sctp_ipv4addr_param_t);
+
+        param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
+        param->v4.param_hdr.length = ntohs(length);
+        param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;       
+
+        return length;
+}
+
+/* Initialize a sctp_addr from a dst_entry. */
+static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct dst_entry *dst,
+                              unsigned short port)
+{
+        struct rtable *rt = (struct rtable *)dst;
+        saddr->v4.sin_family = AF_INET;
+        saddr->v4.sin_port = port;
+        saddr->v4.sin_addr.s_addr = rt->rt_src;
+}
+
+/* Compare two addresses exactly. */
+static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
+                            const union sctp_addr *addr2)
+{
+        if (addr1->sa.sa_family != addr2->sa.sa_family)
+                return 0;
+        if (addr1->v4.sin_port != addr2->v4.sin_port)
+                return 0;
+        if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
+                return 0;
+
+        return 1;
+}
+
+/* Initialize addr struct to INADDR_ANY. */
+static void sctp_v4_inaddr_any(union sctp_addr *addr, unsigned short port)
+{
+        addr->v4.sin_family = AF_INET;
+        addr->v4.sin_addr.s_addr = INADDR_ANY;
+        addr->v4.sin_port = port;
+}
+
+/* Is this a wildcard address? */
+static int sctp_v4_is_any(const union sctp_addr *addr)
+{
+        return INADDR_ANY == addr->v4.sin_addr.s_addr;
+}
+
+/* This function checks if the address is a valid address to be used for
+ * SCTP binding.
+ *
+ * Output:
+ * Return 0 - If the address is a non-unicast or an illegal address.
+ * Return 1 - If the address is a unicast.
+ */
+static int sctp_v4_addr_valid(union sctp_addr *addr, struct sctp_sock *sp)
+{
+        /* Is this a non-unicast address or a unusable SCTP address? */
+        if (IS_IPV4_UNUSABLE_ADDRESS(&addr->v4.sin_addr.s_addr))
+                return 0;
+
+        return 1;
+}
+
+/* Should this be available for binding?   */
+static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
+{
+        int ret = inet_addr_type(addr->v4.sin_addr.s_addr);
+
+        /* FIXME: ip_nonlocal_bind sysctl support. */
+
+        if (addr->v4.sin_addr.s_addr != INADDR_ANY && ret != RTN_LOCAL)
+                return 0;
+        return 1;
+}
+
+/* Checking the loopback, private and other address scopes as defined in
+ * RFC 1918.   The IPv4 scoping is based on the draft for SCTP IPv4
+ * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
+ *
+ * Level 0 - unusable SCTP addresses
+ * Level 1 - loopback address
+ * Level 2 - link-local addresses
+ * Level 3 - private addresses.
+ * Level 4 - global addresses
+ * For INIT and INIT-ACK address list, let L be the level of
+ * of requested destination address, sender and receiver
+ * SHOULD include all of its addresses with level greater
+ * than or equal to L.
+ */
+static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
+{
+        sctp_scope_t retval;
+
+        /* Should IPv4 scoping be a sysctl configurable option
+         * so users can turn it off (default on) for certain
+         * unconventional networking environments?
+         */
+
+        /* Check for unusable SCTP addresses. */
+        if (IS_IPV4_UNUSABLE_ADDRESS(&addr->v4.sin_addr.s_addr)) {
+                retval =  SCTP_SCOPE_UNUSABLE;
+        } else if (LOOPBACK(addr->v4.sin_addr.s_addr)) {
+                retval = SCTP_SCOPE_LOOPBACK;
+        } else if (IS_IPV4_LINK_ADDRESS(&addr->v4.sin_addr.s_addr)) {
+                retval = SCTP_SCOPE_LINK;
+        } else if (IS_IPV4_PRIVATE_ADDRESS(&addr->v4.sin_addr.s_addr)) {
+                retval = SCTP_SCOPE_PRIVATE;
+        } else {
+                retval = SCTP_SCOPE_GLOBAL;
+        }
+
+        return retval;
+}
+
+/* Returns a valid dst cache entry for the given source and destination ip
+ * addresses. If an association is passed, trys to get a dst entry with a
+ * source address that matches an address in the bind address list.
+ */
+static struct dst_entry *sctp_v4_get_dst(struct sctp_association *asoc,
+                                         union sctp_addr *daddr,
+                                         union sctp_addr *saddr)
+{
+        struct rtable *rt;
+        struct flowi fl;
+        struct sctp_bind_addr *bp;
+        rwlock_t *addr_lock;
+        struct sctp_sockaddr_entry *laddr;
+        struct list_head *pos;
+        struct dst_entry *dst = NULL;
+        union sctp_addr dst_saddr;
+
+        memset(&fl, 0x0, sizeof(struct flowi));
+        fl.fl4_dst  = daddr->v4.sin_addr.s_addr;
+        fl.proto = IPPROTO_SCTP;
+        if (asoc) {
+                fl.fl4_tos = RT_CONN_FLAGS(asoc->base.sk);
+                fl.oif = asoc->base.sk->sk_bound_dev_if;
+        }
+        if (saddr)
+                fl.fl4_src = saddr->v4.sin_addr.s_addr;
+
+        SCTP_DEBUG_PRINTK("%s: DST:%u.%u.%u.%u, SRC:%u.%u.%u.%u - ",
+                          __FUNCTION__, NIPQUAD(fl.fl4_dst),
+                          NIPQUAD(fl.fl4_src));
+
+        if (!ip_route_output_key(&rt, &fl)) {
+                dst = &rt->u.dst;
+        }
+
+        /* If there is no association or if a source address is passed, no
+         * more validation is required.
+         */
+        if (!asoc || saddr)
+                goto out;
+
+        bp = &asoc->base.bind_addr;
+        addr_lock = &asoc->base.addr_lock;
+
+        if (dst) {
+                /* Walk through the bind address list and look for a bind
+                 * address that matches the source address of the returned dst.
+                 */
+                sctp_read_lock(addr_lock);
+                list_for_each(pos, &bp->address_list) {
+                        laddr = list_entry(pos, struct sctp_sockaddr_entry,
+                                           list);
+                        sctp_v4_dst_saddr(&dst_saddr, dst, bp->port);
+                        if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
+                                goto out_unlock;
+                }
+                sctp_read_unlock(addr_lock);
+
+                /* None of the bound addresses match the source address of the
+                 * dst. So release it.
+                 */
+                dst_release(dst);
+                dst = NULL;
+        }
+
+        /* Walk through the bind address list and try to get a dst that
+         * matches a bind address as the source address.
+         */
+        sctp_read_lock(addr_lock);
+        list_for_each(pos, &bp->address_list) {
+                laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
+
+                if (AF_INET == laddr->a.sa.sa_family) {
+                        fl.fl4_src = laddr->a.v4.sin_addr.s_addr;
+                        if (!ip_route_output_key(&rt, &fl)) {
+                                dst = &rt->u.dst;
+                                goto out_unlock;
+                        }
+                }
+        }
+
+out_unlock:
+        sctp_read_unlock(addr_lock);
+out:
+        if (dst)
+                SCTP_DEBUG_PRINTK("rt_dst:%u.%u.%u.%u, rt_src:%u.%u.%u.%u\n",
+                                  NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_src));
+        else
+                SCTP_DEBUG_PRINTK("NO ROUTE\n");
+
+        return dst;
+}
+
+/* For v4, the source address is cached in the route entry(dst). So no need
+ * to cache it separately and hence this is an empty routine.
+ */
+static void sctp_v4_get_saddr(struct sctp_association *asoc,
+                              struct dst_entry *dst,
+                              union sctp_addr *daddr,
+                              union sctp_addr *saddr)
+{
+        struct rtable *rt = (struct rtable *)dst;
+
+        if (rt) {
+                saddr->v4.sin_family = AF_INET;
+                saddr->v4.sin_port = asoc->base.bind_addr.port;  
+                saddr->v4.sin_addr.s_addr = rt->rt_src; 
+        }
+}
+
+/* What interface did this skb arrive on? */
+static int sctp_v4_skb_iif(const struct sk_buff *skb)
+{
+        return ((struct rtable *)skb->dst)->rt_iif;
+}
+
+/* Was this packet marked by Explicit Congestion Notification? */
+static int sctp_v4_is_ce(const struct sk_buff *skb)
+{
+        return INET_ECN_is_ce(skb->nh.iph->tos);
+}
+
+/* Create and initialize a new sk for the socket returned by accept(). */
+static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
+                                             struct sctp_association *asoc)
+{
+        struct inet_sock *inet = inet_sk(sk);
+        struct inet_sock *newinet;
+        struct sock *newsk = sk_alloc(PF_INET, GFP_KERNEL, sk->sk_prot, 1);
+
+        if (!newsk)
+                goto out;
+
+        sock_init_data(NULL, newsk);
+
+        newsk->sk_type = SOCK_STREAM;
+
+        newsk->sk_no_check = sk->sk_no_check;
+        newsk->sk_reuse = sk->sk_reuse;
+        newsk->sk_shutdown = sk->sk_shutdown;
+
+        newsk->sk_destruct = inet_sock_destruct;
+        newsk->sk_family = PF_INET;
+        newsk->sk_protocol = IPPROTO_SCTP;
+        newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
+        sock_reset_flag(newsk, SOCK_ZAPPED);
+
+        newinet = inet_sk(newsk);
+
+        /* Initialize sk's sport, dport, rcv_saddr and daddr for
+         * getsockname() and getpeername()
+         */
+        newinet->sport = inet->sport;
+        newinet->saddr = inet->saddr;
+        newinet->rcv_saddr = inet->rcv_saddr;
+        newinet->dport = htons(asoc->peer.port);
+        newinet->daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
+        newinet->pmtudisc = inet->pmtudisc;
+        newinet->id = 0;
+
+        newinet->uc_ttl = -1;
+        newinet->mc_loop = 1;
+        newinet->mc_ttl = 1;
+        newinet->mc_index = 0;
+        newinet->mc_list = NULL;
+
+#ifdef INET_REFCNT_DEBUG
+        atomic_inc(&inet_sock_nr);
+#endif
+
+        if (newsk->sk_prot->init(newsk)) {
+                sk_common_release(newsk);
+                newsk = NULL;
+        }
+
+out:
+        return newsk;
+}
+
+/* Map address, empty for v4 family */
+static void sctp_v4_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
+{
+        /* Empty */
+}
+
+/* Dump the v4 addr to the seq file. */
+static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
+{
+        seq_printf(seq, "%d.%d.%d.%d ", NIPQUAD(addr->v4.sin_addr));
+}
+
+/* Event handler for inet address addition/deletion events.
+ * Basically, whenever there is an event, we re-build our local address list.
+ */
+int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
+                        void *ptr)
+{
+        unsigned long flags;
+
+        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+        __sctp_free_local_addr_list();
+        __sctp_get_local_addr_list();
+        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
+
+        return NOTIFY_DONE;
+}
+
+/*
+ * Initialize the control inode/socket with a control endpoint data
+ * structure.  This endpoint is reserved exclusively for the OOTB processing.
+ */
+static int sctp_ctl_sock_init(void)
+{
+        int err;
+        sa_family_t family;
+
+        if (sctp_get_pf_specific(PF_INET6))
+                family = PF_INET6;
+        else
+                family = PF_INET;
+
+        err = sock_create_kern(family, SOCK_SEQPACKET, IPPROTO_SCTP,
+                               &sctp_ctl_socket);
+        if (err < 0) {
+                printk(KERN_ERR
+                       "SCTP: Failed to create the SCTP control socket.\n");
+                return err;
+        }
+        sctp_ctl_socket->sk->sk_allocation = GFP_ATOMIC;
+        inet_sk(sctp_ctl_socket->sk)->uc_ttl = -1;
+
+        return 0;
+}
+
+/* Register address family specific functions. */
+int sctp_register_af(struct sctp_af *af)
+{
+        switch (af->sa_family) {
+        case AF_INET:
+                if (sctp_af_v4_specific)
+                        return 0;
+                sctp_af_v4_specific = af;
+                break;
+        case AF_INET6:
+                if (sctp_af_v6_specific)
+                        return 0;
+                sctp_af_v6_specific = af;
+                break;
+        default:
+                return 0;
+        }
+
+        INIT_LIST_HEAD(&af->list);
+        list_add_tail(&af->list, &sctp_address_families);
+        return 1;
+}
+
+/* Get the table of functions for manipulating a particular address
+ * family.
+ */
+struct sctp_af *sctp_get_af_specific(sa_family_t family)
+{
+        switch (family) {
+        case AF_INET:
+                return sctp_af_v4_specific;
+        case AF_INET6:
+                return sctp_af_v6_specific;
+        default:
+                return NULL;
+        }
+}
+
+/* Common code to initialize a AF_INET msg_name. */
+static void sctp_inet_msgname(char *msgname, int *addr_len)
+{
+        struct sockaddr_in *sin;
+
+        sin = (struct sockaddr_in *)msgname;
+        *addr_len = sizeof(struct sockaddr_in);
+        sin->sin_family = AF_INET;
+        memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
+}
+
+/* Copy the primary address of the peer primary address as the msg_name. */
+static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
+                                    int *addr_len)
+{
+        struct sockaddr_in *sin, *sinfrom;
+
+        if (msgname) {
+                struct sctp_association *asoc;
+
+                asoc = event->asoc;
+                sctp_inet_msgname(msgname, addr_len);
+                sin = (struct sockaddr_in *)msgname;
+                sinfrom = &asoc->peer.primary_addr.v4;
+                sin->sin_port = htons(asoc->peer.port);
+                sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
+        }
+}
+
+/* Initialize and copy out a msgname from an inbound skb. */
+static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
+{
+        struct sctphdr *sh;
+        struct sockaddr_in *sin;
+
+        if (msgname) {
+                sctp_inet_msgname(msgname, len);
+                sin = (struct sockaddr_in *)msgname;
+                sh = (struct sctphdr *)skb->h.raw;
+                sin->sin_port = sh->source;
+                sin->sin_addr.s_addr = skb->nh.iph->saddr;
+        }
+}
+
+/* Do we support this AF? */
+static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
+{
+        /* PF_INET only supports AF_INET addresses. */
+        return (AF_INET == family);
+}
+
+/* Address matching with wildcards allowed. */
+static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
+                              const union sctp_addr *addr2,
+                              struct sctp_sock *opt)
+{
+        /* PF_INET only supports AF_INET addresses. */
+        if (addr1->sa.sa_family != addr2->sa.sa_family)
+                return 0;
+        if (INADDR_ANY == addr1->v4.sin_addr.s_addr ||
+            INADDR_ANY == addr2->v4.sin_addr.s_addr)
+                return 1;
+        if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
+                return 1;
+
+        return 0;
+}
+
+/* Verify that provided sockaddr looks bindable.  Common verification has
+ * already been taken care of.
+ */
+static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
+{
+        return sctp_v4_available(addr, opt);
+}
+
+/* Verify that sockaddr looks sendable.  Common verification has already
+ * been taken care of.
+ */
+static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
+{
+        return 1;
+}
+
+/* Fill in Supported Address Type information for INIT and INIT-ACK
+ * chunks.  Returns number of addresses supported.
+ */
+static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
+                                     __u16 *types)
+{
+        types[0] = SCTP_PARAM_IPV4_ADDRESS;
+        return 1;
+}
+
+/* Wrapper routine that calls the ip transmit routine. */
+static inline int sctp_v4_xmit(struct sk_buff *skb,
+                               struct sctp_transport *transport, int ipfragok)
+{
+        SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, "
+                          "src:%u.%u.%u.%u, dst:%u.%u.%u.%u\n",
+                          __FUNCTION__, skb, skb->len,
+                          NIPQUAD(((struct rtable *)skb->dst)->rt_src),
+                          NIPQUAD(((struct rtable *)skb->dst)->rt_dst));
+
+        SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
+        return ip_queue_xmit(skb, ipfragok);
+}
+
+static struct sctp_af sctp_ipv4_specific;
+
+static struct sctp_pf sctp_pf_inet = {
+        .event_msgname = sctp_inet_event_msgname,
+        .skb_msgname   = sctp_inet_skb_msgname,
+        .af_supported  = sctp_inet_af_supported,
+        .cmp_addr      = sctp_inet_cmp_addr,
+        .bind_verify   = sctp_inet_bind_verify,
+        .send_verify   = sctp_inet_send_verify,
+        .supported_addrs = sctp_inet_supported_addrs,
+        .create_accept_sk = sctp_v4_create_accept_sk,
+        .addr_v4map     = sctp_v4_addr_v4map,
+        .af            = &sctp_ipv4_specific,
+};
+
+/* Notifier for inetaddr addition/deletion events.  */
+static struct notifier_block sctp_inetaddr_notifier = {
+        .notifier_call = sctp_inetaddr_event,
+};
+
+/* Socket operations.  */
+static struct proto_ops inet_seqpacket_ops = {
+        .family      = PF_INET,
+        .owner       = THIS_MODULE,
+        .release     = inet_release,       /* Needs to be wrapped... */
+        .bind        = inet_bind,
+        .connect     = inet_dgram_connect,
+        .socketpair  = sock_no_socketpair,
+        .accept      = inet_accept,
+        .getname     = inet_getname,      /* Semantics are different.  */
+        .poll        = sctp_poll,
+        .ioctl       = inet_ioctl,
+        .listen      = sctp_inet_listen,
+        .shutdown    = inet_shutdown,     /* Looks harmless.  */
+        .setsockopt  = sock_common_setsockopt,   /* IP_SOL IP_OPTION is a problem. */
+        .getsockopt  = sock_common_getsockopt,
+        .sendmsg     = inet_sendmsg,
+        .recvmsg     = sock_common_recvmsg,
+        .mmap        = sock_no_mmap,
+        .sendpage    = sock_no_sendpage,
+};
+
+/* Registration with AF_INET family.  */
+static struct inet_protosw sctp_seqpacket_protosw = {
+        .type       = SOCK_SEQPACKET,
+        .protocol   = IPPROTO_SCTP,
+        .prot       = &sctp_prot,
+        .ops        = &inet_seqpacket_ops,
+        .capability = -1,
+        .no_check   = 0,
+        .flags      = SCTP_PROTOSW_FLAG
+};
+static struct inet_protosw sctp_stream_protosw = {
+        .type       = SOCK_STREAM,
+        .protocol   = IPPROTO_SCTP,
+        .prot       = &sctp_prot,
+        .ops        = &inet_seqpacket_ops,
+        .capability = -1,
+        .no_check   = 0,
+        .flags      = SCTP_PROTOSW_FLAG
+};
+
+/* Register with IP layer.  */
+static struct net_protocol sctp_protocol = {
+        .handler     = sctp_rcv,
+        .err_handler = sctp_v4_err,
+        .no_policy   = 1,
+};
+
+/* IPv4 address related functions.  */
+static struct sctp_af sctp_ipv4_specific = {
+        .sctp_xmit      = sctp_v4_xmit,
+        .setsockopt     = ip_setsockopt,
+        .getsockopt     = ip_getsockopt,
+        .get_dst        = sctp_v4_get_dst,
+        .get_saddr      = sctp_v4_get_saddr,
+        .copy_addrlist  = sctp_v4_copy_addrlist,
+        .from_skb       = sctp_v4_from_skb,
+        .from_sk        = sctp_v4_from_sk,
+        .to_sk_saddr    = sctp_v4_to_sk_saddr,
+        .to_sk_daddr    = sctp_v4_to_sk_daddr,
+        .from_addr_param= sctp_v4_from_addr_param,
+        .to_addr_param  = sctp_v4_to_addr_param,        
+        .dst_saddr      = sctp_v4_dst_saddr,
+        .cmp_addr       = sctp_v4_cmp_addr,
+        .addr_valid     = sctp_v4_addr_valid,
+        .inaddr_any     = sctp_v4_inaddr_any,
+        .is_any         = sctp_v4_is_any,
+        .available      = sctp_v4_available,
+        .scope          = sctp_v4_scope,
+        .skb_iif        = sctp_v4_skb_iif,
+        .is_ce          = sctp_v4_is_ce,
+        .seq_dump_addr  = sctp_v4_seq_dump_addr,
+        .net_header_len = sizeof(struct iphdr),
+        .sockaddr_len   = sizeof(struct sockaddr_in),
+        .sa_family      = AF_INET,
+};
+
+struct sctp_pf *sctp_get_pf_specific(sa_family_t family) {
+
+        switch (family) {
+        case PF_INET:
+                return sctp_pf_inet_specific;
+        case PF_INET6:
+                return sctp_pf_inet6_specific;
+        default:
+                return NULL;
+        }
+}
+
+/* Register the PF specific function table.  */
+int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
+{
+        switch (family) {
+        case PF_INET:
+                if (sctp_pf_inet_specific)
+                        return 0;
+                sctp_pf_inet_specific = pf;
+                break;
+        case PF_INET6:
+                if (sctp_pf_inet6_specific)
+                        return 0;
+                sctp_pf_inet6_specific = pf;
+                break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int __init init_sctp_mibs(void)
+{
+        sctp_statistics[0] = alloc_percpu(struct sctp_mib);
+        if (!sctp_statistics[0])
+                return -ENOMEM;
+        sctp_statistics[1] = alloc_percpu(struct sctp_mib);
+        if (!sctp_statistics[1]) {
+                free_percpu(sctp_statistics[0]);
+                return -ENOMEM;
+        }
+        return 0;
+
+}
+
+static void cleanup_sctp_mibs(void)
+{
+        free_percpu(sctp_statistics[0]);
+        free_percpu(sctp_statistics[1]);
+}
+
+/* Initialize the universe into something sensible.  */
+SCTP_STATIC __init int sctp_init(void)
+{
+        int i;
+        int status = -EINVAL;
+        unsigned long goal;
+        int order;
+
+        /* SCTP_DEBUG sanity check. */
+        if (!sctp_sanity_check())
+                goto out;
+
+        status = proto_register(&sctp_prot, 1);
+        if (status)
+                goto out;
+
+        /* Add SCTP to inet_protos hash table.  */
+        status = -EAGAIN;
+        if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
+                goto err_add_protocol;
+
+        /* Add SCTP(TCP and UDP style) to inetsw linked list.  */
+        inet_register_protosw(&sctp_seqpacket_protosw);
+        inet_register_protosw(&sctp_stream_protosw);
+
+        /* Allocate a cache pools. */
+        status = -ENOBUFS;
+        sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
+                                               sizeof(struct sctp_bind_bucket),
+                                               0, SLAB_HWCACHE_ALIGN,
+                                               NULL, NULL);
+
+        if (!sctp_bucket_cachep)
+                goto err_bucket_cachep;
+
+        sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
+                                               sizeof(struct sctp_chunk),
+                                               0, SLAB_HWCACHE_ALIGN,
+                                               NULL, NULL);
+        if (!sctp_chunk_cachep)
+                goto err_chunk_cachep;
+
+        /* Allocate and initialise sctp mibs.  */
+        status = init_sctp_mibs();
+        if (status)
+                goto err_init_mibs;
+
+        /* Initialize proc fs directory.  */
+        status = sctp_proc_init();
+        if (status)
+                goto err_init_proc;
+
+        /* Initialize object count debugging.  */
+        sctp_dbg_objcnt_init();
+
+        /* Initialize the SCTP specific PF functions. */
+        sctp_register_pf(&sctp_pf_inet, PF_INET);
+        /*
+         * 14. Suggested SCTP Protocol Parameter Values
+         */
+        /* The following protocol parameters are RECOMMENDED:  */
+        /* RTO.Initial              - 3  seconds */
+        sctp_rto_initial                = SCTP_RTO_INITIAL;
+        /* RTO.Min                  - 1  second */
+        sctp_rto_min                    = SCTP_RTO_MIN;
+        /* RTO.Max                 -  60 seconds */
+        sctp_rto_max                    = SCTP_RTO_MAX;
+        /* RTO.Alpha                - 1/8 */
+        sctp_rto_alpha                  = SCTP_RTO_ALPHA;
+        /* RTO.Beta                 - 1/4 */
+        sctp_rto_beta                   = SCTP_RTO_BETA;
+
+        /* Valid.Cookie.Life        - 60  seconds */
+        sctp_valid_cookie_life          = 60 * HZ;
+
+        /* Whether Cookie Preservative is enabled(1) or not(0) */
+        sctp_cookie_preserve_enable     = 1;
+
+        /* Max.Burst                - 4 */
+        sctp_max_burst                  = SCTP_MAX_BURST;
+
+        /* Association.Max.Retrans  - 10 attempts
+         * Path.Max.Retrans         - 5  attempts (per destination address)
+         * Max.Init.Retransmits     - 8  attempts
+         */
+        sctp_max_retrans_association    = 10;
+        sctp_max_retrans_path           = 5;
+        sctp_max_retrans_init           = 8;
+
+        /* HB.interval              - 30 seconds */
+        sctp_hb_interval                = 30 * HZ;
+
+        /* Implementation specific variables. */
+
+        /* Initialize default stream count setup information. */
+        sctp_max_instreams              = SCTP_DEFAULT_INSTREAMS;
+        sctp_max_outstreams             = SCTP_DEFAULT_OUTSTREAMS;
+
+        /* Initialize handle used for association ids. */
+        idr_init(&sctp_assocs_id);
+
+        /* Size and allocate the association hash table.
+         * The methodology is similar to that of the tcp hash tables.
+         */
+        if (num_physpages >= (128 * 1024))
+                goal = num_physpages >> (22 - PAGE_SHIFT);
+        else
+                goal = num_physpages >> (24 - PAGE_SHIFT);
+
+        for (order = 0; (1UL << order) < goal; order++)
+                ;
+
+        do {
+                sctp_assoc_hashsize = (1UL << order) * PAGE_SIZE /
+                                        sizeof(struct sctp_hashbucket);
+                if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
+                        continue;
+                sctp_assoc_hashtable = (struct sctp_hashbucket *)
+                                        __get_free_pages(GFP_ATOMIC, order);
+        } while (!sctp_assoc_hashtable && --order > 0);
+        if (!sctp_assoc_hashtable) {
+                printk(KERN_ERR "SCTP: Failed association hash alloc.\n");
+                status = -ENOMEM;
+                goto err_ahash_alloc;
+        }
+        for (i = 0; i < sctp_assoc_hashsize; i++) {
+                rwlock_init(&sctp_assoc_hashtable[i].lock);
+                sctp_assoc_hashtable[i].chain = NULL;
+        }
+
+        /* Allocate and initialize the endpoint hash table.  */
+        sctp_ep_hashsize = 64;
+        sctp_ep_hashtable = (struct sctp_hashbucket *)
+                kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
+        if (!sctp_ep_hashtable) {
+                printk(KERN_ERR "SCTP: Failed endpoint_hash alloc.\n");
+                status = -ENOMEM;
+                goto err_ehash_alloc;
+        }
+        for (i = 0; i < sctp_ep_hashsize; i++) {
+                rwlock_init(&sctp_ep_hashtable[i].lock);
+                sctp_ep_hashtable[i].chain = NULL;
+        }
+
+        /* Allocate and initialize the SCTP port hash table.  */
+        do {
+                sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
+                                        sizeof(struct sctp_bind_hashbucket);
+                if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
+                        continue;
+                sctp_port_hashtable = (struct sctp_bind_hashbucket *)
+                                        __get_free_pages(GFP_ATOMIC, order);
+        } while (!sctp_port_hashtable && --order > 0);
+        if (!sctp_port_hashtable) {
+                printk(KERN_ERR "SCTP: Failed bind hash alloc.");
+                status = -ENOMEM;
+                goto err_bhash_alloc;
+        }
+        for (i = 0; i < sctp_port_hashsize; i++) {
+                spin_lock_init(&sctp_port_hashtable[i].lock);
+                sctp_port_hashtable[i].chain = NULL;
+        }
+
+        spin_lock_init(&sctp_port_alloc_lock);
+        sctp_port_rover = sysctl_local_port_range[0] - 1;
+
+        printk(KERN_INFO "SCTP: Hash tables configured "
+                         "(established %d bind %d)\n",
+                sctp_assoc_hashsize, sctp_port_hashsize);
+
+        /* Disable ADDIP by default. */
+        sctp_addip_enable = 0;
+
+        /* Enable PR-SCTP by default. */
+        sctp_prsctp_enable = 1;
+
+        sctp_sysctl_register();
+
+        INIT_LIST_HEAD(&sctp_address_families);
+        sctp_register_af(&sctp_ipv4_specific);
+
+        status = sctp_v6_init();
+        if (status)
+                goto err_v6_init;
+
+        /* Initialize the control inode/socket for handling OOTB packets.  */
+        if ((status = sctp_ctl_sock_init())) {
+                printk (KERN_ERR
+                        "SCTP: Failed to initialize the SCTP control sock.\n");
+                goto err_ctl_sock_init;
+        }
+
+        /* Initialize the local address list. */
+        INIT_LIST_HEAD(&sctp_local_addr_list);
+        spin_lock_init(&sctp_local_addr_lock);
+
+        /* Register notifier for inet address additions/deletions. */
+        register_inetaddr_notifier(&sctp_inetaddr_notifier);
+
+        sctp_get_local_addr_list();
+
+        __unsafe(THIS_MODULE);
+        status = 0;
+out:
+        return status;
+err_add_protocol:
+        proto_unregister(&sctp_prot);
+err_ctl_sock_init:
+        sctp_v6_exit();
+err_v6_init:
+        sctp_sysctl_unregister();
+        list_del(&sctp_ipv4_specific.list);
+        free_pages((unsigned long)sctp_port_hashtable,
+                   get_order(sctp_port_hashsize *
+                             sizeof(struct sctp_bind_hashbucket)));
+err_bhash_alloc:
+        kfree(sctp_ep_hashtable);
+err_ehash_alloc:
+        free_pages((unsigned long)sctp_assoc_hashtable,
+                   get_order(sctp_assoc_hashsize *
+                             sizeof(struct sctp_hashbucket)));
+err_ahash_alloc:
+        sctp_dbg_objcnt_exit();
+err_init_proc:
+        sctp_proc_exit();
+        cleanup_sctp_mibs();
+err_init_mibs:
+        kmem_cache_destroy(sctp_chunk_cachep);
+err_chunk_cachep:
+        kmem_cache_destroy(sctp_bucket_cachep);
+err_bucket_cachep:
+        inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
+        inet_unregister_protosw(&sctp_seqpacket_protosw);
+        inet_unregister_protosw(&sctp_stream_protosw);
+        goto out;
+}
+
+/* Exit handler for the SCTP protocol.  */
+SCTP_STATIC __exit void sctp_exit(void)
+{
+        /* BUG.  This should probably do something useful like clean
+         * up all the remaining associations and all that memory.
+         */
+
+        /* Unregister notifier for inet address additions/deletions. */
+        unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
+
+        /* Free the local address list.  */
+        sctp_free_local_addr_list();
+
+        /* Free the control endpoint.  */
+        sock_release(sctp_ctl_socket);
+
+        sctp_v6_exit();
+        sctp_sysctl_unregister();
+        list_del(&sctp_ipv4_specific.list);
+
+        free_pages((unsigned long)sctp_assoc_hashtable,
+                   get_order(sctp_assoc_hashsize *
+                             sizeof(struct sctp_hashbucket)));
+        kfree(sctp_ep_hashtable);
+        free_pages((unsigned long)sctp_port_hashtable,
+                   get_order(sctp_port_hashsize *
+                             sizeof(struct sctp_bind_hashbucket)));
+
+        kmem_cache_destroy(sctp_chunk_cachep);
+        kmem_cache_destroy(sctp_bucket_cachep);
+
+        sctp_dbg_objcnt_exit();
+        sctp_proc_exit();
+        cleanup_sctp_mibs();
+
+        inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
+        inet_unregister_protosw(&sctp_seqpacket_protosw);
+        inet_unregister_protosw(&sctp_stream_protosw);
+        proto_unregister(&sctp_prot);
+}
+
+module_init(sctp_init);
+module_exit(sctp_exit);
+
+MODULE_AUTHOR("Linux Kernel SCTP developers <lksctp-developers@lists.sourceforge.net>");
+MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
+MODULE_LICENSE("GPL");
diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c
new file mode 100644
index 000000000000..1db12cc18cf7
--- /dev/null
+++ b/net/sctp/sm_make_chunk.c
@@ -0,0 +1,2766 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2002 Intel Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions work with the state functions in sctp_sm_statefuns.c
+ * to implement the state operations.  These functions implement the
+ * steps which require modifying existing data structures.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    C. Robin              <chris@hundredacre.ac.uk>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Dajiang Zhang         <dajiang.zhang@nokia.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Kevin Gao             <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/net.h>
+#include <linux/inet.h>
+#include <asm/scatterlist.h>
+#include <linux/crypto.h>
+#include <net/sock.h>
+
+#include <linux/skbuff.h>
+#include <linux/random.h>       /* for get_random_bytes */
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+extern kmem_cache_t *sctp_chunk_cachep;
+
+SCTP_STATIC
+struct sctp_chunk *sctp_make_chunk(const struct sctp_association *asoc,
+                                   __u8 type, __u8 flags, int paylen);
+static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const struct sctp_chunk *init_chunk,
+                                        int *cookie_len,
+                                        const __u8 *raw_addrs, int addrs_len);
+static int sctp_process_param(struct sctp_association *asoc,
+                              union sctp_params param,
+                              const union sctp_addr *peer_addr,
+                              int gfp);
+
+/* What was the inbound interface for this chunk? */
+int sctp_chunk_iif(const struct sctp_chunk *chunk)
+{
+        struct sctp_af *af;
+        int iif = 0;
+
+        af = sctp_get_af_specific(ipver2af(chunk->skb->nh.iph->version));
+        if (af)
+                iif = af->skb_iif(chunk->skb);
+
+        return iif;
+}
+
+/* RFC 2960 3.3.2 Initiation (INIT) (1)
+ *
+ * Note 2: The ECN capable field is reserved for future use of
+ * Explicit Congestion Notification.
+ */
+static const struct sctp_paramhdr ecap_param = {
+        SCTP_PARAM_ECN_CAPABLE,
+        __constant_htons(sizeof(struct sctp_paramhdr)),
+};
+static const struct sctp_paramhdr prsctp_param = {
+        SCTP_PARAM_FWD_TSN_SUPPORT,
+        __constant_htons(sizeof(struct sctp_paramhdr)),
+};
+
+/* A helper to initialize to initialize an op error inside a
+ * provided chunk, as most cause codes will be embedded inside an
+ * abort chunk.
+ */
+void  sctp_init_cause(struct sctp_chunk *chunk, __u16 cause_code,
+                      const void *payload, size_t paylen)
+{
+        sctp_errhdr_t err;
+        int padlen;
+        __u16 len;
+
+        /* Cause code constants are now defined in network order.  */
+        err.cause = cause_code;
+        len = sizeof(sctp_errhdr_t) + paylen;
+        padlen = len % 4;
+        err.length  = htons(len);
+        len += padlen;
+        sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err);
+        chunk->subh.err_hdr = sctp_addto_chunk(chunk, paylen, payload);
+}
+
+/* 3.3.2 Initiation (INIT) (1)
+ *
+ * This chunk is used to initiate a SCTP association between two
+ * endpoints. The format of the INIT chunk is shown below:
+ *
+ *     0                   1                   2                   3
+ *     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |   Type = 1    |  Chunk Flags  |      Chunk Length             |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |                         Initiate Tag                          |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |           Advertised Receiver Window Credit (a_rwnd)          |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |  Number of Outbound Streams   |  Number of Inbound Streams    |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |                          Initial TSN                          |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    \                                                               \
+ *    /              Optional/Variable-Length Parameters              /
+ *    \                                                               \
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ *
+ * The INIT chunk contains the following parameters. Unless otherwise
+ * noted, each parameter MUST only be included once in the INIT chunk.
+ *
+ * Fixed Parameters                     Status
+ * ----------------------------------------------
+ * Initiate Tag                        Mandatory
+ * Advertised Receiver Window Credit   Mandatory
+ * Number of Outbound Streams          Mandatory
+ * Number of Inbound Streams           Mandatory
+ * Initial TSN                         Mandatory
+ *
+ * Variable Parameters                  Status     Type Value
+ * -------------------------------------------------------------
+ * IPv4 Address (Note 1)               Optional    5
+ * IPv6 Address (Note 1)               Optional    6
+ * Cookie Preservative                 Optional    9
+ * Reserved for ECN Capable (Note 2)   Optional    32768 (0x8000)
+ * Host Name Address (Note 3)          Optional    11
+ * Supported Address Types (Note 4)    Optional    12
+ */
+struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
+                             const struct sctp_bind_addr *bp,
+                             int gfp, int vparam_len)
+{
+        sctp_inithdr_t init;
+        union sctp_params addrs;
+        size_t chunksize;
+        struct sctp_chunk *retval = NULL;
+        int num_types, addrs_len = 0;
+        struct sctp_sock *sp;
+        sctp_supported_addrs_param_t sat;
+        __u16 types[2];
+        sctp_adaption_ind_param_t aiparam;
+
+        /* RFC 2960 3.3.2 Initiation (INIT) (1)
+         *
+         * Note 1: The INIT chunks can contain multiple addresses that
+         * can be IPv4 and/or IPv6 in any combination.
+         */
+        retval = NULL;
+
+        /* Convert the provided bind address list to raw format. */
+        addrs = sctp_bind_addrs_to_raw(bp, &addrs_len, gfp);
+
+        init.init_tag              = htonl(asoc->c.my_vtag);
+        init.a_rwnd                = htonl(asoc->rwnd);
+        init.num_outbound_streams  = htons(asoc->c.sinit_num_ostreams);
+        init.num_inbound_streams   = htons(asoc->c.sinit_max_instreams);
+        init.initial_tsn           = htonl(asoc->c.initial_tsn);
+
+        /* How many address types are needed? */
+        sp = sctp_sk(asoc->base.sk);
+        num_types = sp->pf->supported_addrs(sp, types);
+
+        chunksize = sizeof(init) + addrs_len + SCTP_SAT_LEN(num_types);
+        chunksize += sizeof(ecap_param);
+        if (sctp_prsctp_enable)
+                chunksize += sizeof(prsctp_param);
+        chunksize += sizeof(aiparam);
+        chunksize += vparam_len;
+
+        /* RFC 2960 3.3.2 Initiation (INIT) (1)
+         *
+         * Note 3: An INIT chunk MUST NOT contain more than one Host
+         * Name address parameter. Moreover, the sender of the INIT
+         * MUST NOT combine any other address types with the Host Name
+         * address in the INIT. The receiver of INIT MUST ignore any
+         * other address types if the Host Name address parameter is
+         * present in the received INIT chunk.
+         *
+         * PLEASE DO NOT FIXME [This version does not support Host Name.]
+         */
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_INIT, 0, chunksize);
+        if (!retval)
+                goto nodata;
+
+        retval->subh.init_hdr =
+                sctp_addto_chunk(retval, sizeof(init), &init);
+        retval->param_hdr.v =
+                sctp_addto_chunk(retval, addrs_len, addrs.v);
+
+        /* RFC 2960 3.3.2 Initiation (INIT) (1)
+         *
+         * Note 4: This parameter, when present, specifies all the
+         * address types the sending endpoint can support. The absence
+         * of this parameter indicates that the sending endpoint can
+         * support any address type.
+         */
+        sat.param_hdr.type = SCTP_PARAM_SUPPORTED_ADDRESS_TYPES;
+        sat.param_hdr.length = htons(SCTP_SAT_LEN(num_types));
+        sctp_addto_chunk(retval, sizeof(sat), &sat);
+        sctp_addto_chunk(retval, num_types * sizeof(__u16), &types);
+
+        sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
+        if (sctp_prsctp_enable)
+                sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
+        aiparam.param_hdr.type = SCTP_PARAM_ADAPTION_LAYER_IND;
+        aiparam.param_hdr.length = htons(sizeof(aiparam));
+        aiparam.adaption_ind = htonl(sp->adaption_ind);
+        sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
+nodata:
+        if (addrs.v)
+                kfree(addrs.v);
+        return retval;
+}
+
+struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
+                                 const struct sctp_chunk *chunk,
+                                 int gfp, int unkparam_len)
+{
+        sctp_inithdr_t initack;
+        struct sctp_chunk *retval;
+        union sctp_params addrs;
+        int addrs_len;
+        sctp_cookie_param_t *cookie;
+        int cookie_len;
+        size_t chunksize;
+        sctp_adaption_ind_param_t aiparam;
+
+        retval = NULL;
+
+        /* Note: there may be no addresses to embed. */
+        addrs = sctp_bind_addrs_to_raw(&asoc->base.bind_addr, &addrs_len, gfp);
+
+        initack.init_tag                = htonl(asoc->c.my_vtag);
+        initack.a_rwnd                  = htonl(asoc->rwnd);
+        initack.num_outbound_streams    = htons(asoc->c.sinit_num_ostreams);
+        initack.num_inbound_streams     = htons(asoc->c.sinit_max_instreams);
+        initack.initial_tsn             = htonl(asoc->c.initial_tsn);
+
+        /* FIXME:  We really ought to build the cookie right
+         * into the packet instead of allocating more fresh memory.
+         */
+        cookie = sctp_pack_cookie(asoc->ep, asoc, chunk, &cookie_len,
+                                  addrs.v, addrs_len);
+        if (!cookie)
+                goto nomem_cookie;
+
+        /* Calculate the total size of allocation, include the reserved
+         * space for reporting unknown parameters if it is specified.
+         */
+        chunksize = sizeof(initack) + addrs_len + cookie_len + unkparam_len;
+
+        /* Tell peer that we'll do ECN only if peer advertised such cap.  */
+        if (asoc->peer.ecn_capable)
+                chunksize += sizeof(ecap_param);
+
+        /* Tell peer that we'll do PR-SCTP only if peer advertised.  */
+        if (asoc->peer.prsctp_capable)
+                chunksize += sizeof(prsctp_param);
+
+        chunksize += sizeof(aiparam);
+
+        /* Now allocate and fill out the chunk.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_INIT_ACK, 0, chunksize);
+        if (!retval)
+                goto nomem_chunk;
+
+        /* Per the advice in RFC 2960 6.4, send this reply to
+         * the source of the INIT packet.
+         */
+        retval->transport = chunk->transport;
+        retval->subh.init_hdr =
+                sctp_addto_chunk(retval, sizeof(initack), &initack);
+        retval->param_hdr.v = sctp_addto_chunk(retval, addrs_len, addrs.v);
+        sctp_addto_chunk(retval, cookie_len, cookie);
+        if (asoc->peer.ecn_capable)
+                sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
+        if (asoc->peer.prsctp_capable)
+                sctp_addto_chunk(retval, sizeof(prsctp_param), &prsctp_param);
+
+        aiparam.param_hdr.type = SCTP_PARAM_ADAPTION_LAYER_IND;
+        aiparam.param_hdr.length = htons(sizeof(aiparam));
+        aiparam.adaption_ind = htonl(sctp_sk(asoc->base.sk)->adaption_ind);
+        sctp_addto_chunk(retval, sizeof(aiparam), &aiparam);
+
+        /* We need to remove the const qualifier at this point.  */
+        retval->asoc = (struct sctp_association *) asoc;
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [INIT ACK back to where the INIT came from.]
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+nomem_chunk:
+        kfree(cookie);
+nomem_cookie:
+        if (addrs.v)
+                kfree(addrs.v);
+        return retval;
+}
+
+/* 3.3.11 Cookie Echo (COOKIE ECHO) (10):
+ *
+ * This chunk is used only during the initialization of an association.
+ * It is sent by the initiator of an association to its peer to complete
+ * the initialization process. This chunk MUST precede any DATA chunk
+ * sent within the association, but MAY be bundled with one or more DATA
+ * chunks in the same packet.
+ *
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |   Type = 10   |Chunk  Flags   |         Length                |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     /                     Cookie                                    /
+ *     \                                                               \
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Chunk Flags: 8 bit
+ *
+ *   Set to zero on transmit and ignored on receipt.
+ *
+ * Length: 16 bits (unsigned integer)
+ *
+ *   Set to the size of the chunk in bytes, including the 4 bytes of
+ *   the chunk header and the size of the Cookie.
+ *
+ * Cookie: variable size
+ *
+ *   This field must contain the exact cookie received in the
+ *   State Cookie parameter from the previous INIT ACK.
+ *
+ *   An implementation SHOULD make the cookie as small as possible
+ *   to insure interoperability.
+ */
+struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *asoc,
+                                    const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+        void *cookie;
+        int cookie_len;
+
+        cookie = asoc->peer.cookie;
+        cookie_len = asoc->peer.cookie_len;
+
+        /* Build a cookie echo chunk.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_COOKIE_ECHO, 0, cookie_len);
+        if (!retval)
+                goto nodata;
+        retval->subh.cookie_hdr =
+                sctp_addto_chunk(retval, cookie_len, cookie);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [COOKIE ECHO back to where the INIT ACK came from.]
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+nodata:
+        return retval;
+}
+
+/* 3.3.12 Cookie Acknowledgement (COOKIE ACK) (11):
+ *
+ * This chunk is used only during the initialization of an
+ * association.  It is used to acknowledge the receipt of a COOKIE
+ * ECHO chunk.  This chunk MUST precede any DATA or SACK chunk sent
+ * within the association, but MAY be bundled with one or more DATA
+ * chunks or SACK chunk in the same SCTP packet.
+ *
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |   Type = 11   |Chunk  Flags   |     Length = 4                |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Chunk Flags: 8 bits
+ *
+ *   Set to zero on transmit and ignored on receipt.
+ */
+struct sctp_chunk *sctp_make_cookie_ack(const struct sctp_association *asoc,
+                                   const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_COOKIE_ACK, 0, 0);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [COOKIE ACK back to where the COOKIE ECHO came from.]
+         */
+        if (retval && chunk)
+                retval->transport = chunk->transport;
+
+        return retval;
+}
+
+/*
+ *  Appendix A: Explicit Congestion Notification:
+ *  CWR:
+ *
+ *  RFC 2481 details a specific bit for a sender to send in the header of
+ *  its next outbound TCP segment to indicate to its peer that it has
+ *  reduced its congestion window.  This is termed the CWR bit.  For
+ *  SCTP the same indication is made by including the CWR chunk.
+ *  This chunk contains one data element, i.e. the TSN number that
+ *  was sent in the ECNE chunk.  This element represents the lowest
+ *  TSN number in the datagram that was originally marked with the
+ *  CE bit.
+ *
+ *     0                   1                   2                   3
+ *     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    | Chunk Type=13 | Flags=00000000|    Chunk Length = 8           |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    |                      Lowest TSN Number                        |
+ *    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ *     Note: The CWR is considered a Control chunk.
+ */
+struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc,
+                            const __u32 lowest_tsn,
+                            const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+        sctp_cwrhdr_t cwr;
+
+        cwr.lowest_tsn = htonl(lowest_tsn);
+        retval = sctp_make_chunk(asoc, SCTP_CID_ECN_CWR, 0,
+                                 sizeof(sctp_cwrhdr_t));
+
+        if (!retval)
+                goto nodata;
+
+        retval->subh.ecn_cwr_hdr =
+                sctp_addto_chunk(retval, sizeof(cwr), &cwr);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [Report a reduced congestion window back to where the ECNE
+         * came from.]
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+nodata:
+        return retval;
+}
+
+/* Make an ECNE chunk.  This is a congestion experienced report.  */
+struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc,
+                             const __u32 lowest_tsn)
+{
+        struct sctp_chunk *retval;
+        sctp_ecnehdr_t ecne;
+
+        ecne.lowest_tsn = htonl(lowest_tsn);
+        retval = sctp_make_chunk(asoc, SCTP_CID_ECN_ECNE, 0,
+                                 sizeof(sctp_ecnehdr_t));
+        if (!retval)
+                goto nodata;
+        retval->subh.ecne_hdr =
+                sctp_addto_chunk(retval, sizeof(ecne), &ecne);
+
+nodata:
+        return retval;
+}
+
+/* Make a DATA chunk for the given association from the provided
+ * parameters.  However, do not populate the data payload.
+ */
+struct sctp_chunk *sctp_make_datafrag_empty(struct sctp_association *asoc,
+                                       const struct sctp_sndrcvinfo *sinfo,
+                                       int data_len, __u8 flags, __u16 ssn)
+{
+        struct sctp_chunk *retval;
+        struct sctp_datahdr dp;
+        int chunk_len;
+
+        /* We assign the TSN as LATE as possible, not here when
+         * creating the chunk.
+         */
+        dp.tsn = 0;
+        dp.stream = htons(sinfo->sinfo_stream);
+        dp.ppid   = sinfo->sinfo_ppid;
+
+        /* Set the flags for an unordered send.  */
+        if (sinfo->sinfo_flags & MSG_UNORDERED) {
+                flags |= SCTP_DATA_UNORDERED;
+                dp.ssn = 0;
+        } else
+                dp.ssn = htons(ssn);
+
+        chunk_len = sizeof(dp) + data_len;
+        retval = sctp_make_chunk(asoc, SCTP_CID_DATA, flags, chunk_len);
+        if (!retval)
+                goto nodata;
+
+        retval->subh.data_hdr = sctp_addto_chunk(retval, sizeof(dp), &dp);
+        memcpy(&retval->sinfo, sinfo, sizeof(struct sctp_sndrcvinfo));
+
+nodata:
+        return retval;
+}
+
+/* Create a selective ackowledgement (SACK) for the given
+ * association.  This reports on which TSN's we've seen to date,
+ * including duplicates and gaps.
+ */
+struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc)
+{
+        struct sctp_chunk *retval;
+        struct sctp_sackhdr sack;
+        int len;
+        __u32 ctsn;
+        __u16 num_gabs, num_dup_tsns;
+        struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
+
+        ctsn = sctp_tsnmap_get_ctsn(map);
+        SCTP_DEBUG_PRINTK("sackCTSNAck sent:  0x%x.\n", ctsn);
+
+        /* How much room is needed in the chunk? */
+        num_gabs = sctp_tsnmap_num_gabs(map);
+        num_dup_tsns = sctp_tsnmap_num_dups(map);
+
+        /* Initialize the SACK header.  */
+        sack.cum_tsn_ack            = htonl(ctsn);
+        sack.a_rwnd                 = htonl(asoc->a_rwnd);
+        sack.num_gap_ack_blocks     = htons(num_gabs);
+        sack.num_dup_tsns           = htons(num_dup_tsns);
+
+        len = sizeof(sack)
+                + sizeof(struct sctp_gap_ack_block) * num_gabs
+                + sizeof(__u32) * num_dup_tsns;
+
+        /* Create the chunk.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_SACK, 0, len);
+        if (!retval)
+                goto nodata;
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, etc.) to the same destination transport
+         * address from which it received the DATA or control chunk to
+         * which it is replying.  This rule should also be followed if
+         * the endpoint is bundling DATA chunks together with the
+         * reply chunk.
+         *
+         * However, when acknowledging multiple DATA chunks received
+         * in packets from different source addresses in a single
+         * SACK, the SACK chunk may be transmitted to one of the
+         * destination transport addresses from which the DATA or
+         * control chunks being acknowledged were received.
+         *
+         * [BUG:  We do not implement the following paragraph.
+         * Perhaps we should remember the last transport we used for a
+         * SACK and avoid that (if possible) if we have seen any
+         * duplicates. --piggy]
+         *
+         * When a receiver of a duplicate DATA chunk sends a SACK to a
+         * multi- homed endpoint it MAY be beneficial to vary the
+         * destination address and not use the source address of the
+         * DATA chunk.  The reason being that receiving a duplicate
+         * from a multi-homed endpoint might indicate that the return
+         * path (as specified in the source address of the DATA chunk)
+         * for the SACK is broken.
+         *
+         * [Send to the address from which we last received a DATA chunk.]
+         */
+        retval->transport = asoc->peer.last_data_from;
+
+        retval->subh.sack_hdr =
+                sctp_addto_chunk(retval, sizeof(sack), &sack);
+
+        /* Add the gap ack block information.   */
+        if (num_gabs)
+                sctp_addto_chunk(retval, sizeof(__u32) * num_gabs,
+                                 sctp_tsnmap_get_gabs(map));
+
+        /* Add the duplicate TSN information.  */
+        if (num_dup_tsns)
+                sctp_addto_chunk(retval, sizeof(__u32) * num_dup_tsns,
+                                 sctp_tsnmap_get_dups(map));
+
+nodata:
+        return retval;
+}
+
+/* Make a SHUTDOWN chunk. */
+struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,
+                                      const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+        sctp_shutdownhdr_t shut;
+        __u32 ctsn;
+
+        ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
+        shut.cum_tsn_ack = htonl(ctsn);
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN, 0,
+                                 sizeof(sctp_shutdownhdr_t));
+        if (!retval)
+                goto nodata;
+
+        retval->subh.shutdown_hdr =
+                sctp_addto_chunk(retval, sizeof(shut), &shut);
+
+        if (chunk)
+                retval->transport = chunk->transport;
+nodata:
+        return retval;
+}
+
+struct sctp_chunk *sctp_make_shutdown_ack(const struct sctp_association *asoc,
+                                     const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [ACK back to where the SHUTDOWN came from.]
+         */
+        if (retval && chunk)
+                retval->transport = chunk->transport;
+
+        return retval;
+}
+
+struct sctp_chunk *sctp_make_shutdown_complete(
+        const struct sctp_association *asoc,
+        const struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *retval;
+        __u8 flags = 0;
+
+        /* Maybe set the T-bit if we have no association. */
+        flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags, 0);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [Report SHUTDOWN COMPLETE back to where the SHUTDOWN ACK
+         * came from.]
+         */
+        if (retval && chunk)
+                retval->transport = chunk->transport;
+
+        return retval;
+}
+
+/* Create an ABORT.  Note that we set the T bit if we have no
+ * association.
+ */
+struct sctp_chunk *sctp_make_abort(const struct sctp_association *asoc,
+                              const struct sctp_chunk *chunk,
+                              const size_t hint)
+{
+        struct sctp_chunk *retval;
+        __u8 flags = 0;
+
+        /* Maybe set the T-bit if we have no association.  */
+        flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_ABORT, flags, hint);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [ABORT back to where the offender came from.]
+         */
+        if (retval && chunk)
+                retval->transport = chunk->transport;
+
+        return retval;
+}
+
+/* Helper to create ABORT with a NO_USER_DATA error.  */
+struct sctp_chunk *sctp_make_abort_no_data(
+        const struct sctp_association *asoc,
+        const struct sctp_chunk *chunk, __u32 tsn)
+{
+        struct sctp_chunk *retval;
+        __u32 payload;
+
+        retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t)
+                                 + sizeof(tsn));
+
+        if (!retval)
+                goto no_mem;
+
+        /* Put the tsn back into network byte order.  */
+        payload = htonl(tsn);
+        sctp_init_cause(retval, SCTP_ERROR_NO_DATA, (const void *)&payload,
+                        sizeof(payload));
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [ABORT back to where the offender came from.]
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+no_mem:
+        return retval;
+}
+
+/* Helper to create ABORT with a SCTP_ERROR_USER_ABORT error.  */
+struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc,
+                                   const struct sctp_chunk *chunk,
+                                   const struct msghdr *msg)
+{
+        struct sctp_chunk *retval;
+        void *payload = NULL, *payoff;
+        size_t paylen = 0;
+        struct iovec *iov = NULL;
+        int iovlen = 0;
+
+        if (msg) {
+                iov = msg->msg_iov;
+                iovlen = msg->msg_iovlen;
+                paylen = get_user_iov_size(iov, iovlen);
+        }
+
+        retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t) + paylen);
+        if (!retval)
+                goto err_chunk;
+
+        if (paylen) {
+                /* Put the msg_iov together into payload.  */
+                payload = kmalloc(paylen, GFP_ATOMIC);
+                if (!payload)
+                        goto err_payload;
+                payoff = payload;
+
+                for (; iovlen > 0; --iovlen) {
+                        if (copy_from_user(payoff, iov->iov_base,iov->iov_len))
+                                goto err_copy;
+                        payoff += iov->iov_len;
+                        iov++;
+                }
+        }
+
+        sctp_init_cause(retval, SCTP_ERROR_USER_ABORT, payload, paylen);
+
+        if (paylen)
+                kfree(payload);
+
+        return retval;
+
+err_copy:
+        kfree(payload);
+err_payload:
+        sctp_chunk_free(retval);
+        retval = NULL;
+err_chunk:
+        return retval;
+}
+
+/* Make an ABORT chunk with a PROTOCOL VIOLATION cause code. */ 
+struct sctp_chunk *sctp_make_abort_violation(
+        const struct sctp_association *asoc,
+        const struct sctp_chunk *chunk,
+        const __u8   *payload,
+        const size_t paylen)
+{
+        struct sctp_chunk  *retval;
+        struct sctp_paramhdr phdr;
+
+        retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t) + paylen
+                                        + sizeof(sctp_chunkhdr_t));
+        if (!retval)
+                goto end;
+
+        sctp_init_cause(retval, SCTP_ERROR_PROTO_VIOLATION, payload, paylen);
+
+        phdr.type = htons(chunk->chunk_hdr->type);
+        phdr.length = chunk->chunk_hdr->length;
+        sctp_addto_chunk(retval, sizeof(sctp_paramhdr_t), &phdr);
+
+end:
+        return retval;
+}
+
+/* Make a HEARTBEAT chunk.  */
+struct sctp_chunk *sctp_make_heartbeat(const struct sctp_association *asoc,
+                                  const struct sctp_transport *transport,
+                                  const void *payload, const size_t paylen)
+{
+        struct sctp_chunk *retval = sctp_make_chunk(asoc, SCTP_CID_HEARTBEAT,
+                                                    0, paylen);
+
+        if (!retval)
+                goto nodata;
+
+        /* Cast away the 'const', as this is just telling the chunk
+         * what transport it belongs to.
+         */
+        retval->transport = (struct sctp_transport *) transport;
+        retval->subh.hbs_hdr = sctp_addto_chunk(retval, paylen, payload);
+
+nodata:
+        return retval;
+}
+
+struct sctp_chunk *sctp_make_heartbeat_ack(const struct sctp_association *asoc,
+                                      const struct sctp_chunk *chunk,
+                                      const void *payload, const size_t paylen)
+{
+        struct sctp_chunk *retval;
+
+        retval  = sctp_make_chunk(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen);
+        if (!retval)
+                goto nodata;
+
+        retval->subh.hbs_hdr = sctp_addto_chunk(retval, paylen, payload);
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it * received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [HBACK back to where the HEARTBEAT came from.]
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+nodata:
+        return retval;
+}
+
+/* Create an Operation Error chunk with the specified space reserved.
+ * This routine can be used for containing multiple causes in the chunk.
+ */
+static struct sctp_chunk *sctp_make_op_error_space(
+        const struct sctp_association *asoc,
+        const struct sctp_chunk *chunk,
+        size_t size)
+{
+        struct sctp_chunk *retval;
+
+        retval = sctp_make_chunk(asoc, SCTP_CID_ERROR, 0,
+                                 sizeof(sctp_errhdr_t) + size);
+        if (!retval)
+                goto nodata;
+
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, etc.) to the same destination transport
+         * address from which it received the DATA or control chunk
+         * to which it is replying.
+         *
+         */
+        if (chunk)
+                retval->transport = chunk->transport;
+
+nodata:
+        return retval;
+}
+
+/* Create an Operation Error chunk.  */
+struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc,
+                                 const struct sctp_chunk *chunk,
+                                 __u16 cause_code, const void *payload,
+                                 size_t paylen)
+{
+        struct sctp_chunk *retval;
+
+        retval = sctp_make_op_error_space(asoc, chunk, paylen);
+        if (!retval)
+                goto nodata;
+
+        sctp_init_cause(retval, cause_code, payload, paylen);
+
+nodata:
+        return retval;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* Turn an skb into a chunk.
+ * FIXME: Eventually move the structure directly inside the skb->cb[].
+ */
+struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
+                            const struct sctp_association *asoc,
+                            struct sock *sk)
+{
+        struct sctp_chunk *retval;
+
+        retval = kmem_cache_alloc(sctp_chunk_cachep, SLAB_ATOMIC);
+
+        if (!retval)
+                goto nodata;
+        memset(retval, 0, sizeof(struct sctp_chunk));
+
+        if (!sk) {
+                SCTP_DEBUG_PRINTK("chunkifying skb %p w/o an sk\n", skb);
+        }
+
+        retval->skb             = skb;
+        retval->asoc            = (struct sctp_association *)asoc;
+        retval->resent          = 0;
+        retval->has_tsn         = 0;
+        retval->has_ssn         = 0;
+        retval->rtt_in_progress = 0;
+        retval->sent_at         = 0;
+        retval->singleton       = 1;
+        retval->end_of_packet   = 0;
+        retval->ecn_ce_done     = 0;
+        retval->pdiscard        = 0;
+
+        /* sctpimpguide-05.txt Section 2.8.2
+         * M1) Each time a new DATA chunk is transmitted
+         * set the 'TSN.Missing.Report' count for that TSN to 0. The
+         * 'TSN.Missing.Report' count will be used to determine missing chunks
+         * and when to fast retransmit.
+         */
+        retval->tsn_missing_report = 0;
+        retval->tsn_gap_acked = 0;
+        retval->fast_retransmit = 0;
+
+        /* If this is a fragmented message, track all fragments
+         * of the message (for SEND_FAILED).
+         */
+        retval->msg = NULL;
+
+        /* Polish the bead hole.  */
+        INIT_LIST_HEAD(&retval->transmitted_list);
+        INIT_LIST_HEAD(&retval->frag_list);
+        SCTP_DBG_OBJCNT_INC(chunk);
+        atomic_set(&retval->refcnt, 1);
+
+nodata:
+        return retval;
+}
+
+/* Set chunk->source and dest based on the IP header in chunk->skb.  */
+void sctp_init_addrs(struct sctp_chunk *chunk, union sctp_addr *src,
+                     union sctp_addr *dest)
+{
+        memcpy(&chunk->source, src, sizeof(union sctp_addr));
+        memcpy(&chunk->dest, dest, sizeof(union sctp_addr));
+}
+
+/* Extract the source address from a chunk.  */
+const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)
+{
+        /* If we have a known transport, use that.  */
+        if (chunk->transport) {
+                return &chunk->transport->ipaddr;
+        } else {
+                /* Otherwise, extract it from the IP header.  */
+                return &chunk->source;
+        }
+}
+
+/* Create a new chunk, setting the type and flags headers from the
+ * arguments, reserving enough space for a 'paylen' byte payload.
+ */
+SCTP_STATIC
+struct sctp_chunk *sctp_make_chunk(const struct sctp_association *asoc,
+                                   __u8 type, __u8 flags, int paylen)
+{
+        struct sctp_chunk *retval;
+        sctp_chunkhdr_t *chunk_hdr;
+        struct sk_buff *skb;
+        struct sock *sk;
+
+        /* No need to allocate LL here, as this is only a chunk. */
+        skb = alloc_skb(WORD_ROUND(sizeof(sctp_chunkhdr_t) + paylen),
+                        GFP_ATOMIC);
+        if (!skb)
+                goto nodata;
+
+        /* Make room for the chunk header.  */
+        chunk_hdr = (sctp_chunkhdr_t *)skb_put(skb, sizeof(sctp_chunkhdr_t));
+        chunk_hdr->type   = type;
+        chunk_hdr->flags  = flags;
+        chunk_hdr->length = htons(sizeof(sctp_chunkhdr_t));
+
+        sk = asoc ? asoc->base.sk : NULL;
+        retval = sctp_chunkify(skb, asoc, sk);
+        if (!retval) {
+                kfree_skb(skb);
+                goto nodata;
+        }
+
+        retval->chunk_hdr = chunk_hdr;
+        retval->chunk_end = ((__u8 *)chunk_hdr) + sizeof(struct sctp_chunkhdr);
+
+        /* Set the skb to the belonging sock for accounting.  */
+        skb->sk = sk;
+
+        return retval;
+nodata:
+        return NULL;
+}
+
+
+/* Release the memory occupied by a chunk.  */
+static void sctp_chunk_destroy(struct sctp_chunk *chunk)
+{
+        /* Free the chunk skb data and the SCTP_chunk stub itself. */
+        dev_kfree_skb(chunk->skb);
+
+        SCTP_DBG_OBJCNT_DEC(chunk);
+        kmem_cache_free(sctp_chunk_cachep, chunk);
+}
+
+/* Possibly, free the chunk.  */
+void sctp_chunk_free(struct sctp_chunk *chunk)
+{
+        /* Make sure that we are not on any list.  */
+        skb_unlink((struct sk_buff *) chunk);
+        list_del_init(&chunk->transmitted_list);
+
+        /* Release our reference on the message tracker. */
+        if (chunk->msg)
+                sctp_datamsg_put(chunk->msg);
+
+        sctp_chunk_put(chunk);
+}
+
+/* Grab a reference to the chunk. */
+void sctp_chunk_hold(struct sctp_chunk *ch)
+{
+        atomic_inc(&ch->refcnt);
+}
+
+/* Release a reference to the chunk. */
+void sctp_chunk_put(struct sctp_chunk *ch)
+{
+        if (atomic_dec_and_test(&ch->refcnt))
+                sctp_chunk_destroy(ch);
+}
+
+/* Append bytes to the end of a chunk.  Will panic if chunk is not big
+ * enough.
+ */
+void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)
+{
+        void *target;
+        void *padding;
+        int chunklen = ntohs(chunk->chunk_hdr->length);
+        int padlen = chunklen % 4;
+
+        padding = skb_put(chunk->skb, padlen);
+        target = skb_put(chunk->skb, len);
+
+        memset(padding, 0, padlen);
+        memcpy(target, data, len);
+
+        /* Adjust the chunk length field.  */
+        chunk->chunk_hdr->length = htons(chunklen + padlen + len);
+        chunk->chunk_end = chunk->skb->tail;
+
+        return target;
+}
+
+/* Append bytes from user space to the end of a chunk.  Will panic if
+ * chunk is not big enough.
+ * Returns a kernel err value.
+ */
+int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len,
+                          struct iovec *data)
+{
+        __u8 *target;
+        int err = 0;
+
+        /* Make room in chunk for data.  */
+        target = skb_put(chunk->skb, len);
+
+        /* Copy data (whole iovec) into chunk */
+        if ((err = memcpy_fromiovecend(target, data, off, len)))
+                goto out;
+
+        /* Adjust the chunk length field.  */
+        chunk->chunk_hdr->length =
+                htons(ntohs(chunk->chunk_hdr->length) + len);
+        chunk->chunk_end = chunk->skb->tail;
+
+out:
+        return err;
+}
+
+/* Helper function to assign a TSN if needed.  This assumes that both
+ * the data_hdr and association have already been assigned.
+ */
+void sctp_chunk_assign_ssn(struct sctp_chunk *chunk)
+{
+        __u16 ssn;
+        __u16 sid;
+
+        if (chunk->has_ssn)
+                return;
+
+        /* This is the last possible instant to assign a SSN. */
+        if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
+                ssn = 0;
+        } else {
+                sid = htons(chunk->subh.data_hdr->stream);
+                if (chunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG)
+                        ssn = sctp_ssn_next(&chunk->asoc->ssnmap->out, sid);
+                else
+                        ssn = sctp_ssn_peek(&chunk->asoc->ssnmap->out, sid);
+                ssn = htons(ssn);
+        }
+
+        chunk->subh.data_hdr->ssn = ssn;
+        chunk->has_ssn = 1;
+}
+
+/* Helper function to assign a TSN if needed.  This assumes that both
+ * the data_hdr and association have already been assigned.
+ */
+void sctp_chunk_assign_tsn(struct sctp_chunk *chunk)
+{
+        if (!chunk->has_tsn) {
+                /* This is the last possible instant to
+                 * assign a TSN.
+                 */
+                chunk->subh.data_hdr->tsn =
+                        htonl(sctp_association_get_next_tsn(chunk->asoc));
+                chunk->has_tsn = 1;
+        }
+}
+
+/* Create a CLOSED association to use with an incoming packet.  */
+struct sctp_association *sctp_make_temp_asoc(const struct sctp_endpoint *ep,
+                                        struct sctp_chunk *chunk, int gfp)
+{
+        struct sctp_association *asoc;
+        struct sk_buff *skb;
+        sctp_scope_t scope;
+        struct sctp_af *af;
+
+        /* Create the bare association.  */
+        scope = sctp_scope(sctp_source(chunk));
+        asoc = sctp_association_new(ep, ep->base.sk, scope, gfp);
+        if (!asoc)
+                goto nodata;
+        asoc->temp = 1;
+        skb = chunk->skb;
+        /* Create an entry for the source address of the packet.  */
+        af = sctp_get_af_specific(ipver2af(skb->nh.iph->version));
+        if (unlikely(!af))
+                goto fail;
+        af->from_skb(&asoc->c.peer_addr, skb, 1);
+nodata:
+        return asoc;
+
+fail:
+        sctp_association_free(asoc);
+        return NULL;
+}
+
+/* Build a cookie representing asoc.
+ * This INCLUDES the param header needed to put the cookie in the INIT ACK.
+ */
+static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
+                                      const struct sctp_association *asoc,
+                                      const struct sctp_chunk *init_chunk,
+                                      int *cookie_len,
+                                      const __u8 *raw_addrs, int addrs_len)
+{
+        sctp_cookie_param_t *retval;
+        struct sctp_signed_cookie *cookie;
+        struct scatterlist sg;
+        int headersize, bodysize;
+        unsigned int keylen;
+        char *key;
+
+        headersize = sizeof(sctp_paramhdr_t) + SCTP_SECRET_SIZE;
+        bodysize = sizeof(struct sctp_cookie)
+                + ntohs(init_chunk->chunk_hdr->length) + addrs_len;
+
+        /* Pad out the cookie to a multiple to make the signature
+         * functions simpler to write.
+         */
+        if (bodysize % SCTP_COOKIE_MULTIPLE)
+                bodysize += SCTP_COOKIE_MULTIPLE
+                        - (bodysize % SCTP_COOKIE_MULTIPLE);
+        *cookie_len = headersize + bodysize;
+
+        retval = (sctp_cookie_param_t *)kmalloc(*cookie_len, GFP_ATOMIC);
+
+        if (!retval) {
+                *cookie_len = 0;
+                goto nodata;
+        }
+
+        /* Clear this memory since we are sending this data structure
+         * out on the network.
+         */
+        memset(retval, 0x00, *cookie_len);
+        cookie = (struct sctp_signed_cookie *) retval->body;
+
+        /* Set up the parameter header.  */
+        retval->p.type = SCTP_PARAM_STATE_COOKIE;
+        retval->p.length = htons(*cookie_len);
+
+        /* Copy the cookie part of the association itself.  */
+        cookie->c = asoc->c;
+        /* Save the raw address list length in the cookie. */
+        cookie->c.raw_addr_list_len = addrs_len;
+
+        /* Remember PR-SCTP capability. */
+        cookie->c.prsctp_capable = asoc->peer.prsctp_capable;
+
+        /* Save adaption indication in the cookie. */
+        cookie->c.adaption_ind = asoc->peer.adaption_ind;
+
+        /* Set an expiration time for the cookie.  */
+        do_gettimeofday(&cookie->c.expiration);
+        TIMEVAL_ADD(asoc->cookie_life, cookie->c.expiration);
+
+        /* Copy the peer's init packet.  */
+        memcpy(&cookie->c.peer_init[0], init_chunk->chunk_hdr,
+               ntohs(init_chunk->chunk_hdr->length));
+
+        /* Copy the raw local address list of the association. */
+        memcpy((__u8 *)&cookie->c.peer_init[0] +
+               ntohs(init_chunk->chunk_hdr->length), raw_addrs, addrs_len);
+
+        if (sctp_sk(ep->base.sk)->hmac) {
+                /* Sign the message.  */
+                sg.page = virt_to_page(&cookie->c);
+                sg.offset = (unsigned long)(&cookie->c) % PAGE_SIZE;
+                sg.length = bodysize;
+                keylen = SCTP_SECRET_SIZE;
+                key = (char *)ep->secret_key[ep->current_key];
+
+                sctp_crypto_hmac(sctp_sk(ep->base.sk)->hmac, key, &keylen,
+                                 &sg, 1, cookie->signature);
+        }
+
+nodata:
+        return retval;
+}
+
+/* Unpack the cookie from COOKIE ECHO chunk, recreating the association.  */
+struct sctp_association *sctp_unpack_cookie(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        struct sctp_chunk *chunk, int gfp,
+        int *error, struct sctp_chunk **errp)
+{
+        struct sctp_association *retval = NULL;
+        struct sctp_signed_cookie *cookie;
+        struct sctp_cookie *bear_cookie;
+        int headersize, bodysize, fixed_size;
+        __u8 digest[SCTP_SIGNATURE_SIZE];
+        struct scatterlist sg;
+        unsigned int keylen, len;
+        char *key;
+        sctp_scope_t scope;
+        struct sk_buff *skb = chunk->skb;
+
+        headersize = sizeof(sctp_chunkhdr_t) + SCTP_SECRET_SIZE;
+        bodysize = ntohs(chunk->chunk_hdr->length) - headersize;
+        fixed_size = headersize + sizeof(struct sctp_cookie);
+
+        /* Verify that the chunk looks like it even has a cookie.
+         * There must be enough room for our cookie and our peer's
+         * INIT chunk.
+         */
+        len = ntohs(chunk->chunk_hdr->length);
+        if (len < fixed_size + sizeof(struct sctp_chunkhdr))
+                goto malformed;
+
+        /* Verify that the cookie has been padded out. */
+        if (bodysize % SCTP_COOKIE_MULTIPLE)
+                goto malformed;
+
+        /* Process the cookie.  */
+        cookie = chunk->subh.cookie_hdr;
+        bear_cookie = &cookie->c;
+
+        if (!sctp_sk(ep->base.sk)->hmac)
+                goto no_hmac;
+
+        /* Check the signature.  */
+        keylen = SCTP_SECRET_SIZE;
+        sg.page = virt_to_page(bear_cookie);
+        sg.offset = (unsigned long)(bear_cookie) % PAGE_SIZE;
+        sg.length = bodysize;
+        key = (char *)ep->secret_key[ep->current_key];
+
+        memset(digest, 0x00, sizeof(digest));
+        sctp_crypto_hmac(sctp_sk(ep->base.sk)->hmac, key, &keylen, &sg,
+                         1, digest);
+
+        if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
+                /* Try the previous key. */
+                key = (char *)ep->secret_key[ep->last_key];
+                memset(digest, 0x00, sizeof(digest));
+                sctp_crypto_hmac(sctp_sk(ep->base.sk)->hmac, key, &keylen,
+                                 &sg, 1, digest);
+
+                if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
+                        /* Yikes!  Still bad signature! */
+                        *error = -SCTP_IERROR_BAD_SIG;
+                        goto fail;
+                }
+        }
+
+no_hmac:
+        /* IG Section 2.35.2:
+         *  3) Compare the port numbers and the verification tag contained
+         *     within the COOKIE ECHO chunk to the actual port numbers and the
+         *     verification tag within the SCTP common header of the received
+         *     packet. If these values do not match the packet MUST be silently
+         *     discarded,
+         */
+        if (ntohl(chunk->sctp_hdr->vtag) != bear_cookie->my_vtag) {
+                *error = -SCTP_IERROR_BAD_TAG;
+                goto fail;
+        }
+
+        if (ntohs(chunk->sctp_hdr->source) != bear_cookie->peer_addr.v4.sin_port ||
+            ntohs(chunk->sctp_hdr->dest) != bear_cookie->my_port) {
+                *error = -SCTP_IERROR_BAD_PORTS;
+                goto fail;
+        }
+
+        /* Check to see if the cookie is stale.  If there is already
+         * an association, there is no need to check cookie's expiration
+         * for init collision case of lost COOKIE ACK.
+         */
+        if (!asoc && tv_lt(bear_cookie->expiration, skb->stamp)) {
+                __u16 len;
+                /*
+                 * Section 3.3.10.3 Stale Cookie Error (3)
+                 *
+                 * Cause of error
+                 * ---------------
+                 * Stale Cookie Error:  Indicates the receipt of a valid State
+                 * Cookie that has expired.
+                 */
+                len = ntohs(chunk->chunk_hdr->length);
+                *errp = sctp_make_op_error_space(asoc, chunk, len);
+                if (*errp) {
+                        suseconds_t usecs = (skb->stamp.tv_sec -
+                                bear_cookie->expiration.tv_sec) * 1000000L +
+                                skb->stamp.tv_usec -
+                                bear_cookie->expiration.tv_usec;
+
+                        usecs = htonl(usecs);
+                        sctp_init_cause(*errp, SCTP_ERROR_STALE_COOKIE,
+                                        &usecs, sizeof(usecs));
+                        *error = -SCTP_IERROR_STALE_COOKIE;
+                } else
+                        *error = -SCTP_IERROR_NOMEM;
+
+                goto fail;
+        }
+
+        /* Make a new base association.  */
+        scope = sctp_scope(sctp_source(chunk));
+        retval = sctp_association_new(ep, ep->base.sk, scope, gfp);
+        if (!retval) {
+                *error = -SCTP_IERROR_NOMEM;
+                goto fail;
+        }
+
+        /* Set up our peer's port number.  */
+        retval->peer.port = ntohs(chunk->sctp_hdr->source);
+
+        /* Populate the association from the cookie.  */
+        memcpy(&retval->c, bear_cookie, sizeof(*bear_cookie));
+
+        if (sctp_assoc_set_bind_addr_from_cookie(retval, bear_cookie,
+                                                 GFP_ATOMIC) < 0) {
+                *error = -SCTP_IERROR_NOMEM;
+                goto fail;
+        }
+
+        /* Also, add the destination address. */
+        if (list_empty(&retval->base.bind_addr.address_list)) {
+                sctp_add_bind_addr(&retval->base.bind_addr, &chunk->dest,
+                                   GFP_ATOMIC);
+        }
+
+        retval->next_tsn = retval->c.initial_tsn;
+        retval->ctsn_ack_point = retval->next_tsn - 1;
+        retval->addip_serial = retval->c.initial_tsn;
+        retval->adv_peer_ack_point = retval->ctsn_ack_point;
+        retval->peer.prsctp_capable = retval->c.prsctp_capable;
+        retval->peer.adaption_ind = retval->c.adaption_ind;
+
+        /* The INIT stuff will be done by the side effects.  */
+        return retval;
+
+fail:
+        if (retval)
+                sctp_association_free(retval);
+
+        return NULL;
+
+malformed:
+        /* Yikes!  The packet is either corrupt or deliberately
+         * malformed.
+         */
+        *error = -SCTP_IERROR_MALFORMED;
+        goto fail;
+}
+
+/********************************************************************
+ * 3rd Level Abstractions
+ ********************************************************************/
+
+struct __sctp_missing {
+        __u32 num_missing;
+        __u16 type;
+}  __attribute__((packed));
+
+/*
+ * Report a missing mandatory parameter.
+ */
+static int sctp_process_missing_param(const struct sctp_association *asoc,
+                                      sctp_param_t paramtype,
+                                      struct sctp_chunk *chunk,
+                                      struct sctp_chunk **errp)
+{
+        struct __sctp_missing report;
+        __u16 len;
+
+        len = WORD_ROUND(sizeof(report));
+
+        /* Make an ERROR chunk, preparing enough room for
+         * returning multiple unknown parameters.
+         */
+        if (!*errp)
+                *errp = sctp_make_op_error_space(asoc, chunk, len);
+
+        if (*errp) {
+                report.num_missing = htonl(1);
+                report.type = paramtype;
+                sctp_init_cause(*errp, SCTP_ERROR_INV_PARAM,
+                                &report, sizeof(report));
+        }
+
+        /* Stop processing this chunk. */
+        return 0;
+}
+
+/* Report an Invalid Mandatory Parameter.  */
+static int sctp_process_inv_mandatory(const struct sctp_association *asoc,
+                                      struct sctp_chunk *chunk,
+                                      struct sctp_chunk **errp)
+{
+        /* Invalid Mandatory Parameter Error has no payload. */
+
+        if (!*errp)
+                *errp = sctp_make_op_error_space(asoc, chunk, 0);
+
+        if (*errp)
+                sctp_init_cause(*errp, SCTP_ERROR_INV_PARAM, NULL, 0);
+
+        /* Stop processing this chunk. */
+        return 0;
+}
+
+static int sctp_process_inv_paramlength(const struct sctp_association *asoc,
+                                        struct sctp_paramhdr *param,
+                                        const struct sctp_chunk *chunk,
+                                        struct sctp_chunk **errp)
+{
+        char            error[] = "The following parameter had invalid length:";
+        size_t          payload_len = WORD_ROUND(sizeof(error)) + 
+                                                sizeof(sctp_paramhdr_t);
+
+
+        /* Create an error chunk and fill it in with our payload. */
+        if (!*errp)
+                *errp = sctp_make_op_error_space(asoc, chunk, payload_len);
+
+        if (*errp) {
+                sctp_init_cause(*errp, SCTP_ERROR_PROTO_VIOLATION, error,
+                                sizeof(error));
+                sctp_addto_chunk(*errp, sizeof(sctp_paramhdr_t), param);
+        }
+
+        return 0;
+}
+
+
+/* Do not attempt to handle the HOST_NAME parm.  However, do
+ * send back an indicator to the peer.
+ */
+static int sctp_process_hn_param(const struct sctp_association *asoc,
+                                 union sctp_params param,
+                                 struct sctp_chunk *chunk,
+                                 struct sctp_chunk **errp)
+{
+        __u16 len = ntohs(param.p->length);
+
+        /* Make an ERROR chunk. */
+        if (!*errp)
+                *errp = sctp_make_op_error_space(asoc, chunk, len);
+
+        if (*errp)
+                sctp_init_cause(*errp, SCTP_ERROR_DNS_FAILED,
+                                param.v, len);
+
+        /* Stop processing this chunk. */
+        return 0;
+}
+
+/* RFC 3.2.1 & the Implementers Guide 2.2.
+ *
+ * The Parameter Types are encoded such that the
+ * highest-order two bits specify the action that must be
+ * taken if the processing endpoint does not recognize the
+ * Parameter Type.
+ *
+ * 00 - Stop processing this SCTP chunk and discard it,
+ *      do not process any further chunks within it.
+ *
+ * 01 - Stop processing this SCTP chunk and discard it,
+ *      do not process any further chunks within it, and report
+ *      the unrecognized parameter in an 'Unrecognized
+ *      Parameter Type' (in either an ERROR or in the INIT ACK).
+ *
+ * 10 - Skip this parameter and continue processing.
+ *
+ * 11 - Skip this parameter and continue processing but
+ *      report the unrecognized parameter in an
+ *      'Unrecognized Parameter Type' (in either an ERROR or in
+ *      the INIT ACK).
+ *
+ * Return value:
+ *      0 - discard the chunk
+ *      1 - continue with the chunk
+ */
+static int sctp_process_unk_param(const struct sctp_association *asoc,
+                                  union sctp_params param,
+                                  struct sctp_chunk *chunk,
+                                  struct sctp_chunk **errp)
+{
+        int retval = 1;
+
+        switch (param.p->type & SCTP_PARAM_ACTION_MASK) {
+        case SCTP_PARAM_ACTION_DISCARD:
+                retval =  0;
+                break;
+        case SCTP_PARAM_ACTION_DISCARD_ERR:
+                retval =  0;
+                /* Make an ERROR chunk, preparing enough room for
+                 * returning multiple unknown parameters.
+                 */
+                if (NULL == *errp)
+                        *errp = sctp_make_op_error_space(asoc, chunk,
+                                        ntohs(chunk->chunk_hdr->length));
+
+                if (*errp)
+                        sctp_init_cause(*errp, SCTP_ERROR_UNKNOWN_PARAM,
+                                        param.v,
+                                        WORD_ROUND(ntohs(param.p->length)));
+
+                break;
+        case SCTP_PARAM_ACTION_SKIP:
+                break;
+        case SCTP_PARAM_ACTION_SKIP_ERR:
+                /* Make an ERROR chunk, preparing enough room for
+                 * returning multiple unknown parameters.
+                 */
+                if (NULL == *errp)
+                        *errp = sctp_make_op_error_space(asoc, chunk,
+                                        ntohs(chunk->chunk_hdr->length));
+
+                if (*errp) {
+                        sctp_init_cause(*errp, SCTP_ERROR_UNKNOWN_PARAM,
+                                        param.v,
+                                        WORD_ROUND(ntohs(param.p->length)));
+                } else {
+                        /* If there is no memory for generating the ERROR
+                         * report as specified, an ABORT will be triggered
+                         * to the peer and the association won't be
+                         * established.
+                         */
+                        retval = 0;
+                }
+
+                break;
+        default:
+                break;
+        }
+
+        return retval;
+}
+
+/* Find unrecognized parameters in the chunk.
+ * Return values:
+ *      0 - discard the chunk
+ *      1 - continue with the chunk
+ */
+static int sctp_verify_param(const struct sctp_association *asoc,
+                             union sctp_params param,
+                             sctp_cid_t cid,
+                             struct sctp_chunk *chunk,
+                             struct sctp_chunk **err_chunk)
+{
+        int retval = 1;
+
+        /* FIXME - This routine is not looking at each parameter per the
+         * chunk type, i.e., unrecognized parameters should be further
+         * identified based on the chunk id.
+         */
+
+        switch (param.p->type) {
+        case SCTP_PARAM_IPV4_ADDRESS:
+        case SCTP_PARAM_IPV6_ADDRESS:
+        case SCTP_PARAM_COOKIE_PRESERVATIVE:
+        case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
+        case SCTP_PARAM_STATE_COOKIE:
+        case SCTP_PARAM_HEARTBEAT_INFO:
+        case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
+        case SCTP_PARAM_ECN_CAPABLE:
+        case SCTP_PARAM_ADAPTION_LAYER_IND:
+                break;
+
+        case SCTP_PARAM_HOST_NAME_ADDRESS:
+                /* Tell the peer, we won't support this param.  */
+                return sctp_process_hn_param(asoc, param, chunk, err_chunk);
+        case SCTP_PARAM_FWD_TSN_SUPPORT:
+                if (sctp_prsctp_enable)
+                        break;
+                /* Fall Through */ 
+        default:
+                SCTP_DEBUG_PRINTK("Unrecognized param: %d for chunk %d.\n",
+                                ntohs(param.p->type), cid);
+                return sctp_process_unk_param(asoc, param, chunk, err_chunk);
+
+                break;
+        }
+        return retval;
+}
+
+/* Verify the INIT packet before we process it.  */
+int sctp_verify_init(const struct sctp_association *asoc,
+                     sctp_cid_t cid,
+                     sctp_init_chunk_t *peer_init,
+                     struct sctp_chunk *chunk,
+                     struct sctp_chunk **errp)
+{
+        union sctp_params param;
+        int has_cookie = 0;
+
+        /* Verify stream values are non-zero. */
+        if ((0 == peer_init->init_hdr.num_outbound_streams) ||
+            (0 == peer_init->init_hdr.num_inbound_streams)) {
+
+                sctp_process_inv_mandatory(asoc, chunk, errp);
+                return 0;
+        }
+
+        /* Check for missing mandatory parameters.  */
+        sctp_walk_params(param, peer_init, init_hdr.params) {
+
+                if (SCTP_PARAM_STATE_COOKIE == param.p->type)
+                        has_cookie = 1;
+
+        } /* for (loop through all parameters) */
+
+        /* There is a possibility that a parameter length was bad and
+         * in that case we would have stoped walking the parameters.
+         * The current param.p would point at the bad one.
+         * Current consensus on the mailing list is to generate a PROTOCOL
+         * VIOLATION error.  We build the ERROR chunk here and let the normal
+         * error handling code build and send the packet.
+         */
+        if (param.v < (void*)chunk->chunk_end - sizeof(sctp_paramhdr_t)) {
+                sctp_process_inv_paramlength(asoc, param.p, chunk, errp);
+                return 0;
+        }
+
+        /* The only missing mandatory param possible today is
+         * the state cookie for an INIT-ACK chunk.
+         */
+        if ((SCTP_CID_INIT_ACK == cid) && !has_cookie) {
+                sctp_process_missing_param(asoc, SCTP_PARAM_STATE_COOKIE,
+                                           chunk, errp);
+                return 0;
+        }
+
+        /* Find unrecognized parameters. */
+
+        sctp_walk_params(param, peer_init, init_hdr.params) {
+
+                if (!sctp_verify_param(asoc, param, cid, chunk, errp)) {
+                        if (SCTP_PARAM_HOST_NAME_ADDRESS == param.p->type)
+                                return 0;
+                        else
+                                return 1;
+                }
+
+        } /* for (loop through all parameters) */
+
+        return 1;
+}
+
+/* Unpack the parameters in an INIT packet into an association.
+ * Returns 0 on failure, else success.
+ * FIXME:  This is an association method.
+ */
+int sctp_process_init(struct sctp_association *asoc, sctp_cid_t cid,
+                      const union sctp_addr *peer_addr,
+                      sctp_init_chunk_t *peer_init, int gfp)
+{
+        union sctp_params param;
+        struct sctp_transport *transport;
+        struct list_head *pos, *temp;
+        char *cookie;
+
+        /* We must include the address that the INIT packet came from.
+         * This is the only address that matters for an INIT packet.
+         * When processing a COOKIE ECHO, we retrieve the from address
+         * of the INIT from the cookie.
+         */
+
+        /* This implementation defaults to making the first transport
+         * added as the primary transport.  The source address seems to
+         * be a a better choice than any of the embedded addresses.
+         */
+        if (peer_addr)
+                if(!sctp_assoc_add_peer(asoc, peer_addr, gfp))
+                        goto nomem;
+
+        /* Process the initialization parameters.  */
+
+        sctp_walk_params(param, peer_init, init_hdr.params) {
+
+                if (!sctp_process_param(asoc, param, peer_addr, gfp))
+                        goto clean_up;
+        }
+
+        /* The fixed INIT headers are always in network byte
+         * order.
+         */
+        asoc->peer.i.init_tag =
+                ntohl(peer_init->init_hdr.init_tag);
+        asoc->peer.i.a_rwnd =
+                ntohl(peer_init->init_hdr.a_rwnd);
+        asoc->peer.i.num_outbound_streams =
+                ntohs(peer_init->init_hdr.num_outbound_streams);
+        asoc->peer.i.num_inbound_streams =
+                ntohs(peer_init->init_hdr.num_inbound_streams);
+        asoc->peer.i.initial_tsn =
+                ntohl(peer_init->init_hdr.initial_tsn);
+
+        /* Apply the upper bounds for output streams based on peer's
+         * number of inbound streams.
+         */
+        if (asoc->c.sinit_num_ostreams  >
+            ntohs(peer_init->init_hdr.num_inbound_streams)) {
+                asoc->c.sinit_num_ostreams =
+                        ntohs(peer_init->init_hdr.num_inbound_streams);
+        }
+
+        if (asoc->c.sinit_max_instreams >
+            ntohs(peer_init->init_hdr.num_outbound_streams)) {
+                asoc->c.sinit_max_instreams =
+                        ntohs(peer_init->init_hdr.num_outbound_streams);
+        }
+
+        /* Copy Initiation tag from INIT to VT_peer in cookie.   */
+        asoc->c.peer_vtag = asoc->peer.i.init_tag;
+
+        /* Peer Rwnd   : Current calculated value of the peer's rwnd.  */
+        asoc->peer.rwnd = asoc->peer.i.a_rwnd;
+
+        /* Copy cookie in case we need to resend COOKIE-ECHO. */
+        cookie = asoc->peer.cookie;
+        if (cookie) {
+                asoc->peer.cookie = kmalloc(asoc->peer.cookie_len, gfp);
+                if (!asoc->peer.cookie)
+                        goto clean_up;
+                memcpy(asoc->peer.cookie, cookie, asoc->peer.cookie_len);
+        }
+
+        /* RFC 2960 7.2.1 The initial value of ssthresh MAY be arbitrarily
+         * high (for example, implementations MAY use the size of the receiver
+         * advertised window).
+         */
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                transport->ssthresh = asoc->peer.i.a_rwnd;
+        }
+
+        /* Set up the TSN tracking pieces.  */
+        sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE,
+                         asoc->peer.i.initial_tsn);
+
+        /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
+         *
+         * The stream sequence number in all the streams shall start
+         * from 0 when the association is established.  Also, when the
+         * stream sequence number reaches the value 65535 the next
+         * stream sequence number shall be set to 0.
+         */
+
+        /* Allocate storage for the negotiated streams if it is not a temporary          * association.
+         */
+        if (!asoc->temp) {
+                int assoc_id;
+                int error;
+
+                asoc->ssnmap = sctp_ssnmap_new(asoc->c.sinit_max_instreams,
+                                               asoc->c.sinit_num_ostreams, gfp);
+                if (!asoc->ssnmap)
+                        goto clean_up;
+
+        retry:
+                if (unlikely(!idr_pre_get(&sctp_assocs_id, gfp)))
+                        goto clean_up;
+                spin_lock_bh(&sctp_assocs_id_lock);
+                error = idr_get_new_above(&sctp_assocs_id, (void *)asoc, 1,
+                                          &assoc_id);
+                spin_unlock_bh(&sctp_assocs_id_lock);
+                if (error == -EAGAIN)
+                        goto retry;
+                else if (error)
+                        goto clean_up;
+
+                asoc->assoc_id = (sctp_assoc_t) assoc_id;
+        }
+
+        /* ADDIP Section 4.1 ASCONF Chunk Procedures
+         *
+         * When an endpoint has an ASCONF signaled change to be sent to the
+         * remote endpoint it should do the following:
+         * ...
+         * A2) A serial number should be assigned to the Chunk. The serial
+         * number should be a monotonically increasing number. All serial
+         * numbers are defined to be initialized at the start of the
+         * association to the same value as the Initial TSN.
+         */
+        asoc->peer.addip_serial = asoc->peer.i.initial_tsn - 1;
+        return 1;
+
+clean_up:
+        /* Release the transport structures. */
+        list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
+                transport = list_entry(pos, struct sctp_transport, transports);
+                list_del_init(pos);
+                sctp_transport_free(transport);
+        }
+nomem:
+        return 0;
+}
+
+
+/* Update asoc with the option described in param.
+ *
+ * RFC2960 3.3.2.1 Optional/Variable Length Parameters in INIT
+ *
+ * asoc is the association to update.
+ * param is the variable length parameter to use for update.
+ * cid tells us if this is an INIT, INIT ACK or COOKIE ECHO.
+ * If the current packet is an INIT we want to minimize the amount of
+ * work we do.  In particular, we should not build transport
+ * structures for the addresses.
+ */
+static int sctp_process_param(struct sctp_association *asoc,
+                              union sctp_params param,
+                              const union sctp_addr *peer_addr,
+                              int gfp)
+{
+        union sctp_addr addr;
+        int i;
+        __u16 sat;
+        int retval = 1;
+        sctp_scope_t scope;
+        time_t stale;
+        struct sctp_af *af;
+
+        /* We maintain all INIT parameters in network byte order all the
+         * time.  This allows us to not worry about whether the parameters
+         * came from a fresh INIT, and INIT ACK, or were stored in a cookie.
+         */
+        switch (param.p->type) {
+        case SCTP_PARAM_IPV6_ADDRESS:
+                if (PF_INET6 != asoc->base.sk->sk_family)
+                        break;
+                /* Fall through. */
+        case SCTP_PARAM_IPV4_ADDRESS:
+                af = sctp_get_af_specific(param_type2af(param.p->type));
+                af->from_addr_param(&addr, param.addr, asoc->peer.port, 0);
+                scope = sctp_scope(peer_addr);
+                if (sctp_in_scope(&addr, scope))
+                        if (!sctp_assoc_add_peer(asoc, &addr, gfp))
+                                return 0;
+                break;
+
+        case SCTP_PARAM_COOKIE_PRESERVATIVE:
+                if (!sctp_cookie_preserve_enable)
+                        break;
+
+                stale = ntohl(param.life->lifespan_increment);
+
+                /* Suggested Cookie Life span increment's unit is msec,
+                 * (1/1000sec).
+                 */
+                asoc->cookie_life.tv_sec += stale / 1000;
+                asoc->cookie_life.tv_usec += (stale % 1000) * 1000;
+                break;
+
+        case SCTP_PARAM_HOST_NAME_ADDRESS:
+                SCTP_DEBUG_PRINTK("unimplemented SCTP_HOST_NAME_ADDRESS\n");
+                break;
+
+        case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
+                /* Turn off the default values first so we'll know which
+                 * ones are really set by the peer.
+                 */
+                asoc->peer.ipv4_address = 0;
+                asoc->peer.ipv6_address = 0;
+
+                /* Cycle through address types; avoid divide by 0. */
+                sat = ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
+                if (sat)
+                        sat /= sizeof(__u16);
+
+                for (i = 0; i < sat; ++i) {
+                        switch (param.sat->types[i]) {
+                        case SCTP_PARAM_IPV4_ADDRESS:
+                                asoc->peer.ipv4_address = 1;
+                                break;
+
+                        case SCTP_PARAM_IPV6_ADDRESS:
+                                asoc->peer.ipv6_address = 1;
+                                break;
+
+                        case SCTP_PARAM_HOST_NAME_ADDRESS:
+                                asoc->peer.hostname_address = 1;
+                                break;
+
+                        default: /* Just ignore anything else.  */
+                                break;
+                        };
+                }
+                break;
+
+        case SCTP_PARAM_STATE_COOKIE:
+                asoc->peer.cookie_len =
+                        ntohs(param.p->length) - sizeof(sctp_paramhdr_t);
+                asoc->peer.cookie = param.cookie->body;
+                break;
+
+        case SCTP_PARAM_HEARTBEAT_INFO:
+                /* Would be odd to receive, but it causes no problems. */
+                break;
+
+        case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
+                /* Rejected during verify stage. */
+                break;
+
+        case SCTP_PARAM_ECN_CAPABLE:
+                asoc->peer.ecn_capable = 1;
+                break;
+
+        case SCTP_PARAM_ADAPTION_LAYER_IND:
+                asoc->peer.adaption_ind = param.aind->adaption_ind;
+                break;
+
+        case SCTP_PARAM_FWD_TSN_SUPPORT:
+                if (sctp_prsctp_enable) {
+                        asoc->peer.prsctp_capable = 1;
+                        break;
+                }
+                /* Fall Through */ 
+        default:
+                /* Any unrecognized parameters should have been caught
+                 * and handled by sctp_verify_param() which should be
+                 * called prior to this routine.  Simply log the error
+                 * here.
+                 */
+                SCTP_DEBUG_PRINTK("Ignoring param: %d for association %p.\n",
+                                  ntohs(param.p->type), asoc);
+                break;
+        };
+
+        return retval;
+}
+
+/* Select a new verification tag.  */
+__u32 sctp_generate_tag(const struct sctp_endpoint *ep)
+{
+        /* I believe that this random number generator complies with RFC1750.
+         * A tag of 0 is reserved for special cases (e.g. INIT).
+         */
+        __u32 x;
+
+        do {
+                get_random_bytes(&x, sizeof(__u32));
+        } while (x == 0);
+
+        return x;
+}
+
+/* Select an initial TSN to send during startup.  */
+__u32 sctp_generate_tsn(const struct sctp_endpoint *ep)
+{
+        __u32 retval;
+
+        get_random_bytes(&retval, sizeof(__u32));
+        return retval;
+}
+
+/*
+ * ADDIP 3.1.1 Address Configuration Change Chunk (ASCONF)
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     | Type = 0xC1   |  Chunk Flags  |      Chunk Length             |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                       Serial Number                           |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                    Address Parameter                          |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                     ASCONF Parameter #1                       |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     \                                                               \
+ *     /                             ....                              /
+ *     \                                                               \
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                     ASCONF Parameter #N                       |
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Address Parameter and other parameter will not be wrapped in this function 
+ */
+static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc,
+                                           union sctp_addr *addr,
+                                           int vparam_len)
+{
+        sctp_addiphdr_t asconf;
+        struct sctp_chunk *retval;
+        int length = sizeof(asconf) + vparam_len;
+        union sctp_addr_param addrparam;
+        int addrlen;
+        struct sctp_af *af = sctp_get_af_specific(addr->v4.sin_family);
+
+        addrlen = af->to_addr_param(addr, &addrparam);
+        if (!addrlen)
+                return NULL;
+        length += addrlen;
+
+        /* Create the chunk.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_ASCONF, 0, length);
+        if (!retval)
+                return NULL;
+
+        asconf.serial = htonl(asoc->addip_serial++);
+
+        retval->subh.addip_hdr =
+                sctp_addto_chunk(retval, sizeof(asconf), &asconf);
+        retval->param_hdr.v =
+                sctp_addto_chunk(retval, addrlen, &addrparam);
+
+        return retval;
+}
+
+/* ADDIP
+ * 3.2.1 Add IP Address
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |        Type = 0xC001          |    Length = Variable          |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |               ASCONF-Request Correlation ID                   |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                       Address Parameter                       |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * 3.2.2 Delete IP Address
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |        Type = 0xC002          |    Length = Variable          |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |               ASCONF-Request Correlation ID                   |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                       Address Parameter                       |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ */
+struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc,
+                                              union sctp_addr         *laddr,
+                                              struct sockaddr         *addrs,
+                                              int                     addrcnt,
+                                              __u16                   flags)
+{
+        sctp_addip_param_t      param;
+        struct sctp_chunk       *retval;
+        union sctp_addr_param   addr_param;
+        union sctp_addr         *addr;
+        void                    *addr_buf;
+        struct sctp_af          *af;
+        int                     paramlen = sizeof(param);
+        int                     addr_param_len = 0;
+        int                     totallen = 0;
+        int                     i;
+
+        /* Get total length of all the address parameters. */
+        addr_buf = addrs;
+        for (i = 0; i < addrcnt; i++) {
+                addr = (union sctp_addr *)addr_buf;
+                af = sctp_get_af_specific(addr->v4.sin_family);
+                addr_param_len = af->to_addr_param(addr, &addr_param);
+
+                totallen += paramlen;
+                totallen += addr_param_len;
+
+                addr_buf += af->sockaddr_len;
+        }
+
+        /* Create an asconf chunk with the required length. */
+        retval = sctp_make_asconf(asoc, laddr, totallen);
+        if (!retval)
+                return NULL;
+
+        /* Add the address parameters to the asconf chunk. */
+        addr_buf = addrs;
+        for (i = 0; i < addrcnt; i++) {
+                addr = (union sctp_addr *)addr_buf;
+                af = sctp_get_af_specific(addr->v4.sin_family);
+                addr_param_len = af->to_addr_param(addr, &addr_param);
+                param.param_hdr.type = flags;
+                param.param_hdr.length = htons(paramlen + addr_param_len);
+                param.crr_id = i;
+
+                sctp_addto_chunk(retval, paramlen, &param);
+                sctp_addto_chunk(retval, addr_param_len, &addr_param);
+
+                addr_buf += af->sockaddr_len;
+        }
+        return retval;
+}
+
+/* ADDIP
+ * 3.2.4 Set Primary IP Address
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |        Type =0xC004           |    Length = Variable          |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |               ASCONF-Request Correlation ID                   |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                       Address Parameter                       |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Create an ASCONF chunk with Set Primary IP address parameter. 
+ */
+struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc,
+                                             union sctp_addr *addr)
+{
+        sctp_addip_param_t      param;
+        struct sctp_chunk       *retval;
+        int                     len = sizeof(param);
+        union sctp_addr_param   addrparam;
+        int                     addrlen;
+        struct sctp_af          *af = sctp_get_af_specific(addr->v4.sin_family);
+
+        addrlen = af->to_addr_param(addr, &addrparam);
+        if (!addrlen)
+                return NULL;
+        len += addrlen;
+
+        /* Create the chunk and make asconf header. */
+        retval = sctp_make_asconf(asoc, addr, len);
+        if (!retval)
+                return NULL;
+
+        param.param_hdr.type = SCTP_PARAM_SET_PRIMARY;
+        param.param_hdr.length = htons(len);
+        param.crr_id = 0;
+
+        sctp_addto_chunk(retval, sizeof(param), &param);
+        sctp_addto_chunk(retval, addrlen, &addrparam);
+
+        return retval;
+}
+
+/* ADDIP 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     | Type = 0x80   |  Chunk Flags  |      Chunk Length             |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                       Serial Number                           |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                 ASCONF Parameter Response#1                   |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     \                                                               \
+ *     /                             ....                              /
+ *     \                                                               \
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                 ASCONF Parameter Response#N                   |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Create an ASCONF_ACK chunk with enough space for the parameter responses. 
+ */
+static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *asoc,
+                                               __u32 serial, int vparam_len)
+{
+        sctp_addiphdr_t         asconf;
+        struct sctp_chunk       *retval;
+        int                     length = sizeof(asconf) + vparam_len;
+
+        /* Create the chunk.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_ASCONF_ACK, 0, length);
+        if (!retval)
+                return NULL;
+
+        asconf.serial = htonl(serial);
+
+        retval->subh.addip_hdr =
+                sctp_addto_chunk(retval, sizeof(asconf), &asconf);
+
+        return retval;
+}
+
+/* Add response parameters to an ASCONF_ACK chunk. */
+static void sctp_add_asconf_response(struct sctp_chunk *chunk, __u32 crr_id,
+                              __u16 err_code, sctp_addip_param_t *asconf_param)
+{
+        sctp_addip_param_t      ack_param;
+        sctp_errhdr_t           err_param;
+        int                     asconf_param_len = 0;
+        int                     err_param_len = 0;
+        __u16                   response_type;
+
+        if (SCTP_ERROR_NO_ERROR == err_code) {
+                response_type = SCTP_PARAM_SUCCESS_REPORT;
+        } else {
+                response_type = SCTP_PARAM_ERR_CAUSE;
+                err_param_len = sizeof(err_param);
+                if (asconf_param)
+                        asconf_param_len =
+                                 ntohs(asconf_param->param_hdr.length);
+        }
+
+        /* Add Success Indication or Error Cause Indication parameter. */ 
+        ack_param.param_hdr.type = response_type;
+        ack_param.param_hdr.length = htons(sizeof(ack_param) +
+                                           err_param_len +
+                                           asconf_param_len);
+        ack_param.crr_id = crr_id;
+        sctp_addto_chunk(chunk, sizeof(ack_param), &ack_param);
+
+        if (SCTP_ERROR_NO_ERROR == err_code)
+                return;
+
+        /* Add Error Cause parameter. */
+        err_param.cause = err_code;
+        err_param.length = htons(err_param_len + asconf_param_len);
+        sctp_addto_chunk(chunk, err_param_len, &err_param);
+
+        /* Add the failed TLV copied from ASCONF chunk. */
+        if (asconf_param)
+                sctp_addto_chunk(chunk, asconf_param_len, asconf_param);
+}
+
+/* Process a asconf parameter. */
+static __u16 sctp_process_asconf_param(struct sctp_association *asoc,
+                                       struct sctp_chunk *asconf,
+                                       sctp_addip_param_t *asconf_param)
+{
+        struct sctp_transport *peer;
+        struct sctp_af *af;
+        union sctp_addr addr;
+        struct list_head *pos;
+        union sctp_addr_param *addr_param;
+                                 
+        addr_param = (union sctp_addr_param *)
+                        ((void *)asconf_param + sizeof(sctp_addip_param_t));
+
+        af = sctp_get_af_specific(param_type2af(addr_param->v4.param_hdr.type));
+        if (unlikely(!af))
+                return SCTP_ERROR_INV_PARAM;
+
+        af->from_addr_param(&addr, addr_param, asoc->peer.port, 0);
+        switch (asconf_param->param_hdr.type) {
+        case SCTP_PARAM_ADD_IP:
+                /* ADDIP 4.3 D9) If an endpoint receives an ADD IP address
+                 * request and does not have the local resources to add this
+                 * new address to the association, it MUST return an Error
+                 * Cause TLV set to the new error code 'Operation Refused
+                 * Due to Resource Shortage'.
+                 */
+
+                peer = sctp_assoc_add_peer(asoc, &addr, GFP_ATOMIC);
+                if (!peer)
+                        return SCTP_ERROR_RSRC_LOW;
+
+                /* Start the heartbeat timer. */
+                if (!mod_timer(&peer->hb_timer, sctp_transport_timeout(peer)))
+                        sctp_transport_hold(peer);
+                break;
+        case SCTP_PARAM_DEL_IP:
+                /* ADDIP 4.3 D7) If a request is received to delete the
+                 * last remaining IP address of a peer endpoint, the receiver
+                 * MUST send an Error Cause TLV with the error cause set to the
+                 * new error code 'Request to Delete Last Remaining IP Address'.
+                 */
+                pos = asoc->peer.transport_addr_list.next;
+                if (pos->next == &asoc->peer.transport_addr_list)
+                        return SCTP_ERROR_DEL_LAST_IP;
+
+                /* ADDIP 4.3 D8) If a request is received to delete an IP
+                 * address which is also the source address of the IP packet
+                 * which contained the ASCONF chunk, the receiver MUST reject
+                 * this request. To reject the request the receiver MUST send
+                 * an Error Cause TLV set to the new error code 'Request to
+                 * Delete Source IP Address'
+                 */
+                if (sctp_cmp_addr_exact(sctp_source(asconf), &addr))
+                        return SCTP_ERROR_DEL_SRC_IP;
+
+                sctp_assoc_del_peer(asoc, &addr);
+                break;
+        case SCTP_PARAM_SET_PRIMARY:
+                peer = sctp_assoc_lookup_paddr(asoc, &addr);
+                if (!peer)
+                        return SCTP_ERROR_INV_PARAM;
+
+                sctp_assoc_set_primary(asoc, peer);
+                break;
+        default:
+                return SCTP_ERROR_INV_PARAM;
+                break;
+        }
+
+        return SCTP_ERROR_NO_ERROR;
+}
+
+/* Process an incoming ASCONF chunk with the next expected serial no. and 
+ * return an ASCONF_ACK chunk to be sent in response.
+ */
+struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc,
+                                       struct sctp_chunk *asconf)
+{
+        sctp_addiphdr_t         *hdr;
+        union sctp_addr_param   *addr_param;
+        sctp_addip_param_t      *asconf_param;
+        struct sctp_chunk       *asconf_ack;
+
+        __u16   err_code;
+        int     length = 0;
+        int     chunk_len = asconf->skb->len;
+        __u32   serial;
+        int     all_param_pass = 1;
+
+        hdr = (sctp_addiphdr_t *)asconf->skb->data;
+        serial = ntohl(hdr->serial);
+
+        /* Skip the addiphdr and store a pointer to address parameter.  */ 
+        length = sizeof(sctp_addiphdr_t);
+        addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
+        chunk_len -= length;
+
+        /* Skip the address parameter and store a pointer to the first
+         * asconf paramter.
+         */ 
+        length = ntohs(addr_param->v4.param_hdr.length);
+        asconf_param = (sctp_addip_param_t *)((void *)addr_param + length);
+        chunk_len -= length;
+
+        /* create an ASCONF_ACK chunk. 
+         * Based on the definitions of parameters, we know that the size of
+         * ASCONF_ACK parameters are less than or equal to the twice of ASCONF
+         * paramters.
+         */
+        asconf_ack = sctp_make_asconf_ack(asoc, serial, chunk_len * 2);
+        if (!asconf_ack)
+                goto done;
+
+        /* Process the TLVs contained within the ASCONF chunk. */
+        while (chunk_len > 0) {
+                err_code = sctp_process_asconf_param(asoc, asconf,
+                                                     asconf_param);
+                /* ADDIP 4.1 A7)
+                 * If an error response is received for a TLV parameter,
+                 * all TLVs with no response before the failed TLV are
+                 * considered successful if not reported.  All TLVs after
+                 * the failed response are considered unsuccessful unless
+                 * a specific success indication is present for the parameter.
+                 */
+                if (SCTP_ERROR_NO_ERROR != err_code)
+                        all_param_pass = 0;
+
+                if (!all_param_pass)
+                        sctp_add_asconf_response(asconf_ack,
+                                                 asconf_param->crr_id, err_code,
+                                                 asconf_param);
+
+                /* ADDIP 4.3 D11) When an endpoint receiving an ASCONF to add
+                 * an IP address sends an 'Out of Resource' in its response, it
+                 * MUST also fail any subsequent add or delete requests bundled
+                 * in the ASCONF. 
+                 */
+                if (SCTP_ERROR_RSRC_LOW == err_code)
+                        goto done;
+
+                /* Move to the next ASCONF param. */
+                length = ntohs(asconf_param->param_hdr.length);
+                asconf_param = (sctp_addip_param_t *)((void *)asconf_param +
+                                                      length);
+                chunk_len -= length;
+        }
+        
+done:
+        asoc->peer.addip_serial++;
+
+        /* If we are sending a new ASCONF_ACK hold a reference to it in assoc
+         * after freeing the reference to old asconf ack if any. 
+         */
+        if (asconf_ack) {
+                if (asoc->addip_last_asconf_ack)
+                        sctp_chunk_free(asoc->addip_last_asconf_ack);
+
+                sctp_chunk_hold(asconf_ack);
+                asoc->addip_last_asconf_ack = asconf_ack;
+        }
+
+        return asconf_ack;
+}
+
+/* Process a asconf parameter that is successfully acked. */
+static int sctp_asconf_param_success(struct sctp_association *asoc,
+                                     sctp_addip_param_t *asconf_param)
+{
+        struct sctp_af *af;
+        union sctp_addr addr;
+        struct sctp_bind_addr *bp = &asoc->base.bind_addr;
+        union sctp_addr_param *addr_param;
+        struct list_head *pos;
+        struct sctp_transport *transport;
+        int retval = 0;
+
+        addr_param = (union sctp_addr_param *)
+                        ((void *)asconf_param + sizeof(sctp_addip_param_t));
+
+        /* We have checked the packet before, so we do not check again. */
+        af = sctp_get_af_specific(param_type2af(addr_param->v4.param_hdr.type));
+        af->from_addr_param(&addr, addr_param, bp->port, 0);
+
+        switch (asconf_param->param_hdr.type) {
+        case SCTP_PARAM_ADD_IP:
+                sctp_local_bh_disable();
+                sctp_write_lock(&asoc->base.addr_lock);
+                retval = sctp_add_bind_addr(bp, &addr, GFP_ATOMIC);
+                sctp_write_unlock(&asoc->base.addr_lock);
+                sctp_local_bh_enable();
+                break;
+        case SCTP_PARAM_DEL_IP:
+                sctp_local_bh_disable();
+                sctp_write_lock(&asoc->base.addr_lock);
+                retval = sctp_del_bind_addr(bp, &addr);
+                sctp_write_unlock(&asoc->base.addr_lock);
+                sctp_local_bh_enable();
+                list_for_each(pos, &asoc->peer.transport_addr_list) {
+                        transport = list_entry(pos, struct sctp_transport,
+                                                 transports);
+                        sctp_transport_route(transport, NULL,
+                                             sctp_sk(asoc->base.sk));
+                }
+                break;
+        default:
+                break;
+        }
+
+        return retval;
+}
+
+/* Get the corresponding ASCONF response error code from the ASCONF_ACK chunk
+ * for the given asconf parameter.  If there is no response for this parameter,
+ * return the error code based on the third argument 'no_err'. 
+ * ADDIP 4.1
+ * A7) If an error response is received for a TLV parameter, all TLVs with no
+ * response before the failed TLV are considered successful if not reported.
+ * All TLVs after the failed response are considered unsuccessful unless a
+ * specific success indication is present for the parameter.
+ */
+static __u16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack,
+                                      sctp_addip_param_t *asconf_param,
+                                      int no_err)
+{
+        sctp_addip_param_t      *asconf_ack_param;
+        sctp_errhdr_t           *err_param;
+        int                     length;
+        int                     asconf_ack_len = asconf_ack->skb->len;
+        __u16                   err_code;
+
+        if (no_err)
+                err_code = SCTP_ERROR_NO_ERROR;
+        else
+                err_code = SCTP_ERROR_REQ_REFUSED;
+
+        /* Skip the addiphdr from the asconf_ack chunk and store a pointer to
+         * the first asconf_ack parameter.
+         */ 
+        length = sizeof(sctp_addiphdr_t);
+        asconf_ack_param = (sctp_addip_param_t *)(asconf_ack->skb->data +
+                                                  length);
+        asconf_ack_len -= length;
+
+        while (asconf_ack_len > 0) {
+                if (asconf_ack_param->crr_id == asconf_param->crr_id) {
+                        switch(asconf_ack_param->param_hdr.type) {
+                        case SCTP_PARAM_SUCCESS_REPORT:
+                                return SCTP_ERROR_NO_ERROR;
+                        case SCTP_PARAM_ERR_CAUSE:
+                                length = sizeof(sctp_addip_param_t);
+                                err_param = (sctp_errhdr_t *)
+                                           ((void *)asconf_ack_param + length);
+                                asconf_ack_len -= length;
+                                if (asconf_ack_len > 0)
+                                        return err_param->cause;
+                                else
+                                        return SCTP_ERROR_INV_PARAM;
+                                break;
+                        default:
+                                return SCTP_ERROR_INV_PARAM;
+                        }
+                }
+
+                length = ntohs(asconf_ack_param->param_hdr.length);
+                asconf_ack_param = (sctp_addip_param_t *)
+                                        ((void *)asconf_ack_param + length);
+                asconf_ack_len -= length;
+        }
+
+        return err_code;
+}
+
+/* Process an incoming ASCONF_ACK chunk against the cached last ASCONF chunk. */
+int sctp_process_asconf_ack(struct sctp_association *asoc,
+                            struct sctp_chunk *asconf_ack)
+{
+        struct sctp_chunk       *asconf = asoc->addip_last_asconf;
+        union sctp_addr_param   *addr_param;
+        sctp_addip_param_t      *asconf_param;
+        int     length = 0;
+        int     asconf_len = asconf->skb->len;
+        int     all_param_pass = 0;
+        int     no_err = 1;
+        int     retval = 0;
+        __u16   err_code = SCTP_ERROR_NO_ERROR;
+
+        /* Skip the chunkhdr and addiphdr from the last asconf sent and store
+         * a pointer to address parameter.
+         */ 
+        length = sizeof(sctp_addip_chunk_t);
+        addr_param = (union sctp_addr_param *)(asconf->skb->data + length);
+        asconf_len -= length;
+
+        /* Skip the address parameter in the last asconf sent and store a
+         * pointer to the first asconf paramter.
+         */ 
+        length = ntohs(addr_param->v4.param_hdr.length);
+        asconf_param = (sctp_addip_param_t *)((void *)addr_param + length);
+        asconf_len -= length;
+
+        /* ADDIP 4.1
+         * A8) If there is no response(s) to specific TLV parameter(s), and no
+         * failures are indicated, then all request(s) are considered
+         * successful.
+         */
+        if (asconf_ack->skb->len == sizeof(sctp_addiphdr_t))
+                all_param_pass = 1;
+
+        /* Process the TLVs contained in the last sent ASCONF chunk. */
+        while (asconf_len > 0) {
+                if (all_param_pass)
+                        err_code = SCTP_ERROR_NO_ERROR;
+                else {
+                        err_code = sctp_get_asconf_response(asconf_ack,
+                                                            asconf_param,
+                                                            no_err);
+                        if (no_err && (SCTP_ERROR_NO_ERROR != err_code))
+                                no_err = 0;
+                }
+
+                switch (err_code) {
+                case SCTP_ERROR_NO_ERROR:
+                        retval = sctp_asconf_param_success(asoc, asconf_param);
+                        break;
+
+                case SCTP_ERROR_RSRC_LOW:
+                        retval = 1;
+                        break;
+
+                case SCTP_ERROR_INV_PARAM:
+                        /* Disable sending this type of asconf parameter in
+                         * future.
+                         */     
+                        asoc->peer.addip_disabled_mask |=
+                                asconf_param->param_hdr.type;
+                        break;
+
+                case SCTP_ERROR_REQ_REFUSED:
+                case SCTP_ERROR_DEL_LAST_IP:
+                case SCTP_ERROR_DEL_SRC_IP:
+                default:
+                         break;
+                }
+
+                /* Skip the processed asconf parameter and move to the next
+                 * one.
+                 */ 
+                length = ntohs(asconf_param->param_hdr.length);
+                asconf_param = (sctp_addip_param_t *)((void *)asconf_param +
+                                                      length);
+                asconf_len -= length;
+        }
+
+        /* Free the cached last sent asconf chunk. */
+        sctp_chunk_free(asconf);
+        asoc->addip_last_asconf = NULL;
+
+        /* Send the next asconf chunk from the addip chunk queue. */
+        asconf = (struct sctp_chunk *)__skb_dequeue(&asoc->addip_chunks);
+        if (asconf) {
+                /* Hold the chunk until an ASCONF_ACK is received. */
+                sctp_chunk_hold(asconf);
+                if (sctp_primitive_ASCONF(asoc, asconf))
+                        sctp_chunk_free(asconf);
+                else
+                        asoc->addip_last_asconf = asconf;
+        }
+
+        return retval;
+}
+
+/* Make a FWD TSN chunk. */ 
+struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
+                                    __u32 new_cum_tsn, size_t nstreams,
+                                    struct sctp_fwdtsn_skip *skiplist)
+{
+        struct sctp_chunk *retval = NULL;
+        struct sctp_fwdtsn_chunk *ftsn_chunk;
+        struct sctp_fwdtsn_hdr ftsn_hdr; 
+        struct sctp_fwdtsn_skip skip;
+        size_t hint;
+        int i;
+
+        hint = (nstreams + 1) * sizeof(__u32);
+
+        /* Maybe set the T-bit if we have no association.  */
+        retval = sctp_make_chunk(asoc, SCTP_CID_FWD_TSN, 0, hint);
+
+        if (!retval)
+                return NULL;
+
+        ftsn_chunk = (struct sctp_fwdtsn_chunk *)retval->subh.fwdtsn_hdr;
+
+        ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
+        retval->subh.fwdtsn_hdr =
+                sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
+
+        for (i = 0; i < nstreams; i++) {
+                skip.stream = skiplist[i].stream;
+                skip.ssn = skiplist[i].ssn;
+                sctp_addto_chunk(retval, sizeof(skip), &skip);
+        }
+
+        return retval;
+}
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
new file mode 100644
index 000000000000..f65fa441952f
--- /dev/null
+++ b/net/sctp/sm_sideeffect.c
@@ -0,0 +1,1395 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions work with the state functions in sctp_sm_statefuns.c
+ * to implement that state operations.  These functions implement the
+ * steps which require modifying existing data structures.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@austin.ibm.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Dajiang Zhang         <dajiang.zhang@nokia.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/skbuff.h>
+#include <linux/types.h>
+#include <linux/socket.h>
+#include <linux/ip.h>
+#include <net/sock.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+static int sctp_cmd_interpreter(sctp_event_t event_type,
+                                sctp_subtype_t subtype,
+                                sctp_state_t state,
+                                struct sctp_endpoint *ep,
+                                struct sctp_association *asoc,
+                                void *event_arg,
+                                sctp_disposition_t status,
+                                sctp_cmd_seq_t *commands,
+                                int gfp);
+static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
+                             sctp_state_t state,
+                             struct sctp_endpoint *ep,
+                             struct sctp_association *asoc,
+                             void *event_arg,
+                             sctp_disposition_t status,
+                             sctp_cmd_seq_t *commands,
+                             int gfp);
+
+/********************************************************************
+ * Helper functions
+ ********************************************************************/
+
+/* A helper function for delayed processing of INET ECN CE bit. */
+static void sctp_do_ecn_ce_work(struct sctp_association *asoc, 
+                                __u32 lowest_tsn)
+{
+        /* Save the TSN away for comparison when we receive CWR */
+
+        asoc->last_ecne_tsn = lowest_tsn;
+        asoc->need_ecne = 1;
+}
+
+/* Helper function for delayed processing of SCTP ECNE chunk.  */
+/* RFC 2960 Appendix A
+ *
+ * RFC 2481 details a specific bit for a sender to send in
+ * the header of its next outbound TCP segment to indicate to
+ * its peer that it has reduced its congestion window.  This
+ * is termed the CWR bit.  For SCTP the same indication is made
+ * by including the CWR chunk.  This chunk contains one data
+ * element, i.e. the TSN number that was sent in the ECNE chunk.
+ * This element represents the lowest TSN number in the datagram
+ * that was originally marked with the CE bit.
+ */
+static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
+                                           __u32 lowest_tsn,
+                                           struct sctp_chunk *chunk)
+{
+        struct sctp_chunk *repl;
+
+        /* Our previously transmitted packet ran into some congestion
+         * so we should take action by reducing cwnd and ssthresh
+         * and then ACK our peer that we we've done so by
+         * sending a CWR.
+         */
+
+        /* First, try to determine if we want to actually lower
+         * our cwnd variables.  Only lower them if the ECNE looks more
+         * recent than the last response.
+         */
+        if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
+                struct sctp_transport *transport;
+
+                /* Find which transport's congestion variables
+                 * need to be adjusted.
+                 */
+                transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
+
+                /* Update the congestion variables. */
+                if (transport)
+                        sctp_transport_lower_cwnd(transport,
+                                                  SCTP_LOWER_CWND_ECNE);
+                asoc->last_cwr_tsn = lowest_tsn;
+        }
+
+        /* Always try to quiet the other end.  In case of lost CWR,
+         * resend last_cwr_tsn.
+         */
+        repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
+
+        /* If we run out of memory, it will look like a lost CWR.  We'll
+         * get back in sync eventually.
+         */
+        return repl;
+}
+
+/* Helper function to do delayed processing of ECN CWR chunk.  */
+static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
+                                 __u32 lowest_tsn)
+{
+        /* Turn off ECNE getting auto-prepended to every outgoing
+         * packet
+         */
+        asoc->need_ecne = 0;
+}
+
+/* Generate SACK if necessary.  We call this at the end of a packet.  */
+static int sctp_gen_sack(struct sctp_association *asoc, int force,
+                         sctp_cmd_seq_t *commands)
+{
+        __u32 ctsn, max_tsn_seen;
+        struct sctp_chunk *sack;
+        int error = 0;
+
+        if (force)
+                asoc->peer.sack_needed = 1;
+
+        ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
+        max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
+
+        /* From 12.2 Parameters necessary per association (i.e. the TCB):
+         *
+         * Ack State : This flag indicates if the next received packet
+         *           : is to be responded to with a SACK. ...
+         *           : When DATA chunks are out of order, SACK's
+         *           : are not delayed (see Section 6).
+         *
+         * [This is actually not mentioned in Section 6, but we
+         * implement it here anyway. --piggy]
+         */
+        if (max_tsn_seen != ctsn)
+                asoc->peer.sack_needed = 1;
+
+        /* From 6.2  Acknowledgement on Reception of DATA Chunks:
+         *
+         * Section 4.2 of [RFC2581] SHOULD be followed. Specifically,
+         * an acknowledgement SHOULD be generated for at least every
+         * second packet (not every second DATA chunk) received, and
+         * SHOULD be generated within 200 ms of the arrival of any
+         * unacknowledged DATA chunk. ...
+         */
+        if (!asoc->peer.sack_needed) {
+                /* We will need a SACK for the next packet.  */
+                asoc->peer.sack_needed = 1;
+                goto out;
+        } else {
+                if (asoc->a_rwnd > asoc->rwnd)
+                        asoc->a_rwnd = asoc->rwnd;
+                sack = sctp_make_sack(asoc);
+                if (!sack)
+                        goto nomem;
+
+                asoc->peer.sack_needed = 0;
+
+                error = sctp_outq_tail(&asoc->outqueue, sack);
+
+                /* Stop the SACK timer.  */
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
+        }
+out:
+        return error;
+nomem:
+        error = -ENOMEM;
+        return error;
+}
+
+/* When the T3-RTX timer expires, it calls this function to create the
+ * relevant state machine event.
+ */
+void sctp_generate_t3_rtx_event(unsigned long peer)
+{
+        int error;
+        struct sctp_transport *transport = (struct sctp_transport *) peer;
+        struct sctp_association *asoc = transport->asoc;
+
+        /* Check whether a task is in the sock.  */
+
+        sctp_bh_lock_sock(asoc->base.sk);
+        if (sock_owned_by_user(asoc->base.sk)) {
+                SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __FUNCTION__);
+
+                /* Try again later.  */
+                if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
+                        sctp_transport_hold(transport);
+                goto out_unlock;
+        }
+
+        /* Is this transport really dead and just waiting around for
+         * the timer to let go of the reference?
+         */
+        if (transport->dead)
+                goto out_unlock;
+
+        /* Run through the state machine.  */
+        error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
+                           SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
+                           asoc->state,
+                           asoc->ep, asoc,
+                           transport, GFP_ATOMIC);
+
+        if (error)
+                asoc->base.sk->sk_err = -error;
+
+out_unlock:
+        sctp_bh_unlock_sock(asoc->base.sk);
+        sctp_transport_put(transport);
+}
+
+/* This is a sa interface for producing timeout events.  It works
+ * for timeouts which use the association as their parameter.
+ */
+static void sctp_generate_timeout_event(struct sctp_association *asoc,
+                                        sctp_event_timeout_t timeout_type)
+{
+        int error = 0;
+
+        sctp_bh_lock_sock(asoc->base.sk);
+        if (sock_owned_by_user(asoc->base.sk)) {
+                SCTP_DEBUG_PRINTK("%s:Sock is busy: timer %d\n",
+                                  __FUNCTION__,
+                                  timeout_type);
+
+                /* Try again later.  */
+                if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
+                        sctp_association_hold(asoc);
+                goto out_unlock;
+        }
+
+        /* Is this association really dead and just waiting around for
+         * the timer to let go of the reference?
+         */
+        if (asoc->base.dead)
+                goto out_unlock;
+
+        /* Run through the state machine.  */
+        error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
+                           SCTP_ST_TIMEOUT(timeout_type),
+                           asoc->state, asoc->ep, asoc,
+                           (void *)timeout_type, GFP_ATOMIC);
+
+        if (error)
+                asoc->base.sk->sk_err = -error;
+
+out_unlock:
+        sctp_bh_unlock_sock(asoc->base.sk);
+        sctp_association_put(asoc);
+}
+
+static void sctp_generate_t1_cookie_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
+}
+
+static void sctp_generate_t1_init_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
+}
+
+static void sctp_generate_t2_shutdown_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
+}
+
+static void sctp_generate_t4_rto_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
+}
+
+static void sctp_generate_t5_shutdown_guard_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *)data;
+        sctp_generate_timeout_event(asoc,
+                                    SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
+
+} /* sctp_generate_t5_shutdown_guard_event() */
+
+static void sctp_generate_autoclose_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
+}
+
+/* Generate a heart beat event.  If the sock is busy, reschedule.   Make
+ * sure that the transport is still valid.
+ */
+void sctp_generate_heartbeat_event(unsigned long data)
+{
+        int error = 0;
+        struct sctp_transport *transport = (struct sctp_transport *) data;
+        struct sctp_association *asoc = transport->asoc;
+
+        sctp_bh_lock_sock(asoc->base.sk);
+        if (sock_owned_by_user(asoc->base.sk)) {
+                SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __FUNCTION__);
+
+                /* Try again later.  */
+                if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
+                        sctp_transport_hold(transport);
+                goto out_unlock;
+        }
+
+        /* Is this structure just waiting around for us to actually
+         * get destroyed?
+         */
+        if (transport->dead)
+                goto out_unlock;
+
+        error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
+                           SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
+                           asoc->state, asoc->ep, asoc,
+                           transport, GFP_ATOMIC);
+
+         if (error)
+                 asoc->base.sk->sk_err = -error;
+
+out_unlock:
+        sctp_bh_unlock_sock(asoc->base.sk);
+        sctp_transport_put(transport);
+}
+
+/* Inject a SACK Timeout event into the state machine.  */
+static void sctp_generate_sack_event(unsigned long data)
+{
+        struct sctp_association *asoc = (struct sctp_association *) data;
+        sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
+}
+
+sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
+        NULL,
+        sctp_generate_t1_cookie_event,
+        sctp_generate_t1_init_event,
+        sctp_generate_t2_shutdown_event,
+        NULL,
+        sctp_generate_t4_rto_event,
+        sctp_generate_t5_shutdown_guard_event,
+        sctp_generate_heartbeat_event,
+        sctp_generate_sack_event,
+        sctp_generate_autoclose_event,
+};
+
+
+/* RFC 2960 8.2 Path Failure Detection
+ *
+ * When its peer endpoint is multi-homed, an endpoint should keep a
+ * error counter for each of the destination transport addresses of the
+ * peer endpoint.
+ *
+ * Each time the T3-rtx timer expires on any address, or when a
+ * HEARTBEAT sent to an idle address is not acknowledged within a RTO,
+ * the error counter of that destination address will be incremented.
+ * When the value in the error counter exceeds the protocol parameter
+ * 'Path.Max.Retrans' of that destination address, the endpoint should
+ * mark the destination transport address as inactive, and a
+ * notification SHOULD be sent to the upper layer.
+ *
+ */
+static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
+                                         struct sctp_transport *transport)
+{
+        /* The check for association's overall error counter exceeding the
+         * threshold is done in the state function.
+         */
+        asoc->overall_error_count++;
+
+        if (transport->active &&
+            (transport->error_count++ >= transport->max_retrans)) {
+                SCTP_DEBUG_PRINTK("transport_strike: transport "
+                                  "IP:%d.%d.%d.%d failed.\n",
+                                  NIPQUAD(transport->ipaddr.v4.sin_addr));
+                sctp_assoc_control_transport(asoc, transport,
+                                             SCTP_TRANSPORT_DOWN,
+                                             SCTP_FAILED_THRESHOLD);
+        }
+
+        /* E2) For the destination address for which the timer
+         * expires, set RTO <- RTO * 2 ("back off the timer").  The
+         * maximum value discussed in rule C7 above (RTO.max) may be
+         * used to provide an upper bound to this doubling operation.
+         */
+        transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
+}
+
+/* Worker routine to handle INIT command failure.  */
+static void sctp_cmd_init_failed(sctp_cmd_seq_t *commands,
+                                 struct sctp_association *asoc,
+                                 unsigned error)
+{
+        struct sctp_ulpevent *event;
+
+        event = sctp_ulpevent_make_assoc_change(asoc,0, SCTP_CANT_STR_ASSOC,
+                                                (__u16)error, 0, 0,
+                                                GFP_ATOMIC);
+
+        if (event)
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(event));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+
+        /* SEND_FAILED sent later when cleaning up the association. */
+        asoc->outqueue.error = error;
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+}
+
+/* Worker routine to handle SCTP_CMD_ASSOC_FAILED.  */
+static void sctp_cmd_assoc_failed(sctp_cmd_seq_t *commands,
+                                  struct sctp_association *asoc,
+                                  sctp_event_t event_type,
+                                  sctp_subtype_t subtype,
+                                  struct sctp_chunk *chunk,
+                                  unsigned error)
+{
+        struct sctp_ulpevent *event;
+
+        /* Cancel any partial delivery in progress. */
+        sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
+
+        event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
+                                                (__u16)error, 0, 0,
+                                                GFP_ATOMIC);
+        if (event)
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(event));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+
+        /* Set sk_err to ECONNRESET on a 1-1 style socket. */
+        if (!sctp_style(asoc->base.sk, UDP))
+                asoc->base.sk->sk_err = ECONNRESET; 
+
+        /* SEND_FAILED sent later when cleaning up the association. */
+        asoc->outqueue.error = error;
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+}
+
+/* Process an init chunk (may be real INIT/INIT-ACK or an embedded INIT
+ * inside the cookie.  In reality, this is only used for INIT-ACK processing
+ * since all other cases use "temporary" associations and can do all
+ * their work in statefuns directly.
+ */
+static int sctp_cmd_process_init(sctp_cmd_seq_t *commands,
+                                 struct sctp_association *asoc,
+                                 struct sctp_chunk *chunk,
+                                 sctp_init_chunk_t *peer_init, int gfp)
+{
+        int error;
+
+        /* We only process the init as a sideeffect in a single
+         * case.   This is when we process the INIT-ACK.   If we
+         * fail during INIT processing (due to malloc problems),
+         * just return the error and stop processing the stack.
+         */
+        if (!sctp_process_init(asoc, chunk->chunk_hdr->type,
+                               sctp_source(chunk), peer_init, gfp))
+                error = -ENOMEM;
+        else
+                error = 0;
+
+        return error;
+}
+
+/* Helper function to break out starting up of heartbeat timers.  */
+static void sctp_cmd_hb_timers_start(sctp_cmd_seq_t *cmds,
+                                     struct sctp_association *asoc)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+
+        /* Start a heartbeat timer for each transport on the association.
+         * hold a reference on the transport to make sure none of
+         * the needed data structures go away.
+         */
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+
+                if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
+                        sctp_transport_hold(t);
+        }
+}
+
+static void sctp_cmd_hb_timers_stop(sctp_cmd_seq_t *cmds,
+                                    struct sctp_association *asoc)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+
+        /* Stop all heartbeat timers. */
+
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+                if (del_timer(&t->hb_timer))
+                        sctp_transport_put(t);
+        }
+}
+
+/* Helper function to stop any pending T3-RTX timers */
+static void sctp_cmd_t3_rtx_timers_stop(sctp_cmd_seq_t *cmds,
+                                        struct sctp_association *asoc)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+                if (timer_pending(&t->T3_rtx_timer) &&
+                    del_timer(&t->T3_rtx_timer)) {
+                        sctp_transport_put(t);
+                }
+        }
+}
+
+
+/* Helper function to update the heartbeat timer. */
+static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
+                                     struct sctp_association *asoc,
+                                     struct sctp_transport *t)
+{
+        /* Update the heartbeat timer.  */
+        if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
+                sctp_transport_hold(t);
+}
+
+/* Helper function to handle the reception of an HEARTBEAT ACK.  */
+static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
+                                  struct sctp_association *asoc,
+                                  struct sctp_transport *t,
+                                  struct sctp_chunk *chunk)
+{
+        sctp_sender_hb_info_t *hbinfo;
+
+        /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
+         * HEARTBEAT should clear the error counter of the destination
+         * transport address to which the HEARTBEAT was sent.
+         * The association's overall error count is also cleared.
+         */
+        t->error_count = 0;
+        t->asoc->overall_error_count = 0;
+
+        /* Mark the destination transport address as active if it is not so
+         * marked.
+         */
+        if (!t->active)
+                sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
+                                             SCTP_HEARTBEAT_SUCCESS);
+
+        /* The receiver of the HEARTBEAT ACK should also perform an
+         * RTT measurement for that destination transport address
+         * using the time value carried in the HEARTBEAT ACK chunk.
+         */
+        hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
+        sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
+}
+
+/* Helper function to do a transport reset at the expiry of the hearbeat
+ * timer.
+ */
+static void sctp_cmd_transport_reset(sctp_cmd_seq_t *cmds,
+                                     struct sctp_association *asoc,
+                                     struct sctp_transport *t)
+{
+        sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
+
+        /* Mark one strike against a transport.  */
+        sctp_do_8_2_transport_strike(asoc, t);
+}
+
+/* Helper function to process the process SACK command.  */
+static int sctp_cmd_process_sack(sctp_cmd_seq_t *cmds,
+                                 struct sctp_association *asoc,
+                                 struct sctp_sackhdr *sackh)
+{
+        int err;
+
+        if (sctp_outq_sack(&asoc->outqueue, sackh)) {
+                /* There are no more TSNs awaiting SACK.  */
+                err = sctp_do_sm(SCTP_EVENT_T_OTHER,
+                                 SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
+                                 asoc->state, asoc->ep, asoc, NULL,
+                                 GFP_ATOMIC);
+        } else {
+                /* Windows may have opened, so we need
+                 * to check if we have DATA to transmit
+                 */
+                err = sctp_outq_flush(&asoc->outqueue, 0);
+        }
+
+        return err;
+}
+
+/* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
+ * the transport for a shutdown chunk.
+ */
+static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds, 
+                              struct sctp_association *asoc,
+                              struct sctp_chunk *chunk)
+{
+        struct sctp_transport *t;
+
+        t = sctp_assoc_choose_shutdown_transport(asoc);
+        asoc->shutdown_last_sent_to = t;
+        asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
+        chunk->transport = t;
+}
+
+/* Helper function to change the state of an association. */
+static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds, 
+                               struct sctp_association *asoc,
+                               sctp_state_t state)
+{
+        struct sock *sk = asoc->base.sk;
+
+        asoc->state = state;
+
+        if (sctp_style(sk, TCP)) {
+                /* Change the sk->sk_state of a TCP-style socket that has 
+                 * sucessfully completed a connect() call.
+                 */
+                if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
+                        sk->sk_state = SCTP_SS_ESTABLISHED;
+
+                /* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
+                if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
+                    sctp_sstate(sk, ESTABLISHED))
+                        sk->sk_shutdown |= RCV_SHUTDOWN;
+        }
+
+        if (sctp_state(asoc, ESTABLISHED) ||
+            sctp_state(asoc, CLOSED) ||
+            sctp_state(asoc, SHUTDOWN_RECEIVED)) {
+                /* Wake up any processes waiting in the asoc's wait queue in
+                 * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
+                 */
+                if (waitqueue_active(&asoc->wait))
+                        wake_up_interruptible(&asoc->wait);
+
+                /* Wake up any processes waiting in the sk's sleep queue of
+                 * a TCP-style or UDP-style peeled-off socket in
+                 * sctp_wait_for_accept() or sctp_wait_for_packet().
+                 * For a UDP-style socket, the waiters are woken up by the
+                 * notifications.
+                 */
+                if (!sctp_style(sk, UDP))
+                        sk->sk_state_change(sk);
+        }
+}
+
+/* Helper function to delete an association. */
+static void sctp_cmd_delete_tcb(sctp_cmd_seq_t *cmds,
+                                struct sctp_association *asoc)
+{
+        struct sock *sk = asoc->base.sk;
+
+        /* If it is a non-temporary association belonging to a TCP-style
+         * listening socket that is not closed, do not free it so that accept() 
+         * can pick it up later.
+         */ 
+        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
+            (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
+                return;
+
+        sctp_unhash_established(asoc);
+        sctp_association_free(asoc);
+}
+
+/*
+ * ADDIP Section 4.1 ASCONF Chunk Procedures
+ * A4) Start a T-4 RTO timer, using the RTO value of the selected
+ * destination address (we use active path instead of primary path just
+ * because primary path may be inactive. 
+ */
+static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
+                                struct sctp_association *asoc,
+                                struct sctp_chunk *chunk)
+{
+        struct sctp_transport *t;
+
+        t = asoc->peer.active_path;
+        asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
+        chunk->transport = t;
+}
+
+/* Process an incoming Operation Error Chunk. */ 
+static void sctp_cmd_process_operr(sctp_cmd_seq_t *cmds,
+                                   struct sctp_association *asoc,
+                                   struct sctp_chunk *chunk)
+{
+        struct sctp_operr_chunk *operr_chunk;
+        struct sctp_errhdr *err_hdr;
+
+        operr_chunk = (struct sctp_operr_chunk *)chunk->chunk_hdr;
+        err_hdr = &operr_chunk->err_hdr;
+
+        switch (err_hdr->cause) {
+        case SCTP_ERROR_UNKNOWN_CHUNK:
+        {
+                struct sctp_chunkhdr *unk_chunk_hdr;
+
+                unk_chunk_hdr = (struct sctp_chunkhdr *)err_hdr->variable;
+                switch (unk_chunk_hdr->type) {
+                /* ADDIP 4.1 A9) If the peer responds to an ASCONF with an
+                 * ERROR chunk reporting that it did not recognized the ASCONF
+                 * chunk type, the sender of the ASCONF MUST NOT send any
+                 * further ASCONF chunks and MUST stop its T-4 timer.
+                 */
+                case SCTP_CID_ASCONF:
+                        asoc->peer.asconf_capable = 0;
+                        sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
+                                        SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+                        break;
+                default:
+                        break;
+                }
+                break;
+        }
+        default:
+                break;
+        }
+}
+
+/* Process variable FWDTSN chunk information. */
+static void sctp_cmd_process_fwdtsn(struct sctp_ulpq *ulpq, 
+                                    struct sctp_chunk *chunk)
+{
+        struct sctp_fwdtsn_skip *skip;
+        /* Walk through all the skipped SSNs */
+        sctp_walk_fwdtsn(skip, chunk) {
+                sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
+        }
+
+        return;
+}
+
+/* Helper function to remove the association non-primary peer 
+ * transports.
+ */ 
+static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
+{
+        struct sctp_transport *t;
+        struct list_head *pos;
+        struct list_head *temp;
+
+        list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
+                t = list_entry(pos, struct sctp_transport, transports);
+                if (!sctp_cmp_addr_exact(&t->ipaddr,
+                                         &asoc->peer.primary_addr)) {
+                        sctp_assoc_del_peer(asoc, &t->ipaddr);
+                }
+        }
+
+        return;
+}
+
+/* These three macros allow us to pull the debugging code out of the
+ * main flow of sctp_do_sm() to keep attention focused on the real
+ * functionality there.
+ */
+#define DEBUG_PRE \
+        SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \
+                          "ep %p, %s, %s, asoc %p[%s], %s\n", \
+                          ep, sctp_evttype_tbl[event_type], \
+                          (*debug_fn)(subtype), asoc, \
+                          sctp_state_tbl[state], state_fn->name)
+
+#define DEBUG_POST \
+        SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \
+                          "asoc %p, status: %s\n", \
+                          asoc, sctp_status_tbl[status])
+
+#define DEBUG_POST_SFX \
+        SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \
+                          error, asoc, \
+                          sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
+                          sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED])
+
+/*
+ * This is the master state machine processing function.
+ *
+ * If you want to understand all of lksctp, this is a
+ * good place to start.
+ */
+int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
+               sctp_state_t state,
+               struct sctp_endpoint *ep,
+               struct sctp_association *asoc,
+               void *event_arg,
+               int gfp)
+{
+        sctp_cmd_seq_t commands;
+        const sctp_sm_table_entry_t *state_fn;
+        sctp_disposition_t status;
+        int error = 0;
+        typedef const char *(printfn_t)(sctp_subtype_t);
+
+        static printfn_t *table[] = {
+                NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
+        };
+        printfn_t *debug_fn  __attribute__ ((unused)) = table[event_type];
+
+        /* Look up the state function, run it, and then process the
+         * side effects.  These three steps are the heart of lksctp.
+         */
+        state_fn = sctp_sm_lookup_event(event_type, state, subtype);
+
+        sctp_init_cmd_seq(&commands);
+
+        DEBUG_PRE;
+        status = (*state_fn->fn)(ep, asoc, subtype, event_arg, &commands);
+        DEBUG_POST;
+
+        error = sctp_side_effects(event_type, subtype, state,
+                                  ep, asoc, event_arg, status, 
+                                  &commands, gfp);
+        DEBUG_POST_SFX;
+
+        return error;
+}
+
+#undef DEBUG_PRE
+#undef DEBUG_POST
+
+/*****************************************************************
+ * This the master state function side effect processing function.
+ *****************************************************************/
+static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
+                             sctp_state_t state,
+                             struct sctp_endpoint *ep,
+                             struct sctp_association *asoc,
+                             void *event_arg,
+                             sctp_disposition_t status,
+                             sctp_cmd_seq_t *commands,
+                             int gfp)
+{
+        int error;
+
+        /* FIXME - Most of the dispositions left today would be categorized
+         * as "exceptional" dispositions.  For those dispositions, it
+         * may not be proper to run through any of the commands at all.
+         * For example, the command interpreter might be run only with
+         * disposition SCTP_DISPOSITION_CONSUME.
+         */
+        if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
+                                               ep, asoc,
+                                               event_arg, status,
+                                               commands, gfp)))
+                goto bail;
+
+        switch (status) {
+        case SCTP_DISPOSITION_DISCARD:
+                SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, "
+                                  "event_type %d, event_id %d\n",
+                                  state, event_type, subtype.chunk);
+                break;
+
+        case SCTP_DISPOSITION_NOMEM:
+                /* We ran out of memory, so we need to discard this
+                 * packet.
+                 */
+                /* BUG--we should now recover some memory, probably by
+                 * reneging...
+                 */
+                error = -ENOMEM;
+                break;
+
+        case SCTP_DISPOSITION_DELETE_TCB:
+                /* This should now be a command. */
+                break;
+
+        case SCTP_DISPOSITION_CONSUME:
+        case SCTP_DISPOSITION_ABORT:
+                /*
+                 * We should no longer have much work to do here as the
+                 * real work has been done as explicit commands above.
+                 */
+                break;
+
+        case SCTP_DISPOSITION_VIOLATION:
+                printk(KERN_ERR "sctp protocol violation state %d "
+                       "chunkid %d\n", state, subtype.chunk);
+                break;
+
+        case SCTP_DISPOSITION_NOT_IMPL:
+                printk(KERN_WARNING "sctp unimplemented feature in state %d, "
+                       "event_type %d, event_id %d\n",
+                       state, event_type, subtype.chunk);
+                break;
+
+        case SCTP_DISPOSITION_BUG:
+                printk(KERN_ERR "sctp bug in state %d, "
+                       "event_type %d, event_id %d\n",
+                       state, event_type, subtype.chunk);
+                BUG();
+                break;
+
+        default:
+                printk(KERN_ERR "sctp impossible disposition %d "
+                       "in state %d, event_type %d, event_id %d\n",
+                       status, state, event_type, subtype.chunk);
+                BUG();
+                break;
+        };
+
+bail:
+        return error;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* This is the side-effect interpreter.  */
+static int sctp_cmd_interpreter(sctp_event_t event_type,
+                                sctp_subtype_t subtype,
+                                sctp_state_t state,
+                                struct sctp_endpoint *ep,
+                                struct sctp_association *asoc,
+                                void *event_arg,
+                                sctp_disposition_t status,
+                                sctp_cmd_seq_t *commands,
+                                int gfp)
+{
+        int error = 0;
+        int force;
+        sctp_cmd_t *cmd;
+        struct sctp_chunk *new_obj;
+        struct sctp_chunk *chunk = NULL;
+        struct sctp_packet *packet;
+        struct list_head *pos;
+        struct timer_list *timer;
+        unsigned long timeout;
+        struct sctp_transport *t;
+        struct sctp_sackhdr sackh;
+        int local_cork = 0;
+
+        if (SCTP_EVENT_T_TIMEOUT != event_type)
+                chunk = (struct sctp_chunk *) event_arg;
+
+        /* Note:  This whole file is a huge candidate for rework.
+         * For example, each command could either have its own handler, so
+         * the loop would look like:
+         *     while (cmds)
+         *         cmd->handle(x, y, z)
+         * --jgrimm
+         */
+        while (NULL != (cmd = sctp_next_cmd(commands))) {
+                switch (cmd->verb) {
+                case SCTP_CMD_NOP:
+                        /* Do nothing. */
+                        break;
+
+                case SCTP_CMD_NEW_ASOC:
+                        /* Register a new association.  */
+                        if (local_cork) {
+                                sctp_outq_uncork(&asoc->outqueue); 
+                                local_cork = 0;
+                        }
+                        asoc = cmd->obj.ptr;
+                        /* Register with the endpoint.  */
+                        sctp_endpoint_add_asoc(ep, asoc);
+                        sctp_hash_established(asoc);
+                        break;
+
+                case SCTP_CMD_UPDATE_ASSOC:
+                       sctp_assoc_update(asoc, cmd->obj.ptr);
+                       break;
+
+                case SCTP_CMD_PURGE_OUTQUEUE:
+                       sctp_outq_teardown(&asoc->outqueue);
+                       break;
+
+                case SCTP_CMD_DELETE_TCB:                       
+                        if (local_cork) {
+                                sctp_outq_uncork(&asoc->outqueue);
+                                local_cork = 0;
+                        }
+                        /* Delete the current association.  */
+                        sctp_cmd_delete_tcb(commands, asoc);
+                        asoc = NULL;
+                        break;
+
+                case SCTP_CMD_NEW_STATE:
+                        /* Enter a new state.  */
+                        sctp_cmd_new_state(commands, asoc, cmd->obj.state);
+                        break;
+
+                case SCTP_CMD_REPORT_TSN:
+                        /* Record the arrival of a TSN.  */
+                        sctp_tsnmap_mark(&asoc->peer.tsn_map, cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_REPORT_FWDTSN:
+                        /* Move the Cumulattive TSN Ack ahead. */
+                        sctp_tsnmap_skip(&asoc->peer.tsn_map, cmd->obj.u32);
+
+                        /* Abort any in progress partial delivery. */
+                        sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
+                        break;
+
+                case SCTP_CMD_PROCESS_FWDTSN:
+                        sctp_cmd_process_fwdtsn(&asoc->ulpq, cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_GEN_SACK:
+                        /* Generate a Selective ACK.
+                         * The argument tells us whether to just count
+                         * the packet and MAYBE generate a SACK, or
+                         * force a SACK out.
+                         */
+                        force = cmd->obj.i32;
+                        error = sctp_gen_sack(asoc, force, commands);
+                        break;
+
+                case SCTP_CMD_PROCESS_SACK:
+                        /* Process an inbound SACK.  */
+                        error = sctp_cmd_process_sack(commands, asoc,
+                                                      cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_GEN_INIT_ACK:
+                        /* Generate an INIT ACK chunk.  */
+                        new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
+                                                     0);
+                        if (!new_obj)
+                                goto nomem;
+
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(new_obj));
+                        break;
+
+                case SCTP_CMD_PEER_INIT:
+                        /* Process a unified INIT from the peer.
+                         * Note: Only used during INIT-ACK processing.  If
+                         * there is an error just return to the outter
+                         * layer which will bail.
+                         */
+                        error = sctp_cmd_process_init(commands, asoc, chunk,
+                                                      cmd->obj.ptr, gfp);
+                        break;
+
+                case SCTP_CMD_GEN_COOKIE_ECHO:
+                        /* Generate a COOKIE ECHO chunk.  */
+                        new_obj = sctp_make_cookie_echo(asoc, chunk);
+                        if (!new_obj) {
+                                if (cmd->obj.ptr)
+                                        sctp_chunk_free(cmd->obj.ptr);
+                                goto nomem;
+                        }
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(new_obj));
+
+                        /* If there is an ERROR chunk to be sent along with
+                         * the COOKIE_ECHO, send it, too.
+                         */
+                        if (cmd->obj.ptr)
+                                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                                SCTP_CHUNK(cmd->obj.ptr));
+
+                        /* FIXME - Eventually come up with a cleaner way to
+                         * enabling COOKIE-ECHO + DATA bundling during 
+                         * multihoming stale cookie scenarios, the following 
+                         * command plays with asoc->peer.retran_path to 
+                         * avoid the problem of sending the COOKIE-ECHO and 
+                         * DATA in different paths, which could result 
+                         * in the association being ABORTed if the DATA chunk 
+                         * is processed first by the server.  Checking the
+                         * init error counter simply causes this command
+                         * to be executed only during failed attempts of
+                         * association establishment.
+                         */
+                        if ((asoc->peer.retran_path != 
+                             asoc->peer.primary_path) && 
+                            (asoc->counters[SCTP_COUNTER_INIT_ERROR] > 0)) {
+                                sctp_add_cmd_sf(commands, 
+                                                SCTP_CMD_FORCE_PRIM_RETRAN,
+                                                SCTP_NULL());
+                        }
+
+                        break;
+
+                case SCTP_CMD_GEN_SHUTDOWN:
+                        /* Generate SHUTDOWN when in SHUTDOWN_SENT state.
+                         * Reset error counts.
+                         */
+                        asoc->overall_error_count = 0;
+
+                        /* Generate a SHUTDOWN chunk.  */
+                        new_obj = sctp_make_shutdown(asoc, chunk);
+                        if (!new_obj)
+                                goto nomem;
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(new_obj));
+                        break;
+
+                case SCTP_CMD_CHUNK_ULP:
+                        /* Send a chunk to the sockets layer.  */
+                        SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
+                                          "chunk_up:", cmd->obj.ptr,
+                                          "ulpq:", &asoc->ulpq);
+                        sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.ptr,
+                                            GFP_ATOMIC);
+                        break;
+
+                case SCTP_CMD_EVENT_ULP:
+                        /* Send a notification to the sockets layer.  */
+                        SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
+                                          "event_up:",cmd->obj.ptr,
+                                          "ulpq:",&asoc->ulpq);
+                        sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_REPLY:
+                        /* If an caller has not already corked, do cork. */
+                        if (!asoc->outqueue.cork) {
+                                sctp_outq_cork(&asoc->outqueue);
+                                local_cork = 1;
+                        }
+                        /* Send a chunk to our peer.  */
+                        error = sctp_outq_tail(&asoc->outqueue, cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_SEND_PKT:
+                        /* Send a full packet to our peer.  */
+                        packet = cmd->obj.ptr;
+                        sctp_packet_transmit(packet);
+                        sctp_ootb_pkt_free(packet);
+                        break;
+
+                case SCTP_CMD_RETRAN:
+                        /* Mark a transport for retransmission.  */
+                        sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
+                                        SCTP_RTXR_T3_RTX);
+                        break;
+
+                case SCTP_CMD_TRANSMIT:
+                        /* Kick start transmission. */
+                        error = sctp_outq_uncork(&asoc->outqueue);
+                        local_cork = 0;
+                        break;
+
+                case SCTP_CMD_ECN_CE:
+                        /* Do delayed CE processing.   */
+                        sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_ECN_ECNE:
+                        /* Do delayed ECNE processing. */
+                        new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
+                                                        chunk);
+                        if (new_obj)
+                                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                                SCTP_CHUNK(new_obj));
+                        break;
+
+                case SCTP_CMD_ECN_CWR:
+                        /* Do delayed CWR processing.  */
+                        sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_SETUP_T2:
+                        sctp_cmd_setup_t2(commands, asoc, cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_TIMER_START:
+                        timer = &asoc->timers[cmd->obj.to];
+                        timeout = asoc->timeouts[cmd->obj.to];
+                        if (!timeout)
+                                BUG();
+
+                        timer->expires = jiffies + timeout;
+                        sctp_association_hold(asoc);
+                        add_timer(timer);
+                        break;
+
+                case SCTP_CMD_TIMER_RESTART:
+                        timer = &asoc->timers[cmd->obj.to];
+                        timeout = asoc->timeouts[cmd->obj.to];
+                        if (!mod_timer(timer, jiffies + timeout))
+                                sctp_association_hold(asoc);
+                        break;
+
+                case SCTP_CMD_TIMER_STOP:
+                        timer = &asoc->timers[cmd->obj.to];
+                        if (timer_pending(timer) && del_timer(timer))
+                                sctp_association_put(asoc);
+                        break;
+
+                case SCTP_CMD_INIT_RESTART:
+                        /* Do the needed accounting and updates
+                         * associated with restarting an initialization
+                         * timer.
+                         */
+                        asoc->counters[SCTP_COUNTER_INIT_ERROR]++;
+                        asoc->timeouts[cmd->obj.to] *= 2;
+                        if (asoc->timeouts[cmd->obj.to] >
+                            asoc->max_init_timeo) {
+                                asoc->timeouts[cmd->obj.to] =
+                                        asoc->max_init_timeo;
+                        }
+
+                        /* If we've sent any data bundled with
+                         * COOKIE-ECHO we need to resend.
+                         */
+                        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                                t = list_entry(pos, struct sctp_transport,
+                                               transports);
+                                sctp_retransmit_mark(&asoc->outqueue, t, 0);
+                        }
+
+                        sctp_add_cmd_sf(commands,
+                                        SCTP_CMD_TIMER_RESTART,
+                                        SCTP_TO(cmd->obj.to));
+                        break;
+
+                case SCTP_CMD_INIT_FAILED:
+                        sctp_cmd_init_failed(commands, asoc, cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_ASSOC_FAILED:
+                        sctp_cmd_assoc_failed(commands, asoc, event_type,
+                                              subtype, chunk, cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_COUNTER_INC:
+                        asoc->counters[cmd->obj.counter]++;
+                        break;
+
+                case SCTP_CMD_COUNTER_RESET:
+                        asoc->counters[cmd->obj.counter] = 0;
+                        break;
+
+                case SCTP_CMD_REPORT_DUP:
+                        sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
+                                             cmd->obj.u32);
+                        break;
+
+                case SCTP_CMD_REPORT_BAD_TAG:
+                        SCTP_DEBUG_PRINTK("vtag mismatch!\n");
+                        break;
+
+                case SCTP_CMD_STRIKE:
+                        /* Mark one strike against a transport.  */
+                        sctp_do_8_2_transport_strike(asoc, cmd->obj.transport);
+                        break;
+
+                case SCTP_CMD_TRANSPORT_RESET:
+                        t = cmd->obj.transport;
+                        sctp_cmd_transport_reset(commands, asoc, t);
+                        break;
+
+                case SCTP_CMD_TRANSPORT_ON:
+                        t = cmd->obj.transport;
+                        sctp_cmd_transport_on(commands, asoc, t, chunk);
+                        break;
+
+                case SCTP_CMD_HB_TIMERS_START:
+                        sctp_cmd_hb_timers_start(commands, asoc);
+                        break;
+
+                case SCTP_CMD_HB_TIMER_UPDATE:
+                        t = cmd->obj.transport;
+                        sctp_cmd_hb_timer_update(commands, asoc, t);
+                        break;
+
+                case SCTP_CMD_HB_TIMERS_STOP:
+                        sctp_cmd_hb_timers_stop(commands, asoc);
+                        break;
+
+                case SCTP_CMD_REPORT_ERROR:
+                        error = cmd->obj.error;
+                        break;
+
+                case SCTP_CMD_PROCESS_CTSN:
+                        /* Dummy up a SACK for processing. */
+                        sackh.cum_tsn_ack = cmd->obj.u32;
+                        sackh.a_rwnd = 0;
+                        sackh.num_gap_ack_blocks = 0;
+                        sackh.num_dup_tsns = 0;
+                        sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
+                                        SCTP_SACKH(&sackh));
+                        break;
+
+                case SCTP_CMD_DISCARD_PACKET:
+                        /* We need to discard the whole packet.  */
+                        chunk->pdiscard = 1;
+                        break;
+
+                case SCTP_CMD_RTO_PENDING:
+                        t = cmd->obj.transport;
+                        t->rto_pending = 1;
+                        break;
+
+                case SCTP_CMD_PART_DELIVER:
+                        sctp_ulpq_partial_delivery(&asoc->ulpq, cmd->obj.ptr,
+                                                   GFP_ATOMIC);
+                        break;
+
+                case SCTP_CMD_RENEGE:
+                        sctp_ulpq_renege(&asoc->ulpq, cmd->obj.ptr,
+                                         GFP_ATOMIC);
+                        break;
+
+                case SCTP_CMD_SETUP_T4:
+                        sctp_cmd_setup_t4(commands, asoc, cmd->obj.ptr);
+                        break;
+
+                case SCTP_CMD_PROCESS_OPERR:
+                        sctp_cmd_process_operr(commands, asoc, chunk);
+                        break;
+                case SCTP_CMD_CLEAR_INIT_TAG:
+                        asoc->peer.i.init_tag = 0;
+                        break;
+                case SCTP_CMD_DEL_NON_PRIMARY:
+                        sctp_cmd_del_non_primary(asoc);
+                        break;
+                case SCTP_CMD_T3_RTX_TIMERS_STOP:
+                        sctp_cmd_t3_rtx_timers_stop(commands, asoc);
+                        break;
+                case SCTP_CMD_FORCE_PRIM_RETRAN:
+                        t = asoc->peer.retran_path;
+                        asoc->peer.retran_path = asoc->peer.primary_path;
+                        error = sctp_outq_uncork(&asoc->outqueue);
+                        local_cork = 0;
+                        asoc->peer.retran_path = t;
+                        break;
+                default:
+                        printk(KERN_WARNING "Impossible command: %u, %p\n",
+                               cmd->verb, cmd->obj.ptr);
+                        break;
+                };
+                if (error)
+                        break;
+        }
+
+out:
+        if (local_cork)
+                sctp_outq_uncork(&asoc->outqueue);
+        return error;
+nomem:
+        error = -ENOMEM;
+        goto out;
+}
+
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
new file mode 100644
index 000000000000..278c56a2d076
--- /dev/null
+++ b/net/sctp/sm_statefuns.c
@@ -0,0 +1,5238 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2002 Intel Corp.
+ * Copyright (c) 2002      Nokia Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * This is part of the SCTP Linux Kernel Reference Implementation.
+ *
+ * These are the state functions for the state machine.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Mathew Kotowsky       <kotowsky@sctp.org>
+ *    Sridhar Samudrala     <samudrala@us.ibm.com>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Dajiang Zhang         <dajiang.zhang@nokia.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Ryan Layer            <rmlayer@us.ibm.com>
+ *    Kevin Gao             <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/net.h>
+#include <linux/inet.h>
+#include <net/sock.h>
+#include <net/inet_ecn.h>
+#include <linux/skbuff.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+#include <net/sctp/structs.h>
+
+static struct sctp_packet *sctp_abort_pkt_new(const struct sctp_endpoint *ep,
+                                  const struct sctp_association *asoc,
+                                  struct sctp_chunk *chunk,
+                                  const void *payload,
+                                  size_t paylen);
+static int sctp_eat_data(const struct sctp_association *asoc,
+                         struct sctp_chunk *chunk,
+                         sctp_cmd_seq_t *commands);
+static struct sctp_packet *sctp_ootb_pkt_new(const struct sctp_association *asoc,
+                                             const struct sctp_chunk *chunk);
+static void sctp_send_stale_cookie_err(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const struct sctp_chunk *chunk,
+                                       sctp_cmd_seq_t *commands,
+                                       struct sctp_chunk *err_chunk);
+static sctp_disposition_t sctp_sf_do_5_2_6_stale(const struct sctp_endpoint *ep,
+                                                 const struct sctp_association *asoc,
+                                                 const sctp_subtype_t type,
+                                                 void *arg,
+                                                 sctp_cmd_seq_t *commands);
+static sctp_disposition_t sctp_sf_shut_8_4_5(const struct sctp_endpoint *ep,
+                                             const struct sctp_association *asoc,
+                                             const sctp_subtype_t type,
+                                             void *arg,
+                                             sctp_cmd_seq_t *commands);
+static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk);
+
+
+/* Small helper function that checks if the chunk length
+ * is of the appropriate length.  The 'required_length' argument
+ * is set to be the size of a specific chunk we are testing.
+ * Return Values:  1 = Valid length
+ *                 0 = Invalid length
+ *
+ */
+static inline int
+sctp_chunk_length_valid(struct sctp_chunk *chunk,
+                           __u16 required_length)
+{
+        __u16 chunk_length = ntohs(chunk->chunk_hdr->length);
+
+        if (unlikely(chunk_length < required_length))
+                return 0;
+
+        return 1;
+}
+
+/**********************************************************
+ * These are the state functions for handling chunk events.
+ **********************************************************/
+
+/*
+ * Process the final SHUTDOWN COMPLETE.
+ *
+ * Section: 4 (C) (diagram), 9.2
+ * Upon reception of the SHUTDOWN COMPLETE chunk the endpoint will verify
+ * that it is in SHUTDOWN-ACK-SENT state, if it is not the chunk should be
+ * discarded. If the endpoint is in the SHUTDOWN-ACK-SENT state the endpoint
+ * should stop the T2-shutdown timer and remove all knowledge of the
+ * association (and thus the association enters the CLOSED state).
+ *
+ * Verification Tag: 8.5.1(C)
+ * C) Rules for packet carrying SHUTDOWN COMPLETE:
+ * ...
+ * - The receiver of a SHUTDOWN COMPLETE shall accept the packet if the
+ *   Verification Tag field of the packet matches its own tag OR it is
+ *   set to its peer's tag and the T bit is set in the Chunk Flags.
+ *   Otherwise, the receiver MUST silently discard the packet and take
+ *   no further action. An endpoint MUST ignore the SHUTDOWN COMPLETE if
+ *   it is not in the SHUTDOWN-ACK-SENT state.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_4_C(const struct sctp_endpoint *ep,
+                                  const struct sctp_association *asoc,
+                                  const sctp_subtype_t type,
+                                  void *arg,
+                                  sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_ulpevent *ev;
+
+        /* RFC 2960 6.10 Bundling
+         *
+         * An endpoint MUST NOT bundle INIT, INIT ACK or
+         * SHUTDOWN COMPLETE with any other chunks.
+         */
+        if (!chunk->singleton)
+                return SCTP_DISPOSITION_VIOLATION;
+
+        if (!sctp_vtag_verify_either(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* RFC 2960 10.2 SCTP-to-ULP
+         *
+         * H) SHUTDOWN COMPLETE notification
+         *
+         * When SCTP completes the shutdown procedures (section 9.2) this
+         * notification is passed to the upper layer.
+         */
+        ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_SHUTDOWN_COMP,
+                                             0, 0, 0, GFP_ATOMIC);
+        if (!ev)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+        /* Upon reception of the SHUTDOWN COMPLETE chunk the endpoint
+         * will verify that it is in SHUTDOWN-ACK-SENT state, if it is
+         * not the chunk should be discarded. If the endpoint is in
+         * the SHUTDOWN-ACK-SENT state the endpoint should stop the
+         * T2-shutdown timer and remove all knowledge of the
+         * association (and thus the association enters the CLOSED
+         * state).
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+
+        SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
+        SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+
+        return SCTP_DISPOSITION_DELETE_TCB;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Respond to a normal INIT chunk.
+ * We are the side that is being asked for an association.
+ *
+ * Section: 5.1 Normal Establishment of an Association, B
+ * B) "Z" shall respond immediately with an INIT ACK chunk.  The
+ *    destination IP address of the INIT ACK MUST be set to the source
+ *    IP address of the INIT to which this INIT ACK is responding.  In
+ *    the response, besides filling in other parameters, "Z" must set the
+ *    Verification Tag field to Tag_A, and also provide its own
+ *    Verification Tag (Tag_Z) in the Initiate Tag field.
+ *
+ * Verification Tag: Must be 0. 
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_1B_init(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *repl;
+        struct sctp_association *new_asoc;
+        struct sctp_chunk *err_chunk;
+        struct sctp_packet *packet;
+        sctp_unrecognized_param_t *unk_param;
+        struct sock *sk;
+        int len;
+
+        /* 6.10 Bundling
+         * An endpoint MUST NOT bundle INIT, INIT ACK or
+         * SHUTDOWN COMPLETE with any other chunks.
+         * 
+         * IG Section 2.11.2
+         * Furthermore, we require that the receiver of an INIT chunk MUST
+         * enforce these rules by silently discarding an arriving packet
+         * with an INIT chunk that is bundled with other chunks.
+         */
+        if (!chunk->singleton)
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* If the packet is an OOTB packet which is temporarily on the
+         * control endpoint, respond with an ABORT.
+         */
+        if (ep == sctp_sk((sctp_get_ctl_sock()))->ep)
+                return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
+
+        sk = ep->base.sk;
+        /* If the endpoint is not listening or if the number of associations
+         * on the TCP-style socket exceed the max backlog, respond with an
+         * ABORT.
+         */
+        if (!sctp_sstate(sk, LISTENING) ||
+            (sctp_style(sk, TCP) &&
+             sk_acceptq_is_full(sk)))
+                return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
+
+        /* 3.1 A packet containing an INIT chunk MUST have a zero Verification
+         * Tag. 
+         */
+        if (chunk->sctp_hdr->vtag != 0)
+                return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
+
+        /* Make sure that the INIT chunk has a valid length.
+         * Normally, this would cause an ABORT with a Protocol Violation
+         * error, but since we don't have an association, we'll
+         * just discard the packet.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_init_chunk_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Verify the INIT chunk before processing it. */
+        err_chunk = NULL;
+        if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
+                              (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
+                              &err_chunk)) {
+                /* This chunk contains fatal error. It is to be discarded.
+                 * Send an ABORT, with causes if there is any.
+                 */
+                if (err_chunk) {
+                        packet = sctp_abort_pkt_new(ep, asoc, arg,
+                                        (__u8 *)(err_chunk->chunk_hdr) +
+                                        sizeof(sctp_chunkhdr_t),
+                                        ntohs(err_chunk->chunk_hdr->length) -
+                                        sizeof(sctp_chunkhdr_t));
+
+                        sctp_chunk_free(err_chunk);
+
+                        if (packet) {
+                                sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                                SCTP_PACKET(packet));
+                                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+                                return SCTP_DISPOSITION_CONSUME;
+                        } else {
+                                return SCTP_DISPOSITION_NOMEM;
+                        }
+                } else {
+                        return sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
+                                                    commands);
+                }
+        }
+
+        /* Grab the INIT header.  */
+        chunk->subh.init_hdr = (sctp_inithdr_t *)chunk->skb->data;
+
+        /* Tag the variable length parameters.  */
+        chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
+
+        new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);
+        if (!new_asoc)
+                goto nomem;
+
+        /* The call, sctp_process_init(), can fail on memory allocation.  */
+        if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
+                               sctp_source(chunk),
+                               (sctp_init_chunk_t *)chunk->chunk_hdr,
+                               GFP_ATOMIC))
+                goto nomem_init;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
+
+        /* B) "Z" shall respond immediately with an INIT ACK chunk.  */
+
+        /* If there are errors need to be reported for unknown parameters,
+         * make sure to reserve enough room in the INIT ACK for them.
+         */
+        len = 0;
+        if (err_chunk)
+                len = ntohs(err_chunk->chunk_hdr->length) -
+                        sizeof(sctp_chunkhdr_t);
+
+        if (sctp_assoc_set_bind_addr_from_ep(new_asoc, GFP_ATOMIC) < 0)
+                goto nomem_ack;
+
+        repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);
+        if (!repl)
+                goto nomem_ack;
+
+        /* If there are errors need to be reported for unknown parameters,
+         * include them in the outgoing INIT ACK as "Unrecognized parameter"
+         * parameter.
+         */
+        if (err_chunk) {
+                /* Get the "Unrecognized parameter" parameter(s) out of the
+                 * ERROR chunk generated by sctp_verify_init(). Since the
+                 * error cause code for "unknown parameter" and the
+                 * "Unrecognized parameter" type is the same, we can
+                 * construct the parameters in INIT ACK by copying the
+                 * ERROR causes over.
+                 */
+                unk_param = (sctp_unrecognized_param_t *)
+                            ((__u8 *)(err_chunk->chunk_hdr) +
+                            sizeof(sctp_chunkhdr_t));
+                /* Replace the cause code with the "Unrecognized parameter"
+                 * parameter type.
+                 */
+                sctp_addto_chunk(repl, len, unk_param);
+                sctp_chunk_free(err_chunk);
+        }
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+
+        /*
+         * Note:  After sending out INIT ACK with the State Cookie parameter,
+         * "Z" MUST NOT allocate any resources, nor keep any states for the
+         * new association.  Otherwise, "Z" will be vulnerable to resource
+         * attacks.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+
+        return SCTP_DISPOSITION_DELETE_TCB;
+
+nomem_ack:
+        if (err_chunk)
+                sctp_chunk_free(err_chunk);
+nomem_init:
+        sctp_association_free(new_asoc);
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Respond to a normal INIT ACK chunk.
+ * We are the side that is initiating the association.
+ *
+ * Section: 5.1 Normal Establishment of an Association, C
+ * C) Upon reception of the INIT ACK from "Z", "A" shall stop the T1-init
+ *    timer and leave COOKIE-WAIT state. "A" shall then send the State
+ *    Cookie received in the INIT ACK chunk in a COOKIE ECHO chunk, start
+ *    the T1-cookie timer, and enter the COOKIE-ECHOED state.
+ *
+ *    Note: The COOKIE ECHO chunk can be bundled with any pending outbound
+ *    DATA chunks, but it MUST be the first chunk in the packet and
+ *    until the COOKIE ACK is returned the sender MUST NOT send any
+ *    other packets to the peer.
+ *
+ * Verification Tag: 3.3.3
+ *   If the value of the Initiate Tag in a received INIT ACK chunk is
+ *   found to be 0, the receiver MUST treat it as an error and close the
+ *   association by transmitting an ABORT.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_1C_ack(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const sctp_subtype_t type,
+                                       void *arg,
+                                       sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        sctp_init_chunk_t *initchunk;
+        __u32 init_tag;
+        struct sctp_chunk *err_chunk;
+        struct sctp_packet *packet;
+        sctp_disposition_t ret;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the INIT-ACK chunk has a valid length */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_initack_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+        /* 6.10 Bundling
+         * An endpoint MUST NOT bundle INIT, INIT ACK or
+         * SHUTDOWN COMPLETE with any other chunks.
+         */
+        if (!chunk->singleton)
+                return SCTP_DISPOSITION_VIOLATION;
+
+        /* Grab the INIT header.  */
+        chunk->subh.init_hdr = (sctp_inithdr_t *) chunk->skb->data;
+
+        init_tag = ntohl(chunk->subh.init_hdr->init_tag);
+
+        /* Verification Tag: 3.3.3
+         *   If the value of the Initiate Tag in a received INIT ACK
+         *   chunk is found to be 0, the receiver MUST treat it as an
+         *   error and close the association by transmitting an ABORT.
+         */
+        if (!init_tag) {
+                struct sctp_chunk *reply = sctp_make_abort(asoc, chunk, 0);
+                if (!reply)
+                        goto nomem;
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+                sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                                SCTP_STATE(SCTP_STATE_CLOSED));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        /* Verify the INIT chunk before processing it. */
+        err_chunk = NULL;
+        if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
+                              (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
+                              &err_chunk)) {
+
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+
+                /* This chunk contains fatal error. It is to be discarded.
+                 * Send an ABORT, with causes if there is any.
+                 */
+                if (err_chunk) {
+                        packet = sctp_abort_pkt_new(ep, asoc, arg,
+                                        (__u8 *)(err_chunk->chunk_hdr) +
+                                        sizeof(sctp_chunkhdr_t),
+                                        ntohs(err_chunk->chunk_hdr->length) -
+                                        sizeof(sctp_chunkhdr_t));
+
+                        sctp_chunk_free(err_chunk);
+
+                        if (packet) {
+                                sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                                SCTP_PACKET(packet));
+                                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+                                sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                                                SCTP_STATE(SCTP_STATE_CLOSED));
+                                sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
+                                                SCTP_NULL());
+                                return SCTP_DISPOSITION_CONSUME;
+                        } else {
+                                sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                                                SCTP_STATE(SCTP_STATE_CLOSED));
+                                sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
+                                                SCTP_NULL());
+                                return SCTP_DISPOSITION_NOMEM;
+                        }
+                } else {
+                        ret = sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
+                                                   commands);
+                        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                                        SCTP_STATE(SCTP_STATE_CLOSED));
+                        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB,
+                                        SCTP_NULL());
+                        return ret;
+                }
+        }
+
+        /* Tag the variable length parameters.  Note that we never
+         * convert the parameters in an INIT chunk.
+         */
+        chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
+
+        initchunk = (sctp_init_chunk_t *) chunk->chunk_hdr;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_PEER_INIT,
+                        SCTP_PEER_INIT(initchunk));
+
+        /* 5.1 C) "A" shall stop the T1-init timer and leave
+         * COOKIE-WAIT state.  "A" shall then ... start the T1-cookie
+         * timer, and enter the COOKIE-ECHOED state.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_COOKIE_ECHOED));
+
+        /* 5.1 C) "A" shall then send the State Cookie received in the
+         * INIT ACK chunk in a COOKIE ECHO chunk, ...
+         */
+        /* If there is any errors to report, send the ERROR chunk generated
+         * for unknown parameters as well.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_GEN_COOKIE_ECHO,
+                        SCTP_CHUNK(err_chunk));
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Respond to a normal COOKIE ECHO chunk.
+ * We are the side that is being asked for an association.
+ *
+ * Section: 5.1 Normal Establishment of an Association, D
+ * D) Upon reception of the COOKIE ECHO chunk, Endpoint "Z" will reply
+ *    with a COOKIE ACK chunk after building a TCB and moving to
+ *    the ESTABLISHED state. A COOKIE ACK chunk may be bundled with
+ *    any pending DATA chunks (and/or SACK chunks), but the COOKIE ACK
+ *    chunk MUST be the first chunk in the packet.
+ *
+ *   IMPLEMENTATION NOTE: An implementation may choose to send the
+ *   Communication Up notification to the SCTP user upon reception
+ *   of a valid COOKIE ECHO chunk.
+ *
+ * Verification Tag: 8.5.1 Exceptions in Verification Tag Rules
+ * D) Rules for packet carrying a COOKIE ECHO
+ *
+ * - When sending a COOKIE ECHO, the endpoint MUST use the value of the
+ *   Initial Tag received in the INIT ACK.
+ *
+ * - The receiver of a COOKIE ECHO follows the procedures in Section 5.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_1D_ce(const struct sctp_endpoint *ep,
+                                      const struct sctp_association *asoc,
+                                      const sctp_subtype_t type, void *arg,
+                                      sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_association *new_asoc;
+        sctp_init_chunk_t *peer_init;
+        struct sctp_chunk *repl;
+        struct sctp_ulpevent *ev;
+        int error = 0;
+        struct sctp_chunk *err_chk_p;
+
+        /* If the packet is an OOTB packet which is temporarily on the
+         * control endpoint, respond with an ABORT.
+         */
+        if (ep == sctp_sk((sctp_get_ctl_sock()))->ep)
+                return sctp_sf_ootb(ep, asoc, type, arg, commands);
+
+        /* Make sure that the COOKIE_ECHO chunk has a valid length.
+         * In this case, we check that we have enough for at least a
+         * chunk header.  More detailed verification is done
+         * in sctp_unpack_cookie().
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* "Decode" the chunk.  We have no optional parameters so we
+         * are in good shape.
+         */
+        chunk->subh.cookie_hdr =
+                (struct sctp_signed_cookie *)chunk->skb->data;
+        skb_pull(chunk->skb,
+                 ntohs(chunk->chunk_hdr->length) - sizeof(sctp_chunkhdr_t));
+
+        /* 5.1 D) Upon reception of the COOKIE ECHO chunk, Endpoint
+         * "Z" will reply with a COOKIE ACK chunk after building a TCB
+         * and moving to the ESTABLISHED state.
+         */
+        new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,
+                                      &err_chk_p);
+
+        /* FIXME:
+         * If the re-build failed, what is the proper error path
+         * from here?
+         *
+         * [We should abort the association. --piggy]
+         */
+        if (!new_asoc) {
+                /* FIXME: Several errors are possible.  A bad cookie should
+                 * be silently discarded, but think about logging it too.
+                 */
+                switch (error) {
+                case -SCTP_IERROR_NOMEM:
+                        goto nomem;
+
+                case -SCTP_IERROR_STALE_COOKIE:
+                        sctp_send_stale_cookie_err(ep, asoc, chunk, commands,
+                                                   err_chk_p);
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+                case -SCTP_IERROR_BAD_SIG:
+                default:
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                };
+        }
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_ESTABLISHED));
+        SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
+        SCTP_INC_STATS(SCTP_MIB_PASSIVEESTABS);
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
+
+        if (new_asoc->autoclose)
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
+
+        /* Re-build the bind address for the association is done in
+         * the sctp_unpack_cookie() already.
+         */
+        /* This is a brand-new association, so these are not yet side
+         * effects--it is safe to run them here.
+         */
+        peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
+
+        if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
+                               &chunk->subh.cookie_hdr->c.peer_addr,
+                               peer_init, GFP_ATOMIC))
+                goto nomem_init;
+
+        repl = sctp_make_cookie_ack(new_asoc, chunk);
+        if (!repl)
+                goto nomem_repl;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+
+        /* RFC 2960 5.1 Normal Establishment of an Association
+         *
+         * D) IMPLEMENTATION NOTE: An implementation may choose to
+         * send the Communication Up notification to the SCTP user
+         * upon reception of a valid COOKIE ECHO chunk.
+         */
+        ev = sctp_ulpevent_make_assoc_change(new_asoc, 0, SCTP_COMM_UP, 0,
+                                             new_asoc->c.sinit_num_ostreams,
+                                             new_asoc->c.sinit_max_instreams,
+                                             GFP_ATOMIC);
+        if (!ev)
+                goto nomem_ev;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+        /* Sockets API Draft Section 5.3.1.6    
+         * When a peer sends a Adaption Layer Indication parameter , SCTP
+         * delivers this notification to inform the application that of the
+         * peers requested adaption layer.
+         */
+        if (new_asoc->peer.adaption_ind) {
+                ev = sctp_ulpevent_make_adaption_indication(new_asoc,
+                                                            GFP_ATOMIC);
+                if (!ev)
+                        goto nomem_ev;
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(ev));
+        }
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem_ev:
+        sctp_chunk_free(repl);
+nomem_repl:
+nomem_init:
+        sctp_association_free(new_asoc);
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Respond to a normal COOKIE ACK chunk.
+ * We are the side that is being asked for an association.
+ *
+ * RFC 2960 5.1 Normal Establishment of an Association
+ *
+ * E) Upon reception of the COOKIE ACK, endpoint "A" will move from the
+ *    COOKIE-ECHOED state to the ESTABLISHED state, stopping the T1-cookie
+ *    timer. It may also notify its ULP about the successful
+ *    establishment of the association with a Communication Up
+ *    notification (see Section 10).
+ *
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_1E_ca(const struct sctp_endpoint *ep,
+                                      const struct sctp_association *asoc,
+                                      const sctp_subtype_t type, void *arg,
+                                      sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_ulpevent *ev;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Verify that the chunk length for the COOKIE-ACK is OK.
+         * If we don't do this, any bundled chunks may be junked.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* Reset init error count upon receipt of COOKIE-ACK,
+         * to avoid problems with the managemement of this
+         * counter in stale cookie situations when a transition back
+         * from the COOKIE-ECHOED state to the COOKIE-WAIT
+         * state is performed.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_COUNTER_RESET,
+                        SCTP_COUNTER(SCTP_COUNTER_INIT_ERROR));
+
+        /* RFC 2960 5.1 Normal Establishment of an Association
+         *
+         * E) Upon reception of the COOKIE ACK, endpoint "A" will move
+         * from the COOKIE-ECHOED state to the ESTABLISHED state,
+         * stopping the T1-cookie timer.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_ESTABLISHED));
+        SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
+        SCTP_INC_STATS(SCTP_MIB_ACTIVEESTABS);
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
+        if (asoc->autoclose)
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
+
+        /* It may also notify its ULP about the successful
+         * establishment of the association with a Communication Up
+         * notification (see Section 10).
+         */
+        ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_UP,
+                                             0, asoc->c.sinit_num_ostreams,
+                                             asoc->c.sinit_max_instreams,
+                                             GFP_ATOMIC);
+
+        if (!ev)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+        /* Sockets API Draft Section 5.3.1.6
+         * When a peer sends a Adaption Layer Indication parameter , SCTP
+         * delivers this notification to inform the application that of the
+         * peers requested adaption layer.
+         */
+        if (asoc->peer.adaption_ind) {
+                ev = sctp_ulpevent_make_adaption_indication(asoc, GFP_ATOMIC);
+                if (!ev)
+                        goto nomem;
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(ev));
+        }
+
+        return SCTP_DISPOSITION_CONSUME;
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/* Generate and sendout a heartbeat packet.  */
+static sctp_disposition_t sctp_sf_heartbeat(const struct sctp_endpoint *ep,
+                                            const struct sctp_association *asoc,
+                                            const sctp_subtype_t type,
+                                            void *arg,
+                                            sctp_cmd_seq_t *commands)
+{
+        struct sctp_transport *transport = (struct sctp_transport *) arg;
+        struct sctp_chunk *reply;
+        sctp_sender_hb_info_t hbinfo;
+        size_t paylen = 0;
+
+        hbinfo.param_hdr.type = SCTP_PARAM_HEARTBEAT_INFO;
+        hbinfo.param_hdr.length = htons(sizeof(sctp_sender_hb_info_t));
+        hbinfo.daddr = transport->ipaddr;
+        hbinfo.sent_at = jiffies;
+
+        /* Send a heartbeat to our peer.  */
+        paylen = sizeof(sctp_sender_hb_info_t);
+        reply = sctp_make_heartbeat(asoc, transport, &hbinfo, paylen);
+        if (!reply)
+                return SCTP_DISPOSITION_NOMEM;
+
+        /* Set rto_pending indicating that an RTT measurement
+         * is started with this heartbeat chunk.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_RTO_PENDING,
+                        SCTP_TRANSPORT(transport));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/* Generate a HEARTBEAT packet on the given transport.  */
+sctp_disposition_t sctp_sf_sendbeat_8_3(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_transport *transport = (struct sctp_transport *) arg;
+
+        if (asoc->overall_error_count > asoc->max_retrans) {
+                /* CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_ERROR));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        /* Section 3.3.5.
+         * The Sender-specific Heartbeat Info field should normally include
+         * information about the sender's current time when this HEARTBEAT
+         * chunk is sent and the destination transport address to which this
+         * HEARTBEAT is sent (see Section 8.3).
+         */
+
+        if (transport->hb_allowed) {
+                if (SCTP_DISPOSITION_NOMEM ==
+                                sctp_sf_heartbeat(ep, asoc, type, arg,
+                                                  commands))
+                        return SCTP_DISPOSITION_NOMEM;
+                /* Set transport error counter and association error counter
+                 * when sending heartbeat.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_TRANSPORT_RESET,
+                                SCTP_TRANSPORT(transport));
+        }
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMER_UPDATE,
+                        SCTP_TRANSPORT(transport));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Process an heartbeat request.
+ *
+ * Section: 8.3 Path Heartbeat
+ * The receiver of the HEARTBEAT should immediately respond with a
+ * HEARTBEAT ACK that contains the Heartbeat Information field copied
+ * from the received HEARTBEAT chunk.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ * When receiving an SCTP packet, the endpoint MUST ensure that the
+ * value in the Verification Tag field of the received SCTP packet
+ * matches its own Tag. If the received Verification Tag value does not
+ * match the receiver's own tag value, the receiver shall silently
+ * discard the packet and shall not process it any further except for
+ * those cases listed in Section 8.5.1 below.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_beat_8_3(const struct sctp_endpoint *ep,
+                                    const struct sctp_association *asoc,
+                                    const sctp_subtype_t type,
+                                    void *arg,
+                                    sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *reply;
+        size_t paylen = 0;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the HEARTBEAT chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_heartbeat_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* 8.3 The receiver of the HEARTBEAT should immediately
+         * respond with a HEARTBEAT ACK that contains the Heartbeat
+         * Information field copied from the received HEARTBEAT chunk.
+         */
+        chunk->subh.hb_hdr = (sctp_heartbeathdr_t *) chunk->skb->data;
+        paylen = ntohs(chunk->chunk_hdr->length) - sizeof(sctp_chunkhdr_t);
+        skb_pull(chunk->skb, paylen);
+
+        reply = sctp_make_heartbeat_ack(asoc, chunk,
+                                        chunk->subh.hb_hdr, paylen);
+        if (!reply)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Process the returning HEARTBEAT ACK.
+ *
+ * Section: 8.3 Path Heartbeat
+ * Upon the receipt of the HEARTBEAT ACK, the sender of the HEARTBEAT
+ * should clear the error counter of the destination transport
+ * address to which the HEARTBEAT was sent, and mark the destination
+ * transport address as active if it is not so marked. The endpoint may
+ * optionally report to the upper layer when an inactive destination
+ * address is marked as active due to the reception of the latest
+ * HEARTBEAT ACK. The receiver of the HEARTBEAT ACK must also
+ * clear the association overall error count as well (as defined
+ * in section 8.1).
+ *
+ * The receiver of the HEARTBEAT ACK should also perform an RTT
+ * measurement for that destination transport address using the time
+ * value carried in the HEARTBEAT ACK chunk.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_backbeat_8_3(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        union sctp_addr from_addr;
+        struct sctp_transport *link;
+        sctp_sender_hb_info_t *hbinfo;
+        unsigned long max_interval;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the HEARTBEAT-ACK chunk has a valid length.  */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_heartbeat_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
+        from_addr = hbinfo->daddr;
+        link = sctp_assoc_lookup_paddr(asoc, &from_addr);
+
+        /* This should never happen, but lets log it if so.  */
+        if (!link) {
+                printk(KERN_WARNING
+                       "%s: Could not find address %d.%d.%d.%d\n",
+                       __FUNCTION__, NIPQUAD(from_addr.v4.sin_addr));
+                return SCTP_DISPOSITION_DISCARD;
+        }
+
+        max_interval = link->hb_interval + link->rto;
+
+        /* Check if the timestamp looks valid.  */
+        if (time_after(hbinfo->sent_at, jiffies) ||
+            time_after(jiffies, hbinfo->sent_at + max_interval)) {
+                SCTP_DEBUG_PRINTK("%s: HEARTBEAT ACK with invalid timestamp"
+                                  "received for transport: %p\n",
+                                   __FUNCTION__, link);
+                return SCTP_DISPOSITION_DISCARD;
+        }
+
+        /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of
+         * the HEARTBEAT should clear the error counter of the
+         * destination transport address to which the HEARTBEAT was
+         * sent and mark the destination transport address as active if
+         * it is not so marked.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSPORT_ON, SCTP_TRANSPORT(link));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/* Helper function to send out an abort for the restart
+ * condition.
+ */
+static int sctp_sf_send_restart_abort(union sctp_addr *ssa,
+                                      struct sctp_chunk *init,
+                                      sctp_cmd_seq_t *commands)
+{
+        int len;
+        struct sctp_packet *pkt;
+        union sctp_addr_param *addrparm;
+        struct sctp_errhdr *errhdr;
+        struct sctp_endpoint *ep;
+        char buffer[sizeof(struct sctp_errhdr)+sizeof(union sctp_addr_param)];
+        struct sctp_af *af = sctp_get_af_specific(ssa->v4.sin_family);
+
+        /* Build the error on the stack.   We are way to malloc crazy
+         * throughout the code today.
+         */
+        errhdr = (struct sctp_errhdr *)buffer;
+        addrparm = (union sctp_addr_param *)errhdr->variable;
+
+        /* Copy into a parm format. */
+        len = af->to_addr_param(ssa, addrparm);
+        len += sizeof(sctp_errhdr_t);
+
+        errhdr->cause = SCTP_ERROR_RESTART;
+        errhdr->length = htons(len);
+
+        /* Assign to the control socket. */
+        ep = sctp_sk((sctp_get_ctl_sock()))->ep;
+
+        /* Association is NULL since this may be a restart attack and we
+         * want to send back the attacker's vtag.
+         */
+        pkt = sctp_abort_pkt_new(ep, NULL, init, errhdr, len);
+
+        if (!pkt)
+                goto out;
+        sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT, SCTP_PACKET(pkt));
+
+        SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+
+        /* Discard the rest of the inbound packet. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
+
+out:
+        /* Even if there is no memory, treat as a failure so
+         * the packet will get dropped.
+         */
+        return 0;
+}
+
+/* A restart is occurring, check to make sure no new addresses
+ * are being added as we may be under a takeover attack.
+ */
+static int sctp_sf_check_restart_addrs(const struct sctp_association *new_asoc,
+                                       const struct sctp_association *asoc,
+                                       struct sctp_chunk *init,
+                                       sctp_cmd_seq_t *commands)
+{
+        struct sctp_transport *new_addr, *addr;
+        struct list_head *pos, *pos2;
+        int found;
+
+        /* Implementor's Guide - Sectin 5.2.2
+         * ...
+         * Before responding the endpoint MUST check to see if the
+         * unexpected INIT adds new addresses to the association. If new
+         * addresses are added to the association, the endpoint MUST respond
+         * with an ABORT..
+         */
+
+        /* Search through all current addresses and make sure
+         * we aren't adding any new ones.
+         */
+        new_addr = NULL;
+        found = 0;
+
+        list_for_each(pos, &new_asoc->peer.transport_addr_list) {
+                new_addr = list_entry(pos, struct sctp_transport, transports);
+                found = 0;
+                list_for_each(pos2, &asoc->peer.transport_addr_list) {
+                        addr = list_entry(pos2, struct sctp_transport,
+                                          transports);
+                        if (sctp_cmp_addr_exact(&new_addr->ipaddr,
+                                                &addr->ipaddr)) {
+                                found = 1;
+                                break;
+                        }
+                }
+                if (!found)
+                        break;
+        }
+
+        /* If a new address was added, ABORT the sender. */
+        if (!found && new_addr) {
+                sctp_sf_send_restart_abort(&new_addr->ipaddr, init, commands);
+        }
+
+        /* Return success if all addresses were found. */
+        return found;
+}
+
+/* Populate the verification/tie tags based on overlapping INIT
+ * scenario.
+ *
+ * Note: Do not use in CLOSED or SHUTDOWN-ACK-SENT state.
+ */
+static void sctp_tietags_populate(struct sctp_association *new_asoc,
+                                  const struct sctp_association *asoc)
+{
+        switch (asoc->state) {
+
+        /* 5.2.1 INIT received in COOKIE-WAIT or COOKIE-ECHOED State */
+
+        case SCTP_STATE_COOKIE_WAIT:
+                new_asoc->c.my_vtag     = asoc->c.my_vtag;
+                new_asoc->c.my_ttag     = asoc->c.my_vtag;
+                new_asoc->c.peer_ttag   = 0;
+                break;
+
+        case SCTP_STATE_COOKIE_ECHOED:
+                new_asoc->c.my_vtag     = asoc->c.my_vtag;
+                new_asoc->c.my_ttag     = asoc->c.my_vtag;
+                new_asoc->c.peer_ttag   = asoc->c.peer_vtag;
+                break;
+
+        /* 5.2.2 Unexpected INIT in States Other than CLOSED, COOKIE-ECHOED,
+         * COOKIE-WAIT and SHUTDOWN-ACK-SENT
+         */
+        default:
+                new_asoc->c.my_ttag   = asoc->c.my_vtag;
+                new_asoc->c.peer_ttag = asoc->c.peer_vtag;
+                break;
+        };
+
+        /* Other parameters for the endpoint SHOULD be copied from the
+         * existing parameters of the association (e.g. number of
+         * outbound streams) into the INIT ACK and cookie.
+         */
+        new_asoc->rwnd                  = asoc->rwnd;
+        new_asoc->c.sinit_num_ostreams  = asoc->c.sinit_num_ostreams;
+        new_asoc->c.sinit_max_instreams = asoc->c.sinit_max_instreams;
+        new_asoc->c.initial_tsn         = asoc->c.initial_tsn;
+}
+
+/*
+ * Compare vtag/tietag values to determine unexpected COOKIE-ECHO
+ * handling action.
+ *
+ * RFC 2960 5.2.4 Handle a COOKIE ECHO when a TCB exists.
+ *
+ * Returns value representing action to be taken.   These action values
+ * correspond to Action/Description values in RFC 2960, Table 2.
+ */
+static char sctp_tietags_compare(struct sctp_association *new_asoc,
+                                 const struct sctp_association *asoc)
+{
+        /* In this case, the peer may have restarted.  */
+        if ((asoc->c.my_vtag != new_asoc->c.my_vtag) &&
+            (asoc->c.peer_vtag != new_asoc->c.peer_vtag) &&
+            (asoc->c.my_vtag == new_asoc->c.my_ttag) &&
+            (asoc->c.peer_vtag == new_asoc->c.peer_ttag))
+                return 'A';
+
+        /* Collision case B. */
+        if ((asoc->c.my_vtag == new_asoc->c.my_vtag) &&
+            ((asoc->c.peer_vtag != new_asoc->c.peer_vtag) ||
+             (0 == asoc->c.peer_vtag))) {
+                return 'B';
+        }
+
+        /* Collision case D. */
+        if ((asoc->c.my_vtag == new_asoc->c.my_vtag) &&
+            (asoc->c.peer_vtag == new_asoc->c.peer_vtag))
+                return 'D';
+
+        /* Collision case C. */
+        if ((asoc->c.my_vtag != new_asoc->c.my_vtag) &&
+            (asoc->c.peer_vtag == new_asoc->c.peer_vtag) &&
+            (0 == new_asoc->c.my_ttag) &&
+            (0 == new_asoc->c.peer_ttag))
+                return 'C';
+
+        /* No match to any of the special cases; discard this packet. */
+        return 'E';
+}
+
+/* Common helper routine for both duplicate and simulataneous INIT
+ * chunk handling.
+ */
+static sctp_disposition_t sctp_sf_do_unexpected_init(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg, sctp_cmd_seq_t *commands)
+{
+        sctp_disposition_t retval;
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *repl;
+        struct sctp_association *new_asoc;
+        struct sctp_chunk *err_chunk;
+        struct sctp_packet *packet;
+        sctp_unrecognized_param_t *unk_param;
+        int len;
+
+        /* 6.10 Bundling
+         * An endpoint MUST NOT bundle INIT, INIT ACK or
+         * SHUTDOWN COMPLETE with any other chunks.
+         *
+         * IG Section 2.11.2
+         * Furthermore, we require that the receiver of an INIT chunk MUST
+         * enforce these rules by silently discarding an arriving packet
+         * with an INIT chunk that is bundled with other chunks.
+         */
+        if (!chunk->singleton)
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* 3.1 A packet containing an INIT chunk MUST have a zero Verification
+         * Tag. 
+         */
+        if (chunk->sctp_hdr->vtag != 0)
+                return sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
+
+        /* Make sure that the INIT chunk has a valid length.
+         * In this case, we generate a protocol violation since we have
+         * an association established.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_init_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+        /* Grab the INIT header.  */
+        chunk->subh.init_hdr = (sctp_inithdr_t *) chunk->skb->data;
+
+        /* Tag the variable length parameters.  */
+        chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(sctp_inithdr_t));
+
+        /* Verify the INIT chunk before processing it. */
+        err_chunk = NULL;
+        if (!sctp_verify_init(asoc, chunk->chunk_hdr->type,
+                              (sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
+                              &err_chunk)) {
+                /* This chunk contains fatal error. It is to be discarded.
+                 * Send an ABORT, with causes if there is any.
+                 */
+                if (err_chunk) {
+                        packet = sctp_abort_pkt_new(ep, asoc, arg,
+                                        (__u8 *)(err_chunk->chunk_hdr) +
+                                        sizeof(sctp_chunkhdr_t),
+                                        ntohs(err_chunk->chunk_hdr->length) -
+                                        sizeof(sctp_chunkhdr_t));
+
+                        if (packet) {
+                                sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                                SCTP_PACKET(packet));
+                                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+                                retval = SCTP_DISPOSITION_CONSUME;
+                        } else {
+                                retval = SCTP_DISPOSITION_NOMEM;
+                        }
+                        goto cleanup;
+                } else {
+                        return sctp_sf_tabort_8_4_8(ep, asoc, type, arg,
+                                                    commands);
+                }
+        }
+
+        /*
+         * Other parameters for the endpoint SHOULD be copied from the
+         * existing parameters of the association (e.g. number of
+         * outbound streams) into the INIT ACK and cookie.
+         * FIXME:  We are copying parameters from the endpoint not the
+         * association.
+         */
+        new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);
+        if (!new_asoc)
+                goto nomem;
+
+        /* In the outbound INIT ACK the endpoint MUST copy its current
+         * Verification Tag and Peers Verification tag into a reserved
+         * place (local tie-tag and per tie-tag) within the state cookie.
+         */
+        if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
+                               sctp_source(chunk),
+                               (sctp_init_chunk_t *)chunk->chunk_hdr,
+                               GFP_ATOMIC)) {
+                retval = SCTP_DISPOSITION_NOMEM;
+                goto nomem_init;
+        }
+
+        /* Make sure no new addresses are being added during the
+         * restart.   Do not do this check for COOKIE-WAIT state,
+         * since there are no peer addresses to check against.
+         * Upon return an ABORT will have been sent if needed.
+         */
+        if (!sctp_state(asoc, COOKIE_WAIT)) {
+                if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk,
+                                                 commands)) {
+                        retval = SCTP_DISPOSITION_CONSUME;
+                        goto cleanup_asoc;
+                }
+        }
+
+        sctp_tietags_populate(new_asoc, asoc);
+
+        /* B) "Z" shall respond immediately with an INIT ACK chunk.  */
+
+        /* If there are errors need to be reported for unknown parameters,
+         * make sure to reserve enough room in the INIT ACK for them.
+         */
+        len = 0;
+        if (err_chunk) {
+                len = ntohs(err_chunk->chunk_hdr->length) -
+                        sizeof(sctp_chunkhdr_t);
+        }
+
+        if (sctp_assoc_set_bind_addr_from_ep(new_asoc, GFP_ATOMIC) < 0)
+                goto nomem;
+
+        repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);
+        if (!repl)
+                goto nomem;
+
+        /* If there are errors need to be reported for unknown parameters,
+         * include them in the outgoing INIT ACK as "Unrecognized parameter"
+         * parameter.
+         */
+        if (err_chunk) {
+                /* Get the "Unrecognized parameter" parameter(s) out of the
+                 * ERROR chunk generated by sctp_verify_init(). Since the
+                 * error cause code for "unknown parameter" and the
+                 * "Unrecognized parameter" type is the same, we can
+                 * construct the parameters in INIT ACK by copying the
+                 * ERROR causes over.
+                 */
+                unk_param = (sctp_unrecognized_param_t *)
+                            ((__u8 *)(err_chunk->chunk_hdr) +
+                            sizeof(sctp_chunkhdr_t));
+                /* Replace the cause code with the "Unrecognized parameter"
+                 * parameter type.
+                 */
+                sctp_addto_chunk(repl, len, unk_param);
+        }
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+
+        /*
+         * Note: After sending out INIT ACK with the State Cookie parameter,
+         * "Z" MUST NOT allocate any resources for this new association.
+         * Otherwise, "Z" will be vulnerable to resource attacks.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+        retval = SCTP_DISPOSITION_CONSUME;
+
+cleanup:
+        if (err_chunk)
+                sctp_chunk_free(err_chunk);
+        return retval;
+nomem:
+        retval = SCTP_DISPOSITION_NOMEM;
+        goto cleanup;
+nomem_init:
+cleanup_asoc:
+        sctp_association_free(new_asoc);
+        goto cleanup;
+}
+
+/*
+ * Handle simultanous INIT.
+ * This means we started an INIT and then we got an INIT request from
+ * our peer.
+ *
+ * Section: 5.2.1 INIT received in COOKIE-WAIT or COOKIE-ECHOED State (Item B)
+ * This usually indicates an initialization collision, i.e., each
+ * endpoint is attempting, at about the same time, to establish an
+ * association with the other endpoint.
+ *
+ * Upon receipt of an INIT in the COOKIE-WAIT or COOKIE-ECHOED state, an
+ * endpoint MUST respond with an INIT ACK using the same parameters it
+ * sent in its original INIT chunk (including its Verification Tag,
+ * unchanged). These original parameters are combined with those from the
+ * newly received INIT chunk. The endpoint shall also generate a State
+ * Cookie with the INIT ACK. The endpoint uses the parameters sent in its
+ * INIT to calculate the State Cookie.
+ *
+ * After that, the endpoint MUST NOT change its state, the T1-init
+ * timer shall be left running and the corresponding TCB MUST NOT be
+ * destroyed. The normal procedures for handling State Cookies when
+ * a TCB exists will resolve the duplicate INITs to a single association.
+ *
+ * For an endpoint that is in the COOKIE-ECHOED state it MUST populate
+ * its Tie-Tags with the Tag information of itself and its peer (see
+ * section 5.2.2 for a description of the Tie-Tags).
+ *
+ * Verification Tag: Not explicit, but an INIT can not have a valid
+ * verification tag, so we skip the check.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_2_1_siminit(const struct sctp_endpoint *ep,
+                                    const struct sctp_association *asoc,
+                                    const sctp_subtype_t type,
+                                    void *arg,
+                                    sctp_cmd_seq_t *commands)
+{
+        /* Call helper to do the real work for both simulataneous and
+         * duplicate INIT chunk handling.
+         */
+        return sctp_sf_do_unexpected_init(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Handle duplicated INIT messages.  These are usually delayed
+ * restransmissions.
+ *
+ * Section: 5.2.2 Unexpected INIT in States Other than CLOSED,
+ * COOKIE-ECHOED and COOKIE-WAIT
+ *
+ * Unless otherwise stated, upon reception of an unexpected INIT for
+ * this association, the endpoint shall generate an INIT ACK with a
+ * State Cookie.  In the outbound INIT ACK the endpoint MUST copy its
+ * current Verification Tag and peer's Verification Tag into a reserved
+ * place within the state cookie.  We shall refer to these locations as
+ * the Peer's-Tie-Tag and the Local-Tie-Tag.  The outbound SCTP packet
+ * containing this INIT ACK MUST carry a Verification Tag value equal to
+ * the Initiation Tag found in the unexpected INIT.  And the INIT ACK
+ * MUST contain a new Initiation Tag (randomly generated see Section
+ * 5.3.1).  Other parameters for the endpoint SHOULD be copied from the
+ * existing parameters of the association (e.g. number of outbound
+ * streams) into the INIT ACK and cookie.
+ *
+ * After sending out the INIT ACK, the endpoint shall take no further
+ * actions, i.e., the existing association, including its current state,
+ * and the corresponding TCB MUST NOT be changed.
+ *
+ * Note: Only when a TCB exists and the association is not in a COOKIE-
+ * WAIT state are the Tie-Tags populated.  For a normal association INIT
+ * (i.e. the endpoint is in a COOKIE-WAIT state), the Tie-Tags MUST be
+ * set to 0 (indicating that no previous TCB existed).  The INIT ACK and
+ * State Cookie are populated as specified in section 5.2.1.
+ *
+ * Verification Tag: Not specified, but an INIT has no way of knowing
+ * what the verification tag could be, so we ignore it.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_2_2_dupinit(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        /* Call helper to do the real work for both simulataneous and
+         * duplicate INIT chunk handling.
+         */
+        return sctp_sf_do_unexpected_init(ep, asoc, type, arg, commands);
+}
+
+
+
+/* Unexpected COOKIE-ECHO handler for peer restart (Table 2, action 'A')
+ *
+ * Section 5.2.4
+ *  A)  In this case, the peer may have restarted.
+ */
+static sctp_disposition_t sctp_sf_do_dupcook_a(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        struct sctp_chunk *chunk,
+                                        sctp_cmd_seq_t *commands,
+                                        struct sctp_association *new_asoc)
+{
+        sctp_init_chunk_t *peer_init;
+        struct sctp_ulpevent *ev;
+        struct sctp_chunk *repl;
+        struct sctp_chunk *err;
+        sctp_disposition_t disposition;
+
+        /* new_asoc is a brand-new association, so these are not yet
+         * side effects--it is safe to run them here.
+         */
+        peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
+
+        if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
+                               sctp_source(chunk), peer_init,
+                               GFP_ATOMIC))
+                goto nomem;
+
+        /* Make sure no new addresses are being added during the
+         * restart.  Though this is a pretty complicated attack
+         * since you'd have to get inside the cookie.
+         */
+        if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk, commands)) {
+                return SCTP_DISPOSITION_CONSUME;
+        }
+
+        /* If the endpoint is in the SHUTDOWN-ACK-SENT state and recognizes
+         * the peer has restarted (Action A), it MUST NOT setup a new
+         * association but instead resend the SHUTDOWN ACK and send an ERROR
+         * chunk with a "Cookie Received while Shutting Down" error cause to
+         * its peer.
+        */
+        if (sctp_state(asoc, SHUTDOWN_ACK_SENT)) {
+                disposition = sctp_sf_do_9_2_reshutack(ep, asoc,
+                                SCTP_ST_CHUNK(chunk->chunk_hdr->type),
+                                chunk, commands);
+                if (SCTP_DISPOSITION_NOMEM == disposition)
+                        goto nomem;
+
+                err = sctp_make_op_error(asoc, chunk,
+                                         SCTP_ERROR_COOKIE_IN_SHUTDOWN,
+                                         NULL, 0);
+                if (err)
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(err));
+
+                return SCTP_DISPOSITION_CONSUME;
+        }
+
+        /* For now, fail any unsent/unacked data.  Consider the optional
+         * choice of resending of this data.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_PURGE_OUTQUEUE, SCTP_NULL());
+
+        /* Update the content of current association. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_UPDATE_ASSOC, SCTP_ASOC(new_asoc));
+
+        repl = sctp_make_cookie_ack(new_asoc, chunk);
+        if (!repl)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+
+        /* Report association restart to upper layer. */
+        ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_RESTART, 0,
+                                             new_asoc->c.sinit_num_ostreams,
+                                             new_asoc->c.sinit_max_instreams,
+                                             GFP_ATOMIC);
+        if (!ev)
+                goto nomem_ev;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem_ev:
+        sctp_chunk_free(repl);
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/* Unexpected COOKIE-ECHO handler for setup collision (Table 2, action 'B')
+ *
+ * Section 5.2.4
+ *   B) In this case, both sides may be attempting to start an association
+ *      at about the same time but the peer endpoint started its INIT
+ *      after responding to the local endpoint's INIT
+ */
+/* This case represents an initialization collision.  */
+static sctp_disposition_t sctp_sf_do_dupcook_b(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        struct sctp_chunk *chunk,
+                                        sctp_cmd_seq_t *commands,
+                                        struct sctp_association *new_asoc)
+{
+        sctp_init_chunk_t *peer_init;
+        struct sctp_ulpevent *ev;
+        struct sctp_chunk *repl;
+
+        /* new_asoc is a brand-new association, so these are not yet
+         * side effects--it is safe to run them here.
+         */
+        peer_init = &chunk->subh.cookie_hdr->c.peer_init[0];
+        if (!sctp_process_init(new_asoc, chunk->chunk_hdr->type,
+                               sctp_source(chunk), peer_init,
+                               GFP_ATOMIC))
+                goto nomem;
+
+        /* Update the content of current association.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_UPDATE_ASSOC, SCTP_ASOC(new_asoc));
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_ESTABLISHED));
+        SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START, SCTP_NULL());
+
+        repl = sctp_make_cookie_ack(new_asoc, chunk);
+        if (!repl)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
+
+        /* RFC 2960 5.1 Normal Establishment of an Association
+         *
+         * D) IMPLEMENTATION NOTE: An implementation may choose to
+         * send the Communication Up notification to the SCTP user
+         * upon reception of a valid COOKIE ECHO chunk.
+         */
+        ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_UP, 0,
+                                             new_asoc->c.sinit_num_ostreams,
+                                             new_asoc->c.sinit_max_instreams,
+                                             GFP_ATOMIC);
+        if (!ev)
+                goto nomem_ev;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+        /* Sockets API Draft Section 5.3.1.6
+         * When a peer sends a Adaption Layer Indication parameter , SCTP
+         * delivers this notification to inform the application that of the
+         * peers requested adaption layer.
+         */
+        if (asoc->peer.adaption_ind) {
+                ev = sctp_ulpevent_make_adaption_indication(asoc, GFP_ATOMIC);
+                if (!ev)
+                        goto nomem_ev;
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(ev));
+        }
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem_ev:
+        sctp_chunk_free(repl);
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/* Unexpected COOKIE-ECHO handler for setup collision (Table 2, action 'C')
+ *
+ * Section 5.2.4
+ *  C) In this case, the local endpoint's cookie has arrived late.
+ *     Before it arrived, the local endpoint sent an INIT and received an
+ *     INIT-ACK and finally sent a COOKIE ECHO with the peer's same tag
+ *     but a new tag of its own.
+ */
+/* This case represents an initialization collision.  */
+static sctp_disposition_t sctp_sf_do_dupcook_c(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        struct sctp_chunk *chunk,
+                                        sctp_cmd_seq_t *commands,
+                                        struct sctp_association *new_asoc)
+{
+        /* The cookie should be silently discarded.
+         * The endpoint SHOULD NOT change states and should leave
+         * any timers running.
+         */
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/* Unexpected COOKIE-ECHO handler lost chunk (Table 2, action 'D')
+ *
+ * Section 5.2.4
+ *
+ * D) When both local and remote tags match the endpoint should always
+ *    enter the ESTABLISHED state, if it has not already done so.
+ */
+/* This case represents an initialization collision.  */
+static sctp_disposition_t sctp_sf_do_dupcook_d(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        struct sctp_chunk *chunk,
+                                        sctp_cmd_seq_t *commands,
+                                        struct sctp_association *new_asoc)
+{
+        struct sctp_ulpevent *ev = NULL;
+        struct sctp_chunk *repl;
+
+        /* Clarification from Implementor's Guide:
+         * D) When both local and remote tags match the endpoint should
+         * enter the ESTABLISHED state, if it is in the COOKIE-ECHOED state.
+         * It should stop any cookie timer that may be running and send
+         * a COOKIE ACK.
+         */
+
+        /* Don't accidentally move back into established state. */
+        if (asoc->state < SCTP_STATE_ESTABLISHED) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
+                sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                                SCTP_STATE(SCTP_STATE_ESTABLISHED));
+                SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
+                sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_START,
+                                SCTP_NULL());
+
+                /* RFC 2960 5.1 Normal Establishment of an Association
+                 *
+                 * D) IMPLEMENTATION NOTE: An implementation may choose
+                 * to send the Communication Up notification to the
+                 * SCTP user upon reception of a valid COOKIE
+                 * ECHO chunk.
+                 */
+                ev = sctp_ulpevent_make_assoc_change(new_asoc, 0,
+                                             SCTP_COMM_UP, 0,
+                                             new_asoc->c.sinit_num_ostreams,
+                                             new_asoc->c.sinit_max_instreams,
+                                             GFP_ATOMIC);
+                if (!ev)
+                        goto nomem;
+                sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                SCTP_ULPEVENT(ev));
+
+                /* Sockets API Draft Section 5.3.1.6
+                 * When a peer sends a Adaption Layer Indication parameter,
+                 * SCTP delivers this notification to inform the application
+                 * that of the peers requested adaption layer.
+                 */
+                if (new_asoc->peer.adaption_ind) {
+                        ev = sctp_ulpevent_make_adaption_indication(new_asoc,
+                                                                 GFP_ATOMIC);
+                        if (!ev)
+                                goto nomem;
+
+                        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
+                                        SCTP_ULPEVENT(ev));
+                }
+        }
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
+
+        repl = sctp_make_cookie_ack(new_asoc, chunk);
+        if (!repl)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TRANSMIT, SCTP_NULL());
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        if (ev)
+                sctp_ulpevent_free(ev);
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Handle a duplicate COOKIE-ECHO.  This usually means a cookie-carrying
+ * chunk was retransmitted and then delayed in the network.
+ *
+ * Section: 5.2.4 Handle a COOKIE ECHO when a TCB exists
+ *
+ * Verification Tag: None.  Do cookie validation.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_5_2_4_dupcook(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        sctp_disposition_t retval;
+        struct sctp_chunk *chunk = arg;
+        struct sctp_association *new_asoc;
+        int error = 0;
+        char action;
+        struct sctp_chunk *err_chk_p;
+
+        /* Make sure that the chunk has a valid length from the protocol
+         * perspective.  In this case check to make sure we have at least
+         * enough for the chunk header.  Cookie length verification is
+         * done later.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* "Decode" the chunk.  We have no optional parameters so we
+         * are in good shape.
+         */
+        chunk->subh.cookie_hdr = (struct sctp_signed_cookie *)chunk->skb->data;
+        skb_pull(chunk->skb, ntohs(chunk->chunk_hdr->length) -
+                 sizeof(sctp_chunkhdr_t));
+
+        /* In RFC 2960 5.2.4 3, if both Verification Tags in the State Cookie
+         * of a duplicate COOKIE ECHO match the Verification Tags of the
+         * current association, consider the State Cookie valid even if
+         * the lifespan is exceeded.
+         */
+        new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,
+                                      &err_chk_p);
+
+        /* FIXME:
+         * If the re-build failed, what is the proper error path
+         * from here?
+         *
+         * [We should abort the association. --piggy]
+         */
+        if (!new_asoc) {
+                /* FIXME: Several errors are possible.  A bad cookie should
+                 * be silently discarded, but think about logging it too.
+                 */
+                switch (error) {
+                case -SCTP_IERROR_NOMEM:
+                        goto nomem;
+
+                case -SCTP_IERROR_STALE_COOKIE:
+                        sctp_send_stale_cookie_err(ep, asoc, chunk, commands,
+                                                   err_chk_p);
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                case -SCTP_IERROR_BAD_SIG:
+                default:
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                };
+        }
+
+        /* Compare the tie_tag in cookie with the verification tag of
+         * current association.
+         */
+        action = sctp_tietags_compare(new_asoc, asoc);
+
+        switch (action) {
+        case 'A': /* Association restart. */
+                retval = sctp_sf_do_dupcook_a(ep, asoc, chunk, commands,
+                                              new_asoc);
+                break;
+
+        case 'B': /* Collision case B. */
+                retval = sctp_sf_do_dupcook_b(ep, asoc, chunk, commands,
+                                              new_asoc);
+                break;
+
+        case 'C': /* Collision case C. */
+                retval = sctp_sf_do_dupcook_c(ep, asoc, chunk, commands,
+                                              new_asoc);
+                break;
+
+        case 'D': /* Collision case D. */
+                retval = sctp_sf_do_dupcook_d(ep, asoc, chunk, commands,
+                                              new_asoc);
+                break;
+
+        default: /* Discard packet for all others. */
+                retval = sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                break;
+        };
+
+        /* Delete the tempory new association. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC, SCTP_ASOC(new_asoc));
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+
+        return retval;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Process an ABORT.  (SHUTDOWN-PENDING state)
+ *
+ * See sctp_sf_do_9_1_abort().
+ */
+sctp_disposition_t sctp_sf_shutdown_pending_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+
+        if (!sctp_vtag_verify_either(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ABORT chunk has a valid length.
+         * Since this is an ABORT chunk, we have to discard it
+         * because of the following text:
+         * RFC 2960, Section 3.3.7
+         *    If an endpoint receives an ABORT with a format error or for an
+         *    association that doesn't exist, it MUST silently discard it.
+         * Becasue the length is "invalid", we can't really discard just
+         * as we do not know its true length.  So, to be safe, discard the
+         * packet.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Stop the T5-shutdown guard timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        return sctp_sf_do_9_1_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Process an ABORT.  (SHUTDOWN-SENT state)
+ *
+ * See sctp_sf_do_9_1_abort().
+ */
+sctp_disposition_t sctp_sf_shutdown_sent_abort(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+
+        if (!sctp_vtag_verify_either(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ABORT chunk has a valid length.
+         * Since this is an ABORT chunk, we have to discard it
+         * because of the following text:
+         * RFC 2960, Section 3.3.7
+         *    If an endpoint receives an ABORT with a format error or for an
+         *    association that doesn't exist, it MUST silently discard it.
+         * Becasue the length is "invalid", we can't really discard just
+         * as we do not know its true length.  So, to be safe, discard the
+         * packet.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Stop the T2-shutdown timer. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        /* Stop the T5-shutdown guard timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        return sctp_sf_do_9_1_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Process an ABORT.  (SHUTDOWN-ACK-SENT state)
+ *
+ * See sctp_sf_do_9_1_abort().
+ */
+sctp_disposition_t sctp_sf_shutdown_ack_sent_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* The same T2 timer, so we should be able to use
+         * common function with the SHUTDOWN-SENT state.
+         */
+        return sctp_sf_shutdown_sent_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Handle an Error received in COOKIE_ECHOED state.
+ *
+ * Only handle the error type of stale COOKIE Error, the other errors will
+ * be ignored.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_cookie_echoed_err(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        sctp_errhdr_t *err;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ERROR chunk has a valid length.
+         * The parameter walking depends on this as well.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_operr_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* Process the error here */
+        /* FUTURE FIXME:  When PR-SCTP related and other optional
+         * parms are emitted, this will have to change to handle multiple
+         * errors.
+         */
+        sctp_walk_errors(err, chunk->chunk_hdr) {
+                if (SCTP_ERROR_STALE_COOKIE == err->cause)
+                        return sctp_sf_do_5_2_6_stale(ep, asoc, type, 
+                                                        arg, commands);
+        }
+
+        /* It is possible to have malformed error causes, and that
+         * will cause us to end the walk early.  However, since
+         * we are discarding the packet, there should be no adverse
+         * affects.
+         */
+        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Handle a Stale COOKIE Error
+ *
+ * Section: 5.2.6 Handle Stale COOKIE Error
+ * If the association is in the COOKIE-ECHOED state, the endpoint may elect
+ * one of the following three alternatives.
+ * ...
+ * 3) Send a new INIT chunk to the endpoint, adding a Cookie
+ *    Preservative parameter requesting an extension to the lifetime of
+ *    the State Cookie. When calculating the time extension, an
+ *    implementation SHOULD use the RTT information measured based on the
+ *    previous COOKIE ECHO / ERROR exchange, and should add no more
+ *    than 1 second beyond the measured RTT, due to long State Cookie
+ *    lifetimes making the endpoint more subject to a replay attack.
+ *
+ * Verification Tag:  Not explicit, but safe to ignore.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+static sctp_disposition_t sctp_sf_do_5_2_6_stale(const struct sctp_endpoint *ep,
+                                                 const struct sctp_association *asoc,
+                                                 const sctp_subtype_t type,
+                                                 void *arg,
+                                                 sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        time_t stale;
+        sctp_cookie_preserve_param_t bht;
+        sctp_errhdr_t *err;
+        struct sctp_chunk *reply;
+        struct sctp_bind_addr *bp;
+        int attempts;
+
+        attempts = asoc->counters[SCTP_COUNTER_INIT_ERROR] + 1;
+
+        if (attempts >= asoc->max_init_attempts) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
+                                SCTP_U32(SCTP_ERROR_STALE_COOKIE));
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        err = (sctp_errhdr_t *)(chunk->skb->data);
+
+        /* When calculating the time extension, an implementation
+         * SHOULD use the RTT information measured based on the
+         * previous COOKIE ECHO / ERROR exchange, and should add no
+         * more than 1 second beyond the measured RTT, due to long
+         * State Cookie lifetimes making the endpoint more subject to
+         * a replay attack.
+         * Measure of Staleness's unit is usec. (1/1000000 sec)
+         * Suggested Cookie Life-span Increment's unit is msec.
+         * (1/1000 sec)
+         * In general, if you use the suggested cookie life, the value
+         * found in the field of measure of staleness should be doubled
+         * to give ample time to retransmit the new cookie and thus
+         * yield a higher probability of success on the reattempt.
+         */
+        stale = ntohl(*(suseconds_t *)((u8 *)err + sizeof(sctp_errhdr_t)));
+        stale = (stale * 2) / 1000;
+
+        bht.param_hdr.type = SCTP_PARAM_COOKIE_PRESERVATIVE;
+        bht.param_hdr.length = htons(sizeof(bht));
+        bht.lifespan_increment = htonl(stale);
+
+        /* Build that new INIT chunk.  */
+        bp = (struct sctp_bind_addr *) &asoc->base.bind_addr;
+        reply = sctp_make_init(asoc, bp, GFP_ATOMIC, sizeof(bht));
+        if (!reply)
+                goto nomem;
+
+        sctp_addto_chunk(reply, sizeof(bht), &bht);
+
+        /* Clear peer's init_tag cached in assoc as we are sending a new INIT */
+        sctp_add_cmd_sf(commands, SCTP_CMD_CLEAR_INIT_TAG, SCTP_NULL());
+
+        /* Stop pending T3-rtx and heartbeat timers */
+        sctp_add_cmd_sf(commands, SCTP_CMD_T3_RTX_TIMERS_STOP, SCTP_NULL());
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
+
+        /* Delete non-primary peer ip addresses since we are transitioning
+         * back to the COOKIE-WAIT state
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_DEL_NON_PRIMARY, SCTP_NULL());
+
+        /* If we've sent any data bundled with COOKIE-ECHO we will need to 
+         * resend 
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_RETRAN, 
+                        SCTP_TRANSPORT(asoc->peer.primary_path));
+
+        /* Cast away the const modifier, as we want to just
+         * rerun it through as a sideffect.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_COUNTER_INC,
+                        SCTP_COUNTER(SCTP_COUNTER_INIT_ERROR));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_COOKIE_WAIT));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Process an ABORT.
+ *
+ * Section: 9.1
+ * After checking the Verification Tag, the receiving endpoint shall
+ * remove the association from its record, and shall report the
+ * termination to its upper layer.
+ *
+ * Verification Tag: 8.5.1 Exceptions in Verification Tag Rules
+ * B) Rules for packet carrying ABORT:
+ *
+ *  - The endpoint shall always fill in the Verification Tag field of the
+ *    outbound packet with the destination endpoint's tag value if it
+ *    is known.
+ *
+ *  - If the ABORT is sent in response to an OOTB packet, the endpoint
+ *    MUST follow the procedure described in Section 8.4.
+ *
+ *  - The receiver MUST accept the packet if the Verification Tag
+ *    matches either its own tag, OR the tag of its peer. Otherwise, the
+ *    receiver MUST silently discard the packet and take no further
+ *    action.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_9_1_abort(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        unsigned len;
+        __u16 error = SCTP_ERROR_NO_ERROR;
+
+        if (!sctp_vtag_verify_either(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ABORT chunk has a valid length.
+         * Since this is an ABORT chunk, we have to discard it
+         * because of the following text:
+         * RFC 2960, Section 3.3.7
+         *    If an endpoint receives an ABORT with a format error or for an
+         *    association that doesn't exist, it MUST silently discard it.
+         * Becasue the length is "invalid", we can't really discard just
+         * as we do not know its true length.  So, to be safe, discard the
+         * packet.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* See if we have an error cause code in the chunk.  */
+        len = ntohs(chunk->chunk_hdr->length);
+        if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr))
+                error = ((sctp_errhdr_t *)chunk->skb->data)->cause;
+
+        /* ASSOC_FAILED will DELETE_TCB. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED, SCTP_U32(error));
+        SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+        SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+
+        return SCTP_DISPOSITION_ABORT;
+}
+
+/*
+ * Process an ABORT.  (COOKIE-WAIT state)
+ *
+ * See sctp_sf_do_9_1_abort() above.
+ */
+sctp_disposition_t sctp_sf_cookie_wait_abort(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        unsigned len;
+        __u16 error = SCTP_ERROR_NO_ERROR;
+
+        if (!sctp_vtag_verify_either(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ABORT chunk has a valid length.
+         * Since this is an ABORT chunk, we have to discard it
+         * because of the following text:
+         * RFC 2960, Section 3.3.7
+         *    If an endpoint receives an ABORT with a format error or for an
+         *    association that doesn't exist, it MUST silently discard it.
+         * Becasue the length is "invalid", we can't really discard just
+         * as we do not know its true length.  So, to be safe, discard the
+         * packet.
+         */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_abort_chunk_t)))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* See if we have an error cause code in the chunk.  */
+        len = ntohs(chunk->chunk_hdr->length);
+        if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr))
+                error = ((sctp_errhdr_t *)chunk->skb->data)->cause;
+
+        sctp_stop_t1_and_abort(commands, error);
+        return SCTP_DISPOSITION_ABORT;
+}
+
+/*
+ * Process an incoming ICMP as an ABORT.  (COOKIE-WAIT state)
+ */
+sctp_disposition_t sctp_sf_cookie_wait_icmp_abort(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        sctp_stop_t1_and_abort(commands, SCTP_ERROR_NO_ERROR);
+        return SCTP_DISPOSITION_ABORT;
+}
+
+/*
+ * Process an ABORT.  (COOKIE-ECHOED state)
+ */
+sctp_disposition_t sctp_sf_cookie_echoed_abort(const struct sctp_endpoint *ep,
+                                               const struct sctp_association *asoc,
+                                               const sctp_subtype_t type,
+                                               void *arg,
+                                               sctp_cmd_seq_t *commands)
+{
+        /* There is a single T1 timer, so we should be able to use
+         * common function with the COOKIE-WAIT state.
+         */
+        return sctp_sf_cookie_wait_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Stop T1 timer and abort association with "INIT failed".
+ *
+ * This is common code called by several sctp_sf_*_abort() functions above.
+ */
+void sctp_stop_t1_and_abort(sctp_cmd_seq_t *commands, __u16 error)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+        SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+        /* CMD_INIT_FAILED will DELETE_TCB. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
+                        SCTP_U32(error));
+}
+
+/*
+ * sctp_sf_do_9_2_shut
+ *
+ * Section: 9.2
+ * Upon the reception of the SHUTDOWN, the peer endpoint shall
+ *  - enter the SHUTDOWN-RECEIVED state,
+ *
+ *  - stop accepting new data from its SCTP user
+ *
+ *  - verify, by checking the Cumulative TSN Ack field of the chunk,
+ *    that all its outstanding DATA chunks have been received by the
+ *    SHUTDOWN sender.
+ *
+ * Once an endpoint as reached the SHUTDOWN-RECEIVED state it MUST NOT
+ * send a SHUTDOWN in response to a ULP request. And should discard
+ * subsequent SHUTDOWN chunks.
+ *
+ * If there are still outstanding DATA chunks left, the SHUTDOWN
+ * receiver shall continue to follow normal data transmission
+ * procedures defined in Section 6 until all outstanding DATA chunks
+ * are acknowledged; however, the SHUTDOWN receiver MUST NOT accept
+ * new data from its SCTP user.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_9_2_shutdown(const struct sctp_endpoint *ep,
+                                           const struct sctp_association *asoc,
+                                           const sctp_subtype_t type,
+                                           void *arg,
+                                           sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        sctp_shutdownhdr_t *sdh;
+        sctp_disposition_t disposition;
+        struct sctp_ulpevent *ev;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the SHUTDOWN chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk,
+                                      sizeof(struct sctp_shutdown_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* Convert the elaborate header.  */
+        sdh = (sctp_shutdownhdr_t *)chunk->skb->data;
+        skb_pull(chunk->skb, sizeof(sctp_shutdownhdr_t));
+        chunk->subh.shutdown_hdr = sdh;
+
+        /* Upon the reception of the SHUTDOWN, the peer endpoint shall
+         *  - enter the SHUTDOWN-RECEIVED state,
+         *  - stop accepting new data from its SCTP user
+         *
+         * [This is implicit in the new state.]
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_SHUTDOWN_RECEIVED));
+        disposition = SCTP_DISPOSITION_CONSUME;
+
+        if (sctp_outq_is_empty(&asoc->outqueue)) {
+                disposition = sctp_sf_do_9_2_shutdown_ack(ep, asoc, type,
+                                                          arg, commands);
+        }
+
+        if (SCTP_DISPOSITION_NOMEM == disposition)
+                goto out;
+
+        /*  - verify, by checking the Cumulative TSN Ack field of the
+         *    chunk, that all its outstanding DATA chunks have been
+         *    received by the SHUTDOWN sender.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_CTSN,
+                        SCTP_U32(chunk->subh.shutdown_hdr->cum_tsn_ack));
+
+        /* API 5.3.1.5 SCTP_SHUTDOWN_EVENT
+         * When a peer sends a SHUTDOWN, SCTP delivers this notification to
+         * inform the application that it should cease sending data.
+         */
+        ev = sctp_ulpevent_make_shutdown_event(asoc, 0, GFP_ATOMIC);
+        if (!ev) {
+                disposition = SCTP_DISPOSITION_NOMEM;
+                goto out;       
+        }
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+out:
+        return disposition;
+}
+
+/* RFC 2960 9.2
+ * If an endpoint is in SHUTDOWN-ACK-SENT state and receives an INIT chunk
+ * (e.g., if the SHUTDOWN COMPLETE was lost) with source and destination
+ * transport addresses (either in the IP addresses or in the INIT chunk)
+ * that belong to this association, it should discard the INIT chunk and
+ * retransmit the SHUTDOWN ACK chunk.
+ */
+sctp_disposition_t sctp_sf_do_9_2_reshutack(const struct sctp_endpoint *ep,
+                                    const struct sctp_association *asoc,
+                                    const sctp_subtype_t type,
+                                    void *arg,
+                                    sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = (struct sctp_chunk *) arg;
+        struct sctp_chunk *reply;
+
+        /* Since we are not going to really process this INIT, there
+         * is no point in verifying chunk boundries.  Just generate
+         * the SHUTDOWN ACK.
+         */
+        reply = sctp_make_shutdown_ack(asoc, chunk);
+        if (NULL == reply)
+                goto nomem;
+
+        /* Set the transport for the SHUTDOWN ACK chunk and the timeout for
+         * the T2-SHUTDOWN timer.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
+
+        /* and restart the T2-shutdown timer. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+
+        return SCTP_DISPOSITION_CONSUME;
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * sctp_sf_do_ecn_cwr
+ *
+ * Section:  Appendix A: Explicit Congestion Notification
+ *
+ * CWR:
+ *
+ * RFC 2481 details a specific bit for a sender to send in the header of
+ * its next outbound TCP segment to indicate to its peer that it has
+ * reduced its congestion window.  This is termed the CWR bit.  For
+ * SCTP the same indication is made by including the CWR chunk.
+ * This chunk contains one data element, i.e. the TSN number that
+ * was sent in the ECNE chunk.  This element represents the lowest
+ * TSN number in the datagram that was originally marked with the
+ * CE bit.
+ *
+ * Verification Tag: 8.5 Verification Tag [Normal verification]
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_ecn_cwr(const struct sctp_endpoint *ep,
+                                      const struct sctp_association *asoc,
+                                      const sctp_subtype_t type,
+                                      void *arg,
+                                      sctp_cmd_seq_t *commands)
+{
+        sctp_cwrhdr_t *cwr;
+        struct sctp_chunk *chunk = arg;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_ecne_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+                
+        cwr = (sctp_cwrhdr_t *) chunk->skb->data;
+        skb_pull(chunk->skb, sizeof(sctp_cwrhdr_t));
+
+        cwr->lowest_tsn = ntohl(cwr->lowest_tsn);
+
+        /* Does this CWR ack the last sent congestion notification? */
+        if (TSN_lte(asoc->last_ecne_tsn, cwr->lowest_tsn)) {
+                /* Stop sending ECNE. */
+                sctp_add_cmd_sf(commands,
+                                SCTP_CMD_ECN_CWR,
+                                SCTP_U32(cwr->lowest_tsn));
+        }
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * sctp_sf_do_ecne
+ *
+ * Section:  Appendix A: Explicit Congestion Notification
+ *
+ * ECN-Echo
+ *
+ * RFC 2481 details a specific bit for a receiver to send back in its
+ * TCP acknowledgements to notify the sender of the Congestion
+ * Experienced (CE) bit having arrived from the network.  For SCTP this
+ * same indication is made by including the ECNE chunk.  This chunk
+ * contains one data element, i.e. the lowest TSN associated with the IP
+ * datagram marked with the CE bit.....
+ *
+ * Verification Tag: 8.5 Verification Tag [Normal verification]
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_ecne(const struct sctp_endpoint *ep,
+                                   const struct sctp_association *asoc,
+                                   const sctp_subtype_t type,
+                                   void *arg,
+                                   sctp_cmd_seq_t *commands)
+{
+        sctp_ecnehdr_t *ecne;
+        struct sctp_chunk *chunk = arg;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_ecne_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        ecne = (sctp_ecnehdr_t *) chunk->skb->data;
+        skb_pull(chunk->skb, sizeof(sctp_ecnehdr_t));
+
+        /* If this is a newer ECNE than the last CWR packet we sent out */
+        sctp_add_cmd_sf(commands, SCTP_CMD_ECN_ECNE,
+                        SCTP_U32(ntohl(ecne->lowest_tsn)));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Section: 6.2  Acknowledgement on Reception of DATA Chunks
+ *
+ * The SCTP endpoint MUST always acknowledge the reception of each valid
+ * DATA chunk.
+ *
+ * The guidelines on delayed acknowledgement algorithm specified in
+ * Section 4.2 of [RFC2581] SHOULD be followed. Specifically, an
+ * acknowledgement SHOULD be generated for at least every second packet
+ * (not every second DATA chunk) received, and SHOULD be generated within
+ * 200 ms of the arrival of any unacknowledged DATA chunk. In some
+ * situations it may be beneficial for an SCTP transmitter to be more
+ * conservative than the algorithms detailed in this document allow.
+ * However, an SCTP transmitter MUST NOT be more aggressive than the
+ * following algorithms allow.
+ *
+ * A SCTP receiver MUST NOT generate more than one SACK for every
+ * incoming packet, other than to update the offered window as the
+ * receiving application consumes new data.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_eat_data_6_2(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        int error;
+
+        if (!sctp_vtag_verify(chunk, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_data_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        error = sctp_eat_data(asoc, chunk, commands );
+        switch (error) {
+        case SCTP_IERROR_NO_ERROR:
+                break;
+        case SCTP_IERROR_HIGH_TSN:
+        case SCTP_IERROR_BAD_STREAM:
+                goto discard_noforce;
+        case SCTP_IERROR_DUP_TSN:
+        case SCTP_IERROR_IGNORE_TSN:
+                goto discard_force;
+        case SCTP_IERROR_NO_DATA:
+                goto consume;
+        default:
+                BUG();
+        }
+
+        if (asoc->autoclose) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+        }
+
+        /* If this is the last chunk in a packet, we need to count it
+         * toward sack generation.  Note that we need to SACK every
+         * OTHER packet containing data chunks, EVEN IF WE DISCARD
+         * THEM.  We elect to NOT generate SACK's if the chunk fails
+         * the verification tag test.
+         *
+         * RFC 2960 6.2 Acknowledgement on Reception of DATA Chunks
+         *
+         * The SCTP endpoint MUST always acknowledge the reception of
+         * each valid DATA chunk.
+         *
+         * The guidelines on delayed acknowledgement algorithm
+         * specified in  Section 4.2 of [RFC2581] SHOULD be followed.
+         * Specifically, an acknowledgement SHOULD be generated for at
+         * least every second packet (not every second DATA chunk)
+         * received, and SHOULD be generated within 200 ms of the
+         * arrival of any unacknowledged DATA chunk.  In some
+         * situations it may be beneficial for an SCTP transmitter to
+         * be more conservative than the algorithms detailed in this
+         * document allow. However, an SCTP transmitter MUST NOT be
+         * more aggressive than the following algorithms allow.
+         */
+        if (chunk->end_of_packet) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
+
+                /* Start the SACK timer.  */
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
+        }
+
+        return SCTP_DISPOSITION_CONSUME;
+
+discard_force:
+        /* RFC 2960 6.2 Acknowledgement on Reception of DATA Chunks
+         *
+         * When a packet arrives with duplicate DATA chunk(s) and with
+         * no new DATA chunk(s), the endpoint MUST immediately send a
+         * SACK with no delay.  If a packet arrives with duplicate
+         * DATA chunk(s) bundled with new DATA chunks, the endpoint
+         * MAY immediately send a SACK.  Normally receipt of duplicate
+         * DATA chunks will occur when the original SACK chunk was lost
+         * and the peer's RTO has expired.  The duplicate TSN number(s)
+         * SHOULD be reported in the SACK as duplicate.
+         */
+        /* In our case, we split the MAY SACK advice up whether or not
+         * the last chunk is a duplicate.'
+         */
+        if (chunk->end_of_packet)
+                sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
+        return SCTP_DISPOSITION_DISCARD;
+
+discard_noforce:
+        if (chunk->end_of_packet) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
+
+                /* Start the SACK timer.  */
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
+        }
+        return SCTP_DISPOSITION_DISCARD;
+consume:
+        return SCTP_DISPOSITION_CONSUME;
+        
+}
+
+/*
+ * sctp_sf_eat_data_fast_4_4
+ *
+ * Section: 4 (4)
+ * (4) In SHUTDOWN-SENT state the endpoint MUST acknowledge any received
+ *    DATA chunks without delay.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_eat_data_fast_4_4(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        int error;
+
+        if (!sctp_vtag_verify(chunk, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_data_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        error = sctp_eat_data(asoc, chunk, commands );
+        switch (error) {
+        case SCTP_IERROR_NO_ERROR:
+        case SCTP_IERROR_HIGH_TSN:
+        case SCTP_IERROR_DUP_TSN:
+        case SCTP_IERROR_IGNORE_TSN:
+        case SCTP_IERROR_BAD_STREAM:
+                break;
+        case SCTP_IERROR_NO_DATA:
+                goto consume;
+        default:
+                BUG();
+        }
+
+        /* Go a head and force a SACK, since we are shutting down. */
+
+        /* Implementor's Guide.
+         *
+         * While in SHUTDOWN-SENT state, the SHUTDOWN sender MUST immediately
+         * respond to each received packet containing one or more DATA chunk(s)
+         * with a SACK, a SHUTDOWN chunk, and restart the T2-shutdown timer
+         */
+        if (chunk->end_of_packet) {
+                /* We must delay the chunk creation since the cumulative
+                 * TSN has not been updated yet.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SHUTDOWN, SCTP_NULL());
+                sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+        }
+
+consume:
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Section: 6.2  Processing a Received SACK
+ * D) Any time a SACK arrives, the endpoint performs the following:
+ *
+ *     i) If Cumulative TSN Ack is less than the Cumulative TSN Ack Point,
+ *     then drop the SACK.   Since Cumulative TSN Ack is monotonically
+ *     increasing, a SACK whose Cumulative TSN Ack is less than the
+ *     Cumulative TSN Ack Point indicates an out-of-order SACK.
+ *
+ *     ii) Set rwnd equal to the newly received a_rwnd minus the number
+ *     of bytes still outstanding after processing the Cumulative TSN Ack
+ *     and the Gap Ack Blocks.
+ *
+ *     iii) If the SACK is missing a TSN that was previously
+ *     acknowledged via a Gap Ack Block (e.g., the data receiver
+ *     reneged on the data), then mark the corresponding DATA chunk
+ *     as available for retransmit:  Mark it as missing for fast
+ *     retransmit as described in Section 7.2.4 and if no retransmit
+ *     timer is running for the destination address to which the DATA
+ *     chunk was originally transmitted, then T3-rtx is started for
+ *     that destination address.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_eat_sack_6_2(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        sctp_sackhdr_t *sackh;
+        __u32 ctsn;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the SACK chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_sack_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* Pull the SACK chunk from the data buffer */
+        sackh = sctp_sm_pull_sack(chunk);
+        /* Was this a bogus SACK? */
+        if (!sackh)
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        chunk->subh.sack_hdr = sackh;
+        ctsn = ntohl(sackh->cum_tsn_ack);
+
+        /* i) If Cumulative TSN Ack is less than the Cumulative TSN
+         *     Ack Point, then drop the SACK.  Since Cumulative TSN
+         *     Ack is monotonically increasing, a SACK whose
+         *     Cumulative TSN Ack is less than the Cumulative TSN Ack
+         *     Point indicates an out-of-order SACK.
+         */
+        if (TSN_lt(ctsn, asoc->ctsn_ack_point)) {
+                SCTP_DEBUG_PRINTK("ctsn %x\n", ctsn);
+                SCTP_DEBUG_PRINTK("ctsn_ack_point %x\n", asoc->ctsn_ack_point);
+                return SCTP_DISPOSITION_DISCARD;
+        }
+
+        /* Return this SACK for further processing.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK, SCTP_SACKH(sackh));
+
+        /* Note: We do the rest of the work on the PROCESS_SACK
+         * sideeffect.
+         */
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Generate an ABORT in response to a packet.
+ *
+ * Section: 8.4 Handle "Out of the blue" Packets
+ *
+ * 8) The receiver should respond to the sender of the OOTB packet
+ *    with an ABORT.  When sending the ABORT, the receiver of the
+ *    OOTB packet MUST fill in the Verification Tag field of the
+ *    outbound packet with the value found in the Verification Tag
+ *    field of the OOTB packet and set the T-bit in the Chunk Flags
+ *    to indicate that no TCB was found.  After sending this ABORT,
+ *    the receiver of the OOTB packet shall discard the OOTB packet
+ *    and take no further action.
+ *
+ * Verification Tag:
+ *
+ * The return value is the disposition of the chunk.
+*/
+sctp_disposition_t sctp_sf_tabort_8_4_8(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_packet *packet = NULL;
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *abort;
+
+        packet = sctp_ootb_pkt_new(asoc, chunk);
+
+        if (packet) {
+                /* Make an ABORT. The T bit will be set if the asoc
+                 * is NULL.
+                 */
+                abort = sctp_make_abort(asoc, chunk, 0);
+                if (!abort) {
+                        sctp_ootb_pkt_free(packet);
+                        return SCTP_DISPOSITION_NOMEM;
+                }
+
+                /* Set the skb to the belonging sock for accounting.  */
+                abort->skb->sk = ep->base.sk;
+
+                sctp_packet_append_chunk(packet, abort);
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                SCTP_PACKET(packet));
+
+                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+
+                return SCTP_DISPOSITION_CONSUME;
+        }
+
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Received an ERROR chunk from peer.  Generate SCTP_REMOTE_ERROR
+ * event as ULP notification for each cause included in the chunk.
+ *
+ * API 5.3.1.3 - SCTP_REMOTE_ERROR
+ *
+ * The return value is the disposition of the chunk.
+*/
+sctp_disposition_t sctp_sf_operr_notify(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_ulpevent *ev;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the ERROR chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_operr_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        while (chunk->chunk_end > chunk->skb->data) {
+                ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,
+                                                     GFP_ATOMIC);
+                if (!ev)
+                        goto nomem;
+
+                if (!sctp_add_cmd(commands, SCTP_CMD_EVENT_ULP,
+                                  SCTP_ULPEVENT(ev))) {
+                        sctp_ulpevent_free(ev);
+                        goto nomem;
+                }
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_OPERR,
+                                SCTP_CHUNK(chunk));     
+        }
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Process an inbound SHUTDOWN ACK.
+ *
+ * From Section 9.2:
+ * Upon the receipt of the SHUTDOWN ACK, the SHUTDOWN sender shall
+ * stop the T2-shutdown timer, send a SHUTDOWN COMPLETE chunk to its
+ * peer, and remove all record of the association.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_9_2_final(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *reply;
+        struct sctp_ulpevent *ev;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the SHUTDOWN_ACK chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        /* 10.2 H) SHUTDOWN COMPLETE notification
+         *
+         * When SCTP completes the shutdown procedures (section 9.2) this
+         * notification is passed to the upper layer.
+         */
+        ev = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_SHUTDOWN_COMP,
+                                             0, 0, 0, GFP_ATOMIC);
+        if (!ev)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
+
+        /* Upon the receipt of the SHUTDOWN ACK, the SHUTDOWN sender shall
+         * stop the T2-shutdown timer,
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        /* ...send a SHUTDOWN COMPLETE chunk to its peer, */
+        reply = sctp_make_shutdown_complete(asoc, chunk);
+        if (!reply)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+        SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
+        SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+
+        /* ...and remove all record of the association. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+        return SCTP_DISPOSITION_DELETE_TCB;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * RFC 2960, 8.4 - Handle "Out of the blue" Packets
+ * 5) If the packet contains a SHUTDOWN ACK chunk, the receiver should
+ *    respond to the sender of the OOTB packet with a SHUTDOWN COMPLETE.
+ *    When sending the SHUTDOWN COMPLETE, the receiver of the OOTB
+ *    packet must fill in the Verification Tag field of the outbound
+ *    packet with the Verification Tag received in the SHUTDOWN ACK and
+ *    set the T-bit in the Chunk Flags to indicate that no TCB was
+ *    found. Otherwise,
+ *
+ * 8) The receiver should respond to the sender of the OOTB packet with
+ *    an ABORT.  When sending the ABORT, the receiver of the OOTB packet
+ *    MUST fill in the Verification Tag field of the outbound packet
+ *    with the value found in the Verification Tag field of the OOTB
+ *    packet and set the T-bit in the Chunk Flags to indicate that no
+ *    TCB was found.  After sending this ABORT, the receiver of the OOTB
+ *    packet shall discard the OOTB packet and take no further action.
+ */
+sctp_disposition_t sctp_sf_ootb(const struct sctp_endpoint *ep,
+                                const struct sctp_association *asoc,
+                                const sctp_subtype_t type,
+                                void *arg,
+                                sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sk_buff *skb = chunk->skb;
+        sctp_chunkhdr_t *ch;
+        __u8 *ch_end;
+        int ootb_shut_ack = 0;
+
+        SCTP_INC_STATS(SCTP_MIB_OUTOFBLUES);
+
+        ch = (sctp_chunkhdr_t *) chunk->chunk_hdr;
+        do {
+                /* Break out if chunk length is less then minimal. */
+                if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
+                        break;
+
+                ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
+
+                if (SCTP_CID_SHUTDOWN_ACK == ch->type)
+                        ootb_shut_ack = 1;
+
+                /* RFC 2960, Section 3.3.7
+                 *   Moreover, under any circumstances, an endpoint that
+                 *   receives an ABORT  MUST NOT respond to that ABORT by
+                 *   sending an ABORT of its own.
+                 */
+                if (SCTP_CID_ABORT == ch->type)
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                        
+                ch = (sctp_chunkhdr_t *) ch_end;
+        } while (ch_end < skb->tail);
+
+        if (ootb_shut_ack)
+                sctp_sf_shut_8_4_5(ep, asoc, type, arg, commands);
+        else
+                sctp_sf_tabort_8_4_8(ep, asoc, type, arg, commands);
+
+        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Handle an "Out of the blue" SHUTDOWN ACK.
+ *
+ * Section: 8.4 5)
+ * 5) If the packet contains a SHUTDOWN ACK chunk, the receiver should
+ *   respond to the sender of the OOTB packet with a SHUTDOWN COMPLETE.
+ *   When sending the SHUTDOWN COMPLETE, the receiver of the OOTB packet
+ *   must fill in the Verification Tag field of the outbound packet with
+ *   the Verification Tag received in the SHUTDOWN ACK and set the
+ *   T-bit in the Chunk Flags to indicate that no TCB was found.
+ *
+ * Inputs
+ * (endpoint, asoc, type, arg, commands)
+ *
+ * Outputs
+ * (sctp_disposition_t)
+ *
+ * The return value is the disposition of the chunk.
+ */
+static sctp_disposition_t sctp_sf_shut_8_4_5(const struct sctp_endpoint *ep,
+                                             const struct sctp_association *asoc,
+                                             const sctp_subtype_t type,
+                                             void *arg,
+                                             sctp_cmd_seq_t *commands)
+{
+        struct sctp_packet *packet = NULL;
+        struct sctp_chunk *chunk = arg;
+        struct sctp_chunk *shut;
+
+        packet = sctp_ootb_pkt_new(asoc, chunk);
+
+        if (packet) {
+                /* Make an SHUTDOWN_COMPLETE.
+                 * The T bit will be set if the asoc is NULL.
+                 */
+                shut = sctp_make_shutdown_complete(asoc, chunk);
+                if (!shut) {
+                        sctp_ootb_pkt_free(packet);
+                        return SCTP_DISPOSITION_NOMEM;
+                }
+
+                /* Set the skb to the belonging sock for accounting.  */
+                shut->skb->sk = ep->base.sk;
+
+                sctp_packet_append_chunk(packet, shut);
+
+                sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                SCTP_PACKET(packet));
+
+                SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+
+                /* If the chunk length is invalid, we don't want to process
+                 * the reset of the packet.
+                 */
+                if (!sctp_chunk_length_valid(chunk, sizeof(sctp_chunkhdr_t)))
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+                return SCTP_DISPOSITION_CONSUME;
+        }
+
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Handle SHUTDOWN ACK in COOKIE_ECHOED or COOKIE_WAIT state.
+ *
+ * Verification Tag:  8.5.1 E) Rules for packet carrying a SHUTDOWN ACK
+ *   If the receiver is in COOKIE-ECHOED or COOKIE-WAIT state the
+ *   procedures in section 8.4 SHOULD be followed, in other words it
+ *   should be treated as an Out Of The Blue packet.
+ *   [This means that we do NOT check the Verification Tag on these
+ *   chunks. --piggy ]
+ *
+ */
+sctp_disposition_t sctp_sf_do_8_5_1_E_sa(const struct sctp_endpoint *ep,
+                                      const struct sctp_association *asoc,
+                                      const sctp_subtype_t type,
+                                      void *arg,
+                                      sctp_cmd_seq_t *commands)
+{
+        /* Although we do have an association in this case, it corresponds
+         * to a restarted association. So the packet is treated as an OOTB
+         * packet and the state function that handles OOTB SHUTDOWN_ACK is
+         * called with a NULL association.
+         */
+        return sctp_sf_shut_8_4_5(ep, NULL, type, arg, commands);
+}
+
+/* ADDIP Section 4.2 Upon reception of an ASCONF Chunk.  */
+sctp_disposition_t sctp_sf_do_asconf(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type, void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk       *chunk = arg;
+        struct sctp_chunk       *asconf_ack = NULL;
+        sctp_addiphdr_t         *hdr;
+        __u32                   serial;
+
+        if (!sctp_vtag_verify(chunk, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        /* Make sure that the ASCONF ADDIP chunk has a valid length.  */
+        if (!sctp_chunk_length_valid(chunk, sizeof(sctp_addip_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        hdr = (sctp_addiphdr_t *)chunk->skb->data;
+        serial = ntohl(hdr->serial);
+
+        /* ADDIP 4.2 C1) Compare the value of the serial number to the value
+         * the endpoint stored in a new association variable
+         * 'Peer-Serial-Number'. 
+         */
+        if (serial == asoc->peer.addip_serial + 1) {
+                /* ADDIP 4.2 C2) If the value found in the serial number is
+                 * equal to the ('Peer-Serial-Number' + 1), the endpoint MUST
+                 * do V1-V5.
+                 */
+                asconf_ack = sctp_process_asconf((struct sctp_association *)
+                                                 asoc, chunk);
+                if (!asconf_ack)
+                        return SCTP_DISPOSITION_NOMEM;
+        } else if (serial == asoc->peer.addip_serial) {
+                /* ADDIP 4.2 C3) If the value found in the serial number is
+                 * equal to the value stored in the 'Peer-Serial-Number'
+                 * IMPLEMENTATION NOTE: As an optimization a receiver may wish
+                 * to save the last ASCONF-ACK for some predetermined period of
+                 * time and instead of re-processing the ASCONF (with the same
+                 * serial number) it may just re-transmit the ASCONF-ACK.
+                 */
+                if (asoc->addip_last_asconf_ack)
+                        asconf_ack = asoc->addip_last_asconf_ack;
+                else
+                        return SCTP_DISPOSITION_DISCARD;
+        } else {
+                /* ADDIP 4.2 C4) Otherwise, the ASCONF Chunk is discarded since 
+                 * it must be either a stale packet or from an attacker.
+                 */     
+                return SCTP_DISPOSITION_DISCARD;
+        }
+
+        /* ADDIP 4.2 C5) In both cases C2 and C3 the ASCONF-ACK MUST be sent
+         * back to the source address contained in the IP header of the ASCONF
+         * being responded to.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(asconf_ack));
+        
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * ADDIP Section 4.3 General rules for address manipulation
+ * When building TLV parameters for the ASCONF Chunk that will add or
+ * delete IP addresses the D0 to D13 rules should be applied:
+ */
+sctp_disposition_t sctp_sf_do_asconf_ack(const struct sctp_endpoint *ep,
+                                         const struct sctp_association *asoc,
+                                         const sctp_subtype_t type, void *arg,
+                                         sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk       *asconf_ack = arg;
+        struct sctp_chunk       *last_asconf = asoc->addip_last_asconf;
+        struct sctp_chunk       *abort;
+        sctp_addiphdr_t         *addip_hdr;
+        __u32                   sent_serial, rcvd_serial;
+
+        if (!sctp_vtag_verify(asconf_ack, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        /* Make sure that the ADDIP chunk has a valid length.  */
+        if (!sctp_chunk_length_valid(asconf_ack, sizeof(sctp_addip_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        addip_hdr = (sctp_addiphdr_t *)asconf_ack->skb->data;
+        rcvd_serial = ntohl(addip_hdr->serial);
+
+        if (last_asconf) {
+                addip_hdr = (sctp_addiphdr_t *)last_asconf->subh.addip_hdr;
+                sent_serial = ntohl(addip_hdr->serial);
+        } else {
+                sent_serial = asoc->addip_serial - 1;
+        }
+
+        /* D0) If an endpoint receives an ASCONF-ACK that is greater than or
+         * equal to the next serial number to be used but no ASCONF chunk is
+         * outstanding the endpoint MUST ABORT the association. Note that a
+         * sequence number is greater than if it is no more than 2^^31-1
+         * larger than the current sequence number (using serial arithmetic).
+         */
+        if (ADDIP_SERIAL_gte(rcvd_serial, sent_serial + 1) &&
+            !(asoc->addip_last_asconf)) {
+                abort = sctp_make_abort(asoc, asconf_ack,
+                                        sizeof(sctp_errhdr_t));
+                if (abort) {
+                        sctp_init_cause(abort, SCTP_ERROR_ASCONF_ACK, NULL, 0);
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(abort));
+                }
+                /* We are going to ABORT, so we might as well stop
+                 * processing the rest of the chunks in the packet.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+                sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_ASCONF_ACK));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_ABORT;
+        }
+
+        if ((rcvd_serial == sent_serial) && asoc->addip_last_asconf) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+
+                if (!sctp_process_asconf_ack((struct sctp_association *)asoc,
+                                             asconf_ack))
+                        return SCTP_DISPOSITION_CONSUME;
+
+                abort = sctp_make_abort(asoc, asconf_ack,
+                                        sizeof(sctp_errhdr_t));
+                if (abort) {
+                        sctp_init_cause(abort, SCTP_ERROR_RSRC_LOW, NULL, 0);
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(abort));
+                }
+                /* We are going to ABORT, so we might as well stop
+                 * processing the rest of the chunks in the packet.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_ASCONF_ACK));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_ABORT;
+        }
+
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/*
+ * PR-SCTP Section 3.6 Receiver Side Implementation of PR-SCTP
+ *
+ * When a FORWARD TSN chunk arrives, the data receiver MUST first update
+ * its cumulative TSN point to the value carried in the FORWARD TSN
+ * chunk, and then MUST further advance its cumulative TSN point locally
+ * if possible.
+ * After the above processing, the data receiver MUST stop reporting any
+ * missing TSNs earlier than or equal to the new cumulative TSN point.
+ *
+ * Verification Tag:  8.5 Verification Tag [Normal verification]
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_eat_fwd_tsn(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const sctp_subtype_t type,
+                                       void *arg,
+                                       sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_fwdtsn_hdr *fwdtsn_hdr;
+        __u16 len;
+        __u32 tsn;
+
+        if (!sctp_vtag_verify(chunk, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        /* Make sure that the FORWARD_TSN chunk has valid length.  */
+        if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_fwdtsn_chunk)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;
+        chunk->subh.fwdtsn_hdr = fwdtsn_hdr;
+        len = ntohs(chunk->chunk_hdr->length);
+        len -= sizeof(struct sctp_chunkhdr);
+        skb_pull(chunk->skb, len);
+
+        tsn = ntohl(fwdtsn_hdr->new_cum_tsn);
+        SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __FUNCTION__, tsn);
+
+        /* The TSN is too high--silently discard the chunk and count on it
+         * getting retransmitted later.
+         */
+        if (sctp_tsnmap_check(&asoc->peer.tsn_map, tsn) < 0)
+                goto discard_noforce;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_FWDTSN, SCTP_U32(tsn));
+        if (len > sizeof(struct sctp_fwdtsn_hdr))
+                sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_FWDTSN, 
+                                SCTP_CHUNK(chunk));
+        
+        /* Count this as receiving DATA. */
+        if (asoc->autoclose) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+        }
+        
+        /* FIXME: For now send a SACK, but DATA processing may
+         * send another. 
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE());
+        /* Start the SACK timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
+
+        return SCTP_DISPOSITION_CONSUME;
+
+discard_noforce:
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+sctp_disposition_t sctp_sf_eat_fwd_tsn_fast(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        struct sctp_fwdtsn_hdr *fwdtsn_hdr;
+        __u16 len;
+        __u32 tsn;
+
+        if (!sctp_vtag_verify(chunk, asoc)) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_BAD_TAG,
+                                SCTP_NULL());
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+        }
+
+        /* Make sure that the FORWARD_TSN chunk has a valid length.  */
+        if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_fwdtsn_chunk)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;
+        chunk->subh.fwdtsn_hdr = fwdtsn_hdr;
+        len = ntohs(chunk->chunk_hdr->length);
+        len -= sizeof(struct sctp_chunkhdr);
+        skb_pull(chunk->skb, len);
+
+        tsn = ntohl(fwdtsn_hdr->new_cum_tsn);
+        SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __FUNCTION__, tsn);
+
+        /* The TSN is too high--silently discard the chunk and count on it
+         * getting retransmitted later.
+         */
+        if (sctp_tsnmap_check(&asoc->peer.tsn_map, tsn) < 0)
+                goto gen_shutdown;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_FWDTSN, SCTP_U32(tsn));
+        if (len > sizeof(struct sctp_fwdtsn_hdr))
+                sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_FWDTSN, 
+                                SCTP_CHUNK(chunk));
+        
+        /* Go a head and force a SACK, since we are shutting down. */
+gen_shutdown:
+        /* Implementor's Guide.
+         *
+         * While in SHUTDOWN-SENT state, the SHUTDOWN sender MUST immediately
+         * respond to each received packet containing one or more DATA chunk(s)
+         * with a SACK, a SHUTDOWN chunk, and restart the T2-shutdown timer
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SHUTDOWN, SCTP_NULL());
+        sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Process an unknown chunk.
+ *
+ * Section: 3.2. Also, 2.1 in the implementor's guide.
+ *
+ * Chunk Types are encoded such that the highest-order two bits specify
+ * the action that must be taken if the processing endpoint does not
+ * recognize the Chunk Type.
+ *
+ * 00 - Stop processing this SCTP packet and discard it, do not process
+ *      any further chunks within it.
+ *
+ * 01 - Stop processing this SCTP packet and discard it, do not process
+ *      any further chunks within it, and report the unrecognized
+ *      chunk in an 'Unrecognized Chunk Type'.
+ *
+ * 10 - Skip this chunk and continue processing.
+ *
+ * 11 - Skip this chunk and continue processing, but report in an ERROR
+ *      Chunk using the 'Unrecognized Chunk Type' cause of error.
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_unk_chunk(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *unk_chunk = arg;
+        struct sctp_chunk *err_chunk;
+        sctp_chunkhdr_t *hdr;
+
+        SCTP_DEBUG_PRINTK("Processing the unknown chunk id %d.\n", type.chunk);
+
+        if (!sctp_vtag_verify(unk_chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the chunk has a valid length.
+         * Since we don't know the chunk type, we use a general
+         * chunkhdr structure to make a comparison.
+         */
+        if (!sctp_chunk_length_valid(unk_chunk, sizeof(sctp_chunkhdr_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        switch (type.chunk & SCTP_CID_ACTION_MASK) {
+        case SCTP_CID_ACTION_DISCARD:
+                /* Discard the packet.  */
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+                break;
+        case SCTP_CID_ACTION_DISCARD_ERR:
+                /* Discard the packet.  */
+                sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+                /* Generate an ERROR chunk as response. */
+                hdr = unk_chunk->chunk_hdr;
+                err_chunk = sctp_make_op_error(asoc, unk_chunk,
+                                               SCTP_ERROR_UNKNOWN_CHUNK, hdr,
+                                               WORD_ROUND(ntohs(hdr->length)));
+                if (err_chunk) {
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(err_chunk));
+                }
+                return SCTP_DISPOSITION_CONSUME;
+                break;
+        case SCTP_CID_ACTION_SKIP:
+                /* Skip the chunk.  */
+                return SCTP_DISPOSITION_DISCARD;
+                break;
+        case SCTP_CID_ACTION_SKIP_ERR:
+                /* Generate an ERROR chunk as response. */
+                hdr = unk_chunk->chunk_hdr;
+                err_chunk = sctp_make_op_error(asoc, unk_chunk,
+                                               SCTP_ERROR_UNKNOWN_CHUNK, hdr,
+                                               WORD_ROUND(ntohs(hdr->length)));
+                if (err_chunk) {
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(err_chunk));
+                }
+                /* Skip the chunk.  */
+                return SCTP_DISPOSITION_CONSUME;
+                break;
+        default:
+                break;
+        }
+
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/*
+ * Discard the chunk.
+ *
+ * Section: 0.2, 5.2.3, 5.2.5, 5.2.6, 6.0, 8.4.6, 8.5.1c, 9.2
+ * [Too numerous to mention...]
+ * Verification Tag: No verification needed.
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_discard_chunk(const struct sctp_endpoint *ep,
+                                         const struct sctp_association *asoc,
+                                         const sctp_subtype_t type,
+                                         void *arg,
+                                         sctp_cmd_seq_t *commands)
+{
+        SCTP_DEBUG_PRINTK("Chunk %d is discarded\n", type.chunk);
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/*
+ * Discard the whole packet.
+ *
+ * Section: 8.4 2)
+ *
+ * 2) If the OOTB packet contains an ABORT chunk, the receiver MUST
+ *    silently discard the OOTB packet and take no further action.
+ *    Otherwise,
+ *
+ * Verification Tag: No verification necessary
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_pdiscard(const struct sctp_endpoint *ep,
+                                    const struct sctp_association *asoc,
+                                    const sctp_subtype_t type,
+                                    void *arg,
+                                    sctp_cmd_seq_t *commands)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+
+/*
+ * The other end is violating protocol.
+ *
+ * Section: Not specified
+ * Verification Tag: Not specified
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (asoc, reply_msg, msg_up, timers, counters)
+ *
+ * We simply tag the chunk as a violation.  The state machine will log
+ * the violation and continue.
+ */
+sctp_disposition_t sctp_sf_violation(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        return SCTP_DISPOSITION_VIOLATION;
+}
+
+
+/*
+ * Handle a protocol violation when the chunk length is invalid.
+ * "Invalid" length is identified as smaller then the minimal length a
+ * given chunk can be.  For example, a SACK chunk has invalid length
+ * if it's length is set to be smaller then the size of sctp_sack_chunk_t.
+ *
+ * We inform the other end by sending an ABORT with a Protocol Violation
+ * error code. 
+ *
+ * Section: Not specified
+ * Verification Tag:  Nothing to do
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * Outputs
+ * (reply_msg, msg_up, counters)
+ *
+ * Generate an  ABORT chunk and terminate the association.
+ */
+sctp_disposition_t sctp_sf_violation_chunklen(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk =  arg;
+        struct sctp_chunk *abort = NULL;
+        char               err_str[]="The following chunk had invalid length:";
+
+        /* Make the abort chunk. */
+        abort = sctp_make_abort_violation(asoc, chunk, err_str,
+                                          sizeof(err_str));
+        if (!abort)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
+        SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+
+        if (asoc->state <= SCTP_STATE_COOKIE_ECHOED) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+                sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
+                                SCTP_U32(SCTP_ERROR_PROTO_VIOLATION));
+        } else {
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_PROTO_VIOLATION));
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+        }
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET, SCTP_NULL());
+
+        SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+        
+        return SCTP_DISPOSITION_ABORT;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/***************************************************************************
+ * These are the state functions for handling primitive (Section 10) events.
+ ***************************************************************************/
+/*
+ * sctp_sf_do_prm_asoc
+ *
+ * Section: 10.1 ULP-to-SCTP
+ * B) Associate
+ *
+ * Format: ASSOCIATE(local SCTP instance name, destination transport addr,
+ * outbound stream count)
+ * -> association id [,destination transport addr list] [,outbound stream
+ * count]
+ *
+ * This primitive allows the upper layer to initiate an association to a
+ * specific peer endpoint.
+ *
+ * The peer endpoint shall be specified by one of the transport addresses
+ * which defines the endpoint (see Section 1.4).  If the local SCTP
+ * instance has not been initialized, the ASSOCIATE is considered an
+ * error.
+ * [This is not relevant for the kernel implementation since we do all
+ * initialization at boot time.  It we hadn't initialized we wouldn't
+ * get anywhere near this code.]
+ *
+ * An association id, which is a local handle to the SCTP association,
+ * will be returned on successful establishment of the association. If
+ * SCTP is not able to open an SCTP association with the peer endpoint,
+ * an error is returned.
+ * [In the kernel implementation, the struct sctp_association needs to
+ * be created BEFORE causing this primitive to run.]
+ *
+ * Other association parameters may be returned, including the
+ * complete destination transport addresses of the peer as well as the
+ * outbound stream count of the local endpoint. One of the transport
+ * address from the returned destination addresses will be selected by
+ * the local endpoint as default primary path for sending SCTP packets
+ * to this peer.  The returned "destination transport addr list" can
+ * be used by the ULP to change the default primary path or to force
+ * sending a packet to a specific transport address.  [All of this
+ * stuff happens when the INIT ACK arrives.  This is a NON-BLOCKING
+ * function.]
+ *
+ * Mandatory attributes:
+ *
+ * o local SCTP instance name - obtained from the INITIALIZE operation.
+ *   [This is the argument asoc.]
+ * o destination transport addr - specified as one of the transport
+ * addresses of the peer endpoint with which the association is to be
+ * established.
+ *  [This is asoc->peer.active_path.]
+ * o outbound stream count - the number of outbound streams the ULP
+ * would like to open towards this peer endpoint.
+ * [BUG: This is not currently implemented.]
+ * Optional attributes:
+ *
+ * None.
+ *
+ * The return value is a disposition.
+ */
+sctp_disposition_t sctp_sf_do_prm_asoc(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const sctp_subtype_t type,
+                                       void *arg,
+                                       sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *repl;
+
+        /* The comment below says that we enter COOKIE-WAIT AFTER
+         * sending the INIT, but that doesn't actually work in our
+         * implementation...
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_COOKIE_WAIT));
+
+        /* RFC 2960 5.1 Normal Establishment of an Association
+         *
+         * A) "A" first sends an INIT chunk to "Z".  In the INIT, "A"
+         * must provide its Verification Tag (Tag_A) in the Initiate
+         * Tag field.  Tag_A SHOULD be a random number in the range of
+         * 1 to 4294967295 (see 5.3.1 for Tag value selection). ...
+         */
+
+        repl = sctp_make_init(asoc, &asoc->base.bind_addr, GFP_ATOMIC, 0);
+        if (!repl)
+                goto nomem;
+
+        /* Cast away the const modifier, as we want to just
+         * rerun it through as a sideffect.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_ASOC,
+                        SCTP_ASOC((struct sctp_association *) asoc));
+
+        /* After sending the INIT, "A" starts the T1-init timer and
+         * enters the COOKIE-WAIT state.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Process the SEND primitive.
+ *
+ * Section: 10.1 ULP-to-SCTP
+ * E) Send
+ *
+ * Format: SEND(association id, buffer address, byte count [,context]
+ *         [,stream id] [,life time] [,destination transport address]
+ *         [,unorder flag] [,no-bundle flag] [,payload protocol-id] )
+ * -> result
+ *
+ * This is the main method to send user data via SCTP.
+ *
+ * Mandatory attributes:
+ *
+ *  o association id - local handle to the SCTP association
+ *
+ *  o buffer address - the location where the user message to be
+ *    transmitted is stored;
+ *
+ *  o byte count - The size of the user data in number of bytes;
+ *
+ * Optional attributes:
+ *
+ *  o context - an optional 32 bit integer that will be carried in the
+ *    sending failure notification to the ULP if the transportation of
+ *    this User Message fails.
+ *
+ *  o stream id - to indicate which stream to send the data on. If not
+ *    specified, stream 0 will be used.
+ *
+ *  o life time - specifies the life time of the user data. The user data
+ *    will not be sent by SCTP after the life time expires. This
+ *    parameter can be used to avoid efforts to transmit stale
+ *    user messages. SCTP notifies the ULP if the data cannot be
+ *    initiated to transport (i.e. sent to the destination via SCTP's
+ *    send primitive) within the life time variable. However, the
+ *    user data will be transmitted if SCTP has attempted to transmit a
+ *    chunk before the life time expired.
+ *
+ *  o destination transport address - specified as one of the destination
+ *    transport addresses of the peer endpoint to which this packet
+ *    should be sent. Whenever possible, SCTP should use this destination
+ *    transport address for sending the packets, instead of the current
+ *    primary path.
+ *
+ *  o unorder flag - this flag, if present, indicates that the user
+ *    would like the data delivered in an unordered fashion to the peer
+ *    (i.e., the U flag is set to 1 on all DATA chunks carrying this
+ *    message).
+ *
+ *  o no-bundle flag - instructs SCTP not to bundle this user data with
+ *    other outbound DATA chunks. SCTP MAY still bundle even when
+ *    this flag is present, when faced with network congestion.
+ *
+ *  o payload protocol-id - A 32 bit unsigned integer that is to be
+ *    passed to the peer indicating the type of payload protocol data
+ *    being transmitted. This value is passed as opaque data by SCTP.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_prm_send(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const sctp_subtype_t type,
+                                       void *arg,
+                                       sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Process the SHUTDOWN primitive.
+ *
+ * Section: 10.1:
+ * C) Shutdown
+ *
+ * Format: SHUTDOWN(association id)
+ * -> result
+ *
+ * Gracefully closes an association. Any locally queued user data
+ * will be delivered to the peer. The association will be terminated only
+ * after the peer acknowledges all the SCTP packets sent.  A success code
+ * will be returned on successful termination of the association. If
+ * attempting to terminate the association results in a failure, an error
+ * code shall be returned.
+ *
+ * Mandatory attributes:
+ *
+ *  o association id - local handle to the SCTP association
+ *
+ * Optional attributes:
+ *
+ * None.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_9_2_prm_shutdown(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        int disposition;
+
+        /* From 9.2 Shutdown of an Association
+         * Upon receipt of the SHUTDOWN primitive from its upper
+         * layer, the endpoint enters SHUTDOWN-PENDING state and
+         * remains there until all outstanding data has been
+         * acknowledged by its peer. The endpoint accepts no new data
+         * from its upper layer, but retransmits data to the far end
+         * if necessary to fill gaps.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_SHUTDOWN_PENDING));
+
+        /* sctpimpguide-05 Section 2.12.2
+         * The sender of the SHUTDOWN MAY also start an overall guard timer
+         * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        disposition = SCTP_DISPOSITION_CONSUME;
+        if (sctp_outq_is_empty(&asoc->outqueue)) {
+                disposition = sctp_sf_do_9_2_start_shutdown(ep, asoc, type,
+                                                            arg, commands);
+        }
+        return disposition;
+}
+
+/*
+ * Process the ABORT primitive.
+ *
+ * Section: 10.1:
+ * C) Abort
+ *
+ * Format: Abort(association id [, cause code])
+ * -> result
+ *
+ * Ungracefully closes an association. Any locally queued user data
+ * will be discarded and an ABORT chunk is sent to the peer.  A success code
+ * will be returned on successful abortion of the association. If
+ * attempting to abort the association results in a failure, an error
+ * code shall be returned.
+ *
+ * Mandatory attributes:
+ *
+ *  o association id - local handle to the SCTP association
+ *
+ * Optional attributes:
+ *
+ *  o cause code - reason of the abort to be passed to the peer
+ *
+ * None.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_9_1_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* From 9.1 Abort of an Association
+         * Upon receipt of the ABORT primitive from its upper
+         * layer, the endpoint enters CLOSED state and
+         * discard all outstanding data has been
+         * acknowledged by its peer. The endpoint accepts no new data
+         * from its upper layer, but retransmits data to the far end
+         * if necessary to fill gaps.
+         */
+        struct msghdr *msg = arg;
+        struct sctp_chunk *abort;
+        sctp_disposition_t retval;
+
+        retval = SCTP_DISPOSITION_CONSUME;
+
+        /* Generate ABORT chunk to send the peer.  */
+        abort = sctp_make_abort_user(asoc, NULL, msg);
+        if (!abort)
+                retval = SCTP_DISPOSITION_NOMEM;
+        else
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
+
+        /* Even if we can't send the ABORT due to low memory delete the
+         * TCB.  This is a departure from our typical NOMEM handling.
+         */
+
+        /* Delete the established association. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                        SCTP_U32(SCTP_ERROR_USER_ABORT));
+
+        SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+        SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+
+        return retval;
+}
+
+/* We tried an illegal operation on an association which is closed.  */
+sctp_disposition_t sctp_sf_error_closed(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_ERROR, SCTP_ERROR(-EINVAL));
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/* We tried an illegal operation on an association which is shutting
+ * down.
+ */
+sctp_disposition_t sctp_sf_error_shutdown(const struct sctp_endpoint *ep,
+                                          const struct sctp_association *asoc,
+                                          const sctp_subtype_t type,
+                                          void *arg,
+                                          sctp_cmd_seq_t *commands)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_ERROR,
+                        SCTP_ERROR(-ESHUTDOWN));
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * sctp_cookie_wait_prm_shutdown
+ *
+ * Section: 4 Note: 2
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explicitly address this issue, but is the route through the
+ * state table when someone issues a shutdown while in COOKIE_WAIT state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_cookie_wait_prm_shutdown(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+
+        SCTP_INC_STATS(SCTP_MIB_SHUTDOWNS);
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
+
+        return SCTP_DISPOSITION_DELETE_TCB;
+}
+
+/*
+ * sctp_cookie_echoed_prm_shutdown
+ *
+ * Section: 4 Note: 2
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explcitly address this issue, but is the route through the
+ * state table when someone issues a shutdown while in COOKIE_ECHOED state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_cookie_echoed_prm_shutdown(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg, sctp_cmd_seq_t *commands)
+{
+        /* There is a single T1 timer, so we should be able to use
+         * common function with the COOKIE-WAIT state.
+         */
+        return sctp_sf_cookie_wait_prm_shutdown(ep, asoc, type, arg, commands);
+}
+
+/*
+ * sctp_sf_cookie_wait_prm_abort
+ *
+ * Section: 4 Note: 2
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explicitly address this issue, but is the route through the
+ * state table when someone issues an abort while in COOKIE_WAIT state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_cookie_wait_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct msghdr *msg = arg;
+        struct sctp_chunk *abort;
+        sctp_disposition_t retval;
+
+        /* Stop T1-init timer */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
+        retval = SCTP_DISPOSITION_CONSUME;
+
+        /* Generate ABORT chunk to send the peer */
+        abort = sctp_make_abort_user(asoc, NULL, msg);
+        if (!abort)
+                retval = SCTP_DISPOSITION_NOMEM;
+        else
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_CLOSED));
+
+        SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+
+        /* Even if we can't send the ABORT due to low memory delete the
+         * TCB.  This is a departure from our typical NOMEM handling.
+         */
+
+        /* Delete the established association. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
+                        SCTP_U32(SCTP_ERROR_USER_ABORT));
+
+        return retval;
+}
+
+/*
+ * sctp_sf_cookie_echoed_prm_abort
+ *
+ * Section: 4 Note: 3
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explcitly address this issue, but is the route through the
+ * state table when someone issues an abort while in COOKIE_ECHOED state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_cookie_echoed_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* There is a single T1 timer, so we should be able to use
+         * common function with the COOKIE-WAIT state.
+         */
+        return sctp_sf_cookie_wait_prm_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * sctp_sf_shutdown_pending_prm_abort
+ *
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explicitly address this issue, but is the route through the
+ * state table when someone issues an abort while in SHUTDOWN-PENDING state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_shutdown_pending_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* Stop the T5-shutdown guard timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        return sctp_sf_do_9_1_prm_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * sctp_sf_shutdown_sent_prm_abort
+ *
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explicitly address this issue, but is the route through the
+ * state table when someone issues an abort while in SHUTDOWN-SENT state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_shutdown_sent_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* Stop the T2-shutdown timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        /* Stop the T5-shutdown guard timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+
+        return sctp_sf_do_9_1_prm_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * sctp_sf_cookie_echoed_prm_abort
+ *
+ * Inputs
+ * (endpoint, asoc)
+ *
+ * The RFC does not explcitly address this issue, but is the route through the
+ * state table when someone issues an abort while in COOKIE_ECHOED state.
+ *
+ * Outputs
+ * (timers)
+ */
+sctp_disposition_t sctp_sf_shutdown_ack_sent_prm_abort(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        /* The same T2 timer, so we should be able to use
+         * common function with the SHUTDOWN-SENT state.
+         */
+        return sctp_sf_shutdown_sent_prm_abort(ep, asoc, type, arg, commands);
+}
+
+/*
+ * Process the REQUESTHEARTBEAT primitive
+ *
+ * 10.1 ULP-to-SCTP
+ * J) Request Heartbeat
+ *
+ * Format: REQUESTHEARTBEAT(association id, destination transport address)
+ *
+ * -> result
+ *
+ * Instructs the local endpoint to perform a HeartBeat on the specified
+ * destination transport address of the given association. The returned
+ * result should indicate whether the transmission of the HEARTBEAT
+ * chunk to the destination address is successful.
+ *
+ * Mandatory attributes:
+ *
+ * o association id - local handle to the SCTP association
+ *
+ * o destination transport address - the transport address of the
+ *   association on which a heartbeat should be issued.
+ */
+sctp_disposition_t sctp_sf_do_prm_requestheartbeat(
+                                        const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        return sctp_sf_heartbeat(ep, asoc, type, (struct sctp_transport *)arg,
+                                 commands);
+}
+
+/*
+ * ADDIP Section 4.1 ASCONF Chunk Procedures
+ * When an endpoint has an ASCONF signaled change to be sent to the
+ * remote endpoint it should do A1 to A9
+ */
+sctp_disposition_t sctp_sf_do_prm_asconf(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Ignore the primitive event
+ *
+ * The return value is the disposition of the primitive.
+ */
+sctp_disposition_t sctp_sf_ignore_primitive(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        SCTP_DEBUG_PRINTK("Primitive type %d is ignored.\n", type.primitive);
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/***************************************************************************
+ * These are the state functions for the OTHER events.
+ ***************************************************************************/
+
+/*
+ * Start the shutdown negotiation.
+ *
+ * From Section 9.2:
+ * Once all its outstanding data has been acknowledged, the endpoint
+ * shall send a SHUTDOWN chunk to its peer including in the Cumulative
+ * TSN Ack field the last sequential TSN it has received from the peer.
+ * It shall then start the T2-shutdown timer and enter the SHUTDOWN-SENT
+ * state. If the timer expires, the endpoint must re-send the SHUTDOWN
+ * with the updated last sequential TSN received from its peer.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_9_2_start_shutdown(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *reply;
+
+        /* Once all its outstanding data has been acknowledged, the
+         * endpoint shall send a SHUTDOWN chunk to its peer including
+         * in the Cumulative TSN Ack field the last sequential TSN it
+         * has received from the peer.
+         */
+        reply = sctp_make_shutdown(asoc, NULL);
+        if (!reply)
+                goto nomem;
+
+        /* Set the transport for the SHUTDOWN chunk and the timeout for the
+         * T2-shutdown timer.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
+
+        /* It shall then start the T2-shutdown timer */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        if (asoc->autoclose)
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+
+        /* and enter the SHUTDOWN-SENT state.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_SHUTDOWN_SENT));
+
+        /* sctp-implguide 2.10 Issues with Heartbeating and failover
+         *
+         * HEARTBEAT ... is discontinued after sending either SHUTDOWN
+         * or SHUTDOWN-ACK.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Generate a SHUTDOWN ACK now that everything is SACK'd.
+ *
+ * From Section 9.2:
+ *
+ * If it has no more outstanding DATA chunks, the SHUTDOWN receiver
+ * shall send a SHUTDOWN ACK and start a T2-shutdown timer of its own,
+ * entering the SHUTDOWN-ACK-SENT state. If the timer expires, the
+ * endpoint must re-send the SHUTDOWN ACK.
+ *
+ * The return value is the disposition.
+ */
+sctp_disposition_t sctp_sf_do_9_2_shutdown_ack(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = (struct sctp_chunk *) arg;
+        struct sctp_chunk *reply;
+
+        /* There are 2 ways of getting here:
+         *    1) called in response to a SHUTDOWN chunk
+         *    2) called when SCTP_EVENT_NO_PENDING_TSN event is issued.
+         *
+         * For the case (2), the arg parameter is set to NULL.  We need
+         * to check that we have a chunk before accessing it's fields.
+         */
+        if (chunk) {
+                if (!sctp_vtag_verify(chunk, asoc))
+                        return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+                /* Make sure that the SHUTDOWN chunk has a valid length. */
+                if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_shutdown_chunk_t)))
+                        return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                          commands);
+        }
+
+        /* If it has no more outstanding DATA chunks, the SHUTDOWN receiver
+         * shall send a SHUTDOWN ACK ...
+         */
+        reply = sctp_make_shutdown_ack(asoc, chunk);
+        if (!reply)
+                goto nomem;
+
+        /* Set the transport for the SHUTDOWN ACK chunk and the timeout for
+         * the T2-shutdown timer.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
+
+        /* and start/restart a T2-shutdown timer of its own, */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+
+        if (asoc->autoclose)
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_AUTOCLOSE));
+
+        /* Enter the SHUTDOWN-ACK-SENT state.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_SHUTDOWN_ACK_SENT));
+
+        /* sctp-implguide 2.10 Issues with Heartbeating and failover
+         *
+         * HEARTBEAT ... is discontinued after sending either SHUTDOWN
+         * or SHUTDOWN-ACK.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_HB_TIMERS_STOP, SCTP_NULL());
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * Ignore the event defined as other
+ *
+ * The return value is the disposition of the event.
+ */
+sctp_disposition_t sctp_sf_ignore_other(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        SCTP_DEBUG_PRINTK("The event other type %d is ignored\n", type.other);
+        return SCTP_DISPOSITION_DISCARD;
+}
+
+/************************************************************
+ * These are the state functions for handling timeout events.
+ ************************************************************/
+
+/*
+ * RTX Timeout
+ *
+ * Section: 6.3.3 Handle T3-rtx Expiration
+ *
+ * Whenever the retransmission timer T3-rtx expires for a destination
+ * address, do the following:
+ * [See below]
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_do_6_3_3_rtx(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        struct sctp_transport *transport = arg;
+
+        if (asoc->overall_error_count >= asoc->max_retrans) {
+                /* CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_ERROR));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        /* E1) For the destination address for which the timer
+         * expires, adjust its ssthresh with rules defined in Section
+         * 7.2.3 and set the cwnd <- MTU.
+         */
+
+        /* E2) For the destination address for which the timer
+         * expires, set RTO <- RTO * 2 ("back off the timer").  The
+         * maximum value discussed in rule C7 above (RTO.max) may be
+         * used to provide an upper bound to this doubling operation.
+         */
+
+        /* E3) Determine how many of the earliest (i.e., lowest TSN)
+         * outstanding DATA chunks for the address for which the
+         * T3-rtx has expired will fit into a single packet, subject
+         * to the MTU constraint for the path corresponding to the
+         * destination transport address to which the retransmission
+         * is being sent (this may be different from the address for
+         * which the timer expires [see Section 6.4]).  Call this
+         * value K. Bundle and retransmit those K DATA chunks in a
+         * single packet to the destination endpoint.
+         *
+         * Note: Any DATA chunks that were sent to the address for
+         * which the T3-rtx timer expired but did not fit in one MTU
+         * (rule E3 above), should be marked for retransmission and
+         * sent as soon as cwnd allows (normally when a SACK arrives).
+         */
+
+        /* NB: Rules E4 and F1 are implicit in R1.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_RETRAN, SCTP_TRANSPORT(transport));
+
+        /* Do some failure management (Section 8.2). */
+        sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE, SCTP_TRANSPORT(transport));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * Generate delayed SACK on timeout
+ *
+ * Section: 6.2  Acknowledgement on Reception of DATA Chunks
+ *
+ * The guidelines on delayed acknowledgement algorithm specified in
+ * Section 4.2 of [RFC2581] SHOULD be followed.  Specifically, an
+ * acknowledgement SHOULD be generated for at least every second packet
+ * (not every second DATA chunk) received, and SHOULD be generated
+ * within 200 ms of the arrival of any unacknowledged DATA chunk.  In
+ * some situations it may be beneficial for an SCTP transmitter to be
+ * more conservative than the algorithms detailed in this document
+ * allow. However, an SCTP transmitter MUST NOT be more aggressive than
+ * the following algorithms allow.
+ */
+sctp_disposition_t sctp_sf_do_6_2_sack(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const sctp_subtype_t type,
+                                       void *arg,
+                                       sctp_cmd_seq_t *commands)
+{
+        sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_FORCE());
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
+ * sctp_sf_t1_timer_expire
+ *
+ * Section: 4 Note: 2
+ * Verification Tag:
+ * Inputs
+ * (endpoint, asoc)
+ *
+ *  RFC 2960 Section 4 Notes
+ *  2) If the T1-init timer expires, the endpoint MUST retransmit INIT
+ *     and re-start the T1-init timer without changing state.  This MUST
+ *     be repeated up to 'Max.Init.Retransmits' times.  After that, the
+ *     endpoint MUST abort the initialization process and report the
+ *     error to SCTP user.
+ *
+ *   3) If the T1-cookie timer expires, the endpoint MUST retransmit
+ *     COOKIE ECHO and re-start the T1-cookie timer without changing
+ *     state.  This MUST be repeated up to 'Max.Init.Retransmits' times.
+ *     After that, the endpoint MUST abort the initialization process and
+ *     report the error to SCTP user.
+ *
+ * Outputs
+ * (timers, events)
+ *
+ */
+sctp_disposition_t sctp_sf_t1_timer_expire(const struct sctp_endpoint *ep,
+                                           const struct sctp_association *asoc,
+                                           const sctp_subtype_t type,
+                                           void *arg,
+                                           sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *repl;
+        struct sctp_bind_addr *bp;
+        sctp_event_timeout_t timer = (sctp_event_timeout_t) arg;
+        int timeout;
+        int attempts;
+
+        timeout = asoc->timeouts[timer];
+        attempts = asoc->counters[SCTP_COUNTER_INIT_ERROR] + 1;
+        repl = NULL;
+
+        SCTP_DEBUG_PRINTK("Timer T1 expired.\n");
+
+        if (attempts < asoc->max_init_attempts) {
+                switch (timer) {
+                case SCTP_EVENT_TIMEOUT_T1_INIT:
+                        bp = (struct sctp_bind_addr *) &asoc->base.bind_addr;
+                        repl = sctp_make_init(asoc, bp, GFP_ATOMIC, 0);
+                        break;
+
+                case SCTP_EVENT_TIMEOUT_T1_COOKIE:
+                        repl = sctp_make_cookie_echo(asoc, NULL);
+                        break;
+
+                default:
+                        BUG();
+                        break;
+                };
+
+                if (!repl)
+                        goto nomem;
+
+                /* Issue a sideeffect to do the needed accounting. */
+                sctp_add_cmd_sf(commands, SCTP_CMD_INIT_RESTART,
+                                SCTP_TO(timer));
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
+        } else {
+                sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_ERROR));
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/* RFC2960 9.2 If the timer expires, the endpoint must re-send the SHUTDOWN
+ * with the updated last sequential TSN received from its peer.
+ *
+ * An endpoint should limit the number of retransmissions of the
+ * SHUTDOWN chunk to the protocol parameter 'Association.Max.Retrans'.
+ * If this threshold is exceeded the endpoint should destroy the TCB and
+ * MUST report the peer endpoint unreachable to the upper layer (and
+ * thus the association enters the CLOSED state).  The reception of any
+ * packet from its peer (i.e. as the peer sends all of its queued DATA
+ * chunks) should clear the endpoint's retransmission count and restart
+ * the T2-Shutdown timer,  giving its peer ample opportunity to transmit
+ * all of its queued DATA chunks that have not yet been sent.
+ */
+sctp_disposition_t sctp_sf_t2_timer_expire(const struct sctp_endpoint *ep,
+                                           const struct sctp_association *asoc,
+                                           const sctp_subtype_t type,
+                                           void *arg,
+                                           sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *reply = NULL;
+
+        SCTP_DEBUG_PRINTK("Timer T2 expired.\n");
+        if (asoc->overall_error_count >= asoc->max_retrans) {
+                /* Note:  CMD_ASSOC_FAILED calls CMD_DELETE_TCB. */
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_ERROR));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_DELETE_TCB;
+        }
+
+        switch (asoc->state) {
+        case SCTP_STATE_SHUTDOWN_SENT:
+                reply = sctp_make_shutdown(asoc, NULL);
+                break;
+
+        case SCTP_STATE_SHUTDOWN_ACK_SENT:
+                reply = sctp_make_shutdown_ack(asoc, NULL);
+                break;
+
+        default:
+                BUG();
+                break;
+        };
+
+        if (!reply)
+                goto nomem;
+
+        /* Do some failure management (Section 8.2). */
+        sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE,
+                        SCTP_TRANSPORT(asoc->shutdown_last_sent_to));
+
+        /* Set the transport for the SHUTDOWN/ACK chunk and the timeout for
+         * the T2-shutdown timer.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T2, SCTP_CHUNK(reply));
+
+        /* Restart the T2-shutdown timer.  */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+        return SCTP_DISPOSITION_CONSUME;
+
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/*
+ * ADDIP Section 4.1 ASCONF CHunk Procedures
+ * If the T4 RTO timer expires the endpoint should do B1 to B5
+ */
+sctp_disposition_t sctp_sf_t4_timer_expire(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = asoc->addip_last_asconf;
+        struct sctp_transport *transport = chunk->transport;
+
+        /* ADDIP 4.1 B1) Increment the error counters and perform path failure
+         * detection on the appropriate destination address as defined in
+         * RFC2960 [5] section 8.1 and 8.2.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE, SCTP_TRANSPORT(transport));
+
+        /* Reconfig T4 timer and transport. */
+        sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));
+
+        /* ADDIP 4.1 B2) Increment the association error counters and perform
+         * endpoint failure detection on the association as defined in
+         * RFC2960 [5] section 8.1 and 8.2.
+         * association error counter is incremented in SCTP_CMD_STRIKE.
+         */
+        if (asoc->overall_error_count >= asoc->max_retrans) {
+                sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
+                                SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_ERROR));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_INC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_DISPOSITION_ABORT;
+        }
+
+        /* ADDIP 4.1 B3) Back-off the destination address RTO value to which
+         * the ASCONF chunk was sent by doubling the RTO timer value.
+         * This is done in SCTP_CMD_STRIKE.
+         */
+
+        /* ADDIP 4.1 B4) Re-transmit the ASCONF Chunk last sent and if possible
+         * choose an alternate destination address (please refer to RFC2960
+         * [5] section 6.4.1). An endpoint MUST NOT add new parameters to this
+         * chunk, it MUST be the same (including its serial number) as the last 
+         * ASCONF sent.
+         */
+        sctp_chunk_hold(asoc->addip_last_asconf);
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                        SCTP_CHUNK(asoc->addip_last_asconf));
+
+        /* ADDIP 4.1 B5) Restart the T-4 RTO timer. Note that if a different
+         * destination is selected, then the RTO used will be that of the new
+         * destination address.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/* sctpimpguide-05 Section 2.12.2
+ * The sender of the SHUTDOWN MAY also start an overall guard timer
+ * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
+ * At the expiration of this timer the sender SHOULD abort the association
+ * by sending an ABORT chunk.
+ */
+sctp_disposition_t sctp_sf_t5_timer_expire(const struct sctp_endpoint *ep,
+                                           const struct sctp_association *asoc,
+                                           const sctp_subtype_t type,
+                                           void *arg,
+                                           sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *reply = NULL;
+
+        SCTP_DEBUG_PRINTK("Timer T5 expired.\n");
+
+        reply = sctp_make_abort(asoc, NULL, 0);
+        if (!reply)
+                goto nomem;
+
+        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(reply));
+        sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                        SCTP_U32(SCTP_ERROR_NO_ERROR));
+
+        return SCTP_DISPOSITION_DELETE_TCB;
+nomem:
+        return SCTP_DISPOSITION_NOMEM;
+}
+
+/* Handle expiration of AUTOCLOSE timer.  When the autoclose timer expires,
+ * the association is automatically closed by starting the shutdown process.
+ * The work that needs to be done is same as when SHUTDOWN is initiated by
+ * the user.  So this routine looks same as sctp_sf_do_9_2_prm_shutdown().
+ */
+sctp_disposition_t sctp_sf_autoclose_timer_expire(
+        const struct sctp_endpoint *ep,
+        const struct sctp_association *asoc,
+        const sctp_subtype_t type,
+        void *arg,
+        sctp_cmd_seq_t *commands)
+{
+        int disposition;
+
+        /* From 9.2 Shutdown of an Association
+         * Upon receipt of the SHUTDOWN primitive from its upper
+         * layer, the endpoint enters SHUTDOWN-PENDING state and
+         * remains there until all outstanding data has been
+         * acknowledged by its peer. The endpoint accepts no new data
+         * from its upper layer, but retransmits data to the far end
+         * if necessary to fill gaps.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
+                        SCTP_STATE(SCTP_STATE_SHUTDOWN_PENDING));
+
+        /* sctpimpguide-05 Section 2.12.2
+         * The sender of the SHUTDOWN MAY also start an overall guard timer
+         * 'T5-shutdown-guard' to bound the overall time for shutdown sequence.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_START,
+                        SCTP_TO(SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD));
+        disposition = SCTP_DISPOSITION_CONSUME;
+        if (sctp_outq_is_empty(&asoc->outqueue)) {
+                disposition = sctp_sf_do_9_2_start_shutdown(ep, asoc, type,
+                                                            arg, commands);
+        }
+        return disposition;
+}
+
+/*****************************************************************************
+ * These are sa state functions which could apply to all types of events.
+ ****************************************************************************/
+
+/*
+ * This table entry is not implemented.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_not_impl(const struct sctp_endpoint *ep,
+                                    const struct sctp_association *asoc,
+                                    const sctp_subtype_t type,
+                                    void *arg,
+                                    sctp_cmd_seq_t *commands)
+{
+        return SCTP_DISPOSITION_NOT_IMPL;
+}
+
+/*
+ * This table entry represents a bug.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_bug(const struct sctp_endpoint *ep,
+                               const struct sctp_association *asoc,
+                               const sctp_subtype_t type,
+                               void *arg,
+                               sctp_cmd_seq_t *commands)
+{
+        return SCTP_DISPOSITION_BUG;
+}
+
+/*
+ * This table entry represents the firing of a timer in the wrong state.
+ * Since timer deletion cannot be guaranteed a timer 'may' end up firing
+ * when the association is in the wrong state.   This event should
+ * be ignored, so as to prevent any rearming of the timer.
+ *
+ * Inputs
+ * (endpoint, asoc, chunk)
+ *
+ * The return value is the disposition of the chunk.
+ */
+sctp_disposition_t sctp_sf_timer_ignore(const struct sctp_endpoint *ep,
+                                        const struct sctp_association *asoc,
+                                        const sctp_subtype_t type,
+                                        void *arg,
+                                        sctp_cmd_seq_t *commands)
+{
+        SCTP_DEBUG_PRINTK("Timer %d ignored.\n", type.chunk);
+        return SCTP_DISPOSITION_CONSUME;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* Pull the SACK chunk based on the SACK header. */
+static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk)
+{
+        struct sctp_sackhdr *sack;
+        unsigned int len;
+        __u16 num_blocks;
+        __u16 num_dup_tsns;
+
+        /* Protect ourselves from reading too far into
+         * the skb from a bogus sender.
+         */
+        sack = (struct sctp_sackhdr *) chunk->skb->data;
+
+        num_blocks = ntohs(sack->num_gap_ack_blocks);
+        num_dup_tsns = ntohs(sack->num_dup_tsns);
+        len = sizeof(struct sctp_sackhdr);
+        len += (num_blocks + num_dup_tsns) * sizeof(__u32);
+        if (len > chunk->skb->len)
+                return NULL;
+
+        skb_pull(chunk->skb, len);
+
+        return sack;
+}
+
+/* Create an ABORT packet to be sent as a response, with the specified
+ * error causes.
+ */
+static struct sctp_packet *sctp_abort_pkt_new(const struct sctp_endpoint *ep,
+                                  const struct sctp_association *asoc,
+                                  struct sctp_chunk *chunk,
+                                  const void *payload,
+                                  size_t paylen)
+{
+        struct sctp_packet *packet;
+        struct sctp_chunk *abort;
+
+        packet = sctp_ootb_pkt_new(asoc, chunk);
+
+        if (packet) {
+                /* Make an ABORT.
+                 * The T bit will be set if the asoc is NULL.
+                 */
+                abort = sctp_make_abort(asoc, chunk, paylen);
+                if (!abort) {
+                        sctp_ootb_pkt_free(packet);
+                        return NULL;
+                }
+                /* Add specified error causes, i.e., payload, to the
+                 * end of the chunk.
+                 */
+                sctp_addto_chunk(abort, paylen, payload);
+
+                /* Set the skb to the belonging sock for accounting.  */
+                abort->skb->sk = ep->base.sk;
+
+                sctp_packet_append_chunk(packet, abort);
+
+        }
+
+        return packet;
+}
+
+/* Allocate a packet for responding in the OOTB conditions.  */
+static struct sctp_packet *sctp_ootb_pkt_new(const struct sctp_association *asoc,
+                                             const struct sctp_chunk *chunk)
+{
+        struct sctp_packet *packet;
+        struct sctp_transport *transport;
+        __u16 sport;
+        __u16 dport;
+        __u32 vtag;
+
+        /* Get the source and destination port from the inbound packet.  */
+        sport = ntohs(chunk->sctp_hdr->dest);
+        dport = ntohs(chunk->sctp_hdr->source);
+
+        /* The V-tag is going to be the same as the inbound packet if no
+         * association exists, otherwise, use the peer's vtag.
+         */
+        if (asoc) {
+                vtag = asoc->peer.i.init_tag;
+        } else {
+                /* Special case the INIT and stale COOKIE_ECHO as there is no
+                 * vtag yet.
+                 */
+                switch(chunk->chunk_hdr->type) {
+                case SCTP_CID_INIT:
+                {
+                        sctp_init_chunk_t *init;
+
+                        init = (sctp_init_chunk_t *)chunk->chunk_hdr;
+                        vtag = ntohl(init->init_hdr.init_tag);
+                        break;
+                }
+                default:        
+                        vtag = ntohl(chunk->sctp_hdr->vtag);
+                        break;
+                }
+        }
+
+        /* Make a transport for the bucket, Eliza... */
+        transport = sctp_transport_new(sctp_source(chunk), GFP_ATOMIC);
+        if (!transport)
+                goto nomem;
+
+        /* Cache a route for the transport with the chunk's destination as
+         * the source address.
+         */
+        sctp_transport_route(transport, (union sctp_addr *)&chunk->dest,
+                             sctp_sk(sctp_get_ctl_sock()));
+
+        packet = sctp_packet_init(&transport->packet, transport, sport, dport);
+        packet = sctp_packet_config(packet, vtag, 0);
+
+        return packet;
+
+nomem:
+        return NULL;
+}
+
+/* Free the packet allocated earlier for responding in the OOTB condition.  */
+void sctp_ootb_pkt_free(struct sctp_packet *packet)
+{
+        sctp_transport_free(packet->transport);
+}
+
+/* Send a stale cookie error when a invalid COOKIE ECHO chunk is found  */
+static void sctp_send_stale_cookie_err(const struct sctp_endpoint *ep,
+                                       const struct sctp_association *asoc,
+                                       const struct sctp_chunk *chunk,
+                                       sctp_cmd_seq_t *commands,
+                                       struct sctp_chunk *err_chunk)
+{
+        struct sctp_packet *packet;
+
+        if (err_chunk) {
+                packet = sctp_ootb_pkt_new(asoc, chunk);
+                if (packet) {
+                        struct sctp_signed_cookie *cookie;
+
+                        /* Override the OOTB vtag from the cookie. */
+                        cookie = chunk->subh.cookie_hdr;
+                        packet->vtag = cookie->c.peer_vtag;
+                        
+                        /* Set the skb to the belonging sock for accounting. */
+                        err_chunk->skb->sk = ep->base.sk;
+                        sctp_packet_append_chunk(packet, err_chunk);
+                        sctp_add_cmd_sf(commands, SCTP_CMD_SEND_PKT,
+                                        SCTP_PACKET(packet));
+                        SCTP_INC_STATS(SCTP_MIB_OUTCTRLCHUNKS);
+                } else
+                        sctp_chunk_free (err_chunk);
+        }
+}
+
+
+/* Process a data chunk */
+static int sctp_eat_data(const struct sctp_association *asoc,
+                         struct sctp_chunk *chunk,
+                         sctp_cmd_seq_t *commands)
+{
+        sctp_datahdr_t *data_hdr;
+        struct sctp_chunk *err;
+        size_t datalen;
+        sctp_verb_t deliver;
+        int tmp;
+        __u32 tsn;
+
+        data_hdr = chunk->subh.data_hdr = (sctp_datahdr_t *)chunk->skb->data;
+        skb_pull(chunk->skb, sizeof(sctp_datahdr_t));
+
+        tsn = ntohl(data_hdr->tsn);
+        SCTP_DEBUG_PRINTK("eat_data: TSN 0x%x.\n", tsn);
+
+        /* ASSERT:  Now skb->data is really the user data.  */
+
+        /* Process ECN based congestion.
+         *
+         * Since the chunk structure is reused for all chunks within
+         * a packet, we use ecn_ce_done to track if we've already
+         * done CE processing for this packet.
+         *
+         * We need to do ECN processing even if we plan to discard the
+         * chunk later.
+         */
+
+        if (!chunk->ecn_ce_done) {
+                struct sctp_af *af;
+                chunk->ecn_ce_done = 1;
+
+                af = sctp_get_af_specific(
+                        ipver2af(chunk->skb->nh.iph->version));
+
+                if (af && af->is_ce(chunk->skb) && asoc->peer.ecn_capable) {
+                        /* Do real work as sideffect. */
+                        sctp_add_cmd_sf(commands, SCTP_CMD_ECN_CE,
+                                        SCTP_U32(tsn));
+                }
+        }
+
+        tmp = sctp_tsnmap_check(&asoc->peer.tsn_map, tsn);
+        if (tmp < 0) {
+                /* The TSN is too high--silently discard the chunk and
+                 * count on it getting retransmitted later.
+                 */
+                return SCTP_IERROR_HIGH_TSN;
+        } else if (tmp > 0) {
+                /* This is a duplicate.  Record it.  */
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_DUP, SCTP_U32(tsn));
+                return SCTP_IERROR_DUP_TSN;
+        }
+
+        /* This is a new TSN.  */
+
+        /* Discard if there is no room in the receive window.
+         * Actually, allow a little bit of overflow (up to a MTU).
+         */
+        datalen = ntohs(chunk->chunk_hdr->length);
+        datalen -= sizeof(sctp_data_chunk_t);
+
+        deliver = SCTP_CMD_CHUNK_ULP;
+
+        /* Think about partial delivery. */
+        if ((datalen >= asoc->rwnd) && (!asoc->ulpq.pd_mode)) {
+
+                /* Even if we don't accept this chunk there is
+                 * memory pressure.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_PART_DELIVER, SCTP_NULL());
+        }
+
+        /* Spill over rwnd a little bit.  Note: While allowed, this spill over
+         * seems a bit troublesome in that frag_point varies based on
+         * PMTU.  In cases, such as loopback, this might be a rather
+         * large spill over.
+         */
+        if (!asoc->rwnd || asoc->rwnd_over ||
+            (datalen > asoc->rwnd + asoc->frag_point)) {
+
+                /* If this is the next TSN, consider reneging to make
+                 * room.   Note: Playing nice with a confused sender.  A
+                 * malicious sender can still eat up all our buffer
+                 * space and in the future we may want to detect and
+                 * do more drastic reneging.
+                 */
+                if (sctp_tsnmap_has_gap(&asoc->peer.tsn_map) &&
+                    (sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map) + 1) == tsn) {
+                        SCTP_DEBUG_PRINTK("Reneging for tsn:%u\n", tsn);
+                        deliver = SCTP_CMD_RENEGE;
+                } else {
+                        SCTP_DEBUG_PRINTK("Discard tsn: %u len: %Zd, "
+                                          "rwnd: %d\n", tsn, datalen,
+                                          asoc->rwnd);
+                        return SCTP_IERROR_IGNORE_TSN;
+                }
+        }
+
+        /*
+         * Section 3.3.10.9 No User Data (9)
+         *
+         * Cause of error
+         * ---------------
+         * No User Data:  This error cause is returned to the originator of a
+         * DATA chunk if a received DATA chunk has no user data.
+         */
+        if (unlikely(0 == datalen)) {
+                err = sctp_make_abort_no_data(asoc, chunk, tsn);
+                if (err) {
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(err));
+                }
+                /* We are going to ABORT, so we might as well stop
+                 * processing the rest of the chunks in the packet.
+                 */
+                sctp_add_cmd_sf(commands, SCTP_CMD_DISCARD_PACKET,SCTP_NULL());
+                sctp_add_cmd_sf(commands, SCTP_CMD_ASSOC_FAILED,
+                                SCTP_U32(SCTP_ERROR_NO_DATA));
+                SCTP_INC_STATS(SCTP_MIB_ABORTEDS);
+                SCTP_DEC_STATS(SCTP_MIB_CURRESTAB);
+                return SCTP_IERROR_NO_DATA;
+        }
+
+        /* If definately accepting the DATA chunk, record its TSN, otherwise
+         * wait for renege processing.
+         */
+        if (SCTP_CMD_CHUNK_ULP == deliver)
+                sctp_add_cmd_sf(commands, SCTP_CMD_REPORT_TSN, SCTP_U32(tsn));
+
+        /* Note: Some chunks may get overcounted (if we drop) or overcounted
+         * if we renege and the chunk arrives again.
+         */
+        if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
+                SCTP_INC_STATS(SCTP_MIB_INUNORDERCHUNKS);
+        else
+                SCTP_INC_STATS(SCTP_MIB_INORDERCHUNKS);
+
+        /* RFC 2960 6.5 Stream Identifier and Stream Sequence Number
+         *
+         * If an endpoint receive a DATA chunk with an invalid stream
+         * identifier, it shall acknowledge the reception of the DATA chunk
+         * following the normal procedure, immediately send an ERROR chunk
+         * with cause set to "Invalid Stream Identifier" (See Section 3.3.10)
+         * and discard the DATA chunk.
+         */
+        if (ntohs(data_hdr->stream) >= asoc->c.sinit_max_instreams) {
+                err = sctp_make_op_error(asoc, chunk, SCTP_ERROR_INV_STRM,
+                                         &data_hdr->stream,
+                                         sizeof(data_hdr->stream));
+                if (err)
+                        sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+                                        SCTP_CHUNK(err));
+                return SCTP_IERROR_BAD_STREAM;
+        }
+
+        /* Send the data up to the user.  Note:  Schedule  the
+         * SCTP_CMD_CHUNK_ULP cmd before the SCTP_CMD_GEN_SACK, as the SACK
+         * chunk needs the updated rwnd.
+         */
+        sctp_add_cmd_sf(commands, deliver, SCTP_CHUNK(chunk));
+
+        return SCTP_IERROR_NO_ERROR;
+}
diff --git a/net/sctp/sm_statetable.c b/net/sctp/sm_statetable.c
new file mode 100644
index 000000000000..8967846f69e8
--- /dev/null
+++ b/net/sctp/sm_statetable.c
@@ -0,0 +1,1004 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These are the state tables for the SCTP state machine.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/skbuff.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+static const sctp_sm_table_entry_t
+primitive_event_table[SCTP_NUM_PRIMITIVE_TYPES][SCTP_STATE_NUM_STATES];
+static const sctp_sm_table_entry_t
+other_event_table[SCTP_NUM_OTHER_TYPES][SCTP_STATE_NUM_STATES];
+static const sctp_sm_table_entry_t
+timeout_event_table[SCTP_NUM_TIMEOUT_TYPES][SCTP_STATE_NUM_STATES];
+
+static const sctp_sm_table_entry_t *sctp_chunk_event_lookup(sctp_cid_t cid,
+                                                            sctp_state_t state);
+
+
+static const sctp_sm_table_entry_t bug = {
+        .fn = sctp_sf_bug,
+        .name = "sctp_sf_bug"
+};
+
+#define DO_LOOKUP(_max, _type, _table) \
+        if ((event_subtype._type > (_max))) { \
+                printk(KERN_WARNING \
+                       "sctp table %p possible attack:" \
+                       " event %d exceeds max %d\n", \
+                       _table, event_subtype._type, _max); \
+                return &bug; \
+        } \
+        return &_table[event_subtype._type][(int)state];
+
+const sctp_sm_table_entry_t *sctp_sm_lookup_event(sctp_event_t event_type,
+                                                  sctp_state_t state,
+                                                  sctp_subtype_t event_subtype)
+{
+        switch (event_type) {
+        case SCTP_EVENT_T_CHUNK:
+                return sctp_chunk_event_lookup(event_subtype.chunk, state);
+                break;
+        case SCTP_EVENT_T_TIMEOUT:
+                DO_LOOKUP(SCTP_EVENT_TIMEOUT_MAX, timeout,
+                          timeout_event_table);
+                break;
+
+        case SCTP_EVENT_T_OTHER:
+                DO_LOOKUP(SCTP_EVENT_OTHER_MAX, other, other_event_table);
+                break;
+
+        case SCTP_EVENT_T_PRIMITIVE:
+                DO_LOOKUP(SCTP_EVENT_PRIMITIVE_MAX, primitive,
+                          primitive_event_table);
+                break;
+
+        default:
+                /* Yikes!  We got an illegal event type.  */
+                return &bug;
+        };
+}
+
+#define TYPE_SCTP_DATA { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_eat_data_6_2, .name = "sctp_sf_eat_data_6_2"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_eat_data_6_2, .name = "sctp_sf_eat_data_6_2"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_eat_data_fast_4_4, .name = "sctp_sf_eat_data_fast_4_4"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_DATA */
+
+#define TYPE_SCTP_INIT { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_do_5_1B_init, .name = "sctp_sf_do_5_1B_init"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_5_2_1_siminit, .name = "sctp_sf_do_5_2_1_siminit"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_5_2_1_siminit, .name = "sctp_sf_do_5_2_1_siminit"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_5_2_2_dupinit, .name = "sctp_sf_do_5_2_2_dupinit"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_5_2_2_dupinit, .name = "sctp_sf_do_5_2_2_dupinit"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_5_2_2_dupinit, .name = "sctp_sf_do_5_2_2_dupinit"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_5_2_2_dupinit, .name = "sctp_sf_do_5_2_2_dupinit"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_do_9_2_reshutack, .name = "sctp_sf_do_9_2_reshutack"}, \
+} /* TYPE_SCTP_INIT */
+
+#define TYPE_SCTP_INIT_ACK { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_5_1C_ack, .name = "sctp_sf_do_5_1C_ack"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_INIT_ACK */
+
+#define TYPE_SCTP_SACK { \
+        /*  SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_eat_sack_6_2, .name = "sctp_sf_eat_sack_6_2"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_eat_sack_6_2, .name = "sctp_sf_eat_sack_6_2"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_eat_sack_6_2, .name = "sctp_sf_eat_sack_6_2"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_eat_sack_6_2, .name = "sctp_sf_eat_sack_6_2"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_SACK */
+
+#define TYPE_SCTP_HEARTBEAT { \
+        /*  SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        /* This should not happen, but we are nice.  */ \
+        {.fn = sctp_sf_beat_8_3, .name = "sctp_sf_beat_8_3"}, \
+} /* TYPE_SCTP_HEARTBEAT */
+
+#define TYPE_SCTP_HEARTBEAT_ACK { \
+        /*  SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_violation, .name = "sctp_sf_violation"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_backbeat_8_3, .name = "sctp_sf_backbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_backbeat_8_3, .name = "sctp_sf_backbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_backbeat_8_3, .name = "sctp_sf_backbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_backbeat_8_3, .name = "sctp_sf_backbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_HEARTBEAT_ACK */
+
+#define TYPE_SCTP_ABORT { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_pdiscard, .name = "sctp_sf_pdiscard"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_cookie_wait_abort, .name = "sctp_sf_cookie_wait_abort"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_cookie_echoed_abort, \
+         .name = "sctp_sf_cookie_echoed_abort"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_9_1_abort, .name = "sctp_sf_do_9_1_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_shutdown_pending_abort, \
+        .name = "sctp_sf_shutdown_pending_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_shutdown_sent_abort, \
+        .name = "sctp_sf_shutdown_sent_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_9_1_abort, .name = "sctp_sf_do_9_1_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_shutdown_ack_sent_abort, \
+        .name = "sctp_sf_shutdown_ack_sent_abort"}, \
+} /* TYPE_SCTP_ABORT */
+
+#define TYPE_SCTP_SHUTDOWN { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_9_2_shutdown, .name = "sctp_sf_do_9_2_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_9_2_shutdown_ack, \
+         .name = "sctp_sf_do_9_2_shutdown_ack"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_SHUTDOWN */
+
+#define TYPE_SCTP_SHUTDOWN_ACK { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_8_5_1_E_sa, .name = "sctp_sf_do_8_5_1_E_sa"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_8_5_1_E_sa, .name = "sctp_sf_do_8_5_1_E_sa"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_violation, .name = "sctp_sf_violation"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_violation, .name = "sctp_sf_violation"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_9_2_final, .name = "sctp_sf_do_9_2_final"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_violation, .name = "sctp_sf_violation"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_do_9_2_final, .name = "sctp_sf_do_9_2_final"}, \
+} /* TYPE_SCTP_SHUTDOWN_ACK */
+
+#define TYPE_SCTP_ERROR { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_cookie_echoed_err, .name = "sctp_sf_cookie_echoed_err"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_operr_notify, .name = "sctp_sf_operr_notify"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_operr_notify, .name = "sctp_sf_operr_notify"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_operr_notify, .name = "sctp_sf_operr_notify"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_ERROR */
+
+#define TYPE_SCTP_COOKIE_ECHO { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_do_5_1D_ce, .name = "sctp_sf_do_5_1D_ce"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_do_5_2_4_dupcook, .name = "sctp_sf_do_5_2_4_dupcook"}, \
+} /* TYPE_SCTP_COOKIE_ECHO */
+
+#define TYPE_SCTP_COOKIE_ACK { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_5_1E_ca, .name = "sctp_sf_do_5_1E_ca"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_COOKIE_ACK */
+
+#define TYPE_SCTP_ECN_ECNE { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_ecne, .name = "sctp_sf_do_ecne"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_ecne, .name = "sctp_sf_do_ecne"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_ecne, .name = "sctp_sf_do_ecne"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_ecne, .name = "sctp_sf_do_ecne"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_ecne, .name = "sctp_sf_do_ecne"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+} /* TYPE_SCTP_ECN_ECNE */
+
+#define TYPE_SCTP_ECN_CWR { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_ecn_cwr, .name = "sctp_sf_do_ecn_cwr"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_ecn_cwr, .name = "sctp_sf_do_ecn_cwr"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_ecn_cwr, .name = "sctp_sf_do_ecn_cwr"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+} /* TYPE_SCTP_ECN_CWR */
+
+#define TYPE_SCTP_SHUTDOWN_COMPLETE { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_do_4_C, .name = "sctp_sf_do_4_C"}, \
+} /* TYPE_SCTP_SHUTDOWN_COMPLETE */
+
+/* The primary index for this table is the chunk type.
+ * The secondary index for this table is the state.
+ *
+ * For base protocol (RFC 2960).
+ */
+static const sctp_sm_table_entry_t chunk_event_table[SCTP_NUM_BASE_CHUNK_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_DATA,
+        TYPE_SCTP_INIT,
+        TYPE_SCTP_INIT_ACK,
+        TYPE_SCTP_SACK,
+        TYPE_SCTP_HEARTBEAT,
+        TYPE_SCTP_HEARTBEAT_ACK,
+        TYPE_SCTP_ABORT,
+        TYPE_SCTP_SHUTDOWN,
+        TYPE_SCTP_SHUTDOWN_ACK,
+        TYPE_SCTP_ERROR,
+        TYPE_SCTP_COOKIE_ECHO,
+        TYPE_SCTP_COOKIE_ACK,
+        TYPE_SCTP_ECN_ECNE,
+        TYPE_SCTP_ECN_CWR,
+        TYPE_SCTP_SHUTDOWN_COMPLETE,
+}; /* state_fn_t chunk_event_table[][] */
+
+#define TYPE_SCTP_ASCONF { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_asconf, .name = "sctp_sf_do_asconf"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_ASCONF */
+
+#define TYPE_SCTP_ASCONF_ACK { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_asconf_ack, .name = "sctp_sf_do_asconf_ack"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_ASCONF_ACK */
+
+/* The primary index for this table is the chunk type.
+ * The secondary index for this table is the state.
+ */
+static const sctp_sm_table_entry_t addip_chunk_event_table[SCTP_NUM_ADDIP_CHUNK_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_ASCONF,
+        TYPE_SCTP_ASCONF_ACK,
+}; /*state_fn_t addip_chunk_event_table[][] */
+
+#define TYPE_SCTP_FWD_TSN { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_eat_fwd_tsn, .name = "sctp_sf_eat_fwd_tsn"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_eat_fwd_tsn, .name = "sctp_sf_eat_fwd_tsn"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_eat_fwd_tsn_fast, .name = "sctp_sf_eat_fwd_tsn_fast"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_discard_chunk, .name = "sctp_sf_discard_chunk"}, \
+} /* TYPE_SCTP_FWD_TSN */
+
+/* The primary index for this table is the chunk type.
+ * The secondary index for this table is the state.
+ */
+static const sctp_sm_table_entry_t prsctp_chunk_event_table[SCTP_NUM_PRSCTP_CHUNK_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_FWD_TSN,
+}; /*state_fn_t prsctp_chunk_event_table[][] */
+
+static const sctp_sm_table_entry_t
+chunk_event_table_unknown[SCTP_STATE_NUM_STATES] = {
+        /* SCTP_STATE_EMPTY */
+        {.fn = sctp_sf_ootb, .name = "sctp_sf_ootb"},
+        /* SCTP_STATE_CLOSED */
+        {.fn = sctp_sf_tabort_8_4_8, .name = "sctp_sf_tabort_8_4_8"},
+        /* SCTP_STATE_COOKIE_WAIT */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_COOKIE_ECHOED */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_ESTABLISHED */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_SHUTDOWN_PENDING */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_SHUTDOWN_SENT */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */
+        {.fn = sctp_sf_unk_chunk, .name = "sctp_sf_unk_chunk"},
+};      /* chunk unknown */
+
+
+#define TYPE_SCTP_PRIMITIVE_ASSOCIATE  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_do_prm_asoc, .name = "sctp_sf_do_prm_asoc"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_not_impl, .name = "sctp_sf_not_impl"}, \
+} /* TYPE_SCTP_PRIMITIVE_ASSOCIATE */
+
+#define TYPE_SCTP_PRIMITIVE_SHUTDOWN  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_cookie_wait_prm_shutdown, \
+         .name = "sctp_sf_cookie_wait_prm_shutdown"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_cookie_echoed_prm_shutdown, \
+         .name = "sctp_sf_cookie_echoed_prm_shutdown"},\
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_9_2_prm_shutdown, \
+         .name = "sctp_sf_do_9_2_prm_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_ignore_primitive, .name = "sctp_sf_ignore_primitive"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_ignore_primitive, .name = "sctp_sf_ignore_primitive"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_ignore_primitive, .name = "sctp_sf_ignore_primitive"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_ignore_primitive, .name = "sctp_sf_ignore_primitive"}, \
+} /* TYPE_SCTP_PRIMITIVE_SHUTDOWN */
+
+#define TYPE_SCTP_PRIMITIVE_ABORT  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_cookie_wait_prm_abort, \
+        .name = "sctp_sf_cookie_wait_prm_abort"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_cookie_echoed_prm_abort, \
+        .name = "sctp_sf_cookie_echoed_prm_abort"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_9_1_prm_abort, \
+        .name = "sctp_sf_do_9_1_prm_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_shutdown_pending_prm_abort, \
+        .name = "sctp_sf_shutdown_pending_prm_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_shutdown_sent_prm_abort, \
+        .name = "sctp_sf_shutdown_sent_prm_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_9_1_prm_abort, \
+        .name = "sctp_sf_do_9_1_prm_abort"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_shutdown_ack_sent_prm_abort, \
+        .name = "sctp_sf_shutdown_ack_sent_prm_abort"}, \
+} /* TYPE_SCTP_PRIMITIVE_ABORT */
+
+#define TYPE_SCTP_PRIMITIVE_SEND  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_prm_send, .name = "sctp_sf_do_prm_send"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_prm_send, .name = "sctp_sf_do_prm_send"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_prm_send, .name = "sctp_sf_do_prm_send"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+} /* TYPE_SCTP_PRIMITIVE_SEND */
+
+#define TYPE_SCTP_PRIMITIVE_REQUESTHEARTBEAT  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_do_prm_requestheartbeat,               \
+         .name = "sctp_sf_do_prm_requestheartbeat"},          \
+} /* TYPE_SCTP_PRIMITIVE_REQUESTHEARTBEAT */
+
+#define TYPE_SCTP_PRIMITIVE_ASCONF { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_error_closed, .name = "sctp_sf_error_closed"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_prm_asconf, .name = "sctp_sf_do_prm_asconf"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_error_shutdown, .name = "sctp_sf_error_shutdown"}, \
+} /* TYPE_SCTP_PRIMITIVE_REQUESTHEARTBEAT */
+
+/* The primary index for this table is the primitive type.
+ * The secondary index for this table is the state.
+ */
+static const sctp_sm_table_entry_t primitive_event_table[SCTP_NUM_PRIMITIVE_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_PRIMITIVE_ASSOCIATE,
+        TYPE_SCTP_PRIMITIVE_SHUTDOWN,
+        TYPE_SCTP_PRIMITIVE_ABORT,
+        TYPE_SCTP_PRIMITIVE_SEND,
+        TYPE_SCTP_PRIMITIVE_REQUESTHEARTBEAT,
+        TYPE_SCTP_PRIMITIVE_ASCONF,
+};
+
+#define TYPE_SCTP_OTHER_NO_PENDING_TSN  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_9_2_start_shutdown, \
+         .name = "sctp_do_9_2_start_shutdown"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_9_2_shutdown_ack, \
+         .name = "sctp_sf_do_9_2_shutdown_ack"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+}
+
+#define TYPE_SCTP_OTHER_ICMP_PROTO_UNREACH  { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_cookie_wait_icmp_abort, \
+         .name = "sctp_sf_cookie_wait_icmp_abort"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_ignore_other, .name = "sctp_sf_ignore_other"}, \
+}
+
+static const sctp_sm_table_entry_t other_event_table[SCTP_NUM_OTHER_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_OTHER_NO_PENDING_TSN,
+        TYPE_SCTP_OTHER_ICMP_PROTO_UNREACH,
+};
+
+#define TYPE_SCTP_EVENT_TIMEOUT_NONE { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T1_COOKIE { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_t1_timer_expire, .name = "sctp_sf_t1_timer_expire"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T1_INIT { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_t1_timer_expire, .name = "sctp_sf_t1_timer_expire"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T2_SHUTDOWN { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_t2_timer_expire, .name = "sctp_sf_t2_timer_expire"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_t2_timer_expire, .name = "sctp_sf_t2_timer_expire"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T3_RTX { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_do_6_3_3_rtx, .name = "sctp_sf_do_6_3_3_rtx"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_6_3_3_rtx, .name = "sctp_sf_do_6_3_3_rtx"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_6_3_3_rtx, .name = "sctp_sf_do_6_3_3_rtx"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_do_6_3_3_rtx, .name = "sctp_sf_do_6_3_3_rtx"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T4_RTO { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_t4_timer_expire, .name = "sctp_sf_t4_timer_expire"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_t5_timer_expire, .name = "sctp_sf_t5_timer_expire"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_t5_timer_expire, .name = "sctp_sf_t5_timer_expire"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_HEARTBEAT { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_sendbeat_8_3, .name = "sctp_sf_sendbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_sendbeat_8_3, .name = "sctp_sf_sendbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_sendbeat_8_3, .name = "sctp_sf_sendbeat_8_3"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_SACK { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_bug, .name = "sctp_sf_bug"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_do_6_2_sack, .name = "sctp_sf_do_6_2_sack"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_do_6_2_sack, .name = "sctp_sf_do_6_2_sack"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_do_6_2_sack, .name = "sctp_sf_do_6_2_sack"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+#define TYPE_SCTP_EVENT_TIMEOUT_AUTOCLOSE { \
+        /* SCTP_STATE_EMPTY */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_CLOSED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_WAIT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_COOKIE_ECHOED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_ESTABLISHED */ \
+        {.fn = sctp_sf_autoclose_timer_expire, \
+         .name = "sctp_sf_autoclose_timer_expire"}, \
+        /* SCTP_STATE_SHUTDOWN_PENDING */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+        /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
+        {.fn = sctp_sf_timer_ignore, .name = "sctp_sf_timer_ignore"}, \
+}
+
+static const sctp_sm_table_entry_t timeout_event_table[SCTP_NUM_TIMEOUT_TYPES][SCTP_STATE_NUM_STATES] = {
+        TYPE_SCTP_EVENT_TIMEOUT_NONE,
+        TYPE_SCTP_EVENT_TIMEOUT_T1_COOKIE,
+        TYPE_SCTP_EVENT_TIMEOUT_T1_INIT,
+        TYPE_SCTP_EVENT_TIMEOUT_T2_SHUTDOWN,
+        TYPE_SCTP_EVENT_TIMEOUT_T3_RTX,
+        TYPE_SCTP_EVENT_TIMEOUT_T4_RTO,
+        TYPE_SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD,
+        TYPE_SCTP_EVENT_TIMEOUT_HEARTBEAT,
+        TYPE_SCTP_EVENT_TIMEOUT_SACK,
+        TYPE_SCTP_EVENT_TIMEOUT_AUTOCLOSE,
+};
+
+static const sctp_sm_table_entry_t *sctp_chunk_event_lookup(sctp_cid_t cid, 
+                                                            sctp_state_t state)
+{
+        if (state > SCTP_STATE_MAX)
+                return &bug;
+
+        if (cid >= 0 && cid <= SCTP_CID_BASE_MAX)
+                return &chunk_event_table[cid][state];
+
+        if (sctp_prsctp_enable) {
+                if (cid == SCTP_CID_FWD_TSN)
+                        return &prsctp_chunk_event_table[0][state];
+        }
+
+        if (sctp_addip_enable) {
+                if (cid == SCTP_CID_ASCONF)
+                        return &addip_chunk_event_table[0][state];
+
+                if (cid == SCTP_CID_ASCONF_ACK)
+                        return &addip_chunk_event_table[1][state];
+        }
+
+        return &chunk_event_table_unknown[state];
+}
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
new file mode 100644
index 000000000000..e8c210182571
--- /dev/null
+++ b/net/sctp/socket.c
@@ -0,0 +1,4797 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 Intel Corp.
+ * Copyright (c) 2001-2002 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions interface with the sockets layer to implement the
+ * SCTP Extensions for the Sockets API.
+ *
+ * Note that the descriptions from the specification are USER level
+ * functions--this file is the functions which populate the struct proto
+ * for SCTP which is the BOTTOM of the sockets interface.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Narasimha Budihal     <narsi@refcode.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Daisy Chang           <daisyc@us.ibm.com>
+ *    Sridhar Samudrala     <samudrala@us.ibm.com>
+ *    Inaky Perez-Gonzalez  <inaky.gonzalez@intel.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Ryan Layer            <rmlayer@us.ibm.com>
+ *    Anup Pemmaiah         <pemmaiah@cc.usu.edu>
+ *    Kevin Gao             <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/time.h>
+#include <linux/ip.h>
+#include <linux/fcntl.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/crypto.h>
+
+#include <net/ip.h>
+#include <net/icmp.h>
+#include <net/route.h>
+#include <net/ipv6.h>
+#include <net/inet_common.h>
+
+#include <linux/socket.h> /* for sa_family_t */
+#include <net/sock.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* WARNING:  Please do not remove the SCTP_STATIC attribute to
+ * any of the functions below as they are used to export functions
+ * used by a project regression testsuite.
+ */
+
+/* Forward declarations for internal helper functions. */
+static int sctp_writeable(struct sock *sk);
+static void sctp_wfree(struct sk_buff *skb);
+static int sctp_wait_for_sndbuf(struct sctp_association *, long *timeo_p,
+                                size_t msg_len);
+static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p);
+static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
+static int sctp_wait_for_accept(struct sock *sk, long timeo);
+static void sctp_wait_for_close(struct sock *sk, long timeo);
+static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
+                                        union sctp_addr *addr, int len);
+static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
+static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
+static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
+static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
+static int sctp_send_asconf(struct sctp_association *asoc,
+                            struct sctp_chunk *chunk);
+static int sctp_do_bind(struct sock *, union sctp_addr *, int);
+static int sctp_autobind(struct sock *sk);
+static void sctp_sock_migrate(struct sock *, struct sock *,
+                              struct sctp_association *, sctp_socket_type_t);
+static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG;
+
+extern kmem_cache_t *sctp_bucket_cachep;
+
+/* Get the sndbuf space available at the time on the association.  */
+static inline int sctp_wspace(struct sctp_association *asoc)
+{
+        struct sock *sk = asoc->base.sk;
+        int amt = 0;
+
+        amt = sk->sk_sndbuf - asoc->sndbuf_used;
+        if (amt < 0)
+                amt = 0;
+        return amt;
+}
+
+/* Increment the used sndbuf space count of the corresponding association by
+ * the size of the outgoing data chunk.
+ * Also, set the skb destructor for sndbuf accounting later.
+ *
+ * Since it is always 1-1 between chunk and skb, and also a new skb is always
+ * allocated for chunk bundling in sctp_packet_transmit(), we can use the
+ * destructor in the data chunk skb for the purpose of the sndbuf space
+ * tracking.
+ */
+static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
+{
+        struct sctp_association *asoc = chunk->asoc;
+        struct sock *sk = asoc->base.sk;
+
+        /* The sndbuf space is tracked per association.  */
+        sctp_association_hold(asoc);
+
+        chunk->skb->destructor = sctp_wfree;
+        /* Save the chunk pointer in skb for sctp_wfree to use later.  */
+        *((struct sctp_chunk **)(chunk->skb->cb)) = chunk;
+
+        asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk);
+        sk->sk_wmem_queued += SCTP_DATA_SNDSIZE(chunk);
+}
+
+/* Verify that this is a valid address. */
+static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
+                                   int len)
+{
+        struct sctp_af *af;
+
+        /* Verify basic sockaddr. */
+        af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
+        if (!af)
+                return -EINVAL;
+
+        /* Is this a valid SCTP address?  */
+        if (!af->addr_valid(addr, sctp_sk(sk)))
+                return -EINVAL;
+
+        if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
+                return -EINVAL;
+
+        return 0;
+}
+
+/* Look up the association by its id.  If this is not a UDP-style
+ * socket, the ID field is always ignored.
+ */
+struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
+{
+        struct sctp_association *asoc = NULL;
+
+        /* If this is not a UDP-style socket, assoc id should be ignored. */
+        if (!sctp_style(sk, UDP)) {
+                /* Return NULL if the socket state is not ESTABLISHED. It
+                 * could be a TCP-style listening socket or a socket which
+                 * hasn't yet called connect() to establish an association.
+                 */
+                if (!sctp_sstate(sk, ESTABLISHED))
+                        return NULL;
+
+                /* Get the first and the only association from the list. */
+                if (!list_empty(&sctp_sk(sk)->ep->asocs))
+                        asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
+                                          struct sctp_association, asocs);
+                return asoc;
+        }
+
+        /* Otherwise this is a UDP-style socket. */
+        if (!id || (id == (sctp_assoc_t)-1))
+                return NULL;
+
+        spin_lock_bh(&sctp_assocs_id_lock);
+        asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
+        spin_unlock_bh(&sctp_assocs_id_lock);
+
+        if (!asoc || (asoc->base.sk != sk) || asoc->base.dead)
+                return NULL;
+
+        return asoc;
+}
+
+/* Look up the transport from an address and an assoc id. If both address and
+ * id are specified, the associations matching the address and the id should be
+ * the same.
+ */
+static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
+                                              struct sockaddr_storage *addr,
+                                              sctp_assoc_t id)
+{
+        struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
+        struct sctp_transport *transport;
+        union sctp_addr *laddr = (union sctp_addr *)addr;
+
+        laddr->v4.sin_port = ntohs(laddr->v4.sin_port);
+        addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
+                                               (union sctp_addr *)addr,
+                                               &transport);
+        laddr->v4.sin_port = htons(laddr->v4.sin_port);
+
+        if (!addr_asoc)
+                return NULL;
+
+        id_asoc = sctp_id2assoc(sk, id);
+        if (id_asoc && (id_asoc != addr_asoc))
+                return NULL;
+
+        sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
+                                                (union sctp_addr *)addr);
+
+        return transport;
+}
+
+/* API 3.1.2 bind() - UDP Style Syntax
+ * The syntax of bind() is,
+ *
+ *   ret = bind(int sd, struct sockaddr *addr, int addrlen);
+ *
+ *   sd      - the socket descriptor returned by socket().
+ *   addr    - the address structure (struct sockaddr_in or struct
+ *             sockaddr_in6 [RFC 2553]),
+ *   addr_len - the size of the address structure.
+ */
+SCTP_STATIC int sctp_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+{
+        int retval = 0;
+
+        sctp_lock_sock(sk);
+
+        SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, uaddr: %p, addr_len: %d)\n",
+                          sk, uaddr, addr_len);
+
+        /* Disallow binding twice. */
+        if (!sctp_sk(sk)->ep->base.bind_addr.port)
+                retval = sctp_do_bind(sk, (union sctp_addr *)uaddr,
+                                      addr_len);
+        else
+                retval = -EINVAL;
+
+        sctp_release_sock(sk);
+
+        return retval;
+}
+
+static long sctp_get_port_local(struct sock *, union sctp_addr *);
+
+/* Verify this is a valid sockaddr. */
+static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
+                                        union sctp_addr *addr, int len)
+{
+        struct sctp_af *af;
+
+        /* Check minimum size.  */
+        if (len < sizeof (struct sockaddr))
+                return NULL;
+
+        /* Does this PF support this AF? */
+        if (!opt->pf->af_supported(addr->sa.sa_family, opt))
+                return NULL;
+
+        /* If we get this far, af is valid. */
+        af = sctp_get_af_specific(addr->sa.sa_family);
+
+        if (len < af->sockaddr_len)
+                return NULL;
+
+        return af;
+}
+
+/* Bind a local address either to an endpoint or to an association.  */
+SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+        struct sctp_endpoint *ep = sp->ep;
+        struct sctp_bind_addr *bp = &ep->base.bind_addr;
+        struct sctp_af *af;
+        unsigned short snum;
+        int ret = 0;
+
+        SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d)\n",
+                          sk, addr, len);
+
+        /* Common sockaddr verification. */
+        af = sctp_sockaddr_af(sp, addr, len);
+        if (!af)
+                return -EINVAL;
+
+        /* PF specific bind() address verification. */
+        if (!sp->pf->bind_verify(sp, addr))
+                return -EADDRNOTAVAIL;
+
+        snum= ntohs(addr->v4.sin_port);
+
+        SCTP_DEBUG_PRINTK("sctp_do_bind: port: %d, new port: %d\n",
+                          bp->port, snum);
+
+        /* We must either be unbound, or bind to the same port.  */
+        if (bp->port && (snum != bp->port)) {
+                SCTP_DEBUG_PRINTK("sctp_do_bind:"
+                                  " New port %d does not match existing port "
+                                  "%d.\n", snum, bp->port);
+                return -EINVAL;
+        }
+
+        if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
+                return -EACCES;
+
+        /* Make sure we are allowed to bind here.
+         * The function sctp_get_port_local() does duplicate address
+         * detection.
+         */
+        if ((ret = sctp_get_port_local(sk, addr))) {
+                if (ret == (long) sk) {
+                        /* This endpoint has a conflicting address. */
+                        return -EINVAL;
+                } else {
+                        return -EADDRINUSE;
+                }
+        }
+
+        /* Refresh ephemeral port.  */
+        if (!bp->port)
+                bp->port = inet_sk(sk)->num;
+
+        /* Add the address to the bind address list.  */
+        sctp_local_bh_disable();
+        sctp_write_lock(&ep->base.addr_lock);
+
+        /* Use GFP_ATOMIC since BHs are disabled.  */
+        addr->v4.sin_port = ntohs(addr->v4.sin_port);
+        ret = sctp_add_bind_addr(bp, addr, GFP_ATOMIC);
+        addr->v4.sin_port = htons(addr->v4.sin_port);
+        sctp_write_unlock(&ep->base.addr_lock);
+        sctp_local_bh_enable();
+
+        /* Copy back into socket for getsockname() use. */
+        if (!ret) {
+                inet_sk(sk)->sport = htons(inet_sk(sk)->num);
+                af->to_sk_saddr(addr, sk);
+        }
+
+        return ret;
+}
+
+ /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
+ *
+ * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged 
+ * at any one time.  If a sender, after sending an ASCONF chunk, decides
+ * it needs to transfer another ASCONF Chunk, it MUST wait until the 
+ * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
+ * subsequent ASCONF. Note this restriction binds each side, so at any 
+ * time two ASCONF may be in-transit on any given association (one sent 
+ * from each endpoint).
+ */
+static int sctp_send_asconf(struct sctp_association *asoc,
+                            struct sctp_chunk *chunk)
+{
+        int             retval = 0;
+
+        /* If there is an outstanding ASCONF chunk, queue it for later
+         * transmission.
+         */     
+        if (asoc->addip_last_asconf) {
+                __skb_queue_tail(&asoc->addip_chunks, (struct sk_buff *)chunk);
+                goto out;       
+        }
+
+        /* Hold the chunk until an ASCONF_ACK is received. */
+        sctp_chunk_hold(chunk);
+        retval = sctp_primitive_ASCONF(asoc, chunk);
+        if (retval)
+                sctp_chunk_free(chunk);
+        else
+                asoc->addip_last_asconf = chunk;
+
+out:
+        return retval;
+}
+
+/* Add a list of addresses as bind addresses to local endpoint or
+ * association.
+ *
+ * Basically run through each address specified in the addrs/addrcnt
+ * array/length pair, determine if it is IPv6 or IPv4 and call
+ * sctp_do_bind() on it.
+ *
+ * If any of them fails, then the operation will be reversed and the
+ * ones that were added will be removed.
+ *
+ * Only sctp_setsockopt_bindx() is supposed to call this function.
+ */
+int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
+{
+        int cnt;
+        int retval = 0;
+        void *addr_buf;
+        struct sockaddr *sa_addr;
+        struct sctp_af *af;
+
+        SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n",
+                          sk, addrs, addrcnt);
+
+        addr_buf = addrs;
+        for (cnt = 0; cnt < addrcnt; cnt++) {
+                /* The list may contain either IPv4 or IPv6 address;
+                 * determine the address length for walking thru the list.
+                 */
+                sa_addr = (struct sockaddr *)addr_buf;
+                af = sctp_get_af_specific(sa_addr->sa_family);
+                if (!af) {
+                        retval = -EINVAL;
+                        goto err_bindx_add;
+                }
+
+                retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr, 
+                                      af->sockaddr_len);
+
+                addr_buf += af->sockaddr_len;
+
+err_bindx_add:
+                if (retval < 0) {
+                        /* Failed. Cleanup the ones that have been added */
+                        if (cnt > 0)
+                                sctp_bindx_rem(sk, addrs, cnt);
+                        return retval;
+                }
+        }
+
+        return retval;
+}
+
+/* Send an ASCONF chunk with Add IP address parameters to all the peers of the
+ * associations that are part of the endpoint indicating that a list of local
+ * addresses are added to the endpoint.
+ *
+ * If any of the addresses is already in the bind address list of the 
+ * association, we do not send the chunk for that association.  But it will not
+ * affect other associations.
+ *
+ * Only sctp_setsockopt_bindx() is supposed to call this function.
+ */
+static int sctp_send_asconf_add_ip(struct sock          *sk, 
+                                   struct sockaddr      *addrs,
+                                   int                  addrcnt)
+{
+        struct sctp_sock                *sp;
+        struct sctp_endpoint            *ep;
+        struct sctp_association         *asoc;
+        struct sctp_bind_addr           *bp;
+        struct sctp_chunk               *chunk;
+        struct sctp_sockaddr_entry      *laddr;
+        union sctp_addr                 *addr;
+        void                            *addr_buf;
+        struct sctp_af                  *af;
+        struct list_head                *pos;
+        struct list_head                *p;
+        int                             i;
+        int                             retval = 0;
+
+        if (!sctp_addip_enable)
+                return retval;
+
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
+                          __FUNCTION__, sk, addrs, addrcnt);
+
+        list_for_each(pos, &ep->asocs) {
+                asoc = list_entry(pos, struct sctp_association, asocs);
+
+                if (!asoc->peer.asconf_capable)
+                        continue;
+
+                if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
+                        continue;
+
+                if (!sctp_state(asoc, ESTABLISHED))
+                        continue;
+
+                /* Check if any address in the packed array of addresses is
+                 * in the bind address list of the association. If so, 
+                 * do not send the asconf chunk to its peer, but continue with 
+                 * other associations.
+                 */
+                addr_buf = addrs;
+                for (i = 0; i < addrcnt; i++) {
+                        addr = (union sctp_addr *)addr_buf;
+                        af = sctp_get_af_specific(addr->v4.sin_family);
+                        if (!af) {
+                                retval = -EINVAL;
+                                goto out;
+                        }
+
+                        if (sctp_assoc_lookup_laddr(asoc, addr))
+                                break;
+
+                        addr_buf += af->sockaddr_len;
+                }
+                if (i < addrcnt)
+                        continue;
+
+                /* Use the first address in bind addr list of association as
+                 * Address Parameter of ASCONF CHUNK.
+                 */
+                sctp_read_lock(&asoc->base.addr_lock);
+                bp = &asoc->base.bind_addr;
+                p = bp->address_list.next;
+                laddr = list_entry(p, struct sctp_sockaddr_entry, list);
+                sctp_read_unlock(&asoc->base.addr_lock);
+
+                chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
+                                                   addrcnt, SCTP_PARAM_ADD_IP);
+                if (!chunk) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+
+                retval = sctp_send_asconf(asoc, chunk);
+
+                /* FIXME: After sending the add address ASCONF chunk, we
+                 * cannot append the address to the association's binding
+                 * address list, because the new address may be used as the
+                 * source of a message sent to the peer before the ASCONF
+                 * chunk is received by the peer.  So we should wait until
+                 * ASCONF_ACK is received.
+                 */
+        }
+
+out:
+        return retval;
+}
+
+/* Remove a list of addresses from bind addresses list.  Do not remove the
+ * last address.
+ *
+ * Basically run through each address specified in the addrs/addrcnt
+ * array/length pair, determine if it is IPv6 or IPv4 and call
+ * sctp_del_bind() on it.
+ *
+ * If any of them fails, then the operation will be reversed and the
+ * ones that were removed will be added back.
+ *
+ * At least one address has to be left; if only one address is
+ * available, the operation will return -EBUSY.
+ *
+ * Only sctp_setsockopt_bindx() is supposed to call this function.
+ */
+int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+        struct sctp_endpoint *ep = sp->ep;
+        int cnt;
+        struct sctp_bind_addr *bp = &ep->base.bind_addr;
+        int retval = 0;
+        union sctp_addr saveaddr;
+        void *addr_buf;
+        struct sockaddr *sa_addr;
+        struct sctp_af *af;
+
+        SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n",
+                          sk, addrs, addrcnt);
+
+        addr_buf = addrs;
+        for (cnt = 0; cnt < addrcnt; cnt++) {
+                /* If the bind address list is empty or if there is only one
+                 * bind address, there is nothing more to be removed (we need
+                 * at least one address here).
+                 */
+                if (list_empty(&bp->address_list) ||
+                    (sctp_list_single_entry(&bp->address_list))) {
+                        retval = -EBUSY;
+                        goto err_bindx_rem;
+                }
+
+                /* The list may contain either IPv4 or IPv6 address;
+                 * determine the address length to copy the address to
+                 * saveaddr. 
+                 */
+                sa_addr = (struct sockaddr *)addr_buf;
+                af = sctp_get_af_specific(sa_addr->sa_family);
+                if (!af) {
+                        retval = -EINVAL;
+                        goto err_bindx_rem;
+                }
+                memcpy(&saveaddr, sa_addr, af->sockaddr_len); 
+                saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);
+                if (saveaddr.v4.sin_port != bp->port) {
+                        retval = -EINVAL;
+                        goto err_bindx_rem;
+                }
+
+                /* FIXME - There is probably a need to check if sk->sk_saddr and
+                 * sk->sk_rcv_addr are currently set to one of the addresses to
+                 * be removed. This is something which needs to be looked into
+                 * when we are fixing the outstanding issues with multi-homing
+                 * socket routing and failover schemes. Refer to comments in
+                 * sctp_do_bind(). -daisy
+                 */
+                sctp_local_bh_disable();
+                sctp_write_lock(&ep->base.addr_lock);
+
+                retval = sctp_del_bind_addr(bp, &saveaddr);
+
+                sctp_write_unlock(&ep->base.addr_lock);
+                sctp_local_bh_enable();
+
+                addr_buf += af->sockaddr_len;
+err_bindx_rem:
+                if (retval < 0) {
+                        /* Failed. Add the ones that has been removed back */
+                        if (cnt > 0)
+                                sctp_bindx_add(sk, addrs, cnt);
+                        return retval;
+                }
+        }
+
+        return retval;
+}
+
+/* Send an ASCONF chunk with Delete IP address parameters to all the peers of
+ * the associations that are part of the endpoint indicating that a list of
+ * local addresses are removed from the endpoint.
+ *
+ * If any of the addresses is already in the bind address list of the 
+ * association, we do not send the chunk for that association.  But it will not
+ * affect other associations.
+ *
+ * Only sctp_setsockopt_bindx() is supposed to call this function.
+ */
+static int sctp_send_asconf_del_ip(struct sock          *sk,
+                                   struct sockaddr      *addrs,
+                                   int                  addrcnt)
+{
+        struct sctp_sock        *sp;
+        struct sctp_endpoint    *ep;
+        struct sctp_association *asoc;
+        struct sctp_bind_addr   *bp;
+        struct sctp_chunk       *chunk;
+        union sctp_addr         *laddr;
+        void                    *addr_buf;
+        struct sctp_af          *af;
+        struct list_head        *pos;
+        int                     i;
+        int                     retval = 0;
+
+        if (!sctp_addip_enable)
+                return retval;
+
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
+                          __FUNCTION__, sk, addrs, addrcnt);
+
+        list_for_each(pos, &ep->asocs) {
+                asoc = list_entry(pos, struct sctp_association, asocs);
+
+                if (!asoc->peer.asconf_capable)
+                        continue;
+
+                if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
+                        continue;
+
+                if (!sctp_state(asoc, ESTABLISHED))
+                        continue;
+
+                /* Check if any address in the packed array of addresses is
+                 * not present in the bind address list of the association.
+                 * If so, do not send the asconf chunk to its peer, but
+                 * continue with other associations.
+                 */
+                addr_buf = addrs;
+                for (i = 0; i < addrcnt; i++) {
+                        laddr = (union sctp_addr *)addr_buf;
+                        af = sctp_get_af_specific(laddr->v4.sin_family);
+                        if (!af) {
+                                retval = -EINVAL;
+                                goto out;
+                        }
+
+                        if (!sctp_assoc_lookup_laddr(asoc, laddr))
+                                break;
+
+                        addr_buf += af->sockaddr_len;
+                }
+                if (i < addrcnt)
+                        continue;
+
+                /* Find one address in the association's bind address list
+                 * that is not in the packed array of addresses. This is to
+                 * make sure that we do not delete all the addresses in the
+                 * association.
+                 */
+                sctp_read_lock(&asoc->base.addr_lock);
+                bp = &asoc->base.bind_addr;
+                laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
+                                               addrcnt, sp);
+                sctp_read_unlock(&asoc->base.addr_lock);
+                if (!laddr)
+                        continue;
+
+                chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
+                                                   SCTP_PARAM_DEL_IP);
+                if (!chunk) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+
+                retval = sctp_send_asconf(asoc, chunk);
+
+                /* FIXME: After sending the delete address ASCONF chunk, we
+                 * cannot remove the addresses from the association's bind
+                 * address list, because there maybe some packet send to
+                 * the delete addresses, so we should wait until ASCONF_ACK
+                 * packet is received.
+                 */
+        }
+out:
+        return retval;
+}
+
+/* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
+ *
+ * API 8.1
+ * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
+ *                int flags);
+ *
+ * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
+ * If the sd is an IPv6 socket, the addresses passed can either be IPv4
+ * or IPv6 addresses.
+ *
+ * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
+ * Section 3.1.2 for this usage.
+ *
+ * addrs is a pointer to an array of one or more socket addresses. Each
+ * address is contained in its appropriate structure (i.e. struct
+ * sockaddr_in or struct sockaddr_in6) the family of the address type
+ * must be used to distengish the address length (note that this
+ * representation is termed a "packed array" of addresses). The caller
+ * specifies the number of addresses in the array with addrcnt.
+ *
+ * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
+ * -1, and sets errno to the appropriate error code.
+ *
+ * For SCTP, the port given in each socket address must be the same, or
+ * sctp_bindx() will fail, setting errno to EINVAL.
+ *
+ * The flags parameter is formed from the bitwise OR of zero or more of
+ * the following currently defined flags:
+ *
+ * SCTP_BINDX_ADD_ADDR
+ *
+ * SCTP_BINDX_REM_ADDR
+ *
+ * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
+ * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
+ * addresses from the association. The two flags are mutually exclusive;
+ * if both are given, sctp_bindx() will fail with EINVAL. A caller may
+ * not remove all addresses from an association; sctp_bindx() will
+ * reject such an attempt with EINVAL.
+ *
+ * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
+ * additional addresses with an endpoint after calling bind().  Or use
+ * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
+ * socket is associated with so that no new association accepted will be
+ * associated with those addresses. If the endpoint supports dynamic
+ * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
+ * endpoint to send the appropriate message to the peer to change the
+ * peers address lists.
+ *
+ * Adding and removing addresses from a connected association is
+ * optional functionality. Implementations that do not support this
+ * functionality should return EOPNOTSUPP.
+ *
+ * Basically do nothing but copying the addresses from user to kernel
+ * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
+ * This is used for tunneling the sctp_bindx() request through sctp_setsockopt() * from userspace.
+ *
+ * We don't use copy_from_user() for optimization: we first do the
+ * sanity checks (buffer size -fast- and access check-healthy
+ * pointer); if all of those succeed, then we can alloc the memory
+ * (expensive operation) needed to copy the data to kernel. Then we do
+ * the copying without checking the user space area
+ * (__copy_from_user()).
+ *
+ * On exit there is no need to do sockfd_put(), sys_setsockopt() does
+ * it.
+ *
+ * sk        The sk of the socket
+ * addrs     The pointer to the addresses in user land
+ * addrssize Size of the addrs buffer
+ * op        Operation to perform (add or remove, see the flags of
+ *           sctp_bindx)
+ *
+ * Returns 0 if ok, <0 errno code on error.
+ */
+SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk,
+                                      struct sockaddr __user *addrs,
+                                      int addrs_size, int op)
+{
+        struct sockaddr *kaddrs;
+        int err;
+        int addrcnt = 0;
+        int walk_size = 0;
+        struct sockaddr *sa_addr;
+        void *addr_buf;
+        struct sctp_af *af;
+
+        SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"
+                          " addrs_size %d opt %d\n", sk, addrs, addrs_size, op);
+
+        if (unlikely(addrs_size <= 0))
+                return -EINVAL;
+
+        /* Check the user passed a healthy pointer.  */
+        if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
+                return -EFAULT;
+
+        /* Alloc space for the address array in kernel memory.  */
+        kaddrs = (struct sockaddr *)kmalloc(addrs_size, GFP_KERNEL);
+        if (unlikely(!kaddrs))
+                return -ENOMEM;
+
+        if (__copy_from_user(kaddrs, addrs, addrs_size)) {
+                kfree(kaddrs);
+                return -EFAULT;
+        }
+
+        /* Walk through the addrs buffer and count the number of addresses. */ 
+        addr_buf = kaddrs;
+        while (walk_size < addrs_size) {
+                sa_addr = (struct sockaddr *)addr_buf;
+                af = sctp_get_af_specific(sa_addr->sa_family);
+
+                /* If the address family is not supported or if this address
+                 * causes the address buffer to overflow return EINVAL.
+                 */ 
+                if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
+                        kfree(kaddrs);
+                        return -EINVAL;
+                }
+                addrcnt++;
+                addr_buf += af->sockaddr_len;
+                walk_size += af->sockaddr_len;
+        }
+
+        /* Do the work. */
+        switch (op) {
+        case SCTP_BINDX_ADD_ADDR:
+                err = sctp_bindx_add(sk, kaddrs, addrcnt);
+                if (err)
+                        goto out;
+                err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
+                break;
+
+        case SCTP_BINDX_REM_ADDR:
+                err = sctp_bindx_rem(sk, kaddrs, addrcnt);
+                if (err)
+                        goto out;
+                err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
+                break;
+
+        default:
+                err = -EINVAL;
+                break;
+        };
+
+out:
+        kfree(kaddrs);
+
+        return err;
+}
+
+/* API 3.1.4 close() - UDP Style Syntax
+ * Applications use close() to perform graceful shutdown (as described in
+ * Section 10.1 of [SCTP]) on ALL the associations currently represented
+ * by a UDP-style socket.
+ *
+ * The syntax is
+ *
+ *   ret = close(int sd);
+ *
+ *   sd      - the socket descriptor of the associations to be closed.
+ *
+ * To gracefully shutdown a specific association represented by the
+ * UDP-style socket, an application should use the sendmsg() call,
+ * passing no user data, but including the appropriate flag in the
+ * ancillary data (see Section xxxx).
+ *
+ * If sd in the close() call is a branched-off socket representing only
+ * one association, the shutdown is performed on that association only.
+ *
+ * 4.1.6 close() - TCP Style Syntax
+ *
+ * Applications use close() to gracefully close down an association.
+ *
+ * The syntax is:
+ *
+ *    int close(int sd);
+ *
+ *      sd      - the socket descriptor of the association to be closed.
+ *
+ * After an application calls close() on a socket descriptor, no further
+ * socket operations will succeed on that descriptor.
+ *
+ * API 7.1.4 SO_LINGER
+ *
+ * An application using the TCP-style socket can use this option to
+ * perform the SCTP ABORT primitive.  The linger option structure is:
+ *
+ *  struct  linger {
+ *     int     l_onoff;                // option on/off
+ *     int     l_linger;               // linger time
+ * };
+ *
+ * To enable the option, set l_onoff to 1.  If the l_linger value is set
+ * to 0, calling close() is the same as the ABORT primitive.  If the
+ * value is set to a negative value, the setsockopt() call will return
+ * an error.  If the value is set to a positive value linger_time, the
+ * close() can be blocked for at most linger_time ms.  If the graceful
+ * shutdown phase does not finish during this period, close() will
+ * return but the graceful shutdown phase continues in the system.
+ */
+SCTP_STATIC void sctp_close(struct sock *sk, long timeout)
+{
+        struct sctp_endpoint *ep;
+        struct sctp_association *asoc;
+        struct list_head *pos, *temp;
+
+        SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout);
+
+        sctp_lock_sock(sk);
+        sk->sk_shutdown = SHUTDOWN_MASK;
+
+        ep = sctp_sk(sk)->ep;
+
+        /* Walk all associations on a socket, not on an endpoint.  */
+        list_for_each_safe(pos, temp, &ep->asocs) {
+                asoc = list_entry(pos, struct sctp_association, asocs);
+
+                if (sctp_style(sk, TCP)) {
+                        /* A closed association can still be in the list if
+                         * it belongs to a TCP-style listening socket that is
+                         * not yet accepted. If so, free it. If not, send an
+                         * ABORT or SHUTDOWN based on the linger options.
+                         */
+                        if (sctp_state(asoc, CLOSED)) {
+                                sctp_unhash_established(asoc);
+                                sctp_association_free(asoc);
+
+                        } else if (sock_flag(sk, SOCK_LINGER) &&
+                                   !sk->sk_lingertime)
+                                sctp_primitive_ABORT(asoc, NULL);
+                        else
+                                sctp_primitive_SHUTDOWN(asoc, NULL);
+                } else
+                        sctp_primitive_SHUTDOWN(asoc, NULL);
+        }
+
+        /* Clean up any skbs sitting on the receive queue.  */
+        sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
+        sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
+
+        /* On a TCP-style socket, block for at most linger_time if set. */
+        if (sctp_style(sk, TCP) && timeout)
+                sctp_wait_for_close(sk, timeout);
+
+        /* This will run the backlog queue.  */
+        sctp_release_sock(sk);
+
+        /* Supposedly, no process has access to the socket, but
+         * the net layers still may.
+         */
+        sctp_local_bh_disable();
+        sctp_bh_lock_sock(sk);
+
+        /* Hold the sock, since sk_common_release() will put sock_put()
+         * and we have just a little more cleanup.
+         */
+        sock_hold(sk);
+        sk_common_release(sk);
+
+        sctp_bh_unlock_sock(sk);
+        sctp_local_bh_enable();
+
+        sock_put(sk);
+
+        SCTP_DBG_OBJCNT_DEC(sock);
+}
+
+/* Handle EPIPE error. */
+static int sctp_error(struct sock *sk, int flags, int err)
+{
+        if (err == -EPIPE)
+                err = sock_error(sk) ? : -EPIPE;
+        if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
+                send_sig(SIGPIPE, current, 0);
+        return err;
+}
+
+/* API 3.1.3 sendmsg() - UDP Style Syntax
+ *
+ * An application uses sendmsg() and recvmsg() calls to transmit data to
+ * and receive data from its peer.
+ *
+ *  ssize_t sendmsg(int socket, const struct msghdr *message,
+ *                  int flags);
+ *
+ *  socket  - the socket descriptor of the endpoint.
+ *  message - pointer to the msghdr structure which contains a single
+ *            user message and possibly some ancillary data.
+ *
+ *            See Section 5 for complete description of the data
+ *            structures.
+ *
+ *  flags   - flags sent or received with the user message, see Section
+ *            5 for complete description of the flags.
+ *
+ * Note:  This function could use a rewrite especially when explicit
+ * connect support comes in.
+ */
+/* BUG:  We do not implement the equivalent of sk_stream_wait_memory(). */
+
+SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *);
+
+SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk,
+                             struct msghdr *msg, size_t msg_len)
+{
+        struct sctp_sock *sp;
+        struct sctp_endpoint *ep;
+        struct sctp_association *new_asoc=NULL, *asoc=NULL;
+        struct sctp_transport *transport, *chunk_tp;
+        struct sctp_chunk *chunk;
+        union sctp_addr to;
+        struct sockaddr *msg_name = NULL;
+        struct sctp_sndrcvinfo default_sinfo = { 0 };
+        struct sctp_sndrcvinfo *sinfo;
+        struct sctp_initmsg *sinit;
+        sctp_assoc_t associd = 0;
+        sctp_cmsgs_t cmsgs = { NULL };
+        int err;
+        sctp_scope_t scope;
+        long timeo;
+        __u16 sinfo_flags = 0;
+        struct sctp_datamsg *datamsg;
+        struct list_head *pos;
+        int msg_flags = msg->msg_flags;
+
+        SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n",
+                          sk, msg, msg_len);
+
+        err = 0;
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        SCTP_DEBUG_PRINTK("Using endpoint: %s.\n", ep->debug_name);
+
+        /* We cannot send a message over a TCP-style listening socket. */
+        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
+                err = -EPIPE;
+                goto out_nounlock;
+        }
+
+        /* Parse out the SCTP CMSGs.  */
+        err = sctp_msghdr_parse(msg, &cmsgs);
+
+        if (err) {
+                SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err);
+                goto out_nounlock;
+        }
+
+        /* Fetch the destination address for this packet.  This
+         * address only selects the association--it is not necessarily
+         * the address we will send to.
+         * For a peeled-off socket, msg_name is ignored.
+         */
+        if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
+                int msg_namelen = msg->msg_namelen;
+
+                err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
+                                       msg_namelen);
+                if (err)
+                        return err;
+
+                if (msg_namelen > sizeof(to))
+                        msg_namelen = sizeof(to);
+                memcpy(&to, msg->msg_name, msg_namelen);
+                SCTP_DEBUG_PRINTK("Just memcpy'd. msg_name is "
+                                  "0x%x:%u.\n",
+                                  to.v4.sin_addr.s_addr, to.v4.sin_port);
+
+                to.v4.sin_port = ntohs(to.v4.sin_port);
+                msg_name = msg->msg_name;
+        }
+
+        sinfo = cmsgs.info;
+        sinit = cmsgs.init;
+
+        /* Did the user specify SNDRCVINFO?  */
+        if (sinfo) {
+                sinfo_flags = sinfo->sinfo_flags;
+                associd = sinfo->sinfo_assoc_id;
+        }
+
+        SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n",
+                          msg_len, sinfo_flags);
+
+        /* MSG_EOF or MSG_ABORT cannot be set on a TCP-style socket. */
+        if (sctp_style(sk, TCP) && (sinfo_flags & (MSG_EOF | MSG_ABORT))) {
+                err = -EINVAL;
+                goto out_nounlock;
+        }
+
+        /* If MSG_EOF is set, no data can be sent. Disallow sending zero
+         * length messages when MSG_EOF|MSG_ABORT is not set.
+         * If MSG_ABORT is set, the message length could be non zero with
+         * the msg_iov set to the user abort reason.
+         */
+        if (((sinfo_flags & MSG_EOF) && (msg_len > 0)) ||
+            (!(sinfo_flags & (MSG_EOF|MSG_ABORT)) && (msg_len == 0))) {
+                err = -EINVAL;
+                goto out_nounlock;
+        }
+
+        /* If MSG_ADDR_OVER is set, there must be an address
+         * specified in msg_name.
+         */
+        if ((sinfo_flags & MSG_ADDR_OVER) && (!msg->msg_name)) {
+                err = -EINVAL;
+                goto out_nounlock;
+        }
+
+        transport = NULL;
+
+        SCTP_DEBUG_PRINTK("About to look up association.\n");
+
+        sctp_lock_sock(sk);
+
+        /* If a msg_name has been specified, assume this is to be used.  */
+        if (msg_name) {
+                /* Look for a matching association on the endpoint. */
+                asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
+                if (!asoc) {
+                        /* If we could not find a matching association on the
+                         * endpoint, make sure that it is not a TCP-style
+                         * socket that already has an association or there is
+                         * no peeled-off association on another socket.
+                         */
+                        if ((sctp_style(sk, TCP) &&
+                             sctp_sstate(sk, ESTABLISHED)) ||
+                            sctp_endpoint_is_peeled_off(ep, &to)) {
+                                err = -EADDRNOTAVAIL;
+                                goto out_unlock;
+                        }
+                }
+        } else {
+                asoc = sctp_id2assoc(sk, associd);
+                if (!asoc) {
+                        err = -EPIPE;
+                        goto out_unlock;
+                }
+        }
+
+        if (asoc) {
+                SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc);
+
+                /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
+                 * socket that has an association in CLOSED state. This can
+                 * happen when an accepted socket has an association that is
+                 * already CLOSED.
+                 */
+                if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
+                        err = -EPIPE;
+                        goto out_unlock;
+                }
+
+                if (sinfo_flags & MSG_EOF) {
+                        SCTP_DEBUG_PRINTK("Shutting down association: %p\n",
+                                          asoc);
+                        sctp_primitive_SHUTDOWN(asoc, NULL);
+                        err = 0;
+                        goto out_unlock;
+                }
+                if (sinfo_flags & MSG_ABORT) {
+                        SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc);
+                        sctp_primitive_ABORT(asoc, msg);
+                        err = 0;
+                        goto out_unlock;
+                }
+        }
+
+        /* Do we need to create the association?  */
+        if (!asoc) {
+                SCTP_DEBUG_PRINTK("There is no association yet.\n");
+
+                if (sinfo_flags & (MSG_EOF | MSG_ABORT)) {
+                        err = -EINVAL;
+                        goto out_unlock;
+                }
+
+                /* Check for invalid stream against the stream counts,
+                 * either the default or the user specified stream counts.
+                 */
+                if (sinfo) {
+                        if (!sinit || (sinit && !sinit->sinit_num_ostreams)) {
+                                /* Check against the defaults. */
+                                if (sinfo->sinfo_stream >=
+                                    sp->initmsg.sinit_num_ostreams) {
+                                        err = -EINVAL;
+                                        goto out_unlock;
+                                }
+                        } else {
+                                /* Check against the requested.  */
+                                if (sinfo->sinfo_stream >=
+                                    sinit->sinit_num_ostreams) {
+                                        err = -EINVAL;
+                                        goto out_unlock;
+                                }
+                        }
+                }
+
+                /*
+                 * API 3.1.2 bind() - UDP Style Syntax
+                 * If a bind() or sctp_bindx() is not called prior to a
+                 * sendmsg() call that initiates a new association, the
+                 * system picks an ephemeral port and will choose an address
+                 * set equivalent to binding with a wildcard address.
+                 */
+                if (!ep->base.bind_addr.port) {
+                        if (sctp_autobind(sk)) {
+                                err = -EAGAIN;
+                                goto out_unlock;
+                        }
+                }
+
+                scope = sctp_scope(&to);
+                new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
+                if (!new_asoc) {
+                        err = -ENOMEM;
+                        goto out_unlock;
+                }
+                asoc = new_asoc;
+
+                /* If the SCTP_INIT ancillary data is specified, set all
+                 * the association init values accordingly.
+                 */
+                if (sinit) {
+                        if (sinit->sinit_num_ostreams) {
+                                asoc->c.sinit_num_ostreams =
+                                        sinit->sinit_num_ostreams;
+                        }
+                        if (sinit->sinit_max_instreams) {
+                                asoc->c.sinit_max_instreams =
+                                        sinit->sinit_max_instreams;
+                        }
+                        if (sinit->sinit_max_attempts) {
+                                asoc->max_init_attempts
+                                        = sinit->sinit_max_attempts;
+                        }
+                        if (sinit->sinit_max_init_timeo) {
+                                asoc->max_init_timeo = 
+                                 msecs_to_jiffies(sinit->sinit_max_init_timeo);
+                        }
+                }
+
+                /* Prime the peer's transport structures.  */
+                transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL);
+                if (!transport) {
+                        err = -ENOMEM;
+                        goto out_free;
+                }
+                err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
+                if (err < 0) {
+                        err = -ENOMEM;
+                        goto out_free;
+                }
+        }
+
+        /* ASSERT: we have a valid association at this point.  */
+        SCTP_DEBUG_PRINTK("We have a valid association.\n");
+
+        if (!sinfo) {
+                /* If the user didn't specify SNDRCVINFO, make up one with
+                 * some defaults.
+                 */
+                default_sinfo.sinfo_stream = asoc->default_stream;
+                default_sinfo.sinfo_flags = asoc->default_flags;
+                default_sinfo.sinfo_ppid = asoc->default_ppid;
+                default_sinfo.sinfo_context = asoc->default_context;
+                default_sinfo.sinfo_timetolive = asoc->default_timetolive;
+                default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
+                sinfo = &default_sinfo;
+        }
+
+        /* API 7.1.7, the sndbuf size per association bounds the
+         * maximum size of data that can be sent in a single send call.
+         */
+        if (msg_len > sk->sk_sndbuf) {
+                err = -EMSGSIZE;
+                goto out_free;
+        }
+
+        /* If fragmentation is disabled and the message length exceeds the
+         * association fragmentation point, return EMSGSIZE.  The I-D
+         * does not specify what this error is, but this looks like
+         * a great fit.
+         */
+        if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
+                err = -EMSGSIZE;
+                goto out_free;
+        }
+
+        if (sinfo) {
+                /* Check for invalid stream. */
+                if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) {
+                        err = -EINVAL;
+                        goto out_free;
+                }
+        }
+
+        timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
+        if (!sctp_wspace(asoc)) {
+                err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
+                if (err)
+                        goto out_free;
+        }
+
+        /* If an address is passed with the sendto/sendmsg call, it is used
+         * to override the primary destination address in the TCP model, or
+         * when MSG_ADDR_OVER flag is set in the UDP model.
+         */
+        if ((sctp_style(sk, TCP) && msg_name) ||
+            (sinfo_flags & MSG_ADDR_OVER)) {
+                chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
+                if (!chunk_tp) {
+                        err = -EINVAL;
+                        goto out_free;
+                }
+        } else
+                chunk_tp = NULL;
+
+        /* Auto-connect, if we aren't connected already. */
+        if (sctp_state(asoc, CLOSED)) {
+                err = sctp_primitive_ASSOCIATE(asoc, NULL);
+                if (err < 0)
+                        goto out_free;
+                SCTP_DEBUG_PRINTK("We associated primitively.\n");
+        }
+
+        /* Break the message into multiple chunks of maximum size. */
+        datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len);
+        if (!datamsg) {
+                err = -ENOMEM;
+                goto out_free;
+        }
+
+        /* Now send the (possibly) fragmented message. */
+        list_for_each(pos, &datamsg->chunks) {
+                chunk = list_entry(pos, struct sctp_chunk, frag_list);
+                sctp_datamsg_track(chunk);
+
+                /* Do accounting for the write space.  */
+                sctp_set_owner_w(chunk);
+
+                chunk->transport = chunk_tp;
+
+                /* Send it to the lower layers.  Note:  all chunks
+                 * must either fail or succeed.   The lower layer
+                 * works that way today.  Keep it that way or this
+                 * breaks.
+                 */
+                err = sctp_primitive_SEND(asoc, chunk);
+                /* Did the lower layer accept the chunk? */
+                if (err)
+                        sctp_chunk_free(chunk);
+                SCTP_DEBUG_PRINTK("We sent primitively.\n");
+        }
+
+        sctp_datamsg_free(datamsg);
+        if (err)
+                goto out_free;
+        else
+                err = msg_len;
+
+        /* If we are already past ASSOCIATE, the lower
+         * layers are responsible for association cleanup.
+         */
+        goto out_unlock;
+
+out_free:
+        if (new_asoc)
+                sctp_association_free(asoc);
+out_unlock:
+        sctp_release_sock(sk);
+
+out_nounlock:
+        return sctp_error(sk, msg_flags, err);
+
+#if 0
+do_sock_err:
+        if (msg_len)
+                err = msg_len;
+        else
+                err = sock_error(sk);
+        goto out;
+
+do_interrupted:
+        if (msg_len)
+                err = msg_len;
+        goto out;
+#endif /* 0 */
+}
+
+/* This is an extended version of skb_pull() that removes the data from the
+ * start of a skb even when data is spread across the list of skb's in the
+ * frag_list. len specifies the total amount of data that needs to be removed.
+ * when 'len' bytes could be removed from the skb, it returns 0.
+ * If 'len' exceeds the total skb length,  it returns the no. of bytes that
+ * could not be removed.
+ */
+static int sctp_skb_pull(struct sk_buff *skb, int len)
+{
+        struct sk_buff *list;
+        int skb_len = skb_headlen(skb);
+        int rlen;
+
+        if (len <= skb_len) {
+                __skb_pull(skb, len);
+                return 0;
+        }
+        len -= skb_len;
+        __skb_pull(skb, skb_len);
+
+        for (list = skb_shinfo(skb)->frag_list; list; list = list->next) {
+                rlen = sctp_skb_pull(list, len);
+                skb->len -= (len-rlen);
+                skb->data_len -= (len-rlen);
+
+                if (!rlen)
+                        return 0;
+
+                len = rlen;
+        }
+
+        return len;
+}
+
+/* API 3.1.3  recvmsg() - UDP Style Syntax
+ *
+ *  ssize_t recvmsg(int socket, struct msghdr *message,
+ *                    int flags);
+ *
+ *  socket  - the socket descriptor of the endpoint.
+ *  message - pointer to the msghdr structure which contains a single
+ *            user message and possibly some ancillary data.
+ *
+ *            See Section 5 for complete description of the data
+ *            structures.
+ *
+ *  flags   - flags sent or received with the user message, see Section
+ *            5 for complete description of the flags.
+ */
+static struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *);
+
+SCTP_STATIC int sctp_recvmsg(struct kiocb *iocb, struct sock *sk,
+                             struct msghdr *msg, size_t len, int noblock,
+                             int flags, int *addr_len)
+{
+        struct sctp_ulpevent *event = NULL;
+        struct sctp_sock *sp = sctp_sk(sk);
+        struct sk_buff *skb;
+        int copied;
+        int err = 0;
+        int skb_len;
+
+        SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: "
+                          "0x%x, %s: %p)\n", "sk", sk, "msghdr", msg,
+                          "len", len, "knoblauch", noblock,
+                          "flags", flags, "addr_len", addr_len);
+
+        sctp_lock_sock(sk);
+
+        if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) {
+                err = -ENOTCONN;
+                goto out;
+        }
+
+        skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
+        if (!skb)
+                goto out;
+
+        /* Get the total length of the skb including any skb's in the
+         * frag_list.
+         */
+        skb_len = skb->len;
+
+        copied = skb_len;
+        if (copied > len)
+                copied = len;
+
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
+
+        event = sctp_skb2event(skb);
+
+        if (err)
+                goto out_free;
+
+        sock_recv_timestamp(msg, sk, skb);
+        if (sctp_ulpevent_is_notification(event)) {
+                msg->msg_flags |= MSG_NOTIFICATION;
+                sp->pf->event_msgname(event, msg->msg_name, addr_len);
+        } else {
+                sp->pf->skb_msgname(skb, msg->msg_name, addr_len);
+        }
+
+        /* Check if we allow SCTP_SNDRCVINFO. */
+        if (sp->subscribe.sctp_data_io_event)
+                sctp_ulpevent_read_sndrcvinfo(event, msg);
+#if 0
+        /* FIXME: we should be calling IP/IPv6 layers.  */
+        if (sk->sk_protinfo.af_inet.cmsg_flags)
+                ip_cmsg_recv(msg, skb);
+#endif
+
+        err = copied;
+
+        /* If skb's length exceeds the user's buffer, update the skb and
+         * push it back to the receive_queue so that the next call to
+         * recvmsg() will return the remaining data. Don't set MSG_EOR.
+         */
+        if (skb_len > copied) {
+                msg->msg_flags &= ~MSG_EOR;
+                if (flags & MSG_PEEK)
+                        goto out_free;
+                sctp_skb_pull(skb, copied);
+                skb_queue_head(&sk->sk_receive_queue, skb);
+
+                /* When only partial message is copied to the user, increase
+                 * rwnd by that amount. If all the data in the skb is read,
+                 * rwnd is updated when the event is freed.
+                 */
+                sctp_assoc_rwnd_increase(event->asoc, copied);
+                goto out;
+        } else if ((event->msg_flags & MSG_NOTIFICATION) ||
+                   (event->msg_flags & MSG_EOR))
+                msg->msg_flags |= MSG_EOR;
+        else
+                msg->msg_flags &= ~MSG_EOR;
+
+out_free:
+        if (flags & MSG_PEEK) {
+                /* Release the skb reference acquired after peeking the skb in
+                 * sctp_skb_recv_datagram().
+                 */
+                kfree_skb(skb);
+        } else {
+                /* Free the event which includes releasing the reference to
+                 * the owner of the skb, freeing the skb and updating the
+                 * rwnd.
+                 */
+                sctp_ulpevent_free(event);
+        }
+out:
+        sctp_release_sock(sk);
+        return err;
+}
+
+/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
+ *
+ * This option is a on/off flag.  If enabled no SCTP message
+ * fragmentation will be performed.  Instead if a message being sent
+ * exceeds the current PMTU size, the message will NOT be sent and
+ * instead a error will be indicated to the user.
+ */
+static int sctp_setsockopt_disable_fragments(struct sock *sk,
+                                            char __user *optval, int optlen)
+{
+        int val;
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+
+        sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
+
+        return 0;
+}
+
+static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
+                                        int optlen)
+{
+        if (optlen != sizeof(struct sctp_event_subscribe))
+                return -EINVAL;
+        if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
+                return -EFAULT;
+        return 0;
+}
+
+/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
+ *
+ * This socket option is applicable to the UDP-style socket only.  When
+ * set it will cause associations that are idle for more than the
+ * specified number of seconds to automatically close.  An association
+ * being idle is defined an association that has NOT sent or received
+ * user data.  The special value of '0' indicates that no automatic
+ * close of any associations should be performed.  The option expects an
+ * integer defining the number of seconds of idle time before an
+ * association is closed.
+ */
+static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
+                                            int optlen)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        /* Applicable to UDP-style socket only */
+        if (sctp_style(sk, TCP))
+                return -EOPNOTSUPP;
+        if (optlen != sizeof(int))
+                return -EINVAL;
+        if (copy_from_user(&sp->autoclose, optval, optlen))
+                return -EFAULT;
+
+        sp->ep->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ;
+        return 0;
+}
+
+/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
+ *
+ * Applications can enable or disable heartbeats for any peer address of
+ * an association, modify an address's heartbeat interval, force a
+ * heartbeat to be sent immediately, and adjust the address's maximum
+ * number of retransmissions sent before an address is considered
+ * unreachable.  The following structure is used to access and modify an
+ * address's parameters:
+ *
+ *  struct sctp_paddrparams {
+ *      sctp_assoc_t            spp_assoc_id;
+ *      struct sockaddr_storage spp_address;
+ *      uint32_t                spp_hbinterval;
+ *      uint16_t                spp_pathmaxrxt;
+ *  };
+ *
+ *   spp_assoc_id    - (UDP style socket) This is filled in the application,
+ *                     and identifies the association for this query.
+ *   spp_address     - This specifies which address is of interest.
+ *   spp_hbinterval  - This contains the value of the heartbeat interval,
+ *                     in milliseconds.  A value of 0, when modifying the
+ *                     parameter, specifies that the heartbeat on this
+ *                     address should be disabled. A value of UINT32_MAX
+ *                     (4294967295), when modifying the parameter,
+ *                     specifies that a heartbeat should be sent
+ *                     immediately to the peer address, and the current
+ *                     interval should remain unchanged.
+ *   spp_pathmaxrxt  - This contains the maximum number of
+ *                     retransmissions before this address shall be
+ *                     considered unreachable.
+ */
+static int sctp_setsockopt_peer_addr_params(struct sock *sk,
+                                            char __user *optval, int optlen)
+{
+        struct sctp_paddrparams params;
+        struct sctp_transport *trans;
+        int error;
+
+        if (optlen != sizeof(struct sctp_paddrparams))
+                return -EINVAL;
+        if (copy_from_user(&params, optval, optlen))
+                return -EFAULT;
+
+        /*
+         * API 7. Socket Options (setting the default value for the endpoint)
+         * All options that support specific settings on an association by
+         * filling in either an association id variable or a sockaddr_storage
+         * SHOULD also support setting of the same value for the entire endpoint
+         * (i.e. future associations). To accomplish this the following logic is
+         * used when setting one of these options:
+
+         * c) If neither the sockaddr_storage or association identification is
+         *    set i.e. the sockaddr_storage is set to all 0's (INADDR_ANY) and
+         *    the association identification is 0, the settings are a default
+         *    and to be applied to the endpoint (all future associations).
+         */
+
+        /* update default value for endpoint (all future associations) */
+        if (!params.spp_assoc_id && 
+            sctp_is_any(( union sctp_addr *)&params.spp_address)) {
+                /* Manual heartbeat on an endpoint is invalid. */
+                if (0xffffffff == params.spp_hbinterval)
+                        return -EINVAL;
+                else if (params.spp_hbinterval)
+                        sctp_sk(sk)->paddrparam.spp_hbinterval =
+                                                params.spp_hbinterval;
+                if (params.spp_pathmaxrxt)
+                        sctp_sk(sk)->paddrparam.spp_pathmaxrxt =
+                                                params.spp_pathmaxrxt;
+                return 0;
+        }
+
+        trans = sctp_addr_id2transport(sk, &params.spp_address,
+                                       params.spp_assoc_id);
+        if (!trans)
+                return -EINVAL;
+
+        /* Applications can enable or disable heartbeats for any peer address
+         * of an association, modify an address's heartbeat interval, force a
+         * heartbeat to be sent immediately, and adjust the address's maximum
+         * number of retransmissions sent before an address is considered
+         * unreachable.
+         *
+         * The value of the heartbeat interval, in milliseconds. A value of
+         * UINT32_MAX (4294967295), when modifying the parameter, specifies
+         * that a heartbeat should be sent immediately to the peer address,
+         * and the current interval should remain unchanged.
+         */
+        if (0xffffffff == params.spp_hbinterval) {
+                error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans);
+                if (error)
+                        return error;
+        } else {
+        /* The value of the heartbeat interval, in milliseconds. A value of 0,
+         * when modifying the parameter, specifies that the heartbeat on this
+         * address should be disabled.
+         */
+                if (params.spp_hbinterval) {
+                        trans->hb_allowed = 1;
+                        trans->hb_interval = 
+                                msecs_to_jiffies(params.spp_hbinterval);
+                } else
+                        trans->hb_allowed = 0;
+        }
+
+        /* spp_pathmaxrxt contains the maximum number of retransmissions
+         * before this address shall be considered unreachable.
+         */
+        if (params.spp_pathmaxrxt)
+                trans->max_retrans = params.spp_pathmaxrxt;
+
+        return 0;
+}
+
+/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
+ *
+ * Applications can specify protocol parameters for the default association
+ * initialization.  The option name argument to setsockopt() and getsockopt()
+ * is SCTP_INITMSG.
+ *
+ * Setting initialization parameters is effective only on an unconnected
+ * socket (for UDP-style sockets only future associations are effected
+ * by the change).  With TCP-style sockets, this option is inherited by
+ * sockets derived from a listener socket.
+ */
+static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, int optlen)
+{
+        struct sctp_initmsg sinit;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (optlen != sizeof(struct sctp_initmsg))
+                return -EINVAL;
+        if (copy_from_user(&sinit, optval, optlen))
+                return -EFAULT;
+
+        if (sinit.sinit_num_ostreams)
+                sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;      
+        if (sinit.sinit_max_instreams)
+                sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;    
+        if (sinit.sinit_max_attempts)
+                sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;      
+        if (sinit.sinit_max_init_timeo)
+                sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;  
+
+        return 0;
+}
+
+/*
+ * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
+ *
+ *   Applications that wish to use the sendto() system call may wish to
+ *   specify a default set of parameters that would normally be supplied
+ *   through the inclusion of ancillary data.  This socket option allows
+ *   such an application to set the default sctp_sndrcvinfo structure.
+ *   The application that wishes to use this socket option simply passes
+ *   in to this call the sctp_sndrcvinfo structure defined in Section
+ *   5.2.2) The input parameters accepted by this call include
+ *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
+ *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
+ *   to this call if the caller is using the UDP model.
+ */
+static int sctp_setsockopt_default_send_param(struct sock *sk,
+                                                char __user *optval, int optlen)
+{
+        struct sctp_sndrcvinfo info;
+        struct sctp_association *asoc;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (optlen != sizeof(struct sctp_sndrcvinfo))
+                return -EINVAL;
+        if (copy_from_user(&info, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
+        if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        if (asoc) {
+                asoc->default_stream = info.sinfo_stream;
+                asoc->default_flags = info.sinfo_flags;
+                asoc->default_ppid = info.sinfo_ppid;
+                asoc->default_context = info.sinfo_context;
+                asoc->default_timetolive = info.sinfo_timetolive;
+        } else {
+                sp->default_stream = info.sinfo_stream;
+                sp->default_flags = info.sinfo_flags;
+                sp->default_ppid = info.sinfo_ppid;
+                sp->default_context = info.sinfo_context;
+                sp->default_timetolive = info.sinfo_timetolive;
+        }
+
+        return 0;
+}
+
+/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
+ *
+ * Requests that the local SCTP stack use the enclosed peer address as
+ * the association primary.  The enclosed address must be one of the
+ * association peer's addresses.
+ */
+static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
+                                        int optlen)
+{
+        struct sctp_prim prim;
+        struct sctp_transport *trans;
+
+        if (optlen != sizeof(struct sctp_prim))
+                return -EINVAL;
+
+        if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
+                return -EFAULT;
+
+        trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
+        if (!trans)
+                return -EINVAL;
+
+        sctp_assoc_set_primary(trans->asoc, trans);
+
+        return 0;
+}
+
+/*
+ * 7.1.5 SCTP_NODELAY
+ *
+ * Turn on/off any Nagle-like algorithm.  This means that packets are
+ * generally sent as soon as possible and no unnecessary delays are
+ * introduced, at the cost of more packets in the network.  Expects an
+ *  integer boolean flag.
+ */
+static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
+                                        int optlen)
+{
+        int val;
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+
+        sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
+        return 0;
+}
+
+/*
+ *
+ * 7.1.1 SCTP_RTOINFO
+ *
+ * The protocol parameters used to initialize and bound retransmission
+ * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
+ * and modify these parameters.
+ * All parameters are time values, in milliseconds.  A value of 0, when
+ * modifying the parameters, indicates that the current value should not
+ * be changed.
+ *
+ */
+static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, int optlen) {
+        struct sctp_rtoinfo rtoinfo;
+        struct sctp_association *asoc;
+
+        if (optlen != sizeof (struct sctp_rtoinfo))
+                return -EINVAL;
+
+        if (copy_from_user(&rtoinfo, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
+
+        /* Set the values to the specific association */
+        if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        if (asoc) {
+                if (rtoinfo.srto_initial != 0)
+                        asoc->rto_initial = 
+                                msecs_to_jiffies(rtoinfo.srto_initial);
+                if (rtoinfo.srto_max != 0)
+                        asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max);
+                if (rtoinfo.srto_min != 0)
+                        asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min);
+        } else {
+                /* If there is no association or the association-id = 0
+                 * set the values to the endpoint.
+                 */
+                struct sctp_sock *sp = sctp_sk(sk);
+
+                if (rtoinfo.srto_initial != 0)
+                        sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
+                if (rtoinfo.srto_max != 0)
+                        sp->rtoinfo.srto_max = rtoinfo.srto_max;
+                if (rtoinfo.srto_min != 0)
+                        sp->rtoinfo.srto_min = rtoinfo.srto_min;
+        }
+
+        return 0;
+}
+
+/*
+ *
+ * 7.1.2 SCTP_ASSOCINFO
+ *
+ * This option is used to tune the the maximum retransmission attempts
+ * of the association.
+ * Returns an error if the new association retransmission value is
+ * greater than the sum of the retransmission value  of the peer.
+ * See [SCTP] for more information.
+ *
+ */
+static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, int optlen)
+{
+
+        struct sctp_assocparams assocparams;
+        struct sctp_association *asoc;
+
+        if (optlen != sizeof(struct sctp_assocparams))
+                return -EINVAL;
+        if (copy_from_user(&assocparams, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
+
+        if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        /* Set the values to the specific association */
+        if (asoc) {
+                if (assocparams.sasoc_asocmaxrxt != 0)
+                        asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
+                if (assocparams.sasoc_cookie_life != 0) {
+                        asoc->cookie_life.tv_sec =
+                                        assocparams.sasoc_cookie_life / 1000;
+                        asoc->cookie_life.tv_usec =
+                                        (assocparams.sasoc_cookie_life % 1000)
+                                        * 1000;
+                }
+        } else {
+                /* Set the values to the endpoint */
+                struct sctp_sock *sp = sctp_sk(sk);
+
+                if (assocparams.sasoc_asocmaxrxt != 0)
+                        sp->assocparams.sasoc_asocmaxrxt =
+                                                assocparams.sasoc_asocmaxrxt;
+                if (assocparams.sasoc_cookie_life != 0)
+                        sp->assocparams.sasoc_cookie_life =
+                                                assocparams.sasoc_cookie_life;
+        }
+        return 0;
+}
+
+/*
+ * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
+ *
+ * This socket option is a boolean flag which turns on or off mapped V4
+ * addresses.  If this option is turned on and the socket is type
+ * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
+ * If this option is turned off, then no mapping will be done of V4
+ * addresses and a user will receive both PF_INET6 and PF_INET type
+ * addresses on the socket.
+ */
+static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, int optlen)
+{
+        int val;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+        if (val)
+                sp->v4mapped = 1;
+        else
+                sp->v4mapped = 0;
+
+        return 0;
+}
+
+/*
+ * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
+ *
+ * This socket option specifies the maximum size to put in any outgoing
+ * SCTP chunk.  If a message is larger than this size it will be
+ * fragmented by SCTP into the specified size.  Note that the underlying
+ * SCTP implementation may fragment into smaller sized chunks when the
+ * PMTU of the underlying association is smaller than the value set by
+ * the user.
+ */
+static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, int optlen)
+{
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        struct sctp_sock *sp = sctp_sk(sk);
+        int val;
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+        if ((val < 8) || (val > SCTP_MAX_CHUNK_LEN))
+                return -EINVAL;
+        sp->user_frag = val;
+
+        if (val) {
+                /* Update the frag_point of the existing associations. */
+                list_for_each(pos, &(sp->ep->asocs)) {
+                        asoc = list_entry(pos, struct sctp_association, asocs);
+                        asoc->frag_point = sctp_frag_point(sp, asoc->pmtu); 
+                }
+        }
+
+        return 0;
+}
+
+
+/*
+ *  7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
+ *
+ *   Requests that the peer mark the enclosed address as the association
+ *   primary. The enclosed address must be one of the association's
+ *   locally bound addresses. The following structure is used to make a
+ *   set primary request:
+ */
+static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
+                                             int optlen)
+{
+        struct sctp_sock        *sp;
+        struct sctp_endpoint    *ep;
+        struct sctp_association *asoc = NULL;
+        struct sctp_setpeerprim prim;
+        struct sctp_chunk       *chunk;
+        int                     err;
+
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        if (!sctp_addip_enable)
+                return -EPERM;
+
+        if (optlen != sizeof(struct sctp_setpeerprim))
+                return -EINVAL;
+
+        if (copy_from_user(&prim, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
+        if (!asoc) 
+                return -EINVAL;
+
+        if (!asoc->peer.asconf_capable)
+                return -EPERM;
+
+        if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
+                return -EPERM;
+
+        if (!sctp_state(asoc, ESTABLISHED))
+                return -ENOTCONN;
+
+        if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
+                return -EADDRNOTAVAIL;
+
+        /* Create an ASCONF chunk with SET_PRIMARY parameter    */
+        chunk = sctp_make_asconf_set_prim(asoc,
+                                          (union sctp_addr *)&prim.sspp_addr);
+        if (!chunk)
+                return -ENOMEM;
+
+        err = sctp_send_asconf(asoc, chunk);
+
+        SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n");
+
+        return err;
+}
+
+static int sctp_setsockopt_adaption_layer(struct sock *sk, char __user *optval,
+                                          int optlen)
+{
+        __u32 val;
+
+        if (optlen < sizeof(__u32))
+                return -EINVAL;
+        if (copy_from_user(&val, optval, sizeof(__u32)))
+                return -EFAULT;
+
+        sctp_sk(sk)->adaption_ind = val;
+
+        return 0;
+}
+
+/* API 6.2 setsockopt(), getsockopt()
+ *
+ * Applications use setsockopt() and getsockopt() to set or retrieve
+ * socket options.  Socket options are used to change the default
+ * behavior of sockets calls.  They are described in Section 7.
+ *
+ * The syntax is:
+ *
+ *   ret = getsockopt(int sd, int level, int optname, void __user *optval,
+ *                    int __user *optlen);
+ *   ret = setsockopt(int sd, int level, int optname, const void __user *optval,
+ *                    int optlen);
+ *
+ *   sd      - the socket descript.
+ *   level   - set to IPPROTO_SCTP for all SCTP options.
+ *   optname - the option name.
+ *   optval  - the buffer to store the value of the option.
+ *   optlen  - the size of the buffer.
+ */
+SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
+                                char __user *optval, int optlen)
+{
+        int retval = 0;
+
+        SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n",
+                          sk, optname);
+
+        /* I can hardly begin to describe how wrong this is.  This is
+         * so broken as to be worse than useless.  The API draft
+         * REALLY is NOT helpful here...  I am not convinced that the
+         * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
+         * are at all well-founded.
+         */
+        if (level != SOL_SCTP) {
+                struct sctp_af *af = sctp_sk(sk)->pf->af;
+                retval = af->setsockopt(sk, level, optname, optval, optlen);
+                goto out_nounlock;
+        }
+
+        sctp_lock_sock(sk);
+
+        switch (optname) {
+        case SCTP_SOCKOPT_BINDX_ADD:
+                /* 'optlen' is the size of the addresses buffer. */
+                retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
+                                               optlen, SCTP_BINDX_ADD_ADDR);
+                break;
+
+        case SCTP_SOCKOPT_BINDX_REM:
+                /* 'optlen' is the size of the addresses buffer. */
+                retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
+                                               optlen, SCTP_BINDX_REM_ADDR);
+                break;
+
+        case SCTP_DISABLE_FRAGMENTS:
+                retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
+                break;
+
+        case SCTP_EVENTS:
+                retval = sctp_setsockopt_events(sk, optval, optlen);
+                break;
+
+        case SCTP_AUTOCLOSE:
+                retval = sctp_setsockopt_autoclose(sk, optval, optlen);
+                break;
+
+        case SCTP_PEER_ADDR_PARAMS:
+                retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
+                break;
+
+        case SCTP_INITMSG:
+                retval = sctp_setsockopt_initmsg(sk, optval, optlen);
+                break;
+        case SCTP_DEFAULT_SEND_PARAM:
+                retval = sctp_setsockopt_default_send_param(sk, optval,
+                                                            optlen);
+                break;
+        case SCTP_PRIMARY_ADDR:
+                retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
+                break;
+        case SCTP_SET_PEER_PRIMARY_ADDR:
+                retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
+                break;
+        case SCTP_NODELAY:
+                retval = sctp_setsockopt_nodelay(sk, optval, optlen);
+                break;
+        case SCTP_RTOINFO:
+                retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
+                break;
+        case SCTP_ASSOCINFO:
+                retval = sctp_setsockopt_associnfo(sk, optval, optlen);
+                break;
+        case SCTP_I_WANT_MAPPED_V4_ADDR:
+                retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
+                break;
+        case SCTP_MAXSEG:
+                retval = sctp_setsockopt_maxseg(sk, optval, optlen);
+                break;
+        case SCTP_ADAPTION_LAYER:
+                retval = sctp_setsockopt_adaption_layer(sk, optval, optlen);
+                break;
+
+        default:
+                retval = -ENOPROTOOPT;
+                break;
+        };
+
+        sctp_release_sock(sk);
+
+out_nounlock:
+        return retval;
+}
+
+/* API 3.1.6 connect() - UDP Style Syntax
+ *
+ * An application may use the connect() call in the UDP model to initiate an
+ * association without sending data.
+ *
+ * The syntax is:
+ *
+ * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
+ *
+ * sd: the socket descriptor to have a new association added to.
+ *
+ * nam: the address structure (either struct sockaddr_in or struct
+ *    sockaddr_in6 defined in RFC2553 [7]).
+ *
+ * len: the size of the address.
+ */
+SCTP_STATIC int sctp_connect(struct sock *sk, struct sockaddr *uaddr,
+                             int addr_len)
+{
+        struct sctp_sock *sp;
+        struct sctp_endpoint *ep;
+        struct sctp_association *asoc;
+        struct sctp_transport *transport;
+        union sctp_addr to;
+        struct sctp_af *af;
+        sctp_scope_t scope;
+        long timeo;
+        int err = 0;
+
+        sctp_lock_sock(sk);
+
+        SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d)\n",
+                          __FUNCTION__, sk, uaddr, addr_len);
+
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        /* connect() cannot be done on a socket that is already in ESTABLISHED
+         * state - UDP-style peeled off socket or a TCP-style socket that
+         * is already connected.
+         * It cannot be done even on a TCP-style listening socket.
+         */
+        if (sctp_sstate(sk, ESTABLISHED) ||
+            (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
+                err = -EISCONN;
+                goto out_unlock;
+        }
+
+        err = sctp_verify_addr(sk, (union sctp_addr *)uaddr, addr_len);
+        if (err)
+                goto out_unlock;
+
+        if (addr_len > sizeof(to))
+                addr_len = sizeof(to);
+        memcpy(&to, uaddr, addr_len);
+        to.v4.sin_port = ntohs(to.v4.sin_port);
+
+        asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
+        if (asoc) {
+                if (asoc->state >= SCTP_STATE_ESTABLISHED)
+                        err = -EISCONN;
+                else
+                        err = -EALREADY;
+                goto out_unlock;
+        }
+
+        /* If we could not find a matching association on the endpoint,
+         * make sure that there is no peeled-off association matching the
+         * peer address even on another socket.
+         */
+        if (sctp_endpoint_is_peeled_off(ep, &to)) {
+                err = -EADDRNOTAVAIL;
+                goto out_unlock;
+        }
+
+        /* If a bind() or sctp_bindx() is not called prior to a connect()
+         * call, the system picks an ephemeral port and will choose an address
+         * set equivalent to binding with a wildcard address.
+         */
+        if (!ep->base.bind_addr.port) {
+                if (sctp_autobind(sk)) {
+                        err = -EAGAIN;
+                        goto out_unlock;
+                }
+        }
+
+        scope = sctp_scope(&to);
+        asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
+        if (!asoc) {
+                err = -ENOMEM;
+                goto out_unlock;
+        }
+
+        /* Prime the peer's transport structures.  */
+        transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL);
+        if (!transport) {
+                sctp_association_free(asoc);
+                goto out_unlock;
+        }
+        err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
+        if (err < 0) {
+                sctp_association_free(asoc);
+                goto out_unlock;
+        }
+
+        err = sctp_primitive_ASSOCIATE(asoc, NULL);
+        if (err < 0) {
+                sctp_association_free(asoc);
+                goto out_unlock;
+        }
+
+        /* Initialize sk's dport and daddr for getpeername() */
+        inet_sk(sk)->dport = htons(asoc->peer.port);
+        af = sctp_get_af_specific(to.sa.sa_family);
+        af->to_sk_daddr(&to, sk);
+
+        timeo = sock_sndtimeo(sk, sk->sk_socket->file->f_flags & O_NONBLOCK);
+        err = sctp_wait_for_connect(asoc, &timeo);
+
+out_unlock:
+        sctp_release_sock(sk);
+
+        return err;
+}
+
+/* FIXME: Write comments. */
+SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags)
+{
+        return -EOPNOTSUPP; /* STUB */
+}
+
+/* 4.1.4 accept() - TCP Style Syntax
+ *
+ * Applications use accept() call to remove an established SCTP
+ * association from the accept queue of the endpoint.  A new socket
+ * descriptor will be returned from accept() to represent the newly
+ * formed association.
+ */
+SCTP_STATIC struct sock *sctp_accept(struct sock *sk, int flags, int *err)
+{
+        struct sctp_sock *sp;
+        struct sctp_endpoint *ep;
+        struct sock *newsk = NULL;
+        struct sctp_association *asoc;
+        long timeo;
+        int error = 0;
+
+        sctp_lock_sock(sk);
+
+        sp = sctp_sk(sk);
+        ep = sp->ep;
+
+        if (!sctp_style(sk, TCP)) {
+                error = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!sctp_sstate(sk, LISTENING)) {
+                error = -EINVAL;
+                goto out;
+        }
+
+        timeo = sock_rcvtimeo(sk, sk->sk_socket->file->f_flags & O_NONBLOCK);
+
+        error = sctp_wait_for_accept(sk, timeo);
+        if (error)
+                goto out;
+
+        /* We treat the list of associations on the endpoint as the accept
+         * queue and pick the first association on the list.
+         */
+        asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
+
+        newsk = sp->pf->create_accept_sk(sk, asoc);
+        if (!newsk) {
+                error = -ENOMEM;
+                goto out;
+        }
+
+        /* Populate the fields of the newsk from the oldsk and migrate the
+         * asoc to the newsk.
+         */
+        sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
+
+out:
+        sctp_release_sock(sk);
+        *err = error;
+        return newsk;
+}
+
+/* The SCTP ioctl handler. */
+SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
+{
+        return -ENOIOCTLCMD;
+}
+
+/* This is the function which gets called during socket creation to
+ * initialized the SCTP-specific portion of the sock.
+ * The sock structure should already be zero-filled memory.
+ */
+SCTP_STATIC int sctp_init_sock(struct sock *sk)
+{
+        struct sctp_endpoint *ep;
+        struct sctp_sock *sp;
+
+        SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk);
+
+        sp = sctp_sk(sk);
+
+        /* Initialize the SCTP per socket area.  */
+        switch (sk->sk_type) {
+        case SOCK_SEQPACKET:
+                sp->type = SCTP_SOCKET_UDP;
+                break;
+        case SOCK_STREAM:
+                sp->type = SCTP_SOCKET_TCP;
+                break;
+        default:
+                return -ESOCKTNOSUPPORT;
+        }
+
+        /* Initialize default send parameters. These parameters can be
+         * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
+         */
+        sp->default_stream = 0;
+        sp->default_ppid = 0;
+        sp->default_flags = 0;
+        sp->default_context = 0;
+        sp->default_timetolive = 0;
+
+        /* Initialize default setup parameters. These parameters
+         * can be modified with the SCTP_INITMSG socket option or
+         * overridden by the SCTP_INIT CMSG.
+         */
+        sp->initmsg.sinit_num_ostreams   = sctp_max_outstreams;
+        sp->initmsg.sinit_max_instreams  = sctp_max_instreams;
+        sp->initmsg.sinit_max_attempts   = sctp_max_retrans_init;
+        sp->initmsg.sinit_max_init_timeo = jiffies_to_msecs(sctp_rto_max);
+
+        /* Initialize default RTO related parameters.  These parameters can
+         * be modified for with the SCTP_RTOINFO socket option.
+         */
+        sp->rtoinfo.srto_initial = jiffies_to_msecs(sctp_rto_initial);
+        sp->rtoinfo.srto_max     = jiffies_to_msecs(sctp_rto_max);
+        sp->rtoinfo.srto_min     = jiffies_to_msecs(sctp_rto_min);
+
+        /* Initialize default association related parameters. These parameters
+         * can be modified with the SCTP_ASSOCINFO socket option.
+         */
+        sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association;
+        sp->assocparams.sasoc_number_peer_destinations = 0;
+        sp->assocparams.sasoc_peer_rwnd = 0;
+        sp->assocparams.sasoc_local_rwnd = 0;
+        sp->assocparams.sasoc_cookie_life = 
+                jiffies_to_msecs(sctp_valid_cookie_life);
+
+        /* Initialize default event subscriptions. By default, all the
+         * options are off. 
+         */
+        memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));
+
+        /* Default Peer Address Parameters.  These defaults can
+         * be modified via SCTP_PEER_ADDR_PARAMS
+         */
+        sp->paddrparam.spp_hbinterval = jiffies_to_msecs(sctp_hb_interval);
+        sp->paddrparam.spp_pathmaxrxt = sctp_max_retrans_path;
+
+        /* If enabled no SCTP message fragmentation will be performed.
+         * Configure through SCTP_DISABLE_FRAGMENTS socket option.
+         */
+        sp->disable_fragments = 0;
+
+        /* Turn on/off any Nagle-like algorithm.  */
+        sp->nodelay           = 1;
+
+        /* Enable by default. */
+        sp->v4mapped          = 1;
+
+        /* Auto-close idle associations after the configured
+         * number of seconds.  A value of 0 disables this
+         * feature.  Configure through the SCTP_AUTOCLOSE socket option,
+         * for UDP-style sockets only.
+         */
+        sp->autoclose         = 0;
+
+        /* User specified fragmentation limit. */
+        sp->user_frag         = 0;
+
+        sp->adaption_ind = 0;
+
+        sp->pf = sctp_get_pf_specific(sk->sk_family);
+
+        /* Control variables for partial data delivery. */
+        sp->pd_mode           = 0;
+        skb_queue_head_init(&sp->pd_lobby);
+
+        /* Create a per socket endpoint structure.  Even if we
+         * change the data structure relationships, this may still
+         * be useful for storing pre-connect address information.
+         */
+        ep = sctp_endpoint_new(sk, GFP_KERNEL);
+        if (!ep)
+                return -ENOMEM;
+
+        sp->ep = ep;
+        sp->hmac = NULL;
+
+        SCTP_DBG_OBJCNT_INC(sock);
+        return 0;
+}
+
+/* Cleanup any SCTP per socket resources.  */
+SCTP_STATIC int sctp_destroy_sock(struct sock *sk)
+{
+        struct sctp_endpoint *ep;
+
+        SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk);
+
+        /* Release our hold on the endpoint. */
+        ep = sctp_sk(sk)->ep;
+        sctp_endpoint_free(ep);
+
+        return 0;
+}
+
+/* API 4.1.7 shutdown() - TCP Style Syntax
+ *     int shutdown(int socket, int how);
+ *
+ *     sd      - the socket descriptor of the association to be closed.
+ *     how     - Specifies the type of shutdown.  The  values  are
+ *               as follows:
+ *               SHUT_RD
+ *                     Disables further receive operations. No SCTP
+ *                     protocol action is taken.
+ *               SHUT_WR
+ *                     Disables further send operations, and initiates
+ *                     the SCTP shutdown sequence.
+ *               SHUT_RDWR
+ *                     Disables further send  and  receive  operations
+ *                     and initiates the SCTP shutdown sequence.
+ */
+SCTP_STATIC void sctp_shutdown(struct sock *sk, int how)
+{
+        struct sctp_endpoint *ep;
+        struct sctp_association *asoc;
+
+        if (!sctp_style(sk, TCP))
+                return;
+
+        if (how & SEND_SHUTDOWN) {
+                ep = sctp_sk(sk)->ep;
+                if (!list_empty(&ep->asocs)) {
+                        asoc = list_entry(ep->asocs.next,
+                                          struct sctp_association, asocs);
+                        sctp_primitive_SHUTDOWN(asoc, NULL);
+                }
+        }
+}
+
+/* 7.2.1 Association Status (SCTP_STATUS)
+
+ * Applications can retrieve current status information about an
+ * association, including association state, peer receiver window size,
+ * number of unacked data chunks, and number of data chunks pending
+ * receipt.  This information is read-only.
+ */
+static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
+                                       char __user *optval,
+                                       int __user *optlen)
+{
+        struct sctp_status status;
+        struct sctp_association *asoc = NULL;
+        struct sctp_transport *transport;
+        sctp_assoc_t associd;
+        int retval = 0;
+
+        if (len != sizeof(status)) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        if (copy_from_user(&status, optval, sizeof(status))) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        associd = status.sstat_assoc_id;
+        asoc = sctp_id2assoc(sk, associd);
+        if (!asoc) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        transport = asoc->peer.primary_path;
+
+        status.sstat_assoc_id = sctp_assoc2id(asoc);
+        status.sstat_state = asoc->state;
+        status.sstat_rwnd =  asoc->peer.rwnd;
+        status.sstat_unackdata = asoc->unack_data;
+
+        status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
+        status.sstat_instrms = asoc->c.sinit_max_instreams;
+        status.sstat_outstrms = asoc->c.sinit_num_ostreams;
+        status.sstat_fragmentation_point = asoc->frag_point;
+        status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
+        memcpy(&status.sstat_primary.spinfo_address,
+               &(transport->ipaddr), sizeof(union sctp_addr));
+        /* Map ipv4 address into v4-mapped-on-v6 address.  */
+        sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
+                (union sctp_addr *)&status.sstat_primary.spinfo_address);
+        status.sstat_primary.spinfo_state = transport->active;
+        status.sstat_primary.spinfo_cwnd = transport->cwnd;
+        status.sstat_primary.spinfo_srtt = transport->srtt;
+        status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
+        status.sstat_primary.spinfo_mtu = transport->pmtu;
+
+        if (put_user(len, optlen)) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n",
+                          len, status.sstat_state, status.sstat_rwnd,
+                          status.sstat_assoc_id);
+
+        if (copy_to_user(optval, &status, len)) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+out:
+        return (retval);
+}
+
+
+/* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
+ *
+ * Applications can retrieve information about a specific peer address
+ * of an association, including its reachability state, congestion
+ * window, and retransmission timer values.  This information is
+ * read-only.
+ */
+static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
+                                          char __user *optval,
+                                          int __user *optlen)
+{
+        struct sctp_paddrinfo pinfo;
+        struct sctp_transport *transport;
+        int retval = 0;
+
+        if (len != sizeof(pinfo)) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        if (copy_from_user(&pinfo, optval, sizeof(pinfo))) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
+                                           pinfo.spinfo_assoc_id);
+        if (!transport)
+                return -EINVAL;
+
+        pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
+        pinfo.spinfo_state = transport->active;
+        pinfo.spinfo_cwnd = transport->cwnd;
+        pinfo.spinfo_srtt = transport->srtt;
+        pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
+        pinfo.spinfo_mtu = transport->pmtu;
+
+        if (put_user(len, optlen)) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        if (copy_to_user(optval, &pinfo, len)) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+out:
+        return (retval);
+}
+
+/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
+ *
+ * This option is a on/off flag.  If enabled no SCTP message
+ * fragmentation will be performed.  Instead if a message being sent
+ * exceeds the current PMTU size, the message will NOT be sent and
+ * instead a error will be indicated to the user.
+ */
+static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
+                                        char __user *optval, int __user *optlen)
+{
+        int val;
+
+        if (len < sizeof(int))
+                return -EINVAL;
+
+        len = sizeof(int);
+        val = (sctp_sk(sk)->disable_fragments == 1);
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+        return 0;
+}
+
+/* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
+ *
+ * This socket option is used to specify various notifications and
+ * ancillary data the user wishes to receive.
+ */
+static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
+                                  int __user *optlen)
+{
+        if (len != sizeof(struct sctp_event_subscribe))
+                return -EINVAL;
+        if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))
+                return -EFAULT;
+        return 0;
+}
+
+/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
+ *
+ * This socket option is applicable to the UDP-style socket only.  When
+ * set it will cause associations that are idle for more than the
+ * specified number of seconds to automatically close.  An association
+ * being idle is defined an association that has NOT sent or received
+ * user data.  The special value of '0' indicates that no automatic
+ * close of any associations should be performed.  The option expects an
+ * integer defining the number of seconds of idle time before an
+ * association is closed.
+ */
+static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
+{
+        /* Applicable to UDP-style socket only */
+        if (sctp_style(sk, TCP))
+                return -EOPNOTSUPP;
+        if (len != sizeof(int))
+                return -EINVAL;
+        if (copy_to_user(optval, &sctp_sk(sk)->autoclose, len))
+                return -EFAULT;
+        return 0;
+}
+
+/* Helper routine to branch off an association to a new socket.  */
+SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,
+                                struct socket **sockp)
+{
+        struct sock *sk = asoc->base.sk;
+        struct socket *sock;
+        int err = 0;
+
+        /* An association cannot be branched off from an already peeled-off
+         * socket, nor is this supported for tcp style sockets.
+         */
+        if (!sctp_style(sk, UDP))
+                return -EINVAL;
+
+        /* Create a new socket.  */
+        err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
+        if (err < 0)
+                return err;
+
+        /* Populate the fields of the newsk from the oldsk and migrate the
+         * asoc to the newsk.
+         */
+        sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
+        *sockp = sock;
+
+        return err;
+}
+
+static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
+{
+        sctp_peeloff_arg_t peeloff;
+        struct socket *newsock;
+        int retval = 0;
+        struct sctp_association *asoc;
+
+        if (len != sizeof(sctp_peeloff_arg_t))
+                return -EINVAL;
+        if (copy_from_user(&peeloff, optval, len))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, peeloff.associd);
+        if (!asoc) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __FUNCTION__, sk, asoc);
+
+        retval = sctp_do_peeloff(asoc, &newsock);
+        if (retval < 0)
+                goto out;
+
+        /* Map the socket to an unused fd that can be returned to the user.  */
+        retval = sock_map_fd(newsock);
+        if (retval < 0) {
+                sock_release(newsock);
+                goto out;
+        }
+
+        SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n",
+                          __FUNCTION__, sk, asoc, newsock->sk, retval);
+
+        /* Return the fd mapped to the new socket.  */
+        peeloff.sd = retval;
+        if (copy_to_user(optval, &peeloff, len))
+                retval = -EFAULT;
+
+out:
+        return retval;
+}
+
+/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
+ *
+ * Applications can enable or disable heartbeats for any peer address of
+ * an association, modify an address's heartbeat interval, force a
+ * heartbeat to be sent immediately, and adjust the address's maximum
+ * number of retransmissions sent before an address is considered
+ * unreachable.  The following structure is used to access and modify an
+ * address's parameters:
+ *
+ *  struct sctp_paddrparams {
+ *      sctp_assoc_t            spp_assoc_id;
+ *      struct sockaddr_storage spp_address;
+ *      uint32_t                spp_hbinterval;
+ *      uint16_t                spp_pathmaxrxt;
+ *  };
+ *
+ *   spp_assoc_id    - (UDP style socket) This is filled in the application,
+ *                     and identifies the association for this query.
+ *   spp_address     - This specifies which address is of interest.
+ *   spp_hbinterval  - This contains the value of the heartbeat interval,
+ *                     in milliseconds.  A value of 0, when modifying the
+ *                     parameter, specifies that the heartbeat on this
+ *                     address should be disabled. A value of UINT32_MAX
+ *                     (4294967295), when modifying the parameter,
+ *                     specifies that a heartbeat should be sent
+ *                     immediately to the peer address, and the current
+ *                     interval should remain unchanged.
+ *   spp_pathmaxrxt  - This contains the maximum number of
+ *                     retransmissions before this address shall be
+ *                     considered unreachable.
+ */
+static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
+                                                char __user *optval, int __user *optlen)
+{
+        struct sctp_paddrparams params;
+        struct sctp_transport *trans;
+
+        if (len != sizeof(struct sctp_paddrparams))
+                return -EINVAL;
+        if (copy_from_user(&params, optval, len))
+                return -EFAULT;
+
+        /* If no association id is specified retrieve the default value
+         * for the endpoint that will be used for all future associations
+         */
+        if (!params.spp_assoc_id &&
+            sctp_is_any(( union sctp_addr *)&params.spp_address)) {
+                params.spp_hbinterval = sctp_sk(sk)->paddrparam.spp_hbinterval;
+                params.spp_pathmaxrxt = sctp_sk(sk)->paddrparam.spp_pathmaxrxt;
+
+                goto done;
+        }
+
+        trans = sctp_addr_id2transport(sk, &params.spp_address,
+                                       params.spp_assoc_id);
+        if (!trans)
+                return -EINVAL;
+
+        /* The value of the heartbeat interval, in milliseconds. A value of 0,
+         * when modifying the parameter, specifies that the heartbeat on this
+         * address should be disabled.
+         */
+        if (!trans->hb_allowed)
+                params.spp_hbinterval = 0;
+        else
+                params.spp_hbinterval = jiffies_to_msecs(trans->hb_interval);
+
+        /* spp_pathmaxrxt contains the maximum number of retransmissions
+         * before this address shall be considered unreachable.
+         */
+        params.spp_pathmaxrxt = trans->max_retrans;
+
+done:
+        if (copy_to_user(optval, &params, len))
+                return -EFAULT;
+
+        if (put_user(len, optlen))
+                return -EFAULT;
+
+        return 0;
+}
+
+/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
+ *
+ * Applications can specify protocol parameters for the default association
+ * initialization.  The option name argument to setsockopt() and getsockopt()
+ * is SCTP_INITMSG.
+ *
+ * Setting initialization parameters is effective only on an unconnected
+ * socket (for UDP-style sockets only future associations are effected
+ * by the change).  With TCP-style sockets, this option is inherited by
+ * sockets derived from a listener socket.
+ */
+static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
+{
+        if (len != sizeof(struct sctp_initmsg))
+                return -EINVAL;
+        if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
+                return -EFAULT;
+        return 0;
+}
+
+static int sctp_getsockopt_peer_addrs_num(struct sock *sk, int len,
+                                          char __user *optval, int __user *optlen)
+{
+        sctp_assoc_t id;
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        int cnt = 0;
+
+        if (len != sizeof(sctp_assoc_t))
+                return -EINVAL;
+
+        if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
+                return -EFAULT;
+
+        /* For UDP-style sockets, id specifies the association to query.  */
+        asoc = sctp_id2assoc(sk, id);
+        if (!asoc)
+                return -EINVAL;
+
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                cnt ++;
+        }
+
+        return cnt;
+}
+
+static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
+                                      char __user *optval, int __user *optlen)
+{
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        int cnt = 0;
+        struct sctp_getaddrs getaddrs;
+        struct sctp_transport *from;
+        void __user *to;
+        union sctp_addr temp;
+        struct sctp_sock *sp = sctp_sk(sk);
+        int addrlen;
+
+        if (len != sizeof(struct sctp_getaddrs))
+                return -EINVAL;
+
+        if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
+                return -EFAULT;
+
+        if (getaddrs.addr_num <= 0) return -EINVAL;
+
+        /* For UDP-style sockets, id specifies the association to query.  */
+        asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
+        if (!asoc)
+                return -EINVAL;
+
+        to = (void __user *)getaddrs.addrs;
+        list_for_each(pos, &asoc->peer.transport_addr_list) {
+                from = list_entry(pos, struct sctp_transport, transports);
+                memcpy(&temp, &from->ipaddr, sizeof(temp));
+                sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
+                addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
+                temp.v4.sin_port = htons(temp.v4.sin_port);
+                if (copy_to_user(to, &temp, addrlen))
+                        return -EFAULT;
+                to += addrlen ;
+                cnt ++;
+                if (cnt >= getaddrs.addr_num) break;
+        }
+        getaddrs.addr_num = cnt;
+        if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs)))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int sctp_getsockopt_local_addrs_num(struct sock *sk, int len,
+                                                char __user *optval,
+                                                int __user *optlen)
+{
+        sctp_assoc_t id;
+        struct sctp_bind_addr *bp;
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        struct sctp_sockaddr_entry *addr;
+        rwlock_t *addr_lock;
+        unsigned long flags;
+        int cnt = 0;
+
+        if (len != sizeof(sctp_assoc_t))
+                return -EINVAL;
+
+        if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
+                return -EFAULT;
+
+        /*
+         *  For UDP-style sockets, id specifies the association to query.
+         *  If the id field is set to the value '0' then the locally bound
+         *  addresses are returned without regard to any particular
+         *  association.
+         */
+        if (0 == id) {
+                bp = &sctp_sk(sk)->ep->base.bind_addr;
+                addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
+        } else {
+                asoc = sctp_id2assoc(sk, id);
+                if (!asoc)
+                        return -EINVAL;
+                bp = &asoc->base.bind_addr;
+                addr_lock = &asoc->base.addr_lock;
+        }
+
+        sctp_read_lock(addr_lock);
+
+        /* If the endpoint is bound to 0.0.0.0 or ::0, count the valid
+         * addresses from the global local address list.
+         */
+        if (sctp_list_single_entry(&bp->address_list)) {
+                addr = list_entry(bp->address_list.next,
+                                  struct sctp_sockaddr_entry, list);
+                if (sctp_is_any(&addr->a)) {
+                        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+                        list_for_each(pos, &sctp_local_addr_list) {
+                                addr = list_entry(pos,
+                                                  struct sctp_sockaddr_entry,
+                                                  list);
+                                if ((PF_INET == sk->sk_family) && 
+                                    (AF_INET6 == addr->a.sa.sa_family)) 
+                                        continue;
+                                cnt++;
+                        }
+                        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
+                                                    flags);
+                } else {
+                        cnt = 1;
+                }
+                goto done;
+        }
+
+        list_for_each(pos, &bp->address_list) {
+                cnt ++;
+        }
+
+done:
+        sctp_read_unlock(addr_lock);
+        return cnt;
+}
+
+/* Helper function that copies local addresses to user and returns the number
+ * of addresses copied.
+ */
+static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port, int max_addrs,
+                                    void __user *to)
+{
+        struct list_head *pos;
+        struct sctp_sockaddr_entry *addr;
+        unsigned long flags;
+        union sctp_addr temp;
+        int cnt = 0;
+        int addrlen;
+
+        sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
+        list_for_each(pos, &sctp_local_addr_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                if ((PF_INET == sk->sk_family) && 
+                    (AF_INET6 == addr->a.sa.sa_family))
+                        continue;
+                memcpy(&temp, &addr->a, sizeof(temp));
+                sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
+                                                                &temp);
+                addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
+                temp.v4.sin_port = htons(port);
+                if (copy_to_user(to, &temp, addrlen)) {
+                        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
+                                                    flags);
+                        return -EFAULT;
+                }
+                to += addrlen;
+                cnt ++;
+                if (cnt >= max_addrs) break;
+        }
+        sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
+
+        return cnt;
+}
+
+static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
+                                       char __user *optval, int __user *optlen)
+{
+        struct sctp_bind_addr *bp;
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        int cnt = 0;
+        struct sctp_getaddrs getaddrs;
+        struct sctp_sockaddr_entry *addr;
+        void __user *to;
+        union sctp_addr temp;
+        struct sctp_sock *sp = sctp_sk(sk);
+        int addrlen;
+        rwlock_t *addr_lock;
+        int err = 0;
+
+        if (len != sizeof(struct sctp_getaddrs))
+                return -EINVAL;
+
+        if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
+                return -EFAULT;
+
+        if (getaddrs.addr_num <= 0) return -EINVAL;
+        /*
+         *  For UDP-style sockets, id specifies the association to query.
+         *  If the id field is set to the value '0' then the locally bound
+         *  addresses are returned without regard to any particular
+         *  association.
+         */
+        if (0 == getaddrs.assoc_id) {
+                bp = &sctp_sk(sk)->ep->base.bind_addr;
+                addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
+        } else {
+                asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
+                if (!asoc)
+                        return -EINVAL;
+                bp = &asoc->base.bind_addr;
+                addr_lock = &asoc->base.addr_lock;
+        }
+
+        to = getaddrs.addrs;
+
+        sctp_read_lock(addr_lock);
+
+        /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
+         * addresses from the global local address list.
+         */
+        if (sctp_list_single_entry(&bp->address_list)) {
+                addr = list_entry(bp->address_list.next,
+                                  struct sctp_sockaddr_entry, list);
+                if (sctp_is_any(&addr->a)) {
+                        cnt = sctp_copy_laddrs_to_user(sk, bp->port,
+                                                       getaddrs.addr_num, to);
+                        if (cnt < 0) {
+                                err = cnt;
+                                goto unlock;
+                        }
+                        goto copy_getaddrs;             
+                }
+        }
+
+        list_for_each(pos, &bp->address_list) {
+                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
+                memcpy(&temp, &addr->a, sizeof(temp));
+                sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
+                addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
+                temp.v4.sin_port = htons(temp.v4.sin_port);
+                if (copy_to_user(to, &temp, addrlen)) {
+                        err = -EFAULT;
+                        goto unlock;
+                }
+                to += addrlen;
+                cnt ++;
+                if (cnt >= getaddrs.addr_num) break;
+        }
+
+copy_getaddrs:
+        getaddrs.addr_num = cnt;
+        if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs)))
+                err = -EFAULT;
+
+unlock:
+        sctp_read_unlock(addr_lock);
+        return err;
+}
+
+/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
+ *
+ * Requests that the local SCTP stack use the enclosed peer address as
+ * the association primary.  The enclosed address must be one of the
+ * association peer's addresses.
+ */
+static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
+                                        char __user *optval, int __user *optlen)
+{
+        struct sctp_prim prim;
+        struct sctp_association *asoc;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (len != sizeof(struct sctp_prim))
+                return -EINVAL;
+
+        if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
+        if (!asoc)
+                return -EINVAL;
+
+        if (!asoc->peer.primary_path)
+                return -ENOTCONN;
+        
+        asoc->peer.primary_path->ipaddr.v4.sin_port =
+                htons(asoc->peer.primary_path->ipaddr.v4.sin_port);
+        memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
+               sizeof(union sctp_addr));
+        asoc->peer.primary_path->ipaddr.v4.sin_port =
+                ntohs(asoc->peer.primary_path->ipaddr.v4.sin_port);
+
+        sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp,
+                        (union sctp_addr *)&prim.ssp_addr);
+
+        if (copy_to_user(optval, &prim, sizeof(struct sctp_prim)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * 7.1.11  Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)
+ *
+ * Requests that the local endpoint set the specified Adaption Layer
+ * Indication parameter for all future INIT and INIT-ACK exchanges.
+ */
+static int sctp_getsockopt_adaption_layer(struct sock *sk, int len,
+                                  char __user *optval, int __user *optlen)
+{
+        __u32 val;
+
+        if (len < sizeof(__u32))
+                return -EINVAL;
+
+        len = sizeof(__u32);
+        val = sctp_sk(sk)->adaption_ind;
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+        return 0;
+}
+
+/*
+ *
+ * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
+ *
+ *   Applications that wish to use the sendto() system call may wish to
+ *   specify a default set of parameters that would normally be supplied
+ *   through the inclusion of ancillary data.  This socket option allows
+ *   such an application to set the default sctp_sndrcvinfo structure.
+
+
+ *   The application that wishes to use this socket option simply passes
+ *   in to this call the sctp_sndrcvinfo structure defined in Section
+ *   5.2.2) The input parameters accepted by this call include
+ *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
+ *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
+ *   to this call if the caller is using the UDP model.
+ *
+ *   For getsockopt, it get the default sctp_sndrcvinfo structure.
+ */
+static int sctp_getsockopt_default_send_param(struct sock *sk,
+                                        int len, char __user *optval,
+                                        int __user *optlen)
+{
+        struct sctp_sndrcvinfo info;
+        struct sctp_association *asoc;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (len != sizeof(struct sctp_sndrcvinfo))
+                return -EINVAL;
+        if (copy_from_user(&info, optval, sizeof(struct sctp_sndrcvinfo)))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
+        if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        if (asoc) {
+                info.sinfo_stream = asoc->default_stream;
+                info.sinfo_flags = asoc->default_flags;
+                info.sinfo_ppid = asoc->default_ppid;
+                info.sinfo_context = asoc->default_context;
+                info.sinfo_timetolive = asoc->default_timetolive;
+        } else {
+                info.sinfo_stream = sp->default_stream;
+                info.sinfo_flags = sp->default_flags;
+                info.sinfo_ppid = sp->default_ppid;
+                info.sinfo_context = sp->default_context;
+                info.sinfo_timetolive = sp->default_timetolive;
+        }
+
+        if (copy_to_user(optval, &info, sizeof(struct sctp_sndrcvinfo)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ *
+ * 7.1.5 SCTP_NODELAY
+ *
+ * Turn on/off any Nagle-like algorithm.  This means that packets are
+ * generally sent as soon as possible and no unnecessary delays are
+ * introduced, at the cost of more packets in the network.  Expects an
+ * integer boolean flag.
+ */
+
+static int sctp_getsockopt_nodelay(struct sock *sk, int len,
+                                   char __user *optval, int __user *optlen)
+{
+        int val;
+
+        if (len < sizeof(int))
+                return -EINVAL;
+
+        len = sizeof(int);
+        val = (sctp_sk(sk)->nodelay == 1);
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+        return 0;
+}
+
+/*
+ *
+ * 7.1.1 SCTP_RTOINFO
+ *
+ * The protocol parameters used to initialize and bound retransmission
+ * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
+ * and modify these parameters.
+ * All parameters are time values, in milliseconds.  A value of 0, when
+ * modifying the parameters, indicates that the current value should not
+ * be changed.
+ *
+ */
+static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
+                                char __user *optval,
+                                int __user *optlen) {
+        struct sctp_rtoinfo rtoinfo;
+        struct sctp_association *asoc;
+
+        if (len != sizeof (struct sctp_rtoinfo))
+                return -EINVAL;
+
+        if (copy_from_user(&rtoinfo, optval, sizeof (struct sctp_rtoinfo)))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
+
+        if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        /* Values corresponding to the specific association. */
+        if (asoc) {
+                rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
+                rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
+                rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
+        } else {
+                /* Values corresponding to the endpoint. */
+                struct sctp_sock *sp = sctp_sk(sk);
+
+                rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
+                rtoinfo.srto_max = sp->rtoinfo.srto_max;
+                rtoinfo.srto_min = sp->rtoinfo.srto_min;
+        }
+
+        if (put_user(len, optlen))
+                return -EFAULT;
+
+        if (copy_to_user(optval, &rtoinfo, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ *
+ * 7.1.2 SCTP_ASSOCINFO
+ *
+ * This option is used to tune the the maximum retransmission attempts
+ * of the association.
+ * Returns an error if the new association retransmission value is
+ * greater than the sum of the retransmission value  of the peer.
+ * See [SCTP] for more information.
+ *
+ */
+static int sctp_getsockopt_associnfo(struct sock *sk, int len,
+                                     char __user *optval,
+                                     int __user *optlen)
+{
+
+        struct sctp_assocparams assocparams;
+        struct sctp_association *asoc;
+        struct list_head *pos;
+        int cnt = 0;
+
+        if (len != sizeof (struct sctp_assocparams))
+                return -EINVAL;
+
+        if (copy_from_user(&assocparams, optval,
+                        sizeof (struct sctp_assocparams)))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
+
+        if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        /* Values correspoinding to the specific association */
+        if (assocparams.sasoc_assoc_id != 0) {
+                assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
+                assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
+                assocparams.sasoc_local_rwnd = asoc->a_rwnd;
+                assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec
+                                                * 1000) +
+                                                (asoc->cookie_life.tv_usec
+                                                / 1000);
+
+                list_for_each(pos, &asoc->peer.transport_addr_list) {
+                        cnt ++;
+                }
+
+                assocparams.sasoc_number_peer_destinations = cnt;
+        } else {
+                /* Values corresponding to the endpoint */
+                struct sctp_sock *sp = sctp_sk(sk);
+
+                assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
+                assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
+                assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
+                assocparams.sasoc_cookie_life =
+                                        sp->assocparams.sasoc_cookie_life;
+                assocparams.sasoc_number_peer_destinations =
+                                        sp->assocparams.
+                                        sasoc_number_peer_destinations;
+        }
+
+        if (put_user(len, optlen))
+                return -EFAULT;
+
+        if (copy_to_user(optval, &assocparams, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
+ *
+ * This socket option is a boolean flag which turns on or off mapped V4
+ * addresses.  If this option is turned on and the socket is type
+ * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
+ * If this option is turned off, then no mapping will be done of V4
+ * addresses and a user will receive both PF_INET6 and PF_INET type
+ * addresses on the socket.
+ */
+static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
+                                    char __user *optval, int __user *optlen)
+{
+        int val;
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        if (len < sizeof(int))
+                return -EINVAL;
+
+        len = sizeof(int);
+        val = sp->v4mapped;
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
+ *
+ * This socket option specifies the maximum size to put in any outgoing
+ * SCTP chunk.  If a message is larger than this size it will be
+ * fragmented by SCTP into the specified size.  Note that the underlying
+ * SCTP implementation may fragment into smaller sized chunks when the
+ * PMTU of the underlying association is smaller than the value set by
+ * the user.
+ */
+static int sctp_getsockopt_maxseg(struct sock *sk, int len,
+                                  char __user *optval, int __user *optlen)
+{
+        int val;
+
+        if (len < sizeof(int))
+                return -EINVAL;
+
+        len = sizeof(int);
+
+        val = sctp_sk(sk)->user_frag;
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
+                                char __user *optval, int __user *optlen)
+{
+        int retval = 0;
+        int len;
+
+        SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p, ...)\n", sk);
+
+        /* I can hardly begin to describe how wrong this is.  This is
+         * so broken as to be worse than useless.  The API draft
+         * REALLY is NOT helpful here...  I am not convinced that the
+         * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
+         * are at all well-founded.
+         */
+        if (level != SOL_SCTP) {
+                struct sctp_af *af = sctp_sk(sk)->pf->af;
+
+                retval = af->getsockopt(sk, level, optname, optval, optlen);
+                return retval;
+        }
+
+        if (get_user(len, optlen))
+                return -EFAULT;
+
+        sctp_lock_sock(sk);
+
+        switch (optname) {
+        case SCTP_STATUS:
+                retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
+                break;
+        case SCTP_DISABLE_FRAGMENTS:
+                retval = sctp_getsockopt_disable_fragments(sk, len, optval,
+                                                           optlen);
+                break;
+        case SCTP_EVENTS:
+                retval = sctp_getsockopt_events(sk, len, optval, optlen);
+                break;
+        case SCTP_AUTOCLOSE:
+                retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
+                break;
+        case SCTP_SOCKOPT_PEELOFF:
+                retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
+                break;
+        case SCTP_PEER_ADDR_PARAMS:
+                retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
+                                                          optlen);
+                break;
+        case SCTP_INITMSG:
+                retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
+                break;
+        case SCTP_GET_PEER_ADDRS_NUM:
+                retval = sctp_getsockopt_peer_addrs_num(sk, len, optval,
+                                                        optlen);
+                break;
+        case SCTP_GET_LOCAL_ADDRS_NUM:
+                retval = sctp_getsockopt_local_addrs_num(sk, len, optval,
+                                                         optlen);
+                break;
+        case SCTP_GET_PEER_ADDRS:
+                retval = sctp_getsockopt_peer_addrs(sk, len, optval,
+                                                    optlen);
+                break;
+        case SCTP_GET_LOCAL_ADDRS:
+                retval = sctp_getsockopt_local_addrs(sk, len, optval,
+                                                     optlen);
+                break;
+        case SCTP_DEFAULT_SEND_PARAM:
+                retval = sctp_getsockopt_default_send_param(sk, len,
+                                                            optval, optlen);
+                break;
+        case SCTP_PRIMARY_ADDR:
+                retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
+                break;
+        case SCTP_NODELAY:
+                retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
+                break;
+        case SCTP_RTOINFO:
+                retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
+                break;
+        case SCTP_ASSOCINFO:
+                retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
+                break;
+        case SCTP_I_WANT_MAPPED_V4_ADDR:
+                retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
+                break;
+        case SCTP_MAXSEG:
+                retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
+                break;
+        case SCTP_GET_PEER_ADDR_INFO:
+                retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
+                                                        optlen);
+                break;
+        case SCTP_ADAPTION_LAYER:
+                retval = sctp_getsockopt_adaption_layer(sk, len, optval,
+                                                        optlen);
+                break;
+        default:
+                retval = -ENOPROTOOPT;
+                break;
+        };
+
+        sctp_release_sock(sk);
+        return retval;
+}
+
+static void sctp_hash(struct sock *sk)
+{
+        /* STUB */
+}
+
+static void sctp_unhash(struct sock *sk)
+{
+        /* STUB */
+}
+
+/* Check if port is acceptable.  Possibly find first available port.
+ *
+ * The port hash table (contained in the 'global' SCTP protocol storage
+ * returned by struct sctp_protocol *sctp_get_protocol()). The hash
+ * table is an array of 4096 lists (sctp_bind_hashbucket). Each
+ * list (the list number is the port number hashed out, so as you
+ * would expect from a hash function, all the ports in a given list have
+ * such a number that hashes out to the same list number; you were
+ * expecting that, right?); so each list has a set of ports, with a
+ * link to the socket (struct sock) that uses it, the port number and
+ * a fastreuse flag (FIXME: NPI ipg).
+ */
+static struct sctp_bind_bucket *sctp_bucket_create(
+        struct sctp_bind_hashbucket *head, unsigned short snum);
+
+static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
+{
+        struct sctp_bind_hashbucket *head; /* hash list */
+        struct sctp_bind_bucket *pp; /* hash list port iterator */
+        unsigned short snum;
+        int ret;
+
+        /* NOTE:  Remember to put this back to net order. */
+        addr->v4.sin_port = ntohs(addr->v4.sin_port);
+        snum = addr->v4.sin_port;
+
+        SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum);
+        sctp_local_bh_disable();
+
+        if (snum == 0) {
+                /* Search for an available port.
+                 *
+                 * 'sctp_port_rover' was the last port assigned, so
+                 * we start to search from 'sctp_port_rover +
+                 * 1'. What we do is first check if port 'rover' is
+                 * already in the hash table; if not, we use that; if
+                 * it is, we try next.
+                 */
+                int low = sysctl_local_port_range[0];
+                int high = sysctl_local_port_range[1];
+                int remaining = (high - low) + 1;
+                int rover;
+                int index;
+
+                sctp_spin_lock(&sctp_port_alloc_lock);
+                rover = sctp_port_rover;
+                do {
+                        rover++;
+                        if ((rover < low) || (rover > high))
+                                rover = low;
+                        index = sctp_phashfn(rover);
+                        head = &sctp_port_hashtable[index];
+                        sctp_spin_lock(&head->lock);
+                        for (pp = head->chain; pp; pp = pp->next)
+                                if (pp->port == rover)
+                                        goto next;
+                        break;
+                next:
+                        sctp_spin_unlock(&head->lock);
+                } while (--remaining > 0);
+                sctp_port_rover = rover;
+                sctp_spin_unlock(&sctp_port_alloc_lock);
+
+                /* Exhausted local port range during search? */
+                ret = 1;
+                if (remaining <= 0)
+                        goto fail;
+
+                /* OK, here is the one we will use.  HEAD (the port
+                 * hash table list entry) is non-NULL and we hold it's
+                 * mutex.
+                 */
+                snum = rover;
+        } else {
+                /* We are given an specific port number; we verify
+                 * that it is not being used. If it is used, we will
+                 * exahust the search in the hash list corresponding
+                 * to the port number (snum) - we detect that with the
+                 * port iterator, pp being NULL.
+                 */
+                head = &sctp_port_hashtable[sctp_phashfn(snum)];
+                sctp_spin_lock(&head->lock);
+                for (pp = head->chain; pp; pp = pp->next) {
+                        if (pp->port == snum)
+                                goto pp_found;
+                }
+        }
+        pp = NULL;
+        goto pp_not_found;
+pp_found:
+        if (!hlist_empty(&pp->owner)) {
+                /* We had a port hash table hit - there is an
+                 * available port (pp != NULL) and it is being
+                 * used by other socket (pp->owner not empty); that other
+                 * socket is going to be sk2.
+                 */
+                int reuse = sk->sk_reuse;
+                struct sock *sk2;
+                struct hlist_node *node;
+
+                SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");
+                if (pp->fastreuse && sk->sk_reuse)
+                        goto success;
+
+                /* Run through the list of sockets bound to the port
+                 * (pp->port) [via the pointers bind_next and
+                 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
+                 * we get the endpoint they describe and run through
+                 * the endpoint's list of IP (v4 or v6) addresses,
+                 * comparing each of the addresses with the address of
+                 * the socket sk. If we find a match, then that means
+                 * that this port/socket (sk) combination are already
+                 * in an endpoint.
+                 */
+                sk_for_each_bound(sk2, node, &pp->owner) {
+                        struct sctp_endpoint *ep2;
+                        ep2 = sctp_sk(sk2)->ep;
+
+                        if (reuse && sk2->sk_reuse)
+                                continue;
+
+                        if (sctp_bind_addr_match(&ep2->base.bind_addr, addr,
+                                                 sctp_sk(sk))) {
+                                ret = (long)sk2;
+                                goto fail_unlock;
+                        }
+                }
+                SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n");
+        }
+pp_not_found:
+        /* If there was a hash table miss, create a new port.  */
+        ret = 1;
+        if (!pp && !(pp = sctp_bucket_create(head, snum)))
+                goto fail_unlock;
+
+        /* In either case (hit or miss), make sure fastreuse is 1 only
+         * if sk->sk_reuse is too (that is, if the caller requested
+         * SO_REUSEADDR on this socket -sk-).
+         */
+        if (hlist_empty(&pp->owner))
+                pp->fastreuse = sk->sk_reuse ? 1 : 0;
+        else if (pp->fastreuse && !sk->sk_reuse)
+                pp->fastreuse = 0;
+
+        /* We are set, so fill up all the data in the hash table
+         * entry, tie the socket list information with the rest of the
+         * sockets FIXME: Blurry, NPI (ipg).
+         */
+success:
+        inet_sk(sk)->num = snum;
+        if (!sctp_sk(sk)->bind_hash) {
+                sk_add_bind_node(sk, &pp->owner);
+                sctp_sk(sk)->bind_hash = pp;
+        }
+        ret = 0;
+
+fail_unlock:
+        sctp_spin_unlock(&head->lock);
+
+fail:
+        sctp_local_bh_enable();
+        addr->v4.sin_port = htons(addr->v4.sin_port);
+        return ret;
+}
+
+/* Assign a 'snum' port to the socket.  If snum == 0, an ephemeral
+ * port is requested.
+ */
+static int sctp_get_port(struct sock *sk, unsigned short snum)
+{
+        long ret;
+        union sctp_addr addr;
+        struct sctp_af *af = sctp_sk(sk)->pf->af;
+
+        /* Set up a dummy address struct from the sk. */
+        af->from_sk(&addr, sk);
+        addr.v4.sin_port = htons(snum);
+
+        /* Note: sk->sk_num gets filled in if ephemeral port request. */
+        ret = sctp_get_port_local(sk, &addr);
+
+        return (ret ? 1 : 0);
+}
+
+/*
+ * 3.1.3 listen() - UDP Style Syntax
+ *
+ *   By default, new associations are not accepted for UDP style sockets.
+ *   An application uses listen() to mark a socket as being able to
+ *   accept new associations.
+ */
+SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+        struct sctp_endpoint *ep = sp->ep;
+
+        /* Only UDP style sockets that are not peeled off are allowed to
+         * listen().
+         */
+        if (!sctp_style(sk, UDP))
+                return -EINVAL;
+
+        /* If backlog is zero, disable listening. */
+        if (!backlog) {
+                if (sctp_sstate(sk, CLOSED))
+                        return 0;
+                
+                sctp_unhash_endpoint(ep);
+                sk->sk_state = SCTP_SS_CLOSED;
+        }
+
+        /* Return if we are already listening. */
+        if (sctp_sstate(sk, LISTENING))
+                return 0;
+                
+        /*
+         * If a bind() or sctp_bindx() is not called prior to a listen()
+         * call that allows new associations to be accepted, the system
+         * picks an ephemeral port and will choose an address set equivalent
+         * to binding with a wildcard address.
+         *
+         * This is not currently spelled out in the SCTP sockets
+         * extensions draft, but follows the practice as seen in TCP
+         * sockets.
+         */
+        if (!ep->base.bind_addr.port) {
+                if (sctp_autobind(sk))
+                        return -EAGAIN;
+        }
+        sk->sk_state = SCTP_SS_LISTENING;
+        sctp_hash_endpoint(ep);
+        return 0;
+}
+
+/*
+ * 4.1.3 listen() - TCP Style Syntax
+ *
+ *   Applications uses listen() to ready the SCTP endpoint for accepting
+ *   inbound associations.
+ */
+SCTP_STATIC int sctp_stream_listen(struct sock *sk, int backlog)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+        struct sctp_endpoint *ep = sp->ep;
+
+        /* If backlog is zero, disable listening. */
+        if (!backlog) {
+                if (sctp_sstate(sk, CLOSED))
+                        return 0;
+                
+                sctp_unhash_endpoint(ep);
+                sk->sk_state = SCTP_SS_CLOSED;
+        }
+
+        if (sctp_sstate(sk, LISTENING))
+                return 0;
+
+        /*
+         * If a bind() or sctp_bindx() is not called prior to a listen()
+         * call that allows new associations to be accepted, the system
+         * picks an ephemeral port and will choose an address set equivalent
+         * to binding with a wildcard address.
+         *
+         * This is not currently spelled out in the SCTP sockets
+         * extensions draft, but follows the practice as seen in TCP
+         * sockets.
+         */
+        if (!ep->base.bind_addr.port) {
+                if (sctp_autobind(sk))
+                        return -EAGAIN;
+        }
+        sk->sk_state = SCTP_SS_LISTENING;
+        sk->sk_max_ack_backlog = backlog;
+        sctp_hash_endpoint(ep);
+        return 0;
+}
+
+/*
+ *  Move a socket to LISTENING state.
+ */
+int sctp_inet_listen(struct socket *sock, int backlog)
+{
+        struct sock *sk = sock->sk;
+        struct crypto_tfm *tfm=NULL;
+        int err = -EINVAL;
+
+        if (unlikely(backlog < 0))
+                goto out;
+
+        sctp_lock_sock(sk);
+
+        if (sock->state != SS_UNCONNECTED)
+                goto out;
+
+        /* Allocate HMAC for generating cookie. */
+        if (sctp_hmac_alg) {
+                tfm = sctp_crypto_alloc_tfm(sctp_hmac_alg, 0);
+                if (!tfm) {
+                        err = -ENOSYS;
+                        goto out;
+                }
+        }
+
+        switch (sock->type) {
+        case SOCK_SEQPACKET:
+                err = sctp_seqpacket_listen(sk, backlog);
+                break;
+        case SOCK_STREAM:
+                err = sctp_stream_listen(sk, backlog);
+                break;
+        default:
+                break;
+        };
+        if (err)
+                goto cleanup;
+
+        /* Store away the transform reference. */
+        sctp_sk(sk)->hmac = tfm;
+out:
+        sctp_release_sock(sk);
+        return err;
+cleanup:
+        if (tfm)
+                sctp_crypto_free_tfm(tfm);
+        goto out;
+}
+
+/*
+ * This function is done by modeling the current datagram_poll() and the
+ * tcp_poll().  Note that, based on these implementations, we don't
+ * lock the socket in this function, even though it seems that,
+ * ideally, locking or some other mechanisms can be used to ensure
+ * the integrity of the counters (sndbuf and wmem_queued) used
+ * in this place.  We assume that we don't need locks either until proven
+ * otherwise.
+ *
+ * Another thing to note is that we include the Async I/O support
+ * here, again, by modeling the current TCP/UDP code.  We don't have
+ * a good way to test with it yet.
+ */
+unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
+{
+        struct sock *sk = sock->sk;
+        struct sctp_sock *sp = sctp_sk(sk);
+        unsigned int mask;
+
+        poll_wait(file, sk->sk_sleep, wait);
+
+        /* A TCP-style listening socket becomes readable when the accept queue
+         * is not empty.
+         */
+        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
+                return (!list_empty(&sp->ep->asocs)) ?
+                        (POLLIN | POLLRDNORM) : 0;
+
+        mask = 0;
+
+        /* Is there any exceptional events?  */
+        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
+                mask |= POLLERR;
+        if (sk->sk_shutdown == SHUTDOWN_MASK)
+                mask |= POLLHUP;
+
+        /* Is it readable?  Reconsider this code with TCP-style support.  */
+        if (!skb_queue_empty(&sk->sk_receive_queue) ||
+            (sk->sk_shutdown & RCV_SHUTDOWN))
+                mask |= POLLIN | POLLRDNORM;
+
+        /* The association is either gone or not ready.  */
+        if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
+                return mask;
+
+        /* Is it writable?  */
+        if (sctp_writeable(sk)) {
+                mask |= POLLOUT | POLLWRNORM;
+        } else {
+                set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
+                /*
+                 * Since the socket is not locked, the buffer
+                 * might be made available after the writeable check and
+                 * before the bit is set.  This could cause a lost I/O
+                 * signal.  tcp_poll() has a race breaker for this race
+                 * condition.  Based on their implementation, we put
+                 * in the following code to cover it as well.
+                 */
+                if (sctp_writeable(sk))
+                        mask |= POLLOUT | POLLWRNORM;
+        }
+        return mask;
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+static struct sctp_bind_bucket *sctp_bucket_create(
+        struct sctp_bind_hashbucket *head, unsigned short snum)
+{
+        struct sctp_bind_bucket *pp;
+
+        pp = kmem_cache_alloc(sctp_bucket_cachep, SLAB_ATOMIC);
+        SCTP_DBG_OBJCNT_INC(bind_bucket);
+        if (pp) {
+                pp->port = snum;
+                pp->fastreuse = 0;
+                INIT_HLIST_HEAD(&pp->owner);
+                if ((pp->next = head->chain) != NULL)
+                        pp->next->pprev = &pp->next;
+                head->chain = pp;
+                pp->pprev = &head->chain;
+        }
+        return pp;
+}
+
+/* Caller must hold hashbucket lock for this tb with local BH disabled */
+static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
+{
+        if (hlist_empty(&pp->owner)) {
+                if (pp->next)
+                        pp->next->pprev = pp->pprev;
+                *(pp->pprev) = pp->next;
+                kmem_cache_free(sctp_bucket_cachep, pp);
+                SCTP_DBG_OBJCNT_DEC(bind_bucket);
+        }
+}
+
+/* Release this socket's reference to a local port.  */
+static inline void __sctp_put_port(struct sock *sk)
+{
+        struct sctp_bind_hashbucket *head =
+                &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->num)];
+        struct sctp_bind_bucket *pp;
+
+        sctp_spin_lock(&head->lock);
+        pp = sctp_sk(sk)->bind_hash;
+        __sk_del_bind_node(sk);
+        sctp_sk(sk)->bind_hash = NULL;
+        inet_sk(sk)->num = 0;
+        sctp_bucket_destroy(pp);
+        sctp_spin_unlock(&head->lock);
+}
+
+void sctp_put_port(struct sock *sk)
+{
+        sctp_local_bh_disable();
+        __sctp_put_port(sk);
+        sctp_local_bh_enable();
+}
+
+/*
+ * The system picks an ephemeral port and choose an address set equivalent
+ * to binding with a wildcard address.
+ * One of those addresses will be the primary address for the association.
+ * This automatically enables the multihoming capability of SCTP.
+ */
+static int sctp_autobind(struct sock *sk)
+{
+        union sctp_addr autoaddr;
+        struct sctp_af *af;
+        unsigned short port;
+
+        /* Initialize a local sockaddr structure to INADDR_ANY. */
+        af = sctp_sk(sk)->pf->af;
+
+        port = htons(inet_sk(sk)->num);
+        af->inaddr_any(&autoaddr, port);
+
+        return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
+}
+
+/* Parse out IPPROTO_SCTP CMSG headers.  Perform only minimal validation.
+ *
+ * From RFC 2292
+ * 4.2 The cmsghdr Structure *
+ *
+ * When ancillary data is sent or received, any number of ancillary data
+ * objects can be specified by the msg_control and msg_controllen members of
+ * the msghdr structure, because each object is preceded by
+ * a cmsghdr structure defining the object's length (the cmsg_len member).
+ * Historically Berkeley-derived implementations have passed only one object
+ * at a time, but this API allows multiple objects to be
+ * passed in a single call to sendmsg() or recvmsg(). The following example
+ * shows two ancillary data objects in a control buffer.
+ *
+ *   |<--------------------------- msg_controllen -------------------------->|
+ *   |                                                                       |
+ *
+ *   |<----- ancillary data object ----->|<----- ancillary data object ----->|
+ *
+ *   |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
+ *   |                                   |                                   |
+ *
+ *   |<---------- cmsg_len ---------->|  |<--------- cmsg_len ----------->|  |
+ *
+ *   |<--------- CMSG_LEN() --------->|  |<-------- CMSG_LEN() ---------->|  |
+ *   |                                |  |                                |  |
+ *
+ *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
+ *   |cmsg_|cmsg_|cmsg_|XX|           |XX|cmsg_|cmsg_|cmsg_|XX|           |XX|
+ *
+ *   |len  |level|type |XX|cmsg_data[]|XX|len  |level|type |XX|cmsg_data[]|XX|
+ *
+ *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
+ *    ^
+ *    |
+ *
+ * msg_control
+ * points here
+ */
+SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg,
+                                  sctp_cmsgs_t *cmsgs)
+{
+        struct cmsghdr *cmsg;
+
+        for (cmsg = CMSG_FIRSTHDR(msg);
+             cmsg != NULL;
+             cmsg = CMSG_NXTHDR((struct msghdr*)msg, cmsg)) {
+                if (!CMSG_OK(msg, cmsg))
+                        return -EINVAL;
+
+                /* Should we parse this header or ignore?  */
+                if (cmsg->cmsg_level != IPPROTO_SCTP)
+                        continue;
+
+                /* Strictly check lengths following example in SCM code.  */
+                switch (cmsg->cmsg_type) {
+                case SCTP_INIT:
+                        /* SCTP Socket API Extension
+                         * 5.2.1 SCTP Initiation Structure (SCTP_INIT)
+                         *
+                         * This cmsghdr structure provides information for
+                         * initializing new SCTP associations with sendmsg().
+                         * The SCTP_INITMSG socket option uses this same data
+                         * structure.  This structure is not used for
+                         * recvmsg().
+                         *
+                         * cmsg_level    cmsg_type      cmsg_data[]
+                         * ------------  ------------   ----------------------
+                         * IPPROTO_SCTP  SCTP_INIT      struct sctp_initmsg
+                         */
+                        if (cmsg->cmsg_len !=
+                            CMSG_LEN(sizeof(struct sctp_initmsg)))
+                                return -EINVAL;
+                        cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg);
+                        break;
+
+                case SCTP_SNDRCV:
+                        /* SCTP Socket API Extension
+                         * 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV)
+                         *
+                         * This cmsghdr structure specifies SCTP options for
+                         * sendmsg() and describes SCTP header information
+                         * about a received message through recvmsg().
+                         *
+                         * cmsg_level    cmsg_type      cmsg_data[]
+                         * ------------  ------------   ----------------------
+                         * IPPROTO_SCTP  SCTP_SNDRCV    struct sctp_sndrcvinfo
+                         */
+                        if (cmsg->cmsg_len !=
+                            CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
+                                return -EINVAL;
+
+                        cmsgs->info =
+                                (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
+
+                        /* Minimally, validate the sinfo_flags. */
+                        if (cmsgs->info->sinfo_flags &
+                            ~(MSG_UNORDERED | MSG_ADDR_OVER |
+                              MSG_ABORT | MSG_EOF))
+                                return -EINVAL;
+                        break;
+
+                default:
+                        return -EINVAL;
+                };
+        }
+        return 0;
+}
+
+/*
+ * Wait for a packet..
+ * Note: This function is the same function as in core/datagram.c
+ * with a few modifications to make lksctp work.
+ */
+static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p)
+{
+        int error;
+        DEFINE_WAIT(wait);
+
+        prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+
+        /* Socket errors? */
+        error = sock_error(sk);
+        if (error)
+                goto out;
+
+        if (!skb_queue_empty(&sk->sk_receive_queue))
+                goto ready;
+
+        /* Socket shut down?  */
+        if (sk->sk_shutdown & RCV_SHUTDOWN)
+                goto out;
+
+        /* Sequenced packets can come disconnected.  If so we report the
+         * problem.
+         */
+        error = -ENOTCONN;
+
+        /* Is there a good reason to think that we may receive some data?  */
+        if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
+                goto out;
+
+        /* Handle signals.  */
+        if (signal_pending(current))
+                goto interrupted;
+
+        /* Let another process have a go.  Since we are going to sleep
+         * anyway.  Note: This may cause odd behaviors if the message
+         * does not fit in the user's buffer, but this seems to be the
+         * only way to honor MSG_DONTWAIT realistically.
+         */
+        sctp_release_sock(sk);
+        *timeo_p = schedule_timeout(*timeo_p);
+        sctp_lock_sock(sk);
+
+ready:
+        finish_wait(sk->sk_sleep, &wait);
+        return 0;
+
+interrupted:
+        error = sock_intr_errno(*timeo_p);
+
+out:
+        finish_wait(sk->sk_sleep, &wait);
+        *err = error;
+        return error;
+}
+
+/* Receive a datagram.
+ * Note: This is pretty much the same routine as in core/datagram.c
+ * with a few changes to make lksctp work.
+ */
+static struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags,
+                                              int noblock, int *err)
+{
+        int error;
+        struct sk_buff *skb;
+        long timeo;
+
+        /* Caller is allowed not to check sk->sk_err before calling.  */
+        error = sock_error(sk);
+        if (error)
+                goto no_packet;
+
+        timeo = sock_rcvtimeo(sk, noblock);
+
+        SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n",
+                          timeo, MAX_SCHEDULE_TIMEOUT);
+
+        do {
+                /* Again only user level code calls this function,
+                 * so nothing interrupt level
+                 * will suddenly eat the receive_queue.
+                 *
+                 *  Look at current nfs client by the way...
+                 *  However, this function was corrent in any case. 8)
+                 */
+                if (flags & MSG_PEEK) {
+                        unsigned long cpu_flags;
+
+                        sctp_spin_lock_irqsave(&sk->sk_receive_queue.lock,
+                                               cpu_flags);
+                        skb = skb_peek(&sk->sk_receive_queue);
+                        if (skb)
+                                atomic_inc(&skb->users);
+                        sctp_spin_unlock_irqrestore(&sk->sk_receive_queue.lock,
+                                                    cpu_flags);
+                } else {
+                        skb = skb_dequeue(&sk->sk_receive_queue);
+                }
+
+                if (skb)
+                        return skb;
+
+                if (sk->sk_shutdown & RCV_SHUTDOWN)
+                        break;
+
+                /* User doesn't want to wait.  */
+                error = -EAGAIN;
+                if (!timeo)
+                        goto no_packet;
+        } while (sctp_wait_for_packet(sk, err, &timeo) == 0);
+
+        return NULL;
+
+no_packet:
+        *err = error;
+        return NULL;
+}
+
+/* If sndbuf has changed, wake up per association sndbuf waiters.  */
+static void __sctp_write_space(struct sctp_association *asoc)
+{
+        struct sock *sk = asoc->base.sk;
+        struct socket *sock = sk->sk_socket;
+
+        if ((sctp_wspace(asoc) > 0) && sock) {
+                if (waitqueue_active(&asoc->wait))
+                        wake_up_interruptible(&asoc->wait);
+
+                if (sctp_writeable(sk)) {
+                        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
+                                wake_up_interruptible(sk->sk_sleep);
+
+                        /* Note that we try to include the Async I/O support
+                         * here by modeling from the current TCP/UDP code.
+                         * We have not tested with it yet.
+                         */
+                        if (sock->fasync_list &&
+                            !(sk->sk_shutdown & SEND_SHUTDOWN))
+                                sock_wake_async(sock, 2, POLL_OUT);
+                }
+        }
+}
+
+/* Do accounting for the sndbuf space.
+ * Decrement the used sndbuf space of the corresponding association by the
+ * data size which was just transmitted(freed).
+ */
+static void sctp_wfree(struct sk_buff *skb)
+{
+        struct sctp_association *asoc;
+        struct sctp_chunk *chunk;
+        struct sock *sk;
+
+        /* Get the saved chunk pointer.  */
+        chunk = *((struct sctp_chunk **)(skb->cb));
+        asoc = chunk->asoc;
+        sk = asoc->base.sk;
+        asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk);
+        sk->sk_wmem_queued -= SCTP_DATA_SNDSIZE(chunk);
+        __sctp_write_space(asoc);
+
+        sctp_association_put(asoc);
+}
+
+/* Helper function to wait for space in the sndbuf.  */
+static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
+                                size_t msg_len)
+{
+        struct sock *sk = asoc->base.sk;
+        int err = 0;
+        long current_timeo = *timeo_p;
+        DEFINE_WAIT(wait);
+
+        SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n",
+                          asoc, (long)(*timeo_p), msg_len);
+
+        /* Increment the association's refcnt.  */
+        sctp_association_hold(asoc);
+
+        /* Wait on the association specific sndbuf space. */
+        for (;;) {
+                prepare_to_wait_exclusive(&asoc->wait, &wait,
+                                          TASK_INTERRUPTIBLE);
+                if (!*timeo_p)
+                        goto do_nonblock;
+                if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
+                    asoc->base.dead)
+                        goto do_error;
+                if (signal_pending(current))
+                        goto do_interrupted;
+                if (msg_len <= sctp_wspace(asoc))
+                        break;
+
+                /* Let another process have a go.  Since we are going
+                 * to sleep anyway.
+                 */
+                sctp_release_sock(sk);
+                current_timeo = schedule_timeout(current_timeo);
+                sctp_lock_sock(sk);
+
+                *timeo_p = current_timeo;
+        }
+
+out:
+        finish_wait(&asoc->wait, &wait);
+
+        /* Release the association's refcnt.  */
+        sctp_association_put(asoc);
+
+        return err;
+
+do_error:
+        err = -EPIPE;
+        goto out;
+
+do_interrupted:
+        err = sock_intr_errno(*timeo_p);
+        goto out;
+
+do_nonblock:
+        err = -EAGAIN;
+        goto out;
+}
+
+/* If socket sndbuf has changed, wake up all per association waiters.  */
+void sctp_write_space(struct sock *sk)
+{
+        struct sctp_association *asoc;
+        struct list_head *pos;
+
+        /* Wake up the tasks in each wait queue.  */
+        list_for_each(pos, &((sctp_sk(sk))->ep->asocs)) {
+                asoc = list_entry(pos, struct sctp_association, asocs);
+                __sctp_write_space(asoc);
+        }
+}
+
+/* Is there any sndbuf space available on the socket?
+ *
+ * Note that wmem_queued is the sum of the send buffers on all of the
+ * associations on the same socket.  For a UDP-style socket with
+ * multiple associations, it is possible for it to be "unwriteable"
+ * prematurely.  I assume that this is acceptable because
+ * a premature "unwriteable" is better than an accidental "writeable" which
+ * would cause an unwanted block under certain circumstances.  For the 1-1
+ * UDP-style sockets or TCP-style sockets, this code should work.
+ *  - Daisy
+ */
+static int sctp_writeable(struct sock *sk)
+{
+        int amt = 0;
+
+        amt = sk->sk_sndbuf - sk->sk_wmem_queued;
+        if (amt < 0)
+                amt = 0;
+        return amt;
+}
+
+/* Wait for an association to go into ESTABLISHED state. If timeout is 0,
+ * returns immediately with EINPROGRESS.
+ */
+static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
+{
+        struct sock *sk = asoc->base.sk;
+        int err = 0;
+        long current_timeo = *timeo_p;
+        DEFINE_WAIT(wait);
+
+        SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __FUNCTION__, asoc,
+                          (long)(*timeo_p));
+
+        /* Increment the association's refcnt.  */
+        sctp_association_hold(asoc);
+
+        for (;;) {
+                prepare_to_wait_exclusive(&asoc->wait, &wait,
+                                          TASK_INTERRUPTIBLE);
+                if (!*timeo_p)
+                        goto do_nonblock;
+                if (sk->sk_shutdown & RCV_SHUTDOWN)
+                        break;
+                if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
+                    asoc->base.dead)
+                        goto do_error;
+                if (signal_pending(current))
+                        goto do_interrupted;
+
+                if (sctp_state(asoc, ESTABLISHED))
+                        break;
+
+                /* Let another process have a go.  Since we are going
+                 * to sleep anyway.
+                 */
+                sctp_release_sock(sk);
+                current_timeo = schedule_timeout(current_timeo);
+                sctp_lock_sock(sk);
+
+                *timeo_p = current_timeo;
+        }
+
+out:
+        finish_wait(&asoc->wait, &wait);
+
+        /* Release the association's refcnt.  */
+        sctp_association_put(asoc);
+
+        return err;
+
+do_error:
+        if (asoc->counters[SCTP_COUNTER_INIT_ERROR] + 1 >=
+                                                asoc->max_init_attempts)
+                err = -ETIMEDOUT;
+        else
+                err = -ECONNREFUSED;
+        goto out;
+
+do_interrupted:
+        err = sock_intr_errno(*timeo_p);
+        goto out;
+
+do_nonblock:
+        err = -EINPROGRESS;
+        goto out;
+}
+
+static int sctp_wait_for_accept(struct sock *sk, long timeo)
+{
+        struct sctp_endpoint *ep;
+        int err = 0;
+        DEFINE_WAIT(wait);
+
+        ep = sctp_sk(sk)->ep;
+
+
+        for (;;) {
+                prepare_to_wait_exclusive(sk->sk_sleep, &wait,
+                                          TASK_INTERRUPTIBLE);
+
+                if (list_empty(&ep->asocs)) {
+                        sctp_release_sock(sk);
+                        timeo = schedule_timeout(timeo);
+                        sctp_lock_sock(sk);
+                }
+
+                err = -EINVAL;
+                if (!sctp_sstate(sk, LISTENING))
+                        break;
+
+                err = 0;
+                if (!list_empty(&ep->asocs))
+                        break;
+
+                err = sock_intr_errno(timeo);
+                if (signal_pending(current))
+                        break;
+
+                err = -EAGAIN;
+                if (!timeo)
+                        break;
+        }
+
+        finish_wait(sk->sk_sleep, &wait);
+
+        return err;
+}
+
+void sctp_wait_for_close(struct sock *sk, long timeout)
+{
+        DEFINE_WAIT(wait);
+
+        do {
+                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                if (list_empty(&sctp_sk(sk)->ep->asocs))
+                        break;
+                sctp_release_sock(sk);
+                timeout = schedule_timeout(timeout);
+                sctp_lock_sock(sk);
+        } while (!signal_pending(current) && timeout);
+
+        finish_wait(sk->sk_sleep, &wait);
+}
+
+/* Populate the fields of the newsk from the oldsk and migrate the assoc
+ * and its messages to the newsk.
+ */
+static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
+                              struct sctp_association *assoc,
+                              sctp_socket_type_t type)
+{
+        struct sctp_sock *oldsp = sctp_sk(oldsk);
+        struct sctp_sock *newsp = sctp_sk(newsk);
+        struct sctp_bind_bucket *pp; /* hash list port iterator */
+        struct sctp_endpoint *newep = newsp->ep;
+        struct sk_buff *skb, *tmp;
+        struct sctp_ulpevent *event;
+
+        /* Migrate socket buffer sizes and all the socket level options to the
+         * new socket.
+         */
+        newsk->sk_sndbuf = oldsk->sk_sndbuf;
+        newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
+        /* Brute force copy old sctp opt. */
+        inet_sk_copy_descendant(newsk, oldsk);
+
+        /* Restore the ep value that was overwritten with the above structure
+         * copy.
+         */
+        newsp->ep = newep;
+        newsp->hmac = NULL;
+
+        /* Hook this new socket in to the bind_hash list. */
+        pp = sctp_sk(oldsk)->bind_hash;
+        sk_add_bind_node(newsk, &pp->owner);
+        sctp_sk(newsk)->bind_hash = pp;
+        inet_sk(newsk)->num = inet_sk(oldsk)->num;
+
+        /* Move any messages in the old socket's receive queue that are for the
+         * peeled off association to the new socket's receive queue.
+         */
+        sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
+                event = sctp_skb2event(skb);
+                if (event->asoc == assoc) {
+                        __skb_unlink(skb, skb->list);
+                        __skb_queue_tail(&newsk->sk_receive_queue, skb);
+                }
+        }
+
+        /* Clean up any messages pending delivery due to partial
+         * delivery.   Three cases:
+         * 1) No partial deliver;  no work.
+         * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
+         * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
+         */
+        skb_queue_head_init(&newsp->pd_lobby);
+        sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode;
+
+        if (sctp_sk(oldsk)->pd_mode) {
+                struct sk_buff_head *queue;
+
+                /* Decide which queue to move pd_lobby skbs to. */
+                if (assoc->ulpq.pd_mode) {
+                        queue = &newsp->pd_lobby;
+                } else
+                        queue = &newsk->sk_receive_queue;
+
+                /* Walk through the pd_lobby, looking for skbs that
+                 * need moved to the new socket.
+                 */
+                sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
+                        event = sctp_skb2event(skb);
+                        if (event->asoc == assoc) {
+                                __skb_unlink(skb, skb->list);
+                                __skb_queue_tail(queue, skb);
+                        }
+                }
+
+                /* Clear up any skbs waiting for the partial
+                 * delivery to finish.
+                 */
+                if (assoc->ulpq.pd_mode)
+                        sctp_clear_pd(oldsk);
+
+        }
+
+        /* Set the type of socket to indicate that it is peeled off from the
+         * original UDP-style socket or created with the accept() call on a
+         * TCP-style socket..
+         */
+        newsp->type = type;
+
+        /* Migrate the association to the new socket. */
+        sctp_assoc_migrate(assoc, newsk);
+
+        /* If the association on the newsk is already closed before accept()
+         * is called, set RCV_SHUTDOWN flag.
+         */
+        if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP))
+                newsk->sk_shutdown |= RCV_SHUTDOWN;
+
+        newsk->sk_state = SCTP_SS_ESTABLISHED;
+}
+
+/* This proto struct describes the ULP interface for SCTP.  */
+struct proto sctp_prot = {
+        .name        =  "SCTP",
+        .owner       =  THIS_MODULE,
+        .close       =  sctp_close,
+        .connect     =  sctp_connect,
+        .disconnect  =  sctp_disconnect,
+        .accept      =  sctp_accept,
+        .ioctl       =  sctp_ioctl,
+        .init        =  sctp_init_sock,
+        .destroy     =  sctp_destroy_sock,
+        .shutdown    =  sctp_shutdown,
+        .setsockopt  =  sctp_setsockopt,
+        .getsockopt  =  sctp_getsockopt,
+        .sendmsg     =  sctp_sendmsg,
+        .recvmsg     =  sctp_recvmsg,
+        .bind        =  sctp_bind,
+        .backlog_rcv =  sctp_backlog_rcv,
+        .hash        =  sctp_hash,
+        .unhash      =  sctp_unhash,
+        .get_port    =  sctp_get_port,
+        .obj_size    =  sizeof(struct sctp_sock),
+};
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+struct proto sctpv6_prot = {
+        .name           = "SCTPv6",
+        .owner          = THIS_MODULE,
+        .close          = sctp_close,
+        .connect        = sctp_connect,
+        .disconnect     = sctp_disconnect,
+        .accept         = sctp_accept,
+        .ioctl          = sctp_ioctl,
+        .init           = sctp_init_sock,
+        .destroy        = sctp_destroy_sock,
+        .shutdown       = sctp_shutdown,
+        .setsockopt     = sctp_setsockopt,
+        .getsockopt     = sctp_getsockopt,
+        .sendmsg        = sctp_sendmsg,
+        .recvmsg        = sctp_recvmsg,
+        .bind           = sctp_bind,
+        .backlog_rcv    = sctp_backlog_rcv,
+        .hash           = sctp_hash,
+        .unhash         = sctp_unhash,
+        .get_port       = sctp_get_port,
+        .obj_size       = sizeof(struct sctp6_sock),
+};
+#endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
diff --git a/net/sctp/ssnmap.c b/net/sctp/ssnmap.c
new file mode 100644
index 000000000000..e627d2b451b6
--- /dev/null
+++ b/net/sctp/ssnmap.c
@@ -0,0 +1,131 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 2003 International Business Machines, Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions manipulate sctp SSN tracker.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+#define MAX_KMALLOC_SIZE        131072
+
+static struct sctp_ssnmap *sctp_ssnmap_init(struct sctp_ssnmap *map, __u16 in,
+                                            __u16 out);
+
+/* Storage size needed for map includes 2 headers and then the
+ * specific needs of in or out streams.
+ */
+static inline size_t sctp_ssnmap_size(__u16 in, __u16 out)
+{
+        return sizeof(struct sctp_ssnmap) + (in + out) * sizeof(__u16);
+}
+
+
+/* Create a new sctp_ssnmap.
+ * Allocate room to store at least 'len' contiguous TSNs.
+ */
+struct sctp_ssnmap *sctp_ssnmap_new(__u16 in, __u16 out, int gfp)
+{
+        struct sctp_ssnmap *retval;
+        int size;
+
+        size = sctp_ssnmap_size(in, out);
+        if (size <= MAX_KMALLOC_SIZE)
+                retval = kmalloc(size, gfp);
+        else
+                retval = (struct sctp_ssnmap *)
+                          __get_free_pages(gfp, get_order(size));
+        if (!retval)
+                goto fail;
+
+        if (!sctp_ssnmap_init(retval, in, out))
+                goto fail_map;
+
+        retval->malloced = 1;
+        SCTP_DBG_OBJCNT_INC(ssnmap);
+
+        return retval;
+
+fail_map:
+        if (size <= MAX_KMALLOC_SIZE)
+                kfree(retval);
+        else
+                free_pages((unsigned long)retval, get_order(size));
+fail:
+        return NULL;
+}
+
+
+/* Initialize a block of memory as a ssnmap.  */
+static struct sctp_ssnmap *sctp_ssnmap_init(struct sctp_ssnmap *map, __u16 in,
+                                            __u16 out)
+{
+        memset(map, 0x00, sctp_ssnmap_size(in, out));
+
+        /* Start 'in' stream just after the map header. */
+        map->in.ssn = (__u16 *)&map[1];
+        map->in.len = in;
+
+        /* Start 'out' stream just after 'in'. */
+        map->out.ssn = &map->in.ssn[in];
+        map->out.len = out;
+
+        return map;
+}
+
+/* Clear out the ssnmap streams.  */
+void sctp_ssnmap_clear(struct sctp_ssnmap *map)
+{
+        size_t size;
+
+        size = (map->in.len + map->out.len) * sizeof(__u16);
+        memset(map->in.ssn, 0x00, size);
+}
+
+/* Dispose of a ssnmap.  */
+void sctp_ssnmap_free(struct sctp_ssnmap *map)
+{
+        if (map && map->malloced) {
+                int size;
+
+                size = sctp_ssnmap_size(map->in.len, map->out.len);
+                if (size <= MAX_KMALLOC_SIZE)
+                        kfree(map);
+                else
+                        free_pages((unsigned long)map, get_order(size));
+                SCTP_DBG_OBJCNT_DEC(ssnmap);
+        }
+}
diff --git a/net/sctp/sysctl.c b/net/sctp/sysctl.c
new file mode 100644
index 000000000000..89fa20c73a5c
--- /dev/null
+++ b/net/sctp/sysctl.c
@@ -0,0 +1,251 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2002, 2004
+ * Copyright (c) 2002 Intel Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * Sysctl related interfaces for SCTP.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Mingqin Liu           <liuming@us.ibm.com>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Ryan Layer            <rmlayer@us.ibm.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <net/sctp/structs.h>
+#include <linux/sysctl.h>
+
+static ctl_handler sctp_sysctl_jiffies_ms;
+static long rto_timer_min = 1;
+static long rto_timer_max = 86400000; /* One day */
+
+static ctl_table sctp_table[] = {
+        {
+                .ctl_name       = NET_SCTP_RTO_INITIAL,
+                .procname       = "rto_initial",
+                .data           = &sctp_rto_initial,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_RTO_MIN,
+                .procname       = "rto_min",
+                .data           = &sctp_rto_min,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_RTO_MAX,
+                .procname       = "rto_max",
+                .data           = &sctp_rto_max,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_VALID_COOKIE_LIFE,
+                .procname       = "valid_cookie_life",
+                .data           = &sctp_valid_cookie_life,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_MAX_BURST,
+                .procname       = "max_burst",
+                .data           = &sctp_max_burst,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_ASSOCIATION_MAX_RETRANS,
+                .procname       = "association_max_retrans",
+                .data           = &sctp_max_retrans_association,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_PATH_MAX_RETRANS,
+                .procname       = "path_max_retrans",
+                .data           = &sctp_max_retrans_path,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_MAX_INIT_RETRANSMITS,
+                .procname       = "max_init_retransmits",
+                .data           = &sctp_max_retrans_init,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_HB_INTERVAL,
+                .procname       = "hb_interval",
+                .data           = &sctp_hb_interval,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_PRESERVE_ENABLE,
+                .procname       = "cookie_preserve_enable",
+                .data           = &sctp_cookie_preserve_enable,
+                .maxlen         = sizeof(long),
+                .mode           = 0644,
+                .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+                .strategy       = &sctp_sysctl_jiffies_ms,
+                .extra1         = &rto_timer_min,
+                .extra2         = &rto_timer_max
+        },
+        {
+                .ctl_name       = NET_SCTP_RTO_ALPHA,
+                .procname       = "rto_alpha_exp_divisor",
+                .data           = &sctp_rto_alpha,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_RTO_BETA,
+                .procname       = "rto_beta_exp_divisor",
+                .data           = &sctp_rto_beta,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_ADDIP_ENABLE,
+                .procname       = "addip_enable",
+                .data           = &sctp_addip_enable,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .ctl_name       = NET_SCTP_PRSCTP_ENABLE,
+                .procname       = "prsctp_enable",
+                .data           = &sctp_prsctp_enable,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        { .ctl_name = 0 }
+};
+
+static ctl_table sctp_net_table[] = {
+        {
+                .ctl_name       = NET_SCTP,
+                .procname       = "sctp",
+                .mode           = 0555,
+                .child          = sctp_table
+        },
+        { .ctl_name = 0 }
+};
+
+static ctl_table sctp_root_table[] = {
+        {
+                .ctl_name       = CTL_NET,
+                .procname       = "net",
+                .mode           = 0555,
+                .child          = sctp_net_table
+        },
+        { .ctl_name = 0 }
+};
+
+static struct ctl_table_header * sctp_sysctl_header;
+
+/* Sysctl registration.  */
+void sctp_sysctl_register(void)
+{
+        sctp_sysctl_header = register_sysctl_table(sctp_root_table, 0);
+}
+
+/* Sysctl deregistration.  */
+void sctp_sysctl_unregister(void)
+{
+        unregister_sysctl_table(sctp_sysctl_header);
+}
+
+/* Strategy function to convert jiffies to milliseconds.  */
+static int sctp_sysctl_jiffies_ms(ctl_table *table, int __user *name, int nlen,
+                void __user *oldval, size_t __user *oldlenp,
+                void __user *newval, size_t newlen, void **context) {
+
+        if (oldval) {
+                size_t olen;
+
+                if (oldlenp) {
+                        if (get_user(olen, oldlenp))
+                                return -EFAULT;
+
+                        if (olen != sizeof (int))
+                                return -EINVAL;
+                }
+                if (put_user((*(int *)(table->data) * 1000) / HZ,
+                        (int __user *)oldval) ||
+                    (oldlenp && put_user(sizeof (int), oldlenp)))
+                        return -EFAULT;
+        }
+        if (newval && newlen) {
+                int new;
+
+                if (newlen != sizeof (int))
+                        return -EINVAL;
+
+                if (get_user(new, (int __user *)newval))
+                        return -EFAULT;
+
+                *(int *)(table->data) = (new * HZ) / 1000;
+        }
+        return 1;
+}
diff --git a/net/sctp/transport.c b/net/sctp/transport.c
new file mode 100644
index 000000000000..f30882e1e96a
--- /dev/null
+++ b/net/sctp/transport.c
@@ -0,0 +1,514 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 International Business Machines Corp.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * This module provides the abstraction for an SCTP tranport representing
+ * a remote transport address.  For local transport addresses, we just use
+ * union sctp_addr.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Xingang Guo           <xingang.guo@intel.com>
+ *    Hui Huang             <hui.huang@nokia.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* 1st Level Abstractions.  */
+
+/* Initialize a new transport from provided memory.  */
+static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
+                                                  const union sctp_addr *addr,
+                                                  int gfp)
+{
+        /* Copy in the address.  */
+        peer->ipaddr = *addr;
+        peer->af_specific = sctp_get_af_specific(addr->sa.sa_family);
+        peer->asoc = NULL;
+
+        peer->dst = NULL;
+        memset(&peer->saddr, 0, sizeof(union sctp_addr));
+
+        /* From 6.3.1 RTO Calculation:
+         *
+         * C1) Until an RTT measurement has been made for a packet sent to the
+         * given destination transport address, set RTO to the protocol
+         * parameter 'RTO.Initial'.
+         */
+        peer->rtt = 0;
+        peer->rto = sctp_rto_initial;
+        peer->rttvar = 0;
+        peer->srtt = 0;
+        peer->rto_pending = 0;
+
+        peer->last_time_heard = jiffies;
+        peer->last_time_used = jiffies;
+        peer->last_time_ecne_reduced = jiffies;
+
+        peer->active = SCTP_ACTIVE;
+        peer->hb_allowed = 0;
+
+        /* Initialize the default path max_retrans.  */
+        peer->max_retrans = sctp_max_retrans_path;
+        peer->error_count = 0;
+
+        INIT_LIST_HEAD(&peer->transmitted);
+        INIT_LIST_HEAD(&peer->send_ready);
+        INIT_LIST_HEAD(&peer->transports);
+
+        /* Set up the retransmission timer.  */
+        init_timer(&peer->T3_rtx_timer);
+        peer->T3_rtx_timer.function = sctp_generate_t3_rtx_event;
+        peer->T3_rtx_timer.data = (unsigned long)peer;
+
+        /* Set up the heartbeat timer. */
+        init_timer(&peer->hb_timer);
+        peer->hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
+        peer->hb_timer.function = sctp_generate_heartbeat_event;
+        peer->hb_timer.data = (unsigned long)peer;
+
+        atomic_set(&peer->refcnt, 1);
+        peer->dead = 0;
+
+        peer->malloced = 0;
+
+        /* Initialize the state information for SFR-CACC */
+        peer->cacc.changeover_active = 0;
+        peer->cacc.cycling_changeover = 0;
+        peer->cacc.next_tsn_at_change = 0;
+        peer->cacc.cacc_saw_newack = 0;
+
+        return peer;
+}
+
+/* Allocate and initialize a new transport.  */
+struct sctp_transport *sctp_transport_new(const union sctp_addr *addr, int gfp)
+{
+        struct sctp_transport *transport;
+
+        transport = t_new(struct sctp_transport, gfp);
+        if (!transport)
+                goto fail;
+
+        if (!sctp_transport_init(transport, addr, gfp))
+                goto fail_init;
+
+        transport->malloced = 1;
+        SCTP_DBG_OBJCNT_INC(transport);
+
+        return transport;
+
+fail_init:
+        kfree(transport);
+
+fail:
+        return NULL;
+}
+
+/* This transport is no longer needed.  Free up if possible, or
+ * delay until it last reference count.
+ */
+void sctp_transport_free(struct sctp_transport *transport)
+{
+        transport->dead = 1;
+
+        /* Try to delete the heartbeat timer.  */
+        if (del_timer(&transport->hb_timer))
+                sctp_transport_put(transport);
+
+        /* Delete the T3_rtx timer if it's active.
+         * There is no point in not doing this now and letting
+         * structure hang around in memory since we know
+         * the tranport is going away.
+         */
+        if (timer_pending(&transport->T3_rtx_timer) &&
+            del_timer(&transport->T3_rtx_timer))
+                sctp_transport_put(transport);
+
+
+        sctp_transport_put(transport);
+}
+
+/* Destroy the transport data structure.
+ * Assumes there are no more users of this structure.
+ */
+static void sctp_transport_destroy(struct sctp_transport *transport)
+{
+        SCTP_ASSERT(transport->dead, "Transport is not dead", return);
+
+        if (transport->asoc)
+                sctp_association_put(transport->asoc);
+
+        sctp_packet_free(&transport->packet);
+
+        dst_release(transport->dst);
+        kfree(transport);
+        SCTP_DBG_OBJCNT_DEC(transport);
+}
+
+/* Start T3_rtx timer if it is not already running and update the heartbeat
+ * timer.  This routine is called every time a DATA chunk is sent.
+ */
+void sctp_transport_reset_timers(struct sctp_transport *transport)
+{
+        /* RFC 2960 6.3.2 Retransmission Timer Rules
+         *
+         * R1) Every time a DATA chunk is sent to any address(including a
+         * retransmission), if the T3-rtx timer of that address is not running
+         * start it running so that it will expire after the RTO of that
+         * address.
+         */
+
+        if (!timer_pending(&transport->T3_rtx_timer))
+                if (!mod_timer(&transport->T3_rtx_timer,
+                               jiffies + transport->rto))
+                        sctp_transport_hold(transport);
+
+        /* When a data chunk is sent, reset the heartbeat interval.  */
+        if (!mod_timer(&transport->hb_timer,
+                       sctp_transport_timeout(transport)))
+            sctp_transport_hold(transport);
+}
+
+/* This transport has been assigned to an association.
+ * Initialize fields from the association or from the sock itself.
+ * Register the reference count in the association.
+ */
+void sctp_transport_set_owner(struct sctp_transport *transport,
+                              struct sctp_association *asoc)
+{
+        transport->asoc = asoc;
+        sctp_association_hold(asoc);
+}
+
+/* Initialize the pmtu of a transport. */
+void sctp_transport_pmtu(struct sctp_transport *transport)
+{
+        struct dst_entry *dst;
+
+        dst = transport->af_specific->get_dst(NULL, &transport->ipaddr, NULL);
+
+        if (dst) {
+                transport->pmtu = dst_mtu(dst);
+                dst_release(dst);
+        } else
+                transport->pmtu = SCTP_DEFAULT_MAXSEGMENT;
+}
+
+/* Caches the dst entry and source address for a transport's destination
+ * address.
+ */
+void sctp_transport_route(struct sctp_transport *transport,
+                          union sctp_addr *saddr, struct sctp_sock *opt)
+{
+        struct sctp_association *asoc = transport->asoc;
+        struct sctp_af *af = transport->af_specific;
+        union sctp_addr *daddr = &transport->ipaddr;
+        struct dst_entry *dst;
+
+        dst = af->get_dst(asoc, daddr, saddr);
+
+        if (saddr)
+                memcpy(&transport->saddr, saddr, sizeof(union sctp_addr));
+        else
+                af->get_saddr(asoc, dst, daddr, &transport->saddr);
+
+        transport->dst = dst;
+        if (dst) {
+                transport->pmtu = dst_mtu(dst);
+
+                /* Initialize sk->sk_rcv_saddr, if the transport is the
+                 * association's active path for getsockname().
+                 */ 
+                if (asoc && (transport == asoc->peer.active_path))
+                        af->to_sk_saddr(&transport->saddr, asoc->base.sk);
+        } else
+                transport->pmtu = SCTP_DEFAULT_MAXSEGMENT;
+}
+
+/* Hold a reference to a transport.  */
+void sctp_transport_hold(struct sctp_transport *transport)
+{
+        atomic_inc(&transport->refcnt);
+}
+
+/* Release a reference to a transport and clean up
+ * if there are no more references.
+ */
+void sctp_transport_put(struct sctp_transport *transport)
+{
+        if (atomic_dec_and_test(&transport->refcnt))
+                sctp_transport_destroy(transport);
+}
+
+/* Update transport's RTO based on the newly calculated RTT. */
+void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt)
+{
+        /* Check for valid transport.  */
+        SCTP_ASSERT(tp, "NULL transport", return);
+
+        /* We should not be doing any RTO updates unless rto_pending is set.  */
+        SCTP_ASSERT(tp->rto_pending, "rto_pending not set", return);
+
+        if (tp->rttvar || tp->srtt) {
+                /* 6.3.1 C3) When a new RTT measurement R' is made, set
+                 * RTTVAR <- (1 - RTO.Beta) * RTTVAR + RTO.Beta * |SRTT - R'|
+                 * SRTT <- (1 - RTO.Alpha) * SRTT + RTO.Alpha * R'
+                 */
+
+                /* Note:  The above algorithm has been rewritten to
+                 * express rto_beta and rto_alpha as inverse powers
+                 * of two.
+                 * For example, assuming the default value of RTO.Alpha of
+                 * 1/8, rto_alpha would be expressed as 3.
+                 */
+                tp->rttvar = tp->rttvar - (tp->rttvar >> sctp_rto_beta)
+                        + ((abs(tp->srtt - rtt)) >> sctp_rto_beta);
+                tp->srtt = tp->srtt - (tp->srtt >> sctp_rto_alpha)
+                        + (rtt >> sctp_rto_alpha);
+        } else {
+                /* 6.3.1 C2) When the first RTT measurement R is made, set
+                 * SRTT <- R, RTTVAR <- R/2.
+                 */
+                tp->srtt = rtt;
+                tp->rttvar = rtt >> 1;
+        }
+
+        /* 6.3.1 G1) Whenever RTTVAR is computed, if RTTVAR = 0, then
+         * adjust RTTVAR <- G, where G is the CLOCK GRANULARITY.
+         */
+        if (tp->rttvar == 0)
+                tp->rttvar = SCTP_CLOCK_GRANULARITY;
+
+        /* 6.3.1 C3) After the computation, update RTO <- SRTT + 4 * RTTVAR. */
+        tp->rto = tp->srtt + (tp->rttvar << 2);
+
+        /* 6.3.1 C6) Whenever RTO is computed, if it is less than RTO.Min
+         * seconds then it is rounded up to RTO.Min seconds.
+         */
+        if (tp->rto < tp->asoc->rto_min)
+                tp->rto = tp->asoc->rto_min;
+
+        /* 6.3.1 C7) A maximum value may be placed on RTO provided it is
+         * at least RTO.max seconds.
+         */
+        if (tp->rto > tp->asoc->rto_max)
+                tp->rto = tp->asoc->rto_max;
+
+        tp->rtt = rtt;
+
+        /* Reset rto_pending so that a new RTT measurement is started when a
+         * new data chunk is sent.
+         */
+        tp->rto_pending = 0;
+
+        SCTP_DEBUG_PRINTK("%s: transport: %p, rtt: %d, srtt: %d "
+                          "rttvar: %d, rto: %d\n", __FUNCTION__,
+                          tp, rtt, tp->srtt, tp->rttvar, tp->rto);
+}
+
+/* This routine updates the transport's cwnd and partial_bytes_acked
+ * parameters based on the bytes acked in the received SACK.
+ */
+void sctp_transport_raise_cwnd(struct sctp_transport *transport,
+                               __u32 sack_ctsn, __u32 bytes_acked)
+{
+        __u32 cwnd, ssthresh, flight_size, pba, pmtu;
+
+        cwnd = transport->cwnd;
+        flight_size = transport->flight_size;
+
+        /* The appropriate cwnd increase algorithm is performed if, and only
+         * if the cumulative TSN has advanced and the congestion window is
+         * being fully utilized.
+         */
+        if ((transport->asoc->ctsn_ack_point >= sack_ctsn) ||
+            (flight_size < cwnd))
+                return;
+
+        ssthresh = transport->ssthresh;
+        pba = transport->partial_bytes_acked;
+        pmtu = transport->asoc->pmtu;
+
+        if (cwnd <= ssthresh) {
+                /* RFC 2960 7.2.1, sctpimpguide-05 2.14.2 When cwnd is less
+                 * than or equal to ssthresh an SCTP endpoint MUST use the
+                 * slow start algorithm to increase cwnd only if the current
+                 * congestion window is being fully utilized and an incoming
+                 * SACK advances the Cumulative TSN Ack Point. Only when these
+                 * two conditions are met can the cwnd be increased otherwise
+                 * the cwnd MUST not be increased. If these conditions are met
+                 * then cwnd MUST be increased by at most the lesser of
+                 * 1) the total size of the previously outstanding DATA
+                 * chunk(s) acknowledged, and 2) the destination's path MTU.
+                 */
+                if (bytes_acked > pmtu)
+                        cwnd += pmtu;
+                else
+                        cwnd += bytes_acked;
+                SCTP_DEBUG_PRINTK("%s: SLOW START: transport: %p, "
+                                  "bytes_acked: %d, cwnd: %d, ssthresh: %d, "
+                                  "flight_size: %d, pba: %d\n",
+                                  __FUNCTION__,
+                                  transport, bytes_acked, cwnd,
+                                  ssthresh, flight_size, pba);
+        } else {
+                /* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh,
+                 * upon each SACK arrival that advances the Cumulative TSN Ack
+                 * Point, increase partial_bytes_acked by the total number of
+                 * bytes of all new chunks acknowledged in that SACK including
+                 * chunks acknowledged by the new Cumulative TSN Ack and by
+                 * Gap Ack Blocks.
+                 *
+                 * When partial_bytes_acked is equal to or greater than cwnd
+                 * and before the arrival of the SACK the sender had cwnd or
+                 * more bytes of data outstanding (i.e., before arrival of the
+                 * SACK, flightsize was greater than or equal to cwnd),
+                 * increase cwnd by MTU, and reset partial_bytes_acked to
+                 * (partial_bytes_acked - cwnd).
+                 */
+                pba += bytes_acked;
+                if (pba >= cwnd) {
+                        cwnd += pmtu;
+                        pba = ((cwnd < pba) ? (pba - cwnd) : 0);
+                }
+                SCTP_DEBUG_PRINTK("%s: CONGESTION AVOIDANCE: "
+                                  "transport: %p, bytes_acked: %d, cwnd: %d, "
+                                  "ssthresh: %d, flight_size: %d, pba: %d\n",
+                                  __FUNCTION__,
+                                  transport, bytes_acked, cwnd,
+                                  ssthresh, flight_size, pba);
+        }
+
+        transport->cwnd = cwnd;
+        transport->partial_bytes_acked = pba;
+}
+
+/* This routine is used to lower the transport's cwnd when congestion is
+ * detected.
+ */
+void sctp_transport_lower_cwnd(struct sctp_transport *transport,
+                               sctp_lower_cwnd_t reason)
+{
+        switch (reason) {
+        case SCTP_LOWER_CWND_T3_RTX:
+                /* RFC 2960 Section 7.2.3, sctpimpguide
+                 * When the T3-rtx timer expires on an address, SCTP should
+                 * perform slow start by:
+                 *      ssthresh = max(cwnd/2, 4*MTU)
+                 *      cwnd = 1*MTU
+                 *      partial_bytes_acked = 0
+                 */
+                transport->ssthresh = max(transport->cwnd/2,
+                                          4*transport->asoc->pmtu);
+                transport->cwnd = transport->asoc->pmtu;
+                break;
+
+        case SCTP_LOWER_CWND_FAST_RTX:
+                /* RFC 2960 7.2.4 Adjust the ssthresh and cwnd of the
+                 * destination address(es) to which the missing DATA chunks
+                 * were last sent, according to the formula described in
+                 * Section 7.2.3.
+                 *
+                 * RFC 2960 7.2.3, sctpimpguide Upon detection of packet
+                 * losses from SACK (see Section 7.2.4), An endpoint
+                 * should do the following:
+                 *      ssthresh = max(cwnd/2, 4*MTU)
+                 *      cwnd = ssthresh
+                 *      partial_bytes_acked = 0
+                 */
+                transport->ssthresh = max(transport->cwnd/2,
+                                          4*transport->asoc->pmtu);
+                transport->cwnd = transport->ssthresh;
+                break;
+
+        case SCTP_LOWER_CWND_ECNE:
+                /* RFC 2481 Section 6.1.2.
+                 * If the sender receives an ECN-Echo ACK packet
+                 * then the sender knows that congestion was encountered in the
+                 * network on the path from the sender to the receiver. The
+                 * indication of congestion should be treated just as a
+                 * congestion loss in non-ECN Capable TCP. That is, the TCP
+                 * source halves the congestion window "cwnd" and reduces the
+                 * slow start threshold "ssthresh".
+                 * A critical condition is that TCP does not react to
+                 * congestion indications more than once every window of
+                 * data (or more loosely more than once every round-trip time).
+                 */
+                if ((jiffies - transport->last_time_ecne_reduced) >
+                    transport->rtt) {
+                        transport->ssthresh = max(transport->cwnd/2,
+                                                  4*transport->asoc->pmtu);
+                        transport->cwnd = transport->ssthresh;
+                        transport->last_time_ecne_reduced = jiffies;
+                }
+                break;
+
+        case SCTP_LOWER_CWND_INACTIVE:
+                /* RFC 2960 Section 7.2.1, sctpimpguide
+                 * When the endpoint does not transmit data on a given
+                 * transport address, the cwnd of the transport address
+                 * should be adjusted to max(cwnd/2, 4*MTU) per RTO.
+                 * NOTE: Although the draft recommends that this check needs
+                 * to be done every RTO interval, we do it every hearbeat
+                 * interval.
+                 */
+                if ((jiffies - transport->last_time_used) > transport->rto)
+                        transport->cwnd = max(transport->cwnd/2,
+                                                 4*transport->asoc->pmtu);
+                break;
+        };
+
+        transport->partial_bytes_acked = 0;
+        SCTP_DEBUG_PRINTK("%s: transport: %p reason: %d cwnd: "
+                          "%d ssthresh: %d\n", __FUNCTION__,
+                          transport, reason,
+                          transport->cwnd, transport->ssthresh);
+}
+
+/* What is the next timeout value for this transport? */
+unsigned long sctp_transport_timeout(struct sctp_transport *t)
+{
+        unsigned long timeout;
+        timeout = t->hb_interval + t->rto + sctp_jitter(t->rto);
+        timeout += jiffies;
+        return timeout;
+}
diff --git a/net/sctp/tsnmap.c b/net/sctp/tsnmap.c
new file mode 100644
index 000000000000..ac4fae161bc7
--- /dev/null
+++ b/net/sctp/tsnmap.c
@@ -0,0 +1,417 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * These functions manipulate sctp tsn mapping array.
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    Karl Knutson          <karl@athena.chicago.il.us>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+static void sctp_tsnmap_update(struct sctp_tsnmap *map);
+static void sctp_tsnmap_find_gap_ack(__u8 *map, __u16 off,
+                                     __u16 len, __u16 base,
+                                     int *started, __u16 *start,
+                                     int *ended, __u16 *end);
+
+/* Initialize a block of memory as a tsnmap.  */
+struct sctp_tsnmap *sctp_tsnmap_init(struct sctp_tsnmap *map, __u16 len,
+                                     __u32 initial_tsn)
+{
+        map->tsn_map = map->raw_map;
+        map->overflow_map = map->tsn_map + len;
+        map->len = len;
+
+        /* Clear out a TSN ack status.  */
+        memset(map->tsn_map, 0x00, map->len + map->len);
+
+        /* Keep track of TSNs represented by tsn_map.  */
+        map->base_tsn = initial_tsn;
+        map->overflow_tsn = initial_tsn + map->len;
+        map->cumulative_tsn_ack_point = initial_tsn - 1;
+        map->max_tsn_seen = map->cumulative_tsn_ack_point;
+        map->malloced = 0;
+        map->num_dup_tsns = 0;
+
+        return map;
+}
+
+/* Test the tracking state of this TSN.
+ * Returns:
+ *   0 if the TSN has not yet been seen
+ *  >0 if the TSN has been seen (duplicate)
+ *  <0 if the TSN is invalid (too large to track)
+ */
+int sctp_tsnmap_check(const struct sctp_tsnmap *map, __u32 tsn)
+{
+        __s32 gap;
+        int dup;
+
+        /* Calculate the index into the mapping arrays.  */
+        gap = tsn - map->base_tsn;
+
+        /* Verify that we can hold this TSN.  */
+        if (gap >= (/* base */ map->len + /* overflow */ map->len)) {
+                dup = -1;
+                goto out;
+        }
+
+        /* Honk if we've already seen this TSN.
+         * We have three cases:
+         *      1. The TSN is ancient or belongs to a previous tsn_map.
+         *      2. The TSN is already marked in the tsn_map.
+         *      3. The TSN is already marked in the tsn_map_overflow.
+         */
+        if (gap < 0 ||
+            (gap < map->len && map->tsn_map[gap]) ||
+            (gap >= map->len && map->overflow_map[gap - map->len]))
+                dup = 1;
+        else
+                dup = 0;
+
+out:
+        return dup;
+}
+
+
+/* Mark this TSN as seen.  */
+void sctp_tsnmap_mark(struct sctp_tsnmap *map, __u32 tsn)
+{
+        __s32 gap;
+
+        /* Vacuously mark any TSN which precedes the map base or
+         * exceeds the end of the map.
+         */
+        if (TSN_lt(tsn, map->base_tsn))
+                return;
+        if (!TSN_lt(tsn, map->base_tsn + map->len + map->len))
+                return;
+
+        /* Bump the max.  */
+        if (TSN_lt(map->max_tsn_seen, tsn))
+                map->max_tsn_seen = tsn;
+
+        /* Assert: TSN is in range.  */
+        gap = tsn - map->base_tsn;
+
+        /* Mark the TSN as received.  */
+        if (gap < map->len)
+                map->tsn_map[gap]++;
+        else
+                map->overflow_map[gap - map->len]++;
+
+        /* Go fixup any internal TSN mapping variables including
+         * cumulative_tsn_ack_point.
+         */
+        sctp_tsnmap_update(map);
+}
+
+
+/* Initialize a Gap Ack Block iterator from memory being provided.  */
+SCTP_STATIC void sctp_tsnmap_iter_init(const struct sctp_tsnmap *map,
+                                       struct sctp_tsnmap_iter *iter)
+{
+        /* Only start looking one past the Cumulative TSN Ack Point.  */
+        iter->start = map->cumulative_tsn_ack_point + 1;
+}
+
+/* Get the next Gap Ack Blocks. Returns 0 if there was not another block
+ * to get.
+ */
+SCTP_STATIC int sctp_tsnmap_next_gap_ack(const struct sctp_tsnmap *map,
+                                         struct sctp_tsnmap_iter *iter,
+                                         __u16 *start, __u16 *end)
+{
+        int started, ended;
+        __u16 _start, _end, offset;
+
+        /* We haven't found a gap yet.  */
+        started = ended = 0;
+
+        /* If there are no more gap acks possible, get out fast.  */
+        if (TSN_lte(map->max_tsn_seen, iter->start))
+                return 0;
+
+        /* Search the first mapping array.  */
+        if (iter->start - map->base_tsn < map->len) {
+
+                offset = iter->start - map->base_tsn;
+                sctp_tsnmap_find_gap_ack(map->tsn_map, offset, map->len, 0,
+                                         &started, &_start, &ended, &_end);
+        }
+
+        /* Do we need to check the overflow map? */
+        if (!ended) {
+                /* Fix up where we'd like to start searching in the
+                 * overflow map.
+                 */
+                if (iter->start - map->base_tsn < map->len)
+                        offset = 0;
+                else
+                        offset = iter->start - map->base_tsn - map->len;
+
+                /* Search the overflow map.  */
+                sctp_tsnmap_find_gap_ack(map->overflow_map,
+                                         offset,
+                                         map->len,
+                                         map->len,
+                                         &started, &_start,
+                                         &ended, &_end);
+        }
+
+        /* The Gap Ack Block happens to end at the end of the
+         * overflow map.
+         */
+        if (started && !ended) {
+                ended++;
+                _end = map->len + map->len - 1;
+        }
+
+        /* If we found a Gap Ack Block, return the start and end and
+         * bump the iterator forward.
+         */
+        if (ended) {
+                /* Fix up the start and end based on the
+                 * Cumulative TSN Ack offset into the map.
+                 */
+                int gap = map->cumulative_tsn_ack_point -
+                        map->base_tsn;
+
+                *start = _start - gap;
+                *end = _end - gap;
+
+                /* Move the iterator forward.  */
+                iter->start = map->cumulative_tsn_ack_point + *end + 1;
+        }
+
+        return ended;
+}
+
+/* Mark this and any lower TSN as seen.  */
+void sctp_tsnmap_skip(struct sctp_tsnmap *map, __u32 tsn)
+{
+        __s32 gap;
+
+        /* Vacuously mark any TSN which precedes the map base or
+         * exceeds the end of the map.
+         */
+        if (TSN_lt(tsn, map->base_tsn))
+                return;
+        if (!TSN_lt(tsn, map->base_tsn + map->len + map->len))
+                return;
+
+        /* Bump the max.  */
+        if (TSN_lt(map->max_tsn_seen, tsn))
+                map->max_tsn_seen = tsn;
+
+        /* Assert: TSN is in range.  */
+        gap = tsn - map->base_tsn + 1;
+
+        /* Mark the TSNs as received.  */
+        if (gap <= map->len)
+                memset(map->tsn_map, 0x01, gap);
+        else {
+                memset(map->tsn_map, 0x01, map->len);
+                memset(map->overflow_map, 0x01, (gap - map->len));
+        }
+
+        /* Go fixup any internal TSN mapping variables including
+         * cumulative_tsn_ack_point.
+         */
+        sctp_tsnmap_update(map);
+}
+
+/********************************************************************
+ * 2nd Level Abstractions
+ ********************************************************************/
+
+/* This private helper function updates the tsnmap buffers and
+ * the Cumulative TSN Ack Point.
+ */
+static void sctp_tsnmap_update(struct sctp_tsnmap *map)
+{
+        __u32 ctsn;
+
+        ctsn = map->cumulative_tsn_ack_point;
+        do {
+                ctsn++;
+                if (ctsn == map->overflow_tsn) {
+                        /* Now tsn_map must have been all '1's,
+                         * so we swap the map and check the overflow table
+                         */
+                        __u8 *tmp = map->tsn_map;
+                        memset(tmp, 0, map->len);
+                        map->tsn_map = map->overflow_map;
+                        map->overflow_map = tmp;
+
+                        /* Update the tsn_map boundaries.  */
+                        map->base_tsn += map->len;
+                        map->overflow_tsn += map->len;
+                }
+        } while (map->tsn_map[ctsn - map->base_tsn]);
+
+        map->cumulative_tsn_ack_point = ctsn - 1; /* Back up one. */
+}
+
+/* How many data chunks  are we missing from our peer?
+ */
+__u16 sctp_tsnmap_pending(struct sctp_tsnmap *map)
+{
+        __u32 cum_tsn = map->cumulative_tsn_ack_point;
+        __u32 max_tsn = map->max_tsn_seen;
+        __u32 base_tsn = map->base_tsn;
+        __u16 pending_data;
+        __s32 gap, start, end, i;
+
+        pending_data = max_tsn - cum_tsn;
+        gap = max_tsn - base_tsn;
+
+        if (gap <= 0 || gap >= (map->len + map->len))
+                goto out;
+
+        start = ((cum_tsn >= base_tsn) ? (cum_tsn - base_tsn + 1) : 0);
+        end = ((gap > map->len ) ? map->len : gap + 1);
+
+        for (i = start; i < end; i++) {
+                if (map->tsn_map[i])
+                        pending_data--;
+        }
+
+        if (gap >= map->len) {
+                start = 0;
+                end = gap - map->len + 1;
+                for (i = start; i < end; i++) {
+                        if (map->overflow_map[i])
+                                pending_data--;
+                }
+        }
+
+out:
+        return pending_data;
+}
+
+/* This is a private helper for finding Gap Ack Blocks.  It searches a
+ * single array for the start and end of a Gap Ack Block.
+ *
+ * The flags "started" and "ended" tell is if we found the beginning
+ * or (respectively) the end of a Gap Ack Block.
+ */
+static void sctp_tsnmap_find_gap_ack(__u8 *map, __u16 off,
+                                     __u16 len, __u16 base,
+                                     int *started, __u16 *start,
+                                     int *ended, __u16 *end)
+{
+        int i = off;
+
+        /* Look through the entire array, but break out
+         * early if we have found the end of the Gap Ack Block.
+         */
+
+        /* Also, stop looking past the maximum TSN seen. */
+
+        /* Look for the start. */
+        if (!(*started)) {
+                for (; i < len; i++) {
+                        if (map[i]) {
+                                (*started)++;
+                                *start = base + i;
+                                break;
+                        }
+                }
+        }
+
+        /* Look for the end.  */
+        if (*started) {
+                /* We have found the start, let's find the
+                 * end.  If we find the end, break out.
+                 */
+                for (; i < len; i++) {
+                        if (!map[i]) {
+                                (*ended)++;
+                                *end = base + i - 1;
+                                break;
+                        }
+                }
+        }
+}
+
+/* Renege that we have seen a TSN.  */
+void sctp_tsnmap_renege(struct sctp_tsnmap *map, __u32 tsn)
+{
+        __s32 gap;
+
+        if (TSN_lt(tsn, map->base_tsn))
+                return;
+        if (!TSN_lt(tsn, map->base_tsn + map->len + map->len))
+                return;
+
+        /* Assert: TSN is in range.  */
+        gap = tsn - map->base_tsn;
+
+        /* Pretend we never saw the TSN.  */
+        if (gap < map->len)
+                map->tsn_map[gap] = 0;
+        else
+                map->overflow_map[gap - map->len] = 0;
+}
+
+/* How many gap ack blocks do we have recorded? */
+__u16 sctp_tsnmap_num_gabs(struct sctp_tsnmap *map)
+{
+        struct sctp_tsnmap_iter iter;
+        int gabs = 0;
+
+        /* Refresh the gap ack information. */
+        if (sctp_tsnmap_has_gap(map)) {
+                sctp_tsnmap_iter_init(map, &iter);
+                while (sctp_tsnmap_next_gap_ack(map, &iter,
+                                                &map->gabs[gabs].start,
+                                                &map->gabs[gabs].end)) {
+
+                        map->gabs[gabs].start = htons(map->gabs[gabs].start);
+                        map->gabs[gabs].end = htons(map->gabs[gabs].end);
+                        gabs++;
+                        if (gabs >= SCTP_MAX_GABS)
+                                break;
+                }
+        }
+        return gabs;
+}
diff --git a/net/sctp/ulpevent.c b/net/sctp/ulpevent.c
new file mode 100644
index 000000000000..17d0ff534735
--- /dev/null
+++ b/net/sctp/ulpevent.c
@@ -0,0 +1,942 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * These functions manipulate an sctp event.   The struct ulpevent is used
+ * to carry notifications and data to the ULP (sockets).
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Ardelle Fan           <ardelle.fan@intel.com>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/skbuff.h>
+#include <net/sctp/structs.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
+                                       struct sctp_association *asoc);
+static void sctp_ulpevent_release_data(struct sctp_ulpevent *event);
+
+/* Stub skb destructor.  */
+static void sctp_stub_rfree(struct sk_buff *skb)
+{
+/* WARNING:  This function is just a warning not to use the
+ * skb destructor.  If the skb is shared, we may get the destructor
+ * callback on some processor that does not own the sock_lock.  This
+ * was occuring with PACKET socket applications that were monitoring
+ * our skbs.   We can't take the sock_lock, because we can't risk
+ * recursing if we do really own the sock lock.  Instead, do all
+ * of our rwnd manipulation while we own the sock_lock outright.
+ */
+}
+
+/* Initialize an ULP event from an given skb.  */
+SCTP_STATIC void sctp_ulpevent_init(struct sctp_ulpevent *event, int msg_flags)
+{
+        memset(event, 0, sizeof(struct sctp_ulpevent));
+        event->msg_flags = msg_flags;
+}
+
+/* Create a new sctp_ulpevent.  */
+SCTP_STATIC struct sctp_ulpevent *sctp_ulpevent_new(int size, int msg_flags,
+                                                    int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sk_buff *skb;
+
+        skb = alloc_skb(size, gfp);
+        if (!skb)
+                goto fail;
+
+        event = sctp_skb2event(skb);
+        sctp_ulpevent_init(event, msg_flags);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Is this a MSG_NOTIFICATION?  */
+int sctp_ulpevent_is_notification(const struct sctp_ulpevent *event)
+{
+        return MSG_NOTIFICATION == (event->msg_flags & MSG_NOTIFICATION);
+}
+
+/* Hold the association in case the msg_name needs read out of
+ * the association.
+ */
+static inline void sctp_ulpevent_set_owner(struct sctp_ulpevent *event,
+                                           const struct sctp_association *asoc)
+{
+        struct sk_buff *skb;
+
+        /* Cast away the const, as we are just wanting to
+         * bump the reference count.
+         */
+        sctp_association_hold((struct sctp_association *)asoc);
+        skb = sctp_event2skb(event);
+        skb->sk = asoc->base.sk;
+        event->asoc = (struct sctp_association *)asoc;
+        skb->destructor = sctp_stub_rfree;
+}
+
+/* A simple destructor to give up the reference to the association. */
+static inline void sctp_ulpevent_release_owner(struct sctp_ulpevent *event)
+{
+        sctp_association_put(event->asoc);
+}
+
+/* Create and initialize an SCTP_ASSOC_CHANGE event.
+ *
+ * 5.3.1.1 SCTP_ASSOC_CHANGE
+ *
+ * Communication notifications inform the ULP that an SCTP association
+ * has either begun or ended. The identifier for a new association is
+ * provided by this notification.
+ *
+ * Note: There is no field checking here.  If a field is unused it will be
+ * zero'd out.
+ */
+struct sctp_ulpevent  *sctp_ulpevent_make_assoc_change(
+        const struct sctp_association *asoc,
+        __u16 flags, __u16 state, __u16 error, __u16 outbound,
+        __u16 inbound, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_assoc_change *sac;
+        struct sk_buff *skb;
+
+        event = sctp_ulpevent_new(sizeof(struct sctp_assoc_change),
+                                  MSG_NOTIFICATION, gfp);
+        if (!event)
+                goto fail;
+        skb = sctp_event2skb(event);
+        sac = (struct sctp_assoc_change *)
+                skb_put(skb, sizeof(struct sctp_assoc_change));
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_type:
+         * It should be SCTP_ASSOC_CHANGE.
+         */
+        sac->sac_type = SCTP_ASSOC_CHANGE;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_state: 32 bits (signed integer)
+         * This field holds one of a number of values that communicate the
+         * event that happened to the association.
+         */
+        sac->sac_state = state;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_flags: 16 bits (unsigned integer)
+         * Currently unused.
+         */
+        sac->sac_flags = 0;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_length: sizeof (__u32)
+         * This field is the total length of the notification data, including
+         * the notification header.
+         */
+        sac->sac_length = sizeof(struct sctp_assoc_change);
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_error:  32 bits (signed integer)
+         *
+         * If the state was reached due to a error condition (e.g.
+         * COMMUNICATION_LOST) any relevant error information is available in
+         * this field. This corresponds to the protocol error codes defined in
+         * [SCTP].
+         */
+        sac->sac_error = error;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_outbound_streams:  16 bits (unsigned integer)
+         * sac_inbound_streams:  16 bits (unsigned integer)
+         *
+         * The maximum number of streams allowed in each direction are
+         * available in sac_outbound_streams and sac_inbound streams.
+         */
+        sac->sac_outbound_streams = outbound;
+        sac->sac_inbound_streams = inbound;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * sac_assoc_id: sizeof (sctp_assoc_t)
+         *
+         * The association id field, holds the identifier for the association.
+         * All notifications for a given association have the same association
+         * identifier.  For TCP style socket, this field is ignored.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        sac->sac_assoc_id = sctp_assoc2id(asoc);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Create and initialize an SCTP_PEER_ADDR_CHANGE event.
+ *
+ * Socket Extensions for SCTP - draft-01
+ * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+ *
+ * When a destination address on a multi-homed peer encounters a change
+ * an interface details event is sent.
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_peer_addr_change(
+        const struct sctp_association *asoc,
+        const struct sockaddr_storage *aaddr,
+        int flags, int state, int error, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_paddr_change  *spc;
+        struct sk_buff *skb;
+
+        event = sctp_ulpevent_new(sizeof(struct sctp_paddr_change),
+                                  MSG_NOTIFICATION, gfp);
+        if (!event)
+                goto fail;
+
+        skb = sctp_event2skb(event);
+        spc = (struct sctp_paddr_change *)
+                skb_put(skb, sizeof(struct sctp_paddr_change));
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_type:
+         *
+         *    It should be SCTP_PEER_ADDR_CHANGE.
+         */
+        spc->spc_type = SCTP_PEER_ADDR_CHANGE;
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_length: sizeof (__u32)
+         *
+         * This field is the total length of the notification data, including
+         * the notification header.
+         */
+        spc->spc_length = sizeof(struct sctp_paddr_change);
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_flags: 16 bits (unsigned integer)
+         * Currently unused.
+         */
+        spc->spc_flags = 0;
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_state:  32 bits (signed integer)
+         *
+         * This field holds one of a number of values that communicate the
+         * event that happened to the address.
+         */
+        spc->spc_state = state;
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_error:  32 bits (signed integer)
+         *
+         * If the state was reached due to any error condition (e.g.
+         * ADDRESS_UNREACHABLE) any relevant error information is available in
+         * this field.
+         */
+        spc->spc_error = error;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.1 SCTP_ASSOC_CHANGE
+         *
+         * spc_assoc_id: sizeof (sctp_assoc_t)
+         *
+         * The association id field, holds the identifier for the association.
+         * All notifications for a given association have the same association
+         * identifier.  For TCP style socket, this field is ignored.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        spc->spc_assoc_id = sctp_assoc2id(asoc);
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
+         *
+         * spc_aaddr: sizeof (struct sockaddr_storage)
+         *
+         * The affected address field, holds the remote peer's address that is
+         * encountering the change of state.
+         */
+        memcpy(&spc->spc_aaddr, aaddr, sizeof(struct sockaddr_storage));
+
+        /* Map ipv4 address into v4-mapped-on-v6 address.  */
+        sctp_get_pf_specific(asoc->base.sk->sk_family)->addr_v4map(
+                                        sctp_sk(asoc->base.sk),
+                                        (union sctp_addr *)&spc->spc_aaddr);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Create and initialize an SCTP_REMOTE_ERROR notification.
+ *
+ * Note: This assumes that the chunk->skb->data already points to the
+ * operation error payload.
+ *
+ * Socket Extensions for SCTP - draft-01
+ * 5.3.1.3 SCTP_REMOTE_ERROR
+ *
+ * A remote peer may send an Operational Error message to its peer.
+ * This message indicates a variety of error conditions on an
+ * association. The entire error TLV as it appears on the wire is
+ * included in a SCTP_REMOTE_ERROR event.  Please refer to the SCTP
+ * specification [SCTP] and any extensions for a list of possible
+ * error formats.
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_remote_error(
+        const struct sctp_association *asoc, struct sctp_chunk *chunk,
+        __u16 flags, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_remote_error *sre;
+        struct sk_buff *skb;
+        sctp_errhdr_t *ch;
+        __u16 cause;
+        int elen;
+
+        ch = (sctp_errhdr_t *)(chunk->skb->data);
+        cause = ch->cause;
+        elen = WORD_ROUND(ntohs(ch->length)) - sizeof(sctp_errhdr_t);
+
+        /* Pull off the ERROR header.  */
+        skb_pull(chunk->skb, sizeof(sctp_errhdr_t));
+
+        /* Copy the skb to a new skb with room for us to prepend
+         * notification with.
+         */
+        skb = skb_copy_expand(chunk->skb, sizeof(struct sctp_remote_error),
+                              0, gfp);
+
+        /* Pull off the rest of the cause TLV from the chunk.  */
+        skb_pull(chunk->skb, elen);
+        if (!skb)
+                goto fail;
+
+        /* Embed the event fields inside the cloned skb.  */
+        event = sctp_skb2event(skb);
+        sctp_ulpevent_init(event, MSG_NOTIFICATION);
+
+        sre = (struct sctp_remote_error *)
+                skb_push(skb, sizeof(struct sctp_remote_error));
+
+        /* Trim the buffer to the right length.  */
+        skb_trim(skb, sizeof(struct sctp_remote_error) + elen);
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.3 SCTP_REMOTE_ERROR
+         *
+         * sre_type:
+         *   It should be SCTP_REMOTE_ERROR.
+         */
+        sre->sre_type = SCTP_REMOTE_ERROR;
+
+        /*
+         * Socket Extensions for SCTP
+         * 5.3.1.3 SCTP_REMOTE_ERROR
+         *
+         * sre_flags: 16 bits (unsigned integer)
+         *   Currently unused.
+         */
+        sre->sre_flags = 0;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.3 SCTP_REMOTE_ERROR
+         *
+         * sre_length: sizeof (__u32)
+         *
+         * This field is the total length of the notification data,
+         * including the notification header.
+         */
+        sre->sre_length = skb->len;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.3 SCTP_REMOTE_ERROR
+         *
+         * sre_error: 16 bits (unsigned integer)
+         * This value represents one of the Operational Error causes defined in
+         * the SCTP specification, in network byte order.
+         */
+        sre->sre_error = cause;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.3 SCTP_REMOTE_ERROR
+         *
+         * sre_assoc_id: sizeof (sctp_assoc_t)
+         *
+         * The association id field, holds the identifier for the association.
+         * All notifications for a given association have the same association
+         * identifier.  For TCP style socket, this field is ignored.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        sre->sre_assoc_id = sctp_assoc2id(asoc);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Create and initialize a SCTP_SEND_FAILED notification.
+ *
+ * Socket Extensions for SCTP - draft-01
+ * 5.3.1.4 SCTP_SEND_FAILED
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_send_failed(
+        const struct sctp_association *asoc, struct sctp_chunk *chunk,
+        __u16 flags, __u32 error, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_send_failed *ssf;
+        struct sk_buff *skb;
+
+        /* Pull off any padding. */
+        int len = ntohs(chunk->chunk_hdr->length);
+
+        /* Make skb with more room so we can prepend notification.  */
+        skb = skb_copy_expand(chunk->skb,
+                              sizeof(struct sctp_send_failed), /* headroom */
+                              0,                               /* tailroom */
+                              gfp);
+        if (!skb)
+                goto fail;
+
+        /* Pull off the common chunk header and DATA header.  */
+        skb_pull(skb, sizeof(struct sctp_data_chunk));
+        len -= sizeof(struct sctp_data_chunk);
+
+        /* Embed the event fields inside the cloned skb.  */
+        event = sctp_skb2event(skb);
+        sctp_ulpevent_init(event, MSG_NOTIFICATION);
+
+        ssf = (struct sctp_send_failed *)
+                skb_push(skb, sizeof(struct sctp_send_failed));
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_type:
+         * It should be SCTP_SEND_FAILED.
+         */
+        ssf->ssf_type = SCTP_SEND_FAILED;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_flags: 16 bits (unsigned integer)
+         * The flag value will take one of the following values
+         *
+         * SCTP_DATA_UNSENT - Indicates that the data was never put on
+         *                    the wire.
+         *
+         * SCTP_DATA_SENT   - Indicates that the data was put on the wire.
+         *                    Note that this does not necessarily mean that the
+         *                    data was (or was not) successfully delivered.
+         */
+        ssf->ssf_flags = flags;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_length: sizeof (__u32)
+         * This field is the total length of the notification data, including
+         * the notification header.
+         */
+        ssf->ssf_length = sizeof(struct sctp_send_failed) + len;
+        skb_trim(skb, ssf->ssf_length);
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_error: 16 bits (unsigned integer)
+         * This value represents the reason why the send failed, and if set,
+         * will be a SCTP protocol error code as defined in [SCTP] section
+         * 3.3.10.
+         */
+        ssf->ssf_error = error;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_info: sizeof (struct sctp_sndrcvinfo)
+         * The original send information associated with the undelivered
+         * message.
+         */
+        memcpy(&ssf->ssf_info, &chunk->sinfo, sizeof(struct sctp_sndrcvinfo));
+
+        /* Per TSVWG discussion with Randy. Allow the application to
+         * ressemble a fragmented message.
+         */
+        ssf->ssf_info.sinfo_flags = chunk->chunk_hdr->flags;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.4 SCTP_SEND_FAILED
+         *
+         * ssf_assoc_id: sizeof (sctp_assoc_t)
+         * The association id field, sf_assoc_id, holds the identifier for the
+         * association.  All notifications for a given association have the
+         * same association identifier.  For TCP style socket, this field is
+         * ignored.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        ssf->ssf_assoc_id = sctp_assoc2id(asoc);
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Create and initialize a SCTP_SHUTDOWN_EVENT notification.
+ *
+ * Socket Extensions for SCTP - draft-01
+ * 5.3.1.5 SCTP_SHUTDOWN_EVENT
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_shutdown_event(
+        const struct sctp_association *asoc,
+        __u16 flags, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_shutdown_event *sse;
+        struct sk_buff *skb;
+
+        event = sctp_ulpevent_new(sizeof(struct sctp_shutdown_event),
+                                  MSG_NOTIFICATION, gfp);
+        if (!event)
+                goto fail;
+
+        skb = sctp_event2skb(event);
+        sse = (struct sctp_shutdown_event *)
+                skb_put(skb, sizeof(struct sctp_shutdown_event));
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.5 SCTP_SHUTDOWN_EVENT
+         *
+         * sse_type
+         * It should be SCTP_SHUTDOWN_EVENT
+         */
+        sse->sse_type = SCTP_SHUTDOWN_EVENT;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.5 SCTP_SHUTDOWN_EVENT
+         *
+         * sse_flags: 16 bits (unsigned integer)
+         * Currently unused.
+         */
+        sse->sse_flags = 0;
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.5 SCTP_SHUTDOWN_EVENT
+         *
+         * sse_length: sizeof (__u32)
+         * This field is the total length of the notification data, including
+         * the notification header.
+         */
+        sse->sse_length = sizeof(struct sctp_shutdown_event);
+
+        /* Socket Extensions for SCTP
+         * 5.3.1.5 SCTP_SHUTDOWN_EVENT
+         *
+         * sse_assoc_id: sizeof (sctp_assoc_t)
+         * The association id field, holds the identifier for the association.
+         * All notifications for a given association have the same association
+         * identifier.  For TCP style socket, this field is ignored.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        sse->sse_assoc_id = sctp_assoc2id(asoc);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* Create and initialize a SCTP_ADAPTION_INDICATION notification.
+ *
+ * Socket Extensions for SCTP
+ * 5.3.1.6 SCTP_ADAPTION_INDICATION
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_adaption_indication(
+        const struct sctp_association *asoc, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_adaption_event *sai;
+        struct sk_buff *skb;
+
+        event = sctp_ulpevent_new(sizeof(struct sctp_adaption_event),
+                                  MSG_NOTIFICATION, gfp);
+        if (!event)
+                goto fail;
+
+        skb = sctp_event2skb(event);
+        sai = (struct sctp_adaption_event *)
+                skb_put(skb, sizeof(struct sctp_adaption_event));
+
+        sai->sai_type = SCTP_ADAPTION_INDICATION;
+        sai->sai_flags = 0;
+        sai->sai_length = sizeof(struct sctp_adaption_event);
+        sai->sai_adaption_ind = asoc->peer.adaption_ind;
+        sctp_ulpevent_set_owner(event, asoc);
+        sai->sai_assoc_id = sctp_assoc2id(asoc);
+
+        return event;
+
+fail:
+        return NULL;
+}
+
+/* A message has been received.  Package this message as a notification
+ * to pass it to the upper layers.  Go ahead and calculate the sndrcvinfo
+ * even if filtered out later.
+ *
+ * Socket Extensions for SCTP
+ * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_rcvmsg(struct sctp_association *asoc,
+                                                struct sctp_chunk *chunk,
+                                                int gfp)
+{
+        struct sctp_ulpevent *event = NULL;
+        struct sk_buff *skb;
+        size_t padding, len;
+
+        /* Clone the original skb, sharing the data.  */
+        skb = skb_clone(chunk->skb, gfp);
+        if (!skb)
+                goto fail;
+
+        /* First calculate the padding, so we don't inadvertently
+         * pass up the wrong length to the user.
+         *
+         * RFC 2960 - Section 3.2  Chunk Field Descriptions
+         *
+         * The total length of a chunk(including Type, Length and Value fields)
+         * MUST be a multiple of 4 bytes.  If the length of the chunk is not a
+         * multiple of 4 bytes, the sender MUST pad the chunk with all zero
+         * bytes and this padding is not included in the chunk length field.
+         * The sender should never pad with more than 3 bytes.  The receiver
+         * MUST ignore the padding bytes.
+         */
+        len = ntohs(chunk->chunk_hdr->length);
+        padding = WORD_ROUND(len) - len;
+
+        /* Fixup cloned skb with just this chunks data.  */
+        skb_trim(skb, chunk->chunk_end - padding - skb->data);
+
+        /* Embed the event fields inside the cloned skb.  */
+        event = sctp_skb2event(skb);
+
+        /* Initialize event with flags 0.  */
+        sctp_ulpevent_init(event, 0);
+
+        sctp_ulpevent_receive_data(event, asoc);
+
+        event->stream = ntohs(chunk->subh.data_hdr->stream);
+        event->ssn = ntohs(chunk->subh.data_hdr->ssn);
+        event->ppid = chunk->subh.data_hdr->ppid;
+        if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
+                event->flags |= MSG_UNORDERED;
+                event->cumtsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
+        }
+        event->tsn = ntohl(chunk->subh.data_hdr->tsn);
+        event->msg_flags |= chunk->chunk_hdr->flags;
+        event->iif = sctp_chunk_iif(chunk);
+
+fail:
+        return event;
+}
+
+/* Create a partial delivery related event.
+ *
+ * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
+ *
+ *   When a receiver is engaged in a partial delivery of a
+ *   message this notification will be used to indicate
+ *   various events.
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_pdapi(
+        const struct sctp_association *asoc, __u32 indication, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_pdapi_event *pd;
+        struct sk_buff *skb;
+
+        event = sctp_ulpevent_new(sizeof(struct sctp_pdapi_event),
+                                  MSG_NOTIFICATION, gfp);
+        if (!event)
+                goto fail;
+
+        skb = sctp_event2skb(event);
+        pd = (struct sctp_pdapi_event *)
+                skb_put(skb, sizeof(struct sctp_pdapi_event));
+
+        /* pdapi_type
+         *   It should be SCTP_PARTIAL_DELIVERY_EVENT
+         *
+         * pdapi_flags: 16 bits (unsigned integer)
+         *   Currently unused.
+         */
+        pd->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
+        pd->pdapi_flags = 0;
+
+        /* pdapi_length: 32 bits (unsigned integer)
+         *
+         * This field is the total length of the notification data, including
+         * the notification header.  It will generally be sizeof (struct
+         * sctp_pdapi_event).
+         */
+        pd->pdapi_length = sizeof(struct sctp_pdapi_event);
+
+        /*  pdapi_indication: 32 bits (unsigned integer)
+         *
+         * This field holds the indication being sent to the application.
+         */
+        pd->pdapi_indication = indication;
+
+        /*  pdapi_assoc_id: sizeof (sctp_assoc_t)
+         *
+         * The association id field, holds the identifier for the association.
+         */
+        sctp_ulpevent_set_owner(event, asoc);
+        pd->pdapi_assoc_id = sctp_assoc2id(asoc);
+
+        return event;
+fail:
+        return NULL;
+}
+
+/* Return the notification type, assuming this is a notification
+ * event.
+ */
+__u16 sctp_ulpevent_get_notification_type(const struct sctp_ulpevent *event)
+{
+        union sctp_notification *notification;
+        struct sk_buff *skb;
+
+        skb = sctp_event2skb((struct sctp_ulpevent *)event);
+        notification = (union sctp_notification *) skb->data;
+        return notification->sn_header.sn_type;
+}
+
+/* Copy out the sndrcvinfo into a msghdr.  */
+void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent *event,
+                                   struct msghdr *msghdr)
+{
+        struct sctp_sndrcvinfo sinfo;
+
+        if (sctp_ulpevent_is_notification(event))
+                return;
+
+        /* Sockets API Extensions for SCTP
+         * Section 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
+         *
+         * sinfo_stream: 16 bits (unsigned integer)
+         *
+         * For recvmsg() the SCTP stack places the message's stream number in
+         * this value.
+        */
+        sinfo.sinfo_stream = event->stream;
+        /* sinfo_ssn: 16 bits (unsigned integer)
+         *
+         * For recvmsg() this value contains the stream sequence number that
+         * the remote endpoint placed in the DATA chunk.  For fragmented
+         * messages this is the same number for all deliveries of the message
+         * (if more than one recvmsg() is needed to read the message).
+         */
+        sinfo.sinfo_ssn = event->ssn;
+        /* sinfo_ppid: 32 bits (unsigned integer)
+         *
+         * In recvmsg() this value is
+         * the same information that was passed by the upper layer in the peer
+         * application.  Please note that byte order issues are NOT accounted
+         * for and this information is passed opaquely by the SCTP stack from
+         * one end to the other.
+         */
+        sinfo.sinfo_ppid = event->ppid;
+        /* sinfo_flags: 16 bits (unsigned integer)
+         *
+         * This field may contain any of the following flags and is composed of
+         * a bitwise OR of these values.
+         *
+         * recvmsg() flags:
+         *
+         * MSG_UNORDERED - This flag is present when the message was sent
+         *                 non-ordered.
+         */
+        sinfo.sinfo_flags = event->flags;
+        /* sinfo_tsn: 32 bit (unsigned integer)
+         *
+         * For the receiving side, this field holds a TSN that was 
+         * assigned to one of the SCTP Data Chunks.
+         */
+        sinfo.sinfo_tsn = event->tsn;
+        /* sinfo_cumtsn: 32 bit (unsigned integer)
+         *
+         * This field will hold the current cumulative TSN as
+         * known by the underlying SCTP layer.  Note this field is
+         * ignored when sending and only valid for a receive
+         * operation when sinfo_flags are set to MSG_UNORDERED.
+         */
+        sinfo.sinfo_cumtsn = event->cumtsn;
+        /* sinfo_assoc_id: sizeof (sctp_assoc_t)
+         *
+         * The association handle field, sinfo_assoc_id, holds the identifier
+         * for the association announced in the COMMUNICATION_UP notification.
+         * All notifications for a given association have the same identifier.
+         * Ignored for one-to-one style sockets.
+         */
+        sinfo.sinfo_assoc_id = sctp_assoc2id(event->asoc);
+
+        /* These fields are not used while receiving. */
+        sinfo.sinfo_context = 0;
+        sinfo.sinfo_timetolive = 0;
+
+        put_cmsg(msghdr, IPPROTO_SCTP, SCTP_SNDRCV,
+                 sizeof(struct sctp_sndrcvinfo), (void *)&sinfo);
+}
+
+/* Do accounting for bytes received and hold a reference to the association
+ * for each skb.
+ */
+static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
+                                       struct sctp_association *asoc)
+{
+        struct sk_buff *skb, *frag;
+
+        skb = sctp_event2skb(event);
+        /* Set the owner and charge rwnd for bytes received.  */
+        sctp_ulpevent_set_owner(event, asoc);
+        sctp_assoc_rwnd_decrease(asoc, skb_headlen(skb));
+
+        if (!skb->data_len)
+                return;
+
+        /* Note:  Not clearing the entire event struct as this is just a
+         * fragment of the real event.  However, we still need to do rwnd
+         * accounting.
+         * In general, the skb passed from IP can have only 1 level of
+         * fragments. But we allow multiple levels of fragments. 
+         */
+        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+                sctp_ulpevent_receive_data(sctp_skb2event(frag), asoc);
+        }
+}
+
+/* Do accounting for bytes just read by user and release the references to
+ * the association.
+ */ 
+static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
+{
+        struct sk_buff *skb, *frag;
+
+        /* Current stack structures assume that the rcv buffer is
+         * per socket.   For UDP style sockets this is not true as
+         * multiple associations may be on a single UDP-style socket.
+         * Use the local private area of the skb to track the owning
+         * association.
+         */
+
+        skb = sctp_event2skb(event);
+        sctp_assoc_rwnd_increase(event->asoc, skb_headlen(skb));
+
+        if (!skb->data_len)
+                goto done;
+
+        /* Don't forget the fragments. */
+        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+                /* NOTE:  skb_shinfos are recursive. Although IP returns
+                 * skb's with only 1 level of fragments, SCTP reassembly can
+                 * increase the levels.
+                 */
+                sctp_ulpevent_release_data(sctp_skb2event(frag));
+        }
+
+done:
+        sctp_ulpevent_release_owner(event);
+}
+
+/* Free a ulpevent that has an owner.  It includes releasing the reference
+ * to the owner, updating the rwnd in case of a DATA event and freeing the
+ * skb.
+ * See comments in sctp_stub_rfree().
+ */
+void sctp_ulpevent_free(struct sctp_ulpevent *event)
+{
+        if (sctp_ulpevent_is_notification(event))
+                sctp_ulpevent_release_owner(event);
+        else
+                sctp_ulpevent_release_data(event);
+
+        kfree_skb(sctp_event2skb(event));
+}
+
+/* Purge the skb lists holding ulpevents. */
+void sctp_queue_purge_ulpevents(struct sk_buff_head *list)
+{
+        struct sk_buff *skb;
+        while ((skb = skb_dequeue(list)) != NULL)
+                sctp_ulpevent_free(sctp_skb2event(skb));
+}
diff --git a/net/sctp/ulpqueue.c b/net/sctp/ulpqueue.c
new file mode 100644
index 000000000000..d5dd2cf7ac4a
--- /dev/null
+++ b/net/sctp/ulpqueue.c
@@ -0,0 +1,864 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This abstraction carries sctp events to the ULP (sockets).
+ *
+ * The SCTP reference implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    Jon Grimm             <jgrimm@us.ibm.com>
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Sridhar Samudrala     <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#include <linux/types.h>
+#include <linux/skbuff.h>
+#include <net/sock.h>
+#include <net/sctp/structs.h>
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+/* Forward declarations for internal helpers.  */
+static struct sctp_ulpevent * sctp_ulpq_reasm(struct sctp_ulpq *ulpq,
+                                                struct sctp_ulpevent *);
+static struct sctp_ulpevent * sctp_ulpq_order(struct sctp_ulpq *,
+                                                struct sctp_ulpevent *);
+
+/* 1st Level Abstractions */
+
+/* Initialize a ULP queue from a block of memory.  */
+struct sctp_ulpq *sctp_ulpq_init(struct sctp_ulpq *ulpq,
+                                 struct sctp_association *asoc)
+{
+        memset(ulpq, 0, sizeof(struct sctp_ulpq));
+
+        ulpq->asoc = asoc;
+        skb_queue_head_init(&ulpq->reasm);
+        skb_queue_head_init(&ulpq->lobby);
+        ulpq->pd_mode  = 0;
+        ulpq->malloced = 0;
+
+        return ulpq;
+}
+
+
+/* Flush the reassembly and ordering queues.  */
+static void sctp_ulpq_flush(struct sctp_ulpq *ulpq)
+{
+        struct sk_buff *skb;
+        struct sctp_ulpevent *event;
+
+        while ((skb = __skb_dequeue(&ulpq->lobby)) != NULL) {
+                event = sctp_skb2event(skb);
+                sctp_ulpevent_free(event);
+        }
+
+        while ((skb = __skb_dequeue(&ulpq->reasm)) != NULL) {
+                event = sctp_skb2event(skb);
+                sctp_ulpevent_free(event);
+        }
+
+}
+
+/* Dispose of a ulpqueue.  */
+void sctp_ulpq_free(struct sctp_ulpq *ulpq)
+{
+        sctp_ulpq_flush(ulpq);
+        if (ulpq->malloced)
+                kfree(ulpq);
+}
+
+/* Process an incoming DATA chunk.  */
+int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
+                        int gfp)
+{
+        struct sk_buff_head temp;
+        sctp_data_chunk_t *hdr;
+        struct sctp_ulpevent *event;
+
+        hdr = (sctp_data_chunk_t *) chunk->chunk_hdr;
+
+        /* Create an event from the incoming chunk. */
+        event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);
+        if (!event)
+                return -ENOMEM;
+
+        /* Do reassembly if needed.  */
+        event = sctp_ulpq_reasm(ulpq, event);
+
+        /* Do ordering if needed.  */
+        if ((event) && (event->msg_flags & MSG_EOR)){
+                /* Create a temporary list to collect chunks on.  */
+                skb_queue_head_init(&temp);
+                __skb_queue_tail(&temp, sctp_event2skb(event));
+
+                event = sctp_ulpq_order(ulpq, event);
+        }
+
+        /* Send event to the ULP.  */
+        if (event)
+                sctp_ulpq_tail_event(ulpq, event);
+
+        return 0;
+}
+
+/* Add a new event for propagation to the ULP.  */
+/* Clear the partial delivery mode for this socket.   Note: This
+ * assumes that no association is currently in partial delivery mode.
+ */
+int sctp_clear_pd(struct sock *sk)
+{
+        struct sctp_sock *sp = sctp_sk(sk);
+
+        sp->pd_mode = 0;
+        if (!skb_queue_empty(&sp->pd_lobby)) {
+                struct list_head *list;
+                sctp_skb_list_tail(&sp->pd_lobby, &sk->sk_receive_queue);
+                list = (struct list_head *)&sctp_sk(sk)->pd_lobby;
+                INIT_LIST_HEAD(list);
+                return 1;
+        }
+        return 0;
+}
+
+/* Clear the pd_mode and restart any pending messages waiting for delivery. */
+static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq)
+{
+        ulpq->pd_mode = 0;
+        return sctp_clear_pd(ulpq->asoc->base.sk);
+}
+
+
+
+int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)
+{
+        struct sock *sk = ulpq->asoc->base.sk;
+        struct sk_buff_head *queue;
+        int clear_pd = 0;
+
+        /* If the socket is just going to throw this away, do not
+         * even try to deliver it.
+         */
+        if (sock_flag(sk, SOCK_DEAD) || (sk->sk_shutdown & RCV_SHUTDOWN))
+                goto out_free;
+
+        /* Check if the user wishes to receive this event.  */
+        if (!sctp_ulpevent_is_enabled(event, &sctp_sk(sk)->subscribe))
+                goto out_free;
+
+        /* If we are in partial delivery mode, post to the lobby until
+         * partial delivery is cleared, unless, of course _this_ is
+         * the association the cause of the partial delivery.
+         */
+
+        if (!sctp_sk(sk)->pd_mode) {
+                queue = &sk->sk_receive_queue;
+        } else if (ulpq->pd_mode) {
+                if (event->msg_flags & MSG_NOTIFICATION)
+                        queue = &sctp_sk(sk)->pd_lobby;
+                else {
+                        clear_pd = event->msg_flags & MSG_EOR;
+                        queue = &sk->sk_receive_queue;
+                }
+        } else
+                queue = &sctp_sk(sk)->pd_lobby;
+
+
+        /* If we are harvesting multiple skbs they will be
+         * collected on a list.
+         */
+        if (sctp_event2skb(event)->list)
+                sctp_skb_list_tail(sctp_event2skb(event)->list, queue);
+        else
+                __skb_queue_tail(queue, sctp_event2skb(event));
+
+        /* Did we just complete partial delivery and need to get
+         * rolling again?  Move pending data to the receive
+         * queue.
+         */
+        if (clear_pd)
+                sctp_ulpq_clear_pd(ulpq);
+
+        if (queue == &sk->sk_receive_queue)
+                sk->sk_data_ready(sk, 0);
+        return 1;
+
+out_free:
+        if (sctp_event2skb(event)->list)
+                sctp_queue_purge_ulpevents(sctp_event2skb(event)->list);
+        else
+                sctp_ulpevent_free(event);
+        return 0;
+}
+
+/* 2nd Level Abstractions */
+
+/* Helper function to store chunks that need to be reassembled.  */
+static inline void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq,
+                                         struct sctp_ulpevent *event)
+{
+        struct sk_buff *pos;
+        struct sctp_ulpevent *cevent;
+        __u32 tsn, ctsn;
+
+        tsn = event->tsn;
+
+        /* See if it belongs at the end. */
+        pos = skb_peek_tail(&ulpq->reasm);
+        if (!pos) {
+                __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
+                return;
+        }
+
+        /* Short circuit just dropping it at the end. */
+        cevent = sctp_skb2event(pos);
+        ctsn = cevent->tsn;
+        if (TSN_lt(ctsn, tsn)) {
+                __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
+                return;
+        }
+
+        /* Find the right place in this list. We store them by TSN.  */
+        skb_queue_walk(&ulpq->reasm, pos) {
+                cevent = sctp_skb2event(pos);
+                ctsn = cevent->tsn;
+
+                if (TSN_lt(tsn, ctsn))
+                        break;
+        }
+
+        /* Insert before pos. */
+        __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->reasm);
+
+}
+
+/* Helper function to return an event corresponding to the reassembled
+ * datagram.
+ * This routine creates a re-assembled skb given the first and last skb's
+ * as stored in the reassembly queue. The skb's may be non-linear if the sctp
+ * payload was fragmented on the way and ip had to reassemble them.
+ * We add the rest of skb's to the first skb's fraglist.
+ */
+static struct sctp_ulpevent *sctp_make_reassembled_event(struct sk_buff *f_frag, struct sk_buff *l_frag)
+{
+        struct sk_buff *pos;
+        struct sctp_ulpevent *event;
+        struct sk_buff *pnext, *last;
+        struct sk_buff *list = skb_shinfo(f_frag)->frag_list;
+
+        /* Store the pointer to the 2nd skb */
+        if (f_frag == l_frag)
+                pos = NULL;
+        else
+                pos = f_frag->next;
+
+        /* Get the last skb in the f_frag's frag_list if present. */
+        for (last = list; list; last = list, list = list->next);
+
+        /* Add the list of remaining fragments to the first fragments
+         * frag_list.
+         */
+        if (last)
+                last->next = pos;
+        else
+                skb_shinfo(f_frag)->frag_list = pos;
+
+        /* Remove the first fragment from the reassembly queue.  */
+        __skb_unlink(f_frag, f_frag->list);
+        while (pos) {
+
+                pnext = pos->next;
+
+                /* Update the len and data_len fields of the first fragment. */
+                f_frag->len += pos->len;
+                f_frag->data_len += pos->len;
+
+                /* Remove the fragment from the reassembly queue.  */
+                __skb_unlink(pos, pos->list);
+        
+                /* Break if we have reached the last fragment.  */
+                if (pos == l_frag)
+                        break;
+                pos->next = pnext;
+                pos = pnext;
+        };
+
+        event = sctp_skb2event(f_frag);
+        SCTP_INC_STATS(SCTP_MIB_REASMUSRMSGS);
+
+        return event;
+}
+
+
+/* Helper function to check if an incoming chunk has filled up the last
+ * missing fragment in a SCTP datagram and return the corresponding event.
+ */
+static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq)
+{
+        struct sk_buff *pos;
+        struct sctp_ulpevent *cevent;
+        struct sk_buff *first_frag = NULL;
+        __u32 ctsn, next_tsn;
+        struct sctp_ulpevent *retval = NULL;
+
+        /* Initialized to 0 just to avoid compiler warning message.  Will
+         * never be used with this value. It is referenced only after it
+         * is set when we find the first fragment of a message.
+         */
+        next_tsn = 0;
+
+        /* The chunks are held in the reasm queue sorted by TSN.
+         * Walk through the queue sequentially and look for a sequence of
+         * fragmented chunks that complete a datagram.
+         * 'first_frag' and next_tsn are reset when we find a chunk which
+         * is the first fragment of a datagram. Once these 2 fields are set
+         * we expect to find the remaining middle fragments and the last
+         * fragment in order. If not, first_frag is reset to NULL and we
+         * start the next pass when we find another first fragment.
+         */
+        skb_queue_walk(&ulpq->reasm, pos) {
+                cevent = sctp_skb2event(pos);
+                ctsn = cevent->tsn;
+
+                switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
+                case SCTP_DATA_FIRST_FRAG:
+                        first_frag = pos;
+                        next_tsn = ctsn + 1;
+                        break;
+
+                case SCTP_DATA_MIDDLE_FRAG:
+                        if ((first_frag) && (ctsn == next_tsn))
+                                next_tsn++;
+                        else
+                                first_frag = NULL;
+                        break;
+
+                case SCTP_DATA_LAST_FRAG:
+                        if (first_frag && (ctsn == next_tsn))
+                                goto found;
+                        else
+                                first_frag = NULL;
+                        break;
+                };
+
+        }
+done:
+        return retval;
+found:
+        retval = sctp_make_reassembled_event(first_frag, pos);
+        if (retval)
+                retval->msg_flags |= MSG_EOR;
+        goto done;
+}
+
+/* Retrieve the next set of fragments of a partial message. */
+static inline struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq)
+{
+        struct sk_buff *pos, *last_frag, *first_frag;
+        struct sctp_ulpevent *cevent;
+        __u32 ctsn, next_tsn;
+        int is_last;
+        struct sctp_ulpevent *retval;
+
+        /* The chunks are held in the reasm queue sorted by TSN.
+         * Walk through the queue sequentially and look for the first
+         * sequence of fragmented chunks.
+         */
+
+        if (skb_queue_empty(&ulpq->reasm))
+                return NULL;
+
+        last_frag = first_frag = NULL;
+        retval = NULL;
+        next_tsn = 0;
+        is_last = 0;
+
+        skb_queue_walk(&ulpq->reasm, pos) {
+                cevent = sctp_skb2event(pos);
+                ctsn = cevent->tsn;
+
+                switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
+                case SCTP_DATA_MIDDLE_FRAG:
+                        if (!first_frag) {
+                                first_frag = pos;
+                                next_tsn = ctsn + 1;
+                                last_frag = pos;
+                        } else if (next_tsn == ctsn)
+                                next_tsn++;
+                        else
+                                goto done;
+                        break;
+                case SCTP_DATA_LAST_FRAG:
+                        if (!first_frag)
+                                first_frag = pos;
+                        else if (ctsn != next_tsn)
+                                goto done;
+                        last_frag = pos;
+                        is_last = 1;
+                        goto done;
+                default:
+                        return NULL;
+                };
+        }
+
+        /* We have the reassembled event. There is no need to look
+         * further.
+         */
+done:
+        retval = sctp_make_reassembled_event(first_frag, last_frag);
+        if (retval && is_last)
+                retval->msg_flags |= MSG_EOR;
+
+        return retval;
+}
+
+
+/* Helper function to reassemble chunks.  Hold chunks on the reasm queue that
+ * need reassembling.
+ */
+static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq,
+                                                struct sctp_ulpevent *event)
+{
+        struct sctp_ulpevent *retval = NULL;
+
+        /* Check if this is part of a fragmented message.  */
+        if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) {
+                event->msg_flags |= MSG_EOR;
+                return event;
+        }
+
+        sctp_ulpq_store_reasm(ulpq, event);
+        if (!ulpq->pd_mode)
+                retval = sctp_ulpq_retrieve_reassembled(ulpq);
+        else {
+                __u32 ctsn, ctsnap;
+
+                /* Do not even bother unless this is the next tsn to
+                 * be delivered.
+                 */
+                ctsn = event->tsn;
+                ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map);
+                if (TSN_lte(ctsn, ctsnap))
+                        retval = sctp_ulpq_retrieve_partial(ulpq);
+        }
+
+        return retval;
+}
+
+/* Retrieve the first part (sequential fragments) for partial delivery.  */
+static inline struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq)
+{
+        struct sk_buff *pos, *last_frag, *first_frag;
+        struct sctp_ulpevent *cevent;
+        __u32 ctsn, next_tsn;
+        struct sctp_ulpevent *retval;
+
+        /* The chunks are held in the reasm queue sorted by TSN.
+         * Walk through the queue sequentially and look for a sequence of
+         * fragmented chunks that start a datagram.
+         */
+
+        if (skb_queue_empty(&ulpq->reasm))
+                return NULL;
+
+        last_frag = first_frag = NULL;
+        retval = NULL;
+        next_tsn = 0;
+
+        skb_queue_walk(&ulpq->reasm, pos) {
+                cevent = sctp_skb2event(pos);
+                ctsn = cevent->tsn;
+
+                switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
+                case SCTP_DATA_FIRST_FRAG:
+                        if (!first_frag) {
+                                first_frag = pos;
+                                next_tsn = ctsn + 1;
+                                last_frag = pos;
+                        } else
+                                goto done;
+                        break;
+
+                case SCTP_DATA_MIDDLE_FRAG:
+                        if (!first_frag)
+                                return NULL;
+                        if (ctsn == next_tsn) {
+                                next_tsn++;
+                                last_frag = pos;
+                        } else
+                                goto done;
+                        break;
+                default:
+                        return NULL;
+                };
+        }
+
+        /* We have the reassembled event. There is no need to look
+         * further.
+         */
+done:
+        retval = sctp_make_reassembled_event(first_frag, last_frag);
+        return retval;
+}
+
+/* Helper function to gather skbs that have possibly become
+ * ordered by an an incoming chunk.
+ */
+static inline void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq,
+                                              struct sctp_ulpevent *event)
+{
+        struct sk_buff *pos, *tmp;
+        struct sctp_ulpevent *cevent;
+        struct sctp_stream *in;
+        __u16 sid, csid;
+        __u16 ssn, cssn;
+
+        sid = event->stream;
+        ssn = event->ssn;
+        in  = &ulpq->asoc->ssnmap->in;
+
+        /* We are holding the chunks by stream, by SSN.  */
+        sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
+                cevent = (struct sctp_ulpevent *) pos->cb;
+                csid = cevent->stream;
+                cssn = cevent->ssn;
+
+                /* Have we gone too far?  */
+                if (csid > sid)
+                        break;
+
+                /* Have we not gone far enough?  */
+                if (csid < sid)
+                        continue;
+
+                if (cssn != sctp_ssn_peek(in, sid))
+                        break;
+
+                /* Found it, so mark in the ssnmap. */
+                sctp_ssn_next(in, sid);
+
+                __skb_unlink(pos, pos->list);
+
+                /* Attach all gathered skbs to the event.  */
+                __skb_queue_tail(sctp_event2skb(event)->list, pos);
+        }
+}
+
+/* Helper function to store chunks needing ordering.  */
+static inline void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq,
+                                           struct sctp_ulpevent *event)
+{
+        struct sk_buff *pos;
+        struct sctp_ulpevent *cevent;
+        __u16 sid, csid;
+        __u16 ssn, cssn;
+
+        pos = skb_peek_tail(&ulpq->lobby);
+        if (!pos) {
+                __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
+                return;
+        }
+
+        sid = event->stream;
+        ssn = event->ssn;
+        
+        cevent = (struct sctp_ulpevent *) pos->cb;
+        csid = cevent->stream;
+        cssn = cevent->ssn;
+        if (sid > csid) {
+                __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
+                return;
+        }
+
+        if ((sid == csid) && SSN_lt(cssn, ssn)) {
+                __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
+                return;
+        }
+
+        /* Find the right place in this list.  We store them by
+         * stream ID and then by SSN.
+         */
+        skb_queue_walk(&ulpq->lobby, pos) {
+                cevent = (struct sctp_ulpevent *) pos->cb;
+                csid = cevent->stream;
+                cssn = cevent->ssn;
+
+                if (csid > sid)
+                        break;
+                if (csid == sid && SSN_lt(ssn, cssn))
+                        break;
+        }
+
+
+        /* Insert before pos. */
+        __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->lobby);
+
+}
+
+static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq,
+                                                struct sctp_ulpevent *event)
+{
+        __u16 sid, ssn;
+        struct sctp_stream *in;
+
+        /* Check if this message needs ordering.  */
+        if (SCTP_DATA_UNORDERED & event->msg_flags)
+                return event;
+
+        /* Note: The stream ID must be verified before this routine.  */
+        sid = event->stream;
+        ssn = event->ssn;
+        in  = &ulpq->asoc->ssnmap->in;
+
+        /* Is this the expected SSN for this stream ID?  */
+        if (ssn != sctp_ssn_peek(in, sid)) {
+                /* We've received something out of order, so find where it
+                 * needs to be placed.  We order by stream and then by SSN.
+                 */
+                sctp_ulpq_store_ordered(ulpq, event);
+                return NULL;
+        }
+
+        /* Mark that the next chunk has been found.  */
+        sctp_ssn_next(in, sid);
+
+        /* Go find any other chunks that were waiting for
+         * ordering.
+         */
+        sctp_ulpq_retrieve_ordered(ulpq, event);
+
+        return event;
+}
+
+/* Helper function to gather skbs that have possibly become
+ * ordered by forward tsn skipping their dependencies.
+ */
+static inline void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq)
+{
+        struct sk_buff *pos, *tmp;
+        struct sctp_ulpevent *cevent;
+        struct sctp_ulpevent *event = NULL;
+        struct sctp_stream *in;
+        struct sk_buff_head temp;
+        __u16 csid, cssn;
+
+        in  = &ulpq->asoc->ssnmap->in;
+
+        /* We are holding the chunks by stream, by SSN.  */
+        sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
+                cevent = (struct sctp_ulpevent *) pos->cb;
+                csid = cevent->stream;
+                cssn = cevent->ssn;
+
+                if (cssn != sctp_ssn_peek(in, csid))
+                        break;
+
+                /* Found it, so mark in the ssnmap. */         
+                sctp_ssn_next(in, csid);
+
+                __skb_unlink(pos, pos->list);
+                if (!event) {                                           
+                        /* Create a temporary list to collect chunks on.  */
+                        event = sctp_skb2event(pos);
+                        skb_queue_head_init(&temp);
+                        __skb_queue_tail(&temp, sctp_event2skb(event));
+                } else {
+                        /* Attach all gathered skbs to the event.  */
+                        __skb_queue_tail(sctp_event2skb(event)->list, pos);
+                }
+        }
+
+        /* Send event to the ULP.  */
+        if (event)
+                sctp_ulpq_tail_event(ulpq, event);
+}
+
+/* Skip over an SSN. */
+void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn)
+{
+        struct sctp_stream *in;
+
+        /* Note: The stream ID must be verified before this routine.  */
+        in  = &ulpq->asoc->ssnmap->in;
+
+        /* Is this an old SSN?  If so ignore. */
+        if (SSN_lt(ssn, sctp_ssn_peek(in, sid)))
+                return;
+
+        /* Mark that we are no longer expecting this SSN or lower. */
+        sctp_ssn_skip(in, sid, ssn);
+
+        /* Go find any other chunks that were waiting for
+         * ordering and deliver them if needed. 
+         */
+        sctp_ulpq_reap_ordered(ulpq);
+        return;
+}
+
+/* Renege 'needed' bytes from the ordering queue. */
+static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed)
+{
+        __u16 freed = 0;
+        __u32 tsn;
+        struct sk_buff *skb;
+        struct sctp_ulpevent *event;
+        struct sctp_tsnmap *tsnmap;
+
+        tsnmap = &ulpq->asoc->peer.tsn_map;
+
+        while ((skb = __skb_dequeue_tail(&ulpq->lobby)) != NULL) {
+                freed += skb_headlen(skb);
+                event = sctp_skb2event(skb);
+                tsn = event->tsn;
+
+                sctp_ulpevent_free(event);
+                sctp_tsnmap_renege(tsnmap, tsn);
+                if (freed >= needed)
+                        return freed;
+        }
+
+        return freed;
+}
+
+/* Renege 'needed' bytes from the reassembly queue. */
+static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed)
+{
+        __u16 freed = 0;
+        __u32 tsn;
+        struct sk_buff *skb;
+        struct sctp_ulpevent *event;
+        struct sctp_tsnmap *tsnmap;
+
+        tsnmap = &ulpq->asoc->peer.tsn_map;
+
+        /* Walk backwards through the list, reneges the newest tsns. */
+        while ((skb = __skb_dequeue_tail(&ulpq->reasm)) != NULL) {
+                freed += skb_headlen(skb);
+                event = sctp_skb2event(skb);
+                tsn = event->tsn;
+
+                sctp_ulpevent_free(event);
+                sctp_tsnmap_renege(tsnmap, tsn);
+                if (freed >= needed)
+                        return freed;
+        }
+
+        return freed;
+}
+
+/* Partial deliver the first message as there is pressure on rwnd. */
+void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq,
+                                struct sctp_chunk *chunk, int gfp)
+{
+        struct sctp_ulpevent *event;
+        struct sctp_association *asoc;
+
+        asoc = ulpq->asoc;
+
+        /* Are we already in partial delivery mode?  */
+        if (!sctp_sk(asoc->base.sk)->pd_mode) {
+
+                /* Is partial delivery possible?  */
+                event = sctp_ulpq_retrieve_first(ulpq);
+                /* Send event to the ULP.   */
+                if (event) {
+                        sctp_ulpq_tail_event(ulpq, event);
+                        sctp_sk(asoc->base.sk)->pd_mode = 1;
+                        ulpq->pd_mode = 1;
+                        return;
+                }
+        }
+}
+
+/* Renege some packets to make room for an incoming chunk.  */
+void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
+                      int gfp)
+{
+        struct sctp_association *asoc;
+        __u16 needed, freed;
+
+        asoc = ulpq->asoc;
+
+        if (chunk) {
+                needed = ntohs(chunk->chunk_hdr->length);
+                needed -= sizeof(sctp_data_chunk_t);
+        } else 
+                needed = SCTP_DEFAULT_MAXWINDOW;
+
+        freed = 0;
+
+        if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) {
+                freed = sctp_ulpq_renege_order(ulpq, needed);
+                if (freed < needed) {
+                        freed += sctp_ulpq_renege_frags(ulpq, needed - freed);
+                }
+        }
+        /* If able to free enough room, accept this chunk. */
+        if (chunk && (freed >= needed)) {
+                __u32 tsn;
+                tsn = ntohl(chunk->subh.data_hdr->tsn);
+                sctp_tsnmap_mark(&asoc->peer.tsn_map, tsn);
+                sctp_ulpq_tail_data(ulpq, chunk, gfp);
+                
+                sctp_ulpq_partial_delivery(ulpq, chunk, gfp);
+        }
+
+        return;
+}
+
+
+
+/* Notify the application if an association is aborted and in
+ * partial delivery mode.  Send up any pending received messages.
+ */
+void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, int gfp)
+{
+        struct sctp_ulpevent *ev = NULL;
+        struct sock *sk;
+
+        if (!ulpq->pd_mode)
+                return;
+
+        sk = ulpq->asoc->base.sk;
+        if (sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT,
+                                       &sctp_sk(sk)->subscribe))
+                ev = sctp_ulpevent_make_pdapi(ulpq->asoc,
+                                              SCTP_PARTIAL_DELIVERY_ABORTED,
+                                              gfp);
+        if (ev)
+                __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev));
+
+        /* If there is data waiting, send it up the socket now. */
+        if (sctp_ulpq_clear_pd(ulpq) || ev)
+                sk->sk_data_ready(sk, 0);
+}