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