1 /* SCTP kernel implementation 2 * (C) Copyright IBM Corp. 2001, 2003 3 * Copyright (c) Cisco 1999,2000 4 * Copyright (c) Motorola 1999,2000,2001 5 * Copyright (c) La Monte H.P. Yarroll 2001 6 * 7 * This file is part of the SCTP kernel implementation. 8 * 9 * A collection class to handle the storage of transport addresses. 10 * 11 * This SCTP implementation is free software; 12 * you can redistribute it and/or modify it under the terms of 13 * the GNU General Public License as published by 14 * the Free Software Foundation; either version 2, or (at your option) 15 * any later version. 16 * 17 * This SCTP implementation is distributed in the hope that it 18 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 19 * ************************ 20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 21 * See the GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with GNU CC; see the file COPYING. If not, write to 25 * the Free Software Foundation, 59 Temple Place - Suite 330, 26 * Boston, MA 02111-1307, USA. 27 * 28 * Please send any bug reports or fixes you make to the 29 * email address(es): 30 * lksctp developers <lksctp-developers@lists.sourceforge.net> 31 * 32 * Or submit a bug report through the following website: 33 * http://www.sf.net/projects/lksctp 34 * 35 * Written or modified by: 36 * La Monte H.P. Yarroll <piggy@acm.org> 37 * Karl Knutson <karl@athena.chicago.il.us> 38 * Jon Grimm <jgrimm@us.ibm.com> 39 * Daisy Chang <daisyc@us.ibm.com> 40 * 41 * Any bugs reported given to us we will try to fix... any fixes shared will 42 * be incorporated into the next SCTP release. 43 */ 44 45 #include <linux/types.h> 46 #include <linux/slab.h> 47 #include <linux/in.h> 48 #include <net/sock.h> 49 #include <net/ipv6.h> 50 #include <net/if_inet6.h> 51 #include <net/sctp/sctp.h> 52 #include <net/sctp/sm.h> 53 54 /* Forward declarations for internal helpers. */ 55 static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *, 56 sctp_scope_t scope, gfp_t gfp, 57 int flags); 58 static void sctp_bind_addr_clean(struct sctp_bind_addr *); 59 60 /* First Level Abstractions. */ 61 62 /* Copy 'src' to 'dest' taking 'scope' into account. Omit addresses 63 * in 'src' which have a broader scope than 'scope'. 64 */ 65 int sctp_bind_addr_copy(struct sctp_bind_addr *dest, 66 const struct sctp_bind_addr *src, 67 sctp_scope_t scope, gfp_t gfp, 68 int flags) 69 { 70 struct sctp_sockaddr_entry *addr; 71 int error = 0; 72 73 /* All addresses share the same port. */ 74 dest->port = src->port; 75 76 /* Extract the addresses which are relevant for this scope. */ 77 list_for_each_entry(addr, &src->address_list, list) { 78 error = sctp_copy_one_addr(dest, &addr->a, scope, 79 gfp, flags); 80 if (error < 0) 81 goto out; 82 } 83 84 /* If there are no addresses matching the scope and 85 * this is global scope, try to get a link scope address, with 86 * the assumption that we must be sitting behind a NAT. 87 */ 88 if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) { 89 list_for_each_entry(addr, &src->address_list, list) { 90 error = sctp_copy_one_addr(dest, &addr->a, 91 SCTP_SCOPE_LINK, gfp, 92 flags); 93 if (error < 0) 94 goto out; 95 } 96 } 97 98 out: 99 if (error) 100 sctp_bind_addr_clean(dest); 101 102 return error; 103 } 104 105 /* Exactly duplicate the address lists. This is necessary when doing 106 * peer-offs and accepts. We don't want to put all the current system 107 * addresses into the endpoint. That's useless. But we do want duplicat 108 * the list of bound addresses that the older endpoint used. 109 */ 110 int sctp_bind_addr_dup(struct sctp_bind_addr *dest, 111 const struct sctp_bind_addr *src, 112 gfp_t gfp) 113 { 114 struct sctp_sockaddr_entry *addr; 115 int error = 0; 116 117 /* All addresses share the same port. */ 118 dest->port = src->port; 119 120 list_for_each_entry(addr, &src->address_list, list) { 121 error = sctp_add_bind_addr(dest, &addr->a, 1, gfp); 122 if (error < 0) 123 break; 124 } 125 126 return error; 127 } 128 129 /* Initialize the SCTP_bind_addr structure for either an endpoint or 130 * an association. 131 */ 132 void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port) 133 { 134 bp->malloced = 0; 135 136 INIT_LIST_HEAD(&bp->address_list); 137 bp->port = port; 138 } 139 140 /* Dispose of the address list. */ 141 static void sctp_bind_addr_clean(struct sctp_bind_addr *bp) 142 { 143 struct sctp_sockaddr_entry *addr; 144 struct list_head *pos, *temp; 145 146 /* Empty the bind address list. */ 147 list_for_each_safe(pos, temp, &bp->address_list) { 148 addr = list_entry(pos, struct sctp_sockaddr_entry, list); 149 list_del(pos); 150 kfree(addr); 151 SCTP_DBG_OBJCNT_DEC(addr); 152 } 153 } 154 155 /* Dispose of an SCTP_bind_addr structure */ 156 void sctp_bind_addr_free(struct sctp_bind_addr *bp) 157 { 158 /* Empty the bind address list. */ 159 sctp_bind_addr_clean(bp); 160 161 if (bp->malloced) { 162 kfree(bp); 163 SCTP_DBG_OBJCNT_DEC(bind_addr); 164 } 165 } 166 167 /* Add an address to the bind address list in the SCTP_bind_addr structure. */ 168 int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new, 169 __u8 addr_state, gfp_t gfp) 170 { 171 struct sctp_sockaddr_entry *addr; 172 173 /* Add the address to the bind address list. */ 174 addr = t_new(struct sctp_sockaddr_entry, gfp); 175 if (!addr) 176 return -ENOMEM; 177 178 memcpy(&addr->a, new, sizeof(*new)); 179 180 /* Fix up the port if it has not yet been set. 181 * Both v4 and v6 have the port at the same offset. 182 */ 183 if (!addr->a.v4.sin_port) 184 addr->a.v4.sin_port = htons(bp->port); 185 186 addr->state = addr_state; 187 addr->valid = 1; 188 189 INIT_LIST_HEAD(&addr->list); 190 191 /* We always hold a socket lock when calling this function, 192 * and that acts as a writer synchronizing lock. 193 */ 194 list_add_tail_rcu(&addr->list, &bp->address_list); 195 SCTP_DBG_OBJCNT_INC(addr); 196 197 return 0; 198 } 199 200 /* Delete an address from the bind address list in the SCTP_bind_addr 201 * structure. 202 */ 203 int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr) 204 { 205 struct sctp_sockaddr_entry *addr, *temp; 206 int found = 0; 207 208 /* We hold the socket lock when calling this function, 209 * and that acts as a writer synchronizing lock. 210 */ 211 list_for_each_entry_safe(addr, temp, &bp->address_list, list) { 212 if (sctp_cmp_addr_exact(&addr->a, del_addr)) { 213 /* Found the exact match. */ 214 found = 1; 215 addr->valid = 0; 216 list_del_rcu(&addr->list); 217 break; 218 } 219 } 220 221 if (found) { 222 call_rcu(&addr->rcu, sctp_local_addr_free); 223 SCTP_DBG_OBJCNT_DEC(addr); 224 return 0; 225 } 226 227 return -EINVAL; 228 } 229 230 /* Create a network byte-order representation of all the addresses 231 * formated as SCTP parameters. 232 * 233 * The second argument is the return value for the length. 234 */ 235 union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp, 236 int *addrs_len, 237 gfp_t gfp) 238 { 239 union sctp_params addrparms; 240 union sctp_params retval; 241 int addrparms_len; 242 union sctp_addr_param rawaddr; 243 int len; 244 struct sctp_sockaddr_entry *addr; 245 struct list_head *pos; 246 struct sctp_af *af; 247 248 addrparms_len = 0; 249 len = 0; 250 251 /* Allocate enough memory at once. */ 252 list_for_each(pos, &bp->address_list) { 253 len += sizeof(union sctp_addr_param); 254 } 255 256 /* Don't even bother embedding an address if there 257 * is only one. 258 */ 259 if (len == sizeof(union sctp_addr_param)) { 260 retval.v = NULL; 261 goto end_raw; 262 } 263 264 retval.v = kmalloc(len, gfp); 265 if (!retval.v) 266 goto end_raw; 267 268 addrparms = retval; 269 270 list_for_each_entry(addr, &bp->address_list, list) { 271 af = sctp_get_af_specific(addr->a.v4.sin_family); 272 len = af->to_addr_param(&addr->a, &rawaddr); 273 memcpy(addrparms.v, &rawaddr, len); 274 addrparms.v += len; 275 addrparms_len += len; 276 } 277 278 end_raw: 279 *addrs_len = addrparms_len; 280 return retval; 281 } 282 283 /* 284 * Create an address list out of the raw address list format (IPv4 and IPv6 285 * address parameters). 286 */ 287 int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list, 288 int addrs_len, __u16 port, gfp_t gfp) 289 { 290 union sctp_addr_param *rawaddr; 291 struct sctp_paramhdr *param; 292 union sctp_addr addr; 293 int retval = 0; 294 int len; 295 struct sctp_af *af; 296 297 /* Convert the raw address to standard address format */ 298 while (addrs_len) { 299 param = (struct sctp_paramhdr *)raw_addr_list; 300 rawaddr = (union sctp_addr_param *)raw_addr_list; 301 302 af = sctp_get_af_specific(param_type2af(param->type)); 303 if (unlikely(!af)) { 304 retval = -EINVAL; 305 sctp_bind_addr_clean(bp); 306 break; 307 } 308 309 af->from_addr_param(&addr, rawaddr, htons(port), 0); 310 retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp); 311 if (retval) { 312 /* Can't finish building the list, clean up. */ 313 sctp_bind_addr_clean(bp); 314 break; 315 } 316 317 len = ntohs(param->length); 318 addrs_len -= len; 319 raw_addr_list += len; 320 } 321 322 return retval; 323 } 324 325 /******************************************************************** 326 * 2nd Level Abstractions 327 ********************************************************************/ 328 329 /* Does this contain a specified address? Allow wildcarding. */ 330 int sctp_bind_addr_match(struct sctp_bind_addr *bp, 331 const union sctp_addr *addr, 332 struct sctp_sock *opt) 333 { 334 struct sctp_sockaddr_entry *laddr; 335 int match = 0; 336 337 rcu_read_lock(); 338 list_for_each_entry_rcu(laddr, &bp->address_list, list) { 339 if (!laddr->valid) 340 continue; 341 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) { 342 match = 1; 343 break; 344 } 345 } 346 rcu_read_unlock(); 347 348 return match; 349 } 350 351 /* Does the address 'addr' conflict with any addresses in 352 * the bp. 353 */ 354 int sctp_bind_addr_conflict(struct sctp_bind_addr *bp, 355 const union sctp_addr *addr, 356 struct sctp_sock *bp_sp, 357 struct sctp_sock *addr_sp) 358 { 359 struct sctp_sockaddr_entry *laddr; 360 int conflict = 0; 361 struct sctp_sock *sp; 362 363 /* Pick the IPv6 socket as the basis of comparison 364 * since it's usually a superset of the IPv4. 365 * If there is no IPv6 socket, then default to bind_addr. 366 */ 367 if (sctp_opt2sk(bp_sp)->sk_family == AF_INET6) 368 sp = bp_sp; 369 else if (sctp_opt2sk(addr_sp)->sk_family == AF_INET6) 370 sp = addr_sp; 371 else 372 sp = bp_sp; 373 374 rcu_read_lock(); 375 list_for_each_entry_rcu(laddr, &bp->address_list, list) { 376 if (!laddr->valid) 377 continue; 378 379 conflict = sp->pf->cmp_addr(&laddr->a, addr, sp); 380 if (conflict) 381 break; 382 } 383 rcu_read_unlock(); 384 385 return conflict; 386 } 387 388 /* Get the state of the entry in the bind_addr_list */ 389 int sctp_bind_addr_state(const struct sctp_bind_addr *bp, 390 const union sctp_addr *addr) 391 { 392 struct sctp_sockaddr_entry *laddr; 393 struct sctp_af *af; 394 int state = -1; 395 396 af = sctp_get_af_specific(addr->sa.sa_family); 397 if (unlikely(!af)) 398 return state; 399 400 rcu_read_lock(); 401 list_for_each_entry_rcu(laddr, &bp->address_list, list) { 402 if (!laddr->valid) 403 continue; 404 if (af->cmp_addr(&laddr->a, addr)) { 405 state = laddr->state; 406 break; 407 } 408 } 409 rcu_read_unlock(); 410 411 return state; 412 } 413 414 /* Find the first address in the bind address list that is not present in 415 * the addrs packed array. 416 */ 417 union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp, 418 const union sctp_addr *addrs, 419 int addrcnt, 420 struct sctp_sock *opt) 421 { 422 struct sctp_sockaddr_entry *laddr; 423 union sctp_addr *addr; 424 void *addr_buf; 425 struct sctp_af *af; 426 int i; 427 428 /* This is only called sctp_send_asconf_del_ip() and we hold 429 * the socket lock in that code patch, so that address list 430 * can't change. 431 */ 432 list_for_each_entry(laddr, &bp->address_list, list) { 433 addr_buf = (union sctp_addr *)addrs; 434 for (i = 0; i < addrcnt; i++) { 435 addr = (union sctp_addr *)addr_buf; 436 af = sctp_get_af_specific(addr->v4.sin_family); 437 if (!af) 438 break; 439 440 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) 441 break; 442 443 addr_buf += af->sockaddr_len; 444 } 445 if (i == addrcnt) 446 return &laddr->a; 447 } 448 449 return NULL; 450 } 451 452 /* Copy out addresses from the global local address list. */ 453 static int sctp_copy_one_addr(struct sctp_bind_addr *dest, 454 union sctp_addr *addr, 455 sctp_scope_t scope, gfp_t gfp, 456 int flags) 457 { 458 int error = 0; 459 460 if (sctp_is_any(NULL, addr)) { 461 error = sctp_copy_local_addr_list(dest, scope, gfp, flags); 462 } else if (sctp_in_scope(addr, scope)) { 463 /* Now that the address is in scope, check to see if 464 * the address type is supported by local sock as 465 * well as the remote peer. 466 */ 467 if ((((AF_INET == addr->sa.sa_family) && 468 (flags & SCTP_ADDR4_PEERSUPP))) || 469 (((AF_INET6 == addr->sa.sa_family) && 470 (flags & SCTP_ADDR6_ALLOWED) && 471 (flags & SCTP_ADDR6_PEERSUPP)))) 472 error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC, 473 gfp); 474 } 475 476 return error; 477 } 478 479 /* Is this a wildcard address? */ 480 int sctp_is_any(struct sock *sk, const union sctp_addr *addr) 481 { 482 unsigned short fam = 0; 483 struct sctp_af *af; 484 485 /* Try to get the right address family */ 486 if (addr->sa.sa_family != AF_UNSPEC) 487 fam = addr->sa.sa_family; 488 else if (sk) 489 fam = sk->sk_family; 490 491 af = sctp_get_af_specific(fam); 492 if (!af) 493 return 0; 494 495 return af->is_any(addr); 496 } 497 498 /* Is 'addr' valid for 'scope'? */ 499 int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope) 500 { 501 sctp_scope_t addr_scope = sctp_scope(addr); 502 503 /* The unusable SCTP addresses will not be considered with 504 * any defined scopes. 505 */ 506 if (SCTP_SCOPE_UNUSABLE == addr_scope) 507 return 0; 508 /* 509 * For INIT and INIT-ACK address list, let L be the level of 510 * of requested destination address, sender and receiver 511 * SHOULD include all of its addresses with level greater 512 * than or equal to L. 513 * 514 * Address scoping can be selectively controlled via sysctl 515 * option 516 */ 517 switch (sctp_scope_policy) { 518 case SCTP_SCOPE_POLICY_DISABLE: 519 return 1; 520 case SCTP_SCOPE_POLICY_ENABLE: 521 if (addr_scope <= scope) 522 return 1; 523 break; 524 case SCTP_SCOPE_POLICY_PRIVATE: 525 if (addr_scope <= scope || SCTP_SCOPE_PRIVATE == addr_scope) 526 return 1; 527 break; 528 case SCTP_SCOPE_POLICY_LINK: 529 if (addr_scope <= scope || SCTP_SCOPE_LINK == addr_scope) 530 return 1; 531 break; 532 default: 533 break; 534 } 535 536 return 0; 537 } 538 539 /******************************************************************** 540 * 3rd Level Abstractions 541 ********************************************************************/ 542 543 /* What is the scope of 'addr'? */ 544 sctp_scope_t sctp_scope(const union sctp_addr *addr) 545 { 546 struct sctp_af *af; 547 548 af = sctp_get_af_specific(addr->sa.sa_family); 549 if (!af) 550 return SCTP_SCOPE_UNUSABLE; 551 552 return af->scope((union sctp_addr *)addr); 553 } 554