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