/src/usrsctp/usrsctplib/netinet/sctp_usrreq.c

Source
/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved.
 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * a) Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * b) Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the distribution.
 *
 * c) Neither the name of Cisco Systems, Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <netinet/sctp_os.h>
#if defined(__FreeBSD__) && !defined(__Userspace__)
#include <sys/proc.h>
#endif
#include <netinet/sctp_pcb.h>
#include <netinet/sctp_header.h>
#include <netinet/sctp_var.h>
#ifdef INET6
#include <netinet6/sctp6_var.h>
#endif
#include <netinet/sctp_sysctl.h>
#include <netinet/sctp_output.h>
#include <netinet/sctp_uio.h>
#include <netinet/sctp_asconf.h>
#include <netinet/sctputil.h>
#include <netinet/sctp_indata.h>
#include <netinet/sctp_timer.h>
#include <netinet/sctp_auth.h>
#include <netinet/sctp_bsd_addr.h>
#if defined(__Userspace__)
#include <netinet/sctp_callout.h>
#else
#include <netinet/udp.h>
#endif
#if defined(__FreeBSD__) && !defined(__Userspace__)
#include <sys/eventhandler.h>
#endif
#if defined(HAVE_SCTP_PEELOFF_SOCKOPT)
#include <netinet/sctp_peeloff.h>
#endif        /* HAVE_SCTP_PEELOFF_SOCKOPT */
#if defined(_WIN32) && defined(__MINGW32__)
#include <minmax.h>
#endif

extern const struct sctp_cc_functions sctp_cc_functions[];
extern const struct sctp_ss_functions sctp_ss_functions[];

#if defined(__Userspace__)
void
sctp_init(uint16_t port,
          int (*conn_output)(void *addr, void *buffer, size_t length, uint8_t tos, uint8_t set_df),
          void (*debug_printf)(const char *format, ...), int start_threads)
#elif defined(__APPLE__) && (!defined(APPLE_LEOPARD) && !defined(APPLE_SNOWLEOPARD) &&!defined(APPLE_LION) && !defined(APPLE_MOUNTAINLION))
void
sctp_init(struct protosw *pp SCTP_UNUSED, struct domain *dp SCTP_UNUSED)
#elif defined(__FreeBSD__)
static void
sctp_init(void *arg SCTP_UNUSED)
#else
void
sctp_init(void)
#endif
{
#if !defined(__Userspace__)
  u_long sb_max_adj;

#else
  init_random();
#endif
  /* Initialize and modify the sysctled variables */
  sctp_init_sysctls();
#if defined(__Userspace__)
  SCTP_BASE_SYSCTL(sctp_udp_tunneling_port) = port;
#else
#if defined(__APPLE__) && !defined(__Userspace__)
  sb_max_adj = (u_long)((u_quad_t) (sb_max) * MCLBYTES / (MSIZE + MCLBYTES));
  SCTP_BASE_SYSCTL(sctp_sendspace) = sb_max_adj;
#else
  if ((nmbclusters / 8) > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
    SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue) = (nmbclusters / 8);
  /*
   * Allow a user to take no more than 1/2 the number of clusters or
   * the SB_MAX, whichever is smaller, for the send window.
   */
  sb_max_adj = (u_long)((u_quad_t) (SB_MAX) * MCLBYTES / (MSIZE + MCLBYTES));
  SCTP_BASE_SYSCTL(sctp_sendspace) = min(sb_max_adj,
      (((uint32_t)nmbclusters / 2) * MCLBYTES));
#endif
  /*
   * Now for the recv window, should we take the same amount? or
   * should I do 1/2 the SB_MAX instead in the SB_MAX min above. For
   * now I will just copy.
   */
  SCTP_BASE_SYSCTL(sctp_recvspace) = SCTP_BASE_SYSCTL(sctp_sendspace);
#endif
  SCTP_BASE_VAR(first_time) = 0;
  SCTP_BASE_VAR(sctp_pcb_initialized) = 0;
#if defined(__Userspace__)
#if !defined(_WIN32)
#if defined(INET) || defined(INET6)
  SCTP_BASE_VAR(userspace_route) = -1;
#endif
#endif
#ifdef INET
  SCTP_BASE_VAR(userspace_rawsctp) = -1;
  SCTP_BASE_VAR(userspace_udpsctp) = -1;
#endif
#ifdef INET6
  SCTP_BASE_VAR(userspace_rawsctp6) = -1;
  SCTP_BASE_VAR(userspace_udpsctp6) = -1;
#endif
  SCTP_BASE_VAR(timer_thread_should_exit) = 0;
  SCTP_BASE_VAR(conn_output) = conn_output;
  SCTP_BASE_VAR(debug_printf) = debug_printf;
  SCTP_BASE_VAR(crc32c_offloaded) = 0;
  SCTP_BASE_VAR(iterator_thread_started) = 0;
  SCTP_BASE_VAR(timer_thread_started) = 0;
#endif
#if defined(__Userspace__)
  sctp_pcb_init(start_threads);
  if (start_threads) {
    sctp_start_timer_thread();
  }
#else
  sctp_pcb_init();
#endif
#if defined(SCTP_PACKET_LOGGING)
  SCTP_BASE_VAR(packet_log_writers) = 0;
  SCTP_BASE_VAR(packet_log_end) = 0;
  memset(&SCTP_BASE_VAR(packet_log_buffer), 0, SCTP_PACKET_LOG_SIZE);
#endif
#if defined(__APPLE__) && !defined(__Userspace__)
  SCTP_BASE_VAR(sctp_main_timer_ticks) = 0;
  sctp_start_main_timer();
  timeout(sctp_delayed_startup, NULL, 1);
#endif
#if defined(__FreeBSD__) && !defined(__Userspace__)
  SCTP_BASE_VAR(eh_tag) = EVENTHANDLER_REGISTER(rt_addrmsg,
      sctp_addr_change_event_handler, NULL, EVENTHANDLER_PRI_FIRST);
#endif
}
#if defined(__FreeBSD__) && !defined(__Userspace__)
VNET_SYSINIT(sctp_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, sctp_init, NULL);

#ifdef VIMAGE
static void
sctp_finish(void *unused __unused)
{
  EVENTHANDLER_DEREGISTER(rt_addrmsg, SCTP_BASE_VAR(eh_tag));
  sctp_pcb_finish();
}
VNET_SYSUNINIT(sctp, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH, sctp_finish, NULL);
#endif
#else
void
sctp_finish(void)
{
#if defined(__APPLE__) && !defined(__Userspace__)
  untimeout(sctp_delayed_startup, NULL);
  sctp_over_udp_stop();
  sctp_address_monitor_stop();
  sctp_stop_main_timer();
#endif
#if defined(__Userspace__)
#if defined(INET) || defined(INET6)
  recv_thread_destroy();
#endif
  sctp_stop_timer_thread();
#endif
  sctp_pcb_finish();
#if defined(_WIN32) && !defined(__Userspace__)
  sctp_finish_sysctls();
#endif
#if defined(__Userspace__)
  finish_random();
#endif
}
#endif

void
sctp_pathmtu_adjustment(struct sctp_tcb *stcb, uint32_t mtu, bool resend)
{
  struct sctp_association *asoc;
  struct sctp_tmit_chunk *chk;
  uint32_t overhead;

  asoc = &stcb->asoc;
  KASSERT(mtu < asoc->smallest_mtu,
          ("Currently only reducing association MTU %u supported (MTU %u)",
          asoc->smallest_mtu, mtu));
  asoc->smallest_mtu = mtu;
  if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
    overhead = SCTP_MIN_OVERHEAD;
  } else {
#if defined(__Userspace__)
    if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_CONN) {
      overhead = sizeof(struct sctphdr);
    } else {
      overhead = SCTP_MIN_V4_OVERHEAD;
    }
#else
    overhead = SCTP_MIN_V4_OVERHEAD;
#endif
  }
  if (asoc->idata_supported) {
    if (sctp_auth_is_required_chunk(SCTP_IDATA, asoc->peer_auth_chunks)) {
      overhead += sctp_get_auth_chunk_len(asoc->peer_hmac_id);
    }
  } else {
    if (sctp_auth_is_required_chunk(SCTP_DATA, asoc->peer_auth_chunks)) {
      overhead += sctp_get_auth_chunk_len(asoc->peer_hmac_id);
    }
  }
  KASSERT(overhead % 4 == 0,
          ("overhead (%u) not a multiple of 4", overhead));
  TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) {
    if (((uint32_t)chk->send_size + overhead) > mtu) {
      chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
    }
  }
  TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {
    if (((uint32_t)chk->send_size + overhead) > mtu) {
      chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
      if (resend && chk->sent < SCTP_DATAGRAM_RESEND) {
        /*
         * If requested, mark the chunk for immediate
         * resend, since we sent it being too big.
         */
        sctp_flight_size_decrease(chk);
        sctp_total_flight_decrease(stcb, chk);
        chk->sent = SCTP_DATAGRAM_RESEND;
        sctp_ucount_incr(asoc->sent_queue_retran_cnt);
        chk->rec.data.doing_fast_retransmit = 0;
        if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) {
          sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_PMTU,
                         chk->whoTo->flight_size,
                         chk->book_size,
                         (uint32_t)(uintptr_t)chk->whoTo,
                         chk->rec.data.tsn);
        }
        /* Clear any time, so NO RTT is being done. */
        if (chk->do_rtt == 1) {
          chk->do_rtt = 0;
          chk->whoTo->rto_needed = 1;
        }
      }
    }
  }
}

#ifdef INET
#if !defined(__Userspace__)
void
sctp_notify(struct sctp_inpcb *inp,
            struct sctp_tcb *stcb,
            struct sctp_nets *net,
            uint8_t icmp_type,
            uint8_t icmp_code,
            uint16_t ip_len,
            uint32_t next_mtu)
{
#if defined(__APPLE__) && !defined(__Userspace__)
  struct socket *so;
#endif
  int timer_stopped;

  if (icmp_type != ICMP_UNREACH) {
    /* We only care about unreachable */
    SCTP_TCB_UNLOCK(stcb);
    return;
  }
  if ((icmp_code == ICMP_UNREACH_NET) ||
      (icmp_code == ICMP_UNREACH_HOST) ||
      (icmp_code == ICMP_UNREACH_NET_UNKNOWN) ||
      (icmp_code == ICMP_UNREACH_HOST_UNKNOWN) ||
      (icmp_code == ICMP_UNREACH_ISOLATED) ||
      (icmp_code == ICMP_UNREACH_NET_PROHIB) ||
      (icmp_code == ICMP_UNREACH_HOST_PROHIB) ||
#if defined(__NetBSD__)
      (icmp_code == ICMP_UNREACH_ADMIN_PROHIBIT)) {
#else
      (icmp_code == ICMP_UNREACH_FILTER_PROHIB)) {
#endif
    /* Mark the net unreachable. */
    if (net->dest_state & SCTP_ADDR_REACHABLE) {
      /* OK, that destination is NOT reachable. */
      net->dest_state &= ~SCTP_ADDR_REACHABLE;
      net->dest_state &= ~SCTP_ADDR_PF;
      sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
                      stcb, 0,
                      (void *)net, SCTP_SO_NOT_LOCKED);
    }
    SCTP_TCB_UNLOCK(stcb);
  } else  if ((icmp_code == ICMP_UNREACH_PROTOCOL) ||
        (icmp_code == ICMP_UNREACH_PORT)) {
    /* Treat it like an ABORT. */
    sctp_abort_notification(stcb, true, false, 0, NULL, SCTP_SO_NOT_LOCKED);
#if defined(__APPLE__) && !defined(__Userspace__)
    so = SCTP_INP_SO(inp);
    atomic_add_int(&stcb->asoc.refcnt, 1);
    SCTP_TCB_UNLOCK(stcb);
    SCTP_SOCKET_LOCK(so, 1);
    SCTP_TCB_LOCK(stcb);
    atomic_subtract_int(&stcb->asoc.refcnt, 1);
#endif
    (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
                          SCTP_FROM_SCTP_USRREQ + SCTP_LOC_2);
#if defined(__APPLE__) && !defined(__Userspace__)
    SCTP_SOCKET_UNLOCK(so, 1);
    /* SCTP_TCB_UNLOCK(stcb); MT: I think this is not needed.*/
#endif
    /* no need to unlock here, since the TCB is gone */
  } else if (icmp_code == ICMP_UNREACH_NEEDFRAG) {
    if (net->dest_state & SCTP_ADDR_NO_PMTUD) {
      SCTP_TCB_UNLOCK(stcb);
      return;
    }
    /* Find the next (smaller) MTU */
    if (next_mtu == 0) {
      /*
       * Old type router that does not tell us what the next
       * MTU is.
       * Rats we will have to guess (in a educated fashion
       * of course).
       */
      next_mtu = sctp_get_prev_mtu(ip_len);
    }
    /* Stop the PMTU timer. */
    if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
      timer_stopped = 1;
      sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
                      SCTP_FROM_SCTP_USRREQ + SCTP_LOC_1);
    } else {
      timer_stopped = 0;
    }
    /* Update the path MTU. */
    if (net->port) {
      next_mtu -= sizeof(struct udphdr);
    }
    if (net->mtu > next_mtu) {
      net->mtu = next_mtu;
#if defined(__FreeBSD__) && !defined(__Userspace__)
      if (net->port) {
        sctp_hc_set_mtu(&net->ro._l_addr, inp->fibnum, next_mtu + sizeof(struct udphdr));
      } else {
        sctp_hc_set_mtu(&net->ro._l_addr, inp->fibnum, next_mtu);
      }
#endif
    }
    /* Update the association MTU */
    if (stcb->asoc.smallest_mtu > next_mtu) {
      sctp_pathmtu_adjustment(stcb, next_mtu, true);
    }
    /* Finally, start the PMTU timer if it was running before. */
    if (timer_stopped) {
      sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
    }
    SCTP_TCB_UNLOCK(stcb);
  } else {
    SCTP_TCB_UNLOCK(stcb);
  }
}
#endif

#if !defined(__Userspace__)
#if defined(__FreeBSD__)
void sctp_ctlinput(struct icmp *icmp)
{
  struct ip *inner_ip, *outer_ip;
  struct sctphdr *sh;
  struct sctp_inpcb *inp;
  struct sctp_tcb *stcb;
  struct sctp_nets *net;
  struct sctp_init_chunk *ch;
  struct sockaddr_in src, dst;

  if (icmp_errmap(icmp) == 0)
    return;

  outer_ip = (struct ip *)((caddr_t)icmp - sizeof(struct ip));
  inner_ip = &icmp->icmp_ip;
  sh = (struct sctphdr *)((caddr_t)inner_ip + (inner_ip->ip_hl << 2));
  memset(&src, 0, sizeof(struct sockaddr_in));
  src.sin_family = AF_INET;
  src.sin_len = sizeof(struct sockaddr_in);
  src.sin_port = sh->src_port;
  src.sin_addr = inner_ip->ip_src;
  memset(&dst, 0, sizeof(struct sockaddr_in));
  dst.sin_family = AF_INET;
  dst.sin_len = sizeof(struct sockaddr_in);
  dst.sin_port = sh->dest_port;
  dst.sin_addr = inner_ip->ip_dst;
  /*
   * 'dst' holds the dest of the packet that failed to be sent.
   * 'src' holds our local endpoint address. Thus we reverse
   * the dst and the src in the lookup.
   */
  inp = NULL;
  net = NULL;
  stcb = sctp_findassociation_addr_sa((struct sockaddr *)&dst,
                                      (struct sockaddr *)&src,
                                      &inp, &net, 1,
                                      SCTP_DEFAULT_VRFID);
  if ((stcb != NULL) &&
      (net != NULL) &&
      (inp != NULL)) {
    /* Check the verification tag */
    if (ntohl(sh->v_tag) != 0) {
      /*
       * This must be the verification tag used for
       * sending out packets. We don't consider
       * packets reflecting the verification tag.
       */
      if (ntohl(sh->v_tag) != stcb->asoc.peer_vtag) {
        SCTP_TCB_UNLOCK(stcb);
        return;
      }
    } else {
      if (ntohs(outer_ip->ip_len) >=
          sizeof(struct ip) +
          8 + (inner_ip->ip_hl << 2) + 20) {
        /*
         * In this case we can check if we
         * got an INIT chunk and if the
         * initiate tag matches.
         */
        ch = (struct sctp_init_chunk *)(sh + 1);
        if ((ch->ch.chunk_type != SCTP_INITIATION) ||
            (ntohl(ch->init.initiate_tag) != stcb->asoc.my_vtag)) {
          SCTP_TCB_UNLOCK(stcb);
          return;
        }
      } else {
        SCTP_TCB_UNLOCK(stcb);
        return;
      }
    }
    sctp_notify(inp, stcb, net,
                icmp->icmp_type,
                icmp->icmp_code,
                ntohs(inner_ip->ip_len),
                (uint32_t)ntohs(icmp->icmp_nextmtu));
  } else {
    if ((stcb == NULL) && (inp != NULL)) {
      /* reduce ref-count */
      SCTP_INP_WLOCK(inp);
      SCTP_INP_DECR_REF(inp);
      SCTP_INP_WUNLOCK(inp);
    }
    if (stcb) {
      SCTP_TCB_UNLOCK(stcb);
    }
  }
}
#else
void
#if defined(__APPLE__) && !defined(APPLE_LEOPARD) && !defined(APPLE_SNOWLEOPARD) && !defined(APPLE_LION) && !defined(APPLE_MOUNTAINLION) && !defined(APPLE_ELCAPITAN)
sctp_ctlinput(int cmd, struct sockaddr *sa, void *vip, struct ifnet *ifp SCTP_UNUSED)
#else
sctp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
#endif
{
  struct ip *inner_ip;
  struct sctphdr *sh;
  struct icmp *icmp;
  struct sctp_inpcb *inp;
  struct sctp_tcb *stcb;
  struct sctp_nets *net;
  struct sockaddr_in src, dst;

#if !defined(__FreeBSD__) && !defined(__Userspace__)
  if (sa->sa_family != AF_INET ||
      ((struct sockaddr_in *)sa)->sin_addr.s_addr == INADDR_ANY) {
    return;
  }
#endif
  if (PRC_IS_REDIRECT(cmd)) {
    vip = NULL;
  } else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {
    return;
  }
  if (vip != NULL) {
    inner_ip = (struct ip *)vip;
    icmp = (struct icmp *)((caddr_t)inner_ip -
        (sizeof(struct icmp) - sizeof(struct ip)));
    sh = (struct sctphdr *)((caddr_t)inner_ip + (inner_ip->ip_hl << 2));
    memset(&src, 0, sizeof(struct sockaddr_in));
    src.sin_family = AF_INET;
#ifdef HAVE_SIN_LEN
    src.sin_len = sizeof(struct sockaddr_in);
#endif
    src.sin_port = sh->src_port;
    src.sin_addr = inner_ip->ip_src;
    memset(&dst, 0, sizeof(struct sockaddr_in));
    dst.sin_family = AF_INET;
#ifdef HAVE_SIN_LEN
    dst.sin_len = sizeof(struct sockaddr_in);
#endif
    dst.sin_port = sh->dest_port;
    dst.sin_addr = inner_ip->ip_dst;
    /*
     * 'dst' holds the dest of the packet that failed to be sent.
     * 'src' holds our local endpoint address. Thus we reverse
     * the dst and the src in the lookup.
     */
    inp = NULL;
    net = NULL;
    stcb = sctp_findassociation_addr_sa((struct sockaddr *)&dst,
                                        (struct sockaddr *)&src,
                                        &inp, &net, 1,
                                        SCTP_DEFAULT_VRFID);
    if ((stcb != NULL) &&
        (net != NULL) &&
        (inp != NULL)) {
      /* Check the verification tag */
      if (ntohl(sh->v_tag) != 0) {
        /*
         * This must be the verification tag used for
         * sending out packets. We don't consider
         * packets reflecting the verification tag.
         */
        if (ntohl(sh->v_tag) != stcb->asoc.peer_vtag) {
          SCTP_TCB_UNLOCK(stcb);
          return;
        }
      } else {
        SCTP_TCB_UNLOCK(stcb);
        return;
      }
      sctp_notify(inp, stcb, net,
                  icmp->icmp_type,
                  icmp->icmp_code,
                  inner_ip->ip_len,
                  (uint32_t)ntohs(icmp->icmp_nextmtu));
#if defined(__Userspace__)
      if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
          (stcb->sctp_socket != NULL)) {
        struct socket *upcall_socket;

        upcall_socket = stcb->sctp_socket;
        SOCK_LOCK(upcall_socket);
        soref(upcall_socket);
        SOCK_UNLOCK(upcall_socket);
        if ((upcall_socket->so_upcall != NULL) &&
            (upcall_socket->so_error != 0)) {
          (*upcall_socket->so_upcall)(upcall_socket, upcall_socket->so_upcallarg, M_NOWAIT);
        }
        ACCEPT_LOCK();
        SOCK_LOCK(upcall_socket);
        sorele(upcall_socket);
      }
#endif
    } else {
      if ((stcb == NULL) && (inp != NULL)) {
        /* reduce ref-count */
        SCTP_INP_WLOCK(inp);
        SCTP_INP_DECR_REF(inp);
        SCTP_INP_WUNLOCK(inp);
      }
      if (stcb) {
        SCTP_TCB_UNLOCK(stcb);
      }
    }
  }
  return;
}
#endif
#endif
#endif

#if defined(__FreeBSD__) && !defined(__Userspace__)
static int
sctp_getcred(SYSCTL_HANDLER_ARGS)
{
  struct xucred xuc;
  struct sockaddr_in addrs[2];
  struct sctp_inpcb *inp;
  struct sctp_nets *net;
  struct sctp_tcb *stcb;
  int error;
  uint32_t vrf_id;

  /* FIX, for non-bsd is this right? */
  vrf_id = SCTP_DEFAULT_VRFID;

  if (req->newptr == NULL)
    return (EINVAL);
  error = priv_check(req->td, PRIV_NETINET_GETCRED);
  if (error)
    return (error);

  error = SYSCTL_IN(req, addrs, sizeof(addrs));
  if (error)
    return (error);

  stcb = sctp_findassociation_addr_sa(sintosa(&addrs[1]),
      sintosa(&addrs[0]),
      &inp, &net, 1, vrf_id);
  if (stcb == NULL || inp == NULL || inp->sctp_socket == NULL) {
    if ((inp != NULL) && (stcb == NULL)) {
      /* reduce ref-count */
      SCTP_INP_WLOCK(inp);
      SCTP_INP_DECR_REF(inp);
      goto cred_can_cont;
    }

    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
    error = ENOENT;
    goto out;
  }
  SCTP_TCB_UNLOCK(stcb);
  /* We use the write lock here, only
   * since in the error leg we need it.
   * If we used RLOCK, then we would have
   * to wlock/decr/unlock/rlock. Which
   * in theory could create a hole. Better
   * to use higher wlock.
   */
  SCTP_INP_WLOCK(inp);
 cred_can_cont:
  error = cr_canseesocket(req->td->td_ucred, inp->sctp_socket);
  if (error) {
    SCTP_INP_WUNLOCK(inp);
    goto out;
  }
  cru2x(inp->sctp_socket->so_cred, &xuc);
  SCTP_INP_WUNLOCK(inp);
  error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
out:
  return (error);
}

SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred,
    CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
    0, 0, sctp_getcred, "S,ucred",
    "Get the ucred of a SCTP connection");
#endif

#if defined(__FreeBSD__) && !defined(__Userspace__)
void
#else
int
#endif
sctp_abort(struct socket *so)
{
#if defined(__FreeBSD__) && !defined(__Userspace__)
  struct epoch_tracker et;
#endif
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
#if defined(__FreeBSD__) && !defined(__Userspace__)
    return;
#else
    SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
#endif
  }

  SCTP_INP_WLOCK(inp);
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_ENTER(et);
#endif
#ifdef SCTP_LOG_CLOSING
  sctp_log_closing(inp, NULL, 17);
#endif
  if (((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0)) {
    inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP;
#ifdef SCTP_LOG_CLOSING
    sctp_log_closing(inp, NULL, 16);
#endif
    SCTP_INP_WUNLOCK(inp);
    sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
                    SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
    SOCK_LOCK(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    KASSERT(!SOLISTENING(so),
            ("sctp_abort: called on listening socket %p", so));
#endif
    SCTP_SB_CLEAR(so->so_snd);
    SCTP_SB_CLEAR(so->so_rcv);
#if defined(__APPLE__) && !defined(__Userspace__)
    so->so_usecount--;
#else
    /* Now null out the reference, we are completely detached. */
    so->so_pcb = NULL;
#endif
    SOCK_UNLOCK(so);
  } else {
    SCTP_INP_WUNLOCK(inp);
  }
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_EXIT(et);
#else
  return (0);
#endif
}

#ifdef INET
#if defined(__Userspace__)
int
#else
static int
#endif
#if defined(__Userspace__)
sctp_attach(struct socket *so, int proto SCTP_UNUSED, uint32_t vrf_id)
#elif defined(__FreeBSD__)
sctp_attach(struct socket *so, int proto SCTP_UNUSED, struct thread *p SCTP_UNUSED)
#elif defined(_WIN32)
sctp_attach(struct socket *so, int proto SCTP_UNUSED, PKTHREAD p SCTP_UNUSED)
#else
sctp_attach(struct socket *so, int proto SCTP_UNUSED, struct proc *p SCTP_UNUSED)
#endif
{
  struct sctp_inpcb *inp;
  struct inpcb *ip_inp;
  int error;
#if !defined(__Userspace__)
  uint32_t vrf_id = SCTP_DEFAULT_VRFID;
#endif

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp != NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
    error = SCTP_SORESERVE(so, SCTP_BASE_SYSCTL(sctp_sendspace), SCTP_BASE_SYSCTL(sctp_recvspace));
    if (error) {
      return (error);
    }
  }
  error = sctp_inpcb_alloc(so, vrf_id);
  if (error) {
    return (error);
  }
  inp = (struct sctp_inpcb *)so->so_pcb;
  SCTP_INP_WLOCK(inp);
  inp->sctp_flags &= ~SCTP_PCB_FLAGS_BOUND_V6; /* I'm not v6! */
  ip_inp = &inp->ip_inp.inp;
  ip_inp->inp_vflag |= INP_IPV4;
  ip_inp->inp_ip_ttl = MODULE_GLOBAL(ip_defttl);
  SCTP_INP_WUNLOCK(inp);
  return (0);
}

