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