sys/netinet/sctp_sysctl.c

   1 /*-
   2  * Copyright (c) 2007, by Cisco Systems, Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * a) Redistributions of source code must retain the above copyright notice,
   8  *   this list of conditions and the following disclaimer.
   9  *
  10  * b) Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *   the documentation and/or other materials provided with the distribution.
  13  *
  14  * c) Neither the name of Cisco Systems, Inc. nor the names of its
  15  *    contributors may be used to endorse or promote products derived
  16  *    from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  28  * THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <netinet/sctp_os.h>
  35 #include <netinet/sctp.h>
  36 #include <netinet/sctp_constants.h>
  37 #include <netinet/sctp_sysctl.h>
  38 #include <netinet/sctp_pcb.h>
  39 #include <netinet/sctputil.h>
  40 #include <netinet/sctp_output.h>
  41 #include <sys/smp.h>
  42
  43 /*
  44  * sysctl tunable variables
  45  */
  46
  47 void
  48 sctp_init_sysctls()
  49 {
  50         SCTP_BASE_SYSCTL(sctp_sendspace) = SCTPCTL_MAXDGRAM_DEFAULT;
  51         SCTP_BASE_SYSCTL(sctp_recvspace) = SCTPCTL_RECVSPACE_DEFAULT;
  52         SCTP_BASE_SYSCTL(sctp_auto_asconf) = SCTPCTL_AUTOASCONF_DEFAULT;
  53         SCTP_BASE_SYSCTL(sctp_multiple_asconfs) = SCTPCTL_MULTIPLEASCONFS_DEFAULT;
  54         SCTP_BASE_SYSCTL(sctp_ecn_enable) = SCTPCTL_ECN_ENABLE_DEFAULT;
  55         SCTP_BASE_SYSCTL(sctp_ecn_nonce) = SCTPCTL_ECN_NONCE_DEFAULT;
  56         SCTP_BASE_SYSCTL(sctp_strict_sacks) = SCTPCTL_STRICT_SACKS_DEFAULT;
  57         SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) = SCTPCTL_LOOPBACK_NOCSUM_DEFAULT;
  58         SCTP_BASE_SYSCTL(sctp_strict_init) = SCTPCTL_STRICT_INIT_DEFAULT;
  59         SCTP_BASE_SYSCTL(sctp_peer_chunk_oh) = SCTPCTL_PEER_CHKOH_DEFAULT;
  60         SCTP_BASE_SYSCTL(sctp_max_burst_default) = SCTPCTL_MAXBURST_DEFAULT;
  61         SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue) = SCTPCTL_MAXCHUNKS_DEFAULT;
  62         SCTP_BASE_SYSCTL(sctp_hashtblsize) = SCTPCTL_TCBHASHSIZE_DEFAULT;
  63         SCTP_BASE_SYSCTL(sctp_pcbtblsize) = SCTPCTL_PCBHASHSIZE_DEFAULT;
  64         SCTP_BASE_SYSCTL(sctp_min_split_point) = SCTPCTL_MIN_SPLIT_POINT_DEFAULT;
  65         SCTP_BASE_SYSCTL(sctp_chunkscale) = SCTPCTL_CHUNKSCALE_DEFAULT;
  66         SCTP_BASE_SYSCTL(sctp_delayed_sack_time_default) = SCTPCTL_DELAYED_SACK_TIME_DEFAULT;
  67         SCTP_BASE_SYSCTL(sctp_sack_freq_default) = SCTPCTL_SACK_FREQ_DEFAULT;
  68         SCTP_BASE_SYSCTL(sctp_system_free_resc_limit) = SCTPCTL_SYS_RESOURCE_DEFAULT;
  69         SCTP_BASE_SYSCTL(sctp_asoc_free_resc_limit) = SCTPCTL_ASOC_RESOURCE_DEFAULT;
  70         SCTP_BASE_SYSCTL(sctp_heartbeat_interval_default) = SCTPCTL_HEARTBEAT_INTERVAL_DEFAULT;
  71         SCTP_BASE_SYSCTL(sctp_pmtu_raise_time_default) = SCTPCTL_PMTU_RAISE_TIME_DEFAULT;
  72         SCTP_BASE_SYSCTL(sctp_shutdown_guard_time_default) = SCTPCTL_SHUTDOWN_GUARD_TIME_DEFAULT;
  73         SCTP_BASE_SYSCTL(sctp_secret_lifetime_default) = SCTPCTL_SECRET_LIFETIME_DEFAULT;
  74         SCTP_BASE_SYSCTL(sctp_rto_max_default) = SCTPCTL_RTO_MAX_DEFAULT;
  75         SCTP_BASE_SYSCTL(sctp_rto_min_default) = SCTPCTL_RTO_MIN_DEFAULT;
  76         SCTP_BASE_SYSCTL(sctp_rto_initial_default) = SCTPCTL_RTO_INITIAL_DEFAULT;
  77         SCTP_BASE_SYSCTL(sctp_init_rto_max_default) = SCTPCTL_INIT_RTO_MAX_DEFAULT;
  78         SCTP_BASE_SYSCTL(sctp_valid_cookie_life_default) = SCTPCTL_VALID_COOKIE_LIFE_DEFAULT;
  79         SCTP_BASE_SYSCTL(sctp_init_rtx_max_default) = SCTPCTL_INIT_RTX_MAX_DEFAULT;
  80         SCTP_BASE_SYSCTL(sctp_assoc_rtx_max_default) = SCTPCTL_ASSOC_RTX_MAX_DEFAULT;
  81         SCTP_BASE_SYSCTL(sctp_path_rtx_max_default) = SCTPCTL_PATH_RTX_MAX_DEFAULT;
  82         SCTP_BASE_SYSCTL(sctp_add_more_threshold) = SCTPCTL_ADD_MORE_ON_OUTPUT_DEFAULT;
  83         SCTP_BASE_SYSCTL(sctp_nr_outgoing_streams_default) = SCTPCTL_OUTGOING_STREAMS_DEFAULT;
  84         SCTP_BASE_SYSCTL(sctp_cmt_on_off) = SCTPCTL_CMT_ON_OFF_DEFAULT;
  85         /* EY */
  86         SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) = SCTPCTL_NR_SACK_ON_OFF_DEFAULT;
  87         SCTP_BASE_SYSCTL(sctp_cmt_use_dac) = SCTPCTL_CMT_USE_DAC_DEFAULT;
  88         SCTP_BASE_SYSCTL(sctp_cmt_pf) = SCTPCTL_CMT_PF_DEFAULT;
  89         SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst) = SCTPCTL_CWND_MAXBURST_DEFAULT;
  90         SCTP_BASE_SYSCTL(sctp_early_fr) = SCTPCTL_EARLY_FAST_RETRAN_DEFAULT;
  91         SCTP_BASE_SYSCTL(sctp_early_fr_msec) = SCTPCTL_EARLY_FAST_RETRAN_MSEC_DEFAULT;
  92         SCTP_BASE_SYSCTL(sctp_asconf_auth_nochk) = SCTPCTL_ASCONF_AUTH_NOCHK_DEFAULT;
  93         SCTP_BASE_SYSCTL(sctp_auth_disable) = SCTPCTL_AUTH_DISABLE_DEFAULT;
  94         SCTP_BASE_SYSCTL(sctp_nat_friendly) = SCTPCTL_NAT_FRIENDLY_DEFAULT;
  95         SCTP_BASE_SYSCTL(sctp_L2_abc_variable) = SCTPCTL_ABC_L_VAR_DEFAULT;
  96         SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count) = SCTPCTL_MAX_CHAINED_MBUFS_DEFAULT;
  97         SCTP_BASE_SYSCTL(sctp_do_drain) = SCTPCTL_DO_SCTP_DRAIN_DEFAULT;
  98         SCTP_BASE_SYSCTL(sctp_hb_maxburst) = SCTPCTL_HB_MAX_BURST_DEFAULT;
  99         SCTP_BASE_SYSCTL(sctp_abort_if_one_2_one_hits_limit) = SCTPCTL_ABORT_AT_LIMIT_DEFAULT;
 100         SCTP_BASE_SYSCTL(sctp_strict_data_order) = SCTPCTL_STRICT_DATA_ORDER_DEFAULT;
 101         SCTP_BASE_SYSCTL(sctp_min_residual) = SCTPCTL_MIN_RESIDUAL_DEFAULT;
 102         SCTP_BASE_SYSCTL(sctp_max_retran_chunk) = SCTPCTL_MAX_RETRAN_CHUNK_DEFAULT;
 103         SCTP_BASE_SYSCTL(sctp_logging_level) = SCTPCTL_LOGGING_LEVEL_DEFAULT;
 104         /* JRS - Variable for default congestion control module */
 105         SCTP_BASE_SYSCTL(sctp_default_cc_module) = SCTPCTL_DEFAULT_CC_MODULE_DEFAULT;
 106         SCTP_BASE_SYSCTL(sctp_default_frag_interleave) = SCTPCTL_DEFAULT_FRAG_INTERLEAVE_DEFAULT;
 107         SCTP_BASE_SYSCTL(sctp_mobility_base) = SCTPCTL_MOBILITY_BASE_DEFAULT;
 108         SCTP_BASE_SYSCTL(sctp_mobility_fasthandoff) = SCTPCTL_MOBILITY_FASTHANDOFF_DEFAULT;
 109         SCTP_BASE_SYSCTL(sctp_vtag_time_wait) = SCTPCTL_TIME_WAIT_DEFAULT;
 110 #if defined(SCTP_LOCAL_TRACE_BUF)
 111         memset(&SCTP_BASE_SYSCTL(sctp_log), 0, sizeof(struct sctp_log));
 112 #endif
 113         SCTP_BASE_SYSCTL(sctp_udp_tunneling_for_client_enable) = SCTPCTL_UDP_TUNNELING_FOR_CLIENT_ENABLE_DEFAULT;
 114         SCTP_BASE_SYSCTL(sctp_udp_tunneling_port) = SCTPCTL_UDP_TUNNELING_PORT_DEFAULT;
 115         SCTP_BASE_SYSCTL(sctp_enable_sack_immediately) = SCTPCTL_SACK_IMMEDIATELY_ENABLE_DEFAULT;
 116         SCTP_BASE_SYSCTL(sctp_inits_include_nat_friendly) = SCTPCTL_NAT_FRIENDLY_INITS_DEFAULT;
 117 #if defined(SCTP_DEBUG)
 118         SCTP_BASE_SYSCTL(sctp_debug_on) = SCTPCTL_DEBUG_DEFAULT;
 119 #endif
 120 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
 121         SCTP_BASE_SYSCTL(sctp_output_unlocked) = SCTPCTL_OUTPUT_UNLOCKED_DEFAULT;
 122 #endif
 123 }
 124
 125
 126 /* It returns an upper limit. No filtering is done here */
 127 static unsigned int
 128 number_of_addresses(struct sctp_inpcb *inp)
 129 {
 130         int cnt;
 131         struct sctp_vrf *vrf;
 132         struct sctp_ifn *sctp_ifn;
 133         struct sctp_ifa *sctp_ifa;
 134         struct sctp_laddr *laddr;
 135
 136         cnt = 0;
 137         /* neither Mac OS X nor FreeBSD support mulitple routing functions */
 138         if ((vrf = sctp_find_vrf(inp->def_vrf_id)) == NULL) {
 139                 return (0);
 140         }
 141         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
 142                 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
 143                         LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
 144                                 if ((sctp_ifa->address.sa.sa_family == AF_INET) ||
 145                                     (sctp_ifa->address.sa.sa_family == AF_INET6)) {
 146                                         cnt++;
 147                                 }
 148                         }
 149                 }
 150         } else {
 151                 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
 152                         if ((laddr->ifa->address.sa.sa_family == AF_INET) ||
 153                             (laddr->ifa->address.sa.sa_family == AF_INET6)) {
 154                                 cnt++;
 155                         }
 156                 }
 157         }
 158         return (cnt);
 159 }
 160
 161 static int
 162 copy_out_local_addresses(struct sctp_inpcb *inp, struct sctp_tcb *stcb, struct sysctl_req *req)
 163 {
 164         struct sctp_ifn *sctp_ifn;
 165         struct sctp_ifa *sctp_ifa;
 166         int loopback_scope, ipv4_local_scope, local_scope, site_scope;
 167         int ipv4_addr_legal, ipv6_addr_legal;
 168         struct sctp_vrf *vrf;
 169         struct xsctp_laddr xladdr;
 170         struct sctp_laddr *laddr;
 171         int error;
 172
 173         /* Turn on all the appropriate scope */
 174         if (stcb) {
 175                 /* use association specific values */
 176                 loopback_scope = stcb->asoc.loopback_scope;
 177                 ipv4_local_scope = stcb->asoc.ipv4_local_scope;
 178                 local_scope = stcb->asoc.local_scope;
 179                 site_scope = stcb->asoc.site_scope;
 180         } else {
 181                 /* use generic values for endpoints */
 182                 loopback_scope = 1;
 183                 ipv4_local_scope = 1;
 184                 local_scope = 1;
 185                 site_scope = 1;
 186         }
 187
 188         /* use only address families of interest */
 189         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
 190                 ipv6_addr_legal = 1;
 191                 if (SCTP_IPV6_V6ONLY(inp)) {
 192                         ipv4_addr_legal = 0;
 193                 } else {
 194                         ipv4_addr_legal = 1;
 195                 }
 196         } else {
 197                 ipv4_addr_legal = 1;
 198                 ipv6_addr_legal = 0;
 199         }
 200
 201         error = 0;
 202
 203         /* neither Mac OS X nor FreeBSD support mulitple routing functions */
 204         if ((vrf = sctp_find_vrf(inp->def_vrf_id)) == NULL) {
 205                 SCTP_INP_RUNLOCK(inp);
 206                 SCTP_INP_INFO_RUNLOCK();
 207                 return (-1);
 208         }
 209         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
 210                 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
 211                         if ((loopback_scope == 0) && SCTP_IFN_IS_IFT_LOOP(sctp_ifn))
 212                                 /* Skip loopback if loopback_scope not set */
 213                                 continue;
 214                         LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
 215                                 if (stcb) {
 216                                         /*
 217                                          * ignore if blacklisted at
 218                                          * association level
 219                                          */
 220                                         if (sctp_is_addr_restricted(stcb, sctp_ifa))
 221                                                 continue;
 222                                 }
 223                                 switch (sctp_ifa->address.sa.sa_family) {
 224                                 case AF_INET:
 225                                         if (ipv4_addr_legal) {
 226                                                 struct sockaddr_in *sin;
 227
 228                                                 sin = (struct sockaddr_in *)&sctp_ifa->address.sa;
 229                                                 if (sin->sin_addr.s_addr == 0)
 230                                                         continue;
 231                                                 if ((ipv4_local_scope == 0) && (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr)))
 232                                                         continue;
 233                                         } else {
 234                                                 continue;
 235                                         }
 236                                         break;
 237 #ifdef INET6
 238                                 case AF_INET6:
 239                                         if (ipv6_addr_legal) {
 240                                                 struct sockaddr_in6 *sin6;
 241
 242                                                 sin6 = (struct sockaddr_in6 *)&sctp_ifa->address.sa;
 243                                                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
 244                                                         continue;
 245                                                 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
 246                                                         if (local_scope == 0)
 247                                                                 continue;
 248                                                         if (sin6->sin6_scope_id == 0) {
 249                                                                 /*
 250                                                                  * bad link
 251                                                                  * local
 252                                                                  * address
 253                                                                  */
 254                                                                 if (sa6_recoverscope(sin6) != 0)
 255                                                                         continue;
 256                                                         }
 257                                                 }
 258                                                 if ((site_scope == 0) && (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr)))
 259                                                         continue;
 260                                         } else {
 261                                                 continue;
 262                                         }
 263                                         break;
 264 #endif
 265                                 default:
 266                                         continue;
 267                                 }
 268                                 memset((void *)&xladdr, 0, sizeof(struct xsctp_laddr));
 269                                 memcpy((void *)&xladdr.address, (const void *)&sctp_ifa->address, sizeof(union sctp_sockstore));
 270                                 SCTP_INP_RUNLOCK(inp);
 271                                 SCTP_INP_INFO_RUNLOCK();
 272                                 error = SYSCTL_OUT(req, &xladdr, sizeof(struct xsctp_laddr));
 273                                 if (error) {
 274                                         return (error);
 275                                 } else {
 276                                         SCTP_INP_INFO_RLOCK();
 277                                         SCTP_INP_RLOCK(inp);
 278                                 }
 279                         }
 280                 }
 281         } else {
 282                 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
 283                         /* ignore if blacklisted at association level */
 284                         if (stcb && sctp_is_addr_restricted(stcb, laddr->ifa))
 285                                 continue;
 286                         memset((void *)&xladdr, 0, sizeof(struct xsctp_laddr));
 287                         memcpy((void *)&xladdr.address, (const void *)&laddr->ifa->address, sizeof(union sctp_sockstore));
 288                         xladdr.start_time.tv_sec = (uint32_t) laddr->start_time.tv_sec;
 289                         xladdr.start_time.tv_usec = (uint32_t) laddr->start_time.tv_usec;
 290                         SCTP_INP_RUNLOCK(inp);
 291                         SCTP_INP_INFO_RUNLOCK();
 292                         error = SYSCTL_OUT(req, &xladdr, sizeof(struct xsctp_laddr));
 293                         if (error) {
 294                                 return (error);
 295                         } else {
 296                                 SCTP_INP_INFO_RLOCK();
 297                                 SCTP_INP_RLOCK(inp);
 298                         }
 299                 }
 300         }
 301         memset((void *)&xladdr, 0, sizeof(struct xsctp_laddr));
 302         xladdr.last = 1;
 303         SCTP_INP_RUNLOCK(inp);
 304         SCTP_INP_INFO_RUNLOCK();
 305         error = SYSCTL_OUT(req, &xladdr, sizeof(struct xsctp_laddr));
 306
 307         if (error) {
 308                 return (error);
 309         } else {
 310                 SCTP_INP_INFO_RLOCK();
 311                 SCTP_INP_RLOCK(inp);
 312                 return (0);
 313         }
 314 }
 315
 316 /*
 317  * sysctl functions
 318  */
 319 static int
 320 sctp_assoclist(SYSCTL_HANDLER_ARGS)
 321 {
 322         unsigned int number_of_endpoints;
 323         unsigned int number_of_local_addresses;
 324         unsigned int number_of_associations;
 325         unsigned int number_of_remote_addresses;
 326         unsigned int n;
 327         int error;
 328         struct sctp_inpcb *inp;
 329         struct sctp_tcb *stcb;
 330         struct sctp_nets *net;
 331         struct xsctp_inpcb xinpcb;
 332         struct xsctp_tcb xstcb;
 333         struct xsctp_raddr xraddr;
 334         struct socket *so;
 335
 336         number_of_endpoints = 0;
 337         number_of_local_addresses = 0;
 338         number_of_associations = 0;
 339         number_of_remote_addresses = 0;
 340
 341         SCTP_INP_INFO_RLOCK();
 342         if (req->oldptr == USER_ADDR_NULL) {
 343                 LIST_FOREACH(inp, &SCTP_BASE_INFO(listhead), sctp_list) {
 344                         SCTP_INP_RLOCK(inp);
 345                         number_of_endpoints++;
 346                         number_of_local_addresses += number_of_addresses(inp);
 347                         LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
 348                                 number_of_associations++;
 349                                 number_of_local_addresses += number_of_addresses(inp);
 350                                 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
 351                                         number_of_remote_addresses++;
 352                                 }
 353                         }
 354                         SCTP_INP_RUNLOCK(inp);
 355                 }
 356                 SCTP_INP_INFO_RUNLOCK();
 357                 n = (number_of_endpoints + 1) * sizeof(struct xsctp_inpcb) +
 358                     (number_of_local_addresses + number_of_endpoints + number_of_associations) * sizeof(struct xsctp_laddr) +
 359                     (number_of_associations + number_of_endpoints) * sizeof(struct xsctp_tcb) +
 360                     (number_of_remote_addresses + number_of_associations) * sizeof(struct xsctp_raddr);
 361
 362                 /* request some more memory than needed */
 363                 req->oldidx = (n + n / 8);
 364                 return 0;
 365         }
 366         if (req->newptr != USER_ADDR_NULL) {
 367                 SCTP_INP_INFO_RUNLOCK();
 368                 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_SYSCTL, EPERM);
 369                 return EPERM;
 370         }
 371         LIST_FOREACH(inp, &SCTP_BASE_INFO(listhead), sctp_list) {
 372                 SCTP_INP_RLOCK(inp);
 373                 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) {
 374                         /* if its allgone it is being freed - skip it  */
 375                         goto skip;
 376                 }
 377                 xinpcb.last = 0;
 378                 xinpcb.local_port = ntohs(inp->sctp_lport);
 379                 xinpcb.flags = inp->sctp_flags;
 380                 xinpcb.features = inp->sctp_features;
 381                 xinpcb.total_sends = inp->total_sends;
 382                 xinpcb.total_recvs = inp->total_recvs;
 383                 xinpcb.total_nospaces = inp->total_nospaces;
 384                 xinpcb.fragmentation_point = inp->sctp_frag_point;
 385                 so = inp->sctp_socket;
 386                 if ((so == NULL) ||
 387                     (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
 388                         xinpcb.qlen = 0;
 389                         xinpcb.maxqlen = 0;
 390                 } else {
 391                         xinpcb.qlen = so->so_qlen;
 392                         xinpcb.maxqlen = so->so_qlimit;
 393                 }
 394                 SCTP_INP_INCR_REF(inp);
 395                 SCTP_INP_RUNLOCK(inp);
 396                 SCTP_INP_INFO_RUNLOCK();
 397                 error = SYSCTL_OUT(req, &xinpcb, sizeof(struct xsctp_inpcb));
 398                 if (error) {
 399                         SCTP_INP_DECR_REF(inp);
 400                         return error;
 401                 }
 402                 SCTP_INP_INFO_RLOCK();
 403                 SCTP_INP_RLOCK(inp);
 404                 error = copy_out_local_addresses(inp, NULL, req);
 405                 if (error) {
 406                         SCTP_INP_DECR_REF(inp);
 407                         return error;
 408                 }
 409                 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
 410                         SCTP_TCB_LOCK(stcb);
 411                         atomic_add_int(&stcb->asoc.refcnt, 1);
 412                         SCTP_TCB_UNLOCK(stcb);
 413                         xstcb.last = 0;
 414                         xstcb.local_port = ntohs(inp->sctp_lport);
 415                         xstcb.remote_port = ntohs(stcb->rport);
 416                         if (stcb->asoc.primary_destination != NULL)
 417                                 xstcb.primary_addr = stcb->asoc.primary_destination->ro._l_addr;
 418                         xstcb.heartbeat_interval = stcb->asoc.heart_beat_delay;
 419                         xstcb.state = SCTP_GET_STATE(&stcb->asoc);      /* FIXME */
 420                         /* 7.0 does not support these */
 421                         xstcb.assoc_id = sctp_get_associd(stcb);
 422                         xstcb.peers_rwnd = stcb->asoc.peers_rwnd;
 423                         xstcb.in_streams = stcb->asoc.streamincnt;
 424                         xstcb.out_streams = stcb->asoc.streamoutcnt;
 425                         xstcb.max_nr_retrans = stcb->asoc.overall_error_count;
 426                         xstcb.primary_process = 0;      /* not really supported
 427                                                          * yet */
 428                         xstcb.T1_expireries = stcb->asoc.timoinit + stcb->asoc.timocookie;
 429                         xstcb.T2_expireries = stcb->asoc.timoshutdown + stcb->asoc.timoshutdownack;
 430                         xstcb.retransmitted_tsns = stcb->asoc.marked_retrans;
 431                         xstcb.start_time.tv_sec = (uint32_t) stcb->asoc.start_time.tv_sec;
 432                         xstcb.start_time.tv_usec = (uint32_t) stcb->asoc.start_time.tv_usec;
 433                         xstcb.discontinuity_time.tv_sec = (uint32_t) stcb->asoc.discontinuity_time.tv_sec;
 434                         xstcb.discontinuity_time.tv_usec = (uint32_t) stcb->asoc.discontinuity_time.tv_usec;
 435                         xstcb.total_sends = stcb->total_sends;
 436                         xstcb.total_recvs = stcb->total_recvs;
 437                         xstcb.local_tag = stcb->asoc.my_vtag;
 438                         xstcb.remote_tag = stcb->asoc.peer_vtag;
 439                         xstcb.initial_tsn = stcb->asoc.init_seq_number;
 440                         xstcb.highest_tsn = stcb->asoc.sending_seq - 1;
 441                         xstcb.cumulative_tsn = stcb->asoc.last_acked_seq;
 442                         xstcb.cumulative_tsn_ack = stcb->asoc.cumulative_tsn;
 443                         xstcb.mtu = stcb->asoc.smallest_mtu;
 444                         xstcb.refcnt = stcb->asoc.refcnt;
 445                         SCTP_INP_RUNLOCK(inp);
 446                         SCTP_INP_INFO_RUNLOCK();
 447                         error = SYSCTL_OUT(req, &xstcb, sizeof(struct xsctp_tcb));
 448                         if (error) {
 449                                 SCTP_INP_DECR_REF(inp);
 450                                 atomic_subtract_int(&stcb->asoc.refcnt, 1);
 451                                 return error;
 452                         }
 453                         SCTP_INP_INFO_RLOCK();
 454                         SCTP_INP_RLOCK(inp);
 455                         error = copy_out_local_addresses(inp, stcb, req);
 456                         if (error) {
 457                                 SCTP_INP_DECR_REF(inp);
 458                                 atomic_subtract_int(&stcb->asoc.refcnt, 1);
 459                                 return error;
 460                         }
 461                         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
 462                                 xraddr.last = 0;
 463                                 xraddr.address = net->ro._l_addr;
 464                                 xraddr.active = ((net->dest_state & SCTP_ADDR_REACHABLE) == SCTP_ADDR_REACHABLE);
 465                                 xraddr.confirmed = ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0);
 466                                 xraddr.heartbeat_enabled = ((net->dest_state & SCTP_ADDR_NOHB) == 0);
 467                                 xraddr.rto = net->RTO;
 468                                 xraddr.max_path_rtx = net->failure_threshold;
 469                                 xraddr.rtx = net->marked_retrans;
 470                                 xraddr.error_counter = net->error_count;
 471                                 xraddr.cwnd = net->cwnd;
 472                                 xraddr.flight_size = net->flight_size;
 473                                 xraddr.mtu = net->mtu;
 474                                 xraddr.rtt = net->rtt;
 475                                 xraddr.start_time.tv_sec = (uint32_t) net->start_time.tv_sec;
 476                                 xraddr.start_time.tv_usec = (uint32_t) net->start_time.tv_usec;
 477                                 SCTP_INP_RUNLOCK(inp);
 478                                 SCTP_INP_INFO_RUNLOCK();
 479                                 error = SYSCTL_OUT(req, &xraddr, sizeof(struct xsctp_raddr));
 480                                 if (error) {
 481                                         SCTP_INP_DECR_REF(inp);
 482                                         atomic_subtract_int(&stcb->asoc.refcnt, 1);
 483                                         return error;
 484                                 }
 485                                 SCTP_INP_INFO_RLOCK();
 486                                 SCTP_INP_RLOCK(inp);
 487                         }
 488                         atomic_subtract_int(&stcb->asoc.refcnt, 1);
 489                         memset((void *)&xraddr, 0, sizeof(struct xsctp_raddr));
 490                         xraddr.last = 1;
 491                         SCTP_INP_RUNLOCK(inp);
 492                         SCTP_INP_INFO_RUNLOCK();
 493                         error = SYSCTL_OUT(req, &xraddr, sizeof(struct xsctp_raddr));
 494                         if (error) {
 495                                 SCTP_INP_DECR_REF(inp);
 496                                 return error;
 497                         }
 498                         SCTP_INP_INFO_RLOCK();
 499                         SCTP_INP_RLOCK(inp);
 500                 }
 501                 SCTP_INP_DECR_REF(inp);
 502                 SCTP_INP_RUNLOCK(inp);
 503                 SCTP_INP_INFO_RUNLOCK();
 504                 memset((void *)&xstcb, 0, sizeof(struct xsctp_tcb));
 505                 xstcb.last = 1;
 506                 error = SYSCTL_OUT(req, &xstcb, sizeof(struct xsctp_tcb));
 507                 if (error) {
 508                         return error;
 509                 }
 510 skip:
 511                 SCTP_INP_INFO_RLOCK();
 512         }
 513         SCTP_INP_INFO_RUNLOCK();
 514
 515         memset((void *)&xinpcb, 0, sizeof(struct xsctp_inpcb));
 516         xinpcb.last = 1;
 517         error = SYSCTL_OUT(req, &xinpcb, sizeof(struct xsctp_inpcb));
 518         return error;
 519 }
 520
 521
 522 #define RANGECHK(var, min, max) \
 523         if ((var) < (min)) { (var) = (min); } \
 524         else if ((var) > (max)) { (var) = (max); }
 525
 526 static int
 527 sysctl_sctp_udp_tunneling_check(SYSCTL_HANDLER_ARGS)
 528 {
 529         int error;
 530         uint32_t old_sctp_udp_tunneling_port;
 531
 532         SCTP_INP_INFO_RLOCK();
 533         old_sctp_udp_tunneling_port = SCTP_BASE_SYSCTL(sctp_udp_tunneling_port);
 534         SCTP_INP_INFO_RUNLOCK();
 535         error = sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
 536         if (error == 0) {
 537                 RANGECHK(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port), SCTPCTL_UDP_TUNNELING_PORT_MIN, SCTPCTL_UDP_TUNNELING_PORT_MAX);
 538                 if (old_sctp_udp_tunneling_port == SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)) {
 539                         error = 0;
 540                         goto out;
 541                 }
 542                 SCTP_INP_INFO_WLOCK();
 543                 if (old_sctp_udp_tunneling_port) {
 544                         sctp_over_udp_stop();
 545                 }
 546                 if (SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)) {
 547                         if (sctp_over_udp_start()) {
 548                                 SCTP_BASE_SYSCTL(sctp_udp_tunneling_port) = 0;
 549                         }
 550                 }
 551                 SCTP_INP_INFO_WUNLOCK();
 552         }
 553 out:
 554         return (error);
 555 }
 556
 557
 558 static int
 559 sysctl_sctp_check(SYSCTL_HANDLER_ARGS)
 560 {
 561         int error;
 562
 563         error = sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
 564         if (error == 0) {
 565                 RANGECHK(SCTP_BASE_SYSCTL(sctp_sendspace), SCTPCTL_MAXDGRAM_MIN, SCTPCTL_MAXDGRAM_MAX);
 566                 RANGECHK(SCTP_BASE_SYSCTL(sctp_recvspace), SCTPCTL_RECVSPACE_MIN, SCTPCTL_RECVSPACE_MAX);
 567                 RANGECHK(SCTP_BASE_SYSCTL(sctp_auto_asconf), SCTPCTL_AUTOASCONF_MIN, SCTPCTL_AUTOASCONF_MAX);
 568                 RANGECHK(SCTP_BASE_SYSCTL(sctp_ecn_enable), SCTPCTL_ECN_ENABLE_MIN, SCTPCTL_ECN_ENABLE_MAX);
 569                 RANGECHK(SCTP_BASE_SYSCTL(sctp_ecn_nonce), SCTPCTL_ECN_NONCE_MIN, SCTPCTL_ECN_NONCE_MAX);
 570                 RANGECHK(SCTP_BASE_SYSCTL(sctp_strict_sacks), SCTPCTL_STRICT_SACKS_MIN, SCTPCTL_STRICT_SACKS_MAX);
 571                 RANGECHK(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback), SCTPCTL_LOOPBACK_NOCSUM_MIN, SCTPCTL_LOOPBACK_NOCSUM_MAX);
 572                 RANGECHK(SCTP_BASE_SYSCTL(sctp_strict_init), SCTPCTL_STRICT_INIT_MIN, SCTPCTL_STRICT_INIT_MAX);
 573                 RANGECHK(SCTP_BASE_SYSCTL(sctp_peer_chunk_oh), SCTPCTL_PEER_CHKOH_MIN, SCTPCTL_PEER_CHKOH_MAX);
 574                 RANGECHK(SCTP_BASE_SYSCTL(sctp_max_burst_default), SCTPCTL_MAXBURST_MIN, SCTPCTL_MAXBURST_MAX);
 575                 RANGECHK(SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue), SCTPCTL_MAXCHUNKS_MIN, SCTPCTL_MAXCHUNKS_MAX);
 576                 RANGECHK(SCTP_BASE_SYSCTL(sctp_hashtblsize), SCTPCTL_TCBHASHSIZE_MIN, SCTPCTL_TCBHASHSIZE_MAX);
 577                 RANGECHK(SCTP_BASE_SYSCTL(sctp_pcbtblsize), SCTPCTL_PCBHASHSIZE_MIN, SCTPCTL_PCBHASHSIZE_MAX);
 578                 RANGECHK(SCTP_BASE_SYSCTL(sctp_min_split_point), SCTPCTL_MIN_SPLIT_POINT_MIN, SCTPCTL_MIN_SPLIT_POINT_MAX);
 579                 RANGECHK(SCTP_BASE_SYSCTL(sctp_chunkscale), SCTPCTL_CHUNKSCALE_MIN, SCTPCTL_CHUNKSCALE_MAX);
 580                 RANGECHK(SCTP_BASE_SYSCTL(sctp_delayed_sack_time_default), SCTPCTL_DELAYED_SACK_TIME_MIN, SCTPCTL_DELAYED_SACK_TIME_MAX);
 581                 RANGECHK(SCTP_BASE_SYSCTL(sctp_sack_freq_default), SCTPCTL_SACK_FREQ_MIN, SCTPCTL_SACK_FREQ_MAX);
 582                 RANGECHK(SCTP_BASE_SYSCTL(sctp_system_free_resc_limit), SCTPCTL_SYS_RESOURCE_MIN, SCTPCTL_SYS_RESOURCE_MAX);
 583                 RANGECHK(SCTP_BASE_SYSCTL(sctp_asoc_free_resc_limit), SCTPCTL_ASOC_RESOURCE_MIN, SCTPCTL_ASOC_RESOURCE_MAX);
 584                 RANGECHK(SCTP_BASE_SYSCTL(sctp_heartbeat_interval_default), SCTPCTL_HEARTBEAT_INTERVAL_MIN, SCTPCTL_HEARTBEAT_INTERVAL_MAX);
 585                 RANGECHK(SCTP_BASE_SYSCTL(sctp_pmtu_raise_time_default), SCTPCTL_PMTU_RAISE_TIME_MIN, SCTPCTL_PMTU_RAISE_TIME_MAX);
 586                 RANGECHK(SCTP_BASE_SYSCTL(sctp_shutdown_guard_time_default), SCTPCTL_SHUTDOWN_GUARD_TIME_MIN, SCTPCTL_SHUTDOWN_GUARD_TIME_MAX);
 587                 RANGECHK(SCTP_BASE_SYSCTL(sctp_secret_lifetime_default), SCTPCTL_SECRET_LIFETIME_MIN, SCTPCTL_SECRET_LIFETIME_MAX);
 588                 RANGECHK(SCTP_BASE_SYSCTL(sctp_rto_max_default), SCTPCTL_RTO_MAX_MIN, SCTPCTL_RTO_MAX_MAX);
 589                 RANGECHK(SCTP_BASE_SYSCTL(sctp_rto_min_default), SCTPCTL_RTO_MIN_MIN, SCTPCTL_RTO_MIN_MAX);
 590                 RANGECHK(SCTP_BASE_SYSCTL(sctp_rto_initial_default), SCTPCTL_RTO_INITIAL_MIN, SCTPCTL_RTO_INITIAL_MAX);
 591                 RANGECHK(SCTP_BASE_SYSCTL(sctp_init_rto_max_default), SCTPCTL_INIT_RTO_MAX_MIN, SCTPCTL_INIT_RTO_MAX_MAX);
 592                 RANGECHK(SCTP_BASE_SYSCTL(sctp_valid_cookie_life_default), SCTPCTL_VALID_COOKIE_LIFE_MIN, SCTPCTL_VALID_COOKIE_LIFE_MAX);
 593                 RANGECHK(SCTP_BASE_SYSCTL(sctp_init_rtx_max_default), SCTPCTL_INIT_RTX_MAX_MIN, SCTPCTL_INIT_RTX_MAX_MAX);
 594                 RANGECHK(SCTP_BASE_SYSCTL(sctp_assoc_rtx_max_default), SCTPCTL_ASSOC_RTX_MAX_MIN, SCTPCTL_ASSOC_RTX_MAX_MAX);
 595                 RANGECHK(SCTP_BASE_SYSCTL(sctp_path_rtx_max_default), SCTPCTL_PATH_RTX_MAX_MIN, SCTPCTL_PATH_RTX_MAX_MAX);
 596                 RANGECHK(SCTP_BASE_SYSCTL(sctp_add_more_threshold), SCTPCTL_ADD_MORE_ON_OUTPUT_MIN, SCTPCTL_ADD_MORE_ON_OUTPUT_MAX);
 597                 RANGECHK(SCTP_BASE_SYSCTL(sctp_nr_outgoing_streams_default), SCTPCTL_OUTGOING_STREAMS_MIN, SCTPCTL_OUTGOING_STREAMS_MAX);
 598                 RANGECHK(SCTP_BASE_SYSCTL(sctp_cmt_on_off), SCTPCTL_CMT_ON_OFF_MIN, SCTPCTL_CMT_ON_OFF_MAX);
 599                 /* EY */
 600                 RANGECHK(SCTP_BASE_SYSCTL(sctp_nr_sack_on_off), SCTPCTL_NR_SACK_ON_OFF_MIN, SCTPCTL_NR_SACK_ON_OFF_MAX);
 601                 RANGECHK(SCTP_BASE_SYSCTL(sctp_cmt_use_dac), SCTPCTL_CMT_USE_DAC_MIN, SCTPCTL_CMT_USE_DAC_MAX);
 602                 RANGECHK(SCTP_BASE_SYSCTL(sctp_cmt_pf), SCTPCTL_CMT_PF_MIN, SCTPCTL_CMT_PF_MAX);
 603                 RANGECHK(SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst), SCTPCTL_CWND_MAXBURST_MIN, SCTPCTL_CWND_MAXBURST_MAX);
 604                 RANGECHK(SCTP_BASE_SYSCTL(sctp_early_fr), SCTPCTL_EARLY_FAST_RETRAN_MIN, SCTPCTL_EARLY_FAST_RETRAN_MAX);
 605                 RANGECHK(SCTP_BASE_SYSCTL(sctp_early_fr_msec), SCTPCTL_EARLY_FAST_RETRAN_MSEC_MIN, SCTPCTL_EARLY_FAST_RETRAN_MSEC_MAX);
 606                 RANGECHK(SCTP_BASE_SYSCTL(sctp_asconf_auth_nochk), SCTPCTL_ASCONF_AUTH_NOCHK_MIN, SCTPCTL_ASCONF_AUTH_NOCHK_MAX);
 607                 RANGECHK(SCTP_BASE_SYSCTL(sctp_auth_disable), SCTPCTL_AUTH_DISABLE_MIN, SCTPCTL_AUTH_DISABLE_MAX);
 608                 RANGECHK(SCTP_BASE_SYSCTL(sctp_nat_friendly), SCTPCTL_NAT_FRIENDLY_MIN, SCTPCTL_NAT_FRIENDLY_MAX);
 609                 RANGECHK(SCTP_BASE_SYSCTL(sctp_L2_abc_variable), SCTPCTL_ABC_L_VAR_MIN, SCTPCTL_ABC_L_VAR_MAX);
 610                 RANGECHK(SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count), SCTPCTL_MAX_CHAINED_MBUFS_MIN, SCTPCTL_MAX_CHAINED_MBUFS_MAX);
 611                 RANGECHK(SCTP_BASE_SYSCTL(sctp_do_drain), SCTPCTL_DO_SCTP_DRAIN_MIN, SCTPCTL_DO_SCTP_DRAIN_MAX);
 612                 RANGECHK(SCTP_BASE_SYSCTL(sctp_hb_maxburst), SCTPCTL_HB_MAX_BURST_MIN, SCTPCTL_HB_MAX_BURST_MAX);
 613                 RANGECHK(SCTP_BASE_SYSCTL(sctp_abort_if_one_2_one_hits_limit), SCTPCTL_ABORT_AT_LIMIT_MIN, SCTPCTL_ABORT_AT_LIMIT_MAX);
 614                 RANGECHK(SCTP_BASE_SYSCTL(sctp_strict_data_order), SCTPCTL_STRICT_DATA_ORDER_MIN, SCTPCTL_STRICT_DATA_ORDER_MAX);
 615                 RANGECHK(SCTP_BASE_SYSCTL(sctp_min_residual), SCTPCTL_MIN_RESIDUAL_MIN, SCTPCTL_MIN_RESIDUAL_MAX);
 616                 RANGECHK(SCTP_BASE_SYSCTL(sctp_max_retran_chunk), SCTPCTL_MAX_RETRAN_CHUNK_MIN, SCTPCTL_MAX_RETRAN_CHUNK_MAX);
 617                 RANGECHK(SCTP_BASE_SYSCTL(sctp_logging_level), SCTPCTL_LOGGING_LEVEL_MIN, SCTPCTL_LOGGING_LEVEL_MAX);
 618                 RANGECHK(SCTP_BASE_SYSCTL(sctp_default_cc_module), SCTPCTL_DEFAULT_CC_MODULE_MIN, SCTPCTL_DEFAULT_CC_MODULE_MAX);
 619                 RANGECHK(SCTP_BASE_SYSCTL(sctp_default_frag_interleave), SCTPCTL_DEFAULT_FRAG_INTERLEAVE_MIN, SCTPCTL_DEFAULT_FRAG_INTERLEAVE_MAX);
 620                 RANGECHK(SCTP_BASE_SYSCTL(sctp_vtag_time_wait), SCTPCTL_TIME_WAIT_MIN, SCTPCTL_TIME_WAIT_MAX);
 621
 622                 RANGECHK(SCTP_BASE_SYSCTL(sctp_mobility_base), SCTPCTL_MOBILITY_BASE_MIN, SCTPCTL_MOBILITY_BASE_MAX);
 623                 RANGECHK(SCTP_BASE_SYSCTL(sctp_mobility_fasthandoff), SCTPCTL_MOBILITY_FASTHANDOFF_MIN, SCTPCTL_MOBILITY_FASTHANDOFF_MAX);
 624                 RANGECHK(SCTP_BASE_SYSCTL(sctp_udp_tunneling_for_client_enable), SCTPCTL_UDP_TUNNELING_FOR_CLIENT_ENABLE_MIN, SCTPCTL_UDP_TUNNELING_FOR_CLIENT_ENABLE_MAX);
 625                 RANGECHK(SCTP_BASE_SYSCTL(sctp_enable_sack_immediately), SCTPCTL_SACK_IMMEDIATELY_ENABLE_MIN, SCTPCTL_SACK_IMMEDIATELY_ENABLE_MAX);
 626                 RANGECHK(SCTP_BASE_SYSCTL(sctp_inits_include_nat_friendly), SCTPCTL_NAT_FRIENDLY_INITS_MIN, SCTPCTL_NAT_FRIENDLY_INITS_MAX);
 627
 628 #ifdef SCTP_DEBUG
 629                 RANGECHK(SCTP_BASE_SYSCTL(sctp_debug_on), SCTPCTL_DEBUG_MIN, SCTPCTL_DEBUG_MAX);
 630 #endif
 631 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
 632                 RANGECHK(SCTP_BASE_SYSCTL(sctp_output_unlocked), SCTPCTL_OUTPUT_UNLOCKED_MIN, SCTPCTL_OUTPUT_UNLOCKED_MAX);
 633 #endif
 634         }
 635         return (error);
 636 }
 637
 638 #if defined(__FreeBSD__) && defined(SMP) && defined(SCTP_USE_PERCPU_STAT)
 639 static int
 640 sysctl_stat_get(SYSCTL_HANDLER_ARGS)
 641 {
 642         int cpu, error;
 643         struct sctpstat sb, *sarry;
 644
 645         memset(&sb, 0, sizeof(sb));
 646         for (cpu = 0; cpu < mp_ncpus; cpu++) {
 647                 sarry = &SCTP_BASE_STATS[cpu];
 648                 if (sarry->sctps_discontinuitytime.tv_sec > sb.sctps_discontinuitytime.tv_sec) {
 649                         sb.sctps_discontinuitytime.tv_sec = sarry->sctps_discontinuitytime.tv_sec;
 650                         sb.sctps_discontinuitytime.tv_usec = sarry->sctps_discontinuitytime.tv_usec;
 651                 }
 652                 sb.sctps_currestab += sarry->sctps_currestab;
 653                 sb.sctps_activeestab += sarry->sctps_activeestab;
 654                 sb.sctps_restartestab += sarry->sctps_restartestab;
 655                 sb.sctps_collisionestab += sarry->sctps_collisionestab;
 656                 sb.sctps_passiveestab += sarry->sctps_passiveestab;
 657                 sb.sctps_aborted += sarry->sctps_aborted;
 658                 sb.sctps_shutdown += sarry->sctps_shutdown;
 659                 sb.sctps_outoftheblue += sarry->sctps_outoftheblue;
 660                 sb.sctps_checksumerrors += sarry->sctps_checksumerrors;
 661                 sb.sctps_outcontrolchunks += sarry->sctps_outcontrolchunks;
 662                 sb.sctps_outorderchunks += sarry->sctps_outorderchunks;
 663                 sb.sctps_outunorderchunks += sarry->sctps_outunorderchunks;
 664                 sb.sctps_incontrolchunks += sarry->sctps_incontrolchunks;
 665                 sb.sctps_inorderchunks += sarry->sctps_inorderchunks;
 666                 sb.sctps_inunorderchunks += sarry->sctps_inunorderchunks;
 667                 sb.sctps_fragusrmsgs += sarry->sctps_fragusrmsgs;
 668                 sb.sctps_reasmusrmsgs += sarry->sctps_reasmusrmsgs;
 669                 sb.sctps_outpackets += sarry->sctps_outpackets;
 670                 sb.sctps_inpackets += sarry->sctps_inpackets;
 671                 sb.sctps_recvpackets += sarry->sctps_recvpackets;
 672                 sb.sctps_recvdatagrams += sarry->sctps_recvdatagrams;
 673                 sb.sctps_recvpktwithdata += sarry->sctps_recvpktwithdata;
 674                 sb.sctps_recvsacks += sarry->sctps_recvsacks;
 675                 sb.sctps_recvdata += sarry->sctps_recvdata;
 676                 sb.sctps_recvdupdata += sarry->sctps_recvdupdata;
 677                 sb.sctps_recvheartbeat += sarry->sctps_recvheartbeat;
 678                 sb.sctps_recvheartbeatack += sarry->sctps_recvheartbeatack;
 679                 sb.sctps_recvecne += sarry->sctps_recvecne;
 680                 sb.sctps_recvauth += sarry->sctps_recvauth;
 681                 sb.sctps_recvauthmissing += sarry->sctps_recvauthmissing;
 682                 sb.sctps_recvivalhmacid += sarry->sctps_recvivalhmacid;
 683                 sb.sctps_recvivalkeyid += sarry->sctps_recvivalkeyid;
 684                 sb.sctps_recvauthfailed += sarry->sctps_recvauthfailed;
 685                 sb.sctps_recvexpress += sarry->sctps_recvexpress;
 686                 sb.sctps_recvexpressm += sarry->sctps_recvexpressm;
 687                 sb.sctps_recvnocrc += sarry->sctps_recvnocrc;
 688                 sb.sctps_recvswcrc += sarry->sctps_recvswcrc;
 689                 sb.sctps_recvhwcrc += sarry->sctps_recvhwcrc;
 690                 sb.sctps_sendpackets += sarry->sctps_sendpackets;
 691                 sb.sctps_sendsacks += sarry->sctps_sendsacks;
 692                 sb.sctps_senddata += sarry->sctps_senddata;
 693                 sb.sctps_sendretransdata += sarry->sctps_sendretransdata;
 694                 sb.sctps_sendfastretrans += sarry->sctps_sendfastretrans;
 695                 sb.sctps_sendmultfastretrans += sarry->sctps_sendmultfastretrans;
 696                 sb.sctps_sendheartbeat += sarry->sctps_sendheartbeat;
 697                 sb.sctps_sendecne += sarry->sctps_sendecne;
 698                 sb.sctps_sendauth += sarry->sctps_sendauth;
 699                 sb.sctps_senderrors += sarry->sctps_senderrors;
 700                 sb.sctps_sendnocrc += sarry->sctps_sendnocrc;
 701                 sb.sctps_sendswcrc += sarry->sctps_sendswcrc;
 702                 sb.sctps_sendhwcrc += sarry->sctps_sendhwcrc;
 703                 sb.sctps_pdrpfmbox += sarry->sctps_pdrpfmbox;
 704                 sb.sctps_pdrpfehos += sarry->sctps_pdrpfehos;
 705                 sb.sctps_pdrpmbda += sarry->sctps_pdrpmbda;
 706                 sb.sctps_pdrpmbct += sarry->sctps_pdrpmbct;
 707                 sb.sctps_pdrpbwrpt += sarry->sctps_pdrpbwrpt;
 708                 sb.sctps_pdrpcrupt += sarry->sctps_pdrpcrupt;
 709                 sb.sctps_pdrpnedat += sarry->sctps_pdrpnedat;
 710                 sb.sctps_pdrppdbrk += sarry->sctps_pdrppdbrk;
 711                 sb.sctps_pdrptsnnf += sarry->sctps_pdrptsnnf;
 712                 sb.sctps_pdrpdnfnd += sarry->sctps_pdrpdnfnd;
 713                 sb.sctps_pdrpdiwnp += sarry->sctps_pdrpdiwnp;
 714                 sb.sctps_pdrpdizrw += sarry->sctps_pdrpdizrw;
 715                 sb.sctps_pdrpbadd += sarry->sctps_pdrpbadd;
 716                 sb.sctps_pdrpmark += sarry->sctps_pdrpmark;
 717                 sb.sctps_timoiterator += sarry->sctps_timoiterator;
 718                 sb.sctps_timodata += sarry->sctps_timodata;
 719                 sb.sctps_timowindowprobe += sarry->sctps_timowindowprobe;
 720                 sb.sctps_timoinit += sarry->sctps_timoinit;
 721                 sb.sctps_timosack += sarry->sctps_timosack;
 722                 sb.sctps_timoshutdown += sarry->sctps_timoshutdown;
 723                 sb.sctps_timoheartbeat += sarry->sctps_timoheartbeat;
 724                 sb.sctps_timocookie += sarry->sctps_timocookie;
 725                 sb.sctps_timosecret += sarry->sctps_timosecret;
 726                 sb.sctps_timopathmtu += sarry->sctps_timopathmtu;
 727                 sb.sctps_timoshutdownack += sarry->sctps_timoshutdownack;
 728                 sb.sctps_timoshutdownguard += sarry->sctps_timoshutdownguard;
 729                 sb.sctps_timostrmrst += sarry->sctps_timostrmrst;
 730                 sb.sctps_timoearlyfr += sarry->sctps_timoearlyfr;
 731                 sb.sctps_timoasconf += sarry->sctps_timoasconf;
 732                 sb.sctps_timodelprim += sarry->sctps_timodelprim;
 733                 sb.sctps_timoautoclose += sarry->sctps_timoautoclose;
 734                 sb.sctps_timoassockill += sarry->sctps_timoassockill;
 735                 sb.sctps_timoinpkill += sarry->sctps_timoinpkill;
 736                 sb.sctps_earlyfrstart += sarry->sctps_earlyfrstart;
 737                 sb.sctps_earlyfrstop += sarry->sctps_earlyfrstop;
 738                 sb.sctps_earlyfrmrkretrans += sarry->sctps_earlyfrmrkretrans;
 739                 sb.sctps_earlyfrstpout += sarry->sctps_earlyfrstpout;
 740                 sb.sctps_earlyfrstpidsck1 += sarry->sctps_earlyfrstpidsck1;
 741                 sb.sctps_earlyfrstpidsck2 += sarry->sctps_earlyfrstpidsck2;
 742                 sb.sctps_earlyfrstpidsck3 += sarry->sctps_earlyfrstpidsck3;
 743                 sb.sctps_earlyfrstpidsck4 += sarry->sctps_earlyfrstpidsck4;
 744                 sb.sctps_earlyfrstrid += sarry->sctps_earlyfrstrid;
 745                 sb.sctps_earlyfrstrout += sarry->sctps_earlyfrstrout;
 746                 sb.sctps_earlyfrstrtmr += sarry->sctps_earlyfrstrtmr;
 747                 sb.sctps_hdrops += sarry->sctps_hdrops;
 748                 sb.sctps_badsum += sarry->sctps_badsum;
 749                 sb.sctps_noport += sarry->sctps_noport;
 750                 sb.sctps_badvtag += sarry->sctps_badvtag;
 751                 sb.sctps_badsid += sarry->sctps_badsid;
 752                 sb.sctps_nomem += sarry->sctps_nomem;
 753                 sb.sctps_fastretransinrtt += sarry->sctps_fastretransinrtt;
 754                 sb.sctps_markedretrans += sarry->sctps_markedretrans;
 755                 sb.sctps_naglesent += sarry->sctps_naglesent;
 756                 sb.sctps_naglequeued += sarry->sctps_naglequeued;
 757                 sb.sctps_maxburstqueued += sarry->sctps_maxburstqueued;
 758                 sb.sctps_ifnomemqueued += sarry->sctps_ifnomemqueued;
 759                 sb.sctps_windowprobed += sarry->sctps_windowprobed;
 760                 sb.sctps_lowlevelerr += sarry->sctps_lowlevelerr;
 761                 sb.sctps_lowlevelerrusr += sarry->sctps_lowlevelerrusr;
 762                 sb.sctps_datadropchklmt += sarry->sctps_datadropchklmt;
 763                 sb.sctps_datadroprwnd += sarry->sctps_datadroprwnd;
 764                 sb.sctps_ecnereducedcwnd += sarry->sctps_ecnereducedcwnd;
 765                 sb.sctps_vtagexpress += sarry->sctps_vtagexpress;
 766                 sb.sctps_vtagbogus += sarry->sctps_vtagbogus;
 767                 sb.sctps_primary_randry += sarry->sctps_primary_randry;
 768                 sb.sctps_cmt_randry += sarry->sctps_cmt_randry;
 769                 sb.sctps_slowpath_sack += sarry->sctps_slowpath_sack;
 770                 sb.sctps_wu_sacks_sent += sarry->sctps_wu_sacks_sent;
 771                 sb.sctps_sends_with_flags += sarry->sctps_sends_with_flags;
 772                 sb.sctps_sends_with_unord += sarry->sctps_sends_with_unord;
 773                 sb.sctps_sends_with_eof += sarry->sctps_sends_with_eof;
 774                 sb.sctps_sends_with_abort += sarry->sctps_sends_with_abort;
 775                 sb.sctps_protocol_drain_calls += sarry->sctps_protocol_drain_calls;
 776                 sb.sctps_protocol_drains_done += sarry->sctps_protocol_drains_done;
 777                 sb.sctps_read_peeks += sarry->sctps_read_peeks;
 778                 sb.sctps_cached_chk += sarry->sctps_cached_chk;
 779                 sb.sctps_cached_strmoq += sarry->sctps_cached_strmoq;
 780                 sb.sctps_left_abandon += sarry->sctps_left_abandon;
 781                 sb.sctps_send_burst_avoid += sarry->sctps_send_burst_avoid;
 782                 sb.sctps_send_cwnd_avoid += sarry->sctps_send_cwnd_avoid;
 783                 sb.sctps_fwdtsn_map_over += sarry->sctps_fwdtsn_map_over;
 784         }
 785         error = SYSCTL_OUT(req, &sb, sizeof(sb));
 786         return (error);
 787 }
 788
 789 #endif
 790
 791 #if defined(SCTP_LOCAL_TRACE_BUF)
 792 static int
 793 sysctl_sctp_cleartrace(SYSCTL_HANDLER_ARGS)
 794 {
 795         int error = 0;
 796
 797         memset(&SCTP_BASE_SYSCTL(sctp_log), 0, sizeof(struct sctp_log));
 798         return (error);
 799 }
 800
 801 #endif
 802
 803
 804 /*
 805  * sysctl definitions
 806  */
 807
 808 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, sendspace, CTLTYPE_INT | CTLFLAG_RW,
 809     &SCTP_BASE_SYSCTL(sctp_sendspace), 0, sysctl_sctp_check, "IU",
 810     SCTPCTL_MAXDGRAM_DESC);
 811
 812 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, recvspace, CTLTYPE_INT | CTLFLAG_RW,
 813     &SCTP_BASE_SYSCTL(sctp_recvspace), 0, sysctl_sctp_check, "IU",
 814     SCTPCTL_RECVSPACE_DESC);
 815
 816 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, auto_asconf, CTLTYPE_INT | CTLFLAG_RW,
 817     &SCTP_BASE_SYSCTL(sctp_auto_asconf), 0, sysctl_sctp_check, "IU",
 818     SCTPCTL_AUTOASCONF_DESC);
 819
 820 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, ecn_enable, CTLTYPE_INT | CTLFLAG_RW,
 821     &SCTP_BASE_SYSCTL(sctp_ecn_enable), 0, sysctl_sctp_check, "IU",
 822     SCTPCTL_ECN_ENABLE_DESC);
 823
 824 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, ecn_nonce, CTLTYPE_INT | CTLFLAG_RW,
 825     &SCTP_BASE_SYSCTL(sctp_ecn_nonce), 0, sysctl_sctp_check, "IU",
 826     SCTPCTL_ECN_NONCE_DESC);
 827
 828 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, strict_sacks, CTLTYPE_INT | CTLFLAG_RW,
 829     &SCTP_BASE_SYSCTL(sctp_strict_sacks), 0, sysctl_sctp_check, "IU",
 830     SCTPCTL_STRICT_SACKS_DESC);
 831
 832 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, loopback_nocsum, CTLTYPE_INT | CTLFLAG_RW,
 833     &SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback), 0, sysctl_sctp_check, "IU",
 834     SCTPCTL_LOOPBACK_NOCSUM_DESC);
 835
 836 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, strict_init, CTLTYPE_INT | CTLFLAG_RW,
 837     &SCTP_BASE_SYSCTL(sctp_strict_init), 0, sysctl_sctp_check, "IU",
 838     SCTPCTL_STRICT_INIT_DESC);
 839
 840 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, peer_chkoh, CTLTYPE_INT | CTLFLAG_RW,
 841     &SCTP_BASE_SYSCTL(sctp_peer_chunk_oh), 0, sysctl_sctp_check, "IU",
 842     SCTPCTL_PEER_CHKOH_DESC);
 843
 844 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, maxburst, CTLTYPE_INT | CTLFLAG_RW,
 845     &SCTP_BASE_SYSCTL(sctp_max_burst_default), 0, sysctl_sctp_check, "IU",
 846     SCTPCTL_MAXBURST_DESC);
 847
 848 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, maxchunks, CTLTYPE_INT | CTLFLAG_RW,
 849     &SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue), 0, sysctl_sctp_check, "IU",
 850     SCTPCTL_MAXCHUNKS_DESC);
 851
 852 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, tcbhashsize, CTLTYPE_INT | CTLFLAG_RW,
 853     &SCTP_BASE_SYSCTL(sctp_hashtblsize), 0, sysctl_sctp_check, "IU",
 854     SCTPCTL_TCBHASHSIZE_DESC);
 855
 856 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, pcbhashsize, CTLTYPE_INT | CTLFLAG_RW,
 857     &SCTP_BASE_SYSCTL(sctp_pcbtblsize), 0, sysctl_sctp_check, "IU",
 858     SCTPCTL_PCBHASHSIZE_DESC);
 859
 860 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, min_split_point, CTLTYPE_INT | CTLFLAG_RW,
 861     &SCTP_BASE_SYSCTL(sctp_min_split_point), 0, sysctl_sctp_check, "IU",
 862     SCTPCTL_MIN_SPLIT_POINT_DESC);
 863
 864 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, chunkscale, CTLTYPE_INT | CTLFLAG_RW,
 865     &SCTP_BASE_SYSCTL(sctp_chunkscale), 0, sysctl_sctp_check, "IU",
 866     SCTPCTL_CHUNKSCALE_DESC);
 867
 868 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, delayed_sack_time, CTLTYPE_INT | CTLFLAG_RW,
 869     &SCTP_BASE_SYSCTL(sctp_delayed_sack_time_default), 0, sysctl_sctp_check, "IU",
 870     SCTPCTL_DELAYED_SACK_TIME_DESC);
 871
 872 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, sack_freq, CTLTYPE_INT | CTLFLAG_RW,
 873     &SCTP_BASE_SYSCTL(sctp_sack_freq_default), 0, sysctl_sctp_check, "IU",
 874     SCTPCTL_SACK_FREQ_DESC);
 875
 876 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, sys_resource, CTLTYPE_INT | CTLFLAG_RW,
 877     &SCTP_BASE_SYSCTL(sctp_system_free_resc_limit), 0, sysctl_sctp_check, "IU",
 878     SCTPCTL_SYS_RESOURCE_DESC);
 879
 880 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, asoc_resource, CTLTYPE_INT | CTLFLAG_RW,
 881     &SCTP_BASE_SYSCTL(sctp_asoc_free_resc_limit), 0, sysctl_sctp_check, "IU",
 882     SCTPCTL_ASOC_RESOURCE_DESC);
 883
 884 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, heartbeat_interval, CTLTYPE_INT | CTLFLAG_RW,
 885     &SCTP_BASE_SYSCTL(sctp_heartbeat_interval_default), 0, sysctl_sctp_check, "IU",
 886     SCTPCTL_HEARTBEAT_INTERVAL_DESC);
 887
 888 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, pmtu_raise_time, CTLTYPE_INT | CTLFLAG_RW,
 889     &SCTP_BASE_SYSCTL(sctp_pmtu_raise_time_default), 0, sysctl_sctp_check, "IU",
 890     SCTPCTL_PMTU_RAISE_TIME_DESC);
 891
 892 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, shutdown_guard_time, CTLTYPE_INT | CTLFLAG_RW,
 893     &SCTP_BASE_SYSCTL(sctp_shutdown_guard_time_default), 0, sysctl_sctp_check, "IU",
 894     SCTPCTL_SHUTDOWN_GUARD_TIME_DESC);
 895
 896 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, secret_lifetime, CTLTYPE_INT | CTLFLAG_RW,
 897     &SCTP_BASE_SYSCTL(sctp_secret_lifetime_default), 0, sysctl_sctp_check, "IU",
 898     SCTPCTL_SECRET_LIFETIME_DESC);
 899
 900 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, rto_max, CTLTYPE_INT | CTLFLAG_RW,
 901     &SCTP_BASE_SYSCTL(sctp_rto_max_default), 0, sysctl_sctp_check, "IU",
 902     SCTPCTL_RTO_MAX_DESC);
 903
 904 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, rto_min, CTLTYPE_INT | CTLFLAG_RW,
 905     &SCTP_BASE_SYSCTL(sctp_rto_min_default), 0, sysctl_sctp_check, "IU",
 906     SCTPCTL_RTO_MIN_DESC);
 907
 908 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, rto_initial, CTLTYPE_INT | CTLFLAG_RW,
 909     &SCTP_BASE_SYSCTL(sctp_rto_initial_default), 0, sysctl_sctp_check, "IU",
 910     SCTPCTL_RTO_INITIAL_DESC);
 911
 912 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, init_rto_max, CTLTYPE_INT | CTLFLAG_RW,
 913     &SCTP_BASE_SYSCTL(sctp_init_rto_max_default), 0, sysctl_sctp_check, "IU",
 914     SCTPCTL_INIT_RTO_MAX_DESC);
 915
 916 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, valid_cookie_life, CTLTYPE_INT | CTLFLAG_RW,
 917     &SCTP_BASE_SYSCTL(sctp_valid_cookie_life_default), 0, sysctl_sctp_check, "IU",
 918     SCTPCTL_VALID_COOKIE_LIFE_DESC);
 919
 920 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, init_rtx_max, CTLTYPE_INT | CTLFLAG_RW,
 921     &SCTP_BASE_SYSCTL(sctp_init_rtx_max_default), 0, sysctl_sctp_check, "IU",
 922     SCTPCTL_INIT_RTX_MAX_DESC);
 923
 924 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, assoc_rtx_max, CTLTYPE_INT | CTLFLAG_RW,
 925     &SCTP_BASE_SYSCTL(sctp_assoc_rtx_max_default), 0, sysctl_sctp_check, "IU",
 926     SCTPCTL_ASSOC_RTX_MAX_DESC);
 927
 928 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, path_rtx_max, CTLTYPE_INT | CTLFLAG_RW,
 929     &SCTP_BASE_SYSCTL(sctp_path_rtx_max_default), 0, sysctl_sctp_check, "IU",
 930     SCTPCTL_PATH_RTX_MAX_DESC);
 931
 932 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, add_more_on_output, CTLTYPE_INT | CTLFLAG_RW,
 933     &SCTP_BASE_SYSCTL(sctp_add_more_threshold), 0, sysctl_sctp_check, "IU",
 934     SCTPCTL_ADD_MORE_ON_OUTPUT_DESC);
 935
 936 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, outgoing_streams, CTLTYPE_INT | CTLFLAG_RW,
 937     &SCTP_BASE_SYSCTL(sctp_nr_outgoing_streams_default), 0, sysctl_sctp_check, "IU",
 938     SCTPCTL_OUTGOING_STREAMS_DESC);
 939
 940 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, cmt_on_off, CTLTYPE_INT | CTLFLAG_RW,
 941     &SCTP_BASE_SYSCTL(sctp_cmt_on_off), 0, sysctl_sctp_check, "IU",
 942     SCTPCTL_CMT_ON_OFF_DESC);
 943
 944 /* EY */
 945 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, nr_sack_on_off, CTLTYPE_INT | CTLFLAG_RW,
 946     &SCTP_BASE_SYSCTL(sctp_nr_sack_on_off), 0, sysctl_sctp_check, "IU",
 947     SCTPCTL_NR_SACK_ON_OFF_DESC);
 948
 949 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, cmt_use_dac, CTLTYPE_INT | CTLFLAG_RW,
 950     &SCTP_BASE_SYSCTL(sctp_cmt_use_dac), 0, sysctl_sctp_check, "IU",
 951     SCTPCTL_CMT_USE_DAC_DESC);
 952
 953 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, cmt_pf, CTLTYPE_INT | CTLFLAG_RW,
 954     &SCTP_BASE_SYSCTL(sctp_cmt_pf), 0, sysctl_sctp_check, "IU",
 955     SCTPCTL_CMT_PF_DESC);
 956
 957 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, cwnd_maxburst, CTLTYPE_INT | CTLFLAG_RW,
 958     &SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst), 0, sysctl_sctp_check, "IU",
 959     SCTPCTL_CWND_MAXBURST_DESC);
 960
 961 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, early_fast_retran, CTLTYPE_INT | CTLFLAG_RW,
 962     &SCTP_BASE_SYSCTL(sctp_early_fr), 0, sysctl_sctp_check, "IU",
 963     SCTPCTL_EARLY_FAST_RETRAN_DESC);
 964
 965 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, early_fast_retran_msec, CTLTYPE_INT | CTLFLAG_RW,
 966     &SCTP_BASE_SYSCTL(sctp_early_fr_msec), 0, sysctl_sctp_check, "IU",
 967     SCTPCTL_EARLY_FAST_RETRAN_MSEC_DESC);
 968
 969 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, asconf_auth_nochk, CTLTYPE_INT | CTLFLAG_RW,
 970     &SCTP_BASE_SYSCTL(sctp_asconf_auth_nochk), 0, sysctl_sctp_check, "IU",
 971     SCTPCTL_ASCONF_AUTH_NOCHK_DESC);
 972
 973 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, auth_disable, CTLTYPE_INT | CTLFLAG_RW,
 974     &SCTP_BASE_SYSCTL(sctp_auth_disable), 0, sysctl_sctp_check, "IU",
 975     SCTPCTL_AUTH_DISABLE_DESC);
 976
 977 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, nat_friendly, CTLTYPE_INT | CTLFLAG_RW,
 978     &SCTP_BASE_SYSCTL(sctp_nat_friendly), 0, sysctl_sctp_check, "IU",
 979     SCTPCTL_NAT_FRIENDLY_DESC);
 980
 981 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, abc_l_var, CTLTYPE_INT | CTLFLAG_RW,
 982     &SCTP_BASE_SYSCTL(sctp_L2_abc_variable), 0, sysctl_sctp_check, "IU",
 983     SCTPCTL_ABC_L_VAR_DESC);
 984
 985 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, max_chained_mbufs, CTLTYPE_INT | CTLFLAG_RW,
 986     &SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count), 0, sysctl_sctp_check, "IU",
 987     SCTPCTL_MAX_CHAINED_MBUFS_DESC);
 988
 989 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, do_sctp_drain, CTLTYPE_INT | CTLFLAG_RW,
 990     &SCTP_BASE_SYSCTL(sctp_do_drain), 0, sysctl_sctp_check, "IU",
 991     SCTPCTL_DO_SCTP_DRAIN_DESC);
 992
 993 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, hb_max_burst, CTLTYPE_INT | CTLFLAG_RW,
 994     &SCTP_BASE_SYSCTL(sctp_hb_maxburst), 0, sysctl_sctp_check, "IU",
 995     SCTPCTL_HB_MAX_BURST_DESC);
 996
 997 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, abort_at_limit, CTLTYPE_INT | CTLFLAG_RW,
 998     &SCTP_BASE_SYSCTL(sctp_abort_if_one_2_one_hits_limit), 0, sysctl_sctp_check, "IU",
 999     SCTPCTL_ABORT_AT_LIMIT_DESC);