#if defined(__Userspace__)
int
sctp_bind(struct socket *so, struct sockaddr *addr) {
  void *p = NULL;
#elif defined(__FreeBSD__)
static int
sctp_bind(struct socket *so, struct sockaddr *addr, struct thread *p)
{
#elif defined(__APPLE__)
static int
sctp_bind(struct socket *so, struct sockaddr *addr, struct proc *p) {
#elif defined(_WIN32)
static int
sctp_bind(struct socket *so, struct sockaddr *addr, PKTHREAD p) {
#else
static int
sctp_bind(struct socket *so, struct mbuf *nam, struct proc *p)
{
  struct sockaddr *addr = nam ? mtod(nam, struct sockaddr *): NULL;

#endif
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  if (addr != NULL) {
#ifdef HAVE_SA_LEN
    if ((addr->sa_family != AF_INET) ||
        (addr->sa_len != sizeof(struct sockaddr_in))) {
#else
    if (addr->sa_family != AF_INET) {
#endif
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
  }
  return (sctp_inpcb_bind(so, addr, NULL, p));
}

#endif
#if defined(__Userspace__)

int
sctpconn_attach(struct socket *so, int proto SCTP_UNUSED, uint32_t vrf_id)
{
  struct sctp_inpcb *inp;
  struct inpcb *ip_inp;
  int error;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp != NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
    error = SCTP_SORESERVE(so, SCTP_BASE_SYSCTL(sctp_sendspace), SCTP_BASE_SYSCTL(sctp_recvspace));
    if (error) {
      return (error);
    }
  }
  error = sctp_inpcb_alloc(so, vrf_id);
  if (error) {
    return (error);
  }
  inp = (struct sctp_inpcb *)so->so_pcb;
  SCTP_INP_WLOCK(inp);
  inp->sctp_flags &= ~SCTP_PCB_FLAGS_BOUND_V6;
  inp->sctp_flags |= SCTP_PCB_FLAGS_BOUND_CONN;
  ip_inp = &inp->ip_inp.inp;
  ip_inp->inp_vflag |= INP_CONN;
  ip_inp->inp_ip_ttl = MODULE_GLOBAL(ip_defttl);
  SCTP_INP_WUNLOCK(inp);
  return (0);
}

int
sctpconn_bind(struct socket *so, struct sockaddr *addr)
{
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  if (addr != NULL) {
#ifdef HAVE_SA_LEN
    if ((addr->sa_family != AF_CONN) ||
        (addr->sa_len != sizeof(struct sockaddr_conn))) {
#else
    if (addr->sa_family != AF_CONN) {
#endif
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
  }
  return (sctp_inpcb_bind(so, addr, NULL, NULL));
}

#endif
#if defined(__FreeBSD__) || defined(_WIN32) || defined(__Userspace__)
void
sctp_close(struct socket *so)
{
#if defined(__FreeBSD__) && !defined(__Userspace__)
  struct epoch_tracker et;
#endif
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL)
    return;

  /* Inform all the lower layer assoc that we
   * are done.
   */
  SCTP_INP_WLOCK(inp);
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_ENTER(et);
#endif
#ifdef SCTP_LOG_CLOSING
  sctp_log_closing(inp, NULL, 17);
#endif
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) {
    inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP;
#if defined(__Userspace__)
    if (((so->so_options & SCTP_SO_LINGER) && (so->so_linger == 0)) ||
#else
    if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
#endif
        (SCTP_SBAVAIL(&so->so_rcv) > 0)) {
#ifdef SCTP_LOG_CLOSING
      sctp_log_closing(inp, NULL, 13);
#endif
      SCTP_INP_WUNLOCK(inp);
      sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
                      SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
    } else {
#ifdef SCTP_LOG_CLOSING
      sctp_log_closing(inp, NULL, 14);
#endif
      SCTP_INP_WUNLOCK(inp);
      sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_GRACEFUL_CLOSE,
                      SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
    }
    /* The socket is now detached, no matter what
     * the state of the SCTP association.
     */
    SOCK_LOCK(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    if (!SOLISTENING(so)) {
      SCTP_SB_CLEAR(so->so_snd);
      SCTP_SB_CLEAR(so->so_rcv);
    }
#else
    SCTP_SB_CLEAR(so->so_snd);
    SCTP_SB_CLEAR(so->so_rcv);
#endif
#if !(defined(__APPLE__) && !defined(__Userspace__))
    /* Now null out the reference, we are completely detached. */
    so->so_pcb = NULL;
#endif
    SOCK_UNLOCK(so);
  } else {
    SCTP_INP_WUNLOCK(inp);
  }
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_EXIT(et);
#endif
}
#else
int
sctp_detach(struct socket *so)
{
  struct sctp_inpcb *inp;
  uint32_t flags;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
 sctp_must_try_again:
  flags = inp->sctp_flags;
#ifdef SCTP_LOG_CLOSING
  sctp_log_closing(inp, NULL, 17);
#endif
  if (((flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
      (atomic_cmpset_int(&inp->sctp_flags, flags, (flags | SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP)))) {
    if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
        (SCTP_SBAVAIL(&so->so_rcv) > 0)) {
#ifdef SCTP_LOG_CLOSING
      sctp_log_closing(inp, NULL, 13);
#endif
      sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
                      SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
    } else {
#ifdef SCTP_LOG_CLOSING
      sctp_log_closing(inp, NULL, 13);
#endif
      sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_GRACEFUL_CLOSE,
                      SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
    }
    /* The socket is now detached, no matter what
     * the state of the SCTP association.
     */
    SCTP_SB_CLEAR(so->so_snd);
    /* same for the rcv ones, they are only
     * here for the accounting/select.
     */
    SCTP_SB_CLEAR(so->so_rcv);
#if !(defined(__APPLE__) && !defined(__Userspace__))
    /* Now disconnect */
    so->so_pcb = NULL;
#endif
  } else {
    flags = inp->sctp_flags;
    if ((flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) {
      goto sctp_must_try_again;
    }
  }
  return (0);
}
#endif

#if defined(__Userspace__)
/* __Userspace__ is not calling sctp_sendm */
#endif
#if !(defined(_WIN32) && !defined(__Userspace__))
int
#if defined(__FreeBSD__) && !defined(__Userspace__)
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
    struct mbuf *control, struct thread *p);

#else
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
    struct mbuf *control, struct proc *p);

#endif
int
#if defined(__FreeBSD__) && !defined(__Userspace__)
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
    struct mbuf *control, struct thread *p)
{
#else
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
    struct mbuf *control, struct proc *p)
{
#endif
  struct sctp_inpcb *inp;
  int error;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    if (control) {
      sctp_m_freem(control);
      control = NULL;
    }
    SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    sctp_m_freem(m);
    return (EINVAL);
  }
  /* Got to have an to address if we are NOT a connected socket */
  if ((addr == NULL) &&
      ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) ||
      (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE))) {
    goto connected_type;
  }

  error = 0;
  if (addr == NULL) {
    SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EDESTADDRREQ);
    error = EDESTADDRREQ;
  } else if (addr->sa_family != AF_INET) {
    SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EAFNOSUPPORT);
    error = EAFNOSUPPORT;
#if defined(HAVE_SA_LEN)
  } else if (addr->sa_len != sizeof(struct sockaddr_in)) {
    SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
#endif
  }
  if (error != 0) {
    sctp_m_freem(m);
    if (control) {
      sctp_m_freem(control);
      control = NULL;
    }
    return (error);
  }
connected_type:
  /* now what about control */
  if (control) {
    if (inp->control) {
      sctp_m_freem(inp->control);
      inp->control = NULL;
    }
    inp->control = control;
  }
  /* Place the data */
  if (inp->pkt) {
    SCTP_BUF_NEXT(inp->pkt_last) = m;
    inp->pkt_last = m;
  } else {
    inp->pkt_last = inp->pkt = m;
  }
  if (
#if (defined(__FreeBSD__) || defined(__APPLE__)) && !defined(__Userspace__)
  /* FreeBSD uses a flag passed */
      ((flags & PRUS_MORETOCOME) == 0)
#else
      1      /* Open BSD does not have any "more to come"
         * indication */
#endif
      ) {
    /*
     * note with the current version this code will only be used
     * by OpenBSD-- NetBSD, FreeBSD, and MacOS have methods for
     * re-defining sosend to use the sctp_sosend. One can
     * optionally switch back to this code (by changing back the
     * definitions) but this is not advisable. This code is used
     * by FreeBSD when sending a file with sendfile() though.
     */
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct epoch_tracker et;
#endif
    int ret;

#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_ENTER(et);
#endif
    ret = sctp_output(inp, inp->pkt, addr, inp->control, p, flags);
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_EXIT(et);
#endif
    inp->pkt = NULL;
    inp->control = NULL;
    return (ret);
  } else {
    return (0);
  }
}
#endif

int
sctp_disconnect(struct socket *so)
{
#if defined(__FreeBSD__) && !defined(__Userspace__)
  struct epoch_tracker et;
#endif
  struct sctp_inpcb *inp;
  struct sctp_association *asoc;
  struct sctp_tcb *stcb;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
    return (ENOTCONN);
  }
  SCTP_INP_RLOCK(inp);
  KASSERT(inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE ||
          inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL,
          ("Not a one-to-one style socket"));
  stcb = LIST_FIRST(&inp->sctp_asoc_list);
  if (stcb == NULL) {
    SCTP_INP_RUNLOCK(inp);
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
    return (ENOTCONN);
  }
  SCTP_TCB_LOCK(stcb);
  asoc = &stcb->asoc;
  if (asoc->state & SCTP_STATE_ABOUT_TO_BE_FREED) {
    /* We are about to be freed, out of here */
    SCTP_TCB_UNLOCK(stcb);
    SCTP_INP_RUNLOCK(inp);
    return (0);
  }
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_ENTER(et);
#endif
#if defined(__Userspace__)
  if (((so->so_options & SCTP_SO_LINGER) && (so->so_linger == 0)) ||
      (SCTP_SBAVAIL(&so->so_rcv) > 0)) {
#else
  if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
      (SCTP_SBAVAIL(&so->so_rcv) > 0)) {
#endif
    if (SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) {
      /* Left with Data unread */
      struct mbuf *op_err;

      op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
      sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
      SCTP_STAT_INCR_COUNTER32(sctps_aborted);
    }
    SCTP_INP_RUNLOCK(inp);
    if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
        (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
      SCTP_STAT_DECR_GAUGE32(sctps_currestab);
    }
    (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
                          SCTP_FROM_SCTP_USRREQ + SCTP_LOC_3);
    /* No unlock tcb assoc is gone */
#if defined(__FreeBSD__) && !defined(__Userspace__)
    NET_EPOCH_EXIT(et);
#endif
    return (0);
  }
  if (TAILQ_EMPTY(&asoc->send_queue) &&
      TAILQ_EMPTY(&asoc->sent_queue) &&
      (asoc->stream_queue_cnt == 0)) {
    /* there is nothing queued to send, so done */
    if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete)(stcb, asoc)) {
      goto abort_anyway;
    }
    if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
        (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
      /* only send SHUTDOWN 1st time thru */
      struct sctp_nets *netp;

      if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
          (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
        SCTP_STAT_DECR_GAUGE32(sctps_currestab);
      }
      SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
      sctp_stop_timers_for_shutdown(stcb);
      if (stcb->asoc.alternate) {
        netp = stcb->asoc.alternate;
      } else {
        netp = stcb->asoc.primary_destination;
      }
      sctp_send_shutdown(stcb,netp);
      sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
                       stcb->sctp_ep, stcb, netp);
      sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
                       stcb->sctp_ep, stcb, NULL);
      sctp_chunk_output(stcb->sctp_ep, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
    }
  } else {
    /*
     * we still got (or just got) data to send,
     * so set SHUTDOWN_PENDING
     */
    /*
     * XXX sockets draft says that SCTP_EOF
     * should be sent with no data. currently,
     * we will allow user data to be sent first
     * and move to SHUTDOWN-PENDING
     */
    SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
    if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete)(stcb, asoc)) {
      SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
    }
    if (TAILQ_EMPTY(&asoc->send_queue) &&
        TAILQ_EMPTY(&asoc->sent_queue) &&
        (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) {
      struct mbuf *op_err;
    abort_anyway:
      op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
      stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_USRREQ + SCTP_LOC_4;
      sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
      SCTP_STAT_INCR_COUNTER32(sctps_aborted);
      if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
          (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
        SCTP_STAT_DECR_GAUGE32(sctps_currestab);
      }
      SCTP_INP_RUNLOCK(inp);
      (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
                            SCTP_FROM_SCTP_USRREQ + SCTP_LOC_5);
#if defined(__FreeBSD__) && !defined(__Userspace__)
      NET_EPOCH_EXIT(et);
#endif
      return (0);
    } else {
      sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
    }
  }
  soisdisconnecting(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_EXIT(et);
#endif
  SCTP_TCB_UNLOCK(stcb);
  SCTP_INP_RUNLOCK(inp);
  return (0);
}

#if defined(__FreeBSD__) || defined(_WIN32) || defined(__Userspace__)
int
sctp_flush(struct socket *so, int how)
{
#if defined(__FreeBSD__) && !defined(__Userspace__)
  struct epoch_tracker et;
#endif
  struct sctp_tcb *stcb;
  struct sctp_queued_to_read *control, *ncontrol;
  struct sctp_inpcb *inp;
  struct mbuf *m, *op_err;
  bool need_to_abort = false;

  /*
   * For 1-to-1 style sockets, flush the read queue and trigger an
   * ungraceful shutdown of the association, if and only if user messages
   * are lost. Loosing notifications does not need to be signalled to the
   * peer.
   */
  if (how == PRU_FLUSH_WR) {
    /* This function is only relevant for the read directions. */
    return (0);
  }
  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  SCTP_INP_WLOCK(inp);
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
    /* For 1-to-many style sockets this function does nothing. */
    SCTP_INP_WUNLOCK(inp);
    return (0);
  }
  stcb = LIST_FIRST(&inp->sctp_asoc_list);
  if (stcb != NULL) {
    SCTP_TCB_LOCK(stcb);
  }
  SCTP_INP_READ_LOCK(inp);
  inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_CANT_READ;
  SOCK_LOCK(so);
  TAILQ_FOREACH_SAFE(control, &inp->read_queue, next, ncontrol) {
    if ((control->spec_flags & M_NOTIFICATION) == 0) {
      need_to_abort = true;
    }
    TAILQ_REMOVE(&inp->read_queue, control, next);
    control->on_read_q = 0;
    for (m = control->data; m; m = SCTP_BUF_NEXT(m)) {
      sctp_sbfree(control, control->stcb, &so->so_rcv, m);
    }
    if (control->on_strm_q == 0) {
      sctp_free_remote_addr(control->whoFrom);
      if (control->data) {
        sctp_m_freem(control->data);
        control->data = NULL;
      }
      sctp_free_a_readq(stcb, control);
    } else {
      if (stcb != NULL) {
        stcb->asoc.size_on_all_streams += control->length;
      }
    }
  }
  SOCK_UNLOCK(so);
  SCTP_INP_READ_UNLOCK(inp);
  if (need_to_abort && (stcb != NULL)) {
    inp->last_abort_code = SCTP_FROM_SCTP_USRREQ + SCTP_LOC_6;
    SCTP_INP_WUNLOCK(inp);
    op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, "");
#if defined(__FreeBSD__) && !defined(__Userspace__)
    NET_EPOCH_ENTER(et);
#endif
    sctp_abort_an_association(inp, stcb, op_err, false, SCTP_SO_LOCKED);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    NET_EPOCH_EXIT(et);
#endif
    return (ECONNABORTED);
  }
  if (stcb != NULL) {
    SCTP_TCB_UNLOCK(stcb);
  }
  SCTP_INP_WUNLOCK(inp);
  return (0);
}
#endif

int
sctp_shutdown(struct socket *so)
{
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  SCTP_INP_RLOCK(inp);
  /* For UDP model this is a invalid call */
  if (!((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
        (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) {
    /* Restore the flags that the soshutdown took away. */
#if (defined(__FreeBSD__) || defined(_WIN32)) && !defined(__Userspace__)
    SOCKBUF_LOCK(&so->so_rcv);
    so->so_rcv.sb_state &= ~SBS_CANTRCVMORE;
    SOCKBUF_UNLOCK(&so->so_rcv);
#else
    SOCK_LOCK(so);
    so->so_state &= ~SS_CANTRCVMORE;
    SOCK_UNLOCK(so);
#endif
    /* This proc will wakeup for read and do nothing (I hope) */
    SCTP_INP_RUNLOCK(inp);
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    return (EOPNOTSUPP);
  } else {
    /*
     * Ok, if we reach here its the TCP model and it is either
     * a SHUT_WR or SHUT_RDWR.
     * This means we put the shutdown flag against it.
     */
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct epoch_tracker et;
#endif
    struct sctp_tcb *stcb;
    struct sctp_association *asoc;
    struct sctp_nets *netp;

    if ((so->so_state &
         (SS_ISCONNECTED|SS_ISCONNECTING|SS_ISDISCONNECTING)) == 0) {
      SCTP_INP_RUNLOCK(inp);
      return (ENOTCONN);
    }
    socantsendmore(so);

    stcb = LIST_FIRST(&inp->sctp_asoc_list);
    if (stcb == NULL) {
      /*
       * Ok, we hit the case that the shutdown call was
       * made after an abort or something. Nothing to do
       * now.
       */
      SCTP_INP_RUNLOCK(inp);
      return (0);
    }
    SCTP_TCB_LOCK(stcb);
    asoc = &stcb->asoc;
    if (asoc->state & SCTP_STATE_ABOUT_TO_BE_FREED) {
      SCTP_TCB_UNLOCK(stcb);
      SCTP_INP_RUNLOCK(inp);
      return (0);
    }
    if ((SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) &&
        (SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_ECHOED) &&
        (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN)) {
      /* If we are not in or before ESTABLISHED, there is
       * no protocol action required.
       */
      SCTP_TCB_UNLOCK(stcb);
      SCTP_INP_RUNLOCK(inp);
      return (0);
    }
#if defined(__FreeBSD__) && !defined(__Userspace__)
    NET_EPOCH_ENTER(et);
#endif
    if (stcb->asoc.alternate) {
      netp = stcb->asoc.alternate;
    } else {
      netp = stcb->asoc.primary_destination;
    }
    if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) &&
        TAILQ_EMPTY(&asoc->send_queue) &&
        TAILQ_EMPTY(&asoc->sent_queue) &&
        (asoc->stream_queue_cnt == 0)) {
      if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete)(stcb, asoc)) {
        goto abort_anyway;
      }
      /* there is nothing queued to send, so I'm done... */
      SCTP_STAT_DECR_GAUGE32(sctps_currestab);
      SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
      sctp_stop_timers_for_shutdown(stcb);
      sctp_send_shutdown(stcb, netp);
      sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
                       stcb->sctp_ep, stcb, netp);
      sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
                       stcb->sctp_ep, stcb, NULL);
    } else {
      /*
       * We still got (or just got) data to send, so set
       * SHUTDOWN_PENDING.
       */
      SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
      if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete)(stcb, asoc)) {
        SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
      }
      if (TAILQ_EMPTY(&asoc->send_queue) &&
          TAILQ_EMPTY(&asoc->sent_queue) &&
          (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) {
        struct mbuf *op_err;
      abort_anyway:
        op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
        stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_USRREQ + SCTP_LOC_6;
        SCTP_INP_RUNLOCK(inp);
        sctp_abort_an_association(stcb->sctp_ep, stcb,
                                  op_err, false, SCTP_SO_LOCKED);
#if defined(__FreeBSD__) && !defined(__Userspace__)
        NET_EPOCH_EXIT(et);
#endif
        return (0);
      }
    }
    /* XXX: Why do this in the case where we have still data queued? */
    sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
    SCTP_TCB_UNLOCK(stcb);
    SCTP_INP_RUNLOCK(inp);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    NET_EPOCH_EXIT(et);
#endif
    return (0);
  }
}

/*
 * copies a "user" presentable address and removes embedded scope, etc.
 * returns 0 on success, 1 on error
 */
static uint32_t
sctp_fill_user_address(struct sockaddr *dst, struct sockaddr *src)
{
#ifdef INET6
#if defined(SCTP_EMBEDDED_V6_SCOPE)
  struct sockaddr_in6 lsa6;

  src = (struct sockaddr *)sctp_recover_scope((struct sockaddr_in6 *)src,
      &lsa6);
#endif
#endif
#ifdef HAVE_SA_LEN
  memcpy(dst, src, src->sa_len);
#else
  switch (src->sa_family) {
#ifdef INET
  case AF_INET:
    memcpy(dst, src, sizeof(struct sockaddr_in));
    break;
#endif
#ifdef INET6
  case AF_INET6:
    memcpy(dst, src, sizeof(struct sockaddr_in6));
    break;
#endif
#if defined(__Userspace__)
  case AF_CONN:
    memcpy(dst, src, sizeof(struct sockaddr_conn));
    break;
#endif
  default:
    /* TSNH */
    break;
  }
#endif
  return (0);
}

static size_t
sctp_fill_up_addresses_vrf(struct sctp_inpcb *inp,
                           struct sctp_tcb *stcb,
                           size_t limit,
                           struct sockaddr *addr,
                           uint32_t vrf_id)
{
  struct sctp_ifn *sctp_ifn;
  struct sctp_ifa *sctp_ifa;
  size_t actual;
  int loopback_scope;
#if defined(INET)
  int ipv4_local_scope, ipv4_addr_legal;
#endif
#if defined(INET6)
  int local_scope, site_scope, ipv6_addr_legal;
#endif
#if defined(__Userspace__)
  int conn_addr_legal;
#endif
  struct sctp_vrf *vrf;

  SCTP_IPI_ADDR_LOCK_ASSERT();
  actual = 0;
  if (limit == 0)
    return (actual);

  if (stcb) {
    /* Turn on all the appropriate scope */
    loopback_scope = stcb->asoc.scope.loopback_scope;
#if defined(INET)
    ipv4_local_scope = stcb->asoc.scope.ipv4_local_scope;
    ipv4_addr_legal = stcb->asoc.scope.ipv4_addr_legal;
#endif
#if defined(INET6)
    local_scope = stcb->asoc.scope.local_scope;
    site_scope = stcb->asoc.scope.site_scope;
    ipv6_addr_legal = stcb->asoc.scope.ipv6_addr_legal;
#endif
#if defined(__Userspace__)
    conn_addr_legal = stcb->asoc.scope.conn_addr_legal;
#endif
  } else {
    /* Use generic values for endpoints. */
    loopback_scope = 1;
#if defined(INET)
    ipv4_local_scope = 1;
#endif
#if defined(INET6)
    local_scope = 1;
    site_scope = 1;
#endif
    if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
#if defined(INET6)
      ipv6_addr_legal = 1;
#endif
#if defined(INET)
      if (SCTP_IPV6_V6ONLY(inp)) {
        ipv4_addr_legal = 0;
      } else {
        ipv4_addr_legal = 1;
      }
#endif
#if defined(__Userspace__)
      conn_addr_legal = 0;
#endif
    } else {
#if defined(INET6)
      ipv6_addr_legal = 0;
#endif
#if defined(__Userspace__)
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_CONN) {
        conn_addr_legal = 1;
#if defined(INET)
        ipv4_addr_legal = 0;
#endif
      } else {
        conn_addr_legal = 0;
#if defined(INET)
        ipv4_addr_legal = 1;
#endif
      }
#else
#if defined(INET)
      ipv4_addr_legal = 1;
#endif
#endif
    }
  }
  vrf = sctp_find_vrf(vrf_id);
  if (vrf == NULL) {
    return (0);
  }
  if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
    LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
      if ((loopback_scope == 0) &&
          SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) {
        /* Skip loopback if loopback_scope not set */
        continue;
      }
      LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
        if (stcb) {
          /*
           * For the BOUND-ALL case, the list
           * associated with a TCB is Always
           * considered a reverse list.. i.e.
           * it lists addresses that are NOT
           * part of the association. If this
           * is one of those we must skip it.
           */
          if (sctp_is_addr_restricted(stcb,
                                      sctp_ifa)) {
            continue;
          }
        }
        switch (sctp_ifa->address.sa.sa_family) {
#ifdef INET
        case AF_INET:
          if (ipv4_addr_legal) {
            struct sockaddr_in *sin;

            sin = &sctp_ifa->address.sin;
            if (sin->sin_addr.s_addr == 0) {
              /*
               * we skip unspecified
               * addresses
               */
              continue;
            }
#if defined(__FreeBSD__) && !defined(__Userspace__)
            if (prison_check_ip4(inp->ip_inp.inp.inp_cred,
                                 &sin->sin_addr) != 0) {
              continue;
            }
#endif
            if ((ipv4_local_scope == 0) &&
                (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) {
              continue;
            }
#ifdef INET6
            if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
              if (actual + sizeof(struct sockaddr_in6) > limit) {
                return (actual);
              }
              in6_sin_2_v4mapsin6(sin, (struct sockaddr_in6 *)addr);
              ((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
              addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in6));
              actual += sizeof(struct sockaddr_in6);
            } else {
#endif
              if (actual + sizeof(struct sockaddr_in) > limit) {
                return (actual);
              }
              memcpy(addr, sin, sizeof(struct sockaddr_in));
              ((struct sockaddr_in *)addr)->sin_port = inp->sctp_lport;
              addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in));
              actual += sizeof(struct sockaddr_in);
#ifdef INET6
            }
#endif
          } else {
            continue;
          }
          break;
#endif
#ifdef INET6
        case AF_INET6:
          if (ipv6_addr_legal) {
            struct sockaddr_in6 *sin6;

#if defined(SCTP_EMBEDDED_V6_SCOPE) && !defined(SCTP_KAME)
            struct sockaddr_in6 lsa6;
#endif
            sin6 = &sctp_ifa->address.sin6;
            if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
              /*
               * we skip unspecified
               * addresses
               */
              continue;
            }
#if defined(__FreeBSD__) && !defined(__Userspace__)
            if (prison_check_ip6(inp->ip_inp.inp.inp_cred,
                                 &sin6->sin6_addr) != 0) {
              continue;
            }
#endif
            if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
              if (local_scope == 0)
                continue;
#if defined(SCTP_EMBEDDED_V6_SCOPE)
              if (sin6->sin6_scope_id == 0) {
#ifdef SCTP_KAME
                if (sa6_recoverscope(sin6) != 0)
                  /*
                   * bad link
                   * local
                   * address
                   */
                  continue;
#else
                lsa6 = *sin6;
                if (in6_recoverscope(&lsa6,
                         &lsa6.sin6_addr,
                         NULL))
                  /*
                   * bad link
                   * local
                   * address
                   */
                continue;
                sin6 = &lsa6;
#endif        /* SCTP_KAME */
              }
#endif /* SCTP_EMBEDDED_V6_SCOPE */
            }
            if ((site_scope == 0) &&
                (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) {
              continue;
            }
            if (actual + sizeof(struct sockaddr_in6) > limit) {
              return (actual);
            }
            memcpy(addr, sin6, sizeof(struct sockaddr_in6));
            ((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
            addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in6));
            actual += sizeof(struct sockaddr_in6);
          } else {
            continue;
          }
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          if (conn_addr_legal) {
            if (actual + sizeof(struct sockaddr_conn) > limit) {
              return (actual);
            }
            memcpy(addr, &sctp_ifa->address.sconn, sizeof(struct sockaddr_conn));
            ((struct sockaddr_conn *)addr)->sconn_port = inp->sctp_lport;
            addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_conn));
            actual += sizeof(struct sockaddr_conn);
          } else {
            continue;
          }
#endif
        default:
          /* TSNH */
          break;
        }
      }
    }
  } else {
    struct sctp_laddr *laddr;
    size_t sa_len;

    LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
      if (stcb) {
        if (sctp_is_addr_restricted(stcb, laddr->ifa)) {
          continue;
        }
      }
#ifdef HAVE_SA_LEN
      sa_len = laddr->ifa->address.sa.sa_len;
#else
      switch (laddr->ifa->address.sa.sa_family) {
#ifdef INET
      case AF_INET:
        sa_len = sizeof(struct sockaddr_in);
        break;
#endif
#ifdef INET6
      case AF_INET6:
        sa_len = sizeof(struct sockaddr_in6);
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        sa_len = sizeof(struct sockaddr_conn);
        break;
#endif
      default:
        /* TSNH */
        sa_len = 0;
        break;
      }
#endif
      if (actual + sa_len > limit) {
        return (actual);
      }
      if (sctp_fill_user_address(addr, &laddr->ifa->address.sa))
        continue;
      switch (laddr->ifa->address.sa.sa_family) {
#ifdef INET
      case AF_INET:
        ((struct sockaddr_in *)addr)->sin_port = inp->sctp_lport;
        break;
#endif
#ifdef INET6
      case AF_INET6:
        ((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        ((struct sockaddr_conn *)addr)->sconn_port = inp->sctp_lport;
        break;
#endif
      default:
        /* TSNH */
        break;
      }
      addr = (struct sockaddr *)((caddr_t)addr + sa_len);
      actual += sa_len;
    }
  }
  return (actual);
}

