sctp_impl.h revision 5dd46ab5742d7db1cbb08dec7b64fa14930c02f7
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
*/
#ifndef _INET_SCTP_SCTP_IMPL_H
#define _INET_SCTP_SCTP_IMPL_H
#include <sys/inttypes.h>
#include <sys/taskq.h>
#include <sys/list.h>
#include <sys/strsun.h>
#include <sys/zone.h>
#include <sys/cpuvar.h>
#include <sys/clock_impl.h>
#include <netinet/ip6.h>
#include <inet/optcom.h>
#include <inet/tunables.h>
#include <netinet/sctp.h>
#include <inet/sctp_itf.h>
#include "sctp_stack.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Streams device identifying info and version */
#define SCTP_DEV_IDINFO "SCTP Streams device 1.0"
#define SSN_GT(a, b) ((int16_t)((a)-(b)) > 0)
#define SSN_GE(a, b) ((int16_t)((a)-(b)) >= 0)
/* Default buffer size and flow control wake up threshold. */
#define SCTP_XMIT_LOWATER 8192
#define SCTP_XMIT_HIWATER 102400
#define SCTP_RECV_LOWATER 8192
#define SCTP_RECV_HIWATER 102400
/* SCTP Timer control structure */
typedef struct sctpt_s {
pfv_t sctpt_pfv; /* The routine we are to call */
struct sctp_s *sctpt_sctp; /* The parameter we are to pass in */
struct sctp_faddr_s *sctpt_faddr;
} sctpt_t;
/*
* Maximum number of duplicate TSNs we can report. This is currently
* static, and governs the size of the mblk used to hold the duplicate
* reports. The use of duplcate TSN reports is currently experimental,
* so for now a static limit should suffice.
*/
#define SCTP_DUP_MBLK_SZ 64
#define SCTP_IS_ADDR_UNSPEC(isv4, addr) \
((isv4) ? IN6_IS_ADDR_V4MAPPED_ANY(&(addr)) : \
IN6_IS_ADDR_UNSPECIFIED(&(addr)))
/*
* SCTP properties/tunables
*/
#define sctps_max_init_retr sctps_propinfo_tbl[0].prop_cur_uval
#define sctps_max_init_retr_high sctps_propinfo_tbl[0].prop_max_uval
#define sctps_max_init_retr_low sctps_propinfo_tbl[0].prop_min_uval
#define sctps_pa_max_retr sctps_propinfo_tbl[1].prop_cur_uval
#define sctps_pa_max_retr_high sctps_propinfo_tbl[1].prop_max_uval
#define sctps_pa_max_retr_low sctps_propinfo_tbl[1].prop_min_uval
#define sctps_pp_max_retr sctps_propinfo_tbl[2].prop_cur_uval
#define sctps_pp_max_retr_high sctps_propinfo_tbl[2].prop_max_uval
#define sctps_pp_max_retr_low sctps_propinfo_tbl[2].prop_min_uval
#define sctps_cwnd_max_ sctps_propinfo_tbl[3].prop_cur_uval
#define sctps_smallest_nonpriv_port sctps_propinfo_tbl[4].prop_cur_uval
#define sctps_ipv4_ttl sctps_propinfo_tbl[5].prop_cur_uval
#define sctps_heartbeat_interval sctps_propinfo_tbl[6].prop_cur_uval
#define sctps_heartbeat_interval_high sctps_propinfo_tbl[6].prop_max_uval
#define sctps_heartbeat_interval_low sctps_propinfo_tbl[6].prop_min_uval
#define sctps_initial_mtu sctps_propinfo_tbl[7].prop_cur_uval
#define sctps_mtu_probe_interval sctps_propinfo_tbl[8].prop_cur_uval
#define sctps_new_secret_interval sctps_propinfo_tbl[9].prop_cur_uval
#define sctps_deferred_ack_interval sctps_propinfo_tbl[10].prop_cur_uval
#define sctps_snd_lowat_fraction sctps_propinfo_tbl[11].prop_cur_uval
#define sctps_ignore_path_mtu sctps_propinfo_tbl[12].prop_cur_bval
#define sctps_initial_ssthresh sctps_propinfo_tbl[13].prop_cur_uval
#define sctps_smallest_anon_port sctps_propinfo_tbl[14].prop_cur_uval
#define sctps_largest_anon_port sctps_propinfo_tbl[15].prop_cur_uval
#define sctps_xmit_hiwat sctps_propinfo_tbl[16].prop_cur_uval
#define sctps_xmit_lowat sctps_propinfo_tbl[17].prop_cur_uval
#define sctps_recv_hiwat sctps_propinfo_tbl[18].prop_cur_uval
#define sctps_max_buf sctps_propinfo_tbl[19].prop_cur_uval
#define sctps_rtt_updates sctps_propinfo_tbl[20].prop_cur_uval
#define sctps_ipv6_hoplimit sctps_propinfo_tbl[21].prop_cur_uval
#define sctps_rto_ming sctps_propinfo_tbl[22].prop_cur_uval
#define sctps_rto_ming_high sctps_propinfo_tbl[22].prop_max_uval
#define sctps_rto_ming_low sctps_propinfo_tbl[22].prop_min_uval
#define sctps_rto_maxg sctps_propinfo_tbl[23].prop_cur_uval
#define sctps_rto_maxg_high sctps_propinfo_tbl[23].prop_max_uval
#define sctps_rto_maxg_low sctps_propinfo_tbl[23].prop_min_uval
#define sctps_rto_initialg sctps_propinfo_tbl[24].prop_cur_uval
#define sctps_rto_initialg_high sctps_propinfo_tbl[24].prop_max_uval
#define sctps_rto_initialg_low sctps_propinfo_tbl[24].prop_min_uval
#define sctps_cookie_life sctps_propinfo_tbl[25].prop_cur_uval
#define sctps_cookie_life_high sctps_propinfo_tbl[25].prop_max_uval
#define sctps_cookie_life_low sctps_propinfo_tbl[25].prop_min_uval
#define sctps_max_in_streams sctps_propinfo_tbl[26].prop_cur_uval
#define sctps_max_in_streams_high sctps_propinfo_tbl[26].prop_max_uval
#define sctps_max_in_streams_low sctps_propinfo_tbl[26].prop_min_uval
#define sctps_initial_out_streams sctps_propinfo_tbl[27].prop_cur_uval
#define sctps_initial_out_streams_high sctps_propinfo_tbl[27].prop_max_uval
#define sctps_initial_out_streams_low sctps_propinfo_tbl[27].prop_min_uval
#define sctps_shutack_wait_bound sctps_propinfo_tbl[28].prop_cur_uval
#define sctps_maxburst sctps_propinfo_tbl[29].prop_cur_uval
#define sctps_addip_enabled sctps_propinfo_tbl[30].prop_cur_bval
#define sctps_recv_hiwat_minmss sctps_propinfo_tbl[31].prop_cur_uval
#define sctps_slow_start_initial sctps_propinfo_tbl[32].prop_cur_uval
#define sctps_slow_start_after_idle sctps_propinfo_tbl[33].prop_cur_uval
#define sctps_prsctp_enabled sctps_propinfo_tbl[34].prop_cur_bval
#define sctps_fast_rxt_thresh sctps_propinfo_tbl[35].prop_cur_uval
#define sctps_deferred_acks_max sctps_propinfo_tbl[36].prop_cur_uval
#define sctps_wroff_xtra sctps_propinfo_tbl[37].prop_cur_uval
/*
* Retransmission timer start and stop macro for a given faddr.
*/
#define SCTP_FADDR_TIMER_RESTART(sctp, fp, intvl) \
{ \
dprint(3, ("faddr_timer_restart: fp=%p %x:%x:%x:%x %d\n", \
(void *)(fp), SCTP_PRINTADDR((fp)->faddr), (int)(intvl))); \
sctp_timer((sctp), (fp)->timer_mp, (intvl)); \
(fp)->timer_running = 1; \
}
#define SCTP_FADDR_TIMER_STOP(fp) \
ASSERT((fp)->timer_mp != NULL); \
if ((fp)->timer_running) { \
sctp_timer_stop((fp)->timer_mp); \
(fp)->timer_running = 0; \
}
/* For per endpoint association statistics */
#define SCTP_MAX_RTO(sctp, fp) { \
/* \
* Record the maximum observed RTO, \
* sctp_maxrto is zeroed elsewhere \
* at the end of each stats request. \
*/ \
(sctp)->sctp_maxrto = \
MAX((sctp)->sctp_maxrto, (fp)->rto); \
DTRACE_PROBE2(sctp__maxrto, sctp_t *, \
sctp, struct sctp_faddr_s, fp); \
}
#define SCTP_CALC_RXT(sctp, fp, max) \
{ \
if (((fp)->rto <<= 1) > (max)) \
(fp)->rto = (max); \
SCTP_MAX_RTO(sctp, fp); \
}
#define SCTP_MAX_COMBINED_HEADER_LENGTH (60 + 12) /* Maxed out ip + sctp */
#define SCTP_MAX_IP_OPTIONS_LENGTH (60 - IP_SIMPLE_HDR_LENGTH)
#define SCTP_MAX_HDR_LENGTH 60
#define SCTP_SECRET_LEN 16
#define SCTP_REFHOLD(sctp) { \
mutex_enter(&(sctp)->sctp_reflock); \
(sctp)->sctp_refcnt++; \
DTRACE_PROBE1(sctp_refhold, sctp_t, sctp); \
ASSERT((sctp)->sctp_refcnt != 0); \
mutex_exit(&(sctp)->sctp_reflock); \
}
#define SCTP_REFRELE(sctp) { \
mutex_enter(&(sctp)->sctp_reflock); \
ASSERT((sctp)->sctp_refcnt != 0); \
if (--(sctp)->sctp_refcnt == 0) { \
DTRACE_PROBE1(sctp_refrele, sctp_t, sctp); \
mutex_exit(&(sctp)->sctp_reflock); \
CONN_DEC_REF((sctp)->sctp_connp); \
} else { \
DTRACE_PROBE1(sctp_refrele, sctp_t, sctp); \
mutex_exit(&(sctp)->sctp_reflock); \
} \
}
#define SCTP_PRINTADDR(a) (a).s6_addr32[0], (a).s6_addr32[1],\
(a).s6_addr32[2], (a).s6_addr32[3]
#define CONN2SCTP(conn) ((sctp_t *)(&((conn_t *)conn)[1]))
/*
* Outbound data, flags and macros for per-message, per-chunk info
*/
typedef struct {
int64_t smh_ttl; /* Time to Live */
int64_t smh_tob; /* Time of Birth */
uint32_t smh_context;
uint16_t smh_sid;
uint16_t smh_ssn;
uint32_t smh_ppid;
uint16_t smh_flags;
uint32_t smh_msglen;
} sctp_msg_hdr_t;
#define SCTP_CHUNK_FLAG_SENT 0x01
#define SCTP_CHUNK_FLAG_REXMIT 0x02
#define SCTP_CHUNK_FLAG_ACKED 0x04
#define SCTP_MSG_FLAG_CHUNKED 0x08
#define SCTP_MSG_FLAG_ABANDONED 0x10
#define SCTP_CHUNK_FLAG_ABANDONED 0x20
#define SCTP_CHUNK_CLEAR_FLAGS(mp) ((mp)->b_flag = 0)
/*
* If we are transmitting the chunk for the first time we assign the TSN and
* SSN here. The reason we assign the SSN here (as opposed to doing it in
* sctp_chunkify()) is that the chunk may expire, if PRSCTP is enabled, before
* we get a chance to send it out. If we assign the SSN in sctp_chunkify()
* and this happens, then we need to send a Forward TSN to the peer, which
* will be expecting this SSN, assuming ordered. If we assign it here we
* can just take out the chunk from the transmit list without having to
* send a Forward TSN chunk. While assigning the SSN we use (meta)->b_cont
* to determine if it needs a new SSN (i.e. the next SSN for the stream),
* since (meta)->b_cont signifies the first chunk of a message (if the message
* is unordered, then the SSN is 0).
*
*/
#define SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunkdata, meta) { \
if (!SCTP_CHUNK_ISSENT(mp)) { \
sctp_msg_hdr_t *mhdr = (sctp_msg_hdr_t *)(meta)->b_rptr; \
ASSERT(!SCTP_CHUNK_ABANDONED(mp)); \
(mp)->b_flag = SCTP_CHUNK_FLAG_SENT; \
(sdc)->sdh_tsn = htonl((sctp)->sctp_ltsn++); \
if ((mhdr)->smh_flags & MSG_UNORDERED) { \
(sdc)->sdh_ssn = 0; \
SCTP_DATA_SET_UBIT(sdc); \
BUMP_LOCAL((sctp)->sctp_oudchunks); \
} else { \
BUMP_LOCAL((sctp)->sctp_odchunks); \
if ((mp) == (meta)->b_cont) { \
mhdr->smh_ssn = htons( \
(sctp)->sctp_ostrcntrs[mhdr->smh_sid]++); \
} \
(sdc)->sdh_ssn = mhdr->smh_ssn; \
} \
DTRACE_PROBE3(sctp__chunk__sent1, sctp_t *, sctp, \
mblk_t *, mp, mblk_t *, meta); \
(sctp)->sctp_unacked += (chunkdata); \
(sctp)->sctp_unsent -= (chunkdata); \
(sctp)->sctp_frwnd -= (chunkdata); \
} else { \
if (SCTP_CHUNK_ISACKED(mp)) { \
(sctp)->sctp_unacked += (chunkdata); \
} else { \
ASSERT(SCTP_CHUNK_DEST(mp)->suna >= ((chunkdata) + \
sizeof (*sdc))); \
SCTP_CHUNK_DEST(mp)->suna -= ((chunkdata) + \
sizeof (*sdc)); \
} \
DTRACE_PROBE3(sctp__chunk__sent2, sctp_t *, sctp, \
mblk_t *, mp, mblk_t *, meta); \
(mp)->b_flag &= ~(SCTP_CHUNK_FLAG_REXMIT | \
SCTP_CHUNK_FLAG_ACKED); \
SCTP_CHUNK_SET_SACKCNT(mp, 0); \
BUMP_LOCAL(sctp->sctp_rxtchunks); \
BUMP_LOCAL((sctp)->sctp_T3expire); \
BUMP_LOCAL((fp)->T3expire); \
} \
SCTP_SET_CHUNK_DEST(mp, fp); \
(fp)->suna += ((chunkdata) + sizeof (*sdc)); \
}
#define SCTP_CHUNK_ISSENT(mp) ((mp)->b_flag & SCTP_CHUNK_FLAG_SENT)
#define SCTP_CHUNK_CANSEND(mp) \
(!(SCTP_CHUNK_ABANDONED(mp)) && \
(((mp)->b_flag & (SCTP_CHUNK_FLAG_REXMIT|SCTP_CHUNK_FLAG_SENT)) != \
SCTP_CHUNK_FLAG_SENT))
#define SCTP_CHUNK_DEST(mp) ((sctp_faddr_t *)(mp)->b_queue)
#define SCTP_SET_CHUNK_DEST(mp, fp) ((mp)->b_queue = (queue_t *)fp)
#define SCTP_CHUNK_REXMIT(sctp, mp) { \
DTRACE_PROBE2(sctp__chunk__rexmit, sctp_t *, sctp, mblk_t *, \
mp); \
(mp)->b_flag |= SCTP_CHUNK_FLAG_REXMIT; \
}
#define SCTP_CHUNK_CLEAR_REXMIT(mp) ((mp)->b_flag &= ~SCTP_CHUNK_FLAG_REXMIT)
#define SCTP_CHUNK_WANT_REXMIT(mp) ((mp)->b_flag & SCTP_CHUNK_FLAG_REXMIT)
#define SCTP_CHUNK_ACKED(mp) \
((mp)->b_flag = (SCTP_CHUNK_FLAG_SENT|SCTP_CHUNK_FLAG_ACKED))
#define SCTP_CHUNK_ISACKED(mp) ((mp)->b_flag & SCTP_CHUNK_FLAG_ACKED)
#define SCTP_CHUNK_CLEAR_ACKED(sctp, mp) { \
DTRACE_PROBE2(sctp__chunk__clracked, sctp_t *, sctp, mblk_t *, \
mp); \
(mp)->b_flag &= ~SCTP_CHUNK_FLAG_ACKED; \
}
#define SCTP_CHUNK_SACKCNT(mp) ((intptr_t)((mp)->b_prev))
#define SCTP_CHUNK_SET_SACKCNT(mp, val) ((mp)->b_prev = \
(mblk_t *)(uintptr_t)(val))
#define SCTP_MSG_SET_CHUNKED(mp) ((mp)->b_flag |= SCTP_MSG_FLAG_CHUNKED)
#define SCTP_MSG_CLEAR_CHUNKED(mp)((mp)->b_flag &= ~SCTP_MSG_FLAG_CHUNKED)
#define SCTP_IS_MSG_CHUNKED(mp) ((mp)->b_flag & SCTP_MSG_FLAG_CHUNKED)
/* For PR-SCTP */
#define SCTP_ABANDON_CHUNK(mp) ((mp)->b_flag |= SCTP_CHUNK_FLAG_ABANDONED)
#define SCTP_CHUNK_ABANDONED(mp) \
((mp)->b_flag & SCTP_CHUNK_FLAG_ABANDONED)
#define SCTP_MSG_SET_ABANDONED(mp) \
((mp)->b_flag |= SCTP_MSG_FLAG_ABANDONED)
#define SCTP_MSG_CLEAR_ABANDONED(mp)((mp)->b_flag &= ~SCTP_MSG_FLAG_ABANDONED)
#define SCTP_IS_MSG_ABANDONED(mp) ((mp)->b_flag & SCTP_MSG_FLAG_ABANDONED)
/*
* Check if a message has expired. A message is expired if
* 1. It has a non-zero time to live value and has not been sent before
* that time expires.
* 2. It is sent using PRSCTP and it has not been SACK'ed before
* its lifetime expires.
*/
#define SCTP_MSG_TO_BE_ABANDONED(meta, mhdr, sctp) \
(((!SCTP_CHUNK_ISSENT((meta)->b_cont) && (mhdr)->smh_ttl > 0) || \
((sctp)->sctp_prsctp_aware && ((mhdr)->smh_flags & MSG_PR_SCTP))) && \
((ddi_get_lbolt64() - (mhdr)->smh_tob) > (mhdr)->smh_ttl))
/* SCTP association hash function. */
#define SCTP_CONN_HASH(sctps, ports) \
((((ports) ^ ((ports) >> 16)) * 31) & \
((sctps)->sctps_conn_hash_size - 1))
/*
* Linked list struct to store SCTP listener association limit configuration
* per IP stack. The list is stored at sctps_listener_conf in sctp_stack_t.
*
* sl_port: the listener port of this limit configuration
* sl_ratio: the maximum amount of memory consumed by all concurrent SCTP
* connections created by a listener does not exceed 1/tl_ratio
* of the total system memory. Note that this is only an
* approximation.
* sl_link: linked list struct
*/
typedef struct sctp_listener_s {
in_port_t sl_port;
uint32_t sl_ratio;
list_node_t sl_link;
} sctp_listener_t;
/*
* If there is a limit set on the number of association allowed per each
* listener, the following struct is used to store that counter. It keeps
* the number of SCTP association created by a listener. Note that this needs
* to be separated from the listener since the listener can go away before
* all the associations are gone.
*
* When the struct is allocated, slc_cnt is set to 1. When a new association
* is created by the listener, slc_cnt is incremented by 1. When an
* association created by the listener goes away, slc_count is decremented by
* 1. When the listener itself goes away, slc_cnt is decremented by one.
* The last association (or the listener) which decrements slc_cnt to zero
* frees the struct.
*
* slc_max is the maximum number of concurrent associations created from a
* listener. It is calculated when the sctp_listen_cnt_t is allocated.
*
* slc_report_time stores the time when cmn_err() is called to report that the
* max has been exceeeded. Report is done at most once every
* SCTP_SLC_REPORT_INTERVAL mins for a listener.
*
* slc_drop stores the number of connection attempt dropped because the
* limit has reached.
*/
typedef struct sctp_listen_cnt_s {
uint32_t slc_max;
uint32_t slc_cnt;
int64_t slc_report_time;
uint32_t slc_drop;
} sctp_listen_cnt_t;
#define SCTP_SLC_REPORT_INTERVAL (30 * MINUTES)
#define SCTP_DECR_LISTEN_CNT(sctp) \
{ \
ASSERT((sctp)->sctp_listen_cnt->slc_cnt > 0); \
if (atomic_add_32_nv(&(sctp)->sctp_listen_cnt->slc_cnt, -1) == 0) \
kmem_free((sctp)->sctp_listen_cnt, sizeof (sctp_listen_cnt_t));\
(sctp)->sctp_listen_cnt = NULL; \
}
/* Increment and decrement the number of associations in sctp_stack_t. */
#define SCTPS_ASSOC_INC(sctps) \
atomic_inc_64( \
(uint64_t *)&(sctps)->sctps_sc[CPU->cpu_seqid]->sctp_sc_assoc_cnt)
#define SCTPS_ASSOC_DEC(sctps) \
atomic_dec_64( \
(uint64_t *)&(sctps)->sctps_sc[CPU->cpu_seqid]->sctp_sc_assoc_cnt)
#define SCTP_ASSOC_EST(sctps, sctp) \
{ \
(sctp)->sctp_state = SCTPS_ESTABLISHED; \
(sctp)->sctp_assoc_start_time = (uint32_t)LBOLT_FASTPATH64; \
SCTPS_ASSOC_INC(sctps); \
}
/*
* Bind hash array size and hash function. The size must be a power
* of 2 and lport must be in host byte order.
*/
#define SCTP_BIND_FANOUT_SIZE 2048
#define SCTP_BIND_HASH(lport) (((lport) * 31) & (SCTP_BIND_FANOUT_SIZE - 1))
/* options that SCTP negotiates during association establishment */
#define SCTP_PRSCTP_OPTION 0x01
/*
* Listener hash array size and hash function. The size must be a power
* of 2 and lport must be in host byte order.
*/
#define SCTP_LISTEN_FANOUT_SIZE 512
#define SCTP_LISTEN_HASH(lport) (((lport) * 31) & (SCTP_LISTEN_FANOUT_SIZE - 1))
typedef struct sctp_tf_s {
struct sctp_s *tf_sctp;
kmutex_t tf_lock;
} sctp_tf_t;
/* Round up the value to the nearest mss. */
#define MSS_ROUNDUP(value, mss) ((((value) - 1) / (mss) + 1) * (mss))
extern sin_t sctp_sin_null; /* Zero address for quick clears */
extern sin6_t sctp_sin6_null; /* Zero address for quick clears */
#define SCTP_IS_DETACHED(sctp) ((sctp)->sctp_detached)
/* Data structure used to track received TSNs */
typedef struct sctp_set_s {
struct sctp_set_s *next;
struct sctp_set_s *prev;
uint32_t begin;
uint32_t end;
} sctp_set_t;
/* Data structure used to track TSNs for PR-SCTP */
typedef struct sctp_ftsn_set_s {
struct sctp_ftsn_set_s *next;
ftsn_entry_t ftsn_entries;
} sctp_ftsn_set_t;
/* Data structure used to track incoming SCTP streams */
typedef struct sctp_instr_s {
mblk_t *istr_msgs;
int istr_nmsgs;
uint16_t nextseq;
struct sctp_s *sctp;
mblk_t *istr_reass;
} sctp_instr_t;
/* Reassembly data structure (per-stream) */
typedef struct sctp_reass_s {
uint16_t ssn;
uint16_t needed;
uint16_t got;
uint16_t msglen; /* len of consecutive fragments */
/* from the begining (B-bit) */
mblk_t *tail;
boolean_t hasBchunk; /* If the fragment list begins with */
/* a B-bit set chunk */
uint32_t nexttsn; /* TSN of the next fragment we */
/* are expecting */
boolean_t partial_delivered;
} sctp_reass_t;
/* debugging */
#undef dprint
#ifdef DEBUG
extern int sctpdebug;
#define dprint(level, args) { if (sctpdebug > (level)) printf args; }
#else
#define dprint(level, args) {}
#endif
/* Peer address tracking */
/*
* States for peer addresses
*
* SCTP_FADDRS_UNCONFIRMED: we have not communicated with this peer address
* before, mark it as unconfirmed so that we will not send data to it.
* All addresses initially are in unconfirmed state and required
* validation. SCTP sends a heartbeat to each of them and when it gets
* back a heartbeat ACK, the address will be marked as alive. This
* validation fixes a security issue with multihoming. If an attacker
* establishes an association with us and tells us that it has addresses
* belonging to another host A, this will prevent A from communicating
* with us. This is fixed by peer address validation. In the above case,
* A will respond with an abort.
*
* SCTP_FADDRS_ALIVE: this peer address is alive and we can communicate with
* it with no problem.
*
* SCTP_FADDRS_DOWN: we have exceeded the retransmission limit to this
* peer address. Once an address is marked down, we will only send
* a heartbeat to it every hb_interval in case it becomes alive now.
*
* SCTP_FADDRS_UNREACH: there is no suitable source address to send to
* this peer address. For example, the peer address is v6 but we only
* have v4 addresses. It is marked unreachable until there is an
* address configuration change. At that time, mark these addresses
* as unconfirmed and try again to see if those unreachable addresses
* are OK as we may have more source addresses.
*/
typedef enum {
SCTP_FADDRS_UNREACH,
SCTP_FADDRS_DOWN,
SCTP_FADDRS_ALIVE,
SCTP_FADDRS_UNCONFIRMED
} faddr_state_t;
typedef struct sctp_faddr_s {
struct sctp_faddr_s *next;
faddr_state_t state;
in6_addr_t faddr;
in6_addr_t saddr;
int64_t hb_expiry; /* time to retransmit heartbeat */
uint32_t hb_interval; /* the heartbeat interval */
int rto; /* RTO in tick */
int srtt; /* Smoothed RTT in tick */
int rttvar; /* RTT variance in tick */
uint32_t rtt_updates;
int strikes;
int max_retr;
uint32_t sfa_pmss;
uint32_t cwnd;
uint32_t ssthresh;
uint32_t suna; /* sent - unack'ed */
uint32_t pba; /* partial bytes acked */
uint32_t acked;
int64_t lastactive;
mblk_t *timer_mp; /* retransmission timer control */
uint32_t
hb_pending : 1,
timer_running : 1,
df : 1,
pmtu_discovered : 1,
rc_timer_running : 1,
isv4 : 1,
hb_enabled : 1;
mblk_t *rc_timer_mp; /* reliable control chunk timer */
ip_xmit_attr_t *ixa; /* Transmit attributes */
uint32_t T3expire; /* # of times T3 timer expired */
uint64_t hb_secret; /* per addr "secret" in heartbeat */
uint32_t rxt_unacked; /* # unack'ed retransmitted bytes */
} sctp_faddr_t;
/* Flags to indicate supported address type in the PARM_SUP_ADDRS. */
#define PARM_SUPP_V6 0x1
#define PARM_SUPP_V4 0x2
/*
* Set heartbeat interval plus jitter. The jitter is supposed to be random,
* up to +/- 50% of the RTO. We use gethrtime() here for performance reason
* as the jitter does not really need to be "very" random.
*/
#define SET_HB_INTVL(fp) \
((fp)->hb_interval + (fp)->rto + ((fp)->rto >> 1) - \
(uint_t)gethrtime() % (fp)->rto)
#define SCTP_IPIF_HASH 16
typedef struct sctp_ipif_hash_s {
list_t sctp_ipif_list;
int ipif_count;
krwlock_t ipif_hash_lock;
} sctp_ipif_hash_t;
/*
* Initialize cwnd according to RFC 3390. def_max_init_cwnd is
* either sctp_slow_start_initial or sctp_slow_start_after idle
* depending on the caller.
*/
#define SET_CWND(fp, mss, def_max_init_cwnd) \
{ \
(fp)->cwnd = MIN(def_max_init_cwnd * (mss), \
MIN(4 * (mss), MAX(2 * (mss), 4380 / (mss) * (mss)))); \
}
struct sctp_s;
/*
* Control structure for each open SCTP stream,
* defined only within the kernel or for a kmem user.
* NOTE: sctp_reinit_values MUST have a line for each field in this structure!
*/
#if (defined(_KERNEL) || defined(_KMEMUSER))
typedef struct sctp_s {
/*
* The following is shared with (and duplicated) in IP, so if you
* make changes, make sure you also change things in ip_sctp.c.
*/
struct sctp_s *sctp_conn_hash_next;
struct sctp_s *sctp_conn_hash_prev;
struct sctp_s *sctp_listen_hash_next;
struct sctp_s *sctp_listen_hash_prev;
sctp_tf_t *sctp_listen_tfp; /* Ptr to tf */
sctp_tf_t *sctp_conn_tfp; /* Ptr to tf */
/* Global list of sctp */
list_node_t sctp_list;
sctp_faddr_t *sctp_faddrs;
int sctp_nfaddrs;
sctp_ipif_hash_t sctp_saddrs[SCTP_IPIF_HASH];
int sctp_nsaddrs;
kmutex_t sctp_lock;
kcondvar_t sctp_cv;
boolean_t sctp_running;
#define sctp_ulpd sctp_connp->conn_upper_handle
#define sctp_upcalls sctp_connp->conn_upcalls
#define sctp_ulp_newconn sctp_upcalls->su_newconn
#define sctp_ulp_connected sctp_upcalls->su_connected
#define sctp_ulp_disconnected sctp_upcalls->su_disconnected
#define sctp_ulp_opctl sctp_upcalls->su_opctl
#define sctp_ulp_recv sctp_upcalls->su_recv
#define sctp_ulp_xmitted sctp_upcalls->su_txq_full
#define sctp_ulp_prop sctp_upcalls->su_set_proto_props
int32_t sctp_state;
conn_t *sctp_connp; /* conn_t stuff */
sctp_stack_t *sctp_sctps;
/* Peer address tracking */
sctp_faddr_t *sctp_lastfaddr; /* last faddr in list */
sctp_faddr_t *sctp_primary; /* primary faddr */
sctp_faddr_t *sctp_current; /* current faddr */
sctp_faddr_t *sctp_lastdata; /* last data seen from this */
/* Outbound data tracking */
mblk_t *sctp_xmit_head;
mblk_t *sctp_xmit_tail;
mblk_t *sctp_xmit_unsent;
mblk_t *sctp_xmit_unsent_tail;
mblk_t *sctp_xmit_unacked;
int32_t sctp_unacked; /* # of unacked bytes */
int32_t sctp_unsent; /* # of unsent bytes in hand */
uint32_t sctp_ltsn; /* Local instance TSN */
uint32_t sctp_lastack_rxd; /* Last rx'd cumtsn */
uint32_t sctp_recovery_tsn; /* Exit from fast recovery */
uint32_t sctp_adv_pap; /* Adv. Peer Ack Point */
uint16_t sctp_num_ostr;
uint16_t *sctp_ostrcntrs;
mblk_t *sctp_pad_mp; /* pad unaligned data chunks */
/* sendmsg() default parameters */
uint16_t sctp_def_stream; /* default stream id */
uint16_t sctp_def_flags; /* default xmit flags */
uint32_t sctp_def_ppid; /* default payload id */
uint32_t sctp_def_context; /* default context */
uint32_t sctp_def_timetolive; /* default msg TTL */
/* Inbound data tracking */
sctp_set_t *sctp_sack_info; /* Sack tracking */
mblk_t *sctp_ack_mp; /* Delayed ACK timer block */
sctp_instr_t *sctp_instr; /* Instream trackers */
mblk_t *sctp_uo_frags; /* Un-ordered msg. fragments */
uint32_t sctp_ftsn; /* Peer's TSN */
uint32_t sctp_lastacked; /* last cumtsn SACKd */
uint16_t sctp_num_istr; /* No. of instreams */
int32_t sctp_istr_nmsgs; /* No. of chunks in instreams */
int32_t sctp_sack_gaps; /* No. of received gaps */
int32_t sctp_sack_toggle; /* SACK every other pkt */
/* RTT calculation */
uint32_t sctp_rtt_tsn;
int64_t sctp_out_time;
/* Stats can be reset by snmp users kstat, netstat and snmp agents */
uint64_t sctp_opkts; /* sent pkts */
uint64_t sctp_obchunks; /* sent control chunks */
uint64_t sctp_odchunks; /* sent ordered data chunks */
uint64_t sctp_oudchunks; /* sent unord data chunks */
uint64_t sctp_rxtchunks; /* retransmitted chunks */
uint64_t sctp_ipkts; /* recv pkts */
uint64_t sctp_ibchunks; /* recv control chunks */
uint64_t sctp_idchunks; /* recv ordered data chunks */
uint64_t sctp_iudchunks; /* recv unord data chunks */
uint64_t sctp_fragdmsgs;
uint64_t sctp_reassmsgs;
uint32_t sctp_T1expire; /* # of times T1timer expired */
uint32_t sctp_T2expire; /* # of times T2timer expired */
uint32_t sctp_T3expire; /* # of times T3timer expired */
uint32_t sctp_assoc_start_time; /* time when assoc was est. */
uint32_t sctp_frwnd; /* Peer RWND */
uint32_t sctp_cwnd_max;
/* Inbound flow control */
int32_t sctp_rwnd; /* Current receive window */
int32_t sctp_irwnd; /* Initial receive window */
int32_t sctp_rxqueued; /* No. of bytes in RX q's */
/* Pre-initialized composite headers */
uchar_t *sctp_iphc; /* v4 sctp/ip hdr template buffer */
uchar_t *sctp_iphc6; /* v6 sctp/ip hdr template buffer */
int32_t sctp_iphc_len; /* actual allocated v4 buffer size */
int32_t sctp_iphc6_len; /* actual allocated v6 buffer size */
int32_t sctp_hdr_len; /* len of combined SCTP/IP v4 hdr */
int32_t sctp_hdr6_len; /* len of combined SCTP/IP v6 hdr */
ipha_t *sctp_ipha; /* IPv4 header in the buffer */
ip6_t *sctp_ip6h; /* IPv6 header in the buffer */
int32_t sctp_ip_hdr_len; /* Byte len of our current v4 hdr */
int32_t sctp_ip_hdr6_len; /* Byte len of our current v6 hdr */
sctp_hdr_t *sctp_sctph; /* sctp header in combined v4 hdr */
sctp_hdr_t *sctp_sctph6; /* sctp header in combined v6 hdr */
uint32_t sctp_lvtag; /* local SCTP instance verf tag */
uint32_t sctp_fvtag; /* Peer's SCTP verf tag */
/* Path MTU Discovery */
int64_t sctp_last_mtu_probe;
clock_t sctp_mtu_probe_intvl;
uint32_t sctp_mss; /* Max send size (not TCP MSS!) */
/* structs sctp_bits, sctp_events are for clearing all bits at once */
struct {
uint32_t
sctp_understands_asconf : 1, /* Peer handles ASCONF chunks */
sctp_cchunk_pend : 1, /* Control chunk in flight. */
sctp_lingering : 1, /* Lingering in close */
sctp_loopback: 1, /* src and dst are the same machine */
sctp_force_sack : 1,
sctp_ack_timer_running: 1, /* Delayed ACK timer running */
sctp_hwcksum : 1, /* The NIC is capable of hwcksum */
sctp_understands_addip : 1,
sctp_bound_to_all : 1,
sctp_cansleep : 1, /* itf routines can sleep */
sctp_detached : 1, /* If we're detached from a stream */
sctp_send_adaptation : 1, /* send adaptation layer ind */
sctp_recv_adaptation : 1, /* recv adaptation layer ind */
sctp_ndelay : 1, /* turn off Nagle */
sctp_condemned : 1, /* this sctp is about to disappear */
sctp_chk_fast_rexmit : 1, /* check for fast rexmit message */
sctp_prsctp_aware : 1, /* is peer PR-SCTP aware? */
sctp_linklocal : 1, /* is linklocal assoc. */
sctp_rexmitting : 1, /* SCTP is retransmitting */
sctp_zero_win_probe : 1, /* doing zero win probe */
sctp_txq_full : 1, /* the tx queue is full */
sctp_ulp_discon_done : 1, /* ulp_disconnecting done */
sctp_dummy : 6;
} sctp_bits;
struct {
uint32_t
sctp_recvsndrcvinfo : 1,
sctp_recvassocevnt : 1,
sctp_recvpathevnt : 1,
sctp_recvsendfailevnt : 1,
sctp_recvpeererr : 1,
sctp_recvshutdownevnt : 1,
sctp_recvpdevnt : 1,
sctp_recvalevnt : 1;
} sctp_events;
#define sctp_priv_stream sctp_bits.sctp_priv_stream
#define sctp_understands_asconf sctp_bits.sctp_understands_asconf
#define sctp_cchunk_pend sctp_bits.sctp_cchunk_pend
#define sctp_lingering sctp_bits.sctp_lingering
#define sctp_loopback sctp_bits.sctp_loopback
#define sctp_force_sack sctp_bits.sctp_force_sack
#define sctp_ack_timer_running sctp_bits.sctp_ack_timer_running
#define sctp_hwcksum sctp_bits.sctp_hwcksum
#define sctp_understands_addip sctp_bits.sctp_understands_addip
#define sctp_bound_to_all sctp_bits.sctp_bound_to_all
#define sctp_cansleep sctp_bits.sctp_cansleep
#define sctp_detached sctp_bits.sctp_detached
#define sctp_send_adaptation sctp_bits.sctp_send_adaptation
#define sctp_recv_adaptation sctp_bits.sctp_recv_adaptation
#define sctp_ndelay sctp_bits.sctp_ndelay
#define sctp_condemned sctp_bits.sctp_condemned
#define sctp_chk_fast_rexmit sctp_bits.sctp_chk_fast_rexmit
#define sctp_prsctp_aware sctp_bits.sctp_prsctp_aware
#define sctp_linklocal sctp_bits.sctp_linklocal
#define sctp_rexmitting sctp_bits.sctp_rexmitting
#define sctp_zero_win_probe sctp_bits.sctp_zero_win_probe
#define sctp_txq_full sctp_bits.sctp_txq_full
#define sctp_ulp_discon_done sctp_bits.sctp_ulp_discon_done
#define sctp_recvsndrcvinfo sctp_events.sctp_recvsndrcvinfo
#define sctp_recvassocevnt sctp_events.sctp_recvassocevnt
#define sctp_recvpathevnt sctp_events.sctp_recvpathevnt
#define sctp_recvsendfailevnt sctp_events.sctp_recvsendfailevnt
#define sctp_recvpeererr sctp_events.sctp_recvpeererr
#define sctp_recvshutdownevnt sctp_events.sctp_recvshutdownevnt
#define sctp_recvpdevnt sctp_events.sctp_recvpdevnt
#define sctp_recvalevnt sctp_events.sctp_recvalevnt
/* Retransmit info */
mblk_t *sctp_cookie_mp; /* cookie chunk, if rxt needed */
int32_t sctp_strikes; /* Total number of assoc strikes */
int32_t sctp_max_init_rxt;
int32_t sctp_pa_max_rxt; /* Max per-assoc retransmit cnt */
int32_t sctp_pp_max_rxt; /* Max per-path retransmit cnt */
uint32_t sctp_rto_max;
uint32_t sctp_rto_max_init;
uint32_t sctp_rto_min;
uint32_t sctp_rto_initial;
int64_t sctp_last_secret_update;
uint8_t sctp_secret[SCTP_SECRET_LEN]; /* for cookie auth */
uint8_t sctp_old_secret[SCTP_SECRET_LEN];
uint32_t sctp_cookie_lifetime; /* cookie lifetime in tick */
/* Bind hash tables */
kmutex_t *sctp_bind_lockp; /* Ptr to tf_lock */
struct sctp_s *sctp_bind_hash;
struct sctp_s **sctp_ptpbhn;
/* Shutdown / cleanup */
sctp_faddr_t *sctp_shutdown_faddr; /* rotate faddr during shutd */
int32_t sctp_client_errno; /* How the client screwed up */
kmutex_t sctp_reflock; /* Protects sctp_refcnt & timer mp */
ushort_t sctp_refcnt; /* No. of pending upstream msg */
mblk_t *sctp_timer_mp; /* List of fired timers. */
mblk_t *sctp_heartbeat_mp; /* Timer block for heartbeats */
uint32_t sctp_hb_interval; /* Default hb_interval */
int32_t sctp_autoclose; /* Auto disconnect in ticks */
int64_t sctp_active; /* Last time data/sack on this conn */
uint32_t sctp_tx_adaptation_code; /* TX adaptation code */
uint32_t sctp_rx_adaptation_code; /* RX adaptation code */
/* Reliable control chunks */
mblk_t *sctp_cxmit_list; /* Xmit list for control chunks */
uint32_t sctp_lcsn; /* Our serial number */
uint32_t sctp_fcsn; /* Peer serial number */
/* Per association receive queue */
kmutex_t sctp_recvq_lock;
mblk_t *sctp_recvq;
mblk_t *sctp_recvq_tail;
taskq_t *sctp_recvq_tq;
/* IPv6 ancillary data */
uint_t sctp_recvifindex; /* last rcvd IPV6_RCVPKTINFO */
uint_t sctp_recvhops; /* " IPV6_RECVHOPLIMIT */
uint_t sctp_recvtclass; /* " IPV6_RECVTCLASS */
ip6_hbh_t *sctp_hopopts; /* " IPV6_RECVHOPOPTS */
ip6_dest_t *sctp_dstopts; /* " IPV6_RECVDSTOPTS */
ip6_dest_t *sctp_rthdrdstopts; /* " IPV6_RECVRTHDRDSTOPTS */
ip6_rthdr_t *sctp_rthdr; /* " IPV6_RECVRTHDR */
uint_t sctp_hopoptslen;
uint_t sctp_dstoptslen;
uint_t sctp_rthdrdstoptslen;
uint_t sctp_rthdrlen;
/* Stats */
uint64_t sctp_msgcount;
uint64_t sctp_prsctpdrop;
uint_t sctp_v4label_len; /* length of cached v4 label */
uint_t sctp_v6label_len; /* length of cached v6 label */
uint32_t sctp_rxt_nxttsn; /* Next TSN to be rexmitted */
uint32_t sctp_rxt_maxtsn; /* Max TSN sent at time out */
int sctp_pd_point; /* Partial delivery point */
mblk_t *sctp_err_chunks; /* Error chunks */
uint32_t sctp_err_len; /* Total error chunks length */
/* additional source data for per endpoint association statistics */
uint64_t sctp_outseqtsns; /* TSN rx > expected TSN */
uint64_t sctp_osacks; /* total sacks sent */
uint64_t sctp_isacks; /* total sacks received */
uint64_t sctp_idupchunks; /* rx dups, ord or unord */
uint64_t sctp_gapcnt; /* total gap acks rx */
/*
* Add the current data from the counters which are reset by snmp
* to these cumulative counters to use in per endpoint statistics.
*/
uint64_t sctp_cum_obchunks; /* sent control chunks */
uint64_t sctp_cum_odchunks; /* sent ordered data chunks */
uint64_t sctp_cum_oudchunks; /* sent unord data chunks */
uint64_t sctp_cum_rxtchunks; /* retransmitted chunks */
uint64_t sctp_cum_ibchunks; /* recv control chunks */
uint64_t sctp_cum_idchunks; /* recv ordered data chunks */
uint64_t sctp_cum_iudchunks; /* recv unord data chunks */
/*
* When non-zero, this is the maximum observed RTO since assoc stats
* were last requested. When zero, no RTO update has occurred since
* the previous user request for stats on this endpoint.
*/
int sctp_maxrto;
/*
* The stored value of sctp_maxrto passed to user during the previous
* user request for stats on this endpoint.
*/
int sctp_prev_maxrto;
/* For association counting. */
sctp_listen_cnt_t *sctp_listen_cnt;
} sctp_t;
#define SCTP_TXQ_LEN(sctp) ((sctp)->sctp_unsent + (sctp)->sctp_unacked)
#define SCTP_TXQ_UPDATE(sctp) \
if ((sctp)->sctp_txq_full && SCTP_TXQ_LEN(sctp) <= \
(sctp)->sctp_connp->conn_sndlowat) { \
(sctp)->sctp_txq_full = 0; \
(sctp)->sctp_ulp_xmitted((sctp)->sctp_ulpd, \
B_FALSE); \
}
#endif /* (defined(_KERNEL) || defined(_KMEMUSER)) */
extern void sctp_ack_timer(sctp_t *);
extern size_t sctp_adaptation_code_param(sctp_t *, uchar_t *);
extern void sctp_adaptation_event(sctp_t *);
extern void sctp_add_err(sctp_t *, uint16_t, void *, size_t,
sctp_faddr_t *);
extern int sctp_add_faddr(sctp_t *, in6_addr_t *, int, boolean_t);
extern boolean_t sctp_add_ftsn_set(sctp_ftsn_set_t **, sctp_faddr_t *, mblk_t *,
uint_t *, uint32_t *);
extern void sctp_add_recvq(sctp_t *, mblk_t *, boolean_t,
ip_recv_attr_t *);
extern void sctp_add_unrec_parm(sctp_parm_hdr_t *, mblk_t **, boolean_t);
extern size_t sctp_addr_params(sctp_t *, int, uchar_t *, boolean_t);
extern mblk_t *sctp_add_proto_hdr(sctp_t *, sctp_faddr_t *, mblk_t *, int,
int *);
extern void sctp_addr_req(sctp_t *, mblk_t *);
extern sctp_t *sctp_addrlist2sctp(mblk_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
zoneid_t, sctp_stack_t *);
extern void sctp_check_adv_ack_pt(sctp_t *, mblk_t *, mblk_t *);
extern void sctp_assoc_event(sctp_t *, uint16_t, uint16_t,
sctp_chunk_hdr_t *);
extern void sctp_bind_hash_insert(sctp_tf_t *, sctp_t *, int);
extern void sctp_bind_hash_remove(sctp_t *);
extern int sctp_bindi(sctp_t *, in_port_t, boolean_t, int, in_port_t *);
extern int sctp_bind_add(sctp_t *, const void *, uint32_t, boolean_t,
in_port_t);
extern int sctp_bind_del(sctp_t *, const void *, uint32_t, boolean_t);
extern int sctp_build_hdrs(sctp_t *, int);
extern int sctp_check_abandoned_msg(sctp_t *, mblk_t *);
extern void sctp_clean_death(sctp_t *, int);
extern void sctp_close_eager(sctp_t *);
extern int sctp_compare_faddrsets(sctp_faddr_t *, sctp_faddr_t *);
extern void sctp_congest_reset(sctp_t *);
extern void sctp_conn_hash_insert(sctp_tf_t *, sctp_t *, int);
extern void sctp_conn_hash_remove(sctp_t *);
extern void sctp_conn_init(conn_t *);
extern sctp_t *sctp_conn_match(in6_addr_t **, uint32_t, in6_addr_t *,
uint32_t, zoneid_t, iaflags_t, sctp_stack_t *);
extern void sctp_conn_reclaim(void *);
extern sctp_t *sctp_conn_request(sctp_t *, mblk_t *, uint_t, uint_t,
sctp_init_chunk_t *, ip_recv_attr_t *);
extern uint32_t sctp_cumack(sctp_t *, uint32_t, mblk_t **);
extern sctp_t *sctp_create_eager(sctp_t *);
extern void sctp_dispatch_rput(queue_t *, sctp_t *, sctp_hdr_t *, mblk_t *,
uint_t, uint_t, in6_addr_t);
extern char *sctp_display(sctp_t *, char *);
extern void sctp_display_all(sctp_stack_t *);
extern void sctp_error_event(sctp_t *, sctp_chunk_hdr_t *, boolean_t);
extern void sctp_faddr_alive(sctp_t *, sctp_faddr_t *);
extern int sctp_faddr_dead(sctp_t *, sctp_faddr_t *, int);
extern void sctp_faddr_fini(void);
extern void sctp_faddr_init(void);
extern void sctp_fast_rexmit(sctp_t *);
extern void sctp_fill_sack(sctp_t *, unsigned char *, int);
extern uint32_t sctp_find_listener_conf(sctp_stack_t *, in_port_t);
extern void sctp_free_faddr_timers(sctp_t *);
extern void sctp_free_ftsn_set(sctp_ftsn_set_t *);
extern void sctp_free_msg(mblk_t *);
extern void sctp_free_reass(sctp_instr_t *);
extern void sctp_free_set(sctp_set_t *);
extern void sctp_ftsn_sets_fini(void);
extern void sctp_ftsn_sets_init(void);
extern int sctp_get_addrlist(sctp_t *, const void *, uint32_t *,
uchar_t **, int *, size_t *);
extern int sctp_get_addrparams(sctp_t *, sctp_t *, mblk_t *,
sctp_chunk_hdr_t *, uint_t *);
extern void sctp_get_dest(sctp_t *, sctp_faddr_t *);
extern void sctp_get_faddr_list(sctp_t *, uchar_t *, size_t);
extern mblk_t *sctp_get_first_sent(sctp_t *);
extern mblk_t *sctp_get_msg_to_send(sctp_t *, mblk_t **, mblk_t *, int *,
int32_t, uint32_t, sctp_faddr_t *);
extern void sctp_get_saddr_list(sctp_t *, uchar_t *, size_t);
extern int sctp_handle_error(sctp_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
mblk_t *, ip_recv_attr_t *);
extern void sctp_hash_destroy(sctp_stack_t *);
extern void sctp_hash_init(sctp_stack_t *);
extern void sctp_heartbeat_timer(sctp_t *);
extern void sctp_icmp_error(sctp_t *, mblk_t *);
extern void sctp_inc_taskq(sctp_stack_t *);
extern void sctp_info_req(sctp_t *, mblk_t *);
extern mblk_t *sctp_init_mp(sctp_t *, sctp_faddr_t *);
extern boolean_t sctp_initialize_params(sctp_t *, sctp_init_chunk_t *,
sctp_init_chunk_t *);
extern uint32_t sctp_init2vtag(sctp_chunk_hdr_t *);
extern void sctp_intf_event(sctp_t *, in6_addr_t, int, int);
extern void sctp_input_data(sctp_t *, mblk_t *, ip_recv_attr_t *);
extern void sctp_instream_cleanup(sctp_t *, boolean_t);
extern boolean_t sctp_is_a_faddr_clean(sctp_t *);
extern void *sctp_kstat_init(netstackid_t);
extern void sctp_kstat_fini(netstackid_t, kstat_t *);
extern void *sctp_kstat2_init(netstackid_t);
extern void sctp_kstat2_fini(netstackid_t, kstat_t *);
extern ssize_t sctp_link_abort(mblk_t *, uint16_t, char *, size_t, int,
boolean_t);
extern void sctp_listen_hash_insert(sctp_tf_t *, sctp_t *);
extern void sctp_listen_hash_remove(sctp_t *);
extern void sctp_listener_conf_cleanup(sctp_stack_t *);
extern sctp_t *sctp_lookup(sctp_t *, in6_addr_t *, sctp_tf_t *, uint32_t *,
int);
extern sctp_faddr_t *sctp_lookup_faddr(sctp_t *, in6_addr_t *);
extern mblk_t *sctp_make_err(sctp_t *, uint16_t, void *, size_t);
extern mblk_t *sctp_make_ftsn_chunk(sctp_t *, sctp_faddr_t *,
sctp_ftsn_set_t *, uint_t, uint32_t);
extern void sctp_make_ftsns(sctp_t *, mblk_t *, mblk_t *, mblk_t **,
sctp_faddr_t *, uint32_t *);
extern mblk_t *sctp_make_mp(sctp_t *, sctp_faddr_t *, int);
extern mblk_t *sctp_make_sack(sctp_t *, sctp_faddr_t *, mblk_t *);
extern void sctp_maxpsz_set(sctp_t *);
extern void sctp_move_faddr_timers(queue_t *, sctp_t *);
extern sctp_parm_hdr_t *sctp_next_parm(sctp_parm_hdr_t *, ssize_t *);
extern void sctp_ootb_shutdown_ack(mblk_t *, uint_t, ip_recv_attr_t *,
ip_stack_t *);
extern size_t sctp_options_param(const sctp_t *, void *, int);
extern size_t sctp_options_param_len(const sctp_t *, int);
extern void sctp_output(sctp_t *, uint_t);
extern void sctp_partial_delivery_event(sctp_t *);
extern int sctp_process_cookie(sctp_t *, sctp_chunk_hdr_t *, mblk_t *,
sctp_init_chunk_t **, sctp_hdr_t *, int *, in6_addr_t *,
ip_recv_attr_t *);
extern void sctp_process_err(sctp_t *);
extern void sctp_process_heartbeat(sctp_t *, sctp_chunk_hdr_t *);
extern void sctp_process_timer(sctp_t *);
extern void sctp_redo_faddr_srcs(sctp_t *);
extern void sctp_regift_xmitlist(sctp_t *);
extern void sctp_return_heartbeat(sctp_t *, sctp_chunk_hdr_t *, mblk_t *);
extern void sctp_rexmit(sctp_t *, sctp_faddr_t *);
extern mblk_t *sctp_rexmit_packet(sctp_t *, mblk_t **, mblk_t **,
sctp_faddr_t *, uint_t *);
extern void sctp_rexmit_timer(sctp_t *, sctp_faddr_t *);
extern sctp_faddr_t *sctp_rotate_faddr(sctp_t *, sctp_faddr_t *);
extern boolean_t sctp_sack(sctp_t *, mblk_t *);
extern int sctp_secure_restart_check(mblk_t *, sctp_chunk_hdr_t *,
uint32_t, int, sctp_stack_t *, ip_recv_attr_t *);
extern void sctp_send_abort(sctp_t *, uint32_t, uint16_t, char *, size_t,
mblk_t *, int, boolean_t, ip_recv_attr_t *);
extern void sctp_ootb_send_abort(uint32_t, uint16_t, char *, size_t,
const mblk_t *, int, boolean_t, ip_recv_attr_t *,
ip_stack_t *);
extern void sctp_send_cookie_ack(sctp_t *);
extern void sctp_send_cookie_echo(sctp_t *, sctp_chunk_hdr_t *, mblk_t *,
ip_recv_attr_t *);
extern void sctp_send_initack(sctp_t *, sctp_hdr_t *, sctp_chunk_hdr_t *,
mblk_t *, ip_recv_attr_t *);
extern void sctp_send_shutdown(sctp_t *, int);
extern void sctp_send_heartbeat(sctp_t *, sctp_faddr_t *);
extern void sctp_sendfail_event(sctp_t *, mblk_t *, int, boolean_t);
extern void sctp_set_faddr_current(sctp_t *, sctp_faddr_t *);
extern int sctp_set_hdraddrs(sctp_t *);
extern void sctp_set_saddr(sctp_t *, sctp_faddr_t *);
extern void sctp_sets_init(void);
extern void sctp_sets_fini(void);
extern void sctp_shutdown_event(sctp_t *);
extern void sctp_stop_faddr_timers(sctp_t *);
extern int sctp_shutdown_received(sctp_t *, sctp_chunk_hdr_t *, boolean_t,
boolean_t, sctp_faddr_t *);
extern void sctp_shutdown_complete(sctp_t *);
extern void sctp_set_if_mtu(sctp_t *);
extern void sctp_set_iplen(sctp_t *, mblk_t *, ip_xmit_attr_t *);
extern void sctp_set_ulp_prop(sctp_t *);
extern void sctp_ss_rexmit(sctp_t *);
extern void sctp_stack_cpu_add(sctp_stack_t *, processorid_t);
extern size_t sctp_supaddr_param_len(sctp_t *);
extern size_t sctp_supaddr_param(sctp_t *, uchar_t *);
extern void sctp_timer(sctp_t *, mblk_t *, clock_t);
extern mblk_t *sctp_timer_alloc(sctp_t *, pfv_t, int);
extern void sctp_timer_call(sctp_t *sctp, mblk_t *);
extern void sctp_timer_free(mblk_t *);
extern void sctp_timer_stop(mblk_t *);
extern void sctp_unlink_faddr(sctp_t *, sctp_faddr_t *);
extern void sctp_update_dce(sctp_t *sctp);
extern in_port_t sctp_update_next_port(in_port_t, zone_t *zone, sctp_stack_t *);
extern void sctp_update_rtt(sctp_t *, sctp_faddr_t *, clock_t);
extern void sctp_user_abort(sctp_t *, mblk_t *);
extern void sctp_validate_peer(sctp_t *);
extern int sctp_xmit_list_clean(sctp_t *, ssize_t);
extern void sctp_zap_addrs(sctp_t *);
extern void sctp_zap_faddrs(sctp_t *, int);
extern sctp_chunk_hdr_t *sctp_first_chunk(uchar_t *, ssize_t);
extern void sctp_send_shutdown_ack(sctp_t *, sctp_faddr_t *, boolean_t);
/* Contract private interface between SCTP and Clustering - PSARC/2005/602 */
extern void (*cl_sctp_listen)(sa_family_t, uchar_t *, uint_t, in_port_t);
extern void (*cl_sctp_unlisten)(sa_family_t, uchar_t *, uint_t, in_port_t);
extern void (*cl_sctp_connect)(sa_family_t, uchar_t *, uint_t, in_port_t,
uchar_t *, uint_t, in_port_t, boolean_t, cl_sctp_handle_t);
extern void (*cl_sctp_disconnect)(sa_family_t, cl_sctp_handle_t);
extern void (*cl_sctp_assoc_change)(sa_family_t, uchar_t *, size_t, uint_t,
uchar_t *, size_t, uint_t, int, cl_sctp_handle_t);
extern void (*cl_sctp_check_addrs)(sa_family_t, in_port_t, uchar_t **,
size_t, uint_t *, boolean_t);
#define RUN_SCTP(sctp) \
{ \
mutex_enter(&(sctp)->sctp_lock); \
while ((sctp)->sctp_running) \
cv_wait(&(sctp)->sctp_cv, &(sctp)->sctp_lock); \
(sctp)->sctp_running = B_TRUE; \
mutex_exit(&(sctp)->sctp_lock); \
}
/* Wake up recvq taskq */
#define WAKE_SCTP(sctp) \
{ \
mutex_enter(&(sctp)->sctp_lock); \
if ((sctp)->sctp_timer_mp != NULL) \
sctp_process_timer(sctp); \
(sctp)->sctp_running = B_FALSE; \
cv_broadcast(&(sctp)->sctp_cv); \
mutex_exit(&(sctp)->sctp_lock); \
}
#ifdef __cplusplus
}
#endif
#endif /* _INET_SCTP_SCTP_IMPL_H */