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