static size_t
sctp_fill_up_addresses(struct sctp_inpcb *inp,
                       struct sctp_tcb *stcb,
                       size_t limit,
                       struct sockaddr *addr)
{
  size_t size;
#ifdef SCTP_MVRF
  uint32_t id;
#endif

  SCTP_IPI_ADDR_RLOCK();
#ifdef SCTP_MVRF
/*
 * FIX ME: ?? this WILL report duplicate addresses if they appear
 * in more than one VRF.
 */
  /* fill up addresses for all VRFs on the endpoint */
  size = 0;
  for (id = 0; (id < inp->num_vrfs) && (size < limit); id++) {
    size += sctp_fill_up_addresses_vrf(inp, stcb, limit, addr,
                                       inp->m_vrf_ids[id]);
    addr = (struct sockaddr *)((caddr_t)addr + size);
  }
#else
  /* fill up addresses for the endpoint's default vrf */
  size = sctp_fill_up_addresses_vrf(inp, stcb, limit, addr,
                                    inp->def_vrf_id);
#endif
  SCTP_IPI_ADDR_RUNLOCK();
  return (size);
}

static size_t
sctp_max_size_addresses_vrf(struct sctp_inpcb *inp, uint32_t vrf_id)
{
  struct sctp_vrf *vrf;
  size_t size;

  /*
   * In both sub-set bound an bound_all cases we return the size of
   * the maximum number of addresses that you could get. In reality
   * the sub-set bound may have an exclusion list for a given TCB or
   * in the bound-all case a TCB may NOT include the loopback or other
   * addresses as well.
   */
  SCTP_IPI_ADDR_LOCK_ASSERT();
  vrf = sctp_find_vrf(vrf_id);
  if (vrf == NULL) {
    return (0);
  }
  size = 0;
  if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
    struct sctp_ifn *sctp_ifn;
    struct sctp_ifa *sctp_ifa;

    LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
      LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
        /* Count them if they are the right type */
        switch (sctp_ifa->address.sa.sa_family) {
#ifdef INET
        case AF_INET:
#ifdef INET6
          if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4))
            size += sizeof(struct sockaddr_in6);
          else
            size += sizeof(struct sockaddr_in);
#else
          size += sizeof(struct sockaddr_in);
#endif
          break;
#endif
#ifdef INET6
        case AF_INET6:
          size += sizeof(struct sockaddr_in6);
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          size += sizeof(struct sockaddr_conn);
          break;
#endif
        default:
          break;
        }
      }
    }
  } else {
    struct sctp_laddr *laddr;

    LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
      switch (laddr->ifa->address.sa.sa_family) {
#ifdef INET
      case AF_INET:
#ifdef INET6
        if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4))
          size += sizeof(struct sockaddr_in6);
        else
          size += sizeof(struct sockaddr_in);
#else
        size += sizeof(struct sockaddr_in);
#endif
        break;
#endif
#ifdef INET6
      case AF_INET6:
        size += sizeof(struct sockaddr_in6);
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        size += sizeof(struct sockaddr_conn);
        break;
#endif
      default:
        break;
      }
    }
  }
  return (size);
}

static size_t
sctp_max_size_addresses(struct sctp_inpcb *inp)
{
  size_t size;
#ifdef SCTP_MVRF
  int id;
#endif

  SCTP_IPI_ADDR_RLOCK();
#ifdef SCTP_MVRF
/*
 * FIX ME: ?? this WILL count duplicate addresses if they appear
 * in more than one VRF.
 */
  /* Maximum size of all addresses for all VRFs on the endpoint */
  size = 0;
  for (id = 0; id < inp->num_vrfs; id++) {
    size += sctp_max_size_addresses_vrf(inp, inp->m_vrf_ids[id]);
  }
#else
  /* Maximum size of all addresses for the endpoint's default VRF */
  size = sctp_max_size_addresses_vrf(inp, inp->def_vrf_id);
#endif
  SCTP_IPI_ADDR_RUNLOCK();
  return (size);
}

static int
sctp_do_connect_x(struct socket *so, struct sctp_inpcb *inp, void *optval,
      size_t optsize, void *p, int delay)
{
  int error;
  int creat_lock_on = 0;
  struct sctp_tcb *stcb = NULL;
  struct sockaddr *sa;
  unsigned int num_v6 = 0, num_v4 = 0, *totaddrp, totaddr;
  uint32_t vrf_id;
  sctp_assoc_t *a_id;

  SCTPDBG(SCTP_DEBUG_PCB1, "Connectx called\n");

  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
      (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
    /* We are already connected AND the TCP model */
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EADDRINUSE);
    return (EADDRINUSE);
  }

  if ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) &&
      (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE))) {
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }

  if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
    SCTP_INP_RLOCK(inp);
    stcb = LIST_FIRST(&inp->sctp_asoc_list);
    SCTP_INP_RUNLOCK(inp);
  }
  if (stcb) {
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
    return (EALREADY);
  }
  SCTP_INP_INCR_REF(inp);
  SCTP_ASOC_CREATE_LOCK(inp);
  creat_lock_on = 1;
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
      (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EFAULT);
    error = EFAULT;
    goto out_now;
  }
  totaddrp = (unsigned int *)optval;
  totaddr = *totaddrp;
  sa = (struct sockaddr *)(totaddrp + 1);
  error = sctp_connectx_helper_find(inp, sa, totaddr, &num_v4, &num_v6, (unsigned int)(optsize - sizeof(int)));
  if (error != 0) {
    /* Already have or am bring up an association */
    SCTP_ASOC_CREATE_UNLOCK(inp);
    creat_lock_on = 0;
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    goto out_now;
  }
#ifdef INET6
  if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
      (num_v6 > 0)) {
    error = EINVAL;
    goto out_now;
  }
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
      (num_v4 > 0)) {
    if (SCTP_IPV6_V6ONLY(inp)) {
      /*
       * if IPV6_V6ONLY flag, ignore connections destined
       * to a v4 addr or v4-mapped addr
       */
      SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      goto out_now;
    }
  }
#endif        /* INET6 */
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
    /* Bind a ephemeral port */
    error = sctp_inpcb_bind(so, NULL, NULL, p);
    if (error) {
      goto out_now;
    }
  }

  /* FIX ME: do we want to pass in a vrf on the connect call? */
  vrf_id = inp->def_vrf_id;

  /* We are GOOD to go */
  stcb = sctp_aloc_assoc_connected(inp, sa, &error, 0, 0, vrf_id,
                                   inp->sctp_ep.pre_open_stream_count,
                                   inp->sctp_ep.port,
#if defined(__FreeBSD__) && !defined(__Userspace__)
                                   (struct thread *)p,
#elif defined(_WIN32) && !defined(__Userspace__)
                                   (PKTHREAD)p,
#else
                                   (struct proc *)p,
#endif
                                   SCTP_INITIALIZE_AUTH_PARAMS);
  if (stcb == NULL) {
    /* Gak! no memory */
    goto out_now;
  }
  SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
  /* move to second address */
  switch (sa->sa_family) {
#ifdef INET
  case AF_INET:
    sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in));
    break;
#endif
#ifdef INET6
  case AF_INET6:
    sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6));
    break;
#endif
  default:
    break;
  }

  error = 0;
  sctp_connectx_helper_add(stcb, sa, (totaddr-1), &error);
  /* Fill in the return id */
  if (error) {
    goto out_now;
  }
  a_id = (sctp_assoc_t *)optval;
  *a_id = sctp_get_associd(stcb);

  if (delay) {
    /* doing delayed connection */
    stcb->asoc.delayed_connection = 1;
    sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
  } else {
    (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
    sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
  }
  SCTP_TCB_UNLOCK(stcb);
 out_now:
  if (creat_lock_on) {
    SCTP_ASOC_CREATE_UNLOCK(inp);
  }
  SCTP_INP_DECR_REF(inp);
  return (error);
}

#define SCTP_FIND_STCB(inp, stcb, assoc_id) { \
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||\
      (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { \
    SCTP_INP_RLOCK(inp); \
    stcb = LIST_FIRST(&inp->sctp_asoc_list); \
    if (stcb) { \
      SCTP_TCB_LOCK(stcb); \
    } \
    SCTP_INP_RUNLOCK(inp); \
  } else if (assoc_id > SCTP_ALL_ASSOC) { \
    stcb = sctp_findassociation_ep_asocid(inp, assoc_id, 1); \
    if (stcb == NULL) { \
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT); \
      error = ENOENT; \
      break; \
    } \
  } else { \
    stcb = NULL; \
  } \
}

#define SCTP_CHECK_AND_CAST(destp, srcp, type, size) {\
  if (size < sizeof(type)) { \
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL); \
    error = EINVAL; \
    break; \
  } else { \
    destp = (type *)srcp; \
  } \
}

#if defined(__Userspace__)
int
#else
static int
#endif
sctp_getopt(struct socket *so, int optname, void *optval, size_t *optsize,
      void *p) {
  struct sctp_inpcb *inp = NULL;
  int error, val = 0;
  struct sctp_tcb *stcb = NULL;

  if (optval == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return EINVAL;
  }
  error = 0;

  switch (optname) {
  case SCTP_NODELAY:
  case SCTP_AUTOCLOSE:
  case SCTP_EXPLICIT_EOR:
  case SCTP_AUTO_ASCONF:
  case SCTP_DISABLE_FRAGMENTS:
  case SCTP_I_WANT_MAPPED_V4_ADDR:
  case SCTP_USE_EXT_RCVINFO:
    SCTP_INP_RLOCK(inp);
    switch (optname) {
    case SCTP_DISABLE_FRAGMENTS:
      val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NO_FRAGMENT);
      break;
    case SCTP_I_WANT_MAPPED_V4_ADDR:
      val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4);
      break;
    case SCTP_AUTO_ASCONF:
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
        /* only valid for bound all sockets */
        val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTO_ASCONF);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        goto flags_out;
      }
      break;
    case SCTP_EXPLICIT_EOR:
      val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR);
      break;
    case SCTP_NODELAY:
      val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NODELAY);
      break;
    case SCTP_USE_EXT_RCVINFO:
      val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO);
      break;
    case SCTP_AUTOCLOSE:
      if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE))
        val = sctp_ticks_to_secs(inp->sctp_ep.auto_close_time);
      else
        val = 0;
      break;

    default:
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
      error = ENOPROTOOPT;
    } /* end switch (sopt->sopt_name) */
    if (*optsize < sizeof(val)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
  flags_out:
    SCTP_INP_RUNLOCK(inp);
    if (error == 0) {
      /* return the option value */
      *(int *)optval = val;
      *optsize = sizeof(val);
    }
    break;
        case SCTP_GET_PACKET_LOG:
  {
#ifdef  SCTP_PACKET_LOGGING
    uint8_t *target;
    int ret;

    SCTP_CHECK_AND_CAST(target, optval, uint8_t, *optsize);
    ret = sctp_copy_out_packet_log(target , (int)*optsize);
    *optsize = ret;
#else
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    error = EOPNOTSUPP;
#endif
    break;
  }
  case SCTP_REUSE_PORT:
  {
    uint32_t *value;

    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE)) {
      /* Can't do this for a 1-m socket */
      error = EINVAL;
      break;
    }
    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    *value = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE);
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_PARTIAL_DELIVERY_POINT:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    *value = inp->partial_delivery_point;
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_FRAGMENT_INTERLEAVE:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) {
      if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS)) {
        *value = SCTP_FRAG_LEVEL_2;
      } else {
        *value = SCTP_FRAG_LEVEL_1;
      }
    } else {
      *value = SCTP_FRAG_LEVEL_0;
    }
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_INTERLEAVING_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.idata_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        if (inp->idata_supported) {
          av->assoc_value = 1;
        } else {
          av->assoc_value = 0;
        }
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_CMT_ON_OFF:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      av->assoc_value = stcb->asoc.sctp_cmt_on_off;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_cmt_on_off;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_PLUGGABLE_CC:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      av->assoc_value = stcb->asoc.congestion_control_module;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_ep.sctp_default_cc_module;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_CC_OPTION:
  {
    struct sctp_cc_option *cc_opt;

    SCTP_CHECK_AND_CAST(cc_opt, optval, struct sctp_cc_option, *optsize);
    SCTP_FIND_STCB(inp, stcb, cc_opt->aid_value.assoc_id);
    if (stcb == NULL) {
      error = EINVAL;
    } else {
      if (stcb->asoc.cc_functions.sctp_cwnd_socket_option == NULL) {
        error = ENOTSUP;
      } else {
        error = (*stcb->asoc.cc_functions.sctp_cwnd_socket_option)(stcb, 0, cc_opt);
        *optsize = sizeof(struct sctp_cc_option);
      }
      SCTP_TCB_UNLOCK(stcb);
    }
    break;
  }
  case SCTP_STREAM_SCHEDULER:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      av->assoc_value = stcb->asoc.stream_scheduling_module;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_ep.sctp_default_ss_module;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_STREAM_SCHEDULER_VALUE:
  {
    struct sctp_stream_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_stream_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      if ((av->stream_id >= stcb->asoc.streamoutcnt) ||
          (stcb->asoc.ss_functions.sctp_ss_get_value(stcb, &stcb->asoc, &stcb->asoc.strmout[av->stream_id],
                                                     &av->stream_value) < 0)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      } else {
        *optsize = sizeof(struct sctp_stream_value);
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      /* Can't get stream value without association */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }
  case SCTP_GET_ADDR_LEN:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    error = EINVAL;
#ifdef INET
    if (av->assoc_value == AF_INET) {
      av->assoc_value = sizeof(struct sockaddr_in);
      error = 0;
    }
#endif
#ifdef INET6
    if (av->assoc_value == AF_INET6) {
      av->assoc_value = sizeof(struct sockaddr_in6);
      error = 0;
    }
#endif
#if defined(__Userspace__)
    if (av->assoc_value == AF_CONN) {
      av->assoc_value = sizeof(struct sockaddr_conn);
      error = 0;
    }
#endif
    if (error) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    } else {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_GET_ASSOC_NUMBER:
  {
    uint32_t *value, cnt;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    SCTP_INP_RLOCK(inp);
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
        (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
      /* Can't do this for a 1-1 socket */
      error = EINVAL;
      SCTP_INP_RUNLOCK(inp);
      break;
    }
    cnt = 0;
    LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
      cnt++;
    }
    SCTP_INP_RUNLOCK(inp);
    *value = cnt;
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_GET_ASSOC_ID_LIST:
  {
    struct sctp_assoc_ids *ids;
    uint32_t at;
    size_t limit;

    SCTP_CHECK_AND_CAST(ids, optval, struct sctp_assoc_ids, *optsize);
    SCTP_INP_RLOCK(inp);
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
        (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
      /* Can't do this for a 1-1 socket */
      error = EINVAL;
      SCTP_INP_RUNLOCK(inp);
      break;
    }
    at = 0;
    limit = (*optsize - sizeof(uint32_t)) / sizeof(sctp_assoc_t);
    LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
      if (at < limit) {
        ids->gaids_assoc_id[at++] = sctp_get_associd(stcb);
        if (at == 0) {
          error = EINVAL;
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else {
        error = EINVAL;
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }
    SCTP_INP_RUNLOCK(inp);
    if (error == 0) {
      ids->gaids_number_of_ids = at;
      *optsize = ((at * sizeof(sctp_assoc_t)) + sizeof(uint32_t));
    }
    break;
  }
  case SCTP_CONTEXT:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.context;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_context;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_VRF_ID:
  {
    uint32_t *default_vrfid;

    SCTP_CHECK_AND_CAST(default_vrfid, optval, uint32_t, *optsize);
    *default_vrfid = inp->def_vrf_id;
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_GET_ASOC_VRF:
  {
    struct sctp_assoc_value *id;

    SCTP_CHECK_AND_CAST(id, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, id->assoc_id);
    if (stcb == NULL) {
      error = EINVAL;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    } else {
      id->assoc_value = stcb->asoc.vrf_id;
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_GET_VRF_IDS:
  {
#ifdef SCTP_MVRF
    int siz_needed;
    uint32_t *vrf_ids;

    SCTP_CHECK_AND_CAST(vrf_ids, optval, uint32_t, *optsize);
    siz_needed = inp->num_vrfs * sizeof(uint32_t);
    if (*optsize < siz_needed) {
      error = EINVAL;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    } else {
      memcpy(vrf_ids, inp->m_vrf_ids, siz_needed);
      *optsize = siz_needed;
    }
#else
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    error = EOPNOTSUPP;
#endif
    break;
  }
  case SCTP_GET_NONCE_VALUES:
  {
    struct sctp_get_nonce_values *gnv;

    SCTP_CHECK_AND_CAST(gnv, optval, struct sctp_get_nonce_values, *optsize);
    SCTP_FIND_STCB(inp, stcb, gnv->gn_assoc_id);

    if (stcb) {
      gnv->gn_peers_tag = stcb->asoc.peer_vtag;
      gnv->gn_local_tag = stcb->asoc.my_vtag;
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_get_nonce_values);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
      error = ENOTCONN;
    }
    break;
  }
  case SCTP_DELAYED_SACK:
  {
    struct sctp_sack_info *sack;

    SCTP_CHECK_AND_CAST(sack, optval, struct sctp_sack_info, *optsize);
    SCTP_FIND_STCB(inp, stcb, sack->sack_assoc_id);
    if (stcb) {
      sack->sack_delay = stcb->asoc.delayed_ack;
      sack->sack_freq = stcb->asoc.sack_freq;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (sack->sack_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        sack->sack_delay = sctp_ticks_to_msecs(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);
        sack->sack_freq = inp->sctp_ep.sctp_sack_freq;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_sack_info);
    }
    break;
  }
  case SCTP_GET_SNDBUF_USE:
  {
    struct sctp_sockstat *ss;

    SCTP_CHECK_AND_CAST(ss, optval, struct sctp_sockstat, *optsize);
    SCTP_FIND_STCB(inp, stcb, ss->ss_assoc_id);

    if (stcb) {
      ss->ss_total_sndbuf = stcb->asoc.total_output_queue_size;
      ss->ss_total_recv_buf = (stcb->asoc.size_on_reasm_queue +
             stcb->asoc.size_on_all_streams);
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_sockstat);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
      error = ENOTCONN;
    }
    break;
  }
  case SCTP_MAX_BURST:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.max_burst;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_ep.max_burst;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_MAXSEG:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.sctp_frag_point;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->sctp_frag_point;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_GET_STAT_LOG:
    error = sctp_fill_stat_log(optval, optsize);
    break;
  case SCTP_EVENTS:
  {
    struct sctp_event_subscribe *events;

    SCTP_CHECK_AND_CAST(events, optval, struct sctp_event_subscribe, *optsize);
    memset(events, 0, sizeof(struct sctp_event_subscribe));
    SCTP_INP_RLOCK(inp);
    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT))
      events->sctp_data_io_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT))
      events->sctp_association_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVPADDREVNT))
      events->sctp_address_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT))
      events->sctp_send_failure_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVPEERERR))
      events->sctp_peer_error_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT))
      events->sctp_shutdown_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PDAPIEVNT))
      events->sctp_partial_delivery_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT))
      events->sctp_adaptation_layer_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTHEVNT))
      events->sctp_authentication_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_DRYEVNT))
      events->sctp_sender_dry_event = 1;

    if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT))
      events->sctp_stream_reset_event = 1;
    SCTP_INP_RUNLOCK(inp);
    *optsize = sizeof(struct sctp_event_subscribe);
    break;
  }
  case SCTP_ADAPTATION_LAYER:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);

    SCTP_INP_RLOCK(inp);
    *value = inp->sctp_ep.adaptation_layer_indicator;
    SCTP_INP_RUNLOCK(inp);
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_SET_INITIAL_DBG_SEQ:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    SCTP_INP_RLOCK(inp);
    *value = inp->sctp_ep.initial_sequence_debug;
    SCTP_INP_RUNLOCK(inp);
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_GET_LOCAL_ADDR_SIZE:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    SCTP_INP_RLOCK(inp);
    *value = (uint32_t)sctp_max_size_addresses(inp);
    SCTP_INP_RUNLOCK(inp);
    *optsize = sizeof(uint32_t);
    break;
  }
  case SCTP_GET_REMOTE_ADDR_SIZE:
  {
    uint32_t *value;
    struct sctp_nets *net;
    size_t size;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
    /* FIXME MT: change to sctp_assoc_value? */
    SCTP_FIND_STCB(inp, stcb, (sctp_assoc_t)*value);

    if (stcb != NULL) {
      size = 0;
      /* Count the sizes */
      TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
        switch (net->ro._l_addr.sa.sa_family) {
#ifdef INET
        case AF_INET:
#ifdef INET6
          if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
            size += sizeof(struct sockaddr_in6);
          } else {
            size += sizeof(struct sockaddr_in);
          }
#else
          size += sizeof(struct sockaddr_in);
#endif
          break;
#endif
#ifdef INET6
        case AF_INET6:
          size += sizeof(struct sockaddr_in6);
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          size += sizeof(struct sockaddr_conn);
          break;
#endif
        default:
          break;
        }
      }
      SCTP_TCB_UNLOCK(stcb);
      *value = (uint32_t)size;
      *optsize = sizeof(uint32_t);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((sctp_assoc_t)*value <= SCTP_ALL_ASSOC)) {
        error = EINVAL;
      } else {
        error = ENOENT;
      }
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    }
    break;
  }
  case SCTP_GET_PEER_ADDRESSES:
    /*
     * Get the address information, an array is passed in to
     * fill up we pack it.
     */
  {
    size_t cpsz, left;
    struct sockaddr *addr;
    struct sctp_nets *net;
    struct sctp_getaddresses *saddr;

    SCTP_CHECK_AND_CAST(saddr, optval, struct sctp_getaddresses, *optsize);
    SCTP_FIND_STCB(inp, stcb, saddr->sget_assoc_id);

    if (stcb != NULL) {
      left = *optsize - offsetof(struct sctp_getaddresses, addr);
      *optsize = offsetof(struct sctp_getaddresses, addr);
      addr = &saddr->addr[0].sa;

      TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
        switch (net->ro._l_addr.sa.sa_family) {
#ifdef INET
        case AF_INET:
#ifdef INET6
          if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
            cpsz = sizeof(struct sockaddr_in6);
          } else {
            cpsz = sizeof(struct sockaddr_in);
          }
#else
          cpsz = sizeof(struct sockaddr_in);
#endif
          break;
#endif
#ifdef INET6
        case AF_INET6:
          cpsz = sizeof(struct sockaddr_in6);
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          cpsz = sizeof(struct sockaddr_conn);
          break;
#endif
        default:
          cpsz = 0;
          break;
        }
        if (cpsz == 0) {
          break;
        }
        if (left < cpsz) {
          /* not enough room. */
          break;
        }
#if defined(INET) && defined(INET6)
        if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) &&
            (net->ro._l_addr.sa.sa_family == AF_INET)) {
          /* Must map the address */
          in6_sin_2_v4mapsin6(&net->ro._l_addr.sin,
                              (struct sockaddr_in6 *)addr);
        } else {
          memcpy(addr, &net->ro._l_addr, cpsz);
        }
#else
        memcpy(addr, &net->ro._l_addr, cpsz);
#endif
        ((struct sockaddr_in *)addr)->sin_port = stcb->rport;

        addr = (struct sockaddr *)((caddr_t)addr + cpsz);
        left -= cpsz;
        *optsize += cpsz;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          (saddr->sget_assoc_id <= SCTP_ALL_ASSOC)) {
        error = EINVAL;
      } else {
        error = ENOENT;
      }
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    }
    break;
  }
  case SCTP_GET_LOCAL_ADDRESSES:
  {
    size_t limit, actual;
    struct sctp_getaddresses *saddr;

    SCTP_CHECK_AND_CAST(saddr, optval, struct sctp_getaddresses, *optsize);
    SCTP_FIND_STCB(inp, stcb, saddr->sget_assoc_id);

    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
        ((saddr->sget_assoc_id == SCTP_CURRENT_ASSOC) ||
         (saddr->sget_assoc_id == SCTP_ALL_ASSOC))) {
      error = EINVAL;
    } else {
      limit = *optsize - offsetof(struct sctp_getaddresses, addr);
      actual = sctp_fill_up_addresses(inp, stcb, limit, &saddr->addr[0].sa);
      *optsize = offsetof(struct sctp_getaddresses, addr) + actual;
    }
    if (stcb != NULL) {
      SCTP_TCB_UNLOCK(stcb);
    }
    break;
  }
  case SCTP_PEER_ADDR_PARAMS:
  {
    struct sctp_paddrparams *paddrp;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(paddrp, optval, struct sctp_paddrparams, *optsize);
    SCTP_FIND_STCB(inp, stcb, paddrp->spp_assoc_id);

#if defined(INET) && defined(INET6)
    if (paddrp->spp_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&paddrp->spp_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&paddrp->spp_address;
      }
    } else {
      addr = (struct sockaddr *)&paddrp->spp_address;
    }
#else
    addr = (struct sockaddr *)&paddrp->spp_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
      {
        error = EAFNOSUPPORT;
        SCTP_TCB_UNLOCK(stcb);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }

    if (stcb != NULL) {
      /* Applies to the specific association */
      paddrp->spp_flags = 0;
      if (net != NULL) {
        paddrp->spp_hbinterval = net->heart_beat_delay;
        paddrp->spp_pathmaxrxt = net->failure_threshold;
        paddrp->spp_pathmtu = net->mtu;
        switch (net->ro._l_addr.sa.sa_family) {
#ifdef INET
        case AF_INET:
          paddrp->spp_pathmtu -= SCTP_MIN_V4_OVERHEAD;
          break;
#endif
#ifdef INET6
        case AF_INET6:
          paddrp->spp_pathmtu -= SCTP_MIN_OVERHEAD;
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          paddrp->spp_pathmtu -= sizeof(struct sctphdr);
          break;
#endif
        default:
          break;
        }
        /* get flags for HB */
        if (net->dest_state & SCTP_ADDR_NOHB) {
          paddrp->spp_flags |= SPP_HB_DISABLE;
        } else {
          paddrp->spp_flags |= SPP_HB_ENABLE;
        }
        /* get flags for PMTU */
        if (net->dest_state & SCTP_ADDR_NO_PMTUD) {
          paddrp->spp_flags |= SPP_PMTUD_DISABLE;
        } else {
          paddrp->spp_flags |= SPP_PMTUD_ENABLE;
        }
        if (net->dscp & 0x01) {
          paddrp->spp_dscp = net->dscp & 0xfc;
          paddrp->spp_flags |= SPP_DSCP;
        }
#ifdef INET6
        if ((net->ro._l_addr.sa.sa_family == AF_INET6) &&
            (net->flowlabel & 0x80000000)) {
          paddrp->spp_ipv6_flowlabel = net->flowlabel & 0x000fffff;
          paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
        }
#endif
      } else {
        /*
         * No destination so return default
         * value
         */
        paddrp->spp_pathmaxrxt = stcb->asoc.def_net_failure;
        paddrp->spp_pathmtu = stcb->asoc.default_mtu;
        if (stcb->asoc.default_dscp & 0x01) {
          paddrp->spp_dscp = stcb->asoc.default_dscp & 0xfc;
          paddrp->spp_flags |= SPP_DSCP;
        }
#ifdef INET6
        if (stcb->asoc.default_flowlabel & 0x80000000) {
          paddrp->spp_ipv6_flowlabel = stcb->asoc.default_flowlabel & 0x000fffff;
          paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
        }
#endif
        /* default settings should be these */
        if (sctp_stcb_is_feature_on(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) {
          paddrp->spp_flags |= SPP_HB_DISABLE;
        } else {
          paddrp->spp_flags |= SPP_HB_ENABLE;
        }
        if (sctp_stcb_is_feature_on(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD)) {
          paddrp->spp_flags |= SPP_PMTUD_DISABLE;
        } else {
          paddrp->spp_flags |= SPP_PMTUD_ENABLE;
        }
        paddrp->spp_hbinterval = stcb->asoc.heart_beat_delay;
      }
      paddrp->spp_assoc_id = sctp_get_associd(stcb);
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (paddrp->spp_assoc_id == SCTP_FUTURE_ASSOC))) {
        /* Use endpoint defaults */
        SCTP_INP_RLOCK(inp);
        paddrp->spp_pathmaxrxt = inp->sctp_ep.def_net_failure;
        paddrp->spp_hbinterval = sctp_ticks_to_msecs(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT]);
        paddrp->spp_assoc_id = SCTP_FUTURE_ASSOC;
        /* get inp's default */
        if (inp->sctp_ep.default_dscp & 0x01) {
          paddrp->spp_dscp = inp->sctp_ep.default_dscp & 0xfc;
          paddrp->spp_flags |= SPP_DSCP;
        }
