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