1 /* SCTP kernel implementation 2 * (C) Copyright IBM Corp. 2001, 2004 3 * Copyright (c) 1999-2000 Cisco, Inc. 4 * Copyright (c) 1999-2001 Motorola, Inc. 5 * Copyright (c) 2001-2003 Intel Corp. 6 * Copyright (c) 2001-2002 Nokia, Inc. 7 * Copyright (c) 2001 La Monte H.P. Yarroll 8 * 9 * This file is part of the SCTP kernel implementation 10 * 11 * These functions interface with the sockets layer to implement the 12 * SCTP Extensions for the Sockets API. 13 * 14 * Note that the descriptions from the specification are USER level 15 * functions--this file is the functions which populate the struct proto 16 * for SCTP which is the BOTTOM of the sockets interface. 17 * 18 * This SCTP implementation is free software; 19 * you can redistribute it and/or modify it under the terms of 20 * the GNU General Public License as published by 21 * the Free Software Foundation; either version 2, or (at your option) 22 * any later version. 23 * 24 * This SCTP implementation is distributed in the hope that it 25 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 26 * ************************ 27 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 28 * See the GNU General Public License for more details. 29 * 30 * You should have received a copy of the GNU General Public License 31 * along with GNU CC; see the file COPYING. If not, write to 32 * the Free Software Foundation, 59 Temple Place - Suite 330, 33 * Boston, MA 02111-1307, USA. 34 * 35 * Please send any bug reports or fixes you make to the 36 * email address(es): 37 * lksctp developers <lksctp-developers@lists.sourceforge.net> 38 * 39 * Or submit a bug report through the following website: 40 * http://www.sf.net/projects/lksctp 41 * 42 * Written or modified by: 43 * La Monte H.P. Yarroll <piggy@acm.org> 44 * Narasimha Budihal <narsi@refcode.org> 45 * Karl Knutson <karl@athena.chicago.il.us> 46 * Jon Grimm <jgrimm@us.ibm.com> 47 * Xingang Guo <xingang.guo@intel.com> 48 * Daisy Chang <daisyc@us.ibm.com> 49 * Sridhar Samudrala <samudrala@us.ibm.com> 50 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com> 51 * Ardelle Fan <ardelle.fan@intel.com> 52 * Ryan Layer <rmlayer@us.ibm.com> 53 * Anup Pemmaiah <pemmaiah@cc.usu.edu> 54 * Kevin Gao <kevin.gao@intel.com> 55 * 56 * Any bugs reported given to us we will try to fix... any fixes shared will 57 * be incorporated into the next SCTP release. 58 */ 59 60 #include <linux/types.h> 61 #include <linux/kernel.h> 62 #include <linux/wait.h> 63 #include <linux/time.h> 64 #include <linux/ip.h> 65 #include <linux/capability.h> 66 #include <linux/fcntl.h> 67 #include <linux/poll.h> 68 #include <linux/init.h> 69 #include <linux/crypto.h> 70 #include <linux/slab.h> 71 72 #include <net/ip.h> 73 #include <net/icmp.h> 74 #include <net/route.h> 75 #include <net/ipv6.h> 76 #include <net/inet_common.h> 77 78 #include <linux/socket.h> /* for sa_family_t */ 79 #include <net/sock.h> 80 #include <net/sctp/sctp.h> 81 #include <net/sctp/sm.h> 82 83 /* WARNING: Please do not remove the SCTP_STATIC attribute to 84 * any of the functions below as they are used to export functions 85 * used by a project regression testsuite. 86 */ 87 88 /* Forward declarations for internal helper functions. */ 89 static int sctp_writeable(struct sock *sk); 90 static void sctp_wfree(struct sk_buff *skb); 91 static int sctp_wait_for_sndbuf(struct sctp_association *, long *timeo_p, 92 size_t msg_len); 93 static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p); 94 static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p); 95 static int sctp_wait_for_accept(struct sock *sk, long timeo); 96 static void sctp_wait_for_close(struct sock *sk, long timeo); 97 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt, 98 union sctp_addr *addr, int len); 99 static int sctp_bindx_add(struct sock *, struct sockaddr *, int); 100 static int sctp_bindx_rem(struct sock *, struct sockaddr *, int); 101 static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int); 102 static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int); 103 static int sctp_send_asconf(struct sctp_association *asoc, 104 struct sctp_chunk *chunk); 105 static int sctp_do_bind(struct sock *, union sctp_addr *, int); 106 static int sctp_autobind(struct sock *sk); 107 static void sctp_sock_migrate(struct sock *, struct sock *, 108 struct sctp_association *, sctp_socket_type_t); 109 static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG; 110 111 extern struct kmem_cache *sctp_bucket_cachep; 112 extern int sysctl_sctp_mem[3]; 113 extern int sysctl_sctp_rmem[3]; 114 extern int sysctl_sctp_wmem[3]; 115 116 static int sctp_memory_pressure; 117 static atomic_t sctp_memory_allocated; 118 struct percpu_counter sctp_sockets_allocated; 119 120 static void sctp_enter_memory_pressure(struct sock *sk) 121 { 122 sctp_memory_pressure = 1; 123 } 124 125 126 /* Get the sndbuf space available at the time on the association. */ 127 static inline int sctp_wspace(struct sctp_association *asoc) 128 { 129 int amt; 130 131 if (asoc->ep->sndbuf_policy) 132 amt = asoc->sndbuf_used; 133 else 134 amt = sk_wmem_alloc_get(asoc->base.sk); 135 136 if (amt >= asoc->base.sk->sk_sndbuf) { 137 if (asoc->base.sk->sk_userlocks & SOCK_SNDBUF_LOCK) 138 amt = 0; 139 else { 140 amt = sk_stream_wspace(asoc->base.sk); 141 if (amt < 0) 142 amt = 0; 143 } 144 } else { 145 amt = asoc->base.sk->sk_sndbuf - amt; 146 } 147 return amt; 148 } 149 150 /* Increment the used sndbuf space count of the corresponding association by 151 * the size of the outgoing data chunk. 152 * Also, set the skb destructor for sndbuf accounting later. 153 * 154 * Since it is always 1-1 between chunk and skb, and also a new skb is always 155 * allocated for chunk bundling in sctp_packet_transmit(), we can use the 156 * destructor in the data chunk skb for the purpose of the sndbuf space 157 * tracking. 158 */ 159 static inline void sctp_set_owner_w(struct sctp_chunk *chunk) 160 { 161 struct sctp_association *asoc = chunk->asoc; 162 struct sock *sk = asoc->base.sk; 163 164 /* The sndbuf space is tracked per association. */ 165 sctp_association_hold(asoc); 166 167 skb_set_owner_w(chunk->skb, sk); 168 169 chunk->skb->destructor = sctp_wfree; 170 /* Save the chunk pointer in skb for sctp_wfree to use later. */ 171 *((struct sctp_chunk **)(chunk->skb->cb)) = chunk; 172 173 asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) + 174 sizeof(struct sk_buff) + 175 sizeof(struct sctp_chunk); 176 177 atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc); 178 sk->sk_wmem_queued += chunk->skb->truesize; 179 sk_mem_charge(sk, chunk->skb->truesize); 180 } 181 182 /* Verify that this is a valid address. */ 183 static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr, 184 int len) 185 { 186 struct sctp_af *af; 187 188 /* Verify basic sockaddr. */ 189 af = sctp_sockaddr_af(sctp_sk(sk), addr, len); 190 if (!af) 191 return -EINVAL; 192 193 /* Is this a valid SCTP address? */ 194 if (!af->addr_valid(addr, sctp_sk(sk), NULL)) 195 return -EINVAL; 196 197 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr))) 198 return -EINVAL; 199 200 return 0; 201 } 202 203 /* Look up the association by its id. If this is not a UDP-style 204 * socket, the ID field is always ignored. 205 */ 206 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id) 207 { 208 struct sctp_association *asoc = NULL; 209 210 /* If this is not a UDP-style socket, assoc id should be ignored. */ 211 if (!sctp_style(sk, UDP)) { 212 /* Return NULL if the socket state is not ESTABLISHED. It 213 * could be a TCP-style listening socket or a socket which 214 * hasn't yet called connect() to establish an association. 215 */ 216 if (!sctp_sstate(sk, ESTABLISHED)) 217 return NULL; 218 219 /* Get the first and the only association from the list. */ 220 if (!list_empty(&sctp_sk(sk)->ep->asocs)) 221 asoc = list_entry(sctp_sk(sk)->ep->asocs.next, 222 struct sctp_association, asocs); 223 return asoc; 224 } 225 226 /* Otherwise this is a UDP-style socket. */ 227 if (!id || (id == (sctp_assoc_t)-1)) 228 return NULL; 229 230 spin_lock_bh(&sctp_assocs_id_lock); 231 asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id); 232 spin_unlock_bh(&sctp_assocs_id_lock); 233 234 if (!asoc || (asoc->base.sk != sk) || asoc->base.dead) 235 return NULL; 236 237 return asoc; 238 } 239 240 /* Look up the transport from an address and an assoc id. If both address and 241 * id are specified, the associations matching the address and the id should be 242 * the same. 243 */ 244 static struct sctp_transport *sctp_addr_id2transport(struct sock *sk, 245 struct sockaddr_storage *addr, 246 sctp_assoc_t id) 247 { 248 struct sctp_association *addr_asoc = NULL, *id_asoc = NULL; 249 struct sctp_transport *transport; 250 union sctp_addr *laddr = (union sctp_addr *)addr; 251 252 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep, 253 laddr, 254 &transport); 255 256 if (!addr_asoc) 257 return NULL; 258 259 id_asoc = sctp_id2assoc(sk, id); 260 if (id_asoc && (id_asoc != addr_asoc)) 261 return NULL; 262 263 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 264 (union sctp_addr *)addr); 265 266 return transport; 267 } 268 269 /* API 3.1.2 bind() - UDP Style Syntax 270 * The syntax of bind() is, 271 * 272 * ret = bind(int sd, struct sockaddr *addr, int addrlen); 273 * 274 * sd - the socket descriptor returned by socket(). 275 * addr - the address structure (struct sockaddr_in or struct 276 * sockaddr_in6 [RFC 2553]), 277 * addr_len - the size of the address structure. 278 */ 279 SCTP_STATIC int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len) 280 { 281 int retval = 0; 282 283 sctp_lock_sock(sk); 284 285 SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n", 286 sk, addr, addr_len); 287 288 /* Disallow binding twice. */ 289 if (!sctp_sk(sk)->ep->base.bind_addr.port) 290 retval = sctp_do_bind(sk, (union sctp_addr *)addr, 291 addr_len); 292 else 293 retval = -EINVAL; 294 295 sctp_release_sock(sk); 296 297 return retval; 298 } 299 300 static long sctp_get_port_local(struct sock *, union sctp_addr *); 301 302 /* Verify this is a valid sockaddr. */ 303 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt, 304 union sctp_addr *addr, int len) 305 { 306 struct sctp_af *af; 307 308 /* Check minimum size. */ 309 if (len < sizeof (struct sockaddr)) 310 return NULL; 311 312 /* V4 mapped address are really of AF_INET family */ 313 if (addr->sa.sa_family == AF_INET6 && 314 ipv6_addr_v4mapped(&addr->v6.sin6_addr)) { 315 if (!opt->pf->af_supported(AF_INET, opt)) 316 return NULL; 317 } else { 318 /* Does this PF support this AF? */ 319 if (!opt->pf->af_supported(addr->sa.sa_family, opt)) 320 return NULL; 321 } 322 323 /* If we get this far, af is valid. */ 324 af = sctp_get_af_specific(addr->sa.sa_family); 325 326 if (len < af->sockaddr_len) 327 return NULL; 328 329 return af; 330 } 331 332 /* Bind a local address either to an endpoint or to an association. */ 333 SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len) 334 { 335 struct sctp_sock *sp = sctp_sk(sk); 336 struct sctp_endpoint *ep = sp->ep; 337 struct sctp_bind_addr *bp = &ep->base.bind_addr; 338 struct sctp_af *af; 339 unsigned short snum; 340 int ret = 0; 341 342 /* Common sockaddr verification. */ 343 af = sctp_sockaddr_af(sp, addr, len); 344 if (!af) { 345 SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n", 346 sk, addr, len); 347 return -EINVAL; 348 } 349 350 snum = ntohs(addr->v4.sin_port); 351 352 SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ", 353 ", port: %d, new port: %d, len: %d)\n", 354 sk, 355 addr, 356 bp->port, snum, 357 len); 358 359 /* PF specific bind() address verification. */ 360 if (!sp->pf->bind_verify(sp, addr)) 361 return -EADDRNOTAVAIL; 362 363 /* We must either be unbound, or bind to the same port. 364 * It's OK to allow 0 ports if we are already bound. 365 * We'll just inhert an already bound port in this case 366 */ 367 if (bp->port) { 368 if (!snum) 369 snum = bp->port; 370 else if (snum != bp->port) { 371 SCTP_DEBUG_PRINTK("sctp_do_bind:" 372 " New port %d does not match existing port " 373 "%d.\n", snum, bp->port); 374 return -EINVAL; 375 } 376 } 377 378 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 379 return -EACCES; 380 381 /* See if the address matches any of the addresses we may have 382 * already bound before checking against other endpoints. 383 */ 384 if (sctp_bind_addr_match(bp, addr, sp)) 385 return -EINVAL; 386 387 /* Make sure we are allowed to bind here. 388 * The function sctp_get_port_local() does duplicate address 389 * detection. 390 */ 391 addr->v4.sin_port = htons(snum); 392 if ((ret = sctp_get_port_local(sk, addr))) { 393 return -EADDRINUSE; 394 } 395 396 /* Refresh ephemeral port. */ 397 if (!bp->port) 398 bp->port = inet_sk(sk)->inet_num; 399 400 /* Add the address to the bind address list. 401 * Use GFP_ATOMIC since BHs will be disabled. 402 */ 403 ret = sctp_add_bind_addr(bp, addr, SCTP_ADDR_SRC, GFP_ATOMIC); 404 405 /* Copy back into socket for getsockname() use. */ 406 if (!ret) { 407 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num); 408 af->to_sk_saddr(addr, sk); 409 } 410 411 return ret; 412 } 413 414 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks 415 * 416 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged 417 * at any one time. If a sender, after sending an ASCONF chunk, decides 418 * it needs to transfer another ASCONF Chunk, it MUST wait until the 419 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a 420 * subsequent ASCONF. Note this restriction binds each side, so at any 421 * time two ASCONF may be in-transit on any given association (one sent 422 * from each endpoint). 423 */ 424 static int sctp_send_asconf(struct sctp_association *asoc, 425 struct sctp_chunk *chunk) 426 { 427 int retval = 0; 428 429 /* If there is an outstanding ASCONF chunk, queue it for later 430 * transmission. 431 */ 432 if (asoc->addip_last_asconf) { 433 list_add_tail(&chunk->list, &asoc->addip_chunk_list); 434 goto out; 435 } 436 437 /* Hold the chunk until an ASCONF_ACK is received. */ 438 sctp_chunk_hold(chunk); 439 retval = sctp_primitive_ASCONF(asoc, chunk); 440 if (retval) 441 sctp_chunk_free(chunk); 442 else 443 asoc->addip_last_asconf = chunk; 444 445 out: 446 return retval; 447 } 448 449 /* Add a list of addresses as bind addresses to local endpoint or 450 * association. 451 * 452 * Basically run through each address specified in the addrs/addrcnt 453 * array/length pair, determine if it is IPv6 or IPv4 and call 454 * sctp_do_bind() on it. 455 * 456 * If any of them fails, then the operation will be reversed and the 457 * ones that were added will be removed. 458 * 459 * Only sctp_setsockopt_bindx() is supposed to call this function. 460 */ 461 static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt) 462 { 463 int cnt; 464 int retval = 0; 465 void *addr_buf; 466 struct sockaddr *sa_addr; 467 struct sctp_af *af; 468 469 SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n", 470 sk, addrs, addrcnt); 471 472 addr_buf = addrs; 473 for (cnt = 0; cnt < addrcnt; cnt++) { 474 /* The list may contain either IPv4 or IPv6 address; 475 * determine the address length for walking thru the list. 476 */ 477 sa_addr = (struct sockaddr *)addr_buf; 478 af = sctp_get_af_specific(sa_addr->sa_family); 479 if (!af) { 480 retval = -EINVAL; 481 goto err_bindx_add; 482 } 483 484 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr, 485 af->sockaddr_len); 486 487 addr_buf += af->sockaddr_len; 488 489 err_bindx_add: 490 if (retval < 0) { 491 /* Failed. Cleanup the ones that have been added */ 492 if (cnt > 0) 493 sctp_bindx_rem(sk, addrs, cnt); 494 return retval; 495 } 496 } 497 498 return retval; 499 } 500 501 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the 502 * associations that are part of the endpoint indicating that a list of local 503 * addresses are added to the endpoint. 504 * 505 * If any of the addresses is already in the bind address list of the 506 * association, we do not send the chunk for that association. But it will not 507 * affect other associations. 508 * 509 * Only sctp_setsockopt_bindx() is supposed to call this function. 510 */ 511 static int sctp_send_asconf_add_ip(struct sock *sk, 512 struct sockaddr *addrs, 513 int addrcnt) 514 { 515 struct sctp_sock *sp; 516 struct sctp_endpoint *ep; 517 struct sctp_association *asoc; 518 struct sctp_bind_addr *bp; 519 struct sctp_chunk *chunk; 520 struct sctp_sockaddr_entry *laddr; 521 union sctp_addr *addr; 522 union sctp_addr saveaddr; 523 void *addr_buf; 524 struct sctp_af *af; 525 struct list_head *p; 526 int i; 527 int retval = 0; 528 529 if (!sctp_addip_enable) 530 return retval; 531 532 sp = sctp_sk(sk); 533 ep = sp->ep; 534 535 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", 536 __func__, sk, addrs, addrcnt); 537 538 list_for_each_entry(asoc, &ep->asocs, asocs) { 539 540 if (!asoc->peer.asconf_capable) 541 continue; 542 543 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP) 544 continue; 545 546 if (!sctp_state(asoc, ESTABLISHED)) 547 continue; 548 549 /* Check if any address in the packed array of addresses is 550 * in the bind address list of the association. If so, 551 * do not send the asconf chunk to its peer, but continue with 552 * other associations. 553 */ 554 addr_buf = addrs; 555 for (i = 0; i < addrcnt; i++) { 556 addr = (union sctp_addr *)addr_buf; 557 af = sctp_get_af_specific(addr->v4.sin_family); 558 if (!af) { 559 retval = -EINVAL; 560 goto out; 561 } 562 563 if (sctp_assoc_lookup_laddr(asoc, addr)) 564 break; 565 566 addr_buf += af->sockaddr_len; 567 } 568 if (i < addrcnt) 569 continue; 570 571 /* Use the first valid address in bind addr list of 572 * association as Address Parameter of ASCONF CHUNK. 573 */ 574 bp = &asoc->base.bind_addr; 575 p = bp->address_list.next; 576 laddr = list_entry(p, struct sctp_sockaddr_entry, list); 577 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs, 578 addrcnt, SCTP_PARAM_ADD_IP); 579 if (!chunk) { 580 retval = -ENOMEM; 581 goto out; 582 } 583 584 retval = sctp_send_asconf(asoc, chunk); 585 if (retval) 586 goto out; 587 588 /* Add the new addresses to the bind address list with 589 * use_as_src set to 0. 590 */ 591 addr_buf = addrs; 592 for (i = 0; i < addrcnt; i++) { 593 addr = (union sctp_addr *)addr_buf; 594 af = sctp_get_af_specific(addr->v4.sin_family); 595 memcpy(&saveaddr, addr, af->sockaddr_len); 596 retval = sctp_add_bind_addr(bp, &saveaddr, 597 SCTP_ADDR_NEW, GFP_ATOMIC); 598 addr_buf += af->sockaddr_len; 599 } 600 } 601 602 out: 603 return retval; 604 } 605 606 /* Remove a list of addresses from bind addresses list. Do not remove the 607 * last address. 608 * 609 * Basically run through each address specified in the addrs/addrcnt 610 * array/length pair, determine if it is IPv6 or IPv4 and call 611 * sctp_del_bind() on it. 612 * 613 * If any of them fails, then the operation will be reversed and the 614 * ones that were removed will be added back. 615 * 616 * At least one address has to be left; if only one address is 617 * available, the operation will return -EBUSY. 618 * 619 * Only sctp_setsockopt_bindx() is supposed to call this function. 620 */ 621 static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt) 622 { 623 struct sctp_sock *sp = sctp_sk(sk); 624 struct sctp_endpoint *ep = sp->ep; 625 int cnt; 626 struct sctp_bind_addr *bp = &ep->base.bind_addr; 627 int retval = 0; 628 void *addr_buf; 629 union sctp_addr *sa_addr; 630 struct sctp_af *af; 631 632 SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n", 633 sk, addrs, addrcnt); 634 635 addr_buf = addrs; 636 for (cnt = 0; cnt < addrcnt; cnt++) { 637 /* If the bind address list is empty or if there is only one 638 * bind address, there is nothing more to be removed (we need 639 * at least one address here). 640 */ 641 if (list_empty(&bp->address_list) || 642 (sctp_list_single_entry(&bp->address_list))) { 643 retval = -EBUSY; 644 goto err_bindx_rem; 645 } 646 647 sa_addr = (union sctp_addr *)addr_buf; 648 af = sctp_get_af_specific(sa_addr->sa.sa_family); 649 if (!af) { 650 retval = -EINVAL; 651 goto err_bindx_rem; 652 } 653 654 if (!af->addr_valid(sa_addr, sp, NULL)) { 655 retval = -EADDRNOTAVAIL; 656 goto err_bindx_rem; 657 } 658 659 if (sa_addr->v4.sin_port != htons(bp->port)) { 660 retval = -EINVAL; 661 goto err_bindx_rem; 662 } 663 664 /* FIXME - There is probably a need to check if sk->sk_saddr and 665 * sk->sk_rcv_addr are currently set to one of the addresses to 666 * be removed. This is something which needs to be looked into 667 * when we are fixing the outstanding issues with multi-homing 668 * socket routing and failover schemes. Refer to comments in 669 * sctp_do_bind(). -daisy 670 */ 671 retval = sctp_del_bind_addr(bp, sa_addr); 672 673 addr_buf += af->sockaddr_len; 674 err_bindx_rem: 675 if (retval < 0) { 676 /* Failed. Add the ones that has been removed back */ 677 if (cnt > 0) 678 sctp_bindx_add(sk, addrs, cnt); 679 return retval; 680 } 681 } 682 683 return retval; 684 } 685 686 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of 687 * the associations that are part of the endpoint indicating that a list of 688 * local addresses are removed from the endpoint. 689 * 690 * If any of the addresses is already in the bind address list of the 691 * association, we do not send the chunk for that association. But it will not 692 * affect other associations. 693 * 694 * Only sctp_setsockopt_bindx() is supposed to call this function. 695 */ 696 static int sctp_send_asconf_del_ip(struct sock *sk, 697 struct sockaddr *addrs, 698 int addrcnt) 699 { 700 struct sctp_sock *sp; 701 struct sctp_endpoint *ep; 702 struct sctp_association *asoc; 703 struct sctp_transport *transport; 704 struct sctp_bind_addr *bp; 705 struct sctp_chunk *chunk; 706 union sctp_addr *laddr; 707 void *addr_buf; 708 struct sctp_af *af; 709 struct sctp_sockaddr_entry *saddr; 710 int i; 711 int retval = 0; 712 713 if (!sctp_addip_enable) 714 return retval; 715 716 sp = sctp_sk(sk); 717 ep = sp->ep; 718 719 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", 720 __func__, sk, addrs, addrcnt); 721 722 list_for_each_entry(asoc, &ep->asocs, asocs) { 723 724 if (!asoc->peer.asconf_capable) 725 continue; 726 727 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP) 728 continue; 729 730 if (!sctp_state(asoc, ESTABLISHED)) 731 continue; 732 733 /* Check if any address in the packed array of addresses is 734 * not present in the bind address list of the association. 735 * If so, do not send the asconf chunk to its peer, but 736 * continue with other associations. 737 */ 738 addr_buf = addrs; 739 for (i = 0; i < addrcnt; i++) { 740 laddr = (union sctp_addr *)addr_buf; 741 af = sctp_get_af_specific(laddr->v4.sin_family); 742 if (!af) { 743 retval = -EINVAL; 744 goto out; 745 } 746 747 if (!sctp_assoc_lookup_laddr(asoc, laddr)) 748 break; 749 750 addr_buf += af->sockaddr_len; 751 } 752 if (i < addrcnt) 753 continue; 754 755 /* Find one address in the association's bind address list 756 * that is not in the packed array of addresses. This is to 757 * make sure that we do not delete all the addresses in the 758 * association. 759 */ 760 bp = &asoc->base.bind_addr; 761 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs, 762 addrcnt, sp); 763 if (!laddr) 764 continue; 765 766 /* We do not need RCU protection throughout this loop 767 * because this is done under a socket lock from the 768 * setsockopt call. 769 */ 770 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt, 771 SCTP_PARAM_DEL_IP); 772 if (!chunk) { 773 retval = -ENOMEM; 774 goto out; 775 } 776 777 /* Reset use_as_src flag for the addresses in the bind address 778 * list that are to be deleted. 779 */ 780 addr_buf = addrs; 781 for (i = 0; i < addrcnt; i++) { 782 laddr = (union sctp_addr *)addr_buf; 783 af = sctp_get_af_specific(laddr->v4.sin_family); 784 list_for_each_entry(saddr, &bp->address_list, list) { 785 if (sctp_cmp_addr_exact(&saddr->a, laddr)) 786 saddr->state = SCTP_ADDR_DEL; 787 } 788 addr_buf += af->sockaddr_len; 789 } 790 791 /* Update the route and saddr entries for all the transports 792 * as some of the addresses in the bind address list are 793 * about to be deleted and cannot be used as source addresses. 794 */ 795 list_for_each_entry(transport, &asoc->peer.transport_addr_list, 796 transports) { 797 dst_release(transport->dst); 798 sctp_transport_route(transport, NULL, 799 sctp_sk(asoc->base.sk)); 800 } 801 802 retval = sctp_send_asconf(asoc, chunk); 803 } 804 out: 805 return retval; 806 } 807 808 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt() 809 * 810 * API 8.1 811 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt, 812 * int flags); 813 * 814 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses. 815 * If the sd is an IPv6 socket, the addresses passed can either be IPv4 816 * or IPv6 addresses. 817 * 818 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see 819 * Section 3.1.2 for this usage. 820 * 821 * addrs is a pointer to an array of one or more socket addresses. Each 822 * address is contained in its appropriate structure (i.e. struct 823 * sockaddr_in or struct sockaddr_in6) the family of the address type 824 * must be used to distinguish the address length (note that this 825 * representation is termed a "packed array" of addresses). The caller 826 * specifies the number of addresses in the array with addrcnt. 827 * 828 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns 829 * -1, and sets errno to the appropriate error code. 830 * 831 * For SCTP, the port given in each socket address must be the same, or 832 * sctp_bindx() will fail, setting errno to EINVAL. 833 * 834 * The flags parameter is formed from the bitwise OR of zero or more of 835 * the following currently defined flags: 836 * 837 * SCTP_BINDX_ADD_ADDR 838 * 839 * SCTP_BINDX_REM_ADDR 840 * 841 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the 842 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given 843 * addresses from the association. The two flags are mutually exclusive; 844 * if both are given, sctp_bindx() will fail with EINVAL. A caller may 845 * not remove all addresses from an association; sctp_bindx() will 846 * reject such an attempt with EINVAL. 847 * 848 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate 849 * additional addresses with an endpoint after calling bind(). Or use 850 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening 851 * socket is associated with so that no new association accepted will be 852 * associated with those addresses. If the endpoint supports dynamic 853 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a 854 * endpoint to send the appropriate message to the peer to change the 855 * peers address lists. 856 * 857 * Adding and removing addresses from a connected association is 858 * optional functionality. Implementations that do not support this 859 * functionality should return EOPNOTSUPP. 860 * 861 * Basically do nothing but copying the addresses from user to kernel 862 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk. 863 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt() 864 * from userspace. 865 * 866 * We don't use copy_from_user() for optimization: we first do the 867 * sanity checks (buffer size -fast- and access check-healthy 868 * pointer); if all of those succeed, then we can alloc the memory 869 * (expensive operation) needed to copy the data to kernel. Then we do 870 * the copying without checking the user space area 871 * (__copy_from_user()). 872 * 873 * On exit there is no need to do sockfd_put(), sys_setsockopt() does 874 * it. 875 * 876 * sk The sk of the socket 877 * addrs The pointer to the addresses in user land 878 * addrssize Size of the addrs buffer 879 * op Operation to perform (add or remove, see the flags of 880 * sctp_bindx) 881 * 882 * Returns 0 if ok, <0 errno code on error. 883 */ 884 SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk, 885 struct sockaddr __user *addrs, 886 int addrs_size, int op) 887 { 888 struct sockaddr *kaddrs; 889 int err; 890 int addrcnt = 0; 891 int walk_size = 0; 892 struct sockaddr *sa_addr; 893 void *addr_buf; 894 struct sctp_af *af; 895 896 SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p" 897 " addrs_size %d opt %d\n", sk, addrs, addrs_size, op); 898 899 if (unlikely(addrs_size <= 0)) 900 return -EINVAL; 901 902 /* Check the user passed a healthy pointer. */ 903 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size))) 904 return -EFAULT; 905 906 /* Alloc space for the address array in kernel memory. */ 907 kaddrs = kmalloc(addrs_size, GFP_KERNEL); 908 if (unlikely(!kaddrs)) 909 return -ENOMEM; 910 911 if (__copy_from_user(kaddrs, addrs, addrs_size)) { 912 kfree(kaddrs); 913 return -EFAULT; 914 } 915 916 /* Walk through the addrs buffer and count the number of addresses. */ 917 addr_buf = kaddrs; 918 while (walk_size < addrs_size) { 919 if (walk_size + sizeof(sa_family_t) > addrs_size) { 920 kfree(kaddrs); 921 return -EINVAL; 922 } 923 924 sa_addr = (struct sockaddr *)addr_buf; 925 af = sctp_get_af_specific(sa_addr->sa_family); 926 927 /* If the address family is not supported or if this address 928 * causes the address buffer to overflow return EINVAL. 929 */ 930 if (!af || (walk_size + af->sockaddr_len) > addrs_size) { 931 kfree(kaddrs); 932 return -EINVAL; 933 } 934 addrcnt++; 935 addr_buf += af->sockaddr_len; 936 walk_size += af->sockaddr_len; 937 } 938 939 /* Do the work. */ 940 switch (op) { 941 case SCTP_BINDX_ADD_ADDR: 942 err = sctp_bindx_add(sk, kaddrs, addrcnt); 943 if (err) 944 goto out; 945 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt); 946 break; 947 948 case SCTP_BINDX_REM_ADDR: 949 err = sctp_bindx_rem(sk, kaddrs, addrcnt); 950 if (err) 951 goto out; 952 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt); 953 break; 954 955 default: 956 err = -EINVAL; 957 break; 958 } 959 960 out: 961 kfree(kaddrs); 962 963 return err; 964 } 965 966 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size) 967 * 968 * Common routine for handling connect() and sctp_connectx(). 969 * Connect will come in with just a single address. 970 */ 971 static int __sctp_connect(struct sock* sk, 972 struct sockaddr *kaddrs, 973 int addrs_size, 974 sctp_assoc_t *assoc_id) 975 { 976 struct sctp_sock *sp; 977 struct sctp_endpoint *ep; 978 struct sctp_association *asoc = NULL; 979 struct sctp_association *asoc2; 980 struct sctp_transport *transport; 981 union sctp_addr to; 982 struct sctp_af *af; 983 sctp_scope_t scope; 984 long timeo; 985 int err = 0; 986 int addrcnt = 0; 987 int walk_size = 0; 988 union sctp_addr *sa_addr = NULL; 989 void *addr_buf; 990 unsigned short port; 991 unsigned int f_flags = 0; 992 993 sp = sctp_sk(sk); 994 ep = sp->ep; 995 996 /* connect() cannot be done on a socket that is already in ESTABLISHED 997 * state - UDP-style peeled off socket or a TCP-style socket that 998 * is already connected. 999 * It cannot be done even on a TCP-style listening socket. 1000 */ 1001 if (sctp_sstate(sk, ESTABLISHED) || 1002 (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) { 1003 err = -EISCONN; 1004 goto out_free; 1005 } 1006 1007 /* Walk through the addrs buffer and count the number of addresses. */ 1008 addr_buf = kaddrs; 1009 while (walk_size < addrs_size) { 1010 if (walk_size + sizeof(sa_family_t) > addrs_size) { 1011 err = -EINVAL; 1012 goto out_free; 1013 } 1014 1015 sa_addr = (union sctp_addr *)addr_buf; 1016 af = sctp_get_af_specific(sa_addr->sa.sa_family); 1017 1018 /* If the address family is not supported or if this address 1019 * causes the address buffer to overflow return EINVAL. 1020 */ 1021 if (!af || (walk_size + af->sockaddr_len) > addrs_size) { 1022 err = -EINVAL; 1023 goto out_free; 1024 } 1025 1026 port = ntohs(sa_addr->v4.sin_port); 1027 1028 /* Save current address so we can work with it */ 1029 memcpy(&to, sa_addr, af->sockaddr_len); 1030 1031 err = sctp_verify_addr(sk, &to, af->sockaddr_len); 1032 if (err) 1033 goto out_free; 1034 1035 /* Make sure the destination port is correctly set 1036 * in all addresses. 1037 */ 1038 if (asoc && asoc->peer.port && asoc->peer.port != port) 1039 goto out_free; 1040 1041 1042 /* Check if there already is a matching association on the 1043 * endpoint (other than the one created here). 1044 */ 1045 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport); 1046 if (asoc2 && asoc2 != asoc) { 1047 if (asoc2->state >= SCTP_STATE_ESTABLISHED) 1048 err = -EISCONN; 1049 else 1050 err = -EALREADY; 1051 goto out_free; 1052 } 1053 1054 /* If we could not find a matching association on the endpoint, 1055 * make sure that there is no peeled-off association matching 1056 * the peer address even on another socket. 1057 */ 1058 if (sctp_endpoint_is_peeled_off(ep, &to)) { 1059 err = -EADDRNOTAVAIL; 1060 goto out_free; 1061 } 1062 1063 if (!asoc) { 1064 /* If a bind() or sctp_bindx() is not called prior to 1065 * an sctp_connectx() call, the system picks an 1066 * ephemeral port and will choose an address set 1067 * equivalent to binding with a wildcard address. 1068 */ 1069 if (!ep->base.bind_addr.port) { 1070 if (sctp_autobind(sk)) { 1071 err = -EAGAIN; 1072 goto out_free; 1073 } 1074 } else { 1075 /* 1076 * If an unprivileged user inherits a 1-many 1077 * style socket with open associations on a 1078 * privileged port, it MAY be permitted to 1079 * accept new associations, but it SHOULD NOT 1080 * be permitted to open new associations. 1081 */ 1082 if (ep->base.bind_addr.port < PROT_SOCK && 1083 !capable(CAP_NET_BIND_SERVICE)) { 1084 err = -EACCES; 1085 goto out_free; 1086 } 1087 } 1088 1089 scope = sctp_scope(&to); 1090 asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL); 1091 if (!asoc) { 1092 err = -ENOMEM; 1093 goto out_free; 1094 } 1095 1096 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, 1097 GFP_KERNEL); 1098 if (err < 0) { 1099 goto out_free; 1100 } 1101 1102 } 1103 1104 /* Prime the peer's transport structures. */ 1105 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, 1106 SCTP_UNKNOWN); 1107 if (!transport) { 1108 err = -ENOMEM; 1109 goto out_free; 1110 } 1111 1112 addrcnt++; 1113 addr_buf += af->sockaddr_len; 1114 walk_size += af->sockaddr_len; 1115 } 1116 1117 /* In case the user of sctp_connectx() wants an association 1118 * id back, assign one now. 1119 */ 1120 if (assoc_id) { 1121 err = sctp_assoc_set_id(asoc, GFP_KERNEL); 1122 if (err < 0) 1123 goto out_free; 1124 } 1125 1126 err = sctp_primitive_ASSOCIATE(asoc, NULL); 1127 if (err < 0) { 1128 goto out_free; 1129 } 1130 1131 /* Initialize sk's dport and daddr for getpeername() */ 1132 inet_sk(sk)->inet_dport = htons(asoc->peer.port); 1133 af = sctp_get_af_specific(sa_addr->sa.sa_family); 1134 af->to_sk_daddr(sa_addr, sk); 1135 sk->sk_err = 0; 1136 1137 /* in-kernel sockets don't generally have a file allocated to them 1138 * if all they do is call sock_create_kern(). 1139 */ 1140 if (sk->sk_socket->file) 1141 f_flags = sk->sk_socket->file->f_flags; 1142 1143 timeo = sock_sndtimeo(sk, f_flags & O_NONBLOCK); 1144 1145 err = sctp_wait_for_connect(asoc, &timeo); 1146 if ((err == 0 || err == -EINPROGRESS) && assoc_id) 1147 *assoc_id = asoc->assoc_id; 1148 1149 /* Don't free association on exit. */ 1150 asoc = NULL; 1151 1152 out_free: 1153 1154 SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p" 1155 " kaddrs: %p err: %d\n", 1156 asoc, kaddrs, err); 1157 if (asoc) 1158 sctp_association_free(asoc); 1159 return err; 1160 } 1161 1162 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt() 1163 * 1164 * API 8.9 1165 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt, 1166 * sctp_assoc_t *asoc); 1167 * 1168 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses. 1169 * If the sd is an IPv6 socket, the addresses passed can either be IPv4 1170 * or IPv6 addresses. 1171 * 1172 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see 1173 * Section 3.1.2 for this usage. 1174 * 1175 * addrs is a pointer to an array of one or more socket addresses. Each 1176 * address is contained in its appropriate structure (i.e. struct 1177 * sockaddr_in or struct sockaddr_in6) the family of the address type 1178 * must be used to distengish the address length (note that this 1179 * representation is termed a "packed array" of addresses). The caller 1180 * specifies the number of addresses in the array with addrcnt. 1181 * 1182 * On success, sctp_connectx() returns 0. It also sets the assoc_id to 1183 * the association id of the new association. On failure, sctp_connectx() 1184 * returns -1, and sets errno to the appropriate error code. The assoc_id 1185 * is not touched by the kernel. 1186 * 1187 * For SCTP, the port given in each socket address must be the same, or 1188 * sctp_connectx() will fail, setting errno to EINVAL. 1189 * 1190 * An application can use sctp_connectx to initiate an association with 1191 * an endpoint that is multi-homed. Much like sctp_bindx() this call 1192 * allows a caller to specify multiple addresses at which a peer can be 1193 * reached. The way the SCTP stack uses the list of addresses to set up 1194 * the association is implementation dependant. This function only 1195 * specifies that the stack will try to make use of all the addresses in 1196 * the list when needed. 1197 * 1198 * Note that the list of addresses passed in is only used for setting up 1199 * the association. It does not necessarily equal the set of addresses 1200 * the peer uses for the resulting association. If the caller wants to 1201 * find out the set of peer addresses, it must use sctp_getpaddrs() to 1202 * retrieve them after the association has been set up. 1203 * 1204 * Basically do nothing but copying the addresses from user to kernel 1205 * land and invoking either sctp_connectx(). This is used for tunneling 1206 * the sctp_connectx() request through sctp_setsockopt() from userspace. 1207 * 1208 * We don't use copy_from_user() for optimization: we first do the 1209 * sanity checks (buffer size -fast- and access check-healthy 1210 * pointer); if all of those succeed, then we can alloc the memory 1211 * (expensive operation) needed to copy the data to kernel. Then we do 1212 * the copying without checking the user space area 1213 * (__copy_from_user()). 1214 * 1215 * On exit there is no need to do sockfd_put(), sys_setsockopt() does 1216 * it. 1217 * 1218 * sk The sk of the socket 1219 * addrs The pointer to the addresses in user land 1220 * addrssize Size of the addrs buffer 1221 * 1222 * Returns >=0 if ok, <0 errno code on error. 1223 */ 1224 SCTP_STATIC int __sctp_setsockopt_connectx(struct sock* sk, 1225 struct sockaddr __user *addrs, 1226 int addrs_size, 1227 sctp_assoc_t *assoc_id) 1228 { 1229 int err = 0; 1230 struct sockaddr *kaddrs; 1231 1232 SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n", 1233 __func__, sk, addrs, addrs_size); 1234 1235 if (unlikely(addrs_size <= 0)) 1236 return -EINVAL; 1237 1238 /* Check the user passed a healthy pointer. */ 1239 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size))) 1240 return -EFAULT; 1241 1242 /* Alloc space for the address array in kernel memory. */ 1243 kaddrs = kmalloc(addrs_size, GFP_KERNEL); 1244 if (unlikely(!kaddrs)) 1245 return -ENOMEM; 1246 1247 if (__copy_from_user(kaddrs, addrs, addrs_size)) { 1248 err = -EFAULT; 1249 } else { 1250 err = __sctp_connect(sk, kaddrs, addrs_size, assoc_id); 1251 } 1252 1253 kfree(kaddrs); 1254 1255 return err; 1256 } 1257 1258 /* 1259 * This is an older interface. It's kept for backward compatibility 1260 * to the option that doesn't provide association id. 1261 */ 1262 SCTP_STATIC int sctp_setsockopt_connectx_old(struct sock* sk, 1263 struct sockaddr __user *addrs, 1264 int addrs_size) 1265 { 1266 return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL); 1267 } 1268 1269 /* 1270 * New interface for the API. The since the API is done with a socket 1271 * option, to make it simple we feed back the association id is as a return 1272 * indication to the call. Error is always negative and association id is 1273 * always positive. 1274 */ 1275 SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk, 1276 struct sockaddr __user *addrs, 1277 int addrs_size) 1278 { 1279 sctp_assoc_t assoc_id = 0; 1280 int err = 0; 1281 1282 err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id); 1283 1284 if (err) 1285 return err; 1286 else 1287 return assoc_id; 1288 } 1289 1290 /* 1291 * New (hopefully final) interface for the API. 1292 * We use the sctp_getaddrs_old structure so that use-space library 1293 * can avoid any unnecessary allocations. The only defferent part 1294 * is that we store the actual length of the address buffer into the 1295 * addrs_num structure member. That way we can re-use the existing 1296 * code. 1297 */ 1298 SCTP_STATIC int sctp_getsockopt_connectx3(struct sock* sk, int len, 1299 char __user *optval, 1300 int __user *optlen) 1301 { 1302 struct sctp_getaddrs_old param; 1303 sctp_assoc_t assoc_id = 0; 1304 int err = 0; 1305 1306 if (len < sizeof(param)) 1307 return -EINVAL; 1308 1309 if (copy_from_user(¶m, optval, sizeof(param))) 1310 return -EFAULT; 1311 1312 err = __sctp_setsockopt_connectx(sk, 1313 (struct sockaddr __user *)param.addrs, 1314 param.addr_num, &assoc_id); 1315 1316 if (err == 0 || err == -EINPROGRESS) { 1317 if (copy_to_user(optval, &assoc_id, sizeof(assoc_id))) 1318 return -EFAULT; 1319 if (put_user(sizeof(assoc_id), optlen)) 1320 return -EFAULT; 1321 } 1322 1323 return err; 1324 } 1325 1326 /* API 3.1.4 close() - UDP Style Syntax 1327 * Applications use close() to perform graceful shutdown (as described in 1328 * Section 10.1 of [SCTP]) on ALL the associations currently represented 1329 * by a UDP-style socket. 1330 * 1331 * The syntax is 1332 * 1333 * ret = close(int sd); 1334 * 1335 * sd - the socket descriptor of the associations to be closed. 1336 * 1337 * To gracefully shutdown a specific association represented by the 1338 * UDP-style socket, an application should use the sendmsg() call, 1339 * passing no user data, but including the appropriate flag in the 1340 * ancillary data (see Section xxxx). 1341 * 1342 * If sd in the close() call is a branched-off socket representing only 1343 * one association, the shutdown is performed on that association only. 1344 * 1345 * 4.1.6 close() - TCP Style Syntax 1346 * 1347 * Applications use close() to gracefully close down an association. 1348 * 1349 * The syntax is: 1350 * 1351 * int close(int sd); 1352 * 1353 * sd - the socket descriptor of the association to be closed. 1354 * 1355 * After an application calls close() on a socket descriptor, no further 1356 * socket operations will succeed on that descriptor. 1357 * 1358 * API 7.1.4 SO_LINGER 1359 * 1360 * An application using the TCP-style socket can use this option to 1361 * perform the SCTP ABORT primitive. The linger option structure is: 1362 * 1363 * struct linger { 1364 * int l_onoff; // option on/off 1365 * int l_linger; // linger time 1366 * }; 1367 * 1368 * To enable the option, set l_onoff to 1. If the l_linger value is set 1369 * to 0, calling close() is the same as the ABORT primitive. If the 1370 * value is set to a negative value, the setsockopt() call will return 1371 * an error. If the value is set to a positive value linger_time, the 1372 * close() can be blocked for at most linger_time ms. If the graceful 1373 * shutdown phase does not finish during this period, close() will 1374 * return but the graceful shutdown phase continues in the system. 1375 */ 1376 SCTP_STATIC void sctp_close(struct sock *sk, long timeout) 1377 { 1378 struct sctp_endpoint *ep; 1379 struct sctp_association *asoc; 1380 struct list_head *pos, *temp; 1381 1382 SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout); 1383 1384 sctp_lock_sock(sk); 1385 sk->sk_shutdown = SHUTDOWN_MASK; 1386 sk->sk_state = SCTP_SS_CLOSING; 1387 1388 ep = sctp_sk(sk)->ep; 1389 1390 /* Walk all associations on an endpoint. */ 1391 list_for_each_safe(pos, temp, &ep->asocs) { 1392 asoc = list_entry(pos, struct sctp_association, asocs); 1393 1394 if (sctp_style(sk, TCP)) { 1395 /* A closed association can still be in the list if 1396 * it belongs to a TCP-style listening socket that is 1397 * not yet accepted. If so, free it. If not, send an 1398 * ABORT or SHUTDOWN based on the linger options. 1399 */ 1400 if (sctp_state(asoc, CLOSED)) { 1401 sctp_unhash_established(asoc); 1402 sctp_association_free(asoc); 1403 continue; 1404 } 1405 } 1406 1407 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) { 1408 struct sctp_chunk *chunk; 1409 1410 chunk = sctp_make_abort_user(asoc, NULL, 0); 1411 if (chunk) 1412 sctp_primitive_ABORT(asoc, chunk); 1413 } else 1414 sctp_primitive_SHUTDOWN(asoc, NULL); 1415 } 1416 1417 /* Clean up any skbs sitting on the receive queue. */ 1418 sctp_queue_purge_ulpevents(&sk->sk_receive_queue); 1419 sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby); 1420 1421 /* On a TCP-style socket, block for at most linger_time if set. */ 1422 if (sctp_style(sk, TCP) && timeout) 1423 sctp_wait_for_close(sk, timeout); 1424 1425 /* This will run the backlog queue. */ 1426 sctp_release_sock(sk); 1427 1428 /* Supposedly, no process has access to the socket, but 1429 * the net layers still may. 1430 */ 1431 sctp_local_bh_disable(); 1432 sctp_bh_lock_sock(sk); 1433 1434 /* Hold the sock, since sk_common_release() will put sock_put() 1435 * and we have just a little more cleanup. 1436 */ 1437 sock_hold(sk); 1438 sk_common_release(sk); 1439 1440 sctp_bh_unlock_sock(sk); 1441 sctp_local_bh_enable(); 1442 1443 sock_put(sk); 1444 1445 SCTP_DBG_OBJCNT_DEC(sock); 1446 } 1447 1448 /* Handle EPIPE error. */ 1449 static int sctp_error(struct sock *sk, int flags, int err) 1450 { 1451 if (err == -EPIPE) 1452 err = sock_error(sk) ? : -EPIPE; 1453 if (err == -EPIPE && !(flags & MSG_NOSIGNAL)) 1454 send_sig(SIGPIPE, current, 0); 1455 return err; 1456 } 1457 1458 /* API 3.1.3 sendmsg() - UDP Style Syntax 1459 * 1460 * An application uses sendmsg() and recvmsg() calls to transmit data to 1461 * and receive data from its peer. 1462 * 1463 * ssize_t sendmsg(int socket, const struct msghdr *message, 1464 * int flags); 1465 * 1466 * socket - the socket descriptor of the endpoint. 1467 * message - pointer to the msghdr structure which contains a single 1468 * user message and possibly some ancillary data. 1469 * 1470 * See Section 5 for complete description of the data 1471 * structures. 1472 * 1473 * flags - flags sent or received with the user message, see Section 1474 * 5 for complete description of the flags. 1475 * 1476 * Note: This function could use a rewrite especially when explicit 1477 * connect support comes in. 1478 */ 1479 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */ 1480 1481 SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *); 1482 1483 SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, 1484 struct msghdr *msg, size_t msg_len) 1485 { 1486 struct sctp_sock *sp; 1487 struct sctp_endpoint *ep; 1488 struct sctp_association *new_asoc=NULL, *asoc=NULL; 1489 struct sctp_transport *transport, *chunk_tp; 1490 struct sctp_chunk *chunk; 1491 union sctp_addr to; 1492 struct sockaddr *msg_name = NULL; 1493 struct sctp_sndrcvinfo default_sinfo = { 0 }; 1494 struct sctp_sndrcvinfo *sinfo; 1495 struct sctp_initmsg *sinit; 1496 sctp_assoc_t associd = 0; 1497 sctp_cmsgs_t cmsgs = { NULL }; 1498 int err; 1499 sctp_scope_t scope; 1500 long timeo; 1501 __u16 sinfo_flags = 0; 1502 struct sctp_datamsg *datamsg; 1503 int msg_flags = msg->msg_flags; 1504 1505 SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n", 1506 sk, msg, msg_len); 1507 1508 err = 0; 1509 sp = sctp_sk(sk); 1510 ep = sp->ep; 1511 1512 SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep); 1513 1514 /* We cannot send a message over a TCP-style listening socket. */ 1515 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) { 1516 err = -EPIPE; 1517 goto out_nounlock; 1518 } 1519 1520 /* Parse out the SCTP CMSGs. */ 1521 err = sctp_msghdr_parse(msg, &cmsgs); 1522 1523 if (err) { 1524 SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err); 1525 goto out_nounlock; 1526 } 1527 1528 /* Fetch the destination address for this packet. This 1529 * address only selects the association--it is not necessarily 1530 * the address we will send to. 1531 * For a peeled-off socket, msg_name is ignored. 1532 */ 1533 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) { 1534 int msg_namelen = msg->msg_namelen; 1535 1536 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name, 1537 msg_namelen); 1538 if (err) 1539 return err; 1540 1541 if (msg_namelen > sizeof(to)) 1542 msg_namelen = sizeof(to); 1543 memcpy(&to, msg->msg_name, msg_namelen); 1544 msg_name = msg->msg_name; 1545 } 1546 1547 sinfo = cmsgs.info; 1548 sinit = cmsgs.init; 1549 1550 /* Did the user specify SNDRCVINFO? */ 1551 if (sinfo) { 1552 sinfo_flags = sinfo->sinfo_flags; 1553 associd = sinfo->sinfo_assoc_id; 1554 } 1555 1556 SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n", 1557 msg_len, sinfo_flags); 1558 1559 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */ 1560 if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) { 1561 err = -EINVAL; 1562 goto out_nounlock; 1563 } 1564 1565 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero 1566 * length messages when SCTP_EOF|SCTP_ABORT is not set. 1567 * If SCTP_ABORT is set, the message length could be non zero with 1568 * the msg_iov set to the user abort reason. 1569 */ 1570 if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) || 1571 (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) { 1572 err = -EINVAL; 1573 goto out_nounlock; 1574 } 1575 1576 /* If SCTP_ADDR_OVER is set, there must be an address 1577 * specified in msg_name. 1578 */ 1579 if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) { 1580 err = -EINVAL; 1581 goto out_nounlock; 1582 } 1583 1584 transport = NULL; 1585 1586 SCTP_DEBUG_PRINTK("About to look up association.\n"); 1587 1588 sctp_lock_sock(sk); 1589 1590 /* If a msg_name has been specified, assume this is to be used. */ 1591 if (msg_name) { 1592 /* Look for a matching association on the endpoint. */ 1593 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport); 1594 if (!asoc) { 1595 /* If we could not find a matching association on the 1596 * endpoint, make sure that it is not a TCP-style 1597 * socket that already has an association or there is 1598 * no peeled-off association on another socket. 1599 */ 1600 if ((sctp_style(sk, TCP) && 1601 sctp_sstate(sk, ESTABLISHED)) || 1602 sctp_endpoint_is_peeled_off(ep, &to)) { 1603 err = -EADDRNOTAVAIL; 1604 goto out_unlock; 1605 } 1606 } 1607 } else { 1608 asoc = sctp_id2assoc(sk, associd); 1609 if (!asoc) { 1610 err = -EPIPE; 1611 goto out_unlock; 1612 } 1613 } 1614 1615 if (asoc) { 1616 SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc); 1617 1618 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED 1619 * socket that has an association in CLOSED state. This can 1620 * happen when an accepted socket has an association that is 1621 * already CLOSED. 1622 */ 1623 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) { 1624 err = -EPIPE; 1625 goto out_unlock; 1626 } 1627 1628 if (sinfo_flags & SCTP_EOF) { 1629 SCTP_DEBUG_PRINTK("Shutting down association: %p\n", 1630 asoc); 1631 sctp_primitive_SHUTDOWN(asoc, NULL); 1632 err = 0; 1633 goto out_unlock; 1634 } 1635 if (sinfo_flags & SCTP_ABORT) { 1636 1637 chunk = sctp_make_abort_user(asoc, msg, msg_len); 1638 if (!chunk) { 1639 err = -ENOMEM; 1640 goto out_unlock; 1641 } 1642 1643 SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc); 1644 sctp_primitive_ABORT(asoc, chunk); 1645 err = 0; 1646 goto out_unlock; 1647 } 1648 } 1649 1650 /* Do we need to create the association? */ 1651 if (!asoc) { 1652 SCTP_DEBUG_PRINTK("There is no association yet.\n"); 1653 1654 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) { 1655 err = -EINVAL; 1656 goto out_unlock; 1657 } 1658 1659 /* Check for invalid stream against the stream counts, 1660 * either the default or the user specified stream counts. 1661 */ 1662 if (sinfo) { 1663 if (!sinit || (sinit && !sinit->sinit_num_ostreams)) { 1664 /* Check against the defaults. */ 1665 if (sinfo->sinfo_stream >= 1666 sp->initmsg.sinit_num_ostreams) { 1667 err = -EINVAL; 1668 goto out_unlock; 1669 } 1670 } else { 1671 /* Check against the requested. */ 1672 if (sinfo->sinfo_stream >= 1673 sinit->sinit_num_ostreams) { 1674 err = -EINVAL; 1675 goto out_unlock; 1676 } 1677 } 1678 } 1679 1680 /* 1681 * API 3.1.2 bind() - UDP Style Syntax 1682 * If a bind() or sctp_bindx() is not called prior to a 1683 * sendmsg() call that initiates a new association, the 1684 * system picks an ephemeral port and will choose an address 1685 * set equivalent to binding with a wildcard address. 1686 */ 1687 if (!ep->base.bind_addr.port) { 1688 if (sctp_autobind(sk)) { 1689 err = -EAGAIN; 1690 goto out_unlock; 1691 } 1692 } else { 1693 /* 1694 * If an unprivileged user inherits a one-to-many 1695 * style socket with open associations on a privileged 1696 * port, it MAY be permitted to accept new associations, 1697 * but it SHOULD NOT be permitted to open new 1698 * associations. 1699 */ 1700 if (ep->base.bind_addr.port < PROT_SOCK && 1701 !capable(CAP_NET_BIND_SERVICE)) { 1702 err = -EACCES; 1703 goto out_unlock; 1704 } 1705 } 1706 1707 scope = sctp_scope(&to); 1708 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL); 1709 if (!new_asoc) { 1710 err = -ENOMEM; 1711 goto out_unlock; 1712 } 1713 asoc = new_asoc; 1714 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL); 1715 if (err < 0) { 1716 err = -ENOMEM; 1717 goto out_free; 1718 } 1719 1720 /* If the SCTP_INIT ancillary data is specified, set all 1721 * the association init values accordingly. 1722 */ 1723 if (sinit) { 1724 if (sinit->sinit_num_ostreams) { 1725 asoc->c.sinit_num_ostreams = 1726 sinit->sinit_num_ostreams; 1727 } 1728 if (sinit->sinit_max_instreams) { 1729 asoc->c.sinit_max_instreams = 1730 sinit->sinit_max_instreams; 1731 } 1732 if (sinit->sinit_max_attempts) { 1733 asoc->max_init_attempts 1734 = sinit->sinit_max_attempts; 1735 } 1736 if (sinit->sinit_max_init_timeo) { 1737 asoc->max_init_timeo = 1738 msecs_to_jiffies(sinit->sinit_max_init_timeo); 1739 } 1740 } 1741 1742 /* Prime the peer's transport structures. */ 1743 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN); 1744 if (!transport) { 1745 err = -ENOMEM; 1746 goto out_free; 1747 } 1748 } 1749 1750 /* ASSERT: we have a valid association at this point. */ 1751 SCTP_DEBUG_PRINTK("We have a valid association.\n"); 1752 1753 if (!sinfo) { 1754 /* If the user didn't specify SNDRCVINFO, make up one with 1755 * some defaults. 1756 */ 1757 default_sinfo.sinfo_stream = asoc->default_stream; 1758 default_sinfo.sinfo_flags = asoc->default_flags; 1759 default_sinfo.sinfo_ppid = asoc->default_ppid; 1760 default_sinfo.sinfo_context = asoc->default_context; 1761 default_sinfo.sinfo_timetolive = asoc->default_timetolive; 1762 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc); 1763 sinfo = &default_sinfo; 1764 } 1765 1766 /* API 7.1.7, the sndbuf size per association bounds the 1767 * maximum size of data that can be sent in a single send call. 1768 */ 1769 if (msg_len > sk->sk_sndbuf) { 1770 err = -EMSGSIZE; 1771 goto out_free; 1772 } 1773 1774 if (asoc->pmtu_pending) 1775 sctp_assoc_pending_pmtu(asoc); 1776 1777 /* If fragmentation is disabled and the message length exceeds the 1778 * association fragmentation point, return EMSGSIZE. The I-D 1779 * does not specify what this error is, but this looks like 1780 * a great fit. 1781 */ 1782 if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) { 1783 err = -EMSGSIZE; 1784 goto out_free; 1785 } 1786 1787 if (sinfo) { 1788 /* Check for invalid stream. */ 1789 if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) { 1790 err = -EINVAL; 1791 goto out_free; 1792 } 1793 } 1794 1795 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 1796 if (!sctp_wspace(asoc)) { 1797 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len); 1798 if (err) 1799 goto out_free; 1800 } 1801 1802 /* If an address is passed with the sendto/sendmsg call, it is used 1803 * to override the primary destination address in the TCP model, or 1804 * when SCTP_ADDR_OVER flag is set in the UDP model. 1805 */ 1806 if ((sctp_style(sk, TCP) && msg_name) || 1807 (sinfo_flags & SCTP_ADDR_OVER)) { 1808 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to); 1809 if (!chunk_tp) { 1810 err = -EINVAL; 1811 goto out_free; 1812 } 1813 } else 1814 chunk_tp = NULL; 1815 1816 /* Auto-connect, if we aren't connected already. */ 1817 if (sctp_state(asoc, CLOSED)) { 1818 err = sctp_primitive_ASSOCIATE(asoc, NULL); 1819 if (err < 0) 1820 goto out_free; 1821 SCTP_DEBUG_PRINTK("We associated primitively.\n"); 1822 } 1823 1824 /* Break the message into multiple chunks of maximum size. */ 1825 datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len); 1826 if (!datamsg) { 1827 err = -ENOMEM; 1828 goto out_free; 1829 } 1830 1831 /* Now send the (possibly) fragmented message. */ 1832 list_for_each_entry(chunk, &datamsg->chunks, frag_list) { 1833 sctp_chunk_hold(chunk); 1834 1835 /* Do accounting for the write space. */ 1836 sctp_set_owner_w(chunk); 1837 1838 chunk->transport = chunk_tp; 1839 } 1840 1841 /* Send it to the lower layers. Note: all chunks 1842 * must either fail or succeed. The lower layer 1843 * works that way today. Keep it that way or this 1844 * breaks. 1845 */ 1846 err = sctp_primitive_SEND(asoc, datamsg); 1847 /* Did the lower layer accept the chunk? */ 1848 if (err) 1849 sctp_datamsg_free(datamsg); 1850 else 1851 sctp_datamsg_put(datamsg); 1852 1853 SCTP_DEBUG_PRINTK("We sent primitively.\n"); 1854 1855 if (err) 1856 goto out_free; 1857 else 1858 err = msg_len; 1859 1860 /* If we are already past ASSOCIATE, the lower 1861 * layers are responsible for association cleanup. 1862 */ 1863 goto out_unlock; 1864 1865 out_free: 1866 if (new_asoc) 1867 sctp_association_free(asoc); 1868 out_unlock: 1869 sctp_release_sock(sk); 1870 1871 out_nounlock: 1872 return sctp_error(sk, msg_flags, err); 1873 1874 #if 0 1875 do_sock_err: 1876 if (msg_len) 1877 err = msg_len; 1878 else 1879 err = sock_error(sk); 1880 goto out; 1881 1882 do_interrupted: 1883 if (msg_len) 1884 err = msg_len; 1885 goto out; 1886 #endif /* 0 */ 1887 } 1888 1889 /* This is an extended version of skb_pull() that removes the data from the 1890 * start of a skb even when data is spread across the list of skb's in the 1891 * frag_list. len specifies the total amount of data that needs to be removed. 1892 * when 'len' bytes could be removed from the skb, it returns 0. 1893 * If 'len' exceeds the total skb length, it returns the no. of bytes that 1894 * could not be removed. 1895 */ 1896 static int sctp_skb_pull(struct sk_buff *skb, int len) 1897 { 1898 struct sk_buff *list; 1899 int skb_len = skb_headlen(skb); 1900 int rlen; 1901 1902 if (len <= skb_len) { 1903 __skb_pull(skb, len); 1904 return 0; 1905 } 1906 len -= skb_len; 1907 __skb_pull(skb, skb_len); 1908 1909 skb_walk_frags(skb, list) { 1910 rlen = sctp_skb_pull(list, len); 1911 skb->len -= (len-rlen); 1912 skb->data_len -= (len-rlen); 1913 1914 if (!rlen) 1915 return 0; 1916 1917 len = rlen; 1918 } 1919 1920 return len; 1921 } 1922 1923 /* API 3.1.3 recvmsg() - UDP Style Syntax 1924 * 1925 * ssize_t recvmsg(int socket, struct msghdr *message, 1926 * int flags); 1927 * 1928 * socket - the socket descriptor of the endpoint. 1929 * message - pointer to the msghdr structure which contains a single 1930 * user message and possibly some ancillary data. 1931 * 1932 * See Section 5 for complete description of the data 1933 * structures. 1934 * 1935 * flags - flags sent or received with the user message, see Section 1936 * 5 for complete description of the flags. 1937 */ 1938 static struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *); 1939 1940 SCTP_STATIC int sctp_recvmsg(struct kiocb *iocb, struct sock *sk, 1941 struct msghdr *msg, size_t len, int noblock, 1942 int flags, int *addr_len) 1943 { 1944 struct sctp_ulpevent *event = NULL; 1945 struct sctp_sock *sp = sctp_sk(sk); 1946 struct sk_buff *skb; 1947 int copied; 1948 int err = 0; 1949 int skb_len; 1950 1951 SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: " 1952 "0x%x, %s: %p)\n", "sk", sk, "msghdr", msg, 1953 "len", len, "knoblauch", noblock, 1954 "flags", flags, "addr_len", addr_len); 1955 1956 sctp_lock_sock(sk); 1957 1958 if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) { 1959 err = -ENOTCONN; 1960 goto out; 1961 } 1962 1963 skb = sctp_skb_recv_datagram(sk, flags, noblock, &err); 1964 if (!skb) 1965 goto out; 1966 1967 /* Get the total length of the skb including any skb's in the 1968 * frag_list. 1969 */ 1970 skb_len = skb->len; 1971 1972 copied = skb_len; 1973 if (copied > len) 1974 copied = len; 1975 1976 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1977 1978 event = sctp_skb2event(skb); 1979 1980 if (err) 1981 goto out_free; 1982 1983 sock_recv_ts_and_drops(msg, sk, skb); 1984 if (sctp_ulpevent_is_notification(event)) { 1985 msg->msg_flags |= MSG_NOTIFICATION; 1986 sp->pf->event_msgname(event, msg->msg_name, addr_len); 1987 } else { 1988 sp->pf->skb_msgname(skb, msg->msg_name, addr_len); 1989 } 1990 1991 /* Check if we allow SCTP_SNDRCVINFO. */ 1992 if (sp->subscribe.sctp_data_io_event) 1993 sctp_ulpevent_read_sndrcvinfo(event, msg); 1994 #if 0 1995 /* FIXME: we should be calling IP/IPv6 layers. */ 1996 if (sk->sk_protinfo.af_inet.cmsg_flags) 1997 ip_cmsg_recv(msg, skb); 1998 #endif 1999 2000 err = copied; 2001 2002 /* If skb's length exceeds the user's buffer, update the skb and 2003 * push it back to the receive_queue so that the next call to 2004 * recvmsg() will return the remaining data. Don't set MSG_EOR. 2005 */ 2006 if (skb_len > copied) { 2007 msg->msg_flags &= ~MSG_EOR; 2008 if (flags & MSG_PEEK) 2009 goto out_free; 2010 sctp_skb_pull(skb, copied); 2011 skb_queue_head(&sk->sk_receive_queue, skb); 2012 2013 /* When only partial message is copied to the user, increase 2014 * rwnd by that amount. If all the data in the skb is read, 2015 * rwnd is updated when the event is freed. 2016 */ 2017 if (!sctp_ulpevent_is_notification(event)) 2018 sctp_assoc_rwnd_increase(event->asoc, copied); 2019 goto out; 2020 } else if ((event->msg_flags & MSG_NOTIFICATION) || 2021 (event->msg_flags & MSG_EOR)) 2022 msg->msg_flags |= MSG_EOR; 2023 else 2024 msg->msg_flags &= ~MSG_EOR; 2025 2026 out_free: 2027 if (flags & MSG_PEEK) { 2028 /* Release the skb reference acquired after peeking the skb in 2029 * sctp_skb_recv_datagram(). 2030 */ 2031 kfree_skb(skb); 2032 } else { 2033 /* Free the event which includes releasing the reference to 2034 * the owner of the skb, freeing the skb and updating the 2035 * rwnd. 2036 */ 2037 sctp_ulpevent_free(event); 2038 } 2039 out: 2040 sctp_release_sock(sk); 2041 return err; 2042 } 2043 2044 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS) 2045 * 2046 * This option is a on/off flag. If enabled no SCTP message 2047 * fragmentation will be performed. Instead if a message being sent 2048 * exceeds the current PMTU size, the message will NOT be sent and 2049 * instead a error will be indicated to the user. 2050 */ 2051 static int sctp_setsockopt_disable_fragments(struct sock *sk, 2052 char __user *optval, 2053 unsigned int optlen) 2054 { 2055 int val; 2056 2057 if (optlen < sizeof(int)) 2058 return -EINVAL; 2059 2060 if (get_user(val, (int __user *)optval)) 2061 return -EFAULT; 2062 2063 sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1; 2064 2065 return 0; 2066 } 2067 2068 static int sctp_setsockopt_events(struct sock *sk, char __user *optval, 2069 unsigned int optlen) 2070 { 2071 if (optlen > sizeof(struct sctp_event_subscribe)) 2072 return -EINVAL; 2073 if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen)) 2074 return -EFAULT; 2075 return 0; 2076 } 2077 2078 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE) 2079 * 2080 * This socket option is applicable to the UDP-style socket only. When 2081 * set it will cause associations that are idle for more than the 2082 * specified number of seconds to automatically close. An association 2083 * being idle is defined an association that has NOT sent or received 2084 * user data. The special value of '0' indicates that no automatic 2085 * close of any associations should be performed. The option expects an 2086 * integer defining the number of seconds of idle time before an 2087 * association is closed. 2088 */ 2089 static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval, 2090 unsigned int optlen) 2091 { 2092 struct sctp_sock *sp = sctp_sk(sk); 2093 2094 /* Applicable to UDP-style socket only */ 2095 if (sctp_style(sk, TCP)) 2096 return -EOPNOTSUPP; 2097 if (optlen != sizeof(int)) 2098 return -EINVAL; 2099 if (copy_from_user(&sp->autoclose, optval, optlen)) 2100 return -EFAULT; 2101 /* make sure it won't exceed MAX_SCHEDULE_TIMEOUT */ 2102 sp->autoclose = min_t(long, sp->autoclose, MAX_SCHEDULE_TIMEOUT / HZ); 2103 2104 return 0; 2105 } 2106 2107 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS) 2108 * 2109 * Applications can enable or disable heartbeats for any peer address of 2110 * an association, modify an address's heartbeat interval, force a 2111 * heartbeat to be sent immediately, and adjust the address's maximum 2112 * number of retransmissions sent before an address is considered 2113 * unreachable. The following structure is used to access and modify an 2114 * address's parameters: 2115 * 2116 * struct sctp_paddrparams { 2117 * sctp_assoc_t spp_assoc_id; 2118 * struct sockaddr_storage spp_address; 2119 * uint32_t spp_hbinterval; 2120 * uint16_t spp_pathmaxrxt; 2121 * uint32_t spp_pathmtu; 2122 * uint32_t spp_sackdelay; 2123 * uint32_t spp_flags; 2124 * }; 2125 * 2126 * spp_assoc_id - (one-to-many style socket) This is filled in the 2127 * application, and identifies the association for 2128 * this query. 2129 * spp_address - This specifies which address is of interest. 2130 * spp_hbinterval - This contains the value of the heartbeat interval, 2131 * in milliseconds. If a value of zero 2132 * is present in this field then no changes are to 2133 * be made to this parameter. 2134 * spp_pathmaxrxt - This contains the maximum number of 2135 * retransmissions before this address shall be 2136 * considered unreachable. If a value of zero 2137 * is present in this field then no changes are to 2138 * be made to this parameter. 2139 * spp_pathmtu - When Path MTU discovery is disabled the value 2140 * specified here will be the "fixed" path mtu. 2141 * Note that if the spp_address field is empty 2142 * then all associations on this address will 2143 * have this fixed path mtu set upon them. 2144 * 2145 * spp_sackdelay - When delayed sack is enabled, this value specifies 2146 * the number of milliseconds that sacks will be delayed 2147 * for. This value will apply to all addresses of an 2148 * association if the spp_address field is empty. Note 2149 * also, that if delayed sack is enabled and this 2150 * value is set to 0, no change is made to the last 2151 * recorded delayed sack timer value. 2152 * 2153 * spp_flags - These flags are used to control various features 2154 * on an association. The flag field may contain 2155 * zero or more of the following options. 2156 * 2157 * SPP_HB_ENABLE - Enable heartbeats on the 2158 * specified address. Note that if the address 2159 * field is empty all addresses for the association 2160 * have heartbeats enabled upon them. 2161 * 2162 * SPP_HB_DISABLE - Disable heartbeats on the 2163 * speicifed address. Note that if the address 2164 * field is empty all addresses for the association 2165 * will have their heartbeats disabled. Note also 2166 * that SPP_HB_ENABLE and SPP_HB_DISABLE are 2167 * mutually exclusive, only one of these two should 2168 * be specified. Enabling both fields will have 2169 * undetermined results. 2170 * 2171 * SPP_HB_DEMAND - Request a user initiated heartbeat 2172 * to be made immediately. 2173 * 2174 * SPP_HB_TIME_IS_ZERO - Specify's that the time for 2175 * heartbeat delayis to be set to the value of 0 2176 * milliseconds. 2177 * 2178 * SPP_PMTUD_ENABLE - This field will enable PMTU 2179 * discovery upon the specified address. Note that 2180 * if the address feild is empty then all addresses 2181 * on the association are effected. 2182 * 2183 * SPP_PMTUD_DISABLE - This field will disable PMTU 2184 * discovery upon the specified address. Note that 2185 * if the address feild is empty then all addresses 2186 * on the association are effected. Not also that 2187 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually 2188 * exclusive. Enabling both will have undetermined 2189 * results. 2190 * 2191 * SPP_SACKDELAY_ENABLE - Setting this flag turns 2192 * on delayed sack. The time specified in spp_sackdelay 2193 * is used to specify the sack delay for this address. Note 2194 * that if spp_address is empty then all addresses will 2195 * enable delayed sack and take on the sack delay 2196 * value specified in spp_sackdelay. 2197 * SPP_SACKDELAY_DISABLE - Setting this flag turns 2198 * off delayed sack. If the spp_address field is blank then 2199 * delayed sack is disabled for the entire association. Note 2200 * also that this field is mutually exclusive to 2201 * SPP_SACKDELAY_ENABLE, setting both will have undefined 2202 * results. 2203 */ 2204 static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params, 2205 struct sctp_transport *trans, 2206 struct sctp_association *asoc, 2207 struct sctp_sock *sp, 2208 int hb_change, 2209 int pmtud_change, 2210 int sackdelay_change) 2211 { 2212 int error; 2213 2214 if (params->spp_flags & SPP_HB_DEMAND && trans) { 2215 error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans); 2216 if (error) 2217 return error; 2218 } 2219 2220 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of 2221 * this field is ignored. Note also that a value of zero indicates 2222 * the current setting should be left unchanged. 2223 */ 2224 if (params->spp_flags & SPP_HB_ENABLE) { 2225 2226 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is 2227 * set. This lets us use 0 value when this flag 2228 * is set. 2229 */ 2230 if (params->spp_flags & SPP_HB_TIME_IS_ZERO) 2231 params->spp_hbinterval = 0; 2232 2233 if (params->spp_hbinterval || 2234 (params->spp_flags & SPP_HB_TIME_IS_ZERO)) { 2235 if (trans) { 2236 trans->hbinterval = 2237 msecs_to_jiffies(params->spp_hbinterval); 2238 } else if (asoc) { 2239 asoc->hbinterval = 2240 msecs_to_jiffies(params->spp_hbinterval); 2241 } else { 2242 sp->hbinterval = params->spp_hbinterval; 2243 } 2244 } 2245 } 2246 2247 if (hb_change) { 2248 if (trans) { 2249 trans->param_flags = 2250 (trans->param_flags & ~SPP_HB) | hb_change; 2251 } else if (asoc) { 2252 asoc->param_flags = 2253 (asoc->param_flags & ~SPP_HB) | hb_change; 2254 } else { 2255 sp->param_flags = 2256 (sp->param_flags & ~SPP_HB) | hb_change; 2257 } 2258 } 2259 2260 /* When Path MTU discovery is disabled the value specified here will 2261 * be the "fixed" path mtu (i.e. the value of the spp_flags field must 2262 * include the flag SPP_PMTUD_DISABLE for this field to have any 2263 * effect). 2264 */ 2265 if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) { 2266 if (trans) { 2267 trans->pathmtu = params->spp_pathmtu; 2268 sctp_assoc_sync_pmtu(asoc); 2269 } else if (asoc) { 2270 asoc->pathmtu = params->spp_pathmtu; 2271 sctp_frag_point(asoc, params->spp_pathmtu); 2272 } else { 2273 sp->pathmtu = params->spp_pathmtu; 2274 } 2275 } 2276 2277 if (pmtud_change) { 2278 if (trans) { 2279 int update = (trans->param_flags & SPP_PMTUD_DISABLE) && 2280 (params->spp_flags & SPP_PMTUD_ENABLE); 2281 trans->param_flags = 2282 (trans->param_flags & ~SPP_PMTUD) | pmtud_change; 2283 if (update) { 2284 sctp_transport_pmtu(trans); 2285 sctp_assoc_sync_pmtu(asoc); 2286 } 2287 } else if (asoc) { 2288 asoc->param_flags = 2289 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change; 2290 } else { 2291 sp->param_flags = 2292 (sp->param_flags & ~SPP_PMTUD) | pmtud_change; 2293 } 2294 } 2295 2296 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the 2297 * value of this field is ignored. Note also that a value of zero 2298 * indicates the current setting should be left unchanged. 2299 */ 2300 if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) { 2301 if (trans) { 2302 trans->sackdelay = 2303 msecs_to_jiffies(params->spp_sackdelay); 2304 } else if (asoc) { 2305 asoc->sackdelay = 2306 msecs_to_jiffies(params->spp_sackdelay); 2307 } else { 2308 sp->sackdelay = params->spp_sackdelay; 2309 } 2310 } 2311 2312 if (sackdelay_change) { 2313 if (trans) { 2314 trans->param_flags = 2315 (trans->param_flags & ~SPP_SACKDELAY) | 2316 sackdelay_change; 2317 } else if (asoc) { 2318 asoc->param_flags = 2319 (asoc->param_flags & ~SPP_SACKDELAY) | 2320 sackdelay_change; 2321 } else { 2322 sp->param_flags = 2323 (sp->param_flags & ~SPP_SACKDELAY) | 2324 sackdelay_change; 2325 } 2326 } 2327 2328 /* Note that a value of zero indicates the current setting should be 2329 left unchanged. 2330 */ 2331 if (params->spp_pathmaxrxt) { 2332 if (trans) { 2333 trans->pathmaxrxt = params->spp_pathmaxrxt; 2334 } else if (asoc) { 2335 asoc->pathmaxrxt = params->spp_pathmaxrxt; 2336 } else { 2337 sp->pathmaxrxt = params->spp_pathmaxrxt; 2338 } 2339 } 2340 2341 return 0; 2342 } 2343 2344 static int sctp_setsockopt_peer_addr_params(struct sock *sk, 2345 char __user *optval, 2346 unsigned int optlen) 2347 { 2348 struct sctp_paddrparams params; 2349 struct sctp_transport *trans = NULL; 2350 struct sctp_association *asoc = NULL; 2351 struct sctp_sock *sp = sctp_sk(sk); 2352 int error; 2353 int hb_change, pmtud_change, sackdelay_change; 2354 2355 if (optlen != sizeof(struct sctp_paddrparams)) 2356 return - EINVAL; 2357 2358 if (copy_from_user(¶ms, optval, optlen)) 2359 return -EFAULT; 2360 2361 /* Validate flags and value parameters. */ 2362 hb_change = params.spp_flags & SPP_HB; 2363 pmtud_change = params.spp_flags & SPP_PMTUD; 2364 sackdelay_change = params.spp_flags & SPP_SACKDELAY; 2365 2366 if (hb_change == SPP_HB || 2367 pmtud_change == SPP_PMTUD || 2368 sackdelay_change == SPP_SACKDELAY || 2369 params.spp_sackdelay > 500 || 2370 (params.spp_pathmtu && 2371 params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT)) 2372 return -EINVAL; 2373 2374 /* If an address other than INADDR_ANY is specified, and 2375 * no transport is found, then the request is invalid. 2376 */ 2377 if (!sctp_is_any(sk, ( union sctp_addr *)¶ms.spp_address)) { 2378 trans = sctp_addr_id2transport(sk, ¶ms.spp_address, 2379 params.spp_assoc_id); 2380 if (!trans) 2381 return -EINVAL; 2382 } 2383 2384 /* Get association, if assoc_id != 0 and the socket is a one 2385 * to many style socket, and an association was not found, then 2386 * the id was invalid. 2387 */ 2388 asoc = sctp_id2assoc(sk, params.spp_assoc_id); 2389 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) 2390 return -EINVAL; 2391 2392 /* Heartbeat demand can only be sent on a transport or 2393 * association, but not a socket. 2394 */ 2395 if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc) 2396 return -EINVAL; 2397 2398 /* Process parameters. */ 2399 error = sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, 2400 hb_change, pmtud_change, 2401 sackdelay_change); 2402 2403 if (error) 2404 return error; 2405 2406 /* If changes are for association, also apply parameters to each 2407 * transport. 2408 */ 2409 if (!trans && asoc) { 2410 list_for_each_entry(trans, &asoc->peer.transport_addr_list, 2411 transports) { 2412 sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, 2413 hb_change, pmtud_change, 2414 sackdelay_change); 2415 } 2416 } 2417 2418 return 0; 2419 } 2420 2421 /* 2422 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK) 2423 * 2424 * This option will effect the way delayed acks are performed. This 2425 * option allows you to get or set the delayed ack time, in 2426 * milliseconds. It also allows changing the delayed ack frequency. 2427 * Changing the frequency to 1 disables the delayed sack algorithm. If 2428 * the assoc_id is 0, then this sets or gets the endpoints default 2429 * values. If the assoc_id field is non-zero, then the set or get 2430 * effects the specified association for the one to many model (the 2431 * assoc_id field is ignored by the one to one model). Note that if 2432 * sack_delay or sack_freq are 0 when setting this option, then the 2433 * current values will remain unchanged. 2434 * 2435 * struct sctp_sack_info { 2436 * sctp_assoc_t sack_assoc_id; 2437 * uint32_t sack_delay; 2438 * uint32_t sack_freq; 2439 * }; 2440 * 2441 * sack_assoc_id - This parameter, indicates which association the user 2442 * is performing an action upon. Note that if this field's value is 2443 * zero then the endpoints default value is changed (effecting future 2444 * associations only). 2445 * 2446 * sack_delay - This parameter contains the number of milliseconds that 2447 * the user is requesting the delayed ACK timer be set to. Note that 2448 * this value is defined in the standard to be between 200 and 500 2449 * milliseconds. 2450 * 2451 * sack_freq - This parameter contains the number of packets that must 2452 * be received before a sack is sent without waiting for the delay 2453 * timer to expire. The default value for this is 2, setting this 2454 * value to 1 will disable the delayed sack algorithm. 2455 */ 2456 2457 static int sctp_setsockopt_delayed_ack(struct sock *sk, 2458 char __user *optval, unsigned int optlen) 2459 { 2460 struct sctp_sack_info params; 2461 struct sctp_transport *trans = NULL; 2462 struct sctp_association *asoc = NULL; 2463 struct sctp_sock *sp = sctp_sk(sk); 2464 2465 if (optlen == sizeof(struct sctp_sack_info)) { 2466 if (copy_from_user(¶ms, optval, optlen)) 2467 return -EFAULT; 2468 2469 if (params.sack_delay == 0 && params.sack_freq == 0) 2470 return 0; 2471 } else if (optlen == sizeof(struct sctp_assoc_value)) { 2472 printk(KERN_WARNING "SCTP: Use of struct sctp_assoc_value " 2473 "in delayed_ack socket option deprecated\n"); 2474 printk(KERN_WARNING "SCTP: Use struct sctp_sack_info instead\n"); 2475 if (copy_from_user(¶ms, optval, optlen)) 2476 return -EFAULT; 2477 2478 if (params.sack_delay == 0) 2479 params.sack_freq = 1; 2480 else 2481 params.sack_freq = 0; 2482 } else 2483 return - EINVAL; 2484 2485 /* Validate value parameter. */ 2486 if (params.sack_delay > 500) 2487 return -EINVAL; 2488 2489 /* Get association, if sack_assoc_id != 0 and the socket is a one 2490 * to many style socket, and an association was not found, then 2491 * the id was invalid. 2492 */ 2493 asoc = sctp_id2assoc(sk, params.sack_assoc_id); 2494 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP)) 2495 return -EINVAL; 2496 2497 if (params.sack_delay) { 2498 if (asoc) { 2499 asoc->sackdelay = 2500 msecs_to_jiffies(params.sack_delay); 2501 asoc->param_flags = 2502 (asoc->param_flags & ~SPP_SACKDELAY) | 2503 SPP_SACKDELAY_ENABLE; 2504 } else { 2505 sp->sackdelay = params.sack_delay; 2506 sp->param_flags = 2507 (sp->param_flags & ~SPP_SACKDELAY) | 2508 SPP_SACKDELAY_ENABLE; 2509 } 2510 } 2511 2512 if (params.sack_freq == 1) { 2513 if (asoc) { 2514 asoc->param_flags = 2515 (asoc->param_flags & ~SPP_SACKDELAY) | 2516 SPP_SACKDELAY_DISABLE; 2517 } else { 2518 sp->param_flags = 2519 (sp->param_flags & ~SPP_SACKDELAY) | 2520 SPP_SACKDELAY_DISABLE; 2521 } 2522 } else if (params.sack_freq > 1) { 2523 if (asoc) { 2524 asoc->sackfreq = params.sack_freq; 2525 asoc->param_flags = 2526 (asoc->param_flags & ~SPP_SACKDELAY) | 2527 SPP_SACKDELAY_ENABLE; 2528 } else { 2529 sp->sackfreq = params.sack_freq; 2530 sp->param_flags = 2531 (sp->param_flags & ~SPP_SACKDELAY) | 2532 SPP_SACKDELAY_ENABLE; 2533 } 2534 } 2535 2536 /* If change is for association, also apply to each transport. */ 2537 if (asoc) { 2538 list_for_each_entry(trans, &asoc->peer.transport_addr_list, 2539 transports) { 2540 if (params.sack_delay) { 2541 trans->sackdelay = 2542 msecs_to_jiffies(params.sack_delay); 2543 trans->param_flags = 2544 (trans->param_flags & ~SPP_SACKDELAY) | 2545 SPP_SACKDELAY_ENABLE; 2546 } 2547 if (params.sack_freq == 1) { 2548 trans->param_flags = 2549 (trans->param_flags & ~SPP_SACKDELAY) | 2550 SPP_SACKDELAY_DISABLE; 2551 } else if (params.sack_freq > 1) { 2552 trans->sackfreq = params.sack_freq; 2553 trans->param_flags = 2554 (trans->param_flags & ~SPP_SACKDELAY) | 2555 SPP_SACKDELAY_ENABLE; 2556 } 2557 } 2558 } 2559 2560 return 0; 2561 } 2562 2563 /* 7.1.3 Initialization Parameters (SCTP_INITMSG) 2564 * 2565 * Applications can specify protocol parameters for the default association 2566 * initialization. The option name argument to setsockopt() and getsockopt() 2567 * is SCTP_INITMSG. 2568 * 2569 * Setting initialization parameters is effective only on an unconnected 2570 * socket (for UDP-style sockets only future associations are effected 2571 * by the change). With TCP-style sockets, this option is inherited by 2572 * sockets derived from a listener socket. 2573 */ 2574 static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen) 2575 { 2576 struct sctp_initmsg sinit; 2577 struct sctp_sock *sp = sctp_sk(sk); 2578 2579 if (optlen != sizeof(struct sctp_initmsg)) 2580 return -EINVAL; 2581 if (copy_from_user(&sinit, optval, optlen)) 2582 return -EFAULT; 2583 2584 if (sinit.sinit_num_ostreams) 2585 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams; 2586 if (sinit.sinit_max_instreams) 2587 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams; 2588 if (sinit.sinit_max_attempts) 2589 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts; 2590 if (sinit.sinit_max_init_timeo) 2591 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo; 2592 2593 return 0; 2594 } 2595 2596 /* 2597 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM) 2598 * 2599 * Applications that wish to use the sendto() system call may wish to 2600 * specify a default set of parameters that would normally be supplied 2601 * through the inclusion of ancillary data. This socket option allows 2602 * such an application to set the default sctp_sndrcvinfo structure. 2603 * The application that wishes to use this socket option simply passes 2604 * in to this call the sctp_sndrcvinfo structure defined in Section 2605 * 5.2.2) The input parameters accepted by this call include 2606 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context, 2607 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in 2608 * to this call if the caller is using the UDP model. 2609 */ 2610 static int sctp_setsockopt_default_send_param(struct sock *sk, 2611 char __user *optval, 2612 unsigned int optlen) 2613 { 2614 struct sctp_sndrcvinfo info; 2615 struct sctp_association *asoc; 2616 struct sctp_sock *sp = sctp_sk(sk); 2617 2618 if (optlen != sizeof(struct sctp_sndrcvinfo)) 2619 return -EINVAL; 2620 if (copy_from_user(&info, optval, optlen)) 2621 return -EFAULT; 2622 2623 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id); 2624 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP)) 2625 return -EINVAL; 2626 2627 if (asoc) { 2628 asoc->default_stream = info.sinfo_stream; 2629 asoc->default_flags = info.sinfo_flags; 2630 asoc->default_ppid = info.sinfo_ppid; 2631 asoc->default_context = info.sinfo_context; 2632 asoc->default_timetolive = info.sinfo_timetolive; 2633 } else { 2634 sp->default_stream = info.sinfo_stream; 2635 sp->default_flags = info.sinfo_flags; 2636 sp->default_ppid = info.sinfo_ppid; 2637 sp->default_context = info.sinfo_context; 2638 sp->default_timetolive = info.sinfo_timetolive; 2639 } 2640 2641 return 0; 2642 } 2643 2644 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR) 2645 * 2646 * Requests that the local SCTP stack use the enclosed peer address as 2647 * the association primary. The enclosed address must be one of the 2648 * association peer's addresses. 2649 */ 2650 static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval, 2651 unsigned int optlen) 2652 { 2653 struct sctp_prim prim; 2654 struct sctp_transport *trans; 2655 2656 if (optlen != sizeof(struct sctp_prim)) 2657 return -EINVAL; 2658 2659 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim))) 2660 return -EFAULT; 2661 2662 trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id); 2663 if (!trans) 2664 return -EINVAL; 2665 2666 sctp_assoc_set_primary(trans->asoc, trans); 2667 2668 return 0; 2669 } 2670 2671 /* 2672 * 7.1.5 SCTP_NODELAY 2673 * 2674 * Turn on/off any Nagle-like algorithm. This means that packets are 2675 * generally sent as soon as possible and no unnecessary delays are 2676 * introduced, at the cost of more packets in the network. Expects an 2677 * integer boolean flag. 2678 */ 2679 static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval, 2680 unsigned int optlen) 2681 { 2682 int val; 2683 2684 if (optlen < sizeof(int)) 2685 return -EINVAL; 2686 if (get_user(val, (int __user *)optval)) 2687 return -EFAULT; 2688 2689 sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1; 2690 return 0; 2691 } 2692 2693 /* 2694 * 2695 * 7.1.1 SCTP_RTOINFO 2696 * 2697 * The protocol parameters used to initialize and bound retransmission 2698 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access 2699 * and modify these parameters. 2700 * All parameters are time values, in milliseconds. A value of 0, when 2701 * modifying the parameters, indicates that the current value should not 2702 * be changed. 2703 * 2704 */ 2705 static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen) 2706 { 2707 struct sctp_rtoinfo rtoinfo; 2708 struct sctp_association *asoc; 2709 2710 if (optlen != sizeof (struct sctp_rtoinfo)) 2711 return -EINVAL; 2712 2713 if (copy_from_user(&rtoinfo, optval, optlen)) 2714 return -EFAULT; 2715 2716 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id); 2717 2718 /* Set the values to the specific association */ 2719 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP)) 2720 return -EINVAL; 2721 2722 if (asoc) { 2723 if (rtoinfo.srto_initial != 0) 2724 asoc->rto_initial = 2725 msecs_to_jiffies(rtoinfo.srto_initial); 2726 if (rtoinfo.srto_max != 0) 2727 asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max); 2728 if (rtoinfo.srto_min != 0) 2729 asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min); 2730 } else { 2731 /* If there is no association or the association-id = 0 2732 * set the values to the endpoint. 2733 */ 2734 struct sctp_sock *sp = sctp_sk(sk); 2735 2736 if (rtoinfo.srto_initial != 0) 2737 sp->rtoinfo.srto_initial = rtoinfo.srto_initial; 2738 if (rtoinfo.srto_max != 0) 2739 sp->rtoinfo.srto_max = rtoinfo.srto_max; 2740 if (rtoinfo.srto_min != 0) 2741 sp->rtoinfo.srto_min = rtoinfo.srto_min; 2742 } 2743 2744 return 0; 2745 } 2746 2747 /* 2748 * 2749 * 7.1.2 SCTP_ASSOCINFO 2750 * 2751 * This option is used to tune the maximum retransmission attempts 2752 * of the association. 2753 * Returns an error if the new association retransmission value is 2754 * greater than the sum of the retransmission value of the peer. 2755 * See [SCTP] for more information. 2756 * 2757 */ 2758 static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen) 2759 { 2760 2761 struct sctp_assocparams assocparams; 2762 struct sctp_association *asoc; 2763 2764 if (optlen != sizeof(struct sctp_assocparams)) 2765 return -EINVAL; 2766 if (copy_from_user(&assocparams, optval, optlen)) 2767 return -EFAULT; 2768 2769 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id); 2770 2771 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP)) 2772 return -EINVAL; 2773 2774 /* Set the values to the specific association */ 2775 if (asoc) { 2776 if (assocparams.sasoc_asocmaxrxt != 0) { 2777 __u32 path_sum = 0; 2778 int paths = 0; 2779 struct sctp_transport *peer_addr; 2780 2781 list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list, 2782 transports) { 2783 path_sum += peer_addr->pathmaxrxt; 2784 paths++; 2785 } 2786 2787 /* Only validate asocmaxrxt if we have more than 2788 * one path/transport. We do this because path 2789 * retransmissions are only counted when we have more 2790 * then one path. 2791 */ 2792 if (paths > 1 && 2793 assocparams.sasoc_asocmaxrxt > path_sum) 2794 return -EINVAL; 2795 2796 asoc->max_retrans = assocparams.sasoc_asocmaxrxt; 2797 } 2798 2799 if (assocparams.sasoc_cookie_life != 0) { 2800 asoc->cookie_life.tv_sec = 2801 assocparams.sasoc_cookie_life / 1000; 2802 asoc->cookie_life.tv_usec = 2803 (assocparams.sasoc_cookie_life % 1000) 2804 * 1000; 2805 } 2806 } else { 2807 /* Set the values to the endpoint */ 2808 struct sctp_sock *sp = sctp_sk(sk); 2809 2810 if (assocparams.sasoc_asocmaxrxt != 0) 2811 sp->assocparams.sasoc_asocmaxrxt = 2812 assocparams.sasoc_asocmaxrxt; 2813 if (assocparams.sasoc_cookie_life != 0) 2814 sp->assocparams.sasoc_cookie_life = 2815 assocparams.sasoc_cookie_life; 2816 } 2817 return 0; 2818 } 2819 2820 /* 2821 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR) 2822 * 2823 * This socket option is a boolean flag which turns on or off mapped V4 2824 * addresses. If this option is turned on and the socket is type 2825 * PF_INET6, then IPv4 addresses will be mapped to V6 representation. 2826 * If this option is turned off, then no mapping will be done of V4 2827 * addresses and a user will receive both PF_INET6 and PF_INET type 2828 * addresses on the socket. 2829 */ 2830 static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen) 2831 { 2832 int val; 2833 struct sctp_sock *sp = sctp_sk(sk); 2834 2835 if (optlen < sizeof(int)) 2836 return -EINVAL; 2837 if (get_user(val, (int __user *)optval)) 2838 return -EFAULT; 2839 if (val) 2840 sp->v4mapped = 1; 2841 else 2842 sp->v4mapped = 0; 2843 2844 return 0; 2845 } 2846 2847 /* 2848 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG) 2849 * This option will get or set the maximum size to put in any outgoing 2850 * SCTP DATA chunk. If a message is larger than this size it will be 2851 * fragmented by SCTP into the specified size. Note that the underlying 2852 * SCTP implementation may fragment into smaller sized chunks when the 2853 * PMTU of the underlying association is smaller than the value set by 2854 * the user. The default value for this option is '0' which indicates 2855 * the user is NOT limiting fragmentation and only the PMTU will effect 2856 * SCTP's choice of DATA chunk size. Note also that values set larger 2857 * than the maximum size of an IP datagram will effectively let SCTP 2858 * control fragmentation (i.e. the same as setting this option to 0). 2859 * 2860 * The following structure is used to access and modify this parameter: 2861 * 2862 * struct sctp_assoc_value { 2863 * sctp_assoc_t assoc_id; 2864 * uint32_t assoc_value; 2865 * }; 2866 * 2867 * assoc_id: This parameter is ignored for one-to-one style sockets. 2868 * For one-to-many style sockets this parameter indicates which 2869 * association the user is performing an action upon. Note that if 2870 * this field's value is zero then the endpoints default value is 2871 * changed (effecting future associations only). 2872 * assoc_value: This parameter specifies the maximum size in bytes. 2873 */ 2874 static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen) 2875 { 2876 struct sctp_assoc_value params; 2877 struct sctp_association *asoc; 2878 struct sctp_sock *sp = sctp_sk(sk); 2879 int val; 2880 2881 if (optlen == sizeof(int)) { 2882 printk(KERN_WARNING 2883 "SCTP: Use of int in maxseg socket option deprecated\n"); 2884 printk(KERN_WARNING 2885 "SCTP: Use struct sctp_assoc_value instead\n"); 2886 if (copy_from_user(&val, optval, optlen)) 2887 return -EFAULT; 2888 params.assoc_id = 0; 2889 } else if (optlen == sizeof(struct sctp_assoc_value)) { 2890 if (copy_from_user(¶ms, optval, optlen)) 2891 return -EFAULT; 2892 val = params.assoc_value; 2893 } else 2894 return -EINVAL; 2895 2896 if ((val != 0) && ((val < 8) || (val > SCTP_MAX_CHUNK_LEN))) 2897 return -EINVAL; 2898 2899 asoc = sctp_id2assoc(sk, params.assoc_id); 2900 if (!asoc && params.assoc_id && sctp_style(sk, UDP)) 2901 return -EINVAL; 2902 2903 if (asoc) { 2904 if (val == 0) { 2905 val = asoc->pathmtu; 2906 val -= sp->pf->af->net_header_len; 2907 val -= sizeof(struct sctphdr) + 2908 sizeof(struct sctp_data_chunk); 2909 } 2910 asoc->user_frag = val; 2911 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu); 2912 } else { 2913 sp->user_frag = val; 2914 } 2915 2916 return 0; 2917 } 2918 2919 2920 /* 2921 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR) 2922 * 2923 * Requests that the peer mark the enclosed address as the association 2924 * primary. The enclosed address must be one of the association's 2925 * locally bound addresses. The following structure is used to make a 2926 * set primary request: 2927 */ 2928 static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval, 2929 unsigned int optlen) 2930 { 2931 struct sctp_sock *sp; 2932 struct sctp_endpoint *ep; 2933 struct sctp_association *asoc = NULL; 2934 struct sctp_setpeerprim prim; 2935 struct sctp_chunk *chunk; 2936 int err; 2937 2938 sp = sctp_sk(sk); 2939 ep = sp->ep; 2940 2941 if (!sctp_addip_enable) 2942 return -EPERM; 2943 2944 if (optlen != sizeof(struct sctp_setpeerprim)) 2945 return -EINVAL; 2946 2947 if (copy_from_user(&prim, optval, optlen)) 2948 return -EFAULT; 2949 2950 asoc = sctp_id2assoc(sk, prim.sspp_assoc_id); 2951 if (!asoc) 2952 return -EINVAL; 2953 2954 if (!asoc->peer.asconf_capable) 2955 return -EPERM; 2956 2957 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY) 2958 return -EPERM; 2959 2960 if (!sctp_state(asoc, ESTABLISHED)) 2961 return -ENOTCONN; 2962 2963 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr)) 2964 return -EADDRNOTAVAIL; 2965 2966 /* Create an ASCONF chunk with SET_PRIMARY parameter */ 2967 chunk = sctp_make_asconf_set_prim(asoc, 2968 (union sctp_addr *)&prim.sspp_addr); 2969 if (!chunk) 2970 return -ENOMEM; 2971 2972 err = sctp_send_asconf(asoc, chunk); 2973 2974 SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n"); 2975 2976 return err; 2977 } 2978 2979 static int sctp_setsockopt_adaptation_layer(struct sock *sk, char __user *optval, 2980 unsigned int optlen) 2981 { 2982 struct sctp_setadaptation adaptation; 2983 2984 if (optlen != sizeof(struct sctp_setadaptation)) 2985 return -EINVAL; 2986 if (copy_from_user(&adaptation, optval, optlen)) 2987 return -EFAULT; 2988 2989 sctp_sk(sk)->adaptation_ind = adaptation.ssb_adaptation_ind; 2990 2991 return 0; 2992 } 2993 2994 /* 2995 * 7.1.29. Set or Get the default context (SCTP_CONTEXT) 2996 * 2997 * The context field in the sctp_sndrcvinfo structure is normally only 2998 * used when a failed message is retrieved holding the value that was 2999 * sent down on the actual send call. This option allows the setting of 3000 * a default context on an association basis that will be received on 3001 * reading messages from the peer. This is especially helpful in the 3002 * one-2-many model for an application to keep some reference to an 3003 * internal state machine that is processing messages on the 3004 * association. Note that the setting of this value only effects 3005 * received messages from the peer and does not effect the value that is 3006 * saved with outbound messages. 3007 */ 3008 static int sctp_setsockopt_context(struct sock *sk, char __user *optval, 3009 unsigned int optlen) 3010 { 3011 struct sctp_assoc_value params; 3012 struct sctp_sock *sp; 3013 struct sctp_association *asoc; 3014 3015 if (optlen != sizeof(struct sctp_assoc_value)) 3016 return -EINVAL; 3017 if (copy_from_user(¶ms, optval, optlen)) 3018 return -EFAULT; 3019 3020 sp = sctp_sk(sk); 3021 3022 if (params.assoc_id != 0) { 3023 asoc = sctp_id2assoc(sk, params.assoc_id); 3024 if (!asoc) 3025 return -EINVAL; 3026 asoc->default_rcv_context = params.assoc_value; 3027 } else { 3028 sp->default_rcv_context = params.assoc_value; 3029 } 3030 3031 return 0; 3032 } 3033 3034 /* 3035 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE) 3036 * 3037 * This options will at a minimum specify if the implementation is doing 3038 * fragmented interleave. Fragmented interleave, for a one to many 3039 * socket, is when subsequent calls to receive a message may return 3040 * parts of messages from different associations. Some implementations 3041 * may allow you to turn this value on or off. If so, when turned off, 3042 * no fragment interleave will occur (which will cause a head of line 3043 * blocking amongst multiple associations sharing the same one to many 3044 * socket). When this option is turned on, then each receive call may 3045 * come from a different association (thus the user must receive data 3046 * with the extended calls (e.g. sctp_recvmsg) to keep track of which 3047 * association each receive belongs to. 3048 * 3049 * This option takes a boolean value. A non-zero value indicates that 3050 * fragmented interleave is on. A value of zero indicates that 3051 * fragmented interleave is off. 3052 * 3053 * Note that it is important that an implementation that allows this 3054 * option to be turned on, have it off by default. Otherwise an unaware 3055 * application using the one to many model may become confused and act 3056 * incorrectly. 3057 */ 3058 static int sctp_setsockopt_fragment_interleave(struct sock *sk, 3059 char __user *optval, 3060 unsigned int optlen) 3061 { 3062 int val; 3063 3064 if (optlen != sizeof(int)) 3065 return -EINVAL; 3066 if (get_user(val, (int __user *)optval)) 3067 return -EFAULT; 3068 3069 sctp_sk(sk)->frag_interleave = (val == 0) ? 0 : 1; 3070 3071 return 0; 3072 } 3073 3074 /* 3075 * 8.1.21. Set or Get the SCTP Partial Delivery Point 3076 * (SCTP_PARTIAL_DELIVERY_POINT) 3077 * 3078 * This option will set or get the SCTP partial delivery point. This 3079 * point is the size of a message where the partial delivery API will be 3080 * invoked to help free up rwnd space for the peer. Setting this to a 3081 * lower value will cause partial deliveries to happen more often. The 3082 * calls argument is an integer that sets or gets the partial delivery 3083 * point. Note also that the call will fail if the user attempts to set 3084 * this value larger than the socket receive buffer size. 3085 * 3086 * Note that any single message having a length smaller than or equal to 3087 * the SCTP partial delivery point will be delivered in one single read 3088 * call as long as the user provided buffer is large enough to hold the 3089 * message. 3090 */ 3091 static int sctp_setsockopt_partial_delivery_point(struct sock *sk, 3092 char __user *optval, 3093 unsigned int optlen) 3094 { 3095 u32 val; 3096 3097 if (optlen != sizeof(u32)) 3098 return -EINVAL; 3099 if (get_user(val, (int __user *)optval)) 3100 return -EFAULT; 3101 3102 /* Note: We double the receive buffer from what the user sets 3103 * it to be, also initial rwnd is based on rcvbuf/2. 3104 */ 3105 if (val > (sk->sk_rcvbuf >> 1)) 3106 return -EINVAL; 3107 3108 sctp_sk(sk)->pd_point = val; 3109 3110 return 0; /* is this the right error code? */ 3111 } 3112 3113 /* 3114 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST) 3115 * 3116 * This option will allow a user to change the maximum burst of packets 3117 * that can be emitted by this association. Note that the default value 3118 * is 4, and some implementations may restrict this setting so that it 3119 * can only be lowered. 3120 * 3121 * NOTE: This text doesn't seem right. Do this on a socket basis with 3122 * future associations inheriting the socket value. 3123 */ 3124 static int sctp_setsockopt_maxburst(struct sock *sk, 3125 char __user *optval, 3126 unsigned int optlen) 3127 { 3128 struct sctp_assoc_value params; 3129 struct sctp_sock *sp; 3130 struct sctp_association *asoc; 3131 int val; 3132 int assoc_id = 0; 3133 3134 if (optlen == sizeof(int)) { 3135 printk(KERN_WARNING 3136 "SCTP: Use of int in max_burst socket option deprecated\n"); 3137 printk(KERN_WARNING 3138 "SCTP: Use struct sctp_assoc_value instead\n"); 3139 if (copy_from_user(&val, optval, optlen)) 3140 return -EFAULT; 3141 } else if (optlen == sizeof(struct sctp_assoc_value)) { 3142 if (copy_from_user(¶ms, optval, optlen)) 3143 return -EFAULT; 3144 val = params.assoc_value; 3145 assoc_id = params.assoc_id; 3146 } else 3147 return -EINVAL; 3148 3149 sp = sctp_sk(sk); 3150 3151 if (assoc_id != 0) { 3152 asoc = sctp_id2assoc(sk, assoc_id); 3153 if (!asoc) 3154 return -EINVAL; 3155 asoc->max_burst = val; 3156 } else 3157 sp->max_burst = val; 3158 3159 return 0; 3160 } 3161 3162 /* 3163 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK) 3164 * 3165 * This set option adds a chunk type that the user is requesting to be 3166 * received only in an authenticated way. Changes to the list of chunks 3167 * will only effect future associations on the socket. 3168 */ 3169 static int sctp_setsockopt_auth_chunk(struct sock *sk, 3170 char __user *optval, 3171 unsigned int optlen) 3172 { 3173 struct sctp_authchunk val; 3174 3175 if (!sctp_auth_enable) 3176 return -EACCES; 3177 3178 if (optlen != sizeof(struct sctp_authchunk)) 3179 return -EINVAL; 3180 if (copy_from_user(&val, optval, optlen)) 3181 return -EFAULT; 3182 3183 switch (val.sauth_chunk) { 3184 case SCTP_CID_INIT: 3185 case SCTP_CID_INIT_ACK: 3186 case SCTP_CID_SHUTDOWN_COMPLETE: 3187 case SCTP_CID_AUTH: 3188 return -EINVAL; 3189 } 3190 3191 /* add this chunk id to the endpoint */ 3192 return sctp_auth_ep_add_chunkid(sctp_sk(sk)->ep, val.sauth_chunk); 3193 } 3194 3195 /* 3196 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT) 3197 * 3198 * This option gets or sets the list of HMAC algorithms that the local 3199 * endpoint requires the peer to use. 3200 */ 3201 static int sctp_setsockopt_hmac_ident(struct sock *sk, 3202 char __user *optval, 3203 unsigned int optlen) 3204 { 3205 struct sctp_hmacalgo *hmacs; 3206 u32 idents; 3207 int err; 3208 3209 if (!sctp_auth_enable) 3210 return -EACCES; 3211 3212 if (optlen < sizeof(struct sctp_hmacalgo)) 3213 return -EINVAL; 3214 3215 hmacs = kmalloc(optlen, GFP_KERNEL); 3216 if (!hmacs) 3217 return -ENOMEM; 3218 3219 if (copy_from_user(hmacs, optval, optlen)) { 3220 err = -EFAULT; 3221 goto out; 3222 } 3223 3224 idents = hmacs->shmac_num_idents; 3225 if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS || 3226 (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo))) { 3227 err = -EINVAL; 3228 goto out; 3229 } 3230 3231 err = sctp_auth_ep_set_hmacs(sctp_sk(sk)->ep, hmacs); 3232 out: 3233 kfree(hmacs); 3234 return err; 3235 } 3236 3237 /* 3238 * 7.1.20. Set a shared key (SCTP_AUTH_KEY) 3239 * 3240 * This option will set a shared secret key which is used to build an 3241 * association shared key. 3242 */ 3243 static int sctp_setsockopt_auth_key(struct sock *sk, 3244 char __user *optval, 3245 unsigned int optlen) 3246 { 3247 struct sctp_authkey *authkey; 3248 struct sctp_association *asoc; 3249 int ret; 3250 3251 if (!sctp_auth_enable) 3252 return -EACCES; 3253 3254 if (optlen <= sizeof(struct sctp_authkey)) 3255 return -EINVAL; 3256 3257 authkey = kmalloc(optlen, GFP_KERNEL); 3258 if (!authkey) 3259 return -ENOMEM; 3260 3261 if (copy_from_user(authkey, optval, optlen)) { 3262 ret = -EFAULT; 3263 goto out; 3264 } 3265 3266 if (authkey->sca_keylength > optlen - sizeof(struct sctp_authkey)) { 3267 ret = -EINVAL; 3268 goto out; 3269 } 3270 3271 asoc = sctp_id2assoc(sk, authkey->sca_assoc_id); 3272 if (!asoc && authkey->sca_assoc_id && sctp_style(sk, UDP)) { 3273 ret = -EINVAL; 3274 goto out; 3275 } 3276 3277 ret = sctp_auth_set_key(sctp_sk(sk)->ep, asoc, authkey); 3278 out: 3279 kfree(authkey); 3280 return ret; 3281 } 3282 3283 /* 3284 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY) 3285 * 3286 * This option will get or set the active shared key to be used to build 3287 * the association shared key. 3288 */ 3289 static int sctp_setsockopt_active_key(struct sock *sk, 3290 char __user *optval, 3291 unsigned int optlen) 3292 { 3293 struct sctp_authkeyid val; 3294 struct sctp_association *asoc; 3295 3296 if (!sctp_auth_enable) 3297 return -EACCES; 3298 3299 if (optlen != sizeof(struct sctp_authkeyid)) 3300 return -EINVAL; 3301 if (copy_from_user(&val, optval, optlen)) 3302 return -EFAULT; 3303 3304 asoc = sctp_id2assoc(sk, val.scact_assoc_id); 3305 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP)) 3306 return -EINVAL; 3307 3308 return sctp_auth_set_active_key(sctp_sk(sk)->ep, asoc, 3309 val.scact_keynumber); 3310 } 3311 3312 /* 3313 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY) 3314 * 3315 * This set option will delete a shared secret key from use. 3316 */ 3317 static int sctp_setsockopt_del_key(struct sock *sk, 3318 char __user *optval, 3319 unsigned int optlen) 3320 { 3321 struct sctp_authkeyid val; 3322 struct sctp_association *asoc; 3323 3324 if (!sctp_auth_enable) 3325 return -EACCES; 3326 3327 if (optlen != sizeof(struct sctp_authkeyid)) 3328 return -EINVAL; 3329 if (copy_from_user(&val, optval, optlen)) 3330 return -EFAULT; 3331 3332 asoc = sctp_id2assoc(sk, val.scact_assoc_id); 3333 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP)) 3334 return -EINVAL; 3335 3336 return sctp_auth_del_key_id(sctp_sk(sk)->ep, asoc, 3337 val.scact_keynumber); 3338 3339 } 3340 3341 3342 /* API 6.2 setsockopt(), getsockopt() 3343 * 3344 * Applications use setsockopt() and getsockopt() to set or retrieve 3345 * socket options. Socket options are used to change the default 3346 * behavior of sockets calls. They are described in Section 7. 3347 * 3348 * The syntax is: 3349 * 3350 * ret = getsockopt(int sd, int level, int optname, void __user *optval, 3351 * int __user *optlen); 3352 * ret = setsockopt(int sd, int level, int optname, const void __user *optval, 3353 * int optlen); 3354 * 3355 * sd - the socket descript. 3356 * level - set to IPPROTO_SCTP for all SCTP options. 3357 * optname - the option name. 3358 * optval - the buffer to store the value of the option. 3359 * optlen - the size of the buffer. 3360 */ 3361 SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname, 3362 char __user *optval, unsigned int optlen) 3363 { 3364 int retval = 0; 3365 3366 SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n", 3367 sk, optname); 3368 3369 /* I can hardly begin to describe how wrong this is. This is 3370 * so broken as to be worse than useless. The API draft 3371 * REALLY is NOT helpful here... I am not convinced that the 3372 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP 3373 * are at all well-founded. 3374 */ 3375 if (level != SOL_SCTP) { 3376 struct sctp_af *af = sctp_sk(sk)->pf->af; 3377 retval = af->setsockopt(sk, level, optname, optval, optlen); 3378 goto out_nounlock; 3379 } 3380 3381 sctp_lock_sock(sk); 3382 3383 switch (optname) { 3384 case SCTP_SOCKOPT_BINDX_ADD: 3385 /* 'optlen' is the size of the addresses buffer. */ 3386 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval, 3387 optlen, SCTP_BINDX_ADD_ADDR); 3388 break; 3389 3390 case SCTP_SOCKOPT_BINDX_REM: 3391 /* 'optlen' is the size of the addresses buffer. */ 3392 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval, 3393 optlen, SCTP_BINDX_REM_ADDR); 3394 break; 3395 3396 case SCTP_SOCKOPT_CONNECTX_OLD: 3397 /* 'optlen' is the size of the addresses buffer. */ 3398 retval = sctp_setsockopt_connectx_old(sk, 3399 (struct sockaddr __user *)optval, 3400 optlen); 3401 break; 3402 3403 case SCTP_SOCKOPT_CONNECTX: 3404 /* 'optlen' is the size of the addresses buffer. */ 3405 retval = sctp_setsockopt_connectx(sk, 3406 (struct sockaddr __user *)optval, 3407 optlen); 3408 break; 3409 3410 case SCTP_DISABLE_FRAGMENTS: 3411 retval = sctp_setsockopt_disable_fragments(sk, optval, optlen); 3412 break; 3413 3414 case SCTP_EVENTS: 3415 retval = sctp_setsockopt_events(sk, optval, optlen); 3416 break; 3417 3418 case SCTP_AUTOCLOSE: 3419 retval = sctp_setsockopt_autoclose(sk, optval, optlen); 3420 break; 3421 3422 case SCTP_PEER_ADDR_PARAMS: 3423 retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen); 3424 break; 3425 3426 case SCTP_DELAYED_ACK: 3427 retval = sctp_setsockopt_delayed_ack(sk, optval, optlen); 3428 break; 3429 case SCTP_PARTIAL_DELIVERY_POINT: 3430 retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen); 3431 break; 3432 3433 case SCTP_INITMSG: 3434 retval = sctp_setsockopt_initmsg(sk, optval, optlen); 3435 break; 3436 case SCTP_DEFAULT_SEND_PARAM: 3437 retval = sctp_setsockopt_default_send_param(sk, optval, 3438 optlen); 3439 break; 3440 case SCTP_PRIMARY_ADDR: 3441 retval = sctp_setsockopt_primary_addr(sk, optval, optlen); 3442 break; 3443 case SCTP_SET_PEER_PRIMARY_ADDR: 3444 retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen); 3445 break; 3446 case SCTP_NODELAY: 3447 retval = sctp_setsockopt_nodelay(sk, optval, optlen); 3448 break; 3449 case SCTP_RTOINFO: 3450 retval = sctp_setsockopt_rtoinfo(sk, optval, optlen); 3451 break; 3452 case SCTP_ASSOCINFO: 3453 retval = sctp_setsockopt_associnfo(sk, optval, optlen); 3454 break; 3455 case SCTP_I_WANT_MAPPED_V4_ADDR: 3456 retval = sctp_setsockopt_mappedv4(sk, optval, optlen); 3457 break; 3458 case SCTP_MAXSEG: 3459 retval = sctp_setsockopt_maxseg(sk, optval, optlen); 3460 break; 3461 case SCTP_ADAPTATION_LAYER: 3462 retval = sctp_setsockopt_adaptation_layer(sk, optval, optlen); 3463 break; 3464 case SCTP_CONTEXT: 3465 retval = sctp_setsockopt_context(sk, optval, optlen); 3466 break; 3467 case SCTP_FRAGMENT_INTERLEAVE: 3468 retval = sctp_setsockopt_fragment_interleave(sk, optval, optlen); 3469 break; 3470 case SCTP_MAX_BURST: 3471 retval = sctp_setsockopt_maxburst(sk, optval, optlen); 3472 break; 3473 case SCTP_AUTH_CHUNK: 3474 retval = sctp_setsockopt_auth_chunk(sk, optval, optlen); 3475 break; 3476 case SCTP_HMAC_IDENT: 3477 retval = sctp_setsockopt_hmac_ident(sk, optval, optlen); 3478 break; 3479 case SCTP_AUTH_KEY: 3480 retval = sctp_setsockopt_auth_key(sk, optval, optlen); 3481 break; 3482 case SCTP_AUTH_ACTIVE_KEY: 3483 retval = sctp_setsockopt_active_key(sk, optval, optlen); 3484 break; 3485 case SCTP_AUTH_DELETE_KEY: 3486 retval = sctp_setsockopt_del_key(sk, optval, optlen); 3487 break; 3488 default: 3489 retval = -ENOPROTOOPT; 3490 break; 3491 } 3492 3493 sctp_release_sock(sk); 3494 3495 out_nounlock: 3496 return retval; 3497 } 3498 3499 /* API 3.1.6 connect() - UDP Style Syntax 3500 * 3501 * An application may use the connect() call in the UDP model to initiate an 3502 * association without sending data. 3503 * 3504 * The syntax is: 3505 * 3506 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len); 3507 * 3508 * sd: the socket descriptor to have a new association added to. 3509 * 3510 * nam: the address structure (either struct sockaddr_in or struct 3511 * sockaddr_in6 defined in RFC2553 [7]). 3512 * 3513 * len: the size of the address. 3514 */ 3515 SCTP_STATIC int sctp_connect(struct sock *sk, struct sockaddr *addr, 3516 int addr_len) 3517 { 3518 int err = 0; 3519 struct sctp_af *af; 3520 3521 sctp_lock_sock(sk); 3522 3523 SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n", 3524 __func__, sk, addr, addr_len); 3525 3526 /* Validate addr_len before calling common connect/connectx routine. */ 3527 af = sctp_get_af_specific(addr->sa_family); 3528 if (!af || addr_len < af->sockaddr_len) { 3529 err = -EINVAL; 3530 } else { 3531 /* Pass correct addr len to common routine (so it knows there 3532 * is only one address being passed. 3533 */ 3534 err = __sctp_connect(sk, addr, af->sockaddr_len, NULL); 3535 } 3536 3537 sctp_release_sock(sk); 3538 return err; 3539 } 3540 3541 /* FIXME: Write comments. */ 3542 SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags) 3543 { 3544 return -EOPNOTSUPP; /* STUB */ 3545 } 3546 3547 /* 4.1.4 accept() - TCP Style Syntax 3548 * 3549 * Applications use accept() call to remove an established SCTP 3550 * association from the accept queue of the endpoint. A new socket 3551 * descriptor will be returned from accept() to represent the newly 3552 * formed association. 3553 */ 3554 SCTP_STATIC struct sock *sctp_accept(struct sock *sk, int flags, int *err) 3555 { 3556 struct sctp_sock *sp; 3557 struct sctp_endpoint *ep; 3558 struct sock *newsk = NULL; 3559 struct sctp_association *asoc; 3560 long timeo; 3561 int error = 0; 3562 3563 sctp_lock_sock(sk); 3564 3565 sp = sctp_sk(sk); 3566 ep = sp->ep; 3567 3568 if (!sctp_style(sk, TCP)) { 3569 error = -EOPNOTSUPP; 3570 goto out; 3571 } 3572 3573 if (!sctp_sstate(sk, LISTENING)) { 3574 error = -EINVAL; 3575 goto out; 3576 } 3577 3578 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 3579 3580 error = sctp_wait_for_accept(sk, timeo); 3581 if (error) 3582 goto out; 3583 3584 /* We treat the list of associations on the endpoint as the accept 3585 * queue and pick the first association on the list. 3586 */ 3587 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs); 3588 3589 newsk = sp->pf->create_accept_sk(sk, asoc); 3590 if (!newsk) { 3591 error = -ENOMEM; 3592 goto out; 3593 } 3594 3595 /* Populate the fields of the newsk from the oldsk and migrate the 3596 * asoc to the newsk. 3597 */ 3598 sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP); 3599 3600 out: 3601 sctp_release_sock(sk); 3602 *err = error; 3603 return newsk; 3604 } 3605 3606 /* The SCTP ioctl handler. */ 3607 SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg) 3608 { 3609 return -ENOIOCTLCMD; 3610 } 3611 3612 /* This is the function which gets called during socket creation to 3613 * initialized the SCTP-specific portion of the sock. 3614 * The sock structure should already be zero-filled memory. 3615 */ 3616 SCTP_STATIC int sctp_init_sock(struct sock *sk) 3617 { 3618 struct sctp_endpoint *ep; 3619 struct sctp_sock *sp; 3620 3621 SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk); 3622 3623 sp = sctp_sk(sk); 3624 3625 /* Initialize the SCTP per socket area. */ 3626 switch (sk->sk_type) { 3627 case SOCK_SEQPACKET: 3628 sp->type = SCTP_SOCKET_UDP; 3629 break; 3630 case SOCK_STREAM: 3631 sp->type = SCTP_SOCKET_TCP; 3632 break; 3633 default: 3634 return -ESOCKTNOSUPPORT; 3635 } 3636 3637 /* Initialize default send parameters. These parameters can be 3638 * modified with the SCTP_DEFAULT_SEND_PARAM socket option. 3639 */ 3640 sp->default_stream = 0; 3641 sp->default_ppid = 0; 3642 sp->default_flags = 0; 3643 sp->default_context = 0; 3644 sp->default_timetolive = 0; 3645 3646 sp->default_rcv_context = 0; 3647 sp->max_burst = sctp_max_burst; 3648 3649 /* Initialize default setup parameters. These parameters 3650 * can be modified with the SCTP_INITMSG socket option or 3651 * overridden by the SCTP_INIT CMSG. 3652 */ 3653 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams; 3654 sp->initmsg.sinit_max_instreams = sctp_max_instreams; 3655 sp->initmsg.sinit_max_attempts = sctp_max_retrans_init; 3656 sp->initmsg.sinit_max_init_timeo = sctp_rto_max; 3657 3658 /* Initialize default RTO related parameters. These parameters can 3659 * be modified for with the SCTP_RTOINFO socket option. 3660 */ 3661 sp->rtoinfo.srto_initial = sctp_rto_initial; 3662 sp->rtoinfo.srto_max = sctp_rto_max; 3663 sp->rtoinfo.srto_min = sctp_rto_min; 3664 3665 /* Initialize default association related parameters. These parameters 3666 * can be modified with the SCTP_ASSOCINFO socket option. 3667 */ 3668 sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association; 3669 sp->assocparams.sasoc_number_peer_destinations = 0; 3670 sp->assocparams.sasoc_peer_rwnd = 0; 3671 sp->assocparams.sasoc_local_rwnd = 0; 3672 sp->assocparams.sasoc_cookie_life = sctp_valid_cookie_life; 3673 3674 /* Initialize default event subscriptions. By default, all the 3675 * options are off. 3676 */ 3677 memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe)); 3678 3679 /* Default Peer Address Parameters. These defaults can 3680 * be modified via SCTP_PEER_ADDR_PARAMS 3681 */ 3682 sp->hbinterval = sctp_hb_interval; 3683 sp->pathmaxrxt = sctp_max_retrans_path; 3684 sp->pathmtu = 0; // allow default discovery 3685 sp->sackdelay = sctp_sack_timeout; 3686 sp->sackfreq = 2; 3687 sp->param_flags = SPP_HB_ENABLE | 3688 SPP_PMTUD_ENABLE | 3689 SPP_SACKDELAY_ENABLE; 3690 3691 /* If enabled no SCTP message fragmentation will be performed. 3692 * Configure through SCTP_DISABLE_FRAGMENTS socket option. 3693 */ 3694 sp->disable_fragments = 0; 3695 3696 /* Enable Nagle algorithm by default. */ 3697 sp->nodelay = 0; 3698 3699 /* Enable by default. */ 3700 sp->v4mapped = 1; 3701 3702 /* Auto-close idle associations after the configured 3703 * number of seconds. A value of 0 disables this 3704 * feature. Configure through the SCTP_AUTOCLOSE socket option, 3705 * for UDP-style sockets only. 3706 */ 3707 sp->autoclose = 0; 3708 3709 /* User specified fragmentation limit. */ 3710 sp->user_frag = 0; 3711 3712 sp->adaptation_ind = 0; 3713 3714 sp->pf = sctp_get_pf_specific(sk->sk_family); 3715 3716 /* Control variables for partial data delivery. */ 3717 atomic_set(&sp->pd_mode, 0); 3718 skb_queue_head_init(&sp->pd_lobby); 3719 sp->frag_interleave = 0; 3720 3721 /* Create a per socket endpoint structure. Even if we 3722 * change the data structure relationships, this may still 3723 * be useful for storing pre-connect address information. 3724 */ 3725 ep = sctp_endpoint_new(sk, GFP_KERNEL); 3726 if (!ep) 3727 return -ENOMEM; 3728 3729 sp->ep = ep; 3730 sp->hmac = NULL; 3731 3732 SCTP_DBG_OBJCNT_INC(sock); 3733 3734 local_bh_disable(); 3735 percpu_counter_inc(&sctp_sockets_allocated); 3736 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1); 3737 local_bh_enable(); 3738 3739 return 0; 3740 } 3741 3742 /* Cleanup any SCTP per socket resources. */ 3743 SCTP_STATIC void sctp_destroy_sock(struct sock *sk) 3744 { 3745 struct sctp_endpoint *ep; 3746 3747 SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk); 3748 3749 /* Release our hold on the endpoint. */ 3750 ep = sctp_sk(sk)->ep; 3751 sctp_endpoint_free(ep); 3752 local_bh_disable(); 3753 percpu_counter_dec(&sctp_sockets_allocated); 3754 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1); 3755 local_bh_enable(); 3756 } 3757 3758 /* API 4.1.7 shutdown() - TCP Style Syntax 3759 * int shutdown(int socket, int how); 3760 * 3761 * sd - the socket descriptor of the association to be closed. 3762 * how - Specifies the type of shutdown. The values are 3763 * as follows: 3764 * SHUT_RD 3765 * Disables further receive operations. No SCTP 3766 * protocol action is taken. 3767 * SHUT_WR 3768 * Disables further send operations, and initiates 3769 * the SCTP shutdown sequence. 3770 * SHUT_RDWR 3771 * Disables further send and receive operations 3772 * and initiates the SCTP shutdown sequence. 3773 */ 3774 SCTP_STATIC void sctp_shutdown(struct sock *sk, int how) 3775 { 3776 struct sctp_endpoint *ep; 3777 struct sctp_association *asoc; 3778 3779 if (!sctp_style(sk, TCP)) 3780 return; 3781 3782 if (how & SEND_SHUTDOWN) { 3783 ep = sctp_sk(sk)->ep; 3784 if (!list_empty(&ep->asocs)) { 3785 asoc = list_entry(ep->asocs.next, 3786 struct sctp_association, asocs); 3787 sctp_primitive_SHUTDOWN(asoc, NULL); 3788 } 3789 } 3790 } 3791 3792 /* 7.2.1 Association Status (SCTP_STATUS) 3793 3794 * Applications can retrieve current status information about an 3795 * association, including association state, peer receiver window size, 3796 * number of unacked data chunks, and number of data chunks pending 3797 * receipt. This information is read-only. 3798 */ 3799 static int sctp_getsockopt_sctp_status(struct sock *sk, int len, 3800 char __user *optval, 3801 int __user *optlen) 3802 { 3803 struct sctp_status status; 3804 struct sctp_association *asoc = NULL; 3805 struct sctp_transport *transport; 3806 sctp_assoc_t associd; 3807 int retval = 0; 3808 3809 if (len < sizeof(status)) { 3810 retval = -EINVAL; 3811 goto out; 3812 } 3813 3814 len = sizeof(status); 3815 if (copy_from_user(&status, optval, len)) { 3816 retval = -EFAULT; 3817 goto out; 3818 } 3819 3820 associd = status.sstat_assoc_id; 3821 asoc = sctp_id2assoc(sk, associd); 3822 if (!asoc) { 3823 retval = -EINVAL; 3824 goto out; 3825 } 3826 3827 transport = asoc->peer.primary_path; 3828 3829 status.sstat_assoc_id = sctp_assoc2id(asoc); 3830 status.sstat_state = asoc->state; 3831 status.sstat_rwnd = asoc->peer.rwnd; 3832 status.sstat_unackdata = asoc->unack_data; 3833 3834 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map); 3835 status.sstat_instrms = asoc->c.sinit_max_instreams; 3836 status.sstat_outstrms = asoc->c.sinit_num_ostreams; 3837 status.sstat_fragmentation_point = asoc->frag_point; 3838 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc); 3839 memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr, 3840 transport->af_specific->sockaddr_len); 3841 /* Map ipv4 address into v4-mapped-on-v6 address. */ 3842 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 3843 (union sctp_addr *)&status.sstat_primary.spinfo_address); 3844 status.sstat_primary.spinfo_state = transport->state; 3845 status.sstat_primary.spinfo_cwnd = transport->cwnd; 3846 status.sstat_primary.spinfo_srtt = transport->srtt; 3847 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto); 3848 status.sstat_primary.spinfo_mtu = transport->pathmtu; 3849 3850 if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN) 3851 status.sstat_primary.spinfo_state = SCTP_ACTIVE; 3852 3853 if (put_user(len, optlen)) { 3854 retval = -EFAULT; 3855 goto out; 3856 } 3857 3858 SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n", 3859 len, status.sstat_state, status.sstat_rwnd, 3860 status.sstat_assoc_id); 3861 3862 if (copy_to_user(optval, &status, len)) { 3863 retval = -EFAULT; 3864 goto out; 3865 } 3866 3867 out: 3868 return (retval); 3869 } 3870 3871 3872 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO) 3873 * 3874 * Applications can retrieve information about a specific peer address 3875 * of an association, including its reachability state, congestion 3876 * window, and retransmission timer values. This information is 3877 * read-only. 3878 */ 3879 static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len, 3880 char __user *optval, 3881 int __user *optlen) 3882 { 3883 struct sctp_paddrinfo pinfo; 3884 struct sctp_transport *transport; 3885 int retval = 0; 3886 3887 if (len < sizeof(pinfo)) { 3888 retval = -EINVAL; 3889 goto out; 3890 } 3891 3892 len = sizeof(pinfo); 3893 if (copy_from_user(&pinfo, optval, len)) { 3894 retval = -EFAULT; 3895 goto out; 3896 } 3897 3898 transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address, 3899 pinfo.spinfo_assoc_id); 3900 if (!transport) 3901 return -EINVAL; 3902 3903 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc); 3904 pinfo.spinfo_state = transport->state; 3905 pinfo.spinfo_cwnd = transport->cwnd; 3906 pinfo.spinfo_srtt = transport->srtt; 3907 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto); 3908 pinfo.spinfo_mtu = transport->pathmtu; 3909 3910 if (pinfo.spinfo_state == SCTP_UNKNOWN) 3911 pinfo.spinfo_state = SCTP_ACTIVE; 3912 3913 if (put_user(len, optlen)) { 3914 retval = -EFAULT; 3915 goto out; 3916 } 3917 3918 if (copy_to_user(optval, &pinfo, len)) { 3919 retval = -EFAULT; 3920 goto out; 3921 } 3922 3923 out: 3924 return (retval); 3925 } 3926 3927 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS) 3928 * 3929 * This option is a on/off flag. If enabled no SCTP message 3930 * fragmentation will be performed. Instead if a message being sent 3931 * exceeds the current PMTU size, the message will NOT be sent and 3932 * instead a error will be indicated to the user. 3933 */ 3934 static int sctp_getsockopt_disable_fragments(struct sock *sk, int len, 3935 char __user *optval, int __user *optlen) 3936 { 3937 int val; 3938 3939 if (len < sizeof(int)) 3940 return -EINVAL; 3941 3942 len = sizeof(int); 3943 val = (sctp_sk(sk)->disable_fragments == 1); 3944 if (put_user(len, optlen)) 3945 return -EFAULT; 3946 if (copy_to_user(optval, &val, len)) 3947 return -EFAULT; 3948 return 0; 3949 } 3950 3951 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS) 3952 * 3953 * This socket option is used to specify various notifications and 3954 * ancillary data the user wishes to receive. 3955 */ 3956 static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval, 3957 int __user *optlen) 3958 { 3959 if (len < sizeof(struct sctp_event_subscribe)) 3960 return -EINVAL; 3961 len = sizeof(struct sctp_event_subscribe); 3962 if (put_user(len, optlen)) 3963 return -EFAULT; 3964 if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len)) 3965 return -EFAULT; 3966 return 0; 3967 } 3968 3969 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE) 3970 * 3971 * This socket option is applicable to the UDP-style socket only. When 3972 * set it will cause associations that are idle for more than the 3973 * specified number of seconds to automatically close. An association 3974 * being idle is defined an association that has NOT sent or received 3975 * user data. The special value of '0' indicates that no automatic 3976 * close of any associations should be performed. The option expects an 3977 * integer defining the number of seconds of idle time before an 3978 * association is closed. 3979 */ 3980 static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen) 3981 { 3982 /* Applicable to UDP-style socket only */ 3983 if (sctp_style(sk, TCP)) 3984 return -EOPNOTSUPP; 3985 if (len < sizeof(int)) 3986 return -EINVAL; 3987 len = sizeof(int); 3988 if (put_user(len, optlen)) 3989 return -EFAULT; 3990 if (copy_to_user(optval, &sctp_sk(sk)->autoclose, sizeof(int))) 3991 return -EFAULT; 3992 return 0; 3993 } 3994 3995 /* Helper routine to branch off an association to a new socket. */ 3996 SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc, 3997 struct socket **sockp) 3998 { 3999 struct sock *sk = asoc->base.sk; 4000 struct socket *sock; 4001 struct sctp_af *af; 4002 int err = 0; 4003 4004 /* An association cannot be branched off from an already peeled-off 4005 * socket, nor is this supported for tcp style sockets. 4006 */ 4007 if (!sctp_style(sk, UDP)) 4008 return -EINVAL; 4009 4010 /* Create a new socket. */ 4011 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock); 4012 if (err < 0) 4013 return err; 4014 4015 sctp_copy_sock(sock->sk, sk, asoc); 4016 4017 /* Make peeled-off sockets more like 1-1 accepted sockets. 4018 * Set the daddr and initialize id to something more random 4019 */ 4020 af = sctp_get_af_specific(asoc->peer.primary_addr.sa.sa_family); 4021 af->to_sk_daddr(&asoc->peer.primary_addr, sk); 4022 4023 /* Populate the fields of the newsk from the oldsk and migrate the 4024 * asoc to the newsk. 4025 */ 4026 sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH); 4027 4028 *sockp = sock; 4029 4030 return err; 4031 } 4032 4033 static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen) 4034 { 4035 sctp_peeloff_arg_t peeloff; 4036 struct socket *newsock; 4037 int retval = 0; 4038 struct sctp_association *asoc; 4039 4040 if (len < sizeof(sctp_peeloff_arg_t)) 4041 return -EINVAL; 4042 len = sizeof(sctp_peeloff_arg_t); 4043 if (copy_from_user(&peeloff, optval, len)) 4044 return -EFAULT; 4045 4046 asoc = sctp_id2assoc(sk, peeloff.associd); 4047 if (!asoc) { 4048 retval = -EINVAL; 4049 goto out; 4050 } 4051 4052 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __func__, sk, asoc); 4053 4054 retval = sctp_do_peeloff(asoc, &newsock); 4055 if (retval < 0) 4056 goto out; 4057 4058 /* Map the socket to an unused fd that can be returned to the user. */ 4059 retval = sock_map_fd(newsock, 0); 4060 if (retval < 0) { 4061 sock_release(newsock); 4062 goto out; 4063 } 4064 4065 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n", 4066 __func__, sk, asoc, newsock->sk, retval); 4067 4068 /* Return the fd mapped to the new socket. */ 4069 peeloff.sd = retval; 4070 if (put_user(len, optlen)) 4071 return -EFAULT; 4072 if (copy_to_user(optval, &peeloff, len)) 4073 retval = -EFAULT; 4074 4075 out: 4076 return retval; 4077 } 4078 4079 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS) 4080 * 4081 * Applications can enable or disable heartbeats for any peer address of 4082 * an association, modify an address's heartbeat interval, force a 4083 * heartbeat to be sent immediately, and adjust the address's maximum 4084 * number of retransmissions sent before an address is considered 4085 * unreachable. The following structure is used to access and modify an 4086 * address's parameters: 4087 * 4088 * struct sctp_paddrparams { 4089 * sctp_assoc_t spp_assoc_id; 4090 * struct sockaddr_storage spp_address; 4091 * uint32_t spp_hbinterval; 4092 * uint16_t spp_pathmaxrxt; 4093 * uint32_t spp_pathmtu; 4094 * uint32_t spp_sackdelay; 4095 * uint32_t spp_flags; 4096 * }; 4097 * 4098 * spp_assoc_id - (one-to-many style socket) This is filled in the 4099 * application, and identifies the association for 4100 * this query. 4101 * spp_address - This specifies which address is of interest. 4102 * spp_hbinterval - This contains the value of the heartbeat interval, 4103 * in milliseconds. If a value of zero 4104 * is present in this field then no changes are to 4105 * be made to this parameter. 4106 * spp_pathmaxrxt - This contains the maximum number of 4107 * retransmissions before this address shall be 4108 * considered unreachable. If a value of zero 4109 * is present in this field then no changes are to 4110 * be made to this parameter. 4111 * spp_pathmtu - When Path MTU discovery is disabled the value 4112 * specified here will be the "fixed" path mtu. 4113 * Note that if the spp_address field is empty 4114 * then all associations on this address will 4115 * have this fixed path mtu set upon them. 4116 * 4117 * spp_sackdelay - When delayed sack is enabled, this value specifies 4118 * the number of milliseconds that sacks will be delayed 4119 * for. This value will apply to all addresses of an 4120 * association if the spp_address field is empty. Note 4121 * also, that if delayed sack is enabled and this 4122 * value is set to 0, no change is made to the last 4123 * recorded delayed sack timer value. 4124 * 4125 * spp_flags - These flags are used to control various features 4126 * on an association. The flag field may contain 4127 * zero or more of the following options. 4128 * 4129 * SPP_HB_ENABLE - Enable heartbeats on the 4130 * specified address. Note that if the address 4131 * field is empty all addresses for the association 4132 * have heartbeats enabled upon them. 4133 * 4134 * SPP_HB_DISABLE - Disable heartbeats on the 4135 * speicifed address. Note that if the address 4136 * field is empty all addresses for the association 4137 * will have their heartbeats disabled. Note also 4138 * that SPP_HB_ENABLE and SPP_HB_DISABLE are 4139 * mutually exclusive, only one of these two should 4140 * be specified. Enabling both fields will have 4141 * undetermined results. 4142 * 4143 * SPP_HB_DEMAND - Request a user initiated heartbeat 4144 * to be made immediately. 4145 * 4146 * SPP_PMTUD_ENABLE - This field will enable PMTU 4147 * discovery upon the specified address. Note that 4148 * if the address feild is empty then all addresses 4149 * on the association are effected. 4150 * 4151 * SPP_PMTUD_DISABLE - This field will disable PMTU 4152 * discovery upon the specified address. Note that 4153 * if the address feild is empty then all addresses 4154 * on the association are effected. Not also that 4155 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually 4156 * exclusive. Enabling both will have undetermined 4157 * results. 4158 * 4159 * SPP_SACKDELAY_ENABLE - Setting this flag turns 4160 * on delayed sack. The time specified in spp_sackdelay 4161 * is used to specify the sack delay for this address. Note 4162 * that if spp_address is empty then all addresses will 4163 * enable delayed sack and take on the sack delay 4164 * value specified in spp_sackdelay. 4165 * SPP_SACKDELAY_DISABLE - Setting this flag turns 4166 * off delayed sack. If the spp_address field is blank then 4167 * delayed sack is disabled for the entire association. Note 4168 * also that this field is mutually exclusive to 4169 * SPP_SACKDELAY_ENABLE, setting both will have undefined 4170 * results. 4171 */ 4172 static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len, 4173 char __user *optval, int __user *optlen) 4174 { 4175 struct sctp_paddrparams params; 4176 struct sctp_transport *trans = NULL; 4177 struct sctp_association *asoc = NULL; 4178 struct sctp_sock *sp = sctp_sk(sk); 4179 4180 if (len < sizeof(struct sctp_paddrparams)) 4181 return -EINVAL; 4182 len = sizeof(struct sctp_paddrparams); 4183 if (copy_from_user(¶ms, optval, len)) 4184 return -EFAULT; 4185 4186 /* If an address other than INADDR_ANY is specified, and 4187 * no transport is found, then the request is invalid. 4188 */ 4189 if (!sctp_is_any(sk, ( union sctp_addr *)¶ms.spp_address)) { 4190 trans = sctp_addr_id2transport(sk, ¶ms.spp_address, 4191 params.spp_assoc_id); 4192 if (!trans) { 4193 SCTP_DEBUG_PRINTK("Failed no transport\n"); 4194 return -EINVAL; 4195 } 4196 } 4197 4198 /* Get association, if assoc_id != 0 and the socket is a one 4199 * to many style socket, and an association was not found, then 4200 * the id was invalid. 4201 */ 4202 asoc = sctp_id2assoc(sk, params.spp_assoc_id); 4203 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) { 4204 SCTP_DEBUG_PRINTK("Failed no association\n"); 4205 return -EINVAL; 4206 } 4207 4208 if (trans) { 4209 /* Fetch transport values. */ 4210 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval); 4211 params.spp_pathmtu = trans->pathmtu; 4212 params.spp_pathmaxrxt = trans->pathmaxrxt; 4213 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay); 4214 4215 /*draft-11 doesn't say what to return in spp_flags*/ 4216 params.spp_flags = trans->param_flags; 4217 } else if (asoc) { 4218 /* Fetch association values. */ 4219 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval); 4220 params.spp_pathmtu = asoc->pathmtu; 4221 params.spp_pathmaxrxt = asoc->pathmaxrxt; 4222 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay); 4223 4224 /*draft-11 doesn't say what to return in spp_flags*/ 4225 params.spp_flags = asoc->param_flags; 4226 } else { 4227 /* Fetch socket values. */ 4228 params.spp_hbinterval = sp->hbinterval; 4229 params.spp_pathmtu = sp->pathmtu; 4230 params.spp_sackdelay = sp->sackdelay; 4231 params.spp_pathmaxrxt = sp->pathmaxrxt; 4232 4233 /*draft-11 doesn't say what to return in spp_flags*/ 4234 params.spp_flags = sp->param_flags; 4235 } 4236 4237 if (copy_to_user(optval, ¶ms, len)) 4238 return -EFAULT; 4239 4240 if (put_user(len, optlen)) 4241 return -EFAULT; 4242 4243 return 0; 4244 } 4245 4246 /* 4247 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK) 4248 * 4249 * This option will effect the way delayed acks are performed. This 4250 * option allows you to get or set the delayed ack time, in 4251 * milliseconds. It also allows changing the delayed ack frequency. 4252 * Changing the frequency to 1 disables the delayed sack algorithm. If 4253 * the assoc_id is 0, then this sets or gets the endpoints default 4254 * values. If the assoc_id field is non-zero, then the set or get 4255 * effects the specified association for the one to many model (the 4256 * assoc_id field is ignored by the one to one model). Note that if 4257 * sack_delay or sack_freq are 0 when setting this option, then the 4258 * current values will remain unchanged. 4259 * 4260 * struct sctp_sack_info { 4261 * sctp_assoc_t sack_assoc_id; 4262 * uint32_t sack_delay; 4263 * uint32_t sack_freq; 4264 * }; 4265 * 4266 * sack_assoc_id - This parameter, indicates which association the user 4267 * is performing an action upon. Note that if this field's value is 4268 * zero then the endpoints default value is changed (effecting future 4269 * associations only). 4270 * 4271 * sack_delay - This parameter contains the number of milliseconds that 4272 * the user is requesting the delayed ACK timer be set to. Note that 4273 * this value is defined in the standard to be between 200 and 500 4274 * milliseconds. 4275 * 4276 * sack_freq - This parameter contains the number of packets that must 4277 * be received before a sack is sent without waiting for the delay 4278 * timer to expire. The default value for this is 2, setting this 4279 * value to 1 will disable the delayed sack algorithm. 4280 */ 4281 static int sctp_getsockopt_delayed_ack(struct sock *sk, int len, 4282 char __user *optval, 4283 int __user *optlen) 4284 { 4285 struct sctp_sack_info params; 4286 struct sctp_association *asoc = NULL; 4287 struct sctp_sock *sp = sctp_sk(sk); 4288 4289 if (len >= sizeof(struct sctp_sack_info)) { 4290 len = sizeof(struct sctp_sack_info); 4291 4292 if (copy_from_user(¶ms, optval, len)) 4293 return -EFAULT; 4294 } else if (len == sizeof(struct sctp_assoc_value)) { 4295 printk(KERN_WARNING "SCTP: Use of struct sctp_assoc_value " 4296 "in delayed_ack socket option deprecated\n"); 4297 printk(KERN_WARNING "SCTP: Use struct sctp_sack_info instead\n"); 4298 if (copy_from_user(¶ms, optval, len)) 4299 return -EFAULT; 4300 } else 4301 return - EINVAL; 4302 4303 /* Get association, if sack_assoc_id != 0 and the socket is a one 4304 * to many style socket, and an association was not found, then 4305 * the id was invalid. 4306 */ 4307 asoc = sctp_id2assoc(sk, params.sack_assoc_id); 4308 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP)) 4309 return -EINVAL; 4310 4311 if (asoc) { 4312 /* Fetch association values. */ 4313 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) { 4314 params.sack_delay = jiffies_to_msecs( 4315 asoc->sackdelay); 4316 params.sack_freq = asoc->sackfreq; 4317 4318 } else { 4319 params.sack_delay = 0; 4320 params.sack_freq = 1; 4321 } 4322 } else { 4323 /* Fetch socket values. */ 4324 if (sp->param_flags & SPP_SACKDELAY_ENABLE) { 4325 params.sack_delay = sp->sackdelay; 4326 params.sack_freq = sp->sackfreq; 4327 } else { 4328 params.sack_delay = 0; 4329 params.sack_freq = 1; 4330 } 4331 } 4332 4333 if (copy_to_user(optval, ¶ms, len)) 4334 return -EFAULT; 4335 4336 if (put_user(len, optlen)) 4337 return -EFAULT; 4338 4339 return 0; 4340 } 4341 4342 /* 7.1.3 Initialization Parameters (SCTP_INITMSG) 4343 * 4344 * Applications can specify protocol parameters for the default association 4345 * initialization. The option name argument to setsockopt() and getsockopt() 4346 * is SCTP_INITMSG. 4347 * 4348 * Setting initialization parameters is effective only on an unconnected 4349 * socket (for UDP-style sockets only future associations are effected 4350 * by the change). With TCP-style sockets, this option is inherited by 4351 * sockets derived from a listener socket. 4352 */ 4353 static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen) 4354 { 4355 if (len < sizeof(struct sctp_initmsg)) 4356 return -EINVAL; 4357 len = sizeof(struct sctp_initmsg); 4358 if (put_user(len, optlen)) 4359 return -EFAULT; 4360 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len)) 4361 return -EFAULT; 4362 return 0; 4363 } 4364 4365 4366 static int sctp_getsockopt_peer_addrs(struct sock *sk, int len, 4367 char __user *optval, int __user *optlen) 4368 { 4369 struct sctp_association *asoc; 4370 int cnt = 0; 4371 struct sctp_getaddrs getaddrs; 4372 struct sctp_transport *from; 4373 void __user *to; 4374 union sctp_addr temp; 4375 struct sctp_sock *sp = sctp_sk(sk); 4376 int addrlen; 4377 size_t space_left; 4378 int bytes_copied; 4379 4380 if (len < sizeof(struct sctp_getaddrs)) 4381 return -EINVAL; 4382 4383 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs))) 4384 return -EFAULT; 4385 4386 /* For UDP-style sockets, id specifies the association to query. */ 4387 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 4388 if (!asoc) 4389 return -EINVAL; 4390 4391 to = optval + offsetof(struct sctp_getaddrs,addrs); 4392 space_left = len - offsetof(struct sctp_getaddrs,addrs); 4393 4394 list_for_each_entry(from, &asoc->peer.transport_addr_list, 4395 transports) { 4396 memcpy(&temp, &from->ipaddr, sizeof(temp)); 4397 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 4398 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 4399 if (space_left < addrlen) 4400 return -ENOMEM; 4401 if (copy_to_user(to, &temp, addrlen)) 4402 return -EFAULT; 4403 to += addrlen; 4404 cnt++; 4405 space_left -= addrlen; 4406 } 4407 4408 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) 4409 return -EFAULT; 4410 bytes_copied = ((char __user *)to) - optval; 4411 if (put_user(bytes_copied, optlen)) 4412 return -EFAULT; 4413 4414 return 0; 4415 } 4416 4417 static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to, 4418 size_t space_left, int *bytes_copied) 4419 { 4420 struct sctp_sockaddr_entry *addr; 4421 union sctp_addr temp; 4422 int cnt = 0; 4423 int addrlen; 4424 4425 rcu_read_lock(); 4426 list_for_each_entry_rcu(addr, &sctp_local_addr_list, list) { 4427 if (!addr->valid) 4428 continue; 4429 4430 if ((PF_INET == sk->sk_family) && 4431 (AF_INET6 == addr->a.sa.sa_family)) 4432 continue; 4433 if ((PF_INET6 == sk->sk_family) && 4434 inet_v6_ipv6only(sk) && 4435 (AF_INET == addr->a.sa.sa_family)) 4436 continue; 4437 memcpy(&temp, &addr->a, sizeof(temp)); 4438 if (!temp.v4.sin_port) 4439 temp.v4.sin_port = htons(port); 4440 4441 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 4442 &temp); 4443 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 4444 if (space_left < addrlen) { 4445 cnt = -ENOMEM; 4446 break; 4447 } 4448 memcpy(to, &temp, addrlen); 4449 4450 to += addrlen; 4451 cnt ++; 4452 space_left -= addrlen; 4453 *bytes_copied += addrlen; 4454 } 4455 rcu_read_unlock(); 4456 4457 return cnt; 4458 } 4459 4460 4461 static int sctp_getsockopt_local_addrs(struct sock *sk, int len, 4462 char __user *optval, int __user *optlen) 4463 { 4464 struct sctp_bind_addr *bp; 4465 struct sctp_association *asoc; 4466 int cnt = 0; 4467 struct sctp_getaddrs getaddrs; 4468 struct sctp_sockaddr_entry *addr; 4469 void __user *to; 4470 union sctp_addr temp; 4471 struct sctp_sock *sp = sctp_sk(sk); 4472 int addrlen; 4473 int err = 0; 4474 size_t space_left; 4475 int bytes_copied = 0; 4476 void *addrs; 4477 void *buf; 4478 4479 if (len < sizeof(struct sctp_getaddrs)) 4480 return -EINVAL; 4481 4482 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs))) 4483 return -EFAULT; 4484 4485 /* 4486 * For UDP-style sockets, id specifies the association to query. 4487 * If the id field is set to the value '0' then the locally bound 4488 * addresses are returned without regard to any particular 4489 * association. 4490 */ 4491 if (0 == getaddrs.assoc_id) { 4492 bp = &sctp_sk(sk)->ep->base.bind_addr; 4493 } else { 4494 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 4495 if (!asoc) 4496 return -EINVAL; 4497 bp = &asoc->base.bind_addr; 4498 } 4499 4500 to = optval + offsetof(struct sctp_getaddrs,addrs); 4501 space_left = len - offsetof(struct sctp_getaddrs,addrs); 4502 4503 addrs = kmalloc(space_left, GFP_KERNEL); 4504 if (!addrs) 4505 return -ENOMEM; 4506 4507 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid 4508 * addresses from the global local address list. 4509 */ 4510 if (sctp_list_single_entry(&bp->address_list)) { 4511 addr = list_entry(bp->address_list.next, 4512 struct sctp_sockaddr_entry, list); 4513 if (sctp_is_any(sk, &addr->a)) { 4514 cnt = sctp_copy_laddrs(sk, bp->port, addrs, 4515 space_left, &bytes_copied); 4516 if (cnt < 0) { 4517 err = cnt; 4518 goto out; 4519 } 4520 goto copy_getaddrs; 4521 } 4522 } 4523 4524 buf = addrs; 4525 /* Protection on the bound address list is not needed since 4526 * in the socket option context we hold a socket lock and 4527 * thus the bound address list can't change. 4528 */ 4529 list_for_each_entry(addr, &bp->address_list, list) { 4530 memcpy(&temp, &addr->a, sizeof(temp)); 4531 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 4532 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 4533 if (space_left < addrlen) { 4534 err = -ENOMEM; /*fixme: right error?*/ 4535 goto out; 4536 } 4537 memcpy(buf, &temp, addrlen); 4538 buf += addrlen; 4539 bytes_copied += addrlen; 4540 cnt ++; 4541 space_left -= addrlen; 4542 } 4543 4544 copy_getaddrs: 4545 if (copy_to_user(to, addrs, bytes_copied)) { 4546 err = -EFAULT; 4547 goto out; 4548 } 4549 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) { 4550 err = -EFAULT; 4551 goto out; 4552 } 4553 if (put_user(bytes_copied, optlen)) 4554 err = -EFAULT; 4555 out: 4556 kfree(addrs); 4557 return err; 4558 } 4559 4560 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR) 4561 * 4562 * Requests that the local SCTP stack use the enclosed peer address as 4563 * the association primary. The enclosed address must be one of the 4564 * association peer's addresses. 4565 */ 4566 static int sctp_getsockopt_primary_addr(struct sock *sk, int len, 4567 char __user *optval, int __user *optlen) 4568 { 4569 struct sctp_prim prim; 4570 struct sctp_association *asoc; 4571 struct sctp_sock *sp = sctp_sk(sk); 4572 4573 if (len < sizeof(struct sctp_prim)) 4574 return -EINVAL; 4575 4576 len = sizeof(struct sctp_prim); 4577 4578 if (copy_from_user(&prim, optval, len)) 4579 return -EFAULT; 4580 4581 asoc = sctp_id2assoc(sk, prim.ssp_assoc_id); 4582 if (!asoc) 4583 return -EINVAL; 4584 4585 if (!asoc->peer.primary_path) 4586 return -ENOTCONN; 4587 4588 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr, 4589 asoc->peer.primary_path->af_specific->sockaddr_len); 4590 4591 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, 4592 (union sctp_addr *)&prim.ssp_addr); 4593 4594 if (put_user(len, optlen)) 4595 return -EFAULT; 4596 if (copy_to_user(optval, &prim, len)) 4597 return -EFAULT; 4598 4599 return 0; 4600 } 4601 4602 /* 4603 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER) 4604 * 4605 * Requests that the local endpoint set the specified Adaptation Layer 4606 * Indication parameter for all future INIT and INIT-ACK exchanges. 4607 */ 4608 static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len, 4609 char __user *optval, int __user *optlen) 4610 { 4611 struct sctp_setadaptation adaptation; 4612 4613 if (len < sizeof(struct sctp_setadaptation)) 4614 return -EINVAL; 4615 4616 len = sizeof(struct sctp_setadaptation); 4617 4618 adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind; 4619 4620 if (put_user(len, optlen)) 4621 return -EFAULT; 4622 if (copy_to_user(optval, &adaptation, len)) 4623 return -EFAULT; 4624 4625 return 0; 4626 } 4627 4628 /* 4629 * 4630 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM) 4631 * 4632 * Applications that wish to use the sendto() system call may wish to 4633 * specify a default set of parameters that would normally be supplied 4634 * through the inclusion of ancillary data. This socket option allows 4635 * such an application to set the default sctp_sndrcvinfo structure. 4636 4637 4638 * The application that wishes to use this socket option simply passes 4639 * in to this call the sctp_sndrcvinfo structure defined in Section 4640 * 5.2.2) The input parameters accepted by this call include 4641 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context, 4642 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in 4643 * to this call if the caller is using the UDP model. 4644 * 4645 * For getsockopt, it get the default sctp_sndrcvinfo structure. 4646 */ 4647 static int sctp_getsockopt_default_send_param(struct sock *sk, 4648 int len, char __user *optval, 4649 int __user *optlen) 4650 { 4651 struct sctp_sndrcvinfo info; 4652 struct sctp_association *asoc; 4653 struct sctp_sock *sp = sctp_sk(sk); 4654 4655 if (len < sizeof(struct sctp_sndrcvinfo)) 4656 return -EINVAL; 4657 4658 len = sizeof(struct sctp_sndrcvinfo); 4659 4660 if (copy_from_user(&info, optval, len)) 4661 return -EFAULT; 4662 4663 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id); 4664 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP)) 4665 return -EINVAL; 4666 4667 if (asoc) { 4668 info.sinfo_stream = asoc->default_stream; 4669 info.sinfo_flags = asoc->default_flags; 4670 info.sinfo_ppid = asoc->default_ppid; 4671 info.sinfo_context = asoc->default_context; 4672 info.sinfo_timetolive = asoc->default_timetolive; 4673 } else { 4674 info.sinfo_stream = sp->default_stream; 4675 info.sinfo_flags = sp->default_flags; 4676 info.sinfo_ppid = sp->default_ppid; 4677 info.sinfo_context = sp->default_context; 4678 info.sinfo_timetolive = sp->default_timetolive; 4679 } 4680 4681 if (put_user(len, optlen)) 4682 return -EFAULT; 4683 if (copy_to_user(optval, &info, len)) 4684 return -EFAULT; 4685 4686 return 0; 4687 } 4688 4689 /* 4690 * 4691 * 7.1.5 SCTP_NODELAY 4692 * 4693 * Turn on/off any Nagle-like algorithm. This means that packets are 4694 * generally sent as soon as possible and no unnecessary delays are 4695 * introduced, at the cost of more packets in the network. Expects an 4696 * integer boolean flag. 4697 */ 4698 4699 static int sctp_getsockopt_nodelay(struct sock *sk, int len, 4700 char __user *optval, int __user *optlen) 4701 { 4702 int val; 4703 4704 if (len < sizeof(int)) 4705 return -EINVAL; 4706 4707 len = sizeof(int); 4708 val = (sctp_sk(sk)->nodelay == 1); 4709 if (put_user(len, optlen)) 4710 return -EFAULT; 4711 if (copy_to_user(optval, &val, len)) 4712 return -EFAULT; 4713 return 0; 4714 } 4715 4716 /* 4717 * 4718 * 7.1.1 SCTP_RTOINFO 4719 * 4720 * The protocol parameters used to initialize and bound retransmission 4721 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access 4722 * and modify these parameters. 4723 * All parameters are time values, in milliseconds. A value of 0, when 4724 * modifying the parameters, indicates that the current value should not 4725 * be changed. 4726 * 4727 */ 4728 static int sctp_getsockopt_rtoinfo(struct sock *sk, int len, 4729 char __user *optval, 4730 int __user *optlen) { 4731 struct sctp_rtoinfo rtoinfo; 4732 struct sctp_association *asoc; 4733 4734 if (len < sizeof (struct sctp_rtoinfo)) 4735 return -EINVAL; 4736 4737 len = sizeof(struct sctp_rtoinfo); 4738 4739 if (copy_from_user(&rtoinfo, optval, len)) 4740 return -EFAULT; 4741 4742 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id); 4743 4744 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP)) 4745 return -EINVAL; 4746 4747 /* Values corresponding to the specific association. */ 4748 if (asoc) { 4749 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial); 4750 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max); 4751 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min); 4752 } else { 4753 /* Values corresponding to the endpoint. */ 4754 struct sctp_sock *sp = sctp_sk(sk); 4755 4756 rtoinfo.srto_initial = sp->rtoinfo.srto_initial; 4757 rtoinfo.srto_max = sp->rtoinfo.srto_max; 4758 rtoinfo.srto_min = sp->rtoinfo.srto_min; 4759 } 4760 4761 if (put_user(len, optlen)) 4762 return -EFAULT; 4763 4764 if (copy_to_user(optval, &rtoinfo, len)) 4765 return -EFAULT; 4766 4767 return 0; 4768 } 4769 4770 /* 4771 * 4772 * 7.1.2 SCTP_ASSOCINFO 4773 * 4774 * This option is used to tune the maximum retransmission attempts 4775 * of the association. 4776 * Returns an error if the new association retransmission value is 4777 * greater than the sum of the retransmission value of the peer. 4778 * See [SCTP] for more information. 4779 * 4780 */ 4781 static int sctp_getsockopt_associnfo(struct sock *sk, int len, 4782 char __user *optval, 4783 int __user *optlen) 4784 { 4785 4786 struct sctp_assocparams assocparams; 4787 struct sctp_association *asoc; 4788 struct list_head *pos; 4789 int cnt = 0; 4790 4791 if (len < sizeof (struct sctp_assocparams)) 4792 return -EINVAL; 4793 4794 len = sizeof(struct sctp_assocparams); 4795 4796 if (copy_from_user(&assocparams, optval, len)) 4797 return -EFAULT; 4798 4799 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id); 4800 4801 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP)) 4802 return -EINVAL; 4803 4804 /* Values correspoinding to the specific association */ 4805 if (asoc) { 4806 assocparams.sasoc_asocmaxrxt = asoc->max_retrans; 4807 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd; 4808 assocparams.sasoc_local_rwnd = asoc->a_rwnd; 4809 assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec 4810 * 1000) + 4811 (asoc->cookie_life.tv_usec 4812 / 1000); 4813 4814 list_for_each(pos, &asoc->peer.transport_addr_list) { 4815 cnt ++; 4816 } 4817 4818 assocparams.sasoc_number_peer_destinations = cnt; 4819 } else { 4820 /* Values corresponding to the endpoint */ 4821 struct sctp_sock *sp = sctp_sk(sk); 4822 4823 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt; 4824 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd; 4825 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd; 4826 assocparams.sasoc_cookie_life = 4827 sp->assocparams.sasoc_cookie_life; 4828 assocparams.sasoc_number_peer_destinations = 4829 sp->assocparams. 4830 sasoc_number_peer_destinations; 4831 } 4832 4833 if (put_user(len, optlen)) 4834 return -EFAULT; 4835 4836 if (copy_to_user(optval, &assocparams, len)) 4837 return -EFAULT; 4838 4839 return 0; 4840 } 4841 4842 /* 4843 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR) 4844 * 4845 * This socket option is a boolean flag which turns on or off mapped V4 4846 * addresses. If this option is turned on and the socket is type 4847 * PF_INET6, then IPv4 addresses will be mapped to V6 representation. 4848 * If this option is turned off, then no mapping will be done of V4 4849 * addresses and a user will receive both PF_INET6 and PF_INET type 4850 * addresses on the socket. 4851 */ 4852 static int sctp_getsockopt_mappedv4(struct sock *sk, int len, 4853 char __user *optval, int __user *optlen) 4854 { 4855 int val; 4856 struct sctp_sock *sp = sctp_sk(sk); 4857 4858 if (len < sizeof(int)) 4859 return -EINVAL; 4860 4861 len = sizeof(int); 4862 val = sp->v4mapped; 4863 if (put_user(len, optlen)) 4864 return -EFAULT; 4865 if (copy_to_user(optval, &val, len)) 4866 return -EFAULT; 4867 4868 return 0; 4869 } 4870 4871 /* 4872 * 7.1.29. Set or Get the default context (SCTP_CONTEXT) 4873 * (chapter and verse is quoted at sctp_setsockopt_context()) 4874 */ 4875 static int sctp_getsockopt_context(struct sock *sk, int len, 4876 char __user *optval, int __user *optlen) 4877 { 4878 struct sctp_assoc_value params; 4879 struct sctp_sock *sp; 4880 struct sctp_association *asoc; 4881 4882 if (len < sizeof(struct sctp_assoc_value)) 4883 return -EINVAL; 4884 4885 len = sizeof(struct sctp_assoc_value); 4886 4887 if (copy_from_user(¶ms, optval, len)) 4888 return -EFAULT; 4889 4890 sp = sctp_sk(sk); 4891 4892 if (params.assoc_id != 0) { 4893 asoc = sctp_id2assoc(sk, params.assoc_id); 4894 if (!asoc) 4895 return -EINVAL; 4896 params.assoc_value = asoc->default_rcv_context; 4897 } else { 4898 params.assoc_value = sp->default_rcv_context; 4899 } 4900 4901 if (put_user(len, optlen)) 4902 return -EFAULT; 4903 if (copy_to_user(optval, ¶ms, len)) 4904 return -EFAULT; 4905 4906 return 0; 4907 } 4908 4909 /* 4910 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG) 4911 * This option will get or set the maximum size to put in any outgoing 4912 * SCTP DATA chunk. If a message is larger than this size it will be 4913 * fragmented by SCTP into the specified size. Note that the underlying 4914 * SCTP implementation may fragment into smaller sized chunks when the 4915 * PMTU of the underlying association is smaller than the value set by 4916 * the user. The default value for this option is '0' which indicates 4917 * the user is NOT limiting fragmentation and only the PMTU will effect 4918 * SCTP's choice of DATA chunk size. Note also that values set larger 4919 * than the maximum size of an IP datagram will effectively let SCTP 4920 * control fragmentation (i.e. the same as setting this option to 0). 4921 * 4922 * The following structure is used to access and modify this parameter: 4923 * 4924 * struct sctp_assoc_value { 4925 * sctp_assoc_t assoc_id; 4926 * uint32_t assoc_value; 4927 * }; 4928 * 4929 * assoc_id: This parameter is ignored for one-to-one style sockets. 4930 * For one-to-many style sockets this parameter indicates which 4931 * association the user is performing an action upon. Note that if 4932 * this field's value is zero then the endpoints default value is 4933 * changed (effecting future associations only). 4934 * assoc_value: This parameter specifies the maximum size in bytes. 4935 */ 4936 static int sctp_getsockopt_maxseg(struct sock *sk, int len, 4937 char __user *optval, int __user *optlen) 4938 { 4939 struct sctp_assoc_value params; 4940 struct sctp_association *asoc; 4941 4942 if (len == sizeof(int)) { 4943 printk(KERN_WARNING 4944 "SCTP: Use of int in maxseg socket option deprecated\n"); 4945 printk(KERN_WARNING 4946 "SCTP: Use struct sctp_assoc_value instead\n"); 4947 params.assoc_id = 0; 4948 } else if (len >= sizeof(struct sctp_assoc_value)) { 4949 len = sizeof(struct sctp_assoc_value); 4950 if (copy_from_user(¶ms, optval, sizeof(params))) 4951 return -EFAULT; 4952 } else 4953 return -EINVAL; 4954 4955 asoc = sctp_id2assoc(sk, params.assoc_id); 4956 if (!asoc && params.assoc_id && sctp_style(sk, UDP)) 4957 return -EINVAL; 4958 4959 if (asoc) 4960 params.assoc_value = asoc->frag_point; 4961 else 4962 params.assoc_value = sctp_sk(sk)->user_frag; 4963 4964 if (put_user(len, optlen)) 4965 return -EFAULT; 4966 if (len == sizeof(int)) { 4967 if (copy_to_user(optval, ¶ms.assoc_value, len)) 4968 return -EFAULT; 4969 } else { 4970 if (copy_to_user(optval, ¶ms, len)) 4971 return -EFAULT; 4972 } 4973 4974 return 0; 4975 } 4976 4977 /* 4978 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE) 4979 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave()) 4980 */ 4981 static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len, 4982 char __user *optval, int __user *optlen) 4983 { 4984 int val; 4985 4986 if (len < sizeof(int)) 4987 return -EINVAL; 4988 4989 len = sizeof(int); 4990 4991 val = sctp_sk(sk)->frag_interleave; 4992 if (put_user(len, optlen)) 4993 return -EFAULT; 4994 if (copy_to_user(optval, &val, len)) 4995 return -EFAULT; 4996 4997 return 0; 4998 } 4999 5000 /* 5001 * 7.1.25. Set or Get the sctp partial delivery point 5002 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point()) 5003 */ 5004 static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len, 5005 char __user *optval, 5006 int __user *optlen) 5007 { 5008 u32 val; 5009 5010 if (len < sizeof(u32)) 5011 return -EINVAL; 5012 5013 len = sizeof(u32); 5014 5015 val = sctp_sk(sk)->pd_point; 5016 if (put_user(len, optlen)) 5017 return -EFAULT; 5018 if (copy_to_user(optval, &val, len)) 5019 return -EFAULT; 5020 5021 return -ENOTSUPP; 5022 } 5023 5024 /* 5025 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST) 5026 * (chapter and verse is quoted at sctp_setsockopt_maxburst()) 5027 */ 5028 static int sctp_getsockopt_maxburst(struct sock *sk, int len, 5029 char __user *optval, 5030 int __user *optlen) 5031 { 5032 struct sctp_assoc_value params; 5033 struct sctp_sock *sp; 5034 struct sctp_association *asoc; 5035 5036 if (len == sizeof(int)) { 5037 printk(KERN_WARNING 5038 "SCTP: Use of int in max_burst socket option deprecated\n"); 5039 printk(KERN_WARNING 5040 "SCTP: Use struct sctp_assoc_value instead\n"); 5041 params.assoc_id = 0; 5042 } else if (len >= sizeof(struct sctp_assoc_value)) { 5043 len = sizeof(struct sctp_assoc_value); 5044 if (copy_from_user(¶ms, optval, len)) 5045 return -EFAULT; 5046 } else 5047 return -EINVAL; 5048 5049 sp = sctp_sk(sk); 5050 5051 if (params.assoc_id != 0) { 5052 asoc = sctp_id2assoc(sk, params.assoc_id); 5053 if (!asoc) 5054 return -EINVAL; 5055 params.assoc_value = asoc->max_burst; 5056 } else 5057 params.assoc_value = sp->max_burst; 5058 5059 if (len == sizeof(int)) { 5060 if (copy_to_user(optval, ¶ms.assoc_value, len)) 5061 return -EFAULT; 5062 } else { 5063 if (copy_to_user(optval, ¶ms, len)) 5064 return -EFAULT; 5065 } 5066 5067 return 0; 5068 5069 } 5070 5071 static int sctp_getsockopt_hmac_ident(struct sock *sk, int len, 5072 char __user *optval, int __user *optlen) 5073 { 5074 struct sctp_hmacalgo __user *p = (void __user *)optval; 5075 struct sctp_hmac_algo_param *hmacs; 5076 __u16 data_len = 0; 5077 u32 num_idents; 5078 5079 if (!sctp_auth_enable) 5080 return -EACCES; 5081 5082 hmacs = sctp_sk(sk)->ep->auth_hmacs_list; 5083 data_len = ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t); 5084 5085 if (len < sizeof(struct sctp_hmacalgo) + data_len) 5086 return -EINVAL; 5087 5088 len = sizeof(struct sctp_hmacalgo) + data_len; 5089 num_idents = data_len / sizeof(u16); 5090 5091 if (put_user(len, optlen)) 5092 return -EFAULT; 5093 if (put_user(num_idents, &p->shmac_num_idents)) 5094 return -EFAULT; 5095 if (copy_to_user(p->shmac_idents, hmacs->hmac_ids, data_len)) 5096 return -EFAULT; 5097 return 0; 5098 } 5099 5100 static int sctp_getsockopt_active_key(struct sock *sk, int len, 5101 char __user *optval, int __user *optlen) 5102 { 5103 struct sctp_authkeyid val; 5104 struct sctp_association *asoc; 5105 5106 if (!sctp_auth_enable) 5107 return -EACCES; 5108 5109 if (len < sizeof(struct sctp_authkeyid)) 5110 return -EINVAL; 5111 if (copy_from_user(&val, optval, sizeof(struct sctp_authkeyid))) 5112 return -EFAULT; 5113 5114 asoc = sctp_id2assoc(sk, val.scact_assoc_id); 5115 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP)) 5116 return -EINVAL; 5117 5118 if (asoc) 5119 val.scact_keynumber = asoc->active_key_id; 5120 else 5121 val.scact_keynumber = sctp_sk(sk)->ep->active_key_id; 5122 5123 len = sizeof(struct sctp_authkeyid); 5124 if (put_user(len, optlen)) 5125 return -EFAULT; 5126 if (copy_to_user(optval, &val, len)) 5127 return -EFAULT; 5128 5129 return 0; 5130 } 5131 5132 static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len, 5133 char __user *optval, int __user *optlen) 5134 { 5135 struct sctp_authchunks __user *p = (void __user *)optval; 5136 struct sctp_authchunks val; 5137 struct sctp_association *asoc; 5138 struct sctp_chunks_param *ch; 5139 u32 num_chunks = 0; 5140 char __user *to; 5141 5142 if (!sctp_auth_enable) 5143 return -EACCES; 5144 5145 if (len < sizeof(struct sctp_authchunks)) 5146 return -EINVAL; 5147 5148 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks))) 5149 return -EFAULT; 5150 5151 to = p->gauth_chunks; 5152 asoc = sctp_id2assoc(sk, val.gauth_assoc_id); 5153 if (!asoc) 5154 return -EINVAL; 5155 5156 ch = asoc->peer.peer_chunks; 5157 if (!ch) 5158 goto num; 5159 5160 /* See if the user provided enough room for all the data */ 5161 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t); 5162 if (len < num_chunks) 5163 return -EINVAL; 5164 5165 if (copy_to_user(to, ch->chunks, num_chunks)) 5166 return -EFAULT; 5167 num: 5168 len = sizeof(struct sctp_authchunks) + num_chunks; 5169 if (put_user(len, optlen)) return -EFAULT; 5170 if (put_user(num_chunks, &p->gauth_number_of_chunks)) 5171 return -EFAULT; 5172 return 0; 5173 } 5174 5175 static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len, 5176 char __user *optval, int __user *optlen) 5177 { 5178 struct sctp_authchunks __user *p = (void __user *)optval; 5179 struct sctp_authchunks val; 5180 struct sctp_association *asoc; 5181 struct sctp_chunks_param *ch; 5182 u32 num_chunks = 0; 5183 char __user *to; 5184 5185 if (!sctp_auth_enable) 5186 return -EACCES; 5187 5188 if (len < sizeof(struct sctp_authchunks)) 5189 return -EINVAL; 5190 5191 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks))) 5192 return -EFAULT; 5193 5194 to = p->gauth_chunks; 5195 asoc = sctp_id2assoc(sk, val.gauth_assoc_id); 5196 if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP)) 5197 return -EINVAL; 5198 5199 if (asoc) 5200 ch = (struct sctp_chunks_param*)asoc->c.auth_chunks; 5201 else 5202 ch = sctp_sk(sk)->ep->auth_chunk_list; 5203 5204 if (!ch) 5205 goto num; 5206 5207 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t); 5208 if (len < sizeof(struct sctp_authchunks) + num_chunks) 5209 return -EINVAL; 5210 5211 if (copy_to_user(to, ch->chunks, num_chunks)) 5212 return -EFAULT; 5213 num: 5214 len = sizeof(struct sctp_authchunks) + num_chunks; 5215 if (put_user(len, optlen)) 5216 return -EFAULT; 5217 if (put_user(num_chunks, &p->gauth_number_of_chunks)) 5218 return -EFAULT; 5219 5220 return 0; 5221 } 5222 5223 /* 5224 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER) 5225 * This option gets the current number of associations that are attached 5226 * to a one-to-many style socket. The option value is an uint32_t. 5227 */ 5228 static int sctp_getsockopt_assoc_number(struct sock *sk, int len, 5229 char __user *optval, int __user *optlen) 5230 { 5231 struct sctp_sock *sp = sctp_sk(sk); 5232 struct sctp_association *asoc; 5233 u32 val = 0; 5234 5235 if (sctp_style(sk, TCP)) 5236 return -EOPNOTSUPP; 5237 5238 if (len < sizeof(u32)) 5239 return -EINVAL; 5240 5241 len = sizeof(u32); 5242 5243 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) { 5244 val++; 5245 } 5246 5247 if (put_user(len, optlen)) 5248 return -EFAULT; 5249 if (copy_to_user(optval, &val, len)) 5250 return -EFAULT; 5251 5252 return 0; 5253 } 5254 5255 SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname, 5256 char __user *optval, int __user *optlen) 5257 { 5258 int retval = 0; 5259 int len; 5260 5261 SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n", 5262 sk, optname); 5263 5264 /* I can hardly begin to describe how wrong this is. This is 5265 * so broken as to be worse than useless. The API draft 5266 * REALLY is NOT helpful here... I am not convinced that the 5267 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP 5268 * are at all well-founded. 5269 */ 5270 if (level != SOL_SCTP) { 5271 struct sctp_af *af = sctp_sk(sk)->pf->af; 5272 5273 retval = af->getsockopt(sk, level, optname, optval, optlen); 5274 return retval; 5275 } 5276 5277 if (get_user(len, optlen)) 5278 return -EFAULT; 5279 5280 sctp_lock_sock(sk); 5281 5282 switch (optname) { 5283 case SCTP_STATUS: 5284 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen); 5285 break; 5286 case SCTP_DISABLE_FRAGMENTS: 5287 retval = sctp_getsockopt_disable_fragments(sk, len, optval, 5288 optlen); 5289 break; 5290 case SCTP_EVENTS: 5291 retval = sctp_getsockopt_events(sk, len, optval, optlen); 5292 break; 5293 case SCTP_AUTOCLOSE: 5294 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen); 5295 break; 5296 case SCTP_SOCKOPT_PEELOFF: 5297 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen); 5298 break; 5299 case SCTP_PEER_ADDR_PARAMS: 5300 retval = sctp_getsockopt_peer_addr_params(sk, len, optval, 5301 optlen); 5302 break; 5303 case SCTP_DELAYED_ACK: 5304 retval = sctp_getsockopt_delayed_ack(sk, len, optval, 5305 optlen); 5306 break; 5307 case SCTP_INITMSG: 5308 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen); 5309 break; 5310 case SCTP_GET_PEER_ADDRS: 5311 retval = sctp_getsockopt_peer_addrs(sk, len, optval, 5312 optlen); 5313 break; 5314 case SCTP_GET_LOCAL_ADDRS: 5315 retval = sctp_getsockopt_local_addrs(sk, len, optval, 5316 optlen); 5317 break; 5318 case SCTP_SOCKOPT_CONNECTX3: 5319 retval = sctp_getsockopt_connectx3(sk, len, optval, optlen); 5320 break; 5321 case SCTP_DEFAULT_SEND_PARAM: 5322 retval = sctp_getsockopt_default_send_param(sk, len, 5323 optval, optlen); 5324 break; 5325 case SCTP_PRIMARY_ADDR: 5326 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen); 5327 break; 5328 case SCTP_NODELAY: 5329 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen); 5330 break; 5331 case SCTP_RTOINFO: 5332 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen); 5333 break; 5334 case SCTP_ASSOCINFO: 5335 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen); 5336 break; 5337 case SCTP_I_WANT_MAPPED_V4_ADDR: 5338 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen); 5339 break; 5340 case SCTP_MAXSEG: 5341 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen); 5342 break; 5343 case SCTP_GET_PEER_ADDR_INFO: 5344 retval = sctp_getsockopt_peer_addr_info(sk, len, optval, 5345 optlen); 5346 break; 5347 case SCTP_ADAPTATION_LAYER: 5348 retval = sctp_getsockopt_adaptation_layer(sk, len, optval, 5349 optlen); 5350 break; 5351 case SCTP_CONTEXT: 5352 retval = sctp_getsockopt_context(sk, len, optval, optlen); 5353 break; 5354 case SCTP_FRAGMENT_INTERLEAVE: 5355 retval = sctp_getsockopt_fragment_interleave(sk, len, optval, 5356 optlen); 5357 break; 5358 case SCTP_PARTIAL_DELIVERY_POINT: 5359 retval = sctp_getsockopt_partial_delivery_point(sk, len, optval, 5360 optlen); 5361 break; 5362 case SCTP_MAX_BURST: 5363 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen); 5364 break; 5365 case SCTP_AUTH_KEY: 5366 case SCTP_AUTH_CHUNK: 5367 case SCTP_AUTH_DELETE_KEY: 5368 retval = -EOPNOTSUPP; 5369 break; 5370 case SCTP_HMAC_IDENT: 5371 retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen); 5372 break; 5373 case SCTP_AUTH_ACTIVE_KEY: 5374 retval = sctp_getsockopt_active_key(sk, len, optval, optlen); 5375 break; 5376 case SCTP_PEER_AUTH_CHUNKS: 5377 retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval, 5378 optlen); 5379 break; 5380 case SCTP_LOCAL_AUTH_CHUNKS: 5381 retval = sctp_getsockopt_local_auth_chunks(sk, len, optval, 5382 optlen); 5383 break; 5384 case SCTP_GET_ASSOC_NUMBER: 5385 retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen); 5386 break; 5387 default: 5388 retval = -ENOPROTOOPT; 5389 break; 5390 } 5391 5392 sctp_release_sock(sk); 5393 return retval; 5394 } 5395 5396 static void sctp_hash(struct sock *sk) 5397 { 5398 /* STUB */ 5399 } 5400 5401 static void sctp_unhash(struct sock *sk) 5402 { 5403 /* STUB */ 5404 } 5405 5406 /* Check if port is acceptable. Possibly find first available port. 5407 * 5408 * The port hash table (contained in the 'global' SCTP protocol storage 5409 * returned by struct sctp_protocol *sctp_get_protocol()). The hash 5410 * table is an array of 4096 lists (sctp_bind_hashbucket). Each 5411 * list (the list number is the port number hashed out, so as you 5412 * would expect from a hash function, all the ports in a given list have 5413 * such a number that hashes out to the same list number; you were 5414 * expecting that, right?); so each list has a set of ports, with a 5415 * link to the socket (struct sock) that uses it, the port number and 5416 * a fastreuse flag (FIXME: NPI ipg). 5417 */ 5418 static struct sctp_bind_bucket *sctp_bucket_create( 5419 struct sctp_bind_hashbucket *head, unsigned short snum); 5420 5421 static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr) 5422 { 5423 struct sctp_bind_hashbucket *head; /* hash list */ 5424 struct sctp_bind_bucket *pp; /* hash list port iterator */ 5425 struct hlist_node *node; 5426 unsigned short snum; 5427 int ret; 5428 5429 snum = ntohs(addr->v4.sin_port); 5430 5431 SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum); 5432 sctp_local_bh_disable(); 5433 5434 if (snum == 0) { 5435 /* Search for an available port. */ 5436 int low, high, remaining, index; 5437 unsigned int rover; 5438 5439 inet_get_local_port_range(&low, &high); 5440 remaining = (high - low) + 1; 5441 rover = net_random() % remaining + low; 5442 5443 do { 5444 rover++; 5445 if ((rover < low) || (rover > high)) 5446 rover = low; 5447 if (inet_is_reserved_local_port(rover)) 5448 continue; 5449 index = sctp_phashfn(rover); 5450 head = &sctp_port_hashtable[index]; 5451 sctp_spin_lock(&head->lock); 5452 sctp_for_each_hentry(pp, node, &head->chain) 5453 if (pp->port == rover) 5454 goto next; 5455 break; 5456 next: 5457 sctp_spin_unlock(&head->lock); 5458 } while (--remaining > 0); 5459 5460 /* Exhausted local port range during search? */ 5461 ret = 1; 5462 if (remaining <= 0) 5463 goto fail; 5464 5465 /* OK, here is the one we will use. HEAD (the port 5466 * hash table list entry) is non-NULL and we hold it's 5467 * mutex. 5468 */ 5469 snum = rover; 5470 } else { 5471 /* We are given an specific port number; we verify 5472 * that it is not being used. If it is used, we will 5473 * exahust the search in the hash list corresponding 5474 * to the port number (snum) - we detect that with the 5475 * port iterator, pp being NULL. 5476 */ 5477 head = &sctp_port_hashtable[sctp_phashfn(snum)]; 5478 sctp_spin_lock(&head->lock); 5479 sctp_for_each_hentry(pp, node, &head->chain) { 5480 if (pp->port == snum) 5481 goto pp_found; 5482 } 5483 } 5484 pp = NULL; 5485 goto pp_not_found; 5486 pp_found: 5487 if (!hlist_empty(&pp->owner)) { 5488 /* We had a port hash table hit - there is an 5489 * available port (pp != NULL) and it is being 5490 * used by other socket (pp->owner not empty); that other 5491 * socket is going to be sk2. 5492 */ 5493 int reuse = sk->sk_reuse; 5494 struct sock *sk2; 5495 5496 SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n"); 5497 if (pp->fastreuse && sk->sk_reuse && 5498 sk->sk_state != SCTP_SS_LISTENING) 5499 goto success; 5500 5501 /* Run through the list of sockets bound to the port 5502 * (pp->port) [via the pointers bind_next and 5503 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one, 5504 * we get the endpoint they describe and run through 5505 * the endpoint's list of IP (v4 or v6) addresses, 5506 * comparing each of the addresses with the address of 5507 * the socket sk. If we find a match, then that means 5508 * that this port/socket (sk) combination are already 5509 * in an endpoint. 5510 */ 5511 sk_for_each_bound(sk2, node, &pp->owner) { 5512 struct sctp_endpoint *ep2; 5513 ep2 = sctp_sk(sk2)->ep; 5514 5515 if (sk == sk2 || 5516 (reuse && sk2->sk_reuse && 5517 sk2->sk_state != SCTP_SS_LISTENING)) 5518 continue; 5519 5520 if (sctp_bind_addr_conflict(&ep2->base.bind_addr, addr, 5521 sctp_sk(sk2), sctp_sk(sk))) { 5522 ret = (long)sk2; 5523 goto fail_unlock; 5524 } 5525 } 5526 SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n"); 5527 } 5528 pp_not_found: 5529 /* If there was a hash table miss, create a new port. */ 5530 ret = 1; 5531 if (!pp && !(pp = sctp_bucket_create(head, snum))) 5532 goto fail_unlock; 5533 5534 /* In either case (hit or miss), make sure fastreuse is 1 only 5535 * if sk->sk_reuse is too (that is, if the caller requested 5536 * SO_REUSEADDR on this socket -sk-). 5537 */ 5538 if (hlist_empty(&pp->owner)) { 5539 if (sk->sk_reuse && sk->sk_state != SCTP_SS_LISTENING) 5540 pp->fastreuse = 1; 5541 else 5542 pp->fastreuse = 0; 5543 } else if (pp->fastreuse && 5544 (!sk->sk_reuse || sk->sk_state == SCTP_SS_LISTENING)) 5545 pp->fastreuse = 0; 5546 5547 /* We are set, so fill up all the data in the hash table 5548 * entry, tie the socket list information with the rest of the 5549 * sockets FIXME: Blurry, NPI (ipg). 5550 */ 5551 success: 5552 if (!sctp_sk(sk)->bind_hash) { 5553 inet_sk(sk)->inet_num = snum; 5554 sk_add_bind_node(sk, &pp->owner); 5555 sctp_sk(sk)->bind_hash = pp; 5556 } 5557 ret = 0; 5558 5559 fail_unlock: 5560 sctp_spin_unlock(&head->lock); 5561 5562 fail: 5563 sctp_local_bh_enable(); 5564 return ret; 5565 } 5566 5567 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral 5568 * port is requested. 5569 */ 5570 static int sctp_get_port(struct sock *sk, unsigned short snum) 5571 { 5572 long ret; 5573 union sctp_addr addr; 5574 struct sctp_af *af = sctp_sk(sk)->pf->af; 5575 5576 /* Set up a dummy address struct from the sk. */ 5577 af->from_sk(&addr, sk); 5578 addr.v4.sin_port = htons(snum); 5579 5580 /* Note: sk->sk_num gets filled in if ephemeral port request. */ 5581 ret = sctp_get_port_local(sk, &addr); 5582 5583 return (ret ? 1 : 0); 5584 } 5585 5586 /* 5587 * Move a socket to LISTENING state. 5588 */ 5589 SCTP_STATIC int sctp_listen_start(struct sock *sk, int backlog) 5590 { 5591 struct sctp_sock *sp = sctp_sk(sk); 5592 struct sctp_endpoint *ep = sp->ep; 5593 struct crypto_hash *tfm = NULL; 5594 5595 /* Allocate HMAC for generating cookie. */ 5596 if (!sctp_sk(sk)->hmac && sctp_hmac_alg) { 5597 tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC); 5598 if (IS_ERR(tfm)) { 5599 if (net_ratelimit()) { 5600 printk(KERN_INFO 5601 "SCTP: failed to load transform for %s: %ld\n", 5602 sctp_hmac_alg, PTR_ERR(tfm)); 5603 } 5604 return -ENOSYS; 5605 } 5606 sctp_sk(sk)->hmac = tfm; 5607 } 5608 5609 /* 5610 * If a bind() or sctp_bindx() is not called prior to a listen() 5611 * call that allows new associations to be accepted, the system 5612 * picks an ephemeral port and will choose an address set equivalent 5613 * to binding with a wildcard address. 5614 * 5615 * This is not currently spelled out in the SCTP sockets 5616 * extensions draft, but follows the practice as seen in TCP 5617 * sockets. 5618 * 5619 */ 5620 sk->sk_state = SCTP_SS_LISTENING; 5621 if (!ep->base.bind_addr.port) { 5622 if (sctp_autobind(sk)) 5623 return -EAGAIN; 5624 } else { 5625 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) { 5626 sk->sk_state = SCTP_SS_CLOSED; 5627 return -EADDRINUSE; 5628 } 5629 } 5630 5631 sk->sk_max_ack_backlog = backlog; 5632 sctp_hash_endpoint(ep); 5633 return 0; 5634 } 5635 5636 /* 5637 * 4.1.3 / 5.1.3 listen() 5638 * 5639 * By default, new associations are not accepted for UDP style sockets. 5640 * An application uses listen() to mark a socket as being able to 5641 * accept new associations. 5642 * 5643 * On TCP style sockets, applications use listen() to ready the SCTP 5644 * endpoint for accepting inbound associations. 5645 * 5646 * On both types of endpoints a backlog of '0' disables listening. 5647 * 5648 * Move a socket to LISTENING state. 5649 */ 5650 int sctp_inet_listen(struct socket *sock, int backlog) 5651 { 5652 struct sock *sk = sock->sk; 5653 struct sctp_endpoint *ep = sctp_sk(sk)->ep; 5654 int err = -EINVAL; 5655 5656 if (unlikely(backlog < 0)) 5657 return err; 5658 5659 sctp_lock_sock(sk); 5660 5661 /* Peeled-off sockets are not allowed to listen(). */ 5662 if (sctp_style(sk, UDP_HIGH_BANDWIDTH)) 5663 goto out; 5664 5665 if (sock->state != SS_UNCONNECTED) 5666 goto out; 5667 5668 /* If backlog is zero, disable listening. */ 5669 if (!backlog) { 5670 if (sctp_sstate(sk, CLOSED)) 5671 goto out; 5672 5673 err = 0; 5674 sctp_unhash_endpoint(ep); 5675 sk->sk_state = SCTP_SS_CLOSED; 5676 if (sk->sk_reuse) 5677 sctp_sk(sk)->bind_hash->fastreuse = 1; 5678 goto out; 5679 } 5680 5681 /* If we are already listening, just update the backlog */ 5682 if (sctp_sstate(sk, LISTENING)) 5683 sk->sk_max_ack_backlog = backlog; 5684 else { 5685 err = sctp_listen_start(sk, backlog); 5686 if (err) 5687 goto out; 5688 } 5689 5690 err = 0; 5691 out: 5692 sctp_release_sock(sk); 5693 return err; 5694 } 5695 5696 /* 5697 * This function is done by modeling the current datagram_poll() and the 5698 * tcp_poll(). Note that, based on these implementations, we don't 5699 * lock the socket in this function, even though it seems that, 5700 * ideally, locking or some other mechanisms can be used to ensure 5701 * the integrity of the counters (sndbuf and wmem_alloc) used 5702 * in this place. We assume that we don't need locks either until proven 5703 * otherwise. 5704 * 5705 * Another thing to note is that we include the Async I/O support 5706 * here, again, by modeling the current TCP/UDP code. We don't have 5707 * a good way to test with it yet. 5708 */ 5709 unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait) 5710 { 5711 struct sock *sk = sock->sk; 5712 struct sctp_sock *sp = sctp_sk(sk); 5713 unsigned int mask; 5714 5715 poll_wait(file, sk_sleep(sk), wait); 5716 5717 /* A TCP-style listening socket becomes readable when the accept queue 5718 * is not empty. 5719 */ 5720 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 5721 return (!list_empty(&sp->ep->asocs)) ? 5722 (POLLIN | POLLRDNORM) : 0; 5723 5724 mask = 0; 5725 5726 /* Is there any exceptional events? */ 5727 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 5728 mask |= POLLERR; 5729 if (sk->sk_shutdown & RCV_SHUTDOWN) 5730 mask |= POLLRDHUP; 5731 if (sk->sk_shutdown == SHUTDOWN_MASK) 5732 mask |= POLLHUP; 5733 5734 /* Is it readable? Reconsider this code with TCP-style support. */ 5735 if (!skb_queue_empty(&sk->sk_receive_queue) || 5736 (sk->sk_shutdown & RCV_SHUTDOWN)) 5737 mask |= POLLIN | POLLRDNORM; 5738 5739 /* The association is either gone or not ready. */ 5740 if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED)) 5741 return mask; 5742 5743 /* Is it writable? */ 5744 if (sctp_writeable(sk)) { 5745 mask |= POLLOUT | POLLWRNORM; 5746 } else { 5747 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 5748 /* 5749 * Since the socket is not locked, the buffer 5750 * might be made available after the writeable check and 5751 * before the bit is set. This could cause a lost I/O 5752 * signal. tcp_poll() has a race breaker for this race 5753 * condition. Based on their implementation, we put 5754 * in the following code to cover it as well. 5755 */ 5756 if (sctp_writeable(sk)) 5757 mask |= POLLOUT | POLLWRNORM; 5758 } 5759 return mask; 5760 } 5761 5762 /******************************************************************** 5763 * 2nd Level Abstractions 5764 ********************************************************************/ 5765 5766 static struct sctp_bind_bucket *sctp_bucket_create( 5767 struct sctp_bind_hashbucket *head, unsigned short snum) 5768 { 5769 struct sctp_bind_bucket *pp; 5770 5771 pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC); 5772 if (pp) { 5773 SCTP_DBG_OBJCNT_INC(bind_bucket); 5774 pp->port = snum; 5775 pp->fastreuse = 0; 5776 INIT_HLIST_HEAD(&pp->owner); 5777 hlist_add_head(&pp->node, &head->chain); 5778 } 5779 return pp; 5780 } 5781 5782 /* Caller must hold hashbucket lock for this tb with local BH disabled */ 5783 static void sctp_bucket_destroy(struct sctp_bind_bucket *pp) 5784 { 5785 if (pp && hlist_empty(&pp->owner)) { 5786 __hlist_del(&pp->node); 5787 kmem_cache_free(sctp_bucket_cachep, pp); 5788 SCTP_DBG_OBJCNT_DEC(bind_bucket); 5789 } 5790 } 5791 5792 /* Release this socket's reference to a local port. */ 5793 static inline void __sctp_put_port(struct sock *sk) 5794 { 5795 struct sctp_bind_hashbucket *head = 5796 &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->inet_num)]; 5797 struct sctp_bind_bucket *pp; 5798 5799 sctp_spin_lock(&head->lock); 5800 pp = sctp_sk(sk)->bind_hash; 5801 __sk_del_bind_node(sk); 5802 sctp_sk(sk)->bind_hash = NULL; 5803 inet_sk(sk)->inet_num = 0; 5804 sctp_bucket_destroy(pp); 5805 sctp_spin_unlock(&head->lock); 5806 } 5807 5808 void sctp_put_port(struct sock *sk) 5809 { 5810 sctp_local_bh_disable(); 5811 __sctp_put_port(sk); 5812 sctp_local_bh_enable(); 5813 } 5814 5815 /* 5816 * The system picks an ephemeral port and choose an address set equivalent 5817 * to binding with a wildcard address. 5818 * One of those addresses will be the primary address for the association. 5819 * This automatically enables the multihoming capability of SCTP. 5820 */ 5821 static int sctp_autobind(struct sock *sk) 5822 { 5823 union sctp_addr autoaddr; 5824 struct sctp_af *af; 5825 __be16 port; 5826 5827 /* Initialize a local sockaddr structure to INADDR_ANY. */ 5828 af = sctp_sk(sk)->pf->af; 5829 5830 port = htons(inet_sk(sk)->inet_num); 5831 af->inaddr_any(&autoaddr, port); 5832 5833 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len); 5834 } 5835 5836 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation. 5837 * 5838 * From RFC 2292 5839 * 4.2 The cmsghdr Structure * 5840 * 5841 * When ancillary data is sent or received, any number of ancillary data 5842 * objects can be specified by the msg_control and msg_controllen members of 5843 * the msghdr structure, because each object is preceded by 5844 * a cmsghdr structure defining the object's length (the cmsg_len member). 5845 * Historically Berkeley-derived implementations have passed only one object 5846 * at a time, but this API allows multiple objects to be 5847 * passed in a single call to sendmsg() or recvmsg(). The following example 5848 * shows two ancillary data objects in a control buffer. 5849 * 5850 * |<--------------------------- msg_controllen -------------------------->| 5851 * | | 5852 * 5853 * |<----- ancillary data object ----->|<----- ancillary data object ----->| 5854 * 5855 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->| 5856 * | | | 5857 * 5858 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| | 5859 * 5860 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| | 5861 * | | | | | 5862 * 5863 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+ 5864 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX| 5865 * 5866 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX| 5867 * 5868 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+ 5869 * ^ 5870 * | 5871 * 5872 * msg_control 5873 * points here 5874 */ 5875 SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg, 5876 sctp_cmsgs_t *cmsgs) 5877 { 5878 struct cmsghdr *cmsg; 5879 struct msghdr *my_msg = (struct msghdr *)msg; 5880 5881 for (cmsg = CMSG_FIRSTHDR(msg); 5882 cmsg != NULL; 5883 cmsg = CMSG_NXTHDR(my_msg, cmsg)) { 5884 if (!CMSG_OK(my_msg, cmsg)) 5885 return -EINVAL; 5886 5887 /* Should we parse this header or ignore? */ 5888 if (cmsg->cmsg_level != IPPROTO_SCTP) 5889 continue; 5890 5891 /* Strictly check lengths following example in SCM code. */ 5892 switch (cmsg->cmsg_type) { 5893 case SCTP_INIT: 5894 /* SCTP Socket API Extension 5895 * 5.2.1 SCTP Initiation Structure (SCTP_INIT) 5896 * 5897 * This cmsghdr structure provides information for 5898 * initializing new SCTP associations with sendmsg(). 5899 * The SCTP_INITMSG socket option uses this same data 5900 * structure. This structure is not used for 5901 * recvmsg(). 5902 * 5903 * cmsg_level cmsg_type cmsg_data[] 5904 * ------------ ------------ ---------------------- 5905 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg 5906 */ 5907 if (cmsg->cmsg_len != 5908 CMSG_LEN(sizeof(struct sctp_initmsg))) 5909 return -EINVAL; 5910 cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg); 5911 break; 5912 5913 case SCTP_SNDRCV: 5914 /* SCTP Socket API Extension 5915 * 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV) 5916 * 5917 * This cmsghdr structure specifies SCTP options for 5918 * sendmsg() and describes SCTP header information 5919 * about a received message through recvmsg(). 5920 * 5921 * cmsg_level cmsg_type cmsg_data[] 5922 * ------------ ------------ ---------------------- 5923 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo 5924 */ 5925 if (cmsg->cmsg_len != 5926 CMSG_LEN(sizeof(struct sctp_sndrcvinfo))) 5927 return -EINVAL; 5928 5929 cmsgs->info = 5930 (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); 5931 5932 /* Minimally, validate the sinfo_flags. */ 5933 if (cmsgs->info->sinfo_flags & 5934 ~(SCTP_UNORDERED | SCTP_ADDR_OVER | 5935 SCTP_ABORT | SCTP_EOF)) 5936 return -EINVAL; 5937 break; 5938 5939 default: 5940 return -EINVAL; 5941 } 5942 } 5943 return 0; 5944 } 5945 5946 /* 5947 * Wait for a packet.. 5948 * Note: This function is the same function as in core/datagram.c 5949 * with a few modifications to make lksctp work. 5950 */ 5951 static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p) 5952 { 5953 int error; 5954 DEFINE_WAIT(wait); 5955 5956 prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 5957 5958 /* Socket errors? */ 5959 error = sock_error(sk); 5960 if (error) 5961 goto out; 5962 5963 if (!skb_queue_empty(&sk->sk_receive_queue)) 5964 goto ready; 5965 5966 /* Socket shut down? */ 5967 if (sk->sk_shutdown & RCV_SHUTDOWN) 5968 goto out; 5969 5970 /* Sequenced packets can come disconnected. If so we report the 5971 * problem. 5972 */ 5973 error = -ENOTCONN; 5974 5975 /* Is there a good reason to think that we may receive some data? */ 5976 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING)) 5977 goto out; 5978 5979 /* Handle signals. */ 5980 if (signal_pending(current)) 5981 goto interrupted; 5982 5983 /* Let another process have a go. Since we are going to sleep 5984 * anyway. Note: This may cause odd behaviors if the message 5985 * does not fit in the user's buffer, but this seems to be the 5986 * only way to honor MSG_DONTWAIT realistically. 5987 */ 5988 sctp_release_sock(sk); 5989 *timeo_p = schedule_timeout(*timeo_p); 5990 sctp_lock_sock(sk); 5991 5992 ready: 5993 finish_wait(sk_sleep(sk), &wait); 5994 return 0; 5995 5996 interrupted: 5997 error = sock_intr_errno(*timeo_p); 5998 5999 out: 6000 finish_wait(sk_sleep(sk), &wait); 6001 *err = error; 6002 return error; 6003 } 6004 6005 /* Receive a datagram. 6006 * Note: This is pretty much the same routine as in core/datagram.c 6007 * with a few changes to make lksctp work. 6008 */ 6009 static struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, 6010 int noblock, int *err) 6011 { 6012 int error; 6013 struct sk_buff *skb; 6014 long timeo; 6015 6016 timeo = sock_rcvtimeo(sk, noblock); 6017 6018 SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n", 6019 timeo, MAX_SCHEDULE_TIMEOUT); 6020 6021 do { 6022 /* Again only user level code calls this function, 6023 * so nothing interrupt level 6024 * will suddenly eat the receive_queue. 6025 * 6026 * Look at current nfs client by the way... 6027 * However, this function was corrent in any case. 8) 6028 */ 6029 if (flags & MSG_PEEK) { 6030 spin_lock_bh(&sk->sk_receive_queue.lock); 6031 skb = skb_peek(&sk->sk_receive_queue); 6032 if (skb) 6033 atomic_inc(&skb->users); 6034 spin_unlock_bh(&sk->sk_receive_queue.lock); 6035 } else { 6036 skb = skb_dequeue(&sk->sk_receive_queue); 6037 } 6038 6039 if (skb) 6040 return skb; 6041 6042 /* Caller is allowed not to check sk->sk_err before calling. */ 6043 error = sock_error(sk); 6044 if (error) 6045 goto no_packet; 6046 6047 if (sk->sk_shutdown & RCV_SHUTDOWN) 6048 break; 6049 6050 /* User doesn't want to wait. */ 6051 error = -EAGAIN; 6052 if (!timeo) 6053 goto no_packet; 6054 } while (sctp_wait_for_packet(sk, err, &timeo) == 0); 6055 6056 return NULL; 6057 6058 no_packet: 6059 *err = error; 6060 return NULL; 6061 } 6062 6063 /* If sndbuf has changed, wake up per association sndbuf waiters. */ 6064 static void __sctp_write_space(struct sctp_association *asoc) 6065 { 6066 struct sock *sk = asoc->base.sk; 6067 struct socket *sock = sk->sk_socket; 6068 6069 if ((sctp_wspace(asoc) > 0) && sock) { 6070 if (waitqueue_active(&asoc->wait)) 6071 wake_up_interruptible(&asoc->wait); 6072 6073 if (sctp_writeable(sk)) { 6074 if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk))) 6075 wake_up_interruptible(sk_sleep(sk)); 6076 6077 /* Note that we try to include the Async I/O support 6078 * here by modeling from the current TCP/UDP code. 6079 * We have not tested with it yet. 6080 */ 6081 if (sock->wq->fasync_list && 6082 !(sk->sk_shutdown & SEND_SHUTDOWN)) 6083 sock_wake_async(sock, 6084 SOCK_WAKE_SPACE, POLL_OUT); 6085 } 6086 } 6087 } 6088 6089 /* Do accounting for the sndbuf space. 6090 * Decrement the used sndbuf space of the corresponding association by the 6091 * data size which was just transmitted(freed). 6092 */ 6093 static void sctp_wfree(struct sk_buff *skb) 6094 { 6095 struct sctp_association *asoc; 6096 struct sctp_chunk *chunk; 6097 struct sock *sk; 6098 6099 /* Get the saved chunk pointer. */ 6100 chunk = *((struct sctp_chunk **)(skb->cb)); 6101 asoc = chunk->asoc; 6102 sk = asoc->base.sk; 6103 asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) + 6104 sizeof(struct sk_buff) + 6105 sizeof(struct sctp_chunk); 6106 6107 atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc); 6108 6109 /* 6110 * This undoes what is done via sctp_set_owner_w and sk_mem_charge 6111 */ 6112 sk->sk_wmem_queued -= skb->truesize; 6113 sk_mem_uncharge(sk, skb->truesize); 6114 6115 sock_wfree(skb); 6116 __sctp_write_space(asoc); 6117 6118 sctp_association_put(asoc); 6119 } 6120 6121 /* Do accounting for the receive space on the socket. 6122 * Accounting for the association is done in ulpevent.c 6123 * We set this as a destructor for the cloned data skbs so that 6124 * accounting is done at the correct time. 6125 */ 6126 void sctp_sock_rfree(struct sk_buff *skb) 6127 { 6128 struct sock *sk = skb->sk; 6129 struct sctp_ulpevent *event = sctp_skb2event(skb); 6130 6131 atomic_sub(event->rmem_len, &sk->sk_rmem_alloc); 6132 6133 /* 6134 * Mimic the behavior of sock_rfree 6135 */ 6136 sk_mem_uncharge(sk, event->rmem_len); 6137 } 6138 6139 6140 /* Helper function to wait for space in the sndbuf. */ 6141 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p, 6142 size_t msg_len) 6143 { 6144 struct sock *sk = asoc->base.sk; 6145 int err = 0; 6146 long current_timeo = *timeo_p; 6147 DEFINE_WAIT(wait); 6148 6149 SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n", 6150 asoc, (long)(*timeo_p), msg_len); 6151 6152 /* Increment the association's refcnt. */ 6153 sctp_association_hold(asoc); 6154 6155 /* Wait on the association specific sndbuf space. */ 6156 for (;;) { 6157 prepare_to_wait_exclusive(&asoc->wait, &wait, 6158 TASK_INTERRUPTIBLE); 6159 if (!*timeo_p) 6160 goto do_nonblock; 6161 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING || 6162 asoc->base.dead) 6163 goto do_error; 6164 if (signal_pending(current)) 6165 goto do_interrupted; 6166 if (msg_len <= sctp_wspace(asoc)) 6167 break; 6168 6169 /* Let another process have a go. Since we are going 6170 * to sleep anyway. 6171 */ 6172 sctp_release_sock(sk); 6173 current_timeo = schedule_timeout(current_timeo); 6174 BUG_ON(sk != asoc->base.sk); 6175 sctp_lock_sock(sk); 6176 6177 *timeo_p = current_timeo; 6178 } 6179 6180 out: 6181 finish_wait(&asoc->wait, &wait); 6182 6183 /* Release the association's refcnt. */ 6184 sctp_association_put(asoc); 6185 6186 return err; 6187 6188 do_error: 6189 err = -EPIPE; 6190 goto out; 6191 6192 do_interrupted: 6193 err = sock_intr_errno(*timeo_p); 6194 goto out; 6195 6196 do_nonblock: 6197 err = -EAGAIN; 6198 goto out; 6199 } 6200 6201 void sctp_data_ready(struct sock *sk, int len) 6202 { 6203 struct socket_wq *wq; 6204 6205 rcu_read_lock(); 6206 wq = rcu_dereference(sk->sk_wq); 6207 if (wq_has_sleeper(wq)) 6208 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | 6209 POLLRDNORM | POLLRDBAND); 6210 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN); 6211 rcu_read_unlock(); 6212 } 6213 6214 /* If socket sndbuf has changed, wake up all per association waiters. */ 6215 void sctp_write_space(struct sock *sk) 6216 { 6217 struct sctp_association *asoc; 6218 6219 /* Wake up the tasks in each wait queue. */ 6220 list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) { 6221 __sctp_write_space(asoc); 6222 } 6223 } 6224 6225 /* Is there any sndbuf space available on the socket? 6226 * 6227 * Note that sk_wmem_alloc is the sum of the send buffers on all of the 6228 * associations on the same socket. For a UDP-style socket with 6229 * multiple associations, it is possible for it to be "unwriteable" 6230 * prematurely. I assume that this is acceptable because 6231 * a premature "unwriteable" is better than an accidental "writeable" which 6232 * would cause an unwanted block under certain circumstances. For the 1-1 6233 * UDP-style sockets or TCP-style sockets, this code should work. 6234 * - Daisy 6235 */ 6236 static int sctp_writeable(struct sock *sk) 6237 { 6238 int amt = 0; 6239 6240 amt = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 6241 if (amt < 0) 6242 amt = 0; 6243 return amt; 6244 } 6245 6246 /* Wait for an association to go into ESTABLISHED state. If timeout is 0, 6247 * returns immediately with EINPROGRESS. 6248 */ 6249 static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p) 6250 { 6251 struct sock *sk = asoc->base.sk; 6252 int err = 0; 6253 long current_timeo = *timeo_p; 6254 DEFINE_WAIT(wait); 6255 6256 SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __func__, asoc, 6257 (long)(*timeo_p)); 6258 6259 /* Increment the association's refcnt. */ 6260 sctp_association_hold(asoc); 6261 6262 for (;;) { 6263 prepare_to_wait_exclusive(&asoc->wait, &wait, 6264 TASK_INTERRUPTIBLE); 6265 if (!*timeo_p) 6266 goto do_nonblock; 6267 if (sk->sk_shutdown & RCV_SHUTDOWN) 6268 break; 6269 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING || 6270 asoc->base.dead) 6271 goto do_error; 6272 if (signal_pending(current)) 6273 goto do_interrupted; 6274 6275 if (sctp_state(asoc, ESTABLISHED)) 6276 break; 6277 6278 /* Let another process have a go. Since we are going 6279 * to sleep anyway. 6280 */ 6281 sctp_release_sock(sk); 6282 current_timeo = schedule_timeout(current_timeo); 6283 sctp_lock_sock(sk); 6284 6285 *timeo_p = current_timeo; 6286 } 6287 6288 out: 6289 finish_wait(&asoc->wait, &wait); 6290 6291 /* Release the association's refcnt. */ 6292 sctp_association_put(asoc); 6293 6294 return err; 6295 6296 do_error: 6297 if (asoc->init_err_counter + 1 > asoc->max_init_attempts) 6298 err = -ETIMEDOUT; 6299 else 6300 err = -ECONNREFUSED; 6301 goto out; 6302 6303 do_interrupted: 6304 err = sock_intr_errno(*timeo_p); 6305 goto out; 6306 6307 do_nonblock: 6308 err = -EINPROGRESS; 6309 goto out; 6310 } 6311 6312 static int sctp_wait_for_accept(struct sock *sk, long timeo) 6313 { 6314 struct sctp_endpoint *ep; 6315 int err = 0; 6316 DEFINE_WAIT(wait); 6317 6318 ep = sctp_sk(sk)->ep; 6319 6320 6321 for (;;) { 6322 prepare_to_wait_exclusive(sk_sleep(sk), &wait, 6323 TASK_INTERRUPTIBLE); 6324 6325 if (list_empty(&ep->asocs)) { 6326 sctp_release_sock(sk); 6327 timeo = schedule_timeout(timeo); 6328 sctp_lock_sock(sk); 6329 } 6330 6331 err = -EINVAL; 6332 if (!sctp_sstate(sk, LISTENING)) 6333 break; 6334 6335 err = 0; 6336 if (!list_empty(&ep->asocs)) 6337 break; 6338 6339 err = sock_intr_errno(timeo); 6340 if (signal_pending(current)) 6341 break; 6342 6343 err = -EAGAIN; 6344 if (!timeo) 6345 break; 6346 } 6347 6348 finish_wait(sk_sleep(sk), &wait); 6349 6350 return err; 6351 } 6352 6353 static void sctp_wait_for_close(struct sock *sk, long timeout) 6354 { 6355 DEFINE_WAIT(wait); 6356 6357 do { 6358 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 6359 if (list_empty(&sctp_sk(sk)->ep->asocs)) 6360 break; 6361 sctp_release_sock(sk); 6362 timeout = schedule_timeout(timeout); 6363 sctp_lock_sock(sk); 6364 } while (!signal_pending(current) && timeout); 6365 6366 finish_wait(sk_sleep(sk), &wait); 6367 } 6368 6369 static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk) 6370 { 6371 struct sk_buff *frag; 6372 6373 if (!skb->data_len) 6374 goto done; 6375 6376 /* Don't forget the fragments. */ 6377 skb_walk_frags(skb, frag) 6378 sctp_skb_set_owner_r_frag(frag, sk); 6379 6380 done: 6381 sctp_skb_set_owner_r(skb, sk); 6382 } 6383 6384 void sctp_copy_sock(struct sock *newsk, struct sock *sk, 6385 struct sctp_association *asoc) 6386 { 6387 struct inet_sock *inet = inet_sk(sk); 6388 struct inet_sock *newinet; 6389 6390 newsk->sk_type = sk->sk_type; 6391 newsk->sk_bound_dev_if = sk->sk_bound_dev_if; 6392 newsk->sk_flags = sk->sk_flags; 6393 newsk->sk_no_check = sk->sk_no_check; 6394 newsk->sk_reuse = sk->sk_reuse; 6395 6396 newsk->sk_shutdown = sk->sk_shutdown; 6397 newsk->sk_destruct = inet_sock_destruct; 6398 newsk->sk_family = sk->sk_family; 6399 newsk->sk_protocol = IPPROTO_SCTP; 6400 newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv; 6401 newsk->sk_sndbuf = sk->sk_sndbuf; 6402 newsk->sk_rcvbuf = sk->sk_rcvbuf; 6403 newsk->sk_lingertime = sk->sk_lingertime; 6404 newsk->sk_rcvtimeo = sk->sk_rcvtimeo; 6405 newsk->sk_sndtimeo = sk->sk_sndtimeo; 6406 6407 newinet = inet_sk(newsk); 6408 6409 /* Initialize sk's sport, dport, rcv_saddr and daddr for 6410 * getsockname() and getpeername() 6411 */ 6412 newinet->inet_sport = inet->inet_sport; 6413 newinet->inet_saddr = inet->inet_saddr; 6414 newinet->inet_rcv_saddr = inet->inet_rcv_saddr; 6415 newinet->inet_dport = htons(asoc->peer.port); 6416 newinet->pmtudisc = inet->pmtudisc; 6417 newinet->inet_id = asoc->next_tsn ^ jiffies; 6418 6419 newinet->uc_ttl = inet->uc_ttl; 6420 newinet->mc_loop = 1; 6421 newinet->mc_ttl = 1; 6422 newinet->mc_index = 0; 6423 newinet->mc_list = NULL; 6424 } 6425 6426 /* Populate the fields of the newsk from the oldsk and migrate the assoc 6427 * and its messages to the newsk. 6428 */ 6429 static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk, 6430 struct sctp_association *assoc, 6431 sctp_socket_type_t type) 6432 { 6433 struct sctp_sock *oldsp = sctp_sk(oldsk); 6434 struct sctp_sock *newsp = sctp_sk(newsk); 6435 struct sctp_bind_bucket *pp; /* hash list port iterator */ 6436 struct sctp_endpoint *newep = newsp->ep; 6437 struct sk_buff *skb, *tmp; 6438 struct sctp_ulpevent *event; 6439 struct sctp_bind_hashbucket *head; 6440 6441 /* Migrate socket buffer sizes and all the socket level options to the 6442 * new socket. 6443 */ 6444 newsk->sk_sndbuf = oldsk->sk_sndbuf; 6445 newsk->sk_rcvbuf = oldsk->sk_rcvbuf; 6446 /* Brute force copy old sctp opt. */ 6447 inet_sk_copy_descendant(newsk, oldsk); 6448 6449 /* Restore the ep value that was overwritten with the above structure 6450 * copy. 6451 */ 6452 newsp->ep = newep; 6453 newsp->hmac = NULL; 6454 6455 /* Hook this new socket in to the bind_hash list. */ 6456 head = &sctp_port_hashtable[sctp_phashfn(inet_sk(oldsk)->inet_num)]; 6457 sctp_local_bh_disable(); 6458 sctp_spin_lock(&head->lock); 6459 pp = sctp_sk(oldsk)->bind_hash; 6460 sk_add_bind_node(newsk, &pp->owner); 6461 sctp_sk(newsk)->bind_hash = pp; 6462 inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num; 6463 sctp_spin_unlock(&head->lock); 6464 sctp_local_bh_enable(); 6465 6466 /* Copy the bind_addr list from the original endpoint to the new 6467 * endpoint so that we can handle restarts properly 6468 */ 6469 sctp_bind_addr_dup(&newsp->ep->base.bind_addr, 6470 &oldsp->ep->base.bind_addr, GFP_KERNEL); 6471 6472 /* Move any messages in the old socket's receive queue that are for the 6473 * peeled off association to the new socket's receive queue. 6474 */ 6475 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) { 6476 event = sctp_skb2event(skb); 6477 if (event->asoc == assoc) { 6478 __skb_unlink(skb, &oldsk->sk_receive_queue); 6479 __skb_queue_tail(&newsk->sk_receive_queue, skb); 6480 sctp_skb_set_owner_r_frag(skb, newsk); 6481 } 6482 } 6483 6484 /* Clean up any messages pending delivery due to partial 6485 * delivery. Three cases: 6486 * 1) No partial deliver; no work. 6487 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby. 6488 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue. 6489 */ 6490 skb_queue_head_init(&newsp->pd_lobby); 6491 atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode); 6492 6493 if (atomic_read(&sctp_sk(oldsk)->pd_mode)) { 6494 struct sk_buff_head *queue; 6495 6496 /* Decide which queue to move pd_lobby skbs to. */ 6497 if (assoc->ulpq.pd_mode) { 6498 queue = &newsp->pd_lobby; 6499 } else 6500 queue = &newsk->sk_receive_queue; 6501 6502 /* Walk through the pd_lobby, looking for skbs that 6503 * need moved to the new socket. 6504 */ 6505 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) { 6506 event = sctp_skb2event(skb); 6507 if (event->asoc == assoc) { 6508 __skb_unlink(skb, &oldsp->pd_lobby); 6509 __skb_queue_tail(queue, skb); 6510 sctp_skb_set_owner_r_frag(skb, newsk); 6511 } 6512 } 6513 6514 /* Clear up any skbs waiting for the partial 6515 * delivery to finish. 6516 */ 6517 if (assoc->ulpq.pd_mode) 6518 sctp_clear_pd(oldsk, NULL); 6519 6520 } 6521 6522 sctp_skb_for_each(skb, &assoc->ulpq.reasm, tmp) 6523 sctp_skb_set_owner_r_frag(skb, newsk); 6524 6525 sctp_skb_for_each(skb, &assoc->ulpq.lobby, tmp) 6526 sctp_skb_set_owner_r_frag(skb, newsk); 6527 6528 /* Set the type of socket to indicate that it is peeled off from the 6529 * original UDP-style socket or created with the accept() call on a 6530 * TCP-style socket.. 6531 */ 6532 newsp->type = type; 6533 6534 /* Mark the new socket "in-use" by the user so that any packets 6535 * that may arrive on the association after we've moved it are 6536 * queued to the backlog. This prevents a potential race between 6537 * backlog processing on the old socket and new-packet processing 6538 * on the new socket. 6539 * 6540 * The caller has just allocated newsk so we can guarantee that other 6541 * paths won't try to lock it and then oldsk. 6542 */ 6543 lock_sock_nested(newsk, SINGLE_DEPTH_NESTING); 6544 sctp_assoc_migrate(assoc, newsk); 6545 6546 /* If the association on the newsk is already closed before accept() 6547 * is called, set RCV_SHUTDOWN flag. 6548 */ 6549 if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP)) 6550 newsk->sk_shutdown |= RCV_SHUTDOWN; 6551 6552 newsk->sk_state = SCTP_SS_ESTABLISHED; 6553 sctp_release_sock(newsk); 6554 } 6555 6556 6557 /* This proto struct describes the ULP interface for SCTP. */ 6558 struct proto sctp_prot = { 6559 .name = "SCTP", 6560 .owner = THIS_MODULE, 6561 .close = sctp_close, 6562 .connect = sctp_connect, 6563 .disconnect = sctp_disconnect, 6564 .accept = sctp_accept, 6565 .ioctl = sctp_ioctl, 6566 .init = sctp_init_sock, 6567 .destroy = sctp_destroy_sock, 6568 .shutdown = sctp_shutdown, 6569 .setsockopt = sctp_setsockopt, 6570 .getsockopt = sctp_getsockopt, 6571 .sendmsg = sctp_sendmsg, 6572 .recvmsg = sctp_recvmsg, 6573 .bind = sctp_bind, 6574 .backlog_rcv = sctp_backlog_rcv, 6575 .hash = sctp_hash, 6576 .unhash = sctp_unhash, 6577 .get_port = sctp_get_port, 6578 .obj_size = sizeof(struct sctp_sock), 6579 .sysctl_mem = sysctl_sctp_mem, 6580 .sysctl_rmem = sysctl_sctp_rmem, 6581 .sysctl_wmem = sysctl_sctp_wmem, 6582 .memory_pressure = &sctp_memory_pressure, 6583 .enter_memory_pressure = sctp_enter_memory_pressure, 6584 .memory_allocated = &sctp_memory_allocated, 6585 .sockets_allocated = &sctp_sockets_allocated, 6586 }; 6587 6588 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 6589 6590 struct proto sctpv6_prot = { 6591 .name = "SCTPv6", 6592 .owner = THIS_MODULE, 6593 .close = sctp_close, 6594 .connect = sctp_connect, 6595 .disconnect = sctp_disconnect, 6596 .accept = sctp_accept, 6597 .ioctl = sctp_ioctl, 6598 .init = sctp_init_sock, 6599 .destroy = sctp_destroy_sock, 6600 .shutdown = sctp_shutdown, 6601 .setsockopt = sctp_setsockopt, 6602 .getsockopt = sctp_getsockopt, 6603 .sendmsg = sctp_sendmsg, 6604 .recvmsg = sctp_recvmsg, 6605 .bind = sctp_bind, 6606 .backlog_rcv = sctp_backlog_rcv, 6607 .hash = sctp_hash, 6608 .unhash = sctp_unhash, 6609 .get_port = sctp_get_port, 6610 .obj_size = sizeof(struct sctp6_sock), 6611 .sysctl_mem = sysctl_sctp_mem, 6612 .sysctl_rmem = sysctl_sctp_rmem, 6613 .sysctl_wmem = sysctl_sctp_wmem, 6614 .memory_pressure = &sctp_memory_pressure, 6615 .enter_memory_pressure = sctp_enter_memory_pressure, 6616 .memory_allocated = &sctp_memory_allocated, 6617 .sockets_allocated = &sctp_sockets_allocated, 6618 }; 6619 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */ 6620