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 */ 21*77c67f2fSkcpoon 227c478bd9Sstevel@tonic-gate /* 2345916cd2Sjpk * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/types.h> 307c478bd9Sstevel@tonic-gate #include <sys/systm.h> 317c478bd9Sstevel@tonic-gate #include <sys/stream.h> 327c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 337c478bd9Sstevel@tonic-gate #include <sys/socket.h> 347c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 357c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 367c478bd9Sstevel@tonic-gate #include <sys/strsun.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/mib2.h> 467c478bd9Sstevel@tonic-gate #include "sctp_impl.h" 477c478bd9Sstevel@tonic-gate #include "sctp_asconf.h" 487c478bd9Sstevel@tonic-gate #include "sctp_addr.h" 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate typedef struct sctp_asconf_s { 511d8c4025Svi mblk_t *head; 521d8c4025Svi uint32_t cid; 537c478bd9Sstevel@tonic-gate } sctp_asconf_t; 547c478bd9Sstevel@tonic-gate 551d8c4025Svi /* 561d8c4025Svi * This is only used on a clustered node to maintain pre-allocated buffer info. 571d8c4025Svi * before sending an ASCONF chunk. The reason for pre-allocation is we don't 581d8c4025Svi * want to fail allocating memory when we get then ASCONF-ACK in order to 591d8c4025Svi * update the clustering subsystem's state for this assoc. 601d8c4025Svi */ 611d8c4025Svi typedef struct sctp_cl_ainfo_s { 621d8c4025Svi uchar_t *sctp_cl_alist; 631d8c4025Svi size_t sctp_cl_asize; 641d8c4025Svi uchar_t *sctp_cl_dlist; 651d8c4025Svi size_t sctp_cl_dsize; 661d8c4025Svi } sctp_cl_ainfo_t; 671d8c4025Svi 687c478bd9Sstevel@tonic-gate /* 697c478bd9Sstevel@tonic-gate * The ASCONF chunk per-parameter request interface. ph is the 707c478bd9Sstevel@tonic-gate * parameter header for the parameter in the request, and cid 717c478bd9Sstevel@tonic-gate * is the parameters correlation ID. cont should be set to 1 727c478bd9Sstevel@tonic-gate * if the ASCONF framework should continue processing request 737c478bd9Sstevel@tonic-gate * parameters following this one, or 0 if it should stop. If 747c478bd9Sstevel@tonic-gate * cont is -1, this indicates complete memory depletion, which 757c478bd9Sstevel@tonic-gate * will cause the ASCONF framework to abort building a reply. If 767c478bd9Sstevel@tonic-gate * act is 1, the callback should take whatever action it needs 777c478bd9Sstevel@tonic-gate * to fulfil this request. If act is 0, this request has already 787c478bd9Sstevel@tonic-gate * been processed, so the callback should only verify and pass 797c478bd9Sstevel@tonic-gate * back error parameters, and not take any action. 807c478bd9Sstevel@tonic-gate * 817c478bd9Sstevel@tonic-gate * The callback should return an mblk with any reply enclosed, 827c478bd9Sstevel@tonic-gate * with the correlation ID in the first four bytes of the 837c478bd9Sstevel@tonic-gate * message. A NULL return implies implicit success to the 847c478bd9Sstevel@tonic-gate * requestor. 857c478bd9Sstevel@tonic-gate */ 867c478bd9Sstevel@tonic-gate typedef mblk_t *sctp_asconf_func_t(sctp_t *, sctp_parm_hdr_t *ph, uint32_t cid, 871d8c4025Svi sctp_faddr_t *, int *cont, int act, in6_addr_t *addr); 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate /* 907c478bd9Sstevel@tonic-gate * The ASCONF chunk per-parameter ACK interface. ph is the parameter 917c478bd9Sstevel@tonic-gate * header for the parameter returned in the ACK, and oph is the 927c478bd9Sstevel@tonic-gate * original parameter sent out in the ASCONF request. 937c478bd9Sstevel@tonic-gate * If the peer implicitly responded OK (by not including an 947c478bd9Sstevel@tonic-gate * explicit OK for the request), ph will be NULL. 957c478bd9Sstevel@tonic-gate * ph can also point to an Unrecognized Parameter parameter, 967c478bd9Sstevel@tonic-gate * in which case the peer did not understand the request 977c478bd9Sstevel@tonic-gate * parameter. 987c478bd9Sstevel@tonic-gate * 997c478bd9Sstevel@tonic-gate * ph and oph parameter headers are in host byte order. Encapsulated 1007c478bd9Sstevel@tonic-gate * parameters will still be in network byte order. 1017c478bd9Sstevel@tonic-gate */ 1027c478bd9Sstevel@tonic-gate typedef void sctp_asconf_ack_func_t(sctp_t *, sctp_parm_hdr_t *ph, 1031d8c4025Svi sctp_parm_hdr_t *oph, sctp_faddr_t *, in6_addr_t *addr); 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate typedef struct { 1067c478bd9Sstevel@tonic-gate uint16_t id; 1077c478bd9Sstevel@tonic-gate sctp_asconf_func_t *asconf; 1087c478bd9Sstevel@tonic-gate sctp_asconf_ack_func_t *asconf_ack; 1097c478bd9Sstevel@tonic-gate } dispatch_t; 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate static sctp_asconf_func_t sctp_addip_req, sctp_setprim_req, 1127c478bd9Sstevel@tonic-gate sctp_asconf_unrec_parm; 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate static sctp_asconf_ack_func_t sctp_addip_ack, sctp_setprim_ack, 1157c478bd9Sstevel@tonic-gate sctp_asconf_ack_unrec_parm; 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate static const dispatch_t sctp_asconf_dispatch_tbl[] = { 1187c478bd9Sstevel@tonic-gate /* ID ASCONF ASCONF_ACK */ 1197c478bd9Sstevel@tonic-gate { PARM_ADD_IP, sctp_addip_req, sctp_addip_ack }, 1207c478bd9Sstevel@tonic-gate { PARM_DEL_IP, sctp_addip_req, sctp_addip_ack }, 1217c478bd9Sstevel@tonic-gate { PARM_SET_PRIMARY, sctp_setprim_req, sctp_setprim_ack } 1227c478bd9Sstevel@tonic-gate }; 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate static const dispatch_t sctp_asconf_default_dispatch = { 1257c478bd9Sstevel@tonic-gate 0, sctp_asconf_unrec_parm, sctp_asconf_ack_unrec_parm 1267c478bd9Sstevel@tonic-gate }; 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate /* 1297c478bd9Sstevel@tonic-gate * ASCONF framework 1307c478bd9Sstevel@tonic-gate */ 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate static const dispatch_t * 1337c478bd9Sstevel@tonic-gate sctp_lookup_asconf_dispatch(int id) 1347c478bd9Sstevel@tonic-gate { 1357c478bd9Sstevel@tonic-gate int i; 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate for (i = 0; i < A_CNT(sctp_asconf_dispatch_tbl); i++) { 1387c478bd9Sstevel@tonic-gate if (sctp_asconf_dispatch_tbl[i].id == id) { 1397c478bd9Sstevel@tonic-gate return (sctp_asconf_dispatch_tbl + i); 1407c478bd9Sstevel@tonic-gate } 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate return (&sctp_asconf_default_dispatch); 1447c478bd9Sstevel@tonic-gate } 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate * Frees mp on failure 1487c478bd9Sstevel@tonic-gate */ 1497c478bd9Sstevel@tonic-gate static mblk_t * 1507c478bd9Sstevel@tonic-gate sctp_asconf_prepend_errwrap(mblk_t *mp, uint32_t cid) 1517c478bd9Sstevel@tonic-gate { 1527c478bd9Sstevel@tonic-gate mblk_t *wmp; 1537c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *wph; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* Prepend a wrapper err cause ind param */ 1567c478bd9Sstevel@tonic-gate wmp = allocb(sizeof (*wph) + sizeof (cid), BPRI_MED); 1577c478bd9Sstevel@tonic-gate if (wmp == NULL) { 1587c478bd9Sstevel@tonic-gate freemsg(mp); 1597c478bd9Sstevel@tonic-gate return (NULL); 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate wmp->b_wptr += sizeof (*wph) + sizeof (cid); 1627c478bd9Sstevel@tonic-gate wph = (sctp_parm_hdr_t *)wmp->b_rptr; 1637c478bd9Sstevel@tonic-gate wph->sph_type = htons(PARM_ERROR_IND); 1647c478bd9Sstevel@tonic-gate wph->sph_len = htons(msgdsize(mp) + sizeof (*wph) + sizeof (cid)); 1657c478bd9Sstevel@tonic-gate bcopy(&cid, wph + 1, sizeof (uint32_t)); 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate wmp->b_cont = mp; 1687c478bd9Sstevel@tonic-gate return (wmp); 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1727c478bd9Sstevel@tonic-gate static mblk_t * 1737c478bd9Sstevel@tonic-gate sctp_asconf_unrec_parm(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 1741d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *addr) 1757c478bd9Sstevel@tonic-gate { 1767c478bd9Sstevel@tonic-gate mblk_t *mp = NULL; 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate /* Unrecognized param; check the high order bits */ 1797c478bd9Sstevel@tonic-gate if ((ph->sph_type & 0xc000) == 0xc000) { 1807c478bd9Sstevel@tonic-gate /* report unrecognized param, and keep processing */ 1817c478bd9Sstevel@tonic-gate sctp_add_unrec_parm(ph, &mp); 1827c478bd9Sstevel@tonic-gate if (mp == NULL) { 1837c478bd9Sstevel@tonic-gate *cont = -1; 1847c478bd9Sstevel@tonic-gate return (NULL); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate /* Prepend a the CID and a wrapper err cause ind param */ 1877c478bd9Sstevel@tonic-gate mp = sctp_asconf_prepend_errwrap(mp, cid); 1887c478bd9Sstevel@tonic-gate if (mp == NULL) { 1897c478bd9Sstevel@tonic-gate *cont = -1; 1907c478bd9Sstevel@tonic-gate return (NULL); 1917c478bd9Sstevel@tonic-gate } 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate *cont = 1; 1947c478bd9Sstevel@tonic-gate return (mp); 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate if (ph->sph_type & 0x4000) { 1977c478bd9Sstevel@tonic-gate /* Stop processing and drop; report unrecognized param */ 1987c478bd9Sstevel@tonic-gate sctp_add_unrec_parm(ph, &mp); 1997c478bd9Sstevel@tonic-gate if (mp == NULL) { 2007c478bd9Sstevel@tonic-gate *cont = -1; 2017c478bd9Sstevel@tonic-gate return (NULL); 2027c478bd9Sstevel@tonic-gate } 2037c478bd9Sstevel@tonic-gate /* Prepend a the CID and a wrapper err cause ind param */ 2047c478bd9Sstevel@tonic-gate mp = sctp_asconf_prepend_errwrap(mp, cid); 2057c478bd9Sstevel@tonic-gate if (mp == NULL) { 2067c478bd9Sstevel@tonic-gate *cont = -1; 2077c478bd9Sstevel@tonic-gate return (NULL); 2087c478bd9Sstevel@tonic-gate } 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate *cont = 0; 2117c478bd9Sstevel@tonic-gate return (mp); 2127c478bd9Sstevel@tonic-gate } 2137c478bd9Sstevel@tonic-gate if (ph->sph_type & 0x8000) { 2147c478bd9Sstevel@tonic-gate /* skip and continue processing */ 2157c478bd9Sstevel@tonic-gate *cont = 1; 2167c478bd9Sstevel@tonic-gate return (NULL); 2177c478bd9Sstevel@tonic-gate } 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 2 high bits are clear; stop processing and drop packet */ 2207c478bd9Sstevel@tonic-gate *cont = 0; 2217c478bd9Sstevel@tonic-gate return (NULL); 2227c478bd9Sstevel@tonic-gate } 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2257c478bd9Sstevel@tonic-gate static void 2267c478bd9Sstevel@tonic-gate sctp_asconf_ack_unrec_parm(sctp_t *sctp, sctp_parm_hdr_t *ph, 2271d8c4025Svi sctp_parm_hdr_t *oph, sctp_faddr_t *fp, in6_addr_t *laddr) 2287c478bd9Sstevel@tonic-gate { 2297c478bd9Sstevel@tonic-gate ASSERT(ph); 2307c478bd9Sstevel@tonic-gate sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate static void 2347c478bd9Sstevel@tonic-gate sctp_asconf_init(sctp_asconf_t *asc) 2357c478bd9Sstevel@tonic-gate { 2367c478bd9Sstevel@tonic-gate ASSERT(asc != NULL); 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate asc->head = NULL; 2397c478bd9Sstevel@tonic-gate asc->cid = 0; 2407c478bd9Sstevel@tonic-gate } 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate static int 2437c478bd9Sstevel@tonic-gate sctp_asconf_add(sctp_asconf_t *asc, mblk_t *mp) 2447c478bd9Sstevel@tonic-gate { 2457c478bd9Sstevel@tonic-gate uint32_t *cp; 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate /* XXX can't exceed MTU */ 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate cp = (uint32_t *)(mp->b_rptr + sizeof (sctp_parm_hdr_t)); 2507c478bd9Sstevel@tonic-gate *cp = asc->cid++; 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate if (asc->head == NULL) 2537c478bd9Sstevel@tonic-gate asc->head = mp; 2547c478bd9Sstevel@tonic-gate else 2557c478bd9Sstevel@tonic-gate linkb(asc->head, mp); 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate return (0); 2587c478bd9Sstevel@tonic-gate } 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate static void 2617c478bd9Sstevel@tonic-gate sctp_asconf_destroy(sctp_asconf_t *asc) 2627c478bd9Sstevel@tonic-gate { 2637c478bd9Sstevel@tonic-gate if (asc->head != NULL) { 2647c478bd9Sstevel@tonic-gate freemsg(asc->head); 2657c478bd9Sstevel@tonic-gate asc->head = NULL; 2667c478bd9Sstevel@tonic-gate } 2677c478bd9Sstevel@tonic-gate asc->cid = 0; 2687c478bd9Sstevel@tonic-gate } 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate static int 2711d8c4025Svi sctp_asconf_send(sctp_t *sctp, sctp_asconf_t *asc, sctp_faddr_t *fp, 2721d8c4025Svi sctp_cl_ainfo_t *ainfo) 2737c478bd9Sstevel@tonic-gate { 2747c478bd9Sstevel@tonic-gate mblk_t *mp, *nmp; 2757c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *ch; 2767c478bd9Sstevel@tonic-gate boolean_t isv4; 2777c478bd9Sstevel@tonic-gate size_t msgsize; 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate ASSERT(asc != NULL && asc->head != NULL); 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate isv4 = (fp != NULL) ? fp->isv4 : sctp->sctp_current->isv4; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate /* SCTP chunk header + Serial Number + Address Param TLV */ 2847c478bd9Sstevel@tonic-gate msgsize = sizeof (*ch) + sizeof (uint32_t) + 2857c478bd9Sstevel@tonic-gate (isv4 ? PARM_ADDR4_LEN : PARM_ADDR6_LEN); 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate mp = allocb(msgsize, BPRI_MED); 2887c478bd9Sstevel@tonic-gate if (mp == NULL) 2897c478bd9Sstevel@tonic-gate return (ENOMEM); 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate mp->b_wptr += msgsize; 2927c478bd9Sstevel@tonic-gate mp->b_cont = asc->head; 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate ch = (sctp_chunk_hdr_t *)mp->b_rptr; 2957c478bd9Sstevel@tonic-gate ch->sch_id = CHUNK_ASCONF; 2967c478bd9Sstevel@tonic-gate ch->sch_flags = 0; 2977c478bd9Sstevel@tonic-gate ch->sch_len = htons(msgdsize(mp)); 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate nmp = msgpullup(mp, -1); 3007c478bd9Sstevel@tonic-gate if (nmp == NULL) { 3017c478bd9Sstevel@tonic-gate freeb(mp); 3027c478bd9Sstevel@tonic-gate return (ENOMEM); 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3051d8c4025Svi /* 3061d8c4025Svi * Stash the address list and the count so that when the operation 3071d8c4025Svi * completes, i.e. when as get an ACK, we can update the clustering's 3081d8c4025Svi * state for this association. 3091d8c4025Svi */ 3101d8c4025Svi if (ainfo != NULL) { 3111d8c4025Svi ASSERT(cl_sctp_assoc_change != NULL); 3121d8c4025Svi ASSERT(nmp->b_prev == NULL); 3131d8c4025Svi nmp->b_prev = (mblk_t *)ainfo; 3141d8c4025Svi } 3157c478bd9Sstevel@tonic-gate /* Clean up the temporary mblk chain */ 3167c478bd9Sstevel@tonic-gate freemsg(mp); 3177c478bd9Sstevel@tonic-gate asc->head = NULL; 3187c478bd9Sstevel@tonic-gate asc->cid = 0; 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate /* Queue it ... */ 3217c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL) { 3227c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = nmp; 3237c478bd9Sstevel@tonic-gate } else { 3247c478bd9Sstevel@tonic-gate linkb(sctp->sctp_cxmit_list, nmp); 3257c478bd9Sstevel@tonic-gate } 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate BUMP_LOCAL(sctp->sctp_obchunks); 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* And try to send it. */ 3307c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, fp); 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate return (0); 3337c478bd9Sstevel@tonic-gate } 3347c478bd9Sstevel@tonic-gate 3357c478bd9Sstevel@tonic-gate /* 3367c478bd9Sstevel@tonic-gate * If the peer does not understand an ASCONF chunk, we simply 3377c478bd9Sstevel@tonic-gate * clear out the cxmit_list, since we can send nothing further 3387c478bd9Sstevel@tonic-gate * that the peer will understand. 3397c478bd9Sstevel@tonic-gate * 3407c478bd9Sstevel@tonic-gate * Assumes chunk length has already been checked. 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3437c478bd9Sstevel@tonic-gate void 3441d8c4025Svi sctp_asconf_free_cxmit(sctp_t *sctp, sctp_chunk_hdr_t *ch) 3457c478bd9Sstevel@tonic-gate { 3461d8c4025Svi mblk_t *mp; 3471d8c4025Svi mblk_t *mp1; 3481d8c4025Svi sctp_cl_ainfo_t *ainfo; 3491d8c4025Svi 3507c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL) { 3517c478bd9Sstevel@tonic-gate /* Nothing pending */ 3527c478bd9Sstevel@tonic-gate return; 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate 3551d8c4025Svi mp = sctp->sctp_cxmit_list; 3561d8c4025Svi while (mp != NULL) { 3571d8c4025Svi mp1 = mp->b_cont; 3581d8c4025Svi mp->b_cont = NULL; 3591d8c4025Svi if (mp->b_prev != NULL) { 3601d8c4025Svi ainfo = (sctp_cl_ainfo_t *)mp->b_prev; 3611d8c4025Svi mp->b_prev = NULL; 3621d8c4025Svi kmem_free(ainfo->sctp_cl_alist, ainfo->sctp_cl_asize); 3631d8c4025Svi kmem_free(ainfo->sctp_cl_dlist, ainfo->sctp_cl_dsize); 3641d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 3651d8c4025Svi } 3661d8c4025Svi freeb(mp); 3671d8c4025Svi mp = mp1; 3681d8c4025Svi } 3697c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = NULL; 3707c478bd9Sstevel@tonic-gate } 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate void 3737c478bd9Sstevel@tonic-gate sctp_input_asconf(sctp_t *sctp, sctp_chunk_hdr_t *ch, sctp_faddr_t *fp) 3747c478bd9Sstevel@tonic-gate { 3757c478bd9Sstevel@tonic-gate const dispatch_t *dp; 3767c478bd9Sstevel@tonic-gate mblk_t *hmp; 3777c478bd9Sstevel@tonic-gate mblk_t *mp; 3787c478bd9Sstevel@tonic-gate uint32_t *idp; 3797c478bd9Sstevel@tonic-gate uint32_t *hidp; 3807c478bd9Sstevel@tonic-gate ssize_t rlen; 3817c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 3827c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *ach; 3837c478bd9Sstevel@tonic-gate int cont; 3847c478bd9Sstevel@tonic-gate int act; 3857c478bd9Sstevel@tonic-gate uint16_t plen; 3861d8c4025Svi uchar_t *alist = NULL; 3871d8c4025Svi size_t asize = 0; 3881d8c4025Svi uchar_t *dlist = NULL; 3891d8c4025Svi size_t dsize = 0; 3901d8c4025Svi uchar_t *aptr = NULL; 3911d8c4025Svi uchar_t *dptr = NULL; 3921d8c4025Svi int acount = 0; 3931d8c4025Svi int dcount = 0; 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate ASSERT(ch->sch_id == CHUNK_ASCONF); 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ch + 1); 3987c478bd9Sstevel@tonic-gate rlen = ntohs(ch->sch_len) - sizeof (*ch) - sizeof (*idp); 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate if (rlen < 0 || rlen < sizeof (*idp)) { 4017c478bd9Sstevel@tonic-gate /* nothing there; bail out */ 4027c478bd9Sstevel@tonic-gate return; 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate /* Check for duplicates */ 4067c478bd9Sstevel@tonic-gate *idp = ntohl(*idp); 4077c478bd9Sstevel@tonic-gate if (*idp == (sctp->sctp_fcsn + 1)) { 4087c478bd9Sstevel@tonic-gate act = 1; 4097c478bd9Sstevel@tonic-gate } else if (*idp == sctp->sctp_fcsn) { 4107c478bd9Sstevel@tonic-gate act = 0; 4117c478bd9Sstevel@tonic-gate } else { 4127c478bd9Sstevel@tonic-gate /* stale or malicious packet; drop */ 4137c478bd9Sstevel@tonic-gate return; 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate /* Create the ASCONF_ACK header */ 4177c478bd9Sstevel@tonic-gate hmp = sctp_make_mp(sctp, fp, sizeof (*ach) + sizeof (*idp)); 4187c478bd9Sstevel@tonic-gate if (hmp == NULL) { 4197c478bd9Sstevel@tonic-gate /* Let the peer retransmit */ 420*77c67f2fSkcpoon SCTP_KSTAT(sctp_send_asconf_ack_failed); 4217c478bd9Sstevel@tonic-gate return; 4227c478bd9Sstevel@tonic-gate } 4237c478bd9Sstevel@tonic-gate ach = (sctp_chunk_hdr_t *)hmp->b_wptr; 4247c478bd9Sstevel@tonic-gate ach->sch_id = CHUNK_ASCONF_ACK; 4257c478bd9Sstevel@tonic-gate ach->sch_flags = 0; 4267c478bd9Sstevel@tonic-gate /* Set the length later */ 4277c478bd9Sstevel@tonic-gate hidp = (uint32_t *)(ach + 1); 4287c478bd9Sstevel@tonic-gate *hidp = htonl(*idp); 4297c478bd9Sstevel@tonic-gate hmp->b_wptr = (uchar_t *)(hidp + 1); 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate /* Move to the Address Parameter */ 4327c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)(idp + 1); 4337c478bd9Sstevel@tonic-gate if (rlen <= ntohs(ph->sph_len)) { 4347c478bd9Sstevel@tonic-gate freeb(hmp); 4357c478bd9Sstevel@tonic-gate return; 4367c478bd9Sstevel@tonic-gate } 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate /* 4397c478bd9Sstevel@tonic-gate * We already have the association here, so this address parameter 4407c478bd9Sstevel@tonic-gate * doesn't seem to be very useful, should we make sure this is part 4417c478bd9Sstevel@tonic-gate * of the association and send an error, if not? 4427c478bd9Sstevel@tonic-gate * Ignore it for now. 4437c478bd9Sstevel@tonic-gate */ 4447c478bd9Sstevel@tonic-gate rlen -= ntohs(ph->sph_len); 4457c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)((char *)ph + ntohs(ph->sph_len)); 4461d8c4025Svi 4471d8c4025Svi /* 4481d8c4025Svi * We need to pre-allocate buffer before processing the ASCONF 4491d8c4025Svi * chunk. We don't want to fail allocating buffers after processing 4501d8c4025Svi * the ASCONF chunk. So, we walk the list and get the number of 4511d8c4025Svi * addresses added and/or deleted. 4521d8c4025Svi */ 4531d8c4025Svi if (cl_sctp_assoc_change != NULL) { 4541d8c4025Svi sctp_parm_hdr_t *oph = ph; 4551d8c4025Svi ssize_t orlen = rlen; 4561d8c4025Svi 4571d8c4025Svi /* 4581d8c4025Svi * This not very efficient, but there is no better way of 4591d8c4025Svi * doing it. It should be fine since normally the param list 4601d8c4025Svi * will not be very long. 4611d8c4025Svi */ 4621d8c4025Svi while (orlen > 0) { 4631d8c4025Svi /* Sanity checks */ 4641d8c4025Svi if (orlen < sizeof (*oph)) 4651d8c4025Svi break; 4661d8c4025Svi plen = ntohs(oph->sph_len); 4671d8c4025Svi if (plen < sizeof (*oph) || plen > orlen) 4681d8c4025Svi break; 4691d8c4025Svi if (oph->sph_type == htons(PARM_ADD_IP)) 4701d8c4025Svi acount++; 4711d8c4025Svi if (oph->sph_type == htons(PARM_DEL_IP)) 4721d8c4025Svi dcount++; 4731d8c4025Svi oph = sctp_next_parm(oph, &orlen); 4741d8c4025Svi if (oph == NULL) 4751d8c4025Svi break; 4761d8c4025Svi } 4771d8c4025Svi if (acount > 0 || dcount > 0) { 4781d8c4025Svi if (acount > 0) { 4791d8c4025Svi asize = sizeof (in6_addr_t) * acount; 4801d8c4025Svi alist = kmem_alloc(asize, KM_NOSLEEP); 4811d8c4025Svi if (alist == NULL) { 4821d8c4025Svi freeb(hmp); 483*77c67f2fSkcpoon SCTP_KSTAT(sctp_cl_assoc_change); 4841d8c4025Svi return; 4851d8c4025Svi } 4861d8c4025Svi } 4871d8c4025Svi if (dcount > 0) { 4881d8c4025Svi dsize = sizeof (in6_addr_t) * dcount; 4891d8c4025Svi dlist = kmem_alloc(dsize, KM_NOSLEEP); 4901d8c4025Svi if (dlist == NULL) { 4911d8c4025Svi if (acount > 0) 4921d8c4025Svi kmem_free(alist, asize); 4931d8c4025Svi freeb(hmp); 494*77c67f2fSkcpoon SCTP_KSTAT(sctp_cl_assoc_change); 4951d8c4025Svi return; 4961d8c4025Svi } 4971d8c4025Svi } 4981d8c4025Svi aptr = alist; 4991d8c4025Svi dptr = dlist; 5001d8c4025Svi /* 5011d8c4025Svi * We will get the actual count when we process 5021d8c4025Svi * the chunk. 5031d8c4025Svi */ 5041d8c4025Svi acount = 0; 5051d8c4025Svi dcount = 0; 5061d8c4025Svi } 5071d8c4025Svi } 5087c478bd9Sstevel@tonic-gate cont = 1; 5097c478bd9Sstevel@tonic-gate while (rlen > 0 && cont) { 5101d8c4025Svi in6_addr_t addr; 5111d8c4025Svi 5127c478bd9Sstevel@tonic-gate /* Sanity checks */ 5137c478bd9Sstevel@tonic-gate if (rlen < sizeof (*ph)) 5147c478bd9Sstevel@tonic-gate break; 5157c478bd9Sstevel@tonic-gate plen = ntohs(ph->sph_len); 5167c478bd9Sstevel@tonic-gate if (plen < sizeof (*ph) || plen > rlen) { 5177c478bd9Sstevel@tonic-gate break; 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ph + 1); 5207c478bd9Sstevel@tonic-gate dp = sctp_lookup_asconf_dispatch(ntohs(ph->sph_type)); 5217c478bd9Sstevel@tonic-gate ASSERT(dp); 5227c478bd9Sstevel@tonic-gate if (dp->asconf) { 5231d8c4025Svi mp = dp->asconf(sctp, ph, *idp, fp, &cont, act, &addr); 5247c478bd9Sstevel@tonic-gate if (cont == -1) { 5257c478bd9Sstevel@tonic-gate /* 5267c478bd9Sstevel@tonic-gate * Not even enough memory to create 5277c478bd9Sstevel@tonic-gate * an out-of-resources error. Free 5287c478bd9Sstevel@tonic-gate * everything and return; the peer 5297c478bd9Sstevel@tonic-gate * should retransmit. 5307c478bd9Sstevel@tonic-gate */ 5317c478bd9Sstevel@tonic-gate freemsg(hmp); 5321d8c4025Svi if (alist != NULL) 5331d8c4025Svi kmem_free(alist, asize); 5341d8c4025Svi if (dlist != NULL) 5351d8c4025Svi kmem_free(dlist, dsize); 5367c478bd9Sstevel@tonic-gate return; 5377c478bd9Sstevel@tonic-gate } 5387c478bd9Sstevel@tonic-gate if (mp != NULL) { 5397c478bd9Sstevel@tonic-gate linkb(hmp, mp); 5401d8c4025Svi } else if (act != 0) { 5411d8c4025Svi /* update the add/delete list */ 5421d8c4025Svi if (cl_sctp_assoc_change != NULL) { 5431d8c4025Svi if (ph->sph_type == 5441d8c4025Svi htons(PARM_ADD_IP)) { 5451d8c4025Svi ASSERT(alist != NULL); 5461d8c4025Svi bcopy(&addr, aptr, 5471d8c4025Svi sizeof (addr)); 5481d8c4025Svi aptr += sizeof (addr); 5491d8c4025Svi acount++; 5501d8c4025Svi } else if (ph->sph_type == 5511d8c4025Svi htons(PARM_DEL_IP)) { 5521d8c4025Svi ASSERT(dlist != NULL); 5531d8c4025Svi bcopy(&addr, dptr, 5541d8c4025Svi sizeof (addr)); 5551d8c4025Svi dptr += sizeof (addr); 5561d8c4025Svi dcount++; 5571d8c4025Svi } 5581d8c4025Svi } 5597c478bd9Sstevel@tonic-gate } 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate ph = sctp_next_parm(ph, &rlen); 5627c478bd9Sstevel@tonic-gate if (ph == NULL) 5637c478bd9Sstevel@tonic-gate break; 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate 5661d8c4025Svi /* 5671d8c4025Svi * Update clustering's state for this assoc. Note acount/dcount 5681d8c4025Svi * could be zero (i.e. if the add/delete address(es) were not 5691d8c4025Svi * processed successfully). Regardless, if the ?size is > 0, 5701d8c4025Svi * it is the clustering module's responsibility to free the lists. 5711d8c4025Svi */ 5721d8c4025Svi if (cl_sctp_assoc_change != NULL) { 5731d8c4025Svi (*cl_sctp_assoc_change)(sctp->sctp_family, alist, asize, 5741d8c4025Svi acount, dlist, dsize, dcount, SCTP_CL_PADDR, 5751d8c4025Svi (cl_sctp_handle_t)sctp); 5761d8c4025Svi /* alist and dlist will be freed by the clustering module */ 5771d8c4025Svi } 5787c478bd9Sstevel@tonic-gate /* Now that the params have been processed, increment the fcsn */ 5797c478bd9Sstevel@tonic-gate if (act) { 5807c478bd9Sstevel@tonic-gate sctp->sctp_fcsn++; 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate BUMP_LOCAL(sctp->sctp_obchunks); 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate if (fp->isv4) 5857c478bd9Sstevel@tonic-gate ach->sch_len = htons(msgdsize(hmp) - sctp->sctp_hdr_len); 5867c478bd9Sstevel@tonic-gate else 5877c478bd9Sstevel@tonic-gate ach->sch_len = htons(msgdsize(hmp) - sctp->sctp_hdr6_len); 5887c478bd9Sstevel@tonic-gate sctp_set_iplen(sctp, hmp); 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate sctp_add_sendq(sctp, hmp); 5917c478bd9Sstevel@tonic-gate sctp_validate_peer(sctp); 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate static sctp_parm_hdr_t * 5957c478bd9Sstevel@tonic-gate sctp_lookup_asconf_param(sctp_parm_hdr_t *ph, uint32_t cid, ssize_t rlen) 5967c478bd9Sstevel@tonic-gate { 5977c478bd9Sstevel@tonic-gate uint32_t *idp; 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate while (rlen > 0) { 6007c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ph + 1); 6017c478bd9Sstevel@tonic-gate if (*idp == cid) { 6027c478bd9Sstevel@tonic-gate return (ph); 6037c478bd9Sstevel@tonic-gate } 6047c478bd9Sstevel@tonic-gate ph = sctp_next_parm(ph, &rlen); 6057c478bd9Sstevel@tonic-gate if (ph == NULL) 6067c478bd9Sstevel@tonic-gate break; 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate return (NULL); 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate void 6127c478bd9Sstevel@tonic-gate sctp_input_asconf_ack(sctp_t *sctp, sctp_chunk_hdr_t *ch, sctp_faddr_t *fp) 6137c478bd9Sstevel@tonic-gate { 6147c478bd9Sstevel@tonic-gate const dispatch_t *dp; 6157c478bd9Sstevel@tonic-gate uint32_t *idp; 6167c478bd9Sstevel@tonic-gate uint32_t *snp; 6177c478bd9Sstevel@tonic-gate ssize_t rlen; 6187c478bd9Sstevel@tonic-gate ssize_t plen; 6197c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 6207c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *oph; 6217c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *fph; 6227c478bd9Sstevel@tonic-gate mblk_t *mp; 6237c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *och; 6247c478bd9Sstevel@tonic-gate int redosrcs = 0; 6257c478bd9Sstevel@tonic-gate uint16_t param_len; 6261d8c4025Svi uchar_t *alist; 6271d8c4025Svi uchar_t *dlist; 6281d8c4025Svi uint_t acount = 0; 6291d8c4025Svi uint_t dcount = 0; 6301d8c4025Svi uchar_t *aptr; 6311d8c4025Svi uchar_t *dptr; 6321d8c4025Svi sctp_cl_ainfo_t *ainfo; 6331d8c4025Svi in6_addr_t addr; 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate ASSERT(ch->sch_id == CHUNK_ASCONF_ACK); 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate snp = (uint32_t *)(ch + 1); 6387c478bd9Sstevel@tonic-gate rlen = ntohs(ch->sch_len) - sizeof (*ch) - sizeof (*snp); 6397c478bd9Sstevel@tonic-gate if (rlen < 0) { 6407c478bd9Sstevel@tonic-gate return; 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate /* Accept only an ACK for the current serial number */ 6447c478bd9Sstevel@tonic-gate *snp = ntohl(*snp); 6457c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL || *snp != (sctp->sctp_lcsn - 1)) { 6467c478bd9Sstevel@tonic-gate /* Need to send an abort */ 6477c478bd9Sstevel@tonic-gate return; 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 0; 6507c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_STOP(fp); 6517c478bd9Sstevel@tonic-gate 6521d8c4025Svi mp = sctp->sctp_cxmit_list; 6531d8c4025Svi /* 6541d8c4025Svi * We fill in the addresses here to update the clustering's state for 6551d8c4025Svi * this assoc. 6561d8c4025Svi */ 6571d8c4025Svi if (mp != NULL && cl_sctp_assoc_change != NULL) { 6581d8c4025Svi ASSERT(mp->b_prev != NULL); 6591d8c4025Svi ainfo = (sctp_cl_ainfo_t *)mp->b_prev; 6601d8c4025Svi alist = ainfo->sctp_cl_alist; 6611d8c4025Svi dlist = ainfo->sctp_cl_dlist; 6621d8c4025Svi aptr = alist; 6631d8c4025Svi dptr = dlist; 6641d8c4025Svi } 6651d8c4025Svi 6667c478bd9Sstevel@tonic-gate /* 6677c478bd9Sstevel@tonic-gate * Pass explicit replies to callbacks: 6687c478bd9Sstevel@tonic-gate * For each reply in the ACK, look up the corresponding 6697c478bd9Sstevel@tonic-gate * original parameter in the request using the correlation 6707c478bd9Sstevel@tonic-gate * ID, and pass it to the right callback. 6717c478bd9Sstevel@tonic-gate */ 6727c478bd9Sstevel@tonic-gate och = (sctp_chunk_hdr_t *)sctp->sctp_cxmit_list->b_rptr; 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate plen = ntohs(och->sch_len) - sizeof (*och) - sizeof (*idp); 6757c478bd9Sstevel@tonic-gate idp = (uint32_t *)(och + 1); 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate /* Get to the 1st ASCONF param, need to skip Address TLV parm */ 6787c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)(idp + 1); 6797c478bd9Sstevel@tonic-gate plen -= ntohs(fph->sph_len); 6807c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)((char *)fph + ntohs(fph->sph_len)); 6817c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)(snp + 1); 6827c478bd9Sstevel@tonic-gate while (rlen > 0) { 6837c478bd9Sstevel@tonic-gate /* Sanity checks */ 6847c478bd9Sstevel@tonic-gate if (rlen < sizeof (*ph)) { 6857c478bd9Sstevel@tonic-gate break; 6867c478bd9Sstevel@tonic-gate } 6877c478bd9Sstevel@tonic-gate param_len = ntohs(ph->sph_len); 6887c478bd9Sstevel@tonic-gate if (param_len < sizeof (*ph) || param_len > rlen) { 6897c478bd9Sstevel@tonic-gate break; 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ph + 1); 6927c478bd9Sstevel@tonic-gate oph = sctp_lookup_asconf_param(fph, *idp, plen); 6937c478bd9Sstevel@tonic-gate if (oph != NULL) { 6947c478bd9Sstevel@tonic-gate dp = sctp_lookup_asconf_dispatch(ntohs(oph->sph_type)); 6957c478bd9Sstevel@tonic-gate ASSERT(dp); 6967c478bd9Sstevel@tonic-gate if (dp->asconf_ack) { 6971d8c4025Svi dp->asconf_ack(sctp, ph, oph, fp, &addr); 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate /* hack. see below */ 7007c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADD_IP) || 7017c478bd9Sstevel@tonic-gate oph->sph_type == htons(PARM_DEL_IP)) { 7027c478bd9Sstevel@tonic-gate redosrcs = 1; 7031d8c4025Svi /* 7041d8c4025Svi * If the address was sucessfully 7051d8c4025Svi * processed, add it to the add/delete 7061d8c4025Svi * list to send to the clustering 7071d8c4025Svi * module. 7081d8c4025Svi */ 7091d8c4025Svi if (cl_sctp_assoc_change != NULL && 7101d8c4025Svi !IN6_IS_ADDR_UNSPECIFIED(&addr)) { 7111d8c4025Svi if (oph->sph_type == 7121d8c4025Svi htons(PARM_ADD_IP)) { 7131d8c4025Svi bcopy(&addr, aptr, 7141d8c4025Svi sizeof (addr)); 7151d8c4025Svi aptr += sizeof (addr); 7161d8c4025Svi acount++; 7171d8c4025Svi } else { 7181d8c4025Svi bcopy(&addr, dptr, 7191d8c4025Svi sizeof (addr)); 7201d8c4025Svi dptr += sizeof (addr); 7211d8c4025Svi dcount++; 7221d8c4025Svi } 7231d8c4025Svi } 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate ph = sctp_next_parm(ph, &rlen); 7297c478bd9Sstevel@tonic-gate if (ph == NULL) 7307c478bd9Sstevel@tonic-gate break; 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate /* 7347c478bd9Sstevel@tonic-gate * Pass implicit replies to callbacks: 7357c478bd9Sstevel@tonic-gate * For each original request, look up its parameter 7367c478bd9Sstevel@tonic-gate * in the ACK. If there is no corresponding reply, 7377c478bd9Sstevel@tonic-gate * call the callback with a NULL parameter, indicating 7387c478bd9Sstevel@tonic-gate * success. 7397c478bd9Sstevel@tonic-gate */ 7407c478bd9Sstevel@tonic-gate rlen = plen; 7417c478bd9Sstevel@tonic-gate plen = ntohs(ch->sch_len) - sizeof (*ch) - sizeof (*idp); 7427c478bd9Sstevel@tonic-gate oph = fph; 7437c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)((char *)ch + sizeof (sctp_chunk_hdr_t) + 7447c478bd9Sstevel@tonic-gate sizeof (uint32_t)); 7457c478bd9Sstevel@tonic-gate while (rlen > 0) { 7467c478bd9Sstevel@tonic-gate idp = (uint32_t *)(oph + 1); 7477c478bd9Sstevel@tonic-gate ph = sctp_lookup_asconf_param(fph, *idp, plen); 7487c478bd9Sstevel@tonic-gate if (ph == NULL) { 7497c478bd9Sstevel@tonic-gate dp = sctp_lookup_asconf_dispatch(ntohs(oph->sph_type)); 7507c478bd9Sstevel@tonic-gate ASSERT(dp); 7517c478bd9Sstevel@tonic-gate if (dp->asconf_ack) { 7521d8c4025Svi dp->asconf_ack(sctp, NULL, oph, fp, &addr); 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate /* hack. see below */ 7557c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADD_IP) || 7567c478bd9Sstevel@tonic-gate oph->sph_type == htons(PARM_DEL_IP)) { 7577c478bd9Sstevel@tonic-gate redosrcs = 1; 7581d8c4025Svi /* 7591d8c4025Svi * If the address was sucessfully 7601d8c4025Svi * processed, add it to the add/delete 7611d8c4025Svi * list to send to the clustering 7621d8c4025Svi * module. 7631d8c4025Svi */ 7641d8c4025Svi if (cl_sctp_assoc_change != NULL && 7651d8c4025Svi !IN6_IS_ADDR_UNSPECIFIED(&addr)) { 7661d8c4025Svi if (oph->sph_type == 7671d8c4025Svi htons(PARM_ADD_IP)) { 7681d8c4025Svi bcopy(&addr, aptr, 7691d8c4025Svi sizeof (addr)); 7701d8c4025Svi aptr += sizeof (addr); 7711d8c4025Svi acount++; 7721d8c4025Svi } else { 7731d8c4025Svi bcopy(&addr, dptr, 7741d8c4025Svi sizeof (addr)); 7751d8c4025Svi dptr += sizeof (addr); 7761d8c4025Svi dcount++; 7771d8c4025Svi } 7781d8c4025Svi } 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate } 7827c478bd9Sstevel@tonic-gate oph = sctp_next_parm(oph, &rlen); 7837c478bd9Sstevel@tonic-gate if (oph == NULL) { 7847c478bd9Sstevel@tonic-gate break; 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /* We can now free up the first chunk in the cxmit list */ 7897c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = mp->b_cont; 7907c478bd9Sstevel@tonic-gate mp->b_cont = NULL; 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate fp = SCTP_CHUNK_DEST(mp); 7937c478bd9Sstevel@tonic-gate ASSERT(fp != NULL && fp->suna >= MBLKL(mp)); 7947c478bd9Sstevel@tonic-gate fp->suna -= MBLKL(mp); 7951d8c4025Svi 7961d8c4025Svi /* 7971d8c4025Svi * Update clustering's state for this assoc. Note acount/dcount 7981d8c4025Svi * could be zero (i.e. if the add/delete address(es) did not 7991d8c4025Svi * succeed). Regardless, if the ?size is > 0, it is the clustering 8001d8c4025Svi * module's responsibility to free the lists. 8011d8c4025Svi */ 8021d8c4025Svi if (cl_sctp_assoc_change != NULL) { 8031d8c4025Svi ASSERT(mp->b_prev != NULL); 8041d8c4025Svi mp->b_prev = NULL; 8051d8c4025Svi ainfo->sctp_cl_alist = NULL; 8061d8c4025Svi ainfo->sctp_cl_dlist = NULL; 8071d8c4025Svi (*cl_sctp_assoc_change)(sctp->sctp_family, alist, 8081d8c4025Svi ainfo->sctp_cl_asize, acount, dlist, ainfo->sctp_cl_dsize, 8091d8c4025Svi dcount, SCTP_CL_LADDR, (cl_sctp_handle_t)sctp); 8101d8c4025Svi /* alist and dlist will be freed by the clustering module */ 8111d8c4025Svi ainfo->sctp_cl_asize = 0; 8121d8c4025Svi ainfo->sctp_cl_dsize = 0; 8131d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 8141d8c4025Svi } 8157c478bd9Sstevel@tonic-gate freeb(mp); 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate /* can now send the next control chunk */ 8187c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list != NULL) 8197c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, NULL); 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate /* 8227c478bd9Sstevel@tonic-gate * If an add-ip or del-ip has completed (successfully or 8237c478bd9Sstevel@tonic-gate * unsuccessfully), the pool of available source addresses 8247c478bd9Sstevel@tonic-gate * may have changed, so we need to redo faddr source 8257c478bd9Sstevel@tonic-gate * address selections. This is a bit of a hack since 8267c478bd9Sstevel@tonic-gate * this really belongs in the add/del-ip code. However, 8277c478bd9Sstevel@tonic-gate * that code consists of callbacks called for *each* 8287c478bd9Sstevel@tonic-gate * add/del-ip parameter, and sctp_redo_faddr_srcs() is 8297c478bd9Sstevel@tonic-gate * expensive enough that we really don't want to be 8307c478bd9Sstevel@tonic-gate * doing it for each one. So we do it once here. 8317c478bd9Sstevel@tonic-gate */ 8327c478bd9Sstevel@tonic-gate if (redosrcs) 8337c478bd9Sstevel@tonic-gate sctp_redo_faddr_srcs(sctp); 8347c478bd9Sstevel@tonic-gate } 8357c478bd9Sstevel@tonic-gate 8367c478bd9Sstevel@tonic-gate static void 8377c478bd9Sstevel@tonic-gate sctp_rc_timer(sctp_t *sctp, sctp_faddr_t *fp) 8387c478bd9Sstevel@tonic-gate { 8397c478bd9Sstevel@tonic-gate #define SCTP_CLR_SENT_FLAG(mp) ((mp)->b_flag &= ~SCTP_CHUNK_FLAG_SENT) 8407c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 8417c478bd9Sstevel@tonic-gate sctp_faddr_t *ofp; 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate ASSERT(fp != NULL); 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate fp->rc_timer_running = 0; 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate if (sctp->sctp_state != SCTPS_ESTABLISHED || 8487c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list == NULL) { 8497c478bd9Sstevel@tonic-gate return; 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate /* 8527c478bd9Sstevel@tonic-gate * Not a retransmission, this was deferred due to some error 8537c478bd9Sstevel@tonic-gate * condition 8547c478bd9Sstevel@tonic-gate */ 8557c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_ISSENT(sctp->sctp_cxmit_list)) { 8567c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, fp); 8577c478bd9Sstevel@tonic-gate return; 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate /* 8607c478bd9Sstevel@tonic-gate * The sent flag indicates if the msg has been sent on this fp. 8617c478bd9Sstevel@tonic-gate */ 8627c478bd9Sstevel@tonic-gate SCTP_CLR_SENT_FLAG(sctp->sctp_cxmit_list); 8637c478bd9Sstevel@tonic-gate /* Retransmission */ 8647c478bd9Sstevel@tonic-gate if (sctp->sctp_strikes >= sctp->sctp_pa_max_rxt) { 8657c478bd9Sstevel@tonic-gate /* time to give up */ 8667c478bd9Sstevel@tonic-gate BUMP_MIB(&sctp_mib, sctpAborted); 8677c478bd9Sstevel@tonic-gate sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL); 8687c478bd9Sstevel@tonic-gate sctp_clean_death(sctp, ETIMEDOUT); 8697c478bd9Sstevel@tonic-gate return; 8707c478bd9Sstevel@tonic-gate } 8717c478bd9Sstevel@tonic-gate if (fp->strikes >= fp->max_retr) { 8727c478bd9Sstevel@tonic-gate if (sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) 8737c478bd9Sstevel@tonic-gate return; 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate fp->strikes++; 8777c478bd9Sstevel@tonic-gate sctp->sctp_strikes++; 8787c478bd9Sstevel@tonic-gate SCTP_CALC_RXT(fp, sctp->sctp_rto_max); 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate nfp = sctp_rotate_faddr(sctp, fp); 8817c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 0; 8827c478bd9Sstevel@tonic-gate ofp = SCTP_CHUNK_DEST(sctp->sctp_cxmit_list); 8837c478bd9Sstevel@tonic-gate SCTP_SET_CHUNK_DEST(sctp->sctp_cxmit_list, NULL); 8847c478bd9Sstevel@tonic-gate ASSERT(ofp != NULL && ofp == fp); 8857c478bd9Sstevel@tonic-gate ASSERT(ofp->suna >= MBLKL(sctp->sctp_cxmit_list)); 8867c478bd9Sstevel@tonic-gate /* 8877c478bd9Sstevel@tonic-gate * Enter slow start for this destination. 8887c478bd9Sstevel@tonic-gate * XXX anything in the data path that needs to be considered? 8897c478bd9Sstevel@tonic-gate */ 8907c478bd9Sstevel@tonic-gate ofp->ssthresh = ofp->cwnd / 2; 8917c478bd9Sstevel@tonic-gate if (ofp->ssthresh < 2 * ofp->sfa_pmss) 8927c478bd9Sstevel@tonic-gate ofp->ssthresh = 2 * ofp->sfa_pmss; 8937c478bd9Sstevel@tonic-gate ofp->cwnd = ofp->sfa_pmss; 8947c478bd9Sstevel@tonic-gate ofp->pba = 0; 8957c478bd9Sstevel@tonic-gate ofp->suna -= MBLKL(sctp->sctp_cxmit_list); 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * The rexmit flags is used to determine if a serial number needs to 8987c478bd9Sstevel@tonic-gate * be assigned or not, so once set we leave it there. 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_WANT_REXMIT(sctp->sctp_cxmit_list)) 9017c478bd9Sstevel@tonic-gate SCTP_CHUNK_REXMIT(sctp->sctp_cxmit_list); 9027c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, nfp); 9037c478bd9Sstevel@tonic-gate #undef SCTP_CLR_SENT_FLAG 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate void 9077c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp_t *sctp, sctp_faddr_t *fp) 9087c478bd9Sstevel@tonic-gate { 9097c478bd9Sstevel@tonic-gate #define SCTP_SET_SENT_FLAG(mp) ((mp)->b_flag = SCTP_CHUNK_FLAG_SENT) 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate mblk_t *mp; 9127c478bd9Sstevel@tonic-gate mblk_t *ipmp; 9137c478bd9Sstevel@tonic-gate uint32_t *snp; 9147c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 9157c478bd9Sstevel@tonic-gate boolean_t isv4; 9167c478bd9Sstevel@tonic-gate 9177c478bd9Sstevel@tonic-gate if (sctp->sctp_cchunk_pend || sctp->sctp_cxmit_list == NULL || 9187c478bd9Sstevel@tonic-gate /* Queue it for later transmission if not yet established */ 9197c478bd9Sstevel@tonic-gate sctp->sctp_state < SCTPS_ESTABLISHED) { 9207c478bd9Sstevel@tonic-gate ip2dbg(("sctp_wput_asconf: cchunk pending? (%d) or null "\ 9217c478bd9Sstevel@tonic-gate "sctp_cxmit_list? (%s) or incorrect state? (%x)\n", 9227c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend, sctp->sctp_cxmit_list == NULL ? 9237c478bd9Sstevel@tonic-gate "yes" : "no", sctp->sctp_state)); 9247c478bd9Sstevel@tonic-gate return; 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate if (fp == NULL) 9287c478bd9Sstevel@tonic-gate fp = sctp->sctp_current; 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate /* OK to send */ 9317c478bd9Sstevel@tonic-gate ipmp = sctp_make_mp(sctp, fp, 0); 9327c478bd9Sstevel@tonic-gate if (ipmp == NULL) { 9337c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 934*77c67f2fSkcpoon SCTP_KSTAT(sctp_send_asconf_failed); 9357c478bd9Sstevel@tonic-gate return; 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate mp = sctp->sctp_cxmit_list; 9387c478bd9Sstevel@tonic-gate /* Fill in the mandatory Address Parameter TLV */ 9397c478bd9Sstevel@tonic-gate isv4 = (fp != NULL) ? fp->isv4 : sctp->sctp_current->isv4; 9407c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)(mp->b_rptr + sizeof (sctp_chunk_hdr_t) + 9417c478bd9Sstevel@tonic-gate sizeof (uint32_t)); 9427c478bd9Sstevel@tonic-gate if (isv4) { 9437c478bd9Sstevel@tonic-gate ipha_t *ipha = (ipha_t *)ipmp->b_rptr; 9447c478bd9Sstevel@tonic-gate in6_addr_t ipaddr; 9457c478bd9Sstevel@tonic-gate ipaddr_t addr4; 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate ph->sph_type = htons(PARM_ADDR4); 9487c478bd9Sstevel@tonic-gate ph->sph_len = htons(PARM_ADDR4_LEN); 9497c478bd9Sstevel@tonic-gate if (ipha->ipha_src != INADDR_ANY) { 9507c478bd9Sstevel@tonic-gate bcopy(&ipha->ipha_src, ph + 1, IP_ADDR_LEN); 9517c478bd9Sstevel@tonic-gate } else { 9527c478bd9Sstevel@tonic-gate ipaddr = sctp_get_valid_addr(sctp, B_FALSE); 953df19b344Svi /* 954df19b344Svi * All the addresses are down. 955df19b344Svi * Maybe we might have better luck next time. 956df19b344Svi */ 957df19b344Svi if (IN6_IS_ADDR_V4MAPPED_ANY(&ipaddr)) { 958df19b344Svi SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 959df19b344Svi freeb(ipmp); 960df19b344Svi return; 961df19b344Svi } 9627c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_IPADDR(&ipaddr, addr4); 9637c478bd9Sstevel@tonic-gate bcopy(&addr4, ph + 1, IP_ADDR_LEN); 9647c478bd9Sstevel@tonic-gate } 9657c478bd9Sstevel@tonic-gate } else { 9667c478bd9Sstevel@tonic-gate ip6_t *ip6 = (ip6_t *)ipmp->b_rptr; 9677c478bd9Sstevel@tonic-gate in6_addr_t ipaddr; 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate ph->sph_type = htons(PARM_ADDR6); 9707c478bd9Sstevel@tonic-gate ph->sph_len = htons(PARM_ADDR6_LEN); 9717c478bd9Sstevel@tonic-gate if (!IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) { 9727c478bd9Sstevel@tonic-gate bcopy(&ip6->ip6_src, ph + 1, IPV6_ADDR_LEN); 9737c478bd9Sstevel@tonic-gate } else { 9747c478bd9Sstevel@tonic-gate ipaddr = sctp_get_valid_addr(sctp, B_TRUE); 975df19b344Svi /* 976df19b344Svi * All the addresses are down. 977df19b344Svi * Maybe we might have better luck next time. 978df19b344Svi */ 979df19b344Svi if (IN6_IS_ADDR_UNSPECIFIED(&ipaddr)) { 980df19b344Svi SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 981df19b344Svi freeb(ipmp); 982df19b344Svi return; 983df19b344Svi } 9847c478bd9Sstevel@tonic-gate bcopy(&ipaddr, ph + 1, IPV6_ADDR_LEN); 9857c478bd9Sstevel@tonic-gate } 9867c478bd9Sstevel@tonic-gate } 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* Don't exceed CWND */ 9897c478bd9Sstevel@tonic-gate if ((MBLKL(mp) > (fp->cwnd - fp->suna)) || 9907c478bd9Sstevel@tonic-gate ((mp = dupb(sctp->sctp_cxmit_list)) == NULL)) { 9917c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 9927c478bd9Sstevel@tonic-gate freeb(ipmp); 9937c478bd9Sstevel@tonic-gate return; 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate /* Set the serial number now, if sending for the first time */ 9977c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_WANT_REXMIT(mp)) { 9987c478bd9Sstevel@tonic-gate snp = (uint32_t *)(mp->b_rptr + sizeof (sctp_chunk_hdr_t)); 9997c478bd9Sstevel@tonic-gate *snp = htonl(sctp->sctp_lcsn++); 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate SCTP_CHUNK_CLEAR_FLAGS(mp); 10027c478bd9Sstevel@tonic-gate fp->suna += MBLKL(mp); 10037c478bd9Sstevel@tonic-gate /* Attach the header and send the chunk */ 10047c478bd9Sstevel@tonic-gate ipmp->b_cont = mp; 10057c478bd9Sstevel@tonic-gate sctp_set_iplen(sctp, ipmp); 10067c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 1; 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate SCTP_SET_SENT_FLAG(sctp->sctp_cxmit_list); 10097c478bd9Sstevel@tonic-gate SCTP_SET_CHUNK_DEST(sctp->sctp_cxmit_list, fp); 10107c478bd9Sstevel@tonic-gate sctp_add_sendq(sctp, ipmp); 10117c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 10127c478bd9Sstevel@tonic-gate #undef SCTP_SET_SENT_FLAG 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate /* 10167c478bd9Sstevel@tonic-gate * Generate ASCONF error param, include errph, if present. 10177c478bd9Sstevel@tonic-gate */ 10187c478bd9Sstevel@tonic-gate static mblk_t * 10197c478bd9Sstevel@tonic-gate sctp_asconf_adderr(int err, sctp_parm_hdr_t *errph, uint32_t cid) 10207c478bd9Sstevel@tonic-gate { 10217c478bd9Sstevel@tonic-gate mblk_t *mp; 10227c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *eph; 10237c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *wph; 10247c478bd9Sstevel@tonic-gate size_t len; 10257c478bd9Sstevel@tonic-gate size_t elen = 0; 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate len = sizeof (*wph) + sizeof (*eph) + sizeof (cid); 10287c478bd9Sstevel@tonic-gate if (errph != NULL) { 10297c478bd9Sstevel@tonic-gate elen = ntohs(errph->sph_len); 10307c478bd9Sstevel@tonic-gate len += elen; 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate mp = allocb(len, BPRI_MED); 10337c478bd9Sstevel@tonic-gate if (mp == NULL) { 10347c478bd9Sstevel@tonic-gate return (NULL); 10357c478bd9Sstevel@tonic-gate } 10367c478bd9Sstevel@tonic-gate wph = (sctp_parm_hdr_t *)mp->b_rptr; 10377c478bd9Sstevel@tonic-gate /* error cause wrapper */ 10387c478bd9Sstevel@tonic-gate wph->sph_type = htons(PARM_ERROR_IND); 10397c478bd9Sstevel@tonic-gate wph->sph_len = htons(len); 10407c478bd9Sstevel@tonic-gate bcopy(&cid, wph + 1, sizeof (uint32_t)); 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate /* error cause */ 10437c478bd9Sstevel@tonic-gate eph = (sctp_parm_hdr_t *)((char *)wph + sizeof (sctp_parm_hdr_t) + 10447c478bd9Sstevel@tonic-gate sizeof (cid)); 10457c478bd9Sstevel@tonic-gate eph->sph_type = htons(err); 10467c478bd9Sstevel@tonic-gate eph->sph_len = htons(len - sizeof (*wph) - sizeof (cid)); 10477c478bd9Sstevel@tonic-gate mp->b_wptr = (uchar_t *)(eph + 1); 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate /* details */ 10507c478bd9Sstevel@tonic-gate if (elen > 0) { 10517c478bd9Sstevel@tonic-gate bcopy(errph, mp->b_wptr, elen); 10527c478bd9Sstevel@tonic-gate mp->b_wptr += elen; 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate return (mp); 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate static mblk_t * 10587c478bd9Sstevel@tonic-gate sctp_check_addip_addr(sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, int *cont, 10597c478bd9Sstevel@tonic-gate uint32_t cid, in6_addr_t *raddr) 10607c478bd9Sstevel@tonic-gate { 10617c478bd9Sstevel@tonic-gate uint16_t atype; 10627c478bd9Sstevel@tonic-gate uint16_t alen; 10637c478bd9Sstevel@tonic-gate mblk_t *mp; 10647c478bd9Sstevel@tonic-gate in6_addr_t addr; 10657c478bd9Sstevel@tonic-gate ipaddr_t *addr4; 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate atype = ntohs(ph->sph_type); 10687c478bd9Sstevel@tonic-gate alen = ntohs(ph->sph_len); 10697c478bd9Sstevel@tonic-gate 10707c478bd9Sstevel@tonic-gate if (atype != PARM_ADDR4 && atype != PARM_ADDR6) { 10717c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 10727c478bd9Sstevel@tonic-gate if (mp == NULL) { 10737c478bd9Sstevel@tonic-gate *cont = -1; 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate return (mp); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate if ((atype == PARM_ADDR4 && alen < PARM_ADDR4_LEN) || 10787c478bd9Sstevel@tonic-gate (atype == PARM_ADDR6 && alen < PARM_ADDR6_LEN)) { 10797c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 10807c478bd9Sstevel@tonic-gate if (mp == NULL) { 10817c478bd9Sstevel@tonic-gate *cont = -1; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate return (mp); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* Address parameter is present; extract and screen it */ 10877c478bd9Sstevel@tonic-gate if (atype == PARM_ADDR4) { 10887c478bd9Sstevel@tonic-gate addr4 = (ipaddr_t *)(ph + 1); 10897c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(*addr4, &addr); 10907c478bd9Sstevel@tonic-gate 10917c478bd9Sstevel@tonic-gate /* screen XXX loopback to scoping */ 10927c478bd9Sstevel@tonic-gate if (*addr4 == 0 || *addr4 == INADDR_BROADCAST || 10937c478bd9Sstevel@tonic-gate *addr4 == htonl(INADDR_LOOPBACK) || IN_MULTICAST(*addr4)) { 10947c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr not unicast: %x:%x:%x:%x\n", 10957c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 10967c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, 10977c478bd9Sstevel@tonic-gate cid); 10987c478bd9Sstevel@tonic-gate if (mp == NULL) { 10997c478bd9Sstevel@tonic-gate *cont = -1; 11007c478bd9Sstevel@tonic-gate } 11017c478bd9Sstevel@tonic-gate return (mp); 11027c478bd9Sstevel@tonic-gate } 11037c478bd9Sstevel@tonic-gate /* 11047c478bd9Sstevel@tonic-gate * XXX also need to check for subnet 11057c478bd9Sstevel@tonic-gate * broadcasts. This should probably 11067c478bd9Sstevel@tonic-gate * wait until we have full access 11077c478bd9Sstevel@tonic-gate * to the ILL tables. 11087c478bd9Sstevel@tonic-gate */ 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate } else { 11117c478bd9Sstevel@tonic-gate bcopy(ph + 1, &addr, sizeof (addr)); 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate /* screen XXX loopback to scoping */ 11147c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_LINKLOCAL(&addr) || 11157c478bd9Sstevel@tonic-gate IN6_IS_ADDR_MULTICAST(&addr) || 11167c478bd9Sstevel@tonic-gate IN6_IS_ADDR_LOOPBACK(&addr)) { 11177c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr not unicast: %x:%x:%x:%x\n", 11187c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 11197c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, 11207c478bd9Sstevel@tonic-gate cid); 11217c478bd9Sstevel@tonic-gate if (mp == NULL) { 11227c478bd9Sstevel@tonic-gate *cont = -1; 11237c478bd9Sstevel@tonic-gate } 11247c478bd9Sstevel@tonic-gate return (mp); 11257c478bd9Sstevel@tonic-gate } 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate /* OK */ 11307c478bd9Sstevel@tonic-gate *raddr = addr; 11317c478bd9Sstevel@tonic-gate return (NULL); 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate /* 11357c478bd9Sstevel@tonic-gate * Handles both add and delete address requests. 11367c478bd9Sstevel@tonic-gate */ 11377c478bd9Sstevel@tonic-gate static mblk_t * 11387c478bd9Sstevel@tonic-gate sctp_addip_req(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 11391d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *raddr) 11407c478bd9Sstevel@tonic-gate { 11417c478bd9Sstevel@tonic-gate in6_addr_t addr; 11427c478bd9Sstevel@tonic-gate uint16_t type; 11437c478bd9Sstevel@tonic-gate mblk_t *mp; 11447c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 114545916cd2Sjpk sctp_parm_hdr_t *oph = ph; 114645916cd2Sjpk int err; 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate *cont = 1; 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate /* Send back an authorization error if addip is disabled */ 11517c478bd9Sstevel@tonic-gate if (!sctp_addip_enabled) { 115245916cd2Sjpk err = SCTP_ERR_UNAUTHORIZED; 115345916cd2Sjpk goto error_handler; 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate /* Check input */ 11567c478bd9Sstevel@tonic-gate if (ntohs(ph->sph_len) < (sizeof (*ph) * 2)) { 115745916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 115845916cd2Sjpk goto error_handler; 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate type = ntohs(ph->sph_type); 11627c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)((char *)ph + sizeof (sctp_parm_hdr_t) + 11637c478bd9Sstevel@tonic-gate sizeof (cid)); 11647c478bd9Sstevel@tonic-gate mp = sctp_check_addip_addr(ph, oph, cont, cid, &addr); 11657c478bd9Sstevel@tonic-gate if (mp != NULL) 11667c478bd9Sstevel@tonic-gate return (mp); 11671d8c4025Svi if (raddr != NULL) 11681d8c4025Svi *raddr = addr; 11697c478bd9Sstevel@tonic-gate if (type == PARM_ADD_IP) { 11707c478bd9Sstevel@tonic-gate if (sctp_lookup_faddr(sctp, &addr) != NULL) { 11717c478bd9Sstevel@tonic-gate /* Address is already part of association */ 11727c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr already here: %x:%x:%x:%x\n", 11737c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 117445916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 117545916cd2Sjpk goto error_handler; 11767c478bd9Sstevel@tonic-gate } 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate if (!act) { 11797c478bd9Sstevel@tonic-gate return (NULL); 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate /* Add the new address */ 11827c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 1183*77c67f2fSkcpoon err = sctp_add_faddr(sctp, &addr, KM_NOSLEEP, B_FALSE); 118445916cd2Sjpk mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 118545916cd2Sjpk if (err == ENOMEM) { 11867c478bd9Sstevel@tonic-gate /* no memory */ 11877c478bd9Sstevel@tonic-gate *cont = -1; 11887c478bd9Sstevel@tonic-gate return (NULL); 11897c478bd9Sstevel@tonic-gate } 119045916cd2Sjpk if (err != 0) { 119145916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 119245916cd2Sjpk goto error_handler; 119345916cd2Sjpk } 11947c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_ADDED, 0); 11957c478bd9Sstevel@tonic-gate } else if (type == PARM_DEL_IP) { 11967c478bd9Sstevel@tonic-gate nfp = sctp_lookup_faddr(sctp, &addr); 11977c478bd9Sstevel@tonic-gate if (nfp == NULL) { 11987c478bd9Sstevel@tonic-gate /* 11997c478bd9Sstevel@tonic-gate * Peer is trying to delete an address that is not 12007c478bd9Sstevel@tonic-gate * part of the association. 12017c478bd9Sstevel@tonic-gate */ 12027c478bd9Sstevel@tonic-gate dprint(1, ("delip: addr not here: %x:%x:%x:%x\n", 12037c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 120445916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 120545916cd2Sjpk goto error_handler; 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate if (sctp->sctp_faddrs == nfp && nfp->next == NULL) { 12087c478bd9Sstevel@tonic-gate /* Peer is trying to delete last address */ 12097c478bd9Sstevel@tonic-gate dprint(1, ("delip: del last addr: %x:%x:%x:%x\n", 12107c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 121145916cd2Sjpk err = SCTP_ERR_DEL_LAST_ADDR; 121245916cd2Sjpk goto error_handler; 12137c478bd9Sstevel@tonic-gate } 12147c478bd9Sstevel@tonic-gate if (nfp == fp) { 12157c478bd9Sstevel@tonic-gate /* Peer is trying to delete source address */ 12167c478bd9Sstevel@tonic-gate dprint(1, ("delip: del src addr: %x:%x:%x:%x\n", 12177c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 121845916cd2Sjpk err = SCTP_ERR_DEL_SRC_ADDR; 121945916cd2Sjpk goto error_handler; 12207c478bd9Sstevel@tonic-gate } 12217c478bd9Sstevel@tonic-gate if (!act) { 12227c478bd9Sstevel@tonic-gate return (NULL); 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate sctp_unlink_faddr(sctp, nfp); 12267c478bd9Sstevel@tonic-gate /* Update all references to the deleted faddr */ 12277c478bd9Sstevel@tonic-gate if (sctp->sctp_primary == nfp) { 12287c478bd9Sstevel@tonic-gate sctp->sctp_primary = fp; 12297c478bd9Sstevel@tonic-gate } 12307c478bd9Sstevel@tonic-gate if (sctp->sctp_current == nfp) { 1231*77c67f2fSkcpoon sctp_set_faddr_current(sctp, fp); 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate if (sctp->sctp_lastdata == nfp) { 12347c478bd9Sstevel@tonic-gate sctp->sctp_lastdata = fp; 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate if (sctp->sctp_shutdown_faddr == nfp) { 12377c478bd9Sstevel@tonic-gate sctp->sctp_shutdown_faddr = nfp; 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate if (sctp->sctp_lastfaddr == nfp) { 12407c478bd9Sstevel@tonic-gate for (fp = sctp->sctp_faddrs; fp->next; fp = fp->next) 12417c478bd9Sstevel@tonic-gate ; 12427c478bd9Sstevel@tonic-gate sctp->sctp_lastfaddr = fp; 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_REMOVED, 0); 12457c478bd9Sstevel@tonic-gate } else { 12467c478bd9Sstevel@tonic-gate ASSERT(0); 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate /* Successful, don't need to return anything. */ 12507c478bd9Sstevel@tonic-gate return (NULL); 125145916cd2Sjpk 125245916cd2Sjpk error_handler: 125345916cd2Sjpk mp = sctp_asconf_adderr(err, oph, cid); 125445916cd2Sjpk if (mp == NULL) 125545916cd2Sjpk *cont = -1; 125645916cd2Sjpk return (mp); 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate /* 12607c478bd9Sstevel@tonic-gate * Handles both add and delete IP ACKs. 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12637c478bd9Sstevel@tonic-gate static void 12647c478bd9Sstevel@tonic-gate sctp_addip_ack(sctp_t *sctp, sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, 12651d8c4025Svi sctp_faddr_t *fp, in6_addr_t *laddr) 12667c478bd9Sstevel@tonic-gate { 12677c478bd9Sstevel@tonic-gate in6_addr_t addr; 12687c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *sp; 12697c478bd9Sstevel@tonic-gate ipaddr_t *addr4; 12707c478bd9Sstevel@tonic-gate boolean_t backout = B_FALSE; 12717c478bd9Sstevel@tonic-gate uint16_t type; 12727c478bd9Sstevel@tonic-gate uint32_t *cid; 12737c478bd9Sstevel@tonic-gate 12741d8c4025Svi /* could be an ASSERT */ 12751d8c4025Svi if (laddr != NULL) 12761d8c4025Svi IN6_IPADDR_TO_V4MAPPED(0, laddr); 12771d8c4025Svi 12787c478bd9Sstevel@tonic-gate /* If the peer doesn't understand Add-IP, remember it */ 12797c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type == htons(PARM_UNRECOGNIZED)) { 12807c478bd9Sstevel@tonic-gate sctp->sctp_understands_addip = B_FALSE; 12817c478bd9Sstevel@tonic-gate backout = B_TRUE; 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate /* 12857c478bd9Sstevel@tonic-gate * If OK, continue with the add / delete action, otherwise 12867c478bd9Sstevel@tonic-gate * back out the action. 12877c478bd9Sstevel@tonic-gate */ 12887c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type != htons(PARM_SUCCESS)) { 12897c478bd9Sstevel@tonic-gate backout = B_TRUE; 12907c478bd9Sstevel@tonic-gate sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph); 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate type = ntohs(oph->sph_type); 12947c478bd9Sstevel@tonic-gate cid = (uint32_t *)(oph + 1); 12957c478bd9Sstevel@tonic-gate oph = (sctp_parm_hdr_t *)(cid + 1); 12967c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADDR4)) { 12977c478bd9Sstevel@tonic-gate addr4 = (ipaddr_t *)(oph + 1); 12987c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(*addr4, &addr); 12997c478bd9Sstevel@tonic-gate } else { 13007c478bd9Sstevel@tonic-gate bcopy(oph + 1, &addr, sizeof (addr)); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13031d8c4025Svi /* Signifies that the address was sucessfully processed */ 13041d8c4025Svi if (!backout && laddr != NULL) 13051d8c4025Svi *laddr = addr; 13061d8c4025Svi 13071d8c4025Svi sp = sctp_saddr_lookup(sctp, &addr, 0); 13087c478bd9Sstevel@tonic-gate ASSERT(sp != NULL); 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate if (type == PARM_ADD_IP) { 13117c478bd9Sstevel@tonic-gate if (backout) { 13127c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp, sp); 13137c478bd9Sstevel@tonic-gate } else { 13147c478bd9Sstevel@tonic-gate sp->saddr_ipif_dontsrc = 0; 13157c478bd9Sstevel@tonic-gate } 13167c478bd9Sstevel@tonic-gate } else if (type == PARM_DEL_IP) { 13177c478bd9Sstevel@tonic-gate if (backout) { 13187c478bd9Sstevel@tonic-gate sp->saddr_ipif_delete_pending = 0; 13197c478bd9Sstevel@tonic-gate sp->saddr_ipif_dontsrc = 0; 13207c478bd9Sstevel@tonic-gate } else { 13217c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp, sp); 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate } else { 13247c478bd9Sstevel@tonic-gate /* Must be either PARM_ADD_IP or PARM_DEL_IP */ 13257c478bd9Sstevel@tonic-gate ASSERT(0); 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13307c478bd9Sstevel@tonic-gate static mblk_t * 13317c478bd9Sstevel@tonic-gate sctp_setprim_req(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 13321d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *raddr) 13337c478bd9Sstevel@tonic-gate { 13347c478bd9Sstevel@tonic-gate mblk_t *mp; 13357c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *oph; 13367c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 13377c478bd9Sstevel@tonic-gate in6_addr_t addr; 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate *cont = 1; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate /* Check input */ 13427c478bd9Sstevel@tonic-gate if (ntohs(ph->sph_len) < (sizeof (*ph) * 2)) { 13437c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, ph, cid); 13447c478bd9Sstevel@tonic-gate if (mp == NULL) { 13457c478bd9Sstevel@tonic-gate *cont = -1; 13467c478bd9Sstevel@tonic-gate } 13477c478bd9Sstevel@tonic-gate return (mp); 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate oph = ph; 13517c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)((char *)ph + sizeof (sctp_parm_hdr_t) + 13527c478bd9Sstevel@tonic-gate sizeof (cid)); 13537c478bd9Sstevel@tonic-gate mp = sctp_check_addip_addr(ph, oph, cont, cid, &addr); 13547c478bd9Sstevel@tonic-gate if (mp != NULL) { 13557c478bd9Sstevel@tonic-gate return (mp); 13567c478bd9Sstevel@tonic-gate } 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate nfp = sctp_lookup_faddr(sctp, &addr); 13597c478bd9Sstevel@tonic-gate if (nfp == NULL) { 13607c478bd9Sstevel@tonic-gate /* 13617c478bd9Sstevel@tonic-gate * Peer is trying to set an address that is not 13627c478bd9Sstevel@tonic-gate * part of the association. 13637c478bd9Sstevel@tonic-gate */ 13647c478bd9Sstevel@tonic-gate dprint(1, ("setprim: addr not here: %x:%x:%x:%x\n", 13657c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 13667c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 13677c478bd9Sstevel@tonic-gate if (mp == NULL) { 13687c478bd9Sstevel@tonic-gate *cont = -1; 13697c478bd9Sstevel@tonic-gate } 13707c478bd9Sstevel@tonic-gate return (mp); 13717c478bd9Sstevel@tonic-gate } 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_MADE_PRIM, 0); 13747c478bd9Sstevel@tonic-gate sctp->sctp_primary = nfp; 13757c478bd9Sstevel@tonic-gate if (nfp->state != SCTP_FADDRS_ALIVE || nfp == sctp->sctp_current) { 13767c478bd9Sstevel@tonic-gate return (NULL); 13777c478bd9Sstevel@tonic-gate } 1378*77c67f2fSkcpoon sctp_set_faddr_current(sctp, nfp); 13797c478bd9Sstevel@tonic-gate return (NULL); 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate 13827c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13837c478bd9Sstevel@tonic-gate static void 13847c478bd9Sstevel@tonic-gate sctp_setprim_ack(sctp_t *sctp, sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, 13851d8c4025Svi sctp_faddr_t *fp, in6_addr_t *laddr) 13867c478bd9Sstevel@tonic-gate { 13877c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type != htons(PARM_SUCCESS)) { 13887c478bd9Sstevel@tonic-gate /* If the peer doesn't understand Add-IP, remember it */ 13897c478bd9Sstevel@tonic-gate if (ph->sph_type == htons(PARM_UNRECOGNIZED)) { 13907c478bd9Sstevel@tonic-gate sctp->sctp_understands_addip = B_FALSE; 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph); 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate /* On success we do nothing */ 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate int 13997c478bd9Sstevel@tonic-gate sctp_add_ip(sctp_t *sctp, const void *addrs, uint32_t cnt) 14007c478bd9Sstevel@tonic-gate { 14017c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 14027c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 14037c478bd9Sstevel@tonic-gate mblk_t *mp; 14047c478bd9Sstevel@tonic-gate int error = 0; 14057c478bd9Sstevel@tonic-gate int i; 14067c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 14077c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 14087c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 14097c478bd9Sstevel@tonic-gate uint16_t type = htons(PARM_ADD_IP); 14107c478bd9Sstevel@tonic-gate boolean_t v4mapped = B_FALSE; 14111d8c4025Svi sctp_cl_ainfo_t *ainfo = NULL; 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 14147c478bd9Sstevel@tonic-gate if (!sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) 14157c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 14167c478bd9Sstevel@tonic-gate 14171d8c4025Svi /* 14181d8c4025Svi * On a clustered node, we need to pass this list when 14191d8c4025Svi * we get an ASCONF-ACK. We only pre-allocate memory for the 14201d8c4025Svi * list, but fill in the addresses when it is processed 14211d8c4025Svi * successfully after we get an ASCONF-ACK. 14221d8c4025Svi */ 14231d8c4025Svi if (cl_sctp_assoc_change != NULL) { 14241d8c4025Svi ainfo = kmem_zalloc(sizeof (*ainfo), KM_SLEEP); 14251d8c4025Svi /* 14261d8c4025Svi * Reserve space for the list of new addresses 14271d8c4025Svi */ 14281d8c4025Svi ainfo->sctp_cl_asize = sizeof (in6_addr_t) * cnt; 14291d8c4025Svi ainfo->sctp_cl_alist = kmem_alloc(ainfo->sctp_cl_asize, 14301d8c4025Svi KM_SLEEP); 14311d8c4025Svi } 14321d8c4025Svi 14337c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate /* 14367c478bd9Sstevel@tonic-gate * Screen addresses: 14377c478bd9Sstevel@tonic-gate * If adding: 14387c478bd9Sstevel@tonic-gate * o Must not already be a part of the association 14397c478bd9Sstevel@tonic-gate * o Must be AF_INET or AF_INET6 14407c478bd9Sstevel@tonic-gate * o XXX Must be valid source address for this node 14417c478bd9Sstevel@tonic-gate * o Must be unicast 14427c478bd9Sstevel@tonic-gate * o XXX Must fit scoping rules 14437c478bd9Sstevel@tonic-gate * If deleting: 14447c478bd9Sstevel@tonic-gate * o Must be part of the association 14457c478bd9Sstevel@tonic-gate */ 14467c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 14477c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 14487c478bd9Sstevel@tonic-gate case AF_INET: 14497c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 14507c478bd9Sstevel@tonic-gate v4mapped = B_TRUE; 14517c478bd9Sstevel@tonic-gate break; 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate case AF_INET6: 14547c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 14557c478bd9Sstevel@tonic-gate break; 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate if (v4mapped) { 14597c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 14607c478bd9Sstevel@tonic-gate if (mp == NULL) { 14617c478bd9Sstevel@tonic-gate error = ENOMEM; 14627c478bd9Sstevel@tonic-gate goto fail; 14637c478bd9Sstevel@tonic-gate } 14647c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 14657c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 14667c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = type; 14677c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = 14687c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 14697c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 14707c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 14717c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 14727c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin4->sin_addr.s_addr; 14737c478bd9Sstevel@tonic-gate } else { 14747c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 14757c478bd9Sstevel@tonic-gate if (mp == NULL) { 14767c478bd9Sstevel@tonic-gate error = ENOMEM; 14777c478bd9Sstevel@tonic-gate goto fail; 14787c478bd9Sstevel@tonic-gate } 14797c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 14807c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 14817c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = type; 14827c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = 14837c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 14847c478bd9Sstevel@tonic-gate PARM_ADDR6_LEN + sizeof (ad6->asconf_req_cid)); 14857c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 14867c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 14877c478bd9Sstevel@tonic-gate ad6->sad6_addr = sin6->sin6_addr; 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 14907c478bd9Sstevel@tonic-gate if (error != 0) 14917c478bd9Sstevel@tonic-gate goto fail; 14927c478bd9Sstevel@tonic-gate } 14931d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, ainfo); 14947c478bd9Sstevel@tonic-gate if (error != 0) 14957c478bd9Sstevel@tonic-gate goto fail; 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate return (0); 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate fail: 15001d8c4025Svi if (ainfo != NULL) { 15011d8c4025Svi kmem_free(ainfo->sctp_cl_alist, ainfo->sctp_cl_asize); 15021d8c4025Svi ainfo->sctp_cl_asize = 0; 15031d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 15041d8c4025Svi } 15057c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 15067c478bd9Sstevel@tonic-gate return (error); 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate int 15101d8c4025Svi sctp_del_ip(sctp_t *sctp, const void *addrs, uint32_t cnt, uchar_t *ulist, 15111d8c4025Svi size_t usize) 15127c478bd9Sstevel@tonic-gate { 15137c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 15147c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 15157c478bd9Sstevel@tonic-gate mblk_t *mp; 15167c478bd9Sstevel@tonic-gate int error = 0; 15177c478bd9Sstevel@tonic-gate int i; 15187c478bd9Sstevel@tonic-gate int addrcnt = 0; 15197c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 15207c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 15217c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 15227c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *nsp; 15237c478bd9Sstevel@tonic-gate uint16_t type = htons(PARM_DEL_IP); 15247c478bd9Sstevel@tonic-gate boolean_t v4mapped = B_FALSE; 15257c478bd9Sstevel@tonic-gate in6_addr_t addr; 15267c478bd9Sstevel@tonic-gate boolean_t asconf = B_TRUE; 15271d8c4025Svi uint_t ifindex; 15281d8c4025Svi sctp_cl_ainfo_t *ainfo = NULL; 15291d8c4025Svi uchar_t *p = ulist; 15301d8c4025Svi boolean_t check_lport = B_FALSE; 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 15337c478bd9Sstevel@tonic-gate if (sctp->sctp_state <= SCTPS_LISTEN || !sctp_addip_enabled || 15347c478bd9Sstevel@tonic-gate !sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) { 15357c478bd9Sstevel@tonic-gate asconf = B_FALSE; 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate 15381d8c4025Svi if (sctp->sctp_state > SCTPS_BOUND) 15391d8c4025Svi check_lport = B_TRUE; 15401d8c4025Svi 15411d8c4025Svi if (asconf) { 15421d8c4025Svi /* 15431d8c4025Svi * On a clustered node, we need to pass this list when 15441d8c4025Svi * we get an ASCONF-ACK. We only pre-allocate memory for the 15451d8c4025Svi * list, but fill in the addresses when it is processed 15461d8c4025Svi * successfully after we get an ASCONF-ACK. 15471d8c4025Svi */ 15481d8c4025Svi if (cl_sctp_assoc_change != NULL) { 15491d8c4025Svi ainfo = kmem_alloc(sizeof (*ainfo), KM_SLEEP); 15501d8c4025Svi ainfo->sctp_cl_dsize = sizeof (in6_addr_t) * cnt; 15511d8c4025Svi ainfo->sctp_cl_dlist = kmem_alloc(ainfo->sctp_cl_dsize, 15521d8c4025Svi KM_SLEEP); 15531d8c4025Svi } 15547c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 15551d8c4025Svi } 15567c478bd9Sstevel@tonic-gate /* 15577c478bd9Sstevel@tonic-gate * Screen addresses: 15587c478bd9Sstevel@tonic-gate * If adding: 15597c478bd9Sstevel@tonic-gate * o Must not already be a part of the association 15607c478bd9Sstevel@tonic-gate * o Must be AF_INET or AF_INET6 15617c478bd9Sstevel@tonic-gate * o XXX Must be valid source address for this node 15627c478bd9Sstevel@tonic-gate * o Must be unicast 15637c478bd9Sstevel@tonic-gate * o XXX Must fit scoping rules 15647c478bd9Sstevel@tonic-gate * If deleting: 15657c478bd9Sstevel@tonic-gate * o Must be part of the association 15667c478bd9Sstevel@tonic-gate */ 15677c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 15681d8c4025Svi ifindex = 0; 15691d8c4025Svi 15707c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 15717c478bd9Sstevel@tonic-gate case AF_INET: 15727c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 15731d8c4025Svi if (check_lport && sin4->sin_port != sctp->sctp_lport) { 15741d8c4025Svi error = EINVAL; 15751d8c4025Svi goto fail; 15761d8c4025Svi } 15777c478bd9Sstevel@tonic-gate v4mapped = B_TRUE; 15787c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(sin4->sin_addr.s_addr, &addr); 15797c478bd9Sstevel@tonic-gate break; 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate case AF_INET6: 15827c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 15831d8c4025Svi if (check_lport && 15841d8c4025Svi sin6->sin6_port != sctp->sctp_lport) { 15851d8c4025Svi error = EINVAL; 15861d8c4025Svi goto fail; 15871d8c4025Svi } 15887c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 15891d8c4025Svi ifindex = sin6->sin6_scope_id; 15907c478bd9Sstevel@tonic-gate break; 15917c478bd9Sstevel@tonic-gate } 15921d8c4025Svi nsp = sctp_saddr_lookup(sctp, &addr, ifindex); 15937c478bd9Sstevel@tonic-gate if (nsp == NULL) { 15947c478bd9Sstevel@tonic-gate error = EADDRNOTAVAIL; 15957c478bd9Sstevel@tonic-gate goto fail; 15967c478bd9Sstevel@tonic-gate } 15977c478bd9Sstevel@tonic-gate 15981d8c4025Svi /* Collect the list of addresses, if required */ 15991d8c4025Svi if (usize >= sizeof (addr)) { 16001d8c4025Svi bcopy(&addr, p, sizeof (addr)); 16011d8c4025Svi p += sizeof (addr); 16021d8c4025Svi usize -= sizeof (addr); 16031d8c4025Svi } 16047c478bd9Sstevel@tonic-gate if (!asconf) 16057c478bd9Sstevel@tonic-gate continue; 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate nsp->saddr_ipif_delete_pending = 1; 16087c478bd9Sstevel@tonic-gate nsp->saddr_ipif_dontsrc = 1; 16097c478bd9Sstevel@tonic-gate addrcnt++; 16107c478bd9Sstevel@tonic-gate if (v4mapped) { 16117c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 16127c478bd9Sstevel@tonic-gate if (mp == NULL) { 16137c478bd9Sstevel@tonic-gate error = ENOMEM; 16147c478bd9Sstevel@tonic-gate goto fail; 16157c478bd9Sstevel@tonic-gate } 16167c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 16177c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 16187c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = type; 16197c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = 16207c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 16217c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 16227c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 16237c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 16247c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin4->sin_addr.s_addr; 16257c478bd9Sstevel@tonic-gate } else { 16267c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 16277c478bd9Sstevel@tonic-gate if (mp == NULL) { 16287c478bd9Sstevel@tonic-gate error = ENOMEM; 16297c478bd9Sstevel@tonic-gate goto fail; 16307c478bd9Sstevel@tonic-gate } 16317c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 16327c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 16337c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = type; 16347c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = 16357c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + PARM_ADDR6_LEN + 16367c478bd9Sstevel@tonic-gate sizeof (ad6->asconf_req_cid)); 16377c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 16387c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 16397c478bd9Sstevel@tonic-gate ad6->sad6_addr = addr; 16407c478bd9Sstevel@tonic-gate } 16417c478bd9Sstevel@tonic-gate 16427c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 16437c478bd9Sstevel@tonic-gate if (error != 0) 16447c478bd9Sstevel@tonic-gate goto fail; 16457c478bd9Sstevel@tonic-gate } 16467c478bd9Sstevel@tonic-gate 16477c478bd9Sstevel@tonic-gate if (!asconf) { 16487c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp, addrs, cnt, B_FALSE); 16497c478bd9Sstevel@tonic-gate return (0); 16507c478bd9Sstevel@tonic-gate } 16511d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, ainfo); 16527c478bd9Sstevel@tonic-gate if (error != 0) 16537c478bd9Sstevel@tonic-gate goto fail; 16547c478bd9Sstevel@tonic-gate sctp_redo_faddr_srcs(sctp); 16557c478bd9Sstevel@tonic-gate return (0); 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate fail: 16581d8c4025Svi if (ainfo != NULL) { 16591d8c4025Svi kmem_free(ainfo->sctp_cl_dlist, ainfo->sctp_cl_dsize); 16601d8c4025Svi ainfo->sctp_cl_dsize = 0; 16611d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 16621d8c4025Svi } 16637c478bd9Sstevel@tonic-gate if (!asconf) 16647c478bd9Sstevel@tonic-gate return (error); 16657c478bd9Sstevel@tonic-gate for (i = 0; i < addrcnt; i++) { 16661d8c4025Svi ifindex = 0; 16671d8c4025Svi 16687c478bd9Sstevel@tonic-gate switch (sctp->sctp_family) { 16697c478bd9Sstevel@tonic-gate case AF_INET: 16707c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 16717c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(&(sin4->sin_addr), &addr); 16727c478bd9Sstevel@tonic-gate break; 16737c478bd9Sstevel@tonic-gate case AF_INET6: 16747c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 16757c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 16761d8c4025Svi ifindex = sin6->sin6_scope_id; 16777c478bd9Sstevel@tonic-gate break; 16787c478bd9Sstevel@tonic-gate } 16791d8c4025Svi nsp = sctp_saddr_lookup(sctp, &addr, ifindex); 16807c478bd9Sstevel@tonic-gate ASSERT(nsp != NULL); 16817c478bd9Sstevel@tonic-gate nsp->saddr_ipif_delete_pending = 0; 16827c478bd9Sstevel@tonic-gate nsp->saddr_ipif_dontsrc = 0; 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate return (error); 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate int 16907c478bd9Sstevel@tonic-gate sctp_set_peerprim(sctp_t *sctp, const void *inp, uint_t inlen) 16917c478bd9Sstevel@tonic-gate { 16927c478bd9Sstevel@tonic-gate const struct sctp_setprim *prim = inp; 16937c478bd9Sstevel@tonic-gate const struct sockaddr_storage *ss; 16947c478bd9Sstevel@tonic-gate struct sockaddr_in *sin; 16957c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 16967c478bd9Sstevel@tonic-gate in6_addr_t addr; 16977c478bd9Sstevel@tonic-gate mblk_t *mp; 16987c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *sp; 16997c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 17007c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 17017c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 17027c478bd9Sstevel@tonic-gate int error = 0; 17031d8c4025Svi uint_t ifindex = 0; 17047c478bd9Sstevel@tonic-gate 17057c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 17067c478bd9Sstevel@tonic-gate if (!sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) { 17077c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 17087c478bd9Sstevel@tonic-gate } 17097c478bd9Sstevel@tonic-gate 17107c478bd9Sstevel@tonic-gate if (inlen < sizeof (*prim)) 17117c478bd9Sstevel@tonic-gate return (EINVAL); 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate /* Don't do anything if we are not connected */ 17147c478bd9Sstevel@tonic-gate if (sctp->sctp_state != SCTPS_ESTABLISHED) 17157c478bd9Sstevel@tonic-gate return (EINVAL); 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate ss = &prim->ssp_addr; 17187c478bd9Sstevel@tonic-gate sin = NULL; 17197c478bd9Sstevel@tonic-gate sin6 = NULL; 17207c478bd9Sstevel@tonic-gate if (ss->ss_family == AF_INET) { 17217c478bd9Sstevel@tonic-gate sin = (struct sockaddr_in *)ss; 17227c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &addr); 17237c478bd9Sstevel@tonic-gate } else if (ss->ss_family == AF_INET6) { 17247c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)ss; 17257c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 17261d8c4025Svi ifindex = sin6->sin6_scope_id; 17277c478bd9Sstevel@tonic-gate } else { 17287c478bd9Sstevel@tonic-gate return (EAFNOSUPPORT); 17297c478bd9Sstevel@tonic-gate } 17301d8c4025Svi sp = sctp_saddr_lookup(sctp, &addr, ifindex); 17317c478bd9Sstevel@tonic-gate if (sp == NULL) 17327c478bd9Sstevel@tonic-gate return (EADDRNOTAVAIL); 17337c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 17347c478bd9Sstevel@tonic-gate if (sin) { 17357c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 17367c478bd9Sstevel@tonic-gate if (mp == NULL) { 17377c478bd9Sstevel@tonic-gate error = ENOMEM; 17387c478bd9Sstevel@tonic-gate goto fail; 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 17417c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 17427c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = htons(PARM_SET_PRIMARY); 17437c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = htons(sizeof (sctp_parm_hdr_t) + 17447c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 17457c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 17467c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 17477c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin->sin_addr.s_addr; 17487c478bd9Sstevel@tonic-gate } else { 17497c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 17507c478bd9Sstevel@tonic-gate if (mp == NULL) { 17517c478bd9Sstevel@tonic-gate error = ENOMEM; 17527c478bd9Sstevel@tonic-gate goto fail; 17537c478bd9Sstevel@tonic-gate } 17547c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 17557c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 17567c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = htons(PARM_SET_PRIMARY); 17577c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = htons(sizeof (sctp_parm_hdr_t) + 17587c478bd9Sstevel@tonic-gate PARM_ADDR6_LEN + sizeof (ad6->asconf_req_cid)); 17597c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 17607c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 17617c478bd9Sstevel@tonic-gate ad6->sad6_addr = sin6->sin6_addr; 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 17657c478bd9Sstevel@tonic-gate if (error != 0) { 17667c478bd9Sstevel@tonic-gate goto fail; 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate 17691d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, NULL); 17707c478bd9Sstevel@tonic-gate if (error == 0) { 17717c478bd9Sstevel@tonic-gate return (0); 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate fail: 17757c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 17767c478bd9Sstevel@tonic-gate return (error); 17777c478bd9Sstevel@tonic-gate } 1778