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