1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* SCTP kernel implementation
3  * (C) Copyright IBM Corp. 2001, 2004
4  * Copyright (c) 1999-2000 Cisco, Inc.
5  * Copyright (c) 1999-2001 Motorola, Inc.
6  * Copyright (c) 2001-2003 Intel Corp.
7  * Copyright (c) 2001-2002 Nokia, Inc.
8  * Copyright (c) 2001 La Monte H.P. Yarroll
9  *
10  * This file is part of the SCTP kernel implementation
11  *
12  * These functions interface with the sockets layer to implement the
13  * SCTP Extensions for the Sockets API.
14  *
15  * Note that the descriptions from the specification are USER level
16  * functions--this file is the functions which populate the struct proto
17  * for SCTP which is the BOTTOM of the sockets interface.
18  *
19  * Please send any bug reports or fixes you make to the
20  * email address(es):
21  *    lksctp developers <linux-sctp@vger.kernel.org>
22  *
23  * Written or modified by:
24  *    La Monte H.P. Yarroll <piggy@acm.org>
25  *    Narasimha Budihal     <narsi@refcode.org>
26  *    Karl Knutson          <karl@athena.chicago.il.us>
27  *    Jon Grimm             <jgrimm@us.ibm.com>
28  *    Xingang Guo           <xingang.guo@intel.com>
29  *    Daisy Chang           <daisyc@us.ibm.com>
30  *    Sridhar Samudrala     <samudrala@us.ibm.com>
31  *    Inaky Perez-Gonzalez  <inaky.gonzalez@intel.com>
32  *    Ardelle Fan	    <ardelle.fan@intel.com>
33  *    Ryan Layer	    <rmlayer@us.ibm.com>
34  *    Anup Pemmaiah         <pemmaiah@cc.usu.edu>
35  *    Kevin Gao             <kevin.gao@intel.com>
36  */
37 
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
39 
40 #include <crypto/hash.h>
41 #include <linux/types.h>
42 #include <linux/kernel.h>
43 #include <linux/wait.h>
44 #include <linux/time.h>
45 #include <linux/sched/signal.h>
46 #include <linux/ip.h>
47 #include <linux/capability.h>
48 #include <linux/fcntl.h>
49 #include <linux/poll.h>
50 #include <linux/init.h>
51 #include <linux/slab.h>
52 #include <linux/file.h>
53 #include <linux/compat.h>
54 #include <linux/rhashtable.h>
55 
56 #include <net/ip.h>
57 #include <net/icmp.h>
58 #include <net/route.h>
59 #include <net/ipv6.h>
60 #include <net/inet_common.h>
61 #include <net/busy_poll.h>
62 #include <trace/events/sock.h>
63 
64 #include <linux/socket.h> /* for sa_family_t */
65 #include <linux/export.h>
66 #include <net/sock.h>
67 #include <net/sctp/sctp.h>
68 #include <net/sctp/sm.h>
69 #include <net/sctp/stream_sched.h>
70 
71 /* Forward declarations for internal helper functions. */
72 static bool sctp_writeable(const struct sock *sk);
73 static void sctp_wfree(struct sk_buff *skb);
74 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
75 				size_t msg_len);
76 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);
77 static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
78 static int sctp_wait_for_accept(struct sock *sk, long timeo);
79 static void sctp_wait_for_close(struct sock *sk, long timeo);
80 static void sctp_destruct_sock(struct sock *sk);
81 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
82 					union sctp_addr *addr, int len);
83 static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
84 static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
85 static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
86 static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
87 static int sctp_send_asconf(struct sctp_association *asoc,
88 			    struct sctp_chunk *chunk);
89 static int sctp_do_bind(struct sock *, union sctp_addr *, int);
90 static int sctp_autobind(struct sock *sk);
91 static int sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
92 			     struct sctp_association *assoc,
93 			     enum sctp_socket_type type);
94 
95 static unsigned long sctp_memory_pressure;
96 static atomic_long_t sctp_memory_allocated;
97 static DEFINE_PER_CPU(int, sctp_memory_per_cpu_fw_alloc);
98 struct percpu_counter sctp_sockets_allocated;
99 
sctp_enter_memory_pressure(struct sock * sk)100 static void sctp_enter_memory_pressure(struct sock *sk)
101 {
102 	WRITE_ONCE(sctp_memory_pressure, 1);
103 }
104 
105 
106 /* Get the sndbuf space available at the time on the association.  */
sctp_wspace(struct sctp_association * asoc)107 static inline int sctp_wspace(struct sctp_association *asoc)
108 {
109 	struct sock *sk = asoc->base.sk;
110 
111 	return asoc->ep->sndbuf_policy ? sk->sk_sndbuf - asoc->sndbuf_used
112 				       : sk_stream_wspace(sk);
113 }
114 
115 /* Increment the used sndbuf space count of the corresponding association by
116  * the size of the outgoing data chunk.
117  * Also, set the skb destructor for sndbuf accounting later.
118  *
119  * Since it is always 1-1 between chunk and skb, and also a new skb is always
120  * allocated for chunk bundling in sctp_packet_transmit(), we can use the
121  * destructor in the data chunk skb for the purpose of the sndbuf space
122  * tracking.
123  */
sctp_set_owner_w(struct sctp_chunk * chunk)124 static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
125 {
126 	struct sctp_association *asoc = chunk->asoc;
127 	struct sock *sk = asoc->base.sk;
128 
129 	/* The sndbuf space is tracked per association.  */
130 	sctp_association_hold(asoc);
131 
132 	if (chunk->shkey)
133 		sctp_auth_shkey_hold(chunk->shkey);
134 
135 	skb_set_owner_w(chunk->skb, sk);
136 
137 	chunk->skb->destructor = sctp_wfree;
138 	/* Save the chunk pointer in skb for sctp_wfree to use later.  */
139 	skb_shinfo(chunk->skb)->destructor_arg = chunk;
140 
141 	refcount_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
142 	asoc->sndbuf_used += chunk->skb->truesize + sizeof(struct sctp_chunk);
143 	sk_wmem_queued_add(sk, chunk->skb->truesize + sizeof(struct sctp_chunk));
144 	sk_mem_charge(sk, chunk->skb->truesize);
145 }
146 
sctp_clear_owner_w(struct sctp_chunk * chunk)147 static void sctp_clear_owner_w(struct sctp_chunk *chunk)
148 {
149 	skb_orphan(chunk->skb);
150 }
151 
152 #define traverse_and_process()	\
153 do {				\
154 	msg = chunk->msg;	\
155 	if (msg == prev_msg)	\
156 		continue;	\
157 	list_for_each_entry(c, &msg->chunks, frag_list) {	\
158 		if ((clear && asoc->base.sk == c->skb->sk) ||	\
159 		    (!clear && asoc->base.sk != c->skb->sk))	\
160 			cb(c);	\
161 	}			\
162 	prev_msg = msg;		\
163 } while (0)
164 
sctp_for_each_tx_datachunk(struct sctp_association * asoc,bool clear,void (* cb)(struct sctp_chunk *))165 static void sctp_for_each_tx_datachunk(struct sctp_association *asoc,
166 				       bool clear,
167 				       void (*cb)(struct sctp_chunk *))
168 
169 {
170 	struct sctp_datamsg *msg, *prev_msg = NULL;
171 	struct sctp_outq *q = &asoc->outqueue;
172 	struct sctp_chunk *chunk, *c;
173 	struct sctp_transport *t;
174 
175 	list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
176 		list_for_each_entry(chunk, &t->transmitted, transmitted_list)
177 			traverse_and_process();
178 
179 	list_for_each_entry(chunk, &q->retransmit, transmitted_list)
180 		traverse_and_process();
181 
182 	list_for_each_entry(chunk, &q->sacked, transmitted_list)
183 		traverse_and_process();
184 
185 	list_for_each_entry(chunk, &q->abandoned, transmitted_list)
186 		traverse_and_process();
187 
188 	list_for_each_entry(chunk, &q->out_chunk_list, list)
189 		traverse_and_process();
190 }
191 
sctp_for_each_rx_skb(struct sctp_association * asoc,struct sock * sk,void (* cb)(struct sk_buff *,struct sock *))192 static void sctp_for_each_rx_skb(struct sctp_association *asoc, struct sock *sk,
193 				 void (*cb)(struct sk_buff *, struct sock *))
194 
195 {
196 	struct sk_buff *skb, *tmp;
197 
198 	sctp_skb_for_each(skb, &asoc->ulpq.lobby, tmp)
199 		cb(skb, sk);
200 
201 	sctp_skb_for_each(skb, &asoc->ulpq.reasm, tmp)
202 		cb(skb, sk);
203 
204 	sctp_skb_for_each(skb, &asoc->ulpq.reasm_uo, tmp)
205 		cb(skb, sk);
206 }
207 
208 /* Verify that this is a valid address. */
sctp_verify_addr(struct sock * sk,union sctp_addr * addr,int len)209 static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
210 				   int len)
211 {
212 	struct sctp_af *af;
213 
214 	/* Verify basic sockaddr. */
215 	af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
216 	if (!af)
217 		return -EINVAL;
218 
219 	/* Is this a valid SCTP address?  */
220 	if (!af->addr_valid(addr, sctp_sk(sk), NULL))
221 		return -EINVAL;
222 
223 	if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
224 		return -EINVAL;
225 
226 	return 0;
227 }
228 
229 /* Look up the association by its id.  If this is not a UDP-style
230  * socket, the ID field is always ignored.
231  */
sctp_id2assoc(struct sock * sk,sctp_assoc_t id)232 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
233 {
234 	struct sctp_association *asoc = NULL;
235 
236 	/* If this is not a UDP-style socket, assoc id should be ignored. */
237 	if (!sctp_style(sk, UDP)) {
238 		/* Return NULL if the socket state is not ESTABLISHED. It
239 		 * could be a TCP-style listening socket or a socket which
240 		 * hasn't yet called connect() to establish an association.
241 		 */
242 		if (!sctp_sstate(sk, ESTABLISHED) && !sctp_sstate(sk, CLOSING))
243 			return NULL;
244 
245 		/* Get the first and the only association from the list. */
246 		if (!list_empty(&sctp_sk(sk)->ep->asocs))
247 			asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
248 					  struct sctp_association, asocs);
249 		return asoc;
250 	}
251 
252 	/* Otherwise this is a UDP-style socket. */
253 	if (id <= SCTP_ALL_ASSOC)
254 		return NULL;
255 
256 	spin_lock_bh(&sctp_assocs_id_lock);
257 	asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
258 	if (asoc && (asoc->base.sk != sk || asoc->base.dead))
259 		asoc = NULL;
260 	spin_unlock_bh(&sctp_assocs_id_lock);
261 
262 	return asoc;
263 }
264 
265 /* Look up the transport from an address and an assoc id. If both address and
266  * id are specified, the associations matching the address and the id should be
267  * the same.
268  */
sctp_addr_id2transport(struct sock * sk,struct sockaddr_storage * addr,sctp_assoc_t id)269 static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
270 					      struct sockaddr_storage *addr,
271 					      sctp_assoc_t id)
272 {
273 	struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
274 	struct sctp_af *af = sctp_get_af_specific(addr->ss_family);
275 	union sctp_addr *laddr = (union sctp_addr *)addr;
276 	struct sctp_transport *transport;
277 
278 	if (!af || sctp_verify_addr(sk, laddr, af->sockaddr_len))
279 		return NULL;
280 
281 	addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
282 					       laddr,
283 					       &transport);
284 
285 	if (!addr_asoc)
286 		return NULL;
287 
288 	id_asoc = sctp_id2assoc(sk, id);
289 	if (id_asoc && (id_asoc != addr_asoc))
290 		return NULL;
291 
292 	sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
293 						(union sctp_addr *)addr);
294 
295 	return transport;
296 }
297 
298 /* API 3.1.2 bind() - UDP Style Syntax
299  * The syntax of bind() is,
300  *
301  *   ret = bind(int sd, struct sockaddr *addr, int addrlen);
302  *
303  *   sd      - the socket descriptor returned by socket().
304  *   addr    - the address structure (struct sockaddr_in or struct
305  *             sockaddr_in6 [RFC 2553]),
306  *   addr_len - the size of the address structure.
307  */
sctp_bind(struct sock * sk,struct sockaddr * addr,int addr_len)308 static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
309 {
310 	int retval = 0;
311 
312 	lock_sock(sk);
313 
314 	pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk,
315 		 addr, addr_len);
316 
317 	/* Disallow binding twice. */
318 	if (!sctp_sk(sk)->ep->base.bind_addr.port)
319 		retval = sctp_do_bind(sk, (union sctp_addr *)addr,
320 				      addr_len);
321 	else
322 		retval = -EINVAL;
323 
324 	release_sock(sk);
325 
326 	return retval;
327 }
328 
329 static int sctp_get_port_local(struct sock *, union sctp_addr *);
330 
331 /* Verify this is a valid sockaddr. */
sctp_sockaddr_af(struct sctp_sock * opt,union sctp_addr * addr,int len)332 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
333 					union sctp_addr *addr, int len)
334 {
335 	struct sctp_af *af;
336 
337 	/* Check minimum size.  */
338 	if (len < sizeof (struct sockaddr))
339 		return NULL;
340 
341 	if (!opt->pf->af_supported(addr->sa.sa_family, opt))
342 		return NULL;
343 
344 	if (addr->sa.sa_family == AF_INET6) {
345 		if (len < SIN6_LEN_RFC2133)
346 			return NULL;
347 		/* V4 mapped address are really of AF_INET family */
348 		if (ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
349 		    !opt->pf->af_supported(AF_INET, opt))
350 			return NULL;
351 	}
352 
353 	/* If we get this far, af is valid. */
354 	af = sctp_get_af_specific(addr->sa.sa_family);
355 
356 	if (len < af->sockaddr_len)
357 		return NULL;
358 
359 	return af;
360 }
361 
sctp_auto_asconf_init(struct sctp_sock * sp)362 static void sctp_auto_asconf_init(struct sctp_sock *sp)
363 {
364 	struct net *net = sock_net(&sp->inet.sk);
365 
366 	if (net->sctp.default_auto_asconf) {
367 		spin_lock_bh(&net->sctp.addr_wq_lock);
368 		list_add_tail(&sp->auto_asconf_list, &net->sctp.auto_asconf_splist);
369 		spin_unlock_bh(&net->sctp.addr_wq_lock);
370 		sp->do_auto_asconf = 1;
371 	}
372 }
373 
374 /* Bind a local address either to an endpoint or to an association.  */
sctp_do_bind(struct sock * sk,union sctp_addr * addr,int len)375 static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
376 {
377 	struct net *net = sock_net(sk);
378 	struct sctp_sock *sp = sctp_sk(sk);
379 	struct sctp_endpoint *ep = sp->ep;
380 	struct sctp_bind_addr *bp = &ep->base.bind_addr;
381 	struct sctp_af *af;
382 	unsigned short snum;
383 	int ret = 0;
384 
385 	/* Common sockaddr verification. */
386 	af = sctp_sockaddr_af(sp, addr, len);
387 	if (!af) {
388 		pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
389 			 __func__, sk, addr, len);
390 		return -EINVAL;
391 	}
392 
393 	snum = ntohs(addr->v4.sin_port);
394 
395 	pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
396 		 __func__, sk, &addr->sa, bp->port, snum, len);
397 
398 	/* PF specific bind() address verification. */
399 	if (!sp->pf->bind_verify(sp, addr))
400 		return -EADDRNOTAVAIL;
401 
402 	/* We must either be unbound, or bind to the same port.
403 	 * It's OK to allow 0 ports if we are already bound.
404 	 * We'll just inhert an already bound port in this case
405 	 */
406 	if (bp->port) {
407 		if (!snum)
408 			snum = bp->port;
409 		else if (snum != bp->port) {
410 			pr_debug("%s: new port %d doesn't match existing port "
411 				 "%d\n", __func__, snum, bp->port);
412 			return -EINVAL;
413 		}
414 	}
415 
416 	if (snum && inet_port_requires_bind_service(net, snum) &&
417 	    !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
418 		return -EACCES;
419 
420 	/* See if the address matches any of the addresses we may have
421 	 * already bound before checking against other endpoints.
422 	 */
423 	if (sctp_bind_addr_match(bp, addr, sp))
424 		return -EINVAL;
425 
426 	/* Make sure we are allowed to bind here.
427 	 * The function sctp_get_port_local() does duplicate address
428 	 * detection.
429 	 */
430 	addr->v4.sin_port = htons(snum);
431 	if (sctp_get_port_local(sk, addr))
432 		return -EADDRINUSE;
433 
434 	/* Refresh ephemeral port.  */
435 	if (!bp->port) {
436 		bp->port = inet_sk(sk)->inet_num;
437 		sctp_auto_asconf_init(sp);
438 	}
439 
440 	/* Add the address to the bind address list.
441 	 * Use GFP_ATOMIC since BHs will be disabled.
442 	 */
443 	ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
444 				 SCTP_ADDR_SRC, GFP_ATOMIC);
445 
446 	if (ret) {
447 		sctp_put_port(sk);
448 		return ret;
449 	}
450 	/* Copy back into socket for getsockname() use. */
451 	inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
452 	sp->pf->to_sk_saddr(addr, sk);
453 
454 	return ret;
455 }
456 
457  /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
458  *
459  * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
460  * at any one time.  If a sender, after sending an ASCONF chunk, decides
461  * it needs to transfer another ASCONF Chunk, it MUST wait until the
462  * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
463  * subsequent ASCONF. Note this restriction binds each side, so at any
464  * time two ASCONF may be in-transit on any given association (one sent
465  * from each endpoint).
466  */
sctp_send_asconf(struct sctp_association * asoc,struct sctp_chunk * chunk)467 static int sctp_send_asconf(struct sctp_association *asoc,
468 			    struct sctp_chunk *chunk)
469 {
470 	int retval = 0;
471 
472 	/* If there is an outstanding ASCONF chunk, queue it for later
473 	 * transmission.
474 	 */
475 	if (asoc->addip_last_asconf) {
476 		list_add_tail(&chunk->list, &asoc->addip_chunk_list);
477 		goto out;
478 	}
479 
480 	/* Hold the chunk until an ASCONF_ACK is received. */
481 	sctp_chunk_hold(chunk);
482 	retval = sctp_primitive_ASCONF(asoc->base.net, asoc, chunk);
483 	if (retval)
484 		sctp_chunk_free(chunk);
485 	else
486 		asoc->addip_last_asconf = chunk;
487 
488 out:
489 	return retval;
490 }
491 
492 /* Add a list of addresses as bind addresses to local endpoint or
493  * association.
494  *
495  * Basically run through each address specified in the addrs/addrcnt
496  * array/length pair, determine if it is IPv6 or IPv4 and call
497  * sctp_do_bind() on it.
498  *
499  * If any of them fails, then the operation will be reversed and the
500  * ones that were added will be removed.
501  *
502  * Only sctp_setsockopt_bindx() is supposed to call this function.
503  */
sctp_bindx_add(struct sock * sk,struct sockaddr * addrs,int addrcnt)504 static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
505 {
506 	int cnt;
507 	int retval = 0;
508 	void *addr_buf;
509 	struct sockaddr *sa_addr;
510 	struct sctp_af *af;
511 
512 	pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk,
513 		 addrs, addrcnt);
514 
515 	addr_buf = addrs;
516 	for (cnt = 0; cnt < addrcnt; cnt++) {
517 		/* The list may contain either IPv4 or IPv6 address;
518 		 * determine the address length for walking thru the list.
519 		 */
520 		sa_addr = addr_buf;
521 		af = sctp_get_af_specific(sa_addr->sa_family);
522 		if (!af) {
523 			retval = -EINVAL;
524 			goto err_bindx_add;
525 		}
526 
527 		retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
528 				      af->sockaddr_len);
529 
530 		addr_buf += af->sockaddr_len;
531 
532 err_bindx_add:
533 		if (retval < 0) {
534 			/* Failed. Cleanup the ones that have been added */
535 			if (cnt > 0)
536 				sctp_bindx_rem(sk, addrs, cnt);
537 			return retval;
538 		}
539 	}
540 
541 	return retval;
542 }
543 
544 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
545  * associations that are part of the endpoint indicating that a list of local
546  * addresses are added to the endpoint.
547  *
548  * If any of the addresses is already in the bind address list of the
549  * association, we do not send the chunk for that association.  But it will not
550  * affect other associations.
551  *
552  * Only sctp_setsockopt_bindx() is supposed to call this function.
553  */
sctp_send_asconf_add_ip(struct sock * sk,struct sockaddr * addrs,int addrcnt)554 static int sctp_send_asconf_add_ip(struct sock		*sk,
555 				   struct sockaddr	*addrs,
556 				   int 			addrcnt)
557 {
558 	struct sctp_sock		*sp;
559 	struct sctp_endpoint		*ep;
560 	struct sctp_association		*asoc;
561 	struct sctp_bind_addr		*bp;
562 	struct sctp_chunk		*chunk;
563 	struct sctp_sockaddr_entry	*laddr;
564 	union sctp_addr			*addr;
565 	union sctp_addr			saveaddr;
566 	void				*addr_buf;
567 	struct sctp_af			*af;
568 	struct list_head		*p;
569 	int 				i;
570 	int 				retval = 0;
571 
572 	sp = sctp_sk(sk);
573 	ep = sp->ep;
574 
575 	if (!ep->asconf_enable)
576 		return retval;
577 
578 	pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
579 		 __func__, sk, addrs, addrcnt);
580 
581 	list_for_each_entry(asoc, &ep->asocs, asocs) {
582 		if (!asoc->peer.asconf_capable)
583 			continue;
584 
585 		if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
586 			continue;
587 
588 		if (!sctp_state(asoc, ESTABLISHED))
589 			continue;
590 
591 		/* Check if any address in the packed array of addresses is
592 		 * in the bind address list of the association. If so,
593 		 * do not send the asconf chunk to its peer, but continue with
594 		 * other associations.
595 		 */
596 		addr_buf = addrs;
597 		for (i = 0; i < addrcnt; i++) {
598 			addr = addr_buf;
599 			af = sctp_get_af_specific(addr->v4.sin_family);
600 			if (!af) {
601 				retval = -EINVAL;
602 				goto out;
603 			}
604 
605 			if (sctp_assoc_lookup_laddr(asoc, addr))
606 				break;
607 
608 			addr_buf += af->sockaddr_len;
609 		}
610 		if (i < addrcnt)
611 			continue;
612 
613 		/* Use the first valid address in bind addr list of
614 		 * association as Address Parameter of ASCONF CHUNK.
615 		 */
616 		bp = &asoc->base.bind_addr;
617 		p = bp->address_list.next;
618 		laddr = list_entry(p, struct sctp_sockaddr_entry, list);
619 		chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
620 						   addrcnt, SCTP_PARAM_ADD_IP);
621 		if (!chunk) {
622 			retval = -ENOMEM;
623 			goto out;
624 		}
625 
626 		/* Add the new addresses to the bind address list with
627 		 * use_as_src set to 0.
628 		 */
629 		addr_buf = addrs;
630 		for (i = 0; i < addrcnt; i++) {
631 			addr = addr_buf;
632 			af = sctp_get_af_specific(addr->v4.sin_family);
633 			memcpy(&saveaddr, addr, af->sockaddr_len);
634 			retval = sctp_add_bind_addr(bp, &saveaddr,
635 						    sizeof(saveaddr),
636 						    SCTP_ADDR_NEW, GFP_ATOMIC);
637 			addr_buf += af->sockaddr_len;
638 		}
639 		if (asoc->src_out_of_asoc_ok) {
640 			struct sctp_transport *trans;
641 
642 			list_for_each_entry(trans,
643 			    &asoc->peer.transport_addr_list, transports) {
644 				trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
645 				    2*asoc->pathmtu, 4380));
646 				trans->ssthresh = asoc->peer.i.a_rwnd;
647 				trans->rto = asoc->rto_initial;
648 				sctp_max_rto(asoc, trans);
649 				trans->rtt = trans->srtt = trans->rttvar = 0;
650 				/* Clear the source and route cache */
651 				sctp_transport_route(trans, NULL,
652 						     sctp_sk(asoc->base.sk));
653 			}
654 		}
655 		retval = sctp_send_asconf(asoc, chunk);
656 	}
657 
658 out:
659 	return retval;
660 }
661 
662 /* Remove a list of addresses from bind addresses list.  Do not remove the
663  * last address.
664  *
665  * Basically run through each address specified in the addrs/addrcnt
666  * array/length pair, determine if it is IPv6 or IPv4 and call
667  * sctp_del_bind() on it.
668  *
669  * If any of them fails, then the operation will be reversed and the
670  * ones that were removed will be added back.
671  *
672  * At least one address has to be left; if only one address is
673  * available, the operation will return -EBUSY.
674  *
675  * Only sctp_setsockopt_bindx() is supposed to call this function.
676  */
sctp_bindx_rem(struct sock * sk,struct sockaddr * addrs,int addrcnt)677 static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
678 {
679 	struct sctp_sock *sp = sctp_sk(sk);
680 	struct sctp_endpoint *ep = sp->ep;
681 	int cnt;
682 	struct sctp_bind_addr *bp = &ep->base.bind_addr;
683 	int retval = 0;
684 	void *addr_buf;
685 	union sctp_addr *sa_addr;
686 	struct sctp_af *af;
687 
688 	pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
689 		 __func__, sk, addrs, addrcnt);
690 
691 	addr_buf = addrs;
692 	for (cnt = 0; cnt < addrcnt; cnt++) {
693 		/* If the bind address list is empty or if there is only one
694 		 * bind address, there is nothing more to be removed (we need
695 		 * at least one address here).
696 		 */
697 		if (list_empty(&bp->address_list) ||
698 		    (sctp_list_single_entry(&bp->address_list))) {
699 			retval = -EBUSY;
700 			goto err_bindx_rem;
701 		}
702 
703 		sa_addr = addr_buf;
704 		af = sctp_get_af_specific(sa_addr->sa.sa_family);
705 		if (!af) {
706 			retval = -EINVAL;
707 			goto err_bindx_rem;
708 		}
709 
710 		if (!af->addr_valid(sa_addr, sp, NULL)) {
711 			retval = -EADDRNOTAVAIL;
712 			goto err_bindx_rem;
713 		}
714 
715 		if (sa_addr->v4.sin_port &&
716 		    sa_addr->v4.sin_port != htons(bp->port)) {
717 			retval = -EINVAL;
718 			goto err_bindx_rem;
719 		}
720 
721 		if (!sa_addr->v4.sin_port)
722 			sa_addr->v4.sin_port = htons(bp->port);
723 
724 		/* FIXME - There is probably a need to check if sk->sk_saddr and
725 		 * sk->sk_rcv_addr are currently set to one of the addresses to
726 		 * be removed. This is something which needs to be looked into
727 		 * when we are fixing the outstanding issues with multi-homing
728 		 * socket routing and failover schemes. Refer to comments in
729 		 * sctp_do_bind(). -daisy
730 		 */
731 		retval = sctp_del_bind_addr(bp, sa_addr);
732 
733 		addr_buf += af->sockaddr_len;
734 err_bindx_rem:
735 		if (retval < 0) {
736 			/* Failed. Add the ones that has been removed back */
737 			if (cnt > 0)
738 				sctp_bindx_add(sk, addrs, cnt);
739 			return retval;
740 		}
741 	}
742 
743 	return retval;
744 }
745 
746 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
747  * the associations that are part of the endpoint indicating that a list of
748  * local addresses are removed from the endpoint.
749  *
750  * If any of the addresses is already in the bind address list of the
751  * association, we do not send the chunk for that association.  But it will not
752  * affect other associations.
753  *
754  * Only sctp_setsockopt_bindx() is supposed to call this function.
755  */
sctp_send_asconf_del_ip(struct sock * sk,struct sockaddr * addrs,int addrcnt)756 static int sctp_send_asconf_del_ip(struct sock		*sk,
757 				   struct sockaddr	*addrs,
758 				   int			addrcnt)
759 {
760 	struct sctp_sock	*sp;
761 	struct sctp_endpoint	*ep;
762 	struct sctp_association	*asoc;
763 	struct sctp_transport	*transport;
764 	struct sctp_bind_addr	*bp;
765 	struct sctp_chunk	*chunk;
766 	union sctp_addr		*laddr;
767 	void			*addr_buf;
768 	struct sctp_af		*af;
769 	struct sctp_sockaddr_entry *saddr;
770 	int 			i;
771 	int 			retval = 0;
772 	int			stored = 0;
773 
774 	chunk = NULL;
775 	sp = sctp_sk(sk);
776 	ep = sp->ep;
777 
778 	if (!ep->asconf_enable)
779 		return retval;
780 
781 	pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
782 		 __func__, sk, addrs, addrcnt);
783 
784 	list_for_each_entry(asoc, &ep->asocs, asocs) {
785 
786 		if (!asoc->peer.asconf_capable)
787 			continue;
788 
789 		if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
790 			continue;
791 
792 		if (!sctp_state(asoc, ESTABLISHED))
793 			continue;
794 
795 		/* Check if any address in the packed array of addresses is
796 		 * not present in the bind address list of the association.
797 		 * If so, do not send the asconf chunk to its peer, but
798 		 * continue with other associations.
799 		 */
800 		addr_buf = addrs;
801 		for (i = 0; i < addrcnt; i++) {
802 			laddr = addr_buf;
803 			af = sctp_get_af_specific(laddr->v4.sin_family);
804 			if (!af) {
805 				retval = -EINVAL;
806 				goto out;
807 			}
808 
809 			if (!sctp_assoc_lookup_laddr(asoc, laddr))
810 				break;
811 
812 			addr_buf += af->sockaddr_len;
813 		}
814 		if (i < addrcnt)
815 			continue;
816 
817 		/* Find one address in the association's bind address list
818 		 * that is not in the packed array of addresses. This is to
819 		 * make sure that we do not delete all the addresses in the
820 		 * association.
821 		 */
822 		bp = &asoc->base.bind_addr;
823 		laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
824 					       addrcnt, sp);
825 		if ((laddr == NULL) && (addrcnt == 1)) {
826 			if (asoc->asconf_addr_del_pending)
827 				continue;
828 			asoc->asconf_addr_del_pending =
829 			    kzalloc(sizeof(union sctp_addr), GFP_ATOMIC);
830 			if (asoc->asconf_addr_del_pending == NULL) {
831 				retval = -ENOMEM;
832 				goto out;
833 			}
834 			asoc->asconf_addr_del_pending->sa.sa_family =
835 				    addrs->sa_family;
836 			asoc->asconf_addr_del_pending->v4.sin_port =
837 				    htons(bp->port);
838 			if (addrs->sa_family == AF_INET) {
839 				struct sockaddr_in *sin;
840 
841 				sin = (struct sockaddr_in *)addrs;
842 				asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
843 			} else if (addrs->sa_family == AF_INET6) {
844 				struct sockaddr_in6 *sin6;
845 
846 				sin6 = (struct sockaddr_in6 *)addrs;
847 				asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
848 			}
849 
850 			pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
851 				 __func__, asoc, &asoc->asconf_addr_del_pending->sa,
852 				 asoc->asconf_addr_del_pending);
853 
854 			asoc->src_out_of_asoc_ok = 1;
855 			stored = 1;
856 			goto skip_mkasconf;
857 		}
858 
859 		if (laddr == NULL)
860 			return -EINVAL;
861 
862 		/* We do not need RCU protection throughout this loop
863 		 * because this is done under a socket lock from the
864 		 * setsockopt call.
865 		 */
866 		chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
867 						   SCTP_PARAM_DEL_IP);
868 		if (!chunk) {
869 			retval = -ENOMEM;
870 			goto out;
871 		}
872 
873 skip_mkasconf:
874 		/* Reset use_as_src flag for the addresses in the bind address
875 		 * list that are to be deleted.
876 		 */
877 		addr_buf = addrs;
878 		for (i = 0; i < addrcnt; i++) {
879 			laddr = addr_buf;
880 			af = sctp_get_af_specific(laddr->v4.sin_family);
881 			list_for_each_entry(saddr, &bp->address_list, list) {
882 				if (sctp_cmp_addr_exact(&saddr->a, laddr))
883 					saddr->state = SCTP_ADDR_DEL;
884 			}
885 			addr_buf += af->sockaddr_len;
886 		}
887 
888 		/* Update the route and saddr entries for all the transports
889 		 * as some of the addresses in the bind address list are
890 		 * about to be deleted and cannot be used as source addresses.
891 		 */
892 		list_for_each_entry(transport, &asoc->peer.transport_addr_list,
893 					transports) {
894 			sctp_transport_route(transport, NULL,
895 					     sctp_sk(asoc->base.sk));
896 		}
897 
898 		if (stored)
899 			/* We don't need to transmit ASCONF */
900 			continue;
901 		retval = sctp_send_asconf(asoc, chunk);
902 	}
903 out:
904 	return retval;
905 }
906 
907 /* set addr events to assocs in the endpoint.  ep and addr_wq must be locked */
sctp_asconf_mgmt(struct sctp_sock * sp,struct sctp_sockaddr_entry * addrw)908 int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
909 {
910 	struct sock *sk = sctp_opt2sk(sp);
911 	union sctp_addr *addr;
912 	struct sctp_af *af;
913 
914 	/* It is safe to write port space in caller. */
915 	addr = &addrw->a;
916 	addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
917 	af = sctp_get_af_specific(addr->sa.sa_family);
918 	if (!af)
919 		return -EINVAL;
920 	if (sctp_verify_addr(sk, addr, af->sockaddr_len))
921 		return -EINVAL;
922 
923 	if (addrw->state == SCTP_ADDR_NEW)
924 		return sctp_send_asconf_add_ip(sk, (struct sockaddr *)addr, 1);
925 	else
926 		return sctp_send_asconf_del_ip(sk, (struct sockaddr *)addr, 1);
927 }
928 
929 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
930  *
931  * API 8.1
932  * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
933  *                int flags);
934  *
935  * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
936  * If the sd is an IPv6 socket, the addresses passed can either be IPv4
937  * or IPv6 addresses.
938  *
939  * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
940  * Section 3.1.2 for this usage.
941  *
942  * addrs is a pointer to an array of one or more socket addresses. Each
943  * address is contained in its appropriate structure (i.e. struct
944  * sockaddr_in or struct sockaddr_in6) the family of the address type
945  * must be used to distinguish the address length (note that this
946  * representation is termed a "packed array" of addresses). The caller
947  * specifies the number of addresses in the array with addrcnt.
948  *
949  * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
950  * -1, and sets errno to the appropriate error code.
951  *
952  * For SCTP, the port given in each socket address must be the same, or
953  * sctp_bindx() will fail, setting errno to EINVAL.
954  *
955  * The flags parameter is formed from the bitwise OR of zero or more of
956  * the following currently defined flags:
957  *
958  * SCTP_BINDX_ADD_ADDR
959  *
960  * SCTP_BINDX_REM_ADDR
961  *
962  * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
963  * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
964  * addresses from the association. The two flags are mutually exclusive;
965  * if both are given, sctp_bindx() will fail with EINVAL. A caller may
966  * not remove all addresses from an association; sctp_bindx() will
967  * reject such an attempt with EINVAL.
968  *
969  * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
970  * additional addresses with an endpoint after calling bind().  Or use
971  * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
972  * socket is associated with so that no new association accepted will be
973  * associated with those addresses. If the endpoint supports dynamic
974  * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
975  * endpoint to send the appropriate message to the peer to change the
976  * peers address lists.
977  *
978  * Adding and removing addresses from a connected association is
979  * optional functionality. Implementations that do not support this
980  * functionality should return EOPNOTSUPP.
981  *
982  * Basically do nothing but copying the addresses from user to kernel
983  * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
984  * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
985  * from userspace.
986  *
987  * On exit there is no need to do sockfd_put(), sys_setsockopt() does
988  * it.
989  *
990  * sk        The sk of the socket
991  * addrs     The pointer to the addresses
992  * addrssize Size of the addrs buffer
993  * op        Operation to perform (add or remove, see the flags of
994  *           sctp_bindx)
995  *
996  * Returns 0 if ok, <0 errno code on error.
997  */
sctp_setsockopt_bindx(struct sock * sk,struct sockaddr * addrs,int addrs_size,int op)998 static int sctp_setsockopt_bindx(struct sock *sk, struct sockaddr *addrs,
999 				 int addrs_size, int op)
1000 {
1001 	int err;
1002 	int addrcnt = 0;
1003 	int walk_size = 0;
1004 	struct sockaddr *sa_addr;
1005 	void *addr_buf = addrs;
1006 	struct sctp_af *af;
1007 
1008 	pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
1009 		 __func__, sk, addr_buf, addrs_size, op);
1010 
1011 	if (unlikely(addrs_size <= 0))
1012 		return -EINVAL;
1013 
1014 	/* Walk through the addrs buffer and count the number of addresses. */
1015 	while (walk_size < addrs_size) {
1016 		if (walk_size + sizeof(sa_family_t) > addrs_size)
1017 			return -EINVAL;
1018 
1019 		sa_addr = addr_buf;
1020 		af = sctp_get_af_specific(sa_addr->sa_family);
1021 
1022 		/* If the address family is not supported or if this address
1023 		 * causes the address buffer to overflow return EINVAL.
1024 		 */
1025 		if (!af || (walk_size + af->sockaddr_len) > addrs_size)
1026 			return -EINVAL;
1027 		addrcnt++;
1028 		addr_buf += af->sockaddr_len;
1029 		walk_size += af->sockaddr_len;
1030 	}
1031 
1032 	/* Do the work. */
1033 	switch (op) {
1034 	case SCTP_BINDX_ADD_ADDR:
1035 		/* Allow security module to validate bindx addresses. */
1036 		err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_BINDX_ADD,
1037 						 addrs, addrs_size);
1038 		if (err)
1039 			return err;
1040 		err = sctp_bindx_add(sk, addrs, addrcnt);
1041 		if (err)
1042 			return err;
1043 		return sctp_send_asconf_add_ip(sk, addrs, addrcnt);
1044 	case SCTP_BINDX_REM_ADDR:
1045 		err = sctp_bindx_rem(sk, addrs, addrcnt);
1046 		if (err)
1047 			return err;
1048 		return sctp_send_asconf_del_ip(sk, addrs, addrcnt);
1049 
1050 	default:
1051 		return -EINVAL;
1052 	}
1053 }
1054 
sctp_bind_add(struct sock * sk,struct sockaddr * addrs,int addrlen)1055 static int sctp_bind_add(struct sock *sk, struct sockaddr *addrs,
1056 		int addrlen)
1057 {
1058 	int err;
1059 
1060 	lock_sock(sk);
1061 	err = sctp_setsockopt_bindx(sk, addrs, addrlen, SCTP_BINDX_ADD_ADDR);
1062 	release_sock(sk);
1063 	return err;
1064 }
1065 
sctp_connect_new_asoc(struct sctp_endpoint * ep,const union sctp_addr * daddr,const struct sctp_initmsg * init,struct sctp_transport ** tp)1066 static int sctp_connect_new_asoc(struct sctp_endpoint *ep,
1067 				 const union sctp_addr *daddr,
1068 				 const struct sctp_initmsg *init,
1069 				 struct sctp_transport **tp)
1070 {
1071 	struct sctp_association *asoc;
1072 	struct sock *sk = ep->base.sk;
1073 	struct net *net = sock_net(sk);
1074 	enum sctp_scope scope;
1075 	int err;
1076 
1077 	if (sctp_endpoint_is_peeled_off(ep, daddr))
1078 		return -EADDRNOTAVAIL;
1079 
1080 	if (!ep->base.bind_addr.port) {
1081 		if (sctp_autobind(sk))
1082 			return -EAGAIN;
1083 	} else {
1084 		if (inet_port_requires_bind_service(net, ep->base.bind_addr.port) &&
1085 		    !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
1086 			return -EACCES;
1087 	}
1088 
1089 	scope = sctp_scope(daddr);
1090 	asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1091 	if (!asoc)
1092 		return -ENOMEM;
1093 
1094 	err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
1095 	if (err < 0)
1096 		goto free;
1097 
1098 	*tp = sctp_assoc_add_peer(asoc, daddr, GFP_KERNEL, SCTP_UNKNOWN);
1099 	if (!*tp) {
1100 		err = -ENOMEM;
1101 		goto free;
1102 	}
1103 
1104 	if (!init)
1105 		return 0;
1106 
1107 	if (init->sinit_num_ostreams) {
1108 		__u16 outcnt = init->sinit_num_ostreams;
1109 
1110 		asoc->c.sinit_num_ostreams = outcnt;
1111 		/* outcnt has been changed, need to re-init stream */
1112 		err = sctp_stream_init(&asoc->stream, outcnt, 0, GFP_KERNEL);
1113 		if (err)
1114 			goto free;
1115 	}
1116 
1117 	if (init->sinit_max_instreams)
1118 		asoc->c.sinit_max_instreams = init->sinit_max_instreams;
1119 
1120 	if (init->sinit_max_attempts)
1121 		asoc->max_init_attempts = init->sinit_max_attempts;
1122 
1123 	if (init->sinit_max_init_timeo)
1124 		asoc->max_init_timeo =
1125 			msecs_to_jiffies(init->sinit_max_init_timeo);
1126 
1127 	return 0;
1128 free:
1129 	sctp_association_free(asoc);
1130 	return err;
1131 }
1132 
sctp_connect_add_peer(struct sctp_association * asoc,union sctp_addr * daddr,int addr_len)1133 static int sctp_connect_add_peer(struct sctp_association *asoc,
1134 				 union sctp_addr *daddr, int addr_len)
1135 {
1136 	struct sctp_endpoint *ep = asoc->ep;
1137 	struct sctp_association *old;
1138 	struct sctp_transport *t;
1139 	int err;
1140 
1141 	err = sctp_verify_addr(ep->base.sk, daddr, addr_len);
1142 	if (err)
1143 		return err;
1144 
1145 	old = sctp_endpoint_lookup_assoc(ep, daddr, &t);
1146 	if (old && old != asoc)
1147 		return old->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1148 							    : -EALREADY;
1149 
1150 	if (sctp_endpoint_is_peeled_off(ep, daddr))
1151 		return -EADDRNOTAVAIL;
1152 
1153 	t = sctp_assoc_add_peer(asoc, daddr, GFP_KERNEL, SCTP_UNKNOWN);
1154 	if (!t)
1155 		return -ENOMEM;
1156 
1157 	return 0;
1158 }
1159 
1160 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1161  *
1162  * Common routine for handling connect() and sctp_connectx().
1163  * Connect will come in with just a single address.
1164  */
__sctp_connect(struct sock * sk,struct sockaddr * kaddrs,int addrs_size,int flags,sctp_assoc_t * assoc_id)1165 static int __sctp_connect(struct sock *sk, struct sockaddr *kaddrs,
1166 			  int addrs_size, int flags, sctp_assoc_t *assoc_id)
1167 {
1168 	struct sctp_sock *sp = sctp_sk(sk);
1169 	struct sctp_endpoint *ep = sp->ep;
1170 	struct sctp_transport *transport;
1171 	struct sctp_association *asoc;
1172 	void *addr_buf = kaddrs;
1173 	union sctp_addr *daddr;
1174 	struct sctp_af *af;
1175 	int walk_size, err;
1176 	long timeo;
1177 
1178 	if (sctp_sstate(sk, ESTABLISHED) || sctp_sstate(sk, CLOSING) ||
1179 	    (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)))
1180 		return -EISCONN;
1181 
1182 	daddr = addr_buf;
1183 	af = sctp_get_af_specific(daddr->sa.sa_family);
1184 	if (!af || af->sockaddr_len > addrs_size)
1185 		return -EINVAL;
1186 
1187 	err = sctp_verify_addr(sk, daddr, af->sockaddr_len);
1188 	if (err)
1189 		return err;
1190 
1191 	asoc = sctp_endpoint_lookup_assoc(ep, daddr, &transport);
1192 	if (asoc)
1193 		return asoc->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1194 							     : -EALREADY;
1195 
1196 	err = sctp_connect_new_asoc(ep, daddr, NULL, &transport);
1197 	if (err)
1198 		return err;
1199 	asoc = transport->asoc;
1200 
1201 	addr_buf += af->sockaddr_len;
1202 	walk_size = af->sockaddr_len;
1203 	while (walk_size < addrs_size) {
1204 		err = -EINVAL;
1205 		if (walk_size + sizeof(sa_family_t) > addrs_size)
1206 			goto out_free;
1207 
1208 		daddr = addr_buf;
1209 		af = sctp_get_af_specific(daddr->sa.sa_family);
1210 		if (!af || af->sockaddr_len + walk_size > addrs_size)
1211 			goto out_free;
1212 
1213 		if (asoc->peer.port != ntohs(daddr->v4.sin_port))
1214 			goto out_free;
1215 
1216 		err = sctp_connect_add_peer(asoc, daddr, af->sockaddr_len);
1217 		if (err)
1218 			goto out_free;
1219 
1220 		addr_buf  += af->sockaddr_len;
1221 		walk_size += af->sockaddr_len;
1222 	}
1223 
1224 	/* In case the user of sctp_connectx() wants an association
1225 	 * id back, assign one now.
1226 	 */
1227 	if (assoc_id) {
1228 		err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1229 		if (err < 0)
1230 			goto out_free;
1231 	}
1232 
1233 	err = sctp_primitive_ASSOCIATE(sock_net(sk), asoc, NULL);
1234 	if (err < 0)
1235 		goto out_free;
1236 
1237 	/* Initialize sk's dport and daddr for getpeername() */
1238 	inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1239 	sp->pf->to_sk_daddr(daddr, sk);
1240 	sk->sk_err = 0;
1241 
1242 	if (assoc_id)
1243 		*assoc_id = asoc->assoc_id;
1244 
1245 	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1246 	return sctp_wait_for_connect(asoc, &timeo);
1247 
1248 out_free:
1249 	pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1250 		 __func__, asoc, kaddrs, err);
1251 	sctp_association_free(asoc);
1252 	return err;
1253 }
1254 
1255 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1256  *
1257  * API 8.9
1258  * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1259  * 			sctp_assoc_t *asoc);
1260  *
1261  * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1262  * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1263  * or IPv6 addresses.
1264  *
1265  * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1266  * Section 3.1.2 for this usage.
1267  *
1268  * addrs is a pointer to an array of one or more socket addresses. Each
1269  * address is contained in its appropriate structure (i.e. struct
1270  * sockaddr_in or struct sockaddr_in6) the family of the address type
1271  * must be used to distengish the address length (note that this
1272  * representation is termed a "packed array" of addresses). The caller
1273  * specifies the number of addresses in the array with addrcnt.
1274  *
1275  * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1276  * the association id of the new association.  On failure, sctp_connectx()
1277  * returns -1, and sets errno to the appropriate error code.  The assoc_id
1278  * is not touched by the kernel.
1279  *
1280  * For SCTP, the port given in each socket address must be the same, or
1281  * sctp_connectx() will fail, setting errno to EINVAL.
1282  *
1283  * An application can use sctp_connectx to initiate an association with
1284  * an endpoint that is multi-homed.  Much like sctp_bindx() this call
1285  * allows a caller to specify multiple addresses at which a peer can be
1286  * reached.  The way the SCTP stack uses the list of addresses to set up
1287  * the association is implementation dependent.  This function only
1288  * specifies that the stack will try to make use of all the addresses in
1289  * the list when needed.
1290  *
1291  * Note that the list of addresses passed in is only used for setting up
1292  * the association.  It does not necessarily equal the set of addresses
1293  * the peer uses for the resulting association.  If the caller wants to
1294  * find out the set of peer addresses, it must use sctp_getpaddrs() to
1295  * retrieve them after the association has been set up.
1296  *
1297  * Basically do nothing but copying the addresses from user to kernel
1298  * land and invoking either sctp_connectx(). This is used for tunneling
1299  * the sctp_connectx() request through sctp_setsockopt() from userspace.
1300  *
1301  * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1302  * it.
1303  *
1304  * sk        The sk of the socket
1305  * addrs     The pointer to the addresses
1306  * addrssize Size of the addrs buffer
1307  *
1308  * Returns >=0 if ok, <0 errno code on error.
1309  */
__sctp_setsockopt_connectx(struct sock * sk,struct sockaddr * kaddrs,int addrs_size,sctp_assoc_t * assoc_id)1310 static int __sctp_setsockopt_connectx(struct sock *sk, struct sockaddr *kaddrs,
1311 				      int addrs_size, sctp_assoc_t *assoc_id)
1312 {
1313 	int err = 0, flags = 0;
1314 
1315 	pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1316 		 __func__, sk, kaddrs, addrs_size);
1317 
1318 	/* make sure the 1st addr's sa_family is accessible later */
1319 	if (unlikely(addrs_size < sizeof(sa_family_t)))
1320 		return -EINVAL;
1321 
1322 	/* Allow security module to validate connectx addresses. */
1323 	err = security_sctp_bind_connect(sk, SCTP_SOCKOPT_CONNECTX,
1324 					 (struct sockaddr *)kaddrs,
1325 					  addrs_size);
1326 	if (err)
1327 		return err;
1328 
1329 	/* in-kernel sockets don't generally have a file allocated to them
1330 	 * if all they do is call sock_create_kern().
1331 	 */
1332 	if (sk->sk_socket->file)
1333 		flags = sk->sk_socket->file->f_flags;
1334 
1335 	return __sctp_connect(sk, kaddrs, addrs_size, flags, assoc_id);
1336 }
1337 
1338 /*
1339  * This is an older interface.  It's kept for backward compatibility
1340  * to the option that doesn't provide association id.
1341  */
sctp_setsockopt_connectx_old(struct sock * sk,struct sockaddr * kaddrs,int addrs_size)1342 static int sctp_setsockopt_connectx_old(struct sock *sk,
1343 					struct sockaddr *kaddrs,
1344 					int addrs_size)
1345 {
1346 	return __sctp_setsockopt_connectx(sk, kaddrs, addrs_size, NULL);
1347 }
1348 
1349 /*
1350  * New interface for the API.  The since the API is done with a socket
1351  * option, to make it simple we feed back the association id is as a return
1352  * indication to the call.  Error is always negative and association id is
1353  * always positive.
1354  */
sctp_setsockopt_connectx(struct sock * sk,struct sockaddr * kaddrs,int addrs_size)1355 static int sctp_setsockopt_connectx(struct sock *sk,
1356 				    struct sockaddr *kaddrs,
1357 				    int addrs_size)
1358 {
1359 	sctp_assoc_t assoc_id = 0;
1360 	int err = 0;
1361 
1362 	err = __sctp_setsockopt_connectx(sk, kaddrs, addrs_size, &assoc_id);
1363 
1364 	if (err)
1365 		return err;
1366 	else
1367 		return assoc_id;
1368 }
1369 
1370 /*
1371  * New (hopefully final) interface for the API.
1372  * We use the sctp_getaddrs_old structure so that use-space library
1373  * can avoid any unnecessary allocations. The only different part
1374  * is that we store the actual length of the address buffer into the
1375  * addrs_num structure member. That way we can re-use the existing
1376  * code.
1377  */
1378 #ifdef CONFIG_COMPAT
1379 struct compat_sctp_getaddrs_old {
1380 	sctp_assoc_t	assoc_id;
1381 	s32		addr_num;
1382 	compat_uptr_t	addrs;		/* struct sockaddr * */
1383 };
1384 #endif
1385 
sctp_getsockopt_connectx3(struct sock * sk,int len,char __user * optval,int __user * optlen)1386 static int sctp_getsockopt_connectx3(struct sock *sk, int len,
1387 				     char __user *optval,
1388 				     int __user *optlen)
1389 {
1390 	struct sctp_getaddrs_old param;
1391 	sctp_assoc_t assoc_id = 0;
1392 	struct sockaddr *kaddrs;
1393 	int err = 0;
1394 
1395 #ifdef CONFIG_COMPAT
1396 	if (in_compat_syscall()) {
1397 		struct compat_sctp_getaddrs_old param32;
1398 
1399 		if (len < sizeof(param32))
1400 			return -EINVAL;
1401 		if (copy_from_user(&param32, optval, sizeof(param32)))
1402 			return -EFAULT;
1403 
1404 		param.assoc_id = param32.assoc_id;
1405 		param.addr_num = param32.addr_num;
1406 		param.addrs = compat_ptr(param32.addrs);
1407 	} else
1408 #endif
1409 	{
1410 		if (len < sizeof(param))
1411 			return -EINVAL;
1412 		if (copy_from_user(&param, optval, sizeof(param)))
1413 			return -EFAULT;
1414 	}
1415 
1416 	kaddrs = memdup_user(param.addrs, param.addr_num);
1417 	if (IS_ERR(kaddrs))
1418 		return PTR_ERR(kaddrs);
1419 
1420 	err = __sctp_setsockopt_connectx(sk, kaddrs, param.addr_num, &assoc_id);
1421 	kfree(kaddrs);
1422 	if (err == 0 || err == -EINPROGRESS) {
1423 		if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1424 			return -EFAULT;
1425 		if (put_user(sizeof(assoc_id), optlen))
1426 			return -EFAULT;
1427 	}
1428 
1429 	return err;
1430 }
1431 
1432 /* API 3.1.4 close() - UDP Style Syntax
1433  * Applications use close() to perform graceful shutdown (as described in
1434  * Section 10.1 of [SCTP]) on ALL the associations currently represented
1435  * by a UDP-style socket.
1436  *
1437  * The syntax is
1438  *
1439  *   ret = close(int sd);
1440  *
1441  *   sd      - the socket descriptor of the associations to be closed.
1442  *
1443  * To gracefully shutdown a specific association represented by the
1444  * UDP-style socket, an application should use the sendmsg() call,
1445  * passing no user data, but including the appropriate flag in the
1446  * ancillary data (see Section xxxx).
1447  *
1448  * If sd in the close() call is a branched-off socket representing only
1449  * one association, the shutdown is performed on that association only.
1450  *
1451  * 4.1.6 close() - TCP Style Syntax
1452  *
1453  * Applications use close() to gracefully close down an association.
1454  *
1455  * The syntax is:
1456  *
1457  *    int close(int sd);
1458  *
1459  *      sd      - the socket descriptor of the association to be closed.
1460  *
1461  * After an application calls close() on a socket descriptor, no further
1462  * socket operations will succeed on that descriptor.
1463  *
1464  * API 7.1.4 SO_LINGER
1465  *
1466  * An application using the TCP-style socket can use this option to
1467  * perform the SCTP ABORT primitive.  The linger option structure is:
1468  *
1469  *  struct  linger {
1470  *     int     l_onoff;                // option on/off
1471  *     int     l_linger;               // linger time
1472  * };
1473  *
1474  * To enable the option, set l_onoff to 1.  If the l_linger value is set
1475  * to 0, calling close() is the same as the ABORT primitive.  If the
1476  * value is set to a negative value, the setsockopt() call will return
1477  * an error.  If the value is set to a positive value linger_time, the
1478  * close() can be blocked for at most linger_time ms.  If the graceful
1479  * shutdown phase does not finish during this period, close() will
1480  * return but the graceful shutdown phase continues in the system.
1481  */
sctp_close(struct sock * sk,long timeout)1482 static void sctp_close(struct sock *sk, long timeout)
1483 {
1484 	struct net *net = sock_net(sk);
1485 	struct sctp_endpoint *ep;
1486 	struct sctp_association *asoc;
1487 	struct list_head *pos, *temp;
1488 	unsigned int data_was_unread;
1489 
1490 	pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout);
1491 
1492 	lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1493 	sk->sk_shutdown = SHUTDOWN_MASK;
1494 	inet_sk_set_state(sk, SCTP_SS_CLOSING);
1495 
1496 	ep = sctp_sk(sk)->ep;
1497 
1498 	/* Clean up any skbs sitting on the receive queue.  */
1499 	data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1500 	data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1501 
1502 	/* Walk all associations on an endpoint.  */
1503 	list_for_each_safe(pos, temp, &ep->asocs) {
1504 		asoc = list_entry(pos, struct sctp_association, asocs);
1505 
1506 		if (sctp_style(sk, TCP)) {
1507 			/* A closed association can still be in the list if
1508 			 * it belongs to a TCP-style listening socket that is
1509 			 * not yet accepted. If so, free it. If not, send an
1510 			 * ABORT or SHUTDOWN based on the linger options.
1511 			 */
1512 			if (sctp_state(asoc, CLOSED)) {
1513 				sctp_association_free(asoc);
1514 				continue;
1515 			}
1516 		}
1517 
1518 		if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1519 		    !skb_queue_empty(&asoc->ulpq.reasm) ||
1520 		    !skb_queue_empty(&asoc->ulpq.reasm_uo) ||
1521 		    (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1522 			struct sctp_chunk *chunk;
1523 
1524 			chunk = sctp_make_abort_user(asoc, NULL, 0);
1525 			sctp_primitive_ABORT(net, asoc, chunk);
1526 		} else
1527 			sctp_primitive_SHUTDOWN(net, asoc, NULL);
1528 	}
1529 
1530 	/* On a TCP-style socket, block for at most linger_time if set. */
1531 	if (sctp_style(sk, TCP) && timeout)
1532 		sctp_wait_for_close(sk, timeout);
1533 
1534 	/* This will run the backlog queue.  */
1535 	release_sock(sk);
1536 
1537 	/* Supposedly, no process has access to the socket, but
1538 	 * the net layers still may.
1539 	 * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1540 	 * held and that should be grabbed before socket lock.
1541 	 */
1542 	spin_lock_bh(&net->sctp.addr_wq_lock);
1543 	bh_lock_sock_nested(sk);
1544 
1545 	/* Hold the sock, since sk_common_release() will put sock_put()
1546 	 * and we have just a little more cleanup.
1547 	 */
1548 	sock_hold(sk);
1549 	sk_common_release(sk);
1550 
1551 	bh_unlock_sock(sk);
1552 	spin_unlock_bh(&net->sctp.addr_wq_lock);
1553 
1554 	sock_put(sk);
1555 
1556 	SCTP_DBG_OBJCNT_DEC(sock);
1557 }
1558 
1559 /* Handle EPIPE error. */
sctp_error(struct sock * sk,int flags,int err)1560 static int sctp_error(struct sock *sk, int flags, int err)
1561 {
1562 	if (err == -EPIPE)
1563 		err = sock_error(sk) ? : -EPIPE;
1564 	if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1565 		send_sig(SIGPIPE, current, 0);
1566 	return err;
1567 }
1568 
1569 /* API 3.1.3 sendmsg() - UDP Style Syntax
1570  *
1571  * An application uses sendmsg() and recvmsg() calls to transmit data to
1572  * and receive data from its peer.
1573  *
1574  *  ssize_t sendmsg(int socket, const struct msghdr *message,
1575  *                  int flags);
1576  *
1577  *  socket  - the socket descriptor of the endpoint.
1578  *  message - pointer to the msghdr structure which contains a single
1579  *            user message and possibly some ancillary data.
1580  *
1581  *            See Section 5 for complete description of the data
1582  *            structures.
1583  *
1584  *  flags   - flags sent or received with the user message, see Section
1585  *            5 for complete description of the flags.
1586  *
1587  * Note:  This function could use a rewrite especially when explicit
1588  * connect support comes in.
1589  */
1590 /* BUG:  We do not implement the equivalent of sk_stream_wait_memory(). */
1591 
1592 static int sctp_msghdr_parse(const struct msghdr *msg,
1593 			     struct sctp_cmsgs *cmsgs);
1594 
sctp_sendmsg_parse(struct sock * sk,struct sctp_cmsgs * cmsgs,struct sctp_sndrcvinfo * srinfo,const struct msghdr * msg,size_t msg_len)1595 static int sctp_sendmsg_parse(struct sock *sk, struct sctp_cmsgs *cmsgs,
1596 			      struct sctp_sndrcvinfo *srinfo,
1597 			      const struct msghdr *msg, size_t msg_len)
1598 {
1599 	__u16 sflags;
1600 	int err;
1601 
1602 	if (sctp_sstate(sk, LISTENING) && sctp_style(sk, TCP))
1603 		return -EPIPE;
1604 
1605 	if (msg_len > sk->sk_sndbuf)
1606 		return -EMSGSIZE;
1607 
1608 	memset(cmsgs, 0, sizeof(*cmsgs));
1609 	err = sctp_msghdr_parse(msg, cmsgs);
1610 	if (err) {
1611 		pr_debug("%s: msghdr parse err:%x\n", __func__, err);
1612 		return err;
1613 	}
1614 
1615 	memset(srinfo, 0, sizeof(*srinfo));
1616 	if (cmsgs->srinfo) {
1617 		srinfo->sinfo_stream = cmsgs->srinfo->sinfo_stream;
1618 		srinfo->sinfo_flags = cmsgs->srinfo->sinfo_flags;
1619 		srinfo->sinfo_ppid = cmsgs->srinfo->sinfo_ppid;
1620 		srinfo->sinfo_context = cmsgs->srinfo->sinfo_context;
1621 		srinfo->sinfo_assoc_id = cmsgs->srinfo->sinfo_assoc_id;
1622 		srinfo->sinfo_timetolive = cmsgs->srinfo->sinfo_timetolive;
1623 	}
1624 
1625 	if (cmsgs->sinfo) {
1626 		srinfo->sinfo_stream = cmsgs->sinfo->snd_sid;
1627 		srinfo->sinfo_flags = cmsgs->sinfo->snd_flags;
1628 		srinfo->sinfo_ppid = cmsgs->sinfo->snd_ppid;
1629 		srinfo->sinfo_context = cmsgs->sinfo->snd_context;
1630 		srinfo->sinfo_assoc_id = cmsgs->sinfo->snd_assoc_id;
1631 	}
1632 
1633 	if (cmsgs->prinfo) {
1634 		srinfo->sinfo_timetolive = cmsgs->prinfo->pr_value;
1635 		SCTP_PR_SET_POLICY(srinfo->sinfo_flags,
1636 				   cmsgs->prinfo->pr_policy);
1637 	}
1638 
1639 	sflags = srinfo->sinfo_flags;
1640 	if (!sflags && msg_len)
1641 		return 0;
1642 
1643 	if (sctp_style(sk, TCP) && (sflags & (SCTP_EOF | SCTP_ABORT)))
1644 		return -EINVAL;
1645 
1646 	if (((sflags & SCTP_EOF) && msg_len > 0) ||
1647 	    (!(sflags & (SCTP_EOF | SCTP_ABORT)) && msg_len == 0))
1648 		return -EINVAL;
1649 
1650 	if ((sflags & SCTP_ADDR_OVER) && !msg->msg_name)
1651 		return -EINVAL;
1652 
1653 	return 0;
1654 }
1655 
sctp_sendmsg_new_asoc(struct sock * sk,__u16 sflags,struct sctp_cmsgs * cmsgs,union sctp_addr * daddr,struct sctp_transport ** tp)1656 static int sctp_sendmsg_new_asoc(struct sock *sk, __u16 sflags,
1657 				 struct sctp_cmsgs *cmsgs,
1658 				 union sctp_addr *daddr,
1659 				 struct sctp_transport **tp)
1660 {
1661 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1662 	struct sctp_association *asoc;
1663 	struct cmsghdr *cmsg;
1664 	__be32 flowinfo = 0;
1665 	struct sctp_af *af;
1666 	int err;
1667 
1668 	*tp = NULL;
1669 
1670 	if (sflags & (SCTP_EOF | SCTP_ABORT))
1671 		return -EINVAL;
1672 
1673 	if (sctp_style(sk, TCP) && (sctp_sstate(sk, ESTABLISHED) ||
1674 				    sctp_sstate(sk, CLOSING)))
1675 		return -EADDRNOTAVAIL;
1676 
1677 	/* Label connection socket for first association 1-to-many
1678 	 * style for client sequence socket()->sendmsg(). This
1679 	 * needs to be done before sctp_assoc_add_peer() as that will
1680 	 * set up the initial packet that needs to account for any
1681 	 * security ip options (CIPSO/CALIPSO) added to the packet.
1682 	 */
1683 	af = sctp_get_af_specific(daddr->sa.sa_family);
1684 	if (!af)
1685 		return -EINVAL;
1686 	err = security_sctp_bind_connect(sk, SCTP_SENDMSG_CONNECT,
1687 					 (struct sockaddr *)daddr,
1688 					 af->sockaddr_len);
1689 	if (err < 0)
1690 		return err;
1691 
1692 	err = sctp_connect_new_asoc(ep, daddr, cmsgs->init, tp);
1693 	if (err)
1694 		return err;
1695 	asoc = (*tp)->asoc;
1696 
1697 	if (!cmsgs->addrs_msg)
1698 		return 0;
1699 
1700 	if (daddr->sa.sa_family == AF_INET6)
1701 		flowinfo = daddr->v6.sin6_flowinfo;
1702 
1703 	/* sendv addr list parse */
1704 	for_each_cmsghdr(cmsg, cmsgs->addrs_msg) {
1705 		union sctp_addr _daddr;
1706 		int dlen;
1707 
1708 		if (cmsg->cmsg_level != IPPROTO_SCTP ||
1709 		    (cmsg->cmsg_type != SCTP_DSTADDRV4 &&
1710 		     cmsg->cmsg_type != SCTP_DSTADDRV6))
1711 			continue;
1712 
1713 		daddr = &_daddr;
1714 		memset(daddr, 0, sizeof(*daddr));
1715 		dlen = cmsg->cmsg_len - sizeof(struct cmsghdr);
1716 		if (cmsg->cmsg_type == SCTP_DSTADDRV4) {
1717 			if (dlen < sizeof(struct in_addr)) {
1718 				err = -EINVAL;
1719 				goto free;
1720 			}
1721 
1722 			dlen = sizeof(struct in_addr);
1723 			daddr->v4.sin_family = AF_INET;
1724 			daddr->v4.sin_port = htons(asoc->peer.port);
1725 			memcpy(&daddr->v4.sin_addr, CMSG_DATA(cmsg), dlen);
1726 		} else {
1727 			if (dlen < sizeof(struct in6_addr)) {
1728 				err = -EINVAL;
1729 				goto free;
1730 			}
1731 
1732 			dlen = sizeof(struct in6_addr);
1733 			daddr->v6.sin6_flowinfo = flowinfo;
1734 			daddr->v6.sin6_family = AF_INET6;
1735 			daddr->v6.sin6_port = htons(asoc->peer.port);
1736 			memcpy(&daddr->v6.sin6_addr, CMSG_DATA(cmsg), dlen);
1737 		}
1738 
1739 		err = sctp_connect_add_peer(asoc, daddr, sizeof(*daddr));
1740 		if (err)
1741 			goto free;
1742 	}
1743 
1744 	return 0;
1745 
1746 free:
1747 	sctp_association_free(asoc);
1748 	return err;
1749 }
1750 
sctp_sendmsg_check_sflags(struct sctp_association * asoc,__u16 sflags,struct msghdr * msg,size_t msg_len)1751 static int sctp_sendmsg_check_sflags(struct sctp_association *asoc,
1752 				     __u16 sflags, struct msghdr *msg,
1753 				     size_t msg_len)
1754 {
1755 	struct sock *sk = asoc->base.sk;
1756 	struct net *net = sock_net(sk);
1757 
1758 	if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP))
1759 		return -EPIPE;
1760 
1761 	if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP) &&
1762 	    !sctp_state(asoc, ESTABLISHED))
1763 		return 0;
1764 
1765 	if (sflags & SCTP_EOF) {
1766 		pr_debug("%s: shutting down association:%p\n", __func__, asoc);
1767 		sctp_primitive_SHUTDOWN(net, asoc, NULL);
1768 
1769 		return 0;
1770 	}
1771 
1772 	if (sflags & SCTP_ABORT) {
1773 		struct sctp_chunk *chunk;
1774 
1775 		chunk = sctp_make_abort_user(asoc, msg, msg_len);
1776 		if (!chunk)
1777 			return -ENOMEM;
1778 
1779 		pr_debug("%s: aborting association:%p\n", __func__, asoc);
1780 		sctp_primitive_ABORT(net, asoc, chunk);
1781 		iov_iter_revert(&msg->msg_iter, msg_len);
1782 
1783 		return 0;
1784 	}
1785 
1786 	return 1;
1787 }
1788 
sctp_sendmsg_to_asoc(struct sctp_association * asoc,struct msghdr * msg,size_t msg_len,struct sctp_transport * transport,struct sctp_sndrcvinfo * sinfo)1789 static int sctp_sendmsg_to_asoc(struct sctp_association *asoc,
1790 				struct msghdr *msg, size_t msg_len,
1791 				struct sctp_transport *transport,
1792 				struct sctp_sndrcvinfo *sinfo)
1793 {
1794 	struct sock *sk = asoc->base.sk;
1795 	struct sctp_sock *sp = sctp_sk(sk);
1796 	struct net *net = sock_net(sk);
1797 	struct sctp_datamsg *datamsg;
1798 	bool wait_connect = false;
1799 	struct sctp_chunk *chunk;
1800 	long timeo;
1801 	int err;
1802 
1803 	if (sinfo->sinfo_stream >= asoc->stream.outcnt) {
1804 		err = -EINVAL;
1805 		goto err;
1806 	}
1807 
1808 	if (unlikely(!SCTP_SO(&asoc->stream, sinfo->sinfo_stream)->ext)) {
1809 		err = sctp_stream_init_ext(&asoc->stream, sinfo->sinfo_stream);
1810 		if (err)
1811 			goto err;
1812 	}
1813 
1814 	if (sp->disable_fragments && msg_len > asoc->frag_point) {
1815 		err = -EMSGSIZE;
1816 		goto err;
1817 	}
1818 
1819 	if (asoc->pmtu_pending) {
1820 		if (sp->param_flags & SPP_PMTUD_ENABLE)
1821 			sctp_assoc_sync_pmtu(asoc);
1822 		asoc->pmtu_pending = 0;
1823 	}
1824 
1825 	if (sctp_wspace(asoc) < (int)msg_len)
1826 		sctp_prsctp_prune(asoc, sinfo, msg_len - sctp_wspace(asoc));
1827 
1828 	if (sctp_wspace(asoc) <= 0 || !sk_wmem_schedule(sk, msg_len)) {
1829 		timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1830 		err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1831 		if (err)
1832 			goto err;
1833 		if (unlikely(sinfo->sinfo_stream >= asoc->stream.outcnt)) {
1834 			err = -EINVAL;
1835 			goto err;
1836 		}
1837 	}
1838 
1839 	if (sctp_state(asoc, CLOSED)) {
1840 		err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1841 		if (err)
1842 			goto err;
1843 
1844 		if (asoc->ep->intl_enable) {
1845 			timeo = sock_sndtimeo(sk, 0);
1846 			err = sctp_wait_for_connect(asoc, &timeo);
1847 			if (err) {
1848 				err = -ESRCH;
1849 				goto err;
1850 			}
1851 		} else {
1852 			wait_connect = true;
1853 		}
1854 
1855 		pr_debug("%s: we associated primitively\n", __func__);
1856 	}
1857 
1858 	datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
1859 	if (IS_ERR(datamsg)) {
1860 		err = PTR_ERR(datamsg);
1861 		goto err;
1862 	}
1863 
1864 	asoc->force_delay = !!(msg->msg_flags & MSG_MORE);
1865 
1866 	list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
1867 		sctp_chunk_hold(chunk);
1868 		sctp_set_owner_w(chunk);
1869 		chunk->transport = transport;
1870 	}
1871 
1872 	err = sctp_primitive_SEND(net, asoc, datamsg);
1873 	if (err) {
1874 		sctp_datamsg_free(datamsg);
1875 		goto err;
1876 	}
1877 
1878 	pr_debug("%s: we sent primitively\n", __func__);
1879 
1880 	sctp_datamsg_put(datamsg);
1881 
1882 	if (unlikely(wait_connect)) {
1883 		timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1884 		sctp_wait_for_connect(asoc, &timeo);
1885 	}
1886 
1887 	err = msg_len;
1888 
1889 err:
1890 	return err;
1891 }
1892 
sctp_sendmsg_get_daddr(struct sock * sk,const struct msghdr * msg,struct sctp_cmsgs * cmsgs)1893 static union sctp_addr *sctp_sendmsg_get_daddr(struct sock *sk,
1894 					       const struct msghdr *msg,
1895 					       struct sctp_cmsgs *cmsgs)
1896 {
1897 	union sctp_addr *daddr = NULL;
1898 	int err;
1899 
1900 	if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1901 		int len = msg->msg_namelen;
1902 
1903 		if (len > sizeof(*daddr))
1904 			len = sizeof(*daddr);
1905 
1906 		daddr = (union sctp_addr *)msg->msg_name;
1907 
1908 		err = sctp_verify_addr(sk, daddr, len);
1909 		if (err)
1910 			return ERR_PTR(err);
1911 	}
1912 
1913 	return daddr;
1914 }
1915 
sctp_sendmsg_update_sinfo(struct sctp_association * asoc,struct sctp_sndrcvinfo * sinfo,struct sctp_cmsgs * cmsgs)1916 static void sctp_sendmsg_update_sinfo(struct sctp_association *asoc,
1917 				      struct sctp_sndrcvinfo *sinfo,
1918 				      struct sctp_cmsgs *cmsgs)
1919 {
1920 	if (!cmsgs->srinfo && !cmsgs->sinfo) {
1921 		sinfo->sinfo_stream = asoc->default_stream;
1922 		sinfo->sinfo_ppid = asoc->default_ppid;
1923 		sinfo->sinfo_context = asoc->default_context;
1924 		sinfo->sinfo_assoc_id = sctp_assoc2id(asoc);
1925 
1926 		if (!cmsgs->prinfo)
1927 			sinfo->sinfo_flags = asoc->default_flags;
1928 	}
1929 
1930 	if (!cmsgs->srinfo && !cmsgs->prinfo)
1931 		sinfo->sinfo_timetolive = asoc->default_timetolive;
1932 
1933 	if (cmsgs->authinfo) {
1934 		/* Reuse sinfo_tsn to indicate that authinfo was set and
1935 		 * sinfo_ssn to save the keyid on tx path.
1936 		 */
1937 		sinfo->sinfo_tsn = 1;
1938 		sinfo->sinfo_ssn = cmsgs->authinfo->auth_keynumber;
1939 	}
1940 }
1941 
sctp_sendmsg(struct sock * sk,struct msghdr * msg,size_t msg_len)1942 static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
1943 {
1944 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1945 	struct sctp_transport *transport = NULL;
1946 	struct sctp_sndrcvinfo _sinfo, *sinfo;
1947 	struct sctp_association *asoc, *tmp;
1948 	struct sctp_cmsgs cmsgs;
1949 	union sctp_addr *daddr;
1950 	bool new = false;
1951 	__u16 sflags;
1952 	int err;
1953 
1954 	/* Parse and get snd_info */
1955 	err = sctp_sendmsg_parse(sk, &cmsgs, &_sinfo, msg, msg_len);
1956 	if (err)
1957 		goto out;
1958 
1959 	sinfo  = &_sinfo;
1960 	sflags = sinfo->sinfo_flags;
1961 
1962 	/* Get daddr from msg */
1963 	daddr = sctp_sendmsg_get_daddr(sk, msg, &cmsgs);
1964 	if (IS_ERR(daddr)) {
1965 		err = PTR_ERR(daddr);
1966 		goto out;
1967 	}
1968 
1969 	lock_sock(sk);
1970 
1971 	/* SCTP_SENDALL process */
1972 	if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) {
1973 		list_for_each_entry_safe(asoc, tmp, &ep->asocs, asocs) {
1974 			err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
1975 							msg_len);
1976 			if (err == 0)
1977 				continue;
1978 			if (err < 0)
1979 				goto out_unlock;
1980 
1981 			sctp_sendmsg_update_sinfo(asoc, sinfo, &cmsgs);
1982 
1983 			err = sctp_sendmsg_to_asoc(asoc, msg, msg_len,
1984 						   NULL, sinfo);
1985 			if (err < 0)
1986 				goto out_unlock;
1987 
1988 			iov_iter_revert(&msg->msg_iter, err);
1989 		}
1990 
1991 		goto out_unlock;
1992 	}
1993 
1994 	/* Get and check or create asoc */
1995 	if (daddr) {
1996 		asoc = sctp_endpoint_lookup_assoc(ep, daddr, &transport);
1997 		if (asoc) {
1998 			err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
1999 							msg_len);
2000 			if (err <= 0)
2001 				goto out_unlock;
2002 		} else {
2003 			err = sctp_sendmsg_new_asoc(sk, sflags, &cmsgs, daddr,
2004 						    &transport);
2005 			if (err)
2006 				goto out_unlock;
2007 
2008 			asoc = transport->asoc;
2009 			new = true;
2010 		}
2011 
2012 		if (!sctp_style(sk, TCP) && !(sflags & SCTP_ADDR_OVER))
2013 			transport = NULL;
2014 	} else {
2015 		asoc = sctp_id2assoc(sk, sinfo->sinfo_assoc_id);
2016 		if (!asoc) {
2017 			err = -EPIPE;
2018 			goto out_unlock;
2019 		}
2020 
2021 		err = sctp_sendmsg_check_sflags(asoc, sflags, msg, msg_len);
2022 		if (err <= 0)
2023 			goto out_unlock;
2024 	}
2025 
2026 	/* Update snd_info with the asoc */
2027 	sctp_sendmsg_update_sinfo(asoc, sinfo, &cmsgs);
2028 
2029 	/* Send msg to the asoc */
2030 	err = sctp_sendmsg_to_asoc(asoc, msg, msg_len, transport, sinfo);
2031 	if (err < 0 && err != -ESRCH && new)
2032 		sctp_association_free(asoc);
2033 
2034 out_unlock:
2035 	release_sock(sk);
2036 out:
2037 	return sctp_error(sk, msg->msg_flags, err);
2038 }
2039 
2040 /* This is an extended version of skb_pull() that removes the data from the
2041  * start of a skb even when data is spread across the list of skb's in the
2042  * frag_list. len specifies the total amount of data that needs to be removed.
2043  * when 'len' bytes could be removed from the skb, it returns 0.
2044  * If 'len' exceeds the total skb length,  it returns the no. of bytes that
2045  * could not be removed.
2046  */
sctp_skb_pull(struct sk_buff * skb,int len)2047 static int sctp_skb_pull(struct sk_buff *skb, int len)
2048 {
2049 	struct sk_buff *list;
2050 	int skb_len = skb_headlen(skb);
2051 	int rlen;
2052 
2053 	if (len <= skb_len) {
2054 		__skb_pull(skb, len);
2055 		return 0;
2056 	}
2057 	len -= skb_len;
2058 	__skb_pull(skb, skb_len);
2059 
2060 	skb_walk_frags(skb, list) {
2061 		rlen = sctp_skb_pull(list, len);
2062 		skb->len -= (len-rlen);
2063 		skb->data_len -= (len-rlen);
2064 
2065 		if (!rlen)
2066 			return 0;
2067 
2068 		len = rlen;
2069 	}
2070 
2071 	return len;
2072 }
2073 
2074 /* API 3.1.3  recvmsg() - UDP Style Syntax
2075  *
2076  *  ssize_t recvmsg(int socket, struct msghdr *message,
2077  *                    int flags);
2078  *
2079  *  socket  - the socket descriptor of the endpoint.
2080  *  message - pointer to the msghdr structure which contains a single
2081  *            user message and possibly some ancillary data.
2082  *
2083  *            See Section 5 for complete description of the data
2084  *            structures.
2085  *
2086  *  flags   - flags sent or received with the user message, see Section
2087  *            5 for complete description of the flags.
2088  */
sctp_recvmsg(struct sock * sk,struct msghdr * msg,size_t len,int flags,int * addr_len)2089 static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
2090 			int flags, int *addr_len)
2091 {
2092 	struct sctp_ulpevent *event = NULL;
2093 	struct sctp_sock *sp = sctp_sk(sk);
2094 	struct sk_buff *skb, *head_skb;
2095 	int copied;
2096 	int err = 0;
2097 	int skb_len;
2098 
2099 	pr_debug("%s: sk:%p, msghdr:%p, len:%zd, flags:0x%x, addr_len:%p)\n",
2100 		 __func__, sk, msg, len, flags, addr_len);
2101 
2102 	if (unlikely(flags & MSG_ERRQUEUE))
2103 		return inet_recv_error(sk, msg, len, addr_len);
2104 
2105 	if (sk_can_busy_loop(sk) &&
2106 	    skb_queue_empty_lockless(&sk->sk_receive_queue))
2107 		sk_busy_loop(sk, flags & MSG_DONTWAIT);
2108 
2109 	lock_sock(sk);
2110 
2111 	if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED) &&
2112 	    !sctp_sstate(sk, CLOSING) && !sctp_sstate(sk, CLOSED)) {
2113 		err = -ENOTCONN;
2114 		goto out;
2115 	}
2116 
2117 	skb = sctp_skb_recv_datagram(sk, flags, &err);
2118 	if (!skb)
2119 		goto out;
2120 
2121 	/* Get the total length of the skb including any skb's in the
2122 	 * frag_list.
2123 	 */
2124 	skb_len = skb->len;
2125 
2126 	copied = skb_len;
2127 	if (copied > len)
2128 		copied = len;
2129 
2130 	err = skb_copy_datagram_msg(skb, 0, msg, copied);
2131 
2132 	event = sctp_skb2event(skb);
2133 
2134 	if (err)
2135 		goto out_free;
2136 
2137 	if (event->chunk && event->chunk->head_skb)
2138 		head_skb = event->chunk->head_skb;
2139 	else
2140 		head_skb = skb;
2141 	sock_recv_cmsgs(msg, sk, head_skb);
2142 	if (sctp_ulpevent_is_notification(event)) {
2143 		msg->msg_flags |= MSG_NOTIFICATION;
2144 		sp->pf->event_msgname(event, msg->msg_name, addr_len);
2145 	} else {
2146 		sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len);
2147 	}
2148 
2149 	/* Check if we allow SCTP_NXTINFO. */
2150 	if (sp->recvnxtinfo)
2151 		sctp_ulpevent_read_nxtinfo(event, msg, sk);
2152 	/* Check if we allow SCTP_RCVINFO. */
2153 	if (sp->recvrcvinfo)
2154 		sctp_ulpevent_read_rcvinfo(event, msg);
2155 	/* Check if we allow SCTP_SNDRCVINFO. */
2156 	if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_DATA_IO_EVENT))
2157 		sctp_ulpevent_read_sndrcvinfo(event, msg);
2158 
2159 	err = copied;
2160 
2161 	/* If skb's length exceeds the user's buffer, update the skb and
2162 	 * push it back to the receive_queue so that the next call to
2163 	 * recvmsg() will return the remaining data. Don't set MSG_EOR.
2164 	 */
2165 	if (skb_len > copied) {
2166 		msg->msg_flags &= ~MSG_EOR;
2167 		if (flags & MSG_PEEK)
2168 			goto out_free;
2169 		sctp_skb_pull(skb, copied);
2170 		skb_queue_head(&sk->sk_receive_queue, skb);
2171 
2172 		/* When only partial message is copied to the user, increase
2173 		 * rwnd by that amount. If all the data in the skb is read,
2174 		 * rwnd is updated when the event is freed.
2175 		 */
2176 		if (!sctp_ulpevent_is_notification(event))
2177 			sctp_assoc_rwnd_increase(event->asoc, copied);
2178 		goto out;
2179 	} else if ((event->msg_flags & MSG_NOTIFICATION) ||
2180 		   (event->msg_flags & MSG_EOR))
2181 		msg->msg_flags |= MSG_EOR;
2182 	else
2183 		msg->msg_flags &= ~MSG_EOR;
2184 
2185 out_free:
2186 	if (flags & MSG_PEEK) {
2187 		/* Release the skb reference acquired after peeking the skb in
2188 		 * sctp_skb_recv_datagram().
2189 		 */
2190 		kfree_skb(skb);
2191 	} else {
2192 		/* Free the event which includes releasing the reference to
2193 		 * the owner of the skb, freeing the skb and updating the
2194 		 * rwnd.
2195 		 */
2196 		sctp_ulpevent_free(event);
2197 	}
2198 out:
2199 	release_sock(sk);
2200 	return err;
2201 }
2202 
2203 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2204  *
2205  * This option is a on/off flag.  If enabled no SCTP message
2206  * fragmentation will be performed.  Instead if a message being sent
2207  * exceeds the current PMTU size, the message will NOT be sent and
2208  * instead a error will be indicated to the user.
2209  */
sctp_setsockopt_disable_fragments(struct sock * sk,int * val,unsigned int optlen)2210 static int sctp_setsockopt_disable_fragments(struct sock *sk, int *val,
2211 					     unsigned int optlen)
2212 {
2213 	if (optlen < sizeof(int))
2214 		return -EINVAL;
2215 	sctp_sk(sk)->disable_fragments = (*val == 0) ? 0 : 1;
2216 	return 0;
2217 }
2218 
sctp_setsockopt_events(struct sock * sk,__u8 * sn_type,unsigned int optlen)2219 static int sctp_setsockopt_events(struct sock *sk, __u8 *sn_type,
2220 				  unsigned int optlen)
2221 {
2222 	struct sctp_sock *sp = sctp_sk(sk);
2223 	struct sctp_association *asoc;
2224 	int i;
2225 
2226 	if (optlen > sizeof(struct sctp_event_subscribe))
2227 		return -EINVAL;
2228 
2229 	for (i = 0; i < optlen; i++)
2230 		sctp_ulpevent_type_set(&sp->subscribe, SCTP_SN_TYPE_BASE + i,
2231 				       sn_type[i]);
2232 
2233 	list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2234 		asoc->subscribe = sctp_sk(sk)->subscribe;
2235 
2236 	/* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2237 	 * if there is no data to be sent or retransmit, the stack will
2238 	 * immediately send up this notification.
2239 	 */
2240 	if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_SENDER_DRY_EVENT)) {
2241 		struct sctp_ulpevent *event;
2242 
2243 		asoc = sctp_id2assoc(sk, 0);
2244 		if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2245 			event = sctp_ulpevent_make_sender_dry_event(asoc,
2246 					GFP_USER | __GFP_NOWARN);
2247 			if (!event)
2248 				return -ENOMEM;
2249 
2250 			asoc->stream.si->enqueue_event(&asoc->ulpq, event);
2251 		}
2252 	}
2253 
2254 	return 0;
2255 }
2256 
2257 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2258  *
2259  * This socket option is applicable to the UDP-style socket only.  When
2260  * set it will cause associations that are idle for more than the
2261  * specified number of seconds to automatically close.  An association
2262  * being idle is defined an association that has NOT sent or received
2263  * user data.  The special value of '0' indicates that no automatic
2264  * close of any associations should be performed.  The option expects an
2265  * integer defining the number of seconds of idle time before an
2266  * association is closed.
2267  */
sctp_setsockopt_autoclose(struct sock * sk,u32 * optval,unsigned int optlen)2268 static int sctp_setsockopt_autoclose(struct sock *sk, u32 *optval,
2269 				     unsigned int optlen)
2270 {
2271 	struct sctp_sock *sp = sctp_sk(sk);
2272 	struct net *net = sock_net(sk);
2273 
2274 	/* Applicable to UDP-style socket only */
2275 	if (sctp_style(sk, TCP))
2276 		return -EOPNOTSUPP;
2277 	if (optlen != sizeof(int))
2278 		return -EINVAL;
2279 
2280 	sp->autoclose = *optval;
2281 	if (sp->autoclose > net->sctp.max_autoclose)
2282 		sp->autoclose = net->sctp.max_autoclose;
2283 
2284 	return 0;
2285 }
2286 
2287 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2288  *
2289  * Applications can enable or disable heartbeats for any peer address of
2290  * an association, modify an address's heartbeat interval, force a
2291  * heartbeat to be sent immediately, and adjust the address's maximum
2292  * number of retransmissions sent before an address is considered
2293  * unreachable.  The following structure is used to access and modify an
2294  * address's parameters:
2295  *
2296  *  struct sctp_paddrparams {
2297  *     sctp_assoc_t            spp_assoc_id;
2298  *     struct sockaddr_storage spp_address;
2299  *     uint32_t                spp_hbinterval;
2300  *     uint16_t                spp_pathmaxrxt;
2301  *     uint32_t                spp_pathmtu;
2302  *     uint32_t                spp_sackdelay;
2303  *     uint32_t                spp_flags;
2304  *     uint32_t                spp_ipv6_flowlabel;
2305  *     uint8_t                 spp_dscp;
2306  * };
2307  *
2308  *   spp_assoc_id    - (one-to-many style socket) This is filled in the
2309  *                     application, and identifies the association for
2310  *                     this query.
2311  *   spp_address     - This specifies which address is of interest.
2312  *   spp_hbinterval  - This contains the value of the heartbeat interval,
2313  *                     in milliseconds.  If a  value of zero
2314  *                     is present in this field then no changes are to
2315  *                     be made to this parameter.
2316  *   spp_pathmaxrxt  - This contains the maximum number of
2317  *                     retransmissions before this address shall be
2318  *                     considered unreachable. If a  value of zero
2319  *                     is present in this field then no changes are to
2320  *                     be made to this parameter.
2321  *   spp_pathmtu     - When Path MTU discovery is disabled the value
2322  *                     specified here will be the "fixed" path mtu.
2323  *                     Note that if the spp_address field is empty
2324  *                     then all associations on this address will
2325  *                     have this fixed path mtu set upon them.
2326  *
2327  *   spp_sackdelay   - When delayed sack is enabled, this value specifies
2328  *                     the number of milliseconds that sacks will be delayed
2329  *                     for. This value will apply to all addresses of an
2330  *                     association if the spp_address field is empty. Note
2331  *                     also, that if delayed sack is enabled and this
2332  *                     value is set to 0, no change is made to the last
2333  *                     recorded delayed sack timer value.
2334  *
2335  *   spp_flags       - These flags are used to control various features
2336  *                     on an association. The flag field may contain
2337  *                     zero or more of the following options.
2338  *
2339  *                     SPP_HB_ENABLE  - Enable heartbeats on the
2340  *                     specified address. Note that if the address
2341  *                     field is empty all addresses for the association
2342  *                     have heartbeats enabled upon them.
2343  *
2344  *                     SPP_HB_DISABLE - Disable heartbeats on the
2345  *                     speicifed address. Note that if the address
2346  *                     field is empty all addresses for the association
2347  *                     will have their heartbeats disabled. Note also
2348  *                     that SPP_HB_ENABLE and SPP_HB_DISABLE are
2349  *                     mutually exclusive, only one of these two should
2350  *                     be specified. Enabling both fields will have
2351  *                     undetermined results.
2352  *
2353  *                     SPP_HB_DEMAND - Request a user initiated heartbeat
2354  *                     to be made immediately.
2355  *
2356  *                     SPP_HB_TIME_IS_ZERO - Specify's that the time for
2357  *                     heartbeat delayis to be set to the value of 0
2358  *                     milliseconds.
2359  *
2360  *                     SPP_PMTUD_ENABLE - This field will enable PMTU
2361  *                     discovery upon the specified address. Note that
2362  *                     if the address feild is empty then all addresses
2363  *                     on the association are effected.
2364  *
2365  *                     SPP_PMTUD_DISABLE - This field will disable PMTU
2366  *                     discovery upon the specified address. Note that
2367  *                     if the address feild is empty then all addresses
2368  *                     on the association are effected. Not also that
2369  *                     SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2370  *                     exclusive. Enabling both will have undetermined
2371  *                     results.
2372  *
2373  *                     SPP_SACKDELAY_ENABLE - Setting this flag turns
2374  *                     on delayed sack. The time specified in spp_sackdelay
2375  *                     is used to specify the sack delay for this address. Note
2376  *                     that if spp_address is empty then all addresses will
2377  *                     enable delayed sack and take on the sack delay
2378  *                     value specified in spp_sackdelay.
2379  *                     SPP_SACKDELAY_DISABLE - Setting this flag turns
2380  *                     off delayed sack. If the spp_address field is blank then
2381  *                     delayed sack is disabled for the entire association. Note
2382  *                     also that this field is mutually exclusive to
2383  *                     SPP_SACKDELAY_ENABLE, setting both will have undefined
2384  *                     results.
2385  *
2386  *                     SPP_IPV6_FLOWLABEL:  Setting this flag enables the
2387  *                     setting of the IPV6 flow label value.  The value is
2388  *                     contained in the spp_ipv6_flowlabel field.
2389  *                     Upon retrieval, this flag will be set to indicate that
2390  *                     the spp_ipv6_flowlabel field has a valid value returned.
2391  *                     If a specific destination address is set (in the
2392  *                     spp_address field), then the value returned is that of
2393  *                     the address.  If just an association is specified (and
2394  *                     no address), then the association's default flow label
2395  *                     is returned.  If neither an association nor a destination
2396  *                     is specified, then the socket's default flow label is
2397  *                     returned.  For non-IPv6 sockets, this flag will be left
2398  *                     cleared.
2399  *
2400  *                     SPP_DSCP:  Setting this flag enables the setting of the
2401  *                     Differentiated Services Code Point (DSCP) value
2402  *                     associated with either the association or a specific
2403  *                     address.  The value is obtained in the spp_dscp field.
2404  *                     Upon retrieval, this flag will be set to indicate that
2405  *                     the spp_dscp field has a valid value returned.  If a
2406  *                     specific destination address is set when called (in the
2407  *                     spp_address field), then that specific destination
2408  *                     address's DSCP value is returned.  If just an association
2409  *                     is specified, then the association's default DSCP is
2410  *                     returned.  If neither an association nor a destination is
2411  *                     specified, then the socket's default DSCP is returned.
2412  *
2413  *   spp_ipv6_flowlabel
2414  *                   - This field is used in conjunction with the
2415  *                     SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
2416  *                     The 20 least significant bits are used for the flow
2417  *                     label.  This setting has precedence over any IPv6-layer
2418  *                     setting.
2419  *
2420  *   spp_dscp        - This field is used in conjunction with the SPP_DSCP flag
2421  *                     and contains the DSCP.  The 6 most significant bits are
2422  *                     used for the DSCP.  This setting has precedence over any
2423  *                     IPv4- or IPv6- layer setting.
2424  */
sctp_apply_peer_addr_params(struct sctp_paddrparams * params,struct sctp_transport * trans,struct sctp_association * asoc,struct sctp_sock * sp,int hb_change,int pmtud_change,int sackdelay_change)2425 static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2426 				       struct sctp_transport   *trans,
2427 				       struct sctp_association *asoc,
2428 				       struct sctp_sock        *sp,
2429 				       int                      hb_change,
2430 				       int                      pmtud_change,
2431 				       int                      sackdelay_change)
2432 {
2433 	int error;
2434 
2435 	if (params->spp_flags & SPP_HB_DEMAND && trans) {
2436 		error = sctp_primitive_REQUESTHEARTBEAT(trans->asoc->base.net,
2437 							trans->asoc, trans);
2438 		if (error)
2439 			return error;
2440 	}
2441 
2442 	/* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2443 	 * this field is ignored.  Note also that a value of zero indicates
2444 	 * the current setting should be left unchanged.
2445 	 */
2446 	if (params->spp_flags & SPP_HB_ENABLE) {
2447 
2448 		/* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2449 		 * set.  This lets us use 0 value when this flag
2450 		 * is set.
2451 		 */
2452 		if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2453 			params->spp_hbinterval = 0;
2454 
2455 		if (params->spp_hbinterval ||
2456 		    (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2457 			if (trans) {
2458 				trans->hbinterval =
2459 				    msecs_to_jiffies(params->spp_hbinterval);
2460 				sctp_transport_reset_hb_timer(trans);
2461 			} else if (asoc) {
2462 				asoc->hbinterval =
2463 				    msecs_to_jiffies(params->spp_hbinterval);
2464 			} else {
2465 				sp->hbinterval = params->spp_hbinterval;
2466 			}
2467 		}
2468 	}
2469 
2470 	if (hb_change) {
2471 		if (trans) {
2472 			trans->param_flags =
2473 				(trans->param_flags & ~SPP_HB) | hb_change;
2474 		} else if (asoc) {
2475 			asoc->param_flags =
2476 				(asoc->param_flags & ~SPP_HB) | hb_change;
2477 		} else {
2478 			sp->param_flags =
2479 				(sp->param_flags & ~SPP_HB) | hb_change;
2480 		}
2481 	}
2482 
2483 	/* When Path MTU discovery is disabled the value specified here will
2484 	 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2485 	 * include the flag SPP_PMTUD_DISABLE for this field to have any
2486 	 * effect).
2487 	 */
2488 	if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2489 		if (trans) {
2490 			trans->pathmtu = params->spp_pathmtu;
2491 			sctp_assoc_sync_pmtu(asoc);
2492 		} else if (asoc) {
2493 			sctp_assoc_set_pmtu(asoc, params->spp_pathmtu);
2494 		} else {
2495 			sp->pathmtu = params->spp_pathmtu;
2496 		}
2497 	}
2498 
2499 	if (pmtud_change) {
2500 		if (trans) {
2501 			int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2502 				(params->spp_flags & SPP_PMTUD_ENABLE);
2503 			trans->param_flags =
2504 				(trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2505 			if (update) {
2506 				sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2507 				sctp_assoc_sync_pmtu(asoc);
2508 			}
2509 			sctp_transport_pl_reset(trans);
2510 		} else if (asoc) {
2511 			asoc->param_flags =
2512 				(asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2513 		} else {
2514 			sp->param_flags =
2515 				(sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2516 		}
2517 	}
2518 
2519 	/* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2520 	 * value of this field is ignored.  Note also that a value of zero
2521 	 * indicates the current setting should be left unchanged.
2522 	 */
2523 	if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2524 		if (trans) {
2525 			trans->sackdelay =
2526 				msecs_to_jiffies(params->spp_sackdelay);
2527 		} else if (asoc) {
2528 			asoc->sackdelay =
2529 				msecs_to_jiffies(params->spp_sackdelay);
2530 		} else {
2531 			sp->sackdelay = params->spp_sackdelay;
2532 		}
2533 	}
2534 
2535 	if (sackdelay_change) {
2536 		if (trans) {
2537 			trans->param_flags =
2538 				(trans->param_flags & ~SPP_SACKDELAY) |
2539 				sackdelay_change;
2540 		} else if (asoc) {
2541 			asoc->param_flags =
2542 				(asoc->param_flags & ~SPP_SACKDELAY) |
2543 				sackdelay_change;
2544 		} else {
2545 			sp->param_flags =
2546 				(sp->param_flags & ~SPP_SACKDELAY) |
2547 				sackdelay_change;
2548 		}
2549 	}
2550 
2551 	/* Note that a value of zero indicates the current setting should be
2552 	   left unchanged.
2553 	 */
2554 	if (params->spp_pathmaxrxt) {
2555 		if (trans) {
2556 			trans->pathmaxrxt = params->spp_pathmaxrxt;
2557 		} else if (asoc) {
2558 			asoc->pathmaxrxt = params->spp_pathmaxrxt;
2559 		} else {
2560 			sp->pathmaxrxt = params->spp_pathmaxrxt;
2561 		}
2562 	}
2563 
2564 	if (params->spp_flags & SPP_IPV6_FLOWLABEL) {
2565 		if (trans) {
2566 			if (trans->ipaddr.sa.sa_family == AF_INET6) {
2567 				trans->flowlabel = params->spp_ipv6_flowlabel &
2568 						   SCTP_FLOWLABEL_VAL_MASK;
2569 				trans->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2570 			}
2571 		} else if (asoc) {
2572 			struct sctp_transport *t;
2573 
2574 			list_for_each_entry(t, &asoc->peer.transport_addr_list,
2575 					    transports) {
2576 				if (t->ipaddr.sa.sa_family != AF_INET6)
2577 					continue;
2578 				t->flowlabel = params->spp_ipv6_flowlabel &
2579 					       SCTP_FLOWLABEL_VAL_MASK;
2580 				t->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2581 			}
2582 			asoc->flowlabel = params->spp_ipv6_flowlabel &
2583 					  SCTP_FLOWLABEL_VAL_MASK;
2584 			asoc->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2585 		} else if (sctp_opt2sk(sp)->sk_family == AF_INET6) {
2586 			sp->flowlabel = params->spp_ipv6_flowlabel &
2587 					SCTP_FLOWLABEL_VAL_MASK;
2588 			sp->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2589 		}
2590 	}
2591 
2592 	if (params->spp_flags & SPP_DSCP) {
2593 		if (trans) {
2594 			trans->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2595 			trans->dscp |= SCTP_DSCP_SET_MASK;
2596 		} else if (asoc) {
2597 			struct sctp_transport *t;
2598 
2599 			list_for_each_entry(t, &asoc->peer.transport_addr_list,
2600 					    transports) {
2601 				t->dscp = params->spp_dscp &
2602 					  SCTP_DSCP_VAL_MASK;
2603 				t->dscp |= SCTP_DSCP_SET_MASK;
2604 			}
2605 			asoc->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2606 			asoc->dscp |= SCTP_DSCP_SET_MASK;
2607 		} else {
2608 			sp->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2609 			sp->dscp |= SCTP_DSCP_SET_MASK;
2610 		}
2611 	}
2612 
2613 	return 0;
2614 }
2615 
sctp_setsockopt_peer_addr_params(struct sock * sk,struct sctp_paddrparams * params,unsigned int optlen)2616 static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2617 					    struct sctp_paddrparams *params,
2618 					    unsigned int optlen)
2619 {
2620 	struct sctp_transport   *trans = NULL;
2621 	struct sctp_association *asoc = NULL;
2622 	struct sctp_sock        *sp = sctp_sk(sk);
2623 	int error;
2624 	int hb_change, pmtud_change, sackdelay_change;
2625 
2626 	if (optlen == ALIGN(offsetof(struct sctp_paddrparams,
2627 					    spp_ipv6_flowlabel), 4)) {
2628 		if (params->spp_flags & (SPP_DSCP | SPP_IPV6_FLOWLABEL))
2629 			return -EINVAL;
2630 	} else if (optlen != sizeof(*params)) {
2631 		return -EINVAL;
2632 	}
2633 
2634 	/* Validate flags and value parameters. */
2635 	hb_change        = params->spp_flags & SPP_HB;
2636 	pmtud_change     = params->spp_flags & SPP_PMTUD;
2637 	sackdelay_change = params->spp_flags & SPP_SACKDELAY;
2638 
2639 	if (hb_change        == SPP_HB ||
2640 	    pmtud_change     == SPP_PMTUD ||
2641 	    sackdelay_change == SPP_SACKDELAY ||
2642 	    params->spp_sackdelay > 500 ||
2643 	    (params->spp_pathmtu &&
2644 	     params->spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2645 		return -EINVAL;
2646 
2647 	/* If an address other than INADDR_ANY is specified, and
2648 	 * no transport is found, then the request is invalid.
2649 	 */
2650 	if (!sctp_is_any(sk, (union sctp_addr *)&params->spp_address)) {
2651 		trans = sctp_addr_id2transport(sk, &params->spp_address,
2652 					       params->spp_assoc_id);
2653 		if (!trans)
2654 			return -EINVAL;
2655 	}
2656 
2657 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
2658 	 * socket is a one to many style socket, and an association
2659 	 * was not found, then the id was invalid.
2660 	 */
2661 	asoc = sctp_id2assoc(sk, params->spp_assoc_id);
2662 	if (!asoc && params->spp_assoc_id != SCTP_FUTURE_ASSOC &&
2663 	    sctp_style(sk, UDP))
2664 		return -EINVAL;
2665 
2666 	/* Heartbeat demand can only be sent on a transport or
2667 	 * association, but not a socket.
2668 	 */
2669 	if (params->spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2670 		return -EINVAL;
2671 
2672 	/* Process parameters. */
2673 	error = sctp_apply_peer_addr_params(params, trans, asoc, sp,
2674 					    hb_change, pmtud_change,
2675 					    sackdelay_change);
2676 
2677 	if (error)
2678 		return error;
2679 
2680 	/* If changes are for association, also apply parameters to each
2681 	 * transport.
2682 	 */
2683 	if (!trans && asoc) {
2684 		list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2685 				transports) {
2686 			sctp_apply_peer_addr_params(params, trans, asoc, sp,
2687 						    hb_change, pmtud_change,
2688 						    sackdelay_change);
2689 		}
2690 	}
2691 
2692 	return 0;
2693 }
2694 
sctp_spp_sackdelay_enable(__u32 param_flags)2695 static inline __u32 sctp_spp_sackdelay_enable(__u32 param_flags)
2696 {
2697 	return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_ENABLE;
2698 }
2699 
sctp_spp_sackdelay_disable(__u32 param_flags)2700 static inline __u32 sctp_spp_sackdelay_disable(__u32 param_flags)
2701 {
2702 	return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_DISABLE;
2703 }
2704 
sctp_apply_asoc_delayed_ack(struct sctp_sack_info * params,struct sctp_association * asoc)2705 static void sctp_apply_asoc_delayed_ack(struct sctp_sack_info *params,
2706 					struct sctp_association *asoc)
2707 {
2708 	struct sctp_transport *trans;
2709 
2710 	if (params->sack_delay) {
2711 		asoc->sackdelay = msecs_to_jiffies(params->sack_delay);
2712 		asoc->param_flags =
2713 			sctp_spp_sackdelay_enable(asoc->param_flags);
2714 	}
2715 	if (params->sack_freq == 1) {
2716 		asoc->param_flags =
2717 			sctp_spp_sackdelay_disable(asoc->param_flags);
2718 	} else if (params->sack_freq > 1) {
2719 		asoc->sackfreq = params->sack_freq;
2720 		asoc->param_flags =
2721 			sctp_spp_sackdelay_enable(asoc->param_flags);
2722 	}
2723 
2724 	list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2725 			    transports) {
2726 		if (params->sack_delay) {
2727 			trans->sackdelay = msecs_to_jiffies(params->sack_delay);
2728 			trans->param_flags =
2729 				sctp_spp_sackdelay_enable(trans->param_flags);
2730 		}
2731 		if (params->sack_freq == 1) {
2732 			trans->param_flags =
2733 				sctp_spp_sackdelay_disable(trans->param_flags);
2734 		} else if (params->sack_freq > 1) {
2735 			trans->sackfreq = params->sack_freq;
2736 			trans->param_flags =
2737 				sctp_spp_sackdelay_enable(trans->param_flags);
2738 		}
2739 	}
2740 }
2741 
2742 /*
2743  * 7.1.23.  Get or set delayed ack timer (SCTP_DELAYED_SACK)
2744  *
2745  * This option will effect the way delayed acks are performed.  This
2746  * option allows you to get or set the delayed ack time, in
2747  * milliseconds.  It also allows changing the delayed ack frequency.
2748  * Changing the frequency to 1 disables the delayed sack algorithm.  If
2749  * the assoc_id is 0, then this sets or gets the endpoints default
2750  * values.  If the assoc_id field is non-zero, then the set or get
2751  * effects the specified association for the one to many model (the
2752  * assoc_id field is ignored by the one to one model).  Note that if
2753  * sack_delay or sack_freq are 0 when setting this option, then the
2754  * current values will remain unchanged.
2755  *
2756  * struct sctp_sack_info {
2757  *     sctp_assoc_t            sack_assoc_id;
2758  *     uint32_t                sack_delay;
2759  *     uint32_t                sack_freq;
2760  * };
2761  *
2762  * sack_assoc_id -  This parameter, indicates which association the user
2763  *    is performing an action upon.  Note that if this field's value is
2764  *    zero then the endpoints default value is changed (effecting future
2765  *    associations only).
2766  *
2767  * sack_delay -  This parameter contains the number of milliseconds that
2768  *    the user is requesting the delayed ACK timer be set to.  Note that
2769  *    this value is defined in the standard to be between 200 and 500
2770  *    milliseconds.
2771  *
2772  * sack_freq -  This parameter contains the number of packets that must
2773  *    be received before a sack is sent without waiting for the delay
2774  *    timer to expire.  The default value for this is 2, setting this
2775  *    value to 1 will disable the delayed sack algorithm.
2776  */
__sctp_setsockopt_delayed_ack(struct sock * sk,struct sctp_sack_info * params)2777 static int __sctp_setsockopt_delayed_ack(struct sock *sk,
2778 					 struct sctp_sack_info *params)
2779 {
2780 	struct sctp_sock *sp = sctp_sk(sk);
2781 	struct sctp_association *asoc;
2782 
2783 	/* Validate value parameter. */
2784 	if (params->sack_delay > 500)
2785 		return -EINVAL;
2786 
2787 	/* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
2788 	 * socket is a one to many style socket, and an association
2789 	 * was not found, then the id was invalid.
2790 	 */
2791 	asoc = sctp_id2assoc(sk, params->sack_assoc_id);
2792 	if (!asoc && params->sack_assoc_id > SCTP_ALL_ASSOC &&
2793 	    sctp_style(sk, UDP))
2794 		return -EINVAL;
2795 
2796 	if (asoc) {
2797 		sctp_apply_asoc_delayed_ack(params, asoc);
2798 
2799 		return 0;
2800 	}
2801 
2802 	if (sctp_style(sk, TCP))
2803 		params->sack_assoc_id = SCTP_FUTURE_ASSOC;
2804 
2805 	if (params->sack_assoc_id == SCTP_FUTURE_ASSOC ||
2806 	    params->sack_assoc_id == SCTP_ALL_ASSOC) {
2807 		if (params->sack_delay) {
2808 			sp->sackdelay = params->sack_delay;
2809 			sp->param_flags =
2810 				sctp_spp_sackdelay_enable(sp->param_flags);
2811 		}
2812 		if (params->sack_freq == 1) {
2813 			sp->param_flags =
2814 				sctp_spp_sackdelay_disable(sp->param_flags);
2815 		} else if (params->sack_freq > 1) {
2816 			sp->sackfreq = params->sack_freq;
2817 			sp->param_flags =
2818 				sctp_spp_sackdelay_enable(sp->param_flags);
2819 		}
2820 	}
2821 
2822 	if (params->sack_assoc_id == SCTP_CURRENT_ASSOC ||
2823 	    params->sack_assoc_id == SCTP_ALL_ASSOC)
2824 		list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2825 			sctp_apply_asoc_delayed_ack(params, asoc);
2826 
2827 	return 0;
2828 }
2829 
sctp_setsockopt_delayed_ack(struct sock * sk,struct sctp_sack_info * params,unsigned int optlen)2830 static int sctp_setsockopt_delayed_ack(struct sock *sk,
2831 				       struct sctp_sack_info *params,
2832 				       unsigned int optlen)
2833 {
2834 	if (optlen == sizeof(struct sctp_assoc_value)) {
2835 		struct sctp_assoc_value *v = (struct sctp_assoc_value *)params;
2836 		struct sctp_sack_info p;
2837 
2838 		pr_warn_ratelimited(DEPRECATED
2839 				    "%s (pid %d) "
2840 				    "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2841 				    "Use struct sctp_sack_info instead\n",
2842 				    current->comm, task_pid_nr(current));
2843 
2844 		p.sack_assoc_id = v->assoc_id;
2845 		p.sack_delay = v->assoc_value;
2846 		p.sack_freq = v->assoc_value ? 0 : 1;
2847 		return __sctp_setsockopt_delayed_ack(sk, &p);
2848 	}
2849 
2850 	if (optlen != sizeof(struct sctp_sack_info))
2851 		return -EINVAL;
2852 	if (params->sack_delay == 0 && params->sack_freq == 0)
2853 		return 0;
2854 	return __sctp_setsockopt_delayed_ack(sk, params);
2855 }
2856 
2857 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2858  *
2859  * Applications can specify protocol parameters for the default association
2860  * initialization.  The option name argument to setsockopt() and getsockopt()
2861  * is SCTP_INITMSG.
2862  *
2863  * Setting initialization parameters is effective only on an unconnected
2864  * socket (for UDP-style sockets only future associations are effected
2865  * by the change).  With TCP-style sockets, this option is inherited by
2866  * sockets derived from a listener socket.
2867  */
sctp_setsockopt_initmsg(struct sock * sk,struct sctp_initmsg * sinit,unsigned int optlen)2868 static int sctp_setsockopt_initmsg(struct sock *sk, struct sctp_initmsg *sinit,
2869 				   unsigned int optlen)
2870 {
2871 	struct sctp_sock *sp = sctp_sk(sk);
2872 
2873 	if (optlen != sizeof(struct sctp_initmsg))
2874 		return -EINVAL;
2875 
2876 	if (sinit->sinit_num_ostreams)
2877 		sp->initmsg.sinit_num_ostreams = sinit->sinit_num_ostreams;
2878 	if (sinit->sinit_max_instreams)
2879 		sp->initmsg.sinit_max_instreams = sinit->sinit_max_instreams;
2880 	if (sinit->sinit_max_attempts)
2881 		sp->initmsg.sinit_max_attempts = sinit->sinit_max_attempts;
2882 	if (sinit->sinit_max_init_timeo)
2883 		sp->initmsg.sinit_max_init_timeo = sinit->sinit_max_init_timeo;
2884 
2885 	return 0;
2886 }
2887 
2888 /*
2889  * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2890  *
2891  *   Applications that wish to use the sendto() system call may wish to
2892  *   specify a default set of parameters that would normally be supplied
2893  *   through the inclusion of ancillary data.  This socket option allows
2894  *   such an application to set the default sctp_sndrcvinfo structure.
2895  *   The application that wishes to use this socket option simply passes
2896  *   in to this call the sctp_sndrcvinfo structure defined in Section
2897  *   5.2.2) The input parameters accepted by this call include
2898  *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2899  *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
2900  *   to this call if the caller is using the UDP model.
2901  */
sctp_setsockopt_default_send_param(struct sock * sk,struct sctp_sndrcvinfo * info,unsigned int optlen)2902 static int sctp_setsockopt_default_send_param(struct sock *sk,
2903 					      struct sctp_sndrcvinfo *info,
2904 					      unsigned int optlen)
2905 {
2906 	struct sctp_sock *sp = sctp_sk(sk);
2907 	struct sctp_association *asoc;
2908 
2909 	if (optlen != sizeof(*info))
2910 		return -EINVAL;
2911 	if (info->sinfo_flags &
2912 	    ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2913 	      SCTP_ABORT | SCTP_EOF))
2914 		return -EINVAL;
2915 
2916 	asoc = sctp_id2assoc(sk, info->sinfo_assoc_id);
2917 	if (!asoc && info->sinfo_assoc_id > SCTP_ALL_ASSOC &&
2918 	    sctp_style(sk, UDP))
2919 		return -EINVAL;
2920 
2921 	if (asoc) {
2922 		asoc->default_stream = info->sinfo_stream;
2923 		asoc->default_flags = info->sinfo_flags;
2924 		asoc->default_ppid = info->sinfo_ppid;
2925 		asoc->default_context = info->sinfo_context;
2926 		asoc->default_timetolive = info->sinfo_timetolive;
2927 
2928 		return 0;
2929 	}
2930 
2931 	if (sctp_style(sk, TCP))
2932 		info->sinfo_assoc_id = SCTP_FUTURE_ASSOC;
2933 
2934 	if (info->sinfo_assoc_id == SCTP_FUTURE_ASSOC ||
2935 	    info->sinfo_assoc_id == SCTP_ALL_ASSOC) {
2936 		sp->default_stream = info->sinfo_stream;
2937 		sp->default_flags = info->sinfo_flags;
2938 		sp->default_ppid = info->sinfo_ppid;
2939 		sp->default_context = info->sinfo_context;
2940 		sp->default_timetolive = info->sinfo_timetolive;
2941 	}
2942 
2943 	if (info->sinfo_assoc_id == SCTP_CURRENT_ASSOC ||
2944 	    info->sinfo_assoc_id == SCTP_ALL_ASSOC) {
2945 		list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
2946 			asoc->default_stream = info->sinfo_stream;
2947 			asoc->default_flags = info->sinfo_flags;
2948 			asoc->default_ppid = info->sinfo_ppid;
2949 			asoc->default_context = info->sinfo_context;
2950 			asoc->default_timetolive = info->sinfo_timetolive;
2951 		}
2952 	}
2953 
2954 	return 0;
2955 }
2956 
2957 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2958  * (SCTP_DEFAULT_SNDINFO)
2959  */
sctp_setsockopt_default_sndinfo(struct sock * sk,struct sctp_sndinfo * info,unsigned int optlen)2960 static int sctp_setsockopt_default_sndinfo(struct sock *sk,
2961 					   struct sctp_sndinfo *info,
2962 					   unsigned int optlen)
2963 {
2964 	struct sctp_sock *sp = sctp_sk(sk);
2965 	struct sctp_association *asoc;
2966 
2967 	if (optlen != sizeof(*info))
2968 		return -EINVAL;
2969 	if (info->snd_flags &
2970 	    ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2971 	      SCTP_ABORT | SCTP_EOF))
2972 		return -EINVAL;
2973 
2974 	asoc = sctp_id2assoc(sk, info->snd_assoc_id);
2975 	if (!asoc && info->snd_assoc_id > SCTP_ALL_ASSOC &&
2976 	    sctp_style(sk, UDP))
2977 		return -EINVAL;
2978 
2979 	if (asoc) {
2980 		asoc->default_stream = info->snd_sid;
2981 		asoc->default_flags = info->snd_flags;
2982 		asoc->default_ppid = info->snd_ppid;
2983 		asoc->default_context = info->snd_context;
2984 
2985 		return 0;
2986 	}
2987 
2988 	if (sctp_style(sk, TCP))
2989 		info->snd_assoc_id = SCTP_FUTURE_ASSOC;
2990 
2991 	if (info->snd_assoc_id == SCTP_FUTURE_ASSOC ||
2992 	    info->snd_assoc_id == SCTP_ALL_ASSOC) {
2993 		sp->default_stream = info->snd_sid;
2994 		sp->default_flags = info->snd_flags;
2995 		sp->default_ppid = info->snd_ppid;
2996 		sp->default_context = info->snd_context;
2997 	}
2998 
2999 	if (info->snd_assoc_id == SCTP_CURRENT_ASSOC ||
3000 	    info->snd_assoc_id == SCTP_ALL_ASSOC) {
3001 		list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
3002 			asoc->default_stream = info->snd_sid;
3003 			asoc->default_flags = info->snd_flags;
3004 			asoc->default_ppid = info->snd_ppid;
3005 			asoc->default_context = info->snd_context;
3006 		}
3007 	}
3008 
3009 	return 0;
3010 }
3011 
3012 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
3013  *
3014  * Requests that the local SCTP stack use the enclosed peer address as
3015  * the association primary.  The enclosed address must be one of the
3016  * association peer's addresses.
3017  */
sctp_setsockopt_primary_addr(struct sock * sk,struct sctp_prim * prim,unsigned int optlen)3018 static int sctp_setsockopt_primary_addr(struct sock *sk, struct sctp_prim *prim,
3019 					unsigned int optlen)
3020 {
3021 	struct sctp_transport *trans;
3022 	struct sctp_af *af;
3023 	int err;
3024 
3025 	if (optlen != sizeof(struct sctp_prim))
3026 		return -EINVAL;
3027 
3028 	/* Allow security module to validate address but need address len. */
3029 	af = sctp_get_af_specific(prim->ssp_addr.ss_family);
3030 	if (!af)
3031 		return -EINVAL;
3032 
3033 	err = security_sctp_bind_connect(sk, SCTP_PRIMARY_ADDR,
3034 					 (struct sockaddr *)&prim->ssp_addr,
3035 					 af->sockaddr_len);
3036 	if (err)
3037 		return err;
3038 
3039 	trans = sctp_addr_id2transport(sk, &prim->ssp_addr, prim->ssp_assoc_id);
3040 	if (!trans)
3041 		return -EINVAL;
3042 
3043 	sctp_assoc_set_primary(trans->asoc, trans);
3044 
3045 	return 0;
3046 }
3047 
3048 /*
3049  * 7.1.5 SCTP_NODELAY
3050  *
3051  * Turn on/off any Nagle-like algorithm.  This means that packets are
3052  * generally sent as soon as possible and no unnecessary delays are
3053  * introduced, at the cost of more packets in the network.  Expects an
3054  *  integer boolean flag.
3055  */
sctp_setsockopt_nodelay(struct sock * sk,int * val,unsigned int optlen)3056 static int sctp_setsockopt_nodelay(struct sock *sk, int *val,
3057 				   unsigned int optlen)
3058 {
3059 	if (optlen < sizeof(int))
3060 		return -EINVAL;
3061 	sctp_sk(sk)->nodelay = (*val == 0) ? 0 : 1;
3062 	return 0;
3063 }
3064 
3065 /*
3066  *
3067  * 7.1.1 SCTP_RTOINFO
3068  *
3069  * The protocol parameters used to initialize and bound retransmission
3070  * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3071  * and modify these parameters.
3072  * All parameters are time values, in milliseconds.  A value of 0, when
3073  * modifying the parameters, indicates that the current value should not
3074  * be changed.
3075  *
3076  */
sctp_setsockopt_rtoinfo(struct sock * sk,struct sctp_rtoinfo * rtoinfo,unsigned int optlen)3077 static int sctp_setsockopt_rtoinfo(struct sock *sk,
3078 				   struct sctp_rtoinfo *rtoinfo,
3079 				   unsigned int optlen)
3080 {
3081 	struct sctp_association *asoc;
3082 	unsigned long rto_min, rto_max;
3083 	struct sctp_sock *sp = sctp_sk(sk);
3084 
3085 	if (optlen != sizeof (struct sctp_rtoinfo))
3086 		return -EINVAL;
3087 
3088 	asoc = sctp_id2assoc(sk, rtoinfo->srto_assoc_id);
3089 
3090 	/* Set the values to the specific association */
3091 	if (!asoc && rtoinfo->srto_assoc_id != SCTP_FUTURE_ASSOC &&
3092 	    sctp_style(sk, UDP))
3093 		return -EINVAL;
3094 
3095 	rto_max = rtoinfo->srto_max;
3096 	rto_min = rtoinfo->srto_min;
3097 
3098 	if (rto_max)
3099 		rto_max = asoc ? msecs_to_jiffies(rto_max) : rto_max;
3100 	else
3101 		rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
3102 
3103 	if (rto_min)
3104 		rto_min = asoc ? msecs_to_jiffies(rto_min) : rto_min;
3105 	else
3106 		rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
3107 
3108 	if (rto_min > rto_max)
3109 		return -EINVAL;
3110 
3111 	if (asoc) {
3112 		if (rtoinfo->srto_initial != 0)
3113 			asoc->rto_initial =
3114 				msecs_to_jiffies(rtoinfo->srto_initial);
3115 		asoc->rto_max = rto_max;
3116 		asoc->rto_min = rto_min;
3117 	} else {
3118 		/* If there is no association or the association-id = 0
3119 		 * set the values to the endpoint.
3120 		 */
3121 		if (rtoinfo->srto_initial != 0)
3122 			sp->rtoinfo.srto_initial = rtoinfo->srto_initial;
3123 		sp->rtoinfo.srto_max = rto_max;
3124 		sp->rtoinfo.srto_min = rto_min;
3125 	}
3126 
3127 	return 0;
3128 }
3129 
3130 /*
3131  *
3132  * 7.1.2 SCTP_ASSOCINFO
3133  *
3134  * This option is used to tune the maximum retransmission attempts
3135  * of the association.
3136  * Returns an error if the new association retransmission value is
3137  * greater than the sum of the retransmission value  of the peer.
3138  * See [SCTP] for more information.
3139  *
3140  */
sctp_setsockopt_associnfo(struct sock * sk,struct sctp_assocparams * assocparams,unsigned int optlen)3141 static int sctp_setsockopt_associnfo(struct sock *sk,
3142 				     struct sctp_assocparams *assocparams,
3143 				     unsigned int optlen)
3144 {
3145 
3146 	struct sctp_association *asoc;
3147 
3148 	if (optlen != sizeof(struct sctp_assocparams))
3149 		return -EINVAL;
3150 
3151 	asoc = sctp_id2assoc(sk, assocparams->sasoc_assoc_id);
3152 
3153 	if (!asoc && assocparams->sasoc_assoc_id != SCTP_FUTURE_ASSOC &&
3154 	    sctp_style(sk, UDP))
3155 		return -EINVAL;
3156 
3157 	/* Set the values to the specific association */
3158 	if (asoc) {
3159 		if (assocparams->sasoc_asocmaxrxt != 0) {
3160 			__u32 path_sum = 0;
3161 			int   paths = 0;
3162 			struct sctp_transport *peer_addr;
3163 
3164 			list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
3165 					transports) {
3166 				path_sum += peer_addr->pathmaxrxt;
3167 				paths++;
3168 			}
3169 
3170 			/* Only validate asocmaxrxt if we have more than
3171 			 * one path/transport.  We do this because path
3172 			 * retransmissions are only counted when we have more
3173 			 * then one path.
3174 			 */
3175 			if (paths > 1 &&
3176 			    assocparams->sasoc_asocmaxrxt > path_sum)
3177 				return -EINVAL;
3178 
3179 			asoc->max_retrans = assocparams->sasoc_asocmaxrxt;
3180 		}
3181 
3182 		if (assocparams->sasoc_cookie_life != 0)
3183 			asoc->cookie_life =
3184 				ms_to_ktime(assocparams->sasoc_cookie_life);
3185 	} else {
3186 		/* Set the values to the endpoint */
3187 		struct sctp_sock *sp = sctp_sk(sk);
3188 
3189 		if (assocparams->sasoc_asocmaxrxt != 0)
3190 			sp->assocparams.sasoc_asocmaxrxt =
3191 						assocparams->sasoc_asocmaxrxt;
3192 		if (assocparams->sasoc_cookie_life != 0)
3193 			sp->assocparams.sasoc_cookie_life =
3194 						assocparams->sasoc_cookie_life;
3195 	}
3196 	return 0;
3197 }
3198 
3199 /*
3200  * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3201  *
3202  * This socket option is a boolean flag which turns on or off mapped V4
3203  * addresses.  If this option is turned on and the socket is type
3204  * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3205  * If this option is turned off, then no mapping will be done of V4
3206  * addresses and a user will receive both PF_INET6 and PF_INET type
3207  * addresses on the socket.
3208  */
sctp_setsockopt_mappedv4(struct sock * sk,int * val,unsigned int optlen)3209 static int sctp_setsockopt_mappedv4(struct sock *sk, int *val,
3210 				    unsigned int optlen)
3211 {
3212 	struct sctp_sock *sp = sctp_sk(sk);
3213 
3214 	if (optlen < sizeof(int))
3215 		return -EINVAL;
3216 	if (*val)
3217 		sp->v4mapped = 1;
3218 	else
3219 		sp->v4mapped = 0;
3220 
3221 	return 0;
3222 }
3223 
3224 /*
3225  * 8.1.16.  Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3226  * This option will get or set the maximum size to put in any outgoing
3227  * SCTP DATA chunk.  If a message is larger than this size it will be
3228  * fragmented by SCTP into the specified size.  Note that the underlying
3229  * SCTP implementation may fragment into smaller sized chunks when the
3230  * PMTU of the underlying association is smaller than the value set by
3231  * the user.  The default value for this option is '0' which indicates
3232  * the user is NOT limiting fragmentation and only the PMTU will effect
3233  * SCTP's choice of DATA chunk size.  Note also that values set larger
3234  * than the maximum size of an IP datagram will effectively let SCTP
3235  * control fragmentation (i.e. the same as setting this option to 0).
3236  *
3237  * The following structure is used to access and modify this parameter:
3238  *
3239  * struct sctp_assoc_value {
3240  *   sctp_assoc_t assoc_id;
3241  *   uint32_t assoc_value;
3242  * };
3243  *
3244  * assoc_id:  This parameter is ignored for one-to-one style sockets.
3245  *    For one-to-many style sockets this parameter indicates which
3246  *    association the user is performing an action upon.  Note that if
3247  *    this field's value is zero then the endpoints default value is
3248  *    changed (effecting future associations only).
3249  * assoc_value:  This parameter specifies the maximum size in bytes.
3250  */
sctp_setsockopt_maxseg(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)3251 static int sctp_setsockopt_maxseg(struct sock *sk,
3252 				  struct sctp_assoc_value *params,
3253 				  unsigned int optlen)
3254 {
3255 	struct sctp_sock *sp = sctp_sk(sk);
3256 	struct sctp_association *asoc;
3257 	sctp_assoc_t assoc_id;
3258 	int val;
3259 
3260 	if (optlen == sizeof(int)) {
3261 		pr_warn_ratelimited(DEPRECATED
3262 				    "%s (pid %d) "
3263 				    "Use of int in maxseg socket option.\n"
3264 				    "Use struct sctp_assoc_value instead\n",
3265 				    current->comm, task_pid_nr(current));
3266 		assoc_id = SCTP_FUTURE_ASSOC;
3267 		val = *(int *)params;
3268 	} else if (optlen == sizeof(struct sctp_assoc_value)) {
3269 		assoc_id = params->assoc_id;
3270 		val = params->assoc_value;
3271 	} else {
3272 		return -EINVAL;
3273 	}
3274 
3275 	asoc = sctp_id2assoc(sk, assoc_id);
3276 	if (!asoc && assoc_id != SCTP_FUTURE_ASSOC &&
3277 	    sctp_style(sk, UDP))
3278 		return -EINVAL;
3279 
3280 	if (val) {
3281 		int min_len, max_len;
3282 		__u16 datasize = asoc ? sctp_datachk_len(&asoc->stream) :
3283 				 sizeof(struct sctp_data_chunk);
3284 
3285 		min_len = sctp_min_frag_point(sp, datasize);
3286 		max_len = SCTP_MAX_CHUNK_LEN - datasize;
3287 
3288 		if (val < min_len || val > max_len)
3289 			return -EINVAL;
3290 	}
3291 
3292 	if (asoc) {
3293 		asoc->user_frag = val;
3294 		sctp_assoc_update_frag_point(asoc);
3295 	} else {
3296 		sp->user_frag = val;
3297 	}
3298 
3299 	return 0;
3300 }
3301 
3302 
3303 /*
3304  *  7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3305  *
3306  *   Requests that the peer mark the enclosed address as the association
3307  *   primary. The enclosed address must be one of the association's
3308  *   locally bound addresses. The following structure is used to make a
3309  *   set primary request:
3310  */
sctp_setsockopt_peer_primary_addr(struct sock * sk,struct sctp_setpeerprim * prim,unsigned int optlen)3311 static int sctp_setsockopt_peer_primary_addr(struct sock *sk,
3312 					     struct sctp_setpeerprim *prim,
3313 					     unsigned int optlen)
3314 {
3315 	struct sctp_sock	*sp;
3316 	struct sctp_association	*asoc = NULL;
3317 	struct sctp_chunk	*chunk;
3318 	struct sctp_af		*af;
3319 	int 			err;
3320 
3321 	sp = sctp_sk(sk);
3322 
3323 	if (!sp->ep->asconf_enable)
3324 		return -EPERM;
3325 
3326 	if (optlen != sizeof(struct sctp_setpeerprim))
3327 		return -EINVAL;
3328 
3329 	asoc = sctp_id2assoc(sk, prim->sspp_assoc_id);
3330 	if (!asoc)
3331 		return -EINVAL;
3332 
3333 	if (!asoc->peer.asconf_capable)
3334 		return -EPERM;
3335 
3336 	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3337 		return -EPERM;
3338 
3339 	if (!sctp_state(asoc, ESTABLISHED))
3340 		return -ENOTCONN;
3341 
3342 	af = sctp_get_af_specific(prim->sspp_addr.ss_family);
3343 	if (!af)
3344 		return -EINVAL;
3345 
3346 	if (!af->addr_valid((union sctp_addr *)&prim->sspp_addr, sp, NULL))
3347 		return -EADDRNOTAVAIL;
3348 
3349 	if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim->sspp_addr))
3350 		return -EADDRNOTAVAIL;
3351 
3352 	/* Allow security module to validate address. */
3353 	err = security_sctp_bind_connect(sk, SCTP_SET_PEER_PRIMARY_ADDR,
3354 					 (struct sockaddr *)&prim->sspp_addr,
3355 					 af->sockaddr_len);
3356 	if (err)
3357 		return err;
3358 
3359 	/* Create an ASCONF chunk with SET_PRIMARY parameter	*/
3360 	chunk = sctp_make_asconf_set_prim(asoc,
3361 					  (union sctp_addr *)&prim->sspp_addr);
3362 	if (!chunk)
3363 		return -ENOMEM;
3364 
3365 	err = sctp_send_asconf(asoc, chunk);
3366 
3367 	pr_debug("%s: we set peer primary addr primitively\n", __func__);
3368 
3369 	return err;
3370 }
3371 
sctp_setsockopt_adaptation_layer(struct sock * sk,struct sctp_setadaptation * adapt,unsigned int optlen)3372 static int sctp_setsockopt_adaptation_layer(struct sock *sk,
3373 					    struct sctp_setadaptation *adapt,
3374 					    unsigned int optlen)
3375 {
3376 	if (optlen != sizeof(struct sctp_setadaptation))
3377 		return -EINVAL;
3378 
3379 	sctp_sk(sk)->adaptation_ind = adapt->ssb_adaptation_ind;
3380 
3381 	return 0;
3382 }
3383 
3384 /*
3385  * 7.1.29.  Set or Get the default context (SCTP_CONTEXT)
3386  *
3387  * The context field in the sctp_sndrcvinfo structure is normally only
3388  * used when a failed message is retrieved holding the value that was
3389  * sent down on the actual send call.  This option allows the setting of
3390  * a default context on an association basis that will be received on
3391  * reading messages from the peer.  This is especially helpful in the
3392  * one-2-many model for an application to keep some reference to an
3393  * internal state machine that is processing messages on the
3394  * association.  Note that the setting of this value only effects
3395  * received messages from the peer and does not effect the value that is
3396  * saved with outbound messages.
3397  */
sctp_setsockopt_context(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)3398 static int sctp_setsockopt_context(struct sock *sk,
3399 				   struct sctp_assoc_value *params,
3400 				   unsigned int optlen)
3401 {
3402 	struct sctp_sock *sp = sctp_sk(sk);
3403 	struct sctp_association *asoc;
3404 
3405 	if (optlen != sizeof(struct sctp_assoc_value))
3406 		return -EINVAL;
3407 
3408 	asoc = sctp_id2assoc(sk, params->assoc_id);
3409 	if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
3410 	    sctp_style(sk, UDP))
3411 		return -EINVAL;
3412 
3413 	if (asoc) {
3414 		asoc->default_rcv_context = params->assoc_value;
3415 
3416 		return 0;
3417 	}
3418 
3419 	if (sctp_style(sk, TCP))
3420 		params->assoc_id = SCTP_FUTURE_ASSOC;
3421 
3422 	if (params->assoc_id == SCTP_FUTURE_ASSOC ||
3423 	    params->assoc_id == SCTP_ALL_ASSOC)
3424 		sp->default_rcv_context = params->assoc_value;
3425 
3426 	if (params->assoc_id == SCTP_CURRENT_ASSOC ||
3427 	    params->assoc_id == SCTP_ALL_ASSOC)
3428 		list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3429 			asoc->default_rcv_context = params->assoc_value;
3430 
3431 	return 0;
3432 }
3433 
3434 /*
3435  * 7.1.24.  Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3436  *
3437  * This options will at a minimum specify if the implementation is doing
3438  * fragmented interleave.  Fragmented interleave, for a one to many
3439  * socket, is when subsequent calls to receive a message may return
3440  * parts of messages from different associations.  Some implementations
3441  * may allow you to turn this value on or off.  If so, when turned off,
3442  * no fragment interleave will occur (which will cause a head of line
3443  * blocking amongst multiple associations sharing the same one to many
3444  * socket).  When this option is turned on, then each receive call may
3445  * come from a different association (thus the user must receive data
3446  * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3447  * association each receive belongs to.
3448  *
3449  * This option takes a boolean value.  A non-zero value indicates that
3450  * fragmented interleave is on.  A value of zero indicates that
3451  * fragmented interleave is off.
3452  *
3453  * Note that it is important that an implementation that allows this
3454  * option to be turned on, have it off by default.  Otherwise an unaware
3455  * application using the one to many model may become confused and act
3456  * incorrectly.
3457  */
sctp_setsockopt_fragment_interleave(struct sock * sk,int * val,unsigned int optlen)3458 static int sctp_setsockopt_fragment_interleave(struct sock *sk, int *val,
3459 					       unsigned int optlen)
3460 {
3461 	if (optlen != sizeof(int))
3462 		return -EINVAL;
3463 
3464 	sctp_sk(sk)->frag_interleave = !!*val;
3465 
3466 	if (!sctp_sk(sk)->frag_interleave)
3467 		sctp_sk(sk)->ep->intl_enable = 0;
3468 
3469 	return 0;
3470 }
3471 
3472 /*
3473  * 8.1.21.  Set or Get the SCTP Partial Delivery Point
3474  *       (SCTP_PARTIAL_DELIVERY_POINT)
3475  *
3476  * This option will set or get the SCTP partial delivery point.  This
3477  * point is the size of a message where the partial delivery API will be
3478  * invoked to help free up rwnd space for the peer.  Setting this to a
3479  * lower value will cause partial deliveries to happen more often.  The
3480  * calls argument is an integer that sets or gets the partial delivery
3481  * point.  Note also that the call will fail if the user attempts to set
3482  * this value larger than the socket receive buffer size.
3483  *
3484  * Note that any single message having a length smaller than or equal to
3485  * the SCTP partial delivery point will be delivered in one single read
3486  * call as long as the user provided buffer is large enough to hold the
3487  * message.
3488  */
sctp_setsockopt_partial_delivery_point(struct sock * sk,u32 * val,unsigned int optlen)3489 static int sctp_setsockopt_partial_delivery_point(struct sock *sk, u32 *val,
3490 						  unsigned int optlen)
3491 {
3492 	if (optlen != sizeof(u32))
3493 		return -EINVAL;
3494 
3495 	/* Note: We double the receive buffer from what the user sets
3496 	 * it to be, also initial rwnd is based on rcvbuf/2.
3497 	 */
3498 	if (*val > (sk->sk_rcvbuf >> 1))
3499 		return -EINVAL;
3500 
3501 	sctp_sk(sk)->pd_point = *val;
3502 
3503 	return 0; /* is this the right error code? */
3504 }
3505 
3506 /*
3507  * 7.1.28.  Set or Get the maximum burst (SCTP_MAX_BURST)
3508  *
3509  * This option will allow a user to change the maximum burst of packets
3510  * that can be emitted by this association.  Note that the default value
3511  * is 4, and some implementations may restrict this setting so that it
3512  * can only be lowered.
3513  *
3514  * NOTE: This text doesn't seem right.  Do this on a socket basis with
3515  * future associations inheriting the socket value.
3516  */
sctp_setsockopt_maxburst(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)3517 static int sctp_setsockopt_maxburst(struct sock *sk,
3518 				    struct sctp_assoc_value *params,
3519 				    unsigned int optlen)
3520 {
3521 	struct sctp_sock *sp = sctp_sk(sk);
3522 	struct sctp_association *asoc;
3523 	sctp_assoc_t assoc_id;
3524 	u32 assoc_value;
3525 
3526 	if (optlen == sizeof(int)) {
3527 		pr_warn_ratelimited(DEPRECATED
3528 				    "%s (pid %d) "
3529 				    "Use of int in max_burst socket option deprecated.\n"
3530 				    "Use struct sctp_assoc_value instead\n",
3531 				    current->comm, task_pid_nr(current));
3532 		assoc_id = SCTP_FUTURE_ASSOC;
3533 		assoc_value = *((int *)params);
3534 	} else if (optlen == sizeof(struct sctp_assoc_value)) {
3535 		assoc_id = params->assoc_id;
3536 		assoc_value = params->assoc_value;
3537 	} else
3538 		return -EINVAL;
3539 
3540 	asoc = sctp_id2assoc(sk, assoc_id);
3541 	if (!asoc && assoc_id > SCTP_ALL_ASSOC && sctp_style(sk, UDP))
3542 		return -EINVAL;
3543 
3544 	if (asoc) {
3545 		asoc->max_burst = assoc_value;
3546 
3547 		return 0;
3548 	}
3549 
3550 	if (sctp_style(sk, TCP))
3551 		assoc_id = SCTP_FUTURE_ASSOC;
3552 
3553 	if (assoc_id == SCTP_FUTURE_ASSOC || assoc_id == SCTP_ALL_ASSOC)
3554 		sp->max_burst = assoc_value;
3555 
3556 	if (assoc_id == SCTP_CURRENT_ASSOC || assoc_id == SCTP_ALL_ASSOC)
3557 		list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3558 			asoc->max_burst = assoc_value;
3559 
3560 	return 0;
3561 }
3562 
3563 /*
3564  * 7.1.18.  Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3565  *
3566  * This set option adds a chunk type that the user is requesting to be
3567  * received only in an authenticated way.  Changes to the list of chunks
3568  * will only effect future associations on the socket.
3569  */
sctp_setsockopt_auth_chunk(struct sock * sk,struct sctp_authchunk * val,unsigned int optlen)3570 static int sctp_setsockopt_auth_chunk(struct sock *sk,
3571 				      struct sctp_authchunk *val,
3572 				      unsigned int optlen)
3573 {
3574 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3575 
3576 	if (!ep->auth_enable)
3577 		return -EACCES;
3578 
3579 	if (optlen != sizeof(struct sctp_authchunk))
3580 		return -EINVAL;
3581 
3582 	switch (val->sauth_chunk) {
3583 	case SCTP_CID_INIT:
3584 	case SCTP_CID_INIT_ACK:
3585 	case SCTP_CID_SHUTDOWN_COMPLETE:
3586 	case SCTP_CID_AUTH:
3587 		return -EINVAL;
3588 	}
3589 
3590 	/* add this chunk id to the endpoint */
3591 	return sctp_auth_ep_add_chunkid(ep, val->sauth_chunk);
3592 }
3593 
3594 /*
3595  * 7.1.19.  Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3596  *
3597  * This option gets or sets the list of HMAC algorithms that the local
3598  * endpoint requires the peer to use.
3599  */
sctp_setsockopt_hmac_ident(struct sock * sk,struct sctp_hmacalgo * hmacs,unsigned int optlen)3600 static int sctp_setsockopt_hmac_ident(struct sock *sk,
3601 				      struct sctp_hmacalgo *hmacs,
3602 				      unsigned int optlen)
3603 {
3604 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3605 	u32 idents;
3606 
3607 	if (!ep->auth_enable)
3608 		return -EACCES;
3609 
3610 	if (optlen < sizeof(struct sctp_hmacalgo))
3611 		return -EINVAL;
3612 	optlen = min_t(unsigned int, optlen, sizeof(struct sctp_hmacalgo) +
3613 					     SCTP_AUTH_NUM_HMACS * sizeof(u16));
3614 
3615 	idents = hmacs->shmac_num_idents;
3616 	if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS ||
3617 	    (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo)))
3618 		return -EINVAL;
3619 
3620 	return sctp_auth_ep_set_hmacs(ep, hmacs);
3621 }
3622 
3623 /*
3624  * 7.1.20.  Set a shared key (SCTP_AUTH_KEY)
3625  *
3626  * This option will set a shared secret key which is used to build an
3627  * association shared key.
3628  */
sctp_setsockopt_auth_key(struct sock * sk,struct sctp_authkey * authkey,unsigned int optlen)3629 static int sctp_setsockopt_auth_key(struct sock *sk,
3630 				    struct sctp_authkey *authkey,
3631 				    unsigned int optlen)
3632 {
3633 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3634 	struct sctp_association *asoc;
3635 	int ret = -EINVAL;
3636 
3637 	if (optlen <= sizeof(struct sctp_authkey))
3638 		return -EINVAL;
3639 	/* authkey->sca_keylength is u16, so optlen can't be bigger than
3640 	 * this.
3641 	 */
3642 	optlen = min_t(unsigned int, optlen, USHRT_MAX + sizeof(*authkey));
3643 
3644 	if (authkey->sca_keylength > optlen - sizeof(*authkey))
3645 		goto out;
3646 
3647 	asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3648 	if (!asoc && authkey->sca_assoc_id > SCTP_ALL_ASSOC &&
3649 	    sctp_style(sk, UDP))
3650 		goto out;
3651 
3652 	if (asoc) {
3653 		ret = sctp_auth_set_key(ep, asoc, authkey);
3654 		goto out;
3655 	}
3656 
3657 	if (sctp_style(sk, TCP))
3658 		authkey->sca_assoc_id = SCTP_FUTURE_ASSOC;
3659 
3660 	if (authkey->sca_assoc_id == SCTP_FUTURE_ASSOC ||
3661 	    authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3662 		ret = sctp_auth_set_key(ep, asoc, authkey);
3663 		if (ret)
3664 			goto out;
3665 	}
3666 
3667 	ret = 0;
3668 
3669 	if (authkey->sca_assoc_id == SCTP_CURRENT_ASSOC ||
3670 	    authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3671 		list_for_each_entry(asoc, &ep->asocs, asocs) {
3672 			int res = sctp_auth_set_key(ep, asoc, authkey);
3673 
3674 			if (res && !ret)
3675 				ret = res;
3676 		}
3677 	}
3678 
3679 out:
3680 	memzero_explicit(authkey, optlen);
3681 	return ret;
3682 }
3683 
3684 /*
3685  * 7.1.21.  Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3686  *
3687  * This option will get or set the active shared key to be used to build
3688  * the association shared key.
3689  */
sctp_setsockopt_active_key(struct sock * sk,struct sctp_authkeyid * val,unsigned int optlen)3690 static int sctp_setsockopt_active_key(struct sock *sk,
3691 				      struct sctp_authkeyid *val,
3692 				      unsigned int optlen)
3693 {
3694 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3695 	struct sctp_association *asoc;
3696 	int ret = 0;
3697 
3698 	if (optlen != sizeof(struct sctp_authkeyid))
3699 		return -EINVAL;
3700 
3701 	asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3702 	if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3703 	    sctp_style(sk, UDP))
3704 		return -EINVAL;
3705 
3706 	if (asoc)
3707 		return sctp_auth_set_active_key(ep, asoc, val->scact_keynumber);
3708 
3709 	if (sctp_style(sk, TCP))
3710 		val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3711 
3712 	if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3713 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3714 		ret = sctp_auth_set_active_key(ep, asoc, val->scact_keynumber);
3715 		if (ret)
3716 			return ret;
3717 	}
3718 
3719 	if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3720 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3721 		list_for_each_entry(asoc, &ep->asocs, asocs) {
3722 			int res = sctp_auth_set_active_key(ep, asoc,
3723 							   val->scact_keynumber);
3724 
3725 			if (res && !ret)
3726 				ret = res;
3727 		}
3728 	}
3729 
3730 	return ret;
3731 }
3732 
3733 /*
3734  * 7.1.22.  Delete a shared key (SCTP_AUTH_DELETE_KEY)
3735  *
3736  * This set option will delete a shared secret key from use.
3737  */
sctp_setsockopt_del_key(struct sock * sk,struct sctp_authkeyid * val,unsigned int optlen)3738 static int sctp_setsockopt_del_key(struct sock *sk,
3739 				   struct sctp_authkeyid *val,
3740 				   unsigned int optlen)
3741 {
3742 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3743 	struct sctp_association *asoc;
3744 	int ret = 0;
3745 
3746 	if (optlen != sizeof(struct sctp_authkeyid))
3747 		return -EINVAL;
3748 
3749 	asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3750 	if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3751 	    sctp_style(sk, UDP))
3752 		return -EINVAL;
3753 
3754 	if (asoc)
3755 		return sctp_auth_del_key_id(ep, asoc, val->scact_keynumber);
3756 
3757 	if (sctp_style(sk, TCP))
3758 		val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3759 
3760 	if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3761 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3762 		ret = sctp_auth_del_key_id(ep, asoc, val->scact_keynumber);
3763 		if (ret)
3764 			return ret;
3765 	}
3766 
3767 	if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3768 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3769 		list_for_each_entry(asoc, &ep->asocs, asocs) {
3770 			int res = sctp_auth_del_key_id(ep, asoc,
3771 						       val->scact_keynumber);
3772 
3773 			if (res && !ret)
3774 				ret = res;
3775 		}
3776 	}
3777 
3778 	return ret;
3779 }
3780 
3781 /*
3782  * 8.3.4  Deactivate a Shared Key (SCTP_AUTH_DEACTIVATE_KEY)
3783  *
3784  * This set option will deactivate a shared secret key.
3785  */
sctp_setsockopt_deactivate_key(struct sock * sk,struct sctp_authkeyid * val,unsigned int optlen)3786 static int sctp_setsockopt_deactivate_key(struct sock *sk,
3787 					  struct sctp_authkeyid *val,
3788 					  unsigned int optlen)
3789 {
3790 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3791 	struct sctp_association *asoc;
3792 	int ret = 0;
3793 
3794 	if (optlen != sizeof(struct sctp_authkeyid))
3795 		return -EINVAL;
3796 
3797 	asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3798 	if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3799 	    sctp_style(sk, UDP))
3800 		return -EINVAL;
3801 
3802 	if (asoc)
3803 		return sctp_auth_deact_key_id(ep, asoc, val->scact_keynumber);
3804 
3805 	if (sctp_style(sk, TCP))
3806 		val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3807 
3808 	if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3809 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3810 		ret = sctp_auth_deact_key_id(ep, asoc, val->scact_keynumber);
3811 		if (ret)
3812 			return ret;
3813 	}
3814 
3815 	if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3816 	    val->scact_assoc_id == SCTP_ALL_ASSOC) {
3817 		list_for_each_entry(asoc, &ep->asocs, asocs) {
3818 			int res = sctp_auth_deact_key_id(ep, asoc,
3819 							 val->scact_keynumber);
3820 
3821 			if (res && !ret)
3822 				ret = res;
3823 		}
3824 	}
3825 
3826 	return ret;
3827 }
3828 
3829 /*
3830  * 8.1.23 SCTP_AUTO_ASCONF
3831  *
3832  * This option will enable or disable the use of the automatic generation of
3833  * ASCONF chunks to add and delete addresses to an existing association.  Note
3834  * that this option has two caveats namely: a) it only affects sockets that
3835  * are bound to all addresses available to the SCTP stack, and b) the system
3836  * administrator may have an overriding control that turns the ASCONF feature
3837  * off no matter what setting the socket option may have.
3838  * This option expects an integer boolean flag, where a non-zero value turns on
3839  * the option, and a zero value turns off the option.
3840  * Note. In this implementation, socket operation overrides default parameter
3841  * being set by sysctl as well as FreeBSD implementation
3842  */
sctp_setsockopt_auto_asconf(struct sock * sk,int * val,unsigned int optlen)3843 static int sctp_setsockopt_auto_asconf(struct sock *sk, int *val,
3844 					unsigned int optlen)
3845 {
3846 	struct sctp_sock *sp = sctp_sk(sk);
3847 
3848 	if (optlen < sizeof(int))
3849 		return -EINVAL;
3850 	if (!sctp_is_ep_boundall(sk) && *val)
3851 		return -EINVAL;
3852 	if ((*val && sp->do_auto_asconf) || (!*val && !sp->do_auto_asconf))
3853 		return 0;
3854 
3855 	spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3856 	if (*val == 0 && sp->do_auto_asconf) {
3857 		list_del(&sp->auto_asconf_list);
3858 		sp->do_auto_asconf = 0;
3859 	} else if (*val && !sp->do_auto_asconf) {
3860 		list_add_tail(&sp->auto_asconf_list,
3861 		    &sock_net(sk)->sctp.auto_asconf_splist);
3862 		sp->do_auto_asconf = 1;
3863 	}
3864 	spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3865 	return 0;
3866 }
3867 
3868 /*
3869  * SCTP_PEER_ADDR_THLDS
3870  *
3871  * This option allows us to alter the partially failed threshold for one or all
3872  * transports in an association.  See Section 6.1 of:
3873  * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3874  */
sctp_setsockopt_paddr_thresholds(struct sock * sk,struct sctp_paddrthlds_v2 * val,unsigned int optlen,bool v2)3875 static int sctp_setsockopt_paddr_thresholds(struct sock *sk,
3876 					    struct sctp_paddrthlds_v2 *val,
3877 					    unsigned int optlen, bool v2)
3878 {
3879 	struct sctp_transport *trans;
3880 	struct sctp_association *asoc;
3881 	int len;
3882 
3883 	len = v2 ? sizeof(*val) : sizeof(struct sctp_paddrthlds);
3884 	if (optlen < len)
3885 		return -EINVAL;
3886 
3887 	if (v2 && val->spt_pathpfthld > val->spt_pathcpthld)
3888 		return -EINVAL;
3889 
3890 	if (!sctp_is_any(sk, (const union sctp_addr *)&val->spt_address)) {
3891 		trans = sctp_addr_id2transport(sk, &val->spt_address,
3892 					       val->spt_assoc_id);
3893 		if (!trans)
3894 			return -ENOENT;
3895 
3896 		if (val->spt_pathmaxrxt)
3897 			trans->pathmaxrxt = val->spt_pathmaxrxt;
3898 		if (v2)
3899 			trans->ps_retrans = val->spt_pathcpthld;
3900 		trans->pf_retrans = val->spt_pathpfthld;
3901 
3902 		return 0;
3903 	}
3904 
3905 	asoc = sctp_id2assoc(sk, val->spt_assoc_id);
3906 	if (!asoc && val->spt_assoc_id != SCTP_FUTURE_ASSOC &&
3907 	    sctp_style(sk, UDP))
3908 		return -EINVAL;
3909 
3910 	if (asoc) {
3911 		list_for_each_entry(trans, &asoc->peer.transport_addr_list,
3912 				    transports) {
3913 			if (val->spt_pathmaxrxt)
3914 				trans->pathmaxrxt = val->spt_pathmaxrxt;
3915 			if (v2)
3916 				trans->ps_retrans = val->spt_pathcpthld;
3917 			trans->pf_retrans = val->spt_pathpfthld;
3918 		}
3919 
3920 		if (val->spt_pathmaxrxt)
3921 			asoc->pathmaxrxt = val->spt_pathmaxrxt;
3922 		if (v2)
3923 			asoc->ps_retrans = val->spt_pathcpthld;
3924 		asoc->pf_retrans = val->spt_pathpfthld;
3925 	} else {
3926 		struct sctp_sock *sp = sctp_sk(sk);
3927 
3928 		if (val->spt_pathmaxrxt)
3929 			sp->pathmaxrxt = val->spt_pathmaxrxt;
3930 		if (v2)
3931 			sp->ps_retrans = val->spt_pathcpthld;
3932 		sp->pf_retrans = val->spt_pathpfthld;
3933 	}
3934 
3935 	return 0;
3936 }
3937 
sctp_setsockopt_recvrcvinfo(struct sock * sk,int * val,unsigned int optlen)3938 static int sctp_setsockopt_recvrcvinfo(struct sock *sk, int *val,
3939 				       unsigned int optlen)
3940 {
3941 	if (optlen < sizeof(int))
3942 		return -EINVAL;
3943 
3944 	sctp_sk(sk)->recvrcvinfo = (*val == 0) ? 0 : 1;
3945 
3946 	return 0;
3947 }
3948 
sctp_setsockopt_recvnxtinfo(struct sock * sk,int * val,unsigned int optlen)3949 static int sctp_setsockopt_recvnxtinfo(struct sock *sk, int *val,
3950 				       unsigned int optlen)
3951 {
3952 	if (optlen < sizeof(int))
3953 		return -EINVAL;
3954 
3955 	sctp_sk(sk)->recvnxtinfo = (*val == 0) ? 0 : 1;
3956 
3957 	return 0;
3958 }
3959 
sctp_setsockopt_pr_supported(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)3960 static int sctp_setsockopt_pr_supported(struct sock *sk,
3961 					struct sctp_assoc_value *params,
3962 					unsigned int optlen)
3963 {
3964 	struct sctp_association *asoc;
3965 
3966 	if (optlen != sizeof(*params))
3967 		return -EINVAL;
3968 
3969 	asoc = sctp_id2assoc(sk, params->assoc_id);
3970 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
3971 	    sctp_style(sk, UDP))
3972 		return -EINVAL;
3973 
3974 	sctp_sk(sk)->ep->prsctp_enable = !!params->assoc_value;
3975 
3976 	return 0;
3977 }
3978 
sctp_setsockopt_default_prinfo(struct sock * sk,struct sctp_default_prinfo * info,unsigned int optlen)3979 static int sctp_setsockopt_default_prinfo(struct sock *sk,
3980 					  struct sctp_default_prinfo *info,
3981 					  unsigned int optlen)
3982 {
3983 	struct sctp_sock *sp = sctp_sk(sk);
3984 	struct sctp_association *asoc;
3985 	int retval = -EINVAL;
3986 
3987 	if (optlen != sizeof(*info))
3988 		goto out;
3989 
3990 	if (info->pr_policy & ~SCTP_PR_SCTP_MASK)
3991 		goto out;
3992 
3993 	if (info->pr_policy == SCTP_PR_SCTP_NONE)
3994 		info->pr_value = 0;
3995 
3996 	asoc = sctp_id2assoc(sk, info->pr_assoc_id);
3997 	if (!asoc && info->pr_assoc_id > SCTP_ALL_ASSOC &&
3998 	    sctp_style(sk, UDP))
3999 		goto out;
4000 
4001 	retval = 0;
4002 
4003 	if (asoc) {
4004 		SCTP_PR_SET_POLICY(asoc->default_flags, info->pr_policy);
4005 		asoc->default_timetolive = info->pr_value;
4006 		goto out;
4007 	}
4008 
4009 	if (sctp_style(sk, TCP))
4010 		info->pr_assoc_id = SCTP_FUTURE_ASSOC;
4011 
4012 	if (info->pr_assoc_id == SCTP_FUTURE_ASSOC ||
4013 	    info->pr_assoc_id == SCTP_ALL_ASSOC) {
4014 		SCTP_PR_SET_POLICY(sp->default_flags, info->pr_policy);
4015 		sp->default_timetolive = info->pr_value;
4016 	}
4017 
4018 	if (info->pr_assoc_id == SCTP_CURRENT_ASSOC ||
4019 	    info->pr_assoc_id == SCTP_ALL_ASSOC) {
4020 		list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4021 			SCTP_PR_SET_POLICY(asoc->default_flags,
4022 					   info->pr_policy);
4023 			asoc->default_timetolive = info->pr_value;
4024 		}
4025 	}
4026 
4027 out:
4028 	return retval;
4029 }
4030 
sctp_setsockopt_reconfig_supported(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4031 static int sctp_setsockopt_reconfig_supported(struct sock *sk,
4032 					      struct sctp_assoc_value *params,
4033 					      unsigned int optlen)
4034 {
4035 	struct sctp_association *asoc;
4036 	int retval = -EINVAL;
4037 
4038 	if (optlen != sizeof(*params))
4039 		goto out;
4040 
4041 	asoc = sctp_id2assoc(sk, params->assoc_id);
4042 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4043 	    sctp_style(sk, UDP))
4044 		goto out;
4045 
4046 	sctp_sk(sk)->ep->reconf_enable = !!params->assoc_value;
4047 
4048 	retval = 0;
4049 
4050 out:
4051 	return retval;
4052 }
4053 
sctp_setsockopt_enable_strreset(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4054 static int sctp_setsockopt_enable_strreset(struct sock *sk,
4055 					   struct sctp_assoc_value *params,
4056 					   unsigned int optlen)
4057 {
4058 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
4059 	struct sctp_association *asoc;
4060 	int retval = -EINVAL;
4061 
4062 	if (optlen != sizeof(*params))
4063 		goto out;
4064 
4065 	if (params->assoc_value & (~SCTP_ENABLE_STRRESET_MASK))
4066 		goto out;
4067 
4068 	asoc = sctp_id2assoc(sk, params->assoc_id);
4069 	if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
4070 	    sctp_style(sk, UDP))
4071 		goto out;
4072 
4073 	retval = 0;
4074 
4075 	if (asoc) {
4076 		asoc->strreset_enable = params->assoc_value;
4077 		goto out;
4078 	}
4079 
4080 	if (sctp_style(sk, TCP))
4081 		params->assoc_id = SCTP_FUTURE_ASSOC;
4082 
4083 	if (params->assoc_id == SCTP_FUTURE_ASSOC ||
4084 	    params->assoc_id == SCTP_ALL_ASSOC)
4085 		ep->strreset_enable = params->assoc_value;
4086 
4087 	if (params->assoc_id == SCTP_CURRENT_ASSOC ||
4088 	    params->assoc_id == SCTP_ALL_ASSOC)
4089 		list_for_each_entry(asoc, &ep->asocs, asocs)
4090 			asoc->strreset_enable = params->assoc_value;
4091 
4092 out:
4093 	return retval;
4094 }
4095 
sctp_setsockopt_reset_streams(struct sock * sk,struct sctp_reset_streams * params,unsigned int optlen)4096 static int sctp_setsockopt_reset_streams(struct sock *sk,
4097 					 struct sctp_reset_streams *params,
4098 					 unsigned int optlen)
4099 {
4100 	struct sctp_association *asoc;
4101 
4102 	if (optlen < sizeof(*params))
4103 		return -EINVAL;
4104 	/* srs_number_streams is u16, so optlen can't be bigger than this. */
4105 	optlen = min_t(unsigned int, optlen, USHRT_MAX +
4106 					     sizeof(__u16) * sizeof(*params));
4107 
4108 	if (params->srs_number_streams * sizeof(__u16) >
4109 	    optlen - sizeof(*params))
4110 		return -EINVAL;
4111 
4112 	asoc = sctp_id2assoc(sk, params->srs_assoc_id);
4113 	if (!asoc)
4114 		return -EINVAL;
4115 
4116 	return sctp_send_reset_streams(asoc, params);
4117 }
4118 
sctp_setsockopt_reset_assoc(struct sock * sk,sctp_assoc_t * associd,unsigned int optlen)4119 static int sctp_setsockopt_reset_assoc(struct sock *sk, sctp_assoc_t *associd,
4120 				       unsigned int optlen)
4121 {
4122 	struct sctp_association *asoc;
4123 
4124 	if (optlen != sizeof(*associd))
4125 		return -EINVAL;
4126 
4127 	asoc = sctp_id2assoc(sk, *associd);
4128 	if (!asoc)
4129 		return -EINVAL;
4130 
4131 	return sctp_send_reset_assoc(asoc);
4132 }
4133 
sctp_setsockopt_add_streams(struct sock * sk,struct sctp_add_streams * params,unsigned int optlen)4134 static int sctp_setsockopt_add_streams(struct sock *sk,
4135 				       struct sctp_add_streams *params,
4136 				       unsigned int optlen)
4137 {
4138 	struct sctp_association *asoc;
4139 
4140 	if (optlen != sizeof(*params))
4141 		return -EINVAL;
4142 
4143 	asoc = sctp_id2assoc(sk, params->sas_assoc_id);
4144 	if (!asoc)
4145 		return -EINVAL;
4146 
4147 	return sctp_send_add_streams(asoc, params);
4148 }
4149 
sctp_setsockopt_scheduler(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4150 static int sctp_setsockopt_scheduler(struct sock *sk,
4151 				     struct sctp_assoc_value *params,
4152 				     unsigned int optlen)
4153 {
4154 	struct sctp_sock *sp = sctp_sk(sk);
4155 	struct sctp_association *asoc;
4156 	int retval = 0;
4157 
4158 	if (optlen < sizeof(*params))
4159 		return -EINVAL;
4160 
4161 	if (params->assoc_value > SCTP_SS_MAX)
4162 		return -EINVAL;
4163 
4164 	asoc = sctp_id2assoc(sk, params->assoc_id);
4165 	if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
4166 	    sctp_style(sk, UDP))
4167 		return -EINVAL;
4168 
4169 	if (asoc)
4170 		return sctp_sched_set_sched(asoc, params->assoc_value);
4171 
4172 	if (sctp_style(sk, TCP))
4173 		params->assoc_id = SCTP_FUTURE_ASSOC;
4174 
4175 	if (params->assoc_id == SCTP_FUTURE_ASSOC ||
4176 	    params->assoc_id == SCTP_ALL_ASSOC)
4177 		sp->default_ss = params->assoc_value;
4178 
4179 	if (params->assoc_id == SCTP_CURRENT_ASSOC ||
4180 	    params->assoc_id == SCTP_ALL_ASSOC) {
4181 		list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4182 			int ret = sctp_sched_set_sched(asoc,
4183 						       params->assoc_value);
4184 
4185 			if (ret && !retval)
4186 				retval = ret;
4187 		}
4188 	}
4189 
4190 	return retval;
4191 }
4192 
sctp_setsockopt_scheduler_value(struct sock * sk,struct sctp_stream_value * params,unsigned int optlen)4193 static int sctp_setsockopt_scheduler_value(struct sock *sk,
4194 					   struct sctp_stream_value *params,
4195 					   unsigned int optlen)
4196 {
4197 	struct sctp_association *asoc;
4198 	int retval = -EINVAL;
4199 
4200 	if (optlen < sizeof(*params))
4201 		goto out;
4202 
4203 	asoc = sctp_id2assoc(sk, params->assoc_id);
4204 	if (!asoc && params->assoc_id != SCTP_CURRENT_ASSOC &&
4205 	    sctp_style(sk, UDP))
4206 		goto out;
4207 
4208 	if (asoc) {
4209 		retval = sctp_sched_set_value(asoc, params->stream_id,
4210 					      params->stream_value, GFP_KERNEL);
4211 		goto out;
4212 	}
4213 
4214 	retval = 0;
4215 
4216 	list_for_each_entry(asoc, &sctp_sk(sk)->ep->asocs, asocs) {
4217 		int ret = sctp_sched_set_value(asoc, params->stream_id,
4218 					       params->stream_value,
4219 					       GFP_KERNEL);
4220 		if (ret && !retval) /* try to return the 1st error. */
4221 			retval = ret;
4222 	}
4223 
4224 out:
4225 	return retval;
4226 }
4227 
sctp_setsockopt_interleaving_supported(struct sock * sk,struct sctp_assoc_value * p,unsigned int optlen)4228 static int sctp_setsockopt_interleaving_supported(struct sock *sk,
4229 						  struct sctp_assoc_value *p,
4230 						  unsigned int optlen)
4231 {
4232 	struct sctp_sock *sp = sctp_sk(sk);
4233 	struct sctp_association *asoc;
4234 
4235 	if (optlen < sizeof(*p))
4236 		return -EINVAL;
4237 
4238 	asoc = sctp_id2assoc(sk, p->assoc_id);
4239 	if (!asoc && p->assoc_id != SCTP_FUTURE_ASSOC && sctp_style(sk, UDP))
4240 		return -EINVAL;
4241 
4242 	if (!sock_net(sk)->sctp.intl_enable || !sp->frag_interleave) {
4243 		return -EPERM;
4244 	}
4245 
4246 	sp->ep->intl_enable = !!p->assoc_value;
4247 	return 0;
4248 }
4249 
sctp_setsockopt_reuse_port(struct sock * sk,int * val,unsigned int optlen)4250 static int sctp_setsockopt_reuse_port(struct sock *sk, int *val,
4251 				      unsigned int optlen)
4252 {
4253 	if (!sctp_style(sk, TCP))
4254 		return -EOPNOTSUPP;
4255 
4256 	if (sctp_sk(sk)->ep->base.bind_addr.port)
4257 		return -EFAULT;
4258 
4259 	if (optlen < sizeof(int))
4260 		return -EINVAL;
4261 
4262 	sctp_sk(sk)->reuse = !!*val;
4263 
4264 	return 0;
4265 }
4266 
sctp_assoc_ulpevent_type_set(struct sctp_event * param,struct sctp_association * asoc)4267 static int sctp_assoc_ulpevent_type_set(struct sctp_event *param,
4268 					struct sctp_association *asoc)
4269 {
4270 	struct sctp_ulpevent *event;
4271 
4272 	sctp_ulpevent_type_set(&asoc->subscribe, param->se_type, param->se_on);
4273 
4274 	if (param->se_type == SCTP_SENDER_DRY_EVENT && param->se_on) {
4275 		if (sctp_outq_is_empty(&asoc->outqueue)) {
4276 			event = sctp_ulpevent_make_sender_dry_event(asoc,
4277 					GFP_USER | __GFP_NOWARN);
4278 			if (!event)
4279 				return -ENOMEM;
4280 
4281 			asoc->stream.si->enqueue_event(&asoc->ulpq, event);
4282 		}
4283 	}
4284 
4285 	return 0;
4286 }
4287 
sctp_setsockopt_event(struct sock * sk,struct sctp_event * param,unsigned int optlen)4288 static int sctp_setsockopt_event(struct sock *sk, struct sctp_event *param,
4289 				 unsigned int optlen)
4290 {
4291 	struct sctp_sock *sp = sctp_sk(sk);
4292 	struct sctp_association *asoc;
4293 	int retval = 0;
4294 
4295 	if (optlen < sizeof(*param))
4296 		return -EINVAL;
4297 
4298 	if (param->se_type < SCTP_SN_TYPE_BASE ||
4299 	    param->se_type > SCTP_SN_TYPE_MAX)
4300 		return -EINVAL;
4301 
4302 	asoc = sctp_id2assoc(sk, param->se_assoc_id);
4303 	if (!asoc && param->se_assoc_id > SCTP_ALL_ASSOC &&
4304 	    sctp_style(sk, UDP))
4305 		return -EINVAL;
4306 
4307 	if (asoc)
4308 		return sctp_assoc_ulpevent_type_set(param, asoc);
4309 
4310 	if (sctp_style(sk, TCP))
4311 		param->se_assoc_id = SCTP_FUTURE_ASSOC;
4312 
4313 	if (param->se_assoc_id == SCTP_FUTURE_ASSOC ||
4314 	    param->se_assoc_id == SCTP_ALL_ASSOC)
4315 		sctp_ulpevent_type_set(&sp->subscribe,
4316 				       param->se_type, param->se_on);
4317 
4318 	if (param->se_assoc_id == SCTP_CURRENT_ASSOC ||
4319 	    param->se_assoc_id == SCTP_ALL_ASSOC) {
4320 		list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4321 			int ret = sctp_assoc_ulpevent_type_set(param, asoc);
4322 
4323 			if (ret && !retval)
4324 				retval = ret;
4325 		}
4326 	}
4327 
4328 	return retval;
4329 }
4330 
sctp_setsockopt_asconf_supported(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4331 static int sctp_setsockopt_asconf_supported(struct sock *sk,
4332 					    struct sctp_assoc_value *params,
4333 					    unsigned int optlen)
4334 {
4335 	struct sctp_association *asoc;
4336 	struct sctp_endpoint *ep;
4337 	int retval = -EINVAL;
4338 
4339 	if (optlen != sizeof(*params))
4340 		goto out;
4341 
4342 	asoc = sctp_id2assoc(sk, params->assoc_id);
4343 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4344 	    sctp_style(sk, UDP))
4345 		goto out;
4346 
4347 	ep = sctp_sk(sk)->ep;
4348 	ep->asconf_enable = !!params->assoc_value;
4349 
4350 	if (ep->asconf_enable && ep->auth_enable) {
4351 		sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF);
4352 		sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF_ACK);
4353 	}
4354 
4355 	retval = 0;
4356 
4357 out:
4358 	return retval;
4359 }
4360 
sctp_setsockopt_auth_supported(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4361 static int sctp_setsockopt_auth_supported(struct sock *sk,
4362 					  struct sctp_assoc_value *params,
4363 					  unsigned int optlen)
4364 {
4365 	struct sctp_association *asoc;
4366 	struct sctp_endpoint *ep;
4367 	int retval = -EINVAL;
4368 
4369 	if (optlen != sizeof(*params))
4370 		goto out;
4371 
4372 	asoc = sctp_id2assoc(sk, params->assoc_id);
4373 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4374 	    sctp_style(sk, UDP))
4375 		goto out;
4376 
4377 	ep = sctp_sk(sk)->ep;
4378 	if (params->assoc_value) {
4379 		retval = sctp_auth_init(ep, GFP_KERNEL);
4380 		if (retval)
4381 			goto out;
4382 		if (ep->asconf_enable) {
4383 			sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF);
4384 			sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF_ACK);
4385 		}
4386 	}
4387 
4388 	ep->auth_enable = !!params->assoc_value;
4389 	retval = 0;
4390 
4391 out:
4392 	return retval;
4393 }
4394 
sctp_setsockopt_ecn_supported(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4395 static int sctp_setsockopt_ecn_supported(struct sock *sk,
4396 					 struct sctp_assoc_value *params,
4397 					 unsigned int optlen)
4398 {
4399 	struct sctp_association *asoc;
4400 	int retval = -EINVAL;
4401 
4402 	if (optlen != sizeof(*params))
4403 		goto out;
4404 
4405 	asoc = sctp_id2assoc(sk, params->assoc_id);
4406 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4407 	    sctp_style(sk, UDP))
4408 		goto out;
4409 
4410 	sctp_sk(sk)->ep->ecn_enable = !!params->assoc_value;
4411 	retval = 0;
4412 
4413 out:
4414 	return retval;
4415 }
4416 
sctp_setsockopt_pf_expose(struct sock * sk,struct sctp_assoc_value * params,unsigned int optlen)4417 static int sctp_setsockopt_pf_expose(struct sock *sk,
4418 				     struct sctp_assoc_value *params,
4419 				     unsigned int optlen)
4420 {
4421 	struct sctp_association *asoc;
4422 	int retval = -EINVAL;
4423 
4424 	if (optlen != sizeof(*params))
4425 		goto out;
4426 
4427 	if (params->assoc_value > SCTP_PF_EXPOSE_MAX)
4428 		goto out;
4429 
4430 	asoc = sctp_id2assoc(sk, params->assoc_id);
4431 	if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4432 	    sctp_style(sk, UDP))
4433 		goto out;
4434 
4435 	if (asoc)
4436 		asoc->pf_expose = params->assoc_value;
4437 	else
4438 		sctp_sk(sk)->pf_expose = params->assoc_value;
4439 	retval = 0;
4440 
4441 out:
4442 	return retval;
4443 }
4444 
sctp_setsockopt_encap_port(struct sock * sk,struct sctp_udpencaps * encap,unsigned int optlen)4445 static int sctp_setsockopt_encap_port(struct sock *sk,
4446 				      struct sctp_udpencaps *encap,
4447 				      unsigned int optlen)
4448 {
4449 	struct sctp_association *asoc;
4450 	struct sctp_transport *t;
4451 	__be16 encap_port;
4452 
4453 	if (optlen != sizeof(*encap))
4454 		return -EINVAL;
4455 
4456 	/* If an address other than INADDR_ANY is specified, and
4457 	 * no transport is found, then the request is invalid.
4458 	 */
4459 	encap_port = (__force __be16)encap->sue_port;
4460 	if (!sctp_is_any(sk, (union sctp_addr *)&encap->sue_address)) {
4461 		t = sctp_addr_id2transport(sk, &encap->sue_address,
4462 					   encap->sue_assoc_id);
4463 		if (!t)
4464 			return -EINVAL;
4465 
4466 		t->encap_port = encap_port;
4467 		return 0;
4468 	}
4469 
4470 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
4471 	 * socket is a one to many style socket, and an association
4472 	 * was not found, then the id was invalid.
4473 	 */
4474 	asoc = sctp_id2assoc(sk, encap->sue_assoc_id);
4475 	if (!asoc && encap->sue_assoc_id != SCTP_FUTURE_ASSOC &&
4476 	    sctp_style(sk, UDP))
4477 		return -EINVAL;
4478 
4479 	/* If changes are for association, also apply encap_port to
4480 	 * each transport.
4481 	 */
4482 	if (asoc) {
4483 		list_for_each_entry(t, &asoc->peer.transport_addr_list,
4484 				    transports)
4485 			t->encap_port = encap_port;
4486 
4487 		asoc->encap_port = encap_port;
4488 		return 0;
4489 	}
4490 
4491 	sctp_sk(sk)->encap_port = encap_port;
4492 	return 0;
4493 }
4494 
sctp_setsockopt_probe_interval(struct sock * sk,struct sctp_probeinterval * params,unsigned int optlen)4495 static int sctp_setsockopt_probe_interval(struct sock *sk,
4496 					  struct sctp_probeinterval *params,
4497 					  unsigned int optlen)
4498 {
4499 	struct sctp_association *asoc;
4500 	struct sctp_transport *t;
4501 	__u32 probe_interval;
4502 
4503 	if (optlen != sizeof(*params))
4504 		return -EINVAL;
4505 
4506 	probe_interval = params->spi_interval;
4507 	if (probe_interval && probe_interval < SCTP_PROBE_TIMER_MIN)
4508 		return -EINVAL;
4509 
4510 	/* If an address other than INADDR_ANY is specified, and
4511 	 * no transport is found, then the request is invalid.
4512 	 */
4513 	if (!sctp_is_any(sk, (union sctp_addr *)&params->spi_address)) {
4514 		t = sctp_addr_id2transport(sk, &params->spi_address,
4515 					   params->spi_assoc_id);
4516 		if (!t)
4517 			return -EINVAL;
4518 
4519 		t->probe_interval = msecs_to_jiffies(probe_interval);
4520 		sctp_transport_pl_reset(t);
4521 		return 0;
4522 	}
4523 
4524 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
4525 	 * socket is a one to many style socket, and an association
4526 	 * was not found, then the id was invalid.
4527 	 */
4528 	asoc = sctp_id2assoc(sk, params->spi_assoc_id);
4529 	if (!asoc && params->spi_assoc_id != SCTP_FUTURE_ASSOC &&
4530 	    sctp_style(sk, UDP))
4531 		return -EINVAL;
4532 
4533 	/* If changes are for association, also apply probe_interval to
4534 	 * each transport.
4535 	 */
4536 	if (asoc) {
4537 		list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
4538 			t->probe_interval = msecs_to_jiffies(probe_interval);
4539 			sctp_transport_pl_reset(t);
4540 		}
4541 
4542 		asoc->probe_interval = msecs_to_jiffies(probe_interval);
4543 		return 0;
4544 	}
4545 
4546 	sctp_sk(sk)->probe_interval = probe_interval;
4547 	return 0;
4548 }
4549 
4550 /* API 6.2 setsockopt(), getsockopt()
4551  *
4552  * Applications use setsockopt() and getsockopt() to set or retrieve
4553  * socket options.  Socket options are used to change the default
4554  * behavior of sockets calls.  They are described in Section 7.
4555  *
4556  * The syntax is:
4557  *
4558  *   ret = getsockopt(int sd, int level, int optname, void __user *optval,
4559  *                    int __user *optlen);
4560  *   ret = setsockopt(int sd, int level, int optname, const void __user *optval,
4561  *                    int optlen);
4562  *
4563  *   sd      - the socket descript.
4564  *   level   - set to IPPROTO_SCTP for all SCTP options.
4565  *   optname - the option name.
4566  *   optval  - the buffer to store the value of the option.
4567  *   optlen  - the size of the buffer.
4568  */
sctp_setsockopt(struct sock * sk,int level,int optname,sockptr_t optval,unsigned int optlen)4569 static int sctp_setsockopt(struct sock *sk, int level, int optname,
4570 			   sockptr_t optval, unsigned int optlen)
4571 {
4572 	void *kopt = NULL;
4573 	int retval = 0;
4574 
4575 	pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
4576 
4577 	/* I can hardly begin to describe how wrong this is.  This is
4578 	 * so broken as to be worse than useless.  The API draft
4579 	 * REALLY is NOT helpful here...  I am not convinced that the
4580 	 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
4581 	 * are at all well-founded.
4582 	 */
4583 	if (level != SOL_SCTP) {
4584 		struct sctp_af *af = sctp_sk(sk)->pf->af;
4585 
4586 		return af->setsockopt(sk, level, optname, optval, optlen);
4587 	}
4588 
4589 	if (optlen > 0) {
4590 		/* Trim it to the biggest size sctp sockopt may need if necessary */
4591 		optlen = min_t(unsigned int, optlen,
4592 			       PAGE_ALIGN(USHRT_MAX +
4593 					  sizeof(__u16) * sizeof(struct sctp_reset_streams)));
4594 		kopt = memdup_sockptr(optval, optlen);
4595 		if (IS_ERR(kopt))
4596 			return PTR_ERR(kopt);
4597 	}
4598 
4599 	lock_sock(sk);
4600 
4601 	switch (optname) {
4602 	case SCTP_SOCKOPT_BINDX_ADD:
4603 		/* 'optlen' is the size of the addresses buffer. */
4604 		retval = sctp_setsockopt_bindx(sk, kopt, optlen,
4605 					       SCTP_BINDX_ADD_ADDR);
4606 		break;
4607 
4608 	case SCTP_SOCKOPT_BINDX_REM:
4609 		/* 'optlen' is the size of the addresses buffer. */
4610 		retval = sctp_setsockopt_bindx(sk, kopt, optlen,
4611 					       SCTP_BINDX_REM_ADDR);
4612 		break;
4613 
4614 	case SCTP_SOCKOPT_CONNECTX_OLD:
4615 		/* 'optlen' is the size of the addresses buffer. */
4616 		retval = sctp_setsockopt_connectx_old(sk, kopt, optlen);
4617 		break;
4618 
4619 	case SCTP_SOCKOPT_CONNECTX:
4620 		/* 'optlen' is the size of the addresses buffer. */
4621 		retval = sctp_setsockopt_connectx(sk, kopt, optlen);
4622 		break;
4623 
4624 	case SCTP_DISABLE_FRAGMENTS:
4625 		retval = sctp_setsockopt_disable_fragments(sk, kopt, optlen);
4626 		break;
4627 
4628 	case SCTP_EVENTS:
4629 		retval = sctp_setsockopt_events(sk, kopt, optlen);
4630 		break;
4631 
4632 	case SCTP_AUTOCLOSE:
4633 		retval = sctp_setsockopt_autoclose(sk, kopt, optlen);
4634 		break;
4635 
4636 	case SCTP_PEER_ADDR_PARAMS:
4637 		retval = sctp_setsockopt_peer_addr_params(sk, kopt, optlen);
4638 		break;
4639 
4640 	case SCTP_DELAYED_SACK:
4641 		retval = sctp_setsockopt_delayed_ack(sk, kopt, optlen);
4642 		break;
4643 	case SCTP_PARTIAL_DELIVERY_POINT:
4644 		retval = sctp_setsockopt_partial_delivery_point(sk, kopt, optlen);
4645 		break;
4646 
4647 	case SCTP_INITMSG:
4648 		retval = sctp_setsockopt_initmsg(sk, kopt, optlen);
4649 		break;
4650 	case SCTP_DEFAULT_SEND_PARAM:
4651 		retval = sctp_setsockopt_default_send_param(sk, kopt, optlen);
4652 		break;
4653 	case SCTP_DEFAULT_SNDINFO:
4654 		retval = sctp_setsockopt_default_sndinfo(sk, kopt, optlen);
4655 		break;
4656 	case SCTP_PRIMARY_ADDR:
4657 		retval = sctp_setsockopt_primary_addr(sk, kopt, optlen);
4658 		break;
4659 	case SCTP_SET_PEER_PRIMARY_ADDR:
4660 		retval = sctp_setsockopt_peer_primary_addr(sk, kopt, optlen);
4661 		break;
4662 	case SCTP_NODELAY:
4663 		retval = sctp_setsockopt_nodelay(sk, kopt, optlen);
4664 		break;
4665 	case SCTP_RTOINFO:
4666 		retval = sctp_setsockopt_rtoinfo(sk, kopt, optlen);
4667 		break;
4668 	case SCTP_ASSOCINFO:
4669 		retval = sctp_setsockopt_associnfo(sk, kopt, optlen);
4670 		break;
4671 	case SCTP_I_WANT_MAPPED_V4_ADDR:
4672 		retval = sctp_setsockopt_mappedv4(sk, kopt, optlen);
4673 		break;
4674 	case SCTP_MAXSEG:
4675 		retval = sctp_setsockopt_maxseg(sk, kopt, optlen);
4676 		break;
4677 	case SCTP_ADAPTATION_LAYER:
4678 		retval = sctp_setsockopt_adaptation_layer(sk, kopt, optlen);
4679 		break;
4680 	case SCTP_CONTEXT:
4681 		retval = sctp_setsockopt_context(sk, kopt, optlen);
4682 		break;
4683 	case SCTP_FRAGMENT_INTERLEAVE:
4684 		retval = sctp_setsockopt_fragment_interleave(sk, kopt, optlen);
4685 		break;
4686 	case SCTP_MAX_BURST:
4687 		retval = sctp_setsockopt_maxburst(sk, kopt, optlen);
4688 		break;
4689 	case SCTP_AUTH_CHUNK:
4690 		retval = sctp_setsockopt_auth_chunk(sk, kopt, optlen);
4691 		break;
4692 	case SCTP_HMAC_IDENT:
4693 		retval = sctp_setsockopt_hmac_ident(sk, kopt, optlen);
4694 		break;
4695 	case SCTP_AUTH_KEY:
4696 		retval = sctp_setsockopt_auth_key(sk, kopt, optlen);
4697 		break;
4698 	case SCTP_AUTH_ACTIVE_KEY:
4699 		retval = sctp_setsockopt_active_key(sk, kopt, optlen);
4700 		break;
4701 	case SCTP_AUTH_DELETE_KEY:
4702 		retval = sctp_setsockopt_del_key(sk, kopt, optlen);
4703 		break;
4704 	case SCTP_AUTH_DEACTIVATE_KEY:
4705 		retval = sctp_setsockopt_deactivate_key(sk, kopt, optlen);
4706 		break;
4707 	case SCTP_AUTO_ASCONF:
4708 		retval = sctp_setsockopt_auto_asconf(sk, kopt, optlen);
4709 		break;
4710 	case SCTP_PEER_ADDR_THLDS:
4711 		retval = sctp_setsockopt_paddr_thresholds(sk, kopt, optlen,
4712 							  false);
4713 		break;
4714 	case SCTP_PEER_ADDR_THLDS_V2:
4715 		retval = sctp_setsockopt_paddr_thresholds(sk, kopt, optlen,
4716 							  true);
4717 		break;
4718 	case SCTP_RECVRCVINFO:
4719 		retval = sctp_setsockopt_recvrcvinfo(sk, kopt, optlen);
4720 		break;
4721 	case SCTP_RECVNXTINFO:
4722 		retval = sctp_setsockopt_recvnxtinfo(sk, kopt, optlen);
4723 		break;
4724 	case SCTP_PR_SUPPORTED:
4725 		retval = sctp_setsockopt_pr_supported(sk, kopt, optlen);
4726 		break;
4727 	case SCTP_DEFAULT_PRINFO:
4728 		retval = sctp_setsockopt_default_prinfo(sk, kopt, optlen);
4729 		break;
4730 	case SCTP_RECONFIG_SUPPORTED:
4731 		retval = sctp_setsockopt_reconfig_supported(sk, kopt, optlen);
4732 		break;
4733 	case SCTP_ENABLE_STREAM_RESET:
4734 		retval = sctp_setsockopt_enable_strreset(sk, kopt, optlen);
4735 		break;
4736 	case SCTP_RESET_STREAMS:
4737 		retval = sctp_setsockopt_reset_streams(sk, kopt, optlen);
4738 		break;
4739 	case SCTP_RESET_ASSOC:
4740 		retval = sctp_setsockopt_reset_assoc(sk, kopt, optlen);
4741 		break;
4742 	case SCTP_ADD_STREAMS:
4743 		retval = sctp_setsockopt_add_streams(sk, kopt, optlen);
4744 		break;
4745 	case SCTP_STREAM_SCHEDULER:
4746 		retval = sctp_setsockopt_scheduler(sk, kopt, optlen);
4747 		break;
4748 	case SCTP_STREAM_SCHEDULER_VALUE:
4749 		retval = sctp_setsockopt_scheduler_value(sk, kopt, optlen);
4750 		break;
4751 	case SCTP_INTERLEAVING_SUPPORTED:
4752 		retval = sctp_setsockopt_interleaving_supported(sk, kopt,
4753 								optlen);
4754 		break;
4755 	case SCTP_REUSE_PORT:
4756 		retval = sctp_setsockopt_reuse_port(sk, kopt, optlen);
4757 		break;
4758 	case SCTP_EVENT:
4759 		retval = sctp_setsockopt_event(sk, kopt, optlen);
4760 		break;
4761 	case SCTP_ASCONF_SUPPORTED:
4762 		retval = sctp_setsockopt_asconf_supported(sk, kopt, optlen);
4763 		break;
4764 	case SCTP_AUTH_SUPPORTED:
4765 		retval = sctp_setsockopt_auth_supported(sk, kopt, optlen);
4766 		break;
4767 	case SCTP_ECN_SUPPORTED:
4768 		retval = sctp_setsockopt_ecn_supported(sk, kopt, optlen);
4769 		break;
4770 	case SCTP_EXPOSE_POTENTIALLY_FAILED_STATE:
4771 		retval = sctp_setsockopt_pf_expose(sk, kopt, optlen);
4772 		break;
4773 	case SCTP_REMOTE_UDP_ENCAPS_PORT:
4774 		retval = sctp_setsockopt_encap_port(sk, kopt, optlen);
4775 		break;
4776 	case SCTP_PLPMTUD_PROBE_INTERVAL:
4777 		retval = sctp_setsockopt_probe_interval(sk, kopt, optlen);
4778 		break;
4779 	default:
4780 		retval = -ENOPROTOOPT;
4781 		break;
4782 	}
4783 
4784 	release_sock(sk);
4785 	kfree(kopt);
4786 	return retval;
4787 }
4788 
4789 /* API 3.1.6 connect() - UDP Style Syntax
4790  *
4791  * An application may use the connect() call in the UDP model to initiate an
4792  * association without sending data.
4793  *
4794  * The syntax is:
4795  *
4796  * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4797  *
4798  * sd: the socket descriptor to have a new association added to.
4799  *
4800  * nam: the address structure (either struct sockaddr_in or struct
4801  *    sockaddr_in6 defined in RFC2553 [7]).
4802  *
4803  * len: the size of the address.
4804  */
sctp_connect(struct sock * sk,struct sockaddr * addr,int addr_len,int flags)4805 static int sctp_connect(struct sock *sk, struct sockaddr *addr,
4806 			int addr_len, int flags)
4807 {
4808 	struct sctp_af *af;
4809 	int err = -EINVAL;
4810 
4811 	lock_sock(sk);
4812 	pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__, sk,
4813 		 addr, addr_len);
4814 
4815 	/* Validate addr_len before calling common connect/connectx routine. */
4816 	af = sctp_get_af_specific(addr->sa_family);
4817 	if (af && addr_len >= af->sockaddr_len)
4818 		err = __sctp_connect(sk, addr, af->sockaddr_len, flags, NULL);
4819 
4820 	release_sock(sk);
4821 	return err;
4822 }
4823 
sctp_inet_connect(struct socket * sock,struct sockaddr * uaddr,int addr_len,int flags)4824 int sctp_inet_connect(struct socket *sock, struct sockaddr *uaddr,
4825 		      int addr_len, int flags)
4826 {
4827 	if (addr_len < sizeof(uaddr->sa_family))
4828 		return -EINVAL;
4829 
4830 	if (uaddr->sa_family == AF_UNSPEC)
4831 		return -EOPNOTSUPP;
4832 
4833 	return sctp_connect(sock->sk, uaddr, addr_len, flags);
4834 }
4835 
4836 /* FIXME: Write comments. */
sctp_disconnect(struct sock * sk,int flags)4837 static int sctp_disconnect(struct sock *sk, int flags)
4838 {
4839 	return -EOPNOTSUPP; /* STUB */
4840 }
4841 
4842 /* 4.1.4 accept() - TCP Style Syntax
4843  *
4844  * Applications use accept() call to remove an established SCTP
4845  * association from the accept queue of the endpoint.  A new socket
4846  * descriptor will be returned from accept() to represent the newly
4847  * formed association.
4848  */
sctp_accept(struct sock * sk,int flags,int * err,bool kern)4849 static struct sock *sctp_accept(struct sock *sk, int flags, int *err, bool kern)
4850 {
4851 	struct sctp_sock *sp;
4852 	struct sctp_endpoint *ep;
4853 	struct sock *newsk = NULL;
4854 	struct sctp_association *asoc;
4855 	long timeo;
4856 	int error = 0;
4857 
4858 	lock_sock(sk);
4859 
4860 	sp = sctp_sk(sk);
4861 	ep = sp->ep;
4862 
4863 	if (!sctp_style(sk, TCP)) {
4864 		error = -EOPNOTSUPP;
4865 		goto out;
4866 	}
4867 
4868 	if (!sctp_sstate(sk, LISTENING)) {
4869 		error = -EINVAL;
4870 		goto out;
4871 	}
4872 
4873 	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
4874 
4875 	error = sctp_wait_for_accept(sk, timeo);
4876 	if (error)
4877 		goto out;
4878 
4879 	/* We treat the list of associations on the endpoint as the accept
4880 	 * queue and pick the first association on the list.
4881 	 */
4882 	asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
4883 
4884 	newsk = sp->pf->create_accept_sk(sk, asoc, kern);
4885 	if (!newsk) {
4886 		error = -ENOMEM;
4887 		goto out;
4888 	}
4889 
4890 	/* Populate the fields of the newsk from the oldsk and migrate the
4891 	 * asoc to the newsk.
4892 	 */
4893 	error = sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
4894 	if (error) {
4895 		sk_common_release(newsk);
4896 		newsk = NULL;
4897 	}
4898 
4899 out:
4900 	release_sock(sk);
4901 	*err = error;
4902 	return newsk;
4903 }
4904 
4905 /* The SCTP ioctl handler. */
sctp_ioctl(struct sock * sk,int cmd,int * karg)4906 static int sctp_ioctl(struct sock *sk, int cmd, int *karg)
4907 {
4908 	int rc = -ENOTCONN;
4909 
4910 	lock_sock(sk);
4911 
4912 	/*
4913 	 * SEQPACKET-style sockets in LISTENING state are valid, for
4914 	 * SCTP, so only discard TCP-style sockets in LISTENING state.
4915 	 */
4916 	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
4917 		goto out;
4918 
4919 	switch (cmd) {
4920 	case SIOCINQ: {
4921 		struct sk_buff *skb;
4922 		*karg = 0;
4923 
4924 		skb = skb_peek(&sk->sk_receive_queue);
4925 		if (skb != NULL) {
4926 			/*
4927 			 * We will only return the amount of this packet since
4928 			 * that is all that will be read.
4929 			 */
4930 			*karg = skb->len;
4931 		}
4932 		rc = 0;
4933 		break;
4934 	}
4935 	default:
4936 		rc = -ENOIOCTLCMD;
4937 		break;
4938 	}
4939 out:
4940 	release_sock(sk);
4941 	return rc;
4942 }
4943 
4944 /* This is the function which gets called during socket creation to
4945  * initialized the SCTP-specific portion of the sock.
4946  * The sock structure should already be zero-filled memory.
4947  */
sctp_init_sock(struct sock * sk)4948 static int sctp_init_sock(struct sock *sk)
4949 {
4950 	struct net *net = sock_net(sk);
4951 	struct sctp_sock *sp;
4952 
4953 	pr_debug("%s: sk:%p\n", __func__, sk);
4954 
4955 	sp = sctp_sk(sk);
4956 
4957 	/* Initialize the SCTP per socket area.  */
4958 	switch (sk->sk_type) {
4959 	case SOCK_SEQPACKET:
4960 		sp->type = SCTP_SOCKET_UDP;
4961 		break;
4962 	case SOCK_STREAM:
4963 		sp->type = SCTP_SOCKET_TCP;
4964 		break;
4965 	default:
4966 		return -ESOCKTNOSUPPORT;
4967 	}
4968 
4969 	sk->sk_gso_type = SKB_GSO_SCTP;
4970 
4971 	/* Initialize default send parameters. These parameters can be
4972 	 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4973 	 */
4974 	sp->default_stream = 0;
4975 	sp->default_ppid = 0;
4976 	sp->default_flags = 0;
4977 	sp->default_context = 0;
4978 	sp->default_timetolive = 0;
4979 
4980 	sp->default_rcv_context = 0;
4981 	sp->max_burst = net->sctp.max_burst;
4982 
4983 	sp->sctp_hmac_alg = net->sctp.sctp_hmac_alg;
4984 
4985 	/* Initialize default setup parameters. These parameters
4986 	 * can be modified with the SCTP_INITMSG socket option or
4987 	 * overridden by the SCTP_INIT CMSG.
4988 	 */
4989 	sp->initmsg.sinit_num_ostreams   = sctp_max_outstreams;
4990 	sp->initmsg.sinit_max_instreams  = sctp_max_instreams;
4991 	sp->initmsg.sinit_max_attempts   = net->sctp.max_retrans_init;
4992 	sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
4993 
4994 	/* Initialize default RTO related parameters.  These parameters can
4995 	 * be modified for with the SCTP_RTOINFO socket option.
4996 	 */
4997 	sp->rtoinfo.srto_initial = net->sctp.rto_initial;
4998 	sp->rtoinfo.srto_max     = net->sctp.rto_max;
4999 	sp->rtoinfo.srto_min     = net->sctp.rto_min;
5000 
5001 	/* Initialize default association related parameters. These parameters
5002 	 * can be modified with the SCTP_ASSOCINFO socket option.
5003 	 */
5004 	sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
5005 	sp->assocparams.sasoc_number_peer_destinations = 0;
5006 	sp->assocparams.sasoc_peer_rwnd = 0;
5007 	sp->assocparams.sasoc_local_rwnd = 0;
5008 	sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
5009 
5010 	/* Initialize default event subscriptions. By default, all the
5011 	 * options are off.
5012 	 */
5013 	sp->subscribe = 0;
5014 
5015 	/* Default Peer Address Parameters.  These defaults can
5016 	 * be modified via SCTP_PEER_ADDR_PARAMS
5017 	 */
5018 	sp->hbinterval  = net->sctp.hb_interval;
5019 	sp->udp_port    = htons(net->sctp.udp_port);
5020 	sp->encap_port  = htons(net->sctp.encap_port);
5021 	sp->pathmaxrxt  = net->sctp.max_retrans_path;
5022 	sp->pf_retrans  = net->sctp.pf_retrans;
5023 	sp->ps_retrans  = net->sctp.ps_retrans;
5024 	sp->pf_expose   = net->sctp.pf_expose;
5025 	sp->pathmtu     = 0; /* allow default discovery */
5026 	sp->sackdelay   = net->sctp.sack_timeout;
5027 	sp->sackfreq	= 2;
5028 	sp->param_flags = SPP_HB_ENABLE |
5029 			  SPP_PMTUD_ENABLE |
5030 			  SPP_SACKDELAY_ENABLE;
5031 	sp->default_ss = SCTP_SS_DEFAULT;
5032 
5033 	/* If enabled no SCTP message fragmentation will be performed.
5034 	 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
5035 	 */
5036 	sp->disable_fragments = 0;
5037 
5038 	/* Enable Nagle algorithm by default.  */
5039 	sp->nodelay           = 0;
5040 
5041 	sp->recvrcvinfo = 0;
5042 	sp->recvnxtinfo = 0;
5043 
5044 	/* Enable by default. */
5045 	sp->v4mapped          = 1;
5046 
5047 	/* Auto-close idle associations after the configured
5048 	 * number of seconds.  A value of 0 disables this
5049 	 * feature.  Configure through the SCTP_AUTOCLOSE socket option,
5050 	 * for UDP-style sockets only.
5051 	 */
5052 	sp->autoclose         = 0;
5053 
5054 	/* User specified fragmentation limit. */
5055 	sp->user_frag         = 0;
5056 
5057 	sp->adaptation_ind = 0;
5058 
5059 	sp->pf = sctp_get_pf_specific(sk->sk_family);
5060 
5061 	/* Control variables for partial data delivery. */
5062 	atomic_set(&sp->pd_mode, 0);
5063 	skb_queue_head_init(&sp->pd_lobby);
5064 	sp->frag_interleave = 0;
5065 	sp->probe_interval = net->sctp.probe_interval;
5066 
5067 	/* Create a per socket endpoint structure.  Even if we
5068 	 * change the data structure relationships, this may still
5069 	 * be useful for storing pre-connect address information.
5070 	 */
5071 	sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
5072 	if (!sp->ep)
5073 		return -ENOMEM;
5074 
5075 	sp->hmac = NULL;
5076 
5077 	sk->sk_destruct = sctp_destruct_sock;
5078 
5079 	SCTP_DBG_OBJCNT_INC(sock);
5080 
5081 	sk_sockets_allocated_inc(sk);
5082 	sock_prot_inuse_add(net, sk->sk_prot, 1);
5083 
5084 	return 0;
5085 }
5086 
5087 /* Cleanup any SCTP per socket resources. Must be called with
5088  * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5089  */
sctp_destroy_sock(struct sock * sk)5090 static void sctp_destroy_sock(struct sock *sk)
5091 {
5092 	struct sctp_sock *sp;
5093 
5094 	pr_debug("%s: sk:%p\n", __func__, sk);
5095 
5096 	/* Release our hold on the endpoint. */
5097 	sp = sctp_sk(sk);
5098 	/* This could happen during socket init, thus we bail out
5099 	 * early, since the rest of the below is not setup either.
5100 	 */
5101 	if (sp->ep == NULL)
5102 		return;
5103 
5104 	if (sp->do_auto_asconf) {
5105 		sp->do_auto_asconf = 0;
5106 		list_del(&sp->auto_asconf_list);
5107 	}
5108 	sctp_endpoint_free(sp->ep);
5109 	sk_sockets_allocated_dec(sk);
5110 	sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
5111 }
5112 
5113 /* Triggered when there are no references on the socket anymore */
sctp_destruct_common(struct sock * sk)5114 static void sctp_destruct_common(struct sock *sk)
5115 {
5116 	struct sctp_sock *sp = sctp_sk(sk);
5117 
5118 	/* Free up the HMAC transform. */
5119 	crypto_free_shash(sp->hmac);
5120 }
5121 
sctp_destruct_sock(struct sock * sk)5122 static void sctp_destruct_sock(struct sock *sk)
5123 {
5124 	sctp_destruct_common(sk);
5125 	inet_sock_destruct(sk);
5126 }
5127 
5128 /* API 4.1.7 shutdown() - TCP Style Syntax
5129  *     int shutdown(int socket, int how);
5130  *
5131  *     sd      - the socket descriptor of the association to be closed.
5132  *     how     - Specifies the type of shutdown.  The  values  are
5133  *               as follows:
5134  *               SHUT_RD
5135  *                     Disables further receive operations. No SCTP
5136  *                     protocol action is taken.
5137  *               SHUT_WR
5138  *                     Disables further send operations, and initiates
5139  *                     the SCTP shutdown sequence.
5140  *               SHUT_RDWR
5141  *                     Disables further send  and  receive  operations
5142  *                     and initiates the SCTP shutdown sequence.
5143  */
sctp_shutdown(struct sock * sk,int how)5144 static void sctp_shutdown(struct sock *sk, int how)
5145 {
5146 	struct net *net = sock_net(sk);
5147 	struct sctp_endpoint *ep;
5148 
5149 	if (!sctp_style(sk, TCP))
5150 		return;
5151 
5152 	ep = sctp_sk(sk)->ep;
5153 	if (how & SEND_SHUTDOWN && !list_empty(&ep->asocs)) {
5154 		struct sctp_association *asoc;
5155 
5156 		inet_sk_set_state(sk, SCTP_SS_CLOSING);
5157 		asoc = list_entry(ep->asocs.next,
5158 				  struct sctp_association, asocs);
5159 		sctp_primitive_SHUTDOWN(net, asoc, NULL);
5160 	}
5161 }
5162 
sctp_get_sctp_info(struct sock * sk,struct sctp_association * asoc,struct sctp_info * info)5163 int sctp_get_sctp_info(struct sock *sk, struct sctp_association *asoc,
5164 		       struct sctp_info *info)
5165 {
5166 	struct sctp_transport *prim;
5167 	struct list_head *pos;
5168 	int mask;
5169 
5170 	memset(info, 0, sizeof(*info));
5171 	if (!asoc) {
5172 		struct sctp_sock *sp = sctp_sk(sk);
5173 
5174 		info->sctpi_s_autoclose = sp->autoclose;
5175 		info->sctpi_s_adaptation_ind = sp->adaptation_ind;
5176 		info->sctpi_s_pd_point = sp->pd_point;
5177 		info->sctpi_s_nodelay = sp->nodelay;
5178 		info->sctpi_s_disable_fragments = sp->disable_fragments;
5179 		info->sctpi_s_v4mapped = sp->v4mapped;
5180 		info->sctpi_s_frag_interleave = sp->frag_interleave;
5181 		info->sctpi_s_type = sp->type;
5182 
5183 		return 0;
5184 	}
5185 
5186 	info->sctpi_tag = asoc->c.my_vtag;
5187 	info->sctpi_state = asoc->state;
5188 	info->sctpi_rwnd = asoc->a_rwnd;
5189 	info->sctpi_unackdata = asoc->unack_data;
5190 	info->sctpi_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5191 	info->sctpi_instrms = asoc->stream.incnt;
5192 	info->sctpi_outstrms = asoc->stream.outcnt;
5193 	list_for_each(pos, &asoc->base.inqueue.in_chunk_list)
5194 		info->sctpi_inqueue++;
5195 	list_for_each(pos, &asoc->outqueue.out_chunk_list)
5196 		info->sctpi_outqueue++;
5197 	info->sctpi_overall_error = asoc->overall_error_count;
5198 	info->sctpi_max_burst = asoc->max_burst;
5199 	info->sctpi_maxseg = asoc->frag_point;
5200 	info->sctpi_peer_rwnd = asoc->peer.rwnd;
5201 	info->sctpi_peer_tag = asoc->c.peer_vtag;
5202 
5203 	mask = asoc->peer.intl_capable << 1;
5204 	mask = (mask | asoc->peer.ecn_capable) << 1;
5205 	mask = (mask | asoc->peer.ipv4_address) << 1;
5206 	mask = (mask | asoc->peer.ipv6_address) << 1;
5207 	mask = (mask | asoc->peer.reconf_capable) << 1;
5208 	mask = (mask | asoc->peer.asconf_capable) << 1;
5209 	mask = (mask | asoc->peer.prsctp_capable) << 1;
5210 	mask = (mask | asoc->peer.auth_capable);
5211 	info->sctpi_peer_capable = mask;
5212 	mask = asoc->peer.sack_needed << 1;
5213 	mask = (mask | asoc->peer.sack_generation) << 1;
5214 	mask = (mask | asoc->peer.zero_window_announced);
5215 	info->sctpi_peer_sack = mask;
5216 
5217 	info->sctpi_isacks = asoc->stats.isacks;
5218 	info->sctpi_osacks = asoc->stats.osacks;
5219 	info->sctpi_opackets = asoc->stats.opackets;
5220 	info->sctpi_ipackets = asoc->stats.ipackets;
5221 	info->sctpi_rtxchunks = asoc->stats.rtxchunks;
5222 	info->sctpi_outofseqtsns = asoc->stats.outofseqtsns;
5223 	info->sctpi_idupchunks = asoc->stats.idupchunks;
5224 	info->sctpi_gapcnt = asoc->stats.gapcnt;
5225 	info->sctpi_ouodchunks = asoc->stats.ouodchunks;
5226 	info->sctpi_iuodchunks = asoc->stats.iuodchunks;
5227 	info->sctpi_oodchunks = asoc->stats.oodchunks;
5228 	info->sctpi_iodchunks = asoc->stats.iodchunks;
5229 	info->sctpi_octrlchunks = asoc->stats.octrlchunks;
5230 	info->sctpi_ictrlchunks = asoc->stats.ictrlchunks;
5231 
5232 	prim = asoc->peer.primary_path;
5233 	memcpy(&info->sctpi_p_address, &prim->ipaddr, sizeof(prim->ipaddr));
5234 	info->sctpi_p_state = prim->state;
5235 	info->sctpi_p_cwnd = prim->cwnd;
5236 	info->sctpi_p_srtt = prim->srtt;
5237 	info->sctpi_p_rto = jiffies_to_msecs(prim->rto);
5238 	info->sctpi_p_hbinterval = prim->hbinterval;
5239 	info->sctpi_p_pathmaxrxt = prim->pathmaxrxt;
5240 	info->sctpi_p_sackdelay = jiffies_to_msecs(prim->sackdelay);
5241 	info->sctpi_p_ssthresh = prim->ssthresh;
5242 	info->sctpi_p_partial_bytes_acked = prim->partial_bytes_acked;
5243 	info->sctpi_p_flight_size = prim->flight_size;
5244 	info->sctpi_p_error = prim->error_count;
5245 
5246 	return 0;
5247 }
5248 EXPORT_SYMBOL_GPL(sctp_get_sctp_info);
5249 
5250 /* use callback to avoid exporting the core structure */
sctp_transport_walk_start(struct rhashtable_iter * iter)5251 void sctp_transport_walk_start(struct rhashtable_iter *iter) __acquires(RCU)
5252 {
5253 	rhltable_walk_enter(&sctp_transport_hashtable, iter);
5254 
5255 	rhashtable_walk_start(iter);
5256 }
5257 
sctp_transport_walk_stop(struct rhashtable_iter * iter)5258 void sctp_transport_walk_stop(struct rhashtable_iter *iter) __releases(RCU)
5259 {
5260 	rhashtable_walk_stop(iter);
5261 	rhashtable_walk_exit(iter);
5262 }
5263 
sctp_transport_get_next(struct net * net,struct rhashtable_iter * iter)5264 struct sctp_transport *sctp_transport_get_next(struct net *net,
5265 					       struct rhashtable_iter *iter)
5266 {
5267 	struct sctp_transport *t;
5268 
5269 	t = rhashtable_walk_next(iter);
5270 	for (; t; t = rhashtable_walk_next(iter)) {
5271 		if (IS_ERR(t)) {
5272 			if (PTR_ERR(t) == -EAGAIN)
5273 				continue;
5274 			break;
5275 		}
5276 
5277 		if (!sctp_transport_hold(t))
5278 			continue;
5279 
5280 		if (net_eq(t->asoc->base.net, net) &&
5281 		    t->asoc->peer.primary_path == t)
5282 			break;
5283 
5284 		sctp_transport_put(t);
5285 	}
5286 
5287 	return t;
5288 }
5289 
sctp_transport_get_idx(struct net * net,struct rhashtable_iter * iter,int pos)5290 struct sctp_transport *sctp_transport_get_idx(struct net *net,
5291 					      struct rhashtable_iter *iter,
5292 					      int pos)
5293 {
5294 	struct sctp_transport *t;
5295 
5296 	if (!pos)
5297 		return SEQ_START_TOKEN;
5298 
5299 	while ((t = sctp_transport_get_next(net, iter)) && !IS_ERR(t)) {
5300 		if (!--pos)
5301 			break;
5302 		sctp_transport_put(t);
5303 	}
5304 
5305 	return t;
5306 }
5307 
sctp_for_each_endpoint(int (* cb)(struct sctp_endpoint *,void *),void * p)5308 int sctp_for_each_endpoint(int (*cb)(struct sctp_endpoint *, void *),
5309 			   void *p) {
5310 	int err = 0;
5311 	int hash = 0;
5312 	struct sctp_endpoint *ep;
5313 	struct sctp_hashbucket *head;
5314 
5315 	for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
5316 	     hash++, head++) {
5317 		read_lock_bh(&head->lock);
5318 		sctp_for_each_hentry(ep, &head->chain) {
5319 			err = cb(ep, p);
5320 			if (err)
5321 				break;
5322 		}
5323 		read_unlock_bh(&head->lock);
5324 	}
5325 
5326 	return err;
5327 }
5328 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint);
5329 
sctp_transport_lookup_process(sctp_callback_t cb,struct net * net,const union sctp_addr * laddr,const union sctp_addr * paddr,void * p,int dif)5330 int sctp_transport_lookup_process(sctp_callback_t cb, struct net *net,
5331 				  const union sctp_addr *laddr,
5332 				  const union sctp_addr *paddr, void *p, int dif)
5333 {
5334 	struct sctp_transport *transport;
5335 	struct sctp_endpoint *ep;
5336 	int err = -ENOENT;
5337 
5338 	rcu_read_lock();
5339 	transport = sctp_addrs_lookup_transport(net, laddr, paddr, dif, dif);
5340 	if (!transport) {
5341 		rcu_read_unlock();
5342 		return err;
5343 	}
5344 	ep = transport->asoc->ep;
5345 	if (!sctp_endpoint_hold(ep)) { /* asoc can be peeled off */
5346 		sctp_transport_put(transport);
5347 		rcu_read_unlock();
5348 		return err;
5349 	}
5350 	rcu_read_unlock();
5351 
5352 	err = cb(ep, transport, p);
5353 	sctp_endpoint_put(ep);
5354 	sctp_transport_put(transport);
5355 	return err;
5356 }
5357 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process);
5358 
sctp_transport_traverse_process(sctp_callback_t cb,sctp_callback_t cb_done,struct net * net,int * pos,void * p)5359 int sctp_transport_traverse_process(sctp_callback_t cb, sctp_callback_t cb_done,
5360 				    struct net *net, int *pos, void *p)
5361 {
5362 	struct rhashtable_iter hti;
5363 	struct sctp_transport *tsp;
5364 	struct sctp_endpoint *ep;
5365 	int ret;
5366 
5367 again:
5368 	ret = 0;
5369 	sctp_transport_walk_start(&hti);
5370 
5371 	tsp = sctp_transport_get_idx(net, &hti, *pos + 1);
5372 	for (; !IS_ERR_OR_NULL(tsp); tsp = sctp_transport_get_next(net, &hti)) {
5373 		ep = tsp->asoc->ep;
5374 		if (sctp_endpoint_hold(ep)) { /* asoc can be peeled off */
5375 			ret = cb(ep, tsp, p);
5376 			if (ret)
5377 				break;
5378 			sctp_endpoint_put(ep);
5379 		}
5380 		(*pos)++;
5381 		sctp_transport_put(tsp);
5382 	}
5383 	sctp_transport_walk_stop(&hti);
5384 
5385 	if (ret) {
5386 		if (cb_done && !cb_done(ep, tsp, p)) {
5387 			(*pos)++;
5388 			sctp_endpoint_put(ep);
5389 			sctp_transport_put(tsp);
5390 			goto again;
5391 		}
5392 		sctp_endpoint_put(ep);
5393 		sctp_transport_put(tsp);
5394 	}
5395 
5396 	return ret;
5397 }
5398 EXPORT_SYMBOL_GPL(sctp_transport_traverse_process);
5399 
5400 /* 7.2.1 Association Status (SCTP_STATUS)
5401 
5402  * Applications can retrieve current status information about an
5403  * association, including association state, peer receiver window size,
5404  * number of unacked data chunks, and number of data chunks pending
5405  * receipt.  This information is read-only.
5406  */
sctp_getsockopt_sctp_status(struct sock * sk,int len,char __user * optval,int __user * optlen)5407 static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
5408 				       char __user *optval,
5409 				       int __user *optlen)
5410 {
5411 	struct sctp_status status;
5412 	struct sctp_association *asoc = NULL;
5413 	struct sctp_transport *transport;
5414 	sctp_assoc_t associd;
5415 	int retval = 0;
5416 
5417 	if (len < sizeof(status)) {
5418 		retval = -EINVAL;
5419 		goto out;
5420 	}
5421 
5422 	len = sizeof(status);
5423 	if (copy_from_user(&status, optval, len)) {
5424 		retval = -EFAULT;
5425 		goto out;
5426 	}
5427 
5428 	associd = status.sstat_assoc_id;
5429 	asoc = sctp_id2assoc(sk, associd);
5430 	if (!asoc) {
5431 		retval = -EINVAL;
5432 		goto out;
5433 	}
5434 
5435 	transport = asoc->peer.primary_path;
5436 
5437 	status.sstat_assoc_id = sctp_assoc2id(asoc);
5438 	status.sstat_state = sctp_assoc_to_state(asoc);
5439 	status.sstat_rwnd =  asoc->peer.rwnd;
5440 	status.sstat_unackdata = asoc->unack_data;
5441 
5442 	status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5443 	status.sstat_instrms = asoc->stream.incnt;
5444 	status.sstat_outstrms = asoc->stream.outcnt;
5445 	status.sstat_fragmentation_point = asoc->frag_point;
5446 	status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5447 	memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
5448 			transport->af_specific->sockaddr_len);
5449 	/* Map ipv4 address into v4-mapped-on-v6 address.  */
5450 	sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
5451 		(union sctp_addr *)&status.sstat_primary.spinfo_address);
5452 	status.sstat_primary.spinfo_state = transport->state;
5453 	status.sstat_primary.spinfo_cwnd = transport->cwnd;
5454 	status.sstat_primary.spinfo_srtt = transport->srtt;
5455 	status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
5456 	status.sstat_primary.spinfo_mtu = transport->pathmtu;
5457 
5458 	if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
5459 		status.sstat_primary.spinfo_state = SCTP_ACTIVE;
5460 
5461 	if (put_user(len, optlen)) {
5462 		retval = -EFAULT;
5463 		goto out;
5464 	}
5465 
5466 	pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5467 		 __func__, len, status.sstat_state, status.sstat_rwnd,
5468 		 status.sstat_assoc_id);
5469 
5470 	if (copy_to_user(optval, &status, len)) {
5471 		retval = -EFAULT;
5472 		goto out;
5473 	}
5474 
5475 out:
5476 	return retval;
5477 }
5478 
5479 
5480 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5481  *
5482  * Applications can retrieve information about a specific peer address
5483  * of an association, including its reachability state, congestion
5484  * window, and retransmission timer values.  This information is
5485  * read-only.
5486  */
sctp_getsockopt_peer_addr_info(struct sock * sk,int len,char __user * optval,int __user * optlen)5487 static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
5488 					  char __user *optval,
5489 					  int __user *optlen)
5490 {
5491 	struct sctp_paddrinfo pinfo;
5492 	struct sctp_transport *transport;
5493 	int retval = 0;
5494 
5495 	if (len < sizeof(pinfo)) {
5496 		retval = -EINVAL;
5497 		goto out;
5498 	}
5499 
5500 	len = sizeof(pinfo);
5501 	if (copy_from_user(&pinfo, optval, len)) {
5502 		retval = -EFAULT;
5503 		goto out;
5504 	}
5505 
5506 	transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
5507 					   pinfo.spinfo_assoc_id);
5508 	if (!transport) {
5509 		retval = -EINVAL;
5510 		goto out;
5511 	}
5512 
5513 	if (transport->state == SCTP_PF &&
5514 	    transport->asoc->pf_expose == SCTP_PF_EXPOSE_DISABLE) {
5515 		retval = -EACCES;
5516 		goto out;
5517 	}
5518 
5519 	pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5520 	pinfo.spinfo_state = transport->state;
5521 	pinfo.spinfo_cwnd = transport->cwnd;
5522 	pinfo.spinfo_srtt = transport->srtt;
5523 	pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
5524 	pinfo.spinfo_mtu = transport->pathmtu;
5525 
5526 	if (pinfo.spinfo_state == SCTP_UNKNOWN)
5527 		pinfo.spinfo_state = SCTP_ACTIVE;
5528 
5529 	if (put_user(len, optlen)) {
5530 		retval = -EFAULT;
5531 		goto out;
5532 	}
5533 
5534 	if (copy_to_user(optval, &pinfo, len)) {
5535 		retval = -EFAULT;
5536 		goto out;
5537 	}
5538 
5539 out:
5540 	return retval;
5541 }
5542 
5543 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5544  *
5545  * This option is a on/off flag.  If enabled no SCTP message
5546  * fragmentation will be performed.  Instead if a message being sent
5547  * exceeds the current PMTU size, the message will NOT be sent and
5548  * instead a error will be indicated to the user.
5549  */
sctp_getsockopt_disable_fragments(struct sock * sk,int len,char __user * optval,int __user * optlen)5550 static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
5551 					char __user *optval, int __user *optlen)
5552 {
5553 	int val;
5554 
5555 	if (len < sizeof(int))
5556 		return -EINVAL;
5557 
5558 	len = sizeof(int);
5559 	val = (sctp_sk(sk)->disable_fragments == 1);
5560 	if (put_user(len, optlen))
5561 		return -EFAULT;
5562 	if (copy_to_user(optval, &val, len))
5563 		return -EFAULT;
5564 	return 0;
5565 }
5566 
5567 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5568  *
5569  * This socket option is used to specify various notifications and
5570  * ancillary data the user wishes to receive.
5571  */
sctp_getsockopt_events(struct sock * sk,int len,char __user * optval,int __user * optlen)5572 static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
5573 				  int __user *optlen)
5574 {
5575 	struct sctp_event_subscribe subscribe;
5576 	__u8 *sn_type = (__u8 *)&subscribe;
5577 	int i;
5578 
5579 	if (len == 0)
5580 		return -EINVAL;
5581 	if (len > sizeof(struct sctp_event_subscribe))
5582 		len = sizeof(struct sctp_event_subscribe);
5583 	if (put_user(len, optlen))
5584 		return -EFAULT;
5585 
5586 	for (i = 0; i < len; i++)
5587 		sn_type[i] = sctp_ulpevent_type_enabled(sctp_sk(sk)->subscribe,
5588 							SCTP_SN_TYPE_BASE + i);
5589 
5590 	if (copy_to_user(optval, &subscribe, len))
5591 		return -EFAULT;
5592 
5593 	return 0;
5594 }
5595 
5596 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5597  *
5598  * This socket option is applicable to the UDP-style socket only.  When
5599  * set it will cause associations that are idle for more than the
5600  * specified number of seconds to automatically close.  An association
5601  * being idle is defined an association that has NOT sent or received
5602  * user data.  The special value of '0' indicates that no automatic
5603  * close of any associations should be performed.  The option expects an
5604  * integer defining the number of seconds of idle time before an
5605  * association is closed.
5606  */
sctp_getsockopt_autoclose(struct sock * sk,int len,char __user * optval,int __user * optlen)5607 static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
5608 {
5609 	/* Applicable to UDP-style socket only */
5610 	if (sctp_style(sk, TCP))
5611 		return -EOPNOTSUPP;
5612 	if (len < sizeof(int))
5613 		return -EINVAL;
5614 	len = sizeof(int);
5615 	if (put_user(len, optlen))
5616 		return -EFAULT;
5617 	if (put_user(sctp_sk(sk)->autoclose, (int __user *)optval))
5618 		return -EFAULT;
5619 	return 0;
5620 }
5621 
5622 /* Helper routine to branch off an association to a new socket.  */
sctp_do_peeloff(struct sock * sk,sctp_assoc_t id,struct socket ** sockp)5623 int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp)
5624 {
5625 	struct sctp_association *asoc = sctp_id2assoc(sk, id);
5626 	struct sctp_sock *sp = sctp_sk(sk);
5627 	struct socket *sock;
5628 	int err = 0;
5629 
5630 	/* Do not peel off from one netns to another one. */
5631 	if (!net_eq(current->nsproxy->net_ns, sock_net(sk)))
5632 		return -EINVAL;
5633 
5634 	if (!asoc)
5635 		return -EINVAL;
5636 
5637 	/* An association cannot be branched off from an already peeled-off
5638 	 * socket, nor is this supported for tcp style sockets.
5639 	 */
5640 	if (!sctp_style(sk, UDP))
5641 		return -EINVAL;
5642 
5643 	/* Create a new socket.  */
5644 	err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
5645 	if (err < 0)
5646 		return err;
5647 
5648 	sctp_copy_sock(sock->sk, sk, asoc);
5649 
5650 	/* Make peeled-off sockets more like 1-1 accepted sockets.
5651 	 * Set the daddr and initialize id to something more random and also
5652 	 * copy over any ip options.
5653 	 */
5654 	sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sock->sk);
5655 	sp->pf->copy_ip_options(sk, sock->sk);
5656 
5657 	/* Populate the fields of the newsk from the oldsk and migrate the
5658 	 * asoc to the newsk.
5659 	 */
5660 	err = sctp_sock_migrate(sk, sock->sk, asoc,
5661 				SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
5662 	if (err) {
5663 		sock_release(sock);
5664 		sock = NULL;
5665 	}
5666 
5667 	*sockp = sock;
5668 
5669 	return err;
5670 }
5671 EXPORT_SYMBOL(sctp_do_peeloff);
5672 
sctp_getsockopt_peeloff_common(struct sock * sk,sctp_peeloff_arg_t * peeloff,struct file ** newfile,unsigned flags)5673 static int sctp_getsockopt_peeloff_common(struct sock *sk, sctp_peeloff_arg_t *peeloff,
5674 					  struct file **newfile, unsigned flags)
5675 {
5676 	struct socket *newsock;
5677 	int retval;
5678 
5679 	retval = sctp_do_peeloff(sk, peeloff->associd, &newsock);
5680 	if (retval < 0)
5681 		goto out;
5682 
5683 	/* Map the socket to an unused fd that can be returned to the user.  */
5684 	retval = get_unused_fd_flags(flags & SOCK_CLOEXEC);
5685 	if (retval < 0) {
5686 		sock_release(newsock);
5687 		goto out;
5688 	}
5689 
5690 	*newfile = sock_alloc_file(newsock, 0, NULL);
5691 	if (IS_ERR(*newfile)) {
5692 		put_unused_fd(retval);
5693 		retval = PTR_ERR(*newfile);
5694 		*newfile = NULL;
5695 		return retval;
5696 	}
5697 
5698 	pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__, sk, newsock->sk,
5699 		 retval);
5700 
5701 	peeloff->sd = retval;
5702 
5703 	if (flags & SOCK_NONBLOCK)
5704 		(*newfile)->f_flags |= O_NONBLOCK;
5705 out:
5706 	return retval;
5707 }
5708 
sctp_getsockopt_peeloff(struct sock * sk,int len,char __user * optval,int __user * optlen)5709 static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
5710 {
5711 	sctp_peeloff_arg_t peeloff;
5712 	struct file *newfile = NULL;
5713 	int retval = 0;
5714 
5715 	if (len < sizeof(sctp_peeloff_arg_t))
5716 		return -EINVAL;
5717 	len = sizeof(sctp_peeloff_arg_t);
5718 	if (copy_from_user(&peeloff, optval, len))
5719 		return -EFAULT;
5720 
5721 	retval = sctp_getsockopt_peeloff_common(sk, &peeloff, &newfile, 0);
5722 	if (retval < 0)
5723 		goto out;
5724 
5725 	/* Return the fd mapped to the new socket.  */
5726 	if (put_user(len, optlen)) {
5727 		fput(newfile);
5728 		put_unused_fd(retval);
5729 		return -EFAULT;
5730 	}
5731 
5732 	if (copy_to_user(optval, &peeloff, len)) {
5733 		fput(newfile);
5734 		put_unused_fd(retval);
5735 		return -EFAULT;
5736 	}
5737 	fd_install(retval, newfile);
5738 out:
5739 	return retval;
5740 }
5741 
sctp_getsockopt_peeloff_flags(struct sock * sk,int len,char __user * optval,int __user * optlen)5742 static int sctp_getsockopt_peeloff_flags(struct sock *sk, int len,
5743 					 char __user *optval, int __user *optlen)
5744 {
5745 	sctp_peeloff_flags_arg_t peeloff;
5746 	struct file *newfile = NULL;
5747 	int retval = 0;
5748 
5749 	if (len < sizeof(sctp_peeloff_flags_arg_t))
5750 		return -EINVAL;
5751 	len = sizeof(sctp_peeloff_flags_arg_t);
5752 	if (copy_from_user(&peeloff, optval, len))
5753 		return -EFAULT;
5754 
5755 	retval = sctp_getsockopt_peeloff_common(sk, &peeloff.p_arg,
5756 						&newfile, peeloff.flags);
5757 	if (retval < 0)
5758 		goto out;
5759 
5760 	/* Return the fd mapped to the new socket.  */
5761 	if (put_user(len, optlen)) {
5762 		fput(newfile);
5763 		put_unused_fd(retval);
5764 		return -EFAULT;
5765 	}
5766 
5767 	if (copy_to_user(optval, &peeloff, len)) {
5768 		fput(newfile);
5769 		put_unused_fd(retval);
5770 		return -EFAULT;
5771 	}
5772 	fd_install(retval, newfile);
5773 out:
5774 	return retval;
5775 }
5776 
5777 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5778  *
5779  * Applications can enable or disable heartbeats for any peer address of
5780  * an association, modify an address's heartbeat interval, force a
5781  * heartbeat to be sent immediately, and adjust the address's maximum
5782  * number of retransmissions sent before an address is considered
5783  * unreachable.  The following structure is used to access and modify an
5784  * address's parameters:
5785  *
5786  *  struct sctp_paddrparams {
5787  *     sctp_assoc_t            spp_assoc_id;
5788  *     struct sockaddr_storage spp_address;
5789  *     uint32_t                spp_hbinterval;
5790  *     uint16_t                spp_pathmaxrxt;
5791  *     uint32_t                spp_pathmtu;
5792  *     uint32_t                spp_sackdelay;
5793  *     uint32_t                spp_flags;
5794  * };
5795  *
5796  *   spp_assoc_id    - (one-to-many style socket) This is filled in the
5797  *                     application, and identifies the association for
5798  *                     this query.
5799  *   spp_address     - This specifies which address is of interest.
5800  *   spp_hbinterval  - This contains the value of the heartbeat interval,
5801  *                     in milliseconds.  If a  value of zero
5802  *                     is present in this field then no changes are to
5803  *                     be made to this parameter.
5804  *   spp_pathmaxrxt  - This contains the maximum number of
5805  *                     retransmissions before this address shall be
5806  *                     considered unreachable. If a  value of zero
5807  *                     is present in this field then no changes are to
5808  *                     be made to this parameter.
5809  *   spp_pathmtu     - When Path MTU discovery is disabled the value
5810  *                     specified here will be the "fixed" path mtu.
5811  *                     Note that if the spp_address field is empty
5812  *                     then all associations on this address will
5813  *                     have this fixed path mtu set upon them.
5814  *
5815  *   spp_sackdelay   - When delayed sack is enabled, this value specifies
5816  *                     the number of milliseconds that sacks will be delayed
5817  *                     for. This value will apply to all addresses of an
5818  *                     association if the spp_address field is empty. Note
5819  *                     also, that if delayed sack is enabled and this
5820  *                     value is set to 0, no change is made to the last
5821  *                     recorded delayed sack timer value.
5822  *
5823  *   spp_flags       - These flags are used to control various features
5824  *                     on an association. The flag field may contain
5825  *                     zero or more of the following options.
5826  *
5827  *                     SPP_HB_ENABLE  - Enable heartbeats on the
5828  *                     specified address. Note that if the address
5829  *                     field is empty all addresses for the association
5830  *                     have heartbeats enabled upon them.
5831  *
5832  *                     SPP_HB_DISABLE - Disable heartbeats on the
5833  *                     speicifed address. Note that if the address
5834  *                     field is empty all addresses for the association
5835  *                     will have their heartbeats disabled. Note also
5836  *                     that SPP_HB_ENABLE and SPP_HB_DISABLE are
5837  *                     mutually exclusive, only one of these two should
5838  *                     be specified. Enabling both fields will have
5839  *                     undetermined results.
5840  *
5841  *                     SPP_HB_DEMAND - Request a user initiated heartbeat
5842  *                     to be made immediately.
5843  *
5844  *                     SPP_PMTUD_ENABLE - This field will enable PMTU
5845  *                     discovery upon the specified address. Note that
5846  *                     if the address feild is empty then all addresses
5847  *                     on the association are effected.
5848  *
5849  *                     SPP_PMTUD_DISABLE - This field will disable PMTU
5850  *                     discovery upon the specified address. Note that
5851  *                     if the address feild is empty then all addresses
5852  *                     on the association are effected. Not also that
5853  *                     SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5854  *                     exclusive. Enabling both will have undetermined
5855  *                     results.
5856  *
5857  *                     SPP_SACKDELAY_ENABLE - Setting this flag turns
5858  *                     on delayed sack. The time specified in spp_sackdelay
5859  *                     is used to specify the sack delay for this address. Note
5860  *                     that if spp_address is empty then all addresses will
5861  *                     enable delayed sack and take on the sack delay
5862  *                     value specified in spp_sackdelay.
5863  *                     SPP_SACKDELAY_DISABLE - Setting this flag turns
5864  *                     off delayed sack. If the spp_address field is blank then
5865  *                     delayed sack is disabled for the entire association. Note
5866  *                     also that this field is mutually exclusive to
5867  *                     SPP_SACKDELAY_ENABLE, setting both will have undefined
5868  *                     results.
5869  *
5870  *                     SPP_IPV6_FLOWLABEL:  Setting this flag enables the
5871  *                     setting of the IPV6 flow label value.  The value is
5872  *                     contained in the spp_ipv6_flowlabel field.
5873  *                     Upon retrieval, this flag will be set to indicate that
5874  *                     the spp_ipv6_flowlabel field has a valid value returned.
5875  *                     If a specific destination address is set (in the
5876  *                     spp_address field), then the value returned is that of
5877  *                     the address.  If just an association is specified (and
5878  *                     no address), then the association's default flow label
5879  *                     is returned.  If neither an association nor a destination
5880  *                     is specified, then the socket's default flow label is
5881  *                     returned.  For non-IPv6 sockets, this flag will be left
5882  *                     cleared.
5883  *
5884  *                     SPP_DSCP:  Setting this flag enables the setting of the
5885  *                     Differentiated Services Code Point (DSCP) value
5886  *                     associated with either the association or a specific
5887  *                     address.  The value is obtained in the spp_dscp field.
5888  *                     Upon retrieval, this flag will be set to indicate that
5889  *                     the spp_dscp field has a valid value returned.  If a
5890  *                     specific destination address is set when called (in the
5891  *                     spp_address field), then that specific destination
5892  *                     address's DSCP value is returned.  If just an association
5893  *                     is specified, then the association's default DSCP is
5894  *                     returned.  If neither an association nor a destination is
5895  *                     specified, then the socket's default DSCP is returned.
5896  *
5897  *   spp_ipv6_flowlabel
5898  *                   - This field is used in conjunction with the
5899  *                     SPP_IPV6_FLOWLABEL flag and contains the IPv6 flow label.
5900  *                     The 20 least significant bits are used for the flow
5901  *                     label.  This setting has precedence over any IPv6-layer
5902  *                     setting.
5903  *
5904  *   spp_dscp        - This field is used in conjunction with the SPP_DSCP flag
5905  *                     and contains the DSCP.  The 6 most significant bits are
5906  *                     used for the DSCP.  This setting has precedence over any
5907  *                     IPv4- or IPv6- layer setting.
5908  */
sctp_getsockopt_peer_addr_params(struct sock * sk,int len,char __user * optval,int __user * optlen)5909 static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
5910 					    char __user *optval, int __user *optlen)
5911 {
5912 	struct sctp_paddrparams  params;
5913 	struct sctp_transport   *trans = NULL;
5914 	struct sctp_association *asoc = NULL;
5915 	struct sctp_sock        *sp = sctp_sk(sk);
5916 
5917 	if (len >= sizeof(params))
5918 		len = sizeof(params);
5919 	else if (len >= ALIGN(offsetof(struct sctp_paddrparams,
5920 				       spp_ipv6_flowlabel), 4))
5921 		len = ALIGN(offsetof(struct sctp_paddrparams,
5922 				     spp_ipv6_flowlabel), 4);
5923 	else
5924 		return -EINVAL;
5925 
5926 	if (copy_from_user(&params, optval, len))
5927 		return -EFAULT;
5928 
5929 	/* If an address other than INADDR_ANY is specified, and
5930 	 * no transport is found, then the request is invalid.
5931 	 */
5932 	if (!sctp_is_any(sk, (union sctp_addr *)&params.spp_address)) {
5933 		trans = sctp_addr_id2transport(sk, &params.spp_address,
5934 					       params.spp_assoc_id);
5935 		if (!trans) {
5936 			pr_debug("%s: failed no transport\n", __func__);
5937 			return -EINVAL;
5938 		}
5939 	}
5940 
5941 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
5942 	 * socket is a one to many style socket, and an association
5943 	 * was not found, then the id was invalid.
5944 	 */
5945 	asoc = sctp_id2assoc(sk, params.spp_assoc_id);
5946 	if (!asoc && params.spp_assoc_id != SCTP_FUTURE_ASSOC &&
5947 	    sctp_style(sk, UDP)) {
5948 		pr_debug("%s: failed no association\n", __func__);
5949 		return -EINVAL;
5950 	}
5951 
5952 	if (trans) {
5953 		/* Fetch transport values. */
5954 		params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
5955 		params.spp_pathmtu    = trans->pathmtu;
5956 		params.spp_pathmaxrxt = trans->pathmaxrxt;
5957 		params.spp_sackdelay  = jiffies_to_msecs(trans->sackdelay);
5958 
5959 		/*draft-11 doesn't say what to return in spp_flags*/
5960 		params.spp_flags      = trans->param_flags;
5961 		if (trans->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5962 			params.spp_ipv6_flowlabel = trans->flowlabel &
5963 						    SCTP_FLOWLABEL_VAL_MASK;
5964 			params.spp_flags |= SPP_IPV6_FLOWLABEL;
5965 		}
5966 		if (trans->dscp & SCTP_DSCP_SET_MASK) {
5967 			params.spp_dscp	= trans->dscp & SCTP_DSCP_VAL_MASK;
5968 			params.spp_flags |= SPP_DSCP;
5969 		}
5970 	} else if (asoc) {
5971 		/* Fetch association values. */
5972 		params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
5973 		params.spp_pathmtu    = asoc->pathmtu;
5974 		params.spp_pathmaxrxt = asoc->pathmaxrxt;
5975 		params.spp_sackdelay  = jiffies_to_msecs(asoc->sackdelay);
5976 
5977 		/*draft-11 doesn't say what to return in spp_flags*/
5978 		params.spp_flags      = asoc->param_flags;
5979 		if (asoc->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5980 			params.spp_ipv6_flowlabel = asoc->flowlabel &
5981 						    SCTP_FLOWLABEL_VAL_MASK;
5982 			params.spp_flags |= SPP_IPV6_FLOWLABEL;
5983 		}
5984 		if (asoc->dscp & SCTP_DSCP_SET_MASK) {
5985 			params.spp_dscp	= asoc->dscp & SCTP_DSCP_VAL_MASK;
5986 			params.spp_flags |= SPP_DSCP;
5987 		}
5988 	} else {
5989 		/* Fetch socket values. */
5990 		params.spp_hbinterval = sp->hbinterval;
5991 		params.spp_pathmtu    = sp->pathmtu;
5992 		params.spp_sackdelay  = sp->sackdelay;
5993 		params.spp_pathmaxrxt = sp->pathmaxrxt;
5994 
5995 		/*draft-11 doesn't say what to return in spp_flags*/
5996 		params.spp_flags      = sp->param_flags;
5997 		if (sp->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5998 			params.spp_ipv6_flowlabel = sp->flowlabel &
5999 						    SCTP_FLOWLABEL_VAL_MASK;
6000 			params.spp_flags |= SPP_IPV6_FLOWLABEL;
6001 		}
6002 		if (sp->dscp & SCTP_DSCP_SET_MASK) {
6003 			params.spp_dscp	= sp->dscp & SCTP_DSCP_VAL_MASK;
6004 			params.spp_flags |= SPP_DSCP;
6005 		}
6006 	}
6007 
6008 	if (copy_to_user(optval, &params, len))
6009 		return -EFAULT;
6010 
6011 	if (put_user(len, optlen))
6012 		return -EFAULT;
6013 
6014 	return 0;
6015 }
6016 
6017 /*
6018  * 7.1.23.  Get or set delayed ack timer (SCTP_DELAYED_SACK)
6019  *
6020  * This option will effect the way delayed acks are performed.  This
6021  * option allows you to get or set the delayed ack time, in
6022  * milliseconds.  It also allows changing the delayed ack frequency.
6023  * Changing the frequency to 1 disables the delayed sack algorithm.  If
6024  * the assoc_id is 0, then this sets or gets the endpoints default
6025  * values.  If the assoc_id field is non-zero, then the set or get
6026  * effects the specified association for the one to many model (the
6027  * assoc_id field is ignored by the one to one model).  Note that if
6028  * sack_delay or sack_freq are 0 when setting this option, then the
6029  * current values will remain unchanged.
6030  *
6031  * struct sctp_sack_info {
6032  *     sctp_assoc_t            sack_assoc_id;
6033  *     uint32_t                sack_delay;
6034  *     uint32_t                sack_freq;
6035  * };
6036  *
6037  * sack_assoc_id -  This parameter, indicates which association the user
6038  *    is performing an action upon.  Note that if this field's value is
6039  *    zero then the endpoints default value is changed (effecting future
6040  *    associations only).
6041  *
6042  * sack_delay -  This parameter contains the number of milliseconds that
6043  *    the user is requesting the delayed ACK timer be set to.  Note that
6044  *    this value is defined in the standard to be between 200 and 500
6045  *    milliseconds.
6046  *
6047  * sack_freq -  This parameter contains the number of packets that must
6048  *    be received before a sack is sent without waiting for the delay
6049  *    timer to expire.  The default value for this is 2, setting this
6050  *    value to 1 will disable the delayed sack algorithm.
6051  */
sctp_getsockopt_delayed_ack(struct sock * sk,int len,char __user * optval,int __user * optlen)6052 static int sctp_getsockopt_delayed_ack(struct sock *sk, int len,
6053 					    char __user *optval,
6054 					    int __user *optlen)
6055 {
6056 	struct sctp_sack_info    params;
6057 	struct sctp_association *asoc = NULL;
6058 	struct sctp_sock        *sp = sctp_sk(sk);
6059 
6060 	if (len >= sizeof(struct sctp_sack_info)) {
6061 		len = sizeof(struct sctp_sack_info);
6062 
6063 		if (copy_from_user(&params, optval, len))
6064 			return -EFAULT;
6065 	} else if (len == sizeof(struct sctp_assoc_value)) {
6066 		pr_warn_ratelimited(DEPRECATED
6067 				    "%s (pid %d) "
6068 				    "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
6069 				    "Use struct sctp_sack_info instead\n",
6070 				    current->comm, task_pid_nr(current));
6071 		if (copy_from_user(&params, optval, len))
6072 			return -EFAULT;
6073 	} else
6074 		return -EINVAL;
6075 
6076 	/* Get association, if sack_assoc_id != SCTP_FUTURE_ASSOC and the
6077 	 * socket is a one to many style socket, and an association
6078 	 * was not found, then the id was invalid.
6079 	 */
6080 	asoc = sctp_id2assoc(sk, params.sack_assoc_id);
6081 	if (!asoc && params.sack_assoc_id != SCTP_FUTURE_ASSOC &&
6082 	    sctp_style(sk, UDP))
6083 		return -EINVAL;
6084 
6085 	if (asoc) {
6086 		/* Fetch association values. */
6087 		if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
6088 			params.sack_delay = jiffies_to_msecs(asoc->sackdelay);
6089 			params.sack_freq = asoc->sackfreq;
6090 
6091 		} else {
6092 			params.sack_delay = 0;
6093 			params.sack_freq = 1;
6094 		}
6095 	} else {
6096 		/* Fetch socket values. */
6097 		if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
6098 			params.sack_delay  = sp->sackdelay;
6099 			params.sack_freq = sp->sackfreq;
6100 		} else {
6101 			params.sack_delay  = 0;
6102 			params.sack_freq = 1;
6103 		}
6104 	}
6105 
6106 	if (copy_to_user(optval, &params, len))
6107 		return -EFAULT;
6108 
6109 	if (put_user(len, optlen))
6110 		return -EFAULT;
6111 
6112 	return 0;
6113 }
6114 
6115 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
6116  *
6117  * Applications can specify protocol parameters for the default association
6118  * initialization.  The option name argument to setsockopt() and getsockopt()
6119  * is SCTP_INITMSG.
6120  *
6121  * Setting initialization parameters is effective only on an unconnected
6122  * socket (for UDP-style sockets only future associations are effected
6123  * by the change).  With TCP-style sockets, this option is inherited by
6124  * sockets derived from a listener socket.
6125  */
sctp_getsockopt_initmsg(struct sock * sk,int len,char __user * optval,int __user * optlen)6126 static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
6127 {
6128 	if (len < sizeof(struct sctp_initmsg))
6129 		return -EINVAL;
6130 	len = sizeof(struct sctp_initmsg);
6131 	if (put_user(len, optlen))
6132 		return -EFAULT;
6133 	if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
6134 		return -EFAULT;
6135 	return 0;
6136 }
6137 
6138 
sctp_getsockopt_peer_addrs(struct sock * sk,int len,char __user * optval,int __user * optlen)6139 static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
6140 				      char __user *optval, int __user *optlen)
6141 {
6142 	struct sctp_association *asoc;
6143 	int cnt = 0;
6144 	struct sctp_getaddrs getaddrs;
6145 	struct sctp_transport *from;
6146 	void __user *to;
6147 	union sctp_addr temp;
6148 	struct sctp_sock *sp = sctp_sk(sk);
6149 	int addrlen;
6150 	size_t space_left;
6151 	int bytes_copied;
6152 
6153 	if (len < sizeof(struct sctp_getaddrs))
6154 		return -EINVAL;
6155 
6156 	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6157 		return -EFAULT;
6158 
6159 	/* For UDP-style sockets, id specifies the association to query.  */
6160 	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6161 	if (!asoc)
6162 		return -EINVAL;
6163 
6164 	to = optval + offsetof(struct sctp_getaddrs, addrs);
6165 	space_left = len - offsetof(struct sctp_getaddrs, addrs);
6166 
6167 	list_for_each_entry(from, &asoc->peer.transport_addr_list,
6168 				transports) {
6169 		memcpy(&temp, &from->ipaddr, sizeof(temp));
6170 		addrlen = sctp_get_pf_specific(sk->sk_family)
6171 			      ->addr_to_user(sp, &temp);
6172 		if (space_left < addrlen)
6173 			return -ENOMEM;
6174 		if (copy_to_user(to, &temp, addrlen))
6175 			return -EFAULT;
6176 		to += addrlen;
6177 		cnt++;
6178 		space_left -= addrlen;
6179 	}
6180 
6181 	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
6182 		return -EFAULT;
6183 	bytes_copied = ((char __user *)to) - optval;
6184 	if (put_user(bytes_copied, optlen))
6185 		return -EFAULT;
6186 
6187 	return 0;
6188 }
6189 
sctp_copy_laddrs(struct sock * sk,__u16 port,void * to,size_t space_left,int * bytes_copied)6190 static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
6191 			    size_t space_left, int *bytes_copied)
6192 {
6193 	struct sctp_sockaddr_entry *addr;
6194 	union sctp_addr temp;
6195 	int cnt = 0;
6196 	int addrlen;
6197 	struct net *net = sock_net(sk);
6198 
6199 	rcu_read_lock();
6200 	list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
6201 		if (!addr->valid)
6202 			continue;
6203 
6204 		if ((PF_INET == sk->sk_family) &&
6205 		    (AF_INET6 == addr->a.sa.sa_family))
6206 			continue;
6207 		if ((PF_INET6 == sk->sk_family) &&
6208 		    inet_v6_ipv6only(sk) &&
6209 		    (AF_INET == addr->a.sa.sa_family))
6210 			continue;
6211 		memcpy(&temp, &addr->a, sizeof(temp));
6212 		if (!temp.v4.sin_port)
6213 			temp.v4.sin_port = htons(port);
6214 
6215 		addrlen = sctp_get_pf_specific(sk->sk_family)
6216 			      ->addr_to_user(sctp_sk(sk), &temp);
6217 
6218 		if (space_left < addrlen) {
6219 			cnt =  -ENOMEM;
6220 			break;
6221 		}
6222 		memcpy(to, &temp, addrlen);
6223 
6224 		to += addrlen;
6225 		cnt++;
6226 		space_left -= addrlen;
6227 		*bytes_copied += addrlen;
6228 	}
6229 	rcu_read_unlock();
6230 
6231 	return cnt;
6232 }
6233 
6234 
sctp_getsockopt_local_addrs(struct sock * sk,int len,char __user * optval,int __user * optlen)6235 static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
6236 				       char __user *optval, int __user *optlen)
6237 {
6238 	struct sctp_bind_addr *bp;
6239 	struct sctp_association *asoc;
6240 	int cnt = 0;
6241 	struct sctp_getaddrs getaddrs;
6242 	struct sctp_sockaddr_entry *addr;
6243 	void __user *to;
6244 	union sctp_addr temp;
6245 	struct sctp_sock *sp = sctp_sk(sk);
6246 	int addrlen;
6247 	int err = 0;
6248 	size_t space_left;
6249 	int bytes_copied = 0;
6250 	void *addrs;
6251 	void *buf;
6252 
6253 	if (len < sizeof(struct sctp_getaddrs))
6254 		return -EINVAL;
6255 
6256 	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6257 		return -EFAULT;
6258 
6259 	/*
6260 	 *  For UDP-style sockets, id specifies the association to query.
6261 	 *  If the id field is set to the value '0' then the locally bound
6262 	 *  addresses are returned without regard to any particular
6263 	 *  association.
6264 	 */
6265 	if (0 == getaddrs.assoc_id) {
6266 		bp = &sctp_sk(sk)->ep->base.bind_addr;
6267 	} else {
6268 		asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6269 		if (!asoc)
6270 			return -EINVAL;
6271 		bp = &asoc->base.bind_addr;
6272 	}
6273 
6274 	to = optval + offsetof(struct sctp_getaddrs, addrs);
6275 	space_left = len - offsetof(struct sctp_getaddrs, addrs);
6276 
6277 	addrs = kmalloc(space_left, GFP_USER | __GFP_NOWARN);
6278 	if (!addrs)
6279 		return -ENOMEM;
6280 
6281 	/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
6282 	 * addresses from the global local address list.
6283 	 */
6284 	if (sctp_list_single_entry(&bp->address_list)) {
6285 		addr = list_entry(bp->address_list.next,
6286 				  struct sctp_sockaddr_entry, list);
6287 		if (sctp_is_any(sk, &addr->a)) {
6288 			cnt = sctp_copy_laddrs(sk, bp->port, addrs,
6289 						space_left, &bytes_copied);
6290 			if (cnt < 0) {
6291 				err = cnt;
6292 				goto out;
6293 			}
6294 			goto copy_getaddrs;
6295 		}
6296 	}
6297 
6298 	buf = addrs;
6299 	/* Protection on the bound address list is not needed since
6300 	 * in the socket option context we hold a socket lock and
6301 	 * thus the bound address list can't change.
6302 	 */
6303 	list_for_each_entry(addr, &bp->address_list, list) {
6304 		memcpy(&temp, &addr->a, sizeof(temp));
6305 		addrlen = sctp_get_pf_specific(sk->sk_family)
6306 			      ->addr_to_user(sp, &temp);
6307 		if (space_left < addrlen) {
6308 			err =  -ENOMEM; /*fixme: right error?*/
6309 			goto out;
6310 		}
6311 		memcpy(buf, &temp, addrlen);
6312 		buf += addrlen;
6313 		bytes_copied += addrlen;
6314 		cnt++;
6315 		space_left -= addrlen;
6316 	}
6317 
6318 copy_getaddrs:
6319 	if (copy_to_user(to, addrs, bytes_copied)) {
6320 		err = -EFAULT;
6321 		goto out;
6322 	}
6323 	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
6324 		err = -EFAULT;
6325 		goto out;
6326 	}
6327 	/* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
6328 	 * but we can't change it anymore.
6329 	 */
6330 	if (put_user(bytes_copied, optlen))
6331 		err = -EFAULT;
6332 out:
6333 	kfree(addrs);
6334 	return err;
6335 }
6336 
6337 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
6338  *
6339  * Requests that the local SCTP stack use the enclosed peer address as
6340  * the association primary.  The enclosed address must be one of the
6341  * association peer's addresses.
6342  */
sctp_getsockopt_primary_addr(struct sock * sk,int len,char __user * optval,int __user * optlen)6343 static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
6344 					char __user *optval, int __user *optlen)
6345 {
6346 	struct sctp_prim prim;
6347 	struct sctp_association *asoc;
6348 	struct sctp_sock *sp = sctp_sk(sk);
6349 
6350 	if (len < sizeof(struct sctp_prim))
6351 		return -EINVAL;
6352 
6353 	len = sizeof(struct sctp_prim);
6354 
6355 	if (copy_from_user(&prim, optval, len))
6356 		return -EFAULT;
6357 
6358 	asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
6359 	if (!asoc)
6360 		return -EINVAL;
6361 
6362 	if (!asoc->peer.primary_path)
6363 		return -ENOTCONN;
6364 
6365 	memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
6366 		asoc->peer.primary_path->af_specific->sockaddr_len);
6367 
6368 	sctp_get_pf_specific(sk->sk_family)->addr_to_user(sp,
6369 			(union sctp_addr *)&prim.ssp_addr);
6370 
6371 	if (put_user(len, optlen))
6372 		return -EFAULT;
6373 	if (copy_to_user(optval, &prim, len))
6374 		return -EFAULT;
6375 
6376 	return 0;
6377 }
6378 
6379 /*
6380  * 7.1.11  Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
6381  *
6382  * Requests that the local endpoint set the specified Adaptation Layer
6383  * Indication parameter for all future INIT and INIT-ACK exchanges.
6384  */
sctp_getsockopt_adaptation_layer(struct sock * sk,int len,char __user * optval,int __user * optlen)6385 static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len,
6386 				  char __user *optval, int __user *optlen)
6387 {
6388 	struct sctp_setadaptation adaptation;
6389 
6390 	if (len < sizeof(struct sctp_setadaptation))
6391 		return -EINVAL;
6392 
6393 	len = sizeof(struct sctp_setadaptation);
6394 
6395 	adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
6396 
6397 	if (put_user(len, optlen))
6398 		return -EFAULT;
6399 	if (copy_to_user(optval, &adaptation, len))
6400 		return -EFAULT;
6401 
6402 	return 0;
6403 }
6404 
6405 /*
6406  *
6407  * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
6408  *
6409  *   Applications that wish to use the sendto() system call may wish to
6410  *   specify a default set of parameters that would normally be supplied
6411  *   through the inclusion of ancillary data.  This socket option allows
6412  *   such an application to set the default sctp_sndrcvinfo structure.
6413 
6414 
6415  *   The application that wishes to use this socket option simply passes
6416  *   in to this call the sctp_sndrcvinfo structure defined in Section
6417  *   5.2.2) The input parameters accepted by this call include
6418  *   sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
6419  *   sinfo_timetolive.  The user must provide the sinfo_assoc_id field in
6420  *   to this call if the caller is using the UDP model.
6421  *
6422  *   For getsockopt, it get the default sctp_sndrcvinfo structure.
6423  */
sctp_getsockopt_default_send_param(struct sock * sk,int len,char __user * optval,int __user * optlen)6424 static int sctp_getsockopt_default_send_param(struct sock *sk,
6425 					int len, char __user *optval,
6426 					int __user *optlen)
6427 {
6428 	struct sctp_sock *sp = sctp_sk(sk);
6429 	struct sctp_association *asoc;
6430 	struct sctp_sndrcvinfo info;
6431 
6432 	if (len < sizeof(info))
6433 		return -EINVAL;
6434 
6435 	len = sizeof(info);
6436 
6437 	if (copy_from_user(&info, optval, len))
6438 		return -EFAULT;
6439 
6440 	asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
6441 	if (!asoc && info.sinfo_assoc_id != SCTP_FUTURE_ASSOC &&
6442 	    sctp_style(sk, UDP))
6443 		return -EINVAL;
6444 
6445 	if (asoc) {
6446 		info.sinfo_stream = asoc->default_stream;
6447 		info.sinfo_flags = asoc->default_flags;
6448 		info.sinfo_ppid = asoc->default_ppid;
6449 		info.sinfo_context = asoc->default_context;
6450 		info.sinfo_timetolive = asoc->default_timetolive;
6451 	} else {
6452 		info.sinfo_stream = sp->default_stream;
6453 		info.sinfo_flags = sp->default_flags;
6454 		info.sinfo_ppid = sp->default_ppid;
6455 		info.sinfo_context = sp->default_context;
6456 		info.sinfo_timetolive = sp->default_timetolive;
6457 	}
6458 
6459 	if (put_user(len, optlen))
6460 		return -EFAULT;
6461 	if (copy_to_user(optval, &info, len))
6462 		return -EFAULT;
6463 
6464 	return 0;
6465 }
6466 
6467 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
6468  * (SCTP_DEFAULT_SNDINFO)
6469  */
sctp_getsockopt_default_sndinfo(struct sock * sk,int len,char __user * optval,int __user * optlen)6470 static int sctp_getsockopt_default_sndinfo(struct sock *sk, int len,
6471 					   char __user *optval,
6472 					   int __user *optlen)
6473 {
6474 	struct sctp_sock *sp = sctp_sk(sk);
6475 	struct sctp_association *asoc;
6476 	struct sctp_sndinfo info;
6477 
6478 	if (len < sizeof(info))
6479 		return -EINVAL;
6480 
6481 	len = sizeof(info);
6482 
6483 	if (copy_from_user(&info, optval, len))
6484 		return -EFAULT;
6485 
6486 	asoc = sctp_id2assoc(sk, info.snd_assoc_id);
6487 	if (!asoc && info.snd_assoc_id != SCTP_FUTURE_ASSOC &&
6488 	    sctp_style(sk, UDP))
6489 		return -EINVAL;
6490 
6491 	if (asoc) {
6492 		info.snd_sid = asoc->default_stream;
6493 		info.snd_flags = asoc->default_flags;
6494 		info.snd_ppid = asoc->default_ppid;
6495 		info.snd_context = asoc->default_context;
6496 	} else {
6497 		info.snd_sid = sp->default_stream;
6498 		info.snd_flags = sp->default_flags;
6499 		info.snd_ppid = sp->default_ppid;
6500 		info.snd_context = sp->default_context;
6501 	}
6502 
6503 	if (put_user(len, optlen))
6504 		return -EFAULT;
6505 	if (copy_to_user(optval, &info, len))
6506 		return -EFAULT;
6507 
6508 	return 0;
6509 }
6510 
6511 /*
6512  *
6513  * 7.1.5 SCTP_NODELAY
6514  *
6515  * Turn on/off any Nagle-like algorithm.  This means that packets are
6516  * generally sent as soon as possible and no unnecessary delays are
6517  * introduced, at the cost of more packets in the network.  Expects an
6518  * integer boolean flag.
6519  */
6520 
sctp_getsockopt_nodelay(struct sock * sk,int len,char __user * optval,int __user * optlen)6521 static int sctp_getsockopt_nodelay(struct sock *sk, int len,
6522 				   char __user *optval, int __user *optlen)
6523 {
6524 	int val;
6525 
6526 	if (len < sizeof(int))
6527 		return -EINVAL;
6528 
6529 	len = sizeof(int);
6530 	val = (sctp_sk(sk)->nodelay == 1);
6531 	if (put_user(len, optlen))
6532 		return -EFAULT;
6533 	if (copy_to_user(optval, &val, len))
6534 		return -EFAULT;
6535 	return 0;
6536 }
6537 
6538 /*
6539  *
6540  * 7.1.1 SCTP_RTOINFO
6541  *
6542  * The protocol parameters used to initialize and bound retransmission
6543  * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
6544  * and modify these parameters.
6545  * All parameters are time values, in milliseconds.  A value of 0, when
6546  * modifying the parameters, indicates that the current value should not
6547  * be changed.
6548  *
6549  */
sctp_getsockopt_rtoinfo(struct sock * sk,int len,char __user * optval,int __user * optlen)6550 static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
6551 				char __user *optval,
6552 				int __user *optlen) {
6553 	struct sctp_rtoinfo rtoinfo;
6554 	struct sctp_association *asoc;
6555 
6556 	if (len < sizeof (struct sctp_rtoinfo))
6557 		return -EINVAL;
6558 
6559 	len = sizeof(struct sctp_rtoinfo);
6560 
6561 	if (copy_from_user(&rtoinfo, optval, len))
6562 		return -EFAULT;
6563 
6564 	asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
6565 
6566 	if (!asoc && rtoinfo.srto_assoc_id != SCTP_FUTURE_ASSOC &&
6567 	    sctp_style(sk, UDP))
6568 		return -EINVAL;
6569 
6570 	/* Values corresponding to the specific association. */
6571 	if (asoc) {
6572 		rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
6573 		rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
6574 		rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
6575 	} else {
6576 		/* Values corresponding to the endpoint. */
6577 		struct sctp_sock *sp = sctp_sk(sk);
6578 
6579 		rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
6580 		rtoinfo.srto_max = sp->rtoinfo.srto_max;
6581 		rtoinfo.srto_min = sp->rtoinfo.srto_min;
6582 	}
6583 
6584 	if (put_user(len, optlen))
6585 		return -EFAULT;
6586 
6587 	if (copy_to_user(optval, &rtoinfo, len))
6588 		return -EFAULT;
6589 
6590 	return 0;
6591 }
6592 
6593 /*
6594  *
6595  * 7.1.2 SCTP_ASSOCINFO
6596  *
6597  * This option is used to tune the maximum retransmission attempts
6598  * of the association.
6599  * Returns an error if the new association retransmission value is
6600  * greater than the sum of the retransmission value  of the peer.
6601  * See [SCTP] for more information.
6602  *
6603  */
sctp_getsockopt_associnfo(struct sock * sk,int len,char __user * optval,int __user * optlen)6604 static int sctp_getsockopt_associnfo(struct sock *sk, int len,
6605 				     char __user *optval,
6606 				     int __user *optlen)
6607 {
6608 
6609 	struct sctp_assocparams assocparams;
6610 	struct sctp_association *asoc;
6611 	struct list_head *pos;
6612 	int cnt = 0;
6613 
6614 	if (len < sizeof (struct sctp_assocparams))
6615 		return -EINVAL;
6616 
6617 	len = sizeof(struct sctp_assocparams);
6618 
6619 	if (copy_from_user(&assocparams, optval, len))
6620 		return -EFAULT;
6621 
6622 	asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
6623 
6624 	if (!asoc && assocparams.sasoc_assoc_id != SCTP_FUTURE_ASSOC &&
6625 	    sctp_style(sk, UDP))
6626 		return -EINVAL;
6627 
6628 	/* Values correspoinding to the specific association */
6629 	if (asoc) {
6630 		assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
6631 		assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
6632 		assocparams.sasoc_local_rwnd = asoc->a_rwnd;
6633 		assocparams.sasoc_cookie_life = ktime_to_ms(asoc->cookie_life);
6634 
6635 		list_for_each(pos, &asoc->peer.transport_addr_list) {
6636 			cnt++;
6637 		}
6638 
6639 		assocparams.sasoc_number_peer_destinations = cnt;
6640 	} else {
6641 		/* Values corresponding to the endpoint */
6642 		struct sctp_sock *sp = sctp_sk(sk);
6643 
6644 		assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
6645 		assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
6646 		assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
6647 		assocparams.sasoc_cookie_life =
6648 					sp->assocparams.sasoc_cookie_life;
6649 		assocparams.sasoc_number_peer_destinations =
6650 					sp->assocparams.
6651 					sasoc_number_peer_destinations;
6652 	}
6653 
6654 	if (put_user(len, optlen))
6655 		return -EFAULT;
6656 
6657 	if (copy_to_user(optval, &assocparams, len))
6658 		return -EFAULT;
6659 
6660 	return 0;
6661 }
6662 
6663 /*
6664  * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
6665  *
6666  * This socket option is a boolean flag which turns on or off mapped V4
6667  * addresses.  If this option is turned on and the socket is type
6668  * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
6669  * If this option is turned off, then no mapping will be done of V4
6670  * addresses and a user will receive both PF_INET6 and PF_INET type
6671  * addresses on the socket.
6672  */
sctp_getsockopt_mappedv4(struct sock * sk,int len,char __user * optval,int __user * optlen)6673 static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
6674 				    char __user *optval, int __user *optlen)
6675 {
6676 	int val;
6677 	struct sctp_sock *sp = sctp_sk(sk);
6678 
6679 	if (len < sizeof(int))
6680 		return -EINVAL;
6681 
6682 	len = sizeof(int);
6683 	val = sp->v4mapped;
6684 	if (put_user(len, optlen))
6685 		return -EFAULT;
6686 	if (copy_to_user(optval, &val, len))
6687 		return -EFAULT;
6688 
6689 	return 0;
6690 }
6691 
6692 /*
6693  * 7.1.29.  Set or Get the default context (SCTP_CONTEXT)
6694  * (chapter and verse is quoted at sctp_setsockopt_context())
6695  */
sctp_getsockopt_context(struct sock * sk,int len,char __user * optval,int __user * optlen)6696 static int sctp_getsockopt_context(struct sock *sk, int len,
6697 				   char __user *optval, int __user *optlen)
6698 {
6699 	struct sctp_assoc_value params;
6700 	struct sctp_association *asoc;
6701 
6702 	if (len < sizeof(struct sctp_assoc_value))
6703 		return -EINVAL;
6704 
6705 	len = sizeof(struct sctp_assoc_value);
6706 
6707 	if (copy_from_user(&params, optval, len))
6708 		return -EFAULT;
6709 
6710 	asoc = sctp_id2assoc(sk, params.assoc_id);
6711 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6712 	    sctp_style(sk, UDP))
6713 		return -EINVAL;
6714 
6715 	params.assoc_value = asoc ? asoc->default_rcv_context
6716 				  : sctp_sk(sk)->default_rcv_context;
6717 
6718 	if (put_user(len, optlen))
6719 		return -EFAULT;
6720 	if (copy_to_user(optval, &params, len))
6721 		return -EFAULT;
6722 
6723 	return 0;
6724 }
6725 
6726 /*
6727  * 8.1.16.  Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6728  * This option will get or set the maximum size to put in any outgoing
6729  * SCTP DATA chunk.  If a message is larger than this size it will be
6730  * fragmented by SCTP into the specified size.  Note that the underlying
6731  * SCTP implementation may fragment into smaller sized chunks when the
6732  * PMTU of the underlying association is smaller than the value set by
6733  * the user.  The default value for this option is '0' which indicates
6734  * the user is NOT limiting fragmentation and only the PMTU will effect
6735  * SCTP's choice of DATA chunk size.  Note also that values set larger
6736  * than the maximum size of an IP datagram will effectively let SCTP
6737  * control fragmentation (i.e. the same as setting this option to 0).
6738  *
6739  * The following structure is used to access and modify this parameter:
6740  *
6741  * struct sctp_assoc_value {
6742  *   sctp_assoc_t assoc_id;
6743  *   uint32_t assoc_value;
6744  * };
6745  *
6746  * assoc_id:  This parameter is ignored for one-to-one style sockets.
6747  *    For one-to-many style sockets this parameter indicates which
6748  *    association the user is performing an action upon.  Note that if
6749  *    this field's value is zero then the endpoints default value is
6750  *    changed (effecting future associations only).
6751  * assoc_value:  This parameter specifies the maximum size in bytes.
6752  */
sctp_getsockopt_maxseg(struct sock * sk,int len,char __user * optval,int __user * optlen)6753 static int sctp_getsockopt_maxseg(struct sock *sk, int len,
6754 				  char __user *optval, int __user *optlen)
6755 {
6756 	struct sctp_assoc_value params;
6757 	struct sctp_association *asoc;
6758 
6759 	if (len == sizeof(int)) {
6760 		pr_warn_ratelimited(DEPRECATED
6761 				    "%s (pid %d) "
6762 				    "Use of int in maxseg socket option.\n"
6763 				    "Use struct sctp_assoc_value instead\n",
6764 				    current->comm, task_pid_nr(current));
6765 		params.assoc_id = SCTP_FUTURE_ASSOC;
6766 	} else if (len >= sizeof(struct sctp_assoc_value)) {
6767 		len = sizeof(struct sctp_assoc_value);
6768 		if (copy_from_user(&params, optval, len))
6769 			return -EFAULT;
6770 	} else
6771 		return -EINVAL;
6772 
6773 	asoc = sctp_id2assoc(sk, params.assoc_id);
6774 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6775 	    sctp_style(sk, UDP))
6776 		return -EINVAL;
6777 
6778 	if (asoc)
6779 		params.assoc_value = asoc->frag_point;
6780 	else
6781 		params.assoc_value = sctp_sk(sk)->user_frag;
6782 
6783 	if (put_user(len, optlen))
6784 		return -EFAULT;
6785 	if (len == sizeof(int)) {
6786 		if (copy_to_user(optval, &params.assoc_value, len))
6787 			return -EFAULT;
6788 	} else {
6789 		if (copy_to_user(optval, &params, len))
6790 			return -EFAULT;
6791 	}
6792 
6793 	return 0;
6794 }
6795 
6796 /*
6797  * 7.1.24.  Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6798  * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6799  */
sctp_getsockopt_fragment_interleave(struct sock * sk,int len,char __user * optval,int __user * optlen)6800 static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
6801 					       char __user *optval, int __user *optlen)
6802 {
6803 	int val;
6804 
6805 	if (len < sizeof(int))
6806 		return -EINVAL;
6807 
6808 	len = sizeof(int);
6809 
6810 	val = sctp_sk(sk)->frag_interleave;
6811 	if (put_user(len, optlen))
6812 		return -EFAULT;
6813 	if (copy_to_user(optval, &val, len))
6814 		return -EFAULT;
6815 
6816 	return 0;
6817 }
6818 
6819 /*
6820  * 7.1.25.  Set or Get the sctp partial delivery point
6821  * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6822  */
sctp_getsockopt_partial_delivery_point(struct sock * sk,int len,char __user * optval,int __user * optlen)6823 static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
6824 						  char __user *optval,
6825 						  int __user *optlen)
6826 {
6827 	u32 val;
6828 
6829 	if (len < sizeof(u32))
6830 		return -EINVAL;
6831 
6832 	len = sizeof(u32);
6833 
6834 	val = sctp_sk(sk)->pd_point;
6835 	if (put_user(len, optlen))
6836 		return -EFAULT;
6837 	if (copy_to_user(optval, &val, len))
6838 		return -EFAULT;
6839 
6840 	return 0;
6841 }
6842 
6843 /*
6844  * 7.1.28.  Set or Get the maximum burst (SCTP_MAX_BURST)
6845  * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6846  */
sctp_getsockopt_maxburst(struct sock * sk,int len,char __user * optval,int __user * optlen)6847 static int sctp_getsockopt_maxburst(struct sock *sk, int len,
6848 				    char __user *optval,
6849 				    int __user *optlen)
6850 {
6851 	struct sctp_assoc_value params;
6852 	struct sctp_association *asoc;
6853 
6854 	if (len == sizeof(int)) {
6855 		pr_warn_ratelimited(DEPRECATED
6856 				    "%s (pid %d) "
6857 				    "Use of int in max_burst socket option.\n"
6858 				    "Use struct sctp_assoc_value instead\n",
6859 				    current->comm, task_pid_nr(current));
6860 		params.assoc_id = SCTP_FUTURE_ASSOC;
6861 	} else if (len >= sizeof(struct sctp_assoc_value)) {
6862 		len = sizeof(struct sctp_assoc_value);
6863 		if (copy_from_user(&params, optval, len))
6864 			return -EFAULT;
6865 	} else
6866 		return -EINVAL;
6867 
6868 	asoc = sctp_id2assoc(sk, params.assoc_id);
6869 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
6870 	    sctp_style(sk, UDP))
6871 		return -EINVAL;
6872 
6873 	params.assoc_value = asoc ? asoc->max_burst : sctp_sk(sk)->max_burst;
6874 
6875 	if (len == sizeof(int)) {
6876 		if (copy_to_user(optval, &params.assoc_value, len))
6877 			return -EFAULT;
6878 	} else {
6879 		if (copy_to_user(optval, &params, len))
6880 			return -EFAULT;
6881 	}
6882 
6883 	return 0;
6884 
6885 }
6886 
sctp_getsockopt_hmac_ident(struct sock * sk,int len,char __user * optval,int __user * optlen)6887 static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
6888 				    char __user *optval, int __user *optlen)
6889 {
6890 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6891 	struct sctp_hmacalgo  __user *p = (void __user *)optval;
6892 	struct sctp_hmac_algo_param *hmacs;
6893 	__u16 data_len = 0;
6894 	u32 num_idents;
6895 	int i;
6896 
6897 	if (!ep->auth_enable)
6898 		return -EACCES;
6899 
6900 	hmacs = ep->auth_hmacs_list;
6901 	data_len = ntohs(hmacs->param_hdr.length) -
6902 		   sizeof(struct sctp_paramhdr);
6903 
6904 	if (len < sizeof(struct sctp_hmacalgo) + data_len)
6905 		return -EINVAL;
6906 
6907 	len = sizeof(struct sctp_hmacalgo) + data_len;
6908 	num_idents = data_len / sizeof(u16);
6909 
6910 	if (put_user(len, optlen))
6911 		return -EFAULT;
6912 	if (put_user(num_idents, &p->shmac_num_idents))
6913 		return -EFAULT;
6914 	for (i = 0; i < num_idents; i++) {
6915 		__u16 hmacid = ntohs(hmacs->hmac_ids[i]);
6916 
6917 		if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
6918 			return -EFAULT;
6919 	}
6920 	return 0;
6921 }
6922 
sctp_getsockopt_active_key(struct sock * sk,int len,char __user * optval,int __user * optlen)6923 static int sctp_getsockopt_active_key(struct sock *sk, int len,
6924 				    char __user *optval, int __user *optlen)
6925 {
6926 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6927 	struct sctp_authkeyid val;
6928 	struct sctp_association *asoc;
6929 
6930 	if (len < sizeof(struct sctp_authkeyid))
6931 		return -EINVAL;
6932 
6933 	len = sizeof(struct sctp_authkeyid);
6934 	if (copy_from_user(&val, optval, len))
6935 		return -EFAULT;
6936 
6937 	asoc = sctp_id2assoc(sk, val.scact_assoc_id);
6938 	if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
6939 		return -EINVAL;
6940 
6941 	if (asoc) {
6942 		if (!asoc->peer.auth_capable)
6943 			return -EACCES;
6944 		val.scact_keynumber = asoc->active_key_id;
6945 	} else {
6946 		if (!ep->auth_enable)
6947 			return -EACCES;
6948 		val.scact_keynumber = ep->active_key_id;
6949 	}
6950 
6951 	if (put_user(len, optlen))
6952 		return -EFAULT;
6953 	if (copy_to_user(optval, &val, len))
6954 		return -EFAULT;
6955 
6956 	return 0;
6957 }
6958 
sctp_getsockopt_peer_auth_chunks(struct sock * sk,int len,char __user * optval,int __user * optlen)6959 static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
6960 				    char __user *optval, int __user *optlen)
6961 {
6962 	struct sctp_authchunks __user *p = (void __user *)optval;
6963 	struct sctp_authchunks val;
6964 	struct sctp_association *asoc;
6965 	struct sctp_chunks_param *ch;
6966 	u32    num_chunks = 0;
6967 	char __user *to;
6968 
6969 	if (len < sizeof(struct sctp_authchunks))
6970 		return -EINVAL;
6971 
6972 	if (copy_from_user(&val, optval, sizeof(val)))
6973 		return -EFAULT;
6974 
6975 	to = p->gauth_chunks;
6976 	asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
6977 	if (!asoc)
6978 		return -EINVAL;
6979 
6980 	if (!asoc->peer.auth_capable)
6981 		return -EACCES;
6982 
6983 	ch = asoc->peer.peer_chunks;
6984 	if (!ch)
6985 		goto num;
6986 
6987 	/* See if the user provided enough room for all the data */
6988 	num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
6989 	if (len < num_chunks)
6990 		return -EINVAL;
6991 
6992 	if (copy_to_user(to, ch->chunks, num_chunks))
6993 		return -EFAULT;
6994 num:
6995 	len = sizeof(struct sctp_authchunks) + num_chunks;
6996 	if (put_user(len, optlen))
6997 		return -EFAULT;
6998 	if (put_user(num_chunks, &p->gauth_number_of_chunks))
6999 		return -EFAULT;
7000 	return 0;
7001 }
7002 
sctp_getsockopt_local_auth_chunks(struct sock * sk,int len,char __user * optval,int __user * optlen)7003 static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
7004 				    char __user *optval, int __user *optlen)
7005 {
7006 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
7007 	struct sctp_authchunks __user *p = (void __user *)optval;
7008 	struct sctp_authchunks val;
7009 	struct sctp_association *asoc;
7010 	struct sctp_chunks_param *ch;
7011 	u32    num_chunks = 0;
7012 	char __user *to;
7013 
7014 	if (len < sizeof(struct sctp_authchunks))
7015 		return -EINVAL;
7016 
7017 	if (copy_from_user(&val, optval, sizeof(val)))
7018 		return -EFAULT;
7019 
7020 	to = p->gauth_chunks;
7021 	asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
7022 	if (!asoc && val.gauth_assoc_id != SCTP_FUTURE_ASSOC &&
7023 	    sctp_style(sk, UDP))
7024 		return -EINVAL;
7025 
7026 	if (asoc) {
7027 		if (!asoc->peer.auth_capable)
7028 			return -EACCES;
7029 		ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
7030 	} else {
7031 		if (!ep->auth_enable)
7032 			return -EACCES;
7033 		ch = ep->auth_chunk_list;
7034 	}
7035 	if (!ch)
7036 		goto num;
7037 
7038 	num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
7039 	if (len < sizeof(struct sctp_authchunks) + num_chunks)
7040 		return -EINVAL;
7041 
7042 	if (copy_to_user(to, ch->chunks, num_chunks))
7043 		return -EFAULT;
7044 num:
7045 	len = sizeof(struct sctp_authchunks) + num_chunks;
7046 	if (put_user(len, optlen))
7047 		return -EFAULT;
7048 	if (put_user(num_chunks, &p->gauth_number_of_chunks))
7049 		return -EFAULT;
7050 
7051 	return 0;
7052 }
7053 
7054 /*
7055  * 8.2.5.  Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
7056  * This option gets the current number of associations that are attached
7057  * to a one-to-many style socket.  The option value is an uint32_t.
7058  */
sctp_getsockopt_assoc_number(struct sock * sk,int len,char __user * optval,int __user * optlen)7059 static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
7060 				    char __user *optval, int __user *optlen)
7061 {
7062 	struct sctp_sock *sp = sctp_sk(sk);
7063 	struct sctp_association *asoc;
7064 	u32 val = 0;
7065 
7066 	if (sctp_style(sk, TCP))
7067 		return -EOPNOTSUPP;
7068 
7069 	if (len < sizeof(u32))
7070 		return -EINVAL;
7071 
7072 	len = sizeof(u32);
7073 
7074 	list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7075 		val++;
7076 	}
7077 
7078 	if (put_user(len, optlen))
7079 		return -EFAULT;
7080 	if (copy_to_user(optval, &val, len))
7081 		return -EFAULT;
7082 
7083 	return 0;
7084 }
7085 
7086 /*
7087  * 8.1.23 SCTP_AUTO_ASCONF
7088  * See the corresponding setsockopt entry as description
7089  */
sctp_getsockopt_auto_asconf(struct sock * sk,int len,char __user * optval,int __user * optlen)7090 static int sctp_getsockopt_auto_asconf(struct sock *sk, int len,
7091 				   char __user *optval, int __user *optlen)
7092 {
7093 	int val = 0;
7094 
7095 	if (len < sizeof(int))
7096 		return -EINVAL;
7097 
7098 	len = sizeof(int);
7099 	if (sctp_sk(sk)->do_auto_asconf && sctp_is_ep_boundall(sk))
7100 		val = 1;
7101 	if (put_user(len, optlen))
7102 		return -EFAULT;
7103 	if (copy_to_user(optval, &val, len))
7104 		return -EFAULT;
7105 	return 0;
7106 }
7107 
7108 /*
7109  * 8.2.6. Get the Current Identifiers of Associations
7110  *        (SCTP_GET_ASSOC_ID_LIST)
7111  *
7112  * This option gets the current list of SCTP association identifiers of
7113  * the SCTP associations handled by a one-to-many style socket.
7114  */
sctp_getsockopt_assoc_ids(struct sock * sk,int len,char __user * optval,int __user * optlen)7115 static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
7116 				    char __user *optval, int __user *optlen)
7117 {
7118 	struct sctp_sock *sp = sctp_sk(sk);
7119 	struct sctp_association *asoc;
7120 	struct sctp_assoc_ids *ids;
7121 	u32 num = 0;
7122 
7123 	if (sctp_style(sk, TCP))
7124 		return -EOPNOTSUPP;
7125 
7126 	if (len < sizeof(struct sctp_assoc_ids))
7127 		return -EINVAL;
7128 
7129 	list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7130 		num++;
7131 	}
7132 
7133 	if (len < sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num)
7134 		return -EINVAL;
7135 
7136 	len = sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num;
7137 
7138 	ids = kmalloc(len, GFP_USER | __GFP_NOWARN);
7139 	if (unlikely(!ids))
7140 		return -ENOMEM;
7141 
7142 	ids->gaids_number_of_ids = num;
7143 	num = 0;
7144 	list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7145 		ids->gaids_assoc_id[num++] = asoc->assoc_id;
7146 	}
7147 
7148 	if (put_user(len, optlen) || copy_to_user(optval, ids, len)) {
7149 		kfree(ids);
7150 		return -EFAULT;
7151 	}
7152 
7153 	kfree(ids);
7154 	return 0;
7155 }
7156 
7157 /*
7158  * SCTP_PEER_ADDR_THLDS
7159  *
7160  * This option allows us to fetch the partially failed threshold for one or all
7161  * transports in an association.  See Section 6.1 of:
7162  * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
7163  */
sctp_getsockopt_paddr_thresholds(struct sock * sk,char __user * optval,int len,int __user * optlen,bool v2)7164 static int sctp_getsockopt_paddr_thresholds(struct sock *sk,
7165 					    char __user *optval, int len,
7166 					    int __user *optlen, bool v2)
7167 {
7168 	struct sctp_paddrthlds_v2 val;
7169 	struct sctp_transport *trans;
7170 	struct sctp_association *asoc;
7171 	int min;
7172 
7173 	min = v2 ? sizeof(val) : sizeof(struct sctp_paddrthlds);
7174 	if (len < min)
7175 		return -EINVAL;
7176 	len = min;
7177 	if (copy_from_user(&val, optval, len))
7178 		return -EFAULT;
7179 
7180 	if (!sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
7181 		trans = sctp_addr_id2transport(sk, &val.spt_address,
7182 					       val.spt_assoc_id);
7183 		if (!trans)
7184 			return -ENOENT;
7185 
7186 		val.spt_pathmaxrxt = trans->pathmaxrxt;
7187 		val.spt_pathpfthld = trans->pf_retrans;
7188 		val.spt_pathcpthld = trans->ps_retrans;
7189 
7190 		goto out;
7191 	}
7192 
7193 	asoc = sctp_id2assoc(sk, val.spt_assoc_id);
7194 	if (!asoc && val.spt_assoc_id != SCTP_FUTURE_ASSOC &&
7195 	    sctp_style(sk, UDP))
7196 		return -EINVAL;
7197 
7198 	if (asoc) {
7199 		val.spt_pathpfthld = asoc->pf_retrans;
7200 		val.spt_pathmaxrxt = asoc->pathmaxrxt;
7201 		val.spt_pathcpthld = asoc->ps_retrans;
7202 	} else {
7203 		struct sctp_sock *sp = sctp_sk(sk);
7204 
7205 		val.spt_pathpfthld = sp->pf_retrans;
7206 		val.spt_pathmaxrxt = sp->pathmaxrxt;
7207 		val.spt_pathcpthld = sp->ps_retrans;
7208 	}
7209 
7210 out:
7211 	if (put_user(len, optlen) || copy_to_user(optval, &val, len))
7212 		return -EFAULT;
7213 
7214 	return 0;
7215 }
7216 
7217 /*
7218  * SCTP_GET_ASSOC_STATS
7219  *
7220  * This option retrieves local per endpoint statistics. It is modeled
7221  * after OpenSolaris' implementation
7222  */
sctp_getsockopt_assoc_stats(struct sock * sk,int len,char __user * optval,int __user * optlen)7223 static int sctp_getsockopt_assoc_stats(struct sock *sk, int len,
7224 				       char __user *optval,
7225 				       int __user *optlen)
7226 {
7227 	struct sctp_assoc_stats sas;
7228 	struct sctp_association *asoc = NULL;
7229 
7230 	/* User must provide at least the assoc id */
7231 	if (len < sizeof(sctp_assoc_t))
7232 		return -EINVAL;
7233 
7234 	/* Allow the struct to grow and fill in as much as possible */
7235 	len = min_t(size_t, len, sizeof(sas));
7236 
7237 	if (copy_from_user(&sas, optval, len))
7238 		return -EFAULT;
7239 
7240 	asoc = sctp_id2assoc(sk, sas.sas_assoc_id);
7241 	if (!asoc)
7242 		return -EINVAL;
7243 
7244 	sas.sas_rtxchunks = asoc->stats.rtxchunks;
7245 	sas.sas_gapcnt = asoc->stats.gapcnt;
7246 	sas.sas_outofseqtsns = asoc->stats.outofseqtsns;
7247 	sas.sas_osacks = asoc->stats.osacks;
7248 	sas.sas_isacks = asoc->stats.isacks;
7249 	sas.sas_octrlchunks = asoc->stats.octrlchunks;
7250 	sas.sas_ictrlchunks = asoc->stats.ictrlchunks;
7251 	sas.sas_oodchunks = asoc->stats.oodchunks;
7252 	sas.sas_iodchunks = asoc->stats.iodchunks;
7253 	sas.sas_ouodchunks = asoc->stats.ouodchunks;
7254 	sas.sas_iuodchunks = asoc->stats.iuodchunks;
7255 	sas.sas_idupchunks = asoc->stats.idupchunks;
7256 	sas.sas_opackets = asoc->stats.opackets;
7257 	sas.sas_ipackets = asoc->stats.ipackets;
7258 
7259 	/* New high max rto observed, will return 0 if not a single
7260 	 * RTO update took place. obs_rto_ipaddr will be bogus
7261 	 * in such a case
7262 	 */
7263 	sas.sas_maxrto = asoc->stats.max_obs_rto;
7264 	memcpy(&sas.sas_obs_rto_ipaddr, &asoc->stats.obs_rto_ipaddr,
7265 		sizeof(struct sockaddr_storage));
7266 
7267 	/* Mark beginning of a new observation period */
7268 	asoc->stats.max_obs_rto = asoc->rto_min;
7269 
7270 	if (put_user(len, optlen))
7271 		return -EFAULT;
7272 
7273 	pr_debug("%s: len:%d, assoc_id:%d\n", __func__, len, sas.sas_assoc_id);
7274 
7275 	if (copy_to_user(optval, &sas, len))
7276 		return -EFAULT;
7277 
7278 	return 0;
7279 }
7280 
sctp_getsockopt_recvrcvinfo(struct sock * sk,int len,char __user * optval,int __user * optlen)7281 static int sctp_getsockopt_recvrcvinfo(struct sock *sk,	int len,
7282 				       char __user *optval,
7283 				       int __user *optlen)
7284 {
7285 	int val = 0;
7286 
7287 	if (len < sizeof(int))
7288 		return -EINVAL;
7289 
7290 	len = sizeof(int);
7291 	if (sctp_sk(sk)->recvrcvinfo)
7292 		val = 1;
7293 	if (put_user(len, optlen))
7294 		return -EFAULT;
7295 	if (copy_to_user(optval, &val, len))
7296 		return -EFAULT;
7297 
7298 	return 0;
7299 }
7300 
sctp_getsockopt_recvnxtinfo(struct sock * sk,int len,char __user * optval,int __user * optlen)7301 static int sctp_getsockopt_recvnxtinfo(struct sock *sk,	int len,
7302 				       char __user *optval,
7303 				       int __user *optlen)
7304 {
7305 	int val = 0;
7306 
7307 	if (len < sizeof(int))
7308 		return -EINVAL;
7309 
7310 	len = sizeof(int);
7311 	if (sctp_sk(sk)->recvnxtinfo)
7312 		val = 1;
7313 	if (put_user(len, optlen))
7314 		return -EFAULT;
7315 	if (copy_to_user(optval, &val, len))
7316 		return -EFAULT;
7317 
7318 	return 0;
7319 }
7320 
sctp_getsockopt_pr_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7321 static int sctp_getsockopt_pr_supported(struct sock *sk, int len,
7322 					char __user *optval,
7323 					int __user *optlen)
7324 {
7325 	struct sctp_assoc_value params;
7326 	struct sctp_association *asoc;
7327 	int retval = -EFAULT;
7328 
7329 	if (len < sizeof(params)) {
7330 		retval = -EINVAL;
7331 		goto out;
7332 	}
7333 
7334 	len = sizeof(params);
7335 	if (copy_from_user(&params, optval, len))
7336 		goto out;
7337 
7338 	asoc = sctp_id2assoc(sk, params.assoc_id);
7339 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7340 	    sctp_style(sk, UDP)) {
7341 		retval = -EINVAL;
7342 		goto out;
7343 	}
7344 
7345 	params.assoc_value = asoc ? asoc->peer.prsctp_capable
7346 				  : sctp_sk(sk)->ep->prsctp_enable;
7347 
7348 	if (put_user(len, optlen))
7349 		goto out;
7350 
7351 	if (copy_to_user(optval, &params, len))
7352 		goto out;
7353 
7354 	retval = 0;
7355 
7356 out:
7357 	return retval;
7358 }
7359 
sctp_getsockopt_default_prinfo(struct sock * sk,int len,char __user * optval,int __user * optlen)7360 static int sctp_getsockopt_default_prinfo(struct sock *sk, int len,
7361 					  char __user *optval,
7362 					  int __user *optlen)
7363 {
7364 	struct sctp_default_prinfo info;
7365 	struct sctp_association *asoc;
7366 	int retval = -EFAULT;
7367 
7368 	if (len < sizeof(info)) {
7369 		retval = -EINVAL;
7370 		goto out;
7371 	}
7372 
7373 	len = sizeof(info);
7374 	if (copy_from_user(&info, optval, len))
7375 		goto out;
7376 
7377 	asoc = sctp_id2assoc(sk, info.pr_assoc_id);
7378 	if (!asoc && info.pr_assoc_id != SCTP_FUTURE_ASSOC &&
7379 	    sctp_style(sk, UDP)) {
7380 		retval = -EINVAL;
7381 		goto out;
7382 	}
7383 
7384 	if (asoc) {
7385 		info.pr_policy = SCTP_PR_POLICY(asoc->default_flags);
7386 		info.pr_value = asoc->default_timetolive;
7387 	} else {
7388 		struct sctp_sock *sp = sctp_sk(sk);
7389 
7390 		info.pr_policy = SCTP_PR_POLICY(sp->default_flags);
7391 		info.pr_value = sp->default_timetolive;
7392 	}
7393 
7394 	if (put_user(len, optlen))
7395 		goto out;
7396 
7397 	if (copy_to_user(optval, &info, len))
7398 		goto out;
7399 
7400 	retval = 0;
7401 
7402 out:
7403 	return retval;
7404 }
7405 
sctp_getsockopt_pr_assocstatus(struct sock * sk,int len,char __user * optval,int __user * optlen)7406 static int sctp_getsockopt_pr_assocstatus(struct sock *sk, int len,
7407 					  char __user *optval,
7408 					  int __user *optlen)
7409 {
7410 	struct sctp_prstatus params;
7411 	struct sctp_association *asoc;
7412 	int policy;
7413 	int retval = -EINVAL;
7414 
7415 	if (len < sizeof(params))
7416 		goto out;
7417 
7418 	len = sizeof(params);
7419 	if (copy_from_user(&params, optval, len)) {
7420 		retval = -EFAULT;
7421 		goto out;
7422 	}
7423 
7424 	policy = params.sprstat_policy;
7425 	if (!policy || (policy & ~(SCTP_PR_SCTP_MASK | SCTP_PR_SCTP_ALL)) ||
7426 	    ((policy & SCTP_PR_SCTP_ALL) && (policy & SCTP_PR_SCTP_MASK)))
7427 		goto out;
7428 
7429 	asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7430 	if (!asoc)
7431 		goto out;
7432 
7433 	if (policy == SCTP_PR_SCTP_ALL) {
7434 		params.sprstat_abandoned_unsent = 0;
7435 		params.sprstat_abandoned_sent = 0;
7436 		for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7437 			params.sprstat_abandoned_unsent +=
7438 				asoc->abandoned_unsent[policy];
7439 			params.sprstat_abandoned_sent +=
7440 				asoc->abandoned_sent[policy];
7441 		}
7442 	} else {
7443 		params.sprstat_abandoned_unsent =
7444 			asoc->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7445 		params.sprstat_abandoned_sent =
7446 			asoc->abandoned_sent[__SCTP_PR_INDEX(policy)];
7447 	}
7448 
7449 	if (put_user(len, optlen)) {
7450 		retval = -EFAULT;
7451 		goto out;
7452 	}
7453 
7454 	if (copy_to_user(optval, &params, len)) {
7455 		retval = -EFAULT;
7456 		goto out;
7457 	}
7458 
7459 	retval = 0;
7460 
7461 out:
7462 	return retval;
7463 }
7464 
sctp_getsockopt_pr_streamstatus(struct sock * sk,int len,char __user * optval,int __user * optlen)7465 static int sctp_getsockopt_pr_streamstatus(struct sock *sk, int len,
7466 					   char __user *optval,
7467 					   int __user *optlen)
7468 {
7469 	struct sctp_stream_out_ext *streamoute;
7470 	struct sctp_association *asoc;
7471 	struct sctp_prstatus params;
7472 	int retval = -EINVAL;
7473 	int policy;
7474 
7475 	if (len < sizeof(params))
7476 		goto out;
7477 
7478 	len = sizeof(params);
7479 	if (copy_from_user(&params, optval, len)) {
7480 		retval = -EFAULT;
7481 		goto out;
7482 	}
7483 
7484 	policy = params.sprstat_policy;
7485 	if (!policy || (policy & ~(SCTP_PR_SCTP_MASK | SCTP_PR_SCTP_ALL)) ||
7486 	    ((policy & SCTP_PR_SCTP_ALL) && (policy & SCTP_PR_SCTP_MASK)))
7487 		goto out;
7488 
7489 	asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7490 	if (!asoc || params.sprstat_sid >= asoc->stream.outcnt)
7491 		goto out;
7492 
7493 	streamoute = SCTP_SO(&asoc->stream, params.sprstat_sid)->ext;
7494 	if (!streamoute) {
7495 		/* Not allocated yet, means all stats are 0 */
7496 		params.sprstat_abandoned_unsent = 0;
7497 		params.sprstat_abandoned_sent = 0;
7498 		retval = 0;
7499 		goto out;
7500 	}
7501 
7502 	if (policy == SCTP_PR_SCTP_ALL) {
7503 		params.sprstat_abandoned_unsent = 0;
7504 		params.sprstat_abandoned_sent = 0;
7505 		for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7506 			params.sprstat_abandoned_unsent +=
7507 				streamoute->abandoned_unsent[policy];
7508 			params.sprstat_abandoned_sent +=
7509 				streamoute->abandoned_sent[policy];
7510 		}
7511 	} else {
7512 		params.sprstat_abandoned_unsent =
7513 			streamoute->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7514 		params.sprstat_abandoned_sent =
7515 			streamoute->abandoned_sent[__SCTP_PR_INDEX(policy)];
7516 	}
7517 
7518 	if (put_user(len, optlen) || copy_to_user(optval, &params, len)) {
7519 		retval = -EFAULT;
7520 		goto out;
7521 	}
7522 
7523 	retval = 0;
7524 
7525 out:
7526 	return retval;
7527 }
7528 
sctp_getsockopt_reconfig_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7529 static int sctp_getsockopt_reconfig_supported(struct sock *sk, int len,
7530 					      char __user *optval,
7531 					      int __user *optlen)
7532 {
7533 	struct sctp_assoc_value params;
7534 	struct sctp_association *asoc;
7535 	int retval = -EFAULT;
7536 
7537 	if (len < sizeof(params)) {
7538 		retval = -EINVAL;
7539 		goto out;
7540 	}
7541 
7542 	len = sizeof(params);
7543 	if (copy_from_user(&params, optval, len))
7544 		goto out;
7545 
7546 	asoc = sctp_id2assoc(sk, params.assoc_id);
7547 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7548 	    sctp_style(sk, UDP)) {
7549 		retval = -EINVAL;
7550 		goto out;
7551 	}
7552 
7553 	params.assoc_value = asoc ? asoc->peer.reconf_capable
7554 				  : sctp_sk(sk)->ep->reconf_enable;
7555 
7556 	if (put_user(len, optlen))
7557 		goto out;
7558 
7559 	if (copy_to_user(optval, &params, len))
7560 		goto out;
7561 
7562 	retval = 0;
7563 
7564 out:
7565 	return retval;
7566 }
7567 
sctp_getsockopt_enable_strreset(struct sock * sk,int len,char __user * optval,int __user * optlen)7568 static int sctp_getsockopt_enable_strreset(struct sock *sk, int len,
7569 					   char __user *optval,
7570 					   int __user *optlen)
7571 {
7572 	struct sctp_assoc_value params;
7573 	struct sctp_association *asoc;
7574 	int retval = -EFAULT;
7575 
7576 	if (len < sizeof(params)) {
7577 		retval = -EINVAL;
7578 		goto out;
7579 	}
7580 
7581 	len = sizeof(params);
7582 	if (copy_from_user(&params, optval, len))
7583 		goto out;
7584 
7585 	asoc = sctp_id2assoc(sk, params.assoc_id);
7586 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7587 	    sctp_style(sk, UDP)) {
7588 		retval = -EINVAL;
7589 		goto out;
7590 	}
7591 
7592 	params.assoc_value = asoc ? asoc->strreset_enable
7593 				  : sctp_sk(sk)->ep->strreset_enable;
7594 
7595 	if (put_user(len, optlen))
7596 		goto out;
7597 
7598 	if (copy_to_user(optval, &params, len))
7599 		goto out;
7600 
7601 	retval = 0;
7602 
7603 out:
7604 	return retval;
7605 }
7606 
sctp_getsockopt_scheduler(struct sock * sk,int len,char __user * optval,int __user * optlen)7607 static int sctp_getsockopt_scheduler(struct sock *sk, int len,
7608 				     char __user *optval,
7609 				     int __user *optlen)
7610 {
7611 	struct sctp_assoc_value params;
7612 	struct sctp_association *asoc;
7613 	int retval = -EFAULT;
7614 
7615 	if (len < sizeof(params)) {
7616 		retval = -EINVAL;
7617 		goto out;
7618 	}
7619 
7620 	len = sizeof(params);
7621 	if (copy_from_user(&params, optval, len))
7622 		goto out;
7623 
7624 	asoc = sctp_id2assoc(sk, params.assoc_id);
7625 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7626 	    sctp_style(sk, UDP)) {
7627 		retval = -EINVAL;
7628 		goto out;
7629 	}
7630 
7631 	params.assoc_value = asoc ? sctp_sched_get_sched(asoc)
7632 				  : sctp_sk(sk)->default_ss;
7633 
7634 	if (put_user(len, optlen))
7635 		goto out;
7636 
7637 	if (copy_to_user(optval, &params, len))
7638 		goto out;
7639 
7640 	retval = 0;
7641 
7642 out:
7643 	return retval;
7644 }
7645 
sctp_getsockopt_scheduler_value(struct sock * sk,int len,char __user * optval,int __user * optlen)7646 static int sctp_getsockopt_scheduler_value(struct sock *sk, int len,
7647 					   char __user *optval,
7648 					   int __user *optlen)
7649 {
7650 	struct sctp_stream_value params;
7651 	struct sctp_association *asoc;
7652 	int retval = -EFAULT;
7653 
7654 	if (len < sizeof(params)) {
7655 		retval = -EINVAL;
7656 		goto out;
7657 	}
7658 
7659 	len = sizeof(params);
7660 	if (copy_from_user(&params, optval, len))
7661 		goto out;
7662 
7663 	asoc = sctp_id2assoc(sk, params.assoc_id);
7664 	if (!asoc) {
7665 		retval = -EINVAL;
7666 		goto out;
7667 	}
7668 
7669 	retval = sctp_sched_get_value(asoc, params.stream_id,
7670 				      &params.stream_value);
7671 	if (retval)
7672 		goto out;
7673 
7674 	if (put_user(len, optlen)) {
7675 		retval = -EFAULT;
7676 		goto out;
7677 	}
7678 
7679 	if (copy_to_user(optval, &params, len)) {
7680 		retval = -EFAULT;
7681 		goto out;
7682 	}
7683 
7684 out:
7685 	return retval;
7686 }
7687 
sctp_getsockopt_interleaving_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7688 static int sctp_getsockopt_interleaving_supported(struct sock *sk, int len,
7689 						  char __user *optval,
7690 						  int __user *optlen)
7691 {
7692 	struct sctp_assoc_value params;
7693 	struct sctp_association *asoc;
7694 	int retval = -EFAULT;
7695 
7696 	if (len < sizeof(params)) {
7697 		retval = -EINVAL;
7698 		goto out;
7699 	}
7700 
7701 	len = sizeof(params);
7702 	if (copy_from_user(&params, optval, len))
7703 		goto out;
7704 
7705 	asoc = sctp_id2assoc(sk, params.assoc_id);
7706 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7707 	    sctp_style(sk, UDP)) {
7708 		retval = -EINVAL;
7709 		goto out;
7710 	}
7711 
7712 	params.assoc_value = asoc ? asoc->peer.intl_capable
7713 				  : sctp_sk(sk)->ep->intl_enable;
7714 
7715 	if (put_user(len, optlen))
7716 		goto out;
7717 
7718 	if (copy_to_user(optval, &params, len))
7719 		goto out;
7720 
7721 	retval = 0;
7722 
7723 out:
7724 	return retval;
7725 }
7726 
sctp_getsockopt_reuse_port(struct sock * sk,int len,char __user * optval,int __user * optlen)7727 static int sctp_getsockopt_reuse_port(struct sock *sk, int len,
7728 				      char __user *optval,
7729 				      int __user *optlen)
7730 {
7731 	int val;
7732 
7733 	if (len < sizeof(int))
7734 		return -EINVAL;
7735 
7736 	len = sizeof(int);
7737 	val = sctp_sk(sk)->reuse;
7738 	if (put_user(len, optlen))
7739 		return -EFAULT;
7740 
7741 	if (copy_to_user(optval, &val, len))
7742 		return -EFAULT;
7743 
7744 	return 0;
7745 }
7746 
sctp_getsockopt_event(struct sock * sk,int len,char __user * optval,int __user * optlen)7747 static int sctp_getsockopt_event(struct sock *sk, int len, char __user *optval,
7748 				 int __user *optlen)
7749 {
7750 	struct sctp_association *asoc;
7751 	struct sctp_event param;
7752 	__u16 subscribe;
7753 
7754 	if (len < sizeof(param))
7755 		return -EINVAL;
7756 
7757 	len = sizeof(param);
7758 	if (copy_from_user(&param, optval, len))
7759 		return -EFAULT;
7760 
7761 	if (param.se_type < SCTP_SN_TYPE_BASE ||
7762 	    param.se_type > SCTP_SN_TYPE_MAX)
7763 		return -EINVAL;
7764 
7765 	asoc = sctp_id2assoc(sk, param.se_assoc_id);
7766 	if (!asoc && param.se_assoc_id != SCTP_FUTURE_ASSOC &&
7767 	    sctp_style(sk, UDP))
7768 		return -EINVAL;
7769 
7770 	subscribe = asoc ? asoc->subscribe : sctp_sk(sk)->subscribe;
7771 	param.se_on = sctp_ulpevent_type_enabled(subscribe, param.se_type);
7772 
7773 	if (put_user(len, optlen))
7774 		return -EFAULT;
7775 
7776 	if (copy_to_user(optval, &param, len))
7777 		return -EFAULT;
7778 
7779 	return 0;
7780 }
7781 
sctp_getsockopt_asconf_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7782 static int sctp_getsockopt_asconf_supported(struct sock *sk, int len,
7783 					    char __user *optval,
7784 					    int __user *optlen)
7785 {
7786 	struct sctp_assoc_value params;
7787 	struct sctp_association *asoc;
7788 	int retval = -EFAULT;
7789 
7790 	if (len < sizeof(params)) {
7791 		retval = -EINVAL;
7792 		goto out;
7793 	}
7794 
7795 	len = sizeof(params);
7796 	if (copy_from_user(&params, optval, len))
7797 		goto out;
7798 
7799 	asoc = sctp_id2assoc(sk, params.assoc_id);
7800 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7801 	    sctp_style(sk, UDP)) {
7802 		retval = -EINVAL;
7803 		goto out;
7804 	}
7805 
7806 	params.assoc_value = asoc ? asoc->peer.asconf_capable
7807 				  : sctp_sk(sk)->ep->asconf_enable;
7808 
7809 	if (put_user(len, optlen))
7810 		goto out;
7811 
7812 	if (copy_to_user(optval, &params, len))
7813 		goto out;
7814 
7815 	retval = 0;
7816 
7817 out:
7818 	return retval;
7819 }
7820 
sctp_getsockopt_auth_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7821 static int sctp_getsockopt_auth_supported(struct sock *sk, int len,
7822 					  char __user *optval,
7823 					  int __user *optlen)
7824 {
7825 	struct sctp_assoc_value params;
7826 	struct sctp_association *asoc;
7827 	int retval = -EFAULT;
7828 
7829 	if (len < sizeof(params)) {
7830 		retval = -EINVAL;
7831 		goto out;
7832 	}
7833 
7834 	len = sizeof(params);
7835 	if (copy_from_user(&params, optval, len))
7836 		goto out;
7837 
7838 	asoc = sctp_id2assoc(sk, params.assoc_id);
7839 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7840 	    sctp_style(sk, UDP)) {
7841 		retval = -EINVAL;
7842 		goto out;
7843 	}
7844 
7845 	params.assoc_value = asoc ? asoc->peer.auth_capable
7846 				  : sctp_sk(sk)->ep->auth_enable;
7847 
7848 	if (put_user(len, optlen))
7849 		goto out;
7850 
7851 	if (copy_to_user(optval, &params, len))
7852 		goto out;
7853 
7854 	retval = 0;
7855 
7856 out:
7857 	return retval;
7858 }
7859 
sctp_getsockopt_ecn_supported(struct sock * sk,int len,char __user * optval,int __user * optlen)7860 static int sctp_getsockopt_ecn_supported(struct sock *sk, int len,
7861 					 char __user *optval,
7862 					 int __user *optlen)
7863 {
7864 	struct sctp_assoc_value params;
7865 	struct sctp_association *asoc;
7866 	int retval = -EFAULT;
7867 
7868 	if (len < sizeof(params)) {
7869 		retval = -EINVAL;
7870 		goto out;
7871 	}
7872 
7873 	len = sizeof(params);
7874 	if (copy_from_user(&params, optval, len))
7875 		goto out;
7876 
7877 	asoc = sctp_id2assoc(sk, params.assoc_id);
7878 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7879 	    sctp_style(sk, UDP)) {
7880 		retval = -EINVAL;
7881 		goto out;
7882 	}
7883 
7884 	params.assoc_value = asoc ? asoc->peer.ecn_capable
7885 				  : sctp_sk(sk)->ep->ecn_enable;
7886 
7887 	if (put_user(len, optlen))
7888 		goto out;
7889 
7890 	if (copy_to_user(optval, &params, len))
7891 		goto out;
7892 
7893 	retval = 0;
7894 
7895 out:
7896 	return retval;
7897 }
7898 
sctp_getsockopt_pf_expose(struct sock * sk,int len,char __user * optval,int __user * optlen)7899 static int sctp_getsockopt_pf_expose(struct sock *sk, int len,
7900 				     char __user *optval,
7901 				     int __user *optlen)
7902 {
7903 	struct sctp_assoc_value params;
7904 	struct sctp_association *asoc;
7905 	int retval = -EFAULT;
7906 
7907 	if (len < sizeof(params)) {
7908 		retval = -EINVAL;
7909 		goto out;
7910 	}
7911 
7912 	len = sizeof(params);
7913 	if (copy_from_user(&params, optval, len))
7914 		goto out;
7915 
7916 	asoc = sctp_id2assoc(sk, params.assoc_id);
7917 	if (!asoc && params.assoc_id != SCTP_FUTURE_ASSOC &&
7918 	    sctp_style(sk, UDP)) {
7919 		retval = -EINVAL;
7920 		goto out;
7921 	}
7922 
7923 	params.assoc_value = asoc ? asoc->pf_expose
7924 				  : sctp_sk(sk)->pf_expose;
7925 
7926 	if (put_user(len, optlen))
7927 		goto out;
7928 
7929 	if (copy_to_user(optval, &params, len))
7930 		goto out;
7931 
7932 	retval = 0;
7933 
7934 out:
7935 	return retval;
7936 }
7937 
sctp_getsockopt_encap_port(struct sock * sk,int len,char __user * optval,int __user * optlen)7938 static int sctp_getsockopt_encap_port(struct sock *sk, int len,
7939 				      char __user *optval, int __user *optlen)
7940 {
7941 	struct sctp_association *asoc;
7942 	struct sctp_udpencaps encap;
7943 	struct sctp_transport *t;
7944 	__be16 encap_port;
7945 
7946 	if (len < sizeof(encap))
7947 		return -EINVAL;
7948 
7949 	len = sizeof(encap);
7950 	if (copy_from_user(&encap, optval, len))
7951 		return -EFAULT;
7952 
7953 	/* If an address other than INADDR_ANY is specified, and
7954 	 * no transport is found, then the request is invalid.
7955 	 */
7956 	if (!sctp_is_any(sk, (union sctp_addr *)&encap.sue_address)) {
7957 		t = sctp_addr_id2transport(sk, &encap.sue_address,
7958 					   encap.sue_assoc_id);
7959 		if (!t) {
7960 			pr_debug("%s: failed no transport\n", __func__);
7961 			return -EINVAL;
7962 		}
7963 
7964 		encap_port = t->encap_port;
7965 		goto out;
7966 	}
7967 
7968 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
7969 	 * socket is a one to many style socket, and an association
7970 	 * was not found, then the id was invalid.
7971 	 */
7972 	asoc = sctp_id2assoc(sk, encap.sue_assoc_id);
7973 	if (!asoc && encap.sue_assoc_id != SCTP_FUTURE_ASSOC &&
7974 	    sctp_style(sk, UDP)) {
7975 		pr_debug("%s: failed no association\n", __func__);
7976 		return -EINVAL;
7977 	}
7978 
7979 	if (asoc) {
7980 		encap_port = asoc->encap_port;
7981 		goto out;
7982 	}
7983 
7984 	encap_port = sctp_sk(sk)->encap_port;
7985 
7986 out:
7987 	encap.sue_port = (__force uint16_t)encap_port;
7988 	if (copy_to_user(optval, &encap, len))
7989 		return -EFAULT;
7990 
7991 	if (put_user(len, optlen))
7992 		return -EFAULT;
7993 
7994 	return 0;
7995 }
7996 
sctp_getsockopt_probe_interval(struct sock * sk,int len,char __user * optval,int __user * optlen)7997 static int sctp_getsockopt_probe_interval(struct sock *sk, int len,
7998 					  char __user *optval,
7999 					  int __user *optlen)
8000 {
8001 	struct sctp_probeinterval params;
8002 	struct sctp_association *asoc;
8003 	struct sctp_transport *t;
8004 	__u32 probe_interval;
8005 
8006 	if (len < sizeof(params))
8007 		return -EINVAL;
8008 
8009 	len = sizeof(params);
8010 	if (copy_from_user(&params, optval, len))
8011 		return -EFAULT;
8012 
8013 	/* If an address other than INADDR_ANY is specified, and
8014 	 * no transport is found, then the request is invalid.
8015 	 */
8016 	if (!sctp_is_any(sk, (union sctp_addr *)&params.spi_address)) {
8017 		t = sctp_addr_id2transport(sk, &params.spi_address,
8018 					   params.spi_assoc_id);
8019 		if (!t) {
8020 			pr_debug("%s: failed no transport\n", __func__);
8021 			return -EINVAL;
8022 		}
8023 
8024 		probe_interval = jiffies_to_msecs(t->probe_interval);
8025 		goto out;
8026 	}
8027 
8028 	/* Get association, if assoc_id != SCTP_FUTURE_ASSOC and the
8029 	 * socket is a one to many style socket, and an association
8030 	 * was not found, then the id was invalid.
8031 	 */
8032 	asoc = sctp_id2assoc(sk, params.spi_assoc_id);
8033 	if (!asoc && params.spi_assoc_id != SCTP_FUTURE_ASSOC &&
8034 	    sctp_style(sk, UDP)) {
8035 		pr_debug("%s: failed no association\n", __func__);
8036 		return -EINVAL;
8037 	}
8038 
8039 	if (asoc) {
8040 		probe_interval = jiffies_to_msecs(asoc->probe_interval);
8041 		goto out;
8042 	}
8043 
8044 	probe_interval = sctp_sk(sk)->probe_interval;
8045 
8046 out:
8047 	params.spi_interval = probe_interval;
8048 	if (copy_to_user(optval, &params, len))
8049 		return -EFAULT;
8050 
8051 	if (put_user(len, optlen))
8052 		return -EFAULT;
8053 
8054 	return 0;
8055 }
8056 
sctp_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)8057 static int sctp_getsockopt(struct sock *sk, int level, int optname,
8058 			   char __user *optval, int __user *optlen)
8059 {
8060 	int retval = 0;
8061 	int len;
8062 
8063 	pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
8064 
8065 	/* I can hardly begin to describe how wrong this is.  This is
8066 	 * so broken as to be worse than useless.  The API draft
8067 	 * REALLY is NOT helpful here...  I am not convinced that the
8068 	 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
8069 	 * are at all well-founded.
8070 	 */
8071 	if (level != SOL_SCTP) {
8072 		struct sctp_af *af = sctp_sk(sk)->pf->af;
8073 
8074 		retval = af->getsockopt(sk, level, optname, optval, optlen);
8075 		return retval;
8076 	}
8077 
8078 	if (get_user(len, optlen))
8079 		return -EFAULT;
8080 
8081 	if (len < 0)
8082 		return -EINVAL;
8083 
8084 	lock_sock(sk);
8085 
8086 	switch (optname) {
8087 	case SCTP_STATUS:
8088 		retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
8089 		break;
8090 	case SCTP_DISABLE_FRAGMENTS:
8091 		retval = sctp_getsockopt_disable_fragments(sk, len, optval,
8092 							   optlen);
8093 		break;
8094 	case SCTP_EVENTS:
8095 		retval = sctp_getsockopt_events(sk, len, optval, optlen);
8096 		break;
8097 	case SCTP_AUTOCLOSE:
8098 		retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
8099 		break;
8100 	case SCTP_SOCKOPT_PEELOFF:
8101 		retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
8102 		break;
8103 	case SCTP_SOCKOPT_PEELOFF_FLAGS:
8104 		retval = sctp_getsockopt_peeloff_flags(sk, len, optval, optlen);
8105 		break;
8106 	case SCTP_PEER_ADDR_PARAMS:
8107 		retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
8108 							  optlen);
8109 		break;
8110 	case SCTP_DELAYED_SACK:
8111 		retval = sctp_getsockopt_delayed_ack(sk, len, optval,
8112 							  optlen);
8113 		break;
8114 	case SCTP_INITMSG:
8115 		retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
8116 		break;
8117 	case SCTP_GET_PEER_ADDRS:
8118 		retval = sctp_getsockopt_peer_addrs(sk, len, optval,
8119 						    optlen);
8120 		break;
8121 	case SCTP_GET_LOCAL_ADDRS:
8122 		retval = sctp_getsockopt_local_addrs(sk, len, optval,
8123 						     optlen);
8124 		break;
8125 	case SCTP_SOCKOPT_CONNECTX3:
8126 		retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
8127 		break;
8128 	case SCTP_DEFAULT_SEND_PARAM:
8129 		retval = sctp_getsockopt_default_send_param(sk, len,
8130 							    optval, optlen);
8131 		break;
8132 	case SCTP_DEFAULT_SNDINFO:
8133 		retval = sctp_getsockopt_default_sndinfo(sk, len,
8134 							 optval, optlen);
8135 		break;
8136 	case SCTP_PRIMARY_ADDR:
8137 		retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
8138 		break;
8139 	case SCTP_NODELAY:
8140 		retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
8141 		break;
8142 	case SCTP_RTOINFO:
8143 		retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
8144 		break;
8145 	case SCTP_ASSOCINFO:
8146 		retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
8147 		break;
8148 	case SCTP_I_WANT_MAPPED_V4_ADDR:
8149 		retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
8150 		break;
8151 	case SCTP_MAXSEG:
8152 		retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
8153 		break;
8154 	case SCTP_GET_PEER_ADDR_INFO:
8155 		retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
8156 							optlen);
8157 		break;
8158 	case SCTP_ADAPTATION_LAYER:
8159 		retval = sctp_getsockopt_adaptation_layer(sk, len, optval,
8160 							optlen);
8161 		break;
8162 	case SCTP_CONTEXT:
8163 		retval = sctp_getsockopt_context(sk, len, optval, optlen);
8164 		break;
8165 	case SCTP_FRAGMENT_INTERLEAVE:
8166 		retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
8167 							     optlen);
8168 		break;
8169 	case SCTP_PARTIAL_DELIVERY_POINT:
8170 		retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
8171 								optlen);
8172 		break;
8173 	case SCTP_MAX_BURST:
8174 		retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
8175 		break;
8176 	case SCTP_AUTH_KEY:
8177 	case SCTP_AUTH_CHUNK:
8178 	case SCTP_AUTH_DELETE_KEY:
8179 	case SCTP_AUTH_DEACTIVATE_KEY:
8180 		retval = -EOPNOTSUPP;
8181 		break;
8182 	case SCTP_HMAC_IDENT:
8183 		retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
8184 		break;
8185 	case SCTP_AUTH_ACTIVE_KEY:
8186 		retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
8187 		break;
8188 	case SCTP_PEER_AUTH_CHUNKS:
8189 		retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
8190 							optlen);
8191 		break;
8192 	case SCTP_LOCAL_AUTH_CHUNKS:
8193 		retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
8194 							optlen);
8195 		break;
8196 	case SCTP_GET_ASSOC_NUMBER:
8197 		retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
8198 		break;
8199 	case SCTP_GET_ASSOC_ID_LIST:
8200 		retval = sctp_getsockopt_assoc_ids(sk, len, optval, optlen);
8201 		break;
8202 	case SCTP_AUTO_ASCONF:
8203 		retval = sctp_getsockopt_auto_asconf(sk, len, optval, optlen);
8204 		break;
8205 	case SCTP_PEER_ADDR_THLDS:
8206 		retval = sctp_getsockopt_paddr_thresholds(sk, optval, len,
8207 							  optlen, false);
8208 		break;
8209 	case SCTP_PEER_ADDR_THLDS_V2:
8210 		retval = sctp_getsockopt_paddr_thresholds(sk, optval, len,
8211 							  optlen, true);
8212 		break;
8213 	case SCTP_GET_ASSOC_STATS:
8214 		retval = sctp_getsockopt_assoc_stats(sk, len, optval, optlen);
8215 		break;
8216 	case SCTP_RECVRCVINFO:
8217 		retval = sctp_getsockopt_recvrcvinfo(sk, len, optval, optlen);
8218 		break;
8219 	case SCTP_RECVNXTINFO:
8220 		retval = sctp_getsockopt_recvnxtinfo(sk, len, optval, optlen);
8221 		break;
8222 	case SCTP_PR_SUPPORTED:
8223 		retval = sctp_getsockopt_pr_supported(sk, len, optval, optlen);
8224 		break;
8225 	case SCTP_DEFAULT_PRINFO:
8226 		retval = sctp_getsockopt_default_prinfo(sk, len, optval,
8227 							optlen);
8228 		break;
8229 	case SCTP_PR_ASSOC_STATUS:
8230 		retval = sctp_getsockopt_pr_assocstatus(sk, len, optval,
8231 							optlen);
8232 		break;
8233 	case SCTP_PR_STREAM_STATUS:
8234 		retval = sctp_getsockopt_pr_streamstatus(sk, len, optval,
8235 							 optlen);
8236 		break;
8237 	case SCTP_RECONFIG_SUPPORTED:
8238 		retval = sctp_getsockopt_reconfig_supported(sk, len, optval,
8239 							    optlen);
8240 		break;
8241 	case SCTP_ENABLE_STREAM_RESET:
8242 		retval = sctp_getsockopt_enable_strreset(sk, len, optval,
8243 							 optlen);
8244 		break;
8245 	case SCTP_STREAM_SCHEDULER:
8246 		retval = sctp_getsockopt_scheduler(sk, len, optval,
8247 						   optlen);
8248 		break;
8249 	case SCTP_STREAM_SCHEDULER_VALUE:
8250 		retval = sctp_getsockopt_scheduler_value(sk, len, optval,
8251 							 optlen);
8252 		break;
8253 	case SCTP_INTERLEAVING_SUPPORTED:
8254 		retval = sctp_getsockopt_interleaving_supported(sk, len, optval,
8255 								optlen);
8256 		break;
8257 	case SCTP_REUSE_PORT:
8258 		retval = sctp_getsockopt_reuse_port(sk, len, optval, optlen);
8259 		break;
8260 	case SCTP_EVENT:
8261 		retval = sctp_getsockopt_event(sk, len, optval, optlen);
8262 		break;
8263 	case SCTP_ASCONF_SUPPORTED:
8264 		retval = sctp_getsockopt_asconf_supported(sk, len, optval,
8265 							  optlen);
8266 		break;
8267 	case SCTP_AUTH_SUPPORTED:
8268 		retval = sctp_getsockopt_auth_supported(sk, len, optval,
8269 							optlen);
8270 		break;
8271 	case SCTP_ECN_SUPPORTED:
8272 		retval = sctp_getsockopt_ecn_supported(sk, len, optval, optlen);
8273 		break;
8274 	case SCTP_EXPOSE_POTENTIALLY_FAILED_STATE:
8275 		retval = sctp_getsockopt_pf_expose(sk, len, optval, optlen);
8276 		break;
8277 	case SCTP_REMOTE_UDP_ENCAPS_PORT:
8278 		retval = sctp_getsockopt_encap_port(sk, len, optval, optlen);
8279 		break;
8280 	case SCTP_PLPMTUD_PROBE_INTERVAL:
8281 		retval = sctp_getsockopt_probe_interval(sk, len, optval, optlen);
8282 		break;
8283 	default:
8284 		retval = -ENOPROTOOPT;
8285 		break;
8286 	}
8287 
8288 	release_sock(sk);
8289 	return retval;
8290 }
8291 
sctp_bpf_bypass_getsockopt(int level,int optname)8292 static bool sctp_bpf_bypass_getsockopt(int level, int optname)
8293 {
8294 	if (level == SOL_SCTP) {
8295 		switch (optname) {
8296 		case SCTP_SOCKOPT_PEELOFF:
8297 		case SCTP_SOCKOPT_PEELOFF_FLAGS:
8298 		case SCTP_SOCKOPT_CONNECTX3:
8299 			return true;
8300 		default:
8301 			return false;
8302 		}
8303 	}
8304 
8305 	return false;
8306 }
8307 
sctp_hash(struct sock * sk)8308 static int sctp_hash(struct sock *sk)
8309 {
8310 	/* STUB */
8311 	return 0;
8312 }
8313 
sctp_unhash(struct sock * sk)8314 static void sctp_unhash(struct sock *sk)
8315 {
8316 	/* STUB */
8317 }
8318 
8319 /* Check if port is acceptable.  Possibly find first available port.
8320  *
8321  * The port hash table (contained in the 'global' SCTP protocol storage
8322  * returned by struct sctp_protocol *sctp_get_protocol()). The hash
8323  * table is an array of 4096 lists (sctp_bind_hashbucket). Each
8324  * list (the list number is the port number hashed out, so as you
8325  * would expect from a hash function, all the ports in a given list have
8326  * such a number that hashes out to the same list number; you were
8327  * expecting that, right?); so each list has a set of ports, with a
8328  * link to the socket (struct sock) that uses it, the port number and
8329  * a fastreuse flag (FIXME: NPI ipg).
8330  */
8331 static struct sctp_bind_bucket *sctp_bucket_create(
8332 	struct sctp_bind_hashbucket *head, struct net *, unsigned short snum);
8333 
sctp_get_port_local(struct sock * sk,union sctp_addr * addr)8334 static int sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
8335 {
8336 	struct sctp_sock *sp = sctp_sk(sk);
8337 	bool reuse = (sk->sk_reuse || sp->reuse);
8338 	struct sctp_bind_hashbucket *head; /* hash list */
8339 	struct net *net = sock_net(sk);
8340 	kuid_t uid = sock_i_uid(sk);
8341 	struct sctp_bind_bucket *pp;
8342 	unsigned short snum;
8343 	int ret;
8344 
8345 	snum = ntohs(addr->v4.sin_port);
8346 
8347 	pr_debug("%s: begins, snum:%d\n", __func__, snum);
8348 
8349 	if (snum == 0) {
8350 		/* Search for an available port. */
8351 		int low, high, remaining, index;
8352 		unsigned int rover;
8353 
8354 		inet_sk_get_local_port_range(sk, &low, &high);
8355 		remaining = (high - low) + 1;
8356 		rover = get_random_u32_below(remaining) + low;
8357 
8358 		do {
8359 			rover++;
8360 			if ((rover < low) || (rover > high))
8361 				rover = low;
8362 			if (inet_is_local_reserved_port(net, rover))
8363 				continue;
8364 			index = sctp_phashfn(net, rover);
8365 			head = &sctp_port_hashtable[index];
8366 			spin_lock_bh(&head->lock);
8367 			sctp_for_each_hentry(pp, &head->chain)
8368 				if ((pp->port == rover) &&
8369 				    net_eq(net, pp->net))
8370 					goto next;
8371 			break;
8372 		next:
8373 			spin_unlock_bh(&head->lock);
8374 			cond_resched();
8375 		} while (--remaining > 0);
8376 
8377 		/* Exhausted local port range during search? */
8378 		ret = 1;
8379 		if (remaining <= 0)
8380 			return ret;
8381 
8382 		/* OK, here is the one we will use.  HEAD (the port
8383 		 * hash table list entry) is non-NULL and we hold it's
8384 		 * mutex.
8385 		 */
8386 		snum = rover;
8387 	} else {
8388 		/* We are given an specific port number; we verify
8389 		 * that it is not being used. If it is used, we will
8390 		 * exahust the search in the hash list corresponding
8391 		 * to the port number (snum) - we detect that with the
8392 		 * port iterator, pp being NULL.
8393 		 */
8394 		head = &sctp_port_hashtable[sctp_phashfn(net, snum)];
8395 		spin_lock_bh(&head->lock);
8396 		sctp_for_each_hentry(pp, &head->chain) {
8397 			if ((pp->port == snum) && net_eq(pp->net, net))
8398 				goto pp_found;
8399 		}
8400 	}
8401 	pp = NULL;
8402 	goto pp_not_found;
8403 pp_found:
8404 	if (!hlist_empty(&pp->owner)) {
8405 		/* We had a port hash table hit - there is an
8406 		 * available port (pp != NULL) and it is being
8407 		 * used by other socket (pp->owner not empty); that other
8408 		 * socket is going to be sk2.
8409 		 */
8410 		struct sock *sk2;
8411 
8412 		pr_debug("%s: found a possible match\n", __func__);
8413 
8414 		if ((pp->fastreuse && reuse &&
8415 		     sk->sk_state != SCTP_SS_LISTENING) ||
8416 		    (pp->fastreuseport && sk->sk_reuseport &&
8417 		     uid_eq(pp->fastuid, uid)))
8418 			goto success;
8419 
8420 		/* Run through the list of sockets bound to the port
8421 		 * (pp->port) [via the pointers bind_next and
8422 		 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
8423 		 * we get the endpoint they describe and run through
8424 		 * the endpoint's list of IP (v4 or v6) addresses,
8425 		 * comparing each of the addresses with the address of
8426 		 * the socket sk. If we find a match, then that means
8427 		 * that this port/socket (sk) combination are already
8428 		 * in an endpoint.
8429 		 */
8430 		sk_for_each_bound(sk2, &pp->owner) {
8431 			int bound_dev_if2 = READ_ONCE(sk2->sk_bound_dev_if);
8432 			struct sctp_sock *sp2 = sctp_sk(sk2);
8433 			struct sctp_endpoint *ep2 = sp2->ep;
8434 
8435 			if (sk == sk2 ||
8436 			    (reuse && (sk2->sk_reuse || sp2->reuse) &&
8437 			     sk2->sk_state != SCTP_SS_LISTENING) ||
8438 			    (sk->sk_reuseport && sk2->sk_reuseport &&
8439 			     uid_eq(uid, sock_i_uid(sk2))))
8440 				continue;
8441 
8442 			if ((!sk->sk_bound_dev_if || !bound_dev_if2 ||
8443 			     sk->sk_bound_dev_if == bound_dev_if2) &&
8444 			    sctp_bind_addr_conflict(&ep2->base.bind_addr,
8445 						    addr, sp2, sp)) {
8446 				ret = 1;
8447 				goto fail_unlock;
8448 			}
8449 		}
8450 
8451 		pr_debug("%s: found a match\n", __func__);
8452 	}
8453 pp_not_found:
8454 	/* If there was a hash table miss, create a new port.  */
8455 	ret = 1;
8456 	if (!pp && !(pp = sctp_bucket_create(head, net, snum)))
8457 		goto fail_unlock;
8458 
8459 	/* In either case (hit or miss), make sure fastreuse is 1 only
8460 	 * if sk->sk_reuse is too (that is, if the caller requested
8461 	 * SO_REUSEADDR on this socket -sk-).
8462 	 */
8463 	if (hlist_empty(&pp->owner)) {
8464 		if (reuse && sk->sk_state != SCTP_SS_LISTENING)
8465 			pp->fastreuse = 1;
8466 		else
8467 			pp->fastreuse = 0;
8468 
8469 		if (sk->sk_reuseport) {
8470 			pp->fastreuseport = 1;
8471 			pp->fastuid = uid;
8472 		} else {
8473 			pp->fastreuseport = 0;
8474 		}
8475 	} else {
8476 		if (pp->fastreuse &&
8477 		    (!reuse || sk->sk_state == SCTP_SS_LISTENING))
8478 			pp->fastreuse = 0;
8479 
8480 		if (pp->fastreuseport &&
8481 		    (!sk->sk_reuseport || !uid_eq(pp->fastuid, uid)))
8482 			pp->fastreuseport = 0;
8483 	}
8484 
8485 	/* We are set, so fill up all the data in the hash table
8486 	 * entry, tie the socket list information with the rest of the
8487 	 * sockets FIXME: Blurry, NPI (ipg).
8488 	 */
8489 success:
8490 	if (!sp->bind_hash) {
8491 		inet_sk(sk)->inet_num = snum;
8492 		sk_add_bind_node(sk, &pp->owner);
8493 		sp->bind_hash = pp;
8494 	}
8495 	ret = 0;
8496 
8497 fail_unlock:
8498 	spin_unlock_bh(&head->lock);
8499 	return ret;
8500 }
8501 
8502 /* Assign a 'snum' port to the socket.  If snum == 0, an ephemeral
8503  * port is requested.
8504  */
sctp_get_port(struct sock * sk,unsigned short snum)8505 static int sctp_get_port(struct sock *sk, unsigned short snum)
8506 {
8507 	union sctp_addr addr;
8508 	struct sctp_af *af = sctp_sk(sk)->pf->af;
8509 
8510 	/* Set up a dummy address struct from the sk. */
8511 	af->from_sk(&addr, sk);
8512 	addr.v4.sin_port = htons(snum);
8513 
8514 	/* Note: sk->sk_num gets filled in if ephemeral port request. */
8515 	return sctp_get_port_local(sk, &addr);
8516 }
8517 
8518 /*
8519  *  Move a socket to LISTENING state.
8520  */
sctp_listen_start(struct sock * sk,int backlog)8521 static int sctp_listen_start(struct sock *sk, int backlog)
8522 {
8523 	struct sctp_sock *sp = sctp_sk(sk);
8524 	struct sctp_endpoint *ep = sp->ep;
8525 	struct crypto_shash *tfm = NULL;
8526 	char alg[32];
8527 
8528 	/* Allocate HMAC for generating cookie. */
8529 	if (!sp->hmac && sp->sctp_hmac_alg) {
8530 		sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
8531 		tfm = crypto_alloc_shash(alg, 0, 0);
8532 		if (IS_ERR(tfm)) {
8533 			net_info_ratelimited("failed to load transform for %s: %ld\n",
8534 					     sp->sctp_hmac_alg, PTR_ERR(tfm));
8535 			return -ENOSYS;
8536 		}
8537 		sctp_sk(sk)->hmac = tfm;
8538 	}
8539 
8540 	/*
8541 	 * If a bind() or sctp_bindx() is not called prior to a listen()
8542 	 * call that allows new associations to be accepted, the system
8543 	 * picks an ephemeral port and will choose an address set equivalent
8544 	 * to binding with a wildcard address.
8545 	 *
8546 	 * This is not currently spelled out in the SCTP sockets
8547 	 * extensions draft, but follows the practice as seen in TCP
8548 	 * sockets.
8549 	 *
8550 	 */
8551 	inet_sk_set_state(sk, SCTP_SS_LISTENING);
8552 	if (!ep->base.bind_addr.port) {
8553 		if (sctp_autobind(sk))
8554 			return -EAGAIN;
8555 	} else {
8556 		if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
8557 			inet_sk_set_state(sk, SCTP_SS_CLOSED);
8558 			return -EADDRINUSE;
8559 		}
8560 	}
8561 
8562 	WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8563 	return sctp_hash_endpoint(ep);
8564 }
8565 
8566 /*
8567  * 4.1.3 / 5.1.3 listen()
8568  *
8569  *   By default, new associations are not accepted for UDP style sockets.
8570  *   An application uses listen() to mark a socket as being able to
8571  *   accept new associations.
8572  *
8573  *   On TCP style sockets, applications use listen() to ready the SCTP
8574  *   endpoint for accepting inbound associations.
8575  *
8576  *   On both types of endpoints a backlog of '0' disables listening.
8577  *
8578  *  Move a socket to LISTENING state.
8579  */
sctp_inet_listen(struct socket * sock,int backlog)8580 int sctp_inet_listen(struct socket *sock, int backlog)
8581 {
8582 	struct sock *sk = sock->sk;
8583 	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
8584 	int err = -EINVAL;
8585 
8586 	if (unlikely(backlog < 0))
8587 		return err;
8588 
8589 	lock_sock(sk);
8590 
8591 	/* Peeled-off sockets are not allowed to listen().  */
8592 	if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
8593 		goto out;
8594 
8595 	if (sock->state != SS_UNCONNECTED)
8596 		goto out;
8597 
8598 	if (!sctp_sstate(sk, LISTENING) && !sctp_sstate(sk, CLOSED))
8599 		goto out;
8600 
8601 	/* If backlog is zero, disable listening. */
8602 	if (!backlog) {
8603 		if (sctp_sstate(sk, CLOSED))
8604 			goto out;
8605 
8606 		err = 0;
8607 		sctp_unhash_endpoint(ep);
8608 		sk->sk_state = SCTP_SS_CLOSED;
8609 		if (sk->sk_reuse || sctp_sk(sk)->reuse)
8610 			sctp_sk(sk)->bind_hash->fastreuse = 1;
8611 		goto out;
8612 	}
8613 
8614 	/* If we are already listening, just update the backlog */
8615 	if (sctp_sstate(sk, LISTENING))
8616 		WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8617 	else {
8618 		err = sctp_listen_start(sk, backlog);
8619 		if (err)
8620 			goto out;
8621 	}
8622 
8623 	err = 0;
8624 out:
8625 	release_sock(sk);
8626 	return err;
8627 }
8628 
8629 /*
8630  * This function is done by modeling the current datagram_poll() and the
8631  * tcp_poll().  Note that, based on these implementations, we don't
8632  * lock the socket in this function, even though it seems that,
8633  * ideally, locking or some other mechanisms can be used to ensure
8634  * the integrity of the counters (sndbuf and wmem_alloc) used
8635  * in this place.  We assume that we don't need locks either until proven
8636  * otherwise.
8637  *
8638  * Another thing to note is that we include the Async I/O support
8639  * here, again, by modeling the current TCP/UDP code.  We don't have
8640  * a good way to test with it yet.
8641  */
sctp_poll(struct file * file,struct socket * sock,poll_table * wait)8642 __poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
8643 {
8644 	struct sock *sk = sock->sk;
8645 	struct sctp_sock *sp = sctp_sk(sk);
8646 	__poll_t mask;
8647 
8648 	poll_wait(file, sk_sleep(sk), wait);
8649 
8650 	sock_rps_record_flow(sk);
8651 
8652 	/* A TCP-style listening socket becomes readable when the accept queue
8653 	 * is not empty.
8654 	 */
8655 	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
8656 		return (!list_empty(&sp->ep->asocs)) ?
8657 			(EPOLLIN | EPOLLRDNORM) : 0;
8658 
8659 	mask = 0;
8660 
8661 	/* Is there any exceptional events?  */
8662 	if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
8663 		mask |= EPOLLERR |
8664 			(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
8665 	if (sk->sk_shutdown & RCV_SHUTDOWN)
8666 		mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
8667 	if (sk->sk_shutdown == SHUTDOWN_MASK)
8668 		mask |= EPOLLHUP;
8669 
8670 	/* Is it readable?  Reconsider this code with TCP-style support.  */
8671 	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
8672 		mask |= EPOLLIN | EPOLLRDNORM;
8673 
8674 	/* The association is either gone or not ready.  */
8675 	if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
8676 		return mask;
8677 
8678 	/* Is it writable?  */
8679 	if (sctp_writeable(sk)) {
8680 		mask |= EPOLLOUT | EPOLLWRNORM;
8681 	} else {
8682 		sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
8683 		/*
8684 		 * Since the socket is not locked, the buffer
8685 		 * might be made available after the writeable check and
8686 		 * before the bit is set.  This could cause a lost I/O
8687 		 * signal.  tcp_poll() has a race breaker for this race
8688 		 * condition.  Based on their implementation, we put
8689 		 * in the following code to cover it as well.
8690 		 */
8691 		if (sctp_writeable(sk))
8692 			mask |= EPOLLOUT | EPOLLWRNORM;
8693 	}
8694 	return mask;
8695 }
8696 
8697 /********************************************************************
8698  * 2nd Level Abstractions
8699  ********************************************************************/
8700 
sctp_bucket_create(struct sctp_bind_hashbucket * head,struct net * net,unsigned short snum)8701 static struct sctp_bind_bucket *sctp_bucket_create(
8702 	struct sctp_bind_hashbucket *head, struct net *net, unsigned short snum)
8703 {
8704 	struct sctp_bind_bucket *pp;
8705 
8706 	pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC);
8707 	if (pp) {
8708 		SCTP_DBG_OBJCNT_INC(bind_bucket);
8709 		pp->port = snum;
8710 		pp->fastreuse = 0;
8711 		INIT_HLIST_HEAD(&pp->owner);
8712 		pp->net = net;
8713 		hlist_add_head(&pp->node, &head->chain);
8714 	}
8715 	return pp;
8716 }
8717 
8718 /* Caller must hold hashbucket lock for this tb with local BH disabled */
sctp_bucket_destroy(struct sctp_bind_bucket * pp)8719 static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
8720 {
8721 	if (pp && hlist_empty(&pp->owner)) {
8722 		__hlist_del(&pp->node);
8723 		kmem_cache_free(sctp_bucket_cachep, pp);
8724 		SCTP_DBG_OBJCNT_DEC(bind_bucket);
8725 	}
8726 }
8727 
8728 /* Release this socket's reference to a local port.  */
__sctp_put_port(struct sock * sk)8729 static inline void __sctp_put_port(struct sock *sk)
8730 {
8731 	struct sctp_bind_hashbucket *head =
8732 		&sctp_port_hashtable[sctp_phashfn(sock_net(sk),
8733 						  inet_sk(sk)->inet_num)];
8734 	struct sctp_bind_bucket *pp;
8735 
8736 	spin_lock(&head->lock);
8737 	pp = sctp_sk(sk)->bind_hash;
8738 	__sk_del_bind_node(sk);
8739 	sctp_sk(sk)->bind_hash = NULL;
8740 	inet_sk(sk)->inet_num = 0;
8741 	sctp_bucket_destroy(pp);
8742 	spin_unlock(&head->lock);
8743 }
8744 
sctp_put_port(struct sock * sk)8745 void sctp_put_port(struct sock *sk)
8746 {
8747 	local_bh_disable();
8748 	__sctp_put_port(sk);
8749 	local_bh_enable();
8750 }
8751 
8752 /*
8753  * The system picks an ephemeral port and choose an address set equivalent
8754  * to binding with a wildcard address.
8755  * One of those addresses will be the primary address for the association.
8756  * This automatically enables the multihoming capability of SCTP.
8757  */
sctp_autobind(struct sock * sk)8758 static int sctp_autobind(struct sock *sk)
8759 {
8760 	union sctp_addr autoaddr;
8761 	struct sctp_af *af;
8762 	__be16 port;
8763 
8764 	/* Initialize a local sockaddr structure to INADDR_ANY. */
8765 	af = sctp_sk(sk)->pf->af;
8766 
8767 	port = htons(inet_sk(sk)->inet_num);
8768 	af->inaddr_any(&autoaddr, port);
8769 
8770 	return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
8771 }
8772 
8773 /* Parse out IPPROTO_SCTP CMSG headers.  Perform only minimal validation.
8774  *
8775  * From RFC 2292
8776  * 4.2 The cmsghdr Structure *
8777  *
8778  * When ancillary data is sent or received, any number of ancillary data
8779  * objects can be specified by the msg_control and msg_controllen members of
8780  * the msghdr structure, because each object is preceded by
8781  * a cmsghdr structure defining the object's length (the cmsg_len member).
8782  * Historically Berkeley-derived implementations have passed only one object
8783  * at a time, but this API allows multiple objects to be
8784  * passed in a single call to sendmsg() or recvmsg(). The following example
8785  * shows two ancillary data objects in a control buffer.
8786  *
8787  *   |<--------------------------- msg_controllen -------------------------->|
8788  *   |                                                                       |
8789  *
8790  *   |<----- ancillary data object ----->|<----- ancillary data object ----->|
8791  *
8792  *   |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8793  *   |                                   |                                   |
8794  *
8795  *   |<---------- cmsg_len ---------->|  |<--------- cmsg_len ----------->|  |
8796  *
8797  *   |<--------- CMSG_LEN() --------->|  |<-------- CMSG_LEN() ---------->|  |
8798  *   |                                |  |                                |  |
8799  *
8800  *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8801  *   |cmsg_|cmsg_|cmsg_|XX|           |XX|cmsg_|cmsg_|cmsg_|XX|           |XX|
8802  *
8803  *   |len  |level|type |XX|cmsg_data[]|XX|len  |level|type |XX|cmsg_data[]|XX|
8804  *
8805  *   +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8806  *    ^
8807  *    |
8808  *
8809  * msg_control
8810  * points here
8811  */
sctp_msghdr_parse(const struct msghdr * msg,struct sctp_cmsgs * cmsgs)8812 static int sctp_msghdr_parse(const struct msghdr *msg, struct sctp_cmsgs *cmsgs)
8813 {
8814 	struct msghdr *my_msg = (struct msghdr *)msg;
8815 	struct cmsghdr *cmsg;
8816 
8817 	for_each_cmsghdr(cmsg, my_msg) {
8818 		if (!CMSG_OK(my_msg, cmsg))
8819 			return -EINVAL;
8820 
8821 		/* Should we parse this header or ignore?  */
8822 		if (cmsg->cmsg_level != IPPROTO_SCTP)
8823 			continue;
8824 
8825 		/* Strictly check lengths following example in SCM code.  */
8826 		switch (cmsg->cmsg_type) {
8827 		case SCTP_INIT:
8828 			/* SCTP Socket API Extension
8829 			 * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
8830 			 *
8831 			 * This cmsghdr structure provides information for
8832 			 * initializing new SCTP associations with sendmsg().
8833 			 * The SCTP_INITMSG socket option uses this same data
8834 			 * structure.  This structure is not used for
8835 			 * recvmsg().
8836 			 *
8837 			 * cmsg_level    cmsg_type      cmsg_data[]
8838 			 * ------------  ------------   ----------------------
8839 			 * IPPROTO_SCTP  SCTP_INIT      struct sctp_initmsg
8840 			 */
8841 			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_initmsg)))
8842 				return -EINVAL;
8843 
8844 			cmsgs->init = CMSG_DATA(cmsg);
8845 			break;
8846 
8847 		case SCTP_SNDRCV:
8848 			/* SCTP Socket API Extension
8849 			 * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
8850 			 *
8851 			 * This cmsghdr structure specifies SCTP options for
8852 			 * sendmsg() and describes SCTP header information
8853 			 * about a received message through recvmsg().
8854 			 *
8855 			 * cmsg_level    cmsg_type      cmsg_data[]
8856 			 * ------------  ------------   ----------------------
8857 			 * IPPROTO_SCTP  SCTP_SNDRCV    struct sctp_sndrcvinfo
8858 			 */
8859 			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
8860 				return -EINVAL;
8861 
8862 			cmsgs->srinfo = CMSG_DATA(cmsg);
8863 
8864 			if (cmsgs->srinfo->sinfo_flags &
8865 			    ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8866 			      SCTP_SACK_IMMEDIATELY | SCTP_SENDALL |
8867 			      SCTP_PR_SCTP_MASK | SCTP_ABORT | SCTP_EOF))
8868 				return -EINVAL;
8869 			break;
8870 
8871 		case SCTP_SNDINFO:
8872 			/* SCTP Socket API Extension
8873 			 * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
8874 			 *
8875 			 * This cmsghdr structure specifies SCTP options for
8876 			 * sendmsg(). This structure and SCTP_RCVINFO replaces
8877 			 * SCTP_SNDRCV which has been deprecated.
8878 			 *
8879 			 * cmsg_level    cmsg_type      cmsg_data[]
8880 			 * ------------  ------------   ---------------------
8881 			 * IPPROTO_SCTP  SCTP_SNDINFO    struct sctp_sndinfo
8882 			 */
8883 			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndinfo)))
8884 				return -EINVAL;
8885 
8886 			cmsgs->sinfo = CMSG_DATA(cmsg);
8887 
8888 			if (cmsgs->sinfo->snd_flags &
8889 			    ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8890 			      SCTP_SACK_IMMEDIATELY | SCTP_SENDALL |
8891 			      SCTP_PR_SCTP_MASK | SCTP_ABORT | SCTP_EOF))
8892 				return -EINVAL;
8893 			break;
8894 		case SCTP_PRINFO:
8895 			/* SCTP Socket API Extension
8896 			 * 5.3.7 SCTP PR-SCTP Information Structure (SCTP_PRINFO)
8897 			 *
8898 			 * This cmsghdr structure specifies SCTP options for sendmsg().
8899 			 *
8900 			 * cmsg_level    cmsg_type      cmsg_data[]
8901 			 * ------------  ------------   ---------------------
8902 			 * IPPROTO_SCTP  SCTP_PRINFO    struct sctp_prinfo
8903 			 */
8904 			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_prinfo)))
8905 				return -EINVAL;
8906 
8907 			cmsgs->prinfo = CMSG_DATA(cmsg);
8908 			if (cmsgs->prinfo->pr_policy & ~SCTP_PR_SCTP_MASK)
8909 				return -EINVAL;
8910 
8911 			if (cmsgs->prinfo->pr_policy == SCTP_PR_SCTP_NONE)
8912 				cmsgs->prinfo->pr_value = 0;
8913 			break;
8914 		case SCTP_AUTHINFO:
8915 			/* SCTP Socket API Extension
8916 			 * 5.3.8 SCTP AUTH Information Structure (SCTP_AUTHINFO)
8917 			 *
8918 			 * This cmsghdr structure specifies SCTP options for sendmsg().
8919 			 *
8920 			 * cmsg_level    cmsg_type      cmsg_data[]
8921 			 * ------------  ------------   ---------------------
8922 			 * IPPROTO_SCTP  SCTP_AUTHINFO  struct sctp_authinfo
8923 			 */
8924 			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_authinfo)))
8925 				return -EINVAL;
8926 
8927 			cmsgs->authinfo = CMSG_DATA(cmsg);
8928 			break;
8929 		case SCTP_DSTADDRV4:
8930 		case SCTP_DSTADDRV6:
8931 			/* SCTP Socket API Extension
8932 			 * 5.3.9/10 SCTP Destination IPv4/6 Address Structure (SCTP_DSTADDRV4/6)
8933 			 *
8934 			 * This cmsghdr structure specifies SCTP options for sendmsg().
8935 			 *
8936 			 * cmsg_level    cmsg_type         cmsg_data[]
8937 			 * ------------  ------------   ---------------------
8938 			 * IPPROTO_SCTP  SCTP_DSTADDRV4 struct in_addr
8939 			 * ------------  ------------   ---------------------
8940 			 * IPPROTO_SCTP  SCTP_DSTADDRV6 struct in6_addr
8941 			 */
8942 			cmsgs->addrs_msg = my_msg;
8943 			break;
8944 		default:
8945 			return -EINVAL;
8946 		}
8947 	}
8948 
8949 	return 0;
8950 }
8951 
8952 /*
8953  * Wait for a packet..
8954  * Note: This function is the same function as in core/datagram.c
8955  * with a few modifications to make lksctp work.
8956  */
sctp_wait_for_packet(struct sock * sk,int * err,long * timeo_p)8957 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p)
8958 {
8959 	int error;
8960 	DEFINE_WAIT(wait);
8961 
8962 	prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
8963 
8964 	/* Socket errors? */
8965 	error = sock_error(sk);
8966 	if (error)
8967 		goto out;
8968 
8969 	if (!skb_queue_empty(&sk->sk_receive_queue))
8970 		goto ready;
8971 
8972 	/* Socket shut down?  */
8973 	if (sk->sk_shutdown & RCV_SHUTDOWN)
8974 		goto out;
8975 
8976 	/* Sequenced packets can come disconnected.  If so we report the
8977 	 * problem.
8978 	 */
8979 	error = -ENOTCONN;
8980 
8981 	/* Is there a good reason to think that we may receive some data?  */
8982 	if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
8983 		goto out;
8984 
8985 	/* Handle signals.  */
8986 	if (signal_pending(current))
8987 		goto interrupted;
8988 
8989 	/* Let another process have a go.  Since we are going to sleep
8990 	 * anyway.  Note: This may cause odd behaviors if the message
8991 	 * does not fit in the user's buffer, but this seems to be the
8992 	 * only way to honor MSG_DONTWAIT realistically.
8993 	 */
8994 	release_sock(sk);
8995 	*timeo_p = schedule_timeout(*timeo_p);
8996 	lock_sock(sk);
8997 
8998 ready:
8999 	finish_wait(sk_sleep(sk), &wait);
9000 	return 0;
9001 
9002 interrupted:
9003 	error = sock_intr_errno(*timeo_p);
9004 
9005 out:
9006 	finish_wait(sk_sleep(sk), &wait);
9007 	*err = error;
9008 	return error;
9009 }
9010 
9011 /* Receive a datagram.
9012  * Note: This is pretty much the same routine as in core/datagram.c
9013  * with a few changes to make lksctp work.
9014  */
sctp_skb_recv_datagram(struct sock * sk,int flags,int * err)9015 struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, int *err)
9016 {
9017 	int error;
9018 	struct sk_buff *skb;
9019 	long timeo;
9020 
9021 	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
9022 
9023 	pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo,
9024 		 MAX_SCHEDULE_TIMEOUT);
9025 
9026 	do {
9027 		/* Again only user level code calls this function,
9028 		 * so nothing interrupt level
9029 		 * will suddenly eat the receive_queue.
9030 		 *
9031 		 *  Look at current nfs client by the way...
9032 		 *  However, this function was correct in any case. 8)
9033 		 */
9034 		if (flags & MSG_PEEK) {
9035 			skb = skb_peek(&sk->sk_receive_queue);
9036 			if (skb)
9037 				refcount_inc(&skb->users);
9038 		} else {
9039 			skb = __skb_dequeue(&sk->sk_receive_queue);
9040 		}
9041 
9042 		if (skb)
9043 			return skb;
9044 
9045 		/* Caller is allowed not to check sk->sk_err before calling. */
9046 		error = sock_error(sk);
9047 		if (error)
9048 			goto no_packet;
9049 
9050 		if (sk->sk_shutdown & RCV_SHUTDOWN)
9051 			break;
9052 
9053 
9054 		/* User doesn't want to wait.  */
9055 		error = -EAGAIN;
9056 		if (!timeo)
9057 			goto no_packet;
9058 	} while (sctp_wait_for_packet(sk, err, &timeo) == 0);
9059 
9060 	return NULL;
9061 
9062 no_packet:
9063 	*err = error;
9064 	return NULL;
9065 }
9066 
9067 /* If sndbuf has changed, wake up per association sndbuf waiters.  */
__sctp_write_space(struct sctp_association * asoc)9068 static void __sctp_write_space(struct sctp_association *asoc)
9069 {
9070 	struct sock *sk = asoc->base.sk;
9071 
9072 	if (sctp_wspace(asoc) <= 0)
9073 		return;
9074 
9075 	if (waitqueue_active(&asoc->wait))
9076 		wake_up_interruptible(&asoc->wait);
9077 
9078 	if (sctp_writeable(sk)) {
9079 		struct socket_wq *wq;
9080 
9081 		rcu_read_lock();
9082 		wq = rcu_dereference(sk->sk_wq);
9083 		if (wq) {
9084 			if (waitqueue_active(&wq->wait))
9085 				wake_up_interruptible(&wq->wait);
9086 
9087 			/* Note that we try to include the Async I/O support
9088 			 * here by modeling from the current TCP/UDP code.
9089 			 * We have not tested with it yet.
9090 			 */
9091 			if (!(sk->sk_shutdown & SEND_SHUTDOWN))
9092 				sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
9093 		}
9094 		rcu_read_unlock();
9095 	}
9096 }
9097 
sctp_wake_up_waiters(struct sock * sk,struct sctp_association * asoc)9098 static void sctp_wake_up_waiters(struct sock *sk,
9099 				 struct sctp_association *asoc)
9100 {
9101 	struct sctp_association *tmp = asoc;
9102 
9103 	/* We do accounting for the sndbuf space per association,
9104 	 * so we only need to wake our own association.
9105 	 */
9106 	if (asoc->ep->sndbuf_policy)
9107 		return __sctp_write_space(asoc);
9108 
9109 	/* If association goes down and is just flushing its
9110 	 * outq, then just normally notify others.
9111 	 */
9112 	if (asoc->base.dead)
9113 		return sctp_write_space(sk);
9114 
9115 	/* Accounting for the sndbuf space is per socket, so we
9116 	 * need to wake up others, try to be fair and in case of
9117 	 * other associations, let them have a go first instead
9118 	 * of just doing a sctp_write_space() call.
9119 	 *
9120 	 * Note that we reach sctp_wake_up_waiters() only when
9121 	 * associations free up queued chunks, thus we are under
9122 	 * lock and the list of associations on a socket is
9123 	 * guaranteed not to change.
9124 	 */
9125 	for (tmp = list_next_entry(tmp, asocs); 1;
9126 	     tmp = list_next_entry(tmp, asocs)) {
9127 		/* Manually skip the head element. */
9128 		if (&tmp->asocs == &((sctp_sk(sk))->ep->asocs))
9129 			continue;
9130 		/* Wake up association. */
9131 		__sctp_write_space(tmp);
9132 		/* We've reached the end. */
9133 		if (tmp == asoc)
9134 			break;
9135 	}
9136 }
9137 
9138 /* Do accounting for the sndbuf space.
9139  * Decrement the used sndbuf space of the corresponding association by the
9140  * data size which was just transmitted(freed).
9141  */
sctp_wfree(struct sk_buff * skb)9142 static void sctp_wfree(struct sk_buff *skb)
9143 {
9144 	struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
9145 	struct sctp_association *asoc = chunk->asoc;
9146 	struct sock *sk = asoc->base.sk;
9147 
9148 	sk_mem_uncharge(sk, skb->truesize);
9149 	sk_wmem_queued_add(sk, -(skb->truesize + sizeof(struct sctp_chunk)));
9150 	asoc->sndbuf_used -= skb->truesize + sizeof(struct sctp_chunk);
9151 	WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk),
9152 				      &sk->sk_wmem_alloc));
9153 
9154 	if (chunk->shkey) {
9155 		struct sctp_shared_key *shkey = chunk->shkey;
9156 
9157 		/* refcnt == 2 and !list_empty mean after this release, it's
9158 		 * not being used anywhere, and it's time to notify userland
9159 		 * that this shkey can be freed if it's been deactivated.
9160 		 */
9161 		if (shkey->deactivated && !list_empty(&shkey->key_list) &&
9162 		    refcount_read(&shkey->refcnt) == 2) {
9163 			struct sctp_ulpevent *ev;
9164 
9165 			ev = sctp_ulpevent_make_authkey(asoc, shkey->key_id,
9166 							SCTP_AUTH_FREE_KEY,
9167 							GFP_KERNEL);
9168 			if (ev)
9169 				asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
9170 		}
9171 		sctp_auth_shkey_release(chunk->shkey);
9172 	}
9173 
9174 	sock_wfree(skb);
9175 	sctp_wake_up_waiters(sk, asoc);
9176 
9177 	sctp_association_put(asoc);
9178 }
9179 
9180 /* Do accounting for the receive space on the socket.
9181  * Accounting for the association is done in ulpevent.c
9182  * We set this as a destructor for the cloned data skbs so that
9183  * accounting is done at the correct time.
9184  */
sctp_sock_rfree(struct sk_buff * skb)9185 void sctp_sock_rfree(struct sk_buff *skb)
9186 {
9187 	struct sock *sk = skb->sk;
9188 	struct sctp_ulpevent *event = sctp_skb2event(skb);
9189 
9190 	atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
9191 
9192 	/*
9193 	 * Mimic the behavior of sock_rfree
9194 	 */
9195 	sk_mem_uncharge(sk, event->rmem_len);
9196 }
9197 
9198 
9199 /* Helper function to wait for space in the sndbuf.  */
sctp_wait_for_sndbuf(struct sctp_association * asoc,long * timeo_p,size_t msg_len)9200 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
9201 				size_t msg_len)
9202 {
9203 	struct sock *sk = asoc->base.sk;
9204 	long current_timeo = *timeo_p;
9205 	DEFINE_WAIT(wait);
9206 	int err = 0;
9207 
9208 	pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc,
9209 		 *timeo_p, msg_len);
9210 
9211 	/* Increment the association's refcnt.  */
9212 	sctp_association_hold(asoc);
9213 
9214 	/* Wait on the association specific sndbuf space. */
9215 	for (;;) {
9216 		prepare_to_wait_exclusive(&asoc->wait, &wait,
9217 					  TASK_INTERRUPTIBLE);
9218 		if (asoc->base.dead)
9219 			goto do_dead;
9220 		if (!*timeo_p)
9221 			goto do_nonblock;
9222 		if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING)
9223 			goto do_error;
9224 		if (signal_pending(current))
9225 			goto do_interrupted;
9226 		if ((int)msg_len <= sctp_wspace(asoc) &&
9227 		    sk_wmem_schedule(sk, msg_len))
9228 			break;
9229 
9230 		/* Let another process have a go.  Since we are going
9231 		 * to sleep anyway.
9232 		 */
9233 		release_sock(sk);
9234 		current_timeo = schedule_timeout(current_timeo);
9235 		lock_sock(sk);
9236 		if (sk != asoc->base.sk)
9237 			goto do_error;
9238 
9239 		*timeo_p = current_timeo;
9240 	}
9241 
9242 out:
9243 	finish_wait(&asoc->wait, &wait);
9244 
9245 	/* Release the association's refcnt.  */
9246 	sctp_association_put(asoc);
9247 
9248 	return err;
9249 
9250 do_dead:
9251 	err = -ESRCH;
9252 	goto out;
9253 
9254 do_error:
9255 	err = -EPIPE;
9256 	goto out;
9257 
9258 do_interrupted:
9259 	err = sock_intr_errno(*timeo_p);
9260 	goto out;
9261 
9262 do_nonblock:
9263 	err = -EAGAIN;
9264 	goto out;
9265 }
9266 
sctp_data_ready(struct sock * sk)9267 void sctp_data_ready(struct sock *sk)
9268 {
9269 	struct socket_wq *wq;
9270 
9271 	trace_sk_data_ready(sk);
9272 
9273 	rcu_read_lock();
9274 	wq = rcu_dereference(sk->sk_wq);
9275 	if (skwq_has_sleeper(wq))
9276 		wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
9277 						EPOLLRDNORM | EPOLLRDBAND);
9278 	sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
9279 	rcu_read_unlock();
9280 }
9281 
9282 /* If socket sndbuf has changed, wake up all per association waiters.  */
sctp_write_space(struct sock * sk)9283 void sctp_write_space(struct sock *sk)
9284 {
9285 	struct sctp_association *asoc;
9286 
9287 	/* Wake up the tasks in each wait queue.  */
9288 	list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
9289 		__sctp_write_space(asoc);
9290 	}
9291 }
9292 
9293 /* Is there any sndbuf space available on the socket?
9294  *
9295  * Note that sk_wmem_alloc is the sum of the send buffers on all of the
9296  * associations on the same socket.  For a UDP-style socket with
9297  * multiple associations, it is possible for it to be "unwriteable"
9298  * prematurely.  I assume that this is acceptable because
9299  * a premature "unwriteable" is better than an accidental "writeable" which
9300  * would cause an unwanted block under certain circumstances.  For the 1-1
9301  * UDP-style sockets or TCP-style sockets, this code should work.
9302  *  - Daisy
9303  */
sctp_writeable(const struct sock * sk)9304 static bool sctp_writeable(const struct sock *sk)
9305 {
9306 	return READ_ONCE(sk->sk_sndbuf) > READ_ONCE(sk->sk_wmem_queued);
9307 }
9308 
9309 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
9310  * returns immediately with EINPROGRESS.
9311  */
sctp_wait_for_connect(struct sctp_association * asoc,long * timeo_p)9312 static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
9313 {
9314 	struct sock *sk = asoc->base.sk;
9315 	int err = 0;
9316 	long current_timeo = *timeo_p;
9317 	DEFINE_WAIT(wait);
9318 
9319 	pr_debug("%s: asoc:%p, timeo:%ld\n", __func__, asoc, *timeo_p);
9320 
9321 	/* Increment the association's refcnt.  */
9322 	sctp_association_hold(asoc);
9323 
9324 	for (;;) {
9325 		prepare_to_wait_exclusive(&asoc->wait, &wait,
9326 					  TASK_INTERRUPTIBLE);
9327 		if (!*timeo_p)
9328 			goto do_nonblock;
9329 		if (sk->sk_shutdown & RCV_SHUTDOWN)
9330 			break;
9331 		if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
9332 		    asoc->base.dead)
9333 			goto do_error;
9334 		if (signal_pending(current))
9335 			goto do_interrupted;
9336 
9337 		if (sctp_state(asoc, ESTABLISHED))
9338 			break;
9339 
9340 		/* Let another process have a go.  Since we are going
9341 		 * to sleep anyway.
9342 		 */
9343 		release_sock(sk);
9344 		current_timeo = schedule_timeout(current_timeo);
9345 		lock_sock(sk);
9346 
9347 		*timeo_p = current_timeo;
9348 	}
9349 
9350 out:
9351 	finish_wait(&asoc->wait, &wait);
9352 
9353 	/* Release the association's refcnt.  */
9354 	sctp_association_put(asoc);
9355 
9356 	return err;
9357 
9358 do_error:
9359 	if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
9360 		err = -ETIMEDOUT;
9361 	else
9362 		err = -ECONNREFUSED;
9363 	goto out;
9364 
9365 do_interrupted:
9366 	err = sock_intr_errno(*timeo_p);
9367 	goto out;
9368 
9369 do_nonblock:
9370 	err = -EINPROGRESS;
9371 	goto out;
9372 }
9373 
sctp_wait_for_accept(struct sock * sk,long timeo)9374 static int sctp_wait_for_accept(struct sock *sk, long timeo)
9375 {
9376 	struct sctp_endpoint *ep;
9377 	int err = 0;
9378 	DEFINE_WAIT(wait);
9379 
9380 	ep = sctp_sk(sk)->ep;
9381 
9382 
9383 	for (;;) {
9384 		prepare_to_wait_exclusive(sk_sleep(sk), &wait,
9385 					  TASK_INTERRUPTIBLE);
9386 
9387 		if (list_empty(&ep->asocs)) {
9388 			release_sock(sk);
9389 			timeo = schedule_timeout(timeo);
9390 			lock_sock(sk);
9391 		}
9392 
9393 		err = -EINVAL;
9394 		if (!sctp_sstate(sk, LISTENING))
9395 			break;
9396 
9397 		err = 0;
9398 		if (!list_empty(&ep->asocs))
9399 			break;
9400 
9401 		err = sock_intr_errno(timeo);
9402 		if (signal_pending(current))
9403 			break;
9404 
9405 		err = -EAGAIN;
9406 		if (!timeo)
9407 			break;
9408 	}
9409 
9410 	finish_wait(sk_sleep(sk), &wait);
9411 
9412 	return err;
9413 }
9414 
sctp_wait_for_close(struct sock * sk,long timeout)9415 static void sctp_wait_for_close(struct sock *sk, long timeout)
9416 {
9417 	DEFINE_WAIT(wait);
9418 
9419 	do {
9420 		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
9421 		if (list_empty(&sctp_sk(sk)->ep->asocs))
9422 			break;
9423 		release_sock(sk);
9424 		timeout = schedule_timeout(timeout);
9425 		lock_sock(sk);
9426 	} while (!signal_pending(current) && timeout);
9427 
9428 	finish_wait(sk_sleep(sk), &wait);
9429 }
9430 
sctp_skb_set_owner_r_frag(struct sk_buff * skb,struct sock * sk)9431 static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
9432 {
9433 	struct sk_buff *frag;
9434 
9435 	if (!skb->data_len)
9436 		goto done;
9437 
9438 	/* Don't forget the fragments. */
9439 	skb_walk_frags(skb, frag)
9440 		sctp_skb_set_owner_r_frag(frag, sk);
9441 
9442 done:
9443 	sctp_skb_set_owner_r(skb, sk);
9444 }
9445 
sctp_copy_sock(struct sock * newsk,struct sock * sk,struct sctp_association * asoc)9446 void sctp_copy_sock(struct sock *newsk, struct sock *sk,
9447 		    struct sctp_association *asoc)
9448 {
9449 	struct inet_sock *inet = inet_sk(sk);
9450 	struct inet_sock *newinet;
9451 	struct sctp_sock *sp = sctp_sk(sk);
9452 
9453 	newsk->sk_type = sk->sk_type;
9454 	newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
9455 	newsk->sk_flags = sk->sk_flags;
9456 	newsk->sk_tsflags = sk->sk_tsflags;
9457 	newsk->sk_no_check_tx = sk->sk_no_check_tx;
9458 	newsk->sk_no_check_rx = sk->sk_no_check_rx;
9459 	newsk->sk_reuse = sk->sk_reuse;
9460 	sctp_sk(newsk)->reuse = sp->reuse;
9461 
9462 	newsk->sk_shutdown = sk->sk_shutdown;
9463 	newsk->sk_destruct = sk->sk_destruct;
9464 	newsk->sk_family = sk->sk_family;
9465 	newsk->sk_protocol = IPPROTO_SCTP;
9466 	newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
9467 	newsk->sk_sndbuf = sk->sk_sndbuf;
9468 	newsk->sk_rcvbuf = sk->sk_rcvbuf;
9469 	newsk->sk_lingertime = sk->sk_lingertime;
9470 	newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
9471 	newsk->sk_sndtimeo = sk->sk_sndtimeo;
9472 	newsk->sk_rxhash = sk->sk_rxhash;
9473 
9474 	newinet = inet_sk(newsk);
9475 
9476 	/* Initialize sk's sport, dport, rcv_saddr and daddr for
9477 	 * getsockname() and getpeername()
9478 	 */
9479 	newinet->inet_sport = inet->inet_sport;
9480 	newinet->inet_saddr = inet->inet_saddr;
9481 	newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
9482 	newinet->inet_dport = htons(asoc->peer.port);
9483 	newinet->pmtudisc = inet->pmtudisc;
9484 	atomic_set(&newinet->inet_id, get_random_u16());
9485 
9486 	newinet->uc_ttl = inet->uc_ttl;
9487 	inet_set_bit(MC_LOOP, newsk);
9488 	newinet->mc_ttl = 1;
9489 	newinet->mc_index = 0;
9490 	newinet->mc_list = NULL;
9491 
9492 	if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
9493 		net_enable_timestamp();
9494 
9495 	/* Set newsk security attributes from original sk and connection
9496 	 * security attribute from asoc.
9497 	 */
9498 	security_sctp_sk_clone(asoc, sk, newsk);
9499 }
9500 
sctp_copy_descendant(struct sock * sk_to,const struct sock * sk_from)9501 static inline void sctp_copy_descendant(struct sock *sk_to,
9502 					const struct sock *sk_from)
9503 {
9504 	size_t ancestor_size = sizeof(struct inet_sock);
9505 
9506 	ancestor_size += sk_from->sk_prot->obj_size;
9507 	ancestor_size -= offsetof(struct sctp_sock, pd_lobby);
9508 	__inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
9509 }
9510 
9511 /* Populate the fields of the newsk from the oldsk and migrate the assoc
9512  * and its messages to the newsk.
9513  */
sctp_sock_migrate(struct sock * oldsk,struct sock * newsk,struct sctp_association * assoc,enum sctp_socket_type type)9514 static int sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
9515 			     struct sctp_association *assoc,
9516 			     enum sctp_socket_type type)
9517 {
9518 	struct sctp_sock *oldsp = sctp_sk(oldsk);
9519 	struct sctp_sock *newsp = sctp_sk(newsk);
9520 	struct sctp_bind_bucket *pp; /* hash list port iterator */
9521 	struct sctp_endpoint *newep = newsp->ep;
9522 	struct sk_buff *skb, *tmp;
9523 	struct sctp_ulpevent *event;
9524 	struct sctp_bind_hashbucket *head;
9525 	int err;
9526 
9527 	/* Migrate socket buffer sizes and all the socket level options to the
9528 	 * new socket.
9529 	 */
9530 	newsk->sk_sndbuf = oldsk->sk_sndbuf;
9531 	newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
9532 	/* Brute force copy old sctp opt. */
9533 	sctp_copy_descendant(newsk, oldsk);
9534 
9535 	/* Restore the ep value that was overwritten with the above structure
9536 	 * copy.
9537 	 */
9538 	newsp->ep = newep;
9539 	newsp->hmac = NULL;
9540 
9541 	/* Hook this new socket in to the bind_hash list. */
9542 	head = &sctp_port_hashtable[sctp_phashfn(sock_net(oldsk),
9543 						 inet_sk(oldsk)->inet_num)];
9544 	spin_lock_bh(&head->lock);
9545 	pp = sctp_sk(oldsk)->bind_hash;
9546 	sk_add_bind_node(newsk, &pp->owner);
9547 	sctp_sk(newsk)->bind_hash = pp;
9548 	inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
9549 	spin_unlock_bh(&head->lock);
9550 
9551 	/* Copy the bind_addr list from the original endpoint to the new
9552 	 * endpoint so that we can handle restarts properly
9553 	 */
9554 	err = sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
9555 				 &oldsp->ep->base.bind_addr, GFP_KERNEL);
9556 	if (err)
9557 		return err;
9558 
9559 	/* New ep's auth_hmacs should be set if old ep's is set, in case
9560 	 * that net->sctp.auth_enable has been changed to 0 by users and
9561 	 * new ep's auth_hmacs couldn't be set in sctp_endpoint_init().
9562 	 */
9563 	if (oldsp->ep->auth_hmacs) {
9564 		err = sctp_auth_init_hmacs(newsp->ep, GFP_KERNEL);
9565 		if (err)
9566 			return err;
9567 	}
9568 
9569 	sctp_auto_asconf_init(newsp);
9570 
9571 	/* Move any messages in the old socket's receive queue that are for the
9572 	 * peeled off association to the new socket's receive queue.
9573 	 */
9574 	sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
9575 		event = sctp_skb2event(skb);
9576 		if (event->asoc == assoc) {
9577 			__skb_unlink(skb, &oldsk->sk_receive_queue);
9578 			__skb_queue_tail(&newsk->sk_receive_queue, skb);
9579 			sctp_skb_set_owner_r_frag(skb, newsk);
9580 		}
9581 	}
9582 
9583 	/* Clean up any messages pending delivery due to partial
9584 	 * delivery.   Three cases:
9585 	 * 1) No partial deliver;  no work.
9586 	 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
9587 	 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
9588 	 */
9589 	atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
9590 
9591 	if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
9592 		struct sk_buff_head *queue;
9593 
9594 		/* Decide which queue to move pd_lobby skbs to. */
9595 		if (assoc->ulpq.pd_mode) {
9596 			queue = &newsp->pd_lobby;
9597 		} else
9598 			queue = &newsk->sk_receive_queue;
9599 
9600 		/* Walk through the pd_lobby, looking for skbs that
9601 		 * need moved to the new socket.
9602 		 */
9603 		sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
9604 			event = sctp_skb2event(skb);
9605 			if (event->asoc == assoc) {
9606 				__skb_unlink(skb, &oldsp->pd_lobby);
9607 				__skb_queue_tail(queue, skb);
9608 				sctp_skb_set_owner_r_frag(skb, newsk);
9609 			}
9610 		}
9611 
9612 		/* Clear up any skbs waiting for the partial
9613 		 * delivery to finish.
9614 		 */
9615 		if (assoc->ulpq.pd_mode)
9616 			sctp_clear_pd(oldsk, NULL);
9617 
9618 	}
9619 
9620 	sctp_for_each_rx_skb(assoc, newsk, sctp_skb_set_owner_r_frag);
9621 
9622 	/* Set the type of socket to indicate that it is peeled off from the
9623 	 * original UDP-style socket or created with the accept() call on a
9624 	 * TCP-style socket..
9625 	 */
9626 	newsp->type = type;
9627 
9628 	/* Mark the new socket "in-use" by the user so that any packets
9629 	 * that may arrive on the association after we've moved it are
9630 	 * queued to the backlog.  This prevents a potential race between
9631 	 * backlog processing on the old socket and new-packet processing
9632 	 * on the new socket.
9633 	 *
9634 	 * The caller has just allocated newsk so we can guarantee that other
9635 	 * paths won't try to lock it and then oldsk.
9636 	 */
9637 	lock_sock_nested(newsk, SINGLE_DEPTH_NESTING);
9638 	sctp_for_each_tx_datachunk(assoc, true, sctp_clear_owner_w);
9639 	sctp_assoc_migrate(assoc, newsk);
9640 	sctp_for_each_tx_datachunk(assoc, false, sctp_set_owner_w);
9641 
9642 	/* If the association on the newsk is already closed before accept()
9643 	 * is called, set RCV_SHUTDOWN flag.
9644 	 */
9645 	if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP)) {
9646 		inet_sk_set_state(newsk, SCTP_SS_CLOSED);
9647 		newsk->sk_shutdown |= RCV_SHUTDOWN;
9648 	} else {
9649 		inet_sk_set_state(newsk, SCTP_SS_ESTABLISHED);
9650 	}
9651 
9652 	release_sock(newsk);
9653 
9654 	return 0;
9655 }
9656 
9657 
9658 /* This proto struct describes the ULP interface for SCTP.  */
9659 struct proto sctp_prot = {
9660 	.name        =	"SCTP",
9661 	.owner       =	THIS_MODULE,
9662 	.close       =	sctp_close,
9663 	.disconnect  =	sctp_disconnect,
9664 	.accept      =	sctp_accept,
9665 	.ioctl       =	sctp_ioctl,
9666 	.init        =	sctp_init_sock,
9667 	.destroy     =	sctp_destroy_sock,
9668 	.shutdown    =	sctp_shutdown,
9669 	.setsockopt  =	sctp_setsockopt,
9670 	.getsockopt  =	sctp_getsockopt,
9671 	.bpf_bypass_getsockopt	= sctp_bpf_bypass_getsockopt,
9672 	.sendmsg     =	sctp_sendmsg,
9673 	.recvmsg     =	sctp_recvmsg,
9674 	.bind        =	sctp_bind,
9675 	.bind_add    =  sctp_bind_add,
9676 	.backlog_rcv =	sctp_backlog_rcv,
9677 	.hash        =	sctp_hash,
9678 	.unhash      =	sctp_unhash,
9679 	.no_autobind =	true,
9680 	.obj_size    =  sizeof(struct sctp_sock),
9681 	.useroffset  =  offsetof(struct sctp_sock, subscribe),
9682 	.usersize    =  offsetof(struct sctp_sock, initmsg) -
9683 				offsetof(struct sctp_sock, subscribe) +
9684 				sizeof_field(struct sctp_sock, initmsg),
9685 	.sysctl_mem  =  sysctl_sctp_mem,
9686 	.sysctl_rmem =  sysctl_sctp_rmem,
9687 	.sysctl_wmem =  sysctl_sctp_wmem,
9688 	.memory_pressure = &sctp_memory_pressure,
9689 	.enter_memory_pressure = sctp_enter_memory_pressure,
9690 
9691 	.memory_allocated = &sctp_memory_allocated,
9692 	.per_cpu_fw_alloc = &sctp_memory_per_cpu_fw_alloc,
9693 
9694 	.sockets_allocated = &sctp_sockets_allocated,
9695 };
9696 
9697 #if IS_ENABLED(CONFIG_IPV6)
9698 
sctp_v6_destruct_sock(struct sock * sk)9699 static void sctp_v6_destruct_sock(struct sock *sk)
9700 {
9701 	sctp_destruct_common(sk);
9702 	inet6_sock_destruct(sk);
9703 }
9704 
sctp_v6_init_sock(struct sock * sk)9705 static int sctp_v6_init_sock(struct sock *sk)
9706 {
9707 	int ret = sctp_init_sock(sk);
9708 
9709 	if (!ret)
9710 		sk->sk_destruct = sctp_v6_destruct_sock;
9711 
9712 	return ret;
9713 }
9714 
9715 struct proto sctpv6_prot = {
9716 	.name		= "SCTPv6",
9717 	.owner		= THIS_MODULE,
9718 	.close		= sctp_close,
9719 	.disconnect	= sctp_disconnect,
9720 	.accept		= sctp_accept,
9721 	.ioctl		= sctp_ioctl,
9722 	.init		= sctp_v6_init_sock,
9723 	.destroy	= sctp_destroy_sock,
9724 	.shutdown	= sctp_shutdown,
9725 	.setsockopt	= sctp_setsockopt,
9726 	.getsockopt	= sctp_getsockopt,
9727 	.bpf_bypass_getsockopt	= sctp_bpf_bypass_getsockopt,
9728 	.sendmsg	= sctp_sendmsg,
9729 	.recvmsg	= sctp_recvmsg,
9730 	.bind		= sctp_bind,
9731 	.bind_add	= sctp_bind_add,
9732 	.backlog_rcv	= sctp_backlog_rcv,
9733 	.hash		= sctp_hash,
9734 	.unhash		= sctp_unhash,
9735 	.no_autobind	= true,
9736 	.obj_size	= sizeof(struct sctp6_sock),
9737 	.ipv6_pinfo_offset = offsetof(struct sctp6_sock, inet6),
9738 	.useroffset	= offsetof(struct sctp6_sock, sctp.subscribe),
9739 	.usersize	= offsetof(struct sctp6_sock, sctp.initmsg) -
9740 				offsetof(struct sctp6_sock, sctp.subscribe) +
9741 				sizeof_field(struct sctp6_sock, sctp.initmsg),
9742 	.sysctl_mem	= sysctl_sctp_mem,
9743 	.sysctl_rmem	= sysctl_sctp_rmem,
9744 	.sysctl_wmem	= sysctl_sctp_wmem,
9745 	.memory_pressure = &sctp_memory_pressure,
9746 	.enter_memory_pressure = sctp_enter_memory_pressure,
9747 
9748 	.memory_allocated = &sctp_memory_allocated,
9749 	.per_cpu_fw_alloc = &sctp_memory_per_cpu_fw_alloc,
9750 
9751 	.sockets_allocated = &sctp_sockets_allocated,
9752 };
9753 #endif /* IS_ENABLED(CONFIG_IPV6) */
9754