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