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 */ 217c478bd9Sstevel@tonic-gate /* 22f4b3ec61Sdh * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #include <sys/types.h> 297c478bd9Sstevel@tonic-gate #include <sys/systm.h> 307c478bd9Sstevel@tonic-gate #include <sys/stream.h> 317c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 327c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 337c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 347c478bd9Sstevel@tonic-gate #include <sys/socket.h> 357c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 367c478bd9Sstevel@tonic-gate #include <sys/list.h> 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #include <netinet/in.h> 397c478bd9Sstevel@tonic-gate #include <netinet/ip6.h> 407c478bd9Sstevel@tonic-gate #include <netinet/sctp.h> 417c478bd9Sstevel@tonic-gate 427c478bd9Sstevel@tonic-gate #include <inet/common.h> 437c478bd9Sstevel@tonic-gate #include <inet/ip.h> 447c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 457c478bd9Sstevel@tonic-gate #include <inet/ip_if.h> 467c478bd9Sstevel@tonic-gate #include <inet/ipclassifier.h> 477c478bd9Sstevel@tonic-gate #include <inet/sctp_ip.h> 487c478bd9Sstevel@tonic-gate #include "sctp_impl.h" 497c478bd9Sstevel@tonic-gate #include "sctp_addr.h" 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate static void sctp_ipif_inactive(sctp_ipif_t *); 527c478bd9Sstevel@tonic-gate static sctp_ipif_t *sctp_lookup_ipif_addr(in6_addr_t *, boolean_t, 53*e35d2278Svi zoneid_t, boolean_t, uint_t, uint_t, boolean_t, 54*e35d2278Svi sctp_stack_t *); 557c478bd9Sstevel@tonic-gate static int sctp_get_all_ipifs(sctp_t *, int); 561d8c4025Svi int sctp_valid_addr_list(sctp_t *, const void *, uint32_t, 571d8c4025Svi uchar_t *, size_t); 58f551bb10Svi static int sctp_ipif_hash_insert(sctp_t *, sctp_ipif_t *, int, 59*e35d2278Svi boolean_t, boolean_t); 607c478bd9Sstevel@tonic-gate static void sctp_ipif_hash_remove(sctp_t *, sctp_ipif_t *); 617c478bd9Sstevel@tonic-gate static int sctp_compare_ipif_list(sctp_ipif_hash_t *, 627c478bd9Sstevel@tonic-gate sctp_ipif_hash_t *); 637c478bd9Sstevel@tonic-gate int sctp_compare_saddrs(sctp_t *, sctp_t *); 647c478bd9Sstevel@tonic-gate static int sctp_copy_ipifs(sctp_ipif_hash_t *, sctp_t *, int); 657c478bd9Sstevel@tonic-gate int sctp_dup_saddrs(sctp_t *, sctp_t *, int); 667c478bd9Sstevel@tonic-gate void sctp_free_saddrs(sctp_t *); 677c478bd9Sstevel@tonic-gate void sctp_update_ill(ill_t *, int); 687c478bd9Sstevel@tonic-gate void sctp_update_ipif(ipif_t *, int); 697c478bd9Sstevel@tonic-gate void sctp_move_ipif(ipif_t *, ill_t *, ill_t *); 707c478bd9Sstevel@tonic-gate void sctp_del_saddr(sctp_t *, sctp_saddr_ipif_t *); 717c478bd9Sstevel@tonic-gate void sctp_del_saddr_list(sctp_t *, const void *, int, 727c478bd9Sstevel@tonic-gate boolean_t); 731d8c4025Svi sctp_saddr_ipif_t *sctp_saddr_lookup(sctp_t *, in6_addr_t *, uint_t); 747c478bd9Sstevel@tonic-gate in6_addr_t sctp_get_valid_addr(sctp_t *, boolean_t); 757c478bd9Sstevel@tonic-gate int sctp_getmyaddrs(void *, void *, int *); 76f4b3ec61Sdh void sctp_saddr_init(sctp_stack_t *); 77f4b3ec61Sdh void sctp_saddr_fini(sctp_stack_t *); 78f551bb10Svi 79*e35d2278Svi #define SCTP_ADDR4_HASH(addr) \ 80*e35d2278Svi (((addr) ^ ((addr) >> 8) ^ ((addr) >> 16) ^ ((addr) >> 24)) & \ 81*e35d2278Svi (SCTP_IPIF_HASH - 1)) 82*e35d2278Svi 83*e35d2278Svi #define SCTP_ADDR6_HASH(addr) \ 84*e35d2278Svi (((addr).s6_addr32[3] ^ \ 85*e35d2278Svi (((addr).s6_addr32[3] ^ (addr).s6_addr32[2]) >> 12)) & \ 86*e35d2278Svi (SCTP_IPIF_HASH - 1)) 87*e35d2278Svi 88*e35d2278Svi #define SCTP_IPIF_ADDR_HASH(addr, isv6) \ 89*e35d2278Svi ((isv6) ? SCTP_ADDR6_HASH((addr)) : \ 90*e35d2278Svi SCTP_ADDR4_HASH((addr)._S6_un._S6_u32[3])) 91*e35d2278Svi 927c478bd9Sstevel@tonic-gate #define SCTP_IPIF_USABLE(sctp_ipif_state) \ 937c478bd9Sstevel@tonic-gate ((sctp_ipif_state) == SCTP_IPIFS_UP || \ 94f551bb10Svi (sctp_ipif_state) == SCTP_IPIFS_DOWN) 95f551bb10Svi 96f551bb10Svi #define SCTP_IPIF_DISCARD(sctp_ipif_flags) \ 97f551bb10Svi ((sctp_ipif_flags) & (IPIF_PRIVATE | IPIF_DEPRECATED)) 98f551bb10Svi 991d8c4025Svi #define SCTP_IS_IPIF_LOOPBACK(ipif) \ 1001d8c4025Svi ((ipif)->sctp_ipif_ill->sctp_ill_flags & PHYI_LOOPBACK) 1011d8c4025Svi 1021d8c4025Svi #define SCTP_IS_IPIF_LINKLOCAL(ipif) \ 1031d8c4025Svi ((ipif)->sctp_ipif_isv6 && \ 1041d8c4025Svi IN6_IS_ADDR_LINKLOCAL(&(ipif)->sctp_ipif_saddr)) 105f551bb10Svi 106f551bb10Svi #define SCTP_UNSUPP_AF(ipif, supp_af) \ 107f551bb10Svi ((!(ipif)->sctp_ipif_isv6 && !((supp_af) & PARM_SUPP_V4)) || \ 108f551bb10Svi ((ipif)->sctp_ipif_isv6 && !((supp_af) & PARM_SUPP_V6))) 1097c478bd9Sstevel@tonic-gate 1105d0bc3edSsommerfe #define SCTP_IPIF_ZONE_MATCH(sctp, ipif) \ 1115d0bc3edSsommerfe IPCL_ZONE_MATCH((sctp)->sctp_connp, (ipif)->sctp_ipif_zoneid) 1125d0bc3edSsommerfe 1137c478bd9Sstevel@tonic-gate #define SCTP_ILL_HASH_FN(index) ((index) % SCTP_ILL_HASH) 1147c478bd9Sstevel@tonic-gate #define SCTP_ILL_TO_PHYINDEX(ill) ((ill)->ill_phyint->phyint_ifindex) 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate /* 1177c478bd9Sstevel@tonic-gate * SCTP Interface list manipulation functions, locking used. 1187c478bd9Sstevel@tonic-gate */ 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * Delete an SCTP IPIF from the list if the refcount goes to 0 and it is 1227c478bd9Sstevel@tonic-gate * marked as condemned. Also, check if the ILL needs to go away. 1237c478bd9Sstevel@tonic-gate */ 1247c478bd9Sstevel@tonic-gate static void 1257c478bd9Sstevel@tonic-gate sctp_ipif_inactive(sctp_ipif_t *sctp_ipif) 1267c478bd9Sstevel@tonic-gate { 1277c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill; 128*e35d2278Svi uint_t hindex; 1297c478bd9Sstevel@tonic-gate uint_t ill_index; 130f4b3ec61Sdh sctp_stack_t *sctps = sctp_ipif->sctp_ipif_ill-> 131f4b3ec61Sdh sctp_ill_netstack->netstack_sctp; 1327c478bd9Sstevel@tonic-gate 133f4b3ec61Sdh rw_enter(&sctps->sctps_g_ills_lock, RW_READER); 134f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_WRITER); 1357c478bd9Sstevel@tonic-gate 136*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(sctp_ipif->sctp_ipif_saddr, 137*e35d2278Svi sctp_ipif->sctp_ipif_isv6); 138*e35d2278Svi 1397c478bd9Sstevel@tonic-gate sctp_ill = sctp_ipif->sctp_ipif_ill; 1407c478bd9Sstevel@tonic-gate ASSERT(sctp_ill != NULL); 1417c478bd9Sstevel@tonic-gate ill_index = SCTP_ILL_HASH_FN(sctp_ill->sctp_ill_index); 1427c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_state != SCTP_IPIFS_CONDEMNED || 1437c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_refcnt != 0) { 144f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 145f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 1467c478bd9Sstevel@tonic-gate return; 1477c478bd9Sstevel@tonic-gate } 148*e35d2278Svi list_remove(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list, 149f4b3ec61Sdh sctp_ipif); 150*e35d2278Svi sctps->sctps_g_ipifs[hindex].ipif_count--; 151f4b3ec61Sdh sctps->sctps_g_ipifs_count--; 1527c478bd9Sstevel@tonic-gate rw_destroy(&sctp_ipif->sctp_ipif_lock); 1537c478bd9Sstevel@tonic-gate kmem_free(sctp_ipif, sizeof (sctp_ipif_t)); 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&sctp_ill->sctp_ill_ipifcnt, -1); 156f4b3ec61Sdh if (rw_tryupgrade(&sctps->sctps_g_ills_lock) != 0) { 157f4b3ec61Sdh rw_downgrade(&sctps->sctps_g_ipifs_lock); 1587c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0 && 1597c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) { 160f4b3ec61Sdh list_remove(&sctps->sctps_g_ills[ill_index]. 161f4b3ec61Sdh sctp_ill_list, (void *)sctp_ill); 162f4b3ec61Sdh sctps->sctps_g_ills[ill_index].ill_count--; 163f4b3ec61Sdh sctps->sctps_ills_count--; 1647c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 1657c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length); 1667c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 1677c478bd9Sstevel@tonic-gate } 1687c478bd9Sstevel@tonic-gate } 169f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 170f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate /* 1747c478bd9Sstevel@tonic-gate * Lookup an SCTP IPIF given an IP address. Increments sctp_ipif refcnt. 175*e35d2278Svi * We are either looking for a IPIF with the given address before 176*e35d2278Svi * inserting it into the global list or looking for an IPIF for an 177*e35d2278Svi * address given an SCTP. In the former case we always check the zoneid, 178*e35d2278Svi * but for the latter case, check_zid could be B_FALSE if the connp 179*e35d2278Svi * for the sctp has conn_all_zones set. When looking for an address we 180*e35d2278Svi * give preference to one that is up, so even though we may find one that 181*e35d2278Svi * is not up we keep looking if there is one up, we hold the down addr 182*e35d2278Svi * in backup_ipif in case we don't find one that is up - i.e. we return 183*e35d2278Svi * the backup_ipif in that case. Note that if we are looking for. If we 184*e35d2278Svi * are specifically looking for an up address, then usable will be set 185*e35d2278Svi * to true. 1867c478bd9Sstevel@tonic-gate */ 1877c478bd9Sstevel@tonic-gate static sctp_ipif_t * 188*e35d2278Svi sctp_lookup_ipif_addr(in6_addr_t *addr, boolean_t refhold, zoneid_t zoneid, 189*e35d2278Svi boolean_t check_zid, uint_t ifindex, uint_t seqid, boolean_t usable, 190*e35d2278Svi sctp_stack_t *sctps) 1917c478bd9Sstevel@tonic-gate { 1927c478bd9Sstevel@tonic-gate int j; 1937c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 194*e35d2278Svi sctp_ipif_t *backup_ipif = NULL; 195*e35d2278Svi int hindex; 196*e35d2278Svi 197*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(*addr, !IN6_IS_ADDR_V4MAPPED(addr)); 1987c478bd9Sstevel@tonic-gate 199f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_READER); 200*e35d2278Svi if (sctps->sctps_g_ipifs[hindex].ipif_count == 0) { 201*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 202*e35d2278Svi return (NULL); 203*e35d2278Svi } 204*e35d2278Svi sctp_ipif = list_head(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list); 205*e35d2278Svi for (j = 0; j < sctps->sctps_g_ipifs[hindex].ipif_count; j++) { 206*e35d2278Svi rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 207*e35d2278Svi if ((!check_zid || 208*e35d2278Svi (sctp_ipif->sctp_ipif_zoneid == ALL_ZONES || 209*e35d2278Svi zoneid == sctp_ipif->sctp_ipif_zoneid)) && 210*e35d2278Svi (ifindex == 0 || ifindex == 211*e35d2278Svi sctp_ipif->sctp_ipif_ill->sctp_ill_index) && 212*e35d2278Svi ((seqid != 0 && seqid == sctp_ipif->sctp_ipif_id) || 213*e35d2278Svi (IN6_ARE_ADDR_EQUAL(&sctp_ipif->sctp_ipif_saddr, 214*e35d2278Svi addr)))) { 215*e35d2278Svi if (!usable || sctp_ipif->sctp_ipif_state == 216*e35d2278Svi SCTP_IPIFS_UP) { 2177c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 2187c478bd9Sstevel@tonic-gate if (refhold) 2197c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(sctp_ipif); 220f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 2217c478bd9Sstevel@tonic-gate return (sctp_ipif); 222*e35d2278Svi } else if (sctp_ipif->sctp_ipif_state == 223*e35d2278Svi SCTP_IPIFS_DOWN && backup_ipif == NULL) { 224*e35d2278Svi backup_ipif = sctp_ipif; 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate } 227*e35d2278Svi rw_exit(&sctp_ipif->sctp_ipif_lock); 228*e35d2278Svi sctp_ipif = list_next( 229*e35d2278Svi &sctps->sctps_g_ipifs[hindex].sctp_ipif_list, sctp_ipif); 230*e35d2278Svi } 231*e35d2278Svi if (backup_ipif != NULL) { 232*e35d2278Svi if (refhold) 233*e35d2278Svi SCTP_IPIF_REFHOLD(backup_ipif); 234*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 235*e35d2278Svi return (backup_ipif); 2367c478bd9Sstevel@tonic-gate } 237f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 2387c478bd9Sstevel@tonic-gate return (NULL); 2397c478bd9Sstevel@tonic-gate } 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate /* 2427c478bd9Sstevel@tonic-gate * Populate the list with all the SCTP ipifs for a given ipversion. 2437c478bd9Sstevel@tonic-gate * Increments sctp_ipif refcnt. 2447c478bd9Sstevel@tonic-gate * Called with no locks held. 2457c478bd9Sstevel@tonic-gate */ 2467c478bd9Sstevel@tonic-gate static int 2477c478bd9Sstevel@tonic-gate sctp_get_all_ipifs(sctp_t *sctp, int sleep) 2487c478bd9Sstevel@tonic-gate { 2497c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 2507c478bd9Sstevel@tonic-gate int i; 2517c478bd9Sstevel@tonic-gate int j; 2527c478bd9Sstevel@tonic-gate int error = 0; 253f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 2547c478bd9Sstevel@tonic-gate 255f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_READER); 2567c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 257f4b3ec61Sdh if (sctps->sctps_g_ipifs[i].ipif_count == 0) 2587c478bd9Sstevel@tonic-gate continue; 259f4b3ec61Sdh sctp_ipif = list_head(&sctps->sctps_g_ipifs[i].sctp_ipif_list); 260f4b3ec61Sdh for (j = 0; j < sctps->sctps_g_ipifs[i].ipif_count; j++) { 2617c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 262f551bb10Svi if (SCTP_IPIF_DISCARD(sctp_ipif->sctp_ipif_flags) || 2637c478bd9Sstevel@tonic-gate !SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state) || 2645d0bc3edSsommerfe !SCTP_IPIF_ZONE_MATCH(sctp, sctp_ipif) || 2657c478bd9Sstevel@tonic-gate (sctp->sctp_ipversion == IPV4_VERSION && 266f551bb10Svi sctp_ipif->sctp_ipif_isv6) || 2677c478bd9Sstevel@tonic-gate (sctp->sctp_connp->conn_ipv6_v6only && 268f551bb10Svi !sctp_ipif->sctp_ipif_isv6)) { 2697c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 2707c478bd9Sstevel@tonic-gate sctp_ipif = list_next( 271f4b3ec61Sdh &sctps->sctps_g_ipifs[i].sctp_ipif_list, 272f4b3ec61Sdh sctp_ipif); 2737c478bd9Sstevel@tonic-gate continue; 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 2767c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(sctp_ipif); 277f551bb10Svi error = sctp_ipif_hash_insert(sctp, sctp_ipif, sleep, 278*e35d2278Svi B_FALSE, B_FALSE); 279*e35d2278Svi if (error != 0 && error != EALREADY) 2807c478bd9Sstevel@tonic-gate goto free_stuff; 281f4b3ec61Sdh sctp_ipif = list_next( 282f4b3ec61Sdh &sctps->sctps_g_ipifs[i].sctp_ipif_list, 2837c478bd9Sstevel@tonic-gate sctp_ipif); 2847c478bd9Sstevel@tonic-gate } 2857c478bd9Sstevel@tonic-gate } 286f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 2877c478bd9Sstevel@tonic-gate return (0); 2887c478bd9Sstevel@tonic-gate free_stuff: 289f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 2907c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp); 2917c478bd9Sstevel@tonic-gate return (ENOMEM); 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate /* 2957c478bd9Sstevel@tonic-gate * Given a list of address, fills in the list of SCTP ipifs if all the addresses 2967c478bd9Sstevel@tonic-gate * are present in the SCTP interface list, return number of addresses filled 2971d8c4025Svi * or error. If the caller wants the list of addresses, it sends a pre-allocated 2981d8c4025Svi * buffer - list. Currently, this list is only used on a clustered node when 2991d8c4025Svi * the SCTP is in the listen state (from sctp_bind_add()). When called on a 3001d8c4025Svi * clustered node, the input is always a list of addresses (even if the 3011d8c4025Svi * original bind() was to INADDR_ANY). 3027c478bd9Sstevel@tonic-gate * Called with no locks held. 3037c478bd9Sstevel@tonic-gate */ 3047c478bd9Sstevel@tonic-gate int 3051d8c4025Svi sctp_valid_addr_list(sctp_t *sctp, const void *addrs, uint32_t addrcnt, 3061d8c4025Svi uchar_t *list, size_t lsize) 3077c478bd9Sstevel@tonic-gate { 3087c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 3097c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 3107c478bd9Sstevel@tonic-gate struct in_addr *addr4; 3117c478bd9Sstevel@tonic-gate in6_addr_t addr; 3127c478bd9Sstevel@tonic-gate int cnt; 3137c478bd9Sstevel@tonic-gate int err = 0; 3147c478bd9Sstevel@tonic-gate int saddr_cnt = 0; 3157c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 3167c478bd9Sstevel@tonic-gate boolean_t bind_to_all = B_FALSE; 3177c478bd9Sstevel@tonic-gate boolean_t check_addrs = B_FALSE; 3187c478bd9Sstevel@tonic-gate boolean_t check_lport = B_FALSE; 3191d8c4025Svi uchar_t *p = list; 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate /* 3227c478bd9Sstevel@tonic-gate * Need to check for port and address depending on the state. 3237c478bd9Sstevel@tonic-gate * After a socket is bound, we need to make sure that subsequent 3247c478bd9Sstevel@tonic-gate * bindx() has correct port. After an association is established, 3257c478bd9Sstevel@tonic-gate * we need to check for changing the bound address to invalid 3267c478bd9Sstevel@tonic-gate * addresses. 3277c478bd9Sstevel@tonic-gate */ 3287c478bd9Sstevel@tonic-gate if (sctp->sctp_state >= SCTPS_BOUND) { 3297c478bd9Sstevel@tonic-gate check_lport = B_TRUE; 3307c478bd9Sstevel@tonic-gate if (sctp->sctp_state > SCTPS_LISTEN) 3317c478bd9Sstevel@tonic-gate check_addrs = B_TRUE; 3327c478bd9Sstevel@tonic-gate } 3331d8c4025Svi 3347c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 3357c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 3367c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 3377c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 3387c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < addrcnt; cnt++) { 3397c478bd9Sstevel@tonic-gate boolean_t lookup_saddr = B_TRUE; 3401d8c4025Svi uint_t ifindex = 0; 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 3437c478bd9Sstevel@tonic-gate case AF_INET: 3447c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + cnt; 3457c478bd9Sstevel@tonic-gate if (sin4->sin_family != AF_INET || (check_lport && 3467c478bd9Sstevel@tonic-gate sin4->sin_port != sctp->sctp_lport)) { 3477c478bd9Sstevel@tonic-gate err = EINVAL; 3487c478bd9Sstevel@tonic-gate goto free_ret; 3497c478bd9Sstevel@tonic-gate } 3507c478bd9Sstevel@tonic-gate addr4 = &sin4->sin_addr; 3517c478bd9Sstevel@tonic-gate if (check_addrs && 3527c478bd9Sstevel@tonic-gate (addr4->s_addr == INADDR_ANY || 3537c478bd9Sstevel@tonic-gate addr4->s_addr == INADDR_BROADCAST || 3547c478bd9Sstevel@tonic-gate IN_MULTICAST(addr4->s_addr))) { 3557c478bd9Sstevel@tonic-gate err = EINVAL; 3567c478bd9Sstevel@tonic-gate goto free_ret; 3577c478bd9Sstevel@tonic-gate } 3587c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(addr4, &addr); 3597c478bd9Sstevel@tonic-gate if (!check_addrs && addr4->s_addr == INADDR_ANY) { 3607c478bd9Sstevel@tonic-gate lookup_saddr = B_FALSE; 3617c478bd9Sstevel@tonic-gate bind_to_all = B_TRUE; 3627c478bd9Sstevel@tonic-gate } 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate break; 3657c478bd9Sstevel@tonic-gate case AF_INET6: 3667c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + cnt; 3677c478bd9Sstevel@tonic-gate if (sin6->sin6_family != AF_INET6 || (check_lport && 3687c478bd9Sstevel@tonic-gate sin6->sin6_port != sctp->sctp_lport)) { 3697c478bd9Sstevel@tonic-gate err = EINVAL; 3707c478bd9Sstevel@tonic-gate goto free_ret; 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 3731d8c4025Svi /* Contains the interface index */ 3741d8c4025Svi ifindex = sin6->sin6_scope_id; 3757c478bd9Sstevel@tonic-gate if (sctp->sctp_connp->conn_ipv6_v6only && 3767c478bd9Sstevel@tonic-gate IN6_IS_ADDR_V4MAPPED(&addr)) { 3777c478bd9Sstevel@tonic-gate err = EAFNOSUPPORT; 3787c478bd9Sstevel@tonic-gate goto free_ret; 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate if (check_addrs && 3817c478bd9Sstevel@tonic-gate (IN6_IS_ADDR_LINKLOCAL(&addr) || 3827c478bd9Sstevel@tonic-gate IN6_IS_ADDR_MULTICAST(&addr) || 3837c478bd9Sstevel@tonic-gate IN6_IS_ADDR_UNSPECIFIED(&addr))) { 3847c478bd9Sstevel@tonic-gate err = EINVAL; 3857c478bd9Sstevel@tonic-gate goto free_ret; 3867c478bd9Sstevel@tonic-gate } 3877c478bd9Sstevel@tonic-gate if (!check_addrs && IN6_IS_ADDR_UNSPECIFIED(&addr)) { 3887c478bd9Sstevel@tonic-gate lookup_saddr = B_FALSE; 3897c478bd9Sstevel@tonic-gate bind_to_all = B_TRUE; 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate break; 3937c478bd9Sstevel@tonic-gate default: 3947c478bd9Sstevel@tonic-gate err = EAFNOSUPPORT; 3957c478bd9Sstevel@tonic-gate goto free_ret; 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate if (lookup_saddr) { 398*e35d2278Svi ipif = sctp_lookup_ipif_addr(&addr, B_TRUE, 399*e35d2278Svi sctp->sctp_zoneid, !sctp->sctp_connp->conn_allzones, 400*e35d2278Svi ifindex, 0, B_TRUE, sctp->sctp_sctps); 4017c478bd9Sstevel@tonic-gate if (ipif == NULL) { 4027c478bd9Sstevel@tonic-gate /* Address not in the list */ 4037c478bd9Sstevel@tonic-gate err = EINVAL; 4047c478bd9Sstevel@tonic-gate goto free_ret; 4051d8c4025Svi } else if (check_addrs && SCTP_IS_IPIF_LOOPBACK(ipif) && 4061d8c4025Svi cl_sctp_check_addrs == NULL) { 4077c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif); 4087c478bd9Sstevel@tonic-gate err = EINVAL; 4097c478bd9Sstevel@tonic-gate goto free_ret; 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate } 4127c478bd9Sstevel@tonic-gate if (!bind_to_all) { 413f551bb10Svi /* 414f551bb10Svi * If an address is added after association setup, 415f551bb10Svi * we need to wait for the peer to send us an ASCONF 416f551bb10Svi * ACK before we can start using it. 417f551bb10Svi * saddr_ipif_dontsrc will be reset (to 0) when we 418f551bb10Svi * get the ASCONF ACK for this address. 419f551bb10Svi */ 420f551bb10Svi err = sctp_ipif_hash_insert(sctp, ipif, KM_SLEEP, 421*e35d2278Svi check_addrs ? B_TRUE : B_FALSE, B_FALSE); 4227c478bd9Sstevel@tonic-gate if (err != 0) { 4237c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif); 4247c478bd9Sstevel@tonic-gate if (check_addrs && err == EALREADY) 4257c478bd9Sstevel@tonic-gate err = EADDRINUSE; 4267c478bd9Sstevel@tonic-gate goto free_ret; 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate saddr_cnt++; 4291d8c4025Svi if (lsize >= sizeof (addr)) { 4301d8c4025Svi bcopy(&addr, p, sizeof (addr)); 4311d8c4025Svi p += sizeof (addr); 4321d8c4025Svi lsize -= sizeof (addr); 4331d8c4025Svi } 4347c478bd9Sstevel@tonic-gate } 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate if (bind_to_all) { 4377c478bd9Sstevel@tonic-gate /* 4387c478bd9Sstevel@tonic-gate * Free whatever we might have added before encountering 4397c478bd9Sstevel@tonic-gate * inaddr_any. 4407c478bd9Sstevel@tonic-gate */ 4417c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs > 0) { 4427c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp); 4437c478bd9Sstevel@tonic-gate ASSERT(sctp->sctp_nsaddrs == 0); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate err = sctp_get_all_ipifs(sctp, KM_SLEEP); 4467c478bd9Sstevel@tonic-gate if (err != 0) 4477c478bd9Sstevel@tonic-gate return (err); 4487c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 1; 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 4517c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 4527c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 4537c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 4547c478bd9Sstevel@tonic-gate return (0); 4557c478bd9Sstevel@tonic-gate free_ret: 4567c478bd9Sstevel@tonic-gate if (saddr_cnt != 0) 4577c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp, addrs, saddr_cnt, B_TRUE); 4587c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 4597c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 4607c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 4617c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 4627c478bd9Sstevel@tonic-gate return (err); 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate static int 466f551bb10Svi sctp_ipif_hash_insert(sctp_t *sctp, sctp_ipif_t *ipif, int sleep, 467*e35d2278Svi boolean_t dontsrc, boolean_t allow_dup) 4687c478bd9Sstevel@tonic-gate { 4697c478bd9Sstevel@tonic-gate int cnt; 4707c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *ipif_obj; 471*e35d2278Svi int hindex; 472*e35d2278Svi 473*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(ipif->sctp_ipif_saddr, 474*e35d2278Svi ipif->sctp_ipif_isv6); 475*e35d2278Svi ipif_obj = list_head(&sctp->sctp_saddrs[hindex].sctp_ipif_list); 476*e35d2278Svi for (cnt = 0; cnt < sctp->sctp_saddrs[hindex].ipif_count; cnt++) { 477*e35d2278Svi if (IN6_ARE_ADDR_EQUAL(&ipif_obj->saddr_ipifp->sctp_ipif_saddr, 478*e35d2278Svi &ipif->sctp_ipif_saddr)) { 479*e35d2278Svi if (ipif->sctp_ipif_id != 480*e35d2278Svi ipif_obj->saddr_ipifp->sctp_ipif_id && 481*e35d2278Svi ipif_obj->saddr_ipifp->sctp_ipif_state == 482*e35d2278Svi SCTP_IPIFS_DOWN && ipif->sctp_ipif_state == 483*e35d2278Svi SCTP_IPIFS_UP) { 484*e35d2278Svi SCTP_IPIF_REFRELE(ipif_obj->saddr_ipifp); 485*e35d2278Svi ipif_obj->saddr_ipifp = ipif; 486*e35d2278Svi ipif_obj->saddr_ipif_dontsrc = dontsrc ? 1 : 0; 487*e35d2278Svi return (0); 488*e35d2278Svi } else if (!allow_dup || ipif->sctp_ipif_id == 489*e35d2278Svi ipif_obj->saddr_ipifp->sctp_ipif_id) { 490*e35d2278Svi return (EALREADY); 491*e35d2278Svi } 492*e35d2278Svi } 493*e35d2278Svi ipif_obj = list_next(&sctp->sctp_saddrs[hindex].sctp_ipif_list, 4947c478bd9Sstevel@tonic-gate ipif_obj); 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate ipif_obj = kmem_zalloc(sizeof (sctp_saddr_ipif_t), sleep); 4977c478bd9Sstevel@tonic-gate if (ipif_obj == NULL) { 4987c478bd9Sstevel@tonic-gate /* Need to do something */ 4997c478bd9Sstevel@tonic-gate return (ENOMEM); 5007c478bd9Sstevel@tonic-gate } 5017c478bd9Sstevel@tonic-gate ipif_obj->saddr_ipifp = ipif; 502f551bb10Svi ipif_obj->saddr_ipif_dontsrc = dontsrc ? 1 : 0; 503*e35d2278Svi list_insert_tail(&sctp->sctp_saddrs[hindex].sctp_ipif_list, ipif_obj); 504*e35d2278Svi sctp->sctp_saddrs[hindex].ipif_count++; 5057c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs++; 5067c478bd9Sstevel@tonic-gate return (0); 5077c478bd9Sstevel@tonic-gate } 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate static void 5107c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp_t *sctp, sctp_ipif_t *ipif) 5117c478bd9Sstevel@tonic-gate { 5127c478bd9Sstevel@tonic-gate int cnt; 5137c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *ipif_obj; 514*e35d2278Svi int hindex; 515*e35d2278Svi 516*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(ipif->sctp_ipif_saddr, 517*e35d2278Svi ipif->sctp_ipif_isv6); 518*e35d2278Svi ipif_obj = list_head(&sctp->sctp_saddrs[hindex].sctp_ipif_list); 519*e35d2278Svi for (cnt = 0; cnt < sctp->sctp_saddrs[hindex].ipif_count; cnt++) { 520*e35d2278Svi if (IN6_ARE_ADDR_EQUAL(&ipif_obj->saddr_ipifp->sctp_ipif_saddr, 521*e35d2278Svi &ipif->sctp_ipif_saddr)) { 522*e35d2278Svi list_remove(&sctp->sctp_saddrs[hindex].sctp_ipif_list, 5237c478bd9Sstevel@tonic-gate ipif_obj); 524*e35d2278Svi sctp->sctp_saddrs[hindex].ipif_count--; 5257c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs--; 5267c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(ipif_obj->saddr_ipifp); 5277c478bd9Sstevel@tonic-gate kmem_free(ipif_obj, sizeof (sctp_saddr_ipif_t)); 5287c478bd9Sstevel@tonic-gate break; 5297c478bd9Sstevel@tonic-gate } 530*e35d2278Svi ipif_obj = list_next(&sctp->sctp_saddrs[hindex].sctp_ipif_list, 5317c478bd9Sstevel@tonic-gate ipif_obj); 5327c478bd9Sstevel@tonic-gate } 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate static int 5367c478bd9Sstevel@tonic-gate sctp_compare_ipif_list(sctp_ipif_hash_t *list1, sctp_ipif_hash_t *list2) 5377c478bd9Sstevel@tonic-gate { 5387c478bd9Sstevel@tonic-gate int i; 5397c478bd9Sstevel@tonic-gate int j; 5407c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj1; 5417c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj2; 5427c478bd9Sstevel@tonic-gate int overlap = 0; 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate obj1 = list_head(&list1->sctp_ipif_list); 5457c478bd9Sstevel@tonic-gate for (i = 0; i < list1->ipif_count; i++) { 5467c478bd9Sstevel@tonic-gate obj2 = list_head(&list2->sctp_ipif_list); 5477c478bd9Sstevel@tonic-gate for (j = 0; j < list2->ipif_count; j++) { 548*e35d2278Svi if (IN6_ARE_ADDR_EQUAL( 549*e35d2278Svi &obj1->saddr_ipifp->sctp_ipif_saddr, 550*e35d2278Svi &obj2->saddr_ipifp->sctp_ipif_saddr)) { 5517c478bd9Sstevel@tonic-gate overlap++; 5527c478bd9Sstevel@tonic-gate break; 5537c478bd9Sstevel@tonic-gate } 5547c478bd9Sstevel@tonic-gate obj2 = list_next(&list2->sctp_ipif_list, 5557c478bd9Sstevel@tonic-gate obj2); 5567c478bd9Sstevel@tonic-gate } 5577c478bd9Sstevel@tonic-gate obj1 = list_next(&list1->sctp_ipif_list, obj1); 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate return (overlap); 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate int 5637c478bd9Sstevel@tonic-gate sctp_compare_saddrs(sctp_t *sctp1, sctp_t *sctp2) 5647c478bd9Sstevel@tonic-gate { 5657c478bd9Sstevel@tonic-gate int i; 5667c478bd9Sstevel@tonic-gate int overlap = 0; 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 5697c478bd9Sstevel@tonic-gate overlap += sctp_compare_ipif_list(&sctp1->sctp_saddrs[i], 5707c478bd9Sstevel@tonic-gate &sctp2->sctp_saddrs[i]); 5717c478bd9Sstevel@tonic-gate } 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate if (sctp1->sctp_nsaddrs == sctp2->sctp_nsaddrs && 5747c478bd9Sstevel@tonic-gate overlap == sctp1->sctp_nsaddrs) { 5757c478bd9Sstevel@tonic-gate return (SCTP_ADDR_EQUAL); 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate if (overlap == sctp1->sctp_nsaddrs) 5797c478bd9Sstevel@tonic-gate return (SCTP_ADDR_SUBSET); 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate if (overlap > 0) 5827c478bd9Sstevel@tonic-gate return (SCTP_ADDR_OVERLAP); 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate return (SCTP_ADDR_DISJOINT); 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate static int 5887c478bd9Sstevel@tonic-gate sctp_copy_ipifs(sctp_ipif_hash_t *list1, sctp_t *sctp2, int sleep) 5897c478bd9Sstevel@tonic-gate { 5907c478bd9Sstevel@tonic-gate int i; 5917c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 5927c478bd9Sstevel@tonic-gate int error = 0; 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate obj = list_head(&list1->sctp_ipif_list); 5957c478bd9Sstevel@tonic-gate for (i = 0; i < list1->ipif_count; i++) { 5967c478bd9Sstevel@tonic-gate SCTP_IPIF_REFHOLD(obj->saddr_ipifp); 597f551bb10Svi error = sctp_ipif_hash_insert(sctp2, obj->saddr_ipifp, sleep, 598*e35d2278Svi B_FALSE, B_FALSE); 599*e35d2278Svi ASSERT(error != EALREADY); 6007c478bd9Sstevel@tonic-gate if (error != 0) 6017c478bd9Sstevel@tonic-gate return (error); 6027c478bd9Sstevel@tonic-gate obj = list_next(&list1->sctp_ipif_list, obj); 6037c478bd9Sstevel@tonic-gate } 6047c478bd9Sstevel@tonic-gate return (error); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate int 6087c478bd9Sstevel@tonic-gate sctp_dup_saddrs(sctp_t *sctp1, sctp_t *sctp2, int sleep) 6097c478bd9Sstevel@tonic-gate { 6107c478bd9Sstevel@tonic-gate int error = 0; 6117c478bd9Sstevel@tonic-gate int i; 6127c478bd9Sstevel@tonic-gate 613f551bb10Svi if (sctp1 == NULL || sctp1->sctp_bound_to_all == 1) 6147c478bd9Sstevel@tonic-gate return (sctp_get_all_ipifs(sctp2, sleep)); 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 6177c478bd9Sstevel@tonic-gate if (sctp1->sctp_saddrs[i].ipif_count == 0) 6187c478bd9Sstevel@tonic-gate continue; 6197c478bd9Sstevel@tonic-gate error = sctp_copy_ipifs(&sctp1->sctp_saddrs[i], sctp2, sleep); 6207c478bd9Sstevel@tonic-gate if (error != 0) { 6217c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp2); 6227c478bd9Sstevel@tonic-gate return (error); 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate return (0); 6267c478bd9Sstevel@tonic-gate } 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate void 6297c478bd9Sstevel@tonic-gate sctp_free_saddrs(sctp_t *sctp) 6307c478bd9Sstevel@tonic-gate { 6317c478bd9Sstevel@tonic-gate int i; 6327c478bd9Sstevel@tonic-gate int l; 6337c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs == 0) 6367c478bd9Sstevel@tonic-gate return; 6377c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 6387c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 6397c478bd9Sstevel@tonic-gate continue; 6407c478bd9Sstevel@tonic-gate obj = list_tail(&sctp->sctp_saddrs[i].sctp_ipif_list); 6417c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 6427c478bd9Sstevel@tonic-gate list_remove(&sctp->sctp_saddrs[i].sctp_ipif_list, obj); 6437c478bd9Sstevel@tonic-gate SCTP_IPIF_REFRELE(obj->saddr_ipifp); 6447c478bd9Sstevel@tonic-gate sctp->sctp_nsaddrs--; 6457c478bd9Sstevel@tonic-gate kmem_free(obj, sizeof (sctp_saddr_ipif_t)); 6467c478bd9Sstevel@tonic-gate obj = list_tail(&sctp->sctp_saddrs[i].sctp_ipif_list); 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate sctp->sctp_saddrs[i].ipif_count = 0; 6497c478bd9Sstevel@tonic-gate } 650f551bb10Svi if (sctp->sctp_bound_to_all == 1) 651f551bb10Svi sctp->sctp_bound_to_all = 0; 6527c478bd9Sstevel@tonic-gate ASSERT(sctp->sctp_nsaddrs == 0); 6537c478bd9Sstevel@tonic-gate } 6547c478bd9Sstevel@tonic-gate 6557c478bd9Sstevel@tonic-gate /* 6567c478bd9Sstevel@tonic-gate * Add/Delete the given ILL from the SCTP ILL list. Called with no locks 6577c478bd9Sstevel@tonic-gate * held. 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate void 6607c478bd9Sstevel@tonic-gate sctp_update_ill(ill_t *ill, int op) 6617c478bd9Sstevel@tonic-gate { 6627c478bd9Sstevel@tonic-gate int i; 6637c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill = NULL; 6647c478bd9Sstevel@tonic-gate uint_t index; 665f4b3ec61Sdh netstack_t *ns = ill->ill_ipst->ips_netstack; 666f4b3ec61Sdh sctp_stack_t *sctps = ns->netstack_sctp; 6677c478bd9Sstevel@tonic-gate 668f4b3ec61Sdh rw_enter(&sctps->sctps_g_ills_lock, RW_WRITER); 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(ill)); 671f4b3ec61Sdh sctp_ill = list_head(&sctps->sctps_g_ills[index].sctp_ill_list); 672f4b3ec61Sdh for (i = 0; i < sctps->sctps_g_ills[index].ill_count; i++) { 6737c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(ill)) 6747c478bd9Sstevel@tonic-gate break; 675f4b3ec61Sdh sctp_ill = list_next(&sctps->sctps_g_ills[index].sctp_ill_list, 6767c478bd9Sstevel@tonic-gate sctp_ill); 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate switch (op) { 6807c478bd9Sstevel@tonic-gate case SCTP_ILL_INSERT: 6817c478bd9Sstevel@tonic-gate if (sctp_ill != NULL) { 6827c478bd9Sstevel@tonic-gate /* Unmark it if it is condemned */ 6837c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) 6847c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state = 0; 685f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 6867c478bd9Sstevel@tonic-gate return; 6877c478bd9Sstevel@tonic-gate } 6887c478bd9Sstevel@tonic-gate sctp_ill = kmem_zalloc(sizeof (sctp_ill_t), KM_NOSLEEP); 6897c478bd9Sstevel@tonic-gate /* Need to re-try? */ 6907c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 6917c478bd9Sstevel@tonic-gate ip1dbg(("sctp_ill_insert: mem error..\n")); 692f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 6937c478bd9Sstevel@tonic-gate return; 6947c478bd9Sstevel@tonic-gate } 695*e35d2278Svi sctp_ill->sctp_ill_name = kmem_zalloc(ill->ill_name_length, 696*e35d2278Svi KM_NOSLEEP); 6977c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_name == NULL) { 6987c478bd9Sstevel@tonic-gate ip1dbg(("sctp_ill_insert: mem error..\n")); 6997c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 700f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 7017c478bd9Sstevel@tonic-gate return; 7027c478bd9Sstevel@tonic-gate } 7037c478bd9Sstevel@tonic-gate bcopy(ill->ill_name, sctp_ill->sctp_ill_name, 7047c478bd9Sstevel@tonic-gate ill->ill_name_length); 7057c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length = ill->ill_name_length; 7067c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_index = SCTP_ILL_TO_PHYINDEX(ill); 7077c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_flags = ill->ill_phyint->phyint_flags; 708f4b3ec61Sdh sctp_ill->sctp_ill_netstack = ns; /* No netstack_hold */ 709f4b3ec61Sdh list_insert_tail(&sctps->sctps_g_ills[index].sctp_ill_list, 7107c478bd9Sstevel@tonic-gate (void *)sctp_ill); 711f4b3ec61Sdh sctps->sctps_g_ills[index].ill_count++; 712f4b3ec61Sdh sctps->sctps_ills_count++; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate break; 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate case SCTP_ILL_REMOVE: 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 719f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 7207c478bd9Sstevel@tonic-gate return; 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0) { 723f4b3ec61Sdh list_remove(&sctps->sctps_g_ills[index].sctp_ill_list, 7247c478bd9Sstevel@tonic-gate (void *)sctp_ill); 725f4b3ec61Sdh sctps->sctps_g_ills[index].ill_count--; 726f4b3ec61Sdh sctps->sctps_ills_count--; 7277c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 7287c478bd9Sstevel@tonic-gate ill->ill_name_length); 7297c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 7307c478bd9Sstevel@tonic-gate } else { 7317c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state = SCTP_ILLS_CONDEMNED; 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate break; 7357c478bd9Sstevel@tonic-gate } 736f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 7377c478bd9Sstevel@tonic-gate } 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate /* move ipif from f_ill to t_ill */ 7407c478bd9Sstevel@tonic-gate void 7417c478bd9Sstevel@tonic-gate sctp_move_ipif(ipif_t *ipif, ill_t *f_ill, ill_t *t_ill) 7427c478bd9Sstevel@tonic-gate { 7437c478bd9Sstevel@tonic-gate sctp_ill_t *fsctp_ill = NULL; 7447c478bd9Sstevel@tonic-gate sctp_ill_t *tsctp_ill = NULL; 7457c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 746*e35d2278Svi uint_t hindex; 7477c478bd9Sstevel@tonic-gate int i; 748f4b3ec61Sdh netstack_t *ns = ipif->ipif_ill->ill_ipst->ips_netstack; 749f4b3ec61Sdh sctp_stack_t *sctps = ns->netstack_sctp; 7507c478bd9Sstevel@tonic-gate 751f4b3ec61Sdh rw_enter(&sctps->sctps_g_ills_lock, RW_READER); 752f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_READER); 7537c478bd9Sstevel@tonic-gate 754*e35d2278Svi hindex = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(f_ill)); 755*e35d2278Svi fsctp_ill = list_head(&sctps->sctps_g_ills[hindex].sctp_ill_list); 756*e35d2278Svi for (i = 0; i < sctps->sctps_g_ills[hindex].ill_count; i++) { 7577c478bd9Sstevel@tonic-gate if (fsctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(f_ill)) 7587c478bd9Sstevel@tonic-gate break; 759*e35d2278Svi fsctp_ill = list_next( 760*e35d2278Svi &sctps->sctps_g_ills[hindex].sctp_ill_list, fsctp_ill); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 763*e35d2278Svi hindex = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(t_ill)); 764*e35d2278Svi tsctp_ill = list_head(&sctps->sctps_g_ills[hindex].sctp_ill_list); 765*e35d2278Svi for (i = 0; i < sctps->sctps_g_ills[hindex].ill_count; i++) { 7667c478bd9Sstevel@tonic-gate if (tsctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(t_ill)) 7677c478bd9Sstevel@tonic-gate break; 768*e35d2278Svi tsctp_ill = list_next( 769*e35d2278Svi &sctps->sctps_g_ills[hindex].sctp_ill_list, tsctp_ill); 7707c478bd9Sstevel@tonic-gate } 7717c478bd9Sstevel@tonic-gate 772*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(ipif->ipif_v6lcl_addr, 773*e35d2278Svi ipif->ipif_ill->ill_isv6); 774*e35d2278Svi sctp_ipif = list_head(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list); 775*e35d2278Svi for (i = 0; i < sctps->sctps_g_ipifs[hindex].ipif_count; i++) { 7767c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_id == ipif->ipif_seqid) 7777c478bd9Sstevel@tonic-gate break; 778f4b3ec61Sdh sctp_ipif = list_next( 779*e35d2278Svi &sctps->sctps_g_ipifs[hindex].sctp_ipif_list, sctp_ipif); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate /* Should be an ASSERT? */ 7827c478bd9Sstevel@tonic-gate if (fsctp_ill == NULL || tsctp_ill == NULL || sctp_ipif == NULL) { 7837c478bd9Sstevel@tonic-gate ip1dbg(("sctp_move_ipif: error moving ipif %p from %p to %p\n", 7847c478bd9Sstevel@tonic-gate (void *)ipif, (void *)f_ill, (void *)t_ill)); 785f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 786f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 7877c478bd9Sstevel@tonic-gate return; 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 7907c478bd9Sstevel@tonic-gate ASSERT(sctp_ipif->sctp_ipif_ill == fsctp_ill); 7917c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_ill = tsctp_ill; 7927c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 7937c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&fsctp_ill->sctp_ill_ipifcnt, -1); 7947c478bd9Sstevel@tonic-gate atomic_add_32(&tsctp_ill->sctp_ill_ipifcnt, 1); 795f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 796f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 7977c478bd9Sstevel@tonic-gate } 7987c478bd9Sstevel@tonic-gate 799*e35d2278Svi /* 800*e35d2278Svi * Walk the list of SCTPs and find each that has oipif in it's saddr list, and 801*e35d2278Svi * if so replace it with nipif. 802*e35d2278Svi */ 803*e35d2278Svi void 804*e35d2278Svi sctp_update_saddrs(sctp_ipif_t *oipif, sctp_ipif_t *nipif, int idx, 805*e35d2278Svi sctp_stack_t *sctps) 806*e35d2278Svi { 807*e35d2278Svi sctp_t *sctp; 808*e35d2278Svi sctp_t *sctp_prev = NULL; 809*e35d2278Svi sctp_saddr_ipif_t *sobj; 810*e35d2278Svi int count; 811*e35d2278Svi 812*e35d2278Svi sctp = sctps->sctps_gsctp; 813*e35d2278Svi mutex_enter(&sctps->sctps_g_lock); 814*e35d2278Svi while (sctp != NULL && oipif->sctp_ipif_refcnt > 0) { 815*e35d2278Svi mutex_enter(&sctp->sctp_reflock); 816*e35d2278Svi if (sctp->sctp_condemned || 817*e35d2278Svi sctp->sctp_saddrs[idx].ipif_count <= 0) { 818*e35d2278Svi mutex_exit(&sctp->sctp_reflock); 819*e35d2278Svi sctp = list_next(&sctps->sctps_g_list, sctp); 820*e35d2278Svi continue; 821*e35d2278Svi } 822*e35d2278Svi sctp->sctp_refcnt++; 823*e35d2278Svi mutex_exit(&sctp->sctp_reflock); 824*e35d2278Svi mutex_exit(&sctps->sctps_g_lock); 825*e35d2278Svi if (sctp_prev != NULL) 826*e35d2278Svi SCTP_REFRELE(sctp_prev); 827*e35d2278Svi 828*e35d2278Svi RUN_SCTP(sctp); 829*e35d2278Svi sobj = list_head(&sctp->sctp_saddrs[idx].sctp_ipif_list); 830*e35d2278Svi for (count = 0; count < 831*e35d2278Svi sctp->sctp_saddrs[idx].ipif_count; count++) { 832*e35d2278Svi if (sobj->saddr_ipifp == oipif) { 833*e35d2278Svi SCTP_IPIF_REFHOLD(nipif); 834*e35d2278Svi sobj->saddr_ipifp = nipif; 835*e35d2278Svi ASSERT(oipif->sctp_ipif_refcnt > 0); 836*e35d2278Svi /* We have the writer lock */ 837*e35d2278Svi oipif->sctp_ipif_refcnt--; 838*e35d2278Svi /* 839*e35d2278Svi * Can't have more than one referring 840*e35d2278Svi * to the same sctp_ipif. 841*e35d2278Svi */ 842*e35d2278Svi break; 843*e35d2278Svi } 844*e35d2278Svi sobj = list_next(&sctp->sctp_saddrs[idx].sctp_ipif_list, 845*e35d2278Svi sobj); 846*e35d2278Svi } 847*e35d2278Svi WAKE_SCTP(sctp); 848*e35d2278Svi sctp_prev = sctp; 849*e35d2278Svi mutex_enter(&sctps->sctps_g_lock); 850*e35d2278Svi sctp = list_next(&sctps->sctps_g_list, sctp); 851*e35d2278Svi } 852*e35d2278Svi mutex_exit(&sctps->sctps_g_lock); 853*e35d2278Svi if (sctp_prev != NULL) 854*e35d2278Svi SCTP_REFRELE(sctp_prev); 855*e35d2278Svi } 856*e35d2278Svi 857*e35d2278Svi /* 858*e35d2278Svi * Given an ipif, walk the hash list in the global ipif table and for 859*e35d2278Svi * any other SCTP ipif with the same address and non-zero reference, walk 860*e35d2278Svi * the SCTP list and update the saddr list, if required, to point to the 861*e35d2278Svi * new SCTP ipif. 862*e35d2278Svi */ 863*e35d2278Svi void 864*e35d2278Svi sctp_chk_and_updt_saddr(int hindex, sctp_ipif_t *ipif, sctp_stack_t *sctps) 865*e35d2278Svi { 866*e35d2278Svi int cnt; 867*e35d2278Svi sctp_ipif_t *sipif; 868*e35d2278Svi 869*e35d2278Svi ASSERT(sctps->sctps_g_ipifs[hindex].ipif_count > 0); 870*e35d2278Svi ASSERT(ipif->sctp_ipif_state == SCTP_IPIFS_UP); 871*e35d2278Svi 872*e35d2278Svi sipif = list_head(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list); 873*e35d2278Svi for (cnt = 0; cnt < sctps->sctps_g_ipifs[hindex].ipif_count; cnt++) { 874*e35d2278Svi rw_enter(&sipif->sctp_ipif_lock, RW_WRITER); 875*e35d2278Svi if (sipif->sctp_ipif_id != ipif->sctp_ipif_id && 876*e35d2278Svi IN6_ARE_ADDR_EQUAL(&sipif->sctp_ipif_saddr, 877*e35d2278Svi &ipif->sctp_ipif_saddr) && sipif->sctp_ipif_refcnt > 0) { 878*e35d2278Svi /* 879*e35d2278Svi * There can only be one address up at any time 880*e35d2278Svi * and we are here because ipif has been brought 881*e35d2278Svi * up. 882*e35d2278Svi */ 883*e35d2278Svi ASSERT(sipif->sctp_ipif_state != SCTP_IPIFS_UP); 884*e35d2278Svi /* 885*e35d2278Svi * Someone has a reference to this we need to update to 886*e35d2278Svi * point to the new sipif. 887*e35d2278Svi */ 888*e35d2278Svi sctp_update_saddrs(sipif, ipif, hindex, sctps); 889*e35d2278Svi } 890*e35d2278Svi rw_exit(&sipif->sctp_ipif_lock); 891*e35d2278Svi sipif = list_next(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list, 892*e35d2278Svi sipif); 893*e35d2278Svi } 894*e35d2278Svi } 895*e35d2278Svi 896*e35d2278Svi /* 897*e35d2278Svi * Insert a new SCTP ipif using 'ipif'. v6addr is the address that existed 898*e35d2278Svi * prior to the current address in 'ipif'. Only when an existing address 899*e35d2278Svi * is changed on an IPIF, will v6addr be specified. If the IPIF already 900*e35d2278Svi * exists in the global SCTP ipif table, then we either removed it, if 901*e35d2278Svi * it doesn't have any existing reference, or mark it condemned otherwise. 902*e35d2278Svi * If an address is being brought up (IPIF_UP), then we need to scan 903*e35d2278Svi * the SCTP list to check if there is any SCTP that points to the *same* 904*e35d2278Svi * address on a different SCTP ipif and update in that case. 905*e35d2278Svi */ 906*e35d2278Svi void 907*e35d2278Svi sctp_update_ipif_addr(ipif_t *ipif, in6_addr_t v6addr) 908*e35d2278Svi { 909*e35d2278Svi ill_t *ill = ipif->ipif_ill; 910*e35d2278Svi int i; 911*e35d2278Svi sctp_ill_t *sctp_ill; 912*e35d2278Svi sctp_ill_t *osctp_ill; 913*e35d2278Svi sctp_ipif_t *sctp_ipif = NULL; 914*e35d2278Svi sctp_ipif_t *osctp_ipif = NULL; 915*e35d2278Svi uint_t ill_index; 916*e35d2278Svi int hindex; 917*e35d2278Svi sctp_stack_t *sctps; 918*e35d2278Svi 919*e35d2278Svi 920*e35d2278Svi sctps = ipif->ipif_ill->ill_ipst->ips_netstack->netstack_sctp; 921*e35d2278Svi 922*e35d2278Svi /* Index for new address */ 923*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(ipif->ipif_v6lcl_addr, ill->ill_isv6); 924*e35d2278Svi 925*e35d2278Svi /* 926*e35d2278Svi * The address on this IPIF is changing, we need to look for 927*e35d2278Svi * this old address and mark it condemned, before creating 928*e35d2278Svi * one for the new address. 929*e35d2278Svi */ 930*e35d2278Svi osctp_ipif = sctp_lookup_ipif_addr(&v6addr, B_FALSE, 931*e35d2278Svi ipif->ipif_zoneid, B_TRUE, SCTP_ILL_TO_PHYINDEX(ill), 932*e35d2278Svi ipif->ipif_seqid, B_FALSE, sctps); 933*e35d2278Svi 934*e35d2278Svi rw_enter(&sctps->sctps_g_ills_lock, RW_READER); 935*e35d2278Svi rw_enter(&sctps->sctps_g_ipifs_lock, RW_WRITER); 936*e35d2278Svi 937*e35d2278Svi ill_index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(ill)); 938*e35d2278Svi sctp_ill = list_head(&sctps->sctps_g_ills[ill_index].sctp_ill_list); 939*e35d2278Svi for (i = 0; i < sctps->sctps_g_ills[ill_index].ill_count; i++) { 940*e35d2278Svi if (sctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(ill)) 941*e35d2278Svi break; 942*e35d2278Svi sctp_ill = list_next( 943*e35d2278Svi &sctps->sctps_g_ills[ill_index].sctp_ill_list, sctp_ill); 944*e35d2278Svi } 945*e35d2278Svi 946*e35d2278Svi if (sctp_ill == NULL) { 947*e35d2278Svi ip1dbg(("sctp_ipif_insert: ill not found ..\n")); 948*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 949*e35d2278Svi rw_exit(&sctps->sctps_g_ills_lock); 950*e35d2278Svi } 951*e35d2278Svi 952*e35d2278Svi if (osctp_ipif != NULL) { 953*e35d2278Svi 954*e35d2278Svi /* The address is the same? */ 955*e35d2278Svi if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr, &v6addr)) { 956*e35d2278Svi boolean_t chk_n_updt = B_FALSE; 957*e35d2278Svi 958*e35d2278Svi rw_downgrade(&sctps->sctps_g_ipifs_lock); 959*e35d2278Svi rw_enter(&osctp_ipif->sctp_ipif_lock, RW_WRITER); 960*e35d2278Svi if (ipif->ipif_flags & IPIF_UP && 961*e35d2278Svi osctp_ipif->sctp_ipif_state != SCTP_IPIFS_UP) { 962*e35d2278Svi osctp_ipif->sctp_ipif_state = SCTP_IPIFS_UP; 963*e35d2278Svi chk_n_updt = B_TRUE; 964*e35d2278Svi } else { 965*e35d2278Svi osctp_ipif->sctp_ipif_state = SCTP_IPIFS_DOWN; 966*e35d2278Svi } 967*e35d2278Svi osctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 968*e35d2278Svi rw_exit(&osctp_ipif->sctp_ipif_lock); 969*e35d2278Svi if (chk_n_updt) { 970*e35d2278Svi sctp_chk_and_updt_saddr(hindex, osctp_ipif, 971*e35d2278Svi sctps); 972*e35d2278Svi } 973*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 974*e35d2278Svi rw_exit(&sctps->sctps_g_ills_lock); 975*e35d2278Svi return; 976*e35d2278Svi } 977*e35d2278Svi /* 978*e35d2278Svi * We are effectively removing this address from the ILL. 979*e35d2278Svi */ 980*e35d2278Svi if (osctp_ipif->sctp_ipif_refcnt != 0) { 981*e35d2278Svi osctp_ipif->sctp_ipif_state = SCTP_IPIFS_CONDEMNED; 982*e35d2278Svi } else { 983*e35d2278Svi list_t *ipif_list; 984*e35d2278Svi int ohindex; 985*e35d2278Svi 986*e35d2278Svi osctp_ill = osctp_ipif->sctp_ipif_ill; 987*e35d2278Svi /* hash index for the old one */ 988*e35d2278Svi ohindex = SCTP_IPIF_ADDR_HASH( 989*e35d2278Svi osctp_ipif->sctp_ipif_saddr, 990*e35d2278Svi osctp_ipif->sctp_ipif_isv6); 991*e35d2278Svi 992*e35d2278Svi ipif_list = 993*e35d2278Svi &sctps->sctps_g_ipifs[ohindex].sctp_ipif_list; 994*e35d2278Svi 995*e35d2278Svi list_remove(ipif_list, (void *)osctp_ipif); 996*e35d2278Svi sctps->sctps_g_ipifs[ohindex].ipif_count--; 997*e35d2278Svi sctps->sctps_g_ipifs_count--; 998*e35d2278Svi rw_destroy(&osctp_ipif->sctp_ipif_lock); 999*e35d2278Svi kmem_free(osctp_ipif, sizeof (sctp_ipif_t)); 1000*e35d2278Svi (void) atomic_add_32_nv(&osctp_ill->sctp_ill_ipifcnt, 1001*e35d2278Svi -1); 1002*e35d2278Svi } 1003*e35d2278Svi } 1004*e35d2278Svi 1005*e35d2278Svi sctp_ipif = kmem_zalloc(sizeof (sctp_ipif_t), KM_NOSLEEP); 1006*e35d2278Svi /* Try again? */ 1007*e35d2278Svi if (sctp_ipif == NULL) { 1008*e35d2278Svi ip1dbg(("sctp_ipif_insert: mem failure..\n")); 1009*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 1010*e35d2278Svi rw_exit(&sctps->sctps_g_ills_lock); 1011*e35d2278Svi return; 1012*e35d2278Svi } 1013*e35d2278Svi sctps->sctps_g_ipifs_count++; 1014*e35d2278Svi rw_init(&sctp_ipif->sctp_ipif_lock, NULL, RW_DEFAULT, NULL); 1015*e35d2278Svi sctp_ipif->sctp_ipif_saddr = ipif->ipif_v6lcl_addr; 1016*e35d2278Svi sctp_ipif->sctp_ipif_ill = sctp_ill; 1017*e35d2278Svi sctp_ipif->sctp_ipif_isv6 = ill->ill_isv6; 1018*e35d2278Svi sctp_ipif->sctp_ipif_zoneid = ipif->ipif_zoneid; 1019*e35d2278Svi sctp_ipif->sctp_ipif_id = ipif->ipif_seqid; 1020*e35d2278Svi if (ipif->ipif_flags & IPIF_UP) 1021*e35d2278Svi sctp_ipif->sctp_ipif_state = SCTP_IPIFS_UP; 1022*e35d2278Svi else 1023*e35d2278Svi sctp_ipif->sctp_ipif_state = SCTP_IPIFS_DOWN; 1024*e35d2278Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 1025*e35d2278Svi /* 1026*e35d2278Svi * We add it to the head so that it is quicker to find good/recent 1027*e35d2278Svi * additions. 1028*e35d2278Svi */ 1029*e35d2278Svi list_insert_head(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list, 1030*e35d2278Svi (void *)sctp_ipif); 1031*e35d2278Svi sctps->sctps_g_ipifs[hindex].ipif_count++; 1032*e35d2278Svi atomic_add_32(&sctp_ill->sctp_ill_ipifcnt, 1); 1033*e35d2278Svi if (sctp_ipif->sctp_ipif_state == SCTP_IPIFS_UP) 1034*e35d2278Svi sctp_chk_and_updt_saddr(hindex, sctp_ipif, sctps); 1035*e35d2278Svi rw_exit(&sctps->sctps_g_ipifs_lock); 1036*e35d2278Svi rw_exit(&sctps->sctps_g_ills_lock); 1037*e35d2278Svi } 1038*e35d2278Svi 10397c478bd9Sstevel@tonic-gate /* Insert, Remove, Mark up or Mark down the ipif */ 10407c478bd9Sstevel@tonic-gate void 10417c478bd9Sstevel@tonic-gate sctp_update_ipif(ipif_t *ipif, int op) 10427c478bd9Sstevel@tonic-gate { 10437c478bd9Sstevel@tonic-gate ill_t *ill = ipif->ipif_ill; 10447c478bd9Sstevel@tonic-gate int i; 10457c478bd9Sstevel@tonic-gate sctp_ill_t *sctp_ill; 10467c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 10477c478bd9Sstevel@tonic-gate uint_t ill_index; 1048*e35d2278Svi uint_t hindex; 1049f4b3ec61Sdh netstack_t *ns = ipif->ipif_ill->ill_ipst->ips_netstack; 1050f4b3ec61Sdh sctp_stack_t *sctps = ns->netstack_sctp; 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate ip2dbg(("sctp_update_ipif: %s %d\n", ill->ill_name, ipif->ipif_seqid)); 10537c478bd9Sstevel@tonic-gate 1054f4b3ec61Sdh rw_enter(&sctps->sctps_g_ills_lock, RW_READER); 1055f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_WRITER); 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate ill_index = SCTP_ILL_HASH_FN(SCTP_ILL_TO_PHYINDEX(ill)); 1058f4b3ec61Sdh sctp_ill = list_head(&sctps->sctps_g_ills[ill_index].sctp_ill_list); 1059f4b3ec61Sdh for (i = 0; i < sctps->sctps_g_ills[ill_index].ill_count; i++) { 10607c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_index == SCTP_ILL_TO_PHYINDEX(ill)) 10617c478bd9Sstevel@tonic-gate break; 1062f4b3ec61Sdh sctp_ill = list_next( 1063f4b3ec61Sdh &sctps->sctps_g_ills[ill_index].sctp_ill_list, sctp_ill); 10647c478bd9Sstevel@tonic-gate } 10657c478bd9Sstevel@tonic-gate if (sctp_ill == NULL) { 1066f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 1067f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 10687c478bd9Sstevel@tonic-gate return; 10697c478bd9Sstevel@tonic-gate } 10707c478bd9Sstevel@tonic-gate 1071*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(ipif->ipif_v6lcl_addr, 1072*e35d2278Svi ipif->ipif_ill->ill_isv6); 1073*e35d2278Svi sctp_ipif = list_head(&sctps->sctps_g_ipifs[hindex].sctp_ipif_list); 1074*e35d2278Svi for (i = 0; i < sctps->sctps_g_ipifs[hindex].ipif_count; i++) { 1075*e35d2278Svi if (sctp_ipif->sctp_ipif_id == ipif->ipif_seqid) { 1076*e35d2278Svi ASSERT(IN6_ARE_ADDR_EQUAL(&sctp_ipif->sctp_ipif_saddr, 1077*e35d2278Svi &ipif->ipif_v6lcl_addr)); 10787c478bd9Sstevel@tonic-gate break; 1079*e35d2278Svi } 1080f4b3ec61Sdh sctp_ipif = list_next( 1081*e35d2278Svi &sctps->sctps_g_ipifs[hindex].sctp_ipif_list, 10827c478bd9Sstevel@tonic-gate sctp_ipif); 10837c478bd9Sstevel@tonic-gate } 1084*e35d2278Svi if (sctp_ipif == NULL) { 10857c478bd9Sstevel@tonic-gate ip1dbg(("sctp_update_ipif: null sctp_ipif for %d\n", op)); 1086f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 1087f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 10887c478bd9Sstevel@tonic-gate return; 10897c478bd9Sstevel@tonic-gate } 1090*e35d2278Svi ASSERT(sctp_ill == sctp_ipif->sctp_ipif_ill); 10917c478bd9Sstevel@tonic-gate switch (op) { 10927c478bd9Sstevel@tonic-gate case SCTP_IPIF_REMOVE: 10937c478bd9Sstevel@tonic-gate { 10947c478bd9Sstevel@tonic-gate list_t *ipif_list; 10957c478bd9Sstevel@tonic-gate list_t *ill_list; 10967c478bd9Sstevel@tonic-gate 1097f4b3ec61Sdh ill_list = &sctps->sctps_g_ills[ill_index].sctp_ill_list; 1098*e35d2278Svi ipif_list = &sctps->sctps_g_ipifs[hindex].sctp_ipif_list; 10997c478bd9Sstevel@tonic-gate if (sctp_ipif->sctp_ipif_refcnt != 0) { 11007c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_CONDEMNED; 1101f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 1102f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 11037c478bd9Sstevel@tonic-gate return; 11047c478bd9Sstevel@tonic-gate } 11057c478bd9Sstevel@tonic-gate list_remove(ipif_list, (void *)sctp_ipif); 1106*e35d2278Svi sctps->sctps_g_ipifs[hindex].ipif_count--; 1107f4b3ec61Sdh sctps->sctps_g_ipifs_count--; 11087c478bd9Sstevel@tonic-gate rw_destroy(&sctp_ipif->sctp_ipif_lock); 11097c478bd9Sstevel@tonic-gate kmem_free(sctp_ipif, sizeof (sctp_ipif_t)); 11107c478bd9Sstevel@tonic-gate (void) atomic_add_32_nv(&sctp_ill->sctp_ill_ipifcnt, -1); 1111f4b3ec61Sdh if (rw_tryupgrade(&sctps->sctps_g_ills_lock) != 0) { 1112f4b3ec61Sdh rw_downgrade(&sctps->sctps_g_ipifs_lock); 11137c478bd9Sstevel@tonic-gate if (sctp_ill->sctp_ill_ipifcnt == 0 && 11147c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_state == SCTP_ILLS_CONDEMNED) { 11157c478bd9Sstevel@tonic-gate list_remove(ill_list, (void *)sctp_ill); 1116f4b3ec61Sdh sctps->sctps_ills_count--; 1117f4b3ec61Sdh sctps->sctps_g_ills[ill_index].ill_count--; 11187c478bd9Sstevel@tonic-gate kmem_free(sctp_ill->sctp_ill_name, 11197c478bd9Sstevel@tonic-gate sctp_ill->sctp_ill_name_length); 11207c478bd9Sstevel@tonic-gate kmem_free(sctp_ill, sizeof (sctp_ill_t)); 11217c478bd9Sstevel@tonic-gate } 11227c478bd9Sstevel@tonic-gate } 11237c478bd9Sstevel@tonic-gate break; 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate case SCTP_IPIF_UP: 11277c478bd9Sstevel@tonic-gate 1128f4b3ec61Sdh rw_downgrade(&sctps->sctps_g_ipifs_lock); 11297c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 11307c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_UP; 1131f551bb10Svi sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 1132*e35d2278Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 11337c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 1134*e35d2278Svi sctp_chk_and_updt_saddr(hindex, sctp_ipif, 1135*e35d2278Svi ipif->ipif_ill->ill_ipst->ips_netstack->netstack_sctp); 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate break; 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate case SCTP_IPIF_UPDATE: 11407c478bd9Sstevel@tonic-gate 1141f4b3ec61Sdh rw_downgrade(&sctps->sctps_g_ipifs_lock); 11427c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 11437c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 11447c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_zoneid = ipif->ipif_zoneid; 1145f551bb10Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 11467c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate break; 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate case SCTP_IPIF_DOWN: 11517c478bd9Sstevel@tonic-gate 1152f4b3ec61Sdh rw_downgrade(&sctps->sctps_g_ipifs_lock); 11537c478bd9Sstevel@tonic-gate rw_enter(&sctp_ipif->sctp_ipif_lock, RW_WRITER); 11547c478bd9Sstevel@tonic-gate sctp_ipif->sctp_ipif_state = SCTP_IPIFS_DOWN; 1155*e35d2278Svi sctp_ipif->sctp_ipif_mtu = ipif->ipif_mtu; 1156*e35d2278Svi sctp_ipif->sctp_ipif_flags = ipif->ipif_flags; 11577c478bd9Sstevel@tonic-gate rw_exit(&sctp_ipif->sctp_ipif_lock); 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate break; 11607c478bd9Sstevel@tonic-gate } 1161f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 1162f4b3ec61Sdh rw_exit(&sctps->sctps_g_ills_lock); 11637c478bd9Sstevel@tonic-gate } 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate * SCTP source address list manipulaton, locking not used (except for 11677c478bd9Sstevel@tonic-gate * sctp locking by the caller. 11687c478bd9Sstevel@tonic-gate */ 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* Remove a specific saddr from the list */ 11717c478bd9Sstevel@tonic-gate void 11727c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp_t *sctp, sctp_saddr_ipif_t *sp) 11737c478bd9Sstevel@tonic-gate { 11747c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 11757c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 11787c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp, sp->saddr_ipifp); 11817c478bd9Sstevel@tonic-gate 1182f551bb10Svi if (sctp->sctp_bound_to_all == 1) 11837c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 0; 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 11867c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 11897c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 11907c478bd9Sstevel@tonic-gate } 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate /* 11937c478bd9Sstevel@tonic-gate * Delete source address from the existing list. No error checking done here 11947c478bd9Sstevel@tonic-gate * Called with no locks held. 11957c478bd9Sstevel@tonic-gate */ 11967c478bd9Sstevel@tonic-gate void 11977c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp_t *sctp, const void *addrs, int addcnt, 11987c478bd9Sstevel@tonic-gate boolean_t fanout_locked) 11997c478bd9Sstevel@tonic-gate { 12007c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 12017c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 12027c478bd9Sstevel@tonic-gate int cnt; 12037c478bd9Sstevel@tonic-gate in6_addr_t addr; 12047c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 12051d8c4025Svi int ifindex = 0; 12067c478bd9Sstevel@tonic-gate 12071d8c4025Svi ASSERT(sctp->sctp_nsaddrs >= addcnt); 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate if (!fanout_locked) { 12107c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 12117c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 12127c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 12137c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_listen_tfp->tf_lock); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < addcnt; cnt++) { 12177c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 12187c478bd9Sstevel@tonic-gate case AF_INET: 12197c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + cnt; 12207c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(&sin4->sin_addr, &addr); 12217c478bd9Sstevel@tonic-gate break; 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate case AF_INET6: 12247c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + cnt; 12257c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 12261d8c4025Svi ifindex = sin6->sin6_scope_id; 12277c478bd9Sstevel@tonic-gate break; 12287c478bd9Sstevel@tonic-gate } 1229*e35d2278Svi sctp_ipif = sctp_lookup_ipif_addr(&addr, B_FALSE, 1230*e35d2278Svi sctp->sctp_zoneid, !sctp->sctp_connp->conn_allzones, 1231*e35d2278Svi ifindex, 0, B_TRUE, sctp->sctp_sctps); 12327c478bd9Sstevel@tonic-gate ASSERT(sctp_ipif != NULL); 12337c478bd9Sstevel@tonic-gate sctp_ipif_hash_remove(sctp, sctp_ipif); 12347c478bd9Sstevel@tonic-gate } 1235f551bb10Svi if (sctp->sctp_bound_to_all == 1) 12367c478bd9Sstevel@tonic-gate sctp->sctp_bound_to_all = 0; 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate if (!fanout_locked) { 12397c478bd9Sstevel@tonic-gate if (sctp->sctp_conn_tfp != NULL) 12407c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 12417c478bd9Sstevel@tonic-gate if (sctp->sctp_listen_tfp != NULL) 12427c478bd9Sstevel@tonic-gate mutex_exit(&sctp->sctp_listen_tfp->tf_lock); 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate /* 12477c478bd9Sstevel@tonic-gate * Given an address get the corresponding entry from the list 12487c478bd9Sstevel@tonic-gate * Called with no locks held. 12497c478bd9Sstevel@tonic-gate */ 12507c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t * 12511d8c4025Svi sctp_saddr_lookup(sctp_t *sctp, in6_addr_t *addr, uint_t ifindex) 12527c478bd9Sstevel@tonic-gate { 1253*e35d2278Svi int cnt; 1254*e35d2278Svi sctp_saddr_ipif_t *ipif_obj; 1255*e35d2278Svi int hindex; 12567c478bd9Sstevel@tonic-gate sctp_ipif_t *sctp_ipif; 12577c478bd9Sstevel@tonic-gate 1258*e35d2278Svi hindex = SCTP_IPIF_ADDR_HASH(*addr, !IN6_IS_ADDR_V4MAPPED(addr)); 1259*e35d2278Svi if (sctp->sctp_saddrs[hindex].ipif_count == 0) 12607c478bd9Sstevel@tonic-gate return (NULL); 12617c478bd9Sstevel@tonic-gate 1262*e35d2278Svi ipif_obj = list_head(&sctp->sctp_saddrs[hindex].sctp_ipif_list); 1263*e35d2278Svi for (cnt = 0; cnt < sctp->sctp_saddrs[hindex].ipif_count; cnt++) { 1264*e35d2278Svi sctp_ipif = ipif_obj->saddr_ipifp; 1265*e35d2278Svi /* 1266*e35d2278Svi * Zone check shouldn't be needed. 1267*e35d2278Svi */ 1268*e35d2278Svi if (IN6_ARE_ADDR_EQUAL(addr, &sctp_ipif->sctp_ipif_saddr) && 1269*e35d2278Svi (ifindex == 0 || 1270*e35d2278Svi ifindex == sctp_ipif->sctp_ipif_ill->sctp_ill_index) && 1271*e35d2278Svi SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state)) { 1272*e35d2278Svi return (ipif_obj); 1273*e35d2278Svi } 1274*e35d2278Svi ipif_obj = list_next(&sctp->sctp_saddrs[hindex].sctp_ipif_list, 1275*e35d2278Svi ipif_obj); 1276*e35d2278Svi } 1277*e35d2278Svi return (NULL); 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate 1280f551bb10Svi /* Given an address, add it to the source address list */ 1281f551bb10Svi int 12821d8c4025Svi sctp_saddr_add_addr(sctp_t *sctp, in6_addr_t *addr, uint_t ifindex) 1283f551bb10Svi { 1284f551bb10Svi sctp_ipif_t *sctp_ipif; 1285f551bb10Svi 1286*e35d2278Svi sctp_ipif = sctp_lookup_ipif_addr(addr, B_TRUE, sctp->sctp_zoneid, 1287*e35d2278Svi !sctp->sctp_connp->conn_allzones, ifindex, 0, B_TRUE, 1288*e35d2278Svi sctp->sctp_sctps); 1289f551bb10Svi if (sctp_ipif == NULL) 1290f551bb10Svi return (EINVAL); 1291f551bb10Svi 1292*e35d2278Svi if (sctp_ipif_hash_insert(sctp, sctp_ipif, KM_NOSLEEP, B_FALSE, 1293*e35d2278Svi B_FALSE) != 0) { 1294f551bb10Svi SCTP_IPIF_REFRELE(sctp_ipif); 1295f551bb10Svi return (EINVAL); 1296f551bb10Svi } 1297f551bb10Svi return (0); 1298f551bb10Svi } 1299f551bb10Svi 1300f551bb10Svi /* 1301f551bb10Svi * Remove or mark as dontsrc addresses that are currently not part of the 1302f551bb10Svi * association. One would delete addresses when processing an INIT and 1303f551bb10Svi * mark as dontsrc when processing an INIT-ACK. 1304f551bb10Svi */ 1305f551bb10Svi void 1306f551bb10Svi sctp_check_saddr(sctp_t *sctp, int supp_af, boolean_t delete) 1307f551bb10Svi { 1308f551bb10Svi int i; 1309f551bb10Svi int l; 1310f551bb10Svi sctp_saddr_ipif_t *obj; 1311f551bb10Svi int scanned = 0; 1312f551bb10Svi int naddr; 1313f551bb10Svi int nsaddr; 1314f551bb10Svi 1315f551bb10Svi ASSERT(!sctp->sctp_loopback && !sctp->sctp_linklocal && supp_af != 0); 1316f551bb10Svi 1317f551bb10Svi /* 1318f551bb10Svi * Irregardless of the supported address in the INIT, v4 1319f551bb10Svi * must be supported. 1320f551bb10Svi */ 1321f551bb10Svi if (sctp->sctp_family == AF_INET) 1322f551bb10Svi supp_af = PARM_SUPP_V4; 1323f551bb10Svi 1324f551bb10Svi nsaddr = sctp->sctp_nsaddrs; 1325f551bb10Svi for (i = 0; i < SCTP_IPIF_HASH; i++) { 1326f551bb10Svi if (sctp->sctp_saddrs[i].ipif_count == 0) 1327f551bb10Svi continue; 1328f551bb10Svi obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 1329f551bb10Svi naddr = sctp->sctp_saddrs[i].ipif_count; 1330f551bb10Svi for (l = 0; l < naddr; l++) { 1331f551bb10Svi sctp_ipif_t *ipif; 1332f551bb10Svi 1333f551bb10Svi ipif = obj->saddr_ipifp; 1334f551bb10Svi scanned++; 1335f551bb10Svi 1336f551bb10Svi /* 1337f551bb10Svi * Delete/mark dontsrc loopback/linklocal addresses and 1338f551bb10Svi * unsupported address. 13391d8c4025Svi * On a clustered node, we trust the clustering module 13401d8c4025Svi * to do the right thing w.r.t loopback addresses, so 13411d8c4025Svi * we ignore loopback addresses in this check. 1342f551bb10Svi */ 13431d8c4025Svi if ((SCTP_IS_IPIF_LOOPBACK(ipif) && 13441d8c4025Svi cl_sctp_check_addrs == NULL) || 13451d8c4025Svi SCTP_IS_IPIF_LINKLOCAL(ipif) || 1346f551bb10Svi SCTP_UNSUPP_AF(ipif, supp_af)) { 1347f551bb10Svi if (!delete) { 1348f551bb10Svi obj->saddr_ipif_unconfirmed = 1; 1349f551bb10Svi goto next_obj; 1350f551bb10Svi } 1351f551bb10Svi if (sctp->sctp_bound_to_all == 1) 1352f551bb10Svi sctp->sctp_bound_to_all = 0; 1353f551bb10Svi if (scanned < nsaddr) { 1354f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i]. 1355f551bb10Svi sctp_ipif_list, obj); 1356f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1357f551bb10Svi continue; 1358f551bb10Svi } 1359f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1360f551bb10Svi } 1361f551bb10Svi next_obj: 1362f551bb10Svi if (scanned >= nsaddr) 1363f551bb10Svi return; 1364f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 1365f551bb10Svi obj); 1366f551bb10Svi } 1367f551bb10Svi } 1368f551bb10Svi } 1369f551bb10Svi 1370f551bb10Svi 13717c478bd9Sstevel@tonic-gate /* Get the first valid address from the list. Called with no locks held */ 13727c478bd9Sstevel@tonic-gate in6_addr_t 13737c478bd9Sstevel@tonic-gate sctp_get_valid_addr(sctp_t *sctp, boolean_t isv6) 13747c478bd9Sstevel@tonic-gate { 13757c478bd9Sstevel@tonic-gate int i; 13767c478bd9Sstevel@tonic-gate int l; 13777c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 13787c478bd9Sstevel@tonic-gate int scanned = 0; 13797c478bd9Sstevel@tonic-gate in6_addr_t addr; 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 13827c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 13837c478bd9Sstevel@tonic-gate continue; 13847c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 13857c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 13867c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate ipif = obj->saddr_ipifp; 1389f551bb10Svi if (!SCTP_DONT_SRC(obj) && 13907c478bd9Sstevel@tonic-gate ipif->sctp_ipif_isv6 == isv6 && 1391f551bb10Svi ipif->sctp_ipif_state == SCTP_IPIFS_UP) { 13927c478bd9Sstevel@tonic-gate return (ipif->sctp_ipif_saddr); 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate scanned++; 13957c478bd9Sstevel@tonic-gate if (scanned >= sctp->sctp_nsaddrs) 13967c478bd9Sstevel@tonic-gate goto got_none; 13977c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 13987c478bd9Sstevel@tonic-gate obj); 13997c478bd9Sstevel@tonic-gate } 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate got_none: 14027c478bd9Sstevel@tonic-gate /* Need to double check this */ 14037c478bd9Sstevel@tonic-gate if (isv6 == B_TRUE) 14047c478bd9Sstevel@tonic-gate addr = ipv6_all_zeros; 14057c478bd9Sstevel@tonic-gate else 14067c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(0, &addr); 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate return (addr); 14097c478bd9Sstevel@tonic-gate } 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate /* 14127c478bd9Sstevel@tonic-gate * Return the list of local addresses of an association. The parameter 14137c478bd9Sstevel@tonic-gate * myaddrs is supposed to be either (struct sockaddr_in *) or (struct 14147c478bd9Sstevel@tonic-gate * sockaddr_in6 *) depending on the address family. 14157c478bd9Sstevel@tonic-gate */ 14167c478bd9Sstevel@tonic-gate int 14177c478bd9Sstevel@tonic-gate sctp_getmyaddrs(void *conn, void *myaddrs, int *addrcnt) 14187c478bd9Sstevel@tonic-gate { 14197c478bd9Sstevel@tonic-gate int i; 14207c478bd9Sstevel@tonic-gate int l; 14217c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 14227c478bd9Sstevel@tonic-gate sctp_t *sctp = (sctp_t *)conn; 14237c478bd9Sstevel@tonic-gate int family = sctp->sctp_family; 14247c478bd9Sstevel@tonic-gate int max = *addrcnt; 14257c478bd9Sstevel@tonic-gate size_t added = 0; 14267c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 14277c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 14287c478bd9Sstevel@tonic-gate int scanned = 0; 14297c478bd9Sstevel@tonic-gate boolean_t skip_lback = B_FALSE; 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate if (sctp->sctp_nsaddrs == 0) 14327c478bd9Sstevel@tonic-gate return (EINVAL); 14337c478bd9Sstevel@tonic-gate 14341d8c4025Svi /* 14351d8c4025Svi * Skip loopback addresses for non-loopback assoc., ignore 14361d8c4025Svi * this on a clustered node. 14371d8c4025Svi */ 14381d8c4025Svi if (sctp->sctp_state >= SCTPS_ESTABLISHED && !sctp->sctp_loopback && 14391d8c4025Svi (cl_sctp_check_addrs == NULL)) { 14407c478bd9Sstevel@tonic-gate skip_lback = B_TRUE; 14411d8c4025Svi } 14421d8c4025Svi 14437c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 14447c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 14457c478bd9Sstevel@tonic-gate continue; 14467c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 14477c478bd9Sstevel@tonic-gate for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) { 14487c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif = obj->saddr_ipifp; 14497c478bd9Sstevel@tonic-gate in6_addr_t addr = ipif->sctp_ipif_saddr; 14507c478bd9Sstevel@tonic-gate 14517c478bd9Sstevel@tonic-gate scanned++; 14527c478bd9Sstevel@tonic-gate if ((ipif->sctp_ipif_state == SCTP_IPIFS_CONDEMNED) || 1453f551bb10Svi SCTP_DONT_SRC(obj) || 14541d8c4025Svi (SCTP_IS_IPIF_LOOPBACK(ipif) && skip_lback)) { 14557c478bd9Sstevel@tonic-gate if (scanned >= sctp->sctp_nsaddrs) 14567c478bd9Sstevel@tonic-gate goto done; 14577c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i]. 14587c478bd9Sstevel@tonic-gate sctp_ipif_list, obj); 14597c478bd9Sstevel@tonic-gate continue; 14607c478bd9Sstevel@tonic-gate } 14617c478bd9Sstevel@tonic-gate switch (family) { 14627c478bd9Sstevel@tonic-gate case AF_INET: 14637c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)myaddrs + added; 14647c478bd9Sstevel@tonic-gate sin4->sin_family = AF_INET; 14657c478bd9Sstevel@tonic-gate sin4->sin_port = sctp->sctp_lport; 14667c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_INADDR(&addr, &sin4->sin_addr); 14677c478bd9Sstevel@tonic-gate break; 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate case AF_INET6: 14707c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)myaddrs + added; 14717c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 14727c478bd9Sstevel@tonic-gate sin6->sin6_port = sctp->sctp_lport; 14737c478bd9Sstevel@tonic-gate sin6->sin6_addr = addr; 14747c478bd9Sstevel@tonic-gate break; 14757c478bd9Sstevel@tonic-gate } 14767c478bd9Sstevel@tonic-gate added++; 14777c478bd9Sstevel@tonic-gate if (added >= max || scanned >= sctp->sctp_nsaddrs) 14787c478bd9Sstevel@tonic-gate goto done; 14797c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 14807c478bd9Sstevel@tonic-gate obj); 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate done: 14847c478bd9Sstevel@tonic-gate *addrcnt = added; 14857c478bd9Sstevel@tonic-gate return (0); 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate /* 1489df19b344Svi * Given the supported address family, walk through the source address list 1490df19b344Svi * and return the total length of the available addresses. If 'p' is not 1491df19b344Svi * null, construct the parameter list for the addresses in 'p'. 1492f551bb10Svi * 'modify' will only be set when we want the source address list to 1493f551bb10Svi * be modified. The source address list will be modified only when 1494f551bb10Svi * generating an INIT chunk. For generating an INIT-ACK 'modify' will 1495f551bb10Svi * be false since the 'sctp' will be that of the listener. 14967c478bd9Sstevel@tonic-gate */ 14977c478bd9Sstevel@tonic-gate size_t 1498f551bb10Svi sctp_saddr_info(sctp_t *sctp, int supp_af, uchar_t *p, boolean_t modify) 14997c478bd9Sstevel@tonic-gate { 15007c478bd9Sstevel@tonic-gate int i; 15017c478bd9Sstevel@tonic-gate int l; 15027c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *obj; 1503df19b344Svi size_t paramlen = 0; 15047c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *hdr; 15057c478bd9Sstevel@tonic-gate int scanned = 0; 1506f551bb10Svi int naddr; 1507f551bb10Svi int nsaddr; 15081d8c4025Svi boolean_t del_ll = B_FALSE; 15091d8c4025Svi boolean_t del_lb = B_FALSE; 15101d8c4025Svi 15111d8c4025Svi 15121d8c4025Svi /* 15131d8c4025Svi * On a clustered node don't bother changing anything 15141d8c4025Svi * on the loopback interface. 15151d8c4025Svi */ 15161d8c4025Svi if (modify && !sctp->sctp_loopback && (cl_sctp_check_addrs == NULL)) 15171d8c4025Svi del_lb = B_TRUE; 1518f551bb10Svi 15191d8c4025Svi if (modify && !sctp->sctp_linklocal) 15201d8c4025Svi del_ll = B_TRUE; 15217c478bd9Sstevel@tonic-gate 1522f551bb10Svi nsaddr = sctp->sctp_nsaddrs; 15237c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 15247c478bd9Sstevel@tonic-gate if (sctp->sctp_saddrs[i].ipif_count == 0) 15257c478bd9Sstevel@tonic-gate continue; 15267c478bd9Sstevel@tonic-gate obj = list_head(&sctp->sctp_saddrs[i].sctp_ipif_list); 1527f551bb10Svi naddr = sctp->sctp_saddrs[i].ipif_count; 1528f551bb10Svi for (l = 0; l < naddr; l++) { 15297c478bd9Sstevel@tonic-gate in6_addr_t addr; 15307c478bd9Sstevel@tonic-gate sctp_ipif_t *ipif; 15311d8c4025Svi boolean_t ipif_lb; 15321d8c4025Svi boolean_t ipif_ll; 1533f551bb10Svi boolean_t unsupp_af; 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate ipif = obj->saddr_ipifp; 15367c478bd9Sstevel@tonic-gate scanned++; 1537f551bb10Svi 15381d8c4025Svi ipif_lb = SCTP_IS_IPIF_LOOPBACK(ipif); 15391d8c4025Svi ipif_ll = SCTP_IS_IPIF_LINKLOCAL(ipif); 1540f551bb10Svi unsupp_af = SCTP_UNSUPP_AF(ipif, supp_af); 1541f551bb10Svi /* 1542f551bb10Svi * We need to either delete or skip loopback/linklocal 15431d8c4025Svi * or unsupported addresses, if required. 1544f551bb10Svi */ 15451d8c4025Svi if ((ipif_ll && del_ll) || (ipif_lb && del_lb) || 15461d8c4025Svi (unsupp_af && modify)) { 1547f551bb10Svi if (sctp->sctp_bound_to_all == 1) 1548f551bb10Svi sctp->sctp_bound_to_all = 0; 1549f551bb10Svi if (scanned < nsaddr) { 1550f551bb10Svi obj = list_next(&sctp->sctp_saddrs[i]. 1551f551bb10Svi sctp_ipif_list, obj); 1552f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1553f551bb10Svi continue; 1554f551bb10Svi } 1555f551bb10Svi sctp_ipif_hash_remove(sctp, ipif); 1556f551bb10Svi goto next_addr; 15571d8c4025Svi } else if (ipif_ll || unsupp_af || 15581d8c4025Svi (ipif_lb && (cl_sctp_check_addrs == NULL))) { 1559df19b344Svi goto next_addr; 15607c478bd9Sstevel@tonic-gate } 1561f551bb10Svi 1562f551bb10Svi if (!SCTP_IPIF_USABLE(ipif->sctp_ipif_state)) 1563f551bb10Svi goto next_addr; 1564df19b344Svi if (p != NULL) 1565df19b344Svi hdr = (sctp_parm_hdr_t *)(p + paramlen); 15667c478bd9Sstevel@tonic-gate addr = ipif->sctp_ipif_saddr; 1567f551bb10Svi if (!ipif->sctp_ipif_isv6) { 15687c478bd9Sstevel@tonic-gate struct in_addr *v4; 15697c478bd9Sstevel@tonic-gate 1570df19b344Svi if (p != NULL) { 1571df19b344Svi hdr->sph_type = htons(PARM_ADDR4); 1572df19b344Svi hdr->sph_len = htons(PARM_ADDR4_LEN); 1573df19b344Svi v4 = (struct in_addr *)(hdr + 1); 1574df19b344Svi IN6_V4MAPPED_TO_INADDR(&addr, v4); 1575df19b344Svi } 1576df19b344Svi paramlen += PARM_ADDR4_LEN; 1577f551bb10Svi } else { 1578df19b344Svi if (p != NULL) { 1579df19b344Svi hdr->sph_type = htons(PARM_ADDR6); 1580df19b344Svi hdr->sph_len = htons(PARM_ADDR6_LEN); 1581df19b344Svi bcopy(&addr, hdr + 1, sizeof (addr)); 1582df19b344Svi } 1583df19b344Svi paramlen += PARM_ADDR6_LEN; 15847c478bd9Sstevel@tonic-gate } 1585df19b344Svi next_addr: 1586f551bb10Svi if (scanned >= nsaddr) 1587df19b344Svi return (paramlen); 15887c478bd9Sstevel@tonic-gate obj = list_next(&sctp->sctp_saddrs[i].sctp_ipif_list, 15897c478bd9Sstevel@tonic-gate obj); 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate } 1592df19b344Svi return (paramlen); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15951d8c4025Svi /* 15961d8c4025Svi * This is used on a clustered node to obtain a list of addresses, the list 15971d8c4025Svi * consists of sockaddr_in structs for v4 and sockaddr_in6 for v6. The list 15981d8c4025Svi * is then passed onto the clustering module which sends back the correct 15991d8c4025Svi * list based on the port info. Regardless of the input, i.e INADDR_ANY 16001d8c4025Svi * or specific address(es), we create the list since it could be modified by 16011d8c4025Svi * the clustering module. When given a list of addresses, we simply 16021d8c4025Svi * create the list of sockaddr_in or sockaddr_in6 structs using those 16031d8c4025Svi * addresses. If there is an INADDR_ANY in the input list, or if the 16041d8c4025Svi * input is INADDR_ANY, we create a list of sockaddr_in or sockaddr_in6 16051d8c4025Svi * structs consisting all the addresses in the global interface list 16061d8c4025Svi * except those that are hosted on the loopback interface. We create 16071d8c4025Svi * a list of sockaddr_in[6] structs just so that it can be directly input 16081d8c4025Svi * to sctp_valid_addr_list() once the clustering module has processed it. 16091d8c4025Svi */ 16101d8c4025Svi int 16111d8c4025Svi sctp_get_addrlist(sctp_t *sctp, const void *addrs, uint32_t *addrcnt, 16121d8c4025Svi uchar_t **addrlist, int *uspec, size_t *size) 16131d8c4025Svi { 16141d8c4025Svi int cnt; 16151d8c4025Svi int icnt; 16161d8c4025Svi sctp_ipif_t *sctp_ipif; 16171d8c4025Svi struct sockaddr_in *s4; 16181d8c4025Svi struct sockaddr_in6 *s6; 16191d8c4025Svi uchar_t *p; 16201d8c4025Svi int err = 0; 1621f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 16221d8c4025Svi 16231d8c4025Svi *addrlist = NULL; 16241d8c4025Svi *size = 0; 16251d8c4025Svi 16261d8c4025Svi /* 16271d8c4025Svi * Create a list of sockaddr_in[6] structs using the input list. 16281d8c4025Svi */ 16291d8c4025Svi if (sctp->sctp_family == AF_INET) { 16301d8c4025Svi *size = sizeof (struct sockaddr_in) * *addrcnt; 16311d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 16321d8c4025Svi p = *addrlist; 16331d8c4025Svi for (cnt = 0; cnt < *addrcnt; cnt++) { 16341d8c4025Svi s4 = (struct sockaddr_in *)addrs + cnt; 16351d8c4025Svi /* 16361d8c4025Svi * We need to create a list of all the available 16371d8c4025Svi * addresses if there is an INADDR_ANY. However, 16381d8c4025Svi * if we are beyond LISTEN, then this is invalid 16391d8c4025Svi * (see sctp_valid_addr_list(). So, we just fail 16401d8c4025Svi * it here rather than wait till it fails in 16411d8c4025Svi * sctp_valid_addr_list(). 16421d8c4025Svi */ 16431d8c4025Svi if (s4->sin_addr.s_addr == INADDR_ANY) { 16441d8c4025Svi kmem_free(*addrlist, *size); 16451d8c4025Svi *addrlist = NULL; 16461d8c4025Svi *size = 0; 16471d8c4025Svi if (sctp->sctp_state > SCTPS_LISTEN) { 16481d8c4025Svi *addrcnt = 0; 16491d8c4025Svi return (EINVAL); 16501d8c4025Svi } 16511d8c4025Svi if (uspec != NULL) 16521d8c4025Svi *uspec = 1; 16531d8c4025Svi goto get_all_addrs; 16541d8c4025Svi } else { 16551d8c4025Svi bcopy(s4, p, sizeof (*s4)); 16561d8c4025Svi p += sizeof (*s4); 16571d8c4025Svi } 16581d8c4025Svi } 16591d8c4025Svi } else { 16601d8c4025Svi *size = sizeof (struct sockaddr_in6) * *addrcnt; 16611d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 16621d8c4025Svi p = *addrlist; 16631d8c4025Svi for (cnt = 0; cnt < *addrcnt; cnt++) { 16641d8c4025Svi s6 = (struct sockaddr_in6 *)addrs + cnt; 16651d8c4025Svi /* 16661d8c4025Svi * Comments for INADDR_ANY, above, apply here too. 16671d8c4025Svi */ 16681d8c4025Svi if (IN6_IS_ADDR_UNSPECIFIED(&s6->sin6_addr)) { 16691d8c4025Svi kmem_free(*addrlist, *size); 16701d8c4025Svi *size = 0; 16711d8c4025Svi *addrlist = NULL; 16721d8c4025Svi if (sctp->sctp_state > SCTPS_LISTEN) { 16731d8c4025Svi *addrcnt = 0; 16741d8c4025Svi return (EINVAL); 16751d8c4025Svi } 16761d8c4025Svi if (uspec != NULL) 16771d8c4025Svi *uspec = 1; 16781d8c4025Svi goto get_all_addrs; 16791d8c4025Svi } else { 16801d8c4025Svi bcopy(addrs, p, sizeof (*s6)); 16811d8c4025Svi p += sizeof (*s6); 16821d8c4025Svi } 16831d8c4025Svi } 16841d8c4025Svi } 16851d8c4025Svi return (err); 16861d8c4025Svi get_all_addrs: 16871d8c4025Svi 16881d8c4025Svi /* 16891d8c4025Svi * Allocate max possible size. We allocate the max. size here because 16901d8c4025Svi * the clustering module could end up adding addresses to the list. 16911d8c4025Svi * We allocate upfront so that the clustering module need to bother 16921d8c4025Svi * re-sizing the list. 16931d8c4025Svi */ 1694f4b3ec61Sdh if (sctp->sctp_family == AF_INET) { 1695f4b3ec61Sdh *size = sizeof (struct sockaddr_in) * 1696f4b3ec61Sdh sctps->sctps_g_ipifs_count; 1697f4b3ec61Sdh } else { 1698f4b3ec61Sdh *size = sizeof (struct sockaddr_in6) * 1699f4b3ec61Sdh sctps->sctps_g_ipifs_count; 1700f4b3ec61Sdh } 17011d8c4025Svi *addrlist = kmem_zalloc(*size, KM_SLEEP); 17021d8c4025Svi *addrcnt = 0; 17031d8c4025Svi p = *addrlist; 1704f4b3ec61Sdh rw_enter(&sctps->sctps_g_ipifs_lock, RW_READER); 17051d8c4025Svi 17061d8c4025Svi /* 17071d8c4025Svi * Walk through the global interface list and add all addresses, 17081d8c4025Svi * except those that are hosted on loopback interfaces. 17091d8c4025Svi */ 17101d8c4025Svi for (cnt = 0; cnt < SCTP_IPIF_HASH; cnt++) { 1711f4b3ec61Sdh if (sctps->sctps_g_ipifs[cnt].ipif_count == 0) 17121d8c4025Svi continue; 1713f4b3ec61Sdh sctp_ipif = list_head( 1714f4b3ec61Sdh &sctps->sctps_g_ipifs[cnt].sctp_ipif_list); 1715f4b3ec61Sdh for (icnt = 0; 1716f4b3ec61Sdh icnt < sctps->sctps_g_ipifs[cnt].ipif_count; 1717f4b3ec61Sdh icnt++) { 17181d8c4025Svi in6_addr_t addr; 17191d8c4025Svi 17201d8c4025Svi rw_enter(&sctp_ipif->sctp_ipif_lock, RW_READER); 17211d8c4025Svi addr = sctp_ipif->sctp_ipif_saddr; 17221d8c4025Svi if (SCTP_IPIF_DISCARD(sctp_ipif->sctp_ipif_flags) || 17231d8c4025Svi !SCTP_IPIF_USABLE(sctp_ipif->sctp_ipif_state) || 17241d8c4025Svi SCTP_IS_IPIF_LOOPBACK(sctp_ipif) || 17251d8c4025Svi SCTP_IS_IPIF_LINKLOCAL(sctp_ipif) || 17265d0bc3edSsommerfe !SCTP_IPIF_ZONE_MATCH(sctp, sctp_ipif) || 17271d8c4025Svi (sctp->sctp_ipversion == IPV4_VERSION && 17281d8c4025Svi sctp_ipif->sctp_ipif_isv6) || 17291d8c4025Svi (sctp->sctp_connp->conn_ipv6_v6only && 17301d8c4025Svi !sctp_ipif->sctp_ipif_isv6)) { 17311d8c4025Svi rw_exit(&sctp_ipif->sctp_ipif_lock); 17321d8c4025Svi sctp_ipif = list_next( 1733f4b3ec61Sdh &sctps->sctps_g_ipifs[cnt].sctp_ipif_list, 17341d8c4025Svi sctp_ipif); 17351d8c4025Svi continue; 17361d8c4025Svi } 17371d8c4025Svi rw_exit(&sctp_ipif->sctp_ipif_lock); 17381d8c4025Svi if (sctp->sctp_family == AF_INET) { 17391d8c4025Svi s4 = (struct sockaddr_in *)p; 17401d8c4025Svi IN6_V4MAPPED_TO_INADDR(&addr, &s4->sin_addr); 17411d8c4025Svi s4->sin_family = AF_INET; 17421d8c4025Svi p += sizeof (*s4); 17431d8c4025Svi } else { 17441d8c4025Svi s6 = (struct sockaddr_in6 *)p; 17451d8c4025Svi s6->sin6_addr = addr; 17461d8c4025Svi s6->sin6_family = AF_INET6; 17471d8c4025Svi s6->sin6_scope_id = 17481d8c4025Svi sctp_ipif->sctp_ipif_ill->sctp_ill_index; 17491d8c4025Svi p += sizeof (*s6); 17501d8c4025Svi } 17511d8c4025Svi (*addrcnt)++; 1752f4b3ec61Sdh sctp_ipif = list_next( 1753f4b3ec61Sdh &sctps->sctps_g_ipifs[cnt].sctp_ipif_list, 17541d8c4025Svi sctp_ipif); 17551d8c4025Svi } 17561d8c4025Svi } 1757f4b3ec61Sdh rw_exit(&sctps->sctps_g_ipifs_lock); 17581d8c4025Svi return (err); 17591d8c4025Svi } 17601d8c4025Svi 17611d8c4025Svi /* 17621d8c4025Svi * Get a list of addresses from the source address list. The caller is 17631d8c4025Svi * responsible for allocating sufficient buffer for this. 17641d8c4025Svi */ 17651d8c4025Svi void 17661d8c4025Svi sctp_get_saddr_list(sctp_t *sctp, uchar_t *p, size_t psize) 17671d8c4025Svi { 17681d8c4025Svi int cnt; 17691d8c4025Svi int icnt; 17701d8c4025Svi sctp_saddr_ipif_t *obj; 17711d8c4025Svi int naddr; 17721d8c4025Svi int scanned = 0; 17731d8c4025Svi 17741d8c4025Svi for (cnt = 0; cnt < SCTP_IPIF_HASH; cnt++) { 17751d8c4025Svi if (sctp->sctp_saddrs[cnt].ipif_count == 0) 17761d8c4025Svi continue; 17771d8c4025Svi obj = list_head(&sctp->sctp_saddrs[cnt].sctp_ipif_list); 17781d8c4025Svi naddr = sctp->sctp_saddrs[cnt].ipif_count; 17791d8c4025Svi for (icnt = 0; icnt < naddr; icnt++) { 17801d8c4025Svi sctp_ipif_t *ipif; 17811d8c4025Svi 17821d8c4025Svi if (psize < sizeof (ipif->sctp_ipif_saddr)) 17831d8c4025Svi return; 17841d8c4025Svi 17851d8c4025Svi scanned++; 17861d8c4025Svi ipif = obj->saddr_ipifp; 17871d8c4025Svi bcopy(&ipif->sctp_ipif_saddr, p, 17881d8c4025Svi sizeof (ipif->sctp_ipif_saddr)); 17891d8c4025Svi p += sizeof (ipif->sctp_ipif_saddr); 17901d8c4025Svi psize -= sizeof (ipif->sctp_ipif_saddr); 17911d8c4025Svi if (scanned >= sctp->sctp_nsaddrs) 17921d8c4025Svi return; 1793f4b3ec61Sdh obj = list_next( 1794f4b3ec61Sdh &sctp->sctp_saddrs[icnt].sctp_ipif_list, 17951d8c4025Svi obj); 17961d8c4025Svi } 17971d8c4025Svi } 17981d8c4025Svi } 17991d8c4025Svi 18001d8c4025Svi /* 18011d8c4025Svi * Get a list of addresses from the remote address list. The caller is 18021d8c4025Svi * responsible for allocating sufficient buffer for this. 18031d8c4025Svi */ 18041d8c4025Svi void 18051d8c4025Svi sctp_get_faddr_list(sctp_t *sctp, uchar_t *p, size_t psize) 18061d8c4025Svi { 18071d8c4025Svi sctp_faddr_t *fp; 18081d8c4025Svi 18091d8c4025Svi for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->next) { 18101d8c4025Svi if (psize < sizeof (fp->faddr)) 18111d8c4025Svi return; 18121d8c4025Svi bcopy(&fp->faddr, p, sizeof (fp->faddr)); 18131d8c4025Svi p += sizeof (fp->faddr); 18141d8c4025Svi psize -= sizeof (fp->faddr); 18151d8c4025Svi } 18161d8c4025Svi } 18177c478bd9Sstevel@tonic-gate 1818f4b3ec61Sdh static void 1819f4b3ec61Sdh sctp_free_ills(sctp_stack_t *sctps) 1820f4b3ec61Sdh { 1821f4b3ec61Sdh int i; 1822f4b3ec61Sdh int l; 1823f4b3ec61Sdh sctp_ill_t *sctp_ill; 1824f4b3ec61Sdh 1825f4b3ec61Sdh if (sctps->sctps_ills_count == 0) 1826f4b3ec61Sdh return; 1827f4b3ec61Sdh 1828f4b3ec61Sdh for (i = 0; i < SCTP_ILL_HASH; i++) { 1829f4b3ec61Sdh sctp_ill = list_tail(&sctps->sctps_g_ills[i].sctp_ill_list); 1830f4b3ec61Sdh for (l = 0; l < sctps->sctps_g_ills[i].ill_count; l++) { 1831f4b3ec61Sdh ASSERT(sctp_ill->sctp_ill_ipifcnt == 0); 1832f4b3ec61Sdh list_remove(&sctps->sctps_g_ills[i].sctp_ill_list, 1833f4b3ec61Sdh sctp_ill); 1834f4b3ec61Sdh sctps->sctps_ills_count--; 1835f4b3ec61Sdh kmem_free(sctp_ill->sctp_ill_name, 1836f4b3ec61Sdh sctp_ill->sctp_ill_name_length); 1837f4b3ec61Sdh kmem_free(sctp_ill, sizeof (sctp_ill_t)); 1838f4b3ec61Sdh sctp_ill = 1839f4b3ec61Sdh list_tail(&sctps->sctps_g_ills[i].sctp_ill_list); 1840f4b3ec61Sdh } 1841f4b3ec61Sdh sctps->sctps_g_ills[i].ill_count = 0; 1842f4b3ec61Sdh } 1843f4b3ec61Sdh ASSERT(sctps->sctps_ills_count == 0); 1844f4b3ec61Sdh } 1845f4b3ec61Sdh 1846f4b3ec61Sdh static void 1847f4b3ec61Sdh sctp_free_ipifs(sctp_stack_t *sctps) 1848f4b3ec61Sdh { 1849f4b3ec61Sdh int i; 1850f4b3ec61Sdh int l; 1851f4b3ec61Sdh sctp_ipif_t *sctp_ipif; 1852f4b3ec61Sdh sctp_ill_t *sctp_ill; 1853f4b3ec61Sdh 1854f4b3ec61Sdh if (sctps->sctps_g_ipifs_count == 0) 1855f4b3ec61Sdh return; 1856f4b3ec61Sdh 1857f4b3ec61Sdh for (i = 0; i < SCTP_IPIF_HASH; i++) { 1858f4b3ec61Sdh sctp_ipif = list_tail(&sctps->sctps_g_ipifs[i].sctp_ipif_list); 1859f4b3ec61Sdh for (l = 0; l < sctps->sctps_g_ipifs[i].ipif_count; l++) { 1860f4b3ec61Sdh sctp_ill = sctp_ipif->sctp_ipif_ill; 1861f4b3ec61Sdh 1862f4b3ec61Sdh list_remove(&sctps->sctps_g_ipifs[i].sctp_ipif_list, 1863f4b3ec61Sdh sctp_ipif); 1864f4b3ec61Sdh sctps->sctps_g_ipifs_count--; 1865f4b3ec61Sdh (void) atomic_add_32_nv(&sctp_ill->sctp_ill_ipifcnt, 1866f4b3ec61Sdh -1); 1867f4b3ec61Sdh kmem_free(sctp_ipif, sizeof (sctp_ipif_t)); 1868f4b3ec61Sdh sctp_ipif = 1869f4b3ec61Sdh list_tail(&sctps->sctps_g_ipifs[i].sctp_ipif_list); 1870f4b3ec61Sdh } 1871f4b3ec61Sdh sctps->sctps_g_ipifs[i].ipif_count = 0; 1872f4b3ec61Sdh } 1873f4b3ec61Sdh ASSERT(sctps->sctps_g_ipifs_count == 0); 1874f4b3ec61Sdh } 1875f4b3ec61Sdh 1876f4b3ec61Sdh 18777c478bd9Sstevel@tonic-gate /* Initialize the SCTP ILL list and lock */ 18787c478bd9Sstevel@tonic-gate void 1879f4b3ec61Sdh sctp_saddr_init(sctp_stack_t *sctps) 18807c478bd9Sstevel@tonic-gate { 18817c478bd9Sstevel@tonic-gate int i; 18827c478bd9Sstevel@tonic-gate 1883f4b3ec61Sdh sctps->sctps_g_ills = kmem_zalloc(sizeof (sctp_ill_hash_t) * 1884f4b3ec61Sdh SCTP_ILL_HASH, KM_SLEEP); 1885f4b3ec61Sdh sctps->sctps_g_ipifs = kmem_zalloc(sizeof (sctp_ipif_hash_t) * 1886f4b3ec61Sdh SCTP_IPIF_HASH, KM_SLEEP); 1887f4b3ec61Sdh 1888f4b3ec61Sdh rw_init(&sctps->sctps_g_ills_lock, NULL, RW_DEFAULT, NULL); 1889f4b3ec61Sdh rw_init(&sctps->sctps_g_ipifs_lock, NULL, RW_DEFAULT, NULL); 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_ILL_HASH; i++) { 1892f4b3ec61Sdh sctps->sctps_g_ills[i].ill_count = 0; 1893f4b3ec61Sdh list_create(&sctps->sctps_g_ills[i].sctp_ill_list, 1894f4b3ec61Sdh sizeof (sctp_ill_t), 18957c478bd9Sstevel@tonic-gate offsetof(sctp_ill_t, sctp_ills)); 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) { 1898f4b3ec61Sdh sctps->sctps_g_ipifs[i].ipif_count = 0; 1899f4b3ec61Sdh list_create(&sctps->sctps_g_ipifs[i].sctp_ipif_list, 19007c478bd9Sstevel@tonic-gate sizeof (sctp_ipif_t), offsetof(sctp_ipif_t, sctp_ipifs)); 19017c478bd9Sstevel@tonic-gate } 19027c478bd9Sstevel@tonic-gate } 19037c478bd9Sstevel@tonic-gate 19047c478bd9Sstevel@tonic-gate void 1905f4b3ec61Sdh sctp_saddr_fini(sctp_stack_t *sctps) 19067c478bd9Sstevel@tonic-gate { 19077c478bd9Sstevel@tonic-gate int i; 19087c478bd9Sstevel@tonic-gate 1909f4b3ec61Sdh sctp_free_ipifs(sctps); 1910f4b3ec61Sdh sctp_free_ills(sctps); 1911f4b3ec61Sdh 19127c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_ILL_HASH; i++) 1913f4b3ec61Sdh list_destroy(&sctps->sctps_g_ills[i].sctp_ill_list); 19147c478bd9Sstevel@tonic-gate for (i = 0; i < SCTP_IPIF_HASH; i++) 1915f4b3ec61Sdh list_destroy(&sctps->sctps_g_ipifs[i].sctp_ipif_list); 1916f4b3ec61Sdh 1917f4b3ec61Sdh ASSERT(sctps->sctps_ills_count == 0 && sctps->sctps_g_ipifs_count == 0); 1918f4b3ec61Sdh kmem_free(sctps->sctps_g_ills, sizeof (sctp_ill_hash_t) * 1919f4b3ec61Sdh SCTP_ILL_HASH); 1920f4b3ec61Sdh sctps->sctps_g_ills = NULL; 1921f4b3ec61Sdh kmem_free(sctps->sctps_g_ipifs, sizeof (sctp_ipif_hash_t) * 1922f4b3ec61Sdh SCTP_IPIF_HASH); 1923f4b3ec61Sdh sctps->sctps_g_ipifs = NULL; 1924f4b3ec61Sdh rw_destroy(&sctps->sctps_g_ills_lock); 1925f4b3ec61Sdh rw_destroy(&sctps->sctps_g_ipifs_lock); 19267c478bd9Sstevel@tonic-gate } 1927