1 /*- 2 * Copyright (c) 2001-2007, 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 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 #ifdef SCTP_EARLYFR_LOGGING 124 sctp_log_fr(chk->rec.data.TSN_seq, chk->snd_count, 125 4, SCTP_FR_MARKED_EARLY); 126 #endif 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 #ifdef SCTP_CWND_MONITOR 141 int old_cwnd; 142 143 old_cwnd = net->cwnd; 144 #endif 145 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_EARLY_FR_TMR); 146 /* 147 * make a small adjustment to cwnd and force to CA. 148 */ 149 150 if (net->cwnd > net->mtu) 151 /* drop down one MTU after sending */ 152 net->cwnd -= net->mtu; 153 if (net->cwnd < net->ssthresh) 154 /* still in SS move to CA */ 155 net->ssthresh = net->cwnd - 1; 156 #ifdef SCTP_CWND_MONITOR 157 sctp_log_cwnd(stcb, net, (old_cwnd - net->cwnd), SCTP_CWND_LOG_FROM_FR); 158 #endif 159 } else if (cnt_resend) { 160 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_EARLY_FR_TMR); 161 } 162 /* Restart it? */ 163 if (net->flight_size < net->cwnd) { 164 SCTP_STAT_INCR(sctps_earlyfrstrtmr); 165 sctp_timer_start(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net); 166 } 167 } 168 169 void 170 sctp_audit_retranmission_queue(struct sctp_association *asoc) 171 { 172 struct sctp_tmit_chunk *chk; 173 174 #ifdef SCTP_DEBUG 175 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 176 printf("Audit invoked on send queue cnt:%d onqueue:%d\n", 177 asoc->sent_queue_retran_cnt, 178 asoc->sent_queue_cnt); 179 } 180 #endif /* SCTP_DEBUG */ 181 asoc->sent_queue_retran_cnt = 0; 182 asoc->sent_queue_cnt = 0; 183 TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 184 if (chk->sent == SCTP_DATAGRAM_RESEND) { 185 sctp_ucount_incr(asoc->sent_queue_retran_cnt); 186 } 187 asoc->sent_queue_cnt++; 188 } 189 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 190 if (chk->sent == SCTP_DATAGRAM_RESEND) { 191 sctp_ucount_incr(asoc->sent_queue_retran_cnt); 192 } 193 } 194 #ifdef SCTP_DEBUG 195 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 196 printf("Audit completes retran:%d onqueue:%d\n", 197 asoc->sent_queue_retran_cnt, 198 asoc->sent_queue_cnt); 199 } 200 #endif /* SCTP_DEBUG */ 201 } 202 203 204 int 205 sctp_threshold_management(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 206 struct sctp_nets *net, uint16_t threshold) 207 { 208 if (net) { 209 net->error_count++; 210 #ifdef SCTP_DEBUG 211 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 212 printf("Error count for %p now %d thresh:%d\n", 213 net, net->error_count, 214 net->failure_threshold); 215 } 216 #endif /* SCTP_DEBUG */ 217 if (net->error_count > net->failure_threshold) { 218 /* We had a threshold failure */ 219 if (net->dest_state & SCTP_ADDR_REACHABLE) { 220 net->dest_state &= ~SCTP_ADDR_REACHABLE; 221 net->dest_state |= SCTP_ADDR_NOT_REACHABLE; 222 net->dest_state &= ~SCTP_ADDR_REQ_PRIMARY; 223 if (net == stcb->asoc.primary_destination) { 224 net->dest_state |= SCTP_ADDR_WAS_PRIMARY; 225 } 226 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, 227 stcb, 228 SCTP_FAILED_THRESHOLD, 229 (void *)net); 230 } 231 } 232 /*********HOLD THIS COMMENT FOR PATCH OF ALTERNATE 233 *********ROUTING CODE 234 */ 235 /*********HOLD THIS COMMENT FOR END OF PATCH OF ALTERNATE 236 *********ROUTING CODE 237 */ 238 } 239 if (stcb == NULL) 240 return (0); 241 242 if (net) { 243 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) { 244 stcb->asoc.overall_error_count++; 245 } 246 } else { 247 stcb->asoc.overall_error_count++; 248 } 249 #ifdef SCTP_DEBUG 250 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 251 printf("Overall error count for %p now %d thresh:%u state:%x\n", 252 &stcb->asoc, 253 stcb->asoc.overall_error_count, 254 (uint32_t) threshold, 255 ((net == NULL) ? (uint32_t) 0 : (uint32_t) net->dest_state)); 256 } 257 #endif /* SCTP_DEBUG */ 258 /* 259 * We specifically do not do >= to give the assoc one more change 260 * before we fail it. 261 */ 262 if (stcb->asoc.overall_error_count > threshold) { 263 /* Abort notification sends a ULP notify */ 264 struct mbuf *oper; 265 266 oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 267 0, M_DONTWAIT, 1, MT_DATA); 268 if (oper) { 269 struct sctp_paramhdr *ph; 270 uint32_t *ippp; 271 272 SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 273 sizeof(uint32_t); 274 ph = mtod(oper, struct sctp_paramhdr *); 275 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 276 ph->param_length = htons(SCTP_BUF_LEN(oper)); 277 ippp = (uint32_t *) (ph + 1); 278 *ippp = htonl(SCTP_FROM_SCTP_TIMER + SCTP_LOC_1); 279 } 280 inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_1; 281 sctp_abort_an_association(inp, stcb, SCTP_FAILED_THRESHOLD, oper); 282 return (1); 283 } 284 return (0); 285 } 286 287 struct sctp_nets * 288 sctp_find_alternate_net(struct sctp_tcb *stcb, 289 struct sctp_nets *net, 290 int highest_ssthresh) 291 { 292 /* Find and return an alternate network if possible */ 293 struct sctp_nets *alt, *mnet, *hthresh = NULL; 294 int once; 295 uint32_t val = 0; 296 297 if (stcb->asoc.numnets == 1) { 298 /* No others but net */ 299 return (TAILQ_FIRST(&stcb->asoc.nets)); 300 } 301 if (highest_ssthresh) { 302 TAILQ_FOREACH(mnet, &stcb->asoc.nets, sctp_next) { 303 if (((mnet->dest_state & SCTP_ADDR_REACHABLE) != SCTP_ADDR_REACHABLE) || 304 (mnet->dest_state & SCTP_ADDR_UNCONFIRMED) 305 ) { 306 /* 307 * will skip ones that are not-reachable or 308 * unconfirmed 309 */ 310 continue; 311 } 312 if (val > mnet->ssthresh) { 313 hthresh = mnet; 314 val = mnet->ssthresh; 315 } else if (val == mnet->ssthresh) { 316 uint32_t rndval; 317 uint8_t this_random; 318 319 if (stcb->asoc.hb_random_idx > 3) { 320 rndval = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep); 321 memcpy(stcb->asoc.hb_random_values, &rndval, 322 sizeof(stcb->asoc.hb_random_values)); 323 this_random = stcb->asoc.hb_random_values[0]; 324 stcb->asoc.hb_random_idx = 0; 325 stcb->asoc.hb_ect_randombit = 0; 326 } else { 327 this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx]; 328 stcb->asoc.hb_random_idx++; 329 stcb->asoc.hb_ect_randombit = 0; 330 } 331 if (this_random % 2) { 332 hthresh = mnet; 333 val = mnet->ssthresh; 334 } 335 } 336 } 337 if (hthresh) { 338 return (hthresh); 339 } 340 } 341 mnet = net; 342 once = 0; 343 344 if (mnet == NULL) { 345 mnet = TAILQ_FIRST(&stcb->asoc.nets); 346 } 347 do { 348 alt = TAILQ_NEXT(mnet, sctp_next); 349 if (alt == NULL) { 350 once++; 351 if (once > 1) { 352 break; 353 } 354 alt = TAILQ_FIRST(&stcb->asoc.nets); 355 } 356 if (alt->ro.ro_rt == NULL) { 357 struct sockaddr_in6 *sin6; 358 359 sin6 = (struct sockaddr_in6 *)&alt->ro._l_addr; 360 if (sin6->sin6_family == AF_INET6) { 361 (void)sa6_embedscope(sin6, ip6_use_defzone); 362 } 363 rtalloc_ign((struct route *)&alt->ro, 0UL); 364 365 if (sin6->sin6_family == AF_INET6) { 366 (void)sa6_recoverscope(sin6); 367 } 368 if (alt->ro._s_addr) { 369 sctp_free_ifa(alt->ro._s_addr); 370 alt->ro._s_addr = NULL; 371 } 372 alt->src_addr_selected = 0; 373 } 374 if ( 375 ((alt->dest_state & SCTP_ADDR_REACHABLE) == SCTP_ADDR_REACHABLE) && 376 (alt->ro.ro_rt != NULL) && 377 (!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) 378 ) { 379 /* Found a reachable address */ 380 break; 381 } 382 mnet = alt; 383 } while (alt != NULL); 384 385 if (alt == NULL) { 386 /* Case where NO insv network exists (dormant state) */ 387 /* we rotate destinations */ 388 once = 0; 389 mnet = net; 390 do { 391 alt = TAILQ_NEXT(mnet, sctp_next); 392 if (alt == NULL) { 393 once++; 394 if (once > 1) { 395 break; 396 } 397 alt = TAILQ_FIRST(&stcb->asoc.nets); 398 } 399 if ((!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) && 400 (alt != net)) { 401 /* Found an alternate address */ 402 break; 403 } 404 mnet = alt; 405 } while (alt != NULL); 406 } 407 if (alt == NULL) { 408 return (net); 409 } 410 return (alt); 411 } 412 413 static void 414 sctp_backoff_on_timeout(struct sctp_tcb *stcb, 415 struct sctp_nets *net, 416 int win_probe, 417 int num_marked) 418 { 419 net->RTO <<= 1; 420 if (net->RTO > stcb->asoc.maxrto) { 421 net->RTO = stcb->asoc.maxrto; 422 } 423 if ((win_probe == 0) && num_marked) { 424 /* We don't apply penalty to window probe scenarios */ 425 #ifdef SCTP_CWND_MONITOR 426 int old_cwnd = net->cwnd; 427 428 #endif 429 net->ssthresh = net->cwnd >> 1; 430 if (net->ssthresh < (net->mtu << 1)) { 431 net->ssthresh = (net->mtu << 1); 432 } 433 net->cwnd = net->mtu; 434 /* floor of 1 mtu */ 435 if (net->cwnd < net->mtu) 436 net->cwnd = net->mtu; 437 #ifdef SCTP_CWND_MONITOR 438 sctp_log_cwnd(stcb, net, net->cwnd - old_cwnd, SCTP_CWND_LOG_FROM_RTX); 439 #endif 440 441 net->partial_bytes_acked = 0; 442 } 443 } 444 445 static int 446 sctp_mark_all_for_resend(struct sctp_tcb *stcb, 447 struct sctp_nets *net, 448 struct sctp_nets *alt, 449 int window_probe, 450 int *num_marked) 451 { 452 453 /* 454 * Mark all chunks (well not all) that were sent to *net for 455 * retransmission. Move them to alt for there destination as well... 456 * We only mark chunks that have been outstanding long enough to 457 * have received feed-back. 458 */ 459 struct sctp_tmit_chunk *chk, *tp2, *could_be_sent = NULL; 460 struct sctp_nets *lnets; 461 struct timeval now, min_wait, tv; 462 int cur_rtt; 463 int orig_rwnd, audit_tf, num_mk, fir; 464 unsigned int cnt_mk; 465 uint32_t orig_flight; 466 uint32_t tsnlast, tsnfirst; 467 468 /* 469 * CMT: Using RTX_SSTHRESH policy for CMT. If CMT is being used, 470 * then pick dest with largest ssthresh for any retransmission. 471 * (iyengar@cis.udel.edu, 2005/08/12) 472 */ 473 if (sctp_cmt_on_off) { 474 alt = sctp_find_alternate_net(stcb, net, 1); 475 /* 476 * CUCv2: If a different dest is picked for the 477 * retransmission, then new (rtx-)pseudo_cumack needs to be 478 * tracked for orig dest. Let CUCv2 track new (rtx-) 479 * pseudo-cumack always. 480 */ 481 net->find_pseudo_cumack = 1; 482 net->find_rtx_pseudo_cumack = 1; 483 } 484 /* none in flight now */ 485 audit_tf = 0; 486 fir = 0; 487 /* 488 * figure out how long a data chunk must be pending before we can 489 * mark it .. 490 */ 491 SCTP_GETTIME_TIMEVAL(&now); 492 /* get cur rto in micro-seconds */ 493 cur_rtt = (((net->lastsa >> 2) + net->lastsv) >> 1); 494 cur_rtt *= 1000; 495 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 496 sctp_log_fr(cur_rtt, 497 stcb->asoc.peers_rwnd, 498 window_probe, 499 SCTP_FR_T3_MARK_TIME); 500 sctp_log_fr(net->flight_size, 501 SCTP_OS_TIMER_PENDING(&net->fr_timer.timer), 502 SCTP_OS_TIMER_ACTIVE(&net->fr_timer.timer), 503 SCTP_FR_CWND_REPORT); 504 sctp_log_fr(net->flight_size, net->cwnd, stcb->asoc.total_flight, SCTP_FR_CWND_REPORT); 505 #endif 506 tv.tv_sec = cur_rtt / 1000000; 507 tv.tv_usec = cur_rtt % 1000000; 508 min_wait = now; 509 timevalsub(&min_wait, &tv); 510 if (min_wait.tv_sec < 0 || min_wait.tv_usec < 0) { 511 /* 512 * if we hit here, we don't have enough seconds on the clock 513 * to account for the RTO. We just let the lower seconds be 514 * the bounds and don't worry about it. This may mean we 515 * will mark a lot more than we should. 516 */ 517 min_wait.tv_sec = min_wait.tv_usec = 0; 518 } 519 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 520 sctp_log_fr(cur_rtt, now.tv_sec, now.tv_usec, SCTP_FR_T3_MARK_TIME); 521 sctp_log_fr(0, min_wait.tv_sec, min_wait.tv_usec, SCTP_FR_T3_MARK_TIME); 522 #endif 523 /* 524 * Our rwnd will be incorrect here since we are not adding back the 525 * cnt * mbuf but we will fix that down below. 526 */ 527 orig_rwnd = stcb->asoc.peers_rwnd; 528 orig_flight = net->flight_size; 529 net->fast_retran_ip = 0; 530 /* Now on to each chunk */ 531 num_mk = cnt_mk = 0; 532 tsnfirst = tsnlast = 0; 533 chk = TAILQ_FIRST(&stcb->asoc.sent_queue); 534 for (; chk != NULL; chk = tp2) { 535 tp2 = TAILQ_NEXT(chk, sctp_next); 536 if ((compare_with_wrap(stcb->asoc.last_acked_seq, 537 chk->rec.data.TSN_seq, 538 MAX_TSN)) || 539 (stcb->asoc.last_acked_seq == chk->rec.data.TSN_seq)) { 540 /* Strange case our list got out of order? */ 541 printf("Our list is out of order?\n"); 542 panic("Out of order list"); 543 } 544 if ((chk->whoTo == net) && (chk->sent < SCTP_DATAGRAM_ACKED)) { 545 /* 546 * found one to mark: If it is less than 547 * DATAGRAM_ACKED it MUST not be a skipped or marked 548 * TSN but instead one that is either already set 549 * for retransmission OR one that needs 550 * retransmission. 551 */ 552 553 /* validate its been outstanding long enough */ 554 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 555 sctp_log_fr(chk->rec.data.TSN_seq, 556 chk->sent_rcv_time.tv_sec, 557 chk->sent_rcv_time.tv_usec, 558 SCTP_FR_T3_MARK_TIME); 559 #endif 560 if ((chk->sent_rcv_time.tv_sec > min_wait.tv_sec) && (window_probe == 0)) { 561 /* 562 * we have reached a chunk that was sent 563 * some seconds past our min.. forget it we 564 * will find no more to send. 565 */ 566 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 567 sctp_log_fr(0, 568 chk->sent_rcv_time.tv_sec, 569 chk->sent_rcv_time.tv_usec, 570 SCTP_FR_T3_STOPPED); 571 #endif 572 continue; 573 } else if ((chk->sent_rcv_time.tv_sec == min_wait.tv_sec) && 574 (window_probe == 0)) { 575 /* 576 * we must look at the micro seconds to 577 * know. 578 */ 579 if (chk->sent_rcv_time.tv_usec >= min_wait.tv_usec) { 580 /* 581 * ok it was sent after our boundary 582 * time. 583 */ 584 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 585 sctp_log_fr(0, 586 chk->sent_rcv_time.tv_sec, 587 chk->sent_rcv_time.tv_usec, 588 SCTP_FR_T3_STOPPED); 589 #endif 590 continue; 591 } 592 } 593 if (PR_SCTP_TTL_ENABLED(chk->flags)) { 594 /* Is it expired? */ 595 if ((now.tv_sec > chk->rec.data.timetodrop.tv_sec) || 596 ((chk->rec.data.timetodrop.tv_sec == now.tv_sec) && 597 (now.tv_usec > chk->rec.data.timetodrop.tv_usec))) { 598 /* Yes so drop it */ 599 if (chk->data) { 600 sctp_release_pr_sctp_chunk(stcb, 601 chk, 602 (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 603 &stcb->asoc.sent_queue); 604 } 605 } 606 continue; 607 } 608 if (PR_SCTP_RTX_ENABLED(chk->flags)) { 609 /* Has it been retransmitted tv_sec times? */ 610 if (chk->snd_count > chk->rec.data.timetodrop.tv_sec) { 611 if (chk->data) { 612 sctp_release_pr_sctp_chunk(stcb, 613 chk, 614 (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 615 &stcb->asoc.sent_queue); 616 } 617 } 618 continue; 619 } 620 if (chk->sent != SCTP_DATAGRAM_RESEND) { 621 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 622 num_mk++; 623 if (fir == 0) { 624 fir = 1; 625 tsnfirst = chk->rec.data.TSN_seq; 626 } 627 tsnlast = chk->rec.data.TSN_seq; 628 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 629 sctp_log_fr(chk->rec.data.TSN_seq, chk->snd_count, 630 0, SCTP_FR_T3_MARKED); 631 632 #endif 633 } 634 if (stcb->asoc.total_flight_count > 0) 635 stcb->asoc.total_flight_count--; 636 if (chk->rec.data.chunk_was_revoked) { 637 /* deflate the cwnd */ 638 chk->whoTo->cwnd -= chk->book_size; 639 chk->rec.data.chunk_was_revoked = 0; 640 } 641 chk->sent = SCTP_DATAGRAM_RESEND; 642 SCTP_STAT_INCR(sctps_markedretrans); 643 net->marked_retrans++; 644 stcb->asoc.marked_retrans++; 645 #ifdef SCTP_FLIGHT_LOGGING 646 sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN, 647 chk->whoTo->flight_size, 648 chk->book_size, 649 (uintptr_t) stcb, 650 chk->rec.data.TSN_seq); 651 #endif 652 653 if (net->flight_size >= chk->book_size) 654 net->flight_size -= chk->book_size; 655 else 656 net->flight_size = 0; 657 658 stcb->asoc.peers_rwnd += chk->send_size; 659 stcb->asoc.peers_rwnd += sctp_peer_chunk_oh; 660 661 /* reset the TSN for striking and other FR stuff */ 662 chk->rec.data.doing_fast_retransmit = 0; 663 /* Clear any time so NO RTT is being done */ 664 chk->do_rtt = 0; 665 if (alt != net) { 666 sctp_free_remote_addr(chk->whoTo); 667 chk->no_fr_allowed = 1; 668 chk->whoTo = alt; 669 atomic_add_int(&alt->ref_count, 1); 670 } else { 671 chk->no_fr_allowed = 0; 672 if (TAILQ_EMPTY(&stcb->asoc.send_queue)) { 673 chk->rec.data.fast_retran_tsn = stcb->asoc.sending_seq; 674 } else { 675 chk->rec.data.fast_retran_tsn = (TAILQ_FIRST(&stcb->asoc.send_queue))->rec.data.TSN_seq; 676 } 677 } 678 if (sctp_cmt_on_off == 1) { 679 chk->no_fr_allowed = 1; 680 } 681 } else if (chk->sent == SCTP_DATAGRAM_ACKED) { 682 /* remember highest acked one */ 683 could_be_sent = chk; 684 } 685 if (chk->sent == SCTP_DATAGRAM_RESEND) { 686 cnt_mk++; 687 } 688 } 689 #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 690 sctp_log_fr(tsnfirst, tsnlast, num_mk, SCTP_FR_T3_TIMEOUT); 691 #endif 692 693 if (stcb->asoc.total_flight >= (orig_flight - net->flight_size)) { 694 stcb->asoc.total_flight -= (orig_flight - net->flight_size); 695 } else { 696 stcb->asoc.total_flight = 0; 697 stcb->asoc.total_flight_count = 0; 698 audit_tf = 1; 699 } 700 701 #ifdef SCTP_DEBUG 702 if (sctp_debug_on & SCTP_DEBUG_TIMER1) { 703 if (num_mk) { 704 printf("LAST TSN marked was %x\n", tsnlast); 705 printf("Num marked for retransmission was %d peer-rwd:%ld\n", 706 num_mk, (u_long)stcb->asoc.peers_rwnd); 707 printf("LAST TSN marked was %x\n", tsnlast); 708 printf("Num marked for retransmission was %d peer-rwd:%d\n", 709 num_mk, 710 (int)stcb->asoc.peers_rwnd 711 ); 712 } 713 } 714 #endif 715 *num_marked = num_mk; 716 if ((stcb->asoc.sent_queue_retran_cnt == 0) && (could_be_sent)) { 717 /* fix it so we retransmit the highest acked anyway */ 718 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 719 cnt_mk++; 720 could_be_sent->sent = SCTP_DATAGRAM_RESEND; 721 } 722 if (stcb->asoc.sent_queue_retran_cnt != cnt_mk) { 723 #ifdef INVARIANTS 724 printf("Local Audit says there are %d for retran asoc cnt:%d\n", 725 cnt_mk, stcb->asoc.sent_queue_retran_cnt); 726 #endif 727 #ifndef SCTP_AUDITING_ENABLED 728 stcb->asoc.sent_queue_retran_cnt = cnt_mk; 729 #endif 730 } 731 /* Now check for a ECN Echo that may be stranded */ 732 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 733 if ((chk->whoTo == net) && 734 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 735 sctp_free_remote_addr(chk->whoTo); 736 chk->whoTo = alt; 737 if (chk->sent != SCTP_DATAGRAM_RESEND) { 738 chk->sent = SCTP_DATAGRAM_RESEND; 739 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 740 } 741 atomic_add_int(&alt->ref_count, 1); 742 } 743 } 744 if (audit_tf) { 745 #ifdef SCTP_DEBUG 746 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 747 printf("Audit total flight due to negative value net:%p\n", 748 net); 749 } 750 #endif /* SCTP_DEBUG */ 751 stcb->asoc.total_flight = 0; 752 stcb->asoc.total_flight_count = 0; 753 /* Clear all networks flight size */ 754 TAILQ_FOREACH(lnets, &stcb->asoc.nets, sctp_next) { 755 lnets->flight_size = 0; 756 #ifdef SCTP_DEBUG 757 if (sctp_debug_on & SCTP_DEBUG_TIMER4) { 758 printf("Net:%p c-f cwnd:%d ssthresh:%d\n", 759 lnets, lnets->cwnd, lnets->ssthresh); 760 } 761 #endif /* SCTP_DEBUG */ 762 } 763 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 764 if (chk->sent < SCTP_DATAGRAM_RESEND) { 765 #ifdef SCTP_FLIGHT_LOGGING 766 sctp_misc_ints(SCTP_FLIGHT_LOG_UP, 767 chk->whoTo->flight_size, 768 chk->book_size, 769 (uintptr_t) stcb, 770 chk->rec.data.TSN_seq); 771 #endif 772 stcb->asoc.total_flight += chk->book_size; 773 chk->whoTo->flight_size += chk->book_size; 774 stcb->asoc.total_flight_count++; 775 } 776 } 777 } 778 /* 779 * Setup the ecn nonce re-sync point. We do this since 780 * retranmissions are NOT setup for ECN. This means that do to 781 * Karn's rule, we don't know the total of the peers ecn bits. 782 */ 783 chk = TAILQ_FIRST(&stcb->asoc.send_queue); 784 if (chk == NULL) { 785 stcb->asoc.nonce_resync_tsn = stcb->asoc.sending_seq; 786 } else { 787 stcb->asoc.nonce_resync_tsn = chk->rec.data.TSN_seq; 788 } 789 stcb->asoc.nonce_wait_for_ecne = 0; 790 stcb->asoc.nonce_sum_check = 0; 791 /* We return 1 if we only have a window probe outstanding */ 792 return (0); 793 } 794 795 static void 796 sctp_move_all_chunks_to_alt(struct sctp_tcb *stcb, 797 struct sctp_nets *net, 798 struct sctp_nets *alt) 799 { 800 struct sctp_association *asoc; 801 struct sctp_stream_out *outs; 802 struct sctp_tmit_chunk *chk; 803 struct sctp_stream_queue_pending *sp; 804 805 if (net == alt) 806 /* nothing to do */ 807 return; 808 809 asoc = &stcb->asoc; 810 811 /* 812 * now through all the streams checking for chunks sent to our bad 813 * network. 814 */ 815 TAILQ_FOREACH(outs, &asoc->out_wheel, next_spoke) { 816 /* now clean up any chunks here */ 817 TAILQ_FOREACH(sp, &outs->outqueue, next) { 818 if (sp->net == net) { 819 sctp_free_remote_addr(sp->net); 820 sp->net = alt; 821 atomic_add_int(&alt->ref_count, 1); 822 } 823 } 824 } 825 /* Now check the pending queue */ 826 TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) { 827 if (chk->whoTo == net) { 828 sctp_free_remote_addr(chk->whoTo); 829 chk->whoTo = alt; 830 atomic_add_int(&alt->ref_count, 1); 831 } 832 } 833 834 } 835 836 int 837 sctp_t3rxt_timer(struct sctp_inpcb *inp, 838 struct sctp_tcb *stcb, 839 struct sctp_nets *net) 840 { 841 struct sctp_nets *alt; 842 int win_probe, num_mk; 843 844 #ifdef SCTP_FR_LOGGING 845 sctp_log_fr(0, 0, 0, SCTP_FR_T3_TIMEOUT); 846 #ifdef SCTP_CWND_LOGGING 847 { 848 struct sctp_nets *lnet; 849 850 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 851 if (net == lnet) { 852 sctp_log_cwnd(stcb, lnet, 1, SCTP_CWND_LOG_FROM_T3); 853 } else { 854 sctp_log_cwnd(stcb, lnet, 0, SCTP_CWND_LOG_FROM_T3); 855 } 856 } 857 } 858 #endif 859 #endif 860 /* Find an alternate and mark those for retransmission */ 861 if ((stcb->asoc.peers_rwnd == 0) && 862 (stcb->asoc.total_flight < net->mtu)) { 863 SCTP_STAT_INCR(sctps_timowindowprobe); 864 win_probe = 1; 865 } else { 866 win_probe = 0; 867 } 868 alt = sctp_find_alternate_net(stcb, net, 0); 869 sctp_mark_all_for_resend(stcb, net, alt, win_probe, &num_mk); 870 /* FR Loss recovery just ended with the T3. */ 871 stcb->asoc.fast_retran_loss_recovery = 0; 872 873 /* CMT FR loss recovery ended with the T3 */ 874 net->fast_retran_loss_recovery = 0; 875 876 /* 877 * setup the sat loss recovery that prevents satellite cwnd advance. 878 */ 879 stcb->asoc.sat_t3_loss_recovery = 1; 880 stcb->asoc.sat_t3_recovery_tsn = stcb->asoc.sending_seq; 881 882 /* Backoff the timer and cwnd */ 883 sctp_backoff_on_timeout(stcb, net, win_probe, num_mk); 884 if (win_probe == 0) { 885 /* We don't do normal threshold management on window probes */ 886 if (sctp_threshold_management(inp, stcb, net, 887 stcb->asoc.max_send_times)) { 888 /* Association was destroyed */ 889 return (1); 890 } else { 891 if (net != stcb->asoc.primary_destination) { 892 /* send a immediate HB if our RTO is stale */ 893 struct timeval now; 894 unsigned int ms_goneby; 895 896 SCTP_GETTIME_TIMEVAL(&now); 897 if (net->last_sent_time.tv_sec) { 898 ms_goneby = (now.tv_sec - net->last_sent_time.tv_sec) * 1000; 899 } else { 900 ms_goneby = 0; 901 } 902 if ((ms_goneby > net->RTO) || (net->RTO == 0)) { 903 /* 904 * no recent feed back in an RTO or 905 * more, request a RTT update 906 */ 907 sctp_send_hb(stcb, 1, net); 908 } 909 } 910 } 911 } else { 912 /* 913 * For a window probe we don't penalize the net's but only 914 * the association. This may fail it if SACKs are not coming 915 * back. If sack's are coming with rwnd locked at 0, we will 916 * continue to hold things waiting for rwnd to raise 917 */ 918 if (sctp_threshold_management(inp, stcb, NULL, 919 stcb->asoc.max_send_times)) { 920 /* Association was destroyed */ 921 return (1); 922 } 923 } 924 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 925 /* Move all pending over too */ 926 sctp_move_all_chunks_to_alt(stcb, net, alt); 927 /* Was it our primary? */ 928 if ((stcb->asoc.primary_destination == net) && (alt != net)) { 929 /* 930 * Yes, note it as such and find an alternate note: 931 * this means HB code must use this to resent the 932 * primary if it goes active AND if someone does a 933 * change-primary then this flag must be cleared 934 * from any net structures. 935 */ 936 if (sctp_set_primary_addr(stcb, 937 (struct sockaddr *)NULL, 938 alt) == 0) { 939 net->dest_state |= SCTP_ADDR_WAS_PRIMARY; 940 if (net->ro._s_addr) { 941 sctp_free_ifa(net->ro._s_addr); 942 net->ro._s_addr = NULL; 943 } 944 net->src_addr_selected = 0; 945 } 946 } 947 } 948 /* 949 * Special case for cookie-echo'ed case, we don't do output but must 950 * await the COOKIE-ACK before retransmission 951 */ 952 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) { 953 /* 954 * Here we just reset the timer and start again since we 955 * have not established the asoc 956 */ 957 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 958 return (0); 959 } 960 if (stcb->asoc.peer_supports_prsctp) { 961 struct sctp_tmit_chunk *lchk; 962 963 lchk = sctp_try_advance_peer_ack_point(stcb, &stcb->asoc); 964 /* C3. See if we need to send a Fwd-TSN */ 965 if (compare_with_wrap(stcb->asoc.advanced_peer_ack_point, 966 stcb->asoc.last_acked_seq, MAX_TSN)) { 967 /* 968 * ISSUE with ECN, see FWD-TSN processing for notes 969 * on issues that will occur when the ECN NONCE 970 * stuff is put into SCTP for cross checking. 971 */ 972 send_forward_tsn(stcb, &stcb->asoc); 973 if (lchk) { 974 /* Assure a timer is up */ 975 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, lchk->whoTo); 976 } 977 } 978 } 979 #ifdef SCTP_CWND_MONITOR 980 sctp_log_cwnd(stcb, net, net->cwnd, SCTP_CWND_LOG_FROM_RTX); 981 #endif 982 return (0); 983 } 984 985 int 986 sctp_t1init_timer(struct sctp_inpcb *inp, 987 struct sctp_tcb *stcb, 988 struct sctp_nets *net) 989 { 990 /* bump the thresholds */ 991 if (stcb->asoc.delayed_connection) { 992 /* 993 * special hook for delayed connection. The library did NOT 994 * complete the rest of its sends. 995 */ 996 stcb->asoc.delayed_connection = 0; 997 sctp_send_initiate(inp, stcb); 998 return (0); 999 } 1000 if (SCTP_GET_STATE((&stcb->asoc)) != SCTP_STATE_COOKIE_WAIT) { 1001 return (0); 1002 } 1003 if (sctp_threshold_management(inp, stcb, net, 1004 stcb->asoc.max_init_times)) { 1005 /* Association was destroyed */ 1006 return (1); 1007 } 1008 stcb->asoc.dropped_special_cnt = 0; 1009 sctp_backoff_on_timeout(stcb, stcb->asoc.primary_destination, 1, 0); 1010 if (stcb->asoc.initial_init_rto_max < net->RTO) { 1011 net->RTO = stcb->asoc.initial_init_rto_max; 1012 } 1013 if (stcb->asoc.numnets > 1) { 1014 /* If we have more than one addr use it */ 1015 struct sctp_nets *alt; 1016 1017 alt = sctp_find_alternate_net(stcb, stcb->asoc.primary_destination, 0); 1018 if ((alt != NULL) && (alt != stcb->asoc.primary_destination)) { 1019 sctp_move_all_chunks_to_alt(stcb, stcb->asoc.primary_destination, alt); 1020 stcb->asoc.primary_destination = alt; 1021 } 1022 } 1023 /* Send out a new init */ 1024 sctp_send_initiate(inp, stcb); 1025 return (0); 1026 } 1027 1028 /* 1029 * For cookie and asconf we actually need to find and mark for resend, then 1030 * increment the resend counter (after all the threshold management stuff of 1031 * course). 1032 */ 1033 int 1034 sctp_cookie_timer(struct sctp_inpcb *inp, 1035 struct sctp_tcb *stcb, 1036 struct sctp_nets *net) 1037 { 1038 struct sctp_nets *alt; 1039 struct sctp_tmit_chunk *cookie; 1040 1041 /* first before all else we must find the cookie */ 1042 TAILQ_FOREACH(cookie, &stcb->asoc.control_send_queue, sctp_next) { 1043 if (cookie->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 1044 break; 1045 } 1046 } 1047 if (cookie == NULL) { 1048 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) { 1049 /* FOOBAR! */ 1050 struct mbuf *oper; 1051 1052 oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 1053 0, M_DONTWAIT, 1, MT_DATA); 1054 if (oper) { 1055 struct sctp_paramhdr *ph; 1056 uint32_t *ippp; 1057 1058 SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 1059 sizeof(uint32_t); 1060 ph = mtod(oper, struct sctp_paramhdr *); 1061 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1062 ph->param_length = htons(SCTP_BUF_LEN(oper)); 1063 ippp = (uint32_t *) (ph + 1); 1064 *ippp = htonl(SCTP_FROM_SCTP_TIMER + SCTP_LOC_2); 1065 } 1066 inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_3; 1067 sctp_abort_an_association(inp, stcb, SCTP_INTERNAL_ERROR, 1068 oper); 1069 } else { 1070 #ifdef INVARIANTS 1071 panic("Cookie timer expires in wrong state?"); 1072 #else 1073 printf("Strange in state %d not cookie-echoed yet c-e timer expires?\n", SCTP_GET_STATE(&stcb->asoc)); 1074 return (0); 1075 #endif 1076 } 1077 return (0); 1078 } 1079 /* Ok we found the cookie, threshold management next */ 1080 if (sctp_threshold_management(inp, stcb, cookie->whoTo, 1081 stcb->asoc.max_init_times)) { 1082 /* Assoc is over */ 1083 return (1); 1084 } 1085 /* 1086 * cleared theshold management now lets backoff the address & select 1087 * an alternate 1088 */ 1089 stcb->asoc.dropped_special_cnt = 0; 1090 sctp_backoff_on_timeout(stcb, cookie->whoTo, 1, 0); 1091 alt = sctp_find_alternate_net(stcb, cookie->whoTo, 0); 1092 if (alt != cookie->whoTo) { 1093 sctp_free_remote_addr(cookie->whoTo); 1094 cookie->whoTo = alt; 1095 atomic_add_int(&alt->ref_count, 1); 1096 } 1097 /* Now mark the retran info */ 1098 if (cookie->sent != SCTP_DATAGRAM_RESEND) { 1099 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1100 } 1101 cookie->sent = SCTP_DATAGRAM_RESEND; 1102 /* 1103 * Now call the output routine to kick out the cookie again, Note we 1104 * don't mark any chunks for retran so that FR will need to kick in 1105 * to move these (or a send timer). 1106 */ 1107 return (0); 1108 } 1109 1110 int 1111 sctp_strreset_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1112 struct sctp_nets *net) 1113 { 1114 struct sctp_nets *alt; 1115 struct sctp_tmit_chunk *strrst = NULL, *chk = NULL; 1116 1117 if (stcb->asoc.stream_reset_outstanding == 0) { 1118 return (0); 1119 } 1120 /* find the existing STRRESET, we use the seq number we sent out on */ 1121 sctp_find_stream_reset(stcb, stcb->asoc.str_reset_seq_out, &strrst); 1122 if (strrst == NULL) { 1123 return (0); 1124 } 1125 /* do threshold management */ 1126 if (sctp_threshold_management(inp, stcb, strrst->whoTo, 1127 stcb->asoc.max_send_times)) { 1128 /* Assoc is over */ 1129 return (1); 1130 } 1131 /* 1132 * cleared theshold management now lets backoff the address & select 1133 * an alternate 1134 */ 1135 sctp_backoff_on_timeout(stcb, strrst->whoTo, 1, 0); 1136 alt = sctp_find_alternate_net(stcb, strrst->whoTo, 0); 1137 sctp_free_remote_addr(strrst->whoTo); 1138 strrst->whoTo = alt; 1139 atomic_add_int(&alt->ref_count, 1); 1140 1141 /* See if a ECN Echo is also stranded */ 1142 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 1143 if ((chk->whoTo == net) && 1144 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 1145 sctp_free_remote_addr(chk->whoTo); 1146 if (chk->sent != SCTP_DATAGRAM_RESEND) { 1147 chk->sent = SCTP_DATAGRAM_RESEND; 1148 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1149 } 1150 chk->whoTo = alt; 1151 atomic_add_int(&alt->ref_count, 1); 1152 } 1153 } 1154 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 1155 /* 1156 * If the address went un-reachable, we need to move to 1157 * alternates for ALL chk's in queue 1158 */ 1159 sctp_move_all_chunks_to_alt(stcb, net, alt); 1160 } 1161 /* mark the retran info */ 1162 if (strrst->sent != SCTP_DATAGRAM_RESEND) 1163 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1164 strrst->sent = SCTP_DATAGRAM_RESEND; 1165 1166 /* restart the timer */ 1167 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, inp, stcb, strrst->whoTo); 1168 return (0); 1169 } 1170 1171 int 1172 sctp_asconf_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1173 struct sctp_nets *net) 1174 { 1175 struct sctp_nets *alt; 1176 struct sctp_tmit_chunk *asconf, *chk; 1177 1178 /* is this the first send, or a retransmission? */ 1179 if (stcb->asoc.asconf_sent == 0) { 1180 /* compose a new ASCONF chunk and send it */ 1181 sctp_send_asconf(stcb, net); 1182 } else { 1183 /* Retransmission of the existing ASCONF needed... */ 1184 1185 /* find the existing ASCONF */ 1186 TAILQ_FOREACH(asconf, &stcb->asoc.control_send_queue, 1187 sctp_next) { 1188 if (asconf->rec.chunk_id.id == SCTP_ASCONF) { 1189 break; 1190 } 1191 } 1192 if (asconf == NULL) { 1193 return (0); 1194 } 1195 /* do threshold management */ 1196 if (sctp_threshold_management(inp, stcb, asconf->whoTo, 1197 stcb->asoc.max_send_times)) { 1198 /* Assoc is over */ 1199 return (1); 1200 } 1201 /* 1202 * PETER? FIX? How will the following code ever run? If the 1203 * max_send_times is hit, threshold managment will blow away 1204 * the association? 1205 */ 1206 if (asconf->snd_count > stcb->asoc.max_send_times) { 1207 /* 1208 * Something is rotten, peer is not responding to 1209 * ASCONFs but maybe is to data etc. e.g. it is not 1210 * properly handling the chunk type upper bits Mark 1211 * this peer as ASCONF incapable and cleanup 1212 */ 1213 #ifdef SCTP_DEBUG 1214 if (sctp_debug_on & SCTP_DEBUG_TIMER1) { 1215 printf("asconf_timer: Peer has not responded to our repeated ASCONFs\n"); 1216 } 1217 #endif /* SCTP_DEBUG */ 1218 sctp_asconf_cleanup(stcb, net); 1219 return (0); 1220 } 1221 /* 1222 * cleared theshold management now lets backoff the address 1223 * & select an alternate 1224 */ 1225 sctp_backoff_on_timeout(stcb, asconf->whoTo, 1, 0); 1226 alt = sctp_find_alternate_net(stcb, asconf->whoTo, 0); 1227 sctp_free_remote_addr(asconf->whoTo); 1228 asconf->whoTo = alt; 1229 atomic_add_int(&alt->ref_count, 1); 1230 1231 /* See if a ECN Echo is also stranded */ 1232 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 1233 if ((chk->whoTo == net) && 1234 (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) { 1235 sctp_free_remote_addr(chk->whoTo); 1236 chk->whoTo = alt; 1237 if (chk->sent != SCTP_DATAGRAM_RESEND) { 1238 chk->sent = SCTP_DATAGRAM_RESEND; 1239 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1240 } 1241 atomic_add_int(&alt->ref_count, 1); 1242 } 1243 } 1244 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) { 1245 /* 1246 * If the address went un-reachable, we need to move 1247 * to alternates for ALL chk's in queue 1248 */ 1249 sctp_move_all_chunks_to_alt(stcb, net, alt); 1250 } 1251 /* mark the retran info */ 1252 if (asconf->sent != SCTP_DATAGRAM_RESEND) 1253 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1254 asconf->sent = SCTP_DATAGRAM_RESEND; 1255 } 1256 return (0); 1257 } 1258 1259 /* 1260 * For the shutdown and shutdown-ack, we do not keep one around on the 1261 * control queue. This means we must generate a new one and call the general 1262 * chunk output routine, AFTER having done threshold management. 1263 */ 1264 int 1265 sctp_shutdown_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1266 struct sctp_nets *net) 1267 { 1268 struct sctp_nets *alt; 1269 1270 /* first threshold managment */ 1271 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) { 1272 /* Assoc is over */ 1273 return (1); 1274 } 1275 /* second select an alternative */ 1276 alt = sctp_find_alternate_net(stcb, net, 0); 1277 1278 /* third generate a shutdown into the queue for out net */ 1279 if (alt) { 1280 sctp_send_shutdown(stcb, alt); 1281 } else { 1282 /* 1283 * if alt is NULL, there is no dest to send to?? 1284 */ 1285 return (0); 1286 } 1287 /* fourth restart timer */ 1288 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, inp, stcb, alt); 1289 return (0); 1290 } 1291 1292 int 1293 sctp_shutdownack_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1294 struct sctp_nets *net) 1295 { 1296 struct sctp_nets *alt; 1297 1298 /* first threshold managment */ 1299 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) { 1300 /* Assoc is over */ 1301 return (1); 1302 } 1303 /* second select an alternative */ 1304 alt = sctp_find_alternate_net(stcb, net, 0); 1305 1306 /* third generate a shutdown into the queue for out net */ 1307 sctp_send_shutdown_ack(stcb, alt); 1308 1309 /* fourth restart timer */ 1310 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, inp, stcb, alt); 1311 return (0); 1312 } 1313 1314 static void 1315 sctp_audit_stream_queues_for_size(struct sctp_inpcb *inp, 1316 struct sctp_tcb *stcb) 1317 { 1318 struct sctp_stream_out *outs; 1319 struct sctp_stream_queue_pending *sp; 1320 unsigned int chks_in_queue = 0; 1321 int being_filled = 0; 1322 1323 /* 1324 * This function is ONLY called when the send/sent queues are empty. 1325 */ 1326 if ((stcb == NULL) || (inp == NULL)) 1327 return; 1328 1329 if (stcb->asoc.sent_queue_retran_cnt) { 1330 printf("Hmm, sent_queue_retran_cnt is non-zero %d\n", 1331 stcb->asoc.sent_queue_retran_cnt); 1332 stcb->asoc.sent_queue_retran_cnt = 0; 1333 } 1334 SCTP_TCB_SEND_LOCK(stcb); 1335 if (TAILQ_EMPTY(&stcb->asoc.out_wheel)) { 1336 int i, cnt = 0; 1337 1338 /* Check to see if a spoke fell off the wheel */ 1339 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 1340 if (!TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) { 1341 sctp_insert_on_wheel(stcb, &stcb->asoc, &stcb->asoc.strmout[i], 1); 1342 cnt++; 1343 } 1344 } 1345 if (cnt) { 1346 /* yep, we lost a spoke or two */ 1347 printf("Found an additional %d streams NOT on outwheel, corrected\n", cnt); 1348 } else { 1349 /* no spokes lost, */ 1350 stcb->asoc.total_output_queue_size = 0; 1351 } 1352 SCTP_TCB_SEND_UNLOCK(stcb); 1353 return; 1354 } 1355 SCTP_TCB_SEND_UNLOCK(stcb); 1356 /* Check to see if some data queued, if so report it */ 1357 TAILQ_FOREACH(outs, &stcb->asoc.out_wheel, next_spoke) { 1358 if (!TAILQ_EMPTY(&outs->outqueue)) { 1359 TAILQ_FOREACH(sp, &outs->outqueue, next) { 1360 if (sp->msg_is_complete) 1361 being_filled++; 1362 chks_in_queue++; 1363 } 1364 } 1365 } 1366 if (chks_in_queue != stcb->asoc.stream_queue_cnt) { 1367 printf("Hmm, stream queue cnt at %d I counted %d in stream out wheel\n", 1368 stcb->asoc.stream_queue_cnt, chks_in_queue); 1369 } 1370 if (chks_in_queue) { 1371 /* call the output queue function */ 1372 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3); 1373 if ((TAILQ_EMPTY(&stcb->asoc.send_queue)) && 1374 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) { 1375 /* 1376 * Probably should go in and make it go back through 1377 * and add fragments allowed 1378 */ 1379 if (being_filled == 0) { 1380 printf("Still nothing moved %d chunks are stuck\n", 1381 chks_in_queue); 1382 } 1383 } 1384 } else { 1385 printf("Found no chunks on any queue tot:%lu\n", 1386 (u_long)stcb->asoc.total_output_queue_size); 1387 stcb->asoc.total_output_queue_size = 0; 1388 } 1389 } 1390 1391 int 1392 sctp_heartbeat_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1393 struct sctp_nets *net, int cnt_of_unconf) 1394 { 1395 if (net) { 1396 if (net->hb_responded == 0) { 1397 if (net->ro._s_addr) { 1398 /* 1399 * Invalidate the src address if we did not 1400 * get a response last time. 1401 */ 1402 sctp_free_ifa(net->ro._s_addr); 1403 net->ro._s_addr = NULL; 1404 net->src_addr_selected = 0; 1405 } 1406 sctp_backoff_on_timeout(stcb, net, 1, 0); 1407 } 1408 /* Zero PBA, if it needs it */ 1409 if (net->partial_bytes_acked) { 1410 net->partial_bytes_acked = 0; 1411 } 1412 } 1413 if ((stcb->asoc.total_output_queue_size > 0) && 1414 (TAILQ_EMPTY(&stcb->asoc.send_queue)) && 1415 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) { 1416 sctp_audit_stream_queues_for_size(inp, stcb); 1417 } 1418 /* Send a new HB, this will do threshold managment, pick a new dest */ 1419 if (cnt_of_unconf == 0) { 1420 if (sctp_send_hb(stcb, 0, NULL) < 0) { 1421 return (1); 1422 } 1423 } else { 1424 /* 1425 * this will send out extra hb's up to maxburst if there are 1426 * any unconfirmed addresses. 1427 */ 1428 int cnt_sent = 0; 1429 1430 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 1431 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) && 1432 (net->dest_state & SCTP_ADDR_REACHABLE)) { 1433 cnt_sent++; 1434 if (net->hb_responded == 0) { 1435 /* Did we respond last time? */ 1436 if (net->ro._s_addr) { 1437 sctp_free_ifa(net->ro._s_addr); 1438 net->ro._s_addr = NULL; 1439 net->src_addr_selected = 0; 1440 } 1441 } 1442 if (sctp_send_hb(stcb, 1, net) == 0) { 1443 break; 1444 } 1445 if (cnt_sent >= sctp_hb_maxburst) 1446 break; 1447 } 1448 } 1449 } 1450 return (0); 1451 } 1452 1453 int 1454 sctp_is_hb_timer_running(struct sctp_tcb *stcb) 1455 { 1456 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.hb_timer.timer)) { 1457 /* its running */ 1458 return (1); 1459 } else { 1460 /* nope */ 1461 return (0); 1462 } 1463 } 1464 1465 int 1466 sctp_is_sack_timer_running(struct sctp_tcb *stcb) 1467 { 1468 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 1469 /* its running */ 1470 return (1); 1471 } else { 1472 /* nope */ 1473 return (0); 1474 } 1475 } 1476 1477 #define SCTP_NUMBER_OF_MTU_SIZES 18 1478 static uint32_t mtu_sizes[] = { 1479 68, 1480 296, 1481 508, 1482 512, 1483 544, 1484 576, 1485 1006, 1486 1492, 1487 1500, 1488 1536, 1489 2002, 1490 2048, 1491 4352, 1492 4464, 1493 8166, 1494 17914, 1495 32000, 1496 65535 1497 }; 1498 1499 1500 static uint32_t 1501 sctp_getnext_mtu(struct sctp_inpcb *inp, uint32_t cur_mtu) 1502 { 1503 /* select another MTU that is just bigger than this one */ 1504 int i; 1505 1506 for (i = 0; i < SCTP_NUMBER_OF_MTU_SIZES; i++) { 1507 if (cur_mtu < mtu_sizes[i]) { 1508 /* no max_mtu is bigger than this one */ 1509 return (mtu_sizes[i]); 1510 } 1511 } 1512 /* here return the highest allowable */ 1513 return (cur_mtu); 1514 } 1515 1516 1517 void 1518 sctp_pathmtu_timer(struct sctp_inpcb *inp, 1519 struct sctp_tcb *stcb, 1520 struct sctp_nets *net) 1521 { 1522 uint32_t next_mtu; 1523 1524 /* restart the timer in any case */ 1525 next_mtu = sctp_getnext_mtu(inp, net->mtu); 1526 if (next_mtu <= net->mtu) { 1527 /* nothing to do */ 1528 return; 1529 } 1530 if (net->ro.ro_rt != NULL) { 1531 /* 1532 * only if we have a route and interface do we set anything. 1533 * Note we always restart the timer though just in case it 1534 * is updated (i.e. the ifp) or route/ifp is populated. 1535 */ 1536 if (net->ro.ro_rt->rt_ifp != NULL) { 1537 if (net->ro.ro_rt->rt_ifp->if_mtu > next_mtu) { 1538 /* ok it will fit out the door */ 1539 net->mtu = next_mtu; 1540 } 1541 } 1542 } 1543 /* restart the timer */ 1544 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net); 1545 } 1546 1547 void 1548 sctp_autoclose_timer(struct sctp_inpcb *inp, 1549 struct sctp_tcb *stcb, 1550 struct sctp_nets *net) 1551 { 1552 struct timeval tn, *tim_touse; 1553 struct sctp_association *asoc; 1554 int ticks_gone_by; 1555 1556 SCTP_GETTIME_TIMEVAL(&tn); 1557 if (stcb->asoc.sctp_autoclose_ticks && 1558 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE)) { 1559 /* Auto close is on */ 1560 asoc = &stcb->asoc; 1561 /* pick the time to use */ 1562 if (asoc->time_last_rcvd.tv_sec > 1563 asoc->time_last_sent.tv_sec) { 1564 tim_touse = &asoc->time_last_rcvd; 1565 } else { 1566 tim_touse = &asoc->time_last_sent; 1567 } 1568 /* Now has long enough transpired to autoclose? */ 1569 ticks_gone_by = SEC_TO_TICKS(tn.tv_sec - tim_touse->tv_sec); 1570 if ((ticks_gone_by > 0) && 1571 (ticks_gone_by >= (int)asoc->sctp_autoclose_ticks)) { 1572 /* 1573 * autoclose time has hit, call the output routine, 1574 * which should do nothing just to be SURE we don't 1575 * have hanging data. We can then safely check the 1576 * queues and know that we are clear to send 1577 * shutdown 1578 */ 1579 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR); 1580 /* Are we clean? */ 1581 if (TAILQ_EMPTY(&asoc->send_queue) && 1582 TAILQ_EMPTY(&asoc->sent_queue)) { 1583 /* 1584 * there is nothing queued to send, so I'm 1585 * done... 1586 */ 1587 if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) { 1588 /* only send SHUTDOWN 1st time thru */ 1589 sctp_send_shutdown(stcb, stcb->asoc.primary_destination); 1590 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 1591 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 1592 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 1593 } 1594 asoc->state = SCTP_STATE_SHUTDOWN_SENT; 1595 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 1596 stcb->sctp_ep, stcb, 1597 asoc->primary_destination); 1598 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 1599 stcb->sctp_ep, stcb, 1600 asoc->primary_destination); 1601 } 1602 } 1603 } else { 1604 /* 1605 * No auto close at this time, reset t-o to check 1606 * later 1607 */ 1608 int tmp; 1609 1610 /* fool the timer startup to use the time left */ 1611 tmp = asoc->sctp_autoclose_ticks; 1612 asoc->sctp_autoclose_ticks -= ticks_gone_by; 1613 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb, 1614 net); 1615 /* restore the real tick value */ 1616 asoc->sctp_autoclose_ticks = tmp; 1617 } 1618 } 1619 } 1620 1621 void 1622 sctp_iterator_timer(struct sctp_iterator *it) 1623 { 1624 int iteration_count = 0; 1625 int inp_skip = 0; 1626 1627 /* 1628 * only one iterator can run at a time. This is the only way we can 1629 * cleanly pull ep's from underneath all the running interators when 1630 * a ep is freed. 1631 */ 1632 SCTP_ITERATOR_LOCK(); 1633 if (it->inp == NULL) { 1634 /* iterator is complete */ 1635 done_with_iterator: 1636 SCTP_ITERATOR_UNLOCK(); 1637 SCTP_INP_INFO_WLOCK(); 1638 TAILQ_REMOVE(&sctppcbinfo.iteratorhead, it, sctp_nxt_itr); 1639 /* stopping the callout is not needed, in theory */ 1640 SCTP_INP_INFO_WUNLOCK(); 1641 SCTP_OS_TIMER_STOP(&it->tmr.timer); 1642 if (it->function_atend != NULL) { 1643 (*it->function_atend) (it->pointer, it->val); 1644 } 1645 SCTP_FREE(it); 1646 return; 1647 } 1648 select_a_new_ep: 1649 SCTP_INP_WLOCK(it->inp); 1650 while (((it->pcb_flags) && 1651 ((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) || 1652 ((it->pcb_features) && 1653 ((it->inp->sctp_features & it->pcb_features) != it->pcb_features))) { 1654 /* endpoint flags or features don't match, so keep looking */ 1655 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 1656 SCTP_INP_WUNLOCK(it->inp); 1657 goto done_with_iterator; 1658 } 1659 SCTP_INP_WUNLOCK(it->inp); 1660 it->inp = LIST_NEXT(it->inp, sctp_list); 1661 if (it->inp == NULL) { 1662 goto done_with_iterator; 1663 } 1664 SCTP_INP_WLOCK(it->inp); 1665 } 1666 if ((it->inp->inp_starting_point_for_iterator != NULL) && 1667 (it->inp->inp_starting_point_for_iterator != it)) { 1668 printf("Iterator collision, waiting for one at %p\n", 1669 it->inp); 1670 SCTP_INP_WUNLOCK(it->inp); 1671 goto start_timer_return; 1672 } 1673 /* mark the current iterator on the endpoint */ 1674 it->inp->inp_starting_point_for_iterator = it; 1675 SCTP_INP_WUNLOCK(it->inp); 1676 SCTP_INP_RLOCK(it->inp); 1677 /* now go through each assoc which is in the desired state */ 1678 if (it->done_current_ep == 0) { 1679 if (it->function_inp != NULL) 1680 inp_skip = (*it->function_inp) (it->inp, it->pointer, it->val); 1681 it->done_current_ep = 1; 1682 } 1683 if (it->stcb == NULL) { 1684 /* run the per instance function */ 1685 it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list); 1686 } 1687 SCTP_INP_RUNLOCK(it->inp); 1688 if ((inp_skip) || it->stcb == NULL) { 1689 if (it->function_inp_end != NULL) { 1690 inp_skip = (*it->function_inp_end) (it->inp, 1691 it->pointer, 1692 it->val); 1693 } 1694 goto no_stcb; 1695 } 1696 if ((it->stcb) && 1697 (it->stcb->asoc.stcb_starting_point_for_iterator == it)) { 1698 it->stcb->asoc.stcb_starting_point_for_iterator = NULL; 1699 } 1700 while (it->stcb) { 1701 SCTP_TCB_LOCK(it->stcb); 1702 if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) { 1703 /* not in the right state... keep looking */ 1704 SCTP_TCB_UNLOCK(it->stcb); 1705 goto next_assoc; 1706 } 1707 /* mark the current iterator on the assoc */ 1708 it->stcb->asoc.stcb_starting_point_for_iterator = it; 1709 /* see if we have limited out the iterator loop */ 1710 iteration_count++; 1711 if (iteration_count > SCTP_ITERATOR_MAX_AT_ONCE) { 1712 start_timer_return: 1713 /* set a timer to continue this later */ 1714 SCTP_TCB_UNLOCK(it->stcb); 1715 sctp_timer_start(SCTP_TIMER_TYPE_ITERATOR, 1716 (struct sctp_inpcb *)it, NULL, NULL); 1717 SCTP_ITERATOR_UNLOCK(); 1718 return; 1719 } 1720 /* run function on this one */ 1721 (*it->function_assoc) (it->inp, it->stcb, it->pointer, it->val); 1722 1723 /* 1724 * we lie here, it really needs to have its own type but 1725 * first I must verify that this won't effect things :-0 1726 */ 1727 if (it->no_chunk_output == 0) 1728 sctp_chunk_output(it->inp, it->stcb, SCTP_OUTPUT_FROM_T3); 1729 1730 SCTP_TCB_UNLOCK(it->stcb); 1731 next_assoc: 1732 it->stcb = LIST_NEXT(it->stcb, sctp_tcblist); 1733 if (it->stcb == NULL) { 1734 if (it->function_inp_end != NULL) { 1735 inp_skip = (*it->function_inp_end) (it->inp, 1736 it->pointer, 1737 it->val); 1738 } 1739 } 1740 } 1741 no_stcb: 1742 /* done with all assocs on this endpoint, move on to next endpoint */ 1743 it->done_current_ep = 0; 1744 SCTP_INP_WLOCK(it->inp); 1745 it->inp->inp_starting_point_for_iterator = NULL; 1746 SCTP_INP_WUNLOCK(it->inp); 1747 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 1748 it->inp = NULL; 1749 } else { 1750 SCTP_INP_INFO_RLOCK(); 1751 it->inp = LIST_NEXT(it->inp, sctp_list); 1752 SCTP_INP_INFO_RUNLOCK(); 1753 } 1754 if (it->inp == NULL) { 1755 goto done_with_iterator; 1756 } 1757 goto select_a_new_ep; 1758 } 1759