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>
69 #include <linux/rhashtable.h>
73 #include <net/route.h>
75 #include <net/inet_common.h>
76 #include <net/busy_poll.h>
78 #include <linux/socket.h> /* for sa_family_t */
79 #include <linux/export.h>
81 #include <net/sctp/sctp.h>
82 #include <net/sctp/sm.h>
83 #include <net/sctp/stream_sched.h>
85 /* Forward declarations for internal helper functions. */
86 static bool sctp_writeable(struct sock
*sk
);
87 static void sctp_wfree(struct sk_buff
*skb
);
88 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
90 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
);
91 static int sctp_wait_for_connect(struct sctp_association
*, long *timeo_p
);
92 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
);
93 static void sctp_wait_for_close(struct sock
*sk
, long timeo
);
94 static void sctp_destruct_sock(struct sock
*sk
);
95 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
96 union sctp_addr
*addr
, int len
);
97 static int sctp_bindx_add(struct sock
*, struct sockaddr
*, int);
98 static int sctp_bindx_rem(struct sock
*, struct sockaddr
*, int);
99 static int sctp_send_asconf_add_ip(struct sock
*, struct sockaddr
*, int);
100 static int sctp_send_asconf_del_ip(struct sock
*, struct sockaddr
*, int);
101 static int sctp_send_asconf(struct sctp_association
*asoc
,
102 struct sctp_chunk
*chunk
);
103 static int sctp_do_bind(struct sock
*, union sctp_addr
*, int);
104 static int sctp_autobind(struct sock
*sk
);
105 static void sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
106 struct sctp_association
*assoc
,
107 enum sctp_socket_type type
);
109 static unsigned long sctp_memory_pressure
;
110 static atomic_long_t sctp_memory_allocated
;
111 struct percpu_counter sctp_sockets_allocated
;
113 static void sctp_enter_memory_pressure(struct sock
*sk
)
115 sctp_memory_pressure
= 1;
119 /* Get the sndbuf space available at the time on the association. */
120 static inline int sctp_wspace(struct sctp_association
*asoc
)
122 struct sock
*sk
= asoc
->base
.sk
;
124 return asoc
->ep
->sndbuf_policy
? sk
->sk_sndbuf
- asoc
->sndbuf_used
125 : sk_stream_wspace(sk
);
128 /* Increment the used sndbuf space count of the corresponding association by
129 * the size of the outgoing data chunk.
130 * Also, set the skb destructor for sndbuf accounting later.
132 * Since it is always 1-1 between chunk and skb, and also a new skb is always
133 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
134 * destructor in the data chunk skb for the purpose of the sndbuf space
137 static inline void sctp_set_owner_w(struct sctp_chunk
*chunk
)
139 struct sctp_association
*asoc
= chunk
->asoc
;
140 struct sock
*sk
= asoc
->base
.sk
;
142 /* The sndbuf space is tracked per association. */
143 sctp_association_hold(asoc
);
146 sctp_auth_shkey_hold(chunk
->shkey
);
148 skb_set_owner_w(chunk
->skb
, sk
);
150 chunk
->skb
->destructor
= sctp_wfree
;
151 /* Save the chunk pointer in skb for sctp_wfree to use later. */
152 skb_shinfo(chunk
->skb
)->destructor_arg
= chunk
;
154 refcount_add(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
);
155 asoc
->sndbuf_used
+= chunk
->skb
->truesize
+ sizeof(struct sctp_chunk
);
156 sk
->sk_wmem_queued
+= chunk
->skb
->truesize
+ sizeof(struct sctp_chunk
);
157 sk_mem_charge(sk
, chunk
->skb
->truesize
);
160 static void sctp_clear_owner_w(struct sctp_chunk
*chunk
)
162 skb_orphan(chunk
->skb
);
165 static void sctp_for_each_tx_datachunk(struct sctp_association
*asoc
,
166 void (*cb
)(struct sctp_chunk
*))
169 struct sctp_outq
*q
= &asoc
->outqueue
;
170 struct sctp_transport
*t
;
171 struct sctp_chunk
*chunk
;
173 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
, transports
)
174 list_for_each_entry(chunk
, &t
->transmitted
, transmitted_list
)
177 list_for_each_entry(chunk
, &q
->retransmit
, transmitted_list
)
180 list_for_each_entry(chunk
, &q
->sacked
, transmitted_list
)
183 list_for_each_entry(chunk
, &q
->abandoned
, transmitted_list
)
186 list_for_each_entry(chunk
, &q
->out_chunk_list
, list
)
190 static void sctp_for_each_rx_skb(struct sctp_association
*asoc
, struct sock
*sk
,
191 void (*cb
)(struct sk_buff
*, struct sock
*))
194 struct sk_buff
*skb
, *tmp
;
196 sctp_skb_for_each(skb
, &asoc
->ulpq
.lobby
, tmp
)
199 sctp_skb_for_each(skb
, &asoc
->ulpq
.reasm
, tmp
)
202 sctp_skb_for_each(skb
, &asoc
->ulpq
.reasm_uo
, tmp
)
206 /* Verify that this is a valid address. */
207 static inline int sctp_verify_addr(struct sock
*sk
, union sctp_addr
*addr
,
212 /* Verify basic sockaddr. */
213 af
= sctp_sockaddr_af(sctp_sk(sk
), addr
, len
);
217 /* Is this a valid SCTP address? */
218 if (!af
->addr_valid(addr
, sctp_sk(sk
), NULL
))
221 if (!sctp_sk(sk
)->pf
->send_verify(sctp_sk(sk
), (addr
)))
227 /* Look up the association by its id. If this is not a UDP-style
228 * socket, the ID field is always ignored.
230 struct sctp_association
*sctp_id2assoc(struct sock
*sk
, sctp_assoc_t id
)
232 struct sctp_association
*asoc
= NULL
;
234 /* If this is not a UDP-style socket, assoc id should be ignored. */
235 if (!sctp_style(sk
, UDP
)) {
236 /* Return NULL if the socket state is not ESTABLISHED. It
237 * could be a TCP-style listening socket or a socket which
238 * hasn't yet called connect() to establish an association.
240 if (!sctp_sstate(sk
, ESTABLISHED
) && !sctp_sstate(sk
, CLOSING
))
243 /* Get the first and the only association from the list. */
244 if (!list_empty(&sctp_sk(sk
)->ep
->asocs
))
245 asoc
= list_entry(sctp_sk(sk
)->ep
->asocs
.next
,
246 struct sctp_association
, asocs
);
250 /* Otherwise this is a UDP-style socket. */
251 if (!id
|| (id
== (sctp_assoc_t
)-1))
254 spin_lock_bh(&sctp_assocs_id_lock
);
255 asoc
= (struct sctp_association
*)idr_find(&sctp_assocs_id
, (int)id
);
256 if (asoc
&& (asoc
->base
.sk
!= sk
|| asoc
->base
.dead
))
258 spin_unlock_bh(&sctp_assocs_id_lock
);
263 /* Look up the transport from an address and an assoc id. If both address and
264 * id are specified, the associations matching the address and the id should be
267 static struct sctp_transport
*sctp_addr_id2transport(struct sock
*sk
,
268 struct sockaddr_storage
*addr
,
271 struct sctp_association
*addr_asoc
= NULL
, *id_asoc
= NULL
;
272 struct sctp_af
*af
= sctp_get_af_specific(addr
->ss_family
);
273 union sctp_addr
*laddr
= (union sctp_addr
*)addr
;
274 struct sctp_transport
*transport
;
276 if (!af
|| sctp_verify_addr(sk
, laddr
, af
->sockaddr_len
))
279 addr_asoc
= sctp_endpoint_lookup_assoc(sctp_sk(sk
)->ep
,
286 id_asoc
= sctp_id2assoc(sk
, id
);
287 if (id_asoc
&& (id_asoc
!= addr_asoc
))
290 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
291 (union sctp_addr
*)addr
);
296 /* API 3.1.2 bind() - UDP Style Syntax
297 * The syntax of bind() is,
299 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
301 * sd - the socket descriptor returned by socket().
302 * addr - the address structure (struct sockaddr_in or struct
303 * sockaddr_in6 [RFC 2553]),
304 * addr_len - the size of the address structure.
306 static int sctp_bind(struct sock
*sk
, struct sockaddr
*addr
, int addr_len
)
312 pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__
, sk
,
315 /* Disallow binding twice. */
316 if (!sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
317 retval
= sctp_do_bind(sk
, (union sctp_addr
*)addr
,
327 static long sctp_get_port_local(struct sock
*, union sctp_addr
*);
329 /* Verify this is a valid sockaddr. */
330 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
331 union sctp_addr
*addr
, int len
)
335 /* Check minimum size. */
336 if (len
< sizeof (struct sockaddr
))
339 if (!opt
->pf
->af_supported(addr
->sa
.sa_family
, opt
))
342 if (addr
->sa
.sa_family
== AF_INET6
) {
343 if (len
< SIN6_LEN_RFC2133
)
345 /* V4 mapped address are really of AF_INET family */
346 if (ipv6_addr_v4mapped(&addr
->v6
.sin6_addr
) &&
347 !opt
->pf
->af_supported(AF_INET
, opt
))
351 /* If we get this far, af is valid. */
352 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
354 if (len
< af
->sockaddr_len
)
360 /* Bind a local address either to an endpoint or to an association. */
361 static int sctp_do_bind(struct sock
*sk
, union sctp_addr
*addr
, int len
)
363 struct net
*net
= sock_net(sk
);
364 struct sctp_sock
*sp
= sctp_sk(sk
);
365 struct sctp_endpoint
*ep
= sp
->ep
;
366 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
371 /* Common sockaddr verification. */
372 af
= sctp_sockaddr_af(sp
, addr
, len
);
374 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
375 __func__
, sk
, addr
, len
);
379 snum
= ntohs(addr
->v4
.sin_port
);
381 pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
382 __func__
, sk
, &addr
->sa
, bp
->port
, snum
, len
);
384 /* PF specific bind() address verification. */
385 if (!sp
->pf
->bind_verify(sp
, addr
))
386 return -EADDRNOTAVAIL
;
388 /* We must either be unbound, or bind to the same port.
389 * It's OK to allow 0 ports if we are already bound.
390 * We'll just inhert an already bound port in this case
395 else if (snum
!= bp
->port
) {
396 pr_debug("%s: new port %d doesn't match existing port "
397 "%d\n", __func__
, snum
, bp
->port
);
402 if (snum
&& snum
< inet_prot_sock(net
) &&
403 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
))
406 /* See if the address matches any of the addresses we may have
407 * already bound before checking against other endpoints.
409 if (sctp_bind_addr_match(bp
, addr
, sp
))
412 /* Make sure we are allowed to bind here.
413 * The function sctp_get_port_local() does duplicate address
416 addr
->v4
.sin_port
= htons(snum
);
417 if ((ret
= sctp_get_port_local(sk
, addr
))) {
421 /* Refresh ephemeral port. */
423 bp
->port
= inet_sk(sk
)->inet_num
;
425 /* Add the address to the bind address list.
426 * Use GFP_ATOMIC since BHs will be disabled.
428 ret
= sctp_add_bind_addr(bp
, addr
, af
->sockaddr_len
,
429 SCTP_ADDR_SRC
, GFP_ATOMIC
);
431 /* Copy back into socket for getsockname() use. */
433 inet_sk(sk
)->inet_sport
= htons(inet_sk(sk
)->inet_num
);
434 sp
->pf
->to_sk_saddr(addr
, sk
);
440 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
442 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
443 * at any one time. If a sender, after sending an ASCONF chunk, decides
444 * it needs to transfer another ASCONF Chunk, it MUST wait until the
445 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
446 * subsequent ASCONF. Note this restriction binds each side, so at any
447 * time two ASCONF may be in-transit on any given association (one sent
448 * from each endpoint).
450 static int sctp_send_asconf(struct sctp_association
*asoc
,
451 struct sctp_chunk
*chunk
)
453 struct net
*net
= sock_net(asoc
->base
.sk
);
456 /* If there is an outstanding ASCONF chunk, queue it for later
459 if (asoc
->addip_last_asconf
) {
460 list_add_tail(&chunk
->list
, &asoc
->addip_chunk_list
);
464 /* Hold the chunk until an ASCONF_ACK is received. */
465 sctp_chunk_hold(chunk
);
466 retval
= sctp_primitive_ASCONF(net
, asoc
, chunk
);
468 sctp_chunk_free(chunk
);
470 asoc
->addip_last_asconf
= chunk
;
476 /* Add a list of addresses as bind addresses to local endpoint or
479 * Basically run through each address specified in the addrs/addrcnt
480 * array/length pair, determine if it is IPv6 or IPv4 and call
481 * sctp_do_bind() on it.
483 * If any of them fails, then the operation will be reversed and the
484 * ones that were added will be removed.
486 * Only sctp_setsockopt_bindx() is supposed to call this function.
488 static int sctp_bindx_add(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
493 struct sockaddr
*sa_addr
;
496 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__
, sk
,
500 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
501 /* The list may contain either IPv4 or IPv6 address;
502 * determine the address length for walking thru the list.
505 af
= sctp_get_af_specific(sa_addr
->sa_family
);
511 retval
= sctp_do_bind(sk
, (union sctp_addr
*)sa_addr
,
514 addr_buf
+= af
->sockaddr_len
;
518 /* Failed. Cleanup the ones that have been added */
520 sctp_bindx_rem(sk
, addrs
, cnt
);
528 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
529 * associations that are part of the endpoint indicating that a list of local
530 * addresses are added to the endpoint.
532 * If any of the addresses is already in the bind address list of the
533 * association, we do not send the chunk for that association. But it will not
534 * affect other associations.
536 * Only sctp_setsockopt_bindx() is supposed to call this function.
538 static int sctp_send_asconf_add_ip(struct sock
*sk
,
539 struct sockaddr
*addrs
,
542 struct net
*net
= sock_net(sk
);
543 struct sctp_sock
*sp
;
544 struct sctp_endpoint
*ep
;
545 struct sctp_association
*asoc
;
546 struct sctp_bind_addr
*bp
;
547 struct sctp_chunk
*chunk
;
548 struct sctp_sockaddr_entry
*laddr
;
549 union sctp_addr
*addr
;
550 union sctp_addr saveaddr
;
557 if (!net
->sctp
.addip_enable
)
563 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
564 __func__
, sk
, addrs
, addrcnt
);
566 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
567 if (!asoc
->peer
.asconf_capable
)
570 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_ADD_IP
)
573 if (!sctp_state(asoc
, ESTABLISHED
))
576 /* Check if any address in the packed array of addresses is
577 * in the bind address list of the association. If so,
578 * do not send the asconf chunk to its peer, but continue with
579 * other associations.
582 for (i
= 0; i
< addrcnt
; i
++) {
584 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
590 if (sctp_assoc_lookup_laddr(asoc
, addr
))
593 addr_buf
+= af
->sockaddr_len
;
598 /* Use the first valid address in bind addr list of
599 * association as Address Parameter of ASCONF CHUNK.
601 bp
= &asoc
->base
.bind_addr
;
602 p
= bp
->address_list
.next
;
603 laddr
= list_entry(p
, struct sctp_sockaddr_entry
, list
);
604 chunk
= sctp_make_asconf_update_ip(asoc
, &laddr
->a
, addrs
,
605 addrcnt
, SCTP_PARAM_ADD_IP
);
611 /* Add the new addresses to the bind address list with
612 * use_as_src set to 0.
615 for (i
= 0; i
< addrcnt
; i
++) {
617 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
618 memcpy(&saveaddr
, addr
, af
->sockaddr_len
);
619 retval
= sctp_add_bind_addr(bp
, &saveaddr
,
621 SCTP_ADDR_NEW
, GFP_ATOMIC
);
622 addr_buf
+= af
->sockaddr_len
;
624 if (asoc
->src_out_of_asoc_ok
) {
625 struct sctp_transport
*trans
;
627 list_for_each_entry(trans
,
628 &asoc
->peer
.transport_addr_list
, transports
) {
629 trans
->cwnd
= min(4*asoc
->pathmtu
, max_t(__u32
,
630 2*asoc
->pathmtu
, 4380));
631 trans
->ssthresh
= asoc
->peer
.i
.a_rwnd
;
632 trans
->rto
= asoc
->rto_initial
;
633 sctp_max_rto(asoc
, trans
);
634 trans
->rtt
= trans
->srtt
= trans
->rttvar
= 0;
635 /* Clear the source and route cache */
636 sctp_transport_route(trans
, NULL
,
637 sctp_sk(asoc
->base
.sk
));
640 retval
= sctp_send_asconf(asoc
, chunk
);
647 /* Remove a list of addresses from bind addresses list. Do not remove the
650 * Basically run through each address specified in the addrs/addrcnt
651 * array/length pair, determine if it is IPv6 or IPv4 and call
652 * sctp_del_bind() on it.
654 * If any of them fails, then the operation will be reversed and the
655 * ones that were removed will be added back.
657 * At least one address has to be left; if only one address is
658 * available, the operation will return -EBUSY.
660 * Only sctp_setsockopt_bindx() is supposed to call this function.
662 static int sctp_bindx_rem(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
664 struct sctp_sock
*sp
= sctp_sk(sk
);
665 struct sctp_endpoint
*ep
= sp
->ep
;
667 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
670 union sctp_addr
*sa_addr
;
673 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
674 __func__
, sk
, addrs
, addrcnt
);
677 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
678 /* If the bind address list is empty or if there is only one
679 * bind address, there is nothing more to be removed (we need
680 * at least one address here).
682 if (list_empty(&bp
->address_list
) ||
683 (sctp_list_single_entry(&bp
->address_list
))) {
689 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
695 if (!af
->addr_valid(sa_addr
, sp
, NULL
)) {
696 retval
= -EADDRNOTAVAIL
;
700 if (sa_addr
->v4
.sin_port
&&
701 sa_addr
->v4
.sin_port
!= htons(bp
->port
)) {
706 if (!sa_addr
->v4
.sin_port
)
707 sa_addr
->v4
.sin_port
= htons(bp
->port
);
709 /* FIXME - There is probably a need to check if sk->sk_saddr and
710 * sk->sk_rcv_addr are currently set to one of the addresses to
711 * be removed. This is something which needs to be looked into
712 * when we are fixing the outstanding issues with multi-homing
713 * socket routing and failover schemes. Refer to comments in
714 * sctp_do_bind(). -daisy
716 retval
= sctp_del_bind_addr(bp
, sa_addr
);
718 addr_buf
+= af
->sockaddr_len
;
721 /* Failed. Add the ones that has been removed back */
723 sctp_bindx_add(sk
, addrs
, cnt
);
731 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
732 * the associations that are part of the endpoint indicating that a list of
733 * local addresses are removed from the endpoint.
735 * If any of the addresses is already in the bind address list of the
736 * association, we do not send the chunk for that association. But it will not
737 * affect other associations.
739 * Only sctp_setsockopt_bindx() is supposed to call this function.
741 static int sctp_send_asconf_del_ip(struct sock
*sk
,
742 struct sockaddr
*addrs
,
745 struct net
*net
= sock_net(sk
);
746 struct sctp_sock
*sp
;
747 struct sctp_endpoint
*ep
;
748 struct sctp_association
*asoc
;
749 struct sctp_transport
*transport
;
750 struct sctp_bind_addr
*bp
;
751 struct sctp_chunk
*chunk
;
752 union sctp_addr
*laddr
;
755 struct sctp_sockaddr_entry
*saddr
;
761 if (!net
->sctp
.addip_enable
)
767 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
768 __func__
, sk
, addrs
, addrcnt
);
770 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
772 if (!asoc
->peer
.asconf_capable
)
775 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_DEL_IP
)
778 if (!sctp_state(asoc
, ESTABLISHED
))
781 /* Check if any address in the packed array of addresses is
782 * not present in the bind address list of the association.
783 * If so, do not send the asconf chunk to its peer, but
784 * continue with other associations.
787 for (i
= 0; i
< addrcnt
; i
++) {
789 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
795 if (!sctp_assoc_lookup_laddr(asoc
, laddr
))
798 addr_buf
+= af
->sockaddr_len
;
803 /* Find one address in the association's bind address list
804 * that is not in the packed array of addresses. This is to
805 * make sure that we do not delete all the addresses in the
808 bp
= &asoc
->base
.bind_addr
;
809 laddr
= sctp_find_unmatch_addr(bp
, (union sctp_addr
*)addrs
,
811 if ((laddr
== NULL
) && (addrcnt
== 1)) {
812 if (asoc
->asconf_addr_del_pending
)
814 asoc
->asconf_addr_del_pending
=
815 kzalloc(sizeof(union sctp_addr
), GFP_ATOMIC
);
816 if (asoc
->asconf_addr_del_pending
== NULL
) {
820 asoc
->asconf_addr_del_pending
->sa
.sa_family
=
822 asoc
->asconf_addr_del_pending
->v4
.sin_port
=
824 if (addrs
->sa_family
== AF_INET
) {
825 struct sockaddr_in
*sin
;
827 sin
= (struct sockaddr_in
*)addrs
;
828 asoc
->asconf_addr_del_pending
->v4
.sin_addr
.s_addr
= sin
->sin_addr
.s_addr
;
829 } else if (addrs
->sa_family
== AF_INET6
) {
830 struct sockaddr_in6
*sin6
;
832 sin6
= (struct sockaddr_in6
*)addrs
;
833 asoc
->asconf_addr_del_pending
->v6
.sin6_addr
= sin6
->sin6_addr
;
836 pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
837 __func__
, asoc
, &asoc
->asconf_addr_del_pending
->sa
,
838 asoc
->asconf_addr_del_pending
);
840 asoc
->src_out_of_asoc_ok
= 1;
848 /* We do not need RCU protection throughout this loop
849 * because this is done under a socket lock from the
852 chunk
= sctp_make_asconf_update_ip(asoc
, laddr
, addrs
, addrcnt
,
860 /* Reset use_as_src flag for the addresses in the bind address
861 * list that are to be deleted.
864 for (i
= 0; i
< addrcnt
; i
++) {
866 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
867 list_for_each_entry(saddr
, &bp
->address_list
, list
) {
868 if (sctp_cmp_addr_exact(&saddr
->a
, laddr
))
869 saddr
->state
= SCTP_ADDR_DEL
;
871 addr_buf
+= af
->sockaddr_len
;
874 /* Update the route and saddr entries for all the transports
875 * as some of the addresses in the bind address list are
876 * about to be deleted and cannot be used as source addresses.
878 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
880 sctp_transport_route(transport
, NULL
,
881 sctp_sk(asoc
->base
.sk
));
885 /* We don't need to transmit ASCONF */
887 retval
= sctp_send_asconf(asoc
, chunk
);
893 /* set addr events to assocs in the endpoint. ep and addr_wq must be locked */
894 int sctp_asconf_mgmt(struct sctp_sock
*sp
, struct sctp_sockaddr_entry
*addrw
)
896 struct sock
*sk
= sctp_opt2sk(sp
);
897 union sctp_addr
*addr
;
900 /* It is safe to write port space in caller. */
902 addr
->v4
.sin_port
= htons(sp
->ep
->base
.bind_addr
.port
);
903 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
906 if (sctp_verify_addr(sk
, addr
, af
->sockaddr_len
))
909 if (addrw
->state
== SCTP_ADDR_NEW
)
910 return sctp_send_asconf_add_ip(sk
, (struct sockaddr
*)addr
, 1);
912 return sctp_send_asconf_del_ip(sk
, (struct sockaddr
*)addr
, 1);
915 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
918 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
921 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
922 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
925 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
926 * Section 3.1.2 for this usage.
928 * addrs is a pointer to an array of one or more socket addresses. Each
929 * address is contained in its appropriate structure (i.e. struct
930 * sockaddr_in or struct sockaddr_in6) the family of the address type
931 * must be used to distinguish the address length (note that this
932 * representation is termed a "packed array" of addresses). The caller
933 * specifies the number of addresses in the array with addrcnt.
935 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
936 * -1, and sets errno to the appropriate error code.
938 * For SCTP, the port given in each socket address must be the same, or
939 * sctp_bindx() will fail, setting errno to EINVAL.
941 * The flags parameter is formed from the bitwise OR of zero or more of
942 * the following currently defined flags:
944 * SCTP_BINDX_ADD_ADDR
946 * SCTP_BINDX_REM_ADDR
948 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
949 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
950 * addresses from the association. The two flags are mutually exclusive;
951 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
952 * not remove all addresses from an association; sctp_bindx() will
953 * reject such an attempt with EINVAL.
955 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
956 * additional addresses with an endpoint after calling bind(). Or use
957 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
958 * socket is associated with so that no new association accepted will be
959 * associated with those addresses. If the endpoint supports dynamic
960 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
961 * endpoint to send the appropriate message to the peer to change the
962 * peers address lists.
964 * Adding and removing addresses from a connected association is
965 * optional functionality. Implementations that do not support this
966 * functionality should return EOPNOTSUPP.
968 * Basically do nothing but copying the addresses from user to kernel
969 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
970 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
973 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
976 * sk The sk of the socket
977 * addrs The pointer to the addresses in user land
978 * addrssize Size of the addrs buffer
979 * op Operation to perform (add or remove, see the flags of
982 * Returns 0 if ok, <0 errno code on error.
984 static int sctp_setsockopt_bindx(struct sock
*sk
,
985 struct sockaddr __user
*addrs
,
986 int addrs_size
, int op
)
988 struct sockaddr
*kaddrs
;
992 struct sockaddr
*sa_addr
;
996 pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
997 __func__
, sk
, addrs
, addrs_size
, op
);
999 if (unlikely(addrs_size
<= 0))
1002 kaddrs
= vmemdup_user(addrs
, addrs_size
);
1003 if (unlikely(IS_ERR(kaddrs
)))
1004 return PTR_ERR(kaddrs
);
1006 /* Walk through the addrs buffer and count the number of addresses. */
1008 while (walk_size
< addrs_size
) {
1009 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
) {
1015 af
= sctp_get_af_specific(sa_addr
->sa_family
);
1017 /* If the address family is not supported or if this address
1018 * causes the address buffer to overflow return EINVAL.
1020 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
1025 addr_buf
+= af
->sockaddr_len
;
1026 walk_size
+= af
->sockaddr_len
;
1031 case SCTP_BINDX_ADD_ADDR
:
1032 /* Allow security module to validate bindx addresses. */
1033 err
= security_sctp_bind_connect(sk
, SCTP_SOCKOPT_BINDX_ADD
,
1034 (struct sockaddr
*)kaddrs
,
1038 err
= sctp_bindx_add(sk
, kaddrs
, addrcnt
);
1041 err
= sctp_send_asconf_add_ip(sk
, kaddrs
, addrcnt
);
1044 case SCTP_BINDX_REM_ADDR
:
1045 err
= sctp_bindx_rem(sk
, kaddrs
, addrcnt
);
1048 err
= sctp_send_asconf_del_ip(sk
, kaddrs
, addrcnt
);
1062 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1064 * Common routine for handling connect() and sctp_connectx().
1065 * Connect will come in with just a single address.
1067 static int __sctp_connect(struct sock
*sk
,
1068 struct sockaddr
*kaddrs
,
1069 int addrs_size
, int flags
,
1070 sctp_assoc_t
*assoc_id
)
1072 struct net
*net
= sock_net(sk
);
1073 struct sctp_sock
*sp
;
1074 struct sctp_endpoint
*ep
;
1075 struct sctp_association
*asoc
= NULL
;
1076 struct sctp_association
*asoc2
;
1077 struct sctp_transport
*transport
;
1079 enum sctp_scope scope
;
1084 union sctp_addr
*sa_addr
= NULL
;
1086 unsigned short port
;
1091 /* connect() cannot be done on a socket that is already in ESTABLISHED
1092 * state - UDP-style peeled off socket or a TCP-style socket that
1093 * is already connected.
1094 * It cannot be done even on a TCP-style listening socket.
1096 if (sctp_sstate(sk
, ESTABLISHED
) || sctp_sstate(sk
, CLOSING
) ||
1097 (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))) {
1102 /* Walk through the addrs buffer and count the number of addresses. */
1104 while (walk_size
< addrs_size
) {
1107 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
) {
1113 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
1115 /* If the address family is not supported or if this address
1116 * causes the address buffer to overflow return EINVAL.
1118 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
1123 port
= ntohs(sa_addr
->v4
.sin_port
);
1125 /* Save current address so we can work with it */
1126 memcpy(&to
, sa_addr
, af
->sockaddr_len
);
1128 err
= sctp_verify_addr(sk
, &to
, af
->sockaddr_len
);
1132 /* Make sure the destination port is correctly set
1135 if (asoc
&& asoc
->peer
.port
&& asoc
->peer
.port
!= port
) {
1140 /* Check if there already is a matching association on the
1141 * endpoint (other than the one created here).
1143 asoc2
= sctp_endpoint_lookup_assoc(ep
, &to
, &transport
);
1144 if (asoc2
&& asoc2
!= asoc
) {
1145 if (asoc2
->state
>= SCTP_STATE_ESTABLISHED
)
1152 /* If we could not find a matching association on the endpoint,
1153 * make sure that there is no peeled-off association matching
1154 * the peer address even on another socket.
1156 if (sctp_endpoint_is_peeled_off(ep
, &to
)) {
1157 err
= -EADDRNOTAVAIL
;
1162 /* If a bind() or sctp_bindx() is not called prior to
1163 * an sctp_connectx() call, the system picks an
1164 * ephemeral port and will choose an address set
1165 * equivalent to binding with a wildcard address.
1167 if (!ep
->base
.bind_addr
.port
) {
1168 if (sctp_autobind(sk
)) {
1174 * If an unprivileged user inherits a 1-many
1175 * style socket with open associations on a
1176 * privileged port, it MAY be permitted to
1177 * accept new associations, but it SHOULD NOT
1178 * be permitted to open new associations.
1180 if (ep
->base
.bind_addr
.port
<
1181 inet_prot_sock(net
) &&
1182 !ns_capable(net
->user_ns
,
1183 CAP_NET_BIND_SERVICE
)) {
1189 scope
= sctp_scope(&to
);
1190 asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1196 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, scope
,
1204 /* Prime the peer's transport structures. */
1205 transport
= sctp_assoc_add_peer(asoc
, &to
, GFP_KERNEL
,
1213 addr_buf
+= af
->sockaddr_len
;
1214 walk_size
+= af
->sockaddr_len
;
1217 /* In case the user of sctp_connectx() wants an association
1218 * id back, assign one now.
1221 err
= sctp_assoc_set_id(asoc
, GFP_KERNEL
);
1226 err
= sctp_primitive_ASSOCIATE(net
, asoc
, NULL
);
1231 /* Initialize sk's dport and daddr for getpeername() */
1232 inet_sk(sk
)->inet_dport
= htons(asoc
->peer
.port
);
1233 sp
->pf
->to_sk_daddr(sa_addr
, sk
);
1236 timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
1239 *assoc_id
= asoc
->assoc_id
;
1241 err
= sctp_wait_for_connect(asoc
, &timeo
);
1242 /* Note: the asoc may be freed after the return of
1243 * sctp_wait_for_connect.
1246 /* Don't free association on exit. */
1250 pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1251 __func__
, asoc
, kaddrs
, err
);
1254 /* sctp_primitive_ASSOCIATE may have added this association
1255 * To the hash table, try to unhash it, just in case, its a noop
1256 * if it wasn't hashed so we're safe
1258 sctp_association_free(asoc
);
1263 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1266 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1267 * sctp_assoc_t *asoc);
1269 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1270 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1271 * or IPv6 addresses.
1273 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1274 * Section 3.1.2 for this usage.
1276 * addrs is a pointer to an array of one or more socket addresses. Each
1277 * address is contained in its appropriate structure (i.e. struct
1278 * sockaddr_in or struct sockaddr_in6) the family of the address type
1279 * must be used to distengish the address length (note that this
1280 * representation is termed a "packed array" of addresses). The caller
1281 * specifies the number of addresses in the array with addrcnt.
1283 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1284 * the association id of the new association. On failure, sctp_connectx()
1285 * returns -1, and sets errno to the appropriate error code. The assoc_id
1286 * is not touched by the kernel.
1288 * For SCTP, the port given in each socket address must be the same, or
1289 * sctp_connectx() will fail, setting errno to EINVAL.
1291 * An application can use sctp_connectx to initiate an association with
1292 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1293 * allows a caller to specify multiple addresses at which a peer can be
1294 * reached. The way the SCTP stack uses the list of addresses to set up
1295 * the association is implementation dependent. This function only
1296 * specifies that the stack will try to make use of all the addresses in
1297 * the list when needed.
1299 * Note that the list of addresses passed in is only used for setting up
1300 * the association. It does not necessarily equal the set of addresses
1301 * the peer uses for the resulting association. If the caller wants to
1302 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1303 * retrieve them after the association has been set up.
1305 * Basically do nothing but copying the addresses from user to kernel
1306 * land and invoking either sctp_connectx(). This is used for tunneling
1307 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1309 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1312 * sk The sk of the socket
1313 * addrs The pointer to the addresses in user land
1314 * addrssize Size of the addrs buffer
1316 * Returns >=0 if ok, <0 errno code on error.
1318 static int __sctp_setsockopt_connectx(struct sock
*sk
,
1319 struct sockaddr __user
*addrs
,
1321 sctp_assoc_t
*assoc_id
)
1323 struct sockaddr
*kaddrs
;
1324 int err
= 0, flags
= 0;
1326 pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1327 __func__
, sk
, addrs
, addrs_size
);
1329 if (unlikely(addrs_size
<= 0))
1332 kaddrs
= vmemdup_user(addrs
, addrs_size
);
1333 if (unlikely(IS_ERR(kaddrs
)))
1334 return PTR_ERR(kaddrs
);
1336 /* Allow security module to validate connectx addresses. */
1337 err
= security_sctp_bind_connect(sk
, SCTP_SOCKOPT_CONNECTX
,
1338 (struct sockaddr
*)kaddrs
,
1343 /* in-kernel sockets don't generally have a file allocated to them
1344 * if all they do is call sock_create_kern().
1346 if (sk
->sk_socket
->file
)
1347 flags
= sk
->sk_socket
->file
->f_flags
;
1349 err
= __sctp_connect(sk
, kaddrs
, addrs_size
, flags
, assoc_id
);
1358 * This is an older interface. It's kept for backward compatibility
1359 * to the option that doesn't provide association id.
1361 static int sctp_setsockopt_connectx_old(struct sock
*sk
,
1362 struct sockaddr __user
*addrs
,
1365 return __sctp_setsockopt_connectx(sk
, addrs
, addrs_size
, NULL
);
1369 * New interface for the API. The since the API is done with a socket
1370 * option, to make it simple we feed back the association id is as a return
1371 * indication to the call. Error is always negative and association id is
1374 static int sctp_setsockopt_connectx(struct sock
*sk
,
1375 struct sockaddr __user
*addrs
,
1378 sctp_assoc_t assoc_id
= 0;
1381 err
= __sctp_setsockopt_connectx(sk
, addrs
, addrs_size
, &assoc_id
);
1390 * New (hopefully final) interface for the API.
1391 * We use the sctp_getaddrs_old structure so that use-space library
1392 * can avoid any unnecessary allocations. The only different part
1393 * is that we store the actual length of the address buffer into the
1394 * addrs_num structure member. That way we can re-use the existing
1397 #ifdef CONFIG_COMPAT
1398 struct compat_sctp_getaddrs_old
{
1399 sctp_assoc_t assoc_id
;
1401 compat_uptr_t addrs
; /* struct sockaddr * */
1405 static int sctp_getsockopt_connectx3(struct sock
*sk
, int len
,
1406 char __user
*optval
,
1409 struct sctp_getaddrs_old param
;
1410 sctp_assoc_t assoc_id
= 0;
1413 #ifdef CONFIG_COMPAT
1414 if (in_compat_syscall()) {
1415 struct compat_sctp_getaddrs_old param32
;
1417 if (len
< sizeof(param32
))
1419 if (copy_from_user(¶m32
, optval
, sizeof(param32
)))
1422 param
.assoc_id
= param32
.assoc_id
;
1423 param
.addr_num
= param32
.addr_num
;
1424 param
.addrs
= compat_ptr(param32
.addrs
);
1428 if (len
< sizeof(param
))
1430 if (copy_from_user(¶m
, optval
, sizeof(param
)))
1434 err
= __sctp_setsockopt_connectx(sk
, (struct sockaddr __user
*)
1435 param
.addrs
, param
.addr_num
,
1437 if (err
== 0 || err
== -EINPROGRESS
) {
1438 if (copy_to_user(optval
, &assoc_id
, sizeof(assoc_id
)))
1440 if (put_user(sizeof(assoc_id
), optlen
))
1447 /* API 3.1.4 close() - UDP Style Syntax
1448 * Applications use close() to perform graceful shutdown (as described in
1449 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1450 * by a UDP-style socket.
1454 * ret = close(int sd);
1456 * sd - the socket descriptor of the associations to be closed.
1458 * To gracefully shutdown a specific association represented by the
1459 * UDP-style socket, an application should use the sendmsg() call,
1460 * passing no user data, but including the appropriate flag in the
1461 * ancillary data (see Section xxxx).
1463 * If sd in the close() call is a branched-off socket representing only
1464 * one association, the shutdown is performed on that association only.
1466 * 4.1.6 close() - TCP Style Syntax
1468 * Applications use close() to gracefully close down an association.
1472 * int close(int sd);
1474 * sd - the socket descriptor of the association to be closed.
1476 * After an application calls close() on a socket descriptor, no further
1477 * socket operations will succeed on that descriptor.
1479 * API 7.1.4 SO_LINGER
1481 * An application using the TCP-style socket can use this option to
1482 * perform the SCTP ABORT primitive. The linger option structure is:
1485 * int l_onoff; // option on/off
1486 * int l_linger; // linger time
1489 * To enable the option, set l_onoff to 1. If the l_linger value is set
1490 * to 0, calling close() is the same as the ABORT primitive. If the
1491 * value is set to a negative value, the setsockopt() call will return
1492 * an error. If the value is set to a positive value linger_time, the
1493 * close() can be blocked for at most linger_time ms. If the graceful
1494 * shutdown phase does not finish during this period, close() will
1495 * return but the graceful shutdown phase continues in the system.
1497 static void sctp_close(struct sock
*sk
, long timeout
)
1499 struct net
*net
= sock_net(sk
);
1500 struct sctp_endpoint
*ep
;
1501 struct sctp_association
*asoc
;
1502 struct list_head
*pos
, *temp
;
1503 unsigned int data_was_unread
;
1505 pr_debug("%s: sk:%p, timeout:%ld\n", __func__
, sk
, timeout
);
1507 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
1508 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1509 inet_sk_set_state(sk
, SCTP_SS_CLOSING
);
1511 ep
= sctp_sk(sk
)->ep
;
1513 /* Clean up any skbs sitting on the receive queue. */
1514 data_was_unread
= sctp_queue_purge_ulpevents(&sk
->sk_receive_queue
);
1515 data_was_unread
+= sctp_queue_purge_ulpevents(&sctp_sk(sk
)->pd_lobby
);
1517 /* Walk all associations on an endpoint. */
1518 list_for_each_safe(pos
, temp
, &ep
->asocs
) {
1519 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
1521 if (sctp_style(sk
, TCP
)) {
1522 /* A closed association can still be in the list if
1523 * it belongs to a TCP-style listening socket that is
1524 * not yet accepted. If so, free it. If not, send an
1525 * ABORT or SHUTDOWN based on the linger options.
1527 if (sctp_state(asoc
, CLOSED
)) {
1528 sctp_association_free(asoc
);
1533 if (data_was_unread
|| !skb_queue_empty(&asoc
->ulpq
.lobby
) ||
1534 !skb_queue_empty(&asoc
->ulpq
.reasm
) ||
1535 !skb_queue_empty(&asoc
->ulpq
.reasm_uo
) ||
1536 (sock_flag(sk
, SOCK_LINGER
) && !sk
->sk_lingertime
)) {
1537 struct sctp_chunk
*chunk
;
1539 chunk
= sctp_make_abort_user(asoc
, NULL
, 0);
1540 sctp_primitive_ABORT(net
, asoc
, chunk
);
1542 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
1545 /* On a TCP-style socket, block for at most linger_time if set. */
1546 if (sctp_style(sk
, TCP
) && timeout
)
1547 sctp_wait_for_close(sk
, timeout
);
1549 /* This will run the backlog queue. */
1552 /* Supposedly, no process has access to the socket, but
1553 * the net layers still may.
1554 * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1555 * held and that should be grabbed before socket lock.
1557 spin_lock_bh(&net
->sctp
.addr_wq_lock
);
1558 bh_lock_sock_nested(sk
);
1560 /* Hold the sock, since sk_common_release() will put sock_put()
1561 * and we have just a little more cleanup.
1564 sk_common_release(sk
);
1567 spin_unlock_bh(&net
->sctp
.addr_wq_lock
);
1571 SCTP_DBG_OBJCNT_DEC(sock
);
1574 /* Handle EPIPE error. */
1575 static int sctp_error(struct sock
*sk
, int flags
, int err
)
1578 err
= sock_error(sk
) ? : -EPIPE
;
1579 if (err
== -EPIPE
&& !(flags
& MSG_NOSIGNAL
))
1580 send_sig(SIGPIPE
, current
, 0);
1584 /* API 3.1.3 sendmsg() - UDP Style Syntax
1586 * An application uses sendmsg() and recvmsg() calls to transmit data to
1587 * and receive data from its peer.
1589 * ssize_t sendmsg(int socket, const struct msghdr *message,
1592 * socket - the socket descriptor of the endpoint.
1593 * message - pointer to the msghdr structure which contains a single
1594 * user message and possibly some ancillary data.
1596 * See Section 5 for complete description of the data
1599 * flags - flags sent or received with the user message, see Section
1600 * 5 for complete description of the flags.
1602 * Note: This function could use a rewrite especially when explicit
1603 * connect support comes in.
1605 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1607 static int sctp_msghdr_parse(const struct msghdr
*msg
,
1608 struct sctp_cmsgs
*cmsgs
);
1610 static int sctp_sendmsg_parse(struct sock
*sk
, struct sctp_cmsgs
*cmsgs
,
1611 struct sctp_sndrcvinfo
*srinfo
,
1612 const struct msghdr
*msg
, size_t msg_len
)
1617 if (sctp_sstate(sk
, LISTENING
) && sctp_style(sk
, TCP
))
1620 if (msg_len
> sk
->sk_sndbuf
)
1623 memset(cmsgs
, 0, sizeof(*cmsgs
));
1624 err
= sctp_msghdr_parse(msg
, cmsgs
);
1626 pr_debug("%s: msghdr parse err:%x\n", __func__
, err
);
1630 memset(srinfo
, 0, sizeof(*srinfo
));
1631 if (cmsgs
->srinfo
) {
1632 srinfo
->sinfo_stream
= cmsgs
->srinfo
->sinfo_stream
;
1633 srinfo
->sinfo_flags
= cmsgs
->srinfo
->sinfo_flags
;
1634 srinfo
->sinfo_ppid
= cmsgs
->srinfo
->sinfo_ppid
;
1635 srinfo
->sinfo_context
= cmsgs
->srinfo
->sinfo_context
;
1636 srinfo
->sinfo_assoc_id
= cmsgs
->srinfo
->sinfo_assoc_id
;
1637 srinfo
->sinfo_timetolive
= cmsgs
->srinfo
->sinfo_timetolive
;
1641 srinfo
->sinfo_stream
= cmsgs
->sinfo
->snd_sid
;
1642 srinfo
->sinfo_flags
= cmsgs
->sinfo
->snd_flags
;
1643 srinfo
->sinfo_ppid
= cmsgs
->sinfo
->snd_ppid
;
1644 srinfo
->sinfo_context
= cmsgs
->sinfo
->snd_context
;
1645 srinfo
->sinfo_assoc_id
= cmsgs
->sinfo
->snd_assoc_id
;
1648 if (cmsgs
->prinfo
) {
1649 srinfo
->sinfo_timetolive
= cmsgs
->prinfo
->pr_value
;
1650 SCTP_PR_SET_POLICY(srinfo
->sinfo_flags
,
1651 cmsgs
->prinfo
->pr_policy
);
1654 sflags
= srinfo
->sinfo_flags
;
1655 if (!sflags
&& msg_len
)
1658 if (sctp_style(sk
, TCP
) && (sflags
& (SCTP_EOF
| SCTP_ABORT
)))
1661 if (((sflags
& SCTP_EOF
) && msg_len
> 0) ||
1662 (!(sflags
& (SCTP_EOF
| SCTP_ABORT
)) && msg_len
== 0))
1665 if ((sflags
& SCTP_ADDR_OVER
) && !msg
->msg_name
)
1671 static int sctp_sendmsg_new_asoc(struct sock
*sk
, __u16 sflags
,
1672 struct sctp_cmsgs
*cmsgs
,
1673 union sctp_addr
*daddr
,
1674 struct sctp_transport
**tp
)
1676 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
1677 struct net
*net
= sock_net(sk
);
1678 struct sctp_association
*asoc
;
1679 enum sctp_scope scope
;
1680 struct cmsghdr
*cmsg
;
1681 __be32 flowinfo
= 0;
1687 if (sflags
& (SCTP_EOF
| SCTP_ABORT
))
1690 if (sctp_style(sk
, TCP
) && (sctp_sstate(sk
, ESTABLISHED
) ||
1691 sctp_sstate(sk
, CLOSING
)))
1692 return -EADDRNOTAVAIL
;
1694 if (sctp_endpoint_is_peeled_off(ep
, daddr
))
1695 return -EADDRNOTAVAIL
;
1697 if (!ep
->base
.bind_addr
.port
) {
1698 if (sctp_autobind(sk
))
1701 if (ep
->base
.bind_addr
.port
< inet_prot_sock(net
) &&
1702 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
))
1706 scope
= sctp_scope(daddr
);
1708 /* Label connection socket for first association 1-to-many
1709 * style for client sequence socket()->sendmsg(). This
1710 * needs to be done before sctp_assoc_add_peer() as that will
1711 * set up the initial packet that needs to account for any
1712 * security ip options (CIPSO/CALIPSO) added to the packet.
1714 af
= sctp_get_af_specific(daddr
->sa
.sa_family
);
1717 err
= security_sctp_bind_connect(sk
, SCTP_SENDMSG_CONNECT
,
1718 (struct sockaddr
*)daddr
,
1723 asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1727 if (sctp_assoc_set_bind_addr_from_ep(asoc
, scope
, GFP_KERNEL
) < 0) {
1733 struct sctp_initmsg
*init
= cmsgs
->init
;
1735 if (init
->sinit_num_ostreams
) {
1736 __u16 outcnt
= init
->sinit_num_ostreams
;
1738 asoc
->c
.sinit_num_ostreams
= outcnt
;
1739 /* outcnt has been changed, need to re-init stream */
1740 err
= sctp_stream_init(&asoc
->stream
, outcnt
, 0,
1746 if (init
->sinit_max_instreams
)
1747 asoc
->c
.sinit_max_instreams
= init
->sinit_max_instreams
;
1749 if (init
->sinit_max_attempts
)
1750 asoc
->max_init_attempts
= init
->sinit_max_attempts
;
1752 if (init
->sinit_max_init_timeo
)
1753 asoc
->max_init_timeo
=
1754 msecs_to_jiffies(init
->sinit_max_init_timeo
);
1757 *tp
= sctp_assoc_add_peer(asoc
, daddr
, GFP_KERNEL
, SCTP_UNKNOWN
);
1763 if (!cmsgs
->addrs_msg
)
1766 if (daddr
->sa
.sa_family
== AF_INET6
)
1767 flowinfo
= daddr
->v6
.sin6_flowinfo
;
1769 /* sendv addr list parse */
1770 for_each_cmsghdr(cmsg
, cmsgs
->addrs_msg
) {
1771 struct sctp_transport
*transport
;
1772 struct sctp_association
*old
;
1773 union sctp_addr _daddr
;
1776 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
||
1777 (cmsg
->cmsg_type
!= SCTP_DSTADDRV4
&&
1778 cmsg
->cmsg_type
!= SCTP_DSTADDRV6
))
1782 memset(daddr
, 0, sizeof(*daddr
));
1783 dlen
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1784 if (cmsg
->cmsg_type
== SCTP_DSTADDRV4
) {
1785 if (dlen
< sizeof(struct in_addr
)) {
1790 dlen
= sizeof(struct in_addr
);
1791 daddr
->v4
.sin_family
= AF_INET
;
1792 daddr
->v4
.sin_port
= htons(asoc
->peer
.port
);
1793 memcpy(&daddr
->v4
.sin_addr
, CMSG_DATA(cmsg
), dlen
);
1795 if (dlen
< sizeof(struct in6_addr
)) {
1800 dlen
= sizeof(struct in6_addr
);
1801 daddr
->v6
.sin6_flowinfo
= flowinfo
;
1802 daddr
->v6
.sin6_family
= AF_INET6
;
1803 daddr
->v6
.sin6_port
= htons(asoc
->peer
.port
);
1804 memcpy(&daddr
->v6
.sin6_addr
, CMSG_DATA(cmsg
), dlen
);
1806 err
= sctp_verify_addr(sk
, daddr
, sizeof(*daddr
));
1810 old
= sctp_endpoint_lookup_assoc(ep
, daddr
, &transport
);
1811 if (old
&& old
!= asoc
) {
1812 if (old
->state
>= SCTP_STATE_ESTABLISHED
)
1819 if (sctp_endpoint_is_peeled_off(ep
, daddr
)) {
1820 err
= -EADDRNOTAVAIL
;
1824 transport
= sctp_assoc_add_peer(asoc
, daddr
, GFP_KERNEL
,
1835 sctp_association_free(asoc
);
1839 static int sctp_sendmsg_check_sflags(struct sctp_association
*asoc
,
1840 __u16 sflags
, struct msghdr
*msg
,
1843 struct sock
*sk
= asoc
->base
.sk
;
1844 struct net
*net
= sock_net(sk
);
1846 if (sctp_state(asoc
, CLOSED
) && sctp_style(sk
, TCP
))
1849 if ((sflags
& SCTP_SENDALL
) && sctp_style(sk
, UDP
) &&
1850 !sctp_state(asoc
, ESTABLISHED
))
1853 if (sflags
& SCTP_EOF
) {
1854 pr_debug("%s: shutting down association:%p\n", __func__
, asoc
);
1855 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
1860 if (sflags
& SCTP_ABORT
) {
1861 struct sctp_chunk
*chunk
;
1863 chunk
= sctp_make_abort_user(asoc
, msg
, msg_len
);
1867 pr_debug("%s: aborting association:%p\n", __func__
, asoc
);
1868 sctp_primitive_ABORT(net
, asoc
, chunk
);
1876 static int sctp_sendmsg_to_asoc(struct sctp_association
*asoc
,
1877 struct msghdr
*msg
, size_t msg_len
,
1878 struct sctp_transport
*transport
,
1879 struct sctp_sndrcvinfo
*sinfo
)
1881 struct sock
*sk
= asoc
->base
.sk
;
1882 struct sctp_sock
*sp
= sctp_sk(sk
);
1883 struct net
*net
= sock_net(sk
);
1884 struct sctp_datamsg
*datamsg
;
1885 bool wait_connect
= false;
1886 struct sctp_chunk
*chunk
;
1890 if (sinfo
->sinfo_stream
>= asoc
->stream
.outcnt
) {
1895 if (unlikely(!SCTP_SO(&asoc
->stream
, sinfo
->sinfo_stream
)->ext
)) {
1896 err
= sctp_stream_init_ext(&asoc
->stream
, sinfo
->sinfo_stream
);
1901 if (sp
->disable_fragments
&& msg_len
> asoc
->frag_point
) {
1906 if (asoc
->pmtu_pending
) {
1907 if (sp
->param_flags
& SPP_PMTUD_ENABLE
)
1908 sctp_assoc_sync_pmtu(asoc
);
1909 asoc
->pmtu_pending
= 0;
1912 if (sctp_wspace(asoc
) < (int)msg_len
)
1913 sctp_prsctp_prune(asoc
, sinfo
, msg_len
- sctp_wspace(asoc
));
1915 if (sctp_wspace(asoc
) <= 0) {
1916 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1917 err
= sctp_wait_for_sndbuf(asoc
, &timeo
, msg_len
);
1922 if (sctp_state(asoc
, CLOSED
)) {
1923 err
= sctp_primitive_ASSOCIATE(net
, asoc
, NULL
);
1927 if (sp
->strm_interleave
) {
1928 timeo
= sock_sndtimeo(sk
, 0);
1929 err
= sctp_wait_for_connect(asoc
, &timeo
);
1935 wait_connect
= true;
1938 pr_debug("%s: we associated primitively\n", __func__
);
1941 datamsg
= sctp_datamsg_from_user(asoc
, sinfo
, &msg
->msg_iter
);
1942 if (IS_ERR(datamsg
)) {
1943 err
= PTR_ERR(datamsg
);
1947 asoc
->force_delay
= !!(msg
->msg_flags
& MSG_MORE
);
1949 list_for_each_entry(chunk
, &datamsg
->chunks
, frag_list
) {
1950 sctp_chunk_hold(chunk
);
1951 sctp_set_owner_w(chunk
);
1952 chunk
->transport
= transport
;
1955 err
= sctp_primitive_SEND(net
, asoc
, datamsg
);
1957 sctp_datamsg_free(datamsg
);
1961 pr_debug("%s: we sent primitively\n", __func__
);
1963 sctp_datamsg_put(datamsg
);
1965 if (unlikely(wait_connect
)) {
1966 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1967 sctp_wait_for_connect(asoc
, &timeo
);
1976 static union sctp_addr
*sctp_sendmsg_get_daddr(struct sock
*sk
,
1977 const struct msghdr
*msg
,
1978 struct sctp_cmsgs
*cmsgs
)
1980 union sctp_addr
*daddr
= NULL
;
1983 if (!sctp_style(sk
, UDP_HIGH_BANDWIDTH
) && msg
->msg_name
) {
1984 int len
= msg
->msg_namelen
;
1986 if (len
> sizeof(*daddr
))
1987 len
= sizeof(*daddr
);
1989 daddr
= (union sctp_addr
*)msg
->msg_name
;
1991 err
= sctp_verify_addr(sk
, daddr
, len
);
1993 return ERR_PTR(err
);
1999 static void sctp_sendmsg_update_sinfo(struct sctp_association
*asoc
,
2000 struct sctp_sndrcvinfo
*sinfo
,
2001 struct sctp_cmsgs
*cmsgs
)
2003 if (!cmsgs
->srinfo
&& !cmsgs
->sinfo
) {
2004 sinfo
->sinfo_stream
= asoc
->default_stream
;
2005 sinfo
->sinfo_ppid
= asoc
->default_ppid
;
2006 sinfo
->sinfo_context
= asoc
->default_context
;
2007 sinfo
->sinfo_assoc_id
= sctp_assoc2id(asoc
);
2010 sinfo
->sinfo_flags
= asoc
->default_flags
;
2013 if (!cmsgs
->srinfo
&& !cmsgs
->prinfo
)
2014 sinfo
->sinfo_timetolive
= asoc
->default_timetolive
;
2016 if (cmsgs
->authinfo
) {
2017 /* Reuse sinfo_tsn to indicate that authinfo was set and
2018 * sinfo_ssn to save the keyid on tx path.
2020 sinfo
->sinfo_tsn
= 1;
2021 sinfo
->sinfo_ssn
= cmsgs
->authinfo
->auth_keynumber
;
2025 static int sctp_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t msg_len
)
2027 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
2028 struct sctp_transport
*transport
= NULL
;
2029 struct sctp_sndrcvinfo _sinfo
, *sinfo
;
2030 struct sctp_association
*asoc
, *tmp
;
2031 struct sctp_cmsgs cmsgs
;
2032 union sctp_addr
*daddr
;
2037 /* Parse and get snd_info */
2038 err
= sctp_sendmsg_parse(sk
, &cmsgs
, &_sinfo
, msg
, msg_len
);
2043 sflags
= sinfo
->sinfo_flags
;
2045 /* Get daddr from msg */
2046 daddr
= sctp_sendmsg_get_daddr(sk
, msg
, &cmsgs
);
2047 if (IS_ERR(daddr
)) {
2048 err
= PTR_ERR(daddr
);
2054 /* SCTP_SENDALL process */
2055 if ((sflags
& SCTP_SENDALL
) && sctp_style(sk
, UDP
)) {
2056 list_for_each_entry_safe(asoc
, tmp
, &ep
->asocs
, asocs
) {
2057 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
,
2064 sctp_sendmsg_update_sinfo(asoc
, sinfo
, &cmsgs
);
2066 err
= sctp_sendmsg_to_asoc(asoc
, msg
, msg_len
,
2071 iov_iter_revert(&msg
->msg_iter
, err
);
2077 /* Get and check or create asoc */
2079 asoc
= sctp_endpoint_lookup_assoc(ep
, daddr
, &transport
);
2081 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
,
2086 err
= sctp_sendmsg_new_asoc(sk
, sflags
, &cmsgs
, daddr
,
2091 asoc
= transport
->asoc
;
2095 if (!sctp_style(sk
, TCP
) && !(sflags
& SCTP_ADDR_OVER
))
2098 asoc
= sctp_id2assoc(sk
, sinfo
->sinfo_assoc_id
);
2104 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
, msg_len
);
2109 /* Update snd_info with the asoc */
2110 sctp_sendmsg_update_sinfo(asoc
, sinfo
, &cmsgs
);
2112 /* Send msg to the asoc */
2113 err
= sctp_sendmsg_to_asoc(asoc
, msg
, msg_len
, transport
, sinfo
);
2114 if (err
< 0 && err
!= -ESRCH
&& new)
2115 sctp_association_free(asoc
);
2120 return sctp_error(sk
, msg
->msg_flags
, err
);
2123 /* This is an extended version of skb_pull() that removes the data from the
2124 * start of a skb even when data is spread across the list of skb's in the
2125 * frag_list. len specifies the total amount of data that needs to be removed.
2126 * when 'len' bytes could be removed from the skb, it returns 0.
2127 * If 'len' exceeds the total skb length, it returns the no. of bytes that
2128 * could not be removed.
2130 static int sctp_skb_pull(struct sk_buff
*skb
, int len
)
2132 struct sk_buff
*list
;
2133 int skb_len
= skb_headlen(skb
);
2136 if (len
<= skb_len
) {
2137 __skb_pull(skb
, len
);
2141 __skb_pull(skb
, skb_len
);
2143 skb_walk_frags(skb
, list
) {
2144 rlen
= sctp_skb_pull(list
, len
);
2145 skb
->len
-= (len
-rlen
);
2146 skb
->data_len
-= (len
-rlen
);
2157 /* API 3.1.3 recvmsg() - UDP Style Syntax
2159 * ssize_t recvmsg(int socket, struct msghdr *message,
2162 * socket - the socket descriptor of the endpoint.
2163 * message - pointer to the msghdr structure which contains a single
2164 * user message and possibly some ancillary data.
2166 * See Section 5 for complete description of the data
2169 * flags - flags sent or received with the user message, see Section
2170 * 5 for complete description of the flags.
2172 static int sctp_recvmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
,
2173 int noblock
, int flags
, int *addr_len
)
2175 struct sctp_ulpevent
*event
= NULL
;
2176 struct sctp_sock
*sp
= sctp_sk(sk
);
2177 struct sk_buff
*skb
, *head_skb
;
2182 pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2183 "addr_len:%p)\n", __func__
, sk
, msg
, len
, noblock
, flags
,
2188 if (sctp_style(sk
, TCP
) && !sctp_sstate(sk
, ESTABLISHED
) &&
2189 !sctp_sstate(sk
, CLOSING
) && !sctp_sstate(sk
, CLOSED
)) {
2194 skb
= sctp_skb_recv_datagram(sk
, flags
, noblock
, &err
);
2198 /* Get the total length of the skb including any skb's in the
2207 err
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
2209 event
= sctp_skb2event(skb
);
2214 if (event
->chunk
&& event
->chunk
->head_skb
)
2215 head_skb
= event
->chunk
->head_skb
;
2218 sock_recv_ts_and_drops(msg
, sk
, head_skb
);
2219 if (sctp_ulpevent_is_notification(event
)) {
2220 msg
->msg_flags
|= MSG_NOTIFICATION
;
2221 sp
->pf
->event_msgname(event
, msg
->msg_name
, addr_len
);
2223 sp
->pf
->skb_msgname(head_skb
, msg
->msg_name
, addr_len
);
2226 /* Check if we allow SCTP_NXTINFO. */
2227 if (sp
->recvnxtinfo
)
2228 sctp_ulpevent_read_nxtinfo(event
, msg
, sk
);
2229 /* Check if we allow SCTP_RCVINFO. */
2230 if (sp
->recvrcvinfo
)
2231 sctp_ulpevent_read_rcvinfo(event
, msg
);
2232 /* Check if we allow SCTP_SNDRCVINFO. */
2233 if (sctp_ulpevent_type_enabled(sp
->subscribe
, SCTP_DATA_IO_EVENT
))
2234 sctp_ulpevent_read_sndrcvinfo(event
, msg
);
2238 /* If skb's length exceeds the user's buffer, update the skb and
2239 * push it back to the receive_queue so that the next call to
2240 * recvmsg() will return the remaining data. Don't set MSG_EOR.
2242 if (skb_len
> copied
) {
2243 msg
->msg_flags
&= ~MSG_EOR
;
2244 if (flags
& MSG_PEEK
)
2246 sctp_skb_pull(skb
, copied
);
2247 skb_queue_head(&sk
->sk_receive_queue
, skb
);
2249 /* When only partial message is copied to the user, increase
2250 * rwnd by that amount. If all the data in the skb is read,
2251 * rwnd is updated when the event is freed.
2253 if (!sctp_ulpevent_is_notification(event
))
2254 sctp_assoc_rwnd_increase(event
->asoc
, copied
);
2256 } else if ((event
->msg_flags
& MSG_NOTIFICATION
) ||
2257 (event
->msg_flags
& MSG_EOR
))
2258 msg
->msg_flags
|= MSG_EOR
;
2260 msg
->msg_flags
&= ~MSG_EOR
;
2263 if (flags
& MSG_PEEK
) {
2264 /* Release the skb reference acquired after peeking the skb in
2265 * sctp_skb_recv_datagram().
2269 /* Free the event which includes releasing the reference to
2270 * the owner of the skb, freeing the skb and updating the
2273 sctp_ulpevent_free(event
);
2280 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2282 * This option is a on/off flag. If enabled no SCTP message
2283 * fragmentation will be performed. Instead if a message being sent
2284 * exceeds the current PMTU size, the message will NOT be sent and
2285 * instead a error will be indicated to the user.
2287 static int sctp_setsockopt_disable_fragments(struct sock
*sk
,
2288 char __user
*optval
,
2289 unsigned int optlen
)
2293 if (optlen
< sizeof(int))
2296 if (get_user(val
, (int __user
*)optval
))
2299 sctp_sk(sk
)->disable_fragments
= (val
== 0) ? 0 : 1;
2304 static int sctp_setsockopt_events(struct sock
*sk
, char __user
*optval
,
2305 unsigned int optlen
)
2307 struct sctp_event_subscribe subscribe
;
2308 __u8
*sn_type
= (__u8
*)&subscribe
;
2309 struct sctp_sock
*sp
= sctp_sk(sk
);
2310 struct sctp_association
*asoc
;
2313 if (optlen
> sizeof(struct sctp_event_subscribe
))
2316 if (copy_from_user(&subscribe
, optval
, optlen
))
2319 for (i
= 0; i
< optlen
; i
++)
2320 sctp_ulpevent_type_set(&sp
->subscribe
, SCTP_SN_TYPE_BASE
+ i
,
2323 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
)
2324 asoc
->subscribe
= sctp_sk(sk
)->subscribe
;
2326 /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2327 * if there is no data to be sent or retransmit, the stack will
2328 * immediately send up this notification.
2330 if (sctp_ulpevent_type_enabled(sp
->subscribe
, SCTP_SENDER_DRY_EVENT
)) {
2331 struct sctp_ulpevent
*event
;
2333 asoc
= sctp_id2assoc(sk
, 0);
2334 if (asoc
&& sctp_outq_is_empty(&asoc
->outqueue
)) {
2335 event
= sctp_ulpevent_make_sender_dry_event(asoc
,
2336 GFP_USER
| __GFP_NOWARN
);
2340 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, event
);
2347 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2349 * This socket option is applicable to the UDP-style socket only. When
2350 * set it will cause associations that are idle for more than the
2351 * specified number of seconds to automatically close. An association
2352 * being idle is defined an association that has NOT sent or received
2353 * user data. The special value of '0' indicates that no automatic
2354 * close of any associations should be performed. The option expects an
2355 * integer defining the number of seconds of idle time before an
2356 * association is closed.
2358 static int sctp_setsockopt_autoclose(struct sock
*sk
, char __user
*optval
,
2359 unsigned int optlen
)
2361 struct sctp_sock
*sp
= sctp_sk(sk
);
2362 struct net
*net
= sock_net(sk
);
2364 /* Applicable to UDP-style socket only */
2365 if (sctp_style(sk
, TCP
))
2367 if (optlen
!= sizeof(int))
2369 if (copy_from_user(&sp
->autoclose
, optval
, optlen
))
2372 if (sp
->autoclose
> net
->sctp
.max_autoclose
)
2373 sp
->autoclose
= net
->sctp
.max_autoclose
;
2378 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2380 * Applications can enable or disable heartbeats for any peer address of
2381 * an association, modify an address's heartbeat interval, force a
2382 * heartbeat to be sent immediately, and adjust the address's maximum
2383 * number of retransmissions sent before an address is considered
2384 * unreachable. The following structure is used to access and modify an
2385 * address's parameters:
2387 * struct sctp_paddrparams {
2388 * sctp_assoc_t spp_assoc_id;
2389 * struct sockaddr_storage spp_address;
2390 * uint32_t spp_hbinterval;
2391 * uint16_t spp_pathmaxrxt;
2392 * uint32_t spp_pathmtu;
2393 * uint32_t spp_sackdelay;
2394 * uint32_t spp_flags;
2395 * uint32_t spp_ipv6_flowlabel;
2399 * spp_assoc_id - (one-to-many style socket) This is filled in the
2400 * application, and identifies the association for
2402 * spp_address - This specifies which address is of interest.
2403 * spp_hbinterval - This contains the value of the heartbeat interval,
2404 * in milliseconds. If a value of zero
2405 * is present in this field then no changes are to
2406 * be made to this parameter.
2407 * spp_pathmaxrxt - This contains the maximum number of
2408 * retransmissions before this address shall be
2409 * considered unreachable. If a value of zero
2410 * is present in this field then no changes are to
2411 * be made to this parameter.
2412 * spp_pathmtu - When Path MTU discovery is disabled the value
2413 * specified here will be the "fixed" path mtu.
2414 * Note that if the spp_address field is empty
2415 * then all associations on this address will
2416 * have this fixed path mtu set upon them.
2418 * spp_sackdelay - When delayed sack is enabled, this value specifies
2419 * the number of milliseconds that sacks will be delayed
2420 * for. This value will apply to all addresses of an
2421 * association if the spp_address field is empty. Note
2422 * also, that if delayed sack is enabled and this
2423 * value is set to 0, no change is made to the last
2424 * recorded delayed sack timer value.
2426 * spp_flags - These flags are used to control various features
2427 * on an association. The flag field may contain
2428 * zero or more of the following options.
2430 * SPP_HB_ENABLE - Enable heartbeats on the
2431 * specified address. Note that if the address
2432 * field is empty all addresses for the association
2433 * have heartbeats enabled upon them.
2435 * SPP_HB_DISABLE - Disable heartbeats on the
2436 * speicifed address. Note that if the address
2437 * field is empty all addresses for the association
2438 * will have their heartbeats disabled. Note also
2439 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2440 * mutually exclusive, only one of these two should
2441 * be specified. Enabling both fields will have
2442 * undetermined results.
2444 * SPP_HB_DEMAND - Request a user initiated heartbeat
2445 * to be made immediately.
2447 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2448 * heartbeat delayis to be set to the value of 0
2451 * SPP_PMTUD_ENABLE - This field will enable PMTU
2452 * discovery upon the specified address. Note that
2453 * if the address feild is empty then all addresses
2454 * on the association are effected.
2456 * SPP_PMTUD_DISABLE - This field will disable PMTU
2457 * discovery upon the specified address. Note that
2458 * if the address feild is empty then all addresses
2459 * on the association are effected. Not also that
2460 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2461 * exclusive. Enabling both will have undetermined
2464 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2465 * on delayed sack. The time specified in spp_sackdelay
2466 * is used to specify the sack delay for this address. Note
2467 * that if spp_address is empty then all addresses will
2468 * enable delayed sack and take on the sack delay
2469 * value specified in spp_sackdelay.
2470 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2471 * off delayed sack. If the spp_address field is blank then
2472 * delayed sack is disabled for the entire association. Note
2473 * also that this field is mutually exclusive to
2474 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2477 * SPP_IPV6_FLOWLABEL: Setting this flag enables the
2478 * setting of the IPV6 flow label value. The value is
2479 * contained in the spp_ipv6_flowlabel field.
2480 * Upon retrieval, this flag will be set to indicate that
2481 * the spp_ipv6_flowlabel field has a valid value returned.
2482 * If a specific destination address is set (in the
2483 * spp_address field), then the value returned is that of
2484 * the address. If just an association is specified (and
2485 * no address), then the association's default flow label
2486 * is returned. If neither an association nor a destination
2487 * is specified, then the socket's default flow label is
2488 * returned. For non-IPv6 sockets, this flag will be left
2491 * SPP_DSCP: Setting this flag enables the setting of the
2492 * Differentiated Services Code Point (DSCP) value
2493 * associated with either the association or a specific
2494 * address. The value is obtained in the spp_dscp field.
2495 * Upon retrieval, this flag will be set to indicate that
2496 * the spp_dscp field has a valid value returned. If a
2497 * specific destination address is set when called (in the
2498 * spp_address field), then that specific destination
2499 * address's DSCP value is returned. If just an association
2500 * is specified, then the association's default DSCP is
2501 * returned. If neither an association nor a destination is
2502 * specified, then the socket's default DSCP is returned.
2504 * spp_ipv6_flowlabel
2505 * - This field is used in conjunction with the
2506 * SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
2507 * The 20 least significant bits are used for the flow
2508 * label. This setting has precedence over any IPv6-layer
2511 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
2512 * and contains the DSCP. The 6 most significant bits are
2513 * used for the DSCP. This setting has precedence over any
2514 * IPv4- or IPv6- layer setting.
2516 static int sctp_apply_peer_addr_params(struct sctp_paddrparams
*params
,
2517 struct sctp_transport
*trans
,
2518 struct sctp_association
*asoc
,
2519 struct sctp_sock
*sp
,
2522 int sackdelay_change
)
2526 if (params
->spp_flags
& SPP_HB_DEMAND
&& trans
) {
2527 struct net
*net
= sock_net(trans
->asoc
->base
.sk
);
2529 error
= sctp_primitive_REQUESTHEARTBEAT(net
, trans
->asoc
, trans
);
2534 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2535 * this field is ignored. Note also that a value of zero indicates
2536 * the current setting should be left unchanged.
2538 if (params
->spp_flags
& SPP_HB_ENABLE
) {
2540 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2541 * set. This lets us use 0 value when this flag
2544 if (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)
2545 params
->spp_hbinterval
= 0;
2547 if (params
->spp_hbinterval
||
2548 (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)) {
2551 msecs_to_jiffies(params
->spp_hbinterval
);
2554 msecs_to_jiffies(params
->spp_hbinterval
);
2556 sp
->hbinterval
= params
->spp_hbinterval
;
2563 trans
->param_flags
=
2564 (trans
->param_flags
& ~SPP_HB
) | hb_change
;
2567 (asoc
->param_flags
& ~SPP_HB
) | hb_change
;
2570 (sp
->param_flags
& ~SPP_HB
) | hb_change
;
2574 /* When Path MTU discovery is disabled the value specified here will
2575 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2576 * include the flag SPP_PMTUD_DISABLE for this field to have any
2579 if ((params
->spp_flags
& SPP_PMTUD_DISABLE
) && params
->spp_pathmtu
) {
2581 trans
->pathmtu
= params
->spp_pathmtu
;
2582 sctp_assoc_sync_pmtu(asoc
);
2584 sctp_assoc_set_pmtu(asoc
, params
->spp_pathmtu
);
2586 sp
->pathmtu
= params
->spp_pathmtu
;
2592 int update
= (trans
->param_flags
& SPP_PMTUD_DISABLE
) &&
2593 (params
->spp_flags
& SPP_PMTUD_ENABLE
);
2594 trans
->param_flags
=
2595 (trans
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2597 sctp_transport_pmtu(trans
, sctp_opt2sk(sp
));
2598 sctp_assoc_sync_pmtu(asoc
);
2602 (asoc
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2605 (sp
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2609 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2610 * value of this field is ignored. Note also that a value of zero
2611 * indicates the current setting should be left unchanged.
2613 if ((params
->spp_flags
& SPP_SACKDELAY_ENABLE
) && params
->spp_sackdelay
) {
2616 msecs_to_jiffies(params
->spp_sackdelay
);
2619 msecs_to_jiffies(params
->spp_sackdelay
);
2621 sp
->sackdelay
= params
->spp_sackdelay
;
2625 if (sackdelay_change
) {
2627 trans
->param_flags
=
2628 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2632 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2636 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2641 /* Note that a value of zero indicates the current setting should be
2644 if (params
->spp_pathmaxrxt
) {
2646 trans
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2648 asoc
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2650 sp
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2654 if (params
->spp_flags
& SPP_IPV6_FLOWLABEL
) {
2656 if (trans
->ipaddr
.sa
.sa_family
== AF_INET6
) {
2657 trans
->flowlabel
= params
->spp_ipv6_flowlabel
&
2658 SCTP_FLOWLABEL_VAL_MASK
;
2659 trans
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2662 struct sctp_transport
*t
;
2664 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
,
2666 if (t
->ipaddr
.sa
.sa_family
!= AF_INET6
)
2668 t
->flowlabel
= params
->spp_ipv6_flowlabel
&
2669 SCTP_FLOWLABEL_VAL_MASK
;
2670 t
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2672 asoc
->flowlabel
= params
->spp_ipv6_flowlabel
&
2673 SCTP_FLOWLABEL_VAL_MASK
;
2674 asoc
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2675 } else if (sctp_opt2sk(sp
)->sk_family
== AF_INET6
) {
2676 sp
->flowlabel
= params
->spp_ipv6_flowlabel
&
2677 SCTP_FLOWLABEL_VAL_MASK
;
2678 sp
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2682 if (params
->spp_flags
& SPP_DSCP
) {
2684 trans
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2685 trans
->dscp
|= SCTP_DSCP_SET_MASK
;
2687 struct sctp_transport
*t
;
2689 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
,
2691 t
->dscp
= params
->spp_dscp
&
2693 t
->dscp
|= SCTP_DSCP_SET_MASK
;
2695 asoc
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2696 asoc
->dscp
|= SCTP_DSCP_SET_MASK
;
2698 sp
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2699 sp
->dscp
|= SCTP_DSCP_SET_MASK
;
2706 static int sctp_setsockopt_peer_addr_params(struct sock
*sk
,
2707 char __user
*optval
,
2708 unsigned int optlen
)
2710 struct sctp_paddrparams params
;
2711 struct sctp_transport
*trans
= NULL
;
2712 struct sctp_association
*asoc
= NULL
;
2713 struct sctp_sock
*sp
= sctp_sk(sk
);
2715 int hb_change
, pmtud_change
, sackdelay_change
;
2717 if (optlen
== sizeof(params
)) {
2718 if (copy_from_user(¶ms
, optval
, optlen
))
2720 } else if (optlen
== ALIGN(offsetof(struct sctp_paddrparams
,
2721 spp_ipv6_flowlabel
), 4)) {
2722 if (copy_from_user(¶ms
, optval
, optlen
))
2724 if (params
.spp_flags
& (SPP_DSCP
| SPP_IPV6_FLOWLABEL
))
2730 /* Validate flags and value parameters. */
2731 hb_change
= params
.spp_flags
& SPP_HB
;
2732 pmtud_change
= params
.spp_flags
& SPP_PMTUD
;
2733 sackdelay_change
= params
.spp_flags
& SPP_SACKDELAY
;
2735 if (hb_change
== SPP_HB
||
2736 pmtud_change
== SPP_PMTUD
||
2737 sackdelay_change
== SPP_SACKDELAY
||
2738 params
.spp_sackdelay
> 500 ||
2739 (params
.spp_pathmtu
&&
2740 params
.spp_pathmtu
< SCTP_DEFAULT_MINSEGMENT
))
2743 /* If an address other than INADDR_ANY is specified, and
2744 * no transport is found, then the request is invalid.
2746 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spp_address
)) {
2747 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
2748 params
.spp_assoc_id
);
2753 /* Get association, if assoc_id != 0 and the socket is a one
2754 * to many style socket, and an association was not found, then
2755 * the id was invalid.
2757 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
2758 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
))
2761 /* Heartbeat demand can only be sent on a transport or
2762 * association, but not a socket.
2764 if (params
.spp_flags
& SPP_HB_DEMAND
&& !trans
&& !asoc
)
2767 /* Process parameters. */
2768 error
= sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2769 hb_change
, pmtud_change
,
2775 /* If changes are for association, also apply parameters to each
2778 if (!trans
&& asoc
) {
2779 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2781 sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2782 hb_change
, pmtud_change
,
2790 static inline __u32
sctp_spp_sackdelay_enable(__u32 param_flags
)
2792 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_ENABLE
;
2795 static inline __u32
sctp_spp_sackdelay_disable(__u32 param_flags
)
2797 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_DISABLE
;
2801 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
2803 * This option will effect the way delayed acks are performed. This
2804 * option allows you to get or set the delayed ack time, in
2805 * milliseconds. It also allows changing the delayed ack frequency.
2806 * Changing the frequency to 1 disables the delayed sack algorithm. If
2807 * the assoc_id is 0, then this sets or gets the endpoints default
2808 * values. If the assoc_id field is non-zero, then the set or get
2809 * effects the specified association for the one to many model (the
2810 * assoc_id field is ignored by the one to one model). Note that if
2811 * sack_delay or sack_freq are 0 when setting this option, then the
2812 * current values will remain unchanged.
2814 * struct sctp_sack_info {
2815 * sctp_assoc_t sack_assoc_id;
2816 * uint32_t sack_delay;
2817 * uint32_t sack_freq;
2820 * sack_assoc_id - This parameter, indicates which association the user
2821 * is performing an action upon. Note that if this field's value is
2822 * zero then the endpoints default value is changed (effecting future
2823 * associations only).
2825 * sack_delay - This parameter contains the number of milliseconds that
2826 * the user is requesting the delayed ACK timer be set to. Note that
2827 * this value is defined in the standard to be between 200 and 500
2830 * sack_freq - This parameter contains the number of packets that must
2831 * be received before a sack is sent without waiting for the delay
2832 * timer to expire. The default value for this is 2, setting this
2833 * value to 1 will disable the delayed sack algorithm.
2836 static int sctp_setsockopt_delayed_ack(struct sock
*sk
,
2837 char __user
*optval
, unsigned int optlen
)
2839 struct sctp_sack_info params
;
2840 struct sctp_transport
*trans
= NULL
;
2841 struct sctp_association
*asoc
= NULL
;
2842 struct sctp_sock
*sp
= sctp_sk(sk
);
2844 if (optlen
== sizeof(struct sctp_sack_info
)) {
2845 if (copy_from_user(¶ms
, optval
, optlen
))
2848 if (params
.sack_delay
== 0 && params
.sack_freq
== 0)
2850 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
2851 pr_warn_ratelimited(DEPRECATED
2853 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2854 "Use struct sctp_sack_info instead\n",
2855 current
->comm
, task_pid_nr(current
));
2856 if (copy_from_user(¶ms
, optval
, optlen
))
2859 if (params
.sack_delay
== 0)
2860 params
.sack_freq
= 1;
2862 params
.sack_freq
= 0;
2866 /* Validate value parameter. */
2867 if (params
.sack_delay
> 500)
2870 /* Get association, if sack_assoc_id != 0 and the socket is a one
2871 * to many style socket, and an association was not found, then
2872 * the id was invalid.
2874 asoc
= sctp_id2assoc(sk
, params
.sack_assoc_id
);
2875 if (!asoc
&& params
.sack_assoc_id
&& sctp_style(sk
, UDP
))
2878 if (params
.sack_delay
) {
2881 msecs_to_jiffies(params
.sack_delay
);
2883 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2885 sp
->sackdelay
= params
.sack_delay
;
2887 sctp_spp_sackdelay_enable(sp
->param_flags
);
2891 if (params
.sack_freq
== 1) {
2894 sctp_spp_sackdelay_disable(asoc
->param_flags
);
2897 sctp_spp_sackdelay_disable(sp
->param_flags
);
2899 } else if (params
.sack_freq
> 1) {
2901 asoc
->sackfreq
= params
.sack_freq
;
2903 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2905 sp
->sackfreq
= params
.sack_freq
;
2907 sctp_spp_sackdelay_enable(sp
->param_flags
);
2911 /* If change is for association, also apply to each transport. */
2913 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2915 if (params
.sack_delay
) {
2917 msecs_to_jiffies(params
.sack_delay
);
2918 trans
->param_flags
=
2919 sctp_spp_sackdelay_enable(trans
->param_flags
);
2921 if (params
.sack_freq
== 1) {
2922 trans
->param_flags
=
2923 sctp_spp_sackdelay_disable(trans
->param_flags
);
2924 } else if (params
.sack_freq
> 1) {
2925 trans
->sackfreq
= params
.sack_freq
;
2926 trans
->param_flags
=
2927 sctp_spp_sackdelay_enable(trans
->param_flags
);
2935 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2937 * Applications can specify protocol parameters for the default association
2938 * initialization. The option name argument to setsockopt() and getsockopt()
2941 * Setting initialization parameters is effective only on an unconnected
2942 * socket (for UDP-style sockets only future associations are effected
2943 * by the change). With TCP-style sockets, this option is inherited by
2944 * sockets derived from a listener socket.
2946 static int sctp_setsockopt_initmsg(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
2948 struct sctp_initmsg sinit
;
2949 struct sctp_sock
*sp
= sctp_sk(sk
);
2951 if (optlen
!= sizeof(struct sctp_initmsg
))
2953 if (copy_from_user(&sinit
, optval
, optlen
))
2956 if (sinit
.sinit_num_ostreams
)
2957 sp
->initmsg
.sinit_num_ostreams
= sinit
.sinit_num_ostreams
;
2958 if (sinit
.sinit_max_instreams
)
2959 sp
->initmsg
.sinit_max_instreams
= sinit
.sinit_max_instreams
;
2960 if (sinit
.sinit_max_attempts
)
2961 sp
->initmsg
.sinit_max_attempts
= sinit
.sinit_max_attempts
;
2962 if (sinit
.sinit_max_init_timeo
)
2963 sp
->initmsg
.sinit_max_init_timeo
= sinit
.sinit_max_init_timeo
;
2969 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2971 * Applications that wish to use the sendto() system call may wish to
2972 * specify a default set of parameters that would normally be supplied
2973 * through the inclusion of ancillary data. This socket option allows
2974 * such an application to set the default sctp_sndrcvinfo structure.
2975 * The application that wishes to use this socket option simply passes
2976 * in to this call the sctp_sndrcvinfo structure defined in Section
2977 * 5.2.2) The input parameters accepted by this call include
2978 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2979 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2980 * to this call if the caller is using the UDP model.
2982 static int sctp_setsockopt_default_send_param(struct sock
*sk
,
2983 char __user
*optval
,
2984 unsigned int optlen
)
2986 struct sctp_sock
*sp
= sctp_sk(sk
);
2987 struct sctp_association
*asoc
;
2988 struct sctp_sndrcvinfo info
;
2990 if (optlen
!= sizeof(info
))
2992 if (copy_from_user(&info
, optval
, optlen
))
2994 if (info
.sinfo_flags
&
2995 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
2996 SCTP_ABORT
| SCTP_EOF
))
2999 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
3000 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
3003 asoc
->default_stream
= info
.sinfo_stream
;
3004 asoc
->default_flags
= info
.sinfo_flags
;
3005 asoc
->default_ppid
= info
.sinfo_ppid
;
3006 asoc
->default_context
= info
.sinfo_context
;
3007 asoc
->default_timetolive
= info
.sinfo_timetolive
;
3009 sp
->default_stream
= info
.sinfo_stream
;
3010 sp
->default_flags
= info
.sinfo_flags
;
3011 sp
->default_ppid
= info
.sinfo_ppid
;
3012 sp
->default_context
= info
.sinfo_context
;
3013 sp
->default_timetolive
= info
.sinfo_timetolive
;
3019 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
3020 * (SCTP_DEFAULT_SNDINFO)
3022 static int sctp_setsockopt_default_sndinfo(struct sock
*sk
,
3023 char __user
*optval
,
3024 unsigned int optlen
)
3026 struct sctp_sock
*sp
= sctp_sk(sk
);
3027 struct sctp_association
*asoc
;
3028 struct sctp_sndinfo info
;
3030 if (optlen
!= sizeof(info
))
3032 if (copy_from_user(&info
, optval
, optlen
))
3034 if (info
.snd_flags
&
3035 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
3036 SCTP_ABORT
| SCTP_EOF
))
3039 asoc
= sctp_id2assoc(sk
, info
.snd_assoc_id
);
3040 if (!asoc
&& info
.snd_assoc_id
&& sctp_style(sk
, UDP
))
3043 asoc
->default_stream
= info
.snd_sid
;
3044 asoc
->default_flags
= info
.snd_flags
;
3045 asoc
->default_ppid
= info
.snd_ppid
;
3046 asoc
->default_context
= info
.snd_context
;
3048 sp
->default_stream
= info
.snd_sid
;
3049 sp
->default_flags
= info
.snd_flags
;
3050 sp
->default_ppid
= info
.snd_ppid
;
3051 sp
->default_context
= info
.snd_context
;
3057 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
3059 * Requests that the local SCTP stack use the enclosed peer address as
3060 * the association primary. The enclosed address must be one of the
3061 * association peer's addresses.
3063 static int sctp_setsockopt_primary_addr(struct sock
*sk
, char __user
*optval
,
3064 unsigned int optlen
)
3066 struct sctp_prim prim
;
3067 struct sctp_transport
*trans
;
3071 if (optlen
!= sizeof(struct sctp_prim
))
3074 if (copy_from_user(&prim
, optval
, sizeof(struct sctp_prim
)))
3077 /* Allow security module to validate address but need address len. */
3078 af
= sctp_get_af_specific(prim
.ssp_addr
.ss_family
);
3082 err
= security_sctp_bind_connect(sk
, SCTP_PRIMARY_ADDR
,
3083 (struct sockaddr
*)&prim
.ssp_addr
,
3088 trans
= sctp_addr_id2transport(sk
, &prim
.ssp_addr
, prim
.ssp_assoc_id
);
3092 sctp_assoc_set_primary(trans
->asoc
, trans
);
3098 * 7.1.5 SCTP_NODELAY
3100 * Turn on/off any Nagle-like algorithm. This means that packets are
3101 * generally sent as soon as possible and no unnecessary delays are
3102 * introduced, at the cost of more packets in the network. Expects an
3103 * integer boolean flag.
3105 static int sctp_setsockopt_nodelay(struct sock
*sk
, char __user
*optval
,
3106 unsigned int optlen
)
3110 if (optlen
< sizeof(int))
3112 if (get_user(val
, (int __user
*)optval
))
3115 sctp_sk(sk
)->nodelay
= (val
== 0) ? 0 : 1;
3121 * 7.1.1 SCTP_RTOINFO
3123 * The protocol parameters used to initialize and bound retransmission
3124 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3125 * and modify these parameters.
3126 * All parameters are time values, in milliseconds. A value of 0, when
3127 * modifying the parameters, indicates that the current value should not
3131 static int sctp_setsockopt_rtoinfo(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3133 struct sctp_rtoinfo rtoinfo
;
3134 struct sctp_association
*asoc
;
3135 unsigned long rto_min
, rto_max
;
3136 struct sctp_sock
*sp
= sctp_sk(sk
);
3138 if (optlen
!= sizeof (struct sctp_rtoinfo
))
3141 if (copy_from_user(&rtoinfo
, optval
, optlen
))
3144 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
3146 /* Set the values to the specific association */
3147 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
3150 rto_max
= rtoinfo
.srto_max
;
3151 rto_min
= rtoinfo
.srto_min
;
3154 rto_max
= asoc
? msecs_to_jiffies(rto_max
) : rto_max
;
3156 rto_max
= asoc
? asoc
->rto_max
: sp
->rtoinfo
.srto_max
;
3159 rto_min
= asoc
? msecs_to_jiffies(rto_min
) : rto_min
;
3161 rto_min
= asoc
? asoc
->rto_min
: sp
->rtoinfo
.srto_min
;
3163 if (rto_min
> rto_max
)
3167 if (rtoinfo
.srto_initial
!= 0)
3169 msecs_to_jiffies(rtoinfo
.srto_initial
);
3170 asoc
->rto_max
= rto_max
;
3171 asoc
->rto_min
= rto_min
;
3173 /* If there is no association or the association-id = 0
3174 * set the values to the endpoint.
3176 if (rtoinfo
.srto_initial
!= 0)
3177 sp
->rtoinfo
.srto_initial
= rtoinfo
.srto_initial
;
3178 sp
->rtoinfo
.srto_max
= rto_max
;
3179 sp
->rtoinfo
.srto_min
= rto_min
;
3187 * 7.1.2 SCTP_ASSOCINFO
3189 * This option is used to tune the maximum retransmission attempts
3190 * of the association.
3191 * Returns an error if the new association retransmission value is
3192 * greater than the sum of the retransmission value of the peer.
3193 * See [SCTP] for more information.
3196 static int sctp_setsockopt_associnfo(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3199 struct sctp_assocparams assocparams
;
3200 struct sctp_association
*asoc
;
3202 if (optlen
!= sizeof(struct sctp_assocparams
))
3204 if (copy_from_user(&assocparams
, optval
, optlen
))
3207 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
3209 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
3212 /* Set the values to the specific association */
3214 if (assocparams
.sasoc_asocmaxrxt
!= 0) {
3217 struct sctp_transport
*peer_addr
;
3219 list_for_each_entry(peer_addr
, &asoc
->peer
.transport_addr_list
,
3221 path_sum
+= peer_addr
->pathmaxrxt
;
3225 /* Only validate asocmaxrxt if we have more than
3226 * one path/transport. We do this because path
3227 * retransmissions are only counted when we have more
3231 assocparams
.sasoc_asocmaxrxt
> path_sum
)
3234 asoc
->max_retrans
= assocparams
.sasoc_asocmaxrxt
;
3237 if (assocparams
.sasoc_cookie_life
!= 0)
3238 asoc
->cookie_life
= ms_to_ktime(assocparams
.sasoc_cookie_life
);
3240 /* Set the values to the endpoint */
3241 struct sctp_sock
*sp
= sctp_sk(sk
);
3243 if (assocparams
.sasoc_asocmaxrxt
!= 0)
3244 sp
->assocparams
.sasoc_asocmaxrxt
=
3245 assocparams
.sasoc_asocmaxrxt
;
3246 if (assocparams
.sasoc_cookie_life
!= 0)
3247 sp
->assocparams
.sasoc_cookie_life
=
3248 assocparams
.sasoc_cookie_life
;
3254 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3256 * This socket option is a boolean flag which turns on or off mapped V4
3257 * addresses. If this option is turned on and the socket is type
3258 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3259 * If this option is turned off, then no mapping will be done of V4
3260 * addresses and a user will receive both PF_INET6 and PF_INET type
3261 * addresses on the socket.
3263 static int sctp_setsockopt_mappedv4(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3266 struct sctp_sock
*sp
= sctp_sk(sk
);
3268 if (optlen
< sizeof(int))
3270 if (get_user(val
, (int __user
*)optval
))
3281 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3282 * This option will get or set the maximum size to put in any outgoing
3283 * SCTP DATA chunk. If a message is larger than this size it will be
3284 * fragmented by SCTP into the specified size. Note that the underlying
3285 * SCTP implementation may fragment into smaller sized chunks when the
3286 * PMTU of the underlying association is smaller than the value set by
3287 * the user. The default value for this option is '0' which indicates
3288 * the user is NOT limiting fragmentation and only the PMTU will effect
3289 * SCTP's choice of DATA chunk size. Note also that values set larger
3290 * than the maximum size of an IP datagram will effectively let SCTP
3291 * control fragmentation (i.e. the same as setting this option to 0).
3293 * The following structure is used to access and modify this parameter:
3295 * struct sctp_assoc_value {
3296 * sctp_assoc_t assoc_id;
3297 * uint32_t assoc_value;
3300 * assoc_id: This parameter is ignored for one-to-one style sockets.
3301 * For one-to-many style sockets this parameter indicates which
3302 * association the user is performing an action upon. Note that if
3303 * this field's value is zero then the endpoints default value is
3304 * changed (effecting future associations only).
3305 * assoc_value: This parameter specifies the maximum size in bytes.
3307 static int sctp_setsockopt_maxseg(struct sock
*sk
, char __user
*optval
, unsigned int optlen
)
3309 struct sctp_sock
*sp
= sctp_sk(sk
);
3310 struct sctp_assoc_value params
;
3311 struct sctp_association
*asoc
;
3314 if (optlen
== sizeof(int)) {
3315 pr_warn_ratelimited(DEPRECATED
3317 "Use of int in maxseg socket option.\n"
3318 "Use struct sctp_assoc_value instead\n",
3319 current
->comm
, task_pid_nr(current
));
3320 if (copy_from_user(&val
, optval
, optlen
))
3322 params
.assoc_id
= 0;
3323 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3324 if (copy_from_user(¶ms
, optval
, optlen
))
3326 val
= params
.assoc_value
;
3331 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3334 int min_len
, max_len
;
3335 __u16 datasize
= asoc
? sctp_datachk_len(&asoc
->stream
) :
3336 sizeof(struct sctp_data_chunk
);
3338 min_len
= sctp_min_frag_point(sp
, datasize
);
3339 max_len
= SCTP_MAX_CHUNK_LEN
- datasize
;
3341 if (val
< min_len
|| val
> max_len
)
3346 asoc
->user_frag
= val
;
3347 sctp_assoc_update_frag_point(asoc
);
3349 if (params
.assoc_id
&& sctp_style(sk
, UDP
))
3351 sp
->user_frag
= val
;
3359 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3361 * Requests that the peer mark the enclosed address as the association
3362 * primary. The enclosed address must be one of the association's
3363 * locally bound addresses. The following structure is used to make a
3364 * set primary request:
3366 static int sctp_setsockopt_peer_primary_addr(struct sock
*sk
, char __user
*optval
,
3367 unsigned int optlen
)
3369 struct net
*net
= sock_net(sk
);
3370 struct sctp_sock
*sp
;
3371 struct sctp_association
*asoc
= NULL
;
3372 struct sctp_setpeerprim prim
;
3373 struct sctp_chunk
*chunk
;
3379 if (!net
->sctp
.addip_enable
)
3382 if (optlen
!= sizeof(struct sctp_setpeerprim
))
3385 if (copy_from_user(&prim
, optval
, optlen
))
3388 asoc
= sctp_id2assoc(sk
, prim
.sspp_assoc_id
);
3392 if (!asoc
->peer
.asconf_capable
)
3395 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_SET_PRIMARY
)
3398 if (!sctp_state(asoc
, ESTABLISHED
))
3401 af
= sctp_get_af_specific(prim
.sspp_addr
.ss_family
);
3405 if (!af
->addr_valid((union sctp_addr
*)&prim
.sspp_addr
, sp
, NULL
))
3406 return -EADDRNOTAVAIL
;
3408 if (!sctp_assoc_lookup_laddr(asoc
, (union sctp_addr
*)&prim
.sspp_addr
))
3409 return -EADDRNOTAVAIL
;
3411 /* Allow security module to validate address. */
3412 err
= security_sctp_bind_connect(sk
, SCTP_SET_PEER_PRIMARY_ADDR
,
3413 (struct sockaddr
*)&prim
.sspp_addr
,
3418 /* Create an ASCONF chunk with SET_PRIMARY parameter */
3419 chunk
= sctp_make_asconf_set_prim(asoc
,
3420 (union sctp_addr
*)&prim
.sspp_addr
);
3424 err
= sctp_send_asconf(asoc
, chunk
);
3426 pr_debug("%s: we set peer primary addr primitively\n", __func__
);
3431 static int sctp_setsockopt_adaptation_layer(struct sock
*sk
, char __user
*optval
,
3432 unsigned int optlen
)
3434 struct sctp_setadaptation adaptation
;
3436 if (optlen
!= sizeof(struct sctp_setadaptation
))
3438 if (copy_from_user(&adaptation
, optval
, optlen
))
3441 sctp_sk(sk
)->adaptation_ind
= adaptation
.ssb_adaptation_ind
;
3447 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
3449 * The context field in the sctp_sndrcvinfo structure is normally only
3450 * used when a failed message is retrieved holding the value that was
3451 * sent down on the actual send call. This option allows the setting of
3452 * a default context on an association basis that will be received on
3453 * reading messages from the peer. This is especially helpful in the
3454 * one-2-many model for an application to keep some reference to an
3455 * internal state machine that is processing messages on the
3456 * association. Note that the setting of this value only effects
3457 * received messages from the peer and does not effect the value that is
3458 * saved with outbound messages.
3460 static int sctp_setsockopt_context(struct sock
*sk
, char __user
*optval
,
3461 unsigned int optlen
)
3463 struct sctp_assoc_value params
;
3464 struct sctp_sock
*sp
;
3465 struct sctp_association
*asoc
;
3467 if (optlen
!= sizeof(struct sctp_assoc_value
))
3469 if (copy_from_user(¶ms
, optval
, optlen
))
3474 if (params
.assoc_id
!= 0) {
3475 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3478 asoc
->default_rcv_context
= params
.assoc_value
;
3480 sp
->default_rcv_context
= params
.assoc_value
;
3487 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3489 * This options will at a minimum specify if the implementation is doing
3490 * fragmented interleave. Fragmented interleave, for a one to many
3491 * socket, is when subsequent calls to receive a message may return
3492 * parts of messages from different associations. Some implementations
3493 * may allow you to turn this value on or off. If so, when turned off,
3494 * no fragment interleave will occur (which will cause a head of line
3495 * blocking amongst multiple associations sharing the same one to many
3496 * socket). When this option is turned on, then each receive call may
3497 * come from a different association (thus the user must receive data
3498 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3499 * association each receive belongs to.
3501 * This option takes a boolean value. A non-zero value indicates that
3502 * fragmented interleave is on. A value of zero indicates that
3503 * fragmented interleave is off.
3505 * Note that it is important that an implementation that allows this
3506 * option to be turned on, have it off by default. Otherwise an unaware
3507 * application using the one to many model may become confused and act
3510 static int sctp_setsockopt_fragment_interleave(struct sock
*sk
,
3511 char __user
*optval
,
3512 unsigned int optlen
)
3516 if (optlen
!= sizeof(int))
3518 if (get_user(val
, (int __user
*)optval
))
3521 sctp_sk(sk
)->frag_interleave
= !!val
;
3523 if (!sctp_sk(sk
)->frag_interleave
)
3524 sctp_sk(sk
)->strm_interleave
= 0;
3530 * 8.1.21. Set or Get the SCTP Partial Delivery Point
3531 * (SCTP_PARTIAL_DELIVERY_POINT)
3533 * This option will set or get the SCTP partial delivery point. This
3534 * point is the size of a message where the partial delivery API will be
3535 * invoked to help free up rwnd space for the peer. Setting this to a
3536 * lower value will cause partial deliveries to happen more often. The
3537 * calls argument is an integer that sets or gets the partial delivery
3538 * point. Note also that the call will fail if the user attempts to set
3539 * this value larger than the socket receive buffer size.
3541 * Note that any single message having a length smaller than or equal to
3542 * the SCTP partial delivery point will be delivered in one single read
3543 * call as long as the user provided buffer is large enough to hold the
3546 static int sctp_setsockopt_partial_delivery_point(struct sock
*sk
,
3547 char __user
*optval
,
3548 unsigned int optlen
)
3552 if (optlen
!= sizeof(u32
))
3554 if (get_user(val
, (int __user
*)optval
))
3557 /* Note: We double the receive buffer from what the user sets
3558 * it to be, also initial rwnd is based on rcvbuf/2.
3560 if (val
> (sk
->sk_rcvbuf
>> 1))
3563 sctp_sk(sk
)->pd_point
= val
;
3565 return 0; /* is this the right error code? */
3569 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
3571 * This option will allow a user to change the maximum burst of packets
3572 * that can be emitted by this association. Note that the default value
3573 * is 4, and some implementations may restrict this setting so that it
3574 * can only be lowered.
3576 * NOTE: This text doesn't seem right. Do this on a socket basis with
3577 * future associations inheriting the socket value.
3579 static int sctp_setsockopt_maxburst(struct sock
*sk
,
3580 char __user
*optval
,
3581 unsigned int optlen
)
3583 struct sctp_assoc_value params
;
3584 struct sctp_sock
*sp
;
3585 struct sctp_association
*asoc
;
3589 if (optlen
== sizeof(int)) {
3590 pr_warn_ratelimited(DEPRECATED
3592 "Use of int in max_burst socket option deprecated.\n"
3593 "Use struct sctp_assoc_value instead\n",
3594 current
->comm
, task_pid_nr(current
));
3595 if (copy_from_user(&val
, optval
, optlen
))
3597 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3598 if (copy_from_user(¶ms
, optval
, optlen
))
3600 val
= params
.assoc_value
;
3601 assoc_id
= params
.assoc_id
;
3607 if (assoc_id
!= 0) {
3608 asoc
= sctp_id2assoc(sk
, assoc_id
);
3611 asoc
->max_burst
= val
;
3613 sp
->max_burst
= val
;
3619 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3621 * This set option adds a chunk type that the user is requesting to be
3622 * received only in an authenticated way. Changes to the list of chunks
3623 * will only effect future associations on the socket.
3625 static int sctp_setsockopt_auth_chunk(struct sock
*sk
,
3626 char __user
*optval
,
3627 unsigned int optlen
)
3629 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3630 struct sctp_authchunk val
;
3632 if (!ep
->auth_enable
)
3635 if (optlen
!= sizeof(struct sctp_authchunk
))
3637 if (copy_from_user(&val
, optval
, optlen
))
3640 switch (val
.sauth_chunk
) {
3642 case SCTP_CID_INIT_ACK
:
3643 case SCTP_CID_SHUTDOWN_COMPLETE
:
3648 /* add this chunk id to the endpoint */
3649 return sctp_auth_ep_add_chunkid(ep
, val
.sauth_chunk
);
3653 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3655 * This option gets or sets the list of HMAC algorithms that the local
3656 * endpoint requires the peer to use.
3658 static int sctp_setsockopt_hmac_ident(struct sock
*sk
,
3659 char __user
*optval
,
3660 unsigned int optlen
)
3662 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3663 struct sctp_hmacalgo
*hmacs
;
3667 if (!ep
->auth_enable
)
3670 if (optlen
< sizeof(struct sctp_hmacalgo
))
3672 optlen
= min_t(unsigned int, optlen
, sizeof(struct sctp_hmacalgo
) +
3673 SCTP_AUTH_NUM_HMACS
* sizeof(u16
));
3675 hmacs
= memdup_user(optval
, optlen
);
3677 return PTR_ERR(hmacs
);
3679 idents
= hmacs
->shmac_num_idents
;
3680 if (idents
== 0 || idents
> SCTP_AUTH_NUM_HMACS
||
3681 (idents
* sizeof(u16
)) > (optlen
- sizeof(struct sctp_hmacalgo
))) {
3686 err
= sctp_auth_ep_set_hmacs(ep
, hmacs
);
3693 * 7.1.20. Set a shared key (SCTP_AUTH_KEY)
3695 * This option will set a shared secret key which is used to build an
3696 * association shared key.
3698 static int sctp_setsockopt_auth_key(struct sock
*sk
,
3699 char __user
*optval
,
3700 unsigned int optlen
)
3702 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3703 struct sctp_authkey
*authkey
;
3704 struct sctp_association
*asoc
;
3707 if (!ep
->auth_enable
)
3710 if (optlen
<= sizeof(struct sctp_authkey
))
3712 /* authkey->sca_keylength is u16, so optlen can't be bigger than
3715 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+
3716 sizeof(struct sctp_authkey
));
3718 authkey
= memdup_user(optval
, optlen
);
3719 if (IS_ERR(authkey
))
3720 return PTR_ERR(authkey
);
3722 if (authkey
->sca_keylength
> optlen
- sizeof(struct sctp_authkey
)) {
3727 asoc
= sctp_id2assoc(sk
, authkey
->sca_assoc_id
);
3728 if (!asoc
&& authkey
->sca_assoc_id
&& sctp_style(sk
, UDP
)) {
3733 ret
= sctp_auth_set_key(ep
, asoc
, authkey
);
3740 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3742 * This option will get or set the active shared key to be used to build
3743 * the association shared key.
3745 static int sctp_setsockopt_active_key(struct sock
*sk
,
3746 char __user
*optval
,
3747 unsigned int optlen
)
3749 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3750 struct sctp_authkeyid val
;
3751 struct sctp_association
*asoc
;
3753 if (!ep
->auth_enable
)
3756 if (optlen
!= sizeof(struct sctp_authkeyid
))
3758 if (copy_from_user(&val
, optval
, optlen
))
3761 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
3762 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
3765 return sctp_auth_set_active_key(ep
, asoc
, val
.scact_keynumber
);
3769 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY)
3771 * This set option will delete a shared secret key from use.
3773 static int sctp_setsockopt_del_key(struct sock
*sk
,
3774 char __user
*optval
,
3775 unsigned int optlen
)
3777 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3778 struct sctp_authkeyid val
;
3779 struct sctp_association
*asoc
;
3781 if (!ep
->auth_enable
)
3784 if (optlen
!= sizeof(struct sctp_authkeyid
))
3786 if (copy_from_user(&val
, optval
, optlen
))
3789 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
3790 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
3793 return sctp_auth_del_key_id(ep
, asoc
, val
.scact_keynumber
);
3798 * 8.3.4 Deactivate a Shared Key (SCTP_AUTH_DEACTIVATE_KEY)
3800 * This set option will deactivate a shared secret key.
3802 static int sctp_setsockopt_deactivate_key(struct sock
*sk
, char __user
*optval
,
3803 unsigned int optlen
)
3805 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3806 struct sctp_authkeyid val
;
3807 struct sctp_association
*asoc
;
3809 if (!ep
->auth_enable
)
3812 if (optlen
!= sizeof(struct sctp_authkeyid
))
3814 if (copy_from_user(&val
, optval
, optlen
))
3817 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
3818 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
3821 return sctp_auth_deact_key_id(ep
, asoc
, val
.scact_keynumber
);
3825 * 8.1.23 SCTP_AUTO_ASCONF
3827 * This option will enable or disable the use of the automatic generation of
3828 * ASCONF chunks to add and delete addresses to an existing association. Note
3829 * that this option has two caveats namely: a) it only affects sockets that
3830 * are bound to all addresses available to the SCTP stack, and b) the system
3831 * administrator may have an overriding control that turns the ASCONF feature
3832 * off no matter what setting the socket option may have.
3833 * This option expects an integer boolean flag, where a non-zero value turns on
3834 * the option, and a zero value turns off the option.
3835 * Note. In this implementation, socket operation overrides default parameter
3836 * being set by sysctl as well as FreeBSD implementation
3838 static int sctp_setsockopt_auto_asconf(struct sock
*sk
, char __user
*optval
,
3839 unsigned int optlen
)
3842 struct sctp_sock
*sp
= sctp_sk(sk
);
3844 if (optlen
< sizeof(int))
3846 if (get_user(val
, (int __user
*)optval
))
3848 if (!sctp_is_ep_boundall(sk
) && val
)
3850 if ((val
&& sp
->do_auto_asconf
) || (!val
&& !sp
->do_auto_asconf
))
3853 spin_lock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3854 if (val
== 0 && sp
->do_auto_asconf
) {
3855 list_del(&sp
->auto_asconf_list
);
3856 sp
->do_auto_asconf
= 0;
3857 } else if (val
&& !sp
->do_auto_asconf
) {
3858 list_add_tail(&sp
->auto_asconf_list
,
3859 &sock_net(sk
)->sctp
.auto_asconf_splist
);
3860 sp
->do_auto_asconf
= 1;
3862 spin_unlock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3867 * SCTP_PEER_ADDR_THLDS
3869 * This option allows us to alter the partially failed threshold for one or all
3870 * transports in an association. See Section 6.1 of:
3871 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3873 static int sctp_setsockopt_paddr_thresholds(struct sock
*sk
,
3874 char __user
*optval
,
3875 unsigned int optlen
)
3877 struct sctp_paddrthlds val
;
3878 struct sctp_transport
*trans
;
3879 struct sctp_association
*asoc
;
3881 if (optlen
< sizeof(struct sctp_paddrthlds
))
3883 if (copy_from_user(&val
, (struct sctp_paddrthlds __user
*)optval
,
3884 sizeof(struct sctp_paddrthlds
)))
3888 if (sctp_is_any(sk
, (const union sctp_addr
*)&val
.spt_address
)) {
3889 asoc
= sctp_id2assoc(sk
, val
.spt_assoc_id
);
3892 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
3894 if (val
.spt_pathmaxrxt
)
3895 trans
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3896 trans
->pf_retrans
= val
.spt_pathpfthld
;
3899 if (val
.spt_pathmaxrxt
)
3900 asoc
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3901 asoc
->pf_retrans
= val
.spt_pathpfthld
;
3903 trans
= sctp_addr_id2transport(sk
, &val
.spt_address
,
3908 if (val
.spt_pathmaxrxt
)
3909 trans
->pathmaxrxt
= val
.spt_pathmaxrxt
;
3910 trans
->pf_retrans
= val
.spt_pathpfthld
;
3916 static int sctp_setsockopt_recvrcvinfo(struct sock
*sk
,
3917 char __user
*optval
,
3918 unsigned int optlen
)
3922 if (optlen
< sizeof(int))
3924 if (get_user(val
, (int __user
*) optval
))
3927 sctp_sk(sk
)->recvrcvinfo
= (val
== 0) ? 0 : 1;
3932 static int sctp_setsockopt_recvnxtinfo(struct sock
*sk
,
3933 char __user
*optval
,
3934 unsigned int optlen
)
3938 if (optlen
< sizeof(int))
3940 if (get_user(val
, (int __user
*) optval
))
3943 sctp_sk(sk
)->recvnxtinfo
= (val
== 0) ? 0 : 1;
3948 static int sctp_setsockopt_pr_supported(struct sock
*sk
,
3949 char __user
*optval
,
3950 unsigned int optlen
)
3952 struct sctp_assoc_value params
;
3954 if (optlen
!= sizeof(params
))
3957 if (copy_from_user(¶ms
, optval
, optlen
))
3960 sctp_sk(sk
)->ep
->prsctp_enable
= !!params
.assoc_value
;
3965 static int sctp_setsockopt_default_prinfo(struct sock
*sk
,
3966 char __user
*optval
,
3967 unsigned int optlen
)
3969 struct sctp_default_prinfo info
;
3970 struct sctp_association
*asoc
;
3971 int retval
= -EINVAL
;
3973 if (optlen
!= sizeof(info
))
3976 if (copy_from_user(&info
, optval
, sizeof(info
))) {
3981 if (info
.pr_policy
& ~SCTP_PR_SCTP_MASK
)
3984 if (info
.pr_policy
== SCTP_PR_SCTP_NONE
)
3987 asoc
= sctp_id2assoc(sk
, info
.pr_assoc_id
);
3989 SCTP_PR_SET_POLICY(asoc
->default_flags
, info
.pr_policy
);
3990 asoc
->default_timetolive
= info
.pr_value
;
3991 } else if (!info
.pr_assoc_id
) {
3992 struct sctp_sock
*sp
= sctp_sk(sk
);
3994 SCTP_PR_SET_POLICY(sp
->default_flags
, info
.pr_policy
);
3995 sp
->default_timetolive
= info
.pr_value
;
4006 static int sctp_setsockopt_reconfig_supported(struct sock
*sk
,
4007 char __user
*optval
,
4008 unsigned int optlen
)
4010 struct sctp_assoc_value params
;
4011 struct sctp_association
*asoc
;
4012 int retval
= -EINVAL
;
4014 if (optlen
!= sizeof(params
))
4017 if (copy_from_user(¶ms
, optval
, optlen
)) {
4022 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
4024 asoc
->reconf_enable
= !!params
.assoc_value
;
4025 } else if (!params
.assoc_id
) {
4026 struct sctp_sock
*sp
= sctp_sk(sk
);
4028 sp
->ep
->reconf_enable
= !!params
.assoc_value
;
4039 static int sctp_setsockopt_enable_strreset(struct sock
*sk
,
4040 char __user
*optval
,
4041 unsigned int optlen
)
4043 struct sctp_assoc_value params
;
4044 struct sctp_association
*asoc
;
4045 int retval
= -EINVAL
;
4047 if (optlen
!= sizeof(params
))
4050 if (copy_from_user(¶ms
, optval
, optlen
)) {
4055 if (params
.assoc_value
& (~SCTP_ENABLE_STRRESET_MASK
))
4058 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
4060 asoc
->strreset_enable
= params
.assoc_value
;
4061 } else if (!params
.assoc_id
) {
4062 struct sctp_sock
*sp
= sctp_sk(sk
);
4064 sp
->ep
->strreset_enable
= params
.assoc_value
;
4075 static int sctp_setsockopt_reset_streams(struct sock
*sk
,
4076 char __user
*optval
,
4077 unsigned int optlen
)
4079 struct sctp_reset_streams
*params
;
4080 struct sctp_association
*asoc
;
4081 int retval
= -EINVAL
;
4083 if (optlen
< sizeof(*params
))
4085 /* srs_number_streams is u16, so optlen can't be bigger than this. */
4086 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+
4087 sizeof(__u16
) * sizeof(*params
));
4089 params
= memdup_user(optval
, optlen
);
4091 return PTR_ERR(params
);
4093 if (params
->srs_number_streams
* sizeof(__u16
) >
4094 optlen
- sizeof(*params
))
4097 asoc
= sctp_id2assoc(sk
, params
->srs_assoc_id
);
4101 retval
= sctp_send_reset_streams(asoc
, params
);
4108 static int sctp_setsockopt_reset_assoc(struct sock
*sk
,
4109 char __user
*optval
,
4110 unsigned int optlen
)
4112 struct sctp_association
*asoc
;
4113 sctp_assoc_t associd
;
4114 int retval
= -EINVAL
;
4116 if (optlen
!= sizeof(associd
))
4119 if (copy_from_user(&associd
, optval
, optlen
)) {
4124 asoc
= sctp_id2assoc(sk
, associd
);
4128 retval
= sctp_send_reset_assoc(asoc
);
4134 static int sctp_setsockopt_add_streams(struct sock
*sk
,
4135 char __user
*optval
,
4136 unsigned int optlen
)
4138 struct sctp_association
*asoc
;
4139 struct sctp_add_streams params
;
4140 int retval
= -EINVAL
;
4142 if (optlen
!= sizeof(params
))
4145 if (copy_from_user(¶ms
, optval
, optlen
)) {
4150 asoc
= sctp_id2assoc(sk
, params
.sas_assoc_id
);
4154 retval
= sctp_send_add_streams(asoc
, ¶ms
);
4160 static int sctp_setsockopt_scheduler(struct sock
*sk
,
4161 char __user
*optval
,
4162 unsigned int optlen
)
4164 struct sctp_association
*asoc
;
4165 struct sctp_assoc_value params
;
4166 int retval
= -EINVAL
;
4168 if (optlen
< sizeof(params
))
4171 optlen
= sizeof(params
);
4172 if (copy_from_user(¶ms
, optval
, optlen
)) {
4177 if (params
.assoc_value
> SCTP_SS_MAX
)
4180 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
4184 retval
= sctp_sched_set_sched(asoc
, params
.assoc_value
);
4190 static int sctp_setsockopt_scheduler_value(struct sock
*sk
,
4191 char __user
*optval
,
4192 unsigned int optlen
)
4194 struct sctp_association
*asoc
;
4195 struct sctp_stream_value params
;
4196 int retval
= -EINVAL
;
4198 if (optlen
< sizeof(params
))
4201 optlen
= sizeof(params
);
4202 if (copy_from_user(¶ms
, optval
, optlen
)) {
4207 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
4211 retval
= sctp_sched_set_value(asoc
, params
.stream_id
,
4212 params
.stream_value
, GFP_KERNEL
);
4218 static int sctp_setsockopt_interleaving_supported(struct sock
*sk
,
4219 char __user
*optval
,
4220 unsigned int optlen
)
4222 struct sctp_sock
*sp
= sctp_sk(sk
);
4223 struct net
*net
= sock_net(sk
);
4224 struct sctp_assoc_value params
;
4225 int retval
= -EINVAL
;
4227 if (optlen
< sizeof(params
))
4230 optlen
= sizeof(params
);
4231 if (copy_from_user(¶ms
, optval
, optlen
)) {
4236 if (params
.assoc_id
)
4239 if (!net
->sctp
.intl_enable
|| !sp
->frag_interleave
) {
4244 sp
->strm_interleave
= !!params
.assoc_value
;
4252 static int sctp_setsockopt_reuse_port(struct sock
*sk
, char __user
*optval
,
4253 unsigned int optlen
)
4257 if (!sctp_style(sk
, TCP
))
4260 if (sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
4263 if (optlen
< sizeof(int))
4266 if (get_user(val
, (int __user
*)optval
))
4269 sctp_sk(sk
)->reuse
= !!val
;
4274 static int sctp_setsockopt_event(struct sock
*sk
, char __user
*optval
,
4275 unsigned int optlen
)
4277 struct sctp_association
*asoc
;
4278 struct sctp_ulpevent
*event
;
4279 struct sctp_event param
;
4282 if (optlen
< sizeof(param
)) {
4287 optlen
= sizeof(param
);
4288 if (copy_from_user(¶m
, optval
, optlen
)) {
4293 if (param
.se_type
< SCTP_SN_TYPE_BASE
||
4294 param
.se_type
> SCTP_SN_TYPE_MAX
) {
4299 asoc
= sctp_id2assoc(sk
, param
.se_assoc_id
);
4301 sctp_ulpevent_type_set(&sctp_sk(sk
)->subscribe
,
4302 param
.se_type
, param
.se_on
);
4306 sctp_ulpevent_type_set(&asoc
->subscribe
, param
.se_type
, param
.se_on
);
4308 if (param
.se_type
== SCTP_SENDER_DRY_EVENT
&& param
.se_on
) {
4309 if (sctp_outq_is_empty(&asoc
->outqueue
)) {
4310 event
= sctp_ulpevent_make_sender_dry_event(asoc
,
4311 GFP_USER
| __GFP_NOWARN
);
4317 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, event
);
4325 /* API 6.2 setsockopt(), getsockopt()
4327 * Applications use setsockopt() and getsockopt() to set or retrieve
4328 * socket options. Socket options are used to change the default
4329 * behavior of sockets calls. They are described in Section 7.
4333 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
4334 * int __user *optlen);
4335 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
4338 * sd - the socket descript.
4339 * level - set to IPPROTO_SCTP for all SCTP options.
4340 * optname - the option name.
4341 * optval - the buffer to store the value of the option.
4342 * optlen - the size of the buffer.
4344 static int sctp_setsockopt(struct sock
*sk
, int level
, int optname
,
4345 char __user
*optval
, unsigned int optlen
)
4349 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
4351 /* I can hardly begin to describe how wrong this is. This is
4352 * so broken as to be worse than useless. The API draft
4353 * REALLY is NOT helpful here... I am not convinced that the
4354 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
4355 * are at all well-founded.
4357 if (level
!= SOL_SCTP
) {
4358 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
4359 retval
= af
->setsockopt(sk
, level
, optname
, optval
, optlen
);
4366 case SCTP_SOCKOPT_BINDX_ADD
:
4367 /* 'optlen' is the size of the addresses buffer. */
4368 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
4369 optlen
, SCTP_BINDX_ADD_ADDR
);
4372 case SCTP_SOCKOPT_BINDX_REM
:
4373 /* 'optlen' is the size of the addresses buffer. */
4374 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
4375 optlen
, SCTP_BINDX_REM_ADDR
);
4378 case SCTP_SOCKOPT_CONNECTX_OLD
:
4379 /* 'optlen' is the size of the addresses buffer. */
4380 retval
= sctp_setsockopt_connectx_old(sk
,
4381 (struct sockaddr __user
*)optval
,
4385 case SCTP_SOCKOPT_CONNECTX
:
4386 /* 'optlen' is the size of the addresses buffer. */
4387 retval
= sctp_setsockopt_connectx(sk
,
4388 (struct sockaddr __user
*)optval
,
4392 case SCTP_DISABLE_FRAGMENTS
:
4393 retval
= sctp_setsockopt_disable_fragments(sk
, optval
, optlen
);
4397 retval
= sctp_setsockopt_events(sk
, optval
, optlen
);
4400 case SCTP_AUTOCLOSE
:
4401 retval
= sctp_setsockopt_autoclose(sk
, optval
, optlen
);
4404 case SCTP_PEER_ADDR_PARAMS
:
4405 retval
= sctp_setsockopt_peer_addr_params(sk
, optval
, optlen
);
4408 case SCTP_DELAYED_SACK
:
4409 retval
= sctp_setsockopt_delayed_ack(sk
, optval
, optlen
);
4411 case SCTP_PARTIAL_DELIVERY_POINT
:
4412 retval
= sctp_setsockopt_partial_delivery_point(sk
, optval
, optlen
);
4416 retval
= sctp_setsockopt_initmsg(sk
, optval
, optlen
);
4418 case SCTP_DEFAULT_SEND_PARAM
:
4419 retval
= sctp_setsockopt_default_send_param(sk
, optval
,
4422 case SCTP_DEFAULT_SNDINFO
:
4423 retval
= sctp_setsockopt_default_sndinfo(sk
, optval
, optlen
);
4425 case SCTP_PRIMARY_ADDR
:
4426 retval
= sctp_setsockopt_primary_addr(sk
, optval
, optlen
);
4428 case SCTP_SET_PEER_PRIMARY_ADDR
:
4429 retval
= sctp_setsockopt_peer_primary_addr(sk
, optval
, optlen
);
4432 retval
= sctp_setsockopt_nodelay(sk
, optval
, optlen
);
4435 retval
= sctp_setsockopt_rtoinfo(sk
, optval
, optlen
);
4437 case SCTP_ASSOCINFO
:
4438 retval
= sctp_setsockopt_associnfo(sk
, optval
, optlen
);
4440 case SCTP_I_WANT_MAPPED_V4_ADDR
:
4441 retval
= sctp_setsockopt_mappedv4(sk
, optval
, optlen
);
4444 retval
= sctp_setsockopt_maxseg(sk
, optval
, optlen
);
4446 case SCTP_ADAPTATION_LAYER
:
4447 retval
= sctp_setsockopt_adaptation_layer(sk
, optval
, optlen
);
4450 retval
= sctp_setsockopt_context(sk
, optval
, optlen
);
4452 case SCTP_FRAGMENT_INTERLEAVE
:
4453 retval
= sctp_setsockopt_fragment_interleave(sk
, optval
, optlen
);
4455 case SCTP_MAX_BURST
:
4456 retval
= sctp_setsockopt_maxburst(sk
, optval
, optlen
);
4458 case SCTP_AUTH_CHUNK
:
4459 retval
= sctp_setsockopt_auth_chunk(sk
, optval
, optlen
);
4461 case SCTP_HMAC_IDENT
:
4462 retval
= sctp_setsockopt_hmac_ident(sk
, optval
, optlen
);
4465 retval
= sctp_setsockopt_auth_key(sk
, optval
, optlen
);
4467 case SCTP_AUTH_ACTIVE_KEY
:
4468 retval
= sctp_setsockopt_active_key(sk
, optval
, optlen
);
4470 case SCTP_AUTH_DELETE_KEY
:
4471 retval
= sctp_setsockopt_del_key(sk
, optval
, optlen
);
4473 case SCTP_AUTH_DEACTIVATE_KEY
:
4474 retval
= sctp_setsockopt_deactivate_key(sk
, optval
, optlen
);
4476 case SCTP_AUTO_ASCONF
:
4477 retval
= sctp_setsockopt_auto_asconf(sk
, optval
, optlen
);
4479 case SCTP_PEER_ADDR_THLDS
:
4480 retval
= sctp_setsockopt_paddr_thresholds(sk
, optval
, optlen
);
4482 case SCTP_RECVRCVINFO
:
4483 retval
= sctp_setsockopt_recvrcvinfo(sk
, optval
, optlen
);
4485 case SCTP_RECVNXTINFO
:
4486 retval
= sctp_setsockopt_recvnxtinfo(sk
, optval
, optlen
);
4488 case SCTP_PR_SUPPORTED
:
4489 retval
= sctp_setsockopt_pr_supported(sk
, optval
, optlen
);
4491 case SCTP_DEFAULT_PRINFO
:
4492 retval
= sctp_setsockopt_default_prinfo(sk
, optval
, optlen
);
4494 case SCTP_RECONFIG_SUPPORTED
:
4495 retval
= sctp_setsockopt_reconfig_supported(sk
, optval
, optlen
);
4497 case SCTP_ENABLE_STREAM_RESET
:
4498 retval
= sctp_setsockopt_enable_strreset(sk
, optval
, optlen
);
4500 case SCTP_RESET_STREAMS
:
4501 retval
= sctp_setsockopt_reset_streams(sk
, optval
, optlen
);
4503 case SCTP_RESET_ASSOC
:
4504 retval
= sctp_setsockopt_reset_assoc(sk
, optval
, optlen
);
4506 case SCTP_ADD_STREAMS
:
4507 retval
= sctp_setsockopt_add_streams(sk
, optval
, optlen
);
4509 case SCTP_STREAM_SCHEDULER
:
4510 retval
= sctp_setsockopt_scheduler(sk
, optval
, optlen
);
4512 case SCTP_STREAM_SCHEDULER_VALUE
:
4513 retval
= sctp_setsockopt_scheduler_value(sk
, optval
, optlen
);
4515 case SCTP_INTERLEAVING_SUPPORTED
:
4516 retval
= sctp_setsockopt_interleaving_supported(sk
, optval
,
4519 case SCTP_REUSE_PORT
:
4520 retval
= sctp_setsockopt_reuse_port(sk
, optval
, optlen
);
4523 retval
= sctp_setsockopt_event(sk
, optval
, optlen
);
4526 retval
= -ENOPROTOOPT
;
4536 /* API 3.1.6 connect() - UDP Style Syntax
4538 * An application may use the connect() call in the UDP model to initiate an
4539 * association without sending data.
4543 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4545 * sd: the socket descriptor to have a new association added to.
4547 * nam: the address structure (either struct sockaddr_in or struct
4548 * sockaddr_in6 defined in RFC2553 [7]).
4550 * len: the size of the address.
4552 static int sctp_connect(struct sock
*sk
, struct sockaddr
*addr
,
4553 int addr_len
, int flags
)
4555 struct inet_sock
*inet
= inet_sk(sk
);
4561 pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__
, sk
,
4564 /* We may need to bind the socket. */
4565 if (!inet
->inet_num
) {
4566 if (sk
->sk_prot
->get_port(sk
, 0)) {
4570 inet
->inet_sport
= htons(inet
->inet_num
);
4573 /* Validate addr_len before calling common connect/connectx routine. */
4574 af
= sctp_get_af_specific(addr
->sa_family
);
4575 if (!af
|| addr_len
< af
->sockaddr_len
) {
4578 /* Pass correct addr len to common routine (so it knows there
4579 * is only one address being passed.
4581 err
= __sctp_connect(sk
, addr
, af
->sockaddr_len
, flags
, NULL
);
4588 int sctp_inet_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
4589 int addr_len
, int flags
)
4591 if (addr_len
< sizeof(uaddr
->sa_family
))
4594 if (uaddr
->sa_family
== AF_UNSPEC
)
4597 return sctp_connect(sock
->sk
, uaddr
, addr_len
, flags
);
4600 /* FIXME: Write comments. */
4601 static int sctp_disconnect(struct sock
*sk
, int flags
)
4603 return -EOPNOTSUPP
; /* STUB */
4606 /* 4.1.4 accept() - TCP Style Syntax
4608 * Applications use accept() call to remove an established SCTP
4609 * association from the accept queue of the endpoint. A new socket
4610 * descriptor will be returned from accept() to represent the newly
4611 * formed association.
4613 static struct sock
*sctp_accept(struct sock
*sk
, int flags
, int *err
, bool kern
)
4615 struct sctp_sock
*sp
;
4616 struct sctp_endpoint
*ep
;
4617 struct sock
*newsk
= NULL
;
4618 struct sctp_association
*asoc
;
4627 if (!sctp_style(sk
, TCP
)) {
4628 error
= -EOPNOTSUPP
;
4632 if (!sctp_sstate(sk
, LISTENING
)) {
4637 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
4639 error
= sctp_wait_for_accept(sk
, timeo
);
4643 /* We treat the list of associations on the endpoint as the accept
4644 * queue and pick the first association on the list.
4646 asoc
= list_entry(ep
->asocs
.next
, struct sctp_association
, asocs
);
4648 newsk
= sp
->pf
->create_accept_sk(sk
, asoc
, kern
);
4654 /* Populate the fields of the newsk from the oldsk and migrate the
4655 * asoc to the newsk.
4657 sctp_sock_migrate(sk
, newsk
, asoc
, SCTP_SOCKET_TCP
);
4665 /* The SCTP ioctl handler. */
4666 static int sctp_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
4673 * SEQPACKET-style sockets in LISTENING state are valid, for
4674 * SCTP, so only discard TCP-style sockets in LISTENING state.
4676 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
4681 struct sk_buff
*skb
;
4682 unsigned int amount
= 0;
4684 skb
= skb_peek(&sk
->sk_receive_queue
);
4687 * We will only return the amount of this packet since
4688 * that is all that will be read.
4692 rc
= put_user(amount
, (int __user
*)arg
);
4704 /* This is the function which gets called during socket creation to
4705 * initialized the SCTP-specific portion of the sock.
4706 * The sock structure should already be zero-filled memory.
4708 static int sctp_init_sock(struct sock
*sk
)
4710 struct net
*net
= sock_net(sk
);
4711 struct sctp_sock
*sp
;
4713 pr_debug("%s: sk:%p\n", __func__
, sk
);
4717 /* Initialize the SCTP per socket area. */
4718 switch (sk
->sk_type
) {
4719 case SOCK_SEQPACKET
:
4720 sp
->type
= SCTP_SOCKET_UDP
;
4723 sp
->type
= SCTP_SOCKET_TCP
;
4726 return -ESOCKTNOSUPPORT
;
4729 sk
->sk_gso_type
= SKB_GSO_SCTP
;
4731 /* Initialize default send parameters. These parameters can be
4732 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4734 sp
->default_stream
= 0;
4735 sp
->default_ppid
= 0;
4736 sp
->default_flags
= 0;
4737 sp
->default_context
= 0;
4738 sp
->default_timetolive
= 0;
4740 sp
->default_rcv_context
= 0;
4741 sp
->max_burst
= net
->sctp
.max_burst
;
4743 sp
->sctp_hmac_alg
= net
->sctp
.sctp_hmac_alg
;
4745 /* Initialize default setup parameters. These parameters
4746 * can be modified with the SCTP_INITMSG socket option or
4747 * overridden by the SCTP_INIT CMSG.
4749 sp
->initmsg
.sinit_num_ostreams
= sctp_max_outstreams
;
4750 sp
->initmsg
.sinit_max_instreams
= sctp_max_instreams
;
4751 sp
->initmsg
.sinit_max_attempts
= net
->sctp
.max_retrans_init
;
4752 sp
->initmsg
.sinit_max_init_timeo
= net
->sctp
.rto_max
;
4754 /* Initialize default RTO related parameters. These parameters can
4755 * be modified for with the SCTP_RTOINFO socket option.
4757 sp
->rtoinfo
.srto_initial
= net
->sctp
.rto_initial
;
4758 sp
->rtoinfo
.srto_max
= net
->sctp
.rto_max
;
4759 sp
->rtoinfo
.srto_min
= net
->sctp
.rto_min
;
4761 /* Initialize default association related parameters. These parameters
4762 * can be modified with the SCTP_ASSOCINFO socket option.
4764 sp
->assocparams
.sasoc_asocmaxrxt
= net
->sctp
.max_retrans_association
;
4765 sp
->assocparams
.sasoc_number_peer_destinations
= 0;
4766 sp
->assocparams
.sasoc_peer_rwnd
= 0;
4767 sp
->assocparams
.sasoc_local_rwnd
= 0;
4768 sp
->assocparams
.sasoc_cookie_life
= net
->sctp
.valid_cookie_life
;
4770 /* Initialize default event subscriptions. By default, all the
4775 /* Default Peer Address Parameters. These defaults can
4776 * be modified via SCTP_PEER_ADDR_PARAMS
4778 sp
->hbinterval
= net
->sctp
.hb_interval
;
4779 sp
->pathmaxrxt
= net
->sctp
.max_retrans_path
;
4780 sp
->pathmtu
= 0; /* allow default discovery */
4781 sp
->sackdelay
= net
->sctp
.sack_timeout
;
4783 sp
->param_flags
= SPP_HB_ENABLE
|
4785 SPP_SACKDELAY_ENABLE
;
4787 /* If enabled no SCTP message fragmentation will be performed.
4788 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
4790 sp
->disable_fragments
= 0;
4792 /* Enable Nagle algorithm by default. */
4795 sp
->recvrcvinfo
= 0;
4796 sp
->recvnxtinfo
= 0;
4798 /* Enable by default. */
4801 /* Auto-close idle associations after the configured
4802 * number of seconds. A value of 0 disables this
4803 * feature. Configure through the SCTP_AUTOCLOSE socket option,
4804 * for UDP-style sockets only.
4808 /* User specified fragmentation limit. */
4811 sp
->adaptation_ind
= 0;
4813 sp
->pf
= sctp_get_pf_specific(sk
->sk_family
);
4815 /* Control variables for partial data delivery. */
4816 atomic_set(&sp
->pd_mode
, 0);
4817 skb_queue_head_init(&sp
->pd_lobby
);
4818 sp
->frag_interleave
= 0;
4820 /* Create a per socket endpoint structure. Even if we
4821 * change the data structure relationships, this may still
4822 * be useful for storing pre-connect address information.
4824 sp
->ep
= sctp_endpoint_new(sk
, GFP_KERNEL
);
4830 sk
->sk_destruct
= sctp_destruct_sock
;
4832 SCTP_DBG_OBJCNT_INC(sock
);
4835 sk_sockets_allocated_inc(sk
);
4836 sock_prot_inuse_add(net
, sk
->sk_prot
, 1);
4838 /* Nothing can fail after this block, otherwise
4839 * sctp_destroy_sock() will be called without addr_wq_lock held
4841 if (net
->sctp
.default_auto_asconf
) {
4842 spin_lock(&sock_net(sk
)->sctp
.addr_wq_lock
);
4843 list_add_tail(&sp
->auto_asconf_list
,
4844 &net
->sctp
.auto_asconf_splist
);
4845 sp
->do_auto_asconf
= 1;
4846 spin_unlock(&sock_net(sk
)->sctp
.addr_wq_lock
);
4848 sp
->do_auto_asconf
= 0;
4856 /* Cleanup any SCTP per socket resources. Must be called with
4857 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
4859 static void sctp_destroy_sock(struct sock
*sk
)
4861 struct sctp_sock
*sp
;
4863 pr_debug("%s: sk:%p\n", __func__
, sk
);
4865 /* Release our hold on the endpoint. */
4867 /* This could happen during socket init, thus we bail out
4868 * early, since the rest of the below is not setup either.
4873 if (sp
->do_auto_asconf
) {
4874 sp
->do_auto_asconf
= 0;
4875 list_del(&sp
->auto_asconf_list
);
4877 sctp_endpoint_free(sp
->ep
);
4879 sk_sockets_allocated_dec(sk
);
4880 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, -1);
4884 /* Triggered when there are no references on the socket anymore */
4885 static void sctp_destruct_sock(struct sock
*sk
)
4887 struct sctp_sock
*sp
= sctp_sk(sk
);
4889 /* Free up the HMAC transform. */
4890 crypto_free_shash(sp
->hmac
);
4892 inet_sock_destruct(sk
);
4895 /* API 4.1.7 shutdown() - TCP Style Syntax
4896 * int shutdown(int socket, int how);
4898 * sd - the socket descriptor of the association to be closed.
4899 * how - Specifies the type of shutdown. The values are
4902 * Disables further receive operations. No SCTP
4903 * protocol action is taken.
4905 * Disables further send operations, and initiates
4906 * the SCTP shutdown sequence.
4908 * Disables further send and receive operations
4909 * and initiates the SCTP shutdown sequence.
4911 static void sctp_shutdown(struct sock
*sk
, int how
)
4913 struct net
*net
= sock_net(sk
);
4914 struct sctp_endpoint
*ep
;
4916 if (!sctp_style(sk
, TCP
))
4919 ep
= sctp_sk(sk
)->ep
;
4920 if (how
& SEND_SHUTDOWN
&& !list_empty(&ep
->asocs
)) {
4921 struct sctp_association
*asoc
;
4923 inet_sk_set_state(sk
, SCTP_SS_CLOSING
);
4924 asoc
= list_entry(ep
->asocs
.next
,
4925 struct sctp_association
, asocs
);
4926 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
4930 int sctp_get_sctp_info(struct sock
*sk
, struct sctp_association
*asoc
,
4931 struct sctp_info
*info
)
4933 struct sctp_transport
*prim
;
4934 struct list_head
*pos
;
4937 memset(info
, 0, sizeof(*info
));
4939 struct sctp_sock
*sp
= sctp_sk(sk
);
4941 info
->sctpi_s_autoclose
= sp
->autoclose
;
4942 info
->sctpi_s_adaptation_ind
= sp
->adaptation_ind
;
4943 info
->sctpi_s_pd_point
= sp
->pd_point
;
4944 info
->sctpi_s_nodelay
= sp
->nodelay
;
4945 info
->sctpi_s_disable_fragments
= sp
->disable_fragments
;
4946 info
->sctpi_s_v4mapped
= sp
->v4mapped
;
4947 info
->sctpi_s_frag_interleave
= sp
->frag_interleave
;
4948 info
->sctpi_s_type
= sp
->type
;
4953 info
->sctpi_tag
= asoc
->c
.my_vtag
;
4954 info
->sctpi_state
= asoc
->state
;
4955 info
->sctpi_rwnd
= asoc
->a_rwnd
;
4956 info
->sctpi_unackdata
= asoc
->unack_data
;
4957 info
->sctpi_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
4958 info
->sctpi_instrms
= asoc
->stream
.incnt
;
4959 info
->sctpi_outstrms
= asoc
->stream
.outcnt
;
4960 list_for_each(pos
, &asoc
->base
.inqueue
.in_chunk_list
)
4961 info
->sctpi_inqueue
++;
4962 list_for_each(pos
, &asoc
->outqueue
.out_chunk_list
)
4963 info
->sctpi_outqueue
++;
4964 info
->sctpi_overall_error
= asoc
->overall_error_count
;
4965 info
->sctpi_max_burst
= asoc
->max_burst
;
4966 info
->sctpi_maxseg
= asoc
->frag_point
;
4967 info
->sctpi_peer_rwnd
= asoc
->peer
.rwnd
;
4968 info
->sctpi_peer_tag
= asoc
->c
.peer_vtag
;
4970 mask
= asoc
->peer
.ecn_capable
<< 1;
4971 mask
= (mask
| asoc
->peer
.ipv4_address
) << 1;
4972 mask
= (mask
| asoc
->peer
.ipv6_address
) << 1;
4973 mask
= (mask
| asoc
->peer
.hostname_address
) << 1;
4974 mask
= (mask
| asoc
->peer
.asconf_capable
) << 1;
4975 mask
= (mask
| asoc
->peer
.prsctp_capable
) << 1;
4976 mask
= (mask
| asoc
->peer
.auth_capable
);
4977 info
->sctpi_peer_capable
= mask
;
4978 mask
= asoc
->peer
.sack_needed
<< 1;
4979 mask
= (mask
| asoc
->peer
.sack_generation
) << 1;
4980 mask
= (mask
| asoc
->peer
.zero_window_announced
);
4981 info
->sctpi_peer_sack
= mask
;
4983 info
->sctpi_isacks
= asoc
->stats
.isacks
;
4984 info
->sctpi_osacks
= asoc
->stats
.osacks
;
4985 info
->sctpi_opackets
= asoc
->stats
.opackets
;
4986 info
->sctpi_ipackets
= asoc
->stats
.ipackets
;
4987 info
->sctpi_rtxchunks
= asoc
->stats
.rtxchunks
;
4988 info
->sctpi_outofseqtsns
= asoc
->stats
.outofseqtsns
;
4989 info
->sctpi_idupchunks
= asoc
->stats
.idupchunks
;
4990 info
->sctpi_gapcnt
= asoc
->stats
.gapcnt
;
4991 info
->sctpi_ouodchunks
= asoc
->stats
.ouodchunks
;
4992 info
->sctpi_iuodchunks
= asoc
->stats
.iuodchunks
;
4993 info
->sctpi_oodchunks
= asoc
->stats
.oodchunks
;
4994 info
->sctpi_iodchunks
= asoc
->stats
.iodchunks
;
4995 info
->sctpi_octrlchunks
= asoc
->stats
.octrlchunks
;
4996 info
->sctpi_ictrlchunks
= asoc
->stats
.ictrlchunks
;
4998 prim
= asoc
->peer
.primary_path
;
4999 memcpy(&info
->sctpi_p_address
, &prim
->ipaddr
, sizeof(prim
->ipaddr
));
5000 info
->sctpi_p_state
= prim
->state
;
5001 info
->sctpi_p_cwnd
= prim
->cwnd
;
5002 info
->sctpi_p_srtt
= prim
->srtt
;
5003 info
->sctpi_p_rto
= jiffies_to_msecs(prim
->rto
);
5004 info
->sctpi_p_hbinterval
= prim
->hbinterval
;
5005 info
->sctpi_p_pathmaxrxt
= prim
->pathmaxrxt
;
5006 info
->sctpi_p_sackdelay
= jiffies_to_msecs(prim
->sackdelay
);
5007 info
->sctpi_p_ssthresh
= prim
->ssthresh
;
5008 info
->sctpi_p_partial_bytes_acked
= prim
->partial_bytes_acked
;
5009 info
->sctpi_p_flight_size
= prim
->flight_size
;
5010 info
->sctpi_p_error
= prim
->error_count
;
5014 EXPORT_SYMBOL_GPL(sctp_get_sctp_info
);
5016 /* use callback to avoid exporting the core structure */
5017 void sctp_transport_walk_start(struct rhashtable_iter
*iter
)
5019 rhltable_walk_enter(&sctp_transport_hashtable
, iter
);
5021 rhashtable_walk_start(iter
);
5024 void sctp_transport_walk_stop(struct rhashtable_iter
*iter
)
5026 rhashtable_walk_stop(iter
);
5027 rhashtable_walk_exit(iter
);
5030 struct sctp_transport
*sctp_transport_get_next(struct net
*net
,
5031 struct rhashtable_iter
*iter
)
5033 struct sctp_transport
*t
;
5035 t
= rhashtable_walk_next(iter
);
5036 for (; t
; t
= rhashtable_walk_next(iter
)) {
5038 if (PTR_ERR(t
) == -EAGAIN
)
5043 if (!sctp_transport_hold(t
))
5046 if (net_eq(sock_net(t
->asoc
->base
.sk
), net
) &&
5047 t
->asoc
->peer
.primary_path
== t
)
5050 sctp_transport_put(t
);
5056 struct sctp_transport
*sctp_transport_get_idx(struct net
*net
,
5057 struct rhashtable_iter
*iter
,
5060 struct sctp_transport
*t
;
5063 return SEQ_START_TOKEN
;
5065 while ((t
= sctp_transport_get_next(net
, iter
)) && !IS_ERR(t
)) {
5068 sctp_transport_put(t
);
5074 int sctp_for_each_endpoint(int (*cb
)(struct sctp_endpoint
*, void *),
5078 struct sctp_ep_common
*epb
;
5079 struct sctp_hashbucket
*head
;
5081 for (head
= sctp_ep_hashtable
; hash
< sctp_ep_hashsize
;
5083 read_lock_bh(&head
->lock
);
5084 sctp_for_each_hentry(epb
, &head
->chain
) {
5085 err
= cb(sctp_ep(epb
), p
);
5089 read_unlock_bh(&head
->lock
);
5094 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint
);
5096 int sctp_transport_lookup_process(int (*cb
)(struct sctp_transport
*, void *),
5098 const union sctp_addr
*laddr
,
5099 const union sctp_addr
*paddr
, void *p
)
5101 struct sctp_transport
*transport
;
5105 transport
= sctp_addrs_lookup_transport(net
, laddr
, paddr
);
5110 err
= cb(transport
, p
);
5111 sctp_transport_put(transport
);
5115 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process
);
5117 int sctp_for_each_transport(int (*cb
)(struct sctp_transport
*, void *),
5118 int (*cb_done
)(struct sctp_transport
*, void *),
5119 struct net
*net
, int *pos
, void *p
) {
5120 struct rhashtable_iter hti
;
5121 struct sctp_transport
*tsp
;
5126 sctp_transport_walk_start(&hti
);
5128 tsp
= sctp_transport_get_idx(net
, &hti
, *pos
+ 1);
5129 for (; !IS_ERR_OR_NULL(tsp
); tsp
= sctp_transport_get_next(net
, &hti
)) {
5134 sctp_transport_put(tsp
);
5136 sctp_transport_walk_stop(&hti
);
5139 if (cb_done
&& !cb_done(tsp
, p
)) {
5141 sctp_transport_put(tsp
);
5144 sctp_transport_put(tsp
);
5149 EXPORT_SYMBOL_GPL(sctp_for_each_transport
);
5151 /* 7.2.1 Association Status (SCTP_STATUS)
5153 * Applications can retrieve current status information about an
5154 * association, including association state, peer receiver window size,
5155 * number of unacked data chunks, and number of data chunks pending
5156 * receipt. This information is read-only.
5158 static int sctp_getsockopt_sctp_status(struct sock
*sk
, int len
,
5159 char __user
*optval
,
5162 struct sctp_status status
;
5163 struct sctp_association
*asoc
= NULL
;
5164 struct sctp_transport
*transport
;
5165 sctp_assoc_t associd
;
5168 if (len
< sizeof(status
)) {
5173 len
= sizeof(status
);
5174 if (copy_from_user(&status
, optval
, len
)) {
5179 associd
= status
.sstat_assoc_id
;
5180 asoc
= sctp_id2assoc(sk
, associd
);
5186 transport
= asoc
->peer
.primary_path
;
5188 status
.sstat_assoc_id
= sctp_assoc2id(asoc
);
5189 status
.sstat_state
= sctp_assoc_to_state(asoc
);
5190 status
.sstat_rwnd
= asoc
->peer
.rwnd
;
5191 status
.sstat_unackdata
= asoc
->unack_data
;
5193 status
.sstat_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
5194 status
.sstat_instrms
= asoc
->stream
.incnt
;
5195 status
.sstat_outstrms
= asoc
->stream
.outcnt
;
5196 status
.sstat_fragmentation_point
= asoc
->frag_point
;
5197 status
.sstat_primary
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
5198 memcpy(&status
.sstat_primary
.spinfo_address
, &transport
->ipaddr
,
5199 transport
->af_specific
->sockaddr_len
);
5200 /* Map ipv4 address into v4-mapped-on-v6 address. */
5201 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
5202 (union sctp_addr
*)&status
.sstat_primary
.spinfo_address
);
5203 status
.sstat_primary
.spinfo_state
= transport
->state
;
5204 status
.sstat_primary
.spinfo_cwnd
= transport
->cwnd
;
5205 status
.sstat_primary
.spinfo_srtt
= transport
->srtt
;
5206 status
.sstat_primary
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
5207 status
.sstat_primary
.spinfo_mtu
= transport
->pathmtu
;
5209 if (status
.sstat_primary
.spinfo_state
== SCTP_UNKNOWN
)
5210 status
.sstat_primary
.spinfo_state
= SCTP_ACTIVE
;
5212 if (put_user(len
, optlen
)) {
5217 pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5218 __func__
, len
, status
.sstat_state
, status
.sstat_rwnd
,
5219 status
.sstat_assoc_id
);
5221 if (copy_to_user(optval
, &status
, len
)) {
5231 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5233 * Applications can retrieve information about a specific peer address
5234 * of an association, including its reachability state, congestion
5235 * window, and retransmission timer values. This information is
5238 static int sctp_getsockopt_peer_addr_info(struct sock
*sk
, int len
,
5239 char __user
*optval
,
5242 struct sctp_paddrinfo pinfo
;
5243 struct sctp_transport
*transport
;
5246 if (len
< sizeof(pinfo
)) {
5251 len
= sizeof(pinfo
);
5252 if (copy_from_user(&pinfo
, optval
, len
)) {
5257 transport
= sctp_addr_id2transport(sk
, &pinfo
.spinfo_address
,
5258 pinfo
.spinfo_assoc_id
);
5262 pinfo
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
5263 pinfo
.spinfo_state
= transport
->state
;
5264 pinfo
.spinfo_cwnd
= transport
->cwnd
;
5265 pinfo
.spinfo_srtt
= transport
->srtt
;
5266 pinfo
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
5267 pinfo
.spinfo_mtu
= transport
->pathmtu
;
5269 if (pinfo
.spinfo_state
== SCTP_UNKNOWN
)
5270 pinfo
.spinfo_state
= SCTP_ACTIVE
;
5272 if (put_user(len
, optlen
)) {
5277 if (copy_to_user(optval
, &pinfo
, len
)) {
5286 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5288 * This option is a on/off flag. If enabled no SCTP message
5289 * fragmentation will be performed. Instead if a message being sent
5290 * exceeds the current PMTU size, the message will NOT be sent and
5291 * instead a error will be indicated to the user.
5293 static int sctp_getsockopt_disable_fragments(struct sock
*sk
, int len
,
5294 char __user
*optval
, int __user
*optlen
)
5298 if (len
< sizeof(int))
5302 val
= (sctp_sk(sk
)->disable_fragments
== 1);
5303 if (put_user(len
, optlen
))
5305 if (copy_to_user(optval
, &val
, len
))
5310 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5312 * This socket option is used to specify various notifications and
5313 * ancillary data the user wishes to receive.
5315 static int sctp_getsockopt_events(struct sock
*sk
, int len
, char __user
*optval
,
5318 struct sctp_event_subscribe subscribe
;
5319 __u8
*sn_type
= (__u8
*)&subscribe
;
5324 if (len
> sizeof(struct sctp_event_subscribe
))
5325 len
= sizeof(struct sctp_event_subscribe
);
5326 if (put_user(len
, optlen
))
5329 for (i
= 0; i
< len
; i
++)
5330 sn_type
[i
] = sctp_ulpevent_type_enabled(sctp_sk(sk
)->subscribe
,
5331 SCTP_SN_TYPE_BASE
+ i
);
5333 if (copy_to_user(optval
, &subscribe
, len
))
5339 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5341 * This socket option is applicable to the UDP-style socket only. When
5342 * set it will cause associations that are idle for more than the
5343 * specified number of seconds to automatically close. An association
5344 * being idle is defined an association that has NOT sent or received
5345 * user data. The special value of '0' indicates that no automatic
5346 * close of any associations should be performed. The option expects an
5347 * integer defining the number of seconds of idle time before an
5348 * association is closed.
5350 static int sctp_getsockopt_autoclose(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5352 /* Applicable to UDP-style socket only */
5353 if (sctp_style(sk
, TCP
))
5355 if (len
< sizeof(int))
5358 if (put_user(len
, optlen
))
5360 if (put_user(sctp_sk(sk
)->autoclose
, (int __user
*)optval
))
5365 /* Helper routine to branch off an association to a new socket. */
5366 int sctp_do_peeloff(struct sock
*sk
, sctp_assoc_t id
, struct socket
**sockp
)
5368 struct sctp_association
*asoc
= sctp_id2assoc(sk
, id
);
5369 struct sctp_sock
*sp
= sctp_sk(sk
);
5370 struct socket
*sock
;
5373 /* Do not peel off from one netns to another one. */
5374 if (!net_eq(current
->nsproxy
->net_ns
, sock_net(sk
)))
5380 /* An association cannot be branched off from an already peeled-off
5381 * socket, nor is this supported for tcp style sockets.
5383 if (!sctp_style(sk
, UDP
))
5386 /* Create a new socket. */
5387 err
= sock_create(sk
->sk_family
, SOCK_SEQPACKET
, IPPROTO_SCTP
, &sock
);
5391 sctp_copy_sock(sock
->sk
, sk
, asoc
);
5393 /* Make peeled-off sockets more like 1-1 accepted sockets.
5394 * Set the daddr and initialize id to something more random and also
5395 * copy over any ip options.
5397 sp
->pf
->to_sk_daddr(&asoc
->peer
.primary_addr
, sk
);
5398 sp
->pf
->copy_ip_options(sk
, sock
->sk
);
5400 /* Populate the fields of the newsk from the oldsk and migrate the
5401 * asoc to the newsk.
5403 sctp_sock_migrate(sk
, sock
->sk
, asoc
, SCTP_SOCKET_UDP_HIGH_BANDWIDTH
);
5409 EXPORT_SYMBOL(sctp_do_peeloff
);
5411 static int sctp_getsockopt_peeloff_common(struct sock
*sk
, sctp_peeloff_arg_t
*peeloff
,
5412 struct file
**newfile
, unsigned flags
)
5414 struct socket
*newsock
;
5417 retval
= sctp_do_peeloff(sk
, peeloff
->associd
, &newsock
);
5421 /* Map the socket to an unused fd that can be returned to the user. */
5422 retval
= get_unused_fd_flags(flags
& SOCK_CLOEXEC
);
5424 sock_release(newsock
);
5428 *newfile
= sock_alloc_file(newsock
, 0, NULL
);
5429 if (IS_ERR(*newfile
)) {
5430 put_unused_fd(retval
);
5431 retval
= PTR_ERR(*newfile
);
5436 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__
, sk
, newsock
->sk
,
5439 peeloff
->sd
= retval
;
5441 if (flags
& SOCK_NONBLOCK
)
5442 (*newfile
)->f_flags
|= O_NONBLOCK
;
5447 static int sctp_getsockopt_peeloff(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5449 sctp_peeloff_arg_t peeloff
;
5450 struct file
*newfile
= NULL
;
5453 if (len
< sizeof(sctp_peeloff_arg_t
))
5455 len
= sizeof(sctp_peeloff_arg_t
);
5456 if (copy_from_user(&peeloff
, optval
, len
))
5459 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
, &newfile
, 0);
5463 /* Return the fd mapped to the new socket. */
5464 if (put_user(len
, optlen
)) {
5466 put_unused_fd(retval
);
5470 if (copy_to_user(optval
, &peeloff
, len
)) {
5472 put_unused_fd(retval
);
5475 fd_install(retval
, newfile
);
5480 static int sctp_getsockopt_peeloff_flags(struct sock
*sk
, int len
,
5481 char __user
*optval
, int __user
*optlen
)
5483 sctp_peeloff_flags_arg_t peeloff
;
5484 struct file
*newfile
= NULL
;
5487 if (len
< sizeof(sctp_peeloff_flags_arg_t
))
5489 len
= sizeof(sctp_peeloff_flags_arg_t
);
5490 if (copy_from_user(&peeloff
, optval
, len
))
5493 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
.p_arg
,
5494 &newfile
, peeloff
.flags
);
5498 /* Return the fd mapped to the new socket. */
5499 if (put_user(len
, optlen
)) {
5501 put_unused_fd(retval
);
5505 if (copy_to_user(optval
, &peeloff
, len
)) {
5507 put_unused_fd(retval
);
5510 fd_install(retval
, newfile
);
5515 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5517 * Applications can enable or disable heartbeats for any peer address of
5518 * an association, modify an address's heartbeat interval, force a
5519 * heartbeat to be sent immediately, and adjust the address's maximum
5520 * number of retransmissions sent before an address is considered
5521 * unreachable. The following structure is used to access and modify an
5522 * address's parameters:
5524 * struct sctp_paddrparams {
5525 * sctp_assoc_t spp_assoc_id;
5526 * struct sockaddr_storage spp_address;
5527 * uint32_t spp_hbinterval;
5528 * uint16_t spp_pathmaxrxt;
5529 * uint32_t spp_pathmtu;
5530 * uint32_t spp_sackdelay;
5531 * uint32_t spp_flags;
5534 * spp_assoc_id - (one-to-many style socket) This is filled in the
5535 * application, and identifies the association for
5537 * spp_address - This specifies which address is of interest.
5538 * spp_hbinterval - This contains the value of the heartbeat interval,
5539 * in milliseconds. If a value of zero
5540 * is present in this field then no changes are to
5541 * be made to this parameter.
5542 * spp_pathmaxrxt - This contains the maximum number of
5543 * retransmissions before this address shall be
5544 * considered unreachable. If a value of zero
5545 * is present in this field then no changes are to
5546 * be made to this parameter.
5547 * spp_pathmtu - When Path MTU discovery is disabled the value
5548 * specified here will be the "fixed" path mtu.
5549 * Note that if the spp_address field is empty
5550 * then all associations on this address will
5551 * have this fixed path mtu set upon them.
5553 * spp_sackdelay - When delayed sack is enabled, this value specifies
5554 * the number of milliseconds that sacks will be delayed
5555 * for. This value will apply to all addresses of an
5556 * association if the spp_address field is empty. Note
5557 * also, that if delayed sack is enabled and this
5558 * value is set to 0, no change is made to the last
5559 * recorded delayed sack timer value.
5561 * spp_flags - These flags are used to control various features
5562 * on an association. The flag field may contain
5563 * zero or more of the following options.
5565 * SPP_HB_ENABLE - Enable heartbeats on the
5566 * specified address. Note that if the address
5567 * field is empty all addresses for the association
5568 * have heartbeats enabled upon them.
5570 * SPP_HB_DISABLE - Disable heartbeats on the
5571 * speicifed address. Note that if the address
5572 * field is empty all addresses for the association
5573 * will have their heartbeats disabled. Note also
5574 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
5575 * mutually exclusive, only one of these two should
5576 * be specified. Enabling both fields will have
5577 * undetermined results.
5579 * SPP_HB_DEMAND - Request a user initiated heartbeat
5580 * to be made immediately.
5582 * SPP_PMTUD_ENABLE - This field will enable PMTU
5583 * discovery upon the specified address. Note that
5584 * if the address feild is empty then all addresses
5585 * on the association are effected.
5587 * SPP_PMTUD_DISABLE - This field will disable PMTU
5588 * discovery upon the specified address. Note that
5589 * if the address feild is empty then all addresses
5590 * on the association are effected. Not also that
5591 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5592 * exclusive. Enabling both will have undetermined
5595 * SPP_SACKDELAY_ENABLE - Setting this flag turns
5596 * on delayed sack. The time specified in spp_sackdelay
5597 * is used to specify the sack delay for this address. Note
5598 * that if spp_address is empty then all addresses will
5599 * enable delayed sack and take on the sack delay
5600 * value specified in spp_sackdelay.
5601 * SPP_SACKDELAY_DISABLE - Setting this flag turns
5602 * off delayed sack. If the spp_address field is blank then
5603 * delayed sack is disabled for the entire association. Note
5604 * also that this field is mutually exclusive to
5605 * SPP_SACKDELAY_ENABLE, setting both will have undefined
5608 * SPP_IPV6_FLOWLABEL: Setting this flag enables the
5609 * setting of the IPV6 flow label value. The value is
5610 * contained in the spp_ipv6_flowlabel field.
5611 * Upon retrieval, this flag will be set to indicate that
5612 * the spp_ipv6_flowlabel field has a valid value returned.
5613 * If a specific destination address is set (in the
5614 * spp_address field), then the value returned is that of
5615 * the address. If just an association is specified (and
5616 * no address), then the association's default flow label
5617 * is returned. If neither an association nor a destination
5618 * is specified, then the socket's default flow label is
5619 * returned. For non-IPv6 sockets, this flag will be left
5622 * SPP_DSCP: Setting this flag enables the setting of the
5623 * Differentiated Services Code Point (DSCP) value
5624 * associated with either the association or a specific
5625 * address. The value is obtained in the spp_dscp field.
5626 * Upon retrieval, this flag will be set to indicate that
5627 * the spp_dscp field has a valid value returned. If a
5628 * specific destination address is set when called (in the
5629 * spp_address field), then that specific destination
5630 * address's DSCP value is returned. If just an association
5631 * is specified, then the association's default DSCP is
5632 * returned. If neither an association nor a destination is
5633 * specified, then the socket's default DSCP is returned.
5635 * spp_ipv6_flowlabel
5636 * - This field is used in conjunction with the
5637 * SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
5638 * The 20 least significant bits are used for the flow
5639 * label. This setting has precedence over any IPv6-layer
5642 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
5643 * and contains the DSCP. The 6 most significant bits are
5644 * used for the DSCP. This setting has precedence over any
5645 * IPv4- or IPv6- layer setting.
5647 static int sctp_getsockopt_peer_addr_params(struct sock
*sk
, int len
,
5648 char __user
*optval
, int __user
*optlen
)
5650 struct sctp_paddrparams params
;
5651 struct sctp_transport
*trans
= NULL
;
5652 struct sctp_association
*asoc
= NULL
;
5653 struct sctp_sock
*sp
= sctp_sk(sk
);
5655 if (len
>= sizeof(params
))
5656 len
= sizeof(params
);
5657 else if (len
>= ALIGN(offsetof(struct sctp_paddrparams
,
5658 spp_ipv6_flowlabel
), 4))
5659 len
= ALIGN(offsetof(struct sctp_paddrparams
,
5660 spp_ipv6_flowlabel
), 4);
5664 if (copy_from_user(¶ms
, optval
, len
))
5667 /* If an address other than INADDR_ANY is specified, and
5668 * no transport is found, then the request is invalid.
5670 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spp_address
)) {
5671 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
5672 params
.spp_assoc_id
);
5674 pr_debug("%s: failed no transport\n", __func__
);
5679 /* Get association, if assoc_id != 0 and the socket is a one
5680 * to many style socket, and an association was not found, then
5681 * the id was invalid.
5683 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
5684 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
)) {
5685 pr_debug("%s: failed no association\n", __func__
);
5690 /* Fetch transport values. */
5691 params
.spp_hbinterval
= jiffies_to_msecs(trans
->hbinterval
);
5692 params
.spp_pathmtu
= trans
->pathmtu
;
5693 params
.spp_pathmaxrxt
= trans
->pathmaxrxt
;
5694 params
.spp_sackdelay
= jiffies_to_msecs(trans
->sackdelay
);
5696 /*draft-11 doesn't say what to return in spp_flags*/
5697 params
.spp_flags
= trans
->param_flags
;
5698 if (trans
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5699 params
.spp_ipv6_flowlabel
= trans
->flowlabel
&
5700 SCTP_FLOWLABEL_VAL_MASK
;
5701 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5703 if (trans
->dscp
& SCTP_DSCP_SET_MASK
) {
5704 params
.spp_dscp
= trans
->dscp
& SCTP_DSCP_VAL_MASK
;
5705 params
.spp_flags
|= SPP_DSCP
;
5708 /* Fetch association values. */
5709 params
.spp_hbinterval
= jiffies_to_msecs(asoc
->hbinterval
);
5710 params
.spp_pathmtu
= asoc
->pathmtu
;
5711 params
.spp_pathmaxrxt
= asoc
->pathmaxrxt
;
5712 params
.spp_sackdelay
= jiffies_to_msecs(asoc
->sackdelay
);
5714 /*draft-11 doesn't say what to return in spp_flags*/
5715 params
.spp_flags
= asoc
->param_flags
;
5716 if (asoc
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5717 params
.spp_ipv6_flowlabel
= asoc
->flowlabel
&
5718 SCTP_FLOWLABEL_VAL_MASK
;
5719 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5721 if (asoc
->dscp
& SCTP_DSCP_SET_MASK
) {
5722 params
.spp_dscp
= asoc
->dscp
& SCTP_DSCP_VAL_MASK
;
5723 params
.spp_flags
|= SPP_DSCP
;
5726 /* Fetch socket values. */
5727 params
.spp_hbinterval
= sp
->hbinterval
;
5728 params
.spp_pathmtu
= sp
->pathmtu
;
5729 params
.spp_sackdelay
= sp
->sackdelay
;
5730 params
.spp_pathmaxrxt
= sp
->pathmaxrxt
;
5732 /*draft-11 doesn't say what to return in spp_flags*/
5733 params
.spp_flags
= sp
->param_flags
;
5734 if (sp
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5735 params
.spp_ipv6_flowlabel
= sp
->flowlabel
&
5736 SCTP_FLOWLABEL_VAL_MASK
;
5737 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5739 if (sp
->dscp
& SCTP_DSCP_SET_MASK
) {
5740 params
.spp_dscp
= sp
->dscp
& SCTP_DSCP_VAL_MASK
;
5741 params
.spp_flags
|= SPP_DSCP
;
5745 if (copy_to_user(optval
, ¶ms
, len
))
5748 if (put_user(len
, optlen
))
5755 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
5757 * This option will effect the way delayed acks are performed. This
5758 * option allows you to get or set the delayed ack time, in
5759 * milliseconds. It also allows changing the delayed ack frequency.
5760 * Changing the frequency to 1 disables the delayed sack algorithm. If
5761 * the assoc_id is 0, then this sets or gets the endpoints default
5762 * values. If the assoc_id field is non-zero, then the set or get
5763 * effects the specified association for the one to many model (the
5764 * assoc_id field is ignored by the one to one model). Note that if
5765 * sack_delay or sack_freq are 0 when setting this option, then the
5766 * current values will remain unchanged.
5768 * struct sctp_sack_info {
5769 * sctp_assoc_t sack_assoc_id;
5770 * uint32_t sack_delay;
5771 * uint32_t sack_freq;
5774 * sack_assoc_id - This parameter, indicates which association the user
5775 * is performing an action upon. Note that if this field's value is
5776 * zero then the endpoints default value is changed (effecting future
5777 * associations only).
5779 * sack_delay - This parameter contains the number of milliseconds that
5780 * the user is requesting the delayed ACK timer be set to. Note that
5781 * this value is defined in the standard to be between 200 and 500
5784 * sack_freq - This parameter contains the number of packets that must
5785 * be received before a sack is sent without waiting for the delay
5786 * timer to expire. The default value for this is 2, setting this
5787 * value to 1 will disable the delayed sack algorithm.
5789 static int sctp_getsockopt_delayed_ack(struct sock
*sk
, int len
,
5790 char __user
*optval
,
5793 struct sctp_sack_info params
;
5794 struct sctp_association
*asoc
= NULL
;
5795 struct sctp_sock
*sp
= sctp_sk(sk
);
5797 if (len
>= sizeof(struct sctp_sack_info
)) {
5798 len
= sizeof(struct sctp_sack_info
);
5800 if (copy_from_user(¶ms
, optval
, len
))
5802 } else if (len
== sizeof(struct sctp_assoc_value
)) {
5803 pr_warn_ratelimited(DEPRECATED
5805 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
5806 "Use struct sctp_sack_info instead\n",
5807 current
->comm
, task_pid_nr(current
));
5808 if (copy_from_user(¶ms
, optval
, len
))
5813 /* Get association, if sack_assoc_id != 0 and the socket is a one
5814 * to many style socket, and an association was not found, then
5815 * the id was invalid.
5817 asoc
= sctp_id2assoc(sk
, params
.sack_assoc_id
);
5818 if (!asoc
&& params
.sack_assoc_id
&& sctp_style(sk
, UDP
))
5822 /* Fetch association values. */
5823 if (asoc
->param_flags
& SPP_SACKDELAY_ENABLE
) {
5824 params
.sack_delay
= jiffies_to_msecs(
5826 params
.sack_freq
= asoc
->sackfreq
;
5829 params
.sack_delay
= 0;
5830 params
.sack_freq
= 1;
5833 /* Fetch socket values. */
5834 if (sp
->param_flags
& SPP_SACKDELAY_ENABLE
) {
5835 params
.sack_delay
= sp
->sackdelay
;
5836 params
.sack_freq
= sp
->sackfreq
;
5838 params
.sack_delay
= 0;
5839 params
.sack_freq
= 1;
5843 if (copy_to_user(optval
, ¶ms
, len
))
5846 if (put_user(len
, optlen
))
5852 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
5854 * Applications can specify protocol parameters for the default association
5855 * initialization. The option name argument to setsockopt() and getsockopt()
5858 * Setting initialization parameters is effective only on an unconnected
5859 * socket (for UDP-style sockets only future associations are effected
5860 * by the change). With TCP-style sockets, this option is inherited by
5861 * sockets derived from a listener socket.
5863 static int sctp_getsockopt_initmsg(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5865 if (len
< sizeof(struct sctp_initmsg
))
5867 len
= sizeof(struct sctp_initmsg
);
5868 if (put_user(len
, optlen
))
5870 if (copy_to_user(optval
, &sctp_sk(sk
)->initmsg
, len
))
5876 static int sctp_getsockopt_peer_addrs(struct sock
*sk
, int len
,
5877 char __user
*optval
, int __user
*optlen
)
5879 struct sctp_association
*asoc
;
5881 struct sctp_getaddrs getaddrs
;
5882 struct sctp_transport
*from
;
5884 union sctp_addr temp
;
5885 struct sctp_sock
*sp
= sctp_sk(sk
);
5890 if (len
< sizeof(struct sctp_getaddrs
))
5893 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
5896 /* For UDP-style sockets, id specifies the association to query. */
5897 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
5901 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
5902 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
5904 list_for_each_entry(from
, &asoc
->peer
.transport_addr_list
,
5906 memcpy(&temp
, &from
->ipaddr
, sizeof(temp
));
5907 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
5908 ->addr_to_user(sp
, &temp
);
5909 if (space_left
< addrlen
)
5911 if (copy_to_user(to
, &temp
, addrlen
))
5915 space_left
-= addrlen
;
5918 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
))
5920 bytes_copied
= ((char __user
*)to
) - optval
;
5921 if (put_user(bytes_copied
, optlen
))
5927 static int sctp_copy_laddrs(struct sock
*sk
, __u16 port
, void *to
,
5928 size_t space_left
, int *bytes_copied
)
5930 struct sctp_sockaddr_entry
*addr
;
5931 union sctp_addr temp
;
5934 struct net
*net
= sock_net(sk
);
5937 list_for_each_entry_rcu(addr
, &net
->sctp
.local_addr_list
, list
) {
5941 if ((PF_INET
== sk
->sk_family
) &&
5942 (AF_INET6
== addr
->a
.sa
.sa_family
))
5944 if ((PF_INET6
== sk
->sk_family
) &&
5945 inet_v6_ipv6only(sk
) &&
5946 (AF_INET
== addr
->a
.sa
.sa_family
))
5948 memcpy(&temp
, &addr
->a
, sizeof(temp
));
5949 if (!temp
.v4
.sin_port
)
5950 temp
.v4
.sin_port
= htons(port
);
5952 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
5953 ->addr_to_user(sctp_sk(sk
), &temp
);
5955 if (space_left
< addrlen
) {
5959 memcpy(to
, &temp
, addrlen
);
5963 space_left
-= addrlen
;
5964 *bytes_copied
+= addrlen
;
5972 static int sctp_getsockopt_local_addrs(struct sock
*sk
, int len
,
5973 char __user
*optval
, int __user
*optlen
)
5975 struct sctp_bind_addr
*bp
;
5976 struct sctp_association
*asoc
;
5978 struct sctp_getaddrs getaddrs
;
5979 struct sctp_sockaddr_entry
*addr
;
5981 union sctp_addr temp
;
5982 struct sctp_sock
*sp
= sctp_sk(sk
);
5986 int bytes_copied
= 0;
5990 if (len
< sizeof(struct sctp_getaddrs
))
5993 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
5997 * For UDP-style sockets, id specifies the association to query.
5998 * If the id field is set to the value '0' then the locally bound
5999 * addresses are returned without regard to any particular
6002 if (0 == getaddrs
.assoc_id
) {
6003 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
6005 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
6008 bp
= &asoc
->base
.bind_addr
;
6011 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
6012 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
6014 addrs
= kmalloc(space_left
, GFP_USER
| __GFP_NOWARN
);
6018 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
6019 * addresses from the global local address list.
6021 if (sctp_list_single_entry(&bp
->address_list
)) {
6022 addr
= list_entry(bp
->address_list
.next
,
6023 struct sctp_sockaddr_entry
, list
);
6024 if (sctp_is_any(sk
, &addr
->a
)) {
6025 cnt
= sctp_copy_laddrs(sk
, bp
->port
, addrs
,
6026 space_left
, &bytes_copied
);
6036 /* Protection on the bound address list is not needed since
6037 * in the socket option context we hold a socket lock and
6038 * thus the bound address list can't change.
6040 list_for_each_entry(addr
, &bp
->address_list
, list
) {
6041 memcpy(&temp
, &addr
->a
, sizeof(temp
));
6042 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
6043 ->addr_to_user(sp
, &temp
);
6044 if (space_left
< addrlen
) {
6045 err
= -ENOMEM
; /*fixme: right error?*/
6048 memcpy(buf
, &temp
, addrlen
);
6050 bytes_copied
+= addrlen
;
6052 space_left
-= addrlen
;
6056 if (copy_to_user(to
, addrs
, bytes_copied
)) {
6060 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
)) {
6064 /* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
6065 * but we can't change it anymore.
6067 if (put_user(bytes_copied
, optlen
))
6074 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
6076 * Requests that the local SCTP stack use the enclosed peer address as
6077 * the association primary. The enclosed address must be one of the
6078 * association peer's addresses.
6080 static int sctp_getsockopt_primary_addr(struct sock
*sk
, int len
,
6081 char __user
*optval
, int __user
*optlen
)
6083 struct sctp_prim prim
;
6084 struct sctp_association
*asoc
;
6085 struct sctp_sock
*sp
= sctp_sk(sk
);
6087 if (len
< sizeof(struct sctp_prim
))
6090 len
= sizeof(struct sctp_prim
);
6092 if (copy_from_user(&prim
, optval
, len
))
6095 asoc
= sctp_id2assoc(sk
, prim
.ssp_assoc_id
);
6099 if (!asoc
->peer
.primary_path
)
6102 memcpy(&prim
.ssp_addr
, &asoc
->peer
.primary_path
->ipaddr
,
6103 asoc
->peer
.primary_path
->af_specific
->sockaddr_len
);
6105 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sp
,
6106 (union sctp_addr
*)&prim
.ssp_addr
);
6108 if (put_user(len
, optlen
))
6110 if (copy_to_user(optval
, &prim
, len
))
6117 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
6119 * Requests that the local endpoint set the specified Adaptation Layer
6120 * Indication parameter for all future INIT and INIT-ACK exchanges.
6122 static int sctp_getsockopt_adaptation_layer(struct sock
*sk
, int len
,
6123 char __user
*optval
, int __user
*optlen
)
6125 struct sctp_setadaptation adaptation
;
6127 if (len
< sizeof(struct sctp_setadaptation
))
6130 len
= sizeof(struct sctp_setadaptation
);
6132 adaptation
.ssb_adaptation_ind
= sctp_sk(sk
)->adaptation_ind
;
6134 if (put_user(len
, optlen
))
6136 if (copy_to_user(optval
, &adaptation
, len
))
6144 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
6146 * Applications that wish to use the sendto() system call may wish to
6147 * specify a default set of parameters that would normally be supplied
6148 * through the inclusion of ancillary data. This socket option allows
6149 * such an application to set the default sctp_sndrcvinfo structure.
6152 * The application that wishes to use this socket option simply passes
6153 * in to this call the sctp_sndrcvinfo structure defined in Section
6154 * 5.2.2) The input parameters accepted by this call include
6155 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
6156 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
6157 * to this call if the caller is using the UDP model.
6159 * For getsockopt, it get the default sctp_sndrcvinfo structure.
6161 static int sctp_getsockopt_default_send_param(struct sock
*sk
,
6162 int len
, char __user
*optval
,
6165 struct sctp_sock
*sp
= sctp_sk(sk
);
6166 struct sctp_association
*asoc
;
6167 struct sctp_sndrcvinfo info
;
6169 if (len
< sizeof(info
))
6174 if (copy_from_user(&info
, optval
, len
))
6177 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
6178 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
6181 info
.sinfo_stream
= asoc
->default_stream
;
6182 info
.sinfo_flags
= asoc
->default_flags
;
6183 info
.sinfo_ppid
= asoc
->default_ppid
;
6184 info
.sinfo_context
= asoc
->default_context
;
6185 info
.sinfo_timetolive
= asoc
->default_timetolive
;
6187 info
.sinfo_stream
= sp
->default_stream
;
6188 info
.sinfo_flags
= sp
->default_flags
;
6189 info
.sinfo_ppid
= sp
->default_ppid
;
6190 info
.sinfo_context
= sp
->default_context
;
6191 info
.sinfo_timetolive
= sp
->default_timetolive
;
6194 if (put_user(len
, optlen
))
6196 if (copy_to_user(optval
, &info
, len
))
6202 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
6203 * (SCTP_DEFAULT_SNDINFO)
6205 static int sctp_getsockopt_default_sndinfo(struct sock
*sk
, int len
,
6206 char __user
*optval
,
6209 struct sctp_sock
*sp
= sctp_sk(sk
);
6210 struct sctp_association
*asoc
;
6211 struct sctp_sndinfo info
;
6213 if (len
< sizeof(info
))
6218 if (copy_from_user(&info
, optval
, len
))
6221 asoc
= sctp_id2assoc(sk
, info
.snd_assoc_id
);
6222 if (!asoc
&& info
.snd_assoc_id
&& sctp_style(sk
, UDP
))
6225 info
.snd_sid
= asoc
->default_stream
;
6226 info
.snd_flags
= asoc
->default_flags
;
6227 info
.snd_ppid
= asoc
->default_ppid
;
6228 info
.snd_context
= asoc
->default_context
;
6230 info
.snd_sid
= sp
->default_stream
;
6231 info
.snd_flags
= sp
->default_flags
;
6232 info
.snd_ppid
= sp
->default_ppid
;
6233 info
.snd_context
= sp
->default_context
;
6236 if (put_user(len
, optlen
))
6238 if (copy_to_user(optval
, &info
, len
))
6246 * 7.1.5 SCTP_NODELAY
6248 * Turn on/off any Nagle-like algorithm. This means that packets are
6249 * generally sent as soon as possible and no unnecessary delays are
6250 * introduced, at the cost of more packets in the network. Expects an
6251 * integer boolean flag.
6254 static int sctp_getsockopt_nodelay(struct sock
*sk
, int len
,
6255 char __user
*optval
, int __user
*optlen
)
6259 if (len
< sizeof(int))
6263 val
= (sctp_sk(sk
)->nodelay
== 1);
6264 if (put_user(len
, optlen
))
6266 if (copy_to_user(optval
, &val
, len
))
6273 * 7.1.1 SCTP_RTOINFO
6275 * The protocol parameters used to initialize and bound retransmission
6276 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
6277 * and modify these parameters.
6278 * All parameters are time values, in milliseconds. A value of 0, when
6279 * modifying the parameters, indicates that the current value should not
6283 static int sctp_getsockopt_rtoinfo(struct sock
*sk
, int len
,
6284 char __user
*optval
,
6285 int __user
*optlen
) {
6286 struct sctp_rtoinfo rtoinfo
;
6287 struct sctp_association
*asoc
;
6289 if (len
< sizeof (struct sctp_rtoinfo
))
6292 len
= sizeof(struct sctp_rtoinfo
);
6294 if (copy_from_user(&rtoinfo
, optval
, len
))
6297 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
6299 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
6302 /* Values corresponding to the specific association. */
6304 rtoinfo
.srto_initial
= jiffies_to_msecs(asoc
->rto_initial
);
6305 rtoinfo
.srto_max
= jiffies_to_msecs(asoc
->rto_max
);
6306 rtoinfo
.srto_min
= jiffies_to_msecs(asoc
->rto_min
);
6308 /* Values corresponding to the endpoint. */
6309 struct sctp_sock
*sp
= sctp_sk(sk
);
6311 rtoinfo
.srto_initial
= sp
->rtoinfo
.srto_initial
;
6312 rtoinfo
.srto_max
= sp
->rtoinfo
.srto_max
;
6313 rtoinfo
.srto_min
= sp
->rtoinfo
.srto_min
;
6316 if (put_user(len
, optlen
))
6319 if (copy_to_user(optval
, &rtoinfo
, len
))
6327 * 7.1.2 SCTP_ASSOCINFO
6329 * This option is used to tune the maximum retransmission attempts
6330 * of the association.
6331 * Returns an error if the new association retransmission value is
6332 * greater than the sum of the retransmission value of the peer.
6333 * See [SCTP] for more information.
6336 static int sctp_getsockopt_associnfo(struct sock
*sk
, int len
,
6337 char __user
*optval
,
6341 struct sctp_assocparams assocparams
;
6342 struct sctp_association
*asoc
;
6343 struct list_head
*pos
;
6346 if (len
< sizeof (struct sctp_assocparams
))
6349 len
= sizeof(struct sctp_assocparams
);
6351 if (copy_from_user(&assocparams
, optval
, len
))
6354 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
6356 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
6359 /* Values correspoinding to the specific association */
6361 assocparams
.sasoc_asocmaxrxt
= asoc
->max_retrans
;
6362 assocparams
.sasoc_peer_rwnd
= asoc
->peer
.rwnd
;
6363 assocparams
.sasoc_local_rwnd
= asoc
->a_rwnd
;
6364 assocparams
.sasoc_cookie_life
= ktime_to_ms(asoc
->cookie_life
);
6366 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
6370 assocparams
.sasoc_number_peer_destinations
= cnt
;
6372 /* Values corresponding to the endpoint */
6373 struct sctp_sock
*sp
= sctp_sk(sk
);
6375 assocparams
.sasoc_asocmaxrxt
= sp
->assocparams
.sasoc_asocmaxrxt
;
6376 assocparams
.sasoc_peer_rwnd
= sp
->assocparams
.sasoc_peer_rwnd
;
6377 assocparams
.sasoc_local_rwnd
= sp
->assocparams
.sasoc_local_rwnd
;
6378 assocparams
.sasoc_cookie_life
=
6379 sp
->assocparams
.sasoc_cookie_life
;
6380 assocparams
.sasoc_number_peer_destinations
=
6382 sasoc_number_peer_destinations
;
6385 if (put_user(len
, optlen
))
6388 if (copy_to_user(optval
, &assocparams
, len
))
6395 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
6397 * This socket option is a boolean flag which turns on or off mapped V4
6398 * addresses. If this option is turned on and the socket is type
6399 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
6400 * If this option is turned off, then no mapping will be done of V4
6401 * addresses and a user will receive both PF_INET6 and PF_INET type
6402 * addresses on the socket.
6404 static int sctp_getsockopt_mappedv4(struct sock
*sk
, int len
,
6405 char __user
*optval
, int __user
*optlen
)
6408 struct sctp_sock
*sp
= sctp_sk(sk
);
6410 if (len
< sizeof(int))
6415 if (put_user(len
, optlen
))
6417 if (copy_to_user(optval
, &val
, len
))
6424 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
6425 * (chapter and verse is quoted at sctp_setsockopt_context())
6427 static int sctp_getsockopt_context(struct sock
*sk
, int len
,
6428 char __user
*optval
, int __user
*optlen
)
6430 struct sctp_assoc_value params
;
6431 struct sctp_sock
*sp
;
6432 struct sctp_association
*asoc
;
6434 if (len
< sizeof(struct sctp_assoc_value
))
6437 len
= sizeof(struct sctp_assoc_value
);
6439 if (copy_from_user(¶ms
, optval
, len
))
6444 if (params
.assoc_id
!= 0) {
6445 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6448 params
.assoc_value
= asoc
->default_rcv_context
;
6450 params
.assoc_value
= sp
->default_rcv_context
;
6453 if (put_user(len
, optlen
))
6455 if (copy_to_user(optval
, ¶ms
, len
))
6462 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6463 * This option will get or set the maximum size to put in any outgoing
6464 * SCTP DATA chunk. If a message is larger than this size it will be
6465 * fragmented by SCTP into the specified size. Note that the underlying
6466 * SCTP implementation may fragment into smaller sized chunks when the
6467 * PMTU of the underlying association is smaller than the value set by
6468 * the user. The default value for this option is '0' which indicates
6469 * the user is NOT limiting fragmentation and only the PMTU will effect
6470 * SCTP's choice of DATA chunk size. Note also that values set larger
6471 * than the maximum size of an IP datagram will effectively let SCTP
6472 * control fragmentation (i.e. the same as setting this option to 0).
6474 * The following structure is used to access and modify this parameter:
6476 * struct sctp_assoc_value {
6477 * sctp_assoc_t assoc_id;
6478 * uint32_t assoc_value;
6481 * assoc_id: This parameter is ignored for one-to-one style sockets.
6482 * For one-to-many style sockets this parameter indicates which
6483 * association the user is performing an action upon. Note that if
6484 * this field's value is zero then the endpoints default value is
6485 * changed (effecting future associations only).
6486 * assoc_value: This parameter specifies the maximum size in bytes.
6488 static int sctp_getsockopt_maxseg(struct sock
*sk
, int len
,
6489 char __user
*optval
, int __user
*optlen
)
6491 struct sctp_assoc_value params
;
6492 struct sctp_association
*asoc
;
6494 if (len
== sizeof(int)) {
6495 pr_warn_ratelimited(DEPRECATED
6497 "Use of int in maxseg socket option.\n"
6498 "Use struct sctp_assoc_value instead\n",
6499 current
->comm
, task_pid_nr(current
));
6500 params
.assoc_id
= 0;
6501 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6502 len
= sizeof(struct sctp_assoc_value
);
6503 if (copy_from_user(¶ms
, optval
, len
))
6508 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6509 if (!asoc
&& params
.assoc_id
&& sctp_style(sk
, UDP
))
6513 params
.assoc_value
= asoc
->frag_point
;
6515 params
.assoc_value
= sctp_sk(sk
)->user_frag
;
6517 if (put_user(len
, optlen
))
6519 if (len
== sizeof(int)) {
6520 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6523 if (copy_to_user(optval
, ¶ms
, len
))
6531 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6532 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6534 static int sctp_getsockopt_fragment_interleave(struct sock
*sk
, int len
,
6535 char __user
*optval
, int __user
*optlen
)
6539 if (len
< sizeof(int))
6544 val
= sctp_sk(sk
)->frag_interleave
;
6545 if (put_user(len
, optlen
))
6547 if (copy_to_user(optval
, &val
, len
))
6554 * 7.1.25. Set or Get the sctp partial delivery point
6555 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6557 static int sctp_getsockopt_partial_delivery_point(struct sock
*sk
, int len
,
6558 char __user
*optval
,
6563 if (len
< sizeof(u32
))
6568 val
= sctp_sk(sk
)->pd_point
;
6569 if (put_user(len
, optlen
))
6571 if (copy_to_user(optval
, &val
, len
))
6578 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
6579 * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6581 static int sctp_getsockopt_maxburst(struct sock
*sk
, int len
,
6582 char __user
*optval
,
6585 struct sctp_assoc_value params
;
6586 struct sctp_sock
*sp
;
6587 struct sctp_association
*asoc
;
6589 if (len
== sizeof(int)) {
6590 pr_warn_ratelimited(DEPRECATED
6592 "Use of int in max_burst socket option.\n"
6593 "Use struct sctp_assoc_value instead\n",
6594 current
->comm
, task_pid_nr(current
));
6595 params
.assoc_id
= 0;
6596 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6597 len
= sizeof(struct sctp_assoc_value
);
6598 if (copy_from_user(¶ms
, optval
, len
))
6605 if (params
.assoc_id
!= 0) {
6606 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6609 params
.assoc_value
= asoc
->max_burst
;
6611 params
.assoc_value
= sp
->max_burst
;
6613 if (len
== sizeof(int)) {
6614 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6617 if (copy_to_user(optval
, ¶ms
, len
))
6625 static int sctp_getsockopt_hmac_ident(struct sock
*sk
, int len
,
6626 char __user
*optval
, int __user
*optlen
)
6628 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6629 struct sctp_hmacalgo __user
*p
= (void __user
*)optval
;
6630 struct sctp_hmac_algo_param
*hmacs
;
6635 if (!ep
->auth_enable
)
6638 hmacs
= ep
->auth_hmacs_list
;
6639 data_len
= ntohs(hmacs
->param_hdr
.length
) -
6640 sizeof(struct sctp_paramhdr
);
6642 if (len
< sizeof(struct sctp_hmacalgo
) + data_len
)
6645 len
= sizeof(struct sctp_hmacalgo
) + data_len
;
6646 num_idents
= data_len
/ sizeof(u16
);
6648 if (put_user(len
, optlen
))
6650 if (put_user(num_idents
, &p
->shmac_num_idents
))
6652 for (i
= 0; i
< num_idents
; i
++) {
6653 __u16 hmacid
= ntohs(hmacs
->hmac_ids
[i
]);
6655 if (copy_to_user(&p
->shmac_idents
[i
], &hmacid
, sizeof(__u16
)))
6661 static int sctp_getsockopt_active_key(struct sock
*sk
, int len
,
6662 char __user
*optval
, int __user
*optlen
)
6664 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6665 struct sctp_authkeyid val
;
6666 struct sctp_association
*asoc
;
6668 if (!ep
->auth_enable
)
6671 if (len
< sizeof(struct sctp_authkeyid
))
6674 len
= sizeof(struct sctp_authkeyid
);
6675 if (copy_from_user(&val
, optval
, len
))
6678 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
6679 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
6683 val
.scact_keynumber
= asoc
->active_key_id
;
6685 val
.scact_keynumber
= ep
->active_key_id
;
6687 if (put_user(len
, optlen
))
6689 if (copy_to_user(optval
, &val
, len
))
6695 static int sctp_getsockopt_peer_auth_chunks(struct sock
*sk
, int len
,
6696 char __user
*optval
, int __user
*optlen
)
6698 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6699 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
6700 struct sctp_authchunks val
;
6701 struct sctp_association
*asoc
;
6702 struct sctp_chunks_param
*ch
;
6706 if (!ep
->auth_enable
)
6709 if (len
< sizeof(struct sctp_authchunks
))
6712 if (copy_from_user(&val
, optval
, sizeof(val
)))
6715 to
= p
->gauth_chunks
;
6716 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
6720 ch
= asoc
->peer
.peer_chunks
;
6724 /* See if the user provided enough room for all the data */
6725 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
6726 if (len
< num_chunks
)
6729 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
6732 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
6733 if (put_user(len
, optlen
))
6735 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
6740 static int sctp_getsockopt_local_auth_chunks(struct sock
*sk
, int len
,
6741 char __user
*optval
, int __user
*optlen
)
6743 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6744 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
6745 struct sctp_authchunks val
;
6746 struct sctp_association
*asoc
;
6747 struct sctp_chunks_param
*ch
;
6751 if (!ep
->auth_enable
)
6754 if (len
< sizeof(struct sctp_authchunks
))
6757 if (copy_from_user(&val
, optval
, sizeof(val
)))
6760 to
= p
->gauth_chunks
;
6761 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
6762 if (!asoc
&& val
.gauth_assoc_id
&& sctp_style(sk
, UDP
))
6766 ch
= (struct sctp_chunks_param
*)asoc
->c
.auth_chunks
;
6768 ch
= ep
->auth_chunk_list
;
6773 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
6774 if (len
< sizeof(struct sctp_authchunks
) + num_chunks
)
6777 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
6780 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
6781 if (put_user(len
, optlen
))
6783 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
6790 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
6791 * This option gets the current number of associations that are attached
6792 * to a one-to-many style socket. The option value is an uint32_t.
6794 static int sctp_getsockopt_assoc_number(struct sock
*sk
, int len
,
6795 char __user
*optval
, int __user
*optlen
)
6797 struct sctp_sock
*sp
= sctp_sk(sk
);
6798 struct sctp_association
*asoc
;
6801 if (sctp_style(sk
, TCP
))
6804 if (len
< sizeof(u32
))
6809 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6813 if (put_user(len
, optlen
))
6815 if (copy_to_user(optval
, &val
, len
))
6822 * 8.1.23 SCTP_AUTO_ASCONF
6823 * See the corresponding setsockopt entry as description
6825 static int sctp_getsockopt_auto_asconf(struct sock
*sk
, int len
,
6826 char __user
*optval
, int __user
*optlen
)
6830 if (len
< sizeof(int))
6834 if (sctp_sk(sk
)->do_auto_asconf
&& sctp_is_ep_boundall(sk
))
6836 if (put_user(len
, optlen
))
6838 if (copy_to_user(optval
, &val
, len
))
6844 * 8.2.6. Get the Current Identifiers of Associations
6845 * (SCTP_GET_ASSOC_ID_LIST)
6847 * This option gets the current list of SCTP association identifiers of
6848 * the SCTP associations handled by a one-to-many style socket.
6850 static int sctp_getsockopt_assoc_ids(struct sock
*sk
, int len
,
6851 char __user
*optval
, int __user
*optlen
)
6853 struct sctp_sock
*sp
= sctp_sk(sk
);
6854 struct sctp_association
*asoc
;
6855 struct sctp_assoc_ids
*ids
;
6858 if (sctp_style(sk
, TCP
))
6861 if (len
< sizeof(struct sctp_assoc_ids
))
6864 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6868 if (len
< sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
)
6871 len
= sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
;
6873 ids
= kmalloc(len
, GFP_USER
| __GFP_NOWARN
);
6877 ids
->gaids_number_of_ids
= num
;
6879 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
6880 ids
->gaids_assoc_id
[num
++] = asoc
->assoc_id
;
6883 if (put_user(len
, optlen
) || copy_to_user(optval
, ids
, len
)) {
6893 * SCTP_PEER_ADDR_THLDS
6895 * This option allows us to fetch the partially failed threshold for one or all
6896 * transports in an association. See Section 6.1 of:
6897 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
6899 static int sctp_getsockopt_paddr_thresholds(struct sock
*sk
,
6900 char __user
*optval
,
6904 struct sctp_paddrthlds val
;
6905 struct sctp_transport
*trans
;
6906 struct sctp_association
*asoc
;
6908 if (len
< sizeof(struct sctp_paddrthlds
))
6910 len
= sizeof(struct sctp_paddrthlds
);
6911 if (copy_from_user(&val
, (struct sctp_paddrthlds __user
*)optval
, len
))
6914 if (sctp_is_any(sk
, (const union sctp_addr
*)&val
.spt_address
)) {
6915 asoc
= sctp_id2assoc(sk
, val
.spt_assoc_id
);
6919 val
.spt_pathpfthld
= asoc
->pf_retrans
;
6920 val
.spt_pathmaxrxt
= asoc
->pathmaxrxt
;
6922 trans
= sctp_addr_id2transport(sk
, &val
.spt_address
,
6927 val
.spt_pathmaxrxt
= trans
->pathmaxrxt
;
6928 val
.spt_pathpfthld
= trans
->pf_retrans
;
6931 if (put_user(len
, optlen
) || copy_to_user(optval
, &val
, len
))
6938 * SCTP_GET_ASSOC_STATS
6940 * This option retrieves local per endpoint statistics. It is modeled
6941 * after OpenSolaris' implementation
6943 static int sctp_getsockopt_assoc_stats(struct sock
*sk
, int len
,
6944 char __user
*optval
,
6947 struct sctp_assoc_stats sas
;
6948 struct sctp_association
*asoc
= NULL
;
6950 /* User must provide at least the assoc id */
6951 if (len
< sizeof(sctp_assoc_t
))
6954 /* Allow the struct to grow and fill in as much as possible */
6955 len
= min_t(size_t, len
, sizeof(sas
));
6957 if (copy_from_user(&sas
, optval
, len
))
6960 asoc
= sctp_id2assoc(sk
, sas
.sas_assoc_id
);
6964 sas
.sas_rtxchunks
= asoc
->stats
.rtxchunks
;
6965 sas
.sas_gapcnt
= asoc
->stats
.gapcnt
;
6966 sas
.sas_outofseqtsns
= asoc
->stats
.outofseqtsns
;
6967 sas
.sas_osacks
= asoc
->stats
.osacks
;
6968 sas
.sas_isacks
= asoc
->stats
.isacks
;
6969 sas
.sas_octrlchunks
= asoc
->stats
.octrlchunks
;
6970 sas
.sas_ictrlchunks
= asoc
->stats
.ictrlchunks
;
6971 sas
.sas_oodchunks
= asoc
->stats
.oodchunks
;
6972 sas
.sas_iodchunks
= asoc
->stats
.iodchunks
;
6973 sas
.sas_ouodchunks
= asoc
->stats
.ouodchunks
;
6974 sas
.sas_iuodchunks
= asoc
->stats
.iuodchunks
;
6975 sas
.sas_idupchunks
= asoc
->stats
.idupchunks
;
6976 sas
.sas_opackets
= asoc
->stats
.opackets
;
6977 sas
.sas_ipackets
= asoc
->stats
.ipackets
;
6979 /* New high max rto observed, will return 0 if not a single
6980 * RTO update took place. obs_rto_ipaddr will be bogus
6983 sas
.sas_maxrto
= asoc
->stats
.max_obs_rto
;
6984 memcpy(&sas
.sas_obs_rto_ipaddr
, &asoc
->stats
.obs_rto_ipaddr
,
6985 sizeof(struct sockaddr_storage
));
6987 /* Mark beginning of a new observation period */
6988 asoc
->stats
.max_obs_rto
= asoc
->rto_min
;
6990 if (put_user(len
, optlen
))
6993 pr_debug("%s: len:%d, assoc_id:%d\n", __func__
, len
, sas
.sas_assoc_id
);
6995 if (copy_to_user(optval
, &sas
, len
))
7001 static int sctp_getsockopt_recvrcvinfo(struct sock
*sk
, int len
,
7002 char __user
*optval
,
7007 if (len
< sizeof(int))
7011 if (sctp_sk(sk
)->recvrcvinfo
)
7013 if (put_user(len
, optlen
))
7015 if (copy_to_user(optval
, &val
, len
))
7021 static int sctp_getsockopt_recvnxtinfo(struct sock
*sk
, int len
,
7022 char __user
*optval
,
7027 if (len
< sizeof(int))
7031 if (sctp_sk(sk
)->recvnxtinfo
)
7033 if (put_user(len
, optlen
))
7035 if (copy_to_user(optval
, &val
, len
))
7041 static int sctp_getsockopt_pr_supported(struct sock
*sk
, int len
,
7042 char __user
*optval
,
7045 struct sctp_assoc_value params
;
7046 struct sctp_association
*asoc
;
7047 int retval
= -EFAULT
;
7049 if (len
< sizeof(params
)) {
7054 len
= sizeof(params
);
7055 if (copy_from_user(¶ms
, optval
, len
))
7058 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7060 params
.assoc_value
= asoc
->prsctp_enable
;
7061 } else if (!params
.assoc_id
) {
7062 struct sctp_sock
*sp
= sctp_sk(sk
);
7064 params
.assoc_value
= sp
->ep
->prsctp_enable
;
7070 if (put_user(len
, optlen
))
7073 if (copy_to_user(optval
, ¶ms
, len
))
7082 static int sctp_getsockopt_default_prinfo(struct sock
*sk
, int len
,
7083 char __user
*optval
,
7086 struct sctp_default_prinfo info
;
7087 struct sctp_association
*asoc
;
7088 int retval
= -EFAULT
;
7090 if (len
< sizeof(info
)) {
7096 if (copy_from_user(&info
, optval
, len
))
7099 asoc
= sctp_id2assoc(sk
, info
.pr_assoc_id
);
7101 info
.pr_policy
= SCTP_PR_POLICY(asoc
->default_flags
);
7102 info
.pr_value
= asoc
->default_timetolive
;
7103 } else if (!info
.pr_assoc_id
) {
7104 struct sctp_sock
*sp
= sctp_sk(sk
);
7106 info
.pr_policy
= SCTP_PR_POLICY(sp
->default_flags
);
7107 info
.pr_value
= sp
->default_timetolive
;
7113 if (put_user(len
, optlen
))
7116 if (copy_to_user(optval
, &info
, len
))
7125 static int sctp_getsockopt_pr_assocstatus(struct sock
*sk
, int len
,
7126 char __user
*optval
,
7129 struct sctp_prstatus params
;
7130 struct sctp_association
*asoc
;
7132 int retval
= -EINVAL
;
7134 if (len
< sizeof(params
))
7137 len
= sizeof(params
);
7138 if (copy_from_user(¶ms
, optval
, len
)) {
7143 policy
= params
.sprstat_policy
;
7144 if (!policy
|| (policy
& ~(SCTP_PR_SCTP_MASK
| SCTP_PR_SCTP_ALL
)) ||
7145 ((policy
& SCTP_PR_SCTP_ALL
) && (policy
& SCTP_PR_SCTP_MASK
)))
7148 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
7152 if (policy
== SCTP_PR_SCTP_ALL
) {
7153 params
.sprstat_abandoned_unsent
= 0;
7154 params
.sprstat_abandoned_sent
= 0;
7155 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
7156 params
.sprstat_abandoned_unsent
+=
7157 asoc
->abandoned_unsent
[policy
];
7158 params
.sprstat_abandoned_sent
+=
7159 asoc
->abandoned_sent
[policy
];
7162 params
.sprstat_abandoned_unsent
=
7163 asoc
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
7164 params
.sprstat_abandoned_sent
=
7165 asoc
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
7168 if (put_user(len
, optlen
)) {
7173 if (copy_to_user(optval
, ¶ms
, len
)) {
7184 static int sctp_getsockopt_pr_streamstatus(struct sock
*sk
, int len
,
7185 char __user
*optval
,
7188 struct sctp_stream_out_ext
*streamoute
;
7189 struct sctp_association
*asoc
;
7190 struct sctp_prstatus params
;
7191 int retval
= -EINVAL
;
7194 if (len
< sizeof(params
))
7197 len
= sizeof(params
);
7198 if (copy_from_user(¶ms
, optval
, len
)) {
7203 policy
= params
.sprstat_policy
;
7204 if (!policy
|| (policy
& ~(SCTP_PR_SCTP_MASK
| SCTP_PR_SCTP_ALL
)) ||
7205 ((policy
& SCTP_PR_SCTP_ALL
) && (policy
& SCTP_PR_SCTP_MASK
)))
7208 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
7209 if (!asoc
|| params
.sprstat_sid
>= asoc
->stream
.outcnt
)
7212 streamoute
= SCTP_SO(&asoc
->stream
, params
.sprstat_sid
)->ext
;
7214 /* Not allocated yet, means all stats are 0 */
7215 params
.sprstat_abandoned_unsent
= 0;
7216 params
.sprstat_abandoned_sent
= 0;
7221 if (policy
== SCTP_PR_SCTP_ALL
) {
7222 params
.sprstat_abandoned_unsent
= 0;
7223 params
.sprstat_abandoned_sent
= 0;
7224 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
7225 params
.sprstat_abandoned_unsent
+=
7226 streamoute
->abandoned_unsent
[policy
];
7227 params
.sprstat_abandoned_sent
+=
7228 streamoute
->abandoned_sent
[policy
];
7231 params
.sprstat_abandoned_unsent
=
7232 streamoute
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
7233 params
.sprstat_abandoned_sent
=
7234 streamoute
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
7237 if (put_user(len
, optlen
) || copy_to_user(optval
, ¶ms
, len
)) {
7248 static int sctp_getsockopt_reconfig_supported(struct sock
*sk
, int len
,
7249 char __user
*optval
,
7252 struct sctp_assoc_value params
;
7253 struct sctp_association
*asoc
;
7254 int retval
= -EFAULT
;
7256 if (len
< sizeof(params
)) {
7261 len
= sizeof(params
);
7262 if (copy_from_user(¶ms
, optval
, len
))
7265 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7267 params
.assoc_value
= asoc
->reconf_enable
;
7268 } else if (!params
.assoc_id
) {
7269 struct sctp_sock
*sp
= sctp_sk(sk
);
7271 params
.assoc_value
= sp
->ep
->reconf_enable
;
7277 if (put_user(len
, optlen
))
7280 if (copy_to_user(optval
, ¶ms
, len
))
7289 static int sctp_getsockopt_enable_strreset(struct sock
*sk
, int len
,
7290 char __user
*optval
,
7293 struct sctp_assoc_value params
;
7294 struct sctp_association
*asoc
;
7295 int retval
= -EFAULT
;
7297 if (len
< sizeof(params
)) {
7302 len
= sizeof(params
);
7303 if (copy_from_user(¶ms
, optval
, len
))
7306 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7308 params
.assoc_value
= asoc
->strreset_enable
;
7309 } else if (!params
.assoc_id
) {
7310 struct sctp_sock
*sp
= sctp_sk(sk
);
7312 params
.assoc_value
= sp
->ep
->strreset_enable
;
7318 if (put_user(len
, optlen
))
7321 if (copy_to_user(optval
, ¶ms
, len
))
7330 static int sctp_getsockopt_scheduler(struct sock
*sk
, int len
,
7331 char __user
*optval
,
7334 struct sctp_assoc_value params
;
7335 struct sctp_association
*asoc
;
7336 int retval
= -EFAULT
;
7338 if (len
< sizeof(params
)) {
7343 len
= sizeof(params
);
7344 if (copy_from_user(¶ms
, optval
, len
))
7347 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7353 params
.assoc_value
= sctp_sched_get_sched(asoc
);
7355 if (put_user(len
, optlen
))
7358 if (copy_to_user(optval
, ¶ms
, len
))
7367 static int sctp_getsockopt_scheduler_value(struct sock
*sk
, int len
,
7368 char __user
*optval
,
7371 struct sctp_stream_value params
;
7372 struct sctp_association
*asoc
;
7373 int retval
= -EFAULT
;
7375 if (len
< sizeof(params
)) {
7380 len
= sizeof(params
);
7381 if (copy_from_user(¶ms
, optval
, len
))
7384 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7390 retval
= sctp_sched_get_value(asoc
, params
.stream_id
,
7391 ¶ms
.stream_value
);
7395 if (put_user(len
, optlen
)) {
7400 if (copy_to_user(optval
, ¶ms
, len
)) {
7409 static int sctp_getsockopt_interleaving_supported(struct sock
*sk
, int len
,
7410 char __user
*optval
,
7413 struct sctp_assoc_value params
;
7414 struct sctp_association
*asoc
;
7415 int retval
= -EFAULT
;
7417 if (len
< sizeof(params
)) {
7422 len
= sizeof(params
);
7423 if (copy_from_user(¶ms
, optval
, len
))
7426 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7428 params
.assoc_value
= asoc
->intl_enable
;
7429 } else if (!params
.assoc_id
) {
7430 struct sctp_sock
*sp
= sctp_sk(sk
);
7432 params
.assoc_value
= sp
->strm_interleave
;
7438 if (put_user(len
, optlen
))
7441 if (copy_to_user(optval
, ¶ms
, len
))
7450 static int sctp_getsockopt_reuse_port(struct sock
*sk
, int len
,
7451 char __user
*optval
,
7456 if (len
< sizeof(int))
7460 val
= sctp_sk(sk
)->reuse
;
7461 if (put_user(len
, optlen
))
7464 if (copy_to_user(optval
, &val
, len
))
7470 static int sctp_getsockopt_event(struct sock
*sk
, int len
, char __user
*optval
,
7473 struct sctp_association
*asoc
;
7474 struct sctp_event param
;
7477 if (len
< sizeof(param
))
7480 len
= sizeof(param
);
7481 if (copy_from_user(¶m
, optval
, len
))
7484 if (param
.se_type
< SCTP_SN_TYPE_BASE
||
7485 param
.se_type
> SCTP_SN_TYPE_MAX
)
7488 asoc
= sctp_id2assoc(sk
, param
.se_assoc_id
);
7489 subscribe
= asoc
? asoc
->subscribe
: sctp_sk(sk
)->subscribe
;
7490 param
.se_on
= sctp_ulpevent_type_enabled(subscribe
, param
.se_type
);
7492 if (put_user(len
, optlen
))
7495 if (copy_to_user(optval
, ¶m
, len
))
7501 static int sctp_getsockopt(struct sock
*sk
, int level
, int optname
,
7502 char __user
*optval
, int __user
*optlen
)
7507 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
7509 /* I can hardly begin to describe how wrong this is. This is
7510 * so broken as to be worse than useless. The API draft
7511 * REALLY is NOT helpful here... I am not convinced that the
7512 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
7513 * are at all well-founded.
7515 if (level
!= SOL_SCTP
) {
7516 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
7518 retval
= af
->getsockopt(sk
, level
, optname
, optval
, optlen
);
7522 if (get_user(len
, optlen
))
7532 retval
= sctp_getsockopt_sctp_status(sk
, len
, optval
, optlen
);
7534 case SCTP_DISABLE_FRAGMENTS
:
7535 retval
= sctp_getsockopt_disable_fragments(sk
, len
, optval
,
7539 retval
= sctp_getsockopt_events(sk
, len
, optval
, optlen
);
7541 case SCTP_AUTOCLOSE
:
7542 retval
= sctp_getsockopt_autoclose(sk
, len
, optval
, optlen
);
7544 case SCTP_SOCKOPT_PEELOFF
:
7545 retval
= sctp_getsockopt_peeloff(sk
, len
, optval
, optlen
);
7547 case SCTP_SOCKOPT_PEELOFF_FLAGS
:
7548 retval
= sctp_getsockopt_peeloff_flags(sk
, len
, optval
, optlen
);
7550 case SCTP_PEER_ADDR_PARAMS
:
7551 retval
= sctp_getsockopt_peer_addr_params(sk
, len
, optval
,
7554 case SCTP_DELAYED_SACK
:
7555 retval
= sctp_getsockopt_delayed_ack(sk
, len
, optval
,
7559 retval
= sctp_getsockopt_initmsg(sk
, len
, optval
, optlen
);
7561 case SCTP_GET_PEER_ADDRS
:
7562 retval
= sctp_getsockopt_peer_addrs(sk
, len
, optval
,
7565 case SCTP_GET_LOCAL_ADDRS
:
7566 retval
= sctp_getsockopt_local_addrs(sk
, len
, optval
,
7569 case SCTP_SOCKOPT_CONNECTX3
:
7570 retval
= sctp_getsockopt_connectx3(sk
, len
, optval
, optlen
);
7572 case SCTP_DEFAULT_SEND_PARAM
:
7573 retval
= sctp_getsockopt_default_send_param(sk
, len
,
7576 case SCTP_DEFAULT_SNDINFO
:
7577 retval
= sctp_getsockopt_default_sndinfo(sk
, len
,
7580 case SCTP_PRIMARY_ADDR
:
7581 retval
= sctp_getsockopt_primary_addr(sk
, len
, optval
, optlen
);
7584 retval
= sctp_getsockopt_nodelay(sk
, len
, optval
, optlen
);
7587 retval
= sctp_getsockopt_rtoinfo(sk
, len
, optval
, optlen
);
7589 case SCTP_ASSOCINFO
:
7590 retval
= sctp_getsockopt_associnfo(sk
, len
, optval
, optlen
);
7592 case SCTP_I_WANT_MAPPED_V4_ADDR
:
7593 retval
= sctp_getsockopt_mappedv4(sk
, len
, optval
, optlen
);
7596 retval
= sctp_getsockopt_maxseg(sk
, len
, optval
, optlen
);
7598 case SCTP_GET_PEER_ADDR_INFO
:
7599 retval
= sctp_getsockopt_peer_addr_info(sk
, len
, optval
,
7602 case SCTP_ADAPTATION_LAYER
:
7603 retval
= sctp_getsockopt_adaptation_layer(sk
, len
, optval
,
7607 retval
= sctp_getsockopt_context(sk
, len
, optval
, optlen
);
7609 case SCTP_FRAGMENT_INTERLEAVE
:
7610 retval
= sctp_getsockopt_fragment_interleave(sk
, len
, optval
,
7613 case SCTP_PARTIAL_DELIVERY_POINT
:
7614 retval
= sctp_getsockopt_partial_delivery_point(sk
, len
, optval
,
7617 case SCTP_MAX_BURST
:
7618 retval
= sctp_getsockopt_maxburst(sk
, len
, optval
, optlen
);
7621 case SCTP_AUTH_CHUNK
:
7622 case SCTP_AUTH_DELETE_KEY
:
7623 case SCTP_AUTH_DEACTIVATE_KEY
:
7624 retval
= -EOPNOTSUPP
;
7626 case SCTP_HMAC_IDENT
:
7627 retval
= sctp_getsockopt_hmac_ident(sk
, len
, optval
, optlen
);
7629 case SCTP_AUTH_ACTIVE_KEY
:
7630 retval
= sctp_getsockopt_active_key(sk
, len
, optval
, optlen
);
7632 case SCTP_PEER_AUTH_CHUNKS
:
7633 retval
= sctp_getsockopt_peer_auth_chunks(sk
, len
, optval
,
7636 case SCTP_LOCAL_AUTH_CHUNKS
:
7637 retval
= sctp_getsockopt_local_auth_chunks(sk
, len
, optval
,
7640 case SCTP_GET_ASSOC_NUMBER
:
7641 retval
= sctp_getsockopt_assoc_number(sk
, len
, optval
, optlen
);
7643 case SCTP_GET_ASSOC_ID_LIST
:
7644 retval
= sctp_getsockopt_assoc_ids(sk
, len
, optval
, optlen
);
7646 case SCTP_AUTO_ASCONF
:
7647 retval
= sctp_getsockopt_auto_asconf(sk
, len
, optval
, optlen
);
7649 case SCTP_PEER_ADDR_THLDS
:
7650 retval
= sctp_getsockopt_paddr_thresholds(sk
, optval
, len
, optlen
);
7652 case SCTP_GET_ASSOC_STATS
:
7653 retval
= sctp_getsockopt_assoc_stats(sk
, len
, optval
, optlen
);
7655 case SCTP_RECVRCVINFO
:
7656 retval
= sctp_getsockopt_recvrcvinfo(sk
, len
, optval
, optlen
);
7658 case SCTP_RECVNXTINFO
:
7659 retval
= sctp_getsockopt_recvnxtinfo(sk
, len
, optval
, optlen
);
7661 case SCTP_PR_SUPPORTED
:
7662 retval
= sctp_getsockopt_pr_supported(sk
, len
, optval
, optlen
);
7664 case SCTP_DEFAULT_PRINFO
:
7665 retval
= sctp_getsockopt_default_prinfo(sk
, len
, optval
,
7668 case SCTP_PR_ASSOC_STATUS
:
7669 retval
= sctp_getsockopt_pr_assocstatus(sk
, len
, optval
,
7672 case SCTP_PR_STREAM_STATUS
:
7673 retval
= sctp_getsockopt_pr_streamstatus(sk
, len
, optval
,
7676 case SCTP_RECONFIG_SUPPORTED
:
7677 retval
= sctp_getsockopt_reconfig_supported(sk
, len
, optval
,
7680 case SCTP_ENABLE_STREAM_RESET
:
7681 retval
= sctp_getsockopt_enable_strreset(sk
, len
, optval
,
7684 case SCTP_STREAM_SCHEDULER
:
7685 retval
= sctp_getsockopt_scheduler(sk
, len
, optval
,
7688 case SCTP_STREAM_SCHEDULER_VALUE
:
7689 retval
= sctp_getsockopt_scheduler_value(sk
, len
, optval
,
7692 case SCTP_INTERLEAVING_SUPPORTED
:
7693 retval
= sctp_getsockopt_interleaving_supported(sk
, len
, optval
,
7696 case SCTP_REUSE_PORT
:
7697 retval
= sctp_getsockopt_reuse_port(sk
, len
, optval
, optlen
);
7700 retval
= sctp_getsockopt_event(sk
, len
, optval
, optlen
);
7703 retval
= -ENOPROTOOPT
;
7711 static int sctp_hash(struct sock
*sk
)
7717 static void sctp_unhash(struct sock
*sk
)
7722 /* Check if port is acceptable. Possibly find first available port.
7724 * The port hash table (contained in the 'global' SCTP protocol storage
7725 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
7726 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
7727 * list (the list number is the port number hashed out, so as you
7728 * would expect from a hash function, all the ports in a given list have
7729 * such a number that hashes out to the same list number; you were
7730 * expecting that, right?); so each list has a set of ports, with a
7731 * link to the socket (struct sock) that uses it, the port number and
7732 * a fastreuse flag (FIXME: NPI ipg).
7734 static struct sctp_bind_bucket
*sctp_bucket_create(
7735 struct sctp_bind_hashbucket
*head
, struct net
*, unsigned short snum
);
7737 static long sctp_get_port_local(struct sock
*sk
, union sctp_addr
*addr
)
7739 struct sctp_sock
*sp
= sctp_sk(sk
);
7740 bool reuse
= (sk
->sk_reuse
|| sp
->reuse
);
7741 struct sctp_bind_hashbucket
*head
; /* hash list */
7742 kuid_t uid
= sock_i_uid(sk
);
7743 struct sctp_bind_bucket
*pp
;
7744 unsigned short snum
;
7747 snum
= ntohs(addr
->v4
.sin_port
);
7749 pr_debug("%s: begins, snum:%d\n", __func__
, snum
);
7754 /* Search for an available port. */
7755 int low
, high
, remaining
, index
;
7757 struct net
*net
= sock_net(sk
);
7759 inet_get_local_port_range(net
, &low
, &high
);
7760 remaining
= (high
- low
) + 1;
7761 rover
= prandom_u32() % remaining
+ low
;
7765 if ((rover
< low
) || (rover
> high
))
7767 if (inet_is_local_reserved_port(net
, rover
))
7769 index
= sctp_phashfn(sock_net(sk
), rover
);
7770 head
= &sctp_port_hashtable
[index
];
7771 spin_lock(&head
->lock
);
7772 sctp_for_each_hentry(pp
, &head
->chain
)
7773 if ((pp
->port
== rover
) &&
7774 net_eq(sock_net(sk
), pp
->net
))
7778 spin_unlock(&head
->lock
);
7779 } while (--remaining
> 0);
7781 /* Exhausted local port range during search? */
7786 /* OK, here is the one we will use. HEAD (the port
7787 * hash table list entry) is non-NULL and we hold it's
7792 /* We are given an specific port number; we verify
7793 * that it is not being used. If it is used, we will
7794 * exahust the search in the hash list corresponding
7795 * to the port number (snum) - we detect that with the
7796 * port iterator, pp being NULL.
7798 head
= &sctp_port_hashtable
[sctp_phashfn(sock_net(sk
), snum
)];
7799 spin_lock(&head
->lock
);
7800 sctp_for_each_hentry(pp
, &head
->chain
) {
7801 if ((pp
->port
== snum
) && net_eq(pp
->net
, sock_net(sk
)))
7808 if (!hlist_empty(&pp
->owner
)) {
7809 /* We had a port hash table hit - there is an
7810 * available port (pp != NULL) and it is being
7811 * used by other socket (pp->owner not empty); that other
7812 * socket is going to be sk2.
7816 pr_debug("%s: found a possible match\n", __func__
);
7818 if ((pp
->fastreuse
&& reuse
&&
7819 sk
->sk_state
!= SCTP_SS_LISTENING
) ||
7820 (pp
->fastreuseport
&& sk
->sk_reuseport
&&
7821 uid_eq(pp
->fastuid
, uid
)))
7824 /* Run through the list of sockets bound to the port
7825 * (pp->port) [via the pointers bind_next and
7826 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
7827 * we get the endpoint they describe and run through
7828 * the endpoint's list of IP (v4 or v6) addresses,
7829 * comparing each of the addresses with the address of
7830 * the socket sk. If we find a match, then that means
7831 * that this port/socket (sk) combination are already
7834 sk_for_each_bound(sk2
, &pp
->owner
) {
7835 struct sctp_sock
*sp2
= sctp_sk(sk2
);
7836 struct sctp_endpoint
*ep2
= sp2
->ep
;
7839 (reuse
&& (sk2
->sk_reuse
|| sp2
->reuse
) &&
7840 sk2
->sk_state
!= SCTP_SS_LISTENING
) ||
7841 (sk
->sk_reuseport
&& sk2
->sk_reuseport
&&
7842 uid_eq(uid
, sock_i_uid(sk2
))))
7845 if (sctp_bind_addr_conflict(&ep2
->base
.bind_addr
,
7852 pr_debug("%s: found a match\n", __func__
);
7855 /* If there was a hash table miss, create a new port. */
7857 if (!pp
&& !(pp
= sctp_bucket_create(head
, sock_net(sk
), snum
)))
7860 /* In either case (hit or miss), make sure fastreuse is 1 only
7861 * if sk->sk_reuse is too (that is, if the caller requested
7862 * SO_REUSEADDR on this socket -sk-).
7864 if (hlist_empty(&pp
->owner
)) {
7865 if (reuse
&& sk
->sk_state
!= SCTP_SS_LISTENING
)
7870 if (sk
->sk_reuseport
) {
7871 pp
->fastreuseport
= 1;
7874 pp
->fastreuseport
= 0;
7877 if (pp
->fastreuse
&&
7878 (!reuse
|| sk
->sk_state
== SCTP_SS_LISTENING
))
7881 if (pp
->fastreuseport
&&
7882 (!sk
->sk_reuseport
|| !uid_eq(pp
->fastuid
, uid
)))
7883 pp
->fastreuseport
= 0;
7886 /* We are set, so fill up all the data in the hash table
7887 * entry, tie the socket list information with the rest of the
7888 * sockets FIXME: Blurry, NPI (ipg).
7891 if (!sp
->bind_hash
) {
7892 inet_sk(sk
)->inet_num
= snum
;
7893 sk_add_bind_node(sk
, &pp
->owner
);
7899 spin_unlock(&head
->lock
);
7906 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
7907 * port is requested.
7909 static int sctp_get_port(struct sock
*sk
, unsigned short snum
)
7911 union sctp_addr addr
;
7912 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
7914 /* Set up a dummy address struct from the sk. */
7915 af
->from_sk(&addr
, sk
);
7916 addr
.v4
.sin_port
= htons(snum
);
7918 /* Note: sk->sk_num gets filled in if ephemeral port request. */
7919 return !!sctp_get_port_local(sk
, &addr
);
7923 * Move a socket to LISTENING state.
7925 static int sctp_listen_start(struct sock
*sk
, int backlog
)
7927 struct sctp_sock
*sp
= sctp_sk(sk
);
7928 struct sctp_endpoint
*ep
= sp
->ep
;
7929 struct crypto_shash
*tfm
= NULL
;
7932 /* Allocate HMAC for generating cookie. */
7933 if (!sp
->hmac
&& sp
->sctp_hmac_alg
) {
7934 sprintf(alg
, "hmac(%s)", sp
->sctp_hmac_alg
);
7935 tfm
= crypto_alloc_shash(alg
, 0, 0);
7937 net_info_ratelimited("failed to load transform for %s: %ld\n",
7938 sp
->sctp_hmac_alg
, PTR_ERR(tfm
));
7941 sctp_sk(sk
)->hmac
= tfm
;
7945 * If a bind() or sctp_bindx() is not called prior to a listen()
7946 * call that allows new associations to be accepted, the system
7947 * picks an ephemeral port and will choose an address set equivalent
7948 * to binding with a wildcard address.
7950 * This is not currently spelled out in the SCTP sockets
7951 * extensions draft, but follows the practice as seen in TCP
7955 inet_sk_set_state(sk
, SCTP_SS_LISTENING
);
7956 if (!ep
->base
.bind_addr
.port
) {
7957 if (sctp_autobind(sk
))
7960 if (sctp_get_port(sk
, inet_sk(sk
)->inet_num
)) {
7961 inet_sk_set_state(sk
, SCTP_SS_CLOSED
);
7966 sk
->sk_max_ack_backlog
= backlog
;
7967 return sctp_hash_endpoint(ep
);
7971 * 4.1.3 / 5.1.3 listen()
7973 * By default, new associations are not accepted for UDP style sockets.
7974 * An application uses listen() to mark a socket as being able to
7975 * accept new associations.
7977 * On TCP style sockets, applications use listen() to ready the SCTP
7978 * endpoint for accepting inbound associations.
7980 * On both types of endpoints a backlog of '0' disables listening.
7982 * Move a socket to LISTENING state.
7984 int sctp_inet_listen(struct socket
*sock
, int backlog
)
7986 struct sock
*sk
= sock
->sk
;
7987 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
7990 if (unlikely(backlog
< 0))
7995 /* Peeled-off sockets are not allowed to listen(). */
7996 if (sctp_style(sk
, UDP_HIGH_BANDWIDTH
))
7999 if (sock
->state
!= SS_UNCONNECTED
)
8002 if (!sctp_sstate(sk
, LISTENING
) && !sctp_sstate(sk
, CLOSED
))
8005 /* If backlog is zero, disable listening. */
8007 if (sctp_sstate(sk
, CLOSED
))
8011 sctp_unhash_endpoint(ep
);
8012 sk
->sk_state
= SCTP_SS_CLOSED
;
8013 if (sk
->sk_reuse
|| sctp_sk(sk
)->reuse
)
8014 sctp_sk(sk
)->bind_hash
->fastreuse
= 1;
8018 /* If we are already listening, just update the backlog */
8019 if (sctp_sstate(sk
, LISTENING
))
8020 sk
->sk_max_ack_backlog
= backlog
;
8022 err
= sctp_listen_start(sk
, backlog
);
8034 * This function is done by modeling the current datagram_poll() and the
8035 * tcp_poll(). Note that, based on these implementations, we don't
8036 * lock the socket in this function, even though it seems that,
8037 * ideally, locking or some other mechanisms can be used to ensure
8038 * the integrity of the counters (sndbuf and wmem_alloc) used
8039 * in this place. We assume that we don't need locks either until proven
8042 * Another thing to note is that we include the Async I/O support
8043 * here, again, by modeling the current TCP/UDP code. We don't have
8044 * a good way to test with it yet.
8046 __poll_t
sctp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
8048 struct sock
*sk
= sock
->sk
;
8049 struct sctp_sock
*sp
= sctp_sk(sk
);
8052 poll_wait(file
, sk_sleep(sk
), wait
);
8054 sock_rps_record_flow(sk
);
8056 /* A TCP-style listening socket becomes readable when the accept queue
8059 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
8060 return (!list_empty(&sp
->ep
->asocs
)) ?
8061 (EPOLLIN
| EPOLLRDNORM
) : 0;
8065 /* Is there any exceptional events? */
8066 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
8068 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? EPOLLPRI
: 0);
8069 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8070 mask
|= EPOLLRDHUP
| EPOLLIN
| EPOLLRDNORM
;
8071 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
8074 /* Is it readable? Reconsider this code with TCP-style support. */
8075 if (!skb_queue_empty(&sk
->sk_receive_queue
))
8076 mask
|= EPOLLIN
| EPOLLRDNORM
;
8078 /* The association is either gone or not ready. */
8079 if (!sctp_style(sk
, UDP
) && sctp_sstate(sk
, CLOSED
))
8082 /* Is it writable? */
8083 if (sctp_writeable(sk
)) {
8084 mask
|= EPOLLOUT
| EPOLLWRNORM
;
8086 sk_set_bit(SOCKWQ_ASYNC_NOSPACE
, sk
);
8088 * Since the socket is not locked, the buffer
8089 * might be made available after the writeable check and
8090 * before the bit is set. This could cause a lost I/O
8091 * signal. tcp_poll() has a race breaker for this race
8092 * condition. Based on their implementation, we put
8093 * in the following code to cover it as well.
8095 if (sctp_writeable(sk
))
8096 mask
|= EPOLLOUT
| EPOLLWRNORM
;
8101 /********************************************************************
8102 * 2nd Level Abstractions
8103 ********************************************************************/
8105 static struct sctp_bind_bucket
*sctp_bucket_create(
8106 struct sctp_bind_hashbucket
*head
, struct net
*net
, unsigned short snum
)
8108 struct sctp_bind_bucket
*pp
;
8110 pp
= kmem_cache_alloc(sctp_bucket_cachep
, GFP_ATOMIC
);
8112 SCTP_DBG_OBJCNT_INC(bind_bucket
);
8115 INIT_HLIST_HEAD(&pp
->owner
);
8117 hlist_add_head(&pp
->node
, &head
->chain
);
8122 /* Caller must hold hashbucket lock for this tb with local BH disabled */
8123 static void sctp_bucket_destroy(struct sctp_bind_bucket
*pp
)
8125 if (pp
&& hlist_empty(&pp
->owner
)) {
8126 __hlist_del(&pp
->node
);
8127 kmem_cache_free(sctp_bucket_cachep
, pp
);
8128 SCTP_DBG_OBJCNT_DEC(bind_bucket
);
8132 /* Release this socket's reference to a local port. */
8133 static inline void __sctp_put_port(struct sock
*sk
)
8135 struct sctp_bind_hashbucket
*head
=
8136 &sctp_port_hashtable
[sctp_phashfn(sock_net(sk
),
8137 inet_sk(sk
)->inet_num
)];
8138 struct sctp_bind_bucket
*pp
;
8140 spin_lock(&head
->lock
);
8141 pp
= sctp_sk(sk
)->bind_hash
;
8142 __sk_del_bind_node(sk
);
8143 sctp_sk(sk
)->bind_hash
= NULL
;
8144 inet_sk(sk
)->inet_num
= 0;
8145 sctp_bucket_destroy(pp
);
8146 spin_unlock(&head
->lock
);
8149 void sctp_put_port(struct sock
*sk
)
8152 __sctp_put_port(sk
);
8157 * The system picks an ephemeral port and choose an address set equivalent
8158 * to binding with a wildcard address.
8159 * One of those addresses will be the primary address for the association.
8160 * This automatically enables the multihoming capability of SCTP.
8162 static int sctp_autobind(struct sock
*sk
)
8164 union sctp_addr autoaddr
;
8168 /* Initialize a local sockaddr structure to INADDR_ANY. */
8169 af
= sctp_sk(sk
)->pf
->af
;
8171 port
= htons(inet_sk(sk
)->inet_num
);
8172 af
->inaddr_any(&autoaddr
, port
);
8174 return sctp_do_bind(sk
, &autoaddr
, af
->sockaddr_len
);
8177 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
8180 * 4.2 The cmsghdr Structure *
8182 * When ancillary data is sent or received, any number of ancillary data
8183 * objects can be specified by the msg_control and msg_controllen members of
8184 * the msghdr structure, because each object is preceded by
8185 * a cmsghdr structure defining the object's length (the cmsg_len member).
8186 * Historically Berkeley-derived implementations have passed only one object
8187 * at a time, but this API allows multiple objects to be
8188 * passed in a single call to sendmsg() or recvmsg(). The following example
8189 * shows two ancillary data objects in a control buffer.
8191 * |<--------------------------- msg_controllen -------------------------->|
8194 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
8196 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8199 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
8201 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
8204 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8205 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
8207 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
8209 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8216 static int sctp_msghdr_parse(const struct msghdr
*msg
, struct sctp_cmsgs
*cmsgs
)
8218 struct msghdr
*my_msg
= (struct msghdr
*)msg
;
8219 struct cmsghdr
*cmsg
;
8221 for_each_cmsghdr(cmsg
, my_msg
) {
8222 if (!CMSG_OK(my_msg
, cmsg
))
8225 /* Should we parse this header or ignore? */
8226 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
)
8229 /* Strictly check lengths following example in SCM code. */
8230 switch (cmsg
->cmsg_type
) {
8232 /* SCTP Socket API Extension
8233 * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
8235 * This cmsghdr structure provides information for
8236 * initializing new SCTP associations with sendmsg().
8237 * The SCTP_INITMSG socket option uses this same data
8238 * structure. This structure is not used for
8241 * cmsg_level cmsg_type cmsg_data[]
8242 * ------------ ------------ ----------------------
8243 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
8245 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_initmsg
)))
8248 cmsgs
->init
= CMSG_DATA(cmsg
);
8252 /* SCTP Socket API Extension
8253 * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
8255 * This cmsghdr structure specifies SCTP options for
8256 * sendmsg() and describes SCTP header information
8257 * about a received message through recvmsg().
8259 * cmsg_level cmsg_type cmsg_data[]
8260 * ------------ ------------ ----------------------
8261 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
8263 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndrcvinfo
)))
8266 cmsgs
->srinfo
= CMSG_DATA(cmsg
);
8268 if (cmsgs
->srinfo
->sinfo_flags
&
8269 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
8270 SCTP_SACK_IMMEDIATELY
| SCTP_SENDALL
|
8271 SCTP_PR_SCTP_MASK
| SCTP_ABORT
| SCTP_EOF
))
8276 /* SCTP Socket API Extension
8277 * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
8279 * This cmsghdr structure specifies SCTP options for
8280 * sendmsg(). This structure and SCTP_RCVINFO replaces
8281 * SCTP_SNDRCV which has been deprecated.
8283 * cmsg_level cmsg_type cmsg_data[]
8284 * ------------ ------------ ---------------------
8285 * IPPROTO_SCTP SCTP_SNDINFO struct sctp_sndinfo
8287 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndinfo
)))
8290 cmsgs
->sinfo
= CMSG_DATA(cmsg
);
8292 if (cmsgs
->sinfo
->snd_flags
&
8293 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
8294 SCTP_SACK_IMMEDIATELY
| SCTP_SENDALL
|
8295 SCTP_PR_SCTP_MASK
| SCTP_ABORT
| SCTP_EOF
))
8299 /* SCTP Socket API Extension
8300 * 5.3.7 SCTP PR-SCTP Information Structure (SCTP_PRINFO)
8302 * This cmsghdr structure specifies SCTP options for sendmsg().
8304 * cmsg_level cmsg_type cmsg_data[]
8305 * ------------ ------------ ---------------------
8306 * IPPROTO_SCTP SCTP_PRINFO struct sctp_prinfo
8308 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_prinfo
)))
8311 cmsgs
->prinfo
= CMSG_DATA(cmsg
);
8312 if (cmsgs
->prinfo
->pr_policy
& ~SCTP_PR_SCTP_MASK
)
8315 if (cmsgs
->prinfo
->pr_policy
== SCTP_PR_SCTP_NONE
)
8316 cmsgs
->prinfo
->pr_value
= 0;
8319 /* SCTP Socket API Extension
8320 * 5.3.8 SCTP AUTH Information Structure (SCTP_AUTHINFO)
8322 * This cmsghdr structure specifies SCTP options for sendmsg().
8324 * cmsg_level cmsg_type cmsg_data[]
8325 * ------------ ------------ ---------------------
8326 * IPPROTO_SCTP SCTP_AUTHINFO struct sctp_authinfo
8328 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_authinfo
)))
8331 cmsgs
->authinfo
= CMSG_DATA(cmsg
);
8333 case SCTP_DSTADDRV4
:
8334 case SCTP_DSTADDRV6
:
8335 /* SCTP Socket API Extension
8336 * 5.3.9/10 SCTP Destination IPv4/6 Address Structure (SCTP_DSTADDRV4/6)
8338 * This cmsghdr structure specifies SCTP options for sendmsg().
8340 * cmsg_level cmsg_type cmsg_data[]
8341 * ------------ ------------ ---------------------
8342 * IPPROTO_SCTP SCTP_DSTADDRV4 struct in_addr
8343 * ------------ ------------ ---------------------
8344 * IPPROTO_SCTP SCTP_DSTADDRV6 struct in6_addr
8346 cmsgs
->addrs_msg
= my_msg
;
8357 * Wait for a packet..
8358 * Note: This function is the same function as in core/datagram.c
8359 * with a few modifications to make lksctp work.
8361 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
)
8366 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
8368 /* Socket errors? */
8369 error
= sock_error(sk
);
8373 if (!skb_queue_empty(&sk
->sk_receive_queue
))
8376 /* Socket shut down? */
8377 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8380 /* Sequenced packets can come disconnected. If so we report the
8385 /* Is there a good reason to think that we may receive some data? */
8386 if (list_empty(&sctp_sk(sk
)->ep
->asocs
) && !sctp_sstate(sk
, LISTENING
))
8389 /* Handle signals. */
8390 if (signal_pending(current
))
8393 /* Let another process have a go. Since we are going to sleep
8394 * anyway. Note: This may cause odd behaviors if the message
8395 * does not fit in the user's buffer, but this seems to be the
8396 * only way to honor MSG_DONTWAIT realistically.
8399 *timeo_p
= schedule_timeout(*timeo_p
);
8403 finish_wait(sk_sleep(sk
), &wait
);
8407 error
= sock_intr_errno(*timeo_p
);
8410 finish_wait(sk_sleep(sk
), &wait
);
8415 /* Receive a datagram.
8416 * Note: This is pretty much the same routine as in core/datagram.c
8417 * with a few changes to make lksctp work.
8419 struct sk_buff
*sctp_skb_recv_datagram(struct sock
*sk
, int flags
,
8420 int noblock
, int *err
)
8423 struct sk_buff
*skb
;
8426 timeo
= sock_rcvtimeo(sk
, noblock
);
8428 pr_debug("%s: timeo:%ld, max:%ld\n", __func__
, timeo
,
8429 MAX_SCHEDULE_TIMEOUT
);
8432 /* Again only user level code calls this function,
8433 * so nothing interrupt level
8434 * will suddenly eat the receive_queue.
8436 * Look at current nfs client by the way...
8437 * However, this function was correct in any case. 8)
8439 if (flags
& MSG_PEEK
) {
8440 skb
= skb_peek(&sk
->sk_receive_queue
);
8442 refcount_inc(&skb
->users
);
8444 skb
= __skb_dequeue(&sk
->sk_receive_queue
);
8450 /* Caller is allowed not to check sk->sk_err before calling. */
8451 error
= sock_error(sk
);
8455 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8458 if (sk_can_busy_loop(sk
)) {
8459 sk_busy_loop(sk
, noblock
);
8461 if (!skb_queue_empty(&sk
->sk_receive_queue
))
8465 /* User doesn't want to wait. */
8469 } while (sctp_wait_for_packet(sk
, err
, &timeo
) == 0);
8478 /* If sndbuf has changed, wake up per association sndbuf waiters. */
8479 static void __sctp_write_space(struct sctp_association
*asoc
)
8481 struct sock
*sk
= asoc
->base
.sk
;
8483 if (sctp_wspace(asoc
) <= 0)
8486 if (waitqueue_active(&asoc
->wait
))
8487 wake_up_interruptible(&asoc
->wait
);
8489 if (sctp_writeable(sk
)) {
8490 struct socket_wq
*wq
;
8493 wq
= rcu_dereference(sk
->sk_wq
);
8495 if (waitqueue_active(&wq
->wait
))
8496 wake_up_interruptible(&wq
->wait
);
8498 /* Note that we try to include the Async I/O support
8499 * here by modeling from the current TCP/UDP code.
8500 * We have not tested with it yet.
8502 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
))
8503 sock_wake_async(wq
, SOCK_WAKE_SPACE
, POLL_OUT
);
8509 static void sctp_wake_up_waiters(struct sock
*sk
,
8510 struct sctp_association
*asoc
)
8512 struct sctp_association
*tmp
= asoc
;
8514 /* We do accounting for the sndbuf space per association,
8515 * so we only need to wake our own association.
8517 if (asoc
->ep
->sndbuf_policy
)
8518 return __sctp_write_space(asoc
);
8520 /* If association goes down and is just flushing its
8521 * outq, then just normally notify others.
8523 if (asoc
->base
.dead
)
8524 return sctp_write_space(sk
);
8526 /* Accounting for the sndbuf space is per socket, so we
8527 * need to wake up others, try to be fair and in case of
8528 * other associations, let them have a go first instead
8529 * of just doing a sctp_write_space() call.
8531 * Note that we reach sctp_wake_up_waiters() only when
8532 * associations free up queued chunks, thus we are under
8533 * lock and the list of associations on a socket is
8534 * guaranteed not to change.
8536 for (tmp
= list_next_entry(tmp
, asocs
); 1;
8537 tmp
= list_next_entry(tmp
, asocs
)) {
8538 /* Manually skip the head element. */
8539 if (&tmp
->asocs
== &((sctp_sk(sk
))->ep
->asocs
))
8541 /* Wake up association. */
8542 __sctp_write_space(tmp
);
8543 /* We've reached the end. */
8549 /* Do accounting for the sndbuf space.
8550 * Decrement the used sndbuf space of the corresponding association by the
8551 * data size which was just transmitted(freed).
8553 static void sctp_wfree(struct sk_buff
*skb
)
8555 struct sctp_chunk
*chunk
= skb_shinfo(skb
)->destructor_arg
;
8556 struct sctp_association
*asoc
= chunk
->asoc
;
8557 struct sock
*sk
= asoc
->base
.sk
;
8559 sk_mem_uncharge(sk
, skb
->truesize
);
8560 sk
->sk_wmem_queued
-= skb
->truesize
+ sizeof(struct sctp_chunk
);
8561 asoc
->sndbuf_used
-= skb
->truesize
+ sizeof(struct sctp_chunk
);
8562 WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk
),
8563 &sk
->sk_wmem_alloc
));
8566 struct sctp_shared_key
*shkey
= chunk
->shkey
;
8568 /* refcnt == 2 and !list_empty mean after this release, it's
8569 * not being used anywhere, and it's time to notify userland
8570 * that this shkey can be freed if it's been deactivated.
8572 if (shkey
->deactivated
&& !list_empty(&shkey
->key_list
) &&
8573 refcount_read(&shkey
->refcnt
) == 2) {
8574 struct sctp_ulpevent
*ev
;
8576 ev
= sctp_ulpevent_make_authkey(asoc
, shkey
->key_id
,
8580 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, ev
);
8582 sctp_auth_shkey_release(chunk
->shkey
);
8586 sctp_wake_up_waiters(sk
, asoc
);
8588 sctp_association_put(asoc
);
8591 /* Do accounting for the receive space on the socket.
8592 * Accounting for the association is done in ulpevent.c
8593 * We set this as a destructor for the cloned data skbs so that
8594 * accounting is done at the correct time.
8596 void sctp_sock_rfree(struct sk_buff
*skb
)
8598 struct sock
*sk
= skb
->sk
;
8599 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
8601 atomic_sub(event
->rmem_len
, &sk
->sk_rmem_alloc
);
8604 * Mimic the behavior of sock_rfree
8606 sk_mem_uncharge(sk
, event
->rmem_len
);
8610 /* Helper function to wait for space in the sndbuf. */
8611 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
8614 struct sock
*sk
= asoc
->base
.sk
;
8615 long current_timeo
= *timeo_p
;
8619 pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__
, asoc
,
8622 /* Increment the association's refcnt. */
8623 sctp_association_hold(asoc
);
8625 /* Wait on the association specific sndbuf space. */
8627 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
8628 TASK_INTERRUPTIBLE
);
8629 if (asoc
->base
.dead
)
8633 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
)
8635 if (signal_pending(current
))
8636 goto do_interrupted
;
8637 if ((int)msg_len
<= sctp_wspace(asoc
))
8640 /* Let another process have a go. Since we are going
8644 current_timeo
= schedule_timeout(current_timeo
);
8646 if (sk
!= asoc
->base
.sk
)
8649 *timeo_p
= current_timeo
;
8653 finish_wait(&asoc
->wait
, &wait
);
8655 /* Release the association's refcnt. */
8656 sctp_association_put(asoc
);
8669 err
= sock_intr_errno(*timeo_p
);
8677 void sctp_data_ready(struct sock
*sk
)
8679 struct socket_wq
*wq
;
8682 wq
= rcu_dereference(sk
->sk_wq
);
8683 if (skwq_has_sleeper(wq
))
8684 wake_up_interruptible_sync_poll(&wq
->wait
, EPOLLIN
|
8685 EPOLLRDNORM
| EPOLLRDBAND
);
8686 sk_wake_async(sk
, SOCK_WAKE_WAITD
, POLL_IN
);
8690 /* If socket sndbuf has changed, wake up all per association waiters. */
8691 void sctp_write_space(struct sock
*sk
)
8693 struct sctp_association
*asoc
;
8695 /* Wake up the tasks in each wait queue. */
8696 list_for_each_entry(asoc
, &((sctp_sk(sk
))->ep
->asocs
), asocs
) {
8697 __sctp_write_space(asoc
);
8701 /* Is there any sndbuf space available on the socket?
8703 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
8704 * associations on the same socket. For a UDP-style socket with
8705 * multiple associations, it is possible for it to be "unwriteable"
8706 * prematurely. I assume that this is acceptable because
8707 * a premature "unwriteable" is better than an accidental "writeable" which
8708 * would cause an unwanted block under certain circumstances. For the 1-1
8709 * UDP-style sockets or TCP-style sockets, this code should work.
8712 static bool sctp_writeable(struct sock
*sk
)
8714 return sk
->sk_sndbuf
> sk
->sk_wmem_queued
;
8717 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
8718 * returns immediately with EINPROGRESS.
8720 static int sctp_wait_for_connect(struct sctp_association
*asoc
, long *timeo_p
)
8722 struct sock
*sk
= asoc
->base
.sk
;
8724 long current_timeo
= *timeo_p
;
8727 pr_debug("%s: asoc:%p, timeo:%ld\n", __func__
, asoc
, *timeo_p
);
8729 /* Increment the association's refcnt. */
8730 sctp_association_hold(asoc
);
8733 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
8734 TASK_INTERRUPTIBLE
);
8737 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8739 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
||
8742 if (signal_pending(current
))
8743 goto do_interrupted
;
8745 if (sctp_state(asoc
, ESTABLISHED
))
8748 /* Let another process have a go. Since we are going
8752 current_timeo
= schedule_timeout(current_timeo
);
8755 *timeo_p
= current_timeo
;
8759 finish_wait(&asoc
->wait
, &wait
);
8761 /* Release the association's refcnt. */
8762 sctp_association_put(asoc
);
8767 if (asoc
->init_err_counter
+ 1 > asoc
->max_init_attempts
)
8770 err
= -ECONNREFUSED
;
8774 err
= sock_intr_errno(*timeo_p
);
8782 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
)
8784 struct sctp_endpoint
*ep
;
8788 ep
= sctp_sk(sk
)->ep
;
8792 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
,
8793 TASK_INTERRUPTIBLE
);
8795 if (list_empty(&ep
->asocs
)) {
8797 timeo
= schedule_timeout(timeo
);
8802 if (!sctp_sstate(sk
, LISTENING
))
8806 if (!list_empty(&ep
->asocs
))
8809 err
= sock_intr_errno(timeo
);
8810 if (signal_pending(current
))
8818 finish_wait(sk_sleep(sk
), &wait
);
8823 static void sctp_wait_for_close(struct sock
*sk
, long timeout
)
8828 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
8829 if (list_empty(&sctp_sk(sk
)->ep
->asocs
))
8832 timeout
= schedule_timeout(timeout
);
8834 } while (!signal_pending(current
) && timeout
);
8836 finish_wait(sk_sleep(sk
), &wait
);
8839 static void sctp_skb_set_owner_r_frag(struct sk_buff
*skb
, struct sock
*sk
)
8841 struct sk_buff
*frag
;
8846 /* Don't forget the fragments. */
8847 skb_walk_frags(skb
, frag
)
8848 sctp_skb_set_owner_r_frag(frag
, sk
);
8851 sctp_skb_set_owner_r(skb
, sk
);
8854 void sctp_copy_sock(struct sock
*newsk
, struct sock
*sk
,
8855 struct sctp_association
*asoc
)
8857 struct inet_sock
*inet
= inet_sk(sk
);
8858 struct inet_sock
*newinet
;
8859 struct sctp_sock
*sp
= sctp_sk(sk
);
8860 struct sctp_endpoint
*ep
= sp
->ep
;
8862 newsk
->sk_type
= sk
->sk_type
;
8863 newsk
->sk_bound_dev_if
= sk
->sk_bound_dev_if
;
8864 newsk
->sk_flags
= sk
->sk_flags
;
8865 newsk
->sk_tsflags
= sk
->sk_tsflags
;
8866 newsk
->sk_no_check_tx
= sk
->sk_no_check_tx
;
8867 newsk
->sk_no_check_rx
= sk
->sk_no_check_rx
;
8868 newsk
->sk_reuse
= sk
->sk_reuse
;
8869 sctp_sk(newsk
)->reuse
= sp
->reuse
;
8871 newsk
->sk_shutdown
= sk
->sk_shutdown
;
8872 newsk
->sk_destruct
= sctp_destruct_sock
;
8873 newsk
->sk_family
= sk
->sk_family
;
8874 newsk
->sk_protocol
= IPPROTO_SCTP
;
8875 newsk
->sk_backlog_rcv
= sk
->sk_prot
->backlog_rcv
;
8876 newsk
->sk_sndbuf
= sk
->sk_sndbuf
;
8877 newsk
->sk_rcvbuf
= sk
->sk_rcvbuf
;
8878 newsk
->sk_lingertime
= sk
->sk_lingertime
;
8879 newsk
->sk_rcvtimeo
= sk
->sk_rcvtimeo
;
8880 newsk
->sk_sndtimeo
= sk
->sk_sndtimeo
;
8881 newsk
->sk_rxhash
= sk
->sk_rxhash
;
8883 newinet
= inet_sk(newsk
);
8885 /* Initialize sk's sport, dport, rcv_saddr and daddr for
8886 * getsockname() and getpeername()
8888 newinet
->inet_sport
= inet
->inet_sport
;
8889 newinet
->inet_saddr
= inet
->inet_saddr
;
8890 newinet
->inet_rcv_saddr
= inet
->inet_rcv_saddr
;
8891 newinet
->inet_dport
= htons(asoc
->peer
.port
);
8892 newinet
->pmtudisc
= inet
->pmtudisc
;
8893 newinet
->inet_id
= asoc
->next_tsn
^ jiffies
;
8895 newinet
->uc_ttl
= inet
->uc_ttl
;
8896 newinet
->mc_loop
= 1;
8897 newinet
->mc_ttl
= 1;
8898 newinet
->mc_index
= 0;
8899 newinet
->mc_list
= NULL
;
8901 if (newsk
->sk_flags
& SK_FLAGS_TIMESTAMP
)
8902 net_enable_timestamp();
8904 /* Set newsk security attributes from orginal sk and connection
8905 * security attribute from ep.
8907 security_sctp_sk_clone(ep
, sk
, newsk
);
8910 static inline void sctp_copy_descendant(struct sock
*sk_to
,
8911 const struct sock
*sk_from
)
8913 int ancestor_size
= sizeof(struct inet_sock
) +
8914 sizeof(struct sctp_sock
) -
8915 offsetof(struct sctp_sock
, auto_asconf_list
);
8917 if (sk_from
->sk_family
== PF_INET6
)
8918 ancestor_size
+= sizeof(struct ipv6_pinfo
);
8920 __inet_sk_copy_descendant(sk_to
, sk_from
, ancestor_size
);
8923 /* Populate the fields of the newsk from the oldsk and migrate the assoc
8924 * and its messages to the newsk.
8926 static void sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
8927 struct sctp_association
*assoc
,
8928 enum sctp_socket_type type
)
8930 struct sctp_sock
*oldsp
= sctp_sk(oldsk
);
8931 struct sctp_sock
*newsp
= sctp_sk(newsk
);
8932 struct sctp_bind_bucket
*pp
; /* hash list port iterator */
8933 struct sctp_endpoint
*newep
= newsp
->ep
;
8934 struct sk_buff
*skb
, *tmp
;
8935 struct sctp_ulpevent
*event
;
8936 struct sctp_bind_hashbucket
*head
;
8938 /* Migrate socket buffer sizes and all the socket level options to the
8941 newsk
->sk_sndbuf
= oldsk
->sk_sndbuf
;
8942 newsk
->sk_rcvbuf
= oldsk
->sk_rcvbuf
;
8943 /* Brute force copy old sctp opt. */
8944 sctp_copy_descendant(newsk
, oldsk
);
8946 /* Restore the ep value that was overwritten with the above structure
8952 /* Hook this new socket in to the bind_hash list. */
8953 head
= &sctp_port_hashtable
[sctp_phashfn(sock_net(oldsk
),
8954 inet_sk(oldsk
)->inet_num
)];
8955 spin_lock_bh(&head
->lock
);
8956 pp
= sctp_sk(oldsk
)->bind_hash
;
8957 sk_add_bind_node(newsk
, &pp
->owner
);
8958 sctp_sk(newsk
)->bind_hash
= pp
;
8959 inet_sk(newsk
)->inet_num
= inet_sk(oldsk
)->inet_num
;
8960 spin_unlock_bh(&head
->lock
);
8962 /* Copy the bind_addr list from the original endpoint to the new
8963 * endpoint so that we can handle restarts properly
8965 sctp_bind_addr_dup(&newsp
->ep
->base
.bind_addr
,
8966 &oldsp
->ep
->base
.bind_addr
, GFP_KERNEL
);
8968 /* Move any messages in the old socket's receive queue that are for the
8969 * peeled off association to the new socket's receive queue.
8971 sctp_skb_for_each(skb
, &oldsk
->sk_receive_queue
, tmp
) {
8972 event
= sctp_skb2event(skb
);
8973 if (event
->asoc
== assoc
) {
8974 __skb_unlink(skb
, &oldsk
->sk_receive_queue
);
8975 __skb_queue_tail(&newsk
->sk_receive_queue
, skb
);
8976 sctp_skb_set_owner_r_frag(skb
, newsk
);
8980 /* Clean up any messages pending delivery due to partial
8981 * delivery. Three cases:
8982 * 1) No partial deliver; no work.
8983 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
8984 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
8986 skb_queue_head_init(&newsp
->pd_lobby
);
8987 atomic_set(&sctp_sk(newsk
)->pd_mode
, assoc
->ulpq
.pd_mode
);
8989 if (atomic_read(&sctp_sk(oldsk
)->pd_mode
)) {
8990 struct sk_buff_head
*queue
;
8992 /* Decide which queue to move pd_lobby skbs to. */
8993 if (assoc
->ulpq
.pd_mode
) {
8994 queue
= &newsp
->pd_lobby
;
8996 queue
= &newsk
->sk_receive_queue
;
8998 /* Walk through the pd_lobby, looking for skbs that
8999 * need moved to the new socket.
9001 sctp_skb_for_each(skb
, &oldsp
->pd_lobby
, tmp
) {
9002 event
= sctp_skb2event(skb
);
9003 if (event
->asoc
== assoc
) {
9004 __skb_unlink(skb
, &oldsp
->pd_lobby
);
9005 __skb_queue_tail(queue
, skb
);
9006 sctp_skb_set_owner_r_frag(skb
, newsk
);
9010 /* Clear up any skbs waiting for the partial
9011 * delivery to finish.
9013 if (assoc
->ulpq
.pd_mode
)
9014 sctp_clear_pd(oldsk
, NULL
);
9018 sctp_for_each_rx_skb(assoc
, newsk
, sctp_skb_set_owner_r_frag
);
9020 /* Set the type of socket to indicate that it is peeled off from the
9021 * original UDP-style socket or created with the accept() call on a
9022 * TCP-style socket..
9026 /* Mark the new socket "in-use" by the user so that any packets
9027 * that may arrive on the association after we've moved it are
9028 * queued to the backlog. This prevents a potential race between
9029 * backlog processing on the old socket and new-packet processing
9030 * on the new socket.
9032 * The caller has just allocated newsk so we can guarantee that other
9033 * paths won't try to lock it and then oldsk.
9035 lock_sock_nested(newsk
, SINGLE_DEPTH_NESTING
);
9036 sctp_for_each_tx_datachunk(assoc
, sctp_clear_owner_w
);
9037 sctp_assoc_migrate(assoc
, newsk
);
9038 sctp_for_each_tx_datachunk(assoc
, sctp_set_owner_w
);
9040 /* If the association on the newsk is already closed before accept()
9041 * is called, set RCV_SHUTDOWN flag.
9043 if (sctp_state(assoc
, CLOSED
) && sctp_style(newsk
, TCP
)) {
9044 inet_sk_set_state(newsk
, SCTP_SS_CLOSED
);
9045 newsk
->sk_shutdown
|= RCV_SHUTDOWN
;
9047 inet_sk_set_state(newsk
, SCTP_SS_ESTABLISHED
);
9050 release_sock(newsk
);
9054 /* This proto struct describes the ULP interface for SCTP. */
9055 struct proto sctp_prot
= {
9057 .owner
= THIS_MODULE
,
9058 .close
= sctp_close
,
9059 .disconnect
= sctp_disconnect
,
9060 .accept
= sctp_accept
,
9061 .ioctl
= sctp_ioctl
,
9062 .init
= sctp_init_sock
,
9063 .destroy
= sctp_destroy_sock
,
9064 .shutdown
= sctp_shutdown
,
9065 .setsockopt
= sctp_setsockopt
,
9066 .getsockopt
= sctp_getsockopt
,
9067 .sendmsg
= sctp_sendmsg
,
9068 .recvmsg
= sctp_recvmsg
,
9070 .backlog_rcv
= sctp_backlog_rcv
,
9072 .unhash
= sctp_unhash
,
9073 .get_port
= sctp_get_port
,
9074 .obj_size
= sizeof(struct sctp_sock
),
9075 .useroffset
= offsetof(struct sctp_sock
, subscribe
),
9076 .usersize
= offsetof(struct sctp_sock
, initmsg
) -
9077 offsetof(struct sctp_sock
, subscribe
) +
9078 sizeof_field(struct sctp_sock
, initmsg
),
9079 .sysctl_mem
= sysctl_sctp_mem
,
9080 .sysctl_rmem
= sysctl_sctp_rmem
,
9081 .sysctl_wmem
= sysctl_sctp_wmem
,
9082 .memory_pressure
= &sctp_memory_pressure
,
9083 .enter_memory_pressure
= sctp_enter_memory_pressure
,
9084 .memory_allocated
= &sctp_memory_allocated
,
9085 .sockets_allocated
= &sctp_sockets_allocated
,
9088 #if IS_ENABLED(CONFIG_IPV6)
9090 #include <net/transp_v6.h>
9091 static void sctp_v6_destroy_sock(struct sock
*sk
)
9093 sctp_destroy_sock(sk
);
9094 inet6_destroy_sock(sk
);
9097 struct proto sctpv6_prot
= {
9099 .owner
= THIS_MODULE
,
9100 .close
= sctp_close
,
9101 .disconnect
= sctp_disconnect
,
9102 .accept
= sctp_accept
,
9103 .ioctl
= sctp_ioctl
,
9104 .init
= sctp_init_sock
,
9105 .destroy
= sctp_v6_destroy_sock
,
9106 .shutdown
= sctp_shutdown
,
9107 .setsockopt
= sctp_setsockopt
,
9108 .getsockopt
= sctp_getsockopt
,
9109 .sendmsg
= sctp_sendmsg
,
9110 .recvmsg
= sctp_recvmsg
,
9112 .backlog_rcv
= sctp_backlog_rcv
,
9114 .unhash
= sctp_unhash
,
9115 .get_port
= sctp_get_port
,
9116 .obj_size
= sizeof(struct sctp6_sock
),
9117 .useroffset
= offsetof(struct sctp6_sock
, sctp
.subscribe
),
9118 .usersize
= offsetof(struct sctp6_sock
, sctp
.initmsg
) -
9119 offsetof(struct sctp6_sock
, sctp
.subscribe
) +
9120 sizeof_field(struct sctp6_sock
, sctp
.initmsg
),
9121 .sysctl_mem
= sysctl_sctp_mem
,
9122 .sysctl_rmem
= sysctl_sctp_rmem
,
9123 .sysctl_wmem
= sysctl_sctp_wmem
,
9124 .memory_pressure
= &sctp_memory_pressure
,
9125 .enter_memory_pressure
= sctp_enter_memory_pressure
,
9126 .memory_allocated
= &sctp_memory_allocated
,
9127 .sockets_allocated
= &sctp_sockets_allocated
,
9129 #endif /* IS_ENABLED(CONFIG_IPV6) */