#ifdef INET6
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
            (inp->sctp_ep.default_flowlabel & 0x80000000)) {
          paddrp->spp_ipv6_flowlabel = inp->sctp_ep.default_flowlabel & 0x000fffff;
          paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
        }
#endif
        paddrp->spp_pathmtu = inp->sctp_ep.default_mtu;

        if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) {
          paddrp->spp_flags |= SPP_HB_ENABLE;
        } else {
          paddrp->spp_flags |= SPP_HB_DISABLE;
        }
        if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD)) {
          paddrp->spp_flags |= SPP_PMTUD_ENABLE;
        } else {
          paddrp->spp_flags |= SPP_PMTUD_DISABLE;
        }
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_paddrparams);
    }
    break;
  }
  case SCTP_GET_PEER_ADDR_INFO:
  {
    struct sctp_paddrinfo *paddri;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(paddri, optval, struct sctp_paddrinfo, *optsize);
    SCTP_FIND_STCB(inp, stcb, paddri->spinfo_assoc_id);

#if defined(INET) && defined(INET6)
    if (paddri->spinfo_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&paddri->spinfo_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&paddri->spinfo_address;
      }
    } else {
      addr = (struct sockaddr *)&paddri->spinfo_address;
    }
#else
    addr = (struct sockaddr *)&paddri->spinfo_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }

    if ((stcb != NULL) && (net != NULL)) {
      if (net->dest_state & SCTP_ADDR_UNCONFIRMED) {
        /* It's unconfirmed */
        paddri->spinfo_state = SCTP_UNCONFIRMED;
      } else if (net->dest_state & SCTP_ADDR_REACHABLE) {
        /* It's active */
        paddri->spinfo_state = SCTP_ACTIVE;
      } else {
        /* It's inactive */
        paddri->spinfo_state = SCTP_INACTIVE;
      }
      paddri->spinfo_cwnd = net->cwnd;
      paddri->spinfo_srtt = net->lastsa >> SCTP_RTT_SHIFT;
      paddri->spinfo_rto = net->RTO;
      paddri->spinfo_assoc_id = sctp_get_associd(stcb);
      paddri->spinfo_mtu = net->mtu;
      switch (addr->sa_family) {
#if defined(INET)
      case AF_INET:
        paddri->spinfo_mtu -= SCTP_MIN_V4_OVERHEAD;
        break;
#endif
#if defined(INET6)
      case AF_INET6:
        paddri->spinfo_mtu -= SCTP_MIN_OVERHEAD;
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        paddri->spinfo_mtu -= sizeof(struct sctphdr);
        break;
#endif
      default:
        break;
      }
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_paddrinfo);
    } else {
      if (stcb != NULL) {
        SCTP_TCB_UNLOCK(stcb);
      }
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
    }
    break;
  }
  case SCTP_PCB_STATUS:
  {
    struct sctp_pcbinfo *spcb;

    SCTP_CHECK_AND_CAST(spcb, optval, struct sctp_pcbinfo, *optsize);
    sctp_fill_pcbinfo(spcb);
    *optsize = sizeof(struct sctp_pcbinfo);
    break;
  }
  case SCTP_STATUS:
  {
    struct sctp_nets *net;
    struct sctp_status *sstat;

    SCTP_CHECK_AND_CAST(sstat, optval, struct sctp_status, *optsize);
    SCTP_FIND_STCB(inp, stcb, sstat->sstat_assoc_id);

    if (stcb == NULL) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    sstat->sstat_state = sctp_map_assoc_state(stcb->asoc.state);
    sstat->sstat_assoc_id = sctp_get_associd(stcb);
    sstat->sstat_rwnd = stcb->asoc.peers_rwnd;
    sstat->sstat_unackdata = stcb->asoc.sent_queue_cnt;
    /*
     * We can't include chunks that have been passed to
     * the socket layer. Only things in queue.
     */
    sstat->sstat_penddata = (stcb->asoc.cnt_on_reasm_queue +
           stcb->asoc.cnt_on_all_streams);
    sstat->sstat_instrms = stcb->asoc.streamincnt;
    sstat->sstat_outstrms = stcb->asoc.streamoutcnt;
    sstat->sstat_fragmentation_point = sctp_get_frag_point(stcb);
    net = stcb->asoc.primary_destination;
    if (net != NULL) {
#ifdef HAVE_SA_LEN
      memcpy(&sstat->sstat_primary.spinfo_address,
             &net->ro._l_addr,
             ((struct sockaddr *)(&net->ro._l_addr))->sa_len);
#else
      switch (stcb->asoc.primary_destination->ro._l_addr.sa.sa_family) {
#if defined(INET)
      case AF_INET:
        memcpy(&sstat->sstat_primary.spinfo_address,
               &net->ro._l_addr,
               sizeof(struct sockaddr_in));
        break;
#endif
#if defined(INET6)
      case AF_INET6:
        memcpy(&sstat->sstat_primary.spinfo_address,
               &net->ro._l_addr,
               sizeof(struct sockaddr_in6));
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        memcpy(&sstat->sstat_primary.spinfo_address,
               &net->ro._l_addr,
               sizeof(struct sockaddr_conn));
        break;
#endif
      default:
        break;
      }
#endif
      ((struct sockaddr_in *)&sstat->sstat_primary.spinfo_address)->sin_port = stcb->rport;
      /*
       * Again the user can get info from sctp_constants.h
       * for what the state of the network is.
       */
      if (net->dest_state & SCTP_ADDR_UNCONFIRMED) {
        /* It's unconfirmed */
        sstat->sstat_primary.spinfo_state = SCTP_UNCONFIRMED;
      } else if (net->dest_state & SCTP_ADDR_REACHABLE) {
        /* It's active */
        sstat->sstat_primary.spinfo_state = SCTP_ACTIVE;
      } else {
        /* It's inactive */
        sstat->sstat_primary.spinfo_state = SCTP_INACTIVE;
      }
      sstat->sstat_primary.spinfo_cwnd = net->cwnd;
      sstat->sstat_primary.spinfo_srtt = net->lastsa >> SCTP_RTT_SHIFT;
      sstat->sstat_primary.spinfo_rto = net->RTO;
      sstat->sstat_primary.spinfo_mtu = net->mtu;
      switch (stcb->asoc.primary_destination->ro._l_addr.sa.sa_family) {
#if defined(INET)
      case AF_INET:
        sstat->sstat_primary.spinfo_mtu -= SCTP_MIN_V4_OVERHEAD;
        break;
#endif
#if defined(INET6)
      case AF_INET6:
        sstat->sstat_primary.spinfo_mtu -= SCTP_MIN_OVERHEAD;
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        sstat->sstat_primary.spinfo_mtu -= sizeof(struct sctphdr);
        break;
#endif
      default:
        break;
      }
    } else {
      memset(&sstat->sstat_primary, 0, sizeof(struct sctp_paddrinfo));
    }
    sstat->sstat_primary.spinfo_assoc_id = sctp_get_associd(stcb);
    SCTP_TCB_UNLOCK(stcb);
    *optsize = sizeof(struct sctp_status);
    break;
  }
  case SCTP_RTOINFO:
  {
    struct sctp_rtoinfo *srto;

    SCTP_CHECK_AND_CAST(srto, optval, struct sctp_rtoinfo, *optsize);
    SCTP_FIND_STCB(inp, stcb, srto->srto_assoc_id);

    if (stcb) {
      srto->srto_initial = stcb->asoc.initial_rto;
      srto->srto_max = stcb->asoc.maxrto;
      srto->srto_min = stcb->asoc.minrto;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (srto->srto_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        srto->srto_initial = inp->sctp_ep.initial_rto;
        srto->srto_max = inp->sctp_ep.sctp_maxrto;
        srto->srto_min = inp->sctp_ep.sctp_minrto;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_rtoinfo);
    }
    break;
  }
  case SCTP_TIMEOUTS:
  {
    struct sctp_timeouts *stimo;

    SCTP_CHECK_AND_CAST(stimo, optval, struct sctp_timeouts, *optsize);
    SCTP_FIND_STCB(inp, stcb, stimo->stimo_assoc_id);

    if (stcb) {
      stimo->stimo_init= stcb->asoc.timoinit;
      stimo->stimo_data= stcb->asoc.timodata;
      stimo->stimo_sack= stcb->asoc.timosack;
      stimo->stimo_shutdown= stcb->asoc.timoshutdown;
      stimo->stimo_heartbeat= stcb->asoc.timoheartbeat;
      stimo->stimo_cookie= stcb->asoc.timocookie;
      stimo->stimo_shutdownack= stcb->asoc.timoshutdownack;
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_timeouts);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }
  case SCTP_ASSOCINFO:
  {
    struct sctp_assocparams *sasoc;

    SCTP_CHECK_AND_CAST(sasoc, optval, struct sctp_assocparams, *optsize);
    SCTP_FIND_STCB(inp, stcb, sasoc->sasoc_assoc_id);

    if (stcb) {
      sasoc->sasoc_cookie_life = sctp_ticks_to_msecs(stcb->asoc.cookie_life);
      sasoc->sasoc_asocmaxrxt = stcb->asoc.max_send_times;
      sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
      sasoc->sasoc_peer_rwnd = stcb->asoc.peers_rwnd;
      sasoc->sasoc_local_rwnd = stcb->asoc.my_rwnd;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (sasoc->sasoc_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        sasoc->sasoc_cookie_life = sctp_ticks_to_msecs(inp->sctp_ep.def_cookie_life);
        sasoc->sasoc_asocmaxrxt = inp->sctp_ep.max_send_times;
        sasoc->sasoc_number_peer_destinations = 0;
        sasoc->sasoc_peer_rwnd = 0;
        sasoc->sasoc_local_rwnd = (uint32_t)sbspace(&inp->sctp_socket->so_rcv);
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assocparams);
    }
    break;
  }
  case SCTP_DEFAULT_SEND_PARAM:
  {
    struct sctp_sndrcvinfo *s_info;

    SCTP_CHECK_AND_CAST(s_info, optval, struct sctp_sndrcvinfo, *optsize);
    SCTP_FIND_STCB(inp, stcb, s_info->sinfo_assoc_id);

    if (stcb) {
      memcpy(s_info, &stcb->asoc.def_send, sizeof(stcb->asoc.def_send));
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (s_info->sinfo_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        memcpy(s_info, &inp->def_send, sizeof(inp->def_send));
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_sndrcvinfo);
    }
    break;
  }
  case SCTP_INITMSG:
  {
    struct sctp_initmsg *sinit;

    SCTP_CHECK_AND_CAST(sinit, optval, struct sctp_initmsg, *optsize);
    SCTP_INP_RLOCK(inp);
    sinit->sinit_num_ostreams = inp->sctp_ep.pre_open_stream_count;
    sinit->sinit_max_instreams = inp->sctp_ep.max_open_streams_intome;
    sinit->sinit_max_attempts = inp->sctp_ep.max_init_times;
    sinit->sinit_max_init_timeo = inp->sctp_ep.initial_init_rto_max;
    SCTP_INP_RUNLOCK(inp);
    *optsize = sizeof(struct sctp_initmsg);
    break;
  }
  case SCTP_PRIMARY_ADDR:
    /* we allow a "get" operation on this */
  {
    struct sctp_setprim *ssp;

    SCTP_CHECK_AND_CAST(ssp, optval, struct sctp_setprim, *optsize);
    SCTP_FIND_STCB(inp, stcb, ssp->ssp_assoc_id);

    if (stcb) {
      union sctp_sockstore *addr;

      addr = &stcb->asoc.primary_destination->ro._l_addr;
      switch (addr->sa.sa_family) {
#ifdef INET
      case AF_INET:
#ifdef INET6
        if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
          in6_sin_2_v4mapsin6(&addr->sin,
                              (struct sockaddr_in6 *)&ssp->ssp_addr);
        } else {
          memcpy(&ssp->ssp_addr, &addr->sin, sizeof(struct sockaddr_in));
        }
#else
        memcpy(&ssp->ssp_addr, &addr->sin, sizeof(struct sockaddr_in));
#endif
        break;
#endif
#ifdef INET6
      case AF_INET6:
        memcpy(&ssp->ssp_addr, &addr->sin6, sizeof(struct sockaddr_in6));
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        memcpy(&ssp->ssp_addr, &addr->sconn, sizeof(struct sockaddr_conn));
        break;
#endif
      default:
        break;
      }
      SCTP_TCB_UNLOCK(stcb);
      *optsize = sizeof(struct sctp_setprim);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }
  case SCTP_HMAC_IDENT:
  {
    struct sctp_hmacalgo *shmac;
    sctp_hmaclist_t *hmaclist;
    size_t size;
    int i;

    SCTP_CHECK_AND_CAST(shmac, optval, struct sctp_hmacalgo, *optsize);

    SCTP_INP_RLOCK(inp);
    hmaclist = inp->sctp_ep.local_hmacs;
    if (hmaclist == NULL) {
      /* no HMACs to return */
      *optsize = sizeof(*shmac);
      SCTP_INP_RUNLOCK(inp);
      break;
    }
    /* is there room for all of the hmac ids? */
    size = sizeof(*shmac) + (hmaclist->num_algo *
                             sizeof(shmac->shmac_idents[0]));
    if (*optsize < size) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_INP_RUNLOCK(inp);
      break;
    }
    /* copy in the list */
    shmac->shmac_number_of_idents = hmaclist->num_algo;
    for (i = 0; i < hmaclist->num_algo; i++) {
      shmac->shmac_idents[i] = hmaclist->hmac[i];
    }
    SCTP_INP_RUNLOCK(inp);
    *optsize = size;
    break;
  }
  case SCTP_AUTH_ACTIVE_KEY:
  {
    struct sctp_authkeyid *scact;

    SCTP_CHECK_AND_CAST(scact, optval, struct sctp_authkeyid, *optsize);
    SCTP_FIND_STCB(inp, stcb, scact->scact_assoc_id);

    if (stcb) {
      /* get the active key on the assoc */
      scact->scact_keynumber = stcb->asoc.authinfo.active_keyid;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (scact->scact_assoc_id == SCTP_FUTURE_ASSOC))) {
        /* get the endpoint active key */
        SCTP_INP_RLOCK(inp);
        scact->scact_keynumber = inp->sctp_ep.default_keyid;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_authkeyid);
    }
    break;
  }
  case SCTP_LOCAL_AUTH_CHUNKS:
  {
    struct sctp_authchunks *sac;
    sctp_auth_chklist_t *chklist = NULL;
    size_t size = 0;

    SCTP_CHECK_AND_CAST(sac, optval, struct sctp_authchunks, *optsize);
    SCTP_FIND_STCB(inp, stcb, sac->gauth_assoc_id);

    if (stcb) {
      /* get off the assoc */
      chklist = stcb->asoc.local_auth_chunks;
      /* is there enough space? */
      size = sctp_auth_get_chklist_size(chklist);
      if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
        error = EINVAL;
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      } else {
        /* copy in the chunks */
        (void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
        sac->gauth_number_of_chunks = (uint32_t)size;
        *optsize = sizeof(struct sctp_authchunks) + size;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (sac->gauth_assoc_id == SCTP_FUTURE_ASSOC))) {
        /* get off the endpoint */
        SCTP_INP_RLOCK(inp);
        chklist = inp->sctp_ep.local_auth_chunks;
        /* is there enough space? */
        size = sctp_auth_get_chklist_size(chklist);
        if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
          error = EINVAL;
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        } else {
          /* copy in the chunks */
          (void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
          sac->gauth_number_of_chunks = (uint32_t)size;
          *optsize = sizeof(struct sctp_authchunks) + size;
        }
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_PEER_AUTH_CHUNKS:
  {
    struct sctp_authchunks *sac;
    sctp_auth_chklist_t *chklist = NULL;
    size_t size = 0;

    SCTP_CHECK_AND_CAST(sac, optval, struct sctp_authchunks, *optsize);
    SCTP_FIND_STCB(inp, stcb, sac->gauth_assoc_id);

    if (stcb) {
      /* get off the assoc */
      chklist = stcb->asoc.peer_auth_chunks;
      /* is there enough space? */
      size = sctp_auth_get_chklist_size(chklist);
      if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
        error = EINVAL;
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      } else {
        /* copy in the chunks */
        (void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
        sac->gauth_number_of_chunks = (uint32_t)size;
        *optsize = sizeof(struct sctp_authchunks) + size;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
    }
    break;
  }
#if defined(HAVE_SCTP_PEELOFF_SOCKOPT)
  case SCTP_PEELOFF:
  {
    struct sctp_peeloff_opt *peeloff;

    SCTP_CHECK_AND_CAST(peeloff, optval, struct sctp_peeloff_opt, *optsize);
    /* do the peeloff */
    error = sctp_peeloff_option(p, peeloff);
    if (error == 0) {
      *optsize = sizeof(struct sctp_peeloff_opt);
    }
  }
  break;
#endif /* HAVE_SCTP_PEELOFF_SOCKOPT */
  case SCTP_EVENT:
  {
    struct sctp_event *event;
    uint32_t event_type;

    SCTP_CHECK_AND_CAST(event, optval, struct sctp_event, *optsize);
    SCTP_FIND_STCB(inp, stcb, event->se_assoc_id);

    switch (event->se_type) {
    case SCTP_ASSOC_CHANGE:
      event_type = SCTP_PCB_FLAGS_RECVASSOCEVNT;
      break;
    case SCTP_PEER_ADDR_CHANGE:
      event_type = SCTP_PCB_FLAGS_RECVPADDREVNT;
      break;
    case SCTP_REMOTE_ERROR:
      event_type = SCTP_PCB_FLAGS_RECVPEERERR;
      break;
    case SCTP_SEND_FAILED:
      event_type = SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
      break;
    case SCTP_SHUTDOWN_EVENT:
      event_type = SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
      break;
    case SCTP_ADAPTATION_INDICATION:
      event_type = SCTP_PCB_FLAGS_ADAPTATIONEVNT;
      break;
    case SCTP_PARTIAL_DELIVERY_EVENT:
      event_type = SCTP_PCB_FLAGS_PDAPIEVNT;
      break;
    case SCTP_AUTHENTICATION_EVENT:
      event_type = SCTP_PCB_FLAGS_AUTHEVNT;
      break;
    case SCTP_STREAM_RESET_EVENT:
      event_type = SCTP_PCB_FLAGS_STREAM_RESETEVNT;
      break;
    case SCTP_SENDER_DRY_EVENT:
      event_type = SCTP_PCB_FLAGS_DRYEVNT;
      break;
    case SCTP_NOTIFICATIONS_STOPPED_EVENT:
      event_type = 0;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
      error = ENOTSUP;
      break;
    case SCTP_ASSOC_RESET_EVENT:
      event_type = SCTP_PCB_FLAGS_ASSOC_RESETEVNT;
      break;
    case SCTP_STREAM_CHANGE_EVENT:
      event_type = SCTP_PCB_FLAGS_STREAM_CHANGEEVNT;
      break;
    case SCTP_SEND_FAILED_EVENT:
      event_type = SCTP_PCB_FLAGS_RECVNSENDFAILEVNT;
      break;
    default:
      event_type = 0;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if (event_type > 0) {
      if (stcb) {
        event->se_on = sctp_stcb_is_feature_on(inp, stcb, event_type);
      } else {
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
            (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
            ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
             (event->se_assoc_id == SCTP_FUTURE_ASSOC))) {
          SCTP_INP_RLOCK(inp);
          event->se_on = sctp_is_feature_on(inp, event_type);
          SCTP_INP_RUNLOCK(inp);
        } else {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
      }
    }
    if (stcb != NULL) {
      SCTP_TCB_UNLOCK(stcb);
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_event);
    }
    break;
  }
  case SCTP_RECVRCVINFO:
    if (*optsize < sizeof(int)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    } else {
      SCTP_INP_RLOCK(inp);
      *(int *)optval = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
      SCTP_INP_RUNLOCK(inp);
      *optsize = sizeof(int);
    }
    break;
  case SCTP_RECVNXTINFO:
    if (*optsize < sizeof(int)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    } else {
      SCTP_INP_RLOCK(inp);
      *(int *)optval = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
      SCTP_INP_RUNLOCK(inp);
      *optsize = sizeof(int);
    }
    break;
  case SCTP_DEFAULT_SNDINFO:
  {
    struct sctp_sndinfo *info;

    SCTP_CHECK_AND_CAST(info, optval, struct sctp_sndinfo, *optsize);
    SCTP_FIND_STCB(inp, stcb, info->snd_assoc_id);

    if (stcb) {
      info->snd_sid = stcb->asoc.def_send.sinfo_stream;
      info->snd_flags = stcb->asoc.def_send.sinfo_flags;
      info->snd_flags &= 0xfff0;
      info->snd_ppid = stcb->asoc.def_send.sinfo_ppid;
      info->snd_context = stcb->asoc.def_send.sinfo_context;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (info->snd_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        info->snd_sid = inp->def_send.sinfo_stream;
        info->snd_flags = inp->def_send.sinfo_flags;
        info->snd_flags &= 0xfff0;
        info->snd_ppid = inp->def_send.sinfo_ppid;
        info->snd_context = inp->def_send.sinfo_context;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_sndinfo);
    }
    break;
  }
  case SCTP_DEFAULT_PRINFO:
  {
    struct sctp_default_prinfo *info;

    SCTP_CHECK_AND_CAST(info, optval, struct sctp_default_prinfo, *optsize);
    SCTP_FIND_STCB(inp, stcb, info->pr_assoc_id);

    if (stcb) {
      info->pr_policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
      info->pr_value = stcb->asoc.def_send.sinfo_timetolive;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (info->pr_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        info->pr_policy = PR_SCTP_POLICY(inp->def_send.sinfo_flags);
        info->pr_value = inp->def_send.sinfo_timetolive;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_default_prinfo);
    }
    break;
  }
  case SCTP_PEER_ADDR_THLDS:
  {
    struct sctp_paddrthlds *thlds;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(thlds, optval, struct sctp_paddrthlds, *optsize);
    SCTP_FIND_STCB(inp, stcb, thlds->spt_assoc_id);

#if defined(INET) && defined(INET6)
    if (thlds->spt_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&thlds->spt_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&thlds->spt_address;
      }
    } else {
      addr = (struct sockaddr *)&thlds->spt_address;
    }
#else
    addr = (struct sockaddr *)&thlds->spt_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
      {
        error = EAFNOSUPPORT;
        SCTP_TCB_UNLOCK(stcb);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }

    if (stcb != NULL) {
      if (net != NULL) {
        thlds->spt_pathmaxrxt = net->failure_threshold;
        thlds->spt_pathpfthld = net->pf_threshold;
        thlds->spt_pathcpthld = 0xffff;
      } else {
        thlds->spt_pathmaxrxt = stcb->asoc.def_net_failure;
        thlds->spt_pathpfthld = stcb->asoc.def_net_pf_threshold;
        thlds->spt_pathcpthld = 0xffff;
      }
      thlds->spt_assoc_id = sctp_get_associd(stcb);
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (thlds->spt_assoc_id == SCTP_FUTURE_ASSOC))) {
        /* Use endpoint defaults */
        SCTP_INP_RLOCK(inp);
        thlds->spt_pathmaxrxt = inp->sctp_ep.def_net_failure;
        thlds->spt_pathpfthld = inp->sctp_ep.def_net_pf_threshold;
        thlds->spt_pathcpthld = 0xffff;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_paddrthlds);
    }
    break;
  }
  case SCTP_REMOTE_UDP_ENCAPS_PORT:
  {
    struct sctp_udpencaps *encaps;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(encaps, optval, struct sctp_udpencaps, *optsize);
    SCTP_FIND_STCB(inp, stcb, encaps->sue_assoc_id);

#if defined(INET) && defined(INET6)
    if (encaps->sue_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&encaps->sue_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&encaps->sue_address;
      }
    } else {
      addr = (struct sockaddr *)&encaps->sue_address;
    }
#else
    addr = (struct sockaddr *)&encaps->sue_address;
#endif
    if (stcb) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          error = EINVAL;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
      } else
#endif
      {
        error = EAFNOSUPPORT;
        SCTP_TCB_UNLOCK(stcb);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }

    if (stcb != NULL) {
      if (net) {
        encaps->sue_port = net->port;
      } else {
        encaps->sue_port = stcb->asoc.port;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (encaps->sue_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        encaps->sue_port = inp->sctp_ep.port;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_udpencaps);
    }
    break;
  }
  case SCTP_ECN_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.ecn_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->ecn_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_PR_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.prsctp_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->prsctp_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_AUTH_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.auth_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->auth_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_ASCONF_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.asconf_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->asconf_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_RECONFIG_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.reconfig_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->reconfig_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_NRSACK_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.nrsack_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->nrsack_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_PKTDROP_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.pktdrop_supported;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->pktdrop_supported;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_ENABLE_STREAM_RESET:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = (uint32_t)stcb->asoc.local_strreset_support;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = (uint32_t)inp->local_strreset_support;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  case SCTP_PR_STREAM_STATUS:
  {
    struct sctp_prstatus *sprstat;
    uint16_t sid;
    uint16_t policy;

    SCTP_CHECK_AND_CAST(sprstat, optval, struct sctp_prstatus, *optsize);
    SCTP_FIND_STCB(inp, stcb, sprstat->sprstat_assoc_id);

    sid = sprstat->sprstat_sid;
    policy = sprstat->sprstat_policy;
#if defined(SCTP_DETAILED_STR_STATS)
    if ((stcb != NULL) &&
        (sid < stcb->asoc.streamoutcnt) &&
        (policy != SCTP_PR_SCTP_NONE) &&
        ((policy <= SCTP_PR_SCTP_MAX) ||
         (policy == SCTP_PR_SCTP_ALL))) {
      if (policy == SCTP_PR_SCTP_ALL) {
        sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[0];
        sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[0];
      } else {
        sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[policy];
        sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[policy];
      }
#else
    if ((stcb != NULL) &&
        (sid < stcb->asoc.streamoutcnt) &&
        (policy == SCTP_PR_SCTP_ALL)) {
      sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[0];
      sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[0];
#endif
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    if (stcb != NULL) {
      SCTP_TCB_UNLOCK(stcb);
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_prstatus);
    }
    break;
  }
  case SCTP_PR_ASSOC_STATUS:
  {
    struct sctp_prstatus *sprstat;
    uint16_t policy;

    SCTP_CHECK_AND_CAST(sprstat, optval, struct sctp_prstatus, *optsize);
    SCTP_FIND_STCB(inp, stcb, sprstat->sprstat_assoc_id);

    policy = sprstat->sprstat_policy;
    if ((stcb != NULL) &&
        (policy != SCTP_PR_SCTP_NONE) &&
        ((policy <= SCTP_PR_SCTP_MAX) ||
         (policy == SCTP_PR_SCTP_ALL))) {
      if (policy == SCTP_PR_SCTP_ALL) {
        sprstat->sprstat_abandoned_unsent = stcb->asoc.abandoned_unsent[0];
        sprstat->sprstat_abandoned_sent = stcb->asoc.abandoned_sent[0];
      } else {
        sprstat->sprstat_abandoned_unsent = stcb->asoc.abandoned_unsent[policy];
        sprstat->sprstat_abandoned_sent = stcb->asoc.abandoned_sent[policy];
      }
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    if (stcb != NULL) {
      SCTP_TCB_UNLOCK(stcb);
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_prstatus);
    }
    break;
  }
  case SCTP_MAX_CWND:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      av->assoc_value = stcb->asoc.max_cwnd;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        av->assoc_value = inp->max_cwnd;
        SCTP_INP_RUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    if (error == 0) {
      *optsize = sizeof(struct sctp_assoc_value);
    }
    break;
  }
  default:
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
    error = ENOPROTOOPT;
    break;
  } /* end switch (sopt->sopt_name) */
  if (error) {
    *optsize = 0;
  }
  return (error);
}

