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