net/sctp/socket.c

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