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