#if defined(__Userspace__)
int
#else
static int
#endif
sctp_setopt(struct socket *so, int optname, void *optval, size_t optsize,
      void *p)
{
  int error, set_opt;
  uint32_t *mopt;
  struct sctp_tcb *stcb = NULL;
  struct sctp_inpcb *inp = NULL;
  uint32_t vrf_id;

  if (optval == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (EINVAL);
  }
  vrf_id = inp->def_vrf_id;

  error = 0;
  switch (optname) {
  case SCTP_NODELAY:
  case SCTP_AUTOCLOSE:
  case SCTP_AUTO_ASCONF:
  case SCTP_EXPLICIT_EOR:
  case SCTP_DISABLE_FRAGMENTS:
  case SCTP_USE_EXT_RCVINFO:
  case SCTP_I_WANT_MAPPED_V4_ADDR:
    /* copy in the option value */
    SCTP_CHECK_AND_CAST(mopt, optval, uint32_t, optsize);
    set_opt = 0;
    if (error)
      break;
    switch (optname) {
    case SCTP_DISABLE_FRAGMENTS:
      set_opt = SCTP_PCB_FLAGS_NO_FRAGMENT;
      break;
    case SCTP_AUTO_ASCONF:
      /*
       * NOTE: we don't really support this flag
       */
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
        /* only valid for bound all sockets */
        if ((SCTP_BASE_SYSCTL(sctp_auto_asconf) == 0) &&
            (*mopt != 0)) {
          /* forbidden by admin */
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EPERM);
          return (EPERM);
        }
        set_opt = SCTP_PCB_FLAGS_AUTO_ASCONF;
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        return (EINVAL);
      }
      break;
    case SCTP_EXPLICIT_EOR:
      set_opt = SCTP_PCB_FLAGS_EXPLICIT_EOR;
      break;
    case SCTP_USE_EXT_RCVINFO:
      set_opt = SCTP_PCB_FLAGS_EXT_RCVINFO;
      break;
    case SCTP_I_WANT_MAPPED_V4_ADDR:
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
        set_opt = SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        return (EINVAL);
      }
      break;
    case SCTP_NODELAY:
      set_opt = SCTP_PCB_FLAGS_NODELAY;
      break;
    case SCTP_AUTOCLOSE:
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        return (EINVAL);
      }
      set_opt = SCTP_PCB_FLAGS_AUTOCLOSE;
      /*
       * The value is in ticks. Note this does not effect
       * old associations, only new ones.
       */
      inp->sctp_ep.auto_close_time = sctp_secs_to_ticks(*mopt);
      break;
    }
    SCTP_INP_WLOCK(inp);
    if (*mopt != 0) {
      sctp_feature_on(inp, set_opt);
    } else {
      sctp_feature_off(inp, set_opt);
    }
    SCTP_INP_WUNLOCK(inp);
    break;
  case SCTP_REUSE_PORT:
  {
    SCTP_CHECK_AND_CAST(mopt, optval, uint32_t, optsize);
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) == 0) {
      /* Can't set it after we are bound */
      error = EINVAL;
      break;
    }
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE)) {
      /* Can't do this for a 1-m socket */
      error = EINVAL;
      break;
    }
    if (optval)
      sctp_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE);
    else
      sctp_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE);
    break;
  }
  case SCTP_PARTIAL_DELIVERY_POINT:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, optsize);
    if (*value > SCTP_SB_LIMIT_RCV(so)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    inp->partial_delivery_point = *value;
    break;
  }
  case SCTP_FRAGMENT_INTERLEAVE:
    /* not yet until we re-write sctp_recvmsg() */
  {
    uint32_t *level;

    SCTP_CHECK_AND_CAST(level, optval, uint32_t, optsize);
    if (*level == SCTP_FRAG_LEVEL_2) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
      sctp_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);
    } else if (*level == SCTP_FRAG_LEVEL_1) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
      sctp_feature_off(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);
    } else if (*level == SCTP_FRAG_LEVEL_0) {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
      sctp_feature_off(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);

    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }
  case SCTP_INTERLEAVING_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->idata_supported = 0;
        } else {
          if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) &&
              (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS))) {
            inp->idata_supported = 1;
          } else {
            /* Must have Frag interleave and stream interleave on */
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
            error = EINVAL;
          }
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_CMT_ON_OFF:
    if (SCTP_BASE_SYSCTL(sctp_cmt_on_off)) {
      struct sctp_assoc_value *av;

      SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
      if (av->assoc_value > SCTP_CMT_MAX) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
      SCTP_FIND_STCB(inp, stcb, av->assoc_id);
      if (stcb) {
        stcb->asoc.sctp_cmt_on_off = av->assoc_value;
        SCTP_TCB_UNLOCK(stcb);
      } else {
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
            (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
            ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
             ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
              (av->assoc_id == SCTP_ALL_ASSOC)))) {
          SCTP_INP_WLOCK(inp);
          inp->sctp_cmt_on_off = av->assoc_value;
          SCTP_INP_WUNLOCK(inp);
        }
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
            ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
             (av->assoc_id == SCTP_ALL_ASSOC))) {
          SCTP_INP_RLOCK(inp);
          LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
            SCTP_TCB_LOCK(stcb);
            stcb->asoc.sctp_cmt_on_off = av->assoc_value;
            SCTP_TCB_UNLOCK(stcb);
          }
          SCTP_INP_RUNLOCK(inp);
        }
      }
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
      error = ENOPROTOOPT;
    }
    break;
  case SCTP_PLUGGABLE_CC:
  {
    struct sctp_assoc_value *av;
    struct sctp_nets *net;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    if ((av->assoc_value != SCTP_CC_RFC2581) &&
        (av->assoc_value != SCTP_CC_HSTCP) &&
        (av->assoc_value != SCTP_CC_HTCP) &&
        (av->assoc_value != SCTP_CC_RTCC)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      stcb->asoc.cc_functions = sctp_cc_functions[av->assoc_value];
      stcb->asoc.congestion_control_module = av->assoc_value;
      if (stcb->asoc.cc_functions.sctp_set_initial_cc_param != NULL) {
        TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
          stcb->asoc.cc_functions.sctp_set_initial_cc_param(stcb, net);
        }
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
            (av->assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_ep.sctp_default_cc_module = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
           (av->assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.cc_functions = sctp_cc_functions[av->assoc_value];
          stcb->asoc.congestion_control_module = av->assoc_value;
          if (stcb->asoc.cc_functions.sctp_set_initial_cc_param != NULL) {
            TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
              stcb->asoc.cc_functions.sctp_set_initial_cc_param(stcb, net);
            }
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_CC_OPTION:
  {
    struct sctp_cc_option *cc_opt;

    SCTP_CHECK_AND_CAST(cc_opt, optval, struct sctp_cc_option, optsize);
    SCTP_FIND_STCB(inp, stcb, cc_opt->aid_value.assoc_id);
    if (stcb == NULL) {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          (cc_opt->aid_value.assoc_id == SCTP_CURRENT_ASSOC)) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          if (stcb->asoc.cc_functions.sctp_cwnd_socket_option) {
            (*stcb->asoc.cc_functions.sctp_cwnd_socket_option)(stcb, 1, cc_opt);
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      } else {
        error = EINVAL;
      }
    } else {
      if (stcb->asoc.cc_functions.sctp_cwnd_socket_option == NULL) {
        error = ENOTSUP;
      } else {
        error = (*stcb->asoc.cc_functions.sctp_cwnd_socket_option)(stcb, 1,
                         cc_opt);
      }
      SCTP_TCB_UNLOCK(stcb);
    }
    break;
  }
  case SCTP_STREAM_SCHEDULER:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    if ((av->assoc_value != SCTP_SS_DEFAULT) &&
        (av->assoc_value != SCTP_SS_RR) &&
        (av->assoc_value != SCTP_SS_RR_PKT) &&
        (av->assoc_value != SCTP_SS_PRIO) &&
        (av->assoc_value != SCTP_SS_FB) &&
        (av->assoc_value != SCTP_SS_FCFS)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, true);
      stcb->asoc.ss_functions = sctp_ss_functions[av->assoc_value];
      stcb->asoc.stream_scheduling_module = av->assoc_value;
      stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc);
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
            (av->assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_ep.sctp_default_ss_module = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
           (av->assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, true);
          stcb->asoc.ss_functions = sctp_ss_functions[av->assoc_value];
          stcb->asoc.stream_scheduling_module = av->assoc_value;
          stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc);
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_STREAM_SCHEDULER_VALUE:
  {
    struct sctp_stream_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_stream_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      if ((av->stream_id >= stcb->asoc.streamoutcnt) ||
          (stcb->asoc.ss_functions.sctp_ss_set_value(stcb, &stcb->asoc, &stcb->asoc.strmout[av->stream_id],
                                                     av->stream_value) < 0)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          (av->assoc_id == SCTP_CURRENT_ASSOC)) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          if (av->stream_id < stcb->asoc.streamoutcnt) {
            stcb->asoc.ss_functions.sctp_ss_set_value(stcb,
                                                      &stcb->asoc,
                                                      &stcb->asoc.strmout[av->stream_id],
                                                      av->stream_value);
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      } else {
        /* Can't set stream value without association */
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_CLR_STAT_LOG:
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    error = EOPNOTSUPP;
    break;
  case SCTP_CONTEXT:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      stcb->asoc.context = av->assoc_value;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
            (av->assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_context = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
           (av->assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.context = av->assoc_value;
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_VRF_ID:
  {
    uint32_t *default_vrfid;
#ifdef SCTP_MVRF
    int i;
#endif
    SCTP_CHECK_AND_CAST(default_vrfid, optval, uint32_t, optsize);
    if (*default_vrfid > SCTP_MAX_VRF_ID) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
#ifdef SCTP_MVRF
    for (i = 0; i < inp->num_vrfs; i++) {
      /* The VRF must be in the VRF list */
      if (*default_vrfid == inp->m_vrf_ids[i]) {
        SCTP_INP_WLOCK(inp);
        inp->def_vrf_id = *default_vrfid;
        SCTP_INP_WUNLOCK(inp);
        goto sctp_done;
      }
    }
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
#else
    inp->def_vrf_id = *default_vrfid;
#endif
#ifdef SCTP_MVRF
  sctp_done:
#endif
    break;
  }
  case SCTP_DEL_VRF_ID:
  {
#ifdef SCTP_MVRF
    uint32_t *del_vrfid;
    int i, fnd = 0;

    SCTP_CHECK_AND_CAST(del_vrfid, optval, uint32_t, optsize);
    if (*del_vrfid > SCTP_MAX_VRF_ID) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if (inp->num_vrfs == 1) {
      /* Can't delete last one */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) == 0) {
      /* Can't add more once you are bound */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    SCTP_INP_WLOCK(inp);
    for (i = 0; i < inp->num_vrfs; i++) {
      if (*del_vrfid == inp->m_vrf_ids[i]) {
        fnd = 1;
        break;
      }
    }
    if (!fnd) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if (i != (inp->num_vrfs - 1)) {
      /* Take bottom one and move to this slot */
      inp->m_vrf_ids[i] = inp->m_vrf_ids[(inp->num_vrfs-1)];
    }
    if (*del_vrfid == inp->def_vrf_id) {
      /* Take the first one as the new default */
      inp->def_vrf_id = inp->m_vrf_ids[0];
    }
    /* Drop the number by one killing last one */
    inp->num_vrfs--;
#else
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    error = EOPNOTSUPP;
#endif
    break;
  }
  case SCTP_ADD_VRF_ID:
  {
#ifdef SCTP_MVRF
    uint32_t *add_vrfid;
    int i;

    SCTP_CHECK_AND_CAST(add_vrfid, optval, uint32_t, optsize);
    if (*add_vrfid > SCTP_MAX_VRF_ID) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) == 0) {
      /* Can't add more once you are bound */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    SCTP_INP_WLOCK(inp);
    /* Verify its not already here */
    for (i = 0; i < inp->num_vrfs; i++) {
      if (*add_vrfid == inp->m_vrf_ids[i]) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
        error = EALREADY;
        SCTP_INP_WUNLOCK(inp);
        break;
      }
    }
    if ((inp->num_vrfs + 1) > inp->vrf_size) {
      /* need to grow array */
      uint32_t *tarray;
      SCTP_MALLOC(tarray, uint32_t *,
            (sizeof(uint32_t) * (inp->vrf_size + SCTP_DEFAULT_VRF_SIZE)),
            SCTP_M_MVRF);
      if (tarray == NULL) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
        error = ENOMEM;
        SCTP_INP_WUNLOCK(inp);
        break;
      }
      memcpy(tarray, inp->m_vrf_ids, (sizeof(uint32_t) * inp->vrf_size));
      SCTP_FREE(inp->m_vrf_ids, SCTP_M_MVRF);
      inp->m_vrf_ids = tarray;
      inp->vrf_size += SCTP_DEFAULT_VRF_SIZE;
    }
    inp->m_vrf_ids[inp->num_vrfs] = *add_vrfid;
    inp->num_vrfs++;
    SCTP_INP_WUNLOCK(inp);
#else
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    error = EOPNOTSUPP;
#endif
    break;
  }
  case SCTP_DELAYED_SACK:
  {
    struct sctp_sack_info *sack;

    SCTP_CHECK_AND_CAST(sack, optval, struct sctp_sack_info, optsize);
    SCTP_FIND_STCB(inp, stcb, sack->sack_assoc_id);
    if (sack->sack_delay) {
      if (sack->sack_delay > SCTP_MAX_SACK_DELAY) {
        error = EINVAL;
        if (stcb != NULL) {
          SCTP_TCB_UNLOCK(stcb);
        }
        break;
      }
    }
    if (stcb) {
      if (sack->sack_delay) {
        stcb->asoc.delayed_ack = sack->sack_delay;
      }
      if (sack->sack_freq) {
        stcb->asoc.sack_freq = sack->sack_freq;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((sack->sack_assoc_id == SCTP_FUTURE_ASSOC) ||
            (sack->sack_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        if (sack->sack_delay) {
          inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV] = sctp_msecs_to_ticks(sack->sack_delay);
        }
        if (sack->sack_freq) {
          inp->sctp_ep.sctp_sack_freq = sack->sack_freq;
        }
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((sack->sack_assoc_id == SCTP_CURRENT_ASSOC) ||
           (sack->sack_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          if (sack->sack_delay) {
            stcb->asoc.delayed_ack = sack->sack_delay;
          }
          if (sack->sack_freq) {
            stcb->asoc.sack_freq = sack->sack_freq;
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_AUTH_CHUNK:
  {
    struct sctp_authchunk *sauth;

    SCTP_CHECK_AND_CAST(sauth, optval, struct sctp_authchunk, optsize);

    SCTP_INP_WLOCK(inp);
    if (sctp_auth_add_chunk(sauth->sauth_chunk, inp->sctp_ep.local_auth_chunks)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    } else {
      inp->auth_supported = 1;
    }
    SCTP_INP_WUNLOCK(inp);
    break;
  }
  case SCTP_AUTH_KEY:
  {
    struct sctp_authkey *sca;
    struct sctp_keyhead *shared_keys;
    sctp_sharedkey_t *shared_key;
    sctp_key_t *key = NULL;
    size_t size;

    SCTP_CHECK_AND_CAST(sca, optval, struct sctp_authkey, optsize);
    if (sca->sca_keylength == 0) {
      size = optsize - sizeof(struct sctp_authkey);
    } else {
      if (sca->sca_keylength + sizeof(struct sctp_authkey) <= optsize) {
        size = sca->sca_keylength;
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
    }
    SCTP_FIND_STCB(inp, stcb, sca->sca_assoc_id);

    if (stcb) {
      shared_keys = &stcb->asoc.shared_keys;
      /* clear the cached keys for this key id */
      sctp_clear_cachedkeys(stcb, sca->sca_keynumber);
      /*
       * create the new shared key and
       * insert/replace it
       */
      if (size > 0) {
        key = sctp_set_key(sca->sca_key, (uint32_t) size);
        if (key == NULL) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
          error = ENOMEM;
          SCTP_TCB_UNLOCK(stcb);
          break;
        }
      }
      shared_key = sctp_alloc_sharedkey();
      if (shared_key == NULL) {
        sctp_free_key(key);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
        error = ENOMEM;
        SCTP_TCB_UNLOCK(stcb);
        break;
      }
      shared_key->key = key;
      shared_key->keyid = sca->sca_keynumber;
      error = sctp_insert_sharedkey(shared_keys, shared_key);
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((sca->sca_assoc_id == SCTP_FUTURE_ASSOC) ||
            (sca->sca_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        shared_keys = &inp->sctp_ep.shared_keys;
        /*
         * clear the cached keys on all assocs for
         * this key id
         */
        sctp_clear_cachedkeys_ep(inp, sca->sca_keynumber);
        /*
         * create the new shared key and
         * insert/replace it
         */
        if (size > 0) {
          key = sctp_set_key(sca->sca_key, (uint32_t) size);
          if (key == NULL) {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
            error = ENOMEM;
            SCTP_INP_WUNLOCK(inp);
            break;
          }
        }
        shared_key = sctp_alloc_sharedkey();
        if (shared_key == NULL) {
          sctp_free_key(key);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
          error = ENOMEM;
          SCTP_INP_WUNLOCK(inp);
          break;
        }
        shared_key->key = key;
        shared_key->keyid = sca->sca_keynumber;
        error = sctp_insert_sharedkey(shared_keys, shared_key);
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((sca->sca_assoc_id == SCTP_CURRENT_ASSOC) ||
           (sca->sca_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          shared_keys = &stcb->asoc.shared_keys;
          /* clear the cached keys for this key id */
          sctp_clear_cachedkeys(stcb, sca->sca_keynumber);
          /*
           * create the new shared key and
           * insert/replace it
           */
          if (size > 0) {
            key = sctp_set_key(sca->sca_key, (uint32_t) size);
            if (key == NULL) {
              SCTP_TCB_UNLOCK(stcb);
              continue;
            }
          }
          shared_key = sctp_alloc_sharedkey();
          if (shared_key == NULL) {
            sctp_free_key(key);
            SCTP_TCB_UNLOCK(stcb);
            continue;
          }
          shared_key->key = key;
          shared_key->keyid = sca->sca_keynumber;
          error = sctp_insert_sharedkey(shared_keys, shared_key);
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_HMAC_IDENT:
  {
    struct sctp_hmacalgo *shmac;
    sctp_hmaclist_t *hmaclist;
    uint16_t hmacid;
    uint32_t i;

    SCTP_CHECK_AND_CAST(shmac, optval, struct sctp_hmacalgo, optsize);
    if ((optsize < sizeof(struct sctp_hmacalgo) + shmac->shmac_number_of_idents * sizeof(uint16_t)) ||
        (shmac->shmac_number_of_idents > 0xffff)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }

    hmaclist = sctp_alloc_hmaclist((uint16_t)shmac->shmac_number_of_idents);
    if (hmaclist == NULL) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
      error = ENOMEM;
      break;
    }
    for (i = 0; i < shmac->shmac_number_of_idents; i++) {
      hmacid = shmac->shmac_idents[i];
      if (sctp_auth_add_hmacid(hmaclist, hmacid)) {
        /* invalid HMACs were found */;
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        sctp_free_hmaclist(hmaclist);
        goto sctp_set_hmac_done;
      }
    }
    for (i = 0; i < hmaclist->num_algo; i++) {
      if (hmaclist->hmac[i] == SCTP_AUTH_HMAC_ID_SHA1) {
        /* already in list */
        break;
      }
    }
    if (i == hmaclist->num_algo) {
      /* not found in list */
      sctp_free_hmaclist(hmaclist);
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    /* set it on the endpoint */
    SCTP_INP_WLOCK(inp);
    if (inp->sctp_ep.local_hmacs)
      sctp_free_hmaclist(inp->sctp_ep.local_hmacs);
    inp->sctp_ep.local_hmacs = hmaclist;
    SCTP_INP_WUNLOCK(inp);
  sctp_set_hmac_done:
    break;
  }
  case SCTP_AUTH_ACTIVE_KEY:
  {
    struct sctp_authkeyid *scact;

    SCTP_CHECK_AND_CAST(scact, optval, struct sctp_authkeyid, optsize);
    SCTP_FIND_STCB(inp, stcb, scact->scact_assoc_id);

    /* set the active key on the right place */
    if (stcb) {
      /* set the active key on the assoc */
      if (sctp_auth_setactivekey(stcb,
               scact->scact_keynumber)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL,
                SCTP_FROM_SCTP_USRREQ,
                EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((scact->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
            (scact->scact_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        if (sctp_auth_setactivekey_ep(inp, scact->scact_keynumber)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((scact->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
           (scact->scact_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          sctp_auth_setactivekey(stcb, scact->scact_keynumber);
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_AUTH_DELETE_KEY:
  {
    struct sctp_authkeyid *scdel;

    SCTP_CHECK_AND_CAST(scdel, optval, struct sctp_authkeyid, optsize);
    SCTP_FIND_STCB(inp, stcb, scdel->scact_assoc_id);

    /* delete the key from the right place */
    if (stcb) {
      if (sctp_delete_sharedkey(stcb, scdel->scact_keynumber)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((scdel->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
            (scdel->scact_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        if (sctp_delete_sharedkey_ep(inp, scdel->scact_keynumber)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((scdel->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
           (scdel->scact_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          sctp_delete_sharedkey(stcb, scdel->scact_keynumber);
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_AUTH_DEACTIVATE_KEY:
  {
    struct sctp_authkeyid *keyid;

    SCTP_CHECK_AND_CAST(keyid, optval, struct sctp_authkeyid, optsize);
    SCTP_FIND_STCB(inp, stcb, keyid->scact_assoc_id);

    /* deactivate the key from the right place */
    if (stcb) {
      if (sctp_deact_sharedkey(stcb, keyid->scact_keynumber)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((keyid->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
            (keyid->scact_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        if (sctp_deact_sharedkey_ep(inp, keyid->scact_keynumber)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((keyid->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
           (keyid->scact_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          sctp_deact_sharedkey(stcb, keyid->scact_keynumber);
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_ENABLE_STREAM_RESET:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    if (av->assoc_value & (~SCTP_ENABLE_VALUE_MASK)) {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);
    if (stcb) {
      stcb->asoc.local_strreset_support = (uint8_t)av->assoc_value;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
            (av->assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->local_strreset_support = (uint8_t)av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
           (av->assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.local_strreset_support = (uint8_t)av->assoc_value;
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_RESET_STREAMS:
  {
    struct sctp_reset_streams *strrst;
    int i, send_out = 0;
    int send_in = 0;

    SCTP_CHECK_AND_CAST(strrst, optval, struct sctp_reset_streams, optsize);
    SCTP_FIND_STCB(inp, stcb, strrst->srs_assoc_id);
    if (stcb == NULL) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
      break;
    }
    if (stcb->asoc.reconfig_supported == 0) {
      /*
       * Peer does not support the chunk type.
       */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
      error = EOPNOTSUPP;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (sizeof(struct sctp_reset_streams) +
        strrst->srs_number_streams * sizeof(uint16_t) > optsize) {
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (strrst->srs_flags & SCTP_STREAM_RESET_INCOMING) {
      send_in = 1;
      if (stcb->asoc.stream_reset_outstanding) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
        error = EALREADY;
        SCTP_TCB_UNLOCK(stcb);
        break;
      }
    }
    if (strrst->srs_flags & SCTP_STREAM_RESET_OUTGOING) {
      send_out = 1;
    }
    if ((strrst->srs_number_streams > SCTP_MAX_STREAMS_AT_ONCE_RESET) && send_in) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
      error = ENOMEM;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if ((send_in == 0) && (send_out == 0)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    for (i = 0; i < strrst->srs_number_streams; i++) {
      if ((send_in) &&
          (strrst->srs_stream_list[i] >= stcb->asoc.streamincnt)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
      if ((send_out) &&
          (strrst->srs_stream_list[i] >= stcb->asoc.streamoutcnt)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
    }
    if (error) {
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (send_out) {
      int cnt;
      uint16_t strm;
      if (strrst->srs_number_streams) {
        for (i = 0, cnt = 0; i < strrst->srs_number_streams; i++) {
          strm = strrst->srs_stream_list[i];
          if (stcb->asoc.strmout[strm].state == SCTP_STREAM_OPEN) {
            stcb->asoc.strmout[strm].state = SCTP_STREAM_RESET_PENDING;
            cnt++;
          }
        }
      } else {
        /* Its all */
        for (i = 0, cnt = 0; i < stcb->asoc.streamoutcnt; i++) {
          if (stcb->asoc.strmout[i].state == SCTP_STREAM_OPEN) {
            stcb->asoc.strmout[i].state = SCTP_STREAM_RESET_PENDING;
            cnt++;
          }
        }
      }
    }
    if (send_in) {
      error = sctp_send_str_reset_req(stcb, strrst->srs_number_streams,
              strrst->srs_stream_list,
              send_in, 0, 0, 0, 0, 0);
    } else {
      error = sctp_send_stream_reset_out_if_possible(stcb, SCTP_SO_LOCKED);
    }
    if (error == 0) {
      sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
    } else {
       /*
        * For outgoing streams don't report any problems in
        * sending the request to the application.
        * XXX: Double check resetting incoming streams.
        */
      error = 0;
    }
    SCTP_TCB_UNLOCK(stcb);
    break;
  }
  case SCTP_ADD_STREAMS:
  {
    struct sctp_add_streams *stradd;
    uint8_t addstream = 0;
    uint16_t add_o_strmcnt = 0;
    uint16_t add_i_strmcnt = 0;

    SCTP_CHECK_AND_CAST(stradd, optval, struct sctp_add_streams, optsize);
    SCTP_FIND_STCB(inp, stcb, stradd->sas_assoc_id);
    if (stcb == NULL) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
      break;
    }
    if (stcb->asoc.reconfig_supported == 0) {
      /*
       * Peer does not support the chunk type.
       */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
      error = EOPNOTSUPP;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (stcb->asoc.stream_reset_outstanding) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
      error = EALREADY;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if ((stradd->sas_outstrms == 0) &&
        (stradd->sas_instrms == 0)) {
      error = EINVAL;
      goto skip_stuff;
    }
    if (stradd->sas_outstrms) {
      addstream = 1;
      /* We allocate here */
      add_o_strmcnt = stradd->sas_outstrms;
      if ((((int)add_o_strmcnt) + ((int)stcb->asoc.streamoutcnt)) > 0x0000ffff) {
        /* You can't have more than 64k */
        error = EINVAL;
        goto skip_stuff;
      }
    }
    if (stradd->sas_instrms) {
      int cnt;

      addstream |= 2;
      /* We allocate inside sctp_send_str_reset_req() */
      add_i_strmcnt = stradd->sas_instrms;
      cnt = add_i_strmcnt;
      cnt += stcb->asoc.streamincnt;
      if (cnt > 0x0000ffff) {
        /* You can't have more than 64k */
        error = EINVAL;
        goto skip_stuff;
      }
      if (cnt > (int)stcb->asoc.max_inbound_streams) {
        /* More than you are allowed */
        error = EINVAL;
        goto skip_stuff;
      }
    }
    error = sctp_send_str_reset_req(stcb, 0, NULL, 0, 0, addstream, add_o_strmcnt, add_i_strmcnt, 0);
    sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
  skip_stuff:
    SCTP_TCB_UNLOCK(stcb);
    break;
  }
  case SCTP_RESET_ASSOC:
  {
    int i;
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, optsize);
    SCTP_FIND_STCB(inp, stcb, (sctp_assoc_t) *value);
    if (stcb == NULL) {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
      break;
    }
    if (stcb->asoc.reconfig_supported == 0) {
      /*
       * Peer does not support the chunk type.
       */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
      error = EOPNOTSUPP;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    if (stcb->asoc.stream_reset_outstanding) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
      error = EALREADY;
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    /* Is there any data pending in the send or sent queues? */
    if (!TAILQ_EMPTY(&stcb->asoc.send_queue) ||
        !TAILQ_EMPTY(&stcb->asoc.sent_queue)) {
    busy_out:
      error = EBUSY;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      SCTP_TCB_UNLOCK(stcb);
      break;
    }
    /* Do any streams have data queued? */
    for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
      if (!TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) {
        goto busy_out;
      }
    }
    error = sctp_send_str_reset_req(stcb, 0, NULL, 0, 1, 0, 0, 0, 0);
    sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
    SCTP_TCB_UNLOCK(stcb);
    break;
  }
  case SCTP_CONNECT_X:
    if (optsize < (sizeof(int) + sizeof(struct sockaddr_in))) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    error = sctp_do_connect_x(so, inp, optval, optsize, p, 0);
    break;
  case SCTP_CONNECT_X_DELAYED:
    if (optsize < (sizeof(int) + sizeof(struct sockaddr_in))) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    error = sctp_do_connect_x(so, inp, optval, optsize, p, 1);
    break;
  case SCTP_CONNECT_X_COMPLETE:
  {
    struct sockaddr *sa;

    /* FIXME MT: check correct? */
    SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);

    /* find tcb */
    if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
      SCTP_INP_RLOCK(inp);
      stcb = LIST_FIRST(&inp->sctp_asoc_list);
      if (stcb) {
        SCTP_TCB_LOCK(stcb);
      }
      SCTP_INP_RUNLOCK(inp);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }

    if (stcb == NULL) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      error = ENOENT;
      break;
    }
    if (stcb->asoc.delayed_connection == 1) {
      stcb->asoc.delayed_connection = 0;
      (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
      sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, stcb,
          stcb->asoc.primary_destination,
          SCTP_FROM_SCTP_USRREQ + SCTP_LOC_8);
      sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
    } else {
      /*
       * already expired or did not use delayed
       * connectx
       */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
      error = EALREADY;
    }
    SCTP_TCB_UNLOCK(stcb);
    break;
  }
  case SCTP_MAX_BURST:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      stcb->asoc.max_burst = av->assoc_value;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((av->assoc_id == SCTP_FUTURE_ASSOC) ||
            (av->assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_ep.max_burst = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((av->assoc_id == SCTP_CURRENT_ASSOC) ||
           (av->assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.max_burst = av->assoc_value;
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_MAXSEG:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      stcb->asoc.sctp_frag_point = av->assoc_value;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_frag_point = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_EVENTS:
  {
    struct sctp_event_subscribe *events;

    SCTP_CHECK_AND_CAST(events, optval, struct sctp_event_subscribe, optsize);

    SCTP_INP_WLOCK(inp);
    if (events->sctp_data_io_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT);
    }

    if (events->sctp_association_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT);
    }

    if (events->sctp_address_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVPADDREVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVPADDREVNT);
    }

    if (events->sctp_send_failure_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
    }

    if (events->sctp_peer_error_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVPEERERR);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVPEERERR);
    }

    if (events->sctp_shutdown_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
    }

    if (events->sctp_partial_delivery_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_PDAPIEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_PDAPIEVNT);
    }

    if (events->sctp_adaptation_layer_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
    }

    if (events->sctp_authentication_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_AUTHEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_AUTHEVNT);
    }

    if (events->sctp_sender_dry_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_DRYEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_DRYEVNT);
    }

    if (events->sctp_stream_reset_event) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
    }

    LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
      SCTP_TCB_LOCK(stcb);
      if (events->sctp_association_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVASSOCEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVASSOCEVNT);
      }
      if (events->sctp_address_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVPADDREVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVPADDREVNT);
      }
      if (events->sctp_send_failure_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
      }
      if (events->sctp_peer_error_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVPEERERR);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVPEERERR);
      }
      if (events->sctp_shutdown_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
      }
      if (events->sctp_partial_delivery_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_PDAPIEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_PDAPIEVNT);
      }
      if (events->sctp_adaptation_layer_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
      }
      if (events->sctp_authentication_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_AUTHEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_AUTHEVNT);
      }
      if (events->sctp_sender_dry_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DRYEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DRYEVNT);
      }
      if (events->sctp_stream_reset_event) {
        sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
      } else {
        sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
      }
      SCTP_TCB_UNLOCK(stcb);
    }
    /* Send up the sender dry event only for 1-to-1 style sockets. */
    if (events->sctp_sender_dry_event) {
      if (((inp->sctp_flags & (SCTP_PCB_FLAGS_TCPTYPE | SCTP_PCB_FLAGS_IN_TCPPOOL)) != 0) &&
          !SCTP_IS_LISTENING(inp)) {
        stcb = LIST_FIRST(&inp->sctp_asoc_list);
        if (stcb != NULL) {
          SCTP_TCB_LOCK(stcb);
          if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
              TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
              (stcb->asoc.stream_queue_cnt == 0)) {
            sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb, 0, NULL, SCTP_SO_LOCKED);
          }
          SCTP_TCB_UNLOCK(stcb);
        }
      }
    }
    SCTP_INP_WUNLOCK(inp);
    break;
  }
  case SCTP_ADAPTATION_LAYER:
  {
    struct sctp_setadaptation *adap_bits;

    SCTP_CHECK_AND_CAST(adap_bits, optval, struct sctp_setadaptation, optsize);
    SCTP_INP_WLOCK(inp);
    inp->sctp_ep.adaptation_layer_indicator = adap_bits->ssb_adaptation_ind;
    inp->sctp_ep.adaptation_layer_indicator_provided = 1;
    SCTP_INP_WUNLOCK(inp);
    break;
  }
#ifdef SCTP_DEBUG
  case SCTP_SET_INITIAL_DBG_SEQ:
  {
    uint32_t *vvv;

    SCTP_CHECK_AND_CAST(vvv, optval, uint32_t, optsize);
    SCTP_INP_WLOCK(inp);
    inp->sctp_ep.initial_sequence_debug = *vvv;
    SCTP_INP_WUNLOCK(inp);
    break;
  }
#endif
  case SCTP_DEFAULT_SEND_PARAM:
  {
    struct sctp_sndrcvinfo *s_info;

    SCTP_CHECK_AND_CAST(s_info, optval, struct sctp_sndrcvinfo, optsize);
    SCTP_FIND_STCB(inp, stcb, s_info->sinfo_assoc_id);

    if (stcb) {
      if (s_info->sinfo_stream < stcb->asoc.streamoutcnt) {
        memcpy(&stcb->asoc.def_send, s_info, min(optsize, sizeof(stcb->asoc.def_send)));
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((s_info->sinfo_assoc_id == SCTP_FUTURE_ASSOC) ||
            (s_info->sinfo_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        memcpy(&inp->def_send, s_info, min(optsize, sizeof(inp->def_send)));
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((s_info->sinfo_assoc_id == SCTP_CURRENT_ASSOC) ||
           (s_info->sinfo_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          if (s_info->sinfo_stream < stcb->asoc.streamoutcnt) {
            memcpy(&stcb->asoc.def_send, s_info, min(optsize, sizeof(stcb->asoc.def_send)));
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_PEER_ADDR_PARAMS:
  {
    struct sctp_paddrparams *paddrp;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(paddrp, optval, struct sctp_paddrparams, optsize);
    SCTP_FIND_STCB(inp, stcb, paddrp->spp_assoc_id);

#if defined(INET) && defined(INET6)
    if (paddrp->spp_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&paddrp->spp_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&paddrp->spp_address;
      }
    } else {
      addr = (struct sockaddr *)&paddrp->spp_address;
    }
#else
    addr = (struct sockaddr *)&paddrp->spp_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr,
                                          &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
      {
        error = EAFNOSUPPORT;
        SCTP_TCB_UNLOCK(stcb);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }
    /* sanity checks */
    if ((paddrp->spp_flags & SPP_HB_ENABLE) && (paddrp->spp_flags & SPP_HB_DISABLE)) {
      if (stcb)
        SCTP_TCB_UNLOCK(stcb);
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }

    if ((paddrp->spp_flags & SPP_PMTUD_ENABLE) && (paddrp->spp_flags & SPP_PMTUD_DISABLE)) {
      if (stcb)
        SCTP_TCB_UNLOCK(stcb);
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
    if ((paddrp->spp_flags & SPP_PMTUD_DISABLE) &&
        (paddrp->spp_pathmtu > 0) &&
        ((paddrp->spp_pathmtu < SCTP_SMALLEST_PMTU) ||
         (paddrp->spp_pathmtu > SCTP_LARGEST_PMTU))) {
      if (stcb)
        SCTP_TCB_UNLOCK(stcb);
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }

    if (stcb != NULL) {
      /************************TCB SPECIFIC SET ******************/
      if (net != NULL) {
        /************************NET SPECIFIC SET ******************/
        if (paddrp->spp_flags & SPP_HB_DISABLE) {
          if (((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) &&
              ((net->dest_state & SCTP_ADDR_NOHB) == 0)) {
            sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
                            SCTP_FROM_SCTP_USRREQ + SCTP_LOC_9);
          }
          net->dest_state |= SCTP_ADDR_NOHB;
        }
        if (paddrp->spp_flags & SPP_HB_ENABLE) {
          if (paddrp->spp_hbinterval) {
            net->heart_beat_delay = paddrp->spp_hbinterval;
          } else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
            net->heart_beat_delay = 0;
          }
          sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
                          SCTP_FROM_SCTP_USRREQ + SCTP_LOC_10);
          sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
          net->dest_state &= ~SCTP_ADDR_NOHB;
        }
        if (paddrp->spp_flags & SPP_HB_DEMAND) {
          if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
            sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
            sctp_chunk_output(inp, stcb,  SCTP_OUTPUT_FROM_SOCKOPT, SCTP_SO_LOCKED);
            sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
          }
        }
        if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
          if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
            sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
                            SCTP_FROM_SCTP_USRREQ + SCTP_LOC_11);
          }
          net->dest_state |= SCTP_ADDR_NO_PMTUD;
          if (paddrp->spp_pathmtu > 0) {
            net->mtu = paddrp->spp_pathmtu;
            switch (net->ro._l_addr.sa.sa_family) {
#ifdef INET
            case AF_INET:
              net->mtu += SCTP_MIN_V4_OVERHEAD;
              break;
#endif
#ifdef INET6
            case AF_INET6:
              net->mtu += SCTP_MIN_OVERHEAD;
              break;
#endif
#if defined(__Userspace__)
            case AF_CONN:
              net->mtu += sizeof(struct sctphdr);
              break;
#endif
            default:
              break;
            }
            if (net->mtu < stcb->asoc.smallest_mtu) {
              sctp_pathmtu_adjustment(stcb, net->mtu, true);
            }
          }
        }
        if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
          if (!SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
            sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
          }
          net->dest_state &= ~SCTP_ADDR_NO_PMTUD;
        }
        if (paddrp->spp_pathmaxrxt > 0) {
          if (net->dest_state & SCTP_ADDR_PF) {
            if (net->error_count > paddrp->spp_pathmaxrxt) {
              net->dest_state &= ~SCTP_ADDR_PF;
            }
          } else {
            if ((net->error_count <= paddrp->spp_pathmaxrxt) &&
                (net->error_count > net->pf_threshold)) {
              net->dest_state |= SCTP_ADDR_PF;
              sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
              sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
                              stcb->sctp_ep, stcb, net,
                              SCTP_FROM_SCTP_USRREQ + SCTP_LOC_12);
              sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
            }
          }
          if (net->dest_state & SCTP_ADDR_REACHABLE) {
            if (net->error_count > paddrp->spp_pathmaxrxt) {
              net->dest_state &= ~SCTP_ADDR_REACHABLE;
              sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
            }
          } else {
            if (net->error_count <= paddrp->spp_pathmaxrxt) {
              net->dest_state |= SCTP_ADDR_REACHABLE;
              sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
            }
          }
          net->failure_threshold = paddrp->spp_pathmaxrxt;
        }
        if (paddrp->spp_flags & SPP_DSCP) {
          net->dscp = paddrp->spp_dscp & 0xfc;
          net->dscp |= 0x01;
        }
#ifdef INET6
        if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
          if (net->ro._l_addr.sa.sa_family == AF_INET6) {
            net->flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
            net->flowlabel |= 0x80000000;
          }
        }
#endif
      } else {
        /************************ASSOC ONLY -- NO NET SPECIFIC SET ******************/
        if (paddrp->spp_pathmaxrxt > 0) {
          stcb->asoc.def_net_failure = paddrp->spp_pathmaxrxt;
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if (net->dest_state & SCTP_ADDR_PF) {
              if (net->error_count > paddrp->spp_pathmaxrxt) {
                net->dest_state &= ~SCTP_ADDR_PF;
              }
            } else {
              if ((net->error_count <= paddrp->spp_pathmaxrxt) &&
                  (net->error_count > net->pf_threshold)) {
                net->dest_state |= SCTP_ADDR_PF;
                sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
                sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
                                stcb->sctp_ep, stcb, net,
                                SCTP_FROM_SCTP_USRREQ + SCTP_LOC_13);
                sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
              }
            }
            if (net->dest_state & SCTP_ADDR_REACHABLE) {
              if (net->error_count > paddrp->spp_pathmaxrxt) {
                net->dest_state &= ~SCTP_ADDR_REACHABLE;
                sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
              }
            } else {
              if (net->error_count <= paddrp->spp_pathmaxrxt) {
                net->dest_state |= SCTP_ADDR_REACHABLE;
                sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
              }
            }
            net->failure_threshold = paddrp->spp_pathmaxrxt;
          }
        }
        if (paddrp->spp_flags & SPP_HB_ENABLE) {
          if (paddrp->spp_hbinterval != 0) {
            stcb->asoc.heart_beat_delay = paddrp->spp_hbinterval;
          } else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
            stcb->asoc.heart_beat_delay = 0;
          }
          /* Turn back on the timer */
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if (paddrp->spp_hbinterval != 0) {
              net->heart_beat_delay = paddrp->spp_hbinterval;
            } else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
              net->heart_beat_delay = 0;
            }
            if (net->dest_state & SCTP_ADDR_NOHB) {
              net->dest_state &= ~SCTP_ADDR_NOHB;
            }
            sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
                SCTP_FROM_SCTP_USRREQ + SCTP_LOC_14);
            sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
          }
          sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
        }
        if (paddrp->spp_flags & SPP_HB_DISABLE) {
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if ((net->dest_state & SCTP_ADDR_NOHB) == 0) {
              net->dest_state |= SCTP_ADDR_NOHB;
              if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) {
                sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
                                inp, stcb, net,
                                SCTP_FROM_SCTP_USRREQ + SCTP_LOC_15);
              }
            }
          }
          sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
        }
        if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
              sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
                              SCTP_FROM_SCTP_USRREQ + SCTP_LOC_16);
            }
            net->dest_state |= SCTP_ADDR_NO_PMTUD;
            if (paddrp->spp_pathmtu > 0) {
              net->mtu = paddrp->spp_pathmtu;
              switch (net->ro._l_addr.sa.sa_family) {
#ifdef INET
              case AF_INET:
                net->mtu += SCTP_MIN_V4_OVERHEAD;
                break;
#endif
#ifdef INET6
              case AF_INET6:
                net->mtu += SCTP_MIN_OVERHEAD;
                break;
#endif
#if defined(__Userspace__)
              case AF_CONN:
                net->mtu += sizeof(struct sctphdr);
                break;
#endif
              default:
                break;
              }
              if (net->mtu < stcb->asoc.smallest_mtu) {
                sctp_pathmtu_adjustment(stcb, net->mtu, true);
              }
            }
          }
          if (paddrp->spp_pathmtu > 0) {
            stcb->asoc.default_mtu = paddrp->spp_pathmtu;
          }
          sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
        }
        if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if (!SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
              sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
            }
            net->dest_state &= ~SCTP_ADDR_NO_PMTUD;
          }
          stcb->asoc.default_mtu = 0;
          sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
        }
        if (paddrp->spp_flags & SPP_DSCP) {
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            net->dscp = paddrp->spp_dscp & 0xfc;
            net->dscp |= 0x01;
          }
          stcb->asoc.default_dscp = paddrp->spp_dscp & 0xfc;
          stcb->asoc.default_dscp |= 0x01;
        }
#ifdef INET6
        if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
          TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
            if (net->ro._l_addr.sa.sa_family == AF_INET6) {
              net->flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
              net->flowlabel |= 0x80000000;
            }
          }
          stcb->asoc.default_flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
          stcb->asoc.default_flowlabel |= 0x80000000;
        }
#endif
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      /************************NO TCB, SET TO default stuff ******************/
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (paddrp->spp_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        /*
         * For the TOS/FLOWLABEL stuff you set it
         * with the options on the socket
         */
        if (paddrp->spp_pathmaxrxt > 0) {
          inp->sctp_ep.def_net_failure = paddrp->spp_pathmaxrxt;
        }

        if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO)
          inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = 0;
        else if (paddrp->spp_hbinterval != 0) {
          if (paddrp->spp_hbinterval > SCTP_MAX_HB_INTERVAL)
            paddrp->spp_hbinterval= SCTP_MAX_HB_INTERVAL;
          inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = sctp_msecs_to_ticks(paddrp->spp_hbinterval);
        }

        if (paddrp->spp_flags & SPP_HB_ENABLE) {
          if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
            inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = 0;
          } else if (paddrp->spp_hbinterval) {
            inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = sctp_msecs_to_ticks(paddrp->spp_hbinterval);
          }
          sctp_feature_off(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
        } else if (paddrp->spp_flags & SPP_HB_DISABLE) {
          sctp_feature_on(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
        }
        if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
          inp->sctp_ep.default_mtu = 0;
          sctp_feature_off(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
        } else if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
          if (paddrp->spp_pathmtu > 0) {
            inp->sctp_ep.default_mtu = paddrp->spp_pathmtu;
          }
          sctp_feature_on(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
        }
        if (paddrp->spp_flags & SPP_DSCP) {
          inp->sctp_ep.default_dscp = paddrp->spp_dscp & 0xfc;
          inp->sctp_ep.default_dscp |= 0x01;
        }
#ifdef INET6
        if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
          if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
            inp->sctp_ep.default_flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
            inp->sctp_ep.default_flowlabel |= 0x80000000;
          }
        }
#endif
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_RTOINFO:
  {
    struct sctp_rtoinfo *srto;
    uint32_t new_init, new_min, new_max;

    SCTP_CHECK_AND_CAST(srto, optval, struct sctp_rtoinfo, optsize);
    SCTP_FIND_STCB(inp, stcb, srto->srto_assoc_id);

    if (stcb) {
      if (srto->srto_initial)
        new_init = srto->srto_initial;
      else
        new_init = stcb->asoc.initial_rto;
      if (srto->srto_max)
        new_max = srto->srto_max;
      else
        new_max = stcb->asoc.maxrto;
      if (srto->srto_min)
        new_min = srto->srto_min;
      else
        new_min = stcb->asoc.minrto;
      if ((new_min <= new_init) && (new_init <= new_max)) {
        stcb->asoc.initial_rto = new_init;
        stcb->asoc.maxrto = new_max;
        stcb->asoc.minrto = new_min;
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (srto->srto_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (srto->srto_initial)
          new_init = srto->srto_initial;
        else
          new_init = inp->sctp_ep.initial_rto;
        if (srto->srto_max)
          new_max = srto->srto_max;
        else
          new_max = inp->sctp_ep.sctp_maxrto;
        if (srto->srto_min)
          new_min = srto->srto_min;
        else
          new_min = inp->sctp_ep.sctp_minrto;
        if ((new_min <= new_init) && (new_init <= new_max)) {
          inp->sctp_ep.initial_rto = new_init;
          inp->sctp_ep.sctp_maxrto = new_max;
          inp->sctp_ep.sctp_minrto = new_min;
        } else {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_ASSOCINFO:
  {
    struct sctp_assocparams *sasoc;

    SCTP_CHECK_AND_CAST(sasoc, optval, struct sctp_assocparams, optsize);
    SCTP_FIND_STCB(inp, stcb, sasoc->sasoc_assoc_id);
    if (sasoc->sasoc_cookie_life > 0) {
      /* boundary check the cookie life */
      if (sasoc->sasoc_cookie_life < SCTP_MIN_COOKIE_LIFE) {
        sasoc->sasoc_cookie_life = SCTP_MIN_COOKIE_LIFE;
      }
      if (sasoc->sasoc_cookie_life > SCTP_MAX_COOKIE_LIFE) {
        sasoc->sasoc_cookie_life = SCTP_MAX_COOKIE_LIFE;
      }
    }
    if (stcb) {
      if (sasoc->sasoc_asocmaxrxt > 0) {
        stcb->asoc.max_send_times = sasoc->sasoc_asocmaxrxt;
      }
      if (sasoc->sasoc_cookie_life > 0) {
        stcb->asoc.cookie_life = sctp_msecs_to_ticks(sasoc->sasoc_cookie_life);
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (sasoc->sasoc_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (sasoc->sasoc_asocmaxrxt > 0) {
          inp->sctp_ep.max_send_times = sasoc->sasoc_asocmaxrxt;
        }
        if (sasoc->sasoc_cookie_life > 0) {
          inp->sctp_ep.def_cookie_life = sctp_msecs_to_ticks(sasoc->sasoc_cookie_life);
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_INITMSG:
  {
    struct sctp_initmsg *sinit;

    SCTP_CHECK_AND_CAST(sinit, optval, struct sctp_initmsg, optsize);
    SCTP_INP_WLOCK(inp);
    if (sinit->sinit_num_ostreams)
      inp->sctp_ep.pre_open_stream_count = sinit->sinit_num_ostreams;

    if (sinit->sinit_max_instreams)
      inp->sctp_ep.max_open_streams_intome = sinit->sinit_max_instreams;

    if (sinit->sinit_max_attempts)
      inp->sctp_ep.max_init_times = sinit->sinit_max_attempts;

    if (sinit->sinit_max_init_timeo)
      inp->sctp_ep.initial_init_rto_max = sinit->sinit_max_init_timeo;
    SCTP_INP_WUNLOCK(inp);
    break;
  }
  case SCTP_PRIMARY_ADDR:
  {
    struct sctp_setprim *spa;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(spa, optval, struct sctp_setprim, optsize);
    SCTP_FIND_STCB(inp, stcb, spa->ssp_assoc_id);

#if defined(INET) && defined(INET6)
    if (spa->ssp_addr.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&spa->ssp_addr;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&spa->ssp_addr;
      }
    } else {
      addr = (struct sockaddr *)&spa->ssp_addr;
    }
#else
    addr = (struct sockaddr *)&spa->ssp_addr;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr,
                                          &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }

    if ((stcb != NULL) && (net != NULL)) {
      if (net != stcb->asoc.primary_destination) {
        if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) == 0) {
          /* Ok we need to set it */
          if (sctp_set_primary_addr(stcb, (struct sockaddr *)NULL, net) == 0) {
            if ((stcb->asoc.alternate) &&
                ((net->dest_state & SCTP_ADDR_PF) == 0) &&
                (net->dest_state & SCTP_ADDR_REACHABLE)) {
              sctp_free_remote_addr(stcb->asoc.alternate);
              stcb->asoc.alternate = NULL;
            }
          } else {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
            error = EINVAL;
          }
        } else {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        }
      }
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    if (stcb != NULL) {
      SCTP_TCB_UNLOCK(stcb);
    }
    break;
  }
  case SCTP_SET_DYNAMIC_PRIMARY:
  {
    union sctp_sockstore *ss;
#ifdef SCTP_MVRF
    int i, fnd = 0;
#endif
#if !defined(_WIN32) && !defined(__Userspace__)
#if defined(__APPLE__)
    struct proc *proc;
#endif
#if defined(__FreeBSD__)
    error = priv_check(curthread,
           PRIV_NETINET_RESERVEDPORT);
#elif defined(__APPLE__)
    proc = (struct proc *)p;
    if (p) {
      error = suser(proc->p_ucred, &proc->p_acflag);
    } else {
      break;
    }
#else
    error = suser(p, 0);
#endif
    if (error)
      break;
#endif

    SCTP_CHECK_AND_CAST(ss, optval, union sctp_sockstore, optsize);
    /* SUPER USER CHECK? */
#ifdef SCTP_MVRF
    for (i = 0; i < inp->num_vrfs; i++) {
      if (vrf_id == inp->m_vrf_ids[i]) {
        fnd = 1;
        break;
      }
    }
    if (!fnd) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
#endif
    error = sctp_dynamic_set_primary(&ss->sa, vrf_id);
    break;
  }
  case SCTP_SET_PEER_PRIMARY_ADDR:
  {
    struct sctp_setpeerprim *sspp;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(sspp, optval, struct sctp_setpeerprim, optsize);
    SCTP_FIND_STCB(inp, stcb, sspp->sspp_assoc_id);
    if (stcb != NULL) {
      struct sctp_ifa *ifa;

#if defined(INET) && defined(INET6)
      if (sspp->sspp_addr.ss_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)&sspp->sspp_addr;
        if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
          in6_sin6_2_sin(&sin_store, sin6);
          addr = (struct sockaddr *)&sin_store;
        } else {
          addr = (struct sockaddr *)&sspp->sspp_addr;
        }
      } else {
        addr = (struct sockaddr *)&sspp->sspp_addr;
      }
#else
      addr = (struct sockaddr *)&sspp->sspp_addr;
#endif
      ifa = sctp_find_ifa_by_addr(addr, stcb->asoc.vrf_id, SCTP_ADDR_NOT_LOCKED);
      if (ifa == NULL) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        goto out_of_it;
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
        /* Must validate the ifa found is in our ep */
        struct sctp_laddr *laddr;
        int found = 0;

        LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
          if (laddr->ifa == NULL) {
            SCTPDBG(SCTP_DEBUG_OUTPUT1, "%s: NULL ifa\n",
              __func__);
            continue;
          }
          if ((sctp_is_addr_restricted(stcb, laddr->ifa)) &&
              (!sctp_is_addr_pending(stcb, laddr->ifa))) {
            continue;
          }
          if (laddr->ifa == ifa) {
            found = 1;
            break;
          }
        }
        if (!found) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
          goto out_of_it;
        }
#if defined(__FreeBSD__) && !defined(__Userspace__)
      } else {
        switch (addr->sa_family) {
#ifdef INET
        case AF_INET:
        {
          struct sockaddr_in *sin;

          sin = (struct sockaddr_in *)addr;
          if (prison_check_ip4(inp->ip_inp.inp.inp_cred,
                               &sin->sin_addr) != 0) {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
            error = EINVAL;
            goto out_of_it;
          }
          break;
        }
#endif
#ifdef INET6
        case AF_INET6:
        {
          struct sockaddr_in6 *sin6;

          sin6 = (struct sockaddr_in6 *)addr;
          if (prison_check_ip6(inp->ip_inp.inp.inp_cred,
                               &sin6->sin6_addr) != 0) {
            SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
            error = EINVAL;
            goto out_of_it;
          }
          break;
        }
#endif
        default:
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
          goto out_of_it;
        }
#endif
      }
      if (sctp_set_primary_ip_address_sa(stcb, addr) != 0) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      sctp_chunk_output(inp, stcb,  SCTP_OUTPUT_FROM_SOCKOPT, SCTP_SO_LOCKED);
    out_of_it:
      SCTP_TCB_UNLOCK(stcb);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }
  case SCTP_BINDX_ADD_ADDR:
  {
    struct sockaddr *sa;
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct thread *td;

    td = (struct thread *)p;
#endif
    SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);
#ifdef INET
    if (sa->sa_family == AF_INET) {
      if (optsize < sizeof(struct sockaddr_in)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
#if defined(__FreeBSD__) && !defined(__Userspace__)
      if (td != NULL &&
          (error = prison_local_ip4(td->td_ucred, &(((struct sockaddr_in *)sa)->sin_addr)))) {
        SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
#endif
    } else
#endif
#ifdef INET6
    if (sa->sa_family == AF_INET6) {
      if (optsize < sizeof(struct sockaddr_in6)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
#if defined(__FreeBSD__) && !defined(__Userspace__)
      if (td != NULL &&
          (error = prison_local_ip6(td->td_ucred,
                                    &(((struct sockaddr_in6 *)sa)->sin6_addr),
                                    (SCTP_IPV6_V6ONLY(inp) != 0))) != 0) {
        SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
#endif
    } else
#endif
    {
      error = EAFNOSUPPORT;
      break;
    }
    sctp_bindx_add_address(so, inp, sa, vrf_id, &error, p);
    break;
  }
  case SCTP_BINDX_REM_ADDR:
  {
    struct sockaddr *sa;
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct thread *td;
    td = (struct thread *)p;

#endif
    SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);
#ifdef INET
    if (sa->sa_family == AF_INET) {
      if (optsize < sizeof(struct sockaddr_in)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
#if defined(__FreeBSD__) && !defined(__Userspace__)
      if (td != NULL &&
          (error = prison_local_ip4(td->td_ucred, &(((struct sockaddr_in *)sa)->sin_addr)))) {
        SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
#endif
    } else
#endif
#ifdef INET6
    if (sa->sa_family == AF_INET6) {
      if (optsize < sizeof(struct sockaddr_in6)) {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
        break;
      }
#if defined(__FreeBSD__) && !defined(__Userspace__)
      if (td != NULL &&
          (error = prison_local_ip6(td->td_ucred,
                                    &(((struct sockaddr_in6 *)sa)->sin6_addr),
                                    (SCTP_IPV6_V6ONLY(inp) != 0))) != 0) {
        SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
#endif
    } else
#endif
    {
      error = EAFNOSUPPORT;
      break;
    }
    sctp_bindx_delete_address(inp, sa, vrf_id, &error);
    break;
  }
#if defined(__APPLE__) && !defined(__Userspace__)
  case SCTP_LISTEN_FIX:
    /* only applies to one-to-many sockets */
    if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
      /* make sure the ACCEPTCONN flag is OFF */
      so->so_options &= ~SO_ACCEPTCONN;
    } else {
      /* otherwise, not allowed */
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
#endif
  case SCTP_EVENT:
  {
    struct sctp_event *event;
    uint32_t event_type;

    SCTP_CHECK_AND_CAST(event, optval, struct sctp_event, optsize);
    SCTP_FIND_STCB(inp, stcb, event->se_assoc_id);
    switch (event->se_type) {
    case SCTP_ASSOC_CHANGE:
      event_type = SCTP_PCB_FLAGS_RECVASSOCEVNT;
      break;
    case SCTP_PEER_ADDR_CHANGE:
      event_type = SCTP_PCB_FLAGS_RECVPADDREVNT;
      break;
    case SCTP_REMOTE_ERROR:
      event_type = SCTP_PCB_FLAGS_RECVPEERERR;
      break;
    case SCTP_SEND_FAILED:
      event_type = SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
      break;
    case SCTP_SHUTDOWN_EVENT:
      event_type = SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
      break;
    case SCTP_ADAPTATION_INDICATION:
      event_type = SCTP_PCB_FLAGS_ADAPTATIONEVNT;
      break;
    case SCTP_PARTIAL_DELIVERY_EVENT:
      event_type = SCTP_PCB_FLAGS_PDAPIEVNT;
      break;
    case SCTP_AUTHENTICATION_EVENT:
      event_type = SCTP_PCB_FLAGS_AUTHEVNT;
      break;
    case SCTP_STREAM_RESET_EVENT:
      event_type = SCTP_PCB_FLAGS_STREAM_RESETEVNT;
      break;
    case SCTP_SENDER_DRY_EVENT:
      event_type = SCTP_PCB_FLAGS_DRYEVNT;
      break;
    case SCTP_NOTIFICATIONS_STOPPED_EVENT:
      event_type = 0;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
      error = ENOTSUP;
      break;
    case SCTP_ASSOC_RESET_EVENT:
      event_type = SCTP_PCB_FLAGS_ASSOC_RESETEVNT;
      break;
    case SCTP_STREAM_CHANGE_EVENT:
      event_type = SCTP_PCB_FLAGS_STREAM_CHANGEEVNT;
      break;
    case SCTP_SEND_FAILED_EVENT:
      event_type = SCTP_PCB_FLAGS_RECVNSENDFAILEVNT;
      break;
    default:
      event_type = 0;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if (event_type > 0) {
      if (stcb) {
        if (event->se_on) {
          sctp_stcb_feature_on(inp, stcb, event_type);
          if (event_type == SCTP_PCB_FLAGS_DRYEVNT) {
            if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
                TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
                (stcb->asoc.stream_queue_cnt == 0)) {
              sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb,  0, NULL, SCTP_SO_LOCKED);
            }
          }
        } else {
          sctp_stcb_feature_off(inp, stcb, event_type);
        }
        SCTP_TCB_UNLOCK(stcb);
      } else {
        /*
         * We don't want to send up a storm of events,
         * so return an error for sender dry events
         */
        if ((event_type == SCTP_PCB_FLAGS_DRYEVNT) &&
            (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
            ((event->se_assoc_id == SCTP_ALL_ASSOC) ||
             (event->se_assoc_id == SCTP_CURRENT_ASSOC))) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
          error = ENOTSUP;
          break;
        }
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
            (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
            ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
             ((event->se_assoc_id == SCTP_FUTURE_ASSOC) ||
              (event->se_assoc_id == SCTP_ALL_ASSOC)))) {
          SCTP_INP_WLOCK(inp);
          if (event->se_on) {
            sctp_feature_on(inp, event_type);
          } else {
            sctp_feature_off(inp, event_type);
          }
          SCTP_INP_WUNLOCK(inp);
        }
        if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
            ((event->se_assoc_id == SCTP_CURRENT_ASSOC) ||
             (event->se_assoc_id == SCTP_ALL_ASSOC))) {
          SCTP_INP_RLOCK(inp);
          LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
            SCTP_TCB_LOCK(stcb);
            if (event->se_on) {
              sctp_stcb_feature_on(inp, stcb, event_type);
            } else {
              sctp_stcb_feature_off(inp, stcb, event_type);
            }
            SCTP_TCB_UNLOCK(stcb);
          }
          SCTP_INP_RUNLOCK(inp);
        }
      }
    } else {
      if (stcb) {
        SCTP_TCB_UNLOCK(stcb);
      }
    }
    break;
  }
  case SCTP_RECVRCVINFO:
  {
    int *onoff;

    SCTP_CHECK_AND_CAST(onoff, optval, int, optsize);
    SCTP_INP_WLOCK(inp);
    if (*onoff != 0) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
    }
    SCTP_INP_WUNLOCK(inp);
    break;
  }
  case SCTP_RECVNXTINFO:
  {
    int *onoff;

    SCTP_CHECK_AND_CAST(onoff, optval, int, optsize);
    SCTP_INP_WLOCK(inp);
    if (*onoff != 0) {
      sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
    } else {
      sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
    }
    SCTP_INP_WUNLOCK(inp);
    break;
  }
  case SCTP_DEFAULT_SNDINFO:
  {
    struct sctp_sndinfo *info;
    uint16_t policy;

    SCTP_CHECK_AND_CAST(info, optval, struct sctp_sndinfo, optsize);
    SCTP_FIND_STCB(inp, stcb, info->snd_assoc_id);

    if (stcb) {
      if (info->snd_sid < stcb->asoc.streamoutcnt) {
        stcb->asoc.def_send.sinfo_stream = info->snd_sid;
        policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
        stcb->asoc.def_send.sinfo_flags = info->snd_flags;
        stcb->asoc.def_send.sinfo_flags |= policy;
        stcb->asoc.def_send.sinfo_ppid = info->snd_ppid;
        stcb->asoc.def_send.sinfo_context = info->snd_context;
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((info->snd_assoc_id == SCTP_FUTURE_ASSOC) ||
            (info->snd_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->def_send.sinfo_stream = info->snd_sid;
        policy = PR_SCTP_POLICY(inp->def_send.sinfo_flags);
        inp->def_send.sinfo_flags = info->snd_flags;
        inp->def_send.sinfo_flags |= policy;
        inp->def_send.sinfo_ppid = info->snd_ppid;
        inp->def_send.sinfo_context = info->snd_context;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((info->snd_assoc_id == SCTP_CURRENT_ASSOC) ||
           (info->snd_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          if (info->snd_sid < stcb->asoc.streamoutcnt) {
            stcb->asoc.def_send.sinfo_stream = info->snd_sid;
            policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
            stcb->asoc.def_send.sinfo_flags = info->snd_flags;
            stcb->asoc.def_send.sinfo_flags |= policy;
            stcb->asoc.def_send.sinfo_ppid = info->snd_ppid;
            stcb->asoc.def_send.sinfo_context = info->snd_context;
          }
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_DEFAULT_PRINFO:
  {
    struct sctp_default_prinfo *info;

    SCTP_CHECK_AND_CAST(info, optval, struct sctp_default_prinfo, optsize);
    SCTP_FIND_STCB(inp, stcb, info->pr_assoc_id);

    if (info->pr_policy > SCTP_PR_SCTP_MAX) {
      if (stcb) {
        SCTP_TCB_UNLOCK(stcb);
      }
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      break;
    }
    if (stcb) {
      stcb->asoc.def_send.sinfo_flags &= 0xfff0;
      stcb->asoc.def_send.sinfo_flags |= info->pr_policy;
      stcb->asoc.def_send.sinfo_timetolive = info->pr_value;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           ((info->pr_assoc_id == SCTP_FUTURE_ASSOC) ||
            (info->pr_assoc_id == SCTP_ALL_ASSOC)))) {
        SCTP_INP_WLOCK(inp);
        inp->def_send.sinfo_flags &= 0xfff0;
        inp->def_send.sinfo_flags |= info->pr_policy;
        inp->def_send.sinfo_timetolive = info->pr_value;
        SCTP_INP_WUNLOCK(inp);
      }
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
          ((info->pr_assoc_id == SCTP_CURRENT_ASSOC) ||
           (info->pr_assoc_id == SCTP_ALL_ASSOC))) {
        SCTP_INP_RLOCK(inp);
        LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
          SCTP_TCB_LOCK(stcb);
          stcb->asoc.def_send.sinfo_flags &= 0xfff0;
          stcb->asoc.def_send.sinfo_flags |= info->pr_policy;
          stcb->asoc.def_send.sinfo_timetolive = info->pr_value;
          SCTP_TCB_UNLOCK(stcb);
        }
        SCTP_INP_RUNLOCK(inp);
      }
    }
    break;
  }
  case SCTP_PEER_ADDR_THLDS:
    /* Applies to the specific association */
  {
    struct sctp_paddrthlds *thlds;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(thlds, optval, struct sctp_paddrthlds, optsize);
    SCTP_FIND_STCB(inp, stcb, thlds->spt_assoc_id);

#if defined(INET) && defined(INET6)
    if (thlds->spt_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&thlds->spt_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&thlds->spt_address;
      }
    } else {
      addr = (struct sockaddr *)&thlds->spt_address;
    }
#else
    addr = (struct sockaddr *)&thlds->spt_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr,
                                          &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
      {
        error = EAFNOSUPPORT;
        SCTP_TCB_UNLOCK(stcb);
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
        break;
      }
    }
    if (thlds->spt_pathcpthld != 0xffff) {
      if (stcb != NULL) {
        SCTP_TCB_UNLOCK(stcb);
      }
      error = EINVAL;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      break;
    }
    if (stcb != NULL) {
      if (net != NULL) {
        net->failure_threshold = thlds->spt_pathmaxrxt;
        net->pf_threshold = thlds->spt_pathpfthld;
        if (net->dest_state & SCTP_ADDR_PF) {
          if ((net->error_count > net->failure_threshold) ||
              (net->error_count <= net->pf_threshold)) {
            net->dest_state &= ~SCTP_ADDR_PF;
          }
        } else {
          if ((net->error_count > net->pf_threshold) &&
              (net->error_count <= net->failure_threshold)) {
            net->dest_state |= SCTP_ADDR_PF;
            sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
            sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
                            stcb->sctp_ep, stcb, net,
                            SCTP_FROM_SCTP_USRREQ + SCTP_LOC_17);
            sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
          }
        }
        if (net->dest_state & SCTP_ADDR_REACHABLE) {
          if (net->error_count > net->failure_threshold) {
            net->dest_state &= ~SCTP_ADDR_REACHABLE;
            sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
          }
        } else {
          if (net->error_count <= net->failure_threshold) {
            net->dest_state |= SCTP_ADDR_REACHABLE;
            sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
          }
        }
      } else {
        TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
          net->failure_threshold = thlds->spt_pathmaxrxt;
          net->pf_threshold = thlds->spt_pathpfthld;
          if (net->dest_state & SCTP_ADDR_PF) {
            if ((net->error_count > net->failure_threshold) ||
                (net->error_count <= net->pf_threshold)) {
              net->dest_state &= ~SCTP_ADDR_PF;
            }
          } else {
            if ((net->error_count > net->pf_threshold) &&
                (net->error_count <= net->failure_threshold)) {
              net->dest_state |= SCTP_ADDR_PF;
              sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
              sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
                              stcb->sctp_ep, stcb, net,
                              SCTP_FROM_SCTP_USRREQ + SCTP_LOC_18);
              sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
            }
          }
          if (net->dest_state & SCTP_ADDR_REACHABLE) {
            if (net->error_count > net->failure_threshold) {
              net->dest_state &= ~SCTP_ADDR_REACHABLE;
              sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
            }
          } else {
            if (net->error_count <= net->failure_threshold) {
              net->dest_state |= SCTP_ADDR_REACHABLE;
              sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
            }
          }
        }
        stcb->asoc.def_net_failure = thlds->spt_pathmaxrxt;
        stcb->asoc.def_net_pf_threshold = thlds->spt_pathpfthld;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (thlds->spt_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_ep.def_net_failure = thlds->spt_pathmaxrxt;
        inp->sctp_ep.def_net_pf_threshold = thlds->spt_pathpfthld;
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_REMOTE_UDP_ENCAPS_PORT:
  {
    struct sctp_udpencaps *encaps;
    struct sctp_nets *net;
    struct sockaddr *addr;
#if defined(INET) && defined(INET6)
    struct sockaddr_in sin_store;
#endif

    SCTP_CHECK_AND_CAST(encaps, optval, struct sctp_udpencaps, optsize);
    SCTP_FIND_STCB(inp, stcb, encaps->sue_assoc_id);

#if defined(INET) && defined(INET6)
    if (encaps->sue_address.ss_family == AF_INET6) {
      struct sockaddr_in6 *sin6;

      sin6 = (struct sockaddr_in6 *)&encaps->sue_address;
      if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
        in6_sin6_2_sin(&sin_store, sin6);
        addr = (struct sockaddr *)&sin_store;
      } else {
        addr = (struct sockaddr *)&encaps->sue_address;
      }
    } else {
      addr = (struct sockaddr *)&encaps->sue_address;
    }
#else
    addr = (struct sockaddr *)&encaps->sue_address;
#endif
    if (stcb != NULL) {
      net = sctp_findnet(stcb, addr);
    } else {
      /* We increment here since sctp_findassociation_ep_addr() wil
       * do a decrement if it finds the stcb as long as the locked
       * tcb (last argument) is NOT a TCB.. aka NULL.
       */
      net = NULL;
      SCTP_INP_INCR_REF(inp);
      stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
      if (stcb == NULL) {
        SCTP_INP_DECR_REF(inp);
      }
    }
    if ((stcb != NULL) && (net == NULL)) {
#ifdef INET
      if (addr->sa_family == AF_INET) {
        struct sockaddr_in *sin;

        sin = (struct sockaddr_in *)addr;
        if (sin->sin_addr.s_addr != INADDR_ANY) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#ifdef INET6
      if (addr->sa_family == AF_INET6) {
        struct sockaddr_in6 *sin6;

        sin6 = (struct sockaddr_in6 *)addr;
        if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
#if defined(__Userspace__)
      if (addr->sa_family == AF_CONN) {
        struct sockaddr_conn *sconn;

        sconn = (struct sockaddr_conn *)addr;
        if (sconn->sconn_addr != NULL) {
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          SCTP_TCB_UNLOCK(stcb);
          error = EINVAL;
          break;
        }
      } else
#endif
      {
          error = EAFNOSUPPORT;
          SCTP_TCB_UNLOCK(stcb);
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
          break;
        }
    }

    if (stcb != NULL) {
      if (net != NULL) {
        net->port = encaps->sue_port;
      } else {
        stcb->asoc.port = encaps->sue_port;
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (encaps->sue_assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        inp->sctp_ep.port = encaps->sue_port;
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_ECN_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->ecn_supported = 0;
        } else {
          inp->ecn_supported = 1;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_PR_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->prsctp_supported = 0;
        } else {
          inp->prsctp_supported = 1;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_AUTH_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        if ((av->assoc_value == 0) &&
            (inp->asconf_supported == 1)) {
              /* AUTH is required for ASCONF */
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        } else {
          SCTP_INP_WLOCK(inp);
          if (av->assoc_value == 0) {
            inp->auth_supported = 0;
          } else {
            inp->auth_supported = 1;
          }
          SCTP_INP_WUNLOCK(inp);
        }
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_ASCONF_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        if ((av->assoc_value != 0) &&
            (inp->auth_supported == 0)) {
              /* AUTH is required for ASCONF */
          SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
          error = EINVAL;
        } else {
          SCTP_INP_WLOCK(inp);
          if (av->assoc_value == 0) {
            inp->asconf_supported = 0;
            sctp_auth_delete_chunk(SCTP_ASCONF,
                                   inp->sctp_ep.local_auth_chunks);
            sctp_auth_delete_chunk(SCTP_ASCONF_ACK,
                                   inp->sctp_ep.local_auth_chunks);
          } else {
            inp->asconf_supported = 1;
            sctp_auth_add_chunk(SCTP_ASCONF,
                                inp->sctp_ep.local_auth_chunks);
            sctp_auth_add_chunk(SCTP_ASCONF_ACK,
                                inp->sctp_ep.local_auth_chunks);
          }
          SCTP_INP_WUNLOCK(inp);
        }
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_RECONFIG_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->reconfig_supported = 0;
        } else {
          inp->reconfig_supported = 1;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_NRSACK_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->nrsack_supported = 0;
        } else {
          inp->nrsack_supported = 1;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_PKTDROP_SUPPORTED:
  {
    struct sctp_assoc_value *av;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        if (av->assoc_value == 0) {
          inp->pktdrop_supported = 0;
        } else {
          inp->pktdrop_supported = 1;
        }
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_MAX_CWND:
  {
    struct sctp_assoc_value *av;
    struct sctp_nets *net;

    SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
    SCTP_FIND_STCB(inp, stcb, av->assoc_id);

    if (stcb) {
      stcb->asoc.max_cwnd = av->assoc_value;
      if (stcb->asoc.max_cwnd > 0) {
        TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
          if ((net->cwnd > stcb->asoc.max_cwnd) &&
              (net->cwnd > (net->mtu - sizeof(struct sctphdr)))) {
            net->cwnd = stcb->asoc.max_cwnd;
            if (net->cwnd < (net->mtu - sizeof(struct sctphdr))) {
              net->cwnd = net->mtu - sizeof(struct sctphdr);
            }
          }
        }
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
          (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
          ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
           (av->assoc_id == SCTP_FUTURE_ASSOC))) {
        SCTP_INP_WLOCK(inp);
        inp->max_cwnd = av->assoc_value;
        SCTP_INP_WUNLOCK(inp);
      } else {
        SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
        error = EINVAL;
      }
    }
    break;
  }
  case SCTP_ACCEPT_ZERO_CHECKSUM:
  {
    uint32_t *value;

    SCTP_CHECK_AND_CAST(value, optval, uint32_t, optsize);
    if ((*value == SCTP_EDMID_NONE) ||
        (*value == SCTP_EDMID_LOWER_LAYER_DTLS)) {
      SCTP_INP_WLOCK(inp);
      inp->rcv_edmid = *value;
      SCTP_INP_WUNLOCK(inp);
    } else {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      error = EINVAL;
    }
    break;
  }

  default:
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
    error = ENOPROTOOPT;
    break;
  } /* end switch (opt) */
  return (error);
}

#if !defined(__Userspace__)
int
sctp_ctloutput(struct socket *so, struct sockopt *sopt)
{
#if defined(__FreeBSD__)
  struct epoch_tracker et;
  struct sctp_inpcb *inp;
#endif
  void *optval = NULL;
  void *p;
  size_t optsize = 0;
  int error = 0;

#if defined(__FreeBSD__)
  if ((sopt->sopt_level == SOL_SOCKET) &&
      (sopt->sopt_name == SO_SETFIB)) {
    inp = (struct sctp_inpcb *)so->so_pcb;
    if (inp == NULL) {
      SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
      return (EINVAL);
    }
    SCTP_INP_WLOCK(inp);
    inp->fibnum = so->so_fibnum;
    SCTP_INP_WUNLOCK(inp);
    return (0);
  }
#endif
  if (sopt->sopt_level != IPPROTO_SCTP) {
    /* wrong proto level... send back up to IP */
#ifdef INET6
    if (INP_CHECK_SOCKAF(so, AF_INET6))
      error = ip6_ctloutput(so, sopt);
#endif        /* INET6 */
#if defined(INET) && defined(INET6)
    else
#endif
#ifdef INET
      error = ip_ctloutput(so, sopt);
#endif
    return (error);
  }
  optsize = sopt->sopt_valsize;
  if (optsize > SCTP_SOCKET_OPTION_LIMIT) {
    SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
    return (ENOBUFS);
  }
  if (optsize) {
    SCTP_MALLOC(optval, void *, optsize, SCTP_M_SOCKOPT);
    if (optval == NULL) {
      SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
      return (ENOBUFS);
    }
    error = sooptcopyin(sopt, optval, optsize, optsize);
    if (error) {
      SCTP_FREE(optval, SCTP_M_SOCKOPT);
      goto out;
    }
  }
#if defined(__FreeBSD__) || defined(_WIN32)
  p = (void *)sopt->sopt_td;
#else
  p = (void *)sopt->sopt_p;
#endif
  if (sopt->sopt_dir == SOPT_SET) {
#if defined(__FreeBSD__)
    NET_EPOCH_ENTER(et);
#endif
    error = sctp_setopt(so, sopt->sopt_name, optval, optsize, p);
#if defined(__FreeBSD__)
    NET_EPOCH_EXIT(et);
#endif
  } else if (sopt->sopt_dir == SOPT_GET) {
    error = sctp_getopt(so, sopt->sopt_name, optval, &optsize, p);
  } else {
    SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
  }
  if ((error == 0) && (optval != NULL)) {
    error = sooptcopyout(sopt, optval, optsize);
    SCTP_FREE(optval, SCTP_M_SOCKOPT);
  } else if (optval != NULL) {
    SCTP_FREE(optval, SCTP_M_SOCKOPT);
  }
out:
  return (error);
}
#endif

#ifdef INET
#if defined(__Userspace__)
int
sctp_connect(struct socket *so, struct sockaddr *addr)
{
  void *p = NULL;
#elif defined(__FreeBSD__)
static int
sctp_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
{
#elif defined(__APPLE__)
static int
sctp_connect(struct socket *so, struct sockaddr *addr, struct proc *p)
{
#elif defined(_WIN32)
static int
sctp_connect(struct socket *so, struct sockaddr *addr, PKTHREAD p)
{
#else
static int
sctp_connect(struct socket *so, struct mbuf *nam, struct proc *p)
{
  struct sockaddr *addr = mtod(nam, struct sockaddr *);

#endif
#if defined(__FreeBSD__) && !defined(__Userspace__)
  struct epoch_tracker et;
#endif
#ifdef SCTP_MVRF
  int i, fnd = 0;
#endif
  int error = 0;
  int create_lock_on = 0;
  uint32_t vrf_id;
  struct sctp_inpcb *inp;
  struct sctp_tcb *stcb = NULL;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    /* I made the same as TCP since we are not setup? */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  if (addr == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return EINVAL;
  }

#if defined(__Userspace__)
  /* TODO __Userspace__ falls into this code for IPv6 stuff at the moment... */
#endif
#if !defined(_WIN32) && !defined(__linux__) && !defined(__EMSCRIPTEN__)
  switch (addr->sa_family) {
#ifdef INET6
  case AF_INET6:
  {
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct sockaddr_in6 *sin6;

#endif
    if (addr->sa_len != sizeof(struct sockaddr_in6)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
#if defined(__FreeBSD__) && !defined(__Userspace__)
    sin6 = (struct sockaddr_in6 *)addr;
    if (p != NULL && (error = prison_remote_ip6(p->td_ucred, &sin6->sin6_addr)) != 0) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      return (error);
    }
#endif
    break;
  }
#endif
#ifdef INET
  case AF_INET:
  {
#if defined(__FreeBSD__) && !defined(__Userspace__)
    struct sockaddr_in *sin;

#endif
#if !defined(_WIN32)
    if (addr->sa_len != sizeof(struct sockaddr_in)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
#endif
#if defined(__FreeBSD__) && !defined(__Userspace__)
    sin = (struct sockaddr_in *)addr;
    if (p != NULL && (error = prison_remote_ip4(p->td_ucred, &sin->sin_addr)) != 0) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      return (error);
    }
#endif
    break;
  }
#endif
  default:
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EAFNOSUPPORT);
    return (EAFNOSUPPORT);
  }
#endif
  SCTP_INP_INCR_REF(inp);
  SCTP_ASOC_CREATE_LOCK(inp);
  create_lock_on = 1;
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_ENTER(et);
#endif

  if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
      (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
    /* Should I really unlock ? */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EFAULT);
    error = EFAULT;
    goto out_now;
  }
#ifdef INET6
  if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
      (addr->sa_family == AF_INET6)) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
#endif
#if defined(__Userspace__)
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_CONN) &&
      (addr->sa_family != AF_CONN)) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
#endif
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
    /* Bind a ephemeral port */
    error = sctp_inpcb_bind(so, NULL, NULL, p);
    if (error) {
      goto out_now;
    }
  }
  /* Now do we connect? */
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) &&
      (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE))) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
      (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
    /* We are already connected AND the TCP model */
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EADDRINUSE);
    error = EADDRINUSE;
    goto out_now;
  }
  if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
    SCTP_INP_RLOCK(inp);
    stcb = LIST_FIRST(&inp->sctp_asoc_list);
    SCTP_INP_RUNLOCK(inp);
  } else {
    /* We increment here since sctp_findassociation_ep_addr() will
     * do a decrement if it finds the stcb as long as the locked
     * tcb (last argument) is NOT a TCB.. aka NULL.
     */
    SCTP_INP_INCR_REF(inp);
    stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL);
    if (stcb == NULL) {
      SCTP_INP_DECR_REF(inp);
    } else {
      SCTP_TCB_UNLOCK(stcb);
    }
  }
  if (stcb != NULL) {
    /* Already have or am bring up an association */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
    error = EALREADY;
    goto out_now;
  }

  vrf_id = inp->def_vrf_id;
#ifdef SCTP_MVRF
  for (i = 0; i < inp->num_vrfs; i++) {
    if (vrf_id == inp->m_vrf_ids[i]) {
      fnd = 1;
      break;
    }
  }
  if (!fnd) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
#endif
  /* We are GOOD to go */
  stcb = sctp_aloc_assoc_connected(inp, addr, &error, 0, 0, vrf_id,
                                   inp->sctp_ep.pre_open_stream_count,
                                   inp->sctp_ep.port, p,
                                   SCTP_INITIALIZE_AUTH_PARAMS);
  if (stcb == NULL) {
    /* Gak! no memory */
    goto out_now;
  }
  SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
  (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);

  sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
  SCTP_TCB_UNLOCK(stcb);
 out_now:
#if defined(__FreeBSD__) && !defined(__Userspace__)
  NET_EPOCH_EXIT(et);
#endif
  if (create_lock_on) {
    SCTP_ASOC_CREATE_UNLOCK(inp);
  }
  SCTP_INP_DECR_REF(inp);
  return (error);
}
#endif

#if defined(__Userspace__)
int
sctpconn_connect(struct socket *so, struct sockaddr *addr)
{
#ifdef SCTP_MVRF
  int i, fnd = 0;
#endif
  void *p = NULL;
  int error = 0;
  int create_lock_on = 0;
  uint32_t vrf_id;
  struct sctp_inpcb *inp;
  struct sctp_tcb *stcb = NULL;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    /* I made the same as TCP since we are not setup? */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  if (addr == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return EINVAL;
  }
  switch (addr->sa_family) {
#ifdef INET
  case AF_INET:
#ifdef HAVE_SA_LEN
    if (addr->sa_len != sizeof(struct sockaddr_in)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
#endif
    break;
#endif
#ifdef INET6
  case AF_INET6:
#ifdef HAVE_SA_LEN
    if (addr->sa_len != sizeof(struct sockaddr_in6)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
#endif
    break;
#endif
  case AF_CONN:
#ifdef HAVE_SA_LEN
    if (addr->sa_len != sizeof(struct sockaddr_conn)) {
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
      return (EINVAL);
    }
#endif
    break;
  default:
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EAFNOSUPPORT);
    return (EAFNOSUPPORT);
  }
  SCTP_INP_INCR_REF(inp);
  SCTP_ASOC_CREATE_LOCK(inp);
  create_lock_on = 1;


  if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
      (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
    /* Should I really unlock ? */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EFAULT);
          error = EFAULT;
    goto out_now;
  }
#ifdef INET6
  if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
      (addr->sa_family == AF_INET6)) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
#endif
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
    /* Bind a ephemeral port */
    error = sctp_inpcb_bind(so, NULL, NULL, p);
    if (error) {
      goto out_now;
    }
  }
  /* Now do we connect? */
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) &&
      (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE))) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
      (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
    /* We are already connected AND the TCP model */
    SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EADDRINUSE);
    error = EADDRINUSE;
    goto out_now;
  }
  if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
    SCTP_INP_RLOCK(inp);
    stcb = LIST_FIRST(&inp->sctp_asoc_list);
    SCTP_INP_RUNLOCK(inp);
  } else {
    /* We increment here since sctp_findassociation_ep_addr() will
     * do a decrement if it finds the stcb as long as the locked
     * tcb (last argument) is NOT a TCB.. aka NULL.
     */
    SCTP_INP_INCR_REF(inp);
    stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL);
    if (stcb == NULL) {
      SCTP_INP_DECR_REF(inp);
    } else {
      SCTP_TCB_UNLOCK(stcb);
    }
  }
  if (stcb != NULL) {
    /* Already have or am bring up an association */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
    error = EALREADY;
    goto out_now;
  }

  vrf_id = inp->def_vrf_id;
#ifdef SCTP_MVRF
  for (i = 0; i < inp->num_vrfs; i++) {
    if (vrf_id == inp->m_vrf_ids[i]) {
      fnd = 1;
      break;
    }
  }
  if (!fnd) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    error = EINVAL;
    goto out_now;
  }
#endif
  /* We are GOOD to go */
  stcb = sctp_aloc_assoc_connected(inp, addr, &error, 0, 0, vrf_id,
                                   inp->sctp_ep.pre_open_stream_count,
                                   inp->sctp_ep.port, p,
                                   SCTP_INITIALIZE_AUTH_PARAMS);
  if (stcb == NULL) {
    /* Gak! no memory */
    goto out_now;
  }
  SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
  (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);

  sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
  SCTP_TCB_UNLOCK(stcb);
 out_now:
  if (create_lock_on) {
    SCTP_ASOC_CREATE_UNLOCK(inp);
  }

  SCTP_INP_DECR_REF(inp);
  return (error);
}
#endif
int
#if defined(__Userspace__)
sctp_listen(struct socket *so, int backlog, struct proc *p)
#elif defined(__FreeBSD__)
sctp_listen(struct socket *so, int backlog, struct thread *p)
#elif defined(_WIN32)
sctp_listen(struct socket *so, int backlog, PKTHREAD p)
#else
sctp_listen(struct socket *so, struct proc *p)
#endif
{
  /*
   * Note this module depends on the protocol processing being called
   * AFTER any socket level flags and backlog are applied to the
   * socket. The traditional way that the socket flags are applied is
   * AFTER protocol processing. We have made a change to the
   * sys/kern/uipc_socket.c module to reverse this but this MUST be in
   * place if the socket API for SCTP is to work properly.
   */

  int error = 0;
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *)so->so_pcb;
  if (inp == NULL) {
    /* I made the same as TCP since we are not setup? */
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE)) {
    /* See if we have a listener */
    struct sctp_inpcb *tinp;
    union sctp_sockstore store;

    if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
      /* not bound all */
      struct sctp_laddr *laddr;

      LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
        memcpy(&store, &laddr->ifa->address, sizeof(store));
        switch (store.sa.sa_family) {
#ifdef INET
        case AF_INET:
          store.sin.sin_port = inp->sctp_lport;
          break;
#endif
#ifdef INET6
        case AF_INET6:
          store.sin6.sin6_port = inp->sctp_lport;
          break;
#endif
#if defined(__Userspace__)
        case AF_CONN:
          store.sconn.sconn_port = inp->sctp_lport;
          break;
#endif
        default:
          break;
        }
        tinp = sctp_pcb_findep(&store.sa, 0, 0, inp->def_vrf_id);
        if (tinp && (tinp != inp) &&
            ((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) == 0) &&
            ((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
            (SCTP_IS_LISTENING(tinp))) {
          /* we have a listener already and its not this inp. */
          SCTP_INP_DECR_REF(tinp);
          return (EADDRINUSE);
        } else if (tinp) {
          SCTP_INP_DECR_REF(tinp);
        }
      }
    } else {
      /* Setup a local addr bound all */
      memset(&store, 0, sizeof(store));
#ifdef INET6
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
        store.sa.sa_family = AF_INET6;
#ifdef HAVE_SA_LEN
        store.sa.sa_len = sizeof(struct sockaddr_in6);
#endif
      }
#endif
#if defined(__Userspace__)
      if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_CONN) {
        store.sa.sa_family = AF_CONN;
#ifdef HAVE_SA_LEN
        store.sa.sa_len = sizeof(struct sockaddr_conn);
#endif
      }
#endif
#ifdef INET
#if defined(__Userspace__)
      if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
          ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_CONN) == 0)) {
#else
      if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
#endif
        store.sa.sa_family = AF_INET;
#ifdef HAVE_SA_LEN
        store.sa.sa_len = sizeof(struct sockaddr_in);
#endif
      }
#endif
      switch (store.sa.sa_family) {
#ifdef INET
      case AF_INET:
        store.sin.sin_port = inp->sctp_lport;
        break;
#endif
#ifdef INET6
      case AF_INET6:
        store.sin6.sin6_port = inp->sctp_lport;
        break;
#endif
#if defined(__Userspace__)
      case AF_CONN:
        store.sconn.sconn_port = inp->sctp_lport;
        break;
#endif
      default:
        break;
      }
      tinp = sctp_pcb_findep(&store.sa, 0, 0, inp->def_vrf_id);
      if (tinp && (tinp != inp) &&
          ((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) == 0) &&
          ((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
          (SCTP_IS_LISTENING(tinp))) {
        /* we have a listener already and its not this inp. */
        SCTP_INP_DECR_REF(tinp);
        return (EADDRINUSE);
      } else if (tinp) {
        SCTP_INP_DECR_REF(tinp);
      }
    }
  }
  SCTP_INP_INFO_WLOCK();
  SCTP_INP_WLOCK(inp);
#ifdef SCTP_LOCK_LOGGING
  if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOCK_LOGGING_ENABLE) {
    sctp_log_lock(inp, (struct sctp_tcb *)NULL, SCTP_LOG_LOCK_SOCK);
  }
#endif
  if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE)) &&
      (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
    /* The unlucky case
     * - We are in the tcp pool with this guy.
     * - Someone else is in the main inp slot.
     * - We must move this guy (the listener) to the main slot
     * - We must then move the guy that was listener to the TCP Pool.
     */
    if (sctp_swap_inpcb_for_listen(inp)) {
      error = EADDRINUSE;
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
      goto out;
    }
  }
#if defined(__FreeBSD__) || defined(__Userspace__)
  SOCK_LOCK(so);
  error = solisten_proto_check(so);
  if (error) {
    SOCK_UNLOCK(so);
    goto out;
  }
#endif
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
      (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
    SOCK_UNLOCK(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    solisten_proto_abort(so);
#endif
    error = EADDRINUSE;
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    goto out;
  }
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
      ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) ||
       (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED))) {
    SOCK_UNLOCK(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
    solisten_proto_abort(so);
#endif
    error = EINVAL;
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
    goto out;
  }
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
    if ((error = sctp_inpcb_bind_locked(inp, NULL, NULL, p))) {
      SOCK_UNLOCK(so);
#if defined(__FreeBSD__) && !defined(__Userspace__)
      solisten_proto_abort(so);
#endif
      /* bind error, probably perm */
      goto out;
    }
  }
