Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sm_sideeffect.c
Go to the documentation of this file.
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 <[email protected]>
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 <[email protected]>
38  * Karl Knutson <[email protected]>
39  * Jon Grimm <[email protected]>
40  * Hui Huang <[email protected]>
41  * Dajiang Zhang <[email protected]>
42  * Daisy Chang <[email protected]>
43  * Sridhar Samudrala <[email protected]>
44  * Ardelle Fan <[email protected]>
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
51 
52 #include <linux/skbuff.h>
53 #include <linux/types.h>
54 #include <linux/socket.h>
55 #include <linux/ip.h>
56 #include <linux/gfp.h>
57 #include <net/sock.h>
58 #include <net/sctp/sctp.h>
59 #include <net/sctp/sm.h>
60 
61 static int sctp_cmd_interpreter(sctp_event_t event_type,
64  struct sctp_endpoint *ep,
65  struct sctp_association *asoc,
66  void *event_arg,
69  gfp_t gfp);
70 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
72  struct sctp_endpoint *ep,
73  struct sctp_association *asoc,
74  void *event_arg,
77  gfp_t gfp);
78 
79 static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
80  struct sctp_transport *t);
81 /********************************************************************
82  * Helper functions
83  ********************************************************************/
84 
85 /* A helper function for delayed processing of INET ECN CE bit. */
86 static void sctp_do_ecn_ce_work(struct sctp_association *asoc,
87  __u32 lowest_tsn)
88 {
89  /* Save the TSN away for comparison when we receive CWR */
90 
91  asoc->last_ecne_tsn = lowest_tsn;
92  asoc->need_ecne = 1;
93 }
94 
95 /* Helper function for delayed processing of SCTP ECNE chunk. */
96 /* RFC 2960 Appendix A
97  *
98  * RFC 2481 details a specific bit for a sender to send in
99  * the header of its next outbound TCP segment to indicate to
100  * its peer that it has reduced its congestion window. This
101  * is termed the CWR bit. For SCTP the same indication is made
102  * by including the CWR chunk. This chunk contains one data
103  * element, i.e. the TSN number that was sent in the ECNE chunk.
104  * This element represents the lowest TSN number in the datagram
105  * that was originally marked with the CE bit.
106  */
107 static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
108  __u32 lowest_tsn,
109  struct sctp_chunk *chunk)
110 {
111  struct sctp_chunk *repl;
112 
113  /* Our previously transmitted packet ran into some congestion
114  * so we should take action by reducing cwnd and ssthresh
115  * and then ACK our peer that we we've done so by
116  * sending a CWR.
117  */
118 
119  /* First, try to determine if we want to actually lower
120  * our cwnd variables. Only lower them if the ECNE looks more
121  * recent than the last response.
122  */
123  if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
124  struct sctp_transport *transport;
125 
126  /* Find which transport's congestion variables
127  * need to be adjusted.
128  */
129  transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
130 
131  /* Update the congestion variables. */
132  if (transport)
133  sctp_transport_lower_cwnd(transport,
135  asoc->last_cwr_tsn = lowest_tsn;
136  }
137 
138  /* Always try to quiet the other end. In case of lost CWR,
139  * resend last_cwr_tsn.
140  */
141  repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
142 
143  /* If we run out of memory, it will look like a lost CWR. We'll
144  * get back in sync eventually.
145  */
146  return repl;
147 }
148 
149 /* Helper function to do delayed processing of ECN CWR chunk. */
150 static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
151  __u32 lowest_tsn)
152 {
153  /* Turn off ECNE getting auto-prepended to every outgoing
154  * packet
155  */
156  asoc->need_ecne = 0;
157 }
158 
159 /* Generate SACK if necessary. We call this at the end of a packet. */
160 static int sctp_gen_sack(struct sctp_association *asoc, int force,
162 {
163  __u32 ctsn, max_tsn_seen;
164  struct sctp_chunk *sack;
165  struct sctp_transport *trans = asoc->peer.last_data_from;
166  int error = 0;
167 
168  if (force ||
169  (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) ||
170  (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE)))
171  asoc->peer.sack_needed = 1;
172 
173  ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
174  max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
175 
176  /* From 12.2 Parameters necessary per association (i.e. the TCB):
177  *
178  * Ack State : This flag indicates if the next received packet
179  * : is to be responded to with a SACK. ...
180  * : When DATA chunks are out of order, SACK's
181  * : are not delayed (see Section 6).
182  *
183  * [This is actually not mentioned in Section 6, but we
184  * implement it here anyway. --piggy]
185  */
186  if (max_tsn_seen != ctsn)
187  asoc->peer.sack_needed = 1;
188 
189  /* From 6.2 Acknowledgement on Reception of DATA Chunks:
190  *
191  * Section 4.2 of [RFC2581] SHOULD be followed. Specifically,
192  * an acknowledgement SHOULD be generated for at least every
193  * second packet (not every second DATA chunk) received, and
194  * SHOULD be generated within 200 ms of the arrival of any
195  * unacknowledged DATA chunk. ...
196  */
197  if (!asoc->peer.sack_needed) {
198  asoc->peer.sack_cnt++;
199 
200  /* Set the SACK delay timeout based on the
201  * SACK delay for the last transport
202  * data was received from, or the default
203  * for the association.
204  */
205  if (trans) {
206  /* We will need a SACK for the next packet. */
207  if (asoc->peer.sack_cnt >= trans->sackfreq - 1)
208  asoc->peer.sack_needed = 1;
209 
211  trans->sackdelay;
212  } else {
213  /* We will need a SACK for the next packet. */
214  if (asoc->peer.sack_cnt >= asoc->sackfreq - 1)
215  asoc->peer.sack_needed = 1;
216 
218  asoc->sackdelay;
219  }
220 
221  /* Restart the SACK timer. */
223  SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
224  } else {
225  asoc->a_rwnd = asoc->rwnd;
226  sack = sctp_make_sack(asoc);
227  if (!sack)
228  goto nomem;
229 
230  asoc->peer.sack_needed = 0;
231  asoc->peer.sack_cnt = 0;
232 
233  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
234 
235  /* Stop the SACK timer. */
237  SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
238  }
239 
240  return error;
241 nomem:
242  error = -ENOMEM;
243  return error;
244 }
245 
246 /* When the T3-RTX timer expires, it calls this function to create the
247  * relevant state machine event.
248  */
249 void sctp_generate_t3_rtx_event(unsigned long peer)
250 {
251  int error;
252  struct sctp_transport *transport = (struct sctp_transport *) peer;
253  struct sctp_association *asoc = transport->asoc;
254  struct net *net = sock_net(asoc->base.sk);
255 
256  /* Check whether a task is in the sock. */
257 
258  sctp_bh_lock_sock(asoc->base.sk);
259  if (sock_owned_by_user(asoc->base.sk)) {
260  SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
261 
262  /* Try again later. */
263  if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
264  sctp_transport_hold(transport);
265  goto out_unlock;
266  }
267 
268  /* Is this transport really dead and just waiting around for
269  * the timer to let go of the reference?
270  */
271  if (transport->dead)
272  goto out_unlock;
273 
274  /* Run through the state machine. */
275  error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
276  SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
277  asoc->state,
278  asoc->ep, asoc,
279  transport, GFP_ATOMIC);
280 
281  if (error)
282  asoc->base.sk->sk_err = -error;
283 
284 out_unlock:
285  sctp_bh_unlock_sock(asoc->base.sk);
286  sctp_transport_put(transport);
287 }
288 
289 /* This is a sa interface for producing timeout events. It works
290  * for timeouts which use the association as their parameter.
291  */
292 static void sctp_generate_timeout_event(struct sctp_association *asoc,
293  sctp_event_timeout_t timeout_type)
294 {
295  struct net *net = sock_net(asoc->base.sk);
296  int error = 0;
297 
298  sctp_bh_lock_sock(asoc->base.sk);
299  if (sock_owned_by_user(asoc->base.sk)) {
300  SCTP_DEBUG_PRINTK("%s:Sock is busy: timer %d\n",
301  __func__,
302  timeout_type);
303 
304  /* Try again later. */
305  if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
306  sctp_association_hold(asoc);
307  goto out_unlock;
308  }
309 
310  /* Is this association really dead and just waiting around for
311  * the timer to let go of the reference?
312  */
313  if (asoc->base.dead)
314  goto out_unlock;
315 
316  /* Run through the state machine. */
317  error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
318  SCTP_ST_TIMEOUT(timeout_type),
319  asoc->state, asoc->ep, asoc,
320  (void *)timeout_type, GFP_ATOMIC);
321 
322  if (error)
323  asoc->base.sk->sk_err = -error;
324 
325 out_unlock:
326  sctp_bh_unlock_sock(asoc->base.sk);
327  sctp_association_put(asoc);
328 }
329 
330 static void sctp_generate_t1_cookie_event(unsigned long data)
331 {
332  struct sctp_association *asoc = (struct sctp_association *) data;
333  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
334 }
335 
336 static void sctp_generate_t1_init_event(unsigned long data)
337 {
338  struct sctp_association *asoc = (struct sctp_association *) data;
339  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
340 }
341 
342 static void sctp_generate_t2_shutdown_event(unsigned long data)
343 {
344  struct sctp_association *asoc = (struct sctp_association *) data;
345  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
346 }
347 
348 static void sctp_generate_t4_rto_event(unsigned long data)
349 {
350  struct sctp_association *asoc = (struct sctp_association *) data;
351  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
352 }
353 
354 static void sctp_generate_t5_shutdown_guard_event(unsigned long data)
355 {
356  struct sctp_association *asoc = (struct sctp_association *)data;
357  sctp_generate_timeout_event(asoc,
359 
360 } /* sctp_generate_t5_shutdown_guard_event() */
361 
362 static void sctp_generate_autoclose_event(unsigned long data)
363 {
364  struct sctp_association *asoc = (struct sctp_association *) data;
365  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
366 }
367 
368 /* Generate a heart beat event. If the sock is busy, reschedule. Make
369  * sure that the transport is still valid.
370  */
372 {
373  int error = 0;
374  struct sctp_transport *transport = (struct sctp_transport *) data;
375  struct sctp_association *asoc = transport->asoc;
376  struct net *net = sock_net(asoc->base.sk);
377 
378  sctp_bh_lock_sock(asoc->base.sk);
379  if (sock_owned_by_user(asoc->base.sk)) {
380  SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
381 
382  /* Try again later. */
383  if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
384  sctp_transport_hold(transport);
385  goto out_unlock;
386  }
387 
388  /* Is this structure just waiting around for us to actually
389  * get destroyed?
390  */
391  if (transport->dead)
392  goto out_unlock;
393 
394  error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
395  SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
396  asoc->state, asoc->ep, asoc,
397  transport, GFP_ATOMIC);
398 
399  if (error)
400  asoc->base.sk->sk_err = -error;
401 
402 out_unlock:
403  sctp_bh_unlock_sock(asoc->base.sk);
404  sctp_transport_put(transport);
405 }
406 
407 /* Handle the timeout of the ICMP protocol unreachable timer. Trigger
408  * the correct state machine transition that will close the association.
409  */
411 {
412  struct sctp_transport *transport = (struct sctp_transport *) data;
413  struct sctp_association *asoc = transport->asoc;
414  struct net *net = sock_net(asoc->base.sk);
415 
416  sctp_bh_lock_sock(asoc->base.sk);
417  if (sock_owned_by_user(asoc->base.sk)) {
418  SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
419 
420  /* Try again later. */
421  if (!mod_timer(&transport->proto_unreach_timer,
422  jiffies + (HZ/20)))
423  sctp_association_hold(asoc);
424  goto out_unlock;
425  }
426 
427  /* Is this structure just waiting around for us to actually
428  * get destroyed?
429  */
430  if (asoc->base.dead)
431  goto out_unlock;
432 
434  SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
435  asoc->state, asoc->ep, asoc, transport, GFP_ATOMIC);
436 
437 out_unlock:
438  sctp_bh_unlock_sock(asoc->base.sk);
439  sctp_association_put(asoc);
440 }
441 
442 
443 /* Inject a SACK Timeout event into the state machine. */
444 static void sctp_generate_sack_event(unsigned long data)
445 {
446  struct sctp_association *asoc = (struct sctp_association *) data;
447  sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
448 }
449 
451  NULL,
452  sctp_generate_t1_cookie_event,
453  sctp_generate_t1_init_event,
454  sctp_generate_t2_shutdown_event,
455  NULL,
456  sctp_generate_t4_rto_event,
457  sctp_generate_t5_shutdown_guard_event,
458  NULL,
459  sctp_generate_sack_event,
460  sctp_generate_autoclose_event,
461 };
462 
463 
464 /* RFC 2960 8.2 Path Failure Detection
465  *
466  * When its peer endpoint is multi-homed, an endpoint should keep a
467  * error counter for each of the destination transport addresses of the
468  * peer endpoint.
469  *
470  * Each time the T3-rtx timer expires on any address, or when a
471  * HEARTBEAT sent to an idle address is not acknowledged within a RTO,
472  * the error counter of that destination address will be incremented.
473  * When the value in the error counter exceeds the protocol parameter
474  * 'Path.Max.Retrans' of that destination address, the endpoint should
475  * mark the destination transport address as inactive, and a
476  * notification SHOULD be sent to the upper layer.
477  *
478  */
479 static void sctp_do_8_2_transport_strike(sctp_cmd_seq_t *commands,
480  struct sctp_association *asoc,
481  struct sctp_transport *transport,
482  int is_hb)
483 {
484  /* The check for association's overall error counter exceeding the
485  * threshold is done in the state function.
486  */
487  /* We are here due to a timer expiration. If the timer was
488  * not a HEARTBEAT, then normal error tracking is done.
489  * If the timer was a heartbeat, we only increment error counts
490  * when we already have an outstanding HEARTBEAT that has not
491  * been acknowledged.
492  * Additionally, some tranport states inhibit error increments.
493  */
494  if (!is_hb) {
495  asoc->overall_error_count++;
496  if (transport->state != SCTP_INACTIVE)
497  transport->error_count++;
498  } else if (transport->hb_sent) {
499  if (transport->state != SCTP_UNCONFIRMED)
500  asoc->overall_error_count++;
501  if (transport->state != SCTP_INACTIVE)
502  transport->error_count++;
503  }
504 
505  /* If the transport error count is greater than the pf_retrans
506  * threshold, and less than pathmaxrtx, then mark this transport
507  * as Partially Failed, ee SCTP Quick Failover Draft, secon 5.1,
508  * point 1
509  */
510  if ((transport->state != SCTP_PF) &&
511  (asoc->pf_retrans < transport->pathmaxrxt) &&
512  (transport->error_count > asoc->pf_retrans)) {
513 
514  sctp_assoc_control_transport(asoc, transport,
516  0);
517 
518  /* Update the hb timer to resend a heartbeat every rto */
519  sctp_cmd_hb_timer_update(commands, transport);
520  }
521 
522  if (transport->state != SCTP_INACTIVE &&
523  (transport->error_count > transport->pathmaxrxt)) {
524  SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p",
525  " transport IP: port:%d failed.\n",
526  asoc,
527  (&transport->ipaddr),
528  ntohs(transport->ipaddr.v4.sin_port));
529  sctp_assoc_control_transport(asoc, transport,
532  }
533 
534  /* E2) For the destination address for which the timer
535  * expires, set RTO <- RTO * 2 ("back off the timer"). The
536  * maximum value discussed in rule C7 above (RTO.max) may be
537  * used to provide an upper bound to this doubling operation.
538  *
539  * Special Case: the first HB doesn't trigger exponential backoff.
540  * The first unacknowledged HB triggers it. We do this with a flag
541  * that indicates that we have an outstanding HB.
542  */
543  if (!is_hb || transport->hb_sent) {
544  transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
545  }
546 }
547 
548 /* Worker routine to handle INIT command failure. */
549 static void sctp_cmd_init_failed(sctp_cmd_seq_t *commands,
550  struct sctp_association *asoc,
551  unsigned int error)
552 {
553  struct sctp_ulpevent *event;
554 
556  (__u16)error, 0, 0, NULL,
557  GFP_ATOMIC);
558 
559  if (event)
561  SCTP_ULPEVENT(event));
562 
564  SCTP_STATE(SCTP_STATE_CLOSED));
565 
566  /* SEND_FAILED sent later when cleaning up the association. */
567  asoc->outqueue.error = error;
568  sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
569 }
570 
571 /* Worker routine to handle SCTP_CMD_ASSOC_FAILED. */
572 static void sctp_cmd_assoc_failed(sctp_cmd_seq_t *commands,
573  struct sctp_association *asoc,
576  struct sctp_chunk *chunk,
577  unsigned int error)
578 {
579  struct sctp_ulpevent *event;
580 
581  /* Cancel any partial delivery in progress. */
583 
584  if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)
586  (__u16)error, 0, 0, chunk,
587  GFP_ATOMIC);
588  else
590  (__u16)error, 0, 0, NULL,
591  GFP_ATOMIC);
592  if (event)
594  SCTP_ULPEVENT(event));
595 
597  SCTP_STATE(SCTP_STATE_CLOSED));
598 
599  /* SEND_FAILED sent later when cleaning up the association. */
600  asoc->outqueue.error = error;
601  sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
602 }
603 
604 /* Process an init chunk (may be real INIT/INIT-ACK or an embedded INIT
605  * inside the cookie. In reality, this is only used for INIT-ACK processing
606  * since all other cases use "temporary" associations and can do all
607  * their work in statefuns directly.
608  */
609 static int sctp_cmd_process_init(sctp_cmd_seq_t *commands,
610  struct sctp_association *asoc,
611  struct sctp_chunk *chunk,
612  sctp_init_chunk_t *peer_init,
613  gfp_t gfp)
614 {
615  int error;
616 
617  /* We only process the init as a sideeffect in a single
618  * case. This is when we process the INIT-ACK. If we
619  * fail during INIT processing (due to malloc problems),
620  * just return the error and stop processing the stack.
621  */
622  if (!sctp_process_init(asoc, chunk, sctp_source(chunk), peer_init, gfp))
623  error = -ENOMEM;
624  else
625  error = 0;
626 
627  return error;
628 }
629 
630 /* Helper function to break out starting up of heartbeat timers. */
631 static void sctp_cmd_hb_timers_start(sctp_cmd_seq_t *cmds,
632  struct sctp_association *asoc)
633 {
634  struct sctp_transport *t;
635 
636  /* Start a heartbeat timer for each transport on the association.
637  * hold a reference on the transport to make sure none of
638  * the needed data structures go away.
639  */
640  list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
641 
644  }
645 }
646 
647 static void sctp_cmd_hb_timers_stop(sctp_cmd_seq_t *cmds,
648  struct sctp_association *asoc)
649 {
650  struct sctp_transport *t;
651 
652  /* Stop all heartbeat timers. */
653 
654  list_for_each_entry(t, &asoc->peer.transport_addr_list,
655  transports) {
656  if (del_timer(&t->hb_timer))
658  }
659 }
660 
661 /* Helper function to stop any pending T3-RTX timers */
662 static void sctp_cmd_t3_rtx_timers_stop(sctp_cmd_seq_t *cmds,
663  struct sctp_association *asoc)
664 {
665  struct sctp_transport *t;
666 
667  list_for_each_entry(t, &asoc->peer.transport_addr_list,
668  transports) {
669  if (timer_pending(&t->T3_rtx_timer) &&
670  del_timer(&t->T3_rtx_timer)) {
672  }
673  }
674 }
675 
676 
677 /* Helper function to update the heartbeat timer. */
678 static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
679  struct sctp_transport *t)
680 {
681  /* Update the heartbeat timer. */
684 }
685 
686 /* Helper function to handle the reception of an HEARTBEAT ACK. */
687 static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
688  struct sctp_association *asoc,
689  struct sctp_transport *t,
690  struct sctp_chunk *chunk)
691 {
692  sctp_sender_hb_info_t *hbinfo;
693  int was_unconfirmed = 0;
694 
695  /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
696  * HEARTBEAT should clear the error counter of the destination
697  * transport address to which the HEARTBEAT was sent.
698  */
699  t->error_count = 0;
700 
701  /*
702  * Although RFC4960 specifies that the overall error count must
703  * be cleared when a HEARTBEAT ACK is received, we make an
704  * exception while in SHUTDOWN PENDING. If the peer keeps its
705  * window shut forever, we may never be able to transmit our
706  * outstanding data and rely on the retransmission limit be reached
707  * to shutdown the association.
708  */
709  if (t->asoc->state != SCTP_STATE_SHUTDOWN_PENDING)
710  t->asoc->overall_error_count = 0;
711 
712  /* Clear the hb_sent flag to signal that we had a good
713  * acknowledgement.
714  */
715  t->hb_sent = 0;
716 
717  /* Mark the destination transport address as active if it is not so
718  * marked.
719  */
720  if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED)) {
721  was_unconfirmed = 1;
724  }
725 
726  if (t->state == SCTP_PF)
729 
730  /* The receiver of the HEARTBEAT ACK should also perform an
731  * RTT measurement for that destination transport address
732  * using the time value carried in the HEARTBEAT ACK chunk.
733  * If the transport's rto_pending variable has been cleared,
734  * it was most likely due to a retransmit. However, we want
735  * to re-enable it to properly update the rto.
736  */
737  if (t->rto_pending == 0)
738  t->rto_pending = 1;
739 
740  hbinfo = (sctp_sender_hb_info_t *) chunk->skb->data;
741  sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
742 
743  /* Update the heartbeat timer. */
746 
747  if (was_unconfirmed && asoc->peer.transport_count == 1)
749 }
750 
751 
752 /* Helper function to process the process SACK command. */
753 static int sctp_cmd_process_sack(sctp_cmd_seq_t *cmds,
754  struct sctp_association *asoc,
755  struct sctp_chunk *chunk)
756 {
757  int err = 0;
758 
759  if (sctp_outq_sack(&asoc->outqueue, chunk)) {
760  struct net *net = sock_net(asoc->base.sk);
761 
762  /* There are no more TSNs awaiting SACK. */
763  err = sctp_do_sm(net, SCTP_EVENT_T_OTHER,
764  SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
765  asoc->state, asoc->ep, asoc, NULL,
766  GFP_ATOMIC);
767  }
768 
769  return err;
770 }
771 
772 /* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
773  * the transport for a shutdown chunk.
774  */
775 static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
776  struct sctp_association *asoc,
777  struct sctp_chunk *chunk)
778 {
779  struct sctp_transport *t;
780 
781  if (chunk->transport)
782  t = chunk->transport;
783  else {
785  asoc->shutdown_last_sent_to);
786  chunk->transport = t;
787  }
788  asoc->shutdown_last_sent_to = t;
790 }
791 
792 /* Helper function to change the state of an association. */
793 static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds,
794  struct sctp_association *asoc,
796 {
797  struct sock *sk = asoc->base.sk;
798 
799  asoc->state = state;
800 
801  SCTP_DEBUG_PRINTK("sctp_cmd_new_state: asoc %p[%s]\n",
802  asoc, sctp_state_tbl[state]);
803 
804  if (sctp_style(sk, TCP)) {
805  /* Change the sk->sk_state of a TCP-style socket that has
806  * successfully completed a connect() call.
807  */
808  if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
809  sk->sk_state = SCTP_SS_ESTABLISHED;
810 
811  /* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
812  if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
813  sctp_sstate(sk, ESTABLISHED))
814  sk->sk_shutdown |= RCV_SHUTDOWN;
815  }
816 
817  if (sctp_state(asoc, COOKIE_WAIT)) {
818  /* Reset init timeouts since they may have been
819  * increased due to timer expirations.
820  */
822  asoc->rto_initial;
824  asoc->rto_initial;
825  }
826 
827  if (sctp_state(asoc, ESTABLISHED) ||
828  sctp_state(asoc, CLOSED) ||
829  sctp_state(asoc, SHUTDOWN_RECEIVED)) {
830  /* Wake up any processes waiting in the asoc's wait queue in
831  * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
832  */
833  if (waitqueue_active(&asoc->wait))
834  wake_up_interruptible(&asoc->wait);
835 
836  /* Wake up any processes waiting in the sk's sleep queue of
837  * a TCP-style or UDP-style peeled-off socket in
838  * sctp_wait_for_accept() or sctp_wait_for_packet().
839  * For a UDP-style socket, the waiters are woken up by the
840  * notifications.
841  */
842  if (!sctp_style(sk, UDP))
843  sk->sk_state_change(sk);
844  }
845 }
846 
847 /* Helper function to delete an association. */
848 static void sctp_cmd_delete_tcb(sctp_cmd_seq_t *cmds,
849  struct sctp_association *asoc)
850 {
851  struct sock *sk = asoc->base.sk;
852 
853  /* If it is a non-temporary association belonging to a TCP-style
854  * listening socket that is not closed, do not free it so that accept()
855  * can pick it up later.
856  */
857  if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
858  (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
859  return;
860 
862  sctp_association_free(asoc);
863 }
864 
865 /*
866  * ADDIP Section 4.1 ASCONF Chunk Procedures
867  * A4) Start a T-4 RTO timer, using the RTO value of the selected
868  * destination address (we use active path instead of primary path just
869  * because primary path may be inactive.
870  */
871 static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
872  struct sctp_association *asoc,
873  struct sctp_chunk *chunk)
874 {
875  struct sctp_transport *t;
876 
879  chunk->transport = t;
880 }
881 
882 /* Process an incoming Operation Error Chunk. */
883 static void sctp_cmd_process_operr(sctp_cmd_seq_t *cmds,
884  struct sctp_association *asoc,
885  struct sctp_chunk *chunk)
886 {
887  struct sctp_errhdr *err_hdr;
888  struct sctp_ulpevent *ev;
889 
890  while (chunk->chunk_end > chunk->skb->data) {
891  err_hdr = (struct sctp_errhdr *)(chunk->skb->data);
892 
893  ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,
894  GFP_ATOMIC);
895  if (!ev)
896  return;
897 
898  sctp_ulpq_tail_event(&asoc->ulpq, ev);
899 
900  switch (err_hdr->cause) {
902  {
903  sctp_chunkhdr_t *unk_chunk_hdr;
904 
905  unk_chunk_hdr = (sctp_chunkhdr_t *)err_hdr->variable;
906  switch (unk_chunk_hdr->type) {
907  /* ADDIP 4.1 A9) If the peer responds to an ASCONF with
908  * an ERROR chunk reporting that it did not recognized
909  * the ASCONF chunk type, the sender of the ASCONF MUST
910  * NOT send any further ASCONF chunks and MUST stop its
911  * T-4 timer.
912  */
913  case SCTP_CID_ASCONF:
914  if (asoc->peer.asconf_capable == 0)
915  break;
916 
917  asoc->peer.asconf_capable = 0;
919  SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
920  break;
921  default:
922  break;
923  }
924  break;
925  }
926  default:
927  break;
928  }
929  }
930 }
931 
932 /* Process variable FWDTSN chunk information. */
933 static void sctp_cmd_process_fwdtsn(struct sctp_ulpq *ulpq,
934  struct sctp_chunk *chunk)
935 {
936  struct sctp_fwdtsn_skip *skip;
937  /* Walk through all the skipped SSNs */
938  sctp_walk_fwdtsn(skip, chunk) {
939  sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
940  }
941 }
942 
943 /* Helper function to remove the association non-primary peer
944  * transports.
945  */
946 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
947 {
948  struct sctp_transport *t;
949  struct list_head *pos;
950  struct list_head *temp;
951 
952  list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
953  t = list_entry(pos, struct sctp_transport, transports);
954  if (!sctp_cmp_addr_exact(&t->ipaddr,
955  &asoc->peer.primary_addr)) {
956  sctp_assoc_del_peer(asoc, &t->ipaddr);
957  }
958  }
959 }
960 
961 /* Helper function to set sk_err on a 1-1 style socket. */
962 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
963 {
964  struct sock *sk = asoc->base.sk;
965 
966  if (!sctp_style(sk, UDP))
967  sk->sk_err = error;
968 }
969 
970 /* Helper function to generate an association change event */
971 static void sctp_cmd_assoc_change(sctp_cmd_seq_t *commands,
972  struct sctp_association *asoc,
973  u8 state)
974 {
975  struct sctp_ulpevent *ev;
976 
977  ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
978  asoc->c.sinit_num_ostreams,
979  asoc->c.sinit_max_instreams,
980  NULL, GFP_ATOMIC);
981  if (ev)
982  sctp_ulpq_tail_event(&asoc->ulpq, ev);
983 }
984 
985 /* Helper function to generate an adaptation indication event */
986 static void sctp_cmd_adaptation_ind(sctp_cmd_seq_t *commands,
987  struct sctp_association *asoc)
988 {
989  struct sctp_ulpevent *ev;
990 
992 
993  if (ev)
994  sctp_ulpq_tail_event(&asoc->ulpq, ev);
995 }
996 
997 
998 static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
1000  char *name)
1001 {
1002  struct sctp_transport *t;
1003 
1004  t = asoc->init_last_sent_to;
1005  asoc->init_err_counter++;
1006 
1007  if (t->init_sent_count > (asoc->init_cycle + 1)) {
1008  asoc->timeouts[timer] *= 2;
1009  if (asoc->timeouts[timer] > asoc->max_init_timeo) {
1010  asoc->timeouts[timer] = asoc->max_init_timeo;
1011  }
1012  asoc->init_cycle++;
1014  "T1 %s Timeout adjustment"
1015  " init_err_counter: %d"
1016  " cycle: %d"
1017  " timeout: %ld\n",
1018  name,
1019  asoc->init_err_counter,
1020  asoc->init_cycle,
1021  asoc->timeouts[timer]);
1022  }
1023 
1024 }
1025 
1026 /* Send the whole message, chunk by chunk, to the outqueue.
1027  * This way the whole message is queued up and bundling if
1028  * encouraged for small fragments.
1029  */
1030 static int sctp_cmd_send_msg(struct sctp_association *asoc,
1031  struct sctp_datamsg *msg)
1032 {
1033  struct sctp_chunk *chunk;
1034  int error = 0;
1035 
1036  list_for_each_entry(chunk, &msg->chunks, frag_list) {
1037  error = sctp_outq_tail(&asoc->outqueue, chunk);
1038  if (error)
1039  break;
1040  }
1041 
1042  return error;
1043 }
1044 
1045 
1046 /* Sent the next ASCONF packet currently stored in the association.
1047  * This happens after the ASCONF_ACK was succeffully processed.
1048  */
1049 static void sctp_cmd_send_asconf(struct sctp_association *asoc)
1050 {
1051  struct net *net = sock_net(asoc->base.sk);
1052 
1053  /* Send the next asconf chunk from the addip chunk
1054  * queue.
1055  */
1056  if (!list_empty(&asoc->addip_chunk_list)) {
1057  struct list_head *entry = asoc->addip_chunk_list.next;
1058  struct sctp_chunk *asconf = list_entry(entry,
1059  struct sctp_chunk, list);
1060  list_del_init(entry);
1061 
1062  /* Hold the chunk until an ASCONF_ACK is received. */
1063  sctp_chunk_hold(asconf);
1064  if (sctp_primitive_ASCONF(net, asoc, asconf))
1065  sctp_chunk_free(asconf);
1066  else
1067  asoc->addip_last_asconf = asconf;
1068  }
1069 }
1070 
1071 
1072 /* These three macros allow us to pull the debugging code out of the
1073  * main flow of sctp_do_sm() to keep attention focused on the real
1074  * functionality there.
1075  */
1076 #define DEBUG_PRE \
1077  SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \
1078  "ep %p, %s, %s, asoc %p[%s], %s\n", \
1079  ep, sctp_evttype_tbl[event_type], \
1080  (*debug_fn)(subtype), asoc, \
1081  sctp_state_tbl[state], state_fn->name)
1082 
1083 #define DEBUG_POST \
1084  SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \
1085  "asoc %p, status: %s\n", \
1086  asoc, sctp_status_tbl[status])
1087 
1088 #define DEBUG_POST_SFX \
1089  SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \
1090  error, asoc, \
1091  sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
1092  sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED])
1093 
1094 /*
1095  * This is the master state machine processing function.
1096  *
1097  * If you want to understand all of lksctp, this is a
1098  * good place to start.
1099  */
1100 int sctp_do_sm(struct net *net, sctp_event_t event_type, sctp_subtype_t subtype,
1101  sctp_state_t state,
1102  struct sctp_endpoint *ep,
1103  struct sctp_association *asoc,
1104  void *event_arg,
1105  gfp_t gfp)
1106 {
1110  int error = 0;
1111  typedef const char *(printfn_t)(sctp_subtype_t);
1112 
1113  static printfn_t *table[] = {
1115  };
1116  printfn_t *debug_fn __attribute__ ((unused)) = table[event_type];
1117 
1118  /* Look up the state function, run it, and then process the
1119  * side effects. These three steps are the heart of lksctp.
1120  */
1121  state_fn = sctp_sm_lookup_event(net, event_type, state, subtype);
1122 
1123  sctp_init_cmd_seq(&commands);
1124 
1125  DEBUG_PRE;
1126  status = (*state_fn->fn)(net, ep, asoc, subtype, event_arg, &commands);
1127  DEBUG_POST;
1128 
1129  error = sctp_side_effects(event_type, subtype, state,
1130  ep, asoc, event_arg, status,
1131  &commands, gfp);
1133 
1134  return error;
1135 }
1136 
1137 #undef DEBUG_PRE
1138 #undef DEBUG_POST
1139 
1140 /*****************************************************************
1141  * This the master state function side effect processing function.
1142  *****************************************************************/
1143 static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
1144  sctp_state_t state,
1145  struct sctp_endpoint *ep,
1146  struct sctp_association *asoc,
1147  void *event_arg,
1149  sctp_cmd_seq_t *commands,
1150  gfp_t gfp)
1151 {
1152  int error;
1153 
1154  /* FIXME - Most of the dispositions left today would be categorized
1155  * as "exceptional" dispositions. For those dispositions, it
1156  * may not be proper to run through any of the commands at all.
1157  * For example, the command interpreter might be run only with
1158  * disposition SCTP_DISPOSITION_CONSUME.
1159  */
1160  if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
1161  ep, asoc,
1162  event_arg, status,
1163  commands, gfp)))
1164  goto bail;
1165 
1166  switch (status) {
1168  SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, "
1169  "event_type %d, event_id %d\n",
1170  state, event_type, subtype.chunk);
1171  break;
1172 
1174  /* We ran out of memory, so we need to discard this
1175  * packet.
1176  */
1177  /* BUG--we should now recover some memory, probably by
1178  * reneging...
1179  */
1180  error = -ENOMEM;
1181  break;
1182 
1184  /* This should now be a command. */
1185  break;
1186 
1189  /*
1190  * We should no longer have much work to do here as the
1191  * real work has been done as explicit commands above.
1192  */
1193  break;
1194 
1196  net_err_ratelimited("protocol violation state %d chunkid %d\n",
1197  state, subtype.chunk);
1198  break;
1199 
1201  pr_warn("unimplemented feature in state %d, event_type %d, event_id %d\n",
1202  state, event_type, subtype.chunk);
1203  break;
1204 
1205  case SCTP_DISPOSITION_BUG:
1206  pr_err("bug in state %d, event_type %d, event_id %d\n",
1207  state, event_type, subtype.chunk);
1208  BUG();
1209  break;
1210 
1211  default:
1212  pr_err("impossible disposition %d in state %d, event_type %d, event_id %d\n",
1213  status, state, event_type, subtype.chunk);
1214  BUG();
1215  break;
1216  }
1217 
1218 bail:
1219  return error;
1220 }
1221 
1222 /********************************************************************
1223  * 2nd Level Abstractions
1224  ********************************************************************/
1225 
1226 /* This is the side-effect interpreter. */
1227 static int sctp_cmd_interpreter(sctp_event_t event_type,
1228  sctp_subtype_t subtype,
1229  sctp_state_t state,
1230  struct sctp_endpoint *ep,
1231  struct sctp_association *asoc,
1232  void *event_arg,
1233  sctp_disposition_t status,
1234  sctp_cmd_seq_t *commands,
1235  gfp_t gfp)
1236 {
1237  int error = 0;
1238  int force;
1239  sctp_cmd_t *cmd;
1240  struct sctp_chunk *new_obj;
1241  struct sctp_chunk *chunk = NULL;
1242  struct sctp_packet *packet;
1243  struct timer_list *timer;
1244  unsigned long timeout;
1245  struct sctp_transport *t;
1246  struct sctp_sackhdr sackh;
1247  int local_cork = 0;
1248 
1249  if (SCTP_EVENT_T_TIMEOUT != event_type)
1250  chunk = event_arg;
1251 
1252  /* Note: This whole file is a huge candidate for rework.
1253  * For example, each command could either have its own handler, so
1254  * the loop would look like:
1255  * while (cmds)
1256  * cmd->handle(x, y, z)
1257  * --jgrimm
1258  */
1259  while (NULL != (cmd = sctp_next_cmd(commands))) {
1260  switch (cmd->verb) {
1261  case SCTP_CMD_NOP:
1262  /* Do nothing. */
1263  break;
1264 
1265  case SCTP_CMD_NEW_ASOC:
1266  /* Register a new association. */
1267  if (local_cork) {
1268  sctp_outq_uncork(&asoc->outqueue);
1269  local_cork = 0;
1270  }
1271  asoc = cmd->obj.ptr;
1272  /* Register with the endpoint. */
1273  sctp_endpoint_add_asoc(ep, asoc);
1274  sctp_hash_established(asoc);
1275  break;
1276 
1277  case SCTP_CMD_UPDATE_ASSOC:
1278  sctp_assoc_update(asoc, cmd->obj.ptr);
1279  break;
1280 
1282  sctp_outq_teardown(&asoc->outqueue);
1283  break;
1284 
1285  case SCTP_CMD_DELETE_TCB:
1286  if (local_cork) {
1287  sctp_outq_uncork(&asoc->outqueue);
1288  local_cork = 0;
1289  }
1290  /* Delete the current association. */
1291  sctp_cmd_delete_tcb(commands, asoc);
1292  asoc = NULL;
1293  break;
1294 
1295  case SCTP_CMD_NEW_STATE:
1296  /* Enter a new state. */
1297  sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1298  break;
1299 
1300  case SCTP_CMD_REPORT_TSN:
1301  /* Record the arrival of a TSN. */
1302  error = sctp_tsnmap_mark(&asoc->peer.tsn_map,
1303  cmd->obj.u32, NULL);
1304  break;
1305 
1307  /* Move the Cumulattive TSN Ack ahead. */
1308  sctp_tsnmap_skip(&asoc->peer.tsn_map, cmd->obj.u32);
1309 
1310  /* purge the fragmentation queue */
1311  sctp_ulpq_reasm_flushtsn(&asoc->ulpq, cmd->obj.u32);
1312 
1313  /* Abort any in progress partial delivery. */
1315  break;
1316 
1318  sctp_cmd_process_fwdtsn(&asoc->ulpq, cmd->obj.ptr);
1319  break;
1320 
1321  case SCTP_CMD_GEN_SACK:
1322  /* Generate a Selective ACK.
1323  * The argument tells us whether to just count
1324  * the packet and MAYBE generate a SACK, or
1325  * force a SACK out.
1326  */
1327  force = cmd->obj.i32;
1328  error = sctp_gen_sack(asoc, force, commands);
1329  break;
1330 
1331  case SCTP_CMD_PROCESS_SACK:
1332  /* Process an inbound SACK. */
1333  error = sctp_cmd_process_sack(commands, asoc,
1334  cmd->obj.ptr);
1335  break;
1336 
1337  case SCTP_CMD_GEN_INIT_ACK:
1338  /* Generate an INIT ACK chunk. */
1339  new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1340  0);
1341  if (!new_obj)
1342  goto nomem;
1343 
1344  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1345  SCTP_CHUNK(new_obj));
1346  break;
1347 
1348  case SCTP_CMD_PEER_INIT:
1349  /* Process a unified INIT from the peer.
1350  * Note: Only used during INIT-ACK processing. If
1351  * there is an error just return to the outter
1352  * layer which will bail.
1353  */
1354  error = sctp_cmd_process_init(commands, asoc, chunk,
1355  cmd->obj.ptr, gfp);
1356  break;
1357 
1359  /* Generate a COOKIE ECHO chunk. */
1360  new_obj = sctp_make_cookie_echo(asoc, chunk);
1361  if (!new_obj) {
1362  if (cmd->obj.ptr)
1363  sctp_chunk_free(cmd->obj.ptr);
1364  goto nomem;
1365  }
1366  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1367  SCTP_CHUNK(new_obj));
1368 
1369  /* If there is an ERROR chunk to be sent along with
1370  * the COOKIE_ECHO, send it, too.
1371  */
1372  if (cmd->obj.ptr)
1373  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1374  SCTP_CHUNK(cmd->obj.ptr));
1375 
1376  if (new_obj->transport) {
1377  new_obj->transport->init_sent_count++;
1378  asoc->init_last_sent_to = new_obj->transport;
1379  }
1380 
1381  /* FIXME - Eventually come up with a cleaner way to
1382  * enabling COOKIE-ECHO + DATA bundling during
1383  * multihoming stale cookie scenarios, the following
1384  * command plays with asoc->peer.retran_path to
1385  * avoid the problem of sending the COOKIE-ECHO and
1386  * DATA in different paths, which could result
1387  * in the association being ABORTed if the DATA chunk
1388  * is processed first by the server. Checking the
1389  * init error counter simply causes this command
1390  * to be executed only during failed attempts of
1391  * association establishment.
1392  */
1393  if ((asoc->peer.retran_path !=
1394  asoc->peer.primary_path) &&
1395  (asoc->init_err_counter > 0)) {
1396  sctp_add_cmd_sf(commands,
1398  SCTP_NULL());
1399  }
1400 
1401  break;
1402 
1403  case SCTP_CMD_GEN_SHUTDOWN:
1404  /* Generate SHUTDOWN when in SHUTDOWN_SENT state.
1405  * Reset error counts.
1406  */
1407  asoc->overall_error_count = 0;
1408 
1409  /* Generate a SHUTDOWN chunk. */
1410  new_obj = sctp_make_shutdown(asoc, chunk);
1411  if (!new_obj)
1412  goto nomem;
1413  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1414  SCTP_CHUNK(new_obj));
1415  break;
1416 
1417  case SCTP_CMD_CHUNK_ULP:
1418  /* Send a chunk to the sockets layer. */
1419  SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1420  "chunk_up:", cmd->obj.ptr,
1421  "ulpq:", &asoc->ulpq);
1422  sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.ptr,
1423  GFP_ATOMIC);
1424  break;
1425 
1426  case SCTP_CMD_EVENT_ULP:
1427  /* Send a notification to the sockets layer. */
1428  SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n",
1429  "event_up:",cmd->obj.ptr,
1430  "ulpq:",&asoc->ulpq);
1431  sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ptr);
1432  break;
1433 
1434  case SCTP_CMD_REPLY:
1435  /* If an caller has not already corked, do cork. */
1436  if (!asoc->outqueue.cork) {
1437  sctp_outq_cork(&asoc->outqueue);
1438  local_cork = 1;
1439  }
1440  /* Send a chunk to our peer. */
1441  error = sctp_outq_tail(&asoc->outqueue, cmd->obj.ptr);
1442  break;
1443 
1444  case SCTP_CMD_SEND_PKT:
1445  /* Send a full packet to our peer. */
1446  packet = cmd->obj.ptr;
1447  sctp_packet_transmit(packet);
1448  sctp_ootb_pkt_free(packet);
1449  break;
1450 
1451  case SCTP_CMD_T1_RETRAN:
1452  /* Mark a transport for retransmission. */
1453  sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1455  break;
1456 
1457  case SCTP_CMD_RETRAN:
1458  /* Mark a transport for retransmission. */
1459  sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1461  break;
1462 
1463  case SCTP_CMD_ECN_CE:
1464  /* Do delayed CE processing. */
1465  sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1466  break;
1467 
1468  case SCTP_CMD_ECN_ECNE:
1469  /* Do delayed ECNE processing. */
1470  new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1471  chunk);
1472  if (new_obj)
1473  sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1474  SCTP_CHUNK(new_obj));
1475  break;
1476 
1477  case SCTP_CMD_ECN_CWR:
1478  /* Do delayed CWR processing. */
1479  sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1480  break;
1481 
1482  case SCTP_CMD_SETUP_T2:
1483  sctp_cmd_setup_t2(commands, asoc, cmd->obj.ptr);
1484  break;
1485 
1487  timer = &asoc->timers[cmd->obj.to];
1488 
1489  if (timer_pending(timer))
1490  break;
1491  /* fall through */
1492 
1493  case SCTP_CMD_TIMER_START:
1494  timer = &asoc->timers[cmd->obj.to];
1495  timeout = asoc->timeouts[cmd->obj.to];
1496  BUG_ON(!timeout);
1497 
1498  timer->expires = jiffies + timeout;
1499  sctp_association_hold(asoc);
1500  add_timer(timer);
1501  break;
1502 
1504  timer = &asoc->timers[cmd->obj.to];
1505  timeout = asoc->timeouts[cmd->obj.to];
1506  if (!mod_timer(timer, jiffies + timeout))
1507  sctp_association_hold(asoc);
1508  break;
1509 
1510  case SCTP_CMD_TIMER_STOP:
1511  timer = &asoc->timers[cmd->obj.to];
1512  if (timer_pending(timer) && del_timer(timer))
1513  sctp_association_put(asoc);
1514  break;
1515 
1517  chunk = cmd->obj.ptr;
1519  asoc->init_last_sent_to);
1520  asoc->init_last_sent_to = t;
1521  chunk->transport = t;
1522  t->init_sent_count++;
1523  /* Set the new transport as primary */
1524  sctp_assoc_set_primary(asoc, t);
1525  break;
1526 
1527  case SCTP_CMD_INIT_RESTART:
1528  /* Do the needed accounting and updates
1529  * associated with restarting an initialization
1530  * timer. Only multiply the timeout by two if
1531  * all transports have been tried at the current
1532  * timeout.
1533  */
1534  sctp_cmd_t1_timer_update(asoc,
1536  "INIT");
1537 
1539  SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1540  break;
1541 
1543  /* Do the needed accounting and updates
1544  * associated with restarting an initialization
1545  * timer. Only multiply the timeout by two if
1546  * all transports have been tried at the current
1547  * timeout.
1548  */
1549  sctp_cmd_t1_timer_update(asoc,
1551  "COOKIE");
1552 
1553  /* If we've sent any data bundled with
1554  * COOKIE-ECHO we need to resend.
1555  */
1556  list_for_each_entry(t, &asoc->peer.transport_addr_list,
1557  transports) {
1558  sctp_retransmit_mark(&asoc->outqueue, t,
1560  }
1561 
1562  sctp_add_cmd_sf(commands,
1564  SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1565  break;
1566 
1567  case SCTP_CMD_INIT_FAILED:
1568  sctp_cmd_init_failed(commands, asoc, cmd->obj.err);
1569  break;
1570 
1571  case SCTP_CMD_ASSOC_FAILED:
1572  sctp_cmd_assoc_failed(commands, asoc, event_type,
1573  subtype, chunk, cmd->obj.err);
1574  break;
1575 
1577  asoc->init_err_counter++;
1578  break;
1579 
1581  asoc->init_err_counter = 0;
1582  asoc->init_cycle = 0;
1583  list_for_each_entry(t, &asoc->peer.transport_addr_list,
1584  transports) {
1585  t->init_sent_count = 0;
1586  }
1587  break;
1588 
1589  case SCTP_CMD_REPORT_DUP:
1590  sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1591  cmd->obj.u32);
1592  break;
1593 
1595  SCTP_DEBUG_PRINTK("vtag mismatch!\n");
1596  break;
1597 
1598  case SCTP_CMD_STRIKE:
1599  /* Mark one strike against a transport. */
1600  sctp_do_8_2_transport_strike(commands, asoc,
1601  cmd->obj.transport, 0);
1602  break;
1603 
1605  t = cmd->obj.transport;
1607  break;
1608 
1610  t = cmd->obj.transport;
1611  sctp_do_8_2_transport_strike(commands, asoc,
1612  t, 1);
1613  t->hb_sent = 1;
1614  break;
1615 
1616  case SCTP_CMD_TRANSPORT_ON:
1617  t = cmd->obj.transport;
1618  sctp_cmd_transport_on(commands, asoc, t, chunk);
1619  break;
1620 
1622  sctp_cmd_hb_timers_start(commands, asoc);
1623  break;
1624 
1626  t = cmd->obj.transport;
1627  sctp_cmd_hb_timer_update(commands, t);
1628  break;
1629 
1631  sctp_cmd_hb_timers_stop(commands, asoc);
1632  break;
1633 
1634  case SCTP_CMD_REPORT_ERROR:
1635  error = cmd->obj.error;
1636  break;
1637 
1638  case SCTP_CMD_PROCESS_CTSN:
1639  /* Dummy up a SACK for processing. */
1640  sackh.cum_tsn_ack = cmd->obj.be32;
1641  sackh.a_rwnd = asoc->peer.rwnd +
1642  asoc->outqueue.outstanding_bytes;
1643  sackh.num_gap_ack_blocks = 0;
1644  sackh.num_dup_tsns = 0;
1645  chunk->subh.sack_hdr = &sackh;
1647  SCTP_CHUNK(chunk));
1648  break;
1649 
1651  /* We need to discard the whole packet.
1652  * Uncork the queue since there might be
1653  * responses pending
1654  */
1655  chunk->pdiscard = 1;
1656  if (asoc) {
1657  sctp_outq_uncork(&asoc->outqueue);
1658  local_cork = 0;
1659  }
1660  break;
1661 
1662  case SCTP_CMD_RTO_PENDING:
1663  t = cmd->obj.transport;
1664  t->rto_pending = 1;
1665  break;
1666 
1667  case SCTP_CMD_PART_DELIVER:
1668  sctp_ulpq_partial_delivery(&asoc->ulpq, cmd->obj.ptr,
1669  GFP_ATOMIC);
1670  break;
1671 
1672  case SCTP_CMD_RENEGE:
1673  sctp_ulpq_renege(&asoc->ulpq, cmd->obj.ptr,
1674  GFP_ATOMIC);
1675  break;
1676 
1677  case SCTP_CMD_SETUP_T4:
1678  sctp_cmd_setup_t4(commands, asoc, cmd->obj.ptr);
1679  break;
1680 
1682  sctp_cmd_process_operr(commands, asoc, chunk);
1683  break;
1685  asoc->peer.i.init_tag = 0;
1686  break;
1688  sctp_cmd_del_non_primary(asoc);
1689  break;
1691  sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1692  break;
1694  t = asoc->peer.retran_path;
1695  asoc->peer.retran_path = asoc->peer.primary_path;
1696  error = sctp_outq_uncork(&asoc->outqueue);
1697  local_cork = 0;
1698  asoc->peer.retran_path = t;
1699  break;
1700  case SCTP_CMD_SET_SK_ERR:
1701  sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1702  break;
1703  case SCTP_CMD_ASSOC_CHANGE:
1704  sctp_cmd_assoc_change(commands, asoc,
1705  cmd->obj.u8);
1706  break;
1708  sctp_cmd_adaptation_ind(commands, asoc);
1709  break;
1710 
1711  case SCTP_CMD_ASSOC_SHKEY:
1712  error = sctp_auth_asoc_init_active_key(asoc,
1713  GFP_ATOMIC);
1714  break;
1716  asoc->peer.i.init_tag = cmd->obj.u32;
1717  break;
1718  case SCTP_CMD_SEND_MSG:
1719  if (!asoc->outqueue.cork) {
1720  sctp_outq_cork(&asoc->outqueue);
1721  local_cork = 1;
1722  }
1723  error = sctp_cmd_send_msg(asoc, cmd->obj.msg);
1724  break;
1726  sctp_cmd_send_asconf(asoc);
1727  break;
1730  break;
1731 
1732  case SCTP_CMD_SET_ASOC:
1733  asoc = cmd->obj.asoc;
1734  break;
1735 
1736  default:
1737  pr_warn("Impossible command: %u, %p\n",
1738  cmd->verb, cmd->obj.ptr);
1739  break;
1740  }
1741 
1742  if (error)
1743  break;
1744  }
1745 
1746 out:
1747  /* If this is in response to a received chunk, wait until
1748  * we are done with the packet to open the queue so that we don't
1749  * send multiple packets in response to a single request.
1750  */
1751  if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {
1752  if (chunk->end_of_packet || chunk->singleton)
1753  error = sctp_outq_uncork(&asoc->outqueue);
1754  } else if (local_cork)
1755  error = sctp_outq_uncork(&asoc->outqueue);
1756  return error;
1757 nomem:
1758  error = -ENOMEM;
1759  goto out;
1760 }
1761