1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #ifndef	_INET_SCTP_SCTP_IMPL_H
27 #define	_INET_SCTP_SCTP_IMPL_H
28 
29 #include <sys/inttypes.h>
30 #include <sys/taskq.h>
31 #include <sys/list.h>
32 #include <sys/strsun.h>
33 #include <sys/zone.h>
34 #include <sys/cpuvar.h>
35 #include <sys/clock_impl.h>
36 
37 #include <netinet/ip6.h>
38 #include <inet/optcom.h>
39 #include <inet/tunables.h>
40 #include <netinet/sctp.h>
41 #include <inet/sctp_itf.h>
42 #include "sctp_stack.h"
43 
44 #ifdef	__cplusplus
45 extern "C" {
46 #endif
47 
48 /* Streams device identifying info and version */
49 #define	SCTP_DEV_IDINFO	"SCTP Streams device 1.0"
50 
51 #define	SSN_GT(a, b)	((int16_t)((a)-(b)) > 0)
52 #define	SSN_GE(a, b)	((int16_t)((a)-(b)) >= 0)
53 
54 /* Default buffer size and flow control wake up threshold. */
55 #define	SCTP_XMIT_LOWATER	8192
56 #define	SCTP_XMIT_HIWATER	102400
57 #define	SCTP_RECV_LOWATER	8192
58 #define	SCTP_RECV_HIWATER	102400
59 
60 /* SCTP Timer control structure */
61 typedef struct sctpt_s {
62 	pfv_t	sctpt_pfv;	/* The routine we are to call */
63 	struct sctp_s *sctpt_sctp;	/* The parameter we are to pass in */
64 	struct sctp_faddr_s *sctpt_faddr;
65 } sctpt_t;
66 
67 /*
68  * Maximum number of duplicate TSNs we can report. This is currently
69  * static, and governs the size of the mblk used to hold the duplicate
70  * reports. The use of duplcate TSN reports is currently experimental,
71  * so for now a static limit should suffice.
72  */
73 #define	SCTP_DUP_MBLK_SZ	64
74 
75 #define	SCTP_IS_ADDR_UNSPEC(isv4, addr)		\
76 	((isv4) ? IN6_IS_ADDR_V4MAPPED_ANY(&(addr)) :	\
77 	IN6_IS_ADDR_UNSPECIFIED(&(addr)))
78 
79 /*
80  * SCTP properties/tunables
81  */
82 #define	sctps_max_init_retr		sctps_propinfo_tbl[0].prop_cur_uval
83 #define	sctps_max_init_retr_high	sctps_propinfo_tbl[0].prop_max_uval
84 #define	sctps_max_init_retr_low		sctps_propinfo_tbl[0].prop_min_uval
85 #define	sctps_pa_max_retr		sctps_propinfo_tbl[1].prop_cur_uval
86 #define	sctps_pa_max_retr_high		sctps_propinfo_tbl[1].prop_max_uval
87 #define	sctps_pa_max_retr_low		sctps_propinfo_tbl[1].prop_min_uval
88 #define	sctps_pp_max_retr		sctps_propinfo_tbl[2].prop_cur_uval
89 #define	sctps_pp_max_retr_high		sctps_propinfo_tbl[2].prop_max_uval
90 #define	sctps_pp_max_retr_low		sctps_propinfo_tbl[2].prop_min_uval
91 #define	sctps_cwnd_max_			sctps_propinfo_tbl[3].prop_cur_uval
92 #define	sctps_smallest_nonpriv_port	sctps_propinfo_tbl[4].prop_cur_uval
93 #define	sctps_ipv4_ttl			sctps_propinfo_tbl[5].prop_cur_uval
94 #define	sctps_heartbeat_interval	sctps_propinfo_tbl[6].prop_cur_uval
95 #define	sctps_heartbeat_interval_high	sctps_propinfo_tbl[6].prop_max_uval
96 #define	sctps_heartbeat_interval_low	sctps_propinfo_tbl[6].prop_min_uval
97 #define	sctps_initial_mtu		sctps_propinfo_tbl[7].prop_cur_uval
98 #define	sctps_mtu_probe_interval	sctps_propinfo_tbl[8].prop_cur_uval
99 #define	sctps_new_secret_interval	sctps_propinfo_tbl[9].prop_cur_uval
100 #define	sctps_deferred_ack_interval	sctps_propinfo_tbl[10].prop_cur_uval
101 #define	sctps_snd_lowat_fraction	sctps_propinfo_tbl[11].prop_cur_uval
102 #define	sctps_ignore_path_mtu		sctps_propinfo_tbl[12].prop_cur_bval
103 #define	sctps_initial_ssthresh		sctps_propinfo_tbl[13].prop_cur_uval
104 #define	sctps_smallest_anon_port	sctps_propinfo_tbl[14].prop_cur_uval
105 #define	sctps_largest_anon_port		sctps_propinfo_tbl[15].prop_cur_uval
106 #define	sctps_xmit_hiwat		sctps_propinfo_tbl[16].prop_cur_uval
107 #define	sctps_xmit_lowat		sctps_propinfo_tbl[17].prop_cur_uval
108 #define	sctps_recv_hiwat		sctps_propinfo_tbl[18].prop_cur_uval
109 #define	sctps_max_buf			sctps_propinfo_tbl[19].prop_cur_uval
110 #define	sctps_rtt_updates		sctps_propinfo_tbl[20].prop_cur_uval
111 #define	sctps_ipv6_hoplimit		sctps_propinfo_tbl[21].prop_cur_uval
112 #define	sctps_rto_ming			sctps_propinfo_tbl[22].prop_cur_uval
113 #define	sctps_rto_ming_high		sctps_propinfo_tbl[22].prop_max_uval
114 #define	sctps_rto_ming_low		sctps_propinfo_tbl[22].prop_min_uval
115 #define	sctps_rto_maxg			sctps_propinfo_tbl[23].prop_cur_uval
116 #define	sctps_rto_maxg_high		sctps_propinfo_tbl[23].prop_max_uval
117 #define	sctps_rto_maxg_low		sctps_propinfo_tbl[23].prop_min_uval
118 #define	sctps_rto_initialg		sctps_propinfo_tbl[24].prop_cur_uval
119 #define	sctps_rto_initialg_high		sctps_propinfo_tbl[24].prop_max_uval
120 #define	sctps_rto_initialg_low		sctps_propinfo_tbl[24].prop_min_uval
121 #define	sctps_cookie_life		sctps_propinfo_tbl[25].prop_cur_uval
122 #define	sctps_cookie_life_high		sctps_propinfo_tbl[25].prop_max_uval
123 #define	sctps_cookie_life_low		sctps_propinfo_tbl[25].prop_min_uval
124 #define	sctps_max_in_streams		sctps_propinfo_tbl[26].prop_cur_uval
125 #define	sctps_max_in_streams_high	sctps_propinfo_tbl[26].prop_max_uval
126 #define	sctps_max_in_streams_low	sctps_propinfo_tbl[26].prop_min_uval
127 #define	sctps_initial_out_streams	sctps_propinfo_tbl[27].prop_cur_uval
128 #define	sctps_initial_out_streams_high	sctps_propinfo_tbl[27].prop_max_uval
129 #define	sctps_initial_out_streams_low	sctps_propinfo_tbl[27].prop_min_uval
130 #define	sctps_shutack_wait_bound	sctps_propinfo_tbl[28].prop_cur_uval
131 #define	sctps_maxburst			sctps_propinfo_tbl[29].prop_cur_uval
132 #define	sctps_addip_enabled		sctps_propinfo_tbl[30].prop_cur_bval
133 #define	sctps_recv_hiwat_minmss		sctps_propinfo_tbl[31].prop_cur_uval
134 #define	sctps_slow_start_initial	sctps_propinfo_tbl[32].prop_cur_uval
135 #define	sctps_slow_start_after_idle	sctps_propinfo_tbl[33].prop_cur_uval
136 #define	sctps_prsctp_enabled		sctps_propinfo_tbl[34].prop_cur_bval
137 #define	sctps_fast_rxt_thresh		sctps_propinfo_tbl[35].prop_cur_uval
138 #define	sctps_deferred_acks_max		sctps_propinfo_tbl[36].prop_cur_uval
139 #define	sctps_wroff_xtra		sctps_propinfo_tbl[37].prop_cur_uval
140 
141 /*
142  * Retransmission timer start and stop macro for a given faddr.
143  */
144 #define	SCTP_FADDR_TIMER_RESTART(sctp, fp, intvl)			\
145 {									\
146 	dprint(3, ("faddr_timer_restart: fp=%p %x:%x:%x:%x %d\n",	\
147 	    (void *)(fp), SCTP_PRINTADDR((fp)->sf_faddr), (int)(intvl))); \
148 	sctp_timer((sctp), (fp)->sf_timer_mp, (intvl));			\
149 	(fp)->sf_timer_running = 1;					\
150 }
151 
152 #define	SCTP_FADDR_TIMER_STOP(fp)			\
153 	ASSERT((fp)->sf_timer_mp != NULL);		\
154 	if ((fp)->sf_timer_running) {			\
155 		sctp_timer_stop((fp)->sf_timer_mp);	\
156 		(fp)->sf_timer_running = 0;		\
157 	}
158 
159 /* For per endpoint association statistics */
160 #define	SCTP_MAX_RTO(sctp, fp) {			\
161 	/*						\
162 	 * Record the maximum observed RTO,		\
163 	 * sctp_maxrto is zeroed elsewhere		\
164 	 * at the end of each stats request.		\
165 	 */						\
166 	(sctp)->sctp_maxrto =				\
167 	    MAX((sctp)->sctp_maxrto, (fp)->sf_rto);	\
168 	DTRACE_PROBE2(sctp__maxrto, sctp_t *,		\
169 	    sctp, struct sctp_faddr_s, fp);		\
170 }
171 
172 #define	SCTP_CALC_RXT(sctp, fp, max)	\
173 {					\
174 	if (((fp)->sf_rto <<= 1) > (max))	\
175 		(fp)->sf_rto = (max);	\
176 	SCTP_MAX_RTO(sctp, fp);		\
177 }
178 
179 
180 #define	SCTP_MAX_COMBINED_HEADER_LENGTH	(60 + 12) /* Maxed out ip + sctp */
181 #define	SCTP_MAX_IP_OPTIONS_LENGTH	(60 - IP_SIMPLE_HDR_LENGTH)
182 #define	SCTP_MAX_HDR_LENGTH		60
183 
184 #define	SCTP_SECRET_LEN	16
185 
186 #define	SCTP_REFHOLD(sctp) {				\
187 	mutex_enter(&(sctp)->sctp_reflock);		\
188 	(sctp)->sctp_refcnt++;				\
189 	DTRACE_PROBE1(sctp_refhold, sctp_t, sctp);	\
190 	ASSERT((sctp)->sctp_refcnt != 0);		\
191 	mutex_exit(&(sctp)->sctp_reflock);		\
192 }
193 
194 #define	SCTP_REFRELE(sctp) {					\
195 	mutex_enter(&(sctp)->sctp_reflock);			\
196 	ASSERT((sctp)->sctp_refcnt != 0);			\
197 	if (--(sctp)->sctp_refcnt == 0) {			\
198 		DTRACE_PROBE1(sctp_refrele, sctp_t, sctp);	\
199 		mutex_exit(&(sctp)->sctp_reflock);		\
200 		CONN_DEC_REF((sctp)->sctp_connp);		\
201 	} else {						\
202 		DTRACE_PROBE1(sctp_refrele, sctp_t, sctp);	\
203 		mutex_exit(&(sctp)->sctp_reflock);		\
204 	}							\
205 }
206 
207 #define	SCTP_PRINTADDR(a)	(a).s6_addr32[0], (a).s6_addr32[1],\
208 				(a).s6_addr32[2], (a).s6_addr32[3]
209 
210 #define	CONN2SCTP(conn)	((sctp_t *)(&((conn_t *)conn)[1]))
211 
212 /*
213  * Outbound data, flags and macros for per-message, per-chunk info
214  */
215 typedef struct {
216 	int64_t		smh_ttl;		/* Time to Live */
217 	int64_t		smh_tob;		/* Time of Birth */
218 	uint32_t	smh_context;
219 	uint16_t	smh_sid;
220 	uint16_t	smh_ssn;
221 	uint32_t	smh_ppid;
222 	uint16_t	smh_flags;
223 	uint32_t	smh_msglen;
224 } sctp_msg_hdr_t;
225 
226 #define	SCTP_CHUNK_FLAG_SENT		0x01
227 #define	SCTP_CHUNK_FLAG_REXMIT		0x02
228 #define	SCTP_CHUNK_FLAG_ACKED		0x04
229 #define	SCTP_MSG_FLAG_CHUNKED		0x08
230 #define	SCTP_MSG_FLAG_ABANDONED		0x10
231 #define	SCTP_CHUNK_FLAG_ABANDONED	0x20
232 
233 #define	SCTP_CHUNK_CLEAR_FLAGS(mp) ((mp)->b_flag = 0)
234 /*
235  * If we are transmitting the chunk for the first time we assign the TSN and
236  * SSN here. The reason we assign the SSN here (as opposed to doing it in
237  * sctp_chunkify()) is that the chunk may expire, if PRSCTP is enabled, before
238  * we get a chance to send it out. If we assign the SSN in sctp_chunkify()
239  * and this happens, then we need to send a Forward TSN to the peer, which
240  * will be expecting this SSN, assuming ordered. If we assign it here we
241  * can just take out the chunk from the transmit list without having to
242  * send a Forward TSN chunk. While assigning the SSN we use (meta)->b_cont
243  * to determine if it needs a new SSN (i.e. the next SSN for the stream),
244  * since (meta)->b_cont signifies the first chunk of a message (if the message
245  * is unordered, then the SSN is 0).
246  *
247  */
248 #define	SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunkdata, meta) {		\
249 	if (!SCTP_CHUNK_ISSENT(mp)) {					\
250 		sctp_msg_hdr_t	*mhdr = (sctp_msg_hdr_t *)(meta)->b_rptr; \
251 		ASSERT(!SCTP_CHUNK_ABANDONED(mp));			\
252 		(mp)->b_flag = SCTP_CHUNK_FLAG_SENT;			\
253 		(sdc)->sdh_tsn = htonl((sctp)->sctp_ltsn++);		\
254 		if ((mhdr)->smh_flags & MSG_UNORDERED) {		\
255 			(sdc)->sdh_ssn = 0;				\
256 			SCTP_DATA_SET_UBIT(sdc);			\
257 			BUMP_LOCAL((sctp)->sctp_oudchunks);		\
258 		} else {						\
259 			BUMP_LOCAL((sctp)->sctp_odchunks);		\
260 			if ((mp) == (meta)->b_cont) {			\
261 				mhdr->smh_ssn = htons(			\
262 				    (sctp)->sctp_ostrcntrs[mhdr->smh_sid]++); \
263 			}						\
264 			(sdc)->sdh_ssn = mhdr->smh_ssn;			\
265 		}							\
266 		DTRACE_PROBE3(sctp__chunk__sent1, sctp_t *, sctp,	\
267 		    mblk_t *, mp, mblk_t *, meta);			\
268 		(sctp)->sctp_unacked += (chunkdata);			\
269 		(sctp)->sctp_unsent -= (chunkdata);			\
270 		(sctp)->sctp_frwnd -= (chunkdata);			\
271 	} else {							\
272 		if (SCTP_CHUNK_ISACKED(mp)) {				\
273 			(sctp)->sctp_unacked += (chunkdata);		\
274 		} else {						\
275 			ASSERT(SCTP_CHUNK_DEST(mp)->sf_suna >= ((chunkdata) + \
276 							sizeof (*sdc))); \
277 			SCTP_CHUNK_DEST(mp)->sf_suna -= ((chunkdata) + 	\
278 					sizeof (*sdc));			\
279 		}							\
280 		DTRACE_PROBE3(sctp__chunk__sent2, sctp_t *, sctp,	\
281 		    mblk_t *, mp, mblk_t *, meta);			\
282 		(mp)->b_flag &= ~(SCTP_CHUNK_FLAG_REXMIT |		\
283 			SCTP_CHUNK_FLAG_ACKED);				\
284 		SCTP_CHUNK_SET_SACKCNT(mp, 0);				\
285 		BUMP_LOCAL(sctp->sctp_rxtchunks);			\
286 		BUMP_LOCAL((sctp)->sctp_T3expire);			\
287 		BUMP_LOCAL((fp)->sf_T3expire);				\
288 	}								\
289 	SCTP_SET_CHUNK_DEST(mp, fp);					\
290 	(fp)->sf_suna += ((chunkdata) + sizeof (*sdc));			\
291 }
292 
293 #define	SCTP_CHUNK_ISSENT(mp)	((mp)->b_flag & SCTP_CHUNK_FLAG_SENT)
294 #define	SCTP_CHUNK_CANSEND(mp)	\
295 	(!(SCTP_CHUNK_ABANDONED(mp)) &&	\
296 	(((mp)->b_flag & (SCTP_CHUNK_FLAG_REXMIT|SCTP_CHUNK_FLAG_SENT)) != \
297 	SCTP_CHUNK_FLAG_SENT))
298 
299 #define	SCTP_CHUNK_DEST(mp)		((sctp_faddr_t *)(mp)->b_queue)
300 #define	SCTP_SET_CHUNK_DEST(mp, fp)	((mp)->b_queue = (queue_t *)fp)
301 
302 #define	SCTP_CHUNK_REXMIT(sctp, mp) {					\
303 	DTRACE_PROBE2(sctp__chunk__rexmit, sctp_t *, sctp, mblk_t *,	\
304 	    mp);							\
305 	(mp)->b_flag |= SCTP_CHUNK_FLAG_REXMIT; 			\
306 }
307 #define	SCTP_CHUNK_CLEAR_REXMIT(mp) ((mp)->b_flag &= ~SCTP_CHUNK_FLAG_REXMIT)
308 #define	SCTP_CHUNK_WANT_REXMIT(mp) ((mp)->b_flag & SCTP_CHUNK_FLAG_REXMIT)
309 
310 #define	SCTP_CHUNK_ACKED(mp) \
311 	((mp)->b_flag = (SCTP_CHUNK_FLAG_SENT|SCTP_CHUNK_FLAG_ACKED))
312 #define	SCTP_CHUNK_ISACKED(mp)	((mp)->b_flag & SCTP_CHUNK_FLAG_ACKED)
313 #define	SCTP_CHUNK_CLEAR_ACKED(sctp, mp) {				\
314 	DTRACE_PROBE2(sctp__chunk__clracked, sctp_t *, sctp, mblk_t *,	\
315 	    mp);							\
316 	(mp)->b_flag &= ~SCTP_CHUNK_FLAG_ACKED;				\
317 }
318 
319 #define	SCTP_CHUNK_SACKCNT(mp)	((intptr_t)((mp)->b_prev))
320 #define	SCTP_CHUNK_SET_SACKCNT(mp, val) ((mp)->b_prev = \
321 					(mblk_t *)(uintptr_t)(val))
322 
323 #define	SCTP_MSG_SET_CHUNKED(mp)	((mp)->b_flag |= SCTP_MSG_FLAG_CHUNKED)
324 #define	SCTP_MSG_CLEAR_CHUNKED(mp)((mp)->b_flag &= ~SCTP_MSG_FLAG_CHUNKED)
325 #define	SCTP_IS_MSG_CHUNKED(mp)	((mp)->b_flag & SCTP_MSG_FLAG_CHUNKED)
326 
327 /* For PR-SCTP */
328 #define	SCTP_ABANDON_CHUNK(mp)	((mp)->b_flag |= SCTP_CHUNK_FLAG_ABANDONED)
329 #define	SCTP_CHUNK_ABANDONED(mp) \
330 	((mp)->b_flag & SCTP_CHUNK_FLAG_ABANDONED)
331 
332 #define	SCTP_MSG_SET_ABANDONED(mp)	\
333 	((mp)->b_flag |= SCTP_MSG_FLAG_ABANDONED)
334 #define	SCTP_MSG_CLEAR_ABANDONED(mp)((mp)->b_flag &= ~SCTP_MSG_FLAG_ABANDONED)
335 #define	SCTP_IS_MSG_ABANDONED(mp)	((mp)->b_flag & SCTP_MSG_FLAG_ABANDONED)
336 
337 /*
338  * Check if a message has expired.  A message is expired if
339  *	1. It has a non-zero time to live value and has not been sent before
340  *	that time expires.
341  *	2. It is sent using PRSCTP and it has not been SACK'ed before
342  *	its lifetime expires.
343  */
344 #define	SCTP_MSG_TO_BE_ABANDONED(meta, mhdr, sctp)			     \
345 	(((!SCTP_CHUNK_ISSENT((meta)->b_cont) && (mhdr)->smh_ttl > 0) ||     \
346 	((sctp)->sctp_prsctp_aware && ((mhdr)->smh_flags & MSG_PR_SCTP))) && \
347 	((ddi_get_lbolt64() - (mhdr)->smh_tob) > (mhdr)->smh_ttl))
348 
349 /* SCTP association hash function. */
350 #define	SCTP_CONN_HASH(sctps, ports)			\
351 	((((ports) ^ ((ports) >> 16)) * 31) & 		\
352 	    ((sctps)->sctps_conn_hash_size - 1))
353 
354 /*
355  * Linked list struct to store SCTP listener association limit configuration
356  * per IP stack.  The list is stored at sctps_listener_conf in sctp_stack_t.
357  *
358  * sl_port: the listener port of this limit configuration
359  * sl_ratio: the maximum amount of memory consumed by all concurrent SCTP
360  *           connections created by a listener does not exceed 1/tl_ratio
361  *           of the total system memory.  Note that this is only an
362  *           approximation.
363  * sl_link: linked list struct
364  */
365 typedef struct sctp_listener_s {
366 	in_port_t	sl_port;
367 	uint32_t	sl_ratio;
368 	list_node_t	sl_link;
369 } sctp_listener_t;
370 
371 /*
372  * If there is a limit set on the number of association allowed per each
373  * listener, the following struct is used to store that counter.  It keeps
374  * the number of SCTP association created by a listener.  Note that this needs
375  * to be separated from the listener since the listener can go away before
376  * all the associations are gone.
377  *
378  * When the struct is allocated, slc_cnt is set to 1.  When a new association
379  * is created by the listener, slc_cnt is incremented by 1.  When an
380  * association created by the listener goes away, slc_count is decremented by
381  * 1.  When the listener itself goes away, slc_cnt is decremented  by one.
382  * The last association (or the listener) which decrements slc_cnt to zero
383  * frees the struct.
384  *
385  * slc_max is the maximum number of concurrent associations created from a
386  * listener.  It is calculated when the sctp_listen_cnt_t is allocated.
387  *
388  * slc_report_time stores the time when cmn_err() is called to report that the
389  * max has been exceeeded.  Report is done at most once every
390  * SCTP_SLC_REPORT_INTERVAL mins for a listener.
391  *
392  * slc_drop stores the number of connection attempt dropped because the
393  * limit has reached.
394  */
395 typedef struct sctp_listen_cnt_s {
396 	uint32_t	slc_max;
397 	uint32_t	slc_cnt;
398 	int64_t		slc_report_time;
399 	uint32_t	slc_drop;
400 } sctp_listen_cnt_t;
401 
402 #define	SCTP_SLC_REPORT_INTERVAL	(30 * MINUTES)
403 
404 #define	SCTP_DECR_LISTEN_CNT(sctp)					\
405 {									\
406 	ASSERT((sctp)->sctp_listen_cnt->slc_cnt > 0);			\
407 	if (atomic_dec_32_nv(&(sctp)->sctp_listen_cnt->slc_cnt) == 0) \
408 		kmem_free((sctp)->sctp_listen_cnt, sizeof (sctp_listen_cnt_t));\
409 	(sctp)->sctp_listen_cnt = NULL;					\
410 }
411 
412 /* Increment and decrement the number of associations in sctp_stack_t. */
413 #define	SCTPS_ASSOC_INC(sctps)						\
414 	atomic_inc_64(							\
415 	    (uint64_t *)&(sctps)->sctps_sc[CPU->cpu_seqid]->sctp_sc_assoc_cnt)
416 
417 #define	SCTPS_ASSOC_DEC(sctps)						\
418 	atomic_dec_64(							\
419 	    (uint64_t *)&(sctps)->sctps_sc[CPU->cpu_seqid]->sctp_sc_assoc_cnt)
420 
421 #define	SCTP_ASSOC_EST(sctps, sctp)					\
422 {									\
423 	(sctp)->sctp_state = SCTPS_ESTABLISHED;				\
424 	(sctp)->sctp_assoc_start_time = (uint32_t)LBOLT_FASTPATH64;	\
425 	SCTPS_ASSOC_INC(sctps);						\
426 }
427 
428 /*
429  * Bind hash array size and hash function.  The size must be a power
430  * of 2 and lport must be in host byte order.
431  */
432 #define	SCTP_BIND_FANOUT_SIZE	2048
433 #define	SCTP_BIND_HASH(lport)	(((lport) * 31) & (SCTP_BIND_FANOUT_SIZE - 1))
434 
435 /* options that SCTP negotiates during association establishment */
436 #define	SCTP_PRSCTP_OPTION	0x01
437 
438 /*
439  * Listener hash array size and hash function.  The size must be a power
440  * of 2 and lport must be in host byte order.
441  */
442 #define	SCTP_LISTEN_FANOUT_SIZE	512
443 #define	SCTP_LISTEN_HASH(lport) (((lport) * 31) & (SCTP_LISTEN_FANOUT_SIZE - 1))
444 
445 typedef struct sctp_tf_s {
446 	struct sctp_s	*tf_sctp;
447 	kmutex_t	tf_lock;
448 } sctp_tf_t;
449 
450 /* Round up the value to the nearest mss. */
451 #define	MSS_ROUNDUP(value, mss)		((((value) - 1) / (mss) + 1) * (mss))
452 
453 extern sin_t	sctp_sin_null;	/* Zero address for quick clears */
454 extern sin6_t	sctp_sin6_null;	/* Zero address for quick clears */
455 
456 #define	SCTP_IS_DETACHED(sctp)		((sctp)->sctp_detached)
457 
458 /* Data structure used to track received TSNs */
459 typedef struct sctp_set_s {
460 	struct sctp_set_s *next;
461 	struct sctp_set_s *prev;
462 	uint32_t begin;
463 	uint32_t end;
464 } sctp_set_t;
465 
466 /* Data structure used to track TSNs for PR-SCTP */
467 typedef struct sctp_ftsn_set_s {
468 	struct sctp_ftsn_set_s *next;
469 	ftsn_entry_t	ftsn_entries;
470 } sctp_ftsn_set_t;
471 
472 /* Data structure used to track incoming SCTP streams */
473 typedef struct sctp_instr_s {
474 	mblk_t		*istr_msgs;
475 	int		istr_nmsgs;
476 	uint16_t	nextseq;
477 	struct sctp_s	*sctp;
478 	mblk_t		*istr_reass;
479 } sctp_instr_t;
480 
481 /* Reassembly data structure (per-stream) */
482 typedef struct sctp_reass_s {
483 	uint16_t	sr_ssn;
484 	uint16_t	sr_needed;
485 	uint16_t	sr_got;
486 	uint16_t	sr_msglen;	/* len of consecutive fragments */
487 					/* from the begining (B-bit) */
488 	mblk_t		*sr_tail;
489 	boolean_t	sr_hasBchunk;	/* If the fragment list begins with */
490 					/* a B-bit set chunk */
491 	uint32_t	sr_nexttsn;	/* TSN of the next fragment we */
492 					/* are expecting */
493 	boolean_t	sr_partial_delivered;
494 } sctp_reass_t;
495 
496 /* debugging */
497 #undef	dprint
498 #ifdef DEBUG
499 extern int sctpdebug;
500 #define	dprint(level, args)	{ if (sctpdebug > (level)) printf args; }
501 #else
502 #define	dprint(level, args) {}
503 #endif
504 
505 
506 /* Peer address tracking */
507 
508 /*
509  * States for peer addresses
510  *
511  * SCTP_FADDRS_UNCONFIRMED: we have not communicated with this peer address
512  *     before, mark it as unconfirmed so that we will not send data to it.
513  *     All addresses initially are in unconfirmed state and required
514  *     validation.  SCTP sends a heartbeat to each of them and when it gets
515  *     back a heartbeat ACK, the address will be marked as alive.  This
516  *     validation fixes a security issue with multihoming.  If an attacker
517  *     establishes an association with us and tells us that it has addresses
518  *     belonging to another host A, this will prevent A from communicating
519  *     with us.  This is fixed by peer address validation.  In the above case,
520  *     A will respond with an abort.
521  *
522  * SCTP_FADDRS_ALIVE: this peer address is alive and we can communicate with
523  *     it with no problem.
524  *
525  * SCTP_FADDRS_DOWN: we have exceeded the retransmission limit to this
526  *     peer address.  Once an address is marked down, we will only send
527  *     a heartbeat to it every hb_interval in case it becomes alive now.
528  *
529  * SCTP_FADDRS_UNREACH: there is no suitable source address to send to
530  *     this peer address.  For example, the peer address is v6 but we only
531  *     have v4 addresses.  It is marked unreachable until there is an
532  *     address configuration change.  At that time, mark these addresses
533  *     as unconfirmed and try again to see if those unreachable addresses
534  *     are OK as we may have more source addresses.
535  */
536 typedef enum {
537 	SCTP_FADDRS_UNREACH,
538 	SCTP_FADDRS_DOWN,
539 	SCTP_FADDRS_ALIVE,
540 	SCTP_FADDRS_UNCONFIRMED
541 } faddr_state_t;
542 
543 typedef struct sctp_faddr_s {
544 	struct sctp_faddr_s *sf_next;
545 	faddr_state_t	sf_state;
546 
547 	in6_addr_t	sf_faddr;
548 	in6_addr_t	sf_saddr;
549 
550 	int64_t		sf_hb_expiry;	/* time to retransmit heartbeat */
551 	uint32_t	sf_hb_interval;	/* the heartbeat interval */
552 
553 	int		sf_rto;		/* RTO in tick */
554 	int		sf_srtt;	/* Smoothed RTT in tick */
555 	int		sf_rttvar;	/* RTT variance in tick */
556 	uint32_t	sf_rtt_updates;
557 	int		sf_strikes;
558 	int		sf_max_retr;
559 	uint32_t	sf_pmss;
560 	uint32_t	sf_cwnd;
561 	uint32_t	sf_ssthresh;
562 	uint32_t	sf_suna;	/* sent - unack'ed */
563 	uint32_t	sf_pba;		/* partial bytes acked */
564 	uint32_t	sf_acked;
565 	int64_t		sf_lastactive;
566 	mblk_t		*sf_timer_mp;	/* retransmission timer control */
567 	uint32_t
568 			sf_hb_pending : 1,
569 			sf_timer_running : 1,
570 			sf_df : 1,
571 			sf_pmtu_discovered : 1,
572 
573 			sf_rc_timer_running : 1,
574 			sf_isv4 : 1,
575 			sf_hb_enabled : 1;
576 
577 	mblk_t		*sf_rc_timer_mp; /* reliable control chunk timer */
578 	ip_xmit_attr_t	*sf_ixa;	/* Transmit attributes */
579 	uint32_t	sf_T3expire;	/* # of times T3 timer expired */
580 
581 	uint64_t	sf_hb_secret;	/* per addr "secret" in heartbeat */
582 	uint32_t	sf_rxt_unacked;	/* # unack'ed retransmitted bytes */
583 } sctp_faddr_t;
584 
585 /* Flags to indicate supported address type in the PARM_SUP_ADDRS. */
586 #define	PARM_SUPP_V6	0x1
587 #define	PARM_SUPP_V4	0x2
588 
589 /*
590  * Set heartbeat interval plus jitter.  The jitter is supposed to be random,
591  * up to +/- 50% of the RTO.  We use gethrtime() here for  performance reason
592  * as the jitter does not really need to be "very" random.
593  */
594 #define	SET_HB_INTVL(fp)					\
595 	((fp)->sf_hb_interval + (fp)->sf_rto + ((fp)->sf_rto >> 1) -	\
596 	(uint_t)gethrtime() % (fp)->sf_rto)
597 
598 #define	SCTP_IPIF_HASH	16
599 
600 typedef	struct	sctp_ipif_hash_s {
601 	list_t		sctp_ipif_list;
602 	int		ipif_count;
603 	krwlock_t	ipif_hash_lock;
604 } sctp_ipif_hash_t;
605 
606 
607 /*
608  * Initialize cwnd according to RFC 3390.  def_max_init_cwnd is
609  * either sctp_slow_start_initial or sctp_slow_start_after idle
610  * depending on the caller.
611  */
612 #define	SET_CWND(fp, mss, def_max_init_cwnd)				\
613 {									\
614 	(fp)->sf_cwnd = MIN(def_max_init_cwnd * (mss),			\
615 	    MIN(4 * (mss), MAX(2 * (mss), 4380 / (mss) * (mss))));	\
616 }
617 
618 
619 struct sctp_s;
620 
621 /*
622  * Control structure for each open SCTP stream,
623  * defined only within the kernel or for a kmem user.
624  * NOTE: sctp_reinit_values MUST have a line for each field in this structure!
625  */
626 #if (defined(_KERNEL) || defined(_KMEMUSER))
627 
628 typedef struct sctp_s {
629 
630 	/*
631 	 * The following is shared with (and duplicated) in IP, so if you
632 	 * make changes, make sure you also change things in ip_sctp.c.
633 	 */
634 	struct sctp_s	*sctp_conn_hash_next;
635 	struct sctp_s	*sctp_conn_hash_prev;
636 
637 	struct sctp_s	*sctp_listen_hash_next;
638 	struct sctp_s	*sctp_listen_hash_prev;
639 
640 	sctp_tf_t	*sctp_listen_tfp;	/* Ptr to tf */
641 	sctp_tf_t	*sctp_conn_tfp;		/* Ptr to tf */
642 
643 	/* Global list of sctp */
644 	list_node_t	sctp_list;
645 
646 	sctp_faddr_t		*sctp_faddrs;
647 	int			sctp_nfaddrs;
648 	sctp_ipif_hash_t	sctp_saddrs[SCTP_IPIF_HASH];
649 	int			sctp_nsaddrs;
650 
651 	kmutex_t	sctp_lock;
652 	kcondvar_t	sctp_cv;
653 	boolean_t	sctp_running;
654 
655 #define	sctp_ulpd	sctp_connp->conn_upper_handle
656 #define	sctp_upcalls	sctp_connp->conn_upcalls
657 
658 #define	sctp_ulp_newconn	sctp_upcalls->su_newconn
659 #define	sctp_ulp_connected	sctp_upcalls->su_connected
660 #define	sctp_ulp_disconnected	sctp_upcalls->su_disconnected
661 #define	sctp_ulp_opctl		sctp_upcalls->su_opctl
662 #define	sctp_ulp_recv		sctp_upcalls->su_recv
663 #define	sctp_ulp_txq_full	sctp_upcalls->su_txq_full
664 #define	sctp_ulp_prop		sctp_upcalls->su_set_proto_props
665 
666 	int32_t		sctp_state;
667 
668 	conn_t		*sctp_connp;		/* conn_t stuff */
669 	sctp_stack_t	*sctp_sctps;
670 
671 	/* Peer address tracking */
672 	sctp_faddr_t	*sctp_lastfaddr;	/* last faddr in list */
673 	sctp_faddr_t	*sctp_primary;		/* primary faddr */
674 	sctp_faddr_t	*sctp_current;		/* current faddr */
675 	sctp_faddr_t	*sctp_lastdata;		/* last data seen from this */
676 
677 	/* Outbound data tracking */
678 	mblk_t		*sctp_xmit_head;
679 	mblk_t		*sctp_xmit_tail;
680 	mblk_t		*sctp_xmit_unsent;
681 	mblk_t		*sctp_xmit_unsent_tail;
682 	mblk_t		*sctp_xmit_unacked;
683 
684 	int32_t		sctp_unacked;		/* # of unacked bytes */
685 	int32_t		sctp_unsent;		/* # of unsent bytes in hand */
686 
687 	uint32_t	sctp_ltsn;		/* Local instance TSN */
688 	uint32_t	sctp_lastack_rxd;	/* Last rx'd cumtsn */
689 	uint32_t	sctp_recovery_tsn;	/* Exit from fast recovery */
690 	uint32_t	sctp_adv_pap;		/* Adv. Peer Ack Point */
691 
692 	uint16_t	sctp_num_ostr;
693 	uint16_t	*sctp_ostrcntrs;
694 
695 	mblk_t		*sctp_pad_mp;		/* pad unaligned data chunks */
696 
697 	/* sendmsg() default parameters */
698 	uint16_t	sctp_def_stream;	/* default stream id */
699 	uint16_t	sctp_def_flags;		/* default xmit flags */
700 	uint32_t	sctp_def_ppid;		/* default payload id */
701 	uint32_t	sctp_def_context;	/* default context */
702 	uint32_t	sctp_def_timetolive;	/* default msg TTL */
703 
704 	/* Inbound data tracking */
705 	sctp_set_t	*sctp_sack_info;	/* Sack tracking */
706 	mblk_t		*sctp_ack_mp;		/* Delayed ACK timer block */
707 	sctp_instr_t	*sctp_instr;		/* Instream trackers */
708 	mblk_t		*sctp_uo_frags;		/* Un-ordered msg. fragments */
709 	uint32_t	sctp_ftsn;		/* Peer's TSN */
710 	uint32_t	sctp_lastacked;		/* last cumtsn SACKd */
711 	uint16_t	sctp_num_istr;		/* No. of instreams */
712 	int32_t		sctp_istr_nmsgs;	/* No. of chunks in instreams */
713 	int32_t		sctp_sack_gaps;		/* No. of received gaps */
714 	int32_t		sctp_sack_toggle;	/* SACK every other pkt */
715 
716 	/* RTT calculation */
717 	uint32_t	sctp_rtt_tsn;
718 	int64_t		sctp_out_time;
719 
720 	/* Stats can be reset by snmp users kstat, netstat and snmp agents */
721 	uint64_t	sctp_opkts;		/* sent pkts */
722 	uint64_t	sctp_obchunks;		/* sent control chunks */
723 	uint64_t	sctp_odchunks;		/* sent ordered data chunks */
724 	uint64_t	sctp_oudchunks;		/* sent unord data chunks */
725 	uint64_t	sctp_rxtchunks;		/* retransmitted chunks */
726 	uint64_t	sctp_ipkts;		/* recv pkts */
727 	uint64_t	sctp_ibchunks;		/* recv control chunks */
728 	uint64_t	sctp_idchunks;		/* recv ordered data chunks */
729 	uint64_t	sctp_iudchunks;		/* recv unord data chunks */
730 	uint64_t	sctp_fragdmsgs;
731 	uint64_t	sctp_reassmsgs;
732 	uint32_t	sctp_T1expire;		/* # of times T1timer expired */
733 	uint32_t	sctp_T2expire;		/* # of times T2timer expired */
734 	uint32_t	sctp_T3expire;		/* # of times T3timer expired */
735 	uint32_t	sctp_assoc_start_time;	/* time when assoc was est. */
736 
737 	uint32_t	sctp_frwnd;		/* Peer RWND */
738 	uint32_t	sctp_cwnd_max;
739 
740 	/* Inbound flow control */
741 	int32_t		sctp_rwnd;		/* Current receive window */
742 	int32_t		sctp_arwnd;		/* Last advertised window */
743 	int32_t		sctp_rxqueued;		/* No. of bytes in RX q's */
744 	int32_t		sctp_ulp_rxqueued;	/* Data in ULP */
745 
746 	/* Pre-initialized composite headers */
747 	uchar_t		*sctp_iphc;	/* v4 sctp/ip hdr template buffer */
748 	uchar_t		*sctp_iphc6;	/* v6 sctp/ip hdr template buffer */
749 
750 	int32_t		sctp_iphc_len;	/* actual allocated v4 buffer size */
751 	int32_t		sctp_iphc6_len;	/* actual allocated v6 buffer size */
752 
753 	int32_t		sctp_hdr_len;	/* len of combined SCTP/IP v4 hdr */
754 	int32_t		sctp_hdr6_len;	/* len of combined SCTP/IP v6 hdr */
755 
756 	ipha_t		*sctp_ipha;	/* IPv4 header in the buffer */
757 	ip6_t		*sctp_ip6h;	/* IPv6 header in the buffer */
758 
759 	int32_t		sctp_ip_hdr_len; /* Byte len of our current v4 hdr */
760 	int32_t		sctp_ip_hdr6_len; /* Byte len of our current v6 hdr */
761 
762 	sctp_hdr_t	*sctp_sctph;	/* sctp header in combined v4 hdr */
763 	sctp_hdr_t	*sctp_sctph6;	/* sctp header in combined v6 hdr */
764 
765 	uint32_t	sctp_lvtag;	/* local SCTP instance verf tag */
766 	uint32_t	sctp_fvtag;	/* Peer's SCTP verf tag */
767 
768 	/* Path MTU Discovery */
769 	int64_t		sctp_last_mtu_probe;
770 	clock_t		sctp_mtu_probe_intvl;
771 	uint32_t	sctp_mss;	/* Max send size (not TCP MSS!) */
772 
773 	/* structs sctp_bits, sctp_events are for clearing all bits at once */
774 	struct {
775 		uint32_t
776 
777 		sctp_understands_asconf : 1, /* Peer handles ASCONF chunks */
778 		sctp_cchunk_pend : 1,	/* Control chunk in flight. */
779 		sctp_lingering : 1,	/* Lingering in close */
780 		sctp_loopback: 1,	/* src and dst are the same machine */
781 
782 		sctp_force_sack : 1,
783 		sctp_ack_timer_running: 1,	/* Delayed ACK timer running */
784 		sctp_hwcksum : 1,	/* The NIC is capable of hwcksum */
785 		sctp_understands_addip : 1,
786 
787 		sctp_bound_to_all : 1,
788 		sctp_cansleep : 1,	/* itf routines can sleep */
789 		sctp_detached : 1,	/* If we're detached from a stream */
790 		sctp_send_adaptation : 1,	/* send adaptation layer ind */
791 
792 		sctp_recv_adaptation : 1,	/* recv adaptation layer ind */
793 		sctp_ndelay : 1,	/* turn off Nagle */
794 		sctp_condemned : 1,	/* this sctp is about to disappear */
795 		sctp_chk_fast_rexmit : 1, /* check for fast rexmit message */
796 
797 		sctp_prsctp_aware : 1,	/* is peer PR-SCTP aware? */
798 		sctp_linklocal : 1,	/* is linklocal assoc. */
799 		sctp_rexmitting : 1,	/* SCTP is retransmitting */
800 		sctp_zero_win_probe : 1,	/* doing zero win probe */
801 
802 		sctp_txq_full : 1,	/* the tx queue is full */
803 		sctp_ulp_discon_done : 1,	/* ulp_disconnecting done */
804 		sctp_flowctrld : 1,	/* upper layer flow controlled */
805 		sctp_dummy : 5;
806 	} sctp_bits;
807 	struct {
808 		uint32_t
809 
810 		sctp_recvsndrcvinfo : 1,
811 		sctp_recvassocevnt : 1,
812 		sctp_recvpathevnt : 1,
813 		sctp_recvsendfailevnt : 1,
814 
815 		sctp_recvpeererr : 1,
816 		sctp_recvshutdownevnt : 1,
817 		sctp_recvpdevnt : 1,
818 		sctp_recvalevnt : 1;
819 	} sctp_events;
820 #define	sctp_priv_stream sctp_bits.sctp_priv_stream
821 #define	sctp_understands_asconf sctp_bits.sctp_understands_asconf
822 #define	sctp_cchunk_pend sctp_bits.sctp_cchunk_pend
823 #define	sctp_lingering sctp_bits.sctp_lingering
824 #define	sctp_loopback sctp_bits.sctp_loopback
825 #define	sctp_force_sack sctp_bits.sctp_force_sack
826 #define	sctp_ack_timer_running sctp_bits.sctp_ack_timer_running
827 #define	sctp_hwcksum sctp_bits.sctp_hwcksum
828 #define	sctp_understands_addip sctp_bits.sctp_understands_addip
829 #define	sctp_bound_to_all sctp_bits.sctp_bound_to_all
830 #define	sctp_cansleep sctp_bits.sctp_cansleep
831 #define	sctp_detached sctp_bits.sctp_detached
832 #define	sctp_send_adaptation sctp_bits.sctp_send_adaptation
833 #define	sctp_recv_adaptation sctp_bits.sctp_recv_adaptation
834 #define	sctp_ndelay sctp_bits.sctp_ndelay
835 #define	sctp_condemned sctp_bits.sctp_condemned
836 #define	sctp_chk_fast_rexmit sctp_bits.sctp_chk_fast_rexmit
837 #define	sctp_prsctp_aware sctp_bits.sctp_prsctp_aware
838 #define	sctp_linklocal sctp_bits.sctp_linklocal
839 #define	sctp_rexmitting sctp_bits.sctp_rexmitting
840 #define	sctp_zero_win_probe sctp_bits.sctp_zero_win_probe
841 #define	sctp_txq_full sctp_bits.sctp_txq_full
842 #define	sctp_ulp_discon_done sctp_bits.sctp_ulp_discon_done
843 #define	sctp_flowctrld sctp_bits.sctp_flowctrld
844 
845 #define	sctp_recvsndrcvinfo sctp_events.sctp_recvsndrcvinfo
846 #define	sctp_recvassocevnt sctp_events.sctp_recvassocevnt
847 #define	sctp_recvpathevnt sctp_events.sctp_recvpathevnt
848 #define	sctp_recvsendfailevnt sctp_events.sctp_recvsendfailevnt
849 #define	sctp_recvpeererr sctp_events.sctp_recvpeererr
850 #define	sctp_recvshutdownevnt sctp_events.sctp_recvshutdownevnt
851 #define	sctp_recvpdevnt sctp_events.sctp_recvpdevnt
852 #define	sctp_recvalevnt sctp_events.sctp_recvalevnt
853 
854 	/* Retransmit info */
855 	mblk_t		*sctp_cookie_mp; /* cookie chunk, if rxt needed */
856 	int32_t		sctp_strikes;	/* Total number of assoc strikes */
857 	int32_t		sctp_max_init_rxt;
858 	int32_t		sctp_pa_max_rxt; /* Max per-assoc retransmit cnt */
859 	int32_t		sctp_pp_max_rxt; /* Max per-path retransmit cnt */
860 	uint32_t	sctp_rto_max;
861 	uint32_t	sctp_rto_max_init;
862 	uint32_t	sctp_rto_min;
863 	uint32_t	sctp_rto_initial;
864 
865 	int64_t		sctp_last_secret_update;
866 	uint8_t		sctp_secret[SCTP_SECRET_LEN]; /* for cookie auth */
867 	uint8_t		sctp_old_secret[SCTP_SECRET_LEN];
868 	uint32_t	sctp_cookie_lifetime;	/* cookie lifetime in tick */
869 
870 	/* Bind hash tables */
871 	kmutex_t	*sctp_bind_lockp;	/* Ptr to tf_lock */
872 	struct sctp_s	*sctp_bind_hash;
873 	struct sctp_s **sctp_ptpbhn;
874 
875 	/* Shutdown / cleanup */
876 	sctp_faddr_t	*sctp_shutdown_faddr;	/* rotate faddr during shutd */
877 	int32_t		sctp_client_errno;	/* How the client screwed up */
878 	kmutex_t	sctp_reflock;	/* Protects sctp_refcnt & timer mp */
879 	ushort_t	sctp_refcnt;	/* No. of pending upstream msg */
880 	mblk_t		*sctp_timer_mp;	/* List of fired timers. */
881 
882 	mblk_t		*sctp_heartbeat_mp; /* Timer block for heartbeats */
883 	uint32_t	sctp_hb_interval; /* Default hb_interval */
884 
885 	int32_t		sctp_autoclose;	/* Auto disconnect in ticks */
886 	int64_t		sctp_active;	/* Last time data/sack on this conn */
887 	uint32_t	sctp_tx_adaptation_code; /* TX adaptation code */
888 	uint32_t	sctp_rx_adaptation_code; /* RX adaptation code */
889 
890 	/* Reliable control chunks */
891 	mblk_t		*sctp_cxmit_list; /* Xmit list for control chunks */
892 	uint32_t	sctp_lcsn;	/* Our serial number */
893 	uint32_t	sctp_fcsn;	/* Peer serial number */
894 
895 	/* Per association receive queue */
896 	kmutex_t	sctp_recvq_lock;
897 	mblk_t		*sctp_recvq;
898 	mblk_t		*sctp_recvq_tail;
899 	taskq_t		*sctp_recvq_tq;
900 
901 	/* IPv6 ancillary data */
902 	uint_t		sctp_recvifindex;	/* last rcvd IPV6_RCVPKTINFO */
903 	uint_t		sctp_recvhops;		/*  " IPV6_RECVHOPLIMIT */
904 	uint_t		sctp_recvtclass;	/*  " IPV6_RECVTCLASS */
905 	ip6_hbh_t	*sctp_hopopts;		/*  " IPV6_RECVHOPOPTS */
906 	ip6_dest_t	*sctp_dstopts;		/*  " IPV6_RECVDSTOPTS */
907 	ip6_dest_t	*sctp_rthdrdstopts;	/*  " IPV6_RECVRTHDRDSTOPTS */
908 	ip6_rthdr_t	*sctp_rthdr;		/*  " IPV6_RECVRTHDR */
909 	uint_t		sctp_hopoptslen;
910 	uint_t		sctp_dstoptslen;
911 	uint_t		sctp_rthdrdstoptslen;
912 	uint_t		sctp_rthdrlen;
913 
914 	/* Stats */
915 	uint64_t	sctp_msgcount;
916 	uint64_t	sctp_prsctpdrop;
917 
918 	uint_t		sctp_v4label_len;	/* length of cached v4 label */
919 	uint_t		sctp_v6label_len;	/* length of cached v6 label */
920 	uint32_t	sctp_rxt_nxttsn;	/* Next TSN to be rexmitted */
921 	uint32_t	sctp_rxt_maxtsn;	/* Max TSN sent at time out */
922 
923 	int		sctp_pd_point;		/* Partial delivery point */
924 	mblk_t		*sctp_err_chunks;	/* Error chunks */
925 	uint32_t	sctp_err_len;		/* Total error chunks length */
926 
927 	/* additional source data for per endpoint association statistics */
928 	uint64_t	sctp_outseqtsns;	/* TSN rx > expected TSN */
929 	uint64_t	sctp_osacks;		/* total sacks sent */
930 	uint64_t	sctp_isacks;		/* total sacks received */
931 	uint64_t	sctp_idupchunks;	/* rx dups, ord or unord */
932 	uint64_t	sctp_gapcnt;		/* total gap acks rx */
933 	/*
934 	 * Add the current data from the counters which are reset by snmp
935 	 * to these cumulative counters to use in per endpoint statistics.
936 	 */
937 	uint64_t	sctp_cum_obchunks;	/* sent control chunks */
938 	uint64_t	sctp_cum_odchunks;	/* sent ordered data chunks */
939 	uint64_t	sctp_cum_oudchunks;	/* sent unord data chunks */
940 	uint64_t	sctp_cum_rxtchunks;	/* retransmitted chunks */
941 	uint64_t	sctp_cum_ibchunks;	/* recv control chunks */
942 	uint64_t	sctp_cum_idchunks;	/* recv ordered data chunks */
943 	uint64_t	sctp_cum_iudchunks;	/* recv unord data chunks */
944 
945 	/*
946 	 * When non-zero, this is the maximum observed RTO since assoc stats
947 	 * were last requested. When zero, no RTO update has occurred since
948 	 * the previous user request for stats on this endpoint.
949 	 */
950 	int	sctp_maxrto;
951 	/*
952 	 * The stored value of sctp_maxrto passed to user during the previous
953 	 * user request for stats on this endpoint.
954 	 */
955 	int	sctp_prev_maxrto;
956 
957 	/* For association counting. */
958 	sctp_listen_cnt_t	*sctp_listen_cnt;
959 } sctp_t;
960 
961 #define	SCTP_TXQ_LEN(sctp)	((sctp)->sctp_unsent + (sctp)->sctp_unacked)
962 #define	SCTP_TXQ_UPDATE(sctp)					\
963 	if ((sctp)->sctp_txq_full && SCTP_TXQ_LEN(sctp) <=	\
964 	    (sctp)->sctp_connp->conn_sndlowat) {		\
965 		(sctp)->sctp_txq_full = 0;			\
966 		(sctp)->sctp_ulp_txq_full((sctp)->sctp_ulpd,	\
967 		    B_FALSE);					\
968 	}
969 
970 #endif	/* (defined(_KERNEL) || defined(_KMEMUSER)) */
971 
972 extern void	sctp_ack_timer(sctp_t *);
973 extern size_t	sctp_adaptation_code_param(sctp_t *, uchar_t *);
974 extern void	sctp_adaptation_event(sctp_t *);
975 extern void	sctp_add_err(sctp_t *, uint16_t, void *, size_t,
976 		    sctp_faddr_t *);
977 extern int	sctp_add_faddr(sctp_t *, in6_addr_t *, int, boolean_t);
978 extern boolean_t sctp_add_ftsn_set(sctp_ftsn_set_t **, sctp_faddr_t *, mblk_t *,
979 		    uint_t *, uint32_t *);
980 extern void	sctp_add_recvq(sctp_t *, mblk_t *, boolean_t,
981 		    ip_recv_attr_t *);
982 extern void	sctp_add_unrec_parm(sctp_parm_hdr_t *, mblk_t **, boolean_t);
983 extern size_t	sctp_addr_params(sctp_t *, int, uchar_t *, boolean_t);
984 extern mblk_t	*sctp_add_proto_hdr(sctp_t *, sctp_faddr_t *, mblk_t *, int,
985 		    int *);
986 extern void	sctp_addr_req(sctp_t *, mblk_t *);
987 extern sctp_t	*sctp_addrlist2sctp(mblk_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
988 		    zoneid_t, sctp_stack_t *);
989 extern void	sctp_check_adv_ack_pt(sctp_t *, mblk_t *, mblk_t *);
990 extern void	sctp_assoc_event(sctp_t *, uint16_t, uint16_t,
991 		    sctp_chunk_hdr_t *);
992 
993 extern void	sctp_bind_hash_insert(sctp_tf_t *, sctp_t *, int);
994 extern void	sctp_bind_hash_remove(sctp_t *);
995 extern int	sctp_bindi(sctp_t *, in_port_t, boolean_t, int, in_port_t *);
996 extern int	sctp_bind_add(sctp_t *, const void *, uint32_t, boolean_t,
997 		    in_port_t);
998 extern int	sctp_bind_del(sctp_t *, const void *, uint32_t, boolean_t);
999 extern int	sctp_build_hdrs(sctp_t *, int);
1000 
1001 extern int	sctp_check_abandoned_msg(sctp_t *, mblk_t *);
1002 extern void	sctp_clean_death(sctp_t *, int);
1003 extern void	sctp_close_eager(sctp_t *);
1004 extern int	sctp_compare_faddrsets(sctp_faddr_t *, sctp_faddr_t *);
1005 extern void	sctp_congest_reset(sctp_t *);
1006 extern void	sctp_conn_hash_insert(sctp_tf_t *, sctp_t *, int);
1007 extern void	sctp_conn_hash_remove(sctp_t *);
1008 extern void	sctp_conn_init(conn_t *);
1009 extern sctp_t	*sctp_conn_match(in6_addr_t **, uint32_t, in6_addr_t *,
1010 		    uint32_t, zoneid_t, iaflags_t, sctp_stack_t *);
1011 extern void	sctp_conn_reclaim(void *);
1012 extern sctp_t	*sctp_conn_request(sctp_t *, mblk_t *, uint_t, uint_t,
1013 		    sctp_init_chunk_t *, ip_recv_attr_t *);
1014 extern uint32_t	sctp_cumack(sctp_t *, uint32_t, mblk_t **);
1015 extern sctp_t	*sctp_create_eager(sctp_t *);
1016 
1017 extern void	sctp_dispatch_rput(queue_t *, sctp_t *, sctp_hdr_t *, mblk_t *,
1018 		    uint_t, uint_t, in6_addr_t);
1019 extern char	*sctp_display(sctp_t *, char *);
1020 extern void	sctp_display_all(sctp_stack_t *);
1021 
1022 extern void	sctp_error_event(sctp_t *, sctp_chunk_hdr_t *, boolean_t);
1023 
1024 extern void	sctp_faddr_alive(sctp_t *, sctp_faddr_t *);
1025 extern int	sctp_faddr_dead(sctp_t *, sctp_faddr_t *, int);
1026 extern void	sctp_faddr_fini(void);
1027 extern void	sctp_faddr_init(void);
1028 extern void	sctp_fast_rexmit(sctp_t *);
1029 extern void	sctp_fill_sack(sctp_t *, unsigned char *, int);
1030 extern uint32_t sctp_find_listener_conf(sctp_stack_t *, in_port_t);
1031 extern void	sctp_free_faddr_timers(sctp_t *);
1032 extern void	sctp_free_ftsn_set(sctp_ftsn_set_t *);
1033 extern void	sctp_free_msg(mblk_t *);
1034 extern void	sctp_free_reass(sctp_instr_t *);
1035 extern void	sctp_free_set(sctp_set_t *);
1036 extern void	sctp_ftsn_sets_fini(void);
1037 extern void	sctp_ftsn_sets_init(void);
1038 
1039 extern int	sctp_get_addrlist(sctp_t *, const void *, uint32_t *,
1040 		    uchar_t **, int *, size_t *);
1041 extern int	sctp_get_addrparams(sctp_t *, sctp_t *, mblk_t *,
1042 		    sctp_chunk_hdr_t *, uint_t *);
1043 extern void	sctp_get_dest(sctp_t *, sctp_faddr_t *);
1044 extern void	sctp_get_faddr_list(sctp_t *, uchar_t *, size_t);
1045 extern mblk_t	*sctp_get_first_sent(sctp_t *);
1046 extern mblk_t	*sctp_get_msg_to_send(sctp_t *, mblk_t **, mblk_t *, int  *,
1047 		    int32_t, uint32_t, sctp_faddr_t *);
1048 extern void	sctp_get_saddr_list(sctp_t *, uchar_t *, size_t);
1049 
1050 extern int	sctp_handle_error(sctp_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
1051 		    mblk_t *, ip_recv_attr_t *);
1052 extern void	sctp_hash_destroy(sctp_stack_t *);
1053 extern void	sctp_hash_init(sctp_stack_t *);
1054 extern void	sctp_heartbeat_timer(sctp_t *);
1055 
1056 extern void	sctp_icmp_error(sctp_t *, mblk_t *);
1057 extern void	sctp_inc_taskq(sctp_stack_t *);
1058 extern void	sctp_info_req(sctp_t *, mblk_t *);
1059 extern mblk_t	*sctp_init_mp(sctp_t *, sctp_faddr_t *);
1060 extern boolean_t sctp_initialize_params(sctp_t *, sctp_init_chunk_t *,
1061 		    sctp_init_chunk_t *);
1062 extern uint32_t	sctp_init2vtag(sctp_chunk_hdr_t *);
1063 extern void	sctp_intf_event(sctp_t *, in6_addr_t, int, int);
1064 extern void	sctp_input_data(sctp_t *, mblk_t *, ip_recv_attr_t *);
1065 extern void	sctp_instream_cleanup(sctp_t *, boolean_t);
1066 extern boolean_t sctp_is_a_faddr_clean(sctp_t *);
1067 
1068 extern void	*sctp_kstat_init(netstackid_t);
1069 extern void	sctp_kstat_fini(netstackid_t, kstat_t *);
1070 extern void	*sctp_kstat2_init(netstackid_t);
1071 extern void	sctp_kstat2_fini(netstackid_t, kstat_t *);
1072 
1073 extern ssize_t	sctp_link_abort(mblk_t *, uint16_t, char *, size_t, int,
1074 		    boolean_t);
1075 extern void	sctp_listen_hash_insert(sctp_tf_t *, sctp_t *);
1076 extern void	sctp_listen_hash_remove(sctp_t *);
1077 extern void	sctp_listener_conf_cleanup(sctp_stack_t *);
1078 extern sctp_t	*sctp_lookup(sctp_t *, in6_addr_t *, sctp_tf_t *, uint32_t *,
1079 		    int);
1080 extern sctp_faddr_t *sctp_lookup_faddr(sctp_t *, in6_addr_t *);
1081 
1082 extern mblk_t	*sctp_make_err(sctp_t *, uint16_t, void *, size_t);
1083 extern mblk_t	*sctp_make_ftsn_chunk(sctp_t *, sctp_faddr_t *,
1084 		    sctp_ftsn_set_t *, uint_t, uint32_t);
1085 extern void	sctp_make_ftsns(sctp_t *, mblk_t *, mblk_t *, mblk_t **,
1086 		    sctp_faddr_t *, uint32_t *);
1087 extern mblk_t	*sctp_make_mp(sctp_t *, sctp_faddr_t *, int);
1088 extern mblk_t	*sctp_make_sack(sctp_t *, sctp_faddr_t *, mblk_t *);
1089 extern void	sctp_maxpsz_set(sctp_t *);
1090 extern void	sctp_move_faddr_timers(queue_t *, sctp_t *);
1091 
1092 extern sctp_parm_hdr_t *sctp_next_parm(sctp_parm_hdr_t *, ssize_t *);
1093 
1094 extern void	sctp_ootb_shutdown_ack(mblk_t *, uint_t, ip_recv_attr_t *,
1095 		    ip_stack_t *);
1096 extern size_t	sctp_options_param(const sctp_t *, void *, int);
1097 extern size_t	sctp_options_param_len(const sctp_t *, int);
1098 extern void	sctp_output(sctp_t *, uint_t);
1099 
1100 extern void	sctp_partial_delivery_event(sctp_t *);
1101 extern int	sctp_process_cookie(sctp_t *, sctp_chunk_hdr_t *, mblk_t *,
1102 		    sctp_init_chunk_t **, sctp_hdr_t *, int *, in6_addr_t *,
1103 		    ip_recv_attr_t *);
1104 extern void	sctp_process_err(sctp_t *);
1105 extern void	sctp_process_heartbeat(sctp_t *, sctp_chunk_hdr_t *);
1106 extern void	sctp_process_timer(sctp_t *);
1107 
1108 extern void	sctp_redo_faddr_srcs(sctp_t *);
1109 extern void	sctp_regift_xmitlist(sctp_t *);
1110 extern void	sctp_return_heartbeat(sctp_t *, sctp_chunk_hdr_t *, mblk_t *);
1111 extern void	sctp_rexmit(sctp_t *, sctp_faddr_t *);
1112 extern mblk_t	*sctp_rexmit_packet(sctp_t *, mblk_t **, mblk_t **,
1113 		    sctp_faddr_t *, uint_t *);
1114 extern void	sctp_rexmit_timer(sctp_t *, sctp_faddr_t *);
1115 extern sctp_faddr_t *sctp_rotate_faddr(sctp_t *, sctp_faddr_t *);
1116 
1117 extern boolean_t sctp_sack(sctp_t *, mblk_t *);
1118 extern int	sctp_secure_restart_check(mblk_t *, sctp_chunk_hdr_t *,
1119 		    uint32_t, int, sctp_stack_t *, ip_recv_attr_t *);
1120 extern void	sctp_send_abort(sctp_t *, uint32_t, uint16_t, char *, size_t,
1121 		    mblk_t *, int, boolean_t, ip_recv_attr_t *);
1122 extern void	sctp_ootb_send_abort(uint32_t, uint16_t, char *, size_t,
1123 		    const mblk_t *, int, boolean_t, ip_recv_attr_t *,
1124 		    ip_stack_t *);
1125 extern void	sctp_send_cookie_ack(sctp_t *);
1126 extern void	sctp_send_cookie_echo(sctp_t *, sctp_chunk_hdr_t *, mblk_t *,
1127 			ip_recv_attr_t *);
1128 extern void	sctp_send_initack(sctp_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
1129 		    mblk_t *, ip_recv_attr_t *);
1130 extern void	sctp_send_shutdown(sctp_t *, int);
1131 extern void	sctp_send_heartbeat(sctp_t *, sctp_faddr_t *);
1132 extern void	sctp_sendfail_event(sctp_t *, mblk_t *, int, boolean_t);
1133 extern void	sctp_set_faddr_current(sctp_t *, sctp_faddr_t *);
1134 extern int	sctp_set_hdraddrs(sctp_t *);
1135 extern void	sctp_set_saddr(sctp_t *, sctp_faddr_t *);
1136 extern void	sctp_sets_init(void);
1137 extern void	sctp_sets_fini(void);
1138 extern void	sctp_shutdown_event(sctp_t *);
1139 extern void	sctp_stop_faddr_timers(sctp_t *);
1140 extern int	sctp_shutdown_received(sctp_t *, sctp_chunk_hdr_t *, boolean_t,
1141 		    boolean_t, sctp_faddr_t *);
1142 extern void	sctp_shutdown_complete(sctp_t *);
1143 extern void	sctp_set_if_mtu(sctp_t *);
1144 extern void	sctp_set_iplen(sctp_t *, mblk_t *, ip_xmit_attr_t *);
1145 extern void	sctp_set_ulp_prop(sctp_t *);
1146 extern void	sctp_ss_rexmit(sctp_t *);
1147 extern void	sctp_stack_cpu_add(sctp_stack_t *, processorid_t);
1148 extern size_t	sctp_supaddr_param_len(sctp_t *);
1149 extern size_t	sctp_supaddr_param(sctp_t *, uchar_t *);
1150 
1151 extern void	sctp_timer(sctp_t *, mblk_t *, clock_t);
1152 extern mblk_t	*sctp_timer_alloc(sctp_t *, pfv_t, int);
1153 extern void	sctp_timer_call(sctp_t *sctp, mblk_t *);
1154 extern void	sctp_timer_free(mblk_t *);
1155 extern void	sctp_timer_stop(mblk_t *);
1156 extern void	sctp_unlink_faddr(sctp_t *, sctp_faddr_t *);
1157 
1158 extern void	sctp_update_dce(sctp_t *sctp);
1159 extern in_port_t sctp_update_next_port(in_port_t, zone_t *zone, sctp_stack_t *);
1160 extern void	sctp_update_rtt(sctp_t *, sctp_faddr_t *, clock_t);
1161 extern void	sctp_user_abort(sctp_t *, mblk_t *);
1162 
1163 extern void	sctp_validate_peer(sctp_t *);
1164 
1165 extern int	sctp_xmit_list_clean(sctp_t *, ssize_t);
1166 
1167 extern void	sctp_zap_addrs(sctp_t *);
1168 extern void	sctp_zap_faddrs(sctp_t *, int);
1169 extern sctp_chunk_hdr_t	*sctp_first_chunk(uchar_t *, ssize_t);
1170 extern void	sctp_send_shutdown_ack(sctp_t *, sctp_faddr_t *, boolean_t);
1171 
1172 /* Contract private interface between SCTP and Clustering - PSARC/2005/602 */
1173 
1174 extern void	(*cl_sctp_listen)(sa_family_t, uchar_t *, uint_t, in_port_t);
1175 extern void	(*cl_sctp_unlisten)(sa_family_t, uchar_t *, uint_t, in_port_t);
1176 extern void 	(*cl_sctp_connect)(sa_family_t, uchar_t *, uint_t, in_port_t,
1177 		    uchar_t *, uint_t, in_port_t, boolean_t, cl_sctp_handle_t);
1178 extern void	(*cl_sctp_disconnect)(sa_family_t, cl_sctp_handle_t);
1179 extern void	(*cl_sctp_assoc_change)(sa_family_t, uchar_t *, size_t, uint_t,
1180 		    uchar_t *, size_t, uint_t, int, cl_sctp_handle_t);
1181 extern void	(*cl_sctp_check_addrs)(sa_family_t, in_port_t, uchar_t **,
1182 		    size_t, uint_t *, boolean_t);
1183 
1184 #define	RUN_SCTP(sctp)						\
1185 {								\
1186 	mutex_enter(&(sctp)->sctp_lock);			\
1187 	while ((sctp)->sctp_running)				\
1188 		cv_wait(&(sctp)->sctp_cv, &(sctp)->sctp_lock);	\
1189 	(sctp)->sctp_running = B_TRUE;				\
1190 	mutex_exit(&(sctp)->sctp_lock);				\
1191 }
1192 
1193 /* Wake up recvq taskq */
1194 #define	WAKE_SCTP(sctp)				\
1195 {						\
1196 	mutex_enter(&(sctp)->sctp_lock);	\
1197 	if ((sctp)->sctp_timer_mp != NULL)	\
1198 		sctp_process_timer(sctp);	\
1199 	(sctp)->sctp_running = B_FALSE;		\
1200 	cv_broadcast(&(sctp)->sctp_cv);		\
1201 	mutex_exit(&(sctp)->sctp_lock);		\
1202 }
1203 
1204 #ifdef	__cplusplus
1205 }
1206 #endif
1207 
1208 #endif	/* _INET_SCTP_SCTP_IMPL_H */
1209