blob: ca44917872d2553b98f4e2f3601f95fe0f2c414f [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999-2000 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
5 * Copyright (c) 2001-2003 Intel Corp.
6 * Copyright (c) 2001-2002 Nokia, Inc.
7 * Copyright (c) 2001 La Monte H.P. Yarroll
8 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05009 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * These functions interface with the sockets layer to implement the
12 * SCTP Extensions for the Sockets API.
13 *
14 * Note that the descriptions from the specification are USER level
15 * functions--this file is the functions which populate the struct proto
16 * for SCTP which is the BOTTOM of the sockets interface.
17 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050018 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * you can redistribute it and/or modify it under the terms of
20 * the GNU General Public License as published by
21 * the Free Software Foundation; either version 2, or (at your option)
22 * any later version.
23 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050024 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
26 * ************************
27 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
28 * See the GNU General Public License for more details.
29 *
30 * You should have received a copy of the GNU General Public License
31 * along with GNU CC; see the file COPYING. If not, write to
32 * the Free Software Foundation, 59 Temple Place - Suite 330,
33 * Boston, MA 02111-1307, USA.
34 *
35 * Please send any bug reports or fixes you make to the
36 * email address(es):
37 * lksctp developers <lksctp-developers@lists.sourceforge.net>
38 *
39 * Or submit a bug report through the following website:
40 * http://www.sf.net/projects/lksctp
41 *
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>
55 *
56 * Any bugs reported given to us we will try to fix... any fixes shared will
57 * be incorporated into the next SCTP release.
58 */
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <linux/types.h>
61#include <linux/kernel.h>
62#include <linux/wait.h>
63#include <linux/time.h>
64#include <linux/ip.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080065#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <linux/fcntl.h>
67#include <linux/poll.h>
68#include <linux/init.h>
69#include <linux/crypto.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090070#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72#include <net/ip.h>
73#include <net/icmp.h>
74#include <net/route.h>
75#include <net/ipv6.h>
76#include <net/inet_common.h>
77
78#include <linux/socket.h> /* for sa_family_t */
79#include <net/sock.h>
80#include <net/sctp/sctp.h>
81#include <net/sctp/sm.h>
82
83/* WARNING: Please do not remove the SCTP_STATIC attribute to
84 * any of the functions below as they are used to export functions
85 * used by a project regression testsuite.
86 */
87
88/* Forward declarations for internal helper functions. */
89static int sctp_writeable(struct sock *sk);
90static void sctp_wfree(struct sk_buff *skb);
91static int sctp_wait_for_sndbuf(struct sctp_association *, long *timeo_p,
92 size_t msg_len);
93static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p);
94static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
95static int sctp_wait_for_accept(struct sock *sk, long timeo);
96static void sctp_wait_for_close(struct sock *sk, long timeo);
97static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
98 union sctp_addr *addr, int len);
99static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
100static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
101static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
102static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
103static int sctp_send_asconf(struct sctp_association *asoc,
104 struct sctp_chunk *chunk);
105static int sctp_do_bind(struct sock *, union sctp_addr *, int);
106static int sctp_autobind(struct sock *sk);
107static void sctp_sock_migrate(struct sock *, struct sock *,
108 struct sctp_association *, sctp_socket_type_t);
109static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG;
110
Neil Horman4d93df02007-08-15 16:07:44 -0700111extern struct kmem_cache *sctp_bucket_cachep;
112extern int sysctl_sctp_mem[3];
113extern int sysctl_sctp_rmem[3];
114extern int sysctl_sctp_wmem[3];
115
Adrian Bunkb6fa1a42007-09-12 15:18:00 +0200116static int sctp_memory_pressure;
117static atomic_t sctp_memory_allocated;
Eric Dumazet17483762008-11-25 21:16:35 -0800118struct percpu_counter sctp_sockets_allocated;
Neil Horman4d93df02007-08-15 16:07:44 -0700119
Pavel Emelyanov5c52ba12008-07-16 20:28:10 -0700120static void sctp_enter_memory_pressure(struct sock *sk)
Neil Horman4d93df02007-08-15 16:07:44 -0700121{
122 sctp_memory_pressure = 1;
123}
124
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126/* Get the sndbuf space available at the time on the association. */
127static inline int sctp_wspace(struct sctp_association *asoc)
128{
Neil Horman4d93df02007-08-15 16:07:44 -0700129 int amt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Neil Horman4d93df02007-08-15 16:07:44 -0700131 if (asoc->ep->sndbuf_policy)
132 amt = asoc->sndbuf_used;
133 else
Eric Dumazet31e6d362009-06-17 19:05:41 -0700134 amt = sk_wmem_alloc_get(asoc->base.sk);
Neil Horman4d93df02007-08-15 16:07:44 -0700135
136 if (amt >= asoc->base.sk->sk_sndbuf) {
137 if (asoc->base.sk->sk_userlocks & SOCK_SNDBUF_LOCK)
138 amt = 0;
139 else {
140 amt = sk_stream_wspace(asoc->base.sk);
141 if (amt < 0)
142 amt = 0;
143 }
Neil Horman4eb701d2005-04-28 12:02:04 -0700144 } else {
Neil Horman4d93df02007-08-15 16:07:44 -0700145 amt = asoc->base.sk->sk_sndbuf - amt;
Neil Horman4eb701d2005-04-28 12:02:04 -0700146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 return amt;
148}
149
150/* Increment the used sndbuf space count of the corresponding association by
151 * the size of the outgoing data chunk.
152 * Also, set the skb destructor for sndbuf accounting later.
153 *
154 * Since it is always 1-1 between chunk and skb, and also a new skb is always
155 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
156 * destructor in the data chunk skb for the purpose of the sndbuf space
157 * tracking.
158 */
159static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
160{
161 struct sctp_association *asoc = chunk->asoc;
162 struct sock *sk = asoc->base.sk;
163
164 /* The sndbuf space is tracked per association. */
165 sctp_association_hold(asoc);
166
Neil Horman4eb701d2005-04-28 12:02:04 -0700167 skb_set_owner_w(chunk->skb, sk);
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 chunk->skb->destructor = sctp_wfree;
170 /* Save the chunk pointer in skb for sctp_wfree to use later. */
171 *((struct sctp_chunk **)(chunk->skb->cb)) = chunk;
172
Neil Horman4eb701d2005-04-28 12:02:04 -0700173 asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +
174 sizeof(struct sk_buff) +
175 sizeof(struct sctp_chunk);
176
Neil Horman4eb701d2005-04-28 12:02:04 -0700177 atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800178 sk->sk_wmem_queued += chunk->skb->truesize;
179 sk_mem_charge(sk, chunk->skb->truesize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180}
181
182/* Verify that this is a valid address. */
183static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
184 int len)
185{
186 struct sctp_af *af;
187
188 /* Verify basic sockaddr. */
189 af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
190 if (!af)
191 return -EINVAL;
192
193 /* Is this a valid SCTP address? */
Vlad Yasevich5636bef2006-06-17 22:55:35 -0700194 if (!af->addr_valid(addr, sctp_sk(sk), NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return -EINVAL;
196
197 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
198 return -EINVAL;
199
200 return 0;
201}
202
203/* Look up the association by its id. If this is not a UDP-style
204 * socket, the ID field is always ignored.
205 */
206struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
207{
208 struct sctp_association *asoc = NULL;
209
210 /* If this is not a UDP-style socket, assoc id should be ignored. */
211 if (!sctp_style(sk, UDP)) {
212 /* Return NULL if the socket state is not ESTABLISHED. It
213 * could be a TCP-style listening socket or a socket which
214 * hasn't yet called connect() to establish an association.
215 */
216 if (!sctp_sstate(sk, ESTABLISHED))
217 return NULL;
218
219 /* Get the first and the only association from the list. */
220 if (!list_empty(&sctp_sk(sk)->ep->asocs))
221 asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
222 struct sctp_association, asocs);
223 return asoc;
224 }
225
226 /* Otherwise this is a UDP-style socket. */
227 if (!id || (id == (sctp_assoc_t)-1))
228 return NULL;
229
230 spin_lock_bh(&sctp_assocs_id_lock);
231 asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
232 spin_unlock_bh(&sctp_assocs_id_lock);
233
234 if (!asoc || (asoc->base.sk != sk) || asoc->base.dead)
235 return NULL;
236
237 return asoc;
238}
239
240/* Look up the transport from an address and an assoc id. If both address and
241 * id are specified, the associations matching the address and the id should be
242 * the same.
243 */
244static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
245 struct sockaddr_storage *addr,
246 sctp_assoc_t id)
247{
248 struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
249 struct sctp_transport *transport;
250 union sctp_addr *laddr = (union sctp_addr *)addr;
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
Al Virocd4ff032006-11-20 17:11:33 -0800253 laddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 &transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 if (!addr_asoc)
257 return NULL;
258
259 id_asoc = sctp_id2assoc(sk, id);
260 if (id_asoc && (id_asoc != addr_asoc))
261 return NULL;
262
263 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
264 (union sctp_addr *)addr);
265
266 return transport;
267}
268
269/* API 3.1.2 bind() - UDP Style Syntax
270 * The syntax of bind() is,
271 *
272 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
273 *
274 * sd - the socket descriptor returned by socket().
275 * addr - the address structure (struct sockaddr_in or struct
276 * sockaddr_in6 [RFC 2553]),
277 * addr_len - the size of the address structure.
278 */
Frank Filz3f7a87d2005-06-20 13:14:57 -0700279SCTP_STATIC int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280{
281 int retval = 0;
282
283 sctp_lock_sock(sk);
284
Frank Filz3f7a87d2005-06-20 13:14:57 -0700285 SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n",
286 sk, addr, addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 /* Disallow binding twice. */
289 if (!sctp_sk(sk)->ep->base.bind_addr.port)
Frank Filz3f7a87d2005-06-20 13:14:57 -0700290 retval = sctp_do_bind(sk, (union sctp_addr *)addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 addr_len);
292 else
293 retval = -EINVAL;
294
295 sctp_release_sock(sk);
296
297 return retval;
298}
299
300static long sctp_get_port_local(struct sock *, union sctp_addr *);
301
302/* Verify this is a valid sockaddr. */
303static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
304 union sctp_addr *addr, int len)
305{
306 struct sctp_af *af;
307
308 /* Check minimum size. */
309 if (len < sizeof (struct sockaddr))
310 return NULL;
311
Vlad Yasevich7dab83d2008-07-18 23:05:40 -0700312 /* V4 mapped address are really of AF_INET family */
313 if (addr->sa.sa_family == AF_INET6 &&
314 ipv6_addr_v4mapped(&addr->v6.sin6_addr)) {
315 if (!opt->pf->af_supported(AF_INET, opt))
316 return NULL;
317 } else {
318 /* Does this PF support this AF? */
319 if (!opt->pf->af_supported(addr->sa.sa_family, opt))
320 return NULL;
321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 /* If we get this far, af is valid. */
324 af = sctp_get_af_specific(addr->sa.sa_family);
325
326 if (len < af->sockaddr_len)
327 return NULL;
328
329 return af;
330}
331
332/* Bind a local address either to an endpoint or to an association. */
333SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
334{
335 struct sctp_sock *sp = sctp_sk(sk);
336 struct sctp_endpoint *ep = sp->ep;
337 struct sctp_bind_addr *bp = &ep->base.bind_addr;
338 struct sctp_af *af;
339 unsigned short snum;
340 int ret = 0;
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 /* Common sockaddr verification. */
343 af = sctp_sockaddr_af(sp, addr, len);
Frank Filz3f7a87d2005-06-20 13:14:57 -0700344 if (!af) {
345 SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n",
346 sk, addr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return -EINVAL;
Frank Filz3f7a87d2005-06-20 13:14:57 -0700348 }
349
350 snum = ntohs(addr->v4.sin_port);
351
352 SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ",
353 ", port: %d, new port: %d, len: %d)\n",
354 sk,
355 addr,
356 bp->port, snum,
357 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
359 /* PF specific bind() address verification. */
360 if (!sp->pf->bind_verify(sp, addr))
361 return -EADDRNOTAVAIL;
362
Vlad Yasevich8b358052007-05-15 17:14:58 -0400363 /* We must either be unbound, or bind to the same port.
364 * It's OK to allow 0 ports if we are already bound.
365 * We'll just inhert an already bound port in this case
366 */
367 if (bp->port) {
368 if (!snum)
369 snum = bp->port;
370 else if (snum != bp->port) {
371 SCTP_DEBUG_PRINTK("sctp_do_bind:"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 " New port %d does not match existing port "
373 "%d.\n", snum, bp->port);
Vlad Yasevich8b358052007-05-15 17:14:58 -0400374 return -EINVAL;
375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
377
378 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
379 return -EACCES;
380
Vlad Yasevich4e540642008-07-18 23:06:32 -0700381 /* See if the address matches any of the addresses we may have
382 * already bound before checking against other endpoints.
383 */
384 if (sctp_bind_addr_match(bp, addr, sp))
385 return -EINVAL;
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 /* Make sure we are allowed to bind here.
388 * The function sctp_get_port_local() does duplicate address
389 * detection.
390 */
Vlad Yasevich2772b492007-08-21 14:24:30 +0900391 addr->v4.sin_port = htons(snum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if ((ret = sctp_get_port_local(sk, addr))) {
Vlad Yasevich4e540642008-07-18 23:06:32 -0700393 return -EADDRINUSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
395
396 /* Refresh ephemeral port. */
397 if (!bp->port)
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000398 bp->port = inet_sk(sk)->inet_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Vlad Yasevich559cf712007-09-16 16:03:28 -0700400 /* Add the address to the bind address list.
401 * Use GFP_ATOMIC since BHs will be disabled.
402 */
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800403 ret = sctp_add_bind_addr(bp, addr, SCTP_ADDR_SRC, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 /* Copy back into socket for getsockname() use. */
406 if (!ret) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000407 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 af->to_sk_saddr(addr, sk);
409 }
410
411 return ret;
412}
413
414 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
415 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900416 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 * at any one time. If a sender, after sending an ASCONF chunk, decides
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900418 * it needs to transfer another ASCONF Chunk, it MUST wait until the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900420 * subsequent ASCONF. Note this restriction binds each side, so at any
421 * time two ASCONF may be in-transit on any given association (one sent
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 * from each endpoint).
423 */
424static int sctp_send_asconf(struct sctp_association *asoc,
425 struct sctp_chunk *chunk)
426{
427 int retval = 0;
428
429 /* If there is an outstanding ASCONF chunk, queue it for later
430 * transmission.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900431 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (asoc->addip_last_asconf) {
David S. Miller79af02c2005-07-08 21:47:49 -0700433 list_add_tail(&chunk->list, &asoc->addip_chunk_list);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900434 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 }
436
437 /* Hold the chunk until an ASCONF_ACK is received. */
438 sctp_chunk_hold(chunk);
439 retval = sctp_primitive_ASCONF(asoc, chunk);
440 if (retval)
441 sctp_chunk_free(chunk);
442 else
443 asoc->addip_last_asconf = chunk;
444
445out:
446 return retval;
447}
448
449/* Add a list of addresses as bind addresses to local endpoint or
450 * association.
451 *
452 * Basically run through each address specified in the addrs/addrcnt
453 * array/length pair, determine if it is IPv6 or IPv4 and call
454 * sctp_do_bind() on it.
455 *
456 * If any of them fails, then the operation will be reversed and the
457 * ones that were added will be removed.
458 *
459 * Only sctp_setsockopt_bindx() is supposed to call this function.
460 */
sebastian@breakpoint.cc04675212007-07-26 23:21:31 +0200461static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
463 int cnt;
464 int retval = 0;
465 void *addr_buf;
466 struct sockaddr *sa_addr;
467 struct sctp_af *af;
468
469 SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n",
470 sk, addrs, addrcnt);
471
472 addr_buf = addrs;
473 for (cnt = 0; cnt < addrcnt; cnt++) {
474 /* The list may contain either IPv4 or IPv6 address;
475 * determine the address length for walking thru the list.
476 */
477 sa_addr = (struct sockaddr *)addr_buf;
478 af = sctp_get_af_specific(sa_addr->sa_family);
479 if (!af) {
480 retval = -EINVAL;
481 goto err_bindx_add;
482 }
483
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900484 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 af->sockaddr_len);
486
487 addr_buf += af->sockaddr_len;
488
489err_bindx_add:
490 if (retval < 0) {
491 /* Failed. Cleanup the ones that have been added */
492 if (cnt > 0)
493 sctp_bindx_rem(sk, addrs, cnt);
494 return retval;
495 }
496 }
497
498 return retval;
499}
500
501/* Send an ASCONF chunk with Add IP address parameters to all the peers of the
502 * associations that are part of the endpoint indicating that a list of local
503 * addresses are added to the endpoint.
504 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900505 * If any of the addresses is already in the bind address list of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 * association, we do not send the chunk for that association. But it will not
507 * affect other associations.
508 *
509 * Only sctp_setsockopt_bindx() is supposed to call this function.
510 */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900511static int sctp_send_asconf_add_ip(struct sock *sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 struct sockaddr *addrs,
513 int addrcnt)
514{
515 struct sctp_sock *sp;
516 struct sctp_endpoint *ep;
517 struct sctp_association *asoc;
518 struct sctp_bind_addr *bp;
519 struct sctp_chunk *chunk;
520 struct sctp_sockaddr_entry *laddr;
521 union sctp_addr *addr;
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700522 union sctp_addr saveaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 void *addr_buf;
524 struct sctp_af *af;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 struct list_head *p;
526 int i;
527 int retval = 0;
528
529 if (!sctp_addip_enable)
530 return retval;
531
532 sp = sctp_sk(sk);
533 ep = sp->ep;
534
535 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800536 __func__, sk, addrs, addrcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700538 list_for_each_entry(asoc, &ep->asocs, asocs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 if (!asoc->peer.asconf_capable)
541 continue;
542
543 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
544 continue;
545
546 if (!sctp_state(asoc, ESTABLISHED))
547 continue;
548
549 /* Check if any address in the packed array of addresses is
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900550 * in the bind address list of the association. If so,
551 * do not send the asconf chunk to its peer, but continue with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 * other associations.
553 */
554 addr_buf = addrs;
555 for (i = 0; i < addrcnt; i++) {
556 addr = (union sctp_addr *)addr_buf;
557 af = sctp_get_af_specific(addr->v4.sin_family);
558 if (!af) {
559 retval = -EINVAL;
560 goto out;
561 }
562
563 if (sctp_assoc_lookup_laddr(asoc, addr))
564 break;
565
566 addr_buf += af->sockaddr_len;
567 }
568 if (i < addrcnt)
569 continue;
570
Vlad Yasevich559cf712007-09-16 16:03:28 -0700571 /* Use the first valid address in bind addr list of
572 * association as Address Parameter of ASCONF CHUNK.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 bp = &asoc->base.bind_addr;
575 p = bp->address_list.next;
576 laddr = list_entry(p, struct sctp_sockaddr_entry, list);
Al Viro5ae955c2006-11-20 17:22:08 -0800577 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 addrcnt, SCTP_PARAM_ADD_IP);
579 if (!chunk) {
580 retval = -ENOMEM;
581 goto out;
582 }
583
584 retval = sctp_send_asconf(asoc, chunk);
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700585 if (retval)
586 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700588 /* Add the new addresses to the bind address list with
589 * use_as_src set to 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 */
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700591 addr_buf = addrs;
592 for (i = 0; i < addrcnt; i++) {
593 addr = (union sctp_addr *)addr_buf;
594 af = sctp_get_af_specific(addr->v4.sin_family);
595 memcpy(&saveaddr, addr, af->sockaddr_len);
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800596 retval = sctp_add_bind_addr(bp, &saveaddr,
597 SCTP_ADDR_NEW, GFP_ATOMIC);
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700598 addr_buf += af->sockaddr_len;
599 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 }
601
602out:
603 return retval;
604}
605
606/* Remove a list of addresses from bind addresses list. Do not remove the
607 * last address.
608 *
609 * Basically run through each address specified in the addrs/addrcnt
610 * array/length pair, determine if it is IPv6 or IPv4 and call
611 * sctp_del_bind() on it.
612 *
613 * If any of them fails, then the operation will be reversed and the
614 * ones that were removed will be added back.
615 *
616 * At least one address has to be left; if only one address is
617 * available, the operation will return -EBUSY.
618 *
619 * Only sctp_setsockopt_bindx() is supposed to call this function.
620 */
sebastian@breakpoint.cc04675212007-07-26 23:21:31 +0200621static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
623 struct sctp_sock *sp = sctp_sk(sk);
624 struct sctp_endpoint *ep = sp->ep;
625 int cnt;
626 struct sctp_bind_addr *bp = &ep->base.bind_addr;
627 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 void *addr_buf;
Al Viroc9a08502006-11-20 17:07:48 -0800629 union sctp_addr *sa_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 struct sctp_af *af;
631
632 SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n",
633 sk, addrs, addrcnt);
634
635 addr_buf = addrs;
636 for (cnt = 0; cnt < addrcnt; cnt++) {
637 /* If the bind address list is empty or if there is only one
638 * bind address, there is nothing more to be removed (we need
639 * at least one address here).
640 */
641 if (list_empty(&bp->address_list) ||
642 (sctp_list_single_entry(&bp->address_list))) {
643 retval = -EBUSY;
644 goto err_bindx_rem;
645 }
646
Al Viroc9a08502006-11-20 17:07:48 -0800647 sa_addr = (union sctp_addr *)addr_buf;
648 af = sctp_get_af_specific(sa_addr->sa.sa_family);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (!af) {
650 retval = -EINVAL;
651 goto err_bindx_rem;
652 }
Paolo Galtieri0304ff8a2007-04-17 12:52:36 -0700653
654 if (!af->addr_valid(sa_addr, sp, NULL)) {
655 retval = -EADDRNOTAVAIL;
656 goto err_bindx_rem;
657 }
658
Al Viroc9a08502006-11-20 17:07:48 -0800659 if (sa_addr->v4.sin_port != htons(bp->port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 retval = -EINVAL;
661 goto err_bindx_rem;
662 }
663
664 /* FIXME - There is probably a need to check if sk->sk_saddr and
665 * sk->sk_rcv_addr are currently set to one of the addresses to
666 * be removed. This is something which needs to be looked into
667 * when we are fixing the outstanding issues with multi-homing
668 * socket routing and failover schemes. Refer to comments in
669 * sctp_do_bind(). -daisy
670 */
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -0400671 retval = sctp_del_bind_addr(bp, sa_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673 addr_buf += af->sockaddr_len;
674err_bindx_rem:
675 if (retval < 0) {
676 /* Failed. Add the ones that has been removed back */
677 if (cnt > 0)
678 sctp_bindx_add(sk, addrs, cnt);
679 return retval;
680 }
681 }
682
683 return retval;
684}
685
686/* Send an ASCONF chunk with Delete IP address parameters to all the peers of
687 * the associations that are part of the endpoint indicating that a list of
688 * local addresses are removed from the endpoint.
689 *
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900690 * If any of the addresses is already in the bind address list of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 * association, we do not send the chunk for that association. But it will not
692 * affect other associations.
693 *
694 * Only sctp_setsockopt_bindx() is supposed to call this function.
695 */
696static int sctp_send_asconf_del_ip(struct sock *sk,
697 struct sockaddr *addrs,
698 int addrcnt)
699{
700 struct sctp_sock *sp;
701 struct sctp_endpoint *ep;
702 struct sctp_association *asoc;
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700703 struct sctp_transport *transport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 struct sctp_bind_addr *bp;
705 struct sctp_chunk *chunk;
706 union sctp_addr *laddr;
707 void *addr_buf;
708 struct sctp_af *af;
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700709 struct sctp_sockaddr_entry *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int i;
711 int retval = 0;
712
713 if (!sctp_addip_enable)
714 return retval;
715
716 sp = sctp_sk(sk);
717 ep = sp->ep;
718
719 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800720 __func__, sk, addrs, addrcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700722 list_for_each_entry(asoc, &ep->asocs, asocs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 if (!asoc->peer.asconf_capable)
725 continue;
726
727 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
728 continue;
729
730 if (!sctp_state(asoc, ESTABLISHED))
731 continue;
732
733 /* Check if any address in the packed array of addresses is
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900734 * not present in the bind address list of the association.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 * If so, do not send the asconf chunk to its peer, but
736 * continue with other associations.
737 */
738 addr_buf = addrs;
739 for (i = 0; i < addrcnt; i++) {
740 laddr = (union sctp_addr *)addr_buf;
741 af = sctp_get_af_specific(laddr->v4.sin_family);
742 if (!af) {
743 retval = -EINVAL;
744 goto out;
745 }
746
747 if (!sctp_assoc_lookup_laddr(asoc, laddr))
748 break;
749
750 addr_buf += af->sockaddr_len;
751 }
752 if (i < addrcnt)
753 continue;
754
755 /* Find one address in the association's bind address list
756 * that is not in the packed array of addresses. This is to
757 * make sure that we do not delete all the addresses in the
758 * association.
759 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 bp = &asoc->base.bind_addr;
761 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
762 addrcnt, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 if (!laddr)
764 continue;
765
Vlad Yasevich559cf712007-09-16 16:03:28 -0700766 /* We do not need RCU protection throughout this loop
767 * because this is done under a socket lock from the
768 * setsockopt call.
769 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
771 SCTP_PARAM_DEL_IP);
772 if (!chunk) {
773 retval = -ENOMEM;
774 goto out;
775 }
776
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700777 /* Reset use_as_src flag for the addresses in the bind address
778 * list that are to be deleted.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 */
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700780 addr_buf = addrs;
781 for (i = 0; i < addrcnt; i++) {
782 laddr = (union sctp_addr *)addr_buf;
783 af = sctp_get_af_specific(laddr->v4.sin_family);
Vlad Yasevich559cf712007-09-16 16:03:28 -0700784 list_for_each_entry(saddr, &bp->address_list, list) {
Al Viro5f242a12006-11-20 17:05:23 -0800785 if (sctp_cmp_addr_exact(&saddr->a, laddr))
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800786 saddr->state = SCTP_ADDR_DEL;
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700787 }
788 addr_buf += af->sockaddr_len;
789 }
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700790
791 /* Update the route and saddr entries for all the transports
792 * as some of the addresses in the bind address list are
793 * about to be deleted and cannot be used as source addresses.
794 */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700795 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
796 transports) {
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700797 dst_release(transport->dst);
798 sctp_transport_route(transport, NULL,
799 sctp_sk(asoc->base.sk));
800 }
801
802 retval = sctp_send_asconf(asoc, chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 }
804out:
805 return retval;
806}
807
808/* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
809 *
810 * API 8.1
811 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
812 * int flags);
813 *
814 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
815 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
816 * or IPv6 addresses.
817 *
818 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
819 * Section 3.1.2 for this usage.
820 *
821 * addrs is a pointer to an array of one or more socket addresses. Each
822 * address is contained in its appropriate structure (i.e. struct
823 * sockaddr_in or struct sockaddr_in6) the family of the address type
Ville Nuorvala23c435f2006-10-16 22:08:28 -0700824 * must be used to distinguish the address length (note that this
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 * representation is termed a "packed array" of addresses). The caller
826 * specifies the number of addresses in the array with addrcnt.
827 *
828 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
829 * -1, and sets errno to the appropriate error code.
830 *
831 * For SCTP, the port given in each socket address must be the same, or
832 * sctp_bindx() will fail, setting errno to EINVAL.
833 *
834 * The flags parameter is formed from the bitwise OR of zero or more of
835 * the following currently defined flags:
836 *
837 * SCTP_BINDX_ADD_ADDR
838 *
839 * SCTP_BINDX_REM_ADDR
840 *
841 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
842 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
843 * addresses from the association. The two flags are mutually exclusive;
844 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
845 * not remove all addresses from an association; sctp_bindx() will
846 * reject such an attempt with EINVAL.
847 *
848 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
849 * additional addresses with an endpoint after calling bind(). Or use
850 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
851 * socket is associated with so that no new association accepted will be
852 * associated with those addresses. If the endpoint supports dynamic
853 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
854 * endpoint to send the appropriate message to the peer to change the
855 * peers address lists.
856 *
857 * Adding and removing addresses from a connected association is
858 * optional functionality. Implementations that do not support this
859 * functionality should return EOPNOTSUPP.
860 *
861 * Basically do nothing but copying the addresses from user to kernel
862 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
Frank Filz3f7a87d2005-06-20 13:14:57 -0700863 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
864 * from userspace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 *
866 * We don't use copy_from_user() for optimization: we first do the
867 * sanity checks (buffer size -fast- and access check-healthy
868 * pointer); if all of those succeed, then we can alloc the memory
869 * (expensive operation) needed to copy the data to kernel. Then we do
870 * the copying without checking the user space area
871 * (__copy_from_user()).
872 *
873 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
874 * it.
875 *
876 * sk The sk of the socket
877 * addrs The pointer to the addresses in user land
878 * addrssize Size of the addrs buffer
879 * op Operation to perform (add or remove, see the flags of
880 * sctp_bindx)
881 *
882 * Returns 0 if ok, <0 errno code on error.
883 */
884SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk,
885 struct sockaddr __user *addrs,
886 int addrs_size, int op)
887{
888 struct sockaddr *kaddrs;
889 int err;
890 int addrcnt = 0;
891 int walk_size = 0;
892 struct sockaddr *sa_addr;
893 void *addr_buf;
894 struct sctp_af *af;
895
896 SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"
897 " addrs_size %d opt %d\n", sk, addrs, addrs_size, op);
898
899 if (unlikely(addrs_size <= 0))
900 return -EINVAL;
901
902 /* Check the user passed a healthy pointer. */
903 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
904 return -EFAULT;
905
906 /* Alloc space for the address array in kernel memory. */
Kris Katterjohn8b3a7002006-01-11 15:56:43 -0800907 kaddrs = kmalloc(addrs_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 if (unlikely(!kaddrs))
909 return -ENOMEM;
910
911 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
912 kfree(kaddrs);
913 return -EFAULT;
914 }
915
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900916 /* Walk through the addrs buffer and count the number of addresses. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 addr_buf = kaddrs;
918 while (walk_size < addrs_size) {
919 sa_addr = (struct sockaddr *)addr_buf;
920 af = sctp_get_af_specific(sa_addr->sa_family);
921
922 /* If the address family is not supported or if this address
923 * causes the address buffer to overflow return EINVAL.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900924 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
926 kfree(kaddrs);
927 return -EINVAL;
928 }
929 addrcnt++;
930 addr_buf += af->sockaddr_len;
931 walk_size += af->sockaddr_len;
932 }
933
934 /* Do the work. */
935 switch (op) {
936 case SCTP_BINDX_ADD_ADDR:
937 err = sctp_bindx_add(sk, kaddrs, addrcnt);
938 if (err)
939 goto out;
940 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
941 break;
942
943 case SCTP_BINDX_REM_ADDR:
944 err = sctp_bindx_rem(sk, kaddrs, addrcnt);
945 if (err)
946 goto out;
947 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
948 break;
949
950 default:
951 err = -EINVAL;
952 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
955out:
956 kfree(kaddrs);
957
958 return err;
959}
960
Frank Filz3f7a87d2005-06-20 13:14:57 -0700961/* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
962 *
963 * Common routine for handling connect() and sctp_connectx().
964 * Connect will come in with just a single address.
965 */
966static int __sctp_connect(struct sock* sk,
967 struct sockaddr *kaddrs,
Vlad Yasevich88a0a942008-05-09 15:14:11 -0700968 int addrs_size,
969 sctp_assoc_t *assoc_id)
Frank Filz3f7a87d2005-06-20 13:14:57 -0700970{
971 struct sctp_sock *sp;
972 struct sctp_endpoint *ep;
973 struct sctp_association *asoc = NULL;
974 struct sctp_association *asoc2;
975 struct sctp_transport *transport;
976 union sctp_addr to;
977 struct sctp_af *af;
978 sctp_scope_t scope;
979 long timeo;
980 int err = 0;
981 int addrcnt = 0;
982 int walk_size = 0;
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -0400983 union sctp_addr *sa_addr = NULL;
Frank Filz3f7a87d2005-06-20 13:14:57 -0700984 void *addr_buf;
Vlad Yasevich16d00fb2007-05-04 13:34:09 -0700985 unsigned short port;
Vlad Yasevichf50f95c2007-07-03 12:47:40 -0400986 unsigned int f_flags = 0;
Frank Filz3f7a87d2005-06-20 13:14:57 -0700987
988 sp = sctp_sk(sk);
989 ep = sp->ep;
990
991 /* connect() cannot be done on a socket that is already in ESTABLISHED
992 * state - UDP-style peeled off socket or a TCP-style socket that
993 * is already connected.
994 * It cannot be done even on a TCP-style listening socket.
995 */
996 if (sctp_sstate(sk, ESTABLISHED) ||
997 (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
998 err = -EISCONN;
999 goto out_free;
1000 }
1001
1002 /* Walk through the addrs buffer and count the number of addresses. */
1003 addr_buf = kaddrs;
1004 while (walk_size < addrs_size) {
Al Viro4bdf4b52006-11-20 17:10:20 -08001005 sa_addr = (union sctp_addr *)addr_buf;
1006 af = sctp_get_af_specific(sa_addr->sa.sa_family);
Vlad Yasevich16d00fb2007-05-04 13:34:09 -07001007 port = ntohs(sa_addr->v4.sin_port);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001008
1009 /* If the address family is not supported or if this address
1010 * causes the address buffer to overflow return EINVAL.
1011 */
1012 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1013 err = -EINVAL;
1014 goto out_free;
1015 }
1016
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001017 /* Save current address so we can work with it */
1018 memcpy(&to, sa_addr, af->sockaddr_len);
1019
1020 err = sctp_verify_addr(sk, &to, af->sockaddr_len);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001021 if (err)
1022 goto out_free;
1023
Vlad Yasevich16d00fb2007-05-04 13:34:09 -07001024 /* Make sure the destination port is correctly set
1025 * in all addresses.
1026 */
1027 if (asoc && asoc->peer.port && asoc->peer.port != port)
1028 goto out_free;
1029
Frank Filz3f7a87d2005-06-20 13:14:57 -07001030
1031 /* Check if there already is a matching association on the
1032 * endpoint (other than the one created here).
1033 */
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001034 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001035 if (asoc2 && asoc2 != asoc) {
1036 if (asoc2->state >= SCTP_STATE_ESTABLISHED)
1037 err = -EISCONN;
1038 else
1039 err = -EALREADY;
1040 goto out_free;
1041 }
1042
1043 /* If we could not find a matching association on the endpoint,
1044 * make sure that there is no peeled-off association matching
1045 * the peer address even on another socket.
1046 */
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001047 if (sctp_endpoint_is_peeled_off(ep, &to)) {
Frank Filz3f7a87d2005-06-20 13:14:57 -07001048 err = -EADDRNOTAVAIL;
1049 goto out_free;
1050 }
1051
1052 if (!asoc) {
1053 /* If a bind() or sctp_bindx() is not called prior to
1054 * an sctp_connectx() call, the system picks an
1055 * ephemeral port and will choose an address set
1056 * equivalent to binding with a wildcard address.
1057 */
1058 if (!ep->base.bind_addr.port) {
1059 if (sctp_autobind(sk)) {
1060 err = -EAGAIN;
1061 goto out_free;
1062 }
Ivan Skytte Jorgensen64a0c1c2005-10-28 15:39:02 -07001063 } else {
1064 /*
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001065 * If an unprivileged user inherits a 1-many
1066 * style socket with open associations on a
1067 * privileged port, it MAY be permitted to
1068 * accept new associations, but it SHOULD NOT
Ivan Skytte Jorgensen64a0c1c2005-10-28 15:39:02 -07001069 * be permitted to open new associations.
1070 */
1071 if (ep->base.bind_addr.port < PROT_SOCK &&
1072 !capable(CAP_NET_BIND_SERVICE)) {
1073 err = -EACCES;
1074 goto out_free;
1075 }
Frank Filz3f7a87d2005-06-20 13:14:57 -07001076 }
1077
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001078 scope = sctp_scope(&to);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001079 asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1080 if (!asoc) {
1081 err = -ENOMEM;
1082 goto out_free;
1083 }
Vlad Yasevich409b95a2009-11-10 08:57:34 +00001084
1085 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope,
1086 GFP_KERNEL);
1087 if (err < 0) {
1088 goto out_free;
1089 }
1090
Frank Filz3f7a87d2005-06-20 13:14:57 -07001091 }
1092
1093 /* Prime the peer's transport structures. */
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001094 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
Frank Filz3f7a87d2005-06-20 13:14:57 -07001095 SCTP_UNKNOWN);
1096 if (!transport) {
1097 err = -ENOMEM;
1098 goto out_free;
1099 }
1100
1101 addrcnt++;
1102 addr_buf += af->sockaddr_len;
1103 walk_size += af->sockaddr_len;
1104 }
1105
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001106 /* In case the user of sctp_connectx() wants an association
1107 * id back, assign one now.
1108 */
1109 if (assoc_id) {
1110 err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1111 if (err < 0)
1112 goto out_free;
1113 }
1114
Frank Filz3f7a87d2005-06-20 13:14:57 -07001115 err = sctp_primitive_ASSOCIATE(asoc, NULL);
1116 if (err < 0) {
1117 goto out_free;
1118 }
1119
1120 /* Initialize sk's dport and daddr for getpeername() */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001121 inet_sk(sk)->inet_dport = htons(asoc->peer.port);
Vlad Yaseviche4d1fea2007-08-01 10:56:43 -04001122 af = sctp_get_af_specific(sa_addr->sa.sa_family);
1123 af->to_sk_daddr(sa_addr, sk);
Sridhar Samudrala8de8c872006-05-19 10:58:12 -07001124 sk->sk_err = 0;
Frank Filz3f7a87d2005-06-20 13:14:57 -07001125
Vlad Yasevichf50f95c2007-07-03 12:47:40 -04001126 /* in-kernel sockets don't generally have a file allocated to them
1127 * if all they do is call sock_create_kern().
1128 */
1129 if (sk->sk_socket->file)
1130 f_flags = sk->sk_socket->file->f_flags;
1131
1132 timeo = sock_sndtimeo(sk, f_flags & O_NONBLOCK);
1133
Frank Filz3f7a87d2005-06-20 13:14:57 -07001134 err = sctp_wait_for_connect(asoc, &timeo);
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001135 if ((err == 0 || err == -EINPROGRESS) && assoc_id)
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001136 *assoc_id = asoc->assoc_id;
Frank Filz3f7a87d2005-06-20 13:14:57 -07001137
1138 /* Don't free association on exit. */
1139 asoc = NULL;
1140
1141out_free:
1142
1143 SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p"
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001144 " kaddrs: %p err: %d\n",
1145 asoc, kaddrs, err);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001146 if (asoc)
1147 sctp_association_free(asoc);
1148 return err;
1149}
1150
1151/* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1152 *
1153 * API 8.9
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001154 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1155 * sctp_assoc_t *asoc);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001156 *
1157 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1158 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1159 * or IPv6 addresses.
1160 *
1161 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1162 * Section 3.1.2 for this usage.
1163 *
1164 * addrs is a pointer to an array of one or more socket addresses. Each
1165 * address is contained in its appropriate structure (i.e. struct
1166 * sockaddr_in or struct sockaddr_in6) the family of the address type
1167 * must be used to distengish the address length (note that this
1168 * representation is termed a "packed array" of addresses). The caller
1169 * specifies the number of addresses in the array with addrcnt.
1170 *
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001171 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1172 * the association id of the new association. On failure, sctp_connectx()
1173 * returns -1, and sets errno to the appropriate error code. The assoc_id
1174 * is not touched by the kernel.
Frank Filz3f7a87d2005-06-20 13:14:57 -07001175 *
1176 * For SCTP, the port given in each socket address must be the same, or
1177 * sctp_connectx() will fail, setting errno to EINVAL.
1178 *
1179 * An application can use sctp_connectx to initiate an association with
1180 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1181 * allows a caller to specify multiple addresses at which a peer can be
1182 * reached. The way the SCTP stack uses the list of addresses to set up
1183 * the association is implementation dependant. This function only
1184 * specifies that the stack will try to make use of all the addresses in
1185 * the list when needed.
1186 *
1187 * Note that the list of addresses passed in is only used for setting up
1188 * the association. It does not necessarily equal the set of addresses
1189 * the peer uses for the resulting association. If the caller wants to
1190 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1191 * retrieve them after the association has been set up.
1192 *
1193 * Basically do nothing but copying the addresses from user to kernel
1194 * land and invoking either sctp_connectx(). This is used for tunneling
1195 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1196 *
1197 * We don't use copy_from_user() for optimization: we first do the
1198 * sanity checks (buffer size -fast- and access check-healthy
1199 * pointer); if all of those succeed, then we can alloc the memory
1200 * (expensive operation) needed to copy the data to kernel. Then we do
1201 * the copying without checking the user space area
1202 * (__copy_from_user()).
1203 *
1204 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1205 * it.
1206 *
1207 * sk The sk of the socket
1208 * addrs The pointer to the addresses in user land
1209 * addrssize Size of the addrs buffer
1210 *
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001211 * Returns >=0 if ok, <0 errno code on error.
Frank Filz3f7a87d2005-06-20 13:14:57 -07001212 */
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001213SCTP_STATIC int __sctp_setsockopt_connectx(struct sock* sk,
Frank Filz3f7a87d2005-06-20 13:14:57 -07001214 struct sockaddr __user *addrs,
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001215 int addrs_size,
1216 sctp_assoc_t *assoc_id)
Frank Filz3f7a87d2005-06-20 13:14:57 -07001217{
1218 int err = 0;
1219 struct sockaddr *kaddrs;
1220
1221 SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001222 __func__, sk, addrs, addrs_size);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001223
1224 if (unlikely(addrs_size <= 0))
1225 return -EINVAL;
1226
1227 /* Check the user passed a healthy pointer. */
1228 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
1229 return -EFAULT;
1230
1231 /* Alloc space for the address array in kernel memory. */
Kris Katterjohn8b3a7002006-01-11 15:56:43 -08001232 kaddrs = kmalloc(addrs_size, GFP_KERNEL);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001233 if (unlikely(!kaddrs))
1234 return -ENOMEM;
1235
1236 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
1237 err = -EFAULT;
1238 } else {
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001239 err = __sctp_connect(sk, kaddrs, addrs_size, assoc_id);
Frank Filz3f7a87d2005-06-20 13:14:57 -07001240 }
1241
1242 kfree(kaddrs);
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001243
Frank Filz3f7a87d2005-06-20 13:14:57 -07001244 return err;
1245}
1246
Vlad Yasevich88a0a942008-05-09 15:14:11 -07001247/*
1248 * This is an older interface. It's kept for backward compatibility
1249 * to the option that doesn't provide association id.
1250 */
1251SCTP_STATIC int sctp_setsockopt_connectx_old(struct sock* sk,
1252 struct sockaddr __user *addrs,
1253 int addrs_size)
1254{
1255 return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL);
1256}
1257
1258/*
1259 * New interface for the API. The since the API is done with a socket
1260 * option, to make it simple we feed back the association id is as a return
1261 * indication to the call. Error is always negative and association id is
1262 * always positive.
1263 */
1264SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk,
1265 struct sockaddr __user *addrs,
1266 int addrs_size)
1267{
1268 sctp_assoc_t assoc_id = 0;
1269 int err = 0;
1270
1271 err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id);
1272
1273 if (err)
1274 return err;
1275 else
1276 return assoc_id;
1277}
1278
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001279/*
Vlad Yasevichf9c67812009-11-11 08:19:24 +00001280 * New (hopefully final) interface for the API.
1281 * We use the sctp_getaddrs_old structure so that use-space library
1282 * can avoid any unnecessary allocations. The only defferent part
1283 * is that we store the actual length of the address buffer into the
1284 * addrs_num structure member. That way we can re-use the existing
1285 * code.
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001286 */
1287SCTP_STATIC int sctp_getsockopt_connectx3(struct sock* sk, int len,
1288 char __user *optval,
1289 int __user *optlen)
1290{
Vlad Yasevichf9c67812009-11-11 08:19:24 +00001291 struct sctp_getaddrs_old param;
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001292 sctp_assoc_t assoc_id = 0;
1293 int err = 0;
1294
Vlad Yasevichf9c67812009-11-11 08:19:24 +00001295 if (len < sizeof(param))
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001296 return -EINVAL;
1297
Vlad Yasevichf9c67812009-11-11 08:19:24 +00001298 if (copy_from_user(&param, optval, sizeof(param)))
1299 return -EFAULT;
1300
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001301 err = __sctp_setsockopt_connectx(sk,
Vlad Yasevichf9c67812009-11-11 08:19:24 +00001302 (struct sockaddr __user *)param.addrs,
1303 param.addr_num, &assoc_id);
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04001304
1305 if (err == 0 || err == -EINPROGRESS) {
1306 if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1307 return -EFAULT;
1308 if (put_user(sizeof(assoc_id), optlen))
1309 return -EFAULT;
1310 }
1311
1312 return err;
1313}
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315/* API 3.1.4 close() - UDP Style Syntax
1316 * Applications use close() to perform graceful shutdown (as described in
1317 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1318 * by a UDP-style socket.
1319 *
1320 * The syntax is
1321 *
1322 * ret = close(int sd);
1323 *
1324 * sd - the socket descriptor of the associations to be closed.
1325 *
1326 * To gracefully shutdown a specific association represented by the
1327 * UDP-style socket, an application should use the sendmsg() call,
1328 * passing no user data, but including the appropriate flag in the
1329 * ancillary data (see Section xxxx).
1330 *
1331 * If sd in the close() call is a branched-off socket representing only
1332 * one association, the shutdown is performed on that association only.
1333 *
1334 * 4.1.6 close() - TCP Style Syntax
1335 *
1336 * Applications use close() to gracefully close down an association.
1337 *
1338 * The syntax is:
1339 *
1340 * int close(int sd);
1341 *
1342 * sd - the socket descriptor of the association to be closed.
1343 *
1344 * After an application calls close() on a socket descriptor, no further
1345 * socket operations will succeed on that descriptor.
1346 *
1347 * API 7.1.4 SO_LINGER
1348 *
1349 * An application using the TCP-style socket can use this option to
1350 * perform the SCTP ABORT primitive. The linger option structure is:
1351 *
1352 * struct linger {
1353 * int l_onoff; // option on/off
1354 * int l_linger; // linger time
1355 * };
1356 *
1357 * To enable the option, set l_onoff to 1. If the l_linger value is set
1358 * to 0, calling close() is the same as the ABORT primitive. If the
1359 * value is set to a negative value, the setsockopt() call will return
1360 * an error. If the value is set to a positive value linger_time, the
1361 * close() can be blocked for at most linger_time ms. If the graceful
1362 * shutdown phase does not finish during this period, close() will
1363 * return but the graceful shutdown phase continues in the system.
1364 */
1365SCTP_STATIC void sctp_close(struct sock *sk, long timeout)
1366{
1367 struct sctp_endpoint *ep;
1368 struct sctp_association *asoc;
1369 struct list_head *pos, *temp;
1370
1371 SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout);
1372
1373 sctp_lock_sock(sk);
1374 sk->sk_shutdown = SHUTDOWN_MASK;
Vlad Yasevichbec96402009-07-30 18:08:28 -04001375 sk->sk_state = SCTP_SS_CLOSING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 ep = sctp_sk(sk)->ep;
1378
Vladislav Yasevich61c9fed2006-05-19 11:01:18 -07001379 /* Walk all associations on an endpoint. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 list_for_each_safe(pos, temp, &ep->asocs) {
1381 asoc = list_entry(pos, struct sctp_association, asocs);
1382
1383 if (sctp_style(sk, TCP)) {
1384 /* A closed association can still be in the list if
1385 * it belongs to a TCP-style listening socket that is
1386 * not yet accepted. If so, free it. If not, send an
1387 * ABORT or SHUTDOWN based on the linger options.
1388 */
1389 if (sctp_state(asoc, CLOSED)) {
1390 sctp_unhash_established(asoc);
1391 sctp_association_free(asoc);
Vladislav Yasevichb89498a2006-05-19 14:32:06 -07001392 continue;
1393 }
1394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
Sridhar Samudralab9ac8672006-08-28 13:53:01 -07001396 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1397 struct sctp_chunk *chunk;
1398
1399 chunk = sctp_make_abort_user(asoc, NULL, 0);
1400 if (chunk)
1401 sctp_primitive_ABORT(asoc, chunk);
1402 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 sctp_primitive_SHUTDOWN(asoc, NULL);
1404 }
1405
1406 /* Clean up any skbs sitting on the receive queue. */
1407 sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1408 sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1409
1410 /* On a TCP-style socket, block for at most linger_time if set. */
1411 if (sctp_style(sk, TCP) && timeout)
1412 sctp_wait_for_close(sk, timeout);
1413
1414 /* This will run the backlog queue. */
1415 sctp_release_sock(sk);
1416
1417 /* Supposedly, no process has access to the socket, but
1418 * the net layers still may.
1419 */
1420 sctp_local_bh_disable();
1421 sctp_bh_lock_sock(sk);
1422
1423 /* Hold the sock, since sk_common_release() will put sock_put()
1424 * and we have just a little more cleanup.
1425 */
1426 sock_hold(sk);
1427 sk_common_release(sk);
1428
1429 sctp_bh_unlock_sock(sk);
1430 sctp_local_bh_enable();
1431
1432 sock_put(sk);
1433
1434 SCTP_DBG_OBJCNT_DEC(sock);
1435}
1436
1437/* Handle EPIPE error. */
1438static int sctp_error(struct sock *sk, int flags, int err)
1439{
1440 if (err == -EPIPE)
1441 err = sock_error(sk) ? : -EPIPE;
1442 if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1443 send_sig(SIGPIPE, current, 0);
1444 return err;
1445}
1446
1447/* API 3.1.3 sendmsg() - UDP Style Syntax
1448 *
1449 * An application uses sendmsg() and recvmsg() calls to transmit data to
1450 * and receive data from its peer.
1451 *
1452 * ssize_t sendmsg(int socket, const struct msghdr *message,
1453 * int flags);
1454 *
1455 * socket - the socket descriptor of the endpoint.
1456 * message - pointer to the msghdr structure which contains a single
1457 * user message and possibly some ancillary data.
1458 *
1459 * See Section 5 for complete description of the data
1460 * structures.
1461 *
1462 * flags - flags sent or received with the user message, see Section
1463 * 5 for complete description of the flags.
1464 *
1465 * Note: This function could use a rewrite especially when explicit
1466 * connect support comes in.
1467 */
1468/* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1469
1470SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *);
1471
1472SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk,
1473 struct msghdr *msg, size_t msg_len)
1474{
1475 struct sctp_sock *sp;
1476 struct sctp_endpoint *ep;
1477 struct sctp_association *new_asoc=NULL, *asoc=NULL;
1478 struct sctp_transport *transport, *chunk_tp;
1479 struct sctp_chunk *chunk;
Al Virodce116a2006-11-20 17:25:15 -08001480 union sctp_addr to;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 struct sockaddr *msg_name = NULL;
1482 struct sctp_sndrcvinfo default_sinfo = { 0 };
1483 struct sctp_sndrcvinfo *sinfo;
1484 struct sctp_initmsg *sinit;
1485 sctp_assoc_t associd = 0;
1486 sctp_cmsgs_t cmsgs = { NULL };
1487 int err;
1488 sctp_scope_t scope;
1489 long timeo;
1490 __u16 sinfo_flags = 0;
1491 struct sctp_datamsg *datamsg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 int msg_flags = msg->msg_flags;
1493
1494 SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n",
1495 sk, msg, msg_len);
1496
1497 err = 0;
1498 sp = sctp_sk(sk);
1499 ep = sp->ep;
1500
Frank Filz3f7a87d2005-06-20 13:14:57 -07001501 SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
1503 /* We cannot send a message over a TCP-style listening socket. */
1504 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
1505 err = -EPIPE;
1506 goto out_nounlock;
1507 }
1508
1509 /* Parse out the SCTP CMSGs. */
1510 err = sctp_msghdr_parse(msg, &cmsgs);
1511
1512 if (err) {
1513 SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err);
1514 goto out_nounlock;
1515 }
1516
1517 /* Fetch the destination address for this packet. This
1518 * address only selects the association--it is not necessarily
1519 * the address we will send to.
1520 * For a peeled-off socket, msg_name is ignored.
1521 */
1522 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1523 int msg_namelen = msg->msg_namelen;
1524
1525 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
1526 msg_namelen);
1527 if (err)
1528 return err;
1529
1530 if (msg_namelen > sizeof(to))
1531 msg_namelen = sizeof(to);
1532 memcpy(&to, msg->msg_name, msg_namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 msg_name = msg->msg_name;
1534 }
1535
1536 sinfo = cmsgs.info;
1537 sinit = cmsgs.init;
1538
1539 /* Did the user specify SNDRCVINFO? */
1540 if (sinfo) {
1541 sinfo_flags = sinfo->sinfo_flags;
1542 associd = sinfo->sinfo_assoc_id;
1543 }
1544
1545 SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n",
1546 msg_len, sinfo_flags);
1547
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001548 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1549 if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 err = -EINVAL;
1551 goto out_nounlock;
1552 }
1553
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001554 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1555 * length messages when SCTP_EOF|SCTP_ABORT is not set.
1556 * If SCTP_ABORT is set, the message length could be non zero with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 * the msg_iov set to the user abort reason.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001558 */
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001559 if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) ||
1560 (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 err = -EINVAL;
1562 goto out_nounlock;
1563 }
1564
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001565 /* If SCTP_ADDR_OVER is set, there must be an address
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 * specified in msg_name.
1567 */
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001568 if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 err = -EINVAL;
1570 goto out_nounlock;
1571 }
1572
1573 transport = NULL;
1574
1575 SCTP_DEBUG_PRINTK("About to look up association.\n");
1576
1577 sctp_lock_sock(sk);
1578
1579 /* If a msg_name has been specified, assume this is to be used. */
1580 if (msg_name) {
1581 /* Look for a matching association on the endpoint. */
Al Virodce116a2006-11-20 17:25:15 -08001582 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 if (!asoc) {
1584 /* If we could not find a matching association on the
1585 * endpoint, make sure that it is not a TCP-style
1586 * socket that already has an association or there is
1587 * no peeled-off association on another socket.
1588 */
1589 if ((sctp_style(sk, TCP) &&
1590 sctp_sstate(sk, ESTABLISHED)) ||
Al Virodce116a2006-11-20 17:25:15 -08001591 sctp_endpoint_is_peeled_off(ep, &to)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 err = -EADDRNOTAVAIL;
1593 goto out_unlock;
1594 }
1595 }
1596 } else {
1597 asoc = sctp_id2assoc(sk, associd);
1598 if (!asoc) {
1599 err = -EPIPE;
1600 goto out_unlock;
1601 }
1602 }
1603
1604 if (asoc) {
1605 SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc);
1606
1607 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1608 * socket that has an association in CLOSED state. This can
1609 * happen when an accepted socket has an association that is
1610 * already CLOSED.
1611 */
1612 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
1613 err = -EPIPE;
1614 goto out_unlock;
1615 }
1616
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001617 if (sinfo_flags & SCTP_EOF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 SCTP_DEBUG_PRINTK("Shutting down association: %p\n",
1619 asoc);
1620 sctp_primitive_SHUTDOWN(asoc, NULL);
1621 err = 0;
1622 goto out_unlock;
1623 }
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001624 if (sinfo_flags & SCTP_ABORT) {
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001625
1626 chunk = sctp_make_abort_user(asoc, msg, msg_len);
1627 if (!chunk) {
1628 err = -ENOMEM;
1629 goto out_unlock;
1630 }
1631
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc);
Sridhar Samudralac164a9b2006-08-22 11:50:39 -07001633 sctp_primitive_ABORT(asoc, chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 err = 0;
1635 goto out_unlock;
1636 }
1637 }
1638
1639 /* Do we need to create the association? */
1640 if (!asoc) {
1641 SCTP_DEBUG_PRINTK("There is no association yet.\n");
1642
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001643 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 err = -EINVAL;
1645 goto out_unlock;
1646 }
1647
1648 /* Check for invalid stream against the stream counts,
1649 * either the default or the user specified stream counts.
1650 */
1651 if (sinfo) {
1652 if (!sinit || (sinit && !sinit->sinit_num_ostreams)) {
1653 /* Check against the defaults. */
1654 if (sinfo->sinfo_stream >=
1655 sp->initmsg.sinit_num_ostreams) {
1656 err = -EINVAL;
1657 goto out_unlock;
1658 }
1659 } else {
1660 /* Check against the requested. */
1661 if (sinfo->sinfo_stream >=
1662 sinit->sinit_num_ostreams) {
1663 err = -EINVAL;
1664 goto out_unlock;
1665 }
1666 }
1667 }
1668
1669 /*
1670 * API 3.1.2 bind() - UDP Style Syntax
1671 * If a bind() or sctp_bindx() is not called prior to a
1672 * sendmsg() call that initiates a new association, the
1673 * system picks an ephemeral port and will choose an address
1674 * set equivalent to binding with a wildcard address.
1675 */
1676 if (!ep->base.bind_addr.port) {
1677 if (sctp_autobind(sk)) {
1678 err = -EAGAIN;
1679 goto out_unlock;
1680 }
Ivan Skytte Jorgensen64a0c1c2005-10-28 15:39:02 -07001681 } else {
1682 /*
1683 * If an unprivileged user inherits a one-to-many
1684 * style socket with open associations on a privileged
1685 * port, it MAY be permitted to accept new associations,
1686 * but it SHOULD NOT be permitted to open new
1687 * associations.
1688 */
1689 if (ep->base.bind_addr.port < PROT_SOCK &&
1690 !capable(CAP_NET_BIND_SERVICE)) {
1691 err = -EACCES;
1692 goto out_unlock;
1693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
1695
1696 scope = sctp_scope(&to);
1697 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1698 if (!new_asoc) {
1699 err = -ENOMEM;
1700 goto out_unlock;
1701 }
1702 asoc = new_asoc;
Vlad Yasevich409b95a2009-11-10 08:57:34 +00001703 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
1704 if (err < 0) {
1705 err = -ENOMEM;
1706 goto out_free;
1707 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708
1709 /* If the SCTP_INIT ancillary data is specified, set all
1710 * the association init values accordingly.
1711 */
1712 if (sinit) {
1713 if (sinit->sinit_num_ostreams) {
1714 asoc->c.sinit_num_ostreams =
1715 sinit->sinit_num_ostreams;
1716 }
1717 if (sinit->sinit_max_instreams) {
1718 asoc->c.sinit_max_instreams =
1719 sinit->sinit_max_instreams;
1720 }
1721 if (sinit->sinit_max_attempts) {
1722 asoc->max_init_attempts
1723 = sinit->sinit_max_attempts;
1724 }
1725 if (sinit->sinit_max_init_timeo) {
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001726 asoc->max_init_timeo =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 msecs_to_jiffies(sinit->sinit_max_init_timeo);
1728 }
1729 }
1730
1731 /* Prime the peer's transport structures. */
Al Virodce116a2006-11-20 17:25:15 -08001732 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 if (!transport) {
1734 err = -ENOMEM;
1735 goto out_free;
1736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 }
1738
1739 /* ASSERT: we have a valid association at this point. */
1740 SCTP_DEBUG_PRINTK("We have a valid association.\n");
1741
1742 if (!sinfo) {
1743 /* If the user didn't specify SNDRCVINFO, make up one with
1744 * some defaults.
1745 */
1746 default_sinfo.sinfo_stream = asoc->default_stream;
1747 default_sinfo.sinfo_flags = asoc->default_flags;
1748 default_sinfo.sinfo_ppid = asoc->default_ppid;
1749 default_sinfo.sinfo_context = asoc->default_context;
1750 default_sinfo.sinfo_timetolive = asoc->default_timetolive;
1751 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
1752 sinfo = &default_sinfo;
1753 }
1754
1755 /* API 7.1.7, the sndbuf size per association bounds the
1756 * maximum size of data that can be sent in a single send call.
1757 */
1758 if (msg_len > sk->sk_sndbuf) {
1759 err = -EMSGSIZE;
1760 goto out_free;
1761 }
1762
Vlad Yasevich8a479492007-06-07 14:21:05 -04001763 if (asoc->pmtu_pending)
1764 sctp_assoc_pending_pmtu(asoc);
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 /* If fragmentation is disabled and the message length exceeds the
1767 * association fragmentation point, return EMSGSIZE. The I-D
1768 * does not specify what this error is, but this looks like
1769 * a great fit.
1770 */
1771 if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
1772 err = -EMSGSIZE;
1773 goto out_free;
1774 }
1775
1776 if (sinfo) {
1777 /* Check for invalid stream. */
1778 if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) {
1779 err = -EINVAL;
1780 goto out_free;
1781 }
1782 }
1783
1784 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1785 if (!sctp_wspace(asoc)) {
1786 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1787 if (err)
1788 goto out_free;
1789 }
1790
1791 /* If an address is passed with the sendto/sendmsg call, it is used
1792 * to override the primary destination address in the TCP model, or
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001793 * when SCTP_ADDR_OVER flag is set in the UDP model.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 */
1795 if ((sctp_style(sk, TCP) && msg_name) ||
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07001796 (sinfo_flags & SCTP_ADDR_OVER)) {
Al Virodce116a2006-11-20 17:25:15 -08001797 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 if (!chunk_tp) {
1799 err = -EINVAL;
1800 goto out_free;
1801 }
1802 } else
1803 chunk_tp = NULL;
1804
1805 /* Auto-connect, if we aren't connected already. */
1806 if (sctp_state(asoc, CLOSED)) {
1807 err = sctp_primitive_ASSOCIATE(asoc, NULL);
1808 if (err < 0)
1809 goto out_free;
1810 SCTP_DEBUG_PRINTK("We associated primitively.\n");
1811 }
1812
1813 /* Break the message into multiple chunks of maximum size. */
1814 datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len);
1815 if (!datamsg) {
1816 err = -ENOMEM;
1817 goto out_free;
1818 }
1819
1820 /* Now send the (possibly) fragmented message. */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001821 list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
Florian Westphal80445cf2008-03-23 22:47:08 -07001822 sctp_chunk_hold(chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
1824 /* Do accounting for the write space. */
1825 sctp_set_owner_w(chunk);
1826
1827 chunk->transport = chunk_tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 }
1829
Vlad Yasevich9c5c62b2009-08-10 13:51:03 -04001830 /* Send it to the lower layers. Note: all chunks
1831 * must either fail or succeed. The lower layer
1832 * works that way today. Keep it that way or this
1833 * breaks.
1834 */
1835 err = sctp_primitive_SEND(asoc, datamsg);
1836 /* Did the lower layer accept the chunk? */
1837 if (err)
1838 sctp_datamsg_free(datamsg);
1839 else
1840 sctp_datamsg_put(datamsg);
1841
1842 SCTP_DEBUG_PRINTK("We sent primitively.\n");
1843
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 if (err)
1845 goto out_free;
1846 else
1847 err = msg_len;
1848
1849 /* If we are already past ASSOCIATE, the lower
1850 * layers are responsible for association cleanup.
1851 */
1852 goto out_unlock;
1853
1854out_free:
1855 if (new_asoc)
1856 sctp_association_free(asoc);
1857out_unlock:
1858 sctp_release_sock(sk);
1859
1860out_nounlock:
1861 return sctp_error(sk, msg_flags, err);
1862
1863#if 0
1864do_sock_err:
1865 if (msg_len)
1866 err = msg_len;
1867 else
1868 err = sock_error(sk);
1869 goto out;
1870
1871do_interrupted:
1872 if (msg_len)
1873 err = msg_len;
1874 goto out;
1875#endif /* 0 */
1876}
1877
1878/* This is an extended version of skb_pull() that removes the data from the
1879 * start of a skb even when data is spread across the list of skb's in the
1880 * frag_list. len specifies the total amount of data that needs to be removed.
1881 * when 'len' bytes could be removed from the skb, it returns 0.
1882 * If 'len' exceeds the total skb length, it returns the no. of bytes that
1883 * could not be removed.
1884 */
1885static int sctp_skb_pull(struct sk_buff *skb, int len)
1886{
1887 struct sk_buff *list;
1888 int skb_len = skb_headlen(skb);
1889 int rlen;
1890
1891 if (len <= skb_len) {
1892 __skb_pull(skb, len);
1893 return 0;
1894 }
1895 len -= skb_len;
1896 __skb_pull(skb, skb_len);
1897
David S. Miller1b003be2009-06-09 00:22:35 -07001898 skb_walk_frags(skb, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 rlen = sctp_skb_pull(list, len);
1900 skb->len -= (len-rlen);
1901 skb->data_len -= (len-rlen);
1902
1903 if (!rlen)
1904 return 0;
1905
1906 len = rlen;
1907 }
1908
1909 return len;
1910}
1911
1912/* API 3.1.3 recvmsg() - UDP Style Syntax
1913 *
1914 * ssize_t recvmsg(int socket, struct msghdr *message,
1915 * int flags);
1916 *
1917 * socket - the socket descriptor of the endpoint.
1918 * message - pointer to the msghdr structure which contains a single
1919 * user message and possibly some ancillary data.
1920 *
1921 * See Section 5 for complete description of the data
1922 * structures.
1923 *
1924 * flags - flags sent or received with the user message, see Section
1925 * 5 for complete description of the flags.
1926 */
1927static struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *);
1928
1929SCTP_STATIC int sctp_recvmsg(struct kiocb *iocb, struct sock *sk,
1930 struct msghdr *msg, size_t len, int noblock,
1931 int flags, int *addr_len)
1932{
1933 struct sctp_ulpevent *event = NULL;
1934 struct sctp_sock *sp = sctp_sk(sk);
1935 struct sk_buff *skb;
1936 int copied;
1937 int err = 0;
1938 int skb_len;
1939
1940 SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: "
1941 "0x%x, %s: %p)\n", "sk", sk, "msghdr", msg,
1942 "len", len, "knoblauch", noblock,
1943 "flags", flags, "addr_len", addr_len);
1944
1945 sctp_lock_sock(sk);
1946
1947 if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) {
1948 err = -ENOTCONN;
1949 goto out;
1950 }
1951
1952 skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
1953 if (!skb)
1954 goto out;
1955
1956 /* Get the total length of the skb including any skb's in the
1957 * frag_list.
1958 */
1959 skb_len = skb->len;
1960
1961 copied = skb_len;
1962 if (copied > len)
1963 copied = len;
1964
1965 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1966
1967 event = sctp_skb2event(skb);
1968
1969 if (err)
1970 goto out_free;
1971
Neil Horman3b885782009-10-12 13:26:31 -07001972 sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 if (sctp_ulpevent_is_notification(event)) {
1974 msg->msg_flags |= MSG_NOTIFICATION;
1975 sp->pf->event_msgname(event, msg->msg_name, addr_len);
1976 } else {
1977 sp->pf->skb_msgname(skb, msg->msg_name, addr_len);
1978 }
1979
1980 /* Check if we allow SCTP_SNDRCVINFO. */
1981 if (sp->subscribe.sctp_data_io_event)
1982 sctp_ulpevent_read_sndrcvinfo(event, msg);
1983#if 0
1984 /* FIXME: we should be calling IP/IPv6 layers. */
1985 if (sk->sk_protinfo.af_inet.cmsg_flags)
1986 ip_cmsg_recv(msg, skb);
1987#endif
1988
1989 err = copied;
1990
1991 /* If skb's length exceeds the user's buffer, update the skb and
1992 * push it back to the receive_queue so that the next call to
1993 * recvmsg() will return the remaining data. Don't set MSG_EOR.
1994 */
1995 if (skb_len > copied) {
1996 msg->msg_flags &= ~MSG_EOR;
1997 if (flags & MSG_PEEK)
1998 goto out_free;
1999 sctp_skb_pull(skb, copied);
2000 skb_queue_head(&sk->sk_receive_queue, skb);
2001
2002 /* When only partial message is copied to the user, increase
2003 * rwnd by that amount. If all the data in the skb is read,
2004 * rwnd is updated when the event is freed.
2005 */
Vlad Yasevich0eca8fe2008-01-11 10:12:56 -05002006 if (!sctp_ulpevent_is_notification(event))
2007 sctp_assoc_rwnd_increase(event->asoc, copied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 goto out;
2009 } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2010 (event->msg_flags & MSG_EOR))
2011 msg->msg_flags |= MSG_EOR;
2012 else
2013 msg->msg_flags &= ~MSG_EOR;
2014
2015out_free:
2016 if (flags & MSG_PEEK) {
2017 /* Release the skb reference acquired after peeking the skb in
2018 * sctp_skb_recv_datagram().
2019 */
2020 kfree_skb(skb);
2021 } else {
2022 /* Free the event which includes releasing the reference to
2023 * the owner of the skb, freeing the skb and updating the
2024 * rwnd.
2025 */
2026 sctp_ulpevent_free(event);
2027 }
2028out:
2029 sctp_release_sock(sk);
2030 return err;
2031}
2032
2033/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2034 *
2035 * This option is a on/off flag. If enabled no SCTP message
2036 * fragmentation will be performed. Instead if a message being sent
2037 * exceeds the current PMTU size, the message will NOT be sent and
2038 * instead a error will be indicated to the user.
2039 */
2040static int sctp_setsockopt_disable_fragments(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07002041 char __user *optval,
2042 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043{
2044 int val;
2045
2046 if (optlen < sizeof(int))
2047 return -EINVAL;
2048
2049 if (get_user(val, (int __user *)optval))
2050 return -EFAULT;
2051
2052 sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
2053
2054 return 0;
2055}
2056
2057static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002058 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059{
Vlad Yasevich7e8616d2008-02-27 16:04:52 -05002060 if (optlen > sizeof(struct sctp_event_subscribe))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 return -EINVAL;
2062 if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
2063 return -EFAULT;
2064 return 0;
2065}
2066
2067/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2068 *
2069 * This socket option is applicable to the UDP-style socket only. When
2070 * set it will cause associations that are idle for more than the
2071 * specified number of seconds to automatically close. An association
2072 * being idle is defined an association that has NOT sent or received
2073 * user data. The special value of '0' indicates that no automatic
2074 * close of any associations should be performed. The option expects an
2075 * integer defining the number of seconds of idle time before an
2076 * association is closed.
2077 */
2078static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002079 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080{
2081 struct sctp_sock *sp = sctp_sk(sk);
2082
2083 /* Applicable to UDP-style socket only */
2084 if (sctp_style(sk, TCP))
2085 return -EOPNOTSUPP;
2086 if (optlen != sizeof(int))
2087 return -EINVAL;
2088 if (copy_from_user(&sp->autoclose, optval, optlen))
2089 return -EFAULT;
Andrei Pelinescu-Onciulf6778aa2009-11-23 15:54:01 -05002090 /* make sure it won't exceed MAX_SCHEDULE_TIMEOUT */
Andrew Morton8ffd3202009-12-21 14:25:06 +00002091 sp->autoclose = min_t(long, sp->autoclose, MAX_SCHEDULE_TIMEOUT / HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 return 0;
2094}
2095
2096/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2097 *
2098 * Applications can enable or disable heartbeats for any peer address of
2099 * an association, modify an address's heartbeat interval, force a
2100 * heartbeat to be sent immediately, and adjust the address's maximum
2101 * number of retransmissions sent before an address is considered
2102 * unreachable. The following structure is used to access and modify an
2103 * address's parameters:
2104 *
2105 * struct sctp_paddrparams {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002106 * sctp_assoc_t spp_assoc_id;
2107 * struct sockaddr_storage spp_address;
2108 * uint32_t spp_hbinterval;
2109 * uint16_t spp_pathmaxrxt;
2110 * uint32_t spp_pathmtu;
2111 * uint32_t spp_sackdelay;
2112 * uint32_t spp_flags;
2113 * };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 *
Frank Filz52ccb8e2005-12-22 11:36:46 -08002115 * spp_assoc_id - (one-to-many style socket) This is filled in the
2116 * application, and identifies the association for
2117 * this query.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 * spp_address - This specifies which address is of interest.
2119 * spp_hbinterval - This contains the value of the heartbeat interval,
Frank Filz52ccb8e2005-12-22 11:36:46 -08002120 * in milliseconds. If a value of zero
2121 * is present in this field then no changes are to
2122 * be made to this parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 * spp_pathmaxrxt - This contains the maximum number of
2124 * retransmissions before this address shall be
Frank Filz52ccb8e2005-12-22 11:36:46 -08002125 * considered unreachable. If a value of zero
2126 * is present in this field then no changes are to
2127 * be made to this parameter.
2128 * spp_pathmtu - When Path MTU discovery is disabled the value
2129 * specified here will be the "fixed" path mtu.
2130 * Note that if the spp_address field is empty
2131 * then all associations on this address will
2132 * have this fixed path mtu set upon them.
2133 *
2134 * spp_sackdelay - When delayed sack is enabled, this value specifies
2135 * the number of milliseconds that sacks will be delayed
2136 * for. This value will apply to all addresses of an
2137 * association if the spp_address field is empty. Note
2138 * also, that if delayed sack is enabled and this
2139 * value is set to 0, no change is made to the last
2140 * recorded delayed sack timer value.
2141 *
2142 * spp_flags - These flags are used to control various features
2143 * on an association. The flag field may contain
2144 * zero or more of the following options.
2145 *
2146 * SPP_HB_ENABLE - Enable heartbeats on the
2147 * specified address. Note that if the address
2148 * field is empty all addresses for the association
2149 * have heartbeats enabled upon them.
2150 *
2151 * SPP_HB_DISABLE - Disable heartbeats on the
2152 * speicifed address. Note that if the address
2153 * field is empty all addresses for the association
2154 * will have their heartbeats disabled. Note also
2155 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2156 * mutually exclusive, only one of these two should
2157 * be specified. Enabling both fields will have
2158 * undetermined results.
2159 *
2160 * SPP_HB_DEMAND - Request a user initiated heartbeat
2161 * to be made immediately.
2162 *
Vlad Yasevichbdf30922007-03-23 11:33:12 -07002163 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2164 * heartbeat delayis to be set to the value of 0
2165 * milliseconds.
2166 *
Frank Filz52ccb8e2005-12-22 11:36:46 -08002167 * SPP_PMTUD_ENABLE - This field will enable PMTU
2168 * discovery upon the specified address. Note that
2169 * if the address feild is empty then all addresses
2170 * on the association are effected.
2171 *
2172 * SPP_PMTUD_DISABLE - This field will disable PMTU
2173 * discovery upon the specified address. Note that
2174 * if the address feild is empty then all addresses
2175 * on the association are effected. Not also that
2176 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2177 * exclusive. Enabling both will have undetermined
2178 * results.
2179 *
2180 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2181 * on delayed sack. The time specified in spp_sackdelay
2182 * is used to specify the sack delay for this address. Note
2183 * that if spp_address is empty then all addresses will
2184 * enable delayed sack and take on the sack delay
2185 * value specified in spp_sackdelay.
2186 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2187 * off delayed sack. If the spp_address field is blank then
2188 * delayed sack is disabled for the entire association. Note
2189 * also that this field is mutually exclusive to
2190 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2191 * results.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 */
Adrian Bunk16164362006-09-18 00:40:38 -07002193static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2194 struct sctp_transport *trans,
2195 struct sctp_association *asoc,
2196 struct sctp_sock *sp,
2197 int hb_change,
2198 int pmtud_change,
2199 int sackdelay_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 int error;
2202
Frank Filz52ccb8e2005-12-22 11:36:46 -08002203 if (params->spp_flags & SPP_HB_DEMAND && trans) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans);
2205 if (error)
2206 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 }
2208
Vlad Yasevichbdf30922007-03-23 11:33:12 -07002209 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2210 * this field is ignored. Note also that a value of zero indicates
2211 * the current setting should be left unchanged.
2212 */
2213 if (params->spp_flags & SPP_HB_ENABLE) {
2214
2215 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2216 * set. This lets us use 0 value when this flag
2217 * is set.
2218 */
2219 if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2220 params->spp_hbinterval = 0;
2221
2222 if (params->spp_hbinterval ||
2223 (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2224 if (trans) {
2225 trans->hbinterval =
2226 msecs_to_jiffies(params->spp_hbinterval);
2227 } else if (asoc) {
2228 asoc->hbinterval =
2229 msecs_to_jiffies(params->spp_hbinterval);
2230 } else {
2231 sp->hbinterval = params->spp_hbinterval;
2232 }
Frank Filz52ccb8e2005-12-22 11:36:46 -08002233 }
2234 }
2235
2236 if (hb_change) {
2237 if (trans) {
2238 trans->param_flags =
2239 (trans->param_flags & ~SPP_HB) | hb_change;
2240 } else if (asoc) {
2241 asoc->param_flags =
2242 (asoc->param_flags & ~SPP_HB) | hb_change;
2243 } else {
2244 sp->param_flags =
2245 (sp->param_flags & ~SPP_HB) | hb_change;
2246 }
2247 }
2248
Vlad Yasevichbdf30922007-03-23 11:33:12 -07002249 /* When Path MTU discovery is disabled the value specified here will
2250 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2251 * include the flag SPP_PMTUD_DISABLE for this field to have any
2252 * effect).
2253 */
2254 if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002255 if (trans) {
2256 trans->pathmtu = params->spp_pathmtu;
2257 sctp_assoc_sync_pmtu(asoc);
2258 } else if (asoc) {
2259 asoc->pathmtu = params->spp_pathmtu;
Vlad Yasevichf68b2e02009-09-04 18:21:00 -04002260 sctp_frag_point(asoc, params->spp_pathmtu);
Frank Filz52ccb8e2005-12-22 11:36:46 -08002261 } else {
2262 sp->pathmtu = params->spp_pathmtu;
2263 }
2264 }
2265
2266 if (pmtud_change) {
2267 if (trans) {
2268 int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2269 (params->spp_flags & SPP_PMTUD_ENABLE);
2270 trans->param_flags =
2271 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2272 if (update) {
2273 sctp_transport_pmtu(trans);
2274 sctp_assoc_sync_pmtu(asoc);
2275 }
2276 } else if (asoc) {
2277 asoc->param_flags =
2278 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2279 } else {
2280 sp->param_flags =
2281 (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2282 }
2283 }
2284
Vlad Yasevichbdf30922007-03-23 11:33:12 -07002285 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2286 * value of this field is ignored. Note also that a value of zero
2287 * indicates the current setting should be left unchanged.
2288 */
2289 if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002290 if (trans) {
2291 trans->sackdelay =
2292 msecs_to_jiffies(params->spp_sackdelay);
2293 } else if (asoc) {
2294 asoc->sackdelay =
2295 msecs_to_jiffies(params->spp_sackdelay);
2296 } else {
2297 sp->sackdelay = params->spp_sackdelay;
2298 }
2299 }
2300
2301 if (sackdelay_change) {
2302 if (trans) {
2303 trans->param_flags =
2304 (trans->param_flags & ~SPP_SACKDELAY) |
2305 sackdelay_change;
2306 } else if (asoc) {
2307 asoc->param_flags =
2308 (asoc->param_flags & ~SPP_SACKDELAY) |
2309 sackdelay_change;
2310 } else {
2311 sp->param_flags =
2312 (sp->param_flags & ~SPP_SACKDELAY) |
2313 sackdelay_change;
2314 }
2315 }
2316
Andrei Pelinescu-Onciul37051f72009-11-23 15:53:57 -05002317 /* Note that a value of zero indicates the current setting should be
2318 left unchanged.
Vlad Yasevichbdf30922007-03-23 11:33:12 -07002319 */
Andrei Pelinescu-Onciul37051f72009-11-23 15:53:57 -05002320 if (params->spp_pathmaxrxt) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002321 if (trans) {
2322 trans->pathmaxrxt = params->spp_pathmaxrxt;
2323 } else if (asoc) {
2324 asoc->pathmaxrxt = params->spp_pathmaxrxt;
2325 } else {
2326 sp->pathmaxrxt = params->spp_pathmaxrxt;
2327 }
2328 }
2329
2330 return 0;
2331}
2332
2333static int sctp_setsockopt_peer_addr_params(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07002334 char __user *optval,
2335 unsigned int optlen)
Frank Filz52ccb8e2005-12-22 11:36:46 -08002336{
2337 struct sctp_paddrparams params;
2338 struct sctp_transport *trans = NULL;
2339 struct sctp_association *asoc = NULL;
2340 struct sctp_sock *sp = sctp_sk(sk);
2341 int error;
2342 int hb_change, pmtud_change, sackdelay_change;
2343
2344 if (optlen != sizeof(struct sctp_paddrparams))
2345 return - EINVAL;
2346
2347 if (copy_from_user(&params, optval, optlen))
2348 return -EFAULT;
2349
2350 /* Validate flags and value parameters. */
2351 hb_change = params.spp_flags & SPP_HB;
2352 pmtud_change = params.spp_flags & SPP_PMTUD;
2353 sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2354
2355 if (hb_change == SPP_HB ||
2356 pmtud_change == SPP_PMTUD ||
2357 sackdelay_change == SPP_SACKDELAY ||
2358 params.spp_sackdelay > 500 ||
Joe Perchesf64f9e72009-11-29 16:55:45 -08002359 (params.spp_pathmtu &&
2360 params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
Frank Filz52ccb8e2005-12-22 11:36:46 -08002361 return -EINVAL;
2362
2363 /* If an address other than INADDR_ANY is specified, and
2364 * no transport is found, then the request is invalid.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 */
Vlad Yasevich52cae8f2008-08-18 10:34:34 -04002366 if (!sctp_is_any(sk, ( union sctp_addr *)&params.spp_address)) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002367 trans = sctp_addr_id2transport(sk, &params.spp_address,
2368 params.spp_assoc_id);
2369 if (!trans)
2370 return -EINVAL;
2371 }
2372
2373 /* Get association, if assoc_id != 0 and the socket is a one
2374 * to many style socket, and an association was not found, then
2375 * the id was invalid.
2376 */
2377 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2378 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))
2379 return -EINVAL;
2380
2381 /* Heartbeat demand can only be sent on a transport or
2382 * association, but not a socket.
2383 */
2384 if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2385 return -EINVAL;
2386
2387 /* Process parameters. */
2388 error = sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2389 hb_change, pmtud_change,
2390 sackdelay_change);
2391
2392 if (error)
2393 return error;
2394
2395 /* If changes are for association, also apply parameters to each
2396 * transport.
2397 */
2398 if (!trans && asoc) {
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07002399 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2400 transports) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08002401 sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2402 hb_change, pmtud_change,
2403 sackdelay_change);
2404 }
2405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406
2407 return 0;
2408}
2409
Wei Yongjund364d922008-05-09 15:13:26 -07002410/*
2411 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
Frank Filz77086102005-12-22 11:37:30 -08002412 *
Wei Yongjund364d922008-05-09 15:13:26 -07002413 * This option will effect the way delayed acks are performed. This
2414 * option allows you to get or set the delayed ack time, in
2415 * milliseconds. It also allows changing the delayed ack frequency.
2416 * Changing the frequency to 1 disables the delayed sack algorithm. If
2417 * the assoc_id is 0, then this sets or gets the endpoints default
2418 * values. If the assoc_id field is non-zero, then the set or get
2419 * effects the specified association for the one to many model (the
2420 * assoc_id field is ignored by the one to one model). Note that if
2421 * sack_delay or sack_freq are 0 when setting this option, then the
2422 * current values will remain unchanged.
Frank Filz77086102005-12-22 11:37:30 -08002423 *
Wei Yongjund364d922008-05-09 15:13:26 -07002424 * struct sctp_sack_info {
2425 * sctp_assoc_t sack_assoc_id;
2426 * uint32_t sack_delay;
2427 * uint32_t sack_freq;
2428 * };
Frank Filz77086102005-12-22 11:37:30 -08002429 *
Wei Yongjund364d922008-05-09 15:13:26 -07002430 * sack_assoc_id - This parameter, indicates which association the user
2431 * is performing an action upon. Note that if this field's value is
2432 * zero then the endpoints default value is changed (effecting future
2433 * associations only).
Frank Filz77086102005-12-22 11:37:30 -08002434 *
Wei Yongjund364d922008-05-09 15:13:26 -07002435 * sack_delay - This parameter contains the number of milliseconds that
2436 * the user is requesting the delayed ACK timer be set to. Note that
2437 * this value is defined in the standard to be between 200 and 500
2438 * milliseconds.
Frank Filz77086102005-12-22 11:37:30 -08002439 *
Wei Yongjund364d922008-05-09 15:13:26 -07002440 * sack_freq - This parameter contains the number of packets that must
2441 * be received before a sack is sent without waiting for the delay
2442 * timer to expire. The default value for this is 2, setting this
2443 * value to 1 will disable the delayed sack algorithm.
Frank Filz77086102005-12-22 11:37:30 -08002444 */
2445
Wei Yongjund364d922008-05-09 15:13:26 -07002446static int sctp_setsockopt_delayed_ack(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07002447 char __user *optval, unsigned int optlen)
Frank Filz77086102005-12-22 11:37:30 -08002448{
Wei Yongjund364d922008-05-09 15:13:26 -07002449 struct sctp_sack_info params;
Frank Filz77086102005-12-22 11:37:30 -08002450 struct sctp_transport *trans = NULL;
2451 struct sctp_association *asoc = NULL;
2452 struct sctp_sock *sp = sctp_sk(sk);
2453
Wei Yongjund364d922008-05-09 15:13:26 -07002454 if (optlen == sizeof(struct sctp_sack_info)) {
2455 if (copy_from_user(&params, optval, optlen))
2456 return -EFAULT;
2457
2458 if (params.sack_delay == 0 && params.sack_freq == 0)
2459 return 0;
2460 } else if (optlen == sizeof(struct sctp_assoc_value)) {
Wei Yongjunea686a22008-12-25 16:56:45 -08002461 printk(KERN_WARNING "SCTP: Use of struct sctp_assoc_value "
Wei Yongjund364d922008-05-09 15:13:26 -07002462 "in delayed_ack socket option deprecated\n");
Wei Yongjunea686a22008-12-25 16:56:45 -08002463 printk(KERN_WARNING "SCTP: Use struct sctp_sack_info instead\n");
Wei Yongjund364d922008-05-09 15:13:26 -07002464 if (copy_from_user(&params, optval, optlen))
2465 return -EFAULT;
2466
2467 if (params.sack_delay == 0)
2468 params.sack_freq = 1;
2469 else
2470 params.sack_freq = 0;
2471 } else
Frank Filz77086102005-12-22 11:37:30 -08002472 return - EINVAL;
2473
Frank Filz77086102005-12-22 11:37:30 -08002474 /* Validate value parameter. */
Wei Yongjund364d922008-05-09 15:13:26 -07002475 if (params.sack_delay > 500)
Frank Filz77086102005-12-22 11:37:30 -08002476 return -EINVAL;
2477
Wei Yongjund364d922008-05-09 15:13:26 -07002478 /* Get association, if sack_assoc_id != 0 and the socket is a one
Frank Filz77086102005-12-22 11:37:30 -08002479 * to many style socket, and an association was not found, then
2480 * the id was invalid.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002481 */
Wei Yongjund364d922008-05-09 15:13:26 -07002482 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
2483 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
Frank Filz77086102005-12-22 11:37:30 -08002484 return -EINVAL;
2485
Wei Yongjund364d922008-05-09 15:13:26 -07002486 if (params.sack_delay) {
Frank Filz77086102005-12-22 11:37:30 -08002487 if (asoc) {
2488 asoc->sackdelay =
Wei Yongjund364d922008-05-09 15:13:26 -07002489 msecs_to_jiffies(params.sack_delay);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002490 asoc->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002491 (asoc->param_flags & ~SPP_SACKDELAY) |
2492 SPP_SACKDELAY_ENABLE;
2493 } else {
Wei Yongjund364d922008-05-09 15:13:26 -07002494 sp->sackdelay = params.sack_delay;
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002495 sp->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002496 (sp->param_flags & ~SPP_SACKDELAY) |
2497 SPP_SACKDELAY_ENABLE;
2498 }
Wei Yongjund364d922008-05-09 15:13:26 -07002499 }
2500
2501 if (params.sack_freq == 1) {
Frank Filz77086102005-12-22 11:37:30 -08002502 if (asoc) {
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002503 asoc->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002504 (asoc->param_flags & ~SPP_SACKDELAY) |
2505 SPP_SACKDELAY_DISABLE;
2506 } else {
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002507 sp->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002508 (sp->param_flags & ~SPP_SACKDELAY) |
2509 SPP_SACKDELAY_DISABLE;
2510 }
Wei Yongjund364d922008-05-09 15:13:26 -07002511 } else if (params.sack_freq > 1) {
2512 if (asoc) {
2513 asoc->sackfreq = params.sack_freq;
2514 asoc->param_flags =
2515 (asoc->param_flags & ~SPP_SACKDELAY) |
2516 SPP_SACKDELAY_ENABLE;
2517 } else {
2518 sp->sackfreq = params.sack_freq;
2519 sp->param_flags =
2520 (sp->param_flags & ~SPP_SACKDELAY) |
2521 SPP_SACKDELAY_ENABLE;
2522 }
Frank Filz77086102005-12-22 11:37:30 -08002523 }
2524
2525 /* If change is for association, also apply to each transport. */
2526 if (asoc) {
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07002527 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2528 transports) {
Wei Yongjund364d922008-05-09 15:13:26 -07002529 if (params.sack_delay) {
Frank Filz77086102005-12-22 11:37:30 -08002530 trans->sackdelay =
Wei Yongjund364d922008-05-09 15:13:26 -07002531 msecs_to_jiffies(params.sack_delay);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002532 trans->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002533 (trans->param_flags & ~SPP_SACKDELAY) |
2534 SPP_SACKDELAY_ENABLE;
Wei Yongjund364d922008-05-09 15:13:26 -07002535 }
Vlad Yasevich7bfe8bd2008-06-09 15:45:05 -07002536 if (params.sack_freq == 1) {
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002537 trans->param_flags =
Frank Filz77086102005-12-22 11:37:30 -08002538 (trans->param_flags & ~SPP_SACKDELAY) |
2539 SPP_SACKDELAY_DISABLE;
Wei Yongjund364d922008-05-09 15:13:26 -07002540 } else if (params.sack_freq > 1) {
2541 trans->sackfreq = params.sack_freq;
2542 trans->param_flags =
2543 (trans->param_flags & ~SPP_SACKDELAY) |
2544 SPP_SACKDELAY_ENABLE;
Frank Filz77086102005-12-22 11:37:30 -08002545 }
2546 }
2547 }
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002548
Frank Filz77086102005-12-22 11:37:30 -08002549 return 0;
2550}
2551
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2553 *
2554 * Applications can specify protocol parameters for the default association
2555 * initialization. The option name argument to setsockopt() and getsockopt()
2556 * is SCTP_INITMSG.
2557 *
2558 * Setting initialization parameters is effective only on an unconnected
2559 * socket (for UDP-style sockets only future associations are effected
2560 * by the change). With TCP-style sockets, this option is inherited by
2561 * sockets derived from a listener socket.
2562 */
David S. Millerb7058842009-09-30 16:12:20 -07002563static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564{
2565 struct sctp_initmsg sinit;
2566 struct sctp_sock *sp = sctp_sk(sk);
2567
2568 if (optlen != sizeof(struct sctp_initmsg))
2569 return -EINVAL;
2570 if (copy_from_user(&sinit, optval, optlen))
2571 return -EFAULT;
2572
2573 if (sinit.sinit_num_ostreams)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002574 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 if (sinit.sinit_max_instreams)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002576 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 if (sinit.sinit_max_attempts)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002578 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 if (sinit.sinit_max_init_timeo)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002580 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581
2582 return 0;
2583}
2584
2585/*
2586 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2587 *
2588 * Applications that wish to use the sendto() system call may wish to
2589 * specify a default set of parameters that would normally be supplied
2590 * through the inclusion of ancillary data. This socket option allows
2591 * such an application to set the default sctp_sndrcvinfo structure.
2592 * The application that wishes to use this socket option simply passes
2593 * in to this call the sctp_sndrcvinfo structure defined in Section
2594 * 5.2.2) The input parameters accepted by this call include
2595 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2596 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2597 * to this call if the caller is using the UDP model.
2598 */
2599static int sctp_setsockopt_default_send_param(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07002600 char __user *optval,
2601 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602{
2603 struct sctp_sndrcvinfo info;
2604 struct sctp_association *asoc;
2605 struct sctp_sock *sp = sctp_sk(sk);
2606
2607 if (optlen != sizeof(struct sctp_sndrcvinfo))
2608 return -EINVAL;
2609 if (copy_from_user(&info, optval, optlen))
2610 return -EFAULT;
2611
2612 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2613 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
2614 return -EINVAL;
2615
2616 if (asoc) {
2617 asoc->default_stream = info.sinfo_stream;
2618 asoc->default_flags = info.sinfo_flags;
2619 asoc->default_ppid = info.sinfo_ppid;
2620 asoc->default_context = info.sinfo_context;
2621 asoc->default_timetolive = info.sinfo_timetolive;
2622 } else {
2623 sp->default_stream = info.sinfo_stream;
2624 sp->default_flags = info.sinfo_flags;
2625 sp->default_ppid = info.sinfo_ppid;
2626 sp->default_context = info.sinfo_context;
2627 sp->default_timetolive = info.sinfo_timetolive;
2628 }
2629
2630 return 0;
2631}
2632
2633/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
2634 *
2635 * Requests that the local SCTP stack use the enclosed peer address as
2636 * the association primary. The enclosed address must be one of the
2637 * association peer's addresses.
2638 */
2639static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002640 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641{
2642 struct sctp_prim prim;
2643 struct sctp_transport *trans;
2644
2645 if (optlen != sizeof(struct sctp_prim))
2646 return -EINVAL;
2647
2648 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
2649 return -EFAULT;
2650
2651 trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
2652 if (!trans)
2653 return -EINVAL;
2654
2655 sctp_assoc_set_primary(trans->asoc, trans);
2656
2657 return 0;
2658}
2659
2660/*
2661 * 7.1.5 SCTP_NODELAY
2662 *
2663 * Turn on/off any Nagle-like algorithm. This means that packets are
2664 * generally sent as soon as possible and no unnecessary delays are
2665 * introduced, at the cost of more packets in the network. Expects an
2666 * integer boolean flag.
2667 */
2668static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002669 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670{
2671 int val;
2672
2673 if (optlen < sizeof(int))
2674 return -EINVAL;
2675 if (get_user(val, (int __user *)optval))
2676 return -EFAULT;
2677
2678 sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
2679 return 0;
2680}
2681
2682/*
2683 *
2684 * 7.1.1 SCTP_RTOINFO
2685 *
2686 * The protocol parameters used to initialize and bound retransmission
2687 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
2688 * and modify these parameters.
2689 * All parameters are time values, in milliseconds. A value of 0, when
2690 * modifying the parameters, indicates that the current value should not
2691 * be changed.
2692 *
2693 */
David S. Millerb7058842009-09-30 16:12:20 -07002694static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen)
2695{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 struct sctp_rtoinfo rtoinfo;
2697 struct sctp_association *asoc;
2698
2699 if (optlen != sizeof (struct sctp_rtoinfo))
2700 return -EINVAL;
2701
2702 if (copy_from_user(&rtoinfo, optval, optlen))
2703 return -EFAULT;
2704
2705 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
2706
2707 /* Set the values to the specific association */
2708 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
2709 return -EINVAL;
2710
2711 if (asoc) {
2712 if (rtoinfo.srto_initial != 0)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002713 asoc->rto_initial =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 msecs_to_jiffies(rtoinfo.srto_initial);
2715 if (rtoinfo.srto_max != 0)
2716 asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max);
2717 if (rtoinfo.srto_min != 0)
2718 asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min);
2719 } else {
2720 /* If there is no association or the association-id = 0
2721 * set the values to the endpoint.
2722 */
2723 struct sctp_sock *sp = sctp_sk(sk);
2724
2725 if (rtoinfo.srto_initial != 0)
2726 sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
2727 if (rtoinfo.srto_max != 0)
2728 sp->rtoinfo.srto_max = rtoinfo.srto_max;
2729 if (rtoinfo.srto_min != 0)
2730 sp->rtoinfo.srto_min = rtoinfo.srto_min;
2731 }
2732
2733 return 0;
2734}
2735
2736/*
2737 *
2738 * 7.1.2 SCTP_ASSOCINFO
2739 *
Michael Opdenacker59c51592007-05-09 08:57:56 +02002740 * This option is used to tune the maximum retransmission attempts
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 * of the association.
2742 * Returns an error if the new association retransmission value is
2743 * greater than the sum of the retransmission value of the peer.
2744 * See [SCTP] for more information.
2745 *
2746 */
David S. Millerb7058842009-09-30 16:12:20 -07002747static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748{
2749
2750 struct sctp_assocparams assocparams;
2751 struct sctp_association *asoc;
2752
2753 if (optlen != sizeof(struct sctp_assocparams))
2754 return -EINVAL;
2755 if (copy_from_user(&assocparams, optval, optlen))
2756 return -EFAULT;
2757
2758 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
2759
2760 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
2761 return -EINVAL;
2762
2763 /* Set the values to the specific association */
2764 if (asoc) {
Vlad Yasevich402d68c2006-06-17 22:54:51 -07002765 if (assocparams.sasoc_asocmaxrxt != 0) {
2766 __u32 path_sum = 0;
2767 int paths = 0;
Vlad Yasevich402d68c2006-06-17 22:54:51 -07002768 struct sctp_transport *peer_addr;
2769
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07002770 list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
2771 transports) {
Vlad Yasevich402d68c2006-06-17 22:54:51 -07002772 path_sum += peer_addr->pathmaxrxt;
2773 paths++;
2774 }
2775
Frederik Schwarzer025dfda2008-10-16 19:02:37 +02002776 /* Only validate asocmaxrxt if we have more than
Vlad Yasevich402d68c2006-06-17 22:54:51 -07002777 * one path/transport. We do this because path
2778 * retransmissions are only counted when we have more
2779 * then one path.
2780 */
2781 if (paths > 1 &&
2782 assocparams.sasoc_asocmaxrxt > path_sum)
2783 return -EINVAL;
2784
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
Vlad Yasevich402d68c2006-06-17 22:54:51 -07002786 }
2787
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 if (assocparams.sasoc_cookie_life != 0) {
2789 asoc->cookie_life.tv_sec =
2790 assocparams.sasoc_cookie_life / 1000;
2791 asoc->cookie_life.tv_usec =
2792 (assocparams.sasoc_cookie_life % 1000)
2793 * 1000;
2794 }
2795 } else {
2796 /* Set the values to the endpoint */
2797 struct sctp_sock *sp = sctp_sk(sk);
2798
2799 if (assocparams.sasoc_asocmaxrxt != 0)
2800 sp->assocparams.sasoc_asocmaxrxt =
2801 assocparams.sasoc_asocmaxrxt;
2802 if (assocparams.sasoc_cookie_life != 0)
2803 sp->assocparams.sasoc_cookie_life =
2804 assocparams.sasoc_cookie_life;
2805 }
2806 return 0;
2807}
2808
2809/*
2810 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
2811 *
2812 * This socket option is a boolean flag which turns on or off mapped V4
2813 * addresses. If this option is turned on and the socket is type
2814 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
2815 * If this option is turned off, then no mapping will be done of V4
2816 * addresses and a user will receive both PF_INET6 and PF_INET type
2817 * addresses on the socket.
2818 */
David S. Millerb7058842009-09-30 16:12:20 -07002819static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820{
2821 int val;
2822 struct sctp_sock *sp = sctp_sk(sk);
2823
2824 if (optlen < sizeof(int))
2825 return -EINVAL;
2826 if (get_user(val, (int __user *)optval))
2827 return -EFAULT;
2828 if (val)
2829 sp->v4mapped = 1;
2830 else
2831 sp->v4mapped = 0;
2832
2833 return 0;
2834}
2835
2836/*
Wei Yongjune89c2092008-12-25 16:54:58 -08002837 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
2838 * This option will get or set the maximum size to put in any outgoing
2839 * SCTP DATA chunk. If a message is larger than this size it will be
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 * fragmented by SCTP into the specified size. Note that the underlying
2841 * SCTP implementation may fragment into smaller sized chunks when the
2842 * PMTU of the underlying association is smaller than the value set by
Wei Yongjune89c2092008-12-25 16:54:58 -08002843 * the user. The default value for this option is '0' which indicates
2844 * the user is NOT limiting fragmentation and only the PMTU will effect
2845 * SCTP's choice of DATA chunk size. Note also that values set larger
2846 * than the maximum size of an IP datagram will effectively let SCTP
2847 * control fragmentation (i.e. the same as setting this option to 0).
2848 *
2849 * The following structure is used to access and modify this parameter:
2850 *
2851 * struct sctp_assoc_value {
2852 * sctp_assoc_t assoc_id;
2853 * uint32_t assoc_value;
2854 * };
2855 *
2856 * assoc_id: This parameter is ignored for one-to-one style sockets.
2857 * For one-to-many style sockets this parameter indicates which
2858 * association the user is performing an action upon. Note that if
2859 * this field's value is zero then the endpoints default value is
2860 * changed (effecting future associations only).
2861 * assoc_value: This parameter specifies the maximum size in bytes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 */
David S. Millerb7058842009-09-30 16:12:20 -07002863static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864{
Wei Yongjune89c2092008-12-25 16:54:58 -08002865 struct sctp_assoc_value params;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 struct sctp_association *asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 struct sctp_sock *sp = sctp_sk(sk);
2868 int val;
2869
Wei Yongjune89c2092008-12-25 16:54:58 -08002870 if (optlen == sizeof(int)) {
2871 printk(KERN_WARNING
2872 "SCTP: Use of int in maxseg socket option deprecated\n");
2873 printk(KERN_WARNING
2874 "SCTP: Use struct sctp_assoc_value instead\n");
2875 if (copy_from_user(&val, optval, optlen))
2876 return -EFAULT;
2877 params.assoc_id = 0;
2878 } else if (optlen == sizeof(struct sctp_assoc_value)) {
2879 if (copy_from_user(&params, optval, optlen))
2880 return -EFAULT;
2881 val = params.assoc_value;
2882 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 return -EINVAL;
Wei Yongjune89c2092008-12-25 16:54:58 -08002884
Ivan Skytte Jorgensen96a33992005-10-28 15:36:12 -07002885 if ((val != 0) && ((val < 8) || (val > SCTP_MAX_CHUNK_LEN)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887
Wei Yongjune89c2092008-12-25 16:54:58 -08002888 asoc = sctp_id2assoc(sk, params.assoc_id);
2889 if (!asoc && params.assoc_id && sctp_style(sk, UDP))
2890 return -EINVAL;
2891
2892 if (asoc) {
2893 if (val == 0) {
2894 val = asoc->pathmtu;
2895 val -= sp->pf->af->net_header_len;
2896 val -= sizeof(struct sctphdr) +
2897 sizeof(struct sctp_data_chunk);
2898 }
Vlad Yasevichf68b2e02009-09-04 18:21:00 -04002899 asoc->user_frag = val;
2900 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
Wei Yongjune89c2092008-12-25 16:54:58 -08002901 } else {
2902 sp->user_frag = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 }
2904
2905 return 0;
2906}
2907
2908
2909/*
2910 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
2911 *
2912 * Requests that the peer mark the enclosed address as the association
2913 * primary. The enclosed address must be one of the association's
2914 * locally bound addresses. The following structure is used to make a
2915 * set primary request:
2916 */
2917static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002918 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919{
2920 struct sctp_sock *sp;
2921 struct sctp_endpoint *ep;
2922 struct sctp_association *asoc = NULL;
2923 struct sctp_setpeerprim prim;
2924 struct sctp_chunk *chunk;
2925 int err;
2926
2927 sp = sctp_sk(sk);
2928 ep = sp->ep;
2929
2930 if (!sctp_addip_enable)
2931 return -EPERM;
2932
2933 if (optlen != sizeof(struct sctp_setpeerprim))
2934 return -EINVAL;
2935
2936 if (copy_from_user(&prim, optval, optlen))
2937 return -EFAULT;
2938
2939 asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09002940 if (!asoc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 return -EINVAL;
2942
2943 if (!asoc->peer.asconf_capable)
2944 return -EPERM;
2945
2946 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
2947 return -EPERM;
2948
2949 if (!sctp_state(asoc, ESTABLISHED))
2950 return -ENOTCONN;
2951
2952 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
2953 return -EADDRNOTAVAIL;
2954
2955 /* Create an ASCONF chunk with SET_PRIMARY parameter */
2956 chunk = sctp_make_asconf_set_prim(asoc,
2957 (union sctp_addr *)&prim.sspp_addr);
2958 if (!chunk)
2959 return -ENOMEM;
2960
2961 err = sctp_send_asconf(asoc, chunk);
2962
2963 SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n");
2964
2965 return err;
2966}
2967
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002968static int sctp_setsockopt_adaptation_layer(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002969 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970{
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002971 struct sctp_setadaptation adaptation;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002973 if (optlen != sizeof(struct sctp_setadaptation))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 return -EINVAL;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002975 if (copy_from_user(&adaptation, optval, optlen))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976 return -EFAULT;
2977
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08002978 sctp_sk(sk)->adaptation_ind = adaptation.ssb_adaptation_ind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979
2980 return 0;
2981}
2982
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08002983/*
2984 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
2985 *
2986 * The context field in the sctp_sndrcvinfo structure is normally only
2987 * used when a failed message is retrieved holding the value that was
2988 * sent down on the actual send call. This option allows the setting of
2989 * a default context on an association basis that will be received on
2990 * reading messages from the peer. This is especially helpful in the
2991 * one-2-many model for an application to keep some reference to an
2992 * internal state machine that is processing messages on the
2993 * association. Note that the setting of this value only effects
2994 * received messages from the peer and does not effect the value that is
2995 * saved with outbound messages.
2996 */
2997static int sctp_setsockopt_context(struct sock *sk, char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07002998 unsigned int optlen)
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08002999{
3000 struct sctp_assoc_value params;
3001 struct sctp_sock *sp;
3002 struct sctp_association *asoc;
3003
3004 if (optlen != sizeof(struct sctp_assoc_value))
3005 return -EINVAL;
3006 if (copy_from_user(&params, optval, optlen))
3007 return -EFAULT;
3008
3009 sp = sctp_sk(sk);
3010
3011 if (params.assoc_id != 0) {
3012 asoc = sctp_id2assoc(sk, params.assoc_id);
3013 if (!asoc)
3014 return -EINVAL;
3015 asoc->default_rcv_context = params.assoc_value;
3016 } else {
3017 sp->default_rcv_context = params.assoc_value;
3018 }
3019
3020 return 0;
3021}
3022
Vlad Yasevichb6e13312007-04-20 12:23:15 -07003023/*
3024 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3025 *
3026 * This options will at a minimum specify if the implementation is doing
3027 * fragmented interleave. Fragmented interleave, for a one to many
3028 * socket, is when subsequent calls to receive a message may return
3029 * parts of messages from different associations. Some implementations
3030 * may allow you to turn this value on or off. If so, when turned off,
3031 * no fragment interleave will occur (which will cause a head of line
3032 * blocking amongst multiple associations sharing the same one to many
3033 * socket). When this option is turned on, then each receive call may
3034 * come from a different association (thus the user must receive data
3035 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3036 * association each receive belongs to.
3037 *
3038 * This option takes a boolean value. A non-zero value indicates that
3039 * fragmented interleave is on. A value of zero indicates that
3040 * fragmented interleave is off.
3041 *
3042 * Note that it is important that an implementation that allows this
3043 * option to be turned on, have it off by default. Otherwise an unaware
3044 * application using the one to many model may become confused and act
3045 * incorrectly.
3046 */
3047static int sctp_setsockopt_fragment_interleave(struct sock *sk,
3048 char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07003049 unsigned int optlen)
Vlad Yasevichb6e13312007-04-20 12:23:15 -07003050{
3051 int val;
3052
3053 if (optlen != sizeof(int))
3054 return -EINVAL;
3055 if (get_user(val, (int __user *)optval))
3056 return -EFAULT;
3057
3058 sctp_sk(sk)->frag_interleave = (val == 0) ? 0 : 1;
3059
3060 return 0;
3061}
3062
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003063/*
Wei Yongjun8510b932008-12-25 16:59:03 -08003064 * 8.1.21. Set or Get the SCTP Partial Delivery Point
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003065 * (SCTP_PARTIAL_DELIVERY_POINT)
Wei Yongjun8510b932008-12-25 16:59:03 -08003066 *
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003067 * This option will set or get the SCTP partial delivery point. This
3068 * point is the size of a message where the partial delivery API will be
3069 * invoked to help free up rwnd space for the peer. Setting this to a
Wei Yongjun8510b932008-12-25 16:59:03 -08003070 * lower value will cause partial deliveries to happen more often. The
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003071 * calls argument is an integer that sets or gets the partial delivery
Wei Yongjun8510b932008-12-25 16:59:03 -08003072 * point. Note also that the call will fail if the user attempts to set
3073 * this value larger than the socket receive buffer size.
3074 *
3075 * Note that any single message having a length smaller than or equal to
3076 * the SCTP partial delivery point will be delivered in one single read
3077 * call as long as the user provided buffer is large enough to hold the
3078 * message.
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003079 */
3080static int sctp_setsockopt_partial_delivery_point(struct sock *sk,
3081 char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07003082 unsigned int optlen)
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003083{
3084 u32 val;
3085
3086 if (optlen != sizeof(u32))
3087 return -EINVAL;
3088 if (get_user(val, (int __user *)optval))
3089 return -EFAULT;
3090
Wei Yongjun8510b932008-12-25 16:59:03 -08003091 /* Note: We double the receive buffer from what the user sets
3092 * it to be, also initial rwnd is based on rcvbuf/2.
3093 */
3094 if (val > (sk->sk_rcvbuf >> 1))
3095 return -EINVAL;
3096
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003097 sctp_sk(sk)->pd_point = val;
3098
3099 return 0; /* is this the right error code? */
3100}
3101
Vlad Yasevich70331572007-03-23 11:34:36 -07003102/*
3103 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
3104 *
3105 * This option will allow a user to change the maximum burst of packets
3106 * that can be emitted by this association. Note that the default value
3107 * is 4, and some implementations may restrict this setting so that it
3108 * can only be lowered.
3109 *
3110 * NOTE: This text doesn't seem right. Do this on a socket basis with
3111 * future associations inheriting the socket value.
3112 */
3113static int sctp_setsockopt_maxburst(struct sock *sk,
3114 char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07003115 unsigned int optlen)
Vlad Yasevich70331572007-03-23 11:34:36 -07003116{
Neil Horman219b99a2008-03-05 13:44:46 -08003117 struct sctp_assoc_value params;
3118 struct sctp_sock *sp;
3119 struct sctp_association *asoc;
Vlad Yasevich70331572007-03-23 11:34:36 -07003120 int val;
Neil Horman219b99a2008-03-05 13:44:46 -08003121 int assoc_id = 0;
Vlad Yasevich70331572007-03-23 11:34:36 -07003122
Neil Horman219b99a2008-03-05 13:44:46 -08003123 if (optlen == sizeof(int)) {
3124 printk(KERN_WARNING
3125 "SCTP: Use of int in max_burst socket option deprecated\n");
3126 printk(KERN_WARNING
3127 "SCTP: Use struct sctp_assoc_value instead\n");
3128 if (copy_from_user(&val, optval, optlen))
3129 return -EFAULT;
3130 } else if (optlen == sizeof(struct sctp_assoc_value)) {
3131 if (copy_from_user(&params, optval, optlen))
3132 return -EFAULT;
3133 val = params.assoc_value;
3134 assoc_id = params.assoc_id;
3135 } else
3136 return -EINVAL;
3137
3138 sp = sctp_sk(sk);
3139
3140 if (assoc_id != 0) {
3141 asoc = sctp_id2assoc(sk, assoc_id);
3142 if (!asoc)
3143 return -EINVAL;
3144 asoc->max_burst = val;
3145 } else
3146 sp->max_burst = val;
Vlad Yasevich70331572007-03-23 11:34:36 -07003147
3148 return 0;
3149}
3150
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003151/*
3152 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3153 *
3154 * This set option adds a chunk type that the user is requesting to be
3155 * received only in an authenticated way. Changes to the list of chunks
3156 * will only effect future associations on the socket.
3157 */
3158static int sctp_setsockopt_auth_chunk(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07003159 char __user *optval,
3160 unsigned int optlen)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003161{
3162 struct sctp_authchunk val;
3163
Vlad Yasevich5e739d12008-08-21 03:34:25 -07003164 if (!sctp_auth_enable)
3165 return -EACCES;
3166
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003167 if (optlen != sizeof(struct sctp_authchunk))
3168 return -EINVAL;
3169 if (copy_from_user(&val, optval, optlen))
3170 return -EFAULT;
3171
3172 switch (val.sauth_chunk) {
3173 case SCTP_CID_INIT:
3174 case SCTP_CID_INIT_ACK:
3175 case SCTP_CID_SHUTDOWN_COMPLETE:
3176 case SCTP_CID_AUTH:
3177 return -EINVAL;
3178 }
3179
3180 /* add this chunk id to the endpoint */
3181 return sctp_auth_ep_add_chunkid(sctp_sk(sk)->ep, val.sauth_chunk);
3182}
3183
3184/*
3185 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3186 *
3187 * This option gets or sets the list of HMAC algorithms that the local
3188 * endpoint requires the peer to use.
3189 */
3190static int sctp_setsockopt_hmac_ident(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07003191 char __user *optval,
3192 unsigned int optlen)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003193{
3194 struct sctp_hmacalgo *hmacs;
Vlad Yasevichd9724052008-08-27 16:09:49 -07003195 u32 idents;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003196 int err;
3197
Vlad Yasevich5e739d12008-08-21 03:34:25 -07003198 if (!sctp_auth_enable)
3199 return -EACCES;
3200
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003201 if (optlen < sizeof(struct sctp_hmacalgo))
3202 return -EINVAL;
3203
3204 hmacs = kmalloc(optlen, GFP_KERNEL);
3205 if (!hmacs)
3206 return -ENOMEM;
3207
3208 if (copy_from_user(hmacs, optval, optlen)) {
3209 err = -EFAULT;
3210 goto out;
3211 }
3212
Vlad Yasevichd9724052008-08-27 16:09:49 -07003213 idents = hmacs->shmac_num_idents;
3214 if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS ||
3215 (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo))) {
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003216 err = -EINVAL;
3217 goto out;
3218 }
3219
3220 err = sctp_auth_ep_set_hmacs(sctp_sk(sk)->ep, hmacs);
3221out:
3222 kfree(hmacs);
3223 return err;
3224}
3225
3226/*
3227 * 7.1.20. Set a shared key (SCTP_AUTH_KEY)
3228 *
3229 * This option will set a shared secret key which is used to build an
3230 * association shared key.
3231 */
3232static int sctp_setsockopt_auth_key(struct sock *sk,
3233 char __user *optval,
David S. Millerb7058842009-09-30 16:12:20 -07003234 unsigned int optlen)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003235{
3236 struct sctp_authkey *authkey;
3237 struct sctp_association *asoc;
3238 int ret;
3239
Vlad Yasevich5e739d12008-08-21 03:34:25 -07003240 if (!sctp_auth_enable)
3241 return -EACCES;
3242
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003243 if (optlen <= sizeof(struct sctp_authkey))
3244 return -EINVAL;
3245
3246 authkey = kmalloc(optlen, GFP_KERNEL);
3247 if (!authkey)
3248 return -ENOMEM;
3249
3250 if (copy_from_user(authkey, optval, optlen)) {
3251 ret = -EFAULT;
3252 goto out;
3253 }
3254
Vlad Yasevich328fc472008-08-27 16:08:54 -07003255 if (authkey->sca_keylength > optlen - sizeof(struct sctp_authkey)) {
Vlad Yasevich30c22352008-08-25 15:16:19 -07003256 ret = -EINVAL;
3257 goto out;
3258 }
3259
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003260 asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3261 if (!asoc && authkey->sca_assoc_id && sctp_style(sk, UDP)) {
3262 ret = -EINVAL;
3263 goto out;
3264 }
3265
3266 ret = sctp_auth_set_key(sctp_sk(sk)->ep, asoc, authkey);
3267out:
3268 kfree(authkey);
3269 return ret;
3270}
3271
3272/*
3273 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3274 *
3275 * This option will get or set the active shared key to be used to build
3276 * the association shared key.
3277 */
3278static int sctp_setsockopt_active_key(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07003279 char __user *optval,
3280 unsigned int optlen)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003281{
3282 struct sctp_authkeyid val;
3283 struct sctp_association *asoc;
3284
Vlad Yasevich5e739d12008-08-21 03:34:25 -07003285 if (!sctp_auth_enable)
3286 return -EACCES;
3287
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003288 if (optlen != sizeof(struct sctp_authkeyid))
3289 return -EINVAL;
3290 if (copy_from_user(&val, optval, optlen))
3291 return -EFAULT;
3292
3293 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3294 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3295 return -EINVAL;
3296
3297 return sctp_auth_set_active_key(sctp_sk(sk)->ep, asoc,
3298 val.scact_keynumber);
3299}
3300
3301/*
3302 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY)
3303 *
3304 * This set option will delete a shared secret key from use.
3305 */
3306static int sctp_setsockopt_del_key(struct sock *sk,
David S. Millerb7058842009-09-30 16:12:20 -07003307 char __user *optval,
3308 unsigned int optlen)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003309{
3310 struct sctp_authkeyid val;
3311 struct sctp_association *asoc;
3312
Vlad Yasevich5e739d12008-08-21 03:34:25 -07003313 if (!sctp_auth_enable)
3314 return -EACCES;
3315
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003316 if (optlen != sizeof(struct sctp_authkeyid))
3317 return -EINVAL;
3318 if (copy_from_user(&val, optval, optlen))
3319 return -EFAULT;
3320
3321 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3322 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3323 return -EINVAL;
3324
3325 return sctp_auth_del_key_id(sctp_sk(sk)->ep, asoc,
3326 val.scact_keynumber);
3327
3328}
3329
3330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331/* API 6.2 setsockopt(), getsockopt()
3332 *
3333 * Applications use setsockopt() and getsockopt() to set or retrieve
3334 * socket options. Socket options are used to change the default
3335 * behavior of sockets calls. They are described in Section 7.
3336 *
3337 * The syntax is:
3338 *
3339 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
3340 * int __user *optlen);
3341 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
3342 * int optlen);
3343 *
3344 * sd - the socket descript.
3345 * level - set to IPPROTO_SCTP for all SCTP options.
3346 * optname - the option name.
3347 * optval - the buffer to store the value of the option.
3348 * optlen - the size of the buffer.
3349 */
3350SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -07003351 char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352{
3353 int retval = 0;
3354
3355 SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n",
3356 sk, optname);
3357
3358 /* I can hardly begin to describe how wrong this is. This is
3359 * so broken as to be worse than useless. The API draft
3360 * REALLY is NOT helpful here... I am not convinced that the
3361 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
3362 * are at all well-founded.
3363 */
3364 if (level != SOL_SCTP) {
3365 struct sctp_af *af = sctp_sk(sk)->pf->af;
3366 retval = af->setsockopt(sk, level, optname, optval, optlen);
3367 goto out_nounlock;
3368 }
3369
3370 sctp_lock_sock(sk);
3371
3372 switch (optname) {
3373 case SCTP_SOCKOPT_BINDX_ADD:
3374 /* 'optlen' is the size of the addresses buffer. */
3375 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
3376 optlen, SCTP_BINDX_ADD_ADDR);
3377 break;
3378
3379 case SCTP_SOCKOPT_BINDX_REM:
3380 /* 'optlen' is the size of the addresses buffer. */
3381 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
3382 optlen, SCTP_BINDX_REM_ADDR);
3383 break;
3384
Vlad Yasevich88a0a942008-05-09 15:14:11 -07003385 case SCTP_SOCKOPT_CONNECTX_OLD:
3386 /* 'optlen' is the size of the addresses buffer. */
3387 retval = sctp_setsockopt_connectx_old(sk,
3388 (struct sockaddr __user *)optval,
3389 optlen);
3390 break;
3391
Frank Filz3f7a87d2005-06-20 13:14:57 -07003392 case SCTP_SOCKOPT_CONNECTX:
3393 /* 'optlen' is the size of the addresses buffer. */
Vlad Yasevich88a0a942008-05-09 15:14:11 -07003394 retval = sctp_setsockopt_connectx(sk,
3395 (struct sockaddr __user *)optval,
3396 optlen);
Frank Filz3f7a87d2005-06-20 13:14:57 -07003397 break;
3398
Linus Torvalds1da177e2005-04-16 15:20:36 -07003399 case SCTP_DISABLE_FRAGMENTS:
3400 retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
3401 break;
3402
3403 case SCTP_EVENTS:
3404 retval = sctp_setsockopt_events(sk, optval, optlen);
3405 break;
3406
3407 case SCTP_AUTOCLOSE:
3408 retval = sctp_setsockopt_autoclose(sk, optval, optlen);
3409 break;
3410
3411 case SCTP_PEER_ADDR_PARAMS:
3412 retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
3413 break;
3414
Wei Yongjund364d922008-05-09 15:13:26 -07003415 case SCTP_DELAYED_ACK:
3416 retval = sctp_setsockopt_delayed_ack(sk, optval, optlen);
Frank Filz77086102005-12-22 11:37:30 -08003417 break;
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07003418 case SCTP_PARTIAL_DELIVERY_POINT:
3419 retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen);
3420 break;
Frank Filz77086102005-12-22 11:37:30 -08003421
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422 case SCTP_INITMSG:
3423 retval = sctp_setsockopt_initmsg(sk, optval, optlen);
3424 break;
3425 case SCTP_DEFAULT_SEND_PARAM:
3426 retval = sctp_setsockopt_default_send_param(sk, optval,
3427 optlen);
3428 break;
3429 case SCTP_PRIMARY_ADDR:
3430 retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
3431 break;
3432 case SCTP_SET_PEER_PRIMARY_ADDR:
3433 retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
3434 break;
3435 case SCTP_NODELAY:
3436 retval = sctp_setsockopt_nodelay(sk, optval, optlen);
3437 break;
3438 case SCTP_RTOINFO:
3439 retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
3440 break;
3441 case SCTP_ASSOCINFO:
3442 retval = sctp_setsockopt_associnfo(sk, optval, optlen);
3443 break;
3444 case SCTP_I_WANT_MAPPED_V4_ADDR:
3445 retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
3446 break;
3447 case SCTP_MAXSEG:
3448 retval = sctp_setsockopt_maxseg(sk, optval, optlen);
3449 break;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08003450 case SCTP_ADAPTATION_LAYER:
3451 retval = sctp_setsockopt_adaptation_layer(sk, optval, optlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 break;
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08003453 case SCTP_CONTEXT:
3454 retval = sctp_setsockopt_context(sk, optval, optlen);
3455 break;
Vlad Yasevichb6e13312007-04-20 12:23:15 -07003456 case SCTP_FRAGMENT_INTERLEAVE:
3457 retval = sctp_setsockopt_fragment_interleave(sk, optval, optlen);
3458 break;
Vlad Yasevich70331572007-03-23 11:34:36 -07003459 case SCTP_MAX_BURST:
3460 retval = sctp_setsockopt_maxburst(sk, optval, optlen);
3461 break;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07003462 case SCTP_AUTH_CHUNK:
3463 retval = sctp_setsockopt_auth_chunk(sk, optval, optlen);
3464 break;
3465 case SCTP_HMAC_IDENT:
3466 retval = sctp_setsockopt_hmac_ident(sk, optval, optlen);
3467 break;
3468 case SCTP_AUTH_KEY:
3469 retval = sctp_setsockopt_auth_key(sk, optval, optlen);
3470 break;
3471 case SCTP_AUTH_ACTIVE_KEY:
3472 retval = sctp_setsockopt_active_key(sk, optval, optlen);
3473 break;
3474 case SCTP_AUTH_DELETE_KEY:
3475 retval = sctp_setsockopt_del_key(sk, optval, optlen);
3476 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 default:
3478 retval = -ENOPROTOOPT;
3479 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07003480 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481
3482 sctp_release_sock(sk);
3483
3484out_nounlock:
3485 return retval;
3486}
3487
3488/* API 3.1.6 connect() - UDP Style Syntax
3489 *
3490 * An application may use the connect() call in the UDP model to initiate an
3491 * association without sending data.
3492 *
3493 * The syntax is:
3494 *
3495 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
3496 *
3497 * sd: the socket descriptor to have a new association added to.
3498 *
3499 * nam: the address structure (either struct sockaddr_in or struct
3500 * sockaddr_in6 defined in RFC2553 [7]).
3501 *
3502 * len: the size of the address.
3503 */
Frank Filz3f7a87d2005-06-20 13:14:57 -07003504SCTP_STATIC int sctp_connect(struct sock *sk, struct sockaddr *addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 int addr_len)
3506{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507 int err = 0;
Frank Filz3f7a87d2005-06-20 13:14:57 -07003508 struct sctp_af *af;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509
3510 sctp_lock_sock(sk);
3511
Frank Filz3f7a87d2005-06-20 13:14:57 -07003512 SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08003513 __func__, sk, addr, addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514
Frank Filz3f7a87d2005-06-20 13:14:57 -07003515 /* Validate addr_len before calling common connect/connectx routine. */
3516 af = sctp_get_af_specific(addr->sa_family);
3517 if (!af || addr_len < af->sockaddr_len) {
3518 err = -EINVAL;
3519 } else {
3520 /* Pass correct addr len to common routine (so it knows there
3521 * is only one address being passed.
3522 */
Vlad Yasevich88a0a942008-05-09 15:14:11 -07003523 err = __sctp_connect(sk, addr, af->sockaddr_len, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 }
3525
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526 sctp_release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 return err;
3528}
3529
3530/* FIXME: Write comments. */
3531SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags)
3532{
3533 return -EOPNOTSUPP; /* STUB */
3534}
3535
3536/* 4.1.4 accept() - TCP Style Syntax
3537 *
3538 * Applications use accept() call to remove an established SCTP
3539 * association from the accept queue of the endpoint. A new socket
3540 * descriptor will be returned from accept() to represent the newly
3541 * formed association.
3542 */
3543SCTP_STATIC struct sock *sctp_accept(struct sock *sk, int flags, int *err)
3544{
3545 struct sctp_sock *sp;
3546 struct sctp_endpoint *ep;
3547 struct sock *newsk = NULL;
3548 struct sctp_association *asoc;
3549 long timeo;
3550 int error = 0;
3551
3552 sctp_lock_sock(sk);
3553
3554 sp = sctp_sk(sk);
3555 ep = sp->ep;
3556
3557 if (!sctp_style(sk, TCP)) {
3558 error = -EOPNOTSUPP;
3559 goto out;
3560 }
3561
3562 if (!sctp_sstate(sk, LISTENING)) {
3563 error = -EINVAL;
3564 goto out;
3565 }
3566
Sridhar Samudrala8abfedd2006-08-22 00:24:09 -07003567 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003568
3569 error = sctp_wait_for_accept(sk, timeo);
3570 if (error)
3571 goto out;
3572
3573 /* We treat the list of associations on the endpoint as the accept
3574 * queue and pick the first association on the list.
3575 */
3576 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
3577
3578 newsk = sp->pf->create_accept_sk(sk, asoc);
3579 if (!newsk) {
3580 error = -ENOMEM;
3581 goto out;
3582 }
3583
3584 /* Populate the fields of the newsk from the oldsk and migrate the
3585 * asoc to the newsk.
3586 */
3587 sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
3588
3589out:
3590 sctp_release_sock(sk);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003591 *err = error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 return newsk;
3593}
3594
3595/* The SCTP ioctl handler. */
3596SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
3597{
3598 return -ENOIOCTLCMD;
3599}
3600
3601/* This is the function which gets called during socket creation to
3602 * initialized the SCTP-specific portion of the sock.
3603 * The sock structure should already be zero-filled memory.
3604 */
3605SCTP_STATIC int sctp_init_sock(struct sock *sk)
3606{
3607 struct sctp_endpoint *ep;
3608 struct sctp_sock *sp;
3609
3610 SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk);
3611
3612 sp = sctp_sk(sk);
3613
3614 /* Initialize the SCTP per socket area. */
3615 switch (sk->sk_type) {
3616 case SOCK_SEQPACKET:
3617 sp->type = SCTP_SOCKET_UDP;
3618 break;
3619 case SOCK_STREAM:
3620 sp->type = SCTP_SOCKET_TCP;
3621 break;
3622 default:
3623 return -ESOCKTNOSUPPORT;
3624 }
3625
3626 /* Initialize default send parameters. These parameters can be
3627 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
3628 */
3629 sp->default_stream = 0;
3630 sp->default_ppid = 0;
3631 sp->default_flags = 0;
3632 sp->default_context = 0;
3633 sp->default_timetolive = 0;
3634
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08003635 sp->default_rcv_context = 0;
Vlad Yasevich70331572007-03-23 11:34:36 -07003636 sp->max_burst = sctp_max_burst;
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08003637
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638 /* Initialize default setup parameters. These parameters
3639 * can be modified with the SCTP_INITMSG socket option or
3640 * overridden by the SCTP_INIT CMSG.
3641 */
3642 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;
3643 sp->initmsg.sinit_max_instreams = sctp_max_instreams;
3644 sp->initmsg.sinit_max_attempts = sctp_max_retrans_init;
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -07003645 sp->initmsg.sinit_max_init_timeo = sctp_rto_max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003646
3647 /* Initialize default RTO related parameters. These parameters can
3648 * be modified for with the SCTP_RTOINFO socket option.
3649 */
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -07003650 sp->rtoinfo.srto_initial = sctp_rto_initial;
3651 sp->rtoinfo.srto_max = sctp_rto_max;
3652 sp->rtoinfo.srto_min = sctp_rto_min;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653
3654 /* Initialize default association related parameters. These parameters
3655 * can be modified with the SCTP_ASSOCINFO socket option.
3656 */
3657 sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association;
3658 sp->assocparams.sasoc_number_peer_destinations = 0;
3659 sp->assocparams.sasoc_peer_rwnd = 0;
3660 sp->assocparams.sasoc_local_rwnd = 0;
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -07003661 sp->assocparams.sasoc_cookie_life = sctp_valid_cookie_life;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662
3663 /* Initialize default event subscriptions. By default, all the
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003664 * options are off.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003665 */
3666 memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));
3667
3668 /* Default Peer Address Parameters. These defaults can
3669 * be modified via SCTP_PEER_ADDR_PARAMS
3670 */
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -07003671 sp->hbinterval = sctp_hb_interval;
Frank Filz52ccb8e2005-12-22 11:36:46 -08003672 sp->pathmaxrxt = sctp_max_retrans_path;
3673 sp->pathmtu = 0; // allow default discovery
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -07003674 sp->sackdelay = sctp_sack_timeout;
Vlad Yasevich7bfe8bd2008-06-09 15:45:05 -07003675 sp->sackfreq = 2;
Frank Filz52ccb8e2005-12-22 11:36:46 -08003676 sp->param_flags = SPP_HB_ENABLE |
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09003677 SPP_PMTUD_ENABLE |
3678 SPP_SACKDELAY_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679
3680 /* If enabled no SCTP message fragmentation will be performed.
3681 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
3682 */
3683 sp->disable_fragments = 0;
3684
Sridhar Samudrala208edef2006-09-29 17:08:01 -07003685 /* Enable Nagle algorithm by default. */
3686 sp->nodelay = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003687
3688 /* Enable by default. */
3689 sp->v4mapped = 1;
3690
3691 /* Auto-close idle associations after the configured
3692 * number of seconds. A value of 0 disables this
3693 * feature. Configure through the SCTP_AUTOCLOSE socket option,
3694 * for UDP-style sockets only.
3695 */
3696 sp->autoclose = 0;
3697
3698 /* User specified fragmentation limit. */
3699 sp->user_frag = 0;
3700
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08003701 sp->adaptation_ind = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003702
3703 sp->pf = sctp_get_pf_specific(sk->sk_family);
3704
3705 /* Control variables for partial data delivery. */
Vlad Yasevichb6e13312007-04-20 12:23:15 -07003706 atomic_set(&sp->pd_mode, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707 skb_queue_head_init(&sp->pd_lobby);
Vlad Yasevichb6e13312007-04-20 12:23:15 -07003708 sp->frag_interleave = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709
3710 /* Create a per socket endpoint structure. Even if we
3711 * change the data structure relationships, this may still
3712 * be useful for storing pre-connect address information.
3713 */
3714 ep = sctp_endpoint_new(sk, GFP_KERNEL);
3715 if (!ep)
3716 return -ENOMEM;
3717
3718 sp->ep = ep;
3719 sp->hmac = NULL;
3720
3721 SCTP_DBG_OBJCNT_INC(sock);
David S. Miller6f756a82008-11-23 17:34:03 -08003722
3723 local_bh_disable();
Vlad Yasevich81419d82010-04-28 08:47:20 +00003724 percpu_counter_inc(&sctp_sockets_allocated);
Eric Dumazet9a57f7f2008-11-17 02:41:00 -08003725 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
David S. Miller6f756a82008-11-23 17:34:03 -08003726 local_bh_enable();
3727
Linus Torvalds1da177e2005-04-16 15:20:36 -07003728 return 0;
3729}
3730
3731/* Cleanup any SCTP per socket resources. */
Brian Haley7d06b2e2008-06-14 17:04:49 -07003732SCTP_STATIC void sctp_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003733{
3734 struct sctp_endpoint *ep;
3735
3736 SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk);
3737
3738 /* Release our hold on the endpoint. */
3739 ep = sctp_sk(sk)->ep;
3740 sctp_endpoint_free(ep);
Eric Dumazet5bc0b3b2008-11-25 13:53:27 -08003741 local_bh_disable();
Vlad Yasevich81419d82010-04-28 08:47:20 +00003742 percpu_counter_dec(&sctp_sockets_allocated);
Eric Dumazet9a57f7f2008-11-17 02:41:00 -08003743 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
Eric Dumazet5bc0b3b2008-11-25 13:53:27 -08003744 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745}
3746
3747/* API 4.1.7 shutdown() - TCP Style Syntax
3748 * int shutdown(int socket, int how);
3749 *
3750 * sd - the socket descriptor of the association to be closed.
3751 * how - Specifies the type of shutdown. The values are
3752 * as follows:
3753 * SHUT_RD
3754 * Disables further receive operations. No SCTP
3755 * protocol action is taken.
3756 * SHUT_WR
3757 * Disables further send operations, and initiates
3758 * the SCTP shutdown sequence.
3759 * SHUT_RDWR
3760 * Disables further send and receive operations
3761 * and initiates the SCTP shutdown sequence.
3762 */
3763SCTP_STATIC void sctp_shutdown(struct sock *sk, int how)
3764{
3765 struct sctp_endpoint *ep;
3766 struct sctp_association *asoc;
3767
3768 if (!sctp_style(sk, TCP))
3769 return;
3770
3771 if (how & SEND_SHUTDOWN) {
3772 ep = sctp_sk(sk)->ep;
3773 if (!list_empty(&ep->asocs)) {
3774 asoc = list_entry(ep->asocs.next,
3775 struct sctp_association, asocs);
3776 sctp_primitive_SHUTDOWN(asoc, NULL);
3777 }
3778 }
3779}
3780
3781/* 7.2.1 Association Status (SCTP_STATUS)
3782
3783 * Applications can retrieve current status information about an
3784 * association, including association state, peer receiver window size,
3785 * number of unacked data chunks, and number of data chunks pending
3786 * receipt. This information is read-only.
3787 */
3788static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
3789 char __user *optval,
3790 int __user *optlen)
3791{
3792 struct sctp_status status;
3793 struct sctp_association *asoc = NULL;
3794 struct sctp_transport *transport;
3795 sctp_assoc_t associd;
3796 int retval = 0;
3797
Neil Horman408f22e2007-06-16 14:03:45 -04003798 if (len < sizeof(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799 retval = -EINVAL;
3800 goto out;
3801 }
3802
Neil Horman408f22e2007-06-16 14:03:45 -04003803 len = sizeof(status);
3804 if (copy_from_user(&status, optval, len)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003805 retval = -EFAULT;
3806 goto out;
3807 }
3808
3809 associd = status.sstat_assoc_id;
3810 asoc = sctp_id2assoc(sk, associd);
3811 if (!asoc) {
3812 retval = -EINVAL;
3813 goto out;
3814 }
3815
3816 transport = asoc->peer.primary_path;
3817
3818 status.sstat_assoc_id = sctp_assoc2id(asoc);
3819 status.sstat_state = asoc->state;
3820 status.sstat_rwnd = asoc->peer.rwnd;
3821 status.sstat_unackdata = asoc->unack_data;
3822
3823 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
3824 status.sstat_instrms = asoc->c.sinit_max_instreams;
3825 status.sstat_outstrms = asoc->c.sinit_num_ostreams;
3826 status.sstat_fragmentation_point = asoc->frag_point;
3827 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
Al Viro8cec6b82006-11-20 17:23:01 -08003828 memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
3829 transport->af_specific->sockaddr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003830 /* Map ipv4 address into v4-mapped-on-v6 address. */
3831 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
3832 (union sctp_addr *)&status.sstat_primary.spinfo_address);
Frank Filz3f7a87d2005-06-20 13:14:57 -07003833 status.sstat_primary.spinfo_state = transport->state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003834 status.sstat_primary.spinfo_cwnd = transport->cwnd;
3835 status.sstat_primary.spinfo_srtt = transport->srtt;
3836 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
Frank Filz52ccb8e2005-12-22 11:36:46 -08003837 status.sstat_primary.spinfo_mtu = transport->pathmtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838
Frank Filz3f7a87d2005-06-20 13:14:57 -07003839 if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
3840 status.sstat_primary.spinfo_state = SCTP_ACTIVE;
3841
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 if (put_user(len, optlen)) {
3843 retval = -EFAULT;
3844 goto out;
3845 }
3846
3847 SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n",
3848 len, status.sstat_state, status.sstat_rwnd,
3849 status.sstat_assoc_id);
3850
3851 if (copy_to_user(optval, &status, len)) {
3852 retval = -EFAULT;
3853 goto out;
3854 }
3855
3856out:
3857 return (retval);
3858}
3859
3860
3861/* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
3862 *
3863 * Applications can retrieve information about a specific peer address
3864 * of an association, including its reachability state, congestion
3865 * window, and retransmission timer values. This information is
3866 * read-only.
3867 */
3868static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
3869 char __user *optval,
3870 int __user *optlen)
3871{
3872 struct sctp_paddrinfo pinfo;
3873 struct sctp_transport *transport;
3874 int retval = 0;
3875
Neil Horman408f22e2007-06-16 14:03:45 -04003876 if (len < sizeof(pinfo)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003877 retval = -EINVAL;
3878 goto out;
3879 }
3880
Neil Horman408f22e2007-06-16 14:03:45 -04003881 len = sizeof(pinfo);
3882 if (copy_from_user(&pinfo, optval, len)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003883 retval = -EFAULT;
3884 goto out;
3885 }
3886
3887 transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
3888 pinfo.spinfo_assoc_id);
3889 if (!transport)
3890 return -EINVAL;
3891
3892 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
Frank Filz3f7a87d2005-06-20 13:14:57 -07003893 pinfo.spinfo_state = transport->state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 pinfo.spinfo_cwnd = transport->cwnd;
3895 pinfo.spinfo_srtt = transport->srtt;
3896 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
Frank Filz52ccb8e2005-12-22 11:36:46 -08003897 pinfo.spinfo_mtu = transport->pathmtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003898
Frank Filz3f7a87d2005-06-20 13:14:57 -07003899 if (pinfo.spinfo_state == SCTP_UNKNOWN)
3900 pinfo.spinfo_state = SCTP_ACTIVE;
3901
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 if (put_user(len, optlen)) {
3903 retval = -EFAULT;
3904 goto out;
3905 }
3906
3907 if (copy_to_user(optval, &pinfo, len)) {
3908 retval = -EFAULT;
3909 goto out;
3910 }
3911
3912out:
3913 return (retval);
3914}
3915
3916/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
3917 *
3918 * This option is a on/off flag. If enabled no SCTP message
3919 * fragmentation will be performed. Instead if a message being sent
3920 * exceeds the current PMTU size, the message will NOT be sent and
3921 * instead a error will be indicated to the user.
3922 */
3923static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
3924 char __user *optval, int __user *optlen)
3925{
3926 int val;
3927
3928 if (len < sizeof(int))
3929 return -EINVAL;
3930
3931 len = sizeof(int);
3932 val = (sctp_sk(sk)->disable_fragments == 1);
3933 if (put_user(len, optlen))
3934 return -EFAULT;
3935 if (copy_to_user(optval, &val, len))
3936 return -EFAULT;
3937 return 0;
3938}
3939
3940/* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
3941 *
3942 * This socket option is used to specify various notifications and
3943 * ancillary data the user wishes to receive.
3944 */
3945static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
3946 int __user *optlen)
3947{
Neil Horman408f22e2007-06-16 14:03:45 -04003948 if (len < sizeof(struct sctp_event_subscribe))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04003950 len = sizeof(struct sctp_event_subscribe);
3951 if (put_user(len, optlen))
3952 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003953 if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))
3954 return -EFAULT;
3955 return 0;
3956}
3957
3958/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
3959 *
3960 * This socket option is applicable to the UDP-style socket only. When
3961 * set it will cause associations that are idle for more than the
3962 * specified number of seconds to automatically close. An association
3963 * being idle is defined an association that has NOT sent or received
3964 * user data. The special value of '0' indicates that no automatic
3965 * close of any associations should be performed. The option expects an
3966 * integer defining the number of seconds of idle time before an
3967 * association is closed.
3968 */
3969static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
3970{
3971 /* Applicable to UDP-style socket only */
3972 if (sctp_style(sk, TCP))
3973 return -EOPNOTSUPP;
Neil Horman408f22e2007-06-16 14:03:45 -04003974 if (len < sizeof(int))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04003976 len = sizeof(int);
3977 if (put_user(len, optlen))
3978 return -EFAULT;
3979 if (copy_to_user(optval, &sctp_sk(sk)->autoclose, sizeof(int)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003980 return -EFAULT;
3981 return 0;
3982}
3983
3984/* Helper routine to branch off an association to a new socket. */
3985SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,
3986 struct socket **sockp)
3987{
3988 struct sock *sk = asoc->base.sk;
3989 struct socket *sock;
Vlad Yasevichd570ee42007-05-15 16:32:39 -04003990 struct sctp_af *af;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991 int err = 0;
3992
3993 /* An association cannot be branched off from an already peeled-off
3994 * socket, nor is this supported for tcp style sockets.
3995 */
3996 if (!sctp_style(sk, UDP))
3997 return -EINVAL;
3998
3999 /* Create a new socket. */
4000 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
4001 if (err < 0)
4002 return err;
4003
Vlad Yasevich914e1c82009-02-13 08:33:44 +00004004 sctp_copy_sock(sock->sk, sk, asoc);
Vlad Yasevich4f444302006-10-30 18:54:32 -08004005
4006 /* Make peeled-off sockets more like 1-1 accepted sockets.
4007 * Set the daddr and initialize id to something more random
4008 */
Vlad Yasevichd570ee42007-05-15 16:32:39 -04004009 af = sctp_get_af_specific(asoc->peer.primary_addr.sa.sa_family);
4010 af->to_sk_daddr(&asoc->peer.primary_addr, sk);
Vlad Yasevich914e1c82009-02-13 08:33:44 +00004011
4012 /* Populate the fields of the newsk from the oldsk and migrate the
4013 * asoc to the newsk.
4014 */
4015 sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
Vlad Yasevich4f444302006-10-30 18:54:32 -08004016
Linus Torvalds1da177e2005-04-16 15:20:36 -07004017 *sockp = sock;
4018
4019 return err;
4020}
4021
4022static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
4023{
4024 sctp_peeloff_arg_t peeloff;
4025 struct socket *newsock;
4026 int retval = 0;
4027 struct sctp_association *asoc;
4028
Neil Horman408f22e2007-06-16 14:03:45 -04004029 if (len < sizeof(sctp_peeloff_arg_t))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04004031 len = sizeof(sctp_peeloff_arg_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 if (copy_from_user(&peeloff, optval, len))
4033 return -EFAULT;
4034
4035 asoc = sctp_id2assoc(sk, peeloff.associd);
4036 if (!asoc) {
4037 retval = -EINVAL;
4038 goto out;
4039 }
4040
Harvey Harrison0dc47872008-03-05 20:47:47 -08004041 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __func__, sk, asoc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042
4043 retval = sctp_do_peeloff(asoc, &newsock);
4044 if (retval < 0)
4045 goto out;
4046
4047 /* Map the socket to an unused fd that can be returned to the user. */
Ulrich Dreppera677a032008-07-23 21:29:17 -07004048 retval = sock_map_fd(newsock, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004049 if (retval < 0) {
4050 sock_release(newsock);
4051 goto out;
4052 }
4053
4054 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08004055 __func__, sk, asoc, newsock->sk, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004056
4057 /* Return the fd mapped to the new socket. */
4058 peeloff.sd = retval;
Neil Horman408f22e2007-06-16 14:03:45 -04004059 if (put_user(len, optlen))
4060 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061 if (copy_to_user(optval, &peeloff, len))
4062 retval = -EFAULT;
4063
4064out:
4065 return retval;
4066}
4067
4068/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
4069 *
4070 * Applications can enable or disable heartbeats for any peer address of
4071 * an association, modify an address's heartbeat interval, force a
4072 * heartbeat to be sent immediately, and adjust the address's maximum
4073 * number of retransmissions sent before an address is considered
4074 * unreachable. The following structure is used to access and modify an
4075 * address's parameters:
4076 *
4077 * struct sctp_paddrparams {
Frank Filz52ccb8e2005-12-22 11:36:46 -08004078 * sctp_assoc_t spp_assoc_id;
4079 * struct sockaddr_storage spp_address;
4080 * uint32_t spp_hbinterval;
4081 * uint16_t spp_pathmaxrxt;
4082 * uint32_t spp_pathmtu;
4083 * uint32_t spp_sackdelay;
4084 * uint32_t spp_flags;
4085 * };
Linus Torvalds1da177e2005-04-16 15:20:36 -07004086 *
Frank Filz52ccb8e2005-12-22 11:36:46 -08004087 * spp_assoc_id - (one-to-many style socket) This is filled in the
4088 * application, and identifies the association for
4089 * this query.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004090 * spp_address - This specifies which address is of interest.
4091 * spp_hbinterval - This contains the value of the heartbeat interval,
Frank Filz52ccb8e2005-12-22 11:36:46 -08004092 * in milliseconds. If a value of zero
4093 * is present in this field then no changes are to
4094 * be made to this parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095 * spp_pathmaxrxt - This contains the maximum number of
4096 * retransmissions before this address shall be
Frank Filz52ccb8e2005-12-22 11:36:46 -08004097 * considered unreachable. If a value of zero
4098 * is present in this field then no changes are to
4099 * be made to this parameter.
4100 * spp_pathmtu - When Path MTU discovery is disabled the value
4101 * specified here will be the "fixed" path mtu.
4102 * Note that if the spp_address field is empty
4103 * then all associations on this address will
4104 * have this fixed path mtu set upon them.
4105 *
4106 * spp_sackdelay - When delayed sack is enabled, this value specifies
4107 * the number of milliseconds that sacks will be delayed
4108 * for. This value will apply to all addresses of an
4109 * association if the spp_address field is empty. Note
4110 * also, that if delayed sack is enabled and this
4111 * value is set to 0, no change is made to the last
4112 * recorded delayed sack timer value.
4113 *
4114 * spp_flags - These flags are used to control various features
4115 * on an association. The flag field may contain
4116 * zero or more of the following options.
4117 *
4118 * SPP_HB_ENABLE - Enable heartbeats on the
4119 * specified address. Note that if the address
4120 * field is empty all addresses for the association
4121 * have heartbeats enabled upon them.
4122 *
4123 * SPP_HB_DISABLE - Disable heartbeats on the
4124 * speicifed address. Note that if the address
4125 * field is empty all addresses for the association
4126 * will have their heartbeats disabled. Note also
4127 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
4128 * mutually exclusive, only one of these two should
4129 * be specified. Enabling both fields will have
4130 * undetermined results.
4131 *
4132 * SPP_HB_DEMAND - Request a user initiated heartbeat
4133 * to be made immediately.
4134 *
4135 * SPP_PMTUD_ENABLE - This field will enable PMTU
4136 * discovery upon the specified address. Note that
4137 * if the address feild is empty then all addresses
4138 * on the association are effected.
4139 *
4140 * SPP_PMTUD_DISABLE - This field will disable PMTU
4141 * discovery upon the specified address. Note that
4142 * if the address feild is empty then all addresses
4143 * on the association are effected. Not also that
4144 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
4145 * exclusive. Enabling both will have undetermined
4146 * results.
4147 *
4148 * SPP_SACKDELAY_ENABLE - Setting this flag turns
4149 * on delayed sack. The time specified in spp_sackdelay
4150 * is used to specify the sack delay for this address. Note
4151 * that if spp_address is empty then all addresses will
4152 * enable delayed sack and take on the sack delay
4153 * value specified in spp_sackdelay.
4154 * SPP_SACKDELAY_DISABLE - Setting this flag turns
4155 * off delayed sack. If the spp_address field is blank then
4156 * delayed sack is disabled for the entire association. Note
4157 * also that this field is mutually exclusive to
4158 * SPP_SACKDELAY_ENABLE, setting both will have undefined
4159 * results.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160 */
4161static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
Frank Filz52ccb8e2005-12-22 11:36:46 -08004162 char __user *optval, int __user *optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004163{
Frank Filz52ccb8e2005-12-22 11:36:46 -08004164 struct sctp_paddrparams params;
4165 struct sctp_transport *trans = NULL;
4166 struct sctp_association *asoc = NULL;
4167 struct sctp_sock *sp = sctp_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168
Neil Horman408f22e2007-06-16 14:03:45 -04004169 if (len < sizeof(struct sctp_paddrparams))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04004171 len = sizeof(struct sctp_paddrparams);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004172 if (copy_from_user(&params, optval, len))
4173 return -EFAULT;
4174
Frank Filz52ccb8e2005-12-22 11:36:46 -08004175 /* If an address other than INADDR_ANY is specified, and
4176 * no transport is found, then the request is invalid.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004177 */
Vlad Yasevich52cae8f2008-08-18 10:34:34 -04004178 if (!sctp_is_any(sk, ( union sctp_addr *)&params.spp_address)) {
Frank Filz52ccb8e2005-12-22 11:36:46 -08004179 trans = sctp_addr_id2transport(sk, &params.spp_address,
4180 params.spp_assoc_id);
4181 if (!trans) {
4182 SCTP_DEBUG_PRINTK("Failed no transport\n");
4183 return -EINVAL;
4184 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004185 }
4186
Frank Filz52ccb8e2005-12-22 11:36:46 -08004187 /* Get association, if assoc_id != 0 and the socket is a one
4188 * to many style socket, and an association was not found, then
4189 * the id was invalid.
4190 */
4191 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
4192 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {
4193 SCTP_DEBUG_PRINTK("Failed no association\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004194 return -EINVAL;
Frank Filz52ccb8e2005-12-22 11:36:46 -08004195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004196
Frank Filz52ccb8e2005-12-22 11:36:46 -08004197 if (trans) {
4198 /* Fetch transport values. */
4199 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
4200 params.spp_pathmtu = trans->pathmtu;
4201 params.spp_pathmaxrxt = trans->pathmaxrxt;
4202 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004203
Frank Filz52ccb8e2005-12-22 11:36:46 -08004204 /*draft-11 doesn't say what to return in spp_flags*/
4205 params.spp_flags = trans->param_flags;
4206 } else if (asoc) {
4207 /* Fetch association values. */
4208 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
4209 params.spp_pathmtu = asoc->pathmtu;
4210 params.spp_pathmaxrxt = asoc->pathmaxrxt;
4211 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212
Frank Filz52ccb8e2005-12-22 11:36:46 -08004213 /*draft-11 doesn't say what to return in spp_flags*/
4214 params.spp_flags = asoc->param_flags;
4215 } else {
4216 /* Fetch socket values. */
4217 params.spp_hbinterval = sp->hbinterval;
4218 params.spp_pathmtu = sp->pathmtu;
4219 params.spp_sackdelay = sp->sackdelay;
4220 params.spp_pathmaxrxt = sp->pathmaxrxt;
4221
4222 /*draft-11 doesn't say what to return in spp_flags*/
4223 params.spp_flags = sp->param_flags;
4224 }
4225
Linus Torvalds1da177e2005-04-16 15:20:36 -07004226 if (copy_to_user(optval, &params, len))
4227 return -EFAULT;
4228
4229 if (put_user(len, optlen))
4230 return -EFAULT;
4231
4232 return 0;
4233}
4234
Wei Yongjund364d922008-05-09 15:13:26 -07004235/*
4236 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
Frank Filz77086102005-12-22 11:37:30 -08004237 *
Wei Yongjund364d922008-05-09 15:13:26 -07004238 * This option will effect the way delayed acks are performed. This
4239 * option allows you to get or set the delayed ack time, in
4240 * milliseconds. It also allows changing the delayed ack frequency.
4241 * Changing the frequency to 1 disables the delayed sack algorithm. If
4242 * the assoc_id is 0, then this sets or gets the endpoints default
4243 * values. If the assoc_id field is non-zero, then the set or get
4244 * effects the specified association for the one to many model (the
4245 * assoc_id field is ignored by the one to one model). Note that if
4246 * sack_delay or sack_freq are 0 when setting this option, then the
4247 * current values will remain unchanged.
Frank Filz77086102005-12-22 11:37:30 -08004248 *
Wei Yongjund364d922008-05-09 15:13:26 -07004249 * struct sctp_sack_info {
4250 * sctp_assoc_t sack_assoc_id;
4251 * uint32_t sack_delay;
4252 * uint32_t sack_freq;
4253 * };
Frank Filz77086102005-12-22 11:37:30 -08004254 *
Wei Yongjund364d922008-05-09 15:13:26 -07004255 * sack_assoc_id - This parameter, indicates which association the user
4256 * is performing an action upon. Note that if this field's value is
4257 * zero then the endpoints default value is changed (effecting future
4258 * associations only).
Frank Filz77086102005-12-22 11:37:30 -08004259 *
Wei Yongjund364d922008-05-09 15:13:26 -07004260 * sack_delay - This parameter contains the number of milliseconds that
4261 * the user is requesting the delayed ACK timer be set to. Note that
4262 * this value is defined in the standard to be between 200 and 500
4263 * milliseconds.
Frank Filz77086102005-12-22 11:37:30 -08004264 *
Wei Yongjund364d922008-05-09 15:13:26 -07004265 * sack_freq - This parameter contains the number of packets that must
4266 * be received before a sack is sent without waiting for the delay
4267 * timer to expire. The default value for this is 2, setting this
4268 * value to 1 will disable the delayed sack algorithm.
Frank Filz77086102005-12-22 11:37:30 -08004269 */
Wei Yongjund364d922008-05-09 15:13:26 -07004270static int sctp_getsockopt_delayed_ack(struct sock *sk, int len,
Frank Filz77086102005-12-22 11:37:30 -08004271 char __user *optval,
4272 int __user *optlen)
4273{
Wei Yongjund364d922008-05-09 15:13:26 -07004274 struct sctp_sack_info params;
Frank Filz77086102005-12-22 11:37:30 -08004275 struct sctp_association *asoc = NULL;
4276 struct sctp_sock *sp = sctp_sk(sk);
4277
Wei Yongjund364d922008-05-09 15:13:26 -07004278 if (len >= sizeof(struct sctp_sack_info)) {
4279 len = sizeof(struct sctp_sack_info);
4280
4281 if (copy_from_user(&params, optval, len))
4282 return -EFAULT;
4283 } else if (len == sizeof(struct sctp_assoc_value)) {
Wei Yongjunea686a22008-12-25 16:56:45 -08004284 printk(KERN_WARNING "SCTP: Use of struct sctp_assoc_value "
Wei Yongjund364d922008-05-09 15:13:26 -07004285 "in delayed_ack socket option deprecated\n");
Wei Yongjunea686a22008-12-25 16:56:45 -08004286 printk(KERN_WARNING "SCTP: Use struct sctp_sack_info instead\n");
Wei Yongjund364d922008-05-09 15:13:26 -07004287 if (copy_from_user(&params, optval, len))
4288 return -EFAULT;
4289 } else
Frank Filz77086102005-12-22 11:37:30 -08004290 return - EINVAL;
4291
Wei Yongjund364d922008-05-09 15:13:26 -07004292 /* Get association, if sack_assoc_id != 0 and the socket is a one
Frank Filz77086102005-12-22 11:37:30 -08004293 * to many style socket, and an association was not found, then
4294 * the id was invalid.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09004295 */
Wei Yongjund364d922008-05-09 15:13:26 -07004296 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
4297 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
Frank Filz77086102005-12-22 11:37:30 -08004298 return -EINVAL;
4299
4300 if (asoc) {
4301 /* Fetch association values. */
Wei Yongjund364d922008-05-09 15:13:26 -07004302 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
4303 params.sack_delay = jiffies_to_msecs(
Frank Filz77086102005-12-22 11:37:30 -08004304 asoc->sackdelay);
Wei Yongjund364d922008-05-09 15:13:26 -07004305 params.sack_freq = asoc->sackfreq;
4306
4307 } else {
4308 params.sack_delay = 0;
4309 params.sack_freq = 1;
4310 }
Frank Filz77086102005-12-22 11:37:30 -08004311 } else {
4312 /* Fetch socket values. */
Wei Yongjund364d922008-05-09 15:13:26 -07004313 if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
4314 params.sack_delay = sp->sackdelay;
4315 params.sack_freq = sp->sackfreq;
4316 } else {
4317 params.sack_delay = 0;
4318 params.sack_freq = 1;
4319 }
Frank Filz77086102005-12-22 11:37:30 -08004320 }
4321
4322 if (copy_to_user(optval, &params, len))
4323 return -EFAULT;
4324
4325 if (put_user(len, optlen))
4326 return -EFAULT;
4327
4328 return 0;
4329}
4330
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
4332 *
4333 * Applications can specify protocol parameters for the default association
4334 * initialization. The option name argument to setsockopt() and getsockopt()
4335 * is SCTP_INITMSG.
4336 *
4337 * Setting initialization parameters is effective only on an unconnected
4338 * socket (for UDP-style sockets only future associations are effected
4339 * by the change). With TCP-style sockets, this option is inherited by
4340 * sockets derived from a listener socket.
4341 */
4342static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
4343{
Neil Horman408f22e2007-06-16 14:03:45 -04004344 if (len < sizeof(struct sctp_initmsg))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004345 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04004346 len = sizeof(struct sctp_initmsg);
4347 if (put_user(len, optlen))
4348 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004349 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
4350 return -EFAULT;
4351 return 0;
4352}
4353
Linus Torvalds1da177e2005-04-16 15:20:36 -07004354
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004355static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
4356 char __user *optval, int __user *optlen)
4357{
4358 struct sctp_association *asoc;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004359 int cnt = 0;
4360 struct sctp_getaddrs getaddrs;
4361 struct sctp_transport *from;
4362 void __user *to;
4363 union sctp_addr temp;
4364 struct sctp_sock *sp = sctp_sk(sk);
4365 int addrlen;
4366 size_t space_left;
4367 int bytes_copied;
4368
4369 if (len < sizeof(struct sctp_getaddrs))
4370 return -EINVAL;
4371
4372 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
4373 return -EFAULT;
4374
4375 /* For UDP-style sockets, id specifies the association to query. */
4376 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4377 if (!asoc)
4378 return -EINVAL;
4379
4380 to = optval + offsetof(struct sctp_getaddrs,addrs);
Neil Horman186e2342007-06-18 19:59:16 -04004381 space_left = len - offsetof(struct sctp_getaddrs,addrs);
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004382
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07004383 list_for_each_entry(from, &asoc->peer.transport_addr_list,
4384 transports) {
Al Virob3f5b3b2006-11-20 17:22:43 -08004385 memcpy(&temp, &from->ipaddr, sizeof(temp));
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004386 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
Vlad Yasevicha5f4cea2010-04-30 21:42:42 -04004387 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004388 if (space_left < addrlen)
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004389 return -ENOMEM;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004390 if (copy_to_user(to, &temp, addrlen))
4391 return -EFAULT;
4392 to += addrlen;
4393 cnt++;
4394 space_left -= addrlen;
4395 }
4396
4397 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
4398 return -EFAULT;
4399 bytes_copied = ((char __user *)to) - optval;
4400 if (put_user(bytes_copied, optlen))
4401 return -EFAULT;
4402
4403 return 0;
4404}
4405
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004406static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
4407 size_t space_left, int *bytes_copied)
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004408{
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004409 struct sctp_sockaddr_entry *addr;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004410 union sctp_addr temp;
4411 int cnt = 0;
4412 int addrlen;
4413
Vlad Yasevich29303542007-09-16 16:02:12 -07004414 rcu_read_lock();
4415 list_for_each_entry_rcu(addr, &sctp_local_addr_list, list) {
4416 if (!addr->valid)
4417 continue;
4418
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09004419 if ((PF_INET == sk->sk_family) &&
Al Viro6244be42006-11-20 17:21:44 -08004420 (AF_INET6 == addr->a.sa.sa_family))
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004421 continue;
Vlad Yasevich7dab83d2008-07-18 23:05:40 -07004422 if ((PF_INET6 == sk->sk_family) &&
4423 inet_v6_ipv6only(sk) &&
4424 (AF_INET == addr->a.sa.sa_family))
4425 continue;
Al Viro6244be42006-11-20 17:21:44 -08004426 memcpy(&temp, &addr->a, sizeof(temp));
Vlad Yasevichb46ae362008-01-28 14:25:36 -05004427 if (!temp.v4.sin_port)
4428 temp.v4.sin_port = htons(port);
4429
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004430 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
4431 &temp);
4432 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
Vlad Yasevich29303542007-09-16 16:02:12 -07004433 if (space_left < addrlen) {
4434 cnt = -ENOMEM;
4435 break;
4436 }
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004437 memcpy(to, &temp, addrlen);
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -08004438
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004439 to += addrlen;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004440 cnt ++;
4441 space_left -= addrlen;
Vlad Yasevich3663c302007-07-03 12:43:12 -04004442 *bytes_copied += addrlen;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004443 }
Vlad Yasevich29303542007-09-16 16:02:12 -07004444 rcu_read_unlock();
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004445
4446 return cnt;
4447}
4448
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004450static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
4451 char __user *optval, int __user *optlen)
4452{
4453 struct sctp_bind_addr *bp;
4454 struct sctp_association *asoc;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004455 int cnt = 0;
4456 struct sctp_getaddrs getaddrs;
4457 struct sctp_sockaddr_entry *addr;
4458 void __user *to;
4459 union sctp_addr temp;
4460 struct sctp_sock *sp = sctp_sk(sk);
4461 int addrlen;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004462 int err = 0;
4463 size_t space_left;
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004464 int bytes_copied = 0;
4465 void *addrs;
Vlad Yasevich70b57b82007-05-09 13:51:31 -07004466 void *buf;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004467
Neil Horman408f22e2007-06-16 14:03:45 -04004468 if (len < sizeof(struct sctp_getaddrs))
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004469 return -EINVAL;
4470
4471 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
4472 return -EFAULT;
4473
4474 /*
4475 * For UDP-style sockets, id specifies the association to query.
4476 * If the id field is set to the value '0' then the locally bound
4477 * addresses are returned without regard to any particular
4478 * association.
4479 */
4480 if (0 == getaddrs.assoc_id) {
4481 bp = &sctp_sk(sk)->ep->base.bind_addr;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004482 } else {
4483 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4484 if (!asoc)
4485 return -EINVAL;
4486 bp = &asoc->base.bind_addr;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004487 }
4488
4489 to = optval + offsetof(struct sctp_getaddrs,addrs);
Neil Horman186e2342007-06-18 19:59:16 -04004490 space_left = len - offsetof(struct sctp_getaddrs,addrs);
4491
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004492 addrs = kmalloc(space_left, GFP_KERNEL);
4493 if (!addrs)
4494 return -ENOMEM;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004495
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004496 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4497 * addresses from the global local address list.
4498 */
4499 if (sctp_list_single_entry(&bp->address_list)) {
4500 addr = list_entry(bp->address_list.next,
4501 struct sctp_sockaddr_entry, list);
Vlad Yasevich52cae8f2008-08-18 10:34:34 -04004502 if (sctp_is_any(sk, &addr->a)) {
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004503 cnt = sctp_copy_laddrs(sk, bp->port, addrs,
4504 space_left, &bytes_copied);
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004505 if (cnt < 0) {
4506 err = cnt;
Vlad Yasevich559cf712007-09-16 16:03:28 -07004507 goto out;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004508 }
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09004509 goto copy_getaddrs;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004510 }
4511 }
4512
Vlad Yasevich70b57b82007-05-09 13:51:31 -07004513 buf = addrs;
Vlad Yasevich559cf712007-09-16 16:03:28 -07004514 /* Protection on the bound address list is not needed since
4515 * in the socket option context we hold a socket lock and
4516 * thus the bound address list can't change.
4517 */
4518 list_for_each_entry(addr, &bp->address_list, list) {
Al Viro6244be42006-11-20 17:21:44 -08004519 memcpy(&temp, &addr->a, sizeof(temp));
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004520 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
4521 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004522 if (space_left < addrlen) {
4523 err = -ENOMEM; /*fixme: right error?*/
Vlad Yasevich559cf712007-09-16 16:03:28 -07004524 goto out;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004525 }
Vlad Yasevich70b57b82007-05-09 13:51:31 -07004526 memcpy(buf, &temp, addrlen);
4527 buf += addrlen;
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004528 bytes_copied += addrlen;
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004529 cnt ++;
4530 space_left -= addrlen;
4531 }
4532
4533copy_getaddrs:
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004534 if (copy_to_user(to, addrs, bytes_copied)) {
4535 err = -EFAULT;
Sebastian Siewiord6f9fda2007-07-27 22:55:59 +02004536 goto out;
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004537 }
Vlad Yasevichfe979ac2007-05-23 11:11:37 -04004538 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
4539 err = -EFAULT;
Sebastian Siewiord6f9fda2007-07-27 22:55:59 +02004540 goto out;
Vlad Yasevichfe979ac2007-05-23 11:11:37 -04004541 }
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004542 if (put_user(bytes_copied, optlen))
Vlad Yasevichfe979ac2007-05-23 11:11:37 -04004543 err = -EFAULT;
Sebastian Siewiord6f9fda2007-07-27 22:55:59 +02004544out:
Vlad Yasevichaad97f32007-04-28 21:09:04 -07004545 kfree(addrs);
Ivan Skytte Jørgensen5fe467e2005-10-06 21:36:17 -07004546 return err;
4547}
4548
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
4550 *
4551 * Requests that the local SCTP stack use the enclosed peer address as
4552 * the association primary. The enclosed address must be one of the
4553 * association peer's addresses.
4554 */
4555static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
4556 char __user *optval, int __user *optlen)
4557{
4558 struct sctp_prim prim;
4559 struct sctp_association *asoc;
4560 struct sctp_sock *sp = sctp_sk(sk);
4561
Neil Horman408f22e2007-06-16 14:03:45 -04004562 if (len < sizeof(struct sctp_prim))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004563 return -EINVAL;
4564
Neil Horman408f22e2007-06-16 14:03:45 -04004565 len = sizeof(struct sctp_prim);
4566
4567 if (copy_from_user(&prim, optval, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004568 return -EFAULT;
4569
4570 asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
4571 if (!asoc)
4572 return -EINVAL;
4573
4574 if (!asoc->peer.primary_path)
4575 return -ENOTCONN;
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09004576
Al Viro8cec6b82006-11-20 17:23:01 -08004577 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
4578 asoc->peer.primary_path->af_specific->sockaddr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004579
4580 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp,
4581 (union sctp_addr *)&prim.ssp_addr);
4582
Neil Horman408f22e2007-06-16 14:03:45 -04004583 if (put_user(len, optlen))
4584 return -EFAULT;
4585 if (copy_to_user(optval, &prim, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 return -EFAULT;
4587
4588 return 0;
4589}
4590
4591/*
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004592 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593 *
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004594 * Requests that the local endpoint set the specified Adaptation Layer
Linus Torvalds1da177e2005-04-16 15:20:36 -07004595 * Indication parameter for all future INIT and INIT-ACK exchanges.
4596 */
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004597static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004598 char __user *optval, int __user *optlen)
4599{
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004600 struct sctp_setadaptation adaptation;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601
Neil Horman408f22e2007-06-16 14:03:45 -04004602 if (len < sizeof(struct sctp_setadaptation))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004603 return -EINVAL;
4604
Neil Horman408f22e2007-06-16 14:03:45 -04004605 len = sizeof(struct sctp_setadaptation);
4606
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004607 adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
Neil Horman408f22e2007-06-16 14:03:45 -04004608
4609 if (put_user(len, optlen))
4610 return -EFAULT;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08004611 if (copy_to_user(optval, &adaptation, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004612 return -EFAULT;
Ivan Skytte Jorgensena1ab3582005-10-28 15:33:24 -07004613
Linus Torvalds1da177e2005-04-16 15:20:36 -07004614 return 0;
4615}
4616
4617/*
4618 *
4619 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
4620 *
4621 * Applications that wish to use the sendto() system call may wish to
4622 * specify a default set of parameters that would normally be supplied
4623 * through the inclusion of ancillary data. This socket option allows
4624 * such an application to set the default sctp_sndrcvinfo structure.
4625
4626
4627 * The application that wishes to use this socket option simply passes
4628 * in to this call the sctp_sndrcvinfo structure defined in Section
4629 * 5.2.2) The input parameters accepted by this call include
4630 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
4631 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
4632 * to this call if the caller is using the UDP model.
4633 *
4634 * For getsockopt, it get the default sctp_sndrcvinfo structure.
4635 */
4636static int sctp_getsockopt_default_send_param(struct sock *sk,
4637 int len, char __user *optval,
4638 int __user *optlen)
4639{
4640 struct sctp_sndrcvinfo info;
4641 struct sctp_association *asoc;
4642 struct sctp_sock *sp = sctp_sk(sk);
4643
Neil Horman408f22e2007-06-16 14:03:45 -04004644 if (len < sizeof(struct sctp_sndrcvinfo))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004645 return -EINVAL;
Neil Horman408f22e2007-06-16 14:03:45 -04004646
4647 len = sizeof(struct sctp_sndrcvinfo);
4648
4649 if (copy_from_user(&info, optval, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004650 return -EFAULT;
4651
4652 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
4653 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
4654 return -EINVAL;
4655
4656 if (asoc) {
4657 info.sinfo_stream = asoc->default_stream;
4658 info.sinfo_flags = asoc->default_flags;
4659 info.sinfo_ppid = asoc->default_ppid;
4660 info.sinfo_context = asoc->default_context;
4661 info.sinfo_timetolive = asoc->default_timetolive;
4662 } else {
4663 info.sinfo_stream = sp->default_stream;
4664 info.sinfo_flags = sp->default_flags;
4665 info.sinfo_ppid = sp->default_ppid;
4666 info.sinfo_context = sp->default_context;
4667 info.sinfo_timetolive = sp->default_timetolive;
4668 }
4669
Neil Horman408f22e2007-06-16 14:03:45 -04004670 if (put_user(len, optlen))
4671 return -EFAULT;
4672 if (copy_to_user(optval, &info, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 return -EFAULT;
4674
4675 return 0;
4676}
4677
4678/*
4679 *
4680 * 7.1.5 SCTP_NODELAY
4681 *
4682 * Turn on/off any Nagle-like algorithm. This means that packets are
4683 * generally sent as soon as possible and no unnecessary delays are
4684 * introduced, at the cost of more packets in the network. Expects an
4685 * integer boolean flag.
4686 */
4687
4688static int sctp_getsockopt_nodelay(struct sock *sk, int len,
4689 char __user *optval, int __user *optlen)
4690{
4691 int val;
4692
4693 if (len < sizeof(int))
4694 return -EINVAL;
4695
4696 len = sizeof(int);
4697 val = (sctp_sk(sk)->nodelay == 1);
4698 if (put_user(len, optlen))
4699 return -EFAULT;
4700 if (copy_to_user(optval, &val, len))
4701 return -EFAULT;
4702 return 0;
4703}
4704
4705/*
4706 *
4707 * 7.1.1 SCTP_RTOINFO
4708 *
4709 * The protocol parameters used to initialize and bound retransmission
4710 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
4711 * and modify these parameters.
4712 * All parameters are time values, in milliseconds. A value of 0, when
4713 * modifying the parameters, indicates that the current value should not
4714 * be changed.
4715 *
4716 */
4717static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
4718 char __user *optval,
4719 int __user *optlen) {
4720 struct sctp_rtoinfo rtoinfo;
4721 struct sctp_association *asoc;
4722
Neil Horman408f22e2007-06-16 14:03:45 -04004723 if (len < sizeof (struct sctp_rtoinfo))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724 return -EINVAL;
4725
Neil Horman408f22e2007-06-16 14:03:45 -04004726 len = sizeof(struct sctp_rtoinfo);
4727
4728 if (copy_from_user(&rtoinfo, optval, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004729 return -EFAULT;
4730
4731 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
4732
4733 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
4734 return -EINVAL;
4735
4736 /* Values corresponding to the specific association. */
4737 if (asoc) {
4738 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
4739 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
4740 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
4741 } else {
4742 /* Values corresponding to the endpoint. */
4743 struct sctp_sock *sp = sctp_sk(sk);
4744
4745 rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
4746 rtoinfo.srto_max = sp->rtoinfo.srto_max;
4747 rtoinfo.srto_min = sp->rtoinfo.srto_min;
4748 }
4749
4750 if (put_user(len, optlen))
4751 return -EFAULT;
4752
4753 if (copy_to_user(optval, &rtoinfo, len))
4754 return -EFAULT;
4755
4756 return 0;
4757}
4758
4759/*
4760 *
4761 * 7.1.2 SCTP_ASSOCINFO
4762 *
Michael Opdenacker59c51592007-05-09 08:57:56 +02004763 * This option is used to tune the maximum retransmission attempts
Linus Torvalds1da177e2005-04-16 15:20:36 -07004764 * of the association.
4765 * Returns an error if the new association retransmission value is
4766 * greater than the sum of the retransmission value of the peer.
4767 * See [SCTP] for more information.
4768 *
4769 */
4770static int sctp_getsockopt_associnfo(struct sock *sk, int len,
4771 char __user *optval,
4772 int __user *optlen)
4773{
4774
4775 struct sctp_assocparams assocparams;
4776 struct sctp_association *asoc;
4777 struct list_head *pos;
4778 int cnt = 0;
4779
Neil Horman408f22e2007-06-16 14:03:45 -04004780 if (len < sizeof (struct sctp_assocparams))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004781 return -EINVAL;
4782
Neil Horman408f22e2007-06-16 14:03:45 -04004783 len = sizeof(struct sctp_assocparams);
4784
4785 if (copy_from_user(&assocparams, optval, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004786 return -EFAULT;
4787
4788 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
4789
4790 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
4791 return -EINVAL;
4792
4793 /* Values correspoinding to the specific association */
Vladislav Yasevich17337212005-04-28 11:57:54 -07004794 if (asoc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004795 assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
4796 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
4797 assocparams.sasoc_local_rwnd = asoc->a_rwnd;
4798 assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec
4799 * 1000) +
4800 (asoc->cookie_life.tv_usec
4801 / 1000);
4802
4803 list_for_each(pos, &asoc->peer.transport_addr_list) {
4804 cnt ++;
4805 }
4806
4807 assocparams.sasoc_number_peer_destinations = cnt;
4808 } else {
4809 /* Values corresponding to the endpoint */
4810 struct sctp_sock *sp = sctp_sk(sk);
4811
4812 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
4813 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
4814 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
4815 assocparams.sasoc_cookie_life =
4816 sp->assocparams.sasoc_cookie_life;
4817 assocparams.sasoc_number_peer_destinations =
4818 sp->assocparams.
4819 sasoc_number_peer_destinations;
4820 }
4821
4822 if (put_user(len, optlen))
4823 return -EFAULT;
4824
4825 if (copy_to_user(optval, &assocparams, len))
4826 return -EFAULT;
4827
4828 return 0;
4829}
4830
4831/*
4832 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
4833 *
4834 * This socket option is a boolean flag which turns on or off mapped V4
4835 * addresses. If this option is turned on and the socket is type
4836 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
4837 * If this option is turned off, then no mapping will be done of V4
4838 * addresses and a user will receive both PF_INET6 and PF_INET type
4839 * addresses on the socket.
4840 */
4841static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
4842 char __user *optval, int __user *optlen)
4843{
4844 int val;
4845 struct sctp_sock *sp = sctp_sk(sk);
4846
4847 if (len < sizeof(int))
4848 return -EINVAL;
4849
4850 len = sizeof(int);
4851 val = sp->v4mapped;
4852 if (put_user(len, optlen))
4853 return -EFAULT;
4854 if (copy_to_user(optval, &val, len))
4855 return -EFAULT;
4856
4857 return 0;
4858}
4859
4860/*
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08004861 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
4862 * (chapter and verse is quoted at sctp_setsockopt_context())
4863 */
4864static int sctp_getsockopt_context(struct sock *sk, int len,
4865 char __user *optval, int __user *optlen)
4866{
4867 struct sctp_assoc_value params;
4868 struct sctp_sock *sp;
4869 struct sctp_association *asoc;
4870
Neil Horman408f22e2007-06-16 14:03:45 -04004871 if (len < sizeof(struct sctp_assoc_value))
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08004872 return -EINVAL;
4873
Neil Horman408f22e2007-06-16 14:03:45 -04004874 len = sizeof(struct sctp_assoc_value);
4875
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08004876 if (copy_from_user(&params, optval, len))
4877 return -EFAULT;
4878
4879 sp = sctp_sk(sk);
4880
4881 if (params.assoc_id != 0) {
4882 asoc = sctp_id2assoc(sk, params.assoc_id);
4883 if (!asoc)
4884 return -EINVAL;
4885 params.assoc_value = asoc->default_rcv_context;
4886 } else {
4887 params.assoc_value = sp->default_rcv_context;
4888 }
4889
4890 if (put_user(len, optlen))
4891 return -EFAULT;
4892 if (copy_to_user(optval, &params, len))
4893 return -EFAULT;
4894
4895 return 0;
4896}
4897
4898/*
Wei Yongjune89c2092008-12-25 16:54:58 -08004899 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
4900 * This option will get or set the maximum size to put in any outgoing
4901 * SCTP DATA chunk. If a message is larger than this size it will be
Linus Torvalds1da177e2005-04-16 15:20:36 -07004902 * fragmented by SCTP into the specified size. Note that the underlying
4903 * SCTP implementation may fragment into smaller sized chunks when the
4904 * PMTU of the underlying association is smaller than the value set by
Wei Yongjune89c2092008-12-25 16:54:58 -08004905 * the user. The default value for this option is '0' which indicates
4906 * the user is NOT limiting fragmentation and only the PMTU will effect
4907 * SCTP's choice of DATA chunk size. Note also that values set larger
4908 * than the maximum size of an IP datagram will effectively let SCTP
4909 * control fragmentation (i.e. the same as setting this option to 0).
4910 *
4911 * The following structure is used to access and modify this parameter:
4912 *
4913 * struct sctp_assoc_value {
4914 * sctp_assoc_t assoc_id;
4915 * uint32_t assoc_value;
4916 * };
4917 *
4918 * assoc_id: This parameter is ignored for one-to-one style sockets.
4919 * For one-to-many style sockets this parameter indicates which
4920 * association the user is performing an action upon. Note that if
4921 * this field's value is zero then the endpoints default value is
4922 * changed (effecting future associations only).
4923 * assoc_value: This parameter specifies the maximum size in bytes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004924 */
4925static int sctp_getsockopt_maxseg(struct sock *sk, int len,
4926 char __user *optval, int __user *optlen)
4927{
Wei Yongjune89c2092008-12-25 16:54:58 -08004928 struct sctp_assoc_value params;
4929 struct sctp_association *asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004930
Wei Yongjune89c2092008-12-25 16:54:58 -08004931 if (len == sizeof(int)) {
4932 printk(KERN_WARNING
4933 "SCTP: Use of int in maxseg socket option deprecated\n");
4934 printk(KERN_WARNING
4935 "SCTP: Use struct sctp_assoc_value instead\n");
4936 params.assoc_id = 0;
4937 } else if (len >= sizeof(struct sctp_assoc_value)) {
4938 len = sizeof(struct sctp_assoc_value);
4939 if (copy_from_user(&params, optval, sizeof(params)))
4940 return -EFAULT;
4941 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07004942 return -EINVAL;
4943
Wei Yongjune89c2092008-12-25 16:54:58 -08004944 asoc = sctp_id2assoc(sk, params.assoc_id);
4945 if (!asoc && params.assoc_id && sctp_style(sk, UDP))
4946 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004947
Wei Yongjune89c2092008-12-25 16:54:58 -08004948 if (asoc)
4949 params.assoc_value = asoc->frag_point;
4950 else
4951 params.assoc_value = sctp_sk(sk)->user_frag;
4952
Linus Torvalds1da177e2005-04-16 15:20:36 -07004953 if (put_user(len, optlen))
4954 return -EFAULT;
Wei Yongjune89c2092008-12-25 16:54:58 -08004955 if (len == sizeof(int)) {
4956 if (copy_to_user(optval, &params.assoc_value, len))
4957 return -EFAULT;
4958 } else {
4959 if (copy_to_user(optval, &params, len))
4960 return -EFAULT;
4961 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004962
4963 return 0;
4964}
4965
Vlad Yasevichb6e13312007-04-20 12:23:15 -07004966/*
4967 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
4968 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
4969 */
4970static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
4971 char __user *optval, int __user *optlen)
4972{
4973 int val;
4974
4975 if (len < sizeof(int))
4976 return -EINVAL;
4977
4978 len = sizeof(int);
4979
4980 val = sctp_sk(sk)->frag_interleave;
4981 if (put_user(len, optlen))
4982 return -EFAULT;
4983 if (copy_to_user(optval, &val, len))
4984 return -EFAULT;
4985
4986 return 0;
4987}
4988
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07004989/*
4990 * 7.1.25. Set or Get the sctp partial delivery point
4991 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
4992 */
4993static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
4994 char __user *optval,
4995 int __user *optlen)
4996{
YOSHIFUJI Hideaki9cbcbf42007-07-19 10:44:50 +09004997 u32 val;
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07004998
4999 if (len < sizeof(u32))
5000 return -EINVAL;
5001
5002 len = sizeof(u32);
5003
5004 val = sctp_sk(sk)->pd_point;
5005 if (put_user(len, optlen))
5006 return -EFAULT;
5007 if (copy_to_user(optval, &val, len))
5008 return -EFAULT;
5009
5010 return -ENOTSUPP;
5011}
5012
Vlad Yasevich70331572007-03-23 11:34:36 -07005013/*
5014 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
5015 * (chapter and verse is quoted at sctp_setsockopt_maxburst())
5016 */
5017static int sctp_getsockopt_maxburst(struct sock *sk, int len,
5018 char __user *optval,
5019 int __user *optlen)
5020{
Neil Horman219b99a2008-03-05 13:44:46 -08005021 struct sctp_assoc_value params;
5022 struct sctp_sock *sp;
5023 struct sctp_association *asoc;
Vlad Yasevich70331572007-03-23 11:34:36 -07005024
Neil Horman219b99a2008-03-05 13:44:46 -08005025 if (len == sizeof(int)) {
5026 printk(KERN_WARNING
5027 "SCTP: Use of int in max_burst socket option deprecated\n");
5028 printk(KERN_WARNING
5029 "SCTP: Use struct sctp_assoc_value instead\n");
5030 params.assoc_id = 0;
Wei Yongjunc6db93a2009-03-02 09:46:12 +00005031 } else if (len >= sizeof(struct sctp_assoc_value)) {
5032 len = sizeof(struct sctp_assoc_value);
Neil Horman219b99a2008-03-05 13:44:46 -08005033 if (copy_from_user(&params, optval, len))
5034 return -EFAULT;
5035 } else
5036 return -EINVAL;
Vlad Yasevich70331572007-03-23 11:34:36 -07005037
Neil Horman219b99a2008-03-05 13:44:46 -08005038 sp = sctp_sk(sk);
Vlad Yasevich70331572007-03-23 11:34:36 -07005039
Neil Horman219b99a2008-03-05 13:44:46 -08005040 if (params.assoc_id != 0) {
5041 asoc = sctp_id2assoc(sk, params.assoc_id);
5042 if (!asoc)
5043 return -EINVAL;
5044 params.assoc_value = asoc->max_burst;
5045 } else
5046 params.assoc_value = sp->max_burst;
5047
5048 if (len == sizeof(int)) {
5049 if (copy_to_user(optval, &params.assoc_value, len))
5050 return -EFAULT;
5051 } else {
5052 if (copy_to_user(optval, &params, len))
5053 return -EFAULT;
5054 }
5055
5056 return 0;
5057
Vlad Yasevich70331572007-03-23 11:34:36 -07005058}
5059
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005060static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
5061 char __user *optval, int __user *optlen)
5062{
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005063 struct sctp_hmacalgo __user *p = (void __user *)optval;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005064 struct sctp_hmac_algo_param *hmacs;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005065 __u16 data_len = 0;
5066 u32 num_idents;
5067
5068 if (!sctp_auth_enable)
5069 return -EACCES;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005070
5071 hmacs = sctp_sk(sk)->ep->auth_hmacs_list;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005072 data_len = ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t);
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005073
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005074 if (len < sizeof(struct sctp_hmacalgo) + data_len)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005075 return -EINVAL;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005076
5077 len = sizeof(struct sctp_hmacalgo) + data_len;
5078 num_idents = data_len / sizeof(u16);
5079
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005080 if (put_user(len, optlen))
5081 return -EFAULT;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005082 if (put_user(num_idents, &p->shmac_num_idents))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005083 return -EFAULT;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005084 if (copy_to_user(p->shmac_idents, hmacs->hmac_ids, data_len))
5085 return -EFAULT;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005086 return 0;
5087}
5088
5089static int sctp_getsockopt_active_key(struct sock *sk, int len,
5090 char __user *optval, int __user *optlen)
5091{
5092 struct sctp_authkeyid val;
5093 struct sctp_association *asoc;
5094
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005095 if (!sctp_auth_enable)
5096 return -EACCES;
5097
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005098 if (len < sizeof(struct sctp_authkeyid))
5099 return -EINVAL;
5100 if (copy_from_user(&val, optval, sizeof(struct sctp_authkeyid)))
5101 return -EFAULT;
5102
5103 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
5104 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
5105 return -EINVAL;
5106
5107 if (asoc)
5108 val.scact_keynumber = asoc->active_key_id;
5109 else
5110 val.scact_keynumber = sctp_sk(sk)->ep->active_key_id;
5111
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005112 len = sizeof(struct sctp_authkeyid);
5113 if (put_user(len, optlen))
5114 return -EFAULT;
5115 if (copy_to_user(optval, &val, len))
5116 return -EFAULT;
5117
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005118 return 0;
5119}
5120
5121static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
5122 char __user *optval, int __user *optlen)
5123{
Al Viro411223c2007-10-14 19:21:20 +01005124 struct sctp_authchunks __user *p = (void __user *)optval;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005125 struct sctp_authchunks val;
5126 struct sctp_association *asoc;
5127 struct sctp_chunks_param *ch;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005128 u32 num_chunks = 0;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005129 char __user *to;
5130
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005131 if (!sctp_auth_enable)
5132 return -EACCES;
5133
5134 if (len < sizeof(struct sctp_authchunks))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005135 return -EINVAL;
5136
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005137 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005138 return -EFAULT;
5139
Al Viro411223c2007-10-14 19:21:20 +01005140 to = p->gauth_chunks;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005141 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
5142 if (!asoc)
5143 return -EINVAL;
5144
5145 ch = asoc->peer.peer_chunks;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005146 if (!ch)
5147 goto num;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005148
5149 /* See if the user provided enough room for all the data */
Vlad Yasevichb40db682008-02-27 14:40:37 -05005150 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
5151 if (len < num_chunks)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005152 return -EINVAL;
5153
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005154 if (copy_to_user(to, ch->chunks, num_chunks))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005155 return -EFAULT;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005156num:
5157 len = sizeof(struct sctp_authchunks) + num_chunks;
5158 if (put_user(len, optlen)) return -EFAULT;
Vlad Yasevich7e8616d2008-02-27 16:04:52 -05005159 if (put_user(num_chunks, &p->gauth_number_of_chunks))
5160 return -EFAULT;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005161 return 0;
5162}
5163
5164static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
5165 char __user *optval, int __user *optlen)
5166{
Al Viro411223c2007-10-14 19:21:20 +01005167 struct sctp_authchunks __user *p = (void __user *)optval;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005168 struct sctp_authchunks val;
5169 struct sctp_association *asoc;
5170 struct sctp_chunks_param *ch;
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005171 u32 num_chunks = 0;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005172 char __user *to;
5173
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005174 if (!sctp_auth_enable)
5175 return -EACCES;
5176
5177 if (len < sizeof(struct sctp_authchunks))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005178 return -EINVAL;
5179
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005180 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005181 return -EFAULT;
5182
Al Viro411223c2007-10-14 19:21:20 +01005183 to = p->gauth_chunks;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005184 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
5185 if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP))
5186 return -EINVAL;
5187
5188 if (asoc)
5189 ch = (struct sctp_chunks_param*)asoc->c.auth_chunks;
5190 else
5191 ch = sctp_sk(sk)->ep->auth_chunk_list;
5192
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005193 if (!ch)
5194 goto num;
5195
Vlad Yasevichb40db682008-02-27 14:40:37 -05005196 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005197 if (len < sizeof(struct sctp_authchunks) + num_chunks)
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005198 return -EINVAL;
5199
Vlad Yasevich5e739d12008-08-21 03:34:25 -07005200 if (copy_to_user(to, ch->chunks, num_chunks))
5201 return -EFAULT;
5202num:
5203 len = sizeof(struct sctp_authchunks) + num_chunks;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005204 if (put_user(len, optlen))
5205 return -EFAULT;
Vlad Yasevich7e8616d2008-02-27 16:04:52 -05005206 if (put_user(num_chunks, &p->gauth_number_of_chunks))
5207 return -EFAULT;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005208
5209 return 0;
5210}
5211
Wei Yongjunaea3c5c2008-12-25 16:57:24 -08005212/*
5213 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
5214 * This option gets the current number of associations that are attached
5215 * to a one-to-many style socket. The option value is an uint32_t.
5216 */
5217static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
5218 char __user *optval, int __user *optlen)
5219{
5220 struct sctp_sock *sp = sctp_sk(sk);
5221 struct sctp_association *asoc;
5222 u32 val = 0;
5223
5224 if (sctp_style(sk, TCP))
5225 return -EOPNOTSUPP;
5226
5227 if (len < sizeof(u32))
5228 return -EINVAL;
5229
5230 len = sizeof(u32);
5231
5232 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
5233 val++;
5234 }
5235
5236 if (put_user(len, optlen))
5237 return -EFAULT;
5238 if (copy_to_user(optval, &val, len))
5239 return -EFAULT;
5240
5241 return 0;
5242}
5243
Linus Torvalds1da177e2005-04-16 15:20:36 -07005244SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
5245 char __user *optval, int __user *optlen)
5246{
5247 int retval = 0;
5248 int len;
5249
Frank Filz3f7a87d2005-06-20 13:14:57 -07005250 SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n",
5251 sk, optname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005252
5253 /* I can hardly begin to describe how wrong this is. This is
5254 * so broken as to be worse than useless. The API draft
5255 * REALLY is NOT helpful here... I am not convinced that the
5256 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
5257 * are at all well-founded.
5258 */
5259 if (level != SOL_SCTP) {
5260 struct sctp_af *af = sctp_sk(sk)->pf->af;
5261
5262 retval = af->getsockopt(sk, level, optname, optval, optlen);
5263 return retval;
5264 }
5265
5266 if (get_user(len, optlen))
5267 return -EFAULT;
5268
5269 sctp_lock_sock(sk);
5270
5271 switch (optname) {
5272 case SCTP_STATUS:
5273 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
5274 break;
5275 case SCTP_DISABLE_FRAGMENTS:
5276 retval = sctp_getsockopt_disable_fragments(sk, len, optval,
5277 optlen);
5278 break;
5279 case SCTP_EVENTS:
5280 retval = sctp_getsockopt_events(sk, len, optval, optlen);
5281 break;
5282 case SCTP_AUTOCLOSE:
5283 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
5284 break;
5285 case SCTP_SOCKOPT_PEELOFF:
5286 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
5287 break;
5288 case SCTP_PEER_ADDR_PARAMS:
5289 retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
5290 optlen);
5291 break;
Wei Yongjund364d922008-05-09 15:13:26 -07005292 case SCTP_DELAYED_ACK:
5293 retval = sctp_getsockopt_delayed_ack(sk, len, optval,
Frank Filz77086102005-12-22 11:37:30 -08005294 optlen);
5295 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005296 case SCTP_INITMSG:
5297 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
5298 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005299 case SCTP_GET_PEER_ADDRS:
5300 retval = sctp_getsockopt_peer_addrs(sk, len, optval,
5301 optlen);
5302 break;
5303 case SCTP_GET_LOCAL_ADDRS:
5304 retval = sctp_getsockopt_local_addrs(sk, len, optval,
5305 optlen);
5306 break;
Vlad Yasevichc6ba68a2009-06-01 12:41:15 -04005307 case SCTP_SOCKOPT_CONNECTX3:
5308 retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
5309 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005310 case SCTP_DEFAULT_SEND_PARAM:
5311 retval = sctp_getsockopt_default_send_param(sk, len,
5312 optval, optlen);
5313 break;
5314 case SCTP_PRIMARY_ADDR:
5315 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
5316 break;
5317 case SCTP_NODELAY:
5318 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
5319 break;
5320 case SCTP_RTOINFO:
5321 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
5322 break;
5323 case SCTP_ASSOCINFO:
5324 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
5325 break;
5326 case SCTP_I_WANT_MAPPED_V4_ADDR:
5327 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
5328 break;
5329 case SCTP_MAXSEG:
5330 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
5331 break;
5332 case SCTP_GET_PEER_ADDR_INFO:
5333 retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
5334 optlen);
5335 break;
Ivan Skytte Jorgensen0f3fffd2006-12-20 16:07:04 -08005336 case SCTP_ADAPTATION_LAYER:
5337 retval = sctp_getsockopt_adaptation_layer(sk, len, optval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005338 optlen);
5339 break;
Ivan Skytte Jorgensen6ab792f2006-12-13 16:34:22 -08005340 case SCTP_CONTEXT:
5341 retval = sctp_getsockopt_context(sk, len, optval, optlen);
5342 break;
Vlad Yasevichb6e13312007-04-20 12:23:15 -07005343 case SCTP_FRAGMENT_INTERLEAVE:
5344 retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
5345 optlen);
5346 break;
Vlad Yasevichd49d91d2007-03-23 11:32:00 -07005347 case SCTP_PARTIAL_DELIVERY_POINT:
5348 retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
5349 optlen);
5350 break;
Vlad Yasevich70331572007-03-23 11:34:36 -07005351 case SCTP_MAX_BURST:
5352 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
5353 break;
Vlad Yasevich65b07e52007-09-16 19:34:00 -07005354 case SCTP_AUTH_KEY:
5355 case SCTP_AUTH_CHUNK:
5356 case SCTP_AUTH_DELETE_KEY:
5357 retval = -EOPNOTSUPP;
5358 break;
5359 case SCTP_HMAC_IDENT:
5360 retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
5361 break;
5362 case SCTP_AUTH_ACTIVE_KEY:
5363 retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
5364 break;
5365 case SCTP_PEER_AUTH_CHUNKS:
5366 retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
5367 optlen);
5368 break;
5369 case SCTP_LOCAL_AUTH_CHUNKS:
5370 retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
5371 optlen);
5372 break;
Wei Yongjunaea3c5c2008-12-25 16:57:24 -08005373 case SCTP_GET_ASSOC_NUMBER:
5374 retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
5375 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005376 default:
5377 retval = -ENOPROTOOPT;
5378 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07005379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005380
5381 sctp_release_sock(sk);
5382 return retval;
5383}
5384
5385static void sctp_hash(struct sock *sk)
5386{
5387 /* STUB */
5388}
5389
5390static void sctp_unhash(struct sock *sk)
5391{
5392 /* STUB */
5393}
5394
5395/* Check if port is acceptable. Possibly find first available port.
5396 *
5397 * The port hash table (contained in the 'global' SCTP protocol storage
5398 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
5399 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
5400 * list (the list number is the port number hashed out, so as you
5401 * would expect from a hash function, all the ports in a given list have
5402 * such a number that hashes out to the same list number; you were
5403 * expecting that, right?); so each list has a set of ports, with a
5404 * link to the socket (struct sock) that uses it, the port number and
5405 * a fastreuse flag (FIXME: NPI ipg).
5406 */
5407static struct sctp_bind_bucket *sctp_bucket_create(
5408 struct sctp_bind_hashbucket *head, unsigned short snum);
5409
5410static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
5411{
5412 struct sctp_bind_hashbucket *head; /* hash list */
5413 struct sctp_bind_bucket *pp; /* hash list port iterator */
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05005414 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005415 unsigned short snum;
5416 int ret;
5417
Al Viro04afd8b2006-11-20 17:02:01 -08005418 snum = ntohs(addr->v4.sin_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005419
5420 SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum);
5421 sctp_local_bh_disable();
5422
5423 if (snum == 0) {
Stephen Hemminger06393002007-10-10 17:30:18 -07005424 /* Search for an available port. */
Stephen Hemminger227b60f2007-10-10 17:30:46 -07005425 int low, high, remaining, index;
5426 unsigned int rover;
5427
5428 inet_get_local_port_range(&low, &high);
5429 remaining = (high - low) + 1;
5430 rover = net_random() % remaining + low;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005431
Linus Torvalds1da177e2005-04-16 15:20:36 -07005432 do {
5433 rover++;
5434 if ((rover < low) || (rover > high))
5435 rover = low;
Amerigo Wange3826f12010-05-05 00:27:06 +00005436 if (inet_is_reserved_local_port(rover))
5437 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005438 index = sctp_phashfn(rover);
5439 head = &sctp_port_hashtable[index];
5440 sctp_spin_lock(&head->lock);
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05005441 sctp_for_each_hentry(pp, node, &head->chain)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005442 if (pp->port == rover)
5443 goto next;
5444 break;
5445 next:
5446 sctp_spin_unlock(&head->lock);
5447 } while (--remaining > 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005448
5449 /* Exhausted local port range during search? */
5450 ret = 1;
5451 if (remaining <= 0)
5452 goto fail;
5453
5454 /* OK, here is the one we will use. HEAD (the port
5455 * hash table list entry) is non-NULL and we hold it's
5456 * mutex.
5457 */
5458 snum = rover;
5459 } else {
5460 /* We are given an specific port number; we verify
5461 * that it is not being used. If it is used, we will
5462 * exahust the search in the hash list corresponding
5463 * to the port number (snum) - we detect that with the
5464 * port iterator, pp being NULL.
5465 */
5466 head = &sctp_port_hashtable[sctp_phashfn(snum)];
5467 sctp_spin_lock(&head->lock);
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05005468 sctp_for_each_hentry(pp, node, &head->chain) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005469 if (pp->port == snum)
5470 goto pp_found;
5471 }
5472 }
5473 pp = NULL;
5474 goto pp_not_found;
5475pp_found:
5476 if (!hlist_empty(&pp->owner)) {
5477 /* We had a port hash table hit - there is an
5478 * available port (pp != NULL) and it is being
5479 * used by other socket (pp->owner not empty); that other
5480 * socket is going to be sk2.
5481 */
5482 int reuse = sk->sk_reuse;
5483 struct sock *sk2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005484
5485 SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");
Vlad Yasevichce5325c2007-05-04 13:34:49 -07005486 if (pp->fastreuse && sk->sk_reuse &&
5487 sk->sk_state != SCTP_SS_LISTENING)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005488 goto success;
5489
5490 /* Run through the list of sockets bound to the port
5491 * (pp->port) [via the pointers bind_next and
5492 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
5493 * we get the endpoint they describe and run through
5494 * the endpoint's list of IP (v4 or v6) addresses,
5495 * comparing each of the addresses with the address of
5496 * the socket sk. If we find a match, then that means
5497 * that this port/socket (sk) combination are already
5498 * in an endpoint.
5499 */
5500 sk_for_each_bound(sk2, node, &pp->owner) {
5501 struct sctp_endpoint *ep2;
5502 ep2 = sctp_sk(sk2)->ep;
5503
Vlad Yasevich4e540642008-07-18 23:06:32 -07005504 if (sk == sk2 ||
5505 (reuse && sk2->sk_reuse &&
5506 sk2->sk_state != SCTP_SS_LISTENING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005507 continue;
5508
Vlad Yasevich7dab83d2008-07-18 23:05:40 -07005509 if (sctp_bind_addr_conflict(&ep2->base.bind_addr, addr,
5510 sctp_sk(sk2), sctp_sk(sk))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005511 ret = (long)sk2;
5512 goto fail_unlock;
5513 }
5514 }
5515 SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n");
5516 }
5517pp_not_found:
5518 /* If there was a hash table miss, create a new port. */
5519 ret = 1;
5520 if (!pp && !(pp = sctp_bucket_create(head, snum)))
5521 goto fail_unlock;
5522
5523 /* In either case (hit or miss), make sure fastreuse is 1 only
5524 * if sk->sk_reuse is too (that is, if the caller requested
5525 * SO_REUSEADDR on this socket -sk-).
5526 */
Vlad Yasevichce5325c2007-05-04 13:34:49 -07005527 if (hlist_empty(&pp->owner)) {
5528 if (sk->sk_reuse && sk->sk_state != SCTP_SS_LISTENING)
5529 pp->fastreuse = 1;
5530 else
5531 pp->fastreuse = 0;
5532 } else if (pp->fastreuse &&
5533 (!sk->sk_reuse || sk->sk_state == SCTP_SS_LISTENING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005534 pp->fastreuse = 0;
5535
5536 /* We are set, so fill up all the data in the hash table
5537 * entry, tie the socket list information with the rest of the
5538 * sockets FIXME: Blurry, NPI (ipg).
5539 */
5540success:
Linus Torvalds1da177e2005-04-16 15:20:36 -07005541 if (!sctp_sk(sk)->bind_hash) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00005542 inet_sk(sk)->inet_num = snum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543 sk_add_bind_node(sk, &pp->owner);
5544 sctp_sk(sk)->bind_hash = pp;
5545 }
5546 ret = 0;
5547
5548fail_unlock:
5549 sctp_spin_unlock(&head->lock);
5550
5551fail:
5552 sctp_local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005553 return ret;
5554}
5555
5556/* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
5557 * port is requested.
5558 */
5559static int sctp_get_port(struct sock *sk, unsigned short snum)
5560{
5561 long ret;
5562 union sctp_addr addr;
5563 struct sctp_af *af = sctp_sk(sk)->pf->af;
5564
5565 /* Set up a dummy address struct from the sk. */
5566 af->from_sk(&addr, sk);
5567 addr.v4.sin_port = htons(snum);
5568
5569 /* Note: sk->sk_num gets filled in if ephemeral port request. */
5570 ret = sctp_get_port_local(sk, &addr);
5571
5572 return (ret ? 1 : 0);
5573}
5574
5575/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07005576 * Move a socket to LISTENING state.
5577 */
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005578SCTP_STATIC int sctp_listen_start(struct sock *sk, int backlog)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005579{
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005580 struct sctp_sock *sp = sctp_sk(sk);
5581 struct sctp_endpoint *ep = sp->ep;
Herbert Xu1b489e12006-08-20 15:07:14 +10005582 struct crypto_hash *tfm = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005583
5584 /* Allocate HMAC for generating cookie. */
Vlad Yasevich23b29ed2008-07-18 23:06:07 -07005585 if (!sctp_sk(sk)->hmac && sctp_hmac_alg) {
Herbert Xu1b489e12006-08-20 15:07:14 +10005586 tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC);
Vlad Yasevich8dc49842007-05-09 13:50:20 -07005587 if (IS_ERR(tfm)) {
5588 if (net_ratelimit()) {
5589 printk(KERN_INFO
5590 "SCTP: failed to load transform for %s: %ld\n",
5591 sctp_hmac_alg, PTR_ERR(tfm));
5592 }
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005593 return -ENOSYS;
5594 }
5595 sctp_sk(sk)->hmac = tfm;
5596 }
5597
5598 /*
5599 * If a bind() or sctp_bindx() is not called prior to a listen()
5600 * call that allows new associations to be accepted, the system
5601 * picks an ephemeral port and will choose an address set equivalent
5602 * to binding with a wildcard address.
5603 *
5604 * This is not currently spelled out in the SCTP sockets
5605 * extensions draft, but follows the practice as seen in TCP
5606 * sockets.
5607 *
5608 */
5609 sk->sk_state = SCTP_SS_LISTENING;
5610 if (!ep->base.bind_addr.port) {
5611 if (sctp_autobind(sk))
5612 return -EAGAIN;
5613 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00005614 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005615 sk->sk_state = SCTP_SS_CLOSED;
5616 return -EADDRINUSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005617 }
5618 }
5619
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005620 sk->sk_max_ack_backlog = backlog;
5621 sctp_hash_endpoint(ep);
5622 return 0;
5623}
5624
5625/*
5626 * 4.1.3 / 5.1.3 listen()
5627 *
5628 * By default, new associations are not accepted for UDP style sockets.
5629 * An application uses listen() to mark a socket as being able to
5630 * accept new associations.
5631 *
5632 * On TCP style sockets, applications use listen() to ready the SCTP
5633 * endpoint for accepting inbound associations.
5634 *
5635 * On both types of endpoints a backlog of '0' disables listening.
5636 *
5637 * Move a socket to LISTENING state.
5638 */
5639int sctp_inet_listen(struct socket *sock, int backlog)
5640{
5641 struct sock *sk = sock->sk;
5642 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
5643 int err = -EINVAL;
5644
5645 if (unlikely(backlog < 0))
5646 return err;
5647
5648 sctp_lock_sock(sk);
5649
5650 /* Peeled-off sockets are not allowed to listen(). */
5651 if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
5652 goto out;
5653
5654 if (sock->state != SS_UNCONNECTED)
5655 goto out;
5656
5657 /* If backlog is zero, disable listening. */
5658 if (!backlog) {
5659 if (sctp_sstate(sk, CLOSED))
5660 goto out;
5661
5662 err = 0;
5663 sctp_unhash_endpoint(ep);
5664 sk->sk_state = SCTP_SS_CLOSED;
5665 if (sk->sk_reuse)
5666 sctp_sk(sk)->bind_hash->fastreuse = 1;
5667 goto out;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07005668 }
5669
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005670 /* If we are already listening, just update the backlog */
5671 if (sctp_sstate(sk, LISTENING))
5672 sk->sk_max_ack_backlog = backlog;
5673 else {
5674 err = sctp_listen_start(sk, backlog);
5675 if (err)
5676 goto out;
5677 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005678
Vlad Yasevich5e8f3f72009-03-12 09:49:17 +00005679 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005680out:
5681 sctp_release_sock(sk);
5682 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005683}
5684
5685/*
5686 * This function is done by modeling the current datagram_poll() and the
5687 * tcp_poll(). Note that, based on these implementations, we don't
5688 * lock the socket in this function, even though it seems that,
5689 * ideally, locking or some other mechanisms can be used to ensure
Neil Horman9bffc4a2005-12-19 14:24:40 -08005690 * the integrity of the counters (sndbuf and wmem_alloc) used
Linus Torvalds1da177e2005-04-16 15:20:36 -07005691 * in this place. We assume that we don't need locks either until proven
5692 * otherwise.
5693 *
5694 * Another thing to note is that we include the Async I/O support
5695 * here, again, by modeling the current TCP/UDP code. We don't have
5696 * a good way to test with it yet.
5697 */
5698unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
5699{
5700 struct sock *sk = sock->sk;
5701 struct sctp_sock *sp = sctp_sk(sk);
5702 unsigned int mask;
5703
Eric Dumazetaa395142010-04-20 13:03:51 +00005704 poll_wait(file, sk_sleep(sk), wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005705
5706 /* A TCP-style listening socket becomes readable when the accept queue
5707 * is not empty.
5708 */
5709 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
5710 return (!list_empty(&sp->ep->asocs)) ?
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09005711 (POLLIN | POLLRDNORM) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005712
5713 mask = 0;
5714
5715 /* Is there any exceptional events? */
5716 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
5717 mask |= POLLERR;
Davide Libenzif348d702006-03-25 03:07:39 -08005718 if (sk->sk_shutdown & RCV_SHUTDOWN)
5719 mask |= POLLRDHUP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005720 if (sk->sk_shutdown == SHUTDOWN_MASK)
5721 mask |= POLLHUP;
5722
5723 /* Is it readable? Reconsider this code with TCP-style support. */
5724 if (!skb_queue_empty(&sk->sk_receive_queue) ||
5725 (sk->sk_shutdown & RCV_SHUTDOWN))
5726 mask |= POLLIN | POLLRDNORM;
5727
5728 /* The association is either gone or not ready. */
5729 if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
5730 return mask;
5731
5732 /* Is it writable? */
5733 if (sctp_writeable(sk)) {
5734 mask |= POLLOUT | POLLWRNORM;
5735 } else {
5736 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
5737 /*
5738 * Since the socket is not locked, the buffer
5739 * might be made available after the writeable check and
5740 * before the bit is set. This could cause a lost I/O
5741 * signal. tcp_poll() has a race breaker for this race
5742 * condition. Based on their implementation, we put
5743 * in the following code to cover it as well.
5744 */
5745 if (sctp_writeable(sk))
5746 mask |= POLLOUT | POLLWRNORM;
5747 }
5748 return mask;
5749}
5750
5751/********************************************************************
5752 * 2nd Level Abstractions
5753 ********************************************************************/
5754
5755static struct sctp_bind_bucket *sctp_bucket_create(
5756 struct sctp_bind_hashbucket *head, unsigned short snum)
5757{
5758 struct sctp_bind_bucket *pp;
5759
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08005760 pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005761 if (pp) {
Li Zefan935a7f62008-04-10 01:58:06 -07005762 SCTP_DBG_OBJCNT_INC(bind_bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005763 pp->port = snum;
5764 pp->fastreuse = 0;
5765 INIT_HLIST_HEAD(&pp->owner);
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05005766 hlist_add_head(&pp->node, &head->chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005767 }
5768 return pp;
5769}
5770
5771/* Caller must hold hashbucket lock for this tb with local BH disabled */
5772static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
5773{
Sridhar Samudrala37fa6872006-07-21 14:45:47 -07005774 if (pp && hlist_empty(&pp->owner)) {
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05005775 __hlist_del(&pp->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005776 kmem_cache_free(sctp_bucket_cachep, pp);
5777 SCTP_DBG_OBJCNT_DEC(bind_bucket);
5778 }
5779}
5780
5781/* Release this socket's reference to a local port. */
5782static inline void __sctp_put_port(struct sock *sk)
5783{
5784 struct sctp_bind_hashbucket *head =
Eric Dumazetc720c7e2009-10-15 06:30:45 +00005785 &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->inet_num)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07005786 struct sctp_bind_bucket *pp;
5787
5788 sctp_spin_lock(&head->lock);
5789 pp = sctp_sk(sk)->bind_hash;
5790 __sk_del_bind_node(sk);
5791 sctp_sk(sk)->bind_hash = NULL;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00005792 inet_sk(sk)->inet_num = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005793 sctp_bucket_destroy(pp);
5794 sctp_spin_unlock(&head->lock);
5795}
5796
5797void sctp_put_port(struct sock *sk)
5798{
5799 sctp_local_bh_disable();
5800 __sctp_put_port(sk);
5801 sctp_local_bh_enable();
5802}
5803
5804/*
5805 * The system picks an ephemeral port and choose an address set equivalent
5806 * to binding with a wildcard address.
5807 * One of those addresses will be the primary address for the association.
5808 * This automatically enables the multihoming capability of SCTP.
5809 */
5810static int sctp_autobind(struct sock *sk)
5811{
5812 union sctp_addr autoaddr;
5813 struct sctp_af *af;
Al Viro6fbfa9f2006-11-20 17:24:53 -08005814 __be16 port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005815
5816 /* Initialize a local sockaddr structure to INADDR_ANY. */
5817 af = sctp_sk(sk)->pf->af;
5818
Eric Dumazetc720c7e2009-10-15 06:30:45 +00005819 port = htons(inet_sk(sk)->inet_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005820 af->inaddr_any(&autoaddr, port);
5821
5822 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
5823}
5824
5825/* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
5826 *
5827 * From RFC 2292
5828 * 4.2 The cmsghdr Structure *
5829 *
5830 * When ancillary data is sent or received, any number of ancillary data
5831 * objects can be specified by the msg_control and msg_controllen members of
5832 * the msghdr structure, because each object is preceded by
5833 * a cmsghdr structure defining the object's length (the cmsg_len member).
5834 * Historically Berkeley-derived implementations have passed only one object
5835 * at a time, but this API allows multiple objects to be
5836 * passed in a single call to sendmsg() or recvmsg(). The following example
5837 * shows two ancillary data objects in a control buffer.
5838 *
5839 * |<--------------------------- msg_controllen -------------------------->|
5840 * | |
5841 *
5842 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
5843 *
5844 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
5845 * | | |
5846 *
5847 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
5848 *
5849 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
5850 * | | | | |
5851 *
5852 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5853 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
5854 *
5855 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
5856 *
5857 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5858 * ^
5859 * |
5860 *
5861 * msg_control
5862 * points here
5863 */
5864SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg,
5865 sctp_cmsgs_t *cmsgs)
5866{
5867 struct cmsghdr *cmsg;
Vlad Yasevichab38fb02008-04-12 18:40:06 -07005868 struct msghdr *my_msg = (struct msghdr *)msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005869
5870 for (cmsg = CMSG_FIRSTHDR(msg);
5871 cmsg != NULL;
Vlad Yasevichab38fb02008-04-12 18:40:06 -07005872 cmsg = CMSG_NXTHDR(my_msg, cmsg)) {
5873 if (!CMSG_OK(my_msg, cmsg))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005874 return -EINVAL;
5875
5876 /* Should we parse this header or ignore? */
5877 if (cmsg->cmsg_level != IPPROTO_SCTP)
5878 continue;
5879
5880 /* Strictly check lengths following example in SCM code. */
5881 switch (cmsg->cmsg_type) {
5882 case SCTP_INIT:
5883 /* SCTP Socket API Extension
5884 * 5.2.1 SCTP Initiation Structure (SCTP_INIT)
5885 *
5886 * This cmsghdr structure provides information for
5887 * initializing new SCTP associations with sendmsg().
5888 * The SCTP_INITMSG socket option uses this same data
5889 * structure. This structure is not used for
5890 * recvmsg().
5891 *
5892 * cmsg_level cmsg_type cmsg_data[]
5893 * ------------ ------------ ----------------------
5894 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
5895 */
5896 if (cmsg->cmsg_len !=
5897 CMSG_LEN(sizeof(struct sctp_initmsg)))
5898 return -EINVAL;
5899 cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg);
5900 break;
5901
5902 case SCTP_SNDRCV:
5903 /* SCTP Socket API Extension
5904 * 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV)
5905 *
5906 * This cmsghdr structure specifies SCTP options for
5907 * sendmsg() and describes SCTP header information
5908 * about a received message through recvmsg().
5909 *
5910 * cmsg_level cmsg_type cmsg_data[]
5911 * ------------ ------------ ----------------------
5912 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
5913 */
5914 if (cmsg->cmsg_len !=
5915 CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
5916 return -EINVAL;
5917
5918 cmsgs->info =
5919 (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
5920
5921 /* Minimally, validate the sinfo_flags. */
5922 if (cmsgs->info->sinfo_flags &
Ivan Skytte Jorgenseneaa5c542005-10-28 15:10:00 -07005923 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
5924 SCTP_ABORT | SCTP_EOF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005925 return -EINVAL;
5926 break;
5927
5928 default:
5929 return -EINVAL;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07005930 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005931 }
5932 return 0;
5933}
5934
5935/*
5936 * Wait for a packet..
5937 * Note: This function is the same function as in core/datagram.c
5938 * with a few modifications to make lksctp work.
5939 */
5940static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p)
5941{
5942 int error;
5943 DEFINE_WAIT(wait);
5944
Eric Dumazetaa395142010-04-20 13:03:51 +00005945 prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005946
5947 /* Socket errors? */
5948 error = sock_error(sk);
5949 if (error)
5950 goto out;
5951
5952 if (!skb_queue_empty(&sk->sk_receive_queue))
5953 goto ready;
5954
5955 /* Socket shut down? */
5956 if (sk->sk_shutdown & RCV_SHUTDOWN)
5957 goto out;
5958
5959 /* Sequenced packets can come disconnected. If so we report the
5960 * problem.
5961 */
5962 error = -ENOTCONN;
5963
5964 /* Is there a good reason to think that we may receive some data? */
5965 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
5966 goto out;
5967
5968 /* Handle signals. */
5969 if (signal_pending(current))
5970 goto interrupted;
5971
5972 /* Let another process have a go. Since we are going to sleep
5973 * anyway. Note: This may cause odd behaviors if the message
5974 * does not fit in the user's buffer, but this seems to be the
5975 * only way to honor MSG_DONTWAIT realistically.
5976 */
5977 sctp_release_sock(sk);
5978 *timeo_p = schedule_timeout(*timeo_p);
5979 sctp_lock_sock(sk);
5980
5981ready:
Eric Dumazetaa395142010-04-20 13:03:51 +00005982 finish_wait(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005983 return 0;
5984
5985interrupted:
5986 error = sock_intr_errno(*timeo_p);
5987
5988out:
Eric Dumazetaa395142010-04-20 13:03:51 +00005989 finish_wait(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005990 *err = error;
5991 return error;
5992}
5993
5994/* Receive a datagram.
5995 * Note: This is pretty much the same routine as in core/datagram.c
5996 * with a few changes to make lksctp work.
5997 */
5998static struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags,
5999 int noblock, int *err)
6000{
6001 int error;
6002 struct sk_buff *skb;
6003 long timeo;
6004
Linus Torvalds1da177e2005-04-16 15:20:36 -07006005 timeo = sock_rcvtimeo(sk, noblock);
6006
6007 SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n",
6008 timeo, MAX_SCHEDULE_TIMEOUT);
6009
6010 do {
6011 /* Again only user level code calls this function,
6012 * so nothing interrupt level
6013 * will suddenly eat the receive_queue.
6014 *
6015 * Look at current nfs client by the way...
6016 * However, this function was corrent in any case. 8)
6017 */
6018 if (flags & MSG_PEEK) {
Herbert Xu1e061ab2005-06-18 22:56:42 -07006019 spin_lock_bh(&sk->sk_receive_queue.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006020 skb = skb_peek(&sk->sk_receive_queue);
6021 if (skb)
6022 atomic_inc(&skb->users);
Herbert Xu1e061ab2005-06-18 22:56:42 -07006023 spin_unlock_bh(&sk->sk_receive_queue.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006024 } else {
6025 skb = skb_dequeue(&sk->sk_receive_queue);
6026 }
6027
6028 if (skb)
6029 return skb;
6030
Neil Horman6736dc32005-12-02 20:30:06 -08006031 /* Caller is allowed not to check sk->sk_err before calling. */
6032 error = sock_error(sk);
6033 if (error)
6034 goto no_packet;
6035
Linus Torvalds1da177e2005-04-16 15:20:36 -07006036 if (sk->sk_shutdown & RCV_SHUTDOWN)
6037 break;
6038
6039 /* User doesn't want to wait. */
6040 error = -EAGAIN;
6041 if (!timeo)
6042 goto no_packet;
6043 } while (sctp_wait_for_packet(sk, err, &timeo) == 0);
6044
6045 return NULL;
6046
6047no_packet:
6048 *err = error;
6049 return NULL;
6050}
6051
6052/* If sndbuf has changed, wake up per association sndbuf waiters. */
6053static void __sctp_write_space(struct sctp_association *asoc)
6054{
6055 struct sock *sk = asoc->base.sk;
6056 struct socket *sock = sk->sk_socket;
6057
6058 if ((sctp_wspace(asoc) > 0) && sock) {
6059 if (waitqueue_active(&asoc->wait))
6060 wake_up_interruptible(&asoc->wait);
6061
6062 if (sctp_writeable(sk)) {
Eric Dumazetaa395142010-04-20 13:03:51 +00006063 if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
6064 wake_up_interruptible(sk_sleep(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07006065
6066 /* Note that we try to include the Async I/O support
6067 * here by modeling from the current TCP/UDP code.
6068 * We have not tested with it yet.
6069 */
Eric Dumazet43815482010-04-29 11:01:49 +00006070 if (sock->wq->fasync_list &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07006071 !(sk->sk_shutdown & SEND_SHUTDOWN))
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08006072 sock_wake_async(sock,
6073 SOCK_WAKE_SPACE, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006074 }
6075 }
6076}
6077
6078/* Do accounting for the sndbuf space.
6079 * Decrement the used sndbuf space of the corresponding association by the
6080 * data size which was just transmitted(freed).
6081 */
6082static void sctp_wfree(struct sk_buff *skb)
6083{
6084 struct sctp_association *asoc;
6085 struct sctp_chunk *chunk;
6086 struct sock *sk;
6087
6088 /* Get the saved chunk pointer. */
6089 chunk = *((struct sctp_chunk **)(skb->cb));
6090 asoc = chunk->asoc;
6091 sk = asoc->base.sk;
Neil Horman4eb701d2005-04-28 12:02:04 -07006092 asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) +
6093 sizeof(struct sk_buff) +
6094 sizeof(struct sctp_chunk);
6095
Neil Horman4eb701d2005-04-28 12:02:04 -07006096 atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
6097
Neil Horman4d93df02007-08-15 16:07:44 -07006098 /*
Hideo Aoki3ab224b2007-12-31 00:11:19 -08006099 * This undoes what is done via sctp_set_owner_w and sk_mem_charge
Neil Horman4d93df02007-08-15 16:07:44 -07006100 */
6101 sk->sk_wmem_queued -= skb->truesize;
Hideo Aoki3ab224b2007-12-31 00:11:19 -08006102 sk_mem_uncharge(sk, skb->truesize);
Neil Horman4d93df02007-08-15 16:07:44 -07006103
Neil Horman4eb701d2005-04-28 12:02:04 -07006104 sock_wfree(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006105 __sctp_write_space(asoc);
6106
6107 sctp_association_put(asoc);
6108}
6109
Vlad Yasevich331c4ee2006-10-09 21:34:04 -07006110/* Do accounting for the receive space on the socket.
6111 * Accounting for the association is done in ulpevent.c
6112 * We set this as a destructor for the cloned data skbs so that
6113 * accounting is done at the correct time.
6114 */
6115void sctp_sock_rfree(struct sk_buff *skb)
6116{
6117 struct sock *sk = skb->sk;
6118 struct sctp_ulpevent *event = sctp_skb2event(skb);
6119
6120 atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
Neil Horman4d93df02007-08-15 16:07:44 -07006121
6122 /*
Hideo Aoki3ab224b2007-12-31 00:11:19 -08006123 * Mimic the behavior of sock_rfree
Neil Horman4d93df02007-08-15 16:07:44 -07006124 */
Hideo Aoki3ab224b2007-12-31 00:11:19 -08006125 sk_mem_uncharge(sk, event->rmem_len);
Vlad Yasevich331c4ee2006-10-09 21:34:04 -07006126}
6127
6128
Linus Torvalds1da177e2005-04-16 15:20:36 -07006129/* Helper function to wait for space in the sndbuf. */
6130static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
6131 size_t msg_len)
6132{
6133 struct sock *sk = asoc->base.sk;
6134 int err = 0;
6135 long current_timeo = *timeo_p;
6136 DEFINE_WAIT(wait);
6137
6138 SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n",
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09006139 asoc, (long)(*timeo_p), msg_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006140
6141 /* Increment the association's refcnt. */
6142 sctp_association_hold(asoc);
6143
6144 /* Wait on the association specific sndbuf space. */
6145 for (;;) {
6146 prepare_to_wait_exclusive(&asoc->wait, &wait,
6147 TASK_INTERRUPTIBLE);
6148 if (!*timeo_p)
6149 goto do_nonblock;
6150 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
6151 asoc->base.dead)
6152 goto do_error;
6153 if (signal_pending(current))
6154 goto do_interrupted;
6155 if (msg_len <= sctp_wspace(asoc))
6156 break;
6157
6158 /* Let another process have a go. Since we are going
6159 * to sleep anyway.
6160 */
6161 sctp_release_sock(sk);
6162 current_timeo = schedule_timeout(current_timeo);
Vladislav Yasevich61c9fed2006-05-19 11:01:18 -07006163 BUG_ON(sk != asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006164 sctp_lock_sock(sk);
6165
6166 *timeo_p = current_timeo;
6167 }
6168
6169out:
6170 finish_wait(&asoc->wait, &wait);
6171
6172 /* Release the association's refcnt. */
6173 sctp_association_put(asoc);
6174
6175 return err;
6176
6177do_error:
6178 err = -EPIPE;
6179 goto out;
6180
6181do_interrupted:
6182 err = sock_intr_errno(*timeo_p);
6183 goto out;
6184
6185do_nonblock:
6186 err = -EAGAIN;
6187 goto out;
6188}
6189
Wei Yongjun561b1732010-04-28 08:47:18 +00006190void sctp_data_ready(struct sock *sk, int len)
6191{
David S. Miller7ef52732010-05-02 21:43:40 -07006192 struct socket_wq *wq;
6193
6194 rcu_read_lock();
6195 wq = rcu_dereference(sk->sk_wq);
6196 if (wq_has_sleeper(wq))
6197 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
Wei Yongjun561b1732010-04-28 08:47:18 +00006198 POLLRDNORM | POLLRDBAND);
6199 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
David S. Miller7ef52732010-05-02 21:43:40 -07006200 rcu_read_unlock();
Wei Yongjun561b1732010-04-28 08:47:18 +00006201}
6202
Linus Torvalds1da177e2005-04-16 15:20:36 -07006203/* If socket sndbuf has changed, wake up all per association waiters. */
6204void sctp_write_space(struct sock *sk)
6205{
6206 struct sctp_association *asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006207
6208 /* Wake up the tasks in each wait queue. */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07006209 list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006210 __sctp_write_space(asoc);
6211 }
6212}
6213
6214/* Is there any sndbuf space available on the socket?
6215 *
Neil Horman9bffc4a2005-12-19 14:24:40 -08006216 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
Linus Torvalds1da177e2005-04-16 15:20:36 -07006217 * associations on the same socket. For a UDP-style socket with
6218 * multiple associations, it is possible for it to be "unwriteable"
6219 * prematurely. I assume that this is acceptable because
6220 * a premature "unwriteable" is better than an accidental "writeable" which
6221 * would cause an unwanted block under certain circumstances. For the 1-1
6222 * UDP-style sockets or TCP-style sockets, this code should work.
6223 * - Daisy
6224 */
6225static int sctp_writeable(struct sock *sk)
6226{
6227 int amt = 0;
6228
Eric Dumazet31e6d362009-06-17 19:05:41 -07006229 amt = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006230 if (amt < 0)
6231 amt = 0;
6232 return amt;
6233}
6234
6235/* Wait for an association to go into ESTABLISHED state. If timeout is 0,
6236 * returns immediately with EINPROGRESS.
6237 */
6238static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
6239{
6240 struct sock *sk = asoc->base.sk;
6241 int err = 0;
6242 long current_timeo = *timeo_p;
6243 DEFINE_WAIT(wait);
6244
Harvey Harrison0dc47872008-03-05 20:47:47 -08006245 SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __func__, asoc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006246 (long)(*timeo_p));
6247
6248 /* Increment the association's refcnt. */
6249 sctp_association_hold(asoc);
6250
6251 for (;;) {
6252 prepare_to_wait_exclusive(&asoc->wait, &wait,
6253 TASK_INTERRUPTIBLE);
6254 if (!*timeo_p)
6255 goto do_nonblock;
6256 if (sk->sk_shutdown & RCV_SHUTDOWN)
6257 break;
6258 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
6259 asoc->base.dead)
6260 goto do_error;
6261 if (signal_pending(current))
6262 goto do_interrupted;
6263
6264 if (sctp_state(asoc, ESTABLISHED))
6265 break;
6266
6267 /* Let another process have a go. Since we are going
6268 * to sleep anyway.
6269 */
6270 sctp_release_sock(sk);
6271 current_timeo = schedule_timeout(current_timeo);
6272 sctp_lock_sock(sk);
6273
6274 *timeo_p = current_timeo;
6275 }
6276
6277out:
6278 finish_wait(&asoc->wait, &wait);
6279
6280 /* Release the association's refcnt. */
6281 sctp_association_put(asoc);
6282
6283 return err;
6284
6285do_error:
Vlad Yasevich81845c22006-01-30 15:59:54 -08006286 if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006287 err = -ETIMEDOUT;
6288 else
6289 err = -ECONNREFUSED;
6290 goto out;
6291
6292do_interrupted:
6293 err = sock_intr_errno(*timeo_p);
6294 goto out;
6295
6296do_nonblock:
6297 err = -EINPROGRESS;
6298 goto out;
6299}
6300
6301static int sctp_wait_for_accept(struct sock *sk, long timeo)
6302{
6303 struct sctp_endpoint *ep;
6304 int err = 0;
6305 DEFINE_WAIT(wait);
6306
6307 ep = sctp_sk(sk)->ep;
6308
6309
6310 for (;;) {
Eric Dumazetaa395142010-04-20 13:03:51 +00006311 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006312 TASK_INTERRUPTIBLE);
6313
6314 if (list_empty(&ep->asocs)) {
6315 sctp_release_sock(sk);
6316 timeo = schedule_timeout(timeo);
6317 sctp_lock_sock(sk);
6318 }
6319
6320 err = -EINVAL;
6321 if (!sctp_sstate(sk, LISTENING))
6322 break;
6323
6324 err = 0;
6325 if (!list_empty(&ep->asocs))
6326 break;
6327
6328 err = sock_intr_errno(timeo);
6329 if (signal_pending(current))
6330 break;
6331
6332 err = -EAGAIN;
6333 if (!timeo)
6334 break;
6335 }
6336
Eric Dumazetaa395142010-04-20 13:03:51 +00006337 finish_wait(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006338
6339 return err;
6340}
6341
sebastian@breakpoint.cc04675212007-07-26 23:21:31 +02006342static void sctp_wait_for_close(struct sock *sk, long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006343{
6344 DEFINE_WAIT(wait);
6345
6346 do {
Eric Dumazetaa395142010-04-20 13:03:51 +00006347 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006348 if (list_empty(&sctp_sk(sk)->ep->asocs))
6349 break;
6350 sctp_release_sock(sk);
6351 timeout = schedule_timeout(timeout);
6352 sctp_lock_sock(sk);
6353 } while (!signal_pending(current) && timeout);
6354
Eric Dumazetaa395142010-04-20 13:03:51 +00006355 finish_wait(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006356}
6357
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006358static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
6359{
6360 struct sk_buff *frag;
6361
6362 if (!skb->data_len)
6363 goto done;
6364
6365 /* Don't forget the fragments. */
David S. Miller1b003be2009-06-09 00:22:35 -07006366 skb_walk_frags(skb, frag)
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006367 sctp_skb_set_owner_r_frag(frag, sk);
6368
6369done:
6370 sctp_skb_set_owner_r(skb, sk);
6371}
6372
Vlad Yasevich914e1c82009-02-13 08:33:44 +00006373void sctp_copy_sock(struct sock *newsk, struct sock *sk,
6374 struct sctp_association *asoc)
6375{
6376 struct inet_sock *inet = inet_sk(sk);
Julia Lawall09cb47a2010-01-21 02:43:20 -08006377 struct inet_sock *newinet;
Vlad Yasevich914e1c82009-02-13 08:33:44 +00006378
6379 newsk->sk_type = sk->sk_type;
6380 newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
6381 newsk->sk_flags = sk->sk_flags;
6382 newsk->sk_no_check = sk->sk_no_check;
6383 newsk->sk_reuse = sk->sk_reuse;
6384
6385 newsk->sk_shutdown = sk->sk_shutdown;
6386 newsk->sk_destruct = inet_sock_destruct;
6387 newsk->sk_family = sk->sk_family;
6388 newsk->sk_protocol = IPPROTO_SCTP;
6389 newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
6390 newsk->sk_sndbuf = sk->sk_sndbuf;
6391 newsk->sk_rcvbuf = sk->sk_rcvbuf;
6392 newsk->sk_lingertime = sk->sk_lingertime;
6393 newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
6394 newsk->sk_sndtimeo = sk->sk_sndtimeo;
6395
6396 newinet = inet_sk(newsk);
6397
6398 /* Initialize sk's sport, dport, rcv_saddr and daddr for
6399 * getsockname() and getpeername()
6400 */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00006401 newinet->inet_sport = inet->inet_sport;
6402 newinet->inet_saddr = inet->inet_saddr;
6403 newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
6404 newinet->inet_dport = htons(asoc->peer.port);
Vlad Yasevich914e1c82009-02-13 08:33:44 +00006405 newinet->pmtudisc = inet->pmtudisc;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00006406 newinet->inet_id = asoc->next_tsn ^ jiffies;
Vlad Yasevich914e1c82009-02-13 08:33:44 +00006407
6408 newinet->uc_ttl = inet->uc_ttl;
6409 newinet->mc_loop = 1;
6410 newinet->mc_ttl = 1;
6411 newinet->mc_index = 0;
6412 newinet->mc_list = NULL;
6413}
6414
Linus Torvalds1da177e2005-04-16 15:20:36 -07006415/* Populate the fields of the newsk from the oldsk and migrate the assoc
6416 * and its messages to the newsk.
6417 */
6418static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
6419 struct sctp_association *assoc,
6420 sctp_socket_type_t type)
6421{
6422 struct sctp_sock *oldsp = sctp_sk(oldsk);
6423 struct sctp_sock *newsp = sctp_sk(newsk);
6424 struct sctp_bind_bucket *pp; /* hash list port iterator */
6425 struct sctp_endpoint *newep = newsp->ep;
6426 struct sk_buff *skb, *tmp;
6427 struct sctp_ulpevent *event;
Vlad Yasevichf26f7c42007-12-06 22:50:27 -08006428 struct sctp_bind_hashbucket *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006429
6430 /* Migrate socket buffer sizes and all the socket level options to the
6431 * new socket.
6432 */
6433 newsk->sk_sndbuf = oldsk->sk_sndbuf;
6434 newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
6435 /* Brute force copy old sctp opt. */
6436 inet_sk_copy_descendant(newsk, oldsk);
6437
6438 /* Restore the ep value that was overwritten with the above structure
6439 * copy.
6440 */
6441 newsp->ep = newep;
6442 newsp->hmac = NULL;
6443
6444 /* Hook this new socket in to the bind_hash list. */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00006445 head = &sctp_port_hashtable[sctp_phashfn(inet_sk(oldsk)->inet_num)];
Vlad Yasevichf26f7c42007-12-06 22:50:27 -08006446 sctp_local_bh_disable();
6447 sctp_spin_lock(&head->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006448 pp = sctp_sk(oldsk)->bind_hash;
6449 sk_add_bind_node(newsk, &pp->owner);
6450 sctp_sk(newsk)->bind_hash = pp;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00006451 inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
Vlad Yasevichf26f7c42007-12-06 22:50:27 -08006452 sctp_spin_unlock(&head->lock);
6453 sctp_local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006454
Vladislav Yasevich4243cac2005-06-13 15:10:49 -07006455 /* Copy the bind_addr list from the original endpoint to the new
6456 * endpoint so that we can handle restarts properly
6457 */
Vlad Yasevich8e71a112007-12-06 22:50:54 -08006458 sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
6459 &oldsp->ep->base.bind_addr, GFP_KERNEL);
Vladislav Yasevich4243cac2005-06-13 15:10:49 -07006460
Linus Torvalds1da177e2005-04-16 15:20:36 -07006461 /* Move any messages in the old socket's receive queue that are for the
6462 * peeled off association to the new socket's receive queue.
6463 */
6464 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
6465 event = sctp_skb2event(skb);
6466 if (event->asoc == assoc) {
David S. Miller8728b832005-08-09 19:25:21 -07006467 __skb_unlink(skb, &oldsk->sk_receive_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006468 __skb_queue_tail(&newsk->sk_receive_queue, skb);
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006469 sctp_skb_set_owner_r_frag(skb, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006470 }
6471 }
6472
6473 /* Clean up any messages pending delivery due to partial
6474 * delivery. Three cases:
6475 * 1) No partial deliver; no work.
6476 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
6477 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
6478 */
6479 skb_queue_head_init(&newsp->pd_lobby);
Vlad Yasevichb6e13312007-04-20 12:23:15 -07006480 atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006481
Vlad Yasevichb6e13312007-04-20 12:23:15 -07006482 if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006483 struct sk_buff_head *queue;
6484
6485 /* Decide which queue to move pd_lobby skbs to. */
6486 if (assoc->ulpq.pd_mode) {
6487 queue = &newsp->pd_lobby;
6488 } else
6489 queue = &newsk->sk_receive_queue;
6490
6491 /* Walk through the pd_lobby, looking for skbs that
6492 * need moved to the new socket.
6493 */
6494 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
6495 event = sctp_skb2event(skb);
6496 if (event->asoc == assoc) {
David S. Miller8728b832005-08-09 19:25:21 -07006497 __skb_unlink(skb, &oldsp->pd_lobby);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006498 __skb_queue_tail(queue, skb);
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006499 sctp_skb_set_owner_r_frag(skb, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006500 }
6501 }
6502
6503 /* Clear up any skbs waiting for the partial
6504 * delivery to finish.
6505 */
6506 if (assoc->ulpq.pd_mode)
Vlad Yasevichb6e13312007-04-20 12:23:15 -07006507 sctp_clear_pd(oldsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006508
6509 }
6510
Wei Yongjun1bc4ee42009-07-05 19:45:48 +00006511 sctp_skb_for_each(skb, &assoc->ulpq.reasm, tmp)
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006512 sctp_skb_set_owner_r_frag(skb, newsk);
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006513
Wei Yongjun1bc4ee42009-07-05 19:45:48 +00006514 sctp_skb_for_each(skb, &assoc->ulpq.lobby, tmp)
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006515 sctp_skb_set_owner_r_frag(skb, newsk);
Tsutomu Fujiiea2bc482007-04-17 12:49:53 -07006516
Linus Torvalds1da177e2005-04-16 15:20:36 -07006517 /* Set the type of socket to indicate that it is peeled off from the
6518 * original UDP-style socket or created with the accept() call on a
6519 * TCP-style socket..
6520 */
6521 newsp->type = type;
6522
Vladislav Yasevich61c9fed2006-05-19 11:01:18 -07006523 /* Mark the new socket "in-use" by the user so that any packets
6524 * that may arrive on the association after we've moved it are
6525 * queued to the backlog. This prevents a potential race between
6526 * backlog processing on the old socket and new-packet processing
6527 * on the new socket.
Zach Brown5131a182007-06-22 15:14:46 -07006528 *
6529 * The caller has just allocated newsk so we can guarantee that other
6530 * paths won't try to lock it and then oldsk.
Vladislav Yasevich61c9fed2006-05-19 11:01:18 -07006531 */
Zach Brown5131a182007-06-22 15:14:46 -07006532 lock_sock_nested(newsk, SINGLE_DEPTH_NESTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006533 sctp_assoc_migrate(assoc, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006534
6535 /* If the association on the newsk is already closed before accept()
6536 * is called, set RCV_SHUTDOWN flag.
6537 */
6538 if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP))
6539 newsk->sk_shutdown |= RCV_SHUTDOWN;
6540
6541 newsk->sk_state = SCTP_SS_ESTABLISHED;
Vladislav Yasevich61c9fed2006-05-19 11:01:18 -07006542 sctp_release_sock(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006543}
6544
Neil Horman4d93df02007-08-15 16:07:44 -07006545
Linus Torvalds1da177e2005-04-16 15:20:36 -07006546/* This proto struct describes the ULP interface for SCTP. */
6547struct proto sctp_prot = {
6548 .name = "SCTP",
6549 .owner = THIS_MODULE,
6550 .close = sctp_close,
6551 .connect = sctp_connect,
6552 .disconnect = sctp_disconnect,
6553 .accept = sctp_accept,
6554 .ioctl = sctp_ioctl,
6555 .init = sctp_init_sock,
6556 .destroy = sctp_destroy_sock,
6557 .shutdown = sctp_shutdown,
6558 .setsockopt = sctp_setsockopt,
6559 .getsockopt = sctp_getsockopt,
6560 .sendmsg = sctp_sendmsg,
6561 .recvmsg = sctp_recvmsg,
6562 .bind = sctp_bind,
6563 .backlog_rcv = sctp_backlog_rcv,
6564 .hash = sctp_hash,
6565 .unhash = sctp_unhash,
6566 .get_port = sctp_get_port,
6567 .obj_size = sizeof(struct sctp_sock),
Neil Horman4d93df02007-08-15 16:07:44 -07006568 .sysctl_mem = sysctl_sctp_mem,
6569 .sysctl_rmem = sysctl_sctp_rmem,
6570 .sysctl_wmem = sysctl_sctp_wmem,
6571 .memory_pressure = &sctp_memory_pressure,
6572 .enter_memory_pressure = sctp_enter_memory_pressure,
6573 .memory_allocated = &sctp_memory_allocated,
Pavel Emelyanov5f318862008-02-20 00:23:01 -08006574 .sockets_allocated = &sctp_sockets_allocated,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006575};
6576
6577#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Eric Dumazet8295b6d2007-11-05 23:40:28 -08006578
Linus Torvalds1da177e2005-04-16 15:20:36 -07006579struct proto sctpv6_prot = {
6580 .name = "SCTPv6",
6581 .owner = THIS_MODULE,
6582 .close = sctp_close,
6583 .connect = sctp_connect,
6584 .disconnect = sctp_disconnect,
6585 .accept = sctp_accept,
6586 .ioctl = sctp_ioctl,
6587 .init = sctp_init_sock,
6588 .destroy = sctp_destroy_sock,
6589 .shutdown = sctp_shutdown,
6590 .setsockopt = sctp_setsockopt,
6591 .getsockopt = sctp_getsockopt,
6592 .sendmsg = sctp_sendmsg,
6593 .recvmsg = sctp_recvmsg,
6594 .bind = sctp_bind,
6595 .backlog_rcv = sctp_backlog_rcv,
6596 .hash = sctp_hash,
6597 .unhash = sctp_unhash,
6598 .get_port = sctp_get_port,
6599 .obj_size = sizeof(struct sctp6_sock),
Neil Horman4d93df02007-08-15 16:07:44 -07006600 .sysctl_mem = sysctl_sctp_mem,
6601 .sysctl_rmem = sysctl_sctp_rmem,
6602 .sysctl_wmem = sysctl_sctp_wmem,
6603 .memory_pressure = &sctp_memory_pressure,
6604 .enter_memory_pressure = sctp_enter_memory_pressure,
6605 .memory_allocated = &sctp_memory_allocated,
Pavel Emelyanov5f318862008-02-20 00:23:01 -08006606 .sockets_allocated = &sctp_sockets_allocated,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006607};
6608#endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */