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