This source file includes following definitions.
- sctp_do_ecn_ce_work
- sctp_do_ecn_ecne_work
- sctp_do_ecn_cwr_work
- sctp_gen_sack
- sctp_generate_t3_rtx_event
- sctp_generate_timeout_event
- sctp_generate_t1_cookie_event
- sctp_generate_t1_init_event
- sctp_generate_t2_shutdown_event
- sctp_generate_t4_rto_event
- sctp_generate_t5_shutdown_guard_event
- sctp_generate_autoclose_event
- sctp_generate_heartbeat_event
- sctp_generate_proto_unreach_event
- sctp_generate_reconf_event
- sctp_generate_sack_event
- sctp_do_8_2_transport_strike
- sctp_cmd_init_failed
- sctp_cmd_assoc_failed
- sctp_cmd_process_init
- sctp_cmd_hb_timers_start
- sctp_cmd_hb_timers_stop
- sctp_cmd_t3_rtx_timers_stop
- sctp_cmd_transport_on
- sctp_cmd_process_sack
- sctp_cmd_setup_t2
- sctp_cmd_assoc_update
- sctp_cmd_new_state
- sctp_cmd_delete_tcb
- sctp_cmd_setup_t4
- sctp_cmd_process_operr
- sctp_cmd_del_non_primary
- sctp_cmd_set_sk_err
- sctp_cmd_assoc_change
- sctp_cmd_peer_no_auth
- sctp_cmd_adaptation_ind
- sctp_cmd_t1_timer_update
- sctp_cmd_send_msg
- sctp_do_sm
- sctp_side_effects
- sctp_cmd_interpreter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30 #include <linux/skbuff.h>
31 #include <linux/types.h>
32 #include <linux/socket.h>
33 #include <linux/ip.h>
34 #include <linux/gfp.h>
35 #include <net/sock.h>
36 #include <net/sctp/sctp.h>
37 #include <net/sctp/sm.h>
38 #include <net/sctp/stream_sched.h>
39
40 static int sctp_cmd_interpreter(enum sctp_event_type event_type,
41 union sctp_subtype subtype,
42 enum sctp_state state,
43 struct sctp_endpoint *ep,
44 struct sctp_association *asoc,
45 void *event_arg,
46 enum sctp_disposition status,
47 struct sctp_cmd_seq *commands,
48 gfp_t gfp);
49 static int sctp_side_effects(enum sctp_event_type event_type,
50 union sctp_subtype subtype,
51 enum sctp_state state,
52 struct sctp_endpoint *ep,
53 struct sctp_association **asoc,
54 void *event_arg,
55 enum sctp_disposition status,
56 struct sctp_cmd_seq *commands,
57 gfp_t gfp);
58
59
60
61
62
63
64 static void sctp_do_ecn_ce_work(struct sctp_association *asoc,
65 __u32 lowest_tsn)
66 {
67
68
69 asoc->last_ecne_tsn = lowest_tsn;
70 asoc->need_ecne = 1;
71 }
72
73
74
75
76
77
78
79
80
81
82
83
84
85 static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
86 __u32 lowest_tsn,
87 struct sctp_chunk *chunk)
88 {
89 struct sctp_chunk *repl;
90
91
92
93
94
95
96
97
98
99
100
101 if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
102 struct sctp_transport *transport;
103
104
105
106
107 transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
108
109
110 if (transport)
111 sctp_transport_lower_cwnd(transport,
112 SCTP_LOWER_CWND_ECNE);
113 asoc->last_cwr_tsn = lowest_tsn;
114 }
115
116
117
118
119 repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
120
121
122
123
124 return repl;
125 }
126
127
128 static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
129 __u32 lowest_tsn)
130 {
131
132
133
134 asoc->need_ecne = 0;
135 }
136
137
138 static int sctp_gen_sack(struct sctp_association *asoc, int force,
139 struct sctp_cmd_seq *commands)
140 {
141 struct sctp_transport *trans = asoc->peer.last_data_from;
142 __u32 ctsn, max_tsn_seen;
143 struct sctp_chunk *sack;
144 int error = 0;
145
146 if (force ||
147 (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) ||
148 (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE)))
149 asoc->peer.sack_needed = 1;
150
151 ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
152 max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
153
154
155
156
157
158
159
160
161
162
163
164 if (max_tsn_seen != ctsn)
165 asoc->peer.sack_needed = 1;
166
167
168
169
170
171
172
173
174
175 if (!asoc->peer.sack_needed) {
176 asoc->peer.sack_cnt++;
177
178
179
180
181
182
183 if (trans) {
184
185 if (asoc->peer.sack_cnt >= trans->sackfreq - 1)
186 asoc->peer.sack_needed = 1;
187
188 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
189 trans->sackdelay;
190 } else {
191
192 if (asoc->peer.sack_cnt >= asoc->sackfreq - 1)
193 asoc->peer.sack_needed = 1;
194
195 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
196 asoc->sackdelay;
197 }
198
199
200 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
201 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
202 } else {
203 __u32 old_a_rwnd = asoc->a_rwnd;
204
205 asoc->a_rwnd = asoc->rwnd;
206 sack = sctp_make_sack(asoc);
207 if (!sack) {
208 asoc->a_rwnd = old_a_rwnd;
209 goto nomem;
210 }
211
212 asoc->peer.sack_needed = 0;
213 asoc->peer.sack_cnt = 0;
214
215 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
216
217
218 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
219 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
220 }
221
222 return error;
223 nomem:
224 error = -ENOMEM;
225 return error;
226 }
227
228
229
230
231 void sctp_generate_t3_rtx_event(struct timer_list *t)
232 {
233 struct sctp_transport *transport =
234 from_timer(transport, t, T3_rtx_timer);
235 struct sctp_association *asoc = transport->asoc;
236 struct sock *sk = asoc->base.sk;
237 struct net *net = sock_net(sk);
238 int error;
239
240
241
242 bh_lock_sock(sk);
243 if (sock_owned_by_user(sk)) {
244 pr_debug("%s: sock is busy\n", __func__);
245
246
247 if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
248 sctp_transport_hold(transport);
249 goto out_unlock;
250 }
251
252
253 error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
254 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
255 asoc->state,
256 asoc->ep, asoc,
257 transport, GFP_ATOMIC);
258
259 if (error)
260 sk->sk_err = -error;
261
262 out_unlock:
263 bh_unlock_sock(sk);
264 sctp_transport_put(transport);
265 }
266
267
268
269
270 static void sctp_generate_timeout_event(struct sctp_association *asoc,
271 enum sctp_event_timeout timeout_type)
272 {
273 struct sock *sk = asoc->base.sk;
274 struct net *net = sock_net(sk);
275 int error = 0;
276
277 bh_lock_sock(sk);
278 if (sock_owned_by_user(sk)) {
279 pr_debug("%s: sock is busy: timer %d\n", __func__,
280 timeout_type);
281
282
283 if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
284 sctp_association_hold(asoc);
285 goto out_unlock;
286 }
287
288
289
290
291 if (asoc->base.dead)
292 goto out_unlock;
293
294
295 error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
296 SCTP_ST_TIMEOUT(timeout_type),
297 asoc->state, asoc->ep, asoc,
298 (void *)timeout_type, GFP_ATOMIC);
299
300 if (error)
301 sk->sk_err = -error;
302
303 out_unlock:
304 bh_unlock_sock(sk);
305 sctp_association_put(asoc);
306 }
307
308 static void sctp_generate_t1_cookie_event(struct timer_list *t)
309 {
310 struct sctp_association *asoc =
311 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_COOKIE]);
312
313 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
314 }
315
316 static void sctp_generate_t1_init_event(struct timer_list *t)
317 {
318 struct sctp_association *asoc =
319 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_INIT]);
320
321 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
322 }
323
324 static void sctp_generate_t2_shutdown_event(struct timer_list *t)
325 {
326 struct sctp_association *asoc =
327 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN]);
328
329 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
330 }
331
332 static void sctp_generate_t4_rto_event(struct timer_list *t)
333 {
334 struct sctp_association *asoc =
335 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T4_RTO]);
336
337 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
338 }
339
340 static void sctp_generate_t5_shutdown_guard_event(struct timer_list *t)
341 {
342 struct sctp_association *asoc =
343 from_timer(asoc, t,
344 timers[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]);
345
346 sctp_generate_timeout_event(asoc,
347 SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
348
349 }
350
351 static void sctp_generate_autoclose_event(struct timer_list *t)
352 {
353 struct sctp_association *asoc =
354 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE]);
355
356 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
357 }
358
359
360
361
362 void sctp_generate_heartbeat_event(struct timer_list *t)
363 {
364 struct sctp_transport *transport = from_timer(transport, t, hb_timer);
365 struct sctp_association *asoc = transport->asoc;
366 struct sock *sk = asoc->base.sk;
367 struct net *net = sock_net(sk);
368 u32 elapsed, timeout;
369 int error = 0;
370
371 bh_lock_sock(sk);
372 if (sock_owned_by_user(sk)) {
373 pr_debug("%s: sock is busy\n", __func__);
374
375
376 if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
377 sctp_transport_hold(transport);
378 goto out_unlock;
379 }
380
381
382 elapsed = jiffies - transport->last_time_sent;
383 timeout = sctp_transport_timeout(transport);
384 if (elapsed < timeout) {
385 elapsed = timeout - elapsed;
386 if (!mod_timer(&transport->hb_timer, jiffies + elapsed))
387 sctp_transport_hold(transport);
388 goto out_unlock;
389 }
390
391 error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
392 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
393 asoc->state, asoc->ep, asoc,
394 transport, GFP_ATOMIC);
395
396 if (error)
397 sk->sk_err = -error;
398
399 out_unlock:
400 bh_unlock_sock(sk);
401 sctp_transport_put(transport);
402 }
403
404
405
406
407 void sctp_generate_proto_unreach_event(struct timer_list *t)
408 {
409 struct sctp_transport *transport =
410 from_timer(transport, t, proto_unreach_timer);
411 struct sctp_association *asoc = transport->asoc;
412 struct sock *sk = asoc->base.sk;
413 struct net *net = sock_net(sk);
414
415 bh_lock_sock(sk);
416 if (sock_owned_by_user(sk)) {
417 pr_debug("%s: sock is busy\n", __func__);
418
419
420 if (!mod_timer(&transport->proto_unreach_timer,
421 jiffies + (HZ/20)))
422 sctp_association_hold(asoc);
423 goto out_unlock;
424 }
425
426
427
428
429 if (asoc->base.dead)
430 goto out_unlock;
431
432 sctp_do_sm(net, SCTP_EVENT_T_OTHER,
433 SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
434 asoc->state, asoc->ep, asoc, transport, GFP_ATOMIC);
435
436 out_unlock:
437 bh_unlock_sock(sk);
438 sctp_association_put(asoc);
439 }
440
441
442 void sctp_generate_reconf_event(struct timer_list *t)
443 {
444 struct sctp_transport *transport =
445 from_timer(transport, t, reconf_timer);
446 struct sctp_association *asoc = transport->asoc;
447 struct sock *sk = asoc->base.sk;
448 struct net *net = sock_net(sk);
449 int error = 0;
450
451 bh_lock_sock(sk);
452 if (sock_owned_by_user(sk)) {
453 pr_debug("%s: sock is busy\n", __func__);
454
455
456 if (!mod_timer(&transport->reconf_timer, jiffies + (HZ / 20)))
457 sctp_transport_hold(transport);
458 goto out_unlock;
459 }
460
461 error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
462 SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_RECONF),
463 asoc->state, asoc->ep, asoc,
464 transport, GFP_ATOMIC);
465
466 if (error)
467 sk->sk_err = -error;
468
469 out_unlock:
470 bh_unlock_sock(sk);
471 sctp_transport_put(transport);
472 }
473
474
475 static void sctp_generate_sack_event(struct timer_list *t)
476 {
477 struct sctp_association *asoc =
478 from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_SACK]);
479
480 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
481 }
482
483 sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
484 [SCTP_EVENT_TIMEOUT_NONE] = NULL,
485 [SCTP_EVENT_TIMEOUT_T1_COOKIE] = sctp_generate_t1_cookie_event,
486 [SCTP_EVENT_TIMEOUT_T1_INIT] = sctp_generate_t1_init_event,
487 [SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = sctp_generate_t2_shutdown_event,
488 [SCTP_EVENT_TIMEOUT_T3_RTX] = NULL,
489 [SCTP_EVENT_TIMEOUT_T4_RTO] = sctp_generate_t4_rto_event,
490 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD] =
491 sctp_generate_t5_shutdown_guard_event,
492 [SCTP_EVENT_TIMEOUT_HEARTBEAT] = NULL,
493 [SCTP_EVENT_TIMEOUT_RECONF] = NULL,
494 [SCTP_EVENT_TIMEOUT_SACK] = sctp_generate_sack_event,
495 [SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sctp_generate_autoclose_event,
496 };
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514 static void sctp_do_8_2_transport_strike(struct sctp_cmd_seq *commands,
515 struct sctp_association *asoc,
516 struct sctp_transport *transport,
517 int is_hb)
518 {
519 struct net *net = sock_net(asoc->base.sk);
520
521
522
523
524
525
526
527
528
529
530
531 if (!is_hb) {
532 asoc->overall_error_count++;
533 if (transport->state != SCTP_INACTIVE)
534 transport->error_count++;
535 } else if (transport->hb_sent) {
536 if (transport->state != SCTP_UNCONFIRMED)
537 asoc->overall_error_count++;
538 if (transport->state != SCTP_INACTIVE)
539 transport->error_count++;
540 }
541
542
543
544
545
546
547 if (net->sctp.pf_enable &&
548 (transport->state == SCTP_ACTIVE) &&
549 (transport->error_count < transport->pathmaxrxt) &&
550 (transport->error_count > transport->pf_retrans)) {
551
552 sctp_assoc_control_transport(asoc, transport,
553 SCTP_TRANSPORT_PF,
554 0);
555
556
557 sctp_transport_reset_hb_timer(transport);
558 }
559
560 if (transport->state != SCTP_INACTIVE &&
561 (transport->error_count > transport->pathmaxrxt)) {
562 pr_debug("%s: association:%p transport addr:%pISpc failed\n",
563 __func__, asoc, &transport->ipaddr.sa);
564
565 sctp_assoc_control_transport(asoc, transport,
566 SCTP_TRANSPORT_DOWN,
567 SCTP_FAILED_THRESHOLD);
568 }
569
570
571
572
573
574
575
576
577
578
579 if (!is_hb || transport->hb_sent) {
580 transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
581 sctp_max_rto(asoc, transport);
582 }
583 }
584
585
586 static void sctp_cmd_init_failed(struct sctp_cmd_seq *commands,
587 struct sctp_association *asoc,
588 unsigned int error)
589 {
590 struct sctp_ulpevent *event;
591
592 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_CANT_STR_ASSOC,
593 (__u16)error, 0, 0, NULL,
594 GFP_ATOMIC);
595
596 if (event)
597 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
598 SCTP_ULPEVENT(event));
599
600 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
601 SCTP_STATE(SCTP_STATE_CLOSED));
602
603
604 asoc->outqueue.error = error;
605 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
606 }
607
608
609 static void sctp_cmd_assoc_failed(struct sctp_cmd_seq *commands,
610 struct sctp_association *asoc,
611 enum sctp_event_type event_type,
612 union sctp_subtype subtype,
613 struct sctp_chunk *chunk,
614 unsigned int error)
615 {
616 struct sctp_ulpevent *event;
617 struct sctp_chunk *abort;
618
619
620 asoc->stream.si->abort_pd(&asoc->ulpq, GFP_ATOMIC);
621
622 if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)
623 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
624 (__u16)error, 0, 0, chunk,
625 GFP_ATOMIC);
626 else
627 event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
628 (__u16)error, 0, 0, NULL,
629 GFP_ATOMIC);
630 if (event)
631 sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
632 SCTP_ULPEVENT(event));
633
634 if (asoc->overall_error_count >= asoc->max_retrans) {
635 abort = sctp_make_violation_max_retrans(asoc, chunk);
636 if (abort)
637 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
638 SCTP_CHUNK(abort));
639 }
640
641 sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
642 SCTP_STATE(SCTP_STATE_CLOSED));
643
644
645 asoc->outqueue.error = error;
646 sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
647 }
648
649
650
651
652
653
654 static int sctp_cmd_process_init(struct sctp_cmd_seq *commands,
655 struct sctp_association *asoc,
656 struct sctp_chunk *chunk,
657 struct sctp_init_chunk *peer_init,
658 gfp_t gfp)
659 {
660 int error;
661
662
663
664
665
666
667 if (!sctp_process_init(asoc, chunk, sctp_source(chunk), peer_init, gfp))
668 error = -ENOMEM;
669 else
670 error = 0;
671
672 return error;
673 }
674
675
676 static void sctp_cmd_hb_timers_start(struct sctp_cmd_seq *cmds,
677 struct sctp_association *asoc)
678 {
679 struct sctp_transport *t;
680
681
682
683
684
685 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
686 sctp_transport_reset_hb_timer(t);
687 }
688
689 static void sctp_cmd_hb_timers_stop(struct sctp_cmd_seq *cmds,
690 struct sctp_association *asoc)
691 {
692 struct sctp_transport *t;
693
694
695
696 list_for_each_entry(t, &asoc->peer.transport_addr_list,
697 transports) {
698 if (del_timer(&t->hb_timer))
699 sctp_transport_put(t);
700 }
701 }
702
703
704 static void sctp_cmd_t3_rtx_timers_stop(struct sctp_cmd_seq *cmds,
705 struct sctp_association *asoc)
706 {
707 struct sctp_transport *t;
708
709 list_for_each_entry(t, &asoc->peer.transport_addr_list,
710 transports) {
711 if (del_timer(&t->T3_rtx_timer))
712 sctp_transport_put(t);
713 }
714 }
715
716
717
718 static void sctp_cmd_transport_on(struct sctp_cmd_seq *cmds,
719 struct sctp_association *asoc,
720 struct sctp_transport *t,
721 struct sctp_chunk *chunk)
722 {
723 struct sctp_sender_hb_info *hbinfo;
724 int was_unconfirmed = 0;
725
726
727
728
729
730 t->error_count = 0;
731
732
733
734
735
736
737
738
739
740 if (t->asoc->state < SCTP_STATE_SHUTDOWN_PENDING)
741 t->asoc->overall_error_count = 0;
742
743
744
745
746 t->hb_sent = 0;
747
748
749
750
751 if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED)) {
752 was_unconfirmed = 1;
753 sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
754 SCTP_HEARTBEAT_SUCCESS);
755 }
756
757 if (t->state == SCTP_PF)
758 sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
759 SCTP_HEARTBEAT_SUCCESS);
760
761
762
763
764 if (t->dst)
765 sctp_transport_dst_confirm(t);
766
767
768
769
770
771
772
773
774 if (t->rto_pending == 0)
775 t->rto_pending = 1;
776
777 hbinfo = (struct sctp_sender_hb_info *)chunk->skb->data;
778 sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
779
780
781 sctp_transport_reset_hb_timer(t);
782
783 if (was_unconfirmed && asoc->peer.transport_count == 1)
784 sctp_transport_immediate_rtx(t);
785 }
786
787
788
789 static int sctp_cmd_process_sack(struct sctp_cmd_seq *cmds,
790 struct sctp_association *asoc,
791 struct sctp_chunk *chunk)
792 {
793 int err = 0;
794
795 if (sctp_outq_sack(&asoc->outqueue, chunk)) {
796 struct net *net = sock_net(asoc->base.sk);
797
798
799 err = sctp_do_sm(net, SCTP_EVENT_T_OTHER,
800 SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
801 asoc->state, asoc->ep, asoc, NULL,
802 GFP_ATOMIC);
803 }
804
805 return err;
806 }
807
808
809
810
811 static void sctp_cmd_setup_t2(struct sctp_cmd_seq *cmds,
812 struct sctp_association *asoc,
813 struct sctp_chunk *chunk)
814 {
815 struct sctp_transport *t;
816
817 if (chunk->transport)
818 t = chunk->transport;
819 else {
820 t = sctp_assoc_choose_alter_transport(asoc,
821 asoc->shutdown_last_sent_to);
822 chunk->transport = t;
823 }
824 asoc->shutdown_last_sent_to = t;
825 asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
826 }
827
828 static void sctp_cmd_assoc_update(struct sctp_cmd_seq *cmds,
829 struct sctp_association *asoc,
830 struct sctp_association *new)
831 {
832 struct net *net = sock_net(asoc->base.sk);
833 struct sctp_chunk *abort;
834
835 if (!sctp_assoc_update(asoc, new))
836 return;
837
838 abort = sctp_make_abort(asoc, NULL, sizeof(struct sctp_errhdr));
839 if (abort) {
840 sctp_init_cause(abort, SCTP_ERROR_RSRC_LOW, 0);
841 sctp_add_cmd_sf(cmds, SCTP_CMD_REPLY, SCTP_CHUNK(abort));
842 }
843 sctp_add_cmd_sf(cmds, SCTP_CMD_SET_SK_ERR, SCTP_ERROR(ECONNABORTED));
844 sctp_add_cmd_sf(cmds, SCTP_CMD_ASSOC_FAILED,
845 SCTP_PERR(SCTP_ERROR_RSRC_LOW));
846 SCTP_INC_STATS(net, SCTP_MIB_ABORTEDS);
847 SCTP_DEC_STATS(net, SCTP_MIB_CURRESTAB);
848 }
849
850
851 static void sctp_cmd_new_state(struct sctp_cmd_seq *cmds,
852 struct sctp_association *asoc,
853 enum sctp_state state)
854 {
855 struct sock *sk = asoc->base.sk;
856
857 asoc->state = state;
858
859 pr_debug("%s: asoc:%p[%s]\n", __func__, asoc, sctp_state_tbl[state]);
860
861 if (sctp_style(sk, TCP)) {
862
863
864
865 if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
866 inet_sk_set_state(sk, SCTP_SS_ESTABLISHED);
867
868
869 if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
870 sctp_sstate(sk, ESTABLISHED)) {
871 inet_sk_set_state(sk, SCTP_SS_CLOSING);
872 sk->sk_shutdown |= RCV_SHUTDOWN;
873 }
874 }
875
876 if (sctp_state(asoc, COOKIE_WAIT)) {
877
878
879
880 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
881 asoc->rto_initial;
882 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
883 asoc->rto_initial;
884 }
885
886 if (sctp_state(asoc, ESTABLISHED)) {
887 kfree(asoc->peer.cookie);
888 asoc->peer.cookie = NULL;
889 }
890
891 if (sctp_state(asoc, ESTABLISHED) ||
892 sctp_state(asoc, CLOSED) ||
893 sctp_state(asoc, SHUTDOWN_RECEIVED)) {
894
895
896
897 if (waitqueue_active(&asoc->wait))
898 wake_up_interruptible(&asoc->wait);
899
900
901
902
903
904
905
906 if (!sctp_style(sk, UDP))
907 sk->sk_state_change(sk);
908 }
909
910 if (sctp_state(asoc, SHUTDOWN_PENDING) &&
911 !sctp_outq_is_empty(&asoc->outqueue))
912 sctp_outq_uncork(&asoc->outqueue, GFP_ATOMIC);
913 }
914
915
916 static void sctp_cmd_delete_tcb(struct sctp_cmd_seq *cmds,
917 struct sctp_association *asoc)
918 {
919 struct sock *sk = asoc->base.sk;
920
921
922
923
924
925 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
926 (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
927 return;
928
929 sctp_association_free(asoc);
930 }
931
932
933
934
935
936
937
938 static void sctp_cmd_setup_t4(struct sctp_cmd_seq *cmds,
939 struct sctp_association *asoc,
940 struct sctp_chunk *chunk)
941 {
942 struct sctp_transport *t;
943
944 t = sctp_assoc_choose_alter_transport(asoc, chunk->transport);
945 asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
946 chunk->transport = t;
947 }
948
949
950 static void sctp_cmd_process_operr(struct sctp_cmd_seq *cmds,
951 struct sctp_association *asoc,
952 struct sctp_chunk *chunk)
953 {
954 struct sctp_errhdr *err_hdr;
955 struct sctp_ulpevent *ev;
956
957 while (chunk->chunk_end > chunk->skb->data) {
958 err_hdr = (struct sctp_errhdr *)(chunk->skb->data);
959
960 ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,
961 GFP_ATOMIC);
962 if (!ev)
963 return;
964
965 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
966
967 switch (err_hdr->cause) {
968 case SCTP_ERROR_UNKNOWN_CHUNK:
969 {
970 struct sctp_chunkhdr *unk_chunk_hdr;
971
972 unk_chunk_hdr = (struct sctp_chunkhdr *)
973 err_hdr->variable;
974 switch (unk_chunk_hdr->type) {
975
976
977
978
979
980
981 case SCTP_CID_ASCONF:
982 if (asoc->peer.asconf_capable == 0)
983 break;
984
985 asoc->peer.asconf_capable = 0;
986 sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
987 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
988 break;
989 default:
990 break;
991 }
992 break;
993 }
994 default:
995 break;
996 }
997 }
998 }
999
1000
1001
1002
1003 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
1004 {
1005 struct sctp_transport *t;
1006 struct list_head *temp;
1007 struct list_head *pos;
1008
1009 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
1010 t = list_entry(pos, struct sctp_transport, transports);
1011 if (!sctp_cmp_addr_exact(&t->ipaddr,
1012 &asoc->peer.primary_addr)) {
1013 sctp_assoc_rm_peer(asoc, t);
1014 }
1015 }
1016 }
1017
1018
1019 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
1020 {
1021 struct sock *sk = asoc->base.sk;
1022
1023 if (!sctp_style(sk, UDP))
1024 sk->sk_err = error;
1025 }
1026
1027
1028 static void sctp_cmd_assoc_change(struct sctp_cmd_seq *commands,
1029 struct sctp_association *asoc,
1030 u8 state)
1031 {
1032 struct sctp_ulpevent *ev;
1033
1034 ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
1035 asoc->c.sinit_num_ostreams,
1036 asoc->c.sinit_max_instreams,
1037 NULL, GFP_ATOMIC);
1038 if (ev)
1039 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1040 }
1041
1042 static void sctp_cmd_peer_no_auth(struct sctp_cmd_seq *commands,
1043 struct sctp_association *asoc)
1044 {
1045 struct sctp_ulpevent *ev;
1046
1047 ev = sctp_ulpevent_make_authkey(asoc, 0, SCTP_AUTH_NO_AUTH, GFP_ATOMIC);
1048 if (ev)
1049 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1050 }
1051
1052
1053 static void sctp_cmd_adaptation_ind(struct sctp_cmd_seq *commands,
1054 struct sctp_association *asoc)
1055 {
1056 struct sctp_ulpevent *ev;
1057
1058 ev = sctp_ulpevent_make_adaptation_indication(asoc, GFP_ATOMIC);
1059
1060 if (ev)
1061 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1062 }
1063
1064
1065 static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
1066 enum sctp_event_timeout timer,
1067 char *name)
1068 {
1069 struct sctp_transport *t;
1070
1071 t = asoc->init_last_sent_to;
1072 asoc->init_err_counter++;
1073
1074 if (t->init_sent_count > (asoc->init_cycle + 1)) {
1075 asoc->timeouts[timer] *= 2;
1076 if (asoc->timeouts[timer] > asoc->max_init_timeo) {
1077 asoc->timeouts[timer] = asoc->max_init_timeo;
1078 }
1079 asoc->init_cycle++;
1080
1081 pr_debug("%s: T1[%s] timeout adjustment init_err_counter:%d"
1082 " cycle:%d timeout:%ld\n", __func__, name,
1083 asoc->init_err_counter, asoc->init_cycle,
1084 asoc->timeouts[timer]);
1085 }
1086
1087 }
1088
1089
1090
1091
1092
1093 static void sctp_cmd_send_msg(struct sctp_association *asoc,
1094 struct sctp_datamsg *msg, gfp_t gfp)
1095 {
1096 struct sctp_chunk *chunk;
1097
1098 list_for_each_entry(chunk, &msg->chunks, frag_list)
1099 sctp_outq_tail(&asoc->outqueue, chunk, gfp);
1100
1101 asoc->outqueue.sched->enqueue(&asoc->outqueue, msg);
1102 }
1103
1104
1105
1106
1107
1108
1109 #define debug_pre_sfn() \
1110 pr_debug("%s[pre-fn]: ep:%p, %s, %s, asoc:%p[%s], %s\n", __func__, \
1111 ep, sctp_evttype_tbl[event_type], (*debug_fn)(subtype), \
1112 asoc, sctp_state_tbl[state], state_fn->name)
1113
1114 #define debug_post_sfn() \
1115 pr_debug("%s[post-fn]: asoc:%p, status:%s\n", __func__, asoc, \
1116 sctp_status_tbl[status])
1117
1118 #define debug_post_sfx() \
1119 pr_debug("%s[post-sfx]: error:%d, asoc:%p[%s]\n", __func__, error, \
1120 asoc, sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
1121 sctp_assoc2id(asoc))) ? asoc->state : SCTP_STATE_CLOSED])
1122
1123
1124
1125
1126
1127
1128
1129 int sctp_do_sm(struct net *net, enum sctp_event_type event_type,
1130 union sctp_subtype subtype, enum sctp_state state,
1131 struct sctp_endpoint *ep, struct sctp_association *asoc,
1132 void *event_arg, gfp_t gfp)
1133 {
1134 typedef const char *(printfn_t)(union sctp_subtype);
1135 static printfn_t *table[] = {
1136 NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
1137 };
1138 printfn_t *debug_fn __attribute__ ((unused)) = table[event_type];
1139 const struct sctp_sm_table_entry *state_fn;
1140 struct sctp_cmd_seq commands;
1141 enum sctp_disposition status;
1142 int error = 0;
1143
1144
1145
1146
1147 state_fn = sctp_sm_lookup_event(net, event_type, state, subtype);
1148
1149 sctp_init_cmd_seq(&commands);
1150
1151 debug_pre_sfn();
1152 status = state_fn->fn(net, ep, asoc, subtype, event_arg, &commands);
1153 debug_post_sfn();
1154
1155 error = sctp_side_effects(event_type, subtype, state,
1156 ep, &asoc, event_arg, status,
1157 &commands, gfp);
1158 debug_post_sfx();
1159
1160 return error;
1161 }
1162
1163
1164
1165
1166 static int sctp_side_effects(enum sctp_event_type event_type,
1167 union sctp_subtype subtype,
1168 enum sctp_state state,
1169 struct sctp_endpoint *ep,
1170 struct sctp_association **asoc,
1171 void *event_arg,
1172 enum sctp_disposition status,
1173 struct sctp_cmd_seq *commands,
1174 gfp_t gfp)
1175 {
1176 int error;
1177
1178
1179
1180
1181
1182
1183
1184 if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
1185 ep, *asoc,
1186 event_arg, status,
1187 commands, gfp)))
1188 goto bail;
1189
1190 switch (status) {
1191 case SCTP_DISPOSITION_DISCARD:
1192 pr_debug("%s: ignored sctp protocol event - state:%d, "
1193 "event_type:%d, event_id:%d\n", __func__, state,
1194 event_type, subtype.chunk);
1195 break;
1196
1197 case SCTP_DISPOSITION_NOMEM:
1198
1199
1200
1201
1202
1203
1204 error = -ENOMEM;
1205 break;
1206
1207 case SCTP_DISPOSITION_DELETE_TCB:
1208 case SCTP_DISPOSITION_ABORT:
1209
1210 *asoc = NULL;
1211 break;
1212
1213 case SCTP_DISPOSITION_CONSUME:
1214
1215
1216
1217
1218 break;
1219
1220 case SCTP_DISPOSITION_VIOLATION:
1221 net_err_ratelimited("protocol violation state %d chunkid %d\n",
1222 state, subtype.chunk);
1223 break;
1224
1225 case SCTP_DISPOSITION_NOT_IMPL:
1226 pr_warn("unimplemented feature in state %d, event_type %d, event_id %d\n",
1227 state, event_type, subtype.chunk);
1228 break;
1229
1230 case SCTP_DISPOSITION_BUG:
1231 pr_err("bug in state %d, event_type %d, event_id %d\n",
1232 state, event_type, subtype.chunk);
1233 BUG();
1234 break;
1235
1236 default:
1237 pr_err("impossible disposition %d in state %d, event_type %d, event_id %d\n",
1238 status, state, event_type, subtype.chunk);
1239 BUG();
1240 break;
1241 }
1242
1243 bail:
1244 return error;
1245 }
1246
1247
1248
1249
1250
1251
1252 static int sctp_cmd_interpreter(enum sctp_event_type event_type,
1253 union sctp_subtype subtype,
1254 enum sctp_state state,
1255 struct sctp_endpoint *ep,
1256 struct sctp_association *asoc,
1257 void *event_arg,
1258 enum sctp_disposition status,
1259 struct sctp_cmd_seq *commands,
1260 gfp_t gfp)
1261 {
1262 struct sctp_sock *sp = sctp_sk(ep->base.sk);
1263 struct sctp_chunk *chunk = NULL, *new_obj;
1264 struct sctp_packet *packet;
1265 struct sctp_sackhdr sackh;
1266 struct timer_list *timer;
1267 struct sctp_transport *t;
1268 unsigned long timeout;
1269 struct sctp_cmd *cmd;
1270 int local_cork = 0;
1271 int error = 0;
1272 int force;
1273
1274 if (SCTP_EVENT_T_TIMEOUT != event_type)
1275 chunk = event_arg;
1276
1277
1278
1279
1280
1281
1282
1283
1284 while (NULL != (cmd = sctp_next_cmd(commands))) {
1285 switch (cmd->verb) {
1286 case SCTP_CMD_NOP:
1287
1288 break;
1289
1290 case SCTP_CMD_NEW_ASOC:
1291
1292 if (local_cork) {
1293 sctp_outq_uncork(&asoc->outqueue, gfp);
1294 local_cork = 0;
1295 }
1296
1297
1298 asoc = cmd->obj.asoc;
1299 BUG_ON(asoc->peer.primary_path == NULL);
1300 sctp_endpoint_add_asoc(ep, asoc);
1301 break;
1302
1303 case SCTP_CMD_UPDATE_ASSOC:
1304 sctp_cmd_assoc_update(commands, asoc, cmd->obj.asoc);
1305 break;
1306
1307 case SCTP_CMD_PURGE_OUTQUEUE:
1308 sctp_outq_teardown(&asoc->outqueue);
1309 break;
1310
1311 case SCTP_CMD_DELETE_TCB:
1312 if (local_cork) {
1313 sctp_outq_uncork(&asoc->outqueue, gfp);
1314 local_cork = 0;
1315 }
1316
1317 sctp_cmd_delete_tcb(commands, asoc);
1318 asoc = NULL;
1319 break;
1320
1321 case SCTP_CMD_NEW_STATE:
1322
1323 sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1324 break;
1325
1326 case SCTP_CMD_REPORT_TSN:
1327
1328 error = sctp_tsnmap_mark(&asoc->peer.tsn_map,
1329 cmd->obj.u32, NULL);
1330 break;
1331
1332 case SCTP_CMD_REPORT_FWDTSN:
1333 asoc->stream.si->report_ftsn(&asoc->ulpq, cmd->obj.u32);
1334 break;
1335
1336 case SCTP_CMD_PROCESS_FWDTSN:
1337 asoc->stream.si->handle_ftsn(&asoc->ulpq,
1338 cmd->obj.chunk);
1339 break;
1340
1341 case SCTP_CMD_GEN_SACK:
1342
1343
1344
1345
1346
1347 force = cmd->obj.i32;
1348 error = sctp_gen_sack(asoc, force, commands);
1349 break;
1350
1351 case SCTP_CMD_PROCESS_SACK:
1352
1353 error = sctp_cmd_process_sack(commands, asoc,
1354 cmd->obj.chunk);
1355 break;
1356
1357 case SCTP_CMD_GEN_INIT_ACK:
1358
1359 new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1360 0);
1361 if (!new_obj) {
1362 error = -ENOMEM;
1363 break;
1364 }
1365
1366 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1367 SCTP_CHUNK(new_obj));
1368 break;
1369
1370 case SCTP_CMD_PEER_INIT:
1371
1372
1373
1374
1375
1376 error = sctp_cmd_process_init(commands, asoc, chunk,
1377 cmd->obj.init, gfp);
1378 break;
1379
1380 case SCTP_CMD_GEN_COOKIE_ECHO:
1381
1382 new_obj = sctp_make_cookie_echo(asoc, chunk);
1383 if (!new_obj) {
1384 if (cmd->obj.chunk)
1385 sctp_chunk_free(cmd->obj.chunk);
1386 error = -ENOMEM;
1387 break;
1388 }
1389 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1390 SCTP_CHUNK(new_obj));
1391
1392
1393
1394
1395 if (cmd->obj.chunk)
1396 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1397 SCTP_CHUNK(cmd->obj.chunk));
1398
1399 if (new_obj->transport) {
1400 new_obj->transport->init_sent_count++;
1401 asoc->init_last_sent_to = new_obj->transport;
1402 }
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416 if ((asoc->peer.retran_path !=
1417 asoc->peer.primary_path) &&
1418 (asoc->init_err_counter > 0)) {
1419 sctp_add_cmd_sf(commands,
1420 SCTP_CMD_FORCE_PRIM_RETRAN,
1421 SCTP_NULL());
1422 }
1423
1424 break;
1425
1426 case SCTP_CMD_GEN_SHUTDOWN:
1427
1428
1429
1430 asoc->overall_error_count = 0;
1431
1432
1433 new_obj = sctp_make_shutdown(asoc, chunk);
1434 if (!new_obj) {
1435 error = -ENOMEM;
1436 break;
1437 }
1438 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1439 SCTP_CHUNK(new_obj));
1440 break;
1441
1442 case SCTP_CMD_CHUNK_ULP:
1443
1444 pr_debug("%s: sm_sideff: chunk_up:%p, ulpq:%p\n",
1445 __func__, cmd->obj.chunk, &asoc->ulpq);
1446
1447 asoc->stream.si->ulpevent_data(&asoc->ulpq,
1448 cmd->obj.chunk,
1449 GFP_ATOMIC);
1450 break;
1451
1452 case SCTP_CMD_EVENT_ULP:
1453
1454 pr_debug("%s: sm_sideff: event_up:%p, ulpq:%p\n",
1455 __func__, cmd->obj.ulpevent, &asoc->ulpq);
1456
1457 asoc->stream.si->enqueue_event(&asoc->ulpq,
1458 cmd->obj.ulpevent);
1459 break;
1460
1461 case SCTP_CMD_REPLY:
1462
1463 if (!asoc->outqueue.cork) {
1464 sctp_outq_cork(&asoc->outqueue);
1465 local_cork = 1;
1466 }
1467
1468 sctp_outq_tail(&asoc->outqueue, cmd->obj.chunk, gfp);
1469 break;
1470
1471 case SCTP_CMD_SEND_PKT:
1472
1473 packet = cmd->obj.packet;
1474 sctp_packet_transmit(packet, gfp);
1475 sctp_ootb_pkt_free(packet);
1476 break;
1477
1478 case SCTP_CMD_T1_RETRAN:
1479
1480 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1481 SCTP_RTXR_T1_RTX);
1482 break;
1483
1484 case SCTP_CMD_RETRAN:
1485
1486 sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1487 SCTP_RTXR_T3_RTX);
1488 break;
1489
1490 case SCTP_CMD_ECN_CE:
1491
1492 sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1493 break;
1494
1495 case SCTP_CMD_ECN_ECNE:
1496
1497 new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1498 chunk);
1499 if (new_obj)
1500 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1501 SCTP_CHUNK(new_obj));
1502 break;
1503
1504 case SCTP_CMD_ECN_CWR:
1505
1506 sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1507 break;
1508
1509 case SCTP_CMD_SETUP_T2:
1510 sctp_cmd_setup_t2(commands, asoc, cmd->obj.chunk);
1511 break;
1512
1513 case SCTP_CMD_TIMER_START_ONCE:
1514 timer = &asoc->timers[cmd->obj.to];
1515
1516 if (timer_pending(timer))
1517 break;
1518
1519
1520 case SCTP_CMD_TIMER_START:
1521 timer = &asoc->timers[cmd->obj.to];
1522 timeout = asoc->timeouts[cmd->obj.to];
1523 BUG_ON(!timeout);
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533 if (!timer_pending(timer))
1534 sctp_association_hold(asoc);
1535 timer_reduce(timer, jiffies + timeout);
1536 break;
1537
1538 case SCTP_CMD_TIMER_RESTART:
1539 timer = &asoc->timers[cmd->obj.to];
1540 timeout = asoc->timeouts[cmd->obj.to];
1541 if (!mod_timer(timer, jiffies + timeout))
1542 sctp_association_hold(asoc);
1543 break;
1544
1545 case SCTP_CMD_TIMER_STOP:
1546 timer = &asoc->timers[cmd->obj.to];
1547 if (del_timer(timer))
1548 sctp_association_put(asoc);
1549 break;
1550
1551 case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
1552 chunk = cmd->obj.chunk;
1553 t = sctp_assoc_choose_alter_transport(asoc,
1554 asoc->init_last_sent_to);
1555 asoc->init_last_sent_to = t;
1556 chunk->transport = t;
1557 t->init_sent_count++;
1558
1559 sctp_assoc_set_primary(asoc, t);
1560 break;
1561
1562 case SCTP_CMD_INIT_RESTART:
1563
1564
1565
1566
1567
1568
1569 sctp_cmd_t1_timer_update(asoc,
1570 SCTP_EVENT_TIMEOUT_T1_INIT,
1571 "INIT");
1572
1573 sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
1574 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1575 break;
1576
1577 case SCTP_CMD_COOKIEECHO_RESTART:
1578
1579
1580
1581
1582
1583
1584 sctp_cmd_t1_timer_update(asoc,
1585 SCTP_EVENT_TIMEOUT_T1_COOKIE,
1586 "COOKIE");
1587
1588
1589
1590
1591 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1592 transports) {
1593 sctp_retransmit_mark(&asoc->outqueue, t,
1594 SCTP_RTXR_T1_RTX);
1595 }
1596
1597 sctp_add_cmd_sf(commands,
1598 SCTP_CMD_TIMER_RESTART,
1599 SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1600 break;
1601
1602 case SCTP_CMD_INIT_FAILED:
1603 sctp_cmd_init_failed(commands, asoc, cmd->obj.u32);
1604 break;
1605
1606 case SCTP_CMD_ASSOC_FAILED:
1607 sctp_cmd_assoc_failed(commands, asoc, event_type,
1608 subtype, chunk, cmd->obj.u32);
1609 break;
1610
1611 case SCTP_CMD_INIT_COUNTER_INC:
1612 asoc->init_err_counter++;
1613 break;
1614
1615 case SCTP_CMD_INIT_COUNTER_RESET:
1616 asoc->init_err_counter = 0;
1617 asoc->init_cycle = 0;
1618 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1619 transports) {
1620 t->init_sent_count = 0;
1621 }
1622 break;
1623
1624 case SCTP_CMD_REPORT_DUP:
1625 sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1626 cmd->obj.u32);
1627 break;
1628
1629 case SCTP_CMD_REPORT_BAD_TAG:
1630 pr_debug("%s: vtag mismatch!\n", __func__);
1631 break;
1632
1633 case SCTP_CMD_STRIKE:
1634
1635 sctp_do_8_2_transport_strike(commands, asoc,
1636 cmd->obj.transport, 0);
1637 break;
1638
1639 case SCTP_CMD_TRANSPORT_IDLE:
1640 t = cmd->obj.transport;
1641 sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
1642 break;
1643
1644 case SCTP_CMD_TRANSPORT_HB_SENT:
1645 t = cmd->obj.transport;
1646 sctp_do_8_2_transport_strike(commands, asoc,
1647 t, 1);
1648 t->hb_sent = 1;
1649 break;
1650
1651 case SCTP_CMD_TRANSPORT_ON:
1652 t = cmd->obj.transport;
1653 sctp_cmd_transport_on(commands, asoc, t, chunk);
1654 break;
1655
1656 case SCTP_CMD_HB_TIMERS_START:
1657 sctp_cmd_hb_timers_start(commands, asoc);
1658 break;
1659
1660 case SCTP_CMD_HB_TIMER_UPDATE:
1661 t = cmd->obj.transport;
1662 sctp_transport_reset_hb_timer(t);
1663 break;
1664
1665 case SCTP_CMD_HB_TIMERS_STOP:
1666 sctp_cmd_hb_timers_stop(commands, asoc);
1667 break;
1668
1669 case SCTP_CMD_REPORT_ERROR:
1670 error = cmd->obj.error;
1671 break;
1672
1673 case SCTP_CMD_PROCESS_CTSN:
1674
1675 sackh.cum_tsn_ack = cmd->obj.be32;
1676 sackh.a_rwnd = htonl(asoc->peer.rwnd +
1677 asoc->outqueue.outstanding_bytes);
1678 sackh.num_gap_ack_blocks = 0;
1679 sackh.num_dup_tsns = 0;
1680 chunk->subh.sack_hdr = &sackh;
1681 sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
1682 SCTP_CHUNK(chunk));
1683 break;
1684
1685 case SCTP_CMD_DISCARD_PACKET:
1686
1687
1688
1689
1690 chunk->pdiscard = 1;
1691 if (asoc) {
1692 sctp_outq_uncork(&asoc->outqueue, gfp);
1693 local_cork = 0;
1694 }
1695 break;
1696
1697 case SCTP_CMD_RTO_PENDING:
1698 t = cmd->obj.transport;
1699 t->rto_pending = 1;
1700 break;
1701
1702 case SCTP_CMD_PART_DELIVER:
1703 asoc->stream.si->start_pd(&asoc->ulpq, GFP_ATOMIC);
1704 break;
1705
1706 case SCTP_CMD_RENEGE:
1707 asoc->stream.si->renege_events(&asoc->ulpq,
1708 cmd->obj.chunk,
1709 GFP_ATOMIC);
1710 break;
1711
1712 case SCTP_CMD_SETUP_T4:
1713 sctp_cmd_setup_t4(commands, asoc, cmd->obj.chunk);
1714 break;
1715
1716 case SCTP_CMD_PROCESS_OPERR:
1717 sctp_cmd_process_operr(commands, asoc, chunk);
1718 break;
1719 case SCTP_CMD_CLEAR_INIT_TAG:
1720 asoc->peer.i.init_tag = 0;
1721 break;
1722 case SCTP_CMD_DEL_NON_PRIMARY:
1723 sctp_cmd_del_non_primary(asoc);
1724 break;
1725 case SCTP_CMD_T3_RTX_TIMERS_STOP:
1726 sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1727 break;
1728 case SCTP_CMD_FORCE_PRIM_RETRAN:
1729 t = asoc->peer.retran_path;
1730 asoc->peer.retran_path = asoc->peer.primary_path;
1731 sctp_outq_uncork(&asoc->outqueue, gfp);
1732 local_cork = 0;
1733 asoc->peer.retran_path = t;
1734 break;
1735 case SCTP_CMD_SET_SK_ERR:
1736 sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1737 break;
1738 case SCTP_CMD_ASSOC_CHANGE:
1739 sctp_cmd_assoc_change(commands, asoc,
1740 cmd->obj.u8);
1741 break;
1742 case SCTP_CMD_ADAPTATION_IND:
1743 sctp_cmd_adaptation_ind(commands, asoc);
1744 break;
1745 case SCTP_CMD_PEER_NO_AUTH:
1746 sctp_cmd_peer_no_auth(commands, asoc);
1747 break;
1748
1749 case SCTP_CMD_ASSOC_SHKEY:
1750 error = sctp_auth_asoc_init_active_key(asoc,
1751 GFP_ATOMIC);
1752 break;
1753 case SCTP_CMD_UPDATE_INITTAG:
1754 asoc->peer.i.init_tag = cmd->obj.u32;
1755 break;
1756 case SCTP_CMD_SEND_MSG:
1757 if (!asoc->outqueue.cork) {
1758 sctp_outq_cork(&asoc->outqueue);
1759 local_cork = 1;
1760 }
1761 sctp_cmd_send_msg(asoc, cmd->obj.msg, gfp);
1762 break;
1763 case SCTP_CMD_PURGE_ASCONF_QUEUE:
1764 sctp_asconf_queue_teardown(asoc);
1765 break;
1766
1767 case SCTP_CMD_SET_ASOC:
1768 if (asoc && local_cork) {
1769 sctp_outq_uncork(&asoc->outqueue, gfp);
1770 local_cork = 0;
1771 }
1772 asoc = cmd->obj.asoc;
1773 break;
1774
1775 default:
1776 pr_warn("Impossible command: %u\n",
1777 cmd->verb);
1778 break;
1779 }
1780
1781 if (error) {
1782 cmd = sctp_next_cmd(commands);
1783 while (cmd) {
1784 if (cmd->verb == SCTP_CMD_REPLY)
1785 sctp_chunk_free(cmd->obj.chunk);
1786 cmd = sctp_next_cmd(commands);
1787 }
1788 break;
1789 }
1790 }
1791
1792
1793
1794
1795
1796 if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {
1797 if (chunk->end_of_packet || chunk->singleton)
1798 sctp_outq_uncork(&asoc->outqueue, gfp);
1799 } else if (local_cork)
1800 sctp_outq_uncork(&asoc->outqueue, gfp);
1801
1802 if (sp->data_ready_signalled)
1803 sp->data_ready_signalled = 0;
1804
1805 return error;
1806 }