linux/net/sctp/socket.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* SCTP kernel implementation
   3 * (C) Copyright IBM Corp. 2001, 2004
   4 * Copyright (c) 1999-2000 Cisco, Inc.
   5 * Copyright (c) 1999-2001 Motorola, Inc.
   6 * Copyright (c) 2001-2003 Intel Corp.
   7 * Copyright (c) 2001-2002 Nokia, Inc.
   8 * Copyright (c) 2001 La Monte H.P. Yarroll
   9 *
  10 * This file is part of the SCTP kernel implementation
  11 *
  12 * These functions interface with the sockets layer to implement the
  13 * SCTP Extensions for the Sockets API.
  14 *
  15 * Note that the descriptions from the specification are USER level
  16 * functions--this file is the functions which populate the struct proto
  17 * for SCTP which is the BOTTOM of the sockets interface.
  18 *
  19 * Please send any bug reports or fixes you make to the
  20 * email address(es):
  21 *    lksctp developers <linux-sctp@vger.kernel.org>
  22 *
  23 * Written or modified by:
  24 *    La Monte H.P. Yarroll <piggy@acm.org>
  25 *    Narasimha Budihal     <narsi@refcode.org>
  26 *    Karl Knutson          <karl@athena.chicago.il.us>
  27 *    Jon Grimm             <jgrimm@us.ibm.com>
  28 *    Xingang Guo           <xingang.guo@intel.com>
  29 *    Daisy Chang           <daisyc@us.ibm.com>
  30 *    Sridhar Samudrala     <samudrala@us.ibm.com>
  31 *    Inaky Perez-Gonzalez  <inaky.gonzalez@intel.com>
  32 *    Ardelle Fan           <ardelle.fan@intel.com>
  33 *    Ryan Layer            <rmlayer@us.ibm.com>
  34 *    Anup Pemmaiah         <pemmaiah@cc.usu.edu>
  35 *    Kevin Gao             <kevin.gao@intel.com>
  36 */
  37
  38#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  39
  40#include <crypto/hash.h>
  41#include <linux/types.h>
  42#include <linux/kernel.h>
  43#include <linux/wait.h>
  44#include <linux/time.h>
  45#include <linux/sched/signal.h>
  46#include <linux/ip.h>
  47#include <linux/capability.h>
  48#include <linux/fcntl.h>
  49#include <linux/poll.h>
  50#include <linux/init.h>
  51#include <linux/slab.h>
  52#include <linux/file.h>
  53#include <linux/compat.h>
  54#include <linux/rhashtable.h>
  55
  56#include <net/ip.h>
  57#include <net/icmp.h>
  58#include <net/route.h>
  59#include <net/ipv6.h>
  60#include <net/inet_common.h>
  61#include <net/busy_poll.h>
  62
  63#include <linux/socket.h> /* for sa_family_t */
  64#include <linux/export.h>
  65#include <net/sock.h>
  66#include <net/sctp/sctp.h>
  67#include <net/sctp/sm.h>
  68#include <net/sctp/stream_sched.h>
  69
  70/* Forward declarations for internal helper functions. */
  71static bool sctp_writeable(struct sock *sk);
  72static void sctp_wfree(struct sk_buff *skb);
  73static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
  74                                size_t msg_len);
  75static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);
  76static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
  77static int sctp_wait_for_accept(struct sock *sk, long timeo);
  78static void sctp_wait_for_close(struct sock *sk, long timeo);
  79static void sctp_destruct_sock(struct sock *sk);
  80static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
  81                                        union sctp_addr *addr, int len);
  82static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
  83static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
  84static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
  85static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
  86static int sctp_send_asconf(struct sctp_association *asoc,
  87                            struct sctp_chunk *chunk);
  88static int sctp_do_bind(struct sock *, union sctp_addr *, int);
  89static int sctp_autobind(struct sock *sk);
  90static int sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
  91                             struct sctp_association *assoc,
  92                             enum sctp_socket_type type);
  93
  94static unsigned long sctp_memory_pressure;
  95static atomic_long_t sctp_memory_allocated;
  96struct percpu_counter sctp_sockets_allocated;
  97
  98static void sctp_enter_memory_pressure(struct sock *sk)
  99{
 100        sctp_memory_pressure = 1;
 101}
 102
 103
 104/* Get the sndbuf space available at the time on the association.  */
 105static inline int sctp_wspace(struct sctp_association *asoc)
 106{
 107        struct sock *sk = asoc->base.sk;
 108
 109        return asoc->ep->sndbuf_policy ? sk->sk_sndbuf - asoc->sndbuf_used
 110                                       : sk_stream_wspace(sk);
 111}
 112
 113/* Increment the used sndbuf space count of the corresponding association by
 114 * the size of the outgoing data chunk.
 115 * Also, set the skb destructor for sndbuf accounting later.
 116 *
 117 * Since it is always 1-1 between chunk and skb, and also a new skb is always
 118 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
 119 * destructor in the data chunk skb for the purpose of the sndbuf space
 120 * tracking.
 121 */
 122static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
 123{
 124        struct sctp_association *asoc = chunk->asoc;
 125        struct sock *sk = asoc->base.sk;
 126
 127        /* The sndbuf space is tracked per association.  */
 128        sctp_association_hold(asoc);
 129
 130        if (chunk->shkey)
 131                sctp_auth_shkey_hold(chunk->shkey);
 132
 133        skb_set_owner_w(chunk->skb, sk);
 134
 135        chunk->skb->destructor = sctp_wfree;
 136        /* Save the chunk pointer in skb for sctp_wfree to use later.  */
 137        skb_shinfo(chunk->skb)->destructor_arg = chunk;
 138
 139        refcount_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
 140        asoc->sndbuf_used += chunk->skb->truesize + sizeof(struct sctp_chunk);
 141        sk->sk_wmem_queued += chunk->skb->truesize + sizeof(struct sctp_chunk);
 142        sk_mem_charge(sk, chunk->skb->truesize);
 143}
 144
 145static void sctp_clear_owner_w(struct sctp_chunk *chunk)
 146{
 147        skb_orphan(chunk->skb);
 148}
 149
 150static void sctp_for_each_tx_datachunk(struct sctp_association *asoc,
 151                                       void (*cb)(struct sctp_chunk *))
 152
 153{
 154        struct sctp_outq *q = &asoc->outqueue;
 155        struct sctp_transport *t;
 156        struct sctp_chunk *chunk;
 157
 158        list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
 159                list_for_each_entry(chunk, &t->transmitted, transmitted_list)
 160                        cb(chunk);
 161
 162        list_for_each_entry(chunk, &q->retransmit, transmitted_list)
 163                cb(chunk);
 164
 165        list_for_each_entry(chunk, &q->sacked, transmitted_list)
 166                cb(chunk);
 167
 168        list_for_each_entry(chunk, &q->abandoned, transmitted_list)
 169                cb(chunk);
 170
 171        list_for_each_entry(chunk, &q->out_chunk_list, list)
 172                cb(chunk);
 173}
 174
 175static void sctp_for_each_rx_skb(struct sctp_association *asoc, struct sock *sk,
 176                                 void (*cb)(struct sk_buff *, struct sock *))
 177
 178{
 179        struct sk_buff *skb, *tmp;
 180
 181        sctp_skb_for_each(skb, &asoc->ulpq.lobby, tmp)
 182                cb(skb, sk);
 183
 184        sctp_skb_for_each(skb, &asoc->ulpq.reasm, tmp)
 185                cb(skb, sk);
 186
 187        sctp_skb_for_each(skb, &asoc->ulpq.reasm_uo, tmp)
 188                cb(skb, sk);
 189}
 190
 191/* Verify that this is a valid address. */
 192static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
 193                                   int len)
 194{
 195        struct sctp_af *af;
 196
 197        /* Verify basic sockaddr. */
 198        af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
 199        if (!af)
 200                return -EINVAL;
 201
 202        /* Is this a valid SCTP address?  */
 203        if (!af->addr_valid(addr, sctp_sk(sk), NULL))
 204                return -EINVAL;
 205
 206        if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
 207                return -EINVAL;
 208
 209        return 0;
 210}
 211
 212/* Look up the association by its id.  If this is not a UDP-style
 213 * socket, the ID field is always ignored.
 214 */
 215struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
 216{
 217        struct sctp_association *asoc = NULL;
 218
 219        /* If this is not a UDP-style socket, assoc id should be ignored. */
 220        if (!sctp_style(sk, UDP)) {
 221                /* Return NULL if the socket state is not ESTABLISHED. It
 222                 * could be a TCP-style listening socket or a socket which
 223                 * hasn't yet called connect() to establish an association.
 224                 */
 225                if (!sctp_sstate(sk, ESTABLISHED) && !sctp_sstate(sk, CLOSING))
 226                        return NULL;
 227
 228                /* Get the first and the only association from the list. */
 229                if (!list_empty(&sctp_sk(sk)->ep->asocs))
 230                        asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
 231                                          struct sctp_association, asocs);
 232                return asoc;
 233        }
 234
 235        /* Otherwise this is a UDP-style socket. */
 236        if (id <= SCTP_ALL_ASSOC)
 237                return NULL;
 238
 239        spin_lock_bh(&sctp_assocs_id_lock);
 240        asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
 241        if (asoc && (asoc->base.sk != sk || asoc->base.dead))
 242                asoc = NULL;
 243        spin_unlock_bh(&sctp_assocs_id_lock);
 244
 245        return asoc;
 246}
 247
 248/* Look up the transport from an address and an assoc id. If both address and
 249 * id are specified, the associations matching the address and the id should be
 250 * the same.
 251 */
 252static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
 253                                              struct sockaddr_storage *addr,
 254                                              sctp_assoc_t id)
 255{
 256        struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
 257        struct sctp_af *af = sctp_get_af_specific(addr->ss_family);
 258        union sctp_addr *laddr = (union sctp_addr *)addr;
 259        struct sctp_transport *transport;
 260
 261        if (!af || sctp_verify_addr(sk, laddr, af->sockaddr_len))
 262                return NULL;
 263
 264        addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
 265                                               laddr,
 266                                               &transport);
 267
 268        if (!addr_asoc)
 269                return NULL;
 270
 271        id_asoc = sctp_id2assoc(sk, id);
 272        if (id_asoc && (id_asoc != addr_asoc))
 273                return NULL;
 274
 275        sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
 276                                                (union sctp_addr *)addr);
 277
 278        return transport;
 279}
 280
 281/* API 3.1.2 bind() - UDP Style Syntax
 282 * The syntax of bind() is,
 283 *
 284 *   ret = bind(int sd, struct sockaddr *addr, int addrlen);
 285 *
 286 *   sd      - the socket descriptor returned by socket().
 287 *   addr    - the address structure (struct sockaddr_in or struct
 288 *             sockaddr_in6 [RFC 2553]),
 289 *   addr_len - the size of the address structure.
 290 */
 291static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
 292{
 293        int retval = 0;
 294
 295        lock_sock(sk);
 296
 297        pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk,
 298                 addr, addr_len);
 299
 300        /* Disallow binding twice. */
 301        if (!sctp_sk(sk)->ep->base.bind_addr.port)
 302                retval = sctp_do_bind(sk, (union sctp_addr *)addr,
 303                                      addr_len);
 304        else
 305                retval = -EINVAL;
 306
 307        release_sock(sk);
 308
 309        return retval;
 310}
 311
 312static int sctp_get_port_local(struct sock *, union sctp_addr *);
 313
 314/* Verify this is a valid sockaddr. */
 315static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
 316                                        union sctp_addr *addr, int len)
 317{
 318        struct sctp_af *af;
 319
 320        /* Check minimum size.  */
 321        if (len < sizeof (struct sockaddr))
 322                return NULL;
 323
 324        if (!opt->pf->af_supported(addr->sa.sa_family, opt))
 325                return NULL;
 326
 327        if (addr->sa.sa_family == AF_INET6) {
 328                if (len < SIN6_LEN_RFC2133)
 329                        return NULL;
 330                /* V4 mapped address are really of AF_INET family */
 331                if (ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
 332                    !opt->pf->af_supported(AF_INET, opt))
 333                        return NULL;
 334        }
 335
 336        /* If we get this far, af is valid. */
 337        af = sctp_get_af_specific(addr->sa.sa_family);
 338
 339        if (len < af->sockaddr_len)
 340                return NULL;
 341
 342        return af;
 343}
 344
 345/* Bind a local address either to an endpoint or to an association.  */
 346static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
 347{
 348        struct net *net = sock_net(sk);
 349        struct sctp_sock *sp = sctp_sk(sk);
 350        struct sctp_endpoint *ep = sp->ep;
 351        struct sctp_bind_addr *bp = &ep->base.bind_addr;
 352        struct sctp_af *af;
 353        unsigned short snum;
 354        int ret = 0;
 355
 356        /* Common sockaddr verification. */
 357        af = sctp_sockaddr_af(sp, addr, len);
 358        if (!af) {
 359                pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
 360                         __func__, sk, addr, len);
 361                return -EINVAL;
 362        }
 363
 364        snum = ntohs(addr->v4.sin_port);
 365
 366        pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
 367                 __func__, sk, &addr->sa, bp->port, snum, len);
 368
 369        /* PF specific bind() address verification. */
 370        if (!sp->pf->bind_verify(sp, addr))
 371                return -EADDRNOTAVAIL;
 372
 373        /* We must either be unbound, or bind to the same port.
 374         * It's OK to allow 0 ports if we are already bound.
 375         * We'll just inhert an already bound port in this case
 376         */
 377        if (bp->port) {
 378                if (!snum)
 379                        snum = bp->port;
 380                else if (snum != bp->port) {
 381                        pr_debug("%s: new port %d doesn't match existing port "
 382                                 "%d\n", __func__, snum, bp->port);
 383                        return -EINVAL;
 384                }
 385        }
 386
 387        if (snum && snum < inet_prot_sock(net) &&
 388            !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
 389                return -EACCES;
 390
 391        /* See if the address matches any of the addresses we may have
 392         * already bound before checking against other endpoints.
 393         */
 394        if (sctp_bind_addr_match(bp, addr, sp))
 395                return -EINVAL;
 396
 397        /* Make sure we are allowed to bind here.
 398         * The function sctp_get_port_local() does duplicate address
 399         * detection.
 400         */
 401        addr->v4.sin_port = htons(snum);
 402        if (sctp_get_port_local(sk, addr))
 403                return -EADDRINUSE;
 404
 405        /* Refresh ephemeral port.  */
 406        if (!bp->port)
 407                bp->port = inet_sk(sk)->inet_num;
 408
 409        /* Add the address to the bind address list.
 410         * Use GFP_ATOMIC since BHs will be disabled.
 411         */
 412        ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
 413                                 SCTP_ADDR_SRC, GFP_ATOMIC);
 414
 415        if (ret) {
 416                sctp_put_port(sk);
 417                return ret;
 418        }
 419        /* Copy back into socket for getsockname() use. */
 420        inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
 421        sp->pf->to_sk_saddr(addr, sk);
 422
 423        return ret;
 424}
 425
 426 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
 427 *
 428 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
 429 * at any one time.  If a sender, after sending an ASCONF chunk, decides
 430 * it needs to transfer another ASCONF Chunk, it MUST wait until the
 431 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
 432 * subsequent ASCONF. Note this restriction binds each side, so at any
 433 * time two ASCONF may be in-transit on any given association (one sent
 434 * from each endpoint).
 435 */
 436static int sctp_send_asconf(struct sctp_association *asoc,
 437                            struct sctp_chunk *chunk)
 438{
 439        struct net      *net = sock_net(asoc->base.sk);
 440        int             retval = 0;
 441
 442        /* If there is an outstanding ASCONF chunk, queue it for later
 443         * transmission.
 444         */
 445        if (asoc->addip_last_asconf) {
 446                list_add_tail(&chunk->list, &asoc->addip_chunk_list);
 447                goto out;
 448        }
 449
 450        /* Hold the chunk until an ASCONF_ACK is received. */
 451        sctp_chunk_hold(chunk);
 452        retval = sctp_primitive_ASCONF(net, asoc, chunk);
 453        if (retval)
 454                sctp_chunk_free(chunk);
 455        else
 456                asoc->addip_last_asconf = chunk;
 457
 458out:
 459        return retval;
 460}
 461
 462/* Add a list of addresses as bind addresses to local endpoint or
 463 * association.
 464 *
 465 * Basically run through each address specified in the addrs/addrcnt
 466 * array/length pair, determine if it is IPv6 or IPv4 and call
 467 * sctp_do_bind() on it.
 468 *
 469 * If any of them fails, then the operation will be reversed and the
 470 * ones that were added will be removed.
 471 *
 472 * Only sctp_setsockopt_bindx() is supposed to call this function.
 473 */
 474static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
 475{
 476        int cnt;
 477        int retval = 0;
 478        void *addr_buf;
 479        struct sockaddr *sa_addr;
 480        struct sctp_af *af;
 481
 482        pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk,
 483                 addrs, addrcnt);
 484
 485        addr_buf = addrs;
 486        for (cnt = 0; cnt < addrcnt; cnt++) {
 487                /* The list may contain either IPv4 or IPv6 address;
 488                 * determine the address length for walking thru the list.
 489                 */
 490                sa_addr = addr_buf;
 491                af = sctp_get_af_specific(sa_addr->sa_family);
 492                if (!af) {
 493                        retval = -EINVAL;
 494                        goto err_bindx_add;
 495                }
 496
 497                retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
 498                                      af->sockaddr_len);
 499
 500                addr_buf += af->sockaddr_len;
 501
 502err_bindx_add:
 503                if (retval < 0) {
 504                        /* Failed. Cleanup the ones that have been added */
 505                        if (cnt > 0)
 506                                sctp_bindx_rem(sk, addrs, cnt);
 507                        return retval;
 508                }
 509        }
 510
 511        return retval;
 512}
 513
 514/* Send an ASCONF chunk with Add IP address parameters to all the peers of the
 515 * associations that are part of the endpoint indicating that a list of local
 516 * addresses are added to the endpoint.
 517 *
 518 * If any of the addresses is already in the bind address list of the
 519 * association, we do not send the chunk for that association.  But it will not
 520 * affect other associations.
 521 *
 522 * Only sctp_setsockopt_bindx() is supposed to call this function.
 523 */
 524static int sctp_send_asconf_add_ip(struct sock          *sk,
 525                                   struct sockaddr      *addrs,
 526                                   int                  addrcnt)
 527{
 528        struct sctp_sock                *sp;
 529        struct sctp_endpoint            *ep;
 530        struct sctp_association         *asoc;
 531        struct sctp_bind_addr           *bp;
 532        struct sctp_chunk               *chunk;
 533        struct sctp_sockaddr_entry      *laddr;
 534        union sctp_addr                 *addr;
 535        union sctp_addr                 saveaddr;
 536        void                            *addr_buf;
 537        struct sctp_af                  *af;
 538        struct list_head                *p;
 539        int                             i;
 540        int                             retval = 0;
 541
 542        sp = sctp_sk(sk);
 543        ep = sp->ep;
 544
 545        if (!ep->asconf_enable)
 546                return retval;
 547
 548        pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
 549                 __func__, sk, addrs, addrcnt);
 550
 551        list_for_each_entry(asoc, &ep->asocs, asocs) {
 552                if (!asoc->peer.asconf_capable)
 553                        continue;
 554
 555                if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
 556                        continue;
 557
 558                if (!sctp_state(asoc, ESTABLISHED))
 559                        continue;
 560
 561                /* Check if any address in the packed array of addresses is
 562                 * in the bind address list of the association. If so,
 563                 * do not send the asconf chunk to its peer, but continue with
 564                 * other associations.
 565                 */
 566                addr_buf = addrs;
 567                for (i = 0; i < addrcnt; i++) {
 568                        addr = addr_buf;
 569                        af = sctp_get_af_specific(addr->v4.sin_family);
 570                        if (!af) {
 571                                retval = -EINVAL;
 572                                goto out;
 573                        }
 574
 575                        if (sctp_assoc_lookup_laddr(asoc, addr))
 576                                break;
 577
 578                        addr_buf += af->sockaddr_len;
 579                }
 580                if (i < addrcnt)
 581                        continue;
 582
 583                /* Use the first valid address in bind addr list of
 584                 * association as Address Parameter of ASCONF CHUNK.
 585                 */
 586                bp = &asoc->base.bind_addr;
 587                p = bp->address_list.next;
 588                laddr = list_entry(p, struct sctp_sockaddr_entry, list);
 589                chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
 590                                                   addrcnt, SCTP_PARAM_ADD_IP);
 591                if (!chunk) {
 592                        retval = -ENOMEM;
 593                        goto out;
 594                }
 595
 596                /* Add the new addresses to the bind address list with
 597                 * use_as_src set to 0.
 598                 */
 599                addr_buf = addrs;
 600                for (i = 0; i < addrcnt; i++) {
 601                        addr = addr_buf;
 602                        af = sctp_get_af_specific(addr->v4.sin_family);
 603                        memcpy(&saveaddr, addr, af->sockaddr_len);
 604                        retval = sctp_add_bind_addr(bp, &saveaddr,
 605                                                    sizeof(saveaddr),
 606                                                    SCTP_ADDR_NEW, GFP_ATOMIC);
 607                        addr_buf += af->sockaddr_len;
 608                }
 609                if (asoc->src_out_of_asoc_ok) {
 610                        struct sctp_transport *trans;
 611
 612                        list_for_each_entry(trans,
 613                            &asoc->peer.transport_addr_list, transports) {
 614                                trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
 615                                    2*asoc->pathmtu, 4380));
 616                                trans->ssthresh = asoc->peer.i.a_rwnd;
 617                                trans->rto = asoc->rto_initial;
 618                                sctp_max_rto(asoc, trans);
 619                                trans->rtt = trans->srtt = trans->rttvar = 0;
 620                                /* Clear the source and route cache */
 621                                sctp_transport_route(trans, NULL,
 622                                                     sctp_sk(asoc->base.sk));
 623                        }
 624                }
 625                retval = sctp_send_asconf(asoc, chunk);
 626        }
 627
 628out:
 629        return retval;
 630}
 631
 632/* Remove a list of addresses from bind addresses list.  Do not remove the
 633 * last address.
 634 *
 635 * Basically run through each address specified in the addrs/addrcnt
 636 * array/length pair, determine if it is IPv6 or IPv4 and call
 637 * sctp_del_bind() on it.
 638 *
 639 * If any of them fails, then the operation will be reversed and the
 640 * ones that were removed will be added back.
 641 *
 642 * At least one address has to be left; if only one address is
 643 * available, the operation will return -EBUSY.
 644 *
 645 * Only sctp_setsockopt_bindx() is supposed to call this function.
 646 */
 647static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
 648{
 649        struct sctp_sock *sp = sctp_sk(sk);
 650        struct sctp_endpoint *ep = sp->ep;
 651        int cnt;
 652        struct sctp_bind_addr *bp = &ep->base.bind_addr;
 653        int retval = 0;
 654        void *addr_buf;
 655        union sctp_addr *sa_addr;
 656        struct sctp_af *af;
 657
 658        pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
 659                 __func__, sk, addrs, addrcnt);
 660
 661        addr_buf = addrs;
 662        for (cnt = 0; cnt < addrcnt; cnt++) {
 663                /* If the bind address list is empty or if there is only one
 664                 * bind address, there is nothing more to be removed (we need
 665                 * at least one address here).
 666                 */
 667                if (list_empty(&bp->address_list) ||
 668                    (sctp_list_single_entry(&bp->address_list))) {
 669                        retval = -EBUSY;
 670                        goto err_bindx_rem;
 671                }
 672
 673                sa_addr = addr_buf;
 674                af = sctp_get_af_specific(sa_addr->sa.sa_family);
 675                if (!af) {
 676                        retval = -EINVAL;
 677                        goto err_bindx_rem;
 678                }
 679
 680                if (!af->addr_valid(sa_addr, sp, NULL)) {
 681                        retval = -EADDRNOTAVAIL;
 682                        goto err_bindx_rem;
 683                }
 684
 685                if (sa_addr->v4.sin_port &&
 686                    sa_addr->v4.sin_port != htons(bp->port)) {
 687                        retval = -EINVAL;
 688                        goto err_bindx_rem;
 689                }
 690
 691                if (!sa_addr->v4.sin_port)
 692                        sa_addr->v4.sin_port = htons(bp->port);
 693
 694                /* FIXME - There is probably a need to check if sk->sk_saddr and
 695                 * sk->sk_rcv_addr are currently set to one of the addresses to
 696                 * be removed. This is something which needs to be looked into
 697                 * when we are fixing the outstanding issues with multi-homing
 698                 * socket routing and failover schemes. Refer to comments in
 699                 * sctp_do_bind(). -daisy
 700                 */
 701                retval = sctp_del_bind_addr(bp, sa_addr);
 702
 703                addr_buf += af->sockaddr_len;
 704err_bindx_rem:
 705                if (retval < 0) {
 706                        /* Failed. Add the ones that has been removed back */
 707                        if (cnt > 0)
 708                                sctp_bindx_add(sk, addrs, cnt);
 709                        return retval;
 710                }
 711        }
 712
 713        return retval;
 714}
 715
 716/* Send an ASCONF chunk with Delete IP address parameters to all the peers of
 717 * the associations that are part of the endpoint indicating that a list of
 718 * local addresses are removed from the endpoint.
 719 *
 720 * If any of the addresses is already in the bind address list of the
 721 * association, we do not send the chunk for that association.  But it will not
 722 * affect other associations.
 723 *
 724 * Only sctp_setsockopt_bindx() is supposed to call this function.
 725 */
 726static int sctp_send_asconf_del_ip(struct sock          *sk,
 727                                   struct sockaddr      *addrs,
 728                                   int                  addrcnt)
 729{
 730        struct sctp_sock        *sp;
 731        struct sctp_endpoint    *ep;
 732        struct sctp_association *asoc;
 733        struct sctp_transport   *transport;
 734        struct sctp_bind_addr   *bp;
 735        struct sctp_chunk       *chunk;
 736        union sctp_addr         *laddr;
 737        void                    *addr_buf;
 738        struct sctp_af          *af;
 739        struct sctp_sockaddr_entry *saddr;
 740        int                     i;
 741        int                     retval = 0;
 742        int                     stored = 0;
 743
 744        chunk = NULL;
 745        sp = sctp_sk(sk);
 746        ep = sp->ep;
 747
 748        if (!ep->asconf_enable)
 749                return retval;
 750
 751        pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
 752                 __func__, sk, addrs, addrcnt);
 753
 754        list_for_each_entry(asoc, &ep->asocs, asocs) {
 755
 756                if (!asoc->peer.asconf_capable)
 757                        continue;
 758
 759                if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
 760                        continue;
 761
 762                if (!sctp_state(asoc, ESTABLISHED))
 763                        continue;
 764
 765                /* Check if any address in the packed array of addresses is
 766                 * not present in the bind address list of the association.
 767                 * If so, do not send the asconf chunk to its peer, but
 768                 * continue with other associations.
 769                 */
 770                addr_buf = addrs;
 771                for (i = 0; i < addrcnt; i++) {
 772                        laddr = addr_buf;
 773                        af = sctp_get_af_specific(laddr->v4.sin_family);
 774                        if (!af) {
 775                                retval = -EINVAL;
 776                                goto out;
 777                        }
 778
 779                        if (!sctp_assoc_lookup_laddr(asoc, laddr))
 780                                break;
 781
 782                        addr_buf += af->sockaddr_len;
 783                }
 784                if (i < addrcnt)
 785                        continue;
 786
 787                /* Find one address in the association's bind address list
 788                 * that is not in the packed array of addresses. This is to
 789                 * make sure that we do not delete all the addresses in the
 790                 * association.
 791                 */
 792                bp = &asoc->base.bind_addr;
 793                laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
 794                                               addrcnt, sp);
 795                if ((laddr == NULL) && (addrcnt == 1)) {
 796                        if (asoc->asconf_addr_del_pending)
 797                                continue;
 798                        asoc->asconf_addr_del_pending =
 799                            kzalloc(sizeof(union sctp_addr), GFP_ATOMIC);
 800                        if (asoc->asconf_addr_del_pending == NULL) {
 801                                retval = -ENOMEM;
 802                                goto out;
 803                        }
 804                        asoc->asconf_addr_del_pending->sa.sa_family =
 805                                    addrs->sa_family;
 806                        asoc->asconf_addr_del_pending->v4.sin_port =
 807                                    htons(bp->port);
 808                        if (addrs->sa_family == AF_INET) {
 809                                struct sockaddr_in *sin;
 810
 811                                sin = (struct sockaddr_in *)addrs;
 812                                asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
 813                        } else if (addrs->sa_family == AF_INET6) {
 814                                struct sockaddr_in6 *sin6;
 815
 816                                sin6 = (struct sockaddr_in6 *)addrs;
 817                                asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
 818                        }
 819
 820                        pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
 821                                 __func__, asoc, &asoc->asconf_addr_del_pending->sa,
 822                                 asoc->asconf_addr_del_pending);
 823
 824                        asoc->src_out_of_asoc_ok = 1;
 825                        stored = 1;
 826                        goto skip_mkasconf;
 827                }
 828
 829                if (laddr == NULL)
 830                        return -EINVAL;
 831
 832                /* We do not need RCU protection throughout this loop
 833                 * because this is done under a socket lock from the
 834                 * setsockopt call.
 835                 */
 836                chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
 837                                                   SCTP_PARAM_DEL_IP);
 838                if (!chunk) {
 839                        retval = -ENOMEM;
 840                        goto out;
 841                }
 842
 843skip_mkasconf:
 844                /* Reset use_as_src flag for the addresses in the bind address
 845                 * list that are to be deleted.
 846                 */
 847                addr_buf = addrs;
 848                for (i = 0; i < addrcnt; i++) {
 849                        laddr = addr_buf;
 850                        af = sctp_get_af_specific(laddr->v4.sin_family);
 851                        list_for_each_entry(saddr, &bp->address_list, list) {
 852                                if (sctp_cmp_addr_exact(&saddr->a, laddr))
 853                                        saddr->state = SCTP_ADDR_DEL;
 854                        }
 855                        addr_buf += af->sockaddr_len;
 856                }
 857
 858                /* Update the route and saddr entries for all the transports
 859                 * as some of the addresses in the bind address list are
 860                 * about to be deleted and cannot be used as source addresses.
 861                 */
 862                list_for_each_entry(transport, &asoc->peer.transport_addr_list,
 863                                        transports) {
 864                        sctp_transport_route(transport, NULL,
 865                                             sctp_sk(asoc->base.sk));
 866                }
 867
 868                if (stored)
 869                        /* We don't need to transmit ASCONF */
 870                        continue;
 871                retval = sctp_send_asconf(asoc, chunk);
 872        }
 873out:
 874        return retval;
 875}
 876
 877/* set addr events to assocs in the endpoint.  ep and addr_wq must be locked */
 878int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
 879{
 880        struct sock *sk = sctp_opt2sk(sp);
 881        union sctp_addr *addr;
 882        struct sctp_af *af;
 883
 884        /* It is safe to write port space in caller. */
 885        addr = &addrw->a;
 886        addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
 887        af = sctp_get_af_specific(addr->sa.sa_family);
 888        if (!af)
 889                return -EINVAL;
 890        if (sctp_verify_addr(sk, addr, af->sockaddr_len))
 891                return -EINVAL;
 892
 893        if (addrw->state == SCTP_ADDR_NEW)
 894                return sctp_send_asconf_add_ip(sk, (struct sockaddr *)addr, 1);
 895        else
 896                return sctp_send_asconf_del_ip(sk, (struct sockaddr *)addr, 1);
 897}
 898
 899/* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
 900 *
 901 * API 8.1
 902 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
 903 *                int flags);
 904 *
 905 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
 906 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
 907 * or IPv6 addresses.
 908 *
 909 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
 910 * Section 3.1.2 for this usage.
 911 *
 912 * addrs is a pointer to an array of one or more socket addresses. Each
 913 * address is contained in its appropriate structure (i.e. struct
 914 * sockaddr_in or struct sockaddr_in6) the family of the address type
 915 * must be used to distinguish the address length (note that this
 916 * representation is termed a "packed array" of addresses). The caller
 917 * specifies the number of addresses in the array with addrcnt.
 918 *
 919 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
 920 * -1, and sets errno to the appropriate error code.
 921 *
 922 * For SCTP, the port given in each socket address must be the same, or
 923 * sctp_bindx() will fail, setting errno to EINVAL.
 924 *
 925 * The flags parameter is formed from the bitwise OR of zero or more of
 926 * the following currently defined flags:
 927 *
 928 * SCTP_BINDX_ADD_ADDR
 929 *
 930 * SCTP_BINDX_REM_ADDR
 931 *
 932 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
 933 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
 934 * addresses from the association. The two flags are mutually exclusive;
 935 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
 936 * not remove all addresses from an association; sctp_bindx() will
 937 * reject such an attempt with EINVAL.
 938 *
 939 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
 940 * additional addresses with an endpoint after calling bind().  Or use
 941 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
 942 * socket is associated with so that no new association accepted will be
 943 * associated with those addresses. If the endpoint supports dynamic
 944 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
 945 * endpoint to send the appropriate message to the peer to change the
 946 * peers address lists.
 947 *
 948 * Adding and removing addresses from a connected association is
 949 * optional functionality. Implementations that do not support this
 950 * functionality should return EOPNOTSUPP.
 951 *
 952 * Basically do nothing but copying the addresses from user to kernel
 953 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
 954 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
 955 * from userspace.
 956 *
 957 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
 958 * it.
 959 *
 960 * sk        The sk of the socket
 961 * addrs     The pointer to the addresses in user land
 962 * addrssize Size of the addrs buffer
 963 * op        Operation to perform (add or remove, see the flags of
 964 *           sctp_bindx)
 965 *
 966 * Returns 0 if ok, <0 errno code on error.
 967 */
 968static int sctp_setsockopt_bindx(struct sock *sk,
 969                                 struct sockaddr __user *addrs,
 970                                 int addrs_size, int op)
 971{
 972        struct sockaddr *kaddrs;
 973        int err;
 974        int addrcnt = 0;
 975        int walk_size = 0;
 976        struct sockaddr *sa_addr;
 977        void *addr_buf;
 978        struct sctp_af *af;
 979
 980        pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
 981                 __func__, sk, addrs, addrs_size, op);
 982
 983        if (unlikely(addrs_size <= 0))
 984                return -EINVAL;
 985
 986        kaddrs = memdup_user(addrs, addrs_size);
 987        if (IS_ERR(kaddrs))
 988                return PTR_ERR(kaddrs);
 989
 990        /* Walk through the addrs buffer and count the number of addresses. */
 991        addr_buf = kaddrs;
 992        while (walk_size < addrs_size) {
 993                if (walk_size + sizeof(sa_family_t) > addrs_size) {
 994                        kfree(kaddrs);
 995                        return -EINVAL;
 996                }
 997
 998                sa_addr = addr_buf;
 999                af = sctp_get_af_specific(sa_addr->sa_family);
1000
1001                /* If the address family is not supported or if this address
1002                 * causes the address buffer to overflow return EINVAL.
1003                 */
1004                if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1005                        kfree(kaddrs);
1006                        return -EINVAL;
1007                }
1008                addrcnt++;
1009                addr_buf += af->sockaddr_len;
1010                walk_size += af->sockaddr_len;
1011        }
1012
1013        /* Do the work. */
1014        switch (op) {
1015        case SCTP_BINDX_ADD_ADDR:
1016                /* Allow security module to validate bindx addresses. */
1017                err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_BINDX_ADD,
1018                                                 (struct sockaddr *)kaddrs,
1019                                                 addrs_size);
1020                if (err)
1021                        goto out;
1022                err = sctp_bindx_add(sk, kaddrs, addrcnt);
1023                if (err)
1024                        goto out;
1025                err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
1026                break;
1027
1028        case SCTP_BINDX_REM_ADDR:
1029                err = sctp_bindx_rem(sk, kaddrs, addrcnt);
1030                if (err)
1031                        goto out;
1032                err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
1033                break;
1034
1035        default:
1036                err = -EINVAL;
1037                break;
1038        }
1039
1040out:
1041        kfree(kaddrs);
1042
1043        return err;
1044}
1045
1046static int sctp_connect_new_asoc(struct sctp_endpoint *ep,
1047                                 const union sctp_addr *daddr,
1048                                 const struct sctp_initmsg *init,
1049                                 struct sctp_transport **tp)
1050{
1051        struct sctp_association *asoc;
1052        struct sock *sk = ep->base.sk;
1053        struct net *net = sock_net(sk);
1054        enum sctp_scope scope;
1055        int err;
1056
1057        if (sctp_endpoint_is_peeled_off(ep, daddr))
1058                return -EADDRNOTAVAIL;
1059
1060        if (!ep->base.bind_addr.port) {
1061                if (sctp_autobind(sk))
1062                        return -EAGAIN;
1063        } else {
1064                if (ep->base.bind_addr.port < inet_prot_sock(net) &&
1065                    !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
1066                        return -EACCES;
1067        }
1068
1069        scope = sctp_scope(daddr);
1070        asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1071        if (!asoc)
1072                return -ENOMEM;
1073
1074        err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
1075        if (err < 0)
1076                goto free;
1077
1078        *tp = sctp_assoc_add_peer(asoc, daddr, GFP_KERNEL, SCTP_UNKNOWN);
1079        if (!*tp) {
1080                err = -ENOMEM;
1081                goto free;
1082        }
1083
1084        if (!init)
1085                return 0;
1086
1087        if (init->sinit_num_ostreams) {
1088                __u16 outcnt = init->sinit_num_ostreams;
1089
1090                asoc->c.sinit_num_ostreams = outcnt;
1091                /* outcnt has been changed, need to re-init stream */
1092                err = sctp_stream_init(&asoc->stream, outcnt, 0, GFP_KERNEL);
1093                if (err)
1094                        goto free;
1095        }
1096
1097        if (init->sinit_max_instreams)
1098                asoc->c.sinit_max_instreams = init->sinit_max_instreams;
1099
1100        if (init->sinit_max_attempts)
1101                asoc->max_init_attempts = init->sinit_max_attempts;
1102
1103        if (init->sinit_max_init_timeo)
1104                asoc->max_init_timeo =
1105                        msecs_to_jiffies(init->sinit_max_init_timeo);
1106
1107        return 0;
1108free:
1109        sctp_association_free(asoc);
1110        return err;
1111}
1112
1113static int sctp_connect_add_peer(struct sctp_association *asoc,
1114                                 union sctp_addr *daddr, int addr_len)
1115{
1116        struct sctp_endpoint *ep = asoc->ep;
1117        struct sctp_association *old;
1118        struct sctp_transport *t;
1119        int err;
1120
1121        err = sctp_verify_addr(ep->base.sk, daddr, addr_len);
1122        if (err)
1123                return err;
1124
1125        old = sctp_endpoint_lookup_assoc(ep, daddr, &t);
1126        if (old && old != asoc)
1127                return old->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1128                                                            : -EALREADY;
1129
1130        if (sctp_endpoint_is_peeled_off(ep, daddr))
1131                return -EADDRNOTAVAIL;
1132
1133        t = sctp_assoc_add_peer(asoc, daddr, GFP_KERNEL, SCTP_UNKNOWN);
1134        if (!t)
1135                return -ENOMEM;
1136
1137        return 0;
1138}
1139
1140/* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1141 *
1142 * Common routine for handling connect() and sctp_connectx().
1143 * Connect will come in with just a single address.
1144 */
1145static int __sctp_connect(struct sock *sk, struct sockaddr *kaddrs,
1146                          int addrs_size, int flags, sctp_assoc_t *assoc_id)
1147{
1148        struct sctp_sock *sp = sctp_sk(sk);
1149        struct sctp_endpoint *ep = sp->ep;
1150        struct sctp_transport *transport;
1151        struct sctp_association *asoc;
1152        void *addr_buf = kaddrs;
1153        union sctp_addr *daddr;
1154        struct sctp_af *af;
1155        int walk_size, err;
1156        long timeo;
1157
1158        if (sctp_sstate(sk, ESTABLISHED) || sctp_sstate(sk, CLOSING) ||
1159            (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)))
1160                return -EISCONN;
1161
1162        daddr = addr_buf;
1163        af = sctp_get_af_specific(daddr->sa.sa_family);
1164        if (!af || af->sockaddr_len > addrs_size)
1165                return -EINVAL;
1166
1167        err = sctp_verify_addr(sk, daddr, af->sockaddr_len);
1168        if (err)
1169                return err;
1170
1171        asoc = sctp_endpoint_lookup_assoc(ep, daddr, &transport);
1172        if (asoc)
1173                return asoc->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1174                                                             : -EALREADY;
1175
1176        err = sctp_connect_new_asoc(ep, daddr, NULL, &transport);
1177        if (err)
1178                return err;
1179        asoc = transport->asoc;
1180
1181        addr_buf += af->sockaddr_len;
1182        walk_size = af->sockaddr_len;
1183        while (walk_size < addrs_size) {
1184                err = -EINVAL;
1185                if (walk_size + sizeof(sa_family_t) > addrs_size)
1186                        goto out_free;
1187
1188                daddr = addr_buf;
1189                af = sctp_get_af_specific(daddr->sa.sa_family);
1190                if (!af || af->sockaddr_len + walk_size > addrs_size)
1191                        goto out_free;
1192
1193                if (asoc->peer.port != ntohs(daddr->v4.sin_port))
1194                        goto out_free;
1195
1196                err = sctp_connect_add_peer(asoc, daddr, af->sockaddr_len);
1197                if (err)
1198                        goto out_free;
1199
1200                addr_buf  += af->sockaddr_len;
1201                walk_size += af->sockaddr_len;
1202        }
1203
1204        /* In case the user of sctp_connectx() wants an association
1205         * id back, assign one now.
1206         */
1207        if (assoc_id) {
1208                err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1209                if (err < 0)
1210                        goto out_free;
1211        }
1212
1213        err = sctp_primitive_ASSOCIATE(sock_net(sk), asoc, NULL);
1214        if (err < 0)
1215                goto out_free;
1216
1217        /* Initialize sk's dport and daddr for getpeername() */
1218        inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1219        sp->pf->to_sk_daddr(daddr, sk);
1220        sk->sk_err = 0;
1221
1222        if (assoc_id)
1223                *assoc_id = asoc->assoc_id;
1224
1225        timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1226        return sctp_wait_for_connect(asoc, &timeo);
1227
1228out_free:
1229        pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1230                 __func__, asoc, kaddrs, err);
1231        sctp_association_free(asoc);
1232        return err;
1233}
1234
1235/* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1236 *
1237 * API 8.9
1238 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1239 *                      sctp_assoc_t *asoc);
1240 *
1241 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1242 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1243 * or IPv6 addresses.
1244 *
1245 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1246 * Section 3.1.2 for this usage.
1247 *
1248 * addrs is a pointer to an array of one or more socket addresses. Each
1249 * address is contained in its appropriate structure (i.e. struct
1250 * sockaddr_in or struct sockaddr_in6) the family of the address type
1251 * must be used to distengish the address length (note that this
1252 * representation is termed a "packed array" of addresses). The caller
1253 * specifies the number of addresses in the array with addrcnt.
1254 *
1255 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1256 * the association id of the new association.  On failure, sctp_connectx()
1257 * returns -1, and sets errno to the appropriate error code.  The assoc_id
1258 * is not touched by the kernel.
1259 *
1260 * For SCTP, the port given in each socket address must be the same, or
1261 * sctp_connectx() will fail, setting errno to EINVAL.
1262 *
1263 * An application can use sctp_connectx to initiate an association with
1264 * an endpoint that is multi-homed.  Much like sctp_bindx() this call
1265 * allows a caller to specify multiple addresses at which a peer can be
1266 * reached.  The way the SCTP stack uses the list of addresses to set up
1267 * the association is implementation dependent.  This function only
1268 * specifies that the stack will try to make use of all the addresses in
1269 * the list when needed.
1270 *
1271 * Note that the list of addresses passed in is only used for setting up
1272 * the association.  It does not necessarily equal the set of addresses
1273 * the peer uses for the resulting association.  If the caller wants to
1274 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1275 * retrieve them after the association has been set up.
1276 *
1277 * Basically do nothing but copying the addresses from user to kernel
1278 * land and invoking either sctp_connectx(). This is used for tunneling
1279 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1280 *
1281 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1282 * it.
1283 *
1284 * sk        The sk of the socket
1285 * addrs     The pointer to the addresses in user land
1286 * addrssize Size of the addrs buffer
1287 *
1288 * Returns >=0 if ok, <0 errno code on error.
1289 */
1290static int __sctp_setsockopt_connectx(struct sock *sk,
1291                                      struct sockaddr __user *addrs,
1292                                      int addrs_size,
1293                                      sctp_assoc_t *assoc_id)
1294{
1295        struct sockaddr *kaddrs;
1296        int err = 0, flags = 0;
1297
1298        pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1299                 __func__, sk, addrs, addrs_size);
1300
1301        /* make sure the 1st addr's sa_family is accessible later */
1302        if (unlikely(addrs_size < sizeof(sa_family_t)))
1303                return -EINVAL;
1304
1305        kaddrs = memdup_user(addrs, addrs_size);
1306        if (IS_ERR(kaddrs))
1307                return PTR_ERR(kaddrs);
1308
1309        /* Allow security module to validate connectx addresses. */
1310        err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_CONNECTX,
1311                                         (struct sockaddr *)kaddrs,
1312                                          addrs_size);
1313        if (err)
1314                goto out_free;
1315
1316        /* in-kernel sockets don't generally have a file allocated to them
1317         * if all they do is call sock_create_kern().
1318         */
1319        if (sk->sk_socket->file)
1320                flags = sk->sk_socket->file->f_flags;
1321
1322        err = __sctp_connect(sk, kaddrs, addrs_size, flags, assoc_id);
1323
1324out_free:
1325        kfree(kaddrs);
1326
1327        return err;
1328}
1329
1330/*
1331 * This is an older interface.  It's kept for backward compatibility
1332 * to the option that doesn't provide association id.
1333 */
1334static int sctp_setsockopt_connectx_old(struct sock *sk,
1335                                        struct sockaddr __user *addrs,
1336                                        int addrs_size)
1337{
1338        return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL);
1339}
1340
1341/*
1342 * New interface for the API.  The since the API is done with a socket
1343 * option, to make it simple we feed back the association id is as a return
1344 * indication to the call.  Error is always negative and association id is
1345 * always positive.
1346 */
1347static int sctp_setsockopt_connectx(struct sock *sk,
1348                                    struct sockaddr __user *addrs,
1349                                    int addrs_size)
1350{
1351        sctp_assoc_t assoc_id = 0;
1352        int err = 0;
1353
1354        err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id);
1355
1356        if (err)
1357                return err;
1358        else
1359                return assoc_id;
1360}
1361
1362/*
1363 * New (hopefully final) interface for the API.
1364 * We use the sctp_getaddrs_old structure so that use-space library
1365 * can avoid any unnecessary allocations. The only different part
1366 * is that we store the actual length of the address buffer into the
1367 * addrs_num structure member. That way we can re-use the existing
1368 * code.
1369 */
1370#ifdef CONFIG_COMPAT
1371struct compat_sctp_getaddrs_old {
1372        sctp_assoc_t    assoc_id;
1373        s32             addr_num;
1374        compat_uptr_t   addrs;          /* struct sockaddr * */
1375};
1376#endif
1377
1378static int sctp_getsockopt_connectx3(struct sock *sk, int len,
1379                                     char __user *optval,
1380                                     int __user *optlen)
1381{
1382        struct sctp_getaddrs_old param;
1383        sctp_assoc_t assoc_id = 0;
1384        int err = 0;
1385
1386#ifdef CONFIG_COMPAT
1387        if (in_compat_syscall()) {
1388                struct compat_sctp_getaddrs_old param32;
1389
1390                if (len < sizeof(param32))
1391                        return -EINVAL;
1392                if (copy_from_user(&param32, optval, sizeof(param32)))
1393                        return -EFAULT;
1394
1395                param.assoc_id = param32.assoc_id;
1396                param.addr_num = param32.addr_num;
1397                param.addrs = compat_ptr(param32.addrs);
1398        } else
1399#endif
1400        {
1401                if (len < sizeof(param))
1402                        return -EINVAL;
1403                if (copy_from_user(&param, optval, sizeof(param)))
1404                        return -EFAULT;
1405        }
1406
1407        err = __sctp_setsockopt_connectx(sk, (struct sockaddr __user *)
1408                                         param.addrs, param.addr_num,
1409                                         &assoc_id);
1410        if (err == 0 || err == -EINPROGRESS) {
1411                if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1412                        return -EFAULT;
1413                if (put_user(sizeof(assoc_id), optlen))
1414                        return -EFAULT;
1415        }
1416
1417        return err;
1418}
1419
1420/* API 3.1.4 close() - UDP Style Syntax
1421 * Applications use close() to perform graceful shutdown (as described in
1422 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1423 * by a UDP-style socket.
1424 *
1425 * The syntax is
1426 *
1427 *   ret = close(int sd);
1428 *
1429 *   sd      - the socket descriptor of the associations to be closed.
1430 *
1431 * To gracefully shutdown a specific association represented by the
1432 * UDP-style socket, an application should use the sendmsg() call,
1433 * passing no user data, but including the appropriate flag in the
1434 * ancillary data (see Section xxxx).
1435 *
1436 * If sd in the close() call is a branched-off socket representing only
1437 * one association, the shutdown is performed on that association only.
1438 *
1439 * 4.1.6 close() - TCP Style Syntax
1440 *
1441 * Applications use close() to gracefully close down an association.
1442 *
1443 * The syntax is:
1444 *
1445 *    int close(int sd);
1446 *
1447 *      sd      - the socket descriptor of the association to be closed.
1448 *
1449 * After an application calls close() on a socket descriptor, no further
1450 * socket operations will succeed on that descriptor.
1451 *
1452 * API 7.1.4 SO_LINGER
1453 *
1454 * An application using the TCP-style socket can use this option to
1455 * perform the SCTP ABORT primitive.  The linger option structure is:
1456 *
1457 *  struct  linger {
1458 *     int     l_onoff;                // option on/off
1459 *     int     l_linger;               // linger time
1460 * };
1461 *
1462 * To enable the option, set l_onoff to 1.  If the l_linger value is set
1463 * to 0, calling close() is the same as the ABORT primitive.  If the
1464 * value is set to a negative value, the setsockopt() call will return
1465 * an error.  If the value is set to a positive value linger_time, the
1466 * close() can be blocked for at most linger_time ms.  If the graceful
1467 * shutdown phase does not finish during this period, close() will
1468 * return but the graceful shutdown phase continues in the system.
1469 */
1470static void sctp_close(struct sock *sk, long timeout)
1471{
1472        struct net *net = sock_net(sk);
1473        struct sctp_endpoint *ep;
1474        struct sctp_association *asoc;
1475        struct list_head *pos, *temp;
1476        unsigned int data_was_unread;
1477
1478        pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout);
1479
1480        lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1481        sk->sk_shutdown = SHUTDOWN_MASK;
1482        inet_sk_set_state(sk, SCTP_SS_CLOSING);
1483
1484        ep = sctp_sk(sk)->ep;
1485
1486        /* Clean up any skbs sitting on the receive queue.  */
1487        data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1488        data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1489
1490        /* Walk all associations on an endpoint.  */
1491        list_for_each_safe(pos, temp, &ep->asocs) {
1492                asoc = list_entry(pos, struct sctp_association, asocs);
1493
1494                if (sctp_style(sk, TCP)) {
1495                        /* A closed association can still be in the list if
1496                         * it belongs to a TCP-style listening socket that is
1497                         * not yet accepted. If so, free it. If not, send an
1498                         * ABORT or SHUTDOWN based on the linger options.
1499                         */
1500                        if (sctp_state(asoc, CLOSED)) {
1501                                sctp_association_free(asoc);
1502                                continue;
1503                        }
1504                }
1505
1506                if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1507                    !skb_queue_empty(&asoc->ulpq.reasm) ||
1508                    !skb_queue_empty(&asoc->ulpq.reasm_uo) ||
1509                    (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1510                        struct sctp_chunk *chunk;
1511
1512                        chunk = sctp_make_abort_user(asoc, NULL, 0);
1513                        sctp_primitive_ABORT(net, asoc, chunk);
1514                } else
1515                        sctp_primitive_SHUTDOWN(net, asoc, NULL);
1516        }
1517
1518        /* On a TCP-style socket, block for at most linger_time if set. */
1519        if (sctp_style(sk, TCP) && timeout)
1520                sctp_wait_for_close(sk, timeout);
1521
1522        /* This will run the backlog queue.  */
1523        release_sock(sk);
1524
1525        /* Supposedly, no process has access to the socket, but
1526         * the net layers still may.
1527         * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1528         * held and that should be grabbed before socket lock.
1529         */
1530        spin_lock_bh(&net->sctp.addr_wq_lock);
1531        bh_lock_sock_nested(sk);
1532
1533        /* Hold the sock, since sk_common_release() will put sock_put()
1534         * and we have just a little more cleanup.
1535         */
1536        sock_hold(sk);
1537        sk_common_release(sk);
1538
1539        bh_unlock_sock(sk);
1540        spin_unlock_bh(&net->sctp.addr_wq_lock);
1541
1542        sock_put(sk);
1543
1544        SCTP_DBG_OBJCNT_DEC(sock);
1545}
1546
1547/* Handle EPIPE error. */
1548static int sctp_error(struct sock *sk, int flags, int err)
1549{
1550        if (err == -EPIPE)
1551                err = sock_error(sk) ? : -EPIPE;
1552        if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1553                send_sig(SIGPIPE, current, 0);
1554        return err;
1555}
1556
1557/* API 3.1.3 sendmsg() - UDP Style Syntax
1558 *
1559 * An application uses sendmsg() and recvmsg() calls to transmit data to
1560 * and receive data from its peer.
1561 *
1562 *  ssize_t sendmsg(int socket, const struct msghdr *message,
1563 *                  int flags);
1564 *
1565 *  socket  - the socket descriptor of the endpoint.
1566 *  message - pointer to the msghdr structure which contains a single
1567 *            user message and possibly some ancillary data.
1568 *
1569 *            See Section 5 for complete description of the data
1570 *            structures.
1571 *
1572 *  flags   - flags sent or received with the user message, see Section
1573 *            5 for complete description of the flags.
1574 *
1575 * Note:  This function could use a rewrite especially when explicit
1576 * connect support comes in.
1577 */
1578/* BUG:  We do not implement the equivalent of sk_stream_wait_memory(). */
1579
1580static int sctp_msghdr_parse(const struct msghdr *msg,
1581                             struct sctp_cmsgs *cmsgs);
1582
1583static int sctp_sendmsg_parse(struct sock *sk, struct sctp_cmsgs *cmsgs,
1584                              struct sctp_sndrcvinfo *srinfo,
1585                              const struct msghdr *msg, size_t msg_len)
1586{
1587        __u16 sflags;
1588        int err;
1589
1590        if (sctp_sstate(sk, LISTENING) && sctp_style(sk, TCP))
1591                return -EPIPE;
1592
1593        if (msg_len > sk->sk_sndbuf)
1594                return -EMSGSIZE;
1595
1596        memset(cmsgs, 0, sizeof(*cmsgs));
1597        err = sctp_msghdr_parse(msg, cmsgs);
1598        if (err) {
1599                pr_debug("%s: msghdr parse err:%x\n", __func__, err);
1600                return err;
1601        }
1602
1603        memset(srinfo, 0, sizeof(*srinfo));
1604        if (cmsgs->srinfo) {
1605                srinfo->sinfo_stream = cmsgs->srinfo->sinfo_stream;
1606                srinfo->sinfo_flags = cmsgs->srinfo->sinfo_flags;
1607                srinfo->sinfo_ppid = cmsgs->srinfo->sinfo_ppid;
1608                srinfo->sinfo_context = cmsgs->srinfo->sinfo_context;
1609                srinfo->sinfo_assoc_id = cmsgs->srinfo->sinfo_assoc_id;
1610                srinfo->sinfo_timetolive = cmsgs->srinfo->sinfo_timetolive;
1611        }
1612
1613        if (cmsgs->sinfo) {
1614                srinfo->sinfo_stream = cmsgs->sinfo->snd_sid;
1615                srinfo->sinfo_flags = cmsgs->sinfo->snd_flags;
1616                srinfo->sinfo_ppid = cmsgs->sinfo->snd_ppid;
1617                srinfo->sinfo_context = cmsgs->sinfo->snd_context;
1618                srinfo->sinfo_assoc_id = cmsgs->sinfo->snd_assoc_id;
1619        }
1620
1621        if (cmsgs->prinfo) {
1622                srinfo->sinfo_timetolive = cmsgs->prinfo->pr_value;
1623                SCTP_PR_SET_POLICY(srinfo->sinfo_flags,
1624                                   cmsgs->prinfo->pr_policy);
1625        }
1626
1627        sflags = srinfo->sinfo_flags;
1628        if (!sflags && msg_len)
1629                return 0;
1630
1631        if (sctp_style(sk, TCP) && (sflags & (SCTP_EOF | SCTP_ABORT)))
1632                return -EINVAL;
1633
1634        if (((sflags & SCTP_EOF) && msg_len > 0) ||
1635            (!(sflags & (SCTP_EOF | SCTP_ABORT)) && msg_len == 0))
1636                return -EINVAL;
1637
1638        if ((sflags & SCTP_ADDR_OVER) && !msg->msg_name)
1639                return -EINVAL;
1640
1641        return 0;
1642}
1643
1644static int sctp_sendmsg_new_asoc(struct sock *sk, __u16 sflags,
1645                                 struct sctp_cmsgs *cmsgs,
1646                                 union sctp_addr *daddr,
1647                                 struct sctp_transport **tp)
1648{
1649        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1650        struct sctp_association *asoc;
1651        struct cmsghdr *cmsg;
1652        __be32 flowinfo = 0;
1653        struct sctp_af *af;
1654        int err;
1655
1656        *tp = NULL;
1657
1658        if (sflags & (SCTP_EOF | SCTP_ABORT))
1659                return -EINVAL;
1660
1661        if (sctp_style(sk, TCP) && (sctp_sstate(sk, ESTABLISHED) ||
1662                                    sctp_sstate(sk, CLOSING)))
1663                return -EADDRNOTAVAIL;
1664
1665        /* Label connection socket for first association 1-to-many
1666         * style for client sequence socket()->sendmsg(). This
1667         * needs to be done before sctp_assoc_add_peer() as that will
1668         * set up the initial packet that needs to account for any
1669         * security ip options (CIPSO/CALIPSO) added to the packet.
1670         */
1671        af = sctp_get_af_specific(daddr->sa.sa_family);
1672        if (!af)
1673                return -EINVAL;
1674        err = security_sctp_bind_connect(sk, SCTP_SENDMSG_CONNECT,
1675                                         (struct sockaddr *)daddr,
1676                                         af->sockaddr_len);
1677        if (err < 0)
1678                return err;
1679
1680        err = sctp_connect_new_asoc(ep, daddr, cmsgs->init, tp);
1681        if (err)
1682                return err;
1683        asoc = (*tp)->asoc;
1684
1685        if (!cmsgs->addrs_msg)
1686                return 0;
1687
1688        if (daddr->sa.sa_family == AF_INET6)
1689                flowinfo = daddr->v6.sin6_flowinfo;
1690
1691        /* sendv addr list parse */
1692        for_each_cmsghdr(cmsg, cmsgs->addrs_msg) {
1693                union sctp_addr _daddr;
1694                int dlen;
1695
1696                if (cmsg->cmsg_level != IPPROTO_SCTP ||
1697                    (cmsg->cmsg_type != SCTP_DSTADDRV4 &&
1698                     cmsg->cmsg_type != SCTP_DSTADDRV6))
1699                        continue;
1700
1701                daddr = &_daddr;
1702                memset(daddr, 0, sizeof(*daddr));
1703                dlen = cmsg->cmsg_len - sizeof(struct cmsghdr);
1704                if (cmsg->cmsg_type == SCTP_DSTADDRV4) {
1705                        if (dlen < sizeof(struct in_addr)) {
1706                                err = -EINVAL;
1707                                goto free;
1708                        }
1709
1710                        dlen = sizeof(struct in_addr);
1711                        daddr->v4.sin_family = AF_INET;
1712                        daddr->v4.sin_port = htons(asoc->peer.port);
1713                        memcpy(&daddr->v4.sin_addr, CMSG_DATA(cmsg), dlen);
1714                } else {
1715                        if (dlen < sizeof(struct in6_addr)) {
1716                                err = -EINVAL;
1717                                goto free;
1718                        }
1719
1720                        dlen = sizeof(struct in6_addr);
1721                        daddr->v6.sin6_flowinfo = flowinfo;
1722                        daddr->v6.sin6_family = AF_INET6;
1723                        daddr->v6.sin6_port = htons(asoc->peer.port);
1724                        memcpy(&daddr->v6.sin6_addr, CMSG_DATA(cmsg), dlen);
1725                }
1726
1727                err = sctp_connect_add_peer(asoc, daddr, sizeof(*daddr));
1728                if (err)
1729                        goto free;
1730        }
1731
1732        return 0;
1733
1734free:
1735        sctp_association_free(asoc);
1736        return err;
1737}
1738
1739static int sctp_sendmsg_check_sflags(struct sctp_association *asoc,
1740                                     __u16 sflags, struct msghdr *msg,
1741                                     size_t msg_len)
1742{
1743        struct sock *sk = asoc->base.sk;
1744        struct net *net = sock_net(sk);
1745
1746        if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP))
1747                return -EPIPE;
1748
1749        if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP) &&
1750            !sctp_state(asoc, ESTABLISHED))
1751                return 0;
1752
1753        if (sflags & SCTP_EOF) {
1754                pr_debug("%s: shutting down association:%p\n", __func__, asoc);
1755                sctp_primitive_SHUTDOWN(net, asoc, NULL);
1756
1757                return 0;
1758        }
1759
1760        if (sflags & SCTP_ABORT) {
1761                struct sctp_chunk *chunk;
1762
1763                chunk = sctp_make_abort_user(asoc, msg, msg_len);
1764                if (!chunk)
1765                        return -ENOMEM;
1766
1767                pr_debug("%s: aborting association:%p\n", __func__, asoc);
1768                sctp_primitive_ABORT(net, asoc, chunk);
1769                iov_iter_revert(&msg->msg_iter, msg_len);
1770
1771                return 0;
1772        }
1773
1774        return 1;
1775}
1776
1777static int sctp_sendmsg_to_asoc(struct sctp_association *asoc,
1778                                struct msghdr *msg, size_t msg_len,
1779                                struct sctp_transport *transport,
1780                                struct sctp_sndrcvinfo *sinfo)
1781{
1782        struct sock *sk = asoc->base.sk;
1783        struct sctp_sock *sp = sctp_sk(sk);
1784        struct net *net = sock_net(sk);
1785        struct sctp_datamsg *datamsg;
1786        bool wait_connect = false;
1787        struct sctp_chunk *chunk;
1788        long timeo;
1789        int err;
1790
1791        if (sinfo->sinfo_stream >= asoc->stream.outcnt) {
1792                err = -EINVAL;
1793                goto err;
1794        }
1795
1796        if (unlikely(!SCTP_SO(&asoc->stream, sinfo->sinfo_stream)->ext)) {
1797                err = sctp_stream_init_ext(&asoc->stream, sinfo->sinfo_stream);
1798                if (err)
1799                        goto err;
1800        }
1801
1802        if (sp->disable_fragments && msg_len > asoc->frag_point) {
1803                err = -EMSGSIZE;
1804                goto err;
1805        }
1806
1807        if (asoc->pmtu_pending) {
1808                if (sp->param_flags & SPP_PMTUD_ENABLE)
1809                        sctp_assoc_sync_pmtu(asoc);
1810                asoc->pmtu_pending = 0;
1811        }
1812
1813        if (sctp_wspace(asoc) < (int)msg_len)
1814                sctp_prsctp_prune(asoc, sinfo, msg_len - sctp_wspace(asoc));
1815
1816        if (sk_under_memory_pressure(sk))
1817                sk_mem_reclaim(sk);
1818
1819        if (sctp_wspace(asoc) <= 0 || !sk_wmem_schedule(sk, msg_len)) {
1820                timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1821                err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1822                if (err)
1823                        goto err;
1824        }
1825
1826        if (sctp_state(asoc, CLOSED)) {
1827                err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1828                if (err)
1829                        goto err;
1830
1831                if (asoc->ep->intl_enable) {
1832                        timeo = sock_sndtimeo(sk, 0);
1833                        err = sctp_wait_for_connect(asoc, &timeo);
1834                        if (err) {
1835                                err = -ESRCH;
1836                                goto err;
1837                        }
1838                } else {
1839                        wait_connect = true;
1840                }
1841
1842                pr_debug("%s: we associated primitively\n", __func__);
1843        }
1844
1845        datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
1846        if (IS_ERR(datamsg)) {
1847                err = PTR_ERR(datamsg);
1848                goto err;
1849        }
1850
1851        asoc->force_delay = !!(msg->msg_flags & MSG_MORE);
1852
1853        list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
1854                sctp_chunk_hold(chunk);
1855                sctp_set_owner_w(chunk);
1856                chunk->transport = transport;
1857        }
1858
1859        err = sctp_primitive_SEND(net, asoc, datamsg);
1860        if (err) {
1861                sctp_datamsg_free(datamsg);
1862                goto err;
1863        }
1864
1865        pr_debug("%s: we sent primitively\n", __func__);
1866
1867        sctp_datamsg_put(datamsg);
1868
1869        if (unlikely(wait_connect)) {
1870                timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1871                sctp_wait_for_connect(asoc, &timeo);
1872        }
1873
1874        err = msg_len;
1875
1876err:
1877        return err;
1878}
1879
1880static union sctp_addr *sctp_sendmsg_get_daddr(struct sock *sk,
1881                                               const struct msghdr *msg,
1882                                               struct sctp_cmsgs *cmsgs)
1883{
1884        union sctp_addr *daddr = NULL;
1885        int err;
1886
1887        if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1888                int len = msg->msg_namelen;
1889
1890                if (len > sizeof(*daddr))
1891                        len = sizeof(*daddr);
1892
1893                daddr = (union sctp_addr *)msg->msg_name;
1894
1895                err = sctp_verify_addr(sk, daddr, len);
1896                if (err)
1897                        return ERR_PTR(err);
1898        }
1899
1900        return daddr;
1901}
1902
1903static void sctp_sendmsg_update_sinfo(struct sctp_association *asoc,
1904                                      struct sctp_sndrcvinfo *sinfo,
1905                                      struct sctp_cmsgs *cmsgs)
1906{
1907        if (!cmsgs->srinfo && !cmsgs->sinfo) {
1908                sinfo->sinfo_stream = asoc->default_stream;
1909                sinfo->sinfo_ppid = asoc->default_ppid;
1910                sinfo->sinfo_context = asoc->default_context;
1911                sinfo->sinfo_assoc_id = sctp_assoc2id(asoc);
1912
1913                if (!cmsgs->prinfo)
1914                        sinfo->sinfo_flags = asoc->default_flags;
1915        }
1916
1917        if (!cmsgs->srinfo && !cmsgs->prinfo)
1918                sinfo->sinfo_timetolive = asoc->default_timetolive;
1919
1920        if (cmsgs->authinfo) {
1921                /* Reuse sinfo_tsn to indicate that authinfo was set and
1922                 * sinfo_ssn to save the keyid on tx path.
1923                 */
1924                sinfo->sinfo_tsn = 1;
1925                sinfo->sinfo_ssn = cmsgs->authinfo->auth_keynumber;
1926        }
1927}
1928
1929static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
1930{
1931        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1932        struct sctp_transport *transport = NULL;
1933        struct sctp_sndrcvinfo _sinfo, *sinfo;
1934        struct sctp_association *asoc, *tmp;
1935        struct sctp_cmsgs cmsgs;
1936        union sctp_addr *daddr;
1937        bool new = false;
1938        __u16 sflags;
1939        int err;
1940
1941        /* Parse and get snd_info */
1942        err = sctp_sendmsg_parse(sk, &cmsgs, &_sinfo, msg, msg_len);
1943        if (err)
1944                goto out;
1945
1946        sinfo  = &_sinfo;
1947        sflags = sinfo->sinfo_flags;
1948
1949        /* Get daddr from msg */
1950        daddr = sctp_sendmsg_get_daddr(sk, msg, &cmsgs);
1951        if (IS_ERR(daddr)) {
1952                err = PTR_ERR(daddr);
1953                goto out;
1954        }
1955
1956        lock_sock(sk);
1957
1958        /* SCTP_SENDALL process */
1959        if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) {
1960                list_for_each_entry_safe(asoc, tmp, &ep->asocs, asocs) {
1961                        err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
1962                                                        msg_len);
1963                        if (err == 0)
1964                                continue;
1965                        if (err < 0)
1966                                goto out_unlock;
1967
1968                        sctp_sendmsg_update_sinfo(asoc, sinfo, &cmsgs);
1969
1970                        err = sctp_sendmsg_to_asoc(asoc, msg, msg_len,
1971                                                   NULL, sinfo);
1972                        if (err < 0)
1973                                goto out_unlock;
1974
1975                        iov_iter_revert(&msg->msg_iter, err);
1976                }
1977
1978                goto out_unlock;
1979        }
1980
1981        /* Get and check or create asoc */
1982        if (daddr) {
1983                asoc = sctp_endpoint_lookup_assoc(ep, daddr, &transport);
1984                if (asoc) {
1985                        err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
1986                                                        msg_len);
1987                        if (err <= 0)
1988                                goto out_unlock;
1989                } else {
1990                        err = sctp_sendmsg_new_asoc(sk, sflags, &cmsgs, daddr,
1991                                                    &transport);
1992                        if (err)
1993                                goto out_unlock;
1994
1995                        asoc = transport->asoc;
1996                        new = true;
1997                }
1998
1999                if (!sctp_style(sk, TCP) && !(sflags & SCTP_ADDR_OVER))
2000                        transport = NULL;
2001        } else {
2002                asoc = sctp_id2assoc(sk, sinfo->sinfo_assoc_id);
2003                if (!asoc) {
2004                        err = -EPIPE;
2005                        goto out_unlock;
2006                }
2007
2008                err = sctp_sendmsg_check_sflags(asoc, sflags, msg, msg_len);
2009                if (err <= 0)
2010                        goto out_unlock;
2011        }
2012
2013        /* Update snd_info with the asoc */
2014        sctp_sendmsg_update_sinfo(asoc, sinfo, &cmsgs);
2015
2016        /* Send msg to the asoc */
2017        err = sctp_sendmsg_to_asoc(asoc, msg, msg_len, transport, sinfo);
2018        if (err < 0 && err != -ESRCH && new)
2019                sctp_association_free(asoc);
2020
2021out_unlock:
2022        release_sock(sk);
2023out:
2024        return sctp_error(sk, msg->msg_flags, err);
2025}
2026
2027/* This is an extended version of skb_pull() that removes the data from the
2028 * start of a skb even when data is spread across the list of skb's in the
2029 * frag_list. len specifies the total amount of data that needs to be removed.
2030 * when 'len' bytes could be removed from the skb, it returns 0.
2031 * If 'len' exceeds the total skb length,  it returns the no. of bytes that
2032 * could not be removed.
2033 */
2034static int sctp_skb_pull(struct sk_buff *skb, int len)
2035{
2036        struct sk_buff *list;
2037        int skb_len = skb_headlen(skb);
2038        int rlen;
2039
2040        if (len <= skb_len) {
2041                __skb_pull(skb, len);
2042                return 0;
2043        }
2044        len -= skb_len;
2045        __skb_pull(skb, skb_len);
2046
2047        skb_walk_frags(skb, list) {
2048                rlen = sctp_skb_pull(list, len);
2049                skb->len -= (len-rlen);
2050                skb->data_len -= (len-rlen);
2051
2052                if (!rlen)
2053                        return 0;
2054
2055                len = rlen;
2056        }
2057
2058        return len;
2059}
2060
2061/* API 3.1.3  recvmsg() - UDP Style Syntax
2062 *
2063 *  ssize_t recvmsg(int socket, struct msghdr *message,
2064 *                    int flags);
2065 *
2066 *  socket  - the socket descriptor of the endpoint.
2067 *  message - pointer to the msghdr structure which contains a single
2068 *            user message and possibly some ancillary data.
2069 *
2070 *            See Section 5 for complete description of the data
2071 *            structures.
2072 *
2073 *  flags   - flags sent or received with the user message, see Section
2074 *            5 for complete description of the flags.
2075 */
2076static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
2077                        int noblock, int flags, int *addr_len)
2078{
2079        struct sctp_ulpevent *event = NULL;
2080        struct sctp_sock *sp = sctp_sk(sk);
2081        struct sk_buff *skb, *head_skb;
2082        int copied;
2083        int err = 0;
2084        int skb_len;
2085
2086        pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2087                 "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags,
2088                 addr_len);
2089
2090        lock_sock(sk);
2091
2092        if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED) &&
2093            !sctp_sstate(sk, CLOSING) && !sctp_sstate(sk, CLOSED)) {
2094                err = -ENOTCONN;
2095                goto out;
2096        }
2097
2098        skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
2099        if (!skb)
2100                goto out;
2101
2102        /* Get the total length of the skb including any skb's in the
2103         * frag_list.
2104         */
2105        skb_len = skb->len;
2106
2107        copied = skb_len;
2108        if (copied > len)
2109                copied = len;
2110
2111        err = skb_copy_datagram_msg(skb, 0, msg, copied);
2112
2113        event = sctp_skb2event(skb);
2114
2115        if (err)
2116                goto out_free;
2117
2118        if (event->chunk && event->chunk->head_skb)
2119                head_skb = event->chunk->head_skb;
2120        else
2121                head_skb = skb;
2122        sock_recv_ts_and_drops(msg, sk, head_skb);
2123        if (sctp_ulpevent_is_notification(event)) {
2124                msg->msg_flags |= MSG_NOTIFICATION;
2125                sp->pf->event_msgname(event, msg->msg_name, addr_len);
2126        } else {
2127                sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len);
2128        }
2129
2130        /* Check if we allow SCTP_NXTINFO. */
2131        if (sp->recvnxtinfo)
2132                sctp_ulpevent_read_nxtinfo(event, msg, sk);
2133        /* Check if we allow SCTP_RCVINFO. */
2134        if (sp->recvrcvinfo)
2135                sctp_ulpevent_read_rcvinfo(event, msg);
2136        /* Check if we allow SCTP_SNDRCVINFO. */
2137        if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_DATA_IO_EVENT))
2138                sctp_ulpevent_read_sndrcvinfo(event, msg);
2139
2140        err = copied;
2141
2142        /* If skb's length exceeds the user's buffer, update the skb and
2143         * push it back to the receive_queue so that the next call to
2144         * recvmsg() will return the remaining data. Don't set MSG_EOR.
2145         */
2146        if (skb_len > copied) {
2147                msg->msg_flags &= ~MSG_EOR;
2148                if (flags & MSG_PEEK)
2149                        goto out_free;
2150                sctp_skb_pull(skb, copied);
2151                skb_queue_head(&sk->sk_receive_queue, skb);
2152
2153                /* When only partial message is copied to the user, increase
2154                 * rwnd by that amount. If all the data in the skb is read,
2155                 * rwnd is updated when the event is freed.
2156                 */
2157                if (!sctp_ulpevent_is_notification(event))
2158                        sctp_assoc_rwnd_increase(event->asoc, copied);
2159                goto out;
2160        } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2161                   (event->msg_flags & MSG_EOR))
2162                msg->msg_flags |= MSG_EOR;
2163        else
2164                msg->msg_flags &= ~MSG_EOR;
2165
2166out_free:
2167        if (flags & MSG_PEEK) {
2168                /* Release the skb reference acquired after peeking the skb in
2169                 * sctp_skb_recv_datagram().
2170                 */
2171                kfree_skb(skb);
2172        } else {
2173                /* Free the event which includes releasing the reference to
2174                 * the owner of the skb, freeing the skb and updating the
2175                 * rwnd.
2176                 */
2177                sctp_ulpevent_free(event);
2178        }
2179out:
2180        release_sock(sk);
2181        return err;
2182}
2183
2184/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2185 *
2186 * This option is a on/off flag.  If enabled no SCTP message
2187 * fragmentation will be performed.  Instead if a message being sent
2188 * exceeds the current PMTU size, the message will NOT be sent and
2189 * instead a error will be indicated to the user.
2190 */
2191static int sctp_setsockopt_disable_fragments(struct sock *sk,
2192                                             char __user *optval,
2193                                             unsigned int optlen)
2194{
2195        int val;
2196
2197        if (optlen < sizeof(int))
2198                return -EINVAL;
2199
2200        if (get_user(val, (int __user *)optval))
2201                return -EFAULT;
2202
2203        sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
2204
2205        return 0;
2206}
2207
2208static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
2209                                  unsigned int optlen)
2210{
2211        struct sctp_event_subscribe subscribe;
2212        __u8 *sn_type = (__u8 *)&subscribe;
2213        struct sctp_sock *sp = sctp_sk(sk);
2214        struct sctp_association *asoc;
2215        int i;
2216
2217        if (optlen > sizeof(struct sctp_event_subscribe))
2218                return -EINVAL;
2219
2220        if (copy_from_user(&subscribe, optval, optlen))
2221                return -EFAULT;
2222
2223        for (i = 0; i < optlen; i++)
2224                sctp_ulpevent_type_set(&sp->subscribe, SCTP_SN_TYPE_BASE + i,
2225                                       sn_type[i]);
2226
2227        list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2228                asoc->subscribe = sctp_sk(sk)->subscribe;
2229
2230        /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2231         * if there is no data to be sent or retransmit, the stack will
2232         * immediately send up this notification.
2233         */
2234        if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_SENDER_DRY_EVENT)) {
2235                struct sctp_ulpevent *event;
2236
2237                asoc = sctp_id2assoc(sk, 0);
2238                if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2239                        event = sctp_ulpevent_make_sender_dry_event(asoc,
2240                                        GFP_USER | __GFP_NOWARN);
2241                        if (!event)
2242                                return -ENOMEM;
2243
2244                        asoc->stream.si->enqueue_event(&asoc->ulpq, event);
2245                }
2246        }
2247
2248        return 0;
2249}
2250
2251/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2252 *
2253 * This socket option is applicable to the UDP-style socket only.  When
2254 * set it will cause associations that are idle for more than the
2255 * specified number of seconds to automatically close.  An association
2256 * being idle is defined an association that has NOT sent or received
2257 * user data.  The special value of '0' indicates that no automatic
2258 * close of any associations should be performed.  The option expects an
2259 * integer defining the number of seconds of idle time before an
2260 * association is closed.
2261 */
2262static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
2263                                     unsigned int optlen)
2264{
2265        struct sctp_sock *sp = sctp_sk(sk);
2266        struct net *net = sock_net(sk);
2267
2268        /* Applicable to UDP-style socket only */
2269        if (sctp_style(sk, TCP))
2270                return -EOPNOTSUPP;
2271        if (optlen != sizeof(int))
2272                return -EINVAL;
2273        if (copy_from_user(&sp->autoclose, optval, optlen))
2274                return -EFAULT;
2275
2276        if (sp->autoclose > net->sctp.max_autoclose)
2277                sp->autoclose = net->sctp.max_autoclose;
2278
2279        return 0;
2280}
2281
2282/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2283 *
2284 * Applications can enable or disable heartbeats for any peer address of
2285 * an association, modify an address's heartbeat interval, force a
2286 * heartbeat to be sent immediately, and adjust the address's maximum
2287 * number of retransmissions sent before an address is considered
2288 * unreachable.  The following structure is used to access and modify an
2289 * address's parameters:
2290 *
2291 *  struct sctp_paddrparams {
2292 *     sctp_assoc_t            spp_assoc_id;
2293 *     struct sockaddr_storage spp_address;
2294 *     uint32_t                spp_hbinterval;
2295 *     uint16_t                spp_pathmaxrxt;
2296 *     uint32_t                spp_pathmtu;
2297 *     uint32_t                spp_sackdelay;
2298 *     uint32_t                spp_flags;
2299 *     uint32_t                spp_ipv6_flowlabel;
2300 *     uint8_t                 spp_dscp;
2301 * };
2302 *
2303 *   spp_assoc_id    - (one-to-many style socket) This is filled in the
2304 *                     application, and identifies the association for
2305 *                     this query.
2306 *   spp_address     - This specifies which address is of interest.
2307 *   spp_hbinterval  - This contains the value of the heartbeat interval,
2308 *                     in milliseconds.  If a  value of zero
2309 *                     is present in this field then no changes are to
2310 *                     be made to this parameter.
2311 *   spp_pathmaxrxt  - This contains the maximum number of
2312 *                     retransmissions before this address shall be
2313 *                     considered unreachable. If a  value of zero
2314 *                     is present in this field then no changes are to
2315 *                     be made to this parameter.
2316 *   spp_pathmtu     - When Path MTU discovery is disabled the value
2317 *                     specified here will be the "fixed" path mtu.
2318 *                     Note that if the spp_address field is empty
2319 *                     then all associations on this address will
2320 *                     have this fixed path mtu set upon them.
2321 *
2322 *   spp_sackdelay   - When delayed sack is enabled, this value specifies
2323 *                     the number of milliseconds that sacks will be delayed
2324 *                     for. This value will apply to all addresses of an
2325 *                     association if the spp_address field is empty. Note
2326 *                     also, that if delayed sack is enabled and this
2327 *                     value is set to 0, no change is made to the last
2328 *                     recorded delayed sack timer value.
2329 *
2330 *   spp_flags       - These flags are used to control various features
2331 *                     on an association. The flag field may contain
2332 *                     zero or more of the following options.
2333 *
2334 *                     SPP_HB_ENABLE  - Enable heartbeats on the
2335 *                     specified address. Note that if the address
2336 *                     field is empty all addresses for the association
2337 *                     have heartbeats enabled upon them.
2338 *
2339 *                     SPP_HB_DISABLE - Disable heartbeats on the
2340 *                     speicifed address. Note that if the address
2341 *                     field is empty all addresses for the association
2342 *                     will have their heartbeats disabled. Note also
2343 *                     that SPP_HB_ENABLE and SPP_HB_DISABLE are
2344 *                     mutually exclusive, only one of these two should
2345 *                     be specified. Enabling both fields will have
2346 *                     undetermined results.
2347 *
2348 *                     SPP_HB_DEMAND - Request a user initiated heartbeat
2349 *                     to be made immediately.
2350 *
2351 *                     SPP_HB_TIME_IS_ZERO - Specify's that the time for
2352 *                     heartbeat delayis to be set to the value of 0
2353 *                     milliseconds.
2354 *
2355 *                     SPP_PMTUD_ENABLE - This field will enable PMTU
2356 *                     discovery upon the specified address. Note that
2357 *                     if the address feild is empty then all addresses
2358 *                     on the association are effected.
2359 *
2360 *                     SPP_PMTUD_DISABLE - This field will disable PMTU
2361 *                     discovery upon the specified address. Note that
2362 *                     if the address feild is empty then all addresses
2363 *                     on the association are effected. Not also that
2364 *                     SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2365 *                     exclusive. Enabling both will have undetermined
2366 *                     results.
2367 *
2368 *                     SPP_SACKDELAY_ENABLE - Setting this flag turns
2369 *                     on delayed sack. The time specified in spp_sackdelay
2370 *                     is used to specify the sack delay for this address. Note
2371 *                     that if spp_address is empty then all addresses will
2372 *                     enable delayed sack and take on the sack delay
2373 *                     value specified in spp_sackdelay.
2374 *                     SPP_SACKDELAY_DISABLE - Setting this flag turns
2375 *                     off delayed sack. If the spp_address field is blank then
2376 *                     delayed sack is disabled for the entire association. Note
2377 *                     also that this field is mutually exclusive to
2378 *                     SPP_SACKDELAY_ENABLE, setting both will have undefined
2379 *                     results.
2380 *
2381 *                     SPP_IPV6_FLOWLABEL:  Setting this flag enables the
2382 *                     setting of the IPV6 flow label value.  The value is
2383 *                     contained in the spp_ipv6_flowlabel field.
2384 *                     Upon retrieval, this flag will be set to indicate that
2385 *                     the spp_ipv6_flowlabel field has a valid value returned.
2386 *                     If a specific destination address is set (in the
2387 *                     spp_address field), then the value returned is that of
2388 *                     the address.  If just an association is specified (and
2389 *                     no address), then the association's default flow label
2390 *                     is returned.  If neither an association nor a destination
2391 *                     is specified, then the socket's default flow label is
2392 *                     returned.  For non-IPv6 sockets, this flag will be left
2393 *                     cleared.
2394 *
2395 *                     SPP_DSCP:  Setting this flag enables the setting of the
2396 *                     Differentiated Services Code Point (DSCP) value
2397 *                     associated with either the association or a specific
2398 *                     address.  The value is obtained in the spp_dscp field.
2399 *                     Upon retrieval, this flag will be set to indicate that
2400 *                     the spp_dscp field has a valid value returned.  If a
2401 *                     specific destination address is set when called (in the
2402 *                     spp_address field), then that specific destination
2403 *                     address's DSCP value is returned.  If just an association
2404 *                     is specified, then the association's default DSCP is
2405 *                     returned.  If neither an association nor a destination is
2406 *                     specified, then the socket's default DSCP is returned.
2407 *
2408 *   spp_ipv6_flowlabel
2409 *                   - This field is used in conjunction with the
2410 *                     SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
2411 *                     The 20 least significant bits are used for the flow
2412 *                     label.  This setting has precedence over any IPv6-layer
2413 *                     setting.
2414 *
2415 *   spp_dscp        - This field is used in conjunction with the SPP_DSCP flag
2416 *                     and contains the DSCP.  The 6 most significant bits are
2417 *                     used for the DSCP.  This setting has precedence over any
2418 *                     IPv4- or IPv6- layer setting.
2419 */
2420static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2421                                       struct sctp_transport   *trans,
2422                                       struct sctp_association *asoc,
2423                                       struct sctp_sock        *sp,
2424                                       int                      hb_change,
2425                                       int                      pmtud_change,
2426                                       int                      sackdelay_change)
2427{
2428        int error;
2429
2430        if (params->spp_flags & SPP_HB_DEMAND && trans) {
2431                struct net *net = sock_net(trans->asoc->base.sk);
2432
2433                error = sctp_primitive_REQUESTHEARTBEAT(net, trans->asoc, trans);
2434                if (error)
2435                        return error;
2436        }
2437
2438        /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2439         * this field is ignored.  Note also that a value of zero indicates
2440         * the current setting should be left unchanged.
2441         */
2442        if (params->spp_flags & SPP_HB_ENABLE) {
2443
2444                /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2445                 * set.  This lets us use 0 value when this flag
2446                 * is set.
2447                 */
2448                if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2449                        params->spp_hbinterval = 0;
2450
2451                if (params->spp_hbinterval ||
2452                    (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2453                        if (trans) {
2454                                trans->hbinterval =
2455                                    msecs_to_jiffies(params->spp_hbinterval);
2456                        } else if (asoc) {
2457                                asoc->hbinterval =
2458                                    msecs_to_jiffies(params->spp_hbinterval);
2459                        } else {
2460                                sp->hbinterval = params->spp_hbinterval;
2461                        }
2462                }
2463        }
2464
2465        if (hb_change) {
2466                if (trans) {
2467                        trans->param_flags =
2468                                (trans->param_flags & ~SPP_HB) | hb_change;
2469                } else if (asoc) {
2470                        asoc->param_flags =
2471                                (asoc->param_flags & ~SPP_HB) | hb_change;
2472                } else {
2473                        sp->param_flags =
2474                                (sp->param_flags & ~SPP_HB) | hb_change;
2475                }
2476        }
2477
2478        /* When Path MTU discovery is disabled the value specified here will
2479         * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2480         * include the flag SPP_PMTUD_DISABLE for this field to have any
2481         * effect).
2482         */
2483        if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2484                if (trans) {
2485                        trans->pathmtu = params->spp_pathmtu;
2486                        sctp_assoc_sync_pmtu(asoc);
2487                } else if (asoc) {
2488                        sctp_assoc_set_pmtu(asoc, params->spp_pathmtu);
2489                } else {
2490                        sp->pathmtu = params->spp_pathmtu;
2491                }
2492        }
2493
2494        if (pmtud_change) {
2495                if (trans) {
2496                        int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2497                                (params->spp_flags & SPP_PMTUD_ENABLE);
2498                        trans->param_flags =
2499                                (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2500                        if (update) {
2501                                sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2502                                sctp_assoc_sync_pmtu(asoc);
2503                        }
2504                } else if (asoc) {
2505                        asoc->param_flags =
2506                                (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2507                } else {
2508                        sp->param_flags =
2509                                (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2510                }
2511        }
2512
2513        /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2514         * value of this field is ignored.  Note also that a value of zero
2515         * indicates the current setting should be left unchanged.
2516         */
2517        if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2518                if (trans) {
2519                        trans->sackdelay =
2520                                msecs_to_jiffies(params->spp_sackdelay);
2521                } else if (asoc) {
2522                        asoc->sackdelay =
2523                                msecs_to_jiffies(params->spp_sackdelay);
2524                } else {
2525                        sp->sackdelay = params->spp_sackdelay;
2526                }
2527        }
2528
2529        if (sackdelay_change) {
2530                if (trans) {
2531                        trans->param_flags =
2532                                (trans->param_flags & ~SPP_SACKDELAY) |
2533                                sackdelay_change;
2534                } else if (asoc) {
2535                        asoc->param_flags =
2536                                (asoc->param_flags & ~SPP_SACKDELAY) |
2537                                sackdelay_change;
2538                } else {
2539                        sp->param_flags =
2540                                (sp->param_flags & ~SPP_SACKDELAY) |
2541                                sackdelay_change;
2542                }
2543        }
2544
2545        /* Note that a value of zero indicates the current setting should be
2546           left unchanged.
2547         */
2548        if (params->spp_pathmaxrxt) {
2549                if (trans) {
2550                        trans->pathmaxrxt = params->spp_pathmaxrxt;
2551                } else if (asoc) {
2552                        asoc->pathmaxrxt = params->spp_pathmaxrxt;
2553                } else {
2554                        sp->pathmaxrxt = params->spp_pathmaxrxt;
2555                }
2556        }
2557
2558        if (params->spp_flags & SPP_IPV6_FLOWLABEL) {
2559                if (trans) {
2560                        if (trans->ipaddr.sa.sa_family == AF_INET6) {
2561                                trans->flowlabel = params->spp_ipv6_flowlabel &
2562                                                   SCTP_FLOWLABEL_VAL_MASK;
2563                                trans->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2564                        }
2565                } else if (asoc) {
2566                        struct sctp_transport *t;
2567
2568                        list_for_each_entry(t, &asoc->peer.transport_addr_list,
2569                                            transports) {
2570                                if (t->ipaddr.sa.sa_family != AF_INET6)
2571                                        continue;
2572                                t->flowlabel = params->spp_ipv6_flowlabel &
2573                                               SCTP_FLOWLABEL_VAL_MASK;
2574                                t->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2575                        }
2576                        asoc->flowlabel = params->spp_ipv6_flowlabel &
2577                                          SCTP_FLOWLABEL_VAL_MASK;
2578                        asoc->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2579                } else if (sctp_opt2sk(sp)->sk_family == AF_INET6) {
2580                        sp->flowlabel = params->spp_ipv6_flowlabel &
2581                                        SCTP_FLOWLABEL_VAL_MASK;
2582                        sp->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2583                }
2584        }
2585
2586        if (params->spp_flags & SPP_DSCP) {
2587                if (trans) {
2588                        trans->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2589                        trans->dscp |= SCTP_DSCP_SET_MASK;
2590                } else if (asoc) {
2591                        struct sctp_transport *t;
2592
2593                        list_for_each_entry(t, &asoc->peer.transport_addr_list,
2594                                            transports) {
2595                                t->dscp = params->spp_dscp &
2596                                          SCTP_DSCP_VAL_MASK;
2597                                t->dscp |= SCTP_DSCP_SET_MASK;
2598                        }
2599                        asoc->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2600                        asoc->dscp |= SCTP_DSCP_SET_MASK;
2601                } else {
2602                        sp->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2603                        sp->dscp |= SCTP_DSCP_SET_MASK;
2604                }
2605        }
2606
2607        return 0;
2608}
2609
2610static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2611                                            char __user *optval,
2612                                            unsigned int optlen)
2613{
2614        struct sctp_paddrparams  params;
2615        struct sctp_transport   *trans = NULL;
2616        struct sctp_association *asoc = NULL;
2617        struct sctp_sock        *sp = sctp_sk(sk);
2618        int error;
2619        int hb_change, pmtud_change, sackdelay_change;
2620
2621        if (optlen == sizeof(params)) {
2622                if (copy_from_user(&params, optval, optlen))
2623                        return -EFAULT;
2624        } else if (optlen == ALIGN(offsetof(struct sctp_paddrparams,
2625                                            spp_ipv6_flowlabel), 4)) {
2626                if (copy_from_user(&params, optval, optlen))
2627                        return -EFAULT;
2628                if (params.spp_flags & (SPP_DSCP | SPP_IPV6_FLOWLABEL))
2629                        return -EINVAL;
2630        } else {
2631                return -EINVAL;
2632        }
2633
2634        /* Validate flags and value parameters. */
2635        hb_change        = params.spp_flags & SPP_HB;
2636        pmtud_change     = params.spp_flags & SPP_PMTUD;
2637        sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2638
2639        if (hb_change        == SPP_HB ||
2640            pmtud_change     == SPP_PMTUD ||
2641            sackdelay_change == SPP_SACKDELAY ||
2642            params.spp_sackdelay > 500 ||
2643            (params.spp_pathmtu &&
2644             params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2645                return -EINVAL;
2646
2647        /* If an address other than INADDR_ANY is specified, and
2648         * no transport is found, then the request is invalid.
2649         */
2650        if (!sctp_is_any(sk, (union sctp_addr *)&params.spp_address)) {
2651                trans = sctp_addr_id2transport(sk, &params.spp_address,
2652                                               params.spp_assoc_id);
2653                if (!trans)
2654                        return -EINVAL;
2655        }
2656
2657        /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
2658         * socket is a one to many style socket, and an association
2659         * was not found, then the id was invalid.
2660         */
2661        asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2662        if (!asoc && params.spp_assoc_id != SCTP_FUTURE_ASSOC &&
2663            sctp_style(sk, UDP))
2664                return -EINVAL;
2665
2666        /* Heartbeat demand can only be sent on a transport or
2667         * association, but not a socket.
2668         */
2669        if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2670                return -EINVAL;
2671
2672        /* Process parameters. */
2673        error = sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2674                                            hb_change, pmtud_change,
2675                                            sackdelay_change);
2676
2677        if (error)
2678                return error;
2679
2680        /* If changes are for association, also apply parameters to each
2681         * transport.
2682         */
2683        if (!trans && asoc) {
2684                list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2685                                transports) {
2686                        sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2687                                                    hb_change, pmtud_change,
2688                                                    sackdelay_change);
2689                }
2690        }
2691
2692        return 0;
2693}
2694
2695static inline __u32 sctp_spp_sackdelay_enable(__u32 param_flags)
2696{
2697        return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_ENABLE;
2698}
2699
2700static inline __u32 sctp_spp_sackdelay_disable(__u32 param_flags)
2701{
2702        return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_DISABLE;
2703}
2704
2705static void sctp_apply_asoc_delayed_ack(struct sctp_sack_info *params,
2706                                        struct sctp_association *asoc)
2707{
2708        struct sctp_transport *trans;
2709
2710        if (params->sack_delay) {
2711                asoc->sackdelay = msecs_to_jiffies(params->sack_delay);
2712                asoc->param_flags =
2713                        sctp_spp_sackdelay_enable(asoc->param_flags);
2714        }
2715        if (params->sack_freq == 1) {
2716                asoc->param_flags =
2717                        sctp_spp_sackdelay_disable(asoc->param_flags);
2718        } else if (params->sack_freq > 1) {
2719                asoc->sackfreq = params->sack_freq;
2720                asoc->param_flags =
2721                        sctp_spp_sackdelay_enable(asoc->param_flags);
2722        }
2723
2724        list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2725                            transports) {
2726                if (params->sack_delay) {
2727                        trans->sackdelay = msecs_to_jiffies(params->sack_delay);
2728                        trans->param_flags =
2729                                sctp_spp_sackdelay_enable(trans->param_flags);
2730                }
2731                if (params->sack_freq == 1) {
2732                        trans->param_flags =
2733                                sctp_spp_sackdelay_disable(trans->param_flags);
2734                } else if (params->sack_freq > 1) {
2735                        trans->sackfreq = params->sack_freq;
2736                        trans->param_flags =
2737                                sctp_spp_sackdelay_enable(trans->param_flags);
2738                }
2739        }
2740}
2741
2742/*
2743 * 7.1.23.  Get or set delayed ack timer (SCTP_DELAYED_SACK)
2744 *
2745 * This option will effect the way delayed acks are performed.  This
2746 * option allows you to get or set the delayed ack time, in
2747 * milliseconds.  It also allows changing the delayed ack frequency.
2748 * Changing the frequency to 1 disables the delayed sack algorithm.  If
2749 * the assoc_id is 0, then this sets or gets the endpoints default
2750 * values.  If the assoc_id field is non-zero, then the set or get
2751 * effects the specified association for the one to many model (the
2752 * assoc_id field is ignored by the one to one model).  Note that if
2753 * sack_delay or sack_freq are 0 when setting this option, then the
2754 * current values will remain unchanged.
2755 *
2756 * struct sctp_sack_info {
2757 *     sctp_assoc_t            sack_assoc_id;
2758 *     uint32_t                sack_delay;
2759 *     uint32_t                sack_freq;
2760 * };
2761 *
2762 * sack_assoc_id -  This parameter, indicates which association the user
2763 *    is performing an action upon.  Note that if this field's value is
2764 *    zero then the endpoints default value is changed (effecting future
2765 *    associations only).
2766 *
2767 * sack_delay -  This parameter contains the number of milliseconds that
2768 *    the user is requesting the delayed ACK timer be set to.  Note that
2769 *    this value is defined in the standard to be between 200 and 500
2770 *    milliseconds.
2771 *
2772 * sack_freq -  This parameter contains the number of packets that must
2773 *    be received before a sack is sent without waiting for the delay
2774 *    timer to expire.  The default value for this is 2, setting this
2775 *    value to 1 will disable the delayed sack algorithm.
2776 */
2777
2778static int sctp_setsockopt_delayed_ack(struct sock *sk,
2779                                       char __user *optval, unsigned int optlen)
2780{
2781        struct sctp_sock *sp = sctp_sk(sk);
2782        struct sctp_association *asoc;
2783        struct sctp_sack_info params;
2784
2785        if (optlen == sizeof(struct sctp_sack_info)) {
2786                if (copy_from_user(&params, optval, optlen))
2787                        return -EFAULT;
2788
2789                if (params.sack_delay == 0 && params.sack_freq == 0)
2790                        return 0;
2791        } else if (optlen == sizeof(struct sctp_assoc_value)) {
2792                pr_warn_ratelimited(DEPRECATED
2793                                    "%s (pid %d) "
2794                                    "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2795                                    "Use struct sctp_sack_info instead\n",
2796                                    current->comm, task_pid_nr(current));
2797                if (copy_from_user(&params, optval, optlen))
2798                        return -EFAULT;
2799
2800                if (params.sack_delay == 0)
2801                        params.sack_freq = 1;
2802                else
2803                        params.sack_freq = 0;
2804        } else
2805                return -EINVAL;
2806
2807        /* Validate value parameter. */
2808        if (params.sack_delay > 500)
2809                return -EINVAL;
2810
2811        /* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
2812         * socket is a one to many style socket, and an association
2813         * was not found, then the id was invalid.
2814         */
2815        asoc = sctp_id2assoc(sk, params.sack_assoc_id);
2816        if (!asoc && params.sack_assoc_id > SCTP_ALL_ASSOC &&
2817            sctp_style(sk, UDP))
2818                return -EINVAL;
2819
2820        if (asoc) {
2821                sctp_apply_asoc_delayed_ack(&params, asoc);
2822
2823                return 0;
2824        }
2825
2826        if (sctp_style(sk, TCP))
2827                params.sack_assoc_id = SCTP_FUTURE_ASSOC;
2828
2829        if (params.sack_assoc_id == SCTP_FUTURE_ASSOC ||
2830            params.sack_assoc_id == SCTP_ALL_ASSOC) {
2831                if (params.sack_delay) {
2832                        sp->sackdelay = params.sack_delay;
2833                        sp->param_flags =
2834                                sctp_spp_sackdelay_enable(sp->param_flags);
2835                }
2836                if (params.sack_freq == 1) {
2837                        sp->param_flags =
2838                                sctp_spp_sackdelay_disable(sp->param_flags);
2839                } else if (params.sack_freq > 1) {
2840                        sp->sackfreq = params.sack_freq;
2841                        sp->param_flags =
2842                                sctp_spp_sackdelay_enable(sp->param_flags);
2843                }
2844        }
2845
2846        if (params.sack_assoc_id == SCTP_CURRENT_ASSOC ||
2847            params.sack_assoc_id == SCTP_ALL_ASSOC)
2848                list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2849                        sctp_apply_asoc_delayed_ack(&params, asoc);
2850
2851        return 0;
2852}
2853
2854/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2855 *
2856 * Applications can specify protocol parameters for the default association
2857 * initialization.  The option name argument to setsockopt() and getsockopt()
2858 * is SCTP_INITMSG.
2859 *
2860 * Setting initialization parameters is effective only on an unconnected
2861 * socket (for UDP-style sockets only future associations are effected
2862 * by the change).  With TCP-style sockets, this option is inherited by
2863 * sockets derived from a listener socket.
2864 */
2865static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen)
2866{
2867        struct sctp_initmsg sinit;
2868        struct sctp_sock *sp = sctp_sk(sk);
2869
2870        if (optlen != sizeof(struct sctp_initmsg))
2871                return -EINVAL;
2872        if (copy_from_user(&sinit, optval, optlen))
2873                return -EFAULT;
2874
2875        if (sinit.sinit_num_ostreams)
2876                sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
2877        if (sinit.sinit_max_instreams)
2878                sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
2879        if (sinit.sinit_max_attempts)
2880                sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
2881        if (sinit.sinit_max_init_timeo)
2882                sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
2883
2884        return 0;
2885}
2886
2887/*
2888 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2889 *
2890 *   Applications that wish to use the sendto() system call may wish to
2891 *   specify a default set of parameters that would normally be supplied
2892 *   through the inclusion of ancillary data.  This socket option allows
2893 *   such an application to set the default sctp_sndrcvinfo structure.
2894 *   The application that wishes to use this socket option simply passes
2895 *   in to this call the sctp_sndrcvinfo structure defined in Section
2896 *   5.2.2) The input parameters accepted by this call include
2897 *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2898 *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
2899 *   to this call if the caller is using the UDP model.
2900 */
2901static int sctp_setsockopt_default_send_param(struct sock *sk,
2902                                              char __user *optval,
2903                                              unsigned int optlen)
2904{
2905        struct sctp_sock *sp = sctp_sk(sk);
2906        struct sctp_association *asoc;
2907        struct sctp_sndrcvinfo info;
2908
2909        if (optlen != sizeof(info))
2910                return -EINVAL;
2911        if (copy_from_user(&info, optval, optlen))
2912                return -EFAULT;
2913        if (info.sinfo_flags &
2914            ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2915              SCTP_ABORT | SCTP_EOF))
2916                return -EINVAL;
2917
2918        asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2919        if (!asoc && info.sinfo_assoc_id > SCTP_ALL_ASSOC &&
2920            sctp_style(sk, UDP))
2921                return -EINVAL;
2922
2923        if (asoc) {
2924                asoc->default_stream = info.sinfo_stream;
2925                asoc->default_flags = info.sinfo_flags;
2926                asoc->default_ppid = info.sinfo_ppid;
2927                asoc->default_context = info.sinfo_context;
2928                asoc->default_timetolive = info.sinfo_timetolive;
2929
2930                return 0;
2931        }
2932
2933        if (sctp_style(sk, TCP))
2934                info.sinfo_assoc_id = SCTP_FUTURE_ASSOC;
2935
2936        if (info.sinfo_assoc_id == SCTP_FUTURE_ASSOC ||
2937            info.sinfo_assoc_id == SCTP_ALL_ASSOC) {
2938                sp->default_stream = info.sinfo_stream;
2939                sp->default_flags = info.sinfo_flags;
2940                sp->default_ppid = info.sinfo_ppid;
2941                sp->default_context = info.sinfo_context;
2942                sp->default_timetolive = info.sinfo_timetolive;
2943        }
2944
2945        if (info.sinfo_assoc_id == SCTP_CURRENT_ASSOC ||
2946            info.sinfo_assoc_id == SCTP_ALL_ASSOC) {
2947                list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
2948                        asoc->default_stream = info.sinfo_stream;
2949                        asoc->default_flags = info.sinfo_flags;
2950                        asoc->default_ppid = info.sinfo_ppid;
2951                        asoc->default_context = info.sinfo_context;
2952                        asoc->default_timetolive = info.sinfo_timetolive;
2953                }
2954        }
2955
2956        return 0;
2957}
2958
2959/* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2960 * (SCTP_DEFAULT_SNDINFO)
2961 */
2962static int sctp_setsockopt_default_sndinfo(struct sock *sk,
2963                                           char __user *optval,
2964                                           unsigned int optlen)
2965{
2966        struct sctp_sock *sp = sctp_sk(sk);
2967        struct sctp_association *asoc;
2968        struct sctp_sndinfo info;
2969
2970        if (optlen != sizeof(info))
2971                return -EINVAL;
2972        if (copy_from_user(&info, optval, optlen))
2973                return -EFAULT;
2974        if (info.snd_flags &
2975            ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2976              SCTP_ABORT | SCTP_EOF))
2977                return -EINVAL;
2978
2979        asoc = sctp_id2assoc(sk, info.snd_assoc_id);
2980        if (!asoc && info.snd_assoc_id > SCTP_ALL_ASSOC &&
2981            sctp_style(sk, UDP))
2982                return -EINVAL;
2983
2984        if (asoc) {
2985                asoc->default_stream = info.snd_sid;
2986                asoc->default_flags = info.snd_flags;
2987                asoc->default_ppid = info.snd_ppid;
2988                asoc->default_context = info.snd_context;
2989
2990                return 0;
2991        }
2992
2993        if (sctp_style(sk, TCP))
2994                info.snd_assoc_id = SCTP_FUTURE_ASSOC;
2995
2996        if (info.snd_assoc_id == SCTP_FUTURE_ASSOC ||
2997            info.snd_assoc_id == SCTP_ALL_ASSOC) {
2998                sp->default_stream = info.snd_sid;
2999                sp->default_flags = info.snd_flags;
3000                sp->default_ppid = info.snd_ppid;
3001                sp->default_context = info.snd_context;
3002        }
3003
3004        if (info.snd_assoc_id == SCTP_CURRENT_ASSOC ||
3005            info.snd_assoc_id == SCTP_ALL_ASSOC) {
3006                list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
3007                        asoc->default_stream = info.snd_sid;
3008                        asoc->default_flags = info.snd_flags;
3009                        asoc->default_ppid = info.snd_ppid;
3010                        asoc->default_context = info.snd_context;
3011                }
3012        }
3013
3014        return 0;
3015}
3016
3017/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
3018 *
3019 * Requests that the local SCTP stack use the enclosed peer address as
3020 * the association primary.  The enclosed address must be one of the
3021 * association peer's addresses.
3022 */
3023static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
3024                                        unsigned int optlen)
3025{
3026        struct sctp_prim prim;
3027        struct sctp_transport *trans;
3028        struct sctp_af *af;
3029        int err;
3030
3031        if (optlen != sizeof(struct sctp_prim))
3032                return -EINVAL;
3033
3034        if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
3035                return -EFAULT;
3036
3037        /* Allow security module to validate address but need address len. */
3038        af = sctp_get_af_specific(prim.ssp_addr.ss_family);
3039        if (!af)
3040                return -EINVAL;
3041
3042        err = security_sctp_bind_connect(sk, SCTP_PRIMARY_ADDR,
3043                                         (struct sockaddr *)&prim.ssp_addr,
3044                                         af->sockaddr_len);
3045        if (err)
3046                return err;
3047
3048        trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
3049        if (!trans)
3050                return -EINVAL;
3051
3052        sctp_assoc_set_primary(trans->asoc, trans);
3053
3054        return 0;
3055}
3056
3057/*
3058 * 7.1.5 SCTP_NODELAY
3059 *
3060 * Turn on/off any Nagle-like algorithm.  This means that packets are
3061 * generally sent as soon as possible and no unnecessary delays are
3062 * introduced, at the cost of more packets in the network.  Expects an
3063 *  integer boolean flag.
3064 */
3065static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
3066                                   unsigned int optlen)
3067{
3068        int val;
3069
3070        if (optlen < sizeof(int))
3071                return -EINVAL;
3072        if (get_user(val, (int __user *)optval))
3073                return -EFAULT;
3074
3075        sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
3076        return 0;
3077}
3078
3079/*
3080 *
3081 * 7.1.1 SCTP_RTOINFO
3082 *
3083 * The protocol parameters used to initialize and bound retransmission
3084 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3085 * and modify these parameters.
3086 * All parameters are time values, in milliseconds.  A value of 0, when
3087 * modifying the parameters, indicates that the current value should not
3088 * be changed.
3089 *
3090 */
3091static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen)
3092{
3093        struct sctp_rtoinfo rtoinfo;
3094        struct sctp_association *asoc;
3095        unsigned long rto_min, rto_max;
3096        struct sctp_sock *sp = sctp_sk(sk);
3097
3098        if (optlen != sizeof (struct sctp_rtoinfo))
3099                return -EINVAL;
3100
3101        if (copy_from_user(&rtoinfo, optval, optlen))
3102                return -EFAULT;
3103
3104        asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
3105
3106        /* Set the values to the specific association */
3107        if (!asoc && rtoinfo.srto_assoc_id != SCTP_FUTURE_ASSOC &&
3108            sctp_style(sk, UDP))
3109                return -EINVAL;
3110
3111        rto_max = rtoinfo.srto_max;
3112        rto_min = rtoinfo.srto_min;
3113
3114        if (rto_max)
3115                rto_max = asoc ? msecs_to_jiffies(rto_max) : rto_max;
3116        else
3117                rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
3118
3119        if (rto_min)
3120                rto_min = asoc ? msecs_to_jiffies(rto_min) : rto_min;
3121        else
3122                rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
3123
3124        if (rto_min > rto_max)
3125                return -EINVAL;
3126
3127        if (asoc) {
3128                if (rtoinfo.srto_initial != 0)
3129                        asoc->rto_initial =
3130                                msecs_to_jiffies(rtoinfo.srto_initial);
3131                asoc->rto_max = rto_max;
3132                asoc->rto_min = rto_min;
3133        } else {
3134                /* If there is no association or the association-id = 0
3135                 * set the values to the endpoint.
3136                 */
3137                if (rtoinfo.srto_initial != 0)
3138                        sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
3139                sp->rtoinfo.srto_max = rto_max;
3140                sp->rtoinfo.srto_min = rto_min;
3141        }
3142
3143        return 0;
3144}
3145
3146/*
3147 *
3148 * 7.1.2 SCTP_ASSOCINFO
3149 *
3150 * This option is used to tune the maximum retransmission attempts
3151 * of the association.
3152 * Returns an error if the new association retransmission value is
3153 * greater than the sum of the retransmission value  of the peer.
3154 * See [SCTP] for more information.
3155 *
3156 */
3157static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen)
3158{
3159
3160        struct sctp_assocparams assocparams;
3161        struct sctp_association *asoc;
3162
3163        if (optlen != sizeof(struct sctp_assocparams))
3164                return -EINVAL;
3165        if (copy_from_user(&assocparams, optval, optlen))
3166                return -EFAULT;
3167
3168        asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
3169
3170        if (!asoc && assocparams.sasoc_assoc_id != SCTP_FUTURE_ASSOC &&
3171            sctp_style(sk, UDP))
3172                return -EINVAL;
3173
3174        /* Set the values to the specific association */
3175        if (asoc) {
3176                if (assocparams.sasoc_asocmaxrxt != 0) {
3177                        __u32 path_sum = 0;
3178                        int   paths = 0;
3179                        struct sctp_transport *peer_addr;
3180
3181                        list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
3182                                        transports) {
3183                                path_sum += peer_addr->pathmaxrxt;
3184                                paths++;
3185                        }
3186
3187                        /* Only validate asocmaxrxt if we have more than
3188                         * one path/transport.  We do this because path
3189                         * retransmissions are only counted when we have more
3190                         * then one path.
3191                         */
3192                        if (paths > 1 &&
3193                            assocparams.sasoc_asocmaxrxt > path_sum)
3194                                return -EINVAL;
3195
3196                        asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
3197                }
3198
3199                if (assocparams.sasoc_cookie_life != 0)
3200                        asoc->cookie_life = ms_to_ktime(assocparams.sasoc_cookie_life);
3201        } else {
3202                /* Set the values to the endpoint */
3203                struct sctp_sock *sp = sctp_sk(sk);
3204
3205                if (assocparams.sasoc_asocmaxrxt != 0)
3206                        sp->assocparams.sasoc_asocmaxrxt =
3207                                                assocparams.sasoc_asocmaxrxt;
3208                if (assocparams.sasoc_cookie_life != 0)
3209                        sp->assocparams.sasoc_cookie_life =
3210                                                assocparams.sasoc_cookie_life;
3211        }
3212        return 0;
3213}
3214
3215/*
3216 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3217 *
3218 * This socket option is a boolean flag which turns on or off mapped V4
3219 * addresses.  If this option is turned on and the socket is type
3220 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3221 * If this option is turned off, then no mapping will be done of V4
3222 * addresses and a user will receive both PF_INET6 and PF_INET type
3223 * addresses on the socket.
3224 */
3225static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen)
3226{
3227        int val;
3228        struct sctp_sock *sp = sctp_sk(sk);
3229
3230        if (optlen < sizeof(int))
3231                return -EINVAL;
3232        if (get_user(val, (int __user *)optval))
3233                return -EFAULT;
3234        if (val)
3235                sp->v4mapped = 1;
3236        else
3237                sp->v4mapped = 0;
3238
3239        return 0;
3240}
3241
3242/*
3243 * 8.1.16.  Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3244 * This option will get or set the maximum size to put in any outgoing
3245 * SCTP DATA chunk.  If a message is larger than this size it will be
3246 * fragmented by SCTP into the specified size.  Note that the underlying
3247 * SCTP implementation may fragment into smaller sized chunks when the
3248 * PMTU of the underlying association is smaller than the value set by
3249 * the user.  The default value for this option is '0' which indicates
3250 * the user is NOT limiting fragmentation and only the PMTU will effect
3251 * SCTP's choice of DATA chunk size.  Note also that values set larger
3252 * than the maximum size of an IP datagram will effectively let SCTP
3253 * control fragmentation (i.e. the same as setting this option to 0).
3254 *
3255 * The following structure is used to access and modify this parameter:
3256 *
3257 * struct sctp_assoc_value {
3258 *   sctp_assoc_t assoc_id;
3259 *   uint32_t assoc_value;
3260 * };
3261 *
3262 * assoc_id:  This parameter is ignored for one-to-one style sockets.
3263 *    For one-to-many style sockets this parameter indicates which
3264 *    association the user is performing an action upon.  Note that if
3265 *    this field's value is zero then the endpoints default value is
3266 *    changed (effecting future associations only).
3267 * assoc_value:  This parameter specifies the maximum size in bytes.
3268 */
3269static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen)
3270{
3271        struct sctp_sock *sp = sctp_sk(sk);
3272        struct sctp_assoc_value params;
3273        struct sctp_association *asoc;
3274        int val;
3275
3276        if (optlen == sizeof(int)) {
3277                pr_warn_ratelimited(DEPRECATED
3278                                    "%s (pid %d) "
3279                                    "Use of int in maxseg socket option.\n"
3280                                    "Use struct sctp_assoc_value instead\n",
3281                                    current->comm, task_pid_nr(current));
3282                if (copy_from_user(&val, optval, optlen))
3283                        return -EFAULT;
3284                params.assoc_id = SCTP_FUTURE_ASSOC;
3285        } else if (optlen == sizeof(struct sctp_assoc_value)) {
3286                if (copy_from_user(&params, optval, optlen))
3287                        return -EFAULT;
3288                val = params.assoc_value;
3289        } else {
3290                return -EINVAL;
3291        }
3292
3293        asoc = sctp_id2assoc(sk, params.assoc_id);
3294        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
3295            sctp_style(sk, UDP))
3296                return -EINVAL;
3297
3298        if (val) {
3299                int min_len, max_len;
3300                __u16 datasize = asoc ? sctp_datachk_len(&asoc->stream) :
3301                                 sizeof(struct sctp_data_chunk);
3302
3303                min_len = sctp_min_frag_point(sp, datasize);
3304                max_len = SCTP_MAX_CHUNK_LEN - datasize;
3305
3306                if (val < min_len || val > max_len)
3307                        return -EINVAL;
3308        }
3309
3310        if (asoc) {
3311                asoc->user_frag = val;
3312                sctp_assoc_update_frag_point(asoc);
3313        } else {
3314                sp->user_frag = val;
3315        }
3316
3317        return 0;
3318}
3319
3320
3321/*
3322 *  7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3323 *
3324 *   Requests that the peer mark the enclosed address as the association
3325 *   primary. The enclosed address must be one of the association's
3326 *   locally bound addresses. The following structure is used to make a
3327 *   set primary request:
3328 */
3329static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
3330                                             unsigned int optlen)
3331{
3332        struct sctp_sock        *sp;
3333        struct sctp_association *asoc = NULL;
3334        struct sctp_setpeerprim prim;
3335        struct sctp_chunk       *chunk;
3336        struct sctp_af          *af;
3337        int                     err;
3338
3339        sp = sctp_sk(sk);
3340
3341        if (!sp->ep->asconf_enable)
3342                return -EPERM;
3343
3344        if (optlen != sizeof(struct sctp_setpeerprim))
3345                return -EINVAL;
3346
3347        if (copy_from_user(&prim, optval, optlen))
3348                return -EFAULT;
3349
3350        asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
3351        if (!asoc)
3352                return -EINVAL;
3353
3354        if (!asoc->peer.asconf_capable)
3355                return -EPERM;
3356
3357        if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3358                return -EPERM;
3359
3360        if (!sctp_state(asoc, ESTABLISHED))
3361                return -ENOTCONN;
3362
3363        af = sctp_get_af_specific(prim.sspp_addr.ss_family);
3364        if (!af)
3365                return -EINVAL;
3366
3367        if (!af->addr_valid((union sctp_addr *)&prim.sspp_addr, sp, NULL))
3368                return -EADDRNOTAVAIL;
3369
3370        if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
3371                return -EADDRNOTAVAIL;
3372
3373        /* Allow security module to validate address. */
3374        err = security_sctp_bind_connect(sk, SCTP_SET_PEER_PRIMARY_ADDR,
3375                                         (struct sockaddr *)&prim.sspp_addr,
3376                                         af->sockaddr_len);
3377        if (err)
3378                return err;
3379
3380        /* Create an ASCONF chunk with SET_PRIMARY parameter    */
3381        chunk = sctp_make_asconf_set_prim(asoc,
3382                                          (union sctp_addr *)&prim.sspp_addr);
3383        if (!chunk)
3384                return -ENOMEM;
3385
3386        err = sctp_send_asconf(asoc, chunk);
3387
3388        pr_debug("%s: we set peer primary addr primitively\n", __func__);
3389
3390        return err;
3391}
3392
3393static int sctp_setsockopt_adaptation_layer(struct sock *sk, char __user *optval,
3394                                            unsigned int optlen)
3395{
3396        struct sctp_setadaptation adaptation;
3397
3398        if (optlen != sizeof(struct sctp_setadaptation))
3399                return -EINVAL;
3400        if (copy_from_user(&adaptation, optval, optlen))
3401                return -EFAULT;
3402
3403        sctp_sk(sk)->adaptation_ind = adaptation.ssb_adaptation_ind;
3404
3405        return 0;
3406}
3407
3408/*
3409 * 7.1.29.  Set or Get the default context (SCTP_CONTEXT)
3410 *
3411 * The context field in the sctp_sndrcvinfo structure is normally only
3412 * used when a failed message is retrieved holding the value that was
3413 * sent down on the actual send call.  This option allows the setting of
3414 * a default context on an association basis that will be received on
3415 * reading messages from the peer.  This is especially helpful in the
3416 * one-2-many model for an application to keep some reference to an
3417 * internal state machine that is processing messages on the
3418 * association.  Note that the setting of this value only effects
3419 * received messages from the peer and does not effect the value that is
3420 * saved with outbound messages.
3421 */
3422static int sctp_setsockopt_context(struct sock *sk, char __user *optval,
3423                                   unsigned int optlen)
3424{
3425        struct sctp_sock *sp = sctp_sk(sk);
3426        struct sctp_assoc_value params;
3427        struct sctp_association *asoc;
3428
3429        if (optlen != sizeof(struct sctp_assoc_value))
3430                return -EINVAL;
3431        if (copy_from_user(&params, optval, optlen))
3432                return -EFAULT;
3433
3434        asoc = sctp_id2assoc(sk, params.assoc_id);
3435        if (!asoc && params.assoc_id > SCTP_ALL_ASSOC &&
3436            sctp_style(sk, UDP))
3437                return -EINVAL;
3438
3439        if (asoc) {
3440                asoc->default_rcv_context = params.assoc_value;
3441
3442                return 0;
3443        }
3444
3445        if (sctp_style(sk, TCP))
3446                params.assoc_id = SCTP_FUTURE_ASSOC;
3447
3448        if (params.assoc_id == SCTP_FUTURE_ASSOC ||
3449            params.assoc_id == SCTP_ALL_ASSOC)
3450                sp->default_rcv_context = params.assoc_value;
3451
3452        if (params.assoc_id == SCTP_CURRENT_ASSOC ||
3453            params.assoc_id == SCTP_ALL_ASSOC)
3454                list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3455                        asoc->default_rcv_context = params.assoc_value;
3456
3457        return 0;
3458}
3459
3460/*
3461 * 7.1.24.  Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3462 *
3463 * This options will at a minimum specify if the implementation is doing
3464 * fragmented interleave.  Fragmented interleave, for a one to many
3465 * socket, is when subsequent calls to receive a message may return
3466 * parts of messages from different associations.  Some implementations
3467 * may allow you to turn this value on or off.  If so, when turned off,
3468 * no fragment interleave will occur (which will cause a head of line
3469 * blocking amongst multiple associations sharing the same one to many
3470 * socket).  When this option is turned on, then each receive call may
3471 * come from a different association (thus the user must receive data
3472 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3473 * association each receive belongs to.
3474 *
3475 * This option takes a boolean value.  A non-zero value indicates that
3476 * fragmented interleave is on.  A value of zero indicates that
3477 * fragmented interleave is off.
3478 *
3479 * Note that it is important that an implementation that allows this
3480 * option to be turned on, have it off by default.  Otherwise an unaware
3481 * application using the one to many model may become confused and act
3482 * incorrectly.
3483 */
3484static int sctp_setsockopt_fragment_interleave(struct sock *sk,
3485                                               char __user *optval,
3486                                               unsigned int optlen)
3487{
3488        int val;
3489
3490        if (optlen != sizeof(int))
3491                return -EINVAL;
3492        if (get_user(val, (int __user *)optval))
3493                return -EFAULT;
3494
3495        sctp_sk(sk)->frag_interleave = !!val;
3496
3497        if (!sctp_sk(sk)->frag_interleave)
3498                sctp_sk(sk)->ep->intl_enable = 0;
3499
3500        return 0;
3501}
3502
3503/*
3504 * 8.1.21.  Set or Get the SCTP Partial Delivery Point
3505 *       (SCTP_PARTIAL_DELIVERY_POINT)
3506 *
3507 * This option will set or get the SCTP partial delivery point.  This
3508 * point is the size of a message where the partial delivery API will be
3509 * invoked to help free up rwnd space for the peer.  Setting this to a
3510 * lower value will cause partial deliveries to happen more often.  The
3511 * calls argument is an integer that sets or gets the partial delivery
3512 * point.  Note also that the call will fail if the user attempts to set
3513 * this value larger than the socket receive buffer size.
3514 *
3515 * Note that any single message having a length smaller than or equal to
3516 * the SCTP partial delivery point will be delivered in one single read
3517 * call as long as the user provided buffer is large enough to hold the
3518 * message.
3519 */
3520static int sctp_setsockopt_partial_delivery_point(struct sock *sk,
3521                                                  char __user *optval,
3522                                                  unsigned int optlen)
3523{
3524        u32 val;
3525
3526        if (optlen != sizeof(u32))
3527                return -EINVAL;
3528        if (get_user(val, (int __user *)optval))
3529                return -EFAULT;
3530
3531        /* Note: We double the receive buffer from what the user sets
3532         * it to be, also initial rwnd is based on rcvbuf/2.
3533         */
3534        if (val > (sk->sk_rcvbuf >> 1))
3535                return -EINVAL;
3536
3537        sctp_sk(sk)->pd_point = val;
3538
3539        return 0; /* is this the right error code? */
3540}
3541
3542/*
3543 * 7.1.28.  Set or Get the maximum burst (SCTP_MAX_BURST)
3544 *
3545 * This option will allow a user to change the maximum burst of packets
3546 * that can be emitted by this association.  Note that the default value
3547 * is 4, and some implementations may restrict this setting so that it
3548 * can only be lowered.
3549 *
3550 * NOTE: This text doesn't seem right.  Do this on a socket basis with
3551 * future associations inheriting the socket value.
3552 */
3553static int sctp_setsockopt_maxburst(struct sock *sk,
3554                                    char __user *optval,
3555                                    unsigned int optlen)
3556{
3557        struct sctp_sock *sp = sctp_sk(sk);
3558        struct sctp_assoc_value params;
3559        struct sctp_association *asoc;
3560
3561        if (optlen == sizeof(int)) {
3562                pr_warn_ratelimited(DEPRECATED
3563                                    "%s (pid %d) "
3564                                    "Use of int in max_burst socket option deprecated.\n"
3565                                    "Use struct sctp_assoc_value instead\n",
3566                                    current->comm, task_pid_nr(current));
3567                if (copy_from_user(&params.assoc_value, optval, optlen))
3568                        return -EFAULT;
3569                params.assoc_id = SCTP_FUTURE_ASSOC;
3570        } else if (optlen == sizeof(struct sctp_assoc_value)) {
3571                if (copy_from_user(&params, optval, optlen))
3572                        return -EFAULT;
3573        } else
3574                return -EINVAL;
3575
3576        asoc = sctp_id2assoc(sk, params.assoc_id);
3577        if (!asoc && params.assoc_id > SCTP_ALL_ASSOC &&
3578            sctp_style(sk, UDP))
3579                return -EINVAL;
3580
3581        if (asoc) {
3582                asoc->max_burst = params.assoc_value;
3583
3584                return 0;
3585        }
3586
3587        if (sctp_style(sk, TCP))
3588                params.assoc_id = SCTP_FUTURE_ASSOC;
3589
3590        if (params.assoc_id == SCTP_FUTURE_ASSOC ||
3591            params.assoc_id == SCTP_ALL_ASSOC)
3592                sp->max_burst = params.assoc_value;
3593
3594        if (params.assoc_id == SCTP_CURRENT_ASSOC ||
3595            params.assoc_id == SCTP_ALL_ASSOC)
3596                list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3597                        asoc->max_burst = params.assoc_value;
3598
3599        return 0;
3600}
3601
3602/*
3603 * 7.1.18.  Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3604 *
3605 * This set option adds a chunk type that the user is requesting to be
3606 * received only in an authenticated way.  Changes to the list of chunks
3607 * will only effect future associations on the socket.
3608 */
3609static int sctp_setsockopt_auth_chunk(struct sock *sk,
3610                                      char __user *optval,
3611                                      unsigned int optlen)
3612{
3613        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3614        struct sctp_authchunk val;
3615
3616        if (!ep->auth_enable)
3617                return -EACCES;
3618
3619        if (optlen != sizeof(struct sctp_authchunk))
3620                return -EINVAL;
3621        if (copy_from_user(&val, optval, optlen))
3622                return -EFAULT;
3623
3624        switch (val.sauth_chunk) {
3625        case SCTP_CID_INIT:
3626        case SCTP_CID_INIT_ACK:
3627        case SCTP_CID_SHUTDOWN_COMPLETE:
3628        case SCTP_CID_AUTH:
3629                return -EINVAL;
3630        }
3631
3632        /* add this chunk id to the endpoint */
3633        return sctp_auth_ep_add_chunkid(ep, val.sauth_chunk);
3634}
3635
3636/*
3637 * 7.1.19.  Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3638 *
3639 * This option gets or sets the list of HMAC algorithms that the local
3640 * endpoint requires the peer to use.
3641 */
3642static int sctp_setsockopt_hmac_ident(struct sock *sk,
3643                                      char __user *optval,
3644                                      unsigned int optlen)
3645{
3646        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3647        struct sctp_hmacalgo *hmacs;
3648        u32 idents;
3649        int err;
3650
3651        if (!ep->auth_enable)
3652                return -EACCES;
3653
3654        if (optlen < sizeof(struct sctp_hmacalgo))
3655                return -EINVAL;
3656        optlen = min_t(unsigned int, optlen, sizeof(struct sctp_hmacalgo) +
3657                                             SCTP_AUTH_NUM_HMACS * sizeof(u16));
3658
3659        hmacs = memdup_user(optval, optlen);
3660        if (IS_ERR(hmacs))
3661                return PTR_ERR(hmacs);
3662
3663        idents = hmacs->shmac_num_idents;
3664        if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS ||
3665            (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo))) {
3666                err = -EINVAL;
3667                goto out;
3668        }
3669
3670        err = sctp_auth_ep_set_hmacs(ep, hmacs);
3671out:
3672        kfree(hmacs);
3673        return err;
3674}
3675
3676/*
3677 * 7.1.20.  Set a shared key (SCTP_AUTH_KEY)
3678 *
3679 * This option will set a shared secret key which is used to build an
3680 * association shared key.
3681 */
3682static int sctp_setsockopt_auth_key(struct sock *sk,
3683                                    char __user *optval,
3684                                    unsigned int optlen)
3685{
3686        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3687        struct sctp_authkey *authkey;
3688        struct sctp_association *asoc;
3689        int ret = -EINVAL;
3690
3691        if (optlen <= sizeof(struct sctp_authkey))
3692                return -EINVAL;
3693        /* authkey->sca_keylength is u16, so optlen can't be bigger than
3694         * this.
3695         */
3696        optlen = min_t(unsigned int, optlen, USHRT_MAX + sizeof(*authkey));
3697
3698        authkey = memdup_user(optval, optlen);
3699        if (IS_ERR(authkey))
3700                return PTR_ERR(authkey);
3701
3702        if (authkey->sca_keylength > optlen - sizeof(*authkey))
3703                goto out;
3704
3705        asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3706        if (!asoc && authkey->sca_assoc_id > SCTP_ALL_ASSOC &&
3707            sctp_style(sk, UDP))
3708                goto out;
3709
3710        if (asoc) {
3711                ret = sctp_auth_set_key(ep, asoc, authkey);
3712                goto out;
3713        }
3714
3715        if (sctp_style(sk, TCP))
3716                authkey->sca_assoc_id = SCTP_FUTURE_ASSOC;
3717
3718        if (authkey->sca_assoc_id == SCTP_FUTURE_ASSOC ||
3719            authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3720                ret = sctp_auth_set_key(ep, asoc, authkey);
3721                if (ret)
3722                        goto out;
3723        }
3724
3725        ret = 0;
3726
3727        if (authkey->sca_assoc_id == SCTP_CURRENT_ASSOC ||
3728            authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3729                list_for_each_entry(asoc, &ep->asocs, asocs) {
3730                        int res = sctp_auth_set_key(ep, asoc, authkey);
3731
3732                        if (res && !ret)
3733                                ret = res;
3734                }
3735        }
3736
3737out:
3738        kzfree(authkey);
3739        return ret;
3740}
3741
3742/*
3743 * 7.1.21.  Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3744 *
3745 * This option will get or set the active shared key to be used to build
3746 * the association shared key.
3747 */
3748static int sctp_setsockopt_active_key(struct sock *sk,
3749                                      char __user *optval,
3750                                      unsigned int optlen)
3751{
3752        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3753        struct sctp_association *asoc;
3754        struct sctp_authkeyid val;
3755        int ret = 0;
3756
3757        if (optlen != sizeof(struct sctp_authkeyid))
3758                return -EINVAL;
3759        if (copy_from_user(&val, optval, optlen))
3760                return -EFAULT;
3761
3762        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3763        if (!asoc && val.scact_assoc_id > SCTP_ALL_ASSOC &&
3764            sctp_style(sk, UDP))
3765                return -EINVAL;
3766
3767        if (asoc)
3768                return sctp_auth_set_active_key(ep, asoc, val.scact_keynumber);
3769
3770        if (sctp_style(sk, TCP))
3771                val.scact_assoc_id = SCTP_FUTURE_ASSOC;
3772
3773        if (val.scact_assoc_id == SCTP_FUTURE_ASSOC ||
3774            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3775                ret = sctp_auth_set_active_key(ep, asoc, val.scact_keynumber);
3776                if (ret)
3777                        return ret;
3778        }
3779
3780        if (val.scact_assoc_id == SCTP_CURRENT_ASSOC ||
3781            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3782                list_for_each_entry(asoc, &ep->asocs, asocs) {
3783                        int res = sctp_auth_set_active_key(ep, asoc,
3784                                                           val.scact_keynumber);
3785
3786                        if (res && !ret)
3787                                ret = res;
3788                }
3789        }
3790
3791        return ret;
3792}
3793
3794/*
3795 * 7.1.22.  Delete a shared key (SCTP_AUTH_DELETE_KEY)
3796 *
3797 * This set option will delete a shared secret key from use.
3798 */
3799static int sctp_setsockopt_del_key(struct sock *sk,
3800                                   char __user *optval,
3801                                   unsigned int optlen)
3802{
3803        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3804        struct sctp_association *asoc;
3805        struct sctp_authkeyid val;
3806        int ret = 0;
3807
3808        if (optlen != sizeof(struct sctp_authkeyid))
3809                return -EINVAL;
3810        if (copy_from_user(&val, optval, optlen))
3811                return -EFAULT;
3812
3813        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3814        if (!asoc && val.scact_assoc_id > SCTP_ALL_ASSOC &&
3815            sctp_style(sk, UDP))
3816                return -EINVAL;
3817
3818        if (asoc)
3819                return sctp_auth_del_key_id(ep, asoc, val.scact_keynumber);
3820
3821        if (sctp_style(sk, TCP))
3822                val.scact_assoc_id = SCTP_FUTURE_ASSOC;
3823
3824        if (val.scact_assoc_id == SCTP_FUTURE_ASSOC ||
3825            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3826                ret = sctp_auth_del_key_id(ep, asoc, val.scact_keynumber);
3827                if (ret)
3828                        return ret;
3829        }
3830
3831        if (val.scact_assoc_id == SCTP_CURRENT_ASSOC ||
3832            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3833                list_for_each_entry(asoc, &ep->asocs, asocs) {
3834                        int res = sctp_auth_del_key_id(ep, asoc,
3835                                                       val.scact_keynumber);
3836
3837                        if (res && !ret)
3838                                ret = res;
3839                }
3840        }
3841
3842        return ret;
3843}
3844
3845/*
3846 * 8.3.4  Deactivate a Shared Key (SCTP_AUTH_DEACTIVATE_KEY)
3847 *
3848 * This set option will deactivate a shared secret key.
3849 */
3850static int sctp_setsockopt_deactivate_key(struct sock *sk, char __user *optval,
3851                                          unsigned int optlen)
3852{
3853        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3854        struct sctp_association *asoc;
3855        struct sctp_authkeyid val;
3856        int ret = 0;
3857
3858        if (optlen != sizeof(struct sctp_authkeyid))
3859                return -EINVAL;
3860        if (copy_from_user(&val, optval, optlen))
3861                return -EFAULT;
3862
3863        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3864        if (!asoc && val.scact_assoc_id > SCTP_ALL_ASSOC &&
3865            sctp_style(sk, UDP))
3866                return -EINVAL;
3867
3868        if (asoc)
3869                return sctp_auth_deact_key_id(ep, asoc, val.scact_keynumber);
3870
3871        if (sctp_style(sk, TCP))
3872                val.scact_assoc_id = SCTP_FUTURE_ASSOC;
3873
3874        if (val.scact_assoc_id == SCTP_FUTURE_ASSOC ||
3875            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3876                ret = sctp_auth_deact_key_id(ep, asoc, val.scact_keynumber);
3877                if (ret)
3878                        return ret;
3879        }
3880
3881        if (val.scact_assoc_id == SCTP_CURRENT_ASSOC ||
3882            val.scact_assoc_id == SCTP_ALL_ASSOC) {
3883                list_for_each_entry(asoc, &ep->asocs, asocs) {
3884                        int res = sctp_auth_deact_key_id(ep, asoc,
3885                                                         val.scact_keynumber);
3886
3887                        if (res && !ret)
3888                                ret = res;
3889                }
3890        }
3891
3892        return ret;
3893}
3894
3895/*
3896 * 8.1.23 SCTP_AUTO_ASCONF
3897 *
3898 * This option will enable or disable the use of the automatic generation of
3899 * ASCONF chunks to add and delete addresses to an existing association.  Note
3900 * that this option has two caveats namely: a) it only affects sockets that
3901 * are bound to all addresses available to the SCTP stack, and b) the system
3902 * administrator may have an overriding control that turns the ASCONF feature
3903 * off no matter what setting the socket option may have.
3904 * This option expects an integer boolean flag, where a non-zero value turns on
3905 * the option, and a zero value turns off the option.
3906 * Note. In this implementation, socket operation overrides default parameter
3907 * being set by sysctl as well as FreeBSD implementation
3908 */
3909static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval,
3910                                        unsigned int optlen)
3911{
3912        int val;
3913        struct sctp_sock *sp = sctp_sk(sk);
3914
3915        if (optlen < sizeof(int))
3916                return -EINVAL;
3917        if (get_user(val, (int __user *)optval))
3918                return -EFAULT;
3919        if (!sctp_is_ep_boundall(sk) && val)
3920                return -EINVAL;
3921        if ((val && sp->do_auto_asconf) || (!val && !sp->do_auto_asconf))
3922                return 0;
3923
3924        spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3925        if (val == 0 && sp->do_auto_asconf) {
3926                list_del(&sp->auto_asconf_list);
3927                sp->do_auto_asconf = 0;
3928        } else if (val && !sp->do_auto_asconf) {
3929                list_add_tail(&sp->auto_asconf_list,
3930                    &sock_net(sk)->sctp.auto_asconf_splist);
3931                sp->do_auto_asconf = 1;
3932        }
3933        spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3934        return 0;
3935}
3936
3937/*
3938 * SCTP_PEER_ADDR_THLDS
3939 *
3940 * This option allows us to alter the partially failed threshold for one or all
3941 * transports in an association.  See Section 6.1 of:
3942 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3943 */
3944static int sctp_setsockopt_paddr_thresholds(struct sock *sk,
3945                                            char __user *optval,
3946                                            unsigned int optlen)
3947{
3948        struct sctp_paddrthlds val;
3949        struct sctp_transport *trans;
3950        struct sctp_association *asoc;
3951
3952        if (optlen < sizeof(struct sctp_paddrthlds))
3953                return -EINVAL;
3954        if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval,
3955                           sizeof(struct sctp_paddrthlds)))
3956                return -EFAULT;
3957
3958        if (!sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
3959                trans = sctp_addr_id2transport(sk, &val.spt_address,
3960                                               val.spt_assoc_id);
3961                if (!trans)
3962                        return -ENOENT;
3963
3964                if (val.spt_pathmaxrxt)
3965                        trans->pathmaxrxt = val.spt_pathmaxrxt;
3966                trans->pf_retrans = val.spt_pathpfthld;
3967
3968                return 0;
3969        }
3970
3971        asoc = sctp_id2assoc(sk, val.spt_assoc_id);
3972        if (!asoc && val.spt_assoc_id != SCTP_FUTURE_ASSOC &&
3973            sctp_style(sk, UDP))
3974                return -EINVAL;
3975
3976        if (asoc) {
3977                list_for_each_entry(trans, &asoc->peer.transport_addr_list,
3978                                    transports) {
3979                        if (val.spt_pathmaxrxt)
3980                                trans->pathmaxrxt = val.spt_pathmaxrxt;
3981                        trans->pf_retrans = val.spt_pathpfthld;
3982                }
3983
3984                if (val.spt_pathmaxrxt)
3985                        asoc->pathmaxrxt = val.spt_pathmaxrxt;
3986                asoc->pf_retrans = val.spt_pathpfthld;
3987        } else {
3988                struct sctp_sock *sp = sctp_sk(sk);
3989
3990                if (val.spt_pathmaxrxt)
3991                        sp->pathmaxrxt = val.spt_pathmaxrxt;
3992                sp->pf_retrans = val.spt_pathpfthld;
3993        }
3994
3995        return 0;
3996}
3997
3998static int sctp_setsockopt_recvrcvinfo(struct sock *sk,
3999                                       char __user *optval,
4000                                       unsigned int optlen)
4001{
4002        int val;
4003
4004        if (optlen < sizeof(int))
4005                return -EINVAL;
4006        if (get_user(val, (int __user *) optval))
4007                return -EFAULT;
4008
4009        sctp_sk(sk)->recvrcvinfo = (val == 0) ? 0 : 1;
4010
4011        return 0;
4012}
4013
4014static int sctp_setsockopt_recvnxtinfo(struct sock *sk,
4015                                       char __user *optval,
4016                                       unsigned int optlen)
4017{
4018        int val;
4019
4020        if (optlen < sizeof(int))
4021                return -EINVAL;
4022        if (get_user(val, (int __user *) optval))
4023                return -EFAULT;
4024
4025        sctp_sk(sk)->recvnxtinfo = (val == 0) ? 0 : 1;
4026
4027        return 0;
4028}
4029
4030static int sctp_setsockopt_pr_supported(struct sock *sk,
4031                                        char __user *optval,
4032                                        unsigned int optlen)
4033{
4034        struct sctp_assoc_value params;
4035        struct sctp_association *asoc;
4036
4037        if (optlen != sizeof(params))
4038                return -EINVAL;
4039
4040        if (copy_from_user(&params, optval, optlen))
4041                return -EFAULT;
4042
4043        asoc = sctp_id2assoc(sk, params.assoc_id);
4044        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4045            sctp_style(sk, UDP))
4046                return -EINVAL;
4047
4048        sctp_sk(sk)->ep->prsctp_enable = !!params.assoc_value;
4049
4050        return 0;
4051}
4052
4053static int sctp_setsockopt_default_prinfo(struct sock *sk,
4054                                          char __user *optval,
4055                                          unsigned int optlen)
4056{
4057        struct sctp_sock *sp = sctp_sk(sk);
4058        struct sctp_default_prinfo info;
4059        struct sctp_association *asoc;
4060        int retval = -EINVAL;
4061
4062        if (optlen != sizeof(info))
4063                goto out;
4064
4065        if (copy_from_user(&info, optval, sizeof(info))) {
4066                retval = -EFAULT;
4067                goto out;
4068        }
4069
4070        if (info.pr_policy & ~SCTP_PR_SCTP_MASK)
4071                goto out;
4072
4073        if (info.pr_policy == SCTP_PR_SCTP_NONE)
4074                info.pr_value = 0;
4075
4076        asoc = sctp_id2assoc(sk, info.pr_assoc_id);
4077        if (!asoc && info.pr_assoc_id > SCTP_ALL_ASSOC &&
4078            sctp_style(sk, UDP))
4079                goto out;
4080
4081        retval = 0;
4082
4083        if (asoc) {
4084                SCTP_PR_SET_POLICY(asoc->default_flags, info.pr_policy);
4085                asoc->default_timetolive = info.pr_value;
4086                goto out;
4087        }
4088
4089        if (sctp_style(sk, TCP))
4090                info.pr_assoc_id = SCTP_FUTURE_ASSOC;
4091
4092        if (info.pr_assoc_id == SCTP_FUTURE_ASSOC ||
4093            info.pr_assoc_id == SCTP_ALL_ASSOC) {
4094                SCTP_PR_SET_POLICY(sp->default_flags, info.pr_policy);
4095                sp->default_timetolive = info.pr_value;
4096        }
4097
4098        if (info.pr_assoc_id == SCTP_CURRENT_ASSOC ||
4099            info.pr_assoc_id == SCTP_ALL_ASSOC) {
4100                list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4101                        SCTP_PR_SET_POLICY(asoc->default_flags, info.pr_policy);
4102                        asoc->default_timetolive = info.pr_value;
4103                }
4104        }
4105
4106out:
4107        return retval;
4108}
4109
4110static int sctp_setsockopt_reconfig_supported(struct sock *sk,
4111                                              char __user *optval,
4112                                              unsigned int optlen)
4113{
4114        struct sctp_assoc_value params;
4115        struct sctp_association *asoc;
4116        int retval = -EINVAL;
4117
4118        if (optlen != sizeof(params))
4119                goto out;
4120
4121        if (copy_from_user(&params, optval, optlen)) {
4122                retval = -EFAULT;
4123                goto out;
4124        }
4125
4126        asoc = sctp_id2assoc(sk, params.assoc_id);
4127        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4128            sctp_style(sk, UDP))
4129                goto out;
4130
4131        sctp_sk(sk)->ep->reconf_enable = !!params.assoc_value;
4132
4133        retval = 0;
4134
4135out:
4136        return retval;
4137}
4138
4139static int sctp_setsockopt_enable_strreset(struct sock *sk,
4140                                           char __user *optval,
4141                                           unsigned int optlen)
4142{
4143        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
4144        struct sctp_assoc_value params;
4145        struct sctp_association *asoc;
4146        int retval = -EINVAL;
4147
4148        if (optlen != sizeof(params))
4149                goto out;
4150
4151        if (copy_from_user(&params, optval, optlen)) {
4152                retval = -EFAULT;
4153                goto out;
4154        }
4155
4156        if (params.assoc_value & (~SCTP_ENABLE_STRRESET_MASK))
4157                goto out;
4158
4159        asoc = sctp_id2assoc(sk, params.assoc_id);
4160        if (!asoc && params.assoc_id > SCTP_ALL_ASSOC &&
4161            sctp_style(sk, UDP))
4162                goto out;
4163
4164        retval = 0;
4165
4166        if (asoc) {
4167                asoc->strreset_enable = params.assoc_value;
4168                goto out;
4169        }
4170
4171        if (sctp_style(sk, TCP))
4172                params.assoc_id = SCTP_FUTURE_ASSOC;
4173
4174        if (params.assoc_id == SCTP_FUTURE_ASSOC ||
4175            params.assoc_id == SCTP_ALL_ASSOC)
4176                ep->strreset_enable = params.assoc_value;
4177
4178        if (params.assoc_id == SCTP_CURRENT_ASSOC ||
4179            params.assoc_id == SCTP_ALL_ASSOC)
4180                list_for_each_entry(asoc, &ep->asocs, asocs)
4181                        asoc->strreset_enable = params.assoc_value;
4182
4183out:
4184        return retval;
4185}
4186
4187static int sctp_setsockopt_reset_streams(struct sock *sk,
4188                                         char __user *optval,
4189                                         unsigned int optlen)
4190{
4191        struct sctp_reset_streams *params;
4192        struct sctp_association *asoc;
4193        int retval = -EINVAL;
4194
4195        if (optlen < sizeof(*params))
4196                return -EINVAL;
4197        /* srs_number_streams is u16, so optlen can't be bigger than this. */
4198        optlen = min_t(unsigned int, optlen, USHRT_MAX +
4199                                             sizeof(__u16) * sizeof(*params));
4200
4201        params = memdup_user(optval, optlen);
4202        if (IS_ERR(params))
4203                return PTR_ERR(params);
4204
4205        if (params->srs_number_streams * sizeof(__u16) >
4206            optlen - sizeof(*params))
4207                goto out;
4208
4209        asoc = sctp_id2assoc(sk, params->srs_assoc_id);
4210        if (!asoc)
4211                goto out;
4212
4213        retval = sctp_send_reset_streams(asoc, params);
4214
4215out:
4216        kfree(params);
4217        return retval;
4218}
4219
4220static int sctp_setsockopt_reset_assoc(struct sock *sk,
4221                                       char __user *optval,
4222                                       unsigned int optlen)
4223{
4224        struct sctp_association *asoc;
4225        sctp_assoc_t associd;
4226        int retval = -EINVAL;
4227
4228        if (optlen != sizeof(associd))
4229                goto out;
4230
4231        if (copy_from_user(&associd, optval, optlen)) {
4232                retval = -EFAULT;
4233                goto out;
4234        }
4235
4236        asoc = sctp_id2assoc(sk, associd);
4237        if (!asoc)
4238                goto out;
4239
4240        retval = sctp_send_reset_assoc(asoc);
4241
4242out:
4243        return retval;
4244}
4245
4246static int sctp_setsockopt_add_streams(struct sock *sk,
4247                                       char __user *optval,
4248                                       unsigned int optlen)
4249{
4250        struct sctp_association *asoc;
4251        struct sctp_add_streams params;
4252        int retval = -EINVAL;
4253
4254        if (optlen != sizeof(params))
4255                goto out;
4256
4257        if (copy_from_user(&params, optval, optlen)) {
4258                retval = -EFAULT;
4259                goto out;
4260        }
4261
4262        asoc = sctp_id2assoc(sk, params.sas_assoc_id);
4263        if (!asoc)
4264                goto out;
4265
4266        retval = sctp_send_add_streams(asoc, &params);
4267
4268out:
4269        return retval;
4270}
4271
4272static int sctp_setsockopt_scheduler(struct sock *sk,
4273                                     char __user *optval,
4274                                     unsigned int optlen)
4275{
4276        struct sctp_sock *sp = sctp_sk(sk);
4277        struct sctp_association *asoc;
4278        struct sctp_assoc_value params;
4279        int retval = 0;
4280
4281        if (optlen < sizeof(params))
4282                return -EINVAL;
4283
4284        optlen = sizeof(params);
4285        if (copy_from_user(&params, optval, optlen))
4286                return -EFAULT;
4287
4288        if (params.assoc_value > SCTP_SS_MAX)
4289                return -EINVAL;
4290
4291        asoc = sctp_id2assoc(sk, params.assoc_id);
4292        if (!asoc && params.assoc_id > SCTP_ALL_ASSOC &&
4293            sctp_style(sk, UDP))
4294                return -EINVAL;
4295
4296        if (asoc)
4297                return sctp_sched_set_sched(asoc, params.assoc_value);
4298
4299        if (sctp_style(sk, TCP))
4300                params.assoc_id = SCTP_FUTURE_ASSOC;
4301
4302        if (params.assoc_id == SCTP_FUTURE_ASSOC ||
4303            params.assoc_id == SCTP_ALL_ASSOC)
4304                sp->default_ss = params.assoc_value;
4305
4306        if (params.assoc_id == SCTP_CURRENT_ASSOC ||
4307            params.assoc_id == SCTP_ALL_ASSOC) {
4308                list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4309                        int ret = sctp_sched_set_sched(asoc,
4310                                                       params.assoc_value);
4311
4312                        if (ret && !retval)
4313                                retval = ret;
4314                }
4315        }
4316
4317        return retval;
4318}
4319
4320static int sctp_setsockopt_scheduler_value(struct sock *sk,
4321                                           char __user *optval,
4322                                           unsigned int optlen)
4323{
4324        struct sctp_stream_value params;
4325        struct sctp_association *asoc;
4326        int retval = -EINVAL;
4327
4328        if (optlen < sizeof(params))
4329                goto out;
4330
4331        optlen = sizeof(params);
4332        if (copy_from_user(&params, optval, optlen)) {
4333                retval = -EFAULT;
4334                goto out;
4335        }
4336
4337        asoc = sctp_id2assoc(sk, params.assoc_id);
4338        if (!asoc && params.assoc_id != SCTP_CURRENT_ASSOC &&
4339            sctp_style(sk, UDP))
4340                goto out;
4341
4342        if (asoc) {
4343                retval = sctp_sched_set_value(asoc, params.stream_id,
4344                                              params.stream_value, GFP_KERNEL);
4345                goto out;
4346        }
4347
4348        retval = 0;
4349
4350        list_for_each_entry(asoc, &sctp_sk(sk)->ep->asocs, asocs) {
4351                int ret = sctp_sched_set_value(asoc, params.stream_id,
4352                                               params.stream_value, GFP_KERNEL);
4353                if (ret && !retval) /* try to return the 1st error. */
4354                        retval = ret;
4355        }
4356
4357out:
4358        return retval;
4359}
4360
4361static int sctp_setsockopt_interleaving_supported(struct sock *sk,
4362                                                  char __user *optval,
4363                                                  unsigned int optlen)
4364{
4365        struct sctp_sock *sp = sctp_sk(sk);
4366        struct sctp_assoc_value params;
4367        struct sctp_association *asoc;
4368        int retval = -EINVAL;
4369
4370        if (optlen < sizeof(params))
4371                goto out;
4372
4373        optlen = sizeof(params);
4374        if (copy_from_user(&params, optval, optlen)) {
4375                retval = -EFAULT;
4376                goto out;
4377        }
4378
4379        asoc = sctp_id2assoc(sk, params.assoc_id);
4380        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4381            sctp_style(sk, UDP))
4382                goto out;
4383
4384        if (!sock_net(sk)->sctp.intl_enable || !sp->frag_interleave) {
4385                retval = -EPERM;
4386                goto out;
4387        }
4388
4389        sp->ep->intl_enable = !!params.assoc_value;
4390
4391        retval = 0;
4392
4393out:
4394        return retval;
4395}
4396
4397static int sctp_setsockopt_reuse_port(struct sock *sk, char __user *optval,
4398                                      unsigned int optlen)
4399{
4400        int val;
4401
4402        if (!sctp_style(sk, TCP))
4403                return -EOPNOTSUPP;
4404
4405        if (sctp_sk(sk)->ep->base.bind_addr.port)
4406                return -EFAULT;
4407
4408        if (optlen < sizeof(int))
4409                return -EINVAL;
4410
4411        if (get_user(val, (int __user *)optval))
4412                return -EFAULT;
4413
4414        sctp_sk(sk)->reuse = !!val;
4415
4416        return 0;
4417}
4418
4419static int sctp_assoc_ulpevent_type_set(struct sctp_event *param,
4420                                        struct sctp_association *asoc)
4421{
4422        struct sctp_ulpevent *event;
4423
4424        sctp_ulpevent_type_set(&asoc->subscribe, param->se_type, param->se_on);
4425
4426        if (param->se_type == SCTP_SENDER_DRY_EVENT && param->se_on) {
4427                if (sctp_outq_is_empty(&asoc->outqueue)) {
4428                        event = sctp_ulpevent_make_sender_dry_event(asoc,
4429                                        GFP_USER | __GFP_NOWARN);
4430                        if (!event)
4431                                return -ENOMEM;
4432
4433                        asoc->stream.si->enqueue_event(&asoc->ulpq, event);
4434                }
4435        }
4436
4437        return 0;
4438}
4439
4440static int sctp_setsockopt_event(struct sock *sk, char __user *optval,
4441                                 unsigned int optlen)
4442{
4443        struct sctp_sock *sp = sctp_sk(sk);
4444        struct sctp_association *asoc;
4445        struct sctp_event param;
4446        int retval = 0;
4447
4448        if (optlen < sizeof(param))
4449                return -EINVAL;
4450
4451        optlen = sizeof(param);
4452        if (copy_from_user(&param, optval, optlen))
4453                return -EFAULT;
4454
4455        if (param.se_type < SCTP_SN_TYPE_BASE ||
4456            param.se_type > SCTP_SN_TYPE_MAX)
4457                return -EINVAL;
4458
4459        asoc = sctp_id2assoc(sk, param.se_assoc_id);
4460        if (!asoc && param.se_assoc_id > SCTP_ALL_ASSOC &&
4461            sctp_style(sk, UDP))
4462                return -EINVAL;
4463
4464        if (asoc)
4465                return sctp_assoc_ulpevent_type_set(&param, asoc);
4466
4467        if (sctp_style(sk, TCP))
4468                param.se_assoc_id = SCTP_FUTURE_ASSOC;
4469
4470        if (param.se_assoc_id == SCTP_FUTURE_ASSOC ||
4471            param.se_assoc_id == SCTP_ALL_ASSOC)
4472                sctp_ulpevent_type_set(&sp->subscribe,
4473                                       param.se_type, param.se_on);
4474
4475        if (param.se_assoc_id == SCTP_CURRENT_ASSOC ||
4476            param.se_assoc_id == SCTP_ALL_ASSOC) {
4477                list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4478                        int ret = sctp_assoc_ulpevent_type_set(&param, asoc);
4479
4480                        if (ret && !retval)
4481                                retval = ret;
4482                }
4483        }
4484
4485        return retval;
4486}
4487
4488static int sctp_setsockopt_asconf_supported(struct sock *sk,
4489                                            char __user *optval,
4490                                            unsigned int optlen)
4491{
4492        struct sctp_assoc_value params;
4493        struct sctp_association *asoc;
4494        struct sctp_endpoint *ep;
4495        int retval = -EINVAL;
4496
4497        if (optlen != sizeof(params))
4498                goto out;
4499
4500        if (copy_from_user(&params, optval, optlen)) {
4501                retval = -EFAULT;
4502                goto out;
4503        }
4504
4505        asoc = sctp_id2assoc(sk, params.assoc_id);
4506        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4507            sctp_style(sk, UDP))
4508                goto out;
4509
4510        ep = sctp_sk(sk)->ep;
4511        ep->asconf_enable = !!params.assoc_value;
4512
4513        if (ep->asconf_enable && ep->auth_enable) {
4514                sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF);
4515                sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF_ACK);
4516        }
4517
4518        retval = 0;
4519
4520out:
4521        return retval;
4522}
4523
4524static int sctp_setsockopt_auth_supported(struct sock *sk,
4525                                          char __user *optval,
4526                                          unsigned int optlen)
4527{
4528        struct sctp_assoc_value params;
4529        struct sctp_association *asoc;
4530        struct sctp_endpoint *ep;
4531        int retval = -EINVAL;
4532
4533        if (optlen != sizeof(params))
4534                goto out;
4535
4536        if (copy_from_user(&params, optval, optlen)) {
4537                retval = -EFAULT;
4538                goto out;
4539        }
4540
4541        asoc = sctp_id2assoc(sk, params.assoc_id);
4542        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4543            sctp_style(sk, UDP))
4544                goto out;
4545
4546        ep = sctp_sk(sk)->ep;
4547        if (params.assoc_value) {
4548                retval = sctp_auth_init(ep, GFP_KERNEL);
4549                if (retval)
4550                        goto out;
4551                if (ep->asconf_enable) {
4552                        sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF);
4553                        sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF_ACK);
4554                }
4555        }
4556
4557        ep->auth_enable = !!params.assoc_value;
4558        retval = 0;
4559
4560out:
4561        return retval;
4562}
4563
4564static int sctp_setsockopt_ecn_supported(struct sock *sk,
4565                                         char __user *optval,
4566                                         unsigned int optlen)
4567{
4568        struct sctp_assoc_value params;
4569        struct sctp_association *asoc;
4570        int retval = -EINVAL;
4571
4572        if (optlen != sizeof(params))
4573                goto out;
4574
4575        if (copy_from_user(&params, optval, optlen)) {
4576                retval = -EFAULT;
4577                goto out;
4578        }
4579
4580        asoc = sctp_id2assoc(sk, params.assoc_id);
4581        if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
4582            sctp_style(sk, UDP))
4583                goto out;
4584
4585        sctp_sk(sk)->ep->ecn_enable = !!params.assoc_value;
4586        retval = 0;
4587
4588out:
4589        return retval;
4590}
4591
4592/* API 6.2 setsockopt(), getsockopt()
4593 *
4594 * Applications use setsockopt() and getsockopt() to set or retrieve
4595 * socket options.  Socket options are used to change the default
4596 * behavior of sockets calls.  They are described in Section 7.
4597 *
4598 * The syntax is:
4599 *
4600 *   ret = getsockopt(int sd, int level, int optname, void __user *optval,
4601 *                    int __user *optlen);
4602 *   ret = setsockopt(int sd, int level, int optname, const void __user *optval,
4603 *                    int optlen);
4604 *
4605 *   sd      - the socket descript.
4606 *   level   - set to IPPROTO_SCTP for all SCTP options.
4607 *   optname - the option name.
4608 *   optval  - the buffer to store the value of the option.
4609 *   optlen  - the size of the buffer.
4610 */
4611static int sctp_setsockopt(struct sock *sk, int level, int optname,
4612                           char __user *optval, unsigned int optlen)
4613{
4614        int retval = 0;
4615
4616        pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
4617
4618        /* I can hardly begin to describe how wrong this is.  This is
4619         * so broken as to be worse than useless.  The API draft
4620         * REALLY is NOT helpful here...  I am not convinced that the
4621         * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
4622         * are at all well-founded.
4623         */
4624        if (level != SOL_SCTP) {
4625                struct sctp_af *af = sctp_sk(sk)->pf->af;
4626                retval = af->setsockopt(sk, level, optname, optval, optlen);
4627                goto out_nounlock;
4628        }
4629
4630        lock_sock(sk);
4631
4632        switch (optname) {
4633        case SCTP_SOCKOPT_BINDX_ADD:
4634                /* 'optlen' is the size of the addresses buffer. */
4635                retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
4636                                               optlen, SCTP_BINDX_ADD_ADDR);
4637                break;
4638
4639        case SCTP_SOCKOPT_BINDX_REM:
4640                /* 'optlen' is the size of the addresses buffer. */
4641                retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
4642                                               optlen, SCTP_BINDX_REM_ADDR);
4643                break;
4644
4645        case SCTP_SOCKOPT_CONNECTX_OLD:
4646                /* 'optlen' is the size of the addresses buffer. */
4647                retval = sctp_setsockopt_connectx_old(sk,
4648                                            (struct sockaddr __user *)optval,
4649                                            optlen);
4650                break;
4651
4652        case SCTP_SOCKOPT_CONNECTX:
4653                /* 'optlen' is the size of the addresses buffer. */
4654                retval = sctp_setsockopt_connectx(sk,
4655                                            (struct sockaddr __user *)optval,
4656                                            optlen);
4657                break;
4658
4659        case SCTP_DISABLE_FRAGMENTS:
4660                retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
4661                break;
4662
4663        case SCTP_EVENTS:
4664                retval = sctp_setsockopt_events(sk, optval, optlen);
4665                break;
4666
4667        case SCTP_AUTOCLOSE:
4668                retval = sctp_setsockopt_autoclose(sk, optval, optlen);
4669                break;
4670
4671        case SCTP_PEER_ADDR_PARAMS:
4672                retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
4673                break;
4674
4675        case SCTP_DELAYED_SACK:
4676                retval = sctp_setsockopt_delayed_ack(sk, optval, optlen);
4677                break;
4678        case SCTP_PARTIAL_DELIVERY_POINT:
4679                retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen);
4680                break;
4681
4682        case SCTP_INITMSG:
4683                retval = sctp_setsockopt_initmsg(sk, optval, optlen);
4684                break;
4685        case SCTP_DEFAULT_SEND_PARAM:
4686                retval = sctp_setsockopt_default_send_param(sk, optval,
4687                                                            optlen);
4688                break;
4689        case SCTP_DEFAULT_SNDINFO:
4690                retval = sctp_setsockopt_default_sndinfo(sk, optval, optlen);
4691                break;
4692        case SCTP_PRIMARY_ADDR:
4693                retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
4694                break;
4695        case SCTP_SET_PEER_PRIMARY_ADDR:
4696                retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
4697                break;
4698        case SCTP_NODELAY:
4699                retval = sctp_setsockopt_nodelay(sk, optval, optlen);
4700                break;
4701        case SCTP_RTOINFO:
4702                retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
4703                break;
4704        case SCTP_ASSOCINFO:
4705                retval = sctp_setsockopt_associnfo(sk, optval, optlen);
4706                break;
4707        case SCTP_I_WANT_MAPPED_V4_ADDR:
4708                retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
4709                break;
4710        case SCTP_MAXSEG:
4711                retval = sctp_setsockopt_maxseg(sk, optval, optlen);
4712                break;
4713        case SCTP_ADAPTATION_LAYER:
4714                retval = sctp_setsockopt_adaptation_layer(sk, optval, optlen);
4715                break;
4716        case SCTP_CONTEXT:
4717                retval = sctp_setsockopt_context(sk, optval, optlen);
4718                break;
4719        case SCTP_FRAGMENT_INTERLEAVE:
4720                retval = sctp_setsockopt_fragment_interleave(sk, optval, optlen);
4721                break;
4722        case SCTP_MAX_BURST:
4723                retval = sctp_setsockopt_maxburst(sk, optval, optlen);
4724                break;
4725        case SCTP_AUTH_CHUNK:
4726                retval = sctp_setsockopt_auth_chunk(sk, optval, optlen);
4727                break;
4728        case SCTP_HMAC_IDENT:
4729                retval = sctp_setsockopt_hmac_ident(sk, optval, optlen);
4730                break;
4731        case SCTP_AUTH_KEY:
4732                retval = sctp_setsockopt_auth_key(sk, optval, optlen);
4733                break;
4734        case SCTP_AUTH_ACTIVE_KEY:
4735                retval = sctp_setsockopt_active_key(sk, optval, optlen);
4736                break;
4737        case SCTP_AUTH_DELETE_KEY:
4738                retval = sctp_setsockopt_del_key(sk, optval, optlen);
4739                break;
4740        case SCTP_AUTH_DEACTIVATE_KEY:
4741                retval = sctp_setsockopt_deactivate_key(sk, optval, optlen);
4742                break;
4743        case SCTP_AUTO_ASCONF:
4744                retval = sctp_setsockopt_auto_asconf(sk, optval, optlen);
4745                break;
4746        case SCTP_PEER_ADDR_THLDS:
4747                retval = sctp_setsockopt_paddr_thresholds(sk, optval, optlen);
4748                break;
4749        case SCTP_RECVRCVINFO:
4750                retval = sctp_setsockopt_recvrcvinfo(sk, optval, optlen);
4751                break;
4752        case SCTP_RECVNXTINFO:
4753                retval = sctp_setsockopt_recvnxtinfo(sk, optval, optlen);
4754                break;
4755        case SCTP_PR_SUPPORTED:
4756                retval = sctp_setsockopt_pr_supported(sk, optval, optlen);
4757                break;
4758        case SCTP_DEFAULT_PRINFO:
4759                retval = sctp_setsockopt_default_prinfo(sk, optval, optlen);
4760                break;
4761        case SCTP_RECONFIG_SUPPORTED:
4762                retval = sctp_setsockopt_reconfig_supported(sk, optval, optlen);
4763                break;
4764        case SCTP_ENABLE_STREAM_RESET:
4765                retval = sctp_setsockopt_enable_strreset(sk, optval, optlen);
4766                break;
4767        case SCTP_RESET_STREAMS:
4768                retval = sctp_setsockopt_reset_streams(sk, optval, optlen);
4769                break;
4770        case SCTP_RESET_ASSOC:
4771                retval = sctp_setsockopt_reset_assoc(sk, optval, optlen);
4772                break;
4773        case SCTP_ADD_STREAMS:
4774                retval = sctp_setsockopt_add_streams(sk, optval, optlen);
4775                break;
4776        case SCTP_STREAM_SCHEDULER:
4777                retval = sctp_setsockopt_scheduler(sk, optval, optlen);
4778                break;
4779        case SCTP_STREAM_SCHEDULER_VALUE:
4780                retval = sctp_setsockopt_scheduler_value(sk, optval, optlen);
4781                break;
4782        case SCTP_INTERLEAVING_SUPPORTED:
4783                retval = sctp_setsockopt_interleaving_supported(sk, optval,
4784                                                                optlen);
4785                break;
4786        case SCTP_REUSE_PORT:
4787                retval = sctp_setsockopt_reuse_port(sk, optval, optlen);
4788                break;
4789        case SCTP_EVENT:
4790                retval = sctp_setsockopt_event(sk, optval, optlen);
4791                break;
4792        case SCTP_ASCONF_SUPPORTED:
4793                retval = sctp_setsockopt_asconf_supported(sk, optval, optlen);
4794                break;
4795        case SCTP_AUTH_SUPPORTED:
4796                retval = sctp_setsockopt_auth_supported(sk, optval, optlen);
4797                break;
4798        case SCTP_ECN_SUPPORTED:
4799                retval = sctp_setsockopt_ecn_supported(sk, optval, optlen);
4800                break;
4801        default:
4802                retval = -ENOPROTOOPT;
4803                break;
4804        }
4805
4806        release_sock(sk);
4807
4808out_nounlock:
4809        return retval;
4810}
4811
4812/* API 3.1.6 connect() - UDP Style Syntax
4813 *
4814 * An application may use the connect() call in the UDP model to initiate an
4815 * association without sending data.
4816 *
4817 * The syntax is:
4818 *
4819 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4820 *
4821 * sd: the socket descriptor to have a new association added to.
4822 *
4823 * nam: the address structure (either struct sockaddr_in or struct
4824 *    sockaddr_in6 defined in RFC2553 [7]).
4825 *
4826 * len: the size of the address.
4827 */
4828static int sctp_connect(struct sock *sk, struct sockaddr *addr,
4829                        int addr_len, int flags)
4830{
4831        struct sctp_af *af;
4832        int err = -EINVAL;
4833
4834        lock_sock(sk);
4835        pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__, sk,
4836                 addr, addr_len);
4837
4838        /* Validate addr_len before calling common connect/connectx routine. */
4839        af = sctp_get_af_specific(addr->sa_family);
4840        if (af && addr_len >= af->sockaddr_len)
4841                err = __sctp_connect(sk, addr, af->sockaddr_len, flags, NULL);
4842
4843        release_sock(sk);
4844        return err;
4845}
4846
4847int sctp_inet_connect(struct socket *sock, struct sockaddr *uaddr,
4848                      int addr_len, int flags)
4849{
4850        if (addr_len < sizeof(uaddr->sa_family))
4851                return -EINVAL;
4852
4853        if (uaddr->sa_family == AF_UNSPEC)
4854                return -EOPNOTSUPP;
4855
4856        return sctp_connect(sock->sk, uaddr, addr_len, flags);
4857}
4858
4859/* FIXME: Write comments. */
4860static int sctp_disconnect(struct sock *sk, int flags)
4861{
4862        return -EOPNOTSUPP; /* STUB */
4863}
4864
4865/* 4.1.4 accept() - TCP Style Syntax
4866 *
4867 * Applications use accept() call to remove an established SCTP
4868 * association from the accept queue of the endpoint.  A new socket
4869 * descriptor will be returned from accept() to represent the newly
4870 * formed association.
4871 */
4872static struct sock *sctp_accept(struct sock *sk, int flags, int *err, bool kern)
4873{
4874        struct sctp_sock *sp;
4875        struct sctp_endpoint *ep;
4876        struct sock *newsk = NULL;
4877        struct sctp_association *asoc;
4878        long timeo;
4879        int error = 0;
4880
4881        lock_sock(sk);
4882
4883        sp = sctp_sk(sk);
4884        ep = sp->ep;
4885
4886        if (!sctp_style(sk, TCP)) {
4887                error = -EOPNOTSUPP;
4888                goto out;
4889        }
4890
4891        if (!sctp_sstate(sk, LISTENING)) {
4892                error = -EINVAL;
4893                goto out;
4894        }
4895
4896        timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
4897
4898        error = sctp_wait_for_accept(sk, timeo);
4899        if (error)
4900                goto out;
4901
4902        /* We treat the list of associations on the endpoint as the accept
4903         * queue and pick the first association on the list.
4904         */
4905        asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
4906
4907        newsk = sp->pf->create_accept_sk(sk, asoc, kern);
4908        if (!newsk) {
4909                error = -ENOMEM;
4910                goto out;
4911        }
4912
4913        /* Populate the fields of the newsk from the oldsk and migrate the
4914         * asoc to the newsk.
4915         */
4916        error = sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
4917        if (error) {
4918                sk_common_release(newsk);
4919                newsk = NULL;
4920        }
4921
4922out:
4923        release_sock(sk);
4924        *err = error;
4925        return newsk;
4926}
4927
4928/* The SCTP ioctl handler. */
4929static int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
4930{
4931        int rc = -ENOTCONN;
4932
4933        lock_sock(sk);
4934
4935        /*
4936         * SEQPACKET-style sockets in LISTENING state are valid, for
4937         * SCTP, so only discard TCP-style sockets in LISTENING state.
4938         */
4939        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
4940                goto out;
4941
4942        switch (cmd) {
4943        case SIOCINQ: {
4944                struct sk_buff *skb;
4945                unsigned int amount = 0;
4946
4947                skb = skb_peek(&sk->sk_receive_queue);
4948                if (skb != NULL) {
4949                        /*
4950                         * We will only return the amount of this packet since
4951                         * that is all that will be read.
4952                         */
4953                        amount = skb->len;
4954                }
4955                rc = put_user(amount, (int __user *)arg);
4956                break;
4957        }
4958        default:
4959                rc = -ENOIOCTLCMD;
4960                break;
4961        }
4962out:
4963        release_sock(sk);
4964        return rc;
4965}
4966
4967/* This is the function which gets called during socket creation to
4968 * initialized the SCTP-specific portion of the sock.
4969 * The sock structure should already be zero-filled memory.
4970 */
4971static int sctp_init_sock(struct sock *sk)
4972{
4973        struct net *net = sock_net(sk);
4974        struct sctp_sock *sp;
4975
4976        pr_debug("%s: sk:%p\n", __func__, sk);
4977
4978        sp = sctp_sk(sk);
4979
4980        /* Initialize the SCTP per socket area.  */
4981        switch (sk->sk_type) {
4982        case SOCK_SEQPACKET:
4983                sp->type = SCTP_SOCKET_UDP;
4984                break;
4985        case SOCK_STREAM:
4986                sp->type = SCTP_SOCKET_TCP;
4987                break;
4988        default:
4989                return -ESOCKTNOSUPPORT;
4990        }
4991
4992        sk->sk_gso_type = SKB_GSO_SCTP;
4993
4994        /* Initialize default send parameters. These parameters can be
4995         * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4996         */
4997        sp->default_stream = 0;
4998        sp->default_ppid = 0;
4999        sp->default_flags = 0;
5000        sp->default_context = 0;
5001        sp->default_timetolive = 0;
5002
5003        sp->default_rcv_context = 0;
5004        sp->max_burst = net->sctp.max_burst;
5005
5006        sp->sctp_hmac_alg = net->sctp.sctp_hmac_alg;
5007
5008        /* Initialize default setup parameters. These parameters
5009         * can be modified with the SCTP_INITMSG socket option or
5010         * overridden by the SCTP_INIT CMSG.
5011         */
5012        sp->initmsg.sinit_num_ostreams   = sctp_max_outstreams;
5013        sp->initmsg.sinit_max_instreams  = sctp_max_instreams;
5014        sp->initmsg.sinit_max_attempts   = net->sctp.max_retrans_init;
5015        sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
5016
5017        /* Initialize default RTO related parameters.  These parameters can
5018         * be modified for with the SCTP_RTOINFO socket option.
5019         */
5020        sp->rtoinfo.srto_initial = net->sctp.rto_initial;
5021        sp->rtoinfo.srto_max     = net->sctp.rto_max;
5022        sp->rtoinfo.srto_min     = net->sctp.rto_min;
5023
5024        /* Initialize default association related parameters. These parameters
5025         * can be modified with the SCTP_ASSOCINFO socket option.
5026         */
5027        sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
5028        sp->assocparams.sasoc_number_peer_destinations = 0;
5029        sp->assocparams.sasoc_peer_rwnd = 0;
5030        sp->assocparams.sasoc_local_rwnd = 0;
5031        sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
5032
5033        /* Initialize default event subscriptions. By default, all the
5034         * options are off.
5035         */
5036        sp->subscribe = 0;
5037
5038        /* Default Peer Address Parameters.  These defaults can
5039         * be modified via SCTP_PEER_ADDR_PARAMS
5040         */
5041        sp->hbinterval  = net->sctp.hb_interval;
5042        sp->pathmaxrxt  = net->sctp.max_retrans_path;
5043        sp->pf_retrans  = net->sctp.pf_retrans;
5044        sp->pathmtu     = 0; /* allow default discovery */
5045        sp->sackdelay   = net->sctp.sack_timeout;
5046        sp->sackfreq    = 2;
5047        sp->param_flags = SPP_HB_ENABLE |
5048                          SPP_PMTUD_ENABLE |
5049                          SPP_SACKDELAY_ENABLE;
5050        sp->default_ss = SCTP_SS_DEFAULT;
5051
5052        /* If enabled no SCTP message fragmentation will be performed.
5053         * Configure through SCTP_DISABLE_FRAGMENTS socket option.
5054         */
5055        sp->disable_fragments = 0;
5056
5057        /* Enable Nagle algorithm by default.  */
5058        sp->nodelay           = 0;
5059
5060        sp->recvrcvinfo = 0;
5061        sp->recvnxtinfo = 0;
5062
5063        /* Enable by default. */
5064        sp->v4mapped          = 1;
5065
5066        /* Auto-close idle associations after the configured
5067         * number of seconds.  A value of 0 disables this
5068         * feature.  Configure through the SCTP_AUTOCLOSE socket option,
5069         * for UDP-style sockets only.
5070         */
5071        sp->autoclose         = 0;
5072
5073        /* User specified fragmentation limit. */
5074        sp->user_frag         = 0;
5075
5076        sp->adaptation_ind = 0;
5077
5078        sp->pf = sctp_get_pf_specific(sk->sk_family);
5079
5080        /* Control variables for partial data delivery. */
5081        atomic_set(&sp->pd_mode, 0);
5082        skb_queue_head_init(&sp->pd_lobby);
5083        sp->frag_interleave = 0;
5084
5085        /* Create a per socket endpoint structure.  Even if we
5086         * change the data structure relationships, this may still
5087         * be useful for storing pre-connect address information.
5088         */
5089        sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
5090        if (!sp->ep)
5091                return -ENOMEM;
5092
5093        sp->hmac = NULL;
5094
5095        sk->sk_destruct = sctp_destruct_sock;
5096
5097        SCTP_DBG_OBJCNT_INC(sock);
5098
5099        local_bh_disable();
5100        sk_sockets_allocated_inc(sk);
5101        sock_prot_inuse_add(net, sk->sk_prot, 1);
5102
5103        /* Nothing can fail after this block, otherwise
5104         * sctp_destroy_sock() will be called without addr_wq_lock held
5105         */
5106        if (net->sctp.default_auto_asconf) {
5107                spin_lock(&sock_net(sk)->sctp.addr_wq_lock);
5108                list_add_tail(&sp->auto_asconf_list,
5109                    &net->sctp.auto_asconf_splist);
5110                sp->do_auto_asconf = 1;
5111                spin_unlock(&sock_net(sk)->sctp.addr_wq_lock);
5112        } else {
5113                sp->do_auto_asconf = 0;
5114        }
5115
5116        local_bh_enable();
5117
5118        return 0;
5119}
5120
5121/* Cleanup any SCTP per socket resources. Must be called with
5122 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5123 */
5124static void sctp_destroy_sock(struct sock *sk)
5125{
5126        struct sctp_sock *sp;
5127
5128        pr_debug("%s: sk:%p\n", __func__, sk);
5129
5130        /* Release our hold on the endpoint. */
5131        sp = sctp_sk(sk);
5132        /* This could happen during socket init, thus we bail out
5133         * early, since the rest of the below is not setup either.
5134         */
5135        if (sp->ep == NULL)
5136                return;
5137
5138        if (sp->do_auto_asconf) {
5139                sp->do_auto_asconf = 0;
5140                list_del(&sp->auto_asconf_list);
5141        }
5142        sctp_endpoint_free(sp->ep);
5143        local_bh_disable();
5144        sk_sockets_allocated_dec(sk);
5145        sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
5146        local_bh_enable();
5147}
5148
5149/* Triggered when there are no references on the socket anymore */
5150static void sctp_destruct_sock(struct sock *sk)
5151{
5152        struct sctp_sock *sp = sctp_sk(sk);
5153
5154        /* Free up the HMAC transform. */
5155        crypto_free_shash(sp->hmac);
5156
5157        inet_sock_destruct(sk);
5158}
5159
5160/* API 4.1.7 shutdown() - TCP Style Syntax
5161 *     int shutdown(int socket, int how);
5162 *
5163 *     sd      - the socket descriptor of the association to be closed.
5164 *     how     - Specifies the type of shutdown.  The  values  are
5165 *               as follows:
5166 *               SHUT_RD
5167 *                     Disables further receive operations. No SCTP
5168 *                     protocol action is taken.
5169 *               SHUT_WR
5170 *                     Disables further send operations, and initiates
5171 *                     the SCTP shutdown sequence.
5172 *               SHUT_RDWR
5173 *                     Disables further send  and  receive  operations
5174 *                     and initiates the SCTP shutdown sequence.
5175 */
5176static void sctp_shutdown(struct sock *sk, int how)
5177{
5178        struct net *net = sock_net(sk);
5179        struct sctp_endpoint *ep;
5180
5181        if (!sctp_style(sk, TCP))
5182                return;
5183
5184        ep = sctp_sk(sk)->ep;
5185        if (how & SEND_SHUTDOWN && !list_empty(&ep->asocs)) {
5186                struct sctp_association *asoc;
5187
5188                inet_sk_set_state(sk, SCTP_SS_CLOSING);
5189                asoc = list_entry(ep->asocs.next,
5190                                  struct sctp_association, asocs);
5191                sctp_primitive_SHUTDOWN(net, asoc, NULL);
5192        }
5193}
5194
5195int sctp_get_sctp_info(struct sock *sk, struct sctp_association *asoc,
5196                       struct sctp_info *info)
5197{
5198        struct sctp_transport *prim;
5199        struct list_head *pos;
5200        int mask;
5201
5202        memset(info, 0, sizeof(*info));
5203        if (!asoc) {
5204                struct sctp_sock *sp = sctp_sk(sk);
5205
5206                info->sctpi_s_autoclose = sp->autoclose;
5207                info->sctpi_s_adaptation_ind = sp->adaptation_ind;
5208                info->sctpi_s_pd_point = sp->pd_point;
5209                info->sctpi_s_nodelay = sp->nodelay;
5210                info->sctpi_s_disable_fragments = sp->disable_fragments;
5211                info->sctpi_s_v4mapped = sp->v4mapped;
5212                info->sctpi_s_frag_interleave = sp->frag_interleave;
5213                info->sctpi_s_type = sp->type;
5214
5215                return 0;
5216        }
5217
5218        info->sctpi_tag = asoc->c.my_vtag;
5219        info->sctpi_state = asoc->state;
5220        info->sctpi_rwnd = asoc->a_rwnd;
5221        info->sctpi_unackdata = asoc->unack_data;
5222        info->sctpi_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5223        info->sctpi_instrms = asoc->stream.incnt;
5224        info->sctpi_outstrms = asoc->stream.outcnt;
5225        list_for_each(pos, &asoc->base.inqueue.in_chunk_list)
5226                info->sctpi_inqueue++;
5227        list_for_each(pos, &asoc->outqueue.out_chunk_list)
5228                info->sctpi_outqueue++;
5229        info->sctpi_overall_error = asoc->overall_error_count;
5230        info->sctpi_max_burst = asoc->max_burst;
5231        info->sctpi_maxseg = asoc->frag_point;
5232        info->sctpi_peer_rwnd = asoc->peer.rwnd;
5233        info->sctpi_peer_tag = asoc->c.peer_vtag;
5234
5235        mask = asoc->peer.ecn_capable << 1;
5236        mask = (mask | asoc->peer.ipv4_address) << 1;
5237        mask = (mask | asoc->peer.ipv6_address) << 1;
5238        mask = (mask | asoc->peer.hostname_address) << 1;
5239        mask = (mask | asoc->peer.asconf_capable) << 1;
5240        mask = (mask | asoc->peer.prsctp_capable) << 1;
5241        mask = (mask | asoc->peer.auth_capable);
5242        info->sctpi_peer_capable = mask;
5243        mask = asoc->peer.sack_needed << 1;
5244        mask = (mask | asoc->peer.sack_generation) << 1;
5245        mask = (mask | asoc->peer.zero_window_announced);
5246        info->sctpi_peer_sack = mask;
5247
5248        info->sctpi_isacks = asoc->stats.isacks;
5249        info->sctpi_osacks = asoc->stats.osacks;
5250        info->sctpi_opackets = asoc->stats.opackets;
5251        info->sctpi_ipackets = asoc->stats.ipackets;
5252        info->sctpi_rtxchunks = asoc->stats.rtxchunks;
5253        info->sctpi_outofseqtsns = asoc->stats.outofseqtsns;
5254        info->sctpi_idupchunks = asoc->stats.idupchunks;
5255        info->sctpi_gapcnt = asoc->stats.gapcnt;
5256        info->sctpi_ouodchunks = asoc->stats.ouodchunks;
5257        info->sctpi_iuodchunks = asoc->stats.iuodchunks;
5258        info->sctpi_oodchunks = asoc->stats.oodchunks;
5259        info->sctpi_iodchunks = asoc->stats.iodchunks;
5260        info->sctpi_octrlchunks = asoc->stats.octrlchunks;
5261        info->sctpi_ictrlchunks = asoc->stats.ictrlchunks;
5262
5263        prim = asoc->peer.primary_path;
5264        memcpy(&info->sctpi_p_address, &prim->ipaddr, sizeof(prim->ipaddr));
5265        info->sctpi_p_state = prim->state;
5266        info->sctpi_p_cwnd = prim->cwnd;
5267        info->sctpi_p_srtt = prim->srtt;
5268        info->sctpi_p_rto = jiffies_to_msecs(prim->rto);
5269        info->sctpi_p_hbinterval = prim->hbinterval;
5270        info->sctpi_p_pathmaxrxt = prim->pathmaxrxt;
5271        info->sctpi_p_sackdelay = jiffies_to_msecs(prim->sackdelay);
5272        info->sctpi_p_ssthresh = prim->ssthresh;
5273        info->sctpi_p_partial_bytes_acked = prim->partial_bytes_acked;
5274        info->sctpi_p_flight_size = prim->flight_size;
5275        info->sctpi_p_error = prim->error_count;
5276
5277        return 0;
5278}
5279EXPORT_SYMBOL_GPL(sctp_get_sctp_info);
5280
5281/* use callback to avoid exporting the core structure */
5282void sctp_transport_walk_start(struct rhashtable_iter *iter)
5283{
5284        rhltable_walk_enter(&sctp_transport_hashtable, iter);
5285
5286        rhashtable_walk_start(iter);
5287}
5288
5289void sctp_transport_walk_stop(struct rhashtable_iter *iter)
5290{
5291        rhashtable_walk_stop(iter);
5292        rhashtable_walk_exit(iter);
5293}
5294
5295struct sctp_transport *sctp_transport_get_next(struct net *net,
5296                                               struct rhashtable_iter *iter)
5297{
5298        struct sctp_transport *t;
5299
5300        t = rhashtable_walk_next(iter);
5301        for (; t; t = rhashtable_walk_next(iter)) {
5302                if (IS_ERR(t)) {
5303                        if (PTR_ERR(t) == -EAGAIN)
5304                                continue;
5305                        break;
5306                }
5307
5308                if (!sctp_transport_hold(t))
5309                        continue;
5310
5311                if (net_eq(sock_net(t->asoc->base.sk), net) &&
5312                    t->asoc->peer.primary_path == t)
5313                        break;
5314
5315                sctp_transport_put(t);
5316        }
5317
5318        return t;
5319}
5320
5321struct sctp_transport *sctp_transport_get_idx(struct net *net,
5322                                              struct rhashtable_iter *iter,
5323                                              int pos)
5324{
5325        struct sctp_transport *t;
5326
5327        if (!pos)
5328                return SEQ_START_TOKEN;
5329
5330        while ((t = sctp_transport_get_next(net, iter)) && !IS_ERR(t)) {
5331                if (!--pos)
5332                        break;
5333                sctp_transport_put(t);
5334        }
5335
5336        return t;
5337}
5338
5339int sctp_for_each_endpoint(int (*cb)(struct sctp_endpoint *, void *),
5340                           void *p) {
5341        int err = 0;
5342        int hash = 0;
5343        struct sctp_ep_common *epb;
5344        struct sctp_hashbucket *head;
5345
5346        for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
5347             hash++, head++) {
5348                read_lock_bh(&head->lock);
5349                sctp_for_each_hentry(epb, &head->chain) {
5350                        err = cb(sctp_ep(epb), p);
5351                        if (err)
5352                                break;
5353                }
5354                read_unlock_bh(&head->lock);
5355        }
5356
5357        return err;
5358}
5359EXPORT_SYMBOL_GPL(sctp_for_each_endpoint);
5360
5361int sctp_transport_lookup_process(int (*cb)(struct sctp_transport *, void *),
5362                                  struct net *net,
5363                                  const union sctp_addr *laddr,
5364                                  const union sctp_addr *paddr, void *p)
5365{
5366        struct sctp_transport *transport;
5367        int err;
5368
5369        rcu_read_lock();
5370        transport = sctp_addrs_lookup_transport(net, laddr, paddr);
5371        rcu_read_unlock();
5372        if (!transport)
5373                return -ENOENT;
5374
5375        err = cb(transport, p);
5376        sctp_transport_put(transport);
5377
5378        return err;
5379}
5380EXPORT_SYMBOL_GPL(sctp_transport_lookup_process);
5381
5382int sctp_for_each_transport(int (*cb)(struct sctp_transport *, void *),
5383                            int (*cb_done)(struct sctp_transport *, void *),
5384                            struct net *net, int *pos, void *p) {
5385        struct rhashtable_iter hti;
5386        struct sctp_transport *tsp;
5387        int ret;
5388
5389again:
5390        ret = 0;
5391        sctp_transport_walk_start(&hti);
5392
5393        tsp = sctp_transport_get_idx(net, &hti, *pos + 1);
5394        for (; !IS_ERR_OR_NULL(tsp); tsp = sctp_transport_get_next(net, &hti)) {
5395                ret = cb(tsp, p);
5396                if (ret)
5397                        break;
5398                (*pos)++;
5399                sctp_transport_put(tsp);
5400        }
5401        sctp_transport_walk_stop(&hti);
5402
5403        if (ret) {
5404                if (cb_done && !cb_done(tsp, p)) {
5405                        (*pos)++;
5406                        sctp_transport_put(tsp);
5407                        goto again;
5408                }
5409                sctp_transport_put(tsp);
5410        }
5411
5412        return ret;
5413}
5414EXPORT_SYMBOL_GPL(sctp_for_each_transport);
5415
5416/* 7.2.1 Association Status (SCTP_STATUS)
5417
5418 * Applications can retrieve current status information about an
5419 * association, including association state, peer receiver window size,
5420 * number of unacked data chunks, and number of data chunks pending
5421 * receipt.  This information is read-only.
5422 */
5423static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
5424                                       char __user *optval,
5425                                       int __user *optlen)
5426{
5427        struct sctp_status status;
5428        struct sctp_association *asoc = NULL;
5429        struct sctp_transport *transport;
5430        sctp_assoc_t associd;
5431        int retval = 0;
5432
5433        if (len < sizeof(status)) {
5434                retval = -EINVAL;
5435                goto out;
5436        }
5437
5438        len = sizeof(status);
5439        if (copy_from_user(&status, optval, len)) {
5440                retval = -EFAULT;
5441                goto out;
5442        }
5443
5444        associd = status.sstat_assoc_id;
5445        asoc = sctp_id2assoc(sk, associd);
5446        if (!asoc) {
5447                retval = -EINVAL;
5448                goto out;
5449        }
5450
5451        transport = asoc->peer.primary_path;
5452
5453        status.sstat_assoc_id = sctp_assoc2id(asoc);
5454        status.sstat_state = sctp_assoc_to_state(asoc);
5455        status.sstat_rwnd =  asoc->peer.rwnd;
5456        status.sstat_unackdata = asoc->unack_data;
5457
5458        status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5459        status.sstat_instrms = asoc->stream.incnt;
5460        status.sstat_outstrms = asoc->stream.outcnt;
5461        status.sstat_fragmentation_point = asoc->frag_point;
5462        status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5463        memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
5464                        transport->af_specific->sockaddr_len);
5465        /* Map ipv4 address into v4-mapped-on-v6 address.  */
5466        sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
5467                (union sctp_addr *)&status.sstat_primary.spinfo_address);
5468        status.sstat_primary.spinfo_state = transport->state;
5469        status.sstat_primary.spinfo_cwnd = transport->cwnd;
5470        status.sstat_primary.spinfo_srtt = transport->srtt;
5471        status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
5472        status.sstat_primary.spinfo_mtu = transport->pathmtu;
5473
5474        if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
5475                status.sstat_primary.spinfo_state = SCTP_ACTIVE;
5476
5477        if (put_user(len, optlen)) {
5478                retval = -EFAULT;
5479                goto out;
5480        }
5481
5482        pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5483                 __func__, len, status.sstat_state, status.sstat_rwnd,
5484                 status.sstat_assoc_id);
5485
5486        if (copy_to_user(optval, &status, len)) {
5487                retval = -EFAULT;
5488                goto out;
5489        }
5490
5491out:
5492        return retval;
5493}
5494
5495
5496/* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5497 *
5498 * Applications can retrieve information about a specific peer address
5499 * of an association, including its reachability state, congestion
5500 * window, and retransmission timer values.  This information is
5501 * read-only.
5502 */
5503static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
5504                                          char __user *optval,
5505                                          int __user *optlen)
5506{
5507        struct sctp_paddrinfo pinfo;
5508        struct sctp_transport *transport;
5509        int retval = 0;
5510
5511        if (len < sizeof(pinfo)) {
5512                retval = -EINVAL;
5513                goto out;
5514        }
5515
5516        len = sizeof(pinfo);
5517        if (copy_from_user(&pinfo, optval, len)) {
5518                retval = -EFAULT;
5519                goto out;
5520        }
5521
5522        transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
5523                                           pinfo.spinfo_assoc_id);
5524        if (!transport)
5525                return -EINVAL;
5526
5527        pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5528        pinfo.spinfo_state = transport->state;
5529        pinfo.spinfo_cwnd = transport->cwnd;
5530        pinfo.spinfo_srtt = transport->srtt;
5531        pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
5532        pinfo.spinfo_mtu = transport->pathmtu;
5533
5534        if (pinfo.spinfo_state == SCTP_UNKNOWN)
5535                pinfo.spinfo_state = SCTP_ACTIVE;
5536
5537        if (put_user(len, optlen)) {
5538                retval = -EFAULT;
5539                goto out;
5540        }
5541
5542        if (copy_to_user(optval, &pinfo, len)) {
5543                retval = -EFAULT;
5544                goto out;
5545        }
5546
5547out:
5548        return retval;
5549}
5550
5551/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5552 *
5553 * This option is a on/off flag.  If enabled no SCTP message
5554 * fragmentation will be performed.  Instead if a message being sent
5555 * exceeds the current PMTU size, the message will NOT be sent and
5556 * instead a error will be indicated to the user.
5557 */
5558static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
5559                                        char __user *optval, int __user *optlen)
5560{
5561        int val;
5562
5563        if (len < sizeof(int))
5564                return -EINVAL;
5565
5566        len = sizeof(int);
5567        val = (sctp_sk(sk)->disable_fragments == 1);
5568        if (put_user(len, optlen))
5569                return -EFAULT;
5570        if (copy_to_user(optval, &val, len))
5571                return -EFAULT;
5572        return 0;
5573}
5574
5575/* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5576 *
5577 * This socket option is used to specify various notifications and
5578 * ancillary data the user wishes to receive.
5579 */
5580static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
5581                                  int __user *optlen)
5582{
5583        struct sctp_event_subscribe subscribe;
5584        __u8 *sn_type = (__u8 *)&subscribe;
5585        int i;
5586
5587        if (len == 0)
5588                return -EINVAL;
5589        if (len > sizeof(struct sctp_event_subscribe))
5590                len = sizeof(struct sctp_event_subscribe);
5591        if (put_user(len, optlen))
5592                return -EFAULT;
5593
5594        for (i = 0; i < len; i++)
5595                sn_type[i] = sctp_ulpevent_type_enabled(sctp_sk(sk)->subscribe,
5596                                                        SCTP_SN_TYPE_BASE + i);
5597
5598        if (copy_to_user(optval, &subscribe, len))
5599                return -EFAULT;
5600
5601        return 0;
5602}
5603
5604/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5605 *
5606 * This socket option is applicable to the UDP-style socket only.  When
5607 * set it will cause associations that are idle for more than the
5608 * specified number of seconds to automatically close.  An association
5609 * being idle is defined an association that has NOT sent or received
5610 * user data.  The special value of '0' indicates that no automatic
5611 * close of any associations should be performed.  The option expects an
5612 * integer defining the number of seconds of idle time before an
5613 * association is closed.
5614 */
5615static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
5616{
5617        /* Applicable to UDP-style socket only */
5618        if (sctp_style(sk, TCP))
5619                return -EOPNOTSUPP;
5620        if (len < sizeof(int))
5621                return -EINVAL;
5622        len = sizeof(int);
5623        if (put_user(len, optlen))
5624                return -EFAULT;
5625        if (put_user(sctp_sk(sk)->autoclose, (int __user *)optval))
5626                return -EFAULT;
5627        return 0;
5628}
5629
5630/* Helper routine to branch off an association to a new socket.  */
5631int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp)
5632{
5633        struct sctp_association *asoc = sctp_id2assoc(sk, id);
5634        struct sctp_sock *sp = sctp_sk(sk);
5635        struct socket *sock;
5636        int err = 0;
5637
5638        /* Do not peel off from one netns to another one. */
5639        if (!net_eq(current->nsproxy->net_ns, sock_net(sk)))
5640                return -EINVAL;
5641
5642        if (!asoc)
5643                return -EINVAL;
5644
5645        /* An association cannot be branched off from an already peeled-off
5646         * socket, nor is this supported for tcp style sockets.
5647         */
5648        if (!sctp_style(sk, UDP))
5649                return -EINVAL;
5650
5651        /* Create a new socket.  */
5652        err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
5653        if (err < 0)
5654                return err;
5655
5656        sctp_copy_sock(sock->sk, sk, asoc);
5657
5658        /* Make peeled-off sockets more like 1-1 accepted sockets.
5659         * Set the daddr and initialize id to something more random and also
5660         * copy over any ip options.
5661         */
5662        sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sk);
5663        sp->pf->copy_ip_options(sk, sock->sk);
5664
5665        /* Populate the fields of the newsk from the oldsk and migrate the
5666         * asoc to the newsk.
5667         */
5668        err = sctp_sock_migrate(sk, sock->sk, asoc,
5669                                SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
5670        if (err) {
5671                sock_release(sock);
5672                sock = NULL;
5673        }
5674
5675        *sockp = sock;
5676
5677        return err;
5678}
5679EXPORT_SYMBOL(sctp_do_peeloff);
5680
5681static int sctp_getsockopt_peeloff_common(struct sock *sk, sctp_peeloff_arg_t *peeloff,
5682                                          struct file **newfile, unsigned flags)
5683{
5684        struct socket *newsock;
5685        int retval;
5686
5687        retval = sctp_do_peeloff(sk, peeloff->associd, &newsock);
5688        if (retval < 0)
5689                goto out;
5690
5691        /* Map the socket to an unused fd that can be returned to the user.  */
5692        retval = get_unused_fd_flags(flags & SOCK_CLOEXEC);
5693        if (