~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sctp/socket.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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