selinux: wrap AVC state
[muen/linux.git] / net / sctp / socket.c
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 <crypto/hash.h>
56 #include <linux/types.h>
57 #include <linux/kernel.h>
58 #include <linux/wait.h>
59 #include <linux/time.h>
60 #include <linux/sched/signal.h>
61 #include <linux/ip.h>
62 #include <linux/capability.h>
63 #include <linux/fcntl.h>
64 #include <linux/poll.h>
65 #include <linux/init.h>
66 #include <linux/slab.h>
67 #include <linux/file.h>
68 #include <linux/compat.h>
69
70 #include <net/ip.h>
71 #include <net/icmp.h>
72 #include <net/route.h>
73 #include <net/ipv6.h>
74 #include <net/inet_common.h>
75 #include <net/busy_poll.h>
76
77 #include <linux/socket.h> /* for sa_family_t */
78 #include <linux/export.h>
79 #include <net/sock.h>
80 #include <net/sctp/sctp.h>
81 #include <net/sctp/sm.h>
82 #include <net/sctp/stream_sched.h>
83
84 /* Forward declarations for internal helper functions. */
85 static int sctp_writeable(struct sock *sk);
86 static void sctp_wfree(struct sk_buff *skb);
87 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
88                                 size_t msg_len);
89 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);
90 static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
91 static int sctp_wait_for_accept(struct sock *sk, long timeo);
92 static void sctp_wait_for_close(struct sock *sk, long timeo);
93 static void sctp_destruct_sock(struct sock *sk);
94 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
95                                         union sctp_addr *addr, int len);
96 static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
97 static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
98 static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
99 static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
100 static int sctp_send_asconf(struct sctp_association *asoc,
101                             struct sctp_chunk *chunk);
102 static int sctp_do_bind(struct sock *, union sctp_addr *, int);
103 static int sctp_autobind(struct sock *sk);
104 static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
105                               struct sctp_association *assoc,
106                               enum sctp_socket_type type);
107
108 static unsigned long sctp_memory_pressure;
109 static atomic_long_t sctp_memory_allocated;
110 struct percpu_counter sctp_sockets_allocated;
111
112 static void sctp_enter_memory_pressure(struct sock *sk)
113 {
114         sctp_memory_pressure = 1;
115 }
116
117
118 /* Get the sndbuf space available at the time on the association.  */
119 static inline int sctp_wspace(struct sctp_association *asoc)
120 {
121         int amt;
122
123         if (asoc->ep->sndbuf_policy)
124                 amt = asoc->sndbuf_used;
125         else
126                 amt = sk_wmem_alloc_get(asoc->base.sk);
127
128         if (amt >= asoc->base.sk->sk_sndbuf) {
129                 if (asoc->base.sk->sk_userlocks & SOCK_SNDBUF_LOCK)
130                         amt = 0;
131                 else {
132                         amt = sk_stream_wspace(asoc->base.sk);
133                         if (amt < 0)
134                                 amt = 0;
135                 }
136         } else {
137                 amt = asoc->base.sk->sk_sndbuf - amt;
138         }
139         return amt;
140 }
141
142 /* Increment the used sndbuf space count of the corresponding association by
143  * the size of the outgoing data chunk.
144  * Also, set the skb destructor for sndbuf accounting later.
145  *
146  * Since it is always 1-1 between chunk and skb, and also a new skb is always
147  * allocated for chunk bundling in sctp_packet_transmit(), we can use the
148  * destructor in the data chunk skb for the purpose of the sndbuf space
149  * tracking.
150  */
151 static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
152 {
153         struct sctp_association *asoc = chunk->asoc;
154         struct sock *sk = asoc->base.sk;
155
156         /* The sndbuf space is tracked per association.  */
157         sctp_association_hold(asoc);
158
159         skb_set_owner_w(chunk->skb, sk);
160
161         chunk->skb->destructor = sctp_wfree;
162         /* Save the chunk pointer in skb for sctp_wfree to use later.  */
163         skb_shinfo(chunk->skb)->destructor_arg = chunk;
164
165         asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +
166                                 sizeof(struct sk_buff) +
167                                 sizeof(struct sctp_chunk);
168
169         refcount_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
170         sk->sk_wmem_queued += chunk->skb->truesize;
171         sk_mem_charge(sk, chunk->skb->truesize);
172 }
173
174 static void sctp_clear_owner_w(struct sctp_chunk *chunk)
175 {
176         skb_orphan(chunk->skb);
177 }
178
179 static void sctp_for_each_tx_datachunk(struct sctp_association *asoc,
180                                        void (*cb)(struct sctp_chunk *))
181
182 {
183         struct sctp_outq *q = &asoc->outqueue;
184         struct sctp_transport *t;
185         struct sctp_chunk *chunk;
186
187         list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
188                 list_for_each_entry(chunk, &t->transmitted, transmitted_list)
189                         cb(chunk);
190
191         list_for_each_entry(chunk, &q->retransmit, transmitted_list)
192                 cb(chunk);
193
194         list_for_each_entry(chunk, &q->sacked, transmitted_list)
195                 cb(chunk);
196
197         list_for_each_entry(chunk, &q->abandoned, transmitted_list)
198                 cb(chunk);
199
200         list_for_each_entry(chunk, &q->out_chunk_list, list)
201                 cb(chunk);
202 }
203
204 static void sctp_for_each_rx_skb(struct sctp_association *asoc, struct sock *sk,
205                                  void (*cb)(struct sk_buff *, struct sock *))
206
207 {
208         struct sk_buff *skb, *tmp;
209
210         sctp_skb_for_each(skb, &asoc->ulpq.lobby, tmp)
211                 cb(skb, sk);
212
213         sctp_skb_for_each(skb, &asoc->ulpq.reasm, tmp)
214                 cb(skb, sk);
215
216         sctp_skb_for_each(skb, &asoc->ulpq.reasm_uo, tmp)
217                 cb(skb, sk);
218 }
219
220 /* Verify that this is a valid address. */
221 static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
222                                    int len)
223 {
224         struct sctp_af *af;
225
226         /* Verify basic sockaddr. */
227         af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
228         if (!af)
229                 return -EINVAL;
230
231         /* Is this a valid SCTP address?  */
232         if (!af->addr_valid(addr, sctp_sk(sk), NULL))
233                 return -EINVAL;
234
235         if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
236                 return -EINVAL;
237
238         return 0;
239 }
240
241 /* Look up the association by its id.  If this is not a UDP-style
242  * socket, the ID field is always ignored.
243  */
244 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
245 {
246         struct sctp_association *asoc = NULL;
247
248         /* If this is not a UDP-style socket, assoc id should be ignored. */
249         if (!sctp_style(sk, UDP)) {
250                 /* Return NULL if the socket state is not ESTABLISHED. It
251                  * could be a TCP-style listening socket or a socket which
252                  * hasn't yet called connect() to establish an association.
253                  */
254                 if (!sctp_sstate(sk, ESTABLISHED) && !sctp_sstate(sk, CLOSING))
255                         return NULL;
256
257                 /* Get the first and the only association from the list. */
258                 if (!list_empty(&sctp_sk(sk)->ep->asocs))
259                         asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
260                                           struct sctp_association, asocs);
261                 return asoc;
262         }
263
264         /* Otherwise this is a UDP-style socket. */
265         if (!id || (id == (sctp_assoc_t)-1))
266                 return NULL;
267
268         spin_lock_bh(&sctp_assocs_id_lock);
269         asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
270         spin_unlock_bh(&sctp_assocs_id_lock);
271
272         if (!asoc || (asoc->base.sk != sk) || asoc->base.dead)
273                 return NULL;
274
275         return asoc;
276 }
277
278 /* Look up the transport from an address and an assoc id. If both address and
279  * id are specified, the associations matching the address and the id should be
280  * the same.
281  */
282 static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
283                                               struct sockaddr_storage *addr,
284                                               sctp_assoc_t id)
285 {
286         struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
287         struct sctp_af *af = sctp_get_af_specific(addr->ss_family);
288         union sctp_addr *laddr = (union sctp_addr *)addr;
289         struct sctp_transport *transport;
290
291         if (!af || sctp_verify_addr(sk, laddr, af->sockaddr_len))
292                 return NULL;
293
294         addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
295                                                laddr,
296                                                &transport);
297
298         if (!addr_asoc)
299                 return NULL;
300
301         id_asoc = sctp_id2assoc(sk, id);
302         if (id_asoc && (id_asoc != addr_asoc))
303                 return NULL;
304
305         sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
306                                                 (union sctp_addr *)addr);
307
308         return transport;
309 }
310
311 /* API 3.1.2 bind() - UDP Style Syntax
312  * The syntax of bind() is,
313  *
314  *   ret = bind(int sd, struct sockaddr *addr, int addrlen);
315  *
316  *   sd      - the socket descriptor returned by socket().
317  *   addr    - the address structure (struct sockaddr_in or struct
318  *             sockaddr_in6 [RFC 2553]),
319  *   addr_len - the size of the address structure.
320  */
321 static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
322 {
323         int retval = 0;
324
325         lock_sock(sk);
326
327         pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk,
328                  addr, addr_len);
329
330         /* Disallow binding twice. */
331         if (!sctp_sk(sk)->ep->base.bind_addr.port)
332                 retval = sctp_do_bind(sk, (union sctp_addr *)addr,
333                                       addr_len);
334         else
335                 retval = -EINVAL;
336
337         release_sock(sk);
338
339         return retval;
340 }
341
342 static long sctp_get_port_local(struct sock *, union sctp_addr *);
343
344 /* Verify this is a valid sockaddr. */
345 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
346                                         union sctp_addr *addr, int len)
347 {
348         struct sctp_af *af;
349
350         /* Check minimum size.  */
351         if (len < sizeof (struct sockaddr))
352                 return NULL;
353
354         if (!opt->pf->af_supported(addr->sa.sa_family, opt))
355                 return NULL;
356
357         /* V4 mapped address are really of AF_INET family */
358         if (addr->sa.sa_family == AF_INET6 &&
359             ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
360             !opt->pf->af_supported(AF_INET, opt))
361                 return NULL;
362
363         /* If we get this far, af is valid. */
364         af = sctp_get_af_specific(addr->sa.sa_family);
365
366         if (len < af->sockaddr_len)
367                 return NULL;
368
369         return af;
370 }
371
372 /* Bind a local address either to an endpoint or to an association.  */
373 static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
374 {
375         struct net *net = sock_net(sk);
376         struct sctp_sock *sp = sctp_sk(sk);
377         struct sctp_endpoint *ep = sp->ep;
378         struct sctp_bind_addr *bp = &ep->base.bind_addr;
379         struct sctp_af *af;
380         unsigned short snum;
381         int ret = 0;
382
383         /* Common sockaddr verification. */
384         af = sctp_sockaddr_af(sp, addr, len);
385         if (!af) {
386                 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
387                          __func__, sk, addr, len);
388                 return -EINVAL;
389         }
390
391         snum = ntohs(addr->v4.sin_port);
392
393         pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
394                  __func__, sk, &addr->sa, bp->port, snum, len);
395
396         /* PF specific bind() address verification. */
397         if (!sp->pf->bind_verify(sp, addr))
398                 return -EADDRNOTAVAIL;
399
400         /* We must either be unbound, or bind to the same port.
401          * It's OK to allow 0 ports if we are already bound.
402          * We'll just inhert an already bound port in this case
403          */
404         if (bp->port) {
405                 if (!snum)
406                         snum = bp->port;
407                 else if (snum != bp->port) {
408                         pr_debug("%s: new port %d doesn't match existing port "
409                                  "%d\n", __func__, snum, bp->port);
410                         return -EINVAL;
411                 }
412         }
413
414         if (snum && snum < inet_prot_sock(net) &&
415             !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
416                 return -EACCES;
417
418         /* See if the address matches any of the addresses we may have
419          * already bound before checking against other endpoints.
420          */
421         if (sctp_bind_addr_match(bp, addr, sp))
422                 return -EINVAL;
423
424         /* Make sure we are allowed to bind here.
425          * The function sctp_get_port_local() does duplicate address
426          * detection.
427          */
428         addr->v4.sin_port = htons(snum);
429         if ((ret = sctp_get_port_local(sk, addr))) {
430                 return -EADDRINUSE;
431         }
432
433         /* Refresh ephemeral port.  */
434         if (!bp->port)
435                 bp->port = inet_sk(sk)->inet_num;
436
437         /* Add the address to the bind address list.
438          * Use GFP_ATOMIC since BHs will be disabled.
439          */
440         ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
441                                  SCTP_ADDR_SRC, GFP_ATOMIC);
442
443         /* Copy back into socket for getsockname() use. */
444         if (!ret) {
445                 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
446                 sp->pf->to_sk_saddr(addr, sk);
447         }
448
449         return ret;
450 }
451
452  /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
453  *
454  * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
455  * at any one time.  If a sender, after sending an ASCONF chunk, decides
456  * it needs to transfer another ASCONF Chunk, it MUST wait until the
457  * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
458  * subsequent ASCONF. Note this restriction binds each side, so at any
459  * time two ASCONF may be in-transit on any given association (one sent
460  * from each endpoint).
461  */
462 static int sctp_send_asconf(struct sctp_association *asoc,
463                             struct sctp_chunk *chunk)
464 {
465         struct net      *net = sock_net(asoc->base.sk);
466         int             retval = 0;
467
468         /* If there is an outstanding ASCONF chunk, queue it for later
469          * transmission.
470          */
471         if (asoc->addip_last_asconf) {
472                 list_add_tail(&chunk->list, &asoc->addip_chunk_list);
473                 goto out;
474         }
475
476         /* Hold the chunk until an ASCONF_ACK is received. */
477         sctp_chunk_hold(chunk);
478         retval = sctp_primitive_ASCONF(net, asoc, chunk);
479         if (retval)
480                 sctp_chunk_free(chunk);
481         else
482                 asoc->addip_last_asconf = chunk;
483
484 out:
485         return retval;
486 }
487
488 /* Add a list of addresses as bind addresses to local endpoint or
489  * association.
490  *
491  * Basically run through each address specified in the addrs/addrcnt
492  * array/length pair, determine if it is IPv6 or IPv4 and call
493  * sctp_do_bind() on it.
494  *
495  * If any of them fails, then the operation will be reversed and the
496  * ones that were added will be removed.
497  *
498  * Only sctp_setsockopt_bindx() is supposed to call this function.
499  */
500 static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
501 {
502         int cnt;
503         int retval = 0;
504         void *addr_buf;
505         struct sockaddr *sa_addr;
506         struct sctp_af *af;
507
508         pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk,
509                  addrs, addrcnt);
510
511         addr_buf = addrs;
512         for (cnt = 0; cnt < addrcnt; cnt++) {
513                 /* The list may contain either IPv4 or IPv6 address;
514                  * determine the address length for walking thru the list.
515                  */
516                 sa_addr = addr_buf;
517                 af = sctp_get_af_specific(sa_addr->sa_family);
518                 if (!af) {
519                         retval = -EINVAL;
520                         goto err_bindx_add;
521                 }
522
523                 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
524                                       af->sockaddr_len);
525
526                 addr_buf += af->sockaddr_len;
527
528 err_bindx_add:
529                 if (retval < 0) {
530                         /* Failed. Cleanup the ones that have been added */
531                         if (cnt > 0)
532                                 sctp_bindx_rem(sk, addrs, cnt);
533                         return retval;
534                 }
535         }
536
537         return retval;
538 }
539
540 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
541  * associations that are part of the endpoint indicating that a list of local
542  * addresses are added to the endpoint.
543  *
544  * If any of the addresses is already in the bind address list of the
545  * association, we do not send the chunk for that association.  But it will not
546  * affect other associations.
547  *
548  * Only sctp_setsockopt_bindx() is supposed to call this function.
549  */
550 static int sctp_send_asconf_add_ip(struct sock          *sk,
551                                    struct sockaddr      *addrs,
552                                    int                  addrcnt)
553 {
554         struct net *net = sock_net(sk);
555         struct sctp_sock                *sp;
556         struct sctp_endpoint            *ep;
557         struct sctp_association         *asoc;
558         struct sctp_bind_addr           *bp;
559         struct sctp_chunk               *chunk;
560         struct sctp_sockaddr_entry      *laddr;
561         union sctp_addr                 *addr;
562         union sctp_addr                 saveaddr;
563         void                            *addr_buf;
564         struct sctp_af                  *af;
565         struct list_head                *p;
566         int                             i;
567         int                             retval = 0;
568
569         if (!net->sctp.addip_enable)
570                 return retval;
571
572         sp = sctp_sk(sk);
573         ep = sp->ep;
574
575         pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
576                  __func__, sk, addrs, addrcnt);
577
578         list_for_each_entry(asoc, &ep->asocs, asocs) {
579                 if (!asoc->peer.asconf_capable)
580                         continue;
581
582                 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
583                         continue;
584
585                 if (!sctp_state(asoc, ESTABLISHED))
586                         continue;
587
588                 /* Check if any address in the packed array of addresses is
589                  * in the bind address list of the association. If so,
590                  * do not send the asconf chunk to its peer, but continue with
591                  * other associations.
592                  */
593                 addr_buf = addrs;
594                 for (i = 0; i < addrcnt; i++) {
595                         addr = addr_buf;
596                         af = sctp_get_af_specific(addr->v4.sin_family);
597                         if (!af) {
598                                 retval = -EINVAL;
599                                 goto out;
600                         }
601
602                         if (sctp_assoc_lookup_laddr(asoc, addr))
603                                 break;
604
605                         addr_buf += af->sockaddr_len;
606                 }
607                 if (i < addrcnt)
608                         continue;
609
610                 /* Use the first valid address in bind addr list of
611                  * association as Address Parameter of ASCONF CHUNK.
612                  */
613                 bp = &asoc->base.bind_addr;
614                 p = bp->address_list.next;
615                 laddr = list_entry(p, struct sctp_sockaddr_entry, list);
616                 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
617                                                    addrcnt, SCTP_PARAM_ADD_IP);
618                 if (!chunk) {
619                         retval = -ENOMEM;
620                         goto out;
621                 }
622
623                 /* Add the new addresses to the bind address list with
624                  * use_as_src set to 0.
625                  */
626                 addr_buf = addrs;
627                 for (i = 0; i < addrcnt; i++) {
628                         addr = addr_buf;
629                         af = sctp_get_af_specific(addr->v4.sin_family);
630                         memcpy(&saveaddr, addr, af->sockaddr_len);
631                         retval = sctp_add_bind_addr(bp, &saveaddr,
632                                                     sizeof(saveaddr),
633                                                     SCTP_ADDR_NEW, GFP_ATOMIC);
634                         addr_buf += af->sockaddr_len;
635                 }
636                 if (asoc->src_out_of_asoc_ok) {
637                         struct sctp_transport *trans;
638
639                         list_for_each_entry(trans,
640                             &asoc->peer.transport_addr_list, transports) {
641                                 /* Clear the source and route cache */
642                                 sctp_transport_dst_release(trans);
643                                 trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
644                                     2*asoc->pathmtu, 4380));
645                                 trans->ssthresh = asoc->peer.i.a_rwnd;
646                                 trans->rto = asoc->rto_initial;
647                                 sctp_max_rto(asoc, trans);
648                                 trans->rtt = trans->srtt = trans->rttvar = 0;
649                                 sctp_transport_route(trans, NULL,
650                                     sctp_sk(asoc->base.sk));
651                         }
652                 }
653                 retval = sctp_send_asconf(asoc, chunk);
654         }
655
656 out:
657         return retval;
658 }
659
660 /* Remove a list of addresses from bind addresses list.  Do not remove the
661  * last address.
662  *
663  * Basically run through each address specified in the addrs/addrcnt
664  * array/length pair, determine if it is IPv6 or IPv4 and call
665  * sctp_del_bind() on it.
666  *
667  * If any of them fails, then the operation will be reversed and the
668  * ones that were removed will be added back.
669  *
670  * At least one address has to be left; if only one address is
671  * available, the operation will return -EBUSY.
672  *
673  * Only sctp_setsockopt_bindx() is supposed to call this function.
674  */
675 static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
676 {
677         struct sctp_sock *sp = sctp_sk(sk);
678         struct sctp_endpoint *ep = sp->ep;
679         int cnt;
680         struct sctp_bind_addr *bp = &ep->base.bind_addr;
681         int retval = 0;
682         void *addr_buf;
683         union sctp_addr *sa_addr;
684         struct sctp_af *af;
685
686         pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
687                  __func__, sk, addrs, addrcnt);
688
689         addr_buf = addrs;
690         for (cnt = 0; cnt < addrcnt; cnt++) {
691                 /* If the bind address list is empty or if there is only one
692                  * bind address, there is nothing more to be removed (we need
693                  * at least one address here).
694                  */
695                 if (list_empty(&bp->address_list) ||
696                     (sctp_list_single_entry(&bp->address_list))) {
697                         retval = -EBUSY;
698                         goto err_bindx_rem;
699                 }
700
701                 sa_addr = addr_buf;
702                 af = sctp_get_af_specific(sa_addr->sa.sa_family);
703                 if (!af) {
704                         retval = -EINVAL;
705                         goto err_bindx_rem;
706                 }
707
708                 if (!af->addr_valid(sa_addr, sp, NULL)) {
709                         retval = -EADDRNOTAVAIL;
710                         goto err_bindx_rem;
711                 }
712
713                 if (sa_addr->v4.sin_port &&
714                     sa_addr->v4.sin_port != htons(bp->port)) {
715                         retval = -EINVAL;
716                         goto err_bindx_rem;
717                 }
718
719                 if (!sa_addr->v4.sin_port)
720                         sa_addr->v4.sin_port = htons(bp->port);
721
722                 /* FIXME - There is probably a need to check if sk->sk_saddr and
723                  * sk->sk_rcv_addr are currently set to one of the addresses to
724                  * be removed. This is something which needs to be looked into
725                  * when we are fixing the outstanding issues with multi-homing
726                  * socket routing and failover schemes. Refer to comments in
727                  * sctp_do_bind(). -daisy
728                  */
729                 retval = sctp_del_bind_addr(bp, sa_addr);
730
731                 addr_buf += af->sockaddr_len;
732 err_bindx_rem:
733                 if (retval < 0) {
734                         /* Failed. Add the ones that has been removed back */
735                         if (cnt > 0)
736                                 sctp_bindx_add(sk, addrs, cnt);
737                         return retval;
738                 }
739         }
740
741         return retval;
742 }
743
744 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
745  * the associations that are part of the endpoint indicating that a list of
746  * local addresses are removed from the endpoint.
747  *
748  * If any of the addresses is already in the bind address list of the
749  * association, we do not send the chunk for that association.  But it will not
750  * affect other associations.
751  *
752  * Only sctp_setsockopt_bindx() is supposed to call this function.
753  */
754 static int sctp_send_asconf_del_ip(struct sock          *sk,
755                                    struct sockaddr      *addrs,
756                                    int                  addrcnt)
757 {
758         struct net *net = sock_net(sk);
759         struct sctp_sock        *sp;
760         struct sctp_endpoint    *ep;
761         struct sctp_association *asoc;
762         struct sctp_transport   *transport;
763         struct sctp_bind_addr   *bp;
764         struct sctp_chunk       *chunk;
765         union sctp_addr         *laddr;
766         void                    *addr_buf;
767         struct sctp_af          *af;
768         struct sctp_sockaddr_entry *saddr;
769         int                     i;
770         int                     retval = 0;
771         int                     stored = 0;
772
773         chunk = NULL;
774         if (!net->sctp.addip_enable)
775                 return retval;
776
777         sp = sctp_sk(sk);
778         ep = sp->ep;
779
780         pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
781                  __func__, sk, addrs, addrcnt);
782
783         list_for_each_entry(asoc, &ep->asocs, asocs) {
784
785                 if (!asoc->peer.asconf_capable)
786                         continue;
787
788                 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
789                         continue;
790
791                 if (!sctp_state(asoc, ESTABLISHED))
792                         continue;
793
794                 /* Check if any address in the packed array of addresses is
795                  * not present in the bind address list of the association.
796                  * If so, do not send the asconf chunk to its peer, but
797                  * continue with other associations.
798                  */
799                 addr_buf = addrs;
800                 for (i = 0; i < addrcnt; i++) {
801                         laddr = addr_buf;
802                         af = sctp_get_af_specific(laddr->v4.sin_family);
803                         if (!af) {
804                                 retval = -EINVAL;
805                                 goto out;
806                         }
807
808                         if (!sctp_assoc_lookup_laddr(asoc, laddr))
809                                 break;
810
811                         addr_buf += af->sockaddr_len;
812                 }
813                 if (i < addrcnt)
814                         continue;
815
816                 /* Find one address in the association's bind address list
817                  * that is not in the packed array of addresses. This is to
818                  * make sure that we do not delete all the addresses in the
819                  * association.
820                  */
821                 bp = &asoc->base.bind_addr;
822                 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
823                                                addrcnt, sp);
824                 if ((laddr == NULL) && (addrcnt == 1)) {
825                         if (asoc->asconf_addr_del_pending)
826                                 continue;
827                         asoc->asconf_addr_del_pending =
828                             kzalloc(sizeof(union sctp_addr), GFP_ATOMIC);
829                         if (asoc->asconf_addr_del_pending == NULL) {
830                                 retval = -ENOMEM;
831                                 goto out;
832                         }
833                         asoc->asconf_addr_del_pending->sa.sa_family =
834                                     addrs->sa_family;
835                         asoc->asconf_addr_del_pending->v4.sin_port =
836                                     htons(bp->port);
837                         if (addrs->sa_family == AF_INET) {
838                                 struct sockaddr_in *sin;
839
840                                 sin = (struct sockaddr_in *)addrs;
841                                 asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
842                         } else if (addrs->sa_family == AF_INET6) {
843                                 struct sockaddr_in6 *sin6;
844
845                                 sin6 = (struct sockaddr_in6 *)addrs;
846                                 asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
847                         }
848
849                         pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
850                                  __func__, asoc, &asoc->asconf_addr_del_pending->sa,
851                                  asoc->asconf_addr_del_pending);
852
853                         asoc->src_out_of_asoc_ok = 1;
854                         stored = 1;
855                         goto skip_mkasconf;
856                 }
857
858                 if (laddr == NULL)
859                         return -EINVAL;
860
861                 /* We do not need RCU protection throughout this loop
862                  * because this is done under a socket lock from the
863                  * setsockopt call.
864                  */
865                 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
866                                                    SCTP_PARAM_DEL_IP);
867                 if (!chunk) {
868                         retval = -ENOMEM;
869                         goto out;
870                 }
871
872 skip_mkasconf:
873                 /* Reset use_as_src flag for the addresses in the bind address
874                  * list that are to be deleted.
875                  */
876                 addr_buf = addrs;
877                 for (i = 0; i < addrcnt; i++) {
878                         laddr = addr_buf;
879                         af = sctp_get_af_specific(laddr->v4.sin_family);
880                         list_for_each_entry(saddr, &bp->address_list, list) {
881                                 if (sctp_cmp_addr_exact(&saddr->a, laddr))
882                                         saddr->state = SCTP_ADDR_DEL;
883                         }
884                         addr_buf += af->sockaddr_len;
885                 }
886
887                 /* Update the route and saddr entries for all the transports
888                  * as some of the addresses in the bind address list are
889                  * about to be deleted and cannot be used as source addresses.
890                  */
891                 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
892                                         transports) {
893                         sctp_transport_dst_release(transport);
894                         sctp_transport_route(transport, NULL,
895                                              sctp_sk(asoc->base.sk));
896                 }
897
898                 if (stored)
899                         /* We don't need to transmit ASCONF */
900                         continue;
901                 retval = sctp_send_asconf(asoc, chunk);
902         }
903 out:
904         return retval;
905 }
906
907 /* set addr events to assocs in the endpoint.  ep and addr_wq must be locked */
908 int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
909 {
910         struct sock *sk = sctp_opt2sk(sp);
911         union sctp_addr *addr;
912         struct sctp_af *af;
913
914         /* It is safe to write port space in caller. */
915         addr = &addrw->a;
916         addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
917         af = sctp_get_af_specific(addr->sa.sa_family);
918         if (!af)
919                 return -EINVAL;
920         if (sctp_verify_addr(sk, addr, af->sockaddr_len))
921                 return -EINVAL;
922
923         if (addrw->state == SCTP_ADDR_NEW)
924                 return sctp_send_asconf_add_ip(sk, (struct sockaddr *)addr, 1);
925         else
926                 return sctp_send_asconf_del_ip(sk, (struct sockaddr *)addr, 1);
927 }
928
929 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
930  *
931  * API 8.1
932  * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
933  *                int flags);
934  *
935  * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
936  * If the sd is an IPv6 socket, the addresses passed can either be IPv4
937  * or IPv6 addresses.
938  *
939  * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
940  * Section 3.1.2 for this usage.
941  *
942  * addrs is a pointer to an array of one or more socket addresses. Each
943  * address is contained in its appropriate structure (i.e. struct
944  * sockaddr_in or struct sockaddr_in6) the family of the address type
945  * must be used to distinguish the address length (note that this
946  * representation is termed a "packed array" of addresses). The caller
947  * specifies the number of addresses in the array with addrcnt.
948  *
949  * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
950  * -1, and sets errno to the appropriate error code.
951  *
952  * For SCTP, the port given in each socket address must be the same, or
953  * sctp_bindx() will fail, setting errno to EINVAL.
954  *
955  * The flags parameter is formed from the bitwise OR of zero or more of
956  * the following currently defined flags:
957  *
958  * SCTP_BINDX_ADD_ADDR
959  *
960  * SCTP_BINDX_REM_ADDR
961  *
962  * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
963  * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
964  * addresses from the association. The two flags are mutually exclusive;
965  * if both are given, sctp_bindx() will fail with EINVAL. A caller may
966  * not remove all addresses from an association; sctp_bindx() will
967  * reject such an attempt with EINVAL.
968  *
969  * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
970  * additional addresses with an endpoint after calling bind().  Or use
971  * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
972  * socket is associated with so that no new association accepted will be
973  * associated with those addresses. If the endpoint supports dynamic
974  * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
975  * endpoint to send the appropriate message to the peer to change the
976  * peers address lists.
977  *
978  * Adding and removing addresses from a connected association is
979  * optional functionality. Implementations that do not support this
980  * functionality should return EOPNOTSUPP.
981  *
982  * Basically do nothing but copying the addresses from user to kernel
983  * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
984  * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
985  * from userspace.
986  *
987  * On exit there is no need to do sockfd_put(), sys_setsockopt() does
988  * it.
989  *
990  * sk        The sk of the socket
991  * addrs     The pointer to the addresses in user land
992  * addrssize Size of the addrs buffer
993  * op        Operation to perform (add or remove, see the flags of
994  *           sctp_bindx)
995  *
996  * Returns 0 if ok, <0 errno code on error.
997  */
998 static int sctp_setsockopt_bindx(struct sock *sk,
999                                  struct sockaddr __user *addrs,
1000                                  int addrs_size, int op)
1001 {
1002         struct sockaddr *kaddrs;
1003         int err;
1004         int addrcnt = 0;
1005         int walk_size = 0;
1006         struct sockaddr *sa_addr;
1007         void *addr_buf;
1008         struct sctp_af *af;
1009
1010         pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
1011                  __func__, sk, addrs, addrs_size, op);
1012
1013         if (unlikely(addrs_size <= 0))
1014                 return -EINVAL;
1015
1016         kaddrs = vmemdup_user(addrs, addrs_size);
1017         if (unlikely(IS_ERR(kaddrs)))
1018                 return PTR_ERR(kaddrs);
1019
1020         /* Walk through the addrs buffer and count the number of addresses. */
1021         addr_buf = kaddrs;
1022         while (walk_size < addrs_size) {
1023                 if (walk_size + sizeof(sa_family_t) > addrs_size) {
1024                         kvfree(kaddrs);
1025                         return -EINVAL;
1026                 }
1027
1028                 sa_addr = addr_buf;
1029                 af = sctp_get_af_specific(sa_addr->sa_family);
1030
1031                 /* If the address family is not supported or if this address
1032                  * causes the address buffer to overflow return EINVAL.
1033                  */
1034                 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1035                         kvfree(kaddrs);
1036                         return -EINVAL;
1037                 }
1038                 addrcnt++;
1039                 addr_buf += af->sockaddr_len;
1040                 walk_size += af->sockaddr_len;
1041         }
1042
1043         /* Do the work. */
1044         switch (op) {
1045         case SCTP_BINDX_ADD_ADDR:
1046                 /* Allow security module to validate bindx addresses. */
1047                 err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_BINDX_ADD,
1048                                                  (struct sockaddr *)kaddrs,
1049                                                  addrs_size);
1050                 if (err)
1051                         goto out;
1052                 err = sctp_bindx_add(sk, kaddrs, addrcnt);
1053                 if (err)
1054                         goto out;
1055                 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
1056                 break;
1057
1058         case SCTP_BINDX_REM_ADDR:
1059                 err = sctp_bindx_rem(sk, kaddrs, addrcnt);
1060                 if (err)
1061                         goto out;
1062                 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
1063                 break;
1064
1065         default:
1066                 err = -EINVAL;
1067                 break;
1068         }
1069
1070 out:
1071         kvfree(kaddrs);
1072
1073         return err;
1074 }
1075
1076 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1077  *
1078  * Common routine for handling connect() and sctp_connectx().
1079  * Connect will come in with just a single address.
1080  */
1081 static int __sctp_connect(struct sock *sk,
1082                           struct sockaddr *kaddrs,
1083                           int addrs_size,
1084                           sctp_assoc_t *assoc_id)
1085 {
1086         struct net *net = sock_net(sk);
1087         struct sctp_sock *sp;
1088         struct sctp_endpoint *ep;
1089         struct sctp_association *asoc = NULL;
1090         struct sctp_association *asoc2;
1091         struct sctp_transport *transport;
1092         union sctp_addr to;
1093         enum sctp_scope scope;
1094         long timeo;
1095         int err = 0;
1096         int addrcnt = 0;
1097         int walk_size = 0;
1098         union sctp_addr *sa_addr = NULL;
1099         void *addr_buf;
1100         unsigned short port;
1101         unsigned int f_flags = 0;
1102
1103         sp = sctp_sk(sk);
1104         ep = sp->ep;
1105
1106         /* connect() cannot be done on a socket that is already in ESTABLISHED
1107          * state - UDP-style peeled off socket or a TCP-style socket that
1108          * is already connected.
1109          * It cannot be done even on a TCP-style listening socket.
1110          */
1111         if (sctp_sstate(sk, ESTABLISHED) || sctp_sstate(sk, CLOSING) ||
1112             (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
1113                 err = -EISCONN;
1114                 goto out_free;
1115         }
1116
1117         /* Walk through the addrs buffer and count the number of addresses. */
1118         addr_buf = kaddrs;
1119         while (walk_size < addrs_size) {
1120                 struct sctp_af *af;
1121
1122                 if (walk_size + sizeof(sa_family_t) > addrs_size) {
1123                         err = -EINVAL;
1124                         goto out_free;
1125                 }
1126
1127                 sa_addr = addr_buf;
1128                 af = sctp_get_af_specific(sa_addr->sa.sa_family);
1129
1130                 /* If the address family is not supported or if this address
1131                  * causes the address buffer to overflow return EINVAL.
1132                  */
1133                 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1134                         err = -EINVAL;
1135                         goto out_free;
1136                 }
1137
1138                 port = ntohs(sa_addr->v4.sin_port);
1139
1140                 /* Save current address so we can work with it */
1141                 memcpy(&to, sa_addr, af->sockaddr_len);
1142
1143                 err = sctp_verify_addr(sk, &to, af->sockaddr_len);
1144                 if (err)
1145                         goto out_free;
1146
1147                 /* Make sure the destination port is correctly set
1148                  * in all addresses.
1149                  */
1150                 if (asoc && asoc->peer.port && asoc->peer.port != port) {
1151                         err = -EINVAL;
1152                         goto out_free;
1153                 }
1154
1155                 /* Check if there already is a matching association on the
1156                  * endpoint (other than the one created here).
1157                  */
1158                 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1159                 if (asoc2 && asoc2 != asoc) {
1160                         if (asoc2->state >= SCTP_STATE_ESTABLISHED)
1161                                 err = -EISCONN;
1162                         else
1163                                 err = -EALREADY;
1164                         goto out_free;
1165                 }
1166
1167                 /* If we could not find a matching association on the endpoint,
1168                  * make sure that there is no peeled-off association matching
1169                  * the peer address even on another socket.
1170                  */
1171                 if (sctp_endpoint_is_peeled_off(ep, &to)) {
1172                         err = -EADDRNOTAVAIL;
1173                         goto out_free;
1174                 }
1175
1176                 if (!asoc) {
1177                         /* If a bind() or sctp_bindx() is not called prior to
1178                          * an sctp_connectx() call, the system picks an
1179                          * ephemeral port and will choose an address set
1180                          * equivalent to binding with a wildcard address.
1181                          */
1182                         if (!ep->base.bind_addr.port) {
1183                                 if (sctp_autobind(sk)) {
1184                                         err = -EAGAIN;
1185                                         goto out_free;
1186                                 }
1187                         } else {
1188                                 /*
1189                                  * If an unprivileged user inherits a 1-many
1190                                  * style socket with open associations on a
1191                                  * privileged port, it MAY be permitted to
1192                                  * accept new associations, but it SHOULD NOT
1193                                  * be permitted to open new associations.
1194                                  */
1195                                 if (ep->base.bind_addr.port <
1196                                     inet_prot_sock(net) &&
1197                                     !ns_capable(net->user_ns,
1198                                     CAP_NET_BIND_SERVICE)) {
1199                                         err = -EACCES;
1200                                         goto out_free;
1201                                 }
1202                         }
1203
1204                         scope = sctp_scope(&to);
1205                         asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1206                         if (!asoc) {
1207                                 err = -ENOMEM;
1208                                 goto out_free;
1209                         }
1210
1211                         err = sctp_assoc_set_bind_addr_from_ep(asoc, scope,
1212                                                               GFP_KERNEL);
1213                         if (err < 0) {
1214                                 goto out_free;
1215                         }
1216
1217                 }
1218
1219                 /* Prime the peer's transport structures.  */
1220                 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
1221                                                 SCTP_UNKNOWN);
1222                 if (!transport) {
1223                         err = -ENOMEM;
1224                         goto out_free;
1225                 }
1226
1227                 addrcnt++;
1228                 addr_buf += af->sockaddr_len;
1229                 walk_size += af->sockaddr_len;
1230         }
1231
1232         /* In case the user of sctp_connectx() wants an association
1233          * id back, assign one now.
1234          */
1235         if (assoc_id) {
1236                 err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1237                 if (err < 0)
1238                         goto out_free;
1239         }
1240
1241         err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1242         if (err < 0) {
1243                 goto out_free;
1244         }
1245
1246         /* Initialize sk's dport and daddr for getpeername() */
1247         inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1248         sp->pf->to_sk_daddr(sa_addr, sk);
1249         sk->sk_err = 0;
1250
1251         /* in-kernel sockets don't generally have a file allocated to them
1252          * if all they do is call sock_create_kern().
1253          */
1254         if (sk->sk_socket->file)
1255                 f_flags = sk->sk_socket->file->f_flags;
1256
1257         timeo = sock_sndtimeo(sk, f_flags & O_NONBLOCK);
1258
1259         if (assoc_id)
1260                 *assoc_id = asoc->assoc_id;
1261
1262         err = sctp_wait_for_connect(asoc, &timeo);
1263         /* Note: the asoc may be freed after the return of
1264          * sctp_wait_for_connect.
1265          */
1266
1267         /* Don't free association on exit. */
1268         asoc = NULL;
1269
1270 out_free:
1271         pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1272                  __func__, asoc, kaddrs, err);
1273
1274         if (asoc) {
1275                 /* sctp_primitive_ASSOCIATE may have added this association
1276                  * To the hash table, try to unhash it, just in case, its a noop
1277                  * if it wasn't hashed so we're safe
1278                  */
1279                 sctp_association_free(asoc);
1280         }
1281         return err;
1282 }
1283
1284 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1285  *
1286  * API 8.9
1287  * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1288  *                      sctp_assoc_t *asoc);
1289  *
1290  * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1291  * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1292  * or IPv6 addresses.
1293  *
1294  * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1295  * Section 3.1.2 for this usage.
1296  *
1297  * addrs is a pointer to an array of one or more socket addresses. Each
1298  * address is contained in its appropriate structure (i.e. struct
1299  * sockaddr_in or struct sockaddr_in6) the family of the address type
1300  * must be used to distengish the address length (note that this
1301  * representation is termed a "packed array" of addresses). The caller
1302  * specifies the number of addresses in the array with addrcnt.
1303  *
1304  * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1305  * the association id of the new association.  On failure, sctp_connectx()
1306  * returns -1, and sets errno to the appropriate error code.  The assoc_id
1307  * is not touched by the kernel.
1308  *
1309  * For SCTP, the port given in each socket address must be the same, or
1310  * sctp_connectx() will fail, setting errno to EINVAL.
1311  *
1312  * An application can use sctp_connectx to initiate an association with
1313  * an endpoint that is multi-homed.  Much like sctp_bindx() this call
1314  * allows a caller to specify multiple addresses at which a peer can be
1315  * reached.  The way the SCTP stack uses the list of addresses to set up
1316  * the association is implementation dependent.  This function only
1317  * specifies that the stack will try to make use of all the addresses in
1318  * the list when needed.
1319  *
1320  * Note that the list of addresses passed in is only used for setting up
1321  * the association.  It does not necessarily equal the set of addresses
1322  * the peer uses for the resulting association.  If the caller wants to
1323  * find out the set of peer addresses, it must use sctp_getpaddrs() to
1324  * retrieve them after the association has been set up.
1325  *
1326  * Basically do nothing but copying the addresses from user to kernel
1327  * land and invoking either sctp_connectx(). This is used for tunneling
1328  * the sctp_connectx() request through sctp_setsockopt() from userspace.
1329  *
1330  * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1331  * it.
1332  *
1333  * sk        The sk of the socket
1334  * addrs     The pointer to the addresses in user land
1335  * addrssize Size of the addrs buffer
1336  *
1337  * Returns >=0 if ok, <0 errno code on error.
1338  */
1339 static int __sctp_setsockopt_connectx(struct sock *sk,
1340                                       struct sockaddr __user *addrs,
1341                                       int addrs_size,
1342                                       sctp_assoc_t *assoc_id)
1343 {
1344         struct sockaddr *kaddrs;
1345         int err = 0;
1346
1347         pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1348                  __func__, sk, addrs, addrs_size);
1349
1350         if (unlikely(addrs_size <= 0))
1351                 return -EINVAL;
1352
1353         kaddrs = vmemdup_user(addrs, addrs_size);
1354         if (unlikely(IS_ERR(kaddrs)))
1355                 return PTR_ERR(kaddrs);
1356
1357         /* Allow security module to validate connectx addresses. */
1358         err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_CONNECTX,
1359                                          (struct sockaddr *)kaddrs,
1360                                           addrs_size);
1361         if (err)
1362                 goto out_free;
1363
1364         err = __sctp_connect(sk, kaddrs, addrs_size, assoc_id);
1365
1366 out_free:
1367         kvfree(kaddrs);
1368
1369         return err;
1370 }
1371
1372 /*
1373  * This is an older interface.  It's kept for backward compatibility
1374  * to the option that doesn't provide association id.
1375  */
1376 static int sctp_setsockopt_connectx_old(struct sock *sk,
1377                                         struct sockaddr __user *addrs,
1378                                         int addrs_size)
1379 {
1380         return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL);
1381 }
1382
1383 /*
1384  * New interface for the API.  The since the API is done with a socket
1385  * option, to make it simple we feed back the association id is as a return
1386  * indication to the call.  Error is always negative and association id is
1387  * always positive.
1388  */
1389 static int sctp_setsockopt_connectx(struct sock *sk,
1390                                     struct sockaddr __user *addrs,
1391                                     int addrs_size)
1392 {
1393         sctp_assoc_t assoc_id = 0;
1394         int err = 0;
1395
1396         err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id);
1397
1398         if (err)
1399                 return err;
1400         else
1401                 return assoc_id;
1402 }
1403
1404 /*
1405  * New (hopefully final) interface for the API.
1406  * We use the sctp_getaddrs_old structure so that use-space library
1407  * can avoid any unnecessary allocations. The only different part
1408  * is that we store the actual length of the address buffer into the
1409  * addrs_num structure member. That way we can re-use the existing
1410  * code.
1411  */
1412 #ifdef CONFIG_COMPAT
1413 struct compat_sctp_getaddrs_old {
1414         sctp_assoc_t    assoc_id;
1415         s32             addr_num;
1416         compat_uptr_t   addrs;          /* struct sockaddr * */
1417 };
1418 #endif
1419
1420 static int sctp_getsockopt_connectx3(struct sock *sk, int len,
1421                                      char __user *optval,
1422                                      int __user *optlen)
1423 {
1424         struct sctp_getaddrs_old param;
1425         sctp_assoc_t assoc_id = 0;
1426         int err = 0;
1427
1428 #ifdef CONFIG_COMPAT
1429         if (in_compat_syscall()) {
1430                 struct compat_sctp_getaddrs_old param32;
1431
1432                 if (len < sizeof(param32))
1433                         return -EINVAL;
1434                 if (copy_from_user(&param32, optval, sizeof(param32)))
1435                         return -EFAULT;
1436
1437                 param.assoc_id = param32.assoc_id;
1438                 param.addr_num = param32.addr_num;
1439                 param.addrs = compat_ptr(param32.addrs);
1440         } else
1441 #endif
1442         {
1443                 if (len < sizeof(param))
1444                         return -EINVAL;
1445                 if (copy_from_user(&param, optval, sizeof(param)))
1446                         return -EFAULT;
1447         }
1448
1449         err = __sctp_setsockopt_connectx(sk, (struct sockaddr __user *)
1450                                          param.addrs, param.addr_num,
1451                                          &assoc_id);
1452         if (err == 0 || err == -EINPROGRESS) {
1453                 if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1454                         return -EFAULT;
1455                 if (put_user(sizeof(assoc_id), optlen))
1456                         return -EFAULT;
1457         }
1458
1459         return err;
1460 }
1461
1462 /* API 3.1.4 close() - UDP Style Syntax
1463  * Applications use close() to perform graceful shutdown (as described in
1464  * Section 10.1 of [SCTP]) on ALL the associations currently represented
1465  * by a UDP-style socket.
1466  *
1467  * The syntax is
1468  *
1469  *   ret = close(int sd);
1470  *
1471  *   sd      - the socket descriptor of the associations to be closed.
1472  *
1473  * To gracefully shutdown a specific association represented by the
1474  * UDP-style socket, an application should use the sendmsg() call,
1475  * passing no user data, but including the appropriate flag in the
1476  * ancillary data (see Section xxxx).
1477  *
1478  * If sd in the close() call is a branched-off socket representing only
1479  * one association, the shutdown is performed on that association only.
1480  *
1481  * 4.1.6 close() - TCP Style Syntax
1482  *
1483  * Applications use close() to gracefully close down an association.
1484  *
1485  * The syntax is:
1486  *
1487  *    int close(int sd);
1488  *
1489  *      sd      - the socket descriptor of the association to be closed.
1490  *
1491  * After an application calls close() on a socket descriptor, no further
1492  * socket operations will succeed on that descriptor.
1493  *
1494  * API 7.1.4 SO_LINGER
1495  *
1496  * An application using the TCP-style socket can use this option to
1497  * perform the SCTP ABORT primitive.  The linger option structure is:
1498  *
1499  *  struct  linger {
1500  *     int     l_onoff;                // option on/off
1501  *     int     l_linger;               // linger time
1502  * };
1503  *
1504  * To enable the option, set l_onoff to 1.  If the l_linger value is set
1505  * to 0, calling close() is the same as the ABORT primitive.  If the
1506  * value is set to a negative value, the setsockopt() call will return
1507  * an error.  If the value is set to a positive value linger_time, the
1508  * close() can be blocked for at most linger_time ms.  If the graceful
1509  * shutdown phase does not finish during this period, close() will
1510  * return but the graceful shutdown phase continues in the system.
1511  */
1512 static void sctp_close(struct sock *sk, long timeout)
1513 {
1514         struct net *net = sock_net(sk);
1515         struct sctp_endpoint *ep;
1516         struct sctp_association *asoc;
1517         struct list_head *pos, *temp;
1518         unsigned int data_was_unread;
1519
1520         pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout);
1521
1522         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1523         sk->sk_shutdown = SHUTDOWN_MASK;
1524         inet_sk_set_state(sk, SCTP_SS_CLOSING);
1525
1526         ep = sctp_sk(sk)->ep;
1527
1528         /* Clean up any skbs sitting on the receive queue.  */
1529         data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1530         data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1531
1532         /* Walk all associations on an endpoint.  */
1533         list_for_each_safe(pos, temp, &ep->asocs) {
1534                 asoc = list_entry(pos, struct sctp_association, asocs);
1535
1536                 if (sctp_style(sk, TCP)) {
1537                         /* A closed association can still be in the list if
1538                          * it belongs to a TCP-style listening socket that is
1539                          * not yet accepted. If so, free it. If not, send an
1540                          * ABORT or SHUTDOWN based on the linger options.
1541                          */
1542                         if (sctp_state(asoc, CLOSED)) {
1543                                 sctp_association_free(asoc);
1544                                 continue;
1545                         }
1546                 }
1547
1548                 if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1549                     !skb_queue_empty(&asoc->ulpq.reasm) ||
1550                     !skb_queue_empty(&asoc->ulpq.reasm_uo) ||
1551                     (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1552                         struct sctp_chunk *chunk;
1553
1554                         chunk = sctp_make_abort_user(asoc, NULL, 0);
1555                         sctp_primitive_ABORT(net, asoc, chunk);
1556                 } else
1557                         sctp_primitive_SHUTDOWN(net, asoc, NULL);
1558         }
1559
1560         /* On a TCP-style socket, block for at most linger_time if set. */
1561         if (sctp_style(sk, TCP) && timeout)
1562                 sctp_wait_for_close(sk, timeout);
1563
1564         /* This will run the backlog queue.  */
1565         release_sock(sk);
1566
1567         /* Supposedly, no process has access to the socket, but
1568          * the net layers still may.
1569          * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1570          * held and that should be grabbed before socket lock.
1571          */
1572         spin_lock_bh(&net->sctp.addr_wq_lock);
1573         bh_lock_sock_nested(sk);
1574
1575         /* Hold the sock, since sk_common_release() will put sock_put()
1576          * and we have just a little more cleanup.
1577          */
1578         sock_hold(sk);
1579         sk_common_release(sk);
1580
1581         bh_unlock_sock(sk);
1582         spin_unlock_bh(&net->sctp.addr_wq_lock);
1583
1584         sock_put(sk);
1585
1586         SCTP_DBG_OBJCNT_DEC(sock);
1587 }
1588
1589 /* Handle EPIPE error. */
1590 static int sctp_error(struct sock *sk, int flags, int err)
1591 {
1592         if (err == -EPIPE)
1593                 err = sock_error(sk) ? : -EPIPE;
1594         if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1595                 send_sig(SIGPIPE, current, 0);
1596         return err;
1597 }
1598
1599 /* API 3.1.3 sendmsg() - UDP Style Syntax
1600  *
1601  * An application uses sendmsg() and recvmsg() calls to transmit data to
1602  * and receive data from its peer.
1603  *
1604  *  ssize_t sendmsg(int socket, const struct msghdr *message,
1605  *                  int flags);
1606  *
1607  *  socket  - the socket descriptor of the endpoint.
1608  *  message - pointer to the msghdr structure which contains a single
1609  *            user message and possibly some ancillary data.
1610  *
1611  *            See Section 5 for complete description of the data
1612  *            structures.
1613  *
1614  *  flags   - flags sent or received with the user message, see Section
1615  *            5 for complete description of the flags.
1616  *
1617  * Note:  This function could use a rewrite especially when explicit
1618  * connect support comes in.
1619  */
1620 /* BUG:  We do not implement the equivalent of sk_stream_wait_memory(). */
1621
1622 static int sctp_msghdr_parse(const struct msghdr *msg,
1623                              struct sctp_cmsgs *cmsgs);
1624
1625 static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
1626 {
1627         struct net *net = sock_net(sk);
1628         struct sctp_sock *sp;
1629         struct sctp_endpoint *ep;
1630         struct sctp_association *new_asoc = NULL, *asoc = NULL;
1631         struct sctp_transport *transport, *chunk_tp;
1632         struct sctp_chunk *chunk;
1633         union sctp_addr to;
1634         struct sctp_af *af;
1635         struct sockaddr *msg_name = NULL;
1636         struct sctp_sndrcvinfo default_sinfo;
1637         struct sctp_sndrcvinfo *sinfo;
1638         struct sctp_initmsg *sinit;
1639         sctp_assoc_t associd = 0;
1640         struct sctp_cmsgs cmsgs = { NULL };
1641         enum sctp_scope scope;
1642         bool fill_sinfo_ttl = false, wait_connect = false;
1643         struct sctp_datamsg *datamsg;
1644         int msg_flags = msg->msg_flags;
1645         __u16 sinfo_flags = 0;
1646         long timeo;
1647         int err;
1648
1649         err = 0;
1650         sp = sctp_sk(sk);
1651         ep = sp->ep;
1652
1653         pr_debug("%s: sk:%p, msg:%p, msg_len:%zu ep:%p\n", __func__, sk,
1654                  msg, msg_len, ep);
1655
1656         /* We cannot send a message over a TCP-style listening socket. */
1657         if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
1658                 err = -EPIPE;
1659                 goto out_nounlock;
1660         }
1661
1662         /* Parse out the SCTP CMSGs.  */
1663         err = sctp_msghdr_parse(msg, &cmsgs);
1664         if (err) {
1665                 pr_debug("%s: msghdr parse err:%x\n", __func__, err);
1666                 goto out_nounlock;
1667         }
1668
1669         /* Fetch the destination address for this packet.  This
1670          * address only selects the association--it is not necessarily
1671          * the address we will send to.
1672          * For a peeled-off socket, msg_name is ignored.
1673          */
1674         if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1675                 int msg_namelen = msg->msg_namelen;
1676
1677                 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
1678                                        msg_namelen);
1679                 if (err)
1680                         return err;
1681
1682                 if (msg_namelen > sizeof(to))
1683                         msg_namelen = sizeof(to);
1684                 memcpy(&to, msg->msg_name, msg_namelen);
1685                 msg_name = msg->msg_name;
1686         }
1687
1688         sinit = cmsgs.init;
1689         if (cmsgs.sinfo != NULL) {
1690                 memset(&default_sinfo, 0, sizeof(default_sinfo));
1691                 default_sinfo.sinfo_stream = cmsgs.sinfo->snd_sid;
1692                 default_sinfo.sinfo_flags = cmsgs.sinfo->snd_flags;
1693                 default_sinfo.sinfo_ppid = cmsgs.sinfo->snd_ppid;
1694                 default_sinfo.sinfo_context = cmsgs.sinfo->snd_context;
1695                 default_sinfo.sinfo_assoc_id = cmsgs.sinfo->snd_assoc_id;
1696
1697                 sinfo = &default_sinfo;
1698                 fill_sinfo_ttl = true;
1699         } else {
1700                 sinfo = cmsgs.srinfo;
1701         }
1702         /* Did the user specify SNDINFO/SNDRCVINFO? */
1703         if (sinfo) {
1704                 sinfo_flags = sinfo->sinfo_flags;
1705                 associd = sinfo->sinfo_assoc_id;
1706         }
1707
1708         pr_debug("%s: msg_len:%zu, sinfo_flags:0x%x\n", __func__,
1709                  msg_len, sinfo_flags);
1710
1711         /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1712         if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) {
1713                 err = -EINVAL;
1714                 goto out_nounlock;
1715         }
1716
1717         /* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1718          * length messages when SCTP_EOF|SCTP_ABORT is not set.
1719          * If SCTP_ABORT is set, the message length could be non zero with
1720          * the msg_iov set to the user abort reason.
1721          */
1722         if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) ||
1723             (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) {
1724                 err = -EINVAL;
1725                 goto out_nounlock;
1726         }
1727
1728         /* If SCTP_ADDR_OVER is set, there must be an address
1729          * specified in msg_name.
1730          */
1731         if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {
1732                 err = -EINVAL;
1733                 goto out_nounlock;
1734         }
1735
1736         transport = NULL;
1737
1738         pr_debug("%s: about to look up association\n", __func__);
1739
1740         lock_sock(sk);
1741
1742         /* If a msg_name has been specified, assume this is to be used.  */
1743         if (msg_name) {
1744                 /* Look for a matching association on the endpoint. */
1745                 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1746
1747                 /* If we could not find a matching association on the
1748                  * endpoint, make sure that it is not a TCP-style
1749                  * socket that already has an association or there is
1750                  * no peeled-off association on another socket.
1751                  */
1752                 if (!asoc &&
1753                     ((sctp_style(sk, TCP) &&
1754                       (sctp_sstate(sk, ESTABLISHED) ||
1755                        sctp_sstate(sk, CLOSING))) ||
1756                      sctp_endpoint_is_peeled_off(ep, &to))) {
1757                         err = -EADDRNOTAVAIL;
1758                         goto out_unlock;
1759                 }
1760         } else {
1761                 asoc = sctp_id2assoc(sk, associd);
1762                 if (!asoc) {
1763                         err = -EPIPE;
1764                         goto out_unlock;
1765                 }
1766         }
1767
1768         if (asoc) {
1769                 pr_debug("%s: just looked up association:%p\n", __func__, asoc);
1770
1771                 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1772                  * socket that has an association in CLOSED state. This can
1773                  * happen when an accepted socket has an association that is
1774                  * already CLOSED.
1775                  */
1776                 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
1777                         err = -EPIPE;
1778                         goto out_unlock;
1779                 }
1780
1781                 if (sinfo_flags & SCTP_EOF) {
1782                         pr_debug("%s: shutting down association:%p\n",
1783                                  __func__, asoc);
1784
1785                         sctp_primitive_SHUTDOWN(net, asoc, NULL);
1786                         err = 0;
1787                         goto out_unlock;
1788                 }
1789                 if (sinfo_flags & SCTP_ABORT) {
1790
1791                         chunk = sctp_make_abort_user(asoc, msg, msg_len);
1792                         if (!chunk) {
1793                                 err = -ENOMEM;
1794                                 goto out_unlock;
1795                         }
1796
1797                         pr_debug("%s: aborting association:%p\n",
1798                                  __func__, asoc);
1799
1800                         sctp_primitive_ABORT(net, asoc, chunk);
1801                         err = 0;
1802                         goto out_unlock;
1803                 }
1804         }
1805
1806         /* Do we need to create the association?  */
1807         if (!asoc) {
1808                 pr_debug("%s: there is no association yet\n", __func__);
1809
1810                 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) {
1811                         err = -EINVAL;
1812                         goto out_unlock;
1813                 }
1814
1815                 /* Check for invalid stream against the stream counts,
1816                  * either the default or the user specified stream counts.
1817                  */
1818                 if (sinfo) {
1819                         if (!sinit || !sinit->sinit_num_ostreams) {
1820                                 /* Check against the defaults. */
1821                                 if (sinfo->sinfo_stream >=
1822                                     sp->initmsg.sinit_num_ostreams) {
1823                                         err = -EINVAL;
1824                                         goto out_unlock;
1825                                 }
1826                         } else {
1827                                 /* Check against the requested.  */
1828                                 if (sinfo->sinfo_stream >=
1829                                     sinit->sinit_num_ostreams) {
1830                                         err = -EINVAL;
1831                                         goto out_unlock;
1832                                 }
1833                         }
1834                 }
1835
1836                 /*
1837                  * API 3.1.2 bind() - UDP Style Syntax
1838                  * If a bind() or sctp_bindx() is not called prior to a
1839                  * sendmsg() call that initiates a new association, the
1840                  * system picks an ephemeral port and will choose an address
1841                  * set equivalent to binding with a wildcard address.
1842                  */
1843                 if (!ep->base.bind_addr.port) {
1844                         if (sctp_autobind(sk)) {
1845                                 err = -EAGAIN;
1846                                 goto out_unlock;
1847                         }
1848                 } else {
1849                         /*
1850                          * If an unprivileged user inherits a one-to-many
1851                          * style socket with open associations on a privileged
1852                          * port, it MAY be permitted to accept new associations,
1853                          * but it SHOULD NOT be permitted to open new
1854                          * associations.
1855                          */
1856                         if (ep->base.bind_addr.port < inet_prot_sock(net) &&
1857                             !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE)) {
1858                                 err = -EACCES;
1859                                 goto out_unlock;
1860                         }
1861                 }
1862
1863                 scope = sctp_scope(&to);
1864
1865                 /* Label connection socket for first association 1-to-many
1866                  * style for client sequence socket()->sendmsg(). This
1867                  * needs to be done before sctp_assoc_add_peer() as that will
1868                  * set up the initial packet that needs to account for any
1869                  * security ip options (CIPSO/CALIPSO) added to the packet.
1870                  */
1871                 af = sctp_get_af_specific(to.sa.sa_family);
1872                 if (!af) {
1873                         err = -EINVAL;
1874                         goto out_unlock;
1875                 }
1876                 err = security_sctp_bind_connect(sk, SCTP_SENDMSG_CONNECT,
1877                                                  (struct sockaddr *)&to,
1878                                                  af->sockaddr_len);
1879                 if (err < 0)
1880                         goto out_unlock;
1881
1882                 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1883                 if (!new_asoc) {
1884                         err = -ENOMEM;
1885                         goto out_unlock;
1886                 }
1887                 asoc = new_asoc;
1888                 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
1889                 if (err < 0) {
1890                         err = -ENOMEM;
1891                         goto out_free;
1892                 }
1893
1894                 /* If the SCTP_INIT ancillary data is specified, set all
1895                  * the association init values accordingly.
1896                  */
1897                 if (sinit) {
1898                         if (sinit->sinit_num_ostreams) {
1899                                 __u16 outcnt = sinit->sinit_num_ostreams;
1900
1901                                 asoc->c.sinit_num_ostreams = outcnt;
1902                                 /* outcnt has been changed, so re-init stream */
1903                                 err = sctp_stream_init(&asoc->stream, outcnt, 0,
1904                                                        GFP_KERNEL);
1905                                 if (err)
1906                                         goto out_free;
1907                         }
1908                         if (sinit->sinit_max_instreams) {
1909                                 asoc->c.sinit_max_instreams =
1910                                         sinit->sinit_max_instreams;
1911                         }
1912                         if (sinit->sinit_max_attempts) {
1913                                 asoc->max_init_attempts
1914                                         = sinit->sinit_max_attempts;
1915                         }
1916                         if (sinit->sinit_max_init_timeo) {
1917                                 asoc->max_init_timeo =
1918                                  msecs_to_jiffies(sinit->sinit_max_init_timeo);
1919                         }
1920                 }
1921
1922                 /* Prime the peer's transport structures.  */
1923                 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
1924                 if (!transport) {
1925                         err = -ENOMEM;
1926                         goto out_free;
1927                 }
1928         }
1929
1930         /* ASSERT: we have a valid association at this point.  */
1931         pr_debug("%s: we have a valid association\n", __func__);
1932
1933         if (!sinfo) {
1934                 /* If the user didn't specify SNDINFO/SNDRCVINFO, make up
1935                  * one with some defaults.
1936                  */
1937                 memset(&default_sinfo, 0, sizeof(default_sinfo));
1938                 default_sinfo.sinfo_stream = asoc->default_stream;
1939                 default_sinfo.sinfo_flags = asoc->default_flags;
1940                 default_sinfo.sinfo_ppid = asoc->default_ppid;
1941                 default_sinfo.sinfo_context = asoc->default_context;
1942                 default_sinfo.sinfo_timetolive = asoc->default_timetolive;
1943                 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
1944
1945                 sinfo = &default_sinfo;
1946         } else if (fill_sinfo_ttl) {
1947                 /* In case SNDINFO was specified, we still need to fill
1948                  * it with a default ttl from the assoc here.
1949                  */
1950                 sinfo->sinfo_timetolive = asoc->default_timetolive;
1951         }
1952
1953         /* API 7.1.7, the sndbuf size per association bounds the
1954          * maximum size of data that can be sent in a single send call.
1955          */
1956         if (msg_len > sk->sk_sndbuf) {
1957                 err = -EMSGSIZE;
1958                 goto out_free;
1959         }
1960
1961         if (asoc->pmtu_pending)
1962                 sctp_assoc_pending_pmtu(asoc);
1963
1964         /* If fragmentation is disabled and the message length exceeds the
1965          * association fragmentation point, return EMSGSIZE.  The I-D
1966          * does not specify what this error is, but this looks like
1967          * a great fit.
1968          */
1969         if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
1970                 err = -EMSGSIZE;
1971                 goto out_free;
1972         }
1973
1974         /* Check for invalid stream. */
1975         if (sinfo->sinfo_stream >= asoc->stream.outcnt) {
1976                 err = -EINVAL;
1977                 goto out_free;
1978         }
1979
1980         /* Allocate sctp_stream_out_ext if not already done */
1981         if (unlikely(!asoc->stream.out[sinfo->sinfo_stream].ext)) {
1982                 err = sctp_stream_init_ext(&asoc->stream, sinfo->sinfo_stream);
1983                 if (err)
1984                         goto out_free;
1985         }
1986
1987         if (sctp_wspace(asoc) < msg_len)
1988                 sctp_prsctp_prune(asoc, sinfo, msg_len - sctp_wspace(asoc));
1989
1990         timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1991         if (!sctp_wspace(asoc)) {
1992                 /* sk can be changed by peel off when waiting for buf. */
1993                 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1994                 if (err) {
1995                         if (err == -ESRCH) {
1996                                 /* asoc is already dead. */
1997                                 new_asoc = NULL;
1998                                 err = -EPIPE;
1999                         }
2000                         goto out_free;
2001                 }
2002         }
2003
2004         /* If an address is passed with the sendto/sendmsg call, it is used
2005          * to override the primary destination address in the TCP model, or
2006          * when SCTP_ADDR_OVER flag is set in the UDP model.
2007          */
2008         if ((sctp_style(sk, TCP) && msg_name) ||
2009             (sinfo_flags & SCTP_ADDR_OVER)) {
2010                 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
2011                 if (!chunk_tp) {
2012                         err = -EINVAL;
2013                         goto out_free;
2014                 }
2015         } else
2016                 chunk_tp = NULL;
2017
2018         /* Auto-connect, if we aren't connected already. */
2019         if (sctp_state(asoc, CLOSED)) {
2020                 err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
2021                 if (err < 0)
2022                         goto out_free;
2023
2024                 /* If stream interleave is enabled, wait_connect has to be
2025                  * done earlier than data enqueue, as it needs to make data
2026                  * or idata according to asoc->intl_enable which is set
2027                  * after connection is done.
2028                  */
2029                 if (sctp_sk(asoc->base.sk)->strm_interleave) {
2030                         timeo = sock_sndtimeo(sk, 0);
2031                         err = sctp_wait_for_connect(asoc, &timeo);
2032                         if (err)
2033                                 goto out_unlock;
2034                 } else {
2035                         wait_connect = true;
2036                 }
2037
2038                 pr_debug("%s: we associated primitively\n", __func__);
2039         }
2040
2041         /* Break the message into multiple chunks of maximum size. */
2042         datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
2043         if (IS_ERR(datamsg)) {
2044                 err = PTR_ERR(datamsg);
2045                 goto out_free;
2046         }
2047         asoc->force_delay = !!(msg->msg_flags & MSG_MORE);
2048
2049         /* Now send the (possibly) fragmented message. */
2050         list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
2051                 sctp_chunk_hold(chunk);
2052
2053                 /* Do accounting for the write space.  */
2054                 sctp_set_owner_w(chunk);
2055
2056                 chunk->transport = chunk_tp;
2057         }
2058
2059         /* Send it to the lower layers.  Note:  all chunks
2060          * must either fail or succeed.   The lower layer
2061          * works that way today.  Keep it that way or this
2062          * breaks.
2063          */
2064         err = sctp_primitive_SEND(net, asoc, datamsg);
2065         /* Did the lower layer accept the chunk? */
2066         if (err) {
2067                 sctp_datamsg_free(datamsg);
2068                 goto out_free;
2069         }
2070
2071         pr_debug("%s: we sent primitively\n", __func__);
2072
2073         sctp_datamsg_put(datamsg);
2074         err = msg_len;
2075
2076         if (unlikely(wait_connect)) {
2077                 timeo = sock_sndtimeo(sk, msg_flags & MSG_DONTWAIT);
2078                 sctp_wait_for_connect(asoc, &timeo);
2079         }
2080
2081         /* If we are already past ASSOCIATE, the lower
2082          * layers are responsible for association cleanup.
2083          */
2084         goto out_unlock;
2085
2086 out_free:
2087         if (new_asoc)
2088                 sctp_association_free(asoc);
2089 out_unlock:
2090         release_sock(sk);
2091
2092 out_nounlock:
2093         return sctp_error(sk, msg_flags, err);
2094
2095 #if 0
2096 do_sock_err:
2097         if (msg_len)
2098                 err = msg_len;
2099         else
2100                 err = sock_error(sk);
2101         goto out;
2102
2103 do_interrupted:
2104         if (msg_len)
2105                 err = msg_len;
2106         goto out;
2107 #endif /* 0 */
2108 }
2109
2110 /* This is an extended version of skb_pull() that removes the data from the
2111  * start of a skb even when data is spread across the list of skb's in the
2112  * frag_list. len specifies the total amount of data that needs to be removed.
2113  * when 'len' bytes could be removed from the skb, it returns 0.
2114  * If 'len' exceeds the total skb length,  it returns the no. of bytes that
2115  * could not be removed.
2116  */
2117 static int sctp_skb_pull(struct sk_buff *skb, int len)
2118 {
2119         struct sk_buff *list;
2120         int skb_len = skb_headlen(skb);
2121         int rlen;
2122
2123         if (len <= skb_len) {
2124                 __skb_pull(skb, len);
2125                 return 0;
2126         }
2127         len -= skb_len;
2128         __skb_pull(skb, skb_len);
2129
2130         skb_walk_frags(skb, list) {
2131                 rlen = sctp_skb_pull(list, len);
2132                 skb->len -= (len-rlen);
2133                 skb->data_len -= (len-rlen);
2134
2135                 if (!rlen)
2136                         return 0;
2137
2138                 len = rlen;
2139         }
2140
2141         return len;
2142 }
2143
2144 /* API 3.1.3  recvmsg() - UDP Style Syntax
2145  *
2146  *  ssize_t recvmsg(int socket, struct msghdr *message,
2147  *                    int flags);
2148  *
2149  *  socket  - the socket descriptor of the endpoint.
2150  *  message - pointer to the msghdr structure which contains a single
2151  *            user message and possibly some ancillary data.
2152  *
2153  *            See Section 5 for complete description of the data
2154  *            structures.
2155  *
2156  *  flags   - flags sent or received with the user message, see Section
2157  *            5 for complete description of the flags.
2158  */
2159 static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
2160                         int noblock, int flags, int *addr_len)
2161 {
2162         struct sctp_ulpevent *event = NULL;
2163         struct sctp_sock *sp = sctp_sk(sk);
2164         struct sk_buff *skb, *head_skb;
2165         int copied;
2166         int err = 0;
2167         int skb_len;
2168
2169         pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2170                  "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags,
2171                  addr_len);
2172
2173         lock_sock(sk);
2174
2175         if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED) &&
2176             !sctp_sstate(sk, CLOSING) && !sctp_sstate(sk, CLOSED)) {
2177                 err = -ENOTCONN;
2178                 goto out;
2179         }
2180
2181         skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
2182         if (!skb)
2183                 goto out;
2184
2185         /* Get the total length of the skb including any skb's in the
2186          * frag_list.
2187          */
2188         skb_len = skb->len;
2189
2190         copied = skb_len;
2191         if (copied > len)
2192                 copied = len;
2193
2194         err = skb_copy_datagram_msg(skb, 0, msg, copied);
2195
2196         event = sctp_skb2event(skb);
2197
2198         if (err)
2199                 goto out_free;
2200
2201         if (event->chunk && event->chunk->head_skb)
2202                 head_skb = event->chunk->head_skb;
2203         else
2204                 head_skb = skb;
2205         sock_recv_ts_and_drops(msg, sk, head_skb);
2206         if (sctp_ulpevent_is_notification(event)) {
2207                 msg->msg_flags |= MSG_NOTIFICATION;
2208                 sp->pf->event_msgname(event, msg->msg_name, addr_len);
2209         } else {
2210                 sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len);
2211         }
2212
2213         /* Check if we allow SCTP_NXTINFO. */
2214         if (sp->recvnxtinfo)
2215                 sctp_ulpevent_read_nxtinfo(event, msg, sk);
2216         /* Check if we allow SCTP_RCVINFO. */
2217         if (sp->recvrcvinfo)
2218                 sctp_ulpevent_read_rcvinfo(event, msg);
2219         /* Check if we allow SCTP_SNDRCVINFO. */
2220         if (sp->subscribe.sctp_data_io_event)
2221                 sctp_ulpevent_read_sndrcvinfo(event, msg);
2222
2223         err = copied;
2224
2225         /* If skb's length exceeds the user's buffer, update the skb and
2226          * push it back to the receive_queue so that the next call to
2227          * recvmsg() will return the remaining data. Don't set MSG_EOR.
2228          */
2229         if (skb_len > copied) {
2230                 msg->msg_flags &= ~MSG_EOR;
2231                 if (flags & MSG_PEEK)
2232                         goto out_free;
2233                 sctp_skb_pull(skb, copied);
2234                 skb_queue_head(&sk->sk_receive_queue, skb);
2235
2236                 /* When only partial message is copied to the user, increase
2237                  * rwnd by that amount. If all the data in the skb is read,
2238                  * rwnd is updated when the event is freed.
2239                  */
2240                 if (!sctp_ulpevent_is_notification(event))
2241                         sctp_assoc_rwnd_increase(event->asoc, copied);
2242                 goto out;
2243         } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2244                    (event->msg_flags & MSG_EOR))
2245                 msg->msg_flags |= MSG_EOR;
2246         else
2247                 msg->msg_flags &= ~MSG_EOR;
2248
2249 out_free:
2250         if (flags & MSG_PEEK) {
2251                 /* Release the skb reference acquired after peeking the skb in
2252                  * sctp_skb_recv_datagram().
2253                  */
2254                 kfree_skb(skb);
2255         } else {
2256                 /* Free the event which includes releasing the reference to
2257                  * the owner of the skb, freeing the skb and updating the
2258                  * rwnd.
2259                  */
2260                 sctp_ulpevent_free(event);
2261         }
2262 out:
2263         release_sock(sk);
2264         return err;
2265 }
2266
2267 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2268  *
2269  * This option is a on/off flag.  If enabled no SCTP message
2270  * fragmentation will be performed.  Instead if a message being sent
2271  * exceeds the current PMTU size, the message will NOT be sent and
2272  * instead a error will be indicated to the user.
2273  */
2274 static int sctp_setsockopt_disable_fragments(struct sock *sk,
2275                                              char __user *optval,
2276                                              unsigned int optlen)
2277 {
2278         int val;
2279
2280         if (optlen < sizeof(int))
2281                 return -EINVAL;
2282
2283         if (get_user(val, (int __user *)optval))
2284                 return -EFAULT;
2285
2286         sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
2287
2288         return 0;
2289 }
2290
2291 static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
2292                                   unsigned int optlen)
2293 {
2294         struct sctp_association *asoc;
2295         struct sctp_ulpevent *event;
2296
2297         if (optlen > sizeof(struct sctp_event_subscribe))
2298                 return -EINVAL;
2299         if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
2300                 return -EFAULT;
2301
2302         /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2303          * if there is no data to be sent or retransmit, the stack will
2304          * immediately send up this notification.
2305          */
2306         if (sctp_ulpevent_type_enabled(SCTP_SENDER_DRY_EVENT,
2307                                        &sctp_sk(sk)->subscribe)) {
2308                 asoc = sctp_id2assoc(sk, 0);
2309
2310                 if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2311                         event = sctp_ulpevent_make_sender_dry_event(asoc,
2312                                         GFP_USER | __GFP_NOWARN);
2313                         if (!event)
2314                                 return -ENOMEM;
2315
2316                         asoc->stream.si->enqueue_event(&asoc->ulpq, event);
2317                 }
2318         }
2319
2320         return 0;
2321 }
2322
2323 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2324  *
2325  * This socket option is applicable to the UDP-style socket only.  When
2326  * set it will cause associations that are idle for more than the
2327  * specified number of seconds to automatically close.  An association
2328  * being idle is defined an association that has NOT sent or received
2329  * user data.  The special value of '0' indicates that no automatic
2330  * close of any associations should be performed.  The option expects an
2331  * integer defining the number of seconds of idle time before an
2332  * association is closed.
2333  */
2334 static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
2335                                      unsigned int optlen)
2336 {
2337         struct sctp_sock *sp = sctp_sk(sk);
2338         struct net *net = sock_net(sk);
2339
2340         /* Applicable to UDP-style socket only */
2341         if (sctp_style(sk, TCP))
2342                 return -EOPNOTSUPP;
2343         if (optlen != sizeof(int))
2344                 return -EINVAL;
2345         if (copy_from_user(&sp->autoclose, optval, optlen))
2346                 return -EFAULT;
2347
2348         if (sp->autoclose > net->sctp.max_autoclose)
2349                 sp->autoclose = net->sctp.max_autoclose;
2350
2351         return 0;
2352 }
2353
2354 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2355  *
2356  * Applications can enable or disable heartbeats for any peer address of
2357  * an association, modify an address's heartbeat interval, force a
2358  * heartbeat to be sent immediately, and adjust the address's maximum
2359  * number of retransmissions sent before an address is considered
2360  * unreachable.  The following structure is used to access and modify an
2361  * address's parameters:
2362  *
2363  *  struct sctp_paddrparams {
2364  *     sctp_assoc_t            spp_assoc_id;
2365  *     struct sockaddr_storage spp_address;
2366  *     uint32_t                spp_hbinterval;
2367  *     uint16_t                spp_pathmaxrxt;
2368  *     uint32_t                spp_pathmtu;
2369  *     uint32_t                spp_sackdelay;
2370  *     uint32_t                spp_flags;
2371  * };
2372  *
2373  *   spp_assoc_id    - (one-to-many style socket) This is filled in the
2374  *                     application, and identifies the association for
2375  *                     this query.
2376  *   spp_address     - This specifies which address is of interest.
2377  *   spp_hbinterval  - This contains the value of the heartbeat interval,
2378  *                     in milliseconds.  If a  value of zero
2379  *                     is present in this field then no changes are to
2380  *                     be made to this parameter.
2381  *   spp_pathmaxrxt  - This contains the maximum number of
2382  *                     retransmissions before this address shall be
2383  *                     considered unreachable. If a  value of zero
2384  *                     is present in this field then no changes are to
2385  *                     be made to this parameter.
2386  *   spp_pathmtu     - When Path MTU discovery is disabled the value
2387  *                     specified here will be the "fixed" path mtu.
2388  *                     Note that if the spp_address field is empty
2389  *                     then all associations on this address will
2390  *                     have this fixed path mtu set upon them.
2391  *
2392  *   spp_sackdelay   - When delayed sack is enabled, this value specifies
2393  *                     the number of milliseconds that sacks will be delayed
2394  *                     for. This value will apply to all addresses of an
2395  *                     association if the spp_address field is empty. Note
2396  *                     also, that if delayed sack is enabled and this
2397  *                     value is set to 0, no change is made to the last
2398  *                     recorded delayed sack timer value.
2399  *
2400  *   spp_flags       - These flags are used to control various features
2401  *                     on an association. The flag field may contain
2402  *                     zero or more of the following options.
2403  *
2404  *                     SPP_HB_ENABLE  - Enable heartbeats on the
2405  *                     specified address. Note that if the address
2406  *                     field is empty all addresses for the association
2407  *                     have heartbeats enabled upon them.
2408  *
2409  *                     SPP_HB_DISABLE - Disable heartbeats on the
2410  *                     speicifed address. Note that if the address
2411  *                     field is empty all addresses for the association
2412  *                     will have their heartbeats disabled. Note also
2413  *                     that SPP_HB_ENABLE and SPP_HB_DISABLE are
2414  *                     mutually exclusive, only one of these two should
2415  *                     be specified. Enabling both fields will have
2416  *                     undetermined results.
2417  *
2418  *                     SPP_HB_DEMAND - Request a user initiated heartbeat
2419  *                     to be made immediately.
2420  *
2421  *                     SPP_HB_TIME_IS_ZERO - Specify's that the time for
2422  *                     heartbeat delayis to be set to the value of 0
2423  *                     milliseconds.
2424  *
2425  *                     SPP_PMTUD_ENABLE - This field will enable PMTU
2426  *                     discovery upon the specified address. Note that
2427  *                     if the address feild is empty then all addresses
2428  *                     on the association are effected.
2429  *
2430  *                     SPP_PMTUD_DISABLE - This field will disable PMTU
2431  *                     discovery upon the specified address. Note that
2432  *                     if the address feild is empty then all addresses
2433  *                     on the association are effected. Not also that
2434  *                     SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2435  *                     exclusive. Enabling both will have undetermined
2436  *                     results.
2437  *
2438  *                     SPP_SACKDELAY_ENABLE - Setting this flag turns
2439  *                     on delayed sack. The time specified in spp_sackdelay
2440  *                     is used to specify the sack delay for this address. Note
2441  *                     that if spp_address is empty then all addresses will
2442  *                     enable delayed sack and take on the sack delay
2443  *                     value specified in spp_sackdelay.
2444  *                     SPP_SACKDELAY_DISABLE - Setting this flag turns
2445  *                     off delayed sack. If the spp_address field is blank then
2446  *                     delayed sack is disabled for the entire association. Note
2447  *                     also that this field is mutually exclusive to
2448  *                     SPP_SACKDELAY_ENABLE, setting both will have undefined
2449  *                     results.
2450  */
2451 static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2452                                        struct sctp_transport   *trans,
2453                                        struct sctp_association *asoc,
2454                                        struct sctp_sock        *sp,
2455                                        int                      hb_change,
2456                                        int                      pmtud_change,
2457                                        int                      sackdelay_change)
2458 {
2459         int error;
2460
2461         if (params->spp_flags & SPP_HB_DEMAND && trans) {
2462                 struct net *net = sock_net(trans->asoc->base.sk);
2463
2464                 error = sctp_primitive_REQUESTHEARTBEAT(net, trans->asoc, trans);
2465                 if (error)
2466                         return error;
2467         }
2468
2469         /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2470          * this field is ignored.  Note also that a value of zero indicates
2471          * the current setting should be left unchanged.
2472          */
2473         if (params->spp_flags & SPP_HB_ENABLE) {
2474
2475                 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2476                  * set.  This lets us use 0 value when this flag
2477                  * is set.
2478                  */
2479                 if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2480                         params->spp_hbinterval = 0;
2481
2482                 if (params->spp_hbinterval ||
2483                     (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2484                         if (trans) {
2485                                 trans->hbinterval =
2486                                     msecs_to_jiffies(params->spp_hbinterval);
2487                         } else if (asoc) {
2488                                 asoc->hbinterval =
2489                                     msecs_to_jiffies(params->spp_hbinterval);
2490                         } else {
2491                                 sp->hbinterval = params->spp_hbinterval;
2492                         }
2493                 }
2494         }
2495
2496         if (hb_change) {
2497                 if (trans) {
2498                         trans->param_flags =
2499                                 (trans->param_flags & ~SPP_HB) | hb_change;
2500                 } else if (asoc) {
2501                         asoc->param_flags =
2502                                 (asoc->param_flags & ~SPP_HB) | hb_change;
2503                 } else {
2504                         sp->param_flags =
2505                                 (sp->param_flags & ~SPP_HB) | hb_change;
2506                 }
2507         }
2508
2509         /* When Path MTU discovery is disabled the value specified here will
2510          * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2511          * include the flag SPP_PMTUD_DISABLE for this field to have any
2512          * effect).
2513          */
2514         if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2515                 if (trans) {
2516                         trans->pathmtu = params->spp_pathmtu;
2517                         sctp_assoc_sync_pmtu(asoc);
2518                 } else if (asoc) {
2519                         asoc->pathmtu = params->spp_pathmtu;
2520                 } else {
2521                         sp->pathmtu = params->spp_pathmtu;
2522                 }
2523         }
2524
2525         if (pmtud_change) {
2526                 if (trans) {
2527                         int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2528                                 (params->spp_flags & SPP_PMTUD_ENABLE);
2529                         trans->param_flags =
2530                                 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2531                         if (update) {
2532                                 sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2533                                 sctp_assoc_sync_pmtu(asoc);
2534                         }
2535                 } else if (asoc) {
2536                         asoc->param_flags =
2537                                 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2538                 } else {
2539                         sp->param_flags =
2540                                 (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2541                 }
2542         }
2543
2544         /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2545          * value of this field is ignored.  Note also that a value of zero
2546          * indicates the current setting should be left unchanged.
2547          */
2548         if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2549                 if (trans) {
2550                         trans->sackdelay =
2551                                 msecs_to_jiffies(params->spp_sackdelay);
2552                 } else if (asoc) {
2553                         asoc->sackdelay =
2554                                 msecs_to_jiffies(params->spp_sackdelay);
2555                 } else {
2556                         sp->sackdelay = params->spp_sackdelay;
2557                 }
2558         }
2559
2560         if (sackdelay_change) {
2561                 if (trans) {
2562                         trans->param_flags =
2563                                 (trans->param_flags & ~SPP_SACKDELAY) |
2564                                 sackdelay_change;
2565                 } else if (asoc) {
2566                         asoc->param_flags =
2567                                 (asoc->param_flags & ~SPP_SACKDELAY) |
2568                                 sackdelay_change;
2569                 } else {
2570                         sp->param_flags =
2571                                 (sp->param_flags & ~SPP_SACKDELAY) |
2572                                 sackdelay_change;
2573                 }
2574         }
2575
2576         /* Note that a value of zero indicates the current setting should be
2577            left unchanged.
2578          */
2579         if (params->spp_pathmaxrxt) {
2580                 if (trans) {
2581                         trans->pathmaxrxt = params->spp_pathmaxrxt;
2582                 } else if (asoc) {
2583                         asoc->pathmaxrxt = params->spp_pathmaxrxt;
2584                 } else {
2585                         sp->pathmaxrxt = params->spp_pathmaxrxt;
2586                 }
2587         }
2588
2589         return 0;
2590 }
2591
2592 static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2593                                             char __user *optval,
2594                                             unsigned int optlen)
2595 {
2596         struct sctp_paddrparams  params;
2597         struct sctp_transport   *trans = NULL;
2598         struct sctp_association *asoc = NULL;
2599         struct sctp_sock        *sp = sctp_sk(sk);
2600         int error;
2601         int hb_change, pmtud_change, sackdelay_change;
2602
2603         if (optlen != sizeof(struct sctp_paddrparams))
2604                 return -EINVAL;
2605
2606         if (copy_from_user(&params, optval, optlen))
2607                 return -EFAULT;
2608
2609         /* Validate flags and value parameters. */
2610         hb_change        = params.spp_flags & SPP_HB;
2611         pmtud_change     = params.spp_flags & SPP_PMTUD;
2612         sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2613
2614         if (hb_change        == SPP_HB ||
2615             pmtud_change     == SPP_PMTUD ||
2616             sackdelay_change == SPP_SACKDELAY ||
2617             params.spp_sackdelay > 500 ||
2618             (params.spp_pathmtu &&
2619              params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2620                 return -EINVAL;
2621
2622         /* If an address other than INADDR_ANY is specified, and
2623          * no transport is found, then the request is invalid.
2624          */
2625         if (!sctp_is_any(sk, (union sctp_addr *)&params.spp_address)) {
2626                 trans = sctp_addr_id2transport(sk, &params.spp_address,
2627                                                params.spp_assoc_id);
2628                 if (!trans)
2629                         return -EINVAL;
2630         }
2631
2632         /* Get association, if assoc_id != 0 and the socket is a one
2633          * to many style socket, and an association was not found, then
2634          * the id was invalid.
2635          */
2636         asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2637         if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))
2638                 return -EINVAL;
2639
2640         /* Heartbeat demand can only be sent on a transport or
2641          * association, but not a socket.
2642          */
2643         if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2644                 return -EINVAL;
2645
2646         /* Process parameters. */
2647         error = sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2648                                             hb_change, pmtud_change,
2649                                             sackdelay_change);
2650
2651         if (error)
2652                 return error;
2653
2654         /* If changes are for association, also apply parameters to each
2655          * transport.
2656          */
2657         if (!trans && asoc) {
2658                 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2659                                 transports) {
2660                         sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2661                                                     hb_change, pmtud_change,
2662                                                     sackdelay_change);
2663                 }
2664         }
2665
2666         return 0;
2667 }
2668
2669 static inline __u32 sctp_spp_sackdelay_enable(__u32 param_flags)
2670 {
2671         return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_ENABLE;
2672 }
2673
2674 static inline __u32 sctp_spp_sackdelay_disable(__u32 param_flags)
2675 {
2676         return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_DISABLE;
2677 }
2678
2679 /*
2680  * 7.1.23.  Get or set delayed ack timer (SCTP_DELAYED_SACK)
2681  *
2682  * This option will effect the way delayed acks are performed.  This
2683  * option allows you to get or set the delayed ack time, in
2684  * milliseconds.  It also allows changing the delayed ack frequency.
2685  * Changing the frequency to 1 disables the delayed sack algorithm.  If
2686  * the assoc_id is 0, then this sets or gets the endpoints default
2687  * values.  If the assoc_id field is non-zero, then the set or get
2688  * effects the specified association for the one to many model (the
2689  * assoc_id field is ignored by the one to one model).  Note that if
2690  * sack_delay or sack_freq are 0 when setting this option, then the
2691  * current values will remain unchanged.
2692  *
2693  * struct sctp_sack_info {
2694  *     sctp_assoc_t            sack_assoc_id;
2695  *     uint32_t                sack_delay;
2696  *     uint32_t                sack_freq;
2697  * };
2698  *
2699  * sack_assoc_id -  This parameter, indicates which association the user
2700  *    is performing an action upon.  Note that if this field's value is
2701  *    zero then the endpoints default value is changed (effecting future
2702  *    associations only).
2703  *
2704  * sack_delay -  This parameter contains the number of milliseconds that
2705  *    the user is requesting the delayed ACK timer be set to.  Note that
2706  *    this value is defined in the standard to be between 200 and 500
2707  *    milliseconds.
2708  *
2709  * sack_freq -  This parameter contains the number of packets that must
2710  *    be received before a sack is sent without waiting for the delay
2711  *    timer to expire.  The default value for this is 2, setting this
2712  *    value to 1 will disable the delayed sack algorithm.
2713  */
2714
2715 static int sctp_setsockopt_delayed_ack(struct sock *sk,
2716                                        char __user *optval, unsigned int optlen)
2717 {
2718         struct sctp_sack_info    params;
2719         struct sctp_transport   *trans = NULL;
2720         struct sctp_association *asoc = NULL;
2721         struct sctp_sock        *sp = sctp_sk(sk);
2722
2723         if (optlen == sizeof(struct sctp_sack_info)) {
2724                 if (copy_from_user(&params, optval, optlen))
2725                         return -EFAULT;
2726
2727                 if (params.sack_delay == 0 && params.sack_freq == 0)
2728                         return 0;
2729         } else if (optlen == sizeof(struct sctp_assoc_value)) {
2730                 pr_warn_ratelimited(DEPRECATED
2731                                     "%s (pid %d) "
2732                                     "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2733                                     "Use struct sctp_sack_info instead\n",
2734                                     current->comm, task_pid_nr(current));
2735                 if (copy_from_user(&params, optval, optlen))
2736                         return -EFAULT;
2737
2738                 if (params.sack_delay == 0)
2739                         params.sack_freq = 1;
2740                 else
2741                         params.sack_freq = 0;
2742         } else
2743                 return -EINVAL;
2744
2745         /* Validate value parameter. */
2746         if (params.sack_delay > 500)
2747                 return -EINVAL;
2748
2749         /* Get association, if sack_assoc_id != 0 and the socket is a one
2750          * to many style socket, and an association was not found, then
2751          * the id was invalid.
2752          */
2753         asoc = sctp_id2assoc(sk, params.sack_assoc_id);
2754         if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
2755                 return -EINVAL;
2756
2757         if (params.sack_delay) {
2758                 if (asoc) {
2759                         asoc->sackdelay =
2760                                 msecs_to_jiffies(params.sack_delay);
2761                         asoc->param_flags =
2762                                 sctp_spp_sackdelay_enable(asoc->param_flags);
2763                 } else {
2764                         sp->sackdelay = params.sack_delay;
2765                         sp->param_flags =
2766                                 sctp_spp_sackdelay_enable(sp->param_flags);
2767                 }
2768         }
2769
2770         if (params.sack_freq == 1) {
2771                 if (asoc) {
2772                         asoc->param_flags =
2773                                 sctp_spp_sackdelay_disable(asoc->param_flags);
2774                 } else {
2775                         sp->param_flags =
2776                                 sctp_spp_sackdelay_disable(sp->param_flags);
2777                 }
2778         } else if (params.sack_freq > 1) {
2779                 if (asoc) {
2780                         asoc->sackfreq = params.sack_freq;
2781                         asoc->param_flags =
2782                                 sctp_spp_sackdelay_enable(asoc->param_flags);
2783                 } else {
2784                         sp->sackfreq = params.sack_freq;
2785                         sp->param_flags =
2786                                 sctp_spp_sackdelay_enable(sp->param_flags);
2787                 }
2788         }
2789
2790         /* If change is for association, also apply to each transport. */
2791         if (asoc) {
2792                 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2793                                 transports) {
2794                         if (params.sack_delay) {
2795                                 trans->sackdelay =
2796                                         msecs_to_jiffies(params.sack_delay);
2797                                 trans->param_flags =
2798                                         sctp_spp_sackdelay_enable(trans->param_flags);
2799                         }
2800                         if (params.sack_freq == 1) {
2801                                 trans->param_flags =
2802                                         sctp_spp_sackdelay_disable(trans->param_flags);
2803                         } else if (params.sack_freq > 1) {
2804                                 trans->sackfreq = params.sack_freq;
2805                                 trans->param_flags =
2806                                         sctp_spp_sackdelay_enable(trans->param_flags);
2807                         }
2808                 }
2809         }
2810
2811         return 0;
2812 }
2813
2814 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2815  *
2816  * Applications can specify protocol parameters for the default association
2817  * initialization.  The option name argument to setsockopt() and getsockopt()
2818  * is SCTP_INITMSG.
2819  *
2820  * Setting initialization parameters is effective only on an unconnected
2821  * socket (for UDP-style sockets only future associations are effected
2822  * by the change).  With TCP-style sockets, this option is inherited by
2823  * sockets derived from a listener socket.
2824  */
2825 static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen)
2826 {
2827         struct sctp_initmsg sinit;
2828         struct sctp_sock *sp = sctp_sk(sk);
2829
2830         if (optlen != sizeof(struct sctp_initmsg))
2831                 return -EINVAL;
2832         if (copy_from_user(&sinit, optval, optlen))
2833                 return -EFAULT;
2834
2835         if (sinit.sinit_num_ostreams)
2836                 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
2837         if (sinit.sinit_max_instreams)
2838                 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
2839         if (sinit.sinit_max_attempts)
2840                 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
2841         if (sinit.sinit_max_init_timeo)
2842                 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
2843
2844         return 0;
2845 }
2846
2847 /*
2848  * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2849  *
2850  *   Applications that wish to use the sendto() system call may wish to
2851  *   specify a default set of parameters that would normally be supplied
2852  *   through the inclusion of ancillary data.  This socket option allows
2853  *   such an application to set the default sctp_sndrcvinfo structure.
2854  *   The application that wishes to use this socket option simply passes
2855  *   in to this call the sctp_sndrcvinfo structure defined in Section
2856  *   5.2.2) The input parameters accepted by this call include
2857  *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2858  *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
2859  *   to this call if the caller is using the UDP model.
2860  */
2861 static int sctp_setsockopt_default_send_param(struct sock *sk,
2862                                               char __user *optval,
2863                                               unsigned int optlen)
2864 {
2865         struct sctp_sock *sp = sctp_sk(sk);
2866         struct sctp_association *asoc;
2867         struct sctp_sndrcvinfo info;
2868
2869         if (optlen != sizeof(info))
2870                 return -EINVAL;
2871         if (copy_from_user(&info, optval, optlen))
2872                 return -EFAULT;
2873         if (info.sinfo_flags &
2874             ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2875               SCTP_ABORT | SCTP_EOF))
2876                 return -EINVAL;
2877
2878         asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2879         if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
2880                 return -EINVAL;
2881         if (asoc) {
2882                 asoc->default_stream = info.sinfo_stream;
2883                 asoc->default_flags = info.sinfo_flags;
2884                 asoc->default_ppid = info.sinfo_ppid;
2885                 asoc->default_context = info.sinfo_context;
2886                 asoc->default_timetolive = info.sinfo_timetolive;
2887         } else {
2888                 sp->default_stream = info.sinfo_stream;
2889                 sp->default_flags = info.sinfo_flags;
2890                 sp->default_ppid = info.sinfo_ppid;
2891                 sp->default_context = info.sinfo_context;
2892                 sp->default_timetolive = info.sinfo_timetolive;
2893         }
2894
2895         return 0;
2896 }
2897
2898 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2899  * (SCTP_DEFAULT_SNDINFO)
2900  */
2901 static int sctp_setsockopt_default_sndinfo(struct sock *sk,
2902                                            char __user *optval,
2903                                            unsigned int optlen)
2904 {
2905         struct sctp_sock *sp = sctp_sk(sk);
2906         struct sctp_association *asoc;
2907         struct sctp_sndinfo info;
2908
2909         if (optlen != sizeof(info))
2910                 return -EINVAL;
2911         if (copy_from_user(&info, optval, optlen))
2912                 return -EFAULT;
2913         if (info.snd_flags &
2914             ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2915               SCTP_ABORT | SCTP_EOF))
2916                 return -EINVAL;
2917
2918         asoc = sctp_id2assoc(sk, info.snd_assoc_id);
2919         if (!asoc && info.snd_assoc_id && sctp_style(sk, UDP))
2920                 return -EINVAL;
2921         if (asoc) {
2922                 asoc->default_stream = info.snd_sid;
2923                 asoc->default_flags = info.snd_flags;
2924                 asoc->default_ppid = info.snd_ppid;
2925                 asoc->default_context = info.snd_context;
2926         } else {
2927                 sp->default_stream = info.snd_sid;
2928                 sp->default_flags = info.snd_flags;
2929                 sp->default_ppid = info.snd_ppid;
2930                 sp->default_context = info.snd_context;
2931         }
2932
2933         return 0;
2934 }
2935
2936 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
2937  *
2938  * Requests that the local SCTP stack use the enclosed peer address as
2939  * the association primary.  The enclosed address must be one of the
2940  * association peer's addresses.
2941  */
2942 static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
2943                                         unsigned int optlen)
2944 {
2945         struct sctp_prim prim;
2946         struct sctp_transport *trans;
2947         struct sctp_af *af;
2948         int err;
2949
2950         if (optlen != sizeof(struct sctp_prim))
2951                 return -EINVAL;
2952
2953         if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
2954                 return -EFAULT;
2955
2956         /* Allow security module to validate address but need address len. */
2957         af = sctp_get_af_specific(prim.ssp_addr.ss_family);
2958         if (!af)
2959                 return -EINVAL;
2960
2961         err = security_sctp_bind_connect(sk, SCTP_PRIMARY_ADDR,
2962                                          (struct sockaddr *)&prim.ssp_addr,
2963                                          af->sockaddr_len);
2964         if (err)
2965                 return err;
2966
2967         trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
2968         if (!trans)
2969                 return -EINVAL;
2970
2971         sctp_assoc_set_primary(trans->asoc, trans);
2972
2973         return 0;
2974 }
2975
2976 /*
2977  * 7.1.5 SCTP_NODELAY
2978  *
2979  * Turn on/off any Nagle-like algorithm.  This means that packets are
2980  * generally sent as soon as possible and no unnecessary delays are
2981  * introduced, at the cost of more packets in the network.  Expects an
2982  *  integer boolean flag.
2983  */
2984 static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
2985                                    unsigned int optlen)
2986 {
2987         int val;
2988
2989         if (optlen < sizeof(int))
2990                 return -EINVAL;
2991         if (get_user(val, (int __user *)optval))
2992                 return -EFAULT;
2993
2994         sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
2995         return 0;
2996 }
2997
2998 /*
2999  *
3000  * 7.1.1 SCTP_RTOINFO
3001  *
3002  * The protocol parameters used to initialize and bound retransmission
3003  * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3004  * and modify these parameters.
3005  * All parameters are time values, in milliseconds.  A value of 0, when
3006  * modifying the parameters, indicates that the current value should not
3007  * be changed.
3008  *
3009  */
3010 static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen)
3011 {
3012         struct sctp_rtoinfo rtoinfo;
3013         struct sctp_association *asoc;
3014         unsigned long rto_min, rto_max;
3015         struct sctp_sock *sp = sctp_sk(sk);
3016
3017         if (optlen != sizeof (struct sctp_rtoinfo))
3018                 return -EINVAL;
3019
3020         if (copy_from_user(&rtoinfo, optval, optlen))
3021                 return -EFAULT;
3022
3023         asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
3024
3025         /* Set the values to the specific association */
3026         if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
3027                 return -EINVAL;
3028
3029         rto_max = rtoinfo.srto_max;
3030         rto_min = rtoinfo.srto_min;
3031
3032         if (rto_max)
3033                 rto_max = asoc ? msecs_to_jiffies(rto_max) : rto_max;
3034         else
3035                 rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
3036
3037         if (rto_min)
3038                 rto_min = asoc ? msecs_to_jiffies(rto_min) : rto_min;
3039         else
3040                 rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
3041
3042         if (rto_min > rto_max)
3043                 return -EINVAL;
3044
3045         if (asoc) {
3046                 if (rtoinfo.srto_initial != 0)
3047                         asoc->rto_initial =
3048                                 msecs_to_jiffies(rtoinfo.srto_initial);
3049                 asoc->rto_max = rto_max;
3050                 asoc->rto_min = rto_min;
3051         } else {
3052                 /* If there is no association or the association-id = 0
3053                  * set the values to the endpoint.
3054                  */
3055                 if (rtoinfo.srto_initial != 0)
3056                         sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
3057                 sp->rtoinfo.srto_max = rto_max;
3058                 sp->rtoinfo.srto_min = rto_min;
3059         }
3060
3061         return 0;
3062 }
3063
3064 /*
3065  *
3066  * 7.1.2 SCTP_ASSOCINFO
3067  *
3068  * This option is used to tune the maximum retransmission attempts
3069  * of the association.
3070  * Returns an error if the new association retransmission value is
3071  * greater than the sum of the retransmission value  of the peer.
3072  * See [SCTP] for more information.
3073  *
3074  */
3075 static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen)
3076 {
3077
3078         struct sctp_assocparams assocparams;
3079         struct sctp_association *asoc;
3080
3081         if (optlen != sizeof(struct sctp_assocparams))
3082                 return -EINVAL;
3083         if (copy_from_user(&assocparams, optval, optlen))
3084                 return -EFAULT;
3085
3086         asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
3087
3088         if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
3089                 return -EINVAL;
3090
3091         /* Set the values to the specific association */
3092         if (asoc) {
3093                 if (assocparams.sasoc_asocmaxrxt != 0) {
3094                         __u32 path_sum = 0;
3095                         int   paths = 0;
3096                         struct sctp_transport *peer_addr;
3097
3098                         list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
3099                                         transports) {
3100                                 path_sum += peer_addr->pathmaxrxt;
3101                                 paths++;
3102                         }
3103
3104                         /* Only validate asocmaxrxt if we have more than
3105                          * one path/transport.  We do this because path
3106                          * retransmissions are only counted when we have more
3107                          * then one path.
3108                          */
3109                         if (paths > 1 &&
3110                             assocparams.sasoc_asocmaxrxt > path_sum)
3111                                 return -EINVAL;
3112
3113                         asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
3114                 }
3115
3116                 if (assocparams.sasoc_cookie_life != 0)
3117                         asoc->cookie_life = ms_to_ktime(assocparams.sasoc_cookie_life);
3118         } else {
3119                 /* Set the values to the endpoint */
3120                 struct sctp_sock *sp = sctp_sk(sk);
3121
3122                 if (assocparams.sasoc_asocmaxrxt != 0)
3123                         sp->assocparams.sasoc_asocmaxrxt =
3124                                                 assocparams.sasoc_asocmaxrxt;
3125                 if (assocparams.sasoc_cookie_life != 0)
3126                         sp->assocparams.sasoc_cookie_life =
3127                                                 assocparams.sasoc_cookie_life;
3128         }
3129         return 0;
3130 }
3131
3132 /*
3133  * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3134  *
3135  * This socket option is a boolean flag which turns on or off mapped V4
3136  * addresses.  If this option is turned on and the socket is type
3137  * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3138  * If this option is turned off, then no mapping will be done of V4
3139  * addresses and a user will receive both PF_INET6 and PF_INET type
3140  * addresses on the socket.
3141  */
3142 static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen)
3143 {
3144         int val;
3145         struct sctp_sock *sp = sctp_sk(sk);
3146
3147         if (optlen < sizeof(int))
3148                 return -EINVAL;
3149         if (get_user(val, (int __user *)optval))
3150                 return -EFAULT;
3151         if (val)
3152                 sp->v4mapped = 1;
3153         else
3154                 sp->v4mapped = 0;
3155
3156         return 0;
3157 }
3158
3159 /*
3160  * 8.1.16.  Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3161  * This option will get or set the maximum size to put in any outgoing
3162  * SCTP DATA chunk.  If a message is larger than this size it will be
3163  * fragmented by SCTP into the specified size.  Note that the underlying
3164  * SCTP implementation may fragment into smaller sized chunks when the
3165  * PMTU of the underlying association is smaller than the value set by
3166  * the user.  The default value for this option is '0' which indicates
3167  * the user is NOT limiting fragmentation and only the PMTU will effect
3168  * SCTP's choice of DATA chunk size.  Note also that values set larger
3169  * than the maximum size of an IP datagram will effectively let SCTP
3170  * control fragmentation (i.e. the same as setting this option to 0).
3171  *
3172  * The following structure is used to access and modify this parameter:
3173  *
3174  * struct sctp_assoc_value {
3175  *   sctp_assoc_t assoc_id;
3176  *   uint32_t assoc_value;
3177  * };
3178  *
3179  * assoc_id:  This parameter is ignored for one-to-one style sockets.
3180  *    For one-to-many style sockets this parameter indicates which
3181  *    association the user is performing an action upon.  Note that if
3182  *    this field's value is zero then the endpoints default value is
3183  *    changed (effecting future associations only).
3184  * assoc_value:  This parameter specifies the maximum size in bytes.
3185  */
3186 static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen)
3187 {
3188         struct sctp_sock *sp = sctp_sk(sk);
3189         struct sctp_af *af = sp->pf->af;
3190         struct sctp_assoc_value params;
3191         struct sctp_association *asoc;
3192         int val;
3193
3194         if (optlen == sizeof(int)) {
3195                 pr_warn_ratelimited(DEPRECATED
3196                                     "%s (pid %d) "
3197                                     "Use of int in maxseg socket option.\n"
3198                                     "Use struct sctp_assoc_value instead\n",
3199                                     current->comm, task_pid_nr(current));
3200                 if (copy_from_user(&val, optval, optlen))
3201                         return -EFAULT;
3202                 params.assoc_id = 0;
3203         } else if (optlen == sizeof(struct sctp_assoc_value)) {
3204                 if (copy_from_user(&params, optval, optlen))
3205                         return -EFAULT;
3206                 val = params.assoc_value;
3207         } else {
3208                 return -EINVAL;
3209         }
3210
3211         if (val) {
3212                 int min_len, max_len;
3213
3214                 min_len = SCTP_DEFAULT_MINSEGMENT - af->net_header_len;
3215                 min_len -= af->ip_options_len(sk);
3216                 min_len -= sizeof(struct sctphdr) +
3217                            sizeof(struct sctp_data_chunk);
3218
3219                 max_len = SCTP_MAX_CHUNK_LEN - sizeof(struct sctp_data_chunk);
3220
3221                 if (val < min_len || val > max_len)
3222                         return -EINVAL;
3223         }
3224
3225         asoc = sctp_id2assoc(sk, params.assoc_id);
3226         if (asoc) {
3227                 if (val == 0) {
3228                         val = asoc->pathmtu - af->net_header_len;
3229                         val -= af->ip_options_len(sk);
3230                         val -= sizeof(struct sctphdr) +
3231                                sctp_datachk_len(&asoc->stream);
3232                 }
3233                 asoc->user_frag = val;
3234                 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
3235         } else {
3236                 if (params.assoc_id && sctp_style(sk, UDP))
3237                         return -EINVAL;
3238                 sp->user_frag = val;
3239         }
3240
3241         return 0;
3242 }
3243
3244
3245 /*
3246  *  7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3247  *
3248  *   Requests that the peer mark the enclosed address as the association
3249  *   primary. The enclosed address must be one of the association's
3250  *   locally bound addresses. The following structure is used to make a
3251  *   set primary request:
3252  */
3253 static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
3254                                              unsigned int optlen)
3255 {
3256         struct net *net = sock_net(sk);
3257         struct sctp_sock        *sp;
3258         struct sctp_association *asoc = NULL;
3259         struct sctp_setpeerprim prim;
3260         struct sctp_chunk       *chunk;
3261         struct sctp_af          *af;
3262         int                     err;
3263
3264         sp = sctp_sk(sk);
3265
3266         if (!net->sctp.addip_enable)
3267                 return -EPERM;
3268
3269         if (optlen != sizeof(struct sctp_setpeerprim))
3270                 return -EINVAL;
3271
3272         if (copy_from_user(&prim, optval, optlen))
3273                 return -EFAULT;
3274
3275         asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
3276         if (!asoc)
3277                 return -EINVAL;
3278
3279         if (!asoc->peer.asconf_capable)
3280                 return -EPERM;
3281
3282         if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3283                 return -EPERM;
3284
3285         if (!sctp_state(asoc, ESTABLISHED))
3286                 return -ENOTCONN;
3287
3288         af = sctp_get_af_specific(prim.sspp_addr.ss_family);
3289         if (!af)
3290                 return -EINVAL;
3291
3292         if (!af->addr_valid((union sctp_addr *)&prim.sspp_addr, sp, NULL))
3293                 return -EADDRNOTAVAIL;
3294
3295         if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
3296                 return -EADDRNOTAVAIL;
3297
3298         /* Allow security module to validate address. */
3299         err = security_sctp_bind_connect(sk, SCTP_SET_PEER_PRIMARY_ADDR,
3300                                          (struct sockaddr *)&prim.sspp_addr,
3301                                          af->sockaddr_len);
3302         if (err)
3303                 return err;
3304
3305         /* Create an ASCONF chunk with SET_PRIMARY parameter    */