1 /* SCTP kernel implementation
2 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
6 * This file is part of the SCTP kernel implementation
8 * These functions work with the state functions in sctp_sm_statefuns.c
9 * to implement that state operations. These functions implement the
10 * steps which require modifying existing data structures.
12 * This SCTP implementation is free software;
13 * you can redistribute it and/or modify it under the terms of
14 * the GNU General Public License as published by
15 * the Free Software Foundation; either version 2, or (at your option)
18 * This SCTP implementation is distributed in the hope that it
19 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
20 * ************************
21 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
22 * See the GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with GNU CC; see the file COPYING. If not, write to
26 * the Free Software Foundation, 59 Temple Place - Suite 330,
27 * Boston, MA 02111-1307, USA.
29 * Please send any bug reports or fixes you make to the
31 * lksctp developers <lksctp-developers@lists.sourceforge.net>
33 * Or submit a bug report through the following website:
34 * http://www.sf.net/projects/lksctp
36 * Written or modified by:
37 * La Monte H.P. Yarroll <piggy@acm.org>
38 * Karl Knutson <karl@athena.chicago.il.us>
39 * Jon Grimm <jgrimm@austin.ibm.com>
40 * Hui Huang <hui.huang@nokia.com>
41 * Dajiang Zhang <dajiang.zhang@nokia.com>
42 * Daisy Chang <daisyc@us.ibm.com>
43 * Sridhar Samudrala <sri@us.ibm.com>
44 * Ardelle Fan <ardelle.fan@intel.com>
46 * Any bugs reported given to us we will try to fix... any fixes shared will
47 * be incorporated into the next SCTP release.
50 #include <linux/skbuff.h>
51 #include <linux/types.h>
52 #include <linux/socket.h>
55 #include <net/sctp/sctp.h>
56 #include <net/sctp/sm.h>
58 static int sctp_cmd_interpreter(sctp_event_t event_type,
59 sctp_subtype_t subtype,
61 struct sctp_endpoint *ep,
62 struct sctp_association *asoc,
64 sctp_disposition_t status,
65 sctp_cmd_seq_t *commands,
67 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
69 struct sctp_endpoint *ep,
70 struct sctp_association *asoc,
72 sctp_disposition_t status,
73 sctp_cmd_seq_t *commands,
76 /********************************************************************
78 ********************************************************************/
80 /* A helper function for delayed processing of INET ECN CE bit. */
81 static void sctp_do_ecn_ce_work(struct sctp_association *asoc,
84 /* Save the TSN away for comparison when we receive CWR */
86 asoc->last_ecne_tsn = lowest_tsn;
90 /* Helper function for delayed processing of SCTP ECNE chunk. */
91 /* RFC 2960 Appendix A
93 * RFC 2481 details a specific bit for a sender to send in
94 * the header of its next outbound TCP segment to indicate to
95 * its peer that it has reduced its congestion window. This
96 * is termed the CWR bit. For SCTP the same indication is made
97 * by including the CWR chunk. This chunk contains one data
98 * element, i.e. the TSN number that was sent in the ECNE chunk.
99 * This element represents the lowest TSN number in the datagram
100 * that was originally marked with the CE bit.
102 static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
104 struct sctp_chunk *chunk)
106 struct sctp_chunk *repl;
108 /* Our previously transmitted packet ran into some congestion
109 * so we should take action by reducing cwnd and ssthresh
110 * and then ACK our peer that we we've done so by
114 /* First, try to determine if we want to actually lower
115 * our cwnd variables. Only lower them if the ECNE looks more
116 * recent than the last response.
118 if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
119 struct sctp_transport *transport;
121 /* Find which transport's congestion variables
122 * need to be adjusted.
124 transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
126 /* Update the congestion variables. */
128 sctp_transport_lower_cwnd(transport,
129 SCTP_LOWER_CWND_ECNE);
130 asoc->last_cwr_tsn = lowest_tsn;
133 /* Always try to quiet the other end. In case of lost CWR,
134 * resend last_cwr_tsn.
136 repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
138 /* If we run out of memory, it will look like a lost CWR. We'll
139 * get back in sync eventually.
144 /* Helper function to do delayed processing of ECN CWR chunk. */
145 static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
148 /* Turn off ECNE getting auto-prepended to every outgoing
154 /* Generate SACK if necessary. We call this at the end of a packet. */
155 static int sctp_gen_sack(struct sctp_association *asoc, int force,
156 sctp_cmd_seq_t *commands)
158 __u32 ctsn, max_tsn_seen;
159 struct sctp_chunk *sack;
160 struct sctp_transport *trans = asoc->peer.last_data_from;
164 (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) ||
165 (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE)))
166 asoc->peer.sack_needed = 1;
168 ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
169 max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
171 /* From 12.2 Parameters necessary per association (i.e. the TCB):
173 * Ack State : This flag indicates if the next received packet
174 * : is to be responded to with a SACK. ...
175 * : When DATA chunks are out of order, SACK's
176 * : are not delayed (see Section 6).
178 * [This is actually not mentioned in Section 6, but we
179 * implement it here anyway. --piggy]
181 if (max_tsn_seen != ctsn)
182 asoc->peer.sack_needed = 1;
184 /* From 6.2 Acknowledgement on Reception of DATA Chunks:
186 * Section 4.2 of [RFC2581] SHOULD be followed. Specifically,
187 * an acknowledgement SHOULD be generated for at least every
188 * second packet (not every second DATA chunk) received, and
189 * SHOULD be generated within 200 ms of the arrival of any
190 * unacknowledged DATA chunk. ...
192 if (!asoc->peer.sack_needed) {
193 /* We will need a SACK for the next packet. */
194 asoc->peer.sack_needed = 1;
196 /* Set the SACK delay timeout based on the
197 * SACK delay for the last transport
198 * data was received from, or the default
199 * for the association.
202 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
205 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
208 /* Restart the SACK timer. */
209 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
210 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
212 if (asoc->a_rwnd > asoc->rwnd)
213 asoc->a_rwnd = asoc->rwnd;
214 sack = sctp_make_sack(asoc);
218 asoc->peer.sack_needed = 0;
220 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
222 /* Stop the SACK timer. */
223 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
224 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
233 /* When the T3-RTX timer expires, it calls this function to create the
234 * relevant state machine event.
236 void sctp_generate_t3_rtx_event(unsigned long peer)
239 struct sctp_transport *transport = (struct sctp_transport *) peer;
240 struct sctp_association *asoc = transport->asoc;
242 /* Check whether a task is in the sock. */
244 sctp_bh_lock_sock(asoc->base.sk);
245 if (sock_owned_by_user(asoc->base.sk)) {
246 SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
248 /* Try again later. */
249 if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
250 sctp_transport_hold(transport);
254 /* Is this transport really dead and just waiting around for
255 * the timer to let go of the reference?
260 /* Run through the state machine. */
261 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
262 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
265 transport, GFP_ATOMIC);
268 asoc->base.sk->sk_err = -error;
271 sctp_bh_unlock_sock(asoc->base.sk);
272 sctp_transport_put(transport);
275 /* This is a sa interface for producing timeout events. It works
276 * for timeouts which use the association as their parameter.
278 static void sctp_generate_timeout_event(struct sctp_association *asoc,
279 sctp_event_timeout_t timeout_type)
283 sctp_bh_lock_sock(asoc->base.sk);
284 if (sock_owned_by_user(asoc->base.sk)) {
285 SCTP_DEBUG_PRINTK("%s:Sock is busy: timer %d\n",
289 /* Try again later. */
290 if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
291 sctp_association_hold(asoc);
295 /* Is this association really dead and just waiting around for
296 * the timer to let go of the reference?
301 /* Run through the state machine. */
302 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
303 SCTP_ST_TIMEOUT(timeout_type),
304 asoc->state, asoc->ep, asoc,
305 (void *)timeout_type, GFP_ATOMIC);
308 asoc->base.sk->sk_err = -error;
311 sctp_bh_unlock_sock(asoc->base.sk);
312 sctp_association_put(asoc);
315 static void sctp_generate_t1_cookie_event(unsigned long data)
317 struct sctp_association *asoc = (struct sctp_association *) data;
318 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
321 static void sctp_generate_t1_init_event(unsigned long data)
323 struct sctp_association *asoc = (struct sctp_association *) data;
324 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
327 static void sctp_generate_t2_shutdown_event(unsigned long data)
329 struct sctp_association *asoc = (struct sctp_association *) data;
330 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
333 static void sctp_generate_t4_rto_event(unsigned long data)
335 struct sctp_association *asoc = (struct sctp_association *) data;
336 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
339 static void sctp_generate_t5_shutdown_guard_event(unsigned long data)
341 struct sctp_association *asoc = (struct sctp_association *)data;
342 sctp_generate_timeout_event(asoc,
343 SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
345 } /* sctp_generate_t5_shutdown_guard_event() */
347 static void sctp_generate_autoclose_event(unsigned long data)
349 struct sctp_association *asoc = (struct sctp_association *) data;
350 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
353 /* Generate a heart beat event. If the sock is busy, reschedule. Make
354 * sure that the transport is still valid.
356 void sctp_generate_heartbeat_event(unsigned long data)
359 struct sctp_transport *transport = (struct sctp_transport *) data;
360 struct sctp_association *asoc = transport->asoc;
362 sctp_bh_lock_sock(asoc->base.sk);
363 if (sock_owned_by_user(asoc->base.sk)) {
364 SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
366 /* Try again later. */
367 if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
368 sctp_transport_hold(transport);
372 /* Is this structure just waiting around for us to actually
378 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
379 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
380 asoc->state, asoc->ep, asoc,
381 transport, GFP_ATOMIC);
384 asoc->base.sk->sk_err = -error;
387 sctp_bh_unlock_sock(asoc->base.sk);
388 sctp_transport_put(transport);
391 /* Inject a SACK Timeout event into the state machine. */
392 static void sctp_generate_sack_event(unsigned long data)
394 struct sctp_association *asoc = (struct sctp_association *) data;
395 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
398 sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
400 sctp_generate_t1_cookie_event,
401 sctp_generate_t1_init_event,
402 sctp_generate_t2_shutdown_event,
404 sctp_generate_t4_rto_event,
405 sctp_generate_t5_shutdown_guard_event,
407 sctp_generate_sack_event,
408 sctp_generate_autoclose_event,
412 /* RFC 2960 8.2 Path Failure Detection
414 * When its peer endpoint is multi-homed, an endpoint should keep a
415 * error counter for each of the destination transport addresses of the
418 * Each time the T3-rtx timer expires on any address, or when a
419 * HEARTBEAT sent to an idle address is not acknowledged within a RTO,
420 * the error counter of that destination address will be incremented.
421 * When the value in the error counter exceeds the protocol parameter
422 * 'Path.Max.Retrans' of that destination address, the endpoint should
423 * mark the destination transport address as inactive, and a
424 * notification SHOULD be sent to the upper layer.
427 static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
428 struct sctp_transport *transport)
430 /* The check for association's overall error counter exceeding the
431 * threshold is done in the state function.
433 /* When probing UNCONFIRMED addresses, the association overall
434 * error count is NOT incremented
436 if (transport->state != SCTP_UNCONFIRMED)
437 asoc->overall_error_count++;
439 if (transport->state != SCTP_INACTIVE &&
440 (transport->error_count++ >= transport->pathmaxrxt)) {
441 SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p",
442 " transport IP: port:%d failed.\n",
444 (&transport->ipaddr),
445 ntohs(transport->ipaddr.v4.sin_port));
446 sctp_assoc_control_transport(asoc, transport,
448 SCTP_FAILED_THRESHOLD);
451 /* E2) For the destination address for which the timer
452 * expires, set RTO <- RTO * 2 ("back off the timer"). The
453 * maximum value discussed in rule C7 above (RTO.max) may be
454 * used to provide an upper bound to this doubling operation.
456 transport->last_rto = transport->rto;
457 transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
460 /* Worker routine to handle INIT command failure. */
461 static void sctp_cmd_init_failed(sctp_cmd_seq_t *commands,
462 struct sctp_association *asoc,
465 struct sctp_ulpevent *event;
467 event = sctp_ulpevent_make_assoc_change(asoc,0, SCTP_CANT_STR_ASSOC,
468 (__u16)error, 0, 0, NULL,
472 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
473 SCTP_ULPEVENT(event));
475 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
476 SCTP_STATE(SCTP_STATE_CLOSED));
478 /* SEND_FAILED sent later when cleaning up the association. */
479 asoc->outqueue.error = error;
480 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
483 /* Worker routine to handle SCTP_CMD_ASSOC_FAILED. */
484 static void sctp_cmd_assoc_failed(sctp_cmd_seq_t *commands,
485 struct sctp_association *asoc,
486 sctp_event_t event_type,
487 sctp_subtype_t subtype,
488 struct sctp_chunk *chunk,
491 struct sctp_ulpevent *event;
493 /* Cancel any partial delivery in progress. */
494 sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
496 if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)
497 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
498 (__u16)error, 0, 0, chunk,
501 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
502 (__u16)error, 0, 0, NULL,
505 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
506 SCTP_ULPEVENT(event));
508 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
509 SCTP_STATE(SCTP_STATE_CLOSED));
511 /* SEND_FAILED sent later when cleaning up the association. */
512 asoc->outqueue.error = error;
513 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
516 /* Process an init chunk (may be real INIT/INIT-ACK or an embedded INIT
517 * inside the cookie. In reality, this is only used for INIT-ACK processing
518 * since all other cases use "temporary" associations and can do all
519 * their work in statefuns directly.
521 static int sctp_cmd_process_init(sctp_cmd_seq_t *commands,
522 struct sctp_association *asoc,
523 struct sctp_chunk *chunk,
524 sctp_init_chunk_t *peer_init,
529 /* We only process the init as a sideeffect in a single
530 * case. This is when we process the INIT-ACK. If we
531 * fail during INIT processing (due to malloc problems),
532 * just return the error and stop processing the stack.
534 if (!sctp_process_init(asoc, chunk->chunk_hdr->type,
535 sctp_source(chunk), peer_init, gfp))
543 /* Helper function to break out starting up of heartbeat timers. */
544 static void sctp_cmd_hb_timers_start(sctp_cmd_seq_t *cmds,
545 struct sctp_association *asoc)
547 struct sctp_transport *t;
549 /* Start a heartbeat timer for each transport on the association.
550 * hold a reference on the transport to make sure none of
551 * the needed data structures go away.
553 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
555 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
556 sctp_transport_hold(t);
560 static void sctp_cmd_hb_timers_stop(sctp_cmd_seq_t *cmds,
561 struct sctp_association *asoc)
563 struct sctp_transport *t;
565 /* Stop all heartbeat timers. */
567 list_for_each_entry(t, &asoc->peer.transport_addr_list,
569 if (del_timer(&t->hb_timer))
570 sctp_transport_put(t);
574 /* Helper function to stop any pending T3-RTX timers */
575 static void sctp_cmd_t3_rtx_timers_stop(sctp_cmd_seq_t *cmds,
576 struct sctp_association *asoc)
578 struct sctp_transport *t;
580 list_for_each_entry(t, &asoc->peer.transport_addr_list,
582 if (timer_pending(&t->T3_rtx_timer) &&
583 del_timer(&t->T3_rtx_timer)) {
584 sctp_transport_put(t);
590 /* Helper function to update the heartbeat timer. */
591 static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
592 struct sctp_association *asoc,
593 struct sctp_transport *t)
595 /* Update the heartbeat timer. */
596 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
597 sctp_transport_hold(t);
600 /* Helper function to handle the reception of an HEARTBEAT ACK. */
601 static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
602 struct sctp_association *asoc,
603 struct sctp_transport *t,
604 struct sctp_chunk *chunk)
606 sctp_sender_hb_info_t *hbinfo;
608 /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
609 * HEARTBEAT should clear the error counter of the destination
610 * transport address to which the HEARTBEAT was sent.
611 * The association's overall error count is also cleared.
614 t->asoc->overall_error_count = 0;
616 /* Mark the destination transport address as active if it is not so
619 if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED))
620 sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
621 SCTP_HEARTBEAT_SUCCESS);
623 /* The receiver of the HEARTBEAT ACK should also perform an
624 * RTT measurement for that destination transport address
625 * using the time value carried in the HEARTBEAT ACK chunk.
626 * If the transport's rto_pending variable has been cleared,
627 * it was most likely due to a retransmit. However, we want
628 * to re-enable it to properly update the rto.
630 if (t->rto_pending == 0)
633 hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
634 sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
636 /* Update the heartbeat timer. */
637 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
638 sctp_transport_hold(t);
641 /* Helper function to do a transport reset at the expiry of the hearbeat
644 static void sctp_cmd_transport_reset(sctp_cmd_seq_t *cmds,
645 struct sctp_association *asoc,
646 struct sctp_transport *t)
648 sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
650 /* Mark one strike against a transport. */
651 sctp_do_8_2_transport_strike(asoc, t);
654 /* Helper function to process the process SACK command. */
655 static int sctp_cmd_process_sack(sctp_cmd_seq_t *cmds,
656 struct sctp_association *asoc,
657 struct sctp_sackhdr *sackh)
661 if (sctp_outq_sack(&asoc->outqueue, sackh)) {
662 /* There are no more TSNs awaiting SACK. */
663 err = sctp_do_sm(SCTP_EVENT_T_OTHER,
664 SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
665 asoc->state, asoc->ep, asoc, NULL,
668 /* Windows may have opened, so we need
669 * to check if we have DATA to transmit
671 err = sctp_outq_flush(&asoc->outqueue, 0);
677 /* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
678 * the transport for a shutdown chunk.
680 static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
681 struct sctp_association *asoc,
682 struct sctp_chunk *chunk)
684 struct sctp_transport *t;
686 t = sctp_assoc_choose_shutdown_transport(asoc);
687 asoc->shutdown_last_sent_to = t;
688 asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
689 chunk->transport = t;
692 /* Helper function to change the state of an association. */
693 static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds,
694 struct sctp_association *asoc,
697 struct sock *sk = asoc->base.sk;
701 SCTP_DEBUG_PRINTK("sctp_cmd_new_state: asoc %p[%s]\n",
702 asoc, sctp_state_tbl[state]);
704 if (sctp_style(sk, TCP)) {
705 /* Change the sk->sk_state of a TCP-style socket that has
706 * sucessfully completed a connect() call.
708 if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
709 sk->sk_state = SCTP_SS_ESTABLISHED;
711 /* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
712 if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
713 sctp_sstate(sk, ESTABLISHED))
714 sk->sk_shutdown |= RCV_SHUTDOWN;
717 if (sctp_state(asoc, COOKIE_WAIT)) {
718 /* Reset init timeouts since they may have been
719 * increased due to timer expirations.
721 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
723 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
727 if (sctp_state(asoc, ESTABLISHED) ||
728 sctp_state(asoc, CLOSED) ||
729 sctp_state(asoc, SHUTDOWN_RECEIVED)) {
730 /* Wake up any processes waiting in the asoc's wait queue in
731 * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
733 if (waitqueue_active(&asoc->wait))
734 wake_up_interruptible(&asoc->wait);
736 /* Wake up any processes waiting in the sk's sleep queue of
737 * a TCP-style or UDP-style peeled-off socket in
738 * sctp_wait_for_accept() or sctp_wait_for_packet().
739 * For a UDP-style socket, the waiters are woken up by the
742 if (!sctp_style(sk, UDP))
743 sk->sk_state_change(sk);
747 /* Helper function to delete an association. */
748 static void sctp_cmd_delete_tcb(sctp_cmd_seq_t *cmds,
749 struct sctp_association *asoc)
751 struct sock *sk = asoc->base.sk;
753 /* If it is a non-temporary association belonging to a TCP-style
754 * listening socket that is not closed, do not free it so that accept()
755 * can pick it up later.
757 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
758 (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
761 sctp_unhash_established(asoc);
762 sctp_association_free(asoc);
766 * ADDIP Section 4.1 ASCONF Chunk Procedures
767 * A4) Start a T-4 RTO timer, using the RTO value of the selected
768 * destination address (we use active path instead of primary path just
769 * because primary path may be inactive.
771 static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
772 struct sctp_association *asoc,
773 struct sctp_chunk *chunk)
775 struct sctp_transport *t;
777 t = asoc->peer.active_path;
778 asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
779 chunk->transport = t;
782 /* Process an incoming Operation Error Chunk. */
783 static void sctp_cmd_process_operr(sctp_cmd_seq_t *cmds,
784 struct sctp_association *asoc,
785 struct sctp_chunk *chunk)
787 struct sctp_operr_chunk *operr_chunk;
788 struct sctp_errhdr *err_hdr;
790 operr_chunk = (struct sctp_operr_chunk *)chunk->chunk_hdr;
791 err_hdr = &operr_chunk->err_hdr;
793 switch (err_hdr->cause) {
794 case SCTP_ERROR_UNKNOWN_CHUNK:
796 struct sctp_chunkhdr *unk_chunk_hdr;
798 unk_chunk_hdr = (struct sctp_chunkhdr *)err_hdr->variable;
799 switch (unk_chunk_hdr->type) {
800 /* ADDIP 4.1 A9) If the peer responds to an ASCONF with an
801 * ERROR chunk reporting that it did not recognized the ASCONF
802 * chunk type, the sender of the ASCONF MUST NOT send any
803 * further ASCONF chunks and MUST stop its T-4 timer.
805 case SCTP_CID_ASCONF:
806 asoc->peer.asconf_capable = 0;
807 sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
808 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
820 /* Process variable FWDTSN chunk information. */
821 static void sctp_cmd_process_fwdtsn(struct sctp_ulpq *ulpq,
822 struct sctp_chunk *chunk)
824 struct sctp_fwdtsn_skip *skip;
825 /* Walk through all the skipped SSNs */
826 sctp_walk_fwdtsn(skip, chunk) {
827 sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
833 /* Helper function to remove the association non-primary peer
836 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
838 struct sctp_transport *t;
839 struct list_head *pos;
840 struct list_head *temp;
842 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
843 t = list_entry(pos, struct sctp_transport, transports);
844 if (!sctp_cmp_addr_exact(&t->ipaddr,
845 &asoc->peer.primary_addr)) {
846 sctp_assoc_del_peer(asoc, &t->ipaddr);
853 /* Helper function to set sk_err on a 1-1 style socket. */
854 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
856 struct sock *sk = asoc->base.sk;
858 if (!sctp_style(sk, UDP))
862 /* Helper function to generate an association change event */
863 static void sctp_cmd_assoc_change(sctp_cmd_seq_t *commands,
864 struct sctp_association *asoc,
867 struct sctp_ulpevent *ev;
869 ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
870 asoc->c.sinit_num_ostreams,
871 asoc->c.sinit_max_instreams,
874 sctp_ulpq_tail_event(&asoc->ulpq, ev);
877 /* Helper function to generate an adaptation indication event */
878 static void sctp_cmd_adaptation_ind(sctp_cmd_seq_t *commands,
879 struct sctp_association *asoc)
881 struct sctp_ulpevent *ev;
883 ev = sctp_ulpevent_make_adaptation_indication(asoc, GFP_ATOMIC);
886 sctp_ulpq_tail_event(&asoc->ulpq, ev);
889 /* These three macros allow us to pull the debugging code out of the
890 * main flow of sctp_do_sm() to keep attention focused on the real
891 * functionality there.
894 SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \
895 "ep %p, %s, %s, asoc %p[%s], %s\n", \
896 ep, sctp_evttype_tbl[event_type], \
897 (*debug_fn)(subtype), asoc, \
898 sctp_state_tbl[state], state_fn->name)
901 SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \
902 "asoc %p, status: %s\n", \
903 asoc, sctp_status_tbl[status])
905 #define DEBUG_POST_SFX \
906 SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \
908 sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
909 sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED])
912 * This is the master state machine processing function.
914 * If you want to understand all of lksctp, this is a
915 * good place to start.
917 int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
919 struct sctp_endpoint *ep,
920 struct sctp_association *asoc,
924 sctp_cmd_seq_t commands;
925 const sctp_sm_table_entry_t *state_fn;
926 sctp_disposition_t status;
928 typedef const char *(printfn_t)(sctp_subtype_t);
930 static printfn_t *table[] = {
931 NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
933 printfn_t *debug_fn __attribute__ ((unused)) = table[event_type];
935 /* Look up the state function, run it, and then process the
936 * side effects. These three steps are the heart of lksctp.
938 state_fn = sctp_sm_lookup_event(event_type, state, subtype);
940 sctp_init_cmd_seq(&commands);
943 status = (*state_fn->fn)(ep, asoc, subtype, event_arg, &commands);
946 error = sctp_side_effects(event_type, subtype, state,
947 ep, asoc, event_arg, status,
957 /*****************************************************************
958 * This the master state function side effect processing function.
959 *****************************************************************/
960 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
962 struct sctp_endpoint *ep,
963 struct sctp_association *asoc,
965 sctp_disposition_t status,
966 sctp_cmd_seq_t *commands,
971 /* FIXME - Most of the dispositions left today would be categorized
972 * as "exceptional" dispositions. For those dispositions, it
973 * may not be proper to run through any of the commands at all.
974 * For example, the command interpreter might be run only with
975 * disposition SCTP_DISPOSITION_CONSUME.
977 if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
984 case SCTP_DISPOSITION_DISCARD:
985 SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, "
986 "event_type %d, event_id %d\n",
987 state, event_type, subtype.chunk);
990 case SCTP_DISPOSITION_NOMEM:
991 /* We ran out of memory, so we need to discard this
994 /* BUG--we should now recover some memory, probably by
1000 case SCTP_DISPOSITION_DELETE_TCB:
1001 /* This should now be a command. */
1004 case SCTP_DISPOSITION_CONSUME:
1005 case SCTP_DISPOSITION_ABORT:
1007 * We should no longer have much work to do here as the
1008 * real work has been done as explicit commands above.
1012 case SCTP_DISPOSITION_VIOLATION:
1013 if (net_ratelimit())
1014 printk(KERN_ERR "sctp protocol violation state %d "
1015 "chunkid %d\n", state, subtype.chunk);
1018 case SCTP_DISPOSITION_NOT_IMPL:
1019 printk(KERN_WARNING "sctp unimplemented feature in state %d, "
1020 "event_type %d, event_id %d\n",
1021 state, event_type, subtype.chunk);
1024 case SCTP_DISPOSITION_BUG:
1025 printk(KERN_ERR "sctp bug in state %d, "
1026 "event_type %d, event_id %d\n",
1027 state, event_type, subtype.chunk);
1032 printk(KERN_ERR "sctp impossible disposition %d "
1033 "in state %d, event_type %d, event_id %d\n",
1034 status, state, event_type, subtype.chunk);
1043 /********************************************************************
1044 * 2nd Level Abstractions
1045 ********************************************************************/
1047 /* This is the side-effect interpreter. */
1048 static int sctp_cmd_interpreter(sctp_event_t event_type,
1049 sctp_subtype_t subtype,
1051 struct sctp_endpoint *ep,
1052 struct sctp_association *asoc,
1054 sctp_disposition_t status,
1055 sctp_cmd_seq_t *commands,
1061 struct sctp_chunk *new_obj;
1062 struct sctp_chunk *chunk = NULL;
1063 struct sctp_packet *packet;
1064 struct timer_list *timer;
1065 unsigned long timeout;
1066 struct sctp_transport *t;
1067 struct sctp_sackhdr sackh;
1070 if (SCTP_EVENT_T_TIMEOUT != event_type)
1071 chunk = (struct sctp_chunk *) event_arg;
1073 /* Note: This whole file is a huge candidate for rework.
1074 * For example, each command could either have its own handler, so
1075 * the loop would look like:
1077 * cmd->handle(x, y, z)
1080 while (NULL != (cmd = sctp_next_cmd(commands))) {
1081 switch (cmd->verb) {
1086 case SCTP_CMD_NEW_ASOC:
1087 /* Register a new association. */
1089 sctp_outq_uncork(&asoc->outqueue);
1092 asoc = cmd->obj.ptr;
1093 /* Register with the endpoint. */
1094 sctp_endpoint_add_asoc(ep, asoc);
1095 sctp_hash_established(asoc);
1098 case SCTP_CMD_UPDATE_ASSOC:
1099 sctp_assoc_update(asoc, cmd->obj.ptr);
1102 case SCTP_CMD_PURGE_OUTQUEUE:
1103 sctp_outq_teardown(&asoc->outqueue);
1106 case SCTP_CMD_DELETE_TCB:
1108 sctp_outq_uncork(&asoc->outqueue);
1111 /* Delete the current association. */
1112 sctp_cmd_delete_tcb(commands, asoc);
1116 case SCTP_CMD_NEW_STATE:
1117 /* Enter a new state. */
1118 sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1121 case SCTP_CMD_REPORT_TSN:
1122 /* Record the arrival of a TSN. */
1123 sctp_tsnmap_mark(&asoc->peer.tsn_map, cmd->obj.u32);
1126 case SCTP_CMD_REPORT_FWDTSN:
1127 /* Move the Cumulattive TSN Ack ahead. */
1128 sctp_tsnmap_skip(&asoc->peer.tsn_map, cmd->obj.u32);
1130 /* purge the fragmentation queue */
1131 sctp_ulpq_reasm_flushtsn(&asoc->ulpq, cmd->obj.u32);
1133 /* Abort any in progress partial delivery. */
1134 sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
1137 case SCTP_CMD_PROCESS_FWDTSN:
1138 sctp_cmd_process_fwdtsn(&asoc->ulpq, cmd->obj.ptr);
1141 case SCTP_CMD_GEN_SACK:
1142 /* Generate a Selective ACK.
1143 * The argument tells us whether to just count
1144 * the packet and MAYBE generate a SACK, or
1147 force = cmd->obj.i32;
1148 error = sctp_gen_sack(asoc, force, commands);
1151 case SCTP_CMD_PROCESS_SACK:
1152 /* Process an inbound SACK. */
1153 error = sctp_cmd_process_sack(commands, asoc,
1157 case SCTP_CMD_GEN_INIT_ACK:
1158 /* Generate an INIT ACK chunk. */
1159 new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1164 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1165 SCTP_CHUNK(new_obj));
1168 case SCTP_CMD_PEER_INIT:
1169 /* Process a unified INIT from the peer.
1170 * Note: Only used during INIT-ACK processing. If
1171 * there is an error just return to the outter
1172 * layer which will bail.
1174 error = sctp_cmd_process_init(commands, asoc, chunk,
1178 case SCTP_CMD_GEN_COOKIE_ECHO:
1179 /* Generate a COOKIE ECHO chunk. */
1180 new_obj = sctp_make_cookie_echo(asoc, chunk);
1183 sctp_chunk_free(cmd->obj.ptr);
1186 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1187 SCTP_CHUNK(new_obj));
1189 /* If there is an ERROR chunk to be sent along with
1190 * the COOKIE_ECHO, send it, too.
1193 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1194 SCTP_CHUNK(cmd->obj.ptr));
1196 /* FIXME - Eventually come up with a cleaner way to
1197 * enabling COOKIE-ECHO + DATA bundling during
1198 * multihoming stale cookie scenarios, the following
1199 * command plays with asoc->peer.retran_path to
1200 * avoid the problem of sending the COOKIE-ECHO and
1201 * DATA in different paths, which could result
1202 * in the association being ABORTed if the DATA chunk
1203 * is processed first by the server. Checking the
1204 * init error counter simply causes this command
1205 * to be executed only during failed attempts of
1206 * association establishment.
1208 if ((asoc->peer.retran_path !=
1209 asoc->peer.primary_path) &&
1210 (asoc->init_err_counter > 0)) {
1211 sctp_add_cmd_sf(commands,
1212 SCTP_CMD_FORCE_PRIM_RETRAN,
1218 case SCTP_CMD_GEN_SHUTDOWN:
1219 /* Generate SHUTDOWN when in SHUTDOWN_SENT state.
1220 * Reset error counts.
1222 asoc->overall_error_count = 0;
1224 /* Generate a SHUTDOWN chunk. */
1225 new_obj = sctp_make_shutdown(asoc, chunk);
1228 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1229 SCTP_CHUNK(new_obj));
1232 case SCTP_CMD_CHUNK_ULP:
1233 /* Send a chunk to the sockets layer. */
1234 SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1235 "chunk_up:", cmd->obj.ptr,
1236 "ulpq:", &asoc->ulpq);
1237 sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.ptr,
1241 case SCTP_CMD_EVENT_ULP:
1242 /* Send a notification to the sockets layer. */
1243 SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1244 "event_up:",cmd->obj.ptr,
1245 "ulpq:",&asoc->ulpq);
1246 sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ptr);
1249 case SCTP_CMD_REPLY:
1250 /* If an caller has not already corked, do cork. */
1251 if (!asoc->outqueue.cork) {
1252 sctp_outq_cork(&asoc->outqueue);
1255 /* Send a chunk to our peer. */
1256 error = sctp_outq_tail(&asoc->outqueue, cmd->obj.ptr);
1259 case SCTP_CMD_SEND_PKT:
1260 /* Send a full packet to our peer. */
1261 packet = cmd->obj.ptr;
1262 sctp_packet_transmit(packet);
1263 sctp_ootb_pkt_free(packet);
1266 case SCTP_CMD_T1_RETRAN:
1267 /* Mark a transport for retransmission. */
1268 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1272 case SCTP_CMD_RETRAN:
1273 /* Mark a transport for retransmission. */
1274 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1278 case SCTP_CMD_TRANSMIT:
1279 /* Kick start transmission. */
1280 error = sctp_outq_uncork(&asoc->outqueue);
1284 case SCTP_CMD_ECN_CE:
1285 /* Do delayed CE processing. */
1286 sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1289 case SCTP_CMD_ECN_ECNE:
1290 /* Do delayed ECNE processing. */
1291 new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1294 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1295 SCTP_CHUNK(new_obj));
1298 case SCTP_CMD_ECN_CWR:
1299 /* Do delayed CWR processing. */
1300 sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1303 case SCTP_CMD_SETUP_T2:
1304 sctp_cmd_setup_t2(commands, asoc, cmd->obj.ptr);
1307 case SCTP_CMD_TIMER_START:
1308 timer = &asoc->timers[cmd->obj.to];
1309 timeout = asoc->timeouts[cmd->obj.to];
1312 timer->expires = jiffies + timeout;
1313 sctp_association_hold(asoc);
1317 case SCTP_CMD_TIMER_RESTART:
1318 timer = &asoc->timers[cmd->obj.to];
1319 timeout = asoc->timeouts[cmd->obj.to];
1320 if (!mod_timer(timer, jiffies + timeout))
1321 sctp_association_hold(asoc);
1324 case SCTP_CMD_TIMER_STOP:
1325 timer = &asoc->timers[cmd->obj.to];
1326 if (timer_pending(timer) && del_timer(timer))
1327 sctp_association_put(asoc);
1330 case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
1331 chunk = cmd->obj.ptr;
1332 t = sctp_assoc_choose_init_transport(asoc);
1333 asoc->init_last_sent_to = t;
1334 chunk->transport = t;
1335 t->init_sent_count++;
1338 case SCTP_CMD_INIT_RESTART:
1339 /* Do the needed accounting and updates
1340 * associated with restarting an initialization
1341 * timer. Only multiply the timeout by two if
1342 * all transports have been tried at the current
1345 t = asoc->init_last_sent_to;
1346 asoc->init_err_counter++;
1348 if (t->init_sent_count > (asoc->init_cycle + 1)) {
1349 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] *= 2;
1350 if (asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] >
1351 asoc->max_init_timeo) {
1352 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
1353 asoc->max_init_timeo;
1357 "T1 INIT Timeout adjustment"
1358 " init_err_counter: %d"
1361 asoc->init_err_counter,
1363 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT]);
1366 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
1367 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1370 case SCTP_CMD_COOKIEECHO_RESTART:
1371 /* Do the needed accounting and updates
1372 * associated with restarting an initialization
1373 * timer. Only multiply the timeout by two if
1374 * all transports have been tried at the current
1377 asoc->init_err_counter++;
1379 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] *= 2;
1380 if (asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] >
1381 asoc->max_init_timeo) {
1382 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
1383 asoc->max_init_timeo;
1386 "T1 COOKIE Timeout adjustment"
1387 " init_err_counter: %d"
1389 asoc->init_err_counter,
1390 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE]);
1392 /* If we've sent any data bundled with
1393 * COOKIE-ECHO we need to resend.
1395 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1397 sctp_retransmit_mark(&asoc->outqueue, t,
1401 sctp_add_cmd_sf(commands,
1402 SCTP_CMD_TIMER_RESTART,
1403 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1406 case SCTP_CMD_INIT_FAILED:
1407 sctp_cmd_init_failed(commands, asoc, cmd->obj.err);
1410 case SCTP_CMD_ASSOC_FAILED:
1411 sctp_cmd_assoc_failed(commands, asoc, event_type,
1412 subtype, chunk, cmd->obj.err);
1415 case SCTP_CMD_INIT_COUNTER_INC:
1416 asoc->init_err_counter++;
1419 case SCTP_CMD_INIT_COUNTER_RESET:
1420 asoc->init_err_counter = 0;
1421 asoc->init_cycle = 0;
1424 case SCTP_CMD_REPORT_DUP:
1425 sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1429 case SCTP_CMD_REPORT_BAD_TAG:
1430 SCTP_DEBUG_PRINTK("vtag mismatch!\n");
1433 case SCTP_CMD_STRIKE:
1434 /* Mark one strike against a transport. */
1435 sctp_do_8_2_transport_strike(asoc, cmd->obj.transport);
1438 case SCTP_CMD_TRANSPORT_RESET:
1439 t = cmd->obj.transport;
1440 sctp_cmd_transport_reset(commands, asoc, t);
1443 case SCTP_CMD_TRANSPORT_ON:
1444 t = cmd->obj.transport;
1445 sctp_cmd_transport_on(commands, asoc, t, chunk);
1448 case SCTP_CMD_HB_TIMERS_START:
1449 sctp_cmd_hb_timers_start(commands, asoc);
1452 case SCTP_CMD_HB_TIMER_UPDATE:
1453 t = cmd->obj.transport;
1454 sctp_cmd_hb_timer_update(commands, asoc, t);
1457 case SCTP_CMD_HB_TIMERS_STOP:
1458 sctp_cmd_hb_timers_stop(commands, asoc);
1461 case SCTP_CMD_REPORT_ERROR:
1462 error = cmd->obj.error;
1465 case SCTP_CMD_PROCESS_CTSN:
1466 /* Dummy up a SACK for processing. */
1467 sackh.cum_tsn_ack = cmd->obj.be32;
1469 sackh.num_gap_ack_blocks = 0;
1470 sackh.num_dup_tsns = 0;
1471 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
1472 SCTP_SACKH(&sackh));
1475 case SCTP_CMD_DISCARD_PACKET:
1476 /* We need to discard the whole packet. */
1477 chunk->pdiscard = 1;
1480 case SCTP_CMD_RTO_PENDING:
1481 t = cmd->obj.transport;
1485 case SCTP_CMD_PART_DELIVER:
1486 sctp_ulpq_partial_delivery(&asoc->ulpq, cmd->obj.ptr,
1490 case SCTP_CMD_RENEGE:
1491 sctp_ulpq_renege(&asoc->ulpq, cmd->obj.ptr,
1495 case SCTP_CMD_SETUP_T4:
1496 sctp_cmd_setup_t4(commands, asoc, cmd->obj.ptr);
1499 case SCTP_CMD_PROCESS_OPERR:
1500 sctp_cmd_process_operr(commands, asoc, chunk);
1502 case SCTP_CMD_CLEAR_INIT_TAG:
1503 asoc->peer.i.init_tag = 0;
1505 case SCTP_CMD_DEL_NON_PRIMARY:
1506 sctp_cmd_del_non_primary(asoc);
1508 case SCTP_CMD_T3_RTX_TIMERS_STOP:
1509 sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1511 case SCTP_CMD_FORCE_PRIM_RETRAN:
1512 t = asoc->peer.retran_path;
1513 asoc->peer.retran_path = asoc->peer.primary_path;
1514 error = sctp_outq_uncork(&asoc->outqueue);
1516 asoc->peer.retran_path = t;
1518 case SCTP_CMD_SET_SK_ERR:
1519 sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1521 case SCTP_CMD_ASSOC_CHANGE:
1522 sctp_cmd_assoc_change(commands, asoc,
1525 case SCTP_CMD_ADAPTATION_IND:
1526 sctp_cmd_adaptation_ind(commands, asoc);
1529 case SCTP_CMD_ASSOC_SHKEY:
1530 error = sctp_auth_asoc_init_active_key(asoc,
1535 printk(KERN_WARNING "Impossible command: %u, %p\n",
1536 cmd->verb, cmd->obj.ptr);
1546 sctp_outq_uncork(&asoc->outqueue);