xref: /openbmc/linux/net/sctp/sm_sideeffect.c (revision 22246614)
1 /* SCTP kernel implementation
2  * (C) Copyright IBM Corp. 2001, 2004
3  * Copyright (c) 1999 Cisco, Inc.
4  * Copyright (c) 1999-2001 Motorola, Inc.
5  *
6  * This file is part of the SCTP kernel implementation
7  *
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.
11  *
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)
16  * any later version.
17  *
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.
23  *
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.
28  *
29  * Please send any bug reports or fixes you make to the
30  * email address(es):
31  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
32  *
33  * Or submit a bug report through the following website:
34  *    http://www.sf.net/projects/lksctp
35  *
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>
45  *
46  * Any bugs reported given to us we will try to fix... any fixes shared will
47  * be incorporated into the next SCTP release.
48  */
49 
50 #include <linux/skbuff.h>
51 #include <linux/types.h>
52 #include <linux/socket.h>
53 #include <linux/ip.h>
54 #include <net/sock.h>
55 #include <net/sctp/sctp.h>
56 #include <net/sctp/sm.h>
57 
58 static int sctp_cmd_interpreter(sctp_event_t event_type,
59 				sctp_subtype_t subtype,
60 				sctp_state_t state,
61 				struct sctp_endpoint *ep,
62 				struct sctp_association *asoc,
63 				void *event_arg,
64 				sctp_disposition_t status,
65 				sctp_cmd_seq_t *commands,
66 				gfp_t gfp);
67 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
68 			     sctp_state_t state,
69 			     struct sctp_endpoint *ep,
70 			     struct sctp_association *asoc,
71 			     void *event_arg,
72 			     sctp_disposition_t status,
73 			     sctp_cmd_seq_t *commands,
74 			     gfp_t gfp);
75 
76 /********************************************************************
77  * Helper functions
78  ********************************************************************/
79 
80 /* A helper function for delayed processing of INET ECN CE bit. */
81 static void sctp_do_ecn_ce_work(struct sctp_association *asoc,
82 				__u32 lowest_tsn)
83 {
84 	/* Save the TSN away for comparison when we receive CWR */
85 
86 	asoc->last_ecne_tsn = lowest_tsn;
87 	asoc->need_ecne = 1;
88 }
89 
90 /* Helper function for delayed processing of SCTP ECNE chunk.  */
91 /* RFC 2960 Appendix A
92  *
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.
101  */
102 static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
103 					   __u32 lowest_tsn,
104 					   struct sctp_chunk *chunk)
105 {
106 	struct sctp_chunk *repl;
107 
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
111 	 * sending a CWR.
112 	 */
113 
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.
117 	 */
118 	if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
119 		struct sctp_transport *transport;
120 
121 		/* Find which transport's congestion variables
122 		 * need to be adjusted.
123 		 */
124 		transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
125 
126 		/* Update the congestion variables. */
127 		if (transport)
128 			sctp_transport_lower_cwnd(transport,
129 						  SCTP_LOWER_CWND_ECNE);
130 		asoc->last_cwr_tsn = lowest_tsn;
131 	}
132 
133 	/* Always try to quiet the other end.  In case of lost CWR,
134 	 * resend last_cwr_tsn.
135 	 */
136 	repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
137 
138 	/* If we run out of memory, it will look like a lost CWR.  We'll
139 	 * get back in sync eventually.
140 	 */
141 	return repl;
142 }
143 
144 /* Helper function to do delayed processing of ECN CWR chunk.  */
145 static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
146 				 __u32 lowest_tsn)
147 {
148 	/* Turn off ECNE getting auto-prepended to every outgoing
149 	 * packet
150 	 */
151 	asoc->need_ecne = 0;
152 }
153 
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)
157 {
158 	__u32 ctsn, max_tsn_seen;
159 	struct sctp_chunk *sack;
160 	struct sctp_transport *trans = asoc->peer.last_data_from;
161 	int error = 0;
162 
163 	if (force ||
164 	    (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) ||
165 	    (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE)))
166 		asoc->peer.sack_needed = 1;
167 
168 	ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
169 	max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
170 
171 	/* From 12.2 Parameters necessary per association (i.e. the TCB):
172 	 *
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).
177 	 *
178 	 * [This is actually not mentioned in Section 6, but we
179 	 * implement it here anyway. --piggy]
180 	 */
181 	if (max_tsn_seen != ctsn)
182 		asoc->peer.sack_needed = 1;
183 
184 	/* From 6.2  Acknowledgement on Reception of DATA Chunks:
185 	 *
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. ...
191 	 */
192 	if (!asoc->peer.sack_needed) {
193 		/* We will need a SACK for the next packet.  */
194 		asoc->peer.sack_needed = 1;
195 
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.
200 		 */
201 		if (trans)
202 			asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
203 				trans->sackdelay;
204 		else
205 			asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
206 				asoc->sackdelay;
207 
208 		/* Restart the SACK timer. */
209 		sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
210 				SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
211 	} else {
212 		if (asoc->a_rwnd > asoc->rwnd)
213 			asoc->a_rwnd = asoc->rwnd;
214 		sack = sctp_make_sack(asoc);
215 		if (!sack)
216 			goto nomem;
217 
218 		asoc->peer.sack_needed = 0;
219 
220 		sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
221 
222 		/* Stop the SACK timer.  */
223 		sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
224 				SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
225 	}
226 
227 	return error;
228 nomem:
229 	error = -ENOMEM;
230 	return error;
231 }
232 
233 /* When the T3-RTX timer expires, it calls this function to create the
234  * relevant state machine event.
235  */
236 void sctp_generate_t3_rtx_event(unsigned long peer)
237 {
238 	int error;
239 	struct sctp_transport *transport = (struct sctp_transport *) peer;
240 	struct sctp_association *asoc = transport->asoc;
241 
242 	/* Check whether a task is in the sock.  */
243 
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__);
247 
248 		/* Try again later.  */
249 		if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
250 			sctp_transport_hold(transport);
251 		goto out_unlock;
252 	}
253 
254 	/* Is this transport really dead and just waiting around for
255 	 * the timer to let go of the reference?
256 	 */
257 	if (transport->dead)
258 		goto out_unlock;
259 
260 	/* Run through the state machine.  */
261 	error = sctp_do_sm(SCTP_EVENT_T_TIMEOUT,
262 			   SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
263 			   asoc->state,
264 			   asoc->ep, asoc,
265 			   transport, GFP_ATOMIC);
266 
267 	if (error)
268 		asoc->base.sk->sk_err = -error;
269 
270 out_unlock:
271 	sctp_bh_unlock_sock(asoc->base.sk);
272 	sctp_transport_put(transport);
273 }
274 
275 /* This is a sa interface for producing timeout events.  It works
276  * for timeouts which use the association as their parameter.
277  */
278 static void sctp_generate_timeout_event(struct sctp_association *asoc,
279 					sctp_event_timeout_t timeout_type)
280 {
281 	int error = 0;
282 
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",
286 				  __func__,
287 				  timeout_type);
288 
289 		/* Try again later.  */
290 		if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
291 			sctp_association_hold(asoc);
292 		goto out_unlock;
293 	}
294 
295 	/* Is this association really dead and just waiting around for
296 	 * the timer to let go of the reference?
297 	 */
298 	if (asoc->base.dead)
299 		goto out_unlock;
300 
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);
306 
307 	if (error)
308 		asoc->base.sk->sk_err = -error;
309 
310 out_unlock:
311 	sctp_bh_unlock_sock(asoc->base.sk);
312 	sctp_association_put(asoc);
313 }
314 
315 static void sctp_generate_t1_cookie_event(unsigned long data)
316 {
317 	struct sctp_association *asoc = (struct sctp_association *) data;
318 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
319 }
320 
321 static void sctp_generate_t1_init_event(unsigned long data)
322 {
323 	struct sctp_association *asoc = (struct sctp_association *) data;
324 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
325 }
326 
327 static void sctp_generate_t2_shutdown_event(unsigned long data)
328 {
329 	struct sctp_association *asoc = (struct sctp_association *) data;
330 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
331 }
332 
333 static void sctp_generate_t4_rto_event(unsigned long data)
334 {
335 	struct sctp_association *asoc = (struct sctp_association *) data;
336 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
337 }
338 
339 static void sctp_generate_t5_shutdown_guard_event(unsigned long data)
340 {
341 	struct sctp_association *asoc = (struct sctp_association *)data;
342 	sctp_generate_timeout_event(asoc,
343 				    SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
344 
345 } /* sctp_generate_t5_shutdown_guard_event() */
346 
347 static void sctp_generate_autoclose_event(unsigned long data)
348 {
349 	struct sctp_association *asoc = (struct sctp_association *) data;
350 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
351 }
352 
353 /* Generate a heart beat event.  If the sock is busy, reschedule.   Make
354  * sure that the transport is still valid.
355  */
356 void sctp_generate_heartbeat_event(unsigned long data)
357 {
358 	int error = 0;
359 	struct sctp_transport *transport = (struct sctp_transport *) data;
360 	struct sctp_association *asoc = transport->asoc;
361 
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__);
365 
366 		/* Try again later.  */
367 		if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
368 			sctp_transport_hold(transport);
369 		goto out_unlock;
370 	}
371 
372 	/* Is this structure just waiting around for us to actually
373 	 * get destroyed?
374 	 */
375 	if (transport->dead)
376 		goto out_unlock;
377 
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);
382 
383 	 if (error)
384 		 asoc->base.sk->sk_err = -error;
385 
386 out_unlock:
387 	sctp_bh_unlock_sock(asoc->base.sk);
388 	sctp_transport_put(transport);
389 }
390 
391 /* Inject a SACK Timeout event into the state machine.  */
392 static void sctp_generate_sack_event(unsigned long data)
393 {
394 	struct sctp_association *asoc = (struct sctp_association *) data;
395 	sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
396 }
397 
398 sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
399 	NULL,
400 	sctp_generate_t1_cookie_event,
401 	sctp_generate_t1_init_event,
402 	sctp_generate_t2_shutdown_event,
403 	NULL,
404 	sctp_generate_t4_rto_event,
405 	sctp_generate_t5_shutdown_guard_event,
406 	NULL,
407 	sctp_generate_sack_event,
408 	sctp_generate_autoclose_event,
409 };
410 
411 
412 /* RFC 2960 8.2 Path Failure Detection
413  *
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
416  * peer endpoint.
417  *
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.
425  *
426  */
427 static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
428 					 struct sctp_transport *transport)
429 {
430 	/* The check for association's overall error counter exceeding the
431 	 * threshold is done in the state function.
432 	 */
433 	/* When probing UNCONFIRMED addresses, the association overall
434 	 * error count is NOT incremented
435 	 */
436 	if (transport->state != SCTP_UNCONFIRMED)
437 		asoc->overall_error_count++;
438 
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",
443 					 asoc,
444 					 (&transport->ipaddr),
445 					 ntohs(transport->ipaddr.v4.sin_port));
446 		sctp_assoc_control_transport(asoc, transport,
447 					     SCTP_TRANSPORT_DOWN,
448 					     SCTP_FAILED_THRESHOLD);
449 	}
450 
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.
455 	 */
456 	transport->last_rto = transport->rto;
457 	transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
458 }
459 
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,
463 				 unsigned error)
464 {
465 	struct sctp_ulpevent *event;
466 
467 	event = sctp_ulpevent_make_assoc_change(asoc,0, SCTP_CANT_STR_ASSOC,
468 						(__u16)error, 0, 0, NULL,
469 						GFP_ATOMIC);
470 
471 	if (event)
472 		sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
473 				SCTP_ULPEVENT(event));
474 
475 	sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
476 			SCTP_STATE(SCTP_STATE_CLOSED));
477 
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());
481 }
482 
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,
489 				  unsigned error)
490 {
491 	struct sctp_ulpevent *event;
492 
493 	/* Cancel any partial delivery in progress. */
494 	sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
495 
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,
499 						GFP_ATOMIC);
500 	else
501 		event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
502 						(__u16)error, 0, 0, NULL,
503 						GFP_ATOMIC);
504 	if (event)
505 		sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
506 				SCTP_ULPEVENT(event));
507 
508 	sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
509 			SCTP_STATE(SCTP_STATE_CLOSED));
510 
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());
514 }
515 
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.
520  */
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,
525 				 gfp_t gfp)
526 {
527 	int error;
528 
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.
533 	 */
534 	if (!sctp_process_init(asoc, chunk->chunk_hdr->type,
535 			       sctp_source(chunk), peer_init, gfp))
536 		error = -ENOMEM;
537 	else
538 		error = 0;
539 
540 	return error;
541 }
542 
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)
546 {
547 	struct sctp_transport *t;
548 
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.
552 	 */
553 	list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
554 
555 		if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
556 			sctp_transport_hold(t);
557 	}
558 }
559 
560 static void sctp_cmd_hb_timers_stop(sctp_cmd_seq_t *cmds,
561 				    struct sctp_association *asoc)
562 {
563 	struct sctp_transport *t;
564 
565 	/* Stop all heartbeat timers. */
566 
567 	list_for_each_entry(t, &asoc->peer.transport_addr_list,
568 			transports) {
569 		if (del_timer(&t->hb_timer))
570 			sctp_transport_put(t);
571 	}
572 }
573 
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)
577 {
578 	struct sctp_transport *t;
579 
580 	list_for_each_entry(t, &asoc->peer.transport_addr_list,
581 			transports) {
582 		if (timer_pending(&t->T3_rtx_timer) &&
583 		    del_timer(&t->T3_rtx_timer)) {
584 			sctp_transport_put(t);
585 		}
586 	}
587 }
588 
589 
590 /* Helper function to update the heartbeat timer. */
591 static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
592 				     struct sctp_transport *t)
593 {
594 	/* Update the heartbeat timer.  */
595 	if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
596 		sctp_transport_hold(t);
597 }
598 
599 /* Helper function to handle the reception of an HEARTBEAT ACK.  */
600 static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
601 				  struct sctp_association *asoc,
602 				  struct sctp_transport *t,
603 				  struct sctp_chunk *chunk)
604 {
605 	sctp_sender_hb_info_t *hbinfo;
606 
607 	/* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
608 	 * HEARTBEAT should clear the error counter of the destination
609 	 * transport address to which the HEARTBEAT was sent.
610 	 * The association's overall error count is also cleared.
611 	 */
612 	t->error_count = 0;
613 	t->asoc->overall_error_count = 0;
614 
615 	/* Mark the destination transport address as active if it is not so
616 	 * marked.
617 	 */
618 	if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED))
619 		sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
620 					     SCTP_HEARTBEAT_SUCCESS);
621 
622 	/* The receiver of the HEARTBEAT ACK should also perform an
623 	 * RTT measurement for that destination transport address
624 	 * using the time value carried in the HEARTBEAT ACK chunk.
625 	 * If the transport's rto_pending variable has been cleared,
626 	 * it was most likely due to a retransmit.  However, we want
627 	 * to re-enable it to properly update the rto.
628 	 */
629 	if (t->rto_pending == 0)
630 		t->rto_pending = 1;
631 
632 	hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
633 	sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
634 
635 	/* Update the heartbeat timer.  */
636 	if (!mod_timer(&t->hb_timer, sctp_transport_timeout(t)))
637 		sctp_transport_hold(t);
638 }
639 
640 /* Helper function to do a transport reset at the expiry of the hearbeat
641  * timer.
642  */
643 static void sctp_cmd_transport_reset(sctp_cmd_seq_t *cmds,
644 				     struct sctp_association *asoc,
645 				     struct sctp_transport *t)
646 {
647 	sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
648 
649 	/* Mark one strike against a transport.  */
650 	sctp_do_8_2_transport_strike(asoc, t);
651 }
652 
653 /* Helper function to process the process SACK command.  */
654 static int sctp_cmd_process_sack(sctp_cmd_seq_t *cmds,
655 				 struct sctp_association *asoc,
656 				 struct sctp_sackhdr *sackh)
657 {
658 	int err;
659 
660 	if (sctp_outq_sack(&asoc->outqueue, sackh)) {
661 		/* There are no more TSNs awaiting SACK.  */
662 		err = sctp_do_sm(SCTP_EVENT_T_OTHER,
663 				 SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
664 				 asoc->state, asoc->ep, asoc, NULL,
665 				 GFP_ATOMIC);
666 	} else {
667 		/* Windows may have opened, so we need
668 		 * to check if we have DATA to transmit
669 		 */
670 		err = sctp_outq_flush(&asoc->outqueue, 0);
671 	}
672 
673 	return err;
674 }
675 
676 /* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
677  * the transport for a shutdown chunk.
678  */
679 static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
680 			      struct sctp_association *asoc,
681 			      struct sctp_chunk *chunk)
682 {
683 	struct sctp_transport *t;
684 
685 	t = sctp_assoc_choose_shutdown_transport(asoc);
686 	asoc->shutdown_last_sent_to = t;
687 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
688 	chunk->transport = t;
689 }
690 
691 /* Helper function to change the state of an association. */
692 static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds,
693 			       struct sctp_association *asoc,
694 			       sctp_state_t state)
695 {
696 	struct sock *sk = asoc->base.sk;
697 
698 	asoc->state = state;
699 
700 	SCTP_DEBUG_PRINTK("sctp_cmd_new_state: asoc %p[%s]\n",
701 			  asoc, sctp_state_tbl[state]);
702 
703 	if (sctp_style(sk, TCP)) {
704 		/* Change the sk->sk_state of a TCP-style socket that has
705 		 * sucessfully completed a connect() call.
706 		 */
707 		if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
708 			sk->sk_state = SCTP_SS_ESTABLISHED;
709 
710 		/* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
711 		if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
712 		    sctp_sstate(sk, ESTABLISHED))
713 			sk->sk_shutdown |= RCV_SHUTDOWN;
714 	}
715 
716 	if (sctp_state(asoc, COOKIE_WAIT)) {
717 		/* Reset init timeouts since they may have been
718 		 * increased due to timer expirations.
719 		 */
720 		asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
721 						asoc->rto_initial;
722 		asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
723 						asoc->rto_initial;
724 	}
725 
726 	if (sctp_state(asoc, ESTABLISHED) ||
727 	    sctp_state(asoc, CLOSED) ||
728 	    sctp_state(asoc, SHUTDOWN_RECEIVED)) {
729 		/* Wake up any processes waiting in the asoc's wait queue in
730 		 * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
731 		 */
732 		if (waitqueue_active(&asoc->wait))
733 			wake_up_interruptible(&asoc->wait);
734 
735 		/* Wake up any processes waiting in the sk's sleep queue of
736 		 * a TCP-style or UDP-style peeled-off socket in
737 		 * sctp_wait_for_accept() or sctp_wait_for_packet().
738 		 * For a UDP-style socket, the waiters are woken up by the
739 		 * notifications.
740 		 */
741 		if (!sctp_style(sk, UDP))
742 			sk->sk_state_change(sk);
743 	}
744 }
745 
746 /* Helper function to delete an association. */
747 static void sctp_cmd_delete_tcb(sctp_cmd_seq_t *cmds,
748 				struct sctp_association *asoc)
749 {
750 	struct sock *sk = asoc->base.sk;
751 
752 	/* If it is a non-temporary association belonging to a TCP-style
753 	 * listening socket that is not closed, do not free it so that accept()
754 	 * can pick it up later.
755 	 */
756 	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
757 	    (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
758 		return;
759 
760 	sctp_unhash_established(asoc);
761 	sctp_association_free(asoc);
762 }
763 
764 /*
765  * ADDIP Section 4.1 ASCONF Chunk Procedures
766  * A4) Start a T-4 RTO timer, using the RTO value of the selected
767  * destination address (we use active path instead of primary path just
768  * because primary path may be inactive.
769  */
770 static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
771 				struct sctp_association *asoc,
772 				struct sctp_chunk *chunk)
773 {
774 	struct sctp_transport *t;
775 
776 	t = asoc->peer.active_path;
777 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
778 	chunk->transport = t;
779 }
780 
781 /* Process an incoming Operation Error Chunk. */
782 static void sctp_cmd_process_operr(sctp_cmd_seq_t *cmds,
783 				   struct sctp_association *asoc,
784 				   struct sctp_chunk *chunk)
785 {
786 	struct sctp_operr_chunk *operr_chunk;
787 	struct sctp_errhdr *err_hdr;
788 
789 	operr_chunk = (struct sctp_operr_chunk *)chunk->chunk_hdr;
790 	err_hdr = &operr_chunk->err_hdr;
791 
792 	switch (err_hdr->cause) {
793 	case SCTP_ERROR_UNKNOWN_CHUNK:
794 	{
795 		struct sctp_chunkhdr *unk_chunk_hdr;
796 
797 		unk_chunk_hdr = (struct sctp_chunkhdr *)err_hdr->variable;
798 		switch (unk_chunk_hdr->type) {
799 		/* ADDIP 4.1 A9) If the peer responds to an ASCONF with an
800 		 * ERROR chunk reporting that it did not recognized the ASCONF
801 		 * chunk type, the sender of the ASCONF MUST NOT send any
802 		 * further ASCONF chunks and MUST stop its T-4 timer.
803 		 */
804 		case SCTP_CID_ASCONF:
805 			asoc->peer.asconf_capable = 0;
806 			sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
807 					SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
808 			break;
809 		default:
810 			break;
811 		}
812 		break;
813 	}
814 	default:
815 		break;
816 	}
817 }
818 
819 /* Process variable FWDTSN chunk information. */
820 static void sctp_cmd_process_fwdtsn(struct sctp_ulpq *ulpq,
821 				    struct sctp_chunk *chunk)
822 {
823 	struct sctp_fwdtsn_skip *skip;
824 	/* Walk through all the skipped SSNs */
825 	sctp_walk_fwdtsn(skip, chunk) {
826 		sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
827 	}
828 
829 	return;
830 }
831 
832 /* Helper function to remove the association non-primary peer
833  * transports.
834  */
835 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
836 {
837 	struct sctp_transport *t;
838 	struct list_head *pos;
839 	struct list_head *temp;
840 
841 	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
842 		t = list_entry(pos, struct sctp_transport, transports);
843 		if (!sctp_cmp_addr_exact(&t->ipaddr,
844 					 &asoc->peer.primary_addr)) {
845 			sctp_assoc_del_peer(asoc, &t->ipaddr);
846 		}
847 	}
848 
849 	return;
850 }
851 
852 /* Helper function to set sk_err on a 1-1 style socket. */
853 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
854 {
855 	struct sock *sk = asoc->base.sk;
856 
857 	if (!sctp_style(sk, UDP))
858 		sk->sk_err = error;
859 }
860 
861 /* Helper function to generate an association change event */
862 static void sctp_cmd_assoc_change(sctp_cmd_seq_t *commands,
863 				 struct sctp_association *asoc,
864 				 u8 state)
865 {
866 	struct sctp_ulpevent *ev;
867 
868 	ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
869 					    asoc->c.sinit_num_ostreams,
870 					    asoc->c.sinit_max_instreams,
871 					    NULL, GFP_ATOMIC);
872 	if (ev)
873 		sctp_ulpq_tail_event(&asoc->ulpq, ev);
874 }
875 
876 /* Helper function to generate an adaptation indication event */
877 static void sctp_cmd_adaptation_ind(sctp_cmd_seq_t *commands,
878 				    struct sctp_association *asoc)
879 {
880 	struct sctp_ulpevent *ev;
881 
882 	ev = sctp_ulpevent_make_adaptation_indication(asoc, GFP_ATOMIC);
883 
884 	if (ev)
885 		sctp_ulpq_tail_event(&asoc->ulpq, ev);
886 }
887 
888 /* These three macros allow us to pull the debugging code out of the
889  * main flow of sctp_do_sm() to keep attention focused on the real
890  * functionality there.
891  */
892 #define DEBUG_PRE \
893 	SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \
894 			  "ep %p, %s, %s, asoc %p[%s], %s\n", \
895 			  ep, sctp_evttype_tbl[event_type], \
896 			  (*debug_fn)(subtype), asoc, \
897 			  sctp_state_tbl[state], state_fn->name)
898 
899 #define DEBUG_POST \
900 	SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \
901 			  "asoc %p, status: %s\n", \
902 			  asoc, sctp_status_tbl[status])
903 
904 #define DEBUG_POST_SFX \
905 	SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \
906 			  error, asoc, \
907 			  sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
908 			  sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED])
909 
910 /*
911  * This is the master state machine processing function.
912  *
913  * If you want to understand all of lksctp, this is a
914  * good place to start.
915  */
916 int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
917 	       sctp_state_t state,
918 	       struct sctp_endpoint *ep,
919 	       struct sctp_association *asoc,
920 	       void *event_arg,
921 	       gfp_t gfp)
922 {
923 	sctp_cmd_seq_t commands;
924 	const sctp_sm_table_entry_t *state_fn;
925 	sctp_disposition_t status;
926 	int error = 0;
927 	typedef const char *(printfn_t)(sctp_subtype_t);
928 
929 	static printfn_t *table[] = {
930 		NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
931 	};
932 	printfn_t *debug_fn  __attribute__ ((unused)) = table[event_type];
933 
934 	/* Look up the state function, run it, and then process the
935 	 * side effects.  These three steps are the heart of lksctp.
936 	 */
937 	state_fn = sctp_sm_lookup_event(event_type, state, subtype);
938 
939 	sctp_init_cmd_seq(&commands);
940 
941 	DEBUG_PRE;
942 	status = (*state_fn->fn)(ep, asoc, subtype, event_arg, &commands);
943 	DEBUG_POST;
944 
945 	error = sctp_side_effects(event_type, subtype, state,
946 				  ep, asoc, event_arg, status,
947 				  &commands, gfp);
948 	DEBUG_POST_SFX;
949 
950 	return error;
951 }
952 
953 #undef DEBUG_PRE
954 #undef DEBUG_POST
955 
956 /*****************************************************************
957  * This the master state function side effect processing function.
958  *****************************************************************/
959 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
960 			     sctp_state_t state,
961 			     struct sctp_endpoint *ep,
962 			     struct sctp_association *asoc,
963 			     void *event_arg,
964 			     sctp_disposition_t status,
965 			     sctp_cmd_seq_t *commands,
966 			     gfp_t gfp)
967 {
968 	int error;
969 
970 	/* FIXME - Most of the dispositions left today would be categorized
971 	 * as "exceptional" dispositions.  For those dispositions, it
972 	 * may not be proper to run through any of the commands at all.
973 	 * For example, the command interpreter might be run only with
974 	 * disposition SCTP_DISPOSITION_CONSUME.
975 	 */
976 	if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
977 					       ep, asoc,
978 					       event_arg, status,
979 					       commands, gfp)))
980 		goto bail;
981 
982 	switch (status) {
983 	case SCTP_DISPOSITION_DISCARD:
984 		SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, "
985 				  "event_type %d, event_id %d\n",
986 				  state, event_type, subtype.chunk);
987 		break;
988 
989 	case SCTP_DISPOSITION_NOMEM:
990 		/* We ran out of memory, so we need to discard this
991 		 * packet.
992 		 */
993 		/* BUG--we should now recover some memory, probably by
994 		 * reneging...
995 		 */
996 		error = -ENOMEM;
997 		break;
998 
999 	case SCTP_DISPOSITION_DELETE_TCB:
1000 		/* This should now be a command. */
1001 		break;
1002 
1003 	case SCTP_DISPOSITION_CONSUME:
1004 	case SCTP_DISPOSITION_ABORT:
1005 		/*
1006 		 * We should no longer have much work to do here as the
1007 		 * real work has been done as explicit commands above.
1008 		 */
1009 		break;
1010 
1011 	case SCTP_DISPOSITION_VIOLATION:
1012 		if (net_ratelimit())
1013 			printk(KERN_ERR "sctp protocol violation state %d "
1014 			       "chunkid %d\n", state, subtype.chunk);
1015 		break;
1016 
1017 	case SCTP_DISPOSITION_NOT_IMPL:
1018 		printk(KERN_WARNING "sctp unimplemented feature in state %d, "
1019 		       "event_type %d, event_id %d\n",
1020 		       state, event_type, subtype.chunk);
1021 		break;
1022 
1023 	case SCTP_DISPOSITION_BUG:
1024 		printk(KERN_ERR "sctp bug in state %d, "
1025 		       "event_type %d, event_id %d\n",
1026 		       state, event_type, subtype.chunk);
1027 		BUG();
1028 		break;
1029 
1030 	default:
1031 		printk(KERN_ERR "sctp impossible disposition %d "
1032 		       "in state %d, event_type %d, event_id %d\n",
1033 		       status, state, event_type, subtype.chunk);
1034 		BUG();
1035 		break;
1036 	}
1037 
1038 bail:
1039 	return error;
1040 }
1041 
1042 /********************************************************************
1043  * 2nd Level Abstractions
1044  ********************************************************************/
1045 
1046 /* This is the side-effect interpreter.  */
1047 static int sctp_cmd_interpreter(sctp_event_t event_type,
1048 				sctp_subtype_t subtype,
1049 				sctp_state_t state,
1050 				struct sctp_endpoint *ep,
1051 				struct sctp_association *asoc,
1052 				void *event_arg,
1053 				sctp_disposition_t status,
1054 				sctp_cmd_seq_t *commands,
1055 				gfp_t gfp)
1056 {
1057 	int error = 0;
1058 	int force;
1059 	sctp_cmd_t *cmd;
1060 	struct sctp_chunk *new_obj;
1061 	struct sctp_chunk *chunk = NULL;
1062 	struct sctp_packet *packet;
1063 	struct timer_list *timer;
1064 	unsigned long timeout;
1065 	struct sctp_transport *t;
1066 	struct sctp_sackhdr sackh;
1067 	int local_cork = 0;
1068 
1069 	if (SCTP_EVENT_T_TIMEOUT != event_type)
1070 		chunk = (struct sctp_chunk *) event_arg;
1071 
1072 	/* Note:  This whole file is a huge candidate for rework.
1073 	 * For example, each command could either have its own handler, so
1074 	 * the loop would look like:
1075 	 *     while (cmds)
1076 	 *         cmd->handle(x, y, z)
1077 	 * --jgrimm
1078 	 */
1079 	while (NULL != (cmd = sctp_next_cmd(commands))) {
1080 		switch (cmd->verb) {
1081 		case SCTP_CMD_NOP:
1082 			/* Do nothing. */
1083 			break;
1084 
1085 		case SCTP_CMD_NEW_ASOC:
1086 			/* Register a new association.  */
1087 			if (local_cork) {
1088 				sctp_outq_uncork(&asoc->outqueue);
1089 				local_cork = 0;
1090 			}
1091 			asoc = cmd->obj.ptr;
1092 			/* Register with the endpoint.  */
1093 			sctp_endpoint_add_asoc(ep, asoc);
1094 			sctp_hash_established(asoc);
1095 			break;
1096 
1097 		case SCTP_CMD_UPDATE_ASSOC:
1098 		       sctp_assoc_update(asoc, cmd->obj.ptr);
1099 		       break;
1100 
1101 		case SCTP_CMD_PURGE_OUTQUEUE:
1102 		       sctp_outq_teardown(&asoc->outqueue);
1103 		       break;
1104 
1105 		case SCTP_CMD_DELETE_TCB:
1106 			if (local_cork) {
1107 				sctp_outq_uncork(&asoc->outqueue);
1108 				local_cork = 0;
1109 			}
1110 			/* Delete the current association.  */
1111 			sctp_cmd_delete_tcb(commands, asoc);
1112 			asoc = NULL;
1113 			break;
1114 
1115 		case SCTP_CMD_NEW_STATE:
1116 			/* Enter a new state.  */
1117 			sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1118 			break;
1119 
1120 		case SCTP_CMD_REPORT_TSN:
1121 			/* Record the arrival of a TSN.  */
1122 			sctp_tsnmap_mark(&asoc->peer.tsn_map, cmd->obj.u32);
1123 			break;
1124 
1125 		case SCTP_CMD_REPORT_FWDTSN:
1126 			/* Move the Cumulattive TSN Ack ahead. */
1127 			sctp_tsnmap_skip(&asoc->peer.tsn_map, cmd->obj.u32);
1128 
1129 			/* purge the fragmentation queue */
1130 			sctp_ulpq_reasm_flushtsn(&asoc->ulpq, cmd->obj.u32);
1131 
1132 			/* Abort any in progress partial delivery. */
1133 			sctp_ulpq_abort_pd(&asoc->ulpq, GFP_ATOMIC);
1134 			break;
1135 
1136 		case SCTP_CMD_PROCESS_FWDTSN:
1137 			sctp_cmd_process_fwdtsn(&asoc->ulpq, cmd->obj.ptr);
1138 			break;
1139 
1140 		case SCTP_CMD_GEN_SACK:
1141 			/* Generate a Selective ACK.
1142 			 * The argument tells us whether to just count
1143 			 * the packet and MAYBE generate a SACK, or
1144 			 * force a SACK out.
1145 			 */
1146 			force = cmd->obj.i32;
1147 			error = sctp_gen_sack(asoc, force, commands);
1148 			break;
1149 
1150 		case SCTP_CMD_PROCESS_SACK:
1151 			/* Process an inbound SACK.  */
1152 			error = sctp_cmd_process_sack(commands, asoc,
1153 						      cmd->obj.ptr);
1154 			break;
1155 
1156 		case SCTP_CMD_GEN_INIT_ACK:
1157 			/* Generate an INIT ACK chunk.  */
1158 			new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1159 						     0);
1160 			if (!new_obj)
1161 				goto nomem;
1162 
1163 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1164 					SCTP_CHUNK(new_obj));
1165 			break;
1166 
1167 		case SCTP_CMD_PEER_INIT:
1168 			/* Process a unified INIT from the peer.
1169 			 * Note: Only used during INIT-ACK processing.  If
1170 			 * there is an error just return to the outter
1171 			 * layer which will bail.
1172 			 */
1173 			error = sctp_cmd_process_init(commands, asoc, chunk,
1174 						      cmd->obj.ptr, gfp);
1175 			break;
1176 
1177 		case SCTP_CMD_GEN_COOKIE_ECHO:
1178 			/* Generate a COOKIE ECHO chunk.  */
1179 			new_obj = sctp_make_cookie_echo(asoc, chunk);
1180 			if (!new_obj) {
1181 				if (cmd->obj.ptr)
1182 					sctp_chunk_free(cmd->obj.ptr);
1183 				goto nomem;
1184 			}
1185 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1186 					SCTP_CHUNK(new_obj));
1187 
1188 			/* If there is an ERROR chunk to be sent along with
1189 			 * the COOKIE_ECHO, send it, too.
1190 			 */
1191 			if (cmd->obj.ptr)
1192 				sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1193 						SCTP_CHUNK(cmd->obj.ptr));
1194 
1195 			/* FIXME - Eventually come up with a cleaner way to
1196 			 * enabling COOKIE-ECHO + DATA bundling during
1197 			 * multihoming stale cookie scenarios, the following
1198 			 * command plays with asoc->peer.retran_path to
1199 			 * avoid the problem of sending the COOKIE-ECHO and
1200 			 * DATA in different paths, which could result
1201 			 * in the association being ABORTed if the DATA chunk
1202 			 * is processed first by the server.  Checking the
1203 			 * init error counter simply causes this command
1204 			 * to be executed only during failed attempts of
1205 			 * association establishment.
1206 			 */
1207 			if ((asoc->peer.retran_path !=
1208 			     asoc->peer.primary_path) &&
1209 			    (asoc->init_err_counter > 0)) {
1210 				sctp_add_cmd_sf(commands,
1211 						SCTP_CMD_FORCE_PRIM_RETRAN,
1212 						SCTP_NULL());
1213 			}
1214 
1215 			break;
1216 
1217 		case SCTP_CMD_GEN_SHUTDOWN:
1218 			/* Generate SHUTDOWN when in SHUTDOWN_SENT state.
1219 			 * Reset error counts.
1220 			 */
1221 			asoc->overall_error_count = 0;
1222 
1223 			/* Generate a SHUTDOWN chunk.  */
1224 			new_obj = sctp_make_shutdown(asoc, chunk);
1225 			if (!new_obj)
1226 				goto nomem;
1227 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1228 					SCTP_CHUNK(new_obj));
1229 			break;
1230 
1231 		case SCTP_CMD_CHUNK_ULP:
1232 			/* Send a chunk to the sockets layer.  */
1233 			SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1234 					  "chunk_up:", cmd->obj.ptr,
1235 					  "ulpq:", &asoc->ulpq);
1236 			sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.ptr,
1237 					    GFP_ATOMIC);
1238 			break;
1239 
1240 		case SCTP_CMD_EVENT_ULP:
1241 			/* Send a notification to the sockets layer.  */
1242 			SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1243 					  "event_up:",cmd->obj.ptr,
1244 					  "ulpq:",&asoc->ulpq);
1245 			sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ptr);
1246 			break;
1247 
1248 		case SCTP_CMD_REPLY:
1249 			/* If an caller has not already corked, do cork. */
1250 			if (!asoc->outqueue.cork) {
1251 				sctp_outq_cork(&asoc->outqueue);
1252 				local_cork = 1;
1253 			}
1254 			/* Send a chunk to our peer.  */
1255 			error = sctp_outq_tail(&asoc->outqueue, cmd->obj.ptr);
1256 			break;
1257 
1258 		case SCTP_CMD_SEND_PKT:
1259 			/* Send a full packet to our peer.  */
1260 			packet = cmd->obj.ptr;
1261 			sctp_packet_transmit(packet);
1262 			sctp_ootb_pkt_free(packet);
1263 			break;
1264 
1265 		case SCTP_CMD_T1_RETRAN:
1266 			/* Mark a transport for retransmission.  */
1267 			sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1268 					SCTP_RTXR_T1_RTX);
1269 			break;
1270 
1271 		case SCTP_CMD_RETRAN:
1272 			/* Mark a transport for retransmission.  */
1273 			sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1274 					SCTP_RTXR_T3_RTX);
1275 			break;
1276 
1277 		case SCTP_CMD_TRANSMIT:
1278 			/* Kick start transmission. */
1279 			error = sctp_outq_uncork(&asoc->outqueue);
1280 			local_cork = 0;
1281 			break;
1282 
1283 		case SCTP_CMD_ECN_CE:
1284 			/* Do delayed CE processing.   */
1285 			sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1286 			break;
1287 
1288 		case SCTP_CMD_ECN_ECNE:
1289 			/* Do delayed ECNE processing. */
1290 			new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1291 							chunk);
1292 			if (new_obj)
1293 				sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1294 						SCTP_CHUNK(new_obj));
1295 			break;
1296 
1297 		case SCTP_CMD_ECN_CWR:
1298 			/* Do delayed CWR processing.  */
1299 			sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1300 			break;
1301 
1302 		case SCTP_CMD_SETUP_T2:
1303 			sctp_cmd_setup_t2(commands, asoc, cmd->obj.ptr);
1304 			break;
1305 
1306 		case SCTP_CMD_TIMER_START:
1307 			timer = &asoc->timers[cmd->obj.to];
1308 			timeout = asoc->timeouts[cmd->obj.to];
1309 			BUG_ON(!timeout);
1310 
1311 			timer->expires = jiffies + timeout;
1312 			sctp_association_hold(asoc);
1313 			add_timer(timer);
1314 			break;
1315 
1316 		case SCTP_CMD_TIMER_RESTART:
1317 			timer = &asoc->timers[cmd->obj.to];
1318 			timeout = asoc->timeouts[cmd->obj.to];
1319 			if (!mod_timer(timer, jiffies + timeout))
1320 				sctp_association_hold(asoc);
1321 			break;
1322 
1323 		case SCTP_CMD_TIMER_STOP:
1324 			timer = &asoc->timers[cmd->obj.to];
1325 			if (timer_pending(timer) && del_timer(timer))
1326 				sctp_association_put(asoc);
1327 			break;
1328 
1329 		case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
1330 			chunk = cmd->obj.ptr;
1331 			t = sctp_assoc_choose_init_transport(asoc);
1332 			asoc->init_last_sent_to = t;
1333 			chunk->transport = t;
1334 			t->init_sent_count++;
1335 			break;
1336 
1337 		case SCTP_CMD_INIT_RESTART:
1338 			/* Do the needed accounting and updates
1339 			 * associated with restarting an initialization
1340 			 * timer. Only multiply the timeout by two if
1341 			 * all transports have been tried at the current
1342 			 * timeout.
1343 			 */
1344 			t = asoc->init_last_sent_to;
1345 			asoc->init_err_counter++;
1346 
1347 			if (t->init_sent_count > (asoc->init_cycle + 1)) {
1348 				asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] *= 2;
1349 				if (asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] >
1350 				    asoc->max_init_timeo) {
1351 					asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
1352 						asoc->max_init_timeo;
1353 				}
1354 				asoc->init_cycle++;
1355 				SCTP_DEBUG_PRINTK(
1356 					"T1 INIT Timeout adjustment"
1357 					" init_err_counter: %d"
1358 					" cycle: %d"
1359 					" timeout: %ld\n",
1360 					asoc->init_err_counter,
1361 					asoc->init_cycle,
1362 					asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT]);
1363 			}
1364 
1365 			sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
1366 					SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1367 			break;
1368 
1369 		case SCTP_CMD_COOKIEECHO_RESTART:
1370 			/* Do the needed accounting and updates
1371 			 * associated with restarting an initialization
1372 			 * timer. Only multiply the timeout by two if
1373 			 * all transports have been tried at the current
1374 			 * timeout.
1375 			 */
1376 			asoc->init_err_counter++;
1377 
1378 			asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] *= 2;
1379 			if (asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] >
1380 			    asoc->max_init_timeo) {
1381 				asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
1382 					asoc->max_init_timeo;
1383 			}
1384 			SCTP_DEBUG_PRINTK(
1385 				"T1 COOKIE Timeout adjustment"
1386 				" init_err_counter: %d"
1387 				" timeout: %ld\n",
1388 				asoc->init_err_counter,
1389 				asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE]);
1390 
1391 			/* If we've sent any data bundled with
1392 			 * COOKIE-ECHO we need to resend.
1393 			 */
1394 			list_for_each_entry(t, &asoc->peer.transport_addr_list,
1395 					transports) {
1396 				sctp_retransmit_mark(&asoc->outqueue, t,
1397 					    SCTP_RTXR_T1_RTX);
1398 			}
1399 
1400 			sctp_add_cmd_sf(commands,
1401 					SCTP_CMD_TIMER_RESTART,
1402 					SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1403 			break;
1404 
1405 		case SCTP_CMD_INIT_FAILED:
1406 			sctp_cmd_init_failed(commands, asoc, cmd->obj.err);
1407 			break;
1408 
1409 		case SCTP_CMD_ASSOC_FAILED:
1410 			sctp_cmd_assoc_failed(commands, asoc, event_type,
1411 					      subtype, chunk, cmd->obj.err);
1412 			break;
1413 
1414 		case SCTP_CMD_INIT_COUNTER_INC:
1415 			asoc->init_err_counter++;
1416 			break;
1417 
1418 		case SCTP_CMD_INIT_COUNTER_RESET:
1419 			asoc->init_err_counter = 0;
1420 			asoc->init_cycle = 0;
1421 			break;
1422 
1423 		case SCTP_CMD_REPORT_DUP:
1424 			sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1425 					     cmd->obj.u32);
1426 			break;
1427 
1428 		case SCTP_CMD_REPORT_BAD_TAG:
1429 			SCTP_DEBUG_PRINTK("vtag mismatch!\n");
1430 			break;
1431 
1432 		case SCTP_CMD_STRIKE:
1433 			/* Mark one strike against a transport.  */
1434 			sctp_do_8_2_transport_strike(asoc, cmd->obj.transport);
1435 			break;
1436 
1437 		case SCTP_CMD_TRANSPORT_RESET:
1438 			t = cmd->obj.transport;
1439 			sctp_cmd_transport_reset(commands, asoc, t);
1440 			break;
1441 
1442 		case SCTP_CMD_TRANSPORT_ON:
1443 			t = cmd->obj.transport;
1444 			sctp_cmd_transport_on(commands, asoc, t, chunk);
1445 			break;
1446 
1447 		case SCTP_CMD_HB_TIMERS_START:
1448 			sctp_cmd_hb_timers_start(commands, asoc);
1449 			break;
1450 
1451 		case SCTP_CMD_HB_TIMER_UPDATE:
1452 			t = cmd->obj.transport;
1453 			sctp_cmd_hb_timer_update(commands, t);
1454 			break;
1455 
1456 		case SCTP_CMD_HB_TIMERS_STOP:
1457 			sctp_cmd_hb_timers_stop(commands, asoc);
1458 			break;
1459 
1460 		case SCTP_CMD_REPORT_ERROR:
1461 			error = cmd->obj.error;
1462 			break;
1463 
1464 		case SCTP_CMD_PROCESS_CTSN:
1465 			/* Dummy up a SACK for processing. */
1466 			sackh.cum_tsn_ack = cmd->obj.be32;
1467 			sackh.a_rwnd = 0;
1468 			sackh.num_gap_ack_blocks = 0;
1469 			sackh.num_dup_tsns = 0;
1470 			sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
1471 					SCTP_SACKH(&sackh));
1472 			break;
1473 
1474 		case SCTP_CMD_DISCARD_PACKET:
1475 			/* We need to discard the whole packet.  */
1476 			chunk->pdiscard = 1;
1477 			break;
1478 
1479 		case SCTP_CMD_RTO_PENDING:
1480 			t = cmd->obj.transport;
1481 			t->rto_pending = 1;
1482 			break;
1483 
1484 		case SCTP_CMD_PART_DELIVER:
1485 			sctp_ulpq_partial_delivery(&asoc->ulpq, cmd->obj.ptr,
1486 						   GFP_ATOMIC);
1487 			break;
1488 
1489 		case SCTP_CMD_RENEGE:
1490 			sctp_ulpq_renege(&asoc->ulpq, cmd->obj.ptr,
1491 					 GFP_ATOMIC);
1492 			break;
1493 
1494 		case SCTP_CMD_SETUP_T4:
1495 			sctp_cmd_setup_t4(commands, asoc, cmd->obj.ptr);
1496 			break;
1497 
1498 		case SCTP_CMD_PROCESS_OPERR:
1499 			sctp_cmd_process_operr(commands, asoc, chunk);
1500 			break;
1501 		case SCTP_CMD_CLEAR_INIT_TAG:
1502 			asoc->peer.i.init_tag = 0;
1503 			break;
1504 		case SCTP_CMD_DEL_NON_PRIMARY:
1505 			sctp_cmd_del_non_primary(asoc);
1506 			break;
1507 		case SCTP_CMD_T3_RTX_TIMERS_STOP:
1508 			sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1509 			break;
1510 		case SCTP_CMD_FORCE_PRIM_RETRAN:
1511 			t = asoc->peer.retran_path;
1512 			asoc->peer.retran_path = asoc->peer.primary_path;
1513 			error = sctp_outq_uncork(&asoc->outqueue);
1514 			local_cork = 0;
1515 			asoc->peer.retran_path = t;
1516 			break;
1517 		case SCTP_CMD_SET_SK_ERR:
1518 			sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1519 			break;
1520 		case SCTP_CMD_ASSOC_CHANGE:
1521 			sctp_cmd_assoc_change(commands, asoc,
1522 					      cmd->obj.u8);
1523 			break;
1524 		case SCTP_CMD_ADAPTATION_IND:
1525 			sctp_cmd_adaptation_ind(commands, asoc);
1526 			break;
1527 
1528 		case SCTP_CMD_ASSOC_SHKEY:
1529 			error = sctp_auth_asoc_init_active_key(asoc,
1530 						GFP_ATOMIC);
1531 			break;
1532 		case SCTP_CMD_UPDATE_INITTAG:
1533 			asoc->peer.i.init_tag = cmd->obj.u32;
1534 			break;
1535 
1536 		default:
1537 			printk(KERN_WARNING "Impossible command: %u, %p\n",
1538 			       cmd->verb, cmd->obj.ptr);
1539 			break;
1540 		}
1541 
1542 		if (error)
1543 			break;
1544 	}
1545 
1546 out:
1547 	if (local_cork)
1548 		sctp_outq_uncork(&asoc->outqueue);
1549 	return error;
1550 nomem:
1551 	error = -ENOMEM;
1552 	goto out;
1553 }
1554 
1555