source: src/linux/universal/linux-4.4/net/sctp/socket.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

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