sys/netinet/sctp_usrreq.c

   1 /*      $KAME: sctp_usrreq.c,v 1.47 2005/03/06 16:04:18 itojun Exp $    */
   2 /*      $DragonFly: src/sys/netinet/sctp_usrreq.c,v 1.10 2006/12/22 23:57:52 swildner Exp $     */
   3
   4 /*
   5  * Copyright (c) 2001, 2002, 2003, 2004 Cisco Systems, Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Cisco Systems, Inc.
  19  * 4. Neither the name of the project nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY CISCO SYSTEMS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL CISCO SYSTEMS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #if !(defined(__OpenBSD__) || defined(__APPLE__))
  36 #include "opt_ipsec.h"
  37 #endif
  38 #if defined(__FreeBSD__) || defined(__DragonFly__)
  39 #include "opt_inet6.h"
  40 #include "opt_inet.h"
  41 #endif
  42 #if defined(__NetBSD__)
  43 #include "opt_inet.h"
  44 #endif
  45
  46 #ifdef __APPLE__
  47 #include <sctp.h>
  48 #elif !defined(__OpenBSD__)
  49 #include "opt_sctp.h"
  50 #endif
  51
  52 #include <sys/param.h>
  53 #include <sys/systm.h>
  54 #include <sys/kernel.h>
  55 #include <sys/malloc.h>
  56 #include <sys/mbuf.h>
  57 #include <sys/domain.h>
  58 #include <sys/proc.h>
  59 #include <sys/protosw.h>
  60 #include <sys/socket.h>
  61 #include <sys/socketvar.h>
  62 #include <sys/sysctl.h>
  63 #include <sys/syslog.h>
  64 #include <sys/thread2.h>
  65 #include <net/if.h>
  66 #include <net/if_types.h>
  67 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
  68 #include <net/if_var.h>
  69 #endif
  70 #include <net/route.h>
  71 #include <netinet/in.h>
  72 #include <netinet/in_systm.h>
  73 #include <netinet/ip.h>
  74 #include <netinet/ip6.h>
  75 #include <netinet/in_pcb.h>
  76 #include <netinet/in_var.h>
  77 #include <netinet/ip_var.h>
  78 #include <netinet6/ip6_var.h>
  79 #include <netinet6/in6_var.h>
  80
  81 #include <netinet/ip_icmp.h>
  82 #include <netinet/icmp_var.h>
  83 #include <netinet/sctp_pcb.h>
  84 #include <netinet/sctp_header.h>
  85 #include <netinet/sctp_var.h>
  86 #include <netinet/sctp_output.h>
  87 #include <netinet/sctp_uio.h>
  88 #include <netinet/sctp_asconf.h>
  89 #include <netinet/sctputil.h>
  90 #include <netinet/sctp_indata.h>
  91 #include <netinet/sctp_asconf.h>
  92 #ifdef IPSEC
  93 #ifndef __OpenBSD__
  94 #include <netinet6/ipsec.h>
  95 #include <netproto/key/key.h>
  96 #else
  97 #undef IPSEC
  98 #endif
  99 #endif /* IPSEC */
 100
 101 #include <net/net_osdep.h>
 102
 103 #if defined(HAVE_NRL_INPCB) || defined(__FreeBSD__) || defined(__DragonFly__)
 104 #ifndef in6pcb
 105 #define in6pcb          inpcb
 106 #endif
 107 #ifndef sotoin6pcb
 108 #define sotoin6pcb      sotoinpcb
 109 #endif
 110 #endif
 111
 112 #ifdef SCTP_DEBUG
 113 extern u_int32_t sctp_debug_on;
 114 #endif /* SCTP_DEBUG */
 115
 116 /*
 117  * sysctl tunable variables
 118  */
 119 int sctp_auto_asconf = SCTP_DEFAULT_AUTO_ASCONF;
 120 int sctp_max_burst_default = SCTP_DEF_MAX_BURST;
 121 int sctp_peer_chunk_oh = sizeof(struct mbuf);
 122 int sctp_strict_init = 1;
 123 int sctp_no_csum_on_loopback = 1;
 124 unsigned int sctp_max_chunks_on_queue = SCTP_ASOC_MAX_CHUNKS_ON_QUEUE;
 125 int sctp_sendspace = (128 * 1024);
 126 int sctp_recvspace = 128 * (1024 +
 127 #ifdef INET6
 128                                 sizeof(struct sockaddr_in6)
 129 #else
 130                                 sizeof(struct sockaddr_in)
 131 #endif
 132         );
 133 int sctp_strict_sacks = 0;
 134 int sctp_ecn = 1;
 135 int sctp_ecn_nonce = 0;
 136
 137 unsigned int sctp_delayed_sack_time_default = SCTP_RECV_MSEC;
 138 unsigned int sctp_heartbeat_interval_default = SCTP_HB_DEFAULT_MSEC;
 139 unsigned int sctp_pmtu_raise_time_default = SCTP_DEF_PMTU_RAISE_SEC;
 140 unsigned int sctp_shutdown_guard_time_default = SCTP_DEF_MAX_SHUTDOWN_SEC;
 141 unsigned int sctp_secret_lifetime_default = SCTP_DEFAULT_SECRET_LIFE_SEC;
 142 unsigned int sctp_rto_max_default = SCTP_RTO_UPPER_BOUND;
 143 unsigned int sctp_rto_min_default = SCTP_RTO_LOWER_BOUND;
 144 unsigned int sctp_rto_initial_default = SCTP_RTO_INITIAL;
 145 unsigned int sctp_init_rto_max_default = SCTP_RTO_UPPER_BOUND;
 146 unsigned int sctp_valid_cookie_life_default = SCTP_DEFAULT_COOKIE_LIFE;
 147 unsigned int sctp_init_rtx_max_default = SCTP_DEF_MAX_INIT;
 148 unsigned int sctp_assoc_rtx_max_default = SCTP_DEF_MAX_SEND;
 149 unsigned int sctp_path_rtx_max_default = SCTP_DEF_MAX_SEND/2;
 150 unsigned int sctp_nr_outgoing_streams_default = SCTP_OSTREAM_INITIAL;
 151
 152 void
 153 sctp_init(void)
 154 {
 155 #ifdef __OpenBSD__
 156 #define nmbclusters     nmbclust
 157 #endif
 158         /* Init the SCTP pcb in sctp_pcb.c */
 159         u_long sb_max_adj;
 160
 161         sctp_pcb_init();
 162
 163 #ifndef __OpenBSD__
 164         if (nmbclusters > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
 165                 sctp_max_chunks_on_queue = nmbclusters;
 166 #else
 167 /*      if (nmbclust > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
 168         sctp_max_chunks_on_queue = nmbclust; FIX ME */
 169         sctp_max_chunks_on_queue = nmbclust * 2;
 170 #endif
 171         /*
 172          * Allow a user to take no more than 1/2 the number of clusters
 173          * or the SB_MAX whichever is smaller for the send window.
 174          */
 175         sb_max_adj = (u_long)((u_quad_t)(SB_MAX) * MCLBYTES / (MSIZE + MCLBYTES));
 176         sctp_sendspace = min((min(SB_MAX, sb_max_adj)),
 177 #ifndef __OpenBSD__
 178                              ((nmbclusters/2) * SCTP_DEFAULT_MAXSEGMENT));
 179 #else
 180                              ((nmbclust/2) * SCTP_DEFAULT_MAXSEGMENT));
 181 #endif
 182         /*
 183          * Now for the recv window, should we take the same amount?
 184          * or should I do 1/2 the SB_MAX instead in the SB_MAX min above.
 185          * For now I will just copy.
 186          */
 187         sctp_recvspace = sctp_sendspace;
 188 #ifdef __OpenBSD__
 189 #undef nmbclusters
 190 #endif
 191 }
 192
 193 #ifdef INET6
 194 void
 195 ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip)
 196 {
 197         bzero(ip6, sizeof(*ip6));
 198
 199         ip6->ip6_vfc = IPV6_VERSION;
 200         ip6->ip6_plen = ip->ip_len;
 201         ip6->ip6_nxt = ip->ip_p;
 202         ip6->ip6_hlim = ip->ip_ttl;
 203         ip6->ip6_src.s6_addr32[2] = ip6->ip6_dst.s6_addr32[2] =
 204                 IPV6_ADDR_INT32_SMP;
 205         ip6->ip6_src.s6_addr32[3] = ip->ip_src.s_addr;
 206         ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;
 207 }
 208 #endif /* INET6 */
 209
 210 static void
 211 sctp_split_chunks(struct sctp_association *asoc,
 212                   struct sctp_stream_out *strm,
 213                   struct sctp_tmit_chunk *chk)
 214 {
 215         struct sctp_tmit_chunk *new_chk;
 216
 217         /* First we need a chunk */
 218         new_chk = (struct sctp_tmit_chunk *)SCTP_ZONE_GET(sctppcbinfo.ipi_zone_chunk);
 219         if (new_chk == NULL) {
 220                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 221                 return;
 222         }
 223         sctppcbinfo.ipi_count_chunk++;
 224         sctppcbinfo.ipi_gencnt_chunk++;
 225         /* Copy it all */
 226         *new_chk = *chk;
 227         /*  split the data */
 228         new_chk->data = m_split(chk->data, (chk->send_size>>1), MB_DONTWAIT);
 229         if (new_chk->data == NULL) {
 230                 /* Can't split */
 231                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 232                 SCTP_ZONE_FREE(sctppcbinfo.ipi_zone_chunk, new_chk);
 233                 sctppcbinfo.ipi_count_chunk--;
 234                 if ((int)sctppcbinfo.ipi_count_chunk < 0) {
 235                         panic("Chunk count is negative");
 236                 }
 237                 sctppcbinfo.ipi_gencnt_chunk++;
 238                 return;
 239
 240         }
 241         /* Data is now split adjust sizes */
 242         chk->send_size >>= 1;
 243         new_chk->send_size >>= 1;
 244
 245         chk->book_size >>= 1;
 246         new_chk->book_size >>= 1;
 247
 248         /* now adjust the marks */
 249         chk->rec.data.rcv_flags |= SCTP_DATA_FIRST_FRAG;
 250         chk->rec.data.rcv_flags &= ~SCTP_DATA_LAST_FRAG;
 251
 252         new_chk->rec.data.rcv_flags &= ~SCTP_DATA_FIRST_FRAG;
 253         new_chk->rec.data.rcv_flags |= SCTP_DATA_LAST_FRAG;
 254
 255         /* Increase ref count if dest is set */
 256         if (chk->whoTo) {
 257                 new_chk->whoTo->ref_count++;
 258         }
 259         /* now drop it on the end of the list*/
 260         asoc->stream_queue_cnt++;
 261         TAILQ_INSERT_AFTER(&strm->outqueue, chk, new_chk, sctp_next);
 262 }
 263
 264 static void
 265 sctp_notify_mbuf(struct sctp_inpcb *inp,
 266                  struct sctp_tcb *stcb,
 267                  struct sctp_nets *net,
 268                  struct ip *ip,
 269                  struct sctphdr *sh)
 270
 271 {
 272         struct icmp *icmph;
 273         int totsz;
 274         uint16_t nxtsz;
 275
 276         /* protection */
 277         if ((inp == NULL) || (stcb == NULL) || (net == NULL) ||
 278             (ip == NULL) || (sh == NULL)) {
 279                 if (stcb != NULL)
 280                         SCTP_TCB_UNLOCK(stcb);
 281                 return;
 282         }
 283         /* First job is to verify the vtag matches what I would send */
 284         if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) {
 285                 SCTP_TCB_UNLOCK(stcb);
 286                 return;
 287         }
 288         icmph = (struct icmp *)((caddr_t)ip - (sizeof(struct icmp) -
 289                                                sizeof(struct ip)));
 290         if (icmph->icmp_type != ICMP_UNREACH) {
 291                 /* We only care about unreachable */
 292                 SCTP_TCB_UNLOCK(stcb);
 293                 return;
 294         }
 295         if (icmph->icmp_code != ICMP_UNREACH_NEEDFRAG) {
 296                 /* not a unreachable message due to frag. */
 297                 SCTP_TCB_UNLOCK(stcb);
 298                 return;
 299         }
 300         totsz = ip->ip_len;
 301         nxtsz = ntohs(icmph->icmp_seq);
 302         if (nxtsz == 0) {
 303                 /*
 304                  * old type router that does not tell us what the next size
 305                  * mtu is. Rats we will have to guess (in a educated fashion
 306                  * of course)
 307                  */
 308                 nxtsz = find_next_best_mtu(totsz);
 309         }
 310
 311         /* Stop any PMTU timer */
 312         sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL);
 313
 314         /* Adjust destination size limit */
 315         if (net->mtu > nxtsz) {
 316                 net->mtu = nxtsz;
 317         }
 318         /* now what about the ep? */
 319         if (stcb->asoc.smallest_mtu > nxtsz) {
 320                 struct sctp_tmit_chunk *chk, *nchk;
 321                 struct sctp_stream_out *strm;
 322                 /* Adjust that too */
 323                 stcb->asoc.smallest_mtu = nxtsz;
 324                 /* now off to subtract IP_DF flag if needed */
 325
 326                 TAILQ_FOREACH(chk, &stcb->asoc.send_queue, sctp_next) {
 327                         if ((chk->send_size+IP_HDR_SIZE) > nxtsz) {
 328                                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 329                         }
 330                 }
 331                 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
 332                         if ((chk->send_size+IP_HDR_SIZE) > nxtsz) {
 333                                 /*
 334                                  * For this guy we also mark for immediate
 335                                  * resend since we sent to big of chunk
 336                                  */
 337                                 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
 338                                 if (chk->sent != SCTP_DATAGRAM_RESEND) {
 339                                         stcb->asoc.sent_queue_retran_cnt++;
 340                                 }
 341                                 chk->sent = SCTP_DATAGRAM_RESEND;
 342                                 chk->rec.data.doing_fast_retransmit = 0;
 343
 344                                 /* Clear any time so NO RTT is being done */
 345                                 chk->do_rtt = 0;
 346                                 stcb->asoc.total_flight -= chk->book_size;
 347                                 if (stcb->asoc.total_flight < 0) {
 348                                         stcb->asoc.total_flight = 0;
 349                                 }
 350                                 stcb->asoc.total_flight_count--;
 351                                 if (stcb->asoc.total_flight_count < 0) {
 352                                         stcb->asoc.total_flight_count = 0;
 353                                 }
 354                                 net->flight_size -= chk->book_size;
 355                                 if (net->flight_size < 0) {
 356                                         net->flight_size = 0;
 357                                 }
 358                         }
 359                 }
 360                 TAILQ_FOREACH(strm, &stcb->asoc.out_wheel, next_spoke) {
 361                         chk = TAILQ_FIRST(&strm->outqueue);
 362                         while (chk) {
 363                                 nchk = TAILQ_NEXT(chk, sctp_next);
 364                                 if ((chk->send_size+SCTP_MED_OVERHEAD) > nxtsz) {
 365                                         sctp_split_chunks(&stcb->asoc, strm, chk);
 366                                 }
 367                                 chk = nchk;
 368                         }
 369                 }
 370         }
 371         sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL);
 372         SCTP_TCB_UNLOCK(stcb);
 373 }
 374
 375
 376 void
 377 sctp_notify(struct sctp_inpcb *inp,
 378             int error,
 379             struct sctphdr *sh,
 380             struct sockaddr *to,
 381             struct sctp_tcb *stcb,
 382             struct sctp_nets *net)
 383 {
 384         /* protection */
 385         if ((inp == NULL) || (stcb == NULL) || (net == NULL) ||
 386             (sh == NULL) || (to == NULL)) {
 387 #ifdef SCTP_DEBUG
 388                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
 389                         kprintf("sctp-notify, bad call\n");
 390                 }
 391 #endif /* SCTP_DEBUG */
 392                 return;
 393         }
 394         /* First job is to verify the vtag matches what I would send */
 395         if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) {
 396                 return;
 397         }
 398
 399 /* FIX ME FIX ME PROTOPT i.e. no SCTP should ALWAYS be an ABORT */
 400
 401         if ((error == EHOSTUNREACH) ||  /* Host is not reachable */
 402             (error == EHOSTDOWN) ||     /* Host is down */
 403             (error == ECONNREFUSED) ||  /* Host refused the connection, (not an abort?) */
 404             (error == ENOPROTOOPT)      /* SCTP is not present on host */
 405                 ) {
 406                 /*
 407                  * Hmm reachablity problems we must examine closely.
 408                  * If its not reachable, we may have lost a network.
 409                  * Or if there is NO protocol at the other end named SCTP.
 410                  * well we consider it a OOTB abort.
 411                  */
 412                 if ((error == EHOSTUNREACH) || (error == EHOSTDOWN)) {
 413                         if (net->dest_state & SCTP_ADDR_REACHABLE) {
 414                                 /* Ok that destination is NOT reachable */
 415                                 net->dest_state &= ~SCTP_ADDR_REACHABLE;
 416                                 net->dest_state |= SCTP_ADDR_NOT_REACHABLE;
 417                                 net->error_count = net->failure_threshold + 1;
 418                                 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
 419                                                 stcb, SCTP_FAILED_THRESHOLD,
 420                                                 (void *)net);
 421                         }
 422                         if (stcb)
 423                                 SCTP_TCB_UNLOCK(stcb);
 424                 } else {
 425                         /*
 426                          * Here the peer is either playing tricks on us,
 427                          * including an address that belongs to someone who
 428                          * does not support SCTP OR was a userland
 429                          * implementation that shutdown and now is dead. In
 430                          * either case treat it like a OOTB abort with no TCB
 431                          */
 432                         sctp_abort_notification(stcb, SCTP_PEER_FAULTY);
 433                         sctp_free_assoc(inp, stcb);
 434                         /* no need to unlock here, since the TCB is gone */
 435                 }
 436         } else {
 437                 /* Send all others to the app */
 438                 if (inp->sctp_socket) {
 439                         SOCK_LOCK(inp->sctp_socket);
 440                         inp->sctp_socket->so_error = error;
 441                         sctp_sowwakeup(inp, inp->sctp_socket);
 442                         SOCK_UNLOCK(inp->sctp_socket);
 443                 }
 444                 if (stcb)
 445                         SCTP_TCB_UNLOCK(stcb);
 446         }
 447 }
 448
 449 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 450 void
 451 #else
 452 void *
 453 #endif
 454 sctp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
 455 {
 456         struct ip *ip = vip;
 457         struct sctphdr *sh;
 458
 459
 460         if (sa->sa_family != AF_INET ||
 461             ((struct sockaddr_in *)sa)->sin_addr.s_addr == INADDR_ANY) {
 462 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 463                 return;
 464 #else
 465                 return (NULL);
 466 #endif
 467         }
 468
 469         if (PRC_IS_REDIRECT(cmd)) {
 470                 ip = 0;
 471         } else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {
 472 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 473                 return;
 474 #else
 475                 return (NULL);
 476 #endif
 477         }
 478         if (ip) {
 479                 struct sctp_inpcb *inp;
 480                 struct sctp_tcb *stcb;
 481                 struct sctp_nets *net;
 482                 struct sockaddr_in to, from;
 483
 484                 sh = (struct sctphdr *)((caddr_t)ip + (ip->ip_hl << 2));
 485                 bzero(&to, sizeof(to));
 486                 bzero(&from, sizeof(from));
 487                 from.sin_family = to.sin_family = AF_INET;
 488                 from.sin_len = to.sin_len = sizeof(to);
 489                 from.sin_port = sh->src_port;
 490                 from.sin_addr = ip->ip_src;
 491                 to.sin_port = sh->dest_port;
 492                 to.sin_addr = ip->ip_dst;
 493
 494                 /*
 495                  * 'to' holds the dest of the packet that failed to be sent.
 496                  * 'from' holds our local endpoint address.
 497                  * Thus we reverse the to and the from in the lookup.
 498                  */
 499                 crit_enter();
 500                 stcb = sctp_findassociation_addr_sa((struct sockaddr *)&from,
 501                                                     (struct sockaddr *)&to,
 502                                                     &inp, &net, 1);
 503                 if (stcb != NULL && inp && (inp->sctp_socket != NULL)) {
 504                         if (cmd != PRC_MSGSIZE) {
 505                                 int cm;
 506                                 if (cmd == PRC_HOSTDEAD) {
 507                                         cm = EHOSTUNREACH;
 508                                 } else {
 509                                         cm = inetctlerrmap[cmd];
 510                                 }
 511                                 sctp_notify(inp, cm, sh,
 512                                             (struct sockaddr *)&to, stcb,
 513                                             net);
 514                         } else {
 515                                 /* handle possible ICMP size messages */
 516                                 sctp_notify_mbuf(inp, stcb, net, ip, sh);
 517                         }
 518                 } else {
 519 #if (defined(__FreeBSD__) && __FreeBSD_version < 500000) || defined(__DragonFly__)
 520                         /* XXX must be fixed for 5.x and higher, leave for 4.x */
 521                         if (PRC_IS_REDIRECT(cmd) && inp) {
 522                                 in_rtchange((struct inpcb *)inp,
 523                                             inetctlerrmap[cmd]);
 524                         }
 525 #endif
 526                         if ((stcb == NULL) && (inp != NULL)) {
 527                                 /* reduce ref-count */
 528                                 SCTP_INP_WLOCK(inp);
 529                                 SCTP_INP_DECR_REF(inp);
 530                                 SCTP_INP_WUNLOCK(inp);
 531                         }
 532
 533                 }
 534                 crit_exit();
 535         }
 536 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 537         return;
 538 #else
 539         return (NULL);
 540 #endif
 541 }
 542
 543 #if defined(__FreeBSD__) || defined(__DragonFly__)
 544 static int
 545 sctp_getcred(SYSCTL_HANDLER_ARGS)
 546 {
 547         struct sockaddr_in addrs[2];
 548         struct sctp_inpcb *inp;
 549         struct sctp_nets *net;
 550         struct sctp_tcb *stcb;
 551         int error;
 552
 553 #if __FreeBSD_version >= 500000 || defined(__DragonFly__)
 554         error = suser(req->td);
 555 #else
 556         error = suser(req->p);
 557 #endif
 558         if (error)
 559                 return (error);
 560         error = SYSCTL_IN(req, addrs, sizeof(addrs));
 561         if (error)
 562                 return (error);
 563
 564         crit_enter();
 565         stcb = sctp_findassociation_addr_sa(sintosa(&addrs[0]),
 566                                            sintosa(&addrs[1]),
 567                                            &inp, &net, 1);
 568         if (stcb == NULL || inp == NULL || inp->sctp_socket == NULL) {
 569                 if ((inp != NULL) && (stcb == NULL)) {
 570                         /* reduce ref-count */
 571                         SCTP_INP_WLOCK(inp);
 572                         SCTP_INP_DECR_REF(inp);
 573                         SCTP_INP_WUNLOCK(inp);
 574                 }
 575                 error = ENOENT;
 576                 goto out;
 577         }
 578         error = SYSCTL_OUT(req, inp->sctp_socket->so_cred, sizeof(struct ucred));
 579         SCTP_TCB_UNLOCK(stcb);
 580 out:
 581         crit_exit();
 582         return (error);
 583 }
 584
 585 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW,
 586             0, 0, sctp_getcred, "S,ucred", "Get the ucred of a SCTP connection");
 587 #endif /* #if defined(__FreeBSD__) || defined(__DragonFly__) */
 588
 589 /*
 590  * sysctl definitions
 591  */
 592 #if defined(__FreeBSD__) || defined (__APPLE__) || defined(__DragonFly__)
 593
 594 SYSCTL_DECL(_net_inet);
 595
 596 SYSCTL_NODE(_net_inet, OID_AUTO, sctp, CTLFLAG_RD, 0,
 597         "sctp values");
 598
 599 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxdgram, CTLFLAG_RW,
 600            &sctp_sendspace, 0, "Maximum outgoing SCTP buffer size");
 601
 602 SYSCTL_INT(_net_inet_sctp, OID_AUTO, recvspace, CTLFLAG_RW,
 603            &sctp_recvspace, 0, "Maximum incoming SCTP buffer size");
 604
 605 SYSCTL_INT(_net_inet_sctp, OID_AUTO, auto_asconf, CTLFLAG_RW,
 606            &sctp_auto_asconf, 0, "Enable SCTP Auto-ASCONF");
 607
 608 SYSCTL_INT(_net_inet_sctp, OID_AUTO, ecn_enable, CTLFLAG_RW,
 609            &sctp_ecn, 0, "Enable SCTP ECN");
 610
 611 SYSCTL_INT(_net_inet_sctp, OID_AUTO, ecn_nonce, CTLFLAG_RW,
 612            &sctp_ecn_nonce, 0, "Enable SCTP ECN Nonce");
 613
 614 SYSCTL_INT(_net_inet_sctp, OID_AUTO, strict_sacks, CTLFLAG_RW,
 615            &sctp_strict_sacks, 0, "Enable SCTP Strict SACK checking");
 616
 617 SYSCTL_INT(_net_inet_sctp, OID_AUTO, loopback_nocsum, CTLFLAG_RW,
 618            &sctp_no_csum_on_loopback, 0,
 619            "Enable NO Csum on packets sent on loopback");
 620
 621 SYSCTL_INT(_net_inet_sctp, OID_AUTO, strict_init, CTLFLAG_RW,
 622            &sctp_strict_init, 0,
 623            "Enable strict INIT/INIT-ACK singleton enforcement");
 624
 625 SYSCTL_INT(_net_inet_sctp, OID_AUTO, peer_chkoh, CTLFLAG_RW,
 626            &sctp_peer_chunk_oh, 0,
 627            "Amount to debit peers rwnd per chunk sent");
 628
 629 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxburst, CTLFLAG_RW,
 630            &sctp_max_burst_default, 0,
 631            "Default max burst for sctp endpoints");
 632
 633 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxchunks, CTLFLAG_RW,
 634            &sctp_max_chunks_on_queue, 0,
 635            "Default max chunks on queue per asoc");
 636
 637 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, delayed_sack_time, CTLFLAG_RW,
 638             &sctp_delayed_sack_time_default, 0,
 639             "Default delayed SACK timer in msec");
 640
 641 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, heartbeat_interval, CTLFLAG_RW,
 642             &sctp_heartbeat_interval_default, 0,
 643             "Default heartbeat interval in msec");
 644
 645 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, pmtu_raise_time, CTLFLAG_RW,
 646             &sctp_pmtu_raise_time_default, 0,
 647             "Default PMTU raise timer in sec");
 648
 649 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, shutdown_guard_time, CTLFLAG_RW,
 650             &sctp_shutdown_guard_time_default, 0,
 651             "Default shutdown guard timer in sec");
 652
 653 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, secret_lifetime, CTLFLAG_RW,
 654             &sctp_secret_lifetime_default, 0,
 655             "Default secret lifetime in sec");
 656
 657 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_max, CTLFLAG_RW,
 658             &sctp_rto_max_default, 0,
 659             "Default maximum retransmission timeout in msec");
 660
 661 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_min, CTLFLAG_RW,
 662             &sctp_rto_min_default, 0,
 663             "Default minimum retransmission timeout in msec");
 664
 665 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_initial, CTLFLAG_RW,
 666             &sctp_rto_initial_default, 0,
 667             "Default initial retransmission timeout in msec");
 668
 669 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, init_rto_max, CTLFLAG_RW,
 670             &sctp_init_rto_max_default, 0,
 671             "Default maximum retransmission timeout during association setup in msec");
 672
 673 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, valid_cookie_life, CTLFLAG_RW,
 674             &sctp_valid_cookie_life_default, 0,
 675             "Default cookie lifetime in sec");
 676
 677 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, init_rtx_max, CTLFLAG_RW,
 678             &sctp_init_rtx_max_default, 0,
 679             "Default maximum number of retransmission for INIT chunks");
 680
 681 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, assoc_rtx_max, CTLFLAG_RW,
 682             &sctp_assoc_rtx_max_default, 0,
 683             "Default maximum number of retransmissions per association");
 684
 685 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, path_rtx_max, CTLFLAG_RW,
 686             &sctp_path_rtx_max_default, 0,
 687             "Default maximum of retransmissions per path");
 688
 689 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, nr_outgoing_streams, CTLFLAG_RW,
 690             &sctp_nr_outgoing_streams_default, 0,
 691             "Default number of outgoing streams");
 692
 693 #ifdef SCTP_DEBUG
 694 SYSCTL_INT(_net_inet_sctp, OID_AUTO, debug, CTLFLAG_RW,
 695            &sctp_debug_on, 0, "Configure debug output");
 696 #endif /* SCTP_DEBUG */
 697 #endif
 698
 699 static int
 700 sctp_abort(struct socket *so)
 701 {
 702         struct sctp_inpcb *inp;
 703
 704         inp = (struct sctp_inpcb *)so->so_pcb;
 705         if (inp == 0)
 706                 return EINVAL;  /* ??? possible? panic instead? */
 707
 708         crit_enter();
 709         sctp_inpcb_free(inp, 1);
 710         crit_exit();
 711         return 0;
 712 }
 713
 714 static int
 715 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 716 sctp_attach(struct socket *so, int proto, struct thread *p)
 717 #elif defined(__DragonFly__)
 718 sctp_attach(struct socket *so, int proto, struct pru_attach_info *ai)
 719 #else
 720 sctp_attach(struct socket *so, int proto, struct proc *p)
 721 #endif
 722 {
 723         struct sctp_inpcb *inp;
 724         struct inpcb *ip_inp;
 725         int error;
 726
 727         crit_enter();
 728         inp = (struct sctp_inpcb *)so->so_pcb;
 729         if (inp != 0) {
 730                 crit_exit();
 731                 return EINVAL;
 732         }
 733         error = soreserve(so, sctp_sendspace, sctp_recvspace, NULL);
 734         if (error) {
 735                 crit_exit();
 736                 return error;
 737         }
 738         error = sctp_inpcb_alloc(so);
 739         if (error) {
 740                 crit_exit();
 741                 return error;
 742         }
 743         inp = (struct sctp_inpcb *)so->so_pcb;
 744         SCTP_INP_WLOCK(inp);
 745
 746         inp->sctp_flags &= ~SCTP_PCB_FLAGS_BOUND_V6;    /* I'm not v6! */
 747         ip_inp = &inp->ip_inp.inp;
 748 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 749         ip_inp->inp_vflag |= INP_IPV4;
 750         ip_inp->inp_ip_ttl = ip_defttl;
 751 #else
 752         inp->inp_vflag |= INP_IPV4;
 753         inp->inp_ip_ttl = ip_defttl;
 754 #endif
 755
 756 #ifdef IPSEC
 757 #if !(defined(__OpenBSD__) || defined(__APPLE__))
 758         error = ipsec_init_policy(so, &ip_inp->inp_sp);
 759         if (error != 0) {
 760                 sctp_inpcb_free(inp, 1);
 761                 return error;
 762         }
 763 #endif
 764 #endif /*IPSEC*/
 765         SCTP_INP_WUNLOCK(inp);
 766 #if defined(__NetBSD__)
 767         so->so_send = sctp_sosend;
 768 #endif
 769         crit_exit();
 770         return 0;
 771 }
 772
 773 static int
 774 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
 775 sctp_bind(struct socket *so, struct sockaddr *addr, struct thread *p)
 776 {
 777 #elif defined(__FreeBSD__) || defined(__APPLE__)
 778 sctp_bind(struct socket *so, struct sockaddr *addr, struct proc *p)
 779 {
 780 #else
 781 sctp_bind(struct socket *so, struct mbuf *nam, struct proc *p)
 782 {
 783         struct sockaddr *addr = nam ? mtod(nam, struct sockaddr *) : NULL;
 784 #endif
 785         struct sctp_inpcb *inp;
 786         int error;
 787
 788 #ifdef INET6
 789         if (addr && addr->sa_family != AF_INET)
 790                 /* must be a v4 address! */
 791                 return EINVAL;
 792 #endif /* INET6 */
 793
 794         inp = (struct sctp_inpcb *)so->so_pcb;
 795         if (inp == 0)
 796                 return EINVAL;
 797
 798         crit_enter();
 799         error = sctp_inpcb_bind(so, addr, p);
 800         crit_exit();
 801         return error;
 802 }
 803
 804
 805 static int
 806 sctp_detach(struct socket *so)
 807 {
 808         struct sctp_inpcb *inp;
 809
 810         inp = (struct sctp_inpcb *)so->so_pcb;
 811         if (inp == 0)
 812                 return EINVAL;
 813         crit_enter();
 814         if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
 815             (so->so_rcv.sb_cc > 0)) {
 816                 sctp_inpcb_free(inp, 1);
 817         } else {
 818                 sctp_inpcb_free(inp, 0);
 819         }
 820         crit_exit();
 821         return 0;
 822 }
 823
 824 int
 825 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
 826 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 827           struct mbuf *control, struct thread *p);
 828 #else
 829 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 830           struct mbuf *control, struct proc *p);
 831 #endif
 832
 833 int
 834 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
 835 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 836           struct mbuf *control, struct thread *p)
 837 {
 838 #else
 839 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 840           struct mbuf *control, struct proc *p)
 841 {
 842 #endif
 843         struct sctp_inpcb *inp;
 844         int error;
 845         inp = (struct sctp_inpcb *)so->so_pcb;
 846         if (inp == 0) {
 847                 if (control) {
 848                         sctp_m_freem(control);
 849                         control = NULL;
 850                 }
 851                 sctp_m_freem(m);
 852                 return EINVAL;
 853         }
 854         /* Got to have an to address if we are NOT a connected socket */
 855         if ((addr == NULL) &&
 856             ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) ||
 857              (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE))
 858                 ) {
 859                 goto connected_type;
 860         } else if (addr == NULL) {
 861                 error = EDESTADDRREQ;
 862                 sctp_m_freem(m);
 863                 if (control) {
 864                         sctp_m_freem(control);
 865                         control = NULL;
 866                 }
 867                 return (error);
 868         }
 869 #ifdef INET6
 870         if (addr->sa_family != AF_INET) {
 871                 /* must be a v4 address! */
 872                 sctp_m_freem(m);
 873                 if (control) {
 874                         sctp_m_freem(control);
 875                         control = NULL;
 876                 }
 877                 error = EDESTADDRREQ;
 878                 return EINVAL;
 879         }
 880 #endif /* INET6 */
 881  connected_type:
 882         /* now what about control */
 883         if (control) {
 884                 if (inp->control) {
 885                         kprintf("huh? control set?\n");
 886                         sctp_m_freem(inp->control);
 887                         inp->control = NULL;
 888                 }
 889                 inp->control = control;
 890         }
 891         /* add it in possibly */
 892         if ((inp->pkt) && (inp->pkt->m_flags & M_PKTHDR)) {
 893                 struct mbuf *x;
 894                 int c_len;
 895
 896                 c_len = 0;
 897                 /* How big is it */
 898                 for (x=m;x;x = x->m_next) {
 899                         c_len += x->m_len;
 900                 }
 901                 inp->pkt->m_pkthdr.len += c_len;
 902         }
 903         /* Place the data */
 904         if (inp->pkt) {
 905                 inp->pkt_last->m_next = m;
 906                 inp->pkt_last = m;
 907         } else {
 908                 inp->pkt_last = inp->pkt = m;
 909         }
 910         if (
 911 #if defined (__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
 912             /* FreeBSD uses a flag passed */
 913             ((flags & PRUS_MORETOCOME) == 0)
 914 #elif defined( __NetBSD__)
 915             /* NetBSD uses the so_state field */
 916             ((so->so_state & SS_MORETOCOME) == 0)
 917 #else
 918             1   /* Open BSD does not have any "more to come" indication */
 919 #endif
 920             ) {
 921                 /*
 922                  * note with the current version this code will only be used
 923                  * by OpenBSD-- NetBSD, FreeBSD, and MacOS have methods for
 924                  * re-defining sosend to use the sctp_sosend. One can
 925                  * optionally switch back to this code (by changing back the
 926                  * definitions) but this is not advisable.
 927              */
 928                 int ret;
 929                 ret = sctp_output(inp, inp->pkt, addr, inp->control, p, flags);
 930                 inp->pkt = NULL;
 931                 inp->control = NULL;
 932                 return (ret);
 933         } else {
 934                 return (0);
 935         }
 936 }
 937
 938 static int
 939 sctp_disconnect(struct socket *so)
 940 {
 941         struct sctp_inpcb *inp;
 942
 943         crit_enter();
 944         inp = (struct sctp_inpcb *)so->so_pcb;
 945         if (inp == NULL) {
 946                 crit_exit();
 947                 return (ENOTCONN);
 948         }
 949         SCTP_INP_RLOCK(inp);
 950         if (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
 951                 if (LIST_EMPTY(&inp->sctp_asoc_list)) {
 952                         /* No connection */
 953                         crit_exit();
 954                         SCTP_INP_RUNLOCK(inp);
 955                         return (0);
 956                 } else {
 957                         int some_on_streamwheel = 0;
 958                         struct sctp_association *asoc;
 959                         struct sctp_tcb *stcb;
 960
 961                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
 962                         if (stcb == NULL) {
 963                                 crit_exit();
 964                                 SCTP_INP_RUNLOCK(inp);
 965                                 return (EINVAL);
 966                         }
 967                         asoc = &stcb->asoc;
 968                         SCTP_TCB_LOCK(stcb);
 969                         if (((so->so_options & SO_LINGER) &&
 970                              (so->so_linger == 0)) ||
 971                             (so->so_rcv.sb_cc > 0)) {
 972                                 if (SCTP_GET_STATE(asoc) !=
 973                                     SCTP_STATE_COOKIE_WAIT) {
 974                                         /* Left with Data unread */
 975                                         struct mbuf *err;
 976                                         err = NULL;
 977                                         MGET(err, MB_DONTWAIT, MT_DATA);
 978                                         if (err) {
 979                                                 /* Fill in the user initiated abort */
 980                                                 struct sctp_paramhdr *ph;
 981                                                 ph = mtod(err, struct sctp_paramhdr *);
 982                                                 err->m_len = sizeof(struct sctp_paramhdr);
 983                                                 ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT);
 984                                                 ph->param_length = htons(err->m_len);
 985                                         }
 986                                         sctp_send_abort_tcb(stcb, err);
 987                                 }
 988                                 SCTP_INP_RUNLOCK(inp);
 989                                 sctp_free_assoc(inp, stcb);
 990                                 /* No unlock tcb assoc is gone */
 991                                 crit_exit();
 992                                 return (0);
 993                         }
 994                         if (!TAILQ_EMPTY(&asoc->out_wheel)) {
 995                                 /* Check to see if some data queued */
 996                                 struct sctp_stream_out *outs;
 997                                 TAILQ_FOREACH(outs, &asoc->out_wheel,
 998                                               next_spoke) {
 999                                         if (!TAILQ_EMPTY(&outs->outqueue)) {
1000                                                 some_on_streamwheel = 1;
1001                                                 break;
1002                                         }
1003                                 }
1004                         }
1005
1006                         if (TAILQ_EMPTY(&asoc->send_queue) &&
1007                             TAILQ_EMPTY(&asoc->sent_queue) &&
1008                             (some_on_streamwheel == 0)) {
1009                                 /* there is nothing queued to send, so done */
1010                                 if ((SCTP_GET_STATE(asoc) !=
1011                                      SCTP_STATE_SHUTDOWN_SENT) &&
1012                                     (SCTP_GET_STATE(asoc) !=
1013                                      SCTP_STATE_SHUTDOWN_ACK_SENT)) {
1014                                         /* only send SHUTDOWN 1st time thru */
1015 #ifdef SCTP_DEBUG
1016                                         if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1017                                                 kprintf("%s:%d sends a shutdown\n",
1018                                                        __FILE__,
1019                                                        __LINE__
1020                                                         );
1021                                         }
1022 #endif
1023                                         sctp_send_shutdown(stcb,
1024                                                            stcb->asoc.primary_destination);
1025                                         sctp_chunk_output(stcb->sctp_ep, stcb, 1);
1026                                         asoc->state = SCTP_STATE_SHUTDOWN_SENT;
1027                                         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1028                                                          stcb->sctp_ep, stcb,
1029                                                          asoc->primary_destination);
1030                                         sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1031                                                          stcb->sctp_ep, stcb,
1032                                                          asoc->primary_destination);
1033                                 }
1034                         } else {
1035                                 /*
1036                                  * we still got (or just got) data to send,
1037                                  * so set SHUTDOWN_PENDING
1038                                  */
1039                                 /*
1040                                  * XXX sockets draft says that MSG_EOF should
1041                                  * be sent with no data.
1042                                  * currently, we will allow user data to be
1043                                  * sent first and move to SHUTDOWN-PENDING
1044                                  */
1045                                 asoc->state |= SCTP_STATE_SHUTDOWN_PENDING;
1046                         }
1047                         SCTP_TCB_UNLOCK(stcb);
1048                         SCTP_INP_RUNLOCK(inp);
1049                         crit_exit();
1050                         return (0);
1051                 }
1052                 /* not reached */
1053         } else {
1054                 /* UDP model does not support this */
1055                 SCTP_INP_RUNLOCK(inp);
1056                 crit_exit();
1057                 return EOPNOTSUPP;
1058         }
1059 }
1060
1061 int
1062 sctp_shutdown(struct socket *so)
1063 {
1064         struct sctp_inpcb *inp;
1065
1066         crit_enter();
1067         inp = (struct sctp_inpcb *)so->so_pcb;
1068         if (inp == 0) {
1069                 crit_exit();
1070                 return EINVAL;
1071         }
1072         SCTP_INP_RLOCK(inp);
1073         /* For UDP model this is a invalid call */
1074         if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
1075                 /* Restore the flags that the soshutdown took away. */
1076 #if defined(__FreeBSD__) && __FreeBSD_version >= 502115
1077                 so->so_rcv.sb_state &= ~SBS_CANTRCVMORE;
1078 #else
1079                 so->so_state &= ~SS_CANTRCVMORE;
1080 #endif
1081                 /* This proc will wakeup for read and do nothing (I hope) */
1082                 crit_exit();
1083                 SCTP_INP_RUNLOCK(inp);
1084                 return (EOPNOTSUPP);
1085         }
1086         /*
1087          * Ok if we reach here its the TCP model and it is either a SHUT_WR
1088          * or SHUT_RDWR. This means we put the shutdown flag against it.
1089          */
1090         {
1091                 int some_on_streamwheel = 0;
1092                 struct sctp_tcb *stcb;
1093                 struct sctp_association *asoc;
1094                 socantsendmore(so);
1095
1096                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1097                 if (stcb == NULL) {
1098                         /*
1099                          * Ok we hit the case that the shutdown call was made
1100                          * after an abort or something. Nothing to do now.
1101                          */
1102                         crit_exit();
1103                         return (0);
1104                 }
1105                 SCTP_TCB_LOCK(stcb);
1106                 asoc = &stcb->asoc;
1107
1108                 if (!TAILQ_EMPTY(&asoc->out_wheel)) {
1109                         /* Check to see if some data queued */
1110                         struct sctp_stream_out *outs;
1111                         TAILQ_FOREACH(outs, &asoc->out_wheel, next_spoke) {
1112                                 if (!TAILQ_EMPTY(&outs->outqueue)) {
1113                                         some_on_streamwheel = 1;
1114                                         break;
1115                                 }
1116                         }
1117                 }
1118                 if (TAILQ_EMPTY(&asoc->send_queue) &&
1119                     TAILQ_EMPTY(&asoc->sent_queue) &&
1120                     (some_on_streamwheel == 0)) {
1121                         /* there is nothing queued to send, so I'm done... */
1122                         if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) {
1123                                 /* only send SHUTDOWN the first time through */
1124 #ifdef SCTP_DEBUG
1125                                 if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1126                                         kprintf("%s:%d sends a shutdown\n",
1127                                                __FILE__,
1128                                                __LINE__
1129                                                 );
1130                                 }
1131 #endif
1132                                 sctp_send_shutdown(stcb,
1133                                                    stcb->asoc.primary_destination);
1134                                 sctp_chunk_output(stcb->sctp_ep, stcb, 1);
1135                                 asoc->state = SCTP_STATE_SHUTDOWN_SENT;
1136                                 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1137                                                  stcb->sctp_ep, stcb,
1138                                                  asoc->primary_destination);
1139                                 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1140                                                  stcb->sctp_ep, stcb,
1141                                                  asoc->primary_destination);
1142                         }
1143                 } else {
1144                         /*
1145                          * we still got (or just got) data to send, so
1146                          * set SHUTDOWN_PENDING
1147                          */
1148                         asoc->state |= SCTP_STATE_SHUTDOWN_PENDING;
1149                 }
1150                 SCTP_TCB_UNLOCK(stcb);
1151         }
1152         SCTP_INP_RUNLOCK(inp);
1153         crit_exit();
1154         return 0;
1155 }
1156
1157 /*
1158  * copies a "user" presentable address and removes embedded scope, etc.
1159  * returns 0 on success, 1 on error
1160  */
1161 static uint32_t
1162 sctp_fill_user_address(struct sockaddr_storage *ss, struct sockaddr *sa)
1163 {
1164         struct sockaddr_in6 lsa6;
1165         sa = (struct sockaddr *)sctp_recover_scope((struct sockaddr_in6 *)sa,
1166                                                    &lsa6);
1167         memcpy(ss, sa, sa->sa_len);
1168         return (0);
1169 }
1170
1171
1172 #if defined(__NetBSD__) || defined(__OpenBSD__)
1173 /*
1174  * On NetBSD and OpenBSD in6_sin_2_v4mapsin6() not used and not exported,
1175  * so we have to export it here.
1176  */
1177 void    in6_sin_2_v4mapsin6(struct sockaddr_in *sin, struct sockaddr_in6 *sin6);
1178 #endif
1179
1180 static int
1181 sctp_fill_up_addresses(struct sctp_inpcb *inp,
1182                        struct sctp_tcb *stcb,
1183                        int limit,
1184                        struct sockaddr_storage *sas)
1185 {
1186         struct ifnet *ifn;
1187         struct ifaddr *ifa;
1188         int loopback_scope, ipv4_local_scope, local_scope, site_scope, actual;
1189         int ipv4_addr_legal, ipv6_addr_legal;
1190         actual = 0;
1191         if (limit <= 0)
1192                 return (actual);
1193
1194         if (stcb) {
1195                 /* Turn on all the appropriate scope */
1196                 loopback_scope = stcb->asoc.loopback_scope;
1197                 ipv4_local_scope = stcb->asoc.ipv4_local_scope;
1198                 local_scope = stcb->asoc.local_scope;
1199                 site_scope = stcb->asoc.site_scope;
1200         } else {
1201                 /* Turn on ALL scope, since we look at the EP */
1202                 loopback_scope = ipv4_local_scope = local_scope =
1203                         site_scope = 1;
1204         }
1205         ipv4_addr_legal = ipv6_addr_legal = 0;
1206         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
1207                 ipv6_addr_legal = 1;
1208                 if (
1209 #if defined(__OpenBSD__)
1210                 (0) /* we always do dual bind */
1211 #elif defined (__NetBSD__)
1212                 (((struct in6pcb *)inp)->in6p_flags & IN6P_IPV6_V6ONLY)
1213 #else
1214                 (((struct in6pcb *)inp)->inp_flags & IN6P_IPV6_V6ONLY)
1215 #endif
1216                 == 0) {
1217                         ipv4_addr_legal = 1;
1218                 }
1219         } else {
1220                 ipv4_addr_legal = 1;
1221         }
1222
1223         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
1224                 TAILQ_FOREACH(ifn, &ifnet, if_list) {
1225                         if ((loopback_scope == 0) &&
1226                             (ifn->if_type == IFT_LOOP)) {
1227                                 /* Skip loopback if loopback_scope not set */
1228                                 continue;
1229                         }
1230                         TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) {
1231                                 if (stcb) {
1232                                 /*
1233                                  * For the BOUND-ALL case, the list
1234                                  * associated with a TCB is Always
1235                                  * considered a reverse list.. i.e.
1236                                  * it lists addresses that are NOT
1237                                  * part of the association. If this
1238                                  * is one of those we must skip it.
1239                                  */
1240                                         if (sctp_is_addr_restricted(stcb,
1241                                                                     ifa->ifa_addr)) {
1242                                                 continue;
1243                                         }
1244                                 }
1245                                 if ((ifa->ifa_addr->sa_family == AF_INET) &&
1246                                     (ipv4_addr_legal)) {
1247                                         struct sockaddr_in *sin;
1248                                         sin = (struct sockaddr_in *)ifa->ifa_addr;
1249                                         if (sin->sin_addr.s_addr == 0) {
1250                                                 /* we skip unspecifed addresses */
1251                                                 continue;
1252                                         }
1253                                         if ((ipv4_local_scope == 0) &&
1254                                             (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) {
1255                                                 continue;
1256                                         }
1257                                         if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) {
1258                                                 in6_sin_2_v4mapsin6(sin, (struct sockaddr_in6 *)sas);
1259                                                 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1260                                                 sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(struct sockaddr_in6));
1261                                                 actual += sizeof(sizeof(struct sockaddr_in6));
1262                                         } else {
1263                                                 memcpy(sas, sin, sizeof(*sin));
1264                                                 ((struct sockaddr_in *)sas)->sin_port = inp->sctp_lport;
1265                                                 sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(*sin));
1266                                                 actual += sizeof(*sin);
1267                                         }
1268                                         if (actual >= limit) {
1269                                                 return (actual);
1270                                         }
1271                                 } else if ((ifa->ifa_addr->sa_family == AF_INET6) &&
1272                                            (ipv6_addr_legal)) {
1273                                         struct sockaddr_in6 *sin6, lsa6;
1274                                         sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1275                                         if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
1276                                                 /* we skip unspecifed addresses */
1277                                                 continue;
1278                                         }
1279                                         if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
1280                                                 if (local_scope == 0)
1281                                                         continue;
1282                                                 if (sin6->sin6_scope_id == 0) {
1283                                                         lsa6 = *sin6;
1284                                                         if (in6_recoverscope(&lsa6,
1285                                                                              &lsa6.sin6_addr,
1286                                                                              NULL))
1287                                                                 /* bad link local address */
1288                                                                 continue;
1289                                                         sin6 = &lsa6;
1290                                                 }
1291                                         }
1292                                         if ((site_scope == 0) &&
1293                                             (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) {
1294                                                 continue;
1295                                         }
1296                                         memcpy(sas, sin6, sizeof(*sin6));
1297                                         ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1298                                         sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(*sin6));
1299                                         actual += sizeof(*sin6);
1300                                         if (actual >= limit) {
1301                                                 return (actual);
1302                                         }
1303                                 }
1304                         }
1305                 }
1306         } else {
1307                 struct sctp_laddr *laddr;
1308                 /*
1309                  * If we have a TCB and we do NOT support ASCONF (it's
1310                  * turned off or otherwise) then the list is always the
1311                  * true list of addresses (the else case below).  Otherwise
1312                  * the list on the association is a list of addresses that
1313                  * are NOT part of the association.
1314                  */
1315                 if (inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
1316                         /* The list is a NEGATIVE list */
1317                         LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
1318                                 if (stcb) {
1319                                         if (sctp_is_addr_restricted(stcb, laddr->ifa->ifa_addr)) {
1320                                                 continue;
1321                                         }
1322                                 }
1323                                 if (sctp_fill_user_address(sas, laddr->ifa->ifa_addr))
1324                                         continue;
1325
1326                                 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1327                                 sas = (struct sockaddr_storage *)((caddr_t)sas +
1328                                                                   laddr->ifa->ifa_addr->sa_len);
1329                                 actual += laddr->ifa->ifa_addr->sa_len;
1330                                 if (actual >= limit) {
1331                                         return (actual);
1332                                 }
1333                         }
1334                 } else {
1335                         /* The list is a positive list if present */
1336                         if (stcb) {
1337                                 /* Must use the specific association list */
1338                                 LIST_FOREACH(laddr, &stcb->asoc.sctp_local_addr_list,
1339                                              sctp_nxt_addr) {
1340                                         if (sctp_fill_user_address(sas,
1341                                                                    laddr->ifa->ifa_addr))
1342                                                 continue;
1343                                         ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1344                                         sas = (struct sockaddr_storage *)((caddr_t)sas +
1345                                                                           laddr->ifa->ifa_addr->sa_len);
1346                                         actual += laddr->ifa->ifa_addr->sa_len;
1347                                         if (actual >= limit) {
1348                                                 return (actual);
1349                                         }
1350                                 }
1351                         } else {
1352                                 /* No endpoint so use the endpoints individual list */
1353                                 LIST_FOREACH(laddr, &inp->sctp_addr_list,
1354                                              sctp_nxt_addr) {
1355                                         if (sctp_fill_user_address(sas,
1356                                                                    laddr->ifa->ifa_addr))
1357                                                 continue;
1358                                         ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1359                                         sas = (struct sockaddr_storage *)((caddr_t)sas +
1360                                                                           laddr->ifa->ifa_addr->sa_len);
1361                                         actual += laddr->ifa->ifa_addr->sa_len;
1362                                         if (actual >= limit) {
1363                                                 return (actual);
1364                                         }
1365                                 }
1366                         }
1367                 }
1368         }
1369         return (actual);
1370 }
1371
1372 static int
1373 sctp_count_max_addresses(struct sctp_inpcb *inp)
1374 {
1375         int cnt = 0;
1376         /*
1377          * In both sub-set bound an bound_all cases we return the MAXIMUM
1378          * number of addresses that you COULD get. In reality the sub-set
1379          * bound may have an exclusion list for a given TCB OR in the
1380          * bound-all case a TCB may NOT include the loopback or other
1381          * addresses as well.
1382          */
1383         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
1384                 struct ifnet *ifn;
1385                 struct ifaddr *ifa;
1386
1387                 TAILQ_FOREACH(ifn, &ifnet, if_list) {
1388                         TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) {
1389                                 /* Count them if they are the right type */
1390                                 if (ifa->ifa_addr->sa_family == AF_INET) {
1391                                         if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)
1392                                                 cnt += sizeof(struct sockaddr_in6);
1393                                         else
1394                                                 cnt += sizeof(struct sockaddr_in);
1395
1396                                 } else if (ifa->ifa_addr->sa_family == AF_INET6)
1397                                         cnt += sizeof(struct sockaddr_in6);
1398                         }
1399                 }
1400         } else {
1401                 struct sctp_laddr *laddr;
1402                 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
1403                         if (laddr->ifa->ifa_addr->sa_family == AF_INET) {
1404                                 if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)
1405                                         cnt += sizeof(struct sockaddr_in6);
1406                                 else
1407                                         cnt += sizeof(struct sockaddr_in);
1408
1409                         } else if (laddr->ifa->ifa_addr->sa_family == AF_INET6)
1410                                 cnt += sizeof(struct sockaddr_in6);
1411                 }
1412         }
1413         return (cnt);
1414 }
1415
1416 static int
1417 sctp_do_connect_x(struct socket *so,
1418                   struct sctp_inpcb *inp,
1419                   struct mbuf *m,
1420 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
1421                   struct thread *p,
1422 #else
1423                   struct proc *p,
1424 #endif
1425                   int delay
1426         )
1427 {
1428         int error = 0;
1429         struct sctp_tcb *stcb = NULL;
1430         struct sockaddr *sa;
1431         int num_v6=0, num_v4=0, *totaddrp, totaddr, i, incr, at;
1432 #ifdef SCTP_DEBUG
1433         if (sctp_debug_on & SCTP_DEBUG_PCB1) {
1434                 kprintf("Connectx called\n");
1435         }
1436 #endif /* SCTP_DEBUG */
1437
1438         crit_enter();
1439         if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
1440             (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
1441                 /* We are already connected AND the TCP model */
1442                 crit_exit();
1443                 return (EADDRINUSE);
1444         }
1445         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
1446                 SCTP_INP_RLOCK(inp);
1447                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1448                 SCTP_INP_RUNLOCK(inp);
1449         }
1450         if (stcb) {
1451                 crit_exit();
1452                 return (EALREADY);
1453
1454         }
1455         SCTP_ASOC_CREATE_LOCK(inp);
1456         if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
1457             (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
1458                 SCTP_ASOC_CREATE_UNLOCK(inp);
1459                 crit_exit();
1460                 return (EFAULT);
1461         }
1462
1463         totaddrp = mtod(m, int *);
1464         totaddr = *totaddrp;
1465         sa = (struct sockaddr *)(totaddrp + 1);
1466         at = incr = 0;
1467         /* account and validate addresses */
1468         SCTP_INP_WLOCK(inp);
1469         SCTP_INP_INCR_REF(inp);
1470         SCTP_INP_WUNLOCK(inp);
1471         for (i = 0; i < totaddr; i++) {
1472                 if (sa->sa_family == AF_INET) {
1473                         num_v4++;
1474                         incr = sizeof(struct sockaddr_in);
1475                 } else if (sa->sa_family == AF_INET6) {
1476                         struct sockaddr_in6 *sin6;
1477                         sin6 = (struct sockaddr_in6 *)sa;
1478                         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
1479                                 /* Must be non-mapped for connectx */
1480                                 SCTP_ASOC_CREATE_UNLOCK(inp);
1481                                 crit_exit();
1482                                 return EINVAL;
1483                         }
1484                         num_v6++;
1485                         incr = sizeof(struct sockaddr_in6);
1486                 } else {
1487                         totaddr = i;
1488                         break;
1489                 }
1490                 stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);
1491                 if (stcb != NULL) {
1492                         /* Already have or am bring up an association */
1493                         SCTP_ASOC_CREATE_UNLOCK(inp);
1494                         SCTP_TCB_UNLOCK(stcb);
1495                         crit_exit();
1496                         return (EALREADY);
1497                 }
1498                 if ((at + incr) > m->m_len) {
1499                         totaddr = i;
1500                         break;
1501                 }
1502                 sa = (struct sockaddr *)((caddr_t)sa + incr);
1503         }
1504         sa = (struct sockaddr *)(totaddrp + 1);
1505         SCTP_INP_WLOCK(inp);
1506         SCTP_INP_DECR_REF(inp);
1507         SCTP_INP_WUNLOCK(inp);
1508 #ifdef INET6
1509         if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
1510             (num_v6 > 0)) {
1511                 crit_exit();
1512                 SCTP_INP_WUNLOCK(inp);
1513                 SCTP_ASOC_CREATE_UNLOCK(inp);
1514                 return (EINVAL);
1515         }
1516         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
1517             (num_v4 > 0)) {
1518                 struct in6pcb *inp6;
1519                 inp6 = (struct in6pcb *)inp;
1520                 if (
1521 #if defined(__OpenBSD__)
1522                         (0) /* we always do dual bind */
1523 #elif defined (__NetBSD__)
1524                         (inp6->in6p_flags & IN6P_IPV6_V6ONLY)
1525 #else
1526                         (inp6->inp_flags & IN6P_IPV6_V6ONLY)
1527 #endif
1528                         ) {
1529                         /*
1530                          * if IPV6_V6ONLY flag, ignore connections
1531                          * destined to a v4 addr or v4-mapped addr
1532                          */
1533                         SCTP_INP_WUNLOCK(inp);
1534                         SCTP_ASOC_CREATE_UNLOCK(inp);
1535                         crit_exit();
1536                         return EINVAL;
1537                 }
1538         }
1539 #endif /* INET6 */
1540         if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
1541             SCTP_PCB_FLAGS_UNBOUND) {
1542                 /* Bind a ephemeral port */
1543                 SCTP_INP_WUNLOCK(inp);
1544                 error = sctp_inpcb_bind(so, NULL, p);
1545                 if (error) {
1546                         SCTP_ASOC_CREATE_UNLOCK(inp);
1547                         crit_exit();
1548                         return (error);
1549                 }
1550         } else {
1551                 SCTP_INP_WUNLOCK(inp);
1552         }
1553         /* We are GOOD to go */
1554         stcb = sctp_aloc_assoc(inp, sa, 1, &error, 0);
1555         if (stcb == NULL) {
1556                 /* Gak! no memory */
1557                 SCTP_ASOC_CREATE_UNLOCK(inp);
1558                 crit_exit();
1559                 return (error);
1560         }
1561         /* move to second address */
1562         if (sa->sa_family == AF_INET)
1563                 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in));
1564         else
1565                 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6));
1566
1567         for (i = 1; i < totaddr; i++) {
1568                 if (sa->sa_family == AF_INET) {
1569                         incr = sizeof(struct sockaddr_in);
1570                         if (sctp_add_remote_addr(stcb, sa, 0, 8)) {
1571                                 /* assoc gone no un-lock */
1572                                 sctp_free_assoc(inp, stcb);
1573                                 SCTP_ASOC_CREATE_UNLOCK(inp);
1574                                 crit_exit();
1575                                 return (ENOBUFS);
1576                         }
1577
1578                 } else if (sa->sa_family == AF_INET6) {
1579                         incr = sizeof(struct sockaddr_in6);
1580                         if (sctp_add_remote_addr(stcb, sa, 0, 8)) {
1581                                 /* assoc gone no un-lock */
1582                                 sctp_free_assoc(inp, stcb);
1583                                 SCTP_ASOC_CREATE_UNLOCK(inp);
1584                                 crit_exit();
1585                                 return (ENOBUFS);
1586                         }
1587                 }
1588                 sa = (struct sockaddr *)((caddr_t)sa + incr);
1589         }
1590         stcb->asoc.state = SCTP_STATE_COOKIE_WAIT;
1591         if (delay) {
1592                 /* doing delayed connection */
1593                 stcb->asoc.delayed_connection = 1;
1594                 sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
1595         } else {
1596                 SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
1597                 sctp_send_initiate(inp, stcb);
1598         }
1599         SCTP_TCB_UNLOCK(stcb);
1600         if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
1601                 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
1602                 /* Set the connected flag so we can queue data */
1603                 soisconnecting(so);
1604         }
1605         SCTP_ASOC_CREATE_UNLOCK(inp);
1606         crit_exit();
1607         return error;
1608 }
1609
1610
1611 static int
1612 sctp_optsget(struct socket *so,
1613              int opt,
1614              struct mbuf **mp,
1615 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
1616              struct thread *p
1617 #else
1618              struct proc *p
1619 #endif
1620         )
1621 {
1622         struct sctp_inpcb *inp;
1623         struct mbuf *m;
1624         int error, optval=0;
1625         struct sctp_tcb *stcb = NULL;
1626
1627         inp = (struct sctp_inpcb *)so->so_pcb;
1628         if (inp == 0)
1629                 return EINVAL;
1630         error = 0;
1631
1632         if (mp == NULL) {
1633 #ifdef SCTP_DEBUG
1634                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1635                         kprintf("optsget:MP is NULL EINVAL\n");
1636                 }
1637 #endif /* SCTP_DEBUG */
1638                 return (EINVAL);
1639         }
1640         m = *mp;
1641         if (m == NULL) {
1642                 /* Got to have a mbuf */
1643 #ifdef SCTP_DEBUG
1644                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1645                         kprintf("Huh no mbuf\n");
1646                 }
1647 #endif /* SCTP_DEBUG */
1648                 return (EINVAL);
1649         }
1650 #ifdef SCTP_DEBUG
1651         if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1652                 kprintf("optsget opt:%lxx sz:%u\n", (unsigned long)opt,
1653                        m->m_len);
1654         }
1655 #endif /* SCTP_DEBUG */
1656
1657         switch (opt) {
1658         case SCTP_NODELAY:
1659         case SCTP_AUTOCLOSE:
1660         case SCTP_AUTO_ASCONF:
1661         case SCTP_DISABLE_FRAGMENTS:
1662         case SCTP_I_WANT_MAPPED_V4_ADDR:
1663 #ifdef SCTP_DEBUG
1664                 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1665                         kprintf("other stuff\n");
1666                 }
1667 #endif /* SCTP_DEBUG */
1668                 SCTP_INP_RLOCK(inp);
1669                 switch (opt) {
1670                 case SCTP_DISABLE_FRAGMENTS:
1671                         optval = inp->sctp_flags & SCTP_PCB_FLAGS_NO_FRAGMENT;
1672                         break;
1673                 case SCTP_I_WANT_MAPPED_V4_ADDR:
1674                         optval = inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
1675                         break;
1676                 case SCTP_AUTO_ASCONF:
1677                         optval = inp->sctp_flags & SCTP_PCB_FLAGS_AUTO_ASCONF;
1678                         break;
1679                 case SCTP_NODELAY:
1680                         optval = inp->sctp_flags & SCTP_PCB_FLAGS_NODELAY;
1681                         break;
1682                 case SCTP_AUTOCLOSE:
1683                         if ((inp->sctp_flags & SCTP_PCB_FLAGS_AUTOCLOSE) ==
1684                             SCTP_PCB_FLAGS_AUTOCLOSE)
1685                                 optval = inp->sctp_ep.auto_close_time;
1686                         else
1687                                 optval = 0;
1688                         break;
1689
1690                 default:
1691                         error = ENOPROTOOPT;
1692                 } /* end switch (sopt->sopt_name) */
1693                 if (opt != SCTP_AUTOCLOSE) {
1694                         /* make it an "on/off" value */
1695                         optval = (optval != 0);
1696                 }
1697                 if ((size_t)m->m_len < sizeof(int)) {
1698                         error = EINVAL;
1699                 }
1700                 SCTP_INP_RUNLOCK(inp);
1701                 if (error == 0) {
1702                         /* return the option value */
1703                         *mtod(m, int *) = optval;
1704                         m->m_len = sizeof(optval);
1705                 }
1706                 break;
1707         case SCTP_GET_ASOC_ID_LIST:
1708         {
1709                 struct sctp_assoc_ids *ids;
1710                 int cnt, at;
1711                 u_int16_t orig;
1712
1713                 if ((size_t)m->m_len < sizeof(struct sctp_assoc_ids)) {
1714                         error = EINVAL;
1715                         break;
1716                 }
1717                 ids = mtod(m, struct sctp_assoc_ids *);
1718                 cnt = 0;
1719                 SCTP_INP_RLOCK(inp);
1720                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1721                 if (stcb == NULL) {
1722                 none_out_now:
1723                         ids->asls_numb_present = 0;
1724                         ids->asls_more_to_get = 0;
1725                         SCTP_INP_RUNLOCK(inp);
1726                         break;
1727                 }
1728                 orig = ids->asls_assoc_start;
1729                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1730                 while( orig ) {
1731                         stcb = LIST_NEXT(stcb , sctp_tcblist);
1732                         orig--;
1733                         cnt--;
1734                 }
1735                 if ( stcb == NULL)
1736                         goto none_out_now;
1737
1738                 at = 0;
1739                 ids->asls_numb_present = 0;
1740                 ids->asls_more_to_get = 1;
1741                 while(at < MAX_ASOC_IDS_RET) {
1742                         ids->asls_assoc_id[at] = sctp_get_associd(stcb);
1743                         at++;
1744                         ids->asls_numb_present++;
1745                         stcb = LIST_NEXT(stcb , sctp_tcblist);
1746                         if (stcb == NULL) {
1747                                 ids->asls_more_to_get = 0;
1748                                 break;
1749                         }
1750                 }
1751                 SCTP_INP_RUNLOCK(inp);
1752         }
1753         break;
1754         case SCTP_GET_NONCE_VALUES:
1755         {
1756                 struct sctp_get_nonce_values *gnv;
1757                 if ((size_t)m->m_len < sizeof(struct sctp_get_nonce_values)) {
1758                         error = EINVAL;
1759                         break;
1760                 }
1761                 gnv = mtod(m, struct sctp_get_nonce_values *);
1762                 stcb = sctp_findassociation_ep_asocid(inp, gnv->gn_assoc_id);
1763                 if (stcb == NULL) {
1764                         error = ENOTCONN;
1765                 } else {
1766                         gnv->gn_peers_tag = stcb->asoc.peer_vtag;
1767                         gnv->gn_local_tag = stcb->asoc.my_vtag;
1768                         SCTP_TCB_UNLOCK(stcb);
1769                 }
1770
1771         }
1772         break;
1773         case SCTP_PEER_PUBLIC_KEY:
1774         case SCTP_MY_PUBLIC_KEY:
1775         case SCTP_SET_AUTH_CHUNKS:
1776         case SCTP_SET_AUTH_SECRET:
1777                 /* not supported yet and until we refine the draft */
1778                 error = EOPNOTSUPP;
1779                 break;
1780
1781         case SCTP_DELAYED_ACK_TIME:
1782         {
1783                 int32_t *tm;
1784                 if ((size_t)m->m_len < sizeof(int32_t)) {
1785                         error = EINVAL;
1786                         break;
1787                 }
1788                 tm = mtod(m, int32_t *);
1789
1790                 *tm = TICKS_TO_MSEC(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);
1791         }
1792         break;
1793
1794         case SCTP_GET_SNDBUF_USE:
1795                 if ((size_t)m->m_len < sizeof(struct sctp_sockstat)) {
1796                         error = EINVAL;
1797                 } else {
1798                         struct sctp_sockstat *ss;
1799                         struct sctp_tcb *stcb;
1800                         struct sctp_association *asoc;
1801                         ss = mtod(m, struct sctp_sockstat *);
1802                         stcb = sctp_findassociation_ep_asocid(inp, ss->ss_assoc_id);
1803                         if (stcb == NULL) {
1804                                 error = ENOTCONN;
1805                         } else {
1806                                 asoc = &stcb->asoc;
1807                                 ss->ss_total_sndbuf = (u_int32_t)asoc->total_output_queue_size;
1808                                 ss->ss_total_mbuf_sndbuf = (u_int32_t)asoc->total_output_mbuf_queue_size;
1809                                 ss->ss_total_recv_buf = (u_int32_t)(asoc->size_on_delivery_queue +
1810                                                                     asoc->size_on_reasm_queue +
1811                                                                     asoc->size_on_all_streams);
1812                                 SCTP_TCB_UNLOCK(stcb);
1813                                 error = 0;
1814                                 m->m_len = sizeof(struct sctp_sockstat);
1815                         }
1816                 }
1817                 break;
1818         case SCTP_MAXBURST:
1819         {
1820                 u_int8_t *burst;
1821                 burst = mtod(m, u_int8_t *);
1822                 SCTP_INP_RLOCK(inp);
1823                 *burst = inp->sctp_ep.max_burst;
1824                 SCTP_INP_RUNLOCK(inp);
1825                 m->m_len = sizeof(u_int8_t);
1826         }
1827         break;
1828         case SCTP_MAXSEG:
1829         {
1830                 u_int32_t *segsize;
1831                 sctp_assoc_t *assoc_id;
1832                 int ovh;
1833
1834                 if ((size_t)m->m_len < sizeof(u_int32_t)) {
1835                         error = EINVAL;
1836                         break;
1837                 }
1838                 if ((size_t)m->m_len < sizeof(sctp_assoc_t)) {
1839                         error = EINVAL;
1840                         break;
1841                 }
1842                 assoc_id = mtod(m, sctp_assoc_t *);
1843                 segsize = mtod(m, u_int32_t *);
1844                 m->m_len = sizeof(u_int32_t);
1845
1846                 if (((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
1847                      (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) ||
1848                     (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
1849                         struct sctp_tcb *stcb;
1850                         SCTP_INP_RLOCK(inp);
1851                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
1852                         if (stcb) {
1853                                 SCTP_TCB_LOCK(stcb);
1854                                 SCTP_INP_RUNLOCK(inp);
1855                                 *segsize = sctp_get_frag_point(stcb, &stcb->asoc);
1856                                 SCTP_TCB_UNLOCK(stcb);
1857                         } else {
1858                                 SCTP_INP_RUNLOCK(inp);
1859                                 goto skipit;
1860                         }
1861                 } else {
1862                         stcb = sctp_findassociation_ep_asocid(inp, *assoc_id);
1863                         if (stcb) {
1864                                 *segsize = sctp_get_frag_point(stcb, &stcb->asoc);
1865                                 SCTP_TCB_UNLOCK(stcb);
1866                                 break;
1867                         }
1868                 skipit:
1869                         /* default is to get the max, if I
1870                          * can't calculate from an existing association.
1871                          */
1872                         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
1873                                 ovh = SCTP_MED_OVERHEAD;
1874                         } else {
1875                                 ovh = SCTP_MED_V4_OVERHEAD;
1876                         }
1877                         *segsize = inp->sctp_frag_point - ovh;
1878                 }
1879         }
1880         break;
1881
1882         case SCTP_SET_DEBUG_LEVEL:
1883 #ifdef SCTP_DEBUG
1884         {
1885                 u_int32_t *level;
1886                 if ((size_t)m->m_len < sizeof(u_int32_t)) {
1887                         error = EINVAL;
1888                         break;
1889                 }
1890                 level = mtod(m, u_int32_t *);
1891                 error = 0;
1892                 *level = sctp_debug_on;
1893                 m->m_len = sizeof(u_int32_t);
1894                 kprintf("Returning DEBUG LEVEL %x is set\n",
1895                        (u_int)sctp_debug_on);
1896         }
1897 #else /* SCTP_DEBUG */
1898         error = EOPNOTSUPP;
1899 #endif
1900         break;
1901         case SCTP_GET_STAT_LOG:
1902 #ifdef SCTP_STAT_LOGGING
1903                 error = sctp_fill_stat_log(m);
1904 #else /* SCTP_DEBUG */
1905                 error = EOPNOTSUPP;
1906 #endif
1907                 break;
1908         case SCTP_GET_PEGS:
1909         {
1910                 u_int32_t *pt;
1911                 if ((size_t)m->m_len < sizeof(sctp_pegs)) {
1912                         error = EINVAL;
1913                         break;
1914                 }
1915                 pt = mtod(m, u_int32_t *);
1916                 memcpy(pt, sctp_pegs, sizeof(sctp_pegs));
1917                 m->m_len = sizeof(sctp_pegs);
1918         }
1919         break;
1920         case SCTP_EVENTS:
1921         {
1922                 struct sctp_event_subscribe *events;
1923 #ifdef SCTP_DEBUG
1924                 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1925                         kprintf("get events\n");
1926                 }
1927 #endif /* SCTP_DEBUG */
1928                 if ((size_t)m->m_len < sizeof(struct sctp_event_subscribe)) {
1929 #ifdef SCTP_DEBUG
1930                         if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1931                                 kprintf("M->M_LEN is %d not %d\n",
1932                                        (int)m->m_len,
1933                                        (int)sizeof(struct sctp_event_subscribe));
1934                         }
1935 #endif /* SCTP_DEBUG */
1936                         error = EINVAL;
1937                         break;
1938                 }
1939                 events = mtod(m, struct sctp_event_subscribe *);
1940                 memset(events, 0, sizeof(events));
1941                 SCTP_INP_RLOCK(inp);
1942                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVDATAIOEVNT)
1943                         events->sctp_data_io_event = 1;
1944
1945                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVASSOCEVNT)
1946                         events->sctp_association_event = 1;
1947
1948                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVPADDREVNT)
1949                         events->sctp_address_event = 1;
1950
1951                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVSENDFAILEVNT)
1952                         events->sctp_send_failure_event = 1;
1953
1954                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVPEERERR)
1955                         events->sctp_peer_error_event = 1;
1956
1957                 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT)
1958                         events->sctp_shutdown_event = 1;
1959
1960                 if (inp->sctp_flags & SCTP_PCB_FLAGS_PDAPIEVNT)
1961                         events->sctp_partial_delivery_event = 1;
1962
1963                 if (inp->sctp_flags & SCTP_PCB_FLAGS_ADAPTIONEVNT)
1964                         events->sctp_adaption_layer_event = 1;
1965
1966                 if (inp->sctp_flags & SCTP_PCB_FLAGS_STREAM_RESETEVNT)
1967                         events->sctp_stream_reset_events = 1;
1968                 SCTP_INP_RUNLOCK(inp);
1969                 m->m_len = sizeof(struct sctp_event_subscribe);
1970
1971         }
1972         break;
1973
1974         case SCTP_ADAPTION_LAYER:
1975                 if ((size_t)m->m_len < sizeof(int)) {
1976                         error = EINVAL;
1977                         break;
1978                 }
1979 #ifdef SCTP_DEBUG
1980                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1981                         kprintf("getadaption ind\n");
1982                 }
1983 #endif /* SCTP_DEBUG */
1984                 SCTP_INP_RLOCK(inp);
1985                 *mtod(m, int *) = inp->sctp_ep.adaption_layer_indicator;
1986                 SCTP_INP_RUNLOCK(inp);
1987                 m->m_len = sizeof(int);
1988                 break;
1989         case SCTP_SET_INITIAL_DBG_SEQ:
1990                 if ((size_t)m->m_len < sizeof(int)) {
1991                         error = EINVAL;
1992                         break;
1993                 }
1994 #ifdef SCTP_DEBUG
1995                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1996                         kprintf("get initial dbg seq\n");
1997                 }
1998 #endif /* SCTP_DEBUG */
1999                 SCTP_INP_RLOCK(inp);
2000                 *mtod(m, int *) = inp->sctp_ep.initial_sequence_debug;
2001                 SCTP_INP_RUNLOCK(inp);
2002                 m->m_len = sizeof(int);
2003                 break;
2004         case SCTP_GET_LOCAL_ADDR_SIZE:
2005                 if ((size_t)m->m_len < sizeof(int)) {
2006                         error = EINVAL;
2007                         break;
2008                 }
2009 #ifdef SCTP_DEBUG
2010                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2011                         kprintf("get local sizes\n");
2012                 }
2013 #endif /* SCTP_DEBUG */
2014                 SCTP_INP_RLOCK(inp);
2015                 *mtod(m, int *) = sctp_count_max_addresses(inp);
2016                 SCTP_INP_RUNLOCK(inp);
2017                 m->m_len = sizeof(int);
2018                 break;
2019         case SCTP_GET_REMOTE_ADDR_SIZE:
2020         {
2021                 sctp_assoc_t *assoc_id;
2022                 u_int32_t *val, sz;
2023                 struct sctp_nets *net;
2024 #ifdef SCTP_DEBUG
2025                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2026                         kprintf("get remote size\n");
2027                 }
2028 #endif /* SCTP_DEBUG */
2029                 if ((size_t)m->m_len < sizeof(sctp_assoc_t)) {
2030 #ifdef SCTP_DEBUG
2031                         kprintf("m->m_len:%d not %d\n",
2032                                m->m_len, sizeof(sctp_assoc_t));
2033 #endif /* SCTP_DEBUG */
2034                         error = EINVAL;
2035                         break;
2036                 }
2037                 stcb = NULL;
2038                 val = mtod(m, u_int32_t *);
2039                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2040                         SCTP_INP_RLOCK(inp);
2041                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2042                         if (stcb)
2043                                 SCTP_TCB_LOCK(stcb);
2044                         SCTP_INP_RUNLOCK(inp);
2045                 }
2046                 if (stcb == NULL) {
2047                         assoc_id = mtod(m, sctp_assoc_t *);
2048                         stcb = sctp_findassociation_ep_asocid(inp, *assoc_id);
2049                 }
2050
2051                 if (stcb == NULL) {
2052                         error = EINVAL;
2053                         break;
2054                 }
2055                 *val = 0;
2056                 sz = 0;
2057                 /* Count the sizes */
2058                 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2059                         if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) ||
2060                             (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET6)) {
2061                                 sz += sizeof(struct sockaddr_in6);
2062                         } else if (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET) {
2063                                 sz += sizeof(struct sockaddr_in);
2064                         } else {
2065                                 /* huh */
2066                                 break;
2067                         }
2068                 }
2069                 SCTP_TCB_UNLOCK(stcb);
2070                 *val = sz;
2071                 m->m_len = sizeof(u_int32_t);
2072         }
2073         break;
2074         case SCTP_GET_PEER_ADDRESSES:
2075                 /*
2076                  * Get the address information, an array
2077                  * is passed in to fill up we pack it.
2078                  */
2079         {
2080                 int cpsz, left;
2081                 struct sockaddr_storage *sas;
2082                 struct sctp_nets *net;
2083                 struct sctp_getaddresses *saddr;
2084 #ifdef SCTP_DEBUG
2085                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2086                         kprintf("get peer addresses\n");
2087                 }
2088 #endif /* SCTP_DEBUG */
2089                 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
2090                         error = EINVAL;
2091                         break;
2092                 }
2093                 left = m->m_len - sizeof(struct sctp_getaddresses);
2094                 saddr = mtod(m, struct sctp_getaddresses *);
2095                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2096                         SCTP_INP_RLOCK(inp);
2097                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2098                         if (stcb)
2099                                 SCTP_TCB_LOCK(stcb);
2100                         SCTP_INP_RUNLOCK(inp);
2101                 } else
2102                         stcb = sctp_findassociation_ep_asocid(inp,
2103                                                               saddr->sget_assoc_id);
2104                 if (stcb == NULL) {
2105                         error = ENOENT;
2106                         break;
2107                 }
2108                 m->m_len = sizeof(struct sctp_getaddresses);
2109                 sas = (struct sockaddr_storage *)&saddr->addr[0];
2110
2111                 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2112                         if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) ||
2113                             (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET6)) {
2114                                 cpsz = sizeof(struct sockaddr_in6);
2115                         } else if (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET) {
2116                                 cpsz = sizeof(struct sockaddr_in);
2117                         } else {
2118                                 /* huh */
2119                                 break;
2120                         }
2121                         if (left < cpsz) {
2122                                 /* not enough room. */
2123 #ifdef SCTP_DEBUG
2124                                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2125                                         kprintf("Out of room\n");
2126                                 }
2127 #endif /* SCTP_DEBUG */
2128                                 break;
2129                         }
2130                         if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) &&
2131                             (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET)) {
2132                                 /* Must map the address */
2133                                 in6_sin_2_v4mapsin6((struct sockaddr_in *)&net->ro._l_addr,
2134                                                     (struct sockaddr_in6 *)sas);
2135                         } else {
2136                                 memcpy(sas, &net->ro._l_addr, cpsz);
2137                         }
2138                         ((struct sockaddr_in *)sas)->sin_port = stcb->rport;
2139
2140                         sas = (struct sockaddr_storage *)((caddr_t)sas + cpsz);
2141                         left -= cpsz;
2142                         m->m_len += cpsz;
2143 #ifdef SCTP_DEBUG
2144                         if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
2145                                 kprintf("left now:%d mlen:%d\n",
2146                                        left, m->m_len);
2147                         }
2148 #endif /* SCTP_DEBUG */
2149                 }
2150                 SCTP_TCB_UNLOCK(stcb);
2151         }
2152 #ifdef SCTP_DEBUG
2153         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2154                 kprintf("All done\n");
2155         }
2156 #endif /* SCTP_DEBUG */
2157         break;
2158         case SCTP_GET_LOCAL_ADDRESSES:
2159         {
2160                 int limit, actual;
2161                 struct sockaddr_storage *sas;
2162                 struct sctp_getaddresses *saddr;
2163 #ifdef SCTP_DEBUG
2164                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2165                         kprintf("get local addresses\n");
2166                 }
2167 #endif /* SCTP_DEBUG */
2168                 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
2169                         error = EINVAL;
2170                         break;
2171                 }
2172                 saddr = mtod(m, struct sctp_getaddresses *);
2173
2174                 if (saddr->sget_assoc_id) {
2175                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2176                                 SCTP_INP_RLOCK(inp);
2177                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2178                                 if (stcb)
2179                                         SCTP_TCB_LOCK(stcb);
2180                                 SCTP_INP_RUNLOCK(inp);
2181                         } else
2182                                 stcb = sctp_findassociation_ep_asocid(inp, saddr->sget_assoc_id);
2183
2184                 } else {
2185                         stcb = NULL;
2186                 }
2187                 /*
2188                  * assure that the TCP model does not need a assoc id
2189                  * once connected.
2190                  */
2191                 if ( (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) &&
2192                      (stcb == NULL) ) {
2193                         SCTP_INP_RLOCK(inp);
2194                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2195                         if (stcb)
2196                                 SCTP_TCB_LOCK(stcb);
2197                         SCTP_INP_RUNLOCK(inp);
2198                 }
2199                 sas = (struct sockaddr_storage *)&saddr->addr[0];
2200                 limit = m->m_len - sizeof(sctp_assoc_t);
2201                 actual = sctp_fill_up_addresses(inp, stcb, limit, sas);
2202                 SCTP_TCB_UNLOCK(stcb);
2203                 m->m_len = sizeof(struct sockaddr_storage) + actual;
2204         }
2205         break;
2206         case SCTP_PEER_ADDR_PARAMS:
2207         {
2208                 struct sctp_paddrparams *paddrp;
2209                 struct sctp_nets *net;
2210
2211 #ifdef SCTP_DEBUG
2212                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2213                         kprintf("Getting peer_addr_params\n");
2214                 }
2215 #endif /* SCTP_DEBUG */
2216                 if ((size_t)m->m_len < sizeof(struct sctp_paddrparams)) {
2217 #ifdef SCTP_DEBUG
2218                         if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
2219                                 kprintf("Hmm m->m_len:%d is to small\n",
2220                                        m->m_len);
2221                         }
2222 #endif /* SCTP_DEBUG */
2223                         error = EINVAL;
2224                         break;
2225                 }
2226                 paddrp = mtod(m, struct sctp_paddrparams *);
2227
2228                 net = NULL;
2229                 if (paddrp->spp_assoc_id) {
2230 #ifdef SCTP_DEBUG
2231                         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2232                                 kprintf("In spp_assoc_id find type\n");
2233                         }
2234 #endif /* SCTP_DEBUG */
2235                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2236                                 SCTP_INP_RLOCK(inp);
2237                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2238                                 if (stcb) {
2239                                         SCTP_TCB_LOCK(stcb);
2240                                         net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
2241                                 }
2242                                 SCTP_INP_RLOCK(inp);
2243                         } else {
2244                                 stcb = sctp_findassociation_ep_asocid(inp, paddrp->spp_assoc_id);
2245                         }
2246                         if (stcb == NULL) {
2247                                 error = ENOENT;
2248                                 break;
2249                         }
2250                 }
2251                 if (    (stcb == NULL) &&
2252                         ((((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET) ||
2253                          (((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET6))) {
2254                         /* Lookup via address */
2255 #ifdef SCTP_DEBUG
2256                         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2257                                 kprintf("Ok we need to lookup a param\n");
2258                         }
2259 #endif /* SCTP_DEBUG */
2260                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2261                                 SCTP_INP_RLOCK(inp);
2262                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2263                                 if (stcb) {
2264                                         SCTP_TCB_LOCK(stcb);
2265                                         net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
2266                                 }
2267                                 SCTP_INP_RUNLOCK(inp);
2268                         } else {
2269                                 SCTP_INP_WLOCK(inp);
2270                                 SCTP_INP_INCR_REF(inp);
2271                                 SCTP_INP_WUNLOCK(inp);
2272                                 stcb = sctp_findassociation_ep_addr(&inp,
2273                                                                     (struct sockaddr *)&paddrp->spp_address,
2274                                                                     &net, NULL, NULL);
2275                                 if (stcb == NULL) {
2276                                         SCTP_INP_WLOCK(inp);
2277                                         SCTP_INP_DECR_REF(inp);
2278                                         SCTP_INP_WUNLOCK(inp);
2279                                 }
2280                         }
2281
2282                         if (stcb == NULL) {
2283                                 error = ENOENT;
2284                                 break;
2285                         }
2286                 } else {
2287                         /* Effects the Endpoint */
2288 #ifdef SCTP_DEBUG
2289                         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2290                                 kprintf("User wants EP level info\n");
2291                         }
2292 #endif /* SCTP_DEBUG */
2293                         stcb = NULL;
2294                 }
2295                 if (stcb) {
2296                         /* Applys to the specific association */
2297 #ifdef SCTP_DEBUG
2298                         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2299                                 kprintf("In TCB side\n");
2300                         }
2301 #endif /* SCTP_DEBUG */
2302                         if (net) {
2303                                 paddrp->spp_pathmaxrxt = net->failure_threshold;
2304                         } else {
2305                                 /* No destination so return default value */
2306                                 paddrp->spp_pathmaxrxt = stcb->asoc.def_net_failure;
2307                         }
2308                         paddrp->spp_hbinterval = stcb->asoc.heart_beat_delay;
2309                         paddrp->spp_assoc_id = sctp_get_associd(stcb);
2310                         SCTP_TCB_UNLOCK(stcb);
2311                 } else {
2312                         /* Use endpoint defaults */
2313                         SCTP_INP_RLOCK(inp);
2314 #ifdef SCTP_DEBUG
2315                         if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2316                                 kprintf("In EP levle info\n");
2317                         }
2318 #endif /* SCTP_DEBUG */
2319                         paddrp->spp_pathmaxrxt = inp->sctp_ep.def_net_failure;
2320                         paddrp->spp_hbinterval = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT];
2321                         paddrp->spp_assoc_id = (sctp_assoc_t)0;
2322                         SCTP_INP_RUNLOCK(inp);
2323                 }
2324                 m->m_len = sizeof(struct sctp_paddrparams);
2325         }
2326         break;
2327         case SCTP_GET_PEER_ADDR_INFO:
2328         {
2329                 struct sctp_paddrinfo *paddri;
2330                 struct sctp_nets *net;
2331 #ifdef SCTP_DEBUG
2332                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2333                         kprintf("GetPEER ADDR_INFO\n");
2334                 }
2335 #endif /* SCTP_DEBUG */
2336                 if ((size_t)m->m_len < sizeof(struct sctp_paddrinfo)) {
2337                         error = EINVAL;
2338                         break;
2339                 }
2340                 paddri = mtod(m, struct sctp_paddrinfo *);
2341                 net = NULL;
2342                 if ((((struct sockaddr *)&paddri->spinfo_address)->sa_family == AF_INET) ||
2343                     (((struct sockaddr *)&paddri->spinfo_address)->sa_family == AF_INET6)) {
2344                         /* Lookup via address */
2345                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2346                                 SCTP_INP_RLOCK(inp);
2347                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2348                                 if (stcb) {
2349                                         SCTP_TCB_LOCK(stcb);
2350                                         net = sctp_findnet(stcb,
2351                                                             (struct sockaddr *)&paddri->spinfo_address);
2352                                 }
2353                                 SCTP_INP_RUNLOCK(inp);
2354                         } else {
2355                                 SCTP_INP_WLOCK(inp);
2356                                 SCTP_INP_INCR_REF(inp);
2357                                 SCTP_INP_WUNLOCK(inp);
2358                                 stcb = sctp_findassociation_ep_addr(&inp,
2359                                     (struct sockaddr *)&paddri->spinfo_address,
2360                                     &net, NULL, NULL);
2361                                 if (stcb == NULL) {
2362                                         SCTP_INP_WLOCK(inp);
2363                                         SCTP_INP_DECR_REF(inp);
2364                                         SCTP_INP_WUNLOCK(inp);
2365                                 }
2366                         }
2367
2368                 } else {
2369                         stcb = NULL;
2370                 }
2371                 if ((stcb == NULL) || (net == NULL)) {
2372                         error = ENOENT;
2373                         break;
2374                 }
2375                 m->m_len = sizeof(struct sctp_paddrinfo);
2376                 paddri->spinfo_state = net->dest_state & (SCTP_REACHABLE_MASK|SCTP_ADDR_NOHB);
2377                 paddri->spinfo_cwnd = net->cwnd;
2378                 paddri->spinfo_srtt = ((net->lastsa >> 2) + net->lastsv) >> 1;
2379                 paddri->spinfo_rto = net->RTO;
2380                 paddri->spinfo_assoc_id = sctp_get_associd(stcb);
2381                 SCTP_TCB_UNLOCK(stcb);
2382         }
2383         break;
2384         case SCTP_PCB_STATUS:
2385         {
2386                 struct sctp_pcbinfo *spcb;
2387 #ifdef SCTP_DEBUG
2388                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2389                         kprintf("PCB status\n");
2390                 }
2391 #endif /* SCTP_DEBUG */
2392                 if ((size_t)m->m_len < sizeof(struct sctp_pcbinfo)) {
2393                         error = EINVAL;
2394                         break;
2395                 }
2396                 spcb = mtod(m, struct sctp_pcbinfo *);
2397                 sctp_fill_pcbinfo(spcb);
2398                 m->m_len = sizeof(struct sctp_pcbinfo);
2399         }
2400         break;
2401         case SCTP_STATUS:
2402         {
2403                 struct sctp_nets *net;
2404                 struct sctp_status *sstat;
2405 #ifdef SCTP_DEBUG
2406                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2407                         kprintf("SCTP status\n");
2408                 }
2409 #endif /* SCTP_DEBUG */
2410
2411                 if ((size_t)m->m_len < sizeof(struct sctp_status)) {
2412                         error = EINVAL;
2413                         break;
2414                 }
2415                 sstat = mtod(m, struct sctp_status *);
2416
2417                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2418                         SCTP_INP_RLOCK(inp);
2419                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2420                         if (stcb)
2421                                 SCTP_TCB_LOCK(stcb);
2422                         SCTP_INP_RUNLOCK(inp);
2423                 } else
2424                         stcb = sctp_findassociation_ep_asocid(inp, sstat->sstat_assoc_id);
2425
2426                 if (stcb == NULL) {
2427                         error = EINVAL;
2428                         break;
2429                 }
2430                 /*
2431                  * I think passing the state is fine since
2432                  * sctp_constants.h will be available to the user
2433                  * land.
2434                  */
2435                 sstat->sstat_state = stcb->asoc.state;
2436                 sstat->sstat_rwnd = stcb->asoc.peers_rwnd;
2437                 sstat->sstat_unackdata = stcb->asoc.sent_queue_cnt;
2438                 /*
2439                  * We can't include chunks that have been passed
2440                  * to the socket layer. Only things in queue.
2441                  */
2442                 sstat->sstat_penddata = (stcb->asoc.cnt_on_delivery_queue +
2443                                          stcb->asoc.cnt_on_reasm_queue +
2444                                          stcb->asoc.cnt_on_all_streams);
2445
2446
2447                 sstat->sstat_instrms = stcb->asoc.streamincnt;
2448                 sstat->sstat_outstrms = stcb->asoc.streamoutcnt;
2449                 sstat->sstat_fragmentation_point = sctp_get_frag_point(stcb, &stcb->asoc);
2450                 memcpy(&sstat->sstat_primary.spinfo_address,
2451                        &stcb->asoc.primary_destination->ro._l_addr,
2452                        ((struct sockaddr *)(&stcb->asoc.primary_destination->ro._l_addr))->sa_len);
2453                 net = stcb->asoc.primary_destination;
2454                 ((struct sockaddr_in *)&sstat->sstat_primary.spinfo_address)->sin_port = stcb->rport;
2455                 /*
2456                  * Again the user can get info from sctp_constants.h
2457                  * for what the state of the network is.
2458                  */
2459                 sstat->sstat_primary.spinfo_state = net->dest_state & SCTP_REACHABLE_MASK;
2460                 sstat->sstat_primary.spinfo_cwnd = net->cwnd;
2461                 sstat->sstat_primary.spinfo_srtt = net->lastsa;
2462                 sstat->sstat_primary.spinfo_rto = net->RTO;
2463                 sstat->sstat_primary.spinfo_mtu = net->mtu;
2464                 sstat->sstat_primary.spinfo_assoc_id = sctp_get_associd(stcb);
2465                 SCTP_TCB_UNLOCK(stcb);
2466                 m->m_len = sizeof(*sstat);
2467         }
2468         break;
2469         case SCTP_RTOINFO:
2470         {
2471                 struct sctp_rtoinfo *srto;
2472 #ifdef SCTP_DEBUG
2473                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2474                         kprintf("RTO Info\n");
2475                 }
2476 #endif /* SCTP_DEBUG */
2477                 if ((size_t)m->m_len < sizeof(struct sctp_rtoinfo)) {
2478                         error = EINVAL;
2479                         break;
2480                 }
2481                 srto = mtod(m, struct sctp_rtoinfo *);
2482                 if (srto->srto_assoc_id == 0) {
2483                         /* Endpoint only please */
2484                         SCTP_INP_RLOCK(inp);
2485                         srto->srto_initial = inp->sctp_ep.initial_rto;
2486                         srto->srto_max = inp->sctp_ep.sctp_maxrto;
2487                         srto->srto_min = inp->sctp_ep.sctp_minrto;
2488                         SCTP_INP_RUNLOCK(inp);
2489                         break;
2490                 }
2491                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2492                         SCTP_INP_RLOCK(inp);
2493                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2494                         if (stcb)
2495                                 SCTP_TCB_LOCK(stcb);
2496                         SCTP_INP_RUNLOCK(inp);
2497                 } else
2498                         stcb = sctp_findassociation_ep_asocid(inp, srto->srto_assoc_id);
2499
2500                 if (stcb == NULL) {
2501                         error = EINVAL;
2502                         break;
2503                 }
2504                 srto->srto_initial = stcb->asoc.initial_rto;
2505                 srto->srto_max = stcb->asoc.maxrto;
2506                 srto->srto_min = stcb->asoc.minrto;
2507                 SCTP_TCB_UNLOCK(stcb);
2508                 m->m_len = sizeof(*srto);
2509         }
2510         break;
2511         case SCTP_ASSOCINFO:
2512         {
2513                 struct sctp_assocparams *sasoc;
2514 #ifdef SCTP_DEBUG
2515                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2516                         kprintf("Associnfo\n");
2517                 }
2518 #endif /* SCTP_DEBUG */
2519                 if ((size_t)m->m_len < sizeof(struct sctp_assocparams)) {
2520                         error = EINVAL;
2521                         break;
2522                 }
2523                 sasoc = mtod(m, struct sctp_assocparams *);
2524                 stcb = NULL;
2525
2526                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2527                         SCTP_INP_RLOCK(inp);
2528                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2529                         if (stcb)
2530                                 SCTP_TCB_LOCK(stcb);
2531                         SCTP_INP_RUNLOCK(inp);
2532                 }
2533                 if ((sasoc->sasoc_assoc_id) && (stcb == NULL)) {
2534                         stcb = sctp_findassociation_ep_asocid(inp,
2535                                                              sasoc->sasoc_assoc_id);
2536                         if (stcb == NULL) {
2537                                 error = ENOENT;
2538                                 break;
2539                         }
2540                 } else {
2541                         stcb = NULL;
2542                 }
2543
2544                 if (stcb) {
2545                         sasoc->sasoc_asocmaxrxt = stcb->asoc.max_send_times;
2546                         sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
2547                         sasoc->sasoc_peer_rwnd = stcb->asoc.peers_rwnd;
2548                         sasoc->sasoc_local_rwnd = stcb->asoc.my_rwnd;
2549                         sasoc->sasoc_cookie_life = stcb->asoc.cookie_life;
2550                         SCTP_TCB_UNLOCK(stcb);
2551                 } else {
2552                         SCTP_INP_RLOCK(inp);
2553                         sasoc->sasoc_asocmaxrxt = inp->sctp_ep.max_send_times;
2554                         sasoc->sasoc_number_peer_destinations = 0;
2555                         sasoc->sasoc_peer_rwnd = 0;
2556                         sasoc->sasoc_local_rwnd = sbspace(&inp->sctp_socket->so_rcv);
2557                         sasoc->sasoc_cookie_life = inp->sctp_ep.def_cookie_life;
2558                         SCTP_INP_RUNLOCK(inp);
2559                 }
2560                 m->m_len = sizeof(*sasoc);
2561         }
2562         break;
2563         case SCTP_DEFAULT_SEND_PARAM:
2564         {
2565                 struct sctp_sndrcvinfo *s_info;
2566
2567                 if (m->m_len != sizeof(struct sctp_sndrcvinfo)) {
2568                         error = EINVAL;
2569                         break;
2570                 }
2571                 s_info = mtod(m, struct sctp_sndrcvinfo *);
2572                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2573                         SCTP_INP_RLOCK(inp);
2574                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2575                         if (stcb)
2576                                 SCTP_TCB_LOCK(stcb);
2577                         SCTP_INP_RUNLOCK(inp);
2578                 } else
2579                         stcb = sctp_findassociation_ep_asocid(inp, s_info->sinfo_assoc_id);
2580
2581                 if (stcb == NULL) {
2582                         error = ENOENT;
2583                         break;
2584                 }
2585                 /* Copy it out */
2586                 *s_info = stcb->asoc.def_send;
2587                 SCTP_TCB_UNLOCK(stcb);
2588                 m->m_len = sizeof(*s_info);
2589         }
2590         case SCTP_INITMSG:
2591         {
2592                 struct sctp_initmsg *sinit;
2593 #ifdef SCTP_DEBUG
2594                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2595                         kprintf("initmsg\n");
2596                 }
2597 #endif /* SCTP_DEBUG */
2598                 if ((size_t)m->m_len < sizeof(struct sctp_initmsg)) {
2599                         error = EINVAL;
2600                         break;
2601                 }
2602                 sinit = mtod(m, struct sctp_initmsg *);
2603                 SCTP_INP_RLOCK(inp);
2604                 sinit->sinit_num_ostreams = inp->sctp_ep.pre_open_stream_count;
2605                 sinit->sinit_max_instreams = inp->sctp_ep.max_open_streams_intome;
2606                 sinit->sinit_max_attempts = inp->sctp_ep.max_init_times;
2607                 sinit->sinit_max_init_timeo = inp->sctp_ep.initial_init_rto_max;
2608                 SCTP_INP_RUNLOCK(inp);
2609                 m->m_len = sizeof(*sinit);
2610         }
2611         break;
2612         case SCTP_PRIMARY_ADDR:
2613                 /* we allow a "get" operation on this */
2614         {
2615                 struct sctp_setprim *ssp;
2616
2617 #ifdef SCTP_DEBUG
2618                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2619                         kprintf("setprimary\n");
2620                 }
2621 #endif /* SCTP_DEBUG */
2622                 if ((size_t)m->m_len < sizeof(struct sctp_setprim)) {
2623                         error = EINVAL;
2624                         break;
2625                 }
2626                 ssp = mtod(m, struct sctp_setprim *);
2627                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2628                         SCTP_INP_RLOCK(inp);
2629                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2630                         if (stcb)
2631                                 SCTP_TCB_LOCK(stcb);
2632                         SCTP_INP_RUNLOCK(inp);
2633                 } else {
2634                         stcb = sctp_findassociation_ep_asocid(inp, ssp->ssp_assoc_id);
2635                         if (stcb == NULL) {
2636                                 /* one last shot, try it by the address in */
2637                                 struct sctp_nets *net;
2638
2639                                 SCTP_INP_WLOCK(inp);
2640                                 SCTP_INP_INCR_REF(inp);
2641                                 SCTP_INP_WUNLOCK(inp);
2642                                 stcb = sctp_findassociation_ep_addr(&inp,
2643                                                             (struct sockaddr *)&ssp->ssp_addr,
2644                                                             &net, NULL, NULL);
2645                                 if (stcb == NULL) {
2646                                         SCTP_INP_WLOCK(inp);
2647                                         SCTP_INP_DECR_REF(inp);
2648                                         SCTP_INP_WUNLOCK(inp);
2649                                 }
2650                         }
2651                         if (stcb == NULL) {
2652                                 error = EINVAL;
2653                                 break;
2654                         }
2655                 }
2656                 /* simply copy out the sockaddr_storage... */
2657                 memcpy(&ssp->ssp_addr,
2658                        &stcb->asoc.primary_destination->ro._l_addr,
2659                        ((struct sockaddr *)&stcb->asoc.primary_destination->ro._l_addr)->sa_len);
2660                 SCTP_TCB_UNLOCK(stcb);
2661                 m->m_len = sizeof(*ssp);
2662         }
2663         break;
2664         default:
2665                 error = ENOPROTOOPT;
2666                 m->m_len = 0;
2667                 break;
2668         } /* end switch (sopt->sopt_name) */
2669         return (error);
2670 }
2671
2672 static int
2673 sctp_optsset(struct socket *so,
2674              int opt,
2675              struct mbuf **mp,
2676 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
2677              struct thread *p
2678 #else
2679              struct proc *p
2680 #endif
2681         )
2682 {
2683         int error, *mopt, set_opt;
2684         struct mbuf *m;
2685         struct sctp_tcb *stcb = NULL;
2686         struct sctp_inpcb *inp;
2687
2688         if (mp == NULL) {
2689 #ifdef SCTP_DEBUG
2690                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2691                         kprintf("optsset:MP is NULL EINVAL\n");
2692                 }
2693 #endif /* SCTP_DEBUG */
2694                 return (EINVAL);
2695         }
2696         m = *mp;
2697         if (m == NULL)
2698                 return (EINVAL);
2699
2700         inp = (struct sctp_inpcb *)so->so_pcb;
2701         if (inp == 0)
2702                 return EINVAL;
2703
2704         error = 0;
2705         switch (opt) {
2706         case SCTP_NODELAY:
2707         case SCTP_AUTOCLOSE:
2708         case SCTP_AUTO_ASCONF:
2709         case SCTP_DISABLE_FRAGMENTS:
2710         case SCTP_I_WANT_MAPPED_V4_ADDR:
2711                 /* copy in the option value */
2712                 if ((size_t)m->m_len < sizeof(int)) {
2713                         error = EINVAL;
2714                         break;
2715                 }
2716                 mopt = mtod(m, int *);
2717                 set_opt = 0;
2718                 if (error)
2719                         break;
2720                 switch (opt) {
2721                 case SCTP_DISABLE_FRAGMENTS:
2722                         set_opt = SCTP_PCB_FLAGS_NO_FRAGMENT;
2723                         break;
2724                 case SCTP_AUTO_ASCONF:
2725                         set_opt = SCTP_PCB_FLAGS_AUTO_ASCONF;
2726                         break;
2727
2728                 case SCTP_I_WANT_MAPPED_V4_ADDR:
2729                         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
2730                                 set_opt = SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
2731                         } else {
2732                                 return (EINVAL);
2733                         }
2734                         break;
2735                 case SCTP_NODELAY:
2736                         set_opt = SCTP_PCB_FLAGS_NODELAY;
2737                         break;
2738                 case SCTP_AUTOCLOSE:
2739                         set_opt = SCTP_PCB_FLAGS_AUTOCLOSE;
2740                         /*
2741                          * The value is in ticks.
2742                          * Note this does not effect old associations, only
2743                          * new ones.
2744                          */
2745                         inp->sctp_ep.auto_close_time = (*mopt * hz);
2746                         break;
2747                 }
2748                 SCTP_INP_WLOCK(inp);
2749                 if (*mopt != 0) {
2750                         inp->sctp_flags |= set_opt;
2751                 } else {
2752                         inp->sctp_flags &= ~set_opt;
2753                 }
2754                 SCTP_INP_WUNLOCK(inp);
2755                 break;
2756         case SCTP_MY_PUBLIC_KEY:    /* set my public key */
2757         case SCTP_SET_AUTH_CHUNKS:  /* set the authenticated chunks required */
2758         case SCTP_SET_AUTH_SECRET:  /* set the actual secret for the endpoint */
2759                 /* not supported yet and until we refine the draft */
2760                 error = EOPNOTSUPP;
2761                 break;
2762
2763         case SCTP_CLR_STAT_LOG:
2764 #ifdef SCTP_STAT_LOGGING
2765                 sctp_clr_stat_log();
2766 #else
2767                 error = EOPNOTSUPP;
2768 #endif
2769                 break;
2770         case SCTP_DELAYED_ACK_TIME:
2771         {
2772                 int32_t *tm;
2773                 if ((size_t)m->m_len < sizeof(int32_t)) {
2774                         error = EINVAL;
2775                         break;
2776                 }
2777                 tm = mtod(m, int32_t *);
2778
2779                 if ((*tm < 10) || (*tm > 500)) {
2780                         /* can't be smaller than 10ms */
2781                         /* MUST NOT be larger than 500ms */
2782                         error = EINVAL;
2783                         break;
2784                 }
2785                 inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV] = MSEC_TO_TICKS(*tm);
2786         }
2787                 break;
2788         case SCTP_RESET_STREAMS:
2789         {
2790                 struct sctp_stream_reset *strrst;
2791                 uint8_t two_way, not_peer;
2792
2793                 if ((size_t)m->m_len < sizeof(struct sctp_stream_reset)) {
2794                         error = EINVAL;
2795                         break;
2796                 }
2797                 strrst = mtod(m, struct sctp_stream_reset *);
2798
2799                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2800                         SCTP_INP_RLOCK(inp);
2801                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2802                         if (stcb)
2803                                 SCTP_TCB_LOCK(stcb);
2804                         SCTP_INP_RUNLOCK(inp);
2805                 } else
2806                         stcb = sctp_findassociation_ep_asocid(inp, strrst->strrst_assoc_id);
2807                 if (stcb == NULL) {
2808                         error = ENOENT;
2809                         break;
2810                 }
2811                 if (stcb->asoc.peer_supports_strreset == 0) {
2812                         /* Peer does not support it,
2813                          * we return protocol not supported since
2814                          * this is true for this feature and this
2815                          * peer, not the socket request in general.
2816                          */
2817                         error = EPROTONOSUPPORT;
2818                         SCTP_TCB_UNLOCK(stcb);
2819                         break;
2820                 }
2821
2822 /* Having re-thought this code I added as I write the I-D there
2823  * is NO need for it. The peer, if we are requesting a stream-reset
2824  * will send a request to us but will itself do what we do, take
2825  * and copy off the "reset information" we send and queue TSN's
2826  * larger than the send-next in our response message. Thus they
2827  * will handle it.
2828  */
2829 /*              if (stcb->asoc.sending_seq != (stcb->asoc.last_acked_seq + 1)) {*/
2830                 /* Must have all sending data ack'd before we
2831                  * start this procedure. This is a bit restrictive
2832                  * and we SHOULD work on changing this so ONLY the
2833                  * streams being RESET get held up. So, a reset-all
2834                  * would require this.. but a reset specific just
2835                  * needs to be sure that the ones being reset have
2836                  * nothing on the send_queue. For now we will
2837                  * skip this more detailed method and do a course
2838                  * way.. i.e. nothing pending ... for future FIX ME!
2839                  */
2840 /*                      error = EBUSY;*/
2841 /*                      break;*/
2842 /*              }*/
2843
2844                 if (stcb->asoc.stream_reset_outstanding) {
2845                         error = EALREADY;
2846                         SCTP_TCB_UNLOCK(stcb);
2847                         break;
2848                 }
2849                 if (strrst->strrst_flags == SCTP_RESET_LOCAL_RECV) {
2850                         two_way = 0;
2851                         not_peer = 0;
2852                 } else if (strrst->strrst_flags == SCTP_RESET_LOCAL_SEND) {
2853                         two_way = 1;
2854                         not_peer = 1;
2855                 } else if (strrst->strrst_flags == SCTP_RESET_BOTH) {
2856                         two_way = 1;
2857                         not_peer = 0;
2858                 } else {
2859                         error = EINVAL;
2860                         SCTP_TCB_UNLOCK(stcb);
2861                         break;
2862                 }
2863                 sctp_send_str_reset_req(stcb, strrst->strrst_num_streams,
2864                                         strrst->strrst_list, two_way, not_peer);
2865                 crit_enter();
2866                 sctp_chunk_output(inp, stcb, 12);
2867                 SCTP_TCB_UNLOCK(stcb);
2868                 crit_exit();
2869
2870         }
2871         break;
2872         case SCTP_RESET_PEGS:
2873                 memset(sctp_pegs, 0, sizeof(sctp_pegs));
2874                 error = 0;
2875                 break;
2876         case SCTP_CONNECT_X:
2877                 if ((size_t)m->m_len < (sizeof(int) + sizeof(struct sockaddr_in))) {
2878                         error = EINVAL;
2879                         break;
2880                 }
2881                 error = sctp_do_connect_x(so, inp, m, p, 0);
2882                 break;
2883
2884         case SCTP_CONNECT_X_DELAYED:
2885                 if ((size_t)m->m_len < (sizeof(int) + sizeof(struct sockaddr_in))) {
2886                         error = EINVAL;
2887                         break;
2888                 }
2889                 error = sctp_do_connect_x(so, inp, m, p, 1);
2890                 break;
2891
2892         case SCTP_CONNECT_X_COMPLETE:
2893         {
2894                 struct sockaddr *sa;
2895                 struct sctp_nets *net;
2896                 if ((size_t)m->m_len < sizeof(struct sockaddr_in)) {
2897                         error = EINVAL;
2898                         break;
2899                 }
2900                 sa = mtod(m, struct sockaddr *);
2901                 /* find tcb */
2902                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2903                         SCTP_INP_RLOCK(inp);
2904                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
2905                         if (stcb) {
2906                                 SCTP_TCB_LOCK(stcb);
2907                                 net = sctp_findnet(stcb, sa);
2908                         }
2909                         SCTP_INP_RUNLOCK(inp);
2910                 } else {
2911                         SCTP_INP_WLOCK(inp);
2912                         SCTP_INP_INCR_REF(inp);
2913                         SCTP_INP_WUNLOCK(inp);
2914                         stcb = sctp_findassociation_ep_addr(&inp, sa, &net, NULL, NULL);
2915                         if (stcb == NULL) {
2916                                 SCTP_INP_WLOCK(inp);
2917                                 SCTP_INP_DECR_REF(inp);
2918                                 SCTP_INP_WUNLOCK(inp);
2919                         }
2920                 }
2921
2922                 if (stcb == NULL) {
2923                         error = ENOENT;
2924                         break;
2925                 }
2926                 if (stcb->asoc.delayed_connection == 1) {
2927                         stcb->asoc.delayed_connection = 0;
2928                         SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
2929                         sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
2930                         sctp_send_initiate(inp, stcb);
2931                 } else {
2932                         /* already expired or did not use delayed connectx */
2933                         error = EALREADY;
2934                 }
2935                 SCTP_TCB_UNLOCK(stcb);
2936         }
2937         break;
2938         case SCTP_MAXBURST:
2939         {
2940                 u_int8_t *burst;
2941                 SCTP_INP_WLOCK(inp);
2942                 burst = mtod(m, u_int8_t *);
2943                 if (*burst) {
2944                         inp->sctp_ep.max_burst = *burst;
2945                 }
2946                 SCTP_INP_WUNLOCK(inp);
2947         }
2948         break;
2949         case SCTP_MAXSEG:
2950         {
2951                 u_int32_t *segsize;
2952                 int ovh;
2953                 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
2954                         ovh = SCTP_MED_OVERHEAD;
2955                 } else {
2956                         ovh = SCTP_MED_V4_OVERHEAD;
2957                 }
2958                 segsize = mtod(m, u_int32_t *);
2959                 if (*segsize < 1) {
2960                         error = EINVAL;
2961                         break;
2962                 }
2963                 SCTP_INP_WLOCK(inp);
2964                 inp->sctp_frag_point = (*segsize+ovh);
2965                 if (inp->sctp_frag_point < MHLEN) {
2966                         inp->sctp_frag_point = MHLEN;
2967                 }
2968                 SCTP_INP_WUNLOCK(inp);
2969         }
2970         break;
2971         case SCTP_SET_DEBUG_LEVEL:
2972 #ifdef SCTP_DEBUG
2973         {
2974                 u_int32_t *level;
2975                 if ((size_t)m->m_len < sizeof(u_int32_t)) {
2976                         error = EINVAL;
2977                         break;
2978                 }
2979                 level = mtod(m, u_int32_t *);
2980                 error = 0;
2981                 sctp_debug_on = (*level & (SCTP_DEBUG_ALL |
2982                                            SCTP_DEBUG_NOISY));
2983                 kprintf("SETTING DEBUG LEVEL to %x\n",
2984                        (u_int)sctp_debug_on);
2985
2986         }
2987 #else
2988         error = EOPNOTSUPP;
2989 #endif /* SCTP_DEBUG */
2990         break;
2991         case SCTP_EVENTS:
2992         {
2993                 struct sctp_event_subscribe *events;
2994                 if ((size_t)m->m_len < sizeof(struct sctp_event_subscribe)) {
2995                         error = EINVAL;
2996                         break;
2997                 }
2998                 SCTP_INP_WLOCK(inp);
2999                 events = mtod(m, struct sctp_event_subscribe *);
3000                 if (events->sctp_data_io_event) {
3001                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVDATAIOEVNT;
3002                 } else {
3003                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVDATAIOEVNT;
3004                 }
3005
3006                 if (events->sctp_association_event) {
3007                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVASSOCEVNT;
3008                 } else {
3009                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVASSOCEVNT;
3010                 }
3011
3012                 if (events->sctp_address_event) {
3013                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVPADDREVNT;
3014                 } else {
3015                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVPADDREVNT;
3016                 }
3017
3018                 if (events->sctp_send_failure_event) {
3019                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
3020                 } else {
3021                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
3022                 }
3023
3024                 if (events->sctp_peer_error_event) {
3025                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVPEERERR;
3026                 } else {
3027                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVPEERERR;
3028                 }
3029
3030                 if (events->sctp_shutdown_event) {
3031                         inp->sctp_flags |= SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
3032                 } else {
3033                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
3034                 }
3035
3036                 if (events->sctp_partial_delivery_event) {
3037                         inp->sctp_flags |= SCTP_PCB_FLAGS_PDAPIEVNT;
3038                 } else {
3039                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_PDAPIEVNT;
3040                 }
3041
3042                 if (events->sctp_adaption_layer_event) {
3043                         inp->sctp_flags |= SCTP_PCB_FLAGS_ADAPTIONEVNT;
3044                 } else {
3045                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_ADAPTIONEVNT;
3046                 }
3047
3048                 if (events->sctp_stream_reset_events) {
3049                         inp->sctp_flags |= SCTP_PCB_FLAGS_STREAM_RESETEVNT;
3050                 } else {
3051                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_STREAM_RESETEVNT;
3052                 }
3053                 SCTP_INP_WUNLOCK(inp);
3054         }
3055         break;
3056
3057         case SCTP_ADAPTION_LAYER:
3058         {
3059                 struct sctp_setadaption *adap_bits;
3060                 if ((size_t)m->m_len < sizeof(struct sctp_setadaption)) {
3061                         error = EINVAL;
3062                         break;
3063                 }
3064                 SCTP_INP_WLOCK(inp);
3065                 adap_bits = mtod(m, struct sctp_setadaption *);
3066                 inp->sctp_ep.adaption_layer_indicator = adap_bits->ssb_adaption_ind;
3067                 SCTP_INP_WUNLOCK(inp);
3068         }
3069         break;
3070         case SCTP_SET_INITIAL_DBG_SEQ:
3071         {
3072                 u_int32_t *vvv;
3073                 if ((size_t)m->m_len < sizeof(u_int32_t)) {
3074                         error = EINVAL;
3075                         break;
3076                 }
3077                 SCTP_INP_WLOCK(inp);
3078                 vvv = mtod(m, u_int32_t *);
3079                 inp->sctp_ep.initial_sequence_debug = *vvv;
3080                 SCTP_INP_WUNLOCK(inp);
3081         }
3082         break;
3083         case SCTP_DEFAULT_SEND_PARAM:
3084         {
3085                 struct sctp_sndrcvinfo *s_info;
3086
3087                 if (m->m_len != sizeof(struct sctp_sndrcvinfo)) {
3088                         error = EINVAL;
3089                         break;
3090                 }
3091                 s_info = mtod(m, struct sctp_sndrcvinfo *);
3092
3093                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3094                         SCTP_INP_RLOCK(inp);
3095                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
3096                         if (stcb)
3097                                 SCTP_TCB_LOCK(stcb);
3098                         SCTP_INP_RUNLOCK(inp);
3099                 } else
3100                         stcb = sctp_findassociation_ep_asocid(inp, s_info->sinfo_assoc_id);
3101
3102                 if (stcb == NULL) {
3103                         error = ENOENT;
3104                         break;
3105                 }
3106                 /* Validate things */
3107                 if (s_info->sinfo_stream > stcb->asoc.streamoutcnt) {
3108                         SCTP_TCB_UNLOCK(stcb);
3109                         error = EINVAL;
3110                         break;
3111                 }
3112                 /* Mask off the flags that are allowed */
3113                 s_info->sinfo_flags = (s_info->sinfo_flags &
3114                                        (MSG_UNORDERED | MSG_ADDR_OVER |
3115                                         MSG_PR_SCTP_TTL | MSG_PR_SCTP_BUF));
3116                 /* Copy it in */
3117                 stcb->asoc.def_send = *s_info;
3118                 SCTP_TCB_UNLOCK(stcb);
3119         }
3120         break;
3121         case SCTP_PEER_ADDR_PARAMS:
3122         {
3123                 struct sctp_paddrparams *paddrp;
3124                 struct sctp_nets *net;
3125                 if ((size_t)m->m_len < sizeof(struct sctp_paddrparams)) {
3126                         error = EINVAL;
3127                         break;
3128                 }
3129                 paddrp = mtod(m, struct sctp_paddrparams *);
3130                 net = NULL;
3131                 if (paddrp->spp_assoc_id) {
3132                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3133                                 SCTP_INP_RLOCK(inp);
3134                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3135                                 if (stcb) {
3136                                         SCTP_TCB_LOCK(stcb);
3137                                         net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
3138                                 }
3139                                 SCTP_INP_RUNLOCK(inp);
3140                         } else
3141                                 stcb = sctp_findassociation_ep_asocid(inp, paddrp->spp_assoc_id);
3142                         if (stcb == NULL) {
3143                                 error = ENOENT;
3144                                 break;
3145                         }
3146
3147                 }
3148                 if ((stcb == NULL) &&
3149                     ((((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET) ||
3150                      (((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET6))) {
3151                         /* Lookup via address */
3152                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3153                                 SCTP_INP_RLOCK(inp);
3154                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3155                                 if (stcb) {
3156                                         SCTP_TCB_LOCK(stcb);
3157                                         net = sctp_findnet(stcb,
3158                                                            (struct sockaddr *)&paddrp->spp_address);
3159                                 }
3160                                 SCTP_INP_RUNLOCK(inp);
3161                         } else {
3162                                 SCTP_INP_WLOCK(inp);
3163                                 SCTP_INP_INCR_REF(inp);
3164                                 SCTP_INP_WUNLOCK(inp);
3165                                 stcb = sctp_findassociation_ep_addr(&inp,
3166                                                                     (struct sockaddr *)&paddrp->spp_address,
3167                                                                     &net, NULL, NULL);
3168                                 if (stcb == NULL) {
3169                                         SCTP_INP_WLOCK(inp);
3170                                         SCTP_INP_DECR_REF(inp);
3171                                         SCTP_INP_WUNLOCK(inp);
3172                                 }
3173                         }
3174                 } else {
3175                         /* Effects the Endpoint */
3176                         stcb = NULL;
3177                 }
3178                 if (stcb) {
3179                         /* Applies to the specific association */
3180                         if (paddrp->spp_pathmaxrxt) {
3181                                 if (net) {
3182                                         if (paddrp->spp_pathmaxrxt)
3183                                                 net->failure_threshold = paddrp->spp_pathmaxrxt;
3184                                 } else {
3185                                         if (paddrp->spp_pathmaxrxt)
3186                                                 stcb->asoc.def_net_failure = paddrp->spp_pathmaxrxt;
3187                                 }
3188                         }
3189                         if ((paddrp->spp_hbinterval != 0) && (paddrp->spp_hbinterval != 0xffffffff)) {
3190                                 /* Just a set */
3191                                 int old;
3192                                 if (net) {
3193                                         net->dest_state &= ~SCTP_ADDR_NOHB;
3194                                 } else {
3195                                         old = stcb->asoc.heart_beat_delay;
3196                                         stcb->asoc.heart_beat_delay = paddrp->spp_hbinterval;
3197                                         if (old == 0) {
3198                                                 /* Turn back on the timer */
3199                                                 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
3200                                         }
3201                                 }
3202                         } else if (paddrp->spp_hbinterval == 0xffffffff) {
3203                                 /* on demand HB */
3204                                 sctp_send_hb(stcb, 1, net);
3205                         } else {
3206                                 if (net == NULL) {
3207                                         /* off on association */
3208                                         if (stcb->asoc.heart_beat_delay) {
3209                                                 int cnt_of_unconf = 0;
3210                                                 struct sctp_nets *lnet;
3211                                                 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
3212                                                         if (lnet->dest_state & SCTP_ADDR_UNCONFIRMED) {
3213                                                                 cnt_of_unconf++;
3214                                                         }
3215                                                 }
3216                                                 /* stop the timer ONLY if we have no unconfirmed addresses
3217                                                  */
3218                                                 if (cnt_of_unconf == 0)
3219                                                         sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
3220                                         }
3221                                         stcb->asoc.heart_beat_delay = 0;
3222                                 } else {
3223                                         net->dest_state |= SCTP_ADDR_NOHB;
3224                                 }
3225                         }
3226                         SCTP_TCB_UNLOCK(stcb);
3227                 } else {
3228                         /* Use endpoint defaults */
3229                         SCTP_INP_WLOCK(inp);
3230                         if (paddrp->spp_pathmaxrxt)
3231                                 inp->sctp_ep.def_net_failure = paddrp->spp_pathmaxrxt;
3232                         if (paddrp->spp_hbinterval != SCTP_ISSUE_HB)
3233                                 inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = paddrp->spp_hbinterval;
3234                         SCTP_INP_WUNLOCK(inp);
3235                 }
3236         }
3237         break;
3238         case SCTP_RTOINFO:
3239         {
3240                 struct sctp_rtoinfo *srto;
3241                 if ((size_t)m->m_len < sizeof(struct sctp_rtoinfo)) {
3242                         error = EINVAL;
3243                         break;
3244                 }
3245                 srto = mtod(m, struct sctp_rtoinfo *);
3246                 if (srto->srto_assoc_id == 0) {
3247                         SCTP_INP_WLOCK(inp);
3248                         /* If we have a null asoc, its default for the endpoint */
3249                         if (srto->srto_initial > 10)
3250                                 inp->sctp_ep.initial_rto = srto->srto_initial;
3251                         if (srto->srto_max > 10)
3252                                 inp->sctp_ep.sctp_maxrto = srto->srto_max;
3253                         if (srto->srto_min > 10)
3254                                 inp->sctp_ep.sctp_minrto = srto->srto_min;
3255                         SCTP_INP_WUNLOCK(inp);
3256                         break;
3257                 }
3258                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3259                         SCTP_INP_RLOCK(inp);
3260                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
3261                         if (stcb)
3262                                 SCTP_TCB_LOCK(stcb);
3263                         SCTP_INP_RUNLOCK(inp);
3264                 } else
3265                         stcb = sctp_findassociation_ep_asocid(inp, srto->srto_assoc_id);
3266                 if (stcb == NULL) {
3267                         error = EINVAL;
3268                         break;
3269                 }
3270                 /* Set in ms we hope :-) */
3271                 if (srto->srto_initial > 10)
3272                         stcb->asoc.initial_rto = srto->srto_initial;
3273                 if (srto->srto_max > 10)
3274                         stcb->asoc.maxrto = srto->srto_max;
3275                 if (srto->srto_min > 10)
3276                         stcb->asoc.minrto = srto->srto_min;
3277                 SCTP_TCB_UNLOCK(stcb);
3278         }
3279         break;
3280         case SCTP_ASSOCINFO:
3281         {
3282                 struct sctp_assocparams *sasoc;
3283
3284                 if ((size_t)m->m_len < sizeof(struct sctp_assocparams)) {
3285                         error = EINVAL;
3286                         break;
3287                 }
3288                 sasoc = mtod(m, struct sctp_assocparams *);
3289                 if (sasoc->sasoc_assoc_id) {
3290                         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3291                                 SCTP_INP_RLOCK(inp);
3292                                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3293                                 if (stcb)
3294                                         SCTP_TCB_LOCK(stcb);
3295                                 SCTP_INP_RUNLOCK(inp);
3296                         } else
3297                                 stcb = sctp_findassociation_ep_asocid(inp,
3298                                                                       sasoc->sasoc_assoc_id);
3299                         if (stcb == NULL) {
3300                                 error = ENOENT;
3301                                 break;
3302                         }
3303
3304                 } else {
3305                         stcb = NULL;
3306                 }
3307                 if (stcb) {
3308                         if (sasoc->sasoc_asocmaxrxt)
3309                                 stcb->asoc.max_send_times = sasoc->sasoc_asocmaxrxt;
3310                         sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
3311                         sasoc->sasoc_peer_rwnd = 0;
3312                         sasoc->sasoc_local_rwnd = 0;
3313                         if (stcb->asoc.cookie_life)
3314                                 stcb->asoc.cookie_life = sasoc->sasoc_cookie_life;
3315                         SCTP_TCB_UNLOCK(stcb);
3316                 } else {
3317                         SCTP_INP_WLOCK(inp);
3318                         if (sasoc->sasoc_asocmaxrxt)
3319                                 inp->sctp_ep.max_send_times = sasoc->sasoc_asocmaxrxt;
3320                         sasoc->sasoc_number_peer_destinations = 0;
3321                         sasoc->sasoc_peer_rwnd = 0;
3322                         sasoc->sasoc_local_rwnd = 0;
3323                         if (sasoc->sasoc_cookie_life)
3324                                 inp->sctp_ep.def_cookie_life = sasoc->sasoc_cookie_life;
3325                         SCTP_INP_WUNLOCK(inp);
3326                 }
3327         }
3328         break;
3329         case SCTP_INITMSG:
3330         {
3331                 struct sctp_initmsg *sinit;
3332
3333                 if ((size_t)m->m_len < sizeof(struct sctp_initmsg)) {
3334                         error = EINVAL;
3335                         break;
3336                 }
3337                 sinit = mtod(m, struct sctp_initmsg *);
3338                 SCTP_INP_WLOCK(inp);
3339                 if (sinit->sinit_num_ostreams)
3340                         inp->sctp_ep.pre_open_stream_count = sinit->sinit_num_ostreams;
3341
3342                 if (sinit->sinit_max_instreams)
3343                         inp->sctp_ep.max_open_streams_intome = sinit->sinit_max_instreams;
3344
3345                 if (sinit->sinit_max_attempts)
3346                         inp->sctp_ep.max_init_times = sinit->sinit_max_attempts;
3347
3348                 if (sinit->sinit_max_init_timeo > 10)
3349                         /* We must be at least a 100ms (we set in ticks) */
3350                         inp->sctp_ep.initial_init_rto_max = sinit->sinit_max_init_timeo;
3351                 SCTP_INP_WUNLOCK(inp);
3352         }
3353         break;
3354         case SCTP_PRIMARY_ADDR:
3355         {
3356                 struct sctp_setprim *spa;
3357                 struct sctp_nets *net, *lnet;
3358                 if ((size_t)m->m_len < sizeof(struct sctp_setprim)) {
3359                         error = EINVAL;
3360                         break;
3361                 }
3362                 spa = mtod(m, struct sctp_setprim *);
3363
3364                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3365                         SCTP_INP_RLOCK(inp);
3366                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
3367                         if (stcb) {
3368                                 SCTP_TCB_LOCK(stcb);
3369                         } else {
3370                                 error = EINVAL;
3371                                 break;
3372                         }
3373                         SCTP_INP_RUNLOCK(inp);
3374                 } else
3375                         stcb = sctp_findassociation_ep_asocid(inp, spa->ssp_assoc_id);
3376                 if (stcb == NULL) {
3377                         /* One last shot */
3378                         SCTP_INP_WLOCK(inp);
3379                         SCTP_INP_INCR_REF(inp);
3380                         SCTP_INP_WUNLOCK(inp);
3381                         stcb = sctp_findassociation_ep_addr(&inp,
3382                                                             (struct sockaddr *)&spa->ssp_addr,
3383                                                             &net, NULL, NULL);
3384                         if (stcb == NULL) {
3385                                 SCTP_INP_WLOCK(inp);
3386                                 SCTP_INP_DECR_REF(inp);
3387                                 SCTP_INP_WUNLOCK(inp);
3388                                 error = EINVAL;
3389                                 break;
3390                         }
3391                 } else {
3392                         /* find the net, associd or connected lookup type */
3393                         net = sctp_findnet(stcb, (struct sockaddr *)&spa->ssp_addr);
3394                         if (net == NULL) {
3395                                 SCTP_TCB_UNLOCK(stcb);
3396                                 error = EINVAL;
3397                                 break;
3398                         }
3399                 }
3400                 if ((net != stcb->asoc.primary_destination) &&
3401                     (!(net->dest_state & SCTP_ADDR_UNCONFIRMED))) {
3402                         /* Ok we need to set it */
3403                         lnet = stcb->asoc.primary_destination;
3404                         lnet->next_tsn_at_change = net->next_tsn_at_change = stcb->asoc.sending_seq;
3405                         if (sctp_set_primary_addr(stcb,
3406                                                   (struct sockaddr *)NULL,
3407                                                   net) == 0) {
3408                                 if (net->dest_state & SCTP_ADDR_SWITCH_PRIMARY) {
3409                                         net->dest_state |= SCTP_ADDR_DOUBLE_SWITCH;
3410                                 }
3411                                 net->dest_state |= SCTP_ADDR_SWITCH_PRIMARY;
3412                         }
3413                 }
3414                 SCTP_TCB_UNLOCK(stcb);
3415         }
3416         break;
3417
3418         case SCTP_SET_PEER_PRIMARY_ADDR:
3419         {
3420                 struct sctp_setpeerprim *sspp;
3421                 if ((size_t)m->m_len < sizeof(struct sctp_setpeerprim)) {
3422                         error = EINVAL;
3423                         break;
3424                 }
3425                 sspp = mtod(m, struct sctp_setpeerprim *);
3426
3427
3428                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3429                         SCTP_INP_RLOCK(inp);
3430                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
3431                         if (stcb)
3432                                 SCTP_TCB_UNLOCK(stcb);
3433                         SCTP_INP_RUNLOCK(inp);
3434                 } else
3435                         stcb = sctp_findassociation_ep_asocid(inp, sspp->sspp_assoc_id);
3436                 if (stcb == NULL) {
3437                         error = EINVAL;
3438                         break;
3439                 }
3440                 if (sctp_set_primary_ip_address_sa(stcb, (struct sockaddr *)&sspp->sspp_addr) != 0) {
3441                         error = EINVAL;
3442                 }
3443                 SCTP_TCB_UNLOCK(stcb);
3444         }
3445         break;
3446         case SCTP_BINDX_ADD_ADDR:
3447         {
3448                 struct sctp_getaddresses *addrs;
3449                 struct sockaddr *addr_touse;
3450                 struct sockaddr_in sin;
3451                 /* see if we're bound all already! */
3452                 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
3453                         error = EINVAL;
3454                         break;
3455                 }
3456                 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
3457                         error = EINVAL;
3458                         break;
3459                 }
3460                 addrs = mtod(m, struct sctp_getaddresses *);
3461                 addr_touse = addrs->addr;
3462                 if (addrs->addr->sa_family == AF_INET6) {
3463                         struct sockaddr_in6 *sin6;
3464                         sin6 = (struct sockaddr_in6 *)addr_touse;
3465                         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
3466                                 in6_sin6_2_sin(&sin, sin6);
3467                                 addr_touse = (struct sockaddr *)&sin;
3468                         }
3469                 }
3470                 if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
3471                         if (p == NULL) {
3472                                 /* Can't get proc for Net/Open BSD */
3473                                 error = EINVAL;
3474                                 break;
3475                         }
3476                         error = sctp_inpcb_bind(so, addr_touse, p);
3477                         break;
3478                 }
3479                 /* No locks required here since bind and mgmt_ep_sa all
3480                  * do their own locking. If we do something for the FIX:
3481                  * below we may need to lock in that case.
3482                  */
3483                 if (addrs->sget_assoc_id == 0) {
3484                         /* add the address */
3485                         struct sctp_inpcb  *lep;
3486                         ((struct sockaddr_in *)addr_touse)->sin_port = inp->sctp_lport;
3487                         lep = sctp_pcb_findep(addr_touse, 1, 0);
3488                         if (lep != NULL) {
3489                                 /* We must decrement the refcount
3490                                  * since we have the ep already and
3491                                  * are binding. No remove going on
3492                                  * here.
3493                                  */
3494                                 SCTP_INP_WLOCK(inp);
3495                                 SCTP_INP_DECR_REF(inp);
3496                                 SCTP_INP_WUNLOCK(inp);
3497                         }
3498                         if (lep == inp) {
3499                                 /* already bound to it.. ok */
3500                                 break;
3501                         } else if (lep == NULL) {
3502                                 ((struct sockaddr_in *)addr_touse)->sin_port = 0;
3503                                 error = sctp_addr_mgmt_ep_sa(inp, addr_touse,
3504                                                              SCTP_ADD_IP_ADDRESS);
3505                         } else {
3506                                 error = EADDRNOTAVAIL;
3507                         }
3508                         if (error)
3509                                 break;
3510
3511                 } else {
3512                         /* FIX: decide whether we allow assoc based bindx */
3513                 }
3514         }
3515         break;
3516         case SCTP_BINDX_REM_ADDR:
3517         {
3518                 struct sctp_getaddresses *addrs;
3519                 struct sockaddr *addr_touse;
3520                 struct sockaddr_in sin;
3521                 /* see if we're bound all already! */
3522                 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
3523                         error = EINVAL;
3524                         break;
3525                 }
3526                 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
3527                         error = EINVAL;
3528                         break;
3529                 }
3530                 addrs = mtod(m, struct sctp_getaddresses *);
3531                 addr_touse = addrs->addr;
3532                 if (addrs->addr->sa_family == AF_INET6) {
3533                         struct sockaddr_in6 *sin6;
3534                         sin6 = (struct sockaddr_in6 *)addr_touse;
3535                         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
3536                                 in6_sin6_2_sin(&sin, sin6);
3537                                 addr_touse = (struct sockaddr *)&sin;
3538                         }
3539                 }
3540                 /* No lock required mgmt_ep_sa does its own locking. If
3541                  * the FIX: below is ever changed we may need to
3542                  * lock before calling association level binding.
3543                  */
3544                 if (addrs->sget_assoc_id == 0) {
3545                         /* delete the address */
3546                         sctp_addr_mgmt_ep_sa(inp, addr_touse,
3547                                              SCTP_DEL_IP_ADDRESS);
3548                 } else {
3549                         /* FIX: decide whether we allow assoc based bindx */
3550                 }
3551         }
3552         break;
3553         default:
3554                 error = ENOPROTOOPT;
3555                 break;
3556         } /* end switch (opt) */
3557         return (error);
3558 }
3559
3560
3561 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
3562 int
3563 sctp_ctloutput(struct socket *so, struct sockopt *sopt)
3564 {
3565         struct mbuf *m = NULL;
3566         struct sctp_inpcb *inp;
3567         int error;
3568
3569         inp = (struct sctp_inpcb *)so->so_pcb;
3570         crit_enter();
3571         if (inp == 0) {
3572                 crit_exit();
3573                 /* I made the same as TCP since we are not setup? */
3574                 return (ECONNRESET);
3575         }
3576         if (sopt->sopt_level != IPPROTO_SCTP) {
3577                 /* wrong proto level... send back up to IP */
3578 #ifdef INET6
3579                 if (INP_CHECK_SOCKAF(so, AF_INET6))
3580                         error = ip6_ctloutput(so, sopt);
3581                 else
3582 #endif /* INET6 */
3583                         error = ip_ctloutput(so, sopt);
3584                 crit_exit();
3585                 return (error);
3586         }
3587         if (sopt->sopt_valsize > MCLBYTES) {
3588                 /*
3589                  * Restrict us down to a cluster size, that's all we can
3590                  * pass either way...
3591                  */
3592                 sopt->sopt_valsize = MCLBYTES;
3593         }
3594         if (sopt->sopt_valsize) {
3595
3596                 m = m_get(MB_WAIT, MT_DATA);
3597                 if (sopt->sopt_valsize > MLEN) {
3598                         MCLGET(m, MB_DONTWAIT);
3599                         if ((m->m_flags & M_EXT) == 0) {
3600                                 sctp_m_freem(m);
3601                                 crit_exit();
3602                                 return (ENOBUFS);
3603                         }
3604                 }
3605                 error = sooptcopyin(sopt, mtod(m, caddr_t), sopt->sopt_valsize,
3606                                     sopt->sopt_valsize);
3607                 if (error) {
3608                         m_free(m);
3609                         goto out;
3610                 }
3611                 m->m_len = sopt->sopt_valsize;
3612         }
3613         if (sopt->sopt_dir == SOPT_SET) {
3614 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3615                 error = sctp_optsset(so, sopt->sopt_name, &m, sopt->sopt_td);
3616 #else
3617                 error = sctp_optsset(so, sopt->sopt_name, &m, sopt->sopt_p);
3618 #endif
3619         } else if (sopt->sopt_dir == SOPT_GET) {
3620 #if (defined (__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3621                 error = sctp_optsget(so, sopt->sopt_name, &m, sopt->sopt_td);
3622 #else
3623                 error = sctp_optsget(so, sopt->sopt_name, &m, sopt->sopt_p);
3624 #endif
3625         } else {
3626                 error = EINVAL;
3627         }
3628         if ( (error == 0) && (m != NULL)) {
3629                 error = sooptcopyout(sopt, mtod(m, caddr_t), m->m_len);
3630                 sctp_m_freem(m);
3631         } else if (m != NULL) {
3632                 sctp_m_freem(m);
3633         }
3634  out:
3635         crit_exit();
3636         return (error);
3637 }
3638
3639 #else
3640 /* NetBSD and OpenBSD */
3641 int
3642 sctp_ctloutput(int op, struct socket *so, int level, int optname,
3643                struct mbuf **mp)
3644 {
3645         int s, error;
3646         struct inpcb *inp;
3647 #ifdef INET6
3648         struct in6pcb *in6p;
3649 #endif
3650         int family;     /* family of the socket */
3651
3652         family = so->so_proto->pr_domain->dom_family;
3653         error = 0;
3654         crit_exit();
3655         switch (family) {
3656         case PF_INET:
3657                 inp = sotoinpcb(so);
3658 #ifdef INET6
3659                 in6p = NULL;
3660 #endif
3661                 break;
3662 #ifdef INET6
3663         case PF_INET6:
3664                 inp = NULL;
3665                 in6p = sotoin6pcb(so);
3666                 break;
3667 #endif
3668         default:
3669                 crit_exit();
3670                 return EAFNOSUPPORT;
3671         }
3672 #ifndef INET6
3673         if (inp == NULL)
3674 #else
3675                 if (inp == NULL && in6p == NULL)
3676 #endif
3677                 {
3678                         crit_exit();
3679                         if (op == PRCO_SETOPT && *mp)
3680                                 m_free(*mp);
3681                         return (ECONNRESET);
3682                 }
3683         if (level != IPPROTO_SCTP) {
3684                 switch (family) {
3685                 case PF_INET:
3686                         error = ip_ctloutput(op, so, level, optname, mp);
3687                         break;
3688 #ifdef INET6
3689                 case PF_INET6:
3690                         error = ip6_ctloutput(op, so, level, optname, mp);
3691                         break;
3692 #endif
3693                 }
3694                 crit_exit();
3695                 return (error);
3696         }
3697         /* Ok if we reach here it is a SCTP option we hope */
3698         if (op == PRCO_SETOPT) {
3699                 error = sctp_optsset(so, optname, mp, (struct proc *)NULL);
3700                 if (*mp)
3701                         m_free(*mp);
3702         } else if (op ==  PRCO_GETOPT) {
3703                 error = sctp_optsget(so, optname, mp, (struct proc *)NULL);
3704         } else {
3705                 error = EINVAL;
3706         }
3707         crit_exit();
3708         return (error);
3709 }
3710
3711 #endif
3712
3713 static int
3714 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3715 sctp_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
3716 {
3717 #else
3718 #if defined(__FreeBSD__) || defined(__APPLE__)
3719 sctp_connect(struct socket *so, struct sockaddr *addr, struct proc *p)
3720 {
3721 #else
3722 sctp_connect(struct socket *so, struct mbuf *nam, struct proc *p)
3723 {
3724         struct sockaddr *addr = mtod(nam, struct sockaddr *);
3725 #endif
3726 #endif
3727         int error = 0;
3728         struct sctp_inpcb *inp;
3729         struct sctp_tcb *stcb;
3730
3731 #ifdef SCTP_DEBUG
3732         if (sctp_debug_on & SCTP_DEBUG_PCB1) {
3733                 kprintf("Connect called in SCTP to ");
3734                 sctp_print_address(addr);
3735                 kprintf("Port %d\n", ntohs(((struct sockaddr_in *)addr)->sin_port));
3736         }
3737 #endif /* SCTP_DEBUG */
3738         crit_enter();
3739         inp = (struct sctp_inpcb *)so->so_pcb;
3740         if (inp == 0) {
3741                 crit_exit();
3742                 /* I made the same as TCP since we are not setup? */
3743                 return (ECONNRESET);
3744         }
3745         SCTP_ASOC_CREATE_LOCK(inp);
3746         SCTP_INP_WLOCK(inp);
3747         if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
3748             (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
3749                 /* Should I really unlock ? */
3750                 SCTP_INP_WUNLOCK(inp);
3751                 SCTP_ASOC_CREATE_UNLOCK(inp);
3752                 crit_exit();
3753                 return (EFAULT);
3754         }
3755 #ifdef INET6
3756         if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
3757             (addr->sa_family == AF_INET6)) {
3758                 SCTP_INP_WUNLOCK(inp);
3759                 SCTP_ASOC_CREATE_UNLOCK(inp);
3760                 crit_exit();
3761                 return (EINVAL);
3762         }
3763 #endif /* INET6 */
3764         if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
3765             SCTP_PCB_FLAGS_UNBOUND) {
3766                 /* Bind a ephemeral port */
3767                 SCTP_INP_WUNLOCK(inp);
3768                 error = sctp_inpcb_bind(so, NULL, p);
3769                 if (error) {
3770                         SCTP_ASOC_CREATE_UNLOCK(inp);
3771                         crit_exit();
3772                         return (error);
3773                 }
3774                 SCTP_INP_WLOCK(inp);
3775         }
3776         /* Now do we connect? */
3777         if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
3778             (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
3779                 /* We are already connected AND the TCP model */
3780                 crit_exit();
3781                 SCTP_INP_WUNLOCK(inp);
3782                 SCTP_ASOC_CREATE_UNLOCK(inp);
3783                 return (EADDRINUSE);
3784         }
3785         if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3786                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3787                 if (stcb)
3788                         SCTP_TCB_UNLOCK(stcb);
3789                 SCTP_INP_WUNLOCK(inp);
3790         } else {
3791                 SCTP_INP_INCR_REF(inp);
3792                 SCTP_INP_WUNLOCK(inp);
3793                 stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL);
3794                 if (stcb == NULL) {
3795                         SCTP_INP_WLOCK(inp);
3796                         SCTP_INP_DECR_REF(inp);
3797                         SCTP_INP_WUNLOCK(inp);
3798                 }
3799         }
3800         if (stcb != NULL) {
3801                 /* Already have or am bring up an association */
3802                 SCTP_ASOC_CREATE_UNLOCK(inp);
3803                 SCTP_TCB_UNLOCK(stcb);
3804                 crit_exit();
3805                 return (EALREADY);
3806         }
3807         /* We are GOOD to go */
3808         stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0);
3809         if (stcb == NULL) {
3810                 /* Gak! no memory */
3811                 crit_exit();
3812                 return (error);
3813         }
3814         if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
3815                 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
3816                 /* Set the connected flag so we can queue data */
3817                 soisconnecting(so);
3818         }
3819         stcb->asoc.state = SCTP_STATE_COOKIE_WAIT;
3820         SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
3821         sctp_send_initiate(inp, stcb);
3822         SCTP_ASOC_CREATE_UNLOCK(inp);
3823         SCTP_TCB_UNLOCK(stcb);
3824         crit_exit();
3825         return error;
3826 }
3827
3828 int
3829 sctp_usr_recvd(struct socket *so, int flags)
3830 {
3831         struct sctp_socket_q_list *sq=NULL;
3832         /*
3833          * The user has received some data, we may be able to stuff more
3834          * up the socket. And we need to possibly update the rwnd.
3835          */
3836         struct sctp_inpcb *inp;
3837         struct sctp_tcb *stcb=NULL;
3838
3839         inp = (struct sctp_inpcb *)so->so_pcb;
3840 #ifdef SCTP_DEBUG
3841         if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3842                 kprintf("Read for so:%x inp:%x Flags:%x\n",
3843                        (u_int)so, (u_int)inp, (u_int)flags);
3844 #endif
3845
3846         if (inp == 0) {
3847                 /* I made the same as TCP since we are not setup? */
3848 #ifdef SCTP_DEBUG
3849                 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3850                         kprintf("Nope, connection reset\n");
3851 #endif
3852                 return (ECONNRESET);
3853         }
3854         crit_enter();
3855         /*
3856          * Grab the first one on the list. It will re-insert itself if
3857          * it runs out of room
3858          */
3859         SCTP_INP_WLOCK(inp);
3860         if ((flags & MSG_EOR) && ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3861             && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3862                 /* Ok the other part of our grubby tracking
3863                  * stuff for our horrible layer violation that
3864                  * the tsvwg thinks is ok for sctp_peeloff.. gak!
3865                  * We must update the next vtag pending on the
3866                  * socket buffer (if any).
3867                  */
3868                 inp->sctp_vtag_first = sctp_get_first_vtag_from_sb(so);
3869                 sq = TAILQ_FIRST(&inp->sctp_queue_list);
3870                 if (sq) {
3871                         stcb = sq->tcb;
3872                 } else {
3873                         stcb = NULL;
3874                 }
3875         } else {
3876                 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3877         }
3878         if (stcb)
3879                 SCTP_TCB_LOCK(stcb);
3880         if (stcb) {
3881                 long incr;
3882                 /* all code in normal stcb path assumes
3883                  * that you have a tcb_lock only. Thus
3884                  * we must release the inp write lock.
3885                  */
3886                 if (flags & MSG_EOR) {
3887                         if (((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3888                            && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3889                                 stcb = sctp_remove_from_socket_q(inp);
3890                         }
3891 #ifdef SCTP_DEBUG
3892                         if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3893                                 kprintf("remove from socket queue for inp:%x tcbret:%x\n",
3894                                        (u_int)inp, (u_int)stcb);
3895 #endif
3896
3897                         stcb->asoc.my_rwnd_control_len = sctp_sbspace_sub(stcb->asoc.my_rwnd_control_len,
3898                                                                           sizeof(struct mbuf));
3899                         if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVDATAIOEVNT) {
3900                                 stcb->asoc.my_rwnd_control_len = sctp_sbspace_sub(stcb->asoc.my_rwnd_control_len,
3901                                                                                   CMSG_LEN(sizeof(struct sctp_sndrcvinfo)));
3902                         }
3903                 }
3904                 if ((TAILQ_EMPTY(&stcb->asoc.delivery_queue) == 0) ||
3905                     (TAILQ_EMPTY(&stcb->asoc.reasmqueue) == 0)) {
3906                         /* Deliver if there is something to be delivered */
3907                         sctp_service_queues(stcb, &stcb->asoc, 1);
3908                 }
3909                 sctp_set_rwnd(stcb, &stcb->asoc);
3910                 /* if we increase by 1 or more MTU's (smallest MTUs of all
3911                  * nets) we send a window update sack
3912                  */
3913                 incr = stcb->asoc.my_rwnd - stcb->asoc.my_last_reported_rwnd;
3914                 if (incr < 0) {
3915                         incr = 0;
3916                 }
3917                 if (((uint32_t)incr >= (stcb->asoc.smallest_mtu * SCTP_SEG_TO_RWND_UPD)) ||
3918                     ((((uint32_t)incr)*SCTP_SCALE_OF_RWND_TO_UPD) >= so->so_rcv.sb_hiwat)) {
3919                         if (callout_pending(&stcb->asoc.dack_timer.timer)) {
3920                                 /* If the timer is up, stop it */
3921                                 sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
3922                                                 stcb->sctp_ep, stcb, NULL);
3923                         }
3924                         /* Send the sack, with the new rwnd */
3925                         sctp_send_sack(stcb);
3926                         /* Now do the output */
3927                         sctp_chunk_output(inp, stcb, 10);
3928                 }
3929         } else {
3930                 if ((( sq ) && (flags & MSG_EOR) && ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0))
3931                     && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3932                         stcb = sctp_remove_from_socket_q(inp);
3933                 }
3934         }
3935         SOCKBUF_LOCK(&so->so_rcv);
3936         if (( so->so_rcv.sb_mb == NULL ) &&
3937             (TAILQ_EMPTY(&inp->sctp_queue_list) == 0)) {
3938                 int sq_cnt=0;
3939 #ifdef SCTP_DEBUG
3940                 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3941                         kprintf("Something off, inp:%x so->so_rcv->sb_mb is empty and sockq is not.. cleaning\n",
3942                                (u_int)inp);
3943 #endif
3944                 if (((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3945                    && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3946                         int done_yet;
3947                         done_yet = TAILQ_EMPTY(&inp->sctp_queue_list);
3948                         while (!done_yet) {
3949                                 sq_cnt++;
3950                                 sctp_remove_from_socket_q(inp);
3951                                 done_yet = TAILQ_EMPTY(&inp->sctp_queue_list);
3952                         }
3953                 }
3954 #ifdef SCTP_DEBUG
3955                 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3956                         kprintf("Cleaned up %d sockq's\n", sq_cnt);
3957 #endif
3958         }
3959         SOCKBUF_UNLOCK(&so->so_rcv);
3960         if (stcb)
3961                 SCTP_TCB_UNLOCK(stcb);
3962         SCTP_INP_WUNLOCK(inp);
3963         crit_exit();
3964         return (0);
3965 }
3966
3967 int
3968 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3969 sctp_listen(struct socket *so, struct thread *p)
3970 #else
3971 sctp_listen(struct socket *so, struct proc *p)
3972 #endif
3973 {
3974         /*
3975          * Note this module depends on the protocol processing being
3976          * called AFTER any socket level flags and backlog are applied
3977          * to the socket. The traditional way that the socket flags are
3978          * applied is AFTER protocol processing. We have made a change
3979          * to the sys/kern/uipc_socket.c module to reverse this but this
3980          * MUST be in place if the socket API for SCTP is to work properly.
3981          */
3982         int error = 0;
3983         struct sctp_inpcb *inp;
3984
3985         crit_enter();
3986         inp = (struct sctp_inpcb *)so->so_pcb;
3987         if (inp == 0) {
3988                 crit_exit();
3989                 /* I made the same as TCP since we are not setup? */
3990                 return (ECONNRESET);
3991         }
3992         SCTP_INP_RLOCK(inp);
3993         if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
3994             (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
3995                 /* We are already connected AND the TCP model */
3996                 crit_exit();
3997                 SCTP_INP_RUNLOCK(inp);
3998                 return (EADDRINUSE);
3999         }
4000         if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
4001                 /* We must do a bind. */
4002                 SCTP_INP_RUNLOCK(inp);
4003                 if ((error = sctp_inpcb_bind(so, NULL, p))) {
4004                         /* bind error, probably perm */
4005                         crit_exit();
4006                         return (error);
4007                 }
4008         } else {
4009                 SCTP_INP_RUNLOCK(inp);
4010         }
4011         SOCK_LOCK(so);
4012         SCTP_INP_WLOCK(inp);
4013         if (inp->sctp_socket->so_qlimit) {
4014                 if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
4015                         /*
4016                          * For the UDP model we must TURN OFF the ACCEPT
4017                          * flags since we do NOT allow the accept() call.
4018                          * The TCP model (when present) will do accept which
4019                          * then prohibits connect().
4020                          */
4021                         inp->sctp_socket->so_options &= ~SO_ACCEPTCONN;
4022                 }
4023                 inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
4024         } else {
4025                 if (inp->sctp_flags & SCTP_PCB_FLAGS_ACCEPTING) {
4026                         /*
4027                          * Turning off the listen flags if the backlog is
4028                          * set to 0 (i.e. qlimit is 0).
4029                          */
4030                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_ACCEPTING;
4031                 }
4032                 inp->sctp_socket->so_options &= ~SO_ACCEPTCONN;
4033         }
4034         SCTP_INP_WUNLOCK(inp);
4035         SOCK_UNLOCK(so);
4036         crit_exit();
4037         return (error);
4038 }
4039
4040 int
4041 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4042 sctp_accept(struct socket *so, struct sockaddr **addr)
4043 {
4044 #else
4045 sctp_accept(struct socket *so, struct mbuf *nam)
4046 {
4047         struct sockaddr *addr = mtod(nam, struct sockaddr *);
4048 #endif
4049         struct sctp_tcb *stcb;
4050         struct sockaddr *prim;
4051         struct sctp_inpcb *inp;
4052
4053         crit_enter();
4054         inp = (struct sctp_inpcb *)so->so_pcb;
4055
4056         if (inp == 0) {
4057                 crit_exit();
4058                 return (ECONNRESET);
4059         }
4060         SCTP_INP_RLOCK(inp);
4061         if (so->so_state & SS_ISDISCONNECTED) {
4062                 crit_exit();
4063                 SCTP_INP_RUNLOCK(inp);
4064                 return (ECONNABORTED);
4065         }
4066         stcb = LIST_FIRST(&inp->sctp_asoc_list);
4067         if (stcb == NULL) {
4068                 crit_exit();
4069                 SCTP_INP_RUNLOCK(inp);
4070                 return (ECONNRESET);
4071         }
4072         SCTP_TCB_LOCK(stcb);
4073         SCTP_INP_RUNLOCK(inp);
4074         prim = (struct sockaddr *)&stcb->asoc.primary_destination->ro._l_addr;
4075         if (prim->sa_family == AF_INET) {
4076                 struct sockaddr_in *sin;
4077 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4078                 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME,
4079                        M_WAITOK | M_ZERO);
4080 #else
4081                 sin = (struct sockaddr_in *)addr;
4082                 bzero((caddr_t)sin, sizeof (*sin));
4083 #endif
4084                 sin->sin_family = AF_INET;
4085                 sin->sin_len = sizeof(*sin);
4086                 sin->sin_port = ((struct sockaddr_in *)prim)->sin_port;
4087                 sin->sin_addr = ((struct sockaddr_in *)prim)->sin_addr;
4088 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4089                 *addr = (struct sockaddr *)sin;
4090 #else
4091                 nam->m_len = sizeof(*sin);
4092 #endif
4093         } else {
4094                 struct sockaddr_in6 *sin6;
4095 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4096                 MALLOC(sin6, struct sockaddr_in6 *, sizeof *sin6, M_SONAME,
4097                        M_WAITOK | M_ZERO);
4098 #else
4099                 sin6 = (struct sockaddr_in6 *)addr;
4100 #endif
4101                 bzero((caddr_t)sin6, sizeof (*sin6));
4102                 sin6->sin6_family = AF_INET6;
4103                 sin6->sin6_len = sizeof(*sin6);
4104                 sin6->sin6_port = ((struct sockaddr_in6 *)prim)->sin6_port;
4105
4106                 sin6->sin6_addr = ((struct sockaddr_in6 *)prim)->sin6_addr;
4107                 if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
4108                         /*      sin6->sin6_scope_id = ntohs(sin6->sin6_addr.s6_addr16[1]);*/
4109                         in6_recoverscope(sin6, &sin6->sin6_addr, NULL);  /* skip ifp check */
4110                 else
4111                         sin6->sin6_scope_id = 0;        /*XXX*/
4112 #if defined(__FreeBSD__) || defined (__APPLE__) || defined(__DragonFly__)
4113                 *addr= (struct sockaddr *)sin6;
4114 #else
4115                 nam->m_len = sizeof(*sin6);
4116 #endif
4117         }
4118         /* Wake any delayed sleep action */
4119         SCTP_TCB_UNLOCK(stcb);
4120         SCTP_INP_WLOCK(inp);
4121         if (inp->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE) {
4122                 inp->sctp_flags &= ~SCTP_PCB_FLAGS_DONT_WAKE;
4123                 if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT) {
4124                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEOUTPUT;
4125 #if defined(__NetBSD__)
4126                         if (sowritable(inp->sctp_socket))
4127                                 sowwakeup(inp->sctp_socket);
4128 #else
4129                         if (sowriteable(inp->sctp_socket))
4130                                 sowwakeup(inp->sctp_socket);
4131 #endif
4132                 }
4133                 if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT) {
4134                         inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEINPUT;
4135                         if (soreadable(inp->sctp_socket))
4136                                 sorwakeup(inp->sctp_socket);
4137                 }
4138
4139         }
4140         SCTP_INP_WUNLOCK(inp);
4141         crit_exit();
4142         return (0);
4143 }
4144
4145 int
4146 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4147 sctp_ingetaddr(struct socket *so, struct sockaddr **addr)
4148 #else
4149 sctp_ingetaddr(struct socket *so, struct mbuf *nam)
4150 #endif
4151 {
4152 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4153         struct sockaddr_in *sin;
4154 #else
4155         struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
4156 #endif
4157         struct sctp_inpcb *inp;
4158         /*
4159          * Do the malloc first in case it blocks.
4160          */
4161 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4162         MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK |
4163                M_ZERO);
4164 #else
4165         nam->m_len = sizeof(*sin);
4166         memset(sin, 0, sizeof(*sin));
4167 #endif
4168         sin->sin_family = AF_INET;
4169         sin->sin_len = sizeof(*sin);
4170         crit_enter();
4171         inp = (struct sctp_inpcb *)so->so_pcb;
4172         if (!inp) {
4173                 crit_exit();
4174 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4175                 FREE(sin, M_SONAME);
4176 #endif
4177                 return ECONNRESET;
4178         }
4179         SCTP_INP_RLOCK(inp);
4180         sin->sin_port = inp->sctp_lport;
4181         if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
4182                 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
4183                         struct sctp_tcb *stcb;
4184                         struct sockaddr_in *sin_a;
4185                         struct sctp_nets *net;
4186                         int fnd;
4187
4188                         stcb = LIST_FIRST(&inp->sctp_asoc_list);
4189                         if (stcb == NULL) {
4190                                 goto notConn;
4191                         }
4192                         fnd = 0;
4193                         sin_a = NULL;
4194                         SCTP_TCB_LOCK(stcb);
4195                         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
4196                                 sin_a = (struct sockaddr_in *)&net->ro._l_addr;
4197                                 if (sin_a->sin_family == AF_INET) {
4198                                         fnd = 1;
4199                                         break;
4200                                 }
4201                         }
4202                         if ((!fnd) || (sin_a == NULL)) {
4203                                 /* punt */
4204                                 SCTP_TCB_UNLOCK(stcb);
4205                                 goto notConn;
4206                         }
4207                         sin->sin_addr = sctp_ipv4_source_address_selection(inp,
4208                             stcb, (struct route *)&net->ro, net, 0);
4209                         SCTP_TCB_UNLOCK(stcb);
4210                 } else {
4211                         /* For the bound all case you get back 0 */
4212                 notConn:
4213                         sin->sin_addr.s_addr = 0;
4214                 }
4215
4216         } else {
4217                 /* Take the first IPv4 address in the list */
4218                 struct sctp_laddr *laddr;
4219                 int fnd = 0;
4220                 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
4221                         if (laddr->ifa->ifa_addr->sa_family == AF_INET) {
4222                                 struct sockaddr_in *sin_a;
4223                                 sin_a = (struct sockaddr_in *)laddr->ifa->ifa_addr;
4224                                 sin->sin_addr = sin_a->sin_addr;
4225                                 fnd = 1;
4226                                 break;
4227                         }
4228                 }
4229                 if (!fnd) {
4230                         crit_exit();
4231 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4232                         FREE(sin, M_SONAME);
4233 #endif
4234                         SCTP_INP_RUNLOCK(inp);
4235                         return ENOENT;
4236                 }
4237         }
4238         SCTP_INP_RUNLOCK(inp);
4239         crit_exit();
4240 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4241         (*addr) = (struct sockaddr *)sin;
4242 #endif
4243         return (0);
4244 }
4245
4246 int
4247 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4248 sctp_peeraddr(struct socket *so, struct sockaddr **addr)
4249 {
4250         struct sockaddr_in *sin = (struct sockaddr_in *)*addr;
4251 #else
4252 sctp_peeraddr(struct socket *so, struct mbuf *nam)
4253 {
4254         struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
4255 #endif
4256         int fnd;
4257         struct sockaddr_in *sin_a;
4258         struct sctp_inpcb *inp;
4259         struct sctp_tcb *stcb;
4260         struct sctp_nets *net;
4261
4262         /* Do the malloc first in case it blocks. */
4263         inp = (struct sctp_inpcb *)so->so_pcb;
4264         if ((inp == NULL) ||
4265             ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
4266                 /* UDP type and listeners will drop out here */
4267                 return (ENOTCONN);
4268         }
4269         crit_enter();
4270
4271 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4272         MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK |
4273                M_ZERO);
4274 #else
4275         nam->m_len = sizeof(*sin);
4276         memset(sin, 0, sizeof(*sin));
4277 #endif
4278         sin->sin_family = AF_INET;
4279         sin->sin_len = sizeof(*sin);
4280
4281         /* We must recapture incase we blocked */
4282         inp = (struct sctp_inpcb *)so->so_pcb;
4283         if (!inp) {
4284                 crit_exit();
4285 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4286                 FREE(sin, M_SONAME);
4287 #endif
4288                 return ECONNRESET;
4289         }
4290         SCTP_INP_RLOCK(inp);
4291         stcb = LIST_FIRST(&inp->sctp_asoc_list);
4292         if (stcb)
4293                 SCTP_TCB_LOCK(stcb);
4294         SCTP_INP_RUNLOCK(inp);
4295         if (stcb == NULL) {
4296                 crit_exit();
4297 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4298                 FREE(sin, M_SONAME);
4299 #endif
4300                 return ECONNRESET;
4301         }
4302         fnd = 0;
4303         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
4304                 sin_a = (struct sockaddr_in *)&net->ro._l_addr;
4305                 if (sin_a->sin_family == AF_INET) {
4306                         fnd = 1;
4307                         sin->sin_port = stcb->rport;
4308                         sin->sin_addr = sin_a->sin_addr;
4309                         break;
4310                 }
4311         }
4312         SCTP_TCB_UNLOCK(stcb);
4313         if (!fnd) {
4314                 /* No IPv4 address */
4315                 crit_exit();
4316 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4317                 FREE(sin, M_SONAME);
4318 #endif
4319                 return ENOENT;
4320         }
4321         crit_exit();
4322         return (0);
4323 }
4324
4325 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4326 struct pr_usrreqs sctp_usrreqs = {
4327         sctp_abort,
4328         sctp_accept,
4329         sctp_attach,
4330         sctp_bind,
4331         sctp_connect,
4332         pru_connect2_notsupp,
4333         in_control,
4334         sctp_detach,
4335         sctp_disconnect,
4336         sctp_listen,
4337         sctp_peeraddr,
4338         sctp_usr_recvd,
4339         pru_rcvoob_notsupp,
4340         sctp_send,
4341         pru_sense_null,
4342         sctp_shutdown,
4343         sctp_ingetaddr,
4344         sctp_sosend,
4345         soreceive,
4346         sopoll
4347 };
4348
4349 #else
4350 #if defined(__NetBSD__)
4351 int
4352 sctp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
4353             struct mbuf *control, struct proc *p)
4354 {
4355 #else
4356 int
4357 sctp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
4358             struct mbuf *control)
4359 {
4360         struct proc *p = curproc;
4361 #endif
4362         int error = 0;
4363         int family;
4364
4365         family = so->so_proto->pr_domain->dom_family;
4366
4367         crit_enter();
4368         if (req == PRU_CONTROL) {
4369                 switch (family) {
4370                 case PF_INET:
4371                         error = in_control(so, (long)m, (caddr_t)nam,
4372                             (struct ifnet *)control
4373 #if defined(__NetBSD__)
4374                             , p
4375 #endif
4376                             );
4377                         break;
4378 #ifdef INET6
4379                 case PF_INET6:
4380                         error = in6_control(so, (long)m, (caddr_t)nam,
4381                             (struct ifnet *)control, p);
4382                         break;
4383 #endif
4384                 default:
4385                         error =  EAFNOSUPPORT;
4386                 }
4387                 crit_exit();
4388                 return (error);
4389         }
4390 #ifdef __NetBSD__
4391         if (req == PRU_PURGEIF) {
4392                 struct ifnet *ifn;
4393                 struct ifaddr *ifa;
4394                 ifn = (struct ifnet *)control;
4395                 TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) {
4396                         if (ifa->ifa_addr->sa_family == family) {
4397                                 sctp_delete_ip_address(ifa);
4398                         }
4399                 }
4400                 switch (family) {
4401                 case PF_INET:
4402                         in_purgeif (ifn);
4403                         break;
4404 #ifdef INET6
4405                 case PF_INET6:
4406                         in6_purgeif (ifn);
4407                         break;
4408 #endif /* INET6 */
4409                 default:
4410                         crit_exit();
4411                         return (EAFNOSUPPORT);
4412                 }
4413                 crit_exit();
4414                 return (0);
4415         }
4416 #endif
4417         switch (req) {
4418         case PRU_ATTACH:
4419                 error = sctp_attach(so, family, p);
4420                 break;
4421         case PRU_DETACH:
4422                 error = sctp_detach(so);
4423                 break;
4424         case PRU_BIND:
4425                 if (nam == NULL) {
4426                         crit_exit();
4427                         return (EINVAL);
4428                 }
4429                 error  = sctp_bind(so, nam, p);
4430                 break;
4431         case PRU_LISTEN:
4432                 error = sctp_listen(so, p);
4433                 break;
4434         case PRU_CONNECT:
4435                 if (nam == NULL) {
4436                         crit_exit();
4437                         return (EINVAL);
4438                 }
4439                 error = sctp_connect(so, nam, p);
4440                 break;
4441         case PRU_DISCONNECT:
4442                 error = sctp_disconnect(so);
4443                 break;
4444         case PRU_ACCEPT:
4445                 if (nam == NULL) {
4446                         crit_exit();
4447                         return (EINVAL);
4448                 }
4449                 error = sctp_accept(so, nam);
4450         break;
4451         case PRU_SHUTDOWN:
4452                 error = sctp_shutdown(so);
4453                 break;
4454
4455         case PRU_RCVD:
4456                 /*
4457                  * For Open and Net BSD, this is real
4458                  * ugly. The mbuf *nam that is passed
4459                  * (by soreceive()) is the int flags c
4460                  * ast as a (mbuf *) yuck!
4461                  */
4462                 error = sctp_usr_recvd(so, (int)((long)nam));
4463                 break;
4464
4465         case PRU_SEND:
4466                 /* Flags are ignored */
4467 #ifdef SCTP_DEBUG
4468                 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
4469                         kprintf("Send called on V4 side\n");
4470                 }
4471 #endif
4472                 {
4473                     struct sockaddr *addr;
4474                     if (nam == NULL)
4475                         addr = NULL;
4476                     else
4477                         addr = mtod(nam, struct sockaddr *);
4478
4479                     error = sctp_send(so, 0, m, addr, control, p);
4480                 }
4481                 break;
4482         case PRU_ABORT:
4483                 error = sctp_abort(so);
4484                 break;
4485
4486         case PRU_SENSE:
4487                 error = 0;
4488                 break;
4489         case PRU_RCVOOB:
4490                 error = EAFNOSUPPORT;
4491                 break;
4492         case PRU_SENDOOB:
4493                 error = EAFNOSUPPORT;
4494                 break;
4495         case PRU_PEERADDR:
4496                 error = sctp_peeraddr(so, nam);
4497                 break;
4498         case PRU_SOCKADDR:
4499                 error = sctp_ingetaddr(so, nam);
4500                 break;
4501         case PRU_SLOWTIMO:
4502                 error = 0;
4503                 break;
4504         default:
4505                 break;
4506         }
4507         crit_exit();
4508         return (error);
4509 }
4510 #endif
4511
4512 /* #if defined(__NetBSD__) || defined(__OpenBSD__) */
4513 #if __OpenBSD__
4514 /*
4515  * Sysctl for sctp variables.
4516  */
4517 int
4518 sctp_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
4519             size_t newlen)
4520 {
4521
4522         /* All sysctl names at this level are terminal. */
4523         if (namelen != 1)
4524                 return (ENOTDIR);
4525 sysctl_int();
4526
4527         switch (name[0]) {
4528         case SCTPCTL_MAXDGRAM:
4529                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4530                      &sctp_sendspace));
4531         case SCTPCTL_RECVSPACE:
4532                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4533                     &sctp_recvspace));
4534         case SCTPCTL_AUTOASCONF:
4535                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4536                     &sctp_auto_asconf));
4537         case SCTPCTL_ECN_ENABLE:
4538                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4539                                    &sctp_ecn));
4540         case SCTPCTL_ECN_NONCE:
4541                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4542                                    &sctp_ecn_nonce));
4543         case SCTPCTL_STRICT_SACK:
4544                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4545                                    &sctp_strict_sacks));
4546         case SCTPCTL_NOCSUM_LO:
4547                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4548                                    &sctp_no_csum_on_loopback));
4549         case SCTPCTL_STRICT_INIT:
4550                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4551                                    &sctp_strict_init));
4552         case SCTPCTL_PEER_CHK_OH:
4553                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4554                                    &sctp_peer_chunk_oh));
4555         case SCTPCTL_MAXBURST:
4556                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4557                                    &sctp_max_burst_default));
4558         case SCTPCTL_MAXCHUNKONQ:
4559                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4560                                    &sctp_max_chunks_on_queue));
4561         case SCTPCTL_DELAYED_SACK:
4562                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4563                                    &sctp_delayed_sack_time_default));
4564         case SCTPCTL_HB_INTERVAL:
4565                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4566                                    &sctp_heartbeat_interval_default));
4567         case SCTPCTL_PMTU_RAISE:
4568                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4569                                    &sctp_pmtu_raise_time_default));
4570         case SCTPCTL_SHUTDOWN_GUARD:
4571                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4572                                    &sctp_shutdown_guard_time_default));
4573         case SCTPCTL_SECRET_LIFETIME:
4574                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4575                                    &sctp_secret_lifetime_default));
4576         case SCTPCTL_RTO_MAX:
4577                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4578                                    &sctp_rto_max_default));
4579         case SCTPCTL_RTO_MIN:
4580                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4581                                    &sctp_rto_min_default));
4582         case SCTPCTL_RTO_INITIAL:
4583                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4584                                    &sctp_rto_initial_default));
4585         case SCTPCTL_INIT_RTO_MAX:
4586                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4587                                    &sctp_init_rto_max_default));
4588         case SCTPCTL_COOKIE_LIFE:
4589                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4590                                    &sctp_valid_cookie_life_default));
4591         case SCTPCTL_INIT_RTX_MAX:
4592                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4593                                    &sctp_init_rtx_max_default));
4594         case SCTPCTL_ASSOC_RTX_MAX:
4595                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4596                                    &sctp_assoc_rtx_max_default));
4597         case SCTPCTL_PATH_RTX_MAX:
4598                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4599                                    &sctp_path_rtx_max_default));
4600         case SCTPCTL_NR_OUTGOING_STREAMS:
4601                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4602                                    &sctp_nr_outgoing_streams_default));
4603 #ifdef SCTP_DEBUG
4604         case SCTPCTL_DEBUG:
4605                 return (sysctl_int(oldp, oldlenp, newp, newlen,
4606                                    &sctp_debug_on));
4607 #endif
4608         default:
4609                 return (ENOPROTOOPT);
4610         }
4611         /* NOTREACHED */
4612 }
4613 #endif
4614 #if __NetBSD__
4615 /*
4616  * Sysctl for sctp variables.
4617  */
4618 SYSCTL_SETUP(sysctl_net_inet_sctp_setup, "sysctl net.inet.sctp subtree setup")
4619 {
4620
4621         sysctl_createv(clog, 0, NULL, NULL,
4622                        CTLFLAG_PERMANENT,
4623                        CTLTYPE_NODE, "net", NULL,
4624                        NULL, 0, NULL, 0,
4625                        CTL_NET, CTL_EOL);
4626         sysctl_createv(clog, 0, NULL, NULL,
4627                        CTLFLAG_PERMANENT,
4628                        CTLTYPE_NODE, "inet", NULL,
4629                        NULL, 0, NULL, 0,
4630                        CTL_NET, PF_INET, CTL_EOL);
4631         sysctl_createv(clog, 0, NULL, NULL,
4632                        CTLFLAG_PERMANENT,
4633                        CTLTYPE_NODE, "sctp",
4634                        SYSCTL_DESCR("sctp related settings"),
4635                        NULL, 0, NULL, 0,
4636                        CTL_NET, PF_INET, IPPROTO_SCTP, CTL_EOL);
4637
4638        sysctl_createv(clog, 0, NULL, NULL,
4639                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4640                        CTLTYPE_INT, "maxdgram",
4641                        SYSCTL_DESCR("Maximum outgoing SCTP buffer size"),
4642                        NULL, 0, &sctp_sendspace, 0,
4643                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXDGRAM,
4644                        CTL_EOL);
4645
4646        sysctl_createv(clog, 0, NULL, NULL,
4647                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4648                        CTLTYPE_INT, "recvspace",
4649                        SYSCTL_DESCR("Maximum incoming SCTP buffer size"),
4650                        NULL, 0, &sctp_recvspace, 0,
4651                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_RECVSPACE,
4652                        CTL_EOL);
4653
4654        sysctl_createv(clog, 0, NULL, NULL,
4655                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4656                        CTLTYPE_INT, "autoasconf",
4657                        SYSCTL_DESCR("Enable SCTP Auto-ASCONF"),
4658                        NULL, 0, &sctp_auto_asconf, 0,
4659                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_AUTOASCONF,
4660                        CTL_EOL);
4661
4662        sysctl_createv(clog, 0, NULL, NULL,
4663                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4664                        CTLTYPE_INT, "ecn_enable",
4665                        SYSCTL_DESCR("Enable SCTP ECN"),
4666                        NULL, 0, &sctp_ecn, 0,
4667                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_ECN_ENABLE,
4668                        CTL_EOL);
4669
4670        sysctl_createv(clog, 0, NULL, NULL,
4671                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4672                        CTLTYPE_INT, "ecn_nonce",
4673                        SYSCTL_DESCR("Enable SCTP ECN Nonce"),
4674                        NULL, 0, &sctp_ecn_nonce, 0,
4675                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_ECN_NONCE,
4676                        CTL_EOL);
4677
4678        sysctl_createv(clog, 0, NULL, NULL,
4679                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4680                        CTLTYPE_INT, "strict_sack",
4681                        SYSCTL_DESCR("Enable SCTP Strict SACK checking"),
4682                        NULL, 0, &sctp_strict_sacks, 0,
4683                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_STRICT_SACK,
4684                        CTL_EOL);
4685
4686        sysctl_createv(clog, 0, NULL, NULL,
4687                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4688                        CTLTYPE_INT, "loopback_nocsum",
4689                        SYSCTL_DESCR("Enable NO Csum on packets sent on loopback"),
4690                        NULL, 0, &sctp_no_csum_on_loopback, 0,
4691                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_NOCSUM_LO,
4692                        CTL_EOL);
4693
4694        sysctl_createv(clog, 0, NULL, NULL,
4695                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4696                        CTLTYPE_INT, "strict_init",
4697                        SYSCTL_DESCR("Enable strict INIT/INIT-ACK singleton enforcement"),
4698                        NULL, 0, &sctp_strict_init, 0,
4699                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_STRICT_INIT,
4700                        CTL_EOL);
4701
4702        sysctl_createv(clog, 0, NULL, NULL,
4703                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4704                        CTLTYPE_INT, "peer_chkoh",
4705                        SYSCTL_DESCR("Amount to debit peers rwnd per chunk sent"),
4706                        NULL, 0, &sctp_peer_chunk_oh, 0,
4707                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_PEER_CHK_OH,
4708                        CTL_EOL);
4709
4710        sysctl_createv(clog, 0, NULL, NULL,
4711                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4712                        CTLTYPE_INT, "maxburst",
4713                        SYSCTL_DESCR("Default max burst for sctp endpoints"),
4714                        NULL, 0, &sctp_max_burst_default, 0,
4715                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXBURST,
4716                        CTL_EOL);
4717
4718        sysctl_createv(clog, 0, NULL, NULL,
4719                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4720                        CTLTYPE_INT, "maxchunks",
4721                        SYSCTL_DESCR("Default max chunks on queue per asoc"),
4722                        NULL, 0, &sctp_max_chunks_on_queue, 0,
4723                        CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXCHUNKONQ,
4724                        CTL_EOL);
4725
4726 }
4727 #endif