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

Last change on this file since 31885 was 31885, checked in by brainslayer, 4 months ago

update

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