1 /*- 2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * a) Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. 9 * 10 * b) Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the distribution. 13 * 14 * c) Neither the name of Cisco Systems, Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived 16 * from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28 * THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 /* $KAME: sctp_timer.c,v 1.29 2005/03/06 16:04:18 itojun Exp $ */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #define _IP_VHL 37 #include <netinet/sctp_os.h> 38 #include <netinet/sctp_pcb.h> 39 #ifdef INET6 40 #include <netinet6/sctp6_var.h> 41 #endif 42 #include <netinet/sctp_var.h> 43 #include <netinet/sctp_sysctl.h> 44 #include <netinet/sctp_timer.h> 45 #include <netinet/sctputil.h> 46 #include <netinet/sctp_output.h> 47 #include <netinet/sctp_header.h> 48 #include <netinet/sctp_indata.h> 49 #include <netinet/sctp_asconf.h> 50 #include <netinet/sctp_input.h> 51 #include <netinet/sctp.h> 52 #include <netinet/sctp_uio.h> 53 54 55 56 void 57 sctp_early_fr_timer(struct sctp_inpcb *inp, 58 struct sctp_tcb *stcb, 59 struct sctp_nets *net) 60 { 61 struct sctp_tmit_chunk *chk, *tp2; 62 struct timeval now, min_wait, tv; 63 unsigned int cur_rtt, cnt = 0, cnt_resend = 0; 64 65 /* an early FR is occuring. */ 66 (void)SCTP_GETTIME_TIMEVAL(&now); 67 /* get cur rto in micro-seconds */ 68 if (net->lastsa == 0) { 69 /* Hmm no rtt estimate yet? */ 70 cur_rtt = stcb->asoc.initial_rto >> 2; 71 } else { 72 73 cur_rtt = ((net->lastsa >> 2) + net->lastsv) >> 1; 74 } 75 if (cur_rtt < sctp_early_fr_msec) { 76 cur_rtt = sctp_early_fr_msec; 77 } 78 cur_rtt *= 1000; 79 tv.tv_sec = cur_rtt / 1000000; 80 tv.tv_usec = cur_rtt % 1000000; 81 min_wait = now; 82 timevalsub(&min_wait, &tv); 83 if (min_wait.tv_sec < 0 || min_wait.tv_usec < 0) { 84 /* 85 * if we hit here, we don't have enough seconds on the clock 86 * to account for the RTO. We just let the lower seconds be 87 * the bounds and don't worry about it. This may mean we 88 * will mark a lot more than we should. 89 */ 90 min_wait.tv_sec = min_wait.tv_usec = 0; 91 } 92 chk = TAILQ_LAST(&stcb->asoc.sent_queue, sctpchunk_listhead); 93 for (; chk != NULL; chk = tp2) { 94 tp2 = TAILQ_PREV(chk, sctpchunk_listhead, sctp_next); 95 if (chk->whoTo != net) { 96 continue; 97 } 98 if (chk->sent == SCTP_DATAGRAM_RESEND) 99 cnt_resend++; 100 else if ((chk->sent > SCTP_DATAGRAM_UNSENT) && 101 (chk->sent < SCTP_DATAGRAM_RESEND)) { 102 /* pending, may need retran */ 103 if (chk->sent_rcv_time.tv_sec > min_wait.tv_sec) { 104 /* 105 * we have reached a chunk that was sent 106 * some seconds past our min.. forget it we 107 * will find no more to send. 108 */ 109 continue; 110 } else if (chk->sent_rcv_time.tv_sec == min_wait.tv_sec) { 111 /* 112 * we must look at the micro seconds to 113 * know. 114 */ 115 if (chk->sent_rcv_time.tv_usec >= min_wait.tv_usec) { 116 /* 117 * ok it was sent after our boundary 118 * time. 119 */ 120 continue; 121 } 122 } 123 if (sctp_logging_level & SCTP_EARLYFR_LOGGING_ENABLE) { 124 sctp_log_fr(chk->rec.data.TSN_seq, chk->snd_count, 125 4, SCTP_FR_MARKED_EARLY); 126 } 127 SCTP_STAT_INCR(sctps_earlyfrmrkretrans); 128 chk->sent = SCTP_DATAGRAM_RESEND; 129 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 130 /* double book size since we are doing an early FR */ 131 chk->book_size_scale++; 132 cnt += chk->send_size; 133 if ((cnt + net->flight_size) > net->cwnd) { 134 /* Mark all we could possibly resend */ 135 break; 136 } 137 } 138 } 139 if (cnt) { 140 /* 141 * JRS - Use the congestion control given in the congestion 142 * control module 143 */ 144 stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer(inp, stcb, net); 145 } else if (cnt_resend) { 146 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_EARLY_FR_TMR, SCTP_SO_NOT_LOCKED); 147 } 148 /* Restart it? */ 149 if (net->flight_size < net->cwnd) { 150 SCTP_STAT_INCR(sctps_earlyfrstrtmr); 151 sctp_timer_start(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net); 152 } 153 } 154 155 void 156 sctp_audit_retranmission_queue(struct sctp_association *asoc) 157 { 158 struct sctp_tmit_chunk *chk; 159 160 SCTPDBG(SCTP_DEBUG_TIMER4, "Audit invoked on send queue cnt:%d onqueue:%d\n", 161 asoc->sent_queue_retran_cnt, 162 asoc->sent_queue_cnt); 163 asoc->sent_queue_retran_cnt = 0; 164 asoc->sent_queue_cnt = 0; 165 TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 166 if (chk->sent == SCTP_DATAGRAM_RESEND) { 167 sctp_ucount_incr(asoc->sent_queue_retran_cnt); 168 } 169 asoc->sent_queue_cnt++; 170 } 171 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 172 if (chk->sent == SCTP_DATAGRAM_RESEND) { 173 sctp_ucount_incr(asoc->sent_queue_retran_cnt); 174 } 175 } 176 SCTPDBG(SCTP_DEBUG_TIMER4, "Audit completes retran:%d onqueue:%d\n", 177 asoc->sent_queue_retran_cnt, 178 asoc->sent_queue_cnt); 179 } 180 181 int 182 sctp_threshold_management(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 183 struct sctp_nets *net, uint16_t threshold) 184 { 185 if (net) { 186 net->error_count++; 187 SCTPDBG(SCTP_DEBUG_TIMER4, "Error count for %p now %d thresh:%d\n", 188 net, net->error_count, 189 net->failure_threshold); 190 if (net->error_count > net->failure_threshold) { 191 /* We had a threshold failure */ 192 if (net->dest_state & SCTP_ADDR_REACHABLE) { 193 net->dest_state &= ~SCTP_ADDR_REACHABLE; 194 net->dest_state |= SCTP_ADDR_NOT_REACHABLE; 195 net->dest_state &= ~SCTP_ADDR_REQ_PRIMARY; 196 if (net == stcb->asoc.primary_destination) { 197 net->dest_state |= SCTP_ADDR_WAS_PRIMARY; 198 } 199 /* 200 * JRS 5/14/07 - If a destination is 201 * unreachable, the PF bit is turned off. 202 * This allows an unambiguous use of the PF 203 * bit for destinations that are reachable 204 * but potentially failed. If the 205 * destination is set to the unreachable 206 * state, also set the destination to the PF 207 * state. 208 */ 209 /* 210 * Add debug message here if destination is 211 * not in PF state. 212 */ 213 /* Stop any running T3 timers here? */ 214 if (sctp_cmt_on_off && sctp_cmt_pf) { 215 net->dest_state &= ~SCTP_ADDR_PF; 216 SCTPDBG(SCTP_DEBUG_TIMER4, "Destination %p moved from PF to unreachable.\n", 217 net); 218 } 219 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, 220 stcb, 221 SCTP_FAILED_THRESHOLD, 222 (void *)net, SCTP_SO_NOT_LOCKED); 223 } 224 } 225 /*********HOLD THIS COMMENT FOR PATCH OF ALTERNATE 226 *********ROUTING CODE 227 */ 228 /*********HOLD THIS COMMENT FOR END OF PATCH OF ALTERNATE 229 *********ROUTING CODE 230 */ 231 } 232 if (stcb == NULL) 233 return (0); 234 235 if (net) { 236 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) { 237 if (sctp_logging_level & SCTP_THRESHOLD_LOGGING) { 238 sctp_misc_ints(SCTP_THRESHOLD_INCR, 239 stcb->asoc.overall_error_count, 240 (stcb->asoc.overall_error_count + 1), 241 SCTP_FROM_SCTP_TIMER, 242 __LINE__); 243 } 244 stcb->asoc.overall_error_count++; 245 } 246 } else { 247 if (sctp_logging_level & SCTP_THRESHOLD_LOGGING) { 248 sctp_misc_ints(SCTP_THRESHOLD_INCR, 249 stcb->asoc.overall_error_count, 250 (stcb->asoc.overall_error_count + 1), 251 SCTP_FROM_SCTP_TIMER, 252 __LINE__); 253 } 254 stcb->asoc.overall_error_count++; 255 } 256 SCTPDBG(SCTP_DEBUG_TIMER4, "Overall error count for %p now %d thresh:%u state:%x\n", 257 &stcb->asoc, stcb->asoc.overall_error_count, 258 (uint32_t) threshold, 259 ((net == NULL) ? (uint32_t) 0 : (uint32_t) net->dest_state)); 260 /* 261 * We specifically do not do >= to give the assoc one more change 262 * before we fail it. 263 */ 264 if (stcb->asoc.overall_error_count > threshold) { 265 /* Abort notification sends a ULP notify */ 266 struct mbuf *oper; 267 268 oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 269 0, M_DONTWAIT, 1, MT_DATA); 270 if (oper) { 271 struct sctp_paramhdr *ph; 272 uint32_t *ippp; 273 274 SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 275 sizeof(uint32_t); 276 ph = mtod(oper, struct sctp_paramhdr *); 277 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 278 ph->param_length = htons(SCTP_BUF_LEN(oper)); 279 ippp = (uint32_t *) (ph + 1); 280 *ippp = htonl(SCTP_FROM_SCTP_TIMER + SCTP_LOC_1); 281 } 282 inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_1; 283 printf("Aborting association threshold:%d overall error count:%d\n", 284 threshold, 285 stcb->asoc.overall_error_count); 286 sctp_abort_an_association(inp, stcb, SCTP_FAILED_THRESHOLD, oper, SCTP_SO_NOT_LOCKED); 287 return (1); 288 } 289 return (0); 290 } 291 292 struct sctp_nets * 293 sctp_find_alternate_net(struct sctp_tcb *stcb, 294 struct sctp_nets *net, 295 int mode) 296 { 297 /* Find and return an alternate network if possible */ 298 struct sctp_nets *alt, *mnet, *min_errors_net = NULL, *max_cwnd_net = NULL; 299 int once; 300 301 /* JRS 5/14/07 - Initialize min_errors to an impossible value. */ 302 int min_errors = -1; 303 uint32_t max_cwnd = 0; 304 305 if (stcb->asoc.numnets == 1) { 306 /* No others but net */ 307 return (TAILQ_FIRST(&stcb->asoc.nets)); 308 } 309 /* 310 * JRS 5/14/07 - If mode is set to 2, use the CMT PF find alternate 311 * net algorithm. This algorithm chooses the active destination (not 312 * in PF state) with the largest cwnd value. If all destinations are 313 * in PF state, unreachable, or unconfirmed, choose the desination 314 * that is in PF state with the lowest error count. In case of a 315 * tie, choose the destination that was most recently active. 316 */ 317 if (mode == 2) { 318 TAILQ_FOREACH(mnet, &stcb->asoc.nets, sctp_next) { 319 /* 320 * JRS 5/14/07 - If the destination is unreachable 321 * or unconfirmed, skip it. 322 */ 323 if (((mnet->dest_state & SCTP_ADDR_REACHABLE) != SCTP_ADDR_REACHABLE) || 324 (mnet->dest_state & SCTP_ADDR_UNCONFIRMED)) { 325 continue; 326 } 327 /* 328 * JRS 5/14/07 - If the destination is reachable 329 * but in PF state, compare the error count of the 330 * destination to the minimum error count seen thus 331 * far. Store the destination with the lower error 332 * count. If the error counts are equal, store the 333 * destination that was most recently active. 334 */ 335 if (mnet->dest_state & SCTP_ADDR_PF) { 336 /* 337 * JRS 5/14/07 - If the destination under 338 * consideration is the current destination, 339 * work as if the error count is one higher. 340 * The actual error count will not be 341 * incremented until later in the t3 342 * handler. 343 */ 344 if (mnet == net) { 345 if (min_errors == -1) { 346 min_errors = mnet->error_count + 1; 347 min_errors_net = mnet; 348 } else if (mnet->error_count + 1 < min_errors) { 349 min_errors = mnet->error_count + 1; 350 min_errors_net = mnet; 351 } else if (mnet->error_count + 1 == min_errors 352 && mnet->last_active > min_errors_net->last_active) { 353 min_errors_net = mnet; 354 min_errors = mnet->error_count + 1; 355 } 356 continue; 357 } else { 358 if (min_errors == -1) { 359 min_errors = mnet->error_count; 360 min_errors_net = mnet; 361 } else if (mnet->error_count < min_errors) { 362 min_errors = mnet->error_count; 363 min_errors_net = mnet; 364 } else if (mnet->error_count == min_errors 365 && mnet->last_active > min_errors_net->last_active) { 366 min_errors_net = mnet; 367 min_errors = mnet->error_count; 368 } 369 continue; 370 } 371 } 372 /* 373 * JRS 5/14/07 - If the destination is reachable and 374 * not in PF state, compare the cwnd of the 375 * destination to the highest cwnd seen thus far. 376 * Store the destination with the higher cwnd value. 377 * If the cwnd values are equal, randomly choose one 378 * of the two destinations. 379 */ 380 if (max_cwnd < mnet->cwnd) { 381 max_cwnd_net = mnet; 382 max_cwnd = mnet->cwnd; 383 } else if (max_cwnd == mnet->cwnd) { 384 uint32_t rndval; 385 uint8_t this_random; 386 387 if (stcb->asoc.hb_random_idx > 3) { 388 rndval = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep); 389 memcpy(stcb->asoc.hb_random_values, &rndval, sizeof(stcb->asoc.hb_random_values)); 390 this_random = stcb->asoc.hb_random_values[0]; 391 stcb->asoc.hb_random_idx++; 392 stcb->asoc.hb_ect_randombit = 0; 393 } else { 394 this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx]; 395 stcb->asoc.hb_random_idx++; 396 stcb->asoc.hb_ect_randombit = 0; 397 } 398 if (this_random % 2 == 1) { 399 max_cwnd_net = mnet; 400 max_cwnd = mnet->cwnd; 401 //Useless ? 402 } 403 } 404 } 405 /* 406 * JRS 5/14/07 - After all destination have been considered 407 * as alternates, check to see if there was some active 408 * destination (not in PF state). If not, check to see if 409 * there was some PF destination with the minimum number of 410 * errors. If not, return the original destination. If 411 * there is a min_errors_net, remove the PF flag from that 412 * destination, set the cwnd to one or two MTUs, and return 413 * the destination as an alt. If there was some active 414 * destination with a highest cwnd, return the destination 415 * as an alt. 416 */ 417 if (max_cwnd_net == NULL) { 418 if (min_errors_net == NULL) { 419 return (net); 420 } 421 min_errors_net->dest_state &= ~SCTP_ADDR_PF; 422 min_errors_net->cwnd = min_errors_net->mtu * sctp_cmt_pf; 423 if (SCTP_OS_TIMER_PENDING(&min_errors_net->rxt_timer.timer)) { 424 sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 425 stcb, min_errors_net, 426 SCTP_FROM_SCTP_TIMER + SCTP_LOC_2); 427 } 428 SCTPDBG(SCTP_DEBUG_TIMER4, "Destination %p moved from PF to active with %d errors.\n", 429 min_errors_net, min_errors_net->error_count); 430 return (min_errors_net); 431 } else { 432 return (max_cwnd_net); 433 } 434 } 435 /* 436 * JRS 5/14/07 - If mode is set to 1, use the CMT policy for 437 * choosing an alternate net. 438 */ 439 else if (mode == 1) { 440 TAILQ_FOREACH(mnet, &stcb->asoc.nets, sctp_next) { 441 if (((mnet->dest_state & SCTP_ADDR_REACHABLE) != SCTP_ADDR_REACHABLE) || 442 (mnet->dest_state & SCTP_ADDR_UNCONFIRMED) 443 ) { 444 /* 445 * will skip ones that are not-reachable or 446 * unconfirmed 447 */ 448 continue; 449 } 450 if (max_cwnd < mnet->cwnd) { 451 max_cwnd_net = mnet; 452 max_cwnd = mnet->cwnd; 453 } else if (max_cwnd == mnet->cwnd) { 454 uint32_t rndval; 455 uint8_t this_random; 456 457 if (stcb->asoc.hb_random_idx > 3) { 458 rndval = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep); 459 memcpy(stcb->asoc.hb_random_values, &rndval, 460 sizeof(stcb->asoc.hb_random_values)); 461 this_random = stcb->asoc.hb_random_values[0]; 462 stcb->asoc.hb_random_idx = 0; 463 stcb->asoc.hb_ect_randombit = 0; 464 } else { 465 this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx]; 466 stcb->asoc.hb_random_idx++; 467 stcb->asoc.hb_ect_randombit = 0; 468 } 469 if (this_random % 2) { 470 max_cwnd_net = mnet; 471 max_cwnd = mnet->cwnd; 472 } 473 } 474 } 475 if (max_cwnd_net) { 476 return (max_cwnd_net); 477 } 478 } 479 mnet = net; 480 once = 0; 481 482 if (mnet == NULL) { 483 mnet = TAILQ_FIRST(&stcb->asoc.nets); 484 } 485 do { 486 alt = TAILQ_NEXT(mnet, sctp_next); 487 if (alt == NULL) { 488 once++; 489 if (once > 1) { 490 break; 491 } 492 alt = TAILQ_FIRST(&stcb->asoc.nets); 493 } 494 if (alt->ro.ro_rt == NULL) { 495 if (alt->ro._s_addr) { 496 sctp_free_ifa(alt->ro._s_addr); 497 alt->ro._s_addr = NULL; 498 } 499 alt->src_addr_selected = 0; 500 } 501 if ( 502 ((alt->dest_state & SCTP_ADDR_REACHABLE) == SCTP_ADDR_REACHABLE) && 503 (alt->ro.ro_rt != NULL) && 504 /* sa_ignore NO_NULL_CHK */ 505 (!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) 506 ) { 507 /* Found a reachable address */ 508 break; 509 } 510 mnet = alt; 511 } while (alt != NULL); 512 513 if (alt == NULL) { 514 /* Case where NO insv network exists (dormant state) */ 515 /* we rotate destinations */ 516 once = 0; 517 mnet = net; 518 do { 519 alt = TAILQ_NEXT(mnet, sctp_next); 520 if (alt == NULL) { 521 once++; 522 if (once > 1) { 523 break; 524 } 525 alt = TAILQ_FIRST(&stcb->asoc.nets); 526 } 527 /* sa_ignore NO_NULL_CHK */ 528 if ((!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) && 529 (alt != net)) { 530 /* Found an alternate address */ 531 break; 532 } 533 mnet = alt; 534 } while (alt != NULL); 535 } 536 if (alt == NULL) { 537 return (net); 538 } 539 return (alt); 540 } 541 542 543 544 static void 545 sctp_backoff_on_timeout(struct sctp_tcb *stcb, 546 struct sctp_nets *net, 547 int win_probe, 548 int num_marked) 549 { 550 if (net->RTO == 0) { 551 net->RTO = stcb->asoc.minrto; 552 } 553 net->RTO <<= 1; 554 if (net->RTO > stcb->asoc.maxrto) { 555 net->RTO = stcb->asoc.maxrto; 556 } 557 if ((win_probe == 0) && num_marked) { 558 /* We don't apply penalty to window probe scenarios */ 559 /* JRS - Use the congestion control given in the CC module */ 560 stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout(stcb, net); 561 } 562 } 563 564 static int 565 sctp_mark_all_for_resend(struct sctp_tcb *stcb, 566 struct sctp_nets *net, 567 struct sctp_nets *alt, 568 int window_probe, 569 int *num_marked) 570 { 571 572 /* 573 * Mark all chunks (well not all) that were sent to *net for 574 * retransmission. Move them to alt for there destination as well... 575 * We only mark chunks that have been outstanding long enough to 576 * have received feed-back. 577 */ 578 struct sctp_tmit_chunk *chk, *tp2, *could_be_sent = NULL; 579 struct sctp_nets *lnets; 580 struct timeval now, min_wait, tv; 581 int cur_rtt; 582 int audit_tf, num_mk, fir; 583 unsigned int cnt_mk; 584 uint32_t orig_flight, orig_tf; 585 uint32_t tsnlast, tsnfirst; 586 587 588 /* none in flight now */ 589 audit_tf = 0; 590 fir = 0; 591 /* 592 * figure out how long a data chunk must be pending before we can 593 * mark it .. 594 */ 595 (void)SCTP_GETTIME_TIMEVAL(&now); 596 /* get cur rto in micro-seconds */ 597 cur_rtt = (((net->lastsa >> 2) + net->lastsv) >> 1); 598 cur_rtt *= 1000; 599 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 600 sctp_log_fr(cur_rtt, 601 stcb->asoc.peers_rwnd, 602 window_probe, 603 SCTP_FR_T3_MARK_TIME); 604 sctp_log_fr(net->flight_size, 605 SCTP_OS_TIMER_PENDING(&net->fr_timer.timer), 606 SCTP_OS_TIMER_ACTIVE(&net->fr_timer.timer), 607 SCTP_FR_CWND_REPORT); 608 sctp_log_fr(net->flight_size, net->cwnd, stcb->asoc.total_flight, SCTP_FR_CWND_REPORT); 609 } 610 tv.tv_sec = cur_rtt / 1000000; 611 tv.tv_usec = cur_rtt % 1000000; 612 min_wait = now; 613 timevalsub(&min_wait, &tv); 614 if (min_wait.tv_sec < 0 || min_wait.tv_usec < 0) { 615 /* 616 * if we hit here, we don't have enough seconds on the clock 617 * to account for the RTO. We just let the lower seconds be 618 * the bounds and don't worry about it. This may mean we 619 * will mark a lot more than we should. 620 */ 621 min_wait.tv_sec = min_wait.tv_usec = 0; 622 } 623 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 624 sctp_log_fr(cur_rtt, now.tv_sec, now.tv_usec, SCTP_FR_T3_MARK_TIME); 625 sctp_log_fr(0, min_wait.tv_sec, min_wait.tv_usec, SCTP_FR_T3_MARK_TIME); 626 } 627 /* 628 * Our rwnd will be incorrect here since we are not adding back the 629 * cnt * mbuf but we will fix that down below. 630 */ 631 orig_flight = net->flight_size; 632 orig_tf = stcb->asoc.total_flight; 633 634 net->fast_retran_ip = 0; 635 /* Now on to each chunk */ 636 num_mk = cnt_mk = 0; 637 tsnfirst = tsnlast = 0; 638 chk = TAILQ_FIRST(&stcb->asoc.sent_queue); 639 for (; chk != NULL; chk = tp2) { 640 tp2 = TAILQ_NEXT(chk, sctp_next); 641 if ((compare_with_wrap(stcb->asoc.last_acked_seq, 642 chk->rec.data.TSN_seq, 643 MAX_TSN)) || 644 (stcb->asoc.last_acked_seq == chk->rec.data.TSN_seq)) { 645 /* Strange case our list got out of order? */ 646 SCTP_PRINTF("Our list is out of order?\n"); 647 panic("Out of order list"); 648 } 649 if ((chk->whoTo == net) && (chk->sent < SCTP_DATAGRAM_ACKED)) { 650 /* 651 * found one to mark: If it is less than 652 * DATAGRAM_ACKED it MUST not be a skipped or marked 653 * TSN but instead one that is either already set 654 * for retransmission OR one that needs 655 * retransmission. 656 */ 657 658 /* validate its been outstanding long enough */ 659 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 660 sctp_log_fr(chk->rec.data.TSN_seq, 661 chk->sent_rcv_time.tv_sec, 662 chk->sent_rcv_time.tv_usec, 663 SCTP_FR_T3_MARK_TIME); 664 } 665 if ((chk->sent_rcv_time.tv_sec > min_wait.tv_sec) && (window_probe == 0)) { 666 /* 667 * we have reached a chunk that was sent 668 * some seconds past our min.. forget it we 669 * will find no more to send. 670 */ 671 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 672 sctp_log_fr(0, 673 chk->sent_rcv_time.tv_sec, 674 chk->sent_rcv_time.tv_usec, 675 SCTP_FR_T3_STOPPED); 676 } 677 continue; 678 } else if ((chk->sent_rcv_time.tv_sec == min_wait.tv_sec) && 679 (window_probe == 0)) { 680 /* 681 * we must look at the micro seconds to 682 * know. 683 */ 684 if (chk->sent_rcv_time.tv_usec >= min_wait.tv_usec) { 685 /* 686 * ok it was sent after our boundary 687 * time. 688 */ 689 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 690 sctp_log_fr(0, 691 chk->sent_rcv_time.tv_sec, 692 chk->sent_rcv_time.tv_usec, 693 SCTP_FR_T3_STOPPED); 694 } 695 continue; 696 } 697 } 698 if (PR_SCTP_TTL_ENABLED(chk->flags)) { 699 /* Is it expired? */ 700 if ((now.tv_sec > chk->rec.data.timetodrop.tv_sec) || 701 ((chk->rec.data.timetodrop.tv_sec == now.tv_sec) && 702 (now.tv_usec > chk->rec.data.timetodrop.tv_usec))) { 703 /* Yes so drop it */ 704 if (chk->data) { 705 (void)sctp_release_pr_sctp_chunk(stcb, 706 chk, 707 (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 708 &stcb->asoc.sent_queue, SCTP_SO_NOT_LOCKED); 709 } 710 } 711 continue; 712 } 713 if (PR_SCTP_RTX_ENABLED(chk->flags)) { 714 /* Has it been retransmitted tv_sec times? */ 715 if (chk->snd_count > chk->rec.data.timetodrop.tv_sec) { 716 if (chk->data) { 717 (void)sctp_release_pr_sctp_chunk(stcb, 718 chk, 719 (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 720 &stcb->asoc.sent_queue, SCTP_SO_NOT_LOCKED); 721 } 722 } 723 continue; 724 } 725 if (chk->sent < SCTP_DATAGRAM_RESEND) { 726 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 727 num_mk++; 728 if (fir == 0) { 729 fir = 1; 730 tsnfirst = chk->rec.data.TSN_seq; 731 } 732 tsnlast = chk->rec.data.TSN_seq; 733 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 734 sctp_log_fr(chk->rec.data.TSN_seq, chk->snd_count, 735 0, SCTP_FR_T3_MARKED); 736 } 737 if (chk->rec.data.chunk_was_revoked) { 738 /* deflate the cwnd */ 739 chk->whoTo->cwnd -= chk->book_size; 740 chk->rec.data.chunk_was_revoked = 0; 741 } 742 net->marked_retrans++; 743 stcb->asoc.marked_retrans++; 744 if (sctp_logging_level & SCTP_FLIGHT_LOGGING_ENABLE) { 745 sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_RSND_TO, 746 chk->whoTo->flight_size, 747 chk->book_size, 748 (uintptr_t) chk->whoTo, 749 chk->rec.data.TSN_seq); 750 } 751 sctp_flight_size_decrease(chk); 752 sctp_total_flight_decrease(stcb, chk); 753 stcb->asoc.peers_rwnd += chk->send_size; 754 stcb->asoc.peers_rwnd += sctp_peer_chunk_oh; 755 } 756 chk->sent = SCTP_DATAGRAM_RESEND; 757 SCTP_STAT_INCR(sctps_markedretrans); 758 759 /* reset the TSN for striking and other FR stuff */ 760 chk->rec.data.doing_fast_retransmit = 0; 761 /* Clear any time so NO RTT is being done */ 762 chk->do_rtt = 0; 763 if (alt != net) { 764 sctp_free_remote_addr(chk->whoTo); 765 chk->no_fr_allowed = 1; 766 chk->whoTo = alt; 767 atomic_add_int(&alt->ref_count, 1); 768 } else { 769 chk->no_fr_allowed = 0; 770 if (TAILQ_EMPTY(&stcb->asoc.send_queue)) { 771 chk->rec.data.fast_retran_tsn = stcb->asoc.sending_seq; 772 } else { 773 chk->rec.data.fast_retran_tsn = (TAILQ_FIRST(&stcb->asoc.send_queue))->rec.data.TSN_seq; 774 } 775 } 776 /* 777 * CMT: Do not allow FRs on retransmitted TSNs. 778 */ 779 if (sctp_cmt_on_off == 1) { 780 chk->no_fr_allowed = 1; 781 } 782 } else if (chk->sent == SCTP_DATAGRAM_ACKED) { 783 /* remember highest acked one */ 784 could_be_sent = chk; 785 } 786 if (chk->sent == SCTP_DATAGRAM_RESEND) { 787 cnt_mk++; 788 } 789 } 790 if ((orig_flight - net->flight_size) != (orig_tf - stcb->asoc.total_flight)) { 791 /* we did not subtract the same things? */ 792 audit_tf = 1; 793 } 794 if (sctp_logging_level & (SCTP_EARLYFR_LOGGING_ENABLE | SCTP_FR_LOGGING_ENABLE)) { 795 sctp_log_fr(tsnfirst, tsnlast, num_mk, SCTP_FR_T3_TIMEOUT); 796 } 797 #ifdef SCTP_DEBUG 798 if (num_mk) { 799 SCTPDBG(SCTP_DEBUG_TIMER1, "LAST TSN marked was %x\n", 800 tsnlast); 801 SCTPDBG(SCTP_DEBUG_TIMER1, "Num marked for retransmission was %d peer-rwd:%ld\n", 802 num_mk, (u_long)stcb->asoc.peers_rwnd); 803 SCTPDBG(SCTP_DEBUG_TIMER1, "LAST TSN marked was %x\n", 804 tsnlast); 805 SCTPDBG(SCTP_DEBUG_TIMER1, "Num marked for retransmission was %d peer-rwd:%d\n", 806 num_mk, 807 (int)stcb->asoc.peers_rwnd); 808 } 809 #endif 810 *num_marked = num_mk; 811 if ((stcb->asoc.sent_queue_retran_cnt == 0) && (could_be_sent)) { 812 /* fix it so we retransmit the highest acked anyway */ 813 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 814 cnt_mk++; 815 could_be_sent->sent = SCTP_DATAGRAM_RESEND; 816 } 817 if (stcb->asoc.sent_queue_retran_cnt != cnt_mk) { 818 #ifdef INVARIANTS 819 SCTP_PRINTF("Local Audit says there are %d for retran asoc cnt:%d we marked:%d this time\n", 820 cnt_mk, stcb->asoc.sent_queue_retran_cnt, num_mk); 821 #endif 822 #ifndef SCTP_AUDITING_ENABLED 823 stcb->asoc.sent_queue_retran_cnt = cnt_mk; 824 #endif 825 } 826 /* Now check for a ECN Echo that may be stranded */ 827 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 828 if ((chk->whoTo == net) && 829 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 830 sctp_free_remote_addr(chk->whoTo); 831 chk->whoTo = alt; 832 if (chk->sent != SCTP_DATAGRAM_RESEND) { 833 chk->sent = SCTP_DATAGRAM_RESEND; 834 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 835 } 836 atomic_add_int(&alt->ref_count, 1); 837 } 838 } 839 if (audit_tf) { 840 SCTPDBG(SCTP_DEBUG_TIMER4, 841 "Audit total flight due to negative value net:%p\n", 842 net); 843 stcb->asoc.total_flight = 0; 844 stcb->asoc.total_flight_count = 0; 845 /* Clear all networks flight size */ 846 TAILQ_FOREACH(lnets, &stcb->asoc.nets, sctp_next) { 847 lnets->flight_size = 0; 848 SCTPDBG(SCTP_DEBUG_TIMER4, 849 "Net:%p c-f cwnd:%d ssthresh:%d\n", 850 lnets, lnets->cwnd, lnets->ssthresh); 851 } 852 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 853 if (chk->sent < SCTP_DATAGRAM_RESEND) { 854 if (sctp_logging_level & SCTP_FLIGHT_LOGGING_ENABLE) { 855 sctp_misc_ints(SCTP_FLIGHT_LOG_UP, 856 chk->whoTo->flight_size, 857 chk->book_size, 858 (uintptr_t) chk->whoTo, 859 chk->rec.data.TSN_seq); 860 } 861 sctp_flight_size_increase(chk); 862 sctp_total_flight_increase(stcb, chk); 863 } 864 } 865 } 866 /* 867 * Setup the ecn nonce re-sync point. We do this since 868 * retranmissions are NOT setup for ECN. This means that do to 869 * Karn's rule, we don't know the total of the peers ecn bits. 870 */ 871 chk = TAILQ_FIRST(&stcb->asoc.send_queue); 872 if (chk == NULL) { 873 stcb->asoc.nonce_resync_tsn = stcb->asoc.sending_seq; 874 } else { 875 stcb->asoc.nonce_resync_tsn = chk->rec.data.TSN_seq; 876 } 877 stcb->asoc.nonce_wait_for_ecne = 0; 878 stcb->asoc.nonce_sum_check = 0; 879 /* We return 1 if we only have a window probe outstanding */ 880 return (0); 881 } 882 883 static void 884 sctp_move_all_chunks_to_alt(struct sctp_tcb *stcb, 885 struct sctp_nets *net, 886 struct sctp_nets *alt) 887 { 888 struct sctp_association *asoc; 889 struct sctp_stream_out *outs; 890 struct sctp_tmit_chunk *chk; 891 struct sctp_stream_queue_pending *sp; 892 893 if (net == alt) 894 /* nothing to do */ 895 return; 896 897 asoc = &stcb->asoc; 898 899 /* 900 * now through all the streams checking for chunks sent to our bad 901 * network. 902 */ 903 TAILQ_FOREACH(outs, &asoc->out_wheel, next_spoke) { 904 /* now clean up any chunks here */ 905 TAILQ_FOREACH(sp, &outs->outqueue, next) { 906 if (sp->net == net) { 907 sctp_free_remote_addr(sp->net); 908 sp->net = alt; 909 atomic_add_int(&alt->ref_count, 1); 910 } 911 } 912 } 913 /* Now check the pending queue */ 914 TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) { 915 if (chk->whoTo == net) { 916 sctp_free_remote_addr(chk->whoTo); 917 chk->whoTo = alt; 918 atomic_add_int(&alt->ref_count, 1); 919 } 920 } 921 922 } 923 924 int 925 sctp_t3rxt_timer(struct sctp_inpcb *inp, 926 struct sctp_tcb *stcb, 927 struct sctp_nets *net) 928 { 929 struct sctp_nets *alt; 930 int win_probe, num_mk; 931 932 if (sctp_logging_level & SCTP_FR_LOGGING_ENABLE) { 933 sctp_log_fr(0, 0, 0, SCTP_FR_T3_TIMEOUT); 934 } 935 if (sctp_logging_level & SCTP_CWND_LOGGING_ENABLE) { 936 struct sctp_nets *lnet; 937 938 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 939 if (net == lnet) { 940 sctp_log_cwnd(stcb, lnet, 1, SCTP_CWND_LOG_FROM_T3); 941 } else { 942 sctp_log_cwnd(stcb, lnet, 0, SCTP_CWND_LOG_FROM_T3); 943 } 944 } 945 } 946 /* Find an alternate and mark those for retransmission */ 947 if ((stcb->asoc.peers_rwnd == 0) && 948 (stcb->asoc.total_flight < net->mtu)) { 949 SCTP_STAT_INCR(sctps_timowindowprobe); 950 win_probe = 1; 951 } else { 952 win_probe = 0; 953 } 954 955 /* 956 * JRS 5/14/07 - If CMT PF is on and the destination if not already 957 * in PF state, set the destination to PF state and store the 958 * current time as the time that the destination was last active. In 959 * addition, find an alternate destination with PF-based 960 * find_alt_net(). 961 */ 962 if (sctp_cmt_on_off && sctp_cmt_pf) { 963 if ((net->dest_state & SCTP_ADDR_PF) != SCTP_ADDR_PF) { 964 net->dest_state |= SCTP_ADDR_PF; 965 net->last_active = sctp_get_tick_count(); 966 SCTPDBG(SCTP_DEBUG_TIMER4, "Destination %p moved from active to PF.\n", 967 net); 968 } 969 alt = sctp_find_alternate_net(stcb, net, 2); 970 } else if (sctp_cmt_on_off) { 971 /* 972 * CMT: Using RTX_SSTHRESH policy for CMT. If CMT is being 973 * used, then pick dest with largest ssthresh for any 974 * retransmission. 975 */ 976 alt = net; 977 alt = sctp_find_alternate_net(stcb, alt, 1); 978 /* 979 * CUCv2: If a different dest is picked for the 980 * retransmission, then new (rtx-)pseudo_cumack needs to be 981 * tracked for orig dest. Let CUCv2 track new (rtx-) 982 * pseudo-cumack always. 983 */ 984 net->find_pseudo_cumack = 1; 985 net->find_rtx_pseudo_cumack = 1; 986 } else { /* CMT is OFF */ 987 alt = sctp_find_alternate_net(stcb, net, 0); 988 } 989 990 (void)sctp_mark_all_for_resend(stcb, net, alt, win_probe, &num_mk); 991 /* FR Loss recovery just ended with the T3. */ 992 stcb->asoc.fast_retran_loss_recovery = 0; 993 994 /* CMT FR loss recovery ended with the T3 */ 995 net->fast_retran_loss_recovery = 0; 996 997 /* 998 * setup the sat loss recovery that prevents satellite cwnd advance. 999 */ 1000 stcb->asoc.sat_t3_loss_recovery = 1; 1001 stcb->asoc.sat_t3_recovery_tsn = stcb->asoc.sending_seq; 1002 1003 /* Backoff the timer and cwnd */ 1004 sctp_backoff_on_timeout(stcb, net, win_probe, num_mk); 1005 if (win_probe == 0) { 1006 /* We don't do normal threshold management on window probes */ 1007 if (sctp_threshold_management(inp, stcb, net, 1008 stcb->asoc.max_send_times)) { 1009 /* Association was destroyed */ 1010 return (1); 1011 } else { 1012 if (net != stcb->asoc.primary_destination) { 1013 /* send a immediate HB if our RTO is stale */ 1014 struct timeval now; 1015 unsigned int ms_goneby; 1016 1017 (void)SCTP_GETTIME_TIMEVAL(&now); 1018 if (net->last_sent_time.tv_sec) { 1019 ms_goneby = (now.tv_sec - net->last_sent_time.tv_sec) * 1000; 1020 } else { 1021 ms_goneby = 0; 1022 } 1023 if ((ms_goneby > net->RTO) || (net->RTO == 0)) { 1024 /* 1025 * no recent feed back in an RTO or 1026 * more, request a RTT update 1027 */ 1028 if (sctp_send_hb(stcb, 1, net) < 0) 1029 return 1; 1030 } 1031 } 1032 } 1033 } else { 1034 /* 1035 * For a window probe we don't penalize the net's but only 1036 * the association. This may fail it if SACKs are not coming 1037 * back. If sack's are coming with rwnd locked at 0, we will 1038 * continue to hold things waiting for rwnd to raise 1039 */ 1040 if (sctp_threshold_management(inp, stcb, NULL, 1041 stcb->asoc.max_send_times)) { 1042 /* Association was destroyed */ 1043 return (1); 1044 } 1045 } 1046 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 1047 /* Move all pending over too */ 1048 sctp_move_all_chunks_to_alt(stcb, net, alt); 1049 1050 /* 1051 * Get the address that failed, to force a new src address 1052 * selecton and a route allocation. 1053 */ 1054 if (net->ro._s_addr) { 1055 sctp_free_ifa(net->ro._s_addr); 1056 net->ro._s_addr = NULL; 1057 } 1058 net->src_addr_selected = 0; 1059 1060 /* Force a route allocation too */ 1061 if (net->ro.ro_rt) { 1062 RTFREE(net->ro.ro_rt); 1063 net->ro.ro_rt = NULL; 1064 } 1065 /* Was it our primary? */ 1066 if ((stcb->asoc.primary_destination == net) && (alt != net)) { 1067 /* 1068 * Yes, note it as such and find an alternate note: 1069 * this means HB code must use this to resent the 1070 * primary if it goes active AND if someone does a 1071 * change-primary then this flag must be cleared 1072 * from any net structures. 1073 */ 1074 if (sctp_set_primary_addr(stcb, 1075 (struct sockaddr *)NULL, 1076 alt) == 0) { 1077 net->dest_state |= SCTP_ADDR_WAS_PRIMARY; 1078 } 1079 } 1080 } else if (sctp_cmt_on_off && sctp_cmt_pf && (net->dest_state & SCTP_ADDR_PF) == SCTP_ADDR_PF) { 1081 /* 1082 * JRS 5/14/07 - If the destination hasn't failed completely 1083 * but is in PF state, a PF-heartbeat needs to be sent 1084 * manually. 1085 */ 1086 if (sctp_send_hb(stcb, 1, net) < 0) 1087 return 1; 1088 } 1089 /* 1090 * Special case for cookie-echo'ed case, we don't do output but must 1091 * await the COOKIE-ACK before retransmission 1092 */ 1093 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) { 1094 /* 1095 * Here we just reset the timer and start again since we 1096 * have not established the asoc 1097 */ 1098 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 1099 return (0); 1100 } 1101 if (stcb->asoc.peer_supports_prsctp) { 1102 struct sctp_tmit_chunk *lchk; 1103 1104 lchk = sctp_try_advance_peer_ack_point(stcb, &stcb->asoc); 1105 /* C3. See if we need to send a Fwd-TSN */ 1106 if (compare_with_wrap(stcb->asoc.advanced_peer_ack_point, 1107 stcb->asoc.last_acked_seq, MAX_TSN)) { 1108 /* 1109 * ISSUE with ECN, see FWD-TSN processing for notes 1110 * on issues that will occur when the ECN NONCE 1111 * stuff is put into SCTP for cross checking. 1112 */ 1113 send_forward_tsn(stcb, &stcb->asoc); 1114 if (lchk) { 1115 /* Assure a timer is up */ 1116 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, lchk->whoTo); 1117 } 1118 } 1119 } 1120 if (sctp_logging_level & SCTP_CWND_MONITOR_ENABLE) { 1121 sctp_log_cwnd(stcb, net, net->cwnd, SCTP_CWND_LOG_FROM_RTX); 1122 } 1123 return (0); 1124 } 1125 1126 int 1127 sctp_t1init_timer(struct sctp_inpcb *inp, 1128 struct sctp_tcb *stcb, 1129 struct sctp_nets *net) 1130 { 1131 /* bump the thresholds */ 1132 if (stcb->asoc.delayed_connection) { 1133 /* 1134 * special hook for delayed connection. The library did NOT 1135 * complete the rest of its sends. 1136 */ 1137 stcb->asoc.delayed_connection = 0; 1138 sctp_send_initiate(inp, stcb, SCTP_SO_NOT_LOCKED); 1139 return (0); 1140 } 1141 if (SCTP_GET_STATE((&stcb->asoc)) != SCTP_STATE_COOKIE_WAIT) { 1142 return (0); 1143 } 1144 if (sctp_threshold_management(inp, stcb, net, 1145 stcb->asoc.max_init_times)) { 1146 /* Association was destroyed */ 1147 return (1); 1148 } 1149 stcb->asoc.dropped_special_cnt = 0; 1150 sctp_backoff_on_timeout(stcb, stcb->asoc.primary_destination, 1, 0); 1151 if (stcb->asoc.initial_init_rto_max < net->RTO) { 1152 net->RTO = stcb->asoc.initial_init_rto_max; 1153 } 1154 if (stcb->asoc.numnets > 1) { 1155 /* If we have more than one addr use it */ 1156 struct sctp_nets *alt; 1157 1158 alt = sctp_find_alternate_net(stcb, stcb->asoc.primary_destination, 0); 1159 if ((alt != NULL) && (alt != stcb->asoc.primary_destination)) { 1160 sctp_move_all_chunks_to_alt(stcb, stcb->asoc.primary_destination, alt); 1161 stcb->asoc.primary_destination = alt; 1162 } 1163 } 1164 /* Send out a new init */ 1165 sctp_send_initiate(inp, stcb, SCTP_SO_NOT_LOCKED); 1166 return (0); 1167 } 1168 1169 /* 1170 * For cookie and asconf we actually need to find and mark for resend, then 1171 * increment the resend counter (after all the threshold management stuff of 1172 * course). 1173 */ 1174 int 1175 sctp_cookie_timer(struct sctp_inpcb *inp, 1176 struct sctp_tcb *stcb, 1177 struct sctp_nets *net) 1178 { 1179 struct sctp_nets *alt; 1180 struct sctp_tmit_chunk *cookie; 1181 1182 /* first before all else we must find the cookie */ 1183 TAILQ_FOREACH(cookie, &stcb->asoc.control_send_queue, sctp_next) { 1184 if (cookie->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 1185 break; 1186 } 1187 } 1188 if (cookie == NULL) { 1189 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) { 1190 /* FOOBAR! */ 1191 struct mbuf *oper; 1192 1193 oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 1194 0, M_DONTWAIT, 1, MT_DATA); 1195 if (oper) { 1196 struct sctp_paramhdr *ph; 1197 uint32_t *ippp; 1198 1199 SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 1200 sizeof(uint32_t); 1201 ph = mtod(oper, struct sctp_paramhdr *); 1202 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1203 ph->param_length = htons(SCTP_BUF_LEN(oper)); 1204 ippp = (uint32_t *) (ph + 1); 1205 *ippp = htonl(SCTP_FROM_SCTP_TIMER + SCTP_LOC_3); 1206 } 1207 inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_4; 1208 sctp_abort_an_association(inp, stcb, SCTP_INTERNAL_ERROR, 1209 oper, SCTP_SO_NOT_LOCKED); 1210 } else { 1211 #ifdef INVARIANTS 1212 panic("Cookie timer expires in wrong state?"); 1213 #else 1214 SCTP_PRINTF("Strange in state %d not cookie-echoed yet c-e timer expires?\n", SCTP_GET_STATE(&stcb->asoc)); 1215 return (0); 1216 #endif 1217 } 1218 return (0); 1219 } 1220 /* Ok we found the cookie, threshold management next */ 1221 if (sctp_threshold_management(inp, stcb, cookie->whoTo, 1222 stcb->asoc.max_init_times)) { 1223 /* Assoc is over */ 1224 return (1); 1225 } 1226 /* 1227 * cleared theshold management now lets backoff the address & select 1228 * an alternate 1229 */ 1230 stcb->asoc.dropped_special_cnt = 0; 1231 sctp_backoff_on_timeout(stcb, cookie->whoTo, 1, 0); 1232 alt = sctp_find_alternate_net(stcb, cookie->whoTo, 0); 1233 if (alt != cookie->whoTo) { 1234 sctp_free_remote_addr(cookie->whoTo); 1235 cookie->whoTo = alt; 1236 atomic_add_int(&alt->ref_count, 1); 1237 } 1238 /* Now mark the retran info */ 1239 if (cookie->sent != SCTP_DATAGRAM_RESEND) { 1240 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1241 } 1242 cookie->sent = SCTP_DATAGRAM_RESEND; 1243 /* 1244 * Now call the output routine to kick out the cookie again, Note we 1245 * don't mark any chunks for retran so that FR will need to kick in 1246 * to move these (or a send timer). 1247 */ 1248 return (0); 1249 } 1250 1251 int 1252 sctp_strreset_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1253 struct sctp_nets *net) 1254 { 1255 struct sctp_nets *alt; 1256 struct sctp_tmit_chunk *strrst = NULL, *chk = NULL; 1257 1258 if (stcb->asoc.stream_reset_outstanding == 0) { 1259 return (0); 1260 } 1261 /* find the existing STRRESET, we use the seq number we sent out on */ 1262 (void)sctp_find_stream_reset(stcb, stcb->asoc.str_reset_seq_out, &strrst); 1263 if (strrst == NULL) { 1264 return (0); 1265 } 1266 /* do threshold management */ 1267 if (sctp_threshold_management(inp, stcb, strrst->whoTo, 1268 stcb->asoc.max_send_times)) { 1269 /* Assoc is over */ 1270 return (1); 1271 } 1272 /* 1273 * cleared theshold management now lets backoff the address & select 1274 * an alternate 1275 */ 1276 sctp_backoff_on_timeout(stcb, strrst->whoTo, 1, 0); 1277 alt = sctp_find_alternate_net(stcb, strrst->whoTo, 0); 1278 sctp_free_remote_addr(strrst->whoTo); 1279 strrst->whoTo = alt; 1280 atomic_add_int(&alt->ref_count, 1); 1281 1282 /* See if a ECN Echo is also stranded */ 1283 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 1284 if ((chk->whoTo == net) && 1285 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 1286 sctp_free_remote_addr(chk->whoTo); 1287 if (chk->sent != SCTP_DATAGRAM_RESEND) { 1288 chk->sent = SCTP_DATAGRAM_RESEND; 1289 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1290 } 1291 chk->whoTo = alt; 1292 atomic_add_int(&alt->ref_count, 1); 1293 } 1294 } 1295 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 1296 /* 1297 * If the address went un-reachable, we need to move to 1298 * alternates for ALL chk's in queue 1299 */ 1300 sctp_move_all_chunks_to_alt(stcb, net, alt); 1301 } 1302 /* mark the retran info */ 1303 if (strrst->sent != SCTP_DATAGRAM_RESEND) 1304 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1305 strrst->sent = SCTP_DATAGRAM_RESEND; 1306 1307 /* restart the timer */ 1308 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, inp, stcb, strrst->whoTo); 1309 return (0); 1310 } 1311 1312 int 1313 sctp_asconf_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1314 struct sctp_nets *net) 1315 { 1316 struct sctp_nets *alt; 1317 struct sctp_tmit_chunk *asconf, *chk; 1318 1319 /* is this a first send, or a retransmission? */ 1320 if (stcb->asoc.asconf_sent == 0) { 1321 /* compose a new ASCONF chunk and send it */ 1322 sctp_send_asconf(stcb, net, SCTP_ADDR_NOT_LOCKED); 1323 } else { 1324 /* 1325 * Retransmission of the existing ASCONF is needed 1326 */ 1327 1328 /* find the existing ASCONF */ 1329 TAILQ_FOREACH(asconf, &stcb->asoc.control_send_queue, 1330 sctp_next) { 1331 if (asconf->rec.chunk_id.id == SCTP_ASCONF) { 1332 break; 1333 } 1334 } 1335 if (asconf == NULL) { 1336 return (0); 1337 } 1338 /* do threshold management */ 1339 if (sctp_threshold_management(inp, stcb, asconf->whoTo, 1340 stcb->asoc.max_send_times)) { 1341 /* Assoc is over */ 1342 return (1); 1343 } 1344 if (asconf->snd_count > stcb->asoc.max_send_times) { 1345 /* 1346 * Something is rotten: our peer is not responding 1347 * to ASCONFs but apparently is to other chunks. 1348 * i.e. it is not properly handling the chunk type 1349 * upper bits. Mark this peer as ASCONF incapable 1350 * and cleanup. 1351 */ 1352 SCTPDBG(SCTP_DEBUG_TIMER1, "asconf_timer: Peer has not responded to our repeated ASCONFs\n"); 1353 sctp_asconf_cleanup(stcb, net); 1354 return (0); 1355 } 1356 /* 1357 * cleared threshold management, so now backoff the net and 1358 * select an alternate 1359 */ 1360 sctp_backoff_on_timeout(stcb, asconf->whoTo, 1, 0); 1361 alt = sctp_find_alternate_net(stcb, asconf->whoTo, 0); 1362 sctp_free_remote_addr(asconf->whoTo); 1363 asconf->whoTo = alt; 1364 atomic_add_int(&alt->ref_count, 1); 1365 1366 /* See if an ECN Echo is also stranded */ 1367 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 1368 if ((chk->whoTo == net) && 1369 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 1370 sctp_free_remote_addr(chk->whoTo); 1371 chk->whoTo = alt; 1372 if (chk->sent != SCTP_DATAGRAM_RESEND) { 1373 chk->sent = SCTP_DATAGRAM_RESEND; 1374 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1375 } 1376 atomic_add_int(&alt->ref_count, 1); 1377 } 1378 } 1379 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 1380 /* 1381 * If the address went un-reachable, we need to move 1382 * to the alternate for ALL chunks in queue 1383 */ 1384 sctp_move_all_chunks_to_alt(stcb, net, alt); 1385 } 1386 /* mark the retran info */ 1387 if (asconf->sent != SCTP_DATAGRAM_RESEND) 1388 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1389 asconf->sent = SCTP_DATAGRAM_RESEND; 1390 } 1391 return (0); 1392 } 1393 1394 /* Mobility adaptation */ 1395 void 1396 sctp_delete_prim_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1397 struct sctp_nets *net) 1398 { 1399 if (stcb->asoc.deleted_primary == NULL) { 1400 SCTPDBG(SCTP_DEBUG_ASCONF1, "delete_prim_timer: deleted_primary is not stored...\n"); 1401 sctp_mobility_feature_off(inp, SCTP_MOBILITY_PRIM_DELETED); 1402 return; 1403 } 1404 SCTPDBG(SCTP_DEBUG_ASCONF1, "delete_prim_timer: finished to keep deleted primary "); 1405 SCTPDBG_ADDR(SCTP_DEBUG_ASCONF1, &stcb->asoc.deleted_primary->ro._l_addr.sa); 1406 sctp_free_remote_addr(stcb->asoc.deleted_primary); 1407 stcb->asoc.deleted_primary = NULL; 1408 sctp_mobility_feature_off(inp, SCTP_MOBILITY_PRIM_DELETED); 1409 return; 1410 } 1411 1412 /* 1413 * For the shutdown and shutdown-ack, we do not keep one around on the 1414 * control queue. This means we must generate a new one and call the general 1415 * chunk output routine, AFTER having done threshold management. 1416 */ 1417 int 1418 sctp_shutdown_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1419 struct sctp_nets *net) 1420 { 1421 struct sctp_nets *alt; 1422 1423 /* first threshold managment */ 1424 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) { 1425 /* Assoc is over */ 1426 return (1); 1427 } 1428 /* second select an alternative */ 1429 alt = sctp_find_alternate_net(stcb, net, 0); 1430 1431 /* third generate a shutdown into the queue for out net */ 1432 if (alt) { 1433 sctp_send_shutdown(stcb, alt); 1434 } else { 1435 /* 1436 * if alt is NULL, there is no dest to send to?? 1437 */ 1438 return (0); 1439 } 1440 /* fourth restart timer */ 1441 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, inp, stcb, alt); 1442 return (0); 1443 } 1444 1445 int 1446 sctp_shutdownack_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1447 struct sctp_nets *net) 1448 { 1449 struct sctp_nets *alt; 1450 1451 /* first threshold managment */ 1452 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) { 1453 /* Assoc is over */ 1454 return (1); 1455 } 1456 /* second select an alternative */ 1457 alt = sctp_find_alternate_net(stcb, net, 0); 1458 1459 /* third generate a shutdown into the queue for out net */ 1460 sctp_send_shutdown_ack(stcb, alt); 1461 1462 /* fourth restart timer */ 1463 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, inp, stcb, alt); 1464 return (0); 1465 } 1466 1467 static void 1468 sctp_audit_stream_queues_for_size(struct sctp_inpcb *inp, 1469 struct sctp_tcb *stcb) 1470 { 1471 struct sctp_stream_out *outs; 1472 struct sctp_stream_queue_pending *sp; 1473 unsigned int chks_in_queue = 0; 1474 int being_filled = 0; 1475 1476 /* 1477 * This function is ONLY called when the send/sent queues are empty. 1478 */ 1479 if ((stcb == NULL) || (inp == NULL)) 1480 return; 1481 1482 if (stcb->asoc.sent_queue_retran_cnt) { 1483 SCTP_PRINTF("Hmm, sent_queue_retran_cnt is non-zero %d\n", 1484 stcb->asoc.sent_queue_retran_cnt); 1485 stcb->asoc.sent_queue_retran_cnt = 0; 1486 } 1487 SCTP_TCB_SEND_LOCK(stcb); 1488 if (TAILQ_EMPTY(&stcb->asoc.out_wheel)) { 1489 int i, cnt = 0; 1490 1491 /* Check to see if a spoke fell off the wheel */ 1492 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 1493 if (!TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) { 1494 sctp_insert_on_wheel(stcb, &stcb->asoc, &stcb->asoc.strmout[i], 1); 1495 cnt++; 1496 } 1497 } 1498 if (cnt) { 1499 /* yep, we lost a spoke or two */ 1500 SCTP_PRINTF("Found an additional %d streams NOT on outwheel, corrected\n", cnt); 1501 } else { 1502 /* no spokes lost, */ 1503 stcb->asoc.total_output_queue_size = 0; 1504 } 1505 SCTP_TCB_SEND_UNLOCK(stcb); 1506 return; 1507 } 1508 SCTP_TCB_SEND_UNLOCK(stcb); 1509 /* Check to see if some data queued, if so report it */ 1510 TAILQ_FOREACH(outs, &stcb->asoc.out_wheel, next_spoke) { 1511 if (!TAILQ_EMPTY(&outs->outqueue)) { 1512 TAILQ_FOREACH(sp, &outs->outqueue, next) { 1513 if (sp->msg_is_complete) 1514 being_filled++; 1515 chks_in_queue++; 1516 } 1517 } 1518 } 1519 if (chks_in_queue != stcb->asoc.stream_queue_cnt) { 1520 SCTP_PRINTF("Hmm, stream queue cnt at %d I counted %d in stream out wheel\n", 1521 stcb->asoc.stream_queue_cnt, chks_in_queue); 1522 } 1523 if (chks_in_queue) { 1524 /* call the output queue function */ 1525 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED); 1526 if ((TAILQ_EMPTY(&stcb->asoc.send_queue)) && 1527 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) { 1528 /* 1529 * Probably should go in and make it go back through 1530 * and add fragments allowed 1531 */ 1532 if (being_filled == 0) { 1533 SCTP_PRINTF("Still nothing moved %d chunks are stuck\n", 1534 chks_in_queue); 1535 } 1536 } 1537 } else { 1538 SCTP_PRINTF("Found no chunks on any queue tot:%lu\n", 1539 (u_long)stcb->asoc.total_output_queue_size); 1540 stcb->asoc.total_output_queue_size = 0; 1541 } 1542 } 1543 1544 int 1545 sctp_heartbeat_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1546 struct sctp_nets *net, int cnt_of_unconf) 1547 { 1548 int ret; 1549 1550 if (net) { 1551 if (net->hb_responded == 0) { 1552 if (net->ro._s_addr) { 1553 /* 1554 * Invalidate the src address if we did not 1555 * get a response last time. 1556 */ 1557 sctp_free_ifa(net->ro._s_addr); 1558 net->ro._s_addr = NULL; 1559 net->src_addr_selected = 0; 1560 } 1561 sctp_backoff_on_timeout(stcb, net, 1, 0); 1562 } 1563 /* Zero PBA, if it needs it */ 1564 if (net->partial_bytes_acked) { 1565 net->partial_bytes_acked = 0; 1566 } 1567 } 1568 if ((stcb->asoc.total_output_queue_size > 0) && 1569 (TAILQ_EMPTY(&stcb->asoc.send_queue)) && 1570 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) { 1571 sctp_audit_stream_queues_for_size(inp, stcb); 1572 } 1573 /* Send a new HB, this will do threshold managment, pick a new dest */ 1574 if (cnt_of_unconf == 0) { 1575 if (sctp_send_hb(stcb, 0, NULL) < 0) { 1576 return (1); 1577 } 1578 } else { 1579 /* 1580 * this will send out extra hb's up to maxburst if there are 1581 * any unconfirmed addresses. 1582 */ 1583 uint32_t cnt_sent = 0; 1584 1585 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 1586 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) && 1587 (net->dest_state & SCTP_ADDR_REACHABLE)) { 1588 cnt_sent++; 1589 if (net->hb_responded == 0) { 1590 /* Did we respond last time? */ 1591 if (net->ro._s_addr) { 1592 sctp_free_ifa(net->ro._s_addr); 1593 net->ro._s_addr = NULL; 1594 net->src_addr_selected = 0; 1595 } 1596 } 1597 ret = sctp_send_hb(stcb, 1, net); 1598 if (ret < 0) 1599 return 1; 1600 else if (ret == 0) { 1601 break; 1602 } 1603 if (cnt_sent >= sctp_hb_maxburst) 1604 break; 1605 } 1606 } 1607 } 1608 return (0); 1609 } 1610 1611 int 1612 sctp_is_hb_timer_running(struct sctp_tcb *stcb) 1613 { 1614 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.hb_timer.timer)) { 1615 /* its running */ 1616 return (1); 1617 } else { 1618 /* nope */ 1619 return (0); 1620 } 1621 } 1622 1623 int 1624 sctp_is_sack_timer_running(struct sctp_tcb *stcb) 1625 { 1626 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 1627 /* its running */ 1628 return (1); 1629 } else { 1630 /* nope */ 1631 return (0); 1632 } 1633 } 1634 1635 #define SCTP_NUMBER_OF_MTU_SIZES 18 1636 static uint32_t mtu_sizes[] = { 1637 68, 1638 296, 1639 508, 1640 512, 1641 544, 1642 576, 1643 1006, 1644 1492, 1645 1500, 1646 1536, 1647 2002, 1648 2048, 1649 4352, 1650 4464, 1651 8166, 1652 17914, 1653 32000, 1654 65535 1655 }; 1656 1657 1658 static uint32_t 1659 sctp_getnext_mtu(struct sctp_inpcb *inp, uint32_t cur_mtu) 1660 { 1661 /* select another MTU that is just bigger than this one */ 1662 int i; 1663 1664 for (i = 0; i < SCTP_NUMBER_OF_MTU_SIZES; i++) { 1665 if (cur_mtu < mtu_sizes[i]) { 1666 /* no max_mtu is bigger than this one */ 1667 return (mtu_sizes[i]); 1668 } 1669 } 1670 /* here return the highest allowable */ 1671 return (cur_mtu); 1672 } 1673 1674 1675 void 1676 sctp_pathmtu_timer(struct sctp_inpcb *inp, 1677 struct sctp_tcb *stcb, 1678 struct sctp_nets *net) 1679 { 1680 uint32_t next_mtu; 1681 1682 /* restart the timer in any case */ 1683 next_mtu = sctp_getnext_mtu(inp, net->mtu); 1684 if (next_mtu <= net->mtu) { 1685 /* nothing to do */ 1686 return; 1687 } { 1688 uint32_t mtu; 1689 1690 if ((net->src_addr_selected == 0) || 1691 (net->ro._s_addr == NULL) || 1692 (net->ro._s_addr->localifa_flags & SCTP_BEING_DELETED)) { 1693 if ((net->ro._s_addr != NULL) && (net->ro._s_addr->localifa_flags & SCTP_BEING_DELETED)) { 1694 sctp_free_ifa(net->ro._s_addr); 1695 net->ro._s_addr = NULL; 1696 net->src_addr_selected = 0; 1697 } else if (net->ro._s_addr == NULL) { 1698 net->ro._s_addr = sctp_source_address_selection(inp, 1699 stcb, 1700 (sctp_route_t *) & net->ro, 1701 net, 0, stcb->asoc.vrf_id); 1702 } 1703 if (net->ro._s_addr) 1704 net->src_addr_selected = 1; 1705 } 1706 if (net->ro._s_addr) { 1707 mtu = SCTP_GATHER_MTU_FROM_ROUTE(net->ro._s_addr, &net->ro._s_addr.sa, net->ro.ro_rt); 1708 if (mtu > next_mtu) { 1709 net->mtu = next_mtu; 1710 } 1711 } 1712 } 1713 /* restart the timer */ 1714 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net); 1715 } 1716 1717 void 1718 sctp_autoclose_timer(struct sctp_inpcb *inp, 1719 struct sctp_tcb *stcb, 1720 struct sctp_nets *net) 1721 { 1722 struct timeval tn, *tim_touse; 1723 struct sctp_association *asoc; 1724 int ticks_gone_by; 1725 1726 (void)SCTP_GETTIME_TIMEVAL(&tn); 1727 if (stcb->asoc.sctp_autoclose_ticks && 1728 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE)) { 1729 /* Auto close is on */ 1730 asoc = &stcb->asoc; 1731 /* pick the time to use */ 1732 if (asoc->time_last_rcvd.tv_sec > 1733 asoc->time_last_sent.tv_sec) { 1734 tim_touse = &asoc->time_last_rcvd; 1735 } else { 1736 tim_touse = &asoc->time_last_sent; 1737 } 1738 /* Now has long enough transpired to autoclose? */ 1739 ticks_gone_by = SEC_TO_TICKS(tn.tv_sec - tim_touse->tv_sec); 1740 if ((ticks_gone_by > 0) && 1741 (ticks_gone_by >= (int)asoc->sctp_autoclose_ticks)) { 1742 /* 1743 * autoclose time has hit, call the output routine, 1744 * which should do nothing just to be SURE we don't 1745 * have hanging data. We can then safely check the 1746 * queues and know that we are clear to send 1747 * shutdown 1748 */ 1749 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR, SCTP_SO_NOT_LOCKED); 1750 /* Are we clean? */ 1751 if (TAILQ_EMPTY(&asoc->send_queue) && 1752 TAILQ_EMPTY(&asoc->sent_queue)) { 1753 /* 1754 * there is nothing queued to send, so I'm 1755 * done... 1756 */ 1757 if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) { 1758 /* only send SHUTDOWN 1st time thru */ 1759 sctp_send_shutdown(stcb, stcb->asoc.primary_destination); 1760 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 1761 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 1762 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 1763 } 1764 SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_SENT); 1765 SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 1766 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 1767 stcb->sctp_ep, stcb, 1768 asoc->primary_destination); 1769 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 1770 stcb->sctp_ep, stcb, 1771 asoc->primary_destination); 1772 } 1773 } 1774 } else { 1775 /* 1776 * No auto close at this time, reset t-o to check 1777 * later 1778 */ 1779 int tmp; 1780 1781 /* fool the timer startup to use the time left */ 1782 tmp = asoc->sctp_autoclose_ticks; 1783 asoc->sctp_autoclose_ticks -= ticks_gone_by; 1784 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb, 1785 net); 1786 /* restore the real tick value */ 1787 asoc->sctp_autoclose_ticks = tmp; 1788 } 1789 } 1790 } 1791 1792 void 1793 sctp_iterator_timer(struct sctp_iterator *it) 1794 { 1795 int iteration_count = 0; 1796 int inp_skip = 0; 1797 1798 /* 1799 * only one iterator can run at a time. This is the only way we can 1800 * cleanly pull ep's from underneath all the running interators when 1801 * a ep is freed. 1802 */ 1803 SCTP_ITERATOR_LOCK(); 1804 if (it->inp == NULL) { 1805 /* iterator is complete */ 1806 done_with_iterator: 1807 SCTP_ITERATOR_UNLOCK(); 1808 SCTP_INP_INFO_WLOCK(); 1809 TAILQ_REMOVE(&sctppcbinfo.iteratorhead, it, sctp_nxt_itr); 1810 /* stopping the callout is not needed, in theory */ 1811 SCTP_INP_INFO_WUNLOCK(); 1812 (void)SCTP_OS_TIMER_STOP(&it->tmr.timer); 1813 if (it->function_atend != NULL) { 1814 (*it->function_atend) (it->pointer, it->val); 1815 } 1816 SCTP_FREE(it, SCTP_M_ITER); 1817 return; 1818 } 1819 select_a_new_ep: 1820 SCTP_INP_WLOCK(it->inp); 1821 while (((it->pcb_flags) && 1822 ((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) || 1823 ((it->pcb_features) && 1824 ((it->inp->sctp_features & it->pcb_features) != it->pcb_features))) { 1825 /* endpoint flags or features don't match, so keep looking */ 1826 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 1827 SCTP_INP_WUNLOCK(it->inp); 1828 goto done_with_iterator; 1829 } 1830 SCTP_INP_WUNLOCK(it->inp); 1831 it->inp = LIST_NEXT(it->inp, sctp_list); 1832 if (it->inp == NULL) { 1833 goto done_with_iterator; 1834 } 1835 SCTP_INP_WLOCK(it->inp); 1836 } 1837 if ((it->inp->inp_starting_point_for_iterator != NULL) && 1838 (it->inp->inp_starting_point_for_iterator != it)) { 1839 SCTP_PRINTF("Iterator collision, waiting for one at %p\n", 1840 it->inp); 1841 SCTP_INP_WUNLOCK(it->inp); 1842 goto start_timer_return; 1843 } 1844 /* mark the current iterator on the endpoint */ 1845 it->inp->inp_starting_point_for_iterator = it; 1846 SCTP_INP_WUNLOCK(it->inp); 1847 SCTP_INP_RLOCK(it->inp); 1848 /* now go through each assoc which is in the desired state */ 1849 if (it->done_current_ep == 0) { 1850 if (it->function_inp != NULL) 1851 inp_skip = (*it->function_inp) (it->inp, it->pointer, it->val); 1852 it->done_current_ep = 1; 1853 } 1854 if (it->stcb == NULL) { 1855 /* run the per instance function */ 1856 it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list); 1857 } 1858 SCTP_INP_RUNLOCK(it->inp); 1859 if ((inp_skip) || it->stcb == NULL) { 1860 if (it->function_inp_end != NULL) { 1861 inp_skip = (*it->function_inp_end) (it->inp, 1862 it->pointer, 1863 it->val); 1864 } 1865 goto no_stcb; 1866 } 1867 if ((it->stcb) && 1868 (it->stcb->asoc.stcb_starting_point_for_iterator == it)) { 1869 it->stcb->asoc.stcb_starting_point_for_iterator = NULL; 1870 } 1871 while (it->stcb) { 1872 SCTP_TCB_LOCK(it->stcb); 1873 if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) { 1874 /* not in the right state... keep looking */ 1875 SCTP_TCB_UNLOCK(it->stcb); 1876 goto next_assoc; 1877 } 1878 /* mark the current iterator on the assoc */ 1879 it->stcb->asoc.stcb_starting_point_for_iterator = it; 1880 /* see if we have limited out the iterator loop */ 1881 iteration_count++; 1882 if (iteration_count > SCTP_ITERATOR_MAX_AT_ONCE) { 1883 start_timer_return: 1884 /* set a timer to continue this later */ 1885 if (it->stcb) 1886 SCTP_TCB_UNLOCK(it->stcb); 1887 sctp_timer_start(SCTP_TIMER_TYPE_ITERATOR, 1888 (struct sctp_inpcb *)it, NULL, NULL); 1889 SCTP_ITERATOR_UNLOCK(); 1890 return; 1891 } 1892 /* run function on this one */ 1893 (*it->function_assoc) (it->inp, it->stcb, it->pointer, it->val); 1894 1895 /* 1896 * we lie here, it really needs to have its own type but 1897 * first I must verify that this won't effect things :-0 1898 */ 1899 if (it->no_chunk_output == 0) 1900 sctp_chunk_output(it->inp, it->stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED); 1901 1902 SCTP_TCB_UNLOCK(it->stcb); 1903 next_assoc: 1904 it->stcb = LIST_NEXT(it->stcb, sctp_tcblist); 1905 if (it->stcb == NULL) { 1906 if (it->function_inp_end != NULL) { 1907 inp_skip = (*it->function_inp_end) (it->inp, 1908 it->pointer, 1909 it->val); 1910 } 1911 } 1912 } 1913 no_stcb: 1914 /* done with all assocs on this endpoint, move on to next endpoint */ 1915 it->done_current_ep = 0; 1916 SCTP_INP_WLOCK(it->inp); 1917 it->inp->inp_starting_point_for_iterator = NULL; 1918 SCTP_INP_WUNLOCK(it->inp); 1919 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 1920 it->inp = NULL; 1921 } else { 1922 SCTP_INP_INFO_RLOCK(); 1923 it->inp = LIST_NEXT(it->inp, sctp_list); 1924 SCTP_INP_INFO_RUNLOCK(); 1925 } 1926 if (it->inp == NULL) { 1927 goto done_with_iterator; 1928 } 1929 goto select_a_new_ep; 1930 } 1931