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
9 * This file is part of the SCTP kernel implementation
11 * These functions interface with the sockets layer to implement the
12 * SCTP Extensions for the Sockets API.
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.
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)
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.
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/>.
34 * Please send any bug reports or fixes you make to the
36 * lksctp developers <linux-sctp@vger.kernel.org>
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>
53 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
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>
72 #include <net/route.h>
74 #include <net/inet_common.h>
75 #include <net/busy_poll.h>
77 #include <linux/socket.h> /* for sa_family_t */
78 #include <linux/export.h>
80 #include <net/sctp/sctp.h>
81 #include <net/sctp/sm.h>
83 /* Forward declarations for internal helper functions. */
84 static int sctp_writeable(struct sock
*sk
);
85 static void sctp_wfree(struct sk_buff
*skb
);
86 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
88 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
);
89 static int sctp_wait_for_connect(struct sctp_association
*, long *timeo_p
);
90 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
);
91 static void sctp_wait_for_close(struct sock
*sk
, long timeo
);
92 static void sctp_destruct_sock(struct sock
*sk
);
93 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
94 union sctp_addr
*addr
, int len
);
95 static int sctp_bindx_add(struct sock
*, struct sockaddr
*, int);
96 static int sctp_bindx_rem(struct sock
*, struct sockaddr
*, int);
97 static int sctp_send_asconf_add_ip(struct sock
*, struct sockaddr
*, int);
98 static int sctp_send_asconf_del_ip(struct sock
*, struct sockaddr
*, int);
99 static int sctp_send_asconf(struct sctp_association
*asoc
,
100 struct sctp_chunk
*chunk
);
101 static int sctp_do_bind(struct sock
*, union sctp_addr
*, int);
102 static int sctp_autobind(struct sock
*sk
);
103 static void sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
104 struct sctp_association
*assoc
,
105 enum sctp_socket_type type
);
107 static unsigned long sctp_memory_pressure
;
108 static atomic_long_t sctp_memory_allocated
;
109 struct percpu_counter sctp_sockets_allocated
;
111 static void sctp_enter_memory_pressure(struct sock
*sk
)
113 sctp_memory_pressure
= 1;
117 /* Get the sndbuf space available at the time on the association. */
118 static inline int sctp_wspace(struct sctp_association
*asoc
)
122 if (asoc
->ep
->sndbuf_policy
)
123 amt
= asoc
->sndbuf_used
;
125 amt
= sk_wmem_alloc_get(asoc
->base
.sk
);
127 if (amt
>= asoc
->base
.sk
->sk_sndbuf
) {
128 if (asoc
->base
.sk
->sk_userlocks
& SOCK_SNDBUF_LOCK
)
131 amt
= sk_stream_wspace(asoc
->base
.sk
);
136 amt
= asoc
->base
.sk
->sk_sndbuf
- amt
;
141 /* Increment the used sndbuf space count of the corresponding association by
142 * the size of the outgoing data chunk.
143 * Also, set the skb destructor for sndbuf accounting later.
145 * Since it is always 1-1 between chunk and skb, and also a new skb is always
146 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
147 * destructor in the data chunk skb for the purpose of the sndbuf space
150 static inline void sctp_set_owner_w(struct sctp_chunk
*chunk
)
152 struct sctp_association
*asoc
= chunk
->asoc
;
153 struct sock
*sk
= asoc
->base
.sk
;
155 /* The sndbuf space is tracked per association. */
156 sctp_association_hold(asoc
);
158 skb_set_owner_w(chunk
->skb
, sk
);
160 chunk
->skb
->destructor
= sctp_wfree
;
161 /* Save the chunk pointer in skb for sctp_wfree to use later. */
162 skb_shinfo(chunk
->skb
)->destructor_arg
= chunk
;
164 asoc
->sndbuf_used
+= SCTP_DATA_SNDSIZE(chunk
) +
165 sizeof(struct sk_buff
) +
166 sizeof(struct sctp_chunk
);
168 refcount_add(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
);
169 sk
->sk_wmem_queued
+= chunk
->skb
->truesize
;
170 sk_mem_charge(sk
, chunk
->skb
->truesize
);
173 static void sctp_clear_owner_w(struct sctp_chunk
*chunk
)
175 skb_orphan(chunk
->skb
);
178 static void sctp_for_each_tx_datachunk(struct sctp_association
*asoc
,
179 void (*cb
)(struct sctp_chunk
*))
182 struct sctp_outq
*q
= &asoc
->outqueue
;
183 struct sctp_transport
*t
;
184 struct sctp_chunk
*chunk
;
186 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
, transports
)
187 list_for_each_entry(chunk
, &t
->transmitted
, transmitted_list
)
190 list_for_each_entry(chunk
, &q
->retransmit
, transmitted_list
)
193 list_for_each_entry(chunk
, &q
->sacked
, transmitted_list
)
196 list_for_each_entry(chunk
, &q
->abandoned
, transmitted_list
)
199 list_for_each_entry(chunk
, &q
->out_chunk_list
, list
)
203 /* Verify that this is a valid address. */
204 static inline int sctp_verify_addr(struct sock
*sk
, union sctp_addr
*addr
,
209 /* Verify basic sockaddr. */
210 af
= sctp_sockaddr_af(sctp_sk(sk
), addr
, len
);
214 /* Is this a valid SCTP address? */
215 if (!af
->addr_valid(addr
, sctp_sk(sk
), NULL
))
218 if (!sctp_sk(sk
)->pf
->send_verify(sctp_sk(sk
), (addr
)))
224 /* Look up the association by its id. If this is not a UDP-style
225 * socket, the ID field is always ignored.
227 struct sctp_association
*sctp_id2assoc(struct sock
*sk
, sctp_assoc_t id
)
229 struct sctp_association
*asoc
= NULL
;
231 /* If this is not a UDP-style socket, assoc id should be ignored. */
232 if (!sctp_style(sk
, UDP
)) {
233 /* Return NULL if the socket state is not ESTABLISHED. It
234 * could be a TCP-style listening socket or a socket which
235 * hasn't yet called connect() to establish an association.
237 if (!sctp_sstate(sk
, ESTABLISHED
) && !sctp_sstate(sk
, CLOSING
))
240 /* Get the first and the only association from the list. */
241 if (!list_empty(&sctp_sk(sk
)->ep
->asocs
))
242 asoc
= list_entry(sctp_sk(sk
)->ep
->asocs
.next
,
243 struct sctp_association
, asocs
);
247 /* Otherwise this is a UDP-style socket. */
248 if (!id
|| (id
== (sctp_assoc_t
)-1))
251 spin_lock_bh(&sctp_assocs_id_lock
);
252 asoc
= (struct sctp_association
*)idr_find(&sctp_assocs_id
, (int)id
);
253 if (asoc
&& (asoc
->base
.sk
!= sk
|| asoc
->base
.dead
))
255 spin_unlock_bh(&sctp_assocs_id_lock
);
260 /* Look up the transport from an address and an assoc id. If both address and
261 * id are specified, the associations matching the address and the id should be
264 static struct sctp_transport
*sctp_addr_id2transport(struct sock
*sk
,
265 struct sockaddr_storage
*addr
,
268 struct sctp_association
*addr_asoc
= NULL
, *id_asoc
= NULL
;
269 struct sctp_af
*af
= sctp_get_af_specific(addr
->ss_family
);
270 union sctp_addr
*laddr
= (union sctp_addr
*)addr
;
271 struct sctp_transport
*transport
;
273 if (!af
|| sctp_verify_addr(sk
, laddr
, af
->sockaddr_len
))
276 addr_asoc
= sctp_endpoint_lookup_assoc(sctp_sk(sk
)->ep
,
283 id_asoc
= sctp_id2assoc(sk
, id
);
284 if (id_asoc
&& (id_asoc
!= addr_asoc
))
287 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
288 (union sctp_addr
*)addr
);
293 /* API 3.1.2 bind() - UDP Style Syntax
294 * The syntax of bind() is,
296 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
298 * sd - the socket descriptor returned by socket().
299 * addr - the address structure (struct sockaddr_in or struct
300 * sockaddr_in6 [RFC 2553]),
301 * addr_len - the size of the address structure.
303 static int sctp_bind(struct sock
*sk
, struct sockaddr
*addr
, int addr_len
)
309 pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__
, sk
,
312 /* Disallow binding twice. */
313 if (!sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
314 retval
= sctp_do_bind(sk
, (union sctp_addr
*)addr
,
324 static long sctp_get_port_local(struct sock
*, union sctp_addr
*);
326 /* Verify this is a valid sockaddr. */
327 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
328 union sctp_addr
*addr
, int len
)
332 /* Check minimum size. */
333 if (len
< sizeof (struct sockaddr
))
336 if (!opt
->pf
->af_supported(addr
->sa
.sa_family
, opt
))
339 if (addr
->sa
.sa_family
== AF_INET6
) {
340 if (len
< SIN6_LEN_RFC2133
)
342 /* V4 mapped address are really of AF_INET family */
343 if (ipv6_addr_v4mapped(&addr
->v6
.sin6_addr
) &&
344 !opt
->pf
->af_supported(AF_INET
, opt
))
348 /* If we get this far, af is valid. */
349 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
351 if (len
< af
->sockaddr_len
)
357 /* Bind a local address either to an endpoint or to an association. */
358 static int sctp_do_bind(struct sock
*sk
, union sctp_addr
*addr
, int len
)
360 struct net
*net
= sock_net(sk
);
361 struct sctp_sock
*sp
= sctp_sk(sk
);
362 struct sctp_endpoint
*ep
= sp
->ep
;
363 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
368 /* Common sockaddr verification. */
369 af
= sctp_sockaddr_af(sp
, addr
, len
);
371 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
372 __func__
, sk
, addr
, len
);
376 snum
= ntohs(addr
->v4
.sin_port
);
378 pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
379 __func__
, sk
, &addr
->sa
, bp
->port
, snum
, len
);
381 /* PF specific bind() address verification. */
382 if (!sp
->pf
->bind_verify(sp
, addr
))
383 return -EADDRNOTAVAIL
;
385 /* We must either be unbound, or bind to the same port.
386 * It's OK to allow 0 ports if we are already bound.
387 * We'll just inhert an already bound port in this case
392 else if (snum
!= bp
->port
) {
393 pr_debug("%s: new port %d doesn't match existing port "
394 "%d\n", __func__
, snum
, bp
->port
);
399 if (snum
&& snum
< inet_prot_sock(net
) &&
400 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
))
403 /* See if the address matches any of the addresses we may have
404 * already bound before checking against other endpoints.
406 if (sctp_bind_addr_match(bp
, addr
, sp
))
409 /* Make sure we are allowed to bind here.
410 * The function sctp_get_port_local() does duplicate address
413 addr
->v4
.sin_port
= htons(snum
);
414 if ((ret
= sctp_get_port_local(sk
, addr
))) {
418 /* Refresh ephemeral port. */
420 bp
->port
= inet_sk(sk
)->inet_num
;
422 /* Add the address to the bind address list.
423 * Use GFP_ATOMIC since BHs will be disabled.
425 ret
= sctp_add_bind_addr(bp
, addr
, af
->sockaddr_len
,
426 SCTP_ADDR_SRC
, GFP_ATOMIC
);
428 /* Copy back into socket for getsockname() use. */
430 inet_sk(sk
)->inet_sport
= htons(inet_sk(sk
)->inet_num
);
431 sp
->pf
->to_sk_saddr(addr
, sk
);
437 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
439 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
440 * at any one time. If a sender, after sending an ASCONF chunk, decides
441 * it needs to transfer another ASCONF Chunk, it MUST wait until the
442 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
443 * subsequent ASCONF. Note this restriction binds each side, so at any
444 * time two ASCONF may be in-transit on any given association (one sent
445 * from each endpoint).
447 static int sctp_send_asconf(struct sctp_association
*asoc
,
448 struct sctp_chunk
*chunk
)
450 struct net
*net
= sock_net(asoc
->base
.sk
);
453 /* If there is an outstanding ASCONF chunk, queue it for later
456 if (asoc
->addip_last_asconf
) {
457 list_add_tail(&chunk
->list
, &asoc
->addip_chunk_list
);
461 /* Hold the chunk until an ASCONF_ACK is received. */
462 sctp_chunk_hold(chunk
);
463 retval
= sctp_primitive_ASCONF(net
, asoc
, chunk
);
465 sctp_chunk_free(chunk
);
467 asoc
->addip_last_asconf
= chunk
;
473 /* Add a list of addresses as bind addresses to local endpoint or
476 * Basically run through each address specified in the addrs/addrcnt
477 * array/length pair, determine if it is IPv6 or IPv4 and call
478 * sctp_do_bind() on it.
480 * If any of them fails, then the operation will be reversed and the
481 * ones that were added will be removed.
483 * Only sctp_setsockopt_bindx() is supposed to call this function.
485 static int sctp_bindx_add(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
490 struct sockaddr
*sa_addr
;
493 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__
, sk
,
497 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
498 /* The list may contain either IPv4 or IPv6 address;
499 * determine the address length for walking thru the list.
502 af
= sctp_get_af_specific(sa_addr
->sa_family
);
508 retval
= sctp_do_bind(sk
, (union sctp_addr
*)sa_addr
,
511 addr_buf
+= af
->sockaddr_len
;
515 /* Failed. Cleanup the ones that have been added */
517 sctp_bindx_rem(sk
, addrs
, cnt
);
525 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
526 * associations that are part of the endpoint indicating that a list of local
527 * addresses are added to the endpoint.
529 * If any of the addresses is already in the bind address list of the
530 * association, we do not send the chunk for that association. But it will not
531 * affect other associations.
533 * Only sctp_setsockopt_bindx() is supposed to call this function.
535 static int sctp_send_asconf_add_ip(struct sock
*sk
,
536 struct sockaddr
*addrs
,
539 struct net
*net
= sock_net(sk
);
540 struct sctp_sock
*sp
;
541 struct sctp_endpoint
*ep
;
542 struct sctp_association
*asoc
;
543 struct sctp_bind_addr
*bp
;
544 struct sctp_chunk
*chunk
;
545 struct sctp_sockaddr_entry
*laddr
;
546 union sctp_addr
*addr
;
547 union sctp_addr saveaddr
;
554 if (!net
->sctp
.addip_enable
)
560 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
561 __func__
, sk
, addrs
, addrcnt
);
563 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
564 if (!asoc
->peer
.asconf_capable
)
567 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_ADD_IP
)
570 if (!sctp_state(asoc
, ESTABLISHED
))
573 /* Check if any address in the packed array of addresses is
574 * in the bind address list of the association. If so,
575 * do not send the asconf chunk to its peer, but continue with
576 * other associations.
579 for (i
= 0; i
< addrcnt
; i
++) {
581 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
587 if (sctp_assoc_lookup_laddr(asoc
, addr
))
590 addr_buf
+= af
->sockaddr_len
;
595 /* Use the first valid address in bind addr list of
596 * association as Address Parameter of ASCONF CHUNK.
598 bp
= &asoc
->base
.bind_addr
;
599 p
= bp
->address_list
.next
;
600 laddr
= list_entry(p
, struct sctp_sockaddr_entry
, list
);
601 chunk
= sctp_make_asconf_update_ip(asoc
, &laddr
->a
, addrs
,
602 addrcnt
, SCTP_PARAM_ADD_IP
);
608 /* Add the new addresses to the bind address list with
609 * use_as_src set to 0.
612 for (i
= 0; i
< addrcnt
; i
++) {
614 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
615 memcpy(&saveaddr
, addr
, af
->sockaddr_len
);
616 retval
= sctp_add_bind_addr(bp
, &saveaddr
,
618 SCTP_ADDR_NEW
, GFP_ATOMIC
);
619 addr_buf
+= af
->sockaddr_len
;
621 if (asoc
->src_out_of_asoc_ok
) {
622 struct sctp_transport
*trans
;
624 list_for_each_entry(trans
,
625 &asoc
->peer
.transport_addr_list
, transports
) {
626 /* Clear the source and route cache */
627 sctp_transport_dst_release(trans
);
628 trans
->cwnd
= min(4*asoc
->pathmtu
, max_t(__u32
,
629 2*asoc
->pathmtu
, 4380));
630 trans
->ssthresh
= asoc
->peer
.i
.a_rwnd
;
631 trans
->rto
= asoc
->rto_initial
;
632 sctp_max_rto(asoc
, trans
);
633 trans
->rtt
= trans
->srtt
= trans
->rttvar
= 0;
634 sctp_transport_route(trans
, NULL
,
635 sctp_sk(asoc
->base
.sk
));
638 retval
= sctp_send_asconf(asoc
, chunk
);
645 /* Remove a list of addresses from bind addresses list. Do not remove the
648 * Basically run through each address specified in the addrs/addrcnt
649 * array/length pair, determine if it is IPv6 or IPv4 and call
650 * sctp_del_bind() on it.
652 * If any of them fails, then the operation will be reversed and the
653 * ones that were removed will be added back.
655 * At least one address has to be left; if only one address is
656 * available, the operation will return -EBUSY.
658 * Only sctp_setsockopt_bindx() is supposed to call this function.
660 static int sctp_bindx_rem(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
662 struct sctp_sock
*sp
= sctp_sk(sk
);
663 struct sctp_endpoint
*ep
= sp
->ep
;
665 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
668 union sctp_addr
*sa_addr
;
671 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
672 __func__
, sk
, addrs
, addrcnt
);
675 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
676 /* If the bind address list is empty or if there is only one
677 * bind address, there is nothing more to be removed (we need
678 * at least one address here).
680 if (list_empty(&bp
->address_list
) ||
681 (sctp_list_single_entry(&bp
->address_list
))) {
687 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
693 if (!af
->addr_valid(sa_addr
, sp
, NULL
)) {
694 retval
= -EADDRNOTAVAIL
;
698 if (sa_addr
->v4
.sin_port
&&
699 sa_addr
->v4
.sin_port
!= htons(bp
->port
)) {
704 if (!sa_addr
->v4
.sin_port
)
705 sa_addr
->v4
.sin_port
= htons(bp
->port
);
707 /* FIXME - There is probably a need to check if sk->sk_saddr and
708 * sk->sk_rcv_addr are currently set to one of the addresses to
709 * be removed. This is something which needs to be looked into
710 * when we are fixing the outstanding issues with multi-homing
711 * socket routing and failover schemes. Refer to comments in
712 * sctp_do_bind(). -daisy
714 retval
= sctp_del_bind_addr(bp
, sa_addr
);
716 addr_buf
+= af
->sockaddr_len
;
719 /* Failed. Add the ones that has been removed back */
721 sctp_bindx_add(sk
, addrs
, cnt
);
729 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
730 * the associations that are part of the endpoint indicating that a list of
731 * local addresses are removed from the endpoint.
733 * If any of the addresses is already in the bind address list of the
734 * association, we do not send the chunk for that association. But it will not
735 * affect other associations.
737 * Only sctp_setsockopt_bindx() is supposed to call this function.
739 static int sctp_send_asconf_del_ip(struct sock
*sk
,
740 struct sockaddr
*addrs
,
743 struct net
*net
= sock_net(sk
);
744 struct sctp_sock
*sp
;
745 struct sctp_endpoint
*ep
;
746 struct sctp_association
*asoc
;
747 struct sctp_transport
*transport
;
748 struct sctp_bind_addr
*bp
;
749 struct sctp_chunk
*chunk
;
750 union sctp_addr
*laddr
;
753 struct sctp_sockaddr_entry
*saddr
;
759 if (!net
->sctp
.addip_enable
)
765 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
766 __func__
, sk
, addrs
, addrcnt
);
768 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
770 if (!asoc
->peer
.asconf_capable
)
773 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_DEL_IP
)
776 if (!sctp_state(asoc
, ESTABLISHED
))
779 /* Check if any address in the packed array of addresses is
780 * not present in the bind address list of the association.
781 * If so, do not send the asconf chunk to its peer, but
782 * continue with other associations.
785 for (i
= 0; i
< addrcnt
; i
++) {
787 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
793 if (!sctp_assoc_lookup_laddr(asoc
, laddr
))
796 addr_buf
+= af
->sockaddr_len
;
801 /* Find one address in the association's bind address list
802 * that is not in the packed array of addresses. This is to
803 * make sure that we do not delete all the addresses in the
806 bp
= &asoc
->base
.bind_addr
;
807 laddr
= sctp_find_unmatch_addr(bp
, (union sctp_addr
*)addrs
,
809 if ((laddr
== NULL
) && (addrcnt
== 1)) {
810 if (asoc
->asconf_addr_del_pending
)
812 asoc
->asconf_addr_del_pending
=
813 kzalloc(sizeof(union sctp_addr
), GFP_ATOMIC
);
814 if (asoc
->asconf_addr_del_pending
== NULL
) {
818 asoc
->asconf_addr_del_pending
->sa
.sa_family
=
820 asoc
->asconf_addr_del_pending
->v4
.sin_port
=
822 if (addrs
->sa_family
== AF_INET
) {
823 struct sockaddr_in
*sin
;
825 sin
= (struct sockaddr_in
*)addrs
;
826 asoc
->asconf_addr_del_pending
->v4
.sin_addr
.s_addr
= sin
->sin_addr
.s_addr
;
827 } else if (addrs
->sa_family
== AF_INET6
) {
828 struct sockaddr_in6
*sin6
;
830 sin6
= (struct sockaddr_in6
*)addrs
;
831 asoc
->asconf_addr_del_pending
->v6
.sin6_addr
= sin6
->sin6_addr
;
834 pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
835 __func__
, asoc
, &asoc
->asconf_addr_del_pending
->sa
,
836 asoc
->asconf_addr_del_pending
);
838 asoc
->src_out_of_asoc_ok
= 1;
846 /* We do not need RCU protection throughout this loop
847 * because this is done under a socket lock from the
850 chunk
= sctp_make_asconf_update_ip(asoc
, laddr
, addrs
, addrcnt
,
858 /* Reset use_as_src flag for the addresses in the bind address
859 * list that are to be deleted.
862 for (i
= 0; i
< addrcnt
; i
++) {
864 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
865 list_for_each_entry(saddr
, &bp
->address_list
, list
) {
866 if (sctp_cmp_addr_exact(&saddr
->a
, laddr
))
867 saddr
->state
= SCTP_ADDR_DEL
;
869 addr_buf
+= af
->sockaddr_len
;
872 /* Update the route and saddr entries for all the transports
873 * as some of the addresses in the bind address list are
874 * about to be deleted and cannot be used as source addresses.
876 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
878 sctp_transport_dst_release(transport
);
879 sctp_transport_route(transport
, NULL
,
880 sctp_sk(asoc
->base
.sk
));
884 /* We don't need to transmit ASCONF */
886 retval
= sctp_send_asconf(asoc
, chunk
);
892 /* set addr events to assocs in the endpoint. ep and addr_wq must be locked */
893 int sctp_asconf_mgmt(struct sctp_sock
*sp
, struct sctp_sockaddr_entry
*addrw
)
895 struct sock
*sk
= sctp_opt2sk(sp
);
896 union sctp_addr
*addr
;
899 /* It is safe to write port space in caller. */
901 addr
->v4
.sin_port
= htons(sp
->ep
->base
.bind_addr
.port
);
902 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
905 if (sctp_verify_addr(sk
, addr
, af
->sockaddr_len
))
908 if (addrw
->state
== SCTP_ADDR_NEW
)
909 return sctp_send_asconf_add_ip(sk
, (struct sockaddr
*)addr
, 1);
911 return sctp_send_asconf_del_ip(sk
, (struct sockaddr
*)addr
, 1);
914 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
917 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
920 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
921 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
924 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
925 * Section 3.1.2 for this usage.
927 * addrs is a pointer to an array of one or more socket addresses. Each
928 * address is contained in its appropriate structure (i.e. struct
929 * sockaddr_in or struct sockaddr_in6) the family of the address type
930 * must be used to distinguish the address length (note that this
931 * representation is termed a "packed array" of addresses). The caller
932 * specifies the number of addresses in the array with addrcnt.
934 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
935 * -1, and sets errno to the appropriate error code.
937 * For SCTP, the port given in each socket address must be the same, or
938 * sctp_bindx() will fail, setting errno to EINVAL.
940 * The flags parameter is formed from the bitwise OR of zero or more of
941 * the following currently defined flags:
943 * SCTP_BINDX_ADD_ADDR
945 * SCTP_BINDX_REM_ADDR
947 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
948 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
949 * addresses from the association. The two flags are mutually exclusive;
950 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
951 * not remove all addresses from an association; sctp_bindx() will
952 * reject such an attempt with EINVAL.
954 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
955 * additional addresses with an endpoint after calling bind(). Or use
956 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
957 * socket is associated with so that no new association accepted will be
958 * associated with those addresses. If the endpoint supports dynamic
959 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
960 * endpoint to send the appropriate message to the peer to change the
961 * peers address lists.
963 * Adding and removing addresses from a connected association is
964 * optional functionality. Implementations that do not support this
965 * functionality should return EOPNOTSUPP.
967 * Basically do nothing but copying the addresses from user to kernel
968 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
969 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
972 * We don't use copy_from_user() for optimization: we first do the
973 * sanity checks (buffer size -fast- and access check-healthy
974 * pointer); if all of those succeed, then we can alloc the memory
975 * (expensive operation) needed to copy the data to kernel. Then we do
976 * the copying without checking the user space area
977 * (__copy_from_user()).
979 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
982 * sk The sk of the socket
983 * addrs The pointer to the addresses in user land
984 * addrssize Size of the addrs buffer
985 * op Operation to perform (add or remove, see the flags of
988 * Returns 0 if ok, <0 errno code on error.
990 static int sctp_setsockopt_bindx(struct sock
*sk
,
991 struct sockaddr __user
*addrs
,
992 int addrs_size
, int op
)
994 struct sockaddr
*kaddrs
;
998 struct sockaddr
*sa_addr
;
1002 pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
1003 __func__
, sk
, addrs
, addrs_size
, op
);
1005 if (unlikely(addrs_size
<= 0))
1008 /* Check the user passed a healthy pointer. */
1009 if (unlikely(!access_ok(VERIFY_READ
, addrs
, addrs_size
)))
1012 /* Alloc space for the address array in kernel memory. */
1013 kaddrs
= kmalloc(addrs_size
, GFP_USER
| __GFP_NOWARN
);
1014 if (unlikely(!kaddrs
))
1017 if (__copy_from_user(kaddrs
, addrs
, addrs_size
)) {
1022 /* Walk through the addrs buffer and count the number of addresses. */
1024 while (walk_size
< addrs_size
) {
1025 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
) {
1031 af
= sctp_get_af_specific(sa_addr
->sa_family
);
1033 /* If the address family is not supported or if this address
1034 * causes the address buffer to overflow return EINVAL.
1036 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
1041 addr_buf
+= af
->sockaddr_len
;
1042 walk_size
+= af
->sockaddr_len
;
1047 case SCTP_BINDX_ADD_ADDR
:
1048 err
= sctp_bindx_add(sk
, kaddrs
, addrcnt
);
1051 err
= sctp_send_asconf_add_ip(sk
, kaddrs
, addrcnt
);
1054 case SCTP_BINDX_REM_ADDR
:
1055 err
= sctp_bindx_rem(sk
, kaddrs
, addrcnt
);
1058 err
= sctp_send_asconf_del_ip(sk
, kaddrs
, addrcnt
);
1072 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1074 * Common routine for handling connect() and sctp_connectx().
1075 * Connect will come in with just a single address.
1077 static int __sctp_connect(struct sock
*sk
,
1078 struct sockaddr
*kaddrs
,
1079 int addrs_size
, int flags
,
1080 sctp_assoc_t
*assoc_id
)
1082 struct net
*net
= sock_net(sk
);
1083 struct sctp_sock
*sp
;
1084 struct sctp_endpoint
*ep
;
1085 struct sctp_association
*asoc
= NULL
;
1086 struct sctp_association
*asoc2
;
1087 struct sctp_transport
*transport
;
1089 enum sctp_scope scope
;
1094 union sctp_addr
*sa_addr
= NULL
;
1096 unsigned short port
;
1101 /* connect() cannot be done on a socket that is already in ESTABLISHED
1102 * state - UDP-style peeled off socket or a TCP-style socket that
1103 * is already connected.
1104 * It cannot be done even on a TCP-style listening socket.
1106 if (sctp_sstate(sk
, ESTABLISHED
) || sctp_sstate(sk
, CLOSING
) ||
1107 (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))) {
1112 /* Walk through the addrs buffer and count the number of addresses. */
1114 while (walk_size
< addrs_size
) {
1117 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
) {
1123 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
1125 /* If the address family is not supported or if this address
1126 * causes the address buffer to overflow return EINVAL.
1128 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
1133 port
= ntohs(sa_addr
->v4
.sin_port
);
1135 /* Save current address so we can work with it */
1136 memcpy(&to
, sa_addr
, af
->sockaddr_len
);
1138 err
= sctp_verify_addr(sk
, &to
, af
->sockaddr_len
);
1142 /* Make sure the destination port is correctly set
1145 if (asoc
&& asoc
->peer
.port
&& asoc
->peer
.port
!= port
) {
1150 /* Check if there already is a matching association on the
1151 * endpoint (other than the one created here).
1153 asoc2
= sctp_endpoint_lookup_assoc(ep
, &to
, &transport
);
1154 if (asoc2
&& asoc2
!= asoc
) {
1155 if (asoc2
->state
>= SCTP_STATE_ESTABLISHED
)
1162 /* If we could not find a matching association on the endpoint,
1163 * make sure that there is no peeled-off association matching
1164 * the peer address even on another socket.
1166 if (sctp_endpoint_is_peeled_off(ep
, &to
)) {
1167 err
= -EADDRNOTAVAIL
;
1172 /* If a bind() or sctp_bindx() is not called prior to
1173 * an sctp_connectx() call, the system picks an
1174 * ephemeral port and will choose an address set
1175 * equivalent to binding with a wildcard address.
1177 if (!ep
->base
.bind_addr
.port
) {
1178 if (sctp_autobind(sk
)) {
1184 * If an unprivileged user inherits a 1-many
1185 * style socket with open associations on a
1186 * privileged port, it MAY be permitted to
1187 * accept new associations, but it SHOULD NOT
1188 * be permitted to open new associations.
1190 if (ep
->base
.bind_addr
.port
<
1191 inet_prot_sock(net
) &&
1192 !ns_capable(net
->user_ns
,
1193 CAP_NET_BIND_SERVICE
)) {
1199 scope
= sctp_scope(&to
);
1200 asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1206 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, scope
,
1214 /* Prime the peer's transport structures. */
1215 transport
= sctp_assoc_add_peer(asoc
, &to
, GFP_KERNEL
,
1223 addr_buf
+= af
->sockaddr_len
;
1224 walk_size
+= af
->sockaddr_len
;
1227 /* In case the user of sctp_connectx() wants an association
1228 * id back, assign one now.
1231 err
= sctp_assoc_set_id(asoc
, GFP_KERNEL
);
1236 err
= sctp_primitive_ASSOCIATE(net
, asoc
, NULL
);
1241 /* Initialize sk's dport and daddr for getpeername() */
1242 inet_sk(sk
)->inet_dport
= htons(asoc
->peer
.port
);
1243 sp
->pf
->to_sk_daddr(sa_addr
, sk
);
1246 timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
1249 *assoc_id
= asoc
->assoc_id
;
1250 err
= sctp_wait_for_connect(asoc
, &timeo
);
1251 /* Note: the asoc may be freed after the return of
1252 * sctp_wait_for_connect.
1255 /* Don't free association on exit. */
1259 pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1260 __func__
, asoc
, kaddrs
, err
);
1263 /* sctp_primitive_ASSOCIATE may have added this association
1264 * To the hash table, try to unhash it, just in case, its a noop
1265 * if it wasn't hashed so we're safe
1267 sctp_association_free(asoc
);
1272 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1275 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1276 * sctp_assoc_t *asoc);
1278 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1279 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1280 * or IPv6 addresses.
1282 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1283 * Section 3.1.2 for this usage.
1285 * addrs is a pointer to an array of one or more socket addresses. Each
1286 * address is contained in its appropriate structure (i.e. struct
1287 * sockaddr_in or struct sockaddr_in6) the family of the address type
1288 * must be used to distengish the address length (note that this
1289 * representation is termed a "packed array" of addresses). The caller
1290 * specifies the number of addresses in the array with addrcnt.
1292 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1293 * the association id of the new association. On failure, sctp_connectx()
1294 * returns -1, and sets errno to the appropriate error code. The assoc_id
1295 * is not touched by the kernel.
1297 * For SCTP, the port given in each socket address must be the same, or
1298 * sctp_connectx() will fail, setting errno to EINVAL.
1300 * An application can use sctp_connectx to initiate an association with
1301 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1302 * allows a caller to specify multiple addresses at which a peer can be
1303 * reached. The way the SCTP stack uses the list of addresses to set up
1304 * the association is implementation dependent. This function only
1305 * specifies that the stack will try to make use of all the addresses in
1306 * the list when needed.
1308 * Note that the list of addresses passed in is only used for setting up
1309 * the association. It does not necessarily equal the set of addresses
1310 * the peer uses for the resulting association. If the caller wants to
1311 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1312 * retrieve them after the association has been set up.
1314 * Basically do nothing but copying the addresses from user to kernel
1315 * land and invoking either sctp_connectx(). This is used for tunneling
1316 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1318 * We don't use copy_from_user() for optimization: we first do the
1319 * sanity checks (buffer size -fast- and access check-healthy
1320 * pointer); if all of those succeed, then we can alloc the memory
1321 * (expensive operation) needed to copy the data to kernel. Then we do
1322 * the copying without checking the user space area
1323 * (__copy_from_user()).
1325 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1328 * sk The sk of the socket
1329 * addrs The pointer to the addresses in user land
1330 * addrssize Size of the addrs buffer
1332 * Returns >=0 if ok, <0 errno code on error.
1334 static int __sctp_setsockopt_connectx(struct sock
*sk
,
1335 struct sockaddr __user
*addrs
,
1337 sctp_assoc_t
*assoc_id
)
1339 struct sockaddr
*kaddrs
;
1340 gfp_t gfp
= GFP_KERNEL
;
1341 int err
= 0, flags
= 0;
1343 pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1344 __func__
, sk
, addrs
, addrs_size
);
1346 if (unlikely(addrs_size
<= 0))
1349 /* Check the user passed a healthy pointer. */
1350 if (unlikely(!access_ok(VERIFY_READ
, addrs
, addrs_size
)))
1353 /* Alloc space for the address array in kernel memory. */
1354 if (sk
->sk_socket
->file
)
1355 gfp
= GFP_USER
| __GFP_NOWARN
;
1356 kaddrs
= kmalloc(addrs_size
, gfp
);
1357 if (unlikely(!kaddrs
))
1360 if (__copy_from_user(kaddrs
, addrs
, addrs_size
)) {
1365 /* in-kernel sockets don't generally have a file allocated to them
1366 * if all they do is call sock_create_kern().
1368 if (sk
->sk_socket
->file
)
1369 flags
= sk
->sk_socket
->file
->f_flags
;
1371 err
= __sctp_connect(sk
, kaddrs
, addrs_size
, flags
, assoc_id
);
1379 * This is an older interface. It's kept for backward compatibility
1380 * to the option that doesn't provide association id.
1382 static int sctp_setsockopt_connectx_old(struct sock
*sk
,
1383 struct sockaddr __user
*addrs
,
1386 return __sctp_setsockopt_connectx(sk
, addrs
, addrs_size
, NULL
);
1390 * New interface for the API. The since the API is done with a socket
1391 * option, to make it simple we feed back the association id is as a return
1392 * indication to the call. Error is always negative and association id is
1395 static int sctp_setsockopt_connectx(struct sock
*sk
,
1396 struct sockaddr __user
*addrs
,
1399 sctp_assoc_t assoc_id
= 0;
1402 err
= __sctp_setsockopt_connectx(sk
, addrs
, addrs_size
, &assoc_id
);
1411 * New (hopefully final) interface for the API.
1412 * We use the sctp_getaddrs_old structure so that use-space library
1413 * can avoid any unnecessary allocations. The only different part
1414 * is that we store the actual length of the address buffer into the
1415 * addrs_num structure member. That way we can re-use the existing
1418 #ifdef CONFIG_COMPAT
1419 struct compat_sctp_getaddrs_old
{
1420 sctp_assoc_t assoc_id
;
1422 compat_uptr_t addrs
; /* struct sockaddr * */
1426 static int sctp_getsockopt_connectx3(struct sock
*sk
, int len
,
1427 char __user
*optval
,
1430 struct sctp_getaddrs_old param
;
1431 sctp_assoc_t assoc_id
= 0;
1434 #ifdef CONFIG_COMPAT
1435 if (in_compat_syscall()) {
1436 struct compat_sctp_getaddrs_old param32
;
1438 if (len
< sizeof(param32
))
1440 if (copy_from_user(¶m32
, optval
, sizeof(param32
)))
1443 param
.assoc_id
= param32
.assoc_id
;
1444 param
.addr_num
= param32
.addr_num
;
1445 param
.addrs
= compat_ptr(param32
.addrs
);
1449 if (len
< sizeof(param
))
1451 if (copy_from_user(¶m
, optval
, sizeof(param
)))
1455 err
= __sctp_setsockopt_connectx(sk
, (struct sockaddr __user
*)
1456 param
.addrs
, param
.addr_num
,
1458 if (err
== 0 || err
== -EINPROGRESS
) {
1459 if (copy_to_user(optval
, &assoc_id
, sizeof(assoc_id
)))
1461 if (put_user(sizeof(assoc_id
), optlen
))
1468 /* API 3.1.4 close() - UDP Style Syntax
1469 * Applications use close() to perform graceful shutdown (as described in
1470 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1471 * by a UDP-style socket.
1475 * ret = close(int sd);
1477 * sd - the socket descriptor of the associations to be closed.
1479 * To gracefully shutdown a specific association represented by the
1480 * UDP-style socket, an application should use the sendmsg() call,
1481 * passing no user data, but including the appropriate flag in the
1482 * ancillary data (see Section xxxx).
1484 * If sd in the close() call is a branched-off socket representing only
1485 * one association, the shutdown is performed on that association only.
1487 * 4.1.6 close() - TCP Style Syntax
1489 * Applications use close() to gracefully close down an association.
1493 * int close(int sd);
1495 * sd - the socket descriptor of the association to be closed.
1497 * After an application calls close() on a socket descriptor, no further
1498 * socket operations will succeed on that descriptor.
1500 * API 7.1.4 SO_LINGER
1502 * An application using the TCP-style socket can use this option to
1503 * perform the SCTP ABORT primitive. The linger option structure is:
1506 * int l_onoff; // option on/off
1507 * int l_linger; // linger time
1510 * To enable the option, set l_onoff to 1. If the l_linger value is set
1511 * to 0, calling close() is the same as the ABORT primitive. If the
1512 * value is set to a negative value, the setsockopt() call will return
1513 * an error. If the value is set to a positive value linger_time, the
1514 * close() can be blocked for at most linger_time ms. If the graceful
1515 * shutdown phase does not finish during this period, close() will
1516 * return but the graceful shutdown phase continues in the system.
1518 static void sctp_close(struct sock
*sk
, long timeout
)
1520 struct net
*net
= sock_net(sk
);
1521 struct sctp_endpoint
*ep
;
1522 struct sctp_association
*asoc
;
1523 struct list_head
*pos
, *temp
;
1524 unsigned int data_was_unread
;
1526 pr_debug("%s: sk:%p, timeout:%ld\n", __func__
, sk
, timeout
);
1528 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
1529 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1530 sk
->sk_state
= SCTP_SS_CLOSING
;
1532 ep
= sctp_sk(sk
)->ep
;
1534 /* Clean up any skbs sitting on the receive queue. */
1535 data_was_unread
= sctp_queue_purge_ulpevents(&sk
->sk_receive_queue
);
1536 data_was_unread
+= sctp_queue_purge_ulpevents(&sctp_sk(sk
)->pd_lobby
);
1538 /* Walk all associations on an endpoint. */
1539 list_for_each_safe(pos
, temp
, &ep
->asocs
) {
1540 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
1542 if (sctp_style(sk
, TCP
)) {
1543 /* A closed association can still be in the list if
1544 * it belongs to a TCP-style listening socket that is
1545 * not yet accepted. If so, free it. If not, send an
1546 * ABORT or SHUTDOWN based on the linger options.
1548 if (sctp_state(asoc
, CLOSED
)) {
1549 sctp_association_free(asoc
);
1554 if (data_was_unread
|| !skb_queue_empty(&asoc
->ulpq
.lobby
) ||
1555 !skb_queue_empty(&asoc
->ulpq
.reasm
) ||
1556 (sock_flag(sk
, SOCK_LINGER
) && !sk
->sk_lingertime
)) {
1557 struct sctp_chunk
*chunk
;
1559 chunk
= sctp_make_abort_user(asoc
, NULL
, 0);
1560 sctp_primitive_ABORT(net
, asoc
, chunk
);
1562 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
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
);
1569 /* This will run the backlog queue. */
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.
1577 spin_lock_bh(&net
->sctp
.addr_wq_lock
);
1578 bh_lock_sock_nested(sk
);
1580 /* Hold the sock, since sk_common_release() will put sock_put()
1581 * and we have just a little more cleanup.
1584 sk_common_release(sk
);
1587 spin_unlock_bh(&net
->sctp
.addr_wq_lock
);
1591 SCTP_DBG_OBJCNT_DEC(sock
);
1594 /* Handle EPIPE error. */
1595 static int sctp_error(struct sock
*sk
, int flags
, int err
)
1598 err
= sock_error(sk
) ? : -EPIPE
;
1599 if (err
== -EPIPE
&& !(flags
& MSG_NOSIGNAL
))
1600 send_sig(SIGPIPE
, current
, 0);
1604 /* API 3.1.3 sendmsg() - UDP Style Syntax
1606 * An application uses sendmsg() and recvmsg() calls to transmit data to
1607 * and receive data from its peer.
1609 * ssize_t sendmsg(int socket, const struct msghdr *message,
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.
1616 * See Section 5 for complete description of the data
1619 * flags - flags sent or received with the user message, see Section
1620 * 5 for complete description of the flags.
1622 * Note: This function could use a rewrite especially when explicit
1623 * connect support comes in.
1625 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1627 static int sctp_msghdr_parse(const struct msghdr
*msg
,
1628 struct sctp_cmsgs
*cmsgs
);
1630 static int sctp_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t msg_len
)
1632 struct net
*net
= sock_net(sk
);
1633 struct sctp_sock
*sp
;
1634 struct sctp_endpoint
*ep
;
1635 struct sctp_association
*new_asoc
= NULL
, *asoc
= NULL
;
1636 struct sctp_transport
*transport
, *chunk_tp
;
1637 struct sctp_chunk
*chunk
;
1639 struct sockaddr
*msg_name
= NULL
;
1640 struct sctp_sndrcvinfo default_sinfo
;
1641 struct sctp_sndrcvinfo
*sinfo
;
1642 struct sctp_initmsg
*sinit
;
1643 sctp_assoc_t associd
= 0;
1644 struct sctp_cmsgs cmsgs
= { NULL
};
1645 enum sctp_scope scope
;
1646 bool fill_sinfo_ttl
= false, wait_connect
= false;
1647 struct sctp_datamsg
*datamsg
;
1648 int msg_flags
= msg
->msg_flags
;
1649 __u16 sinfo_flags
= 0;
1657 pr_debug("%s: sk:%p, msg:%p, msg_len:%zu ep:%p\n", __func__
, sk
,
1660 /* We cannot send a message over a TCP-style listening socket. */
1661 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
)) {
1666 /* Parse out the SCTP CMSGs. */
1667 err
= sctp_msghdr_parse(msg
, &cmsgs
);
1669 pr_debug("%s: msghdr parse err:%x\n", __func__
, err
);
1673 /* Fetch the destination address for this packet. This
1674 * address only selects the association--it is not necessarily
1675 * the address we will send to.
1676 * For a peeled-off socket, msg_name is ignored.
1678 if (!sctp_style(sk
, UDP_HIGH_BANDWIDTH
) && msg
->msg_name
) {
1679 int msg_namelen
= msg
->msg_namelen
;
1681 err
= sctp_verify_addr(sk
, (union sctp_addr
*)msg
->msg_name
,
1686 if (msg_namelen
> sizeof(to
))
1687 msg_namelen
= sizeof(to
);
1688 memcpy(&to
, msg
->msg_name
, msg_namelen
);
1689 msg_name
= msg
->msg_name
;
1693 if (cmsgs
.sinfo
!= NULL
) {
1694 memset(&default_sinfo
, 0, sizeof(default_sinfo
));
1695 default_sinfo
.sinfo_stream
= cmsgs
.sinfo
->snd_sid
;
1696 default_sinfo
.sinfo_flags
= cmsgs
.sinfo
->snd_flags
;
1697 default_sinfo
.sinfo_ppid
= cmsgs
.sinfo
->snd_ppid
;
1698 default_sinfo
.sinfo_context
= cmsgs
.sinfo
->snd_context
;
1699 default_sinfo
.sinfo_assoc_id
= cmsgs
.sinfo
->snd_assoc_id
;
1701 sinfo
= &default_sinfo
;
1702 fill_sinfo_ttl
= true;
1704 sinfo
= cmsgs
.srinfo
;
1706 /* Did the user specify SNDINFO/SNDRCVINFO? */
1708 sinfo_flags
= sinfo
->sinfo_flags
;
1709 associd
= sinfo
->sinfo_assoc_id
;
1712 pr_debug("%s: msg_len:%zu, sinfo_flags:0x%x\n", __func__
,
1713 msg_len
, sinfo_flags
);
1715 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1716 if (sctp_style(sk
, TCP
) && (sinfo_flags
& (SCTP_EOF
| SCTP_ABORT
))) {
1721 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1722 * length messages when SCTP_EOF|SCTP_ABORT is not set.
1723 * If SCTP_ABORT is set, the message length could be non zero with
1724 * the msg_iov set to the user abort reason.
1726 if (((sinfo_flags
& SCTP_EOF
) && (msg_len
> 0)) ||
1727 (!(sinfo_flags
& (SCTP_EOF
|SCTP_ABORT
)) && (msg_len
== 0))) {
1732 /* If SCTP_ADDR_OVER is set, there must be an address
1733 * specified in msg_name.
1735 if ((sinfo_flags
& SCTP_ADDR_OVER
) && (!msg
->msg_name
)) {
1742 pr_debug("%s: about to look up association\n", __func__
);
1746 /* If a msg_name has been specified, assume this is to be used. */
1748 /* Look for a matching association on the endpoint. */
1749 asoc
= sctp_endpoint_lookup_assoc(ep
, &to
, &transport
);
1751 /* If we could not find a matching association on the
1752 * endpoint, make sure that it is not a TCP-style
1753 * socket that already has an association or there is
1754 * no peeled-off association on another socket.
1757 ((sctp_style(sk
, TCP
) &&
1758 (sctp_sstate(sk
, ESTABLISHED
) ||
1759 sctp_sstate(sk
, CLOSING
))) ||
1760 sctp_endpoint_is_peeled_off(ep
, &to
))) {
1761 err
= -EADDRNOTAVAIL
;
1765 asoc
= sctp_id2assoc(sk
, associd
);
1773 pr_debug("%s: just looked up association:%p\n", __func__
, asoc
);
1775 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1776 * socket that has an association in CLOSED state. This can
1777 * happen when an accepted socket has an association that is
1780 if (sctp_state(asoc
, CLOSED
) && sctp_style(sk
, TCP
)) {
1785 if (sinfo_flags
& SCTP_EOF
) {
1786 pr_debug("%s: shutting down association:%p\n",
1789 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
1793 if (sinfo_flags
& SCTP_ABORT
) {
1795 chunk
= sctp_make_abort_user(asoc
, msg
, msg_len
);
1801 pr_debug("%s: aborting association:%p\n",
1804 sctp_primitive_ABORT(net
, asoc
, chunk
);
1810 /* Do we need to create the association? */
1812 pr_debug("%s: there is no association yet\n", __func__
);
1814 if (sinfo_flags
& (SCTP_EOF
| SCTP_ABORT
)) {
1819 /* Check for invalid stream against the stream counts,
1820 * either the default or the user specified stream counts.
1823 if (!sinit
|| !sinit
->sinit_num_ostreams
) {
1824 /* Check against the defaults. */
1825 if (sinfo
->sinfo_stream
>=
1826 sp
->initmsg
.sinit_num_ostreams
) {
1831 /* Check against the requested. */
1832 if (sinfo
->sinfo_stream
>=
1833 sinit
->sinit_num_ostreams
) {
1841 * API 3.1.2 bind() - UDP Style Syntax
1842 * If a bind() or sctp_bindx() is not called prior to a
1843 * sendmsg() call that initiates a new association, the
1844 * system picks an ephemeral port and will choose an address
1845 * set equivalent to binding with a wildcard address.
1847 if (!ep
->base
.bind_addr
.port
) {
1848 if (sctp_autobind(sk
)) {
1854 * If an unprivileged user inherits a one-to-many
1855 * style socket with open associations on a privileged
1856 * port, it MAY be permitted to accept new associations,
1857 * but it SHOULD NOT be permitted to open new
1860 if (ep
->base
.bind_addr
.port
< inet_prot_sock(net
) &&
1861 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
)) {
1867 scope
= sctp_scope(&to
);
1868 new_asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1874 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, scope
, GFP_KERNEL
);
1880 /* If the SCTP_INIT ancillary data is specified, set all
1881 * the association init values accordingly.
1884 if (sinit
->sinit_num_ostreams
) {
1885 __u16 outcnt
= sinit
->sinit_num_ostreams
;
1887 asoc
->c
.sinit_num_ostreams
= outcnt
;
1888 /* outcnt has been changed, so re-init stream */
1889 err
= sctp_stream_init(&asoc
->stream
, outcnt
, 0,
1894 if (sinit
->sinit_max_instreams
) {
1895 asoc
->c
.sinit_max_instreams
=
1896 sinit
->sinit_max_instreams
;
1898 if (sinit
->sinit_max_attempts
) {
1899 asoc
->max_init_attempts
1900 = sinit
->sinit_max_attempts
;
1902 if (sinit
->sinit_max_init_timeo
) {
1903 asoc
->max_init_timeo
=
1904 msecs_to_jiffies(sinit
->sinit_max_init_timeo
);
1908 /* Prime the peer's transport structures. */
1909 transport
= sctp_assoc_add_peer(asoc
, &to
, GFP_KERNEL
, SCTP_UNKNOWN
);
1916 /* ASSERT: we have a valid association at this point. */
1917 pr_debug("%s: we have a valid association\n", __func__
);
1920 /* If the user didn't specify SNDINFO/SNDRCVINFO, make up
1921 * one with some defaults.
1923 memset(&default_sinfo
, 0, sizeof(default_sinfo
));
1924 default_sinfo
.sinfo_stream
= asoc
->default_stream
;
1925 default_sinfo
.sinfo_flags
= asoc
->default_flags
;
1926 default_sinfo
.sinfo_ppid
= asoc
->default_ppid
;
1927 default_sinfo
.sinfo_context
= asoc
->default_context
;
1928 default_sinfo
.sinfo_timetolive
= asoc
->default_timetolive
;
1929 default_sinfo
.sinfo_assoc_id
= sctp_assoc2id(asoc
);
1931 sinfo
= &default_sinfo
;
1932 } else if (fill_sinfo_ttl
) {
1933 /* In case SNDINFO was specified, we still need to fill
1934 * it with a default ttl from the assoc here.
1936 sinfo
->sinfo_timetolive
= asoc
->default_timetolive
;
1939 /* API 7.1.7, the sndbuf size per association bounds the
1940 * maximum size of data that can be sent in a single send call.
1942 if (msg_len
> sk
->sk_sndbuf
) {
1947 if (asoc
->pmtu_pending
)
1948 sctp_assoc_pending_pmtu(asoc
);
1950 /* If fragmentation is disabled and the message length exceeds the
1951 * association fragmentation point, return EMSGSIZE. The I-D
1952 * does not specify what this error is, but this looks like
1955 if (sctp_sk(sk
)->disable_fragments
&& (msg_len
> asoc
->frag_point
)) {
1960 /* Check for invalid stream. */
1961 if (sinfo
->sinfo_stream
>= asoc
->stream
.outcnt
) {
1966 if (sctp_wspace(asoc
) < msg_len
)
1967 sctp_prsctp_prune(asoc
, sinfo
, msg_len
- sctp_wspace(asoc
));
1969 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1970 if (!sctp_wspace(asoc
)) {
1971 /* sk can be changed by peel off when waiting for buf. */
1972 err
= sctp_wait_for_sndbuf(asoc
, &timeo
, msg_len
);
1974 if (err
== -ESRCH
) {
1975 /* asoc is already dead. */
1983 /* If an address is passed with the sendto/sendmsg call, it is used
1984 * to override the primary destination address in the TCP model, or
1985 * when SCTP_ADDR_OVER flag is set in the UDP model.
1987 if ((sctp_style(sk
, TCP
) && msg_name
) ||
1988 (sinfo_flags
& SCTP_ADDR_OVER
)) {
1989 chunk_tp
= sctp_assoc_lookup_paddr(asoc
, &to
);
1997 /* Auto-connect, if we aren't connected already. */
1998 if (sctp_state(asoc
, CLOSED
)) {
1999 err
= sctp_primitive_ASSOCIATE(net
, asoc
, NULL
);
2003 wait_connect
= true;
2004 pr_debug("%s: we associated primitively\n", __func__
);
2007 /* Break the message into multiple chunks of maximum size. */
2008 datamsg
= sctp_datamsg_from_user(asoc
, sinfo
, &msg
->msg_iter
);
2009 if (IS_ERR(datamsg
)) {
2010 err
= PTR_ERR(datamsg
);
2013 asoc
->force_delay
= !!(msg
->msg_flags
& MSG_MORE
);
2015 /* Now send the (possibly) fragmented message. */
2016 list_for_each_entry(chunk
, &datamsg
->chunks
, frag_list
) {
2017 sctp_chunk_hold(chunk
);
2019 /* Do accounting for the write space. */
2020 sctp_set_owner_w(chunk
);
2022 chunk
->transport
= chunk_tp
;
2025 /* Send it to the lower layers. Note: all chunks
2026 * must either fail or succeed. The lower layer
2027 * works that way today. Keep it that way or this
2030 err
= sctp_primitive_SEND(net
, asoc
, datamsg
);
2031 /* Did the lower layer accept the chunk? */
2033 sctp_datamsg_free(datamsg
);
2037 pr_debug("%s: we sent primitively\n", __func__
);
2039 sctp_datamsg_put(datamsg
);
2042 if (unlikely(wait_connect
)) {
2043 timeo
= sock_sndtimeo(sk
, msg_flags
& MSG_DONTWAIT
);
2044 sctp_wait_for_connect(asoc
, &timeo
);
2047 /* If we are already past ASSOCIATE, the lower
2048 * layers are responsible for association cleanup.
2054 sctp_association_free(asoc
);
2059 return sctp_error(sk
, msg_flags
, err
);
2066 err
= sock_error(sk
);
2076 /* This is an extended version of skb_pull() that removes the data from the
2077 * start of a skb even when data is spread across the list of skb's in the
2078 * frag_list. len specifies the total amount of data that needs to be removed.
2079 * when 'len' bytes could be removed from the skb, it returns 0.
2080 * If 'len' exceeds the total skb length, it returns the no. of bytes that
2081 * could not be removed.
2083 static int sctp_skb_pull(struct sk_buff
*skb
, int len
)
2085 struct sk_buff
*list
;
2086 int skb_len
= skb_headlen(skb
);
2089 if (len
<= skb_len
) {
2090 __skb_pull(skb
, len
);
2094 __skb_pull(skb
, skb_len
);
2096 skb_walk_frags(skb
, list
) {
2097 rlen
= sctp_skb_pull(list
, len
);
2098 skb
->len
-= (len
-rlen
);
2099 skb
->data_len
-= (len
-rlen
);
2110 /* API 3.1.3 recvmsg() - UDP Style Syntax
2112 * ssize_t recvmsg(int socket, struct msghdr *message,
2115 * socket - the socket descriptor of the endpoint.
2116 * message - pointer to the msghdr structure which contains a single
2117 * user message and possibly some ancillary data.
2119 * See Section 5 for complete description of the data
2122 * flags - flags sent or received with the user message, see Section
2123 * 5 for complete description of the flags.
2125 static int sctp_recvmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
,
2126 int noblock
, int flags
, int *addr_len
)
2128 struct sctp_ulpevent
*event
= NULL
;
2129 struct sctp_sock
*sp
= sctp_sk(sk
);
2130 struct sk_buff
*skb
, *head_skb
;
2135 pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2136 "addr_len:%p)\n", __func__
, sk
, msg
, len
, noblock
, flags
,
2141 if (sctp_style(sk
, TCP
) && !sctp_sstate(sk
, ESTABLISHED
) &&
2142 !sctp_sstate(sk
, CLOSING
) && !sctp_sstate(sk
, CLOSED
)) {
2147 skb
= sctp_skb_recv_datagram(sk
, flags
, noblock
, &err
);
2151 /* Get the total length of the skb including any skb's in the
2160 err
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
2162 event
= sctp_skb2event(skb
);
2167 if (event
->chunk
&& event
->chunk
->head_skb
)
2168 head_skb
= event
->chunk
->head_skb
;
2171 sock_recv_ts_and_drops(msg
, sk
, head_skb
);
2172 if (sctp_ulpevent_is_notification(event
)) {
2173 msg
->msg_flags
|= MSG_NOTIFICATION
;
2174 sp
->pf
->event_msgname(event
, msg
->msg_name
, addr_len
);
2176 sp
->pf
->skb_msgname(head_skb
, msg
->msg_name
, addr_len
);
2179 /* Check if we allow SCTP_NXTINFO. */
2180 if (sp
->recvnxtinfo
)
2181 sctp_ulpevent_read_nxtinfo(event
, msg
, sk
);
2182 /* Check if we allow SCTP_RCVINFO. */
2183 if (sp
->recvrcvinfo
)
2184 sctp_ulpevent_read_rcvinfo(event
, msg
);
2185 /* Check if we allow SCTP_SNDRCVINFO. */
2186 if (sp
->subscribe
.sctp_data_io_event
)
2187 sctp_ulpevent_read_sndrcvinfo(event
, msg
);
2191 /* If skb's length exceeds the user's buffer, update the skb and
2192 * push it back to the receive_queue so that the next call to
2193 * recvmsg() will return the remaining data. Don't set MSG_EOR.
2195 if (skb_len
> copied
) {
2196 msg
->msg_flags
&= ~MSG_EOR
;
2197 if (flags
& MSG_PEEK
)
2199 sctp_skb_pull(skb
, copied
);
2200 skb_queue_head(&sk
->sk_receive_queue
, skb
);
2202 /* When only partial message is copied to the user, increase
2203 * rwnd by that amount. If all the data in the skb is read,
2204 * rwnd is updated when the event is freed.
2206 if (!sctp_ulpevent_is_notification(event
))
2207 sctp_assoc_rwnd_increase(event
->asoc
, copied
);
2209 } else if ((event
->msg_flags
& MSG_NOTIFICATION
) ||
2210 (event
->msg_flags
& MSG_EOR
))
2211 msg
->msg_flags
|= MSG_EOR
;
2213 msg
->msg_flags
&= ~MSG_EOR
;
2216 if (flags
& MSG_PEEK
) {
2217 /* Release the skb reference acquired after peeking the skb in
2218 * sctp_skb_recv_datagram().
2222 /* Free the event which includes releasing the reference to
2223 * the owner of the skb, freeing the skb and updating the
2226 sctp_ulpevent_free(event
);
2233 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2235 * This option is a on/off flag. If enabled no SCTP message
2236 * fragmentation will be performed. Instead if a message being sent
2237 * exceeds the current PMTU size, the message will NOT be sent and
2238 * instead a error will be indicated to the user.
2240 static int sctp_setsockopt_disable_fragments(struct sock
*sk
,
2241 char __user
*optval
,
2242 unsigned int optlen
)
2246 if (optlen
< sizeof(int))
2249 if (get_user(val
, (int __user
*)optval
))
2252 sctp_sk(sk
)->disable_fragments
= (val
== 0) ? 0 : 1;
2257 static int sctp_setsockopt_events(struct sock
*sk
, char __user
*optval
,
2258 unsigned int optlen
)
2260 struct sctp_association
*asoc
;
2261 struct sctp_ulpevent
*event
;
2263 if (optlen
> sizeof(struct sctp_event_subscribe
))
2265 if (copy_from_user(&sctp_sk(sk
)->subscribe
, optval
, optlen
))
2268 /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2269 * if there is no data to be sent or retransmit, the stack will
2270 * immediately send up this notification.
2272 if (sctp_ulpevent_type_enabled(SCTP_SENDER_DRY_EVENT
,
2273 &sctp_sk(sk
)->subscribe
)) {
2274 asoc
= sctp_id2assoc(sk
, 0);
2276 if (asoc
&& sctp_outq_is_empty(&asoc
->outqueue
)) {
2277 event
= sctp_ulpevent_make_sender_dry_event(asoc
,
2282 sctp_ulpq_tail_event(&asoc
->ulpq
, event
);
2289 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2291 * This socket option is applicable to the UDP-style socket only. When
2292 * set it will cause associations that are idle for more than the
2293 * specified number of seconds to automatically close. An association
2294 * being idle is defined an association that has NOT sent or received
2295 * user data. The special value of '0' indicates that no automatic
2296 * close of any associations should be performed. The option expects an
2297 * integer defining the number of seconds of idle time before an
2298 * association is closed.
2300 static int sctp_setsockopt_autoclose(struct sock
*sk
, char __user
*optval
,
2301 unsigned int optlen
)
2303 struct sctp_sock
*sp
= sctp_sk(sk
);
2304 struct net
*net
= sock_net(sk
);
2306 /* Applicable to UDP-style socket only */
2307 if (sctp_style(sk
, TCP
))
2309 if (optlen
!= sizeof(int))
2311 if (copy_from_user(&sp
->autoclose
, optval
, optlen
))
2314 if (sp
->autoclose
> net
->sctp
.max_autoclose
)
2315 sp
->autoclose
= net
->sctp
.max_autoclose
;
2320 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2322 * Applications can enable or disable heartbeats for any peer address of
2323 * an association, modify an address's heartbeat interval, force a
2324 * heartbeat to be sent immediately, and adjust the address's maximum
2325 * number of retransmissions sent before an address is considered
2326 * unreachable. The following structure is used to access and modify an
2327 * address's parameters:
2329 * struct sctp_paddrparams {
2330 * sctp_assoc_t spp_assoc_id;
2331 * struct sockaddr_storage spp_address;
2332 * uint32_t spp_hbinterval;
2333 * uint16_t spp_pathmaxrxt;
2334 * uint32_t spp_pathmtu;
2335 * uint32_t spp_sackdelay;
2336 * uint32_t spp_flags;
2339 * spp_assoc_id - (one-to-many style socket) This is filled in the
2340 * application, and identifies the association for
2342 * spp_address - This specifies which address is of interest.
2343 * spp_hbinterval - This contains the value of the heartbeat interval,
2344 * in milliseconds. If a value of zero
2345 * is present in this field then no changes are to
2346 * be made to this parameter.
2347 * spp_pathmaxrxt - This contains the maximum number of
2348 * retransmissions before this address shall be
2349 * considered unreachable. If a value of zero
2350 * is present in this field then no changes are to
2351 * be made to this parameter.
2352 * spp_pathmtu - When Path MTU discovery is disabled the value
2353 * specified here will be the "fixed" path mtu.
2354 * Note that if the spp_address field is empty
2355 * then all associations on this address will
2356 * have this fixed path mtu set upon them.
2358 * spp_sackdelay - When delayed sack is enabled, this value specifies
2359 * the number of milliseconds that sacks will be delayed
2360 * for. This value will apply to all addresses of an
2361 * association if the spp_address field is empty. Note
2362 * also, that if delayed sack is enabled and this
2363 * value is set to 0, no change is made to the last
2364 * recorded delayed sack timer value.
2366 * spp_flags - These flags are used to control various features
2367 * on an association. The flag field may contain
2368 * zero or more of the following options.
2370 * SPP_HB_ENABLE - Enable heartbeats on the
2371 * specified address. Note that if the address
2372 * field is empty all addresses for the association
2373 * have heartbeats enabled upon them.
2375 * SPP_HB_DISABLE - Disable heartbeats on the
2376 * speicifed address. Note that if the address
2377 * field is empty all addresses for the association
2378 * will have their heartbeats disabled. Note also
2379 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2380 * mutually exclusive, only one of these two should
2381 * be specified. Enabling both fields will have
2382 * undetermined results.
2384 * SPP_HB_DEMAND - Request a user initiated heartbeat
2385 * to be made immediately.
2387 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2388 * heartbeat delayis to be set to the value of 0
2391 * SPP_PMTUD_ENABLE - This field will enable PMTU
2392 * discovery upon the specified address. Note that
2393 * if the address feild is empty then all addresses
2394 * on the association are effected.
2396 * SPP_PMTUD_DISABLE - This field will disable PMTU
2397 * discovery upon the specified address. Note that
2398 * if the address feild is empty then all addresses
2399 * on the association are effected. Not also that
2400 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2401 * exclusive. Enabling both will have undetermined
2404 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2405 * on delayed sack. The time specified in spp_sackdelay
2406 * is used to specify the sack delay for this address. Note
2407 * that if spp_address is empty then all addresses will
2408 * enable delayed sack and take on the sack delay
2409 * value specified in spp_sackdelay.
2410 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2411 * off delayed sack. If the spp_address field is blank then
2412 * delayed sack is disabled for the entire association. Note
2413 * also that this field is mutually exclusive to
2414 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2417 static int sctp_apply_peer_addr_params(struct sctp_paddrparams
*params
,
2418 struct sctp_transport
*trans
,
2419 struct sctp_association
*asoc
,
2420 struct sctp_sock
*sp
,
2423 int sackdelay_change
)
2427 if (params
->spp_flags
& SPP_HB_DEMAND
&& trans
) {
2428 struct net
*net
= sock_net(trans
->asoc
->base
.sk
);
2430 error
= sctp_primitive_REQUESTHEARTBEAT(net
, trans
->asoc
, trans
);
2435 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2436 * this field is ignored. Note also that a value of zero indicates
2437 * the current setting should be left unchanged.
2439 if (params
->spp_flags
& SPP_HB_ENABLE
) {
2441 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2442 * set. This lets us use 0 value when this flag
2445 if (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)
2446 params
->spp_hbinterval
= 0;
2448 if (params
->spp_hbinterval
||
2449 (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)) {
2452 msecs_to_jiffies(params
->spp_hbinterval
);
2455 msecs_to_jiffies(params
->spp_hbinterval
);
2457 sp
->hbinterval
= params
->spp_hbinterval
;
2464 trans
->param_flags
=
2465 (trans
->param_flags
& ~SPP_HB
) | hb_change
;
2468 (asoc
->param_flags
& ~SPP_HB
) | hb_change
;
2471 (sp
->param_flags
& ~SPP_HB
) | hb_change
;
2475 /* When Path MTU discovery is disabled the value specified here will
2476 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2477 * include the flag SPP_PMTUD_DISABLE for this field to have any
2480 if ((params
->spp_flags
& SPP_PMTUD_DISABLE
) && params
->spp_pathmtu
) {
2482 trans
->pathmtu
= params
->spp_pathmtu
;
2483 sctp_assoc_sync_pmtu(asoc
);
2485 asoc
->pathmtu
= params
->spp_pathmtu
;
2487 sp
->pathmtu
= params
->spp_pathmtu
;
2493 int update
= (trans
->param_flags
& SPP_PMTUD_DISABLE
) &&
2494 (params
->spp_flags
& SPP_PMTUD_ENABLE
);
2495 trans
->param_flags
=
2496 (trans
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2498 sctp_transport_pmtu(trans
, sctp_opt2sk(sp
));
2499 sctp_assoc_sync_pmtu(asoc
);
2503 (asoc
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2506 (sp
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2510 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2511 * value of this field is ignored. Note also that a value of zero
2512 * indicates the current setting should be left unchanged.
2514 if ((params
->spp_flags
& SPP_SACKDELAY_ENABLE
) && params
->spp_sackdelay
) {
2517 msecs_to_jiffies(params
->spp_sackdelay
);
2520 msecs_to_jiffies(params
->spp_sackdelay
);
2522 sp
->sackdelay
= params
->spp_sackdelay
;
2526 if (sackdelay_change
) {
2528 trans
->param_flags
=
2529 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2533 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2537 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2542 /* Note that a value of zero indicates the current setting should be
2545 if (params
->spp_pathmaxrxt
) {
2547 trans
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2549 asoc
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2551 sp
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2558 static int sctp_setsockopt_peer_addr_params(struct sock
*sk
,
2559 char __user
*optval
,
2560 unsigned int optlen
)
2562 struct sctp_paddrparams params
;
2563 struct sctp_transport
*trans
= NULL
;
2564 struct sctp_association
*asoc
= NULL
;
2565 struct sctp_sock
*sp
= sctp_sk(sk
);
2567 int hb_change
, pmtud_change
, sackdelay_change
;
2569 if (optlen
!= sizeof(struct sctp_paddrparams
))
2572 if (copy_from_user(¶ms
, optval
, optlen
))
2575 /* Validate flags and value parameters. */
2576 hb_change
= params
.spp_flags
& SPP_HB
;
2577 pmtud_change
= params
.spp_flags
& SPP_PMTUD
;
2578 sackdelay_change
= params
.spp_flags
& SPP_SACKDELAY
;
2580 if (hb_change
== SPP_HB
||
2581 pmtud_change
== SPP_PMTUD
||
2582 sackdelay_change
== SPP_SACKDELAY
||
2583 params
.spp_sackdelay
> 500 ||
2584 (params
.spp_pathmtu
&&
2585 params
.spp_pathmtu
< SCTP_DEFAULT_MINSEGMENT
))
2588 /* If an address other than INADDR_ANY is specified, and
2589 * no transport is found, then the request is invalid.
2591 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spp_address
)) {
2592 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
2593 params
.spp_assoc_id
);
2598 /* Get association, if assoc_id != 0 and the socket is a one
2599 * to many style socket, and an association was not found, then
2600 * the id was invalid.
2602 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
2603 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
))
2606 /* Heartbeat demand can only be sent on a transport or
2607 * association, but not a socket.
2609 if (params
.spp_flags
& SPP_HB_DEMAND
&& !trans
&& !asoc
)
2612 /* Process parameters. */
2613 error
= sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2614 hb_change
, pmtud_change
,
2620 /* If changes are for association, also apply parameters to each
2623 if (!trans
&& asoc
) {
2624 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2626 sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2627 hb_change
, pmtud_change
,
2635 static inline __u32
sctp_spp_sackdelay_enable(__u32 param_flags
)
2637 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_ENABLE
;
2640 static inline __u32
sctp_spp_sackdelay_disable(__u32 param_flags
)
2642 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_DISABLE
;
2646 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
2648 * This option will effect the way delayed acks are performed. This
2649 * option allows you to get or set the delayed ack time, in
2650 * milliseconds. It also allows changing the delayed ack frequency.
2651 * Changing the frequency to 1 disables the delayed sack algorithm. If
2652 * the assoc_id is 0, then this sets or gets the endpoints default
2653 * values. If the assoc_id field is non-zero, then the set or get
2654 * effects the specified association for the one to many model (the
2655 * assoc_id field is ignored by the one to one model). Note that if
2656 * sack_delay or sack_freq are 0 when setting this option, then the
2657 * current values will remain unchanged.
2659 * struct sctp_sack_info {
2660 * sctp_assoc_t sack_assoc_id;
2661 * uint32_t sack_delay;
2662 * uint32_t sack_freq;
2665 * sack_assoc_id - This parameter, indicates which association the user
2666 * is performing an action upon. Note that if this field's value is
2667 * zero then the endpoints default value is changed (effecting future
2668 * associations only).
2670 * sack_delay - This parameter contains the number of milliseconds that
2671 * the user is requesting the delayed ACK timer be set to. Note that
2672 * this value is defined in the standard to be between 200 and 500
2675 * sack_freq - This parameter contains the number of packets that must
2676 * be received before a sack is sent without waiting for the delay
2677 * timer to expire. The default value for this is 2, setting this
2678 * value to 1 will disable the delayed sack algorithm.
2681 static int sctp_setsockopt_delayed_ack(struct sock
*sk
,
2682 char __user
*optval
, unsigned int optlen
)
2684 struct sctp_sack_info params
;
2685 struct sctp_transport
*trans
= NULL
;
2686 struct sctp_association
*asoc
= NULL
;
2687 struct sctp_sock
*sp
= sctp_sk(sk
);
2689 if (optlen
== sizeof(struct sctp_sack_info
)) {
2690 if (copy_from_user(¶ms
, optval
, optlen
))
2693 if (params
.sack_delay
== 0 && params
.sack_freq
== 0)
2695 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
2696 pr_warn_ratelimited(DEPRECATED
2698 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2699 "Use struct sctp_sack_info instead\n",
2700 current
->comm
, task_pid_nr(current
));
2701 if (copy_from_user(¶ms
, optval
, optlen
))
2704 if (params
.sack_delay
== 0)
2705 params
.sack_freq
= 1;
2707 params
.sack_freq
= 0;
2711 /* Validate value parameter. */
2712 if (params
.sack_delay
> 500)
2715 /* Get association, if sack_assoc_id != 0 and the socket is a one
2716 * to many style socket, and an association was not found, then
2717 * the id was invalid.
2719 asoc
= sctp_id2assoc(sk
, params
.sack_assoc_id
);
2720 if (!asoc
&& params
.sack_assoc_id
&& sctp_style(sk
, UDP
))
2723 if (params
.sack_delay
) {
2726 msecs_to_jiffies(params
.sack_delay
);
2728 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2730 sp
->sackdelay
= params
.sack_delay
;
2732 sctp_spp_sackdelay_enable(sp
->param_flags
);
2736 if (params
.sack_freq
== 1) {
2739 sctp_spp_sackdelay_disable(asoc
->param_flags
);
2742 sctp_spp_sackdelay_disable(sp
->param_flags
);
2744 } else if (params
.sack_freq
> 1) {
2746 asoc
->sackfreq
= params
.sack_freq
;
2748 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2750 sp
->sackfreq
= params
.sack_freq
;
2752 sctp_spp_sackdelay_enable(sp
->param_flags
);
2756 /* If change is for association, also apply to each transport. */
2758 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2760 if (params
.sack_delay
) {
2762 msecs_to_jiffies(params
.sack_delay
);
2763 trans
->param_flags
=
2764 sctp_spp_sackdelay_enable(trans
->param_flags
);
2766 if (params
.sack_freq
== 1) {
2767 trans
->param_flags
=
2768 sctp_spp_sackdelay_disable(trans
->param_flags
);
2769 } else if (params
.sack_freq
> 1) {
2770 trans
->sackfreq
= params
.sack_freq
;
2771 trans
->param_flags
=
2772 sctp_spp_sackdelay_enable(trans
->param_flags
);
2780 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2782 * Applications can specify protocol parameters for the default association
2783 * initialization. The option name argument to setsockopt() and getsockopt()
2786 * Setting initialization parameters is effective only on an unconnected
2787 * socket (for UDP-style sockets only future associations are effected
2788 * by the change). With TCP-style sockets, this option is inherited by
2789 * sockets derived from a listener socket.
2791 static int sctp_setsockopt_initmsg(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
2793 struct sctp_initmsg sinit
;
2794 struct sctp_sock
*sp
= sctp_sk(sk
);
2796 if (optlen
!= sizeof(struct sctp_initmsg
))
2798 if (copy_from_user(&sinit
, optval
, optlen
))
2801 if (sinit
.sinit_num_ostreams
)
2802 sp
->initmsg
.sinit_num_ostreams
= sinit
.sinit_num_ostreams
;
2803 if (sinit
.sinit_max_instreams
)
2804 sp
->initmsg
.sinit_max_instreams
= sinit
.sinit_max_instreams
;
2805 if (sinit
.sinit_max_attempts
)
2806 sp
->initmsg
.sinit_max_attempts
= sinit
.sinit_max_attempts
;
2807 if (sinit
.sinit_max_init_timeo
)
2808 sp
->initmsg
.sinit_max_init_timeo
= sinit
.sinit_max_init_timeo
;
2814 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2816 * Applications that wish to use the sendto() system call may wish to
2817 * specify a default set of parameters that would normally be supplied
2818 * through the inclusion of ancillary data. This socket option allows
2819 * such an application to set the default sctp_sndrcvinfo structure.
2820 * The application that wishes to use this socket option simply passes
2821 * in to this call the sctp_sndrcvinfo structure defined in Section
2822 * 5.2.2) The input parameters accepted by this call include
2823 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2824 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2825 * to this call if the caller is using the UDP model.
2827 static int sctp_setsockopt_default_send_param(struct sock
*sk
,
2828 char __user
*optval
,
2829 unsigned int optlen
)
2831 struct sctp_sock
*sp
= sctp_sk(sk
);
2832 struct sctp_association
*asoc
;
2833 struct sctp_sndrcvinfo info
;
2835 if (optlen
!= sizeof(info
))
2837 if (copy_from_user(&info
, optval
, optlen
))
2839 if (info
.sinfo_flags
&
2840 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
2841 SCTP_ABORT
| SCTP_EOF
))
2844 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
2845 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
2848 asoc
->default_stream
= info
.sinfo_stream
;
2849 asoc
->default_flags
= info
.sinfo_flags
;
2850 asoc
->default_ppid
= info
.sinfo_ppid
;
2851 asoc
->default_context
= info
.sinfo_context
;
2852 asoc
->default_timetolive
= info
.sinfo_timetolive
;
2854 sp
->default_stream
= info
.sinfo_stream
;
2855 sp
->default_flags
= info
.sinfo_flags
;
2856 sp
->default_ppid
= info
.sinfo_ppid
;
2857 sp
->default_context
= info
.sinfo_context
;
2858 sp
->default_timetolive
= info
.sinfo_timetolive
;
2864 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2865 * (SCTP_DEFAULT_SNDINFO)
2867 static int sctp_setsockopt_default_sndinfo(struct sock
*sk
,
2868 char __user
*optval
,
2869 unsigned int optlen
)
2871 struct sctp_sock
*sp
= sctp_sk(sk
);
2872 struct sctp_association
*asoc
;
2873 struct sctp_sndinfo info
;
2875 if (optlen
!= sizeof(info
))
2877 if (copy_from_user(&info
, optval
, optlen
))
2879 if (info
.snd_flags
&
2880 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
2881 SCTP_ABORT
| SCTP_EOF
))
2884 asoc
= sctp_id2assoc(sk
, info
.snd_assoc_id
);
2885 if (!asoc
&& info
.snd_assoc_id
&& sctp_style(sk
, UDP
))
2888 asoc
->default_stream
= info
.snd_sid
;
2889 asoc
->default_flags
= info
.snd_flags
;
2890 asoc
->default_ppid
= info
.snd_ppid
;
2891 asoc
->default_context
= info
.snd_context
;
2893 sp
->default_stream
= info
.snd_sid
;
2894 sp
->default_flags
= info
.snd_flags
;
2895 sp
->default_ppid
= info
.snd_ppid
;
2896 sp
->default_context
= info
.snd_context
;
2902 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
2904 * Requests that the local SCTP stack use the enclosed peer address as
2905 * the association primary. The enclosed address must be one of the
2906 * association peer's addresses.
2908 static int sctp_setsockopt_primary_addr(struct sock
*sk
, char __user
*optval
,
2909 unsigned int optlen
)
2911 struct sctp_prim prim
;
2912 struct sctp_transport
*trans
;
2914 if (optlen
!= sizeof(struct sctp_prim
))
2917 if (copy_from_user(&prim
, optval
, sizeof(struct sctp_prim
)))
2920 trans
= sctp_addr_id2transport(sk
, &prim
.ssp_addr
, prim
.ssp_assoc_id
);
2924 sctp_assoc_set_primary(trans
->asoc
, trans
);
2930 * 7.1.5 SCTP_NODELAY
2932 * Turn on/off any Nagle-like algorithm. This means that packets are
2933 * generally sent as soon as possible and no unnecessary delays are
2934 * introduced, at the cost of more packets in the network. Expects an
2935 * integer boolean flag.
2937 static int sctp_setsockopt_nodelay(struct sock
*sk
, char __user
*optval
,
2938 unsigned int optlen
)
2942 if (optlen
< sizeof(int))
2944 if (get_user(val
, (int __user
*)optval
))
2947 sctp_sk(sk
)->nodelay
= (val
== 0) ? 0 : 1;
2953 * 7.1.1 SCTP_RTOINFO
2955 * The protocol parameters used to initialize and bound retransmission
2956 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
2957 * and modify these parameters.
2958 * All parameters are time values, in milliseconds. A value of 0, when
2959 * modifying the parameters, indicates that the current value should not
2963 static int sctp_setsockopt_rtoinfo(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
2965 struct sctp_rtoinfo rtoinfo
;
2966 struct sctp_association
*asoc
;
2967 unsigned long rto_min
, rto_max
;
2968 struct sctp_sock
*sp
= sctp_sk(sk
);
2970 if (optlen
!= sizeof (struct sctp_rtoinfo
))
2973 if (copy_from_user(&rtoinfo
, optval
, optlen
))
2976 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
2978 /* Set the values to the specific association */
2979 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
2982 rto_max
= rtoinfo
.srto_max
;
2983 rto_min
= rtoinfo
.srto_min
;
2986 rto_max
= asoc
? msecs_to_jiffies(rto_max
) : rto_max
;
2988 rto_max
= asoc
? asoc
->rto_max
: sp
->rtoinfo
.srto_max
;
2991 rto_min
= asoc
? msecs_to_jiffies(rto_min
) : rto_min
;
2993 rto_min
= asoc
? asoc
->rto_min
: sp
->rtoinfo
.srto_min
;
2995 if (rto_min
> rto_max
)
2999 if (rtoinfo
.srto_initial
!= 0)
3001 msecs_to_jiffies(rtoinfo
.srto_initial
);
3002 asoc
->rto_max
= rto_max
;
3003 asoc
->rto_min
= rto_min
;
3005 /* If there is no association or the association-id = 0
3006 * set the values to the endpoint.
3008 if (rtoinfo
.srto_initial
!= 0)
3009 sp
->rtoinfo
.srto_initial
= rtoinfo
.srto_initial
;
3010 sp
->rtoinfo
.srto_max
= rto_max
;
3011 sp
->rtoinfo
.srto_min
= rto_min
;
3019 * 7.1.2 SCTP_ASSOCINFO
3021 * This option is used to tune the maximum retransmission attempts
3022 * of the association.
3023 * Returns an error if the new association retransmission value is
3024 * greater than the sum of the retransmission value of the peer.
3025 * See [SCTP] for more information.
3028 static int sctp_setsockopt_associnfo(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3031 struct sctp_assocparams assocparams
;
3032 struct sctp_association
*asoc
;
3034 if (optlen
!= sizeof(struct sctp_assocparams
))
3036 if (copy_from_user(&assocparams
, optval
, optlen
))
3039 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
3041 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
3044 /* Set the values to the specific association */
3046 if (assocparams
.sasoc_asocmaxrxt
!= 0) {
3049 struct sctp_transport
*peer_addr
;
3051 list_for_each_entry(peer_addr
, &asoc
->peer
.transport_addr_list
,
3053 path_sum
+= peer_addr
->pathmaxrxt
;
3057 /* Only validate asocmaxrxt if we have more than
3058 * one path/transport. We do this because path
3059 * retransmissions are only counted when we have more
3063 assocparams
.sasoc_asocmaxrxt
> path_sum
)
3066 asoc
->max_retrans
= assocparams
.sasoc_asocmaxrxt
;
3069 if (assocparams
.sasoc_cookie_life
!= 0)
3070 asoc
->cookie_life
= ms_to_ktime(assocparams
.sasoc_cookie_life
);
3072 /* Set the values to the endpoint */
3073 struct sctp_sock
*sp
= sctp_sk(sk
);
3075 if (assocparams
.sasoc_asocmaxrxt
!= 0)
3076 sp
->assocparams
.sasoc_asocmaxrxt
=
3077 assocparams
.sasoc_asocmaxrxt
;
3078 if (assocparams
.sasoc_cookie_life
!= 0)
3079 sp
->assocparams
.sasoc_cookie_life
=
3080 assocparams
.sasoc_cookie_life
;
3086 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3088 * This socket option is a boolean flag which turns on or off mapped V4
3089 * addresses. If this option is turned on and the socket is type
3090 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3091 * If this option is turned off, then no mapping will be done of V4
3092 * addresses and a user will receive both PF_INET6 and PF_INET type
3093 * addresses on the socket.
3095 static int sctp_setsockopt_mappedv4(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3098 struct sctp_sock
*sp
= sctp_sk(sk
);
3100 if (optlen
< sizeof(int))
3102 if (get_user(val
, (int __user
*)optval
))
3113 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3114 * This option will get or set the maximum size to put in any outgoing
3115 * SCTP DATA chunk. If a message is larger than this size it will be
3116 * fragmented by SCTP into the specified size. Note that the underlying
3117 * SCTP implementation may fragment into smaller sized chunks when the
3118 * PMTU of the underlying association is smaller than the value set by
3119 * the user. The default value for this option is '0' which indicates
3120 * the user is NOT limiting fragmentation and only the PMTU will effect
3121 * SCTP's choice of DATA chunk size. Note also that values set larger
3122 * than the maximum size of an IP datagram will effectively let SCTP
3123 * control fragmentation (i.e. the same as setting this option to 0).
3125 * The following structure is used to access and modify this parameter:
3127 * struct sctp_assoc_value {
3128 * sctp_assoc_t assoc_id;
3129 * uint32_t assoc_value;
3132 * assoc_id: This parameter is ignored for one-to-one style sockets.
3133 * For one-to-many style sockets this parameter indicates which
3134 * association the user is performing an action upon. Note that if
3135 * this field's value is zero then the endpoints default value is
3136 * changed (effecting future associations only).
3137 * assoc_value: This parameter specifies the maximum size in bytes.
3139 static int sctp_setsockopt_maxseg(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3141 struct sctp_sock
*sp
= sctp_sk(sk
);
3142 struct sctp_assoc_value params
;
3143 struct sctp_association
*asoc
;
3146 if (optlen
== sizeof(int)) {
3147 pr_warn_ratelimited(DEPRECATED
3149 "Use of int in maxseg socket option.\n"
3150 "Use struct sctp_assoc_value instead\n",
3151 current
->comm
, task_pid_nr(current
));
3152 if (copy_from_user(&val
, optval
, optlen
))
3154 params
.assoc_id
= 0;
3155 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3156 if (copy_from_user(¶ms
, optval
, optlen
))
3158 val
= params
.assoc_value
;
3164 int min_len
, max_len
;
3166 min_len
= SCTP_DEFAULT_MINSEGMENT
- sp
->pf
->af
->net_header_len
;
3167 min_len
-= sizeof(struct sctphdr
) +
3168 sizeof(struct sctp_data_chunk
);
3170 max_len
= SCTP_MAX_CHUNK_LEN
- sizeof(struct sctp_data_chunk
);
3172 if (val
< min_len
|| val
> max_len
)
3176 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3179 val
= asoc
->pathmtu
- sp
->pf
->af
->net_header_len
;
3180 val
-= sizeof(struct sctphdr
) +
3181 sizeof(struct sctp_data_chunk
);
3183 asoc
->user_frag
= val
;
3184 asoc
->frag_point
= sctp_frag_point(asoc
, asoc
->pathmtu
);
3186 if (params
.assoc_id
&& sctp_style(sk
, UDP
))
3188 sp
->user_frag
= val
;
3196 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3198 * Requests that the peer mark the enclosed address as the association
3199 * primary. The enclosed address must be one of the association's
3200 * locally bound addresses. The following structure is used to make a
3201 * set primary request:
3203 static int sctp_setsockopt_peer_primary_addr(struct sock
*sk
, char __user
*optval
,
3204 unsigned int optlen
)
3206 struct net
*net
= sock_net(sk
);
3207 struct sctp_sock
*sp
;
3208 struct sctp_association
*asoc
= NULL
;
3209 struct sctp_setpeerprim prim
;
3210 struct sctp_chunk
*chunk
;
3216 if (!net
->sctp
.addip_enable
)
3219 if (optlen
!= sizeof(struct sctp_setpeerprim
))
3222 if (copy_from_user(&prim
, optval
, optlen
))
3225 asoc
= sctp_id2assoc(sk
, prim
.sspp_assoc_id
);
3229 if (!asoc
->peer
.asconf_capable
)
3232 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_SET_PRIMARY
)
3235 if (!sctp_state(asoc
, ESTABLISHED
))
3238 af
= sctp_get_af_specific(prim
.sspp_addr
.ss_family
);
3242 if (!af
->addr_valid((union sctp_addr
*)&prim
.sspp_addr
, sp
, NULL
))
3243 return -EADDRNOTAVAIL
;
3245 if (!sctp_assoc_lookup_laddr(asoc
, (union sctp_addr
*)&prim
.sspp_addr
))
3246 return -EADDRNOTAVAIL
;
3248 /* Create an ASCONF chunk with SET_PRIMARY parameter */
3249 chunk
= sctp_make_asconf_set_prim(asoc
,
3250 (union sctp_addr
*)&prim
.sspp_addr
);
3254 err
= sctp_send_asconf(asoc
, chunk
);
3256 pr_debug("%s: we set peer primary addr primitively\n", __func__
);
3261 static int sctp_setsockopt_adaptation_layer(struct sock
*sk
, char __user
*optval
,
3262 unsigned int optlen
)
3264 struct sctp_setadaptation adaptation
;
3266 if (optlen
!= sizeof(struct sctp_setadaptation
))
3268 if (copy_from_user(&adaptation
, optval
, optlen
))
3271 sctp_sk(sk
)->adaptation_ind
= adaptation
.ssb_adaptation_ind
;
3277 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
3279 * The context field in the sctp_sndrcvinfo structure is normally only
3280 * used when a failed message is retrieved holding the value that was
3281 * sent down on the actual send call. This option allows the setting of
3282 * a default context on an association basis that will be received on
3283 * reading messages from the peer. This is especially helpful in the
3284 * one-2-many model for an application to keep some reference to an
3285 * internal state machine that is processing messages on the
3286 * association. Note that the setting of this value only effects
3287 * received messages from the peer and does not effect the value that is
3288 * saved with outbound messages.
3290 static int sctp_setsockopt_context(struct sock
*sk
, char __user
*optval
,
3291 unsigned int optlen
)
3293 struct sctp_assoc_value params
;
3294 struct sctp_sock
*sp
;
3295 struct sctp_association
*asoc
;
3297 if (optlen
!= sizeof(struct sctp_assoc_value
))
3299 if (copy_from_user(¶ms
, optval
, optlen
))
3304 if (params
.assoc_id
!= 0) {
3305 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3308 asoc
->default_rcv_context
= params
.assoc_value
;
3310 sp
->default_rcv_context
= params
.assoc_value
;
3317 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3319 * This options will at a minimum specify if the implementation is doing
3320 * fragmented interleave. Fragmented interleave, for a one to many
3321 * socket, is when subsequent calls to receive a message may return
3322 * parts of messages from different associations. Some implementations
3323 * may allow you to turn this value on or off. If so, when turned off,
3324 * no fragment interleave will occur (which will cause a head of line
3325 * blocking amongst multiple associations sharing the same one to many
3326 * socket). When this option is turned on, then each receive call may
3327 * come from a different association (thus the user must receive data
3328 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3329 * association each receive belongs to.
3331 * This option takes a boolean value. A non-zero value indicates that
3332 * fragmented interleave is on. A value of zero indicates that
3333 * fragmented interleave is off.
3335 * Note that it is important that an implementation that allows this
3336 * option to be turned on, have it off by default. Otherwise an unaware
3337 * application using the one to many model may become confused and act
3340 static int sctp_setsockopt_fragment_interleave(struct sock
*sk
,
3341 char __user
*optval
,
3342 unsigned int optlen
)
3346 if (optlen
!= sizeof(int))
3348 if (get_user(val
, (int __user
*)optval
))
3351 sctp_sk(sk
)->frag_interleave
= (val
== 0) ? 0 : 1;
3357 * 8.1.21. Set or Get the SCTP Partial Delivery Point
3358 * (SCTP_PARTIAL_DELIVERY_POINT)
3360 * This option will set or get the SCTP partial delivery point. This
3361 * point is the size of a message where the partial delivery API will be
3362 * invoked to help free up rwnd space for the peer. Setting this to a
3363 * lower value will cause partial deliveries to happen more often. The
3364 * calls argument is an integer that sets or gets the partial delivery
3365 * point. Note also that the call will fail if the user attempts to set
3366 * this value larger than the socket receive buffer size.
3368 * Note that any single message having a length smaller than or equal to
3369 * the SCTP partial delivery point will be delivered in one single read
3370 * call as long as the user provided buffer is large enough to hold the
3373 static int sctp_setsockopt_partial_delivery_point(struct sock
*sk
,
3374 char __user
*optval
,
3375 unsigned int optlen
)
3379 if (optlen
!= sizeof(u32
))
3381 if (get_user(val
, (int __user
*)optval
))
3384 /* Note: We double the receive buffer from what the user sets
3385 * it to be, also initial rwnd is based on rcvbuf/2.
3387 if (val
> (sk
->sk_rcvbuf
>> 1))
3390 sctp_sk(sk
)->pd_point
= val
;
3392 return 0; /* is this the right error code? */
3396 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
3398 * This option will allow a user to change the maximum burst of packets
3399 * that can be emitted by this association. Note that the default value
3400 * is 4, and some implementations may restrict this setting so that it
3401 * can only be lowered.
3403 * NOTE: This text doesn't seem right. Do this on a socket basis with
3404 * future associations inheriting the socket value.
3406 static int sctp_setsockopt_maxburst(struct sock
*sk
,
3407 char __user
*optval
,
3408 unsigned int optlen
)
3410 struct sctp_assoc_value params
;
3411 struct sctp_sock
*sp
;
3412 struct sctp_association
*asoc
;
3416 if (optlen
== sizeof(int)) {
3417 pr_warn_ratelimited(DEPRECATED
3419 "Use of int in max_burst socket option deprecated.\n"
3420 "Use struct sctp_assoc_value instead\n",
3421 current
->comm
, task_pid_nr(current
));
3422 if (copy_from_user(&val
, optval
, optlen
))
3424 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3425 if (copy_from_user(¶ms
, optval
, optlen
))
3427 val
= params
.assoc_value
;
3428 assoc_id
= params
.assoc_id
;
3434 if (assoc_id
!= 0) {
3435 asoc
= sctp_id2assoc(sk
, assoc_id
);
3438 asoc
->max_burst
= val
;
3440 sp
->max_burst
= val
;
3446 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3448 * This set option adds a chunk type that the user is requesting to be
3449 * received only in an authenticated way. Changes to the list of chunks
3450 * will only effect future associations on the socket.
3452 static int sctp_setsockopt_auth_chunk(struct sock
*sk
,
3453 char __user
*optval
,
3454 unsigned int optlen
)
3456 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3457 struct sctp_authchunk val
;
3459 if (!ep
->auth_enable
)
3462 if (optlen
!= sizeof(struct sctp_authchunk
))
3464 if (copy_from_user(&val
, optval
, optlen
))
3467 switch (val
.sauth_chunk
) {
3469 case SCTP_CID_INIT_ACK
:
3470 case SCTP_CID_SHUTDOWN_COMPLETE
:
3475 /* add this chunk id to the endpoint */
3476 return sctp_auth_ep_add_chunkid(ep
, val
.sauth_chunk
);
3480 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3482 * This option gets or sets the list of HMAC algorithms that the local
3483 * endpoint requires the peer to use.
3485 static int sctp_setsockopt_hmac_ident(struct sock
*sk
,
3486 char __user
*optval
,
3487 unsigned int optlen
)
3489 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3490 struct sctp_hmacalgo
*hmacs
;
3494 if (!ep
->auth_enable
)
3497 if (optlen
< sizeof(struct sctp_hmacalgo
))
3499 optlen
= min_t(unsigned int, optlen
, sizeof(struct sctp_hmacalgo
) +
3500 SCTP_AUTH_NUM_HMACS
* sizeof(u16
));
3502 hmacs
= memdup_user(optval
, optlen
);
3504 return PTR_ERR(hmacs
);
3506 idents
= hmacs
->shmac_num_idents
;
3507 if (idents
== 0 || idents
> SCTP_AUTH_NUM_HMACS
||
3508 (idents
* sizeof(u16
)) > (optlen
- sizeof(struct sctp_hmacalgo
))) {
3513 err
= sctp_auth_ep_set_hmacs(ep
, hmacs
);
3520 * 7.1.20. Set a shared key (SCTP_AUTH_KEY)
3522 * This option will set a shared secret key which is used to build an
3523 * association shared key.
3525 static int sctp_setsockopt_auth_key(struct sock
*sk
,
3526 char __user
*optval
,
3527 unsigned int optlen
)
3529 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3530 struct sctp_authkey
*authkey
;
3531 struct sctp_association
*asoc
;
3534 if (!ep
->auth_enable
)
3537 if (optlen
<= sizeof(struct sctp_authkey
))
3539 /* authkey->sca_keylength is u16, so optlen can't be bigger than
3542 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+
3543 sizeof(struct sctp_authkey
));
3545 authkey
= memdup_user(optval
, optlen
);
3546 if (IS_ERR(authkey
))
3547 return PTR_ERR(authkey
);
3549 if (authkey
->sca_keylength
> optlen
- sizeof(struct sctp_authkey
)) {
3554 asoc
= sctp_id2assoc(sk
, authkey
->sca_assoc_id
);
3555 if (!asoc
&& authkey
->sca_assoc_id
&& sctp_style(sk
, UDP
)) {
3560 ret
= sctp_auth_set_key(ep
, asoc
, authkey
);
3567 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3569 * This option will get or set the active shared key to be used to build
3570 * the association shared key.
3572 static int sctp_setsockopt_active_key(struct sock
*sk
,
3573 char __user
*optval
,
3574 unsigned int optlen
)
3576 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3577 struct sctp_authkeyid val
;
3578 struct sctp_association
*asoc
;
3580 if (!ep
->auth_enable
)
3583 if (optlen
!= sizeof(struct sctp_authkeyid
))
3585 if (copy_from_user(&val
, optval
, optlen
))
3588 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
3589 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
3592 return sctp_auth_set_active_key(ep
, asoc
, val
.scact_keynumber
);
3596 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY)
3598 * This set option will delete a shared secret key from use.
3600 static int sctp_setsockopt_del_key(struct sock
*sk
,
3601 char __user
*optval
,
3602 unsigned int optlen
)
3604 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3605 struct sctp_authkeyid val
;
3606 struct sctp_association
*asoc
;
3608 if (!ep
->auth_enable
)
3611 if (optlen
!= sizeof(struct sctp_authkeyid
))
3613 if (copy_from_user(&val
, optval
, optlen
))
3616 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
3617 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
3620 return sctp_auth_del_key_id(ep
, asoc
, val
.scact_keynumber
);
3625 * 8.1.23 SCTP_AUTO_ASCONF
3627 * This option will enable or disable the use of the automatic generation of
3628 * ASCONF chunks to add and delete addresses to an existing association. Note
3629 * that this option has two caveats namely: a) it only affects sockets that
3630 * are bound to all addresses available to the SCTP stack, and b) the system
3631 * administrator may have an overriding control that turns the ASCONF feature
3632 * off no matter what setting the socket option may have.
3633 * This option expects an integer boolean flag, where a non-zero value turns on
3634 * the option, and a zero value turns off the option.
3635 * Note. In this implementation, socket operation overrides default parameter
3636 * being set by sysctl as well as FreeBSD implementation
3638 static int sctp_setsockopt_auto_asconf(struct sock
*sk
, char __user
*optval
,
3639 unsigned int optlen
)
3642 struct sctp_sock
*sp
= sctp_sk(sk
);
3644 if (optlen
< sizeof(int))
3646 if (get_user(val
, (int __user
*)optval
))
3648 if (!sctp_is_ep_boundall(sk
) && val
)
3650 if ((val
&& sp
->do_auto_asconf
) || (!val
&& !sp
->do_auto_asconf
))
3653 spin_lock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3654 if (val
== 0 && sp
->do_auto_asconf
) {
3655 list_del(&sp
->auto_asconf_list
);
3656 sp
->do_auto_asconf
= 0;
3657 } else if (val
&& !sp
->do_auto_asconf
) {
3658 list_add_tail(&sp
->auto_asconf_list
,
3659 &sock_net(sk
)->sctp
.auto_asconf_splist
);
3660 sp
->do_auto_asconf
= 1;
3662 spin_unlock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3667 * SCTP_PEER_ADDR_THLDS
3669 * This option allows us to alter the partially failed threshold for one or all
3670 * transports in an association. See Section 6.1 of:
3671 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3673 static int sctp_setsockopt_paddr_thresholds(struct sock
*sk
,
3674 char __user
*optval
,
3675 unsigned int optlen
)
3677 struct sctp_paddrthlds val
;
3678 struct sctp_transport
*trans
;
3679 struct sctp_association
*asoc
;
3681 if (optlen
< sizeof(struct sctp_paddrthlds
))
3683 if (copy_from_user(&val
, (struct sctp_paddrthlds __user
*)optval
,
3684 sizeof(struct sctp_paddrthlds
)))
3688 if (sctp_is_any(sk
, (const union sctp_addr
*)&val
.spt_address
)) {
3689 asoc
= sctp_id2assoc(sk
, val
.spt_assoc_id
);
3692 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
3694 if (val
.spt_pathmaxrxt
)
3695 trans
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3696 trans
->pf_retrans
= val
.spt_pathpfthld
;
3699 if (val
.spt_pathmaxrxt
)
3700 asoc
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3701 asoc
->pf_retrans
= val
.spt_pathpfthld
;
3703 trans
= sctp_addr_id2transport(sk
, &val
.spt_address
,
3708 if (val
.spt_pathmaxrxt
)
3709 trans
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3710 trans
->pf_retrans
= val
.spt_pathpfthld
;
3716 static int sctp_setsockopt_recvrcvinfo(struct sock
*sk
,
3717 char __user
*optval
,
3718 unsigned int optlen
)
3722 if (optlen
< sizeof(int))
3724 if (get_user(val
, (int __user
*) optval
))
3727 sctp_sk(sk
)->recvrcvinfo
= (val
== 0) ? 0 : 1;
3732 static int sctp_setsockopt_recvnxtinfo(struct sock
*sk
,
3733 char __user
*optval
,
3734 unsigned int optlen
)
3738 if (optlen
< sizeof(int))
3740 if (get_user(val
, (int __user
*) optval
))
3743 sctp_sk(sk
)->recvnxtinfo
= (val
== 0) ? 0 : 1;
3748 static int sctp_setsockopt_pr_supported(struct sock
*sk
,
3749 char __user
*optval
,
3750 unsigned int optlen
)
3752 struct sctp_assoc_value params
;
3754 if (optlen
!= sizeof(params
))
3757 if (copy_from_user(¶ms
, optval
, optlen
))
3760 sctp_sk(sk
)->ep
->prsctp_enable
= !!params
.assoc_value
;
3765 static int sctp_setsockopt_default_prinfo(struct sock
*sk
,
3766 char __user
*optval
,
3767 unsigned int optlen
)
3769 struct sctp_default_prinfo info
;
3770 struct sctp_association
*asoc
;
3771 int retval
= -EINVAL
;
3773 if (optlen
!= sizeof(info
))
3776 if (copy_from_user(&info
, optval
, sizeof(info
))) {
3781 if (info
.pr_policy
& ~SCTP_PR_SCTP_MASK
)
3784 if (info
.pr_policy
== SCTP_PR_SCTP_NONE
)
3787 asoc
= sctp_id2assoc(sk
, info
.pr_assoc_id
);
3789 SCTP_PR_SET_POLICY(asoc
->default_flags
, info
.pr_policy
);
3790 asoc
->default_timetolive
= info
.pr_value
;
3791 } else if (!info
.pr_assoc_id
) {
3792 struct sctp_sock
*sp
= sctp_sk(sk
);
3794 SCTP_PR_SET_POLICY(sp
->default_flags
, info
.pr_policy
);
3795 sp
->default_timetolive
= info
.pr_value
;
3806 static int sctp_setsockopt_reconfig_supported(struct sock
*sk
,
3807 char __user
*optval
,
3808 unsigned int optlen
)
3810 struct sctp_assoc_value params
;
3811 struct sctp_association
*asoc
;
3812 int retval
= -EINVAL
;
3814 if (optlen
!= sizeof(params
))
3817 if (copy_from_user(¶ms
, optval
, optlen
)) {
3822 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3824 asoc
->reconf_enable
= !!params
.assoc_value
;
3825 } else if (!params
.assoc_id
) {
3826 struct sctp_sock
*sp
= sctp_sk(sk
);
3828 sp
->ep
->reconf_enable
= !!params
.assoc_value
;
3839 static int sctp_setsockopt_enable_strreset(struct sock
*sk
,
3840 char __user
*optval
,
3841 unsigned int optlen
)
3843 struct sctp_assoc_value params
;
3844 struct sctp_association
*asoc
;
3845 int retval
= -EINVAL
;
3847 if (optlen
!= sizeof(params
))
3850 if (copy_from_user(¶ms
, optval
, optlen
)) {
3855 if (params
.assoc_value
& (~SCTP_ENABLE_STRRESET_MASK
))
3858 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3860 asoc
->strreset_enable
= params
.assoc_value
;
3861 } else if (!params
.assoc_id
) {
3862 struct sctp_sock
*sp
= sctp_sk(sk
);
3864 sp
->ep
->strreset_enable
= params
.assoc_value
;
3875 static int sctp_setsockopt_reset_streams(struct sock
*sk
,
3876 char __user
*optval
,
3877 unsigned int optlen
)
3879 struct sctp_reset_streams
*params
;
3880 struct sctp_association
*asoc
;
3881 int retval
= -EINVAL
;
3883 if (optlen
< sizeof(*params
))
3885 /* srs_number_streams is u16, so optlen can't be bigger than this. */
3886 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+
3887 sizeof(__u16
) * sizeof(*params
));
3889 params
= memdup_user(optval
, optlen
);
3891 return PTR_ERR(params
);
3893 if (params
->srs_number_streams
* sizeof(__u16
) >
3894 optlen
- sizeof(*params
))
3897 asoc
= sctp_id2assoc(sk
, params
->srs_assoc_id
);
3901 retval
= sctp_send_reset_streams(asoc
, params
);
3908 static int sctp_setsockopt_reset_assoc(struct sock
*sk
,
3909 char __user
*optval
,
3910 unsigned int optlen
)
3912 struct sctp_association
*asoc
;
3913 sctp_assoc_t associd
;
3914 int retval
= -EINVAL
;
3916 if (optlen
!= sizeof(associd
))
3919 if (copy_from_user(&associd
, optval
, optlen
)) {
3924 asoc
= sctp_id2assoc(sk
, associd
);
3928 retval
= sctp_send_reset_assoc(asoc
);
3934 static int sctp_setsockopt_add_streams(struct sock
*sk
,
3935 char __user
*optval
,
3936 unsigned int optlen
)
3938 struct sctp_association
*asoc
;
3939 struct sctp_add_streams params
;
3940 int retval
= -EINVAL
;
3942 if (optlen
!= sizeof(params
))
3945 if (copy_from_user(¶ms
, optval
, optlen
)) {
3950 asoc
= sctp_id2assoc(sk
, params
.sas_assoc_id
);
3954 retval
= sctp_send_add_streams(asoc
, ¶ms
);
3960 /* API 6.2 setsockopt(), getsockopt()
3962 * Applications use setsockopt() and getsockopt() to set or retrieve
3963 * socket options. Socket options are used to change the default
3964 * behavior of sockets calls. They are described in Section 7.
3968 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
3969 * int __user *optlen);
3970 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
3973 * sd - the socket descript.
3974 * level - set to IPPROTO_SCTP for all SCTP options.
3975 * optname - the option name.
3976 * optval - the buffer to store the value of the option.
3977 * optlen - the size of the buffer.
3979 static int sctp_setsockopt(struct sock
*sk
, int level
, int optname
,
3980 char __user
*optval
, unsigned int optlen
)
3984 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
3986 /* I can hardly begin to describe how wrong this is. This is
3987 * so broken as to be worse than useless. The API draft
3988 * REALLY is NOT helpful here... I am not convinced that the
3989 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
3990 * are at all well-founded.
3992 if (level
!= SOL_SCTP
) {
3993 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
3994 retval
= af
->setsockopt(sk
, level
, optname
, optval
, optlen
);
4001 case SCTP_SOCKOPT_BINDX_ADD
:
4002 /* 'optlen' is the size of the addresses buffer. */
4003 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
4004 optlen
, SCTP_BINDX_ADD_ADDR
);
4007 case SCTP_SOCKOPT_BINDX_REM
:
4008 /* 'optlen' is the size of the addresses buffer. */
4009 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
4010 optlen
, SCTP_BINDX_REM_ADDR
);
4013 case SCTP_SOCKOPT_CONNECTX_OLD
:
4014 /* 'optlen' is the size of the addresses buffer. */
4015 retval
= sctp_setsockopt_connectx_old(sk
,
4016 (struct sockaddr __user
*)optval
,
4020 case SCTP_SOCKOPT_CONNECTX
:
4021 /* 'optlen' is the size of the addresses buffer. */
4022 retval
= sctp_setsockopt_connectx(sk
,
4023 (struct sockaddr __user
*)optval
,
4027 case SCTP_DISABLE_FRAGMENTS
:
4028 retval
= sctp_setsockopt_disable_fragments(sk
, optval
, optlen
);
4032 retval
= sctp_setsockopt_events(sk
, optval
, optlen
);
4035 case SCTP_AUTOCLOSE
:
4036 retval
= sctp_setsockopt_autoclose(sk
, optval
, optlen
);
4039 case SCTP_PEER_ADDR_PARAMS
:
4040 retval
= sctp_setsockopt_peer_addr_params(sk
, optval
, optlen
);
4043 case SCTP_DELAYED_SACK
:
4044 retval
= sctp_setsockopt_delayed_ack(sk
, optval
, optlen
);
4046 case SCTP_PARTIAL_DELIVERY_POINT
:
4047 retval
= sctp_setsockopt_partial_delivery_point(sk
, optval
, optlen
);
4051 retval
= sctp_setsockopt_initmsg(sk
, optval
, optlen
);
4053 case SCTP_DEFAULT_SEND_PARAM
:
4054 retval
= sctp_setsockopt_default_send_param(sk
, optval
,
4057 case SCTP_DEFAULT_SNDINFO
:
4058 retval
= sctp_setsockopt_default_sndinfo(sk
, optval
, optlen
);
4060 case SCTP_PRIMARY_ADDR
:
4061 retval
= sctp_setsockopt_primary_addr(sk
, optval
, optlen
);
4063 case SCTP_SET_PEER_PRIMARY_ADDR
:
4064 retval
= sctp_setsockopt_peer_primary_addr(sk
, optval
, optlen
);
4067 retval
= sctp_setsockopt_nodelay(sk
, optval
, optlen
);
4070 retval
= sctp_setsockopt_rtoinfo(sk
, optval
, optlen
);
4072 case SCTP_ASSOCINFO
:
4073 retval
= sctp_setsockopt_associnfo(sk
, optval
, optlen
);
4075 case SCTP_I_WANT_MAPPED_V4_ADDR
:
4076 retval
= sctp_setsockopt_mappedv4(sk
, optval
, optlen
);
4079 retval
= sctp_setsockopt_maxseg(sk
, optval
, optlen
);
4081 case SCTP_ADAPTATION_LAYER
:
4082 retval
= sctp_setsockopt_adaptation_layer(sk
, optval
, optlen
);
4085 retval
= sctp_setsockopt_context(sk
, optval
, optlen
);
4087 case SCTP_FRAGMENT_INTERLEAVE
:
4088 retval
= sctp_setsockopt_fragment_interleave(sk
, optval
, optlen
);
4090 case SCTP_MAX_BURST
:
4091 retval
= sctp_setsockopt_maxburst(sk
, optval
, optlen
);
4093 case SCTP_AUTH_CHUNK
:
4094 retval
= sctp_setsockopt_auth_chunk(sk
, optval
, optlen
);
4096 case SCTP_HMAC_IDENT
:
4097 retval
= sctp_setsockopt_hmac_ident(sk
, optval
, optlen
);
4100 retval
= sctp_setsockopt_auth_key(sk
, optval
, optlen
);
4102 case SCTP_AUTH_ACTIVE_KEY
:
4103 retval
= sctp_setsockopt_active_key(sk
, optval
, optlen
);
4105 case SCTP_AUTH_DELETE_KEY
:
4106 retval
= sctp_setsockopt_del_key(sk
, optval
, optlen
);
4108 case SCTP_AUTO_ASCONF
:
4109 retval
= sctp_setsockopt_auto_asconf(sk
, optval
, optlen
);
4111 case SCTP_PEER_ADDR_THLDS
:
4112 retval
= sctp_setsockopt_paddr_thresholds(sk
, optval
, optlen
);
4114 case SCTP_RECVRCVINFO
:
4115 retval
= sctp_setsockopt_recvrcvinfo(sk
, optval
, optlen
);
4117 case SCTP_RECVNXTINFO
:
4118 retval
= sctp_setsockopt_recvnxtinfo(sk
, optval
, optlen
);
4120 case SCTP_PR_SUPPORTED
:
4121 retval
= sctp_setsockopt_pr_supported(sk
, optval
, optlen
);
4123 case SCTP_DEFAULT_PRINFO
:
4124 retval
= sctp_setsockopt_default_prinfo(sk
, optval
, optlen
);
4126 case SCTP_RECONFIG_SUPPORTED
:
4127 retval
= sctp_setsockopt_reconfig_supported(sk
, optval
, optlen
);
4129 case SCTP_ENABLE_STREAM_RESET
:
4130 retval
= sctp_setsockopt_enable_strreset(sk
, optval
, optlen
);
4132 case SCTP_RESET_STREAMS
:
4133 retval
= sctp_setsockopt_reset_streams(sk
, optval
, optlen
);
4135 case SCTP_RESET_ASSOC
:
4136 retval
= sctp_setsockopt_reset_assoc(sk
, optval
, optlen
);
4138 case SCTP_ADD_STREAMS
:
4139 retval
= sctp_setsockopt_add_streams(sk
, optval
, optlen
);
4142 retval
= -ENOPROTOOPT
;
4152 /* API 3.1.6 connect() - UDP Style Syntax
4154 * An application may use the connect() call in the UDP model to initiate an
4155 * association without sending data.
4159 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4161 * sd: the socket descriptor to have a new association added to.
4163 * nam: the address structure (either struct sockaddr_in or struct
4164 * sockaddr_in6 defined in RFC2553 [7]).
4166 * len: the size of the address.
4168 static int sctp_connect(struct sock
*sk
, struct sockaddr
*addr
,
4169 int addr_len
, int flags
)
4171 struct inet_sock
*inet
= inet_sk(sk
);
4177 pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__
, sk
,
4180 /* We may need to bind the socket. */
4181 if (!inet
->inet_num
) {
4182 if (sk
->sk_prot
->get_port(sk
, 0)) {
4186 inet
->inet_sport
= htons(inet
->inet_num
);
4189 /* Validate addr_len before calling common connect/connectx routine. */
4190 af
= sctp_get_af_specific(addr
->sa_family
);
4191 if (!af
|| addr_len
< af
->sockaddr_len
) {
4194 /* Pass correct addr len to common routine (so it knows there
4195 * is only one address being passed.
4197 err
= __sctp_connect(sk
, addr
, af
->sockaddr_len
, flags
, NULL
);
4204 int sctp_inet_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
4205 int addr_len
, int flags
)
4207 if (addr_len
< sizeof(uaddr
->sa_family
))
4210 if (uaddr
->sa_family
== AF_UNSPEC
)
4213 return sctp_connect(sock
->sk
, uaddr
, addr_len
, flags
);
4216 /* FIXME: Write comments. */
4217 static int sctp_disconnect(struct sock
*sk
, int flags
)
4219 return -EOPNOTSUPP
; /* STUB */
4222 /* 4.1.4 accept() - TCP Style Syntax
4224 * Applications use accept() call to remove an established SCTP
4225 * association from the accept queue of the endpoint. A new socket
4226 * descriptor will be returned from accept() to represent the newly
4227 * formed association.
4229 static struct sock
*sctp_accept(struct sock
*sk
, int flags
, int *err
, bool kern
)
4231 struct sctp_sock
*sp
;
4232 struct sctp_endpoint
*ep
;
4233 struct sock
*newsk
= NULL
;
4234 struct sctp_association
*asoc
;
4243 if (!sctp_style(sk
, TCP
)) {
4244 error
= -EOPNOTSUPP
;
4248 if (!sctp_sstate(sk
, LISTENING
)) {
4253 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
4255 error
= sctp_wait_for_accept(sk
, timeo
);
4259 /* We treat the list of associations on the endpoint as the accept
4260 * queue and pick the first association on the list.
4262 asoc
= list_entry(ep
->asocs
.next
, struct sctp_association
, asocs
);
4264 newsk
= sp
->pf
->create_accept_sk(sk
, asoc
, kern
);
4270 /* Populate the fields of the newsk from the oldsk and migrate the
4271 * asoc to the newsk.
4273 sctp_sock_migrate(sk
, newsk
, asoc
, SCTP_SOCKET_TCP
);
4281 /* The SCTP ioctl handler. */
4282 static int sctp_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
4289 * SEQPACKET-style sockets in LISTENING state are valid, for
4290 * SCTP, so only discard TCP-style sockets in LISTENING state.
4292 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
4297 struct sk_buff
*skb
;
4298 unsigned int amount
= 0;
4300 skb
= skb_peek(&sk
->sk_receive_queue
);
4303 * We will only return the amount of this packet since
4304 * that is all that will be read.
4308 rc
= put_user(amount
, (int __user
*)arg
);
4320 /* This is the function which gets called during socket creation to
4321 * initialized the SCTP-specific portion of the sock.
4322 * The sock structure should already be zero-filled memory.
4324 static int sctp_init_sock(struct sock
*sk
)
4326 struct net
*net
= sock_net(sk
);
4327 struct sctp_sock
*sp
;
4329 pr_debug("%s: sk:%p\n", __func__
, sk
);
4333 /* Initialize the SCTP per socket area. */
4334 switch (sk
->sk_type
) {
4335 case SOCK_SEQPACKET
:
4336 sp
->type
= SCTP_SOCKET_UDP
;
4339 sp
->type
= SCTP_SOCKET_TCP
;
4342 return -ESOCKTNOSUPPORT
;
4345 sk
->sk_gso_type
= SKB_GSO_SCTP
;
4347 /* Initialize default send parameters. These parameters can be
4348 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4350 sp
->default_stream
= 0;
4351 sp
->default_ppid
= 0;
4352 sp
->default_flags
= 0;
4353 sp
->default_context
= 0;
4354 sp
->default_timetolive
= 0;
4356 sp
->default_rcv_context
= 0;
4357 sp
->max_burst
= net
->sctp
.max_burst
;
4359 sp
->sctp_hmac_alg
= net
->sctp
.sctp_hmac_alg
;
4361 /* Initialize default setup parameters. These parameters
4362 * can be modified with the SCTP_INITMSG socket option or
4363 * overridden by the SCTP_INIT CMSG.
4365 sp
->initmsg
.sinit_num_ostreams
= sctp_max_outstreams
;
4366 sp
->initmsg
.sinit_max_instreams
= sctp_max_instreams
;
4367 sp
->initmsg
.sinit_max_attempts
= net
->sctp
.max_retrans_init
;
4368 sp
->initmsg
.sinit_max_init_timeo
= net
->sctp
.rto_max
;
4370 /* Initialize default RTO related parameters. These parameters can
4371 * be modified for with the SCTP_RTOINFO socket option.
4373 sp
->rtoinfo
.srto_initial
= net
->sctp
.rto_initial
;
4374 sp
->rtoinfo
.srto_max
= net
->sctp
.rto_max
;
4375 sp
->rtoinfo
.srto_min
= net
->sctp
.rto_min
;
4377 /* Initialize default association related parameters. These parameters
4378 * can be modified with the SCTP_ASSOCINFO socket option.
4380 sp
->assocparams
.sasoc_asocmaxrxt
= net
->sctp
.max_retrans_association
;
4381 sp
->assocparams
.sasoc_number_peer_destinations
= 0;
4382 sp
->assocparams
.sasoc_peer_rwnd
= 0;
4383 sp
->assocparams
.sasoc_local_rwnd
= 0;
4384 sp
->assocparams
.sasoc_cookie_life
= net
->sctp
.valid_cookie_life
;
4386 /* Initialize default event subscriptions. By default, all the
4389 memset(&sp
->subscribe
, 0, sizeof(struct sctp_event_subscribe
));
4391 /* Default Peer Address Parameters. These defaults can
4392 * be modified via SCTP_PEER_ADDR_PARAMS
4394 sp
->hbinterval
= net
->sctp
.hb_interval
;
4395 sp
->pathmaxrxt
= net
->sctp
.max_retrans_path
;
4396 sp
->pathmtu
= 0; /* allow default discovery */
4397 sp
->sackdelay
= net
->sctp
.sack_timeout
;
4399 sp
->param_flags
= SPP_HB_ENABLE
|
4401 SPP_SACKDELAY_ENABLE
;
4403 /* If enabled no SCTP message fragmentation will be performed.
4404 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
4406 sp
->disable_fragments
= 0;
4408 /* Enable Nagle algorithm by default. */
4411 sp
->recvrcvinfo
= 0;
4412 sp
->recvnxtinfo
= 0;
4414 /* Enable by default. */
4417 /* Auto-close idle associations after the configured
4418 * number of seconds. A value of 0 disables this
4419 * feature. Configure through the SCTP_AUTOCLOSE socket option,
4420 * for UDP-style sockets only.
4424 /* User specified fragmentation limit. */
4427 sp
->adaptation_ind
= 0;
4429 sp
->pf
= sctp_get_pf_specific(sk
->sk_family
);
4431 /* Control variables for partial data delivery. */
4432 atomic_set(&sp
->pd_mode
, 0);
4433 skb_queue_head_init(&sp
->pd_lobby
);
4434 sp
->frag_interleave
= 0;
4436 /* Create a per socket endpoint structure. Even if we
4437 * change the data structure relationships, this may still
4438 * be useful for storing pre-connect address information.
4440 sp
->ep
= sctp_endpoint_new(sk
, GFP_KERNEL
);
4446 sk
->sk_destruct
= sctp_destruct_sock
;
4448 SCTP_DBG_OBJCNT_INC(sock
);
4451 sk_sockets_allocated_inc(sk
);
4452 sock_prot_inuse_add(net
, sk
->sk_prot
, 1);
4454 /* Nothing can fail after this block, otherwise
4455 * sctp_destroy_sock() will be called without addr_wq_lock held
4457 if (net
->sctp
.default_auto_asconf
) {
4458 spin_lock(&sock_net(sk
)->sctp
.addr_wq_lock
);
4459 list_add_tail(&sp
->auto_asconf_list
,
4460 &net
->sctp
.auto_asconf_splist
);
4461 sp
->do_auto_asconf
= 1;
4462 spin_unlock(&sock_net(sk
)->sctp
.addr_wq_lock
);
4464 sp
->do_auto_asconf
= 0;
4472 /* Cleanup any SCTP per socket resources. Must be called with
4473 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
4475 static void sctp_destroy_sock(struct sock
*sk
)
4477 struct sctp_sock
*sp
;
4479 pr_debug("%s: sk:%p\n", __func__
, sk
);
4481 /* Release our hold on the endpoint. */
4483 /* This could happen during socket init, thus we bail out
4484 * early, since the rest of the below is not setup either.
4489 if (sp
->do_auto_asconf
) {
4490 sp
->do_auto_asconf
= 0;
4491 list_del(&sp
->auto_asconf_list
);
4493 sctp_endpoint_free(sp
->ep
);
4495 sk_sockets_allocated_dec(sk
);
4496 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, -1);
4500 /* Triggered when there are no references on the socket anymore */
4501 static void sctp_destruct_sock(struct sock
*sk
)
4503 struct sctp_sock
*sp
= sctp_sk(sk
);
4505 /* Free up the HMAC transform. */
4506 crypto_free_shash(sp
->hmac
);
4508 inet_sock_destruct(sk
);
4511 /* API 4.1.7 shutdown() - TCP Style Syntax
4512 * int shutdown(int socket, int how);
4514 * sd - the socket descriptor of the association to be closed.
4515 * how - Specifies the type of shutdown. The values are
4518 * Disables further receive operations. No SCTP
4519 * protocol action is taken.
4521 * Disables further send operations, and initiates
4522 * the SCTP shutdown sequence.
4524 * Disables further send and receive operations
4525 * and initiates the SCTP shutdown sequence.
4527 static void sctp_shutdown(struct sock
*sk
, int how
)
4529 struct net
*net
= sock_net(sk
);
4530 struct sctp_endpoint
*ep
;
4532 if (!sctp_style(sk
, TCP
))
4535 ep
= sctp_sk(sk
)->ep
;
4536 if (how
& SEND_SHUTDOWN
&& !list_empty(&ep
->asocs
)) {
4537 struct sctp_association
*asoc
;
4539 sk
->sk_state
= SCTP_SS_CLOSING
;
4540 asoc
= list_entry(ep
->asocs
.next
,
4541 struct sctp_association
, asocs
);
4542 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
4546 int sctp_get_sctp_info(struct sock
*sk
, struct sctp_association
*asoc
,
4547 struct sctp_info
*info
)
4549 struct sctp_transport
*prim
;
4550 struct list_head
*pos
;
4553 memset(info
, 0, sizeof(*info
));
4555 struct sctp_sock
*sp
= sctp_sk(sk
);
4557 info
->sctpi_s_autoclose
= sp
->autoclose
;
4558 info
->sctpi_s_adaptation_ind
= sp
->adaptation_ind
;
4559 info
->sctpi_s_pd_point
= sp
->pd_point
;
4560 info
->sctpi_s_nodelay
= sp
->nodelay
;
4561 info
->sctpi_s_disable_fragments
= sp
->disable_fragments
;
4562 info
->sctpi_s_v4mapped
= sp
->v4mapped
;
4563 info
->sctpi_s_frag_interleave
= sp
->frag_interleave
;
4564 info
->sctpi_s_type
= sp
->type
;
4569 info
->sctpi_tag
= asoc
->c
.my_vtag
;
4570 info
->sctpi_state
= asoc
->state
;
4571 info
->sctpi_rwnd
= asoc
->a_rwnd
;
4572 info
->sctpi_unackdata
= asoc
->unack_data
;
4573 info
->sctpi_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
4574 info
->sctpi_instrms
= asoc
->stream
.incnt
;
4575 info
->sctpi_outstrms
= asoc
->stream
.outcnt
;
4576 list_for_each(pos
, &asoc
->base
.inqueue
.in_chunk_list
)
4577 info
->sctpi_inqueue
++;
4578 list_for_each(pos
, &asoc
->outqueue
.out_chunk_list
)
4579 info
->sctpi_outqueue
++;
4580 info
->sctpi_overall_error
= asoc
->overall_error_count
;
4581 info
->sctpi_max_burst
= asoc
->max_burst
;
4582 info
->sctpi_maxseg
= asoc
->frag_point
;
4583 info
->sctpi_peer_rwnd
= asoc
->peer
.rwnd
;
4584 info
->sctpi_peer_tag
= asoc
->c
.peer_vtag
;
4586 mask
= asoc
->peer
.ecn_capable
<< 1;
4587 mask
= (mask
| asoc
->peer
.ipv4_address
) << 1;
4588 mask
= (mask
| asoc
->peer
.ipv6_address
) << 1;
4589 mask
= (mask
| asoc
->peer
.hostname_address
) << 1;
4590 mask
= (mask
| asoc
->peer
.asconf_capable
) << 1;
4591 mask
= (mask
| asoc
->peer
.prsctp_capable
) << 1;
4592 mask
= (mask
| asoc
->peer
.auth_capable
);
4593 info
->sctpi_peer_capable
= mask
;
4594 mask
= asoc
->peer
.sack_needed
<< 1;
4595 mask
= (mask
| asoc
->peer
.sack_generation
) << 1;
4596 mask
= (mask
| asoc
->peer
.zero_window_announced
);
4597 info
->sctpi_peer_sack
= mask
;
4599 info
->sctpi_isacks
= asoc
->stats
.isacks
;
4600 info
->sctpi_osacks
= asoc
->stats
.osacks
;
4601 info
->sctpi_opackets
= asoc
->stats
.opackets
;
4602 info
->sctpi_ipackets
= asoc
->stats
.ipackets
;
4603 info
->sctpi_rtxchunks
= asoc
->stats
.rtxchunks
;
4604 info
->sctpi_outofseqtsns
= asoc
->stats
.outofseqtsns
;
4605 info
->sctpi_idupchunks
= asoc
->stats
.idupchunks
;
4606 info
->sctpi_gapcnt
= asoc
->stats
.gapcnt
;
4607 info
->sctpi_ouodchunks
= asoc
->stats
.ouodchunks
;
4608 info
->sctpi_iuodchunks
= asoc
->stats
.iuodchunks
;
4609 info
->sctpi_oodchunks
= asoc
->stats
.oodchunks
;
4610 info
->sctpi_iodchunks
= asoc
->stats
.iodchunks
;
4611 info
->sctpi_octrlchunks
= asoc
->stats
.octrlchunks
;
4612 info
->sctpi_ictrlchunks
= asoc
->stats
.ictrlchunks
;
4614 prim
= asoc
->peer
.primary_path
;
4615 memcpy(&info
->sctpi_p_address
, &prim
->ipaddr
, sizeof(prim
->ipaddr
));
4616 info
->sctpi_p_state
= prim
->state
;
4617 info
->sctpi_p_cwnd
= prim
->cwnd
;
4618 info
->sctpi_p_srtt
= prim
->srtt
;
4619 info
->sctpi_p_rto
= jiffies_to_msecs(prim
->rto
);
4620 info
->sctpi_p_hbinterval
= prim
->hbinterval
;
4621 info
->sctpi_p_pathmaxrxt
= prim
->pathmaxrxt
;
4622 info
->sctpi_p_sackdelay
= jiffies_to_msecs(prim
->sackdelay
);
4623 info
->sctpi_p_ssthresh
= prim
->ssthresh
;
4624 info
->sctpi_p_partial_bytes_acked
= prim
->partial_bytes_acked
;
4625 info
->sctpi_p_flight_size
= prim
->flight_size
;
4626 info
->sctpi_p_error
= prim
->error_count
;
4630 EXPORT_SYMBOL_GPL(sctp_get_sctp_info
);
4632 /* use callback to avoid exporting the core structure */
4633 int sctp_transport_walk_start(struct rhashtable_iter
*iter
)
4637 rhltable_walk_enter(&sctp_transport_hashtable
, iter
);
4639 err
= rhashtable_walk_start(iter
);
4640 if (err
&& err
!= -EAGAIN
) {
4641 rhashtable_walk_stop(iter
);
4642 rhashtable_walk_exit(iter
);
4649 void sctp_transport_walk_stop(struct rhashtable_iter
*iter
)
4651 rhashtable_walk_stop(iter
);
4652 rhashtable_walk_exit(iter
);
4655 struct sctp_transport
*sctp_transport_get_next(struct net
*net
,
4656 struct rhashtable_iter
*iter
)
4658 struct sctp_transport
*t
;
4660 t
= rhashtable_walk_next(iter
);
4661 for (; t
; t
= rhashtable_walk_next(iter
)) {
4663 if (PTR_ERR(t
) == -EAGAIN
)
4668 if (!sctp_transport_hold(t
))
4671 if (net_eq(sock_net(t
->asoc
->base
.sk
), net
) &&
4672 t
->asoc
->peer
.primary_path
== t
)
4675 sctp_transport_put(t
);
4681 struct sctp_transport
*sctp_transport_get_idx(struct net
*net
,
4682 struct rhashtable_iter
*iter
,
4685 struct sctp_transport
*t
;
4688 return SEQ_START_TOKEN
;
4690 while ((t
= sctp_transport_get_next(net
, iter
)) && !IS_ERR(t
)) {
4693 sctp_transport_put(t
);
4699 int sctp_for_each_endpoint(int (*cb
)(struct sctp_endpoint
*, void *),
4703 struct sctp_ep_common
*epb
;
4704 struct sctp_hashbucket
*head
;
4706 for (head
= sctp_ep_hashtable
; hash
< sctp_ep_hashsize
;
4708 read_lock_bh(&head
->lock
);
4709 sctp_for_each_hentry(epb
, &head
->chain
) {
4710 err
= cb(sctp_ep(epb
), p
);
4714 read_unlock_bh(&head
->lock
);
4719 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint
);
4721 int sctp_transport_lookup_process(int (*cb
)(struct sctp_transport
*, void *),
4723 const union sctp_addr
*laddr
,
4724 const union sctp_addr
*paddr
, void *p
)
4726 struct sctp_transport
*transport
;
4730 transport
= sctp_addrs_lookup_transport(net
, laddr
, paddr
);
4735 err
= cb(transport
, p
);
4736 sctp_transport_put(transport
);
4740 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process
);
4742 int sctp_for_each_transport(int (*cb
)(struct sctp_transport
*, void *),
4743 int (*cb_done
)(struct sctp_transport
*, void *),
4744 struct net
*net
, int *pos
, void *p
) {
4745 struct rhashtable_iter hti
;
4746 struct sctp_transport
*tsp
;
4750 ret
= sctp_transport_walk_start(&hti
);
4754 tsp
= sctp_transport_get_idx(net
, &hti
, *pos
+ 1);
4755 for (; !IS_ERR_OR_NULL(tsp
); tsp
= sctp_transport_get_next(net
, &hti
)) {
4760 sctp_transport_put(tsp
);
4762 sctp_transport_walk_stop(&hti
);
4765 if (cb_done
&& !cb_done(tsp
, p
)) {
4767 sctp_transport_put(tsp
);
4770 sctp_transport_put(tsp
);
4775 EXPORT_SYMBOL_GPL(sctp_for_each_transport
);
4777 /* 7.2.1 Association Status (SCTP_STATUS)
4779 * Applications can retrieve current status information about an
4780 * association, including association state, peer receiver window size,
4781 * number of unacked data chunks, and number of data chunks pending
4782 * receipt. This information is read-only.
4784 static int sctp_getsockopt_sctp_status(struct sock
*sk
, int len
,
4785 char __user
*optval
,
4788 struct sctp_status status
;
4789 struct sctp_association
*asoc
= NULL
;
4790 struct sctp_transport
*transport
;
4791 sctp_assoc_t associd
;
4794 if (len
< sizeof(status
)) {
4799 len
= sizeof(status
);
4800 if (copy_from_user(&status
, optval
, len
)) {
4805 associd
= status
.sstat_assoc_id
;
4806 asoc
= sctp_id2assoc(sk
, associd
);
4812 transport
= asoc
->peer
.primary_path
;
4814 status
.sstat_assoc_id
= sctp_assoc2id(asoc
);
4815 status
.sstat_state
= sctp_assoc_to_state(asoc
);
4816 status
.sstat_rwnd
= asoc
->peer
.rwnd
;
4817 status
.sstat_unackdata
= asoc
->unack_data
;
4819 status
.sstat_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
4820 status
.sstat_instrms
= asoc
->stream
.incnt
;
4821 status
.sstat_outstrms
= asoc
->stream
.outcnt
;
4822 status
.sstat_fragmentation_point
= asoc
->frag_point
;
4823 status
.sstat_primary
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
4824 memcpy(&status
.sstat_primary
.spinfo_address
, &transport
->ipaddr
,
4825 transport
->af_specific
->sockaddr_len
);
4826 /* Map ipv4 address into v4-mapped-on-v6 address. */
4827 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
4828 (union sctp_addr
*)&status
.sstat_primary
.spinfo_address
);
4829 status
.sstat_primary
.spinfo_state
= transport
->state
;
4830 status
.sstat_primary
.spinfo_cwnd
= transport
->cwnd
;
4831 status
.sstat_primary
.spinfo_srtt
= transport
->srtt
;
4832 status
.sstat_primary
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
4833 status
.sstat_primary
.spinfo_mtu
= transport
->pathmtu
;
4835 if (status
.sstat_primary
.spinfo_state
== SCTP_UNKNOWN
)
4836 status
.sstat_primary
.spinfo_state
= SCTP_ACTIVE
;
4838 if (put_user(len
, optlen
)) {
4843 pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
4844 __func__
, len
, status
.sstat_state
, status
.sstat_rwnd
,
4845 status
.sstat_assoc_id
);
4847 if (copy_to_user(optval
, &status
, len
)) {
4857 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
4859 * Applications can retrieve information about a specific peer address
4860 * of an association, including its reachability state, congestion
4861 * window, and retransmission timer values. This information is
4864 static int sctp_getsockopt_peer_addr_info(struct sock
*sk
, int len
,
4865 char __user
*optval
,
4868 struct sctp_paddrinfo pinfo
;
4869 struct sctp_transport
*transport
;
4872 if (len
< sizeof(pinfo
)) {
4877 len
= sizeof(pinfo
);
4878 if (copy_from_user(&pinfo
, optval
, len
)) {
4883 transport
= sctp_addr_id2transport(sk
, &pinfo
.spinfo_address
,
4884 pinfo
.spinfo_assoc_id
);
4888 pinfo
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
4889 pinfo
.spinfo_state
= transport
->state
;
4890 pinfo
.spinfo_cwnd
= transport
->cwnd
;
4891 pinfo
.spinfo_srtt
= transport
->srtt
;
4892 pinfo
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
4893 pinfo
.spinfo_mtu
= transport
->pathmtu
;
4895 if (pinfo
.spinfo_state
== SCTP_UNKNOWN
)
4896 pinfo
.spinfo_state
= SCTP_ACTIVE
;
4898 if (put_user(len
, optlen
)) {
4903 if (copy_to_user(optval
, &pinfo
, len
)) {
4912 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
4914 * This option is a on/off flag. If enabled no SCTP message
4915 * fragmentation will be performed. Instead if a message being sent
4916 * exceeds the current PMTU size, the message will NOT be sent and
4917 * instead a error will be indicated to the user.
4919 static int sctp_getsockopt_disable_fragments(struct sock
*sk
, int len
,
4920 char __user
*optval
, int __user
*optlen
)
4924 if (len
< sizeof(int))
4928 val
= (sctp_sk(sk
)->disable_fragments
== 1);
4929 if (put_user(len
, optlen
))
4931 if (copy_to_user(optval
, &val
, len
))
4936 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
4938 * This socket option is used to specify various notifications and
4939 * ancillary data the user wishes to receive.
4941 static int sctp_getsockopt_events(struct sock
*sk
, int len
, char __user
*optval
,
4946 if (len
> sizeof(struct sctp_event_subscribe
))
4947 len
= sizeof(struct sctp_event_subscribe
);
4948 if (put_user(len
, optlen
))
4950 if (copy_to_user(optval
, &sctp_sk(sk
)->subscribe
, len
))
4955 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
4957 * This socket option is applicable to the UDP-style socket only. When
4958 * set it will cause associations that are idle for more than the
4959 * specified number of seconds to automatically close. An association
4960 * being idle is defined an association that has NOT sent or received
4961 * user data. The special value of '0' indicates that no automatic
4962 * close of any associations should be performed. The option expects an
4963 * integer defining the number of seconds of idle time before an
4964 * association is closed.
4966 static int sctp_getsockopt_autoclose(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
4968 /* Applicable to UDP-style socket only */
4969 if (sctp_style(sk
, TCP
))
4971 if (len
< sizeof(int))
4974 if (put_user(len
, optlen
))
4976 if (copy_to_user(optval
, &sctp_sk(sk
)->autoclose
, len
))
4981 /* Helper routine to branch off an association to a new socket. */
4982 int sctp_do_peeloff(struct sock
*sk
, sctp_assoc_t id
, struct socket
**sockp
)
4984 struct sctp_association
*asoc
= sctp_id2assoc(sk
, id
);
4985 struct sctp_sock
*sp
= sctp_sk(sk
);
4986 struct socket
*sock
;
4989 /* Do not peel off from one netns to another one. */
4990 if (!net_eq(current
->nsproxy
->net_ns
, sock_net(sk
)))
4996 /* An association cannot be branched off from an already peeled-off
4997 * socket, nor is this supported for tcp style sockets.
4999 if (!sctp_style(sk
, UDP
))
5002 /* Create a new socket. */
5003 err
= sock_create(sk
->sk_family
, SOCK_SEQPACKET
, IPPROTO_SCTP
, &sock
);
5007 sctp_copy_sock(sock
->sk
, sk
, asoc
);
5009 /* Make peeled-off sockets more like 1-1 accepted sockets.
5010 * Set the daddr and initialize id to something more random
5012 sp
->pf
->to_sk_daddr(&asoc
->peer
.primary_addr
, sk
);
5014 /* Populate the fields of the newsk from the oldsk and migrate the
5015 * asoc to the newsk.
5017 sctp_sock_migrate(sk
, sock
->sk
, asoc
, SCTP_SOCKET_UDP_HIGH_BANDWIDTH
);
5023 EXPORT_SYMBOL(sctp_do_peeloff
);
5025 static int sctp_getsockopt_peeloff_common(struct sock
*sk
, sctp_peeloff_arg_t
*peeloff
,
5026 struct file
**newfile
, unsigned flags
)
5028 struct socket
*newsock
;
5031 retval
= sctp_do_peeloff(sk
, peeloff
->associd
, &newsock
);
5035 /* Map the socket to an unused fd that can be returned to the user. */
5036 retval
= get_unused_fd_flags(flags
& SOCK_CLOEXEC
);
5038 sock_release(newsock
);
5042 *newfile
= sock_alloc_file(newsock
, 0, NULL
);
5043 if (IS_ERR(*newfile
)) {
5044 put_unused_fd(retval
);
5045 sock_release(newsock
);
5046 retval
= PTR_ERR(*newfile
);
5051 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__
, sk
, newsock
->sk
,
5054 peeloff
->sd
= retval
;
5056 if (flags
& SOCK_NONBLOCK
)
5057 (*newfile
)->f_flags
|= O_NONBLOCK
;
5062 static int sctp_getsockopt_peeloff(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5064 sctp_peeloff_arg_t peeloff
;
5065 struct file
*newfile
= NULL
;
5068 if (len
< sizeof(sctp_peeloff_arg_t
))
5070 len
= sizeof(sctp_peeloff_arg_t
);
5071 if (copy_from_user(&peeloff
, optval
, len
))
5074 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
, &newfile
, 0);
5078 /* Return the fd mapped to the new socket. */
5079 if (put_user(len
, optlen
)) {
5081 put_unused_fd(retval
);
5085 if (copy_to_user(optval
, &peeloff
, len
)) {
5087 put_unused_fd(retval
);
5090 fd_install(retval
, newfile
);
5095 static int sctp_getsockopt_peeloff_flags(struct sock
*sk
, int len
,
5096 char __user
*optval
, int __user
*optlen
)
5098 sctp_peeloff_flags_arg_t peeloff
;
5099 struct file
*newfile
= NULL
;
5102 if (len
< sizeof(sctp_peeloff_flags_arg_t
))
5104 len
= sizeof(sctp_peeloff_flags_arg_t
);
5105 if (copy_from_user(&peeloff
, optval
, len
))
5108 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
.p_arg
,
5109 &newfile
, peeloff
.flags
);
5113 /* Return the fd mapped to the new socket. */
5114 if (put_user(len
, optlen
)) {
5116 put_unused_fd(retval
);
5120 if (copy_to_user(optval
, &peeloff
, len
)) {
5122 put_unused_fd(retval
);
5125 fd_install(retval
, newfile
);
5130 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5132 * Applications can enable or disable heartbeats for any peer address of
5133 * an association, modify an address's heartbeat interval, force a
5134 * heartbeat to be sent immediately, and adjust the address's maximum
5135 * number of retransmissions sent before an address is considered
5136 * unreachable. The following structure is used to access and modify an
5137 * address's parameters:
5139 * struct sctp_paddrparams {
5140 * sctp_assoc_t spp_assoc_id;
5141 * struct sockaddr_storage spp_address;
5142 * uint32_t spp_hbinterval;
5143 * uint16_t spp_pathmaxrxt;
5144 * uint32_t spp_pathmtu;
5145 * uint32_t spp_sackdelay;
5146 * uint32_t spp_flags;
5149 * spp_assoc_id - (one-to-many style socket) This is filled in the
5150 * application, and identifies the association for
5152 * spp_address - This specifies which address is of interest.
5153 * spp_hbinterval - This contains the value of the heartbeat interval,
5154 * in milliseconds. If a value of zero
5155 * is present in this field then no changes are to
5156 * be made to this parameter.
5157 * spp_pathmaxrxt - This contains the maximum number of
5158 * retransmissions before this address shall be
5159 * considered unreachable. If a value of zero
5160 * is present in this field then no changes are to
5161 * be made to this parameter.
5162 * spp_pathmtu - When Path MTU discovery is disabled the value
5163 * specified here will be the "fixed" path mtu.
5164 * Note that if the spp_address field is empty
5165 * then all associations on this address will
5166 * have this fixed path mtu set upon them.
5168 * spp_sackdelay - When delayed sack is enabled, this value specifies
5169 * the number of milliseconds that sacks will be delayed
5170 * for. This value will apply to all addresses of an
5171 * association if the spp_address field is empty. Note
5172 * also, that if delayed sack is enabled and this
5173 * value is set to 0, no change is made to the last
5174 * recorded delayed sack timer value.
5176 * spp_flags - These flags are used to control various features
5177 * on an association. The flag field may contain
5178 * zero or more of the following options.
5180 * SPP_HB_ENABLE - Enable heartbeats on the
5181 * specified address. Note that if the address
5182 * field is empty all addresses for the association
5183 * have heartbeats enabled upon them.
5185 * SPP_HB_DISABLE - Disable heartbeats on the
5186 * speicifed address. Note that if the address
5187 * field is empty all addresses for the association
5188 * will have their heartbeats disabled. Note also
5189 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
5190 * mutually exclusive, only one of these two should
5191 * be specified. Enabling both fields will have
5192 * undetermined results.
5194 * SPP_HB_DEMAND - Request a user initiated heartbeat
5195 * to be made immediately.
5197 * SPP_PMTUD_ENABLE - This field will enable PMTU
5198 * discovery upon the specified address. Note that
5199 * if the address feild is empty then all addresses
5200 * on the association are effected.
5202 * SPP_PMTUD_DISABLE - This field will disable PMTU
5203 * discovery upon the specified address. Note that
5204 * if the address feild is empty then all addresses
5205 * on the association are effected. Not also that
5206 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5207 * exclusive. Enabling both will have undetermined
5210 * SPP_SACKDELAY_ENABLE - Setting this flag turns
5211 * on delayed sack. The time specified in spp_sackdelay
5212 * is used to specify the sack delay for this address. Note
5213 * that if spp_address is empty then all addresses will
5214 * enable delayed sack and take on the sack delay
5215 * value specified in spp_sackdelay.
5216 * SPP_SACKDELAY_DISABLE - Setting this flag turns
5217 * off delayed sack. If the spp_address field is blank then
5218 * delayed sack is disabled for the entire association. Note
5219 * also that this field is mutually exclusive to
5220 * SPP_SACKDELAY_ENABLE, setting both will have undefined
5223 static int sctp_getsockopt_peer_addr_params(struct sock
*sk
, int len
,
5224 char __user
*optval
, int __user
*optlen
)
5226 struct sctp_paddrparams params
;
5227 struct sctp_transport
*trans
= NULL
;
5228 struct sctp_association
*asoc
= NULL
;
5229 struct sctp_sock
*sp
= sctp_sk(sk
);
5231 if (len
< sizeof(struct sctp_paddrparams
))
5233 len
= sizeof(struct sctp_paddrparams
);
5234 if (copy_from_user(¶ms
, optval
, len
))
5237 /* If an address other than INADDR_ANY is specified, and
5238 * no transport is found, then the request is invalid.
5240 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spp_address
)) {
5241 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
5242 params
.spp_assoc_id
);
5244 pr_debug("%s: failed no transport\n", __func__
);
5249 /* Get association, if assoc_id != 0 and the socket is a one
5250 * to many style socket, and an association was not found, then
5251 * the id was invalid.
5253 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
5254 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
)) {
5255 pr_debug("%s: failed no association\n", __func__
);
5260 /* Fetch transport values. */
5261 params
.spp_hbinterval
= jiffies_to_msecs(trans
->hbinterval
);
5262 params
.spp_pathmtu
= trans
->pathmtu
;
5263 params
.spp_pathmaxrxt
= trans
->pathmaxrxt
;
5264 params
.spp_sackdelay
= jiffies_to_msecs(trans
->sackdelay
);
5266 /*draft-11 doesn't say what to return in spp_flags*/
5267 params
.spp_flags
= trans
->param_flags
;
5269 /* Fetch association values. */
5270 params
.spp_hbinterval
= jiffies_to_msecs(asoc
->hbinterval
);
5271 params
.spp_pathmtu
= asoc
->pathmtu
;
5272 params
.spp_pathmaxrxt
= asoc
->pathmaxrxt
;
5273 params
.spp_sackdelay
= jiffies_to_msecs(asoc
->sackdelay
);
5275 /*draft-11 doesn't say what to return in spp_flags*/
5276 params
.spp_flags
= asoc
->param_flags
;
5278 /* Fetch socket values. */
5279 params
.spp_hbinterval
= sp
->hbinterval
;
5280 params
.spp_pathmtu
= sp
->pathmtu
;
5281 params
.spp_sackdelay
= sp
->sackdelay
;
5282 params
.spp_pathmaxrxt
= sp
->pathmaxrxt
;
5284 /*draft-11 doesn't say what to return in spp_flags*/
5285 params
.spp_flags
= sp
->param_flags
;
5288 if (copy_to_user(optval
, ¶ms
, len
))
5291 if (put_user(len
, optlen
))
5298 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
5300 * This option will effect the way delayed acks are performed. This
5301 * option allows you to get or set the delayed ack time, in
5302 * milliseconds. It also allows changing the delayed ack frequency.
5303 * Changing the frequency to 1 disables the delayed sack algorithm. If
5304 * the assoc_id is 0, then this sets or gets the endpoints default
5305 * values. If the assoc_id field is non-zero, then the set or get
5306 * effects the specified association for the one to many model (the
5307 * assoc_id field is ignored by the one to one model). Note that if
5308 * sack_delay or sack_freq are 0 when setting this option, then the
5309 * current values will remain unchanged.
5311 * struct sctp_sack_info {
5312 * sctp_assoc_t sack_assoc_id;
5313 * uint32_t sack_delay;
5314 * uint32_t sack_freq;
5317 * sack_assoc_id - This parameter, indicates which association the user
5318 * is performing an action upon. Note that if this field's value is
5319 * zero then the endpoints default value is changed (effecting future
5320 * associations only).
5322 * sack_delay - This parameter contains the number of milliseconds that
5323 * the user is requesting the delayed ACK timer be set to. Note that
5324 * this value is defined in the standard to be between 200 and 500
5327 * sack_freq - This parameter contains the number of packets that must
5328 * be received before a sack is sent without waiting for the delay
5329 * timer to expire. The default value for this is 2, setting this
5330 * value to 1 will disable the delayed sack algorithm.
5332 static int sctp_getsockopt_delayed_ack(struct sock
*sk
, int len
,
5333 char __user
*optval
,
5336 struct sctp_sack_info params
;
5337 struct sctp_association
*asoc
= NULL
;
5338 struct sctp_sock
*sp
= sctp_sk(sk
);
5340 if (len
>= sizeof(struct sctp_sack_info
)) {
5341 len
= sizeof(struct sctp_sack_info
);
5343 if (copy_from_user(¶ms
, optval
, len
))
5345 } else if (len
== sizeof(struct sctp_assoc_value
)) {
5346 pr_warn_ratelimited(DEPRECATED
5348 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
5349 "Use struct sctp_sack_info instead\n",
5350 current
->comm
, task_pid_nr(current
));
5351 if (copy_from_user(¶ms
, optval
, len
))
5356 /* Get association, if sack_assoc_id != 0 and the socket is a one
5357 * to many style socket, and an association was not found, then
5358 * the id was invalid.
5360 asoc
= sctp_id2assoc(sk
, params
.sack_assoc_id
);
5361 if (!asoc
&& params
.sack_assoc_id
&& sctp_style(sk
, UDP
))
5365 /* Fetch association values. */
5366 if (asoc
->param_flags
& SPP_SACKDELAY_ENABLE
) {
5367 params
.sack_delay
= jiffies_to_msecs(
5369 params
.sack_freq
= asoc
->sackfreq
;
5372 params
.sack_delay
= 0;
5373 params
.sack_freq
= 1;
5376 /* Fetch socket values. */
5377 if (sp
->param_flags
& SPP_SACKDELAY_ENABLE
) {
5378 params
.sack_delay
= sp
->sackdelay
;
5379 params
.sack_freq
= sp
->sackfreq
;
5381 params
.sack_delay
= 0;
5382 params
.sack_freq
= 1;
5386 if (copy_to_user(optval
, ¶ms
, len
))
5389 if (put_user(len
, optlen
))
5395 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
5397 * Applications can specify protocol parameters for the default association
5398 * initialization. The option name argument to setsockopt() and getsockopt()
5401 * Setting initialization parameters is effective only on an unconnected
5402 * socket (for UDP-style sockets only future associations are effected
5403 * by the change). With TCP-style sockets, this option is inherited by
5404 * sockets derived from a listener socket.
5406 static int sctp_getsockopt_initmsg(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5408 if (len
< sizeof(struct sctp_initmsg
))
5410 len
= sizeof(struct sctp_initmsg
);
5411 if (put_user(len
, optlen
))
5413 if (copy_to_user(optval
, &sctp_sk(sk
)->initmsg
, len
))
5419 static int sctp_getsockopt_peer_addrs(struct sock
*sk
, int len
,
5420 char __user
*optval
, int __user
*optlen
)
5422 struct sctp_association
*asoc
;
5424 struct sctp_getaddrs getaddrs
;
5425 struct sctp_transport
*from
;
5427 union sctp_addr temp
;
5428 struct sctp_sock
*sp
= sctp_sk(sk
);
5433 if (len
< sizeof(struct sctp_getaddrs
))
5436 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
5439 /* For UDP-style sockets, id specifies the association to query. */
5440 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
5444 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
5445 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
5447 list_for_each_entry(from
, &asoc
->peer
.transport_addr_list
,
5449 memcpy(&temp
, &from
->ipaddr
, sizeof(temp
));
5450 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
5451 ->addr_to_user(sp
, &temp
);
5452 if (space_left
< addrlen
)
5454 if (copy_to_user(to
, &temp
, addrlen
))
5458 space_left
-= addrlen
;
5461 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
))
5463 bytes_copied
= ((char __user
*)to
) - optval
;
5464 if (put_user(bytes_copied
, optlen
))
5470 static int sctp_copy_laddrs(struct sock
*sk
, __u16 port
, void *to
,
5471 size_t space_left
, int *bytes_copied
)
5473 struct sctp_sockaddr_entry
*addr
;
5474 union sctp_addr temp
;
5477 struct net
*net
= sock_net(sk
);
5480 list_for_each_entry_rcu(addr
, &net
->sctp
.local_addr_list
, list
) {
5484 if ((PF_INET
== sk
->sk_family
) &&
5485 (AF_INET6
== addr
->a
.sa
.sa_family
))
5487 if ((PF_INET6
== sk
->sk_family
) &&
5488 inet_v6_ipv6only(sk
) &&
5489 (AF_INET
== addr
->a
.sa
.sa_family
))
5491 memcpy(&temp
, &addr
->a
, sizeof(temp
));
5492 if (!temp
.v4
.sin_port
)
5493 temp
.v4
.sin_port
= htons(port
);
5495 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
5496 ->addr_to_user(sctp_sk(sk
), &temp
);
5498 if (space_left
< addrlen
) {
5502 memcpy(to
, &temp
, addrlen
);
5506 space_left
-= addrlen
;
5507 *bytes_copied
+= addrlen
;
5515 static int sctp_getsockopt_local_addrs(struct sock
*sk
, int len
,
5516 char __user
*optval
, int __user
*optlen
)
5518 struct sctp_bind_addr
*bp
;
5519 struct sctp_association
*asoc
;
5521 struct sctp_getaddrs getaddrs
;
5522 struct sctp_sockaddr_entry
*addr
;
5524 union sctp_addr temp
;
5525 struct sctp_sock
*sp
= sctp_sk(sk
);
5529 int bytes_copied
= 0;
5533 if (len
< sizeof(struct sctp_getaddrs
))
5536 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
5540 * For UDP-style sockets, id specifies the association to query.
5541 * If the id field is set to the value '0' then the locally bound
5542 * addresses are returned without regard to any particular
5545 if (0 == getaddrs
.assoc_id
) {
5546 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
5548 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
5551 bp
= &asoc
->base
.bind_addr
;
5554 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
5555 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
5557 addrs
= kmalloc(space_left
, GFP_USER
| __GFP_NOWARN
);
5561 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
5562 * addresses from the global local address list.
5564 if (sctp_list_single_entry(&bp
->address_list
)) {
5565 addr
= list_entry(bp
->address_list
.next
,
5566 struct sctp_sockaddr_entry
, list
);
5567 if (sctp_is_any(sk
, &addr
->a
)) {
5568 cnt
= sctp_copy_laddrs(sk
, bp
->port
, addrs
,
5569 space_left
, &bytes_copied
);
5579 /* Protection on the bound address list is not needed since
5580 * in the socket option context we hold a socket lock and
5581 * thus the bound address list can't change.
5583 list_for_each_entry(addr
, &bp
->address_list
, list
) {
5584 memcpy(&temp
, &addr
->a
, sizeof(temp
));
5585 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
5586 ->addr_to_user(sp
, &temp
);
5587 if (space_left
< addrlen
) {
5588 err
= -ENOMEM
; /*fixme: right error?*/
5591 memcpy(buf
, &temp
, addrlen
);
5593 bytes_copied
+= addrlen
;
5595 space_left
-= addrlen
;
5599 if (copy_to_user(to
, addrs
, bytes_copied
)) {
5603 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
)) {
5607 /* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
5608 * but we can't change it anymore.
5610 if (put_user(bytes_copied
, optlen
))
5617 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
5619 * Requests that the local SCTP stack use the enclosed peer address as
5620 * the association primary. The enclosed address must be one of the
5621 * association peer's addresses.
5623 static int sctp_getsockopt_primary_addr(struct sock
*sk
, int len
,
5624 char __user
*optval
, int __user
*optlen
)
5626 struct sctp_prim prim
;
5627 struct sctp_association
*asoc
;
5628 struct sctp_sock
*sp
= sctp_sk(sk
);
5630 if (len
< sizeof(struct sctp_prim
))
5633 len
= sizeof(struct sctp_prim
);
5635 if (copy_from_user(&prim
, optval
, len
))
5638 asoc
= sctp_id2assoc(sk
, prim
.ssp_assoc_id
);
5642 if (!asoc
->peer
.primary_path
)
5645 memcpy(&prim
.ssp_addr
, &asoc
->peer
.primary_path
->ipaddr
,
5646 asoc
->peer
.primary_path
->af_specific
->sockaddr_len
);
5648 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sp
,
5649 (union sctp_addr
*)&prim
.ssp_addr
);
5651 if (put_user(len
, optlen
))
5653 if (copy_to_user(optval
, &prim
, len
))
5660 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
5662 * Requests that the local endpoint set the specified Adaptation Layer
5663 * Indication parameter for all future INIT and INIT-ACK exchanges.
5665 static int sctp_getsockopt_adaptation_layer(struct sock
*sk
, int len
,
5666 char __user
*optval
, int __user
*optlen
)
5668 struct sctp_setadaptation adaptation
;
5670 if (len
< sizeof(struct sctp_setadaptation
))
5673 len
= sizeof(struct sctp_setadaptation
);
5675 adaptation
.ssb_adaptation_ind
= sctp_sk(sk
)->adaptation_ind
;
5677 if (put_user(len
, optlen
))
5679 if (copy_to_user(optval
, &adaptation
, len
))
5687 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
5689 * Applications that wish to use the sendto() system call may wish to
5690 * specify a default set of parameters that would normally be supplied
5691 * through the inclusion of ancillary data. This socket option allows
5692 * such an application to set the default sctp_sndrcvinfo structure.
5695 * The application that wishes to use this socket option simply passes
5696 * in to this call the sctp_sndrcvinfo structure defined in Section
5697 * 5.2.2) The input parameters accepted by this call include
5698 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
5699 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
5700 * to this call if the caller is using the UDP model.
5702 * For getsockopt, it get the default sctp_sndrcvinfo structure.
5704 static int sctp_getsockopt_default_send_param(struct sock
*sk
,
5705 int len
, char __user
*optval
,
5708 struct sctp_sock
*sp
= sctp_sk(sk
);
5709 struct sctp_association
*asoc
;
5710 struct sctp_sndrcvinfo info
;
5712 if (len
< sizeof(info
))
5717 if (copy_from_user(&info
, optval
, len
))
5720 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
5721 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
5724 info
.sinfo_stream
= asoc
->default_stream
;
5725 info
.sinfo_flags
= asoc
->default_flags
;
5726 info
.sinfo_ppid
= asoc
->default_ppid
;
5727 info
.sinfo_context
= asoc
->default_context
;
5728 info
.sinfo_timetolive
= asoc
->default_timetolive
;
5730 info
.sinfo_stream
= sp
->default_stream
;
5731 info
.sinfo_flags
= sp
->default_flags
;
5732 info
.sinfo_ppid
= sp
->default_ppid
;
5733 info
.sinfo_context
= sp
->default_context
;
5734 info
.sinfo_timetolive
= sp
->default_timetolive
;
5737 if (put_user(len
, optlen
))
5739 if (copy_to_user(optval
, &info
, len
))
5745 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
5746 * (SCTP_DEFAULT_SNDINFO)
5748 static int sctp_getsockopt_default_sndinfo(struct sock
*sk
, int len
,
5749 char __user
*optval
,
5752 struct sctp_sock
*sp
= sctp_sk(sk
);
5753 struct sctp_association
*asoc
;
5754 struct sctp_sndinfo info
;
5756 if (len
< sizeof(info
))
5761 if (copy_from_user(&info
, optval
, len
))
5764 asoc
= sctp_id2assoc(sk
, info
.snd_assoc_id
);
5765 if (!asoc
&& info
.snd_assoc_id
&& sctp_style(sk
, UDP
))
5768 info
.snd_sid
= asoc
->default_stream
;
5769 info
.snd_flags
= asoc
->default_flags
;
5770 info
.snd_ppid
= asoc
->default_ppid
;
5771 info
.snd_context
= asoc
->default_context
;
5773 info
.snd_sid
= sp
->default_stream
;
5774 info
.snd_flags
= sp
->default_flags
;
5775 info
.snd_ppid
= sp
->default_ppid
;
5776 info
.snd_context
= sp
->default_context
;
5779 if (put_user(len
, optlen
))
5781 if (copy_to_user(optval
, &info
, len
))
5789 * 7.1.5 SCTP_NODELAY
5791 * Turn on/off any Nagle-like algorithm. This means that packets are
5792 * generally sent as soon as possible and no unnecessary delays are
5793 * introduced, at the cost of more packets in the network. Expects an
5794 * integer boolean flag.
5797 static int sctp_getsockopt_nodelay(struct sock
*sk
, int len
,
5798 char __user
*optval
, int __user
*optlen
)
5802 if (len
< sizeof(int))
5806 val
= (sctp_sk(sk
)->nodelay
== 1);
5807 if (put_user(len
, optlen
))
5809 if (copy_to_user(optval
, &val
, len
))
5816 * 7.1.1 SCTP_RTOINFO
5818 * The protocol parameters used to initialize and bound retransmission
5819 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
5820 * and modify these parameters.
5821 * All parameters are time values, in milliseconds. A value of 0, when
5822 * modifying the parameters, indicates that the current value should not
5826 static int sctp_getsockopt_rtoinfo(struct sock
*sk
, int len
,
5827 char __user
*optval
,
5828 int __user
*optlen
) {
5829 struct sctp_rtoinfo rtoinfo
;
5830 struct sctp_association
*asoc
;
5832 if (len
< sizeof (struct sctp_rtoinfo
))
5835 len
= sizeof(struct sctp_rtoinfo
);
5837 if (copy_from_user(&rtoinfo
, optval
, len
))
5840 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
5842 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
5845 /* Values corresponding to the specific association. */
5847 rtoinfo
.srto_initial
= jiffies_to_msecs(asoc
->rto_initial
);
5848 rtoinfo
.srto_max
= jiffies_to_msecs(asoc
->rto_max
);
5849 rtoinfo
.srto_min
= jiffies_to_msecs(asoc
->rto_min
);
5851 /* Values corresponding to the endpoint. */
5852 struct sctp_sock
*sp
= sctp_sk(sk
);
5854 rtoinfo
.srto_initial
= sp
->rtoinfo
.srto_initial
;
5855 rtoinfo
.srto_max
= sp
->rtoinfo
.srto_max
;
5856 rtoinfo
.srto_min
= sp
->rtoinfo
.srto_min
;
5859 if (put_user(len
, optlen
))
5862 if (copy_to_user(optval
, &rtoinfo
, len
))
5870 * 7.1.2 SCTP_ASSOCINFO
5872 * This option is used to tune the maximum retransmission attempts
5873 * of the association.
5874 * Returns an error if the new association retransmission value is
5875 * greater than the sum of the retransmission value of the peer.
5876 * See [SCTP] for more information.
5879 static int sctp_getsockopt_associnfo(struct sock
*sk
, int len
,
5880 char __user
*optval
,
5884 struct sctp_assocparams assocparams
;
5885 struct sctp_association
*asoc
;
5886 struct list_head
*pos
;
5889 if (len
< sizeof (struct sctp_assocparams
))
5892 len
= sizeof(struct sctp_assocparams
);
5894 if (copy_from_user(&assocparams
, optval
, len
))
5897 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
5899 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
5902 /* Values correspoinding to the specific association */
5904 assocparams
.sasoc_asocmaxrxt
= asoc
->max_retrans
;
5905 assocparams
.sasoc_peer_rwnd
= asoc
->peer
.rwnd
;
5906 assocparams
.sasoc_local_rwnd
= asoc
->a_rwnd
;
5907 assocparams
.sasoc_cookie_life
= ktime_to_ms(asoc
->cookie_life
);
5909 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
5913 assocparams
.sasoc_number_peer_destinations
= cnt
;
5915 /* Values corresponding to the endpoint */
5916 struct sctp_sock
*sp
= sctp_sk(sk
);
5918 assocparams
.sasoc_asocmaxrxt
= sp
->assocparams
.sasoc_asocmaxrxt
;
5919 assocparams
.sasoc_peer_rwnd
= sp
->assocparams
.sasoc_peer_rwnd
;
5920 assocparams
.sasoc_local_rwnd
= sp
->assocparams
.sasoc_local_rwnd
;
5921 assocparams
.sasoc_cookie_life
=
5922 sp
->assocparams
.sasoc_cookie_life
;
5923 assocparams
.sasoc_number_peer_destinations
=
5925 sasoc_number_peer_destinations
;
5928 if (put_user(len
, optlen
))
5931 if (copy_to_user(optval
, &assocparams
, len
))
5938 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
5940 * This socket option is a boolean flag which turns on or off mapped V4
5941 * addresses. If this option is turned on and the socket is type
5942 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
5943 * If this option is turned off, then no mapping will be done of V4
5944 * addresses and a user will receive both PF_INET6 and PF_INET type
5945 * addresses on the socket.
5947 static int sctp_getsockopt_mappedv4(struct sock
*sk
, int len
,
5948 char __user
*optval
, int __user
*optlen
)
5951 struct sctp_sock
*sp
= sctp_sk(sk
);
5953 if (len
< sizeof(int))
5958 if (put_user(len
, optlen
))
5960 if (copy_to_user(optval
, &val
, len
))
5967 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
5968 * (chapter and verse is quoted at sctp_setsockopt_context())
5970 static int sctp_getsockopt_context(struct sock
*sk
, int len
,
5971 char __user
*optval
, int __user
*optlen
)
5973 struct sctp_assoc_value params
;
5974 struct sctp_sock
*sp
;
5975 struct sctp_association
*asoc
;
5977 if (len
< sizeof(struct sctp_assoc_value
))
5980 len
= sizeof(struct sctp_assoc_value
);
5982 if (copy_from_user(¶ms
, optval
, len
))
5987 if (params
.assoc_id
!= 0) {
5988 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
5991 params
.assoc_value
= asoc
->default_rcv_context
;
5993 params
.assoc_value
= sp
->default_rcv_context
;
5996 if (put_user(len
, optlen
))
5998 if (copy_to_user(optval
, ¶ms
, len
))
6005 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6006 * This option will get or set the maximum size to put in any outgoing
6007 * SCTP DATA chunk. If a message is larger than this size it will be
6008 * fragmented by SCTP into the specified size. Note that the underlying
6009 * SCTP implementation may fragment into smaller sized chunks when the
6010 * PMTU of the underlying association is smaller than the value set by
6011 * the user. The default value for this option is '0' which indicates
6012 * the user is NOT limiting fragmentation and only the PMTU will effect
6013 * SCTP's choice of DATA chunk size. Note also that values set larger
6014 * than the maximum size of an IP datagram will effectively let SCTP
6015 * control fragmentation (i.e. the same as setting this option to 0).
6017 * The following structure is used to access and modify this parameter:
6019 * struct sctp_assoc_value {
6020 * sctp_assoc_t assoc_id;
6021 * uint32_t assoc_value;
6024 * assoc_id: This parameter is ignored for one-to-one style sockets.
6025 * For one-to-many style sockets this parameter indicates which
6026 * association the user is performing an action upon. Note that if
6027 * this field's value is zero then the endpoints default value is
6028 * changed (effecting future associations only).
6029 * assoc_value: This parameter specifies the maximum size in bytes.
6031 static int sctp_getsockopt_maxseg(struct sock
*sk
, int len
,
6032 char __user
*optval
, int __user
*optlen
)
6034 struct sctp_assoc_value params
;
6035 struct sctp_association
*asoc
;
6037 if (len
== sizeof(int)) {
6038 pr_warn_ratelimited(DEPRECATED
6040 "Use of int in maxseg socket option.\n"
6041 "Use struct sctp_assoc_value instead\n",
6042 current
->comm
, task_pid_nr(current
));
6043 params
.assoc_id
= 0;
6044 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6045 len
= sizeof(struct sctp_assoc_value
);
6046 if (copy_from_user(¶ms
, optval
, len
))
6051 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6052 if (!asoc
&& params
.assoc_id
&& sctp_style(sk
, UDP
))
6056 params
.assoc_value
= asoc
->frag_point
;
6058 params
.assoc_value
= sctp_sk(sk
)->user_frag
;
6060 if (put_user(len
, optlen
))
6062 if (len
== sizeof(int)) {
6063 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6066 if (copy_to_user(optval
, ¶ms
, len
))
6074 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6075 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6077 static int sctp_getsockopt_fragment_interleave(struct sock
*sk
, int len
,
6078 char __user
*optval
, int __user
*optlen
)
6082 if (len
< sizeof(int))
6087 val
= sctp_sk(sk
)->frag_interleave
;
6088 if (put_user(len
, optlen
))
6090 if (copy_to_user(optval
, &val
, len
))
6097 * 7.1.25. Set or Get the sctp partial delivery point
6098 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6100 static int sctp_getsockopt_partial_delivery_point(struct sock
*sk
, int len
,
6101 char __user
*optval
,
6106 if (len
< sizeof(u32
))
6111 val
= sctp_sk(sk
)->pd_point
;
6112 if (put_user(len
, optlen
))
6114 if (copy_to_user(optval
, &val
, len
))
6121 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
6122 * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6124 static int sctp_getsockopt_maxburst(struct sock
*sk
, int len
,
6125 char __user
*optval
,
6128 struct sctp_assoc_value params
;
6129 struct sctp_sock
*sp
;
6130 struct sctp_association
*asoc
;
6132 if (len
== sizeof(int)) {
6133 pr_warn_ratelimited(DEPRECATED
6135 "Use of int in max_burst socket option.\n"
6136 "Use struct sctp_assoc_value instead\n",
6137 current
->comm
, task_pid_nr(current
));
6138 params
.assoc_id
= 0;
6139 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6140 len
= sizeof(struct sctp_assoc_value
);
6141 if (copy_from_user(¶ms
, optval
, len
))
6148 if (params
.assoc_id
!= 0) {
6149 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6152 params
.assoc_value
= asoc
->max_burst
;
6154 params
.assoc_value
= sp
->max_burst
;
6156 if (len
== sizeof(int)) {
6157 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6160 if (copy_to_user(optval
, ¶ms
, len
))
6168 static int sctp_getsockopt_hmac_ident(struct sock
*sk
, int len
,
6169 char __user
*optval
, int __user
*optlen
)
6171 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6172 struct sctp_hmacalgo __user
*p
= (void __user
*)optval
;
6173 struct sctp_hmac_algo_param
*hmacs
;
6178 if (!ep
->auth_enable
)
6181 hmacs
= ep
->auth_hmacs_list
;
6182 data_len
= ntohs(hmacs
->param_hdr
.length
) -
6183 sizeof(struct sctp_paramhdr
);
6185 if (len
< sizeof(struct sctp_hmacalgo
) + data_len
)
6188 len
= sizeof(struct sctp_hmacalgo
) + data_len
;
6189 num_idents
= data_len
/ sizeof(u16
);
6191 if (put_user(len
, optlen
))
6193 if (put_user(num_idents
, &p
->shmac_num_idents
))
6195 for (i
= 0; i
< num_idents
; i
++) {
6196 __u16 hmacid
= ntohs(hmacs
->hmac_ids
[i
]);
6198 if (copy_to_user(&p
->shmac_idents
[i
], &hmacid
, sizeof(__u16
)))
6204 static int sctp_getsockopt_active_key(struct sock
*sk
, int len
,
6205 char __user
*optval
, int __user
*optlen
)
6207 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6208 struct sctp_authkeyid val
;
6209 struct sctp_association
*asoc
;
6211 if (!ep
->auth_enable
)
6214 if (len
< sizeof(struct sctp_authkeyid
))
6217 len
= sizeof(struct sctp_authkeyid
);
6218 if (copy_from_user(&val
, optval
, len
))
6221 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
6222 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
6226 val
.scact_keynumber
= asoc
->active_key_id
;
6228 val
.scact_keynumber
= ep
->active_key_id
;
6230 if (put_user(len
, optlen
))
6232 if (copy_to_user(optval
, &val
, len
))
6238 static int sctp_getsockopt_peer_auth_chunks(struct sock
*sk
, int len
,
6239 char __user
*optval
, int __user
*optlen
)
6241 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6242 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
6243 struct sctp_authchunks val
;
6244 struct sctp_association
*asoc
;
6245 struct sctp_chunks_param
*ch
;
6249 if (!ep
->auth_enable
)
6252 if (len
< sizeof(struct sctp_authchunks
))
6255 if (copy_from_user(&val
, optval
, sizeof(val
)))
6258 to
= p
->gauth_chunks
;
6259 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
6263 ch
= asoc
->peer
.peer_chunks
;
6267 /* See if the user provided enough room for all the data */
6268 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
6269 if (len
< num_chunks
)
6272 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
6275 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
6276 if (put_user(len
, optlen
))
6278 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
6283 static int sctp_getsockopt_local_auth_chunks(struct sock
*sk
, int len
,
6284 char __user
*optval
, int __user
*optlen
)
6286 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6287 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
6288 struct sctp_authchunks val
;
6289 struct sctp_association
*asoc
;
6290 struct sctp_chunks_param
*ch
;
6294 if (!ep
->auth_enable
)
6297 if (len
< sizeof(struct sctp_authchunks
))
6300 if (copy_from_user(&val
, optval
, sizeof(val
)))
6303 to
= p
->gauth_chunks
;
6304 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
6305 if (!asoc
&& val
.gauth_assoc_id
&& sctp_style(sk
, UDP
))
6309 ch
= (struct sctp_chunks_param
*)asoc
->c
.auth_chunks
;
6311 ch
= ep
->auth_chunk_list
;
6316 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
6317 if (len
< sizeof(struct sctp_authchunks
) + num_chunks
)
6320 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
6323 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
6324 if (put_user(len
, optlen
))
6326 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
6333 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
6334 * This option gets the current number of associations that are attached
6335 * to a one-to-many style socket. The option value is an uint32_t.
6337 static int sctp_getsockopt_assoc_number(struct sock
*sk
, int len
,
6338 char __user
*optval
, int __user
*optlen
)
6340 struct sctp_sock
*sp
= sctp_sk(sk
);
6341 struct sctp_association
*asoc
;
6344 if (sctp_style(sk
, TCP
))
6347 if (len
< sizeof(u32
))
6352 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6356 if (put_user(len
, optlen
))
6358 if (copy_to_user(optval
, &val
, len
))
6365 * 8.1.23 SCTP_AUTO_ASCONF
6366 * See the corresponding setsockopt entry as description
6368 static int sctp_getsockopt_auto_asconf(struct sock
*sk
, int len
,
6369 char __user
*optval
, int __user
*optlen
)
6373 if (len
< sizeof(int))
6377 if (sctp_sk(sk
)->do_auto_asconf
&& sctp_is_ep_boundall(sk
))
6379 if (put_user(len
, optlen
))
6381 if (copy_to_user(optval
, &val
, len
))
6387 * 8.2.6. Get the Current Identifiers of Associations
6388 * (SCTP_GET_ASSOC_ID_LIST)
6390 * This option gets the current list of SCTP association identifiers of
6391 * the SCTP associations handled by a one-to-many style socket.
6393 static int sctp_getsockopt_assoc_ids(struct sock
*sk
, int len
,
6394 char __user
*optval
, int __user
*optlen
)
6396 struct sctp_sock
*sp
= sctp_sk(sk
);
6397 struct sctp_association
*asoc
;
6398 struct sctp_assoc_ids
*ids
;
6401 if (sctp_style(sk
, TCP
))
6404 if (len
< sizeof(struct sctp_assoc_ids
))
6407 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6411 if (len
< sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
)
6414 len
= sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
;
6416 ids
= kmalloc(len
, GFP_USER
| __GFP_NOWARN
);
6420 ids
->gaids_number_of_ids
= num
;
6422 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6423 ids
->gaids_assoc_id
[num
++] = asoc
->assoc_id
;
6426 if (put_user(len
, optlen
) || copy_to_user(optval
, ids
, len
)) {
6436 * SCTP_PEER_ADDR_THLDS
6438 * This option allows us to fetch the partially failed threshold for one or all
6439 * transports in an association. See Section 6.1 of:
6440 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
6442 static int sctp_getsockopt_paddr_thresholds(struct sock
*sk
,
6443 char __user
*optval
,
6447 struct sctp_paddrthlds val
;
6448 struct sctp_transport
*trans
;
6449 struct sctp_association
*asoc
;
6451 if (len
< sizeof(struct sctp_paddrthlds
))
6453 len
= sizeof(struct sctp_paddrthlds
);
6454 if (copy_from_user(&val
, (struct sctp_paddrthlds __user
*)optval
, len
))
6457 if (sctp_is_any(sk
, (const union sctp_addr
*)&val
.spt_address
)) {
6458 asoc
= sctp_id2assoc(sk
, val
.spt_assoc_id
);
6462 val
.spt_pathpfthld
= asoc
->pf_retrans
;
6463 val
.spt_pathmaxrxt
= asoc
->pathmaxrxt
;
6465 trans
= sctp_addr_id2transport(sk
, &val
.spt_address
,
6470 val
.spt_pathmaxrxt
= trans
->pathmaxrxt
;
6471 val
.spt_pathpfthld
= trans
->pf_retrans
;
6474 if (put_user(len
, optlen
) || copy_to_user(optval
, &val
, len
))
6481 * SCTP_GET_ASSOC_STATS
6483 * This option retrieves local per endpoint statistics. It is modeled
6484 * after OpenSolaris' implementation
6486 static int sctp_getsockopt_assoc_stats(struct sock
*sk
, int len
,
6487 char __user
*optval
,
6490 struct sctp_assoc_stats sas
;
6491 struct sctp_association
*asoc
= NULL
;
6493 /* User must provide at least the assoc id */
6494 if (len
< sizeof(sctp_assoc_t
))
6497 /* Allow the struct to grow and fill in as much as possible */
6498 len
= min_t(size_t, len
, sizeof(sas
));
6500 if (copy_from_user(&sas
, optval
, len
))
6503 asoc
= sctp_id2assoc(sk
, sas
.sas_assoc_id
);
6507 sas
.sas_rtxchunks
= asoc
->stats
.rtxchunks
;
6508 sas
.sas_gapcnt
= asoc
->stats
.gapcnt
;
6509 sas
.sas_outofseqtsns
= asoc
->stats
.outofseqtsns
;
6510 sas
.sas_osacks
= asoc
->stats
.osacks
;
6511 sas
.sas_isacks
= asoc
->stats
.isacks
;
6512 sas
.sas_octrlchunks
= asoc
->stats
.octrlchunks
;
6513 sas
.sas_ictrlchunks
= asoc
->stats
.ictrlchunks
;
6514 sas
.sas_oodchunks
= asoc
->stats
.oodchunks
;
6515 sas
.sas_iodchunks
= asoc
->stats
.iodchunks
;
6516 sas
.sas_ouodchunks
= asoc
->stats
.ouodchunks
;
6517 sas
.sas_iuodchunks
= asoc
->stats
.iuodchunks
;
6518 sas
.sas_idupchunks
= asoc
->stats
.idupchunks
;
6519 sas
.sas_opackets
= asoc
->stats
.opackets
;
6520 sas
.sas_ipackets
= asoc
->stats
.ipackets
;
6522 /* New high max rto observed, will return 0 if not a single
6523 * RTO update took place. obs_rto_ipaddr will be bogus
6526 sas
.sas_maxrto
= asoc
->stats
.max_obs_rto
;
6527 memcpy(&sas
.sas_obs_rto_ipaddr
, &asoc
->stats
.obs_rto_ipaddr
,
6528 sizeof(struct sockaddr_storage
));
6530 /* Mark beginning of a new observation period */
6531 asoc
->stats
.max_obs_rto
= asoc
->rto_min
;
6533 if (put_user(len
, optlen
))
6536 pr_debug("%s: len:%d, assoc_id:%d\n", __func__
, len
, sas
.sas_assoc_id
);
6538 if (copy_to_user(optval
, &sas
, len
))
6544 static int sctp_getsockopt_recvrcvinfo(struct sock
*sk
, int len
,
6545 char __user
*optval
,
6550 if (len
< sizeof(int))
6554 if (sctp_sk(sk
)->recvrcvinfo
)
6556 if (put_user(len
, optlen
))
6558 if (copy_to_user(optval
, &val
, len
))
6564 static int sctp_getsockopt_recvnxtinfo(struct sock
*sk
, int len
,
6565 char __user
*optval
,
6570 if (len
< sizeof(int))
6574 if (sctp_sk(sk
)->recvnxtinfo
)
6576 if (put_user(len
, optlen
))
6578 if (copy_to_user(optval
, &val
, len
))
6584 static int sctp_getsockopt_pr_supported(struct sock
*sk
, int len
,
6585 char __user
*optval
,
6588 struct sctp_assoc_value params
;
6589 struct sctp_association
*asoc
;
6590 int retval
= -EFAULT
;
6592 if (len
< sizeof(params
)) {
6597 len
= sizeof(params
);
6598 if (copy_from_user(¶ms
, optval
, len
))
6601 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6603 params
.assoc_value
= asoc
->prsctp_enable
;
6604 } else if (!params
.assoc_id
) {
6605 struct sctp_sock
*sp
= sctp_sk(sk
);
6607 params
.assoc_value
= sp
->ep
->prsctp_enable
;
6613 if (put_user(len
, optlen
))
6616 if (copy_to_user(optval
, ¶ms
, len
))
6625 static int sctp_getsockopt_default_prinfo(struct sock
*sk
, int len
,
6626 char __user
*optval
,
6629 struct sctp_default_prinfo info
;
6630 struct sctp_association
*asoc
;
6631 int retval
= -EFAULT
;
6633 if (len
< sizeof(info
)) {
6639 if (copy_from_user(&info
, optval
, len
))
6642 asoc
= sctp_id2assoc(sk
, info
.pr_assoc_id
);
6644 info
.pr_policy
= SCTP_PR_POLICY(asoc
->default_flags
);
6645 info
.pr_value
= asoc
->default_timetolive
;
6646 } else if (!info
.pr_assoc_id
) {
6647 struct sctp_sock
*sp
= sctp_sk(sk
);
6649 info
.pr_policy
= SCTP_PR_POLICY(sp
->default_flags
);
6650 info
.pr_value
= sp
->default_timetolive
;
6656 if (put_user(len
, optlen
))
6659 if (copy_to_user(optval
, &info
, len
))
6668 static int sctp_getsockopt_pr_assocstatus(struct sock
*sk
, int len
,
6669 char __user
*optval
,
6672 struct sctp_prstatus params
;
6673 struct sctp_association
*asoc
;
6675 int retval
= -EINVAL
;
6677 if (len
< sizeof(params
))
6680 len
= sizeof(params
);
6681 if (copy_from_user(¶ms
, optval
, len
)) {
6686 policy
= params
.sprstat_policy
;
6687 if (policy
& ~SCTP_PR_SCTP_MASK
)
6690 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
6694 if (policy
== SCTP_PR_SCTP_NONE
) {
6695 params
.sprstat_abandoned_unsent
= 0;
6696 params
.sprstat_abandoned_sent
= 0;
6697 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
6698 params
.sprstat_abandoned_unsent
+=
6699 asoc
->abandoned_unsent
[policy
];
6700 params
.sprstat_abandoned_sent
+=
6701 asoc
->abandoned_sent
[policy
];
6704 params
.sprstat_abandoned_unsent
=
6705 asoc
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
6706 params
.sprstat_abandoned_sent
=
6707 asoc
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
6710 if (put_user(len
, optlen
)) {
6715 if (copy_to_user(optval
, ¶ms
, len
)) {
6726 static int sctp_getsockopt_pr_streamstatus(struct sock
*sk
, int len
,
6727 char __user
*optval
,
6730 struct sctp_stream_out
*streamout
;
6731 struct sctp_association
*asoc
;
6732 struct sctp_prstatus params
;
6733 int retval
= -EINVAL
;
6736 if (len
< sizeof(params
))
6739 len
= sizeof(params
);
6740 if (copy_from_user(¶ms
, optval
, len
)) {
6745 policy
= params
.sprstat_policy
;
6746 if (policy
& ~SCTP_PR_SCTP_MASK
)
6749 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
6750 if (!asoc
|| params
.sprstat_sid
>= asoc
->stream
.outcnt
)
6753 streamout
= &asoc
->stream
.out
[params
.sprstat_sid
];
6754 if (policy
== SCTP_PR_SCTP_NONE
) {
6755 params
.sprstat_abandoned_unsent
= 0;
6756 params
.sprstat_abandoned_sent
= 0;
6757 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
6758 params
.sprstat_abandoned_unsent
+=
6759 streamout
->abandoned_unsent
[policy
];
6760 params
.sprstat_abandoned_sent
+=
6761 streamout
->abandoned_sent
[policy
];
6764 params
.sprstat_abandoned_unsent
=
6765 streamout
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
6766 params
.sprstat_abandoned_sent
=
6767 streamout
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
6770 if (put_user(len
, optlen
) || copy_to_user(optval
, ¶ms
, len
)) {
6781 static int sctp_getsockopt_reconfig_supported(struct sock
*sk
, int len
,
6782 char __user
*optval
,
6785 struct sctp_assoc_value params
;
6786 struct sctp_association
*asoc
;
6787 int retval
= -EFAULT
;
6789 if (len
< sizeof(params
)) {
6794 len
= sizeof(params
);
6795 if (copy_from_user(¶ms
, optval
, len
))
6798 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6800 params
.assoc_value
= asoc
->reconf_enable
;
6801 } else if (!params
.assoc_id
) {
6802 struct sctp_sock
*sp
= sctp_sk(sk
);
6804 params
.assoc_value
= sp
->ep
->reconf_enable
;
6810 if (put_user(len
, optlen
))
6813 if (copy_to_user(optval
, ¶ms
, len
))
6822 static int sctp_getsockopt_enable_strreset(struct sock
*sk
, int len
,
6823 char __user
*optval
,
6826 struct sctp_assoc_value params
;
6827 struct sctp_association
*asoc
;
6828 int retval
= -EFAULT
;
6830 if (len
< sizeof(params
)) {
6835 len
= sizeof(params
);
6836 if (copy_from_user(¶ms
, optval
, len
))
6839 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6841 params
.assoc_value
= asoc
->strreset_enable
;
6842 } else if (!params
.assoc_id
) {
6843 struct sctp_sock
*sp
= sctp_sk(sk
);
6845 params
.assoc_value
= sp
->ep
->strreset_enable
;
6851 if (put_user(len
, optlen
))
6854 if (copy_to_user(optval
, ¶ms
, len
))
6863 static int sctp_getsockopt(struct sock
*sk
, int level
, int optname
,
6864 char __user
*optval
, int __user
*optlen
)
6869 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
6871 /* I can hardly begin to describe how wrong this is. This is
6872 * so broken as to be worse than useless. The API draft
6873 * REALLY is NOT helpful here... I am not convinced that the
6874 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
6875 * are at all well-founded.
6877 if (level
!= SOL_SCTP
) {
6878 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
6880 retval
= af
->getsockopt(sk
, level
, optname
, optval
, optlen
);
6884 if (get_user(len
, optlen
))
6894 retval
= sctp_getsockopt_sctp_status(sk
, len
, optval
, optlen
);
6896 case SCTP_DISABLE_FRAGMENTS
:
6897 retval
= sctp_getsockopt_disable_fragments(sk
, len
, optval
,
6901 retval
= sctp_getsockopt_events(sk
, len
, optval
, optlen
);
6903 case SCTP_AUTOCLOSE
:
6904 retval
= sctp_getsockopt_autoclose(sk
, len
, optval
, optlen
);
6906 case SCTP_SOCKOPT_PEELOFF
:
6907 retval
= sctp_getsockopt_peeloff(sk
, len
, optval
, optlen
);
6909 case SCTP_SOCKOPT_PEELOFF_FLAGS
:
6910 retval
= sctp_getsockopt_peeloff_flags(sk
, len
, optval
, optlen
);
6912 case SCTP_PEER_ADDR_PARAMS
:
6913 retval
= sctp_getsockopt_peer_addr_params(sk
, len
, optval
,
6916 case SCTP_DELAYED_SACK
:
6917 retval
= sctp_getsockopt_delayed_ack(sk
, len
, optval
,
6921 retval
= sctp_getsockopt_initmsg(sk
, len
, optval
, optlen
);
6923 case SCTP_GET_PEER_ADDRS
:
6924 retval
= sctp_getsockopt_peer_addrs(sk
, len
, optval
,
6927 case SCTP_GET_LOCAL_ADDRS
:
6928 retval
= sctp_getsockopt_local_addrs(sk
, len
, optval
,
6931 case SCTP_SOCKOPT_CONNECTX3
:
6932 retval
= sctp_getsockopt_connectx3(sk
, len
, optval
, optlen
);
6934 case SCTP_DEFAULT_SEND_PARAM
:
6935 retval
= sctp_getsockopt_default_send_param(sk
, len
,
6938 case SCTP_DEFAULT_SNDINFO
:
6939 retval
= sctp_getsockopt_default_sndinfo(sk
, len
,
6942 case SCTP_PRIMARY_ADDR
:
6943 retval
= sctp_getsockopt_primary_addr(sk
, len
, optval
, optlen
);
6946 retval
= sctp_getsockopt_nodelay(sk
, len
, optval
, optlen
);
6949 retval
= sctp_getsockopt_rtoinfo(sk
, len
, optval
, optlen
);
6951 case SCTP_ASSOCINFO
:
6952 retval
= sctp_getsockopt_associnfo(sk
, len
, optval
, optlen
);
6954 case SCTP_I_WANT_MAPPED_V4_ADDR
:
6955 retval
= sctp_getsockopt_mappedv4(sk
, len
, optval
, optlen
);
6958 retval
= sctp_getsockopt_maxseg(sk
, len
, optval
, optlen
);
6960 case SCTP_GET_PEER_ADDR_INFO
:
6961 retval
= sctp_getsockopt_peer_addr_info(sk
, len
, optval
,
6964 case SCTP_ADAPTATION_LAYER
:
6965 retval
= sctp_getsockopt_adaptation_layer(sk
, len
, optval
,
6969 retval
= sctp_getsockopt_context(sk
, len
, optval
, optlen
);
6971 case SCTP_FRAGMENT_INTERLEAVE
:
6972 retval
= sctp_getsockopt_fragment_interleave(sk
, len
, optval
,
6975 case SCTP_PARTIAL_DELIVERY_POINT
:
6976 retval
= sctp_getsockopt_partial_delivery_point(sk
, len
, optval
,
6979 case SCTP_MAX_BURST
:
6980 retval
= sctp_getsockopt_maxburst(sk
, len
, optval
, optlen
);
6983 case SCTP_AUTH_CHUNK
:
6984 case SCTP_AUTH_DELETE_KEY
:
6985 retval
= -EOPNOTSUPP
;
6987 case SCTP_HMAC_IDENT
:
6988 retval
= sctp_getsockopt_hmac_ident(sk
, len
, optval
, optlen
);
6990 case SCTP_AUTH_ACTIVE_KEY
:
6991 retval
= sctp_getsockopt_active_key(sk
, len
, optval
, optlen
);
6993 case SCTP_PEER_AUTH_CHUNKS
:
6994 retval
= sctp_getsockopt_peer_auth_chunks(sk
, len
, optval
,
6997 case SCTP_LOCAL_AUTH_CHUNKS
:
6998 retval
= sctp_getsockopt_local_auth_chunks(sk
, len
, optval
,
7001 case SCTP_GET_ASSOC_NUMBER
:
7002 retval
= sctp_getsockopt_assoc_number(sk
, len
, optval
, optlen
);
7004 case SCTP_GET_ASSOC_ID_LIST
:
7005 retval
= sctp_getsockopt_assoc_ids(sk
, len
, optval
, optlen
);
7007 case SCTP_AUTO_ASCONF
:
7008 retval
= sctp_getsockopt_auto_asconf(sk
, len
, optval
, optlen
);
7010 case SCTP_PEER_ADDR_THLDS
:
7011 retval
= sctp_getsockopt_paddr_thresholds(sk
, optval
, len
, optlen
);
7013 case SCTP_GET_ASSOC_STATS
:
7014 retval
= sctp_getsockopt_assoc_stats(sk
, len
, optval
, optlen
);
7016 case SCTP_RECVRCVINFO
:
7017 retval
= sctp_getsockopt_recvrcvinfo(sk
, len
, optval
, optlen
);
7019 case SCTP_RECVNXTINFO
:
7020 retval
= sctp_getsockopt_recvnxtinfo(sk
, len
, optval
, optlen
);
7022 case SCTP_PR_SUPPORTED
:
7023 retval
= sctp_getsockopt_pr_supported(sk
, len
, optval
, optlen
);
7025 case SCTP_DEFAULT_PRINFO
:
7026 retval
= sctp_getsockopt_default_prinfo(sk
, len
, optval
,
7029 case SCTP_PR_ASSOC_STATUS
:
7030 retval
= sctp_getsockopt_pr_assocstatus(sk
, len
, optval
,
7033 case SCTP_PR_STREAM_STATUS
:
7034 retval
= sctp_getsockopt_pr_streamstatus(sk
, len
, optval
,
7037 case SCTP_RECONFIG_SUPPORTED
:
7038 retval
= sctp_getsockopt_reconfig_supported(sk
, len
, optval
,
7041 case SCTP_ENABLE_STREAM_RESET
:
7042 retval
= sctp_getsockopt_enable_strreset(sk
, len
, optval
,
7046 retval
= -ENOPROTOOPT
;
7054 static int sctp_hash(struct sock
*sk
)
7060 static void sctp_unhash(struct sock
*sk
)
7065 /* Check if port is acceptable. Possibly find first available port.
7067 * The port hash table (contained in the 'global' SCTP protocol storage
7068 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
7069 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
7070 * list (the list number is the port number hashed out, so as you
7071 * would expect from a hash function, all the ports in a given list have
7072 * such a number that hashes out to the same list number; you were
7073 * expecting that, right?); so each list has a set of ports, with a
7074 * link to the socket (struct sock) that uses it, the port number and
7075 * a fastreuse flag (FIXME: NPI ipg).
7077 static struct sctp_bind_bucket
*sctp_bucket_create(
7078 struct sctp_bind_hashbucket
*head
, struct net
*, unsigned short snum
);
7080 static long sctp_get_port_local(struct sock
*sk
, union sctp_addr
*addr
)
7082 struct sctp_bind_hashbucket
*head
; /* hash list */
7083 struct sctp_bind_bucket
*pp
;
7084 unsigned short snum
;
7087 snum
= ntohs(addr
->v4
.sin_port
);
7089 pr_debug("%s: begins, snum:%d\n", __func__
, snum
);
7094 /* Search for an available port. */
7095 int low
, high
, remaining
, index
;
7097 struct net
*net
= sock_net(sk
);
7099 inet_get_local_port_range(net
, &low
, &high
);
7100 remaining
= (high
- low
) + 1;
7101 rover
= prandom_u32() % remaining
+ low
;
7105 if ((rover
< low
) || (rover
> high
))
7107 if (inet_is_local_reserved_port(net
, rover
))
7109 index
= sctp_phashfn(sock_net(sk
), rover
);
7110 head
= &sctp_port_hashtable
[index
];
7111 spin_lock(&head
->lock
);
7112 sctp_for_each_hentry(pp
, &head
->chain
)
7113 if ((pp
->port
== rover
) &&
7114 net_eq(sock_net(sk
), pp
->net
))
7118 spin_unlock(&head
->lock
);
7119 } while (--remaining
> 0);
7121 /* Exhausted local port range during search? */
7126 /* OK, here is the one we will use. HEAD (the port
7127 * hash table list entry) is non-NULL and we hold it's
7132 /* We are given an specific port number; we verify
7133 * that it is not being used. If it is used, we will
7134 * exahust the search in the hash list corresponding
7135 * to the port number (snum) - we detect that with the
7136 * port iterator, pp being NULL.
7138 head
= &sctp_port_hashtable
[sctp_phashfn(sock_net(sk
), snum
)];
7139 spin_lock(&head
->lock
);
7140 sctp_for_each_hentry(pp
, &head
->chain
) {
7141 if ((pp
->port
== snum
) && net_eq(pp
->net
, sock_net(sk
)))
7148 if (!hlist_empty(&pp
->owner
)) {
7149 /* We had a port hash table hit - there is an
7150 * available port (pp != NULL) and it is being
7151 * used by other socket (pp->owner not empty); that other
7152 * socket is going to be sk2.
7154 int reuse
= sk
->sk_reuse
;
7157 pr_debug("%s: found a possible match\n", __func__
);
7159 if (pp
->fastreuse
&& sk
->sk_reuse
&&
7160 sk
->sk_state
!= SCTP_SS_LISTENING
)
7163 /* Run through the list of sockets bound to the port
7164 * (pp->port) [via the pointers bind_next and
7165 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
7166 * we get the endpoint they describe and run through
7167 * the endpoint's list of IP (v4 or v6) addresses,
7168 * comparing each of the addresses with the address of
7169 * the socket sk. If we find a match, then that means
7170 * that this port/socket (sk) combination are already
7173 sk_for_each_bound(sk2
, &pp
->owner
) {
7174 struct sctp_endpoint
*ep2
;
7175 ep2
= sctp_sk(sk2
)->ep
;
7178 (reuse
&& sk2
->sk_reuse
&&
7179 sk2
->sk_state
!= SCTP_SS_LISTENING
))
7182 if (sctp_bind_addr_conflict(&ep2
->base
.bind_addr
, addr
,
7183 sctp_sk(sk2
), sctp_sk(sk
))) {
7189 pr_debug("%s: found a match\n", __func__
);
7192 /* If there was a hash table miss, create a new port. */
7194 if (!pp
&& !(pp
= sctp_bucket_create(head
, sock_net(sk
), snum
)))
7197 /* In either case (hit or miss), make sure fastreuse is 1 only
7198 * if sk->sk_reuse is too (that is, if the caller requested
7199 * SO_REUSEADDR on this socket -sk-).
7201 if (hlist_empty(&pp
->owner
)) {
7202 if (sk
->sk_reuse
&& sk
->sk_state
!= SCTP_SS_LISTENING
)
7206 } else if (pp
->fastreuse
&&
7207 (!sk
->sk_reuse
|| sk
->sk_state
== SCTP_SS_LISTENING
))
7210 /* We are set, so fill up all the data in the hash table
7211 * entry, tie the socket list information with the rest of the
7212 * sockets FIXME: Blurry, NPI (ipg).
7215 if (!sctp_sk(sk
)->bind_hash
) {
7216 inet_sk(sk
)->inet_num
= snum
;
7217 sk_add_bind_node(sk
, &pp
->owner
);
7218 sctp_sk(sk
)->bind_hash
= pp
;
7223 spin_unlock(&head
->lock
);
7230 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
7231 * port is requested.
7233 static int sctp_get_port(struct sock
*sk
, unsigned short snum
)
7235 union sctp_addr addr
;
7236 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
7238 /* Set up a dummy address struct from the sk. */
7239 af
->from_sk(&addr
, sk
);
7240 addr
.v4
.sin_port
= htons(snum
);
7242 /* Note: sk->sk_num gets filled in if ephemeral port request. */
7243 return !!sctp_get_port_local(sk
, &addr
);
7247 * Move a socket to LISTENING state.
7249 static int sctp_listen_start(struct sock
*sk
, int backlog
)
7251 struct sctp_sock
*sp
= sctp_sk(sk
);
7252 struct sctp_endpoint
*ep
= sp
->ep
;
7253 struct crypto_shash
*tfm
= NULL
;
7256 /* Allocate HMAC for generating cookie. */
7257 if (!sp
->hmac
&& sp
->sctp_hmac_alg
) {
7258 sprintf(alg
, "hmac(%s)", sp
->sctp_hmac_alg
);
7259 tfm
= crypto_alloc_shash(alg
, 0, 0);
7261 net_info_ratelimited("failed to load transform for %s: %ld\n",
7262 sp
->sctp_hmac_alg
, PTR_ERR(tfm
));
7265 sctp_sk(sk
)->hmac
= tfm
;
7269 * If a bind() or sctp_bindx() is not called prior to a listen()
7270 * call that allows new associations to be accepted, the system
7271 * picks an ephemeral port and will choose an address set equivalent
7272 * to binding with a wildcard address.
7274 * This is not currently spelled out in the SCTP sockets
7275 * extensions draft, but follows the practice as seen in TCP
7279 sk
->sk_state
= SCTP_SS_LISTENING
;
7280 if (!ep
->base
.bind_addr
.port
) {
7281 if (sctp_autobind(sk
))
7284 if (sctp_get_port(sk
, inet_sk(sk
)->inet_num
)) {
7285 sk
->sk_state
= SCTP_SS_CLOSED
;
7290 sk
->sk_max_ack_backlog
= backlog
;
7291 sctp_hash_endpoint(ep
);
7296 * 4.1.3 / 5.1.3 listen()
7298 * By default, new associations are not accepted for UDP style sockets.
7299 * An application uses listen() to mark a socket as being able to
7300 * accept new associations.
7302 * On TCP style sockets, applications use listen() to ready the SCTP
7303 * endpoint for accepting inbound associations.
7305 * On both types of endpoints a backlog of '0' disables listening.
7307 * Move a socket to LISTENING state.
7309 int sctp_inet_listen(struct socket
*sock
, int backlog
)
7311 struct sock
*sk
= sock
->sk
;
7312 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
7315 if (unlikely(backlog
< 0))
7320 /* Peeled-off sockets are not allowed to listen(). */
7321 if (sctp_style(sk
, UDP_HIGH_BANDWIDTH
))
7324 if (sock
->state
!= SS_UNCONNECTED
)
7327 if (!sctp_sstate(sk
, LISTENING
) && !sctp_sstate(sk
, CLOSED
))
7330 /* If backlog is zero, disable listening. */
7332 if (sctp_sstate(sk
, CLOSED
))
7336 sctp_unhash_endpoint(ep
);
7337 sk
->sk_state
= SCTP_SS_CLOSED
;
7339 sctp_sk(sk
)->bind_hash
->fastreuse
= 1;
7343 /* If we are already listening, just update the backlog */
7344 if (sctp_sstate(sk
, LISTENING
))
7345 sk
->sk_max_ack_backlog
= backlog
;
7347 err
= sctp_listen_start(sk
, backlog
);
7359 * This function is done by modeling the current datagram_poll() and the
7360 * tcp_poll(). Note that, based on these implementations, we don't
7361 * lock the socket in this function, even though it seems that,
7362 * ideally, locking or some other mechanisms can be used to ensure
7363 * the integrity of the counters (sndbuf and wmem_alloc) used
7364 * in this place. We assume that we don't need locks either until proven
7367 * Another thing to note is that we include the Async I/O support
7368 * here, again, by modeling the current TCP/UDP code. We don't have
7369 * a good way to test with it yet.
7371 unsigned int sctp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
7373 struct sock
*sk
= sock
->sk
;
7374 struct sctp_sock
*sp
= sctp_sk(sk
);
7377 poll_wait(file
, sk_sleep(sk
), wait
);
7379 sock_rps_record_flow(sk
);
7381 /* A TCP-style listening socket becomes readable when the accept queue
7384 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
7385 return (!list_empty(&sp
->ep
->asocs
)) ?
7386 (POLLIN
| POLLRDNORM
) : 0;
7390 /* Is there any exceptional events? */
7391 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
7393 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? POLLPRI
: 0);
7394 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
7395 mask
|= POLLRDHUP
| POLLIN
| POLLRDNORM
;
7396 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
7399 /* Is it readable? Reconsider this code with TCP-style support. */
7400 if (!skb_queue_empty(&sk
->sk_receive_queue
))
7401 mask
|= POLLIN
| POLLRDNORM
;
7403 /* The association is either gone or not ready. */
7404 if (!sctp_style(sk
, UDP
) && sctp_sstate(sk
, CLOSED
))
7407 /* Is it writable? */
7408 if (sctp_writeable(sk
)) {
7409 mask
|= POLLOUT
| POLLWRNORM
;
7411 sk_set_bit(SOCKWQ_ASYNC_NOSPACE
, sk
);
7413 * Since the socket is not locked, the buffer
7414 * might be made available after the writeable check and
7415 * before the bit is set. This could cause a lost I/O
7416 * signal. tcp_poll() has a race breaker for this race
7417 * condition. Based on their implementation, we put
7418 * in the following code to cover it as well.
7420 if (sctp_writeable(sk
))
7421 mask
|= POLLOUT
| POLLWRNORM
;
7426 /********************************************************************
7427 * 2nd Level Abstractions
7428 ********************************************************************/
7430 static struct sctp_bind_bucket
*sctp_bucket_create(
7431 struct sctp_bind_hashbucket
*head
, struct net
*net
, unsigned short snum
)
7433 struct sctp_bind_bucket
*pp
;
7435 pp
= kmem_cache_alloc(sctp_bucket_cachep
, GFP_ATOMIC
);
7437 SCTP_DBG_OBJCNT_INC(bind_bucket
);
7440 INIT_HLIST_HEAD(&pp
->owner
);
7442 hlist_add_head(&pp
->node
, &head
->chain
);
7447 /* Caller must hold hashbucket lock for this tb with local BH disabled */
7448 static void sctp_bucket_destroy(struct sctp_bind_bucket
*pp
)
7450 if (pp
&& hlist_empty(&pp
->owner
)) {
7451 __hlist_del(&pp
->node
);
7452 kmem_cache_free(sctp_bucket_cachep
, pp
);
7453 SCTP_DBG_OBJCNT_DEC(bind_bucket
);
7457 /* Release this socket's reference to a local port. */
7458 static inline void __sctp_put_port(struct sock
*sk
)
7460 struct sctp_bind_hashbucket
*head
=
7461 &sctp_port_hashtable
[sctp_phashfn(sock_net(sk
),
7462 inet_sk(sk
)->inet_num
)];
7463 struct sctp_bind_bucket
*pp
;
7465 spin_lock(&head
->lock
);
7466 pp
= sctp_sk(sk
)->bind_hash
;
7467 __sk_del_bind_node(sk
);
7468 sctp_sk(sk
)->bind_hash
= NULL
;
7469 inet_sk(sk
)->inet_num
= 0;
7470 sctp_bucket_destroy(pp
);
7471 spin_unlock(&head
->lock
);
7474 void sctp_put_port(struct sock
*sk
)
7477 __sctp_put_port(sk
);
7482 * The system picks an ephemeral port and choose an address set equivalent
7483 * to binding with a wildcard address.
7484 * One of those addresses will be the primary address for the association.
7485 * This automatically enables the multihoming capability of SCTP.
7487 static int sctp_autobind(struct sock
*sk
)
7489 union sctp_addr autoaddr
;
7493 /* Initialize a local sockaddr structure to INADDR_ANY. */
7494 af
= sctp_sk(sk
)->pf
->af
;
7496 port
= htons(inet_sk(sk
)->inet_num
);
7497 af
->inaddr_any(&autoaddr
, port
);
7499 return sctp_do_bind(sk
, &autoaddr
, af
->sockaddr_len
);
7502 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
7505 * 4.2 The cmsghdr Structure *
7507 * When ancillary data is sent or received, any number of ancillary data
7508 * objects can be specified by the msg_control and msg_controllen members of
7509 * the msghdr structure, because each object is preceded by
7510 * a cmsghdr structure defining the object's length (the cmsg_len member).
7511 * Historically Berkeley-derived implementations have passed only one object
7512 * at a time, but this API allows multiple objects to be
7513 * passed in a single call to sendmsg() or recvmsg(). The following example
7514 * shows two ancillary data objects in a control buffer.
7516 * |<--------------------------- msg_controllen -------------------------->|
7519 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
7521 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
7524 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
7526 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
7529 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
7530 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
7532 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
7534 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
7541 static int sctp_msghdr_parse(const struct msghdr
*msg
, struct sctp_cmsgs
*cmsgs
)
7543 struct msghdr
*my_msg
= (struct msghdr
*)msg
;
7544 struct cmsghdr
*cmsg
;
7546 for_each_cmsghdr(cmsg
, my_msg
) {
7547 if (!CMSG_OK(my_msg
, cmsg
))
7550 /* Should we parse this header or ignore? */
7551 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
)
7554 /* Strictly check lengths following example in SCM code. */
7555 switch (cmsg
->cmsg_type
) {
7557 /* SCTP Socket API Extension
7558 * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
7560 * This cmsghdr structure provides information for
7561 * initializing new SCTP associations with sendmsg().
7562 * The SCTP_INITMSG socket option uses this same data
7563 * structure. This structure is not used for
7566 * cmsg_level cmsg_type cmsg_data[]
7567 * ------------ ------------ ----------------------
7568 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
7570 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_initmsg
)))
7573 cmsgs
->init
= CMSG_DATA(cmsg
);
7577 /* SCTP Socket API Extension
7578 * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
7580 * This cmsghdr structure specifies SCTP options for
7581 * sendmsg() and describes SCTP header information
7582 * about a received message through recvmsg().
7584 * cmsg_level cmsg_type cmsg_data[]
7585 * ------------ ------------ ----------------------
7586 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
7588 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndrcvinfo
)))
7591 cmsgs
->srinfo
= CMSG_DATA(cmsg
);
7593 if (cmsgs
->srinfo
->sinfo_flags
&
7594 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
7595 SCTP_SACK_IMMEDIATELY
| SCTP_PR_SCTP_MASK
|
7596 SCTP_ABORT
| SCTP_EOF
))
7601 /* SCTP Socket API Extension
7602 * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
7604 * This cmsghdr structure specifies SCTP options for
7605 * sendmsg(). This structure and SCTP_RCVINFO replaces
7606 * SCTP_SNDRCV which has been deprecated.
7608 * cmsg_level cmsg_type cmsg_data[]
7609 * ------------ ------------ ---------------------
7610 * IPPROTO_SCTP SCTP_SNDINFO struct sctp_sndinfo
7612 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndinfo
)))
7615 cmsgs
->sinfo
= CMSG_DATA(cmsg
);
7617 if (cmsgs
->sinfo
->snd_flags
&
7618 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
7619 SCTP_SACK_IMMEDIATELY
| SCTP_PR_SCTP_MASK
|
7620 SCTP_ABORT
| SCTP_EOF
))
7632 * Wait for a packet..
7633 * Note: This function is the same function as in core/datagram.c
7634 * with a few modifications to make lksctp work.
7636 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
)
7641 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
7643 /* Socket errors? */
7644 error
= sock_error(sk
);
7648 if (!skb_queue_empty(&sk
->sk_receive_queue
))
7651 /* Socket shut down? */
7652 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
7655 /* Sequenced packets can come disconnected. If so we report the
7660 /* Is there a good reason to think that we may receive some data? */
7661 if (list_empty(&sctp_sk(sk
)->ep
->asocs
) && !sctp_sstate(sk
, LISTENING
))
7664 /* Handle signals. */
7665 if (signal_pending(current
))
7668 /* Let another process have a go. Since we are going to sleep
7669 * anyway. Note: This may cause odd behaviors if the message
7670 * does not fit in the user's buffer, but this seems to be the
7671 * only way to honor MSG_DONTWAIT realistically.
7674 *timeo_p
= schedule_timeout(*timeo_p
);
7678 finish_wait(sk_sleep(sk
), &wait
);
7682 error
= sock_intr_errno(*timeo_p
);
7685 finish_wait(sk_sleep(sk
), &wait
);
7690 /* Receive a datagram.
7691 * Note: This is pretty much the same routine as in core/datagram.c
7692 * with a few changes to make lksctp work.
7694 struct sk_buff
*sctp_skb_recv_datagram(struct sock
*sk
, int flags
,
7695 int noblock
, int *err
)
7698 struct sk_buff
*skb
;
7701 timeo
= sock_rcvtimeo(sk
, noblock
);
7703 pr_debug("%s: timeo:%ld, max:%ld\n", __func__
, timeo
,
7704 MAX_SCHEDULE_TIMEOUT
);
7707 /* Again only user level code calls this function,
7708 * so nothing interrupt level
7709 * will suddenly eat the receive_queue.
7711 * Look at current nfs client by the way...
7712 * However, this function was correct in any case. 8)
7714 if (flags
& MSG_PEEK
) {
7715 skb
= skb_peek(&sk
->sk_receive_queue
);
7717 refcount_inc(&skb
->users
);
7719 skb
= __skb_dequeue(&sk
->sk_receive_queue
);
7725 /* Caller is allowed not to check sk->sk_err before calling. */
7726 error
= sock_error(sk
);
7730 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
7733 if (sk_can_busy_loop(sk
)) {
7734 sk_busy_loop(sk
, noblock
);
7736 if (!skb_queue_empty(&sk
->sk_receive_queue
))
7740 /* User doesn't want to wait. */
7744 } while (sctp_wait_for_packet(sk
, err
, &timeo
) == 0);
7753 /* If sndbuf has changed, wake up per association sndbuf waiters. */
7754 static void __sctp_write_space(struct sctp_association
*asoc
)
7756 struct sock
*sk
= asoc
->base
.sk
;
7758 if (sctp_wspace(asoc
) <= 0)
7761 if (waitqueue_active(&asoc
->wait
))
7762 wake_up_interruptible(&asoc
->wait
);
7764 if (sctp_writeable(sk
)) {
7765 struct socket_wq
*wq
;
7768 wq
= rcu_dereference(sk
->sk_wq
);
7770 if (waitqueue_active(&wq
->wait
))
7771 wake_up_interruptible(&wq
->wait
);
7773 /* Note that we try to include the Async I/O support
7774 * here by modeling from the current TCP/UDP code.
7775 * We have not tested with it yet.
7777 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
))
7778 sock_wake_async(wq
, SOCK_WAKE_SPACE
, POLL_OUT
);
7784 static void sctp_wake_up_waiters(struct sock
*sk
,
7785 struct sctp_association
*asoc
)
7787 struct sctp_association
*tmp
= asoc
;
7789 /* We do accounting for the sndbuf space per association,
7790 * so we only need to wake our own association.
7792 if (asoc
->ep
->sndbuf_policy
)
7793 return __sctp_write_space(asoc
);
7795 /* If association goes down and is just flushing its
7796 * outq, then just normally notify others.
7798 if (asoc
->base
.dead
)
7799 return sctp_write_space(sk
);
7801 /* Accounting for the sndbuf space is per socket, so we
7802 * need to wake up others, try to be fair and in case of
7803 * other associations, let them have a go first instead
7804 * of just doing a sctp_write_space() call.
7806 * Note that we reach sctp_wake_up_waiters() only when
7807 * associations free up queued chunks, thus we are under
7808 * lock and the list of associations on a socket is
7809 * guaranteed not to change.
7811 for (tmp
= list_next_entry(tmp
, asocs
); 1;
7812 tmp
= list_next_entry(tmp
, asocs
)) {
7813 /* Manually skip the head element. */
7814 if (&tmp
->asocs
== &((sctp_sk(sk
))->ep
->asocs
))
7816 /* Wake up association. */
7817 __sctp_write_space(tmp
);
7818 /* We've reached the end. */
7824 /* Do accounting for the sndbuf space.
7825 * Decrement the used sndbuf space of the corresponding association by the
7826 * data size which was just transmitted(freed).
7828 static void sctp_wfree(struct sk_buff
*skb
)
7830 struct sctp_chunk
*chunk
= skb_shinfo(skb
)->destructor_arg
;
7831 struct sctp_association
*asoc
= chunk
->asoc
;
7832 struct sock
*sk
= asoc
->base
.sk
;
7834 asoc
->sndbuf_used
-= SCTP_DATA_SNDSIZE(chunk
) +
7835 sizeof(struct sk_buff
) +
7836 sizeof(struct sctp_chunk
);
7838 WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
));
7841 * This undoes what is done via sctp_set_owner_w and sk_mem_charge
7843 sk
->sk_wmem_queued
-= skb
->truesize
;
7844 sk_mem_uncharge(sk
, skb
->truesize
);
7847 sctp_wake_up_waiters(sk
, asoc
);
7849 sctp_association_put(asoc
);
7852 /* Do accounting for the receive space on the socket.
7853 * Accounting for the association is done in ulpevent.c
7854 * We set this as a destructor for the cloned data skbs so that
7855 * accounting is done at the correct time.
7857 void sctp_sock_rfree(struct sk_buff
*skb
)
7859 struct sock
*sk
= skb
->sk
;
7860 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
7862 atomic_sub(event
->rmem_len
, &sk
->sk_rmem_alloc
);
7865 * Mimic the behavior of sock_rfree
7867 sk_mem_uncharge(sk
, event
->rmem_len
);
7871 /* Helper function to wait for space in the sndbuf. */
7872 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
7875 struct sock
*sk
= asoc
->base
.sk
;
7876 long current_timeo
= *timeo_p
;
7880 pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__
, asoc
,
7883 /* Increment the association's refcnt. */
7884 sctp_association_hold(asoc
);
7886 /* Wait on the association specific sndbuf space. */
7888 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
7889 TASK_INTERRUPTIBLE
);
7890 if (asoc
->base
.dead
)
7894 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
)
7896 if (signal_pending(current
))
7897 goto do_interrupted
;
7898 if (msg_len
<= sctp_wspace(asoc
))
7901 /* Let another process have a go. Since we are going
7905 current_timeo
= schedule_timeout(current_timeo
);
7907 if (sk
!= asoc
->base
.sk
)
7910 *timeo_p
= current_timeo
;
7914 finish_wait(&asoc
->wait
, &wait
);
7916 /* Release the association's refcnt. */
7917 sctp_association_put(asoc
);
7930 err
= sock_intr_errno(*timeo_p
);
7938 void sctp_data_ready(struct sock
*sk
)
7940 struct socket_wq
*wq
;
7943 wq
= rcu_dereference(sk
->sk_wq
);
7944 if (skwq_has_sleeper(wq
))
7945 wake_up_interruptible_sync_poll(&wq
->wait
, POLLIN
|
7946 POLLRDNORM
| POLLRDBAND
);
7947 sk_wake_async(sk
, SOCK_WAKE_WAITD
, POLL_IN
);
7951 /* If socket sndbuf has changed, wake up all per association waiters. */
7952 void sctp_write_space(struct sock
*sk
)
7954 struct sctp_association
*asoc
;
7956 /* Wake up the tasks in each wait queue. */
7957 list_for_each_entry(asoc
, &((sctp_sk(sk
))->ep
->asocs
), asocs
) {
7958 __sctp_write_space(asoc
);
7962 /* Is there any sndbuf space available on the socket?
7964 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
7965 * associations on the same socket. For a UDP-style socket with
7966 * multiple associations, it is possible for it to be "unwriteable"
7967 * prematurely. I assume that this is acceptable because
7968 * a premature "unwriteable" is better than an accidental "writeable" which
7969 * would cause an unwanted block under certain circumstances. For the 1-1
7970 * UDP-style sockets or TCP-style sockets, this code should work.
7973 static int sctp_writeable(struct sock
*sk
)
7977 amt
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
7983 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
7984 * returns immediately with EINPROGRESS.
7986 static int sctp_wait_for_connect(struct sctp_association
*asoc
, long *timeo_p
)
7988 struct sock
*sk
= asoc
->base
.sk
;
7990 long current_timeo
= *timeo_p
;
7993 pr_debug("%s: asoc:%p, timeo:%ld\n", __func__
, asoc
, *timeo_p
);
7995 /* Increment the association's refcnt. */
7996 sctp_association_hold(asoc
);
7999 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
8000 TASK_INTERRUPTIBLE
);
8003 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8005 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
||
8008 if (signal_pending(current
))
8009 goto do_interrupted
;
8011 if (sctp_state(asoc
, ESTABLISHED
))
8014 /* Let another process have a go. Since we are going
8018 current_timeo
= schedule_timeout(current_timeo
);
8021 *timeo_p
= current_timeo
;
8025 finish_wait(&asoc
->wait
, &wait
);
8027 /* Release the association's refcnt. */
8028 sctp_association_put(asoc
);
8033 if (asoc
->init_err_counter
+ 1 > asoc
->max_init_attempts
)
8036 err
= -ECONNREFUSED
;
8040 err
= sock_intr_errno(*timeo_p
);
8048 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
)
8050 struct sctp_endpoint
*ep
;
8054 ep
= sctp_sk(sk
)->ep
;
8058 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
,
8059 TASK_INTERRUPTIBLE
);
8061 if (list_empty(&ep
->asocs
)) {
8063 timeo
= schedule_timeout(timeo
);
8068 if (!sctp_sstate(sk
, LISTENING
))
8072 if (!list_empty(&ep
->asocs
))
8075 err
= sock_intr_errno(timeo
);
8076 if (signal_pending(current
))
8084 finish_wait(sk_sleep(sk
), &wait
);
8089 static void sctp_wait_for_close(struct sock
*sk
, long timeout
)
8094 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
8095 if (list_empty(&sctp_sk(sk
)->ep
->asocs
))
8098 timeout
= schedule_timeout(timeout
);
8100 } while (!signal_pending(current
) && timeout
);
8102 finish_wait(sk_sleep(sk
), &wait
);
8105 static void sctp_skb_set_owner_r_frag(struct sk_buff
*skb
, struct sock
*sk
)
8107 struct sk_buff
*frag
;
8112 /* Don't forget the fragments. */
8113 skb_walk_frags(skb
, frag
)
8114 sctp_skb_set_owner_r_frag(frag
, sk
);
8117 sctp_skb_set_owner_r(skb
, sk
);
8120 void sctp_copy_sock(struct sock
*newsk
, struct sock
*sk
,
8121 struct sctp_association
*asoc
)
8123 struct inet_sock
*inet
= inet_sk(sk
);
8124 struct inet_sock
*newinet
;
8126 newsk
->sk_type
= sk
->sk_type
;
8127 newsk
->sk_bound_dev_if
= sk
->sk_bound_dev_if
;
8128 newsk
->sk_flags
= sk
->sk_flags
;
8129 newsk
->sk_tsflags
= sk
->sk_tsflags
;
8130 newsk
->sk_no_check_tx
= sk
->sk_no_check_tx
;
8131 newsk
->sk_no_check_rx
= sk
->sk_no_check_rx
;
8132 newsk
->sk_reuse
= sk
->sk_reuse
;
8134 newsk
->sk_shutdown
= sk
->sk_shutdown
;
8135 newsk
->sk_destruct
= sctp_destruct_sock
;
8136 newsk
->sk_family
= sk
->sk_family
;
8137 newsk
->sk_protocol
= IPPROTO_SCTP
;
8138 newsk
->sk_backlog_rcv
= sk
->sk_prot
->backlog_rcv
;
8139 newsk
->sk_sndbuf
= sk
->sk_sndbuf
;
8140 newsk
->sk_rcvbuf
= sk
->sk_rcvbuf
;
8141 newsk
->sk_lingertime
= sk
->sk_lingertime
;
8142 newsk
->sk_rcvtimeo
= sk
->sk_rcvtimeo
;
8143 newsk
->sk_sndtimeo
= sk
->sk_sndtimeo
;
8144 newsk
->sk_rxhash
= sk
->sk_rxhash
;
8146 newinet
= inet_sk(newsk
);
8148 /* Initialize sk's sport, dport, rcv_saddr and daddr for
8149 * getsockname() and getpeername()
8151 newinet
->inet_sport
= inet
->inet_sport
;
8152 newinet
->inet_saddr
= inet
->inet_saddr
;
8153 newinet
->inet_rcv_saddr
= inet
->inet_rcv_saddr
;
8154 newinet
->inet_dport
= htons(asoc
->peer
.port
);
8155 newinet
->pmtudisc
= inet
->pmtudisc
;
8156 newinet
->inet_id
= asoc
->next_tsn
^ jiffies
;
8158 newinet
->uc_ttl
= inet
->uc_ttl
;
8159 newinet
->mc_loop
= 1;
8160 newinet
->mc_ttl
= 1;
8161 newinet
->mc_index
= 0;
8162 newinet
->mc_list
= NULL
;
8164 if (newsk
->sk_flags
& SK_FLAGS_TIMESTAMP
)
8165 net_enable_timestamp();
8167 security_sk_clone(sk
, newsk
);
8170 static inline void sctp_copy_descendant(struct sock
*sk_to
,
8171 const struct sock
*sk_from
)
8173 int ancestor_size
= sizeof(struct inet_sock
) +
8174 sizeof(struct sctp_sock
) -
8175 offsetof(struct sctp_sock
, auto_asconf_list
);
8177 if (sk_from
->sk_family
== PF_INET6
)
8178 ancestor_size
+= sizeof(struct ipv6_pinfo
);
8180 __inet_sk_copy_descendant(sk_to
, sk_from
, ancestor_size
);
8183 /* Populate the fields of the newsk from the oldsk and migrate the assoc
8184 * and its messages to the newsk.
8186 static void sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
8187 struct sctp_association
*assoc
,
8188 enum sctp_socket_type type
)
8190 struct sctp_sock
*oldsp
= sctp_sk(oldsk
);
8191 struct sctp_sock
*newsp
= sctp_sk(newsk
);
8192 struct sctp_bind_bucket
*pp
; /* hash list port iterator */
8193 struct sctp_endpoint
*newep
= newsp
->ep
;
8194 struct sk_buff
*skb
, *tmp
;
8195 struct sctp_ulpevent
*event
;
8196 struct sctp_bind_hashbucket
*head
;
8198 /* Migrate socket buffer sizes and all the socket level options to the
8201 newsk
->sk_sndbuf
= oldsk
->sk_sndbuf
;
8202 newsk
->sk_rcvbuf
= oldsk
->sk_rcvbuf
;
8203 /* Brute force copy old sctp opt. */
8204 sctp_copy_descendant(newsk
, oldsk
);
8206 /* Restore the ep value that was overwritten with the above structure
8212 /* Hook this new socket in to the bind_hash list. */
8213 head
= &sctp_port_hashtable
[sctp_phashfn(sock_net(oldsk
),
8214 inet_sk(oldsk
)->inet_num
)];
8215 spin_lock_bh(&head
->lock
);
8216 pp
= sctp_sk(oldsk
)->bind_hash
;
8217 sk_add_bind_node(newsk
, &pp
->owner
);
8218 sctp_sk(newsk
)->bind_hash
= pp
;
8219 inet_sk(newsk
)->inet_num
= inet_sk(oldsk
)->inet_num
;
8220 spin_unlock_bh(&head
->lock
);
8222 /* Copy the bind_addr list from the original endpoint to the new
8223 * endpoint so that we can handle restarts properly
8225 sctp_bind_addr_dup(&newsp
->ep
->base
.bind_addr
,
8226 &oldsp
->ep
->base
.bind_addr
, GFP_KERNEL
);
8228 /* Move any messages in the old socket's receive queue that are for the
8229 * peeled off association to the new socket's receive queue.
8231 sctp_skb_for_each(skb
, &oldsk
->sk_receive_queue
, tmp
) {
8232 event
= sctp_skb2event(skb
);
8233 if (event
->asoc
== assoc
) {
8234 __skb_unlink(skb
, &oldsk
->sk_receive_queue
);
8235 __skb_queue_tail(&newsk
->sk_receive_queue
, skb
);
8236 sctp_skb_set_owner_r_frag(skb
, newsk
);
8240 /* Clean up any messages pending delivery due to partial
8241 * delivery. Three cases:
8242 * 1) No partial deliver; no work.
8243 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
8244 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
8246 skb_queue_head_init(&newsp
->pd_lobby
);
8247 atomic_set(&sctp_sk(newsk
)->pd_mode
, assoc
->ulpq
.pd_mode
);
8249 if (atomic_read(&sctp_sk(oldsk
)->pd_mode
)) {
8250 struct sk_buff_head
*queue
;
8252 /* Decide which queue to move pd_lobby skbs to. */
8253 if (assoc
->ulpq
.pd_mode
) {
8254 queue
= &newsp
->pd_lobby
;
8256 queue
= &newsk
->sk_receive_queue
;
8258 /* Walk through the pd_lobby, looking for skbs that
8259 * need moved to the new socket.
8261 sctp_skb_for_each(skb
, &oldsp
->pd_lobby
, tmp
) {
8262 event
= sctp_skb2event(skb
);
8263 if (event
->asoc
== assoc
) {
8264 __skb_unlink(skb
, &oldsp
->pd_lobby
);
8265 __skb_queue_tail(queue
, skb
);
8266 sctp_skb_set_owner_r_frag(skb
, newsk
);
8270 /* Clear up any skbs waiting for the partial
8271 * delivery to finish.
8273 if (assoc
->ulpq
.pd_mode
)
8274 sctp_clear_pd(oldsk
, NULL
);
8278 sctp_skb_for_each(skb
, &assoc
->ulpq
.reasm
, tmp
)
8279 sctp_skb_set_owner_r_frag(skb
, newsk
);
8281 sctp_skb_for_each(skb
, &assoc
->ulpq
.lobby
, tmp
)
8282 sctp_skb_set_owner_r_frag(skb
, newsk
);
8284 /* Set the type of socket to indicate that it is peeled off from the
8285 * original UDP-style socket or created with the accept() call on a
8286 * TCP-style socket..
8290 /* Mark the new socket "in-use" by the user so that any packets
8291 * that may arrive on the association after we've moved it are
8292 * queued to the backlog. This prevents a potential race between
8293 * backlog processing on the old socket and new-packet processing
8294 * on the new socket.
8296 * The caller has just allocated newsk so we can guarantee that other
8297 * paths won't try to lock it and then oldsk.
8299 lock_sock_nested(newsk
, SINGLE_DEPTH_NESTING
);
8300 sctp_for_each_tx_datachunk(assoc
, sctp_clear_owner_w
);
8301 sctp_assoc_migrate(assoc
, newsk
);
8302 sctp_for_each_tx_datachunk(assoc
, sctp_set_owner_w
);
8304 /* If the association on the newsk is already closed before accept()
8305 * is called, set RCV_SHUTDOWN flag.
8307 if (sctp_state(assoc
, CLOSED
) && sctp_style(newsk
, TCP
)) {
8308 newsk
->sk_state
= SCTP_SS_CLOSED
;
8309 newsk
->sk_shutdown
|= RCV_SHUTDOWN
;
8311 newsk
->sk_state
= SCTP_SS_ESTABLISHED
;
8314 release_sock(newsk
);
8318 /* This proto struct describes the ULP interface for SCTP. */
8319 struct proto sctp_prot
= {
8321 .owner
= THIS_MODULE
,
8322 .close
= sctp_close
,
8323 .disconnect
= sctp_disconnect
,
8324 .accept
= sctp_accept
,
8325 .ioctl
= sctp_ioctl
,
8326 .init
= sctp_init_sock
,
8327 .destroy
= sctp_destroy_sock
,
8328 .shutdown
= sctp_shutdown
,
8329 .setsockopt
= sctp_setsockopt
,
8330 .getsockopt
= sctp_getsockopt
,
8331 .sendmsg
= sctp_sendmsg
,
8332 .recvmsg
= sctp_recvmsg
,
8334 .backlog_rcv
= sctp_backlog_rcv
,
8336 .unhash
= sctp_unhash
,
8337 .no_autobind
= true,
8338 .obj_size
= sizeof(struct sctp_sock
),
8339 .sysctl_mem
= sysctl_sctp_mem
,
8340 .sysctl_rmem
= sysctl_sctp_rmem
,
8341 .sysctl_wmem
= sysctl_sctp_wmem
,
8342 .memory_pressure
= &sctp_memory_pressure
,
8343 .enter_memory_pressure
= sctp_enter_memory_pressure
,
8344 .memory_allocated
= &sctp_memory_allocated
,
8345 .sockets_allocated
= &sctp_sockets_allocated
,
8348 #if IS_ENABLED(CONFIG_IPV6)
8350 #include <net/transp_v6.h>
8351 static void sctp_v6_destroy_sock(struct sock
*sk
)
8353 sctp_destroy_sock(sk
);
8354 inet6_destroy_sock(sk
);
8357 struct proto sctpv6_prot
= {
8359 .owner
= THIS_MODULE
,
8360 .close
= sctp_close
,
8361 .disconnect
= sctp_disconnect
,
8362 .accept
= sctp_accept
,
8363 .ioctl
= sctp_ioctl
,
8364 .init
= sctp_init_sock
,
8365 .destroy
= sctp_v6_destroy_sock
,
8366 .shutdown
= sctp_shutdown
,
8367 .setsockopt
= sctp_setsockopt
,
8368 .getsockopt
= sctp_getsockopt
,
8369 .sendmsg
= sctp_sendmsg
,
8370 .recvmsg
= sctp_recvmsg
,
8372 .backlog_rcv
= sctp_backlog_rcv
,
8374 .unhash
= sctp_unhash
,
8375 .no_autobind
= true,
8376 .obj_size
= sizeof(struct sctp6_sock
),
8377 .sysctl_mem
= sysctl_sctp_mem
,
8378 .sysctl_rmem
= sysctl_sctp_rmem
,
8379 .sysctl_wmem
= sysctl_sctp_wmem
,
8380 .memory_pressure
= &sctp_memory_pressure
,
8381 .enter_memory_pressure
= sctp_enter_memory_pressure
,
8382 .memory_allocated
= &sctp_memory_allocated
,
8383 .sockets_allocated
= &sctp_sockets_allocated
,
8385 #endif /* IS_ENABLED(CONFIG_IPV6) */