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