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