17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 545916cd2Sjpk * Common Development and Distribution License (the "License"). 645916cd2Sjpk * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 2177c67f2fSkcpoon 227c478bd9Sstevel@tonic-gate /* 23*fd7b5aedSGeorge Shepherd * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #include <sys/types.h> 277c478bd9Sstevel@tonic-gate #include <sys/systm.h> 287c478bd9Sstevel@tonic-gate #include <sys/stream.h> 297c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 307c478bd9Sstevel@tonic-gate #include <sys/socket.h> 317c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 327c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 337c478bd9Sstevel@tonic-gate #include <sys/strsun.h> 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #include <netinet/in.h> 367c478bd9Sstevel@tonic-gate #include <netinet/ip6.h> 377c478bd9Sstevel@tonic-gate #include <netinet/sctp.h> 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #include <inet/common.h> 407c478bd9Sstevel@tonic-gate #include <inet/ip.h> 417c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 427c478bd9Sstevel@tonic-gate #include <inet/mib2.h> 43f4b3ec61Sdh #include <inet/ipclassifier.h> 447c478bd9Sstevel@tonic-gate #include "sctp_impl.h" 457c478bd9Sstevel@tonic-gate #include "sctp_asconf.h" 467c478bd9Sstevel@tonic-gate #include "sctp_addr.h" 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate typedef struct sctp_asconf_s { 491d8c4025Svi mblk_t *head; 501d8c4025Svi uint32_t cid; 517c478bd9Sstevel@tonic-gate } sctp_asconf_t; 527c478bd9Sstevel@tonic-gate 531d8c4025Svi /* 541d8c4025Svi * This is only used on a clustered node to maintain pre-allocated buffer info. 551d8c4025Svi * before sending an ASCONF chunk. The reason for pre-allocation is we don't 561d8c4025Svi * want to fail allocating memory when we get then ASCONF-ACK in order to 571d8c4025Svi * update the clustering subsystem's state for this assoc. 581d8c4025Svi */ 591d8c4025Svi typedef struct sctp_cl_ainfo_s { 601d8c4025Svi uchar_t *sctp_cl_alist; 611d8c4025Svi size_t sctp_cl_asize; 621d8c4025Svi uchar_t *sctp_cl_dlist; 631d8c4025Svi size_t sctp_cl_dsize; 641d8c4025Svi } sctp_cl_ainfo_t; 651d8c4025Svi 667c478bd9Sstevel@tonic-gate /* 677c478bd9Sstevel@tonic-gate * The ASCONF chunk per-parameter request interface. ph is the 687c478bd9Sstevel@tonic-gate * parameter header for the parameter in the request, and cid 697c478bd9Sstevel@tonic-gate * is the parameters correlation ID. cont should be set to 1 707c478bd9Sstevel@tonic-gate * if the ASCONF framework should continue processing request 717c478bd9Sstevel@tonic-gate * parameters following this one, or 0 if it should stop. If 727c478bd9Sstevel@tonic-gate * cont is -1, this indicates complete memory depletion, which 737c478bd9Sstevel@tonic-gate * will cause the ASCONF framework to abort building a reply. If 747c478bd9Sstevel@tonic-gate * act is 1, the callback should take whatever action it needs 757c478bd9Sstevel@tonic-gate * to fulfil this request. If act is 0, this request has already 767c478bd9Sstevel@tonic-gate * been processed, so the callback should only verify and pass 777c478bd9Sstevel@tonic-gate * back error parameters, and not take any action. 787c478bd9Sstevel@tonic-gate * 797c478bd9Sstevel@tonic-gate * The callback should return an mblk with any reply enclosed, 807c478bd9Sstevel@tonic-gate * with the correlation ID in the first four bytes of the 817c478bd9Sstevel@tonic-gate * message. A NULL return implies implicit success to the 827c478bd9Sstevel@tonic-gate * requestor. 837c478bd9Sstevel@tonic-gate */ 847c478bd9Sstevel@tonic-gate typedef mblk_t *sctp_asconf_func_t(sctp_t *, sctp_parm_hdr_t *ph, uint32_t cid, 851d8c4025Svi sctp_faddr_t *, int *cont, int act, in6_addr_t *addr); 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate /* 887c478bd9Sstevel@tonic-gate * The ASCONF chunk per-parameter ACK interface. ph is the parameter 897c478bd9Sstevel@tonic-gate * header for the parameter returned in the ACK, and oph is the 907c478bd9Sstevel@tonic-gate * original parameter sent out in the ASCONF request. 917c478bd9Sstevel@tonic-gate * If the peer implicitly responded OK (by not including an 927c478bd9Sstevel@tonic-gate * explicit OK for the request), ph will be NULL. 937c478bd9Sstevel@tonic-gate * ph can also point to an Unrecognized Parameter parameter, 947c478bd9Sstevel@tonic-gate * in which case the peer did not understand the request 957c478bd9Sstevel@tonic-gate * parameter. 967c478bd9Sstevel@tonic-gate * 977c478bd9Sstevel@tonic-gate * ph and oph parameter headers are in host byte order. Encapsulated 987c478bd9Sstevel@tonic-gate * parameters will still be in network byte order. 997c478bd9Sstevel@tonic-gate */ 1007c478bd9Sstevel@tonic-gate typedef void sctp_asconf_ack_func_t(sctp_t *, sctp_parm_hdr_t *ph, 1011d8c4025Svi sctp_parm_hdr_t *oph, sctp_faddr_t *, in6_addr_t *addr); 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate typedef struct { 1047c478bd9Sstevel@tonic-gate uint16_t id; 1057c478bd9Sstevel@tonic-gate sctp_asconf_func_t *asconf; 1067c478bd9Sstevel@tonic-gate sctp_asconf_ack_func_t *asconf_ack; 1077c478bd9Sstevel@tonic-gate } dispatch_t; 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate static sctp_asconf_func_t sctp_addip_req, sctp_setprim_req, 1107c478bd9Sstevel@tonic-gate sctp_asconf_unrec_parm; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate static sctp_asconf_ack_func_t sctp_addip_ack, sctp_setprim_ack, 1137c478bd9Sstevel@tonic-gate sctp_asconf_ack_unrec_parm; 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate static const dispatch_t sctp_asconf_dispatch_tbl[] = { 1167c478bd9Sstevel@tonic-gate /* ID ASCONF ASCONF_ACK */ 1177c478bd9Sstevel@tonic-gate { PARM_ADD_IP, sctp_addip_req, sctp_addip_ack }, 1187c478bd9Sstevel@tonic-gate { PARM_DEL_IP, sctp_addip_req, sctp_addip_ack }, 1197c478bd9Sstevel@tonic-gate { PARM_SET_PRIMARY, sctp_setprim_req, sctp_setprim_ack } 1207c478bd9Sstevel@tonic-gate }; 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate static const dispatch_t sctp_asconf_default_dispatch = { 1237c478bd9Sstevel@tonic-gate 0, sctp_asconf_unrec_parm, sctp_asconf_ack_unrec_parm 1247c478bd9Sstevel@tonic-gate }; 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate /* 1277c478bd9Sstevel@tonic-gate * ASCONF framework 1287c478bd9Sstevel@tonic-gate */ 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate static const dispatch_t * 1317c478bd9Sstevel@tonic-gate sctp_lookup_asconf_dispatch(int id) 1327c478bd9Sstevel@tonic-gate { 1337c478bd9Sstevel@tonic-gate int i; 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate for (i = 0; i < A_CNT(sctp_asconf_dispatch_tbl); i++) { 1367c478bd9Sstevel@tonic-gate if (sctp_asconf_dispatch_tbl[i].id == id) { 1377c478bd9Sstevel@tonic-gate return (sctp_asconf_dispatch_tbl + i); 1387c478bd9Sstevel@tonic-gate } 1397c478bd9Sstevel@tonic-gate } 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate return (&sctp_asconf_default_dispatch); 1427c478bd9Sstevel@tonic-gate } 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate /* 1457c478bd9Sstevel@tonic-gate * Frees mp on failure 1467c478bd9Sstevel@tonic-gate */ 1477c478bd9Sstevel@tonic-gate static mblk_t * 1487c478bd9Sstevel@tonic-gate sctp_asconf_prepend_errwrap(mblk_t *mp, uint32_t cid) 1497c478bd9Sstevel@tonic-gate { 1507c478bd9Sstevel@tonic-gate mblk_t *wmp; 1517c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *wph; 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate /* Prepend a wrapper err cause ind param */ 1547c478bd9Sstevel@tonic-gate wmp = allocb(sizeof (*wph) + sizeof (cid), BPRI_MED); 1557c478bd9Sstevel@tonic-gate if (wmp == NULL) { 1567c478bd9Sstevel@tonic-gate freemsg(mp); 1577c478bd9Sstevel@tonic-gate return (NULL); 1587c478bd9Sstevel@tonic-gate } 1597c478bd9Sstevel@tonic-gate wmp->b_wptr += sizeof (*wph) + sizeof (cid); 1607c478bd9Sstevel@tonic-gate wph = (sctp_parm_hdr_t *)wmp->b_rptr; 1617c478bd9Sstevel@tonic-gate wph->sph_type = htons(PARM_ERROR_IND); 1627c478bd9Sstevel@tonic-gate wph->sph_len = htons(msgdsize(mp) + sizeof (*wph) + sizeof (cid)); 1637c478bd9Sstevel@tonic-gate bcopy(&cid, wph + 1, sizeof (uint32_t)); 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate wmp->b_cont = mp; 1667c478bd9Sstevel@tonic-gate return (wmp); 1677c478bd9Sstevel@tonic-gate } 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1707c478bd9Sstevel@tonic-gate static mblk_t * 1717c478bd9Sstevel@tonic-gate sctp_asconf_unrec_parm(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 1721d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *addr) 1737c478bd9Sstevel@tonic-gate { 1747c478bd9Sstevel@tonic-gate mblk_t *mp = NULL; 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate /* Unrecognized param; check the high order bits */ 17777ebe684SGeorge Shepherd if ((ph->sph_type & SCTP_UNREC_PARAM_MASK) == 17877ebe684SGeorge Shepherd (SCTP_CONT_PROC_PARAMS | SCTP_REPORT_THIS_PARAM)) { 1797c478bd9Sstevel@tonic-gate /* report unrecognized param, and keep processing */ 180c513743fSGeorge Shepherd sctp_add_unrec_parm(ph, &mp, B_FALSE); 1817c478bd9Sstevel@tonic-gate if (mp == NULL) { 1827c478bd9Sstevel@tonic-gate *cont = -1; 1837c478bd9Sstevel@tonic-gate return (NULL); 1847c478bd9Sstevel@tonic-gate } 1857c478bd9Sstevel@tonic-gate /* Prepend a the CID and a wrapper err cause ind param */ 1867c478bd9Sstevel@tonic-gate mp = sctp_asconf_prepend_errwrap(mp, cid); 1877c478bd9Sstevel@tonic-gate if (mp == NULL) { 1887c478bd9Sstevel@tonic-gate *cont = -1; 1897c478bd9Sstevel@tonic-gate return (NULL); 1907c478bd9Sstevel@tonic-gate } 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate *cont = 1; 1937c478bd9Sstevel@tonic-gate return (mp); 1947c478bd9Sstevel@tonic-gate } 19577ebe684SGeorge Shepherd if (ph->sph_type & SCTP_REPORT_THIS_PARAM) { 1967c478bd9Sstevel@tonic-gate /* Stop processing and drop; report unrecognized param */ 197c513743fSGeorge Shepherd sctp_add_unrec_parm(ph, &mp, B_FALSE); 1987c478bd9Sstevel@tonic-gate if (mp == NULL) { 1997c478bd9Sstevel@tonic-gate *cont = -1; 2007c478bd9Sstevel@tonic-gate return (NULL); 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate /* Prepend a the CID and a wrapper err cause ind param */ 2037c478bd9Sstevel@tonic-gate mp = sctp_asconf_prepend_errwrap(mp, cid); 2047c478bd9Sstevel@tonic-gate if (mp == NULL) { 2057c478bd9Sstevel@tonic-gate *cont = -1; 2067c478bd9Sstevel@tonic-gate return (NULL); 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate *cont = 0; 2107c478bd9Sstevel@tonic-gate return (mp); 2117c478bd9Sstevel@tonic-gate } 21277ebe684SGeorge Shepherd if (ph->sph_type & SCTP_CONT_PROC_PARAMS) { 2137c478bd9Sstevel@tonic-gate /* skip and continue processing */ 2147c478bd9Sstevel@tonic-gate *cont = 1; 2157c478bd9Sstevel@tonic-gate return (NULL); 2167c478bd9Sstevel@tonic-gate } 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate /* 2 high bits are clear; stop processing and drop packet */ 2197c478bd9Sstevel@tonic-gate *cont = 0; 2207c478bd9Sstevel@tonic-gate return (NULL); 2217c478bd9Sstevel@tonic-gate } 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2247c478bd9Sstevel@tonic-gate static void 2257c478bd9Sstevel@tonic-gate sctp_asconf_ack_unrec_parm(sctp_t *sctp, sctp_parm_hdr_t *ph, 2261d8c4025Svi sctp_parm_hdr_t *oph, sctp_faddr_t *fp, in6_addr_t *laddr) 2277c478bd9Sstevel@tonic-gate { 2287c478bd9Sstevel@tonic-gate ASSERT(ph); 2298dfac042SAnil udupa sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph, B_TRUE); 2307c478bd9Sstevel@tonic-gate } 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate static void 2337c478bd9Sstevel@tonic-gate sctp_asconf_init(sctp_asconf_t *asc) 2347c478bd9Sstevel@tonic-gate { 2357c478bd9Sstevel@tonic-gate ASSERT(asc != NULL); 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate asc->head = NULL; 2387c478bd9Sstevel@tonic-gate asc->cid = 0; 2397c478bd9Sstevel@tonic-gate } 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate static int 2427c478bd9Sstevel@tonic-gate sctp_asconf_add(sctp_asconf_t *asc, mblk_t *mp) 2437c478bd9Sstevel@tonic-gate { 2447c478bd9Sstevel@tonic-gate uint32_t *cp; 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate /* XXX can't exceed MTU */ 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate cp = (uint32_t *)(mp->b_rptr + sizeof (sctp_parm_hdr_t)); 2497c478bd9Sstevel@tonic-gate *cp = asc->cid++; 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate if (asc->head == NULL) 2527c478bd9Sstevel@tonic-gate asc->head = mp; 2537c478bd9Sstevel@tonic-gate else 2547c478bd9Sstevel@tonic-gate linkb(asc->head, mp); 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate return (0); 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate static void 2607c478bd9Sstevel@tonic-gate sctp_asconf_destroy(sctp_asconf_t *asc) 2617c478bd9Sstevel@tonic-gate { 2627c478bd9Sstevel@tonic-gate if (asc->head != NULL) { 2637c478bd9Sstevel@tonic-gate freemsg(asc->head); 2647c478bd9Sstevel@tonic-gate asc->head = NULL; 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate asc->cid = 0; 2677c478bd9Sstevel@tonic-gate } 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate static int 2701d8c4025Svi sctp_asconf_send(sctp_t *sctp, sctp_asconf_t *asc, sctp_faddr_t *fp, 2711d8c4025Svi sctp_cl_ainfo_t *ainfo) 2727c478bd9Sstevel@tonic-gate { 2737c478bd9Sstevel@tonic-gate mblk_t *mp, *nmp; 2747c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *ch; 2757c478bd9Sstevel@tonic-gate boolean_t isv4; 2767c478bd9Sstevel@tonic-gate size_t msgsize; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate ASSERT(asc != NULL && asc->head != NULL); 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate isv4 = (fp != NULL) ? fp->isv4 : sctp->sctp_current->isv4; 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate /* SCTP chunk header + Serial Number + Address Param TLV */ 2837c478bd9Sstevel@tonic-gate msgsize = sizeof (*ch) + sizeof (uint32_t) + 2847c478bd9Sstevel@tonic-gate (isv4 ? PARM_ADDR4_LEN : PARM_ADDR6_LEN); 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate mp = allocb(msgsize, BPRI_MED); 2877c478bd9Sstevel@tonic-gate if (mp == NULL) 2887c478bd9Sstevel@tonic-gate return (ENOMEM); 2897c478bd9Sstevel@tonic-gate 2907c478bd9Sstevel@tonic-gate mp->b_wptr += msgsize; 2917c478bd9Sstevel@tonic-gate mp->b_cont = asc->head; 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate ch = (sctp_chunk_hdr_t *)mp->b_rptr; 2947c478bd9Sstevel@tonic-gate ch->sch_id = CHUNK_ASCONF; 2957c478bd9Sstevel@tonic-gate ch->sch_flags = 0; 2967c478bd9Sstevel@tonic-gate ch->sch_len = htons(msgdsize(mp)); 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate nmp = msgpullup(mp, -1); 2997c478bd9Sstevel@tonic-gate if (nmp == NULL) { 3007c478bd9Sstevel@tonic-gate freeb(mp); 3017c478bd9Sstevel@tonic-gate return (ENOMEM); 3027c478bd9Sstevel@tonic-gate } 3037c478bd9Sstevel@tonic-gate 3041d8c4025Svi /* 3051d8c4025Svi * Stash the address list and the count so that when the operation 3061d8c4025Svi * completes, i.e. when as get an ACK, we can update the clustering's 3071d8c4025Svi * state for this association. 3081d8c4025Svi */ 3091d8c4025Svi if (ainfo != NULL) { 3101d8c4025Svi ASSERT(cl_sctp_assoc_change != NULL); 3111d8c4025Svi ASSERT(nmp->b_prev == NULL); 3121d8c4025Svi nmp->b_prev = (mblk_t *)ainfo; 3131d8c4025Svi } 3147c478bd9Sstevel@tonic-gate /* Clean up the temporary mblk chain */ 3157c478bd9Sstevel@tonic-gate freemsg(mp); 3167c478bd9Sstevel@tonic-gate asc->head = NULL; 3177c478bd9Sstevel@tonic-gate asc->cid = 0; 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate /* Queue it ... */ 3207c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL) { 3217c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = nmp; 3227c478bd9Sstevel@tonic-gate } else { 3237c478bd9Sstevel@tonic-gate linkb(sctp->sctp_cxmit_list, nmp); 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate BUMP_LOCAL(sctp->sctp_obchunks); 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate /* And try to send it. */ 3297c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, fp); 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate return (0); 3327c478bd9Sstevel@tonic-gate } 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate /* 3357c478bd9Sstevel@tonic-gate * If the peer does not understand an ASCONF chunk, we simply 3367c478bd9Sstevel@tonic-gate * clear out the cxmit_list, since we can send nothing further 3377c478bd9Sstevel@tonic-gate * that the peer will understand. 3387c478bd9Sstevel@tonic-gate * 3397c478bd9Sstevel@tonic-gate * Assumes chunk length has already been checked. 3407c478bd9Sstevel@tonic-gate */ 3417c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3427c478bd9Sstevel@tonic-gate void 3431d8c4025Svi sctp_asconf_free_cxmit(sctp_t *sctp, sctp_chunk_hdr_t *ch) 3447c478bd9Sstevel@tonic-gate { 3451d8c4025Svi mblk_t *mp; 3461d8c4025Svi mblk_t *mp1; 3471d8c4025Svi sctp_cl_ainfo_t *ainfo; 3481d8c4025Svi 3497c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL) { 3507c478bd9Sstevel@tonic-gate /* Nothing pending */ 3517c478bd9Sstevel@tonic-gate return; 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3541d8c4025Svi mp = sctp->sctp_cxmit_list; 3551d8c4025Svi while (mp != NULL) { 3561d8c4025Svi mp1 = mp->b_cont; 3571d8c4025Svi mp->b_cont = NULL; 3581d8c4025Svi if (mp->b_prev != NULL) { 3591d8c4025Svi ainfo = (sctp_cl_ainfo_t *)mp->b_prev; 3601d8c4025Svi mp->b_prev = NULL; 3611d8c4025Svi kmem_free(ainfo->sctp_cl_alist, ainfo->sctp_cl_asize); 3621d8c4025Svi kmem_free(ainfo->sctp_cl_dlist, ainfo->sctp_cl_dsize); 3631d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 3641d8c4025Svi } 3651d8c4025Svi freeb(mp); 3661d8c4025Svi mp = mp1; 3671d8c4025Svi } 3687c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = NULL; 3697c478bd9Sstevel@tonic-gate } 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate void 3727c478bd9Sstevel@tonic-gate sctp_input_asconf(sctp_t *sctp, sctp_chunk_hdr_t *ch, sctp_faddr_t *fp) 3737c478bd9Sstevel@tonic-gate { 3747c478bd9Sstevel@tonic-gate const dispatch_t *dp; 3757c478bd9Sstevel@tonic-gate mblk_t *hmp; 3767c478bd9Sstevel@tonic-gate mblk_t *mp; 3777c478bd9Sstevel@tonic-gate uint32_t *idp; 3787c478bd9Sstevel@tonic-gate uint32_t *hidp; 3797c478bd9Sstevel@tonic-gate ssize_t rlen; 3807c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 3817c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *ach; 3827c478bd9Sstevel@tonic-gate int cont; 3837c478bd9Sstevel@tonic-gate int act; 3847c478bd9Sstevel@tonic-gate uint16_t plen; 3851d8c4025Svi uchar_t *alist = NULL; 3861d8c4025Svi size_t asize = 0; 3871d8c4025Svi uchar_t *dlist = NULL; 3881d8c4025Svi size_t dsize = 0; 3891d8c4025Svi uchar_t *aptr = NULL; 3901d8c4025Svi uchar_t *dptr = NULL; 3911d8c4025Svi int acount = 0; 3921d8c4025Svi int dcount = 0; 393f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 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 */ 420f4b3ec61Sdh SCTP_KSTAT(sctps, 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); 483f4b3ec61Sdh SCTP_KSTAT(sctps, 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); 494f4b3ec61Sdh SCTP_KSTAT(sctps, 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) { 573bd670b35SErik Nordmark (*cl_sctp_assoc_change)(sctp->sctp_connp->conn_family, 574bd670b35SErik Nordmark alist, asize, 5751d8c4025Svi acount, dlist, dsize, dcount, SCTP_CL_PADDR, 5761d8c4025Svi (cl_sctp_handle_t)sctp); 5771d8c4025Svi /* alist and dlist will be freed by the clustering module */ 5781d8c4025Svi } 5797c478bd9Sstevel@tonic-gate /* Now that the params have been processed, increment the fcsn */ 5807c478bd9Sstevel@tonic-gate if (act) { 5817c478bd9Sstevel@tonic-gate sctp->sctp_fcsn++; 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate BUMP_LOCAL(sctp->sctp_obchunks); 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate if (fp->isv4) 5867c478bd9Sstevel@tonic-gate ach->sch_len = htons(msgdsize(hmp) - sctp->sctp_hdr_len); 5877c478bd9Sstevel@tonic-gate else 5887c478bd9Sstevel@tonic-gate ach->sch_len = htons(msgdsize(hmp) - sctp->sctp_hdr6_len); 5897c478bd9Sstevel@tonic-gate 590bd670b35SErik Nordmark sctp_set_iplen(sctp, hmp, fp->ixa); 591bd670b35SErik Nordmark (void) conn_ip_output(hmp, fp->ixa); 592bd670b35SErik Nordmark BUMP_LOCAL(sctp->sctp_opkts); 5937c478bd9Sstevel@tonic-gate sctp_validate_peer(sctp); 5947c478bd9Sstevel@tonic-gate } 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate static sctp_parm_hdr_t * 5977c478bd9Sstevel@tonic-gate sctp_lookup_asconf_param(sctp_parm_hdr_t *ph, uint32_t cid, ssize_t rlen) 5987c478bd9Sstevel@tonic-gate { 5997c478bd9Sstevel@tonic-gate uint32_t *idp; 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate while (rlen > 0) { 6027c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ph + 1); 6037c478bd9Sstevel@tonic-gate if (*idp == cid) { 6047c478bd9Sstevel@tonic-gate return (ph); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate ph = sctp_next_parm(ph, &rlen); 6077c478bd9Sstevel@tonic-gate if (ph == NULL) 6087c478bd9Sstevel@tonic-gate break; 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate return (NULL); 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate void 6147c478bd9Sstevel@tonic-gate sctp_input_asconf_ack(sctp_t *sctp, sctp_chunk_hdr_t *ch, sctp_faddr_t *fp) 6157c478bd9Sstevel@tonic-gate { 6167c478bd9Sstevel@tonic-gate const dispatch_t *dp; 6177c478bd9Sstevel@tonic-gate uint32_t *idp; 6187c478bd9Sstevel@tonic-gate uint32_t *snp; 6197c478bd9Sstevel@tonic-gate ssize_t rlen; 6207c478bd9Sstevel@tonic-gate ssize_t plen; 6217c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 6227c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *oph; 6237c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *fph; 6247c478bd9Sstevel@tonic-gate mblk_t *mp; 6257c478bd9Sstevel@tonic-gate sctp_chunk_hdr_t *och; 6267c478bd9Sstevel@tonic-gate int redosrcs = 0; 6277c478bd9Sstevel@tonic-gate uint16_t param_len; 6281d8c4025Svi uchar_t *alist; 6291d8c4025Svi uchar_t *dlist; 6301d8c4025Svi uint_t acount = 0; 6311d8c4025Svi uint_t dcount = 0; 6321d8c4025Svi uchar_t *aptr; 6331d8c4025Svi uchar_t *dptr; 6341d8c4025Svi sctp_cl_ainfo_t *ainfo; 6351d8c4025Svi in6_addr_t addr; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate ASSERT(ch->sch_id == CHUNK_ASCONF_ACK); 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate snp = (uint32_t *)(ch + 1); 6407c478bd9Sstevel@tonic-gate rlen = ntohs(ch->sch_len) - sizeof (*ch) - sizeof (*snp); 6417c478bd9Sstevel@tonic-gate if (rlen < 0) { 6427c478bd9Sstevel@tonic-gate return; 6437c478bd9Sstevel@tonic-gate } 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate /* Accept only an ACK for the current serial number */ 6467c478bd9Sstevel@tonic-gate *snp = ntohl(*snp); 6477c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list == NULL || *snp != (sctp->sctp_lcsn - 1)) { 6487c478bd9Sstevel@tonic-gate /* Need to send an abort */ 6497c478bd9Sstevel@tonic-gate return; 6507c478bd9Sstevel@tonic-gate } 6517c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 0; 6527c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_STOP(fp); 6537c478bd9Sstevel@tonic-gate 6541d8c4025Svi mp = sctp->sctp_cxmit_list; 6551d8c4025Svi /* 6561d8c4025Svi * We fill in the addresses here to update the clustering's state for 6571d8c4025Svi * this assoc. 6581d8c4025Svi */ 6591d8c4025Svi if (mp != NULL && cl_sctp_assoc_change != NULL) { 6601d8c4025Svi ASSERT(mp->b_prev != NULL); 6611d8c4025Svi ainfo = (sctp_cl_ainfo_t *)mp->b_prev; 6621d8c4025Svi alist = ainfo->sctp_cl_alist; 6631d8c4025Svi dlist = ainfo->sctp_cl_dlist; 6641d8c4025Svi aptr = alist; 6651d8c4025Svi dptr = dlist; 6661d8c4025Svi } 6671d8c4025Svi 6687c478bd9Sstevel@tonic-gate /* 6697c478bd9Sstevel@tonic-gate * Pass explicit replies to callbacks: 6707c478bd9Sstevel@tonic-gate * For each reply in the ACK, look up the corresponding 6717c478bd9Sstevel@tonic-gate * original parameter in the request using the correlation 6727c478bd9Sstevel@tonic-gate * ID, and pass it to the right callback. 6737c478bd9Sstevel@tonic-gate */ 6747c478bd9Sstevel@tonic-gate och = (sctp_chunk_hdr_t *)sctp->sctp_cxmit_list->b_rptr; 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate plen = ntohs(och->sch_len) - sizeof (*och) - sizeof (*idp); 6777c478bd9Sstevel@tonic-gate idp = (uint32_t *)(och + 1); 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate /* Get to the 1st ASCONF param, need to skip Address TLV parm */ 6807c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)(idp + 1); 6817c478bd9Sstevel@tonic-gate plen -= ntohs(fph->sph_len); 6827c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)((char *)fph + ntohs(fph->sph_len)); 6837c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)(snp + 1); 6847c478bd9Sstevel@tonic-gate while (rlen > 0) { 6857c478bd9Sstevel@tonic-gate /* Sanity checks */ 6867c478bd9Sstevel@tonic-gate if (rlen < sizeof (*ph)) { 6877c478bd9Sstevel@tonic-gate break; 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate param_len = ntohs(ph->sph_len); 6907c478bd9Sstevel@tonic-gate if (param_len < sizeof (*ph) || param_len > rlen) { 6917c478bd9Sstevel@tonic-gate break; 6927c478bd9Sstevel@tonic-gate } 6937c478bd9Sstevel@tonic-gate idp = (uint32_t *)(ph + 1); 6947c478bd9Sstevel@tonic-gate oph = sctp_lookup_asconf_param(fph, *idp, plen); 6957c478bd9Sstevel@tonic-gate if (oph != NULL) { 6967c478bd9Sstevel@tonic-gate dp = sctp_lookup_asconf_dispatch(ntohs(oph->sph_type)); 6977c478bd9Sstevel@tonic-gate ASSERT(dp); 6987c478bd9Sstevel@tonic-gate if (dp->asconf_ack) { 6991d8c4025Svi dp->asconf_ack(sctp, ph, oph, fp, &addr); 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate /* hack. see below */ 7027c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADD_IP) || 7037c478bd9Sstevel@tonic-gate oph->sph_type == htons(PARM_DEL_IP)) { 7047c478bd9Sstevel@tonic-gate redosrcs = 1; 7051d8c4025Svi /* 7061d8c4025Svi * If the address was sucessfully 7071d8c4025Svi * processed, add it to the add/delete 7081d8c4025Svi * list to send to the clustering 7091d8c4025Svi * module. 7101d8c4025Svi */ 7111d8c4025Svi if (cl_sctp_assoc_change != NULL && 712a22dfb13SVenugopal Iyer !SCTP_IS_ADDR_UNSPEC( 713a22dfb13SVenugopal Iyer IN6_IS_ADDR_V4MAPPED(&addr), 714a22dfb13SVenugopal Iyer addr)) { 7151d8c4025Svi if (oph->sph_type == 7161d8c4025Svi htons(PARM_ADD_IP)) { 7171d8c4025Svi bcopy(&addr, aptr, 7181d8c4025Svi sizeof (addr)); 7191d8c4025Svi aptr += sizeof (addr); 7201d8c4025Svi acount++; 7211d8c4025Svi } else { 7221d8c4025Svi bcopy(&addr, dptr, 7231d8c4025Svi sizeof (addr)); 7241d8c4025Svi dptr += sizeof (addr); 7251d8c4025Svi dcount++; 7261d8c4025Svi } 7271d8c4025Svi } 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate ph = sctp_next_parm(ph, &rlen); 7337c478bd9Sstevel@tonic-gate if (ph == NULL) 7347c478bd9Sstevel@tonic-gate break; 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate /* 7387c478bd9Sstevel@tonic-gate * Pass implicit replies to callbacks: 7397c478bd9Sstevel@tonic-gate * For each original request, look up its parameter 7407c478bd9Sstevel@tonic-gate * in the ACK. If there is no corresponding reply, 7417c478bd9Sstevel@tonic-gate * call the callback with a NULL parameter, indicating 7427c478bd9Sstevel@tonic-gate * success. 7437c478bd9Sstevel@tonic-gate */ 7447c478bd9Sstevel@tonic-gate rlen = plen; 7457c478bd9Sstevel@tonic-gate plen = ntohs(ch->sch_len) - sizeof (*ch) - sizeof (*idp); 7467c478bd9Sstevel@tonic-gate oph = fph; 7477c478bd9Sstevel@tonic-gate fph = (sctp_parm_hdr_t *)((char *)ch + sizeof (sctp_chunk_hdr_t) + 7487c478bd9Sstevel@tonic-gate sizeof (uint32_t)); 7497c478bd9Sstevel@tonic-gate while (rlen > 0) { 7507c478bd9Sstevel@tonic-gate idp = (uint32_t *)(oph + 1); 7517c478bd9Sstevel@tonic-gate ph = sctp_lookup_asconf_param(fph, *idp, plen); 7527c478bd9Sstevel@tonic-gate if (ph == NULL) { 7537c478bd9Sstevel@tonic-gate dp = sctp_lookup_asconf_dispatch(ntohs(oph->sph_type)); 7547c478bd9Sstevel@tonic-gate ASSERT(dp); 7557c478bd9Sstevel@tonic-gate if (dp->asconf_ack) { 7561d8c4025Svi dp->asconf_ack(sctp, NULL, oph, fp, &addr); 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate /* hack. see below */ 7597c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADD_IP) || 7607c478bd9Sstevel@tonic-gate oph->sph_type == htons(PARM_DEL_IP)) { 7617c478bd9Sstevel@tonic-gate redosrcs = 1; 7621d8c4025Svi /* 7631d8c4025Svi * If the address was sucessfully 7641d8c4025Svi * processed, add it to the add/delete 7651d8c4025Svi * list to send to the clustering 7661d8c4025Svi * module. 7671d8c4025Svi */ 7681d8c4025Svi if (cl_sctp_assoc_change != NULL && 769a22dfb13SVenugopal Iyer !SCTP_IS_ADDR_UNSPEC( 770a22dfb13SVenugopal Iyer IN6_IS_ADDR_V4MAPPED(&addr), 771a22dfb13SVenugopal Iyer addr)) { 7721d8c4025Svi if (oph->sph_type == 7731d8c4025Svi htons(PARM_ADD_IP)) { 7741d8c4025Svi bcopy(&addr, aptr, 7751d8c4025Svi sizeof (addr)); 7761d8c4025Svi aptr += sizeof (addr); 7771d8c4025Svi acount++; 7781d8c4025Svi } else { 7791d8c4025Svi bcopy(&addr, dptr, 7801d8c4025Svi sizeof (addr)); 7811d8c4025Svi dptr += sizeof (addr); 7821d8c4025Svi dcount++; 7831d8c4025Svi } 7841d8c4025Svi } 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate oph = sctp_next_parm(oph, &rlen); 7897c478bd9Sstevel@tonic-gate if (oph == NULL) { 7907c478bd9Sstevel@tonic-gate break; 7917c478bd9Sstevel@tonic-gate } 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate /* We can now free up the first chunk in the cxmit list */ 7957c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list = mp->b_cont; 7967c478bd9Sstevel@tonic-gate mp->b_cont = NULL; 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate fp = SCTP_CHUNK_DEST(mp); 7997c478bd9Sstevel@tonic-gate ASSERT(fp != NULL && fp->suna >= MBLKL(mp)); 8007c478bd9Sstevel@tonic-gate fp->suna -= MBLKL(mp); 8011d8c4025Svi 8021d8c4025Svi /* 8031d8c4025Svi * Update clustering's state for this assoc. Note acount/dcount 8041d8c4025Svi * could be zero (i.e. if the add/delete address(es) did not 8051d8c4025Svi * succeed). Regardless, if the ?size is > 0, it is the clustering 8061d8c4025Svi * module's responsibility to free the lists. 8071d8c4025Svi */ 8081d8c4025Svi if (cl_sctp_assoc_change != NULL) { 8091d8c4025Svi ASSERT(mp->b_prev != NULL); 8101d8c4025Svi mp->b_prev = NULL; 8111d8c4025Svi ainfo->sctp_cl_alist = NULL; 8121d8c4025Svi ainfo->sctp_cl_dlist = NULL; 813bd670b35SErik Nordmark (*cl_sctp_assoc_change)(sctp->sctp_connp->conn_family, alist, 8141d8c4025Svi ainfo->sctp_cl_asize, acount, dlist, ainfo->sctp_cl_dsize, 8151d8c4025Svi dcount, SCTP_CL_LADDR, (cl_sctp_handle_t)sctp); 8161d8c4025Svi /* alist and dlist will be freed by the clustering module */ 8171d8c4025Svi ainfo->sctp_cl_asize = 0; 8181d8c4025Svi ainfo->sctp_cl_dsize = 0; 8191d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 8201d8c4025Svi } 8217c478bd9Sstevel@tonic-gate freeb(mp); 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate /* can now send the next control chunk */ 8247c478bd9Sstevel@tonic-gate if (sctp->sctp_cxmit_list != NULL) 8257c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, NULL); 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate /* 8287c478bd9Sstevel@tonic-gate * If an add-ip or del-ip has completed (successfully or 8297c478bd9Sstevel@tonic-gate * unsuccessfully), the pool of available source addresses 8307c478bd9Sstevel@tonic-gate * may have changed, so we need to redo faddr source 8317c478bd9Sstevel@tonic-gate * address selections. This is a bit of a hack since 8327c478bd9Sstevel@tonic-gate * this really belongs in the add/del-ip code. However, 8337c478bd9Sstevel@tonic-gate * that code consists of callbacks called for *each* 8347c478bd9Sstevel@tonic-gate * add/del-ip parameter, and sctp_redo_faddr_srcs() is 8357c478bd9Sstevel@tonic-gate * expensive enough that we really don't want to be 8367c478bd9Sstevel@tonic-gate * doing it for each one. So we do it once here. 8377c478bd9Sstevel@tonic-gate */ 8387c478bd9Sstevel@tonic-gate if (redosrcs) 8397c478bd9Sstevel@tonic-gate sctp_redo_faddr_srcs(sctp); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate static void 8437c478bd9Sstevel@tonic-gate sctp_rc_timer(sctp_t *sctp, sctp_faddr_t *fp) 8447c478bd9Sstevel@tonic-gate { 8457c478bd9Sstevel@tonic-gate #define SCTP_CLR_SENT_FLAG(mp) ((mp)->b_flag &= ~SCTP_CHUNK_FLAG_SENT) 8467c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 8477c478bd9Sstevel@tonic-gate sctp_faddr_t *ofp; 848f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate ASSERT(fp != NULL); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate fp->rc_timer_running = 0; 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate if (sctp->sctp_state != SCTPS_ESTABLISHED || 8557c478bd9Sstevel@tonic-gate sctp->sctp_cxmit_list == NULL) { 8567c478bd9Sstevel@tonic-gate return; 8577c478bd9Sstevel@tonic-gate } 8587c478bd9Sstevel@tonic-gate /* 8597c478bd9Sstevel@tonic-gate * Not a retransmission, this was deferred due to some error 8607c478bd9Sstevel@tonic-gate * condition 8617c478bd9Sstevel@tonic-gate */ 8627c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_ISSENT(sctp->sctp_cxmit_list)) { 8637c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, fp); 8647c478bd9Sstevel@tonic-gate return; 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * The sent flag indicates if the msg has been sent on this fp. 8687c478bd9Sstevel@tonic-gate */ 8697c478bd9Sstevel@tonic-gate SCTP_CLR_SENT_FLAG(sctp->sctp_cxmit_list); 8707c478bd9Sstevel@tonic-gate /* Retransmission */ 8717c478bd9Sstevel@tonic-gate if (sctp->sctp_strikes >= sctp->sctp_pa_max_rxt) { 8727c478bd9Sstevel@tonic-gate /* time to give up */ 873f4b3ec61Sdh BUMP_MIB(&sctps->sctps_mib, sctpAborted); 8747c478bd9Sstevel@tonic-gate sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL); 8757c478bd9Sstevel@tonic-gate sctp_clean_death(sctp, ETIMEDOUT); 8767c478bd9Sstevel@tonic-gate return; 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate if (fp->strikes >= fp->max_retr) { 8797c478bd9Sstevel@tonic-gate if (sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) 8807c478bd9Sstevel@tonic-gate return; 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate 8837c478bd9Sstevel@tonic-gate fp->strikes++; 8847c478bd9Sstevel@tonic-gate sctp->sctp_strikes++; 885*fd7b5aedSGeorge Shepherd SCTP_CALC_RXT(sctp, fp, sctp->sctp_rto_max); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate nfp = sctp_rotate_faddr(sctp, fp); 8887c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 0; 8897c478bd9Sstevel@tonic-gate ofp = SCTP_CHUNK_DEST(sctp->sctp_cxmit_list); 8907c478bd9Sstevel@tonic-gate SCTP_SET_CHUNK_DEST(sctp->sctp_cxmit_list, NULL); 8917c478bd9Sstevel@tonic-gate ASSERT(ofp != NULL && ofp == fp); 8927c478bd9Sstevel@tonic-gate ASSERT(ofp->suna >= MBLKL(sctp->sctp_cxmit_list)); 8937c478bd9Sstevel@tonic-gate /* 8947c478bd9Sstevel@tonic-gate * Enter slow start for this destination. 8957c478bd9Sstevel@tonic-gate * XXX anything in the data path that needs to be considered? 8967c478bd9Sstevel@tonic-gate */ 8977c478bd9Sstevel@tonic-gate ofp->ssthresh = ofp->cwnd / 2; 8987c478bd9Sstevel@tonic-gate if (ofp->ssthresh < 2 * ofp->sfa_pmss) 8997c478bd9Sstevel@tonic-gate ofp->ssthresh = 2 * ofp->sfa_pmss; 9007c478bd9Sstevel@tonic-gate ofp->cwnd = ofp->sfa_pmss; 9017c478bd9Sstevel@tonic-gate ofp->pba = 0; 9027c478bd9Sstevel@tonic-gate ofp->suna -= MBLKL(sctp->sctp_cxmit_list); 9037c478bd9Sstevel@tonic-gate /* 9047c478bd9Sstevel@tonic-gate * The rexmit flags is used to determine if a serial number needs to 9057c478bd9Sstevel@tonic-gate * be assigned or not, so once set we leave it there. 9067c478bd9Sstevel@tonic-gate */ 9077c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_WANT_REXMIT(sctp->sctp_cxmit_list)) 9087c478bd9Sstevel@tonic-gate SCTP_CHUNK_REXMIT(sctp->sctp_cxmit_list); 9097c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp, nfp); 9107c478bd9Sstevel@tonic-gate #undef SCTP_CLR_SENT_FLAG 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate void 9147c478bd9Sstevel@tonic-gate sctp_wput_asconf(sctp_t *sctp, sctp_faddr_t *fp) 9157c478bd9Sstevel@tonic-gate { 9167c478bd9Sstevel@tonic-gate #define SCTP_SET_SENT_FLAG(mp) ((mp)->b_flag = SCTP_CHUNK_FLAG_SENT) 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate mblk_t *mp; 9197c478bd9Sstevel@tonic-gate mblk_t *ipmp; 9207c478bd9Sstevel@tonic-gate uint32_t *snp; 9217c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *ph; 9227c478bd9Sstevel@tonic-gate boolean_t isv4; 923f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 924c31292eeSkcpoon boolean_t saddr_set; 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate if (sctp->sctp_cchunk_pend || sctp->sctp_cxmit_list == NULL || 9277c478bd9Sstevel@tonic-gate /* Queue it for later transmission if not yet established */ 9287c478bd9Sstevel@tonic-gate sctp->sctp_state < SCTPS_ESTABLISHED) { 9297c478bd9Sstevel@tonic-gate ip2dbg(("sctp_wput_asconf: cchunk pending? (%d) or null "\ 9307c478bd9Sstevel@tonic-gate "sctp_cxmit_list? (%s) or incorrect state? (%x)\n", 9317c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend, sctp->sctp_cxmit_list == NULL ? 9327c478bd9Sstevel@tonic-gate "yes" : "no", sctp->sctp_state)); 9337c478bd9Sstevel@tonic-gate return; 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate if (fp == NULL) 9377c478bd9Sstevel@tonic-gate fp = sctp->sctp_current; 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate /* OK to send */ 9407c478bd9Sstevel@tonic-gate ipmp = sctp_make_mp(sctp, fp, 0); 9417c478bd9Sstevel@tonic-gate if (ipmp == NULL) { 9427c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 943f4b3ec61Sdh SCTP_KSTAT(sctps, sctp_send_asconf_failed); 9447c478bd9Sstevel@tonic-gate return; 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate mp = sctp->sctp_cxmit_list; 9477c478bd9Sstevel@tonic-gate /* Fill in the mandatory Address Parameter TLV */ 9487c478bd9Sstevel@tonic-gate isv4 = (fp != NULL) ? fp->isv4 : sctp->sctp_current->isv4; 9497c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)(mp->b_rptr + sizeof (sctp_chunk_hdr_t) + 9507c478bd9Sstevel@tonic-gate sizeof (uint32_t)); 9517c478bd9Sstevel@tonic-gate if (isv4) { 9527c478bd9Sstevel@tonic-gate ipha_t *ipha = (ipha_t *)ipmp->b_rptr; 9537c478bd9Sstevel@tonic-gate in6_addr_t ipaddr; 9547c478bd9Sstevel@tonic-gate ipaddr_t addr4; 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate ph->sph_type = htons(PARM_ADDR4); 9577c478bd9Sstevel@tonic-gate ph->sph_len = htons(PARM_ADDR4_LEN); 9587c478bd9Sstevel@tonic-gate if (ipha->ipha_src != INADDR_ANY) { 9597c478bd9Sstevel@tonic-gate bcopy(&ipha->ipha_src, ph + 1, IP_ADDR_LEN); 9607c478bd9Sstevel@tonic-gate } else { 961c31292eeSkcpoon ipaddr = sctp_get_valid_addr(sctp, B_FALSE, &saddr_set); 962df19b344Svi /* 963df19b344Svi * All the addresses are down. 964df19b344Svi * Maybe we might have better luck next time. 965df19b344Svi */ 966c31292eeSkcpoon if (!saddr_set) { 967df19b344Svi SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 968df19b344Svi freeb(ipmp); 969df19b344Svi return; 970df19b344Svi } 9717c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_IPADDR(&ipaddr, addr4); 9727c478bd9Sstevel@tonic-gate bcopy(&addr4, ph + 1, IP_ADDR_LEN); 9737c478bd9Sstevel@tonic-gate } 9747c478bd9Sstevel@tonic-gate } else { 9757c478bd9Sstevel@tonic-gate ip6_t *ip6 = (ip6_t *)ipmp->b_rptr; 9767c478bd9Sstevel@tonic-gate in6_addr_t ipaddr; 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate ph->sph_type = htons(PARM_ADDR6); 9797c478bd9Sstevel@tonic-gate ph->sph_len = htons(PARM_ADDR6_LEN); 9807c478bd9Sstevel@tonic-gate if (!IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) { 9817c478bd9Sstevel@tonic-gate bcopy(&ip6->ip6_src, ph + 1, IPV6_ADDR_LEN); 9827c478bd9Sstevel@tonic-gate } else { 983c31292eeSkcpoon ipaddr = sctp_get_valid_addr(sctp, B_TRUE, &saddr_set); 984df19b344Svi /* 985df19b344Svi * All the addresses are down. 986df19b344Svi * Maybe we might have better luck next time. 987df19b344Svi */ 988c31292eeSkcpoon if (!saddr_set) { 989df19b344Svi SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 990df19b344Svi freeb(ipmp); 991df19b344Svi return; 992df19b344Svi } 9937c478bd9Sstevel@tonic-gate bcopy(&ipaddr, ph + 1, IPV6_ADDR_LEN); 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate /* Don't exceed CWND */ 9987c478bd9Sstevel@tonic-gate if ((MBLKL(mp) > (fp->cwnd - fp->suna)) || 9997c478bd9Sstevel@tonic-gate ((mp = dupb(sctp->sctp_cxmit_list)) == NULL)) { 10007c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 10017c478bd9Sstevel@tonic-gate freeb(ipmp); 10027c478bd9Sstevel@tonic-gate return; 10037c478bd9Sstevel@tonic-gate } 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate /* Set the serial number now, if sending for the first time */ 10067c478bd9Sstevel@tonic-gate if (!SCTP_CHUNK_WANT_REXMIT(mp)) { 10077c478bd9Sstevel@tonic-gate snp = (uint32_t *)(mp->b_rptr + sizeof (sctp_chunk_hdr_t)); 10087c478bd9Sstevel@tonic-gate *snp = htonl(sctp->sctp_lcsn++); 10097c478bd9Sstevel@tonic-gate } 10107c478bd9Sstevel@tonic-gate SCTP_CHUNK_CLEAR_FLAGS(mp); 10117c478bd9Sstevel@tonic-gate fp->suna += MBLKL(mp); 10127c478bd9Sstevel@tonic-gate /* Attach the header and send the chunk */ 10137c478bd9Sstevel@tonic-gate ipmp->b_cont = mp; 10147c478bd9Sstevel@tonic-gate sctp->sctp_cchunk_pend = 1; 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate SCTP_SET_SENT_FLAG(sctp->sctp_cxmit_list); 10177c478bd9Sstevel@tonic-gate SCTP_SET_CHUNK_DEST(sctp->sctp_cxmit_list, fp); 1018bd670b35SErik Nordmark sctp_set_iplen(sctp, ipmp, fp->ixa); 1019bd670b35SErik Nordmark (void) conn_ip_output(ipmp, fp->ixa); 1020bd670b35SErik Nordmark BUMP_LOCAL(sctp->sctp_opkts); 10217c478bd9Sstevel@tonic-gate SCTP_FADDR_RC_TIMER_RESTART(sctp, fp, fp->rto); 10227c478bd9Sstevel@tonic-gate #undef SCTP_SET_SENT_FLAG 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate /* 10267c478bd9Sstevel@tonic-gate * Generate ASCONF error param, include errph, if present. 10277c478bd9Sstevel@tonic-gate */ 10287c478bd9Sstevel@tonic-gate static mblk_t * 10297c478bd9Sstevel@tonic-gate sctp_asconf_adderr(int err, sctp_parm_hdr_t *errph, uint32_t cid) 10307c478bd9Sstevel@tonic-gate { 10317c478bd9Sstevel@tonic-gate mblk_t *mp; 10327c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *eph; 10337c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *wph; 10347c478bd9Sstevel@tonic-gate size_t len; 10357c478bd9Sstevel@tonic-gate size_t elen = 0; 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate len = sizeof (*wph) + sizeof (*eph) + sizeof (cid); 10387c478bd9Sstevel@tonic-gate if (errph != NULL) { 10397c478bd9Sstevel@tonic-gate elen = ntohs(errph->sph_len); 10407c478bd9Sstevel@tonic-gate len += elen; 10417c478bd9Sstevel@tonic-gate } 10427c478bd9Sstevel@tonic-gate mp = allocb(len, BPRI_MED); 10437c478bd9Sstevel@tonic-gate if (mp == NULL) { 10447c478bd9Sstevel@tonic-gate return (NULL); 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate wph = (sctp_parm_hdr_t *)mp->b_rptr; 10477c478bd9Sstevel@tonic-gate /* error cause wrapper */ 10487c478bd9Sstevel@tonic-gate wph->sph_type = htons(PARM_ERROR_IND); 10497c478bd9Sstevel@tonic-gate wph->sph_len = htons(len); 10507c478bd9Sstevel@tonic-gate bcopy(&cid, wph + 1, sizeof (uint32_t)); 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate /* error cause */ 10537c478bd9Sstevel@tonic-gate eph = (sctp_parm_hdr_t *)((char *)wph + sizeof (sctp_parm_hdr_t) + 10547c478bd9Sstevel@tonic-gate sizeof (cid)); 10557c478bd9Sstevel@tonic-gate eph->sph_type = htons(err); 10567c478bd9Sstevel@tonic-gate eph->sph_len = htons(len - sizeof (*wph) - sizeof (cid)); 10577c478bd9Sstevel@tonic-gate mp->b_wptr = (uchar_t *)(eph + 1); 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate /* details */ 10607c478bd9Sstevel@tonic-gate if (elen > 0) { 10617c478bd9Sstevel@tonic-gate bcopy(errph, mp->b_wptr, elen); 10627c478bd9Sstevel@tonic-gate mp->b_wptr += elen; 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate return (mp); 10657c478bd9Sstevel@tonic-gate } 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate static mblk_t * 10687c478bd9Sstevel@tonic-gate sctp_check_addip_addr(sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, int *cont, 10697c478bd9Sstevel@tonic-gate uint32_t cid, in6_addr_t *raddr) 10707c478bd9Sstevel@tonic-gate { 10717c478bd9Sstevel@tonic-gate uint16_t atype; 10727c478bd9Sstevel@tonic-gate uint16_t alen; 10737c478bd9Sstevel@tonic-gate mblk_t *mp; 10747c478bd9Sstevel@tonic-gate in6_addr_t addr; 10757c478bd9Sstevel@tonic-gate ipaddr_t *addr4; 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate atype = ntohs(ph->sph_type); 10787c478bd9Sstevel@tonic-gate alen = ntohs(ph->sph_len); 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate if (atype != PARM_ADDR4 && atype != PARM_ADDR6) { 10817c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 10827c478bd9Sstevel@tonic-gate if (mp == NULL) { 10837c478bd9Sstevel@tonic-gate *cont = -1; 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate return (mp); 10867c478bd9Sstevel@tonic-gate } 10877c478bd9Sstevel@tonic-gate if ((atype == PARM_ADDR4 && alen < PARM_ADDR4_LEN) || 10887c478bd9Sstevel@tonic-gate (atype == PARM_ADDR6 && alen < PARM_ADDR6_LEN)) { 10897c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 10907c478bd9Sstevel@tonic-gate if (mp == NULL) { 10917c478bd9Sstevel@tonic-gate *cont = -1; 10927c478bd9Sstevel@tonic-gate } 10937c478bd9Sstevel@tonic-gate return (mp); 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate /* Address parameter is present; extract and screen it */ 10977c478bd9Sstevel@tonic-gate if (atype == PARM_ADDR4) { 10987c478bd9Sstevel@tonic-gate addr4 = (ipaddr_t *)(ph + 1); 10997c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(*addr4, &addr); 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate /* screen XXX loopback to scoping */ 11027c478bd9Sstevel@tonic-gate if (*addr4 == 0 || *addr4 == INADDR_BROADCAST || 1103c4f4b3c8Skcpoon *addr4 == htonl(INADDR_LOOPBACK) || CLASSD(*addr4)) { 11047c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr not unicast: %x:%x:%x:%x\n", 11057c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 11067c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, 11077c478bd9Sstevel@tonic-gate cid); 11087c478bd9Sstevel@tonic-gate if (mp == NULL) { 11097c478bd9Sstevel@tonic-gate *cont = -1; 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate return (mp); 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate /* 11147c478bd9Sstevel@tonic-gate * XXX also need to check for subnet 11157c478bd9Sstevel@tonic-gate * broadcasts. This should probably 11167c478bd9Sstevel@tonic-gate * wait until we have full access 11177c478bd9Sstevel@tonic-gate * to the ILL tables. 11187c478bd9Sstevel@tonic-gate */ 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate } else { 11217c478bd9Sstevel@tonic-gate bcopy(ph + 1, &addr, sizeof (addr)); 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate /* screen XXX loopback to scoping */ 11247c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_LINKLOCAL(&addr) || 11257c478bd9Sstevel@tonic-gate IN6_IS_ADDR_MULTICAST(&addr) || 11267c478bd9Sstevel@tonic-gate IN6_IS_ADDR_LOOPBACK(&addr)) { 11277c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr not unicast: %x:%x:%x:%x\n", 11287c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 11297c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, 11307c478bd9Sstevel@tonic-gate cid); 11317c478bd9Sstevel@tonic-gate if (mp == NULL) { 11327c478bd9Sstevel@tonic-gate *cont = -1; 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate return (mp); 11357c478bd9Sstevel@tonic-gate } 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* OK */ 11407c478bd9Sstevel@tonic-gate *raddr = addr; 11417c478bd9Sstevel@tonic-gate return (NULL); 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate /* 11457c478bd9Sstevel@tonic-gate * Handles both add and delete address requests. 11467c478bd9Sstevel@tonic-gate */ 11477c478bd9Sstevel@tonic-gate static mblk_t * 11487c478bd9Sstevel@tonic-gate sctp_addip_req(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 11491d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *raddr) 11507c478bd9Sstevel@tonic-gate { 11517c478bd9Sstevel@tonic-gate in6_addr_t addr; 11527c478bd9Sstevel@tonic-gate uint16_t type; 11537c478bd9Sstevel@tonic-gate mblk_t *mp; 11547c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 115545916cd2Sjpk sctp_parm_hdr_t *oph = ph; 115645916cd2Sjpk int err; 1157f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate *cont = 1; 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* Send back an authorization error if addip is disabled */ 1162f4b3ec61Sdh if (!sctps->sctps_addip_enabled) { 116345916cd2Sjpk err = SCTP_ERR_UNAUTHORIZED; 116445916cd2Sjpk goto error_handler; 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate /* Check input */ 11677c478bd9Sstevel@tonic-gate if (ntohs(ph->sph_len) < (sizeof (*ph) * 2)) { 116845916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 116945916cd2Sjpk goto error_handler; 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate type = ntohs(ph->sph_type); 11737c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)((char *)ph + sizeof (sctp_parm_hdr_t) + 11747c478bd9Sstevel@tonic-gate sizeof (cid)); 11757c478bd9Sstevel@tonic-gate mp = sctp_check_addip_addr(ph, oph, cont, cid, &addr); 11767c478bd9Sstevel@tonic-gate if (mp != NULL) 11777c478bd9Sstevel@tonic-gate return (mp); 11781d8c4025Svi if (raddr != NULL) 11791d8c4025Svi *raddr = addr; 11807c478bd9Sstevel@tonic-gate if (type == PARM_ADD_IP) { 11817c478bd9Sstevel@tonic-gate if (sctp_lookup_faddr(sctp, &addr) != NULL) { 11827c478bd9Sstevel@tonic-gate /* Address is already part of association */ 11837c478bd9Sstevel@tonic-gate dprint(1, ("addip: addr already here: %x:%x:%x:%x\n", 11847c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 118545916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 118645916cd2Sjpk goto error_handler; 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate if (!act) { 11907c478bd9Sstevel@tonic-gate return (NULL); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate /* Add the new address */ 11937c478bd9Sstevel@tonic-gate mutex_enter(&sctp->sctp_conn_tfp->tf_lock); 119477c67f2fSkcpoon err = sctp_add_faddr(sctp, &addr, KM_NOSLEEP, B_FALSE); 119545916cd2Sjpk mutex_exit(&sctp->sctp_conn_tfp->tf_lock); 119645916cd2Sjpk if (err == ENOMEM) { 11977c478bd9Sstevel@tonic-gate /* no memory */ 11987c478bd9Sstevel@tonic-gate *cont = -1; 11997c478bd9Sstevel@tonic-gate return (NULL); 12007c478bd9Sstevel@tonic-gate } 120145916cd2Sjpk if (err != 0) { 120245916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 120345916cd2Sjpk goto error_handler; 120445916cd2Sjpk } 12057c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_ADDED, 0); 12067c478bd9Sstevel@tonic-gate } else if (type == PARM_DEL_IP) { 12077c478bd9Sstevel@tonic-gate nfp = sctp_lookup_faddr(sctp, &addr); 12087c478bd9Sstevel@tonic-gate if (nfp == NULL) { 12097c478bd9Sstevel@tonic-gate /* 12107c478bd9Sstevel@tonic-gate * Peer is trying to delete an address that is not 12117c478bd9Sstevel@tonic-gate * part of the association. 12127c478bd9Sstevel@tonic-gate */ 12137c478bd9Sstevel@tonic-gate dprint(1, ("delip: addr not here: %x:%x:%x:%x\n", 12147c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 121545916cd2Sjpk err = SCTP_ERR_BAD_MANDPARM; 121645916cd2Sjpk goto error_handler; 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate if (sctp->sctp_faddrs == nfp && nfp->next == NULL) { 12197c478bd9Sstevel@tonic-gate /* Peer is trying to delete last address */ 12207c478bd9Sstevel@tonic-gate dprint(1, ("delip: del last addr: %x:%x:%x:%x\n", 12217c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 122245916cd2Sjpk err = SCTP_ERR_DEL_LAST_ADDR; 122345916cd2Sjpk goto error_handler; 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate if (nfp == fp) { 12267c478bd9Sstevel@tonic-gate /* Peer is trying to delete source address */ 12277c478bd9Sstevel@tonic-gate dprint(1, ("delip: del src addr: %x:%x:%x:%x\n", 12287c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 122945916cd2Sjpk err = SCTP_ERR_DEL_SRC_ADDR; 123045916cd2Sjpk goto error_handler; 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate if (!act) { 12337c478bd9Sstevel@tonic-gate return (NULL); 12347c478bd9Sstevel@tonic-gate } 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate sctp_unlink_faddr(sctp, nfp); 12377c478bd9Sstevel@tonic-gate /* Update all references to the deleted faddr */ 12387c478bd9Sstevel@tonic-gate if (sctp->sctp_primary == nfp) { 12397c478bd9Sstevel@tonic-gate sctp->sctp_primary = fp; 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate if (sctp->sctp_current == nfp) { 124277c67f2fSkcpoon sctp_set_faddr_current(sctp, fp); 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate if (sctp->sctp_lastdata == nfp) { 12457c478bd9Sstevel@tonic-gate sctp->sctp_lastdata = fp; 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate if (sctp->sctp_shutdown_faddr == nfp) { 12487c478bd9Sstevel@tonic-gate sctp->sctp_shutdown_faddr = nfp; 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate if (sctp->sctp_lastfaddr == nfp) { 12517c478bd9Sstevel@tonic-gate for (fp = sctp->sctp_faddrs; fp->next; fp = fp->next) 12527c478bd9Sstevel@tonic-gate ; 12537c478bd9Sstevel@tonic-gate sctp->sctp_lastfaddr = fp; 12547c478bd9Sstevel@tonic-gate } 12557c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_REMOVED, 0); 12567c478bd9Sstevel@tonic-gate } else { 12577c478bd9Sstevel@tonic-gate ASSERT(0); 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate /* Successful, don't need to return anything. */ 12617c478bd9Sstevel@tonic-gate return (NULL); 126245916cd2Sjpk 126345916cd2Sjpk error_handler: 126445916cd2Sjpk mp = sctp_asconf_adderr(err, oph, cid); 126545916cd2Sjpk if (mp == NULL) 126645916cd2Sjpk *cont = -1; 126745916cd2Sjpk return (mp); 12687c478bd9Sstevel@tonic-gate } 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate /* 12717c478bd9Sstevel@tonic-gate * Handles both add and delete IP ACKs. 12727c478bd9Sstevel@tonic-gate */ 12737c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12747c478bd9Sstevel@tonic-gate static void 12757c478bd9Sstevel@tonic-gate sctp_addip_ack(sctp_t *sctp, sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, 12761d8c4025Svi sctp_faddr_t *fp, in6_addr_t *laddr) 12777c478bd9Sstevel@tonic-gate { 12787c478bd9Sstevel@tonic-gate in6_addr_t addr; 12797c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *sp; 12807c478bd9Sstevel@tonic-gate ipaddr_t *addr4; 12817c478bd9Sstevel@tonic-gate boolean_t backout = B_FALSE; 12827c478bd9Sstevel@tonic-gate uint16_t type; 12837c478bd9Sstevel@tonic-gate uint32_t *cid; 12847c478bd9Sstevel@tonic-gate 12851d8c4025Svi /* could be an ASSERT */ 12861d8c4025Svi if (laddr != NULL) 12871d8c4025Svi IN6_IPADDR_TO_V4MAPPED(0, laddr); 12881d8c4025Svi 12897c478bd9Sstevel@tonic-gate /* If the peer doesn't understand Add-IP, remember it */ 12907c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type == htons(PARM_UNRECOGNIZED)) { 12917c478bd9Sstevel@tonic-gate sctp->sctp_understands_addip = B_FALSE; 12927c478bd9Sstevel@tonic-gate backout = B_TRUE; 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate /* 12967c478bd9Sstevel@tonic-gate * If OK, continue with the add / delete action, otherwise 12977c478bd9Sstevel@tonic-gate * back out the action. 12987c478bd9Sstevel@tonic-gate */ 12997c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type != htons(PARM_SUCCESS)) { 13007c478bd9Sstevel@tonic-gate backout = B_TRUE; 13018dfac042SAnil udupa sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph, B_TRUE); 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate type = ntohs(oph->sph_type); 13057c478bd9Sstevel@tonic-gate cid = (uint32_t *)(oph + 1); 13067c478bd9Sstevel@tonic-gate oph = (sctp_parm_hdr_t *)(cid + 1); 13077c478bd9Sstevel@tonic-gate if (oph->sph_type == htons(PARM_ADDR4)) { 13087c478bd9Sstevel@tonic-gate addr4 = (ipaddr_t *)(oph + 1); 13097c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(*addr4, &addr); 13107c478bd9Sstevel@tonic-gate } else { 13117c478bd9Sstevel@tonic-gate bcopy(oph + 1, &addr, sizeof (addr)); 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate 13141d8c4025Svi /* Signifies that the address was sucessfully processed */ 13151d8c4025Svi if (!backout && laddr != NULL) 13161d8c4025Svi *laddr = addr; 13171d8c4025Svi 13181d8c4025Svi sp = sctp_saddr_lookup(sctp, &addr, 0); 13197c478bd9Sstevel@tonic-gate ASSERT(sp != NULL); 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate if (type == PARM_ADD_IP) { 13227c478bd9Sstevel@tonic-gate if (backout) { 13237c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp, sp); 13247c478bd9Sstevel@tonic-gate } else { 13257c478bd9Sstevel@tonic-gate sp->saddr_ipif_dontsrc = 0; 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate } else if (type == PARM_DEL_IP) { 13287c478bd9Sstevel@tonic-gate if (backout) { 13297c478bd9Sstevel@tonic-gate sp->saddr_ipif_delete_pending = 0; 13307c478bd9Sstevel@tonic-gate sp->saddr_ipif_dontsrc = 0; 13317c478bd9Sstevel@tonic-gate } else { 13327c478bd9Sstevel@tonic-gate sctp_del_saddr(sctp, sp); 13337c478bd9Sstevel@tonic-gate } 13347c478bd9Sstevel@tonic-gate } else { 13357c478bd9Sstevel@tonic-gate /* Must be either PARM_ADD_IP or PARM_DEL_IP */ 13367c478bd9Sstevel@tonic-gate ASSERT(0); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13417c478bd9Sstevel@tonic-gate static mblk_t * 13427c478bd9Sstevel@tonic-gate sctp_setprim_req(sctp_t *sctp, sctp_parm_hdr_t *ph, uint32_t cid, 13431d8c4025Svi sctp_faddr_t *fp, int *cont, int act, in6_addr_t *raddr) 13447c478bd9Sstevel@tonic-gate { 13457c478bd9Sstevel@tonic-gate mblk_t *mp; 13467c478bd9Sstevel@tonic-gate sctp_parm_hdr_t *oph; 13477c478bd9Sstevel@tonic-gate sctp_faddr_t *nfp; 13487c478bd9Sstevel@tonic-gate in6_addr_t addr; 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate *cont = 1; 13517c478bd9Sstevel@tonic-gate 13528dfac042SAnil udupa /* Does the peer understand ASCONF and Add-IP? */ 13538dfac042SAnil udupa if (!sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) { 13548dfac042SAnil udupa mp = sctp_asconf_adderr(SCTP_ERR_UNAUTHORIZED, ph, cid); 13558dfac042SAnil udupa if (mp == NULL) { 13568dfac042SAnil udupa *cont = -1; 13578dfac042SAnil udupa } 13588dfac042SAnil udupa return (mp); 13598dfac042SAnil udupa } 13608dfac042SAnil udupa 13617c478bd9Sstevel@tonic-gate /* Check input */ 13627c478bd9Sstevel@tonic-gate if (ntohs(ph->sph_len) < (sizeof (*ph) * 2)) { 13637c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, ph, cid); 13647c478bd9Sstevel@tonic-gate if (mp == NULL) { 13657c478bd9Sstevel@tonic-gate *cont = -1; 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate return (mp); 13687c478bd9Sstevel@tonic-gate } 13697c478bd9Sstevel@tonic-gate 13707c478bd9Sstevel@tonic-gate oph = ph; 13717c478bd9Sstevel@tonic-gate ph = (sctp_parm_hdr_t *)((char *)ph + sizeof (sctp_parm_hdr_t) + 13727c478bd9Sstevel@tonic-gate sizeof (cid)); 13737c478bd9Sstevel@tonic-gate mp = sctp_check_addip_addr(ph, oph, cont, cid, &addr); 13747c478bd9Sstevel@tonic-gate if (mp != NULL) { 13757c478bd9Sstevel@tonic-gate return (mp); 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate 13787c478bd9Sstevel@tonic-gate nfp = sctp_lookup_faddr(sctp, &addr); 13797c478bd9Sstevel@tonic-gate if (nfp == NULL) { 13807c478bd9Sstevel@tonic-gate /* 13817c478bd9Sstevel@tonic-gate * Peer is trying to set an address that is not 13827c478bd9Sstevel@tonic-gate * part of the association. 13837c478bd9Sstevel@tonic-gate */ 13847c478bd9Sstevel@tonic-gate dprint(1, ("setprim: addr not here: %x:%x:%x:%x\n", 13857c478bd9Sstevel@tonic-gate SCTP_PRINTADDR(addr))); 13867c478bd9Sstevel@tonic-gate mp = sctp_asconf_adderr(SCTP_ERR_BAD_MANDPARM, oph, cid); 13877c478bd9Sstevel@tonic-gate if (mp == NULL) { 13887c478bd9Sstevel@tonic-gate *cont = -1; 13897c478bd9Sstevel@tonic-gate } 13907c478bd9Sstevel@tonic-gate return (mp); 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate 13937c478bd9Sstevel@tonic-gate sctp_intf_event(sctp, addr, SCTP_ADDR_MADE_PRIM, 0); 13947c478bd9Sstevel@tonic-gate sctp->sctp_primary = nfp; 13957c478bd9Sstevel@tonic-gate if (nfp->state != SCTP_FADDRS_ALIVE || nfp == sctp->sctp_current) { 13967c478bd9Sstevel@tonic-gate return (NULL); 13977c478bd9Sstevel@tonic-gate } 139877c67f2fSkcpoon sctp_set_faddr_current(sctp, nfp); 13997c478bd9Sstevel@tonic-gate return (NULL); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14037c478bd9Sstevel@tonic-gate static void 14047c478bd9Sstevel@tonic-gate sctp_setprim_ack(sctp_t *sctp, sctp_parm_hdr_t *ph, sctp_parm_hdr_t *oph, 14051d8c4025Svi sctp_faddr_t *fp, in6_addr_t *laddr) 14067c478bd9Sstevel@tonic-gate { 14077c478bd9Sstevel@tonic-gate if (ph != NULL && ph->sph_type != htons(PARM_SUCCESS)) { 14087c478bd9Sstevel@tonic-gate /* If the peer doesn't understand Add-IP, remember it */ 14097c478bd9Sstevel@tonic-gate if (ph->sph_type == htons(PARM_UNRECOGNIZED)) { 14107c478bd9Sstevel@tonic-gate sctp->sctp_understands_addip = B_FALSE; 14117c478bd9Sstevel@tonic-gate } 14128dfac042SAnil udupa sctp_error_event(sctp, (sctp_chunk_hdr_t *)ph, B_TRUE); 14137c478bd9Sstevel@tonic-gate } 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate /* On success we do nothing */ 14167c478bd9Sstevel@tonic-gate } 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate int 14197c478bd9Sstevel@tonic-gate sctp_add_ip(sctp_t *sctp, const void *addrs, uint32_t cnt) 14207c478bd9Sstevel@tonic-gate { 14217c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 14227c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 14237c478bd9Sstevel@tonic-gate mblk_t *mp; 14247c478bd9Sstevel@tonic-gate int error = 0; 14257c478bd9Sstevel@tonic-gate int i; 14267c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 14277c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 14287c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 14297c478bd9Sstevel@tonic-gate uint16_t type = htons(PARM_ADD_IP); 14307c478bd9Sstevel@tonic-gate boolean_t v4mapped = B_FALSE; 14311d8c4025Svi sctp_cl_ainfo_t *ainfo = NULL; 1432bd670b35SErik Nordmark conn_t *connp = sctp->sctp_connp; 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 14357c478bd9Sstevel@tonic-gate if (!sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) 14367c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 14377c478bd9Sstevel@tonic-gate 14381d8c4025Svi /* 14391d8c4025Svi * On a clustered node, we need to pass this list when 14401d8c4025Svi * we get an ASCONF-ACK. We only pre-allocate memory for the 14411d8c4025Svi * list, but fill in the addresses when it is processed 14421d8c4025Svi * successfully after we get an ASCONF-ACK. 14431d8c4025Svi */ 14441d8c4025Svi if (cl_sctp_assoc_change != NULL) { 14451d8c4025Svi ainfo = kmem_zalloc(sizeof (*ainfo), KM_SLEEP); 14461d8c4025Svi /* 14471d8c4025Svi * Reserve space for the list of new addresses 14481d8c4025Svi */ 14491d8c4025Svi ainfo->sctp_cl_asize = sizeof (in6_addr_t) * cnt; 14501d8c4025Svi ainfo->sctp_cl_alist = kmem_alloc(ainfo->sctp_cl_asize, 14511d8c4025Svi KM_SLEEP); 14521d8c4025Svi } 14531d8c4025Svi 14547c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate /* 14577c478bd9Sstevel@tonic-gate * Screen addresses: 14587c478bd9Sstevel@tonic-gate * If adding: 14597c478bd9Sstevel@tonic-gate * o Must not already be a part of the association 14607c478bd9Sstevel@tonic-gate * o Must be AF_INET or AF_INET6 14617c478bd9Sstevel@tonic-gate * o XXX Must be valid source address for this node 14627c478bd9Sstevel@tonic-gate * o Must be unicast 14637c478bd9Sstevel@tonic-gate * o XXX Must fit scoping rules 14647c478bd9Sstevel@tonic-gate * If deleting: 14657c478bd9Sstevel@tonic-gate * o Must be part of the association 14667c478bd9Sstevel@tonic-gate */ 14677c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 1468bd670b35SErik Nordmark switch (connp->conn_family) { 14697c478bd9Sstevel@tonic-gate case AF_INET: 14707c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 14717c478bd9Sstevel@tonic-gate v4mapped = B_TRUE; 14727c478bd9Sstevel@tonic-gate break; 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate case AF_INET6: 14757c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 14767c478bd9Sstevel@tonic-gate break; 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate if (v4mapped) { 14807c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 14817c478bd9Sstevel@tonic-gate if (mp == NULL) { 14827c478bd9Sstevel@tonic-gate error = ENOMEM; 14837c478bd9Sstevel@tonic-gate goto fail; 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 14867c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 14877c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = type; 14887c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = 14897c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 14907c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 14917c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 14927c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 14937c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin4->sin_addr.s_addr; 14947c478bd9Sstevel@tonic-gate } else { 14957c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 14967c478bd9Sstevel@tonic-gate if (mp == NULL) { 14977c478bd9Sstevel@tonic-gate error = ENOMEM; 14987c478bd9Sstevel@tonic-gate goto fail; 14997c478bd9Sstevel@tonic-gate } 15007c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 15017c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 15027c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = type; 15037c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = 15047c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 15057c478bd9Sstevel@tonic-gate PARM_ADDR6_LEN + sizeof (ad6->asconf_req_cid)); 15067c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 15077c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 15087c478bd9Sstevel@tonic-gate ad6->sad6_addr = sin6->sin6_addr; 15097c478bd9Sstevel@tonic-gate } 15107c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 15117c478bd9Sstevel@tonic-gate if (error != 0) 15127c478bd9Sstevel@tonic-gate goto fail; 15137c478bd9Sstevel@tonic-gate } 15141d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, ainfo); 15157c478bd9Sstevel@tonic-gate if (error != 0) 15167c478bd9Sstevel@tonic-gate goto fail; 15177c478bd9Sstevel@tonic-gate 15187c478bd9Sstevel@tonic-gate return (0); 15197c478bd9Sstevel@tonic-gate 15207c478bd9Sstevel@tonic-gate fail: 15211d8c4025Svi if (ainfo != NULL) { 15221d8c4025Svi kmem_free(ainfo->sctp_cl_alist, ainfo->sctp_cl_asize); 15231d8c4025Svi ainfo->sctp_cl_asize = 0; 15241d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 15251d8c4025Svi } 15267c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 15277c478bd9Sstevel@tonic-gate return (error); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate int 15311d8c4025Svi sctp_del_ip(sctp_t *sctp, const void *addrs, uint32_t cnt, uchar_t *ulist, 15321d8c4025Svi size_t usize) 15337c478bd9Sstevel@tonic-gate { 15347c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 15357c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 15367c478bd9Sstevel@tonic-gate mblk_t *mp; 15377c478bd9Sstevel@tonic-gate int error = 0; 15387c478bd9Sstevel@tonic-gate int i; 15397c478bd9Sstevel@tonic-gate int addrcnt = 0; 15407c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 15417c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 15427c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 15437c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *nsp; 15447c478bd9Sstevel@tonic-gate uint16_t type = htons(PARM_DEL_IP); 15457c478bd9Sstevel@tonic-gate boolean_t v4mapped = B_FALSE; 15467c478bd9Sstevel@tonic-gate in6_addr_t addr; 15477c478bd9Sstevel@tonic-gate boolean_t asconf = B_TRUE; 15481d8c4025Svi uint_t ifindex; 15491d8c4025Svi sctp_cl_ainfo_t *ainfo = NULL; 15501d8c4025Svi uchar_t *p = ulist; 15511d8c4025Svi boolean_t check_lport = B_FALSE; 1552f4b3ec61Sdh sctp_stack_t *sctps = sctp->sctp_sctps; 1553bd670b35SErik Nordmark conn_t *connp = sctp->sctp_connp; 15547c478bd9Sstevel@tonic-gate 15557c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 1556f4b3ec61Sdh if (sctp->sctp_state <= SCTPS_LISTEN || !sctps->sctps_addip_enabled || 15577c478bd9Sstevel@tonic-gate !sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) { 15587c478bd9Sstevel@tonic-gate asconf = B_FALSE; 15597c478bd9Sstevel@tonic-gate } 15607c478bd9Sstevel@tonic-gate 15611d8c4025Svi if (sctp->sctp_state > SCTPS_BOUND) 15621d8c4025Svi check_lport = B_TRUE; 15631d8c4025Svi 15641d8c4025Svi if (asconf) { 15651d8c4025Svi /* 15661d8c4025Svi * On a clustered node, we need to pass this list when 15671d8c4025Svi * we get an ASCONF-ACK. We only pre-allocate memory for the 15681d8c4025Svi * list, but fill in the addresses when it is processed 15691d8c4025Svi * successfully after we get an ASCONF-ACK. 15701d8c4025Svi */ 15711d8c4025Svi if (cl_sctp_assoc_change != NULL) { 15721d8c4025Svi ainfo = kmem_alloc(sizeof (*ainfo), KM_SLEEP); 15731d8c4025Svi ainfo->sctp_cl_dsize = sizeof (in6_addr_t) * cnt; 15741d8c4025Svi ainfo->sctp_cl_dlist = kmem_alloc(ainfo->sctp_cl_dsize, 15751d8c4025Svi KM_SLEEP); 15761d8c4025Svi } 15777c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 15781d8c4025Svi } 15797c478bd9Sstevel@tonic-gate /* 15807c478bd9Sstevel@tonic-gate * Screen addresses: 15817c478bd9Sstevel@tonic-gate * If adding: 15827c478bd9Sstevel@tonic-gate * o Must not already be a part of the association 15837c478bd9Sstevel@tonic-gate * o Must be AF_INET or AF_INET6 15847c478bd9Sstevel@tonic-gate * o XXX Must be valid source address for this node 15857c478bd9Sstevel@tonic-gate * o Must be unicast 15867c478bd9Sstevel@tonic-gate * o XXX Must fit scoping rules 15877c478bd9Sstevel@tonic-gate * If deleting: 15887c478bd9Sstevel@tonic-gate * o Must be part of the association 15897c478bd9Sstevel@tonic-gate */ 15907c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 15911d8c4025Svi ifindex = 0; 15921d8c4025Svi 1593bd670b35SErik Nordmark switch (connp->conn_family) { 15947c478bd9Sstevel@tonic-gate case AF_INET: 15957c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 1596bd670b35SErik Nordmark if (check_lport && 1597bd670b35SErik Nordmark sin4->sin_port != connp->conn_lport) { 15981d8c4025Svi error = EINVAL; 15991d8c4025Svi goto fail; 16001d8c4025Svi } 16017c478bd9Sstevel@tonic-gate v4mapped = B_TRUE; 16027c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(sin4->sin_addr.s_addr, &addr); 16037c478bd9Sstevel@tonic-gate break; 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate case AF_INET6: 16067c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 16071d8c4025Svi if (check_lport && 1608bd670b35SErik Nordmark sin6->sin6_port != connp->conn_lport) { 16091d8c4025Svi error = EINVAL; 16101d8c4025Svi goto fail; 16111d8c4025Svi } 16127c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 16131d8c4025Svi ifindex = sin6->sin6_scope_id; 16147c478bd9Sstevel@tonic-gate break; 16157c478bd9Sstevel@tonic-gate } 16161d8c4025Svi nsp = sctp_saddr_lookup(sctp, &addr, ifindex); 16177c478bd9Sstevel@tonic-gate if (nsp == NULL) { 16187c478bd9Sstevel@tonic-gate error = EADDRNOTAVAIL; 16197c478bd9Sstevel@tonic-gate goto fail; 16207c478bd9Sstevel@tonic-gate } 16217c478bd9Sstevel@tonic-gate 16221d8c4025Svi /* Collect the list of addresses, if required */ 16231d8c4025Svi if (usize >= sizeof (addr)) { 16241d8c4025Svi bcopy(&addr, p, sizeof (addr)); 16251d8c4025Svi p += sizeof (addr); 16261d8c4025Svi usize -= sizeof (addr); 16271d8c4025Svi } 16287c478bd9Sstevel@tonic-gate if (!asconf) 16297c478bd9Sstevel@tonic-gate continue; 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate nsp->saddr_ipif_delete_pending = 1; 16327c478bd9Sstevel@tonic-gate nsp->saddr_ipif_dontsrc = 1; 16337c478bd9Sstevel@tonic-gate addrcnt++; 16347c478bd9Sstevel@tonic-gate if (v4mapped) { 16357c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 16367c478bd9Sstevel@tonic-gate if (mp == NULL) { 16377c478bd9Sstevel@tonic-gate error = ENOMEM; 16387c478bd9Sstevel@tonic-gate goto fail; 16397c478bd9Sstevel@tonic-gate } 16407c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 16417c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 16427c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = type; 16437c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = 16447c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + 16457c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 16467c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 16477c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 16487c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin4->sin_addr.s_addr; 16497c478bd9Sstevel@tonic-gate } else { 16507c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 16517c478bd9Sstevel@tonic-gate if (mp == NULL) { 16527c478bd9Sstevel@tonic-gate error = ENOMEM; 16537c478bd9Sstevel@tonic-gate goto fail; 16547c478bd9Sstevel@tonic-gate } 16557c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 16567c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 16577c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = type; 16587c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = 16597c478bd9Sstevel@tonic-gate htons(sizeof (sctp_parm_hdr_t) + PARM_ADDR6_LEN + 16607c478bd9Sstevel@tonic-gate sizeof (ad6->asconf_req_cid)); 16617c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 16627c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 16637c478bd9Sstevel@tonic-gate ad6->sad6_addr = addr; 16647c478bd9Sstevel@tonic-gate } 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 16677c478bd9Sstevel@tonic-gate if (error != 0) 16687c478bd9Sstevel@tonic-gate goto fail; 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate if (!asconf) { 16727c478bd9Sstevel@tonic-gate sctp_del_saddr_list(sctp, addrs, cnt, B_FALSE); 16737c478bd9Sstevel@tonic-gate return (0); 16747c478bd9Sstevel@tonic-gate } 16751d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, ainfo); 16767c478bd9Sstevel@tonic-gate if (error != 0) 16777c478bd9Sstevel@tonic-gate goto fail; 16787c478bd9Sstevel@tonic-gate sctp_redo_faddr_srcs(sctp); 16797c478bd9Sstevel@tonic-gate return (0); 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate fail: 16821d8c4025Svi if (ainfo != NULL) { 16831d8c4025Svi kmem_free(ainfo->sctp_cl_dlist, ainfo->sctp_cl_dsize); 16841d8c4025Svi ainfo->sctp_cl_dsize = 0; 16851d8c4025Svi kmem_free(ainfo, sizeof (*ainfo)); 16861d8c4025Svi } 16877c478bd9Sstevel@tonic-gate if (!asconf) 16887c478bd9Sstevel@tonic-gate return (error); 16897c478bd9Sstevel@tonic-gate for (i = 0; i < addrcnt; i++) { 16901d8c4025Svi ifindex = 0; 16911d8c4025Svi 1692bd670b35SErik Nordmark switch (connp->conn_family) { 16937c478bd9Sstevel@tonic-gate case AF_INET: 16947c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)addrs + i; 16957c478bd9Sstevel@tonic-gate IN6_INADDR_TO_V4MAPPED(&(sin4->sin_addr), &addr); 16967c478bd9Sstevel@tonic-gate break; 16977c478bd9Sstevel@tonic-gate case AF_INET6: 16987c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)addrs + i; 16997c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 17001d8c4025Svi ifindex = sin6->sin6_scope_id; 17017c478bd9Sstevel@tonic-gate break; 17027c478bd9Sstevel@tonic-gate } 17031d8c4025Svi nsp = sctp_saddr_lookup(sctp, &addr, ifindex); 17047c478bd9Sstevel@tonic-gate ASSERT(nsp != NULL); 17057c478bd9Sstevel@tonic-gate nsp->saddr_ipif_delete_pending = 0; 17067c478bd9Sstevel@tonic-gate nsp->saddr_ipif_dontsrc = 0; 17077c478bd9Sstevel@tonic-gate } 17087c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 17097c478bd9Sstevel@tonic-gate 17107c478bd9Sstevel@tonic-gate return (error); 17117c478bd9Sstevel@tonic-gate } 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate int 1714bd670b35SErik Nordmark sctp_set_peerprim(sctp_t *sctp, const void *inp) 17157c478bd9Sstevel@tonic-gate { 17167c478bd9Sstevel@tonic-gate const struct sctp_setprim *prim = inp; 17177c478bd9Sstevel@tonic-gate const struct sockaddr_storage *ss; 17187c478bd9Sstevel@tonic-gate struct sockaddr_in *sin; 17197c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 17207c478bd9Sstevel@tonic-gate in6_addr_t addr; 17217c478bd9Sstevel@tonic-gate mblk_t *mp; 17227c478bd9Sstevel@tonic-gate sctp_saddr_ipif_t *sp; 17237c478bd9Sstevel@tonic-gate sctp_addip4_t *ad4; 17247c478bd9Sstevel@tonic-gate sctp_addip6_t *ad6; 17257c478bd9Sstevel@tonic-gate sctp_asconf_t asc[1]; 17267c478bd9Sstevel@tonic-gate int error = 0; 17271d8c4025Svi uint_t ifindex = 0; 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate /* Does the peer understand ASCONF and Add-IP? */ 17307c478bd9Sstevel@tonic-gate if (!sctp->sctp_understands_asconf || !sctp->sctp_understands_addip) { 17317c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate 17347c478bd9Sstevel@tonic-gate /* Don't do anything if we are not connected */ 17357c478bd9Sstevel@tonic-gate if (sctp->sctp_state != SCTPS_ESTABLISHED) 17367c478bd9Sstevel@tonic-gate return (EINVAL); 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate ss = &prim->ssp_addr; 17397c478bd9Sstevel@tonic-gate sin = NULL; 17407c478bd9Sstevel@tonic-gate sin6 = NULL; 17417c478bd9Sstevel@tonic-gate if (ss->ss_family == AF_INET) { 17427c478bd9Sstevel@tonic-gate sin = (struct sockaddr_in *)ss; 17437c478bd9Sstevel@tonic-gate IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &addr); 17447c478bd9Sstevel@tonic-gate } else if (ss->ss_family == AF_INET6) { 17457c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)ss; 17467c478bd9Sstevel@tonic-gate addr = sin6->sin6_addr; 17471d8c4025Svi ifindex = sin6->sin6_scope_id; 17487c478bd9Sstevel@tonic-gate } else { 17497c478bd9Sstevel@tonic-gate return (EAFNOSUPPORT); 17507c478bd9Sstevel@tonic-gate } 17511d8c4025Svi sp = sctp_saddr_lookup(sctp, &addr, ifindex); 17527c478bd9Sstevel@tonic-gate if (sp == NULL) 17537c478bd9Sstevel@tonic-gate return (EADDRNOTAVAIL); 17547c478bd9Sstevel@tonic-gate sctp_asconf_init(asc); 17557c478bd9Sstevel@tonic-gate if (sin) { 17567c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad4), BPRI_MED); 17577c478bd9Sstevel@tonic-gate if (mp == NULL) { 17587c478bd9Sstevel@tonic-gate error = ENOMEM; 17597c478bd9Sstevel@tonic-gate goto fail; 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad4); 17627c478bd9Sstevel@tonic-gate ad4 = (sctp_addip4_t *)mp->b_rptr; 17637c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_type = htons(PARM_SET_PRIMARY); 17647c478bd9Sstevel@tonic-gate ad4->sad4_addip_ph.sph_len = htons(sizeof (sctp_parm_hdr_t) + 17657c478bd9Sstevel@tonic-gate PARM_ADDR4_LEN + sizeof (ad4->asconf_req_cid)); 17667c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_type = htons(PARM_ADDR4); 17677c478bd9Sstevel@tonic-gate ad4->sad4_addr4_ph.sph_len = htons(PARM_ADDR4_LEN); 17687c478bd9Sstevel@tonic-gate ad4->sad4_addr = sin->sin_addr.s_addr; 17697c478bd9Sstevel@tonic-gate } else { 17707c478bd9Sstevel@tonic-gate mp = allocb(sizeof (*ad6), BPRI_MED); 17717c478bd9Sstevel@tonic-gate if (mp == NULL) { 17727c478bd9Sstevel@tonic-gate error = ENOMEM; 17737c478bd9Sstevel@tonic-gate goto fail; 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (*ad6); 17767c478bd9Sstevel@tonic-gate ad6 = (sctp_addip6_t *)mp->b_rptr; 17777c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_type = htons(PARM_SET_PRIMARY); 17787c478bd9Sstevel@tonic-gate ad6->sad6_addip_ph.sph_len = htons(sizeof (sctp_parm_hdr_t) + 17797c478bd9Sstevel@tonic-gate PARM_ADDR6_LEN + sizeof (ad6->asconf_req_cid)); 17807c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_type = htons(PARM_ADDR6); 17817c478bd9Sstevel@tonic-gate ad6->sad6_addr6_ph.sph_len = htons(PARM_ADDR6_LEN); 17827c478bd9Sstevel@tonic-gate ad6->sad6_addr = sin6->sin6_addr; 17837c478bd9Sstevel@tonic-gate } 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate error = sctp_asconf_add(asc, mp); 17867c478bd9Sstevel@tonic-gate if (error != 0) { 17877c478bd9Sstevel@tonic-gate goto fail; 17887c478bd9Sstevel@tonic-gate } 17897c478bd9Sstevel@tonic-gate 17901d8c4025Svi error = sctp_asconf_send(sctp, asc, sctp->sctp_current, NULL); 17917c478bd9Sstevel@tonic-gate if (error == 0) { 17927c478bd9Sstevel@tonic-gate return (0); 17937c478bd9Sstevel@tonic-gate } 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate fail: 17967c478bd9Sstevel@tonic-gate sctp_asconf_destroy(asc); 17977c478bd9Sstevel@tonic-gate return (error); 17987c478bd9Sstevel@tonic-gate } 1799