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