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