17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
545916cd2Sjpk  * Common Development and Distribution License (the "License").
645916cd2Sjpk  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2177c67f2fSkcpoon 
227c478bd9Sstevel@tonic-gate /*
237cae9885SAnders Persson  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate #include <sys/types.h>
287c478bd9Sstevel@tonic-gate #include <sys/stream.h>
297c478bd9Sstevel@tonic-gate #define	_SUN_TPI_VERSION 2
307c478bd9Sstevel@tonic-gate #include <sys/tihdr.h>
317c478bd9Sstevel@tonic-gate #include <sys/socket.h>
327c478bd9Sstevel@tonic-gate #include <sys/xti_inet.h>
337c478bd9Sstevel@tonic-gate #include <sys/systm.h>
347c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
357c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
367c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
377c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
387c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
397c478bd9Sstevel@tonic-gate #include <sys/policy.h>
407c478bd9Sstevel@tonic-gate 
417c478bd9Sstevel@tonic-gate #include <inet/common.h>
427c478bd9Sstevel@tonic-gate #include <netinet/ip6.h>
437c478bd9Sstevel@tonic-gate #include <inet/ip.h>
447c478bd9Sstevel@tonic-gate #include <inet/ip_ire.h>
4543d18f1cSpriyanka #include <inet/ip_if.h>
46bd670b35SErik Nordmark #include <inet/proto_set.h>
477c478bd9Sstevel@tonic-gate #include <inet/ipclassifier.h>
487c478bd9Sstevel@tonic-gate #include <inet/ipsec_impl.h>
497c478bd9Sstevel@tonic-gate 
507c478bd9Sstevel@tonic-gate #include <netinet/in.h>
517c478bd9Sstevel@tonic-gate #include <netinet/ip.h>
527c478bd9Sstevel@tonic-gate #include <netinet/tcp.h>
537c478bd9Sstevel@tonic-gate 
547c478bd9Sstevel@tonic-gate #include <inet/common.h>
557c478bd9Sstevel@tonic-gate #include <inet/ip.h>
567c478bd9Sstevel@tonic-gate #include <inet/ip6.h>
577c478bd9Sstevel@tonic-gate #include <inet/sctp_itf.h>
587c478bd9Sstevel@tonic-gate #include "sctp_impl.h"
597c478bd9Sstevel@tonic-gate #include "sctp_asconf.h"
607c478bd9Sstevel@tonic-gate #include "sctp_addr.h"
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate static int	sctp_getpeeraddrs(sctp_t *, void *, int *);
637c478bd9Sstevel@tonic-gate 
647c478bd9Sstevel@tonic-gate static int
657c478bd9Sstevel@tonic-gate sctp_get_status(sctp_t *sctp, void *ptr)
667c478bd9Sstevel@tonic-gate {
677c478bd9Sstevel@tonic-gate 	struct sctp_status *sstat = ptr;
687c478bd9Sstevel@tonic-gate 	sctp_faddr_t *fp;
697c478bd9Sstevel@tonic-gate 	struct sockaddr_in *sin;
707c478bd9Sstevel@tonic-gate 	struct sockaddr_in6 *sin6;
717c478bd9Sstevel@tonic-gate 	struct sctp_paddrinfo *sp;
727c478bd9Sstevel@tonic-gate 	mblk_t *meta, *mp;
737c478bd9Sstevel@tonic-gate 	int i;
74bd670b35SErik Nordmark 	conn_t	*connp = sctp->sctp_connp;
757c478bd9Sstevel@tonic-gate 
767c478bd9Sstevel@tonic-gate 	sstat->sstat_state = sctp->sctp_state;
777c478bd9Sstevel@tonic-gate 	sstat->sstat_rwnd = sctp->sctp_frwnd;
787c478bd9Sstevel@tonic-gate 
797c478bd9Sstevel@tonic-gate 	sp = &sstat->sstat_primary;
807c478bd9Sstevel@tonic-gate 	if (!sctp->sctp_primary) {
817c478bd9Sstevel@tonic-gate 		bzero(sp, sizeof (*sp));
827c478bd9Sstevel@tonic-gate 		goto noprim;
837c478bd9Sstevel@tonic-gate 	}
847c478bd9Sstevel@tonic-gate 	fp = sctp->sctp_primary;
857c478bd9Sstevel@tonic-gate 
867c478bd9Sstevel@tonic-gate 	if (fp->isv4) {
877c478bd9Sstevel@tonic-gate 		sin = (struct sockaddr_in *)&sp->spinfo_address;
887c478bd9Sstevel@tonic-gate 		sin->sin_family = AF_INET;
89bd670b35SErik Nordmark 		sin->sin_port = connp->conn_fport;
907c478bd9Sstevel@tonic-gate 		IN6_V4MAPPED_TO_INADDR(&fp->faddr, &sin->sin_addr);
917c478bd9Sstevel@tonic-gate 		sp->spinfo_mtu = sctp->sctp_hdr_len;
927c478bd9Sstevel@tonic-gate 	} else {
937c478bd9Sstevel@tonic-gate 		sin6 = (struct sockaddr_in6 *)&sp->spinfo_address;
947c478bd9Sstevel@tonic-gate 		sin6->sin6_family = AF_INET6;
95bd670b35SErik Nordmark 		sin6->sin6_port = connp->conn_fport;
967c478bd9Sstevel@tonic-gate 		sin6->sin6_addr = fp->faddr;
977c478bd9Sstevel@tonic-gate 		sp->spinfo_mtu = sctp->sctp_hdr6_len;
987c478bd9Sstevel@tonic-gate 	}
997c478bd9Sstevel@tonic-gate 	sp->spinfo_state = fp->state == SCTP_FADDRS_ALIVE ? SCTP_ACTIVE :
1007c478bd9Sstevel@tonic-gate 	    SCTP_INACTIVE;
1017c478bd9Sstevel@tonic-gate 	sp->spinfo_cwnd = fp->cwnd;
1027c478bd9Sstevel@tonic-gate 	sp->spinfo_srtt = fp->srtt;
1037c478bd9Sstevel@tonic-gate 	sp->spinfo_rto = fp->rto;
1047c478bd9Sstevel@tonic-gate 	sp->spinfo_mtu += fp->sfa_pmss;
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate noprim:
1077c478bd9Sstevel@tonic-gate 	sstat->sstat_unackdata = 0;
1087c478bd9Sstevel@tonic-gate 	sstat->sstat_penddata = 0;
1097c478bd9Sstevel@tonic-gate 	sstat->sstat_instrms = sctp->sctp_num_istr;
1107c478bd9Sstevel@tonic-gate 	sstat->sstat_outstrms = sctp->sctp_num_ostr;
1117c478bd9Sstevel@tonic-gate 	sstat->sstat_fragmentation_point = sctp->sctp_mss -
1127c478bd9Sstevel@tonic-gate 	    sizeof (sctp_data_hdr_t);
1137c478bd9Sstevel@tonic-gate 
1147c478bd9Sstevel@tonic-gate 	/* count unack'd */
1157c478bd9Sstevel@tonic-gate 	for (meta = sctp->sctp_xmit_head; meta; meta = meta->b_next) {
1167c478bd9Sstevel@tonic-gate 		for (mp = meta->b_cont; mp; mp = mp->b_next) {
1177c478bd9Sstevel@tonic-gate 			if (!SCTP_CHUNK_ISSENT(mp)) {
1187c478bd9Sstevel@tonic-gate 				break;
1197c478bd9Sstevel@tonic-gate 			}
1207c478bd9Sstevel@tonic-gate 			if (!SCTP_CHUNK_ISACKED(mp)) {
1217c478bd9Sstevel@tonic-gate 				sstat->sstat_unackdata++;
1227c478bd9Sstevel@tonic-gate 			}
1237c478bd9Sstevel@tonic-gate 		}
1247c478bd9Sstevel@tonic-gate 	}
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate 	/*
1277c478bd9Sstevel@tonic-gate 	 * Count penddata chunks. We can only count chunks in SCTP (not
1287c478bd9Sstevel@tonic-gate 	 * data already delivered to socket layer).
1297c478bd9Sstevel@tonic-gate 	 */
1307c478bd9Sstevel@tonic-gate 	if (sctp->sctp_instr != NULL) {
1317c478bd9Sstevel@tonic-gate 		for (i = 0; i < sctp->sctp_num_istr; i++) {
1327c478bd9Sstevel@tonic-gate 			for (meta = sctp->sctp_instr[i].istr_reass;
1337c478bd9Sstevel@tonic-gate 			    meta != NULL; meta = meta->b_next) {
1347c478bd9Sstevel@tonic-gate 				for (mp = meta->b_cont; mp; mp = mp->b_cont) {
1357c478bd9Sstevel@tonic-gate 					if (DB_TYPE(mp) != M_CTL) {
1367c478bd9Sstevel@tonic-gate 						sstat->sstat_penddata++;
1377c478bd9Sstevel@tonic-gate 					}
1387c478bd9Sstevel@tonic-gate 				}
1397c478bd9Sstevel@tonic-gate 			}
1407c478bd9Sstevel@tonic-gate 		}
1417c478bd9Sstevel@tonic-gate 	}
1427c478bd9Sstevel@tonic-gate 	/* Un-Ordered Frag list */
1437c478bd9Sstevel@tonic-gate 	for (meta = sctp->sctp_uo_frags; meta != NULL; meta = meta->b_next)
1447c478bd9Sstevel@tonic-gate 		sstat->sstat_penddata++;
1457c478bd9Sstevel@tonic-gate 
1467c478bd9Sstevel@tonic-gate 	return (sizeof (*sstat));
1477c478bd9Sstevel@tonic-gate }
1487c478bd9Sstevel@tonic-gate 
1497c478bd9Sstevel@tonic-gate /*
1507c478bd9Sstevel@tonic-gate  * SCTP_GET_PEER_ADDR_INFO
1517c478bd9Sstevel@tonic-gate  */
1527c478bd9Sstevel@tonic-gate static int
1537c478bd9Sstevel@tonic-gate sctp_get_paddrinfo(sctp_t *sctp, void *ptr, socklen_t *optlen)
1547c478bd9Sstevel@tonic-gate {
1557c478bd9Sstevel@tonic-gate 	struct sctp_paddrinfo	*infop = ptr;
1567c478bd9Sstevel@tonic-gate 	struct sockaddr_in	*sin4;
1577c478bd9Sstevel@tonic-gate 	struct sockaddr_in6	*sin6;
1587c478bd9Sstevel@tonic-gate 	in6_addr_t		faddr;
1597c478bd9Sstevel@tonic-gate 	sctp_faddr_t		*fp;
1607c478bd9Sstevel@tonic-gate 
1617c478bd9Sstevel@tonic-gate 	switch (infop->spinfo_address.ss_family) {
1627c478bd9Sstevel@tonic-gate 	case AF_INET:
1637c478bd9Sstevel@tonic-gate 		sin4 = (struct sockaddr_in *)&infop->spinfo_address;
1647c478bd9Sstevel@tonic-gate 		IN6_INADDR_TO_V4MAPPED(&sin4->sin_addr, &faddr);
1657c478bd9Sstevel@tonic-gate 		break;
1667c478bd9Sstevel@tonic-gate 	case AF_INET6:
1677c478bd9Sstevel@tonic-gate 		sin6 = (struct sockaddr_in6 *)&infop->spinfo_address;
1687c478bd9Sstevel@tonic-gate 		faddr = sin6->sin6_addr;
1697c478bd9Sstevel@tonic-gate 		break;
1707c478bd9Sstevel@tonic-gate 	default:
1717c478bd9Sstevel@tonic-gate 		return (EAFNOSUPPORT);
1727c478bd9Sstevel@tonic-gate 	}
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate 	if ((fp = sctp_lookup_faddr(sctp, &faddr)) == NULL)
1757c478bd9Sstevel@tonic-gate 		return (EINVAL);
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate 	infop->spinfo_state = (fp->state == SCTP_FADDRS_ALIVE) ? SCTP_ACTIVE :
1787c478bd9Sstevel@tonic-gate 	    SCTP_INACTIVE;
1797c478bd9Sstevel@tonic-gate 	infop->spinfo_cwnd = fp->cwnd;
1807c478bd9Sstevel@tonic-gate 	infop->spinfo_srtt = TICK_TO_MSEC(fp->srtt);
1817c478bd9Sstevel@tonic-gate 	infop->spinfo_rto = TICK_TO_MSEC(fp->rto);
1827c478bd9Sstevel@tonic-gate 	infop->spinfo_mtu = fp->sfa_pmss;
1837c478bd9Sstevel@tonic-gate 
1847c478bd9Sstevel@tonic-gate 	*optlen = sizeof (struct sctp_paddrinfo);
1857c478bd9Sstevel@tonic-gate 	return (0);
1867c478bd9Sstevel@tonic-gate }
1877c478bd9Sstevel@tonic-gate 
1887c478bd9Sstevel@tonic-gate /*
1897c478bd9Sstevel@tonic-gate  * SCTP_RTOINFO
1907c478bd9Sstevel@tonic-gate  */
1917c478bd9Sstevel@tonic-gate static int
1927c478bd9Sstevel@tonic-gate sctp_get_rtoinfo(sctp_t *sctp, void *ptr)
1937c478bd9Sstevel@tonic-gate {
1947c478bd9Sstevel@tonic-gate 	struct sctp_rtoinfo *srto = ptr;
1957c478bd9Sstevel@tonic-gate 
1967c478bd9Sstevel@tonic-gate 	srto->srto_initial = TICK_TO_MSEC(sctp->sctp_rto_initial);
1977c478bd9Sstevel@tonic-gate 	srto->srto_max = TICK_TO_MSEC(sctp->sctp_rto_max);
1987c478bd9Sstevel@tonic-gate 	srto->srto_min = TICK_TO_MSEC(sctp->sctp_rto_min);
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate 	return (sizeof (*srto));
2017c478bd9Sstevel@tonic-gate }
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate static int
204bd670b35SErik Nordmark sctp_set_rtoinfo(sctp_t *sctp, const void *invalp)
2057c478bd9Sstevel@tonic-gate {
2067c478bd9Sstevel@tonic-gate 	const struct sctp_rtoinfo *srto;
2077c478bd9Sstevel@tonic-gate 	boolean_t ispriv;
208f4b3ec61Sdh 	sctp_stack_t	*sctps = sctp->sctp_sctps;
209bd670b35SErik Nordmark 	conn_t		*connp = sctp->sctp_connp;
210*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	uint32_t	new_min, new_max;
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate 	srto = invalp;
2137c478bd9Sstevel@tonic-gate 
214bd670b35SErik Nordmark 	ispriv = secpolicy_ip_config(connp->conn_cred, B_TRUE) == 0;
2157c478bd9Sstevel@tonic-gate 
2167c478bd9Sstevel@tonic-gate 	/*
2177c478bd9Sstevel@tonic-gate 	 * Bounds checking.  Priviledged user can set the RTO initial
2187c478bd9Sstevel@tonic-gate 	 * outside the ndd boundary.
2197c478bd9Sstevel@tonic-gate 	 */
2207c478bd9Sstevel@tonic-gate 	if (srto->srto_initial != 0 &&
221f4b3ec61Sdh 	    (!ispriv && (srto->srto_initial < sctps->sctps_rto_initialg_low ||
222b34b8d1aSkcpoon 	    srto->srto_initial > sctps->sctps_rto_initialg_high))) {
2237c478bd9Sstevel@tonic-gate 		return (EINVAL);
2247c478bd9Sstevel@tonic-gate 	}
2257c478bd9Sstevel@tonic-gate 	if (srto->srto_max != 0 &&
226f4b3ec61Sdh 	    (!ispriv && (srto->srto_max < sctps->sctps_rto_maxg_low ||
227b34b8d1aSkcpoon 	    srto->srto_max > sctps->sctps_rto_maxg_high))) {
2287c478bd9Sstevel@tonic-gate 		return (EINVAL);
2297c478bd9Sstevel@tonic-gate 	}
2307c478bd9Sstevel@tonic-gate 	if (srto->srto_min != 0 &&
231f4b3ec61Sdh 	    (!ispriv && (srto->srto_min < sctps->sctps_rto_ming_low ||
232b34b8d1aSkcpoon 	    srto->srto_min > sctps->sctps_rto_ming_high))) {
2337c478bd9Sstevel@tonic-gate 		return (EINVAL);
2347c478bd9Sstevel@tonic-gate 	}
2357c478bd9Sstevel@tonic-gate 
236*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	new_min = (srto->srto_min != 0) ? srto->srto_min : sctp->sctp_rto_min;
237*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	new_max = (srto->srto_max != 0) ? srto->srto_max : sctp->sctp_rto_max;
238*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	if (new_max < new_min) {
239*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 		return (EINVAL);
240*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	}
241*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 
2427c478bd9Sstevel@tonic-gate 	if (srto->srto_initial != 0) {
2437c478bd9Sstevel@tonic-gate 		sctp->sctp_rto_initial = MSEC_TO_TICK(srto->srto_initial);
2447c478bd9Sstevel@tonic-gate 	}
245*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 
246*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 	/* Ensure that sctp_rto_max will never be zero. */
2477c478bd9Sstevel@tonic-gate 	if (srto->srto_max != 0) {
248*05cdb43cSchandrasekar marimuthu - Sun Microsystems - Bangalore India 		sctp->sctp_rto_max = MAX(MSEC_TO_TICK(srto->srto_max), 1);
2497c478bd9Sstevel@tonic-gate 	}
2507c478bd9Sstevel@tonic-gate 	if (srto->srto_min != 0) {
2517c478bd9Sstevel@tonic-gate 		sctp->sctp_rto_min = MSEC_TO_TICK(srto->srto_min);
2527c478bd9Sstevel@tonic-gate 	}
2537c478bd9Sstevel@tonic-gate 
2547c478bd9Sstevel@tonic-gate 	return (0);
2557c478bd9Sstevel@tonic-gate }
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate /*
2587c478bd9Sstevel@tonic-gate  * SCTP_ASSOCINFO
2597c478bd9Sstevel@tonic-gate  */
2607c478bd9Sstevel@tonic-gate static int
2617c478bd9Sstevel@tonic-gate sctp_get_assocparams(sctp_t *sctp, void *ptr)
2627c478bd9Sstevel@tonic-gate {
2637c478bd9Sstevel@tonic-gate 	struct sctp_assocparams *sap = ptr;
2647c478bd9Sstevel@tonic-gate 	sctp_faddr_t *fp;
2657c478bd9Sstevel@tonic-gate 	uint16_t i;
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate 	sap->sasoc_asocmaxrxt = sctp->sctp_pa_max_rxt;
2687c478bd9Sstevel@tonic-gate 
2697c478bd9Sstevel@tonic-gate 	/*
2707c478bd9Sstevel@tonic-gate 	 * Count the number of peer addresses
2717c478bd9Sstevel@tonic-gate 	 */
2727c478bd9Sstevel@tonic-gate 	for (i = 0, fp = sctp->sctp_faddrs; fp != NULL; fp = fp->next) {
2737c478bd9Sstevel@tonic-gate 		i++;
2747c478bd9Sstevel@tonic-gate 	}
2757c478bd9Sstevel@tonic-gate 	sap->sasoc_number_peer_destinations = i;
2767c478bd9Sstevel@tonic-gate 	sap->sasoc_peer_rwnd = sctp->sctp_frwnd;
2777c478bd9Sstevel@tonic-gate 	sap->sasoc_local_rwnd = sctp->sctp_rwnd;
2787c478bd9Sstevel@tonic-gate 	sap->sasoc_cookie_life = TICK_TO_MSEC(sctp->sctp_cookie_lifetime);
2797c478bd9Sstevel@tonic-gate 
2807c478bd9Sstevel@tonic-gate 	return (sizeof (*sap));
2817c478bd9Sstevel@tonic-gate }
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate static int
284bd670b35SErik Nordmark sctp_set_assocparams(sctp_t *sctp, const void *invalp)
2857c478bd9Sstevel@tonic-gate {
2867c478bd9Sstevel@tonic-gate 	const struct sctp_assocparams *sap = invalp;
2877c478bd9Sstevel@tonic-gate 	uint32_t sum = 0;
2887c478bd9Sstevel@tonic-gate 	sctp_faddr_t *fp;
289f4b3ec61Sdh 	sctp_stack_t	*sctps = sctp->sctp_sctps;
2907c478bd9Sstevel@tonic-gate 
2917c478bd9Sstevel@tonic-gate 	if (sap->sasoc_asocmaxrxt) {
2927c478bd9Sstevel@tonic-gate 		if (sctp->sctp_faddrs) {
2937c478bd9Sstevel@tonic-gate 			/*
2947c478bd9Sstevel@tonic-gate 			 * Bounds check: as per rfc2960, assoc max retr cannot
2957c478bd9Sstevel@tonic-gate 			 * exceed the sum of all individual path max retr's.
2967c478bd9Sstevel@tonic-gate 			 */
2977c478bd9Sstevel@tonic-gate 			for (fp = sctp->sctp_faddrs; fp; fp = fp->next) {
2987c478bd9Sstevel@tonic-gate 				sum += fp->max_retr;
2997c478bd9Sstevel@tonic-gate 			}
3007c478bd9Sstevel@tonic-gate 			if (sap->sasoc_asocmaxrxt > sum) {
3017c478bd9Sstevel@tonic-gate 				return (EINVAL);
3027c478bd9Sstevel@tonic-gate 			}
3037c478bd9Sstevel@tonic-gate 		}
304f4b3ec61Sdh 		if (sap->sasoc_asocmaxrxt < sctps->sctps_pa_max_retr_low ||
305f4b3ec61Sdh 		    sap->sasoc_asocmaxrxt > sctps->sctps_pa_max_retr_high) {
3067c478bd9Sstevel@tonic-gate 			/*
3077c478bd9Sstevel@tonic-gate 			 * Out of bounds.
3087c478bd9Sstevel@tonic-gate 			 */
3097c478bd9Sstevel@tonic-gate 			return (EINVAL);
3107c478bd9Sstevel@tonic-gate 		}
3117c478bd9Sstevel@tonic-gate 	}
3127c478bd9Sstevel@tonic-gate 	if (sap->sasoc_cookie_life != 0 &&
313f4b3ec61Sdh 	    (sap->sasoc_cookie_life < sctps->sctps_cookie_life_low ||
314b34b8d1aSkcpoon 	    sap->sasoc_cookie_life > sctps->sctps_cookie_life_high)) {
315b34b8d1aSkcpoon 		return (EINVAL);
3167c478bd9Sstevel@tonic-gate 	}
3177c478bd9Sstevel@tonic-gate 
3187c478bd9Sstevel@tonic-gate 	if (sap->sasoc_asocmaxrxt > 0) {
3197c478bd9Sstevel@tonic-gate 		sctp->sctp_pa_max_rxt = sap->sasoc_asocmaxrxt;
3207c478bd9Sstevel@tonic-gate 	}
3217c478bd9Sstevel@tonic-gate 	if (sap->sasoc_cookie_life > 0) {
3227c478bd9Sstevel@tonic-gate 		sctp->sctp_cookie_lifetime = MSEC_TO_TICK(
3237c478bd9Sstevel@tonic-gate 		    sap->sasoc_cookie_life);
3247c478bd9Sstevel@tonic-gate 	}
3257c478bd9Sstevel@tonic-gate 	return (0);
3267c478bd9Sstevel@tonic-gate }
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate /*
3297c478bd9Sstevel@tonic-gate  * SCTP_INITMSG
3307c478bd9Sstevel@tonic-gate  */
3317c478bd9Sstevel@tonic-gate static int
3327c478bd9Sstevel@tonic-gate sctp_get_initmsg(sctp_t *sctp, void *ptr)
3337c478bd9Sstevel@tonic-gate {
3347c478bd9Sstevel@tonic-gate 	struct sctp_initmsg *si = ptr;
3357c478bd9Sstevel@tonic-gate 
3367c478bd9Sstevel@tonic-gate 	si->sinit_num_ostreams = sctp->sctp_num_ostr;
3377c478bd9Sstevel@tonic-gate 	si->sinit_max_instreams = sctp->sctp_num_istr;
3387c478bd9Sstevel@tonic-gate 	si->sinit_max_attempts = sctp->sctp_max_init_rxt;
3397c478bd9Sstevel@tonic-gate 	si->sinit_max_init_timeo = TICK_TO_MSEC(sctp->sctp_init_rto_max);
3407c478bd9Sstevel@tonic-gate 
3417c478bd9Sstevel@tonic-gate 	return (sizeof (*si));
3427c478bd9Sstevel@tonic-gate }
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate static int
3457c478bd9Sstevel@tonic-gate sctp_set_initmsg(sctp_t *sctp, const void *invalp, uint_t inlen)
3467c478bd9Sstevel@tonic-gate {
3477c478bd9Sstevel@tonic-gate 	const struct sctp_initmsg *si = invalp;
348f4b3ec61Sdh 	sctp_stack_t	*sctps = sctp->sctp_sctps;
349bd670b35SErik Nordmark 	conn_t		*connp = sctp->sctp_connp;
3507c478bd9Sstevel@tonic-gate 
3517c478bd9Sstevel@tonic-gate 	if (sctp->sctp_state > SCTPS_LISTEN) {
3527c478bd9Sstevel@tonic-gate 		return (EINVAL);
3537c478bd9Sstevel@tonic-gate 	}
3547c478bd9Sstevel@tonic-gate 	if (inlen < sizeof (*si)) {
3557c478bd9Sstevel@tonic-gate 		return (EINVAL);
3567c478bd9Sstevel@tonic-gate 	}
3577c478bd9Sstevel@tonic-gate 	if (si->sinit_num_ostreams != 0 &&
358f4b3ec61Sdh 	    (si->sinit_num_ostreams < sctps->sctps_initial_out_streams_low ||
359f4b3ec61Sdh 	    si->sinit_num_ostreams >
360f4b3ec61Sdh 	    sctps->sctps_initial_out_streams_high)) {
3617c478bd9Sstevel@tonic-gate 		/*
3627c478bd9Sstevel@tonic-gate 		 * Out of bounds.
3637c478bd9Sstevel@tonic-gate 		 */
3647c478bd9Sstevel@tonic-gate 		return (EINVAL);
3657c478bd9Sstevel@tonic-gate 	}
3667c478bd9Sstevel@tonic-gate 	if (si->sinit_max_instreams != 0 &&
367f4b3ec61Sdh 	    (si->sinit_max_instreams < sctps->sctps_max_in_streams_low ||
368b34b8d1aSkcpoon 	    si->sinit_max_instreams > sctps->sctps_max_in_streams_high)) {
3697c478bd9Sstevel@tonic-gate 		return (EINVAL);
3707c478bd9Sstevel@tonic-gate 	}
3717c478bd9Sstevel@tonic-gate 	if (si->sinit_max_attempts != 0 &&
372f4b3ec61Sdh 	    (si->sinit_max_attempts < sctps->sctps_max_init_retr_low ||
373b34b8d1aSkcpoon 	    si->sinit_max_attempts > sctps->sctps_max_init_retr_high)) {
3747c478bd9Sstevel@tonic-gate 		return (EINVAL);
3757c478bd9Sstevel@tonic-gate 	}
3767c478bd9Sstevel@tonic-gate 	if (si->sinit_max_init_timeo != 0 &&
377bd670b35SErik Nordmark 	    (secpolicy_ip_config(connp->conn_cred, B_TRUE) != 0 &&
378b34b8d1aSkcpoon 	    (si->sinit_max_init_timeo < sctps->sctps_rto_maxg_low ||
379b34b8d1aSkcpoon 	    si->sinit_max_init_timeo > sctps->sctps_rto_maxg_high))) {
3807c478bd9Sstevel@tonic-gate 		return (EINVAL);
3817c478bd9Sstevel@tonic-gate 	}
3827c478bd9Sstevel@tonic-gate 	if (si->sinit_num_ostreams != 0)
3837c478bd9Sstevel@tonic-gate 		sctp->sctp_num_ostr = si->sinit_num_ostreams;
3847c478bd9Sstevel@tonic-gate 
3857c478bd9Sstevel@tonic-gate 	if (si->sinit_max_instreams != 0)
3867c478bd9Sstevel@tonic-gate 		sctp->sctp_num_istr = si->sinit_max_instreams;
3877c478bd9Sstevel@tonic-gate 
3887c478bd9Sstevel@tonic-gate 	if (si->sinit_max_attempts != 0)
3897c478bd9Sstevel@tonic-gate 		sctp->sctp_max_init_rxt = si->sinit_max_attempts;
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate 	if (si->sinit_max_init_timeo != 0) {
3927c478bd9Sstevel@tonic-gate 		sctp->sctp_init_rto_max =
3937c478bd9Sstevel@tonic-gate 		    MSEC_TO_TICK(si->sinit_max_init_timeo);
3947c478bd9Sstevel@tonic-gate 	}
3957c478bd9Sstevel@tonic-gate 	return (0);
3967c478bd9Sstevel@tonic-gate }
3977c478bd9Sstevel@tonic-gate 
3987c478bd9Sstevel@tonic-gate /*
3997c478bd9Sstevel@tonic-gate  * SCTP_PEER_ADDR_PARAMS
4007c478bd9Sstevel@tonic-gate  */
4017c478bd9Sstevel@tonic-gate static int
4027c478bd9Sstevel@tonic-gate sctp_find_peer_fp(sctp_t *sctp, const struct sockaddr_storage *ss,
4037c478bd9Sstevel@tonic-gate     sctp_faddr_t **fpp)
4047c478bd9Sstevel@tonic-gate {
4057c478bd9Sstevel@tonic-gate 	struct sockaddr_in *sin;
4067c478bd9Sstevel@tonic-gate 	struct sockaddr_in6 *sin6;
4077c478bd9Sstevel@tonic-gate 	in6_addr_t addr;
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate 	if (ss->ss_family == AF_INET) {
4107c478bd9Sstevel@tonic-gate 		sin = (struct sockaddr_in *)ss;
4117c478bd9Sstevel@tonic-gate 		IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &addr);
4127c478bd9Sstevel@tonic-gate 	} else if (ss->ss_family == AF_INET6) {
4137c478bd9Sstevel@tonic-gate 		sin6 = (struct sockaddr_in6 *)ss;
4147c478bd9Sstevel@tonic-gate 		addr = sin6->sin6_addr;
4157c478bd9Sstevel@tonic-gate 	} else if (ss->ss_family) {
4167c478bd9Sstevel@tonic-gate 		return (EAFNOSUPPORT);
4177c478bd9Sstevel@tonic-gate 	}
4187c478bd9Sstevel@tonic-gate 
4197c478bd9Sstevel@tonic-gate 	if (!ss->ss_family ||
4207c478bd9Sstevel@tonic-gate 	    SCTP_IS_ADDR_UNSPEC(IN6_IS_ADDR_V4MAPPED(&addr), addr)) {
4217c478bd9Sstevel@tonic-gate 		*fpp = NULL;
4227c478bd9Sstevel@tonic-gate 	} else {
4237c478bd9Sstevel@tonic-gate 		*fpp = sctp_lookup_faddr(sctp, &addr);
4247c478bd9Sstevel@tonic-gate 		if (*fpp == NULL) {
4257c478bd9Sstevel@tonic-gate 			return (EINVAL);
4267c478bd9Sstevel@tonic-gate 		}
4277c478bd9Sstevel@tonic-gate 	}
4287c478bd9Sstevel@tonic-gate 	return (0);
4297c478bd9Sstevel@tonic-gate }
4307c478bd9Sstevel@tonic-gate 
4317c478bd9Sstevel@tonic-gate static int
4327c478bd9Sstevel@tonic-gate sctp_get_peer_addr_params(sctp_t *sctp, void *ptr)
4337c478bd9Sstevel@tonic-gate {
4347c478bd9Sstevel@tonic-gate 	struct sctp_paddrparams *spp = ptr;
4357c478bd9Sstevel@tonic-gate 	sctp_faddr_t *fp;
4367c478bd9Sstevel@tonic-gate 	int retval;
4377c478bd9Sstevel@tonic-gate 
4387c478bd9Sstevel@tonic-gate 	retval = sctp_find_peer_fp(sctp, &spp->spp_address, &fp);
4397c478bd9Sstevel@tonic-gate 	if (retval) {
4407c478bd9Sstevel@tonic-gate 		return (retval);
4417c478bd9Sstevel@tonic-gate 	}
4427c478bd9Sstevel@tonic-gate 	if (fp) {
4437c478bd9Sstevel@tonic-gate 		spp->spp_hbinterval = TICK_TO_MSEC(fp->hb_interval);
4447c478bd9Sstevel@tonic-gate 		spp->spp_pathmaxrxt = fp->max_retr;
4457c478bd9Sstevel@tonic-gate 	} else {
4467c478bd9Sstevel@tonic-gate 		spp->spp_hbinterval = TICK_TO_MSEC(sctp->sctp_hb_interval);
4477c478bd9Sstevel@tonic-gate 		spp->spp_pathmaxrxt = sctp->sctp_pp_max_rxt;
4487c478bd9Sstevel@tonic-gate 	}
4497c478bd9Sstevel@tonic-gate 	return (sizeof (*spp));
4507c478bd9Sstevel@tonic-gate }
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate static int
453bd670b35SErik Nordmark sctp_set_peer_addr_params(sctp_t *sctp, const void *invalp)
4547c478bd9Sstevel@tonic-gate {
4557c478bd9Sstevel@tonic-gate 	const struct sctp_paddrparams *spp = invalp;
4567c478bd9Sstevel@tonic-gate 	sctp_faddr_t *fp, *fp2;
4577c478bd9Sstevel@tonic-gate 	int retval;
4587c478bd9Sstevel@tonic-gate 	uint32_t sum = 0;
4597c478bd9Sstevel@tonic-gate 	int64_t now;
460f4b3ec61Sdh 	sctp_stack_t	*sctps = sctp->sctp_sctps;
4617c478bd9Sstevel@tonic-gate 
4627c478bd9Sstevel@tonic-gate 	retval = sctp_find_peer_fp(sctp, &spp->spp_address, &fp);
4637c478bd9Sstevel@tonic-gate 	if (retval != 0) {
4647c478bd9Sstevel@tonic-gate 		return (retval);
4657c478bd9Sstevel@tonic-gate 	}
4667c478bd9Sstevel@tonic-gate 
4677c478bd9Sstevel@tonic-gate 	if (spp->spp_hbinterval && spp->spp_hbinterval != UINT32_MAX &&
468f4b3ec61Sdh 	    (spp->spp_hbinterval < sctps->sctps_heartbeat_interval_low ||
469b34b8d1aSkcpoon 	    spp->spp_hbinterval > sctps->sctps_heartbeat_interval_high)) {
4707c478bd9Sstevel@tonic-gate 		return (EINVAL);
4717c478bd9Sstevel@tonic-gate 	}
4727c478bd9Sstevel@tonic-gate 	if (spp->spp_pathmaxrxt &&
473f4b3ec61Sdh 	    (spp->spp_pathmaxrxt < sctps->sctps_pp_max_retr_low ||
474b34b8d1aSkcpoon 	    spp->spp_pathmaxrxt > sctps->sctps_pp_max_retr_high)) {
4757c478bd9Sstevel@tonic-gate 		return (EINVAL);
4767c478bd9Sstevel@tonic-gate 	}
4777c478bd9Sstevel@tonic-gate 	if (spp->spp_pathmaxrxt && sctp->sctp_faddrs) {
4787c478bd9Sstevel@tonic-gate 		for (fp2 = sctp->sctp_faddrs; fp2; fp2 = fp2->next) {
4797c478bd9Sstevel@tonic-gate 			if (!fp || fp2 == fp) {
4807c478bd9Sstevel@tonic-gate 				sum += spp->spp_pathmaxrxt;
4817c478bd9Sstevel@tonic-gate 			} else {
4827c478bd9Sstevel@tonic-gate 				sum += fp2->max_retr;
4837c478bd9Sstevel@tonic-gate 			}
4847c478bd9Sstevel@tonic-gate 		}
4857c478bd9Sstevel@tonic-gate 		if (sctp->sctp_pa_max_rxt > sum) {
4867c478bd9Sstevel@tonic-gate 			return (EINVAL);
4877c478bd9Sstevel@tonic-gate 		}
4887c478bd9Sstevel@tonic-gate 	}
4897c478bd9Sstevel@tonic-gate 
490d3d50737SRafael Vanoni 	now = ddi_get_lbolt64();
4917c478bd9Sstevel@tonic-gate 	if (fp != NULL) {
4927c478bd9Sstevel@tonic-gate 		if (spp->spp_hbinterval == UINT32_MAX) {
4937c478bd9Sstevel@tonic-gate 			/*
4947c478bd9Sstevel@tonic-gate 			 * Send heartbeat immediatelly, don't modify the
4957c478bd9Sstevel@tonic-gate 			 * current setting.
4967c478bd9Sstevel@tonic-gate 			 */
4977c478bd9Sstevel@tonic-gate 			sctp_send_heartbeat(sctp, fp);
4987c478bd9Sstevel@tonic-gate 		} else {
4997c478bd9Sstevel@tonic-gate 			fp->hb_interval = MSEC_TO_TICK(spp->spp_hbinterval);
5007c478bd9Sstevel@tonic-gate 			fp->hb_expiry = now + SET_HB_INTVL(fp);
5017c478bd9Sstevel@tonic-gate 			/*
5027c478bd9Sstevel@tonic-gate 			 * Restart the heartbeat timer using the new intrvl.
5037c478bd9Sstevel@tonic-gate 			 * We need to call sctp_heartbeat_timer() to set
5047c478bd9Sstevel@tonic-gate 			 * the earliest heartbeat expiry time.
5057c478bd9Sstevel@tonic-gate 			 */
5067c478bd9Sstevel@tonic-gate 			sctp_heartbeat_timer(sctp);
5077c478bd9Sstevel@tonic-gate 		}
5087c478bd9Sstevel@tonic-gate 		if (spp->spp_pathmaxrxt) {
5097c478bd9Sstevel@tonic-gate 			fp->max_retr = spp->spp_pathmaxrxt;
5107c478bd9Sstevel@tonic-gate 		}
5117c478bd9Sstevel@tonic-gate 	} else {
5127c478bd9Sstevel@tonic-gate 		for (fp2 = sctp->sctp_faddrs; fp2 != NULL; fp2 = fp2->next) {
5137c478bd9Sstevel@tonic-gate 			if (spp->spp_hbinterval == UINT32_MAX) {
5147c478bd9Sstevel@tonic-gate 				/*
5157c478bd9Sstevel@tonic-gate 				 * Send heartbeat immediatelly, don't modify
5167c478bd9Sstevel@tonic-gate 				 * the current setting.
5177c478bd9Sstevel@tonic-gate 				 */
5187c478bd9Sstevel@tonic-gate 				sctp_send_heartbeat(sctp, fp2);
5197c478bd9Sstevel@tonic-gate 			} else {
5207c478bd9Sstevel@tonic-gate 				fp2->hb_interval = MSEC_TO_TICK(
5217c478bd9Sstevel@tonic-gate 				    spp->spp_hbinterval);
5227c478bd9Sstevel@tonic-gate 				fp2->hb_expiry = now + SET_HB_INTVL(fp2);
5237c478bd9Sstevel@tonic-gate 			}
5247c478bd9Sstevel@tonic-gate 			if (spp->spp_pathmaxrxt) {
5257c478bd9Sstevel@tonic-gate 				fp2->max_retr = spp->spp_pathmaxrxt;
5267c478bd9Sstevel@tonic-gate 			}
5277c478bd9Sstevel@tonic-gate 		}
5287c478bd9Sstevel@tonic-gate 		if (spp->spp_hbinterval != UINT32_MAX) {
5297c478bd9Sstevel@tonic-gate 			sctp->sctp_hb_interval = MSEC_TO_TICK(
5307c478bd9Sstevel@tonic-gate 			    spp->spp_hbinterval);
5317c478bd9Sstevel@tonic-gate 			/* Restart the heartbeat timer using the new intrvl. */
5327c478bd9Sstevel@tonic-gate 			sctp_timer(sctp, sctp->sctp_heartbeat_mp,
5337c478bd9Sstevel@tonic-gate 			    sctp->sctp_hb_interval);
5347c478bd9Sstevel@tonic-gate 		}
5357c478bd9Sstevel@tonic-gate 		if (spp->spp_pathmaxrxt) {
5367c478bd9Sstevel@tonic-gate 			sctp->sctp_pp_max_rxt = spp->spp_pathmaxrxt;
5377c478bd9Sstevel@tonic-gate 		}
5387c478bd9Sstevel@tonic-gate 	}
5397c478bd9Sstevel@tonic-gate 	return (0);
5407c478bd9Sstevel@tonic-gate }
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate /*
5437c478bd9Sstevel@tonic-gate  * SCTP_DEFAULT_SEND_PARAM
5447c478bd9Sstevel@tonic-gate  */
5457c478bd9Sstevel@tonic-gate static int
5467c478bd9Sstevel@tonic-gate sctp_get_def_send_params(sctp_t *sctp, void *ptr)
5477c478bd9Sstevel@tonic-gate {
5487c478bd9Sstevel@tonic-gate 	struct sctp_sndrcvinfo *sinfo = ptr;
5497c478bd9Sstevel@tonic-gate 
5507c478bd9Sstevel@tonic-gate 	sinfo->sinfo_stream = sctp->sctp_def_stream;
5517c478bd9Sstevel@tonic-gate 	sinfo->sinfo_ssn = 0;
5527c478bd9Sstevel@tonic-gate 	sinfo->sinfo_flags = sctp->sctp_def_flags;
5537c478bd9Sstevel@tonic-gate 	sinfo->sinfo_ppid = sctp->sctp_def_ppid;
5547c478bd9Sstevel@tonic-gate 	sinfo->sinfo_context = sctp->sctp_def_context;
5557c478bd9Sstevel@tonic-gate 	sinfo->sinfo_timetolive = sctp->sctp_def_timetolive;
5567c478bd9Sstevel@tonic-gate 	sinfo->sinfo_tsn = 0;
5577c478bd9Sstevel@tonic-gate 	sinfo->sinfo_cumtsn = 0;
5587c478bd9Sstevel@tonic-gate 
5597c478bd9Sstevel@tonic-gate 	return (sizeof (*sinfo));
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate static int
563bd670b35SErik Nordmark sctp_set_def_send_params(sctp_t *sctp, const void *invalp)
5647c478bd9Sstevel@tonic-gate {
5657c478bd9Sstevel@tonic-gate 	const struct sctp_sndrcvinfo *sinfo = invalp;
5667c478bd9Sstevel@tonic-gate 
5677c478bd9Sstevel@tonic-gate 	if (sinfo->sinfo_stream >= sctp->sctp_num_ostr) {
5687c478bd9Sstevel@tonic-gate 		return (EINVAL);
5697c478bd9Sstevel@tonic-gate 	}
5707c478bd9Sstevel@tonic-gate 
5717c478bd9Sstevel@tonic-gate 	sctp->sctp_def_stream = sinfo->sinfo_stream;
5727c478bd9Sstevel@tonic-gate 	sctp->sctp_def_flags = sinfo->sinfo_flags;
5737c478bd9Sstevel@tonic-gate 	sctp->sctp_def_ppid = sinfo->sinfo_ppid;
5747c478bd9Sstevel@tonic-gate 	sctp->sctp_def_context = sinfo->sinfo_context;
5757c478bd9Sstevel@tonic-gate 	sctp->sctp_def_timetolive = sinfo->sinfo_timetolive;
5767c478bd9Sstevel@tonic-gate 
5777c478bd9Sstevel@tonic-gate 	return (0);
5787c478bd9Sstevel@tonic-gate }
5797c478bd9Sstevel@tonic-gate 
5807c478bd9Sstevel@tonic-gate static int
581bd670b35SErik Nordmark sctp_set_prim(sctp_t *sctp, const void *invalp)
5827c478bd9Sstevel@tonic-gate {
5837c478bd9Sstevel@tonic-gate 	const struct	sctp_setpeerprim *pp = invalp;
5847c478bd9Sstevel@tonic-gate 	int		retval;
5857c478bd9Sstevel@tonic-gate 	sctp_faddr_t	*fp;
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	retval = sctp_find_peer_fp(sctp, &pp->sspp_addr, &fp);
5887c478bd9Sstevel@tonic-gate 	if (retval)
5897c478bd9Sstevel@tonic-gate 		return (retval);
5907c478bd9Sstevel@tonic-gate 
5917c478bd9Sstevel@tonic-gate 	if (fp == NULL)
5927c478bd9Sstevel@tonic-gate 		return (EINVAL);
5937c478bd9Sstevel@tonic-gate 	if (fp == sctp->sctp_primary)
5947c478bd9Sstevel@tonic-gate 		return (0);
5957c478bd9Sstevel@tonic-gate 	sctp->sctp_primary = fp;
5967c478bd9Sstevel@tonic-gate 
5977c478bd9Sstevel@tonic-gate 	/* Only switch current if fp is alive */
5987c478bd9Sstevel@tonic-gate 	if (fp->state != SCTP_FADDRS_ALIVE || fp == sctp->sctp_current) {
5997c478bd9Sstevel@tonic-gate 		return (0);
6007c478bd9Sstevel@tonic-gate 	}
60177c67f2fSkcpoon 	sctp_set_faddr_current(sctp, fp);
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 	return (0);
6047c478bd9Sstevel@tonic-gate }
6057c478bd9Sstevel@tonic-gate 
606bd670b35SErik Nordmark /*
607bd670b35SErik Nordmark  * Table of all known options handled on a SCTP protocol stack.
608bd670b35SErik Nordmark  *
609bd670b35SErik Nordmark  * Note: This table contains options processed by both SCTP and IP levels
610bd670b35SErik Nordmark  *       and is the superset of options that can be performed on a SCTP and IP
611bd670b35SErik Nordmark  *       stack.
612bd670b35SErik Nordmark  */
613bd670b35SErik Nordmark opdes_t	sctp_opt_arr[] = {
614bd670b35SErik Nordmark 
615bd670b35SErik Nordmark { SO_LINGER,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0,
616bd670b35SErik Nordmark 	sizeof (struct linger), 0 },
617bd670b35SErik Nordmark 
618bd670b35SErik Nordmark { SO_DEBUG,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
619bd670b35SErik Nordmark { SO_KEEPALIVE,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
620bd670b35SErik Nordmark { SO_DONTROUTE,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
621bd670b35SErik Nordmark { SO_USELOOPBACK, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0
622bd670b35SErik Nordmark 	},
623bd670b35SErik Nordmark { SO_BROADCAST,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
624bd670b35SErik Nordmark { SO_REUSEADDR, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
625bd670b35SErik Nordmark { SO_OOBINLINE, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
626bd670b35SErik Nordmark { SO_TYPE,	SOL_SOCKET, OA_R, OA_R, OP_NP, 0, sizeof (int), 0 },
627bd670b35SErik Nordmark { SO_SNDBUF,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
628bd670b35SErik Nordmark { SO_RCVBUF,	SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
629bd670b35SErik Nordmark { SO_DGRAM_ERRIND, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0
630bd670b35SErik Nordmark 	},
631bd670b35SErik Nordmark { SO_SND_COPYAVOID, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
632bd670b35SErik Nordmark { SO_ANON_MLP, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int),
633bd670b35SErik Nordmark 	0 },
634bd670b35SErik Nordmark { SO_MAC_EXEMPT, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int),
635bd670b35SErik Nordmark 	0 },
636bd670b35SErik Nordmark { SO_ALLZONES, SOL_SOCKET, OA_R, OA_RW, OP_CONFIG, 0, sizeof (int),
637bd670b35SErik Nordmark 	0 },
638bd670b35SErik Nordmark { SO_EXCLBIND, SOL_SOCKET, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
639bd670b35SErik Nordmark 
640bd670b35SErik Nordmark { SO_DOMAIN,	SOL_SOCKET, OA_R, OA_R, OP_NP, 0, sizeof (int), 0 },
641bd670b35SErik Nordmark 
642bd670b35SErik Nordmark { SO_PROTOTYPE,	SOL_SOCKET, OA_R, OA_R, OP_NP, 0, sizeof (int), 0 },
643bd670b35SErik Nordmark 
644bd670b35SErik Nordmark { SCTP_ADAPTATION_LAYER, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
645bd670b35SErik Nordmark 	sizeof (struct sctp_setadaptation), 0 },
646bd670b35SErik Nordmark { SCTP_ADD_ADDR, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, OP_VARLEN,
647bd670b35SErik Nordmark 	sizeof (int), 0 },
648bd670b35SErik Nordmark { SCTP_ASSOCINFO, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
649bd670b35SErik Nordmark 	sizeof (struct sctp_assocparams), 0 },
650bd670b35SErik Nordmark { SCTP_AUTOCLOSE, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
651bd670b35SErik Nordmark { SCTP_DEFAULT_SEND_PARAM, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
652bd670b35SErik Nordmark 	sizeof (struct sctp_sndrcvinfo), 0 },
653bd670b35SErik Nordmark { SCTP_DISABLE_FRAGMENTS, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
654bd670b35SErik Nordmark 	sizeof (int), 0 },
655bd670b35SErik Nordmark { SCTP_EVENTS, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
656bd670b35SErik Nordmark 	sizeof (struct sctp_event_subscribe), 0 },
657bd670b35SErik Nordmark { SCTP_GET_LADDRS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, OP_VARLEN,
658bd670b35SErik Nordmark 	sizeof (int), 0 },
659bd670b35SErik Nordmark { SCTP_GET_NLADDRS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, 0, sizeof (int), 0 },
660bd670b35SErik Nordmark { SCTP_GET_NPADDRS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, 0, sizeof (int), 0 },
661bd670b35SErik Nordmark { SCTP_GET_PADDRS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, OP_VARLEN,
662bd670b35SErik Nordmark 	sizeof (int), 0 },
663bd670b35SErik Nordmark { SCTP_GET_PEER_ADDR_INFO, IPPROTO_SCTP, OA_R, OA_R, OP_NP, 0,
664bd670b35SErik Nordmark 	sizeof (struct sctp_paddrinfo), 0 },
665bd670b35SErik Nordmark { SCTP_INITMSG, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
666bd670b35SErik Nordmark 	sizeof (struct sctp_initmsg), 0 },
667bd670b35SErik Nordmark { SCTP_I_WANT_MAPPED_V4_ADDR, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
668bd670b35SErik Nordmark 	sizeof (int), 0 },
669bd670b35SErik Nordmark { SCTP_MAXSEG, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
670bd670b35SErik Nordmark { SCTP_NODELAY, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
671bd670b35SErik Nordmark { SCTP_PEER_ADDR_PARAMS, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
672bd670b35SErik Nordmark 	sizeof (struct sctp_paddrparams), 0 },
673bd670b35SErik Nordmark { SCTP_PRIMARY_ADDR, IPPROTO_SCTP, OA_W, OA_W, OP_NP, 0,
674bd670b35SErik Nordmark 	sizeof (struct sctp_setpeerprim), 0 },
675bd670b35SErik Nordmark { SCTP_PRSCTP, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
676bd670b35SErik Nordmark { SCTP_GET_ASSOC_STATS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, 0,
677bd670b35SErik Nordmark 	sizeof (sctp_assoc_stats_t), 0 },
678bd670b35SErik Nordmark { SCTP_REM_ADDR, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, OP_VARLEN,
679bd670b35SErik Nordmark 	sizeof (int), 0 },
680bd670b35SErik Nordmark { SCTP_RTOINFO, IPPROTO_SCTP, OA_RW, OA_RW, OP_NP, 0,
681bd670b35SErik Nordmark 	sizeof (struct sctp_rtoinfo), 0 },
682bd670b35SErik Nordmark { SCTP_SET_PEER_PRIMARY_ADDR, IPPROTO_SCTP, OA_W, OA_W, OP_NP, 0,
683bd670b35SErik Nordmark 	sizeof (struct sctp_setprim), 0 },
684bd670b35SErik Nordmark { SCTP_STATUS, IPPROTO_SCTP, OA_R, OA_R, OP_NP, 0,
685bd670b35SErik Nordmark 	sizeof (struct sctp_status), 0 },
686bd670b35SErik Nordmark { SCTP_UC_SWAP, IPPROTO_SCTP, OA_W, OA_W, OP_NP, 0,
687bd670b35SErik Nordmark 	sizeof (struct sctp_uc_swap), 0 },
688bd670b35SErik Nordmark 
689bd670b35SErik Nordmark { IP_OPTIONS,	IPPROTO_IP, OA_RW, OA_RW, OP_NP,
690bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT),
691bd670b35SErik Nordmark 	40, -1 /* not initialized */ },
692bd670b35SErik Nordmark { T_IP_OPTIONS,	IPPROTO_IP, OA_RW, OA_RW, OP_NP,
693bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT),
694bd670b35SErik Nordmark 	40, -1 /* not initialized */ },
695bd670b35SErik Nordmark 
696bd670b35SErik Nordmark { IP_TOS,	IPPROTO_IP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
697bd670b35SErik Nordmark { T_IP_TOS,	IPPROTO_IP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
698bd670b35SErik Nordmark { IP_TTL,	IPPROTO_IP, OA_RW, OA_RW, OP_NP, OP_DEF_FN,
699bd670b35SErik Nordmark 	sizeof (int), -1 /* not initialized */ },
700bd670b35SErik Nordmark 
701bd670b35SErik Nordmark { IP_SEC_OPT, IPPROTO_IP, OA_RW, OA_RW, OP_NP, OP_NODEFAULT,
702bd670b35SErik Nordmark 	sizeof (ipsec_req_t), -1 /* not initialized */ },
703bd670b35SErik Nordmark 
704bd670b35SErik Nordmark { IP_BOUND_IF, IPPROTO_IP, OA_RW, OA_RW, OP_NP, 0,
705bd670b35SErik Nordmark 	sizeof (int),	0 /* no ifindex */ },
706bd670b35SErik Nordmark 
707bd670b35SErik Nordmark { IP_UNSPEC_SRC, IPPROTO_IP, OA_R, OA_RW, OP_RAW, 0,
708bd670b35SErik Nordmark 	sizeof (int), 0 },
709bd670b35SErik Nordmark 
710bd670b35SErik Nordmark { IPV6_UNICAST_HOPS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, OP_DEF_FN,
711bd670b35SErik Nordmark 	sizeof (int), -1 /* not initialized */ },
712bd670b35SErik Nordmark 
713bd670b35SErik Nordmark { IPV6_BOUND_IF, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
714bd670b35SErik Nordmark 	sizeof (int),	0 /* no ifindex */ },
715bd670b35SErik Nordmark 
716bd670b35SErik Nordmark { IP_DONTFRAG, IPPROTO_IP, OA_RW, OA_RW, OP_NP, 0, sizeof (int), 0 },
717bd670b35SErik Nordmark 
718bd670b35SErik Nordmark { IP_NEXTHOP, IPPROTO_IP, OA_R, OA_RW, OP_CONFIG, 0,
719bd670b35SErik Nordmark 	sizeof (in_addr_t),	-1 /* not initialized  */ },
720bd670b35SErik Nordmark 
721bd670b35SErik Nordmark { IPV6_UNSPEC_SRC, IPPROTO_IPV6, OA_R, OA_RW, OP_RAW, 0,
722bd670b35SErik Nordmark 	sizeof (int), 0 },
723bd670b35SErik Nordmark 
724bd670b35SErik Nordmark { IPV6_PKTINFO, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
725bd670b35SErik Nordmark 	(OP_NODEFAULT|OP_VARLEN),
726bd670b35SErik Nordmark 	sizeof (struct in6_pktinfo), -1 /* not initialized */ },
727bd670b35SErik Nordmark { IPV6_NEXTHOP, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
728bd670b35SErik Nordmark 	OP_NODEFAULT,
729bd670b35SErik Nordmark 	sizeof (sin6_t), -1 /* not initialized */ },
730bd670b35SErik Nordmark { IPV6_HOPOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
731bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT), 255*8,
732bd670b35SErik Nordmark 	-1 /* not initialized */ },
733bd670b35SErik Nordmark { IPV6_DSTOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
734bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT), 255*8,
735bd670b35SErik Nordmark 	-1 /* not initialized */ },
736bd670b35SErik Nordmark { IPV6_RTHDRDSTOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
737bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT), 255*8,
738bd670b35SErik Nordmark 	-1 /* not initialized */ },
739bd670b35SErik Nordmark { IPV6_RTHDR, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
740bd670b35SErik Nordmark 	(OP_VARLEN|OP_NODEFAULT), 255*8,
741bd670b35SErik Nordmark 	-1 /* not initialized */ },
742bd670b35SErik Nordmark { IPV6_TCLASS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
743bd670b35SErik Nordmark 	OP_NODEFAULT,
744bd670b35SErik Nordmark 	sizeof (int), -1 /* not initialized */ },
745bd670b35SErik Nordmark { IPV6_PATHMTU, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP,
746bd670b35SErik Nordmark 	OP_NODEFAULT,
747bd670b35SErik Nordmark 	sizeof (struct ip6_mtuinfo), -1 /* not initialized */ },
748bd670b35SErik Nordmark { IPV6_DONTFRAG, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
749bd670b35SErik Nordmark 	sizeof (int), 0 },
750bd670b35SErik Nordmark { IPV6_USE_MIN_MTU, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
751bd670b35SErik Nordmark 	sizeof (int), 0 },
752bd670b35SErik Nordmark { IPV6_V6ONLY, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
753bd670b35SErik Nordmark 	sizeof (int), 0 },
754bd670b35SErik Nordmark 
755bd670b35SErik Nordmark /* Enable receipt of ancillary data */
756bd670b35SErik Nordmark { IPV6_RECVPKTINFO, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
757bd670b35SErik Nordmark 	sizeof (int), 0 },
758bd670b35SErik Nordmark { IPV6_RECVHOPLIMIT, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
759bd670b35SErik Nordmark 	sizeof (int), 0 },
760bd670b35SErik Nordmark { IPV6_RECVTCLASS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
761bd670b35SErik Nordmark 	sizeof (int), 0 },
762bd670b35SErik Nordmark { IPV6_RECVHOPOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
763bd670b35SErik Nordmark 	sizeof (int), 0 },
764bd670b35SErik Nordmark { _OLD_IPV6_RECVDSTOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
765bd670b35SErik Nordmark 	sizeof (int), 0 },
766bd670b35SErik Nordmark { IPV6_RECVDSTOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
767bd670b35SErik Nordmark 	sizeof (int), 0 },
768bd670b35SErik Nordmark { IPV6_RECVRTHDR, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
769bd670b35SErik Nordmark 	sizeof (int), 0 },
770bd670b35SErik Nordmark { IPV6_RECVRTHDRDSTOPTS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
771bd670b35SErik Nordmark 	sizeof (int), 0 },
772bd670b35SErik Nordmark { IPV6_RECVTCLASS, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
773bd670b35SErik Nordmark 	sizeof (int), 0 },
774bd670b35SErik Nordmark 
775bd670b35SErik Nordmark { IPV6_SEC_OPT, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, OP_NODEFAULT,
776bd670b35SErik Nordmark 	sizeof (ipsec_req_t), -1 /* not initialized */ },
777bd670b35SErik Nordmark { IPV6_SRC_PREFERENCES, IPPROTO_IPV6, OA_RW, OA_RW, OP_NP, 0,
778bd670b35SErik Nordmark 	sizeof (uint32_t), IPV6_PREFER_SRC_DEFAULT },
779bd670b35SErik Nordmark };
780bd670b35SErik Nordmark 
781bd670b35SErik Nordmark uint_t sctp_opt_arr_size = A_CNT(sctp_opt_arr);
782bd670b35SErik Nordmark 
7837c478bd9Sstevel@tonic-gate /* Handy on off switch for socket option processing. */
7847c478bd9Sstevel@tonic-gate #define	ONOFF(x)	((x) == 0 ? 0 : 1)
7857c478bd9Sstevel@tonic-gate 
7867c478bd9Sstevel@tonic-gate /*
7877c478bd9Sstevel@tonic-gate  * SCTP routine to get the values of options.
7887c478bd9Sstevel@tonic-gate  */
7897c478bd9Sstevel@tonic-gate int
7907c478bd9Sstevel@tonic-gate sctp_get_opt(sctp_t *sctp, int level, int name, void *ptr, socklen_t *optlen)
7917c478bd9Sstevel@tonic-gate {
7927c478bd9Sstevel@tonic-gate 	int	*i1 = (int *)ptr;
7937c478bd9Sstevel@tonic-gate 	int	retval = 0;
7947c478bd9Sstevel@tonic-gate 	int	buflen = *optlen;
795bd670b35SErik Nordmark 	conn_t	*connp = sctp->sctp_connp;
796bd670b35SErik Nordmark 	conn_opt_arg_t	coas;
797bd670b35SErik Nordmark 
798bd670b35SErik Nordmark 	coas.coa_connp = connp;
799bd670b35SErik Nordmark 	coas.coa_ixa = connp->conn_ixa;
800bd670b35SErik Nordmark 	coas.coa_ipp = &connp->conn_xmit_ipp;
80188cda078Skcpoon 
8027c478bd9Sstevel@tonic-gate 	/* In most cases, the return buffer is just an int */
8037c478bd9Sstevel@tonic-gate 	*optlen = sizeof (int32_t);
8047c478bd9Sstevel@tonic-gate 
8057c478bd9Sstevel@tonic-gate 	RUN_SCTP(sctp);
8067c478bd9Sstevel@tonic-gate 
807b34b8d1aSkcpoon 	if (connp->conn_state_flags & CONN_CLOSING) {
808b34b8d1aSkcpoon 		WAKE_SCTP(sctp);
809b34b8d1aSkcpoon 		return (EINVAL);
810b34b8d1aSkcpoon 	}
811b34b8d1aSkcpoon 
812bd670b35SErik Nordmark 	/*
813bd670b35SErik Nordmark 	 * Check that the level and name are supported by SCTP, and that
814bd670b35SErik Nordmark 	 * the length and credentials are ok.
815bd670b35SErik Nordmark 	 */
816bd670b35SErik Nordmark 	retval = proto_opt_check(level, name, buflen, NULL, sctp_opt_arr,
817bd670b35SErik Nordmark 	    sctp_opt_arr_size, B_FALSE, B_TRUE, connp->conn_cred);
818bd670b35SErik Nordmark 	if (retval != 0) {
819bd670b35SErik Nordmark 		WAKE_SCTP(sctp);
820bd670b35SErik Nordmark 		if (retval < 0) {
821bd670b35SErik Nordmark 			retval = proto_tlitosyserr(-retval);
8227c478bd9Sstevel@tonic-gate 		}
823bd670b35SErik Nordmark 		return (retval);
824bd670b35SErik Nordmark 	}
8257c478bd9Sstevel@tonic-gate 
826bd670b35SErik Nordmark 	switch (level) {
8277c478bd9Sstevel@tonic-gate 	case IPPROTO_SCTP:
8287c478bd9Sstevel@tonic-gate 		switch (name) {
8297c478bd9Sstevel@tonic-gate 		case SCTP_RTOINFO:
8307c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_rtoinfo(sctp, ptr);
8317c478bd9Sstevel@tonic-gate 			break;
8327c478bd9Sstevel@tonic-gate 		case SCTP_ASSOCINFO:
8337c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_assocparams(sctp, ptr);
8347c478bd9Sstevel@tonic-gate 			break;
8357c478bd9Sstevel@tonic-gate 		case SCTP_INITMSG:
8367c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_initmsg(sctp, ptr);
8377c478bd9Sstevel@tonic-gate 			break;
8387c478bd9Sstevel@tonic-gate 		case SCTP_NODELAY:
8397c478bd9Sstevel@tonic-gate 			*i1 = sctp->sctp_ndelay;
8407c478bd9Sstevel@tonic-gate 			break;
8417c478bd9Sstevel@tonic-gate 		case SCTP_AUTOCLOSE:
8427c478bd9Sstevel@tonic-gate 			*i1 = TICK_TO_SEC(sctp->sctp_autoclose);
8437c478bd9Sstevel@tonic-gate 			break;
844558fbd03Skcpoon 		case SCTP_ADAPTATION_LAYER:
845558fbd03Skcpoon 			((struct sctp_setadaptation *)ptr)->ssb_adaptation_ind =
846558fbd03Skcpoon 			    sctp->sctp_tx_adaptation_code;
8477c478bd9Sstevel@tonic-gate 			break;
8487c478bd9Sstevel@tonic-gate 		case SCTP_PEER_ADDR_PARAMS:
8497c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_peer_addr_params(sctp, ptr);
8507c478bd9Sstevel@tonic-gate 			break;
8517c478bd9Sstevel@tonic-gate 		case SCTP_DEFAULT_SEND_PARAM:
8527c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_def_send_params(sctp, ptr);
8537c478bd9Sstevel@tonic-gate 			break;
8547c478bd9Sstevel@tonic-gate 		case SCTP_EVENTS: {
8557c478bd9Sstevel@tonic-gate 			struct sctp_event_subscribe *ev;
8567c478bd9Sstevel@tonic-gate 
8577c478bd9Sstevel@tonic-gate 			ev = (struct sctp_event_subscribe *)ptr;
8587c478bd9Sstevel@tonic-gate 			ev->sctp_data_io_event =
8597c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvsndrcvinfo);
8607c478bd9Sstevel@tonic-gate 			ev->sctp_association_event =
8617c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvassocevnt);
8627c478bd9Sstevel@tonic-gate 			ev->sctp_address_event =
8637c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvpathevnt);
8647c478bd9Sstevel@tonic-gate 			ev->sctp_send_failure_event =
8657c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvsendfailevnt);
8667c478bd9Sstevel@tonic-gate 			ev->sctp_peer_error_event =
8677c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvpeererr);
8687c478bd9Sstevel@tonic-gate 			ev->sctp_shutdown_event =
8697c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvshutdownevnt);
8707c478bd9Sstevel@tonic-gate 			ev->sctp_partial_delivery_event =
8717c478bd9Sstevel@tonic-gate 			    ONOFF(sctp->sctp_recvpdevnt);
872558fbd03Skcpoon 			ev->sctp_adaptation_layer_event =
873b34b8d1aSkcpoon 			    ONOFF(sctp->sctp_recvalevnt);
8747c478bd9Sstevel@tonic-gate 			*optlen = sizeof (struct sctp_event_subscribe);
8757c478bd9Sstevel@tonic-gate 			break;
8767c478bd9Sstevel@tonic-gate 		}
8777c478bd9Sstevel@tonic-gate 		case SCTP_STATUS:
8787c478bd9Sstevel@tonic-gate 			*optlen = sctp_get_status(sctp, ptr);
8797c478bd9Sstevel@tonic-gate 			break;
8807c478bd9Sstevel@tonic-gate 		case SCTP_GET_PEER_ADDR_INFO:
8817c478bd9Sstevel@tonic-gate 			retval = sctp_get_paddrinfo(sctp, ptr, optlen);
8827c478bd9Sstevel@tonic-gate 			break;
8837c478bd9Sstevel@tonic-gate 		case SCTP_GET_NLADDRS:
8847c478bd9Sstevel@tonic-gate 			*(int32_t *)ptr = sctp->sctp_nsaddrs;
8857c478bd9Sstevel@tonic-gate 			break;
8867c478bd9Sstevel@tonic-gate 		case SCTP_GET_LADDRS: {
8877c478bd9Sstevel@tonic-gate 			int addr_cnt;
8887c478bd9Sstevel@tonic-gate 			int addr_size;
8897c478bd9Sstevel@tonic-gate 
890bd670b35SErik Nordmark 			if (connp->conn_family == AF_INET)
8917c478bd9Sstevel@tonic-gate 				addr_size = sizeof (struct sockaddr_in);
8927c478bd9Sstevel@tonic-gate 			else
8937c478bd9Sstevel@tonic-gate 				addr_size = sizeof (struct sockaddr_in6);
8947c478bd9Sstevel@tonic-gate 			addr_cnt = buflen / addr_size;
8957c478bd9Sstevel@tonic-gate 			retval = sctp_getmyaddrs(sctp, ptr, &addr_cnt);
8967c478bd9Sstevel@tonic-gate 			if (retval == 0)
8977c478bd9Sstevel@tonic-gate 				*optlen = addr_cnt * addr_size;
8987c478bd9Sstevel@tonic-gate 			break;
8997c478bd9Sstevel@tonic-gate 		}
9007c478bd9Sstevel@tonic-gate 		case SCTP_GET_NPADDRS: {
9017c478bd9Sstevel@tonic-gate 			int i;
9027c478bd9Sstevel@tonic-gate 			sctp_faddr_t *fp;
9037c478bd9Sstevel@tonic-gate 
9047c478bd9Sstevel@tonic-gate 			for (i = 0, fp = sctp->sctp_faddrs; fp != NULL;
9057c478bd9Sstevel@tonic-gate 			    i++, fp = fp->next)
9067c478bd9Sstevel@tonic-gate 				;
9077c478bd9Sstevel@tonic-gate 			*(int32_t *)ptr = i;
9087c478bd9Sstevel@tonic-gate 			break;
9097c478bd9Sstevel@tonic-gate 		}
9107c478bd9Sstevel@tonic-gate 		case SCTP_GET_PADDRS: {
9117c478bd9Sstevel@tonic-gate 			int addr_cnt;
9127c478bd9Sstevel@tonic-gate 			int addr_size;
9137c478bd9Sstevel@tonic-gate 
914bd670b35SErik Nordmark 			if (connp->conn_family == AF_INET)
9157c478bd9Sstevel@tonic-gate 				addr_size = sizeof (struct sockaddr_in);
9167c478bd9Sstevel@tonic-gate 			else
9177c478bd9Sstevel@tonic-gate 				addr_size = sizeof (struct sockaddr_in6);
9187c478bd9Sstevel@tonic-gate 			addr_cnt = buflen / addr_size;
9197c478bd9Sstevel@tonic-gate 			retval = sctp_getpeeraddrs(sctp, ptr, &addr_cnt);
9207c478bd9Sstevel@tonic-gate 			if (retval == 0)
9217c478bd9Sstevel@tonic-gate 				*optlen = addr_cnt * addr_size;
9227c478bd9Sstevel@tonic-gate 			break;
9237c478bd9Sstevel@tonic-gate 		}
9247c478bd9Sstevel@tonic-gate 		case SCTP_PRSCTP:
9257c478bd9Sstevel@tonic-gate 			*i1 = sctp->sctp_prsctp_aware ? 1 : 0;
9267c478bd9Sstevel@tonic-gate 			break;
9279f13099eSGeorge Shepherd 
9289f13099eSGeorge Shepherd 		case SCTP_GET_ASSOC_STATS: {
9299f13099eSGeorge Shepherd 			sctp_assoc_stats_t *sas;
9309f13099eSGeorge Shepherd 
9319f13099eSGeorge Shepherd 			sas = (sctp_assoc_stats_t *)ptr;
9329f13099eSGeorge Shepherd 
9339f13099eSGeorge Shepherd 			/*
9349f13099eSGeorge Shepherd 			 * Copy the current stats to the stats struct.
93535e12f9cSGeorge Shepherd 			 * For stats which can be reset by snmp users
93635e12f9cSGeorge Shepherd 			 * add the cumulative and current stats for
93735e12f9cSGeorge Shepherd 			 * the raw totals to output to the user.
9389f13099eSGeorge Shepherd 			 */
9399f13099eSGeorge Shepherd 			sas->sas_gapcnt = sctp->sctp_gapcnt;
9409f13099eSGeorge Shepherd 			sas->sas_outseqtsns = sctp->sctp_outseqtsns;
9419f13099eSGeorge Shepherd 			sas->sas_osacks = sctp->sctp_osacks;
9429f13099eSGeorge Shepherd 			sas->sas_isacks = sctp->sctp_isacks;
9439f13099eSGeorge Shepherd 			sas->sas_idupchunks = sctp->sctp_idupchunks;
94435e12f9cSGeorge Shepherd 			sas->sas_rtxchunks =  sctp->sctp_rxtchunks +
94535e12f9cSGeorge Shepherd 			    sctp->sctp_cum_rxtchunks;
94635e12f9cSGeorge Shepherd 			sas->sas_octrlchunks = sctp->sctp_obchunks +
94735e12f9cSGeorge Shepherd 			    sctp->sctp_cum_obchunks;
94835e12f9cSGeorge Shepherd 			sas->sas_ictrlchunks = sctp->sctp_ibchunks +
94935e12f9cSGeorge Shepherd 			    sctp->sctp_cum_ibchunks;
95035e12f9cSGeorge Shepherd 			sas->sas_oodchunks = sctp->sctp_odchunks +
95135e12f9cSGeorge Shepherd 			    sctp->sctp_cum_odchunks;
95235e12f9cSGeorge Shepherd 			sas->sas_iodchunks = sctp->sctp_idchunks +
95335e12f9cSGeorge Shepherd 			    sctp->sctp_cum_idchunks;
95435e12f9cSGeorge Shepherd 			sas->sas_ouodchunks = sctp->sctp_oudchunks +
95535e12f9cSGeorge Shepherd 			    sctp->sctp_cum_oudchunks;
95635e12f9cSGeorge Shepherd 			sas->sas_iuodchunks = sctp->sctp_iudchunks +
95735e12f9cSGeorge Shepherd 			    sctp->sctp_cum_iudchunks;
9589f13099eSGeorge Shepherd 
9599f13099eSGeorge Shepherd 			/*
9609f13099eSGeorge Shepherd 			 * Copy out the maximum observed RTO since the
9619f13099eSGeorge Shepherd 			 * time this data was last requested
9629f13099eSGeorge Shepherd 			 */
9639f13099eSGeorge Shepherd 			if (sctp->sctp_maxrto == 0) {
9649f13099eSGeorge Shepherd 				/* unchanged during obervation period */
9659f13099eSGeorge Shepherd 				sas->sas_maxrto = sctp->sctp_prev_maxrto;
9669f13099eSGeorge Shepherd 			} else {
9679f13099eSGeorge Shepherd 				/* record new period maximum */
9689f13099eSGeorge Shepherd 				sas->sas_maxrto = sctp->sctp_maxrto;
9699f13099eSGeorge Shepherd 			}
9709f13099eSGeorge Shepherd 			/* Record the value sent to the user this period */
9719f13099eSGeorge Shepherd 			sctp->sctp_prev_maxrto = sas->sas_maxrto;
9729f13099eSGeorge Shepherd 
9739f13099eSGeorge Shepherd 			/* Mark beginning of a new observation period */
9749f13099eSGeorge Shepherd 			sctp->sctp_maxrto = 0;
9759f13099eSGeorge Shepherd 
9769f13099eSGeorge Shepherd 			*optlen = sizeof (sctp_assoc_stats_t);
9779f13099eSGeorge Shepherd 			break;
9789f13099eSGeorge Shepherd 		}
9797c478bd9Sstevel@tonic-gate 		case SCTP_I_WANT_MAPPED_V4_ADDR:
9807c478bd9Sstevel@tonic-gate 		case SCTP_MAXSEG:
9817c478bd9Sstevel@tonic-gate 		case SCTP_DISABLE_FRAGMENTS:
9827c478bd9Sstevel@tonic-gate 		default:
983bd670b35SErik Nordmark 			/* Not yet supported. */
98488cda078Skcpoon 			retval = ENOPROTOOPT;
9857c478bd9Sstevel@tonic-gate 			break;
9867c478bd9Sstevel@tonic-gate 		}
987bd670b35SErik Nordmark 		WAKE_SCTP(sctp);
988bd670b35SErik Nordmark 		return (retval);
9897c478bd9Sstevel@tonic-gate 	case IPPROTO_IP:
990bd670b35SErik Nordmark 		if (connp->conn_family != AF_INET) {
9917c478bd9Sstevel@tonic-gate 			retval = EINVAL;
9927c478bd9Sstevel@tonic-gate 			break;
9937c478bd9Sstevel@tonic-gate 		}
9947c478bd9Sstevel@tonic-gate 		switch (name) {
9957c478bd9Sstevel@tonic-gate 		case IP_OPTIONS:
9967c478bd9Sstevel@tonic-gate 		case T_IP_OPTIONS: {
9977c478bd9Sstevel@tonic-gate 			/*
9987c478bd9Sstevel@tonic-gate 			 * This is compatible with BSD in that in only return
9997c478bd9Sstevel@tonic-gate 			 * the reverse source route with the final destination
10007c478bd9Sstevel@tonic-gate 			 * as the last entry. The first 4 bytes of the option
10017c478bd9Sstevel@tonic-gate 			 * will contain the final destination. Allocate a
10027c478bd9Sstevel@tonic-gate 			 * buffer large enough to hold all the options, we
10037c478bd9Sstevel@tonic-gate 			 * add IP_ADDR_LEN to SCTP_MAX_IP_OPTIONS_LENGTH since
100445916cd2Sjpk 			 * ip_opt_get_user() adds the final destination
10057c478bd9Sstevel@tonic-gate 			 * at the start.
10067c478bd9Sstevel@tonic-gate 			 */
10077c478bd9Sstevel@tonic-gate 			int	opt_len;
10087c478bd9Sstevel@tonic-gate 			uchar_t	obuf[SCTP_MAX_IP_OPTIONS_LENGTH + IP_ADDR_LEN];
10097c478bd9Sstevel@tonic-gate 
1010bd670b35SErik Nordmark 			opt_len = ip_opt_get_user(connp, obuf);
1011bd670b35SErik Nordmark 			ASSERT(opt_len <= sizeof (obuf));
1012bd670b35SErik Nordmark 
10137c478bd9Sstevel@tonic-gate 			if (buflen < opt_len) {
10147c478bd9Sstevel@tonic-gate 				/* Silently truncate */
10157c478bd9Sstevel@tonic-gate 				opt_len = buflen;
10167c478bd9Sstevel@tonic-gate 			}
10177c478bd9Sstevel@tonic-gate 			*optlen = opt_len;
10187c478bd9Sstevel@tonic-gate 			bcopy(obuf, ptr, opt_len);
1019bd670b35SErik Nordmark 			WAKE_SCTP(sctp);
1020bd670b35SErik Nordmark 			return (0);
10217c478bd9Sstevel@tonic-gate 		}
10227c478bd9Sstevel@tonic-gate 		default:
10237c478bd9Sstevel@tonic-gate 			break;
10247c478bd9Sstevel@tonic-gate 		}
10257c478bd9Sstevel@tonic-gate 		break;
10267c478bd9Sstevel@tonic-gate 	}
1027bd670b35SErik Nordmark 	mutex_enter(&connp->conn_lock);
1028bd670b35SErik Nordmark 	retval = conn_opt_get(&coas, level, name, ptr);
1029bd670b35SErik Nordmark 	mutex_exit(&connp->conn_lock);
10307c478bd9Sstevel@tonic-gate 	WAKE_SCTP(sctp);
1031bd670b35SErik Nordmark 	if (retval == -1)
1032bd670b35SErik Nordmark 		return (EINVAL);
1033bd670b35SErik Nordmark 	*optlen = retval;
1034bd670b35SErik Nordmark 	return (0);
10357c478bd9Sstevel@tonic-gate }
10367c478bd9Sstevel@tonic-gate 
10377c478bd9Sstevel@tonic-gate int
10387c478bd9Sstevel@tonic-gate sctp_set_opt(sctp_t *sctp, int level, int name, const void *invalp,
10397c478bd9Sstevel@tonic-gate     socklen_t inlen)
10407c478bd9Sstevel@tonic-gate {
10417c478bd9Sstevel@tonic-gate 	int		*i1 = (int *)invalp;
10427c478bd9Sstevel@tonic-gate 	boolean_t	onoff;
10437c478bd9Sstevel@tonic-gate 	int		retval = 0, addrcnt;
10447c478bd9Sstevel@tonic-gate 	conn_t		*connp = sctp->sctp_connp;
1045f4b3ec61Sdh 	sctp_stack_t	*sctps = sctp->sctp_sctps;
1046bd670b35SErik Nordmark 	conn_opt_arg_t	coas;
1047bd670b35SErik Nordmark 
1048bd670b35SErik Nordmark 	coas.coa_connp = connp;
1049bd670b35SErik Nordmark 	coas.coa_ixa = connp->conn_ixa;
1050bd670b35SErik Nordmark 	coas.coa_ipp = &connp->conn_xmit_ipp;
1051bd670b35SErik Nordmark 	coas.coa_ancillary = B_FALSE;
1052bd670b35SErik Nordmark 	coas.coa_changed = 0;
10537c478bd9Sstevel@tonic-gate 
10547c478bd9Sstevel@tonic-gate 	/* In all cases, the size of the option must be bigger than int */
10557c478bd9Sstevel@tonic-gate 	if (inlen >= sizeof (int32_t)) {
10567c478bd9Sstevel@tonic-gate 		onoff = ONOFF(*i1);
10577c478bd9Sstevel@tonic-gate 	}
10587c478bd9Sstevel@tonic-gate 	retval = 0;
10597c478bd9Sstevel@tonic-gate 
10607c478bd9Sstevel@tonic-gate 	RUN_SCTP(sctp);
10617c478bd9Sstevel@tonic-gate 
1062b34b8d1aSkcpoon 	if (connp->conn_state_flags & CONN_CLOSING) {
1063b34b8d1aSkcpoon 		WAKE_SCTP(sctp);
1064b34b8d1aSkcpoon 		return (EINVAL);
1065b34b8d1aSkcpoon 	}
1066b34b8d1aSkcpoon 
1067bd670b35SErik Nordmark 	/*
1068bd670b35SErik Nordmark 	 * Check that the level and name are supported by SCTP, and that
1069bd670b35SErik Nordmark 	 * the length an credentials are ok.
1070bd670b35SErik Nordmark 	 */
1071bd670b35SErik Nordmark 	retval = proto_opt_check(level, name, inlen, NULL, sctp_opt_arr,
1072bd670b35SErik Nordmark 	    sctp_opt_arr_size, B_TRUE, B_FALSE, connp->conn_cred);
1073bd670b35SErik Nordmark 	if (retval != 0) {
1074bd670b35SErik Nordmark 		if (retval < 0) {
1075bd670b35SErik Nordmark 			retval = proto_tlitosyserr(-retval);
1076bd670b35SErik Nordmark 		}
1077bd670b35SErik Nordmark 		goto done;
1078bd670b35SErik Nordmark 	}
1079bd670b35SErik Nordmark 
1080bd670b35SErik Nordmark 	/* Note: both SCTP and TCP interpret l_linger as being in seconds */
10817c478bd9Sstevel@tonic-gate 	switch (level) {
10827c478bd9Sstevel@tonic-gate 	case SOL_SOCKET:
10837c478bd9Sstevel@tonic-gate 		switch (name) {
10847c478bd9Sstevel@tonic-gate 		case SO_SNDBUF:
1085f4b3ec61Sdh 			if (*i1 > sctps->sctps_max_buf) {
10867c478bd9Sstevel@tonic-gate 				retval = ENOBUFS;
1087bd670b35SErik Nordmark 				goto done;
10887c478bd9Sstevel@tonic-gate 			}
10897c478bd9Sstevel@tonic-gate 			if (*i1 < 0) {
10907c478bd9Sstevel@tonic-gate 				retval = EINVAL;
1091bd670b35SErik Nordmark 				goto done;
10927c478bd9Sstevel@tonic-gate 			}
1093bd670b35SErik Nordmark 			connp->conn_sndbuf = *i1;
1094bd670b35SErik Nordmark 			if (sctps->sctps_snd_lowat_fraction != 0) {
1095bd670b35SErik Nordmark 				connp->conn_sndlowat = connp->conn_sndbuf /
1096f4b3ec61Sdh 				    sctps->sctps_snd_lowat_fraction;
1097bd670b35SErik Nordmark 			}
1098bd670b35SErik Nordmark 			goto done;
10997c478bd9Sstevel@tonic-gate 		case SO_RCVBUF:
1100f4b3ec61Sdh 			if (*i1 > sctps->sctps_max_buf) {
11017c478bd9Sstevel@tonic-gate 				retval = ENOBUFS;
1102bd670b35SErik Nordmark 				goto done;
11037c478bd9Sstevel@tonic-gate 			}
11047c478bd9Sstevel@tonic-gate 			/* Silently ignore zero */
11057c478bd9Sstevel@tonic-gate 			if (*i1 != 0) {
11067cae9885SAnders Persson 				struct sock_proto_props sopp;
11077cae9885SAnders Persson 
11087c478bd9Sstevel@tonic-gate 				/*
11097c478bd9Sstevel@tonic-gate 				 * Insist on a receive window that is at least
11107c478bd9Sstevel@tonic-gate 				 * sctp_recv_hiwat_minmss * MSS (default 4*MSS)
11117c478bd9Sstevel@tonic-gate 				 * to avoid funny interactions of Nagle
11127c478bd9Sstevel@tonic-gate 				 * algorithm, SWS avoidance and delayed
11137c478bd9Sstevel@tonic-gate 				 * acknowledgement.
11147c478bd9Sstevel@tonic-gate 				 */
11157c478bd9Sstevel@tonic-gate 				*i1 = MAX(*i1,
1116f4b3ec61Sdh 				    sctps->sctps_recv_hiwat_minmss *
1117f4b3ec61Sdh 				    sctp->sctp_mss);
1118bd670b35SErik Nordmark 				/*
1119bd670b35SErik Nordmark 				 * Note that sctp_rwnd is modified by the
1120bd670b35SErik Nordmark 				 * protocol and here we just whack it.
1121bd670b35SErik Nordmark 				 */
1122bd670b35SErik Nordmark 				connp->conn_rcvbuf = sctp->sctp_rwnd = *i1;
11231d8c4025Svi 				sctp->sctp_irwnd = sctp->sctp_rwnd;
11247d546a59Svi 				sctp->sctp_pd_point = sctp->sctp_rwnd;
11257cae9885SAnders Persson 
11267cae9885SAnders Persson 				sopp.sopp_flags = SOCKOPT_RCVHIWAT;
1127bd670b35SErik Nordmark 				sopp.sopp_rxhiwat = connp->conn_rcvbuf;
11287cae9885SAnders Persson 				sctp->sctp_ulp_prop(sctp->sctp_ulpd, &sopp);
11297cae9885SAnders Persson 
11307c478bd9Sstevel@tonic-gate 			}
11317c478bd9Sstevel@tonic-gate 			/*
11327c478bd9Sstevel@tonic-gate 			 * XXX should we return the rwnd here
11337c478bd9Sstevel@tonic-gate 			 * and sctp_opt_get ?
11347c478bd9Sstevel@tonic-gate 			 */
1135bd670b35SErik Nordmark 			goto done;
11365d0bc3edSsommerfe 		case SO_ALLZONES:
11375d0bc3edSsommerfe 			if (sctp->sctp_state >= SCTPS_BOUND) {
11385d0bc3edSsommerfe 				retval = EINVAL;
1139bd670b35SErik Nordmark 				goto done;
11405d0bc3edSsommerfe 			}
11415d0bc3edSsommerfe 			break;
114245916cd2Sjpk 		case SO_MAC_EXEMPT:
11435d3b8cb7SBill Sommerfeld 			if (sctp->sctp_state >= SCTPS_BOUND) {
11445d3b8cb7SBill Sommerfeld 				retval = EINVAL;
1145bd670b35SErik Nordmark 				goto done;
11465d3b8cb7SBill Sommerfeld 			}
11477c478bd9Sstevel@tonic-gate 			break;
11487c478bd9Sstevel@tonic-gate 		}
11497c478bd9Sstevel@tonic-gate 		break;
11507c478bd9Sstevel@tonic-gate 
11517c478bd9Sstevel@tonic-gate 	case IPPROTO_SCTP:
11527c478bd9Sstevel@tonic-gate 		switch (name) {
11537c478bd9Sstevel@tonic-gate 		case SCTP_RTOINFO:
1154bd670b35SErik Nordmark 			retval = sctp_set_rtoinfo(sctp, invalp);
11557c478bd9Sstevel@tonic-gate 			break;
11567c478bd9Sstevel@tonic-gate 		case SCTP_ASSOCINFO:
1157bd670b35SErik Nordmark 			retval = sctp_set_assocparams(sctp, invalp);
11587c478bd9Sstevel@tonic-gate 			break;
11597c478bd9Sstevel@tonic-gate 		case SCTP_INITMSG:
11607c478bd9Sstevel@tonic-gate 			retval = sctp_set_initmsg(sctp, invalp, inlen);
11617c478bd9Sstevel@tonic-gate 			break;
11627c478bd9Sstevel@tonic-gate 		case SCTP_NODELAY:
11637c478bd9Sstevel@tonic-gate 			sctp->sctp_ndelay = ONOFF(*i1);
11647c478bd9Sstevel@tonic-gate 			break;
11657c478bd9Sstevel@tonic-gate 		case SCTP_AUTOCLOSE:
11667c478bd9Sstevel@tonic-gate 			if (SEC_TO_TICK(*i1) < 0) {
11677c478bd9Sstevel@tonic-gate 				retval = EINVAL;
11687c478bd9Sstevel@tonic-gate 				break;
11697c478bd9Sstevel@tonic-gate 			}
11707c478bd9Sstevel@tonic-gate 			/* Convert the number of seconds to ticks. */
11717c478bd9Sstevel@tonic-gate 			sctp->sctp_autoclose = SEC_TO_TICK(*i1);
11727c478bd9Sstevel@tonic-gate 			sctp_heartbeat_timer(sctp);
11737c478bd9Sstevel@tonic-gate 			break;
11747c478bd9Sstevel@tonic-gate 		case SCTP_SET_PEER_PRIMARY_ADDR:
1175bd670b35SErik Nordmark 			retval = sctp_set_peerprim(sctp, invalp);
11767c478bd9Sstevel@tonic-gate 			break;
11777c478bd9Sstevel@tonic-gate 		case SCTP_PRIMARY_ADDR:
1178bd670b35SErik Nordmark 			retval = sctp_set_prim(sctp, invalp);
11797c478bd9Sstevel@tonic-gate 			break;
1180558fbd03Skcpoon 		case SCTP_ADAPTATION_LAYER: {
1181558fbd03Skcpoon 			struct sctp_setadaptation *ssb;
11827c478bd9Sstevel@tonic-gate 
1183558fbd03Skcpoon 			ssb = (struct sctp_setadaptation *)invalp;
1184558fbd03Skcpoon 			sctp->sctp_send_adaptation = 1;
1185558fbd03Skcpoon 			sctp->sctp_tx_adaptation_code = ssb->ssb_adaptation_ind;
11867c478bd9Sstevel@tonic-gate 			break;
11877c478bd9Sstevel@tonic-gate 		}
11887c478bd9Sstevel@tonic-gate 		case SCTP_PEER_ADDR_PARAMS:
1189bd670b35SErik Nordmark 			retval = sctp_set_peer_addr_params(sctp, invalp);
11907c478bd9Sstevel@tonic-gate 			break;
11917c478bd9Sstevel@tonic-gate 		case SCTP_DEFAULT_SEND_PARAM:
1192bd670b35SErik Nordmark 			retval = sctp_set_def_send_params(sctp, invalp);
11937c478bd9Sstevel@tonic-gate 			break;
11947c478bd9Sstevel@tonic-gate 		case SCTP_EVENTS: {
11957c478bd9Sstevel@tonic-gate 			struct sctp_event_subscribe *ev;
11967c478bd9Sstevel@tonic-gate 
11977c478bd9Sstevel@tonic-gate 			ev = (struct sctp_event_subscribe *)invalp;
11987c478bd9Sstevel@tonic-gate 			sctp->sctp_recvsndrcvinfo =
11997c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_data_io_event);
12007c478bd9Sstevel@tonic-gate 			sctp->sctp_recvassocevnt =
12017c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_association_event);
12027c478bd9Sstevel@tonic-gate 			sctp->sctp_recvpathevnt =
12037c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_address_event);
12047c478bd9Sstevel@tonic-gate 			sctp->sctp_recvsendfailevnt =
12057c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_send_failure_event);
12067c478bd9Sstevel@tonic-gate 			sctp->sctp_recvpeererr =
12077c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_peer_error_event);
12087c478bd9Sstevel@tonic-gate 			sctp->sctp_recvshutdownevnt =
12097c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_shutdown_event);
12107c478bd9Sstevel@tonic-gate 			sctp->sctp_recvpdevnt =
12117c478bd9Sstevel@tonic-gate 			    ONOFF(ev->sctp_partial_delivery_event);
12127c478bd9Sstevel@tonic-gate 			sctp->sctp_recvalevnt =
1213558fbd03Skcpoon 			    ONOFF(ev->sctp_adaptation_layer_event);
12147c478bd9Sstevel@tonic-gate 			break;
12157c478bd9Sstevel@tonic-gate 		}
12167c478bd9Sstevel@tonic-gate 		case SCTP_ADD_ADDR:
12177c478bd9Sstevel@tonic-gate 		case SCTP_REM_ADDR:
12187c478bd9Sstevel@tonic-gate 			/*
12197c478bd9Sstevel@tonic-gate 			 * The sctp_t has to be bound first before
12207c478bd9Sstevel@tonic-gate 			 * the address list can be changed.
12217c478bd9Sstevel@tonic-gate 			 */
12227c478bd9Sstevel@tonic-gate 			if (sctp->sctp_state < SCTPS_BOUND) {
12237c478bd9Sstevel@tonic-gate 				retval = EINVAL;
12247c478bd9Sstevel@tonic-gate 				break;
12257c478bd9Sstevel@tonic-gate 			}
1226bd670b35SErik Nordmark 			if (connp->conn_family == AF_INET) {
12277c478bd9Sstevel@tonic-gate 				addrcnt = inlen / sizeof (struct sockaddr_in);
12287c478bd9Sstevel@tonic-gate 			} else {
1229bd670b35SErik Nordmark 				ASSERT(connp->conn_family == AF_INET6);
12307c478bd9Sstevel@tonic-gate 				addrcnt = inlen / sizeof (struct sockaddr_in6);
12317c478bd9Sstevel@tonic-gate 			}
12327c478bd9Sstevel@tonic-gate 			if (name == SCTP_ADD_ADDR) {
12337c478bd9Sstevel@tonic-gate 				retval = sctp_bind_add(sctp, invalp, addrcnt,
1234bd670b35SErik Nordmark 				    B_TRUE, connp->conn_lport);
12357c478bd9Sstevel@tonic-gate 			} else {
12367c478bd9Sstevel@tonic-gate 				retval = sctp_bind_del(sctp, invalp, addrcnt,
12377c478bd9Sstevel@tonic-gate 				    B_TRUE);
12387c478bd9Sstevel@tonic-gate 			}
12397c478bd9Sstevel@tonic-gate 			break;
12407c478bd9Sstevel@tonic-gate 		case SCTP_UC_SWAP: {
12417c478bd9Sstevel@tonic-gate 			struct sctp_uc_swap *us;
12427c478bd9Sstevel@tonic-gate 
12437c478bd9Sstevel@tonic-gate 			/*
12447c478bd9Sstevel@tonic-gate 			 * Change handle & upcalls.
12457c478bd9Sstevel@tonic-gate 			 */
12467c478bd9Sstevel@tonic-gate 			us = (struct sctp_uc_swap *)invalp;
12477c478bd9Sstevel@tonic-gate 			sctp->sctp_ulpd = us->sus_handle;
12480f1702c5SYu Xiangning 			sctp->sctp_upcalls = us->sus_upcalls;
12497c478bd9Sstevel@tonic-gate 			break;
12507c478bd9Sstevel@tonic-gate 		}
12517c478bd9Sstevel@tonic-gate 		case SCTP_PRSCTP:
12527c478bd9Sstevel@tonic-gate 			sctp->sctp_prsctp_aware = onoff;
12537c478bd9Sstevel@tonic-gate 			break;
12547c478bd9Sstevel@tonic-gate 		case SCTP_I_WANT_MAPPED_V4_ADDR:
12557c478bd9Sstevel@tonic-gate 		case SCTP_MAXSEG:
12567c478bd9Sstevel@tonic-gate 		case SCTP_DISABLE_FRAGMENTS:
12577c478bd9Sstevel@tonic-gate 			/* Not yet supported. */
125888cda078Skcpoon 			retval = ENOPROTOOPT;
12597c478bd9Sstevel@tonic-gate 			break;
12607c478bd9Sstevel@tonic-gate 		}
1261bd670b35SErik Nordmark 		goto done;
12627c478bd9Sstevel@tonic-gate 
12637c478bd9Sstevel@tonic-gate 	case IPPROTO_IP:
1264bd670b35SErik Nordmark 		if (connp->conn_family != AF_INET) {
12657c478bd9Sstevel@tonic-gate 			retval = ENOPROTOOPT;
1266bd670b35SErik Nordmark 			goto done;
12677c478bd9Sstevel@tonic-gate 		}
12687c478bd9Sstevel@tonic-gate 		switch (name) {
12697c478bd9Sstevel@tonic-gate 		case IP_SEC_OPT:
12707c478bd9Sstevel@tonic-gate 			/*
12717c478bd9Sstevel@tonic-gate 			 * We should not allow policy setting after
12727c478bd9Sstevel@tonic-gate 			 * we start listening for connections.
12737c478bd9Sstevel@tonic-gate 			 */
12747c478bd9Sstevel@tonic-gate 			if (sctp->sctp_state >= SCTPS_LISTEN) {
12757c478bd9Sstevel@tonic-gate 				retval = EINVAL;
1276bd670b35SErik Nordmark 				goto done;
127743d18f1cSpriyanka 			}
127843d18f1cSpriyanka 			break;
127943d18f1cSpriyanka 		}
12807c478bd9Sstevel@tonic-gate 		break;
1281bd670b35SErik Nordmark 	case IPPROTO_IPV6:
1282bd670b35SErik Nordmark 		if (connp->conn_family != AF_INET6) {
1283bd670b35SErik Nordmark 			retval = EINVAL;
1284bd670b35SErik Nordmark 			goto done;
12857c478bd9Sstevel@tonic-gate 		}
12867c478bd9Sstevel@tonic-gate 
12877c478bd9Sstevel@tonic-gate 		switch (name) {
12887c478bd9Sstevel@tonic-gate 		case IPV6_RECVPKTINFO:
12897c478bd9Sstevel@tonic-gate 			/* Send it with the next msg */
12907c478bd9Sstevel@tonic-gate 			sctp->sctp_recvifindex = 0;
1291bd670b35SErik Nordmark 			break;
1292bd670b35SErik Nordmark 		case IPV6_RECVTCLASS:
1293bd670b35SErik Nordmark 			/* Force it to be sent up with the next msg */
1294bd670b35SErik Nordmark 			sctp->sctp_recvtclass = 0xffffffffU;
12957c478bd9Sstevel@tonic-gate 			break;
12967c478bd9Sstevel@tonic-gate 		case IPV6_RECVHOPLIMIT:
1297bd670b35SErik Nordmark 			/* Force it to be sent up with the next msg */
12987c478bd9Sstevel@tonic-gate 			sctp->sctp_recvhops = 0xffffffffU;
12997c478bd9Sstevel@tonic-gate 			break;
13007c478bd9Sstevel@tonic-gate 		case IPV6_SEC_OPT:
13017c478bd9Sstevel@tonic-gate 			/*
13027c478bd9Sstevel@tonic-gate 			 * We should not allow policy setting after
13037c478bd9Sstevel@tonic-gate 			 * we start listening for connections.
13047c478bd9Sstevel@tonic-gate 			 */
13057c478bd9Sstevel@tonic-gate 			if (sctp->sctp_state >= SCTPS_LISTEN) {
13067c478bd9Sstevel@tonic-gate 				retval = EINVAL;
1307bd670b35SErik Nordmark 				goto done;
13087c478bd9Sstevel@tonic-gate 			}
13097c478bd9Sstevel@tonic-gate 			break;
13107c478bd9Sstevel@tonic-gate 		case IPV6_V6ONLY:
13117c478bd9Sstevel@tonic-gate 			/*
13127c478bd9Sstevel@tonic-gate 			 * After the bound state, setting the v6only option
13137c478bd9Sstevel@tonic-gate 			 * is too late.
13147c478bd9Sstevel@tonic-gate 			 */
13157c478bd9Sstevel@tonic-gate 			if (sctp->sctp_state >= SCTPS_BOUND) {
13167c478bd9Sstevel@tonic-gate 				retval = EINVAL;
1317bd670b35SErik Nordmark 				goto done;
13187c478bd9Sstevel@tonic-gate 			}
13197c478bd9Sstevel@tonic-gate 			break;
13207c478bd9Sstevel@tonic-gate 		}
13217c478bd9Sstevel@tonic-gate 		break;
13227c478bd9Sstevel@tonic-gate 	}
13237c478bd9Sstevel@tonic-gate 
1324bd670b35SErik Nordmark 	retval = conn_opt_set(&coas, level, name, inlen, (uchar_t *)invalp,
1325bd670b35SErik Nordmark 	    B_FALSE, connp->conn_cred);
1326bd670b35SErik Nordmark 	if (retval != 0)
1327bd670b35SErik Nordmark 		goto done;
1328bd670b35SErik Nordmark 
1329bd670b35SErik Nordmark 	if (coas.coa_changed & COA_ROUTE_CHANGED) {
1330bd670b35SErik Nordmark 		sctp_faddr_t *fp;
1331bd670b35SErik Nordmark 		/*
1332bd670b35SErik Nordmark 		 * We recache the information which might pick a different
1333bd670b35SErik Nordmark 		 * source and redo IPsec as a result.
1334bd670b35SErik Nordmark 		 */
1335bd670b35SErik Nordmark 		for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->next)
1336bd670b35SErik Nordmark 			sctp_get_dest(sctp, fp);
1337bd670b35SErik Nordmark 	}
1338bd670b35SErik Nordmark 	if (coas.coa_changed & COA_HEADER_CHANGED) {
1339bd670b35SErik Nordmark 		retval = sctp_build_hdrs(sctp, KM_NOSLEEP);
1340bd670b35SErik Nordmark 		if (retval != 0)
1341bd670b35SErik Nordmark 			goto done;
1342bd670b35SErik Nordmark 	}
1343bd670b35SErik Nordmark 	if (coas.coa_changed & COA_WROFF_CHANGED) {
1344bd670b35SErik Nordmark 		connp->conn_wroff = connp->conn_ht_iphc_allocated +
1345bd670b35SErik Nordmark 		    sctps->sctps_wroff_xtra;
1346bd670b35SErik Nordmark 		if (sctp->sctp_current != NULL) {
1347bd670b35SErik Nordmark 			/*
1348bd670b35SErik Nordmark 			 * Could be setting options before setting up
1349bd670b35SErik Nordmark 			 * connection.
1350bd670b35SErik Nordmark 			 */
1351bd670b35SErik Nordmark 			sctp_set_ulp_prop(sctp);
1352bd670b35SErik Nordmark 		}
1353bd670b35SErik Nordmark 	}
1354bd670b35SErik Nordmark done:
13557c478bd9Sstevel@tonic-gate 	WAKE_SCTP(sctp);
13567c478bd9Sstevel@tonic-gate 	return (retval);
13577c478bd9Sstevel@tonic-gate }
13587c478bd9Sstevel@tonic-gate 
13597c478bd9Sstevel@tonic-gate /*
13607c478bd9Sstevel@tonic-gate  * SCTP exported kernel interface for geting the first source address of
13617c478bd9Sstevel@tonic-gate  * a sctp_t.  The parameter addr is assumed to have enough space to hold
13627c478bd9Sstevel@tonic-gate  * one socket address.
13637c478bd9Sstevel@tonic-gate  */
13647c478bd9Sstevel@tonic-gate int
13657c478bd9Sstevel@tonic-gate sctp_getsockname(sctp_t *sctp, struct sockaddr *addr, socklen_t *addrlen)
13667c478bd9Sstevel@tonic-gate {
13677c478bd9Sstevel@tonic-gate 	int	err = 0;
13687c478bd9Sstevel@tonic-gate 	int	addrcnt = 1;
13697c478bd9Sstevel@tonic-gate 	sin_t	*sin4;
13707c478bd9Sstevel@tonic-gate 	sin6_t	*sin6;
1371bd670b35SErik Nordmark 	conn_t	*connp = sctp->sctp_connp;
13727c478bd9Sstevel@tonic-gate 
13737c478bd9Sstevel@tonic-gate 	ASSERT(sctp != NULL);
13747c478bd9Sstevel@tonic-gate 
13757c478bd9Sstevel@tonic-gate 	RUN_SCTP(sctp);
1376bd670b35SErik Nordmark 	addr->sa_family = connp->conn_family;
1377bd670b35SErik Nordmark 	switch (connp->conn_family) {
13787c478bd9Sstevel@tonic-gate 	case AF_INET:
13797c478bd9Sstevel@tonic-gate 		sin4 = (sin_t *)addr;
13807c478bd9Sstevel@tonic-gate 		if ((sctp->sctp_state <= SCTPS_LISTEN) &&
13817c478bd9Sstevel@tonic-gate 		    sctp->sctp_bound_to_all) {
13827c478bd9Sstevel@tonic-gate 			sin4->sin_addr.s_addr = INADDR_ANY;
1383bd670b35SErik Nordmark 			sin4->sin_port = connp->conn_lport;
13847c478bd9Sstevel@tonic-gate 		} else {
13857c478bd9Sstevel@tonic-gate 			err = sctp_getmyaddrs(sctp, sin4, &addrcnt);
13867c478bd9Sstevel@tonic-gate 			if (err != 0) {
13877c478bd9Sstevel@tonic-gate 				*addrlen = 0;
13887c478bd9Sstevel@tonic-gate 				break;
13897c478bd9Sstevel@tonic-gate 			}
13907c478bd9Sstevel@tonic-gate 		}
13917c478bd9Sstevel@tonic-gate 		*addrlen = sizeof (struct sockaddr_in);
13927c478bd9Sstevel@tonic-gate 		break;
13937c478bd9Sstevel@tonic-gate 	case AF_INET6:
13947c478bd9Sstevel@tonic-gate 		sin6 = (sin6_t *)addr;
13957c478bd9Sstevel@tonic-gate 		if ((sctp->sctp_state <= SCTPS_LISTEN) &&
13967c478bd9Sstevel@tonic-gate 		    sctp->sctp_bound_to_all) {
13977c478bd9Sstevel@tonic-gate 			bzero(&sin6->sin6_addr, sizeof (sin6->sin6_addr));
1398bd670b35SErik Nordmark 			sin6->sin6_port = connp->conn_lport;
13997c478bd9Sstevel@tonic-gate 		} else {
14007c478bd9Sstevel@tonic-gate 			err = sctp_getmyaddrs(sctp, sin6, &addrcnt);
14017c478bd9Sstevel@tonic-gate 			if (err != 0) {
14027c478bd9Sstevel@tonic-gate 				*addrlen = 0;
14037c478bd9Sstevel@tonic-gate 				break;
14047c478bd9Sstevel@tonic-gate 			}
14057c478bd9Sstevel@tonic-gate 		}
14067c478bd9Sstevel@tonic-gate 		*addrlen = sizeof (struct sockaddr_in6);
1407bd670b35SErik Nordmark 		/* Note that flowinfo is only returned for getpeername */
14087c478bd9Sstevel@tonic-gate 		break;
14097c478bd9Sstevel@tonic-gate 	}
14107c478bd9Sstevel@tonic-gate 	WAKE_SCTP(sctp);
14117c478bd9Sstevel@tonic-gate 	return (err);
14127c478bd9Sstevel@tonic-gate }
14137c478bd9Sstevel@tonic-gate 
14147c478bd9Sstevel@tonic-gate /*
14157c478bd9Sstevel@tonic-gate  * SCTP exported kernel interface for geting the primary peer address of
14167c478bd9Sstevel@tonic-gate  * a sctp_t.  The parameter addr is assumed to have enough space to hold
14177c478bd9Sstevel@tonic-gate  * one socket address.
14187c478bd9Sstevel@tonic-gate  */
14197c478bd9Sstevel@tonic-gate int
14207c478bd9Sstevel@tonic-gate sctp_getpeername(sctp_t *sctp, struct sockaddr *addr, socklen_t *addrlen)
14217c478bd9Sstevel@tonic-gate {
14227c478bd9Sstevel@tonic-gate 	int	err = 0;
14237c478bd9Sstevel@tonic-gate 	int	addrcnt = 1;
14247c478bd9Sstevel@tonic-gate 	sin6_t	*sin6;
1425bd670b35SErik Nordmark 	conn_t	*connp = sctp->sctp_connp;
14267c478bd9Sstevel@tonic-gate 
14277c478bd9Sstevel@tonic-gate 	ASSERT(sctp != NULL);
14287c478bd9Sstevel@tonic-gate 
14297c478bd9Sstevel@tonic-gate 	RUN_SCTP(sctp);
1430bd670b35SErik Nordmark 	addr->sa_family = connp->conn_family;
1431bd670b35SErik Nordmark 	switch (connp->conn_family) {
14327c478bd9Sstevel@tonic-gate 	case AF_INET:
14337c478bd9Sstevel@tonic-gate 		err = sctp_getpeeraddrs(sctp, addr, &addrcnt);
14347c478bd9Sstevel@tonic-gate 		if (err != 0) {
14357c478bd9Sstevel@tonic-gate 			*addrlen = 0;
14367c478bd9Sstevel@tonic-gate 			break;
14377c478bd9Sstevel@tonic-gate 		}
14387c478bd9Sstevel@tonic-gate 		*addrlen = sizeof (struct sockaddr_in);
14397c478bd9Sstevel@tonic-gate 		break;
14407c478bd9Sstevel@tonic-gate 	case AF_INET6:
14417c478bd9Sstevel@tonic-gate 		sin6 = (sin6_t *)addr;
14427c478bd9Sstevel@tonic-gate 		err = sctp_getpeeraddrs(sctp, sin6, &addrcnt);
14437c478bd9Sstevel@tonic-gate 		if (err != 0) {
14447c478bd9Sstevel@tonic-gate 			*addrlen = 0;
14457c478bd9Sstevel@tonic-gate 			break;
14467c478bd9Sstevel@tonic-gate 		}
14477c478bd9Sstevel@tonic-gate 		*addrlen = sizeof (struct sockaddr_in6);
14487c478bd9Sstevel@tonic-gate 		break;
14497c478bd9Sstevel@tonic-gate 	}
14507c478bd9Sstevel@tonic-gate 	WAKE_SCTP(sctp);
14517c478bd9Sstevel@tonic-gate 	return (err);
14527c478bd9Sstevel@tonic-gate }
14537c478bd9Sstevel@tonic-gate 
14547c478bd9Sstevel@tonic-gate /*
14557c478bd9Sstevel@tonic-gate  * Return a list of IP addresses of the peer endpoint of this sctp_t.
14567c478bd9Sstevel@tonic-gate  * The parameter paddrs is supposed to be either (struct sockaddr_in *) or
14577c478bd9Sstevel@tonic-gate  * (struct sockaddr_in6 *) depending on the address family of the sctp_t.
14587c478bd9Sstevel@tonic-gate  */
14597c478bd9Sstevel@tonic-gate int
14607c478bd9Sstevel@tonic-gate sctp_getpeeraddrs(sctp_t *sctp, void *paddrs, int *addrcnt)
14617c478bd9Sstevel@tonic-gate {
14627c478bd9Sstevel@tonic-gate 	int			family;
14637c478bd9Sstevel@tonic-gate 	struct sockaddr_in	*sin4;
14647c478bd9Sstevel@tonic-gate 	struct sockaddr_in6	*sin6;
14657c478bd9Sstevel@tonic-gate 	int			max;
14667c478bd9Sstevel@tonic-gate 	int			cnt;
14677c478bd9Sstevel@tonic-gate 	sctp_faddr_t		*fp = sctp->sctp_faddrs;
14687c478bd9Sstevel@tonic-gate 	in6_addr_t		addr;
1469bd670b35SErik Nordmark 	conn_t			*connp = sctp->sctp_connp;
14707c478bd9Sstevel@tonic-gate 
14717c478bd9Sstevel@tonic-gate 	ASSERT(sctp != NULL);
14727c478bd9Sstevel@tonic-gate 
14737c478bd9Sstevel@tonic-gate 	if (sctp->sctp_faddrs == NULL)
14747c478bd9Sstevel@tonic-gate 		return (ENOTCONN);
14757c478bd9Sstevel@tonic-gate 
1476bd670b35SErik Nordmark 	family = connp->conn_family;
14777c478bd9Sstevel@tonic-gate 	max = *addrcnt;
14787c478bd9Sstevel@tonic-gate 
14797c478bd9Sstevel@tonic-gate 	/* If we want only one, give the primary */
14807c478bd9Sstevel@tonic-gate 	if (max == 1) {
14817c478bd9Sstevel@tonic-gate 		addr = sctp->sctp_primary->faddr;
14827c478bd9Sstevel@tonic-gate 		switch (family) {
14837c478bd9Sstevel@tonic-gate 		case AF_INET:
14847c478bd9Sstevel@tonic-gate 			sin4 = paddrs;
14857c478bd9Sstevel@tonic-gate 			IN6_V4MAPPED_TO_INADDR(&addr, &sin4->sin_addr);
1486bd670b35SErik Nordmark 			sin4->sin_port = connp->conn_fport;
14877c478bd9Sstevel@tonic-gate 			sin4->sin_family = AF_INET;
14887c478bd9Sstevel@tonic-gate 			break;
14897c478bd9Sstevel@tonic-gate 
14907c478bd9Sstevel@tonic-gate 		case AF_INET6:
14917c478bd9Sstevel@tonic-gate 			sin6 = paddrs;
14927c478bd9Sstevel@tonic-gate 			sin6->sin6_addr = addr;
1493bd670b35SErik Nordmark 			sin6->sin6_port = connp->conn_fport;
14947c478bd9Sstevel@tonic-gate 			sin6->sin6_family = AF_INET6;
1495bd670b35SErik Nordmark 			sin6->sin6_flowinfo = connp->conn_flowinfo;
1496bd670b35SErik Nordmark 			if (IN6_IS_ADDR_LINKSCOPE(&addr) &&
1497bd670b35SErik Nordmark 			    sctp->sctp_primary != NULL &&
1498bd670b35SErik Nordmark 			    (sctp->sctp_primary->ixa->ixa_flags &
1499bd670b35SErik Nordmark 			    IXAF_SCOPEID_SET)) {
1500bd670b35SErik Nordmark 				sin6->sin6_scope_id =
1501bd670b35SErik Nordmark 				    sctp->sctp_primary->ixa->ixa_scopeid;
1502bd670b35SErik Nordmark 			} else {
1503bd670b35SErik Nordmark 				sin6->sin6_scope_id = 0;
1504bd670b35SErik Nordmark 			}
1505bd670b35SErik Nordmark 			sin6->__sin6_src_id = 0;
15067c478bd9Sstevel@tonic-gate 			break;
15077c478bd9Sstevel@tonic-gate 		}
15087c478bd9Sstevel@tonic-gate 		return (0);
15097c478bd9Sstevel@tonic-gate 	}
15107c478bd9Sstevel@tonic-gate 
15117c478bd9Sstevel@tonic-gate 	for (cnt = 0; cnt < max && fp != NULL; cnt++, fp = fp->next) {
15127c478bd9Sstevel@tonic-gate 		addr = fp->faddr;
15137c478bd9Sstevel@tonic-gate 		switch (family) {
15147c478bd9Sstevel@tonic-gate 		case AF_INET:
15157c478bd9Sstevel@tonic-gate 			ASSERT(IN6_IS_ADDR_V4MAPPED(&addr));
15167c478bd9Sstevel@tonic-gate 			sin4 = (struct sockaddr_in *)paddrs + cnt;
15177c478bd9Sstevel@tonic-gate 			IN6_V4MAPPED_TO_INADDR(&addr, &sin4->sin_addr);
1518bd670b35SErik Nordmark 			sin4->sin_port = connp->conn_fport;
15197c478bd9Sstevel@tonic-gate 			sin4->sin_family = AF_INET;
15207c478bd9Sstevel@tonic-gate 			break;
15217c478bd9Sstevel@tonic-gate 		case AF_INET6:
15227c478bd9Sstevel@tonic-gate 			sin6 = (struct sockaddr_in6 *)paddrs + cnt;
15237c478bd9Sstevel@tonic-gate 			sin6->sin6_addr = addr;
1524bd670b35SErik Nordmark 			sin6->sin6_port = connp->conn_fport;
15257c478bd9Sstevel@tonic-gate 			sin6->sin6_family = AF_INET6;
1526bd670b35SErik Nordmark 			sin6->sin6_flowinfo = connp->conn_flowinfo;
1527bd670b35SErik Nordmark 			if (IN6_IS_ADDR_LINKSCOPE(&addr) &&
1528bd670b35SErik Nordmark 			    (fp->ixa->ixa_flags & IXAF_SCOPEID_SET))
1529bd670b35SErik Nordmark 				sin6->sin6_scope_id = fp->ixa->ixa_scopeid;
1530bd670b35SErik Nordmark 			else
1531bd670b35SErik Nordmark 				sin6->sin6_scope_id = 0;
1532bd670b35SErik Nordmark 			sin6->__sin6_src_id = 0;
15337c478bd9Sstevel@tonic-gate 			break;
15347c478bd9Sstevel@tonic-gate 		}
15357c478bd9Sstevel@tonic-gate 	}
15367c478bd9Sstevel@tonic-gate 	*addrcnt = cnt;
15377c478bd9Sstevel@tonic-gate 	return (0);
15387c478bd9Sstevel@tonic-gate }
1539