1 /* SCTP kernel reference Implementation
2 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999-2000 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
5 * Copyright (c) 2001-2003 Intel Corp.
6 * Copyright (c) 2001-2002 Nokia, Inc.
7 * Copyright (c) 2001 La Monte H.P. Yarroll
9 * This file is part of the SCTP kernel reference Implementation
11 * These functions interface with the sockets layer to implement the
12 * SCTP Extensions for the Sockets API.
14 * Note that the descriptions from the specification are USER level
15 * functions--this file is the functions which populate the struct proto
16 * for SCTP which is the BOTTOM of the sockets interface.
18 * The SCTP reference implementation is free software;
19 * you can redistribute it and/or modify it under the terms of
20 * the GNU General Public License as published by
21 * the Free Software Foundation; either version 2, or (at your option)
24 * The SCTP reference implementation is distributed in the hope that it
25 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
26 * ************************
27 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
28 * See the GNU General Public License for more details.
30 * You should have received a copy of the GNU General Public License
31 * along with GNU CC; see the file COPYING. If not, write to
32 * the Free Software Foundation, 59 Temple Place - Suite 330,
33 * Boston, MA 02111-1307, USA.
35 * Please send any bug reports or fixes you make to the
37 * lksctp developers <lksctp-developers@lists.sourceforge.net>
39 * Or submit a bug report through the following website:
40 * http://www.sf.net/projects/lksctp
42 * Written or modified by:
43 * La Monte H.P. Yarroll <piggy@acm.org>
44 * Narasimha Budihal <narsi@refcode.org>
45 * Karl Knutson <karl@athena.chicago.il.us>
46 * Jon Grimm <jgrimm@us.ibm.com>
47 * Xingang Guo <xingang.guo@intel.com>
48 * Daisy Chang <daisyc@us.ibm.com>
49 * Sridhar Samudrala <samudrala@us.ibm.com>
50 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>
51 * Ardelle Fan <ardelle.fan@intel.com>
52 * Ryan Layer <rmlayer@us.ibm.com>
53 * Anup Pemmaiah <pemmaiah@cc.usu.edu>
54 * Kevin Gao <kevin.gao@intel.com>
56 * Any bugs reported given to us we will try to fix... any fixes shared will
57 * be incorporated into the next SCTP release.
60 #include <linux/types.h>
61 #include <linux/kernel.h>
62 #include <linux/wait.h>
63 #include <linux/time.h>
65 #include <linux/capability.h>
66 #include <linux/fcntl.h>
67 #include <linux/poll.h>
68 #include <linux/init.h>
69 #include <linux/crypto.h>
73 #include <net/route.h>
75 #include <net/inet_common.h>
77 #include <linux/socket.h> /* for sa_family_t */
79 #include <net/sctp/sctp.h>
80 #include <net/sctp/sm.h>
82 /* WARNING: Please do not remove the SCTP_STATIC attribute to
83 * any of the functions below as they are used to export functions
84 * used by a project regression testsuite.
87 /* Forward declarations for internal helper functions. */
88 static int sctp_writeable(struct sock
*sk
);
89 static void sctp_wfree(struct sk_buff
*skb
);
90 static int sctp_wait_for_sndbuf(struct sctp_association
*, long *timeo_p
,
92 static int sctp_wait_for_packet(struct sock
* sk
, int *err
, long *timeo_p
);
93 static int sctp_wait_for_connect(struct sctp_association
*, long *timeo_p
);
94 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
);
95 static void sctp_wait_for_close(struct sock
*sk
, long timeo
);
96 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
97 union sctp_addr
*addr
, int len
);
98 static int sctp_bindx_add(struct sock
*, struct sockaddr
*, int);
99 static int sctp_bindx_rem(struct sock
*, struct sockaddr
*, int);
100 static int sctp_send_asconf_add_ip(struct sock
*, struct sockaddr
*, int);
101 static int sctp_send_asconf_del_ip(struct sock
*, struct sockaddr
*, int);
102 static int sctp_send_asconf(struct sctp_association
*asoc
,
103 struct sctp_chunk
*chunk
);
104 static int sctp_do_bind(struct sock
*, union sctp_addr
*, int);
105 static int sctp_autobind(struct sock
*sk
);
106 static void sctp_sock_migrate(struct sock
*, struct sock
*,
107 struct sctp_association
*, sctp_socket_type_t
);
108 static char *sctp_hmac_alg
= SCTP_COOKIE_HMAC_ALG
;
110 extern kmem_cache_t
*sctp_bucket_cachep
;
112 /* Get the sndbuf space available at the time on the association. */
113 static inline int sctp_wspace(struct sctp_association
*asoc
)
115 struct sock
*sk
= asoc
->base
.sk
;
118 if (asoc
->ep
->sndbuf_policy
) {
119 /* make sure that no association uses more than sk_sndbuf */
120 amt
= sk
->sk_sndbuf
- asoc
->sndbuf_used
;
122 /* do socket level accounting */
123 amt
= sk
->sk_sndbuf
- atomic_read(&sk
->sk_wmem_alloc
);
132 /* Increment the used sndbuf space count of the corresponding association by
133 * the size of the outgoing data chunk.
134 * Also, set the skb destructor for sndbuf accounting later.
136 * Since it is always 1-1 between chunk and skb, and also a new skb is always
137 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
138 * destructor in the data chunk skb for the purpose of the sndbuf space
141 static inline void sctp_set_owner_w(struct sctp_chunk
*chunk
)
143 struct sctp_association
*asoc
= chunk
->asoc
;
144 struct sock
*sk
= asoc
->base
.sk
;
146 /* The sndbuf space is tracked per association. */
147 sctp_association_hold(asoc
);
149 skb_set_owner_w(chunk
->skb
, sk
);
151 chunk
->skb
->destructor
= sctp_wfree
;
152 /* Save the chunk pointer in skb for sctp_wfree to use later. */
153 *((struct sctp_chunk
**)(chunk
->skb
->cb
)) = chunk
;
155 asoc
->sndbuf_used
+= SCTP_DATA_SNDSIZE(chunk
) +
156 sizeof(struct sk_buff
) +
157 sizeof(struct sctp_chunk
);
159 atomic_add(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
);
162 /* Verify that this is a valid address. */
163 static inline int sctp_verify_addr(struct sock
*sk
, union sctp_addr
*addr
,
168 /* Verify basic sockaddr. */
169 af
= sctp_sockaddr_af(sctp_sk(sk
), addr
, len
);
173 /* Is this a valid SCTP address? */
174 if (!af
->addr_valid(addr
, sctp_sk(sk
), NULL
))
177 if (!sctp_sk(sk
)->pf
->send_verify(sctp_sk(sk
), (addr
)))
183 /* Look up the association by its id. If this is not a UDP-style
184 * socket, the ID field is always ignored.
186 struct sctp_association
*sctp_id2assoc(struct sock
*sk
, sctp_assoc_t id
)
188 struct sctp_association
*asoc
= NULL
;
190 /* If this is not a UDP-style socket, assoc id should be ignored. */
191 if (!sctp_style(sk
, UDP
)) {
192 /* Return NULL if the socket state is not ESTABLISHED. It
193 * could be a TCP-style listening socket or a socket which
194 * hasn't yet called connect() to establish an association.
196 if (!sctp_sstate(sk
, ESTABLISHED
))
199 /* Get the first and the only association from the list. */
200 if (!list_empty(&sctp_sk(sk
)->ep
->asocs
))
201 asoc
= list_entry(sctp_sk(sk
)->ep
->asocs
.next
,
202 struct sctp_association
, asocs
);
206 /* Otherwise this is a UDP-style socket. */
207 if (!id
|| (id
== (sctp_assoc_t
)-1))
210 spin_lock_bh(&sctp_assocs_id_lock
);
211 asoc
= (struct sctp_association
*)idr_find(&sctp_assocs_id
, (int)id
);
212 spin_unlock_bh(&sctp_assocs_id_lock
);
214 if (!asoc
|| (asoc
->base
.sk
!= sk
) || asoc
->base
.dead
)
220 /* Look up the transport from an address and an assoc id. If both address and
221 * id are specified, the associations matching the address and the id should be
224 static struct sctp_transport
*sctp_addr_id2transport(struct sock
*sk
,
225 struct sockaddr_storage
*addr
,
228 struct sctp_association
*addr_asoc
= NULL
, *id_asoc
= NULL
;
229 struct sctp_transport
*transport
;
230 union sctp_addr
*laddr
= (union sctp_addr
*)addr
;
232 addr_asoc
= sctp_endpoint_lookup_assoc(sctp_sk(sk
)->ep
,
239 id_asoc
= sctp_id2assoc(sk
, id
);
240 if (id_asoc
&& (id_asoc
!= addr_asoc
))
243 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sctp_sk(sk
),
244 (union sctp_addr
*)addr
);
249 /* API 3.1.2 bind() - UDP Style Syntax
250 * The syntax of bind() is,
252 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
254 * sd - the socket descriptor returned by socket().
255 * addr - the address structure (struct sockaddr_in or struct
256 * sockaddr_in6 [RFC 2553]),
257 * addr_len - the size of the address structure.
259 SCTP_STATIC
int sctp_bind(struct sock
*sk
, struct sockaddr
*addr
, int addr_len
)
265 SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n",
268 /* Disallow binding twice. */
269 if (!sctp_sk(sk
)->ep
->base
.bind_addr
.port
)
270 retval
= sctp_do_bind(sk
, (union sctp_addr
*)addr
,
275 sctp_release_sock(sk
);
280 static long sctp_get_port_local(struct sock
*, union sctp_addr
*);
282 /* Verify this is a valid sockaddr. */
283 static struct sctp_af
*sctp_sockaddr_af(struct sctp_sock
*opt
,
284 union sctp_addr
*addr
, int len
)
288 /* Check minimum size. */
289 if (len
< sizeof (struct sockaddr
))
292 /* Does this PF support this AF? */
293 if (!opt
->pf
->af_supported(addr
->sa
.sa_family
, opt
))
296 /* If we get this far, af is valid. */
297 af
= sctp_get_af_specific(addr
->sa
.sa_family
);
299 if (len
< af
->sockaddr_len
)
305 /* Bind a local address either to an endpoint or to an association. */
306 SCTP_STATIC
int sctp_do_bind(struct sock
*sk
, union sctp_addr
*addr
, int len
)
308 struct sctp_sock
*sp
= sctp_sk(sk
);
309 struct sctp_endpoint
*ep
= sp
->ep
;
310 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
315 /* Common sockaddr verification. */
316 af
= sctp_sockaddr_af(sp
, addr
, len
);
318 SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n",
323 snum
= ntohs(addr
->v4
.sin_port
);
325 SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ",
326 ", port: %d, new port: %d, len: %d)\n",
332 /* PF specific bind() address verification. */
333 if (!sp
->pf
->bind_verify(sp
, addr
))
334 return -EADDRNOTAVAIL
;
336 /* We must either be unbound, or bind to the same port. */
337 if (bp
->port
&& (snum
!= bp
->port
)) {
338 SCTP_DEBUG_PRINTK("sctp_do_bind:"
339 " New port %d does not match existing port "
340 "%d.\n", snum
, bp
->port
);
344 if (snum
&& snum
< PROT_SOCK
&& !capable(CAP_NET_BIND_SERVICE
))
347 /* Make sure we are allowed to bind here.
348 * The function sctp_get_port_local() does duplicate address
351 if ((ret
= sctp_get_port_local(sk
, addr
))) {
352 if (ret
== (long) sk
) {
353 /* This endpoint has a conflicting address. */
360 /* Refresh ephemeral port. */
362 bp
->port
= inet_sk(sk
)->num
;
364 /* Add the address to the bind address list. */
365 sctp_local_bh_disable();
366 sctp_write_lock(&ep
->base
.addr_lock
);
368 /* Use GFP_ATOMIC since BHs are disabled. */
369 ret
= sctp_add_bind_addr(bp
, addr
, 1, GFP_ATOMIC
);
370 sctp_write_unlock(&ep
->base
.addr_lock
);
371 sctp_local_bh_enable();
373 /* Copy back into socket for getsockname() use. */
375 inet_sk(sk
)->sport
= htons(inet_sk(sk
)->num
);
376 af
->to_sk_saddr(addr
, sk
);
382 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
384 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
385 * at any one time. If a sender, after sending an ASCONF chunk, decides
386 * it needs to transfer another ASCONF Chunk, it MUST wait until the
387 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
388 * subsequent ASCONF. Note this restriction binds each side, so at any
389 * time two ASCONF may be in-transit on any given association (one sent
390 * from each endpoint).
392 static int sctp_send_asconf(struct sctp_association
*asoc
,
393 struct sctp_chunk
*chunk
)
397 /* If there is an outstanding ASCONF chunk, queue it for later
400 if (asoc
->addip_last_asconf
) {
401 list_add_tail(&chunk
->list
, &asoc
->addip_chunk_list
);
405 /* Hold the chunk until an ASCONF_ACK is received. */
406 sctp_chunk_hold(chunk
);
407 retval
= sctp_primitive_ASCONF(asoc
, chunk
);
409 sctp_chunk_free(chunk
);
411 asoc
->addip_last_asconf
= chunk
;
417 /* Add a list of addresses as bind addresses to local endpoint or
420 * Basically run through each address specified in the addrs/addrcnt
421 * array/length pair, determine if it is IPv6 or IPv4 and call
422 * sctp_do_bind() on it.
424 * If any of them fails, then the operation will be reversed and the
425 * ones that were added will be removed.
427 * Only sctp_setsockopt_bindx() is supposed to call this function.
429 int sctp_bindx_add(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
434 struct sockaddr
*sa_addr
;
437 SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n",
441 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
442 /* The list may contain either IPv4 or IPv6 address;
443 * determine the address length for walking thru the list.
445 sa_addr
= (struct sockaddr
*)addr_buf
;
446 af
= sctp_get_af_specific(sa_addr
->sa_family
);
452 retval
= sctp_do_bind(sk
, (union sctp_addr
*)sa_addr
,
455 addr_buf
+= af
->sockaddr_len
;
459 /* Failed. Cleanup the ones that have been added */
461 sctp_bindx_rem(sk
, addrs
, cnt
);
469 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
470 * associations that are part of the endpoint indicating that a list of local
471 * addresses are added to the endpoint.
473 * If any of the addresses is already in the bind address list of the
474 * association, we do not send the chunk for that association. But it will not
475 * affect other associations.
477 * Only sctp_setsockopt_bindx() is supposed to call this function.
479 static int sctp_send_asconf_add_ip(struct sock
*sk
,
480 struct sockaddr
*addrs
,
483 struct sctp_sock
*sp
;
484 struct sctp_endpoint
*ep
;
485 struct sctp_association
*asoc
;
486 struct sctp_bind_addr
*bp
;
487 struct sctp_chunk
*chunk
;
488 struct sctp_sockaddr_entry
*laddr
;
489 union sctp_addr
*addr
;
490 union sctp_addr saveaddr
;
493 struct list_head
*pos
;
498 if (!sctp_addip_enable
)
504 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
505 __FUNCTION__
, sk
, addrs
, addrcnt
);
507 list_for_each(pos
, &ep
->asocs
) {
508 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
510 if (!asoc
->peer
.asconf_capable
)
513 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_ADD_IP
)
516 if (!sctp_state(asoc
, ESTABLISHED
))
519 /* Check if any address in the packed array of addresses is
520 * in the bind address list of the association. If so,
521 * do not send the asconf chunk to its peer, but continue with
522 * other associations.
525 for (i
= 0; i
< addrcnt
; i
++) {
526 addr
= (union sctp_addr
*)addr_buf
;
527 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
533 if (sctp_assoc_lookup_laddr(asoc
, addr
))
536 addr_buf
+= af
->sockaddr_len
;
541 /* Use the first address in bind addr list of association as
542 * Address Parameter of ASCONF CHUNK.
544 sctp_read_lock(&asoc
->base
.addr_lock
);
545 bp
= &asoc
->base
.bind_addr
;
546 p
= bp
->address_list
.next
;
547 laddr
= list_entry(p
, struct sctp_sockaddr_entry
, list
);
548 sctp_read_unlock(&asoc
->base
.addr_lock
);
550 chunk
= sctp_make_asconf_update_ip(asoc
, &laddr
->a
, addrs
,
551 addrcnt
, SCTP_PARAM_ADD_IP
);
557 retval
= sctp_send_asconf(asoc
, chunk
);
561 /* Add the new addresses to the bind address list with
562 * use_as_src set to 0.
564 sctp_local_bh_disable();
565 sctp_write_lock(&asoc
->base
.addr_lock
);
567 for (i
= 0; i
< addrcnt
; i
++) {
568 addr
= (union sctp_addr
*)addr_buf
;
569 af
= sctp_get_af_specific(addr
->v4
.sin_family
);
570 memcpy(&saveaddr
, addr
, af
->sockaddr_len
);
571 retval
= sctp_add_bind_addr(bp
, &saveaddr
, 0,
573 addr_buf
+= af
->sockaddr_len
;
575 sctp_write_unlock(&asoc
->base
.addr_lock
);
576 sctp_local_bh_enable();
583 /* Remove a list of addresses from bind addresses list. Do not remove the
586 * Basically run through each address specified in the addrs/addrcnt
587 * array/length pair, determine if it is IPv6 or IPv4 and call
588 * sctp_del_bind() on it.
590 * If any of them fails, then the operation will be reversed and the
591 * ones that were removed will be added back.
593 * At least one address has to be left; if only one address is
594 * available, the operation will return -EBUSY.
596 * Only sctp_setsockopt_bindx() is supposed to call this function.
598 int sctp_bindx_rem(struct sock
*sk
, struct sockaddr
*addrs
, int addrcnt
)
600 struct sctp_sock
*sp
= sctp_sk(sk
);
601 struct sctp_endpoint
*ep
= sp
->ep
;
603 struct sctp_bind_addr
*bp
= &ep
->base
.bind_addr
;
606 union sctp_addr
*sa_addr
;
609 SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n",
613 for (cnt
= 0; cnt
< addrcnt
; cnt
++) {
614 /* If the bind address list is empty or if there is only one
615 * bind address, there is nothing more to be removed (we need
616 * at least one address here).
618 if (list_empty(&bp
->address_list
) ||
619 (sctp_list_single_entry(&bp
->address_list
))) {
624 sa_addr
= (union sctp_addr
*)addr_buf
;
625 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
630 if (sa_addr
->v4
.sin_port
!= htons(bp
->port
)) {
635 /* FIXME - There is probably a need to check if sk->sk_saddr and
636 * sk->sk_rcv_addr are currently set to one of the addresses to
637 * be removed. This is something which needs to be looked into
638 * when we are fixing the outstanding issues with multi-homing
639 * socket routing and failover schemes. Refer to comments in
640 * sctp_do_bind(). -daisy
642 sctp_local_bh_disable();
643 sctp_write_lock(&ep
->base
.addr_lock
);
645 retval
= sctp_del_bind_addr(bp
, sa_addr
);
647 sctp_write_unlock(&ep
->base
.addr_lock
);
648 sctp_local_bh_enable();
650 addr_buf
+= af
->sockaddr_len
;
653 /* Failed. Add the ones that has been removed back */
655 sctp_bindx_add(sk
, addrs
, cnt
);
663 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
664 * the associations that are part of the endpoint indicating that a list of
665 * local addresses are removed from the endpoint.
667 * If any of the addresses is already in the bind address list of the
668 * association, we do not send the chunk for that association. But it will not
669 * affect other associations.
671 * Only sctp_setsockopt_bindx() is supposed to call this function.
673 static int sctp_send_asconf_del_ip(struct sock
*sk
,
674 struct sockaddr
*addrs
,
677 struct sctp_sock
*sp
;
678 struct sctp_endpoint
*ep
;
679 struct sctp_association
*asoc
;
680 struct sctp_transport
*transport
;
681 struct sctp_bind_addr
*bp
;
682 struct sctp_chunk
*chunk
;
683 union sctp_addr
*laddr
;
686 struct list_head
*pos
, *pos1
;
687 struct sctp_sockaddr_entry
*saddr
;
691 if (!sctp_addip_enable
)
697 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
698 __FUNCTION__
, sk
, addrs
, addrcnt
);
700 list_for_each(pos
, &ep
->asocs
) {
701 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
703 if (!asoc
->peer
.asconf_capable
)
706 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_DEL_IP
)
709 if (!sctp_state(asoc
, ESTABLISHED
))
712 /* Check if any address in the packed array of addresses is
713 * not present in the bind address list of the association.
714 * If so, do not send the asconf chunk to its peer, but
715 * continue with other associations.
718 for (i
= 0; i
< addrcnt
; i
++) {
719 laddr
= (union sctp_addr
*)addr_buf
;
720 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
726 if (!sctp_assoc_lookup_laddr(asoc
, laddr
))
729 addr_buf
+= af
->sockaddr_len
;
734 /* Find one address in the association's bind address list
735 * that is not in the packed array of addresses. This is to
736 * make sure that we do not delete all the addresses in the
739 sctp_read_lock(&asoc
->base
.addr_lock
);
740 bp
= &asoc
->base
.bind_addr
;
741 laddr
= sctp_find_unmatch_addr(bp
, (union sctp_addr
*)addrs
,
743 sctp_read_unlock(&asoc
->base
.addr_lock
);
747 chunk
= sctp_make_asconf_update_ip(asoc
, laddr
, addrs
, addrcnt
,
754 /* Reset use_as_src flag for the addresses in the bind address
755 * list that are to be deleted.
757 sctp_local_bh_disable();
758 sctp_write_lock(&asoc
->base
.addr_lock
);
760 for (i
= 0; i
< addrcnt
; i
++) {
761 laddr
= (union sctp_addr
*)addr_buf
;
762 af
= sctp_get_af_specific(laddr
->v4
.sin_family
);
763 list_for_each(pos1
, &bp
->address_list
) {
764 saddr
= list_entry(pos1
,
765 struct sctp_sockaddr_entry
,
767 if (sctp_cmp_addr_exact(&saddr
->a
, laddr
))
768 saddr
->use_as_src
= 0;
770 addr_buf
+= af
->sockaddr_len
;
772 sctp_write_unlock(&asoc
->base
.addr_lock
);
773 sctp_local_bh_enable();
775 /* Update the route and saddr entries for all the transports
776 * as some of the addresses in the bind address list are
777 * about to be deleted and cannot be used as source addresses.
779 list_for_each(pos1
, &asoc
->peer
.transport_addr_list
) {
780 transport
= list_entry(pos1
, struct sctp_transport
,
782 dst_release(transport
->dst
);
783 sctp_transport_route(transport
, NULL
,
784 sctp_sk(asoc
->base
.sk
));
787 retval
= sctp_send_asconf(asoc
, chunk
);
793 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
796 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
799 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
800 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
803 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
804 * Section 3.1.2 for this usage.
806 * addrs is a pointer to an array of one or more socket addresses. Each
807 * address is contained in its appropriate structure (i.e. struct
808 * sockaddr_in or struct sockaddr_in6) the family of the address type
809 * must be used to distinguish the address length (note that this
810 * representation is termed a "packed array" of addresses). The caller
811 * specifies the number of addresses in the array with addrcnt.
813 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
814 * -1, and sets errno to the appropriate error code.
816 * For SCTP, the port given in each socket address must be the same, or
817 * sctp_bindx() will fail, setting errno to EINVAL.
819 * The flags parameter is formed from the bitwise OR of zero or more of
820 * the following currently defined flags:
822 * SCTP_BINDX_ADD_ADDR
824 * SCTP_BINDX_REM_ADDR
826 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
827 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
828 * addresses from the association. The two flags are mutually exclusive;
829 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
830 * not remove all addresses from an association; sctp_bindx() will
831 * reject such an attempt with EINVAL.
833 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
834 * additional addresses with an endpoint after calling bind(). Or use
835 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
836 * socket is associated with so that no new association accepted will be
837 * associated with those addresses. If the endpoint supports dynamic
838 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
839 * endpoint to send the appropriate message to the peer to change the
840 * peers address lists.
842 * Adding and removing addresses from a connected association is
843 * optional functionality. Implementations that do not support this
844 * functionality should return EOPNOTSUPP.
846 * Basically do nothing but copying the addresses from user to kernel
847 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
848 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
851 * We don't use copy_from_user() for optimization: we first do the
852 * sanity checks (buffer size -fast- and access check-healthy
853 * pointer); if all of those succeed, then we can alloc the memory
854 * (expensive operation) needed to copy the data to kernel. Then we do
855 * the copying without checking the user space area
856 * (__copy_from_user()).
858 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
861 * sk The sk of the socket
862 * addrs The pointer to the addresses in user land
863 * addrssize Size of the addrs buffer
864 * op Operation to perform (add or remove, see the flags of
867 * Returns 0 if ok, <0 errno code on error.
869 SCTP_STATIC
int sctp_setsockopt_bindx(struct sock
* sk
,
870 struct sockaddr __user
*addrs
,
871 int addrs_size
, int op
)
873 struct sockaddr
*kaddrs
;
877 struct sockaddr
*sa_addr
;
881 SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"
882 " addrs_size %d opt %d\n", sk
, addrs
, addrs_size
, op
);
884 if (unlikely(addrs_size
<= 0))
887 /* Check the user passed a healthy pointer. */
888 if (unlikely(!access_ok(VERIFY_READ
, addrs
, addrs_size
)))
891 /* Alloc space for the address array in kernel memory. */
892 kaddrs
= kmalloc(addrs_size
, GFP_KERNEL
);
893 if (unlikely(!kaddrs
))
896 if (__copy_from_user(kaddrs
, addrs
, addrs_size
)) {
901 /* Walk through the addrs buffer and count the number of addresses. */
903 while (walk_size
< addrs_size
) {
904 sa_addr
= (struct sockaddr
*)addr_buf
;
905 af
= sctp_get_af_specific(sa_addr
->sa_family
);
907 /* If the address family is not supported or if this address
908 * causes the address buffer to overflow return EINVAL.
910 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
915 addr_buf
+= af
->sockaddr_len
;
916 walk_size
+= af
->sockaddr_len
;
921 case SCTP_BINDX_ADD_ADDR
:
922 err
= sctp_bindx_add(sk
, kaddrs
, addrcnt
);
925 err
= sctp_send_asconf_add_ip(sk
, kaddrs
, addrcnt
);
928 case SCTP_BINDX_REM_ADDR
:
929 err
= sctp_bindx_rem(sk
, kaddrs
, addrcnt
);
932 err
= sctp_send_asconf_del_ip(sk
, kaddrs
, addrcnt
);
946 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
948 * Common routine for handling connect() and sctp_connectx().
949 * Connect will come in with just a single address.
951 static int __sctp_connect(struct sock
* sk
,
952 struct sockaddr
*kaddrs
,
955 struct sctp_sock
*sp
;
956 struct sctp_endpoint
*ep
;
957 struct sctp_association
*asoc
= NULL
;
958 struct sctp_association
*asoc2
;
959 struct sctp_transport
*transport
;
967 union sctp_addr
*sa_addr
;
973 /* connect() cannot be done on a socket that is already in ESTABLISHED
974 * state - UDP-style peeled off socket or a TCP-style socket that
975 * is already connected.
976 * It cannot be done even on a TCP-style listening socket.
978 if (sctp_sstate(sk
, ESTABLISHED
) ||
979 (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))) {
984 /* Walk through the addrs buffer and count the number of addresses. */
986 while (walk_size
< addrs_size
) {
987 sa_addr
= (union sctp_addr
*)addr_buf
;
988 af
= sctp_get_af_specific(sa_addr
->sa
.sa_family
);
990 /* If the address family is not supported or if this address
991 * causes the address buffer to overflow return EINVAL.
993 if (!af
|| (walk_size
+ af
->sockaddr_len
) > addrs_size
) {
998 err
= sctp_verify_addr(sk
, sa_addr
, af
->sockaddr_len
);
1002 memcpy(&to
, sa_addr
, af
->sockaddr_len
);
1004 /* Check if there already is a matching association on the
1005 * endpoint (other than the one created here).
1007 asoc2
= sctp_endpoint_lookup_assoc(ep
, sa_addr
, &transport
);
1008 if (asoc2
&& asoc2
!= asoc
) {
1009 if (asoc2
->state
>= SCTP_STATE_ESTABLISHED
)
1016 /* If we could not find a matching association on the endpoint,
1017 * make sure that there is no peeled-off association matching
1018 * the peer address even on another socket.
1020 if (sctp_endpoint_is_peeled_off(ep
, sa_addr
)) {
1021 err
= -EADDRNOTAVAIL
;
1026 /* If a bind() or sctp_bindx() is not called prior to
1027 * an sctp_connectx() call, the system picks an
1028 * ephemeral port and will choose an address set
1029 * equivalent to binding with a wildcard address.
1031 if (!ep
->base
.bind_addr
.port
) {
1032 if (sctp_autobind(sk
)) {
1038 * If an unprivileged user inherits a 1-many
1039 * style socket with open associations on a
1040 * privileged port, it MAY be permitted to
1041 * accept new associations, but it SHOULD NOT
1042 * be permitted to open new associations.
1044 if (ep
->base
.bind_addr
.port
< PROT_SOCK
&&
1045 !capable(CAP_NET_BIND_SERVICE
)) {
1051 scope
= sctp_scope(sa_addr
);
1052 asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1059 /* Prime the peer's transport structures. */
1060 transport
= sctp_assoc_add_peer(asoc
, sa_addr
, GFP_KERNEL
,
1068 addr_buf
+= af
->sockaddr_len
;
1069 walk_size
+= af
->sockaddr_len
;
1072 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, GFP_KERNEL
);
1077 err
= sctp_primitive_ASSOCIATE(asoc
, NULL
);
1082 /* Initialize sk's dport and daddr for getpeername() */
1083 inet_sk(sk
)->dport
= htons(asoc
->peer
.port
);
1084 af
= sctp_get_af_specific(to
.sa
.sa_family
);
1085 af
->to_sk_daddr(&to
, sk
);
1088 timeo
= sock_sndtimeo(sk
, sk
->sk_socket
->file
->f_flags
& O_NONBLOCK
);
1089 err
= sctp_wait_for_connect(asoc
, &timeo
);
1091 /* Don't free association on exit. */
1096 SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p"
1097 " kaddrs: %p err: %d\n",
1100 sctp_association_free(asoc
);
1104 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1107 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt);
1109 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1110 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1111 * or IPv6 addresses.
1113 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1114 * Section 3.1.2 for this usage.
1116 * addrs is a pointer to an array of one or more socket addresses. Each
1117 * address is contained in its appropriate structure (i.e. struct
1118 * sockaddr_in or struct sockaddr_in6) the family of the address type
1119 * must be used to distengish the address length (note that this
1120 * representation is termed a "packed array" of addresses). The caller
1121 * specifies the number of addresses in the array with addrcnt.
1123 * On success, sctp_connectx() returns 0. On failure, sctp_connectx() returns
1124 * -1, and sets errno to the appropriate error code.
1126 * For SCTP, the port given in each socket address must be the same, or
1127 * sctp_connectx() will fail, setting errno to EINVAL.
1129 * An application can use sctp_connectx to initiate an association with
1130 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1131 * allows a caller to specify multiple addresses at which a peer can be
1132 * reached. The way the SCTP stack uses the list of addresses to set up
1133 * the association is implementation dependant. This function only
1134 * specifies that the stack will try to make use of all the addresses in
1135 * the list when needed.
1137 * Note that the list of addresses passed in is only used for setting up
1138 * the association. It does not necessarily equal the set of addresses
1139 * the peer uses for the resulting association. If the caller wants to
1140 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1141 * retrieve them after the association has been set up.
1143 * Basically do nothing but copying the addresses from user to kernel
1144 * land and invoking either sctp_connectx(). This is used for tunneling
1145 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1147 * We don't use copy_from_user() for optimization: we first do the
1148 * sanity checks (buffer size -fast- and access check-healthy
1149 * pointer); if all of those succeed, then we can alloc the memory
1150 * (expensive operation) needed to copy the data to kernel. Then we do
1151 * the copying without checking the user space area
1152 * (__copy_from_user()).
1154 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1157 * sk The sk of the socket
1158 * addrs The pointer to the addresses in user land
1159 * addrssize Size of the addrs buffer
1161 * Returns 0 if ok, <0 errno code on error.
1163 SCTP_STATIC
int sctp_setsockopt_connectx(struct sock
* sk
,
1164 struct sockaddr __user
*addrs
,
1168 struct sockaddr
*kaddrs
;
1170 SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n",
1171 __FUNCTION__
, sk
, addrs
, addrs_size
);
1173 if (unlikely(addrs_size
<= 0))
1176 /* Check the user passed a healthy pointer. */
1177 if (unlikely(!access_ok(VERIFY_READ
, addrs
, addrs_size
)))
1180 /* Alloc space for the address array in kernel memory. */
1181 kaddrs
= kmalloc(addrs_size
, GFP_KERNEL
);
1182 if (unlikely(!kaddrs
))
1185 if (__copy_from_user(kaddrs
, addrs
, addrs_size
)) {
1188 err
= __sctp_connect(sk
, kaddrs
, addrs_size
);
1195 /* API 3.1.4 close() - UDP Style Syntax
1196 * Applications use close() to perform graceful shutdown (as described in
1197 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1198 * by a UDP-style socket.
1202 * ret = close(int sd);
1204 * sd - the socket descriptor of the associations to be closed.
1206 * To gracefully shutdown a specific association represented by the
1207 * UDP-style socket, an application should use the sendmsg() call,
1208 * passing no user data, but including the appropriate flag in the
1209 * ancillary data (see Section xxxx).
1211 * If sd in the close() call is a branched-off socket representing only
1212 * one association, the shutdown is performed on that association only.
1214 * 4.1.6 close() - TCP Style Syntax
1216 * Applications use close() to gracefully close down an association.
1220 * int close(int sd);
1222 * sd - the socket descriptor of the association to be closed.
1224 * After an application calls close() on a socket descriptor, no further
1225 * socket operations will succeed on that descriptor.
1227 * API 7.1.4 SO_LINGER
1229 * An application using the TCP-style socket can use this option to
1230 * perform the SCTP ABORT primitive. The linger option structure is:
1233 * int l_onoff; // option on/off
1234 * int l_linger; // linger time
1237 * To enable the option, set l_onoff to 1. If the l_linger value is set
1238 * to 0, calling close() is the same as the ABORT primitive. If the
1239 * value is set to a negative value, the setsockopt() call will return
1240 * an error. If the value is set to a positive value linger_time, the
1241 * close() can be blocked for at most linger_time ms. If the graceful
1242 * shutdown phase does not finish during this period, close() will
1243 * return but the graceful shutdown phase continues in the system.
1245 SCTP_STATIC
void sctp_close(struct sock
*sk
, long timeout
)
1247 struct sctp_endpoint
*ep
;
1248 struct sctp_association
*asoc
;
1249 struct list_head
*pos
, *temp
;
1251 SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk
, timeout
);
1254 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1256 ep
= sctp_sk(sk
)->ep
;
1258 /* Walk all associations on an endpoint. */
1259 list_for_each_safe(pos
, temp
, &ep
->asocs
) {
1260 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
1262 if (sctp_style(sk
, TCP
)) {
1263 /* A closed association can still be in the list if
1264 * it belongs to a TCP-style listening socket that is
1265 * not yet accepted. If so, free it. If not, send an
1266 * ABORT or SHUTDOWN based on the linger options.
1268 if (sctp_state(asoc
, CLOSED
)) {
1269 sctp_unhash_established(asoc
);
1270 sctp_association_free(asoc
);
1275 if (sock_flag(sk
, SOCK_LINGER
) && !sk
->sk_lingertime
) {
1276 struct sctp_chunk
*chunk
;
1278 chunk
= sctp_make_abort_user(asoc
, NULL
, 0);
1280 sctp_primitive_ABORT(asoc
, chunk
);
1282 sctp_primitive_SHUTDOWN(asoc
, NULL
);
1285 /* Clean up any skbs sitting on the receive queue. */
1286 sctp_queue_purge_ulpevents(&sk
->sk_receive_queue
);
1287 sctp_queue_purge_ulpevents(&sctp_sk(sk
)->pd_lobby
);
1289 /* On a TCP-style socket, block for at most linger_time if set. */
1290 if (sctp_style(sk
, TCP
) && timeout
)
1291 sctp_wait_for_close(sk
, timeout
);
1293 /* This will run the backlog queue. */
1294 sctp_release_sock(sk
);
1296 /* Supposedly, no process has access to the socket, but
1297 * the net layers still may.
1299 sctp_local_bh_disable();
1300 sctp_bh_lock_sock(sk
);
1302 /* Hold the sock, since sk_common_release() will put sock_put()
1303 * and we have just a little more cleanup.
1306 sk_common_release(sk
);
1308 sctp_bh_unlock_sock(sk
);
1309 sctp_local_bh_enable();
1313 SCTP_DBG_OBJCNT_DEC(sock
);
1316 /* Handle EPIPE error. */
1317 static int sctp_error(struct sock
*sk
, int flags
, int err
)
1320 err
= sock_error(sk
) ? : -EPIPE
;
1321 if (err
== -EPIPE
&& !(flags
& MSG_NOSIGNAL
))
1322 send_sig(SIGPIPE
, current
, 0);
1326 /* API 3.1.3 sendmsg() - UDP Style Syntax
1328 * An application uses sendmsg() and recvmsg() calls to transmit data to
1329 * and receive data from its peer.
1331 * ssize_t sendmsg(int socket, const struct msghdr *message,
1334 * socket - the socket descriptor of the endpoint.
1335 * message - pointer to the msghdr structure which contains a single
1336 * user message and possibly some ancillary data.
1338 * See Section 5 for complete description of the data
1341 * flags - flags sent or received with the user message, see Section
1342 * 5 for complete description of the flags.
1344 * Note: This function could use a rewrite especially when explicit
1345 * connect support comes in.
1347 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1349 SCTP_STATIC
int sctp_msghdr_parse(const struct msghdr
*, sctp_cmsgs_t
*);
1351 SCTP_STATIC
int sctp_sendmsg(struct kiocb
*iocb
, struct sock
*sk
,
1352 struct msghdr
*msg
, size_t msg_len
)
1354 struct sctp_sock
*sp
;
1355 struct sctp_endpoint
*ep
;
1356 struct sctp_association
*new_asoc
=NULL
, *asoc
=NULL
;
1357 struct sctp_transport
*transport
, *chunk_tp
;
1358 struct sctp_chunk
*chunk
;
1360 struct sockaddr
*msg_name
= NULL
;
1361 struct sctp_sndrcvinfo default_sinfo
= { 0 };
1362 struct sctp_sndrcvinfo
*sinfo
;
1363 struct sctp_initmsg
*sinit
;
1364 sctp_assoc_t associd
= 0;
1365 sctp_cmsgs_t cmsgs
= { NULL
};
1369 __u16 sinfo_flags
= 0;
1370 struct sctp_datamsg
*datamsg
;
1371 struct list_head
*pos
;
1372 int msg_flags
= msg
->msg_flags
;
1374 SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n",
1381 SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep
);
1383 /* We cannot send a message over a TCP-style listening socket. */
1384 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
)) {
1389 /* Parse out the SCTP CMSGs. */
1390 err
= sctp_msghdr_parse(msg
, &cmsgs
);
1393 SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err
);
1397 /* Fetch the destination address for this packet. This
1398 * address only selects the association--it is not necessarily
1399 * the address we will send to.
1400 * For a peeled-off socket, msg_name is ignored.
1402 if (!sctp_style(sk
, UDP_HIGH_BANDWIDTH
) && msg
->msg_name
) {
1403 int msg_namelen
= msg
->msg_namelen
;
1405 err
= sctp_verify_addr(sk
, (union sctp_addr
*)msg
->msg_name
,
1410 if (msg_namelen
> sizeof(to
))
1411 msg_namelen
= sizeof(to
);
1412 memcpy(&to
, msg
->msg_name
, msg_namelen
);
1413 msg_name
= msg
->msg_name
;
1419 /* Did the user specify SNDRCVINFO? */
1421 sinfo_flags
= sinfo
->sinfo_flags
;
1422 associd
= sinfo
->sinfo_assoc_id
;
1425 SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n",
1426 msg_len
, sinfo_flags
);
1428 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1429 if (sctp_style(sk
, TCP
) && (sinfo_flags
& (SCTP_EOF
| SCTP_ABORT
))) {
1434 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1435 * length messages when SCTP_EOF|SCTP_ABORT is not set.
1436 * If SCTP_ABORT is set, the message length could be non zero with
1437 * the msg_iov set to the user abort reason.
1439 if (((sinfo_flags
& SCTP_EOF
) && (msg_len
> 0)) ||
1440 (!(sinfo_flags
& (SCTP_EOF
|SCTP_ABORT
)) && (msg_len
== 0))) {
1445 /* If SCTP_ADDR_OVER is set, there must be an address
1446 * specified in msg_name.
1448 if ((sinfo_flags
& SCTP_ADDR_OVER
) && (!msg
->msg_name
)) {
1455 SCTP_DEBUG_PRINTK("About to look up association.\n");
1459 /* If a msg_name has been specified, assume this is to be used. */
1461 /* Look for a matching association on the endpoint. */
1462 asoc
= sctp_endpoint_lookup_assoc(ep
, &to
, &transport
);
1464 /* If we could not find a matching association on the
1465 * endpoint, make sure that it is not a TCP-style
1466 * socket that already has an association or there is
1467 * no peeled-off association on another socket.
1469 if ((sctp_style(sk
, TCP
) &&
1470 sctp_sstate(sk
, ESTABLISHED
)) ||
1471 sctp_endpoint_is_peeled_off(ep
, &to
)) {
1472 err
= -EADDRNOTAVAIL
;
1477 asoc
= sctp_id2assoc(sk
, associd
);
1485 SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc
);
1487 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1488 * socket that has an association in CLOSED state. This can
1489 * happen when an accepted socket has an association that is
1492 if (sctp_state(asoc
, CLOSED
) && sctp_style(sk
, TCP
)) {
1497 if (sinfo_flags
& SCTP_EOF
) {
1498 SCTP_DEBUG_PRINTK("Shutting down association: %p\n",
1500 sctp_primitive_SHUTDOWN(asoc
, NULL
);
1504 if (sinfo_flags
& SCTP_ABORT
) {
1505 struct sctp_chunk
*chunk
;
1507 chunk
= sctp_make_abort_user(asoc
, msg
, msg_len
);
1513 SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc
);
1514 sctp_primitive_ABORT(asoc
, chunk
);
1520 /* Do we need to create the association? */
1522 SCTP_DEBUG_PRINTK("There is no association yet.\n");
1524 if (sinfo_flags
& (SCTP_EOF
| SCTP_ABORT
)) {
1529 /* Check for invalid stream against the stream counts,
1530 * either the default or the user specified stream counts.
1533 if (!sinit
|| (sinit
&& !sinit
->sinit_num_ostreams
)) {
1534 /* Check against the defaults. */
1535 if (sinfo
->sinfo_stream
>=
1536 sp
->initmsg
.sinit_num_ostreams
) {
1541 /* Check against the requested. */
1542 if (sinfo
->sinfo_stream
>=
1543 sinit
->sinit_num_ostreams
) {
1551 * API 3.1.2 bind() - UDP Style Syntax
1552 * If a bind() or sctp_bindx() is not called prior to a
1553 * sendmsg() call that initiates a new association, the
1554 * system picks an ephemeral port and will choose an address
1555 * set equivalent to binding with a wildcard address.
1557 if (!ep
->base
.bind_addr
.port
) {
1558 if (sctp_autobind(sk
)) {
1564 * If an unprivileged user inherits a one-to-many
1565 * style socket with open associations on a privileged
1566 * port, it MAY be permitted to accept new associations,
1567 * but it SHOULD NOT be permitted to open new
1570 if (ep
->base
.bind_addr
.port
< PROT_SOCK
&&
1571 !capable(CAP_NET_BIND_SERVICE
)) {
1577 scope
= sctp_scope(&to
);
1578 new_asoc
= sctp_association_new(ep
, sk
, scope
, GFP_KERNEL
);
1585 /* If the SCTP_INIT ancillary data is specified, set all
1586 * the association init values accordingly.
1589 if (sinit
->sinit_num_ostreams
) {
1590 asoc
->c
.sinit_num_ostreams
=
1591 sinit
->sinit_num_ostreams
;
1593 if (sinit
->sinit_max_instreams
) {
1594 asoc
->c
.sinit_max_instreams
=
1595 sinit
->sinit_max_instreams
;
1597 if (sinit
->sinit_max_attempts
) {
1598 asoc
->max_init_attempts
1599 = sinit
->sinit_max_attempts
;
1601 if (sinit
->sinit_max_init_timeo
) {
1602 asoc
->max_init_timeo
=
1603 msecs_to_jiffies(sinit
->sinit_max_init_timeo
);
1607 /* Prime the peer's transport structures. */
1608 transport
= sctp_assoc_add_peer(asoc
, &to
, GFP_KERNEL
, SCTP_UNKNOWN
);
1613 err
= sctp_assoc_set_bind_addr_from_ep(asoc
, GFP_KERNEL
);
1620 /* ASSERT: we have a valid association at this point. */
1621 SCTP_DEBUG_PRINTK("We have a valid association.\n");
1624 /* If the user didn't specify SNDRCVINFO, make up one with
1627 default_sinfo
.sinfo_stream
= asoc
->default_stream
;
1628 default_sinfo
.sinfo_flags
= asoc
->default_flags
;
1629 default_sinfo
.sinfo_ppid
= asoc
->default_ppid
;
1630 default_sinfo
.sinfo_context
= asoc
->default_context
;
1631 default_sinfo
.sinfo_timetolive
= asoc
->default_timetolive
;
1632 default_sinfo
.sinfo_assoc_id
= sctp_assoc2id(asoc
);
1633 sinfo
= &default_sinfo
;
1636 /* API 7.1.7, the sndbuf size per association bounds the
1637 * maximum size of data that can be sent in a single send call.
1639 if (msg_len
> sk
->sk_sndbuf
) {
1644 /* If fragmentation is disabled and the message length exceeds the
1645 * association fragmentation point, return EMSGSIZE. The I-D
1646 * does not specify what this error is, but this looks like
1649 if (sctp_sk(sk
)->disable_fragments
&& (msg_len
> asoc
->frag_point
)) {
1655 /* Check for invalid stream. */
1656 if (sinfo
->sinfo_stream
>= asoc
->c
.sinit_num_ostreams
) {
1662 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1663 if (!sctp_wspace(asoc
)) {
1664 err
= sctp_wait_for_sndbuf(asoc
, &timeo
, msg_len
);
1669 /* If an address is passed with the sendto/sendmsg call, it is used
1670 * to override the primary destination address in the TCP model, or
1671 * when SCTP_ADDR_OVER flag is set in the UDP model.
1673 if ((sctp_style(sk
, TCP
) && msg_name
) ||
1674 (sinfo_flags
& SCTP_ADDR_OVER
)) {
1675 chunk_tp
= sctp_assoc_lookup_paddr(asoc
, &to
);
1683 /* Auto-connect, if we aren't connected already. */
1684 if (sctp_state(asoc
, CLOSED
)) {
1685 err
= sctp_primitive_ASSOCIATE(asoc
, NULL
);
1688 SCTP_DEBUG_PRINTK("We associated primitively.\n");
1691 /* Break the message into multiple chunks of maximum size. */
1692 datamsg
= sctp_datamsg_from_user(asoc
, sinfo
, msg
, msg_len
);
1698 /* Now send the (possibly) fragmented message. */
1699 list_for_each(pos
, &datamsg
->chunks
) {
1700 chunk
= list_entry(pos
, struct sctp_chunk
, frag_list
);
1701 sctp_datamsg_track(chunk
);
1703 /* Do accounting for the write space. */
1704 sctp_set_owner_w(chunk
);
1706 chunk
->transport
= chunk_tp
;
1708 /* Send it to the lower layers. Note: all chunks
1709 * must either fail or succeed. The lower layer
1710 * works that way today. Keep it that way or this
1713 err
= sctp_primitive_SEND(asoc
, chunk
);
1714 /* Did the lower layer accept the chunk? */
1716 sctp_chunk_free(chunk
);
1717 SCTP_DEBUG_PRINTK("We sent primitively.\n");
1720 sctp_datamsg_free(datamsg
);
1726 /* If we are already past ASSOCIATE, the lower
1727 * layers are responsible for association cleanup.
1733 sctp_association_free(asoc
);
1735 sctp_release_sock(sk
);
1738 return sctp_error(sk
, msg_flags
, err
);
1745 err
= sock_error(sk
);
1755 /* This is an extended version of skb_pull() that removes the data from the
1756 * start of a skb even when data is spread across the list of skb's in the
1757 * frag_list. len specifies the total amount of data that needs to be removed.
1758 * when 'len' bytes could be removed from the skb, it returns 0.
1759 * If 'len' exceeds the total skb length, it returns the no. of bytes that
1760 * could not be removed.
1762 static int sctp_skb_pull(struct sk_buff
*skb
, int len
)
1764 struct sk_buff
*list
;
1765 int skb_len
= skb_headlen(skb
);
1768 if (len
<= skb_len
) {
1769 __skb_pull(skb
, len
);
1773 __skb_pull(skb
, skb_len
);
1775 for (list
= skb_shinfo(skb
)->frag_list
; list
; list
= list
->next
) {
1776 rlen
= sctp_skb_pull(list
, len
);
1777 skb
->len
-= (len
-rlen
);
1778 skb
->data_len
-= (len
-rlen
);
1789 /* API 3.1.3 recvmsg() - UDP Style Syntax
1791 * ssize_t recvmsg(int socket, struct msghdr *message,
1794 * socket - the socket descriptor of the endpoint.
1795 * message - pointer to the msghdr structure which contains a single
1796 * user message and possibly some ancillary data.
1798 * See Section 5 for complete description of the data
1801 * flags - flags sent or received with the user message, see Section
1802 * 5 for complete description of the flags.
1804 static struct sk_buff
*sctp_skb_recv_datagram(struct sock
*, int, int, int *);
1806 SCTP_STATIC
int sctp_recvmsg(struct kiocb
*iocb
, struct sock
*sk
,
1807 struct msghdr
*msg
, size_t len
, int noblock
,
1808 int flags
, int *addr_len
)
1810 struct sctp_ulpevent
*event
= NULL
;
1811 struct sctp_sock
*sp
= sctp_sk(sk
);
1812 struct sk_buff
*skb
;
1817 SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: "
1818 "0x%x, %s: %p)\n", "sk", sk
, "msghdr", msg
,
1819 "len", len
, "knoblauch", noblock
,
1820 "flags", flags
, "addr_len", addr_len
);
1824 if (sctp_style(sk
, TCP
) && !sctp_sstate(sk
, ESTABLISHED
)) {
1829 skb
= sctp_skb_recv_datagram(sk
, flags
, noblock
, &err
);
1833 /* Get the total length of the skb including any skb's in the
1842 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
1844 event
= sctp_skb2event(skb
);
1849 sock_recv_timestamp(msg
, sk
, skb
);
1850 if (sctp_ulpevent_is_notification(event
)) {
1851 msg
->msg_flags
|= MSG_NOTIFICATION
;
1852 sp
->pf
->event_msgname(event
, msg
->msg_name
, addr_len
);
1854 sp
->pf
->skb_msgname(skb
, msg
->msg_name
, addr_len
);
1857 /* Check if we allow SCTP_SNDRCVINFO. */
1858 if (sp
->subscribe
.sctp_data_io_event
)
1859 sctp_ulpevent_read_sndrcvinfo(event
, msg
);
1861 /* FIXME: we should be calling IP/IPv6 layers. */
1862 if (sk
->sk_protinfo
.af_inet
.cmsg_flags
)
1863 ip_cmsg_recv(msg
, skb
);
1868 /* If skb's length exceeds the user's buffer, update the skb and
1869 * push it back to the receive_queue so that the next call to
1870 * recvmsg() will return the remaining data. Don't set MSG_EOR.
1872 if (skb_len
> copied
) {
1873 msg
->msg_flags
&= ~MSG_EOR
;
1874 if (flags
& MSG_PEEK
)
1876 sctp_skb_pull(skb
, copied
);
1877 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1879 /* When only partial message is copied to the user, increase
1880 * rwnd by that amount. If all the data in the skb is read,
1881 * rwnd is updated when the event is freed.
1883 sctp_assoc_rwnd_increase(event
->asoc
, copied
);
1885 } else if ((event
->msg_flags
& MSG_NOTIFICATION
) ||
1886 (event
->msg_flags
& MSG_EOR
))
1887 msg
->msg_flags
|= MSG_EOR
;
1889 msg
->msg_flags
&= ~MSG_EOR
;
1892 if (flags
& MSG_PEEK
) {
1893 /* Release the skb reference acquired after peeking the skb in
1894 * sctp_skb_recv_datagram().
1898 /* Free the event which includes releasing the reference to
1899 * the owner of the skb, freeing the skb and updating the
1902 sctp_ulpevent_free(event
);
1905 sctp_release_sock(sk
);
1909 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
1911 * This option is a on/off flag. If enabled no SCTP message
1912 * fragmentation will be performed. Instead if a message being sent
1913 * exceeds the current PMTU size, the message will NOT be sent and
1914 * instead a error will be indicated to the user.
1916 static int sctp_setsockopt_disable_fragments(struct sock
*sk
,
1917 char __user
*optval
, int optlen
)
1921 if (optlen
< sizeof(int))
1924 if (get_user(val
, (int __user
*)optval
))
1927 sctp_sk(sk
)->disable_fragments
= (val
== 0) ? 0 : 1;
1932 static int sctp_setsockopt_events(struct sock
*sk
, char __user
*optval
,
1935 if (optlen
!= sizeof(struct sctp_event_subscribe
))
1937 if (copy_from_user(&sctp_sk(sk
)->subscribe
, optval
, optlen
))
1942 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
1944 * This socket option is applicable to the UDP-style socket only. When
1945 * set it will cause associations that are idle for more than the
1946 * specified number of seconds to automatically close. An association
1947 * being idle is defined an association that has NOT sent or received
1948 * user data. The special value of '0' indicates that no automatic
1949 * close of any associations should be performed. The option expects an
1950 * integer defining the number of seconds of idle time before an
1951 * association is closed.
1953 static int sctp_setsockopt_autoclose(struct sock
*sk
, char __user
*optval
,
1956 struct sctp_sock
*sp
= sctp_sk(sk
);
1958 /* Applicable to UDP-style socket only */
1959 if (sctp_style(sk
, TCP
))
1961 if (optlen
!= sizeof(int))
1963 if (copy_from_user(&sp
->autoclose
, optval
, optlen
))
1969 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
1971 * Applications can enable or disable heartbeats for any peer address of
1972 * an association, modify an address's heartbeat interval, force a
1973 * heartbeat to be sent immediately, and adjust the address's maximum
1974 * number of retransmissions sent before an address is considered
1975 * unreachable. The following structure is used to access and modify an
1976 * address's parameters:
1978 * struct sctp_paddrparams {
1979 * sctp_assoc_t spp_assoc_id;
1980 * struct sockaddr_storage spp_address;
1981 * uint32_t spp_hbinterval;
1982 * uint16_t spp_pathmaxrxt;
1983 * uint32_t spp_pathmtu;
1984 * uint32_t spp_sackdelay;
1985 * uint32_t spp_flags;
1988 * spp_assoc_id - (one-to-many style socket) This is filled in the
1989 * application, and identifies the association for
1991 * spp_address - This specifies which address is of interest.
1992 * spp_hbinterval - This contains the value of the heartbeat interval,
1993 * in milliseconds. If a value of zero
1994 * is present in this field then no changes are to
1995 * be made to this parameter.
1996 * spp_pathmaxrxt - This contains the maximum number of
1997 * retransmissions before this address shall be
1998 * considered unreachable. If a value of zero
1999 * is present in this field then no changes are to
2000 * be made to this parameter.
2001 * spp_pathmtu - When Path MTU discovery is disabled the value
2002 * specified here will be the "fixed" path mtu.
2003 * Note that if the spp_address field is empty
2004 * then all associations on this address will
2005 * have this fixed path mtu set upon them.
2007 * spp_sackdelay - When delayed sack is enabled, this value specifies
2008 * the number of milliseconds that sacks will be delayed
2009 * for. This value will apply to all addresses of an
2010 * association if the spp_address field is empty. Note
2011 * also, that if delayed sack is enabled and this
2012 * value is set to 0, no change is made to the last
2013 * recorded delayed sack timer value.
2015 * spp_flags - These flags are used to control various features
2016 * on an association. The flag field may contain
2017 * zero or more of the following options.
2019 * SPP_HB_ENABLE - Enable heartbeats on the
2020 * specified address. Note that if the address
2021 * field is empty all addresses for the association
2022 * have heartbeats enabled upon them.
2024 * SPP_HB_DISABLE - Disable heartbeats on the
2025 * speicifed address. Note that if the address
2026 * field is empty all addresses for the association
2027 * will have their heartbeats disabled. Note also
2028 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2029 * mutually exclusive, only one of these two should
2030 * be specified. Enabling both fields will have
2031 * undetermined results.
2033 * SPP_HB_DEMAND - Request a user initiated heartbeat
2034 * to be made immediately.
2036 * SPP_PMTUD_ENABLE - This field will enable PMTU
2037 * discovery upon the specified address. Note that
2038 * if the address feild is empty then all addresses
2039 * on the association are effected.
2041 * SPP_PMTUD_DISABLE - This field will disable PMTU
2042 * discovery upon the specified address. Note that
2043 * if the address feild is empty then all addresses
2044 * on the association are effected. Not also that
2045 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2046 * exclusive. Enabling both will have undetermined
2049 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2050 * on delayed sack. The time specified in spp_sackdelay
2051 * is used to specify the sack delay for this address. Note
2052 * that if spp_address is empty then all addresses will
2053 * enable delayed sack and take on the sack delay
2054 * value specified in spp_sackdelay.
2055 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2056 * off delayed sack. If the spp_address field is blank then
2057 * delayed sack is disabled for the entire association. Note
2058 * also that this field is mutually exclusive to
2059 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2062 static int sctp_apply_peer_addr_params(struct sctp_paddrparams
*params
,
2063 struct sctp_transport
*trans
,
2064 struct sctp_association
*asoc
,
2065 struct sctp_sock
*sp
,
2068 int sackdelay_change
)
2072 if (params
->spp_flags
& SPP_HB_DEMAND
&& trans
) {
2073 error
= sctp_primitive_REQUESTHEARTBEAT (trans
->asoc
, trans
);
2078 if (params
->spp_hbinterval
) {
2080 trans
->hbinterval
= msecs_to_jiffies(params
->spp_hbinterval
);
2082 asoc
->hbinterval
= msecs_to_jiffies(params
->spp_hbinterval
);
2084 sp
->hbinterval
= params
->spp_hbinterval
;
2090 trans
->param_flags
=
2091 (trans
->param_flags
& ~SPP_HB
) | hb_change
;
2094 (asoc
->param_flags
& ~SPP_HB
) | hb_change
;
2097 (sp
->param_flags
& ~SPP_HB
) | hb_change
;
2101 if (params
->spp_pathmtu
) {
2103 trans
->pathmtu
= params
->spp_pathmtu
;
2104 sctp_assoc_sync_pmtu(asoc
);
2106 asoc
->pathmtu
= params
->spp_pathmtu
;
2107 sctp_frag_point(sp
, params
->spp_pathmtu
);
2109 sp
->pathmtu
= params
->spp_pathmtu
;
2115 int update
= (trans
->param_flags
& SPP_PMTUD_DISABLE
) &&
2116 (params
->spp_flags
& SPP_PMTUD_ENABLE
);
2117 trans
->param_flags
=
2118 (trans
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2120 sctp_transport_pmtu(trans
);
2121 sctp_assoc_sync_pmtu(asoc
);
2125 (asoc
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2128 (sp
->param_flags
& ~SPP_PMTUD
) | pmtud_change
;
2132 if (params
->spp_sackdelay
) {
2135 msecs_to_jiffies(params
->spp_sackdelay
);
2138 msecs_to_jiffies(params
->spp_sackdelay
);
2140 sp
->sackdelay
= params
->spp_sackdelay
;
2144 if (sackdelay_change
) {
2146 trans
->param_flags
=
2147 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2151 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2155 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2160 if (params
->spp_pathmaxrxt
) {
2162 trans
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2164 asoc
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2166 sp
->pathmaxrxt
= params
->spp_pathmaxrxt
;
2173 static int sctp_setsockopt_peer_addr_params(struct sock
*sk
,
2174 char __user
*optval
, int optlen
)
2176 struct sctp_paddrparams params
;
2177 struct sctp_transport
*trans
= NULL
;
2178 struct sctp_association
*asoc
= NULL
;
2179 struct sctp_sock
*sp
= sctp_sk(sk
);
2181 int hb_change
, pmtud_change
, sackdelay_change
;
2183 if (optlen
!= sizeof(struct sctp_paddrparams
))
2186 if (copy_from_user(¶ms
, optval
, optlen
))
2189 /* Validate flags and value parameters. */
2190 hb_change
= params
.spp_flags
& SPP_HB
;
2191 pmtud_change
= params
.spp_flags
& SPP_PMTUD
;
2192 sackdelay_change
= params
.spp_flags
& SPP_SACKDELAY
;
2194 if (hb_change
== SPP_HB
||
2195 pmtud_change
== SPP_PMTUD
||
2196 sackdelay_change
== SPP_SACKDELAY
||
2197 params
.spp_sackdelay
> 500 ||
2199 && params
.spp_pathmtu
< SCTP_DEFAULT_MINSEGMENT
))
2202 /* If an address other than INADDR_ANY is specified, and
2203 * no transport is found, then the request is invalid.
2205 if (!sctp_is_any(( union sctp_addr
*)¶ms
.spp_address
)) {
2206 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
2207 params
.spp_assoc_id
);
2212 /* Get association, if assoc_id != 0 and the socket is a one
2213 * to many style socket, and an association was not found, then
2214 * the id was invalid.
2216 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
2217 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
))
2220 /* Heartbeat demand can only be sent on a transport or
2221 * association, but not a socket.
2223 if (params
.spp_flags
& SPP_HB_DEMAND
&& !trans
&& !asoc
)
2226 /* Process parameters. */
2227 error
= sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2228 hb_change
, pmtud_change
,
2234 /* If changes are for association, also apply parameters to each
2237 if (!trans
&& asoc
) {
2238 struct list_head
*pos
;
2240 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
2241 trans
= list_entry(pos
, struct sctp_transport
,
2243 sctp_apply_peer_addr_params(¶ms
, trans
, asoc
, sp
,
2244 hb_change
, pmtud_change
,
2252 /* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)
2254 * This options will get or set the delayed ack timer. The time is set
2255 * in milliseconds. If the assoc_id is 0, then this sets or gets the
2256 * endpoints default delayed ack timer value. If the assoc_id field is
2257 * non-zero, then the set or get effects the specified association.
2259 * struct sctp_assoc_value {
2260 * sctp_assoc_t assoc_id;
2261 * uint32_t assoc_value;
2264 * assoc_id - This parameter, indicates which association the
2265 * user is preforming an action upon. Note that if
2266 * this field's value is zero then the endpoints
2267 * default value is changed (effecting future
2268 * associations only).
2270 * assoc_value - This parameter contains the number of milliseconds
2271 * that the user is requesting the delayed ACK timer
2272 * be set to. Note that this value is defined in
2273 * the standard to be between 200 and 500 milliseconds.
2275 * Note: a value of zero will leave the value alone,
2276 * but disable SACK delay. A non-zero value will also
2277 * enable SACK delay.
2280 static int sctp_setsockopt_delayed_ack_time(struct sock
*sk
,
2281 char __user
*optval
, int optlen
)
2283 struct sctp_assoc_value params
;
2284 struct sctp_transport
*trans
= NULL
;
2285 struct sctp_association
*asoc
= NULL
;
2286 struct sctp_sock
*sp
= sctp_sk(sk
);
2288 if (optlen
!= sizeof(struct sctp_assoc_value
))
2291 if (copy_from_user(¶ms
, optval
, optlen
))
2294 /* Validate value parameter. */
2295 if (params
.assoc_value
> 500)
2298 /* Get association, if assoc_id != 0 and the socket is a one
2299 * to many style socket, and an association was not found, then
2300 * the id was invalid.
2302 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
2303 if (!asoc
&& params
.assoc_id
&& sctp_style(sk
, UDP
))
2306 if (params
.assoc_value
) {
2309 msecs_to_jiffies(params
.assoc_value
);
2311 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2312 SPP_SACKDELAY_ENABLE
;
2314 sp
->sackdelay
= params
.assoc_value
;
2316 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2317 SPP_SACKDELAY_ENABLE
;
2322 (asoc
->param_flags
& ~SPP_SACKDELAY
) |
2323 SPP_SACKDELAY_DISABLE
;
2326 (sp
->param_flags
& ~SPP_SACKDELAY
) |
2327 SPP_SACKDELAY_DISABLE
;
2331 /* If change is for association, also apply to each transport. */
2333 struct list_head
*pos
;
2335 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
2336 trans
= list_entry(pos
, struct sctp_transport
,
2338 if (params
.assoc_value
) {
2340 msecs_to_jiffies(params
.assoc_value
);
2341 trans
->param_flags
=
2342 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2343 SPP_SACKDELAY_ENABLE
;
2345 trans
->param_flags
=
2346 (trans
->param_flags
& ~SPP_SACKDELAY
) |
2347 SPP_SACKDELAY_DISABLE
;
2355 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2357 * Applications can specify protocol parameters for the default association
2358 * initialization. The option name argument to setsockopt() and getsockopt()
2361 * Setting initialization parameters is effective only on an unconnected
2362 * socket (for UDP-style sockets only future associations are effected
2363 * by the change). With TCP-style sockets, this option is inherited by
2364 * sockets derived from a listener socket.
2366 static int sctp_setsockopt_initmsg(struct sock
*sk
, char __user
*optval
, int optlen
)
2368 struct sctp_initmsg sinit
;
2369 struct sctp_sock
*sp
= sctp_sk(sk
);
2371 if (optlen
!= sizeof(struct sctp_initmsg
))
2373 if (copy_from_user(&sinit
, optval
, optlen
))
2376 if (sinit
.sinit_num_ostreams
)
2377 sp
->initmsg
.sinit_num_ostreams
= sinit
.sinit_num_ostreams
;
2378 if (sinit
.sinit_max_instreams
)
2379 sp
->initmsg
.sinit_max_instreams
= sinit
.sinit_max_instreams
;
2380 if (sinit
.sinit_max_attempts
)
2381 sp
->initmsg
.sinit_max_attempts
= sinit
.sinit_max_attempts
;
2382 if (sinit
.sinit_max_init_timeo
)
2383 sp
->initmsg
.sinit_max_init_timeo
= sinit
.sinit_max_init_timeo
;
2389 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2391 * Applications that wish to use the sendto() system call may wish to
2392 * specify a default set of parameters that would normally be supplied
2393 * through the inclusion of ancillary data. This socket option allows
2394 * such an application to set the default sctp_sndrcvinfo structure.
2395 * The application that wishes to use this socket option simply passes
2396 * in to this call the sctp_sndrcvinfo structure defined in Section
2397 * 5.2.2) The input parameters accepted by this call include
2398 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2399 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2400 * to this call if the caller is using the UDP model.
2402 static int sctp_setsockopt_default_send_param(struct sock
*sk
,
2403 char __user
*optval
, int optlen
)
2405 struct sctp_sndrcvinfo info
;
2406 struct sctp_association
*asoc
;
2407 struct sctp_sock
*sp
= sctp_sk(sk
);
2409 if (optlen
!= sizeof(struct sctp_sndrcvinfo
))
2411 if (copy_from_user(&info
, optval
, optlen
))
2414 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
2415 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
2419 asoc
->default_stream
= info
.sinfo_stream
;
2420 asoc
->default_flags
= info
.sinfo_flags
;
2421 asoc
->default_ppid
= info
.sinfo_ppid
;
2422 asoc
->default_context
= info
.sinfo_context
;
2423 asoc
->default_timetolive
= info
.sinfo_timetolive
;
2425 sp
->default_stream
= info
.sinfo_stream
;
2426 sp
->default_flags
= info
.sinfo_flags
;
2427 sp
->default_ppid
= info
.sinfo_ppid
;
2428 sp
->default_context
= info
.sinfo_context
;
2429 sp
->default_timetolive
= info
.sinfo_timetolive
;
2435 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
2437 * Requests that the local SCTP stack use the enclosed peer address as
2438 * the association primary. The enclosed address must be one of the
2439 * association peer's addresses.
2441 static int sctp_setsockopt_primary_addr(struct sock
*sk
, char __user
*optval
,
2444 struct sctp_prim prim
;
2445 struct sctp_transport
*trans
;
2447 if (optlen
!= sizeof(struct sctp_prim
))
2450 if (copy_from_user(&prim
, optval
, sizeof(struct sctp_prim
)))
2453 trans
= sctp_addr_id2transport(sk
, &prim
.ssp_addr
, prim
.ssp_assoc_id
);
2457 sctp_assoc_set_primary(trans
->asoc
, trans
);
2463 * 7.1.5 SCTP_NODELAY
2465 * Turn on/off any Nagle-like algorithm. This means that packets are
2466 * generally sent as soon as possible and no unnecessary delays are
2467 * introduced, at the cost of more packets in the network. Expects an
2468 * integer boolean flag.
2470 static int sctp_setsockopt_nodelay(struct sock
*sk
, char __user
*optval
,
2475 if (optlen
< sizeof(int))
2477 if (get_user(val
, (int __user
*)optval
))
2480 sctp_sk(sk
)->nodelay
= (val
== 0) ? 0 : 1;
2486 * 7.1.1 SCTP_RTOINFO
2488 * The protocol parameters used to initialize and bound retransmission
2489 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
2490 * and modify these parameters.
2491 * All parameters are time values, in milliseconds. A value of 0, when
2492 * modifying the parameters, indicates that the current value should not
2496 static int sctp_setsockopt_rtoinfo(struct sock
*sk
, char __user
*optval
, int optlen
) {
2497 struct sctp_rtoinfo rtoinfo
;
2498 struct sctp_association
*asoc
;
2500 if (optlen
!= sizeof (struct sctp_rtoinfo
))
2503 if (copy_from_user(&rtoinfo
, optval
, optlen
))
2506 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
2508 /* Set the values to the specific association */
2509 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
2513 if (rtoinfo
.srto_initial
!= 0)
2515 msecs_to_jiffies(rtoinfo
.srto_initial
);
2516 if (rtoinfo
.srto_max
!= 0)
2517 asoc
->rto_max
= msecs_to_jiffies(rtoinfo
.srto_max
);
2518 if (rtoinfo
.srto_min
!= 0)
2519 asoc
->rto_min
= msecs_to_jiffies(rtoinfo
.srto_min
);
2521 /* If there is no association or the association-id = 0
2522 * set the values to the endpoint.
2524 struct sctp_sock
*sp
= sctp_sk(sk
);
2526 if (rtoinfo
.srto_initial
!= 0)
2527 sp
->rtoinfo
.srto_initial
= rtoinfo
.srto_initial
;
2528 if (rtoinfo
.srto_max
!= 0)
2529 sp
->rtoinfo
.srto_max
= rtoinfo
.srto_max
;
2530 if (rtoinfo
.srto_min
!= 0)
2531 sp
->rtoinfo
.srto_min
= rtoinfo
.srto_min
;
2539 * 7.1.2 SCTP_ASSOCINFO
2541 * This option is used to tune the the maximum retransmission attempts
2542 * of the association.
2543 * Returns an error if the new association retransmission value is
2544 * greater than the sum of the retransmission value of the peer.
2545 * See [SCTP] for more information.
2548 static int sctp_setsockopt_associnfo(struct sock
*sk
, char __user
*optval
, int optlen
)
2551 struct sctp_assocparams assocparams
;
2552 struct sctp_association
*asoc
;
2554 if (optlen
!= sizeof(struct sctp_assocparams
))
2556 if (copy_from_user(&assocparams
, optval
, optlen
))
2559 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
2561 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
2564 /* Set the values to the specific association */
2566 if (assocparams
.sasoc_asocmaxrxt
!= 0) {
2569 struct list_head
*pos
;
2570 struct sctp_transport
*peer_addr
;
2572 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
2573 peer_addr
= list_entry(pos
,
2574 struct sctp_transport
,
2576 path_sum
+= peer_addr
->pathmaxrxt
;
2580 /* Only validate asocmaxrxt if we have more then
2581 * one path/transport. We do this because path
2582 * retransmissions are only counted when we have more
2586 assocparams
.sasoc_asocmaxrxt
> path_sum
)
2589 asoc
->max_retrans
= assocparams
.sasoc_asocmaxrxt
;
2592 if (assocparams
.sasoc_cookie_life
!= 0) {
2593 asoc
->cookie_life
.tv_sec
=
2594 assocparams
.sasoc_cookie_life
/ 1000;
2595 asoc
->cookie_life
.tv_usec
=
2596 (assocparams
.sasoc_cookie_life
% 1000)
2600 /* Set the values to the endpoint */
2601 struct sctp_sock
*sp
= sctp_sk(sk
);
2603 if (assocparams
.sasoc_asocmaxrxt
!= 0)
2604 sp
->assocparams
.sasoc_asocmaxrxt
=
2605 assocparams
.sasoc_asocmaxrxt
;
2606 if (assocparams
.sasoc_cookie_life
!= 0)
2607 sp
->assocparams
.sasoc_cookie_life
=
2608 assocparams
.sasoc_cookie_life
;
2614 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
2616 * This socket option is a boolean flag which turns on or off mapped V4
2617 * addresses. If this option is turned on and the socket is type
2618 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
2619 * If this option is turned off, then no mapping will be done of V4
2620 * addresses and a user will receive both PF_INET6 and PF_INET type
2621 * addresses on the socket.
2623 static int sctp_setsockopt_mappedv4(struct sock
*sk
, char __user
*optval
, int optlen
)
2626 struct sctp_sock
*sp
= sctp_sk(sk
);
2628 if (optlen
< sizeof(int))
2630 if (get_user(val
, (int __user
*)optval
))
2641 * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
2643 * This socket option specifies the maximum size to put in any outgoing
2644 * SCTP chunk. If a message is larger than this size it will be
2645 * fragmented by SCTP into the specified size. Note that the underlying
2646 * SCTP implementation may fragment into smaller sized chunks when the
2647 * PMTU of the underlying association is smaller than the value set by
2650 static int sctp_setsockopt_maxseg(struct sock
*sk
, char __user
*optval
, int optlen
)
2652 struct sctp_association
*asoc
;
2653 struct list_head
*pos
;
2654 struct sctp_sock
*sp
= sctp_sk(sk
);
2657 if (optlen
< sizeof(int))
2659 if (get_user(val
, (int __user
*)optval
))
2661 if ((val
!= 0) && ((val
< 8) || (val
> SCTP_MAX_CHUNK_LEN
)))
2663 sp
->user_frag
= val
;
2665 /* Update the frag_point of the existing associations. */
2666 list_for_each(pos
, &(sp
->ep
->asocs
)) {
2667 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
2668 asoc
->frag_point
= sctp_frag_point(sp
, asoc
->pathmtu
);
2676 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
2678 * Requests that the peer mark the enclosed address as the association
2679 * primary. The enclosed address must be one of the association's
2680 * locally bound addresses. The following structure is used to make a
2681 * set primary request:
2683 static int sctp_setsockopt_peer_primary_addr(struct sock
*sk
, char __user
*optval
,
2686 struct sctp_sock
*sp
;
2687 struct sctp_endpoint
*ep
;
2688 struct sctp_association
*asoc
= NULL
;
2689 struct sctp_setpeerprim prim
;
2690 struct sctp_chunk
*chunk
;
2696 if (!sctp_addip_enable
)
2699 if (optlen
!= sizeof(struct sctp_setpeerprim
))
2702 if (copy_from_user(&prim
, optval
, optlen
))
2705 asoc
= sctp_id2assoc(sk
, prim
.sspp_assoc_id
);
2709 if (!asoc
->peer
.asconf_capable
)
2712 if (asoc
->peer
.addip_disabled_mask
& SCTP_PARAM_SET_PRIMARY
)
2715 if (!sctp_state(asoc
, ESTABLISHED
))
2718 if (!sctp_assoc_lookup_laddr(asoc
, (union sctp_addr
*)&prim
.sspp_addr
))
2719 return -EADDRNOTAVAIL
;
2721 /* Create an ASCONF chunk with SET_PRIMARY parameter */
2722 chunk
= sctp_make_asconf_set_prim(asoc
,
2723 (union sctp_addr
*)&prim
.sspp_addr
);
2727 err
= sctp_send_asconf(asoc
, chunk
);
2729 SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n");
2734 static int sctp_setsockopt_adaption_layer(struct sock
*sk
, char __user
*optval
,
2737 struct sctp_setadaption adaption
;
2739 if (optlen
!= sizeof(struct sctp_setadaption
))
2741 if (copy_from_user(&adaption
, optval
, optlen
))
2744 sctp_sk(sk
)->adaption_ind
= adaption
.ssb_adaption_ind
;
2749 /* API 6.2 setsockopt(), getsockopt()
2751 * Applications use setsockopt() and getsockopt() to set or retrieve
2752 * socket options. Socket options are used to change the default
2753 * behavior of sockets calls. They are described in Section 7.
2757 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
2758 * int __user *optlen);
2759 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
2762 * sd - the socket descript.
2763 * level - set to IPPROTO_SCTP for all SCTP options.
2764 * optname - the option name.
2765 * optval - the buffer to store the value of the option.
2766 * optlen - the size of the buffer.
2768 SCTP_STATIC
int sctp_setsockopt(struct sock
*sk
, int level
, int optname
,
2769 char __user
*optval
, int optlen
)
2773 SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n",
2776 /* I can hardly begin to describe how wrong this is. This is
2777 * so broken as to be worse than useless. The API draft
2778 * REALLY is NOT helpful here... I am not convinced that the
2779 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
2780 * are at all well-founded.
2782 if (level
!= SOL_SCTP
) {
2783 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
2784 retval
= af
->setsockopt(sk
, level
, optname
, optval
, optlen
);
2791 case SCTP_SOCKOPT_BINDX_ADD
:
2792 /* 'optlen' is the size of the addresses buffer. */
2793 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
2794 optlen
, SCTP_BINDX_ADD_ADDR
);
2797 case SCTP_SOCKOPT_BINDX_REM
:
2798 /* 'optlen' is the size of the addresses buffer. */
2799 retval
= sctp_setsockopt_bindx(sk
, (struct sockaddr __user
*)optval
,
2800 optlen
, SCTP_BINDX_REM_ADDR
);
2803 case SCTP_SOCKOPT_CONNECTX
:
2804 /* 'optlen' is the size of the addresses buffer. */
2805 retval
= sctp_setsockopt_connectx(sk
, (struct sockaddr __user
*)optval
,
2809 case SCTP_DISABLE_FRAGMENTS
:
2810 retval
= sctp_setsockopt_disable_fragments(sk
, optval
, optlen
);
2814 retval
= sctp_setsockopt_events(sk
, optval
, optlen
);
2817 case SCTP_AUTOCLOSE
:
2818 retval
= sctp_setsockopt_autoclose(sk
, optval
, optlen
);
2821 case SCTP_PEER_ADDR_PARAMS
:
2822 retval
= sctp_setsockopt_peer_addr_params(sk
, optval
, optlen
);
2825 case SCTP_DELAYED_ACK_TIME
:
2826 retval
= sctp_setsockopt_delayed_ack_time(sk
, optval
, optlen
);
2830 retval
= sctp_setsockopt_initmsg(sk
, optval
, optlen
);
2832 case SCTP_DEFAULT_SEND_PARAM
:
2833 retval
= sctp_setsockopt_default_send_param(sk
, optval
,
2836 case SCTP_PRIMARY_ADDR
:
2837 retval
= sctp_setsockopt_primary_addr(sk
, optval
, optlen
);
2839 case SCTP_SET_PEER_PRIMARY_ADDR
:
2840 retval
= sctp_setsockopt_peer_primary_addr(sk
, optval
, optlen
);
2843 retval
= sctp_setsockopt_nodelay(sk
, optval
, optlen
);
2846 retval
= sctp_setsockopt_rtoinfo(sk
, optval
, optlen
);
2848 case SCTP_ASSOCINFO
:
2849 retval
= sctp_setsockopt_associnfo(sk
, optval
, optlen
);
2851 case SCTP_I_WANT_MAPPED_V4_ADDR
:
2852 retval
= sctp_setsockopt_mappedv4(sk
, optval
, optlen
);
2855 retval
= sctp_setsockopt_maxseg(sk
, optval
, optlen
);
2857 case SCTP_ADAPTION_LAYER
:
2858 retval
= sctp_setsockopt_adaption_layer(sk
, optval
, optlen
);
2862 retval
= -ENOPROTOOPT
;
2866 sctp_release_sock(sk
);
2872 /* API 3.1.6 connect() - UDP Style Syntax
2874 * An application may use the connect() call in the UDP model to initiate an
2875 * association without sending data.
2879 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
2881 * sd: the socket descriptor to have a new association added to.
2883 * nam: the address structure (either struct sockaddr_in or struct
2884 * sockaddr_in6 defined in RFC2553 [7]).
2886 * len: the size of the address.
2888 SCTP_STATIC
int sctp_connect(struct sock
*sk
, struct sockaddr
*addr
,
2896 SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n",
2897 __FUNCTION__
, sk
, addr
, addr_len
);
2899 /* Validate addr_len before calling common connect/connectx routine. */
2900 af
= sctp_get_af_specific(addr
->sa_family
);
2901 if (!af
|| addr_len
< af
->sockaddr_len
) {
2904 /* Pass correct addr len to common routine (so it knows there
2905 * is only one address being passed.
2907 err
= __sctp_connect(sk
, addr
, af
->sockaddr_len
);
2910 sctp_release_sock(sk
);
2914 /* FIXME: Write comments. */
2915 SCTP_STATIC
int sctp_disconnect(struct sock
*sk
, int flags
)
2917 return -EOPNOTSUPP
; /* STUB */
2920 /* 4.1.4 accept() - TCP Style Syntax
2922 * Applications use accept() call to remove an established SCTP
2923 * association from the accept queue of the endpoint. A new socket
2924 * descriptor will be returned from accept() to represent the newly
2925 * formed association.
2927 SCTP_STATIC
struct sock
*sctp_accept(struct sock
*sk
, int flags
, int *err
)
2929 struct sctp_sock
*sp
;
2930 struct sctp_endpoint
*ep
;
2931 struct sock
*newsk
= NULL
;
2932 struct sctp_association
*asoc
;
2941 if (!sctp_style(sk
, TCP
)) {
2942 error
= -EOPNOTSUPP
;
2946 if (!sctp_sstate(sk
, LISTENING
)) {
2951 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
2953 error
= sctp_wait_for_accept(sk
, timeo
);
2957 /* We treat the list of associations on the endpoint as the accept
2958 * queue and pick the first association on the list.
2960 asoc
= list_entry(ep
->asocs
.next
, struct sctp_association
, asocs
);
2962 newsk
= sp
->pf
->create_accept_sk(sk
, asoc
);
2968 /* Populate the fields of the newsk from the oldsk and migrate the
2969 * asoc to the newsk.
2971 sctp_sock_migrate(sk
, newsk
, asoc
, SCTP_SOCKET_TCP
);
2974 sctp_release_sock(sk
);
2979 /* The SCTP ioctl handler. */
2980 SCTP_STATIC
int sctp_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
2982 return -ENOIOCTLCMD
;
2985 /* This is the function which gets called during socket creation to
2986 * initialized the SCTP-specific portion of the sock.
2987 * The sock structure should already be zero-filled memory.
2989 SCTP_STATIC
int sctp_init_sock(struct sock
*sk
)
2991 struct sctp_endpoint
*ep
;
2992 struct sctp_sock
*sp
;
2994 SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk
);
2998 /* Initialize the SCTP per socket area. */
2999 switch (sk
->sk_type
) {
3000 case SOCK_SEQPACKET
:
3001 sp
->type
= SCTP_SOCKET_UDP
;
3004 sp
->type
= SCTP_SOCKET_TCP
;
3007 return -ESOCKTNOSUPPORT
;
3010 /* Initialize default send parameters. These parameters can be
3011 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
3013 sp
->default_stream
= 0;
3014 sp
->default_ppid
= 0;
3015 sp
->default_flags
= 0;
3016 sp
->default_context
= 0;
3017 sp
->default_timetolive
= 0;
3019 /* Initialize default setup parameters. These parameters
3020 * can be modified with the SCTP_INITMSG socket option or
3021 * overridden by the SCTP_INIT CMSG.
3023 sp
->initmsg
.sinit_num_ostreams
= sctp_max_outstreams
;
3024 sp
->initmsg
.sinit_max_instreams
= sctp_max_instreams
;
3025 sp
->initmsg
.sinit_max_attempts
= sctp_max_retrans_init
;
3026 sp
->initmsg
.sinit_max_init_timeo
= sctp_rto_max
;
3028 /* Initialize default RTO related parameters. These parameters can
3029 * be modified for with the SCTP_RTOINFO socket option.
3031 sp
->rtoinfo
.srto_initial
= sctp_rto_initial
;
3032 sp
->rtoinfo
.srto_max
= sctp_rto_max
;
3033 sp
->rtoinfo
.srto_min
= sctp_rto_min
;
3035 /* Initialize default association related parameters. These parameters
3036 * can be modified with the SCTP_ASSOCINFO socket option.
3038 sp
->assocparams
.sasoc_asocmaxrxt
= sctp_max_retrans_association
;
3039 sp
->assocparams
.sasoc_number_peer_destinations
= 0;
3040 sp
->assocparams
.sasoc_peer_rwnd
= 0;
3041 sp
->assocparams
.sasoc_local_rwnd
= 0;
3042 sp
->assocparams
.sasoc_cookie_life
= sctp_valid_cookie_life
;
3044 /* Initialize default event subscriptions. By default, all the
3047 memset(&sp
->subscribe
, 0, sizeof(struct sctp_event_subscribe
));
3049 /* Default Peer Address Parameters. These defaults can
3050 * be modified via SCTP_PEER_ADDR_PARAMS
3052 sp
->hbinterval
= sctp_hb_interval
;
3053 sp
->pathmaxrxt
= sctp_max_retrans_path
;
3054 sp
->pathmtu
= 0; // allow default discovery
3055 sp
->sackdelay
= sctp_sack_timeout
;
3056 sp
->param_flags
= SPP_HB_ENABLE
|
3058 SPP_SACKDELAY_ENABLE
;
3060 /* If enabled no SCTP message fragmentation will be performed.
3061 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
3063 sp
->disable_fragments
= 0;
3065 /* Enable Nagle algorithm by default. */
3068 /* Enable by default. */
3071 /* Auto-close idle associations after the configured
3072 * number of seconds. A value of 0 disables this
3073 * feature. Configure through the SCTP_AUTOCLOSE socket option,
3074 * for UDP-style sockets only.
3078 /* User specified fragmentation limit. */
3081 sp
->adaption_ind
= 0;
3083 sp
->pf
= sctp_get_pf_specific(sk
->sk_family
);
3085 /* Control variables for partial data delivery. */
3087 skb_queue_head_init(&sp
->pd_lobby
);
3089 /* Create a per socket endpoint structure. Even if we
3090 * change the data structure relationships, this may still
3091 * be useful for storing pre-connect address information.
3093 ep
= sctp_endpoint_new(sk
, GFP_KERNEL
);
3100 SCTP_DBG_OBJCNT_INC(sock
);
3104 /* Cleanup any SCTP per socket resources. */
3105 SCTP_STATIC
int sctp_destroy_sock(struct sock
*sk
)
3107 struct sctp_endpoint
*ep
;
3109 SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk
);
3111 /* Release our hold on the endpoint. */
3112 ep
= sctp_sk(sk
)->ep
;
3113 sctp_endpoint_free(ep
);
3118 /* API 4.1.7 shutdown() - TCP Style Syntax
3119 * int shutdown(int socket, int how);
3121 * sd - the socket descriptor of the association to be closed.
3122 * how - Specifies the type of shutdown. The values are
3125 * Disables further receive operations. No SCTP
3126 * protocol action is taken.
3128 * Disables further send operations, and initiates
3129 * the SCTP shutdown sequence.
3131 * Disables further send and receive operations
3132 * and initiates the SCTP shutdown sequence.
3134 SCTP_STATIC
void sctp_shutdown(struct sock
*sk
, int how
)
3136 struct sctp_endpoint
*ep
;
3137 struct sctp_association
*asoc
;
3139 if (!sctp_style(sk
, TCP
))
3142 if (how
& SEND_SHUTDOWN
) {
3143 ep
= sctp_sk(sk
)->ep
;
3144 if (!list_empty(&ep
->asocs
)) {
3145 asoc
= list_entry(ep
->asocs
.next
,
3146 struct sctp_association
, asocs
);
3147 sctp_primitive_SHUTDOWN(asoc
, NULL
);
3152 /* 7.2.1 Association Status (SCTP_STATUS)
3154 * Applications can retrieve current status information about an
3155 * association, including association state, peer receiver window size,
3156 * number of unacked data chunks, and number of data chunks pending
3157 * receipt. This information is read-only.
3159 static int sctp_getsockopt_sctp_status(struct sock
*sk
, int len
,
3160 char __user
*optval
,
3163 struct sctp_status status
;
3164 struct sctp_association
*asoc
= NULL
;
3165 struct sctp_transport
*transport
;
3166 sctp_assoc_t associd
;
3169 if (len
!= sizeof(status
)) {
3174 if (copy_from_user(&status
, optval
, sizeof(status
))) {
3179 associd
= status
.sstat_assoc_id
;
3180 asoc
= sctp_id2assoc(sk
, associd
);
3186 transport
= asoc
->peer
.primary_path
;
3188 status
.sstat_assoc_id
= sctp_assoc2id(asoc
);
3189 status
.sstat_state
= asoc
->state
;
3190 status
.sstat_rwnd
= asoc
->peer
.rwnd
;
3191 status
.sstat_unackdata
= asoc
->unack_data
;
3193 status
.sstat_penddata
= sctp_tsnmap_pending(&asoc
->peer
.tsn_map
);
3194 status
.sstat_instrms
= asoc
->c
.sinit_max_instreams
;
3195 status
.sstat_outstrms
= asoc
->c
.sinit_num_ostreams
;
3196 status
.sstat_fragmentation_point
= asoc
->frag_point
;
3197 status
.sstat_primary
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
3198 memcpy(&status
.sstat_primary
.spinfo_address
, &transport
->ipaddr
,
3199 transport
->af_specific
->sockaddr_len
);
3200 /* Map ipv4 address into v4-mapped-on-v6 address. */
3201 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sctp_sk(sk
),
3202 (union sctp_addr
*)&status
.sstat_primary
.spinfo_address
);
3203 status
.sstat_primary
.spinfo_state
= transport
->state
;
3204 status
.sstat_primary
.spinfo_cwnd
= transport
->cwnd
;
3205 status
.sstat_primary
.spinfo_srtt
= transport
->srtt
;
3206 status
.sstat_primary
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
3207 status
.sstat_primary
.spinfo_mtu
= transport
->pathmtu
;
3209 if (status
.sstat_primary
.spinfo_state
== SCTP_UNKNOWN
)
3210 status
.sstat_primary
.spinfo_state
= SCTP_ACTIVE
;
3212 if (put_user(len
, optlen
)) {
3217 SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n",
3218 len
, status
.sstat_state
, status
.sstat_rwnd
,
3219 status
.sstat_assoc_id
);
3221 if (copy_to_user(optval
, &status
, len
)) {
3231 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
3233 * Applications can retrieve information about a specific peer address
3234 * of an association, including its reachability state, congestion
3235 * window, and retransmission timer values. This information is
3238 static int sctp_getsockopt_peer_addr_info(struct sock
*sk
, int len
,
3239 char __user
*optval
,
3242 struct sctp_paddrinfo pinfo
;
3243 struct sctp_transport
*transport
;
3246 if (len
!= sizeof(pinfo
)) {
3251 if (copy_from_user(&pinfo
, optval
, sizeof(pinfo
))) {
3256 transport
= sctp_addr_id2transport(sk
, &pinfo
.spinfo_address
,
3257 pinfo
.spinfo_assoc_id
);
3261 pinfo
.spinfo_assoc_id
= sctp_assoc2id(transport
->asoc
);
3262 pinfo
.spinfo_state
= transport
->state
;
3263 pinfo
.spinfo_cwnd
= transport
->cwnd
;
3264 pinfo
.spinfo_srtt
= transport
->srtt
;
3265 pinfo
.spinfo_rto
= jiffies_to_msecs(transport
->rto
);
3266 pinfo
.spinfo_mtu
= transport
->pathmtu
;
3268 if (pinfo
.spinfo_state
== SCTP_UNKNOWN
)
3269 pinfo
.spinfo_state
= SCTP_ACTIVE
;
3271 if (put_user(len
, optlen
)) {
3276 if (copy_to_user(optval
, &pinfo
, len
)) {
3285 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
3287 * This option is a on/off flag. If enabled no SCTP message
3288 * fragmentation will be performed. Instead if a message being sent
3289 * exceeds the current PMTU size, the message will NOT be sent and
3290 * instead a error will be indicated to the user.
3292 static int sctp_getsockopt_disable_fragments(struct sock
*sk
, int len
,
3293 char __user
*optval
, int __user
*optlen
)
3297 if (len
< sizeof(int))
3301 val
= (sctp_sk(sk
)->disable_fragments
== 1);
3302 if (put_user(len
, optlen
))
3304 if (copy_to_user(optval
, &val
, len
))
3309 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
3311 * This socket option is used to specify various notifications and
3312 * ancillary data the user wishes to receive.
3314 static int sctp_getsockopt_events(struct sock
*sk
, int len
, char __user
*optval
,
3317 if (len
!= sizeof(struct sctp_event_subscribe
))
3319 if (copy_to_user(optval
, &sctp_sk(sk
)->subscribe
, len
))
3324 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
3326 * This socket option is applicable to the UDP-style socket only. When
3327 * set it will cause associations that are idle for more than the
3328 * specified number of seconds to automatically close. An association
3329 * being idle is defined an association that has NOT sent or received
3330 * user data. The special value of '0' indicates that no automatic
3331 * close of any associations should be performed. The option expects an
3332 * integer defining the number of seconds of idle time before an
3333 * association is closed.
3335 static int sctp_getsockopt_autoclose(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
3337 /* Applicable to UDP-style socket only */
3338 if (sctp_style(sk
, TCP
))
3340 if (len
!= sizeof(int))
3342 if (copy_to_user(optval
, &sctp_sk(sk
)->autoclose
, len
))
3347 /* Helper routine to branch off an association to a new socket. */
3348 SCTP_STATIC
int sctp_do_peeloff(struct sctp_association
*asoc
,
3349 struct socket
**sockp
)
3351 struct sock
*sk
= asoc
->base
.sk
;
3352 struct socket
*sock
;
3353 struct inet_sock
*inetsk
;
3356 /* An association cannot be branched off from an already peeled-off
3357 * socket, nor is this supported for tcp style sockets.
3359 if (!sctp_style(sk
, UDP
))
3362 /* Create a new socket. */
3363 err
= sock_create(sk
->sk_family
, SOCK_SEQPACKET
, IPPROTO_SCTP
, &sock
);
3367 /* Populate the fields of the newsk from the oldsk and migrate the
3368 * asoc to the newsk.
3370 sctp_sock_migrate(sk
, sock
->sk
, asoc
, SCTP_SOCKET_UDP_HIGH_BANDWIDTH
);
3372 /* Make peeled-off sockets more like 1-1 accepted sockets.
3373 * Set the daddr and initialize id to something more random
3375 inetsk
= inet_sk(sock
->sk
);
3376 inetsk
->daddr
= asoc
->peer
.primary_addr
.v4
.sin_addr
.s_addr
;
3377 inetsk
->id
= asoc
->next_tsn
^ jiffies
;
3384 static int sctp_getsockopt_peeloff(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
3386 sctp_peeloff_arg_t peeloff
;
3387 struct socket
*newsock
;
3389 struct sctp_association
*asoc
;
3391 if (len
!= sizeof(sctp_peeloff_arg_t
))
3393 if (copy_from_user(&peeloff
, optval
, len
))
3396 asoc
= sctp_id2assoc(sk
, peeloff
.associd
);
3402 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __FUNCTION__
, sk
, asoc
);
3404 retval
= sctp_do_peeloff(asoc
, &newsock
);
3408 /* Map the socket to an unused fd that can be returned to the user. */
3409 retval
= sock_map_fd(newsock
);
3411 sock_release(newsock
);
3415 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n",
3416 __FUNCTION__
, sk
, asoc
, newsock
->sk
, retval
);
3418 /* Return the fd mapped to the new socket. */
3419 peeloff
.sd
= retval
;
3420 if (copy_to_user(optval
, &peeloff
, len
))
3427 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
3429 * Applications can enable or disable heartbeats for any peer address of
3430 * an association, modify an address's heartbeat interval, force a
3431 * heartbeat to be sent immediately, and adjust the address's maximum
3432 * number of retransmissions sent before an address is considered
3433 * unreachable. The following structure is used to access and modify an
3434 * address's parameters:
3436 * struct sctp_paddrparams {
3437 * sctp_assoc_t spp_assoc_id;
3438 * struct sockaddr_storage spp_address;
3439 * uint32_t spp_hbinterval;
3440 * uint16_t spp_pathmaxrxt;
3441 * uint32_t spp_pathmtu;
3442 * uint32_t spp_sackdelay;
3443 * uint32_t spp_flags;
3446 * spp_assoc_id - (one-to-many style socket) This is filled in the
3447 * application, and identifies the association for
3449 * spp_address - This specifies which address is of interest.
3450 * spp_hbinterval - This contains the value of the heartbeat interval,
3451 * in milliseconds. If a value of zero
3452 * is present in this field then no changes are to
3453 * be made to this parameter.
3454 * spp_pathmaxrxt - This contains the maximum number of
3455 * retransmissions before this address shall be
3456 * considered unreachable. If a value of zero
3457 * is present in this field then no changes are to
3458 * be made to this parameter.
3459 * spp_pathmtu - When Path MTU discovery is disabled the value
3460 * specified here will be the "fixed" path mtu.
3461 * Note that if the spp_address field is empty
3462 * then all associations on this address will
3463 * have this fixed path mtu set upon them.
3465 * spp_sackdelay - When delayed sack is enabled, this value specifies
3466 * the number of milliseconds that sacks will be delayed
3467 * for. This value will apply to all addresses of an
3468 * association if the spp_address field is empty. Note
3469 * also, that if delayed sack is enabled and this
3470 * value is set to 0, no change is made to the last
3471 * recorded delayed sack timer value.
3473 * spp_flags - These flags are used to control various features
3474 * on an association. The flag field may contain
3475 * zero or more of the following options.
3477 * SPP_HB_ENABLE - Enable heartbeats on the
3478 * specified address. Note that if the address
3479 * field is empty all addresses for the association
3480 * have heartbeats enabled upon them.
3482 * SPP_HB_DISABLE - Disable heartbeats on the
3483 * speicifed address. Note that if the address
3484 * field is empty all addresses for the association
3485 * will have their heartbeats disabled. Note also
3486 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
3487 * mutually exclusive, only one of these two should
3488 * be specified. Enabling both fields will have
3489 * undetermined results.
3491 * SPP_HB_DEMAND - Request a user initiated heartbeat
3492 * to be made immediately.
3494 * SPP_PMTUD_ENABLE - This field will enable PMTU
3495 * discovery upon the specified address. Note that
3496 * if the address feild is empty then all addresses
3497 * on the association are effected.
3499 * SPP_PMTUD_DISABLE - This field will disable PMTU
3500 * discovery upon the specified address. Note that
3501 * if the address feild is empty then all addresses
3502 * on the association are effected. Not also that
3503 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
3504 * exclusive. Enabling both will have undetermined
3507 * SPP_SACKDELAY_ENABLE - Setting this flag turns
3508 * on delayed sack. The time specified in spp_sackdelay
3509 * is used to specify the sack delay for this address. Note
3510 * that if spp_address is empty then all addresses will
3511 * enable delayed sack and take on the sack delay
3512 * value specified in spp_sackdelay.
3513 * SPP_SACKDELAY_DISABLE - Setting this flag turns
3514 * off delayed sack. If the spp_address field is blank then
3515 * delayed sack is disabled for the entire association. Note
3516 * also that this field is mutually exclusive to
3517 * SPP_SACKDELAY_ENABLE, setting both will have undefined
3520 static int sctp_getsockopt_peer_addr_params(struct sock
*sk
, int len
,
3521 char __user
*optval
, int __user
*optlen
)
3523 struct sctp_paddrparams params
;
3524 struct sctp_transport
*trans
= NULL
;
3525 struct sctp_association
*asoc
= NULL
;
3526 struct sctp_sock
*sp
= sctp_sk(sk
);
3528 if (len
!= sizeof(struct sctp_paddrparams
))
3531 if (copy_from_user(¶ms
, optval
, len
))
3534 /* If an address other than INADDR_ANY is specified, and
3535 * no transport is found, then the request is invalid.
3537 if (!sctp_is_any(( union sctp_addr
*)¶ms
.spp_address
)) {
3538 trans
= sctp_addr_id2transport(sk
, ¶ms
.spp_address
,
3539 params
.spp_assoc_id
);
3541 SCTP_DEBUG_PRINTK("Failed no transport\n");
3546 /* Get association, if assoc_id != 0 and the socket is a one
3547 * to many style socket, and an association was not found, then
3548 * the id was invalid.
3550 asoc
= sctp_id2assoc(sk
, params
.spp_assoc_id
);
3551 if (!asoc
&& params
.spp_assoc_id
&& sctp_style(sk
, UDP
)) {
3552 SCTP_DEBUG_PRINTK("Failed no association\n");
3557 /* Fetch transport values. */
3558 params
.spp_hbinterval
= jiffies_to_msecs(trans
->hbinterval
);
3559 params
.spp_pathmtu
= trans
->pathmtu
;
3560 params
.spp_pathmaxrxt
= trans
->pathmaxrxt
;
3561 params
.spp_sackdelay
= jiffies_to_msecs(trans
->sackdelay
);
3563 /*draft-11 doesn't say what to return in spp_flags*/
3564 params
.spp_flags
= trans
->param_flags
;
3566 /* Fetch association values. */
3567 params
.spp_hbinterval
= jiffies_to_msecs(asoc
->hbinterval
);
3568 params
.spp_pathmtu
= asoc
->pathmtu
;
3569 params
.spp_pathmaxrxt
= asoc
->pathmaxrxt
;
3570 params
.spp_sackdelay
= jiffies_to_msecs(asoc
->sackdelay
);
3572 /*draft-11 doesn't say what to return in spp_flags*/
3573 params
.spp_flags
= asoc
->param_flags
;
3575 /* Fetch socket values. */
3576 params
.spp_hbinterval
= sp
->hbinterval
;
3577 params
.spp_pathmtu
= sp
->pathmtu
;
3578 params
.spp_sackdelay
= sp
->sackdelay
;
3579 params
.spp_pathmaxrxt
= sp
->pathmaxrxt
;
3581 /*draft-11 doesn't say what to return in spp_flags*/
3582 params
.spp_flags
= sp
->param_flags
;
3585 if (copy_to_user(optval
, ¶ms
, len
))
3588 if (put_user(len
, optlen
))
3594 /* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)
3596 * This options will get or set the delayed ack timer. The time is set
3597 * in milliseconds. If the assoc_id is 0, then this sets or gets the
3598 * endpoints default delayed ack timer value. If the assoc_id field is
3599 * non-zero, then the set or get effects the specified association.
3601 * struct sctp_assoc_value {
3602 * sctp_assoc_t assoc_id;
3603 * uint32_t assoc_value;
3606 * assoc_id - This parameter, indicates which association the
3607 * user is preforming an action upon. Note that if
3608 * this field's value is zero then the endpoints
3609 * default value is changed (effecting future
3610 * associations only).
3612 * assoc_value - This parameter contains the number of milliseconds
3613 * that the user is requesting the delayed ACK timer
3614 * be set to. Note that this value is defined in
3615 * the standard to be between 200 and 500 milliseconds.
3617 * Note: a value of zero will leave the value alone,
3618 * but disable SACK delay. A non-zero value will also
3619 * enable SACK delay.
3621 static int sctp_getsockopt_delayed_ack_time(struct sock
*sk
, int len
,
3622 char __user
*optval
,
3625 struct sctp_assoc_value params
;
3626 struct sctp_association
*asoc
= NULL
;
3627 struct sctp_sock
*sp
= sctp_sk(sk
);
3629 if (len
!= sizeof(struct sctp_assoc_value
))
3632 if (copy_from_user(¶ms
, optval
, len
))
3635 /* Get association, if assoc_id != 0 and the socket is a one
3636 * to many style socket, and an association was not found, then
3637 * the id was invalid.
3639 asoc
= sctp_id2assoc(sk
, params
.assoc_id
);
3640 if (!asoc
&& params
.assoc_id
&& sctp_style(sk
, UDP
))
3644 /* Fetch association values. */
3645 if (asoc
->param_flags
& SPP_SACKDELAY_ENABLE
)
3646 params
.assoc_value
= jiffies_to_msecs(
3649 params
.assoc_value
= 0;
3651 /* Fetch socket values. */
3652 if (sp
->param_flags
& SPP_SACKDELAY_ENABLE
)
3653 params
.assoc_value
= sp
->sackdelay
;
3655 params
.assoc_value
= 0;
3658 if (copy_to_user(optval
, ¶ms
, len
))
3661 if (put_user(len
, optlen
))
3667 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
3669 * Applications can specify protocol parameters for the default association
3670 * initialization. The option name argument to setsockopt() and getsockopt()
3673 * Setting initialization parameters is effective only on an unconnected
3674 * socket (for UDP-style sockets only future associations are effected
3675 * by the change). With TCP-style sockets, this option is inherited by
3676 * sockets derived from a listener socket.
3678 static int sctp_getsockopt_initmsg(struct sock
*sk
, int len
, char __user
*optval
, int __user
*optlen
)
3680 if (len
!= sizeof(struct sctp_initmsg
))
3682 if (copy_to_user(optval
, &sctp_sk(sk
)->initmsg
, len
))
3687 static int sctp_getsockopt_peer_addrs_num_old(struct sock
*sk
, int len
,
3688 char __user
*optval
,
3692 struct sctp_association
*asoc
;
3693 struct list_head
*pos
;
3696 if (len
!= sizeof(sctp_assoc_t
))
3699 if (copy_from_user(&id
, optval
, sizeof(sctp_assoc_t
)))
3702 /* For UDP-style sockets, id specifies the association to query. */
3703 asoc
= sctp_id2assoc(sk
, id
);
3707 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
3715 * Old API for getting list of peer addresses. Does not work for 32-bit
3716 * programs running on a 64-bit kernel
3718 static int sctp_getsockopt_peer_addrs_old(struct sock
*sk
, int len
,
3719 char __user
*optval
,
3722 struct sctp_association
*asoc
;
3723 struct list_head
*pos
;
3725 struct sctp_getaddrs_old getaddrs
;
3726 struct sctp_transport
*from
;
3728 union sctp_addr temp
;
3729 struct sctp_sock
*sp
= sctp_sk(sk
);
3732 if (len
!= sizeof(struct sctp_getaddrs_old
))
3735 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs_old
)))
3738 if (getaddrs
.addr_num
<= 0) return -EINVAL
;
3740 /* For UDP-style sockets, id specifies the association to query. */
3741 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
3745 to
= (void __user
*)getaddrs
.addrs
;
3746 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
3747 from
= list_entry(pos
, struct sctp_transport
, transports
);
3748 memcpy(&temp
, &from
->ipaddr
, sizeof(temp
));
3749 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sp
, &temp
);
3750 addrlen
= sctp_get_af_specific(sk
->sk_family
)->sockaddr_len
;
3751 if (copy_to_user(to
, &temp
, addrlen
))
3755 if (cnt
>= getaddrs
.addr_num
) break;
3757 getaddrs
.addr_num
= cnt
;
3758 if (copy_to_user(optval
, &getaddrs
, sizeof(struct sctp_getaddrs_old
)))
3764 static int sctp_getsockopt_peer_addrs(struct sock
*sk
, int len
,
3765 char __user
*optval
, int __user
*optlen
)
3767 struct sctp_association
*asoc
;
3768 struct list_head
*pos
;
3770 struct sctp_getaddrs getaddrs
;
3771 struct sctp_transport
*from
;
3773 union sctp_addr temp
;
3774 struct sctp_sock
*sp
= sctp_sk(sk
);
3779 if (len
< sizeof(struct sctp_getaddrs
))
3782 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
3785 /* For UDP-style sockets, id specifies the association to query. */
3786 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
3790 to
= optval
+ offsetof(struct sctp_getaddrs
,addrs
);
3791 space_left
= len
- sizeof(struct sctp_getaddrs
) -
3792 offsetof(struct sctp_getaddrs
,addrs
);
3794 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
3795 from
= list_entry(pos
, struct sctp_transport
, transports
);
3796 memcpy(&temp
, &from
->ipaddr
, sizeof(temp
));
3797 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sp
, &temp
);
3798 addrlen
= sctp_get_af_specific(sk
->sk_family
)->sockaddr_len
;
3799 if(space_left
< addrlen
)
3801 if (copy_to_user(to
, &temp
, addrlen
))
3805 space_left
-= addrlen
;
3808 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
))
3810 bytes_copied
= ((char __user
*)to
) - optval
;
3811 if (put_user(bytes_copied
, optlen
))
3817 static int sctp_getsockopt_local_addrs_num_old(struct sock
*sk
, int len
,
3818 char __user
*optval
,
3822 struct sctp_bind_addr
*bp
;
3823 struct sctp_association
*asoc
;
3824 struct list_head
*pos
;
3825 struct sctp_sockaddr_entry
*addr
;
3826 rwlock_t
*addr_lock
;
3827 unsigned long flags
;
3830 if (len
!= sizeof(sctp_assoc_t
))
3833 if (copy_from_user(&id
, optval
, sizeof(sctp_assoc_t
)))
3837 * For UDP-style sockets, id specifies the association to query.
3838 * If the id field is set to the value '0' then the locally bound
3839 * addresses are returned without regard to any particular
3843 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
3844 addr_lock
= &sctp_sk(sk
)->ep
->base
.addr_lock
;
3846 asoc
= sctp_id2assoc(sk
, id
);
3849 bp
= &asoc
->base
.bind_addr
;
3850 addr_lock
= &asoc
->base
.addr_lock
;
3853 sctp_read_lock(addr_lock
);
3855 /* If the endpoint is bound to 0.0.0.0 or ::0, count the valid
3856 * addresses from the global local address list.
3858 if (sctp_list_single_entry(&bp
->address_list
)) {
3859 addr
= list_entry(bp
->address_list
.next
,
3860 struct sctp_sockaddr_entry
, list
);
3861 if (sctp_is_any(&addr
->a
)) {
3862 sctp_spin_lock_irqsave(&sctp_local_addr_lock
, flags
);
3863 list_for_each(pos
, &sctp_local_addr_list
) {
3864 addr
= list_entry(pos
,
3865 struct sctp_sockaddr_entry
,
3867 if ((PF_INET
== sk
->sk_family
) &&
3868 (AF_INET6
== addr
->a
.sa
.sa_family
))
3872 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock
,
3880 list_for_each(pos
, &bp
->address_list
) {
3885 sctp_read_unlock(addr_lock
);
3889 /* Helper function that copies local addresses to user and returns the number
3890 * of addresses copied.
3892 static int sctp_copy_laddrs_to_user_old(struct sock
*sk
, __u16 port
, int max_addrs
,
3895 struct list_head
*pos
;
3896 struct sctp_sockaddr_entry
*addr
;
3897 unsigned long flags
;
3898 union sctp_addr temp
;
3902 sctp_spin_lock_irqsave(&sctp_local_addr_lock
, flags
);
3903 list_for_each(pos
, &sctp_local_addr_list
) {
3904 addr
= list_entry(pos
, struct sctp_sockaddr_entry
, list
);
3905 if ((PF_INET
== sk
->sk_family
) &&
3906 (AF_INET6
== addr
->a
.sa
.sa_family
))
3908 memcpy(&temp
, &addr
->a
, sizeof(temp
));
3909 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sctp_sk(sk
),
3911 addrlen
= sctp_get_af_specific(temp
.sa
.sa_family
)->sockaddr_len
;
3912 if (copy_to_user(to
, &temp
, addrlen
)) {
3913 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock
,
3919 if (cnt
>= max_addrs
) break;
3921 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock
, flags
);
3926 static int sctp_copy_laddrs_to_user(struct sock
*sk
, __u16 port
,
3927 void __user
**to
, size_t space_left
)
3929 struct list_head
*pos
;
3930 struct sctp_sockaddr_entry
*addr
;
3931 unsigned long flags
;
3932 union sctp_addr temp
;
3936 sctp_spin_lock_irqsave(&sctp_local_addr_lock
, flags
);
3937 list_for_each(pos
, &sctp_local_addr_list
) {
3938 addr
= list_entry(pos
, struct sctp_sockaddr_entry
, list
);
3939 if ((PF_INET
== sk
->sk_family
) &&
3940 (AF_INET6
== addr
->a
.sa
.sa_family
))
3942 memcpy(&temp
, &addr
->a
, sizeof(temp
));
3943 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sctp_sk(sk
),
3945 addrlen
= sctp_get_af_specific(temp
.sa
.sa_family
)->sockaddr_len
;
3946 if(space_left
<addrlen
)
3948 if (copy_to_user(*to
, &temp
, addrlen
)) {
3949 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock
,
3955 space_left
-= addrlen
;
3957 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock
, flags
);
3962 /* Old API for getting list of local addresses. Does not work for 32-bit
3963 * programs running on a 64-bit kernel
3965 static int sctp_getsockopt_local_addrs_old(struct sock
*sk
, int len
,
3966 char __user
*optval
, int __user
*optlen
)
3968 struct sctp_bind_addr
*bp
;
3969 struct sctp_association
*asoc
;
3970 struct list_head
*pos
;
3972 struct sctp_getaddrs_old getaddrs
;
3973 struct sctp_sockaddr_entry
*addr
;
3975 union sctp_addr temp
;
3976 struct sctp_sock
*sp
= sctp_sk(sk
);
3978 rwlock_t
*addr_lock
;
3981 if (len
!= sizeof(struct sctp_getaddrs_old
))
3984 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs_old
)))
3987 if (getaddrs
.addr_num
<= 0) return -EINVAL
;
3989 * For UDP-style sockets, id specifies the association to query.
3990 * If the id field is set to the value '0' then the locally bound
3991 * addresses are returned without regard to any particular
3994 if (0 == getaddrs
.assoc_id
) {
3995 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
3996 addr_lock
= &sctp_sk(sk
)->ep
->base
.addr_lock
;
3998 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
4001 bp
= &asoc
->base
.bind_addr
;
4002 addr_lock
= &asoc
->base
.addr_lock
;
4005 to
= getaddrs
.addrs
;
4007 sctp_read_lock(addr_lock
);
4009 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4010 * addresses from the global local address list.
4012 if (sctp_list_single_entry(&bp
->address_list
)) {
4013 addr
= list_entry(bp
->address_list
.next
,
4014 struct sctp_sockaddr_entry
, list
);
4015 if (sctp_is_any(&addr
->a
)) {
4016 cnt
= sctp_copy_laddrs_to_user_old(sk
, bp
->port
,
4027 list_for_each(pos
, &bp
->address_list
) {
4028 addr
= list_entry(pos
, struct sctp_sockaddr_entry
, list
);
4029 memcpy(&temp
, &addr
->a
, sizeof(temp
));
4030 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sp
, &temp
);
4031 addrlen
= sctp_get_af_specific(temp
.sa
.sa_family
)->sockaddr_len
;
4032 if (copy_to_user(to
, &temp
, addrlen
)) {
4038 if (cnt
>= getaddrs
.addr_num
) break;
4042 getaddrs
.addr_num
= cnt
;
4043 if (copy_to_user(optval
, &getaddrs
, sizeof(struct sctp_getaddrs_old
)))
4047 sctp_read_unlock(addr_lock
);
4051 static int sctp_getsockopt_local_addrs(struct sock
*sk
, int len
,
4052 char __user
*optval
, int __user
*optlen
)
4054 struct sctp_bind_addr
*bp
;
4055 struct sctp_association
*asoc
;
4056 struct list_head
*pos
;
4058 struct sctp_getaddrs getaddrs
;
4059 struct sctp_sockaddr_entry
*addr
;
4061 union sctp_addr temp
;
4062 struct sctp_sock
*sp
= sctp_sk(sk
);
4064 rwlock_t
*addr_lock
;
4069 if (len
<= sizeof(struct sctp_getaddrs
))
4072 if (copy_from_user(&getaddrs
, optval
, sizeof(struct sctp_getaddrs
)))
4076 * For UDP-style sockets, id specifies the association to query.
4077 * If the id field is set to the value '0' then the locally bound
4078 * addresses are returned without regard to any particular
4081 if (0 == getaddrs
.assoc_id
) {
4082 bp
= &sctp_sk(sk
)->ep
->base
.bind_addr
;
4083 addr_lock
= &sctp_sk(sk
)->ep
->base
.addr_lock
;
4085 asoc
= sctp_id2assoc(sk
, getaddrs
.assoc_id
);
4088 bp
= &asoc
->base
.bind_addr
;
4089 addr_lock
= &asoc
->base
.addr_lock
;
4092 to
= optval
+ offsetof(struct sctp_getaddrs
,addrs
);
4093 space_left
= len
- sizeof(struct sctp_getaddrs
) -
4094 offsetof(struct sctp_getaddrs
,addrs
);
4096 sctp_read_lock(addr_lock
);
4098 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4099 * addresses from the global local address list.
4101 if (sctp_list_single_entry(&bp
->address_list
)) {
4102 addr
= list_entry(bp
->address_list
.next
,
4103 struct sctp_sockaddr_entry
, list
);
4104 if (sctp_is_any(&addr
->a
)) {
4105 cnt
= sctp_copy_laddrs_to_user(sk
, bp
->port
,
4115 list_for_each(pos
, &bp
->address_list
) {
4116 addr
= list_entry(pos
, struct sctp_sockaddr_entry
, list
);
4117 memcpy(&temp
, &addr
->a
, sizeof(temp
));
4118 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sp
, &temp
);
4119 addrlen
= sctp_get_af_specific(temp
.sa
.sa_family
)->sockaddr_len
;
4120 if(space_left
< addrlen
)
4121 return -ENOMEM
; /*fixme: right error?*/
4122 if (copy_to_user(to
, &temp
, addrlen
)) {
4128 space_left
-= addrlen
;
4132 if (put_user(cnt
, &((struct sctp_getaddrs __user
*)optval
)->addr_num
))
4134 bytes_copied
= ((char __user
*)to
) - optval
;
4135 if (put_user(bytes_copied
, optlen
))
4139 sctp_read_unlock(addr_lock
);
4143 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
4145 * Requests that the local SCTP stack use the enclosed peer address as
4146 * the association primary. The enclosed address must be one of the
4147 * association peer's addresses.
4149 static int sctp_getsockopt_primary_addr(struct sock
*sk
, int len
,
4150 char __user
*optval
, int __user
*optlen
)
4152 struct sctp_prim prim
;
4153 struct sctp_association
*asoc
;
4154 struct sctp_sock
*sp
= sctp_sk(sk
);
4156 if (len
!= sizeof(struct sctp_prim
))
4159 if (copy_from_user(&prim
, optval
, sizeof(struct sctp_prim
)))
4162 asoc
= sctp_id2assoc(sk
, prim
.ssp_assoc_id
);
4166 if (!asoc
->peer
.primary_path
)
4169 memcpy(&prim
.ssp_addr
, &asoc
->peer
.primary_path
->ipaddr
,
4170 asoc
->peer
.primary_path
->af_specific
->sockaddr_len
);
4172 sctp_get_pf_specific(sk
->sk_family
)->addr_v4map(sp
,
4173 (union sctp_addr
*)&prim
.ssp_addr
);
4175 if (copy_to_user(optval
, &prim
, sizeof(struct sctp_prim
)))
4182 * 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)
4184 * Requests that the local endpoint set the specified Adaption Layer
4185 * Indication parameter for all future INIT and INIT-ACK exchanges.
4187 static int sctp_getsockopt_adaption_layer(struct sock
*sk
, int len
,
4188 char __user
*optval
, int __user
*optlen
)
4190 struct sctp_setadaption adaption
;
4192 if (len
!= sizeof(struct sctp_setadaption
))
4195 adaption
.ssb_adaption_ind
= sctp_sk(sk
)->adaption_ind
;
4196 if (copy_to_user(optval
, &adaption
, len
))
4204 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
4206 * Applications that wish to use the sendto() system call may wish to
4207 * specify a default set of parameters that would normally be supplied
4208 * through the inclusion of ancillary data. This socket option allows
4209 * such an application to set the default sctp_sndrcvinfo structure.
4212 * The application that wishes to use this socket option simply passes
4213 * in to this call the sctp_sndrcvinfo structure defined in Section
4214 * 5.2.2) The input parameters accepted by this call include
4215 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
4216 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
4217 * to this call if the caller is using the UDP model.
4219 * For getsockopt, it get the default sctp_sndrcvinfo structure.
4221 static int sctp_getsockopt_default_send_param(struct sock
*sk
,
4222 int len
, char __user
*optval
,
4225 struct sctp_sndrcvinfo info
;
4226 struct sctp_association
*asoc
;
4227 struct sctp_sock
*sp
= sctp_sk(sk
);
4229 if (len
!= sizeof(struct sctp_sndrcvinfo
))
4231 if (copy_from_user(&info
, optval
, sizeof(struct sctp_sndrcvinfo
)))
4234 asoc
= sctp_id2assoc(sk
, info
.sinfo_assoc_id
);
4235 if (!asoc
&& info
.sinfo_assoc_id
&& sctp_style(sk
, UDP
))
4239 info
.sinfo_stream
= asoc
->default_stream
;
4240 info
.sinfo_flags
= asoc
->default_flags
;
4241 info
.sinfo_ppid
= asoc
->default_ppid
;
4242 info
.sinfo_context
= asoc
->default_context
;
4243 info
.sinfo_timetolive
= asoc
->default_timetolive
;
4245 info
.sinfo_stream
= sp
->default_stream
;
4246 info
.sinfo_flags
= sp
->default_flags
;
4247 info
.sinfo_ppid
= sp
->default_ppid
;
4248 info
.sinfo_context
= sp
->default_context
;
4249 info
.sinfo_timetolive
= sp
->default_timetolive
;
4252 if (copy_to_user(optval
, &info
, sizeof(struct sctp_sndrcvinfo
)))
4260 * 7.1.5 SCTP_NODELAY
4262 * Turn on/off any Nagle-like algorithm. This means that packets are
4263 * generally sent as soon as possible and no unnecessary delays are
4264 * introduced, at the cost of more packets in the network. Expects an
4265 * integer boolean flag.
4268 static int sctp_getsockopt_nodelay(struct sock
*sk
, int len
,
4269 char __user
*optval
, int __user
*optlen
)
4273 if (len
< sizeof(int))
4277 val
= (sctp_sk(sk
)->nodelay
== 1);
4278 if (put_user(len
, optlen
))
4280 if (copy_to_user(optval
, &val
, len
))
4287 * 7.1.1 SCTP_RTOINFO
4289 * The protocol parameters used to initialize and bound retransmission
4290 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
4291 * and modify these parameters.
4292 * All parameters are time values, in milliseconds. A value of 0, when
4293 * modifying the parameters, indicates that the current value should not
4297 static int sctp_getsockopt_rtoinfo(struct sock
*sk
, int len
,
4298 char __user
*optval
,
4299 int __user
*optlen
) {
4300 struct sctp_rtoinfo rtoinfo
;
4301 struct sctp_association
*asoc
;
4303 if (len
!= sizeof (struct sctp_rtoinfo
))
4306 if (copy_from_user(&rtoinfo
, optval
, sizeof (struct sctp_rtoinfo
)))
4309 asoc
= sctp_id2assoc(sk
, rtoinfo
.srto_assoc_id
);
4311 if (!asoc
&& rtoinfo
.srto_assoc_id
&& sctp_style(sk
, UDP
))
4314 /* Values corresponding to the specific association. */
4316 rtoinfo
.srto_initial
= jiffies_to_msecs(asoc
->rto_initial
);
4317 rtoinfo
.srto_max
= jiffies_to_msecs(asoc
->rto_max
);
4318 rtoinfo
.srto_min
= jiffies_to_msecs(asoc
->rto_min
);
4320 /* Values corresponding to the endpoint. */
4321 struct sctp_sock
*sp
= sctp_sk(sk
);
4323 rtoinfo
.srto_initial
= sp
->rtoinfo
.srto_initial
;
4324 rtoinfo
.srto_max
= sp
->rtoinfo
.srto_max
;
4325 rtoinfo
.srto_min
= sp
->rtoinfo
.srto_min
;
4328 if (put_user(len
, optlen
))
4331 if (copy_to_user(optval
, &rtoinfo
, len
))
4339 * 7.1.2 SCTP_ASSOCINFO
4341 * This option is used to tune the the maximum retransmission attempts
4342 * of the association.
4343 * Returns an error if the new association retransmission value is
4344 * greater than the sum of the retransmission value of the peer.
4345 * See [SCTP] for more information.
4348 static int sctp_getsockopt_associnfo(struct sock
*sk
, int len
,
4349 char __user
*optval
,
4353 struct sctp_assocparams assocparams
;
4354 struct sctp_association
*asoc
;
4355 struct list_head
*pos
;
4358 if (len
!= sizeof (struct sctp_assocparams
))
4361 if (copy_from_user(&assocparams
, optval
,
4362 sizeof (struct sctp_assocparams
)))
4365 asoc
= sctp_id2assoc(sk
, assocparams
.sasoc_assoc_id
);
4367 if (!asoc
&& assocparams
.sasoc_assoc_id
&& sctp_style(sk
, UDP
))
4370 /* Values correspoinding to the specific association */
4372 assocparams
.sasoc_asocmaxrxt
= asoc
->max_retrans
;
4373 assocparams
.sasoc_peer_rwnd
= asoc
->peer
.rwnd
;
4374 assocparams
.sasoc_local_rwnd
= asoc
->a_rwnd
;
4375 assocparams
.sasoc_cookie_life
= (asoc
->cookie_life
.tv_sec
4377 (asoc
->cookie_life
.tv_usec
4380 list_for_each(pos
, &asoc
->peer
.transport_addr_list
) {
4384 assocparams
.sasoc_number_peer_destinations
= cnt
;
4386 /* Values corresponding to the endpoint */
4387 struct sctp_sock
*sp
= sctp_sk(sk
);
4389 assocparams
.sasoc_asocmaxrxt
= sp
->assocparams
.sasoc_asocmaxrxt
;
4390 assocparams
.sasoc_peer_rwnd
= sp
->assocparams
.sasoc_peer_rwnd
;
4391 assocparams
.sasoc_local_rwnd
= sp
->assocparams
.sasoc_local_rwnd
;
4392 assocparams
.sasoc_cookie_life
=
4393 sp
->assocparams
.sasoc_cookie_life
;
4394 assocparams
.sasoc_number_peer_destinations
=
4396 sasoc_number_peer_destinations
;
4399 if (put_user(len
, optlen
))
4402 if (copy_to_user(optval
, &assocparams
, len
))
4409 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
4411 * This socket option is a boolean flag which turns on or off mapped V4
4412 * addresses. If this option is turned on and the socket is type
4413 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
4414 * If this option is turned off, then no mapping will be done of V4
4415 * addresses and a user will receive both PF_INET6 and PF_INET type
4416 * addresses on the socket.
4418 static int sctp_getsockopt_mappedv4(struct sock
*sk
, int len
,
4419 char __user
*optval
, int __user
*optlen
)
4422 struct sctp_sock
*sp
= sctp_sk(sk
);
4424 if (len
< sizeof(int))
4429 if (put_user(len
, optlen
))
4431 if (copy_to_user(optval
, &val
, len
))
4438 * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
4440 * This socket option specifies the maximum size to put in any outgoing
4441 * SCTP chunk. If a message is larger than this size it will be
4442 * fragmented by SCTP into the specified size. Note that the underlying
4443 * SCTP implementation may fragment into smaller sized chunks when the
4444 * PMTU of the underlying association is smaller than the value set by
4447 static int sctp_getsockopt_maxseg(struct sock
*sk
, int len
,
4448 char __user
*optval
, int __user
*optlen
)
4452 if (len
< sizeof(int))
4457 val
= sctp_sk(sk
)->user_frag
;
4458 if (put_user(len
, optlen
))
4460 if (copy_to_user(optval
, &val
, len
))
4466 SCTP_STATIC
int sctp_getsockopt(struct sock
*sk
, int level
, int optname
,
4467 char __user
*optval
, int __user
*optlen
)
4472 SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n",
4475 /* I can hardly begin to describe how wrong this is. This is
4476 * so broken as to be worse than useless. The API draft
4477 * REALLY is NOT helpful here... I am not convinced that the
4478 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
4479 * are at all well-founded.
4481 if (level
!= SOL_SCTP
) {
4482 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
4484 retval
= af
->getsockopt(sk
, level
, optname
, optval
, optlen
);
4488 if (get_user(len
, optlen
))
4495 retval
= sctp_getsockopt_sctp_status(sk
, len
, optval
, optlen
);
4497 case SCTP_DISABLE_FRAGMENTS
:
4498 retval
= sctp_getsockopt_disable_fragments(sk
, len
, optval
,
4502 retval
= sctp_getsockopt_events(sk
, len
, optval
, optlen
);
4504 case SCTP_AUTOCLOSE
:
4505 retval
= sctp_getsockopt_autoclose(sk
, len
, optval
, optlen
);
4507 case SCTP_SOCKOPT_PEELOFF
:
4508 retval
= sctp_getsockopt_peeloff(sk
, len
, optval
, optlen
);
4510 case SCTP_PEER_ADDR_PARAMS
:
4511 retval
= sctp_getsockopt_peer_addr_params(sk
, len
, optval
,
4514 case SCTP_DELAYED_ACK_TIME
:
4515 retval
= sctp_getsockopt_delayed_ack_time(sk
, len
, optval
,
4519 retval
= sctp_getsockopt_initmsg(sk
, len
, optval
, optlen
);
4521 case SCTP_GET_PEER_ADDRS_NUM_OLD
:
4522 retval
= sctp_getsockopt_peer_addrs_num_old(sk
, len
, optval
,
4525 case SCTP_GET_LOCAL_ADDRS_NUM_OLD
:
4526 retval
= sctp_getsockopt_local_addrs_num_old(sk
, len
, optval
,
4529 case SCTP_GET_PEER_ADDRS_OLD
:
4530 retval
= sctp_getsockopt_peer_addrs_old(sk
, len
, optval
,
4533 case SCTP_GET_LOCAL_ADDRS_OLD
:
4534 retval
= sctp_getsockopt_local_addrs_old(sk
, len
, optval
,
4537 case SCTP_GET_PEER_ADDRS
:
4538 retval
= sctp_getsockopt_peer_addrs(sk
, len
, optval
,
4541 case SCTP_GET_LOCAL_ADDRS
:
4542 retval
= sctp_getsockopt_local_addrs(sk
, len
, optval
,
4545 case SCTP_DEFAULT_SEND_PARAM
:
4546 retval
= sctp_getsockopt_default_send_param(sk
, len
,
4549 case SCTP_PRIMARY_ADDR
:
4550 retval
= sctp_getsockopt_primary_addr(sk
, len
, optval
, optlen
);
4553 retval
= sctp_getsockopt_nodelay(sk
, len
, optval
, optlen
);
4556 retval
= sctp_getsockopt_rtoinfo(sk
, len
, optval
, optlen
);
4558 case SCTP_ASSOCINFO
:
4559 retval
= sctp_getsockopt_associnfo(sk
, len
, optval
, optlen
);
4561 case SCTP_I_WANT_MAPPED_V4_ADDR
:
4562 retval
= sctp_getsockopt_mappedv4(sk
, len
, optval
, optlen
);
4565 retval
= sctp_getsockopt_maxseg(sk
, len
, optval
, optlen
);
4567 case SCTP_GET_PEER_ADDR_INFO
:
4568 retval
= sctp_getsockopt_peer_addr_info(sk
, len
, optval
,
4571 case SCTP_ADAPTION_LAYER
:
4572 retval
= sctp_getsockopt_adaption_layer(sk
, len
, optval
,
4576 retval
= -ENOPROTOOPT
;
4580 sctp_release_sock(sk
);
4584 static void sctp_hash(struct sock
*sk
)
4589 static void sctp_unhash(struct sock
*sk
)
4594 /* Check if port is acceptable. Possibly find first available port.
4596 * The port hash table (contained in the 'global' SCTP protocol storage
4597 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
4598 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
4599 * list (the list number is the port number hashed out, so as you
4600 * would expect from a hash function, all the ports in a given list have
4601 * such a number that hashes out to the same list number; you were
4602 * expecting that, right?); so each list has a set of ports, with a
4603 * link to the socket (struct sock) that uses it, the port number and
4604 * a fastreuse flag (FIXME: NPI ipg).
4606 static struct sctp_bind_bucket
*sctp_bucket_create(
4607 struct sctp_bind_hashbucket
*head
, unsigned short snum
);
4609 static long sctp_get_port_local(struct sock
*sk
, union sctp_addr
*addr
)
4611 struct sctp_bind_hashbucket
*head
; /* hash list */
4612 struct sctp_bind_bucket
*pp
; /* hash list port iterator */
4613 unsigned short snum
;
4616 snum
= ntohs(addr
->v4
.sin_port
);
4618 SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum
);
4619 sctp_local_bh_disable();
4622 /* Search for an available port.
4624 * 'sctp_port_rover' was the last port assigned, so
4625 * we start to search from 'sctp_port_rover +
4626 * 1'. What we do is first check if port 'rover' is
4627 * already in the hash table; if not, we use that; if
4628 * it is, we try next.
4630 int low
= sysctl_local_port_range
[0];
4631 int high
= sysctl_local_port_range
[1];
4632 int remaining
= (high
- low
) + 1;
4636 sctp_spin_lock(&sctp_port_alloc_lock
);
4637 rover
= sctp_port_rover
;
4640 if ((rover
< low
) || (rover
> high
))
4642 index
= sctp_phashfn(rover
);
4643 head
= &sctp_port_hashtable
[index
];
4644 sctp_spin_lock(&head
->lock
);
4645 for (pp
= head
->chain
; pp
; pp
= pp
->next
)
4646 if (pp
->port
== rover
)
4650 sctp_spin_unlock(&head
->lock
);
4651 } while (--remaining
> 0);
4652 sctp_port_rover
= rover
;
4653 sctp_spin_unlock(&sctp_port_alloc_lock
);
4655 /* Exhausted local port range during search? */
4660 /* OK, here is the one we will use. HEAD (the port
4661 * hash table list entry) is non-NULL and we hold it's
4666 /* We are given an specific port number; we verify
4667 * that it is not being used. If it is used, we will
4668 * exahust the search in the hash list corresponding
4669 * to the port number (snum) - we detect that with the
4670 * port iterator, pp being NULL.
4672 head
= &sctp_port_hashtable
[sctp_phashfn(snum
)];
4673 sctp_spin_lock(&head
->lock
);
4674 for (pp
= head
->chain
; pp
; pp
= pp
->next
) {
4675 if (pp
->port
== snum
)
4682 if (!hlist_empty(&pp
->owner
)) {
4683 /* We had a port hash table hit - there is an
4684 * available port (pp != NULL) and it is being
4685 * used by other socket (pp->owner not empty); that other
4686 * socket is going to be sk2.
4688 int reuse
= sk
->sk_reuse
;
4690 struct hlist_node
*node
;
4692 SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");
4693 if (pp
->fastreuse
&& sk
->sk_reuse
)
4696 /* Run through the list of sockets bound to the port
4697 * (pp->port) [via the pointers bind_next and
4698 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
4699 * we get the endpoint they describe and run through
4700 * the endpoint's list of IP (v4 or v6) addresses,
4701 * comparing each of the addresses with the address of
4702 * the socket sk. If we find a match, then that means
4703 * that this port/socket (sk) combination are already
4706 sk_for_each_bound(sk2
, node
, &pp
->owner
) {
4707 struct sctp_endpoint
*ep2
;
4708 ep2
= sctp_sk(sk2
)->ep
;
4710 if (reuse
&& sk2
->sk_reuse
)
4713 if (sctp_bind_addr_match(&ep2
->base
.bind_addr
, addr
,
4719 SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n");
4722 /* If there was a hash table miss, create a new port. */
4724 if (!pp
&& !(pp
= sctp_bucket_create(head
, snum
)))
4727 /* In either case (hit or miss), make sure fastreuse is 1 only
4728 * if sk->sk_reuse is too (that is, if the caller requested
4729 * SO_REUSEADDR on this socket -sk-).
4731 if (hlist_empty(&pp
->owner
))
4732 pp
->fastreuse
= sk
->sk_reuse
? 1 : 0;
4733 else if (pp
->fastreuse
&& !sk
->sk_reuse
)
4736 /* We are set, so fill up all the data in the hash table
4737 * entry, tie the socket list information with the rest of the
4738 * sockets FIXME: Blurry, NPI (ipg).
4741 inet_sk(sk
)->num
= snum
;
4742 if (!sctp_sk(sk
)->bind_hash
) {
4743 sk_add_bind_node(sk
, &pp
->owner
);
4744 sctp_sk(sk
)->bind_hash
= pp
;
4749 sctp_spin_unlock(&head
->lock
);
4752 sctp_local_bh_enable();
4756 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
4757 * port is requested.
4759 static int sctp_get_port(struct sock
*sk
, unsigned short snum
)
4762 union sctp_addr addr
;
4763 struct sctp_af
*af
= sctp_sk(sk
)->pf
->af
;
4765 /* Set up a dummy address struct from the sk. */
4766 af
->from_sk(&addr
, sk
);
4767 addr
.v4
.sin_port
= htons(snum
);
4769 /* Note: sk->sk_num gets filled in if ephemeral port request. */
4770 ret
= sctp_get_port_local(sk
, &addr
);
4772 return (ret
? 1 : 0);
4776 * 3.1.3 listen() - UDP Style Syntax
4778 * By default, new associations are not accepted for UDP style sockets.
4779 * An application uses listen() to mark a socket as being able to
4780 * accept new associations.
4782 SCTP_STATIC
int sctp_seqpacket_listen(struct sock
*sk
, int backlog
)
4784 struct sctp_sock
*sp
= sctp_sk(sk
);
4785 struct sctp_endpoint
*ep
= sp
->ep
;
4787 /* Only UDP style sockets that are not peeled off are allowed to
4790 if (!sctp_style(sk
, UDP
))
4793 /* If backlog is zero, disable listening. */
4795 if (sctp_sstate(sk
, CLOSED
))
4798 sctp_unhash_endpoint(ep
);
4799 sk
->sk_state
= SCTP_SS_CLOSED
;
4802 /* Return if we are already listening. */
4803 if (sctp_sstate(sk
, LISTENING
))
4807 * If a bind() or sctp_bindx() is not called prior to a listen()
4808 * call that allows new associations to be accepted, the system
4809 * picks an ephemeral port and will choose an address set equivalent
4810 * to binding with a wildcard address.
4812 * This is not currently spelled out in the SCTP sockets
4813 * extensions draft, but follows the practice as seen in TCP
4816 if (!ep
->base
.bind_addr
.port
) {
4817 if (sctp_autobind(sk
))
4820 sk
->sk_state
= SCTP_SS_LISTENING
;
4821 sctp_hash_endpoint(ep
);
4826 * 4.1.3 listen() - TCP Style Syntax
4828 * Applications uses listen() to ready the SCTP endpoint for accepting
4829 * inbound associations.
4831 SCTP_STATIC
int sctp_stream_listen(struct sock
*sk
, int backlog
)
4833 struct sctp_sock
*sp
= sctp_sk(sk
);
4834 struct sctp_endpoint
*ep
= sp
->ep
;
4836 /* If backlog is zero, disable listening. */
4838 if (sctp_sstate(sk
, CLOSED
))
4841 sctp_unhash_endpoint(ep
);
4842 sk
->sk_state
= SCTP_SS_CLOSED
;
4845 if (sctp_sstate(sk
, LISTENING
))
4849 * If a bind() or sctp_bindx() is not called prior to a listen()
4850 * call that allows new associations to be accepted, the system
4851 * picks an ephemeral port and will choose an address set equivalent
4852 * to binding with a wildcard address.
4854 * This is not currently spelled out in the SCTP sockets
4855 * extensions draft, but follows the practice as seen in TCP
4858 if (!ep
->base
.bind_addr
.port
) {
4859 if (sctp_autobind(sk
))
4862 sk
->sk_state
= SCTP_SS_LISTENING
;
4863 sk
->sk_max_ack_backlog
= backlog
;
4864 sctp_hash_endpoint(ep
);
4869 * Move a socket to LISTENING state.
4871 int sctp_inet_listen(struct socket
*sock
, int backlog
)
4873 struct sock
*sk
= sock
->sk
;
4874 struct crypto_hash
*tfm
= NULL
;
4877 if (unlikely(backlog
< 0))
4882 if (sock
->state
!= SS_UNCONNECTED
)
4885 /* Allocate HMAC for generating cookie. */
4886 if (sctp_hmac_alg
) {
4887 tfm
= crypto_alloc_hash(sctp_hmac_alg
, 0, CRYPTO_ALG_ASYNC
);
4894 switch (sock
->type
) {
4895 case SOCK_SEQPACKET
:
4896 err
= sctp_seqpacket_listen(sk
, backlog
);
4899 err
= sctp_stream_listen(sk
, backlog
);
4907 /* Store away the transform reference. */
4908 sctp_sk(sk
)->hmac
= tfm
;
4910 sctp_release_sock(sk
);
4913 crypto_free_hash(tfm
);
4918 * This function is done by modeling the current datagram_poll() and the
4919 * tcp_poll(). Note that, based on these implementations, we don't
4920 * lock the socket in this function, even though it seems that,
4921 * ideally, locking or some other mechanisms can be used to ensure
4922 * the integrity of the counters (sndbuf and wmem_alloc) used
4923 * in this place. We assume that we don't need locks either until proven
4926 * Another thing to note is that we include the Async I/O support
4927 * here, again, by modeling the current TCP/UDP code. We don't have
4928 * a good way to test with it yet.
4930 unsigned int sctp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
4932 struct sock
*sk
= sock
->sk
;
4933 struct sctp_sock
*sp
= sctp_sk(sk
);
4936 poll_wait(file
, sk
->sk_sleep
, wait
);
4938 /* A TCP-style listening socket becomes readable when the accept queue
4941 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
4942 return (!list_empty(&sp
->ep
->asocs
)) ?
4943 (POLLIN
| POLLRDNORM
) : 0;
4947 /* Is there any exceptional events? */
4948 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
4950 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
4952 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
4955 /* Is it readable? Reconsider this code with TCP-style support. */
4956 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
4957 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
4958 mask
|= POLLIN
| POLLRDNORM
;
4960 /* The association is either gone or not ready. */
4961 if (!sctp_style(sk
, UDP
) && sctp_sstate(sk
, CLOSED
))
4964 /* Is it writable? */
4965 if (sctp_writeable(sk
)) {
4966 mask
|= POLLOUT
| POLLWRNORM
;
4968 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
4970 * Since the socket is not locked, the buffer
4971 * might be made available after the writeable check and
4972 * before the bit is set. This could cause a lost I/O
4973 * signal. tcp_poll() has a race breaker for this race
4974 * condition. Based on their implementation, we put
4975 * in the following code to cover it as well.
4977 if (sctp_writeable(sk
))
4978 mask
|= POLLOUT
| POLLWRNORM
;
4983 /********************************************************************
4984 * 2nd Level Abstractions
4985 ********************************************************************/
4987 static struct sctp_bind_bucket
*sctp_bucket_create(
4988 struct sctp_bind_hashbucket
*head
, unsigned short snum
)
4990 struct sctp_bind_bucket
*pp
;
4992 pp
= kmem_cache_alloc(sctp_bucket_cachep
, GFP_ATOMIC
);
4993 SCTP_DBG_OBJCNT_INC(bind_bucket
);
4997 INIT_HLIST_HEAD(&pp
->owner
);
4998 if ((pp
->next
= head
->chain
) != NULL
)
4999 pp
->next
->pprev
= &pp
->next
;
5001 pp
->pprev
= &head
->chain
;
5006 /* Caller must hold hashbucket lock for this tb with local BH disabled */
5007 static void sctp_bucket_destroy(struct sctp_bind_bucket
*pp
)
5009 if (pp
&& hlist_empty(&pp
->owner
)) {
5011 pp
->next
->pprev
= pp
->pprev
;
5012 *(pp
->pprev
) = pp
->next
;
5013 kmem_cache_free(sctp_bucket_cachep
, pp
);
5014 SCTP_DBG_OBJCNT_DEC(bind_bucket
);
5018 /* Release this socket's reference to a local port. */
5019 static inline void __sctp_put_port(struct sock
*sk
)
5021 struct sctp_bind_hashbucket
*head
=
5022 &sctp_port_hashtable
[sctp_phashfn(inet_sk(sk
)->num
)];
5023 struct sctp_bind_bucket
*pp
;
5025 sctp_spin_lock(&head
->lock
);
5026 pp
= sctp_sk(sk
)->bind_hash
;
5027 __sk_del_bind_node(sk
);
5028 sctp_sk(sk
)->bind_hash
= NULL
;
5029 inet_sk(sk
)->num
= 0;
5030 sctp_bucket_destroy(pp
);
5031 sctp_spin_unlock(&head
->lock
);
5034 void sctp_put_port(struct sock
*sk
)
5036 sctp_local_bh_disable();
5037 __sctp_put_port(sk
);
5038 sctp_local_bh_enable();
5042 * The system picks an ephemeral port and choose an address set equivalent
5043 * to binding with a wildcard address.
5044 * One of those addresses will be the primary address for the association.
5045 * This automatically enables the multihoming capability of SCTP.
5047 static int sctp_autobind(struct sock
*sk
)
5049 union sctp_addr autoaddr
;
5053 /* Initialize a local sockaddr structure to INADDR_ANY. */
5054 af
= sctp_sk(sk
)->pf
->af
;
5056 port
= htons(inet_sk(sk
)->num
);
5057 af
->inaddr_any(&autoaddr
, port
);
5059 return sctp_do_bind(sk
, &autoaddr
, af
->sockaddr_len
);
5062 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
5065 * 4.2 The cmsghdr Structure *
5067 * When ancillary data is sent or received, any number of ancillary data
5068 * objects can be specified by the msg_control and msg_controllen members of
5069 * the msghdr structure, because each object is preceded by
5070 * a cmsghdr structure defining the object's length (the cmsg_len member).
5071 * Historically Berkeley-derived implementations have passed only one object
5072 * at a time, but this API allows multiple objects to be
5073 * passed in a single call to sendmsg() or recvmsg(). The following example
5074 * shows two ancillary data objects in a control buffer.
5076 * |<--------------------------- msg_controllen -------------------------->|
5079 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
5081 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
5084 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
5086 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
5089 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5090 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
5092 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
5094 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5101 SCTP_STATIC
int sctp_msghdr_parse(const struct msghdr
*msg
,
5102 sctp_cmsgs_t
*cmsgs
)
5104 struct cmsghdr
*cmsg
;
5106 for (cmsg
= CMSG_FIRSTHDR(msg
);
5108 cmsg
= CMSG_NXTHDR((struct msghdr
*)msg
, cmsg
)) {
5109 if (!CMSG_OK(msg
, cmsg
))
5112 /* Should we parse this header or ignore? */
5113 if (cmsg
->cmsg_level
!= IPPROTO_SCTP
)
5116 /* Strictly check lengths following example in SCM code. */
5117 switch (cmsg
->cmsg_type
) {
5119 /* SCTP Socket API Extension
5120 * 5.2.1 SCTP Initiation Structure (SCTP_INIT)
5122 * This cmsghdr structure provides information for
5123 * initializing new SCTP associations with sendmsg().
5124 * The SCTP_INITMSG socket option uses this same data
5125 * structure. This structure is not used for
5128 * cmsg_level cmsg_type cmsg_data[]
5129 * ------------ ------------ ----------------------
5130 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
5132 if (cmsg
->cmsg_len
!=
5133 CMSG_LEN(sizeof(struct sctp_initmsg
)))
5135 cmsgs
->init
= (struct sctp_initmsg
*)CMSG_DATA(cmsg
);
5139 /* SCTP Socket API Extension
5140 * 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV)
5142 * This cmsghdr structure specifies SCTP options for
5143 * sendmsg() and describes SCTP header information
5144 * about a received message through recvmsg().
5146 * cmsg_level cmsg_type cmsg_data[]
5147 * ------------ ------------ ----------------------
5148 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
5150 if (cmsg
->cmsg_len
!=
5151 CMSG_LEN(sizeof(struct sctp_sndrcvinfo
)))
5155 (struct sctp_sndrcvinfo
*)CMSG_DATA(cmsg
);
5157 /* Minimally, validate the sinfo_flags. */
5158 if (cmsgs
->info
->sinfo_flags
&
5159 ~(SCTP_UNORDERED
| SCTP_ADDR_OVER
|
5160 SCTP_ABORT
| SCTP_EOF
))
5172 * Wait for a packet..
5173 * Note: This function is the same function as in core/datagram.c
5174 * with a few modifications to make lksctp work.
5176 static int sctp_wait_for_packet(struct sock
* sk
, int *err
, long *timeo_p
)
5181 prepare_to_wait_exclusive(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
5183 /* Socket errors? */
5184 error
= sock_error(sk
);
5188 if (!skb_queue_empty(&sk
->sk_receive_queue
))
5191 /* Socket shut down? */
5192 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
5195 /* Sequenced packets can come disconnected. If so we report the
5200 /* Is there a good reason to think that we may receive some data? */
5201 if (list_empty(&sctp_sk(sk
)->ep
->asocs
) && !sctp_sstate(sk
, LISTENING
))
5204 /* Handle signals. */
5205 if (signal_pending(current
))
5208 /* Let another process have a go. Since we are going to sleep
5209 * anyway. Note: This may cause odd behaviors if the message
5210 * does not fit in the user's buffer, but this seems to be the
5211 * only way to honor MSG_DONTWAIT realistically.
5213 sctp_release_sock(sk
);
5214 *timeo_p
= schedule_timeout(*timeo_p
);
5218 finish_wait(sk
->sk_sleep
, &wait
);
5222 error
= sock_intr_errno(*timeo_p
);
5225 finish_wait(sk
->sk_sleep
, &wait
);
5230 /* Receive a datagram.
5231 * Note: This is pretty much the same routine as in core/datagram.c
5232 * with a few changes to make lksctp work.
5234 static struct sk_buff
*sctp_skb_recv_datagram(struct sock
*sk
, int flags
,
5235 int noblock
, int *err
)
5238 struct sk_buff
*skb
;
5241 timeo
= sock_rcvtimeo(sk
, noblock
);
5243 SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n",
5244 timeo
, MAX_SCHEDULE_TIMEOUT
);
5247 /* Again only user level code calls this function,
5248 * so nothing interrupt level
5249 * will suddenly eat the receive_queue.
5251 * Look at current nfs client by the way...
5252 * However, this function was corrent in any case. 8)
5254 if (flags
& MSG_PEEK
) {
5255 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
5256 skb
= skb_peek(&sk
->sk_receive_queue
);
5258 atomic_inc(&skb
->users
);
5259 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
5261 skb
= skb_dequeue(&sk
->sk_receive_queue
);
5267 /* Caller is allowed not to check sk->sk_err before calling. */
5268 error
= sock_error(sk
);
5272 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
5275 /* User doesn't want to wait. */
5279 } while (sctp_wait_for_packet(sk
, err
, &timeo
) == 0);
5288 /* If sndbuf has changed, wake up per association sndbuf waiters. */
5289 static void __sctp_write_space(struct sctp_association
*asoc
)
5291 struct sock
*sk
= asoc
->base
.sk
;
5292 struct socket
*sock
= sk
->sk_socket
;
5294 if ((sctp_wspace(asoc
) > 0) && sock
) {
5295 if (waitqueue_active(&asoc
->wait
))
5296 wake_up_interruptible(&asoc
->wait
);
5298 if (sctp_writeable(sk
)) {
5299 if (sk
->sk_sleep
&& waitqueue_active(sk
->sk_sleep
))
5300 wake_up_interruptible(sk
->sk_sleep
);
5302 /* Note that we try to include the Async I/O support
5303 * here by modeling from the current TCP/UDP code.
5304 * We have not tested with it yet.
5306 if (sock
->fasync_list
&&
5307 !(sk
->sk_shutdown
& SEND_SHUTDOWN
))
5308 sock_wake_async(sock
, 2, POLL_OUT
);
5313 /* Do accounting for the sndbuf space.
5314 * Decrement the used sndbuf space of the corresponding association by the
5315 * data size which was just transmitted(freed).
5317 static void sctp_wfree(struct sk_buff
*skb
)
5319 struct sctp_association
*asoc
;
5320 struct sctp_chunk
*chunk
;
5323 /* Get the saved chunk pointer. */
5324 chunk
= *((struct sctp_chunk
**)(skb
->cb
));
5327 asoc
->sndbuf_used
-= SCTP_DATA_SNDSIZE(chunk
) +
5328 sizeof(struct sk_buff
) +
5329 sizeof(struct sctp_chunk
);
5331 atomic_sub(sizeof(struct sctp_chunk
), &sk
->sk_wmem_alloc
);
5334 __sctp_write_space(asoc
);
5336 sctp_association_put(asoc
);
5339 /* Do accounting for the receive space on the socket.
5340 * Accounting for the association is done in ulpevent.c
5341 * We set this as a destructor for the cloned data skbs so that
5342 * accounting is done at the correct time.
5344 void sctp_sock_rfree(struct sk_buff
*skb
)
5346 struct sock
*sk
= skb
->sk
;
5347 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
5349 atomic_sub(event
->rmem_len
, &sk
->sk_rmem_alloc
);
5353 /* Helper function to wait for space in the sndbuf. */
5354 static int sctp_wait_for_sndbuf(struct sctp_association
*asoc
, long *timeo_p
,
5357 struct sock
*sk
= asoc
->base
.sk
;
5359 long current_timeo
= *timeo_p
;
5362 SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n",
5363 asoc
, (long)(*timeo_p
), msg_len
);
5365 /* Increment the association's refcnt. */
5366 sctp_association_hold(asoc
);
5368 /* Wait on the association specific sndbuf space. */
5370 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
5371 TASK_INTERRUPTIBLE
);
5374 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
||
5377 if (signal_pending(current
))
5378 goto do_interrupted
;
5379 if (msg_len
<= sctp_wspace(asoc
))
5382 /* Let another process have a go. Since we are going
5385 sctp_release_sock(sk
);
5386 current_timeo
= schedule_timeout(current_timeo
);
5387 BUG_ON(sk
!= asoc
->base
.sk
);
5390 *timeo_p
= current_timeo
;
5394 finish_wait(&asoc
->wait
, &wait
);
5396 /* Release the association's refcnt. */
5397 sctp_association_put(asoc
);
5406 err
= sock_intr_errno(*timeo_p
);
5414 /* If socket sndbuf has changed, wake up all per association waiters. */
5415 void sctp_write_space(struct sock
*sk
)
5417 struct sctp_association
*asoc
;
5418 struct list_head
*pos
;
5420 /* Wake up the tasks in each wait queue. */
5421 list_for_each(pos
, &((sctp_sk(sk
))->ep
->asocs
)) {
5422 asoc
= list_entry(pos
, struct sctp_association
, asocs
);
5423 __sctp_write_space(asoc
);
5427 /* Is there any sndbuf space available on the socket?
5429 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
5430 * associations on the same socket. For a UDP-style socket with
5431 * multiple associations, it is possible for it to be "unwriteable"
5432 * prematurely. I assume that this is acceptable because
5433 * a premature "unwriteable" is better than an accidental "writeable" which
5434 * would cause an unwanted block under certain circumstances. For the 1-1
5435 * UDP-style sockets or TCP-style sockets, this code should work.
5438 static int sctp_writeable(struct sock
*sk
)
5442 amt
= sk
->sk_sndbuf
- atomic_read(&sk
->sk_wmem_alloc
);
5448 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
5449 * returns immediately with EINPROGRESS.
5451 static int sctp_wait_for_connect(struct sctp_association
*asoc
, long *timeo_p
)
5453 struct sock
*sk
= asoc
->base
.sk
;
5455 long current_timeo
= *timeo_p
;
5458 SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __FUNCTION__
, asoc
,
5461 /* Increment the association's refcnt. */
5462 sctp_association_hold(asoc
);
5465 prepare_to_wait_exclusive(&asoc
->wait
, &wait
,
5466 TASK_INTERRUPTIBLE
);
5469 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
5471 if (sk
->sk_err
|| asoc
->state
>= SCTP_STATE_SHUTDOWN_PENDING
||
5474 if (signal_pending(current
))
5475 goto do_interrupted
;
5477 if (sctp_state(asoc
, ESTABLISHED
))
5480 /* Let another process have a go. Since we are going
5483 sctp_release_sock(sk
);
5484 current_timeo
= schedule_timeout(current_timeo
);
5487 *timeo_p
= current_timeo
;
5491 finish_wait(&asoc
->wait
, &wait
);
5493 /* Release the association's refcnt. */
5494 sctp_association_put(asoc
);
5499 if (asoc
->init_err_counter
+ 1 > asoc
->max_init_attempts
)
5502 err
= -ECONNREFUSED
;
5506 err
= sock_intr_errno(*timeo_p
);
5514 static int sctp_wait_for_accept(struct sock
*sk
, long timeo
)
5516 struct sctp_endpoint
*ep
;
5520 ep
= sctp_sk(sk
)->ep
;
5524 prepare_to_wait_exclusive(sk
->sk_sleep
, &wait
,
5525 TASK_INTERRUPTIBLE
);
5527 if (list_empty(&ep
->asocs
)) {
5528 sctp_release_sock(sk
);
5529 timeo
= schedule_timeout(timeo
);
5534 if (!sctp_sstate(sk
, LISTENING
))
5538 if (!list_empty(&ep
->asocs
))
5541 err
= sock_intr_errno(timeo
);
5542 if (signal_pending(current
))
5550 finish_wait(sk
->sk_sleep
, &wait
);
5555 void sctp_wait_for_close(struct sock
*sk
, long timeout
)
5560 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
5561 if (list_empty(&sctp_sk(sk
)->ep
->asocs
))
5563 sctp_release_sock(sk
);
5564 timeout
= schedule_timeout(timeout
);
5566 } while (!signal_pending(current
) && timeout
);
5568 finish_wait(sk
->sk_sleep
, &wait
);
5571 /* Populate the fields of the newsk from the oldsk and migrate the assoc
5572 * and its messages to the newsk.
5574 static void sctp_sock_migrate(struct sock
*oldsk
, struct sock
*newsk
,
5575 struct sctp_association
*assoc
,
5576 sctp_socket_type_t type
)
5578 struct sctp_sock
*oldsp
= sctp_sk(oldsk
);
5579 struct sctp_sock
*newsp
= sctp_sk(newsk
);
5580 struct sctp_bind_bucket
*pp
; /* hash list port iterator */
5581 struct sctp_endpoint
*newep
= newsp
->ep
;
5582 struct sk_buff
*skb
, *tmp
;
5583 struct sctp_ulpevent
*event
;
5586 /* Migrate socket buffer sizes and all the socket level options to the
5589 newsk
->sk_sndbuf
= oldsk
->sk_sndbuf
;
5590 newsk
->sk_rcvbuf
= oldsk
->sk_rcvbuf
;
5591 /* Brute force copy old sctp opt. */
5592 inet_sk_copy_descendant(newsk
, oldsk
);
5594 /* Restore the ep value that was overwritten with the above structure
5600 /* Hook this new socket in to the bind_hash list. */
5601 pp
= sctp_sk(oldsk
)->bind_hash
;
5602 sk_add_bind_node(newsk
, &pp
->owner
);
5603 sctp_sk(newsk
)->bind_hash
= pp
;
5604 inet_sk(newsk
)->num
= inet_sk(oldsk
)->num
;
5606 /* Copy the bind_addr list from the original endpoint to the new
5607 * endpoint so that we can handle restarts properly
5609 if (PF_INET6
== assoc
->base
.sk
->sk_family
)
5610 flags
= SCTP_ADDR6_ALLOWED
;
5611 if (assoc
->peer
.ipv4_address
)
5612 flags
|= SCTP_ADDR4_PEERSUPP
;
5613 if (assoc
->peer
.ipv6_address
)
5614 flags
|= SCTP_ADDR6_PEERSUPP
;
5615 sctp_bind_addr_copy(&newsp
->ep
->base
.bind_addr
,
5616 &oldsp
->ep
->base
.bind_addr
,
5617 SCTP_SCOPE_GLOBAL
, GFP_KERNEL
, flags
);
5619 /* Move any messages in the old socket's receive queue that are for the
5620 * peeled off association to the new socket's receive queue.
5622 sctp_skb_for_each(skb
, &oldsk
->sk_receive_queue
, tmp
) {
5623 event
= sctp_skb2event(skb
);
5624 if (event
->asoc
== assoc
) {
5625 sctp_sock_rfree(skb
);
5626 __skb_unlink(skb
, &oldsk
->sk_receive_queue
);
5627 __skb_queue_tail(&newsk
->sk_receive_queue
, skb
);
5628 sctp_skb_set_owner_r(skb
, newsk
);
5632 /* Clean up any messages pending delivery due to partial
5633 * delivery. Three cases:
5634 * 1) No partial deliver; no work.
5635 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
5636 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
5638 skb_queue_head_init(&newsp
->pd_lobby
);
5639 sctp_sk(newsk
)->pd_mode
= assoc
->ulpq
.pd_mode
;
5641 if (sctp_sk(oldsk
)->pd_mode
) {
5642 struct sk_buff_head
*queue
;
5644 /* Decide which queue to move pd_lobby skbs to. */
5645 if (assoc
->ulpq
.pd_mode
) {
5646 queue
= &newsp
->pd_lobby
;
5648 queue
= &newsk
->sk_receive_queue
;
5650 /* Walk through the pd_lobby, looking for skbs that
5651 * need moved to the new socket.
5653 sctp_skb_for_each(skb
, &oldsp
->pd_lobby
, tmp
) {
5654 event
= sctp_skb2event(skb
);
5655 if (event
->asoc
== assoc
) {
5656 sctp_sock_rfree(skb
);
5657 __skb_unlink(skb
, &oldsp
->pd_lobby
);
5658 __skb_queue_tail(queue
, skb
);
5659 sctp_skb_set_owner_r(skb
, newsk
);
5663 /* Clear up any skbs waiting for the partial
5664 * delivery to finish.
5666 if (assoc
->ulpq
.pd_mode
)
5667 sctp_clear_pd(oldsk
);
5671 /* Set the type of socket to indicate that it is peeled off from the
5672 * original UDP-style socket or created with the accept() call on a
5673 * TCP-style socket..
5677 /* Mark the new socket "in-use" by the user so that any packets
5678 * that may arrive on the association after we've moved it are
5679 * queued to the backlog. This prevents a potential race between
5680 * backlog processing on the old socket and new-packet processing
5681 * on the new socket.
5683 sctp_lock_sock(newsk
);
5684 sctp_assoc_migrate(assoc
, newsk
);
5686 /* If the association on the newsk is already closed before accept()
5687 * is called, set RCV_SHUTDOWN flag.
5689 if (sctp_state(assoc
, CLOSED
) && sctp_style(newsk
, TCP
))
5690 newsk
->sk_shutdown
|= RCV_SHUTDOWN
;
5692 newsk
->sk_state
= SCTP_SS_ESTABLISHED
;
5693 sctp_release_sock(newsk
);
5696 /* This proto struct describes the ULP interface for SCTP. */
5697 struct proto sctp_prot
= {
5699 .owner
= THIS_MODULE
,
5700 .close
= sctp_close
,
5701 .connect
= sctp_connect
,
5702 .disconnect
= sctp_disconnect
,
5703 .accept
= sctp_accept
,
5704 .ioctl
= sctp_ioctl
,
5705 .init
= sctp_init_sock
,
5706 .destroy
= sctp_destroy_sock
,
5707 .shutdown
= sctp_shutdown
,
5708 .setsockopt
= sctp_setsockopt
,
5709 .getsockopt
= sctp_getsockopt
,
5710 .sendmsg
= sctp_sendmsg
,
5711 .recvmsg
= sctp_recvmsg
,
5713 .backlog_rcv
= sctp_backlog_rcv
,
5715 .unhash
= sctp_unhash
,
5716 .get_port
= sctp_get_port
,
5717 .obj_size
= sizeof(struct sctp_sock
),
5720 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5721 struct proto sctpv6_prot
= {
5723 .owner
= THIS_MODULE
,
5724 .close
= sctp_close
,
5725 .connect
= sctp_connect
,
5726 .disconnect
= sctp_disconnect
,
5727 .accept
= sctp_accept
,
5728 .ioctl
= sctp_ioctl
,
5729 .init
= sctp_init_sock
,
5730 .destroy
= sctp_destroy_sock
,
5731 .shutdown
= sctp_shutdown
,
5732 .setsockopt
= sctp_setsockopt
,
5733 .getsockopt
= sctp_getsockopt
,
5734 .sendmsg
= sctp_sendmsg
,
5735 .recvmsg
= sctp_recvmsg
,
5737 .backlog_rcv
= sctp_backlog_rcv
,
5739 .unhash
= sctp_unhash
,
5740 .get_port
= sctp_get_port
,
5741 .obj_size
= sizeof(struct sctp6_sock
),
5743 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */