1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* SCTP kernel implementation
3 * (C) Copyright IBM Corp. 2001, 2004
4 * Copyright (c) 1999-2000 Cisco, Inc.
5 * Copyright (c) 1999-2001 Motorola, Inc.
6 * Copyright (c) 2001-2003 Intel Corp.
7 * Copyright (c) 2001-2002 Nokia, Inc.
8 * Copyright (c) 2001 La Monte H.P. Yarroll
10 * This file is part of the SCTP kernel implementation
12 * These functions interface with the sockets layer to implement the
13 * SCTP Extensions for the Sockets API.
15 * Note that the descriptions from the specification are USER level
16 * functions--this file is the functions which populate the struct proto
17 * for SCTP which is the BOTTOM of the sockets interface.
19 * Please send any bug reports or fixes you make to the
21 * lksctp developers <linux-sctp@vger.kernel.org>
23 * Written or modified by:
24 * La Monte H.P. Yarroll <piggy@acm.org>
25 * Narasimha Budihal <narsi@refcode.org>
26 * Karl Knutson <karl@athena.chicago.il.us>
27 * Jon Grimm <jgrimm@us.ibm.com>
28 * Xingang Guo <xingang.guo@intel.com>
29 * Daisy Chang <daisyc@us.ibm.com>
30 * Sridhar Samudrala <samudrala@us.ibm.com>
31 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>
32 * Ardelle Fan <ardelle.fan@intel.com>
33 * Ryan Layer <rmlayer@us.ibm.com>
34 * Anup Pemmaiah <pemmaiah@cc.usu.edu>
35 * Kevin Gao <kevin.gao@intel.com>
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 #include <crypto/hash.h>
41 #include <linux/types.h>
42 #include <linux/kernel.h>
43 #include <linux/wait.h>
44 #include <linux/time.h>
45 #include <linux/sched/signal.h>
47 #include <linux/capability.h>
48 #include <linux/fcntl.h>
49 #include <linux/poll.h>
50 #include <linux/init.h>
51 #include <linux/slab.h>
52 #include <linux/file.h>
53 #include <linux/compat.h>
54 #include <linux/rhashtable.h>
58 #include <net/route.h>
60 #include <net/inet_common.h>
61 #include <net/busy_poll.h>
62 #include <trace/events/sock.h>
64 #include <linux/socket.h> /* for sa_family_t */
65 #include <linux/export.h>
67 #include <net/sctp/sctp.h>
68 #include <net/sctp/sm.h>
69 #include <net/sctp/stream_sched.h>
71 /* Forward declarations for internal helper functions. */
72 static bool sctp_writeable(const struct sock
*sk
);
73 static void sctp_wfree(struct sk_buff
*skb
);
74 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
76 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
);
77 static int sctp_wait_for_connect(struct sctp_association
*, long *timeo_p
);
78 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
);
79 static void sctp_wait_for_close(struct sock
*sk
, long timeo
);
80 static void sctp_destruct_sock(struct sock
*sk
);
81 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
82 union sctp_addr
*addr
, int len
);
83 static int sctp_bindx_add(struct sock
*, struct sockaddr
*, int);
84 static int sctp_bindx_rem(struct sock
*, struct sockaddr
*, int);
85 static int sctp_send_asconf_add_ip(struct sock
*, struct sockaddr
*, int);
86 static int sctp_send_asconf_del_ip(struct sock
*, struct sockaddr
*, int);
87 static int sctp_send_asconf(struct sctp_association
*asoc
,
88 struct sctp_chunk
*chunk
);
89 static int sctp_do_bind(struct sock
*, union sctp_addr
*, int);
90 static int sctp_autobind(struct sock
*sk
);
91 static int sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
92 struct sctp_association
*assoc
,
93 enum sctp_socket_type type
);
95 static unsigned long sctp_memory_pressure
;
96 static atomic_long_t sctp_memory_allocated
;
97 static DEFINE_PER_CPU(int, sctp_memory_per_cpu_fw_alloc
);
98 struct percpu_counter sctp_sockets_allocated
;
100 static void sctp_enter_memory_pressure(struct sock
*sk
)
102 WRITE_ONCE(sctp_memory_pressure
, 1);
106 /* Get the sndbuf space available at the time on the association. */
107 static inline int sctp_wspace(struct sctp_association
*asoc
)
109 struct sock
*sk
= asoc
->base
.sk
;
111 return asoc
->ep
->sndbuf_policy
? sk
->sk_sndbuf
- asoc
->sndbuf_used
112 : sk_stream_wspace(sk
);
115 /* Increment the used sndbuf space count of the corresponding association by
116 * the size of the outgoing data chunk.
117 * Also, set the skb destructor for sndbuf accounting later.
119 * Since it is always 1-1 between chunk and skb, and also a new skb is always
120 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
121 * destructor in the data chunk skb for the purpose of the sndbuf space
124 static inline void sctp_set_owner_w(struct sctp_chunk
*chunk
)
126 struct sctp_association
*asoc
= chunk
->asoc
;
127 struct sock
*sk
= asoc
->base
.sk
;
129 /* The sndbuf space is tracked per association. */
130 sctp_association_hold(asoc
);
133 sctp_auth_shkey_hold(chunk
->shkey
);
135 skb_set_owner_w(chunk
->skb
, sk
);
137 chunk
->skb
->destructor
= sctp_wfree
;
138 /* Save the chunk pointer in skb for sctp_wfree to use later. */
139 skb_shinfo(chunk
->skb
)->destructor_arg
= chunk
;
141 refcount_add(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
);
142 asoc
->sndbuf_used
+= chunk
->skb
->truesize
+ sizeof(struct sctp_chunk
);
143 sk_wmem_queued_add(sk
, chunk
->skb
->truesize
+ sizeof(struct sctp_chunk
));
144 sk_mem_charge(sk
, chunk
->skb
->truesize
);
147 static void sctp_clear_owner_w(struct sctp_chunk
*chunk
)
149 skb_orphan(chunk
->skb
);
152 #define traverse_and_process() \
155 if (msg == prev_msg) \
157 list_for_each_entry(c, &msg->chunks, frag_list) { \
158 if ((clear && asoc->base.sk == c->skb->sk) || \
159 (!clear && asoc->base.sk != c->skb->sk)) \
165 static void sctp_for_each_tx_datachunk(struct sctp_association
*asoc
,
167 void (*cb
)(struct sctp_chunk
*))
170 struct sctp_datamsg
*msg
, *prev_msg
= NULL
;
171 struct sctp_outq
*q
= &asoc
->outqueue
;
172 struct sctp_chunk
*chunk
, *c
;
173 struct sctp_transport
*t
;
175 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
, transports
)
176 list_for_each_entry(chunk
, &t
->transmitted
, transmitted_list
)
177 traverse_and_process();
179 list_for_each_entry(chunk
, &q
->retransmit
, transmitted_list
)
180 traverse_and_process();
182 list_for_each_entry(chunk
, &q
->sacked
, transmitted_list
)
183 traverse_and_process();
185 list_for_each_entry(chunk
, &q
->abandoned
, transmitted_list
)
186 traverse_and_process();
188 list_for_each_entry(chunk
, &q
->out_chunk_list
, list
)
189 traverse_and_process();
192 static void sctp_for_each_rx_skb(struct sctp_association
*asoc
, struct sock
*sk
,
193 void (*cb
)(struct sk_buff
*, struct sock
*))
196 struct sk_buff
*skb
, *tmp
;
198 sctp_skb_for_each(skb
, &asoc
->ulpq
.lobby
, tmp
)
201 sctp_skb_for_each(skb
, &asoc
->ulpq
.reasm
, tmp
)
204 sctp_skb_for_each(skb
, &asoc
->ulpq
.reasm_uo
, tmp
)
208 /* Verify that this is a valid address. */
209 static inline int sctp_verify_addr(struct sock
*sk
, union sctp_addr
*addr
,
214 /* Verify basic sockaddr. */
215 af
= sctp_sockaddr_af(sctp_sk(sk
), addr
, len
);
219 /* Is this a valid SCTP address? */
220 if (!af
->addr_valid(addr
, sctp_sk(sk
), NULL
))
223 if (!sctp_sk(sk
)->pf
->send_verify(sctp_sk(sk
), (addr
)))
229 /* Look up the association by its id. If this is not a UDP-style
230 * socket, the ID field is always ignored.
232 struct sctp_association
*sctp_id2assoc(struct sock
*sk
, sctp_assoc_t id
)
234 struct sctp_association
*asoc
= NULL
;
236 /* If this is not a UDP-style socket, assoc id should be ignored. */
237 if (!sctp_style(sk
, UDP
)) {
238 /* Return NULL if the socket state is not ESTABLISHED. It
239 * could be a TCP-style listening socket or a socket which
240 * hasn't yet called connect() to establish an association.
242 if (!sctp_sstate(sk
, ESTABLISHED
) && !sctp_sstate(sk
, CLOSING
))
245 /* Get the first and the only association from the list. */
246 if (!list_empty(&sctp_sk(sk
)->ep
->asocs
))
247 asoc
= list_entry(sctp_sk(sk
)->ep
->asocs
.next
,
248 struct sctp_association
, asocs
);
252 /* Otherwise this is a UDP-style socket. */
253 if (id
<= SCTP_ALL_ASSOC
)
256 spin_lock_bh(&sctp_assocs_id_lock
);
257 asoc
= (struct sctp_association
*)idr_find(&sctp_assocs_id
, (int)id
);
258 if (asoc
&& (asoc
->base
.sk
!= sk
|| asoc
->base
.dead
))
260 spin_unlock_bh(&sctp_assocs_id_lock
);
265 /* Look up the transport from an address and an assoc id. If both address and
266 * id are specified, the associations matching the address and the id should be
269 static struct sctp_transport
*sctp_addr_id2transport(struct sock
*sk
,
270 struct sockaddr_storage
*addr
,
273 struct sctp_association
*addr_asoc
= NULL
, *id_asoc
= NULL
;
274 struct sctp_af
*af
= sctp_get_af_specific(addr
->ss_family
);
275 union sctp_addr
*laddr
= (union sctp_addr
*)addr
;
276 struct sctp_transport
*transport
;
278 if (!af
|| sctp_verify_addr(sk
, laddr
, af
->sockaddr_len
))
281 addr_asoc
= sctp_endpoint_lookup_assoc(sctp_sk(sk
)->ep
,
288 id_asoc
= sctp_id2assoc(sk
, id
);
289 if (id_asoc
&& (id_asoc
!= addr_asoc
))
292 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
293 (union sctp_addr
*)addr
);
298 /* API 3.1.2 bind() - UDP Style Syntax
299 * The syntax of bind() is,
301 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
303 * sd - the socket descriptor returned by socket().
304 * addr - the address structure (struct sockaddr_in or struct
305 * sockaddr_in6 [RFC 2553]),
306 * addr_len - the size of the address structure.
308 static int sctp_bind(struct sock
*sk
, struct sockaddr
*addr
, int addr_len
)
314 pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__
, sk
,
317 /* Disallow binding twice. */
318 if (!sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
319 retval
= sctp_do_bind(sk
, (union sctp_addr
*)addr
,
329 static int sctp_get_port_local(struct sock
*, union sctp_addr
*);
331 /* Verify this is a valid sockaddr. */
332 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
333 union sctp_addr
*addr
, int len
)
337 /* Check minimum size. */
338 if (len
< sizeof (struct sockaddr
))
341 if (!opt
->pf
->af_supported(addr
->sa
.sa_family
, opt
))
344 if (addr
->sa
.sa_family
== AF_INET6
) {
345 if (len
< SIN6_LEN_RFC2133
)
347 /* V4 mapped address are really of AF_INET family */
348 if (ipv6_addr_v4mapped(&addr
->v6
.sin6_addr
) &&
349 !opt
->pf
->af_supported(AF_INET
, opt
))
353 /* If we get this far, af is valid. */
354 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
356 if (len
< af
->sockaddr_len
)
362 static void sctp_auto_asconf_init(struct sctp_sock
*sp
)
364 struct net
*net
= sock_net(&sp
->inet
.sk
);
366 if (net
->sctp
.default_auto_asconf
) {
367 spin_lock_bh(&net
->sctp
.addr_wq_lock
);
368 list_add_tail(&sp
->auto_asconf_list
, &net
->sctp
.auto_asconf_splist
);
369 spin_unlock_bh(&net
->sctp
.addr_wq_lock
);
370 sp
->do_auto_asconf
= 1;
374 /* Bind a local address either to an endpoint or to an association. */
375 static int sctp_do_bind(struct sock
*sk
, union sctp_addr
*addr
, int len
)
377 struct net
*net
= sock_net(sk
);
378 struct sctp_sock
*sp
= sctp_sk(sk
);
379 struct sctp_endpoint
*ep
= sp
->ep
;
380 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
385 /* Common sockaddr verification. */
386 af
= sctp_sockaddr_af(sp
, addr
, len
);
388 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
389 __func__
, sk
, addr
, len
);
393 snum
= ntohs(addr
->v4
.sin_port
);
395 pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
396 __func__
, sk
, &addr
->sa
, bp
->port
, snum
, len
);
398 /* PF specific bind() address verification. */
399 if (!sp
->pf
->bind_verify(sp
, addr
))
400 return -EADDRNOTAVAIL
;
402 /* We must either be unbound, or bind to the same port.
403 * It's OK to allow 0 ports if we are already bound.
404 * We'll just inhert an already bound port in this case
409 else if (snum
!= bp
->port
) {
410 pr_debug("%s: new port %d doesn't match existing port "
411 "%d\n", __func__
, snum
, bp
->port
);
416 if (snum
&& inet_port_requires_bind_service(net
, snum
) &&
417 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
))
420 /* See if the address matches any of the addresses we may have
421 * already bound before checking against other endpoints.
423 if (sctp_bind_addr_match(bp
, addr
, sp
))
426 /* Make sure we are allowed to bind here.
427 * The function sctp_get_port_local() does duplicate address
430 addr
->v4
.sin_port
= htons(snum
);
431 if (sctp_get_port_local(sk
, addr
))
434 /* Refresh ephemeral port. */
436 bp
->port
= inet_sk(sk
)->inet_num
;
437 sctp_auto_asconf_init(sp
);
440 /* Add the address to the bind address list.
441 * Use GFP_ATOMIC since BHs will be disabled.
443 ret
= sctp_add_bind_addr(bp
, addr
, af
->sockaddr_len
,
444 SCTP_ADDR_SRC
, GFP_ATOMIC
);
450 /* Copy back into socket for getsockname() use. */
451 inet_sk(sk
)->inet_sport
= htons(inet_sk(sk
)->inet_num
);
452 sp
->pf
->to_sk_saddr(addr
, sk
);
457 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
459 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
460 * at any one time. If a sender, after sending an ASCONF chunk, decides
461 * it needs to transfer another ASCONF Chunk, it MUST wait until the
462 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
463 * subsequent ASCONF. Note this restriction binds each side, so at any
464 * time two ASCONF may be in-transit on any given association (one sent
465 * from each endpoint).
467 static int sctp_send_asconf(struct sctp_association
*asoc
,
468 struct sctp_chunk
*chunk
)
472 /* If there is an outstanding ASCONF chunk, queue it for later
475 if (asoc
->addip_last_asconf
) {
476 list_add_tail(&chunk
->list
, &asoc
->addip_chunk_list
);
480 /* Hold the chunk until an ASCONF_ACK is received. */
481 sctp_chunk_hold(chunk
);
482 retval
= sctp_primitive_ASCONF(asoc
->base
.net
, asoc
, chunk
);
484 sctp_chunk_free(chunk
);
486 asoc
->addip_last_asconf
= chunk
;
492 /* Add a list of addresses as bind addresses to local endpoint or
495 * Basically run through each address specified in the addrs/addrcnt
496 * array/length pair, determine if it is IPv6 or IPv4 and call
497 * sctp_do_bind() on it.
499 * If any of them fails, then the operation will be reversed and the
500 * ones that were added will be removed.
502 * Only sctp_setsockopt_bindx() is supposed to call this function.
504 static int sctp_bindx_add(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
509 struct sockaddr
*sa_addr
;
512 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__
, sk
,
516 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
517 /* The list may contain either IPv4 or IPv6 address;
518 * determine the address length for walking thru the list.
521 af
= sctp_get_af_specific(sa_addr
->sa_family
);
527 retval
= sctp_do_bind(sk
, (union sctp_addr
*)sa_addr
,
530 addr_buf
+= af
->sockaddr_len
;
534 /* Failed. Cleanup the ones that have been added */
536 sctp_bindx_rem(sk
, addrs
, cnt
);
544 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
545 * associations that are part of the endpoint indicating that a list of local
546 * addresses are added to the endpoint.
548 * If any of the addresses is already in the bind address list of the
549 * association, we do not send the chunk for that association. But it will not
550 * affect other associations.
552 * Only sctp_setsockopt_bindx() is supposed to call this function.
554 static int sctp_send_asconf_add_ip(struct sock
*sk
,
555 struct sockaddr
*addrs
,
558 struct sctp_sock
*sp
;
559 struct sctp_endpoint
*ep
;
560 struct sctp_association
*asoc
;
561 struct sctp_bind_addr
*bp
;
562 struct sctp_chunk
*chunk
;
563 struct sctp_sockaddr_entry
*laddr
;
564 union sctp_addr
*addr
;
565 union sctp_addr saveaddr
;
575 if (!ep
->asconf_enable
)
578 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
579 __func__
, sk
, addrs
, addrcnt
);
581 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
582 if (!asoc
->peer
.asconf_capable
)
585 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_ADD_IP
)
588 if (!sctp_state(asoc
, ESTABLISHED
))
591 /* Check if any address in the packed array of addresses is
592 * in the bind address list of the association. If so,
593 * do not send the asconf chunk to its peer, but continue with
594 * other associations.
597 for (i
= 0; i
< addrcnt
; i
++) {
599 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
605 if (sctp_assoc_lookup_laddr(asoc
, addr
))
608 addr_buf
+= af
->sockaddr_len
;
613 /* Use the first valid address in bind addr list of
614 * association as Address Parameter of ASCONF CHUNK.
616 bp
= &asoc
->base
.bind_addr
;
617 p
= bp
->address_list
.next
;
618 laddr
= list_entry(p
, struct sctp_sockaddr_entry
, list
);
619 chunk
= sctp_make_asconf_update_ip(asoc
, &laddr
->a
, addrs
,
620 addrcnt
, SCTP_PARAM_ADD_IP
);
626 /* Add the new addresses to the bind address list with
627 * use_as_src set to 0.
630 for (i
= 0; i
< addrcnt
; i
++) {
632 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
633 memcpy(&saveaddr
, addr
, af
->sockaddr_len
);
634 retval
= sctp_add_bind_addr(bp
, &saveaddr
,
636 SCTP_ADDR_NEW
, GFP_ATOMIC
);
637 addr_buf
+= af
->sockaddr_len
;
639 if (asoc
->src_out_of_asoc_ok
) {
640 struct sctp_transport
*trans
;
642 list_for_each_entry(trans
,
643 &asoc
->peer
.transport_addr_list
, transports
) {
644 trans
->cwnd
= min(4*asoc
->pathmtu
, max_t(__u32
,
645 2*asoc
->pathmtu
, 4380));
646 trans
->ssthresh
= asoc
->peer
.i
.a_rwnd
;
647 trans
->rto
= asoc
->rto_initial
;
648 sctp_max_rto(asoc
, trans
);
649 trans
->rtt
= trans
->srtt
= trans
->rttvar
= 0;
650 /* Clear the source and route cache */
651 sctp_transport_route(trans
, NULL
,
652 sctp_sk(asoc
->base
.sk
));
655 retval
= sctp_send_asconf(asoc
, chunk
);
662 /* Remove a list of addresses from bind addresses list. Do not remove the
665 * Basically run through each address specified in the addrs/addrcnt
666 * array/length pair, determine if it is IPv6 or IPv4 and call
667 * sctp_del_bind() on it.
669 * If any of them fails, then the operation will be reversed and the
670 * ones that were removed will be added back.
672 * At least one address has to be left; if only one address is
673 * available, the operation will return -EBUSY.
675 * Only sctp_setsockopt_bindx() is supposed to call this function.
677 static int sctp_bindx_rem(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
679 struct sctp_sock
*sp
= sctp_sk(sk
);
680 struct sctp_endpoint
*ep
= sp
->ep
;
682 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
685 union sctp_addr
*sa_addr
;
688 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
689 __func__
, sk
, addrs
, addrcnt
);
692 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
693 /* If the bind address list is empty or if there is only one
694 * bind address, there is nothing more to be removed (we need
695 * at least one address here).
697 if (list_empty(&bp
->address_list
) ||
698 (sctp_list_single_entry(&bp
->address_list
))) {
704 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
710 if (!af
->addr_valid(sa_addr
, sp
, NULL
)) {
711 retval
= -EADDRNOTAVAIL
;
715 if (sa_addr
->v4
.sin_port
&&
716 sa_addr
->v4
.sin_port
!= htons(bp
->port
)) {
721 if (!sa_addr
->v4
.sin_port
)
722 sa_addr
->v4
.sin_port
= htons(bp
->port
);
724 /* FIXME - There is probably a need to check if sk->sk_saddr and
725 * sk->sk_rcv_addr are currently set to one of the addresses to
726 * be removed. This is something which needs to be looked into
727 * when we are fixing the outstanding issues with multi-homing
728 * socket routing and failover schemes. Refer to comments in
729 * sctp_do_bind(). -daisy
731 retval
= sctp_del_bind_addr(bp
, sa_addr
);
733 addr_buf
+= af
->sockaddr_len
;
736 /* Failed. Add the ones that has been removed back */
738 sctp_bindx_add(sk
, addrs
, cnt
);
746 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
747 * the associations that are part of the endpoint indicating that a list of
748 * local addresses are removed from the endpoint.
750 * If any of the addresses is already in the bind address list of the
751 * association, we do not send the chunk for that association. But it will not
752 * affect other associations.
754 * Only sctp_setsockopt_bindx() is supposed to call this function.
756 static int sctp_send_asconf_del_ip(struct sock
*sk
,
757 struct sockaddr
*addrs
,
760 struct sctp_sock
*sp
;
761 struct sctp_endpoint
*ep
;
762 struct sctp_association
*asoc
;
763 struct sctp_transport
*transport
;
764 struct sctp_bind_addr
*bp
;
765 struct sctp_chunk
*chunk
;
766 union sctp_addr
*laddr
;
769 struct sctp_sockaddr_entry
*saddr
;
778 if (!ep
->asconf_enable
)
781 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
782 __func__
, sk
, addrs
, addrcnt
);
784 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
786 if (!asoc
->peer
.asconf_capable
)
789 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_DEL_IP
)
792 if (!sctp_state(asoc
, ESTABLISHED
))
795 /* Check if any address in the packed array of addresses is
796 * not present in the bind address list of the association.
797 * If so, do not send the asconf chunk to its peer, but
798 * continue with other associations.
801 for (i
= 0; i
< addrcnt
; i
++) {
803 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
809 if (!sctp_assoc_lookup_laddr(asoc
, laddr
))
812 addr_buf
+= af
->sockaddr_len
;
817 /* Find one address in the association's bind address list
818 * that is not in the packed array of addresses. This is to
819 * make sure that we do not delete all the addresses in the
822 bp
= &asoc
->base
.bind_addr
;
823 laddr
= sctp_find_unmatch_addr(bp
, (union sctp_addr
*)addrs
,
825 if ((laddr
== NULL
) && (addrcnt
== 1)) {
826 if (asoc
->asconf_addr_del_pending
)
828 asoc
->asconf_addr_del_pending
=
829 kzalloc(sizeof(union sctp_addr
), GFP_ATOMIC
);
830 if (asoc
->asconf_addr_del_pending
== NULL
) {
834 asoc
->asconf_addr_del_pending
->sa
.sa_family
=
836 asoc
->asconf_addr_del_pending
->v4
.sin_port
=
838 if (addrs
->sa_family
== AF_INET
) {
839 struct sockaddr_in
*sin
;
841 sin
= (struct sockaddr_in
*)addrs
;
842 asoc
->asconf_addr_del_pending
->v4
.sin_addr
.s_addr
= sin
->sin_addr
.s_addr
;
843 } else if (addrs
->sa_family
== AF_INET6
) {
844 struct sockaddr_in6
*sin6
;
846 sin6
= (struct sockaddr_in6
*)addrs
;
847 asoc
->asconf_addr_del_pending
->v6
.sin6_addr
= sin6
->sin6_addr
;
850 pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
851 __func__
, asoc
, &asoc
->asconf_addr_del_pending
->sa
,
852 asoc
->asconf_addr_del_pending
);
854 asoc
->src_out_of_asoc_ok
= 1;
862 /* We do not need RCU protection throughout this loop
863 * because this is done under a socket lock from the
866 chunk
= sctp_make_asconf_update_ip(asoc
, laddr
, addrs
, addrcnt
,
874 /* Reset use_as_src flag for the addresses in the bind address
875 * list that are to be deleted.
878 for (i
= 0; i
< addrcnt
; i
++) {
880 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
881 list_for_each_entry(saddr
, &bp
->address_list
, list
) {
882 if (sctp_cmp_addr_exact(&saddr
->a
, laddr
))
883 saddr
->state
= SCTP_ADDR_DEL
;
885 addr_buf
+= af
->sockaddr_len
;
888 /* Update the route and saddr entries for all the transports
889 * as some of the addresses in the bind address list are
890 * about to be deleted and cannot be used as source addresses.
892 list_for_each_entry(transport
, &asoc
->peer
.transport_addr_list
,
894 sctp_transport_route(transport
, NULL
,
895 sctp_sk(asoc
->base
.sk
));
899 /* We don't need to transmit ASCONF */
901 retval
= sctp_send_asconf(asoc
, chunk
);
907 /* set addr events to assocs in the endpoint. ep and addr_wq must be locked */
908 int sctp_asconf_mgmt(struct sctp_sock
*sp
, struct sctp_sockaddr_entry
*addrw
)
910 struct sock
*sk
= sctp_opt2sk(sp
);
911 union sctp_addr
*addr
;
914 /* It is safe to write port space in caller. */
916 addr
->v4
.sin_port
= htons(sp
->ep
->base
.bind_addr
.port
);
917 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
920 if (sctp_verify_addr(sk
, addr
, af
->sockaddr_len
))
923 if (addrw
->state
== SCTP_ADDR_NEW
)
924 return sctp_send_asconf_add_ip(sk
, (struct sockaddr
*)addr
, 1);
926 return sctp_send_asconf_del_ip(sk
, (struct sockaddr
*)addr
, 1);
929 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
932 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
935 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
936 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
939 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
940 * Section 3.1.2 for this usage.
942 * addrs is a pointer to an array of one or more socket addresses. Each
943 * address is contained in its appropriate structure (i.e. struct
944 * sockaddr_in or struct sockaddr_in6) the family of the address type
945 * must be used to distinguish the address length (note that this
946 * representation is termed a "packed array" of addresses). The caller
947 * specifies the number of addresses in the array with addrcnt.
949 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
950 * -1, and sets errno to the appropriate error code.
952 * For SCTP, the port given in each socket address must be the same, or
953 * sctp_bindx() will fail, setting errno to EINVAL.
955 * The flags parameter is formed from the bitwise OR of zero or more of
956 * the following currently defined flags:
958 * SCTP_BINDX_ADD_ADDR
960 * SCTP_BINDX_REM_ADDR
962 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
963 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
964 * addresses from the association. The two flags are mutually exclusive;
965 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
966 * not remove all addresses from an association; sctp_bindx() will
967 * reject such an attempt with EINVAL.
969 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
970 * additional addresses with an endpoint after calling bind(). Or use
971 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
972 * socket is associated with so that no new association accepted will be
973 * associated with those addresses. If the endpoint supports dynamic
974 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
975 * endpoint to send the appropriate message to the peer to change the
976 * peers address lists.
978 * Adding and removing addresses from a connected association is
979 * optional functionality. Implementations that do not support this
980 * functionality should return EOPNOTSUPP.
982 * Basically do nothing but copying the addresses from user to kernel
983 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
984 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
987 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
990 * sk The sk of the socket
991 * addrs The pointer to the addresses
992 * addrssize Size of the addrs buffer
993 * op Operation to perform (add or remove, see the flags of
996 * Returns 0 if ok, <0 errno code on error.
998 static int sctp_setsockopt_bindx(struct sock
*sk
, struct sockaddr
*addrs
,
999 int addrs_size
, int op
)
1004 struct sockaddr
*sa_addr
;
1005 void *addr_buf
= addrs
;
1008 pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
1009 __func__
, sk
, addr_buf
, addrs_size
, op
);
1011 if (unlikely(addrs_size
<= 0))
1014 /* Walk through the addrs buffer and count the number of addresses. */
1015 while (walk_size
< addrs_size
) {
1016 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
)
1020 af
= sctp_get_af_specific(sa_addr
->sa_family
);
1022 /* If the address family is not supported or if this address
1023 * causes the address buffer to overflow return EINVAL.
1025 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
)
1028 addr_buf
+= af
->sockaddr_len
;
1029 walk_size
+= af
->sockaddr_len
;
1034 case SCTP_BINDX_ADD_ADDR
:
1035 /* Allow security module to validate bindx addresses. */
1036 err
= security_sctp_bind_connect(sk
, SCTP_SOCKOPT_BINDX_ADD
,
1040 err
= sctp_bindx_add(sk
, addrs
, addrcnt
);
1043 return sctp_send_asconf_add_ip(sk
, addrs
, addrcnt
);
1044 case SCTP_BINDX_REM_ADDR
:
1045 err
= sctp_bindx_rem(sk
, addrs
, addrcnt
);
1048 return sctp_send_asconf_del_ip(sk
, addrs
, addrcnt
);
1055 static int sctp_bind_add(struct sock
*sk
, struct sockaddr
*addrs
,
1061 err
= sctp_setsockopt_bindx(sk
, addrs
, addrlen
, SCTP_BINDX_ADD_ADDR
);
1066 static int sctp_connect_new_asoc(struct sctp_endpoint
*ep
,
1067 const union sctp_addr
*daddr
,
1068 const struct sctp_initmsg
*init
,
1069 struct sctp_transport
**tp
)
1071 struct sctp_association
*asoc
;
1072 struct sock
*sk
= ep
->base
.sk
;
1073 struct net
*net
= sock_net(sk
);
1074 enum sctp_scope scope
;
1077 if (sctp_endpoint_is_peeled_off(ep
, daddr
))
1078 return -EADDRNOTAVAIL
;
1080 if (!ep
->base
.bind_addr
.port
) {
1081 if (sctp_autobind(sk
))
1084 if (inet_port_requires_bind_service(net
, ep
->base
.bind_addr
.port
) &&
1085 !ns_capable(net
->user_ns
, CAP_NET_BIND_SERVICE
))
1089 scope
= sctp_scope(daddr
);
1090 asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1094 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, scope
, GFP_KERNEL
);
1098 *tp
= sctp_assoc_add_peer(asoc
, daddr
, GFP_KERNEL
, SCTP_UNKNOWN
);
1107 if (init
->sinit_num_ostreams
) {
1108 __u16 outcnt
= init
->sinit_num_ostreams
;
1110 asoc
->c
.sinit_num_ostreams
= outcnt
;
1111 /* outcnt has been changed, need to re-init stream */
1112 err
= sctp_stream_init(&asoc
->stream
, outcnt
, 0, GFP_KERNEL
);
1117 if (init
->sinit_max_instreams
)
1118 asoc
->c
.sinit_max_instreams
= init
->sinit_max_instreams
;
1120 if (init
->sinit_max_attempts
)
1121 asoc
->max_init_attempts
= init
->sinit_max_attempts
;
1123 if (init
->sinit_max_init_timeo
)
1124 asoc
->max_init_timeo
=
1125 msecs_to_jiffies(init
->sinit_max_init_timeo
);
1129 sctp_association_free(asoc
);
1133 static int sctp_connect_add_peer(struct sctp_association
*asoc
,
1134 union sctp_addr
*daddr
, int addr_len
)
1136 struct sctp_endpoint
*ep
= asoc
->ep
;
1137 struct sctp_association
*old
;
1138 struct sctp_transport
*t
;
1141 err
= sctp_verify_addr(ep
->base
.sk
, daddr
, addr_len
);
1145 old
= sctp_endpoint_lookup_assoc(ep
, daddr
, &t
);
1146 if (old
&& old
!= asoc
)
1147 return old
->state
>= SCTP_STATE_ESTABLISHED
? -EISCONN
1150 if (sctp_endpoint_is_peeled_off(ep
, daddr
))
1151 return -EADDRNOTAVAIL
;
1153 t
= sctp_assoc_add_peer(asoc
, daddr
, GFP_KERNEL
, SCTP_UNKNOWN
);
1160 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1162 * Common routine for handling connect() and sctp_connectx().
1163 * Connect will come in with just a single address.
1165 static int __sctp_connect(struct sock
*sk
, struct sockaddr
*kaddrs
,
1166 int addrs_size
, int flags
, sctp_assoc_t
*assoc_id
)
1168 struct sctp_sock
*sp
= sctp_sk(sk
);
1169 struct sctp_endpoint
*ep
= sp
->ep
;
1170 struct sctp_transport
*transport
;
1171 struct sctp_association
*asoc
;
1172 void *addr_buf
= kaddrs
;
1173 union sctp_addr
*daddr
;
1178 if (sctp_sstate(sk
, ESTABLISHED
) || sctp_sstate(sk
, CLOSING
) ||
1179 (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
)))
1183 af
= sctp_get_af_specific(daddr
->sa
.sa_family
);
1184 if (!af
|| af
->sockaddr_len
> addrs_size
)
1187 err
= sctp_verify_addr(sk
, daddr
, af
->sockaddr_len
);
1191 asoc
= sctp_endpoint_lookup_assoc(ep
, daddr
, &transport
);
1193 return asoc
->state
>= SCTP_STATE_ESTABLISHED
? -EISCONN
1196 err
= sctp_connect_new_asoc(ep
, daddr
, NULL
, &transport
);
1199 asoc
= transport
->asoc
;
1201 addr_buf
+= af
->sockaddr_len
;
1202 walk_size
= af
->sockaddr_len
;
1203 while (walk_size
< addrs_size
) {
1205 if (walk_size
+ sizeof(sa_family_t
) > addrs_size
)
1209 af
= sctp_get_af_specific(daddr
->sa
.sa_family
);
1210 if (!af
|| af
->sockaddr_len
+ walk_size
> addrs_size
)
1213 if (asoc
->peer
.port
!= ntohs(daddr
->v4
.sin_port
))
1216 err
= sctp_connect_add_peer(asoc
, daddr
, af
->sockaddr_len
);
1220 addr_buf
+= af
->sockaddr_len
;
1221 walk_size
+= af
->sockaddr_len
;
1224 /* In case the user of sctp_connectx() wants an association
1225 * id back, assign one now.
1228 err
= sctp_assoc_set_id(asoc
, GFP_KERNEL
);
1233 err
= sctp_primitive_ASSOCIATE(sock_net(sk
), asoc
, NULL
);
1237 /* Initialize sk's dport and daddr for getpeername() */
1238 inet_sk(sk
)->inet_dport
= htons(asoc
->peer
.port
);
1239 sp
->pf
->to_sk_daddr(daddr
, sk
);
1243 *assoc_id
= asoc
->assoc_id
;
1245 timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
1246 return sctp_wait_for_connect(asoc
, &timeo
);
1249 pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1250 __func__
, asoc
, kaddrs
, err
);
1251 sctp_association_free(asoc
);
1255 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1258 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1259 * sctp_assoc_t *asoc);
1261 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1262 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1263 * or IPv6 addresses.
1265 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1266 * Section 3.1.2 for this usage.
1268 * addrs is a pointer to an array of one or more socket addresses. Each
1269 * address is contained in its appropriate structure (i.e. struct
1270 * sockaddr_in or struct sockaddr_in6) the family of the address type
1271 * must be used to distengish the address length (note that this
1272 * representation is termed a "packed array" of addresses). The caller
1273 * specifies the number of addresses in the array with addrcnt.
1275 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1276 * the association id of the new association. On failure, sctp_connectx()
1277 * returns -1, and sets errno to the appropriate error code. The assoc_id
1278 * is not touched by the kernel.
1280 * For SCTP, the port given in each socket address must be the same, or
1281 * sctp_connectx() will fail, setting errno to EINVAL.
1283 * An application can use sctp_connectx to initiate an association with
1284 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1285 * allows a caller to specify multiple addresses at which a peer can be
1286 * reached. The way the SCTP stack uses the list of addresses to set up
1287 * the association is implementation dependent. This function only
1288 * specifies that the stack will try to make use of all the addresses in
1289 * the list when needed.
1291 * Note that the list of addresses passed in is only used for setting up
1292 * the association. It does not necessarily equal the set of addresses
1293 * the peer uses for the resulting association. If the caller wants to
1294 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1295 * retrieve them after the association has been set up.
1297 * Basically do nothing but copying the addresses from user to kernel
1298 * land and invoking either sctp_connectx(). This is used for tunneling
1299 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1301 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1304 * sk The sk of the socket
1305 * addrs The pointer to the addresses
1306 * addrssize Size of the addrs buffer
1308 * Returns >=0 if ok, <0 errno code on error.
1310 static int __sctp_setsockopt_connectx(struct sock
*sk
, struct sockaddr
*kaddrs
,
1311 int addrs_size
, sctp_assoc_t
*assoc_id
)
1313 int err
= 0, flags
= 0;
1315 pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1316 __func__
, sk
, kaddrs
, addrs_size
);
1318 /* make sure the 1st addr's sa_family is accessible later */
1319 if (unlikely(addrs_size
< sizeof(sa_family_t
)))
1322 /* Allow security module to validate connectx addresses. */
1323 err
= security_sctp_bind_connect(sk
, SCTP_SOCKOPT_CONNECTX
,
1324 (struct sockaddr
*)kaddrs
,
1329 /* in-kernel sockets don't generally have a file allocated to them
1330 * if all they do is call sock_create_kern().
1332 if (sk
->sk_socket
->file
)
1333 flags
= sk
->sk_socket
->file
->f_flags
;
1335 return __sctp_connect(sk
, kaddrs
, addrs_size
, flags
, assoc_id
);
1339 * This is an older interface. It's kept for backward compatibility
1340 * to the option that doesn't provide association id.
1342 static int sctp_setsockopt_connectx_old(struct sock
*sk
,
1343 struct sockaddr
*kaddrs
,
1346 return __sctp_setsockopt_connectx(sk
, kaddrs
, addrs_size
, NULL
);
1350 * New interface for the API. The since the API is done with a socket
1351 * option, to make it simple we feed back the association id is as a return
1352 * indication to the call. Error is always negative and association id is
1355 static int sctp_setsockopt_connectx(struct sock
*sk
,
1356 struct sockaddr
*kaddrs
,
1359 sctp_assoc_t assoc_id
= 0;
1362 err
= __sctp_setsockopt_connectx(sk
, kaddrs
, addrs_size
, &assoc_id
);
1371 * New (hopefully final) interface for the API.
1372 * We use the sctp_getaddrs_old structure so that use-space library
1373 * can avoid any unnecessary allocations. The only different part
1374 * is that we store the actual length of the address buffer into the
1375 * addrs_num structure member. That way we can re-use the existing
1378 #ifdef CONFIG_COMPAT
1379 struct compat_sctp_getaddrs_old
{
1380 sctp_assoc_t assoc_id
;
1382 compat_uptr_t addrs
; /* struct sockaddr * */
1386 static int sctp_getsockopt_connectx3(struct sock
*sk
, int len
,
1387 char __user
*optval
,
1390 struct sctp_getaddrs_old param
;
1391 sctp_assoc_t assoc_id
= 0;
1392 struct sockaddr
*kaddrs
;
1395 #ifdef CONFIG_COMPAT
1396 if (in_compat_syscall()) {
1397 struct compat_sctp_getaddrs_old param32
;
1399 if (len
< sizeof(param32
))
1401 if (copy_from_user(¶m32
, optval
, sizeof(param32
)))
1404 param
.assoc_id
= param32
.assoc_id
;
1405 param
.addr_num
= param32
.addr_num
;
1406 param
.addrs
= compat_ptr(param32
.addrs
);
1410 if (len
< sizeof(param
))
1412 if (copy_from_user(¶m
, optval
, sizeof(param
)))
1416 kaddrs
= memdup_user(param
.addrs
, param
.addr_num
);
1418 return PTR_ERR(kaddrs
);
1420 err
= __sctp_setsockopt_connectx(sk
, kaddrs
, param
.addr_num
, &assoc_id
);
1422 if (err
== 0 || err
== -EINPROGRESS
) {
1423 if (copy_to_user(optval
, &assoc_id
, sizeof(assoc_id
)))
1425 if (put_user(sizeof(assoc_id
), optlen
))
1432 /* API 3.1.4 close() - UDP Style Syntax
1433 * Applications use close() to perform graceful shutdown (as described in
1434 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1435 * by a UDP-style socket.
1439 * ret = close(int sd);
1441 * sd - the socket descriptor of the associations to be closed.
1443 * To gracefully shutdown a specific association represented by the
1444 * UDP-style socket, an application should use the sendmsg() call,
1445 * passing no user data, but including the appropriate flag in the
1446 * ancillary data (see Section xxxx).
1448 * If sd in the close() call is a branched-off socket representing only
1449 * one association, the shutdown is performed on that association only.
1451 * 4.1.6 close() - TCP Style Syntax
1453 * Applications use close() to gracefully close down an association.
1457 * int close(int sd);
1459 * sd - the socket descriptor of the association to be closed.
1461 * After an application calls close() on a socket descriptor, no further
1462 * socket operations will succeed on that descriptor.
1464 * API 7.1.4 SO_LINGER
1466 * An application using the TCP-style socket can use this option to
1467 * perform the SCTP ABORT primitive. The linger option structure is:
1470 * int l_onoff; // option on/off
1471 * int l_linger; // linger time
1474 * To enable the option, set l_onoff to 1. If the l_linger value is set
1475 * to 0, calling close() is the same as the ABORT primitive. If the
1476 * value is set to a negative value, the setsockopt() call will return
1477 * an error. If the value is set to a positive value linger_time, the
1478 * close() can be blocked for at most linger_time ms. If the graceful
1479 * shutdown phase does not finish during this period, close() will
1480 * return but the graceful shutdown phase continues in the system.
1482 static void sctp_close(struct sock
*sk
, long timeout
)
1484 struct net
*net
= sock_net(sk
);
1485 struct sctp_endpoint
*ep
;
1486 struct sctp_association
*asoc
;
1487 struct list_head
*pos
, *temp
;
1488 unsigned int data_was_unread
;
1490 pr_debug("%s: sk:%p, timeout:%ld\n", __func__
, sk
, timeout
);
1492 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
1493 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1494 inet_sk_set_state(sk
, SCTP_SS_CLOSING
);
1496 ep
= sctp_sk(sk
)->ep
;
1498 /* Clean up any skbs sitting on the receive queue. */
1499 data_was_unread
= sctp_queue_purge_ulpevents(&sk
->sk_receive_queue
);
1500 data_was_unread
+= sctp_queue_purge_ulpevents(&sctp_sk(sk
)->pd_lobby
);
1502 /* Walk all associations on an endpoint. */
1503 list_for_each_safe(pos
, temp
, &ep
->asocs
) {
1504 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
1506 if (sctp_style(sk
, TCP
)) {
1507 /* A closed association can still be in the list if
1508 * it belongs to a TCP-style listening socket that is
1509 * not yet accepted. If so, free it. If not, send an
1510 * ABORT or SHUTDOWN based on the linger options.
1512 if (sctp_state(asoc
, CLOSED
)) {
1513 sctp_association_free(asoc
);
1518 if (data_was_unread
|| !skb_queue_empty(&asoc
->ulpq
.lobby
) ||
1519 !skb_queue_empty(&asoc
->ulpq
.reasm
) ||
1520 !skb_queue_empty(&asoc
->ulpq
.reasm_uo
) ||
1521 (sock_flag(sk
, SOCK_LINGER
) && !sk
->sk_lingertime
)) {
1522 struct sctp_chunk
*chunk
;
1524 chunk
= sctp_make_abort_user(asoc
, NULL
, 0);
1525 sctp_primitive_ABORT(net
, asoc
, chunk
);
1527 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
1530 /* On a TCP-style socket, block for at most linger_time if set. */
1531 if (sctp_style(sk
, TCP
) && timeout
)
1532 sctp_wait_for_close(sk
, timeout
);
1534 /* This will run the backlog queue. */
1537 /* Supposedly, no process has access to the socket, but
1538 * the net layers still may.
1539 * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1540 * held and that should be grabbed before socket lock.
1542 spin_lock_bh(&net
->sctp
.addr_wq_lock
);
1543 bh_lock_sock_nested(sk
);
1545 /* Hold the sock, since sk_common_release() will put sock_put()
1546 * and we have just a little more cleanup.
1549 sk_common_release(sk
);
1552 spin_unlock_bh(&net
->sctp
.addr_wq_lock
);
1556 SCTP_DBG_OBJCNT_DEC(sock
);
1559 /* Handle EPIPE error. */
1560 static int sctp_error(struct sock
*sk
, int flags
, int err
)
1563 err
= sock_error(sk
) ? : -EPIPE
;
1564 if (err
== -EPIPE
&& !(flags
& MSG_NOSIGNAL
))
1565 send_sig(SIGPIPE
, current
, 0);
1569 /* API 3.1.3 sendmsg() - UDP Style Syntax
1571 * An application uses sendmsg() and recvmsg() calls to transmit data to
1572 * and receive data from its peer.
1574 * ssize_t sendmsg(int socket, const struct msghdr *message,
1577 * socket - the socket descriptor of the endpoint.
1578 * message - pointer to the msghdr structure which contains a single
1579 * user message and possibly some ancillary data.
1581 * See Section 5 for complete description of the data
1584 * flags - flags sent or received with the user message, see Section
1585 * 5 for complete description of the flags.
1587 * Note: This function could use a rewrite especially when explicit
1588 * connect support comes in.
1590 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1592 static int sctp_msghdr_parse(const struct msghdr
*msg
,
1593 struct sctp_cmsgs
*cmsgs
);
1595 static int sctp_sendmsg_parse(struct sock
*sk
, struct sctp_cmsgs
*cmsgs
,
1596 struct sctp_sndrcvinfo
*srinfo
,
1597 const struct msghdr
*msg
, size_t msg_len
)
1602 if (sctp_sstate(sk
, LISTENING
) && sctp_style(sk
, TCP
))
1605 if (msg_len
> sk
->sk_sndbuf
)
1608 memset(cmsgs
, 0, sizeof(*cmsgs
));
1609 err
= sctp_msghdr_parse(msg
, cmsgs
);
1611 pr_debug("%s: msghdr parse err:%x\n", __func__
, err
);
1615 memset(srinfo
, 0, sizeof(*srinfo
));
1616 if (cmsgs
->srinfo
) {
1617 srinfo
->sinfo_stream
= cmsgs
->srinfo
->sinfo_stream
;
1618 srinfo
->sinfo_flags
= cmsgs
->srinfo
->sinfo_flags
;
1619 srinfo
->sinfo_ppid
= cmsgs
->srinfo
->sinfo_ppid
;
1620 srinfo
->sinfo_context
= cmsgs
->srinfo
->sinfo_context
;
1621 srinfo
->sinfo_assoc_id
= cmsgs
->srinfo
->sinfo_assoc_id
;
1622 srinfo
->sinfo_timetolive
= cmsgs
->srinfo
->sinfo_timetolive
;
1626 srinfo
->sinfo_stream
= cmsgs
->sinfo
->snd_sid
;
1627 srinfo
->sinfo_flags
= cmsgs
->sinfo
->snd_flags
;
1628 srinfo
->sinfo_ppid
= cmsgs
->sinfo
->snd_ppid
;
1629 srinfo
->sinfo_context
= cmsgs
->sinfo
->snd_context
;
1630 srinfo
->sinfo_assoc_id
= cmsgs
->sinfo
->snd_assoc_id
;
1633 if (cmsgs
->prinfo
) {
1634 srinfo
->sinfo_timetolive
= cmsgs
->prinfo
->pr_value
;
1635 SCTP_PR_SET_POLICY(srinfo
->sinfo_flags
,
1636 cmsgs
->prinfo
->pr_policy
);
1639 sflags
= srinfo
->sinfo_flags
;
1640 if (!sflags
&& msg_len
)
1643 if (sctp_style(sk
, TCP
) && (sflags
& (SCTP_EOF
| SCTP_ABORT
)))
1646 if (((sflags
& SCTP_EOF
) && msg_len
> 0) ||
1647 (!(sflags
& (SCTP_EOF
| SCTP_ABORT
)) && msg_len
== 0))
1650 if ((sflags
& SCTP_ADDR_OVER
) && !msg
->msg_name
)
1656 static int sctp_sendmsg_new_asoc(struct sock
*sk
, __u16 sflags
,
1657 struct sctp_cmsgs
*cmsgs
,
1658 union sctp_addr
*daddr
,
1659 struct sctp_transport
**tp
)
1661 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
1662 struct sctp_association
*asoc
;
1663 struct cmsghdr
*cmsg
;
1664 __be32 flowinfo
= 0;
1670 if (sflags
& (SCTP_EOF
| SCTP_ABORT
))
1673 if (sctp_style(sk
, TCP
) && (sctp_sstate(sk
, ESTABLISHED
) ||
1674 sctp_sstate(sk
, CLOSING
)))
1675 return -EADDRNOTAVAIL
;
1677 /* Label connection socket for first association 1-to-many
1678 * style for client sequence socket()->sendmsg(). This
1679 * needs to be done before sctp_assoc_add_peer() as that will
1680 * set up the initial packet that needs to account for any
1681 * security ip options (CIPSO/CALIPSO) added to the packet.
1683 af
= sctp_get_af_specific(daddr
->sa
.sa_family
);
1686 err
= security_sctp_bind_connect(sk
, SCTP_SENDMSG_CONNECT
,
1687 (struct sockaddr
*)daddr
,
1692 err
= sctp_connect_new_asoc(ep
, daddr
, cmsgs
->init
, tp
);
1697 if (!cmsgs
->addrs_msg
)
1700 if (daddr
->sa
.sa_family
== AF_INET6
)
1701 flowinfo
= daddr
->v6
.sin6_flowinfo
;
1703 /* sendv addr list parse */
1704 for_each_cmsghdr(cmsg
, cmsgs
->addrs_msg
) {
1705 union sctp_addr _daddr
;
1708 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
||
1709 (cmsg
->cmsg_type
!= SCTP_DSTADDRV4
&&
1710 cmsg
->cmsg_type
!= SCTP_DSTADDRV6
))
1714 memset(daddr
, 0, sizeof(*daddr
));
1715 dlen
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1716 if (cmsg
->cmsg_type
== SCTP_DSTADDRV4
) {
1717 if (dlen
< sizeof(struct in_addr
)) {
1722 dlen
= sizeof(struct in_addr
);
1723 daddr
->v4
.sin_family
= AF_INET
;
1724 daddr
->v4
.sin_port
= htons(asoc
->peer
.port
);
1725 memcpy(&daddr
->v4
.sin_addr
, CMSG_DATA(cmsg
), dlen
);
1727 if (dlen
< sizeof(struct in6_addr
)) {
1732 dlen
= sizeof(struct in6_addr
);
1733 daddr
->v6
.sin6_flowinfo
= flowinfo
;
1734 daddr
->v6
.sin6_family
= AF_INET6
;
1735 daddr
->v6
.sin6_port
= htons(asoc
->peer
.port
);
1736 memcpy(&daddr
->v6
.sin6_addr
, CMSG_DATA(cmsg
), dlen
);
1739 err
= sctp_connect_add_peer(asoc
, daddr
, sizeof(*daddr
));
1747 sctp_association_free(asoc
);
1751 static int sctp_sendmsg_check_sflags(struct sctp_association
*asoc
,
1752 __u16 sflags
, struct msghdr
*msg
,
1755 struct sock
*sk
= asoc
->base
.sk
;
1756 struct net
*net
= sock_net(sk
);
1758 if (sctp_state(asoc
, CLOSED
) && sctp_style(sk
, TCP
))
1761 if ((sflags
& SCTP_SENDALL
) && sctp_style(sk
, UDP
) &&
1762 !sctp_state(asoc
, ESTABLISHED
))
1765 if (sflags
& SCTP_EOF
) {
1766 pr_debug("%s: shutting down association:%p\n", __func__
, asoc
);
1767 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
1772 if (sflags
& SCTP_ABORT
) {
1773 struct sctp_chunk
*chunk
;
1775 chunk
= sctp_make_abort_user(asoc
, msg
, msg_len
);
1779 pr_debug("%s: aborting association:%p\n", __func__
, asoc
);
1780 sctp_primitive_ABORT(net
, asoc
, chunk
);
1781 iov_iter_revert(&msg
->msg_iter
, msg_len
);
1789 static int sctp_sendmsg_to_asoc(struct sctp_association
*asoc
,
1790 struct msghdr
*msg
, size_t msg_len
,
1791 struct sctp_transport
*transport
,
1792 struct sctp_sndrcvinfo
*sinfo
)
1794 struct sock
*sk
= asoc
->base
.sk
;
1795 struct sctp_sock
*sp
= sctp_sk(sk
);
1796 struct net
*net
= sock_net(sk
);
1797 struct sctp_datamsg
*datamsg
;
1798 bool wait_connect
= false;
1799 struct sctp_chunk
*chunk
;
1803 if (sinfo
->sinfo_stream
>= asoc
->stream
.outcnt
) {
1808 if (unlikely(!SCTP_SO(&asoc
->stream
, sinfo
->sinfo_stream
)->ext
)) {
1809 err
= sctp_stream_init_ext(&asoc
->stream
, sinfo
->sinfo_stream
);
1814 if (sp
->disable_fragments
&& msg_len
> asoc
->frag_point
) {
1819 if (asoc
->pmtu_pending
) {
1820 if (sp
->param_flags
& SPP_PMTUD_ENABLE
)
1821 sctp_assoc_sync_pmtu(asoc
);
1822 asoc
->pmtu_pending
= 0;
1825 if (sctp_wspace(asoc
) < (int)msg_len
)
1826 sctp_prsctp_prune(asoc
, sinfo
, msg_len
- sctp_wspace(asoc
));
1828 if (sctp_wspace(asoc
) <= 0 || !sk_wmem_schedule(sk
, msg_len
)) {
1829 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1830 err
= sctp_wait_for_sndbuf(asoc
, &timeo
, msg_len
);
1833 if (unlikely(sinfo
->sinfo_stream
>= asoc
->stream
.outcnt
)) {
1839 if (sctp_state(asoc
, CLOSED
)) {
1840 err
= sctp_primitive_ASSOCIATE(net
, asoc
, NULL
);
1844 if (asoc
->ep
->intl_enable
) {
1845 timeo
= sock_sndtimeo(sk
, 0);
1846 err
= sctp_wait_for_connect(asoc
, &timeo
);
1852 wait_connect
= true;
1855 pr_debug("%s: we associated primitively\n", __func__
);
1858 datamsg
= sctp_datamsg_from_user(asoc
, sinfo
, &msg
->msg_iter
);
1859 if (IS_ERR(datamsg
)) {
1860 err
= PTR_ERR(datamsg
);
1864 asoc
->force_delay
= !!(msg
->msg_flags
& MSG_MORE
);
1866 list_for_each_entry(chunk
, &datamsg
->chunks
, frag_list
) {
1867 sctp_chunk_hold(chunk
);
1868 sctp_set_owner_w(chunk
);
1869 chunk
->transport
= transport
;
1872 err
= sctp_primitive_SEND(net
, asoc
, datamsg
);
1874 sctp_datamsg_free(datamsg
);
1878 pr_debug("%s: we sent primitively\n", __func__
);
1880 sctp_datamsg_put(datamsg
);
1882 if (unlikely(wait_connect
)) {
1883 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1884 sctp_wait_for_connect(asoc
, &timeo
);
1893 static union sctp_addr
*sctp_sendmsg_get_daddr(struct sock
*sk
,
1894 const struct msghdr
*msg
,
1895 struct sctp_cmsgs
*cmsgs
)
1897 union sctp_addr
*daddr
= NULL
;
1900 if (!sctp_style(sk
, UDP_HIGH_BANDWIDTH
) && msg
->msg_name
) {
1901 int len
= msg
->msg_namelen
;
1903 if (len
> sizeof(*daddr
))
1904 len
= sizeof(*daddr
);
1906 daddr
= (union sctp_addr
*)msg
->msg_name
;
1908 err
= sctp_verify_addr(sk
, daddr
, len
);
1910 return ERR_PTR(err
);
1916 static void sctp_sendmsg_update_sinfo(struct sctp_association
*asoc
,
1917 struct sctp_sndrcvinfo
*sinfo
,
1918 struct sctp_cmsgs
*cmsgs
)
1920 if (!cmsgs
->srinfo
&& !cmsgs
->sinfo
) {
1921 sinfo
->sinfo_stream
= asoc
->default_stream
;
1922 sinfo
->sinfo_ppid
= asoc
->default_ppid
;
1923 sinfo
->sinfo_context
= asoc
->default_context
;
1924 sinfo
->sinfo_assoc_id
= sctp_assoc2id(asoc
);
1927 sinfo
->sinfo_flags
= asoc
->default_flags
;
1930 if (!cmsgs
->srinfo
&& !cmsgs
->prinfo
)
1931 sinfo
->sinfo_timetolive
= asoc
->default_timetolive
;
1933 if (cmsgs
->authinfo
) {
1934 /* Reuse sinfo_tsn to indicate that authinfo was set and
1935 * sinfo_ssn to save the keyid on tx path.
1937 sinfo
->sinfo_tsn
= 1;
1938 sinfo
->sinfo_ssn
= cmsgs
->authinfo
->auth_keynumber
;
1942 static int sctp_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t msg_len
)
1944 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
1945 struct sctp_transport
*transport
= NULL
;
1946 struct sctp_sndrcvinfo _sinfo
, *sinfo
;
1947 struct sctp_association
*asoc
, *tmp
;
1948 struct sctp_cmsgs cmsgs
;
1949 union sctp_addr
*daddr
;
1954 /* Parse and get snd_info */
1955 err
= sctp_sendmsg_parse(sk
, &cmsgs
, &_sinfo
, msg
, msg_len
);
1960 sflags
= sinfo
->sinfo_flags
;
1962 /* Get daddr from msg */
1963 daddr
= sctp_sendmsg_get_daddr(sk
, msg
, &cmsgs
);
1964 if (IS_ERR(daddr
)) {
1965 err
= PTR_ERR(daddr
);
1971 /* SCTP_SENDALL process */
1972 if ((sflags
& SCTP_SENDALL
) && sctp_style(sk
, UDP
)) {
1973 list_for_each_entry_safe(asoc
, tmp
, &ep
->asocs
, asocs
) {
1974 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
,
1981 sctp_sendmsg_update_sinfo(asoc
, sinfo
, &cmsgs
);
1983 err
= sctp_sendmsg_to_asoc(asoc
, msg
, msg_len
,
1988 iov_iter_revert(&msg
->msg_iter
, err
);
1994 /* Get and check or create asoc */
1996 asoc
= sctp_endpoint_lookup_assoc(ep
, daddr
, &transport
);
1998 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
,
2003 err
= sctp_sendmsg_new_asoc(sk
, sflags
, &cmsgs
, daddr
,
2008 asoc
= transport
->asoc
;
2012 if (!sctp_style(sk
, TCP
) && !(sflags
& SCTP_ADDR_OVER
))
2015 asoc
= sctp_id2assoc(sk
, sinfo
->sinfo_assoc_id
);
2021 err
= sctp_sendmsg_check_sflags(asoc
, sflags
, msg
, msg_len
);
2026 /* Update snd_info with the asoc */
2027 sctp_sendmsg_update_sinfo(asoc
, sinfo
, &cmsgs
);
2029 /* Send msg to the asoc */
2030 err
= sctp_sendmsg_to_asoc(asoc
, msg
, msg_len
, transport
, sinfo
);
2031 if (err
< 0 && err
!= -ESRCH
&& new)
2032 sctp_association_free(asoc
);
2037 return sctp_error(sk
, msg
->msg_flags
, err
);
2040 /* This is an extended version of skb_pull() that removes the data from the
2041 * start of a skb even when data is spread across the list of skb's in the
2042 * frag_list. len specifies the total amount of data that needs to be removed.
2043 * when 'len' bytes could be removed from the skb, it returns 0.
2044 * If 'len' exceeds the total skb length, it returns the no. of bytes that
2045 * could not be removed.
2047 static int sctp_skb_pull(struct sk_buff
*skb
, int len
)
2049 struct sk_buff
*list
;
2050 int skb_len
= skb_headlen(skb
);
2053 if (len
<= skb_len
) {
2054 __skb_pull(skb
, len
);
2058 __skb_pull(skb
, skb_len
);
2060 skb_walk_frags(skb
, list
) {
2061 rlen
= sctp_skb_pull(list
, len
);
2062 skb
->len
-= (len
-rlen
);
2063 skb
->data_len
-= (len
-rlen
);
2074 /* API 3.1.3 recvmsg() - UDP Style Syntax
2076 * ssize_t recvmsg(int socket, struct msghdr *message,
2079 * socket - the socket descriptor of the endpoint.
2080 * message - pointer to the msghdr structure which contains a single
2081 * user message and possibly some ancillary data.
2083 * See Section 5 for complete description of the data
2086 * flags - flags sent or received with the user message, see Section
2087 * 5 for complete description of the flags.
2089 static int sctp_recvmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
,
2090 int flags
, int *addr_len
)
2092 struct sctp_ulpevent
*event
= NULL
;
2093 struct sctp_sock
*sp
= sctp_sk(sk
);
2094 struct sk_buff
*skb
, *head_skb
;
2099 pr_debug("%s: sk:%p, msghdr:%p, len:%zd, flags:0x%x, addr_len:%p)\n",
2100 __func__
, sk
, msg
, len
, flags
, addr_len
);
2104 if (sctp_style(sk
, TCP
) && !sctp_sstate(sk
, ESTABLISHED
) &&
2105 !sctp_sstate(sk
, CLOSING
) && !sctp_sstate(sk
, CLOSED
)) {
2110 skb
= sctp_skb_recv_datagram(sk
, flags
, &err
);
2114 /* Get the total length of the skb including any skb's in the
2123 err
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
2125 event
= sctp_skb2event(skb
);
2130 if (event
->chunk
&& event
->chunk
->head_skb
)
2131 head_skb
= event
->chunk
->head_skb
;
2134 sock_recv_cmsgs(msg
, sk
, head_skb
);
2135 if (sctp_ulpevent_is_notification(event
)) {
2136 msg
->msg_flags
|= MSG_NOTIFICATION
;
2137 sp
->pf
->event_msgname(event
, msg
->msg_name
, addr_len
);
2139 sp
->pf
->skb_msgname(head_skb
, msg
->msg_name
, addr_len
);
2142 /* Check if we allow SCTP_NXTINFO. */
2143 if (sp
->recvnxtinfo
)
2144 sctp_ulpevent_read_nxtinfo(event
, msg
, sk
);
2145 /* Check if we allow SCTP_RCVINFO. */
2146 if (sp
->recvrcvinfo
)
2147 sctp_ulpevent_read_rcvinfo(event
, msg
);
2148 /* Check if we allow SCTP_SNDRCVINFO. */
2149 if (sctp_ulpevent_type_enabled(sp
->subscribe
, SCTP_DATA_IO_EVENT
))
2150 sctp_ulpevent_read_sndrcvinfo(event
, msg
);
2154 /* If skb's length exceeds the user's buffer, update the skb and
2155 * push it back to the receive_queue so that the next call to
2156 * recvmsg() will return the remaining data. Don't set MSG_EOR.
2158 if (skb_len
> copied
) {
2159 msg
->msg_flags
&= ~MSG_EOR
;
2160 if (flags
& MSG_PEEK
)
2162 sctp_skb_pull(skb
, copied
);
2163 skb_queue_head(&sk
->sk_receive_queue
, skb
);
2165 /* When only partial message is copied to the user, increase
2166 * rwnd by that amount. If all the data in the skb is read,
2167 * rwnd is updated when the event is freed.
2169 if (!sctp_ulpevent_is_notification(event
))
2170 sctp_assoc_rwnd_increase(event
->asoc
, copied
);
2172 } else if ((event
->msg_flags
& MSG_NOTIFICATION
) ||
2173 (event
->msg_flags
& MSG_EOR
))
2174 msg
->msg_flags
|= MSG_EOR
;
2176 msg
->msg_flags
&= ~MSG_EOR
;
2179 if (flags
& MSG_PEEK
) {
2180 /* Release the skb reference acquired after peeking the skb in
2181 * sctp_skb_recv_datagram().
2185 /* Free the event which includes releasing the reference to
2186 * the owner of the skb, freeing the skb and updating the
2189 sctp_ulpevent_free(event
);
2196 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2198 * This option is a on/off flag. If enabled no SCTP message
2199 * fragmentation will be performed. Instead if a message being sent
2200 * exceeds the current PMTU size, the message will NOT be sent and
2201 * instead a error will be indicated to the user.
2203 static int sctp_setsockopt_disable_fragments(struct sock
*sk
, int *val
,
2204 unsigned int optlen
)
2206 if (optlen
< sizeof(int))
2208 sctp_sk(sk
)->disable_fragments
= (*val
== 0) ? 0 : 1;
2212 static int sctp_setsockopt_events(struct sock
*sk
, __u8
*sn_type
,
2213 unsigned int optlen
)
2215 struct sctp_sock
*sp
= sctp_sk(sk
);
2216 struct sctp_association
*asoc
;
2219 if (optlen
> sizeof(struct sctp_event_subscribe
))
2222 for (i
= 0; i
< optlen
; i
++)
2223 sctp_ulpevent_type_set(&sp
->subscribe
, SCTP_SN_TYPE_BASE
+ i
,
2226 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
)
2227 asoc
->subscribe
= sctp_sk(sk
)->subscribe
;
2229 /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2230 * if there is no data to be sent or retransmit, the stack will
2231 * immediately send up this notification.
2233 if (sctp_ulpevent_type_enabled(sp
->subscribe
, SCTP_SENDER_DRY_EVENT
)) {
2234 struct sctp_ulpevent
*event
;
2236 asoc
= sctp_id2assoc(sk
, 0);
2237 if (asoc
&& sctp_outq_is_empty(&asoc
->outqueue
)) {
2238 event
= sctp_ulpevent_make_sender_dry_event(asoc
,
2239 GFP_USER
| __GFP_NOWARN
);
2243 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, event
);
2250 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2252 * This socket option is applicable to the UDP-style socket only. When
2253 * set it will cause associations that are idle for more than the
2254 * specified number of seconds to automatically close. An association
2255 * being idle is defined an association that has NOT sent or received
2256 * user data. The special value of '0' indicates that no automatic
2257 * close of any associations should be performed. The option expects an
2258 * integer defining the number of seconds of idle time before an
2259 * association is closed.
2261 static int sctp_setsockopt_autoclose(struct sock
*sk
, u32
*optval
,
2262 unsigned int optlen
)
2264 struct sctp_sock
*sp
= sctp_sk(sk
);
2265 struct net
*net
= sock_net(sk
);
2267 /* Applicable to UDP-style socket only */
2268 if (sctp_style(sk
, TCP
))
2270 if (optlen
!= sizeof(int))
2273 sp
->autoclose
= *optval
;
2274 if (sp
->autoclose
> net
->sctp
.max_autoclose
)
2275 sp
->autoclose
= net
->sctp
.max_autoclose
;
2280 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2282 * Applications can enable or disable heartbeats for any peer address of
2283 * an association, modify an address's heartbeat interval, force a
2284 * heartbeat to be sent immediately, and adjust the address's maximum
2285 * number of retransmissions sent before an address is considered
2286 * unreachable. The following structure is used to access and modify an
2287 * address's parameters:
2289 * struct sctp_paddrparams {
2290 * sctp_assoc_t spp_assoc_id;
2291 * struct sockaddr_storage spp_address;
2292 * uint32_t spp_hbinterval;
2293 * uint16_t spp_pathmaxrxt;
2294 * uint32_t spp_pathmtu;
2295 * uint32_t spp_sackdelay;
2296 * uint32_t spp_flags;
2297 * uint32_t spp_ipv6_flowlabel;
2301 * spp_assoc_id - (one-to-many style socket) This is filled in the
2302 * application, and identifies the association for
2304 * spp_address - This specifies which address is of interest.
2305 * spp_hbinterval - This contains the value of the heartbeat interval,
2306 * in milliseconds. If a value of zero
2307 * is present in this field then no changes are to
2308 * be made to this parameter.
2309 * spp_pathmaxrxt - This contains the maximum number of
2310 * retransmissions before this address shall be
2311 * considered unreachable. If a value of zero
2312 * is present in this field then no changes are to
2313 * be made to this parameter.
2314 * spp_pathmtu - When Path MTU discovery is disabled the value
2315 * specified here will be the "fixed" path mtu.
2316 * Note that if the spp_address field is empty
2317 * then all associations on this address will
2318 * have this fixed path mtu set upon them.
2320 * spp_sackdelay - When delayed sack is enabled, this value specifies
2321 * the number of milliseconds that sacks will be delayed
2322 * for. This value will apply to all addresses of an
2323 * association if the spp_address field is empty. Note
2324 * also, that if delayed sack is enabled and this
2325 * value is set to 0, no change is made to the last
2326 * recorded delayed sack timer value.
2328 * spp_flags - These flags are used to control various features
2329 * on an association. The flag field may contain
2330 * zero or more of the following options.
2332 * SPP_HB_ENABLE - Enable heartbeats on the
2333 * specified address. Note that if the address
2334 * field is empty all addresses for the association
2335 * have heartbeats enabled upon them.
2337 * SPP_HB_DISABLE - Disable heartbeats on the
2338 * speicifed address. Note that if the address
2339 * field is empty all addresses for the association
2340 * will have their heartbeats disabled. Note also
2341 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2342 * mutually exclusive, only one of these two should
2343 * be specified. Enabling both fields will have
2344 * undetermined results.
2346 * SPP_HB_DEMAND - Request a user initiated heartbeat
2347 * to be made immediately.
2349 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2350 * heartbeat delayis to be set to the value of 0
2353 * SPP_PMTUD_ENABLE - This field will enable PMTU
2354 * discovery upon the specified address. Note that
2355 * if the address feild is empty then all addresses
2356 * on the association are effected.
2358 * SPP_PMTUD_DISABLE - This field will disable PMTU
2359 * discovery upon the specified address. Note that
2360 * if the address feild is empty then all addresses
2361 * on the association are effected. Not also that
2362 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2363 * exclusive. Enabling both will have undetermined
2366 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2367 * on delayed sack. The time specified in spp_sackdelay
2368 * is used to specify the sack delay for this address. Note
2369 * that if spp_address is empty then all addresses will
2370 * enable delayed sack and take on the sack delay
2371 * value specified in spp_sackdelay.
2372 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2373 * off delayed sack. If the spp_address field is blank then
2374 * delayed sack is disabled for the entire association. Note
2375 * also that this field is mutually exclusive to
2376 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2379 * SPP_IPV6_FLOWLABEL: Setting this flag enables the
2380 * setting of the IPV6 flow label value. The value is
2381 * contained in the spp_ipv6_flowlabel field.
2382 * Upon retrieval, this flag will be set to indicate that
2383 * the spp_ipv6_flowlabel field has a valid value returned.
2384 * If a specific destination address is set (in the
2385 * spp_address field), then the value returned is that of
2386 * the address. If just an association is specified (and
2387 * no address), then the association's default flow label
2388 * is returned. If neither an association nor a destination
2389 * is specified, then the socket's default flow label is
2390 * returned. For non-IPv6 sockets, this flag will be left
2393 * SPP_DSCP: Setting this flag enables the setting of the
2394 * Differentiated Services Code Point (DSCP) value
2395 * associated with either the association or a specific
2396 * address. The value is obtained in the spp_dscp field.
2397 * Upon retrieval, this flag will be set to indicate that
2398 * the spp_dscp field has a valid value returned. If a
2399 * specific destination address is set when called (in the
2400 * spp_address field), then that specific destination
2401 * address's DSCP value is returned. If just an association
2402 * is specified, then the association's default DSCP is
2403 * returned. If neither an association nor a destination is
2404 * specified, then the socket's default DSCP is returned.
2406 * spp_ipv6_flowlabel
2407 * - This field is used in conjunction with the
2408 * SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
2409 * The 20 least significant bits are used for the flow
2410 * label. This setting has precedence over any IPv6-layer
2413 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
2414 * and contains the DSCP. The 6 most significant bits are
2415 * used for the DSCP. This setting has precedence over any
2416 * IPv4- or IPv6- layer setting.
2418 static int sctp_apply_peer_addr_params(struct sctp_paddrparams
*params
,
2419 struct sctp_transport
*trans
,
2420 struct sctp_association
*asoc
,
2421 struct sctp_sock
*sp
,
2424 int sackdelay_change
)
2428 if (params
->spp_flags
& SPP_HB_DEMAND
&& trans
) {
2429 error
= sctp_primitive_REQUESTHEARTBEAT(trans
->asoc
->base
.net
,
2430 trans
->asoc
, trans
);
2435 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2436 * this field is ignored. Note also that a value of zero indicates
2437 * the current setting should be left unchanged.
2439 if (params
->spp_flags
& SPP_HB_ENABLE
) {
2441 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2442 * set. This lets us use 0 value when this flag
2445 if (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)
2446 params
->spp_hbinterval
= 0;
2448 if (params
->spp_hbinterval
||
2449 (params
->spp_flags
& SPP_HB_TIME_IS_ZERO
)) {
2452 msecs_to_jiffies(params
->spp_hbinterval
);
2455 msecs_to_jiffies(params
->spp_hbinterval
);
2457 sp
->hbinterval
= params
->spp_hbinterval
;
2464 trans
->param_flags
=
2465 (trans
->param_flags
& ~SPP_HB
) | hb_change
;
2468 (asoc
->param_flags
& ~SPP_HB
) | hb_change
;
2471 (sp
->param_flags
& ~SPP_HB
) | hb_change
;
2475 /* When Path MTU discovery is disabled the value specified here will
2476 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2477 * include the flag SPP_PMTUD_DISABLE for this field to have any
2480 if ((params
->spp_flags
& SPP_PMTUD_DISABLE
) && params
->spp_pathmtu
) {
2482 trans
->pathmtu
= params
->spp_pathmtu
;
2483 sctp_assoc_sync_pmtu(asoc
);
2485 sctp_assoc_set_pmtu(asoc
, params
->spp_pathmtu
);
2487 sp
->pathmtu
= params
->spp_pathmtu
;
2493 int update
= (trans
->param_flags
& SPP_PMTUD_DISABLE
) &&
2494 (params
->spp_flags
& SPP_PMTUD_ENABLE
);
2495 trans
->param_flags
=
2496 (trans
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2498 sctp_transport_pmtu(trans
, sctp_opt2sk(sp
));
2499 sctp_assoc_sync_pmtu(asoc
);
2501 sctp_transport_pl_reset(trans
);
2504 (asoc
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2507 (sp
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2511 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2512 * value of this field is ignored. Note also that a value of zero
2513 * indicates the current setting should be left unchanged.
2515 if ((params
->spp_flags
& SPP_SACKDELAY_ENABLE
) && params
->spp_sackdelay
) {
2518 msecs_to_jiffies(params
->spp_sackdelay
);
2521 msecs_to_jiffies(params
->spp_sackdelay
);
2523 sp
->sackdelay
= params
->spp_sackdelay
;
2527 if (sackdelay_change
) {
2529 trans
->param_flags
=
2530 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2534 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2538 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2543 /* Note that a value of zero indicates the current setting should be
2546 if (params
->spp_pathmaxrxt
) {
2548 trans
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2550 asoc
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2552 sp
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2556 if (params
->spp_flags
& SPP_IPV6_FLOWLABEL
) {
2558 if (trans
->ipaddr
.sa
.sa_family
== AF_INET6
) {
2559 trans
->flowlabel
= params
->spp_ipv6_flowlabel
&
2560 SCTP_FLOWLABEL_VAL_MASK
;
2561 trans
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2564 struct sctp_transport
*t
;
2566 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
,
2568 if (t
->ipaddr
.sa
.sa_family
!= AF_INET6
)
2570 t
->flowlabel
= params
->spp_ipv6_flowlabel
&
2571 SCTP_FLOWLABEL_VAL_MASK
;
2572 t
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2574 asoc
->flowlabel
= params
->spp_ipv6_flowlabel
&
2575 SCTP_FLOWLABEL_VAL_MASK
;
2576 asoc
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2577 } else if (sctp_opt2sk(sp
)->sk_family
== AF_INET6
) {
2578 sp
->flowlabel
= params
->spp_ipv6_flowlabel
&
2579 SCTP_FLOWLABEL_VAL_MASK
;
2580 sp
->flowlabel
|= SCTP_FLOWLABEL_SET_MASK
;
2584 if (params
->spp_flags
& SPP_DSCP
) {
2586 trans
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2587 trans
->dscp
|= SCTP_DSCP_SET_MASK
;
2589 struct sctp_transport
*t
;
2591 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
,
2593 t
->dscp
= params
->spp_dscp
&
2595 t
->dscp
|= SCTP_DSCP_SET_MASK
;
2597 asoc
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2598 asoc
->dscp
|= SCTP_DSCP_SET_MASK
;
2600 sp
->dscp
= params
->spp_dscp
& SCTP_DSCP_VAL_MASK
;
2601 sp
->dscp
|= SCTP_DSCP_SET_MASK
;
2608 static int sctp_setsockopt_peer_addr_params(struct sock
*sk
,
2609 struct sctp_paddrparams
*params
,
2610 unsigned int optlen
)
2612 struct sctp_transport
*trans
= NULL
;
2613 struct sctp_association
*asoc
= NULL
;
2614 struct sctp_sock
*sp
= sctp_sk(sk
);
2616 int hb_change
, pmtud_change
, sackdelay_change
;
2618 if (optlen
== ALIGN(offsetof(struct sctp_paddrparams
,
2619 spp_ipv6_flowlabel
), 4)) {
2620 if (params
->spp_flags
& (SPP_DSCP
| SPP_IPV6_FLOWLABEL
))
2622 } else if (optlen
!= sizeof(*params
)) {
2626 /* Validate flags and value parameters. */
2627 hb_change
= params
->spp_flags
& SPP_HB
;
2628 pmtud_change
= params
->spp_flags
& SPP_PMTUD
;
2629 sackdelay_change
= params
->spp_flags
& SPP_SACKDELAY
;
2631 if (hb_change
== SPP_HB
||
2632 pmtud_change
== SPP_PMTUD
||
2633 sackdelay_change
== SPP_SACKDELAY
||
2634 params
->spp_sackdelay
> 500 ||
2635 (params
->spp_pathmtu
&&
2636 params
->spp_pathmtu
< SCTP_DEFAULT_MINSEGMENT
))
2639 /* If an address other than INADDR_ANY is specified, and
2640 * no transport is found, then the request is invalid.
2642 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
->spp_address
)) {
2643 trans
= sctp_addr_id2transport(sk
, ¶ms
->spp_address
,
2644 params
->spp_assoc_id
);
2649 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
2650 * socket is a one to many style socket, and an association
2651 * was not found, then the id was invalid.
2653 asoc
= sctp_id2assoc(sk
, params
->spp_assoc_id
);
2654 if (!asoc
&& params
->spp_assoc_id
!= SCTP_FUTURE_ASSOC
&&
2655 sctp_style(sk
, UDP
))
2658 /* Heartbeat demand can only be sent on a transport or
2659 * association, but not a socket.
2661 if (params
->spp_flags
& SPP_HB_DEMAND
&& !trans
&& !asoc
)
2664 /* Process parameters. */
2665 error
= sctp_apply_peer_addr_params(params
, trans
, asoc
, sp
,
2666 hb_change
, pmtud_change
,
2672 /* If changes are for association, also apply parameters to each
2675 if (!trans
&& asoc
) {
2676 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2678 sctp_apply_peer_addr_params(params
, trans
, asoc
, sp
,
2679 hb_change
, pmtud_change
,
2687 static inline __u32
sctp_spp_sackdelay_enable(__u32 param_flags
)
2689 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_ENABLE
;
2692 static inline __u32
sctp_spp_sackdelay_disable(__u32 param_flags
)
2694 return (param_flags
& ~SPP_SACKDELAY
) | SPP_SACKDELAY_DISABLE
;
2697 static void sctp_apply_asoc_delayed_ack(struct sctp_sack_info
*params
,
2698 struct sctp_association
*asoc
)
2700 struct sctp_transport
*trans
;
2702 if (params
->sack_delay
) {
2703 asoc
->sackdelay
= msecs_to_jiffies(params
->sack_delay
);
2705 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2707 if (params
->sack_freq
== 1) {
2709 sctp_spp_sackdelay_disable(asoc
->param_flags
);
2710 } else if (params
->sack_freq
> 1) {
2711 asoc
->sackfreq
= params
->sack_freq
;
2713 sctp_spp_sackdelay_enable(asoc
->param_flags
);
2716 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
2718 if (params
->sack_delay
) {
2719 trans
->sackdelay
= msecs_to_jiffies(params
->sack_delay
);
2720 trans
->param_flags
=
2721 sctp_spp_sackdelay_enable(trans
->param_flags
);
2723 if (params
->sack_freq
== 1) {
2724 trans
->param_flags
=
2725 sctp_spp_sackdelay_disable(trans
->param_flags
);
2726 } else if (params
->sack_freq
> 1) {
2727 trans
->sackfreq
= params
->sack_freq
;
2728 trans
->param_flags
=
2729 sctp_spp_sackdelay_enable(trans
->param_flags
);
2735 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
2737 * This option will effect the way delayed acks are performed. This
2738 * option allows you to get or set the delayed ack time, in
2739 * milliseconds. It also allows changing the delayed ack frequency.
2740 * Changing the frequency to 1 disables the delayed sack algorithm. If
2741 * the assoc_id is 0, then this sets or gets the endpoints default
2742 * values. If the assoc_id field is non-zero, then the set or get
2743 * effects the specified association for the one to many model (the
2744 * assoc_id field is ignored by the one to one model). Note that if
2745 * sack_delay or sack_freq are 0 when setting this option, then the
2746 * current values will remain unchanged.
2748 * struct sctp_sack_info {
2749 * sctp_assoc_t sack_assoc_id;
2750 * uint32_t sack_delay;
2751 * uint32_t sack_freq;
2754 * sack_assoc_id - This parameter, indicates which association the user
2755 * is performing an action upon. Note that if this field's value is
2756 * zero then the endpoints default value is changed (effecting future
2757 * associations only).
2759 * sack_delay - This parameter contains the number of milliseconds that
2760 * the user is requesting the delayed ACK timer be set to. Note that
2761 * this value is defined in the standard to be between 200 and 500
2764 * sack_freq - This parameter contains the number of packets that must
2765 * be received before a sack is sent without waiting for the delay
2766 * timer to expire. The default value for this is 2, setting this
2767 * value to 1 will disable the delayed sack algorithm.
2769 static int __sctp_setsockopt_delayed_ack(struct sock
*sk
,
2770 struct sctp_sack_info
*params
)
2772 struct sctp_sock
*sp
= sctp_sk(sk
);
2773 struct sctp_association
*asoc
;
2775 /* Validate value parameter. */
2776 if (params
->sack_delay
> 500)
2779 /* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
2780 * socket is a one to many style socket, and an association
2781 * was not found, then the id was invalid.
2783 asoc
= sctp_id2assoc(sk
, params
->sack_assoc_id
);
2784 if (!asoc
&& params
->sack_assoc_id
> SCTP_ALL_ASSOC
&&
2785 sctp_style(sk
, UDP
))
2789 sctp_apply_asoc_delayed_ack(params
, asoc
);
2794 if (sctp_style(sk
, TCP
))
2795 params
->sack_assoc_id
= SCTP_FUTURE_ASSOC
;
2797 if (params
->sack_assoc_id
== SCTP_FUTURE_ASSOC
||
2798 params
->sack_assoc_id
== SCTP_ALL_ASSOC
) {
2799 if (params
->sack_delay
) {
2800 sp
->sackdelay
= params
->sack_delay
;
2802 sctp_spp_sackdelay_enable(sp
->param_flags
);
2804 if (params
->sack_freq
== 1) {
2806 sctp_spp_sackdelay_disable(sp
->param_flags
);
2807 } else if (params
->sack_freq
> 1) {
2808 sp
->sackfreq
= params
->sack_freq
;
2810 sctp_spp_sackdelay_enable(sp
->param_flags
);
2814 if (params
->sack_assoc_id
== SCTP_CURRENT_ASSOC
||
2815 params
->sack_assoc_id
== SCTP_ALL_ASSOC
)
2816 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
)
2817 sctp_apply_asoc_delayed_ack(params
, asoc
);
2822 static int sctp_setsockopt_delayed_ack(struct sock
*sk
,
2823 struct sctp_sack_info
*params
,
2824 unsigned int optlen
)
2826 if (optlen
== sizeof(struct sctp_assoc_value
)) {
2827 struct sctp_assoc_value
*v
= (struct sctp_assoc_value
*)params
;
2828 struct sctp_sack_info p
;
2830 pr_warn_ratelimited(DEPRECATED
2832 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2833 "Use struct sctp_sack_info instead\n",
2834 current
->comm
, task_pid_nr(current
));
2836 p
.sack_assoc_id
= v
->assoc_id
;
2837 p
.sack_delay
= v
->assoc_value
;
2838 p
.sack_freq
= v
->assoc_value
? 0 : 1;
2839 return __sctp_setsockopt_delayed_ack(sk
, &p
);
2842 if (optlen
!= sizeof(struct sctp_sack_info
))
2844 if (params
->sack_delay
== 0 && params
->sack_freq
== 0)
2846 return __sctp_setsockopt_delayed_ack(sk
, params
);
2849 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2851 * Applications can specify protocol parameters for the default association
2852 * initialization. The option name argument to setsockopt() and getsockopt()
2855 * Setting initialization parameters is effective only on an unconnected
2856 * socket (for UDP-style sockets only future associations are effected
2857 * by the change). With TCP-style sockets, this option is inherited by
2858 * sockets derived from a listener socket.
2860 static int sctp_setsockopt_initmsg(struct sock
*sk
, struct sctp_initmsg
*sinit
,
2861 unsigned int optlen
)
2863 struct sctp_sock
*sp
= sctp_sk(sk
);
2865 if (optlen
!= sizeof(struct sctp_initmsg
))
2868 if (sinit
->sinit_num_ostreams
)
2869 sp
->initmsg
.sinit_num_ostreams
= sinit
->sinit_num_ostreams
;
2870 if (sinit
->sinit_max_instreams
)
2871 sp
->initmsg
.sinit_max_instreams
= sinit
->sinit_max_instreams
;
2872 if (sinit
->sinit_max_attempts
)
2873 sp
->initmsg
.sinit_max_attempts
= sinit
->sinit_max_attempts
;
2874 if (sinit
->sinit_max_init_timeo
)
2875 sp
->initmsg
.sinit_max_init_timeo
= sinit
->sinit_max_init_timeo
;
2881 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2883 * Applications that wish to use the sendto() system call may wish to
2884 * specify a default set of parameters that would normally be supplied
2885 * through the inclusion of ancillary data. This socket option allows
2886 * such an application to set the default sctp_sndrcvinfo structure.
2887 * The application that wishes to use this socket option simply passes
2888 * in to this call the sctp_sndrcvinfo structure defined in Section
2889 * 5.2.2) The input parameters accepted by this call include
2890 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2891 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2892 * to this call if the caller is using the UDP model.
2894 static int sctp_setsockopt_default_send_param(struct sock
*sk
,
2895 struct sctp_sndrcvinfo
*info
,
2896 unsigned int optlen
)
2898 struct sctp_sock
*sp
= sctp_sk(sk
);
2899 struct sctp_association
*asoc
;
2901 if (optlen
!= sizeof(*info
))
2903 if (info
->sinfo_flags
&
2904 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
2905 SCTP_ABORT
| SCTP_EOF
))
2908 asoc
= sctp_id2assoc(sk
, info
->sinfo_assoc_id
);
2909 if (!asoc
&& info
->sinfo_assoc_id
> SCTP_ALL_ASSOC
&&
2910 sctp_style(sk
, UDP
))
2914 asoc
->default_stream
= info
->sinfo_stream
;
2915 asoc
->default_flags
= info
->sinfo_flags
;
2916 asoc
->default_ppid
= info
->sinfo_ppid
;
2917 asoc
->default_context
= info
->sinfo_context
;
2918 asoc
->default_timetolive
= info
->sinfo_timetolive
;
2923 if (sctp_style(sk
, TCP
))
2924 info
->sinfo_assoc_id
= SCTP_FUTURE_ASSOC
;
2926 if (info
->sinfo_assoc_id
== SCTP_FUTURE_ASSOC
||
2927 info
->sinfo_assoc_id
== SCTP_ALL_ASSOC
) {
2928 sp
->default_stream
= info
->sinfo_stream
;
2929 sp
->default_flags
= info
->sinfo_flags
;
2930 sp
->default_ppid
= info
->sinfo_ppid
;
2931 sp
->default_context
= info
->sinfo_context
;
2932 sp
->default_timetolive
= info
->sinfo_timetolive
;
2935 if (info
->sinfo_assoc_id
== SCTP_CURRENT_ASSOC
||
2936 info
->sinfo_assoc_id
== SCTP_ALL_ASSOC
) {
2937 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
) {
2938 asoc
->default_stream
= info
->sinfo_stream
;
2939 asoc
->default_flags
= info
->sinfo_flags
;
2940 asoc
->default_ppid
= info
->sinfo_ppid
;
2941 asoc
->default_context
= info
->sinfo_context
;
2942 asoc
->default_timetolive
= info
->sinfo_timetolive
;
2949 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2950 * (SCTP_DEFAULT_SNDINFO)
2952 static int sctp_setsockopt_default_sndinfo(struct sock
*sk
,
2953 struct sctp_sndinfo
*info
,
2954 unsigned int optlen
)
2956 struct sctp_sock
*sp
= sctp_sk(sk
);
2957 struct sctp_association
*asoc
;
2959 if (optlen
!= sizeof(*info
))
2961 if (info
->snd_flags
&
2962 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
2963 SCTP_ABORT
| SCTP_EOF
))
2966 asoc
= sctp_id2assoc(sk
, info
->snd_assoc_id
);
2967 if (!asoc
&& info
->snd_assoc_id
> SCTP_ALL_ASSOC
&&
2968 sctp_style(sk
, UDP
))
2972 asoc
->default_stream
= info
->snd_sid
;
2973 asoc
->default_flags
= info
->snd_flags
;
2974 asoc
->default_ppid
= info
->snd_ppid
;
2975 asoc
->default_context
= info
->snd_context
;
2980 if (sctp_style(sk
, TCP
))
2981 info
->snd_assoc_id
= SCTP_FUTURE_ASSOC
;
2983 if (info
->snd_assoc_id
== SCTP_FUTURE_ASSOC
||
2984 info
->snd_assoc_id
== SCTP_ALL_ASSOC
) {
2985 sp
->default_stream
= info
->snd_sid
;
2986 sp
->default_flags
= info
->snd_flags
;
2987 sp
->default_ppid
= info
->snd_ppid
;
2988 sp
->default_context
= info
->snd_context
;
2991 if (info
->snd_assoc_id
== SCTP_CURRENT_ASSOC
||
2992 info
->snd_assoc_id
== SCTP_ALL_ASSOC
) {
2993 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
) {
2994 asoc
->default_stream
= info
->snd_sid
;
2995 asoc
->default_flags
= info
->snd_flags
;
2996 asoc
->default_ppid
= info
->snd_ppid
;
2997 asoc
->default_context
= info
->snd_context
;
3004 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
3006 * Requests that the local SCTP stack use the enclosed peer address as
3007 * the association primary. The enclosed address must be one of the
3008 * association peer's addresses.
3010 static int sctp_setsockopt_primary_addr(struct sock
*sk
, struct sctp_prim
*prim
,
3011 unsigned int optlen
)
3013 struct sctp_transport
*trans
;
3017 if (optlen
!= sizeof(struct sctp_prim
))
3020 /* Allow security module to validate address but need address len. */
3021 af
= sctp_get_af_specific(prim
->ssp_addr
.ss_family
);
3025 err
= security_sctp_bind_connect(sk
, SCTP_PRIMARY_ADDR
,
3026 (struct sockaddr
*)&prim
->ssp_addr
,
3031 trans
= sctp_addr_id2transport(sk
, &prim
->ssp_addr
, prim
->ssp_assoc_id
);
3035 sctp_assoc_set_primary(trans
->asoc
, trans
);
3041 * 7.1.5 SCTP_NODELAY
3043 * Turn on/off any Nagle-like algorithm. This means that packets are
3044 * generally sent as soon as possible and no unnecessary delays are
3045 * introduced, at the cost of more packets in the network. Expects an
3046 * integer boolean flag.
3048 static int sctp_setsockopt_nodelay(struct sock
*sk
, int *val
,
3049 unsigned int optlen
)
3051 if (optlen
< sizeof(int))
3053 sctp_sk(sk
)->nodelay
= (*val
== 0) ? 0 : 1;
3059 * 7.1.1 SCTP_RTOINFO
3061 * The protocol parameters used to initialize and bound retransmission
3062 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3063 * and modify these parameters.
3064 * All parameters are time values, in milliseconds. A value of 0, when
3065 * modifying the parameters, indicates that the current value should not
3069 static int sctp_setsockopt_rtoinfo(struct sock
*sk
,
3070 struct sctp_rtoinfo
*rtoinfo
,
3071 unsigned int optlen
)
3073 struct sctp_association
*asoc
;
3074 unsigned long rto_min
, rto_max
;
3075 struct sctp_sock
*sp
= sctp_sk(sk
);
3077 if (optlen
!= sizeof (struct sctp_rtoinfo
))
3080 asoc
= sctp_id2assoc(sk
, rtoinfo
->srto_assoc_id
);
3082 /* Set the values to the specific association */
3083 if (!asoc
&& rtoinfo
->srto_assoc_id
!= SCTP_FUTURE_ASSOC
&&
3084 sctp_style(sk
, UDP
))
3087 rto_max
= rtoinfo
->srto_max
;
3088 rto_min
= rtoinfo
->srto_min
;
3091 rto_max
= asoc
? msecs_to_jiffies(rto_max
) : rto_max
;
3093 rto_max
= asoc
? asoc
->rto_max
: sp
->rtoinfo
.srto_max
;
3096 rto_min
= asoc
? msecs_to_jiffies(rto_min
) : rto_min
;
3098 rto_min
= asoc
? asoc
->rto_min
: sp
->rtoinfo
.srto_min
;
3100 if (rto_min
> rto_max
)
3104 if (rtoinfo
->srto_initial
!= 0)
3106 msecs_to_jiffies(rtoinfo
->srto_initial
);
3107 asoc
->rto_max
= rto_max
;
3108 asoc
->rto_min
= rto_min
;
3110 /* If there is no association or the association-id = 0
3111 * set the values to the endpoint.
3113 if (rtoinfo
->srto_initial
!= 0)
3114 sp
->rtoinfo
.srto_initial
= rtoinfo
->srto_initial
;
3115 sp
->rtoinfo
.srto_max
= rto_max
;
3116 sp
->rtoinfo
.srto_min
= rto_min
;
3124 * 7.1.2 SCTP_ASSOCINFO
3126 * This option is used to tune the maximum retransmission attempts
3127 * of the association.
3128 * Returns an error if the new association retransmission value is
3129 * greater than the sum of the retransmission value of the peer.
3130 * See [SCTP] for more information.
3133 static int sctp_setsockopt_associnfo(struct sock
*sk
,
3134 struct sctp_assocparams
*assocparams
,
3135 unsigned int optlen
)
3138 struct sctp_association
*asoc
;
3140 if (optlen
!= sizeof(struct sctp_assocparams
))
3143 asoc
= sctp_id2assoc(sk
, assocparams
->sasoc_assoc_id
);
3145 if (!asoc
&& assocparams
->sasoc_assoc_id
!= SCTP_FUTURE_ASSOC
&&
3146 sctp_style(sk
, UDP
))
3149 /* Set the values to the specific association */
3151 if (assocparams
->sasoc_asocmaxrxt
!= 0) {
3154 struct sctp_transport
*peer_addr
;
3156 list_for_each_entry(peer_addr
, &asoc
->peer
.transport_addr_list
,
3158 path_sum
+= peer_addr
->pathmaxrxt
;
3162 /* Only validate asocmaxrxt if we have more than
3163 * one path/transport. We do this because path
3164 * retransmissions are only counted when we have more
3168 assocparams
->sasoc_asocmaxrxt
> path_sum
)
3171 asoc
->max_retrans
= assocparams
->sasoc_asocmaxrxt
;
3174 if (assocparams
->sasoc_cookie_life
!= 0)
3176 ms_to_ktime(assocparams
->sasoc_cookie_life
);
3178 /* Set the values to the endpoint */
3179 struct sctp_sock
*sp
= sctp_sk(sk
);
3181 if (assocparams
->sasoc_asocmaxrxt
!= 0)
3182 sp
->assocparams
.sasoc_asocmaxrxt
=
3183 assocparams
->sasoc_asocmaxrxt
;
3184 if (assocparams
->sasoc_cookie_life
!= 0)
3185 sp
->assocparams
.sasoc_cookie_life
=
3186 assocparams
->sasoc_cookie_life
;
3192 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3194 * This socket option is a boolean flag which turns on or off mapped V4
3195 * addresses. If this option is turned on and the socket is type
3196 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3197 * If this option is turned off, then no mapping will be done of V4
3198 * addresses and a user will receive both PF_INET6 and PF_INET type
3199 * addresses on the socket.
3201 static int sctp_setsockopt_mappedv4(struct sock
*sk
, int *val
,
3202 unsigned int optlen
)
3204 struct sctp_sock
*sp
= sctp_sk(sk
);
3206 if (optlen
< sizeof(int))
3217 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3218 * This option will get or set the maximum size to put in any outgoing
3219 * SCTP DATA chunk. If a message is larger than this size it will be
3220 * fragmented by SCTP into the specified size. Note that the underlying
3221 * SCTP implementation may fragment into smaller sized chunks when the
3222 * PMTU of the underlying association is smaller than the value set by
3223 * the user. The default value for this option is '0' which indicates
3224 * the user is NOT limiting fragmentation and only the PMTU will effect
3225 * SCTP's choice of DATA chunk size. Note also that values set larger
3226 * than the maximum size of an IP datagram will effectively let SCTP
3227 * control fragmentation (i.e. the same as setting this option to 0).
3229 * The following structure is used to access and modify this parameter:
3231 * struct sctp_assoc_value {
3232 * sctp_assoc_t assoc_id;
3233 * uint32_t assoc_value;
3236 * assoc_id: This parameter is ignored for one-to-one style sockets.
3237 * For one-to-many style sockets this parameter indicates which
3238 * association the user is performing an action upon. Note that if
3239 * this field's value is zero then the endpoints default value is
3240 * changed (effecting future associations only).
3241 * assoc_value: This parameter specifies the maximum size in bytes.
3243 static int sctp_setsockopt_maxseg(struct sock
*sk
,
3244 struct sctp_assoc_value
*params
,
3245 unsigned int optlen
)
3247 struct sctp_sock
*sp
= sctp_sk(sk
);
3248 struct sctp_association
*asoc
;
3249 sctp_assoc_t assoc_id
;
3252 if (optlen
== sizeof(int)) {
3253 pr_warn_ratelimited(DEPRECATED
3255 "Use of int in maxseg socket option.\n"
3256 "Use struct sctp_assoc_value instead\n",
3257 current
->comm
, task_pid_nr(current
));
3258 assoc_id
= SCTP_FUTURE_ASSOC
;
3259 val
= *(int *)params
;
3260 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3261 assoc_id
= params
->assoc_id
;
3262 val
= params
->assoc_value
;
3267 asoc
= sctp_id2assoc(sk
, assoc_id
);
3268 if (!asoc
&& assoc_id
!= SCTP_FUTURE_ASSOC
&&
3269 sctp_style(sk
, UDP
))
3273 int min_len
, max_len
;
3274 __u16 datasize
= asoc
? sctp_datachk_len(&asoc
->stream
) :
3275 sizeof(struct sctp_data_chunk
);
3277 min_len
= sctp_min_frag_point(sp
, datasize
);
3278 max_len
= SCTP_MAX_CHUNK_LEN
- datasize
;
3280 if (val
< min_len
|| val
> max_len
)
3285 asoc
->user_frag
= val
;
3286 sctp_assoc_update_frag_point(asoc
);
3288 sp
->user_frag
= val
;
3296 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3298 * Requests that the peer mark the enclosed address as the association
3299 * primary. The enclosed address must be one of the association's
3300 * locally bound addresses. The following structure is used to make a
3301 * set primary request:
3303 static int sctp_setsockopt_peer_primary_addr(struct sock
*sk
,
3304 struct sctp_setpeerprim
*prim
,
3305 unsigned int optlen
)
3307 struct sctp_sock
*sp
;
3308 struct sctp_association
*asoc
= NULL
;
3309 struct sctp_chunk
*chunk
;
3315 if (!sp
->ep
->asconf_enable
)
3318 if (optlen
!= sizeof(struct sctp_setpeerprim
))
3321 asoc
= sctp_id2assoc(sk
, prim
->sspp_assoc_id
);
3325 if (!asoc
->peer
.asconf_capable
)
3328 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_SET_PRIMARY
)
3331 if (!sctp_state(asoc
, ESTABLISHED
))
3334 af
= sctp_get_af_specific(prim
->sspp_addr
.ss_family
);
3338 if (!af
->addr_valid((union sctp_addr
*)&prim
->sspp_addr
, sp
, NULL
))
3339 return -EADDRNOTAVAIL
;
3341 if (!sctp_assoc_lookup_laddr(asoc
, (union sctp_addr
*)&prim
->sspp_addr
))
3342 return -EADDRNOTAVAIL
;
3344 /* Allow security module to validate address. */
3345 err
= security_sctp_bind_connect(sk
, SCTP_SET_PEER_PRIMARY_ADDR
,
3346 (struct sockaddr
*)&prim
->sspp_addr
,
3351 /* Create an ASCONF chunk with SET_PRIMARY parameter */
3352 chunk
= sctp_make_asconf_set_prim(asoc
,
3353 (union sctp_addr
*)&prim
->sspp_addr
);
3357 err
= sctp_send_asconf(asoc
, chunk
);
3359 pr_debug("%s: we set peer primary addr primitively\n", __func__
);
3364 static int sctp_setsockopt_adaptation_layer(struct sock
*sk
,
3365 struct sctp_setadaptation
*adapt
,
3366 unsigned int optlen
)
3368 if (optlen
!= sizeof(struct sctp_setadaptation
))
3371 sctp_sk(sk
)->adaptation_ind
= adapt
->ssb_adaptation_ind
;
3377 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
3379 * The context field in the sctp_sndrcvinfo structure is normally only
3380 * used when a failed message is retrieved holding the value that was
3381 * sent down on the actual send call. This option allows the setting of
3382 * a default context on an association basis that will be received on
3383 * reading messages from the peer. This is especially helpful in the
3384 * one-2-many model for an application to keep some reference to an
3385 * internal state machine that is processing messages on the
3386 * association. Note that the setting of this value only effects
3387 * received messages from the peer and does not effect the value that is
3388 * saved with outbound messages.
3390 static int sctp_setsockopt_context(struct sock
*sk
,
3391 struct sctp_assoc_value
*params
,
3392 unsigned int optlen
)
3394 struct sctp_sock
*sp
= sctp_sk(sk
);
3395 struct sctp_association
*asoc
;
3397 if (optlen
!= sizeof(struct sctp_assoc_value
))
3400 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
3401 if (!asoc
&& params
->assoc_id
> SCTP_ALL_ASSOC
&&
3402 sctp_style(sk
, UDP
))
3406 asoc
->default_rcv_context
= params
->assoc_value
;
3411 if (sctp_style(sk
, TCP
))
3412 params
->assoc_id
= SCTP_FUTURE_ASSOC
;
3414 if (params
->assoc_id
== SCTP_FUTURE_ASSOC
||
3415 params
->assoc_id
== SCTP_ALL_ASSOC
)
3416 sp
->default_rcv_context
= params
->assoc_value
;
3418 if (params
->assoc_id
== SCTP_CURRENT_ASSOC
||
3419 params
->assoc_id
== SCTP_ALL_ASSOC
)
3420 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
)
3421 asoc
->default_rcv_context
= params
->assoc_value
;
3427 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3429 * This options will at a minimum specify if the implementation is doing
3430 * fragmented interleave. Fragmented interleave, for a one to many
3431 * socket, is when subsequent calls to receive a message may return
3432 * parts of messages from different associations. Some implementations
3433 * may allow you to turn this value on or off. If so, when turned off,
3434 * no fragment interleave will occur (which will cause a head of line
3435 * blocking amongst multiple associations sharing the same one to many
3436 * socket). When this option is turned on, then each receive call may
3437 * come from a different association (thus the user must receive data
3438 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3439 * association each receive belongs to.
3441 * This option takes a boolean value. A non-zero value indicates that
3442 * fragmented interleave is on. A value of zero indicates that
3443 * fragmented interleave is off.
3445 * Note that it is important that an implementation that allows this
3446 * option to be turned on, have it off by default. Otherwise an unaware
3447 * application using the one to many model may become confused and act
3450 static int sctp_setsockopt_fragment_interleave(struct sock
*sk
, int *val
,
3451 unsigned int optlen
)
3453 if (optlen
!= sizeof(int))
3456 sctp_sk(sk
)->frag_interleave
= !!*val
;
3458 if (!sctp_sk(sk
)->frag_interleave
)
3459 sctp_sk(sk
)->ep
->intl_enable
= 0;
3465 * 8.1.21. Set or Get the SCTP Partial Delivery Point
3466 * (SCTP_PARTIAL_DELIVERY_POINT)
3468 * This option will set or get the SCTP partial delivery point. This
3469 * point is the size of a message where the partial delivery API will be
3470 * invoked to help free up rwnd space for the peer. Setting this to a
3471 * lower value will cause partial deliveries to happen more often. The
3472 * calls argument is an integer that sets or gets the partial delivery
3473 * point. Note also that the call will fail if the user attempts to set
3474 * this value larger than the socket receive buffer size.
3476 * Note that any single message having a length smaller than or equal to
3477 * the SCTP partial delivery point will be delivered in one single read
3478 * call as long as the user provided buffer is large enough to hold the
3481 static int sctp_setsockopt_partial_delivery_point(struct sock
*sk
, u32
*val
,
3482 unsigned int optlen
)
3484 if (optlen
!= sizeof(u32
))
3487 /* Note: We double the receive buffer from what the user sets
3488 * it to be, also initial rwnd is based on rcvbuf/2.
3490 if (*val
> (sk
->sk_rcvbuf
>> 1))
3493 sctp_sk(sk
)->pd_point
= *val
;
3495 return 0; /* is this the right error code? */
3499 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
3501 * This option will allow a user to change the maximum burst of packets
3502 * that can be emitted by this association. Note that the default value
3503 * is 4, and some implementations may restrict this setting so that it
3504 * can only be lowered.
3506 * NOTE: This text doesn't seem right. Do this on a socket basis with
3507 * future associations inheriting the socket value.
3509 static int sctp_setsockopt_maxburst(struct sock
*sk
,
3510 struct sctp_assoc_value
*params
,
3511 unsigned int optlen
)
3513 struct sctp_sock
*sp
= sctp_sk(sk
);
3514 struct sctp_association
*asoc
;
3515 sctp_assoc_t assoc_id
;
3518 if (optlen
== sizeof(int)) {
3519 pr_warn_ratelimited(DEPRECATED
3521 "Use of int in max_burst socket option deprecated.\n"
3522 "Use struct sctp_assoc_value instead\n",
3523 current
->comm
, task_pid_nr(current
));
3524 assoc_id
= SCTP_FUTURE_ASSOC
;
3525 assoc_value
= *((int *)params
);
3526 } else if (optlen
== sizeof(struct sctp_assoc_value
)) {
3527 assoc_id
= params
->assoc_id
;
3528 assoc_value
= params
->assoc_value
;
3532 asoc
= sctp_id2assoc(sk
, assoc_id
);
3533 if (!asoc
&& assoc_id
> SCTP_ALL_ASSOC
&& sctp_style(sk
, UDP
))
3537 asoc
->max_burst
= assoc_value
;
3542 if (sctp_style(sk
, TCP
))
3543 assoc_id
= SCTP_FUTURE_ASSOC
;
3545 if (assoc_id
== SCTP_FUTURE_ASSOC
|| assoc_id
== SCTP_ALL_ASSOC
)
3546 sp
->max_burst
= assoc_value
;
3548 if (assoc_id
== SCTP_CURRENT_ASSOC
|| assoc_id
== SCTP_ALL_ASSOC
)
3549 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
)
3550 asoc
->max_burst
= assoc_value
;
3556 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3558 * This set option adds a chunk type that the user is requesting to be
3559 * received only in an authenticated way. Changes to the list of chunks
3560 * will only effect future associations on the socket.
3562 static int sctp_setsockopt_auth_chunk(struct sock
*sk
,
3563 struct sctp_authchunk
*val
,
3564 unsigned int optlen
)
3566 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3568 if (!ep
->auth_enable
)
3571 if (optlen
!= sizeof(struct sctp_authchunk
))
3574 switch (val
->sauth_chunk
) {
3576 case SCTP_CID_INIT_ACK
:
3577 case SCTP_CID_SHUTDOWN_COMPLETE
:
3582 /* add this chunk id to the endpoint */
3583 return sctp_auth_ep_add_chunkid(ep
, val
->sauth_chunk
);
3587 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3589 * This option gets or sets the list of HMAC algorithms that the local
3590 * endpoint requires the peer to use.
3592 static int sctp_setsockopt_hmac_ident(struct sock
*sk
,
3593 struct sctp_hmacalgo
*hmacs
,
3594 unsigned int optlen
)
3596 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3599 if (!ep
->auth_enable
)
3602 if (optlen
< sizeof(struct sctp_hmacalgo
))
3604 optlen
= min_t(unsigned int, optlen
, sizeof(struct sctp_hmacalgo
) +
3605 SCTP_AUTH_NUM_HMACS
* sizeof(u16
));
3607 idents
= hmacs
->shmac_num_idents
;
3608 if (idents
== 0 || idents
> SCTP_AUTH_NUM_HMACS
||
3609 (idents
* sizeof(u16
)) > (optlen
- sizeof(struct sctp_hmacalgo
)))
3612 return sctp_auth_ep_set_hmacs(ep
, hmacs
);
3616 * 7.1.20. Set a shared key (SCTP_AUTH_KEY)
3618 * This option will set a shared secret key which is used to build an
3619 * association shared key.
3621 static int sctp_setsockopt_auth_key(struct sock
*sk
,
3622 struct sctp_authkey
*authkey
,
3623 unsigned int optlen
)
3625 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3626 struct sctp_association
*asoc
;
3629 if (optlen
<= sizeof(struct sctp_authkey
))
3631 /* authkey->sca_keylength is u16, so optlen can't be bigger than
3634 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+ sizeof(*authkey
));
3636 if (authkey
->sca_keylength
> optlen
- sizeof(*authkey
))
3639 asoc
= sctp_id2assoc(sk
, authkey
->sca_assoc_id
);
3640 if (!asoc
&& authkey
->sca_assoc_id
> SCTP_ALL_ASSOC
&&
3641 sctp_style(sk
, UDP
))
3645 ret
= sctp_auth_set_key(ep
, asoc
, authkey
);
3649 if (sctp_style(sk
, TCP
))
3650 authkey
->sca_assoc_id
= SCTP_FUTURE_ASSOC
;
3652 if (authkey
->sca_assoc_id
== SCTP_FUTURE_ASSOC
||
3653 authkey
->sca_assoc_id
== SCTP_ALL_ASSOC
) {
3654 ret
= sctp_auth_set_key(ep
, asoc
, authkey
);
3661 if (authkey
->sca_assoc_id
== SCTP_CURRENT_ASSOC
||
3662 authkey
->sca_assoc_id
== SCTP_ALL_ASSOC
) {
3663 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
3664 int res
= sctp_auth_set_key(ep
, asoc
, authkey
);
3672 memzero_explicit(authkey
, optlen
);
3677 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3679 * This option will get or set the active shared key to be used to build
3680 * the association shared key.
3682 static int sctp_setsockopt_active_key(struct sock
*sk
,
3683 struct sctp_authkeyid
*val
,
3684 unsigned int optlen
)
3686 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3687 struct sctp_association
*asoc
;
3690 if (optlen
!= sizeof(struct sctp_authkeyid
))
3693 asoc
= sctp_id2assoc(sk
, val
->scact_assoc_id
);
3694 if (!asoc
&& val
->scact_assoc_id
> SCTP_ALL_ASSOC
&&
3695 sctp_style(sk
, UDP
))
3699 return sctp_auth_set_active_key(ep
, asoc
, val
->scact_keynumber
);
3701 if (sctp_style(sk
, TCP
))
3702 val
->scact_assoc_id
= SCTP_FUTURE_ASSOC
;
3704 if (val
->scact_assoc_id
== SCTP_FUTURE_ASSOC
||
3705 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3706 ret
= sctp_auth_set_active_key(ep
, asoc
, val
->scact_keynumber
);
3711 if (val
->scact_assoc_id
== SCTP_CURRENT_ASSOC
||
3712 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3713 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
3714 int res
= sctp_auth_set_active_key(ep
, asoc
,
3715 val
->scact_keynumber
);
3726 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY)
3728 * This set option will delete a shared secret key from use.
3730 static int sctp_setsockopt_del_key(struct sock
*sk
,
3731 struct sctp_authkeyid
*val
,
3732 unsigned int optlen
)
3734 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3735 struct sctp_association
*asoc
;
3738 if (optlen
!= sizeof(struct sctp_authkeyid
))
3741 asoc
= sctp_id2assoc(sk
, val
->scact_assoc_id
);
3742 if (!asoc
&& val
->scact_assoc_id
> SCTP_ALL_ASSOC
&&
3743 sctp_style(sk
, UDP
))
3747 return sctp_auth_del_key_id(ep
, asoc
, val
->scact_keynumber
);
3749 if (sctp_style(sk
, TCP
))
3750 val
->scact_assoc_id
= SCTP_FUTURE_ASSOC
;
3752 if (val
->scact_assoc_id
== SCTP_FUTURE_ASSOC
||
3753 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3754 ret
= sctp_auth_del_key_id(ep
, asoc
, val
->scact_keynumber
);
3759 if (val
->scact_assoc_id
== SCTP_CURRENT_ASSOC
||
3760 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3761 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
3762 int res
= sctp_auth_del_key_id(ep
, asoc
,
3763 val
->scact_keynumber
);
3774 * 8.3.4 Deactivate a Shared Key (SCTP_AUTH_DEACTIVATE_KEY)
3776 * This set option will deactivate a shared secret key.
3778 static int sctp_setsockopt_deactivate_key(struct sock
*sk
,
3779 struct sctp_authkeyid
*val
,
3780 unsigned int optlen
)
3782 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
3783 struct sctp_association
*asoc
;
3786 if (optlen
!= sizeof(struct sctp_authkeyid
))
3789 asoc
= sctp_id2assoc(sk
, val
->scact_assoc_id
);
3790 if (!asoc
&& val
->scact_assoc_id
> SCTP_ALL_ASSOC
&&
3791 sctp_style(sk
, UDP
))
3795 return sctp_auth_deact_key_id(ep
, asoc
, val
->scact_keynumber
);
3797 if (sctp_style(sk
, TCP
))
3798 val
->scact_assoc_id
= SCTP_FUTURE_ASSOC
;
3800 if (val
->scact_assoc_id
== SCTP_FUTURE_ASSOC
||
3801 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3802 ret
= sctp_auth_deact_key_id(ep
, asoc
, val
->scact_keynumber
);
3807 if (val
->scact_assoc_id
== SCTP_CURRENT_ASSOC
||
3808 val
->scact_assoc_id
== SCTP_ALL_ASSOC
) {
3809 list_for_each_entry(asoc
, &ep
->asocs
, asocs
) {
3810 int res
= sctp_auth_deact_key_id(ep
, asoc
,
3811 val
->scact_keynumber
);
3822 * 8.1.23 SCTP_AUTO_ASCONF
3824 * This option will enable or disable the use of the automatic generation of
3825 * ASCONF chunks to add and delete addresses to an existing association. Note
3826 * that this option has two caveats namely: a) it only affects sockets that
3827 * are bound to all addresses available to the SCTP stack, and b) the system
3828 * administrator may have an overriding control that turns the ASCONF feature
3829 * off no matter what setting the socket option may have.
3830 * This option expects an integer boolean flag, where a non-zero value turns on
3831 * the option, and a zero value turns off the option.
3832 * Note. In this implementation, socket operation overrides default parameter
3833 * being set by sysctl as well as FreeBSD implementation
3835 static int sctp_setsockopt_auto_asconf(struct sock
*sk
, int *val
,
3836 unsigned int optlen
)
3838 struct sctp_sock
*sp
= sctp_sk(sk
);
3840 if (optlen
< sizeof(int))
3842 if (!sctp_is_ep_boundall(sk
) && *val
)
3844 if ((*val
&& sp
->do_auto_asconf
) || (!*val
&& !sp
->do_auto_asconf
))
3847 spin_lock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3848 if (*val
== 0 && sp
->do_auto_asconf
) {
3849 list_del(&sp
->auto_asconf_list
);
3850 sp
->do_auto_asconf
= 0;
3851 } else if (*val
&& !sp
->do_auto_asconf
) {
3852 list_add_tail(&sp
->auto_asconf_list
,
3853 &sock_net(sk
)->sctp
.auto_asconf_splist
);
3854 sp
->do_auto_asconf
= 1;
3856 spin_unlock_bh(&sock_net(sk
)->sctp
.addr_wq_lock
);
3861 * SCTP_PEER_ADDR_THLDS
3863 * This option allows us to alter the partially failed threshold for one or all
3864 * transports in an association. See Section 6.1 of:
3865 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3867 static int sctp_setsockopt_paddr_thresholds(struct sock
*sk
,
3868 struct sctp_paddrthlds_v2
*val
,
3869 unsigned int optlen
, bool v2
)
3871 struct sctp_transport
*trans
;
3872 struct sctp_association
*asoc
;
3875 len
= v2
? sizeof(*val
) : sizeof(struct sctp_paddrthlds
);
3879 if (v2
&& val
->spt_pathpfthld
> val
->spt_pathcpthld
)
3882 if (!sctp_is_any(sk
, (const union sctp_addr
*)&val
->spt_address
)) {
3883 trans
= sctp_addr_id2transport(sk
, &val
->spt_address
,
3888 if (val
->spt_pathmaxrxt
)
3889 trans
->pathmaxrxt
= val
->spt_pathmaxrxt
;
3891 trans
->ps_retrans
= val
->spt_pathcpthld
;
3892 trans
->pf_retrans
= val
->spt_pathpfthld
;
3897 asoc
= sctp_id2assoc(sk
, val
->spt_assoc_id
);
3898 if (!asoc
&& val
->spt_assoc_id
!= SCTP_FUTURE_ASSOC
&&
3899 sctp_style(sk
, UDP
))
3903 list_for_each_entry(trans
, &asoc
->peer
.transport_addr_list
,
3905 if (val
->spt_pathmaxrxt
)
3906 trans
->pathmaxrxt
= val
->spt_pathmaxrxt
;
3908 trans
->ps_retrans
= val
->spt_pathcpthld
;
3909 trans
->pf_retrans
= val
->spt_pathpfthld
;
3912 if (val
->spt_pathmaxrxt
)
3913 asoc
->pathmaxrxt
= val
->spt_pathmaxrxt
;
3915 asoc
->ps_retrans
= val
->spt_pathcpthld
;
3916 asoc
->pf_retrans
= val
->spt_pathpfthld
;
3918 struct sctp_sock
*sp
= sctp_sk(sk
);
3920 if (val
->spt_pathmaxrxt
)
3921 sp
->pathmaxrxt
= val
->spt_pathmaxrxt
;
3923 sp
->ps_retrans
= val
->spt_pathcpthld
;
3924 sp
->pf_retrans
= val
->spt_pathpfthld
;
3930 static int sctp_setsockopt_recvrcvinfo(struct sock
*sk
, int *val
,
3931 unsigned int optlen
)
3933 if (optlen
< sizeof(int))
3936 sctp_sk(sk
)->recvrcvinfo
= (*val
== 0) ? 0 : 1;
3941 static int sctp_setsockopt_recvnxtinfo(struct sock
*sk
, int *val
,
3942 unsigned int optlen
)
3944 if (optlen
< sizeof(int))
3947 sctp_sk(sk
)->recvnxtinfo
= (*val
== 0) ? 0 : 1;
3952 static int sctp_setsockopt_pr_supported(struct sock
*sk
,
3953 struct sctp_assoc_value
*params
,
3954 unsigned int optlen
)
3956 struct sctp_association
*asoc
;
3958 if (optlen
!= sizeof(*params
))
3961 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
3962 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
3963 sctp_style(sk
, UDP
))
3966 sctp_sk(sk
)->ep
->prsctp_enable
= !!params
->assoc_value
;
3971 static int sctp_setsockopt_default_prinfo(struct sock
*sk
,
3972 struct sctp_default_prinfo
*info
,
3973 unsigned int optlen
)
3975 struct sctp_sock
*sp
= sctp_sk(sk
);
3976 struct sctp_association
*asoc
;
3977 int retval
= -EINVAL
;
3979 if (optlen
!= sizeof(*info
))
3982 if (info
->pr_policy
& ~SCTP_PR_SCTP_MASK
)
3985 if (info
->pr_policy
== SCTP_PR_SCTP_NONE
)
3988 asoc
= sctp_id2assoc(sk
, info
->pr_assoc_id
);
3989 if (!asoc
&& info
->pr_assoc_id
> SCTP_ALL_ASSOC
&&
3990 sctp_style(sk
, UDP
))
3996 SCTP_PR_SET_POLICY(asoc
->default_flags
, info
->pr_policy
);
3997 asoc
->default_timetolive
= info
->pr_value
;
4001 if (sctp_style(sk
, TCP
))
4002 info
->pr_assoc_id
= SCTP_FUTURE_ASSOC
;
4004 if (info
->pr_assoc_id
== SCTP_FUTURE_ASSOC
||
4005 info
->pr_assoc_id
== SCTP_ALL_ASSOC
) {
4006 SCTP_PR_SET_POLICY(sp
->default_flags
, info
->pr_policy
);
4007 sp
->default_timetolive
= info
->pr_value
;
4010 if (info
->pr_assoc_id
== SCTP_CURRENT_ASSOC
||
4011 info
->pr_assoc_id
== SCTP_ALL_ASSOC
) {
4012 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
) {
4013 SCTP_PR_SET_POLICY(asoc
->default_flags
,
4015 asoc
->default_timetolive
= info
->pr_value
;
4023 static int sctp_setsockopt_reconfig_supported(struct sock
*sk
,
4024 struct sctp_assoc_value
*params
,
4025 unsigned int optlen
)
4027 struct sctp_association
*asoc
;
4028 int retval
= -EINVAL
;
4030 if (optlen
!= sizeof(*params
))
4033 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4034 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
4035 sctp_style(sk
, UDP
))
4038 sctp_sk(sk
)->ep
->reconf_enable
= !!params
->assoc_value
;
4046 static int sctp_setsockopt_enable_strreset(struct sock
*sk
,
4047 struct sctp_assoc_value
*params
,
4048 unsigned int optlen
)
4050 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
4051 struct sctp_association
*asoc
;
4052 int retval
= -EINVAL
;
4054 if (optlen
!= sizeof(*params
))
4057 if (params
->assoc_value
& (~SCTP_ENABLE_STRRESET_MASK
))
4060 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4061 if (!asoc
&& params
->assoc_id
> SCTP_ALL_ASSOC
&&
4062 sctp_style(sk
, UDP
))
4068 asoc
->strreset_enable
= params
->assoc_value
;
4072 if (sctp_style(sk
, TCP
))
4073 params
->assoc_id
= SCTP_FUTURE_ASSOC
;
4075 if (params
->assoc_id
== SCTP_FUTURE_ASSOC
||
4076 params
->assoc_id
== SCTP_ALL_ASSOC
)
4077 ep
->strreset_enable
= params
->assoc_value
;
4079 if (params
->assoc_id
== SCTP_CURRENT_ASSOC
||
4080 params
->assoc_id
== SCTP_ALL_ASSOC
)
4081 list_for_each_entry(asoc
, &ep
->asocs
, asocs
)
4082 asoc
->strreset_enable
= params
->assoc_value
;
4088 static int sctp_setsockopt_reset_streams(struct sock
*sk
,
4089 struct sctp_reset_streams
*params
,
4090 unsigned int optlen
)
4092 struct sctp_association
*asoc
;
4094 if (optlen
< sizeof(*params
))
4096 /* srs_number_streams is u16, so optlen can't be bigger than this. */
4097 optlen
= min_t(unsigned int, optlen
, USHRT_MAX
+
4098 sizeof(__u16
) * sizeof(*params
));
4100 if (params
->srs_number_streams
* sizeof(__u16
) >
4101 optlen
- sizeof(*params
))
4104 asoc
= sctp_id2assoc(sk
, params
->srs_assoc_id
);
4108 return sctp_send_reset_streams(asoc
, params
);
4111 static int sctp_setsockopt_reset_assoc(struct sock
*sk
, sctp_assoc_t
*associd
,
4112 unsigned int optlen
)
4114 struct sctp_association
*asoc
;
4116 if (optlen
!= sizeof(*associd
))
4119 asoc
= sctp_id2assoc(sk
, *associd
);
4123 return sctp_send_reset_assoc(asoc
);
4126 static int sctp_setsockopt_add_streams(struct sock
*sk
,
4127 struct sctp_add_streams
*params
,
4128 unsigned int optlen
)
4130 struct sctp_association
*asoc
;
4132 if (optlen
!= sizeof(*params
))
4135 asoc
= sctp_id2assoc(sk
, params
->sas_assoc_id
);
4139 return sctp_send_add_streams(asoc
, params
);
4142 static int sctp_setsockopt_scheduler(struct sock
*sk
,
4143 struct sctp_assoc_value
*params
,
4144 unsigned int optlen
)
4146 struct sctp_sock
*sp
= sctp_sk(sk
);
4147 struct sctp_association
*asoc
;
4150 if (optlen
< sizeof(*params
))
4153 if (params
->assoc_value
> SCTP_SS_MAX
)
4156 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4157 if (!asoc
&& params
->assoc_id
> SCTP_ALL_ASSOC
&&
4158 sctp_style(sk
, UDP
))
4162 return sctp_sched_set_sched(asoc
, params
->assoc_value
);
4164 if (sctp_style(sk
, TCP
))
4165 params
->assoc_id
= SCTP_FUTURE_ASSOC
;
4167 if (params
->assoc_id
== SCTP_FUTURE_ASSOC
||
4168 params
->assoc_id
== SCTP_ALL_ASSOC
)
4169 sp
->default_ss
= params
->assoc_value
;
4171 if (params
->assoc_id
== SCTP_CURRENT_ASSOC
||
4172 params
->assoc_id
== SCTP_ALL_ASSOC
) {
4173 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
) {
4174 int ret
= sctp_sched_set_sched(asoc
,
4175 params
->assoc_value
);
4185 static int sctp_setsockopt_scheduler_value(struct sock
*sk
,
4186 struct sctp_stream_value
*params
,
4187 unsigned int optlen
)
4189 struct sctp_association
*asoc
;
4190 int retval
= -EINVAL
;
4192 if (optlen
< sizeof(*params
))
4195 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4196 if (!asoc
&& params
->assoc_id
!= SCTP_CURRENT_ASSOC
&&
4197 sctp_style(sk
, UDP
))
4201 retval
= sctp_sched_set_value(asoc
, params
->stream_id
,
4202 params
->stream_value
, GFP_KERNEL
);
4208 list_for_each_entry(asoc
, &sctp_sk(sk
)->ep
->asocs
, asocs
) {
4209 int ret
= sctp_sched_set_value(asoc
, params
->stream_id
,
4210 params
->stream_value
,
4212 if (ret
&& !retval
) /* try to return the 1st error. */
4220 static int sctp_setsockopt_interleaving_supported(struct sock
*sk
,
4221 struct sctp_assoc_value
*p
,
4222 unsigned int optlen
)
4224 struct sctp_sock
*sp
= sctp_sk(sk
);
4225 struct sctp_association
*asoc
;
4227 if (optlen
< sizeof(*p
))
4230 asoc
= sctp_id2assoc(sk
, p
->assoc_id
);
4231 if (!asoc
&& p
->assoc_id
!= SCTP_FUTURE_ASSOC
&& sctp_style(sk
, UDP
))
4234 if (!sock_net(sk
)->sctp
.intl_enable
|| !sp
->frag_interleave
) {
4238 sp
->ep
->intl_enable
= !!p
->assoc_value
;
4242 static int sctp_setsockopt_reuse_port(struct sock
*sk
, int *val
,
4243 unsigned int optlen
)
4245 if (!sctp_style(sk
, TCP
))
4248 if (sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
4251 if (optlen
< sizeof(int))
4254 sctp_sk(sk
)->reuse
= !!*val
;
4259 static int sctp_assoc_ulpevent_type_set(struct sctp_event
*param
,
4260 struct sctp_association
*asoc
)
4262 struct sctp_ulpevent
*event
;
4264 sctp_ulpevent_type_set(&asoc
->subscribe
, param
->se_type
, param
->se_on
);
4266 if (param
->se_type
== SCTP_SENDER_DRY_EVENT
&& param
->se_on
) {
4267 if (sctp_outq_is_empty(&asoc
->outqueue
)) {
4268 event
= sctp_ulpevent_make_sender_dry_event(asoc
,
4269 GFP_USER
| __GFP_NOWARN
);
4273 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, event
);
4280 static int sctp_setsockopt_event(struct sock
*sk
, struct sctp_event
*param
,
4281 unsigned int optlen
)
4283 struct sctp_sock
*sp
= sctp_sk(sk
);
4284 struct sctp_association
*asoc
;
4287 if (optlen
< sizeof(*param
))
4290 if (param
->se_type
< SCTP_SN_TYPE_BASE
||
4291 param
->se_type
> SCTP_SN_TYPE_MAX
)
4294 asoc
= sctp_id2assoc(sk
, param
->se_assoc_id
);
4295 if (!asoc
&& param
->se_assoc_id
> SCTP_ALL_ASSOC
&&
4296 sctp_style(sk
, UDP
))
4300 return sctp_assoc_ulpevent_type_set(param
, asoc
);
4302 if (sctp_style(sk
, TCP
))
4303 param
->se_assoc_id
= SCTP_FUTURE_ASSOC
;
4305 if (param
->se_assoc_id
== SCTP_FUTURE_ASSOC
||
4306 param
->se_assoc_id
== SCTP_ALL_ASSOC
)
4307 sctp_ulpevent_type_set(&sp
->subscribe
,
4308 param
->se_type
, param
->se_on
);
4310 if (param
->se_assoc_id
== SCTP_CURRENT_ASSOC
||
4311 param
->se_assoc_id
== SCTP_ALL_ASSOC
) {
4312 list_for_each_entry(asoc
, &sp
->ep
->asocs
, asocs
) {
4313 int ret
= sctp_assoc_ulpevent_type_set(param
, asoc
);
4323 static int sctp_setsockopt_asconf_supported(struct sock
*sk
,
4324 struct sctp_assoc_value
*params
,
4325 unsigned int optlen
)
4327 struct sctp_association
*asoc
;
4328 struct sctp_endpoint
*ep
;
4329 int retval
= -EINVAL
;
4331 if (optlen
!= sizeof(*params
))
4334 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4335 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
4336 sctp_style(sk
, UDP
))
4339 ep
= sctp_sk(sk
)->ep
;
4340 ep
->asconf_enable
= !!params
->assoc_value
;
4342 if (ep
->asconf_enable
&& ep
->auth_enable
) {
4343 sctp_auth_ep_add_chunkid(ep
, SCTP_CID_ASCONF
);
4344 sctp_auth_ep_add_chunkid(ep
, SCTP_CID_ASCONF_ACK
);
4353 static int sctp_setsockopt_auth_supported(struct sock
*sk
,
4354 struct sctp_assoc_value
*params
,
4355 unsigned int optlen
)
4357 struct sctp_association
*asoc
;
4358 struct sctp_endpoint
*ep
;
4359 int retval
= -EINVAL
;
4361 if (optlen
!= sizeof(*params
))
4364 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4365 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
4366 sctp_style(sk
, UDP
))
4369 ep
= sctp_sk(sk
)->ep
;
4370 if (params
->assoc_value
) {
4371 retval
= sctp_auth_init(ep
, GFP_KERNEL
);
4374 if (ep
->asconf_enable
) {
4375 sctp_auth_ep_add_chunkid(ep
, SCTP_CID_ASCONF
);
4376 sctp_auth_ep_add_chunkid(ep
, SCTP_CID_ASCONF_ACK
);
4380 ep
->auth_enable
= !!params
->assoc_value
;
4387 static int sctp_setsockopt_ecn_supported(struct sock
*sk
,
4388 struct sctp_assoc_value
*params
,
4389 unsigned int optlen
)
4391 struct sctp_association
*asoc
;
4392 int retval
= -EINVAL
;
4394 if (optlen
!= sizeof(*params
))
4397 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4398 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
4399 sctp_style(sk
, UDP
))
4402 sctp_sk(sk
)->ep
->ecn_enable
= !!params
->assoc_value
;
4409 static int sctp_setsockopt_pf_expose(struct sock
*sk
,
4410 struct sctp_assoc_value
*params
,
4411 unsigned int optlen
)
4413 struct sctp_association
*asoc
;
4414 int retval
= -EINVAL
;
4416 if (optlen
!= sizeof(*params
))
4419 if (params
->assoc_value
> SCTP_PF_EXPOSE_MAX
)
4422 asoc
= sctp_id2assoc(sk
, params
->assoc_id
);
4423 if (!asoc
&& params
->assoc_id
!= SCTP_FUTURE_ASSOC
&&
4424 sctp_style(sk
, UDP
))
4428 asoc
->pf_expose
= params
->assoc_value
;
4430 sctp_sk(sk
)->pf_expose
= params
->assoc_value
;
4437 static int sctp_setsockopt_encap_port(struct sock
*sk
,
4438 struct sctp_udpencaps
*encap
,
4439 unsigned int optlen
)
4441 struct sctp_association
*asoc
;
4442 struct sctp_transport
*t
;
4445 if (optlen
!= sizeof(*encap
))
4448 /* If an address other than INADDR_ANY is specified, and
4449 * no transport is found, then the request is invalid.
4451 encap_port
= (__force __be16
)encap
->sue_port
;
4452 if (!sctp_is_any(sk
, (union sctp_addr
*)&encap
->sue_address
)) {
4453 t
= sctp_addr_id2transport(sk
, &encap
->sue_address
,
4454 encap
->sue_assoc_id
);
4458 t
->encap_port
= encap_port
;
4462 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
4463 * socket is a one to many style socket, and an association
4464 * was not found, then the id was invalid.
4466 asoc
= sctp_id2assoc(sk
, encap
->sue_assoc_id
);
4467 if (!asoc
&& encap
->sue_assoc_id
!= SCTP_FUTURE_ASSOC
&&
4468 sctp_style(sk
, UDP
))
4471 /* If changes are for association, also apply encap_port to
4475 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
,
4477 t
->encap_port
= encap_port
;
4479 asoc
->encap_port
= encap_port
;
4483 sctp_sk(sk
)->encap_port
= encap_port
;
4487 static int sctp_setsockopt_probe_interval(struct sock
*sk
,
4488 struct sctp_probeinterval
*params
,
4489 unsigned int optlen
)
4491 struct sctp_association
*asoc
;
4492 struct sctp_transport
*t
;
4493 __u32 probe_interval
;
4495 if (optlen
!= sizeof(*params
))
4498 probe_interval
= params
->spi_interval
;
4499 if (probe_interval
&& probe_interval
< SCTP_PROBE_TIMER_MIN
)
4502 /* If an address other than INADDR_ANY is specified, and
4503 * no transport is found, then the request is invalid.
4505 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
->spi_address
)) {
4506 t
= sctp_addr_id2transport(sk
, ¶ms
->spi_address
,
4507 params
->spi_assoc_id
);
4511 t
->probe_interval
= msecs_to_jiffies(probe_interval
);
4512 sctp_transport_pl_reset(t
);
4516 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
4517 * socket is a one to many style socket, and an association
4518 * was not found, then the id was invalid.
4520 asoc
= sctp_id2assoc(sk
, params
->spi_assoc_id
);
4521 if (!asoc
&& params
->spi_assoc_id
!= SCTP_FUTURE_ASSOC
&&
4522 sctp_style(sk
, UDP
))
4525 /* If changes are for association, also apply probe_interval to
4529 list_for_each_entry(t
, &asoc
->peer
.transport_addr_list
, transports
) {
4530 t
->probe_interval
= msecs_to_jiffies(probe_interval
);
4531 sctp_transport_pl_reset(t
);
4534 asoc
->probe_interval
= msecs_to_jiffies(probe_interval
);
4538 sctp_sk(sk
)->probe_interval
= probe_interval
;
4542 /* API 6.2 setsockopt(), getsockopt()
4544 * Applications use setsockopt() and getsockopt() to set or retrieve
4545 * socket options. Socket options are used to change the default
4546 * behavior of sockets calls. They are described in Section 7.
4550 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
4551 * int __user *optlen);
4552 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
4555 * sd - the socket descript.
4556 * level - set to IPPROTO_SCTP for all SCTP options.
4557 * optname - the option name.
4558 * optval - the buffer to store the value of the option.
4559 * optlen - the size of the buffer.
4561 static int sctp_setsockopt(struct sock
*sk
, int level
, int optname
,
4562 sockptr_t optval
, unsigned int optlen
)
4567 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
4569 /* I can hardly begin to describe how wrong this is. This is
4570 * so broken as to be worse than useless. The API draft
4571 * REALLY is NOT helpful here... I am not convinced that the
4572 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
4573 * are at all well-founded.
4575 if (level
!= SOL_SCTP
) {
4576 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
4578 return af
->setsockopt(sk
, level
, optname
, optval
, optlen
);
4582 /* Trim it to the biggest size sctp sockopt may need if necessary */
4583 optlen
= min_t(unsigned int, optlen
,
4584 PAGE_ALIGN(USHRT_MAX
+
4585 sizeof(__u16
) * sizeof(struct sctp_reset_streams
)));
4586 kopt
= memdup_sockptr(optval
, optlen
);
4588 return PTR_ERR(kopt
);
4594 case SCTP_SOCKOPT_BINDX_ADD
:
4595 /* 'optlen' is the size of the addresses buffer. */
4596 retval
= sctp_setsockopt_bindx(sk
, kopt
, optlen
,
4597 SCTP_BINDX_ADD_ADDR
);
4600 case SCTP_SOCKOPT_BINDX_REM
:
4601 /* 'optlen' is the size of the addresses buffer. */
4602 retval
= sctp_setsockopt_bindx(sk
, kopt
, optlen
,
4603 SCTP_BINDX_REM_ADDR
);
4606 case SCTP_SOCKOPT_CONNECTX_OLD
:
4607 /* 'optlen' is the size of the addresses buffer. */
4608 retval
= sctp_setsockopt_connectx_old(sk
, kopt
, optlen
);
4611 case SCTP_SOCKOPT_CONNECTX
:
4612 /* 'optlen' is the size of the addresses buffer. */
4613 retval
= sctp_setsockopt_connectx(sk
, kopt
, optlen
);
4616 case SCTP_DISABLE_FRAGMENTS
:
4617 retval
= sctp_setsockopt_disable_fragments(sk
, kopt
, optlen
);
4621 retval
= sctp_setsockopt_events(sk
, kopt
, optlen
);
4624 case SCTP_AUTOCLOSE
:
4625 retval
= sctp_setsockopt_autoclose(sk
, kopt
, optlen
);
4628 case SCTP_PEER_ADDR_PARAMS
:
4629 retval
= sctp_setsockopt_peer_addr_params(sk
, kopt
, optlen
);
4632 case SCTP_DELAYED_SACK
:
4633 retval
= sctp_setsockopt_delayed_ack(sk
, kopt
, optlen
);
4635 case SCTP_PARTIAL_DELIVERY_POINT
:
4636 retval
= sctp_setsockopt_partial_delivery_point(sk
, kopt
, optlen
);
4640 retval
= sctp_setsockopt_initmsg(sk
, kopt
, optlen
);
4642 case SCTP_DEFAULT_SEND_PARAM
:
4643 retval
= sctp_setsockopt_default_send_param(sk
, kopt
, optlen
);
4645 case SCTP_DEFAULT_SNDINFO
:
4646 retval
= sctp_setsockopt_default_sndinfo(sk
, kopt
, optlen
);
4648 case SCTP_PRIMARY_ADDR
:
4649 retval
= sctp_setsockopt_primary_addr(sk
, kopt
, optlen
);
4651 case SCTP_SET_PEER_PRIMARY_ADDR
:
4652 retval
= sctp_setsockopt_peer_primary_addr(sk
, kopt
, optlen
);
4655 retval
= sctp_setsockopt_nodelay(sk
, kopt
, optlen
);
4658 retval
= sctp_setsockopt_rtoinfo(sk
, kopt
, optlen
);
4660 case SCTP_ASSOCINFO
:
4661 retval
= sctp_setsockopt_associnfo(sk
, kopt
, optlen
);
4663 case SCTP_I_WANT_MAPPED_V4_ADDR
:
4664 retval
= sctp_setsockopt_mappedv4(sk
, kopt
, optlen
);
4667 retval
= sctp_setsockopt_maxseg(sk
, kopt
, optlen
);
4669 case SCTP_ADAPTATION_LAYER
:
4670 retval
= sctp_setsockopt_adaptation_layer(sk
, kopt
, optlen
);
4673 retval
= sctp_setsockopt_context(sk
, kopt
, optlen
);
4675 case SCTP_FRAGMENT_INTERLEAVE
:
4676 retval
= sctp_setsockopt_fragment_interleave(sk
, kopt
, optlen
);
4678 case SCTP_MAX_BURST
:
4679 retval
= sctp_setsockopt_maxburst(sk
, kopt
, optlen
);
4681 case SCTP_AUTH_CHUNK
:
4682 retval
= sctp_setsockopt_auth_chunk(sk
, kopt
, optlen
);
4684 case SCTP_HMAC_IDENT
:
4685 retval
= sctp_setsockopt_hmac_ident(sk
, kopt
, optlen
);
4688 retval
= sctp_setsockopt_auth_key(sk
, kopt
, optlen
);
4690 case SCTP_AUTH_ACTIVE_KEY
:
4691 retval
= sctp_setsockopt_active_key(sk
, kopt
, optlen
);
4693 case SCTP_AUTH_DELETE_KEY
:
4694 retval
= sctp_setsockopt_del_key(sk
, kopt
, optlen
);
4696 case SCTP_AUTH_DEACTIVATE_KEY
:
4697 retval
= sctp_setsockopt_deactivate_key(sk
, kopt
, optlen
);
4699 case SCTP_AUTO_ASCONF
:
4700 retval
= sctp_setsockopt_auto_asconf(sk
, kopt
, optlen
);
4702 case SCTP_PEER_ADDR_THLDS
:
4703 retval
= sctp_setsockopt_paddr_thresholds(sk
, kopt
, optlen
,
4706 case SCTP_PEER_ADDR_THLDS_V2
:
4707 retval
= sctp_setsockopt_paddr_thresholds(sk
, kopt
, optlen
,
4710 case SCTP_RECVRCVINFO
:
4711 retval
= sctp_setsockopt_recvrcvinfo(sk
, kopt
, optlen
);
4713 case SCTP_RECVNXTINFO
:
4714 retval
= sctp_setsockopt_recvnxtinfo(sk
, kopt
, optlen
);
4716 case SCTP_PR_SUPPORTED
:
4717 retval
= sctp_setsockopt_pr_supported(sk
, kopt
, optlen
);
4719 case SCTP_DEFAULT_PRINFO
:
4720 retval
= sctp_setsockopt_default_prinfo(sk
, kopt
, optlen
);
4722 case SCTP_RECONFIG_SUPPORTED
:
4723 retval
= sctp_setsockopt_reconfig_supported(sk
, kopt
, optlen
);
4725 case SCTP_ENABLE_STREAM_RESET
:
4726 retval
= sctp_setsockopt_enable_strreset(sk
, kopt
, optlen
);
4728 case SCTP_RESET_STREAMS
:
4729 retval
= sctp_setsockopt_reset_streams(sk
, kopt
, optlen
);
4731 case SCTP_RESET_ASSOC
:
4732 retval
= sctp_setsockopt_reset_assoc(sk
, kopt
, optlen
);
4734 case SCTP_ADD_STREAMS
:
4735 retval
= sctp_setsockopt_add_streams(sk
, kopt
, optlen
);
4737 case SCTP_STREAM_SCHEDULER
:
4738 retval
= sctp_setsockopt_scheduler(sk
, kopt
, optlen
);
4740 case SCTP_STREAM_SCHEDULER_VALUE
:
4741 retval
= sctp_setsockopt_scheduler_value(sk
, kopt
, optlen
);
4743 case SCTP_INTERLEAVING_SUPPORTED
:
4744 retval
= sctp_setsockopt_interleaving_supported(sk
, kopt
,
4747 case SCTP_REUSE_PORT
:
4748 retval
= sctp_setsockopt_reuse_port(sk
, kopt
, optlen
);
4751 retval
= sctp_setsockopt_event(sk
, kopt
, optlen
);
4753 case SCTP_ASCONF_SUPPORTED
:
4754 retval
= sctp_setsockopt_asconf_supported(sk
, kopt
, optlen
);
4756 case SCTP_AUTH_SUPPORTED
:
4757 retval
= sctp_setsockopt_auth_supported(sk
, kopt
, optlen
);
4759 case SCTP_ECN_SUPPORTED
:
4760 retval
= sctp_setsockopt_ecn_supported(sk
, kopt
, optlen
);
4762 case SCTP_EXPOSE_POTENTIALLY_FAILED_STATE
:
4763 retval
= sctp_setsockopt_pf_expose(sk
, kopt
, optlen
);
4765 case SCTP_REMOTE_UDP_ENCAPS_PORT
:
4766 retval
= sctp_setsockopt_encap_port(sk
, kopt
, optlen
);
4768 case SCTP_PLPMTUD_PROBE_INTERVAL
:
4769 retval
= sctp_setsockopt_probe_interval(sk
, kopt
, optlen
);
4772 retval
= -ENOPROTOOPT
;
4781 /* API 3.1.6 connect() - UDP Style Syntax
4783 * An application may use the connect() call in the UDP model to initiate an
4784 * association without sending data.
4788 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4790 * sd: the socket descriptor to have a new association added to.
4792 * nam: the address structure (either struct sockaddr_in or struct
4793 * sockaddr_in6 defined in RFC2553 [7]).
4795 * len: the size of the address.
4797 static int sctp_connect(struct sock
*sk
, struct sockaddr
*addr
,
4798 int addr_len
, int flags
)
4804 pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__
, sk
,
4807 /* Validate addr_len before calling common connect/connectx routine. */
4808 af
= sctp_get_af_specific(addr
->sa_family
);
4809 if (af
&& addr_len
>= af
->sockaddr_len
)
4810 err
= __sctp_connect(sk
, addr
, af
->sockaddr_len
, flags
, NULL
);
4816 int sctp_inet_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
4817 int addr_len
, int flags
)
4819 if (addr_len
< sizeof(uaddr
->sa_family
))
4822 if (uaddr
->sa_family
== AF_UNSPEC
)
4825 return sctp_connect(sock
->sk
, uaddr
, addr_len
, flags
);
4828 /* FIXME: Write comments. */
4829 static int sctp_disconnect(struct sock
*sk
, int flags
)
4831 return -EOPNOTSUPP
; /* STUB */
4834 /* 4.1.4 accept() - TCP Style Syntax
4836 * Applications use accept() call to remove an established SCTP
4837 * association from the accept queue of the endpoint. A new socket
4838 * descriptor will be returned from accept() to represent the newly
4839 * formed association.
4841 static struct sock
*sctp_accept(struct sock
*sk
, int flags
, int *err
, bool kern
)
4843 struct sctp_sock
*sp
;
4844 struct sctp_endpoint
*ep
;
4845 struct sock
*newsk
= NULL
;
4846 struct sctp_association
*asoc
;
4855 if (!sctp_style(sk
, TCP
)) {
4856 error
= -EOPNOTSUPP
;
4860 if (!sctp_sstate(sk
, LISTENING
)) {
4865 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
4867 error
= sctp_wait_for_accept(sk
, timeo
);
4871 /* We treat the list of associations on the endpoint as the accept
4872 * queue and pick the first association on the list.
4874 asoc
= list_entry(ep
->asocs
.next
, struct sctp_association
, asocs
);
4876 newsk
= sp
->pf
->create_accept_sk(sk
, asoc
, kern
);
4882 /* Populate the fields of the newsk from the oldsk and migrate the
4883 * asoc to the newsk.
4885 error
= sctp_sock_migrate(sk
, newsk
, asoc
, SCTP_SOCKET_TCP
);
4887 sk_common_release(newsk
);
4897 /* The SCTP ioctl handler. */
4898 static int sctp_ioctl(struct sock
*sk
, int cmd
, int *karg
)
4905 * SEQPACKET-style sockets in LISTENING state are valid, for
4906 * SCTP, so only discard TCP-style sockets in LISTENING state.
4908 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
4913 struct sk_buff
*skb
;
4916 skb
= skb_peek(&sk
->sk_receive_queue
);
4919 * We will only return the amount of this packet since
4920 * that is all that will be read.
4936 /* This is the function which gets called during socket creation to
4937 * initialized the SCTP-specific portion of the sock.
4938 * The sock structure should already be zero-filled memory.
4940 static int sctp_init_sock(struct sock
*sk
)
4942 struct net
*net
= sock_net(sk
);
4943 struct sctp_sock
*sp
;
4945 pr_debug("%s: sk:%p\n", __func__
, sk
);
4949 /* Initialize the SCTP per socket area. */
4950 switch (sk
->sk_type
) {
4951 case SOCK_SEQPACKET
:
4952 sp
->type
= SCTP_SOCKET_UDP
;
4955 sp
->type
= SCTP_SOCKET_TCP
;
4958 return -ESOCKTNOSUPPORT
;
4961 sk
->sk_gso_type
= SKB_GSO_SCTP
;
4963 /* Initialize default send parameters. These parameters can be
4964 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4966 sp
->default_stream
= 0;
4967 sp
->default_ppid
= 0;
4968 sp
->default_flags
= 0;
4969 sp
->default_context
= 0;
4970 sp
->default_timetolive
= 0;
4972 sp
->default_rcv_context
= 0;
4973 sp
->max_burst
= net
->sctp
.max_burst
;
4975 sp
->sctp_hmac_alg
= net
->sctp
.sctp_hmac_alg
;
4977 /* Initialize default setup parameters. These parameters
4978 * can be modified with the SCTP_INITMSG socket option or
4979 * overridden by the SCTP_INIT CMSG.
4981 sp
->initmsg
.sinit_num_ostreams
= sctp_max_outstreams
;
4982 sp
->initmsg
.sinit_max_instreams
= sctp_max_instreams
;
4983 sp
->initmsg
.sinit_max_attempts
= net
->sctp
.max_retrans_init
;
4984 sp
->initmsg
.sinit_max_init_timeo
= net
->sctp
.rto_max
;
4986 /* Initialize default RTO related parameters. These parameters can
4987 * be modified for with the SCTP_RTOINFO socket option.
4989 sp
->rtoinfo
.srto_initial
= net
->sctp
.rto_initial
;
4990 sp
->rtoinfo
.srto_max
= net
->sctp
.rto_max
;
4991 sp
->rtoinfo
.srto_min
= net
->sctp
.rto_min
;
4993 /* Initialize default association related parameters. These parameters
4994 * can be modified with the SCTP_ASSOCINFO socket option.
4996 sp
->assocparams
.sasoc_asocmaxrxt
= net
->sctp
.max_retrans_association
;
4997 sp
->assocparams
.sasoc_number_peer_destinations
= 0;
4998 sp
->assocparams
.sasoc_peer_rwnd
= 0;
4999 sp
->assocparams
.sasoc_local_rwnd
= 0;
5000 sp
->assocparams
.sasoc_cookie_life
= net
->sctp
.valid_cookie_life
;
5002 /* Initialize default event subscriptions. By default, all the
5007 /* Default Peer Address Parameters. These defaults can
5008 * be modified via SCTP_PEER_ADDR_PARAMS
5010 sp
->hbinterval
= net
->sctp
.hb_interval
;
5011 sp
->udp_port
= htons(net
->sctp
.udp_port
);
5012 sp
->encap_port
= htons(net
->sctp
.encap_port
);
5013 sp
->pathmaxrxt
= net
->sctp
.max_retrans_path
;
5014 sp
->pf_retrans
= net
->sctp
.pf_retrans
;
5015 sp
->ps_retrans
= net
->sctp
.ps_retrans
;
5016 sp
->pf_expose
= net
->sctp
.pf_expose
;
5017 sp
->pathmtu
= 0; /* allow default discovery */
5018 sp
->sackdelay
= net
->sctp
.sack_timeout
;
5020 sp
->param_flags
= SPP_HB_ENABLE
|
5022 SPP_SACKDELAY_ENABLE
;
5023 sp
->default_ss
= SCTP_SS_DEFAULT
;
5025 /* If enabled no SCTP message fragmentation will be performed.
5026 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
5028 sp
->disable_fragments
= 0;
5030 /* Enable Nagle algorithm by default. */
5033 sp
->recvrcvinfo
= 0;
5034 sp
->recvnxtinfo
= 0;
5036 /* Enable by default. */
5039 /* Auto-close idle associations after the configured
5040 * number of seconds. A value of 0 disables this
5041 * feature. Configure through the SCTP_AUTOCLOSE socket option,
5042 * for UDP-style sockets only.
5046 /* User specified fragmentation limit. */
5049 sp
->adaptation_ind
= 0;
5051 sp
->pf
= sctp_get_pf_specific(sk
->sk_family
);
5053 /* Control variables for partial data delivery. */
5054 atomic_set(&sp
->pd_mode
, 0);
5055 skb_queue_head_init(&sp
->pd_lobby
);
5056 sp
->frag_interleave
= 0;
5057 sp
->probe_interval
= net
->sctp
.probe_interval
;
5059 /* Create a per socket endpoint structure. Even if we
5060 * change the data structure relationships, this may still
5061 * be useful for storing pre-connect address information.
5063 sp
->ep
= sctp_endpoint_new(sk
, GFP_KERNEL
);
5069 sk
->sk_destruct
= sctp_destruct_sock
;
5071 SCTP_DBG_OBJCNT_INC(sock
);
5073 sk_sockets_allocated_inc(sk
);
5074 sock_prot_inuse_add(net
, sk
->sk_prot
, 1);
5079 /* Cleanup any SCTP per socket resources. Must be called with
5080 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5082 static void sctp_destroy_sock(struct sock
*sk
)
5084 struct sctp_sock
*sp
;
5086 pr_debug("%s: sk:%p\n", __func__
, sk
);
5088 /* Release our hold on the endpoint. */
5090 /* This could happen during socket init, thus we bail out
5091 * early, since the rest of the below is not setup either.
5096 if (sp
->do_auto_asconf
) {
5097 sp
->do_auto_asconf
= 0;
5098 list_del(&sp
->auto_asconf_list
);
5100 sctp_endpoint_free(sp
->ep
);
5101 sk_sockets_allocated_dec(sk
);
5102 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, -1);
5105 /* Triggered when there are no references on the socket anymore */
5106 static void sctp_destruct_common(struct sock
*sk
)
5108 struct sctp_sock
*sp
= sctp_sk(sk
);
5110 /* Free up the HMAC transform. */
5111 crypto_free_shash(sp
->hmac
);
5114 static void sctp_destruct_sock(struct sock
*sk
)
5116 sctp_destruct_common(sk
);
5117 inet_sock_destruct(sk
);
5120 /* API 4.1.7 shutdown() - TCP Style Syntax
5121 * int shutdown(int socket, int how);
5123 * sd - the socket descriptor of the association to be closed.
5124 * how - Specifies the type of shutdown. The values are
5127 * Disables further receive operations. No SCTP
5128 * protocol action is taken.
5130 * Disables further send operations, and initiates
5131 * the SCTP shutdown sequence.
5133 * Disables further send and receive operations
5134 * and initiates the SCTP shutdown sequence.
5136 static void sctp_shutdown(struct sock
*sk
, int how
)
5138 struct net
*net
= sock_net(sk
);
5139 struct sctp_endpoint
*ep
;
5141 if (!sctp_style(sk
, TCP
))
5144 ep
= sctp_sk(sk
)->ep
;
5145 if (how
& SEND_SHUTDOWN
&& !list_empty(&ep
->asocs
)) {
5146 struct sctp_association
*asoc
;
5148 inet_sk_set_state(sk
, SCTP_SS_CLOSING
);
5149 asoc
= list_entry(ep
->asocs
.next
,
5150 struct sctp_association
, asocs
);
5151 sctp_primitive_SHUTDOWN(net
, asoc
, NULL
);
5155 int sctp_get_sctp_info(struct sock
*sk
, struct sctp_association
*asoc
,
5156 struct sctp_info
*info
)
5158 struct sctp_transport
*prim
;
5159 struct list_head
*pos
;
5162 memset(info
, 0, sizeof(*info
));
5164 struct sctp_sock
*sp
= sctp_sk(sk
);
5166 info
->sctpi_s_autoclose
= sp
->autoclose
;
5167 info
->sctpi_s_adaptation_ind
= sp
->adaptation_ind
;
5168 info
->sctpi_s_pd_point
= sp
->pd_point
;
5169 info
->sctpi_s_nodelay
= sp
->nodelay
;
5170 info
->sctpi_s_disable_fragments
= sp
->disable_fragments
;
5171 info
->sctpi_s_v4mapped
= sp
->v4mapped
;
5172 info
->sctpi_s_frag_interleave
= sp
->frag_interleave
;
5173 info
->sctpi_s_type
= sp
->type
;
5178 info
->sctpi_tag
= asoc
->c
.my_vtag
;
5179 info
->sctpi_state
= asoc
->state
;
5180 info
->sctpi_rwnd
= asoc
->a_rwnd
;
5181 info
->sctpi_unackdata
= asoc
->unack_data
;
5182 info
->sctpi_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
5183 info
->sctpi_instrms
= asoc
->stream
.incnt
;
5184 info
->sctpi_outstrms
= asoc
->stream
.outcnt
;
5185 list_for_each(pos
, &asoc
->base
.inqueue
.in_chunk_list
)
5186 info
->sctpi_inqueue
++;
5187 list_for_each(pos
, &asoc
->outqueue
.out_chunk_list
)
5188 info
->sctpi_outqueue
++;
5189 info
->sctpi_overall_error
= asoc
->overall_error_count
;
5190 info
->sctpi_max_burst
= asoc
->max_burst
;
5191 info
->sctpi_maxseg
= asoc
->frag_point
;
5192 info
->sctpi_peer_rwnd
= asoc
->peer
.rwnd
;
5193 info
->sctpi_peer_tag
= asoc
->c
.peer_vtag
;
5195 mask
= asoc
->peer
.intl_capable
<< 1;
5196 mask
= (mask
| asoc
->peer
.ecn_capable
) << 1;
5197 mask
= (mask
| asoc
->peer
.ipv4_address
) << 1;
5198 mask
= (mask
| asoc
->peer
.ipv6_address
) << 1;
5199 mask
= (mask
| asoc
->peer
.reconf_capable
) << 1;
5200 mask
= (mask
| asoc
->peer
.asconf_capable
) << 1;
5201 mask
= (mask
| asoc
->peer
.prsctp_capable
) << 1;
5202 mask
= (mask
| asoc
->peer
.auth_capable
);
5203 info
->sctpi_peer_capable
= mask
;
5204 mask
= asoc
->peer
.sack_needed
<< 1;
5205 mask
= (mask
| asoc
->peer
.sack_generation
) << 1;
5206 mask
= (mask
| asoc
->peer
.zero_window_announced
);
5207 info
->sctpi_peer_sack
= mask
;
5209 info
->sctpi_isacks
= asoc
->stats
.isacks
;
5210 info
->sctpi_osacks
= asoc
->stats
.osacks
;
5211 info
->sctpi_opackets
= asoc
->stats
.opackets
;
5212 info
->sctpi_ipackets
= asoc
->stats
.ipackets
;
5213 info
->sctpi_rtxchunks
= asoc
->stats
.rtxchunks
;
5214 info
->sctpi_outofseqtsns
= asoc
->stats
.outofseqtsns
;
5215 info
->sctpi_idupchunks
= asoc
->stats
.idupchunks
;
5216 info
->sctpi_gapcnt
= asoc
->stats
.gapcnt
;
5217 info
->sctpi_ouodchunks
= asoc
->stats
.ouodchunks
;
5218 info
->sctpi_iuodchunks
= asoc
->stats
.iuodchunks
;
5219 info
->sctpi_oodchunks
= asoc
->stats
.oodchunks
;
5220 info
->sctpi_iodchunks
= asoc
->stats
.iodchunks
;
5221 info
->sctpi_octrlchunks
= asoc
->stats
.octrlchunks
;
5222 info
->sctpi_ictrlchunks
= asoc
->stats
.ictrlchunks
;
5224 prim
= asoc
->peer
.primary_path
;
5225 memcpy(&info
->sctpi_p_address
, &prim
->ipaddr
, sizeof(prim
->ipaddr
));
5226 info
->sctpi_p_state
= prim
->state
;
5227 info
->sctpi_p_cwnd
= prim
->cwnd
;
5228 info
->sctpi_p_srtt
= prim
->srtt
;
5229 info
->sctpi_p_rto
= jiffies_to_msecs(prim
->rto
);
5230 info
->sctpi_p_hbinterval
= prim
->hbinterval
;
5231 info
->sctpi_p_pathmaxrxt
= prim
->pathmaxrxt
;
5232 info
->sctpi_p_sackdelay
= jiffies_to_msecs(prim
->sackdelay
);
5233 info
->sctpi_p_ssthresh
= prim
->ssthresh
;
5234 info
->sctpi_p_partial_bytes_acked
= prim
->partial_bytes_acked
;
5235 info
->sctpi_p_flight_size
= prim
->flight_size
;
5236 info
->sctpi_p_error
= prim
->error_count
;
5240 EXPORT_SYMBOL_GPL(sctp_get_sctp_info
);
5242 /* use callback to avoid exporting the core structure */
5243 void sctp_transport_walk_start(struct rhashtable_iter
*iter
) __acquires(RCU
)
5245 rhltable_walk_enter(&sctp_transport_hashtable
, iter
);
5247 rhashtable_walk_start(iter
);
5250 void sctp_transport_walk_stop(struct rhashtable_iter
*iter
) __releases(RCU
)
5252 rhashtable_walk_stop(iter
);
5253 rhashtable_walk_exit(iter
);
5256 struct sctp_transport
*sctp_transport_get_next(struct net
*net
,
5257 struct rhashtable_iter
*iter
)
5259 struct sctp_transport
*t
;
5261 t
= rhashtable_walk_next(iter
);
5262 for (; t
; t
= rhashtable_walk_next(iter
)) {
5264 if (PTR_ERR(t
) == -EAGAIN
)
5269 if (!sctp_transport_hold(t
))
5272 if (net_eq(t
->asoc
->base
.net
, net
) &&
5273 t
->asoc
->peer
.primary_path
== t
)
5276 sctp_transport_put(t
);
5282 struct sctp_transport
*sctp_transport_get_idx(struct net
*net
,
5283 struct rhashtable_iter
*iter
,
5286 struct sctp_transport
*t
;
5289 return SEQ_START_TOKEN
;
5291 while ((t
= sctp_transport_get_next(net
, iter
)) && !IS_ERR(t
)) {
5294 sctp_transport_put(t
);
5300 int sctp_for_each_endpoint(int (*cb
)(struct sctp_endpoint
*, void *),
5304 struct sctp_endpoint
*ep
;
5305 struct sctp_hashbucket
*head
;
5307 for (head
= sctp_ep_hashtable
; hash
< sctp_ep_hashsize
;
5309 read_lock_bh(&head
->lock
);
5310 sctp_for_each_hentry(ep
, &head
->chain
) {
5315 read_unlock_bh(&head
->lock
);
5320 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint
);
5322 int sctp_transport_lookup_process(sctp_callback_t cb
, struct net
*net
,
5323 const union sctp_addr
*laddr
,
5324 const union sctp_addr
*paddr
, void *p
, int dif
)
5326 struct sctp_transport
*transport
;
5327 struct sctp_endpoint
*ep
;
5331 transport
= sctp_addrs_lookup_transport(net
, laddr
, paddr
, dif
, dif
);
5336 ep
= transport
->asoc
->ep
;
5337 if (!sctp_endpoint_hold(ep
)) { /* asoc can be peeled off */
5338 sctp_transport_put(transport
);
5344 err
= cb(ep
, transport
, p
);
5345 sctp_endpoint_put(ep
);
5346 sctp_transport_put(transport
);
5349 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process
);
5351 int sctp_transport_traverse_process(sctp_callback_t cb
, sctp_callback_t cb_done
,
5352 struct net
*net
, int *pos
, void *p
)
5354 struct rhashtable_iter hti
;
5355 struct sctp_transport
*tsp
;
5356 struct sctp_endpoint
*ep
;
5361 sctp_transport_walk_start(&hti
);
5363 tsp
= sctp_transport_get_idx(net
, &hti
, *pos
+ 1);
5364 for (; !IS_ERR_OR_NULL(tsp
); tsp
= sctp_transport_get_next(net
, &hti
)) {
5366 if (sctp_endpoint_hold(ep
)) { /* asoc can be peeled off */
5367 ret
= cb(ep
, tsp
, p
);
5370 sctp_endpoint_put(ep
);
5373 sctp_transport_put(tsp
);
5375 sctp_transport_walk_stop(&hti
);
5378 if (cb_done
&& !cb_done(ep
, tsp
, p
)) {
5380 sctp_endpoint_put(ep
);
5381 sctp_transport_put(tsp
);
5384 sctp_endpoint_put(ep
);
5385 sctp_transport_put(tsp
);
5390 EXPORT_SYMBOL_GPL(sctp_transport_traverse_process
);
5392 /* 7.2.1 Association Status (SCTP_STATUS)
5394 * Applications can retrieve current status information about an
5395 * association, including association state, peer receiver window size,
5396 * number of unacked data chunks, and number of data chunks pending
5397 * receipt. This information is read-only.
5399 static int sctp_getsockopt_sctp_status(struct sock
*sk
, int len
,
5400 char __user
*optval
,
5403 struct sctp_status status
;
5404 struct sctp_association
*asoc
= NULL
;
5405 struct sctp_transport
*transport
;
5406 sctp_assoc_t associd
;
5409 if (len
< sizeof(status
)) {
5414 len
= sizeof(status
);
5415 if (copy_from_user(&status
, optval
, len
)) {
5420 associd
= status
.sstat_assoc_id
;
5421 asoc
= sctp_id2assoc(sk
, associd
);
5427 transport
= asoc
->peer
.primary_path
;
5429 status
.sstat_assoc_id
= sctp_assoc2id(asoc
);
5430 status
.sstat_state
= sctp_assoc_to_state(asoc
);
5431 status
.sstat_rwnd
= asoc
->peer
.rwnd
;
5432 status
.sstat_unackdata
= asoc
->unack_data
;
5434 status
.sstat_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
5435 status
.sstat_instrms
= asoc
->stream
.incnt
;
5436 status
.sstat_outstrms
= asoc
->stream
.outcnt
;
5437 status
.sstat_fragmentation_point
= asoc
->frag_point
;
5438 status
.sstat_primary
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
5439 memcpy(&status
.sstat_primary
.spinfo_address
, &transport
->ipaddr
,
5440 transport
->af_specific
->sockaddr_len
);
5441 /* Map ipv4 address into v4-mapped-on-v6 address. */
5442 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sctp_sk(sk
),
5443 (union sctp_addr
*)&status
.sstat_primary
.spinfo_address
);
5444 status
.sstat_primary
.spinfo_state
= transport
->state
;
5445 status
.sstat_primary
.spinfo_cwnd
= transport
->cwnd
;
5446 status
.sstat_primary
.spinfo_srtt
= transport
->srtt
;
5447 status
.sstat_primary
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
5448 status
.sstat_primary
.spinfo_mtu
= transport
->pathmtu
;
5450 if (status
.sstat_primary
.spinfo_state
== SCTP_UNKNOWN
)
5451 status
.sstat_primary
.spinfo_state
= SCTP_ACTIVE
;
5453 if (put_user(len
, optlen
)) {
5458 pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5459 __func__
, len
, status
.sstat_state
, status
.sstat_rwnd
,
5460 status
.sstat_assoc_id
);
5462 if (copy_to_user(optval
, &status
, len
)) {
5472 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5474 * Applications can retrieve information about a specific peer address
5475 * of an association, including its reachability state, congestion
5476 * window, and retransmission timer values. This information is
5479 static int sctp_getsockopt_peer_addr_info(struct sock
*sk
, int len
,
5480 char __user
*optval
,
5483 struct sctp_paddrinfo pinfo
;
5484 struct sctp_transport
*transport
;
5487 if (len
< sizeof(pinfo
)) {
5492 len
= sizeof(pinfo
);
5493 if (copy_from_user(&pinfo
, optval
, len
)) {
5498 transport
= sctp_addr_id2transport(sk
, &pinfo
.spinfo_address
,
5499 pinfo
.spinfo_assoc_id
);
5505 if (transport
->state
== SCTP_PF
&&
5506 transport
->asoc
->pf_expose
== SCTP_PF_EXPOSE_DISABLE
) {
5511 pinfo
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
5512 pinfo
.spinfo_state
= transport
->state
;
5513 pinfo
.spinfo_cwnd
= transport
->cwnd
;
5514 pinfo
.spinfo_srtt
= transport
->srtt
;
5515 pinfo
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
5516 pinfo
.spinfo_mtu
= transport
->pathmtu
;
5518 if (pinfo
.spinfo_state
== SCTP_UNKNOWN
)
5519 pinfo
.spinfo_state
= SCTP_ACTIVE
;
5521 if (put_user(len
, optlen
)) {
5526 if (copy_to_user(optval
, &pinfo
, len
)) {
5535 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5537 * This option is a on/off flag. If enabled no SCTP message
5538 * fragmentation will be performed. Instead if a message being sent
5539 * exceeds the current PMTU size, the message will NOT be sent and
5540 * instead a error will be indicated to the user.
5542 static int sctp_getsockopt_disable_fragments(struct sock
*sk
, int len
,
5543 char __user
*optval
, int __user
*optlen
)
5547 if (len
< sizeof(int))
5551 val
= (sctp_sk(sk
)->disable_fragments
== 1);
5552 if (put_user(len
, optlen
))
5554 if (copy_to_user(optval
, &val
, len
))
5559 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5561 * This socket option is used to specify various notifications and
5562 * ancillary data the user wishes to receive.
5564 static int sctp_getsockopt_events(struct sock
*sk
, int len
, char __user
*optval
,
5567 struct sctp_event_subscribe subscribe
;
5568 __u8
*sn_type
= (__u8
*)&subscribe
;
5573 if (len
> sizeof(struct sctp_event_subscribe
))
5574 len
= sizeof(struct sctp_event_subscribe
);
5575 if (put_user(len
, optlen
))
5578 for (i
= 0; i
< len
; i
++)
5579 sn_type
[i
] = sctp_ulpevent_type_enabled(sctp_sk(sk
)->subscribe
,
5580 SCTP_SN_TYPE_BASE
+ i
);
5582 if (copy_to_user(optval
, &subscribe
, len
))
5588 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5590 * This socket option is applicable to the UDP-style socket only. When
5591 * set it will cause associations that are idle for more than the
5592 * specified number of seconds to automatically close. An association
5593 * being idle is defined an association that has NOT sent or received
5594 * user data. The special value of '0' indicates that no automatic
5595 * close of any associations should be performed. The option expects an
5596 * integer defining the number of seconds of idle time before an
5597 * association is closed.
5599 static int sctp_getsockopt_autoclose(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5601 /* Applicable to UDP-style socket only */
5602 if (sctp_style(sk
, TCP
))
5604 if (len
< sizeof(int))
5607 if (put_user(len
, optlen
))
5609 if (put_user(sctp_sk(sk
)->autoclose
, (int __user
*)optval
))
5614 /* Helper routine to branch off an association to a new socket. */
5615 int sctp_do_peeloff(struct sock
*sk
, sctp_assoc_t id
, struct socket
**sockp
)
5617 struct sctp_association
*asoc
= sctp_id2assoc(sk
, id
);
5618 struct sctp_sock
*sp
= sctp_sk(sk
);
5619 struct socket
*sock
;
5622 /* Do not peel off from one netns to another one. */
5623 if (!net_eq(current
->nsproxy
->net_ns
, sock_net(sk
)))
5629 /* An association cannot be branched off from an already peeled-off
5630 * socket, nor is this supported for tcp style sockets.
5632 if (!sctp_style(sk
, UDP
))
5635 /* Create a new socket. */
5636 err
= sock_create(sk
->sk_family
, SOCK_SEQPACKET
, IPPROTO_SCTP
, &sock
);
5640 sctp_copy_sock(sock
->sk
, sk
, asoc
);
5642 /* Make peeled-off sockets more like 1-1 accepted sockets.
5643 * Set the daddr and initialize id to something more random and also
5644 * copy over any ip options.
5646 sp
->pf
->to_sk_daddr(&asoc
->peer
.primary_addr
, sock
->sk
);
5647 sp
->pf
->copy_ip_options(sk
, sock
->sk
);
5649 /* Populate the fields of the newsk from the oldsk and migrate the
5650 * asoc to the newsk.
5652 err
= sctp_sock_migrate(sk
, sock
->sk
, asoc
,
5653 SCTP_SOCKET_UDP_HIGH_BANDWIDTH
);
5663 EXPORT_SYMBOL(sctp_do_peeloff
);
5665 static int sctp_getsockopt_peeloff_common(struct sock
*sk
, sctp_peeloff_arg_t
*peeloff
,
5666 struct file
**newfile
, unsigned flags
)
5668 struct socket
*newsock
;
5671 retval
= sctp_do_peeloff(sk
, peeloff
->associd
, &newsock
);
5675 /* Map the socket to an unused fd that can be returned to the user. */
5676 retval
= get_unused_fd_flags(flags
& SOCK_CLOEXEC
);
5678 sock_release(newsock
);
5682 *newfile
= sock_alloc_file(newsock
, 0, NULL
);
5683 if (IS_ERR(*newfile
)) {
5684 put_unused_fd(retval
);
5685 retval
= PTR_ERR(*newfile
);
5690 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__
, sk
, newsock
->sk
,
5693 peeloff
->sd
= retval
;
5695 if (flags
& SOCK_NONBLOCK
)
5696 (*newfile
)->f_flags
|= O_NONBLOCK
;
5701 static int sctp_getsockopt_peeloff(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
5703 sctp_peeloff_arg_t peeloff
;
5704 struct file
*newfile
= NULL
;
5707 if (len
< sizeof(sctp_peeloff_arg_t
))
5709 len
= sizeof(sctp_peeloff_arg_t
);
5710 if (copy_from_user(&peeloff
, optval
, len
))
5713 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
, &newfile
, 0);
5717 /* Return the fd mapped to the new socket. */
5718 if (put_user(len
, optlen
)) {
5720 put_unused_fd(retval
);
5724 if (copy_to_user(optval
, &peeloff
, len
)) {
5726 put_unused_fd(retval
);
5729 fd_install(retval
, newfile
);
5734 static int sctp_getsockopt_peeloff_flags(struct sock
*sk
, int len
,
5735 char __user
*optval
, int __user
*optlen
)
5737 sctp_peeloff_flags_arg_t peeloff
;
5738 struct file
*newfile
= NULL
;
5741 if (len
< sizeof(sctp_peeloff_flags_arg_t
))
5743 len
= sizeof(sctp_peeloff_flags_arg_t
);
5744 if (copy_from_user(&peeloff
, optval
, len
))
5747 retval
= sctp_getsockopt_peeloff_common(sk
, &peeloff
.p_arg
,
5748 &newfile
, peeloff
.flags
);
5752 /* Return the fd mapped to the new socket. */
5753 if (put_user(len
, optlen
)) {
5755 put_unused_fd(retval
);
5759 if (copy_to_user(optval
, &peeloff
, len
)) {
5761 put_unused_fd(retval
);
5764 fd_install(retval
, newfile
);
5769 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5771 * Applications can enable or disable heartbeats for any peer address of
5772 * an association, modify an address's heartbeat interval, force a
5773 * heartbeat to be sent immediately, and adjust the address's maximum
5774 * number of retransmissions sent before an address is considered
5775 * unreachable. The following structure is used to access and modify an
5776 * address's parameters:
5778 * struct sctp_paddrparams {
5779 * sctp_assoc_t spp_assoc_id;
5780 * struct sockaddr_storage spp_address;
5781 * uint32_t spp_hbinterval;
5782 * uint16_t spp_pathmaxrxt;
5783 * uint32_t spp_pathmtu;
5784 * uint32_t spp_sackdelay;
5785 * uint32_t spp_flags;
5788 * spp_assoc_id - (one-to-many style socket) This is filled in the
5789 * application, and identifies the association for
5791 * spp_address - This specifies which address is of interest.
5792 * spp_hbinterval - This contains the value of the heartbeat interval,
5793 * in milliseconds. If a value of zero
5794 * is present in this field then no changes are to
5795 * be made to this parameter.
5796 * spp_pathmaxrxt - This contains the maximum number of
5797 * retransmissions before this address shall be
5798 * considered unreachable. If a value of zero
5799 * is present in this field then no changes are to
5800 * be made to this parameter.
5801 * spp_pathmtu - When Path MTU discovery is disabled the value
5802 * specified here will be the "fixed" path mtu.
5803 * Note that if the spp_address field is empty
5804 * then all associations on this address will
5805 * have this fixed path mtu set upon them.
5807 * spp_sackdelay - When delayed sack is enabled, this value specifies
5808 * the number of milliseconds that sacks will be delayed
5809 * for. This value will apply to all addresses of an
5810 * association if the spp_address field is empty. Note
5811 * also, that if delayed sack is enabled and this
5812 * value is set to 0, no change is made to the last
5813 * recorded delayed sack timer value.
5815 * spp_flags - These flags are used to control various features
5816 * on an association. The flag field may contain
5817 * zero or more of the following options.
5819 * SPP_HB_ENABLE - Enable heartbeats on the
5820 * specified address. Note that if the address
5821 * field is empty all addresses for the association
5822 * have heartbeats enabled upon them.
5824 * SPP_HB_DISABLE - Disable heartbeats on the
5825 * speicifed address. Note that if the address
5826 * field is empty all addresses for the association
5827 * will have their heartbeats disabled. Note also
5828 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
5829 * mutually exclusive, only one of these two should
5830 * be specified. Enabling both fields will have
5831 * undetermined results.
5833 * SPP_HB_DEMAND - Request a user initiated heartbeat
5834 * to be made immediately.
5836 * SPP_PMTUD_ENABLE - This field will enable PMTU
5837 * discovery upon the specified address. Note that
5838 * if the address feild is empty then all addresses
5839 * on the association are effected.
5841 * SPP_PMTUD_DISABLE - This field will disable PMTU
5842 * discovery upon the specified address. Note that
5843 * if the address feild is empty then all addresses
5844 * on the association are effected. Not also that
5845 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5846 * exclusive. Enabling both will have undetermined
5849 * SPP_SACKDELAY_ENABLE - Setting this flag turns
5850 * on delayed sack. The time specified in spp_sackdelay
5851 * is used to specify the sack delay for this address. Note
5852 * that if spp_address is empty then all addresses will
5853 * enable delayed sack and take on the sack delay
5854 * value specified in spp_sackdelay.
5855 * SPP_SACKDELAY_DISABLE - Setting this flag turns
5856 * off delayed sack. If the spp_address field is blank then
5857 * delayed sack is disabled for the entire association. Note
5858 * also that this field is mutually exclusive to
5859 * SPP_SACKDELAY_ENABLE, setting both will have undefined
5862 * SPP_IPV6_FLOWLABEL: Setting this flag enables the
5863 * setting of the IPV6 flow label value. The value is
5864 * contained in the spp_ipv6_flowlabel field.
5865 * Upon retrieval, this flag will be set to indicate that
5866 * the spp_ipv6_flowlabel field has a valid value returned.
5867 * If a specific destination address is set (in the
5868 * spp_address field), then the value returned is that of
5869 * the address. If just an association is specified (and
5870 * no address), then the association's default flow label
5871 * is returned. If neither an association nor a destination
5872 * is specified, then the socket's default flow label is
5873 * returned. For non-IPv6 sockets, this flag will be left
5876 * SPP_DSCP: Setting this flag enables the setting of the
5877 * Differentiated Services Code Point (DSCP) value
5878 * associated with either the association or a specific
5879 * address. The value is obtained in the spp_dscp field.
5880 * Upon retrieval, this flag will be set to indicate that
5881 * the spp_dscp field has a valid value returned. If a
5882 * specific destination address is set when called (in the
5883 * spp_address field), then that specific destination
5884 * address's DSCP value is returned. If just an association
5885 * is specified, then the association's default DSCP is
5886 * returned. If neither an association nor a destination is
5887 * specified, then the socket's default DSCP is returned.
5889 * spp_ipv6_flowlabel
5890 * - This field is used in conjunction with the
5891 * SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
5892 * The 20 least significant bits are used for the flow
5893 * label. This setting has precedence over any IPv6-layer
5896 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
5897 * and contains the DSCP. The 6 most significant bits are
5898 * used for the DSCP. This setting has precedence over any
5899 * IPv4- or IPv6- layer setting.
5901 static int sctp_getsockopt_peer_addr_params(struct sock
*sk
, int len
,
5902 char __user
*optval
, int __user
*optlen
)
5904 struct sctp_paddrparams params
;
5905 struct sctp_transport
*trans
= NULL
;
5906 struct sctp_association
*asoc
= NULL
;
5907 struct sctp_sock
*sp
= sctp_sk(sk
);
5909 if (len
>= sizeof(params
))
5910 len
= sizeof(params
);
5911 else if (len
>= ALIGN(offsetof(struct sctp_paddrparams
,
5912 spp_ipv6_flowlabel
), 4))
5913 len
= ALIGN(offsetof(struct sctp_paddrparams
,
5914 spp_ipv6_flowlabel
), 4);
5918 if (copy_from_user(¶ms
, optval
, len
))
5921 /* If an address other than INADDR_ANY is specified, and
5922 * no transport is found, then the request is invalid.
5924 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spp_address
)) {
5925 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
5926 params
.spp_assoc_id
);
5928 pr_debug("%s: failed no transport\n", __func__
);
5933 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
5934 * socket is a one to many style socket, and an association
5935 * was not found, then the id was invalid.
5937 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
5938 if (!asoc
&& params
.spp_assoc_id
!= SCTP_FUTURE_ASSOC
&&
5939 sctp_style(sk
, UDP
)) {
5940 pr_debug("%s: failed no association\n", __func__
);
5945 /* Fetch transport values. */
5946 params
.spp_hbinterval
= jiffies_to_msecs(trans
->hbinterval
);
5947 params
.spp_pathmtu
= trans
->pathmtu
;
5948 params
.spp_pathmaxrxt
= trans
->pathmaxrxt
;
5949 params
.spp_sackdelay
= jiffies_to_msecs(trans
->sackdelay
);
5951 /*draft-11 doesn't say what to return in spp_flags*/
5952 params
.spp_flags
= trans
->param_flags
;
5953 if (trans
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5954 params
.spp_ipv6_flowlabel
= trans
->flowlabel
&
5955 SCTP_FLOWLABEL_VAL_MASK
;
5956 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5958 if (trans
->dscp
& SCTP_DSCP_SET_MASK
) {
5959 params
.spp_dscp
= trans
->dscp
& SCTP_DSCP_VAL_MASK
;
5960 params
.spp_flags
|= SPP_DSCP
;
5963 /* Fetch association values. */
5964 params
.spp_hbinterval
= jiffies_to_msecs(asoc
->hbinterval
);
5965 params
.spp_pathmtu
= asoc
->pathmtu
;
5966 params
.spp_pathmaxrxt
= asoc
->pathmaxrxt
;
5967 params
.spp_sackdelay
= jiffies_to_msecs(asoc
->sackdelay
);
5969 /*draft-11 doesn't say what to return in spp_flags*/
5970 params
.spp_flags
= asoc
->param_flags
;
5971 if (asoc
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5972 params
.spp_ipv6_flowlabel
= asoc
->flowlabel
&
5973 SCTP_FLOWLABEL_VAL_MASK
;
5974 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5976 if (asoc
->dscp
& SCTP_DSCP_SET_MASK
) {
5977 params
.spp_dscp
= asoc
->dscp
& SCTP_DSCP_VAL_MASK
;
5978 params
.spp_flags
|= SPP_DSCP
;
5981 /* Fetch socket values. */
5982 params
.spp_hbinterval
= sp
->hbinterval
;
5983 params
.spp_pathmtu
= sp
->pathmtu
;
5984 params
.spp_sackdelay
= sp
->sackdelay
;
5985 params
.spp_pathmaxrxt
= sp
->pathmaxrxt
;
5987 /*draft-11 doesn't say what to return in spp_flags*/
5988 params
.spp_flags
= sp
->param_flags
;
5989 if (sp
->flowlabel
& SCTP_FLOWLABEL_SET_MASK
) {
5990 params
.spp_ipv6_flowlabel
= sp
->flowlabel
&
5991 SCTP_FLOWLABEL_VAL_MASK
;
5992 params
.spp_flags
|= SPP_IPV6_FLOWLABEL
;
5994 if (sp
->dscp
& SCTP_DSCP_SET_MASK
) {
5995 params
.spp_dscp
= sp
->dscp
& SCTP_DSCP_VAL_MASK
;
5996 params
.spp_flags
|= SPP_DSCP
;
6000 if (copy_to_user(optval
, ¶ms
, len
))
6003 if (put_user(len
, optlen
))
6010 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
6012 * This option will effect the way delayed acks are performed. This
6013 * option allows you to get or set the delayed ack time, in
6014 * milliseconds. It also allows changing the delayed ack frequency.
6015 * Changing the frequency to 1 disables the delayed sack algorithm. If
6016 * the assoc_id is 0, then this sets or gets the endpoints default
6017 * values. If the assoc_id field is non-zero, then the set or get
6018 * effects the specified association for the one to many model (the
6019 * assoc_id field is ignored by the one to one model). Note that if
6020 * sack_delay or sack_freq are 0 when setting this option, then the
6021 * current values will remain unchanged.
6023 * struct sctp_sack_info {
6024 * sctp_assoc_t sack_assoc_id;
6025 * uint32_t sack_delay;
6026 * uint32_t sack_freq;
6029 * sack_assoc_id - This parameter, indicates which association the user
6030 * is performing an action upon. Note that if this field's value is
6031 * zero then the endpoints default value is changed (effecting future
6032 * associations only).
6034 * sack_delay - This parameter contains the number of milliseconds that
6035 * the user is requesting the delayed ACK timer be set to. Note that
6036 * this value is defined in the standard to be between 200 and 500
6039 * sack_freq - This parameter contains the number of packets that must
6040 * be received before a sack is sent without waiting for the delay
6041 * timer to expire. The default value for this is 2, setting this
6042 * value to 1 will disable the delayed sack algorithm.
6044 static int sctp_getsockopt_delayed_ack(struct sock
*sk
, int len
,
6045 char __user
*optval
,
6048 struct sctp_sack_info params
;
6049 struct sctp_association
*asoc
= NULL
;
6050 struct sctp_sock
*sp
= sctp_sk(sk
);
6052 if (len
>= sizeof(struct sctp_sack_info
)) {
6053 len
= sizeof(struct sctp_sack_info
);
6055 if (copy_from_user(¶ms
, optval
, len
))
6057 } else if (len
== sizeof(struct sctp_assoc_value
)) {
6058 pr_warn_ratelimited(DEPRECATED
6060 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
6061 "Use struct sctp_sack_info instead\n",
6062 current
->comm
, task_pid_nr(current
));
6063 if (copy_from_user(¶ms
, optval
, len
))
6068 /* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
6069 * socket is a one to many style socket, and an association
6070 * was not found, then the id was invalid.
6072 asoc
= sctp_id2assoc(sk
, params
.sack_assoc_id
);
6073 if (!asoc
&& params
.sack_assoc_id
!= SCTP_FUTURE_ASSOC
&&
6074 sctp_style(sk
, UDP
))
6078 /* Fetch association values. */
6079 if (asoc
->param_flags
& SPP_SACKDELAY_ENABLE
) {
6080 params
.sack_delay
= jiffies_to_msecs(asoc
->sackdelay
);
6081 params
.sack_freq
= asoc
->sackfreq
;
6084 params
.sack_delay
= 0;
6085 params
.sack_freq
= 1;
6088 /* Fetch socket values. */
6089 if (sp
->param_flags
& SPP_SACKDELAY_ENABLE
) {
6090 params
.sack_delay
= sp
->sackdelay
;
6091 params
.sack_freq
= sp
->sackfreq
;
6093 params
.sack_delay
= 0;
6094 params
.sack_freq
= 1;
6098 if (copy_to_user(optval
, ¶ms
, len
))
6101 if (put_user(len
, optlen
))
6107 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
6109 * Applications can specify protocol parameters for the default association
6110 * initialization. The option name argument to setsockopt() and getsockopt()
6113 * Setting initialization parameters is effective only on an unconnected
6114 * socket (for UDP-style sockets only future associations are effected
6115 * by the change). With TCP-style sockets, this option is inherited by
6116 * sockets derived from a listener socket.
6118 static int sctp_getsockopt_initmsg(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
6120 if (len
< sizeof(struct sctp_initmsg
))
6122 len
= sizeof(struct sctp_initmsg
);
6123 if (put_user(len
, optlen
))
6125 if (copy_to_user(optval
, &sctp_sk(sk
)->initmsg
, len
))
6131 static int sctp_getsockopt_peer_addrs(struct sock
*sk
, int len
,
6132 char __user
*optval
, int __user
*optlen
)
6134 struct sctp_association
*asoc
;
6136 struct sctp_getaddrs getaddrs
;
6137 struct sctp_transport
*from
;
6139 union sctp_addr temp
;
6140 struct sctp_sock
*sp
= sctp_sk(sk
);
6145 if (len
< sizeof(struct sctp_getaddrs
))
6148 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
6151 /* For UDP-style sockets, id specifies the association to query. */
6152 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
6156 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
6157 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
6159 list_for_each_entry(from
, &asoc
->peer
.transport_addr_list
,
6161 memcpy(&temp
, &from
->ipaddr
, sizeof(temp
));
6162 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
6163 ->addr_to_user(sp
, &temp
);
6164 if (space_left
< addrlen
)
6166 if (copy_to_user(to
, &temp
, addrlen
))
6170 space_left
-= addrlen
;
6173 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
))
6175 bytes_copied
= ((char __user
*)to
) - optval
;
6176 if (put_user(bytes_copied
, optlen
))
6182 static int sctp_copy_laddrs(struct sock
*sk
, __u16 port
, void *to
,
6183 size_t space_left
, int *bytes_copied
)
6185 struct sctp_sockaddr_entry
*addr
;
6186 union sctp_addr temp
;
6189 struct net
*net
= sock_net(sk
);
6192 list_for_each_entry_rcu(addr
, &net
->sctp
.local_addr_list
, list
) {
6196 if ((PF_INET
== sk
->sk_family
) &&
6197 (AF_INET6
== addr
->a
.sa
.sa_family
))
6199 if ((PF_INET6
== sk
->sk_family
) &&
6200 inet_v6_ipv6only(sk
) &&
6201 (AF_INET
== addr
->a
.sa
.sa_family
))
6203 memcpy(&temp
, &addr
->a
, sizeof(temp
));
6204 if (!temp
.v4
.sin_port
)
6205 temp
.v4
.sin_port
= htons(port
);
6207 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
6208 ->addr_to_user(sctp_sk(sk
), &temp
);
6210 if (space_left
< addrlen
) {
6214 memcpy(to
, &temp
, addrlen
);
6218 space_left
-= addrlen
;
6219 *bytes_copied
+= addrlen
;
6227 static int sctp_getsockopt_local_addrs(struct sock
*sk
, int len
,
6228 char __user
*optval
, int __user
*optlen
)
6230 struct sctp_bind_addr
*bp
;
6231 struct sctp_association
*asoc
;
6233 struct sctp_getaddrs getaddrs
;
6234 struct sctp_sockaddr_entry
*addr
;
6236 union sctp_addr temp
;
6237 struct sctp_sock
*sp
= sctp_sk(sk
);
6241 int bytes_copied
= 0;
6245 if (len
< sizeof(struct sctp_getaddrs
))
6248 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
6252 * For UDP-style sockets, id specifies the association to query.
6253 * If the id field is set to the value '0' then the locally bound
6254 * addresses are returned without regard to any particular
6257 if (0 == getaddrs
.assoc_id
) {
6258 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
6260 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
6263 bp
= &asoc
->base
.bind_addr
;
6266 to
= optval
+ offsetof(struct sctp_getaddrs
, addrs
);
6267 space_left
= len
- offsetof(struct sctp_getaddrs
, addrs
);
6269 addrs
= kmalloc(space_left
, GFP_USER
| __GFP_NOWARN
);
6273 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
6274 * addresses from the global local address list.
6276 if (sctp_list_single_entry(&bp
->address_list
)) {
6277 addr
= list_entry(bp
->address_list
.next
,
6278 struct sctp_sockaddr_entry
, list
);
6279 if (sctp_is_any(sk
, &addr
->a
)) {
6280 cnt
= sctp_copy_laddrs(sk
, bp
->port
, addrs
,
6281 space_left
, &bytes_copied
);
6291 /* Protection on the bound address list is not needed since
6292 * in the socket option context we hold a socket lock and
6293 * thus the bound address list can't change.
6295 list_for_each_entry(addr
, &bp
->address_list
, list
) {
6296 memcpy(&temp
, &addr
->a
, sizeof(temp
));
6297 addrlen
= sctp_get_pf_specific(sk
->sk_family
)
6298 ->addr_to_user(sp
, &temp
);
6299 if (space_left
< addrlen
) {
6300 err
= -ENOMEM
; /*fixme: right error?*/
6303 memcpy(buf
, &temp
, addrlen
);
6305 bytes_copied
+= addrlen
;
6307 space_left
-= addrlen
;
6311 if (copy_to_user(to
, addrs
, bytes_copied
)) {
6315 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
)) {
6319 /* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
6320 * but we can't change it anymore.
6322 if (put_user(bytes_copied
, optlen
))
6329 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
6331 * Requests that the local SCTP stack use the enclosed peer address as
6332 * the association primary. The enclosed address must be one of the
6333 * association peer's addresses.
6335 static int sctp_getsockopt_primary_addr(struct sock
*sk
, int len
,
6336 char __user
*optval
, int __user
*optlen
)
6338 struct sctp_prim prim
;
6339 struct sctp_association
*asoc
;
6340 struct sctp_sock
*sp
= sctp_sk(sk
);
6342 if (len
< sizeof(struct sctp_prim
))
6345 len
= sizeof(struct sctp_prim
);
6347 if (copy_from_user(&prim
, optval
, len
))
6350 asoc
= sctp_id2assoc(sk
, prim
.ssp_assoc_id
);
6354 if (!asoc
->peer
.primary_path
)
6357 memcpy(&prim
.ssp_addr
, &asoc
->peer
.primary_path
->ipaddr
,
6358 asoc
->peer
.primary_path
->af_specific
->sockaddr_len
);
6360 sctp_get_pf_specific(sk
->sk_family
)->addr_to_user(sp
,
6361 (union sctp_addr
*)&prim
.ssp_addr
);
6363 if (put_user(len
, optlen
))
6365 if (copy_to_user(optval
, &prim
, len
))
6372 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
6374 * Requests that the local endpoint set the specified Adaptation Layer
6375 * Indication parameter for all future INIT and INIT-ACK exchanges.
6377 static int sctp_getsockopt_adaptation_layer(struct sock
*sk
, int len
,
6378 char __user
*optval
, int __user
*optlen
)
6380 struct sctp_setadaptation adaptation
;
6382 if (len
< sizeof(struct sctp_setadaptation
))
6385 len
= sizeof(struct sctp_setadaptation
);
6387 adaptation
.ssb_adaptation_ind
= sctp_sk(sk
)->adaptation_ind
;
6389 if (put_user(len
, optlen
))
6391 if (copy_to_user(optval
, &adaptation
, len
))
6399 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
6401 * Applications that wish to use the sendto() system call may wish to
6402 * specify a default set of parameters that would normally be supplied
6403 * through the inclusion of ancillary data. This socket option allows
6404 * such an application to set the default sctp_sndrcvinfo structure.
6407 * The application that wishes to use this socket option simply passes
6408 * in to this call the sctp_sndrcvinfo structure defined in Section
6409 * 5.2.2) The input parameters accepted by this call include
6410 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
6411 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
6412 * to this call if the caller is using the UDP model.
6414 * For getsockopt, it get the default sctp_sndrcvinfo structure.
6416 static int sctp_getsockopt_default_send_param(struct sock
*sk
,
6417 int len
, char __user
*optval
,
6420 struct sctp_sock
*sp
= sctp_sk(sk
);
6421 struct sctp_association
*asoc
;
6422 struct sctp_sndrcvinfo info
;
6424 if (len
< sizeof(info
))
6429 if (copy_from_user(&info
, optval
, len
))
6432 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
6433 if (!asoc
&& info
.sinfo_assoc_id
!= SCTP_FUTURE_ASSOC
&&
6434 sctp_style(sk
, UDP
))
6438 info
.sinfo_stream
= asoc
->default_stream
;
6439 info
.sinfo_flags
= asoc
->default_flags
;
6440 info
.sinfo_ppid
= asoc
->default_ppid
;
6441 info
.sinfo_context
= asoc
->default_context
;
6442 info
.sinfo_timetolive
= asoc
->default_timetolive
;
6444 info
.sinfo_stream
= sp
->default_stream
;
6445 info
.sinfo_flags
= sp
->default_flags
;
6446 info
.sinfo_ppid
= sp
->default_ppid
;
6447 info
.sinfo_context
= sp
->default_context
;
6448 info
.sinfo_timetolive
= sp
->default_timetolive
;
6451 if (put_user(len
, optlen
))
6453 if (copy_to_user(optval
, &info
, len
))
6459 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
6460 * (SCTP_DEFAULT_SNDINFO)
6462 static int sctp_getsockopt_default_sndinfo(struct sock
*sk
, int len
,
6463 char __user
*optval
,
6466 struct sctp_sock
*sp
= sctp_sk(sk
);
6467 struct sctp_association
*asoc
;
6468 struct sctp_sndinfo info
;
6470 if (len
< sizeof(info
))
6475 if (copy_from_user(&info
, optval
, len
))
6478 asoc
= sctp_id2assoc(sk
, info
.snd_assoc_id
);
6479 if (!asoc
&& info
.snd_assoc_id
!= SCTP_FUTURE_ASSOC
&&
6480 sctp_style(sk
, UDP
))
6484 info
.snd_sid
= asoc
->default_stream
;
6485 info
.snd_flags
= asoc
->default_flags
;
6486 info
.snd_ppid
= asoc
->default_ppid
;
6487 info
.snd_context
= asoc
->default_context
;
6489 info
.snd_sid
= sp
->default_stream
;
6490 info
.snd_flags
= sp
->default_flags
;
6491 info
.snd_ppid
= sp
->default_ppid
;
6492 info
.snd_context
= sp
->default_context
;
6495 if (put_user(len
, optlen
))
6497 if (copy_to_user(optval
, &info
, len
))
6505 * 7.1.5 SCTP_NODELAY
6507 * Turn on/off any Nagle-like algorithm. This means that packets are
6508 * generally sent as soon as possible and no unnecessary delays are
6509 * introduced, at the cost of more packets in the network. Expects an
6510 * integer boolean flag.
6513 static int sctp_getsockopt_nodelay(struct sock
*sk
, int len
,
6514 char __user
*optval
, int __user
*optlen
)
6518 if (len
< sizeof(int))
6522 val
= (sctp_sk(sk
)->nodelay
== 1);
6523 if (put_user(len
, optlen
))
6525 if (copy_to_user(optval
, &val
, len
))
6532 * 7.1.1 SCTP_RTOINFO
6534 * The protocol parameters used to initialize and bound retransmission
6535 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
6536 * and modify these parameters.
6537 * All parameters are time values, in milliseconds. A value of 0, when
6538 * modifying the parameters, indicates that the current value should not
6542 static int sctp_getsockopt_rtoinfo(struct sock
*sk
, int len
,
6543 char __user
*optval
,
6544 int __user
*optlen
) {
6545 struct sctp_rtoinfo rtoinfo
;
6546 struct sctp_association
*asoc
;
6548 if (len
< sizeof (struct sctp_rtoinfo
))
6551 len
= sizeof(struct sctp_rtoinfo
);
6553 if (copy_from_user(&rtoinfo
, optval
, len
))
6556 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
6558 if (!asoc
&& rtoinfo
.srto_assoc_id
!= SCTP_FUTURE_ASSOC
&&
6559 sctp_style(sk
, UDP
))
6562 /* Values corresponding to the specific association. */
6564 rtoinfo
.srto_initial
= jiffies_to_msecs(asoc
->rto_initial
);
6565 rtoinfo
.srto_max
= jiffies_to_msecs(asoc
->rto_max
);
6566 rtoinfo
.srto_min
= jiffies_to_msecs(asoc
->rto_min
);
6568 /* Values corresponding to the endpoint. */
6569 struct sctp_sock
*sp
= sctp_sk(sk
);
6571 rtoinfo
.srto_initial
= sp
->rtoinfo
.srto_initial
;
6572 rtoinfo
.srto_max
= sp
->rtoinfo
.srto_max
;
6573 rtoinfo
.srto_min
= sp
->rtoinfo
.srto_min
;
6576 if (put_user(len
, optlen
))
6579 if (copy_to_user(optval
, &rtoinfo
, len
))
6587 * 7.1.2 SCTP_ASSOCINFO
6589 * This option is used to tune the maximum retransmission attempts
6590 * of the association.
6591 * Returns an error if the new association retransmission value is
6592 * greater than the sum of the retransmission value of the peer.
6593 * See [SCTP] for more information.
6596 static int sctp_getsockopt_associnfo(struct sock
*sk
, int len
,
6597 char __user
*optval
,
6601 struct sctp_assocparams assocparams
;
6602 struct sctp_association
*asoc
;
6603 struct list_head
*pos
;
6606 if (len
< sizeof (struct sctp_assocparams
))
6609 len
= sizeof(struct sctp_assocparams
);
6611 if (copy_from_user(&assocparams
, optval
, len
))
6614 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
6616 if (!asoc
&& assocparams
.sasoc_assoc_id
!= SCTP_FUTURE_ASSOC
&&
6617 sctp_style(sk
, UDP
))
6620 /* Values correspoinding to the specific association */
6622 assocparams
.sasoc_asocmaxrxt
= asoc
->max_retrans
;
6623 assocparams
.sasoc_peer_rwnd
= asoc
->peer
.rwnd
;
6624 assocparams
.sasoc_local_rwnd
= asoc
->a_rwnd
;
6625 assocparams
.sasoc_cookie_life
= ktime_to_ms(asoc
->cookie_life
);
6627 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
6631 assocparams
.sasoc_number_peer_destinations
= cnt
;
6633 /* Values corresponding to the endpoint */
6634 struct sctp_sock
*sp
= sctp_sk(sk
);
6636 assocparams
.sasoc_asocmaxrxt
= sp
->assocparams
.sasoc_asocmaxrxt
;
6637 assocparams
.sasoc_peer_rwnd
= sp
->assocparams
.sasoc_peer_rwnd
;
6638 assocparams
.sasoc_local_rwnd
= sp
->assocparams
.sasoc_local_rwnd
;
6639 assocparams
.sasoc_cookie_life
=
6640 sp
->assocparams
.sasoc_cookie_life
;
6641 assocparams
.sasoc_number_peer_destinations
=
6643 sasoc_number_peer_destinations
;
6646 if (put_user(len
, optlen
))
6649 if (copy_to_user(optval
, &assocparams
, len
))
6656 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
6658 * This socket option is a boolean flag which turns on or off mapped V4
6659 * addresses. If this option is turned on and the socket is type
6660 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
6661 * If this option is turned off, then no mapping will be done of V4
6662 * addresses and a user will receive both PF_INET6 and PF_INET type
6663 * addresses on the socket.
6665 static int sctp_getsockopt_mappedv4(struct sock
*sk
, int len
,
6666 char __user
*optval
, int __user
*optlen
)
6669 struct sctp_sock
*sp
= sctp_sk(sk
);
6671 if (len
< sizeof(int))
6676 if (put_user(len
, optlen
))
6678 if (copy_to_user(optval
, &val
, len
))
6685 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
6686 * (chapter and verse is quoted at sctp_setsockopt_context())
6688 static int sctp_getsockopt_context(struct sock
*sk
, int len
,
6689 char __user
*optval
, int __user
*optlen
)
6691 struct sctp_assoc_value params
;
6692 struct sctp_association
*asoc
;
6694 if (len
< sizeof(struct sctp_assoc_value
))
6697 len
= sizeof(struct sctp_assoc_value
);
6699 if (copy_from_user(¶ms
, optval
, len
))
6702 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6703 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
6704 sctp_style(sk
, UDP
))
6707 params
.assoc_value
= asoc
? asoc
->default_rcv_context
6708 : sctp_sk(sk
)->default_rcv_context
;
6710 if (put_user(len
, optlen
))
6712 if (copy_to_user(optval
, ¶ms
, len
))
6719 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6720 * This option will get or set the maximum size to put in any outgoing
6721 * SCTP DATA chunk. If a message is larger than this size it will be
6722 * fragmented by SCTP into the specified size. Note that the underlying
6723 * SCTP implementation may fragment into smaller sized chunks when the
6724 * PMTU of the underlying association is smaller than the value set by
6725 * the user. The default value for this option is '0' which indicates
6726 * the user is NOT limiting fragmentation and only the PMTU will effect
6727 * SCTP's choice of DATA chunk size. Note also that values set larger
6728 * than the maximum size of an IP datagram will effectively let SCTP
6729 * control fragmentation (i.e. the same as setting this option to 0).
6731 * The following structure is used to access and modify this parameter:
6733 * struct sctp_assoc_value {
6734 * sctp_assoc_t assoc_id;
6735 * uint32_t assoc_value;
6738 * assoc_id: This parameter is ignored for one-to-one style sockets.
6739 * For one-to-many style sockets this parameter indicates which
6740 * association the user is performing an action upon. Note that if
6741 * this field's value is zero then the endpoints default value is
6742 * changed (effecting future associations only).
6743 * assoc_value: This parameter specifies the maximum size in bytes.
6745 static int sctp_getsockopt_maxseg(struct sock
*sk
, int len
,
6746 char __user
*optval
, int __user
*optlen
)
6748 struct sctp_assoc_value params
;
6749 struct sctp_association
*asoc
;
6751 if (len
== sizeof(int)) {
6752 pr_warn_ratelimited(DEPRECATED
6754 "Use of int in maxseg socket option.\n"
6755 "Use struct sctp_assoc_value instead\n",
6756 current
->comm
, task_pid_nr(current
));
6757 params
.assoc_id
= SCTP_FUTURE_ASSOC
;
6758 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6759 len
= sizeof(struct sctp_assoc_value
);
6760 if (copy_from_user(¶ms
, optval
, len
))
6765 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6766 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
6767 sctp_style(sk
, UDP
))
6771 params
.assoc_value
= asoc
->frag_point
;
6773 params
.assoc_value
= sctp_sk(sk
)->user_frag
;
6775 if (put_user(len
, optlen
))
6777 if (len
== sizeof(int)) {
6778 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6781 if (copy_to_user(optval
, ¶ms
, len
))
6789 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6790 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6792 static int sctp_getsockopt_fragment_interleave(struct sock
*sk
, int len
,
6793 char __user
*optval
, int __user
*optlen
)
6797 if (len
< sizeof(int))
6802 val
= sctp_sk(sk
)->frag_interleave
;
6803 if (put_user(len
, optlen
))
6805 if (copy_to_user(optval
, &val
, len
))
6812 * 7.1.25. Set or Get the sctp partial delivery point
6813 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6815 static int sctp_getsockopt_partial_delivery_point(struct sock
*sk
, int len
,
6816 char __user
*optval
,
6821 if (len
< sizeof(u32
))
6826 val
= sctp_sk(sk
)->pd_point
;
6827 if (put_user(len
, optlen
))
6829 if (copy_to_user(optval
, &val
, len
))
6836 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
6837 * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6839 static int sctp_getsockopt_maxburst(struct sock
*sk
, int len
,
6840 char __user
*optval
,
6843 struct sctp_assoc_value params
;
6844 struct sctp_association
*asoc
;
6846 if (len
== sizeof(int)) {
6847 pr_warn_ratelimited(DEPRECATED
6849 "Use of int in max_burst socket option.\n"
6850 "Use struct sctp_assoc_value instead\n",
6851 current
->comm
, task_pid_nr(current
));
6852 params
.assoc_id
= SCTP_FUTURE_ASSOC
;
6853 } else if (len
>= sizeof(struct sctp_assoc_value
)) {
6854 len
= sizeof(struct sctp_assoc_value
);
6855 if (copy_from_user(¶ms
, optval
, len
))
6860 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
6861 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
6862 sctp_style(sk
, UDP
))
6865 params
.assoc_value
= asoc
? asoc
->max_burst
: sctp_sk(sk
)->max_burst
;
6867 if (len
== sizeof(int)) {
6868 if (copy_to_user(optval
, ¶ms
.assoc_value
, len
))
6871 if (copy_to_user(optval
, ¶ms
, len
))
6879 static int sctp_getsockopt_hmac_ident(struct sock
*sk
, int len
,
6880 char __user
*optval
, int __user
*optlen
)
6882 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6883 struct sctp_hmacalgo __user
*p
= (void __user
*)optval
;
6884 struct sctp_hmac_algo_param
*hmacs
;
6889 if (!ep
->auth_enable
)
6892 hmacs
= ep
->auth_hmacs_list
;
6893 data_len
= ntohs(hmacs
->param_hdr
.length
) -
6894 sizeof(struct sctp_paramhdr
);
6896 if (len
< sizeof(struct sctp_hmacalgo
) + data_len
)
6899 len
= sizeof(struct sctp_hmacalgo
) + data_len
;
6900 num_idents
= data_len
/ sizeof(u16
);
6902 if (put_user(len
, optlen
))
6904 if (put_user(num_idents
, &p
->shmac_num_idents
))
6906 for (i
= 0; i
< num_idents
; i
++) {
6907 __u16 hmacid
= ntohs(hmacs
->hmac_ids
[i
]);
6909 if (copy_to_user(&p
->shmac_idents
[i
], &hmacid
, sizeof(__u16
)))
6915 static int sctp_getsockopt_active_key(struct sock
*sk
, int len
,
6916 char __user
*optval
, int __user
*optlen
)
6918 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6919 struct sctp_authkeyid val
;
6920 struct sctp_association
*asoc
;
6922 if (len
< sizeof(struct sctp_authkeyid
))
6925 len
= sizeof(struct sctp_authkeyid
);
6926 if (copy_from_user(&val
, optval
, len
))
6929 asoc
= sctp_id2assoc(sk
, val
.scact_assoc_id
);
6930 if (!asoc
&& val
.scact_assoc_id
&& sctp_style(sk
, UDP
))
6934 if (!asoc
->peer
.auth_capable
)
6936 val
.scact_keynumber
= asoc
->active_key_id
;
6938 if (!ep
->auth_enable
)
6940 val
.scact_keynumber
= ep
->active_key_id
;
6943 if (put_user(len
, optlen
))
6945 if (copy_to_user(optval
, &val
, len
))
6951 static int sctp_getsockopt_peer_auth_chunks(struct sock
*sk
, int len
,
6952 char __user
*optval
, int __user
*optlen
)
6954 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
6955 struct sctp_authchunks val
;
6956 struct sctp_association
*asoc
;
6957 struct sctp_chunks_param
*ch
;
6961 if (len
< sizeof(struct sctp_authchunks
))
6964 if (copy_from_user(&val
, optval
, sizeof(val
)))
6967 to
= p
->gauth_chunks
;
6968 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
6972 if (!asoc
->peer
.auth_capable
)
6975 ch
= asoc
->peer
.peer_chunks
;
6979 /* See if the user provided enough room for all the data */
6980 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
6981 if (len
< num_chunks
)
6984 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
6987 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
6988 if (put_user(len
, optlen
))
6990 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
6995 static int sctp_getsockopt_local_auth_chunks(struct sock
*sk
, int len
,
6996 char __user
*optval
, int __user
*optlen
)
6998 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
6999 struct sctp_authchunks __user
*p
= (void __user
*)optval
;
7000 struct sctp_authchunks val
;
7001 struct sctp_association
*asoc
;
7002 struct sctp_chunks_param
*ch
;
7006 if (len
< sizeof(struct sctp_authchunks
))
7009 if (copy_from_user(&val
, optval
, sizeof(val
)))
7012 to
= p
->gauth_chunks
;
7013 asoc
= sctp_id2assoc(sk
, val
.gauth_assoc_id
);
7014 if (!asoc
&& val
.gauth_assoc_id
!= SCTP_FUTURE_ASSOC
&&
7015 sctp_style(sk
, UDP
))
7019 if (!asoc
->peer
.auth_capable
)
7021 ch
= (struct sctp_chunks_param
*)asoc
->c
.auth_chunks
;
7023 if (!ep
->auth_enable
)
7025 ch
= ep
->auth_chunk_list
;
7030 num_chunks
= ntohs(ch
->param_hdr
.length
) - sizeof(struct sctp_paramhdr
);
7031 if (len
< sizeof(struct sctp_authchunks
) + num_chunks
)
7034 if (copy_to_user(to
, ch
->chunks
, num_chunks
))
7037 len
= sizeof(struct sctp_authchunks
) + num_chunks
;
7038 if (put_user(len
, optlen
))
7040 if (put_user(num_chunks
, &p
->gauth_number_of_chunks
))
7047 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
7048 * This option gets the current number of associations that are attached
7049 * to a one-to-many style socket. The option value is an uint32_t.
7051 static int sctp_getsockopt_assoc_number(struct sock
*sk
, int len
,
7052 char __user
*optval
, int __user
*optlen
)
7054 struct sctp_sock
*sp
= sctp_sk(sk
);
7055 struct sctp_association
*asoc
;
7058 if (sctp_style(sk
, TCP
))
7061 if (len
< sizeof(u32
))
7066 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
7070 if (put_user(len
, optlen
))
7072 if (copy_to_user(optval
, &val
, len
))
7079 * 8.1.23 SCTP_AUTO_ASCONF
7080 * See the corresponding setsockopt entry as description
7082 static int sctp_getsockopt_auto_asconf(struct sock
*sk
, int len
,
7083 char __user
*optval
, int __user
*optlen
)
7087 if (len
< sizeof(int))
7091 if (sctp_sk(sk
)->do_auto_asconf
&& sctp_is_ep_boundall(sk
))
7093 if (put_user(len
, optlen
))
7095 if (copy_to_user(optval
, &val
, len
))
7101 * 8.2.6. Get the Current Identifiers of Associations
7102 * (SCTP_GET_ASSOC_ID_LIST)
7104 * This option gets the current list of SCTP association identifiers of
7105 * the SCTP associations handled by a one-to-many style socket.
7107 static int sctp_getsockopt_assoc_ids(struct sock
*sk
, int len
,
7108 char __user
*optval
, int __user
*optlen
)
7110 struct sctp_sock
*sp
= sctp_sk(sk
);
7111 struct sctp_association
*asoc
;
7112 struct sctp_assoc_ids
*ids
;
7115 if (sctp_style(sk
, TCP
))
7118 if (len
< sizeof(struct sctp_assoc_ids
))
7121 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
7125 if (len
< sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
)
7128 len
= sizeof(struct sctp_assoc_ids
) + sizeof(sctp_assoc_t
) * num
;
7130 ids
= kmalloc(len
, GFP_USER
| __GFP_NOWARN
);
7134 ids
->gaids_number_of_ids
= num
;
7136 list_for_each_entry(asoc
, &(sp
->ep
->asocs
), asocs
) {
7137 ids
->gaids_assoc_id
[num
++] = asoc
->assoc_id
;
7140 if (put_user(len
, optlen
) || copy_to_user(optval
, ids
, len
)) {
7150 * SCTP_PEER_ADDR_THLDS
7152 * This option allows us to fetch the partially failed threshold for one or all
7153 * transports in an association. See Section 6.1 of:
7154 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
7156 static int sctp_getsockopt_paddr_thresholds(struct sock
*sk
,
7157 char __user
*optval
, int len
,
7158 int __user
*optlen
, bool v2
)
7160 struct sctp_paddrthlds_v2 val
;
7161 struct sctp_transport
*trans
;
7162 struct sctp_association
*asoc
;
7165 min
= v2
? sizeof(val
) : sizeof(struct sctp_paddrthlds
);
7169 if (copy_from_user(&val
, optval
, len
))
7172 if (!sctp_is_any(sk
, (const union sctp_addr
*)&val
.spt_address
)) {
7173 trans
= sctp_addr_id2transport(sk
, &val
.spt_address
,
7178 val
.spt_pathmaxrxt
= trans
->pathmaxrxt
;
7179 val
.spt_pathpfthld
= trans
->pf_retrans
;
7180 val
.spt_pathcpthld
= trans
->ps_retrans
;
7185 asoc
= sctp_id2assoc(sk
, val
.spt_assoc_id
);
7186 if (!asoc
&& val
.spt_assoc_id
!= SCTP_FUTURE_ASSOC
&&
7187 sctp_style(sk
, UDP
))
7191 val
.spt_pathpfthld
= asoc
->pf_retrans
;
7192 val
.spt_pathmaxrxt
= asoc
->pathmaxrxt
;
7193 val
.spt_pathcpthld
= asoc
->ps_retrans
;
7195 struct sctp_sock
*sp
= sctp_sk(sk
);
7197 val
.spt_pathpfthld
= sp
->pf_retrans
;
7198 val
.spt_pathmaxrxt
= sp
->pathmaxrxt
;
7199 val
.spt_pathcpthld
= sp
->ps_retrans
;
7203 if (put_user(len
, optlen
) || copy_to_user(optval
, &val
, len
))
7210 * SCTP_GET_ASSOC_STATS
7212 * This option retrieves local per endpoint statistics. It is modeled
7213 * after OpenSolaris' implementation
7215 static int sctp_getsockopt_assoc_stats(struct sock
*sk
, int len
,
7216 char __user
*optval
,
7219 struct sctp_assoc_stats sas
;
7220 struct sctp_association
*asoc
= NULL
;
7222 /* User must provide at least the assoc id */
7223 if (len
< sizeof(sctp_assoc_t
))
7226 /* Allow the struct to grow and fill in as much as possible */
7227 len
= min_t(size_t, len
, sizeof(sas
));
7229 if (copy_from_user(&sas
, optval
, len
))
7232 asoc
= sctp_id2assoc(sk
, sas
.sas_assoc_id
);
7236 sas
.sas_rtxchunks
= asoc
->stats
.rtxchunks
;
7237 sas
.sas_gapcnt
= asoc
->stats
.gapcnt
;
7238 sas
.sas_outofseqtsns
= asoc
->stats
.outofseqtsns
;
7239 sas
.sas_osacks
= asoc
->stats
.osacks
;
7240 sas
.sas_isacks
= asoc
->stats
.isacks
;
7241 sas
.sas_octrlchunks
= asoc
->stats
.octrlchunks
;
7242 sas
.sas_ictrlchunks
= asoc
->stats
.ictrlchunks
;
7243 sas
.sas_oodchunks
= asoc
->stats
.oodchunks
;
7244 sas
.sas_iodchunks
= asoc
->stats
.iodchunks
;
7245 sas
.sas_ouodchunks
= asoc
->stats
.ouodchunks
;
7246 sas
.sas_iuodchunks
= asoc
->stats
.iuodchunks
;
7247 sas
.sas_idupchunks
= asoc
->stats
.idupchunks
;
7248 sas
.sas_opackets
= asoc
->stats
.opackets
;
7249 sas
.sas_ipackets
= asoc
->stats
.ipackets
;
7251 /* New high max rto observed, will return 0 if not a single
7252 * RTO update took place. obs_rto_ipaddr will be bogus
7255 sas
.sas_maxrto
= asoc
->stats
.max_obs_rto
;
7256 memcpy(&sas
.sas_obs_rto_ipaddr
, &asoc
->stats
.obs_rto_ipaddr
,
7257 sizeof(struct sockaddr_storage
));
7259 /* Mark beginning of a new observation period */
7260 asoc
->stats
.max_obs_rto
= asoc
->rto_min
;
7262 if (put_user(len
, optlen
))
7265 pr_debug("%s: len:%d, assoc_id:%d\n", __func__
, len
, sas
.sas_assoc_id
);
7267 if (copy_to_user(optval
, &sas
, len
))
7273 static int sctp_getsockopt_recvrcvinfo(struct sock
*sk
, int len
,
7274 char __user
*optval
,
7279 if (len
< sizeof(int))
7283 if (sctp_sk(sk
)->recvrcvinfo
)
7285 if (put_user(len
, optlen
))
7287 if (copy_to_user(optval
, &val
, len
))
7293 static int sctp_getsockopt_recvnxtinfo(struct sock
*sk
, int len
,
7294 char __user
*optval
,
7299 if (len
< sizeof(int))
7303 if (sctp_sk(sk
)->recvnxtinfo
)
7305 if (put_user(len
, optlen
))
7307 if (copy_to_user(optval
, &val
, len
))
7313 static int sctp_getsockopt_pr_supported(struct sock
*sk
, int len
,
7314 char __user
*optval
,
7317 struct sctp_assoc_value params
;
7318 struct sctp_association
*asoc
;
7319 int retval
= -EFAULT
;
7321 if (len
< sizeof(params
)) {
7326 len
= sizeof(params
);
7327 if (copy_from_user(¶ms
, optval
, len
))
7330 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7331 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7332 sctp_style(sk
, UDP
)) {
7337 params
.assoc_value
= asoc
? asoc
->peer
.prsctp_capable
7338 : sctp_sk(sk
)->ep
->prsctp_enable
;
7340 if (put_user(len
, optlen
))
7343 if (copy_to_user(optval
, ¶ms
, len
))
7352 static int sctp_getsockopt_default_prinfo(struct sock
*sk
, int len
,
7353 char __user
*optval
,
7356 struct sctp_default_prinfo info
;
7357 struct sctp_association
*asoc
;
7358 int retval
= -EFAULT
;
7360 if (len
< sizeof(info
)) {
7366 if (copy_from_user(&info
, optval
, len
))
7369 asoc
= sctp_id2assoc(sk
, info
.pr_assoc_id
);
7370 if (!asoc
&& info
.pr_assoc_id
!= SCTP_FUTURE_ASSOC
&&
7371 sctp_style(sk
, UDP
)) {
7377 info
.pr_policy
= SCTP_PR_POLICY(asoc
->default_flags
);
7378 info
.pr_value
= asoc
->default_timetolive
;
7380 struct sctp_sock
*sp
= sctp_sk(sk
);
7382 info
.pr_policy
= SCTP_PR_POLICY(sp
->default_flags
);
7383 info
.pr_value
= sp
->default_timetolive
;
7386 if (put_user(len
, optlen
))
7389 if (copy_to_user(optval
, &info
, len
))
7398 static int sctp_getsockopt_pr_assocstatus(struct sock
*sk
, int len
,
7399 char __user
*optval
,
7402 struct sctp_prstatus params
;
7403 struct sctp_association
*asoc
;
7405 int retval
= -EINVAL
;
7407 if (len
< sizeof(params
))
7410 len
= sizeof(params
);
7411 if (copy_from_user(¶ms
, optval
, len
)) {
7416 policy
= params
.sprstat_policy
;
7417 if (!policy
|| (policy
& ~(SCTP_PR_SCTP_MASK
| SCTP_PR_SCTP_ALL
)) ||
7418 ((policy
& SCTP_PR_SCTP_ALL
) && (policy
& SCTP_PR_SCTP_MASK
)))
7421 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
7425 if (policy
== SCTP_PR_SCTP_ALL
) {
7426 params
.sprstat_abandoned_unsent
= 0;
7427 params
.sprstat_abandoned_sent
= 0;
7428 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
7429 params
.sprstat_abandoned_unsent
+=
7430 asoc
->abandoned_unsent
[policy
];
7431 params
.sprstat_abandoned_sent
+=
7432 asoc
->abandoned_sent
[policy
];
7435 params
.sprstat_abandoned_unsent
=
7436 asoc
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
7437 params
.sprstat_abandoned_sent
=
7438 asoc
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
7441 if (put_user(len
, optlen
)) {
7446 if (copy_to_user(optval
, ¶ms
, len
)) {
7457 static int sctp_getsockopt_pr_streamstatus(struct sock
*sk
, int len
,
7458 char __user
*optval
,
7461 struct sctp_stream_out_ext
*streamoute
;
7462 struct sctp_association
*asoc
;
7463 struct sctp_prstatus params
;
7464 int retval
= -EINVAL
;
7467 if (len
< sizeof(params
))
7470 len
= sizeof(params
);
7471 if (copy_from_user(¶ms
, optval
, len
)) {
7476 policy
= params
.sprstat_policy
;
7477 if (!policy
|| (policy
& ~(SCTP_PR_SCTP_MASK
| SCTP_PR_SCTP_ALL
)) ||
7478 ((policy
& SCTP_PR_SCTP_ALL
) && (policy
& SCTP_PR_SCTP_MASK
)))
7481 asoc
= sctp_id2assoc(sk
, params
.sprstat_assoc_id
);
7482 if (!asoc
|| params
.sprstat_sid
>= asoc
->stream
.outcnt
)
7485 streamoute
= SCTP_SO(&asoc
->stream
, params
.sprstat_sid
)->ext
;
7487 /* Not allocated yet, means all stats are 0 */
7488 params
.sprstat_abandoned_unsent
= 0;
7489 params
.sprstat_abandoned_sent
= 0;
7494 if (policy
== SCTP_PR_SCTP_ALL
) {
7495 params
.sprstat_abandoned_unsent
= 0;
7496 params
.sprstat_abandoned_sent
= 0;
7497 for (policy
= 0; policy
<= SCTP_PR_INDEX(MAX
); policy
++) {
7498 params
.sprstat_abandoned_unsent
+=
7499 streamoute
->abandoned_unsent
[policy
];
7500 params
.sprstat_abandoned_sent
+=
7501 streamoute
->abandoned_sent
[policy
];
7504 params
.sprstat_abandoned_unsent
=
7505 streamoute
->abandoned_unsent
[__SCTP_PR_INDEX(policy
)];
7506 params
.sprstat_abandoned_sent
=
7507 streamoute
->abandoned_sent
[__SCTP_PR_INDEX(policy
)];
7510 if (put_user(len
, optlen
) || copy_to_user(optval
, ¶ms
, len
)) {
7521 static int sctp_getsockopt_reconfig_supported(struct sock
*sk
, int len
,
7522 char __user
*optval
,
7525 struct sctp_assoc_value params
;
7526 struct sctp_association
*asoc
;
7527 int retval
= -EFAULT
;
7529 if (len
< sizeof(params
)) {
7534 len
= sizeof(params
);
7535 if (copy_from_user(¶ms
, optval
, len
))
7538 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7539 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7540 sctp_style(sk
, UDP
)) {
7545 params
.assoc_value
= asoc
? asoc
->peer
.reconf_capable
7546 : sctp_sk(sk
)->ep
->reconf_enable
;
7548 if (put_user(len
, optlen
))
7551 if (copy_to_user(optval
, ¶ms
, len
))
7560 static int sctp_getsockopt_enable_strreset(struct sock
*sk
, int len
,
7561 char __user
*optval
,
7564 struct sctp_assoc_value params
;
7565 struct sctp_association
*asoc
;
7566 int retval
= -EFAULT
;
7568 if (len
< sizeof(params
)) {
7573 len
= sizeof(params
);
7574 if (copy_from_user(¶ms
, optval
, len
))
7577 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7578 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7579 sctp_style(sk
, UDP
)) {
7584 params
.assoc_value
= asoc
? asoc
->strreset_enable
7585 : sctp_sk(sk
)->ep
->strreset_enable
;
7587 if (put_user(len
, optlen
))
7590 if (copy_to_user(optval
, ¶ms
, len
))
7599 static int sctp_getsockopt_scheduler(struct sock
*sk
, int len
,
7600 char __user
*optval
,
7603 struct sctp_assoc_value params
;
7604 struct sctp_association
*asoc
;
7605 int retval
= -EFAULT
;
7607 if (len
< sizeof(params
)) {
7612 len
= sizeof(params
);
7613 if (copy_from_user(¶ms
, optval
, len
))
7616 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7617 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7618 sctp_style(sk
, UDP
)) {
7623 params
.assoc_value
= asoc
? sctp_sched_get_sched(asoc
)
7624 : sctp_sk(sk
)->default_ss
;
7626 if (put_user(len
, optlen
))
7629 if (copy_to_user(optval
, ¶ms
, len
))
7638 static int sctp_getsockopt_scheduler_value(struct sock
*sk
, int len
,
7639 char __user
*optval
,
7642 struct sctp_stream_value params
;
7643 struct sctp_association
*asoc
;
7644 int retval
= -EFAULT
;
7646 if (len
< sizeof(params
)) {
7651 len
= sizeof(params
);
7652 if (copy_from_user(¶ms
, optval
, len
))
7655 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7661 retval
= sctp_sched_get_value(asoc
, params
.stream_id
,
7662 ¶ms
.stream_value
);
7666 if (put_user(len
, optlen
)) {
7671 if (copy_to_user(optval
, ¶ms
, len
)) {
7680 static int sctp_getsockopt_interleaving_supported(struct sock
*sk
, int len
,
7681 char __user
*optval
,
7684 struct sctp_assoc_value params
;
7685 struct sctp_association
*asoc
;
7686 int retval
= -EFAULT
;
7688 if (len
< sizeof(params
)) {
7693 len
= sizeof(params
);
7694 if (copy_from_user(¶ms
, optval
, len
))
7697 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7698 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7699 sctp_style(sk
, UDP
)) {
7704 params
.assoc_value
= asoc
? asoc
->peer
.intl_capable
7705 : sctp_sk(sk
)->ep
->intl_enable
;
7707 if (put_user(len
, optlen
))
7710 if (copy_to_user(optval
, ¶ms
, len
))
7719 static int sctp_getsockopt_reuse_port(struct sock
*sk
, int len
,
7720 char __user
*optval
,
7725 if (len
< sizeof(int))
7729 val
= sctp_sk(sk
)->reuse
;
7730 if (put_user(len
, optlen
))
7733 if (copy_to_user(optval
, &val
, len
))
7739 static int sctp_getsockopt_event(struct sock
*sk
, int len
, char __user
*optval
,
7742 struct sctp_association
*asoc
;
7743 struct sctp_event param
;
7746 if (len
< sizeof(param
))
7749 len
= sizeof(param
);
7750 if (copy_from_user(¶m
, optval
, len
))
7753 if (param
.se_type
< SCTP_SN_TYPE_BASE
||
7754 param
.se_type
> SCTP_SN_TYPE_MAX
)
7757 asoc
= sctp_id2assoc(sk
, param
.se_assoc_id
);
7758 if (!asoc
&& param
.se_assoc_id
!= SCTP_FUTURE_ASSOC
&&
7759 sctp_style(sk
, UDP
))
7762 subscribe
= asoc
? asoc
->subscribe
: sctp_sk(sk
)->subscribe
;
7763 param
.se_on
= sctp_ulpevent_type_enabled(subscribe
, param
.se_type
);
7765 if (put_user(len
, optlen
))
7768 if (copy_to_user(optval
, ¶m
, len
))
7774 static int sctp_getsockopt_asconf_supported(struct sock
*sk
, int len
,
7775 char __user
*optval
,
7778 struct sctp_assoc_value params
;
7779 struct sctp_association
*asoc
;
7780 int retval
= -EFAULT
;
7782 if (len
< sizeof(params
)) {
7787 len
= sizeof(params
);
7788 if (copy_from_user(¶ms
, optval
, len
))
7791 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7792 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7793 sctp_style(sk
, UDP
)) {
7798 params
.assoc_value
= asoc
? asoc
->peer
.asconf_capable
7799 : sctp_sk(sk
)->ep
->asconf_enable
;
7801 if (put_user(len
, optlen
))
7804 if (copy_to_user(optval
, ¶ms
, len
))
7813 static int sctp_getsockopt_auth_supported(struct sock
*sk
, int len
,
7814 char __user
*optval
,
7817 struct sctp_assoc_value params
;
7818 struct sctp_association
*asoc
;
7819 int retval
= -EFAULT
;
7821 if (len
< sizeof(params
)) {
7826 len
= sizeof(params
);
7827 if (copy_from_user(¶ms
, optval
, len
))
7830 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7831 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7832 sctp_style(sk
, UDP
)) {
7837 params
.assoc_value
= asoc
? asoc
->peer
.auth_capable
7838 : sctp_sk(sk
)->ep
->auth_enable
;
7840 if (put_user(len
, optlen
))
7843 if (copy_to_user(optval
, ¶ms
, len
))
7852 static int sctp_getsockopt_ecn_supported(struct sock
*sk
, int len
,
7853 char __user
*optval
,
7856 struct sctp_assoc_value params
;
7857 struct sctp_association
*asoc
;
7858 int retval
= -EFAULT
;
7860 if (len
< sizeof(params
)) {
7865 len
= sizeof(params
);
7866 if (copy_from_user(¶ms
, optval
, len
))
7869 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7870 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7871 sctp_style(sk
, UDP
)) {
7876 params
.assoc_value
= asoc
? asoc
->peer
.ecn_capable
7877 : sctp_sk(sk
)->ep
->ecn_enable
;
7879 if (put_user(len
, optlen
))
7882 if (copy_to_user(optval
, ¶ms
, len
))
7891 static int sctp_getsockopt_pf_expose(struct sock
*sk
, int len
,
7892 char __user
*optval
,
7895 struct sctp_assoc_value params
;
7896 struct sctp_association
*asoc
;
7897 int retval
= -EFAULT
;
7899 if (len
< sizeof(params
)) {
7904 len
= sizeof(params
);
7905 if (copy_from_user(¶ms
, optval
, len
))
7908 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
7909 if (!asoc
&& params
.assoc_id
!= SCTP_FUTURE_ASSOC
&&
7910 sctp_style(sk
, UDP
)) {
7915 params
.assoc_value
= asoc
? asoc
->pf_expose
7916 : sctp_sk(sk
)->pf_expose
;
7918 if (put_user(len
, optlen
))
7921 if (copy_to_user(optval
, ¶ms
, len
))
7930 static int sctp_getsockopt_encap_port(struct sock
*sk
, int len
,
7931 char __user
*optval
, int __user
*optlen
)
7933 struct sctp_association
*asoc
;
7934 struct sctp_udpencaps encap
;
7935 struct sctp_transport
*t
;
7938 if (len
< sizeof(encap
))
7941 len
= sizeof(encap
);
7942 if (copy_from_user(&encap
, optval
, len
))
7945 /* If an address other than INADDR_ANY is specified, and
7946 * no transport is found, then the request is invalid.
7948 if (!sctp_is_any(sk
, (union sctp_addr
*)&encap
.sue_address
)) {
7949 t
= sctp_addr_id2transport(sk
, &encap
.sue_address
,
7950 encap
.sue_assoc_id
);
7952 pr_debug("%s: failed no transport\n", __func__
);
7956 encap_port
= t
->encap_port
;
7960 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
7961 * socket is a one to many style socket, and an association
7962 * was not found, then the id was invalid.
7964 asoc
= sctp_id2assoc(sk
, encap
.sue_assoc_id
);
7965 if (!asoc
&& encap
.sue_assoc_id
!= SCTP_FUTURE_ASSOC
&&
7966 sctp_style(sk
, UDP
)) {
7967 pr_debug("%s: failed no association\n", __func__
);
7972 encap_port
= asoc
->encap_port
;
7976 encap_port
= sctp_sk(sk
)->encap_port
;
7979 encap
.sue_port
= (__force
uint16_t)encap_port
;
7980 if (copy_to_user(optval
, &encap
, len
))
7983 if (put_user(len
, optlen
))
7989 static int sctp_getsockopt_probe_interval(struct sock
*sk
, int len
,
7990 char __user
*optval
,
7993 struct sctp_probeinterval params
;
7994 struct sctp_association
*asoc
;
7995 struct sctp_transport
*t
;
7996 __u32 probe_interval
;
7998 if (len
< sizeof(params
))
8001 len
= sizeof(params
);
8002 if (copy_from_user(¶ms
, optval
, len
))
8005 /* If an address other than INADDR_ANY is specified, and
8006 * no transport is found, then the request is invalid.
8008 if (!sctp_is_any(sk
, (union sctp_addr
*)¶ms
.spi_address
)) {
8009 t
= sctp_addr_id2transport(sk
, ¶ms
.spi_address
,
8010 params
.spi_assoc_id
);
8012 pr_debug("%s: failed no transport\n", __func__
);
8016 probe_interval
= jiffies_to_msecs(t
->probe_interval
);
8020 /* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
8021 * socket is a one to many style socket, and an association
8022 * was not found, then the id was invalid.
8024 asoc
= sctp_id2assoc(sk
, params
.spi_assoc_id
);
8025 if (!asoc
&& params
.spi_assoc_id
!= SCTP_FUTURE_ASSOC
&&
8026 sctp_style(sk
, UDP
)) {
8027 pr_debug("%s: failed no association\n", __func__
);
8032 probe_interval
= jiffies_to_msecs(asoc
->probe_interval
);
8036 probe_interval
= sctp_sk(sk
)->probe_interval
;
8039 params
.spi_interval
= probe_interval
;
8040 if (copy_to_user(optval
, ¶ms
, len
))
8043 if (put_user(len
, optlen
))
8049 static int sctp_getsockopt(struct sock
*sk
, int level
, int optname
,
8050 char __user
*optval
, int __user
*optlen
)
8055 pr_debug("%s: sk:%p, optname:%d\n", __func__
, sk
, optname
);
8057 /* I can hardly begin to describe how wrong this is. This is
8058 * so broken as to be worse than useless. The API draft
8059 * REALLY is NOT helpful here... I am not convinced that the
8060 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
8061 * are at all well-founded.
8063 if (level
!= SOL_SCTP
) {
8064 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
8066 retval
= af
->getsockopt(sk
, level
, optname
, optval
, optlen
);
8070 if (get_user(len
, optlen
))
8080 retval
= sctp_getsockopt_sctp_status(sk
, len
, optval
, optlen
);
8082 case SCTP_DISABLE_FRAGMENTS
:
8083 retval
= sctp_getsockopt_disable_fragments(sk
, len
, optval
,
8087 retval
= sctp_getsockopt_events(sk
, len
, optval
, optlen
);
8089 case SCTP_AUTOCLOSE
:
8090 retval
= sctp_getsockopt_autoclose(sk
, len
, optval
, optlen
);
8092 case SCTP_SOCKOPT_PEELOFF
:
8093 retval
= sctp_getsockopt_peeloff(sk
, len
, optval
, optlen
);
8095 case SCTP_SOCKOPT_PEELOFF_FLAGS
:
8096 retval
= sctp_getsockopt_peeloff_flags(sk
, len
, optval
, optlen
);
8098 case SCTP_PEER_ADDR_PARAMS
:
8099 retval
= sctp_getsockopt_peer_addr_params(sk
, len
, optval
,
8102 case SCTP_DELAYED_SACK
:
8103 retval
= sctp_getsockopt_delayed_ack(sk
, len
, optval
,
8107 retval
= sctp_getsockopt_initmsg(sk
, len
, optval
, optlen
);
8109 case SCTP_GET_PEER_ADDRS
:
8110 retval
= sctp_getsockopt_peer_addrs(sk
, len
, optval
,
8113 case SCTP_GET_LOCAL_ADDRS
:
8114 retval
= sctp_getsockopt_local_addrs(sk
, len
, optval
,
8117 case SCTP_SOCKOPT_CONNECTX3
:
8118 retval
= sctp_getsockopt_connectx3(sk
, len
, optval
, optlen
);
8120 case SCTP_DEFAULT_SEND_PARAM
:
8121 retval
= sctp_getsockopt_default_send_param(sk
, len
,
8124 case SCTP_DEFAULT_SNDINFO
:
8125 retval
= sctp_getsockopt_default_sndinfo(sk
, len
,
8128 case SCTP_PRIMARY_ADDR
:
8129 retval
= sctp_getsockopt_primary_addr(sk
, len
, optval
, optlen
);
8132 retval
= sctp_getsockopt_nodelay(sk
, len
, optval
, optlen
);
8135 retval
= sctp_getsockopt_rtoinfo(sk
, len
, optval
, optlen
);
8137 case SCTP_ASSOCINFO
:
8138 retval
= sctp_getsockopt_associnfo(sk
, len
, optval
, optlen
);
8140 case SCTP_I_WANT_MAPPED_V4_ADDR
:
8141 retval
= sctp_getsockopt_mappedv4(sk
, len
, optval
, optlen
);
8144 retval
= sctp_getsockopt_maxseg(sk
, len
, optval
, optlen
);
8146 case SCTP_GET_PEER_ADDR_INFO
:
8147 retval
= sctp_getsockopt_peer_addr_info(sk
, len
, optval
,
8150 case SCTP_ADAPTATION_LAYER
:
8151 retval
= sctp_getsockopt_adaptation_layer(sk
, len
, optval
,
8155 retval
= sctp_getsockopt_context(sk
, len
, optval
, optlen
);
8157 case SCTP_FRAGMENT_INTERLEAVE
:
8158 retval
= sctp_getsockopt_fragment_interleave(sk
, len
, optval
,
8161 case SCTP_PARTIAL_DELIVERY_POINT
:
8162 retval
= sctp_getsockopt_partial_delivery_point(sk
, len
, optval
,
8165 case SCTP_MAX_BURST
:
8166 retval
= sctp_getsockopt_maxburst(sk
, len
, optval
, optlen
);
8169 case SCTP_AUTH_CHUNK
:
8170 case SCTP_AUTH_DELETE_KEY
:
8171 case SCTP_AUTH_DEACTIVATE_KEY
:
8172 retval
= -EOPNOTSUPP
;
8174 case SCTP_HMAC_IDENT
:
8175 retval
= sctp_getsockopt_hmac_ident(sk
, len
, optval
, optlen
);
8177 case SCTP_AUTH_ACTIVE_KEY
:
8178 retval
= sctp_getsockopt_active_key(sk
, len
, optval
, optlen
);
8180 case SCTP_PEER_AUTH_CHUNKS
:
8181 retval
= sctp_getsockopt_peer_auth_chunks(sk
, len
, optval
,
8184 case SCTP_LOCAL_AUTH_CHUNKS
:
8185 retval
= sctp_getsockopt_local_auth_chunks(sk
, len
, optval
,
8188 case SCTP_GET_ASSOC_NUMBER
:
8189 retval
= sctp_getsockopt_assoc_number(sk
, len
, optval
, optlen
);
8191 case SCTP_GET_ASSOC_ID_LIST
:
8192 retval
= sctp_getsockopt_assoc_ids(sk
, len
, optval
, optlen
);
8194 case SCTP_AUTO_ASCONF
:
8195 retval
= sctp_getsockopt_auto_asconf(sk
, len
, optval
, optlen
);
8197 case SCTP_PEER_ADDR_THLDS
:
8198 retval
= sctp_getsockopt_paddr_thresholds(sk
, optval
, len
,
8201 case SCTP_PEER_ADDR_THLDS_V2
:
8202 retval
= sctp_getsockopt_paddr_thresholds(sk
, optval
, len
,
8205 case SCTP_GET_ASSOC_STATS
:
8206 retval
= sctp_getsockopt_assoc_stats(sk
, len
, optval
, optlen
);
8208 case SCTP_RECVRCVINFO
:
8209 retval
= sctp_getsockopt_recvrcvinfo(sk
, len
, optval
, optlen
);
8211 case SCTP_RECVNXTINFO
:
8212 retval
= sctp_getsockopt_recvnxtinfo(sk
, len
, optval
, optlen
);
8214 case SCTP_PR_SUPPORTED
:
8215 retval
= sctp_getsockopt_pr_supported(sk
, len
, optval
, optlen
);
8217 case SCTP_DEFAULT_PRINFO
:
8218 retval
= sctp_getsockopt_default_prinfo(sk
, len
, optval
,
8221 case SCTP_PR_ASSOC_STATUS
:
8222 retval
= sctp_getsockopt_pr_assocstatus(sk
, len
, optval
,
8225 case SCTP_PR_STREAM_STATUS
:
8226 retval
= sctp_getsockopt_pr_streamstatus(sk
, len
, optval
,
8229 case SCTP_RECONFIG_SUPPORTED
:
8230 retval
= sctp_getsockopt_reconfig_supported(sk
, len
, optval
,
8233 case SCTP_ENABLE_STREAM_RESET
:
8234 retval
= sctp_getsockopt_enable_strreset(sk
, len
, optval
,
8237 case SCTP_STREAM_SCHEDULER
:
8238 retval
= sctp_getsockopt_scheduler(sk
, len
, optval
,
8241 case SCTP_STREAM_SCHEDULER_VALUE
:
8242 retval
= sctp_getsockopt_scheduler_value(sk
, len
, optval
,
8245 case SCTP_INTERLEAVING_SUPPORTED
:
8246 retval
= sctp_getsockopt_interleaving_supported(sk
, len
, optval
,
8249 case SCTP_REUSE_PORT
:
8250 retval
= sctp_getsockopt_reuse_port(sk
, len
, optval
, optlen
);
8253 retval
= sctp_getsockopt_event(sk
, len
, optval
, optlen
);
8255 case SCTP_ASCONF_SUPPORTED
:
8256 retval
= sctp_getsockopt_asconf_supported(sk
, len
, optval
,
8259 case SCTP_AUTH_SUPPORTED
:
8260 retval
= sctp_getsockopt_auth_supported(sk
, len
, optval
,
8263 case SCTP_ECN_SUPPORTED
:
8264 retval
= sctp_getsockopt_ecn_supported(sk
, len
, optval
, optlen
);
8266 case SCTP_EXPOSE_POTENTIALLY_FAILED_STATE
:
8267 retval
= sctp_getsockopt_pf_expose(sk
, len
, optval
, optlen
);
8269 case SCTP_REMOTE_UDP_ENCAPS_PORT
:
8270 retval
= sctp_getsockopt_encap_port(sk
, len
, optval
, optlen
);
8272 case SCTP_PLPMTUD_PROBE_INTERVAL
:
8273 retval
= sctp_getsockopt_probe_interval(sk
, len
, optval
, optlen
);
8276 retval
= -ENOPROTOOPT
;
8284 static bool sctp_bpf_bypass_getsockopt(int level
, int optname
)
8286 if (level
== SOL_SCTP
) {
8288 case SCTP_SOCKOPT_PEELOFF
:
8289 case SCTP_SOCKOPT_PEELOFF_FLAGS
:
8290 case SCTP_SOCKOPT_CONNECTX3
:
8300 static int sctp_hash(struct sock
*sk
)
8306 static void sctp_unhash(struct sock
*sk
)
8311 /* Check if port is acceptable. Possibly find first available port.
8313 * The port hash table (contained in the 'global' SCTP protocol storage
8314 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
8315 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
8316 * list (the list number is the port number hashed out, so as you
8317 * would expect from a hash function, all the ports in a given list have
8318 * such a number that hashes out to the same list number; you were
8319 * expecting that, right?); so each list has a set of ports, with a
8320 * link to the socket (struct sock) that uses it, the port number and
8321 * a fastreuse flag (FIXME: NPI ipg).
8323 static struct sctp_bind_bucket
*sctp_bucket_create(
8324 struct sctp_bind_hashbucket
*head
, struct net
*, unsigned short snum
);
8326 static int sctp_get_port_local(struct sock
*sk
, union sctp_addr
*addr
)
8328 struct sctp_sock
*sp
= sctp_sk(sk
);
8329 bool reuse
= (sk
->sk_reuse
|| sp
->reuse
);
8330 struct sctp_bind_hashbucket
*head
; /* hash list */
8331 struct net
*net
= sock_net(sk
);
8332 kuid_t uid
= sock_i_uid(sk
);
8333 struct sctp_bind_bucket
*pp
;
8334 unsigned short snum
;
8337 snum
= ntohs(addr
->v4
.sin_port
);
8339 pr_debug("%s: begins, snum:%d\n", __func__
, snum
);
8342 /* Search for an available port. */
8343 int low
, high
, remaining
, index
;
8346 inet_sk_get_local_port_range(sk
, &low
, &high
);
8347 remaining
= (high
- low
) + 1;
8348 rover
= get_random_u32_below(remaining
) + low
;
8352 if ((rover
< low
) || (rover
> high
))
8354 if (inet_is_local_reserved_port(net
, rover
))
8356 index
= sctp_phashfn(net
, rover
);
8357 head
= &sctp_port_hashtable
[index
];
8358 spin_lock_bh(&head
->lock
);
8359 sctp_for_each_hentry(pp
, &head
->chain
)
8360 if ((pp
->port
== rover
) &&
8361 net_eq(net
, pp
->net
))
8365 spin_unlock_bh(&head
->lock
);
8367 } while (--remaining
> 0);
8369 /* Exhausted local port range during search? */
8374 /* OK, here is the one we will use. HEAD (the port
8375 * hash table list entry) is non-NULL and we hold it's
8380 /* We are given an specific port number; we verify
8381 * that it is not being used. If it is used, we will
8382 * exahust the search in the hash list corresponding
8383 * to the port number (snum) - we detect that with the
8384 * port iterator, pp being NULL.
8386 head
= &sctp_port_hashtable
[sctp_phashfn(net
, snum
)];
8387 spin_lock_bh(&head
->lock
);
8388 sctp_for_each_hentry(pp
, &head
->chain
) {
8389 if ((pp
->port
== snum
) && net_eq(pp
->net
, net
))
8396 if (!hlist_empty(&pp
->owner
)) {
8397 /* We had a port hash table hit - there is an
8398 * available port (pp != NULL) and it is being
8399 * used by other socket (pp->owner not empty); that other
8400 * socket is going to be sk2.
8404 pr_debug("%s: found a possible match\n", __func__
);
8406 if ((pp
->fastreuse
&& reuse
&&
8407 sk
->sk_state
!= SCTP_SS_LISTENING
) ||
8408 (pp
->fastreuseport
&& sk
->sk_reuseport
&&
8409 uid_eq(pp
->fastuid
, uid
)))
8412 /* Run through the list of sockets bound to the port
8413 * (pp->port) [via the pointers bind_next and
8414 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
8415 * we get the endpoint they describe and run through
8416 * the endpoint's list of IP (v4 or v6) addresses,
8417 * comparing each of the addresses with the address of
8418 * the socket sk. If we find a match, then that means
8419 * that this port/socket (sk) combination are already
8422 sk_for_each_bound(sk2
, &pp
->owner
) {
8423 int bound_dev_if2
= READ_ONCE(sk2
->sk_bound_dev_if
);
8424 struct sctp_sock
*sp2
= sctp_sk(sk2
);
8425 struct sctp_endpoint
*ep2
= sp2
->ep
;
8428 (reuse
&& (sk2
->sk_reuse
|| sp2
->reuse
) &&
8429 sk2
->sk_state
!= SCTP_SS_LISTENING
) ||
8430 (sk
->sk_reuseport
&& sk2
->sk_reuseport
&&
8431 uid_eq(uid
, sock_i_uid(sk2
))))
8434 if ((!sk
->sk_bound_dev_if
|| !bound_dev_if2
||
8435 sk
->sk_bound_dev_if
== bound_dev_if2
) &&
8436 sctp_bind_addr_conflict(&ep2
->base
.bind_addr
,
8443 pr_debug("%s: found a match\n", __func__
);
8446 /* If there was a hash table miss, create a new port. */
8448 if (!pp
&& !(pp
= sctp_bucket_create(head
, net
, snum
)))
8451 /* In either case (hit or miss), make sure fastreuse is 1 only
8452 * if sk->sk_reuse is too (that is, if the caller requested
8453 * SO_REUSEADDR on this socket -sk-).
8455 if (hlist_empty(&pp
->owner
)) {
8456 if (reuse
&& sk
->sk_state
!= SCTP_SS_LISTENING
)
8461 if (sk
->sk_reuseport
) {
8462 pp
->fastreuseport
= 1;
8465 pp
->fastreuseport
= 0;
8468 if (pp
->fastreuse
&&
8469 (!reuse
|| sk
->sk_state
== SCTP_SS_LISTENING
))
8472 if (pp
->fastreuseport
&&
8473 (!sk
->sk_reuseport
|| !uid_eq(pp
->fastuid
, uid
)))
8474 pp
->fastreuseport
= 0;
8477 /* We are set, so fill up all the data in the hash table
8478 * entry, tie the socket list information with the rest of the
8479 * sockets FIXME: Blurry, NPI (ipg).
8482 if (!sp
->bind_hash
) {
8483 inet_sk(sk
)->inet_num
= snum
;
8484 sk_add_bind_node(sk
, &pp
->owner
);
8490 spin_unlock_bh(&head
->lock
);
8494 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
8495 * port is requested.
8497 static int sctp_get_port(struct sock
*sk
, unsigned short snum
)
8499 union sctp_addr addr
;
8500 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
8502 /* Set up a dummy address struct from the sk. */
8503 af
->from_sk(&addr
, sk
);
8504 addr
.v4
.sin_port
= htons(snum
);
8506 /* Note: sk->sk_num gets filled in if ephemeral port request. */
8507 return sctp_get_port_local(sk
, &addr
);
8511 * Move a socket to LISTENING state.
8513 static int sctp_listen_start(struct sock
*sk
, int backlog
)
8515 struct sctp_sock
*sp
= sctp_sk(sk
);
8516 struct sctp_endpoint
*ep
= sp
->ep
;
8517 struct crypto_shash
*tfm
= NULL
;
8520 /* Allocate HMAC for generating cookie. */
8521 if (!sp
->hmac
&& sp
->sctp_hmac_alg
) {
8522 sprintf(alg
, "hmac(%s)", sp
->sctp_hmac_alg
);
8523 tfm
= crypto_alloc_shash(alg
, 0, 0);
8525 net_info_ratelimited("failed to load transform for %s: %ld\n",
8526 sp
->sctp_hmac_alg
, PTR_ERR(tfm
));
8529 sctp_sk(sk
)->hmac
= tfm
;
8533 * If a bind() or sctp_bindx() is not called prior to a listen()
8534 * call that allows new associations to be accepted, the system
8535 * picks an ephemeral port and will choose an address set equivalent
8536 * to binding with a wildcard address.
8538 * This is not currently spelled out in the SCTP sockets
8539 * extensions draft, but follows the practice as seen in TCP
8543 inet_sk_set_state(sk
, SCTP_SS_LISTENING
);
8544 if (!ep
->base
.bind_addr
.port
) {
8545 if (sctp_autobind(sk
))
8548 if (sctp_get_port(sk
, inet_sk(sk
)->inet_num
)) {
8549 inet_sk_set_state(sk
, SCTP_SS_CLOSED
);
8554 WRITE_ONCE(sk
->sk_max_ack_backlog
, backlog
);
8555 return sctp_hash_endpoint(ep
);
8559 * 4.1.3 / 5.1.3 listen()
8561 * By default, new associations are not accepted for UDP style sockets.
8562 * An application uses listen() to mark a socket as being able to
8563 * accept new associations.
8565 * On TCP style sockets, applications use listen() to ready the SCTP
8566 * endpoint for accepting inbound associations.
8568 * On both types of endpoints a backlog of '0' disables listening.
8570 * Move a socket to LISTENING state.
8572 int sctp_inet_listen(struct socket
*sock
, int backlog
)
8574 struct sock
*sk
= sock
->sk
;
8575 struct sctp_endpoint
*ep
= sctp_sk(sk
)->ep
;
8578 if (unlikely(backlog
< 0))
8583 /* Peeled-off sockets are not allowed to listen(). */
8584 if (sctp_style(sk
, UDP_HIGH_BANDWIDTH
))
8587 if (sock
->state
!= SS_UNCONNECTED
)
8590 if (!sctp_sstate(sk
, LISTENING
) && !sctp_sstate(sk
, CLOSED
))
8593 /* If backlog is zero, disable listening. */
8595 if (sctp_sstate(sk
, CLOSED
))
8599 sctp_unhash_endpoint(ep
);
8600 sk
->sk_state
= SCTP_SS_CLOSED
;
8601 if (sk
->sk_reuse
|| sctp_sk(sk
)->reuse
)
8602 sctp_sk(sk
)->bind_hash
->fastreuse
= 1;
8606 /* If we are already listening, just update the backlog */
8607 if (sctp_sstate(sk
, LISTENING
))
8608 WRITE_ONCE(sk
->sk_max_ack_backlog
, backlog
);
8610 err
= sctp_listen_start(sk
, backlog
);
8622 * This function is done by modeling the current datagram_poll() and the
8623 * tcp_poll(). Note that, based on these implementations, we don't
8624 * lock the socket in this function, even though it seems that,
8625 * ideally, locking or some other mechanisms can be used to ensure
8626 * the integrity of the counters (sndbuf and wmem_alloc) used
8627 * in this place. We assume that we don't need locks either until proven
8630 * Another thing to note is that we include the Async I/O support
8631 * here, again, by modeling the current TCP/UDP code. We don't have
8632 * a good way to test with it yet.
8634 __poll_t
sctp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
8636 struct sock
*sk
= sock
->sk
;
8637 struct sctp_sock
*sp
= sctp_sk(sk
);
8640 poll_wait(file
, sk_sleep(sk
), wait
);
8642 sock_rps_record_flow(sk
);
8644 /* A TCP-style listening socket becomes readable when the accept queue
8647 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
8648 return (!list_empty(&sp
->ep
->asocs
)) ?
8649 (EPOLLIN
| EPOLLRDNORM
) : 0;
8653 /* Is there any exceptional events? */
8654 if (sk
->sk_err
|| !skb_queue_empty_lockless(&sk
->sk_error_queue
))
8656 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? EPOLLPRI
: 0);
8657 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8658 mask
|= EPOLLRDHUP
| EPOLLIN
| EPOLLRDNORM
;
8659 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
8662 /* Is it readable? Reconsider this code with TCP-style support. */
8663 if (!skb_queue_empty_lockless(&sk
->sk_receive_queue
))
8664 mask
|= EPOLLIN
| EPOLLRDNORM
;
8666 /* The association is either gone or not ready. */
8667 if (!sctp_style(sk
, UDP
) && sctp_sstate(sk
, CLOSED
))
8670 /* Is it writable? */
8671 if (sctp_writeable(sk
)) {
8672 mask
|= EPOLLOUT
| EPOLLWRNORM
;
8674 sk_set_bit(SOCKWQ_ASYNC_NOSPACE
, sk
);
8676 * Since the socket is not locked, the buffer
8677 * might be made available after the writeable check and
8678 * before the bit is set. This could cause a lost I/O
8679 * signal. tcp_poll() has a race breaker for this race
8680 * condition. Based on their implementation, we put
8681 * in the following code to cover it as well.
8683 if (sctp_writeable(sk
))
8684 mask
|= EPOLLOUT
| EPOLLWRNORM
;
8689 /********************************************************************
8690 * 2nd Level Abstractions
8691 ********************************************************************/
8693 static struct sctp_bind_bucket
*sctp_bucket_create(
8694 struct sctp_bind_hashbucket
*head
, struct net
*net
, unsigned short snum
)
8696 struct sctp_bind_bucket
*pp
;
8698 pp
= kmem_cache_alloc(sctp_bucket_cachep
, GFP_ATOMIC
);
8700 SCTP_DBG_OBJCNT_INC(bind_bucket
);
8703 INIT_HLIST_HEAD(&pp
->owner
);
8705 hlist_add_head(&pp
->node
, &head
->chain
);
8710 /* Caller must hold hashbucket lock for this tb with local BH disabled */
8711 static void sctp_bucket_destroy(struct sctp_bind_bucket
*pp
)
8713 if (pp
&& hlist_empty(&pp
->owner
)) {
8714 __hlist_del(&pp
->node
);
8715 kmem_cache_free(sctp_bucket_cachep
, pp
);
8716 SCTP_DBG_OBJCNT_DEC(bind_bucket
);
8720 /* Release this socket's reference to a local port. */
8721 static inline void __sctp_put_port(struct sock
*sk
)
8723 struct sctp_bind_hashbucket
*head
=
8724 &sctp_port_hashtable
[sctp_phashfn(sock_net(sk
),
8725 inet_sk(sk
)->inet_num
)];
8726 struct sctp_bind_bucket
*pp
;
8728 spin_lock(&head
->lock
);
8729 pp
= sctp_sk(sk
)->bind_hash
;
8730 __sk_del_bind_node(sk
);
8731 sctp_sk(sk
)->bind_hash
= NULL
;
8732 inet_sk(sk
)->inet_num
= 0;
8733 sctp_bucket_destroy(pp
);
8734 spin_unlock(&head
->lock
);
8737 void sctp_put_port(struct sock
*sk
)
8740 __sctp_put_port(sk
);
8745 * The system picks an ephemeral port and choose an address set equivalent
8746 * to binding with a wildcard address.
8747 * One of those addresses will be the primary address for the association.
8748 * This automatically enables the multihoming capability of SCTP.
8750 static int sctp_autobind(struct sock
*sk
)
8752 union sctp_addr autoaddr
;
8756 /* Initialize a local sockaddr structure to INADDR_ANY. */
8757 af
= sctp_sk(sk
)->pf
->af
;
8759 port
= htons(inet_sk(sk
)->inet_num
);
8760 af
->inaddr_any(&autoaddr
, port
);
8762 return sctp_do_bind(sk
, &autoaddr
, af
->sockaddr_len
);
8765 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
8768 * 4.2 The cmsghdr Structure *
8770 * When ancillary data is sent or received, any number of ancillary data
8771 * objects can be specified by the msg_control and msg_controllen members of
8772 * the msghdr structure, because each object is preceded by
8773 * a cmsghdr structure defining the object's length (the cmsg_len member).
8774 * Historically Berkeley-derived implementations have passed only one object
8775 * at a time, but this API allows multiple objects to be
8776 * passed in a single call to sendmsg() or recvmsg(). The following example
8777 * shows two ancillary data objects in a control buffer.
8779 * |<--------------------------- msg_controllen -------------------------->|
8782 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
8784 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8787 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
8789 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
8792 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8793 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
8795 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
8797 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8804 static int sctp_msghdr_parse(const struct msghdr
*msg
, struct sctp_cmsgs
*cmsgs
)
8806 struct msghdr
*my_msg
= (struct msghdr
*)msg
;
8807 struct cmsghdr
*cmsg
;
8809 for_each_cmsghdr(cmsg
, my_msg
) {
8810 if (!CMSG_OK(my_msg
, cmsg
))
8813 /* Should we parse this header or ignore? */
8814 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
)
8817 /* Strictly check lengths following example in SCM code. */
8818 switch (cmsg
->cmsg_type
) {
8820 /* SCTP Socket API Extension
8821 * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
8823 * This cmsghdr structure provides information for
8824 * initializing new SCTP associations with sendmsg().
8825 * The SCTP_INITMSG socket option uses this same data
8826 * structure. This structure is not used for
8829 * cmsg_level cmsg_type cmsg_data[]
8830 * ------------ ------------ ----------------------
8831 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
8833 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_initmsg
)))
8836 cmsgs
->init
= CMSG_DATA(cmsg
);
8840 /* SCTP Socket API Extension
8841 * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
8843 * This cmsghdr structure specifies SCTP options for
8844 * sendmsg() and describes SCTP header information
8845 * about a received message through recvmsg().
8847 * cmsg_level cmsg_type cmsg_data[]
8848 * ------------ ------------ ----------------------
8849 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
8851 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndrcvinfo
)))
8854 cmsgs
->srinfo
= CMSG_DATA(cmsg
);
8856 if (cmsgs
->srinfo
->sinfo_flags
&
8857 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
8858 SCTP_SACK_IMMEDIATELY
| SCTP_SENDALL
|
8859 SCTP_PR_SCTP_MASK
| SCTP_ABORT
| SCTP_EOF
))
8864 /* SCTP Socket API Extension
8865 * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
8867 * This cmsghdr structure specifies SCTP options for
8868 * sendmsg(). This structure and SCTP_RCVINFO replaces
8869 * SCTP_SNDRCV which has been deprecated.
8871 * cmsg_level cmsg_type cmsg_data[]
8872 * ------------ ------------ ---------------------
8873 * IPPROTO_SCTP SCTP_SNDINFO struct sctp_sndinfo
8875 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_sndinfo
)))
8878 cmsgs
->sinfo
= CMSG_DATA(cmsg
);
8880 if (cmsgs
->sinfo
->snd_flags
&
8881 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
8882 SCTP_SACK_IMMEDIATELY
| SCTP_SENDALL
|
8883 SCTP_PR_SCTP_MASK
| SCTP_ABORT
| SCTP_EOF
))
8887 /* SCTP Socket API Extension
8888 * 5.3.7 SCTP PR-SCTP Information Structure (SCTP_PRINFO)
8890 * This cmsghdr structure specifies SCTP options for sendmsg().
8892 * cmsg_level cmsg_type cmsg_data[]
8893 * ------------ ------------ ---------------------
8894 * IPPROTO_SCTP SCTP_PRINFO struct sctp_prinfo
8896 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_prinfo
)))
8899 cmsgs
->prinfo
= CMSG_DATA(cmsg
);
8900 if (cmsgs
->prinfo
->pr_policy
& ~SCTP_PR_SCTP_MASK
)
8903 if (cmsgs
->prinfo
->pr_policy
== SCTP_PR_SCTP_NONE
)
8904 cmsgs
->prinfo
->pr_value
= 0;
8907 /* SCTP Socket API Extension
8908 * 5.3.8 SCTP AUTH Information Structure (SCTP_AUTHINFO)
8910 * This cmsghdr structure specifies SCTP options for sendmsg().
8912 * cmsg_level cmsg_type cmsg_data[]
8913 * ------------ ------------ ---------------------
8914 * IPPROTO_SCTP SCTP_AUTHINFO struct sctp_authinfo
8916 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct sctp_authinfo
)))
8919 cmsgs
->authinfo
= CMSG_DATA(cmsg
);
8921 case SCTP_DSTADDRV4
:
8922 case SCTP_DSTADDRV6
:
8923 /* SCTP Socket API Extension
8924 * 5.3.9/10 SCTP Destination IPv4/6 Address Structure (SCTP_DSTADDRV4/6)
8926 * This cmsghdr structure specifies SCTP options for sendmsg().
8928 * cmsg_level cmsg_type cmsg_data[]
8929 * ------------ ------------ ---------------------
8930 * IPPROTO_SCTP SCTP_DSTADDRV4 struct in_addr
8931 * ------------ ------------ ---------------------
8932 * IPPROTO_SCTP SCTP_DSTADDRV6 struct in6_addr
8934 cmsgs
->addrs_msg
= my_msg
;
8945 * Wait for a packet..
8946 * Note: This function is the same function as in core/datagram.c
8947 * with a few modifications to make lksctp work.
8949 static int sctp_wait_for_packet(struct sock
*sk
, int *err
, long *timeo_p
)
8954 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
8956 /* Socket errors? */
8957 error
= sock_error(sk
);
8961 if (!skb_queue_empty(&sk
->sk_receive_queue
))
8964 /* Socket shut down? */
8965 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
8968 /* Sequenced packets can come disconnected. If so we report the
8973 /* Is there a good reason to think that we may receive some data? */
8974 if (list_empty(&sctp_sk(sk
)->ep
->asocs
) && !sctp_sstate(sk
, LISTENING
))
8977 /* Handle signals. */
8978 if (signal_pending(current
))
8981 /* Let another process have a go. Since we are going to sleep
8982 * anyway. Note: This may cause odd behaviors if the message
8983 * does not fit in the user's buffer, but this seems to be the
8984 * only way to honor MSG_DONTWAIT realistically.
8987 *timeo_p
= schedule_timeout(*timeo_p
);
8991 finish_wait(sk_sleep(sk
), &wait
);
8995 error
= sock_intr_errno(*timeo_p
);
8998 finish_wait(sk_sleep(sk
), &wait
);
9003 /* Receive a datagram.
9004 * Note: This is pretty much the same routine as in core/datagram.c
9005 * with a few changes to make lksctp work.
9007 struct sk_buff
*sctp_skb_recv_datagram(struct sock
*sk
, int flags
, int *err
)
9010 struct sk_buff
*skb
;
9013 timeo
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
9015 pr_debug("%s: timeo:%ld, max:%ld\n", __func__
, timeo
,
9016 MAX_SCHEDULE_TIMEOUT
);
9019 /* Again only user level code calls this function,
9020 * so nothing interrupt level
9021 * will suddenly eat the receive_queue.
9023 * Look at current nfs client by the way...
9024 * However, this function was correct in any case. 8)
9026 if (flags
& MSG_PEEK
) {
9027 skb
= skb_peek(&sk
->sk_receive_queue
);
9029 refcount_inc(&skb
->users
);
9031 skb
= __skb_dequeue(&sk
->sk_receive_queue
);
9037 /* Caller is allowed not to check sk->sk_err before calling. */
9038 error
= sock_error(sk
);
9042 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
9045 if (sk_can_busy_loop(sk
)) {
9046 sk_busy_loop(sk
, flags
& MSG_DONTWAIT
);
9048 if (!skb_queue_empty_lockless(&sk
->sk_receive_queue
))
9052 /* User doesn't want to wait. */
9056 } while (sctp_wait_for_packet(sk
, err
, &timeo
) == 0);
9065 /* If sndbuf has changed, wake up per association sndbuf waiters. */
9066 static void __sctp_write_space(struct sctp_association
*asoc
)
9068 struct sock
*sk
= asoc
->base
.sk
;
9070 if (sctp_wspace(asoc
) <= 0)
9073 if (waitqueue_active(&asoc
->wait
))
9074 wake_up_interruptible(&asoc
->wait
);
9076 if (sctp_writeable(sk
)) {
9077 struct socket_wq
*wq
;
9080 wq
= rcu_dereference(sk
->sk_wq
);
9082 if (waitqueue_active(&wq
->wait
))
9083 wake_up_interruptible(&wq
->wait
);
9085 /* Note that we try to include the Async I/O support
9086 * here by modeling from the current TCP/UDP code.
9087 * We have not tested with it yet.
9089 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
))
9090 sock_wake_async(wq
, SOCK_WAKE_SPACE
, POLL_OUT
);
9096 static void sctp_wake_up_waiters(struct sock
*sk
,
9097 struct sctp_association
*asoc
)
9099 struct sctp_association
*tmp
= asoc
;
9101 /* We do accounting for the sndbuf space per association,
9102 * so we only need to wake our own association.
9104 if (asoc
->ep
->sndbuf_policy
)
9105 return __sctp_write_space(asoc
);
9107 /* If association goes down and is just flushing its
9108 * outq, then just normally notify others.
9110 if (asoc
->base
.dead
)
9111 return sctp_write_space(sk
);
9113 /* Accounting for the sndbuf space is per socket, so we
9114 * need to wake up others, try to be fair and in case of
9115 * other associations, let them have a go first instead
9116 * of just doing a sctp_write_space() call.
9118 * Note that we reach sctp_wake_up_waiters() only when
9119 * associations free up queued chunks, thus we are under
9120 * lock and the list of associations on a socket is
9121 * guaranteed not to change.
9123 for (tmp
= list_next_entry(tmp
, asocs
); 1;
9124 tmp
= list_next_entry(tmp
, asocs
)) {
9125 /* Manually skip the head element. */
9126 if (&tmp
->asocs
== &((sctp_sk(sk
))->ep
->asocs
))
9128 /* Wake up association. */
9129 __sctp_write_space(tmp
);
9130 /* We've reached the end. */
9136 /* Do accounting for the sndbuf space.
9137 * Decrement the used sndbuf space of the corresponding association by the
9138 * data size which was just transmitted(freed).
9140 static void sctp_wfree(struct sk_buff
*skb
)
9142 struct sctp_chunk
*chunk
= skb_shinfo(skb
)->destructor_arg
;
9143 struct sctp_association
*asoc
= chunk
->asoc
;
9144 struct sock
*sk
= asoc
->base
.sk
;
9146 sk_mem_uncharge(sk
, skb
->truesize
);
9147 sk_wmem_queued_add(sk
, -(skb
->truesize
+ sizeof(struct sctp_chunk
)));
9148 asoc
->sndbuf_used
-= skb
->truesize
+ sizeof(struct sctp_chunk
);
9149 WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk
),
9150 &sk
->sk_wmem_alloc
));
9153 struct sctp_shared_key
*shkey
= chunk
->shkey
;
9155 /* refcnt == 2 and !list_empty mean after this release, it's
9156 * not being used anywhere, and it's time to notify userland
9157 * that this shkey can be freed if it's been deactivated.
9159 if (shkey
->deactivated
&& !list_empty(&shkey
->key_list
) &&
9160 refcount_read(&shkey
->refcnt
) == 2) {
9161 struct sctp_ulpevent
*ev
;
9163 ev
= sctp_ulpevent_make_authkey(asoc
, shkey
->key_id
,
9167 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, ev
);
9169 sctp_auth_shkey_release(chunk
->shkey
);
9173 sctp_wake_up_waiters(sk
, asoc
);
9175 sctp_association_put(asoc
);
9178 /* Do accounting for the receive space on the socket.
9179 * Accounting for the association is done in ulpevent.c
9180 * We set this as a destructor for the cloned data skbs so that
9181 * accounting is done at the correct time.
9183 void sctp_sock_rfree(struct sk_buff
*skb
)
9185 struct sock
*sk
= skb
->sk
;
9186 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
9188 atomic_sub(event
->rmem_len
, &sk
->sk_rmem_alloc
);
9191 * Mimic the behavior of sock_rfree
9193 sk_mem_uncharge(sk
, event
->rmem_len
);
9197 /* Helper function to wait for space in the sndbuf. */
9198 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
9201 struct sock
*sk
= asoc
->base
.sk
;
9202 long current_timeo
= *timeo_p
;
9206 pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__
, asoc
,
9209 /* Increment the association's refcnt. */
9210 sctp_association_hold(asoc
);
9212 /* Wait on the association specific sndbuf space. */
9214 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
9215 TASK_INTERRUPTIBLE
);
9216 if (asoc
->base
.dead
)
9220 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
)
9222 if (signal_pending(current
))
9223 goto do_interrupted
;
9224 if ((int)msg_len
<= sctp_wspace(asoc
) &&
9225 sk_wmem_schedule(sk
, msg_len
))
9228 /* Let another process have a go. Since we are going
9232 current_timeo
= schedule_timeout(current_timeo
);
9234 if (sk
!= asoc
->base
.sk
)
9237 *timeo_p
= current_timeo
;
9241 finish_wait(&asoc
->wait
, &wait
);
9243 /* Release the association's refcnt. */
9244 sctp_association_put(asoc
);
9257 err
= sock_intr_errno(*timeo_p
);
9265 void sctp_data_ready(struct sock
*sk
)
9267 struct socket_wq
*wq
;
9269 trace_sk_data_ready(sk
);
9272 wq
= rcu_dereference(sk
->sk_wq
);
9273 if (skwq_has_sleeper(wq
))
9274 wake_up_interruptible_sync_poll(&wq
->wait
, EPOLLIN
|
9275 EPOLLRDNORM
| EPOLLRDBAND
);
9276 sk_wake_async(sk
, SOCK_WAKE_WAITD
, POLL_IN
);
9280 /* If socket sndbuf has changed, wake up all per association waiters. */
9281 void sctp_write_space(struct sock
*sk
)
9283 struct sctp_association
*asoc
;
9285 /* Wake up the tasks in each wait queue. */
9286 list_for_each_entry(asoc
, &((sctp_sk(sk
))->ep
->asocs
), asocs
) {
9287 __sctp_write_space(asoc
);
9291 /* Is there any sndbuf space available on the socket?
9293 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
9294 * associations on the same socket. For a UDP-style socket with
9295 * multiple associations, it is possible for it to be "unwriteable"
9296 * prematurely. I assume that this is acceptable because
9297 * a premature "unwriteable" is better than an accidental "writeable" which
9298 * would cause an unwanted block under certain circumstances. For the 1-1
9299 * UDP-style sockets or TCP-style sockets, this code should work.
9302 static bool sctp_writeable(const struct sock
*sk
)
9304 return READ_ONCE(sk
->sk_sndbuf
) > READ_ONCE(sk
->sk_wmem_queued
);
9307 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
9308 * returns immediately with EINPROGRESS.
9310 static int sctp_wait_for_connect(struct sctp_association
*asoc
, long *timeo_p
)
9312 struct sock
*sk
= asoc
->base
.sk
;
9314 long current_timeo
= *timeo_p
;
9317 pr_debug("%s: asoc:%p, timeo:%ld\n", __func__
, asoc
, *timeo_p
);
9319 /* Increment the association's refcnt. */
9320 sctp_association_hold(asoc
);
9323 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
9324 TASK_INTERRUPTIBLE
);
9327 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
9329 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
||
9332 if (signal_pending(current
))
9333 goto do_interrupted
;
9335 if (sctp_state(asoc
, ESTABLISHED
))
9338 /* Let another process have a go. Since we are going
9342 current_timeo
= schedule_timeout(current_timeo
);
9345 *timeo_p
= current_timeo
;
9349 finish_wait(&asoc
->wait
, &wait
);
9351 /* Release the association's refcnt. */
9352 sctp_association_put(asoc
);
9357 if (asoc
->init_err_counter
+ 1 > asoc
->max_init_attempts
)
9360 err
= -ECONNREFUSED
;
9364 err
= sock_intr_errno(*timeo_p
);
9372 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
)
9374 struct sctp_endpoint
*ep
;
9378 ep
= sctp_sk(sk
)->ep
;
9382 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
,
9383 TASK_INTERRUPTIBLE
);
9385 if (list_empty(&ep
->asocs
)) {
9387 timeo
= schedule_timeout(timeo
);
9392 if (!sctp_sstate(sk
, LISTENING
))
9396 if (!list_empty(&ep
->asocs
))
9399 err
= sock_intr_errno(timeo
);
9400 if (signal_pending(current
))
9408 finish_wait(sk_sleep(sk
), &wait
);
9413 static void sctp_wait_for_close(struct sock
*sk
, long timeout
)
9418 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
9419 if (list_empty(&sctp_sk(sk
)->ep
->asocs
))
9422 timeout
= schedule_timeout(timeout
);
9424 } while (!signal_pending(current
) && timeout
);
9426 finish_wait(sk_sleep(sk
), &wait
);
9429 static void sctp_skb_set_owner_r_frag(struct sk_buff
*skb
, struct sock
*sk
)
9431 struct sk_buff
*frag
;
9436 /* Don't forget the fragments. */
9437 skb_walk_frags(skb
, frag
)
9438 sctp_skb_set_owner_r_frag(frag
, sk
);
9441 sctp_skb_set_owner_r(skb
, sk
);
9444 void sctp_copy_sock(struct sock
*newsk
, struct sock
*sk
,
9445 struct sctp_association
*asoc
)
9447 struct inet_sock
*inet
= inet_sk(sk
);
9448 struct inet_sock
*newinet
;
9449 struct sctp_sock
*sp
= sctp_sk(sk
);
9451 newsk
->sk_type
= sk
->sk_type
;
9452 newsk
->sk_bound_dev_if
= sk
->sk_bound_dev_if
;
9453 newsk
->sk_flags
= sk
->sk_flags
;
9454 newsk
->sk_tsflags
= sk
->sk_tsflags
;
9455 newsk
->sk_no_check_tx
= sk
->sk_no_check_tx
;
9456 newsk
->sk_no_check_rx
= sk
->sk_no_check_rx
;
9457 newsk
->sk_reuse
= sk
->sk_reuse
;
9458 sctp_sk(newsk
)->reuse
= sp
->reuse
;
9460 newsk
->sk_shutdown
= sk
->sk_shutdown
;
9461 newsk
->sk_destruct
= sk
->sk_destruct
;
9462 newsk
->sk_family
= sk
->sk_family
;
9463 newsk
->sk_protocol
= IPPROTO_SCTP
;
9464 newsk
->sk_backlog_rcv
= sk
->sk_prot
->backlog_rcv
;
9465 newsk
->sk_sndbuf
= sk
->sk_sndbuf
;
9466 newsk
->sk_rcvbuf
= sk
->sk_rcvbuf
;
9467 newsk
->sk_lingertime
= sk
->sk_lingertime
;
9468 newsk
->sk_rcvtimeo
= sk
->sk_rcvtimeo
;
9469 newsk
->sk_sndtimeo
= sk
->sk_sndtimeo
;
9470 newsk
->sk_rxhash
= sk
->sk_rxhash
;
9472 newinet
= inet_sk(newsk
);
9474 /* Initialize sk's sport, dport, rcv_saddr and daddr for
9475 * getsockname() and getpeername()
9477 newinet
->inet_sport
= inet
->inet_sport
;
9478 newinet
->inet_saddr
= inet
->inet_saddr
;
9479 newinet
->inet_rcv_saddr
= inet
->inet_rcv_saddr
;
9480 newinet
->inet_dport
= htons(asoc
->peer
.port
);
9481 newinet
->pmtudisc
= inet
->pmtudisc
;
9482 atomic_set(&newinet
->inet_id
, get_random_u16());
9484 newinet
->uc_ttl
= inet
->uc_ttl
;
9485 inet_set_bit(MC_LOOP
, newsk
);
9486 newinet
->mc_ttl
= 1;
9487 newinet
->mc_index
= 0;
9488 newinet
->mc_list
= NULL
;
9490 if (newsk
->sk_flags
& SK_FLAGS_TIMESTAMP
)
9491 net_enable_timestamp();
9493 /* Set newsk security attributes from original sk and connection
9494 * security attribute from asoc.
9496 security_sctp_sk_clone(asoc
, sk
, newsk
);
9499 static inline void sctp_copy_descendant(struct sock
*sk_to
,
9500 const struct sock
*sk_from
)
9502 size_t ancestor_size
= sizeof(struct inet_sock
);
9504 ancestor_size
+= sk_from
->sk_prot
->obj_size
;
9505 ancestor_size
-= offsetof(struct sctp_sock
, pd_lobby
);
9506 __inet_sk_copy_descendant(sk_to
, sk_from
, ancestor_size
);
9509 /* Populate the fields of the newsk from the oldsk and migrate the assoc
9510 * and its messages to the newsk.
9512 static int sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
9513 struct sctp_association
*assoc
,
9514 enum sctp_socket_type type
)
9516 struct sctp_sock
*oldsp
= sctp_sk(oldsk
);
9517 struct sctp_sock
*newsp
= sctp_sk(newsk
);
9518 struct sctp_bind_bucket
*pp
; /* hash list port iterator */
9519 struct sctp_endpoint
*newep
= newsp
->ep
;
9520 struct sk_buff
*skb
, *tmp
;
9521 struct sctp_ulpevent
*event
;
9522 struct sctp_bind_hashbucket
*head
;
9525 /* Migrate socket buffer sizes and all the socket level options to the
9528 newsk
->sk_sndbuf
= oldsk
->sk_sndbuf
;
9529 newsk
->sk_rcvbuf
= oldsk
->sk_rcvbuf
;
9530 /* Brute force copy old sctp opt. */
9531 sctp_copy_descendant(newsk
, oldsk
);
9533 /* Restore the ep value that was overwritten with the above structure
9539 /* Hook this new socket in to the bind_hash list. */
9540 head
= &sctp_port_hashtable
[sctp_phashfn(sock_net(oldsk
),
9541 inet_sk(oldsk
)->inet_num
)];
9542 spin_lock_bh(&head
->lock
);
9543 pp
= sctp_sk(oldsk
)->bind_hash
;
9544 sk_add_bind_node(newsk
, &pp
->owner
);
9545 sctp_sk(newsk
)->bind_hash
= pp
;
9546 inet_sk(newsk
)->inet_num
= inet_sk(oldsk
)->inet_num
;
9547 spin_unlock_bh(&head
->lock
);
9549 /* Copy the bind_addr list from the original endpoint to the new
9550 * endpoint so that we can handle restarts properly
9552 err
= sctp_bind_addr_dup(&newsp
->ep
->base
.bind_addr
,
9553 &oldsp
->ep
->base
.bind_addr
, GFP_KERNEL
);
9557 /* New ep's auth_hmacs should be set if old ep's is set, in case
9558 * that net->sctp.auth_enable has been changed to 0 by users and
9559 * new ep's auth_hmacs couldn't be set in sctp_endpoint_init().
9561 if (oldsp
->ep
->auth_hmacs
) {
9562 err
= sctp_auth_init_hmacs(newsp
->ep
, GFP_KERNEL
);
9567 sctp_auto_asconf_init(newsp
);
9569 /* Move any messages in the old socket's receive queue that are for the
9570 * peeled off association to the new socket's receive queue.
9572 sctp_skb_for_each(skb
, &oldsk
->sk_receive_queue
, tmp
) {
9573 event
= sctp_skb2event(skb
);
9574 if (event
->asoc
== assoc
) {
9575 __skb_unlink(skb
, &oldsk
->sk_receive_queue
);
9576 __skb_queue_tail(&newsk
->sk_receive_queue
, skb
);
9577 sctp_skb_set_owner_r_frag(skb
, newsk
);
9581 /* Clean up any messages pending delivery due to partial
9582 * delivery. Three cases:
9583 * 1) No partial deliver; no work.
9584 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
9585 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
9587 atomic_set(&sctp_sk(newsk
)->pd_mode
, assoc
->ulpq
.pd_mode
);
9589 if (atomic_read(&sctp_sk(oldsk
)->pd_mode
)) {
9590 struct sk_buff_head
*queue
;
9592 /* Decide which queue to move pd_lobby skbs to. */
9593 if (assoc
->ulpq
.pd_mode
) {
9594 queue
= &newsp
->pd_lobby
;
9596 queue
= &newsk
->sk_receive_queue
;
9598 /* Walk through the pd_lobby, looking for skbs that
9599 * need moved to the new socket.
9601 sctp_skb_for_each(skb
, &oldsp
->pd_lobby
, tmp
) {
9602 event
= sctp_skb2event(skb
);
9603 if (event
->asoc
== assoc
) {
9604 __skb_unlink(skb
, &oldsp
->pd_lobby
);
9605 __skb_queue_tail(queue
, skb
);
9606 sctp_skb_set_owner_r_frag(skb
, newsk
);
9610 /* Clear up any skbs waiting for the partial
9611 * delivery to finish.
9613 if (assoc
->ulpq
.pd_mode
)
9614 sctp_clear_pd(oldsk
, NULL
);
9618 sctp_for_each_rx_skb(assoc
, newsk
, sctp_skb_set_owner_r_frag
);
9620 /* Set the type of socket to indicate that it is peeled off from the
9621 * original UDP-style socket or created with the accept() call on a
9622 * TCP-style socket..
9626 /* Mark the new socket "in-use" by the user so that any packets
9627 * that may arrive on the association after we've moved it are
9628 * queued to the backlog. This prevents a potential race between
9629 * backlog processing on the old socket and new-packet processing
9630 * on the new socket.
9632 * The caller has just allocated newsk so we can guarantee that other
9633 * paths won't try to lock it and then oldsk.
9635 lock_sock_nested(newsk
, SINGLE_DEPTH_NESTING
);
9636 sctp_for_each_tx_datachunk(assoc
, true, sctp_clear_owner_w
);
9637 sctp_assoc_migrate(assoc
, newsk
);
9638 sctp_for_each_tx_datachunk(assoc
, false, sctp_set_owner_w
);
9640 /* If the association on the newsk is already closed before accept()
9641 * is called, set RCV_SHUTDOWN flag.
9643 if (sctp_state(assoc
, CLOSED
) && sctp_style(newsk
, TCP
)) {
9644 inet_sk_set_state(newsk
, SCTP_SS_CLOSED
);
9645 newsk
->sk_shutdown
|= RCV_SHUTDOWN
;
9647 inet_sk_set_state(newsk
, SCTP_SS_ESTABLISHED
);
9650 release_sock(newsk
);
9656 /* This proto struct describes the ULP interface for SCTP. */
9657 struct proto sctp_prot
= {
9659 .owner
= THIS_MODULE
,
9660 .close
= sctp_close
,
9661 .disconnect
= sctp_disconnect
,
9662 .accept
= sctp_accept
,
9663 .ioctl
= sctp_ioctl
,
9664 .init
= sctp_init_sock
,
9665 .destroy
= sctp_destroy_sock
,
9666 .shutdown
= sctp_shutdown
,
9667 .setsockopt
= sctp_setsockopt
,
9668 .getsockopt
= sctp_getsockopt
,
9669 .bpf_bypass_getsockopt
= sctp_bpf_bypass_getsockopt
,
9670 .sendmsg
= sctp_sendmsg
,
9671 .recvmsg
= sctp_recvmsg
,
9673 .bind_add
= sctp_bind_add
,
9674 .backlog_rcv
= sctp_backlog_rcv
,
9676 .unhash
= sctp_unhash
,
9677 .no_autobind
= true,
9678 .obj_size
= sizeof(struct sctp_sock
),
9679 .useroffset
= offsetof(struct sctp_sock
, subscribe
),
9680 .usersize
= offsetof(struct sctp_sock
, initmsg
) -
9681 offsetof(struct sctp_sock
, subscribe
) +
9682 sizeof_field(struct sctp_sock
, initmsg
),
9683 .sysctl_mem
= sysctl_sctp_mem
,
9684 .sysctl_rmem
= sysctl_sctp_rmem
,
9685 .sysctl_wmem
= sysctl_sctp_wmem
,
9686 .memory_pressure
= &sctp_memory_pressure
,
9687 .enter_memory_pressure
= sctp_enter_memory_pressure
,
9689 .memory_allocated
= &sctp_memory_allocated
,
9690 .per_cpu_fw_alloc
= &sctp_memory_per_cpu_fw_alloc
,
9692 .sockets_allocated
= &sctp_sockets_allocated
,
9695 #if IS_ENABLED(CONFIG_IPV6)
9697 static void sctp_v6_destruct_sock(struct sock
*sk
)
9699 sctp_destruct_common(sk
);
9700 inet6_sock_destruct(sk
);
9703 static int sctp_v6_init_sock(struct sock
*sk
)
9705 int ret
= sctp_init_sock(sk
);
9708 sk
->sk_destruct
= sctp_v6_destruct_sock
;
9713 struct proto sctpv6_prot
= {
9715 .owner
= THIS_MODULE
,
9716 .close
= sctp_close
,
9717 .disconnect
= sctp_disconnect
,
9718 .accept
= sctp_accept
,
9719 .ioctl
= sctp_ioctl
,
9720 .init
= sctp_v6_init_sock
,
9721 .destroy
= sctp_destroy_sock
,
9722 .shutdown
= sctp_shutdown
,
9723 .setsockopt
= sctp_setsockopt
,
9724 .getsockopt
= sctp_getsockopt
,
9725 .bpf_bypass_getsockopt
= sctp_bpf_bypass_getsockopt
,
9726 .sendmsg
= sctp_sendmsg
,
9727 .recvmsg
= sctp_recvmsg
,
9729 .bind_add
= sctp_bind_add
,
9730 .backlog_rcv
= sctp_backlog_rcv
,
9732 .unhash
= sctp_unhash
,
9733 .no_autobind
= true,
9734 .obj_size
= sizeof(struct sctp6_sock
),
9735 .ipv6_pinfo_offset
= offsetof(struct sctp6_sock
, inet6
),
9736 .useroffset
= offsetof(struct sctp6_sock
, sctp
.subscribe
),
9737 .usersize
= offsetof(struct sctp6_sock
, sctp
.initmsg
) -
9738 offsetof(struct sctp6_sock
, sctp
.subscribe
) +
9739 sizeof_field(struct sctp6_sock
, sctp
.initmsg
),
9740 .sysctl_mem
= sysctl_sctp_mem
,
9741 .sysctl_rmem
= sysctl_sctp_rmem
,
9742 .sysctl_wmem
= sysctl_sctp_wmem
,
9743 .memory_pressure
= &sctp_memory_pressure
,
9744 .enter_memory_pressure
= sctp_enter_memory_pressure
,
9746 .memory_allocated
= &sctp_memory_allocated
,
9747 .per_cpu_fw_alloc
= &sctp_memory_per_cpu_fw_alloc
,
9749 .sockets_allocated
= &sctp_sockets_allocated
,
9751 #endif /* IS_ENABLED(CONFIG_IPV6) */