net/sctp/socket.c

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