1000
1001 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, strict_data_order, CTLTYPE_INT | CTLFLAG_RW,
1002     &SCTP_BASE_SYSCTL(sctp_strict_data_order), 0, sysctl_sctp_check, "IU",
1003     SCTPCTL_STRICT_DATA_ORDER_DESC);
1004
1005 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, min_residual, CTLTYPE_INT | CTLFLAG_RW,
1006     &SCTP_BASE_SYSCTL(sctp_min_residual), 0, sysctl_sctp_check, "IU",
1007     SCTPCTL_MIN_RESIDUAL_DESC);
1008
1009 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, max_retran_chunk, CTLTYPE_INT | CTLFLAG_RW,
1010     &SCTP_BASE_SYSCTL(sctp_max_retran_chunk), 0, sysctl_sctp_check, "IU",
1011     SCTPCTL_MAX_RETRAN_CHUNK_DESC);
1012
1013 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, log_level, CTLTYPE_INT | CTLFLAG_RW,
1014     &SCTP_BASE_SYSCTL(sctp_logging_level), 0, sysctl_sctp_check, "IU",
1015     SCTPCTL_LOGGING_LEVEL_DESC);
1016
1017 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, default_cc_module, CTLTYPE_INT | CTLFLAG_RW,
1018     &SCTP_BASE_SYSCTL(sctp_default_cc_module), 0, sysctl_sctp_check, "IU",
1019     SCTPCTL_DEFAULT_CC_MODULE_DESC);
1020
1021 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, default_frag_interleave, CTLTYPE_INT | CTLFLAG_RW,
1022     &SCTP_BASE_SYSCTL(sctp_default_frag_interleave), 0, sysctl_sctp_check, "IU",
1023     SCTPCTL_DEFAULT_FRAG_INTERLEAVE_DESC);
1024
1025 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, mobility_base, CTLTYPE_INT | CTLFLAG_RW,
1026     &SCTP_BASE_SYSCTL(sctp_mobility_base), 0, sysctl_sctp_check, "IU",
1027     SCTPCTL_MOBILITY_BASE_DESC);
1028
1029 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, mobility_fasthandoff, CTLTYPE_INT | CTLFLAG_RW,
1030     &SCTP_BASE_SYSCTL(sctp_mobility_fasthandoff), 0, sysctl_sctp_check, "IU",
1031     SCTPCTL_MOBILITY_FASTHANDOFF_DESC);
1032
1033 #if defined(SCTP_LOCAL_TRACE_BUF)
1034 SYSCTL_STRUCT(_net_inet_sctp, OID_AUTO, log, CTLFLAG_RD,
1035     &SCTP_BASE_SYSCTL(sctp_log), sctp_log,
1036     "SCTP logging (struct sctp_log)");
1037
1038 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, clear_trace, CTLTYPE_OPAQUE | CTLFLAG_RW,
1039     &SCTP_BASE_SYSCTL(sctp_log), 0, sysctl_sctp_cleartrace, "IU",
1040     "Clear SCTP Logging buffer");
1041
1042
1043
1044 #endif
1045
1046 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, udp_tunneling_for_client_enable, CTLTYPE_INT | CTLFLAG_RW,
1047     &SCTP_BASE_SYSCTL(sctp_udp_tunneling_for_client_enable), 0, sysctl_sctp_check, "IU",
1048     SCTPCTL_UDP_TUNNELING_FOR_CLIENT_ENABLE_DESC);
1049
1050 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, udp_tunneling_port, CTLTYPE_INT | CTLFLAG_RW,
1051     &SCTP_BASE_SYSCTL(sctp_udp_tunneling_port), 0, sysctl_sctp_udp_tunneling_check, "IU",
1052     SCTPCTL_UDP_TUNNELING_PORT_DESC);
1053
1054 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, enable_sack_immediately, CTLTYPE_INT | CTLFLAG_RW,
1055     &SCTP_BASE_SYSCTL(sctp_enable_sack_immediately), 0, sysctl_sctp_check, "IU",
1056     SCTPCTL_SACK_IMMEDIATELY_ENABLE_DESC);
1057
1058 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, nat_friendly_init, CTLTYPE_INT | CTLFLAG_RW,
1059     &SCTP_BASE_SYSCTL(sctp_inits_include_nat_friendly), 0, sysctl_sctp_check, "IU",
1060     SCTPCTL_NAT_FRIENDLY_INITS_DESC);
1061
1062 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, vtag_time_wait, CTLTYPE_INT | CTLFLAG_RW,
1063     &SCTP_BASE_SYSCTL(sctp_vtag_time_wait), 0, sysctl_sctp_check, "IU",
1064     SCTPCTL_TIME_WAIT_DESC);
1065
1066 #ifdef SCTP_DEBUG
1067 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, debug, CTLTYPE_INT | CTLFLAG_RW,
1068     &SCTP_BASE_SYSCTL(sctp_debug_on), 0, sysctl_sctp_check, "IU",
1069     SCTPCTL_DEBUG_DESC);
1070 #endif                          /* SCTP_DEBUG */
1071
1072
1073 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
1074 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, output_unlocked, CTLTYPE_INT | CTLFLAG_RW,
1075     &SCTP_BASE_SYSCTL(sctp_output_unlocked), 0, sysctl_sctp_check, "IU",
1076     SCTPCTL_OUTPUT_UNLOCKED_DESC);
1077 #endif
1078 #if defined(__FreeBSD__) && defined(SMP) && defined(SCTP_USE_PERCPU_STAT)
1079 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, stats,
1080     CTLTYPE_STRUCT | CTLFLAG_RD,
1081     0, 0, sysctl_stat_get, "S,sctpstat",
1082     "SCTP statistics (struct sctp_stat)");
1083 #else
1084 SYSCTL_STRUCT(_net_inet_sctp, OID_AUTO, stats, CTLFLAG_RW,
1085     &SCTP_BASE_STATS_SYSCTL, sctpstat,
1086     "SCTP statistics (struct sctp_stat)");
1087 #endif
1088
1089 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, assoclist, CTLFLAG_RD,
1090     0, 0, sctp_assoclist,
1091     "S,xassoc", "List of active SCTP associations");