?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reduce differences between our VKERNEL and VKERNEL64 configurations.
[dragonfly.git] / sys / netinet / sctp_timer.c
bloba9f7b0ef79fa5c289d2568312d7b0cb70c1e3bdb
1 /* $KAME: sctp_timer.c,v 1.28 2004/08/17 04:06:20 itojun Exp $ */
2
3 /*
4 * Copyright (C) 2002, 2003, 2004 Cisco Systems Inc,
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31 #if !(defined(__OpenBSD__) || defined(__APPLE__))
32 #include "opt_ipsec.h"
33 #endif
34 #if defined(__FreeBSD__) || defined(__DragonFly__)
35 #include "opt_compat.h"
36 #include "opt_inet6.h"
37 #include "opt_inet.h"
38 #endif
39 #if defined(__NetBSD__)
40 #include "opt_inet.h"
41 #endif
42 #ifdef __APPLE__
43 #include <sctp.h>
44 #elif !defined(__OpenBSD__)
45 #include "opt_sctp.h"
46 #endif
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/malloc.h>
51 #include <sys/mbuf.h>
52 #ifndef __OpenBSD__
53 #include <sys/domain.h>
54 #endif
55 #include <sys/protosw.h>
56 #include <sys/socket.h>
57 #include <sys/socketvar.h>
58 #include <sys/proc.h>
59 #include <sys/kernel.h>
60 #include <sys/sysctl.h>
61 #ifdef INET6
62 #include <sys/domain.h>
63 #endif
64
65 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
66 #include <sys/limits.h>
67 #else
68 #include <machine/limits.h>
69 #endif
70
71 #include <net/if.h>
72 #include <net/if_types.h>
73 #include <net/route.h>
74 #include <netinet/in.h>
75 #include <netinet/in_systm.h>
76 #define _IP_VHL
77 #include <netinet/ip.h>
78 #include <netinet/in_pcb.h>
79 #include <netinet/in_var.h>
80 #include <netinet/ip_var.h>
81
82 #ifdef INET6
83 #include <netinet/ip6.h>
84 #include <netinet6/ip6_var.h>
85 #endif /* INET6 */
86
87 #include <netinet/sctp_pcb.h>
88
89 #ifdef IPSEC
90 #ifndef __OpenBSD__
91 #include <netinet6/ipsec.h>
92 #include <netproto/key/key.h>
93 #else
94 #undef IPSEC
95 #endif
96 #endif /* IPSEC */
97 #ifdef INET6
98 #include <netinet6/sctp6_var.h>
99 #endif
100 #include <netinet/sctp_var.h>
101 #include <netinet/sctp_timer.h>
102 #include <netinet/sctputil.h>
103 #include <netinet/sctp_output.h>
104 #include <netinet/sctp_hashdriver.h>
105 #include <netinet/sctp_header.h>
106 #include <netinet/sctp_indata.h>
107 #include <netinet/sctp_asconf.h>
108
109 #include <netinet/sctp.h>
110 #include <netinet/sctp_uio.h>
111
112 #include <net/net_osdep.h>
113
114 #ifdef SCTP_DEBUG
115 extern u_int32_t sctp_debug_on;
116 #endif /* SCTP_DEBUG */
117
118 void
119 sctp_audit_retranmission_queue(struct sctp_association *asoc)
120 {
121 struct sctp_tmit_chunk *chk;
122
123 #ifdef SCTP_DEBUG
124 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
125 kprintf("Audit invoked on send queue cnt:%d onqueue:%d\n",
126 asoc->sent_queue_retran_cnt,
127 asoc->sent_queue_cnt);
128 }
129 #endif /* SCTP_DEBUG */
130 asoc->sent_queue_retran_cnt = 0;
131 asoc->sent_queue_cnt = 0;
132 TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {
133 if (chk->sent == SCTP_DATAGRAM_RESEND) {
134 asoc->sent_queue_retran_cnt++;
135 }
136 asoc->sent_queue_cnt++;
137 }
138 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) {
139 if (chk->sent == SCTP_DATAGRAM_RESEND) {
140 asoc->sent_queue_retran_cnt++;
141 }
142 }
143 #ifdef SCTP_DEBUG
144 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
145 kprintf("Audit completes retran:%d onqueue:%d\n",
146 asoc->sent_queue_retran_cnt,
147 asoc->sent_queue_cnt);
148 }
149 #endif /* SCTP_DEBUG */
150 }
151
152 int
153 sctp_threshold_management(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
154 struct sctp_nets *net, uint16_t threshold)
155 {
156 if (net) {
157 net->error_count++;
158 #ifdef SCTP_DEBUG
159 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
160 kprintf("Error count for %p now %d thresh:%d\n",
161 net, net->error_count,
162 net->failure_threshold);
163 }
164 #endif /* SCTP_DEBUG */
165 if (net->error_count >= net->failure_threshold) {
166 /* We had a threshold failure */
167 if (net->dest_state & SCTP_ADDR_REACHABLE) {
168 net->dest_state &= ~SCTP_ADDR_REACHABLE;
169 net->dest_state |= SCTP_ADDR_NOT_REACHABLE;
170 if (net == stcb->asoc.primary_destination) {
171 net->dest_state |= SCTP_ADDR_WAS_PRIMARY;
172 }
173 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
174 stcb,
175 SCTP_FAILED_THRESHOLD,
176 (void *)net);
177 }
178 }
179 /*********HOLD THIS COMMENT FOR PATCH OF ALTERNATE
180 *********ROUTING CODE
181 */
182 /*********HOLD THIS COMMENT FOR END OF PATCH OF ALTERNATE
183 *********ROUTING CODE
184 */
185 }
186 if (stcb == NULL)
187 return (0);
188
189 if (net) {
190 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) {
191 stcb->asoc.overall_error_count++;
192 }
193 } else {
194 stcb->asoc.overall_error_count++;
195 }
196 #ifdef SCTP_DEBUG
197 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
198 kprintf("Overall error count for %p now %d thresh:%u state:%x\n",
199 &stcb->asoc,
200 stcb->asoc.overall_error_count,
201 (u_int)threshold,
202 ((net == NULL) ? (u_int)0 : (u_int)net->dest_state));
203 }
204 #endif /* SCTP_DEBUG */
205 /* We specifically do not do >= to give the assoc one more
206 * change before we fail it.
207 */
208 if (stcb->asoc.overall_error_count > threshold) {
209 /* Abort notification sends a ULP notify */
210 struct mbuf *oper;
211 MGET(oper, MB_DONTWAIT, MT_DATA);
212 if (oper) {
213 struct sctp_paramhdr *ph;
214 u_int32_t *ippp;
215
216 oper->m_len = sizeof(struct sctp_paramhdr) +
217 sizeof(*ippp);
218 ph = mtod(oper, struct sctp_paramhdr *);
219 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION);
220 ph->param_length = htons(oper->m_len);
221 ippp = (u_int32_t *)(ph + 1);
222 *ippp = htonl(0x40000001);
223 }
224 sctp_abort_an_association(inp, stcb, SCTP_FAILED_THRESHOLD, oper);
225 return (1);
226 }
227 return (0);
228 }
229
230 struct sctp_nets *
231 sctp_find_alternate_net(struct sctp_tcb *stcb,
232 struct sctp_nets *net)
233 {
234 /* Find and return an alternate network if possible */
235 struct sctp_nets *alt, *mnet;
236 int once;
237
238 if (stcb->asoc.numnets == 1) {
239 /* No others but net */
240 return (TAILQ_FIRST(&stcb->asoc.nets));
241 }
242 mnet = net;
243 once = 0;
244
245 if (mnet == NULL) {
246 mnet = TAILQ_FIRST(&stcb->asoc.nets);
247 }
248 do {
249 alt = TAILQ_NEXT(mnet, sctp_next);
250 if (alt == NULL) {
251 once++;
252 if (once > 1) {
253 break;
254 }
255 alt = TAILQ_FIRST(&stcb->asoc.nets);
256 }
257 if (alt->ro.ro_rt == NULL) {
258 #ifndef SCOPEDROUTING
259 struct sockaddr_in6 *sin6;
260 sin6 = (struct sockaddr_in6 *)&alt->ro._l_addr;
261 if (sin6->sin6_family == AF_INET6) {
262 #if defined(SCTP_BASE_FREEBSD) || defined(__APPLE__) || defined(__DragonFly__)
263 in6_embedscope(&sin6->sin6_addr, sin6,
264 NULL, NULL);
265 #else
266 in6_embedscope(&sin6->sin6_addr, sin6);
267 #endif
268 }
269 #endif
270 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
271 rtalloc_ign((struct route*)&alt->ro, 0UL);
272 #else
273 rtalloc((struct route*)&alt->ro);
274 #endif
275 #ifndef SCOPEDROUTING
276 if (sin6->sin6_family == AF_INET6) {
277 in6_recoverscope(sin6, &sin6->sin6_addr, NULL);
278 }
279 #endif
280 alt->src_addr_selected = 0;
281 }
282 if (
283 ((alt->dest_state & SCTP_ADDR_REACHABLE) == SCTP_ADDR_REACHABLE) &&
284 (alt->ro.ro_rt != NULL) &&
285 (!(alt->dest_state & SCTP_ADDR_UNCONFIRMED))
286 ) {
287 /* Found a reachable address */
288 break;
289 }
290 mnet = alt;
291 } while (alt != NULL);
292
293 if (alt == NULL) {
294 /* Case where NO insv network exists (dormant state) */
295 /* we rotate destinations */
296 once = 0;
297 mnet = net;
298 do {
299 alt = TAILQ_NEXT(mnet, sctp_next);
300 if (alt == NULL) {
301 once++;
302 if (once > 1) {
303 break;
304 }
305 alt = TAILQ_FIRST(&stcb->asoc.nets);
306 }
307 if ((!(alt->dest_state & SCTP_ADDR_UNCONFIRMED)) &&
308 (alt != net)) {
309 /* Found an alternate address */
310 break;
311 }
312 mnet = alt;
313 } while (alt != NULL);
314 }
315 if (alt == NULL) {
316 return (net);
317 }
318 return (alt);
319 }
320
321 static void
322 sctp_backoff_on_timeout(struct sctp_tcb *stcb,
323 struct sctp_nets *net,
324 int win_probe,
325 int num_marked)
326 {
327 #ifdef SCTP_DEBUG
328 int oldRTO;
329
330 oldRTO = net->RTO;
331 #endif /* SCTP_DEBUG */
332 net->RTO <<= 1;
333 #ifdef SCTP_DEBUG
334 if (sctp_debug_on & SCTP_DEBUG_TIMER2) {
335 kprintf("Timer doubles from %d ms -to-> %d ms\n",
336 oldRTO, net->RTO);
337 }
338 #endif /* SCTP_DEBUG */
339
340 if (net->RTO > stcb->asoc.maxrto) {
341 net->RTO = stcb->asoc.maxrto;
342 #ifdef SCTP_DEBUG
343 if (sctp_debug_on & SCTP_DEBUG_TIMER2) {
344 kprintf("Growth capped by maxrto %d\n",
345 net->RTO);
346 }
347 #endif /* SCTP_DEBUG */
348 }
349
350
351 if ((win_probe == 0) && num_marked) {
352 /* We don't apply penalty to window probe scenarios */
353 #ifdef SCTP_CWND_LOGGING
354 int old_cwnd=net->cwnd;
355 #endif
356 net->ssthresh = net->cwnd >> 1;
357 if (net->ssthresh < (net->mtu << 1)) {
358 net->ssthresh = (net->mtu << 1);
359 }
360 net->cwnd = net->mtu;
361 /* floor of 1 mtu */
362 if (net->cwnd < net->mtu)
363 net->cwnd = net->mtu;
364 #ifdef SCTP_CWND_LOGGING
365 sctp_log_cwnd(net, net->cwnd-old_cwnd, SCTP_CWND_LOG_FROM_RTX);
366 #endif
367
368 net->partial_bytes_acked = 0;
369 #ifdef SCTP_DEBUG
370 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
371 kprintf("collapse cwnd to 1MTU ssthresh to %d\n",
372 net->ssthresh);
373 }
374 #endif
375
376 }
377 }
378
379
380 static int
381 sctp_mark_all_for_resend(struct sctp_tcb *stcb,
382 struct sctp_nets *net,
383 struct sctp_nets *alt,
384 int *num_marked)
385 {
386
387 /*
388 * Mark all chunks (well not all) that were sent to *net for retransmission.
389 * Move them to alt for there destination as well... We only
390 * mark chunks that have been outstanding long enough to have
391 * received feed-back.
392 */
393 struct sctp_tmit_chunk *chk, *tp2;
394 struct sctp_nets *lnets;
395 struct timeval now, min_wait, tv;
396 int cur_rto;
397 int win_probes, non_win_probes, orig_rwnd, audit_tf, num_mk, fir;
398 unsigned int cnt_mk;
399 u_int32_t orig_flight;
400 u_int32_t tsnlast, tsnfirst;
401
402 /* none in flight now */
403 audit_tf = 0;
404 fir=0;
405 /* figure out how long a data chunk must be pending
406 * before we can mark it ..
407 */
408 SCTP_GETTIME_TIMEVAL(&now);
409 /* get cur rto in micro-seconds */
410 cur_rto = (((net->lastsa >> 2) + net->lastsv) >> 1);
411 #ifdef SCTP_FR_LOGGING
412 sctp_log_fr(cur_rto, 0, 0, SCTP_FR_T3_MARK_TIME);
413 #endif
414 cur_rto *= 1000;
415 #ifdef SCTP_FR_LOGGING
416 sctp_log_fr(cur_rto, 0, 0, SCTP_FR_T3_MARK_TIME);
417 #endif
418 tv.tv_sec = cur_rto / 1000000;
419 tv.tv_usec = cur_rto % 1000000;
420 #ifndef __FreeBSD__
421 timersub(&now, &tv, &min_wait);
422 #else
423 min_wait = now;
424 timevalsub(&min_wait, &tv);
425 #endif
426 if (min_wait.tv_sec < 0 || min_wait.tv_usec < 0) {
427 /*
428 * if we hit here, we don't
429 * have enough seconds on the clock to account
430 * for the RTO. We just let the lower seconds
431 * be the bounds and don't worry about it. This
432 * may mean we will mark a lot more than we should.
433 */
434 min_wait.tv_sec = min_wait.tv_usec = 0;
435 }
436 #ifdef SCTP_FR_LOGGING
437 sctp_log_fr(cur_rto, now.tv_sec, now.tv_usec, SCTP_FR_T3_MARK_TIME);
438 sctp_log_fr(0, min_wait.tv_sec, min_wait.tv_usec, SCTP_FR_T3_MARK_TIME);
439 #endif
440 stcb->asoc.total_flight -= net->flight_size;
441 if (stcb->asoc.total_flight < 0) {
442 audit_tf = 1;
443 stcb->asoc.total_flight = 0;
444 }
445 /* Our rwnd will be incorrect here since we are not adding
446 * back the cnt * mbuf but we will fix that down below.
447 */
448 orig_rwnd = stcb->asoc.peers_rwnd;
449 orig_flight = net->flight_size;
450 stcb->asoc.peers_rwnd += net->flight_size;
451 net->flight_size = 0;
452 net->rto_pending = 0;
453 net->fast_retran_ip= 0;
454 win_probes = non_win_probes = 0;
455 #ifdef SCTP_DEBUG
456 if (sctp_debug_on & SCTP_DEBUG_TIMER2) {
457 kprintf("Marking ALL un-acked for retransmission at t3-timeout\n");
458 }
459 #endif /* SCTP_DEBUG */
460 /* Now on to each chunk */
461 num_mk = cnt_mk = 0;
462 tsnfirst = tsnlast = 0;
463 chk = TAILQ_FIRST(&stcb->asoc.sent_queue);
464 for (;chk != NULL; chk = tp2) {
465 tp2 = TAILQ_NEXT(chk, sctp_next);
466 if ((compare_with_wrap(stcb->asoc.last_acked_seq,
467 chk->rec.data.TSN_seq,
468 MAX_TSN)) ||
469 (stcb->asoc.last_acked_seq == chk->rec.data.TSN_seq)) {
470 /* Strange case our list got out of order? */
471 kprintf("Our list is out of order?\n");
472 TAILQ_REMOVE(&stcb->asoc.sent_queue, chk, sctp_next);
473 if (chk->data) {
474 sctp_release_pr_sctp_chunk(stcb, chk, 0xffff,
475 &stcb->asoc.sent_queue);
476 if (chk->flags & SCTP_PR_SCTP_BUFFER) {
477 stcb->asoc.sent_queue_cnt_removeable--;
478 }
479 }
480 stcb->asoc.sent_queue_cnt--;
481 sctp_free_remote_addr(chk->whoTo);
482 sctppcbinfo.ipi_count_chunk--;
483 if ((int)sctppcbinfo.ipi_count_chunk < 0) {
484 panic("Chunk count is going negative");
485 }
486 SCTP_ZONE_FREE(sctppcbinfo.ipi_zone_chunk, chk);
487 sctppcbinfo.ipi_gencnt_chunk++;
488 continue;
489 }
490 if ((chk->whoTo == net) && (chk->sent < SCTP_DATAGRAM_ACKED)) {
491 /* found one to mark:
492 * If it is less than DATAGRAM_ACKED it MUST
493 * not be a skipped or marked TSN but instead
494 * one that is either already set for retransmission OR
495 * one that needs retransmission.
496 */
497
498 /* validate its been outstanding long enough */
499 #ifdef SCTP_FR_LOGGING
500 sctp_log_fr(chk->rec.data.TSN_seq,
501 chk->sent_rcv_time.tv_sec,
502 chk->sent_rcv_time.tv_usec,
503 SCTP_FR_T3_MARK_TIME);
504 #endif
505 if (chk->sent_rcv_time.tv_sec > min_wait.tv_sec) {
506 /* we have reached a chunk that was sent some
507 * seconds past our min.. forget it we will
508 * find no more to send.
509 */
510 #ifdef SCTP_FR_LOGGING
511 sctp_log_fr(0,
512 chk->sent_rcv_time.tv_sec,
513 chk->sent_rcv_time.tv_usec,
514 SCTP_FR_T3_STOPPED);
515 #endif
516 continue;
517 } else if (chk->sent_rcv_time.tv_sec == min_wait.tv_sec) {
518 /* we must look at the micro seconds to know.
519 */
520 if (chk->sent_rcv_time.tv_usec >= min_wait.tv_usec) {
521 /* ok it was sent after our boundary time. */
522 #ifdef SCTP_FR_LOGGING
523 sctp_log_fr(0,
524 chk->sent_rcv_time.tv_sec,
525 chk->sent_rcv_time.tv_usec,
526 SCTP_FR_T3_STOPPED);
527 #endif
528 continue;
529 }
530 }
531 stcb->asoc.total_flight_count--;
532 if (stcb->asoc.total_flight_count < 0) {
533 stcb->asoc.total_flight_count = 0;
534 }
535 if ((chk->flags & (SCTP_PR_SCTP_ENABLED|SCTP_PR_SCTP_BUFFER)) == SCTP_PR_SCTP_ENABLED) {
536 /* Is it expired? */
537 if ((now.tv_sec > chk->rec.data.timetodrop.tv_sec) ||
538 ((chk->rec.data.timetodrop.tv_sec == now.tv_sec) &&
539 (now.tv_usec > chk->rec.data.timetodrop.tv_usec))) {
540 /* Yes so drop it */
541 if (chk->data) {
542 sctp_release_pr_sctp_chunk(stcb,
543 chk,
544 (SCTP_RESPONSE_TO_USER_REQ|SCTP_NOTIFY_DATAGRAM_SENT),
545 &stcb->asoc.sent_queue);
546 }
547 }
548 continue;
549 }
550 if (chk->sent != SCTP_DATAGRAM_RESEND) {
551 stcb->asoc.sent_queue_retran_cnt++;
552 num_mk++;
553 if (fir == 0) {
554 fir = 1;
555 #ifdef SCTP_DEBUG
556 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
557 kprintf("First TSN marked was %x\n",
558 chk->rec.data.TSN_seq);
559 }
560 #endif
561 tsnfirst = chk->rec.data.TSN_seq;
562 }
563 tsnlast = chk->rec.data.TSN_seq;
564 #ifdef SCTP_FR_LOGGING
565 sctp_log_fr(chk->rec.data.TSN_seq, chk->snd_count,
566 0, SCTP_FR_T3_MARKED);
567
568 #endif
569 }
570 chk->sent = SCTP_DATAGRAM_RESEND;
571 /* reset the TSN for striking and other FR stuff */
572 chk->rec.data.doing_fast_retransmit = 0;
573 #ifdef SCTP_DEBUG
574 if (sctp_debug_on & SCTP_DEBUG_TIMER3) {
575 kprintf("mark TSN:%x for retransmission\n", chk->rec.data.TSN_seq);
576 }
577 #endif /* SCTP_DEBUG */
578 /* Clear any time so NO RTT is being done */
579 chk->do_rtt = 0;
580 /* Bump up the count */
581 if (compare_with_wrap(chk->rec.data.TSN_seq,
582 stcb->asoc.t3timeout_highest_marked,
583 MAX_TSN)) {
584 /* TSN_seq > than t3timeout so update */
585 stcb->asoc.t3timeout_highest_marked = chk->rec.data.TSN_seq;
586 }
587 if (alt != net) {
588 sctp_free_remote_addr(chk->whoTo);
589 chk->whoTo = alt;
590 alt->ref_count++;
591 }
592 if ((chk->rec.data.state_flags & SCTP_WINDOW_PROBE) !=
593 SCTP_WINDOW_PROBE) {
594 non_win_probes++;
595 } else {
596 chk->rec.data.state_flags &= ~SCTP_WINDOW_PROBE;
597 win_probes++;
598 }
599 }
600 if (chk->sent == SCTP_DATAGRAM_RESEND) {
601 cnt_mk++;
602 }
603 }
604
605 #ifdef SCTP_FR_LOGGING
606 sctp_log_fr(tsnfirst, tsnlast, num_mk, SCTP_FR_T3_TIMEOUT);
607 #endif
608 /* compensate for the number we marked */
609 stcb->asoc.peers_rwnd += (num_mk /* * sizeof(struct mbuf)*/);
610
611 #ifdef SCTP_DEBUG
612 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
613 if (num_mk) {
614 kprintf("LAST TSN marked was %x\n", tsnlast);
615 kprintf("Num marked for retransmission was %d peer-rwd:%ld\n",
616 num_mk, (u_long)stcb->asoc.peers_rwnd);
617 kprintf("LAST TSN marked was %x\n", tsnlast);
618 kprintf("Num marked for retransmission was %d peer-rwd:%d\n",
619 num_mk,
620 (int)stcb->asoc.peers_rwnd
621 );
622 }
623 }
624 #endif
625 *num_marked = num_mk;
626 if (stcb->asoc.sent_queue_retran_cnt != cnt_mk) {
627 kprintf("Local Audit says there are %d for retran asoc cnt:%d\n",
628 cnt_mk, stcb->asoc.sent_queue_retran_cnt);
629 #ifndef SCTP_AUDITING_ENABLED
630 stcb->asoc.sent_queue_retran_cnt = cnt_mk;
631 #endif
632 }
633 #ifdef SCTP_DEBUG
634 if (sctp_debug_on & SCTP_DEBUG_TIMER3) {
635 kprintf("**************************\n");
636 }
637 #endif /* SCTP_DEBUG */
638
639 /* Now check for a ECN Echo that may be stranded */
640 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
641 if ((chk->whoTo == net) &&
642 (chk->rec.chunk_id == SCTP_ECN_ECHO)) {
643 sctp_free_remote_addr(chk->whoTo);
644 chk->whoTo = alt;
645 if (chk->sent != SCTP_DATAGRAM_RESEND) {
646 chk->sent = SCTP_DATAGRAM_RESEND;
647 stcb->asoc.sent_queue_retran_cnt++;
648 }
649 alt->ref_count++;
650 }
651 }
652 if ((orig_rwnd == 0) && (stcb->asoc.total_flight == 0) &&
653 (orig_flight <= net->mtu)) {
654 /*
655 * If the LAST packet sent was not acked and our rwnd is 0
656 * then we are in a win-probe state.
657 */
658 win_probes = 1;
659 non_win_probes = 0;
660 #ifdef SCTP_DEBUG
661 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
662 kprintf("WIN_PROBE set via o_rwnd=0 tf=0 and all:%d fit in mtu:%d\n",
663 orig_flight, net->mtu);
664 }
665 #endif
666 }
667
668 if (audit_tf) {
669 #ifdef SCTP_DEBUG
670 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
671 kprintf("Audit total flight due to negative value net:%p\n",
672 net);
673 }
674 #endif /* SCTP_DEBUG */
675 stcb->asoc.total_flight = 0;
676 stcb->asoc.total_flight_count = 0;
677 /* Clear all networks flight size */
678 TAILQ_FOREACH(lnets, &stcb->asoc.nets, sctp_next) {
679 lnets->flight_size = 0;
680 #ifdef SCTP_DEBUG
681 if (sctp_debug_on & SCTP_DEBUG_TIMER4) {
682 kprintf("Net:%p c-f cwnd:%d ssthresh:%d\n",
683 lnets, lnets->cwnd, lnets->ssthresh);
684 }
685 #endif /* SCTP_DEBUG */
686 }
687 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
688 if (chk->sent < SCTP_DATAGRAM_RESEND) {
689 stcb->asoc.total_flight += chk->book_size;
690 chk->whoTo->flight_size += chk->book_size;
691 stcb->asoc.total_flight_count++;
692 }
693 }
694 }
695 /* Setup the ecn nonce re-sync point. We
696 * do this since retranmissions are NOT
697 * setup for ECN. This means that do to
698 * Karn's rule, we don't know the total
699 * of the peers ecn bits.
700 */
701 chk = TAILQ_FIRST(&stcb->asoc.send_queue);
702 if (chk == NULL) {
703 stcb->asoc.nonce_resync_tsn = stcb->asoc.sending_seq;
704 } else {
705 stcb->asoc.nonce_resync_tsn = chk->rec.data.TSN_seq;
706 }
707 stcb->asoc.nonce_wait_for_ecne = 0;
708 stcb->asoc.nonce_sum_check = 0;
709 /* We return 1 if we only have a window probe outstanding */
710 if (win_probes && (non_win_probes == 0)) {
711 return (1);
712 }
713 return (0);
714 }
715
716 static void
717 sctp_move_all_chunks_to_alt(struct sctp_tcb *stcb,
718 struct sctp_nets *net,
719 struct sctp_nets *alt)
720 {
721 struct sctp_association *asoc;
722 struct sctp_stream_out *outs;
723 struct sctp_tmit_chunk *chk;
724
725 if (net == alt)
726 /* nothing to do */
727 return;
728
729 asoc = &stcb->asoc;
730
731 /*
732 * now through all the streams checking for chunks sent to our
733 * bad network.
734 */
735 TAILQ_FOREACH(outs, &asoc->out_wheel, next_spoke) {
736 /* now clean up any chunks here */
737 TAILQ_FOREACH(chk, &outs->outqueue, sctp_next) {
738 if (chk->whoTo == net) {
739 sctp_free_remote_addr(chk->whoTo);
740 chk->whoTo = alt;
741 alt->ref_count++;
742 }
743 }
744 }
745 /* Now check the pending queue */
746 TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) {
747 if (chk->whoTo == net) {
748 sctp_free_remote_addr(chk->whoTo);
749 chk->whoTo = alt;
750 alt->ref_count++;
751 }
752 }
753
754 }
755
756 int
757 sctp_t3rxt_timer(struct sctp_inpcb *inp,
758 struct sctp_tcb *stcb,
759 struct sctp_nets *net)
760 {
761 struct sctp_nets *alt;
762 int win_probe, num_mk;
763
764
765 #ifdef SCTP_FR_LOGGING
766 sctp_log_fr(0, 0, 0, SCTP_FR_T3_TIMEOUT);
767 #endif
768 /* Find an alternate and mark those for retransmission */
769 alt = sctp_find_alternate_net(stcb, net);
770 win_probe = sctp_mark_all_for_resend(stcb, net, alt, &num_mk);
771
772 /* FR Loss recovery just ended with the T3. */
773 stcb->asoc.fast_retran_loss_recovery = 0;
774
775 /* setup the sat loss recovery that prevents
776 * satellite cwnd advance.
777 */
778 stcb->asoc.sat_t3_loss_recovery = 1;
779 stcb->asoc.sat_t3_recovery_tsn = stcb->asoc.sending_seq;
780
781 /* Backoff the timer and cwnd */
782 sctp_backoff_on_timeout(stcb, net, win_probe, num_mk);
783 if (win_probe == 0) {
784 /* We don't do normal threshold management on window probes */
785 if (sctp_threshold_management(inp, stcb, net,
786 stcb->asoc.max_send_times)) {
787 /* Association was destroyed */
788 return (1);
789 } else {
790 if (net != stcb->asoc.primary_destination) {
791 /* send a immediate HB if our RTO is stale */
792 struct timeval now;
793 unsigned int ms_goneby;
794 SCTP_GETTIME_TIMEVAL(&now);
795 if (net->last_sent_time.tv_sec) {
796 ms_goneby = (now.tv_sec - net->last_sent_time.tv_sec) * 1000;
797 } else {
798 ms_goneby = 0;
799 }
800 if ((ms_goneby > net->RTO) || (net->RTO == 0)) {
801 /* no recent feed back in an RTO or more, request a RTT update */
802 sctp_send_hb(stcb, 1, net);
803 }
804 }
805 }
806 } else {
807 /*
808 * For a window probe we don't penalize the net's but only
809 * the association. This may fail it if SACKs are not coming
810 * back. If sack's are coming with rwnd locked at 0, we will
811 * continue to hold things waiting for rwnd to raise
812 */
813 if (sctp_threshold_management(inp, stcb, NULL,
814 stcb->asoc.max_send_times)) {
815 /* Association was destroyed */
816 return (1);
817 }
818 }
819 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) {
820 /* Move all pending over too */
821 sctp_move_all_chunks_to_alt(stcb, net, alt);
822 /* Was it our primary? */
823 if ((stcb->asoc.primary_destination == net) && (alt != net)) {
824 /*
825 * Yes, note it as such and find an alternate
826 * note: this means HB code must use this to resent
827 * the primary if it goes active AND if someone does
828 * a change-primary then this flag must be cleared
829 * from any net structures.
830 */
831 if (sctp_set_primary_addr(stcb,
832 NULL,
833 alt) == 0) {
834 net->dest_state |= SCTP_ADDR_WAS_PRIMARY;
835 net->src_addr_selected = 0;
836 }
837 }
838 }
839 /*
840 * Special case for cookie-echo'ed case, we don't do output
841 * but must await the COOKIE-ACK before retransmission
842 */
843 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) {
844 /*
845 * Here we just reset the timer and start again since we
846 * have not established the asoc
847 */
848 #ifdef SCTP_DEBUG
849 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
850 kprintf("Special cookie case return\n");
851 }
852 #endif /* SCTP_DEBUG */
853 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
854 return (0);
855 }
856 if (stcb->asoc.peer_supports_prsctp) {
857 struct sctp_tmit_chunk *lchk;
858 lchk = sctp_try_advance_peer_ack_point(stcb, &stcb->asoc);
859 /* C3. See if we need to send a Fwd-TSN */
860 if (compare_with_wrap(stcb->asoc.advanced_peer_ack_point,
861 stcb->asoc.last_acked_seq, MAX_TSN)) {
862 /*
863 * ISSUE with ECN, see FWD-TSN processing for notes
864 * on issues that will occur when the ECN NONCE stuff
865 * is put into SCTP for cross checking.
866 */
867 #ifdef SCTP_DEBUG
868 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
869 kprintf("Forward TSN time\n");
870 }
871 #endif /* SCTP_DEBUG */
872 send_forward_tsn(stcb, &stcb->asoc);
873 if (lchk) {
874 /* Assure a timer is up */
875 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, lchk->whoTo);
876 }
877 }
878 }
879 return (0);
880 }
881
882 int
883 sctp_t1init_timer(struct sctp_inpcb *inp,
884 struct sctp_tcb *stcb,
885 struct sctp_nets *net)
886 {
887 /* bump the thresholds */
888 if (stcb->asoc.delayed_connection) {
889 /* special hook for delayed connection. The
890 * library did NOT complete the rest of its
891 * sends.
892 */
893 stcb->asoc.delayed_connection = 0;
894 sctp_send_initiate(inp, stcb);
895 return (0);
896 }
897 if (sctp_threshold_management(inp, stcb, net,
898 stcb->asoc.max_init_times)) {
899 /* Association was destroyed */
900 return (1);
901 }
902 stcb->asoc.dropped_special_cnt = 0;
903 sctp_backoff_on_timeout(stcb, stcb->asoc.primary_destination, 1, 0);
904 if (stcb->asoc.initial_init_rto_max < net->RTO) {
905 net->RTO = stcb->asoc.initial_init_rto_max;
906 }
907 if (stcb->asoc.numnets > 1) {
908 /* If we have more than one addr use it */
909 struct sctp_nets *alt;
910 alt = sctp_find_alternate_net(stcb, stcb->asoc.primary_destination);
911 if ((alt != NULL) && (alt != stcb->asoc.primary_destination)) {
912 sctp_move_all_chunks_to_alt(stcb, stcb->asoc.primary_destination, alt);
913 stcb->asoc.primary_destination = alt;
914 }
915 }
916 /* Send out a new init */
917 sctp_send_initiate(inp, stcb);
918 return (0);
919 }
920
921 /*
922 * For cookie and asconf we actually need to find and mark for resend,
923 * then increment the resend counter (after all the threshold management
924 * stuff of course).
925 */
926 int
927 sctp_cookie_timer(struct sctp_inpcb *inp,
928 struct sctp_tcb *stcb,
929 struct sctp_nets *net)
930 {
931 struct sctp_nets *alt;
932 struct sctp_tmit_chunk *cookie;
933 /* first before all else we must find the cookie */
934 TAILQ_FOREACH(cookie, &stcb->asoc.control_send_queue, sctp_next) {
935 if (cookie->rec.chunk_id == SCTP_COOKIE_ECHO) {
936 break;
937 }
938 }
939 if (cookie == NULL) {
940 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) {
941 /* FOOBAR! */
942 struct mbuf *oper;
943 MGET(oper, MB_DONTWAIT, MT_DATA);
944 if (oper) {
945 struct sctp_paramhdr *ph;
946 u_int32_t *ippp;
947
948 oper->m_len = sizeof(struct sctp_paramhdr) +
949 sizeof(*ippp);
950 ph = mtod(oper, struct sctp_paramhdr *);
951 ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION);
952 ph->param_length = htons(oper->m_len);
953 ippp = (u_int32_t *)(ph + 1);
954 *ippp = htonl(0x40000002);
955 }
956 sctp_abort_an_association(inp, stcb, SCTP_INTERNAL_ERROR,
957 oper);
958 }
959 return (1);
960 }
961 /* Ok we found the cookie, threshold management next */
962 if (sctp_threshold_management(inp, stcb, cookie->whoTo,
963 stcb->asoc.max_init_times)) {
964 /* Assoc is over */
965 return (1);
966 }
967 /*
968 * cleared theshold management now lets backoff the address &
969 * select an alternate
970 */
971 stcb->asoc.dropped_special_cnt = 0;
972 sctp_backoff_on_timeout(stcb, cookie->whoTo, 1, 0);
973 alt = sctp_find_alternate_net(stcb, cookie->whoTo);
974 if (alt != cookie->whoTo) {
975 sctp_free_remote_addr(cookie->whoTo);
976 cookie->whoTo = alt;
977 alt->ref_count++;
978 }
979 /* Now mark the retran info */
980 if (cookie->sent != SCTP_DATAGRAM_RESEND) {
981 stcb->asoc.sent_queue_retran_cnt++;
982 }
983 cookie->sent = SCTP_DATAGRAM_RESEND;
984 /*
985 * Now call the output routine to kick out the cookie again, Note we
986 * don't mark any chunks for retran so that FR will need to kick in
987 * to move these (or a send timer).
988 */
989 return (0);
990 }
991
992 int
993 sctp_strreset_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
994 struct sctp_nets *net)
995 {
996 struct sctp_nets *alt;
997 struct sctp_tmit_chunk *strrst, *chk;
998 struct sctp_stream_reset_req *strreq;
999 /* find the existing STRRESET */
1000 TAILQ_FOREACH(strrst, &stcb->asoc.control_send_queue,
1001 sctp_next) {
1002 if (strrst->rec.chunk_id == SCTP_STREAM_RESET) {
1003 /* is it what we want */
1004 strreq = mtod(strrst->data, struct sctp_stream_reset_req *);
1005 if (strreq->sr_req.ph.param_type == ntohs(SCTP_STR_RESET_REQUEST)) {
1006 break;
1007 }
1008 }
1009 }
1010 if (strrst == NULL) {
1011 #ifdef SCTP_DEBUG
1012 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
1013 kprintf("Strange, strreset timer fires, but I can't find an str-reset?\n");
1014 }
1015 #endif /* SCTP_DEBUG */
1016 return (0);
1017 }
1018 /* do threshold management */
1019 if (sctp_threshold_management(inp, stcb, strrst->whoTo,
1020 stcb->asoc.max_send_times)) {
1021 /* Assoc is over */
1022 return (1);
1023 }
1024
1025 /*
1026 * cleared theshold management
1027 * now lets backoff the address & select an alternate
1028 */
1029 sctp_backoff_on_timeout(stcb, strrst->whoTo, 1, 0);
1030 alt = sctp_find_alternate_net(stcb, strrst->whoTo);
1031 sctp_free_remote_addr(strrst->whoTo);
1032 strrst->whoTo = alt;
1033 alt->ref_count++;
1034
1035 /* See if a ECN Echo is also stranded */
1036 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
1037 if ((chk->whoTo == net) &&
1038 (chk->rec.chunk_id == SCTP_ECN_ECHO)) {
1039 sctp_free_remote_addr(chk->whoTo);
1040 if (chk->sent != SCTP_DATAGRAM_RESEND) {
1041 chk->sent = SCTP_DATAGRAM_RESEND;
1042 stcb->asoc.sent_queue_retran_cnt++;
1043 }
1044 chk->whoTo = alt;
1045 alt->ref_count++;
1046 }
1047 }
1048 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) {
1049 /*
1050 * If the address went un-reachable, we need to move
1051 * to alternates for ALL chk's in queue
1052 */
1053 sctp_move_all_chunks_to_alt(stcb, net, alt);
1054 }
1055 /* mark the retran info */
1056 if (strrst->sent != SCTP_DATAGRAM_RESEND)
1057 stcb->asoc.sent_queue_retran_cnt++;
1058 strrst->sent = SCTP_DATAGRAM_RESEND;
1059
1060 /* restart the timer */
1061 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, inp, stcb, strrst->whoTo);
1062 return (0);
1063 }
1064
1065 int
1066 sctp_asconf_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1067 struct sctp_nets *net)
1068 {
1069 struct sctp_nets *alt;
1070 struct sctp_tmit_chunk *asconf, *chk;
1071
1072 /* is this the first send, or a retransmission? */
1073 if (stcb->asoc.asconf_sent == 0) {
1074 /* compose a new ASCONF chunk and send it */
1075 sctp_send_asconf(stcb, net);
1076 } else {
1077 /* Retransmission of the existing ASCONF needed... */
1078
1079 /* find the existing ASCONF */
1080 TAILQ_FOREACH(asconf, &stcb->asoc.control_send_queue,
1081 sctp_next) {
1082 if (asconf->rec.chunk_id == SCTP_ASCONF) {
1083 break;
1084 }
1085 }
1086 if (asconf == NULL) {
1087 #ifdef SCTP_DEBUG
1088 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
1089 kprintf("Strange, asconf timer fires, but I can't find an asconf?\n");
1090 }
1091 #endif /* SCTP_DEBUG */
1092 return (0);
1093 }
1094 /* do threshold management */
1095 if (sctp_threshold_management(inp, stcb, asconf->whoTo,
1096 stcb->asoc.max_send_times)) {
1097 /* Assoc is over */
1098 return (1);
1099 }
1100
1101 /* PETER? FIX? How will the following code ever run? If
1102 * the max_send_times is hit, threshold managment will
1103 * blow away the association?
1104 */
1105 if (asconf->snd_count > stcb->asoc.max_send_times) {
1106 /*
1107 * Something is rotten, peer is not responding to
1108 * ASCONFs but maybe is to data etc. e.g. it is not
1109 * properly handling the chunk type upper bits
1110 * Mark this peer as ASCONF incapable and cleanup
1111 */
1112 #ifdef SCTP_DEBUG
1113 if (sctp_debug_on & SCTP_DEBUG_TIMER1) {
1114 kprintf("asconf_timer: Peer has not responded to our repeated ASCONFs\n");
1115 }
1116 #endif /* SCTP_DEBUG */
1117 sctp_asconf_cleanup(stcb, net);
1118 return (0);
1119 }
1120 /*
1121 * cleared theshold management
1122 * now lets backoff the address & select an alternate
1123 */
1124 sctp_backoff_on_timeout(stcb, asconf->whoTo, 1, 0);
1125 alt = sctp_find_alternate_net(stcb, asconf->whoTo);
1126 sctp_free_remote_addr(asconf->whoTo);
1127 asconf->whoTo = alt;
1128 alt->ref_count++;
1129
1130 /* See if a ECN Echo is also stranded */
1131 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
1132 if ((chk->whoTo == net) &&
1133 (chk->rec.chunk_id == SCTP_ECN_ECHO)) {
1134 sctp_free_remote_addr(chk->whoTo);
1135 chk->whoTo = alt;
1136 if (chk->sent != SCTP_DATAGRAM_RESEND) {
1137 chk->sent = SCTP_DATAGRAM_RESEND;
1138 stcb->asoc.sent_queue_retran_cnt++;
1139 }
1140 alt->ref_count++;
1141
1142 }
1143 }
1144 if (net->dest_state & SCTP_ADDR_NOT_REACHABLE) {
1145 /*
1146 * If the address went un-reachable, we need to move
1147 * to alternates for ALL chk's in queue
1148 */
1149 sctp_move_all_chunks_to_alt(stcb, net, alt);
1150 }
1151 /* mark the retran info */
1152 if (asconf->sent != SCTP_DATAGRAM_RESEND)
1153 stcb->asoc.sent_queue_retran_cnt++;
1154 asconf->sent = SCTP_DATAGRAM_RESEND;
1155 }
1156 return (0);
1157 }
1158
1159 /*
1160 * For the shutdown and shutdown-ack, we do not keep one around on the
1161 * control queue. This means we must generate a new one and call the general
1162 * chunk output routine, AFTER having done threshold
1163 * management.
1164 */
1165 int
1166 sctp_shutdown_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1167 struct sctp_nets *net)
1168 {
1169 struct sctp_nets *alt;
1170 /* first threshold managment */
1171 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1172 /* Assoc is over */
1173 return (1);
1174 }
1175 /* second select an alternative */
1176 alt = sctp_find_alternate_net(stcb, net);
1177
1178 /* third generate a shutdown into the queue for out net */
1179 #ifdef SCTP_DEBUG
1180 if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1181 kprintf("%s:%d sends a shutdown\n",
1182 __FILE__,
1183 __LINE__
1184 );
1185 }
1186 #endif
1187 if (alt) {
1188 sctp_send_shutdown(stcb, alt);
1189 } else {
1190 /* if alt is NULL, there is no dest
1191 * to send to??
1192 */
1193 return (0);
1194 }
1195 /* fourth restart timer */
1196 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, inp, stcb, alt);
1197 return (0);
1198 }
1199
1200 int
1201 sctp_shutdownack_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1202 struct sctp_nets *net)
1203 {
1204 struct sctp_nets *alt;
1205 /* first threshold managment */
1206 if (sctp_threshold_management(inp, stcb, net, stcb->asoc.max_send_times)) {
1207 /* Assoc is over */
1208 return (1);
1209 }
1210 /* second select an alternative */
1211 alt = sctp_find_alternate_net(stcb, net);
1212
1213 /* third generate a shutdown into the queue for out net */
1214 sctp_send_shutdown_ack(stcb, alt);
1215
1216 /* fourth restart timer */
1217 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, inp, stcb, alt);
1218 return (0);
1219 }
1220
1221 static void
1222 sctp_audit_stream_queues_for_size(struct sctp_inpcb *inp,
1223 struct sctp_tcb *stcb)
1224 {
1225 struct sctp_stream_out *outs;
1226 struct sctp_tmit_chunk *chk;
1227 unsigned int chks_in_queue=0;
1228
1229 if ((stcb == NULL) || (inp == NULL))
1230 return;
1231 if (TAILQ_EMPTY(&stcb->asoc.out_wheel)) {
1232 kprintf("Strange, out_wheel empty nothing on sent/send and tot=%lu?\n",
1233 (u_long)stcb->asoc.total_output_queue_size);
1234 stcb->asoc.total_output_queue_size = 0;
1235 return;
1236 }
1237 if (stcb->asoc.sent_queue_retran_cnt) {
1238 kprintf("Hmm, sent_queue_retran_cnt is non-zero %d\n",
1239 stcb->asoc.sent_queue_retran_cnt);
1240 stcb->asoc.sent_queue_retran_cnt = 0;
1241 }
1242 /* Check to see if some data queued, if so report it */
1243 TAILQ_FOREACH(outs, &stcb->asoc.out_wheel, next_spoke) {
1244 if (!TAILQ_EMPTY(&outs->outqueue)) {
1245 TAILQ_FOREACH(chk, &outs->outqueue, sctp_next) {
1246 chks_in_queue++;
1247 }
1248 }
1249 }
1250 if (chks_in_queue != stcb->asoc.stream_queue_cnt) {
1251 kprintf("Hmm, stream queue cnt at %d I counted %d in stream out wheel\n",
1252 stcb->asoc.stream_queue_cnt, chks_in_queue);
1253 }
1254 if (chks_in_queue) {
1255 /* call the output queue function */
1256 sctp_chunk_output(inp, stcb, 1);
1257 if ((TAILQ_EMPTY(&stcb->asoc.send_queue)) &&
1258 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) {
1259 /* Probably should go in and make it go back through and add fragments allowed */
1260 kprintf("Still nothing moved %d chunks are stuck\n", chks_in_queue);
1261 }
1262 } else {
1263 kprintf("Found no chunks on any queue tot:%lu\n",
1264 (u_long)stcb->asoc.total_output_queue_size);
1265 stcb->asoc.total_output_queue_size = 0;
1266 }
1267 }
1268
1269 int
1270 sctp_heartbeat_timer(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1271 struct sctp_nets *net)
1272 {
1273 int cnt_of_unconf=0;
1274
1275 if (net) {
1276 if (net->hb_responded == 0) {
1277 sctp_backoff_on_timeout(stcb, net, 1, 0);
1278 }
1279 /* Zero PBA, if it needs it */
1280 if (net->partial_bytes_acked) {
1281 net->partial_bytes_acked = 0;
1282 }
1283 }
1284 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1285 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) &&
1286 (net->dest_state & SCTP_ADDR_REACHABLE)) {
1287 cnt_of_unconf++;
1288 }
1289 }
1290 if ((stcb->asoc.total_output_queue_size > 0) &&
1291 (TAILQ_EMPTY(&stcb->asoc.send_queue)) &&
1292 (TAILQ_EMPTY(&stcb->asoc.sent_queue))) {
1293 sctp_audit_stream_queues_for_size(inp, stcb);
1294 }
1295 /* Send a new HB, this will do threshold managment, pick a new dest */
1296 if (sctp_send_hb(stcb, 0, NULL) < 0) {
1297 return (1);
1298 }
1299 if (cnt_of_unconf > 1) {
1300 /*
1301 * this will send out extra hb's up to maxburst if
1302 * there are any unconfirmed addresses.
1303 */
1304 int cnt_sent = 1;
1305 while ((cnt_sent < stcb->asoc.max_burst) && (cnt_of_unconf > 1)) {
1306 if (sctp_send_hb(stcb, 0, NULL) == 0)
1307 break;
1308 cnt_of_unconf--;
1309 cnt_sent++;
1310 }
1311 }
1312 return (0);
1313 }
1314
1315 #define SCTP_NUMBER_OF_MTU_SIZES 18
1316 static u_int32_t mtu_sizes[]={
1317 68,
1318 296,
1319 508,
1320 512,
1321 544,
1322 576,
1323 1006,
1324 1492,
1325 1500,
1326 1536,
1327 2002,
1328 2048,
1329 4352,
1330 4464,
1331 8166,
1332 17914,
1333 32000,
1334 65535
1335 };
1336
1337
1338 static u_int32_t
1339 sctp_getnext_mtu(struct sctp_inpcb *inp, u_int32_t cur_mtu)
1340 {
1341 /* select another MTU that is just bigger than this one */
1342 int i;
1343
1344 for (i = 0; i < SCTP_NUMBER_OF_MTU_SIZES; i++) {
1345 if (cur_mtu < mtu_sizes[i]) {
1346 /* no max_mtu is bigger than this one */
1347 return (mtu_sizes[i]);
1348 }
1349 }
1350 /* here return the highest allowable */
1351 return (cur_mtu);
1352 }
1353
1354
1355 void
1356 sctp_pathmtu_timer(struct sctp_inpcb *inp,
1357 struct sctp_tcb *stcb,
1358 struct sctp_nets *net)
1359 {
1360 u_int32_t next_mtu;
1361
1362 /* restart the timer in any case */
1363 next_mtu = sctp_getnext_mtu(inp, net->mtu);
1364 if (next_mtu <= net->mtu) {
1365 /* nothing to do */
1366 return;
1367 }
1368 if (net->ro.ro_rt != NULL) {
1369 /* only if we have a route and interface do we
1370 * set anything. Note we always restart
1371 * the timer though just in case it is updated
1372 * (i.e. the ifp) or route/ifp is populated.
1373 */
1374 if (net->ro.ro_rt->rt_ifp != NULL) {
1375 if (net->ro.ro_rt->rt_ifp->if_mtu > next_mtu) {
1376 /* ok it will fit out the door */
1377 net->mtu = next_mtu;
1378 }
1379 }
1380 }
1381 /* restart the timer */
1382 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
1383 }
1384
1385 void
1386 sctp_autoclose_timer(struct sctp_inpcb *inp,
1387 struct sctp_tcb *stcb,
1388 struct sctp_nets *net)
1389 {
1390 struct timeval tn, *tim_touse;
1391 struct sctp_association *asoc;
1392 int ticks_gone_by;
1393
1394 SCTP_GETTIME_TIMEVAL(&tn);
1395 if (stcb->asoc.sctp_autoclose_ticks &&
1396 (inp->sctp_flags & SCTP_PCB_FLAGS_AUTOCLOSE)) {
1397 /* Auto close is on */
1398 asoc = &stcb->asoc;
1399 /* pick the time to use */
1400 if (asoc->time_last_rcvd.tv_sec >
1401 asoc->time_last_sent.tv_sec) {
1402 tim_touse = &asoc->time_last_rcvd;
1403 } else {
1404 tim_touse = &asoc->time_last_sent;
1405 }
1406 /* Now has long enough transpired to autoclose? */
1407 ticks_gone_by = ((tn.tv_sec - tim_touse->tv_sec) * hz);
1408 if ((ticks_gone_by > 0) &&
1409 (ticks_gone_by >= (int)asoc->sctp_autoclose_ticks)) {
1410 /*
1411 * autoclose time has hit, call the output routine,
1412 * which should do nothing just to be SURE we don't
1413 * have hanging data. We can then safely check the
1414 * queues and know that we are clear to send shutdown
1415 */
1416 sctp_chunk_output(inp, stcb, 9);
1417 /* Are we clean? */
1418 if (TAILQ_EMPTY(&asoc->send_queue) &&
1419 TAILQ_EMPTY(&asoc->sent_queue)) {
1420 /*
1421 * there is nothing queued to send,
1422 * so I'm done...
1423 */
1424 if (SCTP_GET_STATE(asoc) !=
1425 SCTP_STATE_SHUTDOWN_SENT) {
1426 /* only send SHUTDOWN 1st time thru */
1427 #ifdef SCTP_DEBUG
1428 if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1429 kprintf("%s:%d sends a shutdown\n",
1430 __FILE__,
1431 __LINE__
1432 );
1433 }
1434 #endif
1435 sctp_send_shutdown(stcb, stcb->asoc.primary_destination);
1436 asoc->state = SCTP_STATE_SHUTDOWN_SENT;
1437 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1438 stcb->sctp_ep, stcb,
1439 asoc->primary_destination);
1440 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1441 stcb->sctp_ep, stcb,
1442 asoc->primary_destination);
1443 }
1444 }
1445 } else {
1446 /*
1447 * No auto close at this time, reset t-o to
1448 * check later
1449 */
1450 int tmp;
1451 /* fool the timer startup to use the time left */
1452 tmp = asoc->sctp_autoclose_ticks;
1453 asoc->sctp_autoclose_ticks -= ticks_gone_by;
1454 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb,
1455 net);
1456 /* restore the real tick value */
1457 asoc->sctp_autoclose_ticks = tmp;
1458 }
1459 }
1460 }
1461
1462 void
1463 sctp_iterator_timer(struct sctp_iterator *it)
1464 {
1465 int cnt= 0;
1466 /* only one iterator can run at a
1467 * time. This is the only way we
1468 * can cleanly pull ep's from underneath
1469 * all the running interators when a
1470 * ep is freed.
1471 */
1472 SCTP_ITERATOR_LOCK();
1473 if (it->inp == NULL) {
1474 /* iterator is complete */
1475 done_with_iterator:
1476 SCTP_ITERATOR_UNLOCK();
1477 SCTP_INP_INFO_WLOCK();
1478 LIST_REMOVE(it, sctp_nxt_itr);
1479 /* stopping the callout is not needed, in theory,
1480 * but I am paranoid.
1481 */
1482 SCTP_INP_INFO_WUNLOCK();
1483 callout_stop(&it->tmr.timer);
1484 if (it->function_atend != NULL) {
1485 (*it->function_atend)(it->pointer, it->val);
1486 }
1487 kfree(it, M_PCB);
1488 return;
1489 }
1490 select_a_new_ep:
1491 SCTP_INP_WLOCK(it->inp);
1492 while ((it->pcb_flags) && ((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) {
1493 /* we do not like this ep */
1494 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {
1495 SCTP_INP_WUNLOCK(it->inp);
1496 goto done_with_iterator;
1497 }
1498 SCTP_INP_WUNLOCK(it->inp);
1499 it->inp = LIST_NEXT(it->inp, sctp_list);
1500 if (it->inp == NULL) {
1501 goto done_with_iterator;
1502 }
1503 SCTP_INP_WLOCK(it->inp);
1504 }
1505 if ((it->inp->inp_starting_point_for_iterator != NULL) &&
1506 (it->inp->inp_starting_point_for_iterator != it)) {
1507 kprintf("Iterator collision, we must wait for other iterator at %p\n",
1508 it->inp);
1509 SCTP_INP_WUNLOCK(it->inp);
1510 goto start_timer_return;
1511 }
1512 /* now we do the actual write to this guy */
1513 it->inp->inp_starting_point_for_iterator = it;
1514 SCTP_INP_WUNLOCK(it->inp);
1515 SCTP_INP_RLOCK(it->inp);
1516 /* if we reach here we found a inp acceptable, now through each
1517 * one that has the association in the right state
1518 */
1519 if (it->stcb == NULL) {
1520 it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list);
1521 }
1522 if (it->stcb->asoc.stcb_starting_point_for_iterator == it) {
1523 it->stcb->asoc.stcb_starting_point_for_iterator = NULL;
1524 }
1525 while (it->stcb) {
1526 SCTP_TCB_LOCK(it->stcb);
1527 if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) {
1528 SCTP_TCB_UNLOCK(it->stcb);
1529 it->stcb = LIST_NEXT(it->stcb, sctp_tcblist);
1530 continue;
1531 }
1532 cnt++;
1533 /* run function on this one */
1534 SCTP_INP_RUNLOCK(it->inp);
1535 (*it->function_toapply)(it->inp, it->stcb, it->pointer, it->val);
1536 sctp_chunk_output(it->inp, it->stcb, 1);
1537 SCTP_TCB_UNLOCK(it->stcb);
1538 /* see if we have limited out */
1539 if (cnt > SCTP_MAX_ITERATOR_AT_ONCE) {
1540 it->stcb->asoc.stcb_starting_point_for_iterator = it;
1541 start_timer_return:
1542 SCTP_ITERATOR_UNLOCK();
1543 sctp_timer_start(SCTP_TIMER_TYPE_ITERATOR, (struct sctp_inpcb *)it, NULL, NULL);
1544 return;
1545 }
1546 SCTP_INP_RLOCK(it->inp);
1547 it->stcb = LIST_NEXT(it->stcb, sctp_tcblist);
1548 }
1549 /* if we reach here, we ran out of stcb's in the inp we are looking at */
1550 SCTP_INP_RUNLOCK(it->inp);
1551 SCTP_INP_WLOCK(it->inp);
1552 it->inp->inp_starting_point_for_iterator = NULL;
1553 SCTP_INP_WUNLOCK(it->inp);
1554 if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {
1555 it->inp = NULL;
1556 } else {
1557 SCTP_INP_INFO_RLOCK();
1558 it->inp = LIST_NEXT(it->inp, sctp_list);
1559 SCTP_INP_INFO_RUNLOCK();
1560 }
1561 if (it->inp == NULL) {
1562 goto done_with_iterator;
1563 }
1564 goto select_a_new_ep;
1565 }
DragonFly BSD