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 /* Only called when shutdown a listening SCTP socket. */
4838 static int sctp_disconnect(struct sock *sk, int flags)
4839 {
4840         if (!sctp_style(sk, TCP))
4841                 return -EOPNOTSUPP;
4842
4843         sk->sk_shutdown |= RCV_SHUTDOWN;
4844         return 0;
4845 }
4846
4847 /* 4.1.4 accept() - TCP Style Syntax
4848  *
4849  * Applications use accept() call to remove an established SCTP
4850  * association from the accept queue of the endpoint.  A new socket
4851  * descriptor will be returned from accept() to represent the newly
4852  * formed association.
4853  */
4854 static struct sock *sctp_accept(struct sock *sk, struct proto_accept_arg *arg)
4855 {
4856         struct sctp_sock *sp;
4857         struct sctp_endpoint *ep;
4858         struct sock *newsk = NULL;
4859         struct sctp_association *asoc;
4860         long timeo;
4861         int error = 0;
4862
4863         lock_sock(sk);
4864
4865         sp = sctp_sk(sk);
4866         ep = sp->ep;
4867
4868         if (!sctp_style(sk, TCP)) {
4869                 error = -EOPNOTSUPP;
4870                 goto out;
4871         }
4872
4873         if (!sctp_sstate(sk, LISTENING) ||
4874             (sk->sk_shutdown & RCV_SHUTDOWN)) {
4875                 error = -EINVAL;
4876                 goto out;
4877         }
4878
4879         timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
4880
4881         error = sctp_wait_for_accept(sk, timeo);
4882         if (error)
4883                 goto out;
4884
4885         /* We treat the list of associations on the endpoint as the accept
4886          * queue and pick the first association on the list.
4887          */
4888         asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
4889
4890         newsk = sp->pf->create_accept_sk(sk, asoc, arg->kern);
4891         if (!newsk) {
4892                 error = -ENOMEM;
4893                 goto out;
4894         }
4895
4896         /* Populate the fields of the newsk from the oldsk and migrate the
4897          * asoc to the newsk.
4898          */
4899         error = sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
4900         if (error) {
4901                 sk_common_release(newsk);
4902                 newsk = NULL;
4903         }
4904
4905 out:
4906         release_sock(sk);
4907         arg->err = error;
4908         return newsk;
4909 }
4910
4911 /* The SCTP ioctl handler. */
4912 static int sctp_ioctl(struct sock *sk, int cmd, int *karg)
4913 {
4914         int rc = -ENOTCONN;
4915
4916         lock_sock(sk);
4917
4918         /*
4919          * SEQPACKET-style sockets in LISTENING state are valid, for
4920          * SCTP, so only discard TCP-style sockets in LISTENING state.
4921          */
4922         if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
4923                 goto out;
4924
4925         switch (cmd) {
4926         case SIOCINQ: {
4927                 struct sk_buff *skb;
4928                 *karg = 0;
4929
4930                 skb = skb_peek(&sk->sk_receive_queue);
4931                 if (skb != NULL) {
4932                         /*
4933                          * We will only return the amount of this packet since
4934                          * that is all that will be read.
4935                          */
4936                         *karg = skb->len;
4937                 }
4938                 rc = 0;
4939                 break;
4940         }
4941         default:
4942                 rc = -ENOIOCTLCMD;
4943                 break;
4944         }
4945 out:
4946         release_sock(sk);
4947         return rc;
4948 }
4949
4950 /* This is the function which gets called during socket creation to
4951  * initialized the SCTP-specific portion of the sock.
4952  * The sock structure should already be zero-filled memory.
4953  */
4954 static int sctp_init_sock(struct sock *sk)
4955 {
4956         struct net *net = sock_net(sk);
4957         struct sctp_sock *sp;
4958
4959         pr_debug("%s: sk:%p\n", __func__, sk);
4960
4961         sp = sctp_sk(sk);
4962
4963         /* Initialize the SCTP per socket area.  */
4964         switch (sk->sk_type) {
4965         case SOCK_SEQPACKET:
4966                 sp->type = SCTP_SOCKET_UDP;
4967                 break;
4968         case SOCK_STREAM:
4969                 sp->type = SCTP_SOCKET_TCP;
4970                 break;
4971         default:
4972                 return -ESOCKTNOSUPPORT;
4973         }
4974
4975         sk->sk_gso_type = SKB_GSO_SCTP;
4976
4977         /* Initialize default send parameters. These parameters can be
4978          * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4979          */
4980         sp->default_stream = 0;
4981         sp->default_ppid = 0;
4982         sp->default_flags = 0;
4983         sp->default_context = 0;
4984         sp->default_timetolive = 0;
4985
4986         sp->default_rcv_context = 0;
4987         sp->max_burst = net->sctp.max_burst;
4988
4989         sp->sctp_hmac_alg = net->sctp.sctp_hmac_alg;
4990
4991         /* Initialize default setup parameters. These parameters
4992          * can be modified with the SCTP_INITMSG socket option or
4993          * overridden by the SCTP_INIT CMSG.
4994          */
4995         sp->initmsg.sinit_num_ostreams   = sctp_max_outstreams;
4996         sp->initmsg.sinit_max_instreams  = sctp_max_instreams;
4997         sp->initmsg.sinit_max_attempts   = net->sctp.max_retrans_init;
4998         sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
4999
5000         /* Initialize default RTO related parameters.  These parameters can
5001          * be modified for with the SCTP_RTOINFO socket option.
5002          */
5003         sp->rtoinfo.srto_initial = net->sctp.rto_initial;
5004         sp->rtoinfo.srto_max     = net->sctp.rto_max;
5005         sp->rtoinfo.srto_min     = net->sctp.rto_min;
5006
5007         /* Initialize default association related parameters. These parameters
5008          * can be modified with the SCTP_ASSOCINFO socket option.
5009          */
5010         sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
5011         sp->assocparams.sasoc_number_peer_destinations = 0;
5012         sp->assocparams.sasoc_peer_rwnd = 0;
5013         sp->assocparams.sasoc_local_rwnd = 0;
5014         sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
5015
5016         /* Initialize default event subscriptions. By default, all the
5017          * options are off.
5018          */
5019         sp->subscribe = 0;
5020
5021         /* Default Peer Address Parameters.  These defaults can
5022          * be modified via SCTP_PEER_ADDR_PARAMS
5023          */
5024         sp->hbinterval  = net->sctp.hb_interval;
5025         sp->udp_port    = htons(net->sctp.udp_port);
5026         sp->encap_port  = htons(net->sctp.encap_port);
5027         sp->pathmaxrxt  = net->sctp.max_retrans_path;
5028         sp->pf_retrans  = net->sctp.pf_retrans;
5029         sp->ps_retrans  = net->sctp.ps_retrans;
5030         sp->pf_expose   = net->sctp.pf_expose;
5031         sp->pathmtu     = 0; /* allow default discovery */
5032         sp->sackdelay   = net->sctp.sack_timeout;
5033         sp->sackfreq    = 2;
5034         sp->param_flags = SPP_HB_ENABLE |
5035                           SPP_PMTUD_ENABLE |
5036                           SPP_SACKDELAY_ENABLE;
5037         sp->default_ss = SCTP_SS_DEFAULT;
5038
5039         /* If enabled no SCTP message fragmentation will be performed.
5040          * Configure through SCTP_DISABLE_FRAGMENTS socket option.
5041          */
5042         sp->disable_fragments = 0;
5043
5044         /* Enable Nagle algorithm by default.  */
5045         sp->nodelay           = 0;
5046
5047         sp->recvrcvinfo = 0;
5048         sp->recvnxtinfo = 0;
5049
5050         /* Enable by default. */
5051         sp->v4mapped          = 1;
5052
5053         /* Auto-close idle associations after the configured
5054          * number of seconds.  A value of 0 disables this
5055          * feature.  Configure through the SCTP_AUTOCLOSE socket option,
5056          * for UDP-style sockets only.
5057          */
5058         sp->autoclose         = 0;
5059
5060         /* User specified fragmentation limit. */
5061         sp->user_frag         = 0;
5062
5063         sp->adaptation_ind = 0;
5064
5065         sp->pf = sctp_get_pf_specific(sk->sk_family);
5066
5067         /* Control variables for partial data delivery. */
5068         atomic_set(&sp->pd_mode, 0);
5069         skb_queue_head_init(&sp->pd_lobby);
5070         sp->frag_interleave = 0;
5071         sp->probe_interval = net->sctp.probe_interval;
5072
5073         /* Create a per socket endpoint structure.  Even if we
5074          * change the data structure relationships, this may still
5075          * be useful for storing pre-connect address information.
5076          */
5077         sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
5078         if (!sp->ep)
5079                 return -ENOMEM;
5080
5081         sp->hmac = NULL;
5082
5083         sk->sk_destruct = sctp_destruct_sock;
5084
5085         SCTP_DBG_OBJCNT_INC(sock);
5086
5087         sk_sockets_allocated_inc(sk);
5088         sock_prot_inuse_add(net, sk->sk_prot, 1);
5089
5090         return 0;
5091 }
5092
5093 /* Cleanup any SCTP per socket resources. Must be called with
5094  * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5095  */
5096 static void sctp_destroy_sock(struct sock *sk)
5097 {
5098         struct sctp_sock *sp;
5099
5100         pr_debug("%s: sk:%p\n", __func__, sk);
5101
5102         /* Release our hold on the endpoint. */
5103         sp = sctp_sk(sk);
5104         /* This could happen during socket init, thus we bail out
5105          * early, since the rest of the below is not setup either.
5106          */
5107         if (sp->ep == NULL)
5108                 return;
5109
5110         if (sp->do_auto_asconf) {
5111                 sp->do_auto_asconf = 0;
5112                 list_del(&sp->auto_asconf_list);
5113         }
5114         sctp_endpoint_free(sp->ep);
5115         sk_sockets_allocated_dec(sk);
5116         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
5117 }
5118
5119 /* Triggered when there are no references on the socket anymore */
5120 static void sctp_destruct_common(struct sock *sk)
5121 {
5122         struct sctp_sock *sp = sctp_sk(sk);
5123
5124         /* Free up the HMAC transform. */
5125         crypto_free_shash(sp->hmac);
5126 }
5127
5128 static void sctp_destruct_sock(struct sock *sk)
5129 {
5130         sctp_destruct_common(sk);
5131         inet_sock_destruct(sk);
5132 }
5133
5134 /* API 4.1.7 shutdown() - TCP Style Syntax
5135  *     int shutdown(int socket, int how);
5136  *
5137  *     sd      - the socket descriptor of the association to be closed.
5138  *     how     - Specifies the type of shutdown.  The  values  are
5139  *               as follows:
5140  *               SHUT_RD
5141  *                     Disables further receive operations. No SCTP
5142  *                     protocol action is taken.
5143  *               SHUT_WR
5144  *                     Disables further send operations, and initiates
5145  *                     the SCTP shutdown sequence.
5146  *               SHUT_RDWR
5147  *                     Disables further send  and  receive  operations
5148  *                     and initiates the SCTP shutdown sequence.
5149  */
5150 static void sctp_shutdown(struct sock *sk, int how)
5151 {
5152         struct net *net = sock_net(sk);
5153         struct sctp_endpoint *ep;
5154
5155         if (!sctp_style(sk, TCP))
5156                 return;
5157
5158         ep = sctp_sk(sk)->ep;
5159         if (how & SEND_SHUTDOWN && !list_empty(&ep->asocs)) {
5160                 struct sctp_association *asoc;
5161
5162                 inet_sk_set_state(sk, SCTP_SS_CLOSING);
5163                 asoc = list_entry(ep->asocs.next,
5164                                   struct sctp_association, asocs);
5165                 sctp_primitive_SHUTDOWN(net, asoc, NULL);
5166         }
5167 }
5168
5169 int sctp_get_sctp_info(struct sock *sk, struct sctp_association *asoc,
5170                        struct sctp_info *info)
5171 {
5172         struct sctp_transport *prim;
5173         struct list_head *pos;
5174         int mask;
5175
5176         memset(info, 0, sizeof(*info));
5177         if (!asoc) {
5178                 struct sctp_sock *sp = sctp_sk(sk);
5179
5180                 info->sctpi_s_autoclose = sp->autoclose;
5181                 info->sctpi_s_adaptation_ind = sp->adaptation_ind;
5182                 info->sctpi_s_pd_point = sp->pd_point;
5183                 info->sctpi_s_nodelay = sp->nodelay;
5184                 info->sctpi_s_disable_fragments = sp->disable_fragments;
5185                 info->sctpi_s_v4mapped = sp->v4mapped;
5186                 info->sctpi_s_frag_interleave = sp->frag_interleave;
5187                 info->sctpi_s_type = sp->type;
5188
5189                 return 0;
5190         }
5191
5192         info->sctpi_tag = asoc->c.my_vtag;
5193         info->sctpi_state = asoc->state;
5194         info->sctpi_rwnd = asoc->a_rwnd;
5195         info->sctpi_unackdata = asoc->unack_data;
5196         info->sctpi_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5197         info->sctpi_instrms = asoc->stream.incnt;
5198         info->sctpi_outstrms = asoc->stream.outcnt;
5199         list_for_each(pos, &asoc->base.inqueue.in_chunk_list)
5200                 info->sctpi_inqueue++;
5201         list_for_each(pos, &asoc->outqueue.out_chunk_list)
5202                 info->sctpi_outqueue++;
5203         info->sctpi_overall_error = asoc->overall_error_count;
5204         info->sctpi_max_burst = asoc->max_burst;
5205         info->sctpi_maxseg = asoc->frag_point;
5206         info->sctpi_peer_rwnd = asoc->peer.rwnd;
5207         info->sctpi_peer_tag = asoc->c.peer_vtag;
5208
5209         mask = asoc->peer.intl_capable << 1;
5210         mask = (mask | asoc->peer.ecn_capable) << 1;
5211         mask = (mask | asoc->peer.ipv4_address) << 1;
5212         mask = (mask | asoc->peer.ipv6_address) << 1;
5213         mask = (mask | asoc->peer.reconf_capable) << 1;
5214         mask = (mask | asoc->peer.asconf_capable) << 1;
5215         mask = (mask | asoc->peer.prsctp_capable) << 1;
5216         mask = (mask | asoc->peer.auth_capable);
5217         info->sctpi_peer_capable = mask;
5218         mask = asoc->peer.sack_needed << 1;
5219         mask = (mask | asoc->peer.sack_generation) << 1;
5220         mask = (mask | asoc->peer.zero_window_announced);
5221         info->sctpi_peer_sack = mask;
5222
5223         info->sctpi_isacks = asoc->stats.isacks;
5224         info->sctpi_osacks = asoc->stats.osacks;
5225         info->sctpi_opackets = asoc->stats.opackets;
5226         info->sctpi_ipackets = asoc->stats.ipackets;
5227         info->sctpi_rtxchunks = asoc->stats.rtxchunks;
5228         info->sctpi_outofseqtsns = asoc->stats.outofseqtsns;
5229         info->sctpi_idupchunks = asoc->stats.idupchunks;
5230         info->sctpi_gapcnt = asoc->stats.gapcnt;
5231         info->sctpi_ouodchunks = asoc->stats.ouodchunks;
5232         info->sctpi_iuodchunks = asoc->stats.iuodchunks;
5233         info->sctpi_oodchunks = asoc->stats.oodchunks;
5234         info->sctpi_iodchunks = asoc->stats.iodchunks;
5235         info->sctpi_octrlchunks = asoc->stats.octrlchunks;
5236         info->sctpi_ictrlchunks = asoc->stats.ictrlchunks;
5237
5238         prim = asoc->peer.primary_path;
5239         memcpy(&info->sctpi_p_address, &prim->ipaddr, sizeof(prim->ipaddr));
5240         info->sctpi_p_state = prim->state;
5241         info->sctpi_p_cwnd = prim->cwnd;
5242         info->sctpi_p_srtt = prim->srtt;
5243         info->sctpi_p_rto = jiffies_to_msecs(prim->rto);
5244         info->sctpi_p_hbinterval = prim->hbinterval;
5245         info->sctpi_p_pathmaxrxt = prim->pathmaxrxt;
5246         info->sctpi_p_sackdelay = jiffies_to_msecs(prim->sackdelay);
5247         info->sctpi_p_ssthresh = prim->ssthresh;
5248         info->sctpi_p_partial_bytes_acked = prim->partial_bytes_acked;
5249         info->sctpi_p_flight_size = prim->flight_size;
5250         info->sctpi_p_error = prim->error_count;
5251
5252         return 0;
5253 }
5254 EXPORT_SYMBOL_GPL(sctp_get_sctp_info);
5255
5256 /* use callback to avoid exporting the core structure */
5257 void sctp_transport_walk_start(struct rhashtable_iter *iter) __acquires(RCU)
5258 {
5259         rhltable_walk_enter(&sctp_transport_hashtable, iter);
5260
5261         rhashtable_walk_start(iter);
5262 }
5263
5264 void sctp_transport_walk_stop(struct rhashtable_iter *iter) __releases(RCU)
5265 {
5266         rhashtable_walk_stop(iter);
5267         rhashtable_walk_exit(iter);
5268 }
5269
5270 struct sctp_transport *sctp_transport_get_next(struct net *net,
5271                                                struct rhashtable_iter *iter)
5272 {
5273         struct sctp_transport *t;
5274
5275         t = rhashtable_walk_next(iter);
5276         for (; t; t = rhashtable_walk_next(iter)) {
5277                 if (IS_ERR(t)) {
5278                         if (PTR_ERR(t) == -EAGAIN)
5279                                 continue;
5280                         break;
5281                 }
5282
5283                 if (!sctp_transport_hold(t))
5284                         continue;
5285
5286                 if (net_eq(t->asoc->base.net, net) &&
5287                     t->asoc->peer.primary_path == t)
5288                         break;
5289
5290                 sctp_transport_put(t);
5291         }
5292
5293         return t;
5294 }
5295
5296 struct sctp_transport *sctp_transport_get_idx(struct net *net,
5297                                               struct rhashtable_iter *iter,
5298                                               int pos)
5299 {
5300         struct sctp_transport *t;
5301
5302         if (!pos)
5303                 return SEQ_START_TOKEN;
5304
5305         while ((t = sctp_transport_get_next(net, iter)) && !IS_ERR(t)) {
5306                 if (!--pos)
5307                         break;
5308                 sctp_transport_put(t);
5309         }
5310
5311         return t;
5312 }
5313
5314 int sctp_for_each_endpoint(int (*cb)(struct sctp_endpoint *, void *),
5315                            void *p) {
5316         int err = 0;
5317         int hash = 0;
5318         struct sctp_endpoint *ep;
5319         struct sctp_hashbucket *head;
5320
5321         for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
5322              hash++, head++) {
5323                 read_lock_bh(&head->lock);
5324                 sctp_for_each_hentry(ep, &head->chain) {
5325                         err = cb(ep, p);
5326                         if (err)
5327                                 break;
5328                 }
5329                 read_unlock_bh(&head->lock);
5330         }
5331
5332         return err;
5333 }
5334 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint);
5335
5336 int sctp_transport_lookup_process(sctp_callback_t cb, struct net *net,
5337                                   const union sctp_addr *laddr,
5338                                   const union sctp_addr *paddr, void *p, int dif)
5339 {
5340         struct sctp_transport *transport;
5341         struct sctp_endpoint *ep;
5342         int err = -ENOENT;
5343
5344         rcu_read_lock();
5345         transport = sctp_addrs_lookup_transport(net, laddr, paddr, dif, dif);
5346         if (!transport) {
5347                 rcu_read_unlock();
5348                 return err;
5349         }
5350         ep = transport->asoc->ep;
5351         if (!sctp_endpoint_hold(ep)) { /* asoc can be peeled off */
5352                 sctp_transport_put(transport);
5353                 rcu_read_unlock();
5354                 return err;
5355         }
5356         rcu_read_unlock();
5357
5358         err = cb(ep, transport, p);
5359         sctp_endpoint_put(ep);
5360         sctp_transport_put(transport);
5361         return err;
5362 }
5363 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process);
5364
5365 int sctp_transport_traverse_process(sctp_callback_t cb, sctp_callback_t cb_done,
5366                                     struct net *net, int *pos, void *p)
5367 {
5368         struct rhashtable_iter hti;
5369         struct sctp_transport *tsp;
5370         struct sctp_endpoint *ep;
5371         int ret;
5372
5373 again:
5374         ret = 0;
5375         sctp_transport_walk_start(&hti);
5376
5377         tsp = sctp_transport_get_idx(net, &hti, *pos + 1);
5378         for (; !IS_ERR_OR_NULL(tsp); tsp = sctp_transport_get_next(net, &hti)) {
5379                 ep = tsp->asoc->ep;
5380                 if (sctp_endpoint_hold(ep)) { /* asoc can be peeled off */
5381                         ret = cb(ep, tsp, p);
5382                         if (ret)
5383                                 break;
5384                         sctp_endpoint_put(ep);
5385                 }
5386                 (*pos)++;
5387                 sctp_transport_put(tsp);
5388         }
5389         sctp_transport_walk_stop(&hti);
5390
5391         if (ret) {
5392                 if (cb_done && !cb_done(ep, tsp, p)) {
5393                         (*pos)++;
5394                         sctp_endpoint_put(ep);
5395                         sctp_transport_put(tsp);
5396                         goto again;
5397                 }
5398                 sctp_endpoint_put(ep);
5399                 sctp_transport_put(tsp);
5400         }
5401
5402         return ret;
5403 }
5404 EXPORT_SYMBOL_GPL(sctp_transport_traverse_process);
5405
5406 /* 7.2.1 Association Status (SCTP_STATUS)
5407
5408  * Applications can retrieve current status information about an
5409  * association, including association state, peer receiver window size,
5410  * number of unacked data chunks, and number of data chunks pending
5411  * receipt.  This information is read-only.
5412  */
5413 static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
5414                                        char __user *optval,
5415                                        int __user *optlen)
5416 {
5417         struct sctp_status status;
5418         struct sctp_association *asoc = NULL;
5419         struct sctp_transport *transport;
5420         sctp_assoc_t associd;
5421         int retval = 0;
5422
5423         if (len < sizeof(status)) {
5424                 retval = -EINVAL;
5425                 goto out;
5426         }
5427
5428         len = sizeof(status);
5429         if (copy_from_user(&status, optval, len)) {
5430                 retval = -EFAULT;
5431                 goto out;
5432         }
5433
5434         associd = status.sstat_assoc_id;
5435         asoc = sctp_id2assoc(sk, associd);
5436         if (!asoc) {
5437                 retval = -EINVAL;
5438                 goto out;
5439         }
5440
5441         transport = asoc->peer.primary_path;
5442
5443         status.sstat_assoc_id = sctp_assoc2id(asoc);
5444         status.sstat_state = sctp_assoc_to_state(asoc);
5445         status.sstat_rwnd =  asoc->peer.rwnd;
5446         status.sstat_unackdata = asoc->unack_data;
5447
5448         status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5449         status.sstat_instrms = asoc->stream.incnt;
5450         status.sstat_outstrms = asoc->stream.outcnt;
5451         status.sstat_fragmentation_point = asoc->frag_point;
5452         status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5453         memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
5454                         transport->af_specific->sockaddr_len);
5455         /* Map ipv4 address into v4-mapped-on-v6 address.  */
5456         sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
5457                 (union sctp_addr *)&status.sstat_primary.spinfo_address);
5458         status.sstat_primary.spinfo_state = transport->state;
5459         status.sstat_primary.spinfo_cwnd = transport->cwnd;
5460         status.sstat_primary.spinfo_srtt = transport->srtt;
5461         status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
5462         status.sstat_primary.spinfo_mtu = transport->pathmtu;
5463
5464         if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
5465                 status.sstat_primary.spinfo_state = SCTP_ACTIVE;
5466
5467         if (put_user(len, optlen)) {
5468                 retval = -EFAULT;
5469                 goto out;
5470         }
5471
5472         pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5473                  __func__, len, status.sstat_state, status.sstat_rwnd,
5474                  status.sstat_assoc_id);
5475
5476         if (copy_to_user(optval, &status, len)) {
5477                 retval = -EFAULT;
5478                 goto out;
5479         }
5480
5481 out:
5482         return retval;
5483 }
5484
5485
5486 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5487  *
5488  * Applications can retrieve information about a specific peer address
5489  * of an association, including its reachability state, congestion
5490  * window, and retransmission timer values.  This information is
5491  * read-only.
5492  */
5493 static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
5494                                           char __user *optval,
5495                                           int __user *optlen)
5496 {
5497         struct sctp_paddrinfo pinfo;
5498         struct sctp_transport *transport;
5499         int retval = 0;
5500
5501         if (len < sizeof(pinfo)) {
5502                 retval = -EINVAL;
5503                 goto out;
5504         }
5505
5506         len = sizeof(pinfo);
5507         if (copy_from_user(&pinfo, optval, len)) {
5508                 retval = -EFAULT;
5509                 goto out;
5510         }
5511
5512         transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
5513                                            pinfo.spinfo_assoc_id);
5514         if (!transport) {
5515                 retval = -EINVAL;
5516                 goto out;
5517         }
5518
5519         if (transport->state == SCTP_PF &&
5520             transport->asoc->pf_expose == SCTP_PF_EXPOSE_DISABLE) {
5521                 retval = -EACCES;
5522                 goto out;
5523         }
5524
5525         pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5526         pinfo.spinfo_state = transport->state;
5527         pinfo.spinfo_cwnd = transport->cwnd;
5528         pinfo.spinfo_srtt = transport->srtt;
5529         pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
5530         pinfo.spinfo_mtu = transport->pathmtu;
5531
5532         if (pinfo.spinfo_state == SCTP_UNKNOWN)
5533                 pinfo.spinfo_state = SCTP_ACTIVE;
5534
5535         if (put_user(len, optlen)) {
5536                 retval = -EFAULT;
5537                 goto out;
5538         }
5539
5540         if (copy_to_user(optval, &pinfo, len)) {
5541                 retval = -EFAULT;
5542                 goto out;
5543         }
5544
5545 out:
5546         return retval;
5547 }
5548
5549 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5550  *
5551  * This option is a on/off flag.  If enabled no SCTP message
5552  * fragmentation will be performed.  Instead if a message being sent
5553  * exceeds the current PMTU size, the message will NOT be sent and
5554  * instead a error will be indicated to the user.
5555  */
5556 static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
5557                                         char __user *optval, int __user *optlen)
5558 {
5559         int val;
5560
5561         if (len < sizeof(int))
5562                 return -EINVAL;
5563
5564         len = sizeof(int);
5565         val = (sctp_sk(sk)->disable_fragments == 1);
5566         if (put_user(len, optlen))
5567                 return -EFAULT;
5568         if (copy_to_user(optval, &val, len))
5569                 return -EFAULT;
5570         return 0;
5571 }
5572
5573 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5574  *
5575  * This socket option is used to specify various notifications and
5576  * ancillary data the user wishes to receive.
5577  */
5578 static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
5579                                   int __user *optlen)
5580 {
5581         struct sctp_event_subscribe subscribe;
5582         __u8 *sn_type = (__u8 *)&subscribe;
5583         int i;
5584
5585         if (len == 0)
5586                 return -EINVAL;
5587         if (len > sizeof(struct sctp_event_subscribe))
5588                 len = sizeof(struct sctp_event_subscribe);
5589         if (put_user(len, optlen))
5590                 return -EFAULT;
5591
5592         for (i = 0; i < len; i++)
5593                 sn_type[i] = sctp_ulpevent_type_enabled(sctp_sk(sk)->subscribe,
5594                                                         SCTP_SN_TYPE_BASE + i);
5595
5596         if (copy_to_user(optval, &subscribe, len))
5597                 return -EFAULT;
5598
5599         return 0;
5600 }
5601
5602 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5603  *
5604  * This socket option is applicable to the UDP-style socket only.  When
5605  * set it will cause associations that are idle for more than the
5606  * specified number of seconds to automatically close.  An association
5607  * being idle is defined an association that has NOT sent or received
5608  * user data.  The special value of '0' indicates that no automatic
5609  * close of any associations should be performed.  The option expects an
5610  * integer defining the number of seconds of idle time before an
5611  * association is closed.
5612  */
5613 static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
5614 {
5615         /* Applicable to UDP-style socket only */
5616         if (sctp_style(sk, TCP))
5617                 return -EOPNOTSUPP;
5618         if (len < sizeof(int))
5619                 return -EINVAL;
5620         len = sizeof(int);
5621         if (put_user(len, optlen))
5622                 return -EFAULT;
5623         if (put_user(sctp_sk(sk)->autoclose, (int __user *)optval))
5624                 return -EFAULT;
5625         return 0;
5626 }
5627
5628 /* Helper routine to branch off an association to a new socket.  */
5629 int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp)
5630 {
5631         struct sctp_association *asoc = sctp_id2assoc(sk, id);
5632         struct sctp_sock *sp = sctp_sk(sk);
5633         struct socket *sock;
5634         int err = 0;
5635
5636         /* Do not peel off from one netns to another one. */
5637         if (!net_eq(current->nsproxy->net_ns, sock_net(sk)))
5638                 return -EINVAL;
5639
5640         if (!asoc)
5641                 return -EINVAL;
5642
5643         /* An association cannot be branched off from an already peeled-off
5644          * socket, nor is this supported for tcp style sockets.
5645          */
5646         if (!sctp_style(sk, UDP))
5647                 return -EINVAL;
5648
5649         /* Create a new socket.  */
5650         err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
5651         if (err < 0)
5652                 return err;
5653
5654         sctp_copy_sock(sock->sk, sk, asoc);
5655
5656         /* Make peeled-off sockets more like 1-1 accepted sockets.
5657          * Set the daddr and initialize id to something more random and also
5658          * copy over any ip options.
5659          */
5660         sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sock->sk);
5661         sp->pf->copy_ip_options(sk, sock->sk);
5662
5663         /* Populate the fields of the newsk from the oldsk and migrate the
5664          * asoc to the newsk.
5665          */
5666         err = sctp_sock_migrate(sk, sock->sk, asoc,
5667                                 SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
5668         if (err) {
5669                 sock_release(sock);
5670                 sock = NULL;
5671         }
5672
5673         *sockp = sock;
5674
5675         return err;
5676 }
5677 EXPORT_SYMBOL(sctp_do_peeloff);
5678
5679 static int sctp_getsockopt_peeloff_common(struct sock *sk, sctp_peeloff_arg_t *peeloff,
5680                                           struct file **newfile, unsigned flags)
5681 {
5682         struct socket *newsock;
5683         int retval;
5684
5685         retval = sctp_do_peeloff(sk, peeloff->associd, &newsock);
5686         if (retval < 0)
5687                 goto out;
5688
5689         /* Map the socket to an unused fd that can be returned to the user.  */
5690         retval = get_unused_fd_flags(flags & SOCK_CLOEXEC);
5691         if (retval < 0) {
5692                 sock_release(newsock);
5693                 goto out;
5694         }
5695
5696         *newfile = sock_alloc_file(newsock, 0, NULL);
5697         if (IS_ERR(*newfile)) {
5698                 put_unused_fd(retval);
5699                 retval = PTR_ERR(*newfile);
5700                 *newfile = NULL;
5701                 return retval;
5702         }
5703
5704         pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__, sk, newsock->sk,
5705                  retval);
5706
5707         peeloff->sd = retval;
5708
5709         if (flags & SOCK_NONBLOCK)
5710                 (*newfile)->f_flags |= O_NONBLOCK;
5711 out:
5712         return retval;
5713 }
5714
5715 static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
5716 {
5717         sctp_peeloff_arg_t peeloff;
5718         struct file *newfile = NULL;
5719         int retval = 0;
5720
5721         if (len < sizeof(sctp_peeloff_arg_t))
5722                 return -EINVAL;
5723         len = sizeof(sctp_peeloff_arg_t);
5724         if (copy_from_user(&peeloff, optval, len))
5725                 return -EFAULT;
5726
5727         retval = sctp_getsockopt_peeloff_common(sk, &peeloff, &newfile, 0);
5728         if (retval < 0)
5729                 goto out;
5730
5731         /* Return the fd mapped to the new socket.  */
5732         if (put_user(len, optlen)) {
5733                 fput(newfile);
5734                 put_unused_fd(retval);
5735                 return -EFAULT;
5736         }
5737
5738         if (copy_to_user(optval, &peeloff, len)) {
5739                 fput(newfile);
5740                 put_unused_fd(retval);
5741                 return -EFAULT;
5742         }
5743         fd_install(retval, newfile);
5744 out:
5745         return retval;
5746 }
5747
5748 static int sctp_getsockopt_peeloff_flags(struct sock *sk, int len,
5749                                          char __user *optval, int __user *optlen)
5750 {
5751         sctp_peeloff_flags_arg_t peeloff;
5752         struct file *newfile = NULL;
5753         int retval = 0;
5754
5755         if (len < sizeof(sctp_peeloff_flags_arg_t))
5756                 return -EINVAL;
5757         len = sizeof(sctp_peeloff_flags_arg_t);
5758         if (copy_from_user(&peeloff, optval, len))
5759                 return -EFAULT;
5760
5761         retval = sctp_getsockopt_peeloff_common(sk, &peeloff.p_arg,
5762                                                 &newfile, peeloff.flags);
5763         if (retval < 0)
5764                 goto out;
5765
5766         /* Return the fd mapped to the new socket.  */
5767         if (put_user(len, optlen)) {
5768                 fput(newfile);
5769                 put_unused_fd(retval);
5770                 return -EFAULT;
5771         }
5772
5773         if (copy_to_user(optval, &peeloff, len)) {
5774                 fput(newfile);
5775                 put_unused_fd(retval);
5776                 return -EFAULT;
5777         }
5778         fd_install(retval, newfile);
5779 out:
5780         return retval;
5781 }
5782
5783 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5784  *
5785  * Applications can enable or disable heartbeats for any peer address of
5786  * an association, modify an address's heartbeat interval, force a
5787  * heartbeat to be sent immediately, and adjust the address's maximum
5788  * number of retransmissions sent before an address is considered
5789  * unreachable.  The following structure is used to access and modify an
5790  * address's parameters:
5791  *
5792  *  struct sctp_paddrparams {
5793  *     sctp_assoc_t            spp_assoc_id;
5794  *     struct sockaddr_storage spp_address;
5795  *     uint32_t                spp_hbinterval;
5796  *     uint16_t                spp_pathmaxrxt;
5797  *     uint32_t                spp_pathmtu;
5798  *     uint32_t                spp_sackdelay;
5799  *     uint32_t                spp_flags;
5800  * };
5801  *
5802  *   spp_assoc_id    - (one-to-many style socket) This is filled in the
5803  *                     application, and identifies the association for
5804  *                     this query.
5805  *   spp_address     - This specifies which address is of interest.
5806  *   spp_hbinterval  - This contains the value of the heartbeat interval,
5807  *                     in milliseconds.  If a  value of zero
5808  *                     is present in this field then no changes are to
5809  *                     be made to this parameter.
5810  *   spp_pathmaxrxt  - This contains the maximum number of
5811  *                     retransmissions before this address shall be
5812  *                     considered unreachable. If a  value of zero
5813  *                     is present in this field then no changes are to
5814  *                     be made to this parameter.
5815  *   spp_pathmtu     - When Path MTU discovery is disabled the value
5816  *                     specified here will be the "fixed" path mtu.
5817  *                     Note that if the spp_address field is empty
5818  *                     then all associations on this address will
5819  *                     have this fixed path mtu set upon them.
5820  *
5821  *   spp_sackdelay   - When delayed sack is enabled, this value specifies
5822  *                     the number of milliseconds that sacks will be delayed
5823  *                     for. This value will apply to all addresses of an
5824  *                     association if the spp_address field is empty. Note
5825  *                     also, that if delayed sack is enabled and this
5826  *                     value is set to 0, no change is made to the last
5827  *                     recorded delayed sack timer value.
5828  *
5829  *   spp_flags       - These flags are used to control various features
5830  *                     on an association. The flag field may contain
5831  *                     zero or more of the following options.
5832  *
5833  *                     SPP_HB_ENABLE  - Enable heartbeats on the
5834  *                     specified address. Note that if the address
5835  *                     field is empty all addresses for the association
5836  *                     have heartbeats enabled upon them.
5837  *
5838  *                     SPP_HB_DISABLE - Disable heartbeats on the
5839  *                     speicifed address. Note that if the address
5840  *                     field is empty all addresses for the association
5841  *                     will have their heartbeats disabled. Note also
5842  *                     that SPP_HB_ENABLE and SPP_HB_DISABLE are
5843  *                     mutually exclusive, only one of these two should
5844  *                     be specified. Enabling both fields will have
5845  *                     undetermined results.
5846  *
5847  *                     SPP_HB_DEMAND - Request a user initiated heartbeat
5848  *                     to be made immediately.
5849  *
5850  *                     SPP_PMTUD_ENABLE - This field will enable 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.
5854  *
5855  *                     SPP_PMTUD_DISABLE - This field will disable PMTU
5856  *                     discovery upon the specified address. Note that
5857  *                     if the address feild is empty then all addresses
5858  *                     on the association are effected. Not also that
5859  *                     SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5860  *                     exclusive. Enabling both will have undetermined
5861  *                     results.
5862  *
5863  *                     SPP_SACKDELAY_ENABLE - Setting this flag turns
5864  *                     on delayed sack. The time specified in spp_sackdelay
5865  *                     is used to specify the sack delay for this address. Note
5866  *                     that if spp_address is empty then all addresses will
5867  *                     enable delayed sack and take on the sack delay
5868  *                     value specified in spp_sackdelay.
5869  *                     SPP_SACKDELAY_DISABLE - Setting this flag turns
5870  *                     off delayed sack. If the spp_address field is blank then
5871  *                     delayed sack is disabled for the entire association. Note
5872  *                     also that this field is mutually exclusive to
5873  *                     SPP_SACKDELAY_ENABLE, setting both will have undefined
5874  *                     results.
5875  *
5876  *                     SPP_IPV6_FLOWLABEL:  Setting this flag enables the
5877  *                     setting of the IPV6 flow label value.  The value is
5878  *                     contained in the spp_ipv6_flowlabel field.
5879  *                     Upon retrieval, this flag will be set to indicate that
5880  *                     the spp_ipv6_flowlabel field has a valid value returned.
5881  *                     If a specific destination address is set (in the
5882  *                     spp_address field), then the value returned is that of
5883  *                     the address.  If just an association is specified (and
5884  *                     no address), then the association's default flow label
5885  *                     is returned.  If neither an association nor a destination
5886  *                     is specified, then the socket's default flow label is
5887  *                     returned.  For non-IPv6 sockets, this flag will be left
5888  *                     cleared.
5889  *
5890  *                     SPP_DSCP:  Setting this flag enables the setting of the
5891  *                     Differentiated Services Code Point (DSCP) value
5892  *                     associated with either the association or a specific
5893  *                     address.  The value is obtained in the spp_dscp field.
5894  *                     Upon retrieval, this flag will be set to indicate that
5895  *                     the spp_dscp field has a valid value returned.  If a
5896  *                     specific destination address is set when called (in the
5897  *                     spp_address field), then that specific destination
5898  *                     address's DSCP value is returned.  If just an association
5899  *                     is specified, then the association's default DSCP is
5900  *                     returned.  If neither an association nor a destination is
5901  *                     specified, then the socket's default DSCP is returned.
5902  *
5903  *   spp_ipv6_flowlabel
5904  *                   - This field is used in conjunction with the
5905  *                     SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
5906  *                     The 20 least significant bits are used for the flow
5907  *                     label.  This setting has precedence over any IPv6-layer
5908  *                     setting.
5909  *
5910  *   spp_dscp        - This field is used in conjunction with the SPP_DSCP flag
5911  *                     and contains the DSCP.  The 6 most significant bits are
5912  *                     used for the DSCP.  This setting has precedence over any
5913  *                     IPv4- or IPv6- layer setting.
5914  */
5915 static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
5916                                             char __user *optval, int __user *optlen)
5917 {
5918         struct sctp_paddrparams  params;
5919         struct sctp_transport   *trans = NULL;
5920         struct sctp_association *asoc = NULL;
5921         struct sctp_sock        *sp = sctp_sk(sk);
5922
5923         if (len >= sizeof(params))
5924                 len = sizeof(params);
5925         else if (len >= ALIGN(offsetof(struct sctp_paddrparams,
5926                                        spp_ipv6_flowlabel), 4))
5927                 len = ALIGN(offsetof(struct sctp_paddrparams,
5928                                      spp_ipv6_flowlabel), 4);
5929         else
5930                 return -EINVAL;
5931
5932         if (copy_from_user(&params, optval, len))
5933                 return -EFAULT;
5934
5935         /* If an address other than INADDR_ANY is specified, and
5936          * no transport is found, then the request is invalid.
5937          */
5938         if (!sctp_is_any(sk, (union sctp_addr *)&params.spp_address)) {
5939                 trans = sctp_addr_id2transport(sk, &params.spp_address,
5940                                                params.spp_assoc_id);
5941                 if (!trans) {
5942                         pr_debug("%s: failed no transport\n", __func__);
5943                         return -EINVAL;
5944                 }
5945         }
5946
5947         /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
5948          * socket is a one to many style socket, and an association
5949          * was not found, then the id was invalid.
5950          */
5951         asoc = sctp_id2assoc(sk, params.spp_assoc_id);
5952         if (!asoc && params.spp_assoc_id != SCTP_FUTURE_ASSOC &&
5953             sctp_style(sk, UDP)) {
5954                 pr_debug("%s: failed no association\n", __func__);
5955                 return -EINVAL;
5956         }
5957
5958         if (trans) {
5959                 /* Fetch transport values. */
5960                 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
5961                 params.spp_pathmtu    = trans->pathmtu;
5962                 params.spp_pathmaxrxt = trans->pathmaxrxt;
5963                 params.spp_sackdelay  = jiffies_to_msecs(trans->sackdelay);
5964
5965                 /*draft-11 doesn't say what to return in spp_flags*/
5966                 params.spp_flags      = trans->param_flags;
5967                 if (trans->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5968                         params.spp_ipv6_flowlabel = trans->flowlabel &
5969                                                     SCTP_FLOWLABEL_VAL_MASK;
5970                         params.spp_flags |= SPP_IPV6_FLOWLABEL;
5971                 }
5972                 if (trans->dscp & SCTP_DSCP_SET_MASK) {
5973                         params.spp_dscp = trans->dscp & SCTP_DSCP_VAL_MASK;
5974                         params.spp_flags |= SPP_DSCP;
5975                 }
5976         } else if (asoc) {
5977                 /* Fetch association values. */
5978                 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
5979                 params.spp_pathmtu    = asoc->pathmtu;
5980                 params.spp_pathmaxrxt = asoc->pathmaxrxt;
5981                 params.spp_sackdelay  = jiffies_to_msecs(asoc->sackdelay);
5982
5983                 /*draft-11 doesn't say what to return in spp_flags*/
5984                 params.spp_flags      = asoc->param_flags;
5985                 if (asoc->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5986                         params.spp_ipv6_flowlabel = asoc->flowlabel &
5987                                                     SCTP_FLOWLABEL_VAL_MASK;
5988                         params.spp_flags |= SPP_IPV6_FLOWLABEL;
5989                 }
5990                 if (asoc->dscp & SCTP_DSCP_SET_MASK) {
5991                         params.spp_dscp = asoc->dscp & SCTP_DSCP_VAL_MASK;
5992                         params.spp_flags |= SPP_DSCP;
5993                 }
5994         } else {
5995                 /* Fetch socket values. */
5996                 params.spp_hbinterval = sp->hbinterval;
5997                 params.spp_pathmtu    = sp->pathmtu;
5998                 params.spp_sackdelay  = sp->sackdelay;
5999                 params.spp_pathmaxrxt = sp->pathmaxrxt;
6000
6001                 /*draft-11 doesn't say what to return in spp_flags*/
6002                 params.spp_flags      = sp->param_flags;
6003                 if (sp->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
6004                         params.spp_ipv6_flowlabel = sp->flowlabel &
6005                                                     SCTP_FLOWLABEL_VAL_MASK;
6006                         params.spp_flags |= SPP_IPV6_FLOWLABEL;
6007                 }
6008                 if (sp->dscp & SCTP_DSCP_SET_MASK) {
6009                         params.spp_dscp = sp->dscp & SCTP_DSCP_VAL_MASK;
6010                         params.spp_flags |= SPP_DSCP;
6011                 }
6012         }
6013
6014         if (copy_to_user(optval, &params, len))
6015                 return -EFAULT;
6016
6017         if (put_user(len, optlen))
6018                 return -EFAULT;
6019
6020         return 0;
6021 }
6022
6023 /*
6024  * 7.1.23.  Get or set delayed ack timer (SCTP_DELAYED_SACK)
6025  *
6026  * This option will effect the way delayed acks are performed.  This
6027  * option allows you to get or set the delayed ack time, in
6028  * milliseconds.  It also allows changing the delayed ack frequency.
6029  * Changing the frequency to 1 disables the delayed sack algorithm.  If
6030  * the assoc_id is 0, then this sets or gets the endpoints default
6031  * values.  If the assoc_id field is non-zero, then the set or get
6032  * effects the specified association for the one to many model (the
6033  * assoc_id field is ignored by the one to one model).  Note that if
6034  * sack_delay or sack_freq are 0 when setting this option, then the
6035  * current values will remain unchanged.
6036  *
6037  * struct sctp_sack_info {
6038  *     sctp_assoc_t            sack_assoc_id;
6039  *     uint32_t                sack_delay;
6040  *     uint32_t                sack_freq;
6041  * };
6042  *
6043  * sack_assoc_id -  This parameter, indicates which association the user
6044  *    is performing an action upon.  Note that if this field's value is
6045  *    zero then the endpoints default value is changed (effecting future
6046  *    associations only).
6047  *
6048  * sack_delay -  This parameter contains the number of milliseconds that
6049  *    the user is requesting the delayed ACK timer be set to.  Note that
6050  *    this value is defined in the standard to be between 200 and 500
6051  *    milliseconds.
6052  *
6053  * sack_freq -  This parameter contains the number of packets that must
6054  *    be received before a sack is sent without waiting for the delay
6055  *    timer to expire.  The default value for this is 2, setting this
6056  *    value to 1 will disable the delayed sack algorithm.
6057  */
6058 static int sctp_getsockopt_delayed_ack(struct sock *sk, int len,
6059                                             char __user *optval,
6060                                             int __user *optlen)
6061 {
6062         struct sctp_sack_info    params;
6063         struct sctp_association *asoc = NULL;
6064         struct sctp_sock        *sp = sctp_sk(sk);
6065
6066         if (len >= sizeof(struct sctp_sack_info)) {
6067                 len = sizeof(struct sctp_sack_info);
6068
6069                 if (copy_from_user(&params, optval, len))
6070                         return -EFAULT;
6071         } else if (len == sizeof(struct sctp_assoc_value)) {
6072                 pr_warn_ratelimited(DEPRECATED
6073                                     "%s (pid %d) "
6074                                     "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
6075                                     "Use struct sctp_sack_info instead\n",
6076                                     current->comm, task_pid_nr(current));
6077                 if (copy_from_user(&params, optval, len))
6078                         return -EFAULT;
6079         } else
6080                 return -EINVAL;
6081
6082         /* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
6083          * socket is a one to many style socket, and an association
6084          * was not found, then the id was invalid.
6085          */
6086         asoc = sctp_id2assoc(sk, params.sack_assoc_id);
6087         if (!asoc && params.sack_assoc_id != SCTP_FUTURE_ASSOC &&
6088             sctp_style(sk, UDP))
6089                 return -EINVAL;
6090
6091         if (asoc) {
6092                 /* Fetch association values. */
6093                 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
6094                         params.sack_delay = jiffies_to_msecs(asoc->sackdelay);
6095                         params.sack_freq = asoc->sackfreq;
6096
6097                 } else {
6098                         params.sack_delay = 0;
6099                         params.sack_freq = 1;
6100                 }
6101         } else {
6102                 /* Fetch socket values. */
6103                 if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
6104                         params.sack_delay  = sp->sackdelay;
6105                         params.sack_freq = sp->sackfreq;
6106                 } else {
6107                         params.sack_delay  = 0;
6108                         params.sack_freq = 1;
6109                 }
6110         }
6111
6112         if (copy_to_user(optval, &params, len))
6113                 return -EFAULT;
6114
6115         if (put_user(len, optlen))
6116                 return -EFAULT;
6117
6118         return 0;
6119 }
6120
6121 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
6122  *
6123  * Applications can specify protocol parameters for the default association
6124  * initialization.  The option name argument to setsockopt() and getsockopt()
6125  * is SCTP_INITMSG.
6126  *
6127  * Setting initialization parameters is effective only on an unconnected
6128  * socket (for UDP-style sockets only future associations are effected
6129  * by the change).  With TCP-style sockets, this option is inherited by
6130  * sockets derived from a listener socket.
6131  */
6132 static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
6133 {
6134         if (len < sizeof(struct sctp_initmsg))
6135                 return -EINVAL;
6136         len = sizeof(struct sctp_initmsg);
6137         if (put_user(len, optlen))
6138                 return -EFAULT;
6139         if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
6140                 return -EFAULT;
6141         return 0;
6142 }
6143
6144
6145 static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
6146                                       char __user *optval, int __user *optlen)
6147 {
6148         struct sctp_association *asoc;
6149         int cnt = 0;
6150         struct sctp_getaddrs getaddrs;
6151         struct sctp_transport *from;
6152         void __user *to;
6153         union sctp_addr temp;
6154         struct sctp_sock *sp = sctp_sk(sk);
6155         int addrlen;
6156         size_t space_left;
6157         int bytes_copied;
6158
6159         if (len < sizeof(struct sctp_getaddrs))
6160                 return -EINVAL;
6161
6162         if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6163                 return -EFAULT;
6164
6165         /* For UDP-style sockets, id specifies the association to query.  */
6166         asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6167         if (!asoc)
6168                 return -EINVAL;
6169
6170         to = optval + offsetof(struct sctp_getaddrs, addrs);
6171         space_left = len - offsetof(struct sctp_getaddrs, addrs);
6172
6173         list_for_each_entry(from, &asoc->peer.transport_addr_list,
6174                                 transports) {
6175                 memcpy(&temp, &from->ipaddr, sizeof(temp));
6176                 addrlen = sctp_get_pf_specific(sk->sk_family)
6177                               ->addr_to_user(sp, &temp);
6178                 if (space_left < addrlen)
6179                         return -ENOMEM;
6180                 if (copy_to_user(to, &temp, addrlen))
6181                         return -EFAULT;
6182                 to += addrlen;
6183                 cnt++;
6184                 space_left -= addrlen;
6185         }
6186
6187         if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
6188                 return -EFAULT;
6189         bytes_copied = ((char __user *)to) - optval;
6190         if (put_user(bytes_copied, optlen))
6191                 return -EFAULT;
6192
6193         return 0;
6194 }
6195
6196 static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
6197                             size_t space_left, int *bytes_copied)
6198 {
6199         struct sctp_sockaddr_entry *addr;
6200         union sctp_addr temp;
6201         int cnt = 0;
6202         int addrlen;
6203         struct net *net = sock_net(sk);
6204
6205         rcu_read_lock();
6206         list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
6207                 if (!addr->valid)
6208                         continue;
6209
6210                 if ((PF_INET == sk->sk_family) &&
6211                     (AF_INET6 == addr->a.sa.sa_family))
6212                         continue;
6213                 if ((PF_INET6 == sk->sk_family) &&
6214                     inet_v6_ipv6only(sk) &&
6215                     (AF_INET == addr->a.sa.sa_family))
6216                         continue;
6217                 memcpy(&temp, &addr->a, sizeof(temp));
6218                 if (!temp.v4.sin_port)
6219                         temp.v4.sin_port = htons(port);
6220
6221                 addrlen = sctp_get_pf_specific(sk->sk_family)
6222                               ->addr_to_user(sctp_sk(sk), &temp);
6223
6224                 if (space_left < addrlen) {
6225                         cnt =  -ENOMEM;
6226                         break;
6227                 }
6228                 memcpy(to, &temp, addrlen);
6229
6230                 to += addrlen;
6231                 cnt++;
6232                 space_left -= addrlen;
6233                 *bytes_copied += addrlen;
6234         }
6235         rcu_read_unlock();
6236
6237         return cnt;
6238 }
6239
6240
6241 static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
6242                                        char __user *optval, int __user *optlen)
6243 {
6244         struct sctp_bind_addr *bp;
6245         struct sctp_association *asoc;
6246         int cnt = 0;
6247         struct sctp_getaddrs getaddrs;
6248         struct sctp_sockaddr_entry *addr;
6249         void __user *to;
6250         union sctp_addr temp;
6251         struct sctp_sock *sp = sctp_sk(sk);
6252         int addrlen;
6253         int err = 0;
6254         size_t space_left;
6255         int bytes_copied = 0;
6256         void *addrs;
6257         void *buf;
6258
6259         if (len < sizeof(struct sctp_getaddrs))
6260                 return -EINVAL;
6261
6262         if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6263                 return -EFAULT;
6264
6265         /*
6266          *  For UDP-style sockets, id specifies the association to query.
6267          *  If the id field is set to the value '0' then the locally bound
6268          *  addresses are returned without regard to any particular
6269          *  association.
6270          */
6271         if (0 == getaddrs.assoc_id) {
6272                 bp = &sctp_sk(sk)->ep->base.bind_addr;
6273         } else {
6274                 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6275                 if (!asoc)
6276                         return -EINVAL;
6277                 bp = &asoc->base.bind_addr;
6278         }
6279
6280         to = optval + offsetof(struct sctp_getaddrs, addrs);
6281         space_left = len - offsetof(struct sctp_getaddrs, addrs);
6282
6283         addrs = kmalloc(space_left, GFP_USER | __GFP_NOWARN);
6284         if (!addrs)
6285                 return -ENOMEM;
6286
6287         /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
6288          * addresses from the global local address list.
6289          */
6290         if (sctp_list_single_entry(&bp->address_list)) {
6291                 addr = list_entry(bp->address_list.next,
6292                                   struct sctp_sockaddr_entry, list);
6293                 if (sctp_is_any(sk, &addr->a)) {
6294                         cnt = sctp_copy_laddrs(sk, bp->port, addrs,
6295                                                 space_left, &bytes_copied);
6296                         if (cnt < 0) {
6297                                 err = cnt;
6298                                 goto out;
6299                         }
6300                         goto copy_getaddrs;
6301                 }
6302         }
6303
6304         buf = addrs;
6305         /* Protection on the bound address list is not needed since
6306          * in the socket option context we hold a socket lock and
6307          * thus the bound address list can't change.
6308          */
6309         list_for_each_entry(addr, &bp->address_list, list) {
6310                 memcpy(&temp, &addr->a, sizeof(temp));
6311                 addrlen = sctp_get_pf_specific(sk->sk_family)
6312                               ->addr_to_user(sp, &temp);
6313                 if (space_left < addrlen) {
6314                         err =  -ENOMEM; /*fixme: right error?*/
6315                         goto out;
6316                 }
6317                 memcpy(buf, &temp, addrlen);
6318                 buf += addrlen;
6319                 bytes_copied += addrlen;
6320                 cnt++;
6321                 space_left -= addrlen;
6322         }
6323
6324 copy_getaddrs:
6325         if (copy_to_user(to, addrs, bytes_copied)) {
6326                 err = -EFAULT;
6327                 goto out;
6328         }
6329         if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
6330                 err = -EFAULT;
6331                 goto out;
6332         }
6333         /* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
6334          * but we can't change it anymore.
6335          */
6336         if (put_user(bytes_copied, optlen))
6337                 err = -EFAULT;
6338 out:
6339         kfree(addrs);
6340         return err;
6341 }
6342
6343 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
6344  *
6345  * Requests that the local SCTP stack use the enclosed peer address as
6346  * the association primary.  The enclosed address must be one of the
6347  * association peer's addresses.
6348  */
6349 static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
6350                                         char __user *optval, int __user *optlen)
6351 {
6352         struct sctp_prim prim;
6353         struct sctp_association *asoc;
6354         struct sctp_sock *sp = sctp_sk(sk);
6355
6356         if (len < sizeof(struct sctp_prim))
6357                 return -EINVAL;
6358
6359         len = sizeof(struct sctp_prim);
6360
6361         if (copy_from_user(&prim, optval, len))
6362                 return -EFAULT;
6363
6364         asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
6365         if (!asoc)
6366                 return -EINVAL;
6367
6368         if (!asoc->peer.primary_path)
6369                 return -ENOTCONN;
6370
6371         memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
6372                 asoc->peer.primary_path->af_specific->sockaddr_len);
6373
6374         sctp_get_pf_specific(sk->sk_family)->addr_to_user(sp,
6375                         (union sctp_addr *)&prim.ssp_addr);
6376
6377         if (put_user(len, optlen))
6378                 return -EFAULT;
6379         if (copy_to_user(optval, &prim, len))
6380                 return -EFAULT;
6381
6382         return 0;
6383 }
6384
6385 /*
6386  * 7.1.11  Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
6387  *
6388  * Requests that the local endpoint set the specified Adaptation Layer
6389  * Indication parameter for all future INIT and INIT-ACK exchanges.
6390  */
6391 static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len,
6392                                   char __user *optval, int __user *optlen)
6393 {
6394         struct sctp_setadaptation adaptation;
6395
6396         if (len < sizeof(struct sctp_setadaptation))
6397                 return -EINVAL;
6398
6399         len = sizeof(struct sctp_setadaptation);
6400
6401         adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
6402
6403         if (put_user(len, optlen))
6404                 return -EFAULT;
6405         if (copy_to_user(optval, &adaptation, len))
6406                 return -EFAULT;
6407
6408         return 0;
6409 }
6410
6411 /*
6412  *
6413  * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
6414  *
6415  *   Applications that wish to use the sendto() system call may wish to
6416  *   specify a default set of parameters that would normally be supplied
6417  *   through the inclusion of ancillary data.  This socket option allows
6418  *   such an application to set the default sctp_sndrcvinfo structure.
6419
6420
6421  *   The application that wishes to use this socket option simply passes
6422  *   in to this call the sctp_sndrcvinfo structure defined in Section
6423  *   5.2.2) The input parameters accepted by this call include
6424  *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
6425  *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
6426  *   to this call if the caller is using the UDP model.
6427  *
6428  *   For getsockopt, it get the default sctp_sndrcvinfo structure.
6429  */
6430 static int sctp_getsockopt_default_send_param(struct sock *sk,
6431                                         int len, char __user *optval,
6432                                         int __user *optlen)
6433 {
6434         struct sctp_sock *sp = sctp_sk(sk);
6435         struct sctp_association *asoc;
6436         struct sctp_sndrcvinfo info;
6437
6438         if (len < sizeof(info))
6439                 return -EINVAL;
6440
6441         len = sizeof(info);
6442
6443         if (copy_from_user(&info, optval, len))
6444                 return -EFAULT;
6445
6446         asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
6447         if (!asoc && info.sinfo_assoc_id != SCTP_FUTURE_ASSOC &&
6448             sctp_style(sk, UDP))
6449                 return -EINVAL;
6450
6451         if (asoc) {
6452                 info.sinfo_stream = asoc->default_stream;
6453                 info.sinfo_flags = asoc->default_flags;
6454                 info.sinfo_ppid = asoc->default_ppid;
6455                 info.sinfo_context = asoc->default_context;
6456                 info.sinfo_timetolive = asoc->default_timetolive;
6457         } else {
6458                 info.sinfo_stream = sp->default_stream;
6459                 info.sinfo_flags = sp->default_flags;
6460                 info.sinfo_ppid = sp->default_ppid;
6461                 info.sinfo_context = sp->default_context;
6462                 info.sinfo_timetolive = sp->default_timetolive;
6463         }
6464
6465         if (put_user(len, optlen))
6466                 return -EFAULT;
6467         if (copy_to_user(optval, &info, len))
6468                 return -EFAULT;
6469
6470         return 0;
6471 }
6472
6473 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
6474  * (SCTP_DEFAULT_SNDINFO)
6475  */
6476 static int sctp_getsockopt_default_sndinfo(struct sock *sk, int len,
6477                                            char __user *optval,
6478                                            int __user *optlen)
6479 {
6480         struct sctp_sock *sp = sctp_sk(sk);
6481         struct sctp_association *asoc;
6482         struct sctp_sndinfo info;
6483
6484         if (len < sizeof(info))
6485                 return -EINVAL;
6486
6487         len = sizeof(info);
6488
6489         if (copy_from_user(&info, optval, len))
6490                 return -EFAULT;
6491
6492         asoc = sctp_id2assoc(sk, info.snd_assoc_id);
6493         if (!asoc && info.snd_assoc_id != SCTP_FUTURE_ASSOC &&
6494             sctp_style(sk, UDP))
6495                 return -EINVAL;
6496
6497         if (asoc) {
6498                 info.snd_sid = asoc->default_stream;
6499                 info.snd_flags = asoc->default_flags;
6500                 info.snd_ppid = asoc->default_ppid;
6501                 info.snd_context = asoc->default_context;
6502         } else {
6503                 info.snd_sid = sp->default_stream;
6504                 info.snd_flags = sp->default_flags;
6505                 info.snd_ppid = sp->default_ppid;
6506                 info.snd_context = sp->default_context;
6507         }
6508
6509         if (put_user(len, optlen))
6510                 return -EFAULT;
6511         if (copy_to_user(optval, &info, len))
6512                 return -EFAULT;
6513
6514         return 0;
6515 }
6516
6517 /*
6518  *
6519  * 7.1.5 SCTP_NODELAY
6520  *
6521  * Turn on/off any Nagle-like algorithm.  This means that packets are
6522  * generally sent as soon as possible and no unnecessary delays are
6523  * introduced, at the cost of more packets in the network.  Expects an
6524  * integer boolean flag.
6525  */
6526
6527 static int sctp_getsockopt_nodelay(struct sock *sk, int len,
6528                                    char __user *optval, int __user *optlen)
6529 {
6530         int val;
6531
6532         if (len < sizeof(int))
6533                 return -EINVAL;
6534
6535         len = sizeof(int);
6536         val = (sctp_sk(sk)->nodelay == 1);
6537         if (put_user(len, optlen))
6538                 return -EFAULT;
6539         if (copy_to_user(optval, &val, len))
6540                 return -EFAULT;
6541         return 0;
6542 }
6543
6544 /*
6545  *
6546  * 7.1.1 SCTP_RTOINFO
6547  *
6548  * The protocol parameters used to initialize and bound retransmission
6549  * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
6550  * and modify these parameters.
6551  * All parameters are time values, in milliseconds.  A value of 0, when
6552  * modifying the parameters, indicates that the current value should not
6553  * be changed.
6554  *
6555  */
6556 static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
6557                                 char __user *optval,
6558                                 int __user *optlen) {
6559         struct sctp_rtoinfo rtoinfo;
6560         struct sctp_association *asoc;
6561
6562         if (len < sizeof (struct sctp_rtoinfo))
6563                 return -EINVAL;
6564
6565         len = sizeof(struct sctp_rtoinfo);
6566
6567         if (copy_from_user(&rtoinfo, optval, len))
6568                 return -EFAULT;
6569
6570         asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
6571
6572         if (!asoc && rtoinfo.srto_assoc_id != SCTP_FUTURE_ASSOC &&
6573             sctp_style(sk, UDP))
6574                 return -EINVAL;
6575
6576         /* Values corresponding to the specific association. */
6577         if (asoc) {
6578                 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
6579                 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
6580                 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
6581         } else {
6582                 /* Values corresponding to the endpoint. */
6583                 struct sctp_sock *sp = sctp_sk(sk);
6584
6585                 rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
6586                 rtoinfo.srto_max = sp->rtoinfo.srto_max;
6587                 rtoinfo.srto_min = sp->rtoinfo.srto_min;
6588         }
6589
6590         if (put_user(len, optlen))
6591                 return -EFAULT;
6592
6593         if (copy_to_user(optval, &rtoinfo, len))
6594                 return -EFAULT;
6595
6596         return 0;
6597 }
6598
6599 /*
6600  *
6601  * 7.1.2 SCTP_ASSOCINFO
6602  *
6603  * This option is used to tune the maximum retransmission attempts
6604  * of the association.
6605  * Returns an error if the new association retransmission value is
6606  * greater than the sum of the retransmission value  of the peer.
6607  * See [SCTP] for more information.
6608  *
6609  */
6610 static int sctp_getsockopt_associnfo(struct sock *sk, int len,
6611                                      char __user *optval,
6612                                      int __user *optlen)
6613 {
6614
6615         struct sctp_assocparams assocparams;
6616         struct sctp_association *asoc;
6617         struct list_head *pos;
6618         int cnt = 0;
6619
6620         if (len < sizeof (struct sctp_assocparams))
6621                 return -EINVAL;
6622
6623         len = sizeof(struct sctp_assocparams);
6624
6625         if (copy_from_user(&assocparams, optval, len))
6626                 return -EFAULT;
6627
6628         asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
6629
6630         if (!asoc && assocparams.sasoc_assoc_id != SCTP_FUTURE_ASSOC &&
6631             sctp_style(sk, UDP))
6632                 return -EINVAL;
6633
6634         /* Values correspoinding to the specific association */
6635         if (asoc) {
6636                 assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
6637                 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
6638                 assocparams.sasoc_local_rwnd = asoc->a_rwnd;
6639                 assocparams.sasoc_cookie_life = ktime_to_ms(asoc->cookie_life);
6640
6641                 list_for_each(pos, &asoc->peer.transport_addr_list) {
6642                         cnt++;
6643                 }
6644
6645                 assocparams.sasoc_number_peer_destinations = cnt;
6646         } else {
6647                 /* Values corresponding to the endpoint */
6648                 struct sctp_sock *sp = sctp_sk(sk);
6649
6650                 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
6651                 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
6652                 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
6653                 assocparams.sasoc_cookie_life =
6654                                         sp->assocparams.sasoc_cookie_life;
6655                 assocparams.sasoc_number_peer_destinations =
6656                                         sp->assocparams.
6657                                         sasoc_number_peer_destinations;
6658         }
6659
6660         if (put_user(len, optlen))
6661                 return -EFAULT;
6662
6663         if (copy_to_user(optval, &assocparams, len))
6664                 return -EFAULT;
6665
6666         return 0;
6667 }
6668
6669 /*
6670  * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
6671  *
6672  * This socket option is a boolean flag which turns on or off mapped V4
6673  * addresses.  If this option is turned on and the socket is type
6674  * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
6675  * If this option is turned off, then no mapping will be done of V4
6676  * addresses and a user will receive both PF_INET6 and PF_INET type
6677  * addresses on the socket.
6678  */
6679 static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
6680                                     char __user *optval, int __user *optlen)
6681 {
6682         int val;
6683         struct sctp_sock *sp = sctp_sk(sk);
6684
6685         if (len < sizeof(int))
6686                 return -EINVAL;
6687
6688         len = sizeof(int);
6689         val = sp->v4mapped;
6690         if (put_user(len, optlen))
6691                 return -EFAULT;
6692         if (copy_to_user(optval, &val, len))
6693                 return -EFAULT;
6694
6695         return 0;
6696 }
6697
6698 /*
6699  * 7.1.29.  Set or Get the default context (SCTP_CONTEXT)
6700  * (chapter and verse is quoted at sctp_setsockopt_context())
6701  */
6702 static int sctp_getsockopt_context(struct sock *sk, int len,
6703                                    char __user *optval, int __user *optlen)
6704 {
6705         struct sctp_assoc_value params;
6706         struct sctp_association *asoc;
6707
6708         if (len < sizeof(struct sctp_assoc_value))
6709                 return -EINVAL;
6710
6711         len = sizeof(struct sctp_assoc_value);
6712
6713         if (copy_from_user(&params, optval, len))
6714                 return -EFAULT;
6715
6716         asoc = sctp_id2assoc(sk, params.assoc_id);
6717         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6718             sctp_style(sk, UDP))
6719                 return -EINVAL;
6720
6721         params.assoc_value = asoc ? asoc->default_rcv_context
6722                                   : sctp_sk(sk)->default_rcv_context;
6723
6724         if (put_user(len, optlen))
6725                 return -EFAULT;
6726         if (copy_to_user(optval, &params, len))
6727                 return -EFAULT;
6728
6729         return 0;
6730 }
6731
6732 /*
6733  * 8.1.16.  Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6734  * This option will get or set the maximum size to put in any outgoing
6735  * SCTP DATA chunk.  If a message is larger than this size it will be
6736  * fragmented by SCTP into the specified size.  Note that the underlying
6737  * SCTP implementation may fragment into smaller sized chunks when the
6738  * PMTU of the underlying association is smaller than the value set by
6739  * the user.  The default value for this option is '0' which indicates
6740  * the user is NOT limiting fragmentation and only the PMTU will effect
6741  * SCTP's choice of DATA chunk size.  Note also that values set larger
6742  * than the maximum size of an IP datagram will effectively let SCTP
6743  * control fragmentation (i.e. the same as setting this option to 0).
6744  *
6745  * The following structure is used to access and modify this parameter:
6746  *
6747  * struct sctp_assoc_value {
6748  *   sctp_assoc_t assoc_id;
6749  *   uint32_t assoc_value;
6750  * };
6751  *
6752  * assoc_id:  This parameter is ignored for one-to-one style sockets.
6753  *    For one-to-many style sockets this parameter indicates which
6754  *    association the user is performing an action upon.  Note that if
6755  *    this field's value is zero then the endpoints default value is
6756  *    changed (effecting future associations only).
6757  * assoc_value:  This parameter specifies the maximum size in bytes.
6758  */
6759 static int sctp_getsockopt_maxseg(struct sock *sk, int len,
6760                                   char __user *optval, int __user *optlen)
6761 {
6762         struct sctp_assoc_value params;
6763         struct sctp_association *asoc;
6764
6765         if (len == sizeof(int)) {
6766                 pr_warn_ratelimited(DEPRECATED
6767                                     "%s (pid %d) "
6768                                     "Use of int in maxseg socket option.\n"
6769                                     "Use struct sctp_assoc_value instead\n",
6770                                     current->comm, task_pid_nr(current));
6771                 params.assoc_id = SCTP_FUTURE_ASSOC;
6772         } else if (len >= sizeof(struct sctp_assoc_value)) {
6773                 len = sizeof(struct sctp_assoc_value);
6774                 if (copy_from_user(&params, optval, len))
6775                         return -EFAULT;
6776         } else
6777                 return -EINVAL;
6778
6779         asoc = sctp_id2assoc(sk, params.assoc_id);
6780         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6781             sctp_style(sk, UDP))
6782                 return -EINVAL;
6783
6784         if (asoc)
6785                 params.assoc_value = asoc->frag_point;
6786         else
6787                 params.assoc_value = sctp_sk(sk)->user_frag;
6788
6789         if (put_user(len, optlen))
6790                 return -EFAULT;
6791         if (len == sizeof(int)) {
6792                 if (copy_to_user(optval, &params.assoc_value, len))
6793                         return -EFAULT;
6794         } else {
6795                 if (copy_to_user(optval, &params, len))
6796                         return -EFAULT;
6797         }
6798
6799         return 0;
6800 }
6801
6802 /*
6803  * 7.1.24.  Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6804  * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6805  */
6806 static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
6807                                                char __user *optval, int __user *optlen)
6808 {
6809         int val;
6810
6811         if (len < sizeof(int))
6812                 return -EINVAL;
6813
6814         len = sizeof(int);
6815
6816         val = sctp_sk(sk)->frag_interleave;
6817         if (put_user(len, optlen))
6818                 return -EFAULT;
6819         if (copy_to_user(optval, &val, len))
6820                 return -EFAULT;
6821
6822         return 0;
6823 }
6824
6825 /*
6826  * 7.1.25.  Set or Get the sctp partial delivery point
6827  * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6828  */
6829 static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
6830                                                   char __user *optval,
6831                                                   int __user *optlen)
6832 {
6833         u32 val;
6834
6835         if (len < sizeof(u32))
6836                 return -EINVAL;
6837
6838         len = sizeof(u32);
6839
6840         val = sctp_sk(sk)->pd_point;
6841         if (put_user(len, optlen))
6842                 return -EFAULT;
6843         if (copy_to_user(optval, &val, len))
6844                 return -EFAULT;
6845
6846         return 0;
6847 }
6848
6849 /*
6850  * 7.1.28.  Set or Get the maximum burst (SCTP_MAX_BURST)
6851  * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6852  */
6853 static int sctp_getsockopt_maxburst(struct sock *sk, int len,
6854                                     char __user *optval,
6855                                     int __user *optlen)
6856 {
6857         struct sctp_assoc_value params;
6858         struct sctp_association *asoc;
6859
6860         if (len == sizeof(int)) {
6861                 pr_warn_ratelimited(DEPRECATED
6862                                     "%s (pid %d) "
6863                                     "Use of int in max_burst socket option.\n"
6864                                     "Use struct sctp_assoc_value instead\n",
6865                                     current->comm, task_pid_nr(current));
6866                 params.assoc_id = SCTP_FUTURE_ASSOC;
6867         } else if (len >= sizeof(struct sctp_assoc_value)) {
6868                 len = sizeof(struct sctp_assoc_value);
6869                 if (copy_from_user(&params, optval, len))
6870                         return -EFAULT;
6871         } else
6872                 return -EINVAL;
6873
6874         asoc = sctp_id2assoc(sk, params.assoc_id);
6875         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6876             sctp_style(sk, UDP))
6877                 return -EINVAL;
6878
6879         params.assoc_value = asoc ? asoc->max_burst : sctp_sk(sk)->max_burst;
6880
6881         if (len == sizeof(int)) {
6882                 if (copy_to_user(optval, &params.assoc_value, len))
6883                         return -EFAULT;
6884         } else {
6885                 if (copy_to_user(optval, &params, len))
6886                         return -EFAULT;
6887         }
6888
6889         return 0;
6890
6891 }
6892
6893 static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
6894                                     char __user *optval, int __user *optlen)
6895 {
6896         struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6897         struct sctp_hmacalgo  __user *p = (void __user *)optval;
6898         struct sctp_hmac_algo_param *hmacs;
6899         __u16 data_len = 0;
6900         u32 num_idents;
6901         int i;
6902
6903         if (!ep->auth_enable)
6904                 return -EACCES;
6905
6906         hmacs = ep->auth_hmacs_list;
6907         data_len = ntohs(hmacs->param_hdr.length) -
6908                    sizeof(struct sctp_paramhdr);
6909
6910         if (len < sizeof(struct sctp_hmacalgo) + data_len)
6911                 return -EINVAL;
6912
6913         len = sizeof(struct sctp_hmacalgo) + data_len;
6914         num_idents = data_len / sizeof(u16);
6915
6916         if (put_user(len, optlen))
6917                 return -EFAULT;
6918         if (put_user(num_idents, &p->shmac_num_idents))
6919                 return -EFAULT;
6920         for (i = 0; i < num_idents; i++) {
6921                 __u16 hmacid = ntohs(hmacs->hmac_ids[i]);
6922
6923                 if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
6924                         return -EFAULT;
6925         }
6926         return 0;
6927 }
6928
6929 static int sctp_getsockopt_active_key(struct sock *sk, int len,
6930                                     char __user *optval, int __user *optlen)
6931 {
6932         struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6933         struct sctp_authkeyid val;
6934         struct sctp_association *asoc;
6935
6936         if (len < sizeof(struct sctp_authkeyid))
6937                 return -EINVAL;
6938
6939         len = sizeof(struct sctp_authkeyid);
6940         if (copy_from_user(&val, optval, len))
6941                 return -EFAULT;
6942
6943         asoc = sctp_id2assoc(sk, val.scact_assoc_id);
6944         if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
6945                 return -EINVAL;
6946
6947         if (asoc) {
6948                 if (!asoc->peer.auth_capable)
6949                         return -EACCES;
6950                 val.scact_keynumber = asoc->active_key_id;
6951         } else {
6952                 if (!ep->auth_enable)
6953                         return -EACCES;
6954                 val.scact_keynumber = ep->active_key_id;
6955         }
6956
6957         if (put_user(len, optlen))
6958                 return -EFAULT;
6959         if (copy_to_user(optval, &val, len))
6960                 return -EFAULT;
6961
6962         return 0;
6963 }
6964
6965 static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
6966                                     char __user *optval, int __user *optlen)
6967 {
6968         struct sctp_authchunks __user *p = (void __user *)optval;
6969         struct sctp_authchunks val;
6970         struct sctp_association *asoc;
6971         struct sctp_chunks_param *ch;
6972         u32    num_chunks = 0;
6973         char __user *to;
6974
6975         if (len < sizeof(struct sctp_authchunks))
6976                 return -EINVAL;
6977
6978         if (copy_from_user(&val, optval, sizeof(val)))
6979                 return -EFAULT;
6980
6981         to = p->gauth_chunks;
6982         asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
6983         if (!asoc)
6984                 return -EINVAL;
6985
6986         if (!asoc->peer.auth_capable)
6987                 return -EACCES;
6988
6989         ch = asoc->peer.peer_chunks;
6990         if (!ch)
6991                 goto num;
6992
6993         /* See if the user provided enough room for all the data */
6994         num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
6995         if (len < num_chunks)
6996                 return -EINVAL;
6997
6998         if (copy_to_user(to, ch->chunks, num_chunks))
6999                 return -EFAULT;
7000 num:
7001         len = sizeof(struct sctp_authchunks) + num_chunks;
7002         if (put_user(len, optlen))
7003                 return -EFAULT;
7004         if (put_user(num_chunks, &p->gauth_number_of_chunks))
7005                 return -EFAULT;
7006         return 0;
7007 }
7008
7009 static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
7010                                     char __user *optval, int __user *optlen)
7011 {
7012         struct sctp_endpoint *ep = sctp_sk(sk)->ep;
7013         struct sctp_authchunks __user *p = (void __user *)optval;
7014         struct sctp_authchunks val;
7015         struct sctp_association *asoc;
7016         struct sctp_chunks_param *ch;
7017         u32    num_chunks = 0;
7018         char __user *to;
7019
7020         if (len < sizeof(struct sctp_authchunks))
7021                 return -EINVAL;
7022
7023         if (copy_from_user(&val, optval, sizeof(val)))
7024                 return -EFAULT;
7025
7026         to = p->gauth_chunks;
7027         asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
7028         if (!asoc && val.gauth_assoc_id != SCTP_FUTURE_ASSOC &&
7029             sctp_style(sk, UDP))
7030                 return -EINVAL;
7031
7032         if (asoc) {
7033                 if (!asoc->peer.auth_capable)
7034                         return -EACCES;
7035                 ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
7036         } else {
7037                 if (!ep->auth_enable)
7038                         return -EACCES;
7039                 ch = ep->auth_chunk_list;
7040         }
7041         if (!ch)
7042                 goto num;
7043
7044         num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
7045         if (len < sizeof(struct sctp_authchunks) + num_chunks)
7046                 return -EINVAL;
7047
7048         if (copy_to_user(to, ch->chunks, num_chunks))
7049                 return -EFAULT;
7050 num:
7051         len = sizeof(struct sctp_authchunks) + num_chunks;
7052         if (put_user(len, optlen))
7053                 return -EFAULT;
7054         if (put_user(num_chunks, &p->gauth_number_of_chunks))
7055                 return -EFAULT;
7056
7057         return 0;
7058 }
7059
7060 /*
7061  * 8.2.5.  Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
7062  * This option gets the current number of associations that are attached
7063  * to a one-to-many style socket.  The option value is an uint32_t.
7064  */
7065 static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
7066                                     char __user *optval, int __user *optlen)
7067 {
7068         struct sctp_sock *sp = sctp_sk(sk);
7069         struct sctp_association *asoc;
7070         u32 val = 0;
7071
7072         if (sctp_style(sk, TCP))
7073                 return -EOPNOTSUPP;
7074
7075         if (len < sizeof(u32))
7076                 return -EINVAL;
7077
7078         len = sizeof(u32);
7079
7080         list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7081                 val++;
7082         }
7083
7084         if (put_user(len, optlen))
7085                 return -EFAULT;
7086         if (copy_to_user(optval, &val, len))
7087                 return -EFAULT;
7088
7089         return 0;
7090 }
7091
7092 /*
7093  * 8.1.23 SCTP_AUTO_ASCONF
7094  * See the corresponding setsockopt entry as description
7095  */
7096 static int sctp_getsockopt_auto_asconf(struct sock *sk, int len,
7097                                    char __user *optval, int __user *optlen)
7098 {
7099         int val = 0;
7100
7101         if (len < sizeof(int))
7102                 return -EINVAL;
7103
7104         len = sizeof(int);
7105         if (sctp_sk(sk)->do_auto_asconf && sctp_is_ep_boundall(sk))
7106                 val = 1;
7107         if (put_user(len, optlen))
7108                 return -EFAULT;
7109         if (copy_to_user(optval, &val, len))
7110                 return -EFAULT;
7111         return 0;
7112 }
7113
7114 /*
7115  * 8.2.6. Get the Current Identifiers of Associations
7116  *        (SCTP_GET_ASSOC_ID_LIST)
7117  *
7118  * This option gets the current list of SCTP association identifiers of
7119  * the SCTP associations handled by a one-to-many style socket.
7120  */
7121 static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
7122                                     char __user *optval, int __user *optlen)
7123 {
7124         struct sctp_sock *sp = sctp_sk(sk);
7125         struct sctp_association *asoc;
7126         struct sctp_assoc_ids *ids;
7127         size_t ids_size;
7128         u32 num = 0;
7129
7130         if (sctp_style(sk, TCP))
7131                 return -EOPNOTSUPP;
7132
7133         if (len < sizeof(struct sctp_assoc_ids))
7134                 return -EINVAL;
7135
7136         list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7137                 num++;
7138         }
7139
7140         ids_size = struct_size(ids, gaids_assoc_id, num);
7141         if (len < ids_size)
7142                 return -EINVAL;
7143
7144         len = ids_size;
7145         ids = kmalloc(len, GFP_USER | __GFP_NOWARN);
7146         if (unlikely(!ids))
7147                 return -ENOMEM;
7148
7149         ids->gaids_number_of_ids = num;
7150         num = 0;
7151         list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7152                 ids->gaids_assoc_id[num++] = asoc->assoc_id;
7153         }
7154
7155         if (put_user(len, optlen) || copy_to_user(optval, ids, len)) {
7156                 kfree(ids);
7157                 return -EFAULT;
7158         }
7159
7160         kfree(ids);
7161         return 0;
7162 }
7163
7164 /*
7165  * SCTP_PEER_ADDR_THLDS
7166  *
7167  * This option allows us to fetch the partially failed threshold for one or all
7168  * transports in an association.  See Section 6.1 of:
7169  * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
7170  */
7171 static int sctp_getsockopt_paddr_thresholds(struct sock *sk,
7172                                             char __user *optval, int len,
7173                                             int __user *optlen, bool v2)
7174 {
7175         struct sctp_paddrthlds_v2 val;
7176         struct sctp_transport *trans;
7177         struct sctp_association *asoc;
7178         int min;
7179
7180         min = v2 ? sizeof(val) : sizeof(struct sctp_paddrthlds);
7181         if (len < min)
7182                 return -EINVAL;
7183         len = min;
7184         if (copy_from_user(&val, optval, len))
7185                 return -EFAULT;
7186
7187         if (!sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
7188                 trans = sctp_addr_id2transport(sk, &val.spt_address,
7189                                                val.spt_assoc_id);
7190                 if (!trans)
7191                         return -ENOENT;
7192
7193                 val.spt_pathmaxrxt = trans->pathmaxrxt;
7194                 val.spt_pathpfthld = trans->pf_retrans;
7195                 val.spt_pathcpthld = trans->ps_retrans;
7196
7197                 goto out;
7198         }
7199
7200         asoc = sctp_id2assoc(sk, val.spt_assoc_id);
7201         if (!asoc && val.spt_assoc_id != SCTP_FUTURE_ASSOC &&
7202             sctp_style(sk, UDP))
7203                 return -EINVAL;
7204
7205         if (asoc) {
7206                 val.spt_pathpfthld = asoc->pf_retrans;
7207                 val.spt_pathmaxrxt = asoc->pathmaxrxt;
7208                 val.spt_pathcpthld = asoc->ps_retrans;
7209         } else {
7210                 struct sctp_sock *sp = sctp_sk(sk);
7211
7212                 val.spt_pathpfthld = sp->pf_retrans;
7213                 val.spt_pathmaxrxt = sp->pathmaxrxt;
7214                 val.spt_pathcpthld = sp->ps_retrans;
7215         }
7216
7217 out:
7218         if (put_user(len, optlen) || copy_to_user(optval, &val, len))
7219                 return -EFAULT;
7220
7221         return 0;
7222 }
7223
7224 /*
7225  * SCTP_GET_ASSOC_STATS
7226  *
7227  * This option retrieves local per endpoint statistics. It is modeled
7228  * after OpenSolaris' implementation
7229  */
7230 static int sctp_getsockopt_assoc_stats(struct sock *sk, int len,
7231                                        char __user *optval,
7232                                        int __user *optlen)
7233 {
7234         struct sctp_assoc_stats sas;
7235         struct sctp_association *asoc = NULL;
7236
7237         /* User must provide at least the assoc id */
7238         if (len < sizeof(sctp_assoc_t))
7239                 return -EINVAL;
7240
7241         /* Allow the struct to grow and fill in as much as possible */
7242         len = min_t(size_t, len, sizeof(sas));
7243
7244         if (copy_from_user(&sas, optval, len))
7245                 return -EFAULT;
7246
7247         asoc = sctp_id2assoc(sk, sas.sas_assoc_id);
7248         if (!asoc)
7249                 return -EINVAL;
7250
7251         sas.sas_rtxchunks = asoc->stats.rtxchunks;
7252         sas.sas_gapcnt = asoc->stats.gapcnt;
7253         sas.sas_outofseqtsns = asoc->stats.outofseqtsns;
7254         sas.sas_osacks = asoc->stats.osacks;
7255         sas.sas_isacks = asoc->stats.isacks;
7256         sas.sas_octrlchunks = asoc->stats.octrlchunks;
7257         sas.sas_ictrlchunks = asoc->stats.ictrlchunks;
7258         sas.sas_oodchunks = asoc->stats.oodchunks;
7259         sas.sas_iodchunks = asoc->stats.iodchunks;
7260         sas.sas_ouodchunks = asoc->stats.ouodchunks;
7261         sas.sas_iuodchunks = asoc->stats.iuodchunks;
7262         sas.sas_idupchunks = asoc->stats.idupchunks;
7263         sas.sas_opackets = asoc->stats.opackets;
7264         sas.sas_ipackets = asoc->stats.ipackets;
7265
7266         /* New high max rto observed, will return 0 if not a single
7267          * RTO update took place. obs_rto_ipaddr will be bogus
7268          * in such a case
7269          */
7270         sas.sas_maxrto = asoc->stats.max_obs_rto;
7271         memcpy(&sas.sas_obs_rto_ipaddr, &asoc->stats.obs_rto_ipaddr,
7272                 sizeof(struct sockaddr_storage));
7273
7274         /* Mark beginning of a new observation period */
7275         asoc->stats.max_obs_rto = asoc->rto_min;
7276
7277         if (put_user(len, optlen))
7278                 return -EFAULT;
7279
7280         pr_debug("%s: len:%d, assoc_id:%d\n", __func__, len, sas.sas_assoc_id);
7281
7282         if (copy_to_user(optval, &sas, len))
7283                 return -EFAULT;
7284
7285         return 0;
7286 }
7287
7288 static int sctp_getsockopt_recvrcvinfo(struct sock *sk, int len,
7289                                        char __user *optval,
7290                                        int __user *optlen)
7291 {
7292         int val = 0;
7293
7294         if (len < sizeof(int))
7295                 return -EINVAL;
7296
7297         len = sizeof(int);
7298         if (sctp_sk(sk)->recvrcvinfo)
7299                 val = 1;
7300         if (put_user(len, optlen))
7301                 return -EFAULT;
7302         if (copy_to_user(optval, &val, len))
7303                 return -EFAULT;
7304
7305         return 0;
7306 }
7307
7308 static int sctp_getsockopt_recvnxtinfo(struct sock *sk, int len,
7309                                        char __user *optval,
7310                                        int __user *optlen)
7311 {
7312         int val = 0;
7313
7314         if (len < sizeof(int))
7315                 return -EINVAL;
7316
7317         len = sizeof(int);
7318         if (sctp_sk(sk)->recvnxtinfo)
7319                 val = 1;
7320         if (put_user(len, optlen))
7321                 return -EFAULT;
7322         if (copy_to_user(optval, &val, len))
7323                 return -EFAULT;
7324
7325         return 0;
7326 }
7327
7328 static int sctp_getsockopt_pr_supported(struct sock *sk, int len,
7329                                         char __user *optval,
7330                                         int __user *optlen)
7331 {
7332         struct sctp_assoc_value params;
7333         struct sctp_association *asoc;
7334         int retval = -EFAULT;
7335
7336         if (len < sizeof(params)) {
7337                 retval = -EINVAL;
7338                 goto out;
7339         }
7340
7341         len = sizeof(params);
7342         if (copy_from_user(&params, optval, len))
7343                 goto out;
7344
7345         asoc = sctp_id2assoc(sk, params.assoc_id);
7346         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7347             sctp_style(sk, UDP)) {
7348                 retval = -EINVAL;
7349                 goto out;
7350         }
7351
7352         params.assoc_value = asoc ? asoc->peer.prsctp_capable
7353                                   : sctp_sk(sk)->ep->prsctp_enable;
7354
7355         if (put_user(len, optlen))
7356                 goto out;
7357
7358         if (copy_to_user(optval, &params, len))
7359                 goto out;
7360
7361         retval = 0;
7362
7363 out:
7364         return retval;
7365 }
7366
7367 static int sctp_getsockopt_default_prinfo(struct sock *sk, int len,
7368                                           char __user *optval,
7369                                           int __user *optlen)
7370 {
7371         struct sctp_default_prinfo info;
7372         struct sctp_association *asoc;
7373         int retval = -EFAULT;
7374
7375         if (len < sizeof(info)) {
7376                 retval = -EINVAL;
7377                 goto out;
7378         }
7379
7380         len = sizeof(info);
7381         if (copy_from_user(&info, optval, len))
7382                 goto out;
7383
7384         asoc = sctp_id2assoc(sk, info.pr_assoc_id);
7385         if (!asoc && info.pr_assoc_id != SCTP_FUTURE_ASSOC &&
7386             sctp_style(sk, UDP)) {
7387                 retval = -EINVAL;
7388                 goto out;
7389         }
7390
7391         if (asoc) {
7392                 info.pr_policy = SCTP_PR_POLICY(asoc->default_flags);
7393                 info.pr_value = asoc->default_timetolive;
7394         } else {
7395                 struct sctp_sock *sp = sctp_sk(sk);
7396
7397                 info.pr_policy = SCTP_PR_POLICY(sp->default_flags);
7398                 info.pr_value = sp->default_timetolive;
7399         }
7400
7401         if (put_user(len, optlen))
7402                 goto out;
7403
7404         if (copy_to_user(optval, &info, len))
7405                 goto out;
7406
7407         retval = 0;
7408
7409 out:
7410         return retval;
7411 }
7412
7413 static int sctp_getsockopt_pr_assocstatus(struct sock *sk, int len,
7414                                           char __user *optval,
7415                                           int __user *optlen)
7416 {
7417         struct sctp_prstatus params;
7418         struct sctp_association *asoc;
7419         int policy;
7420         int retval = -EINVAL;
7421
7422         if (len < sizeof(params))
7423                 goto out;
7424
7425         len = sizeof(params);
7426         if (copy_from_user(&params, optval, len)) {
7427                 retval = -EFAULT;
7428                 goto out;
7429         }
7430
7431         policy = params.sprstat_policy;
7432         if (!policy || (policy & ~(SCTP_PR_SCTP_MASK | SCTP_PR_SCTP_ALL)) ||
7433             ((policy & SCTP_PR_SCTP_ALL) && (policy & SCTP_PR_SCTP_MASK)))
7434                 goto out;
7435
7436         asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7437         if (!asoc)
7438                 goto out;
7439
7440         if (policy == SCTP_PR_SCTP_ALL) {
7441                 params.sprstat_abandoned_unsent = 0;
7442                 params.sprstat_abandoned_sent = 0;
7443                 for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7444                         params.sprstat_abandoned_unsent +=
7445                                 asoc->abandoned_unsent[policy];
7446                         params.sprstat_abandoned_sent +=
7447                                 asoc->abandoned_sent[policy];
7448                 }
7449         } else {
7450                 params.sprstat_abandoned_unsent =
7451                         asoc->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7452                 params.sprstat_abandoned_sent =
7453                         asoc->abandoned_sent[__SCTP_PR_INDEX(policy)];
7454         }
7455
7456         if (put_user(len, optlen)) {
7457                 retval = -EFAULT;
7458                 goto out;
7459         }
7460
7461         if (copy_to_user(optval, &params, len)) {
7462                 retval = -EFAULT;
7463                 goto out;
7464         }
7465
7466         retval = 0;
7467
7468 out:
7469         return retval;
7470 }
7471
7472 static int sctp_getsockopt_pr_streamstatus(struct sock *sk, int len,
7473                                            char __user *optval,
7474                                            int __user *optlen)
7475 {
7476         struct sctp_stream_out_ext *streamoute;
7477         struct sctp_association *asoc;
7478         struct sctp_prstatus params;
7479         int retval = -EINVAL;
7480         int policy;
7481
7482         if (len < sizeof(params))
7483                 goto out;
7484
7485         len = sizeof(params);
7486         if (copy_from_user(&params, optval, len)) {
7487                 retval = -EFAULT;
7488                 goto out;
7489         }
7490
7491         policy = params.sprstat_policy;
7492         if (!policy || (policy & ~(SCTP_PR_SCTP_MASK | SCTP_PR_SCTP_ALL)) ||
7493             ((policy & SCTP_PR_SCTP_ALL) && (policy & SCTP_PR_SCTP_MASK)))
7494                 goto out;
7495
7496         asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7497         if (!asoc || params.sprstat_sid >= asoc->stream.outcnt)
7498                 goto out;
7499
7500         streamoute = SCTP_SO(&asoc->stream, params.sprstat_sid)->ext;
7501         if (!streamoute) {
7502                 /* Not allocated yet, means all stats are 0 */
7503                 params.sprstat_abandoned_unsent = 0;
7504                 params.sprstat_abandoned_sent = 0;
7505                 retval = 0;
7506                 goto out;
7507         }
7508
7509         if (policy == SCTP_PR_SCTP_ALL) {
7510                 params.sprstat_abandoned_unsent = 0;
7511                 params.sprstat_abandoned_sent = 0;
7512                 for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7513                         params.sprstat_abandoned_unsent +=
7514                                 streamoute->abandoned_unsent[policy];
7515                         params.sprstat_abandoned_sent +=
7516                                 streamoute->abandoned_sent[policy];
7517                 }
7518         } else {
7519                 params.sprstat_abandoned_unsent =
7520                         streamoute->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7521                 params.sprstat_abandoned_sent =
7522                         streamoute->abandoned_sent[__SCTP_PR_INDEX(policy)];
7523         }
7524
7525         if (put_user(len, optlen) || copy_to_user(optval, &params, len)) {
7526                 retval = -EFAULT;
7527                 goto out;
7528         }
7529
7530         retval = 0;
7531
7532 out:
7533         return retval;
7534 }
7535
7536 static int sctp_getsockopt_reconfig_supported(struct sock *sk, int len,
7537                                               char __user *optval,
7538                                               int __user *optlen)
7539 {
7540         struct sctp_assoc_value params;
7541         struct sctp_association *asoc;
7542         int retval = -EFAULT;
7543
7544         if (len < sizeof(params)) {
7545                 retval = -EINVAL;
7546                 goto out;
7547         }
7548
7549         len = sizeof(params);
7550         if (copy_from_user(&params, optval, len))
7551                 goto out;
7552
7553         asoc = sctp_id2assoc(sk, params.assoc_id);
7554         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7555             sctp_style(sk, UDP)) {
7556                 retval = -EINVAL;
7557                 goto out;
7558         }
7559
7560         params.assoc_value = asoc ? asoc->peer.reconf_capable
7561                                   : sctp_sk(sk)->ep->reconf_enable;
7562
7563         if (put_user(len, optlen))
7564                 goto out;
7565
7566         if (copy_to_user(optval, &params, len))
7567                 goto out;
7568
7569         retval = 0;
7570
7571 out:
7572         return retval;
7573 }
7574
7575 static int sctp_getsockopt_enable_strreset(struct sock *sk, int len,
7576                                            char __user *optval,
7577                                            int __user *optlen)
7578 {
7579         struct sctp_assoc_value params;
7580         struct sctp_association *asoc;
7581         int retval = -EFAULT;
7582
7583         if (len < sizeof(params)) {
7584                 retval = -EINVAL;
7585                 goto out;
7586         }
7587
7588         len = sizeof(params);
7589         if (copy_from_user(&params, optval, len))
7590                 goto out;
7591
7592         asoc = sctp_id2assoc(sk, params.assoc_id);
7593         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7594             sctp_style(sk, UDP)) {
7595                 retval = -EINVAL;
7596                 goto out;
7597         }
7598
7599         params.assoc_value = asoc ? asoc->strreset_enable
7600                                   : sctp_sk(sk)->ep->strreset_enable;
7601
7602         if (put_user(len, optlen))
7603                 goto out;
7604
7605         if (copy_to_user(optval, &params, len))
7606                 goto out;
7607
7608         retval = 0;
7609
7610 out:
7611         return retval;
7612 }
7613
7614 static int sctp_getsockopt_scheduler(struct sock *sk, int len,
7615                                      char __user *optval,
7616                                      int __user *optlen)
7617 {
7618         struct sctp_assoc_value params;
7619         struct sctp_association *asoc;
7620         int retval = -EFAULT;
7621
7622         if (len < sizeof(params)) {
7623                 retval = -EINVAL;
7624                 goto out;
7625         }
7626
7627         len = sizeof(params);
7628         if (copy_from_user(&params, optval, len))
7629                 goto out;
7630
7631         asoc = sctp_id2assoc(sk, params.assoc_id);
7632         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7633             sctp_style(sk, UDP)) {
7634                 retval = -EINVAL;
7635                 goto out;
7636         }
7637
7638         params.assoc_value = asoc ? sctp_sched_get_sched(asoc)
7639                                   : sctp_sk(sk)->default_ss;
7640
7641         if (put_user(len, optlen))
7642                 goto out;
7643
7644         if (copy_to_user(optval, &params, len))
7645                 goto out;
7646
7647         retval = 0;
7648
7649 out:
7650         return retval;
7651 }
7652
7653 static int sctp_getsockopt_scheduler_value(struct sock *sk, int len,
7654                                            char __user *optval,
7655                                            int __user *optlen)
7656 {
7657         struct sctp_stream_value params;
7658         struct sctp_association *asoc;
7659         int retval = -EFAULT;
7660
7661         if (len < sizeof(params)) {
7662                 retval = -EINVAL;
7663                 goto out;
7664         }
7665
7666         len = sizeof(params);
7667         if (copy_from_user(&params, optval, len))
7668                 goto out;
7669
7670         asoc = sctp_id2assoc(sk, params.assoc_id);
7671         if (!asoc) {
7672                 retval = -EINVAL;
7673                 goto out;
7674         }
7675
7676         retval = sctp_sched_get_value(asoc, params.stream_id,
7677                                       &params.stream_value);
7678         if (retval)
7679                 goto out;
7680
7681         if (put_user(len, optlen)) {
7682                 retval = -EFAULT;
7683                 goto out;
7684         }
7685
7686         if (copy_to_user(optval, &params, len)) {
7687                 retval = -EFAULT;
7688                 goto out;
7689         }
7690
7691 out:
7692         return retval;
7693 }
7694
7695 static int sctp_getsockopt_interleaving_supported(struct sock *sk, int len,
7696                                                   char __user *optval,
7697                                                   int __user *optlen)
7698 {
7699         struct sctp_assoc_value params;
7700         struct sctp_association *asoc;
7701         int retval = -EFAULT;
7702
7703         if (len < sizeof(params)) {
7704                 retval = -EINVAL;
7705                 goto out;
7706         }
7707
7708         len = sizeof(params);
7709         if (copy_from_user(&params, optval, len))
7710                 goto out;
7711
7712         asoc = sctp_id2assoc(sk, params.assoc_id);
7713         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7714             sctp_style(sk, UDP)) {
7715                 retval = -EINVAL;
7716                 goto out;
7717         }
7718
7719         params.assoc_value = asoc ? asoc->peer.intl_capable
7720                                   : sctp_sk(sk)->ep->intl_enable;
7721
7722         if (put_user(len, optlen))
7723                 goto out;
7724
7725         if (copy_to_user(optval, &params, len))
7726                 goto out;
7727
7728         retval = 0;
7729
7730 out:
7731         return retval;
7732 }
7733
7734 static int sctp_getsockopt_reuse_port(struct sock *sk, int len,
7735                                       char __user *optval,
7736                                       int __user *optlen)
7737 {
7738         int val;
7739
7740         if (len < sizeof(int))
7741                 return -EINVAL;
7742
7743         len = sizeof(int);
7744         val = sctp_sk(sk)->reuse;
7745         if (put_user(len, optlen))
7746                 return -EFAULT;
7747
7748         if (copy_to_user(optval, &val, len))
7749                 return -EFAULT;
7750
7751         return 0;
7752 }
7753
7754 static int sctp_getsockopt_event(struct sock *sk, int len, char __user *optval,
7755                                  int __user *optlen)
7756 {
7757         struct sctp_association *asoc;
7758         struct sctp_event param;
7759         __u16 subscribe;
7760
7761         if (len < sizeof(param))
7762                 return -EINVAL;
7763
7764         len = sizeof(param);
7765         if (copy_from_user(&param, optval, len))
7766                 return -EFAULT;
7767
7768         if (param.se_type < SCTP_SN_TYPE_BASE ||
7769             param.se_type > SCTP_SN_TYPE_MAX)
7770                 return -EINVAL;
7771
7772         asoc = sctp_id2assoc(sk, param.se_assoc_id);
7773         if (!asoc && param.se_assoc_id != SCTP_FUTURE_ASSOC &&
7774             sctp_style(sk, UDP))
7775                 return -EINVAL;
7776
7777         subscribe = asoc ? asoc->subscribe : sctp_sk(sk)->subscribe;
7778         param.se_on = sctp_ulpevent_type_enabled(subscribe, param.se_type);
7779
7780         if (put_user(len, optlen))
7781                 return -EFAULT;
7782
7783         if (copy_to_user(optval, &param, len))
7784                 return -EFAULT;
7785
7786         return 0;
7787 }
7788
7789 static int sctp_getsockopt_asconf_supported(struct sock *sk, int len,
7790                                             char __user *optval,
7791                                             int __user *optlen)
7792 {
7793         struct sctp_assoc_value params;
7794         struct sctp_association *asoc;
7795         int retval = -EFAULT;
7796
7797         if (len < sizeof(params)) {
7798                 retval = -EINVAL;
7799                 goto out;
7800         }
7801
7802         len = sizeof(params);
7803         if (copy_from_user(&params, optval, len))
7804                 goto out;
7805
7806         asoc = sctp_id2assoc(sk, params.assoc_id);
7807         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7808             sctp_style(sk, UDP)) {
7809                 retval = -EINVAL;
7810                 goto out;
7811         }
7812
7813         params.assoc_value = asoc ? asoc->peer.asconf_capable
7814                                   : sctp_sk(sk)->ep->asconf_enable;
7815
7816         if (put_user(len, optlen))
7817                 goto out;
7818
7819         if (copy_to_user(optval, &params, len))
7820                 goto out;
7821
7822         retval = 0;
7823
7824 out:
7825         return retval;
7826 }
7827
7828 static int sctp_getsockopt_auth_supported(struct sock *sk, int len,
7829                                           char __user *optval,
7830                                           int __user *optlen)
7831 {
7832         struct sctp_assoc_value params;
7833         struct sctp_association *asoc;
7834         int retval = -EFAULT;
7835
7836         if (len < sizeof(params)) {
7837                 retval = -EINVAL;
7838                 goto out;
7839         }
7840
7841         len = sizeof(params);
7842         if (copy_from_user(&params, optval, len))
7843                 goto out;
7844
7845         asoc = sctp_id2assoc(sk, params.assoc_id);
7846         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7847             sctp_style(sk, UDP)) {
7848                 retval = -EINVAL;
7849                 goto out;
7850         }
7851
7852         params.assoc_value = asoc ? asoc->peer.auth_capable
7853                                   : sctp_sk(sk)->ep->auth_enable;
7854
7855         if (put_user(len, optlen))
7856                 goto out;
7857
7858         if (copy_to_user(optval, &params, len))
7859                 goto out;
7860
7861         retval = 0;
7862
7863 out:
7864         return retval;
7865 }
7866
7867 static int sctp_getsockopt_ecn_supported(struct sock *sk, int len,
7868                                          char __user *optval,
7869                                          int __user *optlen)
7870 {
7871         struct sctp_assoc_value params;
7872         struct sctp_association *asoc;
7873         int retval = -EFAULT;
7874
7875         if (len < sizeof(params)) {
7876                 retval = -EINVAL;
7877                 goto out;
7878         }
7879
7880         len = sizeof(params);
7881         if (copy_from_user(&params, optval, len))
7882                 goto out;
7883
7884         asoc = sctp_id2assoc(sk, params.assoc_id);
7885         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7886             sctp_style(sk, UDP)) {
7887                 retval = -EINVAL;
7888                 goto out;
7889         }
7890
7891         params.assoc_value = asoc ? asoc->peer.ecn_capable
7892                                   : sctp_sk(sk)->ep->ecn_enable;
7893
7894         if (put_user(len, optlen))
7895                 goto out;
7896
7897         if (copy_to_user(optval, &params, len))
7898                 goto out;
7899
7900         retval = 0;
7901
7902 out:
7903         return retval;
7904 }
7905
7906 static int sctp_getsockopt_pf_expose(struct sock *sk, int len,
7907                                      char __user *optval,
7908                                      int __user *optlen)
7909 {
7910         struct sctp_assoc_value params;
7911         struct sctp_association *asoc;
7912         int retval = -EFAULT;
7913
7914         if (len < sizeof(params)) {
7915                 retval = -EINVAL;
7916                 goto out;
7917         }
7918
7919         len = sizeof(params);
7920         if (copy_from_user(&params, optval, len))
7921                 goto out;
7922
7923         asoc = sctp_id2assoc(sk, params.assoc_id);
7924         if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7925             sctp_style(sk, UDP)) {
7926                 retval = -EINVAL;
7927                 goto out;
7928         }
7929
7930         params.assoc_value = asoc ? asoc->pf_expose
7931                                   : sctp_sk(sk)->pf_expose;
7932
7933         if (put_user(len, optlen))
7934                 goto out;
7935
7936         if (copy_to_user(optval, &params, len))
7937                 goto out;
7938
7939         retval = 0;
7940
7941 out:
7942         return retval;
7943 }
7944
7945 static int sctp_getsockopt_encap_port(struct sock *sk, int len,
7946                                       char __user *optval, int __user *optlen)
7947 {
7948         struct sctp_association *asoc;
7949         struct sctp_udpencaps encap;
7950         struct sctp_transport *t;
7951         __be16 encap_port;
7952
7953         if (len < sizeof(encap))
7954                 return -EINVAL;
7955
7956         len = sizeof(encap);
7957         if (copy_from_user(&encap, optval, len))
7958                 return -EFAULT;
7959
7960         /* If an address other than INADDR_ANY is specified, and
7961          * no transport is found, then the request is invalid.
7962          */
7963         if (!sctp_is_any(sk, (union sctp_addr *)&encap.sue_address)) {
7964                 t = sctp_addr_id2transport(sk, &encap.sue_address,
7965                                            encap.sue_assoc_id);
7966                 if (!t) {
7967                         pr_debug("%s: failed no transport\n", __func__);
7968                         return -EINVAL;
7969                 }
7970
7971                 encap_port = t->encap_port;
7972                 goto out;
7973         }
7974
7975         /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
7976          * socket is a one to many style socket, and an association
7977          * was not found, then the id was invalid.
7978          */
7979         asoc = sctp_id2assoc(sk, encap.sue_assoc_id);
7980         if (!asoc && encap.sue_assoc_id != SCTP_FUTURE_ASSOC &&
7981             sctp_style(sk, UDP)) {
7982                 pr_debug("%s: failed no association\n", __func__);
7983                 return -EINVAL;
7984         }
7985
7986         if (asoc) {
7987                 encap_port = asoc->encap_port;
7988                 goto out;
7989         }
7990
7991         encap_port = sctp_sk(sk)->encap_port;
7992
7993 out:
7994         encap.sue_port = (__force uint16_t)encap_port;
7995         if (copy_to_user(optval, &encap, len))
7996                 return -EFAULT;
7997
7998         if (put_user(len, optlen))
7999                 return -EFAULT;
8000
8001         return 0;
8002 }
8003
8004 static int sctp_getsockopt_probe_interval(struct sock *sk, int len,
8005                                           char __user *optval,
8006                                           int __user *optlen)
8007 {
8008         struct sctp_probeinterval params;
8009         struct sctp_association *asoc;
8010         struct sctp_transport *t;
8011         __u32 probe_interval;
8012
8013         if (len < sizeof(params))
8014                 return -EINVAL;
8015
8016         len = sizeof(params);
8017         if (copy_from_user(&params, optval, len))
8018                 return -EFAULT;
8019
8020         /* If an address other than INADDR_ANY is specified, and
8021          * no transport is found, then the request is invalid.
8022          */
8023         if (!sctp_is_any(sk, (union sctp_addr *)&params.spi_address)) {
8024                 t = sctp_addr_id2transport(sk, &params.spi_address,
8025                                            params.spi_assoc_id);
8026                 if (!t) {
8027                         pr_debug("%s: failed no transport\n", __func__);
8028                         return -EINVAL;
8029                 }
8030
8031                 probe_interval = jiffies_to_msecs(t->probe_interval);
8032                 goto out;
8033         }
8034
8035         /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
8036          * socket is a one to many style socket, and an association
8037          * was not found, then the id was invalid.
8038          */
8039         asoc = sctp_id2assoc(sk, params.spi_assoc_id);
8040         if (!asoc && params.spi_assoc_id != SCTP_FUTURE_ASSOC &&
8041             sctp_style(sk, UDP)) {
8042                 pr_debug("%s: failed no association\n", __func__);
8043                 return -EINVAL;
8044         }
8045
8046         if (asoc) {
8047                 probe_interval = jiffies_to_msecs(asoc->probe_interval);
8048                 goto out;
8049         }
8050
8051         probe_interval = sctp_sk(sk)->probe_interval;
8052
8053 out:
8054         params.spi_interval = probe_interval;
8055         if (copy_to_user(optval, &params, len))
8056                 return -EFAULT;
8057
8058         if (put_user(len, optlen))
8059                 return -EFAULT;
8060
8061         return 0;
8062 }
8063
8064 static int sctp_getsockopt(struct sock *sk, int level, int optname,
8065                            char __user *optval, int __user *optlen)
8066 {
8067         int retval = 0;
8068         int len;
8069
8070         pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
8071
8072         /* I can hardly begin to describe how wrong this is.  This is
8073          * so broken as to be worse than useless.  The API draft
8074          * REALLY is NOT helpful here...  I am not convinced that the
8075          * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
8076          * are at all well-founded.
8077          */
8078         if (level != SOL_SCTP) {
8079                 struct sctp_af *af = sctp_sk(sk)->pf->af;
8080
8081                 retval = af->getsockopt(sk, level, optname, optval, optlen);
8082                 return retval;
8083         }
8084
8085         if (get_user(len, optlen))
8086                 return -EFAULT;
8087
8088         if (len < 0)
8089                 return -EINVAL;
8090
8091         lock_sock(sk);
8092
8093         switch (optname) {
8094         case SCTP_STATUS:
8095                 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
8096                 break;
8097         case SCTP_DISABLE_FRAGMENTS:
8098                 retval = sctp_getsockopt_disable_fragments(sk, len, optval,
8099                                                            optlen);
8100                 break;
8101         case SCTP_EVENTS:
8102                 retval = sctp_getsockopt_events(sk, len, optval, optlen);
8103                 break;
8104         case SCTP_AUTOCLOSE:
8105                 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
8106                 break;
8107         case SCTP_SOCKOPT_PEELOFF:
8108                 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
8109                 break;
8110         case SCTP_SOCKOPT_PEELOFF_FLAGS:
8111                 retval = sctp_getsockopt_peeloff_flags(sk, len, optval, optlen);
8112                 break;
8113         case SCTP_PEER_ADDR_PARAMS:
8114                 retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
8115                                                           optlen);
8116                 break;
8117         case SCTP_DELAYED_SACK:
8118                 retval = sctp_getsockopt_delayed_ack(sk, len, optval,
8119                                                           optlen);
8120                 break;
8121         case SCTP_INITMSG:
8122                 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
8123                 break;
8124         case SCTP_GET_PEER_ADDRS:
8125                 retval = sctp_getsockopt_peer_addrs(sk, len, optval,
8126                                                     optlen);
8127                 break;
8128         case SCTP_GET_LOCAL_ADDRS:
8129                 retval = sctp_getsockopt_local_addrs(sk, len, optval,
8130                                                      optlen);
8131                 break;
8132         case SCTP_SOCKOPT_CONNECTX3:
8133                 retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
8134                 break;
8135         case SCTP_DEFAULT_SEND_PARAM:
8136                 retval = sctp_getsockopt_default_send_param(sk, len,
8137                                                             optval, optlen);
8138                 break;
8139         case SCTP_DEFAULT_SNDINFO:
8140                 retval = sctp_getsockopt_default_sndinfo(sk, len,
8141                                                          optval, optlen);
8142                 break;
8143         case SCTP_PRIMARY_ADDR:
8144                 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
8145                 break;
8146         case SCTP_NODELAY:
8147                 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
8148                 break;
8149         case SCTP_RTOINFO:
8150                 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
8151                 break;
8152         case SCTP_ASSOCINFO:
8153                 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
8154                 break;
8155         case SCTP_I_WANT_MAPPED_V4_ADDR:
8156                 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
8157                 break;
8158         case SCTP_MAXSEG:
8159                 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
8160                 break;
8161         case SCTP_GET_PEER_ADDR_INFO:
8162                 retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
8163                                                         optlen);
8164                 break;
8165         case SCTP_ADAPTATION_LAYER:
8166                 retval = sctp_getsockopt_adaptation_layer(sk, len, optval,
8167                                                         optlen);
8168                 break;
8169         case SCTP_CONTEXT:
8170                 retval = sctp_getsockopt_context(sk, len, optval, optlen);
8171                 break;
8172         case SCTP_FRAGMENT_INTERLEAVE:
8173                 retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
8174                                                              optlen);
8175                 break;
8176         case SCTP_PARTIAL_DELIVERY_POINT:
8177                 retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
8178                                                                 optlen);
8179                 break;
8180         case SCTP_MAX_BURST:
8181                 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
8182                 break;
8183         case SCTP_AUTH_KEY:
8184         case SCTP_AUTH_CHUNK:
8185         case SCTP_AUTH_DELETE_KEY:
8186         case SCTP_AUTH_DEACTIVATE_KEY:
8187                 retval = -EOPNOTSUPP;
8188                 break;
8189         case SCTP_HMAC_IDENT:
8190                 retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
8191                 break;
8192         case SCTP_AUTH_ACTIVE_KEY:
8193                 retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
8194                 break;
8195         case SCTP_PEER_AUTH_CHUNKS:
8196                 retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
8197                                                         optlen);
8198                 break;
8199         case SCTP_LOCAL_AUTH_CHUNKS:
8200                 retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
8201                                                         optlen);
8202                 break;
8203         case SCTP_GET_ASSOC_NUMBER:
8204                 retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
8205                 break;
8206         case SCTP_GET_ASSOC_ID_LIST:
8207                 retval = sctp_getsockopt_assoc_ids(sk, len, optval, optlen);
8208                 break;
8209         case SCTP_AUTO_ASCONF:
8210                 retval = sctp_getsockopt_auto_asconf(sk, len, optval, optlen);
8211                 break;
8212         case SCTP_PEER_ADDR_THLDS:
8213                 retval = sctp_getsockopt_paddr_thresholds(sk, optval, len,
8214                                                           optlen, false);
8215                 break;
8216         case SCTP_PEER_ADDR_THLDS_V2:
8217                 retval = sctp_getsockopt_paddr_thresholds(sk, optval, len,
8218                                                           optlen, true);
8219                 break;
8220         case SCTP_GET_ASSOC_STATS:
8221                 retval = sctp_getsockopt_assoc_stats(sk, len, optval, optlen);
8222                 break;
8223         case SCTP_RECVRCVINFO:
8224                 retval = sctp_getsockopt_recvrcvinfo(sk, len, optval, optlen);
8225                 break;
8226         case SCTP_RECVNXTINFO:
8227                 retval = sctp_getsockopt_recvnxtinfo(sk, len, optval, optlen);
8228                 break;
8229         case SCTP_PR_SUPPORTED:
8230                 retval = sctp_getsockopt_pr_supported(sk, len, optval, optlen);
8231                 break;
8232         case SCTP_DEFAULT_PRINFO:
8233                 retval = sctp_getsockopt_default_prinfo(sk, len, optval,
8234                                                         optlen);
8235                 break;
8236         case SCTP_PR_ASSOC_STATUS:
8237                 retval = sctp_getsockopt_pr_assocstatus(sk, len, optval,
8238                                                         optlen);
8239                 break;
8240         case SCTP_PR_STREAM_STATUS:
8241                 retval = sctp_getsockopt_pr_streamstatus(sk, len, optval,
8242                                                          optlen);
8243                 break;
8244         case SCTP_RECONFIG_SUPPORTED:
8245                 retval = sctp_getsockopt_reconfig_supported(sk, len, optval,
8246                                                             optlen);
8247                 break;
8248         case SCTP_ENABLE_STREAM_RESET:
8249                 retval = sctp_getsockopt_enable_strreset(sk, len, optval,
8250                                                          optlen);
8251                 break;
8252         case SCTP_STREAM_SCHEDULER:
8253                 retval = sctp_getsockopt_scheduler(sk, len, optval,
8254                                                    optlen);
8255                 break;
8256         case SCTP_STREAM_SCHEDULER_VALUE:
8257                 retval = sctp_getsockopt_scheduler_value(sk, len, optval,
8258                                                          optlen);
8259                 break;
8260         case SCTP_INTERLEAVING_SUPPORTED:
8261                 retval = sctp_getsockopt_interleaving_supported(sk, len, optval,
8262                                                                 optlen);
8263                 break;
8264         case SCTP_REUSE_PORT:
8265                 retval = sctp_getsockopt_reuse_port(sk, len, optval, optlen);
8266                 break;
8267         case SCTP_EVENT:
8268                 retval = sctp_getsockopt_event(sk, len, optval, optlen);
8269                 break;
8270         case SCTP_ASCONF_SUPPORTED:
8271                 retval = sctp_getsockopt_asconf_supported(sk, len, optval,
8272                                                           optlen);
8273                 break;
8274         case SCTP_AUTH_SUPPORTED:
8275                 retval = sctp_getsockopt_auth_supported(sk, len, optval,
8276                                                         optlen);
8277                 break;
8278         case SCTP_ECN_SUPPORTED:
8279                 retval = sctp_getsockopt_ecn_supported(sk, len, optval, optlen);
8280                 break;
8281         case SCTP_EXPOSE_POTENTIALLY_FAILED_STATE:
8282                 retval = sctp_getsockopt_pf_expose(sk, len, optval, optlen);
8283                 break;
8284         case SCTP_REMOTE_UDP_ENCAPS_PORT:
8285                 retval = sctp_getsockopt_encap_port(sk, len, optval, optlen);
8286                 break;
8287         case SCTP_PLPMTUD_PROBE_INTERVAL:
8288                 retval = sctp_getsockopt_probe_interval(sk, len, optval, optlen);
8289                 break;
8290         default:
8291                 retval = -ENOPROTOOPT;
8292                 break;
8293         }
8294
8295         release_sock(sk);
8296         return retval;
8297 }
8298
8299 static bool sctp_bpf_bypass_getsockopt(int level, int optname)
8300 {
8301         if (level == SOL_SCTP) {
8302                 switch (optname) {
8303                 case SCTP_SOCKOPT_PEELOFF:
8304                 case SCTP_SOCKOPT_PEELOFF_FLAGS:
8305                 case SCTP_SOCKOPT_CONNECTX3:
8306                         return true;
8307                 default:
8308                         return false;
8309                 }
8310         }
8311
8312         return false;
8313 }
8314
8315 static int sctp_hash(struct sock *sk)
8316 {
8317         /* STUB */
8318         return 0;
8319 }
8320
8321 static void sctp_unhash(struct sock *sk)
8322 {
8323         /* STUB */
8324 }
8325
8326 /* Check if port is acceptable.  Possibly find first available port.
8327  *
8328  * The port hash table (contained in the 'global' SCTP protocol storage
8329  * returned by struct sctp_protocol *sctp_get_protocol()). The hash
8330  * table is an array of 4096 lists (sctp_bind_hashbucket). Each
8331  * list (the list number is the port number hashed out, so as you
8332  * would expect from a hash function, all the ports in a given list have
8333  * such a number that hashes out to the same list number; you were
8334  * expecting that, right?); so each list has a set of ports, with a
8335  * link to the socket (struct sock) that uses it, the port number and
8336  * a fastreuse flag (FIXME: NPI ipg).
8337  */
8338 static struct sctp_bind_bucket *sctp_bucket_create(
8339         struct sctp_bind_hashbucket *head, struct net *, unsigned short snum);
8340
8341 static int sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
8342 {
8343         struct sctp_sock *sp = sctp_sk(sk);
8344         bool reuse = (sk->sk_reuse || sp->reuse);
8345         struct sctp_bind_hashbucket *head; /* hash list */
8346         struct net *net = sock_net(sk);
8347         kuid_t uid = sock_i_uid(sk);
8348         struct sctp_bind_bucket *pp;
8349         unsigned short snum;
8350         int ret;
8351
8352         snum = ntohs(addr->v4.sin_port);
8353
8354         pr_debug("%s: begins, snum:%d\n", __func__, snum);
8355
8356         if (snum == 0) {
8357                 /* Search for an available port. */
8358                 int low, high, remaining, index;
8359                 unsigned int rover;
8360
8361                 inet_sk_get_local_port_range(sk, &low, &high);
8362                 remaining = (high - low) + 1;
8363                 rover = get_random_u32_below(remaining) + low;
8364
8365                 do {
8366                         rover++;
8367                         if ((rover < low) || (rover > high))
8368                                 rover = low;
8369                         if (inet_is_local_reserved_port(net, rover))
8370                                 continue;
8371                         index = sctp_phashfn(net, rover);
8372                         head = &sctp_port_hashtable[index];
8373                         spin_lock_bh(&head->lock);
8374                         sctp_for_each_hentry(pp, &head->chain)
8375                                 if ((pp->port == rover) &&
8376                                     net_eq(net, pp->net))
8377                                         goto next;
8378                         break;
8379                 next:
8380                         spin_unlock_bh(&head->lock);
8381                         cond_resched();
8382                 } while (--remaining > 0);
8383
8384                 /* Exhausted local port range during search? */
8385                 ret = 1;
8386                 if (remaining <= 0)
8387                         return ret;
8388
8389                 /* OK, here is the one we will use.  HEAD (the port
8390                  * hash table list entry) is non-NULL and we hold it's
8391                  * mutex.
8392                  */
8393                 snum = rover;
8394         } else {
8395                 /* We are given an specific port number; we verify
8396                  * that it is not being used. If it is used, we will
8397                  * exahust the search in the hash list corresponding
8398                  * to the port number (snum) - we detect that with the
8399                  * port iterator, pp being NULL.
8400                  */
8401                 head = &sctp_port_hashtable[sctp_phashfn(net, snum)];
8402                 spin_lock_bh(&head->lock);
8403                 sctp_for_each_hentry(pp, &head->chain) {
8404                         if ((pp->port == snum) && net_eq(pp->net, net))
8405                                 goto pp_found;
8406                 }
8407         }
8408         pp = NULL;
8409         goto pp_not_found;
8410 pp_found:
8411         if (!hlist_empty(&pp->owner)) {
8412                 /* We had a port hash table hit - there is an
8413                  * available port (pp != NULL) and it is being
8414                  * used by other socket (pp->owner not empty); that other
8415                  * socket is going to be sk2.
8416                  */
8417                 struct sock *sk2;
8418
8419                 pr_debug("%s: found a possible match\n", __func__);
8420
8421                 if ((pp->fastreuse && reuse &&
8422                      sk->sk_state != SCTP_SS_LISTENING) ||
8423                     (pp->fastreuseport && sk->sk_reuseport &&
8424                      uid_eq(pp->fastuid, uid)))
8425                         goto success;
8426
8427                 /* Run through the list of sockets bound to the port
8428                  * (pp->port) [via the pointers bind_next and
8429                  * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
8430                  * we get the endpoint they describe and run through
8431                  * the endpoint's list of IP (v4 or v6) addresses,
8432                  * comparing each of the addresses with the address of
8433                  * the socket sk. If we find a match, then that means
8434                  * that this port/socket (sk) combination are already
8435                  * in an endpoint.
8436                  */
8437                 sk_for_each_bound(sk2, &pp->owner) {
8438                         int bound_dev_if2 = READ_ONCE(sk2->sk_bound_dev_if);
8439                         struct sctp_sock *sp2 = sctp_sk(sk2);
8440                         struct sctp_endpoint *ep2 = sp2->ep;
8441
8442                         if (sk == sk2 ||
8443                             (reuse && (sk2->sk_reuse || sp2->reuse) &&
8444                              sk2->sk_state != SCTP_SS_LISTENING) ||
8445                             (sk->sk_reuseport && sk2->sk_reuseport &&
8446                              uid_eq(uid, sock_i_uid(sk2))))
8447                                 continue;
8448
8449                         if ((!sk->sk_bound_dev_if || !bound_dev_if2 ||
8450                              sk->sk_bound_dev_if == bound_dev_if2) &&
8451                             sctp_bind_addr_conflict(&ep2->base.bind_addr,
8452                                                     addr, sp2, sp)) {
8453                                 ret = 1;
8454                                 goto fail_unlock;
8455                         }
8456                 }
8457
8458                 pr_debug("%s: found a match\n", __func__);
8459         }
8460 pp_not_found:
8461         /* If there was a hash table miss, create a new port.  */
8462         ret = 1;
8463         if (!pp && !(pp = sctp_bucket_create(head, net, snum)))
8464                 goto fail_unlock;
8465
8466         /* In either case (hit or miss), make sure fastreuse is 1 only
8467          * if sk->sk_reuse is too (that is, if the caller requested
8468          * SO_REUSEADDR on this socket -sk-).
8469          */
8470         if (hlist_empty(&pp->owner)) {
8471                 if (reuse && sk->sk_state != SCTP_SS_LISTENING)
8472                         pp->fastreuse = 1;
8473                 else
8474                         pp->fastreuse = 0;
8475
8476                 if (sk->sk_reuseport) {
8477                         pp->fastreuseport = 1;
8478                         pp->fastuid = uid;
8479                 } else {
8480                         pp->fastreuseport = 0;
8481                 }
8482         } else {
8483                 if (pp->fastreuse &&
8484                     (!reuse || sk->sk_state == SCTP_SS_LISTENING))
8485                         pp->fastreuse = 0;
8486
8487                 if (pp->fastreuseport &&
8488                     (!sk->sk_reuseport || !uid_eq(pp->fastuid, uid)))
8489                         pp->fastreuseport = 0;
8490         }
8491
8492         /* We are set, so fill up all the data in the hash table
8493          * entry, tie the socket list information with the rest of the
8494          * sockets FIXME: Blurry, NPI (ipg).
8495          */
8496 success:
8497         if (!sp->bind_hash) {
8498                 inet_sk(sk)->inet_num = snum;
8499                 sk_add_bind_node(sk, &pp->owner);
8500                 sp->bind_hash = pp;
8501         }
8502         ret = 0;
8503
8504 fail_unlock:
8505         spin_unlock_bh(&head->lock);
8506         return ret;
8507 }
8508
8509 /* Assign a 'snum' port to the socket.  If snum == 0, an ephemeral
8510  * port is requested.
8511  */
8512 static int sctp_get_port(struct sock *sk, unsigned short snum)
8513 {
8514         union sctp_addr addr;
8515         struct sctp_af *af = sctp_sk(sk)->pf->af;
8516
8517         /* Set up a dummy address struct from the sk. */
8518         af->from_sk(&addr, sk);
8519         addr.v4.sin_port = htons(snum);
8520
8521         /* Note: sk->sk_num gets filled in if ephemeral port request. */
8522         return sctp_get_port_local(sk, &addr);
8523 }
8524
8525 /*
8526  *  Move a socket to LISTENING state.
8527  */
8528 static int sctp_listen_start(struct sock *sk, int backlog)
8529 {
8530         struct sctp_sock *sp = sctp_sk(sk);
8531         struct sctp_endpoint *ep = sp->ep;
8532         struct crypto_shash *tfm = NULL;
8533         char alg[32];
8534
8535         /* Allocate HMAC for generating cookie. */
8536         if (!sp->hmac && sp->sctp_hmac_alg) {
8537                 sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
8538                 tfm = crypto_alloc_shash(alg, 0, 0);
8539                 if (IS_ERR(tfm)) {
8540                         net_info_ratelimited("failed to load transform for %s: %ld\n",
8541                                              sp->sctp_hmac_alg, PTR_ERR(tfm));
8542                         return -ENOSYS;
8543                 }
8544                 sctp_sk(sk)->hmac = tfm;
8545         }
8546
8547         /*
8548          * If a bind() or sctp_bindx() is not called prior to a listen()
8549          * call that allows new associations to be accepted, the system
8550          * picks an ephemeral port and will choose an address set equivalent
8551          * to binding with a wildcard address.
8552          *
8553          * This is not currently spelled out in the SCTP sockets
8554          * extensions draft, but follows the practice as seen in TCP
8555          * sockets.
8556          *
8557          */
8558         inet_sk_set_state(sk, SCTP_SS_LISTENING);
8559         if (!ep->base.bind_addr.port) {
8560                 if (sctp_autobind(sk))
8561                         return -EAGAIN;
8562         } else {
8563                 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
8564                         inet_sk_set_state(sk, SCTP_SS_CLOSED);
8565                         return -EADDRINUSE;
8566                 }
8567         }
8568
8569         WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8570         return sctp_hash_endpoint(ep);
8571 }
8572
8573 /*
8574  * 4.1.3 / 5.1.3 listen()
8575  *
8576  *   By default, new associations are not accepted for UDP style sockets.
8577  *   An application uses listen() to mark a socket as being able to
8578  *   accept new associations.
8579  *
8580  *   On TCP style sockets, applications use listen() to ready the SCTP
8581  *   endpoint for accepting inbound associations.
8582  *
8583  *   On both types of endpoints a backlog of '0' disables listening.
8584  *
8585  *  Move a socket to LISTENING state.
8586  */
8587 int sctp_inet_listen(struct socket *sock, int backlog)
8588 {
8589         struct sock *sk = sock->sk;
8590         struct sctp_endpoint *ep = sctp_sk(sk)->ep;
8591         int err = -EINVAL;
8592
8593         if (unlikely(backlog < 0))
8594                 return err;
8595
8596         lock_sock(sk);
8597
8598         /* Peeled-off sockets are not allowed to listen().  */
8599         if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
8600                 goto out;
8601
8602         if (sock->state != SS_UNCONNECTED)
8603                 goto out;
8604
8605         if (!sctp_sstate(sk, LISTENING) && !sctp_sstate(sk, CLOSED))
8606                 goto out;
8607
8608         /* If backlog is zero, disable listening. */
8609         if (!backlog) {
8610                 if (sctp_sstate(sk, CLOSED))
8611                         goto out;
8612
8613                 err = 0;
8614                 sctp_unhash_endpoint(ep);
8615                 sk->sk_state = SCTP_SS_CLOSED;
8616                 if (sk->sk_reuse || sctp_sk(sk)->reuse)
8617                         sctp_sk(sk)->bind_hash->fastreuse = 1;
8618                 goto out;
8619         }
8620
8621         /* If we are already listening, just update the backlog */
8622         if (sctp_sstate(sk, LISTENING))
8623                 WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8624         else {
8625                 err = sctp_listen_start(sk, backlog);
8626                 if (err)
8627                         goto out;
8628         }
8629
8630         err = 0;
8631 out:
8632         release_sock(sk);
8633         return err;
8634 }
8635
8636 /*
8637  * This function is done by modeling the current datagram_poll() and the
8638  * tcp_poll().  Note that, based on these implementations, we don't
8639  * lock the socket in this function, even though it seems that,
8640  * ideally, locking or some other mechanisms can be used to ensure
8641  * the integrity of the counters (sndbuf and wmem_alloc) used
8642  * in this place.  We assume that we don't need locks either until proven
8643  * otherwise.
8644  *
8645  * Another thing to note is that we include the Async I/O support
8646  * here, again, by modeling the current TCP/UDP code.  We don't have
8647  * a good way to test with it yet.
8648  */
8649 __poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
8650 {
8651         struct sock *sk = sock->sk;
8652         struct sctp_sock *sp = sctp_sk(sk);
8653         __poll_t mask;
8654
8655         poll_wait(file, sk_sleep(sk), wait);
8656
8657         sock_rps_record_flow(sk);
8658
8659         /* A TCP-style listening socket becomes readable when the accept queue
8660          * is not empty.
8661          */
8662         if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
8663                 return (!list_empty(&sp->ep->asocs)) ?
8664                         (EPOLLIN | EPOLLRDNORM) : 0;
8665
8666         mask = 0;
8667
8668         /* Is there any exceptional events?  */
8669         if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
8670                 mask |= EPOLLERR |
8671                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
8672         if (sk->sk_shutdown & RCV_SHUTDOWN)
8673                 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
8674         if (sk->sk_shutdown == SHUTDOWN_MASK)
8675                 mask |= EPOLLHUP;
8676
8677         /* Is it readable?  Reconsider this code with TCP-style support.  */
8678         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
8679                 mask |= EPOLLIN | EPOLLRDNORM;
8680
8681         /* The association is either gone or not ready.  */
8682         if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
8683                 return mask;
8684
8685         /* Is it writable?  */
8686         if (sctp_writeable(sk)) {
8687                 mask |= EPOLLOUT | EPOLLWRNORM;
8688         } else {
8689                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
8690                 /*
8691                  * Since the socket is not locked, the buffer
8692                  * might be made available after the writeable check and
8693                  * before the bit is set.  This could cause a lost I/O
8694                  * signal.  tcp_poll() has a race breaker for this race
8695                  * condition.  Based on their implementation, we put
8696                  * in the following code to cover it as well.
8697                  */
8698                 if (sctp_writeable(sk))
8699                         mask |= EPOLLOUT | EPOLLWRNORM;
8700         }
8701         return mask;
8702 }
8703
8704 /********************************************************************
8705  * 2nd Level Abstractions
8706  ********************************************************************/
8707
8708 static struct sctp_bind_bucket *sctp_bucket_create(
8709         struct sctp_bind_hashbucket *head, struct net *net, unsigned short snum)
8710 {
8711         struct sctp_bind_bucket *pp;
8712
8713         pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC);
8714         if (pp) {
8715                 SCTP_DBG_OBJCNT_INC(bind_bucket);
8716                 pp->port = snum;
8717                 pp->fastreuse = 0;
8718                 INIT_HLIST_HEAD(&pp->owner);
8719                 pp->net = net;
8720                 hlist_add_head(&pp->node, &head->chain);
8721         }
8722         return pp;
8723 }
8724
8725 /* Caller must hold hashbucket lock for this tb with local BH disabled */
8726 static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
8727 {
8728         if (pp && hlist_empty(&pp->owner)) {
8729                 __hlist_del(&pp->node);
8730                 kmem_cache_free(sctp_bucket_cachep, pp);
8731                 SCTP_DBG_OBJCNT_DEC(bind_bucket);
8732         }
8733 }
8734
8735 /* Release this socket's reference to a local port.  */
8736 static inline void __sctp_put_port(struct sock *sk)
8737 {
8738         struct sctp_bind_hashbucket *head =
8739                 &sctp_port_hashtable[sctp_phashfn(sock_net(sk),
8740                                                   inet_sk(sk)->inet_num)];
8741         struct sctp_bind_bucket *pp;
8742
8743         spin_lock(&head->lock);
8744         pp = sctp_sk(sk)->bind_hash;
8745         __sk_del_bind_node(sk);
8746         sctp_sk(sk)->bind_hash = NULL;
8747         inet_sk(sk)->inet_num = 0;
8748         sctp_bucket_destroy(pp);
8749         spin_unlock(&head->lock);
8750 }
8751
8752 void sctp_put_port(struct sock *sk)
8753 {
8754         local_bh_disable();
8755         __sctp_put_port(sk);
8756         local_bh_enable();
8757 }
8758
8759 /*
8760  * The system picks an ephemeral port and choose an address set equivalent
8761  * to binding with a wildcard address.
8762  * One of those addresses will be the primary address for the association.
8763  * This automatically enables the multihoming capability of SCTP.
8764  */
8765 static int sctp_autobind(struct sock *sk)
8766 {
8767         union sctp_addr autoaddr;
8768         struct sctp_af *af;
8769         __be16 port;
8770
8771         /* Initialize a local sockaddr structure to INADDR_ANY. */
8772         af = sctp_sk(sk)->pf->af;
8773
8774         port = htons(inet_sk(sk)->inet_num);
8775         af->inaddr_any(&autoaddr, port);
8776
8777         return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
8778 }
8779
8780 /* Parse out IPPROTO_SCTP CMSG headers.  Perform only minimal validation.
8781  *
8782  * From RFC 2292
8783  * 4.2 The cmsghdr Structure *
8784  *
8785  * When ancillary data is sent or received, any number of ancillary data
8786  * objects can be specified by the msg_control and msg_controllen members of
8787  * the msghdr structure, because each object is preceded by
8788  * a cmsghdr structure defining the object's length (the cmsg_len member).
8789  * Historically Berkeley-derived implementations have passed only one object
8790  * at a time, but this API allows multiple objects to be
8791  * passed in a single call to sendmsg() or recvmsg(). The following example
8792  * shows two ancillary data objects in a control buffer.
8793  *
8794  *   |<--------------------------- msg_controllen -------------------------->|
8795  *   |                                                                       |
8796  *
8797  *   |<----- ancillary data object ----->|<----- ancillary data object ----->|
8798  *
8799  *   |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8800  *   |                                   |                                   |
8801  *
8802  *   |<---------- cmsg_len ---------->|  |<--------- cmsg_len ----------->|  |
8803  *
8804  *   |<--------- CMSG_LEN() --------->|  |<-------- CMSG_LEN() ---------->|  |
8805  *   |                                |  |                                |  |
8806  *
8807  *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8808  *   |cmsg_|cmsg_|cmsg_|XX|           |XX|cmsg_|cmsg_|cmsg_|XX|           |XX|
8809  *
8810  *   |len  |level|type |XX|cmsg_data[]|XX|len  |level|type |XX|cmsg_data[]|XX|
8811  *
8812  *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8813  *    ^
8814  *    |
8815  *
8816  * msg_control
8817  * points here
8818  */
8819 static int sctp_msghdr_parse(const struct msghdr *msg, struct sctp_cmsgs *cmsgs)
8820 {
8821         struct msghdr *my_msg = (struct msghdr *)msg;
8822         struct cmsghdr *cmsg;
8823
8824         for_each_cmsghdr(cmsg, my_msg) {
8825                 if (!CMSG_OK(my_msg, cmsg))
8826                         return -EINVAL;
8827
8828                 /* Should we parse this header or ignore?  */
8829                 if (cmsg->cmsg_level != IPPROTO_SCTP)
8830                         continue;
8831
8832                 /* Strictly check lengths following example in SCM code.  */
8833                 switch (cmsg->cmsg_type) {
8834                 case SCTP_INIT:
8835                         /* SCTP Socket API Extension
8836                          * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
8837                          *
8838                          * This cmsghdr structure provides information for
8839                          * initializing new SCTP associations with sendmsg().
8840                          * The SCTP_INITMSG socket option uses this same data
8841                          * structure.  This structure is not used for
8842                          * recvmsg().
8843                          *
8844                          * cmsg_level    cmsg_type      cmsg_data[]
8845                          * ------------  ------------   ----------------------
8846                          * IPPROTO_SCTP  SCTP_INIT      struct sctp_initmsg
8847                          */
8848                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_initmsg)))
8849                                 return -EINVAL;
8850
8851                         cmsgs->init = CMSG_DATA(cmsg);
8852                         break;
8853
8854                 case SCTP_SNDRCV:
8855                         /* SCTP Socket API Extension
8856                          * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
8857                          *
8858                          * This cmsghdr structure specifies SCTP options for
8859                          * sendmsg() and describes SCTP header information
8860                          * about a received message through recvmsg().
8861                          *
8862                          * cmsg_level    cmsg_type      cmsg_data[]
8863                          * ------------  ------------   ----------------------
8864                          * IPPROTO_SCTP  SCTP_SNDRCV    struct sctp_sndrcvinfo
8865                          */
8866                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
8867                                 return -EINVAL;
8868
8869                         cmsgs->srinfo = CMSG_DATA(cmsg);
8870
8871                         if (cmsgs->srinfo->sinfo_flags &
8872                             ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8873                               SCTP_SACK_IMMEDIATELY | SCTP_SENDALL |
8874                               SCTP_PR_SCTP_MASK | SCTP_ABORT | SCTP_EOF))
8875                                 return -EINVAL;
8876                         break;
8877
8878                 case SCTP_SNDINFO:
8879                         /* SCTP Socket API Extension
8880                          * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
8881                          *
8882                          * This cmsghdr structure specifies SCTP options for
8883                          * sendmsg(). This structure and SCTP_RCVINFO replaces
8884                          * SCTP_SNDRCV which has been deprecated.
8885                          *
8886                          * cmsg_level    cmsg_type      cmsg_data[]
8887                          * ------------  ------------   ---------------------
8888                          * IPPROTO_SCTP  SCTP_SNDINFO    struct sctp_sndinfo
8889                          */
8890                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndinfo)))
8891                                 return -EINVAL;
8892
8893                         cmsgs->sinfo = CMSG_DATA(cmsg);
8894
8895                         if (cmsgs->sinfo->snd_flags &
8896                             ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8897                               SCTP_SACK_IMMEDIATELY | SCTP_SENDALL |
8898                               SCTP_PR_SCTP_MASK | SCTP_ABORT | SCTP_EOF))
8899                                 return -EINVAL;
8900                         break;
8901                 case SCTP_PRINFO:
8902                         /* SCTP Socket API Extension
8903                          * 5.3.7 SCTP PR-SCTP Information Structure (SCTP_PRINFO)
8904                          *
8905                          * This cmsghdr structure specifies SCTP options for sendmsg().
8906                          *
8907                          * cmsg_level    cmsg_type      cmsg_data[]
8908                          * ------------  ------------   ---------------------
8909                          * IPPROTO_SCTP  SCTP_PRINFO    struct sctp_prinfo
8910                          */
8911                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_prinfo)))
8912                                 return -EINVAL;
8913
8914                         cmsgs->prinfo = CMSG_DATA(cmsg);
8915                         if (cmsgs->prinfo->pr_policy & ~SCTP_PR_SCTP_MASK)
8916                                 return -EINVAL;
8917
8918                         if (cmsgs->prinfo->pr_policy == SCTP_PR_SCTP_NONE)
8919                                 cmsgs->prinfo->pr_value = 0;
8920                         break;
8921                 case SCTP_AUTHINFO:
8922                         /* SCTP Socket API Extension
8923                          * 5.3.8 SCTP AUTH Information Structure (SCTP_AUTHINFO)
8924                          *
8925                          * This cmsghdr structure specifies SCTP options for sendmsg().
8926                          *
8927                          * cmsg_level    cmsg_type      cmsg_data[]
8928                          * ------------  ------------   ---------------------
8929                          * IPPROTO_SCTP  SCTP_AUTHINFO  struct sctp_authinfo
8930                          */
8931                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_authinfo)))
8932                                 return -EINVAL;
8933
8934                         cmsgs->authinfo = CMSG_DATA(cmsg);
8935                         break;
8936                 case SCTP_DSTADDRV4:
8937                 case SCTP_DSTADDRV6:
8938                         /* SCTP Socket API Extension
8939                          * 5.3.9/10 SCTP Destination IPv4/6 Address Structure (SCTP_DSTADDRV4/6)
8940                          *
8941                          * This cmsghdr structure specifies SCTP options for sendmsg().
8942                          *
8943                          * cmsg_level    cmsg_type         cmsg_data[]
8944                          * ------------  ------------   ---------------------
8945                          * IPPROTO_SCTP  SCTP_DSTADDRV4 struct in_addr
8946                          * ------------  ------------   ---------------------
8947                          * IPPROTO_SCTP  SCTP_DSTADDRV6 struct in6_addr
8948                          */
8949                         cmsgs->addrs_msg = my_msg;
8950                         break;
8951                 default:
8952                         return -EINVAL;
8953                 }
8954         }
8955
8956         return 0;
8957 }
8958
8959 /*
8960  * Wait for a packet..
8961  * Note: This function is the same function as in core/datagram.c
8962  * with a few modifications to make lksctp work.
8963  */
8964 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p)
8965 {
8966         int error;
8967         DEFINE_WAIT(wait);
8968
8969         prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
8970
8971         /* Socket errors? */
8972         error = sock_error(sk);
8973         if (error)
8974                 goto out;
8975
8976         if (!skb_queue_empty(&sk->sk_receive_queue))
8977                 goto ready;
8978
8979         /* Socket shut down?  */
8980         if (sk->sk_shutdown & RCV_SHUTDOWN)
8981                 goto out;
8982
8983         /* Sequenced packets can come disconnected.  If so we report the
8984          * problem.
8985          */
8986         error = -ENOTCONN;
8987
8988         /* Is there a good reason to think that we may receive some data?  */
8989         if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
8990                 goto out;
8991
8992         /* Handle signals.  */
8993         if (signal_pending(current))
8994                 goto interrupted;
8995
8996         /* Let another process have a go.  Since we are going to sleep
8997          * anyway.  Note: This may cause odd behaviors if the message
8998          * does not fit in the user's buffer, but this seems to be the
8999          * only way to honor MSG_DONTWAIT realistically.
9000          */
9001         release_sock(sk);
9002         *timeo_p = schedule_timeout(*timeo_p);
9003         lock_sock(sk);
9004
9005 ready:
9006         finish_wait(sk_sleep(sk), &wait);
9007         return 0;
9008
9009 interrupted:
9010         error = sock_intr_errno(*timeo_p);
9011
9012 out:
9013         finish_wait(sk_sleep(sk), &wait);
9014         *err = error;
9015         return error;
9016 }
9017
9018 /* Receive a datagram.
9019  * Note: This is pretty much the same routine as in core/datagram.c
9020  * with a few changes to make lksctp work.
9021  */
9022 struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, int *err)
9023 {
9024         int error;
9025         struct sk_buff *skb;
9026         long timeo;
9027
9028         timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
9029
9030         pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo,
9031                  MAX_SCHEDULE_TIMEOUT);
9032
9033         do {
9034                 /* Again only user level code calls this function,
9035                  * so nothing interrupt level
9036                  * will suddenly eat the receive_queue.
9037                  *
9038                  *  Look at current nfs client by the way...
9039                  *  However, this function was correct in any case. 8)
9040                  */
9041                 if (flags & MSG_PEEK) {
9042                         skb = skb_peek(&sk->sk_receive_queue);
9043                         if (skb)
9044                                 refcount_inc(&skb->users);
9045                 } else {
9046                         skb = __skb_dequeue(&sk->sk_receive_queue);
9047                 }
9048
9049                 if (skb)
9050                         return skb;
9051
9052                 /* Caller is allowed not to check sk->sk_err before calling. */
9053                 error = sock_error(sk);
9054                 if (error)
9055                         goto no_packet;
9056
9057                 if (sk->sk_shutdown & RCV_SHUTDOWN)
9058                         break;
9059
9060
9061                 /* User doesn't want to wait.  */
9062                 error = -EAGAIN;
9063                 if (!timeo)
9064                         goto no_packet;
9065         } while (sctp_wait_for_packet(sk, err, &timeo) == 0);
9066
9067         return NULL;
9068
9069 no_packet:
9070         *err = error;
9071         return NULL;
9072 }
9073
9074 /* If sndbuf has changed, wake up per association sndbuf waiters.  */
9075 static void __sctp_write_space(struct sctp_association *asoc)
9076 {
9077         struct sock *sk = asoc->base.sk;
9078
9079         if (sctp_wspace(asoc) <= 0)
9080                 return;
9081
9082         if (waitqueue_active(&asoc->wait))
9083                 wake_up_interruptible(&asoc->wait);
9084
9085         if (sctp_writeable(sk)) {
9086                 struct socket_wq *wq;
9087
9088                 rcu_read_lock();
9089                 wq = rcu_dereference(sk->sk_wq);
9090                 if (wq) {
9091                         if (waitqueue_active(&wq->wait))
9092                                 wake_up_interruptible(&wq->wait);
9093
9094                         /* Note that we try to include the Async I/O support
9095                          * here by modeling from the current TCP/UDP code.
9096                          * We have not tested with it yet.
9097                          */
9098                         if (!(sk->sk_shutdown & SEND_SHUTDOWN))
9099                                 sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
9100                 }
9101                 rcu_read_unlock();
9102         }
9103 }
9104
9105 static void sctp_wake_up_waiters(struct sock *sk,
9106                                  struct sctp_association *asoc)
9107 {
9108         struct sctp_association *tmp = asoc;
9109
9110         /* We do accounting for the sndbuf space per association,
9111          * so we only need to wake our own association.
9112          */
9113         if (asoc->ep->sndbuf_policy)
9114                 return __sctp_write_space(asoc);
9115
9116         /* If association goes down and is just flushing its
9117          * outq, then just normally notify others.
9118          */
9119         if (asoc->base.dead)
9120                 return sctp_write_space(sk);
9121
9122         /* Accounting for the sndbuf space is per socket, so we
9123          * need to wake up others, try to be fair and in case of
9124          * other associations, let them have a go first instead
9125          * of just doing a sctp_write_space() call.
9126          *
9127          * Note that we reach sctp_wake_up_waiters() only when
9128          * associations free up queued chunks, thus we are under
9129          * lock and the list of associations on a socket is
9130          * guaranteed not to change.
9131          */
9132         for (tmp = list_next_entry(tmp, asocs); 1;
9133              tmp = list_next_entry(tmp, asocs)) {
9134                 /* Manually skip the head element. */
9135                 if (&tmp->asocs == &((sctp_sk(sk))->ep->asocs))
9136                         continue;
9137                 /* Wake up association. */
9138                 __sctp_write_space(tmp);
9139                 /* We've reached the end. */
9140                 if (tmp == asoc)
9141                         break;
9142         }
9143 }
9144
9145 /* Do accounting for the sndbuf space.
9146  * Decrement the used sndbuf space of the corresponding association by the
9147  * data size which was just transmitted(freed).
9148  */
9149 static void sctp_wfree(struct sk_buff *skb)
9150 {
9151         struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
9152         struct sctp_association *asoc = chunk->asoc;
9153         struct sock *sk = asoc->base.sk;
9154
9155         sk_mem_uncharge(sk, skb->truesize);
9156         sk_wmem_queued_add(sk, -(skb->truesize + sizeof(struct sctp_chunk)));
9157         asoc->sndbuf_used -= skb->truesize + sizeof(struct sctp_chunk);
9158         WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk),
9159                                       &sk->sk_wmem_alloc));
9160
9161         if (chunk->shkey) {
9162                 struct sctp_shared_key *shkey = chunk->shkey;
9163
9164                 /* refcnt == 2 and !list_empty mean after this release, it's
9165                  * not being used anywhere, and it's time to notify userland
9166                  * that this shkey can be freed if it's been deactivated.
9167                  */
9168                 if (shkey->deactivated && !list_empty(&shkey->key_list) &&
9169                     refcount_read(&shkey->refcnt) == 2) {
9170                         struct sctp_ulpevent *ev;
9171
9172                         ev = sctp_ulpevent_make_authkey(asoc, shkey->key_id,
9173                                                         SCTP_AUTH_FREE_KEY,
9174                                                         GFP_KERNEL);
9175                         if (ev)
9176                                 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
9177                 }
9178                 sctp_auth_shkey_release(chunk->shkey);
9179         }
9180
9181         sock_wfree(skb);
9182         sctp_wake_up_waiters(sk, asoc);
9183
9184         sctp_association_put(asoc);
9185 }
9186
9187 /* Do accounting for the receive space on the socket.
9188  * Accounting for the association is done in ulpevent.c
9189  * We set this as a destructor for the cloned data skbs so that
9190  * accounting is done at the correct time.
9191  */
9192 void sctp_sock_rfree(struct sk_buff *skb)
9193 {
9194         struct sock *sk = skb->sk;
9195         struct sctp_ulpevent *event = sctp_skb2event(skb);
9196
9197         atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
9198
9199         /*
9200          * Mimic the behavior of sock_rfree
9201          */
9202         sk_mem_uncharge(sk, event->rmem_len);
9203 }
9204
9205
9206 /* Helper function to wait for space in the sndbuf.  */
9207 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
9208                                 size_t msg_len)
9209 {
9210         struct sock *sk = asoc->base.sk;
9211         long current_timeo = *timeo_p;
9212         DEFINE_WAIT(wait);
9213         int err = 0;
9214
9215         pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc,
9216                  *timeo_p, msg_len);
9217
9218         /* Increment the association's refcnt.  */
9219         sctp_association_hold(asoc);
9220
9221         /* Wait on the association specific sndbuf space. */
9222         for (;;) {
9223                 prepare_to_wait_exclusive(&asoc->wait, &wait,
9224                                           TASK_INTERRUPTIBLE);
9225                 if (asoc->base.dead)
9226                         goto do_dead;
9227                 if (!*timeo_p)
9228                         goto do_nonblock;
9229                 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING)
9230                         goto do_error;
9231                 if (signal_pending(current))
9232                         goto do_interrupted;
9233                 if ((int)msg_len <= sctp_wspace(asoc) &&
9234                     sk_wmem_schedule(sk, msg_len))
9235                         break;
9236
9237                 /* Let another process have a go.  Since we are going
9238                  * to sleep anyway.
9239                  */
9240                 release_sock(sk);
9241                 current_timeo = schedule_timeout(current_timeo);
9242                 lock_sock(sk);
9243                 if (sk != asoc->base.sk)
9244                         goto do_error;
9245
9246                 *timeo_p = current_timeo;
9247         }
9248
9249 out:
9250         finish_wait(&asoc->wait, &wait);
9251
9252         /* Release the association's refcnt.  */
9253         sctp_association_put(asoc);
9254
9255         return err;
9256
9257 do_dead:
9258         err = -ESRCH;
9259         goto out;
9260
9261 do_error:
9262         err = -EPIPE;
9263         goto out;
9264
9265 do_interrupted:
9266         err = sock_intr_errno(*timeo_p);
9267         goto out;
9268
9269 do_nonblock:
9270         err = -EAGAIN;
9271         goto out;
9272 }
9273
9274 void sctp_data_ready(struct sock *sk)
9275 {
9276         struct socket_wq *wq;
9277
9278         trace_sk_data_ready(sk);
9279
9280         rcu_read_lock();
9281         wq = rcu_dereference(sk->sk_wq);
9282         if (skwq_has_sleeper(wq))
9283                 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
9284                                                 EPOLLRDNORM | EPOLLRDBAND);
9285         sk_wake_async_rcu(sk, SOCK_WAKE_WAITD, POLL_IN);
9286         rcu_read_unlock();
9287 }
9288
9289 /* If socket sndbuf has changed, wake up all per association waiters.  */
9290 void sctp_write_space(struct sock *sk)
9291 {
9292         struct sctp_association *asoc;
9293
9294         /* Wake up the tasks in each wait queue.  */
9295         list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
9296                 __sctp_write_space(asoc);
9297         }
9298 }
9299
9300 /* Is there any sndbuf space available on the socket?
9301  *
9302  * Note that sk_wmem_alloc is the sum of the send buffers on all of the
9303  * associations on the same socket.  For a UDP-style socket with
9304  * multiple associations, it is possible for it to be "unwriteable"
9305  * prematurely.  I assume that this is acceptable because
9306  * a premature "unwriteable" is better than an accidental "writeable" which
9307  * would cause an unwanted block under certain circumstances.  For the 1-1
9308  * UDP-style sockets or TCP-style sockets, this code should work.
9309  *  - Daisy
9310  */
9311 static bool sctp_writeable(const struct sock *sk)
9312 {
9313         return READ_ONCE(sk->sk_sndbuf) > READ_ONCE(sk->sk_wmem_queued);
9314 }
9315
9316 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
9317  * returns immediately with EINPROGRESS.
9318  */
9319 static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
9320 {
9321         struct sock *sk = asoc->base.sk;
9322         int err = 0;
9323         long current_timeo = *timeo_p;
9324         DEFINE_WAIT(wait);
9325
9326         pr_debug("%s: asoc:%p, timeo:%ld\n", __func__, asoc, *timeo_p);
9327
9328         /* Increment the association's refcnt.  */
9329         sctp_association_hold(asoc);
9330
9331         for (;;) {
9332                 prepare_to_wait_exclusive(&asoc->wait, &wait,
9333                                           TASK_INTERRUPTIBLE);
9334                 if (!*timeo_p)
9335                         goto do_nonblock;
9336                 if (sk->sk_shutdown & RCV_SHUTDOWN)
9337                         break;
9338                 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
9339                     asoc->base.dead)
9340                         goto do_error;
9341                 if (signal_pending(current))
9342                         goto do_interrupted;
9343
9344                 if (sctp_state(asoc, ESTABLISHED))
9345                         break;
9346
9347                 /* Let another process have a go.  Since we are going
9348                  * to sleep anyway.
9349                  */
9350                 release_sock(sk);
9351                 current_timeo = schedule_timeout(current_timeo);
9352                 lock_sock(sk);
9353
9354                 *timeo_p = current_timeo;
9355         }
9356
9357 out:
9358         finish_wait(&asoc->wait, &wait);
9359
9360         /* Release the association's refcnt.  */
9361         sctp_association_put(asoc);
9362
9363         return err;
9364
9365 do_error:
9366         if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
9367                 err = -ETIMEDOUT;
9368         else
9369                 err = -ECONNREFUSED;
9370         goto out;
9371
9372 do_interrupted:
9373         err = sock_intr_errno(*timeo_p);
9374         goto out;
9375
9376 do_nonblock:
9377         err = -EINPROGRESS;
9378         goto out;
9379 }
9380
9381 static int sctp_wait_for_accept(struct sock *sk, long timeo)
9382 {
9383         struct sctp_endpoint *ep;
9384         int err = 0;
9385         DEFINE_WAIT(wait);
9386
9387         ep = sctp_sk(sk)->ep;
9388
9389
9390         for (;;) {
9391                 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
9392                                           TASK_INTERRUPTIBLE);
9393
9394                 if (list_empty(&ep->asocs)) {
9395                         release_sock(sk);
9396                         timeo = schedule_timeout(timeo);
9397                         lock_sock(sk);
9398                 }
9399
9400                 err = -EINVAL;
9401                 if (!sctp_sstate(sk, LISTENING) ||
9402                     (sk->sk_shutdown & RCV_SHUTDOWN))
9403                         break;
9404
9405                 err = 0;
9406                 if (!list_empty(&ep->asocs))
9407                         break;
9408
9409                 err = sock_intr_errno(timeo);
9410                 if (signal_pending(current))
9411                         break;
9412
9413                 err = -EAGAIN;
9414                 if (!timeo)
9415                         break;
9416         }
9417
9418         finish_wait(sk_sleep(sk), &wait);
9419
9420         return err;
9421 }
9422
9423 static void sctp_wait_for_close(struct sock *sk, long timeout)
9424 {
9425         DEFINE_WAIT(wait);
9426
9427         do {
9428                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
9429                 if (list_empty(&sctp_sk(sk)->ep->asocs))
9430                         break;
9431                 release_sock(sk);
9432                 timeout = schedule_timeout(timeout);
9433                 lock_sock(sk);
9434         } while (!signal_pending(current) && timeout);
9435
9436         finish_wait(sk_sleep(sk), &wait);
9437 }
9438
9439 static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
9440 {
9441         struct sk_buff *frag;
9442
9443         if (!skb->data_len)
9444                 goto done;
9445
9446         /* Don't forget the fragments. */
9447         skb_walk_frags(skb, frag)
9448                 sctp_skb_set_owner_r_frag(frag, sk);
9449
9450 done:
9451         sctp_skb_set_owner_r(skb, sk);
9452 }
9453
9454 void sctp_copy_sock(struct sock *newsk, struct sock *sk,
9455                     struct sctp_association *asoc)
9456 {
9457         struct inet_sock *inet = inet_sk(sk);
9458         struct inet_sock *newinet;
9459         struct sctp_sock *sp = sctp_sk(sk);
9460
9461         newsk->sk_type = sk->sk_type;
9462         newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
9463         newsk->sk_flags = sk->sk_flags;
9464         newsk->sk_tsflags = sk->sk_tsflags;
9465         newsk->sk_no_check_tx = sk->sk_no_check_tx;
9466         newsk->sk_no_check_rx = sk->sk_no_check_rx;
9467         newsk->sk_reuse = sk->sk_reuse;
9468         sctp_sk(newsk)->reuse = sp->reuse;
9469
9470         newsk->sk_shutdown = sk->sk_shutdown;
9471         newsk->sk_destruct = sk->sk_destruct;
9472         newsk->sk_family = sk->sk_family;
9473         newsk->sk_protocol = IPPROTO_SCTP;
9474         newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
9475         newsk->sk_sndbuf = sk->sk_sndbuf;
9476         newsk->sk_rcvbuf = sk->sk_rcvbuf;
9477         newsk->sk_lingertime = sk->sk_lingertime;
9478         newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
9479         newsk->sk_sndtimeo = sk->sk_sndtimeo;
9480         newsk->sk_rxhash = sk->sk_rxhash;
9481
9482         newinet = inet_sk(newsk);
9483
9484         /* Initialize sk's sport, dport, rcv_saddr and daddr for
9485          * getsockname() and getpeername()
9486          */
9487         newinet->inet_sport = inet->inet_sport;
9488         newinet->inet_saddr = inet->inet_saddr;
9489         newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
9490         newinet->inet_dport = htons(asoc->peer.port);
9491         newinet->pmtudisc = inet->pmtudisc;
9492         atomic_set(&newinet->inet_id, get_random_u16());
9493
9494         newinet->uc_ttl = inet->uc_ttl;
9495         inet_set_bit(MC_LOOP, newsk);
9496         newinet->mc_ttl = 1;
9497         newinet->mc_index = 0;
9498         newinet->mc_list = NULL;
9499
9500         if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
9501                 net_enable_timestamp();
9502
9503         /* Set newsk security attributes from original sk and connection
9504          * security attribute from asoc.
9505          */
9506         security_sctp_sk_clone(asoc, sk, newsk);
9507 }
9508
9509 static inline void sctp_copy_descendant(struct sock *sk_to,
9510                                         const struct sock *sk_from)
9511 {
9512         size_t ancestor_size = sizeof(struct inet_sock);
9513
9514         ancestor_size += sk_from->sk_prot->obj_size;
9515         ancestor_size -= offsetof(struct sctp_sock, pd_lobby);
9516         __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
9517 }
9518
9519 /* Populate the fields of the newsk from the oldsk and migrate the assoc
9520  * and its messages to the newsk.
9521  */
9522 static int sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
9523                              struct sctp_association *assoc,
9524                              enum sctp_socket_type type)
9525 {
9526         struct sctp_sock *oldsp = sctp_sk(oldsk);
9527         struct sctp_sock *newsp = sctp_sk(newsk);
9528         struct sctp_bind_bucket *pp; /* hash list port iterator */
9529         struct sctp_endpoint *newep = newsp->ep;
9530         struct sk_buff *skb, *tmp;
9531         struct sctp_ulpevent *event;
9532         struct sctp_bind_hashbucket *head;
9533         int err;
9534
9535         /* Migrate socket buffer sizes and all the socket level options to the
9536          * new socket.
9537          */
9538         newsk->sk_sndbuf = oldsk->sk_sndbuf;
9539         newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
9540         /* Brute force copy old sctp opt. */
9541         sctp_copy_descendant(newsk, oldsk);
9542
9543         /* Restore the ep value that was overwritten with the above structure
9544          * copy.
9545          */
9546         newsp->ep = newep;
9547         newsp->hmac = NULL;
9548
9549         /* Hook this new socket in to the bind_hash list. */
9550         head = &sctp_port_hashtable[sctp_phashfn(sock_net(oldsk),
9551                                                  inet_sk(oldsk)->inet_num)];
9552         spin_lock_bh(&head->lock);
9553         pp = sctp_sk(oldsk)->bind_hash;
9554         sk_add_bind_node(newsk, &pp->owner);
9555         sctp_sk(newsk)->bind_hash = pp;
9556         inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
9557         spin_unlock_bh(&head->lock);
9558
9559         /* Copy the bind_addr list from the original endpoint to the new
9560          * endpoint so that we can handle restarts properly
9561          */
9562         err = sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
9563                                  &oldsp->ep->base.bind_addr, GFP_KERNEL);
9564         if (err)
9565                 return err;
9566
9567         /* New ep's auth_hmacs should be set if old ep's is set, in case
9568          * that net->sctp.auth_enable has been changed to 0 by users and
9569          * new ep's auth_hmacs couldn't be set in sctp_endpoint_init().
9570          */
9571         if (oldsp->ep->auth_hmacs) {
9572                 err = sctp_auth_init_hmacs(newsp->ep, GFP_KERNEL);
9573                 if (err)
9574                         return err;
9575         }
9576
9577         sctp_auto_asconf_init(newsp);
9578
9579         /* Move any messages in the old socket's receive queue that are for the
9580          * peeled off association to the new socket's receive queue.
9581          */
9582         sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
9583                 event = sctp_skb2event(skb);
9584                 if (event->asoc == assoc) {
9585                         __skb_unlink(skb, &oldsk->sk_receive_queue);
9586                         __skb_queue_tail(&newsk->sk_receive_queue, skb);
9587                         sctp_skb_set_owner_r_frag(skb, newsk);
9588                 }
9589         }
9590
9591         /* Clean up any messages pending delivery due to partial
9592          * delivery.   Three cases:
9593          * 1) No partial deliver;  no work.
9594          * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
9595          * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
9596          */
9597         atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
9598
9599         if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
9600                 struct sk_buff_head *queue;
9601
9602                 /* Decide which queue to move pd_lobby skbs to. */
9603                 if (assoc->ulpq.pd_mode) {
9604                         queue = &newsp->pd_lobby;
9605                 } else
9606                         queue = &newsk->sk_receive_queue;
9607
9608                 /* Walk through the pd_lobby, looking for skbs that
9609                  * need moved to the new socket.
9610                  */
9611                 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
9612                         event = sctp_skb2event(skb);
9613                         if (event->asoc == assoc) {
9614                                 __skb_unlink(skb, &oldsp->pd_lobby);
9615                                 __skb_queue_tail(queue, skb);
9616                                 sctp_skb_set_owner_r_frag(skb, newsk);
9617                         }
9618                 }
9619
9620                 /* Clear up any skbs waiting for the partial
9621                  * delivery to finish.
9622                  */
9623                 if (assoc->ulpq.pd_mode)
9624                         sctp_clear_pd(oldsk, NULL);
9625
9626         }
9627
9628         sctp_for_each_rx_skb(assoc, newsk, sctp_skb_set_owner_r_frag);
9629
9630         /* Set the type of socket to indicate that it is peeled off from the
9631          * original UDP-style socket or created with the accept() call on a
9632          * TCP-style socket..
9633          */
9634         newsp->type = type;
9635
9636         /* Mark the new socket "in-use" by the user so that any packets
9637          * that may arrive on the association after we've moved it are
9638          * queued to the backlog.  This prevents a potential race between
9639          * backlog processing on the old socket and new-packet processing
9640          * on the new socket.
9641          *
9642          * The caller has just allocated newsk so we can guarantee that other
9643          * paths won't try to lock it and then oldsk.
9644          */
9645         lock_sock_nested(newsk, SINGLE_DEPTH_NESTING);
9646         sctp_for_each_tx_datachunk(assoc, true, sctp_clear_owner_w);
9647         sctp_assoc_migrate(assoc, newsk);
9648         sctp_for_each_tx_datachunk(assoc, false, sctp_set_owner_w);
9649
9650         /* If the association on the newsk is already closed before accept()
9651          * is called, set RCV_SHUTDOWN flag.
9652          */
9653         if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP)) {
9654                 inet_sk_set_state(newsk, SCTP_SS_CLOSED);
9655                 newsk->sk_shutdown |= RCV_SHUTDOWN;
9656         } else {
9657                 inet_sk_set_state(newsk, SCTP_SS_ESTABLISHED);
9658         }
9659
9660         release_sock(newsk);
9661
9662         return 0;
9663 }
9664
9665
9666 /* This proto struct describes the ULP interface for SCTP.  */
9667 struct proto sctp_prot = {
9668         .name        =  "SCTP",
9669         .owner       =  THIS_MODULE,
9670         .close       =  sctp_close,
9671         .disconnect  =  sctp_disconnect,
9672         .accept      =  sctp_accept,
9673         .ioctl       =  sctp_ioctl,
9674         .init        =  sctp_init_sock,
9675         .destroy     =  sctp_destroy_sock,
9676         .shutdown    =  sctp_shutdown,
9677         .setsockopt  =  sctp_setsockopt,
9678         .getsockopt  =  sctp_getsockopt,
9679         .bpf_bypass_getsockopt  = sctp_bpf_bypass_getsockopt,
9680         .sendmsg     =  sctp_sendmsg,
9681         .recvmsg     =  sctp_recvmsg,
9682         .bind        =  sctp_bind,
9683         .bind_add    =  sctp_bind_add,
9684         .backlog_rcv =  sctp_backlog_rcv,
9685         .hash        =  sctp_hash,
9686         .unhash      =  sctp_unhash,
9687         .no_autobind =  true,
9688         .obj_size    =  sizeof(struct sctp_sock),
9689         .useroffset  =  offsetof(struct sctp_sock, subscribe),
9690         .usersize    =  offsetof(struct sctp_sock, initmsg) -
9691                                 offsetof(struct sctp_sock, subscribe) +
9692                                 sizeof_field(struct sctp_sock, initmsg),
9693         .sysctl_mem  =  sysctl_sctp_mem,
9694         .sysctl_rmem =  sysctl_sctp_rmem,
9695         .sysctl_wmem =  sysctl_sctp_wmem,
9696         .memory_pressure = &sctp_memory_pressure,
9697         .enter_memory_pressure = sctp_enter_memory_pressure,
9698
9699         .memory_allocated = &sctp_memory_allocated,
9700         .per_cpu_fw_alloc = &sctp_memory_per_cpu_fw_alloc,
9701
9702         .sockets_allocated = &sctp_sockets_allocated,
9703 };
9704
9705 #if IS_ENABLED(CONFIG_IPV6)
9706
9707 static void sctp_v6_destruct_sock(struct sock *sk)
9708 {
9709         sctp_destruct_common(sk);
9710         inet6_sock_destruct(sk);
9711 }
9712
9713 static int sctp_v6_init_sock(struct sock *sk)
9714 {
9715         int ret = sctp_init_sock(sk);
9716
9717         if (!ret)
9718                 sk->sk_destruct = sctp_v6_destruct_sock;
9719
9720         return ret;
9721 }
9722
9723 struct proto sctpv6_prot = {
9724         .name           = "SCTPv6",
9725         .owner          = THIS_MODULE,
9726         .close          = sctp_close,
9727         .disconnect     = sctp_disconnect,
9728         .accept         = sctp_accept,
9729         .ioctl          = sctp_ioctl,
9730         .init           = sctp_v6_init_sock,
9731         .destroy        = sctp_destroy_sock,
9732         .shutdown       = sctp_shutdown,
9733         .setsockopt     = sctp_setsockopt,
9734         .getsockopt     = sctp_getsockopt,
9735         .bpf_bypass_getsockopt  = sctp_bpf_bypass_getsockopt,
9736         .sendmsg        = sctp_sendmsg,
9737         .recvmsg        = sctp_recvmsg,
9738         .bind           = sctp_bind,
9739         .bind_add       = sctp_bind_add,
9740         .backlog_rcv    = sctp_backlog_rcv,
9741         .hash           = sctp_hash,
9742         .unhash         = sctp_unhash,
9743         .no_autobind    = true,
9744         .obj_size       = sizeof(struct sctp6_sock),
9745         .ipv6_pinfo_offset = offsetof(struct sctp6_sock, inet6),
9746         .useroffset     = offsetof(struct sctp6_sock, sctp.subscribe),
9747         .usersize       = offsetof(struct sctp6_sock, sctp.initmsg) -
9748                                 offsetof(struct sctp6_sock, sctp.subscribe) +
9749                                 sizeof_field(struct sctp6_sock, sctp.initmsg),
9750         .sysctl_mem     = sysctl_sctp_mem,
9751         .sysctl_rmem    = sysctl_sctp_rmem,
9752         .sysctl_wmem    = sysctl_sctp_wmem,
9753         .memory_pressure = &sctp_memory_pressure,
9754         .enter_memory_pressure = sctp_enter_memory_pressure,
9755
9756         .memory_allocated = &sctp_memory_allocated,
9757         .per_cpu_fw_alloc = &sctp_memory_per_cpu_fw_alloc,
9758
9759         .sockets_allocated = &sctp_sockets_allocated,
9760 };
9761 #endif /* IS_ENABLED(CONFIG_IPV6) */