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