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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 23df19b344Svi * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/types.h> 307c478bd9Sstevel@tonic-gate #include <sys/systm.h> 317c478bd9Sstevel@tonic-gate #include <sys/stream.h> 327c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 337c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 347c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 357c478bd9Sstevel@tonic-gate #include <sys/socket.h> 367c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 377c478bd9Sstevel@tonic-gate #include <sys/list.h> 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #include <netinet/in.h> 407c478bd9Sstevel@tonic-gate #include <netinet/ip6.h> 417c478bd9Sstevel@tonic-gate #include <netinet/sctp.h> 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate #include <inet/common.h> 447c478bd9Sstevel@tonic-gate #include <inet/ip.h> 457c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 467c478bd9Sstevel@tonic-gate #include <inet/ip_if.h> 477c478bd9Sstevel@tonic-gate #include <inet/ipclassifier.h> 487c478bd9Sstevel@tonic-gate #include <inet/sctp_ip.h> 497c478bd9Sstevel@tonic-gate #include "sctp_impl.h" 507c478bd9Sstevel@tonic-gate #include "sctp_addr.h" 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate static void sctp_ipif_inactive(sctp_ipif_t *); 537c478bd9Sstevel@tonic-gate static sctp_ipif_t *sctp_lookup_ipif_addr(in6_addr_t *, boolean_t, 54*1d8c4025Svi zoneid_t zoneid, uint_t); 557c478bd9Sstevel@tonic-gate static int sctp_get_all_ipifs(sctp_t *, int); 56*1d8c4025Svi int sctp_valid_addr_list(sctp_t *, const void *, uint32_t, 57*1d8c4025Svi uchar_t *, size_t); 587c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *sctp_ipif_lookup(sctp_t *, uint_t); 59f551bb10Svi static int sctp_ipif_hash_insert(sctp_t *, sctp_ipif_t *, int, 60f551bb10Svi boolean_t dontsrc); 617c478bd9Sstevel@tonic-gate static void sctp_ipif_hash_remove(sctp_t *, sctp_ipif_t *); 627c478bd9Sstevel@tonic-gate static int sctp_compare_ipif_list(sctp_ipif_hash_t *, 637c478bd9Sstevel@tonic-gate sctp_ipif_hash_t *); 647c478bd9Sstevel@tonic-gate int sctp_compare_saddrs(sctp_t *, sctp_t *); 657c478bd9Sstevel@tonic-gate static int sctp_copy_ipifs(sctp_ipif_hash_t *, sctp_t *, int); 667c478bd9Sstevel@tonic-gate int sctp_dup_saddrs(sctp_t *, sctp_t *, int); 677c478bd9Sstevel@tonic-gate void sctp_free_saddrs(sctp_t *); 687c478bd9Sstevel@tonic-gate void sctp_update_ill(ill_t *, int); 697c478bd9Sstevel@tonic-gate void sctp_update_ipif(ipif_t *, int); 707c478bd9Sstevel@tonic-gate void sctp_move_ipif(ipif_t *, ill_t *, ill_t *); 717c478bd9Sstevel@tonic-gate void sctp_del_saddr(sctp_t *, sctp_saddr_ipif_t *); 727c478bd9Sstevel@tonic-gate void sctp_del_saddr_list(sctp_t *, const void *, int, 737c478bd9Sstevel@tonic-gate boolean_t); 74*1d8c4025Svi sctp_saddr_ipif_t *sctp_saddr_lookup(sctp_t *, in6_addr_t *, uint_t); 757c478bd9Sstevel@tonic-gate in6_addr_t sctp_get_valid_addr(sctp_t *, boolean_t); 767c478bd9Sstevel@tonic-gate int sctp_getmyaddrs(void *, void *, int *); 777c478bd9Sstevel@tonic-gate void sctp_saddr_init(); 787c478bd9Sstevel@tonic-gate void sctp_saddr_fini(); 79f551bb10Svi 807c478bd9Sstevel@tonic-gate #define SCTP_IPIF_USABLE(sctp_ipif_state) \ 817c478bd9Sstevel@tonic-gate ((sctp_ipif_state) == SCTP_IPIFS_UP || \ 82f551bb10Svi (sctp_ipif_state) == SCTP_IPIFS_DOWN) 83f551bb10Svi 84f551bb10Svi #define SCTP_IPIF_DISCARD(sctp_ipif_flags) \ 85f551bb10Svi ((sctp_ipif_flags) & (IPIF_PRIVATE | IPIF_DEPRECATED)) 86f551bb10Svi 87*1d8c4025Svi #define SCTP_IS_IPIF_LOOPBACK(ipif) \ 88*1d8c4025Svi ((ipif)->sctp_ipif_ill->sctp_ill_flags & PHYI_LOOPBACK) 89*1d8c4025Svi 90*1d8c4025Svi #define SCTP_IS_IPIF_LINKLOCAL(ipif) \ 91*1d8c4025Svi ((ipif)->sctp_ipif_isv6 && \ 92*1d8c4025Svi IN6_IS_ADDR_LINKLOCAL(&(ipif)->sctp_ipif_saddr)) 93f551bb10Svi 94f551bb10Svi #define SCTP_UNSUPP_AF(ipif, supp_af) \ 95f551bb10Svi ((!(ipif)->sctp_ipif_isv6 && !((supp_af) & PARM_SUPP_V4)) || \ 96f551bb10Svi ((ipif)->sctp_ipif_isv6 && !((supp_af) & PARM_SUPP_V6))) 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate #define SCTP_ILL_HASH_FN(index) ((index) % SCTP_ILL_HASH) 997c478bd9Sstevel@tonic-gate #define SCTP_IPIF_HASH_FN(seqid) ((seqid) % SCTP_IPIF_HASH) 1007c478bd9Sstevel@tonic-gate #define SCTP_ILL_TO_PHYINDEX(ill) ((ill)->ill_phyint->phyint_ifindex) 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate /* Global list of SCTP ILLs */ 1037c478bd9Sstevel@tonic-gate sctp_ill_hash_t sctp_g_ills[SCTP_ILL_HASH]; 1047c478bd9Sstevel@tonic-gate uint32_t sctp_ills_count = 0; 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate /* Global list of SCTP IPIFs */ 1077c478bd9Sstevel@tonic-gate sctp_ipif_hash_t sctp_g_ipifs[SCTP_IPIF_HASH]; 108*1d8c4025Svi uint32_t sctp_g_ipifs_count = 0; 1097c478bd9Sstevel@tonic-gate /* 1107c478bd9Sstevel@tonic-gate * 1117c478bd9Sstevel@tonic-gate * 1127c478bd9Sstevel@tonic-gate * SCTP Interface list manipulation functions, locking used. 1137c478bd9Sstevel@tonic-gate * 1147c478bd9Sstevel@tonic-gate * 1157c478bd9Sstevel@tonic-gate */ 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate /* 1187c478bd9Sstevel@tonic-gate * Delete an SCTP IPIF from the list if the refcount goes to 0 and it is 1197c478bd9Sstevel@tonic-gate * marked as condemned. Also, check if the ILL needs to go away. 1207c478bd9Sstevel@tonic-gate * Called with no locks held. 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate static void 1237c478bd9Sstevel@tonic-gate sctp_ipif_inactive(sctp_ipif_t *sctp_ipif) 1247c478bd9Sstevel@tonic-gate { 1257c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill; 1267c478bd9Sstevel@tonic-gate uint_t ipif_index; 1277c478bd9Sstevel@tonic-gate uint_t ill_index; 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ills_lock, RW_READER); 1307c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ipifs_lock, RW_WRITER); 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate ipif_index = SCTP_IPIF_HASH_FN(sctp_ipif->sctp_ipif_id); 1337c478bd9Sstevel@tonic-gate sctp_ill = sctp_ipif->sctp_ipif_ill; 1347c478bd9Sstevel@tonic-gate ASSERT(sctp_ill != NULL); 1357c478bd9Sstevel@tonic-gate ill_index = SCTP_ILL_HASH_FN(sctp_ill->sctp_ill_index); 1367c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_state != SCTP_IPIFS_CONDEMNED || 1377c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_refcnt != 0) { 1387c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 1397c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 1407c478bd9Sstevel@tonic-gate return; 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate list_remove(&sctp_g_ipifs[ipif_index].sctp_ipif_list, sctp_ipif); 1437c478bd9Sstevel@tonic-gate sctp_g_ipifs[ipif_index].ipif_count--; 1447c478bd9Sstevel@tonic-gate sctp_g_ipifs_count--; 1457c478bd9Sstevel@tonic-gate rw_destroy(&sctp_ipif->sctp_ipif_lock); 1467c478bd9Sstevel@tonic-gate kmem_free(sctp_ipif, sizeof (sctp_ipif_t)); 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&sctp_ill->sctp_ill_ipifcnt, -1); 1497c478bd9Sstevel@tonic-gate if (rw_tryupgrade(&sctp_g_ills_lock) != 0) { 1507c478bd9Sstevel@tonic-gate rw_downgrade(&sctp_g_ipifs_lock); 1517c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0 && 1527c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) { 1537c478bd9Sstevel@tonic-gate list_remove(&sctp_g_ills[ill_index].sctp_ill_list, 1547c478bd9Sstevel@tonic-gate (void *)sctp_ill); 1557c478bd9Sstevel@tonic-gate sctp_g_ills[ill_index].ill_count--; 1567c478bd9Sstevel@tonic-gate sctp_ills_count--; 1577c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 1587c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length); 1597c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate } 1627c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 1637c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 1647c478bd9Sstevel@tonic-gate } 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate /* 1677c478bd9Sstevel@tonic-gate * Lookup an SCTP IPIF given an IP address. Increments sctp_ipif refcnt. 1687c478bd9Sstevel@tonic-gate * Called with no locks held. 1697c478bd9Sstevel@tonic-gate */ 1707c478bd9Sstevel@tonic-gate static sctp_ipif_t * 171*1d8c4025Svi sctp_lookup_ipif_addr(in6_addr_t *addr, boolean_t refhold, zoneid_t zoneid, 172*1d8c4025Svi uint_t ifindex) 1737c478bd9Sstevel@tonic-gate { 1747c478bd9Sstevel@tonic-gate int i; 1757c478bd9Sstevel@tonic-gate int j; 1767c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ipifs_lock, RW_READER); 1797c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 1807c478bd9Sstevel@tonic-gate if (sctp_g_ipifs[i].ipif_count == 0) 1817c478bd9Sstevel@tonic-gate continue; 1827c478bd9Sstevel@tonic-gate sctp_ipif = list_head(&sctp_g_ipifs[i].sctp_ipif_list); 1837c478bd9Sstevel@tonic-gate for (j = 0; j < sctp_g_ipifs[i].ipif_count; j++) { 1847c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 1857c478bd9Sstevel@tonic-gate if (zoneid == sctp_ipif->sctp_ipif_zoneid && 1867c478bd9Sstevel@tonic-gate SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state) && 187*1d8c4025Svi (ifindex == 0 || ifindex == 188*1d8c4025Svi sctp_ipif->sctp_ipif_ill->sctp_ill_index) && 1897c478bd9Sstevel@tonic-gate IN6_ARE_ADDR_EQUAL(&sctp_ipif->sctp_ipif_saddr, 1907c478bd9Sstevel@tonic-gate addr)) { 1917c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 1927c478bd9Sstevel@tonic-gate if (refhold) 1937c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(sctp_ipif); 1947c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 1957c478bd9Sstevel@tonic-gate return (sctp_ipif); 1967c478bd9Sstevel@tonic-gate } 1977c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 1987c478bd9Sstevel@tonic-gate sctp_ipif = list_next(&sctp_g_ipifs[i].sctp_ipif_list, 1997c478bd9Sstevel@tonic-gate sctp_ipif); 2007c478bd9Sstevel@tonic-gate } 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 2037c478bd9Sstevel@tonic-gate return (NULL); 2047c478bd9Sstevel@tonic-gate } 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate /* 2077c478bd9Sstevel@tonic-gate * Populate the list with all the SCTP ipifs for a given ipversion. 2087c478bd9Sstevel@tonic-gate * Increments sctp_ipif refcnt. 2097c478bd9Sstevel@tonic-gate * Called with no locks held. 2107c478bd9Sstevel@tonic-gate */ 2117c478bd9Sstevel@tonic-gate static int 2127c478bd9Sstevel@tonic-gate sctp_get_all_ipifs(sctp_t *sctp, int sleep) 2137c478bd9Sstevel@tonic-gate { 2147c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 2157c478bd9Sstevel@tonic-gate int i; 2167c478bd9Sstevel@tonic-gate int j; 2177c478bd9Sstevel@tonic-gate int error = 0; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ipifs_lock, RW_READER); 2207c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 2217c478bd9Sstevel@tonic-gate if (sctp_g_ipifs[i].ipif_count == 0) 2227c478bd9Sstevel@tonic-gate continue; 2237c478bd9Sstevel@tonic-gate sctp_ipif = list_head(&sctp_g_ipifs[i].sctp_ipif_list); 2247c478bd9Sstevel@tonic-gate for (j = 0; j < sctp_g_ipifs[i].ipif_count; j++) { 2257c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 226f551bb10Svi if (SCTP_IPIF_DISCARD(sctp_ipif->sctp_ipif_flags) || 2277c478bd9Sstevel@tonic-gate !SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state) || 228f551bb10Svi sctp_ipif->sctp_ipif_zoneid != sctp->sctp_zoneid || 2297c478bd9Sstevel@tonic-gate (sctp->sctp_ipversion == IPV4_VERSION && 230f551bb10Svi sctp_ipif->sctp_ipif_isv6) || 2317c478bd9Sstevel@tonic-gate (sctp->sctp_connp->conn_ipv6_v6only && 232f551bb10Svi !sctp_ipif->sctp_ipif_isv6)) { 2337c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 2347c478bd9Sstevel@tonic-gate sctp_ipif = list_next( 2357c478bd9Sstevel@tonic-gate &sctp_g_ipifs[i].sctp_ipif_list, sctp_ipif); 2367c478bd9Sstevel@tonic-gate continue; 2377c478bd9Sstevel@tonic-gate } 2387c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 2397c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(sctp_ipif); 240f551bb10Svi error = sctp_ipif_hash_insert(sctp, sctp_ipif, sleep, 241f551bb10Svi B_FALSE); 2427c478bd9Sstevel@tonic-gate if (error != 0) 2437c478bd9Sstevel@tonic-gate goto free_stuff; 2447c478bd9Sstevel@tonic-gate sctp_ipif = list_next(&sctp_g_ipifs[i].sctp_ipif_list, 2457c478bd9Sstevel@tonic-gate sctp_ipif); 2467c478bd9Sstevel@tonic-gate } 2477c478bd9Sstevel@tonic-gate } 2487c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 2497c478bd9Sstevel@tonic-gate return (0); 2507c478bd9Sstevel@tonic-gate free_stuff: 2517c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 2527c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp); 2537c478bd9Sstevel@tonic-gate return (ENOMEM); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate /* 2577c478bd9Sstevel@tonic-gate * Given a list of address, fills in the list of SCTP ipifs if all the addresses 2587c478bd9Sstevel@tonic-gate * are present in the SCTP interface list, return number of addresses filled 259*1d8c4025Svi * or error. If the caller wants the list of addresses, it sends a pre-allocated 260*1d8c4025Svi * buffer - list. Currently, this list is only used on a clustered node when 261*1d8c4025Svi * the SCTP is in the listen state (from sctp_bind_add()). When called on a 262*1d8c4025Svi * clustered node, the input is always a list of addresses (even if the 263*1d8c4025Svi * original bind() was to INADDR_ANY). 2647c478bd9Sstevel@tonic-gate * Called with no locks held. 2657c478bd9Sstevel@tonic-gate */ 2667c478bd9Sstevel@tonic-gate int 267*1d8c4025Svi sctp_valid_addr_list(sctp_t *sctp, const void *addrs, uint32_t addrcnt, 268*1d8c4025Svi uchar_t *list, size_t lsize) 2697c478bd9Sstevel@tonic-gate { 2707c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 2717c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 2727c478bd9Sstevel@tonic-gate struct in_addr *addr4; 2737c478bd9Sstevel@tonic-gate in6_addr_t addr; 2747c478bd9Sstevel@tonic-gate int cnt; 2757c478bd9Sstevel@tonic-gate int err = 0; 2767c478bd9Sstevel@tonic-gate int saddr_cnt = 0; 2777c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 2787c478bd9Sstevel@tonic-gate boolean_t bind_to_all = B_FALSE; 2797c478bd9Sstevel@tonic-gate boolean_t check_addrs = B_FALSE; 2807c478bd9Sstevel@tonic-gate boolean_t check_lport = B_FALSE; 281*1d8c4025Svi uchar_t *p = list; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate /* 2847c478bd9Sstevel@tonic-gate * Need to check for port and address depending on the state. 2857c478bd9Sstevel@tonic-gate * After a socket is bound, we need to make sure that subsequent 2867c478bd9Sstevel@tonic-gate * bindx() has correct port. After an association is established, 2877c478bd9Sstevel@tonic-gate * we need to check for changing the bound address to invalid 2887c478bd9Sstevel@tonic-gate * addresses. 2897c478bd9Sstevel@tonic-gate */ 2907c478bd9Sstevel@tonic-gate if (sctp->sctp_state >= SCTPS_BOUND) { 2917c478bd9Sstevel@tonic-gate check_lport = B_TRUE; 2927c478bd9Sstevel@tonic-gate if (sctp->sctp_state > SCTPS_LISTEN) 2937c478bd9Sstevel@tonic-gate check_addrs = B_TRUE; 2947c478bd9Sstevel@tonic-gate } 295*1d8c4025Svi 2967c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 2977c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 2987c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 2997c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 3007c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < addrcnt; cnt++) { 3017c478bd9Sstevel@tonic-gate boolean_t lookup_saddr = B_TRUE; 302*1d8c4025Svi uint_t ifindex = 0; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 3057c478bd9Sstevel@tonic-gate case AF_INET: 3067c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + cnt; 3077c478bd9Sstevel@tonic-gate if (sin4->sin_family != AF_INET || (check_lport && 3087c478bd9Sstevel@tonic-gate sin4->sin_port != sctp->sctp_lport)) { 3097c478bd9Sstevel@tonic-gate err = EINVAL; 3107c478bd9Sstevel@tonic-gate goto free_ret; 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate addr4 = &sin4->sin_addr; 3137c478bd9Sstevel@tonic-gate if (check_addrs && 3147c478bd9Sstevel@tonic-gate (addr4->s_addr == INADDR_ANY || 3157c478bd9Sstevel@tonic-gate addr4->s_addr == INADDR_BROADCAST || 3167c478bd9Sstevel@tonic-gate IN_MULTICAST(addr4->s_addr))) { 3177c478bd9Sstevel@tonic-gate err = EINVAL; 3187c478bd9Sstevel@tonic-gate goto free_ret; 3197c478bd9Sstevel@tonic-gate } 3207c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(addr4, &addr); 3217c478bd9Sstevel@tonic-gate if (!check_addrs && addr4->s_addr == INADDR_ANY) { 3227c478bd9Sstevel@tonic-gate lookup_saddr = B_FALSE; 3237c478bd9Sstevel@tonic-gate bind_to_all = B_TRUE; 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate break; 3277c478bd9Sstevel@tonic-gate case AF_INET6: 3287c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + cnt; 3297c478bd9Sstevel@tonic-gate if (sin6->sin6_family != AF_INET6 || (check_lport && 3307c478bd9Sstevel@tonic-gate sin6->sin6_port != sctp->sctp_lport)) { 3317c478bd9Sstevel@tonic-gate err = EINVAL; 3327c478bd9Sstevel@tonic-gate goto free_ret; 3337c478bd9Sstevel@tonic-gate } 3347c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 335*1d8c4025Svi /* Contains the interface index */ 336*1d8c4025Svi ifindex = sin6->sin6_scope_id; 3377c478bd9Sstevel@tonic-gate if (sctp->sctp_connp->conn_ipv6_v6only && 3387c478bd9Sstevel@tonic-gate IN6_IS_ADDR_V4MAPPED(&addr)) { 3397c478bd9Sstevel@tonic-gate err = EAFNOSUPPORT; 3407c478bd9Sstevel@tonic-gate goto free_ret; 3417c478bd9Sstevel@tonic-gate } 3427c478bd9Sstevel@tonic-gate if (check_addrs && 3437c478bd9Sstevel@tonic-gate (IN6_IS_ADDR_LINKLOCAL(&addr) || 3447c478bd9Sstevel@tonic-gate IN6_IS_ADDR_MULTICAST(&addr) || 3457c478bd9Sstevel@tonic-gate IN6_IS_ADDR_UNSPECIFIED(&addr))) { 3467c478bd9Sstevel@tonic-gate err = EINVAL; 3477c478bd9Sstevel@tonic-gate goto free_ret; 3487c478bd9Sstevel@tonic-gate } 3497c478bd9Sstevel@tonic-gate if (!check_addrs && IN6_IS_ADDR_UNSPECIFIED(&addr)) { 3507c478bd9Sstevel@tonic-gate lookup_saddr = B_FALSE; 3517c478bd9Sstevel@tonic-gate bind_to_all = B_TRUE; 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate break; 3557c478bd9Sstevel@tonic-gate default: 3567c478bd9Sstevel@tonic-gate err = EAFNOSUPPORT; 3577c478bd9Sstevel@tonic-gate goto free_ret; 3587c478bd9Sstevel@tonic-gate } 3597c478bd9Sstevel@tonic-gate if (lookup_saddr) { 3607c478bd9Sstevel@tonic-gate ipif = sctp_lookup_ipif_addr(&addr, B_TRUE, 361*1d8c4025Svi sctp->sctp_zoneid, ifindex); 3627c478bd9Sstevel@tonic-gate if (ipif == NULL) { 3637c478bd9Sstevel@tonic-gate /* Address not in the list */ 3647c478bd9Sstevel@tonic-gate err = EINVAL; 3657c478bd9Sstevel@tonic-gate goto free_ret; 366*1d8c4025Svi } else if (check_addrs && SCTP_IS_IPIF_LOOPBACK(ipif) && 367*1d8c4025Svi cl_sctp_check_addrs == NULL) { 3687c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif); 3697c478bd9Sstevel@tonic-gate err = EINVAL; 3707c478bd9Sstevel@tonic-gate goto free_ret; 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate if (!bind_to_all) { 374f551bb10Svi /* 375f551bb10Svi * If an address is added after association setup, 376f551bb10Svi * we need to wait for the peer to send us an ASCONF 377f551bb10Svi * ACK before we can start using it. 378f551bb10Svi * saddr_ipif_dontsrc will be reset (to 0) when we 379f551bb10Svi * get the ASCONF ACK for this address. 380f551bb10Svi */ 381f551bb10Svi err = sctp_ipif_hash_insert(sctp, ipif, KM_SLEEP, 382f551bb10Svi check_addrs ? B_TRUE : B_FALSE); 3837c478bd9Sstevel@tonic-gate if (err != 0) { 3847c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif); 3857c478bd9Sstevel@tonic-gate if (check_addrs && err == EALREADY) 3867c478bd9Sstevel@tonic-gate err = EADDRINUSE; 3877c478bd9Sstevel@tonic-gate goto free_ret; 3887c478bd9Sstevel@tonic-gate } 3897c478bd9Sstevel@tonic-gate saddr_cnt++; 390*1d8c4025Svi if (lsize >= sizeof (addr)) { 391*1d8c4025Svi bcopy(&addr, p, sizeof (addr)); 392*1d8c4025Svi p += sizeof (addr); 393*1d8c4025Svi lsize -= sizeof (addr); 394*1d8c4025Svi } 3957c478bd9Sstevel@tonic-gate } 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate if (bind_to_all) { 3987c478bd9Sstevel@tonic-gate /* 3997c478bd9Sstevel@tonic-gate * Free whatever we might have added before encountering 4007c478bd9Sstevel@tonic-gate * inaddr_any. 4017c478bd9Sstevel@tonic-gate */ 4027c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs > 0) { 4037c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp); 4047c478bd9Sstevel@tonic-gate ASSERT(sctp->sctp_nsaddrs == 0); 4057c478bd9Sstevel@tonic-gate } 4067c478bd9Sstevel@tonic-gate err = sctp_get_all_ipifs(sctp, KM_SLEEP); 4077c478bd9Sstevel@tonic-gate if (err != 0) 4087c478bd9Sstevel@tonic-gate return (err); 4097c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 1; 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 4127c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 4137c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 4147c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 4157c478bd9Sstevel@tonic-gate return (0); 4167c478bd9Sstevel@tonic-gate free_ret: 4177c478bd9Sstevel@tonic-gate if (saddr_cnt != 0) 4187c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp, addrs, saddr_cnt, B_TRUE); 4197c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 4207c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 4217c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 4227c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 4237c478bd9Sstevel@tonic-gate return (err); 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t * 4277c478bd9Sstevel@tonic-gate sctp_ipif_lookup(sctp_t *sctp, uint_t ipif_index) 4287c478bd9Sstevel@tonic-gate { 4297c478bd9Sstevel@tonic-gate int cnt; 4307c478bd9Sstevel@tonic-gate int seqid = SCTP_IPIF_HASH_FN(ipif_index); 4317c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *ipif_obj; 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[seqid].ipif_count == 0) 4347c478bd9Sstevel@tonic-gate return (NULL); 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate ipif_obj = list_head(&sctp->sctp_saddrs[seqid].sctp_ipif_list); 4377c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < sctp->sctp_saddrs[seqid].ipif_count; cnt++) { 4387c478bd9Sstevel@tonic-gate if (ipif_obj->saddr_ipifp->sctp_ipif_id == ipif_index) 4397c478bd9Sstevel@tonic-gate return (ipif_obj); 4407c478bd9Sstevel@tonic-gate ipif_obj = list_next(&sctp->sctp_saddrs[seqid].sctp_ipif_list, 4417c478bd9Sstevel@tonic-gate ipif_obj); 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate return (NULL); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate static int 447f551bb10Svi sctp_ipif_hash_insert(sctp_t *sctp, sctp_ipif_t *ipif, int sleep, 448f551bb10Svi boolean_t dontsrc) 4497c478bd9Sstevel@tonic-gate { 4507c478bd9Sstevel@tonic-gate int cnt; 4517c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *ipif_obj; 4527c478bd9Sstevel@tonic-gate int seqid = SCTP_IPIF_HASH_FN(ipif->sctp_ipif_id); 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate ipif_obj = list_head(&sctp->sctp_saddrs[seqid].sctp_ipif_list); 4557c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < sctp->sctp_saddrs[seqid].ipif_count; cnt++) { 4567c478bd9Sstevel@tonic-gate if (ipif_obj->saddr_ipifp->sctp_ipif_id == ipif->sctp_ipif_id) 4577c478bd9Sstevel@tonic-gate return (EALREADY); 4587c478bd9Sstevel@tonic-gate ipif_obj = list_next(&sctp->sctp_saddrs[seqid].sctp_ipif_list, 4597c478bd9Sstevel@tonic-gate ipif_obj); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate ipif_obj = kmem_zalloc(sizeof (sctp_saddr_ipif_t), sleep); 4627c478bd9Sstevel@tonic-gate if (ipif_obj == NULL) { 4637c478bd9Sstevel@tonic-gate /* Need to do something */ 4647c478bd9Sstevel@tonic-gate return (ENOMEM); 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate ipif_obj->saddr_ipifp = ipif; 467f551bb10Svi ipif_obj->saddr_ipif_dontsrc = dontsrc ? 1 : 0; 4687c478bd9Sstevel@tonic-gate list_insert_tail(&sctp->sctp_saddrs[seqid].sctp_ipif_list, ipif_obj); 4697c478bd9Sstevel@tonic-gate sctp->sctp_saddrs[seqid].ipif_count++; 4707c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs++; 4717c478bd9Sstevel@tonic-gate return (0); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate static void 4757c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp_t *sctp, sctp_ipif_t *ipif) 4767c478bd9Sstevel@tonic-gate { 4777c478bd9Sstevel@tonic-gate int cnt; 4787c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *ipif_obj; 4797c478bd9Sstevel@tonic-gate int seqid = SCTP_IPIF_HASH_FN(ipif->sctp_ipif_id); 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate ipif_obj = list_head(&sctp->sctp_saddrs[seqid].sctp_ipif_list); 4827c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < sctp->sctp_saddrs[seqid].ipif_count; cnt++) { 4837c478bd9Sstevel@tonic-gate if (ipif_obj->saddr_ipifp->sctp_ipif_id == ipif->sctp_ipif_id) { 4847c478bd9Sstevel@tonic-gate list_remove(&sctp->sctp_saddrs[seqid].sctp_ipif_list, 4857c478bd9Sstevel@tonic-gate ipif_obj); 4867c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs--; 4877c478bd9Sstevel@tonic-gate sctp->sctp_saddrs[seqid].ipif_count--; 4887c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif_obj->saddr_ipifp); 4897c478bd9Sstevel@tonic-gate kmem_free(ipif_obj, sizeof (sctp_saddr_ipif_t)); 4907c478bd9Sstevel@tonic-gate break; 4917c478bd9Sstevel@tonic-gate } 4927c478bd9Sstevel@tonic-gate ipif_obj = list_next(&sctp->sctp_saddrs[seqid].sctp_ipif_list, 4937c478bd9Sstevel@tonic-gate ipif_obj); 4947c478bd9Sstevel@tonic-gate } 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate static int 4987c478bd9Sstevel@tonic-gate sctp_compare_ipif_list(sctp_ipif_hash_t *list1, sctp_ipif_hash_t *list2) 4997c478bd9Sstevel@tonic-gate { 5007c478bd9Sstevel@tonic-gate int i; 5017c478bd9Sstevel@tonic-gate int j; 5027c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj1; 5037c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj2; 5047c478bd9Sstevel@tonic-gate int overlap = 0; 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate obj1 = list_head(&list1->sctp_ipif_list); 5077c478bd9Sstevel@tonic-gate for (i = 0; i < list1->ipif_count; i++) { 5087c478bd9Sstevel@tonic-gate obj2 = list_head(&list2->sctp_ipif_list); 5097c478bd9Sstevel@tonic-gate for (j = 0; j < list2->ipif_count; j++) { 5107c478bd9Sstevel@tonic-gate if (obj1->saddr_ipifp->sctp_ipif_id == 5117c478bd9Sstevel@tonic-gate obj2->saddr_ipifp->sctp_ipif_id) { 5127c478bd9Sstevel@tonic-gate overlap++; 5137c478bd9Sstevel@tonic-gate break; 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate obj2 = list_next(&list2->sctp_ipif_list, 5167c478bd9Sstevel@tonic-gate obj2); 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate obj1 = list_next(&list1->sctp_ipif_list, obj1); 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate return (overlap); 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate int 5247c478bd9Sstevel@tonic-gate sctp_compare_saddrs(sctp_t *sctp1, sctp_t *sctp2) 5257c478bd9Sstevel@tonic-gate { 5267c478bd9Sstevel@tonic-gate int i; 5277c478bd9Sstevel@tonic-gate int overlap = 0; 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 5307c478bd9Sstevel@tonic-gate overlap += sctp_compare_ipif_list(&sctp1->sctp_saddrs[i], 5317c478bd9Sstevel@tonic-gate &sctp2->sctp_saddrs[i]); 5327c478bd9Sstevel@tonic-gate } 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate if (sctp1->sctp_nsaddrs == sctp2->sctp_nsaddrs && 5357c478bd9Sstevel@tonic-gate overlap == sctp1->sctp_nsaddrs) { 5367c478bd9Sstevel@tonic-gate return (SCTP_ADDR_EQUAL); 5377c478bd9Sstevel@tonic-gate } 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate if (overlap == sctp1->sctp_nsaddrs) 5407c478bd9Sstevel@tonic-gate return (SCTP_ADDR_SUBSET); 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate if (overlap > 0) 5437c478bd9Sstevel@tonic-gate return (SCTP_ADDR_OVERLAP); 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate return (SCTP_ADDR_DISJOINT); 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate static int 5497c478bd9Sstevel@tonic-gate sctp_copy_ipifs(sctp_ipif_hash_t *list1, sctp_t *sctp2, int sleep) 5507c478bd9Sstevel@tonic-gate { 5517c478bd9Sstevel@tonic-gate int i; 5527c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 5537c478bd9Sstevel@tonic-gate int error = 0; 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate obj = list_head(&list1->sctp_ipif_list); 5567c478bd9Sstevel@tonic-gate for (i = 0; i < list1->ipif_count; i++) { 5577c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(obj->saddr_ipifp); 558f551bb10Svi error = sctp_ipif_hash_insert(sctp2, obj->saddr_ipifp, sleep, 559f551bb10Svi B_FALSE); 5607c478bd9Sstevel@tonic-gate if (error != 0) 5617c478bd9Sstevel@tonic-gate return (error); 5627c478bd9Sstevel@tonic-gate obj = list_next(&list1->sctp_ipif_list, obj); 5637c478bd9Sstevel@tonic-gate } 5647c478bd9Sstevel@tonic-gate return (error); 5657c478bd9Sstevel@tonic-gate } 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate int 5687c478bd9Sstevel@tonic-gate sctp_dup_saddrs(sctp_t *sctp1, sctp_t *sctp2, int sleep) 5697c478bd9Sstevel@tonic-gate { 5707c478bd9Sstevel@tonic-gate int error = 0; 5717c478bd9Sstevel@tonic-gate int i; 5727c478bd9Sstevel@tonic-gate 573f551bb10Svi if (sctp1 == NULL || sctp1->sctp_bound_to_all == 1) 5747c478bd9Sstevel@tonic-gate return (sctp_get_all_ipifs(sctp2, sleep)); 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 5777c478bd9Sstevel@tonic-gate if (sctp1->sctp_saddrs[i].ipif_count == 0) 5787c478bd9Sstevel@tonic-gate continue; 5797c478bd9Sstevel@tonic-gate error = sctp_copy_ipifs(&sctp1->sctp_saddrs[i], sctp2, sleep); 5807c478bd9Sstevel@tonic-gate if (error != 0) { 5817c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp2); 5827c478bd9Sstevel@tonic-gate return (error); 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate return (0); 5867c478bd9Sstevel@tonic-gate } 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate void 5897c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp_t *sctp) 5907c478bd9Sstevel@tonic-gate { 5917c478bd9Sstevel@tonic-gate int i; 5927c478bd9Sstevel@tonic-gate int l; 5937c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs == 0) 5967c478bd9Sstevel@tonic-gate return; 5977c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 5987c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 5997c478bd9Sstevel@tonic-gate continue; 6007c478bd9Sstevel@tonic-gate obj = list_tail(&sctp->sctp_saddrs[i].sctp_ipif_list); 6017c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 6027c478bd9Sstevel@tonic-gate list_remove(&sctp->sctp_saddrs[i].sctp_ipif_list, obj); 6037c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(obj->saddr_ipifp); 6047c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs--; 6057c478bd9Sstevel@tonic-gate kmem_free(obj, sizeof (sctp_saddr_ipif_t)); 6067c478bd9Sstevel@tonic-gate obj = list_tail(&sctp->sctp_saddrs[i].sctp_ipif_list); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate sctp->sctp_saddrs[i].ipif_count = 0; 6097c478bd9Sstevel@tonic-gate } 610f551bb10Svi if (sctp->sctp_bound_to_all == 1) 611f551bb10Svi sctp->sctp_bound_to_all = 0; 6127c478bd9Sstevel@tonic-gate ASSERT(sctp->sctp_nsaddrs == 0); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate /* 6167c478bd9Sstevel@tonic-gate * Add/Delete the given ILL from the SCTP ILL list. Called with no locks 6177c478bd9Sstevel@tonic-gate * held. 6187c478bd9Sstevel@tonic-gate */ 6197c478bd9Sstevel@tonic-gate void 6207c478bd9Sstevel@tonic-gate sctp_update_ill(ill_t *ill, int op) 6217c478bd9Sstevel@tonic-gate { 6227c478bd9Sstevel@tonic-gate int i; 6237c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill = NULL; 6247c478bd9Sstevel@tonic-gate uint_t index; 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate ip2dbg(("sctp_update_ill: %s\n", ill->ill_name)); 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ills_lock, RW_WRITER); 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(ill)); 6317c478bd9Sstevel@tonic-gate sctp_ill = list_head(&sctp_g_ills[index].sctp_ill_list); 6327c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ills[index].ill_count; i++) { 6337c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(ill)) 6347c478bd9Sstevel@tonic-gate break; 6357c478bd9Sstevel@tonic-gate sctp_ill = list_next(&sctp_g_ills[index].sctp_ill_list, 6367c478bd9Sstevel@tonic-gate sctp_ill); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate switch (op) { 6407c478bd9Sstevel@tonic-gate case SCTP_ILL_INSERT: 6417c478bd9Sstevel@tonic-gate if (sctp_ill != NULL) { 6427c478bd9Sstevel@tonic-gate /* Unmark it if it is condemned */ 6437c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) 6447c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state = 0; 6457c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 6467c478bd9Sstevel@tonic-gate return; 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate sctp_ill = kmem_zalloc(sizeof (sctp_ill_t), KM_NOSLEEP); 6497c478bd9Sstevel@tonic-gate /* Need to re-try? */ 6507c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 6517c478bd9Sstevel@tonic-gate ip1dbg(("sctp_ill_insert: mem error..\n")); 6527c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 6537c478bd9Sstevel@tonic-gate return; 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name = 6567c478bd9Sstevel@tonic-gate kmem_zalloc(ill->ill_name_length, KM_NOSLEEP); 6577c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_name == NULL) { 6587c478bd9Sstevel@tonic-gate ip1dbg(("sctp_ill_insert: mem error..\n")); 6597c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 6607c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 6617c478bd9Sstevel@tonic-gate return; 6627c478bd9Sstevel@tonic-gate } 6637c478bd9Sstevel@tonic-gate bcopy(ill->ill_name, sctp_ill->sctp_ill_name, 6647c478bd9Sstevel@tonic-gate ill->ill_name_length); 6657c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length = ill->ill_name_length; 6667c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_index = SCTP_ILL_TO_PHYINDEX(ill); 6677c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_flags = ill->ill_phyint->phyint_flags; 6687c478bd9Sstevel@tonic-gate list_insert_tail(&sctp_g_ills[index].sctp_ill_list, 6697c478bd9Sstevel@tonic-gate (void *)sctp_ill); 6707c478bd9Sstevel@tonic-gate sctp_g_ills[index].ill_count++; 6717c478bd9Sstevel@tonic-gate sctp_ills_count++; 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate break; 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate case SCTP_ILL_REMOVE: 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 6787c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 6797c478bd9Sstevel@tonic-gate return; 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0) { 6827c478bd9Sstevel@tonic-gate list_remove(&sctp_g_ills[index].sctp_ill_list, 6837c478bd9Sstevel@tonic-gate (void *)sctp_ill); 6847c478bd9Sstevel@tonic-gate sctp_g_ills[index].ill_count--; 6857c478bd9Sstevel@tonic-gate sctp_ills_count--; 6867c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 6877c478bd9Sstevel@tonic-gate ill->ill_name_length); 6887c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 6897c478bd9Sstevel@tonic-gate } else { 6907c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state = SCTP_ILLS_CONDEMNED; 6917c478bd9Sstevel@tonic-gate } 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate break; 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 6967c478bd9Sstevel@tonic-gate } 6977c478bd9Sstevel@tonic-gate 6987c478bd9Sstevel@tonic-gate /* move ipif from f_ill to t_ill */ 6997c478bd9Sstevel@tonic-gate void 7007c478bd9Sstevel@tonic-gate sctp_move_ipif(ipif_t *ipif, ill_t *f_ill, ill_t *t_ill) 7017c478bd9Sstevel@tonic-gate { 7027c478bd9Sstevel@tonic-gate sctp_ill_t *fsctp_ill = NULL; 7037c478bd9Sstevel@tonic-gate sctp_ill_t *tsctp_ill = NULL; 7047c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 7057c478bd9Sstevel@tonic-gate uint_t index; 7067c478bd9Sstevel@tonic-gate int i; 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ills_lock, RW_READER); 7097c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ipifs_lock, RW_READER); 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(f_ill)); 7127c478bd9Sstevel@tonic-gate fsctp_ill = list_head(&sctp_g_ills[index].sctp_ill_list); 7137c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ills[index].ill_count; i++) { 7147c478bd9Sstevel@tonic-gate if (fsctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(f_ill)) 7157c478bd9Sstevel@tonic-gate break; 7167c478bd9Sstevel@tonic-gate fsctp_ill = list_next(&sctp_g_ills[index].sctp_ill_list, 7177c478bd9Sstevel@tonic-gate fsctp_ill); 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(t_ill)); 7217c478bd9Sstevel@tonic-gate tsctp_ill = list_head(&sctp_g_ills[index].sctp_ill_list); 7227c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ills[index].ill_count; i++) { 7237c478bd9Sstevel@tonic-gate if (tsctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(t_ill)) 7247c478bd9Sstevel@tonic-gate break; 7257c478bd9Sstevel@tonic-gate tsctp_ill = list_next(&sctp_g_ills[index].sctp_ill_list, 7267c478bd9Sstevel@tonic-gate tsctp_ill); 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate index = SCTP_IPIF_HASH_FN(ipif->ipif_seqid); 7307c478bd9Sstevel@tonic-gate sctp_ipif = list_head(&sctp_g_ipifs[index].sctp_ipif_list); 7317c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ipifs[index].ipif_count; i++) { 7327c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_id == ipif->ipif_seqid) 7337c478bd9Sstevel@tonic-gate break; 7347c478bd9Sstevel@tonic-gate sctp_ipif = list_next(&sctp_g_ipifs[index].sctp_ipif_list, 7357c478bd9Sstevel@tonic-gate sctp_ipif); 7367c478bd9Sstevel@tonic-gate } 7377c478bd9Sstevel@tonic-gate /* Should be an ASSERT? */ 7387c478bd9Sstevel@tonic-gate if (fsctp_ill == NULL || tsctp_ill == NULL || sctp_ipif == NULL) { 7397c478bd9Sstevel@tonic-gate ip1dbg(("sctp_move_ipif: error moving ipif %p from %p to %p\n", 7407c478bd9Sstevel@tonic-gate (void *)ipif, (void *)f_ill, (void *)t_ill)); 7417c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 7427c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 7437c478bd9Sstevel@tonic-gate return; 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 7467c478bd9Sstevel@tonic-gate ASSERT(sctp_ipif->sctp_ipif_ill == fsctp_ill); 7477c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_ill = tsctp_ill; 7487c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 7497c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&fsctp_ill->sctp_ill_ipifcnt, -1); 7507c478bd9Sstevel@tonic-gate atomic_add_32(&tsctp_ill->sctp_ill_ipifcnt, 1); 7517c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 7527c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate /* Insert, Remove, Mark up or Mark down the ipif */ 7567c478bd9Sstevel@tonic-gate void 7577c478bd9Sstevel@tonic-gate sctp_update_ipif(ipif_t *ipif, int op) 7587c478bd9Sstevel@tonic-gate { 7597c478bd9Sstevel@tonic-gate ill_t *ill = ipif->ipif_ill; 7607c478bd9Sstevel@tonic-gate int i; 7617c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill; 7627c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 7637c478bd9Sstevel@tonic-gate uint_t ill_index; 7647c478bd9Sstevel@tonic-gate uint_t ipif_index; 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate ip2dbg(("sctp_update_ipif: %s %d\n", ill->ill_name, ipif->ipif_seqid)); 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ills_lock, RW_READER); 7697c478bd9Sstevel@tonic-gate rw_enter(&sctp_g_ipifs_lock, RW_WRITER); 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate ill_index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(ill)); 7727c478bd9Sstevel@tonic-gate sctp_ill = list_head(&sctp_g_ills[ill_index].sctp_ill_list); 7737c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ills[ill_index].ill_count; i++) { 7747c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(ill)) 7757c478bd9Sstevel@tonic-gate break; 7767c478bd9Sstevel@tonic-gate sctp_ill = list_next(&sctp_g_ills[ill_index].sctp_ill_list, 7777c478bd9Sstevel@tonic-gate sctp_ill); 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 7807c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 7817c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 7827c478bd9Sstevel@tonic-gate return; 7837c478bd9Sstevel@tonic-gate } 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate ipif_index = SCTP_IPIF_HASH_FN(ipif->ipif_seqid); 7867c478bd9Sstevel@tonic-gate sctp_ipif = list_head(&sctp_g_ipifs[ipif_index].sctp_ipif_list); 7877c478bd9Sstevel@tonic-gate for (i = 0; i < sctp_g_ipifs[ipif_index].ipif_count; i++) { 7887c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_id == ipif->ipif_seqid) 7897c478bd9Sstevel@tonic-gate break; 7907c478bd9Sstevel@tonic-gate sctp_ipif = list_next(&sctp_g_ipifs[ipif_index].sctp_ipif_list, 7917c478bd9Sstevel@tonic-gate sctp_ipif); 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate if (op != SCTP_IPIF_INSERT && sctp_ipif == NULL) { 7947c478bd9Sstevel@tonic-gate ip1dbg(("sctp_update_ipif: null sctp_ipif for %d\n", op)); 7957c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 7967c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 7977c478bd9Sstevel@tonic-gate return; 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate #ifdef DEBUG 8007c478bd9Sstevel@tonic-gate if (sctp_ipif != NULL) 8017c478bd9Sstevel@tonic-gate ASSERT(sctp_ill == sctp_ipif->sctp_ipif_ill); 8027c478bd9Sstevel@tonic-gate #endif 8037c478bd9Sstevel@tonic-gate switch (op) { 8047c478bd9Sstevel@tonic-gate case SCTP_IPIF_INSERT: 8057c478bd9Sstevel@tonic-gate if (sctp_ipif != NULL) { 8067c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_state == SCTP_IPIFS_CONDEMNED) 807df19b344Svi sctp_ipif->sctp_ipif_state = SCTP_IPIFS_INVALID; 8087c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 8097c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 8107c478bd9Sstevel@tonic-gate return; 8117c478bd9Sstevel@tonic-gate } 8127c478bd9Sstevel@tonic-gate sctp_ipif = kmem_zalloc(sizeof (sctp_ipif_t), KM_NOSLEEP); 8137c478bd9Sstevel@tonic-gate /* Try again? */ 8147c478bd9Sstevel@tonic-gate if (sctp_ipif == NULL) { 8157c478bd9Sstevel@tonic-gate ip1dbg(("sctp_ipif_insert: mem failure..\n")); 8167c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 8177c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 8187c478bd9Sstevel@tonic-gate return; 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_id = ipif->ipif_seqid; 8217c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_ill = sctp_ill; 822df19b344Svi sctp_ipif->sctp_ipif_state = SCTP_IPIFS_INVALID; 8237c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 8247c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_zoneid = ipif->ipif_zoneid; 8257c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_isv6 = ill->ill_isv6; 826f551bb10Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 8277c478bd9Sstevel@tonic-gate rw_init(&sctp_ipif->sctp_ipif_lock, NULL, RW_DEFAULT, NULL); 8287c478bd9Sstevel@tonic-gate list_insert_tail(&sctp_g_ipifs[ipif_index].sctp_ipif_list, 8297c478bd9Sstevel@tonic-gate (void *)sctp_ipif); 8307c478bd9Sstevel@tonic-gate sctp_g_ipifs[ipif_index].ipif_count++; 8317c478bd9Sstevel@tonic-gate sctp_g_ipifs_count++; 8327c478bd9Sstevel@tonic-gate atomic_add_32(&sctp_ill->sctp_ill_ipifcnt, 1); 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate break; 8357c478bd9Sstevel@tonic-gate 8367c478bd9Sstevel@tonic-gate case SCTP_IPIF_REMOVE: 8377c478bd9Sstevel@tonic-gate { 8387c478bd9Sstevel@tonic-gate list_t *ipif_list; 8397c478bd9Sstevel@tonic-gate list_t *ill_list; 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate ill_list = &sctp_g_ills[ill_index].sctp_ill_list; 8427c478bd9Sstevel@tonic-gate ipif_list = &sctp_g_ipifs[ipif_index].sctp_ipif_list; 8437c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_refcnt != 0) { 8447c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_CONDEMNED; 8457c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 8467c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 8477c478bd9Sstevel@tonic-gate return; 8487c478bd9Sstevel@tonic-gate } 8497c478bd9Sstevel@tonic-gate list_remove(ipif_list, (void *)sctp_ipif); 8507c478bd9Sstevel@tonic-gate sctp_g_ipifs[ipif_index].ipif_count--; 8517c478bd9Sstevel@tonic-gate sctp_g_ipifs_count--; 8527c478bd9Sstevel@tonic-gate rw_destroy(&sctp_ipif->sctp_ipif_lock); 8537c478bd9Sstevel@tonic-gate kmem_free(sctp_ipif, sizeof (sctp_ipif_t)); 8547c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&sctp_ill->sctp_ill_ipifcnt, -1); 8557c478bd9Sstevel@tonic-gate if (rw_tryupgrade(&sctp_g_ills_lock) != 0) { 8567c478bd9Sstevel@tonic-gate rw_downgrade(&sctp_g_ipifs_lock); 8577c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0 && 8587c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) { 8597c478bd9Sstevel@tonic-gate list_remove(ill_list, (void *)sctp_ill); 8607c478bd9Sstevel@tonic-gate sctp_ills_count--; 8617c478bd9Sstevel@tonic-gate sctp_g_ills[ill_index].ill_count--; 8627c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 8637c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length); 8647c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate } 8677c478bd9Sstevel@tonic-gate break; 8687c478bd9Sstevel@tonic-gate } 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate case SCTP_IPIF_UP: 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate rw_downgrade(&sctp_g_ipifs_lock); 8737c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 8747c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_UP; 8757c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_saddr = ipif->ipif_v6lcl_addr; 876f551bb10Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 877f551bb10Svi sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 8787c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate break; 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate case SCTP_IPIF_UPDATE: 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate rw_downgrade(&sctp_g_ipifs_lock); 8857c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 8867c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 8877c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_saddr = ipif->ipif_v6lcl_addr; 8887c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_zoneid = ipif->ipif_zoneid; 889f551bb10Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 8907c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate break; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate case SCTP_IPIF_DOWN: 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate rw_downgrade(&sctp_g_ipifs_lock); 8977c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 8987c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_DOWN; 8997c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 9007c478bd9Sstevel@tonic-gate 9017c478bd9Sstevel@tonic-gate break; 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ipifs_lock); 9047c478bd9Sstevel@tonic-gate rw_exit(&sctp_g_ills_lock); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * 9097c478bd9Sstevel@tonic-gate * 9107c478bd9Sstevel@tonic-gate * SCTP source address list manipulaton, locking not used (except for 9117c478bd9Sstevel@tonic-gate * sctp locking by the caller. 9127c478bd9Sstevel@tonic-gate * 9137c478bd9Sstevel@tonic-gate * 9147c478bd9Sstevel@tonic-gate */ 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* Remove a specific saddr from the list */ 9177c478bd9Sstevel@tonic-gate void 9187c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp_t *sctp, sctp_saddr_ipif_t *sp) 9197c478bd9Sstevel@tonic-gate { 9207c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 9217c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 9247c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp, sp->saddr_ipifp); 9277c478bd9Sstevel@tonic-gate 928f551bb10Svi if (sctp->sctp_bound_to_all == 1) 9297c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 0; 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 9327c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 9357c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate /* 9397c478bd9Sstevel@tonic-gate * Delete source address from the existing list. No error checking done here 9407c478bd9Sstevel@tonic-gate * Called with no locks held. 9417c478bd9Sstevel@tonic-gate */ 9427c478bd9Sstevel@tonic-gate void 9437c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp_t *sctp, const void *addrs, int addcnt, 9447c478bd9Sstevel@tonic-gate boolean_t fanout_locked) 9457c478bd9Sstevel@tonic-gate { 9467c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 9477c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 9487c478bd9Sstevel@tonic-gate int cnt; 9497c478bd9Sstevel@tonic-gate in6_addr_t addr; 9507c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 951*1d8c4025Svi int ifindex = 0; 9527c478bd9Sstevel@tonic-gate 953*1d8c4025Svi ASSERT(sctp->sctp_nsaddrs >= addcnt); 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate if (!fanout_locked) { 9567c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 9577c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 9587c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 9597c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < addcnt; cnt++) { 9637c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 9647c478bd9Sstevel@tonic-gate case AF_INET: 9657c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + cnt; 9667c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(&sin4->sin_addr, &addr); 9677c478bd9Sstevel@tonic-gate break; 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate case AF_INET6: 9707c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + cnt; 9717c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 972*1d8c4025Svi ifindex = sin6->sin6_scope_id; 9737c478bd9Sstevel@tonic-gate break; 9747c478bd9Sstevel@tonic-gate } 9757c478bd9Sstevel@tonic-gate sctp_ipif = sctp_lookup_ipif_addr(&addr, B_FALSE, 976*1d8c4025Svi sctp->sctp_zoneid, ifindex); 9777c478bd9Sstevel@tonic-gate ASSERT(sctp_ipif != NULL); 9787c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp, sctp_ipif); 9797c478bd9Sstevel@tonic-gate } 980f551bb10Svi if (sctp->sctp_bound_to_all == 1) 9817c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 0; 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate if (!fanout_locked) { 9847c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 9857c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 9867c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 9877c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate /* 9927c478bd9Sstevel@tonic-gate * Given an address get the corresponding entry from the list 9937c478bd9Sstevel@tonic-gate * Called with no locks held. 9947c478bd9Sstevel@tonic-gate */ 9957c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t * 996*1d8c4025Svi sctp_saddr_lookup(sctp_t *sctp, in6_addr_t *addr, uint_t ifindex) 9977c478bd9Sstevel@tonic-gate { 9987c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *saddr_ipifs; 9997c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 10007c478bd9Sstevel@tonic-gate 1001*1d8c4025Svi sctp_ipif = sctp_lookup_ipif_addr(addr, B_FALSE, sctp->sctp_zoneid, 1002*1d8c4025Svi ifindex); 10037c478bd9Sstevel@tonic-gate if (sctp_ipif == NULL) 10047c478bd9Sstevel@tonic-gate return (NULL); 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate saddr_ipifs = sctp_ipif_lookup(sctp, sctp_ipif->sctp_ipif_id); 10077c478bd9Sstevel@tonic-gate return (saddr_ipifs); 10087c478bd9Sstevel@tonic-gate } 10097c478bd9Sstevel@tonic-gate 1010f551bb10Svi /* Given an address, add it to the source address list */ 1011f551bb10Svi int 1012*1d8c4025Svi sctp_saddr_add_addr(sctp_t *sctp, in6_addr_t *addr, uint_t ifindex) 1013f551bb10Svi { 1014f551bb10Svi sctp_ipif_t *sctp_ipif; 1015f551bb10Svi 1016*1d8c4025Svi sctp_ipif = sctp_lookup_ipif_addr(addr, B_TRUE, sctp->sctp_zoneid, 1017*1d8c4025Svi ifindex); 1018f551bb10Svi if (sctp_ipif == NULL) 1019f551bb10Svi return (EINVAL); 1020f551bb10Svi 1021f551bb10Svi if (sctp_ipif_hash_insert(sctp, sctp_ipif, KM_NOSLEEP, B_FALSE) != 0) { 1022f551bb10Svi SCTP_IPIF_REFRELE(sctp_ipif); 1023f551bb10Svi return (EINVAL); 1024f551bb10Svi } 1025f551bb10Svi return (0); 1026f551bb10Svi } 1027f551bb10Svi 1028f551bb10Svi /* 1029f551bb10Svi * Remove or mark as dontsrc addresses that are currently not part of the 1030f551bb10Svi * association. One would delete addresses when processing an INIT and 1031f551bb10Svi * mark as dontsrc when processing an INIT-ACK. 1032f551bb10Svi */ 1033f551bb10Svi void 1034f551bb10Svi sctp_check_saddr(sctp_t *sctp, int supp_af, boolean_t delete) 1035f551bb10Svi { 1036f551bb10Svi int i; 1037f551bb10Svi int l; 1038f551bb10Svi sctp_saddr_ipif_t *obj; 1039f551bb10Svi int scanned = 0; 1040f551bb10Svi int naddr; 1041f551bb10Svi int nsaddr; 1042f551bb10Svi 1043f551bb10Svi ASSERT(!sctp->sctp_loopback && !sctp->sctp_linklocal && supp_af != 0); 1044f551bb10Svi 1045f551bb10Svi /* 1046f551bb10Svi * Irregardless of the supported address in the INIT, v4 1047f551bb10Svi * must be supported. 1048f551bb10Svi */ 1049f551bb10Svi if (sctp->sctp_family == AF_INET) 1050f551bb10Svi supp_af = PARM_SUPP_V4; 1051f551bb10Svi 1052f551bb10Svi nsaddr = sctp->sctp_nsaddrs; 1053f551bb10Svi for (i = 0; i < SCTP_IPIF_HASH; i++) { 1054f551bb10Svi if (sctp->sctp_saddrs[i].ipif_count == 0) 1055f551bb10Svi continue; 1056f551bb10Svi obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 1057f551bb10Svi naddr = sctp->sctp_saddrs[i].ipif_count; 1058f551bb10Svi for (l = 0; l < naddr; l++) { 1059f551bb10Svi sctp_ipif_t *ipif; 1060f551bb10Svi 1061f551bb10Svi ipif = obj->saddr_ipifp; 1062f551bb10Svi scanned++; 1063f551bb10Svi 1064f551bb10Svi /* 1065f551bb10Svi * Delete/mark dontsrc loopback/linklocal addresses and 1066f551bb10Svi * unsupported address. 1067*1d8c4025Svi * On a clustered node, we trust the clustering module 1068*1d8c4025Svi * to do the right thing w.r.t loopback addresses, so 1069*1d8c4025Svi * we ignore loopback addresses in this check. 1070f551bb10Svi */ 1071*1d8c4025Svi if ((SCTP_IS_IPIF_LOOPBACK(ipif) && 1072*1d8c4025Svi cl_sctp_check_addrs == NULL) || 1073*1d8c4025Svi SCTP_IS_IPIF_LINKLOCAL(ipif) || 1074f551bb10Svi SCTP_UNSUPP_AF(ipif, supp_af)) { 1075f551bb10Svi if (!delete) { 1076f551bb10Svi obj->saddr_ipif_unconfirmed = 1; 1077f551bb10Svi goto next_obj; 1078f551bb10Svi } 1079f551bb10Svi if (sctp->sctp_bound_to_all == 1) 1080f551bb10Svi sctp->sctp_bound_to_all = 0; 1081f551bb10Svi if (scanned < nsaddr) { 1082f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i]. 1083f551bb10Svi sctp_ipif_list, obj); 1084f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1085f551bb10Svi continue; 1086f551bb10Svi } 1087f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1088f551bb10Svi } 1089f551bb10Svi next_obj: 1090f551bb10Svi if (scanned >= nsaddr) 1091f551bb10Svi return; 1092f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 1093f551bb10Svi obj); 1094f551bb10Svi } 1095f551bb10Svi } 1096f551bb10Svi } 1097f551bb10Svi 1098f551bb10Svi 10997c478bd9Sstevel@tonic-gate /* Get the first valid address from the list. Called with no locks held */ 11007c478bd9Sstevel@tonic-gate in6_addr_t 11017c478bd9Sstevel@tonic-gate sctp_get_valid_addr(sctp_t *sctp, boolean_t isv6) 11027c478bd9Sstevel@tonic-gate { 11037c478bd9Sstevel@tonic-gate int i; 11047c478bd9Sstevel@tonic-gate int l; 11057c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 11067c478bd9Sstevel@tonic-gate int scanned = 0; 11077c478bd9Sstevel@tonic-gate in6_addr_t addr; 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 11107c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 11117c478bd9Sstevel@tonic-gate continue; 11127c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 11137c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 11147c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate ipif = obj->saddr_ipifp; 1117f551bb10Svi if (!SCTP_DONT_SRC(obj) && 11187c478bd9Sstevel@tonic-gate ipif->sctp_ipif_isv6 == isv6 && 1119f551bb10Svi ipif->sctp_ipif_state == SCTP_IPIFS_UP) { 11207c478bd9Sstevel@tonic-gate return (ipif->sctp_ipif_saddr); 11217c478bd9Sstevel@tonic-gate } 11227c478bd9Sstevel@tonic-gate scanned++; 11237c478bd9Sstevel@tonic-gate if (scanned >= sctp->sctp_nsaddrs) 11247c478bd9Sstevel@tonic-gate goto got_none; 11257c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 11267c478bd9Sstevel@tonic-gate obj); 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate } 11297c478bd9Sstevel@tonic-gate got_none: 11307c478bd9Sstevel@tonic-gate /* Need to double check this */ 11317c478bd9Sstevel@tonic-gate if (isv6 == B_TRUE) 11327c478bd9Sstevel@tonic-gate addr = ipv6_all_zeros; 11337c478bd9Sstevel@tonic-gate else 11347c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(0, &addr); 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate return (addr); 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* 11407c478bd9Sstevel@tonic-gate * Return the list of local addresses of an association. The parameter 11417c478bd9Sstevel@tonic-gate * myaddrs is supposed to be either (struct sockaddr_in *) or (struct 11427c478bd9Sstevel@tonic-gate * sockaddr_in6 *) depending on the address family. 11437c478bd9Sstevel@tonic-gate */ 11447c478bd9Sstevel@tonic-gate int 11457c478bd9Sstevel@tonic-gate sctp_getmyaddrs(void *conn, void *myaddrs, int *addrcnt) 11467c478bd9Sstevel@tonic-gate { 11477c478bd9Sstevel@tonic-gate int i; 11487c478bd9Sstevel@tonic-gate int l; 11497c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 11507c478bd9Sstevel@tonic-gate sctp_t *sctp = (sctp_t *)conn; 11517c478bd9Sstevel@tonic-gate int family = sctp->sctp_family; 11527c478bd9Sstevel@tonic-gate int max = *addrcnt; 11537c478bd9Sstevel@tonic-gate size_t added = 0; 11547c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 11557c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 11567c478bd9Sstevel@tonic-gate int scanned = 0; 11577c478bd9Sstevel@tonic-gate boolean_t skip_lback = B_FALSE; 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs == 0) 11607c478bd9Sstevel@tonic-gate return (EINVAL); 11617c478bd9Sstevel@tonic-gate 1162*1d8c4025Svi /* 1163*1d8c4025Svi * Skip loopback addresses for non-loopback assoc., ignore 1164*1d8c4025Svi * this on a clustered node. 1165*1d8c4025Svi */ 1166*1d8c4025Svi if (sctp->sctp_state >= SCTPS_ESTABLISHED && !sctp->sctp_loopback && 1167*1d8c4025Svi (cl_sctp_check_addrs == NULL)) { 11687c478bd9Sstevel@tonic-gate skip_lback = B_TRUE; 1169*1d8c4025Svi } 1170*1d8c4025Svi 11717c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 11727c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 11737c478bd9Sstevel@tonic-gate continue; 11747c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 11757c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 11767c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif = obj->saddr_ipifp; 11777c478bd9Sstevel@tonic-gate in6_addr_t addr = ipif->sctp_ipif_saddr; 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate scanned++; 11807c478bd9Sstevel@tonic-gate if ((ipif->sctp_ipif_state == SCTP_IPIFS_CONDEMNED) || 1181f551bb10Svi SCTP_DONT_SRC(obj) || 1182*1d8c4025Svi (SCTP_IS_IPIF_LOOPBACK(ipif) && skip_lback)) { 11837c478bd9Sstevel@tonic-gate if (scanned >= sctp->sctp_nsaddrs) 11847c478bd9Sstevel@tonic-gate goto done; 11857c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i]. 11867c478bd9Sstevel@tonic-gate sctp_ipif_list, obj); 11877c478bd9Sstevel@tonic-gate continue; 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate switch (family) { 11907c478bd9Sstevel@tonic-gate case AF_INET: 11917c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)myaddrs + added; 11927c478bd9Sstevel@tonic-gate sin4->sin_family = AF_INET; 11937c478bd9Sstevel@tonic-gate sin4->sin_port = sctp->sctp_lport; 11947c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_INADDR(&addr, &sin4->sin_addr); 11957c478bd9Sstevel@tonic-gate break; 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate case AF_INET6: 11987c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)myaddrs + added; 11997c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 12007c478bd9Sstevel@tonic-gate sin6->sin6_port = sctp->sctp_lport; 12017c478bd9Sstevel@tonic-gate sin6->sin6_addr = addr; 12027c478bd9Sstevel@tonic-gate break; 12037c478bd9Sstevel@tonic-gate } 12047c478bd9Sstevel@tonic-gate added++; 12057c478bd9Sstevel@tonic-gate if (added >= max || scanned >= sctp->sctp_nsaddrs) 12067c478bd9Sstevel@tonic-gate goto done; 12077c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 12087c478bd9Sstevel@tonic-gate obj); 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate } 12117c478bd9Sstevel@tonic-gate done: 12127c478bd9Sstevel@tonic-gate *addrcnt = added; 12137c478bd9Sstevel@tonic-gate return (0); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate /* 1217df19b344Svi * Given the supported address family, walk through the source address list 1218df19b344Svi * and return the total length of the available addresses. If 'p' is not 1219df19b344Svi * null, construct the parameter list for the addresses in 'p'. 1220f551bb10Svi * 'modify' will only be set when we want the source address list to 1221f551bb10Svi * be modified. The source address list will be modified only when 1222f551bb10Svi * generating an INIT chunk. For generating an INIT-ACK 'modify' will 1223f551bb10Svi * be false since the 'sctp' will be that of the listener. 12247c478bd9Sstevel@tonic-gate */ 12257c478bd9Sstevel@tonic-gate size_t 1226f551bb10Svi sctp_saddr_info(sctp_t *sctp, int supp_af, uchar_t *p, boolean_t modify) 12277c478bd9Sstevel@tonic-gate { 12287c478bd9Sstevel@tonic-gate int i; 12297c478bd9Sstevel@tonic-gate int l; 12307c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 1231df19b344Svi size_t paramlen = 0; 12327c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *hdr; 12337c478bd9Sstevel@tonic-gate int scanned = 0; 1234f551bb10Svi int naddr; 1235f551bb10Svi int nsaddr; 1236*1d8c4025Svi boolean_t del_ll = B_FALSE; 1237*1d8c4025Svi boolean_t del_lb = B_FALSE; 1238*1d8c4025Svi 1239*1d8c4025Svi 1240*1d8c4025Svi /* 1241*1d8c4025Svi * On a clustered node don't bother changing anything 1242*1d8c4025Svi * on the loopback interface. 1243*1d8c4025Svi */ 1244*1d8c4025Svi if (modify && !sctp->sctp_loopback && (cl_sctp_check_addrs == NULL)) 1245*1d8c4025Svi del_lb = B_TRUE; 1246f551bb10Svi 1247*1d8c4025Svi if (modify && !sctp->sctp_linklocal) 1248*1d8c4025Svi del_ll = B_TRUE; 12497c478bd9Sstevel@tonic-gate 1250f551bb10Svi nsaddr = sctp->sctp_nsaddrs; 12517c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 12527c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 12537c478bd9Sstevel@tonic-gate continue; 12547c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 1255f551bb10Svi naddr = sctp->sctp_saddrs[i].ipif_count; 1256f551bb10Svi for (l = 0; l < naddr; l++) { 12577c478bd9Sstevel@tonic-gate in6_addr_t addr; 12587c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 1259*1d8c4025Svi boolean_t ipif_lb; 1260*1d8c4025Svi boolean_t ipif_ll; 1261f551bb10Svi boolean_t unsupp_af; 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate ipif = obj->saddr_ipifp; 12647c478bd9Sstevel@tonic-gate scanned++; 1265f551bb10Svi 1266*1d8c4025Svi ipif_lb = SCTP_IS_IPIF_LOOPBACK(ipif); 1267*1d8c4025Svi ipif_ll = SCTP_IS_IPIF_LINKLOCAL(ipif); 1268f551bb10Svi unsupp_af = SCTP_UNSUPP_AF(ipif, supp_af); 1269f551bb10Svi /* 1270f551bb10Svi * We need to either delete or skip loopback/linklocal 1271*1d8c4025Svi * or unsupported addresses, if required. 1272f551bb10Svi */ 1273*1d8c4025Svi if ((ipif_ll && del_ll) || (ipif_lb && del_lb) || 1274*1d8c4025Svi (unsupp_af && modify)) { 1275f551bb10Svi if (sctp->sctp_bound_to_all == 1) 1276f551bb10Svi sctp->sctp_bound_to_all = 0; 1277f551bb10Svi if (scanned < nsaddr) { 1278f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i]. 1279f551bb10Svi sctp_ipif_list, obj); 1280f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1281f551bb10Svi continue; 1282f551bb10Svi } 1283f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1284f551bb10Svi goto next_addr; 1285*1d8c4025Svi } else if (ipif_ll || unsupp_af || 1286*1d8c4025Svi (ipif_lb && (cl_sctp_check_addrs == NULL))) { 1287df19b344Svi goto next_addr; 12887c478bd9Sstevel@tonic-gate } 1289f551bb10Svi 1290f551bb10Svi if (!SCTP_IPIF_USABLE(ipif->sctp_ipif_state)) 1291f551bb10Svi goto next_addr; 1292df19b344Svi if (p != NULL) 1293df19b344Svi hdr = (sctp_parm_hdr_t *)(p + paramlen); 12947c478bd9Sstevel@tonic-gate addr = ipif->sctp_ipif_saddr; 1295f551bb10Svi if (!ipif->sctp_ipif_isv6) { 12967c478bd9Sstevel@tonic-gate struct in_addr *v4; 12977c478bd9Sstevel@tonic-gate 1298df19b344Svi if (p != NULL) { 1299df19b344Svi hdr->sph_type = htons(PARM_ADDR4); 1300df19b344Svi hdr->sph_len = htons(PARM_ADDR4_LEN); 1301df19b344Svi v4 = (struct in_addr *)(hdr + 1); 1302df19b344Svi IN6_V4MAPPED_TO_INADDR(&addr, v4); 1303df19b344Svi } 1304df19b344Svi paramlen += PARM_ADDR4_LEN; 1305f551bb10Svi } else { 1306df19b344Svi if (p != NULL) { 1307df19b344Svi hdr->sph_type = htons(PARM_ADDR6); 1308df19b344Svi hdr->sph_len = htons(PARM_ADDR6_LEN); 1309df19b344Svi bcopy(&addr, hdr + 1, sizeof (addr)); 1310df19b344Svi } 1311df19b344Svi paramlen += PARM_ADDR6_LEN; 13127c478bd9Sstevel@tonic-gate } 1313df19b344Svi next_addr: 1314f551bb10Svi if (scanned >= nsaddr) 1315df19b344Svi return (paramlen); 13167c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 13177c478bd9Sstevel@tonic-gate obj); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate } 1320df19b344Svi return (paramlen); 13217c478bd9Sstevel@tonic-gate } 13227c478bd9Sstevel@tonic-gate 1323*1d8c4025Svi /* 1324*1d8c4025Svi * This is used on a clustered node to obtain a list of addresses, the list 1325*1d8c4025Svi * consists of sockaddr_in structs for v4 and sockaddr_in6 for v6. The list 1326*1d8c4025Svi * is then passed onto the clustering module which sends back the correct 1327*1d8c4025Svi * list based on the port info. Regardless of the input, i.e INADDR_ANY 1328*1d8c4025Svi * or specific address(es), we create the list since it could be modified by 1329*1d8c4025Svi * the clustering module. When given a list of addresses, we simply 1330*1d8c4025Svi * create the list of sockaddr_in or sockaddr_in6 structs using those 1331*1d8c4025Svi * addresses. If there is an INADDR_ANY in the input list, or if the 1332*1d8c4025Svi * input is INADDR_ANY, we create a list of sockaddr_in or sockaddr_in6 1333*1d8c4025Svi * structs consisting all the addresses in the global interface list 1334*1d8c4025Svi * except those that are hosted on the loopback interface. We create 1335*1d8c4025Svi * a list of sockaddr_in[6] structs just so that it can be directly input 1336*1d8c4025Svi * to sctp_valid_addr_list() once the clustering module has processed it. 1337*1d8c4025Svi */ 1338*1d8c4025Svi int 1339*1d8c4025Svi sctp_get_addrlist(sctp_t *sctp, const void *addrs, uint32_t *addrcnt, 1340*1d8c4025Svi uchar_t **addrlist, int *uspec, size_t *size) 1341*1d8c4025Svi { 1342*1d8c4025Svi int cnt; 1343*1d8c4025Svi int icnt; 1344*1d8c4025Svi sctp_ipif_t *sctp_ipif; 1345*1d8c4025Svi struct sockaddr_in *s4; 1346*1d8c4025Svi struct sockaddr_in6 *s6; 1347*1d8c4025Svi uchar_t *p; 1348*1d8c4025Svi int err = 0; 1349*1d8c4025Svi 1350*1d8c4025Svi *addrlist = NULL; 1351*1d8c4025Svi *size = 0; 1352*1d8c4025Svi 1353*1d8c4025Svi /* 1354*1d8c4025Svi * Create a list of sockaddr_in[6] structs using the input list. 1355*1d8c4025Svi */ 1356*1d8c4025Svi if (sctp->sctp_family == AF_INET) { 1357*1d8c4025Svi *size = sizeof (struct sockaddr_in) * *addrcnt; 1358*1d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 1359*1d8c4025Svi p = *addrlist; 1360*1d8c4025Svi for (cnt = 0; cnt < *addrcnt; cnt++) { 1361*1d8c4025Svi s4 = (struct sockaddr_in *)addrs + cnt; 1362*1d8c4025Svi /* 1363*1d8c4025Svi * We need to create a list of all the available 1364*1d8c4025Svi * addresses if there is an INADDR_ANY. However, 1365*1d8c4025Svi * if we are beyond LISTEN, then this is invalid 1366*1d8c4025Svi * (see sctp_valid_addr_list(). So, we just fail 1367*1d8c4025Svi * it here rather than wait till it fails in 1368*1d8c4025Svi * sctp_valid_addr_list(). 1369*1d8c4025Svi */ 1370*1d8c4025Svi if (s4->sin_addr.s_addr == INADDR_ANY) { 1371*1d8c4025Svi kmem_free(*addrlist, *size); 1372*1d8c4025Svi *addrlist = NULL; 1373*1d8c4025Svi *size = 0; 1374*1d8c4025Svi if (sctp->sctp_state > SCTPS_LISTEN) { 1375*1d8c4025Svi *addrcnt = 0; 1376*1d8c4025Svi return (EINVAL); 1377*1d8c4025Svi } 1378*1d8c4025Svi if (uspec != NULL) 1379*1d8c4025Svi *uspec = 1; 1380*1d8c4025Svi goto get_all_addrs; 1381*1d8c4025Svi } else { 1382*1d8c4025Svi bcopy(s4, p, sizeof (*s4)); 1383*1d8c4025Svi p += sizeof (*s4); 1384*1d8c4025Svi } 1385*1d8c4025Svi } 1386*1d8c4025Svi } else { 1387*1d8c4025Svi *size = sizeof (struct sockaddr_in6) * *addrcnt; 1388*1d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 1389*1d8c4025Svi p = *addrlist; 1390*1d8c4025Svi for (cnt = 0; cnt < *addrcnt; cnt++) { 1391*1d8c4025Svi s6 = (struct sockaddr_in6 *)addrs + cnt; 1392*1d8c4025Svi /* 1393*1d8c4025Svi * Comments for INADDR_ANY, above, apply here too. 1394*1d8c4025Svi */ 1395*1d8c4025Svi if (IN6_IS_ADDR_UNSPECIFIED(&s6->sin6_addr)) { 1396*1d8c4025Svi kmem_free(*addrlist, *size); 1397*1d8c4025Svi *size = 0; 1398*1d8c4025Svi *addrlist = NULL; 1399*1d8c4025Svi if (sctp->sctp_state > SCTPS_LISTEN) { 1400*1d8c4025Svi *addrcnt = 0; 1401*1d8c4025Svi return (EINVAL); 1402*1d8c4025Svi } 1403*1d8c4025Svi if (uspec != NULL) 1404*1d8c4025Svi *uspec = 1; 1405*1d8c4025Svi goto get_all_addrs; 1406*1d8c4025Svi } else { 1407*1d8c4025Svi bcopy(addrs, p, sizeof (*s6)); 1408*1d8c4025Svi p += sizeof (*s6); 1409*1d8c4025Svi } 1410*1d8c4025Svi } 1411*1d8c4025Svi } 1412*1d8c4025Svi return (err); 1413*1d8c4025Svi get_all_addrs: 1414*1d8c4025Svi 1415*1d8c4025Svi /* 1416*1d8c4025Svi * Allocate max possible size. We allocate the max. size here because 1417*1d8c4025Svi * the clustering module could end up adding addresses to the list. 1418*1d8c4025Svi * We allocate upfront so that the clustering module need to bother 1419*1d8c4025Svi * re-sizing the list. 1420*1d8c4025Svi */ 1421*1d8c4025Svi if (sctp->sctp_family == AF_INET) 1422*1d8c4025Svi *size = sizeof (struct sockaddr_in) * sctp_g_ipifs_count; 1423*1d8c4025Svi else 1424*1d8c4025Svi *size = sizeof (struct sockaddr_in6) * sctp_g_ipifs_count; 1425*1d8c4025Svi 1426*1d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 1427*1d8c4025Svi *addrcnt = 0; 1428*1d8c4025Svi p = *addrlist; 1429*1d8c4025Svi rw_enter(&sctp_g_ipifs_lock, RW_READER); 1430*1d8c4025Svi 1431*1d8c4025Svi /* 1432*1d8c4025Svi * Walk through the global interface list and add all addresses, 1433*1d8c4025Svi * except those that are hosted on loopback interfaces. 1434*1d8c4025Svi */ 1435*1d8c4025Svi for (cnt = 0; cnt < SCTP_IPIF_HASH; cnt++) { 1436*1d8c4025Svi if (sctp_g_ipifs[cnt].ipif_count == 0) 1437*1d8c4025Svi continue; 1438*1d8c4025Svi sctp_ipif = list_head(&sctp_g_ipifs[cnt].sctp_ipif_list); 1439*1d8c4025Svi for (icnt = 0; icnt < sctp_g_ipifs[cnt].ipif_count; icnt++) { 1440*1d8c4025Svi in6_addr_t addr; 1441*1d8c4025Svi 1442*1d8c4025Svi rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 1443*1d8c4025Svi addr = sctp_ipif->sctp_ipif_saddr; 1444*1d8c4025Svi if (SCTP_IPIF_DISCARD(sctp_ipif->sctp_ipif_flags) || 1445*1d8c4025Svi !SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state) || 1446*1d8c4025Svi SCTP_IS_IPIF_LOOPBACK(sctp_ipif) || 1447*1d8c4025Svi SCTP_IS_IPIF_LINKLOCAL(sctp_ipif) || 1448*1d8c4025Svi sctp_ipif->sctp_ipif_zoneid != sctp->sctp_zoneid || 1449*1d8c4025Svi (sctp->sctp_ipversion == IPV4_VERSION && 1450*1d8c4025Svi sctp_ipif->sctp_ipif_isv6) || 1451*1d8c4025Svi (sctp->sctp_connp->conn_ipv6_v6only && 1452*1d8c4025Svi !sctp_ipif->sctp_ipif_isv6)) { 1453*1d8c4025Svi rw_exit(&sctp_ipif->sctp_ipif_lock); 1454*1d8c4025Svi sctp_ipif = list_next( 1455*1d8c4025Svi &sctp_g_ipifs[cnt].sctp_ipif_list, 1456*1d8c4025Svi sctp_ipif); 1457*1d8c4025Svi continue; 1458*1d8c4025Svi } 1459*1d8c4025Svi rw_exit(&sctp_ipif->sctp_ipif_lock); 1460*1d8c4025Svi if (sctp->sctp_family == AF_INET) { 1461*1d8c4025Svi s4 = (struct sockaddr_in *)p; 1462*1d8c4025Svi IN6_V4MAPPED_TO_INADDR(&addr, &s4->sin_addr); 1463*1d8c4025Svi s4->sin_family = AF_INET; 1464*1d8c4025Svi p += sizeof (*s4); 1465*1d8c4025Svi } else { 1466*1d8c4025Svi s6 = (struct sockaddr_in6 *)p; 1467*1d8c4025Svi s6->sin6_addr = addr; 1468*1d8c4025Svi s6->sin6_family = AF_INET6; 1469*1d8c4025Svi s6->sin6_scope_id = 1470*1d8c4025Svi sctp_ipif->sctp_ipif_ill->sctp_ill_index; 1471*1d8c4025Svi p += sizeof (*s6); 1472*1d8c4025Svi } 1473*1d8c4025Svi (*addrcnt)++; 1474*1d8c4025Svi sctp_ipif = list_next(&sctp_g_ipifs[cnt].sctp_ipif_list, 1475*1d8c4025Svi sctp_ipif); 1476*1d8c4025Svi } 1477*1d8c4025Svi } 1478*1d8c4025Svi rw_exit(&sctp_g_ipifs_lock); 1479*1d8c4025Svi return (err); 1480*1d8c4025Svi } 1481*1d8c4025Svi 1482*1d8c4025Svi /* 1483*1d8c4025Svi * Get a list of addresses from the source address list. The caller is 1484*1d8c4025Svi * responsible for allocating sufficient buffer for this. 1485*1d8c4025Svi */ 1486*1d8c4025Svi void 1487*1d8c4025Svi sctp_get_saddr_list(sctp_t *sctp, uchar_t *p, size_t psize) 1488*1d8c4025Svi { 1489*1d8c4025Svi int cnt; 1490*1d8c4025Svi int icnt; 1491*1d8c4025Svi sctp_saddr_ipif_t *obj; 1492*1d8c4025Svi int naddr; 1493*1d8c4025Svi int scanned = 0; 1494*1d8c4025Svi 1495*1d8c4025Svi for (cnt = 0; cnt < SCTP_IPIF_HASH; cnt++) { 1496*1d8c4025Svi if (sctp->sctp_saddrs[cnt].ipif_count == 0) 1497*1d8c4025Svi continue; 1498*1d8c4025Svi obj = list_head(&sctp->sctp_saddrs[cnt].sctp_ipif_list); 1499*1d8c4025Svi naddr = sctp->sctp_saddrs[cnt].ipif_count; 1500*1d8c4025Svi for (icnt = 0; icnt < naddr; icnt++) { 1501*1d8c4025Svi sctp_ipif_t *ipif; 1502*1d8c4025Svi 1503*1d8c4025Svi if (psize < sizeof (ipif->sctp_ipif_saddr)) 1504*1d8c4025Svi return; 1505*1d8c4025Svi 1506*1d8c4025Svi scanned++; 1507*1d8c4025Svi ipif = obj->saddr_ipifp; 1508*1d8c4025Svi bcopy(&ipif->sctp_ipif_saddr, p, 1509*1d8c4025Svi sizeof (ipif->sctp_ipif_saddr)); 1510*1d8c4025Svi p += sizeof (ipif->sctp_ipif_saddr); 1511*1d8c4025Svi psize -= sizeof (ipif->sctp_ipif_saddr); 1512*1d8c4025Svi if (scanned >= sctp->sctp_nsaddrs) 1513*1d8c4025Svi return; 1514*1d8c4025Svi obj = list_next(&sctp->sctp_saddrs[icnt].sctp_ipif_list, 1515*1d8c4025Svi obj); 1516*1d8c4025Svi } 1517*1d8c4025Svi } 1518*1d8c4025Svi } 1519*1d8c4025Svi 1520*1d8c4025Svi /* 1521*1d8c4025Svi * Get a list of addresses from the remote address list. The caller is 1522*1d8c4025Svi * responsible for allocating sufficient buffer for this. 1523*1d8c4025Svi */ 1524*1d8c4025Svi void 1525*1d8c4025Svi sctp_get_faddr_list(sctp_t *sctp, uchar_t *p, size_t psize) 1526*1d8c4025Svi { 1527*1d8c4025Svi sctp_faddr_t *fp; 1528*1d8c4025Svi 1529*1d8c4025Svi for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->next) { 1530*1d8c4025Svi if (psize < sizeof (fp->faddr)) 1531*1d8c4025Svi return; 1532*1d8c4025Svi bcopy(&fp->faddr, p, sizeof (fp->faddr)); 1533*1d8c4025Svi p += sizeof (fp->faddr); 1534*1d8c4025Svi psize -= sizeof (fp->faddr); 1535*1d8c4025Svi } 1536*1d8c4025Svi } 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate /* Initialize the SCTP ILL list and lock */ 15397c478bd9Sstevel@tonic-gate void 15407c478bd9Sstevel@tonic-gate sctp_saddr_init() 15417c478bd9Sstevel@tonic-gate { 15427c478bd9Sstevel@tonic-gate int i; 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate rw_init(&sctp_g_ills_lock, NULL, RW_DEFAULT, NULL); 15457c478bd9Sstevel@tonic-gate rw_init(&sctp_g_ipifs_lock, NULL, RW_DEFAULT, NULL); 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_ILL_HASH; i++) { 15487c478bd9Sstevel@tonic-gate sctp_g_ills[i].ill_count = 0; 15497c478bd9Sstevel@tonic-gate list_create(&sctp_g_ills[i].sctp_ill_list, sizeof (sctp_ill_t), 15507c478bd9Sstevel@tonic-gate offsetof(sctp_ill_t, sctp_ills)); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 15537c478bd9Sstevel@tonic-gate sctp_g_ipifs[i].ipif_count = 0; 15547c478bd9Sstevel@tonic-gate list_create(&sctp_g_ipifs[i].sctp_ipif_list, 15557c478bd9Sstevel@tonic-gate sizeof (sctp_ipif_t), offsetof(sctp_ipif_t, sctp_ipifs)); 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate } 15587c478bd9Sstevel@tonic-gate 15597c478bd9Sstevel@tonic-gate void 15607c478bd9Sstevel@tonic-gate sctp_saddr_fini() 15617c478bd9Sstevel@tonic-gate { 15627c478bd9Sstevel@tonic-gate int i; 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate rw_destroy(&sctp_g_ills_lock); 15657c478bd9Sstevel@tonic-gate rw_destroy(&sctp_g_ipifs_lock); 15667c478bd9Sstevel@tonic-gate ASSERT(sctp_ills_count == 0 && sctp_g_ipifs_count == 0); 15677c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_ILL_HASH; i++) 15687c478bd9Sstevel@tonic-gate list_destroy(&sctp_g_ills[i].sctp_ill_list); 15697c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) 15707c478bd9Sstevel@tonic-gate list_destroy(&sctp_g_ipifs[i].sctp_ipif_list); 15717c478bd9Sstevel@tonic-gate } 1572