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 asoc->peer.sack_cnt++;
195 /* Set the SACK delay timeout based on the
196 * SACK delay for the last transport
197 * data was received from, or the default
198 * for the association.
201 /* We will need a SACK for the next packet. */
202 if (asoc->peer.sack_cnt >= trans->sackfreq - 1)
203 asoc->peer.sack_needed = 1;
205 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
208 /* We will need a SACK for the next packet. */
209 if (asoc->peer.sack_cnt >= asoc->sackfreq - 1)
210 asoc->peer.sack_needed = 1;
212 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
216 /* Restart the SACK timer. */
217 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
218 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
220 if (asoc->a_rwnd > asoc->rwnd)
221 asoc->a_rwnd = asoc->rwnd;
222 sack = sctp_make_sack(asoc);
226 asoc->peer.sack_needed = 0;
227 asoc->peer.sack_cnt = 0;
229 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
231 /* Stop the SACK timer. */
232 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
233 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
242 /* When the T3-RTX timer expires, it calls this function to create the
243 * relevant state machine event.
245 void sctp_generate_t3_rtx_event(unsigned long peer)
248 struct sctp_transport *transport = (struct sctp_transport *) peer;
249 struct sctp_association *asoc = transport->asoc;
251 /* Check whether a task is in the sock. */
253 sctp_bh_lock_sock(asoc->base.sk);
254 if (sock_owned_by_user(asoc->base.sk)) {
255 SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
257 /* Try again later. */
258 if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
259 sctp_transport_hold(transport);
263 /* Is this transport really dead and just waiting around for
264 * the timer to let go of the reference?
269 /* Run through the state machine. */
270 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
271 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
274 transport, GFP_ATOMIC);
277 asoc->base.sk->sk_err = -error;
280 sctp_bh_unlock_sock(asoc->base.sk);
281 sctp_transport_put(transport);
284 /* This is a sa interface for producing timeout events. It works
285 * for timeouts which use the association as their parameter.
287 static void sctp_generate_timeout_event(struct sctp_association *asoc,
288 sctp_event_timeout_t timeout_type)
292 sctp_bh_lock_sock(asoc->base.sk);
293 if (sock_owned_by_user(asoc->base.sk)) {
294 SCTP_DEBUG_PRINTK("%s:Sock is busy: timer %d\n",
298 /* Try again later. */
299 if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
300 sctp_association_hold(asoc);
304 /* Is this association really dead and just waiting around for
305 * the timer to let go of the reference?
310 /* Run through the state machine. */
311 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
312 SCTP_ST_TIMEOUT(timeout_type),
313 asoc->state, asoc->ep, asoc,
314 (void *)timeout_type, GFP_ATOMIC);
317 asoc->base.sk->sk_err = -error;
320 sctp_bh_unlock_sock(asoc->base.sk);
321 sctp_association_put(asoc);
324 static void sctp_generate_t1_cookie_event(unsigned long data)
326 struct sctp_association *asoc = (struct sctp_association *) data;
327 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
330 static void sctp_generate_t1_init_event(unsigned long data)
332 struct sctp_association *asoc = (struct sctp_association *) data;
333 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
336 static void sctp_generate_t2_shutdown_event(unsigned long data)
338 struct sctp_association *asoc = (struct sctp_association *) data;
339 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
342 static void sctp_generate_t4_rto_event(unsigned long data)
344 struct sctp_association *asoc = (struct sctp_association *) data;
345 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
348 static void sctp_generate_t5_shutdown_guard_event(unsigned long data)
350 struct sctp_association *asoc = (struct sctp_association *)data;
351 sctp_generate_timeout_event(asoc,
352 SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
354 } /* sctp_generate_t5_shutdown_guard_event() */
356 static void sctp_generate_autoclose_event(unsigned long data)
358 struct sctp_association *asoc = (struct sctp_association *) data;
359 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
362 /* Generate a heart beat event. If the sock is busy, reschedule. Make
363 * sure that the transport is still valid.
365 void sctp_generate_heartbeat_event(unsigned long data)
368 struct sctp_transport *transport = (struct sctp_transport *) data;
369 struct sctp_association *asoc = transport->asoc;
371 sctp_bh_lock_sock(asoc->base.sk);
372 if (sock_owned_by_user(asoc->base.sk)) {
373 SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
375 /* Try again later. */
376 if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
377 sctp_transport_hold(transport);
381 /* Is this structure just waiting around for us to actually
387 error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
388 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
389 asoc->state, asoc->ep, asoc,
390 transport, GFP_ATOMIC);
393 asoc->base.sk->sk_err = -error;
396 sctp_bh_unlock_sock(asoc->base.sk);
397 sctp_transport_put(transport);
400 /* Inject a SACK Timeout event into the state machine. */
401 static void sctp_generate_sack_event(unsigned long data)
403 struct sctp_association *asoc = (struct sctp_association *) data;
404 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
407 sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
409 sctp_generate_t1_cookie_event,
410 sctp_generate_t1_init_event,
411 sctp_generate_t2_shutdown_event,
413 sctp_generate_t4_rto_event,
414 sctp_generate_t5_shutdown_guard_event,
416 sctp_generate_sack_event,
417 sctp_generate_autoclose_event,
421 /* RFC 2960 8.2 Path Failure Detection
423 * When its peer endpoint is multi-homed, an endpoint should keep a
424 * error counter for each of the destination transport addresses of the
427 * Each time the T3-rtx timer expires on any address, or when a
428 * HEARTBEAT sent to an idle address is not acknowledged within a RTO,
429 * the error counter of that destination address will be incremented.
430 * When the value in the error counter exceeds the protocol parameter
431 * 'Path.Max.Retrans' of that destination address, the endpoint should
432 * mark the destination transport address as inactive, and a
433 * notification SHOULD be sent to the upper layer.
436 static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
437 struct sctp_transport *transport)
439 /* The check for association's overall error counter exceeding the
440 * threshold is done in the state function.
442 /* When probing UNCONFIRMED addresses, the association overall
443 * error count is NOT incremented
445 if (transport->state != SCTP_UNCONFIRMED)
446 asoc->overall_error_count++;
448 if (transport->state != SCTP_INACTIVE &&
449 (transport->error_count++ >= transport->pathmaxrxt)) {
450 SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p",
451 " transport IP: port:%d failed.\n",
453 (&transport->ipaddr),
454 ntohs(transport->ipaddr.v4.sin_port));
455 sctp_assoc_control_transport(asoc, transport,
457 SCTP_FAILED_THRESHOLD);
460 /* E2) For the destination address for which the timer
461 * expires, set RTO <- RTO * 2 ("back off the timer"). The
462 * maximum value discussed in rule C7 above (RTO.max) may be
463 * used to provide an upper bound to this doubling operation.
465 * Special Case: the first HB doesn't trigger exponential backoff.
466 * The first unacknowleged HB triggers it. We do this with a flag
467 * that indicates that we have an outstanding HB.
469 if (transport->hb_sent) {
470 transport->last_rto = transport->rto;
471 transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
475 /* Worker routine to handle INIT command failure. */
476 static void sctp_cmd_init_failed(sctp_cmd_seq_t *commands,
477 struct sctp_association *asoc,
480 struct sctp_ulpevent *event;
482 event = sctp_ulpevent_make_assoc_change(asoc,0, SCTP_CANT_STR_ASSOC,
483 (__u16)error, 0, 0, NULL,
487 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
488 SCTP_ULPEVENT(event));
490 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
491 SCTP_STATE(SCTP_STATE_CLOSED));
493 /* SEND_FAILED sent later when cleaning up the association. */
494 asoc->outqueue.error = error;
495 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
498 /* Worker routine to handle SCTP_CMD_ASSOC_FAILED. */
499 static void sctp_cmd_assoc_failed(sctp_cmd_seq_t *commands,
500 struct sctp_association *asoc,
501 sctp_event_t event_type,
502 sctp_subtype_t subtype,
503 struct sctp_chunk *chunk,
506 struct sctp_ulpevent *event;
508 /* Cancel any partial delivery in progress. */
509 sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
511 if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)
512 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
513 (__u16)error, 0, 0, chunk,
516 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
517 (__u16)error, 0, 0, NULL,
520 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
521 SCTP_ULPEVENT(event));
523 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
524 SCTP_STATE(SCTP_STATE_CLOSED));
526 /* SEND_FAILED sent later when cleaning up the association. */
527 asoc->outqueue.error = error;
528 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
531 /* Process an init chunk (may be real INIT/INIT-ACK or an embedded INIT
532 * inside the cookie. In reality, this is only used for INIT-ACK processing
533 * since all other cases use "temporary" associations and can do all
534 * their work in statefuns directly.
536 static int sctp_cmd_process_init(sctp_cmd_seq_t *commands,
537 struct sctp_association *asoc,
538 struct sctp_chunk *chunk,
539 sctp_init_chunk_t *peer_init,
544 /* We only process the init as a sideeffect in a single
545 * case. This is when we process the INIT-ACK. If we
546 * fail during INIT processing (due to malloc problems),
547 * just return the error and stop processing the stack.
549 if (!sctp_process_init(asoc, chunk->chunk_hdr->type,
550 sctp_source(chunk), peer_init, gfp))
558 /* Helper function to break out starting up of heartbeat timers. */
559 static void sctp_cmd_hb_timers_start(sctp_cmd_seq_t *cmds,
560 struct sctp_association *asoc)
562 struct sctp_transport *t;
564 /* Start a heartbeat timer for each transport on the association.
565 * hold a reference on the transport to make sure none of
566 * the needed data structures go away.
568 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
570 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
571 sctp_transport_hold(t);
575 static void sctp_cmd_hb_timers_stop(sctp_cmd_seq_t *cmds,
576 struct sctp_association *asoc)
578 struct sctp_transport *t;
580 /* Stop all heartbeat timers. */
582 list_for_each_entry(t, &asoc->peer.transport_addr_list,
584 if (del_timer(&t->hb_timer))
585 sctp_transport_put(t);
589 /* Helper function to stop any pending T3-RTX timers */
590 static void sctp_cmd_t3_rtx_timers_stop(sctp_cmd_seq_t *cmds,
591 struct sctp_association *asoc)
593 struct sctp_transport *t;
595 list_for_each_entry(t, &asoc->peer.transport_addr_list,
597 if (timer_pending(&t->T3_rtx_timer) &&
598 del_timer(&t->T3_rtx_timer)) {
599 sctp_transport_put(t);
605 /* Helper function to update the heartbeat timer. */
606 static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
607 struct sctp_transport *t)
609 /* Update the heartbeat timer. */
610 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
611 sctp_transport_hold(t);
614 /* Helper function to handle the reception of an HEARTBEAT ACK. */
615 static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
616 struct sctp_association *asoc,
617 struct sctp_transport *t,
618 struct sctp_chunk *chunk)
620 sctp_sender_hb_info_t *hbinfo;
622 /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
623 * HEARTBEAT should clear the error counter of the destination
624 * transport address to which the HEARTBEAT was sent.
625 * The association's overall error count is also cleared.
628 t->asoc->overall_error_count = 0;
630 /* Clear the hb_sent flag to signal that we had a good
635 /* Mark the destination transport address as active if it is not so
638 if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED))
639 sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
640 SCTP_HEARTBEAT_SUCCESS);
642 /* The receiver of the HEARTBEAT ACK should also perform an
643 * RTT measurement for that destination transport address
644 * using the time value carried in the HEARTBEAT ACK chunk.
645 * If the transport's rto_pending variable has been cleared,
646 * it was most likely due to a retransmit. However, we want
647 * to re-enable it to properly update the rto.
649 if (t->rto_pending == 0)
652 hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
653 sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
655 /* Update the heartbeat timer. */
656 if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
657 sctp_transport_hold(t);
660 /* Helper function to do a transport reset at the expiry of the hearbeat
663 static void sctp_cmd_transport_reset(sctp_cmd_seq_t *cmds,
664 struct sctp_association *asoc,
665 struct sctp_transport *t)
667 sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
669 /* Mark one strike against a transport. */
670 sctp_do_8_2_transport_strike(asoc, t);
675 /* Helper function to process the process SACK command. */
676 static int sctp_cmd_process_sack(sctp_cmd_seq_t *cmds,
677 struct sctp_association *asoc,
678 struct sctp_sackhdr *sackh)
682 if (sctp_outq_sack(&asoc->outqueue, sackh)) {
683 /* There are no more TSNs awaiting SACK. */
684 err = sctp_do_sm(SCTP_EVENT_T_OTHER,
685 SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
686 asoc->state, asoc->ep, asoc, NULL,
693 /* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
694 * the transport for a shutdown chunk.
696 static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
697 struct sctp_association *asoc,
698 struct sctp_chunk *chunk)
700 struct sctp_transport *t;
702 t = sctp_assoc_choose_shutdown_transport(asoc);
703 asoc->shutdown_last_sent_to = t;
704 asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
705 chunk->transport = t;
708 /* Helper function to change the state of an association. */
709 static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds,
710 struct sctp_association *asoc,
713 struct sock *sk = asoc->base.sk;
717 SCTP_DEBUG_PRINTK("sctp_cmd_new_state: asoc %p[%s]\n",
718 asoc, sctp_state_tbl[state]);
720 if (sctp_style(sk, TCP)) {
721 /* Change the sk->sk_state of a TCP-style socket that has
722 * sucessfully completed a connect() call.
724 if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
725 sk->sk_state = SCTP_SS_ESTABLISHED;
727 /* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
728 if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
729 sctp_sstate(sk, ESTABLISHED))
730 sk->sk_shutdown |= RCV_SHUTDOWN;
733 if (sctp_state(asoc, COOKIE_WAIT)) {
734 /* Reset init timeouts since they may have been
735 * increased due to timer expirations.
737 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
739 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
743 if (sctp_state(asoc, ESTABLISHED) ||
744 sctp_state(asoc, CLOSED) ||
745 sctp_state(asoc, SHUTDOWN_RECEIVED)) {
746 /* Wake up any processes waiting in the asoc's wait queue in
747 * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
749 if (waitqueue_active(&asoc->wait))
750 wake_up_interruptible(&asoc->wait);
752 /* Wake up any processes waiting in the sk's sleep queue of
753 * a TCP-style or UDP-style peeled-off socket in
754 * sctp_wait_for_accept() or sctp_wait_for_packet().
755 * For a UDP-style socket, the waiters are woken up by the
758 if (!sctp_style(sk, UDP))
759 sk->sk_state_change(sk);
763 /* Helper function to delete an association. */
764 static void sctp_cmd_delete_tcb(sctp_cmd_seq_t *cmds,
765 struct sctp_association *asoc)
767 struct sock *sk = asoc->base.sk;
769 /* If it is a non-temporary association belonging to a TCP-style
770 * listening socket that is not closed, do not free it so that accept()
771 * can pick it up later.
773 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
774 (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
777 sctp_unhash_established(asoc);
778 sctp_association_free(asoc);
782 * ADDIP Section 4.1 ASCONF Chunk Procedures
783 * A4) Start a T-4 RTO timer, using the RTO value of the selected
784 * destination address (we use active path instead of primary path just
785 * because primary path may be inactive.
787 static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
788 struct sctp_association *asoc,
789 struct sctp_chunk *chunk)
791 struct sctp_transport *t;
793 t = asoc->peer.active_path;
794 asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
795 chunk->transport = t;
798 /* Process an incoming Operation Error Chunk. */
799 static void sctp_cmd_process_operr(sctp_cmd_seq_t *cmds,
800 struct sctp_association *asoc,
801 struct sctp_chunk *chunk)
803 struct sctp_operr_chunk *operr_chunk;
804 struct sctp_errhdr *err_hdr;
806 operr_chunk = (struct sctp_operr_chunk *)chunk->chunk_hdr;
807 err_hdr = &operr_chunk->err_hdr;
809 switch (err_hdr->cause) {
810 case SCTP_ERROR_UNKNOWN_CHUNK:
812 struct sctp_chunkhdr *unk_chunk_hdr;
814 unk_chunk_hdr = (struct sctp_chunkhdr *)err_hdr->variable;
815 switch (unk_chunk_hdr->type) {
816 /* ADDIP 4.1 A9) If the peer responds to an ASCONF with an
817 * ERROR chunk reporting that it did not recognized the ASCONF
818 * chunk type, the sender of the ASCONF MUST NOT send any
819 * further ASCONF chunks and MUST stop its T-4 timer.
821 case SCTP_CID_ASCONF:
822 asoc->peer.asconf_capable = 0;
823 sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
824 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
836 /* Process variable FWDTSN chunk information. */
837 static void sctp_cmd_process_fwdtsn(struct sctp_ulpq *ulpq,
838 struct sctp_chunk *chunk)
840 struct sctp_fwdtsn_skip *skip;
841 /* Walk through all the skipped SSNs */
842 sctp_walk_fwdtsn(skip, chunk) {
843 sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
849 /* Helper function to remove the association non-primary peer
852 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
854 struct sctp_transport *t;
855 struct list_head *pos;
856 struct list_head *temp;
858 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
859 t = list_entry(pos, struct sctp_transport, transports);
860 if (!sctp_cmp_addr_exact(&t->ipaddr,
861 &asoc->peer.primary_addr)) {
862 sctp_assoc_del_peer(asoc, &t->ipaddr);
869 /* Helper function to set sk_err on a 1-1 style socket. */
870 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
872 struct sock *sk = asoc->base.sk;
874 if (!sctp_style(sk, UDP))
878 /* Helper function to generate an association change event */
879 static void sctp_cmd_assoc_change(sctp_cmd_seq_t *commands,
880 struct sctp_association *asoc,
883 struct sctp_ulpevent *ev;
885 ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
886 asoc->c.sinit_num_ostreams,
887 asoc->c.sinit_max_instreams,
890 sctp_ulpq_tail_event(&asoc->ulpq, ev);
893 /* Helper function to generate an adaptation indication event */
894 static void sctp_cmd_adaptation_ind(sctp_cmd_seq_t *commands,
895 struct sctp_association *asoc)
897 struct sctp_ulpevent *ev;
899 ev = sctp_ulpevent_make_adaptation_indication(asoc, GFP_ATOMIC);
902 sctp_ulpq_tail_event(&asoc->ulpq, ev);
906 static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
907 sctp_event_timeout_t timer,
910 struct sctp_transport *t;
912 t = asoc->init_last_sent_to;
913 asoc->init_err_counter++;
915 if (t->init_sent_count > (asoc->init_cycle + 1)) {
916 asoc->timeouts[timer] *= 2;
917 if (asoc->timeouts[timer] > asoc->max_init_timeo) {
918 asoc->timeouts[timer] = asoc->max_init_timeo;
922 "T1 %s Timeout adjustment"
923 " init_err_counter: %d"
927 asoc->init_err_counter,
929 asoc->timeouts[timer]);
934 /* These three macros allow us to pull the debugging code out of the
935 * main flow of sctp_do_sm() to keep attention focused on the real
936 * functionality there.
939 SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \
940 "ep %p, %s, %s, asoc %p[%s], %s\n", \
941 ep, sctp_evttype_tbl[event_type], \
942 (*debug_fn)(subtype), asoc, \
943 sctp_state_tbl[state], state_fn->name)
946 SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \
947 "asoc %p, status: %s\n", \
948 asoc, sctp_status_tbl[status])
950 #define DEBUG_POST_SFX \
951 SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \
953 sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
954 sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED])
957 * This is the master state machine processing function.
959 * If you want to understand all of lksctp, this is a
960 * good place to start.
962 int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
964 struct sctp_endpoint *ep,
965 struct sctp_association *asoc,
969 sctp_cmd_seq_t commands;
970 const sctp_sm_table_entry_t *state_fn;
971 sctp_disposition_t status;
973 typedef const char *(printfn_t)(sctp_subtype_t);
975 static printfn_t *table[] = {
976 NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
978 printfn_t *debug_fn __attribute__ ((unused)) = table[event_type];
980 /* Look up the state function, run it, and then process the
981 * side effects. These three steps are the heart of lksctp.
983 state_fn = sctp_sm_lookup_event(event_type, state, subtype);
985 sctp_init_cmd_seq(&commands);
988 status = (*state_fn->fn)(ep, asoc, subtype, event_arg, &commands);
991 error = sctp_side_effects(event_type, subtype, state,
992 ep, asoc, event_arg, status,
1002 /*****************************************************************
1003 * This the master state function side effect processing function.
1004 *****************************************************************/
1005 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
1007 struct sctp_endpoint *ep,
1008 struct sctp_association *asoc,
1010 sctp_disposition_t status,
1011 sctp_cmd_seq_t *commands,
1016 /* FIXME - Most of the dispositions left today would be categorized
1017 * as "exceptional" dispositions. For those dispositions, it
1018 * may not be proper to run through any of the commands at all.
1019 * For example, the command interpreter might be run only with
1020 * disposition SCTP_DISPOSITION_CONSUME.
1022 if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
1029 case SCTP_DISPOSITION_DISCARD:
1030 SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, "
1031 "event_type %d, event_id %d\n",
1032 state, event_type, subtype.chunk);
1035 case SCTP_DISPOSITION_NOMEM:
1036 /* We ran out of memory, so we need to discard this
1039 /* BUG--we should now recover some memory, probably by
1045 case SCTP_DISPOSITION_DELETE_TCB:
1046 /* This should now be a command. */
1049 case SCTP_DISPOSITION_CONSUME:
1050 case SCTP_DISPOSITION_ABORT:
1052 * We should no longer have much work to do here as the
1053 * real work has been done as explicit commands above.
1057 case SCTP_DISPOSITION_VIOLATION:
1058 if (net_ratelimit())
1059 printk(KERN_ERR "sctp protocol violation state %d "
1060 "chunkid %d\n", state, subtype.chunk);
1063 case SCTP_DISPOSITION_NOT_IMPL:
1064 printk(KERN_WARNING "sctp unimplemented feature in state %d, "
1065 "event_type %d, event_id %d\n",
1066 state, event_type, subtype.chunk);
1069 case SCTP_DISPOSITION_BUG:
1070 printk(KERN_ERR "sctp bug in state %d, "
1071 "event_type %d, event_id %d\n",
1072 state, event_type, subtype.chunk);
1077 printk(KERN_ERR "sctp impossible disposition %d "
1078 "in state %d, event_type %d, event_id %d\n",
1079 status, state, event_type, subtype.chunk);
1088 /********************************************************************
1089 * 2nd Level Abstractions
1090 ********************************************************************/
1092 /* This is the side-effect interpreter. */
1093 static int sctp_cmd_interpreter(sctp_event_t event_type,
1094 sctp_subtype_t subtype,
1096 struct sctp_endpoint *ep,
1097 struct sctp_association *asoc,
1099 sctp_disposition_t status,
1100 sctp_cmd_seq_t *commands,
1106 struct sctp_chunk *new_obj;
1107 struct sctp_chunk *chunk = NULL;
1108 struct sctp_packet *packet;
1109 struct timer_list *timer;
1110 unsigned long timeout;
1111 struct sctp_transport *t;
1112 struct sctp_sackhdr sackh;
1115 if (SCTP_EVENT_T_TIMEOUT != event_type)
1116 chunk = (struct sctp_chunk *) event_arg;
1118 /* Note: This whole file is a huge candidate for rework.
1119 * For example, each command could either have its own handler, so
1120 * the loop would look like:
1122 * cmd->handle(x, y, z)
1125 while (NULL != (cmd = sctp_next_cmd(commands))) {
1126 switch (cmd->verb) {
1131 case SCTP_CMD_NEW_ASOC:
1132 /* Register a new association. */
1134 sctp_outq_uncork(&asoc->outqueue);
1137 asoc = cmd->obj.ptr;
1138 /* Register with the endpoint. */
1139 sctp_endpoint_add_asoc(ep, asoc);
1140 sctp_hash_established(asoc);
1143 case SCTP_CMD_UPDATE_ASSOC:
1144 sctp_assoc_update(asoc, cmd->obj.ptr);
1147 case SCTP_CMD_PURGE_OUTQUEUE:
1148 sctp_outq_teardown(&asoc->outqueue);
1151 case SCTP_CMD_DELETE_TCB:
1153 sctp_outq_uncork(&asoc->outqueue);
1156 /* Delete the current association. */
1157 sctp_cmd_delete_tcb(commands, asoc);
1161 case SCTP_CMD_NEW_STATE:
1162 /* Enter a new state. */
1163 sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1166 case SCTP_CMD_REPORT_TSN:
1167 /* Record the arrival of a TSN. */
1168 error = sctp_tsnmap_mark(&asoc->peer.tsn_map,
1172 case SCTP_CMD_REPORT_FWDTSN:
1173 /* Move the Cumulattive TSN Ack ahead. */
1174 sctp_tsnmap_skip(&asoc->peer.tsn_map, cmd->obj.u32);
1176 /* purge the fragmentation queue */
1177 sctp_ulpq_reasm_flushtsn(&asoc->ulpq, cmd->obj.u32);
1179 /* Abort any in progress partial delivery. */
1180 sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
1183 case SCTP_CMD_PROCESS_FWDTSN:
1184 sctp_cmd_process_fwdtsn(&asoc->ulpq, cmd->obj.ptr);
1187 case SCTP_CMD_GEN_SACK:
1188 /* Generate a Selective ACK.
1189 * The argument tells us whether to just count
1190 * the packet and MAYBE generate a SACK, or
1193 force = cmd->obj.i32;
1194 error = sctp_gen_sack(asoc, force, commands);
1197 case SCTP_CMD_PROCESS_SACK:
1198 /* Process an inbound SACK. */
1199 error = sctp_cmd_process_sack(commands, asoc,
1203 case SCTP_CMD_GEN_INIT_ACK:
1204 /* Generate an INIT ACK chunk. */
1205 new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1210 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1211 SCTP_CHUNK(new_obj));
1214 case SCTP_CMD_PEER_INIT:
1215 /* Process a unified INIT from the peer.
1216 * Note: Only used during INIT-ACK processing. If
1217 * there is an error just return to the outter
1218 * layer which will bail.
1220 error = sctp_cmd_process_init(commands, asoc, chunk,
1224 case SCTP_CMD_GEN_COOKIE_ECHO:
1225 /* Generate a COOKIE ECHO chunk. */
1226 new_obj = sctp_make_cookie_echo(asoc, chunk);
1229 sctp_chunk_free(cmd->obj.ptr);
1232 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1233 SCTP_CHUNK(new_obj));
1235 /* If there is an ERROR chunk to be sent along with
1236 * the COOKIE_ECHO, send it, too.
1239 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1240 SCTP_CHUNK(cmd->obj.ptr));
1242 if (new_obj->transport) {
1243 new_obj->transport->init_sent_count++;
1244 asoc->init_last_sent_to = new_obj->transport;
1247 /* FIXME - Eventually come up with a cleaner way to
1248 * enabling COOKIE-ECHO + DATA bundling during
1249 * multihoming stale cookie scenarios, the following
1250 * command plays with asoc->peer.retran_path to
1251 * avoid the problem of sending the COOKIE-ECHO and
1252 * DATA in different paths, which could result
1253 * in the association being ABORTed if the DATA chunk
1254 * is processed first by the server. Checking the
1255 * init error counter simply causes this command
1256 * to be executed only during failed attempts of
1257 * association establishment.
1259 if ((asoc->peer.retran_path !=
1260 asoc->peer.primary_path) &&
1261 (asoc->init_err_counter > 0)) {
1262 sctp_add_cmd_sf(commands,
1263 SCTP_CMD_FORCE_PRIM_RETRAN,
1269 case SCTP_CMD_GEN_SHUTDOWN:
1270 /* Generate SHUTDOWN when in SHUTDOWN_SENT state.
1271 * Reset error counts.
1273 asoc->overall_error_count = 0;
1275 /* Generate a SHUTDOWN chunk. */
1276 new_obj = sctp_make_shutdown(asoc, chunk);
1279 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1280 SCTP_CHUNK(new_obj));
1283 case SCTP_CMD_CHUNK_ULP:
1284 /* Send a chunk to the sockets layer. */
1285 SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1286 "chunk_up:", cmd->obj.ptr,
1287 "ulpq:", &asoc->ulpq);
1288 sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.ptr,
1292 case SCTP_CMD_EVENT_ULP:
1293 /* Send a notification to the sockets layer. */
1294 SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1295 "event_up:",cmd->obj.ptr,
1296 "ulpq:",&asoc->ulpq);
1297 sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ptr);
1300 case SCTP_CMD_REPLY:
1301 /* If an caller has not already corked, do cork. */
1302 if (!asoc->outqueue.cork) {
1303 sctp_outq_cork(&asoc->outqueue);
1306 /* Send a chunk to our peer. */
1307 error = sctp_outq_tail(&asoc->outqueue, cmd->obj.ptr);
1310 case SCTP_CMD_SEND_PKT:
1311 /* Send a full packet to our peer. */
1312 packet = cmd->obj.ptr;
1313 sctp_packet_transmit(packet);
1314 sctp_ootb_pkt_free(packet);
1317 case SCTP_CMD_T1_RETRAN:
1318 /* Mark a transport for retransmission. */
1319 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1323 case SCTP_CMD_RETRAN:
1324 /* Mark a transport for retransmission. */
1325 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1329 case SCTP_CMD_TRANSMIT:
1330 /* Kick start transmission. */
1331 error = sctp_outq_uncork(&asoc->outqueue);
1335 case SCTP_CMD_ECN_CE:
1336 /* Do delayed CE processing. */
1337 sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1340 case SCTP_CMD_ECN_ECNE:
1341 /* Do delayed ECNE processing. */
1342 new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1345 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1346 SCTP_CHUNK(new_obj));
1349 case SCTP_CMD_ECN_CWR:
1350 /* Do delayed CWR processing. */
1351 sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1354 case SCTP_CMD_SETUP_T2:
1355 sctp_cmd_setup_t2(commands, asoc, cmd->obj.ptr);
1358 case SCTP_CMD_TIMER_START:
1359 timer = &asoc->timers[cmd->obj.to];
1360 timeout = asoc->timeouts[cmd->obj.to];
1363 timer->expires = jiffies + timeout;
1364 sctp_association_hold(asoc);
1368 case SCTP_CMD_TIMER_RESTART:
1369 timer = &asoc->timers[cmd->obj.to];
1370 timeout = asoc->timeouts[cmd->obj.to];
1371 if (!mod_timer(timer, jiffies + timeout))
1372 sctp_association_hold(asoc);
1375 case SCTP_CMD_TIMER_STOP:
1376 timer = &asoc->timers[cmd->obj.to];
1377 if (timer_pending(timer) && del_timer(timer))
1378 sctp_association_put(asoc);
1381 case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
1382 chunk = cmd->obj.ptr;
1383 t = sctp_assoc_choose_init_transport(asoc);
1384 asoc->init_last_sent_to = t;
1385 chunk->transport = t;
1386 t->init_sent_count++;
1389 case SCTP_CMD_INIT_RESTART:
1390 /* Do the needed accounting and updates
1391 * associated with restarting an initialization
1392 * timer. Only multiply the timeout by two if
1393 * all transports have been tried at the current
1396 sctp_cmd_t1_timer_update(asoc,
1397 SCTP_EVENT_TIMEOUT_T1_INIT,
1400 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
1401 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1404 case SCTP_CMD_COOKIEECHO_RESTART:
1405 /* Do the needed accounting and updates
1406 * associated with restarting an initialization
1407 * timer. Only multiply the timeout by two if
1408 * all transports have been tried at the current
1411 sctp_cmd_t1_timer_update(asoc,
1412 SCTP_EVENT_TIMEOUT_T1_COOKIE,
1415 /* If we've sent any data bundled with
1416 * COOKIE-ECHO we need to resend.
1418 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1420 sctp_retransmit_mark(&asoc->outqueue, t,
1424 sctp_add_cmd_sf(commands,
1425 SCTP_CMD_TIMER_RESTART,
1426 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1429 case SCTP_CMD_INIT_FAILED:
1430 sctp_cmd_init_failed(commands, asoc, cmd->obj.err);
1433 case SCTP_CMD_ASSOC_FAILED:
1434 sctp_cmd_assoc_failed(commands, asoc, event_type,
1435 subtype, chunk, cmd->obj.err);
1438 case SCTP_CMD_INIT_COUNTER_INC:
1439 asoc->init_err_counter++;
1442 case SCTP_CMD_INIT_COUNTER_RESET:
1443 asoc->init_err_counter = 0;
1444 asoc->init_cycle = 0;
1445 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1447 t->init_sent_count = 0;
1451 case SCTP_CMD_REPORT_DUP:
1452 sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1456 case SCTP_CMD_REPORT_BAD_TAG:
1457 SCTP_DEBUG_PRINTK("vtag mismatch!\n");
1460 case SCTP_CMD_STRIKE:
1461 /* Mark one strike against a transport. */
1462 sctp_do_8_2_transport_strike(asoc, cmd->obj.transport);
1465 case SCTP_CMD_TRANSPORT_RESET:
1466 t = cmd->obj.transport;
1467 sctp_cmd_transport_reset(commands, asoc, t);
1470 case SCTP_CMD_TRANSPORT_ON:
1471 t = cmd->obj.transport;
1472 sctp_cmd_transport_on(commands, asoc, t, chunk);
1475 case SCTP_CMD_HB_TIMERS_START:
1476 sctp_cmd_hb_timers_start(commands, asoc);
1479 case SCTP_CMD_HB_TIMER_UPDATE:
1480 t = cmd->obj.transport;
1481 sctp_cmd_hb_timer_update(commands, t);
1484 case SCTP_CMD_HB_TIMERS_STOP:
1485 sctp_cmd_hb_timers_stop(commands, asoc);
1488 case SCTP_CMD_REPORT_ERROR:
1489 error = cmd->obj.error;
1492 case SCTP_CMD_PROCESS_CTSN:
1493 /* Dummy up a SACK for processing. */
1494 sackh.cum_tsn_ack = cmd->obj.be32;
1496 sackh.num_gap_ack_blocks = 0;
1497 sackh.num_dup_tsns = 0;
1498 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
1499 SCTP_SACKH(&sackh));
1502 case SCTP_CMD_DISCARD_PACKET:
1503 /* We need to discard the whole packet.
1504 * Uncork the queue since there might be
1507 chunk->pdiscard = 1;
1509 sctp_outq_uncork(&asoc->outqueue);
1514 case SCTP_CMD_RTO_PENDING:
1515 t = cmd->obj.transport;
1519 case SCTP_CMD_PART_DELIVER:
1520 sctp_ulpq_partial_delivery(&asoc->ulpq, cmd->obj.ptr,
1524 case SCTP_CMD_RENEGE:
1525 sctp_ulpq_renege(&asoc->ulpq, cmd->obj.ptr,
1529 case SCTP_CMD_SETUP_T4:
1530 sctp_cmd_setup_t4(commands, asoc, cmd->obj.ptr);
1533 case SCTP_CMD_PROCESS_OPERR:
1534 sctp_cmd_process_operr(commands, asoc, chunk);
1536 case SCTP_CMD_CLEAR_INIT_TAG:
1537 asoc->peer.i.init_tag = 0;
1539 case SCTP_CMD_DEL_NON_PRIMARY:
1540 sctp_cmd_del_non_primary(asoc);
1542 case SCTP_CMD_T3_RTX_TIMERS_STOP:
1543 sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1545 case SCTP_CMD_FORCE_PRIM_RETRAN:
1546 t = asoc->peer.retran_path;
1547 asoc->peer.retran_path = asoc->peer.primary_path;
1548 error = sctp_outq_uncork(&asoc->outqueue);
1550 asoc->peer.retran_path = t;
1552 case SCTP_CMD_SET_SK_ERR:
1553 sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1555 case SCTP_CMD_ASSOC_CHANGE:
1556 sctp_cmd_assoc_change(commands, asoc,
1559 case SCTP_CMD_ADAPTATION_IND:
1560 sctp_cmd_adaptation_ind(commands, asoc);
1563 case SCTP_CMD_ASSOC_SHKEY:
1564 error = sctp_auth_asoc_init_active_key(asoc,
1567 case SCTP_CMD_UPDATE_INITTAG:
1568 asoc->peer.i.init_tag = cmd->obj.u32;
1572 printk(KERN_WARNING "Impossible command: %u, %p\n",
1573 cmd->verb, cmd->obj.ptr);
1582 /* If this is in response to a received chunk, wait until
1583 * we are done with the packet to open the queue so that we don't
1584 * send multiple packets in response to a single request.
1586 if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {
1587 if (chunk->end_of_packet || chunk->singleton)
1588 sctp_outq_uncork(&asoc->outqueue);
1589 } else if (local_cork)
1590 sctp_outq_uncork(&asoc->outqueue);