ext/sctp/usrsctp/usrsctplib/netinet/sctp_timer.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
   5  * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
   6  * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * a) Redistributions of source code must retain the above copyright notice,
  12  *    this list of conditions and the following disclaimer.
  13  *
  14  * b) Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the distribution.
  17  *
  18  * c) Neither the name of Cisco Systems, Inc. nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  24  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  32  * THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #if defined(__FreeBSD__) && !defined(__Userspace__)
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD: head/sys/netinet/sctp_timer.c 362054 2020-06-11 13:34:09Z tuexen $");
  38 #endif
  39
  40 #define _IP_VHL
  41 #include <netinet/sctp_os.h>
  42 #include <netinet/sctp_pcb.h>
  43 #ifdef INET6
  44 #if defined(__FreeBSD__) && defined(__Userspace__)
  45 #include <netinet6/sctp6_var.h>
  46 #endif
  47 #endif
  48 #include <netinet/sctp_var.h>
  49 #include <netinet/sctp_sysctl.h>
  50 #include <netinet/sctp_timer.h>
  51 #include <netinet/sctputil.h>
  52 #include <netinet/sctp_output.h>
  53 #include <netinet/sctp_header.h>
  54 #include <netinet/sctp_indata.h>
  55 #include <netinet/sctp_asconf.h>
  56 #include <netinet/sctp_input.h>
  57 #include <netinet/sctp.h>
  58 #include <netinet/sctp_uio.h>
  59 #if defined(INET) || defined(INET6)
  60 #if !(defined(_WIN32) && defined(__Userspace__))
  61 #include <netinet/udp.h>
  62 #endif
  63 #endif
  64
  65 void
  66 sctp_audit_retranmission_queue(struct sctp_association *asoc)
  67 {
  68         struct sctp_tmit_chunk *chk;
  69
  70         SCTPDBG(SCTP_DEBUG_TIMER4, "Audit invoked on send queue cnt:%d onqueue:%d\n",
  71                         asoc->sent_queue_retran_cnt,
  72                         asoc->sent_queue_cnt);
  73         asoc->sent_queue_retran_cnt = 0;
  74         asoc->sent_queue_cnt = 0;
  75         TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {
  76                 if (chk->sent == SCTP_DATAGRAM_RESEND) {
  77                         sctp_ucount_incr(asoc->sent_queue_retran_cnt);
  78                 }
  79                 asoc->sent_queue_cnt++;
  80         }
  81         TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) {
  82                 if (chk->sent == SCTP_DATAGRAM_RESEND) {
  83                         sctp_ucount_incr(asoc->sent_queue_retran_cnt);
  84                 }
  85         }
  86         TAILQ_FOREACH(chk, &asoc->asconf_send_queue, sctp_next) {
  87                 if (chk->sent == SCTP_DATAGRAM_RESEND) {
  88                         sctp_ucount_incr(asoc->sent_queue_retran_cnt);
  89                 }
  90         }
  91         SCTPDBG(SCTP_DEBUG_TIMER4, "Audit completes retran:%d onqueue:%d\n",
  92                 asoc->sent_queue_retran_cnt,
  93                 asoc->sent_queue_cnt);
  94 }
  95
  96 static int
  97 sctp_threshold_management(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
  98     struct sctp_nets *net, uint16_t threshold)
  99 {
 100         if (net) {
 101                 net->error_count++;
 102                 SCTPDBG(SCTP_DEBUG_TIMER4, "Error count for %p now %d thresh:%d\n",
 103                         (void *)net, net->error_count,
 104                         net->failure_threshold);
 105                 if (net->error_count > net->failure_threshold) {
 106                         /* We had a threshold failure */
 107                         if (net->dest_state & SCTP_ADDR_REACHABLE) {
 108                                 net->dest_state &= ~SCTP_ADDR_REACHABLE;
 109                                 net->dest_state &= ~SCTP_ADDR_REQ_PRIMARY;
 110                                 net->dest_state &= ~SCTP_ADDR_PF;
 111                                 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
 112                                     stcb, 0,
 113                                     (void *)net, SCTP_SO_NOT_LOCKED);
 114                         }
 115                 } else if ((net->pf_threshold < net->failure_threshold) &&
 116                            (net->error_count > net->pf_threshold)) {
 117                         if (!(net->dest_state & SCTP_ADDR_PF)) {
 118                                 net->dest_state |= SCTP_ADDR_PF;
 119                                 net->last_active = sctp_get_tick_count();
 120                                 sctp_send_hb(stcb, net, SCTP_SO_NOT_LOCKED);
 121                                 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
 122                                                 inp, stcb, net,
 123                                                 SCTP_FROM_SCTP_TIMER + SCTP_LOC_1);
 124                                 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
 125                         }
 126                 }
 127         }
 128         if (stcb == NULL)
 129                 return (0);
 130
 131         if (net) {
 132                 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) {
 133                         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) {
 134                                 sctp_misc_ints(SCTP_THRESHOLD_INCR,
 135                                                stcb->asoc.overall_error_count,
 136                                                (stcb->asoc.overall_error_count+1),
 137                                                SCTP_FROM_SCTP_TIMER,
 138                                                __LINE__);
 139                         }
 140                         stcb->asoc.overall_error_count++;
 141                 }
 142         } else {
 143                 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) {
 144                         sctp_misc_ints(SCTP_THRESHOLD_INCR,
 145                                        stcb->asoc.overall_error_count,
 146                                        (stcb->asoc.overall_error_count+1),
 147                                        SCTP_FROM_SCTP_TIMER,
 148                                        __LINE__);
 149                 }
 150                 stcb->asoc.overall_error_count++;
 151         }
 152         SCTPDBG(SCTP_DEBUG_TIMER4, "Overall error count for %p now %d thresh:%u state:%x\n",
 153                 (void *)&stcb->asoc, stcb->asoc.overall_error_count,
 154                 (uint32_t)threshold,
 155                 ((net == NULL) ? (uint32_t) 0 : (uint32_t) net->dest_state));
 156         /*
 157          * We specifically do not do >= to give the assoc one more change
 158          * before we fail it.
 159          */
 160         if (stcb->asoc.overall_error_count > threshold) {
 161                 /* Abort notification sends a ULP notify */
 162                 struct mbuf *op_err;
 163
 164                 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code),
 165                                              "Association error counter exceeded");
 166                 inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_2;
 167                 sctp_abort_an_association(inp, stcb, op_err, SCTP_SO_NOT_LOCKED);
 168                 return (1);
 169         }
 170         return (0);
 171 }
 172
 173 /*
 174  * sctp_find_alternate_net() returns a non-NULL pointer as long
 175  * the argument net is non-NULL.
 176  */
 177 struct sctp_nets *
 178 sctp_find_alternate_net(struct sctp_tcb *stcb,
 179     struct sctp_nets *net,
 180     int mode)
 181 {
 182         /* Find and return an alternate network if possible */
 183         struct sctp_nets *alt, *mnet, *min_errors_net = NULL , *max_cwnd_net = NULL;
 184         int once;
 185         /* JRS 5/14/07 - Initialize min_errors to an impossible value. */
 186         int min_errors = -1;
 187         uint32_t max_cwnd = 0;
 188
 189         if (stcb->asoc.numnets == 1) {
 190                 /* No others but net */
 191                 return (TAILQ_FIRST(&stcb->asoc.nets));
 192         }
 193         /*
 194          * JRS 5/14/07 - If mode is set to 2, use the CMT PF find alternate net algorithm.
 195          * This algorithm chooses the active destination (not in PF state) with the largest
 196          * cwnd value. If all destinations are in PF state, unreachable, or unconfirmed, choose
 197          * the desination that is in PF state with the lowest error count. In case of a tie,
 198          * choose the destination that was most recently active.
 199          */
 200         if (mode == 2) {
 201                 TAILQ_FOREACH(mnet, &stcb->asoc.nets, sctp_next) {
 202                         /* JRS 5/14/07 - If the destination is unreachable or unconfirmed, skip it. */
 203                         if (((mnet->dest_state & SCTP_ADDR_REACHABLE) != SCTP_ADDR_REACHABLE) ||
 204                             (mnet->dest_state & SCTP_ADDR_UNCONFIRMED)) {
 205                                 continue;
 206                         }
 207                         /*
 208                          * JRS 5/14/07 -  If the destination is reachable but in PF state, compare
 209                          *  the error count of the destination to the minimum error count seen thus far.
 210                          *  Store the destination with the lower error count.  If the error counts are
 211                          *  equal, store the destination that was most recently active.
 212                          */
 213                         if (mnet->dest_state & SCTP_ADDR_PF) {
 214                                 /*
 215                                  * JRS 5/14/07 - If the destination under consideration is the current
 216                                  *  destination, work as if the error count is one higher.  The
 217                                  *  actual error count will not be incremented until later in the
 218                                  *  t3 handler.
 219                                  */
 220                                 if (mnet == net) {
 221                                         if (min_errors == -1) {
 222                                                 min_errors = mnet->error_count + 1;
 223                                                 min_errors_net = mnet;
 224                                         } else if (mnet->error_count + 1 < min_errors) {
 225                                                 min_errors = mnet->error_count + 1;
 226                                                 min_errors_net = mnet;
 227                                         } else if (mnet->error_count + 1 == min_errors
 228                                                                 && mnet->last_active > min_errors_net->last_active) {
 229                                                 min_errors_net = mnet;
 230                                                 min_errors = mnet->error_count + 1;
 231                                         }
 232                                         continue;
 233                                 } else {
 234                                         if (min_errors == -1) {
 235                                                 min_errors = mnet->error_count;
 236                                                 min_errors_net = mnet;
 237                                         } else if (mnet->error_count < min_errors) {
 238                                                 min_errors = mnet->error_count;
 239                                                 min_errors_net = mnet;
 240                                         } else if (mnet->error_count == min_errors
 241                                                                 && mnet->last_active > min_errors_net->last_active) {
 242                                                 min_errors_net = mnet;
 243                                                 min_errors = mnet->error_count;
 244                                         }
 245                                         continue;
 246                                 }
 247                         }
 248                         /*
 249                          * JRS 5/14/07 - If the destination is reachable and not in PF state, compare the
 250                          *  cwnd of the destination to the highest cwnd seen thus far.  Store the
 251                          *  destination with the higher cwnd value.  If the cwnd values are equal,
 252                          *  randomly choose one of the two destinations.
 253                          */
 254                         if (max_cwnd < mnet->cwnd) {
 255                                 max_cwnd_net = mnet;
 256                                 max_cwnd = mnet->cwnd;
 257                         } else if (max_cwnd == mnet->cwnd) {
 258                                 uint32_t rndval;
 259                                 uint8_t this_random;
 260
 261                                 if (stcb->asoc.hb_random_idx > 3) {
 262                                         rndval = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep);
 263                                         memcpy(stcb->asoc.hb_random_values, &rndval, sizeof(stcb->asoc.hb_random_values));
 264                                         this_random = stcb->asoc.hb_random_values[0];
 265                                         stcb->asoc.hb_random_idx++;
 266                                         stcb->asoc.hb_ect_randombit = 0;
 267                                 } else {
 268                                         this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx];
 269                                         stcb->asoc.hb_random_idx++;
 270                                         stcb->asoc.hb_ect_randombit = 0;
 271                                 }
 272                                 if (this_random % 2 == 1) {
 273                                         max_cwnd_net = mnet;
 274                                         max_cwnd = mnet->cwnd; /* Useless? */
 275                                 }
 276                         }
 277                 }
 278                 if (max_cwnd_net == NULL) {
 279                         if (min_errors_net == NULL) {
 280                                 return (net);
 281                         }
 282                         return (min_errors_net);
 283                 } else {
 284                         return (max_cwnd_net);
 285                 }
 286         } /* JRS 5/14/07 - If mode is set to 1, use the CMT policy for choosing an alternate net. */
 287         else if (mode == 1) {
 288                 TAILQ_FOREACH(mnet, &stcb->asoc.nets, sctp_next) {
 289                         if (((mnet->dest_state & SCTP_ADDR_REACHABLE) != SCTP_ADDR_REACHABLE) ||
 290                             (mnet->dest_state & SCTP_ADDR_UNCONFIRMED)) {
 291                                 /*
 292                                  * will skip ones that are not-reachable or
 293                                  * unconfirmed
 294                                  */
 295                                 continue;
 296                         }
 297                         if (max_cwnd < mnet->cwnd) {
 298                                 max_cwnd_net = mnet;
 299                                 max_cwnd = mnet->cwnd;
 300                         } else if (max_cwnd == mnet->cwnd) {
 301                                 uint32_t rndval;
 302                                 uint8_t this_random;
 303
 304                                 if (stcb->asoc.hb_random_idx > 3) {
 305                                         rndval = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep);
 306                                         memcpy(stcb->asoc.hb_random_values, &rndval,
 307                                             sizeof(stcb->asoc.hb_random_values));
 308                                         this_random = stcb->asoc.hb_random_values[0];
 309                                         stcb->asoc.hb_random_idx = 0;
 310                                         stcb->asoc.hb_ect_randombit = 0;
 311                                 } else {
 312                                         this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx];
 313                                         stcb->asoc.hb_random_idx++;
 314                                         stcb->asoc.hb_ect_randombit = 0;
 315                                 }
 316                                 if (this_random % 2) {
 317                                         max_cwnd_net = mnet;
 318                                         max_cwnd = mnet->cwnd;
 319                                 }
 320                         }
 321                 }
 322                 if (max_cwnd_net) {
 323                         return (max_cwnd_net);
 324                 }
 325         }
 326         mnet = net;
 327         once = 0;
 328
 329         if (mnet == NULL) {
 330                 mnet = TAILQ_FIRST(&stcb->asoc.nets);
 331                 if (mnet == NULL) {
 332                         return (NULL);
 333                 }
 334         }
 335         for (;;) {
 336                 alt = TAILQ_NEXT(mnet, sctp_next);
 337                 if (alt == NULL) {
 338                         once++;
 339                         if (once > 1) {
 340                                 break;
 341                         }
 342                         alt = TAILQ_FIRST(&stcb->asoc.nets);
 343                         if (alt == NULL) {
 344                                 return (NULL);
 345                         }
 346                 }
 347 #if defined(__FreeBSD__) && !defined(__Userspace__)
 348                 if (alt->ro.ro_nh == NULL) {
 349 #else
 350                 if (alt->ro.ro_rt == NULL) {
 351 #endif
 352                         if (alt->ro._s_addr) {
 353                                 sctp_free_ifa(alt->ro._s_addr);
 354                                 alt->ro._s_addr = NULL;
 355                         }
 356                         alt->src_addr_selected = 0;
 357                 }
 358                 if (((alt->dest_state & SCTP_ADDR_REACHABLE) == SCTP_ADDR_REACHABLE) &&
 359 #if defined(__FreeBSD__) && !defined(__Userspace__)
 360                     (alt->ro.ro_nh != NULL) &&
 361 #else
 362                     (alt->ro.ro_rt != NULL) &&
 363 #endif
 364                     (!(alt->dest_state & SCTP_ADDR_UNCONFIRMED))) {
 365                         /* Found a reachable address */
 366                         break;
 367                 }
 368                 mnet = alt;
 369         }
 370
 371         if (alt == NULL) {
 372                 /* Case where NO insv network exists (dormant state) */
 373                 /* we rotate destinations */
 374                 once = 0;
 375                 mnet = net;
 376                 for (;;) {
 377                         if (mnet == NULL) {
 378                                 return (TAILQ_FIRST(&stcb->asoc.nets));
 379                         }
 380                         alt = TAILQ_NEXT(mnet, sctp_next);
 381                         if (alt == NULL) {
 382                                 once++;
 383                                 if (once > 1) {
 384                                         break;
 385                                 }
 386                                 alt = TAILQ_FIRST(&stcb->asoc.nets);
 387                                 if (alt == NULL) {
 388                                         break;
 389                                 }
 390                         }
 391                         if ((!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) &&
 392                             (alt != net)) {
 393                                 /* Found an alternate address */
 394                                 break;
 395                         }
 396                         mnet = alt;
 397                 }
 398         }
 399         if (alt == NULL) {
 400                 return (net);
 401         }
 402         return (alt);
 403 }
 404
 405 static void
 406 sctp_backoff_on_timeout(struct sctp_tcb *stcb,
 407     struct sctp_nets *net,
 408     int win_probe,
 409     int num_marked, int num_abandoned)
 410 {
 411         if (net->RTO == 0) {
 412                 if (net->RTO_measured) {
 413                         net->RTO = stcb->asoc.minrto;
 414                 } else {
 415                         net->RTO = stcb->asoc.initial_rto;
 416                 }
 417         }
 418         net->RTO <<= 1;
 419         if (net->RTO > stcb->asoc.maxrto) {
 420                 net->RTO = stcb->asoc.maxrto;
 421         }
 422         if ((win_probe == 0) && (num_marked || num_abandoned)) {
 423                 /* We don't apply penalty to window probe scenarios */
 424                 /* JRS - Use the congestion control given in the CC module */
 425                 stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout(stcb, net);
 426         }
 427 }
 428
 429 #ifndef INVARIANTS
 430 static void
 431 sctp_recover_sent_list(struct sctp_tcb *stcb)
 432 {
 433         struct sctp_tmit_chunk *chk, *nchk;
 434         struct sctp_association *asoc;
 435
 436         asoc = &stcb->asoc;
 437         TAILQ_FOREACH_SAFE(chk, &asoc->sent_queue, sctp_next, nchk) {
 438                 if (SCTP_TSN_GE(asoc->last_acked_seq, chk->rec.data.tsn)) {
 439                         SCTP_PRINTF("Found chk:%p tsn:%x <= last_acked_seq:%x\n",
 440                                     (void *)chk, chk->rec.data.tsn, asoc->last_acked_seq);
 441                         if (chk->sent != SCTP_DATAGRAM_NR_ACKED) {
 442                                 if (asoc->strmout[chk->rec.data.sid].chunks_on_queues > 0) {
 443                                         asoc->strmout[chk->rec.data.sid].chunks_on_queues--;
 444                                 }
 445                         }
 446                         if ((asoc->strmout[chk->rec.data.sid].chunks_on_queues == 0) &&
 447                             (asoc->strmout[chk->rec.data.sid].state == SCTP_STREAM_RESET_PENDING) &&
 448                             TAILQ_EMPTY(&asoc->strmout[chk->rec.data.sid].outqueue)) {
 449                                 asoc->trigger_reset = 1;
 450                         }
 451                         TAILQ_REMOVE(&asoc->sent_queue, chk, sctp_next);
 452                         if (PR_SCTP_ENABLED(chk->flags)) {
 453                                 if (asoc->pr_sctp_cnt != 0)
 454                                         asoc->pr_sctp_cnt--;
 455                         }
 456                         if (chk->data) {
 457                                 /*sa_ignore NO_NULL_CHK*/
 458                                 sctp_free_bufspace(stcb, asoc, chk, 1);
 459                                 sctp_m_freem(chk->data);
 460                                 chk->data = NULL;
 461                                 if (asoc->prsctp_supported && PR_SCTP_BUF_ENABLED(chk->flags)) {
 462                                         asoc->sent_queue_cnt_removeable--;
 463                                 }
 464                         }
 465                         asoc->sent_queue_cnt--;
 466                         sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
 467                 }
 468         }
 469         SCTP_PRINTF("after recover order is as follows\n");
 470         TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {
 471                 SCTP_PRINTF("chk:%p TSN:%x\n", (void *)chk, chk->rec.data.tsn);
 472         }
 473 }
 474 #endif
 475
 476 static int
 477 sctp_mark_all_for_resend(struct sctp_tcb *stcb,
 478     struct sctp_nets *net,
 479     struct sctp_nets *alt,
 480     int window_probe,
 481     int *num_marked,
 482     int *num_abandoned)
 483 {
 484
 485         /*
 486          * Mark all chunks (well not all) that were sent to *net for
 487          * retransmission. Move them to alt for there destination as well...
 488          * We only mark chunks that have been outstanding long enough to
 489          * have received feed-back.
 490          */
 491         struct sctp_tmit_chunk *chk, *nchk;
 492         struct sctp_nets *lnets;
 493         struct timeval now, min_wait, tv;
 494         int cur_rto;
 495         int cnt_abandoned;
 496         int audit_tf, num_mk, fir;
 497         unsigned int cnt_mk;
 498         uint32_t orig_flight, orig_tf;
 499         uint32_t tsnlast, tsnfirst;
 500         int recovery_cnt = 0;
 501
 502
 503         /* none in flight now */
 504         audit_tf = 0;
 505         fir = 0;
 506         /*
 507          * figure out how long a data chunk must be pending before we can
 508          * mark it ..
 509          */
 510         (void)SCTP_GETTIME_TIMEVAL(&now);
 511         /* get cur rto in micro-seconds */
 512         cur_rto = (net->lastsa >> SCTP_RTT_SHIFT) + net->lastsv;
 513         cur_rto *= 1000;
 514         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 515                 sctp_log_fr(cur_rto,
 516                             stcb->asoc.peers_rwnd,
 517                             window_probe,
 518                             SCTP_FR_T3_MARK_TIME);
 519                 sctp_log_fr(net->flight_size, 0, 0, SCTP_FR_CWND_REPORT);
 520                 sctp_log_fr(net->flight_size, net->cwnd, stcb->asoc.total_flight, SCTP_FR_CWND_REPORT);
 521         }
 522         tv.tv_sec = cur_rto / 1000000;
 523         tv.tv_usec = cur_rto % 1000000;
 524 #if !(defined(__FreeBSD__) && !defined(__Userspace__))
 525         timersub(&now, &tv, &min_wait);
 526 #else
 527         min_wait = now;
 528         timevalsub(&min_wait, &tv);
 529 #endif
 530         if (min_wait.tv_sec < 0 || min_wait.tv_usec < 0) {
 531                 /*
 532                  * if we hit here, we don't have enough seconds on the clock
 533                  * to account for the RTO. We just let the lower seconds be
 534                  * the bounds and don't worry about it. This may mean we
 535                  * will mark a lot more than we should.
 536                  */
 537                 min_wait.tv_sec = min_wait.tv_usec = 0;
 538         }
 539         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 540                 sctp_log_fr(cur_rto, now.tv_sec, now.tv_usec, SCTP_FR_T3_MARK_TIME);
 541                 sctp_log_fr(0, min_wait.tv_sec, min_wait.tv_usec, SCTP_FR_T3_MARK_TIME);
 542         }
 543         /*
 544          * Our rwnd will be incorrect here since we are not adding back the
 545          * cnt * mbuf but we will fix that down below.
 546          */
 547         orig_flight = net->flight_size;
 548         orig_tf = stcb->asoc.total_flight;
 549
 550         net->fast_retran_ip = 0;
 551         /* Now on to each chunk */
 552         cnt_abandoned = 0;
 553         num_mk = cnt_mk = 0;
 554         tsnfirst = tsnlast = 0;
 555 #ifndef INVARIANTS
 556  start_again:
 557 #endif
 558         TAILQ_FOREACH_SAFE(chk, &stcb->asoc.sent_queue, sctp_next, nchk) {
 559                 if (SCTP_TSN_GE(stcb->asoc.last_acked_seq, chk->rec.data.tsn)) {
 560                         /* Strange case our list got out of order? */
 561                         SCTP_PRINTF("Our list is out of order? last_acked:%x chk:%x\n",
 562                                     (unsigned int)stcb->asoc.last_acked_seq, (unsigned int)chk->rec.data.tsn);
 563                         recovery_cnt++;
 564 #ifdef INVARIANTS
 565                         panic("last acked >= chk on sent-Q");
 566 #else
 567                         SCTP_PRINTF("Recover attempts a restart cnt:%d\n", recovery_cnt);
 568                         sctp_recover_sent_list(stcb);
 569                         if (recovery_cnt < 10) {
 570                                 goto start_again;
 571                         } else {
 572                                 SCTP_PRINTF("Recovery fails %d times??\n", recovery_cnt);
 573                         }
 574 #endif
 575                 }
 576                 if ((chk->whoTo == net) && (chk->sent < SCTP_DATAGRAM_ACKED)) {
 577                         /*
 578                          * found one to mark: If it is less than
 579                          * DATAGRAM_ACKED it MUST not be a skipped or marked
 580                          * TSN but instead one that is either already set
 581                          * for retransmission OR one that needs
 582                          * retransmission.
 583                          */
 584
 585                         /* validate its been outstanding long enough */
 586                         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 587                                 sctp_log_fr(chk->rec.data.tsn,
 588                                             chk->sent_rcv_time.tv_sec,
 589                                             chk->sent_rcv_time.tv_usec,
 590                                             SCTP_FR_T3_MARK_TIME);
 591                         }
 592                         if ((chk->sent_rcv_time.tv_sec > min_wait.tv_sec) && (window_probe == 0)) {
 593                                 /*
 594                                  * we have reached a chunk that was sent
 595                                  * some seconds past our min.. forget it we
 596                                  * will find no more to send.
 597                                  */
 598                                 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 599                                         sctp_log_fr(0,
 600                                                     chk->sent_rcv_time.tv_sec,
 601                                                     chk->sent_rcv_time.tv_usec,
 602                                                     SCTP_FR_T3_STOPPED);
 603                                 }
 604                                 continue;
 605                         } else if ((chk->sent_rcv_time.tv_sec == min_wait.tv_sec) &&
 606                                    (window_probe == 0)) {
 607                                 /*
 608                                  * we must look at the micro seconds to
 609                                  * know.
 610                                  */
 611                                 if (chk->sent_rcv_time.tv_usec >= min_wait.tv_usec) {
 612                                         /*
 613                                          * ok it was sent after our boundary
 614                                          * time.
 615                                          */
 616                                         continue;
 617                                 }
 618                         }
 619                         if (stcb->asoc.prsctp_supported && PR_SCTP_TTL_ENABLED(chk->flags)) {
 620                                 /* Is it expired? */
 621 #if !(defined(__FreeBSD__) && !defined(__Userspace__))
 622                                 if (timercmp(&now, &chk->rec.data.timetodrop, >)) {
 623 #else
 624                                 if (timevalcmp(&now, &chk->rec.data.timetodrop, >)) {
 625 #endif
 626                                         /* Yes so drop it */
 627                                         if (chk->data) {
 628                                                 (void)sctp_release_pr_sctp_chunk(stcb,
 629                                                                                  chk,
 630                                                                                  1,
 631                                                                                  SCTP_SO_NOT_LOCKED);
 632                                                 cnt_abandoned++;
 633                                         }
 634                                         continue;
 635                                 }
 636                         }
 637                         if (stcb->asoc.prsctp_supported && PR_SCTP_RTX_ENABLED(chk->flags)) {
 638                                 /* Has it been retransmitted tv_sec times? */
 639                                 if (chk->snd_count > chk->rec.data.timetodrop.tv_sec) {
 640                                         if (chk->data) {
 641                                                 (void)sctp_release_pr_sctp_chunk(stcb,
 642                                                                                  chk,
 643                                                                                  1,
 644                                                                                  SCTP_SO_NOT_LOCKED);
 645                                                 cnt_abandoned++;
 646                                         }
 647                                         continue;
 648                                 }
 649                         }
 650                         if (chk->sent < SCTP_DATAGRAM_RESEND) {
 651                                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
 652                                 num_mk++;
 653                                 if (fir == 0) {
 654                                         fir = 1;
 655                                         tsnfirst = chk->rec.data.tsn;
 656                                 }
 657                                 tsnlast = chk->rec.data.tsn;
 658                                 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 659                                         sctp_log_fr(chk->rec.data.tsn, chk->snd_count,
 660                                                     0, SCTP_FR_T3_MARKED);
 661                                 }
 662
 663                                 if (chk->rec.data.chunk_was_revoked) {
 664                                         /* deflate the cwnd */
 665                                         chk->whoTo->cwnd -= chk->book_size;
 666                                         chk->rec.data.chunk_was_revoked = 0;
 667                                 }
 668                                 net->marked_retrans++;
 669                                 stcb->asoc.marked_retrans++;
 670                                 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) {
 671                                         sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_RSND_TO,
 672                                                        chk->whoTo->flight_size,
 673                                                        chk->book_size,
 674                                                        (uint32_t)(uintptr_t)chk->whoTo,
 675                                                        chk->rec.data.tsn);
 676                                 }
 677                                 sctp_flight_size_decrease(chk);
 678                                 sctp_total_flight_decrease(stcb, chk);
 679                                 stcb->asoc.peers_rwnd += chk->send_size;
 680                                 stcb->asoc.peers_rwnd += SCTP_BASE_SYSCTL(sctp_peer_chunk_oh);
 681                         }
 682                         chk->sent = SCTP_DATAGRAM_RESEND;
 683                         chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 684                         SCTP_STAT_INCR(sctps_markedretrans);
 685
 686                         /* reset the TSN for striking and other FR stuff */
 687                         chk->rec.data.doing_fast_retransmit = 0;
 688                         /* Clear any time so NO RTT is being done */
 689
 690                         if (chk->do_rtt) {
 691                                 if (chk->whoTo->rto_needed == 0) {
 692                                         chk->whoTo->rto_needed = 1;
 693                                 }
 694                         }
 695                         chk->do_rtt = 0;
 696                         if (alt != net) {
 697                                 sctp_free_remote_addr(chk->whoTo);
 698                                 chk->no_fr_allowed = 1;
 699                                 chk->whoTo = alt;
 700                                 atomic_add_int(&alt->ref_count, 1);
 701                         } else {
 702                                 chk->no_fr_allowed = 0;
 703                                 if (TAILQ_EMPTY(&stcb->asoc.send_queue)) {
 704                                         chk->rec.data.fast_retran_tsn = stcb->asoc.sending_seq;
 705                                 } else {
 706                                         chk->rec.data.fast_retran_tsn = (TAILQ_FIRST(&stcb->asoc.send_queue))->rec.data.tsn;
 707                                 }
 708                         }
 709                         /* CMT: Do not allow FRs on retransmitted TSNs.
 710                          */
 711                         if (stcb->asoc.sctp_cmt_on_off > 0) {
 712                                 chk->no_fr_allowed = 1;
 713                         }
 714 #ifdef THIS_SHOULD_NOT_BE_DONE
 715                 } else if (chk->sent == SCTP_DATAGRAM_ACKED) {
 716                         /* remember highest acked one */
 717                         could_be_sent = chk;
 718 #endif
 719                 }
 720                 if (chk->sent == SCTP_DATAGRAM_RESEND) {
 721                         cnt_mk++;
 722                 }
 723         }
 724         if ((orig_flight - net->flight_size) != (orig_tf - stcb->asoc.total_flight)) {
 725                 /* we did not subtract the same things? */
 726                 audit_tf = 1;
 727         }
 728
 729         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 730                 sctp_log_fr(tsnfirst, tsnlast, num_mk, SCTP_FR_T3_TIMEOUT);
 731         }
 732 #ifdef SCTP_DEBUG
 733         if (num_mk) {
 734                 SCTPDBG(SCTP_DEBUG_TIMER1, "LAST TSN marked was %x\n",
 735                         tsnlast);
 736                 SCTPDBG(SCTP_DEBUG_TIMER1, "Num marked for retransmission was %d peer-rwd:%u\n",
 737                         num_mk,
 738                         stcb->asoc.peers_rwnd);
 739         }
 740 #endif
 741         *num_marked = num_mk;
 742         *num_abandoned = cnt_abandoned;
 743         /* Now check for a ECN Echo that may be stranded And
 744          * include the cnt_mk'd to have all resends in the
 745          * control queue.
 746          */
 747         TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
 748                 if (chk->sent == SCTP_DATAGRAM_RESEND) {
 749                         cnt_mk++;
 750                 }
 751                 if ((chk->whoTo == net) &&
 752                     (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) {
 753                         sctp_free_remote_addr(chk->whoTo);
 754                         chk->whoTo = alt;
 755                         if (chk->sent != SCTP_DATAGRAM_RESEND) {
 756                                 chk->sent = SCTP_DATAGRAM_RESEND;
 757                                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 758                                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
 759                                 cnt_mk++;
 760                         }
 761                         atomic_add_int(&alt->ref_count, 1);
 762                 }
 763         }
 764 #ifdef THIS_SHOULD_NOT_BE_DONE
 765         if ((stcb->asoc.sent_queue_retran_cnt == 0) && (could_be_sent)) {
 766                 /* fix it so we retransmit the highest acked anyway */
 767                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
 768                 cnt_mk++;
 769                 could_be_sent->sent = SCTP_DATAGRAM_RESEND;
 770         }
 771 #endif
 772         if (stcb->asoc.sent_queue_retran_cnt != cnt_mk) {
 773 #ifdef INVARIANTS
 774                 SCTP_PRINTF("Local Audit says there are %d for retran asoc cnt:%d we marked:%d this time\n",
 775                             cnt_mk, stcb->asoc.sent_queue_retran_cnt, num_mk);
 776 #endif
 777 #ifndef SCTP_AUDITING_ENABLED
 778                 stcb->asoc.sent_queue_retran_cnt = cnt_mk;
 779 #endif
 780         }
 781         if (audit_tf) {
 782                 SCTPDBG(SCTP_DEBUG_TIMER4,
 783                         "Audit total flight due to negative value net:%p\n",
 784                         (void *)net);
 785                 stcb->asoc.total_flight = 0;
 786                 stcb->asoc.total_flight_count = 0;
 787                 /* Clear all networks flight size */
 788                 TAILQ_FOREACH(lnets, &stcb->asoc.nets, sctp_next) {
 789                         lnets->flight_size = 0;
 790                         SCTPDBG(SCTP_DEBUG_TIMER4,
 791                                 "Net:%p c-f cwnd:%d ssthresh:%d\n",
 792                                 (void *)lnets, lnets->cwnd, lnets->ssthresh);
 793                 }
 794                 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
 795                         if (chk->sent < SCTP_DATAGRAM_RESEND) {
 796                                 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) {
 797                                         sctp_misc_ints(SCTP_FLIGHT_LOG_UP,
 798                                                        chk->whoTo->flight_size,
 799                                                        chk->book_size,
 800                                                        (uint32_t)(uintptr_t)chk->whoTo,
 801                                                        chk->rec.data.tsn);
 802                                 }
 803
 804                                 sctp_flight_size_increase(chk);
 805                                 sctp_total_flight_increase(stcb, chk);
 806                         }
 807                 }
 808         }
 809         /* We return 1 if we only have a window probe outstanding */
 810         return (0);
 811 }
 812
 813
 814 int
 815 sctp_t3rxt_timer(struct sctp_inpcb *inp,
 816     struct sctp_tcb *stcb,
 817     struct sctp_nets *net)
 818 {
 819         struct sctp_nets *alt;
 820         int win_probe, num_mk, num_abandoned;
 821
 822         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) {
 823                 sctp_log_fr(0, 0, 0, SCTP_FR_T3_TIMEOUT);
 824         }
 825         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
 826                 struct sctp_nets *lnet;
 827
 828                 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
 829                         if (net == lnet) {
 830                                 sctp_log_cwnd(stcb, lnet, 1, SCTP_CWND_LOG_FROM_T3);
 831                         } else {
 832                                 sctp_log_cwnd(stcb, lnet, 0, SCTP_CWND_LOG_FROM_T3);
 833                         }
 834                 }
 835         }
 836         /* Find an alternate and mark those for retransmission */
 837         if ((stcb->asoc.peers_rwnd == 0) &&
 838             (stcb->asoc.total_flight < net->mtu)) {
 839                 SCTP_STAT_INCR(sctps_timowindowprobe);
 840                 win_probe = 1;
 841         } else {
 842                 win_probe = 0;
 843         }
 844
 845         if (win_probe == 0) {
 846                 /* We don't do normal threshold management on window probes */
 847                 if (sctp_threshold_management(inp, stcb, net,
 848                     stcb->asoc.max_send_times)) {
 849                         /* Association was destroyed */
 850                         return (1);
 851                 } else {
 852                         if (net != stcb->asoc.primary_destination) {
 853                                 /* send a immediate HB if our RTO is stale */
 854                                 struct timeval now;
 855                                 unsigned int ms_goneby;
 856
 857                                 (void)SCTP_GETTIME_TIMEVAL(&now);
 858                                 if (net->last_sent_time.tv_sec) {
 859                                         ms_goneby = (now.tv_sec - net->last_sent_time.tv_sec) * 1000;
 860                                 } else {
 861                                         ms_goneby = 0;
 862                                 }
 863                                 if ((net->dest_state & SCTP_ADDR_PF) == 0) {
 864                                         if ((ms_goneby > net->RTO) || (net->RTO == 0)) {
 865                                                 /*
 866                                                  * no recent feed back in an RTO or
 867                                                  * more, request a RTT update
 868                                                  */
 869                                                 sctp_send_hb(stcb, net, SCTP_SO_NOT_LOCKED);
 870                                         }
 871                                 }
 872                         }
 873                 }
 874         } else {
 875                 /*
 876                  * For a window probe we don't penalize the net's but only
 877                  * the association. This may fail it if SACKs are not coming
 878                  * back. If sack's are coming with rwnd locked at 0, we will
 879                  * continue to hold things waiting for rwnd to raise
 880                  */
 881                 if (sctp_threshold_management(inp, stcb, NULL,
 882                     stcb->asoc.max_send_times)) {
 883                         /* Association was destroyed */
 884                         return (1);
 885                 }
 886         }
 887         if (stcb->asoc.sctp_cmt_on_off > 0) {
 888                 if (net->pf_threshold < net->failure_threshold) {
 889                         alt = sctp_find_alternate_net(stcb, net, 2);
 890                 } else {
 891                         /*
 892                          * CMT: Using RTX_SSTHRESH policy for CMT.
 893                          * If CMT is being used, then pick dest with
 894                          * largest ssthresh for any retransmission.
 895                          */
 896                         alt = sctp_find_alternate_net(stcb, net, 1);
 897                         /*
 898                          * CUCv2: If a different dest is picked for
 899                          * the retransmission, then new
 900                          * (rtx-)pseudo_cumack needs to be tracked
 901                          * for orig dest. Let CUCv2 track new (rtx-)
 902                          * pseudo-cumack always.
 903                          */
 904                         net->find_pseudo_cumack = 1;
 905                         net->find_rtx_pseudo_cumack = 1;
 906                 }
 907         } else {
 908                 alt = sctp_find_alternate_net(stcb, net, 0);
 909         }
 910
 911         num_mk = 0;
 912         num_abandoned = 0;
 913         (void)sctp_mark_all_for_resend(stcb, net, alt, win_probe,
 914                                       &num_mk, &num_abandoned);
 915         /* FR Loss recovery just ended with the T3. */
 916         stcb->asoc.fast_retran_loss_recovery = 0;
 917
 918         /* CMT FR loss recovery ended with the T3 */
 919         net->fast_retran_loss_recovery = 0;
 920         if ((stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins) &&
 921             (net->flight_size == 0)) {
 922                 (*stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins)(stcb, net);
 923         }
 924
 925         /*
 926          * setup the sat loss recovery that prevents satellite cwnd advance.
 927          */
 928         stcb->asoc.sat_t3_loss_recovery = 1;
 929         stcb->asoc.sat_t3_recovery_tsn = stcb->asoc.sending_seq;
 930
 931         /* Backoff the timer and cwnd */
 932         sctp_backoff_on_timeout(stcb, net, win_probe, num_mk, num_abandoned);
 933         if ((!(net->dest_state & SCTP_ADDR_REACHABLE)) ||
 934             (net->dest_state & SCTP_ADDR_PF)) {
 935                 /* Move all pending over too */
 936                 sctp_move_chunks_from_net(stcb, net);
 937
 938                 /* Get the address that failed, to
 939                  * force a new src address selecton and
 940                  * a route allocation.
 941                  */
 942                 if (net->ro._s_addr) {
 943                         sctp_free_ifa(net->ro._s_addr);
 944                         net->ro._s_addr = NULL;
 945                 }
 946                 net->src_addr_selected = 0;
 947
 948                 /* Force a route allocation too */
 949 #if defined(__FreeBSD__) && !defined(__Userspace__)
 950                 RO_NHFREE(&net->ro);
 951 #else
 952                 if (net->ro.ro_rt) {
 953                         RTFREE(net->ro.ro_rt);
 954                         net->ro.ro_rt = NULL;
 955                 }
 956 #endif
 957
 958                 /* Was it our primary? */
 959                 if ((stcb->asoc.primary_destination == net) && (alt != net)) {
 960                         /*
 961                          * Yes, note it as such and find an alternate note:
 962                          * this means HB code must use this to resent the
 963                          * primary if it goes active AND if someone does a
 964                          * change-primary then this flag must be cleared
 965                          * from any net structures.
 966                          */
 967                         if (stcb->asoc.alternate) {
 968                                 sctp_free_remote_addr(stcb->asoc.alternate);
 969                         }
 970                         stcb->asoc.alternate = alt;
 971                         atomic_add_int(&stcb->asoc.alternate->ref_count, 1);
 972                 }
 973         }
 974         /*
 975          * Special case for cookie-echo'ed case, we don't do output but must
 976          * await the COOKIE-ACK before retransmission
 977          */
 978         if (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED) {
 979                 /*
 980                  * Here we just reset the timer and start again since we
 981                  * have not established the asoc
 982                  */
 983                 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
 984                 return (0);
 985         }
 986         if (stcb->asoc.prsctp_supported) {
 987                 struct sctp_tmit_chunk *lchk;
 988
 989                 lchk = sctp_try_advance_peer_ack_point(stcb, &stcb->asoc);
 990                 /* C3. See if we need to send a Fwd-TSN */
 991                 if (SCTP_TSN_GT(stcb->asoc.advanced_peer_ack_point, stcb->asoc.last_acked_seq)) {
 992                         send_forward_tsn(stcb, &stcb->asoc);
 993                         for (; lchk != NULL; lchk = TAILQ_NEXT(lchk, sctp_next)) {
 994                                 if (lchk->whoTo != NULL) {
 995                                         break;
 996                                 }
 997                         }
 998                         if (lchk != NULL) {
 999                                 /* Assure a timer is up */
1000                                 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, lchk->whoTo);
1001                         }
1002                 }
1003         }
1004         if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1005                 sctp_log_cwnd(stcb, net, net->cwnd, SCTP_CWND_LOG_FROM_RTX);
1006         }
1007         return (0);
1008 }
1009
1010 int
1011 sctp_t1init_timer(struct sctp_inpcb *inp,
1012     struct sctp_tcb *stcb,
1013     struct sctp_nets *net)
1014 {
1015         /* bump the thresholds */
1016         if (stcb->asoc.delayed_connection) {
1017                 /*
1018                  * special hook for delayed connection. The library did NOT
1019                  * complete the rest of its sends.
1020                  */
1021                 stcb->asoc.delayed_connection = 0;
1022                 sctp_send_initiate(inp, stcb, SCTP_SO_NOT_LOCKED);
1023                 return (0);
1024         }
1025         if (SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) {
1026                 return (0);
1027         }
1028         if (sctp_threshold_management(inp, stcb, net,
1029             stcb->asoc.max_init_times)) {
1030                 /* Association was destroyed */
1031                 return (1);
1032         }
1033         stcb->asoc.dropped_special_cnt = 0;
1034         sctp_backoff_on_timeout(stcb, stcb->asoc.primary_destination, 1, 0, 0);
1035         if (stcb->asoc.initial_init_rto_max < net->RTO) {
1036                 net->RTO = stcb->asoc.initial_init_rto_max;
1037         }
1038         if (stcb->asoc.numnets > 1) {
1039                 /* If we have more than one addr use it */
1040                 struct sctp_nets *alt;
1041
1042                 alt = sctp_find_alternate_net(stcb, stcb->asoc.primary_destination, 0);
1043                 if (alt != stcb->asoc.primary_destination) {
1044                         sctp_move_chunks_from_net(stcb, stcb->asoc.primary_destination);
1045                         stcb->asoc.primary_destination = alt;
1046                 }
1047         }
1048         /* Send out a new init */
1049         sctp_send_initiate(inp, stcb, SCTP_SO_NOT_LOCKED);
1050         return (0);
1051 }
1052
1053 /*
1054  * For cookie and asconf we actually need to find and mark for resend, then
1055  * increment the resend counter (after all the threshold management stuff of
1056  * course).
1057  */
1058 int
1059 sctp_cookie_timer(struct sctp_inpcb *inp,
1060     struct sctp_tcb *stcb,
1061     struct sctp_nets *net SCTP_UNUSED)
1062 {
1063         struct sctp_nets *alt;
1064         struct sctp_tmit_chunk *cookie;
1065
1066         /* first before all else we must find the cookie */
1067         TAILQ_FOREACH(cookie, &stcb->asoc.control_send_queue, sctp_next) {
1068                 if (cookie->rec.chunk_id.id == SCTP_COOKIE_ECHO) {
1069                         break;
1070                 }
1071         }
1072         if (cookie == NULL) {
1073                 if (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED) {
1074                         /* FOOBAR! */
1075                         struct mbuf *op_err;
1076
1077                         op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code),
1078                                                      "Cookie timer expired, but no cookie");
1079                         inp->last_abort_code = SCTP_FROM_SCTP_TIMER + SCTP_LOC_3;
1080                         sctp_abort_an_association(inp, stcb, op_err, SCTP_SO_NOT_LOCKED);
1081                 } else {
1082 #ifdef INVARIANTS
1083                         panic("Cookie timer expires in wrong state?");
1084 #else
1085                         SCTP_PRINTF("Strange in state %d not cookie-echoed yet c-e timer expires?\n", SCTP_GET_STATE(stcb));
1086                         return (0);
1087 #endif
1088                 }
1089                 return (0);
1090         }
1091         /* Ok we found the cookie, threshold management next */
1092         if (sctp_threshold_management(inp, stcb, cookie->whoTo,
1093             stcb->asoc.max_init_times)) {
1094                 /* Assoc is over */
1095                 return (1);
1096         }
1097         /*
1098          * Cleared threshold management, now lets backoff the address
1099          * and select an alternate
1100          */
1101         stcb->asoc.dropped_special_cnt = 0;
1102         sctp_backoff_on_timeout(stcb, cookie->whoTo, 1, 0, 0);
1103         alt = sctp_find_alternate_net(stcb, cookie->whoTo, 0);
1104         if (alt != cookie->whoTo) {
1105                 sctp_free_remote_addr(cookie->whoTo);
1106                 cookie->whoTo = alt;
1107                 atomic_add_int(&alt->ref_count, 1);
1108         }
1109         /* Now mark the retran info */
1110         if (cookie->sent != SCTP_DATAGRAM_RESEND) {
1111                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1112         }
1113         cookie->sent = SCTP_DATAGRAM_RESEND;
1114         cookie->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1115         /*
1116          * Now call the output routine to kick out the cookie again, Note we
1117          * don't mark any chunks for retran so that FR will need to kick in
1118          * to move these (or a send timer).
1119          */
1120         return (0);
1121 }
1122
1123 int
1124 sctp_strreset_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
1125 {
1126         struct sctp_nets *alt, *net;
1127         struct sctp_tmit_chunk *strrst = NULL, *chk = NULL;
1128
1129         if (stcb->asoc.stream_reset_outstanding == 0) {
1130                 return (0);
1131         }
1132         /* find the existing STRRESET, we use the seq number we sent out on */
1133         (void)sctp_find_stream_reset(stcb, stcb->asoc.str_reset_seq_out, &strrst);
1134         if (strrst == NULL) {
1135                 return (0);
1136         }
1137         net = strrst->whoTo;
1138         /* do threshold management */
1139         if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1140                 /* Assoc is over */
1141                 return (1);
1142         }
1143         /*
1144          * Cleared threshold management, now lets backoff the address
1145          * and select an alternate
1146          */
1147         sctp_backoff_on_timeout(stcb, net, 1, 0, 0);
1148         alt = sctp_find_alternate_net(stcb, net, 0);
1149         strrst->whoTo = alt;
1150         atomic_add_int(&alt->ref_count, 1);
1151
1152         /* See if a ECN Echo is also stranded */
1153         TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
1154                 if ((chk->whoTo == net) &&
1155                     (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) {
1156                         sctp_free_remote_addr(chk->whoTo);
1157                         if (chk->sent != SCTP_DATAGRAM_RESEND) {
1158                                 chk->sent = SCTP_DATAGRAM_RESEND;
1159                                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1160                                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1161                         }
1162                         chk->whoTo = alt;
1163                         atomic_add_int(&alt->ref_count, 1);
1164                 }
1165         }
1166         if (!(net->dest_state & SCTP_ADDR_REACHABLE)) {
1167                 /*
1168                  * If the address went un-reachable, we need to move to
1169                  * alternates for ALL chk's in queue
1170                  */
1171                 sctp_move_chunks_from_net(stcb, net);
1172         }
1173         sctp_free_remote_addr(net);
1174
1175         /* mark the retran info */
1176         if (strrst->sent != SCTP_DATAGRAM_RESEND)
1177                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1178         strrst->sent = SCTP_DATAGRAM_RESEND;
1179         strrst->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1180
1181         /* restart the timer */
1182         sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, inp, stcb, alt);
1183         return (0);
1184 }
1185
1186 int
1187 sctp_asconf_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1188                   struct sctp_nets *net)
1189 {
1190         struct sctp_nets *alt;
1191         struct sctp_tmit_chunk *asconf, *chk;
1192
1193         /* is this a first send, or a retransmission? */
1194         if (TAILQ_EMPTY(&stcb->asoc.asconf_send_queue)) {
1195                 /* compose a new ASCONF chunk and send it */
1196                 sctp_send_asconf(stcb, net, SCTP_ADDR_NOT_LOCKED);
1197         } else {
1198                 /*
1199                  * Retransmission of the existing ASCONF is needed
1200                  */
1201
1202                 /* find the existing ASCONF */
1203                 asconf = TAILQ_FIRST(&stcb->asoc.asconf_send_queue);
1204                 if (asconf == NULL) {
1205                         return (0);
1206                 }
1207                 net = asconf->whoTo;
1208                 /* do threshold management */
1209                 if (sctp_threshold_management(inp, stcb, net,
1210                     stcb->asoc.max_send_times)) {
1211                         /* Assoc is over */
1212                         return (1);
1213                 }
1214                 if (asconf->snd_count > stcb->asoc.max_send_times) {
1215                         /*
1216                          * Something is rotten: our peer is not responding to
1217                          * ASCONFs but apparently is to other chunks.  i.e. it
1218                          * is not properly handling the chunk type upper bits.
1219                          * Mark this peer as ASCONF incapable and cleanup.
1220                          */
1221                         SCTPDBG(SCTP_DEBUG_TIMER1, "asconf_timer: Peer has not responded to our repeated ASCONFs\n");
1222                         sctp_asconf_cleanup(stcb);
1223                         return (0);
1224                 }
1225                 /*
1226                  * cleared threshold management, so now backoff the net and
1227                  * select an alternate
1228                  */
1229                 sctp_backoff_on_timeout(stcb, net, 1, 0, 0);
1230                 alt = sctp_find_alternate_net(stcb, net, 0);
1231                 if (asconf->whoTo != alt) {
1232                         asconf->whoTo = alt;
1233                         atomic_add_int(&alt->ref_count, 1);
1234                 }
1235
1236                 /* See if an ECN Echo is also stranded */
1237                 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
1238                         if ((chk->whoTo == net) &&
1239                             (chk->rec.chunk_id.id == SCTP_ECN_ECHO)) {
1240                                 sctp_free_remote_addr(chk->whoTo);
1241                                 chk->whoTo = alt;
1242                                 if (chk->sent != SCTP_DATAGRAM_RESEND) {
1243                                         chk->sent = SCTP_DATAGRAM_RESEND;
1244                                         chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1245                                         sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1246                                 }
1247                                 atomic_add_int(&alt->ref_count, 1);
1248                         }
1249                 }
1250                 TAILQ_FOREACH(chk, &stcb->asoc.asconf_send_queue, sctp_next) {
1251                         if (chk->whoTo != alt) {
1252                                 sctp_free_remote_addr(chk->whoTo);
1253                                 chk->whoTo = alt;
1254                                 atomic_add_int(&alt->ref_count, 1);
1255                         }
1256                         if (asconf->sent != SCTP_DATAGRAM_RESEND && chk->sent != SCTP_DATAGRAM_UNSENT)
1257                                 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1258                         chk->sent = SCTP_DATAGRAM_RESEND;
1259                         chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1260                 }
1261                 if (!(net->dest_state & SCTP_ADDR_REACHABLE)) {
1262                         /*
1263                          * If the address went un-reachable, we need to move
1264                          * to the alternate for ALL chunks in queue
1265                          */
1266                         sctp_move_chunks_from_net(stcb, net);
1267                 }
1268                 sctp_free_remote_addr(net);
1269
1270                 /* mark the retran info */
1271                 if (asconf->sent != SCTP_DATAGRAM_RESEND)
1272                         sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
1273                 asconf->sent = SCTP_DATAGRAM_RESEND;
1274                 asconf->flags |= CHUNK_FLAGS_FRAGMENT_OK;
1275
1276                 /* send another ASCONF if any and we can do */
1277                 sctp_send_asconf(stcb, alt, SCTP_ADDR_NOT_LOCKED);
1278         }
1279         return (0);
1280 }
1281
1282 /* Mobility adaptation */
1283 void
1284 sctp_delete_prim_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
1285 {
1286         if (stcb->asoc.deleted_primary == NULL) {
1287                 SCTPDBG(SCTP_DEBUG_ASCONF1, "delete_prim_timer: deleted_primary is not stored...\n");
1288                 sctp_mobility_feature_off(inp, SCTP_MOBILITY_PRIM_DELETED);
1289                 return;
1290         }
1291         SCTPDBG(SCTP_DEBUG_ASCONF1, "delete_prim_timer: finished to keep deleted primary ");
1292         SCTPDBG_ADDR(SCTP_DEBUG_ASCONF1, &stcb->asoc.deleted_primary->ro._l_addr.sa);
1293         sctp_free_remote_addr(stcb->asoc.deleted_primary);
1294         stcb->asoc.deleted_primary = NULL;
1295         sctp_mobility_feature_off(inp, SCTP_MOBILITY_PRIM_DELETED);
1296         return;
1297 }
1298
1299 /*
1300  * For the shutdown and shutdown-ack, we do not keep one around on the
1301  * control queue. This means we must generate a new one and call the general
1302  * chunk output routine, AFTER having done threshold management.
1303  * It is assumed that net is non-NULL.
1304  */
1305 int
1306 sctp_shutdown_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1307     struct sctp_nets *net)
1308 {
1309         struct sctp_nets *alt;
1310
1311         /* first threshold management */
1312         if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1313                 /* Assoc is over */
1314                 return (1);
1315         }
1316         sctp_backoff_on_timeout(stcb, net, 1, 0, 0);
1317         /* second select an alternative */
1318         alt = sctp_find_alternate_net(stcb, net, 0);
1319
1320         /* third generate a shutdown into the queue for out net */
1321         sctp_send_shutdown(stcb, alt);
1322
1323         /* fourth restart timer */
1324         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, inp, stcb, alt);
1325         return (0);
1326 }
1327
1328 int
1329 sctp_shutdownack_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1330     struct sctp_nets *net)
1331 {
1332         struct sctp_nets *alt;
1333
1334         /* first threshold management */
1335         if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1336                 /* Assoc is over */
1337                 return (1);
1338         }
1339         sctp_backoff_on_timeout(stcb, net, 1, 0, 0);
1340         /* second select an alternative */
1341         alt = sctp_find_alternate_net(stcb, net, 0);
1342
1343         /* third generate a shutdown into the queue for out net */
1344         sctp_send_shutdown_ack(stcb, alt);
1345
1346         /* fourth restart timer */
1347         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, inp, stcb, alt);
1348         return (0);
1349 }
1350
1351 static void
1352 sctp_audit_stream_queues_for_size(struct sctp_inpcb *inp,
1353     struct sctp_tcb *stcb)
1354 {
1355         struct sctp_stream_queue_pending *sp;
1356         unsigned int i, chks_in_queue = 0;
1357         int being_filled = 0;
1358         /*
1359          * This function is ONLY called when the send/sent queues are empty.
1360          */
1361         if ((stcb == NULL) || (inp == NULL))
1362                 return;
1363
1364         if (stcb->asoc.sent_queue_retran_cnt) {
1365                 SCTP_PRINTF("Hmm, sent_queue_retran_cnt is non-zero %d\n",
1366                             stcb->asoc.sent_queue_retran_cnt);
1367                 stcb->asoc.sent_queue_retran_cnt = 0;
1368         }
1369         if (stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, &stcb->asoc)) {
1370                 /* No stream scheduler information, initialize scheduler */
1371                 stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc, 0);
1372                 if (!stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, &stcb->asoc)) {
1373                         /* yep, we lost a stream or two */
1374                         SCTP_PRINTF("Found additional streams NOT managed by scheduler, corrected\n");
1375                 } else {
1376                         /* no streams lost */
1377                         stcb->asoc.total_output_queue_size = 0;
1378                 }
1379         }
1380         /* Check to see if some data queued, if so report it */
1381         for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
1382                 if (!TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) {
1383                         TAILQ_FOREACH(sp, &stcb->asoc.strmout[i].outqueue, next) {
1384                                 if (sp->msg_is_complete)
1385                                         being_filled++;
1386                                 chks_in_queue++;
1387                         }
1388                 }
1389         }
1390         if (chks_in_queue != stcb->asoc.stream_queue_cnt) {
1391                 SCTP_PRINTF("Hmm, stream queue cnt at %d I counted %d in stream out wheel\n",
1392                             stcb->asoc.stream_queue_cnt, chks_in_queue);
1393         }
1394         if (chks_in_queue) {
1395                 /* call the output queue function */
1396                 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED);
1397                 if ((TAILQ_EMPTY(&stcb->asoc.send_queue)) &&
1398                     (TAILQ_EMPTY(&stcb->asoc.sent_queue))) {
1399                         /*
1400                          * Probably should go in and make it go back through
1401                          * and add fragments allowed
1402                          */
1403                         if (being_filled == 0) {
1404                                 SCTP_PRINTF("Still nothing moved %d chunks are stuck\n",
1405                                             chks_in_queue);
1406                         }
1407                 }
1408         } else {
1409                 SCTP_PRINTF("Found no chunks on any queue tot:%lu\n",
1410                             (u_long)stcb->asoc.total_output_queue_size);
1411                 stcb->asoc.total_output_queue_size = 0;
1412         }
1413 }
1414
1415 int
1416 sctp_heartbeat_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1417     struct sctp_nets *net)
1418 {
1419         uint8_t net_was_pf;
1420
1421         if (net->dest_state & SCTP_ADDR_PF) {
1422                 net_was_pf = 1;
1423         } else {
1424                 net_was_pf = 0;
1425         }
1426         if (net->hb_responded == 0) {
1427                 if (net->ro._s_addr) {
1428                         /* Invalidate the src address if we did not get
1429                          * a response last time.
1430                          */
1431                         sctp_free_ifa(net->ro._s_addr);
1432                         net->ro._s_addr = NULL;
1433                         net->src_addr_selected = 0;
1434                 }
1435                 sctp_backoff_on_timeout(stcb, net, 1, 0, 0);
1436                 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1437                         /* Assoc is over */
1438                         return (1);
1439                 }
1440         }
1441         /* Zero PBA, if it needs it */
1442         if (net->partial_bytes_acked) {
1443                 net->partial_bytes_acked = 0;
1444         }
1445         if ((stcb->asoc.total_output_queue_size > 0) &&
1446             (TAILQ_EMPTY(&stcb->asoc.send_queue)) &&
1447             (TAILQ_EMPTY(&stcb->asoc.sent_queue))) {
1448                 sctp_audit_stream_queues_for_size(inp, stcb);
1449         }
1450         if (!(net->dest_state & SCTP_ADDR_NOHB) &&
1451             !((net_was_pf == 0) && (net->dest_state & SCTP_ADDR_PF))) {
1452                 /* when move to PF during threshold mangement, a HB has been
1453                    queued in that routine */
1454                 uint32_t ms_gone_by;
1455
1456                 if ((net->last_sent_time.tv_sec > 0) ||
1457                     (net->last_sent_time.tv_usec > 0)) {
1458 #if defined(__FreeBSD__) && !defined(__Userspace__)
1459                         struct timeval diff;
1460
1461                         SCTP_GETTIME_TIMEVAL(&diff);
1462                         timevalsub(&diff, &net->last_sent_time);
1463 #else
1464                         struct timeval diff, now;
1465
1466                         SCTP_GETTIME_TIMEVAL(&now);
1467                         timersub(&now, &net->last_sent_time, &diff);
1468 #endif
1469                         ms_gone_by = (uint32_t)(diff.tv_sec * 1000) +
1470                                      (uint32_t)(diff.tv_usec / 1000);
1471                 } else {
1472                         ms_gone_by = 0xffffffff;
1473                 }
1474                 if ((ms_gone_by >= net->heart_beat_delay) ||
1475                     (net->dest_state & SCTP_ADDR_PF)) {
1476                         sctp_send_hb(stcb, net, SCTP_SO_NOT_LOCKED);
1477                 }
1478         }
1479         return (0);
1480 }
1481
1482 void
1483 sctp_pathmtu_timer(struct sctp_inpcb *inp,
1484     struct sctp_tcb *stcb,
1485     struct sctp_nets *net)
1486 {
1487         uint32_t next_mtu, mtu;
1488
1489         next_mtu = sctp_get_next_mtu(net->mtu);
1490
1491         if ((next_mtu > net->mtu) && (net->port == 0)) {
1492                 if ((net->src_addr_selected == 0) ||
1493                     (net->ro._s_addr == NULL) ||
1494                     (net->ro._s_addr->localifa_flags & SCTP_BEING_DELETED)) {
1495                         if ((net->ro._s_addr != NULL) && (net->ro._s_addr->localifa_flags & SCTP_BEING_DELETED)) {
1496                                 sctp_free_ifa(net->ro._s_addr);
1497                                 net->ro._s_addr = NULL;
1498                                 net->src_addr_selected = 0;
1499                         } else  if (net->ro._s_addr == NULL) {
1500 #if defined(INET6) && defined(SCTP_EMBEDDED_V6_SCOPE)
1501                                 if (net->ro._l_addr.sa.sa_family == AF_INET6) {
1502                                         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&net->ro._l_addr;
1503                                         /* KAME hack: embed scopeid */
1504 #if defined(__APPLE__) && !defined(__Userspace__)
1505 #if defined(APPLE_LEOPARD) || defined(APPLE_SNOWLEOPARD)
1506                                         (void)in6_embedscope(&sin6->sin6_addr, sin6, NULL, NULL);
1507 #else
1508                                         (void)in6_embedscope(&sin6->sin6_addr, sin6, NULL, NULL, NULL);
1509 #endif
1510 #elif defined(SCTP_KAME)
1511                                         (void)sa6_embedscope(sin6, MODULE_GLOBAL(ip6_use_defzone));
1512 #else
1513                                         (void)in6_embedscope(&sin6->sin6_addr, sin6);
1514 #endif
1515                                 }
1516 #endif
1517
1518                                 net->ro._s_addr = sctp_source_address_selection(inp,
1519                                                                                 stcb,
1520                                                                                 (sctp_route_t *)&net->ro,
1521                                                                                 net, 0, stcb->asoc.vrf_id);
1522 #if defined(INET6) && defined(SCTP_EMBEDDED_V6_SCOPE)
1523                                 if (net->ro._l_addr.sa.sa_family == AF_INET6) {
1524                                         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&net->ro._l_addr;
1525 #ifdef SCTP_KAME
1526                                         (void)sa6_recoverscope(sin6);
1527 #else
1528                                         (void)in6_recoverscope(sin6, &sin6->sin6_addr, NULL);
1529 #endif  /* SCTP_KAME */
1530                                 }
1531 #endif  /* INET6 */
1532                         }
1533                         if (net->ro._s_addr)
1534                                 net->src_addr_selected = 1;
1535                 }
1536                 if (net->ro._s_addr) {
1537 #if defined(__FreeBSD__) && !defined(__Userspace__)
1538                         mtu = SCTP_GATHER_MTU_FROM_ROUTE(net->ro._s_addr, &net->ro._s_addr.sa, net->ro.ro_nh);
1539 #else
1540                         mtu = SCTP_GATHER_MTU_FROM_ROUTE(net->ro._s_addr, &net->ro._s_addr.sa, net->ro.ro_rt);
1541 #endif
1542 #if defined(INET) || defined(INET6)
1543                         if (net->port) {
1544                                 mtu -= sizeof(struct udphdr);
1545                         }
1546 #endif
1547                         if (mtu > next_mtu) {
1548                                 net->mtu = next_mtu;
1549                         } else {
1550                                 net->mtu = mtu;
1551                         }
1552                 }
1553         }
1554         /* restart the timer */
1555         sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
1556 }
1557
1558 void
1559 sctp_autoclose_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
1560 {
1561         struct timeval tn, *tim_touse;
1562         struct sctp_association *asoc;
1563         uint32_t ticks_gone_by;
1564
1565         (void)SCTP_GETTIME_TIMEVAL(&tn);
1566         if (stcb->asoc.sctp_autoclose_ticks > 0 &&
1567             sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE)) {
1568                 /* Auto close is on */
1569                 asoc = &stcb->asoc;
1570                 /* pick the time to use */
1571                 if (asoc->time_last_rcvd.tv_sec >
1572                     asoc->time_last_sent.tv_sec) {
1573                         tim_touse = &asoc->time_last_rcvd;
1574                 } else {
1575                         tim_touse = &asoc->time_last_sent;
1576                 }
1577                 /* Now has long enough transpired to autoclose? */
1578                 ticks_gone_by = sctp_secs_to_ticks((uint32_t)(tn.tv_sec - tim_touse->tv_sec));
1579                 if (ticks_gone_by >= asoc->sctp_autoclose_ticks) {
1580                         /*
1581                          * autoclose time has hit, call the output routine,
1582                          * which should do nothing just to be SURE we don't
1583                          * have hanging data. We can then safely check the
1584                          * queues and know that we are clear to send
1585                          * shutdown
1586                          */
1587                         sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR, SCTP_SO_NOT_LOCKED);
1588                         /* Are we clean? */
1589                         if (TAILQ_EMPTY(&asoc->send_queue) &&
1590                             TAILQ_EMPTY(&asoc->sent_queue)) {
1591                                 /*
1592                                  * there is nothing queued to send, so I'm
1593                                  * done...
1594                                  */
1595                                 if (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) {
1596                                         /* only send SHUTDOWN 1st time thru */
1597                                         struct sctp_nets *net;
1598
1599                                         if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
1600                                             (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
1601                                                 SCTP_STAT_DECR_GAUGE32(sctps_currestab);
1602                                         }
1603                                         SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
1604                                         sctp_stop_timers_for_shutdown(stcb);
1605                                         if (stcb->asoc.alternate) {
1606                                                 net = stcb->asoc.alternate;
1607                                         } else {
1608                                                 net = stcb->asoc.primary_destination;
1609                                         }
1610                                         sctp_send_shutdown(stcb, net);
1611                                         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1612                                                          stcb->sctp_ep, stcb, net);
1613                                         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1614                                                          stcb->sctp_ep, stcb, NULL);
1615                                 }
1616                         }
1617                 } else {
1618                         /*
1619                          * No auto close at this time, reset t-o to check
1620                          * later
1621                          */
1622                         uint32_t tmp;
1623
1624                         /* fool the timer startup to use the time left */
1625                         tmp = asoc->sctp_autoclose_ticks;
1626                         asoc->sctp_autoclose_ticks -= ticks_gone_by;
1627                         sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb, NULL);
1628                         /* restore the real tick value */
1629                         asoc->sctp_autoclose_ticks = tmp;
1630                 }
1631         }
1632 }
1633