xref: /freebsd/sys/netinet/sctputil.c (revision 97c76f10a082eb0c921134f12b4f3ab8c5a4b118)
1f8829a4aSRandall Stewart /*-
2b1006367SRandall Stewart  * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
3f8829a4aSRandall Stewart  *
4f8829a4aSRandall Stewart  * Redistribution and use in source and binary forms, with or without
5f8829a4aSRandall Stewart  * modification, are permitted provided that the following conditions are met:
6f8829a4aSRandall Stewart  *
7f8829a4aSRandall Stewart  * a) Redistributions of source code must retain the above copyright notice,
8f8829a4aSRandall Stewart  *   this list of conditions and the following disclaimer.
9f8829a4aSRandall Stewart  *
10f8829a4aSRandall Stewart  * b) Redistributions in binary form must reproduce the above copyright
11f8829a4aSRandall Stewart  *    notice, this list of conditions and the following disclaimer in
12f8829a4aSRandall Stewart  *   the documentation and/or other materials provided with the distribution.
13f8829a4aSRandall Stewart  *
14f8829a4aSRandall Stewart  * c) Neither the name of Cisco Systems, Inc. nor the names of its
15f8829a4aSRandall Stewart  *    contributors may be used to endorse or promote products derived
16f8829a4aSRandall Stewart  *    from this software without specific prior written permission.
17f8829a4aSRandall Stewart  *
18f8829a4aSRandall Stewart  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19f8829a4aSRandall Stewart  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20f8829a4aSRandall Stewart  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21f8829a4aSRandall Stewart  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22f8829a4aSRandall Stewart  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23f8829a4aSRandall Stewart  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24f8829a4aSRandall Stewart  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25f8829a4aSRandall Stewart  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26f8829a4aSRandall Stewart  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27f8829a4aSRandall Stewart  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
28f8829a4aSRandall Stewart  * THE POSSIBILITY OF SUCH DAMAGE.
29f8829a4aSRandall Stewart  */
30f8829a4aSRandall Stewart 
31f8829a4aSRandall Stewart /* $KAME: sctputil.c,v 1.37 2005/03/07 23:26:09 itojun Exp $	 */
32f8829a4aSRandall Stewart 
33f8829a4aSRandall Stewart #include <sys/cdefs.h>
34f8829a4aSRandall Stewart __FBSDID("$FreeBSD$");
35f8829a4aSRandall Stewart 
36f8829a4aSRandall Stewart #include <netinet/sctp_os.h>
37f8829a4aSRandall Stewart #include <netinet/sctp_pcb.h>
38f8829a4aSRandall Stewart #include <netinet/sctputil.h>
39f8829a4aSRandall Stewart #include <netinet/sctp_var.h>
4042551e99SRandall Stewart #include <netinet/sctp_sysctl.h>
41f8829a4aSRandall Stewart #ifdef INET6
42f8829a4aSRandall Stewart #include <netinet6/sctp6_var.h>
43f8829a4aSRandall Stewart #endif
44f8829a4aSRandall Stewart #include <netinet/sctp_header.h>
45f8829a4aSRandall Stewart #include <netinet/sctp_output.h>
46f8829a4aSRandall Stewart #include <netinet/sctp_uio.h>
47f8829a4aSRandall Stewart #include <netinet/sctp_timer.h>
48f8829a4aSRandall Stewart #include <netinet/sctp_crc32.h>
49f8829a4aSRandall Stewart #include <netinet/sctp_indata.h>/* for sctp_deliver_data() */
50f8829a4aSRandall Stewart #include <netinet/sctp_auth.h>
51f8829a4aSRandall Stewart #include <netinet/sctp_asconf.h>
52f8829a4aSRandall Stewart 
53f8829a4aSRandall Stewart #define NUMBER_OF_MTU_SIZES 18
54f8829a4aSRandall Stewart 
55f8829a4aSRandall Stewart 
56b9e7085aSRandall Stewart #ifndef KTR_SCTP
57b9e7085aSRandall Stewart #define KTR_SCTP KTR_SUBSYS
5880fefe0aSRandall Stewart #endif
59f8829a4aSRandall Stewart 
60f8829a4aSRandall Stewart void
61f8829a4aSRandall Stewart sctp_sblog(struct sockbuf *sb,
62f8829a4aSRandall Stewart     struct sctp_tcb *stcb, int from, int incr)
63f8829a4aSRandall Stewart {
6480fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
65f8829a4aSRandall Stewart 
6680fefe0aSRandall Stewart 	sctp_clog.x.sb.stcb = stcb;
6780fefe0aSRandall Stewart 	sctp_clog.x.sb.so_sbcc = sb->sb_cc;
68f8829a4aSRandall Stewart 	if (stcb)
6980fefe0aSRandall Stewart 		sctp_clog.x.sb.stcb_sbcc = stcb->asoc.sb_cc;
70f8829a4aSRandall Stewart 	else
7180fefe0aSRandall Stewart 		sctp_clog.x.sb.stcb_sbcc = 0;
7280fefe0aSRandall Stewart 	sctp_clog.x.sb.incr = incr;
73b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
7480fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_SB,
7580fefe0aSRandall Stewart 	    from,
7680fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
7780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
7880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
7980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
80f8829a4aSRandall Stewart }
81f8829a4aSRandall Stewart 
82f8829a4aSRandall Stewart void
83f8829a4aSRandall Stewart sctp_log_closing(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int16_t loc)
84f8829a4aSRandall Stewart {
8580fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
86f8829a4aSRandall Stewart 
8780fefe0aSRandall Stewart 	sctp_clog.x.close.inp = (void *)inp;
8880fefe0aSRandall Stewart 	sctp_clog.x.close.sctp_flags = inp->sctp_flags;
89f8829a4aSRandall Stewart 	if (stcb) {
9080fefe0aSRandall Stewart 		sctp_clog.x.close.stcb = (void *)stcb;
9180fefe0aSRandall Stewart 		sctp_clog.x.close.state = (uint16_t) stcb->asoc.state;
92f8829a4aSRandall Stewart 	} else {
9380fefe0aSRandall Stewart 		sctp_clog.x.close.stcb = 0;
9480fefe0aSRandall Stewart 		sctp_clog.x.close.state = 0;
95f8829a4aSRandall Stewart 	}
9680fefe0aSRandall Stewart 	sctp_clog.x.close.loc = loc;
97b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
9880fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_CLOSE,
9980fefe0aSRandall Stewart 	    0,
10080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
10180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
10280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
10380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
104f8829a4aSRandall Stewart }
105f8829a4aSRandall Stewart 
106f8829a4aSRandall Stewart 
107f8829a4aSRandall Stewart void
108f8829a4aSRandall Stewart rto_logging(struct sctp_nets *net, int from)
109f8829a4aSRandall Stewart {
11080fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
111f8829a4aSRandall Stewart 
11280fefe0aSRandall Stewart 	sctp_clog.x.rto.net = (void *)net;
11380fefe0aSRandall Stewart 	sctp_clog.x.rto.rtt = net->prev_rtt;
114b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
11580fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_RTT,
11680fefe0aSRandall Stewart 	    from,
11780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
11880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
11980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
12080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
12180fefe0aSRandall Stewart 
122f8829a4aSRandall Stewart }
123f8829a4aSRandall Stewart 
124f8829a4aSRandall Stewart void
1256a91f103SRandall Stewart sctp_log_strm_del_alt(struct sctp_tcb *stcb, uint32_t tsn, uint16_t sseq, uint16_t stream, int from)
126f8829a4aSRandall Stewart {
12780fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
128f8829a4aSRandall Stewart 
12980fefe0aSRandall Stewart 	sctp_clog.x.strlog.stcb = stcb;
13080fefe0aSRandall Stewart 	sctp_clog.x.strlog.n_tsn = tsn;
13180fefe0aSRandall Stewart 	sctp_clog.x.strlog.n_sseq = sseq;
13280fefe0aSRandall Stewart 	sctp_clog.x.strlog.e_tsn = 0;
13380fefe0aSRandall Stewart 	sctp_clog.x.strlog.e_sseq = 0;
13480fefe0aSRandall Stewart 	sctp_clog.x.strlog.strm = stream;
135b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
13680fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_STRM,
13780fefe0aSRandall Stewart 	    from,
13880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
13980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
14080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
14180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
14280fefe0aSRandall Stewart 
143f8829a4aSRandall Stewart }
144f8829a4aSRandall Stewart 
145f8829a4aSRandall Stewart void
146f8829a4aSRandall Stewart sctp_log_nagle_event(struct sctp_tcb *stcb, int action)
147f8829a4aSRandall Stewart {
14880fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
149f8829a4aSRandall Stewart 
15080fefe0aSRandall Stewart 	sctp_clog.x.nagle.stcb = (void *)stcb;
15180fefe0aSRandall Stewart 	sctp_clog.x.nagle.total_flight = stcb->asoc.total_flight;
15280fefe0aSRandall Stewart 	sctp_clog.x.nagle.total_in_queue = stcb->asoc.total_output_queue_size;
15380fefe0aSRandall Stewart 	sctp_clog.x.nagle.count_in_queue = stcb->asoc.chunks_on_out_queue;
15480fefe0aSRandall Stewart 	sctp_clog.x.nagle.count_in_flight = stcb->asoc.total_flight_count;
155b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
15680fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_NAGLE,
15780fefe0aSRandall Stewart 	    action,
15880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
15980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
16080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
16180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
162f8829a4aSRandall Stewart }
163f8829a4aSRandall Stewart 
164f8829a4aSRandall Stewart 
165f8829a4aSRandall Stewart void
166f8829a4aSRandall Stewart sctp_log_sack(uint32_t old_cumack, uint32_t cumack, uint32_t tsn, uint16_t gaps, uint16_t dups, int from)
167f8829a4aSRandall Stewart {
16880fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
169f8829a4aSRandall Stewart 
17080fefe0aSRandall Stewart 	sctp_clog.x.sack.cumack = cumack;
17180fefe0aSRandall Stewart 	sctp_clog.x.sack.oldcumack = old_cumack;
17280fefe0aSRandall Stewart 	sctp_clog.x.sack.tsn = tsn;
17380fefe0aSRandall Stewart 	sctp_clog.x.sack.numGaps = gaps;
17480fefe0aSRandall Stewart 	sctp_clog.x.sack.numDups = dups;
175b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
17680fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_SACK,
17780fefe0aSRandall Stewart 	    from,
17880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
17980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
18080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
18180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
182f8829a4aSRandall Stewart }
183f8829a4aSRandall Stewart 
184f8829a4aSRandall Stewart void
185f8829a4aSRandall Stewart sctp_log_map(uint32_t map, uint32_t cum, uint32_t high, int from)
186f8829a4aSRandall Stewart {
18780fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
188f8829a4aSRandall Stewart 
18980fefe0aSRandall Stewart 	sctp_clog.x.map.base = map;
19080fefe0aSRandall Stewart 	sctp_clog.x.map.cum = cum;
19180fefe0aSRandall Stewart 	sctp_clog.x.map.high = high;
192b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
19380fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_MAP,
19480fefe0aSRandall Stewart 	    from,
19580fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
19680fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
19780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
19880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
199f8829a4aSRandall Stewart }
200f8829a4aSRandall Stewart 
201f8829a4aSRandall Stewart void
202f8829a4aSRandall Stewart sctp_log_fr(uint32_t biggest_tsn, uint32_t biggest_new_tsn, uint32_t tsn,
203f8829a4aSRandall Stewart     int from)
204f8829a4aSRandall Stewart {
20580fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
206f8829a4aSRandall Stewart 
20780fefe0aSRandall Stewart 	sctp_clog.x.fr.largest_tsn = biggest_tsn;
20880fefe0aSRandall Stewart 	sctp_clog.x.fr.largest_new_tsn = biggest_new_tsn;
20980fefe0aSRandall Stewart 	sctp_clog.x.fr.tsn = tsn;
210b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
21180fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_FR,
21280fefe0aSRandall Stewart 	    from,
21380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
21480fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
21580fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
21680fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
21780fefe0aSRandall Stewart 
218f8829a4aSRandall Stewart }
219f8829a4aSRandall Stewart 
220f8829a4aSRandall Stewart 
221f8829a4aSRandall Stewart void
222f8829a4aSRandall Stewart sctp_log_mb(struct mbuf *m, int from)
223f8829a4aSRandall Stewart {
22480fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
225f8829a4aSRandall Stewart 
22680fefe0aSRandall Stewart 	sctp_clog.x.mb.mp = m;
22780fefe0aSRandall Stewart 	sctp_clog.x.mb.mbuf_flags = (uint8_t) (SCTP_BUF_GET_FLAGS(m));
22880fefe0aSRandall Stewart 	sctp_clog.x.mb.size = (uint16_t) (SCTP_BUF_LEN(m));
22980fefe0aSRandall Stewart 	sctp_clog.x.mb.data = SCTP_BUF_AT(m, 0);
230139bc87fSRandall Stewart 	if (SCTP_BUF_IS_EXTENDED(m)) {
23180fefe0aSRandall Stewart 		sctp_clog.x.mb.ext = SCTP_BUF_EXTEND_BASE(m);
23280fefe0aSRandall Stewart 		sctp_clog.x.mb.refcnt = (uint8_t) (SCTP_BUF_EXTEND_REFCNT(m));
233f8829a4aSRandall Stewart 	} else {
23480fefe0aSRandall Stewart 		sctp_clog.x.mb.ext = 0;
23580fefe0aSRandall Stewart 		sctp_clog.x.mb.refcnt = 0;
236f8829a4aSRandall Stewart 	}
237b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
23880fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_MBUF,
23980fefe0aSRandall Stewart 	    from,
24080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
24180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
24280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
24380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
244f8829a4aSRandall Stewart }
245f8829a4aSRandall Stewart 
246f8829a4aSRandall Stewart 
247f8829a4aSRandall Stewart void
248f8829a4aSRandall Stewart sctp_log_strm_del(struct sctp_queued_to_read *control, struct sctp_queued_to_read *poschk,
249f8829a4aSRandall Stewart     int from)
250f8829a4aSRandall Stewart {
25180fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
252f8829a4aSRandall Stewart 
253f8829a4aSRandall Stewart 	if (control == NULL) {
254ad81507eSRandall Stewart 		SCTP_PRINTF("Gak log of NULL?\n");
255f8829a4aSRandall Stewart 		return;
256f8829a4aSRandall Stewart 	}
25780fefe0aSRandall Stewart 	sctp_clog.x.strlog.stcb = control->stcb;
25880fefe0aSRandall Stewart 	sctp_clog.x.strlog.n_tsn = control->sinfo_tsn;
25980fefe0aSRandall Stewart 	sctp_clog.x.strlog.n_sseq = control->sinfo_ssn;
26080fefe0aSRandall Stewart 	sctp_clog.x.strlog.strm = control->sinfo_stream;
261f8829a4aSRandall Stewart 	if (poschk != NULL) {
26280fefe0aSRandall Stewart 		sctp_clog.x.strlog.e_tsn = poschk->sinfo_tsn;
26380fefe0aSRandall Stewart 		sctp_clog.x.strlog.e_sseq = poschk->sinfo_ssn;
264f8829a4aSRandall Stewart 	} else {
26580fefe0aSRandall Stewart 		sctp_clog.x.strlog.e_tsn = 0;
26680fefe0aSRandall Stewart 		sctp_clog.x.strlog.e_sseq = 0;
267f8829a4aSRandall Stewart 	}
268b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
26980fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_STRM,
27080fefe0aSRandall Stewart 	    from,
27180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
27280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
27380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
27480fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
27580fefe0aSRandall Stewart 
276f8829a4aSRandall Stewart }
277f8829a4aSRandall Stewart 
278f8829a4aSRandall Stewart void
279f8829a4aSRandall Stewart sctp_log_cwnd(struct sctp_tcb *stcb, struct sctp_nets *net, int augment, uint8_t from)
280f8829a4aSRandall Stewart {
28180fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
282f8829a4aSRandall Stewart 
28380fefe0aSRandall Stewart 	sctp_clog.x.cwnd.net = net;
284f8829a4aSRandall Stewart 	if (stcb->asoc.send_queue_cnt > 255)
28580fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_send = 255;
286f8829a4aSRandall Stewart 	else
28780fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt;
288f8829a4aSRandall Stewart 	if (stcb->asoc.stream_queue_cnt > 255)
28980fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_str = 255;
290f8829a4aSRandall Stewart 	else
29180fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt;
292f8829a4aSRandall Stewart 
293f8829a4aSRandall Stewart 	if (net) {
29480fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cwnd_new_value = net->cwnd;
29580fefe0aSRandall Stewart 		sctp_clog.x.cwnd.inflight = net->flight_size;
29680fefe0aSRandall Stewart 		sctp_clog.x.cwnd.pseudo_cumack = net->pseudo_cumack;
29780fefe0aSRandall Stewart 		sctp_clog.x.cwnd.meets_pseudo_cumack = net->new_pseudo_cumack;
29880fefe0aSRandall Stewart 		sctp_clog.x.cwnd.need_new_pseudo_cumack = net->find_pseudo_cumack;
299f8829a4aSRandall Stewart 	}
300f8829a4aSRandall Stewart 	if (SCTP_CWNDLOG_PRESEND == from) {
30180fefe0aSRandall Stewart 		sctp_clog.x.cwnd.meets_pseudo_cumack = stcb->asoc.peers_rwnd;
302f8829a4aSRandall Stewart 	}
30380fefe0aSRandall Stewart 	sctp_clog.x.cwnd.cwnd_augment = augment;
304b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
30580fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_CWND,
30680fefe0aSRandall Stewart 	    from,
30780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
30880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
30980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
31080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
31180fefe0aSRandall Stewart 
312f8829a4aSRandall Stewart }
313f8829a4aSRandall Stewart 
314f8829a4aSRandall Stewart void
315f8829a4aSRandall Stewart sctp_log_lock(struct sctp_inpcb *inp, struct sctp_tcb *stcb, uint8_t from)
316f8829a4aSRandall Stewart {
31780fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
318f8829a4aSRandall Stewart 
31903b0b021SRandall Stewart 	if (inp) {
32080fefe0aSRandall Stewart 		sctp_clog.x.lock.sock = (void *)inp->sctp_socket;
32103b0b021SRandall Stewart 
32203b0b021SRandall Stewart 	} else {
32380fefe0aSRandall Stewart 		sctp_clog.x.lock.sock = (void *)NULL;
32403b0b021SRandall Stewart 	}
32580fefe0aSRandall Stewart 	sctp_clog.x.lock.inp = (void *)inp;
326f8829a4aSRandall Stewart 	if (stcb) {
32780fefe0aSRandall Stewart 		sctp_clog.x.lock.tcb_lock = mtx_owned(&stcb->tcb_mtx);
328f8829a4aSRandall Stewart 	} else {
32980fefe0aSRandall Stewart 		sctp_clog.x.lock.tcb_lock = SCTP_LOCK_UNKNOWN;
330f8829a4aSRandall Stewart 	}
331f8829a4aSRandall Stewart 	if (inp) {
33280fefe0aSRandall Stewart 		sctp_clog.x.lock.inp_lock = mtx_owned(&inp->inp_mtx);
33380fefe0aSRandall Stewart 		sctp_clog.x.lock.create_lock = mtx_owned(&inp->inp_create_mtx);
334f8829a4aSRandall Stewart 	} else {
33580fefe0aSRandall Stewart 		sctp_clog.x.lock.inp_lock = SCTP_LOCK_UNKNOWN;
33680fefe0aSRandall Stewart 		sctp_clog.x.lock.create_lock = SCTP_LOCK_UNKNOWN;
337f8829a4aSRandall Stewart 	}
33880fefe0aSRandall Stewart 	sctp_clog.x.lock.info_lock = mtx_owned(&sctppcbinfo.ipi_ep_mtx);
339f8829a4aSRandall Stewart 	if (inp->sctp_socket) {
34080fefe0aSRandall Stewart 		sctp_clog.x.lock.sock_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx));
34180fefe0aSRandall Stewart 		sctp_clog.x.lock.sockrcvbuf_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx));
34280fefe0aSRandall Stewart 		sctp_clog.x.lock.socksndbuf_lock = mtx_owned(&(inp->sctp_socket->so_snd.sb_mtx));
343f8829a4aSRandall Stewart 	} else {
34480fefe0aSRandall Stewart 		sctp_clog.x.lock.sock_lock = SCTP_LOCK_UNKNOWN;
34580fefe0aSRandall Stewart 		sctp_clog.x.lock.sockrcvbuf_lock = SCTP_LOCK_UNKNOWN;
34680fefe0aSRandall Stewart 		sctp_clog.x.lock.socksndbuf_lock = SCTP_LOCK_UNKNOWN;
347f8829a4aSRandall Stewart 	}
348b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
34980fefe0aSRandall Stewart 	    SCTP_LOG_LOCK_EVENT,
35080fefe0aSRandall Stewart 	    from,
35180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
35280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
35380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
35480fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
35580fefe0aSRandall Stewart 
356f8829a4aSRandall Stewart }
357f8829a4aSRandall Stewart 
358f8829a4aSRandall Stewart void
359f8829a4aSRandall Stewart sctp_log_maxburst(struct sctp_tcb *stcb, struct sctp_nets *net, int error, int burst, uint8_t from)
360f8829a4aSRandall Stewart {
36180fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
362f8829a4aSRandall Stewart 
36380fefe0aSRandall Stewart 	sctp_clog.x.cwnd.net = net;
36480fefe0aSRandall Stewart 	sctp_clog.x.cwnd.cwnd_new_value = error;
36580fefe0aSRandall Stewart 	sctp_clog.x.cwnd.inflight = net->flight_size;
36680fefe0aSRandall Stewart 	sctp_clog.x.cwnd.cwnd_augment = burst;
367f8829a4aSRandall Stewart 	if (stcb->asoc.send_queue_cnt > 255)
36880fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_send = 255;
369f8829a4aSRandall Stewart 	else
37080fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt;
371f8829a4aSRandall Stewart 	if (stcb->asoc.stream_queue_cnt > 255)
37280fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_str = 255;
373f8829a4aSRandall Stewart 	else
37480fefe0aSRandall Stewart 		sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt;
375b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
37680fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_MAXBURST,
37780fefe0aSRandall Stewart 	    from,
37880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
37980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
38080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
38180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
38280fefe0aSRandall Stewart 
383f8829a4aSRandall Stewart }
384f8829a4aSRandall Stewart 
385f8829a4aSRandall Stewart void
386f8829a4aSRandall Stewart sctp_log_rwnd(uint8_t from, uint32_t peers_rwnd, uint32_t snd_size, uint32_t overhead)
387f8829a4aSRandall Stewart {
38880fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
389f8829a4aSRandall Stewart 
39080fefe0aSRandall Stewart 	sctp_clog.x.rwnd.rwnd = peers_rwnd;
39180fefe0aSRandall Stewart 	sctp_clog.x.rwnd.send_size = snd_size;
39280fefe0aSRandall Stewart 	sctp_clog.x.rwnd.overhead = overhead;
39380fefe0aSRandall Stewart 	sctp_clog.x.rwnd.new_rwnd = 0;
394b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
39580fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_RWND,
39680fefe0aSRandall Stewart 	    from,
39780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
39880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
39980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
40080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
401f8829a4aSRandall Stewart }
402f8829a4aSRandall Stewart 
403f8829a4aSRandall Stewart void
404f8829a4aSRandall Stewart sctp_log_rwnd_set(uint8_t from, uint32_t peers_rwnd, uint32_t flight_size, uint32_t overhead, uint32_t a_rwndval)
405f8829a4aSRandall Stewart {
40680fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
407f8829a4aSRandall Stewart 
40880fefe0aSRandall Stewart 	sctp_clog.x.rwnd.rwnd = peers_rwnd;
40980fefe0aSRandall Stewart 	sctp_clog.x.rwnd.send_size = flight_size;
41080fefe0aSRandall Stewart 	sctp_clog.x.rwnd.overhead = overhead;
41180fefe0aSRandall Stewart 	sctp_clog.x.rwnd.new_rwnd = a_rwndval;
412b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
41380fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_RWND,
41480fefe0aSRandall Stewart 	    from,
41580fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
41680fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
41780fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
41880fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
419f8829a4aSRandall Stewart }
420f8829a4aSRandall Stewart 
421f8829a4aSRandall Stewart void
422f8829a4aSRandall Stewart sctp_log_mbcnt(uint8_t from, uint32_t total_oq, uint32_t book, uint32_t total_mbcnt_q, uint32_t mbcnt)
423f8829a4aSRandall Stewart {
42480fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
425f8829a4aSRandall Stewart 
42680fefe0aSRandall Stewart 	sctp_clog.x.mbcnt.total_queue_size = total_oq;
42780fefe0aSRandall Stewart 	sctp_clog.x.mbcnt.size_change = book;
42880fefe0aSRandall Stewart 	sctp_clog.x.mbcnt.total_queue_mb_size = total_mbcnt_q;
42980fefe0aSRandall Stewart 	sctp_clog.x.mbcnt.mbcnt_change = mbcnt;
430b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
43180fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_MBCNT,
43280fefe0aSRandall Stewart 	    from,
43380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
43480fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
43580fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
43680fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
43780fefe0aSRandall Stewart 
438f8829a4aSRandall Stewart }
439f8829a4aSRandall Stewart 
440f8829a4aSRandall Stewart void
441f8829a4aSRandall Stewart sctp_misc_ints(uint8_t from, uint32_t a, uint32_t b, uint32_t c, uint32_t d)
442f8829a4aSRandall Stewart {
443b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
44480fefe0aSRandall Stewart 	    SCTP_LOG_MISC_EVENT,
44580fefe0aSRandall Stewart 	    from,
44680fefe0aSRandall Stewart 	    a, b, c, d);
447f8829a4aSRandall Stewart }
448f8829a4aSRandall Stewart 
449f8829a4aSRandall Stewart void
450f8829a4aSRandall Stewart sctp_wakeup_log(struct sctp_tcb *stcb, uint32_t cumtsn, uint32_t wake_cnt, int from)
451f8829a4aSRandall Stewart {
45280fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
453f8829a4aSRandall Stewart 
45480fefe0aSRandall Stewart 	sctp_clog.x.wake.stcb = (void *)stcb;
45580fefe0aSRandall Stewart 	sctp_clog.x.wake.wake_cnt = wake_cnt;
45680fefe0aSRandall Stewart 	sctp_clog.x.wake.flight = stcb->asoc.total_flight_count;
45780fefe0aSRandall Stewart 	sctp_clog.x.wake.send_q = stcb->asoc.send_queue_cnt;
45880fefe0aSRandall Stewart 	sctp_clog.x.wake.sent_q = stcb->asoc.sent_queue_cnt;
459f8829a4aSRandall Stewart 
460f8829a4aSRandall Stewart 	if (stcb->asoc.stream_queue_cnt < 0xff)
46180fefe0aSRandall Stewart 		sctp_clog.x.wake.stream_qcnt = (uint8_t) stcb->asoc.stream_queue_cnt;
462f8829a4aSRandall Stewart 	else
46380fefe0aSRandall Stewart 		sctp_clog.x.wake.stream_qcnt = 0xff;
464f8829a4aSRandall Stewart 
465f8829a4aSRandall Stewart 	if (stcb->asoc.chunks_on_out_queue < 0xff)
46680fefe0aSRandall Stewart 		sctp_clog.x.wake.chunks_on_oque = (uint8_t) stcb->asoc.chunks_on_out_queue;
467f8829a4aSRandall Stewart 	else
46880fefe0aSRandall Stewart 		sctp_clog.x.wake.chunks_on_oque = 0xff;
469f8829a4aSRandall Stewart 
47080fefe0aSRandall Stewart 	sctp_clog.x.wake.sctpflags = 0;
471f8829a4aSRandall Stewart 	/* set in the defered mode stuff */
472f8829a4aSRandall Stewart 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE)
47380fefe0aSRandall Stewart 		sctp_clog.x.wake.sctpflags |= 1;
474f8829a4aSRandall Stewart 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT)
47580fefe0aSRandall Stewart 		sctp_clog.x.wake.sctpflags |= 2;
476f8829a4aSRandall Stewart 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT)
47780fefe0aSRandall Stewart 		sctp_clog.x.wake.sctpflags |= 4;
478f8829a4aSRandall Stewart 	/* what about the sb */
479f8829a4aSRandall Stewart 	if (stcb->sctp_socket) {
480f8829a4aSRandall Stewart 		struct socket *so = stcb->sctp_socket;
481f8829a4aSRandall Stewart 
48280fefe0aSRandall Stewart 		sctp_clog.x.wake.sbflags = (uint8_t) ((so->so_snd.sb_flags & 0x00ff));
483f8829a4aSRandall Stewart 	} else {
48480fefe0aSRandall Stewart 		sctp_clog.x.wake.sbflags = 0xff;
485f8829a4aSRandall Stewart 	}
486b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
48780fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_WAKE,
48880fefe0aSRandall Stewart 	    from,
48980fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
49080fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
49180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
49280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
49380fefe0aSRandall Stewart 
494f8829a4aSRandall Stewart }
495f8829a4aSRandall Stewart 
496f8829a4aSRandall Stewart void
497f8829a4aSRandall Stewart sctp_log_block(uint8_t from, struct socket *so, struct sctp_association *asoc, int sendlen)
498f8829a4aSRandall Stewart {
49980fefe0aSRandall Stewart 	struct sctp_cwnd_log sctp_clog;
500f8829a4aSRandall Stewart 
50180fefe0aSRandall Stewart 	sctp_clog.x.blk.onsb = asoc->total_output_queue_size;
50280fefe0aSRandall Stewart 	sctp_clog.x.blk.send_sent_qcnt = (uint16_t) (asoc->send_queue_cnt + asoc->sent_queue_cnt);
50380fefe0aSRandall Stewart 	sctp_clog.x.blk.peer_rwnd = asoc->peers_rwnd;
50480fefe0aSRandall Stewart 	sctp_clog.x.blk.stream_qcnt = (uint16_t) asoc->stream_queue_cnt;
50580fefe0aSRandall Stewart 	sctp_clog.x.blk.chunks_on_oque = (uint16_t) asoc->chunks_on_out_queue;
50680fefe0aSRandall Stewart 	sctp_clog.x.blk.flight_size = (uint16_t) (asoc->total_flight / 1024);
50780fefe0aSRandall Stewart 	sctp_clog.x.blk.sndlen = sendlen;
508b9e7085aSRandall Stewart 	CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",
50980fefe0aSRandall Stewart 	    SCTP_LOG_EVENT_BLOCK,
51080fefe0aSRandall Stewart 	    from,
51180fefe0aSRandall Stewart 	    sctp_clog.x.misc.log1,
51280fefe0aSRandall Stewart 	    sctp_clog.x.misc.log2,
51380fefe0aSRandall Stewart 	    sctp_clog.x.misc.log3,
51480fefe0aSRandall Stewart 	    sctp_clog.x.misc.log4);
51580fefe0aSRandall Stewart 
516f8829a4aSRandall Stewart }
517f8829a4aSRandall Stewart 
518f8829a4aSRandall Stewart int
51942551e99SRandall Stewart sctp_fill_stat_log(void *optval, size_t *optsize)
520f8829a4aSRandall Stewart {
52180fefe0aSRandall Stewart 	/* May need to fix this if ktrdump does not work */
522f8829a4aSRandall Stewart 	return (0);
523f8829a4aSRandall Stewart }
524f8829a4aSRandall Stewart 
525f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
526f8829a4aSRandall Stewart uint8_t sctp_audit_data[SCTP_AUDIT_SIZE][2];
527f8829a4aSRandall Stewart static int sctp_audit_indx = 0;
528f8829a4aSRandall Stewart 
529f8829a4aSRandall Stewart static
530f8829a4aSRandall Stewart void
531f8829a4aSRandall Stewart sctp_print_audit_report(void)
532f8829a4aSRandall Stewart {
533f8829a4aSRandall Stewart 	int i;
534f8829a4aSRandall Stewart 	int cnt;
535f8829a4aSRandall Stewart 
536f8829a4aSRandall Stewart 	cnt = 0;
537f8829a4aSRandall Stewart 	for (i = sctp_audit_indx; i < SCTP_AUDIT_SIZE; i++) {
538f8829a4aSRandall Stewart 		if ((sctp_audit_data[i][0] == 0xe0) &&
539f8829a4aSRandall Stewart 		    (sctp_audit_data[i][1] == 0x01)) {
540f8829a4aSRandall Stewart 			cnt = 0;
541ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
542f8829a4aSRandall Stewart 		} else if (sctp_audit_data[i][0] == 0xf0) {
543f8829a4aSRandall Stewart 			cnt = 0;
544ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
545f8829a4aSRandall Stewart 		} else if ((sctp_audit_data[i][0] == 0xc0) &&
546f8829a4aSRandall Stewart 		    (sctp_audit_data[i][1] == 0x01)) {
547ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
548f8829a4aSRandall Stewart 			cnt = 0;
549f8829a4aSRandall Stewart 		}
550ad81507eSRandall Stewart 		SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0],
551f8829a4aSRandall Stewart 		    (uint32_t) sctp_audit_data[i][1]);
552f8829a4aSRandall Stewart 		cnt++;
553f8829a4aSRandall Stewart 		if ((cnt % 14) == 0)
554ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
555f8829a4aSRandall Stewart 	}
556f8829a4aSRandall Stewart 	for (i = 0; i < sctp_audit_indx; i++) {
557f8829a4aSRandall Stewart 		if ((sctp_audit_data[i][0] == 0xe0) &&
558f8829a4aSRandall Stewart 		    (sctp_audit_data[i][1] == 0x01)) {
559f8829a4aSRandall Stewart 			cnt = 0;
560ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
561f8829a4aSRandall Stewart 		} else if (sctp_audit_data[i][0] == 0xf0) {
562f8829a4aSRandall Stewart 			cnt = 0;
563ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
564f8829a4aSRandall Stewart 		} else if ((sctp_audit_data[i][0] == 0xc0) &&
565f8829a4aSRandall Stewart 		    (sctp_audit_data[i][1] == 0x01)) {
566ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
567f8829a4aSRandall Stewart 			cnt = 0;
568f8829a4aSRandall Stewart 		}
569ad81507eSRandall Stewart 		SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0],
570f8829a4aSRandall Stewart 		    (uint32_t) sctp_audit_data[i][1]);
571f8829a4aSRandall Stewart 		cnt++;
572f8829a4aSRandall Stewart 		if ((cnt % 14) == 0)
573ad81507eSRandall Stewart 			SCTP_PRINTF("\n");
574f8829a4aSRandall Stewart 	}
575ad81507eSRandall Stewart 	SCTP_PRINTF("\n");
576f8829a4aSRandall Stewart }
577f8829a4aSRandall Stewart 
578f8829a4aSRandall Stewart void
579f8829a4aSRandall Stewart sctp_auditing(int from, struct sctp_inpcb *inp, struct sctp_tcb *stcb,
580f8829a4aSRandall Stewart     struct sctp_nets *net)
581f8829a4aSRandall Stewart {
582f8829a4aSRandall Stewart 	int resend_cnt, tot_out, rep, tot_book_cnt;
583f8829a4aSRandall Stewart 	struct sctp_nets *lnet;
584f8829a4aSRandall Stewart 	struct sctp_tmit_chunk *chk;
585f8829a4aSRandall Stewart 
586f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][0] = 0xAA;
587f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][1] = 0x000000ff & from;
588f8829a4aSRandall Stewart 	sctp_audit_indx++;
589f8829a4aSRandall Stewart 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
590f8829a4aSRandall Stewart 		sctp_audit_indx = 0;
591f8829a4aSRandall Stewart 	}
592f8829a4aSRandall Stewart 	if (inp == NULL) {
593f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
594f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0x01;
595f8829a4aSRandall Stewart 		sctp_audit_indx++;
596f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
597f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
598f8829a4aSRandall Stewart 		}
599f8829a4aSRandall Stewart 		return;
600f8829a4aSRandall Stewart 	}
601f8829a4aSRandall Stewart 	if (stcb == NULL) {
602f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
603f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0x02;
604f8829a4aSRandall Stewart 		sctp_audit_indx++;
605f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
606f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
607f8829a4aSRandall Stewart 		}
608f8829a4aSRandall Stewart 		return;
609f8829a4aSRandall Stewart 	}
610f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][0] = 0xA1;
611f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][1] =
612f8829a4aSRandall Stewart 	    (0x000000ff & stcb->asoc.sent_queue_retran_cnt);
613f8829a4aSRandall Stewart 	sctp_audit_indx++;
614f8829a4aSRandall Stewart 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
615f8829a4aSRandall Stewart 		sctp_audit_indx = 0;
616f8829a4aSRandall Stewart 	}
617f8829a4aSRandall Stewart 	rep = 0;
618f8829a4aSRandall Stewart 	tot_book_cnt = 0;
619f8829a4aSRandall Stewart 	resend_cnt = tot_out = 0;
620f8829a4aSRandall Stewart 	TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
621f8829a4aSRandall Stewart 		if (chk->sent == SCTP_DATAGRAM_RESEND) {
622f8829a4aSRandall Stewart 			resend_cnt++;
623f8829a4aSRandall Stewart 		} else if (chk->sent < SCTP_DATAGRAM_RESEND) {
624f8829a4aSRandall Stewart 			tot_out += chk->book_size;
625f8829a4aSRandall Stewart 			tot_book_cnt++;
626f8829a4aSRandall Stewart 		}
627f8829a4aSRandall Stewart 	}
628f8829a4aSRandall Stewart 	if (resend_cnt != stcb->asoc.sent_queue_retran_cnt) {
629f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
630f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0xA1;
631f8829a4aSRandall Stewart 		sctp_audit_indx++;
632f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
633f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
634f8829a4aSRandall Stewart 		}
635ad81507eSRandall Stewart 		SCTP_PRINTF("resend_cnt:%d asoc-tot:%d\n",
636f8829a4aSRandall Stewart 		    resend_cnt, stcb->asoc.sent_queue_retran_cnt);
637f8829a4aSRandall Stewart 		rep = 1;
638f8829a4aSRandall Stewart 		stcb->asoc.sent_queue_retran_cnt = resend_cnt;
639f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xA2;
640f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] =
641f8829a4aSRandall Stewart 		    (0x000000ff & stcb->asoc.sent_queue_retran_cnt);
642f8829a4aSRandall Stewart 		sctp_audit_indx++;
643f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
644f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
645f8829a4aSRandall Stewart 		}
646f8829a4aSRandall Stewart 	}
647f8829a4aSRandall Stewart 	if (tot_out != stcb->asoc.total_flight) {
648f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
649f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0xA2;
650f8829a4aSRandall Stewart 		sctp_audit_indx++;
651f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
652f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
653f8829a4aSRandall Stewart 		}
654f8829a4aSRandall Stewart 		rep = 1;
655ad81507eSRandall Stewart 		SCTP_PRINTF("tot_flt:%d asoc_tot:%d\n", tot_out,
656f8829a4aSRandall Stewart 		    (int)stcb->asoc.total_flight);
657f8829a4aSRandall Stewart 		stcb->asoc.total_flight = tot_out;
658f8829a4aSRandall Stewart 	}
659f8829a4aSRandall Stewart 	if (tot_book_cnt != stcb->asoc.total_flight_count) {
660f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
661f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0xA5;
662f8829a4aSRandall Stewart 		sctp_audit_indx++;
663f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
664f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
665f8829a4aSRandall Stewart 		}
666f8829a4aSRandall Stewart 		rep = 1;
667ad81507eSRandall Stewart 		SCTP_PRINTF("tot_flt_book:%d\n", tot_book);
668f8829a4aSRandall Stewart 
669f8829a4aSRandall Stewart 		stcb->asoc.total_flight_count = tot_book_cnt;
670f8829a4aSRandall Stewart 	}
671f8829a4aSRandall Stewart 	tot_out = 0;
672f8829a4aSRandall Stewart 	TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
673f8829a4aSRandall Stewart 		tot_out += lnet->flight_size;
674f8829a4aSRandall Stewart 	}
675f8829a4aSRandall Stewart 	if (tot_out != stcb->asoc.total_flight) {
676f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;
677f8829a4aSRandall Stewart 		sctp_audit_data[sctp_audit_indx][1] = 0xA3;
678f8829a4aSRandall Stewart 		sctp_audit_indx++;
679f8829a4aSRandall Stewart 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
680f8829a4aSRandall Stewart 			sctp_audit_indx = 0;
681f8829a4aSRandall Stewart 		}
682f8829a4aSRandall Stewart 		rep = 1;
683ad81507eSRandall Stewart 		SCTP_PRINTF("real flight:%d net total was %d\n",
684f8829a4aSRandall Stewart 		    stcb->asoc.total_flight, tot_out);
685f8829a4aSRandall Stewart 		/* now corrective action */
686f8829a4aSRandall Stewart 		TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
687f8829a4aSRandall Stewart 
688f8829a4aSRandall Stewart 			tot_out = 0;
689f8829a4aSRandall Stewart 			TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
690f8829a4aSRandall Stewart 				if ((chk->whoTo == lnet) &&
691f8829a4aSRandall Stewart 				    (chk->sent < SCTP_DATAGRAM_RESEND)) {
692f8829a4aSRandall Stewart 					tot_out += chk->book_size;
693f8829a4aSRandall Stewart 				}
694f8829a4aSRandall Stewart 			}
695f8829a4aSRandall Stewart 			if (lnet->flight_size != tot_out) {
696ad81507eSRandall Stewart 				SCTP_PRINTF("net:%x flight was %d corrected to %d\n",
697ad81507eSRandall Stewart 				    (uint32_t) lnet, lnet->flight_size,
698ad81507eSRandall Stewart 				    tot_out);
699f8829a4aSRandall Stewart 				lnet->flight_size = tot_out;
700f8829a4aSRandall Stewart 			}
701f8829a4aSRandall Stewart 		}
702f8829a4aSRandall Stewart 	}
703f8829a4aSRandall Stewart 	if (rep) {
704f8829a4aSRandall Stewart 		sctp_print_audit_report();
705f8829a4aSRandall Stewart 	}
706f8829a4aSRandall Stewart }
707f8829a4aSRandall Stewart 
708f8829a4aSRandall Stewart void
709f8829a4aSRandall Stewart sctp_audit_log(uint8_t ev, uint8_t fd)
710f8829a4aSRandall Stewart {
711f8829a4aSRandall Stewart 
712f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][0] = ev;
713f8829a4aSRandall Stewart 	sctp_audit_data[sctp_audit_indx][1] = fd;
714f8829a4aSRandall Stewart 	sctp_audit_indx++;
715f8829a4aSRandall Stewart 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {
716f8829a4aSRandall Stewart 		sctp_audit_indx = 0;
717f8829a4aSRandall Stewart 	}
718f8829a4aSRandall Stewart }
719f8829a4aSRandall Stewart 
720f8829a4aSRandall Stewart #endif
721f8829a4aSRandall Stewart 
722f8829a4aSRandall Stewart /*
723f8829a4aSRandall Stewart  * a list of sizes based on typical mtu's, used only if next hop size not
724f8829a4aSRandall Stewart  * returned.
725f8829a4aSRandall Stewart  */
726f8829a4aSRandall Stewart static int sctp_mtu_sizes[] = {
727f8829a4aSRandall Stewart 	68,
728f8829a4aSRandall Stewart 	296,
729f8829a4aSRandall Stewart 	508,
730f8829a4aSRandall Stewart 	512,
731f8829a4aSRandall Stewart 	544,
732f8829a4aSRandall Stewart 	576,
733f8829a4aSRandall Stewart 	1006,
734f8829a4aSRandall Stewart 	1492,
735f8829a4aSRandall Stewart 	1500,
736f8829a4aSRandall Stewart 	1536,
737f8829a4aSRandall Stewart 	2002,
738f8829a4aSRandall Stewart 	2048,
739f8829a4aSRandall Stewart 	4352,
740f8829a4aSRandall Stewart 	4464,
741f8829a4aSRandall Stewart 	8166,
742f8829a4aSRandall Stewart 	17914,
743f8829a4aSRandall Stewart 	32000,
744f8829a4aSRandall Stewart 	65535
745f8829a4aSRandall Stewart };
746f8829a4aSRandall Stewart 
747f8829a4aSRandall Stewart void
748f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(struct sctp_tcb *stcb)
749f8829a4aSRandall Stewart {
750f8829a4aSRandall Stewart 	struct sctp_association *asoc;
751f8829a4aSRandall Stewart 	struct sctp_nets *net;
752f8829a4aSRandall Stewart 
753f8829a4aSRandall Stewart 	asoc = &stcb->asoc;
754f8829a4aSRandall Stewart 
7556e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->hb_timer.timer);
7566e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->dack_timer.timer);
7576e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->strreset_timer.timer);
7586e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->asconf_timer.timer);
7596e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->autoclose_timer.timer);
7606e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&asoc->delayed_event_timer.timer);
761f8829a4aSRandall Stewart 	TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
7626e55db54SRandall Stewart 		(void)SCTP_OS_TIMER_STOP(&net->fr_timer.timer);
7636e55db54SRandall Stewart 		(void)SCTP_OS_TIMER_STOP(&net->pmtu_timer.timer);
764f8829a4aSRandall Stewart 	}
765f8829a4aSRandall Stewart }
766f8829a4aSRandall Stewart 
767f8829a4aSRandall Stewart int
768f8829a4aSRandall Stewart find_next_best_mtu(int totsz)
769f8829a4aSRandall Stewart {
770f8829a4aSRandall Stewart 	int i, perfer;
771f8829a4aSRandall Stewart 
772f8829a4aSRandall Stewart 	/*
773f8829a4aSRandall Stewart 	 * if we are in here we must find the next best fit based on the
774f8829a4aSRandall Stewart 	 * size of the dg that failed to be sent.
775f8829a4aSRandall Stewart 	 */
776f8829a4aSRandall Stewart 	perfer = 0;
777f8829a4aSRandall Stewart 	for (i = 0; i < NUMBER_OF_MTU_SIZES; i++) {
778f8829a4aSRandall Stewart 		if (totsz < sctp_mtu_sizes[i]) {
779f8829a4aSRandall Stewart 			perfer = i - 1;
780f8829a4aSRandall Stewart 			if (perfer < 0)
781f8829a4aSRandall Stewart 				perfer = 0;
782f8829a4aSRandall Stewart 			break;
783f8829a4aSRandall Stewart 		}
784f8829a4aSRandall Stewart 	}
785f8829a4aSRandall Stewart 	return (sctp_mtu_sizes[perfer]);
786f8829a4aSRandall Stewart }
787f8829a4aSRandall Stewart 
788f8829a4aSRandall Stewart void
789f8829a4aSRandall Stewart sctp_fill_random_store(struct sctp_pcb *m)
790f8829a4aSRandall Stewart {
791f8829a4aSRandall Stewart 	/*
792f8829a4aSRandall Stewart 	 * Here we use the MD5/SHA-1 to hash with our good randomNumbers and
793f8829a4aSRandall Stewart 	 * our counter. The result becomes our good random numbers and we
794f8829a4aSRandall Stewart 	 * then setup to give these out. Note that we do no locking to
795f8829a4aSRandall Stewart 	 * protect this. This is ok, since if competing folks call this we
79617205eccSRandall Stewart 	 * will get more gobbled gook in the random store which is what we
797f8829a4aSRandall Stewart 	 * want. There is a danger that two guys will use the same random
798f8829a4aSRandall Stewart 	 * numbers, but thats ok too since that is random as well :->
799f8829a4aSRandall Stewart 	 */
800f8829a4aSRandall Stewart 	m->store_at = 0;
801ad81507eSRandall Stewart 	(void)sctp_hmac(SCTP_HMAC, (uint8_t *) m->random_numbers,
802f8829a4aSRandall Stewart 	    sizeof(m->random_numbers), (uint8_t *) & m->random_counter,
803f8829a4aSRandall Stewart 	    sizeof(m->random_counter), (uint8_t *) m->random_store);
804f8829a4aSRandall Stewart 	m->random_counter++;
805f8829a4aSRandall Stewart }
806f8829a4aSRandall Stewart 
807f8829a4aSRandall Stewart uint32_t
808f8829a4aSRandall Stewart sctp_select_initial_TSN(struct sctp_pcb *m)
809f8829a4aSRandall Stewart {
810f8829a4aSRandall Stewart 	/*
811f8829a4aSRandall Stewart 	 * A true implementation should use random selection process to get
812f8829a4aSRandall Stewart 	 * the initial stream sequence number, using RFC1750 as a good
813f8829a4aSRandall Stewart 	 * guideline
814f8829a4aSRandall Stewart 	 */
815139bc87fSRandall Stewart 	uint32_t x, *xp;
816f8829a4aSRandall Stewart 	uint8_t *p;
817f8829a4aSRandall Stewart 
818f8829a4aSRandall Stewart 	if (m->initial_sequence_debug != 0) {
819f8829a4aSRandall Stewart 		uint32_t ret;
820f8829a4aSRandall Stewart 
821f8829a4aSRandall Stewart 		ret = m->initial_sequence_debug;
822f8829a4aSRandall Stewart 		m->initial_sequence_debug++;
823f8829a4aSRandall Stewart 		return (ret);
824f8829a4aSRandall Stewart 	}
825f8829a4aSRandall Stewart 	if ((m->store_at + sizeof(u_long)) > SCTP_SIGNATURE_SIZE) {
826f8829a4aSRandall Stewart 		/* Refill the random store */
827f8829a4aSRandall Stewart 		sctp_fill_random_store(m);
828f8829a4aSRandall Stewart 	}
829f8829a4aSRandall Stewart 	p = &m->random_store[(int)m->store_at];
830139bc87fSRandall Stewart 	xp = (uint32_t *) p;
831f8829a4aSRandall Stewart 	x = *xp;
832139bc87fSRandall Stewart 	m->store_at += sizeof(uint32_t);
833f8829a4aSRandall Stewart 	return (x);
834f8829a4aSRandall Stewart }
835f8829a4aSRandall Stewart 
836f8829a4aSRandall Stewart uint32_t
837f8829a4aSRandall Stewart sctp_select_a_tag(struct sctp_inpcb *m)
838f8829a4aSRandall Stewart {
839f8829a4aSRandall Stewart 	u_long x, not_done;
840f8829a4aSRandall Stewart 	struct timeval now;
841f8829a4aSRandall Stewart 
8426e55db54SRandall Stewart 	(void)SCTP_GETTIME_TIMEVAL(&now);
843f8829a4aSRandall Stewart 	not_done = 1;
844f8829a4aSRandall Stewart 	while (not_done) {
845f8829a4aSRandall Stewart 		x = sctp_select_initial_TSN(&m->sctp_ep);
846f8829a4aSRandall Stewart 		if (x == 0) {
847f8829a4aSRandall Stewart 			/* we never use 0 */
848f8829a4aSRandall Stewart 			continue;
849f8829a4aSRandall Stewart 		}
850f8829a4aSRandall Stewart 		if (sctp_is_vtag_good(m, x, &now)) {
851f8829a4aSRandall Stewart 			not_done = 0;
852f8829a4aSRandall Stewart 		}
853f8829a4aSRandall Stewart 	}
854f8829a4aSRandall Stewart 	return (x);
855f8829a4aSRandall Stewart }
856f8829a4aSRandall Stewart 
857f8829a4aSRandall Stewart 
858f8829a4aSRandall Stewart int
8590696e120SRandall Stewart sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,
86042551e99SRandall Stewart     int for_a_init, uint32_t override_tag, uint32_t vrf_id)
861f8829a4aSRandall Stewart {
8620696e120SRandall Stewart 	struct sctp_association *asoc;
8630696e120SRandall Stewart 
864f8829a4aSRandall Stewart 	/*
865f8829a4aSRandall Stewart 	 * Anything set to zero is taken care of by the allocation routine's
866f8829a4aSRandall Stewart 	 * bzero
867f8829a4aSRandall Stewart 	 */
868f8829a4aSRandall Stewart 
869f8829a4aSRandall Stewart 	/*
870f8829a4aSRandall Stewart 	 * Up front select what scoping to apply on addresses I tell my peer
871f8829a4aSRandall Stewart 	 * Not sure what to do with these right now, we will need to come up
872f8829a4aSRandall Stewart 	 * with a way to set them. We may need to pass them through from the
873f8829a4aSRandall Stewart 	 * caller in the sctp_aloc_assoc() function.
874f8829a4aSRandall Stewart 	 */
875f8829a4aSRandall Stewart 	int i;
876f8829a4aSRandall Stewart 
8770696e120SRandall Stewart 	asoc = &stcb->asoc;
878f8829a4aSRandall Stewart 	/* init all variables to a known value. */
879f8829a4aSRandall Stewart 	asoc->state = SCTP_STATE_INUSE;
880f8829a4aSRandall Stewart 	asoc->max_burst = m->sctp_ep.max_burst;
881f8829a4aSRandall Stewart 	asoc->heart_beat_delay = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT]);
882f8829a4aSRandall Stewart 	asoc->cookie_life = m->sctp_ep.def_cookie_life;
883f8829a4aSRandall Stewart 	asoc->sctp_cmt_on_off = (uint8_t) sctp_cmt_on_off;
884d61a0ae0SRandall Stewart 	asoc->sctp_frag_point = m->sctp_frag_point;
88542551e99SRandall Stewart #ifdef INET
886f8829a4aSRandall Stewart 	asoc->default_tos = m->ip_inp.inp.inp_ip_tos;
887f8829a4aSRandall Stewart #else
888f8829a4aSRandall Stewart 	asoc->default_tos = 0;
889f8829a4aSRandall Stewart #endif
890f8829a4aSRandall Stewart 
89142551e99SRandall Stewart #ifdef INET6
892f8829a4aSRandall Stewart 	asoc->default_flowlabel = ((struct in6pcb *)m)->in6p_flowinfo;
893f8829a4aSRandall Stewart #else
894f8829a4aSRandall Stewart 	asoc->default_flowlabel = 0;
895f8829a4aSRandall Stewart #endif
896f8829a4aSRandall Stewart 	if (override_tag) {
897f8829a4aSRandall Stewart 		struct timeval now;
898f8829a4aSRandall Stewart 
8996e55db54SRandall Stewart 		(void)SCTP_GETTIME_TIMEVAL(&now);
900f8829a4aSRandall Stewart 		if (sctp_is_vtag_good(m, override_tag, &now)) {
901f8829a4aSRandall Stewart 			asoc->my_vtag = override_tag;
902f8829a4aSRandall Stewart 		} else {
903f8829a4aSRandall Stewart 			return (ENOMEM);
904f8829a4aSRandall Stewart 		}
905f8829a4aSRandall Stewart 
906f8829a4aSRandall Stewart 	} else {
907f8829a4aSRandall Stewart 		asoc->my_vtag = sctp_select_a_tag(m);
908f8829a4aSRandall Stewart 	}
909de0e935bSRandall Stewart 	/* Get the nonce tags */
910de0e935bSRandall Stewart 	asoc->my_vtag_nonce = sctp_select_a_tag(m);
911de0e935bSRandall Stewart 	asoc->peer_vtag_nonce = sctp_select_a_tag(m);
91242551e99SRandall Stewart 	asoc->vrf_id = vrf_id;
913de0e935bSRandall Stewart 
914f8829a4aSRandall Stewart 	if (sctp_is_feature_on(m, SCTP_PCB_FLAGS_DONOT_HEARTBEAT))
915f8829a4aSRandall Stewart 		asoc->hb_is_disabled = 1;
916f8829a4aSRandall Stewart 	else
917f8829a4aSRandall Stewart 		asoc->hb_is_disabled = 0;
918f8829a4aSRandall Stewart 
919f8829a4aSRandall Stewart 	asoc->refcnt = 0;
920f8829a4aSRandall Stewart 	asoc->assoc_up_sent = 0;
921f8829a4aSRandall Stewart 	asoc->assoc_id = asoc->my_vtag;
922f8829a4aSRandall Stewart 	asoc->asconf_seq_out = asoc->str_reset_seq_out = asoc->init_seq_number = asoc->sending_seq =
923f8829a4aSRandall Stewart 	    sctp_select_initial_TSN(&m->sctp_ep);
924f8829a4aSRandall Stewart 	/* we are optimisitic here */
925f8829a4aSRandall Stewart 	asoc->peer_supports_pktdrop = 1;
926f8829a4aSRandall Stewart 
927f8829a4aSRandall Stewart 	asoc->sent_queue_retran_cnt = 0;
928f8829a4aSRandall Stewart 
929f8829a4aSRandall Stewart 	/* for CMT */
930f8829a4aSRandall Stewart 	asoc->last_net_data_came_from = NULL;
931f8829a4aSRandall Stewart 
932f8829a4aSRandall Stewart 	/* This will need to be adjusted */
933f8829a4aSRandall Stewart 	asoc->last_cwr_tsn = asoc->init_seq_number - 1;
934f8829a4aSRandall Stewart 	asoc->last_acked_seq = asoc->init_seq_number - 1;
935f8829a4aSRandall Stewart 	asoc->advanced_peer_ack_point = asoc->last_acked_seq;
936f8829a4aSRandall Stewart 	asoc->asconf_seq_in = asoc->last_acked_seq;
937f8829a4aSRandall Stewart 
938f8829a4aSRandall Stewart 	/* here we are different, we hold the next one we expect */
939f8829a4aSRandall Stewart 	asoc->str_reset_seq_in = asoc->last_acked_seq + 1;
940f8829a4aSRandall Stewart 
941f8829a4aSRandall Stewart 	asoc->initial_init_rto_max = m->sctp_ep.initial_init_rto_max;
942f8829a4aSRandall Stewart 	asoc->initial_rto = m->sctp_ep.initial_rto;
943f8829a4aSRandall Stewart 
944f8829a4aSRandall Stewart 	asoc->max_init_times = m->sctp_ep.max_init_times;
945f8829a4aSRandall Stewart 	asoc->max_send_times = m->sctp_ep.max_send_times;
946f8829a4aSRandall Stewart 	asoc->def_net_failure = m->sctp_ep.def_net_failure;
947f8829a4aSRandall Stewart 	asoc->free_chunk_cnt = 0;
948f8829a4aSRandall Stewart 
949f8829a4aSRandall Stewart 	asoc->iam_blocking = 0;
950f8829a4aSRandall Stewart 	/* ECN Nonce initialization */
951f8829a4aSRandall Stewart 	asoc->context = m->sctp_context;
952f8829a4aSRandall Stewart 	asoc->def_send = m->def_send;
953f8829a4aSRandall Stewart 	asoc->ecn_nonce_allowed = 0;
954f8829a4aSRandall Stewart 	asoc->receiver_nonce_sum = 1;
955f8829a4aSRandall Stewart 	asoc->nonce_sum_expect_base = 1;
956f8829a4aSRandall Stewart 	asoc->nonce_sum_check = 1;
957f8829a4aSRandall Stewart 	asoc->nonce_resync_tsn = 0;
958f8829a4aSRandall Stewart 	asoc->nonce_wait_for_ecne = 0;
959f8829a4aSRandall Stewart 	asoc->nonce_wait_tsn = 0;
960f8829a4aSRandall Stewart 	asoc->delayed_ack = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);
96142551e99SRandall Stewart 	asoc->sack_freq = m->sctp_ep.sctp_sack_freq;
962f8829a4aSRandall Stewart 	asoc->pr_sctp_cnt = 0;
963f8829a4aSRandall Stewart 	asoc->total_output_queue_size = 0;
964f8829a4aSRandall Stewart 
965f8829a4aSRandall Stewart 	if (m->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
966f8829a4aSRandall Stewart 		struct in6pcb *inp6;
967f8829a4aSRandall Stewart 
968f8829a4aSRandall Stewart 		/* Its a V6 socket */
969f8829a4aSRandall Stewart 		inp6 = (struct in6pcb *)m;
970f8829a4aSRandall Stewart 		asoc->ipv6_addr_legal = 1;
971f8829a4aSRandall Stewart 		/* Now look at the binding flag to see if V4 will be legal */
97244b7479bSRandall Stewart 		if (SCTP_IPV6_V6ONLY(inp6) == 0) {
973f8829a4aSRandall Stewart 			asoc->ipv4_addr_legal = 1;
974f8829a4aSRandall Stewart 		} else {
975f8829a4aSRandall Stewart 			/* V4 addresses are NOT legal on the association */
976f8829a4aSRandall Stewart 			asoc->ipv4_addr_legal = 0;
977f8829a4aSRandall Stewart 		}
978f8829a4aSRandall Stewart 	} else {
979f8829a4aSRandall Stewart 		/* Its a V4 socket, no - V6 */
980f8829a4aSRandall Stewart 		asoc->ipv4_addr_legal = 1;
981f8829a4aSRandall Stewart 		asoc->ipv6_addr_legal = 0;
982f8829a4aSRandall Stewart 	}
983f8829a4aSRandall Stewart 
98462c1ff9cSRandall Stewart 	asoc->my_rwnd = max(SCTP_SB_LIMIT_RCV(m->sctp_socket), SCTP_MINIMAL_RWND);
98562c1ff9cSRandall Stewart 	asoc->peers_rwnd = SCTP_SB_LIMIT_RCV(m->sctp_socket);
986f8829a4aSRandall Stewart 
987f8829a4aSRandall Stewart 	asoc->smallest_mtu = m->sctp_frag_point;
98817205eccSRandall Stewart #ifdef SCTP_PRINT_FOR_B_AND_M
989ad81507eSRandall Stewart 	SCTP_PRINTF("smallest_mtu init'd with asoc to :%d\n",
99017205eccSRandall Stewart 	    asoc->smallest_mtu);
99117205eccSRandall Stewart #endif
992f8829a4aSRandall Stewart 	asoc->minrto = m->sctp_ep.sctp_minrto;
993f8829a4aSRandall Stewart 	asoc->maxrto = m->sctp_ep.sctp_maxrto;
994f8829a4aSRandall Stewart 
995f8829a4aSRandall Stewart 	asoc->locked_on_sending = NULL;
996f8829a4aSRandall Stewart 	asoc->stream_locked_on = 0;
997f8829a4aSRandall Stewart 	asoc->ecn_echo_cnt_onq = 0;
998f8829a4aSRandall Stewart 	asoc->stream_locked = 0;
999f8829a4aSRandall Stewart 
100042551e99SRandall Stewart 	asoc->send_sack = 1;
100142551e99SRandall Stewart 
100242551e99SRandall Stewart 	LIST_INIT(&asoc->sctp_restricted_addrs);
100342551e99SRandall Stewart 
1004f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->nets);
1005f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->pending_reply_queue);
1006f8829a4aSRandall Stewart 	asoc->last_asconf_ack_sent = NULL;
1007f8829a4aSRandall Stewart 	/* Setup to fill the hb random cache at first HB */
1008f8829a4aSRandall Stewart 	asoc->hb_random_idx = 4;
1009f8829a4aSRandall Stewart 
1010f8829a4aSRandall Stewart 	asoc->sctp_autoclose_ticks = m->sctp_ep.auto_close_time;
1011f8829a4aSRandall Stewart 
1012f8829a4aSRandall Stewart 	/*
1013f8829a4aSRandall Stewart 	 * Now the stream parameters, here we allocate space for all streams
1014f8829a4aSRandall Stewart 	 * that we request by default.
1015f8829a4aSRandall Stewart 	 */
1016f8829a4aSRandall Stewart 	asoc->streamoutcnt = asoc->pre_open_streams =
1017f8829a4aSRandall Stewart 	    m->sctp_ep.pre_open_stream_count;
1018f8829a4aSRandall Stewart 	SCTP_MALLOC(asoc->strmout, struct sctp_stream_out *,
1019f8829a4aSRandall Stewart 	    asoc->streamoutcnt * sizeof(struct sctp_stream_out),
1020207304d4SRandall Stewart 	    SCTP_M_STRMO);
1021f8829a4aSRandall Stewart 	if (asoc->strmout == NULL) {
1022f8829a4aSRandall Stewart 		/* big trouble no memory */
1023f8829a4aSRandall Stewart 		return (ENOMEM);
1024f8829a4aSRandall Stewart 	}
1025f8829a4aSRandall Stewart 	for (i = 0; i < asoc->streamoutcnt; i++) {
1026f8829a4aSRandall Stewart 		/*
1027f8829a4aSRandall Stewart 		 * inbound side must be set to 0xffff, also NOTE when we get
1028f8829a4aSRandall Stewart 		 * the INIT-ACK back (for INIT sender) we MUST reduce the
1029f8829a4aSRandall Stewart 		 * count (streamoutcnt) but first check if we sent to any of
1030f8829a4aSRandall Stewart 		 * the upper streams that were dropped (if some were). Those
1031f8829a4aSRandall Stewart 		 * that were dropped must be notified to the upper layer as
1032f8829a4aSRandall Stewart 		 * failed to send.
1033f8829a4aSRandall Stewart 		 */
1034f8829a4aSRandall Stewart 		asoc->strmout[i].next_sequence_sent = 0x0;
1035f8829a4aSRandall Stewart 		TAILQ_INIT(&asoc->strmout[i].outqueue);
1036f8829a4aSRandall Stewart 		asoc->strmout[i].stream_no = i;
1037f8829a4aSRandall Stewart 		asoc->strmout[i].last_msg_incomplete = 0;
1038f8829a4aSRandall Stewart 		asoc->strmout[i].next_spoke.tqe_next = 0;
1039f8829a4aSRandall Stewart 		asoc->strmout[i].next_spoke.tqe_prev = 0;
1040f8829a4aSRandall Stewart 	}
1041f8829a4aSRandall Stewart 	/* Now the mapping array */
1042f8829a4aSRandall Stewart 	asoc->mapping_array_size = SCTP_INITIAL_MAPPING_ARRAY;
1043f8829a4aSRandall Stewart 	SCTP_MALLOC(asoc->mapping_array, uint8_t *, asoc->mapping_array_size,
1044207304d4SRandall Stewart 	    SCTP_M_MAP);
1045f8829a4aSRandall Stewart 	if (asoc->mapping_array == NULL) {
1046207304d4SRandall Stewart 		SCTP_FREE(asoc->strmout, SCTP_M_STRMO);
1047f8829a4aSRandall Stewart 		return (ENOMEM);
1048f8829a4aSRandall Stewart 	}
1049f8829a4aSRandall Stewart 	memset(asoc->mapping_array, 0, asoc->mapping_array_size);
1050f8829a4aSRandall Stewart 	/* Now the init of the other outqueues */
1051f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->free_chunks);
1052f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->out_wheel);
1053f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->control_send_queue);
1054f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->send_queue);
1055f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->sent_queue);
1056f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->reasmqueue);
1057f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->resetHead);
1058f8829a4aSRandall Stewart 	asoc->max_inbound_streams = m->sctp_ep.max_open_streams_intome;
1059f8829a4aSRandall Stewart 	TAILQ_INIT(&asoc->asconf_queue);
1060f8829a4aSRandall Stewart 	/* authentication fields */
1061f8829a4aSRandall Stewart 	asoc->authinfo.random = NULL;
1062f8829a4aSRandall Stewart 	asoc->authinfo.assoc_key = NULL;
1063f8829a4aSRandall Stewart 	asoc->authinfo.assoc_keyid = 0;
1064f8829a4aSRandall Stewart 	asoc->authinfo.recv_key = NULL;
1065f8829a4aSRandall Stewart 	asoc->authinfo.recv_keyid = 0;
1066f8829a4aSRandall Stewart 	LIST_INIT(&asoc->shared_keys);
1067f42a358aSRandall Stewart 	asoc->marked_retrans = 0;
1068f42a358aSRandall Stewart 	asoc->timoinit = 0;
1069f42a358aSRandall Stewart 	asoc->timodata = 0;
1070f42a358aSRandall Stewart 	asoc->timosack = 0;
1071f42a358aSRandall Stewart 	asoc->timoshutdown = 0;
1072f42a358aSRandall Stewart 	asoc->timoheartbeat = 0;
1073f42a358aSRandall Stewart 	asoc->timocookie = 0;
1074f42a358aSRandall Stewart 	asoc->timoshutdownack = 0;
10756e55db54SRandall Stewart 	(void)SCTP_GETTIME_TIMEVAL(&asoc->start_time);
10766e55db54SRandall Stewart 	asoc->discontinuity_time = asoc->start_time;
1077eacc51c5SRandall Stewart 	/*
1078eacc51c5SRandall Stewart 	 * sa_ignore MEMLEAK {memory is put in the assoc mapping array and
1079eacc51c5SRandall Stewart 	 * freed later whe the association is freed.
1080eacc51c5SRandall Stewart 	 */
1081f8829a4aSRandall Stewart 	return (0);
1082f8829a4aSRandall Stewart }
1083f8829a4aSRandall Stewart 
1084f8829a4aSRandall Stewart int
10850696e120SRandall Stewart sctp_expand_mapping_array(struct sctp_association *asoc, uint32_t needed)
1086f8829a4aSRandall Stewart {
1087f8829a4aSRandall Stewart 	/* mapping array needs to grow */
1088f8829a4aSRandall Stewart 	uint8_t *new_array;
10890696e120SRandall Stewart 	uint32_t new_size;
1090f8829a4aSRandall Stewart 
10910696e120SRandall Stewart 
10920696e120SRandall Stewart 	new_size = asoc->mapping_array_size + ((needed + 7) / 8 + SCTP_MAPPING_ARRAY_INCR);
1093207304d4SRandall Stewart 	SCTP_MALLOC(new_array, uint8_t *, new_size, SCTP_M_MAP);
1094f8829a4aSRandall Stewart 	if (new_array == NULL) {
1095f8829a4aSRandall Stewart 		/* can't get more, forget it */
1096ad81507eSRandall Stewart 		SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n",
1097f8829a4aSRandall Stewart 		    new_size);
1098f8829a4aSRandall Stewart 		return (-1);
1099f8829a4aSRandall Stewart 	}
1100f8829a4aSRandall Stewart 	memset(new_array, 0, new_size);
1101f8829a4aSRandall Stewart 	memcpy(new_array, asoc->mapping_array, asoc->mapping_array_size);
1102207304d4SRandall Stewart 	SCTP_FREE(asoc->mapping_array, SCTP_M_MAP);
1103f8829a4aSRandall Stewart 	asoc->mapping_array = new_array;
1104f8829a4aSRandall Stewart 	asoc->mapping_array_size = new_size;
1105f8829a4aSRandall Stewart 	return (0);
1106f8829a4aSRandall Stewart }
1107f8829a4aSRandall Stewart 
110842551e99SRandall Stewart #if defined(SCTP_USE_THREAD_BASED_ITERATOR)
110942551e99SRandall Stewart static void
111042551e99SRandall Stewart sctp_iterator_work(struct sctp_iterator *it)
111142551e99SRandall Stewart {
111242551e99SRandall Stewart 	int iteration_count = 0;
111342551e99SRandall Stewart 	int inp_skip = 0;
111442551e99SRandall Stewart 
111542551e99SRandall Stewart 	SCTP_ITERATOR_LOCK();
1116ad81507eSRandall Stewart 	if (it->inp) {
111742551e99SRandall Stewart 		SCTP_INP_DECR_REF(it->inp);
1118ad81507eSRandall Stewart 	}
111942551e99SRandall Stewart 	if (it->inp == NULL) {
112042551e99SRandall Stewart 		/* iterator is complete */
112142551e99SRandall Stewart done_with_iterator:
112242551e99SRandall Stewart 		SCTP_ITERATOR_UNLOCK();
112342551e99SRandall Stewart 		if (it->function_atend != NULL) {
112442551e99SRandall Stewart 			(*it->function_atend) (it->pointer, it->val);
112542551e99SRandall Stewart 		}
1126207304d4SRandall Stewart 		SCTP_FREE(it, SCTP_M_ITER);
112742551e99SRandall Stewart 		return;
112842551e99SRandall Stewart 	}
112942551e99SRandall Stewart select_a_new_ep:
113042551e99SRandall Stewart 	SCTP_INP_WLOCK(it->inp);
113142551e99SRandall Stewart 	while (((it->pcb_flags) &&
113242551e99SRandall Stewart 	    ((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) ||
113342551e99SRandall Stewart 	    ((it->pcb_features) &&
113442551e99SRandall Stewart 	    ((it->inp->sctp_features & it->pcb_features) != it->pcb_features))) {
113542551e99SRandall Stewart 		/* endpoint flags or features don't match, so keep looking */
113642551e99SRandall Stewart 		if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {
113742551e99SRandall Stewart 			SCTP_INP_WUNLOCK(it->inp);
113842551e99SRandall Stewart 			goto done_with_iterator;
113942551e99SRandall Stewart 		}
114042551e99SRandall Stewart 		SCTP_INP_WUNLOCK(it->inp);
114142551e99SRandall Stewart 		it->inp = LIST_NEXT(it->inp, sctp_list);
114242551e99SRandall Stewart 		if (it->inp == NULL) {
114342551e99SRandall Stewart 			goto done_with_iterator;
114442551e99SRandall Stewart 		}
114542551e99SRandall Stewart 		SCTP_INP_WLOCK(it->inp);
114642551e99SRandall Stewart 	}
114742551e99SRandall Stewart 
114842551e99SRandall Stewart 	/* mark the current iterator on the endpoint */
114942551e99SRandall Stewart 	it->inp->inp_starting_point_for_iterator = it;
115042551e99SRandall Stewart 	SCTP_INP_WUNLOCK(it->inp);
115142551e99SRandall Stewart 	SCTP_INP_RLOCK(it->inp);
115242551e99SRandall Stewart 
115342551e99SRandall Stewart 	/* now go through each assoc which is in the desired state */
115442551e99SRandall Stewart 	if (it->done_current_ep == 0) {
115542551e99SRandall Stewart 		if (it->function_inp != NULL)
115642551e99SRandall Stewart 			inp_skip = (*it->function_inp) (it->inp, it->pointer, it->val);
115742551e99SRandall Stewart 		it->done_current_ep = 1;
115842551e99SRandall Stewart 	}
115942551e99SRandall Stewart 	if (it->stcb == NULL) {
116042551e99SRandall Stewart 		/* run the per instance function */
116142551e99SRandall Stewart 		it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list);
116242551e99SRandall Stewart 	}
116342551e99SRandall Stewart 	if ((inp_skip) || it->stcb == NULL) {
116442551e99SRandall Stewart 		if (it->function_inp_end != NULL) {
116542551e99SRandall Stewart 			inp_skip = (*it->function_inp_end) (it->inp,
116642551e99SRandall Stewart 			    it->pointer,
116742551e99SRandall Stewart 			    it->val);
116842551e99SRandall Stewart 		}
116942551e99SRandall Stewart 		SCTP_INP_RUNLOCK(it->inp);
117042551e99SRandall Stewart 		goto no_stcb;
117142551e99SRandall Stewart 	}
117242551e99SRandall Stewart 	if ((it->stcb) &&
117342551e99SRandall Stewart 	    (it->stcb->asoc.stcb_starting_point_for_iterator == it)) {
117442551e99SRandall Stewart 		it->stcb->asoc.stcb_starting_point_for_iterator = NULL;
117542551e99SRandall Stewart 	}
117642551e99SRandall Stewart 	while (it->stcb) {
117742551e99SRandall Stewart 		SCTP_TCB_LOCK(it->stcb);
117842551e99SRandall Stewart 		if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) {
117942551e99SRandall Stewart 			/* not in the right state... keep looking */
118042551e99SRandall Stewart 			SCTP_TCB_UNLOCK(it->stcb);
118142551e99SRandall Stewart 			goto next_assoc;
118242551e99SRandall Stewart 		}
118342551e99SRandall Stewart 		/* mark the current iterator on the assoc */
118442551e99SRandall Stewart 		it->stcb->asoc.stcb_starting_point_for_iterator = it;
118542551e99SRandall Stewart 		/* see if we have limited out the iterator loop */
118642551e99SRandall Stewart 		iteration_count++;
118742551e99SRandall Stewart 		if (iteration_count > SCTP_ITERATOR_MAX_AT_ONCE) {
118842551e99SRandall Stewart 			/* Pause to let others grab the lock */
118942551e99SRandall Stewart 			atomic_add_int(&it->stcb->asoc.refcnt, 1);
119042551e99SRandall Stewart 			SCTP_TCB_UNLOCK(it->stcb);
119142551e99SRandall Stewart 			SCTP_INP_RUNLOCK(it->inp);
119242551e99SRandall Stewart 			SCTP_ITERATOR_UNLOCK();
119342551e99SRandall Stewart 			SCTP_ITERATOR_LOCK();
119442551e99SRandall Stewart 			SCTP_INP_RLOCK(it->inp);
119542551e99SRandall Stewart 			SCTP_TCB_LOCK(it->stcb);
119642551e99SRandall Stewart 			atomic_add_int(&it->stcb->asoc.refcnt, -1);
119742551e99SRandall Stewart 			iteration_count = 0;
119842551e99SRandall Stewart 		}
119942551e99SRandall Stewart 		/* run function on this one */
120042551e99SRandall Stewart 		(*it->function_assoc) (it->inp, it->stcb, it->pointer, it->val);
120142551e99SRandall Stewart 
120242551e99SRandall Stewart 		/*
120342551e99SRandall Stewart 		 * we lie here, it really needs to have its own type but
120442551e99SRandall Stewart 		 * first I must verify that this won't effect things :-0
120542551e99SRandall Stewart 		 */
120642551e99SRandall Stewart 		if (it->no_chunk_output == 0)
120742551e99SRandall Stewart 			sctp_chunk_output(it->inp, it->stcb, SCTP_OUTPUT_FROM_T3);
120842551e99SRandall Stewart 
120942551e99SRandall Stewart 		SCTP_TCB_UNLOCK(it->stcb);
121042551e99SRandall Stewart next_assoc:
121142551e99SRandall Stewart 		it->stcb = LIST_NEXT(it->stcb, sctp_tcblist);
121242551e99SRandall Stewart 		if (it->stcb == NULL) {
121342551e99SRandall Stewart 			/* Run last function */
121442551e99SRandall Stewart 			if (it->function_inp_end != NULL) {
121542551e99SRandall Stewart 				inp_skip = (*it->function_inp_end) (it->inp,
121642551e99SRandall Stewart 				    it->pointer,
121742551e99SRandall Stewart 				    it->val);
121842551e99SRandall Stewart 			}
121942551e99SRandall Stewart 		}
122042551e99SRandall Stewart 	}
122142551e99SRandall Stewart 	SCTP_INP_RUNLOCK(it->inp);
122242551e99SRandall Stewart no_stcb:
122342551e99SRandall Stewart 	/* done with all assocs on this endpoint, move on to next endpoint */
122442551e99SRandall Stewart 	it->done_current_ep = 0;
122542551e99SRandall Stewart 	SCTP_INP_WLOCK(it->inp);
122642551e99SRandall Stewart 	it->inp->inp_starting_point_for_iterator = NULL;
122742551e99SRandall Stewart 	SCTP_INP_WUNLOCK(it->inp);
122842551e99SRandall Stewart 	if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {
122942551e99SRandall Stewart 		it->inp = NULL;
123042551e99SRandall Stewart 	} else {
123142551e99SRandall Stewart 		SCTP_INP_INFO_RLOCK();
123242551e99SRandall Stewart 		it->inp = LIST_NEXT(it->inp, sctp_list);
123342551e99SRandall Stewart 		SCTP_INP_INFO_RUNLOCK();
123442551e99SRandall Stewart 	}
123542551e99SRandall Stewart 	if (it->inp == NULL) {
123642551e99SRandall Stewart 		goto done_with_iterator;
123742551e99SRandall Stewart 	}
123842551e99SRandall Stewart 	goto select_a_new_ep;
123942551e99SRandall Stewart }
124042551e99SRandall Stewart 
124142551e99SRandall Stewart void
124242551e99SRandall Stewart sctp_iterator_worker(void)
124342551e99SRandall Stewart {
124442551e99SRandall Stewart 	struct sctp_iterator *it = NULL;
124542551e99SRandall Stewart 
124642551e99SRandall Stewart 	/* This function is called with the WQ lock in place */
124742551e99SRandall Stewart 
124842551e99SRandall Stewart 	sctppcbinfo.iterator_running = 1;
124942551e99SRandall Stewart again:
125042551e99SRandall Stewart 	it = TAILQ_FIRST(&sctppcbinfo.iteratorhead);
125142551e99SRandall Stewart 	while (it) {
125242551e99SRandall Stewart 		/* now lets work on this one */
125342551e99SRandall Stewart 		TAILQ_REMOVE(&sctppcbinfo.iteratorhead, it, sctp_nxt_itr);
125442551e99SRandall Stewart 		SCTP_IPI_ITERATOR_WQ_UNLOCK();
125542551e99SRandall Stewart 		sctp_iterator_work(it);
125642551e99SRandall Stewart 		SCTP_IPI_ITERATOR_WQ_LOCK();
12573c503c28SRandall Stewart 		/* sa_ignore FREED_MEMORY */
125842551e99SRandall Stewart 		it = TAILQ_FIRST(&sctppcbinfo.iteratorhead);
125942551e99SRandall Stewart 	}
126042551e99SRandall Stewart 	if (TAILQ_FIRST(&sctppcbinfo.iteratorhead)) {
126142551e99SRandall Stewart 		goto again;
126242551e99SRandall Stewart 	}
126342551e99SRandall Stewart 	sctppcbinfo.iterator_running = 0;
126442551e99SRandall Stewart 	return;
126542551e99SRandall Stewart }
126642551e99SRandall Stewart 
126742551e99SRandall Stewart #endif
126842551e99SRandall Stewart 
1269f8829a4aSRandall Stewart 
1270f8829a4aSRandall Stewart static void
1271f8829a4aSRandall Stewart sctp_handle_addr_wq(void)
1272f8829a4aSRandall Stewart {
1273f8829a4aSRandall Stewart 	/* deal with the ADDR wq from the rtsock calls */
1274f8829a4aSRandall Stewart 	struct sctp_laddr *wi;
127542551e99SRandall Stewart 	struct sctp_asconf_iterator *asc;
1276f8829a4aSRandall Stewart 
127742551e99SRandall Stewart 	SCTP_MALLOC(asc, struct sctp_asconf_iterator *,
1278207304d4SRandall Stewart 	    sizeof(struct sctp_asconf_iterator), SCTP_M_ASC_IT);
127942551e99SRandall Stewart 	if (asc == NULL) {
128042551e99SRandall Stewart 		/* Try later, no memory */
1281f8829a4aSRandall Stewart 		sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ,
1282f8829a4aSRandall Stewart 		    (struct sctp_inpcb *)NULL,
1283f8829a4aSRandall Stewart 		    (struct sctp_tcb *)NULL,
1284f8829a4aSRandall Stewart 		    (struct sctp_nets *)NULL);
128542551e99SRandall Stewart 		return;
1286f8829a4aSRandall Stewart 	}
128742551e99SRandall Stewart 	LIST_INIT(&asc->list_of_work);
128842551e99SRandall Stewart 	asc->cnt = 0;
128942551e99SRandall Stewart 	SCTP_IPI_ITERATOR_WQ_LOCK();
129042551e99SRandall Stewart 	wi = LIST_FIRST(&sctppcbinfo.addr_wq);
129142551e99SRandall Stewart 	while (wi != NULL) {
129242551e99SRandall Stewart 		LIST_REMOVE(wi, sctp_nxt_addr);
129342551e99SRandall Stewart 		LIST_INSERT_HEAD(&asc->list_of_work, wi, sctp_nxt_addr);
129442551e99SRandall Stewart 		asc->cnt++;
129542551e99SRandall Stewart 		wi = LIST_FIRST(&sctppcbinfo.addr_wq);
1296f8829a4aSRandall Stewart 	}
129742551e99SRandall Stewart 	SCTP_IPI_ITERATOR_WQ_UNLOCK();
129842551e99SRandall Stewart 	if (asc->cnt == 0) {
1299207304d4SRandall Stewart 		SCTP_FREE(asc, SCTP_M_ASC_IT);
130042551e99SRandall Stewart 	} else {
1301ad81507eSRandall Stewart 		(void)sctp_initiate_iterator(sctp_iterator_ep,
130242551e99SRandall Stewart 		    sctp_iterator_stcb,
130342551e99SRandall Stewart 		    NULL,	/* No ep end for boundall */
130442551e99SRandall Stewart 		    SCTP_PCB_FLAGS_BOUNDALL,
130542551e99SRandall Stewart 		    SCTP_PCB_ANY_FEATURES,
130642551e99SRandall Stewart 		    SCTP_ASOC_ANY_STATE, (void *)asc, 0,
130742551e99SRandall Stewart 		    sctp_iterator_end, NULL, 0);
130842551e99SRandall Stewart 	}
130942551e99SRandall Stewart 
1310f8829a4aSRandall Stewart }
1311f8829a4aSRandall Stewart 
1312f8829a4aSRandall Stewart void
1313f8829a4aSRandall Stewart sctp_timeout_handler(void *t)
1314f8829a4aSRandall Stewart {
1315f8829a4aSRandall Stewart 	struct sctp_inpcb *inp;
1316f8829a4aSRandall Stewart 	struct sctp_tcb *stcb;
1317f8829a4aSRandall Stewart 	struct sctp_nets *net;
1318f8829a4aSRandall Stewart 	struct sctp_timer *tmr;
131993164cf9SRandall Stewart 	int did_output;
1320f8829a4aSRandall Stewart 	struct sctp_iterator *it = NULL;
1321f8829a4aSRandall Stewart 
1322f8829a4aSRandall Stewart 
1323f8829a4aSRandall Stewart 	tmr = (struct sctp_timer *)t;
1324f8829a4aSRandall Stewart 	inp = (struct sctp_inpcb *)tmr->ep;
1325f8829a4aSRandall Stewart 	stcb = (struct sctp_tcb *)tmr->tcb;
1326f8829a4aSRandall Stewart 	net = (struct sctp_nets *)tmr->net;
1327f8829a4aSRandall Stewart 	did_output = 1;
1328f8829a4aSRandall Stewart 
1329f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1330f8829a4aSRandall Stewart 	sctp_audit_log(0xF0, (uint8_t) tmr->type);
1331f8829a4aSRandall Stewart 	sctp_auditing(3, inp, stcb, net);
1332f8829a4aSRandall Stewart #endif
1333f8829a4aSRandall Stewart 
1334f8829a4aSRandall Stewart 	/* sanity checks... */
1335f8829a4aSRandall Stewart 	if (tmr->self != (void *)tmr) {
1336f8829a4aSRandall Stewart 		/*
1337ad81507eSRandall Stewart 		 * SCTP_PRINTF("Stale SCTP timer fired (%p), ignoring...\n",
1338f8829a4aSRandall Stewart 		 * tmr);
1339f8829a4aSRandall Stewart 		 */
1340f8829a4aSRandall Stewart 		return;
1341f8829a4aSRandall Stewart 	}
1342a5d547adSRandall Stewart 	tmr->stopped_from = 0xa001;
1343f8829a4aSRandall Stewart 	if (!SCTP_IS_TIMER_TYPE_VALID(tmr->type)) {
1344f8829a4aSRandall Stewart 		/*
1345ad81507eSRandall Stewart 		 * SCTP_PRINTF("SCTP timer fired with invalid type: 0x%x\n",
1346f8829a4aSRandall Stewart 		 * tmr->type);
1347f8829a4aSRandall Stewart 		 */
1348f8829a4aSRandall Stewart 		return;
1349f8829a4aSRandall Stewart 	}
1350a5d547adSRandall Stewart 	tmr->stopped_from = 0xa002;
1351f8829a4aSRandall Stewart 	if ((tmr->type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL)) {
1352f8829a4aSRandall Stewart 		return;
1353f8829a4aSRandall Stewart 	}
1354f8829a4aSRandall Stewart 	/* if this is an iterator timeout, get the struct and clear inp */
1355a5d547adSRandall Stewart 	tmr->stopped_from = 0xa003;
1356f8829a4aSRandall Stewart 	if (tmr->type == SCTP_TIMER_TYPE_ITERATOR) {
1357f8829a4aSRandall Stewart 		it = (struct sctp_iterator *)inp;
1358f8829a4aSRandall Stewart 		inp = NULL;
1359f8829a4aSRandall Stewart 	}
1360f8829a4aSRandall Stewart 	if (inp) {
1361f8829a4aSRandall Stewart 		SCTP_INP_INCR_REF(inp);
1362f8829a4aSRandall Stewart 		if ((inp->sctp_socket == 0) &&
1363f8829a4aSRandall Stewart 		    ((tmr->type != SCTP_TIMER_TYPE_INPKILL) &&
1364f8829a4aSRandall Stewart 		    (tmr->type != SCTP_TIMER_TYPE_SHUTDOWN) &&
1365f8829a4aSRandall Stewart 		    (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNACK) &&
1366f8829a4aSRandall Stewart 		    (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNGUARD) &&
1367f8829a4aSRandall Stewart 		    (tmr->type != SCTP_TIMER_TYPE_ASOCKILL))
1368f8829a4aSRandall Stewart 		    ) {
1369f8829a4aSRandall Stewart 			SCTP_INP_DECR_REF(inp);
1370f8829a4aSRandall Stewart 			return;
1371f8829a4aSRandall Stewart 		}
1372f8829a4aSRandall Stewart 	}
1373a5d547adSRandall Stewart 	tmr->stopped_from = 0xa004;
1374f8829a4aSRandall Stewart 	if (stcb) {
1375c105859eSRandall Stewart 		atomic_add_int(&stcb->asoc.refcnt, 1);
1376f8829a4aSRandall Stewart 		if (stcb->asoc.state == 0) {
1377c105859eSRandall Stewart 			atomic_add_int(&stcb->asoc.refcnt, -1);
1378f8829a4aSRandall Stewart 			if (inp) {
1379f8829a4aSRandall Stewart 				SCTP_INP_DECR_REF(inp);
1380f8829a4aSRandall Stewart 			}
1381f8829a4aSRandall Stewart 			return;
1382f8829a4aSRandall Stewart 		}
1383f8829a4aSRandall Stewart 	}
1384a5d547adSRandall Stewart 	tmr->stopped_from = 0xa005;
1385ad81507eSRandall Stewart 	SCTPDBG(SCTP_DEBUG_TIMER1, "Timer type %d goes off\n", tmr->type);
1386139bc87fSRandall Stewart 	if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) {
1387f8829a4aSRandall Stewart 		if (inp) {
1388f8829a4aSRandall Stewart 			SCTP_INP_DECR_REF(inp);
1389f8829a4aSRandall Stewart 		}
1390207304d4SRandall Stewart 		if (stcb) {
1391207304d4SRandall Stewart 			atomic_add_int(&stcb->asoc.refcnt, -1);
1392207304d4SRandall Stewart 		}
1393f8829a4aSRandall Stewart 		return;
1394f8829a4aSRandall Stewart 	}
1395a5d547adSRandall Stewart 	tmr->stopped_from = 0xa006;
1396a5d547adSRandall Stewart 
1397f8829a4aSRandall Stewart 	if (stcb) {
1398f8829a4aSRandall Stewart 		SCTP_TCB_LOCK(stcb);
139950cec919SRandall Stewart 		atomic_add_int(&stcb->asoc.refcnt, -1);
1400f8829a4aSRandall Stewart 	}
140144b7479bSRandall Stewart 	/* record in stopped what t-o occured */
140244b7479bSRandall Stewart 	tmr->stopped_from = tmr->type;
140344b7479bSRandall Stewart 
1404f8829a4aSRandall Stewart 	/* mark as being serviced now */
140544b7479bSRandall Stewart 	if (SCTP_OS_TIMER_PENDING(&tmr->timer)) {
140644b7479bSRandall Stewart 		/*
140744b7479bSRandall Stewart 		 * Callout has been rescheduled.
140844b7479bSRandall Stewart 		 */
140944b7479bSRandall Stewart 		goto get_out;
141044b7479bSRandall Stewart 	}
141144b7479bSRandall Stewart 	if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) {
141244b7479bSRandall Stewart 		/*
141344b7479bSRandall Stewart 		 * Not active, so no action.
141444b7479bSRandall Stewart 		 */
141544b7479bSRandall Stewart 		goto get_out;
141644b7479bSRandall Stewart 	}
1417139bc87fSRandall Stewart 	SCTP_OS_TIMER_DEACTIVATE(&tmr->timer);
1418f8829a4aSRandall Stewart 
1419f8829a4aSRandall Stewart 	/* call the handler for the appropriate timer type */
1420f8829a4aSRandall Stewart 	switch (tmr->type) {
1421d61a0ae0SRandall Stewart 	case SCTP_TIMER_TYPE_ZERO_COPY:
1422eacc51c5SRandall Stewart 		if (inp == NULL) {
1423eacc51c5SRandall Stewart 			break;
1424eacc51c5SRandall Stewart 		}
1425d61a0ae0SRandall Stewart 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {
1426d61a0ae0SRandall Stewart 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);
1427d61a0ae0SRandall Stewart 		}
1428d61a0ae0SRandall Stewart 		break;
1429ad21a364SRandall Stewart 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:
1430eacc51c5SRandall Stewart 		if (inp == NULL) {
1431eacc51c5SRandall Stewart 			break;
1432eacc51c5SRandall Stewart 		}
1433ad21a364SRandall Stewart 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {
1434ad21a364SRandall Stewart 			SCTP_ZERO_COPY_SENDQ_EVENT(inp, inp->sctp_socket);
1435ad21a364SRandall Stewart 		}
1436ad21a364SRandall Stewart 		break;
1437f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ADDR_WQ:
1438f8829a4aSRandall Stewart 		sctp_handle_addr_wq();
1439f8829a4aSRandall Stewart 		break;
1440f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ITERATOR:
1441f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoiterator);
1442f8829a4aSRandall Stewart 		sctp_iterator_timer(it);
1443f8829a4aSRandall Stewart 		break;
1444f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SEND:
1445ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1446ad81507eSRandall Stewart 			break;
1447ad81507eSRandall Stewart 		}
1448f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timodata);
1449f42a358aSRandall Stewart 		stcb->asoc.timodata++;
1450f8829a4aSRandall Stewart 		stcb->asoc.num_send_timers_up--;
1451f8829a4aSRandall Stewart 		if (stcb->asoc.num_send_timers_up < 0) {
1452f8829a4aSRandall Stewart 			stcb->asoc.num_send_timers_up = 0;
1453f8829a4aSRandall Stewart 		}
1454f8829a4aSRandall Stewart 		if (sctp_t3rxt_timer(inp, stcb, net)) {
1455f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1456f8829a4aSRandall Stewart 
1457f8829a4aSRandall Stewart 			goto out_decr;
1458f8829a4aSRandall Stewart 		}
1459f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1460f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1461f8829a4aSRandall Stewart #endif
1462f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3);
1463f8829a4aSRandall Stewart 		if ((stcb->asoc.num_send_timers_up == 0) &&
1464f8829a4aSRandall Stewart 		    (stcb->asoc.sent_queue_cnt > 0)
1465f8829a4aSRandall Stewart 		    ) {
1466f8829a4aSRandall Stewart 			struct sctp_tmit_chunk *chk;
1467f8829a4aSRandall Stewart 
1468f8829a4aSRandall Stewart 			/*
1469f8829a4aSRandall Stewart 			 * safeguard. If there on some on the sent queue
1470f8829a4aSRandall Stewart 			 * somewhere but no timers running something is
1471f8829a4aSRandall Stewart 			 * wrong... so we start a timer on the first chunk
1472f8829a4aSRandall Stewart 			 * on the send queue on whatever net it is sent to.
1473f8829a4aSRandall Stewart 			 */
1474f8829a4aSRandall Stewart 			chk = TAILQ_FIRST(&stcb->asoc.sent_queue);
1475f8829a4aSRandall Stewart 			sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb,
1476f8829a4aSRandall Stewart 			    chk->whoTo);
1477f8829a4aSRandall Stewart 		}
1478f8829a4aSRandall Stewart 		break;
1479f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INIT:
1480ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1481ad81507eSRandall Stewart 			break;
1482ad81507eSRandall Stewart 		}
1483f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoinit);
1484f42a358aSRandall Stewart 		stcb->asoc.timoinit++;
1485f8829a4aSRandall Stewart 		if (sctp_t1init_timer(inp, stcb, net)) {
1486f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1487f8829a4aSRandall Stewart 			goto out_decr;
1488f8829a4aSRandall Stewart 		}
1489f8829a4aSRandall Stewart 		/* We do output but not here */
1490f8829a4aSRandall Stewart 		did_output = 0;
1491f8829a4aSRandall Stewart 		break;
1492f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_RECV:
1493ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1494ad81507eSRandall Stewart 			break;
1495ad81507eSRandall Stewart 		}
1496f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timosack);
1497f42a358aSRandall Stewart 		stcb->asoc.timosack++;
1498f8829a4aSRandall Stewart 		sctp_send_sack(stcb);
1499f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1500f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1501f8829a4aSRandall Stewart #endif
1502f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SACK_TMR);
1503f8829a4aSRandall Stewart 		break;
1504f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWN:
1505ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1506ad81507eSRandall Stewart 			break;
1507ad81507eSRandall Stewart 		}
1508f8829a4aSRandall Stewart 		if (sctp_shutdown_timer(inp, stcb, net)) {
1509f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1510f8829a4aSRandall Stewart 			goto out_decr;
1511f8829a4aSRandall Stewart 		}
1512f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoshutdown);
1513f42a358aSRandall Stewart 		stcb->asoc.timoshutdown++;
1514f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1515f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1516f8829a4aSRandall Stewart #endif
1517f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_TMR);
1518f8829a4aSRandall Stewart 		break;
1519f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_HEARTBEAT:
1520f8829a4aSRandall Stewart 		{
15214c9179adSRandall Stewart 			struct sctp_nets *lnet;
1522f8829a4aSRandall Stewart 			int cnt_of_unconf = 0;
1523f8829a4aSRandall Stewart 
1524ad81507eSRandall Stewart 			if ((stcb == NULL) || (inp == NULL)) {
1525ad81507eSRandall Stewart 				break;
1526ad81507eSRandall Stewart 			}
1527f8829a4aSRandall Stewart 			SCTP_STAT_INCR(sctps_timoheartbeat);
1528f42a358aSRandall Stewart 			stcb->asoc.timoheartbeat++;
15294c9179adSRandall Stewart 			TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
15304c9179adSRandall Stewart 				if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) &&
15314c9179adSRandall Stewart 				    (lnet->dest_state & SCTP_ADDR_REACHABLE)) {
1532f8829a4aSRandall Stewart 					cnt_of_unconf++;
1533f8829a4aSRandall Stewart 				}
1534f8829a4aSRandall Stewart 			}
1535f8829a4aSRandall Stewart 			if (cnt_of_unconf == 0) {
15364c9179adSRandall Stewart 				if (sctp_heartbeat_timer(inp, stcb, lnet,
15374c9179adSRandall Stewart 				    cnt_of_unconf)) {
1538f8829a4aSRandall Stewart 					/* no need to unlock on tcb its gone */
1539f8829a4aSRandall Stewart 					goto out_decr;
1540f8829a4aSRandall Stewart 				}
1541f8829a4aSRandall Stewart 			}
1542f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
15434c9179adSRandall Stewart 			sctp_auditing(4, inp, stcb, lnet);
1544f8829a4aSRandall Stewart #endif
15454c9179adSRandall Stewart 			sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT,
15464c9179adSRandall Stewart 			    stcb->sctp_ep, stcb, lnet);
1547f8829a4aSRandall Stewart 			sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_HB_TMR);
1548f8829a4aSRandall Stewart 		}
1549f8829a4aSRandall Stewart 		break;
1550f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_COOKIE:
1551ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1552ad81507eSRandall Stewart 			break;
1553ad81507eSRandall Stewart 		}
1554f8829a4aSRandall Stewart 		if (sctp_cookie_timer(inp, stcb, net)) {
1555f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1556f8829a4aSRandall Stewart 			goto out_decr;
1557f8829a4aSRandall Stewart 		}
1558f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timocookie);
1559f42a358aSRandall Stewart 		stcb->asoc.timocookie++;
1560f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1561f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1562f8829a4aSRandall Stewart #endif
1563f8829a4aSRandall Stewart 		/*
1564f8829a4aSRandall Stewart 		 * We consider T3 and Cookie timer pretty much the same with
1565f8829a4aSRandall Stewart 		 * respect to where from in chunk_output.
1566f8829a4aSRandall Stewart 		 */
1567f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3);
1568f8829a4aSRandall Stewart 		break;
1569f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_NEWCOOKIE:
1570f8829a4aSRandall Stewart 		{
1571f8829a4aSRandall Stewart 			struct timeval tv;
1572f8829a4aSRandall Stewart 			int i, secret;
1573f8829a4aSRandall Stewart 
1574ad81507eSRandall Stewart 			if (inp == NULL) {
1575ad81507eSRandall Stewart 				break;
1576ad81507eSRandall Stewart 			}
1577f8829a4aSRandall Stewart 			SCTP_STAT_INCR(sctps_timosecret);
15786e55db54SRandall Stewart 			(void)SCTP_GETTIME_TIMEVAL(&tv);
1579f8829a4aSRandall Stewart 			SCTP_INP_WLOCK(inp);
1580f8829a4aSRandall Stewart 			inp->sctp_ep.time_of_secret_change = tv.tv_sec;
1581f8829a4aSRandall Stewart 			inp->sctp_ep.last_secret_number =
1582f8829a4aSRandall Stewart 			    inp->sctp_ep.current_secret_number;
1583f8829a4aSRandall Stewart 			inp->sctp_ep.current_secret_number++;
1584f8829a4aSRandall Stewart 			if (inp->sctp_ep.current_secret_number >=
1585f8829a4aSRandall Stewart 			    SCTP_HOW_MANY_SECRETS) {
1586f8829a4aSRandall Stewart 				inp->sctp_ep.current_secret_number = 0;
1587f8829a4aSRandall Stewart 			}
1588f8829a4aSRandall Stewart 			secret = (int)inp->sctp_ep.current_secret_number;
1589f8829a4aSRandall Stewart 			for (i = 0; i < SCTP_NUMBER_OF_SECRETS; i++) {
1590f8829a4aSRandall Stewart 				inp->sctp_ep.secret_key[secret][i] =
1591f8829a4aSRandall Stewart 				    sctp_select_initial_TSN(&inp->sctp_ep);
1592f8829a4aSRandall Stewart 			}
1593f8829a4aSRandall Stewart 			SCTP_INP_WUNLOCK(inp);
1594f8829a4aSRandall Stewart 			sctp_timer_start(SCTP_TIMER_TYPE_NEWCOOKIE, inp, stcb, net);
1595f8829a4aSRandall Stewart 		}
1596f8829a4aSRandall Stewart 		did_output = 0;
1597f8829a4aSRandall Stewart 		break;
1598f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_PATHMTURAISE:
1599ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1600ad81507eSRandall Stewart 			break;
1601ad81507eSRandall Stewart 		}
1602f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timopathmtu);
1603f8829a4aSRandall Stewart 		sctp_pathmtu_timer(inp, stcb, net);
1604f8829a4aSRandall Stewart 		did_output = 0;
1605f8829a4aSRandall Stewart 		break;
1606f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNACK:
1607ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1608ad81507eSRandall Stewart 			break;
1609ad81507eSRandall Stewart 		}
1610f8829a4aSRandall Stewart 		if (sctp_shutdownack_timer(inp, stcb, net)) {
1611f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1612f8829a4aSRandall Stewart 			goto out_decr;
1613f8829a4aSRandall Stewart 		}
1614f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoshutdownack);
1615f42a358aSRandall Stewart 		stcb->asoc.timoshutdownack++;
1616f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1617f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1618f8829a4aSRandall Stewart #endif
1619f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_ACK_TMR);
1620f8829a4aSRandall Stewart 		break;
1621f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:
1622ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1623ad81507eSRandall Stewart 			break;
1624ad81507eSRandall Stewart 		}
1625f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoshutdownguard);
1626f8829a4aSRandall Stewart 		sctp_abort_an_association(inp, stcb,
1627f8829a4aSRandall Stewart 		    SCTP_SHUTDOWN_GUARD_EXPIRES, NULL);
1628f8829a4aSRandall Stewart 		/* no need to unlock on tcb its gone */
1629f8829a4aSRandall Stewart 		goto out_decr;
1630f8829a4aSRandall Stewart 
1631f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_STRRESET:
1632ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1633ad81507eSRandall Stewart 			break;
1634ad81507eSRandall Stewart 		}
1635f8829a4aSRandall Stewart 		if (sctp_strreset_timer(inp, stcb, net)) {
1636f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1637f8829a4aSRandall Stewart 			goto out_decr;
1638f8829a4aSRandall Stewart 		}
1639f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timostrmrst);
1640f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_TMR);
1641f8829a4aSRandall Stewart 		break;
1642f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_EARLYFR:
1643f8829a4aSRandall Stewart 		/* Need to do FR of things for net */
1644ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1645ad81507eSRandall Stewart 			break;
1646ad81507eSRandall Stewart 		}
1647f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoearlyfr);
1648f8829a4aSRandall Stewart 		sctp_early_fr_timer(inp, stcb, net);
1649f8829a4aSRandall Stewart 		break;
1650f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASCONF:
1651ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1652ad81507eSRandall Stewart 			break;
1653ad81507eSRandall Stewart 		}
1654f8829a4aSRandall Stewart 		if (sctp_asconf_timer(inp, stcb, net)) {
1655f8829a4aSRandall Stewart 			/* no need to unlock on tcb its gone */
1656f8829a4aSRandall Stewart 			goto out_decr;
1657f8829a4aSRandall Stewart 		}
1658f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoasconf);
1659f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1660f8829a4aSRandall Stewart 		sctp_auditing(4, inp, stcb, net);
1661f8829a4aSRandall Stewart #endif
1662f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_ASCONF_TMR);
1663f8829a4aSRandall Stewart 		break;
1664f8829a4aSRandall Stewart 
1665f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_AUTOCLOSE:
1666ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1667ad81507eSRandall Stewart 			break;
1668ad81507eSRandall Stewart 		}
1669f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoautoclose);
1670f8829a4aSRandall Stewart 		sctp_autoclose_timer(inp, stcb, net);
1671f8829a4aSRandall Stewart 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR);
1672f8829a4aSRandall Stewart 		did_output = 0;
1673f8829a4aSRandall Stewart 		break;
1674f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASOCKILL:
1675ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1676ad81507eSRandall Stewart 			break;
1677ad81507eSRandall Stewart 		}
1678f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoassockill);
1679f8829a4aSRandall Stewart 		/* Can we free it yet? */
1680f8829a4aSRandall Stewart 		SCTP_INP_DECR_REF(inp);
1681a5d547adSRandall Stewart 		sctp_timer_stop(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_1);
1682a5d547adSRandall Stewart 		sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_2);
1683f8829a4aSRandall Stewart 		/*
1684f8829a4aSRandall Stewart 		 * free asoc, always unlocks (or destroy's) so prevent
1685f8829a4aSRandall Stewart 		 * duplicate unlock or unlock of a free mtx :-0
1686f8829a4aSRandall Stewart 		 */
1687f8829a4aSRandall Stewart 		stcb = NULL;
1688f8829a4aSRandall Stewart 		goto out_no_decr;
1689f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INPKILL:
1690f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_timoinpkill);
1691ad81507eSRandall Stewart 		if (inp == NULL) {
1692ad81507eSRandall Stewart 			break;
1693ad81507eSRandall Stewart 		}
1694f8829a4aSRandall Stewart 		/*
1695f8829a4aSRandall Stewart 		 * special case, take away our increment since WE are the
1696f8829a4aSRandall Stewart 		 * killer
1697f8829a4aSRandall Stewart 		 */
1698f8829a4aSRandall Stewart 		SCTP_INP_DECR_REF(inp);
1699a5d547adSRandall Stewart 		sctp_timer_stop(SCTP_TIMER_TYPE_INPKILL, inp, NULL, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_3);
1700b0552ae2SRandall Stewart 		sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
1701b0552ae2SRandall Stewart 		    SCTP_CALLED_DIRECTLY_NOCMPSET);
1702f8829a4aSRandall Stewart 		goto out_no_decr;
1703f8829a4aSRandall Stewart 	default:
1704ad81507eSRandall Stewart 		SCTPDBG(SCTP_DEBUG_TIMER1, "sctp_timeout_handler:unknown timer %d\n",
1705f8829a4aSRandall Stewart 		    tmr->type);
1706f8829a4aSRandall Stewart 		break;
1707f8829a4aSRandall Stewart 	};
1708f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED
1709f8829a4aSRandall Stewart 	sctp_audit_log(0xF1, (uint8_t) tmr->type);
1710f8829a4aSRandall Stewart 	if (inp)
1711f8829a4aSRandall Stewart 		sctp_auditing(5, inp, stcb, net);
1712f8829a4aSRandall Stewart #endif
1713f8829a4aSRandall Stewart 	if ((did_output) && stcb) {
1714f8829a4aSRandall Stewart 		/*
1715f8829a4aSRandall Stewart 		 * Now we need to clean up the control chunk chain if an
1716f8829a4aSRandall Stewart 		 * ECNE is on it. It must be marked as UNSENT again so next
1717f8829a4aSRandall Stewart 		 * call will continue to send it until such time that we get
1718f8829a4aSRandall Stewart 		 * a CWR, to remove it. It is, however, less likely that we
1719f8829a4aSRandall Stewart 		 * will find a ecn echo on the chain though.
1720f8829a4aSRandall Stewart 		 */
1721f8829a4aSRandall Stewart 		sctp_fix_ecn_echo(&stcb->asoc);
1722f8829a4aSRandall Stewart 	}
172344b7479bSRandall Stewart get_out:
1724f8829a4aSRandall Stewart 	if (stcb) {
1725f8829a4aSRandall Stewart 		SCTP_TCB_UNLOCK(stcb);
1726f8829a4aSRandall Stewart 	}
1727f8829a4aSRandall Stewart out_decr:
1728f8829a4aSRandall Stewart 	if (inp) {
1729f8829a4aSRandall Stewart 		SCTP_INP_DECR_REF(inp);
1730f8829a4aSRandall Stewart 	}
1731f8829a4aSRandall Stewart out_no_decr:
1732ad81507eSRandall Stewart 	SCTPDBG(SCTP_DEBUG_TIMER1, "Timer now complete (type %d)\n",
1733ad81507eSRandall Stewart 	    tmr->type);
1734f8829a4aSRandall Stewart 	if (inp) {
1735f8829a4aSRandall Stewart 	}
1736f8829a4aSRandall Stewart }
1737f8829a4aSRandall Stewart 
1738ad81507eSRandall Stewart void
1739f8829a4aSRandall Stewart sctp_timer_start(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1740f8829a4aSRandall Stewart     struct sctp_nets *net)
1741f8829a4aSRandall Stewart {
1742f8829a4aSRandall Stewart 	int to_ticks;
1743f8829a4aSRandall Stewart 	struct sctp_timer *tmr;
1744f8829a4aSRandall Stewart 
1745139bc87fSRandall Stewart 	if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL))
1746ad81507eSRandall Stewart 		return;
1747f8829a4aSRandall Stewart 
1748f8829a4aSRandall Stewart 	to_ticks = 0;
1749f8829a4aSRandall Stewart 
1750f8829a4aSRandall Stewart 	tmr = NULL;
1751f8829a4aSRandall Stewart 	if (stcb) {
1752f8829a4aSRandall Stewart 		SCTP_TCB_LOCK_ASSERT(stcb);
1753f8829a4aSRandall Stewart 	}
1754f8829a4aSRandall Stewart 	switch (t_type) {
1755d61a0ae0SRandall Stewart 	case SCTP_TIMER_TYPE_ZERO_COPY:
1756d61a0ae0SRandall Stewart 		tmr = &inp->sctp_ep.zero_copy_timer;
1757d61a0ae0SRandall Stewart 		to_ticks = SCTP_ZERO_COPY_TICK_DELAY;
1758d61a0ae0SRandall Stewart 		break;
1759ad21a364SRandall Stewart 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:
1760ad21a364SRandall Stewart 		tmr = &inp->sctp_ep.zero_copy_sendq_timer;
1761ad21a364SRandall Stewart 		to_ticks = SCTP_ZERO_COPY_SENDQ_TICK_DELAY;
1762ad21a364SRandall Stewart 		break;
1763f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ADDR_WQ:
1764f8829a4aSRandall Stewart 		/* Only 1 tick away :-) */
1765f8829a4aSRandall Stewart 		tmr = &sctppcbinfo.addr_wq_timer;
176642551e99SRandall Stewart 		to_ticks = SCTP_ADDRESS_TICK_DELAY;
1767f8829a4aSRandall Stewart 		break;
1768f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ITERATOR:
1769f8829a4aSRandall Stewart 		{
1770f8829a4aSRandall Stewart 			struct sctp_iterator *it;
1771f8829a4aSRandall Stewart 
1772f8829a4aSRandall Stewart 			it = (struct sctp_iterator *)inp;
1773f8829a4aSRandall Stewart 			tmr = &it->tmr;
1774f8829a4aSRandall Stewart 			to_ticks = SCTP_ITERATOR_TICKS;
1775f8829a4aSRandall Stewart 		}
1776f8829a4aSRandall Stewart 		break;
1777f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SEND:
1778f8829a4aSRandall Stewart 		/* Here we use the RTO timer */
1779f8829a4aSRandall Stewart 		{
1780f8829a4aSRandall Stewart 			int rto_val;
1781f8829a4aSRandall Stewart 
1782f8829a4aSRandall Stewart 			if ((stcb == NULL) || (net == NULL)) {
1783ad81507eSRandall Stewart 				return;
1784f8829a4aSRandall Stewart 			}
1785f8829a4aSRandall Stewart 			tmr = &net->rxt_timer;
1786f8829a4aSRandall Stewart 			if (net->RTO == 0) {
1787f8829a4aSRandall Stewart 				rto_val = stcb->asoc.initial_rto;
1788f8829a4aSRandall Stewart 			} else {
1789f8829a4aSRandall Stewart 				rto_val = net->RTO;
1790f8829a4aSRandall Stewart 			}
1791f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(rto_val);
1792f8829a4aSRandall Stewart 		}
1793f8829a4aSRandall Stewart 		break;
1794f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INIT:
1795f8829a4aSRandall Stewart 		/*
1796f8829a4aSRandall Stewart 		 * Here we use the INIT timer default usually about 1
1797f8829a4aSRandall Stewart 		 * minute.
1798f8829a4aSRandall Stewart 		 */
1799f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
1800ad81507eSRandall Stewart 			return;
1801f8829a4aSRandall Stewart 		}
1802f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
1803f8829a4aSRandall Stewart 		if (net->RTO == 0) {
1804f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
1805f8829a4aSRandall Stewart 		} else {
1806f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
1807f8829a4aSRandall Stewart 		}
1808f8829a4aSRandall Stewart 		break;
1809f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_RECV:
1810f8829a4aSRandall Stewart 		/*
1811f8829a4aSRandall Stewart 		 * Here we use the Delayed-Ack timer value from the inp
1812f8829a4aSRandall Stewart 		 * ususually about 200ms.
1813f8829a4aSRandall Stewart 		 */
1814f8829a4aSRandall Stewart 		if (stcb == NULL) {
1815ad81507eSRandall Stewart 			return;
1816f8829a4aSRandall Stewart 		}
1817f8829a4aSRandall Stewart 		tmr = &stcb->asoc.dack_timer;
1818f8829a4aSRandall Stewart 		to_ticks = MSEC_TO_TICKS(stcb->asoc.delayed_ack);
1819f8829a4aSRandall Stewart 		break;
1820f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWN:
1821f8829a4aSRandall Stewart 		/* Here we use the RTO of the destination. */
1822f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
1823ad81507eSRandall Stewart 			return;
1824f8829a4aSRandall Stewart 		}
1825f8829a4aSRandall Stewart 		if (net->RTO == 0) {
1826f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
1827f8829a4aSRandall Stewart 		} else {
1828f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
1829f8829a4aSRandall Stewart 		}
1830f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
1831f8829a4aSRandall Stewart 		break;
1832f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_HEARTBEAT:
1833f8829a4aSRandall Stewart 		/*
1834f8829a4aSRandall Stewart 		 * the net is used here so that we can add in the RTO. Even
1835f8829a4aSRandall Stewart 		 * though we use a different timer. We also add the HB timer
1836f8829a4aSRandall Stewart 		 * PLUS a random jitter.
1837f8829a4aSRandall Stewart 		 */
1838ad81507eSRandall Stewart 		if ((inp == NULL) || (stcb == NULL)) {
1839ad81507eSRandall Stewart 			return;
1840ad81507eSRandall Stewart 		} else {
1841f8829a4aSRandall Stewart 			uint32_t rndval;
1842f8829a4aSRandall Stewart 			uint8_t this_random;
1843f8829a4aSRandall Stewart 			int cnt_of_unconf = 0;
1844f8829a4aSRandall Stewart 			struct sctp_nets *lnet;
1845f8829a4aSRandall Stewart 
1846f8829a4aSRandall Stewart 			TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
1847f8829a4aSRandall Stewart 				if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) &&
1848f8829a4aSRandall Stewart 				    (lnet->dest_state & SCTP_ADDR_REACHABLE)) {
1849f8829a4aSRandall Stewart 					cnt_of_unconf++;
1850f8829a4aSRandall Stewart 				}
1851f8829a4aSRandall Stewart 			}
1852f8829a4aSRandall Stewart 			if (cnt_of_unconf) {
18533c503c28SRandall Stewart 				net = lnet = NULL;
1854ad81507eSRandall Stewart 				(void)sctp_heartbeat_timer(inp, stcb, lnet, cnt_of_unconf);
1855f8829a4aSRandall Stewart 			}
1856f8829a4aSRandall Stewart 			if (stcb->asoc.hb_random_idx > 3) {
1857f8829a4aSRandall Stewart 				rndval = sctp_select_initial_TSN(&inp->sctp_ep);
1858f8829a4aSRandall Stewart 				memcpy(stcb->asoc.hb_random_values, &rndval,
1859f8829a4aSRandall Stewart 				    sizeof(stcb->asoc.hb_random_values));
1860f8829a4aSRandall Stewart 				stcb->asoc.hb_random_idx = 0;
186142551e99SRandall Stewart 			}
1862f8829a4aSRandall Stewart 			this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx];
1863f8829a4aSRandall Stewart 			stcb->asoc.hb_random_idx++;
1864f8829a4aSRandall Stewart 			stcb->asoc.hb_ect_randombit = 0;
1865f8829a4aSRandall Stewart 			/*
1866f8829a4aSRandall Stewart 			 * this_random will be 0 - 256 ms RTO is in ms.
1867f8829a4aSRandall Stewart 			 */
1868f8829a4aSRandall Stewart 			if ((stcb->asoc.hb_is_disabled) &&
1869f8829a4aSRandall Stewart 			    (cnt_of_unconf == 0)) {
1870ad81507eSRandall Stewart 				return;
1871f8829a4aSRandall Stewart 			}
1872f8829a4aSRandall Stewart 			if (net) {
1873f8829a4aSRandall Stewart 				int delay;
1874f8829a4aSRandall Stewart 
1875f8829a4aSRandall Stewart 				delay = stcb->asoc.heart_beat_delay;
1876f8829a4aSRandall Stewart 				TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
1877f8829a4aSRandall Stewart 					if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) &&
1878f8829a4aSRandall Stewart 					    ((lnet->dest_state & SCTP_ADDR_OUT_OF_SCOPE) == 0) &&
1879f8829a4aSRandall Stewart 					    (lnet->dest_state & SCTP_ADDR_REACHABLE)) {
1880f8829a4aSRandall Stewart 						delay = 0;
1881f8829a4aSRandall Stewart 					}
1882f8829a4aSRandall Stewart 				}
1883f8829a4aSRandall Stewart 				if (net->RTO == 0) {
1884f8829a4aSRandall Stewart 					/* Never been checked */
1885f8829a4aSRandall Stewart 					to_ticks = this_random + stcb->asoc.initial_rto + delay;
1886f8829a4aSRandall Stewart 				} else {
1887f8829a4aSRandall Stewart 					/* set rto_val to the ms */
1888f8829a4aSRandall Stewart 					to_ticks = delay + net->RTO + this_random;
1889f8829a4aSRandall Stewart 				}
1890f8829a4aSRandall Stewart 			} else {
1891f8829a4aSRandall Stewart 				if (cnt_of_unconf) {
1892f8829a4aSRandall Stewart 					to_ticks = this_random + stcb->asoc.initial_rto;
1893f8829a4aSRandall Stewart 				} else {
1894f8829a4aSRandall Stewart 					to_ticks = stcb->asoc.heart_beat_delay + this_random + stcb->asoc.initial_rto;
1895f8829a4aSRandall Stewart 				}
1896f8829a4aSRandall Stewart 			}
1897f8829a4aSRandall Stewart 			/*
1898f8829a4aSRandall Stewart 			 * Now we must convert the to_ticks that are now in
1899f8829a4aSRandall Stewart 			 * ms to ticks.
1900f8829a4aSRandall Stewart 			 */
1901f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(to_ticks);
1902f8829a4aSRandall Stewart 			tmr = &stcb->asoc.hb_timer;
1903f8829a4aSRandall Stewart 		}
1904f8829a4aSRandall Stewart 		break;
1905f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_COOKIE:
1906f8829a4aSRandall Stewart 		/*
1907f8829a4aSRandall Stewart 		 * Here we can use the RTO timer from the network since one
1908f8829a4aSRandall Stewart 		 * RTT was compelete. If a retran happened then we will be
1909f8829a4aSRandall Stewart 		 * using the RTO initial value.
1910f8829a4aSRandall Stewart 		 */
1911f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
1912ad81507eSRandall Stewart 			return;
1913f8829a4aSRandall Stewart 		}
1914f8829a4aSRandall Stewart 		if (net->RTO == 0) {
1915f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
1916f8829a4aSRandall Stewart 		} else {
1917f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
1918f8829a4aSRandall Stewart 		}
1919f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
1920f8829a4aSRandall Stewart 		break;
1921f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_NEWCOOKIE:
1922f8829a4aSRandall Stewart 		/*
1923f8829a4aSRandall Stewart 		 * nothing needed but the endpoint here ususually about 60
1924f8829a4aSRandall Stewart 		 * minutes.
1925f8829a4aSRandall Stewart 		 */
1926ad81507eSRandall Stewart 		if (inp == NULL) {
1927ad81507eSRandall Stewart 			return;
1928ad81507eSRandall Stewart 		}
1929f8829a4aSRandall Stewart 		tmr = &inp->sctp_ep.signature_change;
1930f8829a4aSRandall Stewart 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_SIGNATURE];
1931f8829a4aSRandall Stewart 		break;
1932f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASOCKILL:
1933f8829a4aSRandall Stewart 		if (stcb == NULL) {
1934ad81507eSRandall Stewart 			return;
1935f8829a4aSRandall Stewart 		}
1936f8829a4aSRandall Stewart 		tmr = &stcb->asoc.strreset_timer;
1937f8829a4aSRandall Stewart 		to_ticks = MSEC_TO_TICKS(SCTP_ASOC_KILL_TIMEOUT);
1938f8829a4aSRandall Stewart 		break;
1939f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INPKILL:
1940f8829a4aSRandall Stewart 		/*
1941f8829a4aSRandall Stewart 		 * The inp is setup to die. We re-use the signature_chage
1942f8829a4aSRandall Stewart 		 * timer since that has stopped and we are in the GONE
1943f8829a4aSRandall Stewart 		 * state.
1944f8829a4aSRandall Stewart 		 */
1945ad81507eSRandall Stewart 		if (inp == NULL) {
1946ad81507eSRandall Stewart 			return;
1947ad81507eSRandall Stewart 		}
1948f8829a4aSRandall Stewart 		tmr = &inp->sctp_ep.signature_change;
1949f8829a4aSRandall Stewart 		to_ticks = MSEC_TO_TICKS(SCTP_INP_KILL_TIMEOUT);
1950f8829a4aSRandall Stewart 		break;
1951f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_PATHMTURAISE:
1952f8829a4aSRandall Stewart 		/*
1953f8829a4aSRandall Stewart 		 * Here we use the value found in the EP for PMTU ususually
1954f8829a4aSRandall Stewart 		 * about 10 minutes.
1955f8829a4aSRandall Stewart 		 */
1956ad81507eSRandall Stewart 		if ((stcb == NULL) || (inp == NULL)) {
1957ad81507eSRandall Stewart 			return;
1958f8829a4aSRandall Stewart 		}
1959f8829a4aSRandall Stewart 		if (net == NULL) {
1960ad81507eSRandall Stewart 			return;
1961f8829a4aSRandall Stewart 		}
1962f8829a4aSRandall Stewart 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_PMTU];
1963f8829a4aSRandall Stewart 		tmr = &net->pmtu_timer;
1964f8829a4aSRandall Stewart 		break;
1965f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNACK:
1966f8829a4aSRandall Stewart 		/* Here we use the RTO of the destination */
1967f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
1968ad81507eSRandall Stewart 			return;
1969f8829a4aSRandall Stewart 		}
1970f8829a4aSRandall Stewart 		if (net->RTO == 0) {
1971f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
1972f8829a4aSRandall Stewart 		} else {
1973f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
1974f8829a4aSRandall Stewart 		}
1975f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
1976f8829a4aSRandall Stewart 		break;
1977f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:
1978f8829a4aSRandall Stewart 		/*
1979f8829a4aSRandall Stewart 		 * Here we use the endpoints shutdown guard timer usually
1980f8829a4aSRandall Stewart 		 * about 3 minutes.
1981f8829a4aSRandall Stewart 		 */
1982ad81507eSRandall Stewart 		if ((inp == NULL) || (stcb == NULL)) {
1983ad81507eSRandall Stewart 			return;
1984f8829a4aSRandall Stewart 		}
1985f8829a4aSRandall Stewart 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_MAXSHUTDOWN];
1986f8829a4aSRandall Stewart 		tmr = &stcb->asoc.shut_guard_timer;
1987f8829a4aSRandall Stewart 		break;
1988f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_STRRESET:
1989f8829a4aSRandall Stewart 		/*
1990f8829a4aSRandall Stewart 		 * Here the timer comes from the inp but its value is from
1991f8829a4aSRandall Stewart 		 * the RTO.
1992f8829a4aSRandall Stewart 		 */
1993f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
1994ad81507eSRandall Stewart 			return;
1995f8829a4aSRandall Stewart 		}
1996f8829a4aSRandall Stewart 		if (net->RTO == 0) {
1997f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
1998f8829a4aSRandall Stewart 		} else {
1999f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
2000f8829a4aSRandall Stewart 		}
2001f8829a4aSRandall Stewart 		tmr = &stcb->asoc.strreset_timer;
2002f8829a4aSRandall Stewart 		break;
2003f8829a4aSRandall Stewart 
2004f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_EARLYFR:
2005f8829a4aSRandall Stewart 		{
2006f8829a4aSRandall Stewart 			unsigned int msec;
2007f8829a4aSRandall Stewart 
2008f8829a4aSRandall Stewart 			if ((stcb == NULL) || (net == NULL)) {
2009ad81507eSRandall Stewart 				return;
2010f8829a4aSRandall Stewart 			}
2011f8829a4aSRandall Stewart 			if (net->flight_size > net->cwnd) {
2012f8829a4aSRandall Stewart 				/* no need to start */
2013ad81507eSRandall Stewart 				return;
2014f8829a4aSRandall Stewart 			}
2015f8829a4aSRandall Stewart 			SCTP_STAT_INCR(sctps_earlyfrstart);
2016f8829a4aSRandall Stewart 			if (net->lastsa == 0) {
2017f8829a4aSRandall Stewart 				/* Hmm no rtt estimate yet? */
2018f8829a4aSRandall Stewart 				msec = stcb->asoc.initial_rto >> 2;
2019f8829a4aSRandall Stewart 			} else {
2020f8829a4aSRandall Stewart 				msec = ((net->lastsa >> 2) + net->lastsv) >> 1;
2021f8829a4aSRandall Stewart 			}
2022f8829a4aSRandall Stewart 			if (msec < sctp_early_fr_msec) {
2023f8829a4aSRandall Stewart 				msec = sctp_early_fr_msec;
2024f8829a4aSRandall Stewart 				if (msec < SCTP_MINFR_MSEC_FLOOR) {
2025f8829a4aSRandall Stewart 					msec = SCTP_MINFR_MSEC_FLOOR;
2026f8829a4aSRandall Stewart 				}
2027f8829a4aSRandall Stewart 			}
2028f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(msec);
2029f8829a4aSRandall Stewart 			tmr = &net->fr_timer;
2030f8829a4aSRandall Stewart 		}
2031f8829a4aSRandall Stewart 		break;
2032f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASCONF:
2033f8829a4aSRandall Stewart 		/*
2034f8829a4aSRandall Stewart 		 * Here the timer comes from the inp but its value is from
2035f8829a4aSRandall Stewart 		 * the RTO.
2036f8829a4aSRandall Stewart 		 */
2037f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
2038ad81507eSRandall Stewart 			return;
2039f8829a4aSRandall Stewart 		}
2040f8829a4aSRandall Stewart 		if (net->RTO == 0) {
2041f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);
2042f8829a4aSRandall Stewart 		} else {
2043f8829a4aSRandall Stewart 			to_ticks = MSEC_TO_TICKS(net->RTO);
2044f8829a4aSRandall Stewart 		}
2045f8829a4aSRandall Stewart 		tmr = &stcb->asoc.asconf_timer;
2046f8829a4aSRandall Stewart 		break;
2047f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_AUTOCLOSE:
2048f8829a4aSRandall Stewart 		if (stcb == NULL) {
2049ad81507eSRandall Stewart 			return;
2050f8829a4aSRandall Stewart 		}
2051f8829a4aSRandall Stewart 		if (stcb->asoc.sctp_autoclose_ticks == 0) {
2052f8829a4aSRandall Stewart 			/*
2053f8829a4aSRandall Stewart 			 * Really an error since stcb is NOT set to
2054f8829a4aSRandall Stewart 			 * autoclose
2055f8829a4aSRandall Stewart 			 */
2056ad81507eSRandall Stewart 			return;
2057f8829a4aSRandall Stewart 		}
2058f8829a4aSRandall Stewart 		to_ticks = stcb->asoc.sctp_autoclose_ticks;
2059f8829a4aSRandall Stewart 		tmr = &stcb->asoc.autoclose_timer;
2060f8829a4aSRandall Stewart 		break;
2061f8829a4aSRandall Stewart 	default:
2062ad81507eSRandall Stewart 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n",
2063ad81507eSRandall Stewart 		    __FUNCTION__, t_type);
2064ad81507eSRandall Stewart 		return;
2065f8829a4aSRandall Stewart 		break;
2066f8829a4aSRandall Stewart 	};
2067f8829a4aSRandall Stewart 	if ((to_ticks <= 0) || (tmr == NULL)) {
2068ad81507eSRandall Stewart 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: %d:software error to_ticks:%d tmr:%p not set ??\n",
2069ad81507eSRandall Stewart 		    __FUNCTION__, t_type, to_ticks, tmr);
2070ad81507eSRandall Stewart 		return;
2071f8829a4aSRandall Stewart 	}
2072139bc87fSRandall Stewart 	if (SCTP_OS_TIMER_PENDING(&tmr->timer)) {
2073f8829a4aSRandall Stewart 		/*
2074f8829a4aSRandall Stewart 		 * we do NOT allow you to have it already running. if it is
2075f8829a4aSRandall Stewart 		 * we leave the current one up unchanged
2076f8829a4aSRandall Stewart 		 */
2077ad81507eSRandall Stewart 		return;
2078f8829a4aSRandall Stewart 	}
2079f8829a4aSRandall Stewart 	/* At this point we can proceed */
2080f8829a4aSRandall Stewart 	if (t_type == SCTP_TIMER_TYPE_SEND) {
2081f8829a4aSRandall Stewart 		stcb->asoc.num_send_timers_up++;
2082f8829a4aSRandall Stewart 	}
2083a5d547adSRandall Stewart 	tmr->stopped_from = 0;
2084f8829a4aSRandall Stewart 	tmr->type = t_type;
2085f8829a4aSRandall Stewart 	tmr->ep = (void *)inp;
2086f8829a4aSRandall Stewart 	tmr->tcb = (void *)stcb;
2087f8829a4aSRandall Stewart 	tmr->net = (void *)net;
2088f8829a4aSRandall Stewart 	tmr->self = (void *)tmr;
2089f8829a4aSRandall Stewart 	tmr->ticks = ticks;
2090ad81507eSRandall Stewart 	(void)SCTP_OS_TIMER_START(&tmr->timer, to_ticks, sctp_timeout_handler, tmr);
2091ad81507eSRandall Stewart 	return;
2092f8829a4aSRandall Stewart }
2093f8829a4aSRandall Stewart 
20946e55db54SRandall Stewart void
2095f8829a4aSRandall Stewart sctp_timer_stop(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb,
2096a5d547adSRandall Stewart     struct sctp_nets *net, uint32_t from)
2097f8829a4aSRandall Stewart {
2098f8829a4aSRandall Stewart 	struct sctp_timer *tmr;
2099f8829a4aSRandall Stewart 
2100f8829a4aSRandall Stewart 	if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) &&
2101f8829a4aSRandall Stewart 	    (inp == NULL))
21026e55db54SRandall Stewart 		return;
2103f8829a4aSRandall Stewart 
2104f8829a4aSRandall Stewart 	tmr = NULL;
2105f8829a4aSRandall Stewart 	if (stcb) {
2106f8829a4aSRandall Stewart 		SCTP_TCB_LOCK_ASSERT(stcb);
2107f8829a4aSRandall Stewart 	}
2108f8829a4aSRandall Stewart 	switch (t_type) {
2109d61a0ae0SRandall Stewart 	case SCTP_TIMER_TYPE_ZERO_COPY:
2110d61a0ae0SRandall Stewart 		tmr = &inp->sctp_ep.zero_copy_timer;
2111d61a0ae0SRandall Stewart 		break;
2112ad21a364SRandall Stewart 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:
2113ad21a364SRandall Stewart 		tmr = &inp->sctp_ep.zero_copy_sendq_timer;
2114ad21a364SRandall Stewart 		break;
2115f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ADDR_WQ:
2116f8829a4aSRandall Stewart 		tmr = &sctppcbinfo.addr_wq_timer;
2117f8829a4aSRandall Stewart 		break;
2118f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_EARLYFR:
2119f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21206e55db54SRandall Stewart 			return;
2121f8829a4aSRandall Stewart 		}
2122f8829a4aSRandall Stewart 		tmr = &net->fr_timer;
2123f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_earlyfrstop);
2124f8829a4aSRandall Stewart 		break;
2125f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ITERATOR:
2126f8829a4aSRandall Stewart 		{
2127f8829a4aSRandall Stewart 			struct sctp_iterator *it;
2128f8829a4aSRandall Stewart 
2129f8829a4aSRandall Stewart 			it = (struct sctp_iterator *)inp;
2130f8829a4aSRandall Stewart 			tmr = &it->tmr;
2131f8829a4aSRandall Stewart 		}
2132f8829a4aSRandall Stewart 		break;
2133f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SEND:
2134f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21356e55db54SRandall Stewart 			return;
2136f8829a4aSRandall Stewart 		}
2137f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
2138f8829a4aSRandall Stewart 		break;
2139f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INIT:
2140f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21416e55db54SRandall Stewart 			return;
2142f8829a4aSRandall Stewart 		}
2143f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
2144f8829a4aSRandall Stewart 		break;
2145f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_RECV:
2146f8829a4aSRandall Stewart 		if (stcb == NULL) {
21476e55db54SRandall Stewart 			return;
2148f8829a4aSRandall Stewart 		}
2149f8829a4aSRandall Stewart 		tmr = &stcb->asoc.dack_timer;
2150f8829a4aSRandall Stewart 		break;
2151f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWN:
2152f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21536e55db54SRandall Stewart 			return;
2154f8829a4aSRandall Stewart 		}
2155f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
2156f8829a4aSRandall Stewart 		break;
2157f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_HEARTBEAT:
2158f8829a4aSRandall Stewart 		if (stcb == NULL) {
21596e55db54SRandall Stewart 			return;
2160f8829a4aSRandall Stewart 		}
2161f8829a4aSRandall Stewart 		tmr = &stcb->asoc.hb_timer;
2162f8829a4aSRandall Stewart 		break;
2163f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_COOKIE:
2164f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21656e55db54SRandall Stewart 			return;
2166f8829a4aSRandall Stewart 		}
2167f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
2168f8829a4aSRandall Stewart 		break;
2169f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_NEWCOOKIE:
2170f8829a4aSRandall Stewart 		/* nothing needed but the endpoint here */
2171f8829a4aSRandall Stewart 		tmr = &inp->sctp_ep.signature_change;
2172f8829a4aSRandall Stewart 		/*
2173f8829a4aSRandall Stewart 		 * We re-use the newcookie timer for the INP kill timer. We
2174f8829a4aSRandall Stewart 		 * must assure that we do not kill it by accident.
2175f8829a4aSRandall Stewart 		 */
2176f8829a4aSRandall Stewart 		break;
2177f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASOCKILL:
2178f8829a4aSRandall Stewart 		/*
2179f8829a4aSRandall Stewart 		 * Stop the asoc kill timer.
2180f8829a4aSRandall Stewart 		 */
2181f8829a4aSRandall Stewart 		if (stcb == NULL) {
21826e55db54SRandall Stewart 			return;
2183f8829a4aSRandall Stewart 		}
2184f8829a4aSRandall Stewart 		tmr = &stcb->asoc.strreset_timer;
2185f8829a4aSRandall Stewart 		break;
2186f8829a4aSRandall Stewart 
2187f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_INPKILL:
2188f8829a4aSRandall Stewart 		/*
2189f8829a4aSRandall Stewart 		 * The inp is setup to die. We re-use the signature_chage
2190f8829a4aSRandall Stewart 		 * timer since that has stopped and we are in the GONE
2191f8829a4aSRandall Stewart 		 * state.
2192f8829a4aSRandall Stewart 		 */
2193f8829a4aSRandall Stewart 		tmr = &inp->sctp_ep.signature_change;
2194f8829a4aSRandall Stewart 		break;
2195f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_PATHMTURAISE:
2196f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
21976e55db54SRandall Stewart 			return;
2198f8829a4aSRandall Stewart 		}
2199f8829a4aSRandall Stewart 		tmr = &net->pmtu_timer;
2200f8829a4aSRandall Stewart 		break;
2201f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNACK:
2202f8829a4aSRandall Stewart 		if ((stcb == NULL) || (net == NULL)) {
22036e55db54SRandall Stewart 			return;
2204f8829a4aSRandall Stewart 		}
2205f8829a4aSRandall Stewart 		tmr = &net->rxt_timer;
2206f8829a4aSRandall Stewart 		break;
2207f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:
2208f8829a4aSRandall Stewart 		if (stcb == NULL) {
22096e55db54SRandall Stewart 			return;
2210f8829a4aSRandall Stewart 		}
2211f8829a4aSRandall Stewart 		tmr = &stcb->asoc.shut_guard_timer;
2212f8829a4aSRandall Stewart 		break;
2213f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_STRRESET:
2214f8829a4aSRandall Stewart 		if (stcb == NULL) {
22156e55db54SRandall Stewart 			return;
2216f8829a4aSRandall Stewart 		}
2217f8829a4aSRandall Stewart 		tmr = &stcb->asoc.strreset_timer;
2218f8829a4aSRandall Stewart 		break;
2219f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_ASCONF:
2220f8829a4aSRandall Stewart 		if (stcb == NULL) {
22216e55db54SRandall Stewart 			return;
2222f8829a4aSRandall Stewart 		}
2223f8829a4aSRandall Stewart 		tmr = &stcb->asoc.asconf_timer;
2224f8829a4aSRandall Stewart 		break;
2225f8829a4aSRandall Stewart 	case SCTP_TIMER_TYPE_AUTOCLOSE:
2226f8829a4aSRandall Stewart 		if (stcb == NULL) {
22276e55db54SRandall Stewart 			return;
2228f8829a4aSRandall Stewart 		}
2229f8829a4aSRandall Stewart 		tmr = &stcb->asoc.autoclose_timer;
2230f8829a4aSRandall Stewart 		break;
2231f8829a4aSRandall Stewart 	default:
2232ad81507eSRandall Stewart 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n",
2233ad81507eSRandall Stewart 		    __FUNCTION__, t_type);
2234f8829a4aSRandall Stewart 		break;
2235f8829a4aSRandall Stewart 	};
2236f8829a4aSRandall Stewart 	if (tmr == NULL) {
22376e55db54SRandall Stewart 		return;
2238f8829a4aSRandall Stewart 	}
2239f8829a4aSRandall Stewart 	if ((tmr->type != t_type) && tmr->type) {
2240f8829a4aSRandall Stewart 		/*
2241f8829a4aSRandall Stewart 		 * Ok we have a timer that is under joint use. Cookie timer
2242f8829a4aSRandall Stewart 		 * per chance with the SEND timer. We therefore are NOT
2243f8829a4aSRandall Stewart 		 * running the timer that the caller wants stopped.  So just
2244f8829a4aSRandall Stewart 		 * return.
2245f8829a4aSRandall Stewart 		 */
22466e55db54SRandall Stewart 		return;
2247f8829a4aSRandall Stewart 	}
2248ad81507eSRandall Stewart 	if ((t_type == SCTP_TIMER_TYPE_SEND) && (stcb != NULL)) {
2249f8829a4aSRandall Stewart 		stcb->asoc.num_send_timers_up--;
2250f8829a4aSRandall Stewart 		if (stcb->asoc.num_send_timers_up < 0) {
2251f8829a4aSRandall Stewart 			stcb->asoc.num_send_timers_up = 0;
2252f8829a4aSRandall Stewart 		}
2253f8829a4aSRandall Stewart 	}
2254f8829a4aSRandall Stewart 	tmr->self = NULL;
2255a5d547adSRandall Stewart 	tmr->stopped_from = from;
22566e55db54SRandall Stewart 	(void)SCTP_OS_TIMER_STOP(&tmr->timer);
22576e55db54SRandall Stewart 	return;
2258f8829a4aSRandall Stewart }
2259f8829a4aSRandall Stewart 
2260f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32
2261f8829a4aSRandall Stewart static uint32_t
2262f8829a4aSRandall Stewart update_adler32(uint32_t adler, uint8_t * buf, int32_t len)
2263f8829a4aSRandall Stewart {
2264f8829a4aSRandall Stewart 	uint32_t s1 = adler & 0xffff;
2265f8829a4aSRandall Stewart 	uint32_t s2 = (adler >> 16) & 0xffff;
2266f8829a4aSRandall Stewart 	int n;
2267f8829a4aSRandall Stewart 
2268f8829a4aSRandall Stewart 	for (n = 0; n < len; n++, buf++) {
2269f8829a4aSRandall Stewart 		/* s1 = (s1 + buf[n]) % BASE */
2270f8829a4aSRandall Stewart 		/* first we add */
2271f8829a4aSRandall Stewart 		s1 = (s1 + *buf);
2272f8829a4aSRandall Stewart 		/*
2273f8829a4aSRandall Stewart 		 * now if we need to, we do a mod by subtracting. It seems a
2274f8829a4aSRandall Stewart 		 * bit faster since I really will only ever do one subtract
2275f8829a4aSRandall Stewart 		 * at the MOST, since buf[n] is a max of 255.
2276f8829a4aSRandall Stewart 		 */
2277f8829a4aSRandall Stewart 		if (s1 >= SCTP_ADLER32_BASE) {
2278f8829a4aSRandall Stewart 			s1 -= SCTP_ADLER32_BASE;
2279f8829a4aSRandall Stewart 		}
2280f8829a4aSRandall Stewart 		/* s2 = (s2 + s1) % BASE */
2281f8829a4aSRandall Stewart 		/* first we add */
2282f8829a4aSRandall Stewart 		s2 = (s2 + s1);
2283f8829a4aSRandall Stewart 		/*
2284f8829a4aSRandall Stewart 		 * again, it is more efficent (it seems) to subtract since
2285f8829a4aSRandall Stewart 		 * the most s2 will ever be is (BASE-1 + BASE-1) in the
2286f8829a4aSRandall Stewart 		 * worse case. This would then be (2 * BASE) - 2, which will
2287f8829a4aSRandall Stewart 		 * still only do one subtract. On Intel this is much better
2288f8829a4aSRandall Stewart 		 * to do this way and avoid the divide. Have not -pg'd on
2289f8829a4aSRandall Stewart 		 * sparc.
2290f8829a4aSRandall Stewart 		 */
2291f8829a4aSRandall Stewart 		if (s2 >= SCTP_ADLER32_BASE) {
2292f8829a4aSRandall Stewart 			s2 -= SCTP_ADLER32_BASE;
2293f8829a4aSRandall Stewart 		}
2294f8829a4aSRandall Stewart 	}
2295f8829a4aSRandall Stewart 	/* Return the adler32 of the bytes buf[0..len-1] */
2296f8829a4aSRandall Stewart 	return ((s2 << 16) + s1);
2297f8829a4aSRandall Stewart }
2298f8829a4aSRandall Stewart 
2299f8829a4aSRandall Stewart #endif
2300f8829a4aSRandall Stewart 
2301f8829a4aSRandall Stewart 
2302f8829a4aSRandall Stewart uint32_t
2303f8829a4aSRandall Stewart sctp_calculate_len(struct mbuf *m)
2304f8829a4aSRandall Stewart {
2305f8829a4aSRandall Stewart 	uint32_t tlen = 0;
2306f8829a4aSRandall Stewart 	struct mbuf *at;
2307f8829a4aSRandall Stewart 
2308f8829a4aSRandall Stewart 	at = m;
2309f8829a4aSRandall Stewart 	while (at) {
2310139bc87fSRandall Stewart 		tlen += SCTP_BUF_LEN(at);
2311139bc87fSRandall Stewart 		at = SCTP_BUF_NEXT(at);
2312f8829a4aSRandall Stewart 	}
2313f8829a4aSRandall Stewart 	return (tlen);
2314f8829a4aSRandall Stewart }
2315f8829a4aSRandall Stewart 
2316f8829a4aSRandall Stewart #if defined(SCTP_WITH_NO_CSUM)
2317f8829a4aSRandall Stewart 
2318f8829a4aSRandall Stewart uint32_t
2319f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset)
2320f8829a4aSRandall Stewart {
2321f8829a4aSRandall Stewart 	/*
2322f8829a4aSRandall Stewart 	 * given a mbuf chain with a packetheader offset by 'offset'
2323f8829a4aSRandall Stewart 	 * pointing at a sctphdr (with csum set to 0) go through the chain
23244c9179adSRandall Stewart 	 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
23254c9179adSRandall Stewart 	 * has a side bonus as it will calculate the total length of the
23264c9179adSRandall Stewart 	 * mbuf chain. Note: if offset is greater than the total mbuf
23274c9179adSRandall Stewart 	 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2328f8829a4aSRandall Stewart 	 */
2329f8829a4aSRandall Stewart 	if (pktlen == NULL)
2330f8829a4aSRandall Stewart 		return (0);
2331f8829a4aSRandall Stewart 	*pktlen = sctp_calculate_len(m);
2332f8829a4aSRandall Stewart 	return (0);
2333f8829a4aSRandall Stewart }
2334f8829a4aSRandall Stewart 
2335f8829a4aSRandall Stewart #elif defined(SCTP_USE_INCHKSUM)
2336f8829a4aSRandall Stewart 
2337f8829a4aSRandall Stewart #include <machine/in_cksum.h>
2338f8829a4aSRandall Stewart 
2339f8829a4aSRandall Stewart uint32_t
2340f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset)
2341f8829a4aSRandall Stewart {
2342f8829a4aSRandall Stewart 	/*
2343f8829a4aSRandall Stewart 	 * given a mbuf chain with a packetheader offset by 'offset'
2344f8829a4aSRandall Stewart 	 * pointing at a sctphdr (with csum set to 0) go through the chain
23454c9179adSRandall Stewart 	 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
23464c9179adSRandall Stewart 	 * has a side bonus as it will calculate the total length of the
23474c9179adSRandall Stewart 	 * mbuf chain. Note: if offset is greater than the total mbuf
23484c9179adSRandall Stewart 	 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2349f8829a4aSRandall Stewart 	 */
2350f8829a4aSRandall Stewart 	int32_t tlen = 0;
2351f8829a4aSRandall Stewart 	struct mbuf *at;
2352f8829a4aSRandall Stewart 	uint32_t the_sum, retsum;
2353f8829a4aSRandall Stewart 
2354f8829a4aSRandall Stewart 	at = m;
2355f8829a4aSRandall Stewart 	while (at) {
2356139bc87fSRandall Stewart 		tlen += SCTP_BUF_LEN(at);
2357139bc87fSRandall Stewart 		at = SCTP_BUF_NEXT(at);
2358f8829a4aSRandall Stewart 	}
2359f8829a4aSRandall Stewart 	the_sum = (uint32_t) (in_cksum_skip(m, tlen, offset));
2360f8829a4aSRandall Stewart 	if (pktlen != NULL)
2361f8829a4aSRandall Stewart 		*pktlen = (tlen - offset);
2362f8829a4aSRandall Stewart 	retsum = htons(the_sum);
2363f8829a4aSRandall Stewart 	return (the_sum);
2364f8829a4aSRandall Stewart }
2365f8829a4aSRandall Stewart 
2366f8829a4aSRandall Stewart #else
2367f8829a4aSRandall Stewart 
2368f8829a4aSRandall Stewart uint32_t
2369f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset)
2370f8829a4aSRandall Stewart {
2371f8829a4aSRandall Stewart 	/*
2372f8829a4aSRandall Stewart 	 * given a mbuf chain with a packetheader offset by 'offset'
2373f8829a4aSRandall Stewart 	 * pointing at a sctphdr (with csum set to 0) go through the chain
23744c9179adSRandall Stewart 	 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
23754c9179adSRandall Stewart 	 * has a side bonus as it will calculate the total length of the
23764c9179adSRandall Stewart 	 * mbuf chain. Note: if offset is greater than the total mbuf
23774c9179adSRandall Stewart 	 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2378f8829a4aSRandall Stewart 	 */
2379f8829a4aSRandall Stewart 	int32_t tlen = 0;
2380f8829a4aSRandall Stewart 
2381f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32
2382f8829a4aSRandall Stewart 	uint32_t base = 1L;
2383f8829a4aSRandall Stewart 
2384f8829a4aSRandall Stewart #else
2385f8829a4aSRandall Stewart 	uint32_t base = 0xffffffff;
2386f8829a4aSRandall Stewart 
23874c9179adSRandall Stewart #endif
2388f8829a4aSRandall Stewart 	struct mbuf *at;
2389f8829a4aSRandall Stewart 
2390f8829a4aSRandall Stewart 	at = m;
2391f8829a4aSRandall Stewart 	/* find the correct mbuf and offset into mbuf */
2392139bc87fSRandall Stewart 	while ((at != NULL) && (offset > (uint32_t) SCTP_BUF_LEN(at))) {
2393139bc87fSRandall Stewart 		offset -= SCTP_BUF_LEN(at);	/* update remaining offset
2394139bc87fSRandall Stewart 						 * left */
2395139bc87fSRandall Stewart 		at = SCTP_BUF_NEXT(at);
2396f8829a4aSRandall Stewart 	}
2397f8829a4aSRandall Stewart 	while (at != NULL) {
2398139bc87fSRandall Stewart 		if ((SCTP_BUF_LEN(at) - offset) > 0) {
2399f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32
2400f8829a4aSRandall Stewart 			base = update_adler32(base,
2401139bc87fSRandall Stewart 			    (unsigned char *)(SCTP_BUF_AT(at, offset)),
2402139bc87fSRandall Stewart 			    (unsigned int)(SCTP_BUF_LEN(at) - offset));
2403f8829a4aSRandall Stewart #else
2404139bc87fSRandall Stewart 			if ((SCTP_BUF_LEN(at) - offset) < 4) {
2405f8829a4aSRandall Stewart 				/* Use old method if less than 4 bytes */
2406f8829a4aSRandall Stewart 				base = old_update_crc32(base,
2407139bc87fSRandall Stewart 				    (unsigned char *)(SCTP_BUF_AT(at, offset)),
2408139bc87fSRandall Stewart 				    (unsigned int)(SCTP_BUF_LEN(at) - offset));
2409f8829a4aSRandall Stewart 			} else {
2410f8829a4aSRandall Stewart 				base = update_crc32(base,
2411139bc87fSRandall Stewart 				    (unsigned char *)(SCTP_BUF_AT(at, offset)),
2412139bc87fSRandall Stewart 				    (unsigned int)(SCTP_BUF_LEN(at) - offset));
2413f8829a4aSRandall Stewart 			}
24144c9179adSRandall Stewart #endif
2415139bc87fSRandall Stewart 			tlen += SCTP_BUF_LEN(at) - offset;
2416f8829a4aSRandall Stewart 			/* we only offset once into the first mbuf */
2417f8829a4aSRandall Stewart 		}
2418f8829a4aSRandall Stewart 		if (offset) {
24194c9179adSRandall Stewart 			if (offset < (uint32_t) SCTP_BUF_LEN(at))
2420f8829a4aSRandall Stewart 				offset = 0;
2421f8829a4aSRandall Stewart 			else
2422139bc87fSRandall Stewart 				offset -= SCTP_BUF_LEN(at);
2423f8829a4aSRandall Stewart 		}
2424139bc87fSRandall Stewart 		at = SCTP_BUF_NEXT(at);
2425f8829a4aSRandall Stewart 	}
2426f8829a4aSRandall Stewart 	if (pktlen != NULL) {
2427f8829a4aSRandall Stewart 		*pktlen = tlen;
2428f8829a4aSRandall Stewart 	}
2429f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32
2430f8829a4aSRandall Stewart 	/* Adler32 */
2431f8829a4aSRandall Stewart 	base = htonl(base);
2432f8829a4aSRandall Stewart #else
2433f8829a4aSRandall Stewart 	/* CRC-32c */
2434f8829a4aSRandall Stewart 	base = sctp_csum_finalize(base);
2435f8829a4aSRandall Stewart #endif
2436f8829a4aSRandall Stewart 	return (base);
2437f8829a4aSRandall Stewart }
2438f8829a4aSRandall Stewart 
2439f8829a4aSRandall Stewart 
2440f8829a4aSRandall Stewart #endif
2441f8829a4aSRandall Stewart 
2442f8829a4aSRandall Stewart void
2443f8829a4aSRandall Stewart sctp_mtu_size_reset(struct sctp_inpcb *inp,
244444b7479bSRandall Stewart     struct sctp_association *asoc, uint32_t mtu)
2445f8829a4aSRandall Stewart {
2446f8829a4aSRandall Stewart 	/*
2447f8829a4aSRandall Stewart 	 * Reset the P-MTU size on this association, this involves changing
2448f8829a4aSRandall Stewart 	 * the asoc MTU, going through ANY chunk+overhead larger than mtu to
2449f8829a4aSRandall Stewart 	 * allow the DF flag to be cleared.
2450f8829a4aSRandall Stewart 	 */
2451f8829a4aSRandall Stewart 	struct sctp_tmit_chunk *chk;
2452f8829a4aSRandall Stewart 	unsigned int eff_mtu, ovh;
2453f8829a4aSRandall Stewart 
245417205eccSRandall Stewart #ifdef SCTP_PRINT_FOR_B_AND_M
2455ad81507eSRandall Stewart 	SCTP_PRINTF("sctp_mtu_size_reset(%p, asoc:%p mtu:%d\n",
245617205eccSRandall Stewart 	    inp, asoc, mtu);
245717205eccSRandall Stewart #endif
2458f8829a4aSRandall Stewart 	asoc->smallest_mtu = mtu;
2459f8829a4aSRandall Stewart 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
2460f8829a4aSRandall Stewart 		ovh = SCTP_MIN_OVERHEAD;
2461f8829a4aSRandall Stewart 	} else {
2462f8829a4aSRandall Stewart 		ovh = SCTP_MIN_V4_OVERHEAD;
2463f8829a4aSRandall Stewart 	}
2464f8829a4aSRandall Stewart 	eff_mtu = mtu - ovh;
2465f8829a4aSRandall Stewart 	TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) {
2466f8829a4aSRandall Stewart 
2467f8829a4aSRandall Stewart 		if (chk->send_size > eff_mtu) {
2468f8829a4aSRandall Stewart 			chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
2469f8829a4aSRandall Stewart 		}
2470f8829a4aSRandall Stewart 	}
2471f8829a4aSRandall Stewart 	TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {
2472f8829a4aSRandall Stewart 		if (chk->send_size > eff_mtu) {
2473f8829a4aSRandall Stewart 			chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
2474f8829a4aSRandall Stewart 		}
2475f8829a4aSRandall Stewart 	}
2476f8829a4aSRandall Stewart }
2477f8829a4aSRandall Stewart 
2478f8829a4aSRandall Stewart 
2479f8829a4aSRandall Stewart /*
2480f8829a4aSRandall Stewart  * given an association and starting time of the current RTT period return
2481f42a358aSRandall Stewart  * RTO in number of msecs net should point to the current network
2482f8829a4aSRandall Stewart  */
2483f8829a4aSRandall Stewart uint32_t
2484f8829a4aSRandall Stewart sctp_calculate_rto(struct sctp_tcb *stcb,
2485f8829a4aSRandall Stewart     struct sctp_association *asoc,
2486f8829a4aSRandall Stewart     struct sctp_nets *net,
2487f8829a4aSRandall Stewart     struct timeval *old)
2488f8829a4aSRandall Stewart {
2489f8829a4aSRandall Stewart 	/*
2490f8829a4aSRandall Stewart 	 * given an association and the starting time of the current RTT
2491f42a358aSRandall Stewart 	 * period (in value1/value2) return RTO in number of msecs.
2492f8829a4aSRandall Stewart 	 */
2493f8829a4aSRandall Stewart 	int calc_time = 0;
2494f8829a4aSRandall Stewart 	int o_calctime;
24955e54f665SRandall Stewart 	uint32_t new_rto = 0;
2496f8829a4aSRandall Stewart 	int first_measure = 0;
2497f8829a4aSRandall Stewart 	struct timeval now;
2498f8829a4aSRandall Stewart 
2499f8829a4aSRandall Stewart 	/************************/
2500f8829a4aSRandall Stewart 	/* 1. calculate new RTT */
2501f8829a4aSRandall Stewart 	/************************/
2502f8829a4aSRandall Stewart 	/* get the current time */
25036e55db54SRandall Stewart 	(void)SCTP_GETTIME_TIMEVAL(&now);
2504f8829a4aSRandall Stewart 	/* compute the RTT value */
2505f8829a4aSRandall Stewart 	if ((u_long)now.tv_sec > (u_long)old->tv_sec) {
2506f8829a4aSRandall Stewart 		calc_time = ((u_long)now.tv_sec - (u_long)old->tv_sec) * 1000;
2507f8829a4aSRandall Stewart 		if ((u_long)now.tv_usec > (u_long)old->tv_usec) {
2508f8829a4aSRandall Stewart 			calc_time += (((u_long)now.tv_usec -
2509f8829a4aSRandall Stewart 			    (u_long)old->tv_usec) / 1000);
2510f8829a4aSRandall Stewart 		} else if ((u_long)now.tv_usec < (u_long)old->tv_usec) {
2511f8829a4aSRandall Stewart 			/* Borrow 1,000ms from current calculation */
2512f8829a4aSRandall Stewart 			calc_time -= 1000;
2513f8829a4aSRandall Stewart 			/* Add in the slop over */
2514f8829a4aSRandall Stewart 			calc_time += ((int)now.tv_usec / 1000);
2515f8829a4aSRandall Stewart 			/* Add in the pre-second ms's */
2516f8829a4aSRandall Stewart 			calc_time += (((int)1000000 - (int)old->tv_usec) / 1000);
2517f8829a4aSRandall Stewart 		}
2518f8829a4aSRandall Stewart 	} else if ((u_long)now.tv_sec == (u_long)old->tv_sec) {
2519f8829a4aSRandall Stewart 		if ((u_long)now.tv_usec > (u_long)old->tv_usec) {
2520f8829a4aSRandall Stewart 			calc_time = ((u_long)now.tv_usec -
2521f8829a4aSRandall Stewart 			    (u_long)old->tv_usec) / 1000;
2522f8829a4aSRandall Stewart 		} else if ((u_long)now.tv_usec < (u_long)old->tv_usec) {
2523f8829a4aSRandall Stewart 			/* impossible .. garbage in nothing out */
25245e54f665SRandall Stewart 			goto calc_rto;
2525a5d547adSRandall Stewart 		} else if ((u_long)now.tv_usec == (u_long)old->tv_usec) {
2526a5d547adSRandall Stewart 			/*
2527a5d547adSRandall Stewart 			 * We have to have 1 usec :-D this must be the
2528a5d547adSRandall Stewart 			 * loopback.
2529a5d547adSRandall Stewart 			 */
2530a5d547adSRandall Stewart 			calc_time = 1;
2531f8829a4aSRandall Stewart 		} else {
2532f8829a4aSRandall Stewart 			/* impossible .. garbage in nothing out */
25335e54f665SRandall Stewart 			goto calc_rto;
2534f8829a4aSRandall Stewart 		}
2535f8829a4aSRandall Stewart 	} else {
2536f8829a4aSRandall Stewart 		/* Clock wrapped? */
25375e54f665SRandall Stewart 		goto calc_rto;
2538f8829a4aSRandall Stewart 	}
2539f8829a4aSRandall Stewart 	/***************************/
2540f8829a4aSRandall Stewart 	/* 2. update RTTVAR & SRTT */
2541f8829a4aSRandall Stewart 	/***************************/
2542f8829a4aSRandall Stewart 	o_calctime = calc_time;
2543f8829a4aSRandall Stewart 	/* this is Van Jacobson's integer version */
25449a972525SRandall Stewart 	if (net->RTO_measured) {
2545108df27cSRandall Stewart 		calc_time -= (net->lastsa >> SCTP_RTT_SHIFT);	/* take away 1/8th when
2546108df27cSRandall Stewart 								 * shift=3 */
254780fefe0aSRandall Stewart 		if (sctp_logging_level & SCTP_RTTVAR_LOGGING_ENABLE) {
2548f8829a4aSRandall Stewart 			rto_logging(net, SCTP_LOG_RTTVAR);
254980fefe0aSRandall Stewart 		}
2550f8829a4aSRandall Stewart 		net->prev_rtt = o_calctime;
2551108df27cSRandall Stewart 		net->lastsa += calc_time;	/* add 7/8th into sa when
2552108df27cSRandall Stewart 						 * shift=3 */
2553f8829a4aSRandall Stewart 		if (calc_time < 0) {
2554f8829a4aSRandall Stewart 			calc_time = -calc_time;
2555f8829a4aSRandall Stewart 		}
2556108df27cSRandall Stewart 		calc_time -= (net->lastsv >> SCTP_RTT_VAR_SHIFT);	/* take away 1/4 when
2557108df27cSRandall Stewart 									 * VAR shift=2 */
2558f8829a4aSRandall Stewart 		net->lastsv += calc_time;
2559f8829a4aSRandall Stewart 		if (net->lastsv == 0) {
2560f8829a4aSRandall Stewart 			net->lastsv = SCTP_CLOCK_GRANULARITY;
2561f8829a4aSRandall Stewart 		}
2562f8829a4aSRandall Stewart 	} else {
2563f8829a4aSRandall Stewart 		/* First RTO measurment */
25649a972525SRandall Stewart 		net->RTO_measured = 1;
2565108df27cSRandall Stewart 		net->lastsa = calc_time << SCTP_RTT_SHIFT;	/* Multiply by 8 when
2566108df27cSRandall Stewart 								 * shift=3 */
2567108df27cSRandall Stewart 		net->lastsv = calc_time;
2568108df27cSRandall Stewart 		if (net->lastsv == 0) {
2569108df27cSRandall Stewart 			net->lastsv = SCTP_CLOCK_GRANULARITY;
2570108df27cSRandall Stewart 		}
2571f8829a4aSRandall Stewart 		first_measure = 1;
2572f8829a4aSRandall Stewart 		net->prev_rtt = o_calctime;
257380fefe0aSRandall Stewart 		if (sctp_logging_level & SCTP_RTTVAR_LOGGING_ENABLE) {
2574f8829a4aSRandall Stewart 			rto_logging(net, SCTP_LOG_INITIAL_RTT);
257580fefe0aSRandall Stewart 		}
2576f8829a4aSRandall Stewart 	}
25775e54f665SRandall Stewart calc_rto:
2578108df27cSRandall Stewart 	new_rto = (net->lastsa >> SCTP_RTT_SHIFT) + net->lastsv;
2579f8829a4aSRandall Stewart 	if ((new_rto > SCTP_SAT_NETWORK_MIN) &&
2580f8829a4aSRandall Stewart 	    (stcb->asoc.sat_network_lockout == 0)) {
2581f8829a4aSRandall Stewart 		stcb->asoc.sat_network = 1;
2582f8829a4aSRandall Stewart 	} else if ((!first_measure) && stcb->asoc.sat_network) {
2583f8829a4aSRandall Stewart 		stcb->asoc.sat_network = 0;
2584f8829a4aSRandall Stewart 		stcb->asoc.sat_network_lockout = 1;
2585f8829a4aSRandall Stewart 	}
2586f8829a4aSRandall Stewart 	/* bound it, per C6/C7 in Section 5.3.1 */
2587f8829a4aSRandall Stewart 	if (new_rto < stcb->asoc.minrto) {
2588f8829a4aSRandall Stewart 		new_rto = stcb->asoc.minrto;
2589f8829a4aSRandall Stewart 	}
2590f8829a4aSRandall Stewart 	if (new_rto > stcb->asoc.maxrto) {
2591f8829a4aSRandall Stewart 		new_rto = stcb->asoc.maxrto;
2592f8829a4aSRandall Stewart 	}
25935e54f665SRandall Stewart 	/* we are now returning the RTO */
25945e54f665SRandall Stewart 	return (new_rto);
2595f8829a4aSRandall Stewart }
2596f8829a4aSRandall Stewart 
2597f8829a4aSRandall Stewart /*
2598f8829a4aSRandall Stewart  * return a pointer to a contiguous piece of data from the given mbuf chain
2599f8829a4aSRandall Stewart  * starting at 'off' for 'len' bytes.  If the desired piece spans more than
2600f8829a4aSRandall Stewart  * one mbuf, a copy is made at 'ptr'. caller must ensure that the buffer size
2601f8829a4aSRandall Stewart  * is >= 'len' returns NULL if there there isn't 'len' bytes in the chain.
2602f8829a4aSRandall Stewart  */
260372fb6fdbSRandall Stewart caddr_t
2604f8829a4aSRandall Stewart sctp_m_getptr(struct mbuf *m, int off, int len, uint8_t * in_ptr)
2605f8829a4aSRandall Stewart {
2606f8829a4aSRandall Stewart 	uint32_t count;
2607f8829a4aSRandall Stewart 	uint8_t *ptr;
2608f8829a4aSRandall Stewart 
2609f8829a4aSRandall Stewart 	ptr = in_ptr;
2610f8829a4aSRandall Stewart 	if ((off < 0) || (len <= 0))
2611f8829a4aSRandall Stewart 		return (NULL);
2612f8829a4aSRandall Stewart 
2613f8829a4aSRandall Stewart 	/* find the desired start location */
2614f8829a4aSRandall Stewart 	while ((m != NULL) && (off > 0)) {
2615139bc87fSRandall Stewart 		if (off < SCTP_BUF_LEN(m))
2616f8829a4aSRandall Stewart 			break;
2617139bc87fSRandall Stewart 		off -= SCTP_BUF_LEN(m);
2618139bc87fSRandall Stewart 		m = SCTP_BUF_NEXT(m);
2619f8829a4aSRandall Stewart 	}
2620f8829a4aSRandall Stewart 	if (m == NULL)
2621f8829a4aSRandall Stewart 		return (NULL);
2622f8829a4aSRandall Stewart 
2623f8829a4aSRandall Stewart 	/* is the current mbuf large enough (eg. contiguous)? */
2624139bc87fSRandall Stewart 	if ((SCTP_BUF_LEN(m) - off) >= len) {
2625f8829a4aSRandall Stewart 		return (mtod(m, caddr_t)+off);
2626f8829a4aSRandall Stewart 	} else {
2627f8829a4aSRandall Stewart 		/* else, it spans more than one mbuf, so save a temp copy... */
2628f8829a4aSRandall Stewart 		while ((m != NULL) && (len > 0)) {
2629139bc87fSRandall Stewart 			count = min(SCTP_BUF_LEN(m) - off, len);
2630f8829a4aSRandall Stewart 			bcopy(mtod(m, caddr_t)+off, ptr, count);
2631f8829a4aSRandall Stewart 			len -= count;
2632f8829a4aSRandall Stewart 			ptr += count;
2633f8829a4aSRandall Stewart 			off = 0;
2634139bc87fSRandall Stewart 			m = SCTP_BUF_NEXT(m);
2635f8829a4aSRandall Stewart 		}
2636f8829a4aSRandall Stewart 		if ((m == NULL) && (len > 0))
2637f8829a4aSRandall Stewart 			return (NULL);
2638f8829a4aSRandall Stewart 		else
2639f8829a4aSRandall Stewart 			return ((caddr_t)in_ptr);
2640f8829a4aSRandall Stewart 	}
2641f8829a4aSRandall Stewart }
2642f8829a4aSRandall Stewart 
2643f8829a4aSRandall Stewart 
264444b7479bSRandall Stewart 
2645f8829a4aSRandall Stewart struct sctp_paramhdr *
2646f8829a4aSRandall Stewart sctp_get_next_param(struct mbuf *m,
2647f8829a4aSRandall Stewart     int offset,
2648f8829a4aSRandall Stewart     struct sctp_paramhdr *pull,
2649f8829a4aSRandall Stewart     int pull_limit)
2650f8829a4aSRandall Stewart {
2651f8829a4aSRandall Stewart 	/* This just provides a typed signature to Peter's Pull routine */
2652f8829a4aSRandall Stewart 	return ((struct sctp_paramhdr *)sctp_m_getptr(m, offset, pull_limit,
2653f8829a4aSRandall Stewart 	    (uint8_t *) pull));
2654f8829a4aSRandall Stewart }
2655f8829a4aSRandall Stewart 
2656f8829a4aSRandall Stewart 
2657f8829a4aSRandall Stewart int
2658f8829a4aSRandall Stewart sctp_add_pad_tombuf(struct mbuf *m, int padlen)
2659f8829a4aSRandall Stewart {
2660f8829a4aSRandall Stewart 	/*
2661f8829a4aSRandall Stewart 	 * add padlen bytes of 0 filled padding to the end of the mbuf. If
2662f8829a4aSRandall Stewart 	 * padlen is > 3 this routine will fail.
2663f8829a4aSRandall Stewart 	 */
2664f8829a4aSRandall Stewart 	uint8_t *dp;
2665f8829a4aSRandall Stewart 	int i;
2666f8829a4aSRandall Stewart 
2667f8829a4aSRandall Stewart 	if (padlen > 3) {
2668f8829a4aSRandall Stewart 		return (ENOBUFS);
2669f8829a4aSRandall Stewart 	}
2670f8829a4aSRandall Stewart 	if (M_TRAILINGSPACE(m)) {
2671f8829a4aSRandall Stewart 		/*
2672f8829a4aSRandall Stewart 		 * The easy way. We hope the majority of the time we hit
2673f8829a4aSRandall Stewart 		 * here :)
2674f8829a4aSRandall Stewart 		 */
2675139bc87fSRandall Stewart 		dp = (uint8_t *) (mtod(m, caddr_t)+SCTP_BUF_LEN(m));
2676139bc87fSRandall Stewart 		SCTP_BUF_LEN(m) += padlen;
2677f8829a4aSRandall Stewart 	} else {
2678f8829a4aSRandall Stewart 		/* Hard way we must grow the mbuf */
2679f8829a4aSRandall Stewart 		struct mbuf *tmp;
2680f8829a4aSRandall Stewart 
2681f8829a4aSRandall Stewart 		tmp = sctp_get_mbuf_for_msg(padlen, 0, M_DONTWAIT, 1, MT_DATA);
2682f8829a4aSRandall Stewart 		if (tmp == NULL) {
2683f8829a4aSRandall Stewart 			/* Out of space GAK! we are in big trouble. */
2684f8829a4aSRandall Stewart 			return (ENOSPC);
2685f8829a4aSRandall Stewart 		}
2686f8829a4aSRandall Stewart 		/* setup and insert in middle */
2687139bc87fSRandall Stewart 		SCTP_BUF_NEXT(tmp) = SCTP_BUF_NEXT(m);
2688139bc87fSRandall Stewart 		SCTP_BUF_LEN(tmp) = padlen;
2689139bc87fSRandall Stewart 		SCTP_BUF_NEXT(m) = tmp;
2690f8829a4aSRandall Stewart 		dp = mtod(tmp, uint8_t *);
2691f8829a4aSRandall Stewart 	}
2692f8829a4aSRandall Stewart 	/* zero out the pad */
2693f8829a4aSRandall Stewart 	for (i = 0; i < padlen; i++) {
2694f8829a4aSRandall Stewart 		*dp = 0;
2695f8829a4aSRandall Stewart 		dp++;
2696f8829a4aSRandall Stewart 	}
2697f8829a4aSRandall Stewart 	return (0);
2698f8829a4aSRandall Stewart }
2699f8829a4aSRandall Stewart 
2700f8829a4aSRandall Stewart int
2701f8829a4aSRandall Stewart sctp_pad_lastmbuf(struct mbuf *m, int padval, struct mbuf *last_mbuf)
2702f8829a4aSRandall Stewart {
2703f8829a4aSRandall Stewart 	/* find the last mbuf in chain and pad it */
2704f8829a4aSRandall Stewart 	struct mbuf *m_at;
2705f8829a4aSRandall Stewart 
2706f8829a4aSRandall Stewart 	m_at = m;
2707f8829a4aSRandall Stewart 	if (last_mbuf) {
2708f8829a4aSRandall Stewart 		return (sctp_add_pad_tombuf(last_mbuf, padval));
2709f8829a4aSRandall Stewart 	} else {
2710f8829a4aSRandall Stewart 		while (m_at) {
2711139bc87fSRandall Stewart 			if (SCTP_BUF_NEXT(m_at) == NULL) {
2712f8829a4aSRandall Stewart 				return (sctp_add_pad_tombuf(m_at, padval));
2713f8829a4aSRandall Stewart 			}
2714139bc87fSRandall Stewart 			m_at = SCTP_BUF_NEXT(m_at);
2715f8829a4aSRandall Stewart 		}
2716f8829a4aSRandall Stewart 	}
2717f8829a4aSRandall Stewart 	return (EFAULT);
2718f8829a4aSRandall Stewart }
2719f8829a4aSRandall Stewart 
2720f8829a4aSRandall Stewart int sctp_asoc_change_wake = 0;
2721f8829a4aSRandall Stewart 
2722f8829a4aSRandall Stewart static void
2723f8829a4aSRandall Stewart sctp_notify_assoc_change(uint32_t event, struct sctp_tcb *stcb,
2724f8829a4aSRandall Stewart     uint32_t error, void *data)
2725f8829a4aSRandall Stewart {
2726f8829a4aSRandall Stewart 	struct mbuf *m_notify;
2727f8829a4aSRandall Stewart 	struct sctp_assoc_change *sac;
2728f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
2729f8829a4aSRandall Stewart 
2730f8829a4aSRandall Stewart 	/*
2731f8829a4aSRandall Stewart 	 * First if we are are going down dump everything we can to the
2732f8829a4aSRandall Stewart 	 * socket rcv queue.
2733f8829a4aSRandall Stewart 	 */
2734f8829a4aSRandall Stewart 
2735ad81507eSRandall Stewart 	if ((stcb == NULL) ||
2736ad81507eSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
2737f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
2738f8829a4aSRandall Stewart 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)
2739f8829a4aSRandall Stewart 	    ) {
2740f8829a4aSRandall Stewart 		/* If the socket is gone we are out of here */
2741f8829a4aSRandall Stewart 		return;
2742f8829a4aSRandall Stewart 	}
2743f8829a4aSRandall Stewart 	/*
2744f8829a4aSRandall Stewart 	 * For TCP model AND UDP connected sockets we will send an error up
2745f8829a4aSRandall Stewart 	 * when an ABORT comes in.
2746f8829a4aSRandall Stewart 	 */
2747f8829a4aSRandall Stewart 	if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
2748f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) &&
27493c503c28SRandall Stewart 	    ((event == SCTP_COMM_LOST) || (event == SCTP_CANT_STR_ASSOC))) {
275044b7479bSRandall Stewart 		if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_WAIT)
275144b7479bSRandall Stewart 			stcb->sctp_socket->so_error = ECONNREFUSED;
275244b7479bSRandall Stewart 		else
2753f8829a4aSRandall Stewart 			stcb->sctp_socket->so_error = ECONNRESET;
2754f8829a4aSRandall Stewart 		/* Wake ANY sleepers */
2755f8829a4aSRandall Stewart 		sorwakeup(stcb->sctp_socket);
2756f8829a4aSRandall Stewart 		sowwakeup(stcb->sctp_socket);
2757f8829a4aSRandall Stewart 		sctp_asoc_change_wake++;
2758f8829a4aSRandall Stewart 	}
2759f8829a4aSRandall Stewart 	if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVASSOCEVNT)) {
2760f8829a4aSRandall Stewart 		/* event not enabled */
2761f8829a4aSRandall Stewart 		return;
2762f8829a4aSRandall Stewart 	}
2763139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_assoc_change), 0, M_DONTWAIT, 1, MT_DATA);
2764f8829a4aSRandall Stewart 	if (m_notify == NULL)
2765f8829a4aSRandall Stewart 		/* no space left */
2766f8829a4aSRandall Stewart 		return;
2767139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
2768f8829a4aSRandall Stewart 
2769f8829a4aSRandall Stewart 	sac = mtod(m_notify, struct sctp_assoc_change *);
2770f8829a4aSRandall Stewart 	sac->sac_type = SCTP_ASSOC_CHANGE;
2771f8829a4aSRandall Stewart 	sac->sac_flags = 0;
2772f8829a4aSRandall Stewart 	sac->sac_length = sizeof(struct sctp_assoc_change);
2773f8829a4aSRandall Stewart 	sac->sac_state = event;
2774f8829a4aSRandall Stewart 	sac->sac_error = error;
2775f8829a4aSRandall Stewart 	/* XXX verify these stream counts */
2776f8829a4aSRandall Stewart 	sac->sac_outbound_streams = stcb->asoc.streamoutcnt;
2777f8829a4aSRandall Stewart 	sac->sac_inbound_streams = stcb->asoc.streamincnt;
2778f8829a4aSRandall Stewart 	sac->sac_assoc_id = sctp_get_associd(stcb);
2779139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_assoc_change);
2780139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
2781f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
2782f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
2783f8829a4aSRandall Stewart 	    m_notify);
2784f8829a4aSRandall Stewart 	if (control == NULL) {
2785f8829a4aSRandall Stewart 		/* no memory */
2786f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2787f8829a4aSRandall Stewart 		return;
2788f8829a4aSRandall Stewart 	}
2789139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
2790f8829a4aSRandall Stewart 	/* not that we need this */
2791f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
2792139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
2793f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
2794f8829a4aSRandall Stewart 	    control,
2795f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
2796f8829a4aSRandall Stewart 	if (event == SCTP_COMM_LOST) {
2797f8829a4aSRandall Stewart 		/* Wake up any sleeper */
2798f8829a4aSRandall Stewart 		sctp_sowwakeup(stcb->sctp_ep, stcb->sctp_socket);
2799f8829a4aSRandall Stewart 	}
2800f8829a4aSRandall Stewart }
2801f8829a4aSRandall Stewart 
2802f8829a4aSRandall Stewart static void
2803f8829a4aSRandall Stewart sctp_notify_peer_addr_change(struct sctp_tcb *stcb, uint32_t state,
2804f8829a4aSRandall Stewart     struct sockaddr *sa, uint32_t error)
2805f8829a4aSRandall Stewart {
2806f8829a4aSRandall Stewart 	struct mbuf *m_notify;
2807f8829a4aSRandall Stewart 	struct sctp_paddr_change *spc;
2808f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
2809f8829a4aSRandall Stewart 
2810ad81507eSRandall Stewart 	if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVPADDREVNT)))
2811f8829a4aSRandall Stewart 		/* event not enabled */
2812f8829a4aSRandall Stewart 		return;
2813f8829a4aSRandall Stewart 
2814139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_paddr_change), 0, M_DONTWAIT, 1, MT_DATA);
2815f8829a4aSRandall Stewart 	if (m_notify == NULL)
2816f8829a4aSRandall Stewart 		return;
2817139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
2818f8829a4aSRandall Stewart 	spc = mtod(m_notify, struct sctp_paddr_change *);
2819f8829a4aSRandall Stewart 	spc->spc_type = SCTP_PEER_ADDR_CHANGE;
2820f8829a4aSRandall Stewart 	spc->spc_flags = 0;
2821f8829a4aSRandall Stewart 	spc->spc_length = sizeof(struct sctp_paddr_change);
2822f8829a4aSRandall Stewart 	if (sa->sa_family == AF_INET) {
2823f8829a4aSRandall Stewart 		memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in));
2824f8829a4aSRandall Stewart 	} else {
2825f42a358aSRandall Stewart 		struct sockaddr_in6 *sin6;
2826f42a358aSRandall Stewart 
2827f8829a4aSRandall Stewart 		memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in6));
2828f42a358aSRandall Stewart 
2829f42a358aSRandall Stewart 		sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr;
2830f42a358aSRandall Stewart 		if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) {
283142551e99SRandall Stewart 			if (sin6->sin6_scope_id == 0) {
283242551e99SRandall Stewart 				/* recover scope_id for user */
2833f42a358aSRandall Stewart 				(void)sa6_recoverscope(sin6);
283442551e99SRandall Stewart 			} else {
283542551e99SRandall Stewart 				/* clear embedded scope_id for user */
283642551e99SRandall Stewart 				in6_clearscope(&sin6->sin6_addr);
283742551e99SRandall Stewart 			}
2838f42a358aSRandall Stewart 		}
2839f8829a4aSRandall Stewart 	}
2840f8829a4aSRandall Stewart 	spc->spc_state = state;
2841f8829a4aSRandall Stewart 	spc->spc_error = error;
2842f8829a4aSRandall Stewart 	spc->spc_assoc_id = sctp_get_associd(stcb);
2843f8829a4aSRandall Stewart 
2844139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_paddr_change);
2845139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
2846f8829a4aSRandall Stewart 
2847f8829a4aSRandall Stewart 	/* append to socket */
2848f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
2849f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
2850f8829a4aSRandall Stewart 	    m_notify);
2851f8829a4aSRandall Stewart 	if (control == NULL) {
2852f8829a4aSRandall Stewart 		/* no memory */
2853f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2854f8829a4aSRandall Stewart 		return;
2855f8829a4aSRandall Stewart 	}
2856139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
2857139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
2858f8829a4aSRandall Stewart 	/* not that we need this */
2859f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
2860f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
2861f8829a4aSRandall Stewart 	    control,
2862f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
2863f8829a4aSRandall Stewart }
2864f8829a4aSRandall Stewart 
2865f8829a4aSRandall Stewart 
2866f8829a4aSRandall Stewart static void
2867f8829a4aSRandall Stewart sctp_notify_send_failed(struct sctp_tcb *stcb, uint32_t error,
2868f8829a4aSRandall Stewart     struct sctp_tmit_chunk *chk)
2869f8829a4aSRandall Stewart {
2870f8829a4aSRandall Stewart 	struct mbuf *m_notify;
2871f8829a4aSRandall Stewart 	struct sctp_send_failed *ssf;
2872f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
2873f8829a4aSRandall Stewart 	int length;
2874f8829a4aSRandall Stewart 
2875ad81507eSRandall Stewart 	if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSENDFAILEVNT)))
2876f8829a4aSRandall Stewart 		/* event not enabled */
2877f8829a4aSRandall Stewart 		return;
2878f8829a4aSRandall Stewart 
2879f8829a4aSRandall Stewart 	length = sizeof(struct sctp_send_failed) + chk->send_size;
2880139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_send_failed), 0, M_DONTWAIT, 1, MT_DATA);
2881f8829a4aSRandall Stewart 	if (m_notify == NULL)
2882f8829a4aSRandall Stewart 		/* no space left */
2883f8829a4aSRandall Stewart 		return;
2884139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
2885f8829a4aSRandall Stewart 	ssf = mtod(m_notify, struct sctp_send_failed *);
2886f8829a4aSRandall Stewart 	ssf->ssf_type = SCTP_SEND_FAILED;
2887f8829a4aSRandall Stewart 	if (error == SCTP_NOTIFY_DATAGRAM_UNSENT)
2888f8829a4aSRandall Stewart 		ssf->ssf_flags = SCTP_DATA_UNSENT;
2889f8829a4aSRandall Stewart 	else
2890f8829a4aSRandall Stewart 		ssf->ssf_flags = SCTP_DATA_SENT;
2891f8829a4aSRandall Stewart 	ssf->ssf_length = length;
2892f8829a4aSRandall Stewart 	ssf->ssf_error = error;
2893f8829a4aSRandall Stewart 	/* not exactly what the user sent in, but should be close :) */
2894d00aff5dSRandall Stewart 	bzero(&ssf->ssf_info, sizeof(ssf->ssf_info));
2895f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_stream = chk->rec.data.stream_number;
2896f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_ssn = chk->rec.data.stream_seq;
2897f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_flags = chk->rec.data.rcv_flags;
2898f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_ppid = chk->rec.data.payloadtype;
2899f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_context = chk->rec.data.context;
2900f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb);
2901f8829a4aSRandall Stewart 	ssf->ssf_assoc_id = sctp_get_associd(stcb);
2902139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = chk->data;
2903139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed);
2904f8829a4aSRandall Stewart 
2905f8829a4aSRandall Stewart 	/* Steal off the mbuf */
2906f8829a4aSRandall Stewart 	chk->data = NULL;
2907f8829a4aSRandall Stewart 	/*
2908f8829a4aSRandall Stewart 	 * For this case, we check the actual socket buffer, since the assoc
2909f8829a4aSRandall Stewart 	 * is going away we don't want to overfill the socket buffer for a
2910f8829a4aSRandall Stewart 	 * non-reader
2911f8829a4aSRandall Stewart 	 */
2912139bc87fSRandall Stewart 	if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {
2913f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2914f8829a4aSRandall Stewart 		return;
2915f8829a4aSRandall Stewart 	}
2916f8829a4aSRandall Stewart 	/* append to socket */
2917f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
2918f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
2919f8829a4aSRandall Stewart 	    m_notify);
2920f8829a4aSRandall Stewart 	if (control == NULL) {
2921f8829a4aSRandall Stewart 		/* no memory */
2922f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2923f8829a4aSRandall Stewart 		return;
2924f8829a4aSRandall Stewart 	}
2925139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
2926f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
2927f8829a4aSRandall Stewart 	    control,
2928f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
2929f8829a4aSRandall Stewart }
2930f8829a4aSRandall Stewart 
2931f8829a4aSRandall Stewart 
2932f8829a4aSRandall Stewart static void
2933f8829a4aSRandall Stewart sctp_notify_send_failed2(struct sctp_tcb *stcb, uint32_t error,
2934f8829a4aSRandall Stewart     struct sctp_stream_queue_pending *sp)
2935f8829a4aSRandall Stewart {
2936f8829a4aSRandall Stewart 	struct mbuf *m_notify;
2937f8829a4aSRandall Stewart 	struct sctp_send_failed *ssf;
2938f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
2939f8829a4aSRandall Stewart 	int length;
2940f8829a4aSRandall Stewart 
2941ad81507eSRandall Stewart 	if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSENDFAILEVNT)))
2942f8829a4aSRandall Stewart 		/* event not enabled */
2943f8829a4aSRandall Stewart 		return;
2944f8829a4aSRandall Stewart 
2945f8829a4aSRandall Stewart 	length = sizeof(struct sctp_send_failed) + sp->length;
2946d00aff5dSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_send_failed), 0, M_DONTWAIT, 1, MT_DATA);
2947f8829a4aSRandall Stewart 	if (m_notify == NULL)
2948f8829a4aSRandall Stewart 		/* no space left */
2949f8829a4aSRandall Stewart 		return;
2950139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
2951f8829a4aSRandall Stewart 	ssf = mtod(m_notify, struct sctp_send_failed *);
2952f8829a4aSRandall Stewart 	ssf->ssf_type = SCTP_SEND_FAILED;
2953f8829a4aSRandall Stewart 	if (error == SCTP_NOTIFY_DATAGRAM_UNSENT)
2954f8829a4aSRandall Stewart 		ssf->ssf_flags = SCTP_DATA_UNSENT;
2955f8829a4aSRandall Stewart 	else
2956f8829a4aSRandall Stewart 		ssf->ssf_flags = SCTP_DATA_SENT;
2957f8829a4aSRandall Stewart 	ssf->ssf_length = length;
2958f8829a4aSRandall Stewart 	ssf->ssf_error = error;
2959f8829a4aSRandall Stewart 	/* not exactly what the user sent in, but should be close :) */
2960d00aff5dSRandall Stewart 	bzero(&ssf->ssf_info, sizeof(ssf->ssf_info));
2961f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_stream = sp->stream;
2962f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_ssn = sp->strseq;
2963f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_flags = sp->sinfo_flags;
2964f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_ppid = sp->ppid;
2965f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_context = sp->context;
2966f8829a4aSRandall Stewart 	ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb);
2967f8829a4aSRandall Stewart 	ssf->ssf_assoc_id = sctp_get_associd(stcb);
2968139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = sp->data;
2969139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed);
2970f8829a4aSRandall Stewart 
2971f8829a4aSRandall Stewart 	/* Steal off the mbuf */
2972f8829a4aSRandall Stewart 	sp->data = NULL;
2973f8829a4aSRandall Stewart 	/*
2974f8829a4aSRandall Stewart 	 * For this case, we check the actual socket buffer, since the assoc
2975f8829a4aSRandall Stewart 	 * is going away we don't want to overfill the socket buffer for a
2976f8829a4aSRandall Stewart 	 * non-reader
2977f8829a4aSRandall Stewart 	 */
2978139bc87fSRandall Stewart 	if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {
2979f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2980f8829a4aSRandall Stewart 		return;
2981f8829a4aSRandall Stewart 	}
2982f8829a4aSRandall Stewart 	/* append to socket */
2983f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
2984f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
2985f8829a4aSRandall Stewart 	    m_notify);
2986f8829a4aSRandall Stewart 	if (control == NULL) {
2987f8829a4aSRandall Stewart 		/* no memory */
2988f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
2989f8829a4aSRandall Stewart 		return;
2990f8829a4aSRandall Stewart 	}
2991139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
2992f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
2993f8829a4aSRandall Stewart 	    control,
2994f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
2995f8829a4aSRandall Stewart }
2996f8829a4aSRandall Stewart 
2997f8829a4aSRandall Stewart 
2998f8829a4aSRandall Stewart 
2999f8829a4aSRandall Stewart static void
3000f8829a4aSRandall Stewart sctp_notify_adaptation_layer(struct sctp_tcb *stcb,
3001f8829a4aSRandall Stewart     uint32_t error)
3002f8829a4aSRandall Stewart {
3003f8829a4aSRandall Stewart 	struct mbuf *m_notify;
3004f8829a4aSRandall Stewart 	struct sctp_adaptation_event *sai;
3005f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
3006f8829a4aSRandall Stewart 
3007ad81507eSRandall Stewart 	if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_ADAPTATIONEVNT)))
3008f8829a4aSRandall Stewart 		/* event not enabled */
3009f8829a4aSRandall Stewart 		return;
3010f8829a4aSRandall Stewart 
3011139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_adaption_event), 0, M_DONTWAIT, 1, MT_DATA);
3012f8829a4aSRandall Stewart 	if (m_notify == NULL)
3013f8829a4aSRandall Stewart 		/* no space left */
3014f8829a4aSRandall Stewart 		return;
3015139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
3016f8829a4aSRandall Stewart 	sai = mtod(m_notify, struct sctp_adaptation_event *);
3017f8829a4aSRandall Stewart 	sai->sai_type = SCTP_ADAPTATION_INDICATION;
3018f8829a4aSRandall Stewart 	sai->sai_flags = 0;
3019f8829a4aSRandall Stewart 	sai->sai_length = sizeof(struct sctp_adaptation_event);
3020f8829a4aSRandall Stewart 	sai->sai_adaptation_ind = error;
3021f8829a4aSRandall Stewart 	sai->sai_assoc_id = sctp_get_associd(stcb);
3022f8829a4aSRandall Stewart 
3023139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_adaptation_event);
3024139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
3025f8829a4aSRandall Stewart 
3026f8829a4aSRandall Stewart 	/* append to socket */
3027f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
3028f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
3029f8829a4aSRandall Stewart 	    m_notify);
3030f8829a4aSRandall Stewart 	if (control == NULL) {
3031f8829a4aSRandall Stewart 		/* no memory */
3032f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3033f8829a4aSRandall Stewart 		return;
3034f8829a4aSRandall Stewart 	}
3035139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
3036139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
3037f8829a4aSRandall Stewart 	/* not that we need this */
3038f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
3039f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
3040f8829a4aSRandall Stewart 	    control,
3041f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
3042f8829a4aSRandall Stewart }
3043f8829a4aSRandall Stewart 
304403b0b021SRandall Stewart /* This always must be called with the read-queue LOCKED in the INP */
3045f8829a4aSRandall Stewart void
3046f8829a4aSRandall Stewart sctp_notify_partial_delivery_indication(struct sctp_tcb *stcb,
30479a6142d8SRandall Stewart     uint32_t error, int nolock, uint32_t val)
3048f8829a4aSRandall Stewart {
3049f8829a4aSRandall Stewart 	struct mbuf *m_notify;
3050f8829a4aSRandall Stewart 	struct sctp_pdapi_event *pdapi;
3051f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
305203b0b021SRandall Stewart 	struct sockbuf *sb;
3053f8829a4aSRandall Stewart 
3054ad81507eSRandall Stewart 	if ((stcb == NULL) || sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_PDAPIEVNT))
3055f8829a4aSRandall Stewart 		/* event not enabled */
3056f8829a4aSRandall Stewart 		return;
3057f8829a4aSRandall Stewart 
3058139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_pdapi_event), 0, M_DONTWAIT, 1, MT_DATA);
3059f8829a4aSRandall Stewart 	if (m_notify == NULL)
3060f8829a4aSRandall Stewart 		/* no space left */
3061f8829a4aSRandall Stewart 		return;
3062139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
3063f8829a4aSRandall Stewart 	pdapi = mtod(m_notify, struct sctp_pdapi_event *);
3064f8829a4aSRandall Stewart 	pdapi->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
3065f8829a4aSRandall Stewart 	pdapi->pdapi_flags = 0;
3066f8829a4aSRandall Stewart 	pdapi->pdapi_length = sizeof(struct sctp_pdapi_event);
3067f8829a4aSRandall Stewart 	pdapi->pdapi_indication = error;
30689a6142d8SRandall Stewart 	pdapi->pdapi_stream = (val >> 16);
30699a6142d8SRandall Stewart 	pdapi->pdapi_seq = (val & 0x0000ffff);
3070f8829a4aSRandall Stewart 	pdapi->pdapi_assoc_id = sctp_get_associd(stcb);
3071f8829a4aSRandall Stewart 
3072139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_pdapi_event);
3073139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
3074f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
3075f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
3076f8829a4aSRandall Stewart 	    m_notify);
3077f8829a4aSRandall Stewart 	if (control == NULL) {
3078f8829a4aSRandall Stewart 		/* no memory */
3079f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3080f8829a4aSRandall Stewart 		return;
3081f8829a4aSRandall Stewart 	}
3082139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
3083139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
3084f8829a4aSRandall Stewart 	/* not that we need this */
3085f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
308603b0b021SRandall Stewart 	control->held_length = 0;
308703b0b021SRandall Stewart 	control->length = 0;
308803b0b021SRandall Stewart 	if (nolock == 0) {
308903b0b021SRandall Stewart 		SCTP_INP_READ_LOCK(stcb->sctp_ep);
309003b0b021SRandall Stewart 	}
309103b0b021SRandall Stewart 	sb = &stcb->sctp_socket->so_rcv;
309280fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
3093139bc87fSRandall Stewart 		sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m_notify));
309480fefe0aSRandall Stewart 	}
309503b0b021SRandall Stewart 	sctp_sballoc(stcb, sb, m_notify);
309680fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
309703b0b021SRandall Stewart 		sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
309880fefe0aSRandall Stewart 	}
3099139bc87fSRandall Stewart 	atomic_add_int(&control->length, SCTP_BUF_LEN(m_notify));
310003b0b021SRandall Stewart 	control->end_added = 1;
310103b0b021SRandall Stewart 	if (stcb->asoc.control_pdapi)
310203b0b021SRandall Stewart 		TAILQ_INSERT_AFTER(&stcb->sctp_ep->read_queue, stcb->asoc.control_pdapi, control, next);
310303b0b021SRandall Stewart 	else {
310403b0b021SRandall Stewart 		/* we really should not see this case */
310503b0b021SRandall Stewart 		TAILQ_INSERT_TAIL(&stcb->sctp_ep->read_queue, control, next);
310603b0b021SRandall Stewart 	}
310703b0b021SRandall Stewart 	if (nolock == 0) {
310803b0b021SRandall Stewart 		SCTP_INP_READ_UNLOCK(stcb->sctp_ep);
310903b0b021SRandall Stewart 	}
311003b0b021SRandall Stewart 	if (stcb->sctp_ep && stcb->sctp_socket) {
311103b0b021SRandall Stewart 		/* This should always be the case */
311203b0b021SRandall Stewart 		sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket);
3113f8829a4aSRandall Stewart 	}
3114f8829a4aSRandall Stewart }
3115f8829a4aSRandall Stewart 
3116f8829a4aSRandall Stewart static void
3117f8829a4aSRandall Stewart sctp_notify_shutdown_event(struct sctp_tcb *stcb)
3118f8829a4aSRandall Stewart {
3119f8829a4aSRandall Stewart 	struct mbuf *m_notify;
3120f8829a4aSRandall Stewart 	struct sctp_shutdown_event *sse;
3121f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
3122f8829a4aSRandall Stewart 
3123f8829a4aSRandall Stewart 	/*
3124f8829a4aSRandall Stewart 	 * For TCP model AND UDP connected sockets we will send an error up
3125f8829a4aSRandall Stewart 	 * when an SHUTDOWN completes
3126f8829a4aSRandall Stewart 	 */
3127ad81507eSRandall Stewart 	if (stcb == NULL) {
3128ad81507eSRandall Stewart 		return;
3129ad81507eSRandall Stewart 	}
3130f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
3131f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
3132f8829a4aSRandall Stewart 		/* mark socket closed for read/write and wakeup! */
3133f8829a4aSRandall Stewart 		socantsendmore(stcb->sctp_socket);
3134f8829a4aSRandall Stewart 	}
3135f8829a4aSRandall Stewart 	if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT))
3136f8829a4aSRandall Stewart 		/* event not enabled */
3137f8829a4aSRandall Stewart 		return;
3138f8829a4aSRandall Stewart 
3139139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_event), 0, M_DONTWAIT, 1, MT_DATA);
3140f8829a4aSRandall Stewart 	if (m_notify == NULL)
3141f8829a4aSRandall Stewart 		/* no space left */
3142f8829a4aSRandall Stewart 		return;
3143f8829a4aSRandall Stewart 	sse = mtod(m_notify, struct sctp_shutdown_event *);
3144f8829a4aSRandall Stewart 	sse->sse_type = SCTP_SHUTDOWN_EVENT;
3145f8829a4aSRandall Stewart 	sse->sse_flags = 0;
3146f8829a4aSRandall Stewart 	sse->sse_length = sizeof(struct sctp_shutdown_event);
3147f8829a4aSRandall Stewart 	sse->sse_assoc_id = sctp_get_associd(stcb);
3148f8829a4aSRandall Stewart 
3149139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_shutdown_event);
3150139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
3151f8829a4aSRandall Stewart 
3152f8829a4aSRandall Stewart 	/* append to socket */
3153f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
3154f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
3155f8829a4aSRandall Stewart 	    m_notify);
3156f8829a4aSRandall Stewart 	if (control == NULL) {
3157f8829a4aSRandall Stewart 		/* no memory */
3158f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3159f8829a4aSRandall Stewart 		return;
3160f8829a4aSRandall Stewart 	}
3161139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
3162139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
3163f8829a4aSRandall Stewart 	/* not that we need this */
3164f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
3165f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
3166f8829a4aSRandall Stewart 	    control,
3167f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
3168f8829a4aSRandall Stewart }
3169f8829a4aSRandall Stewart 
3170f8829a4aSRandall Stewart static void
3171f8829a4aSRandall Stewart sctp_notify_stream_reset(struct sctp_tcb *stcb,
3172f8829a4aSRandall Stewart     int number_entries, uint16_t * list, int flag)
3173f8829a4aSRandall Stewart {
3174f8829a4aSRandall Stewart 	struct mbuf *m_notify;
3175f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control;
3176f8829a4aSRandall Stewart 	struct sctp_stream_reset_event *strreset;
3177f8829a4aSRandall Stewart 	int len;
3178f8829a4aSRandall Stewart 
3179ad81507eSRandall Stewart 	if (stcb == NULL) {
3180ad81507eSRandall Stewart 		return;
3181ad81507eSRandall Stewart 	}
3182f8829a4aSRandall Stewart 	if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_STREAM_RESETEVNT))
3183f8829a4aSRandall Stewart 		/* event not enabled */
3184f8829a4aSRandall Stewart 		return;
3185f8829a4aSRandall Stewart 
3186139bc87fSRandall Stewart 	m_notify = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA);
3187f8829a4aSRandall Stewart 	if (m_notify == NULL)
3188f8829a4aSRandall Stewart 		/* no space left */
3189f8829a4aSRandall Stewart 		return;
3190139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = 0;
3191f8829a4aSRandall Stewart 	len = sizeof(struct sctp_stream_reset_event) + (number_entries * sizeof(uint16_t));
3192f8829a4aSRandall Stewart 	if (len > M_TRAILINGSPACE(m_notify)) {
3193f8829a4aSRandall Stewart 		/* never enough room */
3194f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3195f8829a4aSRandall Stewart 		return;
3196f8829a4aSRandall Stewart 	}
3197f8829a4aSRandall Stewart 	strreset = mtod(m_notify, struct sctp_stream_reset_event *);
3198f8829a4aSRandall Stewart 	strreset->strreset_type = SCTP_STREAM_RESET_EVENT;
3199f8829a4aSRandall Stewart 	if (number_entries == 0) {
3200f8829a4aSRandall Stewart 		strreset->strreset_flags = flag | SCTP_STRRESET_ALL_STREAMS;
3201f8829a4aSRandall Stewart 	} else {
3202f8829a4aSRandall Stewart 		strreset->strreset_flags = flag | SCTP_STRRESET_STREAM_LIST;
3203f8829a4aSRandall Stewart 	}
3204f8829a4aSRandall Stewart 	strreset->strreset_length = len;
3205f8829a4aSRandall Stewart 	strreset->strreset_assoc_id = sctp_get_associd(stcb);
3206f8829a4aSRandall Stewart 	if (number_entries) {
3207f8829a4aSRandall Stewart 		int i;
3208f8829a4aSRandall Stewart 
3209f8829a4aSRandall Stewart 		for (i = 0; i < number_entries; i++) {
3210f8829a4aSRandall Stewart 			strreset->strreset_list[i] = ntohs(list[i]);
3211f8829a4aSRandall Stewart 		}
3212f8829a4aSRandall Stewart 	}
3213139bc87fSRandall Stewart 	SCTP_BUF_LEN(m_notify) = len;
3214139bc87fSRandall Stewart 	SCTP_BUF_NEXT(m_notify) = NULL;
3215139bc87fSRandall Stewart 	if (sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {
3216f8829a4aSRandall Stewart 		/* no space */
3217f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3218f8829a4aSRandall Stewart 		return;
3219f8829a4aSRandall Stewart 	}
3220f8829a4aSRandall Stewart 	/* append to socket */
3221f8829a4aSRandall Stewart 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,
3222f8829a4aSRandall Stewart 	    0, 0, 0, 0, 0, 0,
3223f8829a4aSRandall Stewart 	    m_notify);
3224f8829a4aSRandall Stewart 	if (control == NULL) {
3225f8829a4aSRandall Stewart 		/* no memory */
3226f8829a4aSRandall Stewart 		sctp_m_freem(m_notify);
3227f8829a4aSRandall Stewart 		return;
3228f8829a4aSRandall Stewart 	}
3229139bc87fSRandall Stewart 	control->spec_flags = M_NOTIFICATION;
3230139bc87fSRandall Stewart 	control->length = SCTP_BUF_LEN(m_notify);
3231f8829a4aSRandall Stewart 	/* not that we need this */
3232f8829a4aSRandall Stewart 	control->tail_mbuf = m_notify;
3233f8829a4aSRandall Stewart 	sctp_add_to_readq(stcb->sctp_ep, stcb,
3234f8829a4aSRandall Stewart 	    control,
3235f8829a4aSRandall Stewart 	    &stcb->sctp_socket->so_rcv, 1);
3236f8829a4aSRandall Stewart }
3237f8829a4aSRandall Stewart 
3238f8829a4aSRandall Stewart 
3239f8829a4aSRandall Stewart void
3240f8829a4aSRandall Stewart sctp_ulp_notify(uint32_t notification, struct sctp_tcb *stcb,
3241f8829a4aSRandall Stewart     uint32_t error, void *data)
3242f8829a4aSRandall Stewart {
324303b0b021SRandall Stewart 	if (stcb == NULL) {
324403b0b021SRandall Stewart 		/* unlikely but */
324503b0b021SRandall Stewart 		return;
324603b0b021SRandall Stewart 	}
3247f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
3248f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
3249f8829a4aSRandall Stewart 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)
3250f8829a4aSRandall Stewart 	    ) {
3251f8829a4aSRandall Stewart 		/* No notifications up when we are in a no socket state */
3252f8829a4aSRandall Stewart 		return;
3253f8829a4aSRandall Stewart 	}
3254f8829a4aSRandall Stewart 	if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) {
3255f8829a4aSRandall Stewart 		/* Can't send up to a closed socket any notifications */
3256f8829a4aSRandall Stewart 		return;
3257f8829a4aSRandall Stewart 	}
325817205eccSRandall Stewart 	if (stcb && ((stcb->asoc.state & SCTP_STATE_COOKIE_WAIT) ||
325917205eccSRandall Stewart 	    (stcb->asoc.state & SCTP_STATE_COOKIE_ECHOED))) {
326017205eccSRandall Stewart 		if ((notification == SCTP_NOTIFY_INTERFACE_DOWN) ||
326117205eccSRandall Stewart 		    (notification == SCTP_NOTIFY_INTERFACE_UP) ||
326217205eccSRandall Stewart 		    (notification == SCTP_NOTIFY_INTERFACE_CONFIRMED)) {
326317205eccSRandall Stewart 			/* Don't report these in front states */
326417205eccSRandall Stewart 			return;
326517205eccSRandall Stewart 		}
326617205eccSRandall Stewart 	}
3267f8829a4aSRandall Stewart 	if (stcb && (stcb->asoc.assoc_up_sent == 0) && (notification != SCTP_NOTIFY_ASSOC_UP)) {
3268f8829a4aSRandall Stewart 		if ((notification != SCTP_NOTIFY_ASSOC_DOWN) &&
3269f8829a4aSRandall Stewart 		    (notification != SCTP_NOTIFY_ASSOC_ABORTED) &&
3270f8829a4aSRandall Stewart 		    (notification != SCTP_NOTIFY_SPECIAL_SP_FAIL) &&
3271f8829a4aSRandall Stewart 		    (notification != SCTP_NOTIFY_DG_FAIL) &&
3272f8829a4aSRandall Stewart 		    (notification != SCTP_NOTIFY_PEER_SHUTDOWN)) {
3273f8829a4aSRandall Stewart 			sctp_notify_assoc_change(SCTP_COMM_UP, stcb, 0, NULL);
3274f8829a4aSRandall Stewart 			stcb->asoc.assoc_up_sent = 1;
3275f8829a4aSRandall Stewart 		}
3276f8829a4aSRandall Stewart 	}
3277f8829a4aSRandall Stewart 	switch (notification) {
3278f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASSOC_UP:
3279f8829a4aSRandall Stewart 		if (stcb->asoc.assoc_up_sent == 0) {
3280f8829a4aSRandall Stewart 			sctp_notify_assoc_change(SCTP_COMM_UP, stcb, error, NULL);
3281f8829a4aSRandall Stewart 			stcb->asoc.assoc_up_sent = 1;
3282f8829a4aSRandall Stewart 		}
3283f8829a4aSRandall Stewart 		break;
3284f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASSOC_DOWN:
3285f8829a4aSRandall Stewart 		sctp_notify_assoc_change(SCTP_SHUTDOWN_COMP, stcb, error, NULL);
3286f8829a4aSRandall Stewart 		break;
3287f8829a4aSRandall Stewart 	case SCTP_NOTIFY_INTERFACE_DOWN:
3288f8829a4aSRandall Stewart 		{
3289f8829a4aSRandall Stewart 			struct sctp_nets *net;
3290f8829a4aSRandall Stewart 
3291f8829a4aSRandall Stewart 			net = (struct sctp_nets *)data;
3292f8829a4aSRandall Stewart 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_UNREACHABLE,
3293f8829a4aSRandall Stewart 			    (struct sockaddr *)&net->ro._l_addr, error);
3294f8829a4aSRandall Stewart 			break;
3295f8829a4aSRandall Stewart 		}
3296f8829a4aSRandall Stewart 	case SCTP_NOTIFY_INTERFACE_UP:
3297f8829a4aSRandall Stewart 		{
3298f8829a4aSRandall Stewart 			struct sctp_nets *net;
3299f8829a4aSRandall Stewart 
3300f8829a4aSRandall Stewart 			net = (struct sctp_nets *)data;
3301f8829a4aSRandall Stewart 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_AVAILABLE,
3302f8829a4aSRandall Stewart 			    (struct sockaddr *)&net->ro._l_addr, error);
3303f8829a4aSRandall Stewart 			break;
3304f8829a4aSRandall Stewart 		}
3305f8829a4aSRandall Stewart 	case SCTP_NOTIFY_INTERFACE_CONFIRMED:
3306f8829a4aSRandall Stewart 		{
3307f8829a4aSRandall Stewart 			struct sctp_nets *net;
3308f8829a4aSRandall Stewart 
3309f8829a4aSRandall Stewart 			net = (struct sctp_nets *)data;
3310f8829a4aSRandall Stewart 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_CONFIRMED,
3311f8829a4aSRandall Stewart 			    (struct sockaddr *)&net->ro._l_addr, error);
3312f8829a4aSRandall Stewart 			break;
3313f8829a4aSRandall Stewart 		}
3314f8829a4aSRandall Stewart 	case SCTP_NOTIFY_SPECIAL_SP_FAIL:
3315f8829a4aSRandall Stewart 		sctp_notify_send_failed2(stcb, error,
3316f8829a4aSRandall Stewart 		    (struct sctp_stream_queue_pending *)data);
3317f8829a4aSRandall Stewart 		break;
3318f8829a4aSRandall Stewart 	case SCTP_NOTIFY_DG_FAIL:
3319f8829a4aSRandall Stewart 		sctp_notify_send_failed(stcb, error,
3320f8829a4aSRandall Stewart 		    (struct sctp_tmit_chunk *)data);
3321f8829a4aSRandall Stewart 		break;
3322f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ADAPTATION_INDICATION:
3323f8829a4aSRandall Stewart 		/* Here the error is the adaptation indication */
3324f8829a4aSRandall Stewart 		sctp_notify_adaptation_layer(stcb, error);
3325f8829a4aSRandall Stewart 		break;
3326f8829a4aSRandall Stewart 	case SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION:
33279a6142d8SRandall Stewart 		{
33289a6142d8SRandall Stewart 			uint32_t val;
33299a6142d8SRandall Stewart 
33309a6142d8SRandall Stewart 			val = *((uint32_t *) data);
33319a6142d8SRandall Stewart 
33329a6142d8SRandall Stewart 			sctp_notify_partial_delivery_indication(stcb, error, 0, val);
33339a6142d8SRandall Stewart 		}
3334f8829a4aSRandall Stewart 		break;
3335f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STRDATA_ERR:
3336f8829a4aSRandall Stewart 		break;
3337f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASSOC_ABORTED:
3338c105859eSRandall Stewart 		if ((stcb) && (((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_WAIT) ||
3339c105859eSRandall Stewart 		    ((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_ECHOED))) {
3340c105859eSRandall Stewart 			sctp_notify_assoc_change(SCTP_CANT_STR_ASSOC, stcb, error, NULL);
3341c105859eSRandall Stewart 		} else {
3342f8829a4aSRandall Stewart 			sctp_notify_assoc_change(SCTP_COMM_LOST, stcb, error, NULL);
3343c105859eSRandall Stewart 		}
3344f8829a4aSRandall Stewart 		break;
3345f8829a4aSRandall Stewart 	case SCTP_NOTIFY_PEER_OPENED_STREAM:
3346f8829a4aSRandall Stewart 		break;
3347f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STREAM_OPENED_OK:
3348f8829a4aSRandall Stewart 		break;
3349f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASSOC_RESTART:
3350f8829a4aSRandall Stewart 		sctp_notify_assoc_change(SCTP_RESTART, stcb, error, data);
3351f8829a4aSRandall Stewart 		break;
3352f8829a4aSRandall Stewart 	case SCTP_NOTIFY_HB_RESP:
3353f8829a4aSRandall Stewart 		break;
3354f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STR_RESET_SEND:
3355f8829a4aSRandall Stewart 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STRRESET_OUTBOUND_STR);
3356f8829a4aSRandall Stewart 		break;
3357f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STR_RESET_RECV:
3358f8829a4aSRandall Stewart 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STRRESET_INBOUND_STR);
3359f8829a4aSRandall Stewart 		break;
3360f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STR_RESET_FAILED_OUT:
3361671d309cSRandall Stewart 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_OUTBOUND_STR | SCTP_STRRESET_FAILED));
3362f8829a4aSRandall Stewart 		break;
3363f8829a4aSRandall Stewart 
3364f8829a4aSRandall Stewart 	case SCTP_NOTIFY_STR_RESET_FAILED_IN:
3365671d309cSRandall Stewart 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_INBOUND_STR | SCTP_STRRESET_FAILED));
3366f8829a4aSRandall Stewart 		break;
3367f8829a4aSRandall Stewart 
3368f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASCONF_ADD_IP:
3369f8829a4aSRandall Stewart 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_ADDED, data,
3370f8829a4aSRandall Stewart 		    error);
3371f8829a4aSRandall Stewart 		break;
3372f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASCONF_DELETE_IP:
3373f8829a4aSRandall Stewart 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_REMOVED, data,
3374f8829a4aSRandall Stewart 		    error);
3375f8829a4aSRandall Stewart 		break;
3376f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASCONF_SET_PRIMARY:
3377f8829a4aSRandall Stewart 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_MADE_PRIM, data,
3378f8829a4aSRandall Stewart 		    error);
3379f8829a4aSRandall Stewart 		break;
3380f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASCONF_SUCCESS:
3381f8829a4aSRandall Stewart 		break;
3382f8829a4aSRandall Stewart 	case SCTP_NOTIFY_ASCONF_FAILED:
3383f8829a4aSRandall Stewart 		break;
3384f8829a4aSRandall Stewart 	case SCTP_NOTIFY_PEER_SHUTDOWN:
3385f8829a4aSRandall Stewart 		sctp_notify_shutdown_event(stcb);
3386f8829a4aSRandall Stewart 		break;
3387f8829a4aSRandall Stewart 	case SCTP_NOTIFY_AUTH_NEW_KEY:
3388f8829a4aSRandall Stewart 		sctp_notify_authentication(stcb, SCTP_AUTH_NEWKEY, error,
3389562a89b5SRandall Stewart 		    (uint16_t) (uintptr_t) data);
3390f8829a4aSRandall Stewart 		break;
3391f8829a4aSRandall Stewart #if 0
3392f8829a4aSRandall Stewart 	case SCTP_NOTIFY_AUTH_KEY_CONFLICT:
3393f8829a4aSRandall Stewart 		sctp_notify_authentication(stcb, SCTP_AUTH_KEY_CONFLICT,
3394562a89b5SRandall Stewart 		    error, (uint16_t) (uintptr_t) data);
3395f8829a4aSRandall Stewart 		break;
3396f8829a4aSRandall Stewart #endif				/* not yet? remove? */
3397f8829a4aSRandall Stewart 
3398f8829a4aSRandall Stewart 
3399f8829a4aSRandall Stewart 	default:
3400ad81507eSRandall Stewart 		SCTPDBG(SCTP_DEBUG_UTIL1, "%s: unknown notification %xh (%u)\n",
3401ad81507eSRandall Stewart 		    __FUNCTION__, notification, notification);
3402f8829a4aSRandall Stewart 		break;
3403f8829a4aSRandall Stewart 	}			/* end switch */
3404f8829a4aSRandall Stewart }
3405f8829a4aSRandall Stewart 
3406f8829a4aSRandall Stewart void
34077f34832bSRandall Stewart sctp_report_all_outbound(struct sctp_tcb *stcb, int holds_lock)
3408f8829a4aSRandall Stewart {
3409f8829a4aSRandall Stewart 	struct sctp_association *asoc;
3410f8829a4aSRandall Stewart 	struct sctp_stream_out *outs;
3411f8829a4aSRandall Stewart 	struct sctp_tmit_chunk *chk;
3412f8829a4aSRandall Stewart 	struct sctp_stream_queue_pending *sp;
34137f34832bSRandall Stewart 	int i;
3414f8829a4aSRandall Stewart 
3415f8829a4aSRandall Stewart 	asoc = &stcb->asoc;
3416f8829a4aSRandall Stewart 
3417ad81507eSRandall Stewart 	if (stcb == NULL) {
3418ad81507eSRandall Stewart 		return;
3419ad81507eSRandall Stewart 	}
3420f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
3421f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
3422f8829a4aSRandall Stewart 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) {
3423f8829a4aSRandall Stewart 		return;
3424f8829a4aSRandall Stewart 	}
3425f8829a4aSRandall Stewart 	/* now through all the gunk freeing chunks */
3426ad81507eSRandall Stewart 	if (holds_lock == 0) {
34277f34832bSRandall Stewart 		SCTP_TCB_SEND_LOCK(stcb);
3428ad81507eSRandall Stewart 	}
3429d00aff5dSRandall Stewart 	/* sent queue SHOULD be empty */
3430d00aff5dSRandall Stewart 	if (!TAILQ_EMPTY(&asoc->sent_queue)) {
3431d00aff5dSRandall Stewart 		chk = TAILQ_FIRST(&asoc->sent_queue);
3432d00aff5dSRandall Stewart 		while (chk) {
3433d00aff5dSRandall Stewart 			TAILQ_REMOVE(&asoc->sent_queue, chk, sctp_next);
3434d00aff5dSRandall Stewart 			asoc->sent_queue_cnt--;
3435d00aff5dSRandall Stewart 			if (chk->data) {
3436d00aff5dSRandall Stewart 				/*
3437d00aff5dSRandall Stewart 				 * trim off the sctp chunk header(it should
3438d00aff5dSRandall Stewart 				 * be there)
3439d00aff5dSRandall Stewart 				 */
3440d00aff5dSRandall Stewart 				if (chk->send_size >= sizeof(struct sctp_data_chunk)) {
3441d00aff5dSRandall Stewart 					m_adj(chk->data, sizeof(struct sctp_data_chunk));
3442d00aff5dSRandall Stewart 					sctp_mbuf_crush(chk->data);
3443d00aff5dSRandall Stewart 					chk->send_size -= sizeof(struct sctp_data_chunk);
3444d00aff5dSRandall Stewart 				}
3445d00aff5dSRandall Stewart 			}
3446d00aff5dSRandall Stewart 			sctp_free_bufspace(stcb, asoc, chk, 1);
3447d00aff5dSRandall Stewart 			sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb,
3448d00aff5dSRandall Stewart 			    SCTP_NOTIFY_DATAGRAM_SENT, chk);
3449d00aff5dSRandall Stewart 			if (chk->data) {
3450d00aff5dSRandall Stewart 				sctp_m_freem(chk->data);
3451d00aff5dSRandall Stewart 				chk->data = NULL;
3452d00aff5dSRandall Stewart 			}
3453d00aff5dSRandall Stewart 			if (chk->whoTo)
3454d00aff5dSRandall Stewart 				sctp_free_remote_addr(chk->whoTo);
3455d00aff5dSRandall Stewart 			chk->whoTo = NULL;
3456d00aff5dSRandall Stewart 			sctp_free_a_chunk(stcb, chk);
3457d00aff5dSRandall Stewart 			/* sa_ignore FREED_MEMORY */
3458d00aff5dSRandall Stewart 			chk = TAILQ_FIRST(&asoc->sent_queue);
3459d00aff5dSRandall Stewart 		}
3460d00aff5dSRandall Stewart 	}
3461d00aff5dSRandall Stewart 	/* pending send queue SHOULD be empty */
3462d00aff5dSRandall Stewart 	if (!TAILQ_EMPTY(&asoc->send_queue)) {
3463d00aff5dSRandall Stewart 		chk = TAILQ_FIRST(&asoc->send_queue);
3464d00aff5dSRandall Stewart 		while (chk) {
3465d00aff5dSRandall Stewart 			TAILQ_REMOVE(&asoc->send_queue, chk, sctp_next);
3466d00aff5dSRandall Stewart 			asoc->send_queue_cnt--;
3467d00aff5dSRandall Stewart 			if (chk->data) {
3468d00aff5dSRandall Stewart 				/*
3469d00aff5dSRandall Stewart 				 * trim off the sctp chunk header(it should
3470d00aff5dSRandall Stewart 				 * be there)
3471d00aff5dSRandall Stewart 				 */
3472d00aff5dSRandall Stewart 				if (chk->send_size >= sizeof(struct sctp_data_chunk)) {
3473d00aff5dSRandall Stewart 					m_adj(chk->data, sizeof(struct sctp_data_chunk));
3474d00aff5dSRandall Stewart 					sctp_mbuf_crush(chk->data);
3475d00aff5dSRandall Stewart 					chk->send_size -= sizeof(struct sctp_data_chunk);
3476d00aff5dSRandall Stewart 				}
3477d00aff5dSRandall Stewart 			}
3478d00aff5dSRandall Stewart 			sctp_free_bufspace(stcb, asoc, chk, 1);
3479d00aff5dSRandall Stewart 			sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, SCTP_NOTIFY_DATAGRAM_UNSENT, chk);
3480d00aff5dSRandall Stewart 			if (chk->data) {
3481d00aff5dSRandall Stewart 				sctp_m_freem(chk->data);
3482d00aff5dSRandall Stewart 				chk->data = NULL;
3483d00aff5dSRandall Stewart 			}
3484d00aff5dSRandall Stewart 			if (chk->whoTo)
3485d00aff5dSRandall Stewart 				sctp_free_remote_addr(chk->whoTo);
3486d00aff5dSRandall Stewart 			chk->whoTo = NULL;
3487d00aff5dSRandall Stewart 			sctp_free_a_chunk(stcb, chk);
3488d00aff5dSRandall Stewart 			/* sa_ignore FREED_MEMORY */
3489d00aff5dSRandall Stewart 			chk = TAILQ_FIRST(&asoc->send_queue);
3490d00aff5dSRandall Stewart 		}
3491d00aff5dSRandall Stewart 	}
34927f34832bSRandall Stewart 	for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
34937f34832bSRandall Stewart 		/* For each stream */
34947f34832bSRandall Stewart 		outs = &stcb->asoc.strmout[i];
34957f34832bSRandall Stewart 		/* clean up any sends there */
3496f8829a4aSRandall Stewart 		stcb->asoc.locked_on_sending = NULL;
3497f8829a4aSRandall Stewart 		sp = TAILQ_FIRST(&outs->outqueue);
3498f8829a4aSRandall Stewart 		while (sp) {
3499f8829a4aSRandall Stewart 			stcb->asoc.stream_queue_cnt--;
3500f8829a4aSRandall Stewart 			TAILQ_REMOVE(&outs->outqueue, sp, next);
3501f8829a4aSRandall Stewart 			sctp_free_spbufspace(stcb, asoc, sp);
3502f8829a4aSRandall Stewart 			sctp_ulp_notify(SCTP_NOTIFY_SPECIAL_SP_FAIL, stcb,
3503f8829a4aSRandall Stewart 			    SCTP_NOTIFY_DATAGRAM_UNSENT, (void *)sp);
3504f8829a4aSRandall Stewart 			if (sp->data) {
3505f8829a4aSRandall Stewart 				sctp_m_freem(sp->data);
3506f8829a4aSRandall Stewart 				sp->data = NULL;
3507f8829a4aSRandall Stewart 			}
3508f8829a4aSRandall Stewart 			if (sp->net)
3509f8829a4aSRandall Stewart 				sctp_free_remote_addr(sp->net);
3510f8829a4aSRandall Stewart 			sp->net = NULL;
3511f8829a4aSRandall Stewart 			/* Free the chunk */
3512f8829a4aSRandall Stewart 			sctp_free_a_strmoq(stcb, sp);
35133c503c28SRandall Stewart 			/* sa_ignore FREED_MEMORY */
3514f8829a4aSRandall Stewart 			sp = TAILQ_FIRST(&outs->outqueue);
3515f8829a4aSRandall Stewart 		}
3516f8829a4aSRandall Stewart 	}
3517f8829a4aSRandall Stewart 
3518ad81507eSRandall Stewart 	if (holds_lock == 0) {
35197f34832bSRandall Stewart 		SCTP_TCB_SEND_UNLOCK(stcb);
3520f8829a4aSRandall Stewart 	}
3521ad81507eSRandall Stewart }
3522f8829a4aSRandall Stewart 
3523f8829a4aSRandall Stewart void
3524f8829a4aSRandall Stewart sctp_abort_notification(struct sctp_tcb *stcb, int error)
3525f8829a4aSRandall Stewart {
3526f8829a4aSRandall Stewart 
3527ad81507eSRandall Stewart 	if (stcb == NULL) {
3528ad81507eSRandall Stewart 		return;
3529ad81507eSRandall Stewart 	}
3530f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
3531f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
3532f8829a4aSRandall Stewart 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) {
3533f8829a4aSRandall Stewart 		return;
3534f8829a4aSRandall Stewart 	}
3535f8829a4aSRandall Stewart 	/* Tell them we lost the asoc */
35367f34832bSRandall Stewart 	sctp_report_all_outbound(stcb, 1);
3537f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
3538f8829a4aSRandall Stewart 	    ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
3539f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_CONNECTED))) {
3540f8829a4aSRandall Stewart 		stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_WAS_ABORTED;
3541f8829a4aSRandall Stewart 	}
3542f8829a4aSRandall Stewart 	sctp_ulp_notify(SCTP_NOTIFY_ASSOC_ABORTED, stcb, error, NULL);
3543f8829a4aSRandall Stewart }
3544f8829a4aSRandall Stewart 
3545f8829a4aSRandall Stewart void
3546f8829a4aSRandall Stewart sctp_abort_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
354717205eccSRandall Stewart     struct mbuf *m, int iphlen, struct sctphdr *sh, struct mbuf *op_err,
3548ad21a364SRandall Stewart     uint32_t vrf_id)
3549f8829a4aSRandall Stewart {
3550f8829a4aSRandall Stewart 	uint32_t vtag;
3551f8829a4aSRandall Stewart 
3552f8829a4aSRandall Stewart 	vtag = 0;
3553f8829a4aSRandall Stewart 	if (stcb != NULL) {
3554f8829a4aSRandall Stewart 		/* We have a TCB to abort, send notification too */
3555f8829a4aSRandall Stewart 		vtag = stcb->asoc.peer_vtag;
3556f8829a4aSRandall Stewart 		sctp_abort_notification(stcb, 0);
355717205eccSRandall Stewart 		/* get the assoc vrf id and table id */
355817205eccSRandall Stewart 		vrf_id = stcb->asoc.vrf_id;
3559f8829a4aSRandall Stewart 	}
3560ad21a364SRandall Stewart 	sctp_send_abort(m, iphlen, sh, vtag, op_err, vrf_id);
3561f8829a4aSRandall Stewart 	if (stcb != NULL) {
3562f8829a4aSRandall Stewart 		/* Ok, now lets free it */
3563a5d547adSRandall Stewart 		sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_4);
3564f8829a4aSRandall Stewart 	} else {
3565f8829a4aSRandall Stewart 		if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {
3566f8829a4aSRandall Stewart 			if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) {
3567b0552ae2SRandall Stewart 				sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
3568b0552ae2SRandall Stewart 				    SCTP_CALLED_DIRECTLY_NOCMPSET);
3569f8829a4aSRandall Stewart 			}
3570f8829a4aSRandall Stewart 		}
3571f8829a4aSRandall Stewart 	}
3572f8829a4aSRandall Stewart }
3573f8829a4aSRandall Stewart 
3574f1f73e57SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS
3575f1f73e57SRandall Stewart void
3576f1f73e57SRandall Stewart sctp_print_out_track_log(struct sctp_tcb *stcb)
3577f1f73e57SRandall Stewart {
3578f1f73e57SRandall Stewart 	int i;
3579f1f73e57SRandall Stewart 
3580ad81507eSRandall Stewart 	SCTP_PRINTF("Last ep reason:%x\n", stcb->sctp_ep->last_abort_code);
3581ad81507eSRandall Stewart 	SCTP_PRINTF("IN bound TSN log-aaa\n");
3582f1f73e57SRandall Stewart 	if ((stcb->asoc.tsn_in_at == 0) && (stcb->asoc.tsn_in_wrapped == 0)) {
3583ad81507eSRandall Stewart 		SCTP_PRINTF("None rcvd\n");
3584f1f73e57SRandall Stewart 		goto none_in;
3585f1f73e57SRandall Stewart 	}
3586f1f73e57SRandall Stewart 	if (stcb->asoc.tsn_in_wrapped) {
3587f1f73e57SRandall Stewart 		for (i = stcb->asoc.tsn_in_at; i < SCTP_TSN_LOG_SIZE; i++) {
3588ad81507eSRandall Stewart 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",
3589f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].tsn,
3590f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].strm,
3591f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].seq,
3592f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].flgs,
3593f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].sz);
3594f1f73e57SRandall Stewart 		}
3595f1f73e57SRandall Stewart 	}
3596f1f73e57SRandall Stewart 	if (stcb->asoc.tsn_in_at) {
3597f1f73e57SRandall Stewart 		for (i = 0; i < stcb->asoc.tsn_in_at; i++) {
3598ad81507eSRandall Stewart 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",
3599f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].tsn,
3600f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].strm,
3601f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].seq,
3602f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].flgs,
3603f1f73e57SRandall Stewart 			    stcb->asoc.in_tsnlog[i].sz);
3604f1f73e57SRandall Stewart 		}
3605f1f73e57SRandall Stewart 	}
3606f1f73e57SRandall Stewart none_in:
3607ad81507eSRandall Stewart 	SCTP_PRINTF("OUT bound TSN log-aaa\n");
3608ad81507eSRandall Stewart 	if ((stcb->asoc.tsn_out_at == 0) &&
3609ad81507eSRandall Stewart 	    (stcb->asoc.tsn_out_wrapped == 0)) {
3610ad81507eSRandall Stewart 		SCTP_PRINTF("None sent\n");
3611f1f73e57SRandall Stewart 	}
3612f1f73e57SRandall Stewart 	if (stcb->asoc.tsn_out_wrapped) {
3613f1f73e57SRandall Stewart 		for (i = stcb->asoc.tsn_out_at; i < SCTP_TSN_LOG_SIZE; i++) {
3614ad81507eSRandall Stewart 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",
3615f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].tsn,
3616f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].strm,
3617f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].seq,
3618f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].flgs,
3619f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].sz);
3620f1f73e57SRandall Stewart 		}
3621f1f73e57SRandall Stewart 	}
3622f1f73e57SRandall Stewart 	if (stcb->asoc.tsn_out_at) {
3623f1f73e57SRandall Stewart 		for (i = 0; i < stcb->asoc.tsn_out_at; i++) {
3624ad81507eSRandall Stewart 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",
3625f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].tsn,
3626f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].strm,
3627f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].seq,
3628f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].flgs,
3629f1f73e57SRandall Stewart 			    stcb->asoc.out_tsnlog[i].sz);
3630f1f73e57SRandall Stewart 		}
3631f1f73e57SRandall Stewart 	}
3632f1f73e57SRandall Stewart }
3633f1f73e57SRandall Stewart 
3634f1f73e57SRandall Stewart #endif
3635f1f73e57SRandall Stewart 
3636f8829a4aSRandall Stewart void
3637f8829a4aSRandall Stewart sctp_abort_an_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
3638f8829a4aSRandall Stewart     int error, struct mbuf *op_err)
3639f8829a4aSRandall Stewart {
3640f8829a4aSRandall Stewart 	uint32_t vtag;
3641f8829a4aSRandall Stewart 
3642f8829a4aSRandall Stewart 	if (stcb == NULL) {
3643f8829a4aSRandall Stewart 		/* Got to have a TCB */
3644f8829a4aSRandall Stewart 		if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {
3645f8829a4aSRandall Stewart 			if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) {
3646b0552ae2SRandall Stewart 				sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
3647b0552ae2SRandall Stewart 				    SCTP_CALLED_DIRECTLY_NOCMPSET);
3648f8829a4aSRandall Stewart 			}
3649f8829a4aSRandall Stewart 		}
3650f8829a4aSRandall Stewart 		return;
3651f8829a4aSRandall Stewart 	}
3652f8829a4aSRandall Stewart 	vtag = stcb->asoc.peer_vtag;
3653f8829a4aSRandall Stewart 	/* notify the ulp */
3654f8829a4aSRandall Stewart 	if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0)
3655f8829a4aSRandall Stewart 		sctp_abort_notification(stcb, error);
3656f8829a4aSRandall Stewart 	/* notify the peer */
3657f8829a4aSRandall Stewart 	sctp_send_abort_tcb(stcb, op_err);
3658f8829a4aSRandall Stewart 	SCTP_STAT_INCR_COUNTER32(sctps_aborted);
3659f8829a4aSRandall Stewart 	if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) ||
3660f8829a4aSRandall Stewart 	    (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
3661f8829a4aSRandall Stewart 		SCTP_STAT_DECR_GAUGE32(sctps_currestab);
3662f8829a4aSRandall Stewart 	}
3663f8829a4aSRandall Stewart 	/* now free the asoc */
3664f1f73e57SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS
3665f1f73e57SRandall Stewart 	sctp_print_out_track_log(stcb);
3666f1f73e57SRandall Stewart #endif
3667a5d547adSRandall Stewart 	sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_5);
3668f8829a4aSRandall Stewart }
3669f8829a4aSRandall Stewart 
3670f8829a4aSRandall Stewart void
3671f8829a4aSRandall Stewart sctp_handle_ootb(struct mbuf *m, int iphlen, int offset, struct sctphdr *sh,
3672ad21a364SRandall Stewart     struct sctp_inpcb *inp, struct mbuf *op_err, uint32_t vrf_id)
3673f8829a4aSRandall Stewart {
3674f8829a4aSRandall Stewart 	struct sctp_chunkhdr *ch, chunk_buf;
3675f8829a4aSRandall Stewart 	unsigned int chk_length;
3676f8829a4aSRandall Stewart 
3677f8829a4aSRandall Stewart 	SCTP_STAT_INCR_COUNTER32(sctps_outoftheblue);
3678f8829a4aSRandall Stewart 	/* Generate a TO address for future reference */
3679f8829a4aSRandall Stewart 	if (inp && (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
3680f8829a4aSRandall Stewart 		if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) {
3681b0552ae2SRandall Stewart 			sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
3682b0552ae2SRandall Stewart 			    SCTP_CALLED_DIRECTLY_NOCMPSET);
3683f8829a4aSRandall Stewart 		}
3684f8829a4aSRandall Stewart 	}
3685f8829a4aSRandall Stewart 	ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,
3686f8829a4aSRandall Stewart 	    sizeof(*ch), (uint8_t *) & chunk_buf);
3687f8829a4aSRandall Stewart 	while (ch != NULL) {
3688f8829a4aSRandall Stewart 		chk_length = ntohs(ch->chunk_length);
3689f8829a4aSRandall Stewart 		if (chk_length < sizeof(*ch)) {
3690f8829a4aSRandall Stewart 			/* break to abort land */
3691f8829a4aSRandall Stewart 			break;
3692f8829a4aSRandall Stewart 		}
3693f8829a4aSRandall Stewart 		switch (ch->chunk_type) {
3694f8829a4aSRandall Stewart 		case SCTP_PACKET_DROPPED:
3695f8829a4aSRandall Stewart 			/* we don't respond to pkt-dropped */
3696f8829a4aSRandall Stewart 			return;
3697f8829a4aSRandall Stewart 		case SCTP_ABORT_ASSOCIATION:
3698f8829a4aSRandall Stewart 			/* we don't respond with an ABORT to an ABORT */
3699f8829a4aSRandall Stewart 			return;
3700f8829a4aSRandall Stewart 		case SCTP_SHUTDOWN_COMPLETE:
3701f8829a4aSRandall Stewart 			/*
3702f8829a4aSRandall Stewart 			 * we ignore it since we are not waiting for it and
3703f8829a4aSRandall Stewart 			 * peer is gone
3704f8829a4aSRandall Stewart 			 */
3705f8829a4aSRandall Stewart 			return;
3706f8829a4aSRandall Stewart 		case SCTP_SHUTDOWN_ACK:
3707ad21a364SRandall Stewart 			sctp_send_shutdown_complete2(m, iphlen, sh, vrf_id);
3708f8829a4aSRandall Stewart 			return;
3709f8829a4aSRandall Stewart 		default:
3710f8829a4aSRandall Stewart 			break;
3711f8829a4aSRandall Stewart 		}
3712f8829a4aSRandall Stewart 		offset += SCTP_SIZE32(chk_length);
3713f8829a4aSRandall Stewart 		ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,
3714f8829a4aSRandall Stewart 		    sizeof(*ch), (uint8_t *) & chunk_buf);
3715f8829a4aSRandall Stewart 	}
3716ad21a364SRandall Stewart 	sctp_send_abort(m, iphlen, sh, 0, op_err, vrf_id);
3717f8829a4aSRandall Stewart }
3718f8829a4aSRandall Stewart 
3719f8829a4aSRandall Stewart /*
3720f8829a4aSRandall Stewart  * check the inbound datagram to make sure there is not an abort inside it,
3721f8829a4aSRandall Stewart  * if there is return 1, else return 0.
3722f8829a4aSRandall Stewart  */
3723f8829a4aSRandall Stewart int
3724f8829a4aSRandall Stewart sctp_is_there_an_abort_here(struct mbuf *m, int iphlen, uint32_t * vtagfill)
3725f8829a4aSRandall Stewart {
3726f8829a4aSRandall Stewart 	struct sctp_chunkhdr *ch;
3727f8829a4aSRandall Stewart 	struct sctp_init_chunk *init_chk, chunk_buf;
3728f8829a4aSRandall Stewart 	int offset;
3729f8829a4aSRandall Stewart 	unsigned int chk_length;
3730f8829a4aSRandall Stewart 
3731f8829a4aSRandall Stewart 	offset = iphlen + sizeof(struct sctphdr);
3732f8829a4aSRandall Stewart 	ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, sizeof(*ch),
3733f8829a4aSRandall Stewart 	    (uint8_t *) & chunk_buf);
3734f8829a4aSRandall Stewart 	while (ch != NULL) {
3735f8829a4aSRandall Stewart 		chk_length = ntohs(ch->chunk_length);
3736f8829a4aSRandall Stewart 		if (chk_length < sizeof(*ch)) {
3737f8829a4aSRandall Stewart 			/* packet is probably corrupt */
3738f8829a4aSRandall Stewart 			break;
3739f8829a4aSRandall Stewart 		}
3740f8829a4aSRandall Stewart 		/* we seem to be ok, is it an abort? */
3741f8829a4aSRandall Stewart 		if (ch->chunk_type == SCTP_ABORT_ASSOCIATION) {
3742f8829a4aSRandall Stewart 			/* yep, tell them */
3743f8829a4aSRandall Stewart 			return (1);
3744f8829a4aSRandall Stewart 		}
3745f8829a4aSRandall Stewart 		if (ch->chunk_type == SCTP_INITIATION) {
3746f8829a4aSRandall Stewart 			/* need to update the Vtag */
3747f8829a4aSRandall Stewart 			init_chk = (struct sctp_init_chunk *)sctp_m_getptr(m,
3748f8829a4aSRandall Stewart 			    offset, sizeof(*init_chk), (uint8_t *) & chunk_buf);
3749f8829a4aSRandall Stewart 			if (init_chk != NULL) {
3750f8829a4aSRandall Stewart 				*vtagfill = ntohl(init_chk->init.initiate_tag);
3751f8829a4aSRandall Stewart 			}
3752f8829a4aSRandall Stewart 		}
3753f8829a4aSRandall Stewart 		/* Nope, move to the next chunk */
3754f8829a4aSRandall Stewart 		offset += SCTP_SIZE32(chk_length);
3755f8829a4aSRandall Stewart 		ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,
3756f8829a4aSRandall Stewart 		    sizeof(*ch), (uint8_t *) & chunk_buf);
3757f8829a4aSRandall Stewart 	}
3758f8829a4aSRandall Stewart 	return (0);
3759f8829a4aSRandall Stewart }
3760f8829a4aSRandall Stewart 
3761f8829a4aSRandall Stewart /*
3762f8829a4aSRandall Stewart  * currently (2/02), ifa_addr embeds scope_id's and don't have sin6_scope_id
3763f8829a4aSRandall Stewart  * set (i.e. it's 0) so, create this function to compare link local scopes
3764f8829a4aSRandall Stewart  */
3765f8829a4aSRandall Stewart uint32_t
3766f8829a4aSRandall Stewart sctp_is_same_scope(struct sockaddr_in6 *addr1, struct sockaddr_in6 *addr2)
3767f8829a4aSRandall Stewart {
3768f8829a4aSRandall Stewart 	struct sockaddr_in6 a, b;
3769f8829a4aSRandall Stewart 
3770f8829a4aSRandall Stewart 	/* save copies */
3771f8829a4aSRandall Stewart 	a = *addr1;
3772f8829a4aSRandall Stewart 	b = *addr2;
3773f8829a4aSRandall Stewart 
3774f8829a4aSRandall Stewart 	if (a.sin6_scope_id == 0)
3775f8829a4aSRandall Stewart 		if (sa6_recoverscope(&a)) {
3776f8829a4aSRandall Stewart 			/* can't get scope, so can't match */
3777f8829a4aSRandall Stewart 			return (0);
3778f8829a4aSRandall Stewart 		}
3779f8829a4aSRandall Stewart 	if (b.sin6_scope_id == 0)
3780f8829a4aSRandall Stewart 		if (sa6_recoverscope(&b)) {
3781f8829a4aSRandall Stewart 			/* can't get scope, so can't match */
3782f8829a4aSRandall Stewart 			return (0);
3783f8829a4aSRandall Stewart 		}
3784f8829a4aSRandall Stewart 	if (a.sin6_scope_id != b.sin6_scope_id)
3785f8829a4aSRandall Stewart 		return (0);
3786f8829a4aSRandall Stewart 
3787f8829a4aSRandall Stewart 	return (1);
3788f8829a4aSRandall Stewart }
3789f8829a4aSRandall Stewart 
3790f8829a4aSRandall Stewart /*
3791f8829a4aSRandall Stewart  * returns a sockaddr_in6 with embedded scope recovered and removed
3792f8829a4aSRandall Stewart  */
3793f8829a4aSRandall Stewart struct sockaddr_in6 *
3794f8829a4aSRandall Stewart sctp_recover_scope(struct sockaddr_in6 *addr, struct sockaddr_in6 *store)
3795f8829a4aSRandall Stewart {
3796f8829a4aSRandall Stewart 	/* check and strip embedded scope junk */
3797f8829a4aSRandall Stewart 	if (addr->sin6_family == AF_INET6) {
3798f8829a4aSRandall Stewart 		if (IN6_IS_SCOPE_LINKLOCAL(&addr->sin6_addr)) {
3799f8829a4aSRandall Stewart 			if (addr->sin6_scope_id == 0) {
3800f8829a4aSRandall Stewart 				*store = *addr;
3801f8829a4aSRandall Stewart 				if (!sa6_recoverscope(store)) {
3802f8829a4aSRandall Stewart 					/* use the recovered scope */
3803f8829a4aSRandall Stewart 					addr = store;
3804f8829a4aSRandall Stewart 				}
3805f42a358aSRandall Stewart 			} else {
3806f8829a4aSRandall Stewart 				/* else, return the original "to" addr */
3807f42a358aSRandall Stewart 				in6_clearscope(&addr->sin6_addr);
3808f8829a4aSRandall Stewart 			}
3809f8829a4aSRandall Stewart 		}
3810f8829a4aSRandall Stewart 	}
3811f8829a4aSRandall Stewart 	return (addr);
3812f8829a4aSRandall Stewart }
3813f8829a4aSRandall Stewart 
3814f8829a4aSRandall Stewart /*
3815f8829a4aSRandall Stewart  * are the two addresses the same?  currently a "scopeless" check returns: 1
3816f8829a4aSRandall Stewart  * if same, 0 if not
3817f8829a4aSRandall Stewart  */
381872fb6fdbSRandall Stewart int
3819f8829a4aSRandall Stewart sctp_cmpaddr(struct sockaddr *sa1, struct sockaddr *sa2)
3820f8829a4aSRandall Stewart {
3821f8829a4aSRandall Stewart 
3822f8829a4aSRandall Stewart 	/* must be valid */
3823f8829a4aSRandall Stewart 	if (sa1 == NULL || sa2 == NULL)
3824f8829a4aSRandall Stewart 		return (0);
3825f8829a4aSRandall Stewart 
3826f8829a4aSRandall Stewart 	/* must be the same family */
3827f8829a4aSRandall Stewart 	if (sa1->sa_family != sa2->sa_family)
3828f8829a4aSRandall Stewart 		return (0);
3829f8829a4aSRandall Stewart 
3830f8829a4aSRandall Stewart 	if (sa1->sa_family == AF_INET6) {
3831f8829a4aSRandall Stewart 		/* IPv6 addresses */
3832f8829a4aSRandall Stewart 		struct sockaddr_in6 *sin6_1, *sin6_2;
3833f8829a4aSRandall Stewart 
3834f8829a4aSRandall Stewart 		sin6_1 = (struct sockaddr_in6 *)sa1;
3835f8829a4aSRandall Stewart 		sin6_2 = (struct sockaddr_in6 *)sa2;
3836f8829a4aSRandall Stewart 		return (SCTP6_ARE_ADDR_EQUAL(&sin6_1->sin6_addr,
3837f8829a4aSRandall Stewart 		    &sin6_2->sin6_addr));
3838f8829a4aSRandall Stewart 	} else if (sa1->sa_family == AF_INET) {
3839f8829a4aSRandall Stewart 		/* IPv4 addresses */
3840f8829a4aSRandall Stewart 		struct sockaddr_in *sin_1, *sin_2;
3841f8829a4aSRandall Stewart 
3842f8829a4aSRandall Stewart 		sin_1 = (struct sockaddr_in *)sa1;
3843f8829a4aSRandall Stewart 		sin_2 = (struct sockaddr_in *)sa2;
3844f8829a4aSRandall Stewart 		return (sin_1->sin_addr.s_addr == sin_2->sin_addr.s_addr);
3845f8829a4aSRandall Stewart 	} else {
3846f8829a4aSRandall Stewart 		/* we don't do these... */
3847f8829a4aSRandall Stewart 		return (0);
3848f8829a4aSRandall Stewart 	}
3849f8829a4aSRandall Stewart }
3850f8829a4aSRandall Stewart 
3851f8829a4aSRandall Stewart void
3852f8829a4aSRandall Stewart sctp_print_address(struct sockaddr *sa)
3853f8829a4aSRandall Stewart {
38547d32aa0cSBjoern A. Zeeb 	char ip6buf[INET6_ADDRSTRLEN];
3855f8829a4aSRandall Stewart 
3856ad81507eSRandall Stewart 	ip6buf[0] = 0;
3857ad81507eSRandall Stewart 	if (sa->sa_family == AF_INET6) {
3858ad81507eSRandall Stewart 		struct sockaddr_in6 *sin6;
3859ad81507eSRandall Stewart 
3860f8829a4aSRandall Stewart 		sin6 = (struct sockaddr_in6 *)sa;
3861ad81507eSRandall Stewart 		SCTP_PRINTF("IPv6 address: %s:port:%d scope:%u\n",
38627d32aa0cSBjoern A. Zeeb 		    ip6_sprintf(ip6buf, &sin6->sin6_addr),
38637d32aa0cSBjoern A. Zeeb 		    ntohs(sin6->sin6_port),
3864f8829a4aSRandall Stewart 		    sin6->sin6_scope_id);
3865f8829a4aSRandall Stewart 	} else if (sa->sa_family == AF_INET) {
3866f8829a4aSRandall Stewart 		struct sockaddr_in *sin;
3867f8829a4aSRandall Stewart 		unsigned char *p;
3868f8829a4aSRandall Stewart 
3869f8829a4aSRandall Stewart 		sin = (struct sockaddr_in *)sa;
3870f8829a4aSRandall Stewart 		p = (unsigned char *)&sin->sin_addr;
3871ad81507eSRandall Stewart 		SCTP_PRINTF("IPv4 address: %u.%u.%u.%u:%d\n",
3872f8829a4aSRandall Stewart 		    p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
3873f8829a4aSRandall Stewart 	} else {
3874ad81507eSRandall Stewart 		SCTP_PRINTF("?\n");
3875f8829a4aSRandall Stewart 	}
3876f8829a4aSRandall Stewart }
3877f8829a4aSRandall Stewart 
3878f8829a4aSRandall Stewart void
3879f8829a4aSRandall Stewart sctp_print_address_pkt(struct ip *iph, struct sctphdr *sh)
3880f8829a4aSRandall Stewart {
3881f8829a4aSRandall Stewart 	if (iph->ip_v == IPVERSION) {
3882f8829a4aSRandall Stewart 		struct sockaddr_in lsa, fsa;
3883f8829a4aSRandall Stewart 
3884f8829a4aSRandall Stewart 		bzero(&lsa, sizeof(lsa));
3885f8829a4aSRandall Stewart 		lsa.sin_len = sizeof(lsa);
3886f8829a4aSRandall Stewart 		lsa.sin_family = AF_INET;
3887f8829a4aSRandall Stewart 		lsa.sin_addr = iph->ip_src;
3888f8829a4aSRandall Stewart 		lsa.sin_port = sh->src_port;
3889f8829a4aSRandall Stewart 		bzero(&fsa, sizeof(fsa));
3890f8829a4aSRandall Stewart 		fsa.sin_len = sizeof(fsa);
3891f8829a4aSRandall Stewart 		fsa.sin_family = AF_INET;
3892f8829a4aSRandall Stewart 		fsa.sin_addr = iph->ip_dst;
3893f8829a4aSRandall Stewart 		fsa.sin_port = sh->dest_port;
3894ad81507eSRandall Stewart 		SCTP_PRINTF("src: ");
3895f8829a4aSRandall Stewart 		sctp_print_address((struct sockaddr *)&lsa);
3896ad81507eSRandall Stewart 		SCTP_PRINTF("dest: ");
3897f8829a4aSRandall Stewart 		sctp_print_address((struct sockaddr *)&fsa);
3898f8829a4aSRandall Stewart 	} else if (iph->ip_v == (IPV6_VERSION >> 4)) {
3899f8829a4aSRandall Stewart 		struct ip6_hdr *ip6;
3900f8829a4aSRandall Stewart 		struct sockaddr_in6 lsa6, fsa6;
3901f8829a4aSRandall Stewart 
3902f8829a4aSRandall Stewart 		ip6 = (struct ip6_hdr *)iph;
3903f8829a4aSRandall Stewart 		bzero(&lsa6, sizeof(lsa6));
3904f8829a4aSRandall Stewart 		lsa6.sin6_len = sizeof(lsa6);
3905f8829a4aSRandall Stewart 		lsa6.sin6_family = AF_INET6;
3906f8829a4aSRandall Stewart 		lsa6.sin6_addr = ip6->ip6_src;
3907f8829a4aSRandall Stewart 		lsa6.sin6_port = sh->src_port;
3908f8829a4aSRandall Stewart 		bzero(&fsa6, sizeof(fsa6));
3909f8829a4aSRandall Stewart 		fsa6.sin6_len = sizeof(fsa6);
3910f8829a4aSRandall Stewart 		fsa6.sin6_family = AF_INET6;
3911f8829a4aSRandall Stewart 		fsa6.sin6_addr = ip6->ip6_dst;
3912f8829a4aSRandall Stewart 		fsa6.sin6_port = sh->dest_port;
3913ad81507eSRandall Stewart 		SCTP_PRINTF("src: ");
3914f8829a4aSRandall Stewart 		sctp_print_address((struct sockaddr *)&lsa6);
3915ad81507eSRandall Stewart 		SCTP_PRINTF("dest: ");
3916f8829a4aSRandall Stewart 		sctp_print_address((struct sockaddr *)&fsa6);
3917f8829a4aSRandall Stewart 	}
3918f8829a4aSRandall Stewart }
3919f8829a4aSRandall Stewart 
3920f8829a4aSRandall Stewart void
3921f8829a4aSRandall Stewart sctp_pull_off_control_to_new_inp(struct sctp_inpcb *old_inp,
3922f8829a4aSRandall Stewart     struct sctp_inpcb *new_inp,
3923d06c82f1SRandall Stewart     struct sctp_tcb *stcb,
3924d06c82f1SRandall Stewart     int waitflags)
3925f8829a4aSRandall Stewart {
3926f8829a4aSRandall Stewart 	/*
3927f8829a4aSRandall Stewart 	 * go through our old INP and pull off any control structures that
3928f8829a4aSRandall Stewart 	 * belong to stcb and move then to the new inp.
3929f8829a4aSRandall Stewart 	 */
3930f8829a4aSRandall Stewart 	struct socket *old_so, *new_so;
3931f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control, *nctl;
3932f8829a4aSRandall Stewart 	struct sctp_readhead tmp_queue;
3933f8829a4aSRandall Stewart 	struct mbuf *m;
3934bff64a4dSRandall Stewart 	int error = 0;
3935f8829a4aSRandall Stewart 
3936f8829a4aSRandall Stewart 	old_so = old_inp->sctp_socket;
3937f8829a4aSRandall Stewart 	new_so = new_inp->sctp_socket;
3938f8829a4aSRandall Stewart 	TAILQ_INIT(&tmp_queue);
3939d06c82f1SRandall Stewart 	error = sblock(&old_so->so_rcv, waitflags);
3940f8829a4aSRandall Stewart 	if (error) {
3941f8829a4aSRandall Stewart 		/*
3942f8829a4aSRandall Stewart 		 * Gak, can't get sblock, we have a problem. data will be
3943f8829a4aSRandall Stewart 		 * left stranded.. and we don't dare look at it since the
3944f8829a4aSRandall Stewart 		 * other thread may be reading something. Oh well, its a
3945f8829a4aSRandall Stewart 		 * screwed up app that does a peeloff OR a accept while
3946f8829a4aSRandall Stewart 		 * reading from the main socket... actually its only the
3947f8829a4aSRandall Stewart 		 * peeloff() case, since I think read will fail on a
3948f8829a4aSRandall Stewart 		 * listening socket..
3949f8829a4aSRandall Stewart 		 */
3950f8829a4aSRandall Stewart 		return;
3951f8829a4aSRandall Stewart 	}
3952f8829a4aSRandall Stewart 	/* lock the socket buffers */
3953f8829a4aSRandall Stewart 	SCTP_INP_READ_LOCK(old_inp);
3954f8829a4aSRandall Stewart 	control = TAILQ_FIRST(&old_inp->read_queue);
3955f8829a4aSRandall Stewart 	/* Pull off all for out target stcb */
3956f8829a4aSRandall Stewart 	while (control) {
3957f8829a4aSRandall Stewart 		nctl = TAILQ_NEXT(control, next);
3958f8829a4aSRandall Stewart 		if (control->stcb == stcb) {
3959f8829a4aSRandall Stewart 			/* remove it we want it */
3960f8829a4aSRandall Stewart 			TAILQ_REMOVE(&old_inp->read_queue, control, next);
3961f8829a4aSRandall Stewart 			TAILQ_INSERT_TAIL(&tmp_queue, control, next);
3962f8829a4aSRandall Stewart 			m = control->data;
3963f8829a4aSRandall Stewart 			while (m) {
396480fefe0aSRandall Stewart 				if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
3965139bc87fSRandall Stewart 					sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));
396680fefe0aSRandall Stewart 				}
3967f8829a4aSRandall Stewart 				sctp_sbfree(control, stcb, &old_so->so_rcv, m);
396880fefe0aSRandall Stewart 				if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
3969f8829a4aSRandall Stewart 					sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
397080fefe0aSRandall Stewart 				}
3971139bc87fSRandall Stewart 				m = SCTP_BUF_NEXT(m);
3972f8829a4aSRandall Stewart 			}
3973f8829a4aSRandall Stewart 		}
3974f8829a4aSRandall Stewart 		control = nctl;
3975f8829a4aSRandall Stewart 	}
3976f8829a4aSRandall Stewart 	SCTP_INP_READ_UNLOCK(old_inp);
3977f8829a4aSRandall Stewart 	/* Remove the sb-lock on the old socket */
3978f8829a4aSRandall Stewart 
3979f8829a4aSRandall Stewart 	sbunlock(&old_so->so_rcv);
3980f8829a4aSRandall Stewart 	/* Now we move them over to the new socket buffer */
3981f8829a4aSRandall Stewart 	control = TAILQ_FIRST(&tmp_queue);
3982f8829a4aSRandall Stewart 	SCTP_INP_READ_LOCK(new_inp);
3983f8829a4aSRandall Stewart 	while (control) {
3984f8829a4aSRandall Stewart 		nctl = TAILQ_NEXT(control, next);
3985f8829a4aSRandall Stewart 		TAILQ_INSERT_TAIL(&new_inp->read_queue, control, next);
3986f8829a4aSRandall Stewart 		m = control->data;
3987f8829a4aSRandall Stewart 		while (m) {
398880fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
3989139bc87fSRandall Stewart 				sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m));
399080fefe0aSRandall Stewart 			}
3991f8829a4aSRandall Stewart 			sctp_sballoc(stcb, &new_so->so_rcv, m);
399280fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
3993f8829a4aSRandall Stewart 				sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
399480fefe0aSRandall Stewart 			}
3995139bc87fSRandall Stewart 			m = SCTP_BUF_NEXT(m);
3996f8829a4aSRandall Stewart 		}
3997f8829a4aSRandall Stewart 		control = nctl;
3998f8829a4aSRandall Stewart 	}
3999f8829a4aSRandall Stewart 	SCTP_INP_READ_UNLOCK(new_inp);
4000f8829a4aSRandall Stewart }
4001f8829a4aSRandall Stewart 
4002f8829a4aSRandall Stewart 
4003f8829a4aSRandall Stewart void
4004f8829a4aSRandall Stewart sctp_add_to_readq(struct sctp_inpcb *inp,
4005f8829a4aSRandall Stewart     struct sctp_tcb *stcb,
4006f8829a4aSRandall Stewart     struct sctp_queued_to_read *control,
4007f8829a4aSRandall Stewart     struct sockbuf *sb,
4008f8829a4aSRandall Stewart     int end)
4009f8829a4aSRandall Stewart {
4010f8829a4aSRandall Stewart 	/*
4011f8829a4aSRandall Stewart 	 * Here we must place the control on the end of the socket read
4012f8829a4aSRandall Stewart 	 * queue AND increment sb_cc so that select will work properly on
4013f8829a4aSRandall Stewart 	 * read.
4014f8829a4aSRandall Stewart 	 */
4015f8829a4aSRandall Stewart 	struct mbuf *m, *prev = NULL;
4016f8829a4aSRandall Stewart 
401703b0b021SRandall Stewart 	if (inp == NULL) {
401803b0b021SRandall Stewart 		/* Gak, TSNH!! */
4019a5d547adSRandall Stewart #ifdef INVARIANTS
402003b0b021SRandall Stewart 		panic("Gak, inp NULL on add_to_readq");
402103b0b021SRandall Stewart #endif
402203b0b021SRandall Stewart 		return;
402303b0b021SRandall Stewart 	}
4024f8829a4aSRandall Stewart 	SCTP_INP_READ_LOCK(inp);
402542551e99SRandall Stewart 	if (!(control->spec_flags & M_NOTIFICATION)) {
4026a5d547adSRandall Stewart 		atomic_add_int(&inp->total_recvs, 1);
402742551e99SRandall Stewart 		if (!control->do_not_ref_stcb) {
4028a5d547adSRandall Stewart 			atomic_add_int(&stcb->total_recvs, 1);
402942551e99SRandall Stewart 		}
403042551e99SRandall Stewart 	}
4031f8829a4aSRandall Stewart 	m = control->data;
4032f8829a4aSRandall Stewart 	control->held_length = 0;
4033f8829a4aSRandall Stewart 	control->length = 0;
4034f8829a4aSRandall Stewart 	while (m) {
4035139bc87fSRandall Stewart 		if (SCTP_BUF_LEN(m) == 0) {
4036f8829a4aSRandall Stewart 			/* Skip mbufs with NO length */
4037f8829a4aSRandall Stewart 			if (prev == NULL) {
4038f8829a4aSRandall Stewart 				/* First one */
4039f8829a4aSRandall Stewart 				control->data = sctp_m_free(m);
4040f8829a4aSRandall Stewart 				m = control->data;
4041f8829a4aSRandall Stewart 			} else {
4042139bc87fSRandall Stewart 				SCTP_BUF_NEXT(prev) = sctp_m_free(m);
4043139bc87fSRandall Stewart 				m = SCTP_BUF_NEXT(prev);
4044f8829a4aSRandall Stewart 			}
4045f8829a4aSRandall Stewart 			if (m == NULL) {
4046f8829a4aSRandall Stewart 				control->tail_mbuf = prev;;
4047f8829a4aSRandall Stewart 			}
4048f8829a4aSRandall Stewart 			continue;
4049f8829a4aSRandall Stewart 		}
4050f8829a4aSRandall Stewart 		prev = m;
405180fefe0aSRandall Stewart 		if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
4052139bc87fSRandall Stewart 			sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m));
405380fefe0aSRandall Stewart 		}
4054f8829a4aSRandall Stewart 		sctp_sballoc(stcb, sb, m);
405580fefe0aSRandall Stewart 		if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
4056f8829a4aSRandall Stewart 			sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
405780fefe0aSRandall Stewart 		}
4058139bc87fSRandall Stewart 		atomic_add_int(&control->length, SCTP_BUF_LEN(m));
4059139bc87fSRandall Stewart 		m = SCTP_BUF_NEXT(m);
4060f8829a4aSRandall Stewart 	}
4061f8829a4aSRandall Stewart 	if (prev != NULL) {
4062f8829a4aSRandall Stewart 		control->tail_mbuf = prev;
4063f8829a4aSRandall Stewart 	} else {
4064139bc87fSRandall Stewart 		/* Everything got collapsed out?? */
4065f8829a4aSRandall Stewart 		return;
4066f8829a4aSRandall Stewart 	}
4067f8829a4aSRandall Stewart 	if (end) {
4068f8829a4aSRandall Stewart 		control->end_added = 1;
4069f8829a4aSRandall Stewart 	}
4070f8829a4aSRandall Stewart 	TAILQ_INSERT_TAIL(&inp->read_queue, control, next);
4071f8829a4aSRandall Stewart 	SCTP_INP_READ_UNLOCK(inp);
4072f8829a4aSRandall Stewart 	if (inp && inp->sctp_socket) {
407317205eccSRandall Stewart 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {
407417205eccSRandall Stewart 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);
407517205eccSRandall Stewart 		} else
4076f8829a4aSRandall Stewart 			sctp_sorwakeup(inp, inp->sctp_socket);
4077f8829a4aSRandall Stewart 	}
4078f8829a4aSRandall Stewart }
4079f8829a4aSRandall Stewart 
4080f8829a4aSRandall Stewart 
4081f8829a4aSRandall Stewart int
4082f8829a4aSRandall Stewart sctp_append_to_readq(struct sctp_inpcb *inp,
4083f8829a4aSRandall Stewart     struct sctp_tcb *stcb,
4084f8829a4aSRandall Stewart     struct sctp_queued_to_read *control,
4085f8829a4aSRandall Stewart     struct mbuf *m,
4086f8829a4aSRandall Stewart     int end,
4087f8829a4aSRandall Stewart     int ctls_cumack,
4088f8829a4aSRandall Stewart     struct sockbuf *sb)
4089f8829a4aSRandall Stewart {
4090f8829a4aSRandall Stewart 	/*
4091f8829a4aSRandall Stewart 	 * A partial delivery API event is underway. OR we are appending on
4092f8829a4aSRandall Stewart 	 * the reassembly queue.
4093f8829a4aSRandall Stewart 	 *
4094f8829a4aSRandall Stewart 	 * If PDAPI this means we need to add m to the end of the data.
4095f8829a4aSRandall Stewart 	 * Increase the length in the control AND increment the sb_cc.
4096f8829a4aSRandall Stewart 	 * Otherwise sb is NULL and all we need to do is put it at the end
4097f8829a4aSRandall Stewart 	 * of the mbuf chain.
4098f8829a4aSRandall Stewart 	 */
4099f8829a4aSRandall Stewart 	int len = 0;
4100f8829a4aSRandall Stewart 	struct mbuf *mm, *tail = NULL, *prev = NULL;
4101f8829a4aSRandall Stewart 
4102f8829a4aSRandall Stewart 	if (inp) {
4103f8829a4aSRandall Stewart 		SCTP_INP_READ_LOCK(inp);
4104f8829a4aSRandall Stewart 	}
4105f8829a4aSRandall Stewart 	if (control == NULL) {
4106f8829a4aSRandall Stewart get_out:
4107f8829a4aSRandall Stewart 		if (inp) {
4108f8829a4aSRandall Stewart 			SCTP_INP_READ_UNLOCK(inp);
4109f8829a4aSRandall Stewart 		}
4110f8829a4aSRandall Stewart 		return (-1);
4111f8829a4aSRandall Stewart 	}
4112139bc87fSRandall Stewart 	if (control->end_added) {
4113f8829a4aSRandall Stewart 		/* huh this one is complete? */
4114f8829a4aSRandall Stewart 		goto get_out;
4115f8829a4aSRandall Stewart 	}
4116f8829a4aSRandall Stewart 	mm = m;
4117f8829a4aSRandall Stewart 	if (mm == NULL) {
4118f8829a4aSRandall Stewart 		goto get_out;
4119f8829a4aSRandall Stewart 	}
4120f8829a4aSRandall Stewart 	while (mm) {
4121139bc87fSRandall Stewart 		if (SCTP_BUF_LEN(mm) == 0) {
4122f8829a4aSRandall Stewart 			/* Skip mbufs with NO lenght */
4123f8829a4aSRandall Stewart 			if (prev == NULL) {
4124f8829a4aSRandall Stewart 				/* First one */
4125f8829a4aSRandall Stewart 				m = sctp_m_free(mm);
4126f8829a4aSRandall Stewart 				mm = m;
4127f8829a4aSRandall Stewart 			} else {
4128139bc87fSRandall Stewart 				SCTP_BUF_NEXT(prev) = sctp_m_free(mm);
4129139bc87fSRandall Stewart 				mm = SCTP_BUF_NEXT(prev);
4130f8829a4aSRandall Stewart 			}
4131f8829a4aSRandall Stewart 			continue;
4132f8829a4aSRandall Stewart 		}
4133f8829a4aSRandall Stewart 		prev = mm;
4134139bc87fSRandall Stewart 		len += SCTP_BUF_LEN(mm);
4135f8829a4aSRandall Stewart 		if (sb) {
413680fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
4137139bc87fSRandall Stewart 				sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(mm));
413880fefe0aSRandall Stewart 			}
4139f8829a4aSRandall Stewart 			sctp_sballoc(stcb, sb, mm);
414080fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
4141f8829a4aSRandall Stewart 				sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
414280fefe0aSRandall Stewart 			}
4143f8829a4aSRandall Stewart 		}
4144139bc87fSRandall Stewart 		mm = SCTP_BUF_NEXT(mm);
4145f8829a4aSRandall Stewart 	}
4146f8829a4aSRandall Stewart 	if (prev) {
4147f8829a4aSRandall Stewart 		tail = prev;
4148f8829a4aSRandall Stewart 	} else {
4149f8829a4aSRandall Stewart 		/* Really there should always be a prev */
4150f8829a4aSRandall Stewart 		if (m == NULL) {
4151f8829a4aSRandall Stewart 			/* Huh nothing left? */
4152a5d547adSRandall Stewart #ifdef INVARIANTS
4153f8829a4aSRandall Stewart 			panic("Nothing left to add?");
4154f8829a4aSRandall Stewart #else
4155f8829a4aSRandall Stewart 			goto get_out;
4156f8829a4aSRandall Stewart #endif
4157f8829a4aSRandall Stewart 		}
4158f8829a4aSRandall Stewart 		tail = m;
4159f8829a4aSRandall Stewart 	}
4160f8829a4aSRandall Stewart 	if (end) {
4161f8829a4aSRandall Stewart 		/* message is complete */
4162ad81507eSRandall Stewart 		if (stcb && (control == stcb->asoc.control_pdapi)) {
4163f8829a4aSRandall Stewart 			stcb->asoc.control_pdapi = NULL;
4164f8829a4aSRandall Stewart 		}
4165f8829a4aSRandall Stewart 		control->held_length = 0;
4166f8829a4aSRandall Stewart 		control->end_added = 1;
4167f8829a4aSRandall Stewart 	}
4168f8829a4aSRandall Stewart 	atomic_add_int(&control->length, len);
4169f8829a4aSRandall Stewart 	if (control->tail_mbuf) {
4170f8829a4aSRandall Stewart 		/* append */
4171139bc87fSRandall Stewart 		SCTP_BUF_NEXT(control->tail_mbuf) = m;
4172f8829a4aSRandall Stewart 		control->tail_mbuf = tail;
4173f8829a4aSRandall Stewart 	} else {
4174f8829a4aSRandall Stewart 		/* nothing there */
4175a5d547adSRandall Stewart #ifdef INVARIANTS
4176f8829a4aSRandall Stewart 		if (control->data != NULL) {
4177f8829a4aSRandall Stewart 			panic("This should NOT happen");
4178f8829a4aSRandall Stewart 		}
4179f8829a4aSRandall Stewart #endif
4180f8829a4aSRandall Stewart 		control->data = m;
4181f8829a4aSRandall Stewart 		control->tail_mbuf = tail;
4182f8829a4aSRandall Stewart 	}
4183ad81507eSRandall Stewart 	if (stcb == NULL) {
4184ad81507eSRandall Stewart 		control->do_not_ref_stcb = 1;
4185ad81507eSRandall Stewart 	}
4186f8829a4aSRandall Stewart 	/*
4187f8829a4aSRandall Stewart 	 * When we are appending in partial delivery, the cum-ack is used
4188f8829a4aSRandall Stewart 	 * for the actual pd-api highest tsn on this mbuf. The true cum-ack
4189f8829a4aSRandall Stewart 	 * is populated in the outbound sinfo structure from the true cumack
4190f8829a4aSRandall Stewart 	 * if the association exists...
4191f8829a4aSRandall Stewart 	 */
4192f8829a4aSRandall Stewart 	control->sinfo_tsn = control->sinfo_cumtsn = ctls_cumack;
4193f8829a4aSRandall Stewart 	if (inp) {
4194f8829a4aSRandall Stewart 		SCTP_INP_READ_UNLOCK(inp);
4195f8829a4aSRandall Stewart 	}
4196f8829a4aSRandall Stewart 	if (inp && inp->sctp_socket) {
419717205eccSRandall Stewart 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {
419817205eccSRandall Stewart 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);
419917205eccSRandall Stewart 		} else
4200f8829a4aSRandall Stewart 			sctp_sorwakeup(inp, inp->sctp_socket);
4201f8829a4aSRandall Stewart 	}
4202f8829a4aSRandall Stewart 	return (0);
4203f8829a4aSRandall Stewart }
4204f8829a4aSRandall Stewart 
4205f8829a4aSRandall Stewart 
4206f8829a4aSRandall Stewart 
4207f8829a4aSRandall Stewart /*************HOLD THIS COMMENT FOR PATCH FILE OF
4208f8829a4aSRandall Stewart  *************ALTERNATE ROUTING CODE
4209f8829a4aSRandall Stewart  */
4210f8829a4aSRandall Stewart 
4211f8829a4aSRandall Stewart /*************HOLD THIS COMMENT FOR END OF PATCH FILE OF
4212f8829a4aSRandall Stewart  *************ALTERNATE ROUTING CODE
4213f8829a4aSRandall Stewart  */
4214f8829a4aSRandall Stewart 
4215f8829a4aSRandall Stewart struct mbuf *
4216f8829a4aSRandall Stewart sctp_generate_invmanparam(int err)
4217f8829a4aSRandall Stewart {
4218f8829a4aSRandall Stewart 	/* Return a MBUF with a invalid mandatory parameter */
4219f8829a4aSRandall Stewart 	struct mbuf *m;
4220f8829a4aSRandall Stewart 
4221f8829a4aSRandall Stewart 	m = sctp_get_mbuf_for_msg(sizeof(struct sctp_paramhdr), 0, M_DONTWAIT, 1, MT_DATA);
4222f8829a4aSRandall Stewart 	if (m) {
4223f8829a4aSRandall Stewart 		struct sctp_paramhdr *ph;
4224f8829a4aSRandall Stewart 
4225139bc87fSRandall Stewart 		SCTP_BUF_LEN(m) = sizeof(struct sctp_paramhdr);
4226f8829a4aSRandall Stewart 		ph = mtod(m, struct sctp_paramhdr *);
4227f8829a4aSRandall Stewart 		ph->param_length = htons(sizeof(struct sctp_paramhdr));
4228f8829a4aSRandall Stewart 		ph->param_type = htons(err);
4229f8829a4aSRandall Stewart 	}
4230f8829a4aSRandall Stewart 	return (m);
4231f8829a4aSRandall Stewart }
4232f8829a4aSRandall Stewart 
4233f8829a4aSRandall Stewart #ifdef SCTP_MBCNT_LOGGING
4234f8829a4aSRandall Stewart void
4235f8829a4aSRandall Stewart sctp_free_bufspace(struct sctp_tcb *stcb, struct sctp_association *asoc,
4236f8829a4aSRandall Stewart     struct sctp_tmit_chunk *tp1, int chk_cnt)
4237f8829a4aSRandall Stewart {
4238f8829a4aSRandall Stewart 	if (tp1->data == NULL) {
4239f8829a4aSRandall Stewart 		return;
4240f8829a4aSRandall Stewart 	}
4241f8829a4aSRandall Stewart 	asoc->chunks_on_out_queue -= chk_cnt;
424280fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_MBCNT_LOGGING_ENABLE) {
4243f8829a4aSRandall Stewart 		sctp_log_mbcnt(SCTP_LOG_MBCNT_DECREASE,
4244f8829a4aSRandall Stewart 		    asoc->total_output_queue_size,
4245f8829a4aSRandall Stewart 		    tp1->book_size,
4246f8829a4aSRandall Stewart 		    0,
4247f8829a4aSRandall Stewart 		    tp1->mbcnt);
424880fefe0aSRandall Stewart 	}
4249f8829a4aSRandall Stewart 	if (asoc->total_output_queue_size >= tp1->book_size) {
425044b7479bSRandall Stewart 		atomic_add_int(&asoc->total_output_queue_size, -tp1->book_size);
4251f8829a4aSRandall Stewart 	} else {
4252f8829a4aSRandall Stewart 		asoc->total_output_queue_size = 0;
4253f8829a4aSRandall Stewart 	}
4254f8829a4aSRandall Stewart 
4255f8829a4aSRandall Stewart 	if (stcb->sctp_socket && (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) ||
4256f8829a4aSRandall Stewart 	    ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE)))) {
4257f8829a4aSRandall Stewart 		if (stcb->sctp_socket->so_snd.sb_cc >= tp1->book_size) {
4258f8829a4aSRandall Stewart 			stcb->sctp_socket->so_snd.sb_cc -= tp1->book_size;
4259f8829a4aSRandall Stewart 		} else {
4260f8829a4aSRandall Stewart 			stcb->sctp_socket->so_snd.sb_cc = 0;
4261f8829a4aSRandall Stewart 
4262f8829a4aSRandall Stewart 		}
4263f8829a4aSRandall Stewart 	}
4264f8829a4aSRandall Stewart }
4265f8829a4aSRandall Stewart 
4266f8829a4aSRandall Stewart #endif
4267f8829a4aSRandall Stewart 
4268f8829a4aSRandall Stewart int
4269f8829a4aSRandall Stewart sctp_release_pr_sctp_chunk(struct sctp_tcb *stcb, struct sctp_tmit_chunk *tp1,
4270f8829a4aSRandall Stewart     int reason, struct sctpchunk_listhead *queue)
4271f8829a4aSRandall Stewart {
4272f8829a4aSRandall Stewart 	int ret_sz = 0;
4273f8829a4aSRandall Stewart 	int notdone;
4274f8829a4aSRandall Stewart 	uint8_t foundeom = 0;
4275f8829a4aSRandall Stewart 
4276f8829a4aSRandall Stewart 	do {
4277f8829a4aSRandall Stewart 		ret_sz += tp1->book_size;
4278f8829a4aSRandall Stewart 		tp1->sent = SCTP_FORWARD_TSN_SKIP;
4279f8829a4aSRandall Stewart 		if (tp1->data) {
4280f8829a4aSRandall Stewart 			sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1);
4281f8829a4aSRandall Stewart 			sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, reason, tp1);
4282f8829a4aSRandall Stewart 			sctp_m_freem(tp1->data);
4283f8829a4aSRandall Stewart 			tp1->data = NULL;
4284f8829a4aSRandall Stewart 			sctp_sowwakeup(stcb->sctp_ep, stcb->sctp_socket);
4285f8829a4aSRandall Stewart 		}
4286f8829a4aSRandall Stewart 		if (PR_SCTP_BUF_ENABLED(tp1->flags)) {
4287f8829a4aSRandall Stewart 			stcb->asoc.sent_queue_cnt_removeable--;
4288f8829a4aSRandall Stewart 		}
4289f8829a4aSRandall Stewart 		if (queue == &stcb->asoc.send_queue) {
4290f8829a4aSRandall Stewart 			TAILQ_REMOVE(&stcb->asoc.send_queue, tp1, sctp_next);
4291f8829a4aSRandall Stewart 			/* on to the sent queue */
4292f8829a4aSRandall Stewart 			TAILQ_INSERT_TAIL(&stcb->asoc.sent_queue, tp1,
4293f8829a4aSRandall Stewart 			    sctp_next);
4294f8829a4aSRandall Stewart 			stcb->asoc.sent_queue_cnt++;
4295f8829a4aSRandall Stewart 		}
4296f8829a4aSRandall Stewart 		if ((tp1->rec.data.rcv_flags & SCTP_DATA_NOT_FRAG) ==
4297f8829a4aSRandall Stewart 		    SCTP_DATA_NOT_FRAG) {
4298f8829a4aSRandall Stewart 			/* not frag'ed we ae done   */
4299f8829a4aSRandall Stewart 			notdone = 0;
4300f8829a4aSRandall Stewart 			foundeom = 1;
4301f8829a4aSRandall Stewart 		} else if (tp1->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) {
4302f8829a4aSRandall Stewart 			/* end of frag, we are done */
4303f8829a4aSRandall Stewart 			notdone = 0;
4304f8829a4aSRandall Stewart 			foundeom = 1;
4305f8829a4aSRandall Stewart 		} else {
4306f8829a4aSRandall Stewart 			/*
4307f8829a4aSRandall Stewart 			 * Its a begin or middle piece, we must mark all of
4308f8829a4aSRandall Stewart 			 * it
4309f8829a4aSRandall Stewart 			 */
4310f8829a4aSRandall Stewart 			notdone = 1;
4311f8829a4aSRandall Stewart 			tp1 = TAILQ_NEXT(tp1, sctp_next);
4312f8829a4aSRandall Stewart 		}
4313f8829a4aSRandall Stewart 	} while (tp1 && notdone);
4314f8829a4aSRandall Stewart 	if ((foundeom == 0) && (queue == &stcb->asoc.sent_queue)) {
4315f8829a4aSRandall Stewart 		/*
4316f8829a4aSRandall Stewart 		 * The multi-part message was scattered across the send and
4317f8829a4aSRandall Stewart 		 * sent queue.
4318f8829a4aSRandall Stewart 		 */
4319f8829a4aSRandall Stewart 		tp1 = TAILQ_FIRST(&stcb->asoc.send_queue);
4320f8829a4aSRandall Stewart 		/*
4321f8829a4aSRandall Stewart 		 * recurse throught the send_queue too, starting at the
4322f8829a4aSRandall Stewart 		 * beginning.
4323f8829a4aSRandall Stewart 		 */
4324f8829a4aSRandall Stewart 		if (tp1) {
4325f8829a4aSRandall Stewart 			ret_sz += sctp_release_pr_sctp_chunk(stcb, tp1, reason,
4326f8829a4aSRandall Stewart 			    &stcb->asoc.send_queue);
4327f8829a4aSRandall Stewart 		} else {
4328ad81507eSRandall Stewart 			SCTP_PRINTF("hmm, nothing on the send queue and no EOM?\n");
4329f8829a4aSRandall Stewart 		}
4330f8829a4aSRandall Stewart 	}
4331f8829a4aSRandall Stewart 	return (ret_sz);
4332f8829a4aSRandall Stewart }
4333f8829a4aSRandall Stewart 
4334f8829a4aSRandall Stewart /*
4335f8829a4aSRandall Stewart  * checks to see if the given address, sa, is one that is currently known by
4336f8829a4aSRandall Stewart  * the kernel note: can't distinguish the same address on multiple interfaces
4337f8829a4aSRandall Stewart  * and doesn't handle multiple addresses with different zone/scope id's note:
4338f8829a4aSRandall Stewart  * ifa_ifwithaddr() compares the entire sockaddr struct
4339f8829a4aSRandall Stewart  */
434042551e99SRandall Stewart struct sctp_ifa *
434180fefe0aSRandall Stewart sctp_find_ifa_in_ep(struct sctp_inpcb *inp, struct sockaddr *addr,
434280fefe0aSRandall Stewart     int holds_lock)
4343f8829a4aSRandall Stewart {
434442551e99SRandall Stewart 	struct sctp_laddr *laddr;
4345f8829a4aSRandall Stewart 
4346ad81507eSRandall Stewart 	if (holds_lock == 0) {
434742551e99SRandall Stewart 		SCTP_INP_RLOCK(inp);
4348ad81507eSRandall Stewart 	}
434942551e99SRandall Stewart 	LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
435042551e99SRandall Stewart 		if (laddr->ifa == NULL)
4351f8829a4aSRandall Stewart 			continue;
435242551e99SRandall Stewart 		if (addr->sa_family != laddr->ifa->address.sa.sa_family)
435342551e99SRandall Stewart 			continue;
435442551e99SRandall Stewart 		if (addr->sa_family == AF_INET) {
435542551e99SRandall Stewart 			if (((struct sockaddr_in *)addr)->sin_addr.s_addr ==
435642551e99SRandall Stewart 			    laddr->ifa->address.sin.sin_addr.s_addr) {
435742551e99SRandall Stewart 				/* found him. */
4358ad81507eSRandall Stewart 				if (holds_lock == 0) {
435942551e99SRandall Stewart 					SCTP_INP_RUNLOCK(inp);
4360ad81507eSRandall Stewart 				}
436142551e99SRandall Stewart 				return (laddr->ifa);
436242551e99SRandall Stewart 				break;
436342551e99SRandall Stewart 			}
436442551e99SRandall Stewart 		} else if (addr->sa_family == AF_INET6) {
436542551e99SRandall Stewart 			if (SCTP6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)addr)->sin6_addr,
436642551e99SRandall Stewart 			    &laddr->ifa->address.sin6.sin6_addr)) {
436742551e99SRandall Stewart 				/* found him. */
4368ad81507eSRandall Stewart 				if (holds_lock == 0) {
436942551e99SRandall Stewart 					SCTP_INP_RUNLOCK(inp);
4370ad81507eSRandall Stewart 				}
437142551e99SRandall Stewart 				return (laddr->ifa);
437242551e99SRandall Stewart 				break;
437342551e99SRandall Stewart 			}
437442551e99SRandall Stewart 		}
437542551e99SRandall Stewart 	}
4376ad81507eSRandall Stewart 	if (holds_lock == 0) {
437742551e99SRandall Stewart 		SCTP_INP_RUNLOCK(inp);
4378ad81507eSRandall Stewart 	}
437942551e99SRandall Stewart 	return (NULL);
438042551e99SRandall Stewart }
4381f8829a4aSRandall Stewart 
43826a27c376SRandall Stewart uint32_t
43836a27c376SRandall Stewart sctp_get_ifa_hash_val(struct sockaddr *addr)
43846a27c376SRandall Stewart {
43856a27c376SRandall Stewart 
43866a27c376SRandall Stewart 	if (addr->sa_family == AF_INET) {
43876a27c376SRandall Stewart 		struct sockaddr_in *sin;
43886a27c376SRandall Stewart 
43896a27c376SRandall Stewart 		sin = (struct sockaddr_in *)addr;
43906a27c376SRandall Stewart 		return (sin->sin_addr.s_addr ^ (sin->sin_addr.s_addr >> 16));
43916a27c376SRandall Stewart 	} else if (addr->sa_family == AF_INET6) {
43926a27c376SRandall Stewart 		struct sockaddr_in6 *sin6;
43936a27c376SRandall Stewart 		uint32_t hash_of_addr;
43946a27c376SRandall Stewart 
43956a27c376SRandall Stewart 		sin6 = (struct sockaddr_in6 *)addr;
43966a27c376SRandall Stewart 		hash_of_addr = (sin6->sin6_addr.s6_addr32[0] +
43976a27c376SRandall Stewart 		    sin6->sin6_addr.s6_addr32[1] +
43986a27c376SRandall Stewart 		    sin6->sin6_addr.s6_addr32[2] +
43996a27c376SRandall Stewart 		    sin6->sin6_addr.s6_addr32[3]);
44006a27c376SRandall Stewart 		hash_of_addr = (hash_of_addr ^ (hash_of_addr >> 16));
44016a27c376SRandall Stewart 		return (hash_of_addr);
44026a27c376SRandall Stewart 	}
44036a27c376SRandall Stewart 	return (0);
44046a27c376SRandall Stewart }
44056a27c376SRandall Stewart 
440642551e99SRandall Stewart struct sctp_ifa *
440742551e99SRandall Stewart sctp_find_ifa_by_addr(struct sockaddr *addr, uint32_t vrf_id, int holds_lock)
440842551e99SRandall Stewart {
440942551e99SRandall Stewart 	struct sctp_ifa *sctp_ifap;
441042551e99SRandall Stewart 	struct sctp_vrf *vrf;
44116a27c376SRandall Stewart 	struct sctp_ifalist *hash_head;
44126a27c376SRandall Stewart 	uint32_t hash_of_addr;
441342551e99SRandall Stewart 
441442551e99SRandall Stewart 	if (holds_lock == 0)
441542551e99SRandall Stewart 		SCTP_IPI_ADDR_LOCK();
441642551e99SRandall Stewart 
4417bff64a4dSRandall Stewart 	vrf = sctp_find_vrf(vrf_id);
4418bff64a4dSRandall Stewart 	if (vrf == NULL) {
4419bff64a4dSRandall Stewart 		if (holds_lock == 0)
4420bff64a4dSRandall Stewart 			SCTP_IPI_ADDR_UNLOCK();
4421bff64a4dSRandall Stewart 		return (NULL);
4422bff64a4dSRandall Stewart 	}
4423bff64a4dSRandall Stewart 	hash_of_addr = sctp_get_ifa_hash_val(addr);
4424bff64a4dSRandall Stewart 
442517205eccSRandall Stewart 	hash_head = &vrf->vrf_addr_hash[(hash_of_addr & vrf->vrf_addr_hashmark)];
4426bff64a4dSRandall Stewart 	if (hash_head == NULL) {
4427ad81507eSRandall Stewart 		SCTP_PRINTF("hash_of_addr:%x mask:%x table:%x - ",
442817205eccSRandall Stewart 		    (u_int)hash_of_addr, (u_int)vrf->vrf_addr_hashmark,
442917205eccSRandall Stewart 		    (u_int)(hash_of_addr & vrf->vrf_addr_hashmark));
4430bff64a4dSRandall Stewart 		sctp_print_address(addr);
4431ad81507eSRandall Stewart 		SCTP_PRINTF("No such bucket for address\n");
4432bff64a4dSRandall Stewart 		if (holds_lock == 0)
4433bff64a4dSRandall Stewart 			SCTP_IPI_ADDR_UNLOCK();
4434bff64a4dSRandall Stewart 
4435bff64a4dSRandall Stewart 		return (NULL);
4436bff64a4dSRandall Stewart 	}
44376a27c376SRandall Stewart 	LIST_FOREACH(sctp_ifap, hash_head, next_bucket) {
4438bff64a4dSRandall Stewart 		if (sctp_ifap == NULL) {
4439bff64a4dSRandall Stewart 			panic("Huh LIST_FOREACH corrupt");
4440bff64a4dSRandall Stewart 		}
44416a27c376SRandall Stewart 		if (addr->sa_family != sctp_ifap->address.sa.sa_family)
44426a27c376SRandall Stewart 			continue;
44436a27c376SRandall Stewart 		if (addr->sa_family == AF_INET) {
44446a27c376SRandall Stewart 			if (((struct sockaddr_in *)addr)->sin_addr.s_addr ==
44456a27c376SRandall Stewart 			    sctp_ifap->address.sin.sin_addr.s_addr) {
44466a27c376SRandall Stewart 				/* found him. */
444742551e99SRandall Stewart 				if (holds_lock == 0)
444842551e99SRandall Stewart 					SCTP_IPI_ADDR_UNLOCK();
444942551e99SRandall Stewart 				return (sctp_ifap);
44506a27c376SRandall Stewart 				break;
44516a27c376SRandall Stewart 			}
44526a27c376SRandall Stewart 		} else if (addr->sa_family == AF_INET6) {
44536a27c376SRandall Stewart 			if (SCTP6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)addr)->sin6_addr,
44546a27c376SRandall Stewart 			    &sctp_ifap->address.sin6.sin6_addr)) {
44556a27c376SRandall Stewart 				/* found him. */
44566a27c376SRandall Stewart 				if (holds_lock == 0)
44576a27c376SRandall Stewart 					SCTP_IPI_ADDR_UNLOCK();
44586a27c376SRandall Stewart 				return (sctp_ifap);
44596a27c376SRandall Stewart 				break;
44606a27c376SRandall Stewart 			}
446142551e99SRandall Stewart 		}
446242551e99SRandall Stewart 	}
446342551e99SRandall Stewart 	if (holds_lock == 0)
446442551e99SRandall Stewart 		SCTP_IPI_ADDR_UNLOCK();
4465f8829a4aSRandall Stewart 	return (NULL);
4466f8829a4aSRandall Stewart }
4467f8829a4aSRandall Stewart 
4468f8829a4aSRandall Stewart static void
44694c9179adSRandall Stewart sctp_user_rcvd(struct sctp_tcb *stcb, uint32_t * freed_so_far, int hold_rlock,
4470f8829a4aSRandall Stewart     uint32_t rwnd_req)
4471f8829a4aSRandall Stewart {
4472f8829a4aSRandall Stewart 	/* User pulled some data, do we need a rwnd update? */
4473f8829a4aSRandall Stewart 	int r_unlocked = 0;
4474f8829a4aSRandall Stewart 	uint32_t dif, rwnd;
4475f8829a4aSRandall Stewart 	struct socket *so = NULL;
4476f8829a4aSRandall Stewart 
4477f8829a4aSRandall Stewart 	if (stcb == NULL)
4478f8829a4aSRandall Stewart 		return;
4479f8829a4aSRandall Stewart 
448050cec919SRandall Stewart 	atomic_add_int(&stcb->asoc.refcnt, 1);
4481f8829a4aSRandall Stewart 
448262c1ff9cSRandall Stewart 	if (stcb->asoc.state & (SCTP_STATE_ABOUT_TO_BE_FREED |
448362c1ff9cSRandall Stewart 	    SCTP_STATE_SHUTDOWN_RECEIVED |
44844c9179adSRandall Stewart 	    SCTP_STATE_SHUTDOWN_ACK_SENT)) {
4485f8829a4aSRandall Stewart 		/* Pre-check If we are freeing no update */
4486f8829a4aSRandall Stewart 		goto no_lock;
4487f8829a4aSRandall Stewart 	}
4488f8829a4aSRandall Stewart 	SCTP_INP_INCR_REF(stcb->sctp_ep);
4489f8829a4aSRandall Stewart 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
4490f8829a4aSRandall Stewart 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) {
4491f8829a4aSRandall Stewart 		goto out;
4492f8829a4aSRandall Stewart 	}
4493f8829a4aSRandall Stewart 	so = stcb->sctp_socket;
4494f8829a4aSRandall Stewart 	if (so == NULL) {
4495f8829a4aSRandall Stewart 		goto out;
4496f8829a4aSRandall Stewart 	}
4497f8829a4aSRandall Stewart 	atomic_add_int(&stcb->freed_by_sorcv_sincelast, *freed_so_far);
4498f8829a4aSRandall Stewart 	/* Have you have freed enough to look */
4499f8829a4aSRandall Stewart 	*freed_so_far = 0;
4500f8829a4aSRandall Stewart 	/* Yep, its worth a look and the lock overhead */
4501f8829a4aSRandall Stewart 
4502f8829a4aSRandall Stewart 	/* Figure out what the rwnd would be */
4503f8829a4aSRandall Stewart 	rwnd = sctp_calc_rwnd(stcb, &stcb->asoc);
4504f8829a4aSRandall Stewart 	if (rwnd >= stcb->asoc.my_last_reported_rwnd) {
4505f8829a4aSRandall Stewart 		dif = rwnd - stcb->asoc.my_last_reported_rwnd;
4506f8829a4aSRandall Stewart 	} else {
4507f8829a4aSRandall Stewart 		dif = 0;
4508f8829a4aSRandall Stewart 	}
4509f8829a4aSRandall Stewart 	if (dif >= rwnd_req) {
4510f8829a4aSRandall Stewart 		if (hold_rlock) {
4511f8829a4aSRandall Stewart 			SCTP_INP_READ_UNLOCK(stcb->sctp_ep);
4512f8829a4aSRandall Stewart 			r_unlocked = 1;
4513f8829a4aSRandall Stewart 		}
4514f8829a4aSRandall Stewart 		if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
4515f8829a4aSRandall Stewart 			/*
4516f8829a4aSRandall Stewart 			 * One last check before we allow the guy possibly
4517f8829a4aSRandall Stewart 			 * to get in. There is a race, where the guy has not
4518f8829a4aSRandall Stewart 			 * reached the gate. In that case
4519f8829a4aSRandall Stewart 			 */
4520f8829a4aSRandall Stewart 			goto out;
4521f8829a4aSRandall Stewart 		}
4522f8829a4aSRandall Stewart 		SCTP_TCB_LOCK(stcb);
4523f8829a4aSRandall Stewart 		if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
4524f8829a4aSRandall Stewart 			/* No reports here */
4525f8829a4aSRandall Stewart 			SCTP_TCB_UNLOCK(stcb);
4526f8829a4aSRandall Stewart 			goto out;
4527f8829a4aSRandall Stewart 		}
4528f8829a4aSRandall Stewart 		SCTP_STAT_INCR(sctps_wu_sacks_sent);
4529f8829a4aSRandall Stewart 		sctp_send_sack(stcb);
4530f8829a4aSRandall Stewart 		sctp_chunk_output(stcb->sctp_ep, stcb,
4531f8829a4aSRandall Stewart 		    SCTP_OUTPUT_FROM_USR_RCVD);
4532f8829a4aSRandall Stewart 		/* make sure no timer is running */
4533a5d547adSRandall Stewart 		sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_6);
4534f8829a4aSRandall Stewart 		SCTP_TCB_UNLOCK(stcb);
4535f8829a4aSRandall Stewart 	} else {
4536f8829a4aSRandall Stewart 		/* Update how much we have pending */
4537f8829a4aSRandall Stewart 		stcb->freed_by_sorcv_sincelast = dif;
4538f8829a4aSRandall Stewart 	}
4539f8829a4aSRandall Stewart out:
4540f8829a4aSRandall Stewart 	if (so && r_unlocked && hold_rlock) {
4541f8829a4aSRandall Stewart 		SCTP_INP_READ_LOCK(stcb->sctp_ep);
4542f8829a4aSRandall Stewart 	}
4543f8829a4aSRandall Stewart 	SCTP_INP_DECR_REF(stcb->sctp_ep);
4544f8829a4aSRandall Stewart no_lock:
454550cec919SRandall Stewart 	atomic_add_int(&stcb->asoc.refcnt, -1);
4546f8829a4aSRandall Stewart 	return;
4547f8829a4aSRandall Stewart }
4548f8829a4aSRandall Stewart 
4549f8829a4aSRandall Stewart int
4550f8829a4aSRandall Stewart sctp_sorecvmsg(struct socket *so,
4551f8829a4aSRandall Stewart     struct uio *uio,
4552f8829a4aSRandall Stewart     struct mbuf **mp,
4553f8829a4aSRandall Stewart     struct sockaddr *from,
4554f8829a4aSRandall Stewart     int fromlen,
4555f8829a4aSRandall Stewart     int *msg_flags,
4556f8829a4aSRandall Stewart     struct sctp_sndrcvinfo *sinfo,
4557f8829a4aSRandall Stewart     int filling_sinfo)
4558f8829a4aSRandall Stewart {
4559f8829a4aSRandall Stewart 	/*
4560f8829a4aSRandall Stewart 	 * MSG flags we will look at MSG_DONTWAIT - non-blocking IO.
4561f8829a4aSRandall Stewart 	 * MSG_PEEK - Look don't touch :-D (only valid with OUT mbuf copy
4562f8829a4aSRandall Stewart 	 * mp=NULL thus uio is the copy method to userland) MSG_WAITALL - ??
4563f8829a4aSRandall Stewart 	 * On the way out we may send out any combination of:
4564f8829a4aSRandall Stewart 	 * MSG_NOTIFICATION MSG_EOR
4565f8829a4aSRandall Stewart 	 *
4566f8829a4aSRandall Stewart 	 */
4567f8829a4aSRandall Stewart 	struct sctp_inpcb *inp = NULL;
4568f8829a4aSRandall Stewart 	int my_len = 0;
4569f8829a4aSRandall Stewart 	int cp_len = 0, error = 0;
4570f8829a4aSRandall Stewart 	struct sctp_queued_to_read *control = NULL, *ctl = NULL, *nxt = NULL;
4571f8829a4aSRandall Stewart 	struct mbuf *m = NULL, *embuf = NULL;
4572f8829a4aSRandall Stewart 	struct sctp_tcb *stcb = NULL;
4573f8829a4aSRandall Stewart 	int wakeup_read_socket = 0;
4574f8829a4aSRandall Stewart 	int freecnt_applied = 0;
4575f8829a4aSRandall Stewart 	int out_flags = 0, in_flags = 0;
4576f8829a4aSRandall Stewart 	int block_allowed = 1;
45774c9179adSRandall Stewart 	uint32_t freed_so_far = 0;
4578f8829a4aSRandall Stewart 	int copied_so_far = 0;
457993164cf9SRandall Stewart 	int in_eeor_mode = 0;
4580f8829a4aSRandall Stewart 	int no_rcv_needed = 0;
4581f8829a4aSRandall Stewart 	uint32_t rwnd_req = 0;
4582f8829a4aSRandall Stewart 	int hold_sblock = 0;
4583f8829a4aSRandall Stewart 	int hold_rlock = 0;
458442551e99SRandall Stewart 	int alen = 0;
458542551e99SRandall Stewart 	int slen = 0;
45864c9179adSRandall Stewart 	uint32_t held_length = 0;
45877abab911SRobert Watson 	int sockbuf_lock = 0;
4588f8829a4aSRandall Stewart 
458917205eccSRandall Stewart 	if (uio == NULL) {
459017205eccSRandall Stewart 		return (EINVAL);
459117205eccSRandall Stewart 	}
4592f8829a4aSRandall Stewart 	if (msg_flags) {
4593f8829a4aSRandall Stewart 		in_flags = *msg_flags;
4594c105859eSRandall Stewart 		if (in_flags & MSG_PEEK)
4595c105859eSRandall Stewart 			SCTP_STAT_INCR(sctps_read_peeks);
4596f8829a4aSRandall Stewart 	} else {
4597f8829a4aSRandall Stewart 		in_flags = 0;
4598f8829a4aSRandall Stewart 	}
4599f8829a4aSRandall Stewart 	slen = uio->uio_resid;
460017205eccSRandall Stewart 
4601f8829a4aSRandall Stewart 	/* Pull in and set up our int flags */
4602f8829a4aSRandall Stewart 	if (in_flags & MSG_OOB) {
4603f8829a4aSRandall Stewart 		/* Out of band's NOT supported */
4604f8829a4aSRandall Stewart 		return (EOPNOTSUPP);
4605f8829a4aSRandall Stewart 	}
4606f8829a4aSRandall Stewart 	if ((in_flags & MSG_PEEK) && (mp != NULL)) {
4607f8829a4aSRandall Stewart 		return (EINVAL);
4608f8829a4aSRandall Stewart 	}
4609f8829a4aSRandall Stewart 	if ((in_flags & (MSG_DONTWAIT
4610f8829a4aSRandall Stewart 	    | MSG_NBIO
4611f8829a4aSRandall Stewart 	    )) ||
461242551e99SRandall Stewart 	    SCTP_SO_IS_NBIO(so)) {
4613f8829a4aSRandall Stewart 		block_allowed = 0;
4614f8829a4aSRandall Stewart 	}
4615f8829a4aSRandall Stewart 	/* setup the endpoint */
4616f8829a4aSRandall Stewart 	inp = (struct sctp_inpcb *)so->so_pcb;
4617f8829a4aSRandall Stewart 	if (inp == NULL) {
4618f8829a4aSRandall Stewart 		return (EFAULT);
4619f8829a4aSRandall Stewart 	}
462062c1ff9cSRandall Stewart 	rwnd_req = (SCTP_SB_LIMIT_RCV(so) >> SCTP_RWND_HIWAT_SHIFT);
4621f8829a4aSRandall Stewart 	/* Must be at least a MTU's worth */
4622f8829a4aSRandall Stewart 	if (rwnd_req < SCTP_MIN_RWND)
4623f8829a4aSRandall Stewart 		rwnd_req = SCTP_MIN_RWND;
4624f8829a4aSRandall Stewart 	in_eeor_mode = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR);
462580fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) {
4626f8829a4aSRandall Stewart 		sctp_misc_ints(SCTP_SORECV_ENTER,
462717205eccSRandall Stewart 		    rwnd_req, in_eeor_mode, so->so_rcv.sb_cc, uio->uio_resid);
462880fefe0aSRandall Stewart 	}
462980fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) {
4630f8829a4aSRandall Stewart 		sctp_misc_ints(SCTP_SORECV_ENTERPL,
463117205eccSRandall Stewart 		    rwnd_req, block_allowed, so->so_rcv.sb_cc, uio->uio_resid);
463280fefe0aSRandall Stewart 	}
4633f8829a4aSRandall Stewart 	error = sblock(&so->so_rcv, (block_allowed ? M_WAITOK : 0));
46347abab911SRobert Watson 	sockbuf_lock = 1;
4635f8829a4aSRandall Stewart 	if (error) {
4636f8829a4aSRandall Stewart 		goto release_unlocked;
4637f8829a4aSRandall Stewart 	}
4638f8829a4aSRandall Stewart restart:
46397abab911SRobert Watson 
4640f8829a4aSRandall Stewart 
4641f8829a4aSRandall Stewart restart_nosblocks:
4642f8829a4aSRandall Stewart 	if (hold_sblock == 0) {
4643f8829a4aSRandall Stewart 		SOCKBUF_LOCK(&so->so_rcv);
4644f8829a4aSRandall Stewart 		hold_sblock = 1;
4645f8829a4aSRandall Stewart 	}
4646f8829a4aSRandall Stewart 	if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
4647f8829a4aSRandall Stewart 	    (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) {
4648f8829a4aSRandall Stewart 		goto out;
4649f8829a4aSRandall Stewart 	}
465044b7479bSRandall Stewart 	if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
4651f8829a4aSRandall Stewart 		if (so->so_error) {
4652f8829a4aSRandall Stewart 			error = so->so_error;
465344b7479bSRandall Stewart 			if ((in_flags & MSG_PEEK) == 0)
465444b7479bSRandall Stewart 				so->so_error = 0;
4655f8829a4aSRandall Stewart 		} else {
4656f8829a4aSRandall Stewart 			error = ENOTCONN;
4657f8829a4aSRandall Stewart 		}
4658f8829a4aSRandall Stewart 		goto out;
4659f8829a4aSRandall Stewart 	}
4660f8829a4aSRandall Stewart 	if ((so->so_rcv.sb_cc <= held_length) && block_allowed) {
4661f8829a4aSRandall Stewart 		/* we need to wait for data */
4662f8829a4aSRandall Stewart 		if ((so->so_rcv.sb_cc == 0) &&
4663f8829a4aSRandall Stewart 		    ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
4664f8829a4aSRandall Stewart 		    (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) {
4665f8829a4aSRandall Stewart 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) {
4666f8829a4aSRandall Stewart 				/*
4667f8829a4aSRandall Stewart 				 * For active open side clear flags for
4668f8829a4aSRandall Stewart 				 * re-use passive open is blocked by
4669f8829a4aSRandall Stewart 				 * connect.
4670f8829a4aSRandall Stewart 				 */
4671f8829a4aSRandall Stewart 				if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) {
4672f8829a4aSRandall Stewart 					/*
4673f8829a4aSRandall Stewart 					 * You were aborted, passive side
4674f8829a4aSRandall Stewart 					 * always hits here
4675f8829a4aSRandall Stewart 					 */
4676f8829a4aSRandall Stewart 					error = ECONNRESET;
4677f8829a4aSRandall Stewart 					/*
4678f8829a4aSRandall Stewart 					 * You get this once if you are
4679f8829a4aSRandall Stewart 					 * active open side
4680f8829a4aSRandall Stewart 					 */
4681f8829a4aSRandall Stewart 					if (!(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
4682f8829a4aSRandall Stewart 						/*
4683f8829a4aSRandall Stewart 						 * Remove flag if on the
4684f8829a4aSRandall Stewart 						 * active open side
4685f8829a4aSRandall Stewart 						 */
4686f8829a4aSRandall Stewart 						inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_ABORTED;
4687f8829a4aSRandall Stewart 					}
4688f8829a4aSRandall Stewart 				}
4689f8829a4aSRandall Stewart 				so->so_state &= ~(SS_ISCONNECTING |
4690f8829a4aSRandall Stewart 				    SS_ISDISCONNECTING |
4691f8829a4aSRandall Stewart 				    SS_ISCONFIRMING |
4692f8829a4aSRandall Stewart 				    SS_ISCONNECTED);
4693f8829a4aSRandall Stewart 				if (error == 0) {
4694f8829a4aSRandall Stewart 					if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) {
4695f8829a4aSRandall Stewart 						error = ENOTCONN;
4696f8829a4aSRandall Stewart 					} else {
4697f8829a4aSRandall Stewart 						inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_CONNECTED;
4698f8829a4aSRandall Stewart 					}
4699f8829a4aSRandall Stewart 				}
4700f8829a4aSRandall Stewart 				goto out;
4701f8829a4aSRandall Stewart 			}
4702f8829a4aSRandall Stewart 		}
4703f8829a4aSRandall Stewart 		error = sbwait(&so->so_rcv);
4704f8829a4aSRandall Stewart 		if (error) {
4705f8829a4aSRandall Stewart 			goto out;
4706f8829a4aSRandall Stewart 		}
4707f8829a4aSRandall Stewart 		held_length = 0;
4708f8829a4aSRandall Stewart 		goto restart_nosblocks;
4709f8829a4aSRandall Stewart 	} else if (so->so_rcv.sb_cc == 0) {
471044b7479bSRandall Stewart 		if (so->so_error) {
471144b7479bSRandall Stewart 			error = so->so_error;
471244b7479bSRandall Stewart 			if ((in_flags & MSG_PEEK) == 0)
471344b7479bSRandall Stewart 				so->so_error = 0;
471444b7479bSRandall Stewart 		} else {
471544b7479bSRandall Stewart 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
471644b7479bSRandall Stewart 			    (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
471744b7479bSRandall Stewart 				if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) {
471844b7479bSRandall Stewart 					/*
471944b7479bSRandall Stewart 					 * For active open side clear flags
472044b7479bSRandall Stewart 					 * for re-use passive open is
472144b7479bSRandall Stewart 					 * blocked by connect.
472244b7479bSRandall Stewart 					 */
472344b7479bSRandall Stewart 					if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) {
472444b7479bSRandall Stewart 						/*
472544b7479bSRandall Stewart 						 * You were aborted, passive
472644b7479bSRandall Stewart 						 * side always hits here
472744b7479bSRandall Stewart 						 */
472844b7479bSRandall Stewart 						error = ECONNRESET;
472944b7479bSRandall Stewart 						/*
473044b7479bSRandall Stewart 						 * You get this once if you
473144b7479bSRandall Stewart 						 * are active open side
473244b7479bSRandall Stewart 						 */
473344b7479bSRandall Stewart 						if (!(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
473444b7479bSRandall Stewart 							/*
473544b7479bSRandall Stewart 							 * Remove flag if on
473644b7479bSRandall Stewart 							 * the active open
473744b7479bSRandall Stewart 							 * side
473844b7479bSRandall Stewart 							 */
473944b7479bSRandall Stewart 							inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_ABORTED;
474044b7479bSRandall Stewart 						}
474144b7479bSRandall Stewart 					}
474244b7479bSRandall Stewart 					so->so_state &= ~(SS_ISCONNECTING |
474344b7479bSRandall Stewart 					    SS_ISDISCONNECTING |
474444b7479bSRandall Stewart 					    SS_ISCONFIRMING |
474544b7479bSRandall Stewart 					    SS_ISCONNECTED);
474644b7479bSRandall Stewart 					if (error == 0) {
474744b7479bSRandall Stewart 						if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) {
474844b7479bSRandall Stewart 							error = ENOTCONN;
474944b7479bSRandall Stewart 						} else {
475044b7479bSRandall Stewart 							inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_CONNECTED;
475144b7479bSRandall Stewart 						}
475244b7479bSRandall Stewart 					}
475344b7479bSRandall Stewart 					goto out;
475444b7479bSRandall Stewart 				}
475544b7479bSRandall Stewart 			}
4756f8829a4aSRandall Stewart 			error = EWOULDBLOCK;
475744b7479bSRandall Stewart 		}
4758f8829a4aSRandall Stewart 		goto out;
4759f8829a4aSRandall Stewart 	}
4760d06c82f1SRandall Stewart 	if (hold_sblock == 1) {
4761d06c82f1SRandall Stewart 		SOCKBUF_UNLOCK(&so->so_rcv);
4762d06c82f1SRandall Stewart 		hold_sblock = 0;
4763d06c82f1SRandall Stewart 	}
4764f8829a4aSRandall Stewart 	/* we possibly have data we can read */
47653c503c28SRandall Stewart 	/* sa_ignore FREED_MEMORY */
4766f8829a4aSRandall Stewart 	control = TAILQ_FIRST(&inp->read_queue);
4767f8829a4aSRandall Stewart 	if (control == NULL) {
4768f8829a4aSRandall Stewart 		/*
4769f8829a4aSRandall Stewart 		 * This could be happening since the appender did the
4770f8829a4aSRandall Stewart 		 * increment but as not yet did the tailq insert onto the
4771f8829a4aSRandall Stewart 		 * read_queue
4772f8829a4aSRandall Stewart 		 */
4773f8829a4aSRandall Stewart 		if (hold_rlock == 0) {
4774f8829a4aSRandall Stewart 			SCTP_INP_READ_LOCK(inp);
4775f8829a4aSRandall Stewart 			hold_rlock = 1;
4776f8829a4aSRandall Stewart 		}
4777f8829a4aSRandall Stewart 		control = TAILQ_FIRST(&inp->read_queue);
4778f8829a4aSRandall Stewart 		if ((control == NULL) && (so->so_rcv.sb_cc != 0)) {
4779a5d547adSRandall Stewart #ifdef INVARIANTS
4780f8829a4aSRandall Stewart 			panic("Huh, its non zero and nothing on control?");
4781f8829a4aSRandall Stewart #endif
4782f8829a4aSRandall Stewart 			so->so_rcv.sb_cc = 0;
4783f8829a4aSRandall Stewart 		}
4784f8829a4aSRandall Stewart 		SCTP_INP_READ_UNLOCK(inp);
4785f8829a4aSRandall Stewart 		hold_rlock = 0;
4786f8829a4aSRandall Stewart 		goto restart;
4787f8829a4aSRandall Stewart 	}
4788f8829a4aSRandall Stewart 	if ((control->length == 0) &&
4789f8829a4aSRandall Stewart 	    (control->do_not_ref_stcb)) {
4790f8829a4aSRandall Stewart 		/*
4791f8829a4aSRandall Stewart 		 * Clean up code for freeing assoc that left behind a
4792f8829a4aSRandall Stewart 		 * pdapi.. maybe a peer in EEOR that just closed after
4793f8829a4aSRandall Stewart 		 * sending and never indicated a EOR.
4794f8829a4aSRandall Stewart 		 */
4795f8829a4aSRandall Stewart 		if (hold_rlock == 0) {
4796f8829a4aSRandall Stewart 			hold_rlock = 1;
4797f8829a4aSRandall Stewart 			SCTP_INP_READ_LOCK(inp);
4798f8829a4aSRandall Stewart 		}
4799f8829a4aSRandall Stewart 		control->held_length = 0;
4800f8829a4aSRandall Stewart 		if (control->data) {
4801f8829a4aSRandall Stewart 			/* Hmm there is data here .. fix */
48024c9179adSRandall Stewart 			struct mbuf *m_tmp;
4803f8829a4aSRandall Stewart 			int cnt = 0;
4804f8829a4aSRandall Stewart 
48054c9179adSRandall Stewart 			m_tmp = control->data;
48064c9179adSRandall Stewart 			while (m_tmp) {
48074c9179adSRandall Stewart 				cnt += SCTP_BUF_LEN(m_tmp);
48084c9179adSRandall Stewart 				if (SCTP_BUF_NEXT(m_tmp) == NULL) {
48094c9179adSRandall Stewart 					control->tail_mbuf = m_tmp;
4810f8829a4aSRandall Stewart 					control->end_added = 1;
4811f8829a4aSRandall Stewart 				}
48124c9179adSRandall Stewart 				m_tmp = SCTP_BUF_NEXT(m_tmp);
4813f8829a4aSRandall Stewart 			}
4814f8829a4aSRandall Stewart 			control->length = cnt;
4815f8829a4aSRandall Stewart 		} else {
4816f8829a4aSRandall Stewart 			/* remove it */
4817f8829a4aSRandall Stewart 			TAILQ_REMOVE(&inp->read_queue, control, next);
4818f8829a4aSRandall Stewart 			/* Add back any hiddend data */
4819f8829a4aSRandall Stewart 			sctp_free_remote_addr(control->whoFrom);
4820f8829a4aSRandall Stewart 			sctp_free_a_readq(stcb, control);
4821f8829a4aSRandall Stewart 		}
4822f8829a4aSRandall Stewart 		if (hold_rlock) {
4823f8829a4aSRandall Stewart 			hold_rlock = 0;
4824f8829a4aSRandall Stewart 			SCTP_INP_READ_UNLOCK(inp);
4825f8829a4aSRandall Stewart 		}
4826f8829a4aSRandall Stewart 		goto restart;
4827f8829a4aSRandall Stewart 	}
4828f8829a4aSRandall Stewart 	if (control->length == 0) {
4829f8829a4aSRandall Stewart 		if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) &&
4830f8829a4aSRandall Stewart 		    (filling_sinfo)) {
4831f8829a4aSRandall Stewart 			/* find a more suitable one then this */
4832f8829a4aSRandall Stewart 			ctl = TAILQ_NEXT(control, next);
4833f8829a4aSRandall Stewart 			while (ctl) {
48349a6142d8SRandall Stewart 				if ((ctl->stcb != control->stcb) && (ctl->length) &&
48359a6142d8SRandall Stewart 				    (ctl->some_taken ||
48366114cd96SRandall Stewart 				    (ctl->spec_flags & M_NOTIFICATION) ||
48379a6142d8SRandall Stewart 				    ((ctl->do_not_ref_stcb == 0) &&
48389a6142d8SRandall Stewart 				    (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))
48399a6142d8SRandall Stewart 				    ) {
48409a6142d8SRandall Stewart 					/*-
48419a6142d8SRandall Stewart 					 * If we have a different TCB next, and there is data
48429a6142d8SRandall Stewart 					 * present. If we have already taken some (pdapi), OR we can
48439a6142d8SRandall Stewart 					 * ref the tcb and no delivery as started on this stream, we
484417205eccSRandall Stewart 					 * take it. Note we allow a notification on a different
484517205eccSRandall Stewart 					 * assoc to be delivered..
48469a6142d8SRandall Stewart 					 */
48479a6142d8SRandall Stewart 					control = ctl;
48489a6142d8SRandall Stewart 					goto found_one;
48499a6142d8SRandall Stewart 				} else if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS)) &&
48509a6142d8SRandall Stewart 					    (ctl->length) &&
48519a6142d8SRandall Stewart 					    ((ctl->some_taken) ||
48529a6142d8SRandall Stewart 					    ((ctl->do_not_ref_stcb == 0) &&
485317205eccSRandall Stewart 					    ((ctl->spec_flags & M_NOTIFICATION) == 0) &&
48549a6142d8SRandall Stewart 					    (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))
48559a6142d8SRandall Stewart 				    ) {
48569a6142d8SRandall Stewart 					/*-
48579a6142d8SRandall Stewart 					 * If we have the same tcb, and there is data present, and we
48589a6142d8SRandall Stewart 					 * have the strm interleave feature present. Then if we have
48599a6142d8SRandall Stewart 					 * taken some (pdapi) or we can refer to tht tcb AND we have
48609a6142d8SRandall Stewart 					 * not started a delivery for this stream, we can take it.
486117205eccSRandall Stewart 					 * Note we do NOT allow a notificaiton on the same assoc to
486217205eccSRandall Stewart 					 * be delivered.
48639a6142d8SRandall Stewart 					 */
4864f8829a4aSRandall Stewart 					control = ctl;
4865f8829a4aSRandall Stewart 					goto found_one;
4866f8829a4aSRandall Stewart 				}
4867f8829a4aSRandall Stewart 				ctl = TAILQ_NEXT(ctl, next);
4868f8829a4aSRandall Stewart 			}
4869f8829a4aSRandall Stewart 		}
4870f8829a4aSRandall Stewart 		/*
4871f8829a4aSRandall Stewart 		 * if we reach here, not suitable replacement is available
4872f8829a4aSRandall Stewart 		 * <or> fragment interleave is NOT on. So stuff the sb_cc
4873f8829a4aSRandall Stewart 		 * into the our held count, and its time to sleep again.
4874f8829a4aSRandall Stewart 		 */
4875f8829a4aSRandall Stewart 		held_length = so->so_rcv.sb_cc;
4876f8829a4aSRandall Stewart 		control->held_length = so->so_rcv.sb_cc;
4877f8829a4aSRandall Stewart 		goto restart;
4878f8829a4aSRandall Stewart 	}
4879f8829a4aSRandall Stewart 	/* Clear the held length since there is something to read */
4880f8829a4aSRandall Stewart 	control->held_length = 0;
4881f8829a4aSRandall Stewart 	if (hold_rlock) {
4882f8829a4aSRandall Stewart 		SCTP_INP_READ_UNLOCK(inp);
4883f8829a4aSRandall Stewart 		hold_rlock = 0;
4884f8829a4aSRandall Stewart 	}
4885f8829a4aSRandall Stewart found_one:
4886f8829a4aSRandall Stewart 	/*
4887f8829a4aSRandall Stewart 	 * If we reach here, control has a some data for us to read off.
4888f8829a4aSRandall Stewart 	 * Note that stcb COULD be NULL.
4889f8829a4aSRandall Stewart 	 */
48909a6142d8SRandall Stewart 	control->some_taken = 1;
4891f8829a4aSRandall Stewart 	if (hold_sblock) {
4892f8829a4aSRandall Stewart 		SOCKBUF_UNLOCK(&so->so_rcv);
4893f8829a4aSRandall Stewart 		hold_sblock = 0;
4894f8829a4aSRandall Stewart 	}
4895f8829a4aSRandall Stewart 	stcb = control->stcb;
4896f8829a4aSRandall Stewart 	if (stcb) {
48970696e120SRandall Stewart 		if ((control->do_not_ref_stcb == 0) &&
48980696e120SRandall Stewart 		    (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED)) {
489950cec919SRandall Stewart 			if (freecnt_applied == 0)
4900f8829a4aSRandall Stewart 				stcb = NULL;
4901f8829a4aSRandall Stewart 		} else if (control->do_not_ref_stcb == 0) {
4902f8829a4aSRandall Stewart 			/* you can't free it on me please */
4903f8829a4aSRandall Stewart 			/*
4904f8829a4aSRandall Stewart 			 * The lock on the socket buffer protects us so the
4905f8829a4aSRandall Stewart 			 * free code will stop. But since we used the
4906f8829a4aSRandall Stewart 			 * socketbuf lock and the sender uses the tcb_lock
4907f8829a4aSRandall Stewart 			 * to increment, we need to use the atomic add to
4908f8829a4aSRandall Stewart 			 * the refcnt
4909f8829a4aSRandall Stewart 			 */
4910207304d4SRandall Stewart 			if (freecnt_applied)
4911207304d4SRandall Stewart 				panic("refcnt already incremented");
491250cec919SRandall Stewart 			atomic_add_int(&stcb->asoc.refcnt, 1);
4913f8829a4aSRandall Stewart 			freecnt_applied = 1;
4914f8829a4aSRandall Stewart 			/*
4915f8829a4aSRandall Stewart 			 * Setup to remember how much we have not yet told
4916f8829a4aSRandall Stewart 			 * the peer our rwnd has opened up. Note we grab the
4917f8829a4aSRandall Stewart 			 * value from the tcb from last time. Note too that
49180696e120SRandall Stewart 			 * sack sending clears this when a sack is sent,
4919f8829a4aSRandall Stewart 			 * which is fine. Once we hit the rwnd_req, we then
4920f8829a4aSRandall Stewart 			 * will go to the sctp_user_rcvd() that will not
4921f8829a4aSRandall Stewart 			 * lock until it KNOWs it MUST send a WUP-SACK.
4922f8829a4aSRandall Stewart 			 */
4923f8829a4aSRandall Stewart 			freed_so_far = stcb->freed_by_sorcv_sincelast;
4924f8829a4aSRandall Stewart 			stcb->freed_by_sorcv_sincelast = 0;
4925f8829a4aSRandall Stewart 		}
4926f8829a4aSRandall Stewart 	}
49276114cd96SRandall Stewart 	if (stcb &&
49286114cd96SRandall Stewart 	    ((control->spec_flags & M_NOTIFICATION) == 0) &&
49296114cd96SRandall Stewart 	    control->do_not_ref_stcb == 0) {
4930d06c82f1SRandall Stewart 		stcb->asoc.strmin[control->sinfo_stream].delivery_started = 1;
4931d06c82f1SRandall Stewart 	}
4932f8829a4aSRandall Stewart 	/* First lets get off the sinfo and sockaddr info */
4933f8829a4aSRandall Stewart 	if ((sinfo) && filling_sinfo) {
4934f8829a4aSRandall Stewart 		memcpy(sinfo, control, sizeof(struct sctp_nonpad_sndrcvinfo));
4935f8829a4aSRandall Stewart 		nxt = TAILQ_NEXT(control, next);
4936f8829a4aSRandall Stewart 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) {
4937f8829a4aSRandall Stewart 			struct sctp_extrcvinfo *s_extra;
4938f8829a4aSRandall Stewart 
4939f8829a4aSRandall Stewart 			s_extra = (struct sctp_extrcvinfo *)sinfo;
49409a6142d8SRandall Stewart 			if ((nxt) &&
49419a6142d8SRandall Stewart 			    (nxt->length)) {
49429a6142d8SRandall Stewart 				s_extra->sreinfo_next_flags = SCTP_NEXT_MSG_AVAIL;
4943f8829a4aSRandall Stewart 				if (nxt->sinfo_flags & SCTP_UNORDERED) {
49449a6142d8SRandall Stewart 					s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_UNORDERED;
4945f8829a4aSRandall Stewart 				}
4946f42a358aSRandall Stewart 				if (nxt->spec_flags & M_NOTIFICATION) {
49479a6142d8SRandall Stewart 					s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_NOTIFICATION;
4948f42a358aSRandall Stewart 				}
49499a6142d8SRandall Stewart 				s_extra->sreinfo_next_aid = nxt->sinfo_assoc_id;
49509a6142d8SRandall Stewart 				s_extra->sreinfo_next_length = nxt->length;
49519a6142d8SRandall Stewart 				s_extra->sreinfo_next_ppid = nxt->sinfo_ppid;
49529a6142d8SRandall Stewart 				s_extra->sreinfo_next_stream = nxt->sinfo_stream;
4953f8829a4aSRandall Stewart 				if (nxt->tail_mbuf != NULL) {
4954139bc87fSRandall Stewart 					if (nxt->end_added) {
49559a6142d8SRandall Stewart 						s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_ISCOMPLETE;
4956f8829a4aSRandall Stewart 					}
4957f8829a4aSRandall Stewart 				}
4958f8829a4aSRandall Stewart 			} else {
4959f8829a4aSRandall Stewart 				/*
4960f8829a4aSRandall Stewart 				 * we explicitly 0 this, since the memcpy
4961f8829a4aSRandall Stewart 				 * got some other things beyond the older
4962f8829a4aSRandall Stewart 				 * sinfo_ that is on the control's structure
4963f8829a4aSRandall Stewart 				 * :-D
4964f8829a4aSRandall Stewart 				 */
49659a6142d8SRandall Stewart 				nxt = NULL;
49669a6142d8SRandall Stewart 				s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG;
49679a6142d8SRandall Stewart 				s_extra->sreinfo_next_aid = 0;
49689a6142d8SRandall Stewart 				s_extra->sreinfo_next_length = 0;
49699a6142d8SRandall Stewart 				s_extra->sreinfo_next_ppid = 0;
49709a6142d8SRandall Stewart 				s_extra->sreinfo_next_stream = 0;
4971f8829a4aSRandall Stewart 			}
4972f8829a4aSRandall Stewart 		}
4973f8829a4aSRandall Stewart 		/*
4974f8829a4aSRandall Stewart 		 * update off the real current cum-ack, if we have an stcb.
4975f8829a4aSRandall Stewart 		 */
49760696e120SRandall Stewart 		if ((control->do_not_ref_stcb == 0) && stcb)
4977f8829a4aSRandall Stewart 			sinfo->sinfo_cumtsn = stcb->asoc.cumulative_tsn;
4978f8829a4aSRandall Stewart 		/*
4979f8829a4aSRandall Stewart 		 * mask off the high bits, we keep the actual chunk bits in
4980f8829a4aSRandall Stewart 		 * there.
4981f8829a4aSRandall Stewart 		 */
4982f8829a4aSRandall Stewart 		sinfo->sinfo_flags &= 0x00ff;
49835f26a41dSRandall Stewart 		if ((control->sinfo_flags >> 8) & SCTP_DATA_UNORDERED) {
49845f26a41dSRandall Stewart 			sinfo->sinfo_flags |= SCTP_UNORDERED;
49855f26a41dSRandall Stewart 		}
4986f8829a4aSRandall Stewart 	}
4987f8829a4aSRandall Stewart 	if (fromlen && from) {
4988f8829a4aSRandall Stewart 		struct sockaddr *to;
4989f8829a4aSRandall Stewart 
499042551e99SRandall Stewart #ifdef INET
4991f8829a4aSRandall Stewart 		cp_len = min(fromlen, control->whoFrom->ro._l_addr.sin.sin_len);
4992f8829a4aSRandall Stewart 		memcpy(from, &control->whoFrom->ro._l_addr, cp_len);
4993f8829a4aSRandall Stewart 		((struct sockaddr_in *)from)->sin_port = control->port_from;
4994f8829a4aSRandall Stewart #else
4995f8829a4aSRandall Stewart 		/* No AF_INET use AF_INET6 */
4996f8829a4aSRandall Stewart 		cp_len = min(fromlen, control->whoFrom->ro._l_addr.sin6.sin6_len);
4997f8829a4aSRandall Stewart 		memcpy(from, &control->whoFrom->ro._l_addr, cp_len);
4998f8829a4aSRandall Stewart 		((struct sockaddr_in6 *)from)->sin6_port = control->port_from;
4999f8829a4aSRandall Stewart #endif
5000f8829a4aSRandall Stewart 
5001f8829a4aSRandall Stewart 		to = from;
500242551e99SRandall Stewart #if defined(INET) && defined(INET6)
5003f8829a4aSRandall Stewart 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) &&
5004f8829a4aSRandall Stewart 		    (to->sa_family == AF_INET) &&
5005f8829a4aSRandall Stewart 		    ((size_t)fromlen >= sizeof(struct sockaddr_in6))) {
5006f8829a4aSRandall Stewart 			struct sockaddr_in *sin;
5007f8829a4aSRandall Stewart 			struct sockaddr_in6 sin6;
5008f8829a4aSRandall Stewart 
5009f8829a4aSRandall Stewart 			sin = (struct sockaddr_in *)to;
5010f8829a4aSRandall Stewart 			bzero(&sin6, sizeof(sin6));
5011f8829a4aSRandall Stewart 			sin6.sin6_family = AF_INET6;
5012f8829a4aSRandall Stewart 			sin6.sin6_len = sizeof(struct sockaddr_in6);
5013f8829a4aSRandall Stewart 			sin6.sin6_addr.s6_addr16[2] = 0xffff;
5014f8829a4aSRandall Stewart 			bcopy(&sin->sin_addr,
5015f8829a4aSRandall Stewart 			    &sin6.sin6_addr.s6_addr16[3],
5016f8829a4aSRandall Stewart 			    sizeof(sin6.sin6_addr.s6_addr16[3]));
5017f8829a4aSRandall Stewart 			sin6.sin6_port = sin->sin_port;
5018f8829a4aSRandall Stewart 			memcpy(from, (caddr_t)&sin6, sizeof(sin6));
5019f8829a4aSRandall Stewart 		}
5020f8829a4aSRandall Stewart #endif
502142551e99SRandall Stewart #if defined(INET6)
5022f8829a4aSRandall Stewart 		{
5023f8829a4aSRandall Stewart 			struct sockaddr_in6 lsa6, *to6;
5024f8829a4aSRandall Stewart 
5025f8829a4aSRandall Stewart 			to6 = (struct sockaddr_in6 *)to;
5026f8829a4aSRandall Stewart 			sctp_recover_scope_mac(to6, (&lsa6));
5027f8829a4aSRandall Stewart 		}
5028f8829a4aSRandall Stewart #endif
5029f8829a4aSRandall Stewart 	}
5030f8829a4aSRandall Stewart 	/* now copy out what data we can */
5031f8829a4aSRandall Stewart 	if (mp == NULL) {
5032f8829a4aSRandall Stewart 		/* copy out each mbuf in the chain up to length */
5033f8829a4aSRandall Stewart get_more_data:
5034f8829a4aSRandall Stewart 		m = control->data;
5035f8829a4aSRandall Stewart 		while (m) {
5036f8829a4aSRandall Stewart 			/* Move out all we can */
5037f8829a4aSRandall Stewart 			cp_len = (int)uio->uio_resid;
5038139bc87fSRandall Stewart 			my_len = (int)SCTP_BUF_LEN(m);
5039f8829a4aSRandall Stewart 			if (cp_len > my_len) {
5040f8829a4aSRandall Stewart 				/* not enough in this buf */
5041f8829a4aSRandall Stewart 				cp_len = my_len;
5042f8829a4aSRandall Stewart 			}
5043f8829a4aSRandall Stewart 			if (hold_rlock) {
5044f8829a4aSRandall Stewart 				SCTP_INP_READ_UNLOCK(inp);
5045f8829a4aSRandall Stewart 				hold_rlock = 0;
5046f8829a4aSRandall Stewart 			}
5047f8829a4aSRandall Stewart 			if (cp_len > 0)
5048f8829a4aSRandall Stewart 				error = uiomove(mtod(m, char *), cp_len, uio);
5049f8829a4aSRandall Stewart 			/* re-read */
5050f8829a4aSRandall Stewart 			if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {
5051f8829a4aSRandall Stewart 				goto release;
5052f8829a4aSRandall Stewart 			}
50530696e120SRandall Stewart 			if ((control->do_not_ref_stcb == 0) && stcb &&
5054f8829a4aSRandall Stewart 			    stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
5055f8829a4aSRandall Stewart 				no_rcv_needed = 1;
5056f8829a4aSRandall Stewart 			}
5057f8829a4aSRandall Stewart 			if (error) {
5058f8829a4aSRandall Stewart 				/* error we are out of here */
5059f8829a4aSRandall Stewart 				goto release;
5060f8829a4aSRandall Stewart 			}
5061139bc87fSRandall Stewart 			if ((SCTP_BUF_NEXT(m) == NULL) &&
5062139bc87fSRandall Stewart 			    (cp_len >= SCTP_BUF_LEN(m)) &&
5063f8829a4aSRandall Stewart 			    ((control->end_added == 0) ||
50640696e120SRandall Stewart 			    (control->end_added &&
50650696e120SRandall Stewart 			    (TAILQ_NEXT(control, next) == NULL)))
5066f8829a4aSRandall Stewart 			    ) {
5067f8829a4aSRandall Stewart 				SCTP_INP_READ_LOCK(inp);
5068f8829a4aSRandall Stewart 				hold_rlock = 1;
5069f8829a4aSRandall Stewart 			}
5070139bc87fSRandall Stewart 			if (cp_len == SCTP_BUF_LEN(m)) {
5071139bc87fSRandall Stewart 				if ((SCTP_BUF_NEXT(m) == NULL) &&
5072139bc87fSRandall Stewart 				    (control->end_added)) {
5073f8829a4aSRandall Stewart 					out_flags |= MSG_EOR;
50746114cd96SRandall Stewart 					if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))
5075ee7f9857SRandall Stewart 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;
5076f8829a4aSRandall Stewart 				}
5077139bc87fSRandall Stewart 				if (control->spec_flags & M_NOTIFICATION) {
5078f8829a4aSRandall Stewart 					out_flags |= MSG_NOTIFICATION;
5079f8829a4aSRandall Stewart 				}
5080f8829a4aSRandall Stewart 				/* we ate up the mbuf */
5081f8829a4aSRandall Stewart 				if (in_flags & MSG_PEEK) {
5082f8829a4aSRandall Stewart 					/* just looking */
5083139bc87fSRandall Stewart 					m = SCTP_BUF_NEXT(m);
5084f8829a4aSRandall Stewart 					copied_so_far += cp_len;
5085f8829a4aSRandall Stewart 				} else {
5086f8829a4aSRandall Stewart 					/* dispose of the mbuf */
508780fefe0aSRandall Stewart 					if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5088f8829a4aSRandall Stewart 						sctp_sblog(&so->so_rcv,
5089139bc87fSRandall Stewart 						    control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));
509080fefe0aSRandall Stewart 					}
5091f8829a4aSRandall Stewart 					sctp_sbfree(control, stcb, &so->so_rcv, m);
509280fefe0aSRandall Stewart 					if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5093f8829a4aSRandall Stewart 						sctp_sblog(&so->so_rcv,
5094f8829a4aSRandall Stewart 						    control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
509580fefe0aSRandall Stewart 					}
5096f8829a4aSRandall Stewart 					embuf = m;
5097f8829a4aSRandall Stewart 					copied_so_far += cp_len;
5098f8829a4aSRandall Stewart 					freed_so_far += cp_len;
5099f8829a4aSRandall Stewart 					alen = atomic_fetchadd_int(&control->length, -(cp_len));
5100f8829a4aSRandall Stewart 					if (alen < cp_len) {
5101f8829a4aSRandall Stewart 						panic("Control length goes negative?");
5102f8829a4aSRandall Stewart 					}
5103f8829a4aSRandall Stewart 					control->data = sctp_m_free(m);
5104f8829a4aSRandall Stewart 					m = control->data;
5105f8829a4aSRandall Stewart 					/*
5106f8829a4aSRandall Stewart 					 * been through it all, must hold sb
5107f8829a4aSRandall Stewart 					 * lock ok to null tail
5108f8829a4aSRandall Stewart 					 */
5109f8829a4aSRandall Stewart 					if (control->data == NULL) {
5110a5d547adSRandall Stewart #ifdef INVARIANTS
5111f8829a4aSRandall Stewart 						if ((control->end_added == 0) ||
5112f8829a4aSRandall Stewart 						    (TAILQ_NEXT(control, next) == NULL)) {
5113f8829a4aSRandall Stewart 							/*
5114f8829a4aSRandall Stewart 							 * If the end is not
5115f8829a4aSRandall Stewart 							 * added, OR the
5116f8829a4aSRandall Stewart 							 * next is NOT null
5117f8829a4aSRandall Stewart 							 * we MUST have the
5118f8829a4aSRandall Stewart 							 * lock.
5119f8829a4aSRandall Stewart 							 */
5120f8829a4aSRandall Stewart 							if (mtx_owned(&inp->inp_rdata_mtx) == 0) {
5121f8829a4aSRandall Stewart 								panic("Hmm we don't own the lock?");
5122f8829a4aSRandall Stewart 							}
5123f8829a4aSRandall Stewart 						}
5124f8829a4aSRandall Stewart #endif
5125f8829a4aSRandall Stewart 						control->tail_mbuf = NULL;
5126a5d547adSRandall Stewart #ifdef INVARIANTS
5127f8829a4aSRandall Stewart 						if ((control->end_added) && ((out_flags & MSG_EOR) == 0)) {
5128f8829a4aSRandall Stewart 							panic("end_added, nothing left and no MSG_EOR");
5129f8829a4aSRandall Stewart 						}
5130f8829a4aSRandall Stewart #endif
5131f8829a4aSRandall Stewart 					}
5132f8829a4aSRandall Stewart 				}
5133f8829a4aSRandall Stewart 			} else {
5134f8829a4aSRandall Stewart 				/* Do we need to trim the mbuf? */
5135139bc87fSRandall Stewart 				if (control->spec_flags & M_NOTIFICATION) {
5136f8829a4aSRandall Stewart 					out_flags |= MSG_NOTIFICATION;
5137f8829a4aSRandall Stewart 				}
5138f8829a4aSRandall Stewart 				if ((in_flags & MSG_PEEK) == 0) {
5139139bc87fSRandall Stewart 					SCTP_BUF_RESV_UF(m, cp_len);
5140139bc87fSRandall Stewart 					SCTP_BUF_LEN(m) -= cp_len;
514180fefe0aSRandall Stewart 					if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5142f8829a4aSRandall Stewart 						sctp_sblog(&so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, cp_len);
514380fefe0aSRandall Stewart 					}
5144f8829a4aSRandall Stewart 					atomic_subtract_int(&so->so_rcv.sb_cc, cp_len);
51450696e120SRandall Stewart 					if ((control->do_not_ref_stcb == 0) &&
51460696e120SRandall Stewart 					    stcb) {
5147f8829a4aSRandall Stewart 						atomic_subtract_int(&stcb->asoc.sb_cc, cp_len);
5148f8829a4aSRandall Stewart 					}
5149f8829a4aSRandall Stewart 					copied_so_far += cp_len;
5150f8829a4aSRandall Stewart 					embuf = m;
5151f8829a4aSRandall Stewart 					freed_so_far += cp_len;
515280fefe0aSRandall Stewart 					if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5153f8829a4aSRandall Stewart 						sctp_sblog(&so->so_rcv, control->do_not_ref_stcb ? NULL : stcb,
5154f8829a4aSRandall Stewart 						    SCTP_LOG_SBRESULT, 0);
515580fefe0aSRandall Stewart 					}
5156f8829a4aSRandall Stewart 					alen = atomic_fetchadd_int(&control->length, -(cp_len));
5157f8829a4aSRandall Stewart 					if (alen < cp_len) {
5158f8829a4aSRandall Stewart 						panic("Control length goes negative2?");
5159f8829a4aSRandall Stewart 					}
5160f8829a4aSRandall Stewart 				} else {
5161f8829a4aSRandall Stewart 					copied_so_far += cp_len;
5162f8829a4aSRandall Stewart 				}
5163f8829a4aSRandall Stewart 			}
5164d61a0ae0SRandall Stewart 			if ((out_flags & MSG_EOR) || (uio->uio_resid == 0)) {
5165f8829a4aSRandall Stewart 				break;
5166f8829a4aSRandall Stewart 			}
5167f8829a4aSRandall Stewart 			if (((stcb) && (in_flags & MSG_PEEK) == 0) &&
5168f8829a4aSRandall Stewart 			    (control->do_not_ref_stcb == 0) &&
5169f8829a4aSRandall Stewart 			    (freed_so_far >= rwnd_req)) {
5170f8829a4aSRandall Stewart 				sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);
5171f8829a4aSRandall Stewart 			}
5172f8829a4aSRandall Stewart 		}		/* end while(m) */
5173f8829a4aSRandall Stewart 		/*
5174f8829a4aSRandall Stewart 		 * At this point we have looked at it all and we either have
5175f8829a4aSRandall Stewart 		 * a MSG_EOR/or read all the user wants... <OR>
5176f8829a4aSRandall Stewart 		 * control->length == 0.
5177f8829a4aSRandall Stewart 		 */
5178d61a0ae0SRandall Stewart 		if ((out_flags & MSG_EOR) && ((in_flags & MSG_PEEK) == 0)) {
5179f8829a4aSRandall Stewart 			/* we are done with this control */
5180f8829a4aSRandall Stewart 			if (control->length == 0) {
5181f8829a4aSRandall Stewart 				if (control->data) {
5182a5d547adSRandall Stewart #ifdef INVARIANTS
5183f8829a4aSRandall Stewart 					panic("control->data not null at read eor?");
5184f8829a4aSRandall Stewart #else
5185ad81507eSRandall Stewart 					SCTP_PRINTF("Strange, data left in the control buffer .. invarients would panic?\n");
5186f8829a4aSRandall Stewart 					sctp_m_freem(control->data);
5187f8829a4aSRandall Stewart 					control->data = NULL;
5188f8829a4aSRandall Stewart #endif
5189f8829a4aSRandall Stewart 				}
5190f8829a4aSRandall Stewart 		done_with_control:
5191f8829a4aSRandall Stewart 				if (TAILQ_NEXT(control, next) == NULL) {
5192f8829a4aSRandall Stewart 					/*
5193f8829a4aSRandall Stewart 					 * If we don't have a next we need a
5194f8829a4aSRandall Stewart 					 * lock, if there is a next interupt
5195f8829a4aSRandall Stewart 					 * is filling ahead of us and we
5196f8829a4aSRandall Stewart 					 * don't need a lock to remove this
5197f8829a4aSRandall Stewart 					 * guy (which is the head of the
5198f8829a4aSRandall Stewart 					 * queue).
5199f8829a4aSRandall Stewart 					 */
5200f8829a4aSRandall Stewart 					if (hold_rlock == 0) {
5201f8829a4aSRandall Stewart 						SCTP_INP_READ_LOCK(inp);
5202f8829a4aSRandall Stewart 						hold_rlock = 1;
5203f8829a4aSRandall Stewart 					}
5204f8829a4aSRandall Stewart 				}
5205f8829a4aSRandall Stewart 				TAILQ_REMOVE(&inp->read_queue, control, next);
5206f8829a4aSRandall Stewart 				/* Add back any hiddend data */
5207f8829a4aSRandall Stewart 				if (control->held_length) {
5208f8829a4aSRandall Stewart 					held_length = 0;
5209f8829a4aSRandall Stewart 					control->held_length = 0;
5210f8829a4aSRandall Stewart 					wakeup_read_socket = 1;
5211f8829a4aSRandall Stewart 				}
521217205eccSRandall Stewart 				if (control->aux_data) {
521317205eccSRandall Stewart 					sctp_m_free(control->aux_data);
521417205eccSRandall Stewart 					control->aux_data = NULL;
521517205eccSRandall Stewart 				}
5216f8829a4aSRandall Stewart 				no_rcv_needed = control->do_not_ref_stcb;
5217f8829a4aSRandall Stewart 				sctp_free_remote_addr(control->whoFrom);
5218f8829a4aSRandall Stewart 				control->data = NULL;
5219f8829a4aSRandall Stewart 				sctp_free_a_readq(stcb, control);
5220f8829a4aSRandall Stewart 				control = NULL;
52210696e120SRandall Stewart 				if ((freed_so_far >= rwnd_req) &&
52220696e120SRandall Stewart 				    (no_rcv_needed == 0))
5223f8829a4aSRandall Stewart 					sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);
5224f8829a4aSRandall Stewart 
5225f8829a4aSRandall Stewart 			} else {
5226f8829a4aSRandall Stewart 				/*
5227f8829a4aSRandall Stewart 				 * The user did not read all of this
5228f8829a4aSRandall Stewart 				 * message, turn off the returned MSG_EOR
5229f8829a4aSRandall Stewart 				 * since we are leaving more behind on the
5230f8829a4aSRandall Stewart 				 * control to read.
5231f8829a4aSRandall Stewart 				 */
5232a5d547adSRandall Stewart #ifdef INVARIANTS
52330696e120SRandall Stewart 				if (control->end_added &&
52340696e120SRandall Stewart 				    (control->data == NULL) &&
5235f8829a4aSRandall Stewart 				    (control->tail_mbuf == NULL)) {
5236f8829a4aSRandall Stewart 					panic("Gak, control->length is corrupt?");
5237f8829a4aSRandall Stewart 				}
5238f8829a4aSRandall Stewart #endif
5239f8829a4aSRandall Stewart 				no_rcv_needed = control->do_not_ref_stcb;
5240f8829a4aSRandall Stewart 				out_flags &= ~MSG_EOR;
5241f8829a4aSRandall Stewart 			}
5242f8829a4aSRandall Stewart 		}
5243f8829a4aSRandall Stewart 		if (out_flags & MSG_EOR) {
5244f8829a4aSRandall Stewart 			goto release;
5245f8829a4aSRandall Stewart 		}
5246f8829a4aSRandall Stewart 		if ((uio->uio_resid == 0) ||
5247f8829a4aSRandall Stewart 		    ((in_eeor_mode) && (copied_so_far >= max(so->so_rcv.sb_lowat, 1)))
5248f8829a4aSRandall Stewart 		    ) {
5249f8829a4aSRandall Stewart 			goto release;
5250f8829a4aSRandall Stewart 		}
5251f8829a4aSRandall Stewart 		/*
5252f8829a4aSRandall Stewart 		 * If I hit here the receiver wants more and this message is
5253f8829a4aSRandall Stewart 		 * NOT done (pd-api). So two questions. Can we block? if not
5254f8829a4aSRandall Stewart 		 * we are done. Did the user NOT set MSG_WAITALL?
5255f8829a4aSRandall Stewart 		 */
5256f8829a4aSRandall Stewart 		if (block_allowed == 0) {
5257f8829a4aSRandall Stewart 			goto release;
5258f8829a4aSRandall Stewart 		}
5259f8829a4aSRandall Stewart 		/*
5260f8829a4aSRandall Stewart 		 * We need to wait for more data a few things: - We don't
5261f8829a4aSRandall Stewart 		 * sbunlock() so we don't get someone else reading. - We
5262f8829a4aSRandall Stewart 		 * must be sure to account for the case where what is added
5263f8829a4aSRandall Stewart 		 * is NOT to our control when we wakeup.
5264f8829a4aSRandall Stewart 		 */
5265f8829a4aSRandall Stewart 
5266f8829a4aSRandall Stewart 		/*
5267f8829a4aSRandall Stewart 		 * Do we need to tell the transport a rwnd update might be
5268f8829a4aSRandall Stewart 		 * needed before we go to sleep?
5269f8829a4aSRandall Stewart 		 */
5270f8829a4aSRandall Stewart 		if (((stcb) && (in_flags & MSG_PEEK) == 0) &&
5271f8829a4aSRandall Stewart 		    ((freed_so_far >= rwnd_req) &&
5272f8829a4aSRandall Stewart 		    (control->do_not_ref_stcb == 0) &&
5273f8829a4aSRandall Stewart 		    (no_rcv_needed == 0))) {
5274f8829a4aSRandall Stewart 			sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);
5275f8829a4aSRandall Stewart 		}
5276f8829a4aSRandall Stewart wait_some_more:
527744b7479bSRandall Stewart 		if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
5278f8829a4aSRandall Stewart 			goto release;
5279f8829a4aSRandall Stewart 		}
5280f8829a4aSRandall Stewart 		if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)
5281f8829a4aSRandall Stewart 			goto release;
5282f8829a4aSRandall Stewart 
5283f8829a4aSRandall Stewart 		if (hold_rlock == 1) {
5284f8829a4aSRandall Stewart 			SCTP_INP_READ_UNLOCK(inp);
5285f8829a4aSRandall Stewart 			hold_rlock = 0;
5286f8829a4aSRandall Stewart 		}
5287f8829a4aSRandall Stewart 		if (hold_sblock == 0) {
5288f8829a4aSRandall Stewart 			SOCKBUF_LOCK(&so->so_rcv);
5289f8829a4aSRandall Stewart 			hold_sblock = 1;
5290f8829a4aSRandall Stewart 		}
5291f8829a4aSRandall Stewart 		if (so->so_rcv.sb_cc <= control->held_length) {
5292f8829a4aSRandall Stewart 			error = sbwait(&so->so_rcv);
5293f8829a4aSRandall Stewart 			if (error) {
5294f8829a4aSRandall Stewart 				goto release;
5295f8829a4aSRandall Stewart 			}
5296f8829a4aSRandall Stewart 			control->held_length = 0;
5297f8829a4aSRandall Stewart 		}
5298f8829a4aSRandall Stewart 		if (hold_sblock) {
5299f8829a4aSRandall Stewart 			SOCKBUF_UNLOCK(&so->so_rcv);
5300f8829a4aSRandall Stewart 			hold_sblock = 0;
5301f8829a4aSRandall Stewart 		}
5302f8829a4aSRandall Stewart 		if (control->length == 0) {
5303f8829a4aSRandall Stewart 			/* still nothing here */
5304f8829a4aSRandall Stewart 			if (control->end_added == 1) {
5305f8829a4aSRandall Stewart 				/* he aborted, or is done i.e.did a shutdown */
5306f8829a4aSRandall Stewart 				out_flags |= MSG_EOR;
53079a6142d8SRandall Stewart 				if (control->pdapi_aborted) {
53086114cd96SRandall Stewart 					if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))
5309ee7f9857SRandall Stewart 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;
53109a6142d8SRandall Stewart 
531103b0b021SRandall Stewart 					out_flags |= MSG_TRUNC;
53129a6142d8SRandall Stewart 				} else {
53136114cd96SRandall Stewart 					if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))
5314ee7f9857SRandall Stewart 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;
53159a6142d8SRandall Stewart 				}
5316f8829a4aSRandall Stewart 				goto done_with_control;
5317f8829a4aSRandall Stewart 			}
5318f8829a4aSRandall Stewart 			if (so->so_rcv.sb_cc > held_length) {
5319f8829a4aSRandall Stewart 				control->held_length = so->so_rcv.sb_cc;
5320f8829a4aSRandall Stewart 				held_length = 0;
5321f8829a4aSRandall Stewart 			}
5322f8829a4aSRandall Stewart 			goto wait_some_more;
5323f8829a4aSRandall Stewart 		} else if (control->data == NULL) {
532450cec919SRandall Stewart 			/*
532550cec919SRandall Stewart 			 * we must re-sync since data is probably being
532650cec919SRandall Stewart 			 * added
532750cec919SRandall Stewart 			 */
532850cec919SRandall Stewart 			SCTP_INP_READ_LOCK(inp);
532950cec919SRandall Stewart 			if ((control->length > 0) && (control->data == NULL)) {
533050cec919SRandall Stewart 				/*
533150cec919SRandall Stewart 				 * big trouble.. we have the lock and its
533250cec919SRandall Stewart 				 * corrupt?
533350cec919SRandall Stewart 				 */
5334f8829a4aSRandall Stewart 				panic("Impossible data==NULL length !=0");
5335f8829a4aSRandall Stewart 			}
533650cec919SRandall Stewart 			SCTP_INP_READ_UNLOCK(inp);
533750cec919SRandall Stewart 			/* We will fall around to get more data */
533850cec919SRandall Stewart 		}
5339f8829a4aSRandall Stewart 		goto get_more_data;
5340f8829a4aSRandall Stewart 	} else {
534117205eccSRandall Stewart 		/*-
534217205eccSRandall Stewart 		 * Give caller back the mbuf chain,
534317205eccSRandall Stewart 		 * store in uio_resid the length
5344f8829a4aSRandall Stewart 		 */
534517205eccSRandall Stewart 		wakeup_read_socket = 0;
5346f8829a4aSRandall Stewart 		if ((control->end_added == 0) ||
5347f8829a4aSRandall Stewart 		    (TAILQ_NEXT(control, next) == NULL)) {
5348f8829a4aSRandall Stewart 			/* Need to get rlock */
5349f8829a4aSRandall Stewart 			if (hold_rlock == 0) {
5350f8829a4aSRandall Stewart 				SCTP_INP_READ_LOCK(inp);
5351f8829a4aSRandall Stewart 				hold_rlock = 1;
5352f8829a4aSRandall Stewart 			}
5353f8829a4aSRandall Stewart 		}
5354139bc87fSRandall Stewart 		if (control->end_added) {
5355f8829a4aSRandall Stewart 			out_flags |= MSG_EOR;
53566114cd96SRandall Stewart 			if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))
5357ee7f9857SRandall Stewart 				control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;
5358f8829a4aSRandall Stewart 		}
5359139bc87fSRandall Stewart 		if (control->spec_flags & M_NOTIFICATION) {
5360f8829a4aSRandall Stewart 			out_flags |= MSG_NOTIFICATION;
5361f8829a4aSRandall Stewart 		}
536217205eccSRandall Stewart 		uio->uio_resid = control->length;
5363f8829a4aSRandall Stewart 		*mp = control->data;
5364f8829a4aSRandall Stewart 		m = control->data;
5365f8829a4aSRandall Stewart 		while (m) {
536680fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5367f8829a4aSRandall Stewart 				sctp_sblog(&so->so_rcv,
5368139bc87fSRandall Stewart 				    control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));
536980fefe0aSRandall Stewart 			}
5370f8829a4aSRandall Stewart 			sctp_sbfree(control, stcb, &so->so_rcv, m);
5371139bc87fSRandall Stewart 			freed_so_far += SCTP_BUF_LEN(m);
537280fefe0aSRandall Stewart 			if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) {
5373f8829a4aSRandall Stewart 				sctp_sblog(&so->so_rcv,
5374f8829a4aSRandall Stewart 				    control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0);
537580fefe0aSRandall Stewart 			}
5376139bc87fSRandall Stewart 			m = SCTP_BUF_NEXT(m);
5377f8829a4aSRandall Stewart 		}
5378f8829a4aSRandall Stewart 		control->data = control->tail_mbuf = NULL;
5379f8829a4aSRandall Stewart 		control->length = 0;
5380f8829a4aSRandall Stewart 		if (out_flags & MSG_EOR) {
5381f8829a4aSRandall Stewart 			/* Done with this control */
5382f8829a4aSRandall Stewart 			goto done_with_control;
5383f8829a4aSRandall Stewart 		}
5384f8829a4aSRandall Stewart 	}
5385f8829a4aSRandall Stewart release:
5386f8829a4aSRandall Stewart 	if (hold_rlock == 1) {
5387f8829a4aSRandall Stewart 		SCTP_INP_READ_UNLOCK(inp);
5388f8829a4aSRandall Stewart 		hold_rlock = 0;
5389f8829a4aSRandall Stewart 	}
53907abab911SRobert Watson 	if (hold_sblock == 1) {
53917abab911SRobert Watson 		SOCKBUF_UNLOCK(&so->so_rcv);
53927abab911SRobert Watson 		hold_sblock = 0;
5393f8829a4aSRandall Stewart 	}
5394f8829a4aSRandall Stewart 	sbunlock(&so->so_rcv);
53957abab911SRobert Watson 	sockbuf_lock = 0;
5396f8829a4aSRandall Stewart 
5397f8829a4aSRandall Stewart release_unlocked:
5398f8829a4aSRandall Stewart 	if (hold_sblock) {
5399f8829a4aSRandall Stewart 		SOCKBUF_UNLOCK(&so->so_rcv);
5400f8829a4aSRandall Stewart 		hold_sblock = 0;
5401f8829a4aSRandall Stewart 	}
5402f8829a4aSRandall Stewart 	if ((stcb) && (in_flags & MSG_PEEK) == 0) {
5403f8829a4aSRandall Stewart 		if ((freed_so_far >= rwnd_req) &&
5404f8829a4aSRandall Stewart 		    (control && (control->do_not_ref_stcb == 0)) &&
5405f8829a4aSRandall Stewart 		    (no_rcv_needed == 0))
5406f8829a4aSRandall Stewart 			sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);
5407f8829a4aSRandall Stewart 	}
5408f8829a4aSRandall Stewart 	if (msg_flags)
5409f8829a4aSRandall Stewart 		*msg_flags |= out_flags;
5410f8829a4aSRandall Stewart out:
54119a6142d8SRandall Stewart 	if (((out_flags & MSG_EOR) == 0) &&
54129a6142d8SRandall Stewart 	    ((in_flags & MSG_PEEK) == 0) &&
54139a6142d8SRandall Stewart 	    (sinfo) &&
54149a6142d8SRandall Stewart 	    (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO))) {
54159a6142d8SRandall Stewart 		struct sctp_extrcvinfo *s_extra;
54169a6142d8SRandall Stewart 
54179a6142d8SRandall Stewart 		s_extra = (struct sctp_extrcvinfo *)sinfo;
54189a6142d8SRandall Stewart 		s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG;
54199a6142d8SRandall Stewart 	}
5420f8829a4aSRandall Stewart 	if (hold_rlock == 1) {
5421f8829a4aSRandall Stewart 		SCTP_INP_READ_UNLOCK(inp);
5422f8829a4aSRandall Stewart 		hold_rlock = 0;
5423f8829a4aSRandall Stewart 	}
5424f8829a4aSRandall Stewart 	if (hold_sblock) {
5425f8829a4aSRandall Stewart 		SOCKBUF_UNLOCK(&so->so_rcv);
5426f8829a4aSRandall Stewart 		hold_sblock = 0;
5427f8829a4aSRandall Stewart 	}
54287abab911SRobert Watson 	if (sockbuf_lock) {
54297abab911SRobert Watson 		sbunlock(&so->so_rcv);
54307abab911SRobert Watson 	}
543150cec919SRandall Stewart 	if (freecnt_applied) {
5432f8829a4aSRandall Stewart 		/*
5433f8829a4aSRandall Stewart 		 * The lock on the socket buffer protects us so the free
5434f8829a4aSRandall Stewart 		 * code will stop. But since we used the socketbuf lock and
5435f8829a4aSRandall Stewart 		 * the sender uses the tcb_lock to increment, we need to use
5436f8829a4aSRandall Stewart 		 * the atomic add to the refcnt.
5437f8829a4aSRandall Stewart 		 */
543850cec919SRandall Stewart 		if (stcb == NULL) {
543950cec919SRandall Stewart 			panic("stcb for refcnt has gone NULL?");
544050cec919SRandall Stewart 		}
544150cec919SRandall Stewart 		atomic_add_int(&stcb->asoc.refcnt, -1);
5442f8829a4aSRandall Stewart 		freecnt_applied = 0;
5443f8829a4aSRandall Stewart 		/* Save the value back for next time */
5444f8829a4aSRandall Stewart 		stcb->freed_by_sorcv_sincelast = freed_so_far;
5445f8829a4aSRandall Stewart 	}
544680fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) {
5447f8829a4aSRandall Stewart 		if (stcb) {
5448f8829a4aSRandall Stewart 			sctp_misc_ints(SCTP_SORECV_DONE,
5449f8829a4aSRandall Stewart 			    freed_so_far,
5450f8829a4aSRandall Stewart 			    ((uio) ? (slen - uio->uio_resid) : slen),
5451f8829a4aSRandall Stewart 			    stcb->asoc.my_rwnd,
5452f8829a4aSRandall Stewart 			    so->so_rcv.sb_cc);
5453f8829a4aSRandall Stewart 		} else {
5454f8829a4aSRandall Stewart 			sctp_misc_ints(SCTP_SORECV_DONE,
5455f8829a4aSRandall Stewart 			    freed_so_far,
5456f8829a4aSRandall Stewart 			    ((uio) ? (slen - uio->uio_resid) : slen),
5457f8829a4aSRandall Stewart 			    0,
5458f8829a4aSRandall Stewart 			    so->so_rcv.sb_cc);
5459f8829a4aSRandall Stewart 		}
546080fefe0aSRandall Stewart 	}
5461f8829a4aSRandall Stewart 	if (wakeup_read_socket) {
5462f8829a4aSRandall Stewart 		sctp_sorwakeup(inp, so);
5463f8829a4aSRandall Stewart 	}
5464f8829a4aSRandall Stewart 	return (error);
5465f8829a4aSRandall Stewart }
5466f8829a4aSRandall Stewart 
5467f8829a4aSRandall Stewart 
5468f8829a4aSRandall Stewart #ifdef SCTP_MBUF_LOGGING
5469f8829a4aSRandall Stewart struct mbuf *
5470f8829a4aSRandall Stewart sctp_m_free(struct mbuf *m)
5471f8829a4aSRandall Stewart {
547280fefe0aSRandall Stewart 	if (sctp_logging_level & SCTP_MBUF_LOGGING_ENABLE) {
5473139bc87fSRandall Stewart 		if (SCTP_BUF_IS_EXTENDED(m)) {
5474f8829a4aSRandall Stewart 			sctp_log_mb(m, SCTP_MBUF_IFREE);
5475f8829a4aSRandall Stewart 		}
547680fefe0aSRandall Stewart 	}
5477f8829a4aSRandall Stewart 	return (m_free(m));
5478f8829a4aSRandall Stewart }
5479f8829a4aSRandall Stewart 
5480f8829a4aSRandall Stewart void
5481f8829a4aSRandall Stewart sctp_m_freem(struct mbuf *mb)
5482f8829a4aSRandall Stewart {
5483f8829a4aSRandall Stewart 	while (mb != NULL)
5484f8829a4aSRandall Stewart 		mb = sctp_m_free(mb);
5485f8829a4aSRandall Stewart }
5486f8829a4aSRandall Stewart 
5487f8829a4aSRandall Stewart #endif
5488f8829a4aSRandall Stewart 
548942551e99SRandall Stewart int
549042551e99SRandall Stewart sctp_dynamic_set_primary(struct sockaddr *sa, uint32_t vrf_id)
549142551e99SRandall Stewart {
549242551e99SRandall Stewart 	/*
549342551e99SRandall Stewart 	 * Given a local address. For all associations that holds the
549442551e99SRandall Stewart 	 * address, request a peer-set-primary.
549542551e99SRandall Stewart 	 */
549642551e99SRandall Stewart 	struct sctp_ifa *ifa;
549742551e99SRandall Stewart 	struct sctp_laddr *wi;
549842551e99SRandall Stewart 
549942551e99SRandall Stewart 	ifa = sctp_find_ifa_by_addr(sa, vrf_id, 0);
550042551e99SRandall Stewart 	if (ifa == NULL) {
550142551e99SRandall Stewart 		return (EADDRNOTAVAIL);
550242551e99SRandall Stewart 	}
550342551e99SRandall Stewart 	/*
550442551e99SRandall Stewart 	 * Now that we have the ifa we must awaken the iterator with this
550542551e99SRandall Stewart 	 * message.
550642551e99SRandall Stewart 	 */
550742551e99SRandall Stewart 	wi = SCTP_ZONE_GET(sctppcbinfo.ipi_zone_laddr, struct sctp_laddr);
550842551e99SRandall Stewart 	if (wi == NULL) {
550942551e99SRandall Stewart 		return (ENOMEM);
551042551e99SRandall Stewart 	}
551142551e99SRandall Stewart 	/* Now incr the count and int wi structure */
551242551e99SRandall Stewart 	SCTP_INCR_LADDR_COUNT();
551342551e99SRandall Stewart 	bzero(wi, sizeof(*wi));
5514d61a0ae0SRandall Stewart 	(void)SCTP_GETTIME_TIMEVAL(&wi->start_time);
551542551e99SRandall Stewart 	wi->ifa = ifa;
551642551e99SRandall Stewart 	wi->action = SCTP_SET_PRIM_ADDR;
551742551e99SRandall Stewart 	atomic_add_int(&ifa->refcount, 1);
551842551e99SRandall Stewart 
551942551e99SRandall Stewart 	/* Now add it to the work queue */
552042551e99SRandall Stewart 	SCTP_IPI_ITERATOR_WQ_LOCK();
552142551e99SRandall Stewart 	/*
552242551e99SRandall Stewart 	 * Should this really be a tailq? As it is we will process the
552342551e99SRandall Stewart 	 * newest first :-0
552442551e99SRandall Stewart 	 */
552542551e99SRandall Stewart 	LIST_INSERT_HEAD(&sctppcbinfo.addr_wq, wi, sctp_nxt_addr);
552642551e99SRandall Stewart 	sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ,
552742551e99SRandall Stewart 	    (struct sctp_inpcb *)NULL,
552842551e99SRandall Stewart 	    (struct sctp_tcb *)NULL,
552942551e99SRandall Stewart 	    (struct sctp_nets *)NULL);
553042551e99SRandall Stewart 	SCTP_IPI_ITERATOR_WQ_UNLOCK();
553142551e99SRandall Stewart 	return (0);
553242551e99SRandall Stewart }
553342551e99SRandall Stewart 
553442551e99SRandall Stewart 
553542551e99SRandall Stewart 
5536f8829a4aSRandall Stewart 
5537f8829a4aSRandall Stewart int
553817205eccSRandall Stewart sctp_soreceive(struct socket *so,
553917205eccSRandall Stewart     struct sockaddr **psa,
554017205eccSRandall Stewart     struct uio *uio,
554117205eccSRandall Stewart     struct mbuf **mp0,
554217205eccSRandall Stewart     struct mbuf **controlp,
554317205eccSRandall Stewart     int *flagsp)
5544f8829a4aSRandall Stewart {
5545f8829a4aSRandall Stewart 	int error, fromlen;
5546f8829a4aSRandall Stewart 	uint8_t sockbuf[256];
5547f8829a4aSRandall Stewart 	struct sockaddr *from;
5548f8829a4aSRandall Stewart 	struct sctp_extrcvinfo sinfo;
5549f8829a4aSRandall Stewart 	int filling_sinfo = 1;
5550f8829a4aSRandall Stewart 	struct sctp_inpcb *inp;
5551f8829a4aSRandall Stewart 
5552f8829a4aSRandall Stewart 	inp = (struct sctp_inpcb *)so->so_pcb;
5553f8829a4aSRandall Stewart 	/* pickup the assoc we are reading from */
5554f8829a4aSRandall Stewart 	if (inp == NULL) {
5555f8829a4aSRandall Stewart 		return (EINVAL);
5556f8829a4aSRandall Stewart 	}
5557f8829a4aSRandall Stewart 	if ((sctp_is_feature_off(inp,
5558f8829a4aSRandall Stewart 	    SCTP_PCB_FLAGS_RECVDATAIOEVNT)) ||
5559f8829a4aSRandall Stewart 	    (controlp == NULL)) {
5560f8829a4aSRandall Stewart 		/* user does not want the sndrcv ctl */
5561f8829a4aSRandall Stewart 		filling_sinfo = 0;
5562f8829a4aSRandall Stewart 	}
5563f8829a4aSRandall Stewart 	if (psa) {
5564f8829a4aSRandall Stewart 		from = (struct sockaddr *)sockbuf;
5565f8829a4aSRandall Stewart 		fromlen = sizeof(sockbuf);
5566f8829a4aSRandall Stewart 		from->sa_len = 0;
5567f8829a4aSRandall Stewart 	} else {
5568f8829a4aSRandall Stewart 		from = NULL;
5569f8829a4aSRandall Stewart 		fromlen = 0;
5570f8829a4aSRandall Stewart 	}
5571f8829a4aSRandall Stewart 
5572f8829a4aSRandall Stewart 	error = sctp_sorecvmsg(so, uio, mp0, from, fromlen, flagsp,
5573f8829a4aSRandall Stewart 	    (struct sctp_sndrcvinfo *)&sinfo, filling_sinfo);
5574f8829a4aSRandall Stewart 	if ((controlp) && (filling_sinfo)) {
5575f8829a4aSRandall Stewart 		/* copy back the sinfo in a CMSG format */
5576f8829a4aSRandall Stewart 		if (filling_sinfo)
5577f8829a4aSRandall Stewart 			*controlp = sctp_build_ctl_nchunk(inp,
5578f8829a4aSRandall Stewart 			    (struct sctp_sndrcvinfo *)&sinfo);
5579f8829a4aSRandall Stewart 		else
5580f8829a4aSRandall Stewart 			*controlp = NULL;
5581f8829a4aSRandall Stewart 	}
5582f8829a4aSRandall Stewart 	if (psa) {
5583f8829a4aSRandall Stewart 		/* copy back the address info */
5584f8829a4aSRandall Stewart 		if (from && from->sa_len) {
5585f8829a4aSRandall Stewart 			*psa = sodupsockaddr(from, M_NOWAIT);
5586f8829a4aSRandall Stewart 		} else {
5587f8829a4aSRandall Stewart 			*psa = NULL;
5588f8829a4aSRandall Stewart 		}
5589f8829a4aSRandall Stewart 	}
5590f8829a4aSRandall Stewart 	return (error);
5591f8829a4aSRandall Stewart }
559217205eccSRandall Stewart 
559317205eccSRandall Stewart 
559417205eccSRandall Stewart int
559517205eccSRandall Stewart sctp_l_soreceive(struct socket *so,
559617205eccSRandall Stewart     struct sockaddr **name,
559717205eccSRandall Stewart     struct uio *uio,
559817205eccSRandall Stewart     char **controlp,
559917205eccSRandall Stewart     int *controllen,
560017205eccSRandall Stewart     int *flag)
560117205eccSRandall Stewart {
560217205eccSRandall Stewart 	int error, fromlen;
560317205eccSRandall Stewart 	uint8_t sockbuf[256];
560417205eccSRandall Stewart 	struct sockaddr *from;
560517205eccSRandall Stewart 	struct sctp_extrcvinfo sinfo;
560617205eccSRandall Stewart 	int filling_sinfo = 1;
560717205eccSRandall Stewart 	struct sctp_inpcb *inp;
560817205eccSRandall Stewart 
560917205eccSRandall Stewart 	inp = (struct sctp_inpcb *)so->so_pcb;
561017205eccSRandall Stewart 	/* pickup the assoc we are reading from */
561117205eccSRandall Stewart 	if (inp == NULL) {
561217205eccSRandall Stewart 		return (EINVAL);
561317205eccSRandall Stewart 	}
561417205eccSRandall Stewart 	if ((sctp_is_feature_off(inp,
561517205eccSRandall Stewart 	    SCTP_PCB_FLAGS_RECVDATAIOEVNT)) ||
561617205eccSRandall Stewart 	    (controlp == NULL)) {
561717205eccSRandall Stewart 		/* user does not want the sndrcv ctl */
561817205eccSRandall Stewart 		filling_sinfo = 0;
561917205eccSRandall Stewart 	}
562017205eccSRandall Stewart 	if (name) {
562117205eccSRandall Stewart 		from = (struct sockaddr *)sockbuf;
562217205eccSRandall Stewart 		fromlen = sizeof(sockbuf);
562317205eccSRandall Stewart 		from->sa_len = 0;
562417205eccSRandall Stewart 	} else {
562517205eccSRandall Stewart 		from = NULL;
562617205eccSRandall Stewart 		fromlen = 0;
562717205eccSRandall Stewart 	}
562817205eccSRandall Stewart 
562917205eccSRandall Stewart 	error = sctp_sorecvmsg(so, uio,
563017205eccSRandall Stewart 	    (struct mbuf **)NULL,
563117205eccSRandall Stewart 	    from, fromlen, flag,
563217205eccSRandall Stewart 	    (struct sctp_sndrcvinfo *)&sinfo,
563317205eccSRandall Stewart 	    filling_sinfo);
563417205eccSRandall Stewart 	if ((controlp) && (filling_sinfo)) {
563517205eccSRandall Stewart 		/*
563617205eccSRandall Stewart 		 * copy back the sinfo in a CMSG format note that the caller
563717205eccSRandall Stewart 		 * has reponsibility for freeing the memory.
563817205eccSRandall Stewart 		 */
563917205eccSRandall Stewart 		if (filling_sinfo)
564017205eccSRandall Stewart 			*controlp = sctp_build_ctl_cchunk(inp,
564117205eccSRandall Stewart 			    controllen,
564217205eccSRandall Stewart 			    (struct sctp_sndrcvinfo *)&sinfo);
564317205eccSRandall Stewart 	}
564417205eccSRandall Stewart 	if (name) {
564517205eccSRandall Stewart 		/* copy back the address info */
564617205eccSRandall Stewart 		if (from && from->sa_len) {
564717205eccSRandall Stewart 			*name = sodupsockaddr(from, M_WAIT);
564817205eccSRandall Stewart 		} else {
564917205eccSRandall Stewart 			*name = NULL;
565017205eccSRandall Stewart 		}
565117205eccSRandall Stewart 	}
565217205eccSRandall Stewart 	return (error);
565317205eccSRandall Stewart }
565417205eccSRandall Stewart 
565517205eccSRandall Stewart 
565617205eccSRandall Stewart 
565717205eccSRandall Stewart 
565817205eccSRandall Stewart 
565917205eccSRandall Stewart 
566017205eccSRandall Stewart 
566117205eccSRandall Stewart int
5662d61a0ae0SRandall Stewart sctp_connectx_helper_add(struct sctp_tcb *stcb, struct sockaddr *addr,
5663d61a0ae0SRandall Stewart     int totaddr, int *error)
566417205eccSRandall Stewart {
566517205eccSRandall Stewart 	int added = 0;
566617205eccSRandall Stewart 	int i;
566717205eccSRandall Stewart 	struct sctp_inpcb *inp;
566817205eccSRandall Stewart 	struct sockaddr *sa;
566917205eccSRandall Stewart 	size_t incr = 0;
567017205eccSRandall Stewart 
567117205eccSRandall Stewart 	sa = addr;
567217205eccSRandall Stewart 	inp = stcb->sctp_ep;
567317205eccSRandall Stewart 	*error = 0;
567417205eccSRandall Stewart 	for (i = 0; i < totaddr; i++) {
567517205eccSRandall Stewart 		if (sa->sa_family == AF_INET) {
567617205eccSRandall Stewart 			incr = sizeof(struct sockaddr_in);
567717205eccSRandall Stewart 			if (sctp_add_remote_addr(stcb, sa, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) {
567817205eccSRandall Stewart 				/* assoc gone no un-lock */
567917205eccSRandall Stewart 				sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ + SCTP_LOC_7);
568017205eccSRandall Stewart 				*error = ENOBUFS;
568117205eccSRandall Stewart 				goto out_now;
568217205eccSRandall Stewart 			}
568317205eccSRandall Stewart 			added++;
568417205eccSRandall Stewart 		} else if (sa->sa_family == AF_INET6) {
568517205eccSRandall Stewart 			incr = sizeof(struct sockaddr_in6);
568617205eccSRandall Stewart 			if (sctp_add_remote_addr(stcb, sa, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) {
568717205eccSRandall Stewart 				/* assoc gone no un-lock */
568817205eccSRandall Stewart 				sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ + SCTP_LOC_8);
568917205eccSRandall Stewart 				*error = ENOBUFS;
569017205eccSRandall Stewart 				goto out_now;
569117205eccSRandall Stewart 			}
569217205eccSRandall Stewart 			added++;
569317205eccSRandall Stewart 		}
569417205eccSRandall Stewart 		sa = (struct sockaddr *)((caddr_t)sa + incr);
569517205eccSRandall Stewart 	}
569617205eccSRandall Stewart out_now:
569717205eccSRandall Stewart 	return (added);
569817205eccSRandall Stewart }
569917205eccSRandall Stewart 
570017205eccSRandall Stewart struct sctp_tcb *
5701d61a0ae0SRandall Stewart sctp_connectx_helper_find(struct sctp_inpcb *inp, struct sockaddr *addr,
5702d61a0ae0SRandall Stewart     int *totaddr, int *num_v4, int *num_v6, int *error,
5703d61a0ae0SRandall Stewart     int limit, int *bad_addr)
570417205eccSRandall Stewart {
570517205eccSRandall Stewart 	struct sockaddr *sa;
570617205eccSRandall Stewart 	struct sctp_tcb *stcb = NULL;
570717205eccSRandall Stewart 	size_t incr, at, i;
570817205eccSRandall Stewart 
570917205eccSRandall Stewart 	at = incr = 0;
571017205eccSRandall Stewart 	sa = addr;
571117205eccSRandall Stewart 	*error = *num_v6 = *num_v4 = 0;
571217205eccSRandall Stewart 	/* account and validate addresses */
57134c9179adSRandall Stewart 	for (i = 0; i < (size_t)*totaddr; i++) {
571417205eccSRandall Stewart 		if (sa->sa_family == AF_INET) {
571517205eccSRandall Stewart 			(*num_v4) += 1;
571617205eccSRandall Stewart 			incr = sizeof(struct sockaddr_in);
5717d61a0ae0SRandall Stewart 			if (sa->sa_len != incr) {
5718d61a0ae0SRandall Stewart 				*error = EINVAL;
5719d61a0ae0SRandall Stewart 				*bad_addr = 1;
5720d61a0ae0SRandall Stewart 				return (NULL);
5721d61a0ae0SRandall Stewart 			}
572217205eccSRandall Stewart 		} else if (sa->sa_family == AF_INET6) {
572317205eccSRandall Stewart 			struct sockaddr_in6 *sin6;
572417205eccSRandall Stewart 
572517205eccSRandall Stewart 			sin6 = (struct sockaddr_in6 *)sa;
572617205eccSRandall Stewart 			if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
572717205eccSRandall Stewart 				/* Must be non-mapped for connectx */
572817205eccSRandall Stewart 				*error = EINVAL;
5729d61a0ae0SRandall Stewart 				*bad_addr = 1;
573017205eccSRandall Stewart 				return (NULL);
573117205eccSRandall Stewart 			}
573217205eccSRandall Stewart 			(*num_v6) += 1;
573317205eccSRandall Stewart 			incr = sizeof(struct sockaddr_in6);
5734d61a0ae0SRandall Stewart 			if (sa->sa_len != incr) {
5735d61a0ae0SRandall Stewart 				*error = EINVAL;
5736d61a0ae0SRandall Stewart 				*bad_addr = 1;
5737d61a0ae0SRandall Stewart 				return (NULL);
5738d61a0ae0SRandall Stewart 			}
573917205eccSRandall Stewart 		} else {
574017205eccSRandall Stewart 			*totaddr = i;
574117205eccSRandall Stewart 			/* we are done */
574217205eccSRandall Stewart 			break;
574317205eccSRandall Stewart 		}
5744d61a0ae0SRandall Stewart 		SCTP_INP_INCR_REF(inp);
574517205eccSRandall Stewart 		stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);
574617205eccSRandall Stewart 		if (stcb != NULL) {
574717205eccSRandall Stewart 			/* Already have or am bring up an association */
574817205eccSRandall Stewart 			return (stcb);
5749d61a0ae0SRandall Stewart 		} else {
5750d61a0ae0SRandall Stewart 			SCTP_INP_DECR_REF(inp);
575117205eccSRandall Stewart 		}
57524c9179adSRandall Stewart 		if ((at + incr) > (size_t)limit) {
575317205eccSRandall Stewart 			*totaddr = i;
575417205eccSRandall Stewart 			break;
575517205eccSRandall Stewart 		}
575617205eccSRandall Stewart 		sa = (struct sockaddr *)((caddr_t)sa + incr);
575717205eccSRandall Stewart 	}
575817205eccSRandall Stewart 	return ((struct sctp_tcb *)NULL);
575917205eccSRandall Stewart }
576035918f85SRandall Stewart 
576135918f85SRandall Stewart /*
576235918f85SRandall Stewart  * sctp_bindx(ADD) for one address.
576335918f85SRandall Stewart  * assumes all arguments are valid/checked by caller.
576435918f85SRandall Stewart  */
576535918f85SRandall Stewart void
576635918f85SRandall Stewart sctp_bindx_add_address(struct socket *so, struct sctp_inpcb *inp,
576735918f85SRandall Stewart     struct sockaddr *sa, sctp_assoc_t assoc_id,
576835918f85SRandall Stewart     uint32_t vrf_id, int *error, void *p)
576935918f85SRandall Stewart {
577035918f85SRandall Stewart 	struct sockaddr *addr_touse;
577135918f85SRandall Stewart 	struct sockaddr_in sin;
577235918f85SRandall Stewart 
577335918f85SRandall Stewart 	/* see if we're bound all already! */
577435918f85SRandall Stewart 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
577535918f85SRandall Stewart 		*error = EINVAL;
577635918f85SRandall Stewart 		return;
577735918f85SRandall Stewart 	}
577835918f85SRandall Stewart 	addr_touse = sa;
577935918f85SRandall Stewart #if defined(INET6)
578035918f85SRandall Stewart 	if (sa->sa_family == AF_INET6) {
578135918f85SRandall Stewart 		struct sockaddr_in6 *sin6;
578235918f85SRandall Stewart 
578335918f85SRandall Stewart 		if (sa->sa_len != sizeof(struct sockaddr_in6)) {
578435918f85SRandall Stewart 			*error = EINVAL;
578535918f85SRandall Stewart 			return;
578635918f85SRandall Stewart 		}
5787db4fd95bSRandall Stewart 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
5788db4fd95bSRandall Stewart 			/* can only bind v6 on PF_INET6 sockets */
5789db4fd95bSRandall Stewart 			*error = EINVAL;
5790db4fd95bSRandall Stewart 			return;
5791db4fd95bSRandall Stewart 		}
579235918f85SRandall Stewart 		sin6 = (struct sockaddr_in6 *)addr_touse;
579335918f85SRandall Stewart 		if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
5794db4fd95bSRandall Stewart 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
5795db4fd95bSRandall Stewart 			    SCTP_IPV6_V6ONLY(inp)) {
5796db4fd95bSRandall Stewart 				/* can't bind v4-mapped on PF_INET sockets */
5797db4fd95bSRandall Stewart 				*error = EINVAL;
5798db4fd95bSRandall Stewart 				return;
5799db4fd95bSRandall Stewart 			}
580035918f85SRandall Stewart 			in6_sin6_2_sin(&sin, sin6);
580135918f85SRandall Stewart 			addr_touse = (struct sockaddr *)&sin;
580235918f85SRandall Stewart 		}
580335918f85SRandall Stewart 	}
580435918f85SRandall Stewart #endif
580535918f85SRandall Stewart 	if (sa->sa_family == AF_INET) {
580635918f85SRandall Stewart 		if (sa->sa_len != sizeof(struct sockaddr_in)) {
580735918f85SRandall Stewart 			*error = EINVAL;
580835918f85SRandall Stewart 			return;
580935918f85SRandall Stewart 		}
5810db4fd95bSRandall Stewart 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
5811db4fd95bSRandall Stewart 		    SCTP_IPV6_V6ONLY(inp)) {
5812db4fd95bSRandall Stewart 			/* can't bind v4 on PF_INET sockets */
5813db4fd95bSRandall Stewart 			*error = EINVAL;
5814db4fd95bSRandall Stewart 			return;
5815db4fd95bSRandall Stewart 		}
581635918f85SRandall Stewart 	}
581735918f85SRandall Stewart 	if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
581835918f85SRandall Stewart 		if (p == NULL) {
581935918f85SRandall Stewart 			/* Can't get proc for Net/Open BSD */
582035918f85SRandall Stewart 			*error = EINVAL;
582135918f85SRandall Stewart 			return;
582235918f85SRandall Stewart 		}
582380fefe0aSRandall Stewart 		*error = sctp_inpcb_bind(so, addr_touse, NULL, p);
582435918f85SRandall Stewart 		return;
582535918f85SRandall Stewart 	}
582635918f85SRandall Stewart 	/*
582735918f85SRandall Stewart 	 * No locks required here since bind and mgmt_ep_sa all do their own
582835918f85SRandall Stewart 	 * locking. If we do something for the FIX: below we may need to
582935918f85SRandall Stewart 	 * lock in that case.
583035918f85SRandall Stewart 	 */
583135918f85SRandall Stewart 	if (assoc_id == 0) {
583235918f85SRandall Stewart 		/* add the address */
583335918f85SRandall Stewart 		struct sctp_inpcb *lep;
583497c76f10SRandall Stewart 		struct sockaddr_in *lsin = (struct sockaddr_in *)addr_touse;
583535918f85SRandall Stewart 
583697c76f10SRandall Stewart 		/* validate the incoming port */
583797c76f10SRandall Stewart 		if ((lsin->sin_port != 0) &&
583897c76f10SRandall Stewart 		    (lsin->sin_port != inp->sctp_lport)) {
583997c76f10SRandall Stewart 			*error = EINVAL;
584097c76f10SRandall Stewart 			return;
584197c76f10SRandall Stewart 		} else {
584297c76f10SRandall Stewart 			/* user specified 0 port, set it to existing port */
584397c76f10SRandall Stewart 			lsin->sin_port = inp->sctp_lport;
584497c76f10SRandall Stewart 		}
584597c76f10SRandall Stewart 
584635918f85SRandall Stewart 		lep = sctp_pcb_findep(addr_touse, 1, 0, vrf_id);
584735918f85SRandall Stewart 		if (lep != NULL) {
584835918f85SRandall Stewart 			/*
584935918f85SRandall Stewart 			 * We must decrement the refcount since we have the
585035918f85SRandall Stewart 			 * ep already and are binding. No remove going on
585135918f85SRandall Stewart 			 * here.
585235918f85SRandall Stewart 			 */
585335918f85SRandall Stewart 			SCTP_INP_DECR_REF(inp);
585435918f85SRandall Stewart 		}
585535918f85SRandall Stewart 		if (lep == inp) {
585635918f85SRandall Stewart 			/* already bound to it.. ok */
585735918f85SRandall Stewart 			return;
585835918f85SRandall Stewart 		} else if (lep == NULL) {
585935918f85SRandall Stewart 			((struct sockaddr_in *)addr_touse)->sin_port = 0;
586035918f85SRandall Stewart 			*error = sctp_addr_mgmt_ep_sa(inp, addr_touse,
586135918f85SRandall Stewart 			    SCTP_ADD_IP_ADDRESS,
586280fefe0aSRandall Stewart 			    vrf_id, NULL);
586335918f85SRandall Stewart 		} else {
586435918f85SRandall Stewart 			*error = EADDRINUSE;
586535918f85SRandall Stewart 		}
586635918f85SRandall Stewart 		if (*error)
586735918f85SRandall Stewart 			return;
586835918f85SRandall Stewart 	} else {
586935918f85SRandall Stewart 		/*
587035918f85SRandall Stewart 		 * FIX: decide whether we allow assoc based bindx
587135918f85SRandall Stewart 		 */
587235918f85SRandall Stewart 	}
587335918f85SRandall Stewart }
587435918f85SRandall Stewart 
587535918f85SRandall Stewart /*
587635918f85SRandall Stewart  * sctp_bindx(DELETE) for one address.
587735918f85SRandall Stewart  * assumes all arguments are valid/checked by caller.
587835918f85SRandall Stewart  */
587935918f85SRandall Stewart void
588035918f85SRandall Stewart sctp_bindx_delete_address(struct socket *so, struct sctp_inpcb *inp,
588135918f85SRandall Stewart     struct sockaddr *sa, sctp_assoc_t assoc_id,
588235918f85SRandall Stewart     uint32_t vrf_id, int *error)
588335918f85SRandall Stewart {
588435918f85SRandall Stewart 	struct sockaddr *addr_touse;
588535918f85SRandall Stewart 	struct sockaddr_in sin;
588635918f85SRandall Stewart 
588735918f85SRandall Stewart 	/* see if we're bound all already! */
588835918f85SRandall Stewart 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
588935918f85SRandall Stewart 		*error = EINVAL;
589035918f85SRandall Stewart 		return;
589135918f85SRandall Stewart 	}
589235918f85SRandall Stewart 	addr_touse = sa;
589335918f85SRandall Stewart #if defined(INET6)
589435918f85SRandall Stewart 	if (sa->sa_family == AF_INET6) {
589535918f85SRandall Stewart 		struct sockaddr_in6 *sin6;
589635918f85SRandall Stewart 
589735918f85SRandall Stewart 		if (sa->sa_len != sizeof(struct sockaddr_in6)) {
589835918f85SRandall Stewart 			*error = EINVAL;
589935918f85SRandall Stewart 			return;
590035918f85SRandall Stewart 		}
5901db4fd95bSRandall Stewart 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
5902db4fd95bSRandall Stewart 			/* can only bind v6 on PF_INET6 sockets */
5903db4fd95bSRandall Stewart 			*error = EINVAL;
5904db4fd95bSRandall Stewart 			return;
5905db4fd95bSRandall Stewart 		}
590635918f85SRandall Stewart 		sin6 = (struct sockaddr_in6 *)addr_touse;
590735918f85SRandall Stewart 		if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
5908db4fd95bSRandall Stewart 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
5909db4fd95bSRandall Stewart 			    SCTP_IPV6_V6ONLY(inp)) {
5910db4fd95bSRandall Stewart 				/* can't bind mapped-v4 on PF_INET sockets */
5911db4fd95bSRandall Stewart 				*error = EINVAL;
5912db4fd95bSRandall Stewart 				return;
5913db4fd95bSRandall Stewart 			}
591435918f85SRandall Stewart 			in6_sin6_2_sin(&sin, sin6);
591535918f85SRandall Stewart 			addr_touse = (struct sockaddr *)&sin;
591635918f85SRandall Stewart 		}
591735918f85SRandall Stewart 	}
591835918f85SRandall Stewart #endif
591935918f85SRandall Stewart 	if (sa->sa_family == AF_INET) {
592035918f85SRandall Stewart 		if (sa->sa_len != sizeof(struct sockaddr_in)) {
592135918f85SRandall Stewart 			*error = EINVAL;
592235918f85SRandall Stewart 			return;
592335918f85SRandall Stewart 		}
5924db4fd95bSRandall Stewart 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
5925db4fd95bSRandall Stewart 		    SCTP_IPV6_V6ONLY(inp)) {
5926db4fd95bSRandall Stewart 			/* can't bind v4 on PF_INET sockets */
5927db4fd95bSRandall Stewart 			*error = EINVAL;
5928db4fd95bSRandall Stewart 			return;
5929db4fd95bSRandall Stewart 		}
593035918f85SRandall Stewart 	}
593135918f85SRandall Stewart 	/*
593235918f85SRandall Stewart 	 * No lock required mgmt_ep_sa does its own locking. If the FIX:
593335918f85SRandall Stewart 	 * below is ever changed we may need to lock before calling
593435918f85SRandall Stewart 	 * association level binding.
593535918f85SRandall Stewart 	 */
593635918f85SRandall Stewart 	if (assoc_id == 0) {
593735918f85SRandall Stewart 		/* delete the address */
593835918f85SRandall Stewart 		*error = sctp_addr_mgmt_ep_sa(inp, addr_touse,
593935918f85SRandall Stewart 		    SCTP_DEL_IP_ADDRESS,
594080fefe0aSRandall Stewart 		    vrf_id, NULL);
594135918f85SRandall Stewart 	} else {
594235918f85SRandall Stewart 		/*
594335918f85SRandall Stewart 		 * FIX: decide whether we allow assoc based bindx
594435918f85SRandall Stewart 		 */
594535918f85SRandall Stewart 	}
594635918f85SRandall Stewart }
5947