include/inet/sctp/sctp_impl.h

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