#if defined(__FreeBSD__) && !defined(__Userspace__)
  if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) == 0) {
    solisten_proto(so, backlog);
    SOCK_UNLOCK(so);
    inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
  } else {
    solisten_proto_abort(so);
    SOCK_UNLOCK(so);
    if (backlog > 0) {
      inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
    } else {
      inp->sctp_flags &= ~SCTP_PCB_FLAGS_ACCEPTING;
    }
  }
#elif defined(_WIN32) || defined(__Userspace__)
  solisten_proto(so, backlog);
#endif
#if !(defined(__FreeBSD__) && !defined(__Userspace__))
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
    /* remove the ACCEPTCONN flag for one-to-many sockets */
#if defined(__Userspace__)
    so->so_options &= ~SCTP_SO_ACCEPTCONN;
#else
    so->so_options &= ~SO_ACCEPTCONN;
#endif
  }
  SOCK_UNLOCK(so);
  if (backlog > 0) {
    inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
  } else {
    inp->sctp_flags &= ~SCTP_PCB_FLAGS_ACCEPTING;
  }
#endif
out:
  SCTP_INP_WUNLOCK(inp);
  SCTP_INP_INFO_WUNLOCK();
  return (error);
}

static int sctp_defered_wakeup_cnt = 0;

int
sctp_accept(struct socket *so, struct sockaddr **addr)
{
  struct sctp_tcb *stcb;
  struct sctp_inpcb *inp;
  union sctp_sockstore store;
#ifdef INET6
#if defined(SCTP_KAME) && defined(SCTP_EMBEDDED_V6_SCOPE)
  int error;
#endif
#endif
  inp = (struct sctp_inpcb *)so->so_pcb;

  if (inp == NULL) {
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  SCTP_INP_WLOCK(inp);
  if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
    SCTP_INP_WUNLOCK(inp);
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
    return (EOPNOTSUPP);
  }
  if (so->so_state & SS_ISDISCONNECTED) {
    SCTP_INP_WUNLOCK(inp);
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ECONNABORTED);
    return (ECONNABORTED);
  }
  stcb = LIST_FIRST(&inp->sctp_asoc_list);
  if (stcb == NULL) {
    SCTP_INP_WUNLOCK(inp);
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  SCTP_TCB_LOCK(stcb);
  store = stcb->asoc.primary_destination->ro._l_addr;
  SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
  /* Wake any delayed sleep action */
  if (inp->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE) {
    inp->sctp_flags &= ~SCTP_PCB_FLAGS_DONT_WAKE;
    if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT) {
      inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEOUTPUT;
      SOCKBUF_LOCK(&inp->sctp_socket->so_snd);
      if (sowriteable(inp->sctp_socket)) {
#if defined(__Userspace__)
        /*__Userspace__ calling sowwakup_locked because of SOCKBUF_LOCK above. */
#endif
#if defined(__FreeBSD__) || defined(_WIN32) || defined(__Userspace__)
        sowwakeup_locked(inp->sctp_socket);
#else
#if defined(__APPLE__)
        /* socket is locked */
#endif
        sowwakeup(inp->sctp_socket);
#endif
      } else {
        SOCKBUF_UNLOCK(&inp->sctp_socket->so_snd);
      }
    }
    if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT) {
      inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEINPUT;
      SOCKBUF_LOCK(&inp->sctp_socket->so_rcv);
      if (soreadable(inp->sctp_socket)) {
        sctp_defered_wakeup_cnt++;
#if defined(__Userspace__)
        /*__Userspace__ calling sorwakup_locked because of SOCKBUF_LOCK above */
#endif
#if defined(__FreeBSD__) || defined(_WIN32) || defined(__Userspace__)
        sorwakeup_locked(inp->sctp_socket);
#else
#if defined(__APPLE__)
        /* socket is locked */
#endif
        sorwakeup(inp->sctp_socket);
#endif
      } else {
        SOCKBUF_UNLOCK(&inp->sctp_socket->so_rcv);
      }
    }
  }
  SCTP_INP_WUNLOCK(inp);
  if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
    sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
                    SCTP_FROM_SCTP_USRREQ + SCTP_LOC_19);
  } else {
    SCTP_TCB_UNLOCK(stcb);
  }
  switch (store.sa.sa_family) {
#ifdef INET
  case AF_INET:
  {
    struct sockaddr_in *sin;

    SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
    if (sin == NULL)
      return (ENOMEM);
    sin->sin_family = AF_INET;
#ifdef HAVE_SIN_LEN
    sin->sin_len = sizeof(*sin);
#endif
    sin->sin_port = store.sin.sin_port;
    sin->sin_addr = store.sin.sin_addr;
    *addr = (struct sockaddr *)sin;
    break;
  }
#endif
#ifdef INET6
  case AF_INET6:
  {
    struct sockaddr_in6 *sin6;

    SCTP_MALLOC_SONAME(sin6, struct sockaddr_in6 *, sizeof *sin6);
    if (sin6 == NULL)
      return (ENOMEM);
    sin6->sin6_family = AF_INET6;
#ifdef HAVE_SIN6_LEN
    sin6->sin6_len = sizeof(*sin6);
#endif
    sin6->sin6_port = store.sin6.sin6_port;
    sin6->sin6_addr = store.sin6.sin6_addr;
#if defined(SCTP_EMBEDDED_V6_SCOPE)
#ifdef SCTP_KAME
    if ((error = sa6_recoverscope(sin6)) != 0) {
      SCTP_FREE_SONAME(sin6);
      return (error);
    }
#else
    if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
      /*
       * sin6->sin6_scope_id =
       * ntohs(sin6->sin6_addr.s6_addr16[1]);
       */
      in6_recoverscope(sin6, &sin6->sin6_addr, NULL); /* skip ifp check */
    else
      sin6->sin6_scope_id = 0;  /* XXX */
#endif /* SCTP_KAME */
#endif /* SCTP_EMBEDDED_V6_SCOPE */
    *addr = (struct sockaddr *)sin6;
    break;
  }
#endif
#if defined(__Userspace__)
  case AF_CONN:
  {
    struct sockaddr_conn *sconn;

    SCTP_MALLOC_SONAME(sconn, struct sockaddr_conn *, sizeof(struct sockaddr_conn));
    if (sconn == NULL) {
      return (ENOMEM);
    }
    sconn->sconn_family = AF_CONN;
#ifdef HAVE_SCONN_LEN
    sconn->sconn_len = sizeof(struct sockaddr_conn);
#endif
    sconn->sconn_port = store.sconn.sconn_port;
    sconn->sconn_addr = store.sconn.sconn_addr;
    *addr = (struct sockaddr *)sconn;
    break;
  }
#endif
  default:
    /* TSNH */
    break;
  }
  return (0);
}

