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