sys/netinet/sctp_timer.c

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