#ifdef INET
int
#if !defined(__Userspace__)
sctp_ingetaddr(struct socket *so, struct sockaddr **addr)
{
  struct sockaddr_in *sin;
#else
sctp_ingetaddr(struct socket *so, struct mbuf *nam)
{
  struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
#endif
  uint32_t vrf_id;
  struct sctp_inpcb *inp;
  struct sctp_ifa *sctp_ifa;

  /*
   * Do the malloc first in case it blocks.
   */
#if !defined(__Userspace__)
  SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
  if (sin == NULL)
    return (ENOMEM);
#else
  SCTP_BUF_LEN(nam) = sizeof(*sin);
  memset(sin, 0, sizeof(*sin));
#endif
  sin->sin_family = AF_INET;
#ifdef HAVE_SIN_LEN
  sin->sin_len = sizeof(*sin);
#endif
  inp = (struct sctp_inpcb *)so->so_pcb;
  if (!inp) {
#if !defined(__Userspace__)
    SCTP_FREE_SONAME(sin);
#endif
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  SCTP_INP_RLOCK(inp);
  sin->sin_port = inp->sctp_lport;
  if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
    if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
      struct sctp_tcb *stcb;
      struct sockaddr_in *sin_a;
      struct sctp_nets *net;
      int fnd;

      stcb = LIST_FIRST(&inp->sctp_asoc_list);
      if (stcb == NULL) {
        goto notConn;
      }
      fnd = 0;
      sin_a = NULL;
      SCTP_TCB_LOCK(stcb);
      TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
        sin_a = (struct sockaddr_in *)&net->ro._l_addr;
        if (sin_a == NULL)
          /* this will make coverity happy */
          continue;

        if (sin_a->sin_family == AF_INET) {
          fnd = 1;
          break;
        }
      }
      if ((!fnd) || (sin_a == NULL)) {
        /* punt */
        SCTP_TCB_UNLOCK(stcb);
        goto notConn;
      }

      vrf_id = inp->def_vrf_id;
      sctp_ifa = sctp_source_address_selection(inp,
                 stcb,
                 (sctp_route_t *)&net->ro,
                 net, 0, vrf_id);
      if (sctp_ifa) {
        sin->sin_addr = sctp_ifa->address.sin.sin_addr;
        sctp_free_ifa(sctp_ifa);
      }
      SCTP_TCB_UNLOCK(stcb);
    } else {
      /* For the bound all case you get back 0 */
  notConn:
      sin->sin_addr.s_addr = 0;
    }

  } else {
    /* Take the first IPv4 address in the list */
    struct sctp_laddr *laddr;
    int fnd = 0;

    LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
      if (laddr->ifa->address.sa.sa_family == AF_INET) {
        struct sockaddr_in *sin_a;

        sin_a = &laddr->ifa->address.sin;
        sin->sin_addr = sin_a->sin_addr;
        fnd = 1;
        break;
      }
    }
    if (!fnd) {
#if !defined(__Userspace__)
      SCTP_FREE_SONAME(sin);
#endif
      SCTP_INP_RUNLOCK(inp);
      SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
      return (ENOENT);
    }
  }
  SCTP_INP_RUNLOCK(inp);
