net/sctp/socket.c

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