1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/stream.h> 31 #include <sys/ddi.h> 32 #include <sys/sunddi.h> 33 34 #include <netinet/in.h> 35 #include <netinet/ip6.h> 36 37 #include <inet/common.h> 38 #include <inet/ipclassifier.h> 39 #include <inet/ip.h> 40 #include <inet/ip6.h> 41 #include <inet/mib2.h> 42 #include <inet/nd.h> 43 #include <inet/optcom.h> 44 #include "sctp_impl.h" 45 #include "sctp_addr.h" 46 47 /* 48 * This will compute the checksum over the SCTP packet, so this 49 * function should only be called after the whole packet has been 50 * built. 51 * 52 * rptr should point to the IP / SCTP composite header. 53 * len should be the length of the entire packet, including the IP 54 * header. 55 */ 56 void 57 sctp_add_hdr(sctp_t *sctp, uchar_t *rptr, size_t len) 58 { 59 ipha_t *iphdr; 60 short iplen; 61 62 ASSERT(len >= sctp->sctp_hdr_len); 63 64 /* Copy the common header from the template */ 65 bcopy(sctp->sctp_iphc, rptr, sctp->sctp_hdr_len); 66 67 /* Set the total length in the IP hdr */ 68 iplen = (short)len; 69 iphdr = (ipha_t *)rptr; 70 U16_TO_ABE16(iplen, &iphdr->ipha_length); 71 } 72 73 /*ARGSUSED*/ 74 size_t 75 sctp_supaddr_param_len(sctp_t *sctp) 76 { 77 return (sizeof (sctp_parm_hdr_t) + sizeof (int32_t)); 78 } 79 80 size_t 81 sctp_supaddr_param(sctp_t *sctp, uchar_t *p) 82 { 83 sctp_parm_hdr_t *sph; 84 uint16_t *addrtype; 85 86 sph = (sctp_parm_hdr_t *)p; 87 sph->sph_type = htons(PARM_SUPP_ADDRS); 88 addrtype = (uint16_t *)(sph + 1); 89 switch (sctp->sctp_ipversion) { 90 case IPV4_VERSION: 91 *addrtype++ = htons(PARM_ADDR4); 92 *addrtype = 0; 93 sph->sph_len = htons(sizeof (*sph) + sizeof (*addrtype)); 94 break; 95 case IPV6_VERSION: 96 *addrtype++ = htons(PARM_ADDR6); 97 if (!sctp->sctp_connp->conn_ipv6_v6only) { 98 *addrtype = htons(PARM_ADDR4); 99 sph->sph_len = htons(sizeof (*sph) + 100 sizeof (*addrtype) * 2); 101 } else { 102 *addrtype = 0; 103 sph->sph_len = htons(sizeof (*sph) + 104 sizeof (*addrtype)); 105 } 106 break; 107 default: 108 break; 109 } 110 return (sizeof (*sph) + (sizeof (*addrtype) * 2)); 111 } 112 113 /* 114 * Currently, we support on PRSCTP option, there is more to come. 115 */ 116 /*ARGSUSED*/ 117 size_t 118 sctp_options_param_len(const sctp_t *sctp, int option) 119 { 120 size_t optlen; 121 122 switch (option) { 123 case SCTP_PRSCTP_OPTION: 124 optlen = sizeof (sctp_parm_hdr_t); 125 break; 126 default: 127 ASSERT(0); 128 } 129 130 return (optlen); 131 } 132 133 /*ARGSUSED*/ 134 size_t 135 sctp_options_param(const sctp_t *sctp, void *p, int option) 136 { 137 sctp_parm_hdr_t *sph = (sctp_parm_hdr_t *)p; 138 139 switch (option) { 140 case SCTP_PRSCTP_OPTION: 141 sph->sph_type = htons(PARM_FORWARD_TSN); 142 sph->sph_len = htons(sizeof (*sph)); 143 break; 144 default: 145 ASSERT(0); 146 } 147 148 return (sizeof (*sph)); 149 150 } 151 152 size_t 153 sctp_adaption_code_param(sctp_t *sctp, uchar_t *p) 154 { 155 sctp_parm_hdr_t *sph; 156 157 if (!sctp->sctp_send_adaption) { 158 return (0); 159 } 160 sph = (sctp_parm_hdr_t *)p; 161 sph->sph_type = htons(PARM_ADAPT_LAYER_IND); 162 sph->sph_len = htons(sizeof (*sph) + sizeof (uint32_t)); 163 *(uint32_t *)(sph + 1) = htonl(sctp->sctp_tx_adaption_code); 164 165 return (sizeof (*sph) + sizeof (uint32_t)); 166 } 167 168 mblk_t * 169 sctp_init_mp(sctp_t *sctp) 170 { 171 mblk_t *mp; 172 uchar_t *p; 173 size_t initlen; 174 sctp_init_chunk_t *icp; 175 sctp_chunk_hdr_t *chp; 176 uint16_t schlen; 177 int supp_af; 178 179 if (sctp->sctp_family == AF_INET) { 180 supp_af = PARM_SUPP_V4; 181 } else { 182 /* Assume here that a v6 endpoint supports v4 address. */ 183 if (sctp->sctp_connp->conn_ipv6_v6only) 184 supp_af = PARM_SUPP_V6; 185 else 186 supp_af = PARM_SUPP_V6 | PARM_SUPP_V4; 187 } 188 initlen = sizeof (*chp) + sizeof (*icp); 189 if (sctp->sctp_send_adaption) { 190 initlen += (sizeof (sctp_parm_hdr_t) + sizeof (uint32_t)); 191 } 192 initlen += sctp_supaddr_param_len(sctp); 193 initlen += sctp_addr_params_len(sctp, supp_af, B_TRUE); 194 if (sctp->sctp_prsctp_aware && sctp_prsctp_enabled) 195 initlen += sctp_options_param_len(sctp, SCTP_PRSCTP_OPTION); 196 197 /* 198 * This could be a INIT retransmission in which case sh_verf may 199 * be non-zero, zero it out just to be sure. 200 */ 201 sctp->sctp_sctph->sh_verf = 0; 202 sctp->sctp_sctph6->sh_verf = 0; 203 204 mp = sctp_make_mp(sctp, NULL, initlen); 205 if (mp == NULL) 206 return (NULL); 207 208 /* Lay in a new INIT chunk, starting with the chunk header */ 209 chp = (sctp_chunk_hdr_t *)mp->b_wptr; 210 chp->sch_id = CHUNK_INIT; 211 chp->sch_flags = 0; 212 schlen = (uint16_t)initlen; 213 U16_TO_ABE16(schlen, &(chp->sch_len)); 214 215 mp->b_wptr += initlen; 216 217 icp = (sctp_init_chunk_t *)(chp + 1); 218 icp->sic_inittag = sctp->sctp_lvtag; 219 U32_TO_ABE32(sctp->sctp_rwnd, &(icp->sic_a_rwnd)); 220 U16_TO_ABE16(sctp->sctp_num_ostr, &(icp->sic_outstr)); 221 U16_TO_ABE16(sctp->sctp_num_istr, &(icp->sic_instr)); 222 U32_TO_ABE32(sctp->sctp_ltsn, &(icp->sic_inittsn)); 223 224 p = (uchar_t *)(icp + 1); 225 226 /* Adaption layer param */ 227 p += sctp_adaption_code_param(sctp, p); 228 229 /* Add supported address types parameter */ 230 p += sctp_supaddr_param(sctp, p); 231 232 /* Add address parameters */ 233 p += sctp_addr_params(sctp, supp_af, p); 234 235 /* Add Forward-TSN-Supported param */ 236 if (sctp->sctp_prsctp_aware && sctp_prsctp_enabled) 237 p += sctp_options_param(sctp, p, SCTP_PRSCTP_OPTION); 238 239 BUMP_LOCAL(sctp->sctp_obchunks); 240 241 sctp_set_iplen(sctp, mp); 242 243 return (mp); 244 } 245 246 /* 247 * Extracts the verification tag from an INIT chunk. If the INIT 248 * chunk is truncated or malformed, returns 0. 249 */ 250 uint32_t 251 sctp_init2vtag(sctp_chunk_hdr_t *initch) 252 { 253 sctp_init_chunk_t *init; 254 255 init = (sctp_init_chunk_t *)(initch + 1); 256 return (init->sic_inittag); 257 } 258 259 size_t 260 sctp_addr_params_len(sctp_t *sctp, int af, boolean_t modify) 261 { 262 ASSERT(sctp->sctp_nsaddrs > 0); 263 264 /* 265 * If we have only one local address or it is a loopback or linklocal 266 * association, we let the peer pull the address from the IP header. 267 */ 268 if (sctp->sctp_nsaddrs == 1 || sctp->sctp_loopback || 269 sctp->sctp_linklocal) { 270 return (0); 271 } 272 273 return (sctp_saddr_info(sctp, af, NULL, modify)); 274 } 275 276 size_t 277 sctp_addr_params(sctp_t *sctp, int af, uchar_t *p) 278 { 279 /* 280 * If we have only one local address or it is a loopback or linklocal 281 * association, we let the peer pull the address from the IP header. 282 */ 283 if (sctp->sctp_nsaddrs == 1 || sctp->sctp_loopback || 284 sctp->sctp_linklocal) { 285 return (0); 286 } 287 return (sctp_saddr_info(sctp, af, p, B_FALSE)); 288 } 289