#if !defined(__Userspace__)
  (*addr) = (struct sockaddr *)sin;
#endif
  return (0);
}

int
#if !defined(__Userspace__)
sctp_peeraddr(struct socket *so, struct sockaddr **addr)
{
  struct sockaddr_in *sin;
#else
sctp_peeraddr(struct socket *so, struct mbuf *nam)
{
  struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);

#endif
  int fnd;
  struct sockaddr_in *sin_a;
  struct sctp_inpcb *inp;
  struct sctp_tcb *stcb;
  struct sctp_nets *net;

  /* Do the malloc first in case it blocks. */
#if !defined(__Userspace__)
  SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
  if (sin == NULL)
    return (ENOMEM);
#else
  SCTP_BUF_LEN(nam) = sizeof(*sin);
  memset(sin, 0, sizeof(*sin));
#endif
  sin->sin_family = AF_INET;
#ifdef HAVE_SIN_LEN
  sin->sin_len = sizeof(*sin);
#endif

  inp = (struct sctp_inpcb *)so->so_pcb;
  if ((inp == NULL) ||
      ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
    /* UDP type and listeners will drop out here */
#if !defined(__Userspace__)
    SCTP_FREE_SONAME(sin);
#endif
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
    return (ENOTCONN);
  }
  SCTP_INP_RLOCK(inp);
  stcb = LIST_FIRST(&inp->sctp_asoc_list);
  if (stcb) {
    SCTP_TCB_LOCK(stcb);
  }
  SCTP_INP_RUNLOCK(inp);
  if (stcb == NULL) {
#if !defined(__Userspace__)
    SCTP_FREE_SONAME(sin);
#endif
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
    return (ECONNRESET);
  }
  fnd = 0;
  TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
    sin_a = (struct sockaddr_in *)&net->ro._l_addr;
    if (sin_a->sin_family == AF_INET) {
      fnd = 1;
      sin->sin_port = stcb->rport;
      sin->sin_addr = sin_a->sin_addr;
      break;
    }
  }
  SCTP_TCB_UNLOCK(stcb);
  if (!fnd) {
    /* No IPv4 address */
#if !defined(__Userspace__)
    SCTP_FREE_SONAME(sin);
#endif
    SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
    return (ENOENT);
  }
#if !defined(__Userspace__)
  (*addr) = (struct sockaddr *)sin;
#endif
  return (0);
}

#if !defined(__Userspace__)
#if defined(__FreeBSD__)
#define SCTP_PROTOSW            \
  .pr_protocol =  IPPROTO_SCTP,       \
  .pr_ctloutput = sctp_ctloutput,       \
  .pr_abort = sctp_abort,       \
  .pr_accept =  sctp_accept,        \
  .pr_attach =  sctp_attach,        \
  .pr_bind =  sctp_bind,        \
  .pr_connect = sctp_connect,       \
  .pr_control = in_control,       \
  .pr_close = sctp_close,       \
  .pr_detach =  sctp_close,       \
  .pr_flush = sctp_flush,       \
  .pr_disconnect = sctp_disconnect,     \
  .pr_listen =  sctp_listen,        \
  .pr_peeraddr =  sctp_peeraddr,        \
  .pr_send =  sctp_sendm,       \
  .pr_shutdown =  sctp_shutdown,        \
  .pr_sockaddr =  sctp_ingetaddr,       \
  .pr_sosend =  sctp_sosend,        \
  .pr_soreceive = sctp_soreceive        \

struct protosw sctp_seqpacket_protosw = {
  .pr_type =  SOCK_SEQPACKET,
  .pr_flags = PR_WANTRCVD,
  SCTP_PROTOSW
};

struct protosw sctp_stream_protosw = {
  .pr_type =      SOCK_STREAM,
  .pr_flags = PR_CONNREQUIRED | PR_WANTRCVD,
  SCTP_PROTOSW
};
#else
struct pr_usrreqs sctp_usrreqs = {
#if defined(__APPLE__)
  .pru_abort = sctp_abort,
  .pru_accept = sctp_accept,
  .pru_attach = sctp_attach,
  .pru_bind = sctp_bind,
  .pru_connect = sctp_connect,
  .pru_connect2 = pru_connect2_notsupp,
  .pru_control = in_control,
  .pru_detach = sctp_detach,
  .pru_disconnect = sctp_disconnect,
  .pru_listen = sctp_listen,
  .pru_peeraddr = sctp_peeraddr,
  .pru_rcvd = NULL,
  .pru_rcvoob = pru_rcvoob_notsupp,
  .pru_send = sctp_sendm,
  .pru_sense = pru_sense_null,
  .pru_shutdown = sctp_shutdown,
  .pru_sockaddr = sctp_ingetaddr,
  .pru_sosend = sctp_sosend,
  .pru_soreceive = sctp_soreceive,
  .pru_sopoll = sopoll
#elif defined(_WIN32) && !defined(__Userspace__)
  sctp_abort,
  sctp_accept,
  sctp_attach,
  sctp_bind,
  sctp_connect,
  pru_connect2_notsupp,
  NULL,
  NULL,
  sctp_disconnect,
  sctp_listen,
  sctp_peeraddr,
  NULL,
  pru_rcvoob_notsupp,
  NULL,
  pru_sense_null,
  sctp_shutdown,
  sctp_flush,
  sctp_ingetaddr,
  sctp_sosend,
  sctp_soreceive,
  sopoll_generic,
  NULL,
  sctp_close
#endif
};
#endif
#endif
#endif

#if defined(__Userspace__)
int
register_recv_cb(struct socket *so,
                 int (*receive_cb)(struct socket *sock, union sctp_sockstore addr, void *data,
                 size_t datalen, struct sctp_rcvinfo, int flags, void *ulp_info))
{
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *) so->so_pcb;
  if (inp == NULL) {
    return (0);
  }
  SCTP_INP_WLOCK(inp);
  inp->recv_callback = receive_cb;
  SCTP_INP_WUNLOCK(inp);
  return (1);
}

int
register_send_cb(struct socket *so, uint32_t sb_threshold, int (*send_cb)(struct socket *sock, uint32_t sb_free, void *ulp_info))
{
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *) so->so_pcb;
  if (inp == NULL) {
    return (0);
  }
  SCTP_INP_WLOCK(inp);
  inp->send_callback = send_cb;
  inp->send_sb_threshold = sb_threshold;
  SCTP_INP_WUNLOCK(inp);
  /* FIXME change to current amount free. This will be the full buffer
   * the first time this is registered but it could be only a portion
   * of the send buffer if this is called a second time e.g. if the
   * threshold changes.
   */
  return (1);
}

int
register_ulp_info (struct socket *so, void *ulp_info)
{
  struct sctp_inpcb *inp;

  inp = (struct sctp_inpcb *) so->so_pcb;
  if (inp == NULL) {
    return (0);
  }
  SCTP_INP_WLOCK(inp);
  inp->ulp_info = ulp_info;
  SCTP_INP_WUNLOCK(inp);
  return (1);
}

int
retrieve_ulp_info (struct socket *so, void **pulp_info)
{
  struct sctp_inpcb *inp;

  if (pulp_info == NULL) {
    return (0);
  }

  inp = (struct sctp_inpcb *) so->so_pcb;
  if (inp == NULL) {
    return (0);
  }
  SCTP_INP_RLOCK(inp);
  *pulp_info = inp->ulp_info;
  SCTP_INP_RUNLOCK(inp);
  return (1);
}
#endif

Coverage Report

Created: 2025-12-31 07:49