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