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