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