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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
54
55#include <crypto/hash.h>
56#include <linux/types.h>
57#include <linux/kernel.h>
58#include <linux/wait.h>
59#include <linux/time.h>
60#include <linux/ip.h>
61#include <linux/capability.h>
62#include <linux/fcntl.h>
63#include <linux/poll.h>
64#include <linux/init.h>
65#include <linux/slab.h>
66#include <linux/file.h>
67#include <linux/compat.h>
68
69#include <net/ip.h>
70#include <net/icmp.h>
71#include <net/route.h>
72#include <net/ipv6.h>
73#include <net/inet_common.h>
74#include <net/busy_poll.h>
75
76#include <linux/socket.h>
77#include <linux/export.h>
78#include <net/sock.h>
79#include <net/sctp/sctp.h>
80#include <net/sctp/sm.h>
81
82
83static int sctp_writeable(struct sock *sk);
84static void sctp_wfree(struct sk_buff *skb);
85static int sctp_wait_for_sndbuf(struct sctp_association *, long *timeo_p,
86 size_t msg_len);
87static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);
88static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
89static int sctp_wait_for_accept(struct sock *sk, long timeo);
90static void sctp_wait_for_close(struct sock *sk, long timeo);
91static void sctp_destruct_sock(struct sock *sk);
92static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
93 union sctp_addr *addr, int len);
94static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
95static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
96static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
97static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
98static int sctp_send_asconf(struct sctp_association *asoc,
99 struct sctp_chunk *chunk);
100static int sctp_do_bind(struct sock *, union sctp_addr *, int);
101static int sctp_autobind(struct sock *sk);
102static void sctp_sock_migrate(struct sock *, struct sock *,
103 struct sctp_association *, sctp_socket_type_t);
104
105static int sctp_memory_pressure;
106static atomic_long_t sctp_memory_allocated;
107struct percpu_counter sctp_sockets_allocated;
108
109static void sctp_enter_memory_pressure(struct sock *sk)
110{
111 sctp_memory_pressure = 1;
112}
113
114
115
116static inline int sctp_wspace(struct sctp_association *asoc)
117{
118 int amt;
119
120 if (asoc->ep->sndbuf_policy)
121 amt = asoc->sndbuf_used;
122 else
123 amt = sk_wmem_alloc_get(asoc->base.sk);
124
125 if (amt >= asoc->base.sk->sk_sndbuf) {
126 if (asoc->base.sk->sk_userlocks & SOCK_SNDBUF_LOCK)
127 amt = 0;
128 else {
129 amt = sk_stream_wspace(asoc->base.sk);
130 if (amt < 0)
131 amt = 0;
132 }
133 } else {
134 amt = asoc->base.sk->sk_sndbuf - amt;
135 }
136 return amt;
137}
138
139
140
141
142
143
144
145
146
147
148static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
149{
150 struct sctp_association *asoc = chunk->asoc;
151 struct sock *sk = asoc->base.sk;
152
153
154 sctp_association_hold(asoc);
155
156 skb_set_owner_w(chunk->skb, sk);
157
158 chunk->skb->destructor = sctp_wfree;
159
160 skb_shinfo(chunk->skb)->destructor_arg = chunk;
161
162 asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +
163 sizeof(struct sk_buff) +
164 sizeof(struct sctp_chunk);
165
166 atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
167 sk->sk_wmem_queued += chunk->skb->truesize;
168 sk_mem_charge(sk, chunk->skb->truesize);
169}
170
171
172static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
173 int len)
174{
175 struct sctp_af *af;
176
177
178 af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
179 if (!af)
180 return -EINVAL;
181
182
183 if (!af->addr_valid(addr, sctp_sk(sk), NULL))
184 return -EINVAL;
185
186 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
187 return -EINVAL;
188
189 return 0;
190}
191
192
193
194
195struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
196{
197 struct sctp_association *asoc = NULL;
198
199
200 if (!sctp_style(sk, UDP)) {
201
202
203
204
205 if (!sctp_sstate(sk, ESTABLISHED))
206 return NULL;
207
208
209 if (!list_empty(&sctp_sk(sk)->ep->asocs))
210 asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
211 struct sctp_association, asocs);
212 return asoc;
213 }
214
215
216 if (!id || (id == (sctp_assoc_t)-1))
217 return NULL;
218
219 spin_lock_bh(&sctp_assocs_id_lock);
220 asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
221 spin_unlock_bh(&sctp_assocs_id_lock);
222
223 if (!asoc || (asoc->base.sk != sk) || asoc->base.dead)
224 return NULL;
225
226 return asoc;
227}
228
229
230
231
232
233static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
234 struct sockaddr_storage *addr,
235 sctp_assoc_t id)
236{
237 struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
238 struct sctp_transport *transport;
239 union sctp_addr *laddr = (union sctp_addr *)addr;
240
241 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
242 laddr,
243 &transport);
244
245 if (!addr_asoc)
246 return NULL;
247
248 id_asoc = sctp_id2assoc(sk, id);
249 if (id_asoc && (id_asoc != addr_asoc))
250 return NULL;
251
252 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
253 (union sctp_addr *)addr);
254
255 return transport;
256}
257
258
259
260
261
262
263
264
265
266
267
268static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
269{
270 int retval = 0;
271
272 lock_sock(sk);
273
274 pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk,
275 addr, addr_len);
276
277
278 if (!sctp_sk(sk)->ep->base.bind_addr.port)
279 retval = sctp_do_bind(sk, (union sctp_addr *)addr,
280 addr_len);
281 else
282 retval = -EINVAL;
283
284 release_sock(sk);
285
286 return retval;
287}
288
289static long sctp_get_port_local(struct sock *, union sctp_addr *);
290
291
292static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
293 union sctp_addr *addr, int len)
294{
295 struct sctp_af *af;
296
297
298 if (len < sizeof (struct sockaddr))
299 return NULL;
300
301
302 if (addr->sa.sa_family == AF_INET6 &&
303 ipv6_addr_v4mapped(&addr->v6.sin6_addr)) {
304 if (!opt->pf->af_supported(AF_INET, opt))
305 return NULL;
306 } else {
307
308 if (!opt->pf->af_supported(addr->sa.sa_family, opt))
309 return NULL;
310 }
311
312
313 af = sctp_get_af_specific(addr->sa.sa_family);
314
315 if (len < af->sockaddr_len)
316 return NULL;
317
318 return af;
319}
320
321
322static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
323{
324 struct net *net = sock_net(sk);
325 struct sctp_sock *sp = sctp_sk(sk);
326 struct sctp_endpoint *ep = sp->ep;
327 struct sctp_bind_addr *bp = &ep->base.bind_addr;
328 struct sctp_af *af;
329 unsigned short snum;
330 int ret = 0;
331
332
333 af = sctp_sockaddr_af(sp, addr, len);
334 if (!af) {
335 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
336 __func__, sk, addr, len);
337 return -EINVAL;
338 }
339
340 snum = ntohs(addr->v4.sin_port);
341
342 pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
343 __func__, sk, &addr->sa, bp->port, snum, len);
344
345
346 if (!sp->pf->bind_verify(sp, addr))
347 return -EADDRNOTAVAIL;
348
349
350
351
352
353 if (bp->port) {
354 if (!snum)
355 snum = bp->port;
356 else if (snum != bp->port) {
357 pr_debug("%s: new port %d doesn't match existing port "
358 "%d\n", __func__, snum, bp->port);
359 return -EINVAL;
360 }
361 }
362
363 if (snum && snum < PROT_SOCK &&
364 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
365 return -EACCES;
366
367
368
369
370 if (sctp_bind_addr_match(bp, addr, sp))
371 return -EINVAL;
372
373
374
375
376
377 addr->v4.sin_port = htons(snum);
378 if ((ret = sctp_get_port_local(sk, addr))) {
379 return -EADDRINUSE;
380 }
381
382
383 if (!bp->port)
384 bp->port = inet_sk(sk)->inet_num;
385
386
387
388
389 ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
390 SCTP_ADDR_SRC, GFP_ATOMIC);
391
392
393 if (!ret) {
394 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
395 sp->pf->to_sk_saddr(addr, sk);
396 }
397
398 return ret;
399}
400
401
402
403
404
405
406
407
408
409
410
411static int sctp_send_asconf(struct sctp_association *asoc,
412 struct sctp_chunk *chunk)
413{
414 struct net *net = sock_net(asoc->base.sk);
415 int retval = 0;
416
417
418
419
420 if (asoc->addip_last_asconf) {
421 list_add_tail(&chunk->list, &asoc->addip_chunk_list);
422 goto out;
423 }
424
425
426 sctp_chunk_hold(chunk);
427 retval = sctp_primitive_ASCONF(net, asoc, chunk);
428 if (retval)
429 sctp_chunk_free(chunk);
430 else
431 asoc->addip_last_asconf = chunk;
432
433out:
434 return retval;
435}
436
437
438
439
440
441
442
443
444
445
446
447
448
449static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
450{
451 int cnt;
452 int retval = 0;
453 void *addr_buf;
454 struct sockaddr *sa_addr;
455 struct sctp_af *af;
456
457 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk,
458 addrs, addrcnt);
459
460 addr_buf = addrs;
461 for (cnt = 0; cnt < addrcnt; cnt++) {
462
463
464
465 sa_addr = addr_buf;
466 af = sctp_get_af_specific(sa_addr->sa_family);
467 if (!af) {
468 retval = -EINVAL;
469 goto err_bindx_add;
470 }
471
472 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
473 af->sockaddr_len);
474
475 addr_buf += af->sockaddr_len;
476
477err_bindx_add:
478 if (retval < 0) {
479
480 if (cnt > 0)
481 sctp_bindx_rem(sk, addrs, cnt);
482 return retval;
483 }
484 }
485
486 return retval;
487}
488
489
490
491
492
493
494
495
496
497
498
499static int sctp_send_asconf_add_ip(struct sock *sk,
500 struct sockaddr *addrs,
501 int addrcnt)
502{
503 struct net *net = sock_net(sk);
504 struct sctp_sock *sp;
505 struct sctp_endpoint *ep;
506 struct sctp_association *asoc;
507 struct sctp_bind_addr *bp;
508 struct sctp_chunk *chunk;
509 struct sctp_sockaddr_entry *laddr;
510 union sctp_addr *addr;
511 union sctp_addr saveaddr;
512 void *addr_buf;
513 struct sctp_af *af;
514 struct list_head *p;
515 int i;
516 int retval = 0;
517
518 if (!net->sctp.addip_enable)
519 return retval;
520
521 sp = sctp_sk(sk);
522 ep = sp->ep;
523
524 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
525 __func__, sk, addrs, addrcnt);
526
527 list_for_each_entry(asoc, &ep->asocs, asocs) {
528 if (!asoc->peer.asconf_capable)
529 continue;
530
531 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
532 continue;
533
534 if (!sctp_state(asoc, ESTABLISHED))
535 continue;
536
537
538
539
540
541
542 addr_buf = addrs;
543 for (i = 0; i < addrcnt; i++) {
544 addr = addr_buf;
545 af = sctp_get_af_specific(addr->v4.sin_family);
546 if (!af) {
547 retval = -EINVAL;
548 goto out;
549 }
550
551 if (sctp_assoc_lookup_laddr(asoc, addr))
552 break;
553
554 addr_buf += af->sockaddr_len;
555 }
556 if (i < addrcnt)
557 continue;
558
559
560
561
562 bp = &asoc->base.bind_addr;
563 p = bp->address_list.next;
564 laddr = list_entry(p, struct sctp_sockaddr_entry, list);
565 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
566 addrcnt, SCTP_PARAM_ADD_IP);
567 if (!chunk) {
568 retval = -ENOMEM;
569 goto out;
570 }
571
572
573
574
575 addr_buf = addrs;
576 for (i = 0; i < addrcnt; i++) {
577 addr = addr_buf;
578 af = sctp_get_af_specific(addr->v4.sin_family);
579 memcpy(&saveaddr, addr, af->sockaddr_len);
580 retval = sctp_add_bind_addr(bp, &saveaddr,
581 sizeof(saveaddr),
582 SCTP_ADDR_NEW, GFP_ATOMIC);
583 addr_buf += af->sockaddr_len;
584 }
585 if (asoc->src_out_of_asoc_ok) {
586 struct sctp_transport *trans;
587
588 list_for_each_entry(trans,
589 &asoc->peer.transport_addr_list, transports) {
590
591 dst_release(trans->dst);
592 trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
593 2*asoc->pathmtu, 4380));
594 trans->ssthresh = asoc->peer.i.a_rwnd;
595 trans->rto = asoc->rto_initial;
596 sctp_max_rto(asoc, trans);
597 trans->rtt = trans->srtt = trans->rttvar = 0;
598 sctp_transport_route(trans, NULL,
599 sctp_sk(asoc->base.sk));
600 }
601 }
602 retval = sctp_send_asconf(asoc, chunk);
603 }
604
605out:
606 return retval;
607}
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
625{
626 struct sctp_sock *sp = sctp_sk(sk);
627 struct sctp_endpoint *ep = sp->ep;
628 int cnt;
629 struct sctp_bind_addr *bp = &ep->base.bind_addr;
630 int retval = 0;
631 void *addr_buf;
632 union sctp_addr *sa_addr;
633 struct sctp_af *af;
634
635 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
636 __func__, sk, addrs, addrcnt);
637
638 addr_buf = addrs;
639 for (cnt = 0; cnt < addrcnt; cnt++) {
640
641
642
643
644 if (list_empty(&bp->address_list) ||
645 (sctp_list_single_entry(&bp->address_list))) {
646 retval = -EBUSY;
647 goto err_bindx_rem;
648 }
649
650 sa_addr = addr_buf;
651 af = sctp_get_af_specific(sa_addr->sa.sa_family);
652 if (!af) {
653 retval = -EINVAL;
654 goto err_bindx_rem;
655 }
656
657 if (!af->addr_valid(sa_addr, sp, NULL)) {
658 retval = -EADDRNOTAVAIL;
659 goto err_bindx_rem;
660 }
661
662 if (sa_addr->v4.sin_port &&
663 sa_addr->v4.sin_port != htons(bp->port)) {
664 retval = -EINVAL;
665 goto err_bindx_rem;
666 }
667
668 if (!sa_addr->v4.sin_port)
669 sa_addr->v4.sin_port = htons(bp->port);
670
671
672
673
674
675
676
677
678 retval = sctp_del_bind_addr(bp, sa_addr);
679
680 addr_buf += af->sockaddr_len;
681err_bindx_rem:
682 if (retval < 0) {
683
684 if (cnt > 0)
685 sctp_bindx_add(sk, addrs, cnt);
686 return retval;
687 }
688 }
689
690 return retval;
691}
692
693
694
695
696
697
698
699
700
701
702
703static int sctp_send_asconf_del_ip(struct sock *sk,
704 struct sockaddr *addrs,
705 int addrcnt)
706{
707 struct net *net = sock_net(sk);
708 struct sctp_sock *sp;
709 struct sctp_endpoint *ep;
710 struct sctp_association *asoc;
711 struct sctp_transport *transport;
712 struct sctp_bind_addr *bp;
713 struct sctp_chunk *chunk;
714 union sctp_addr *laddr;
715 void *addr_buf;
716 struct sctp_af *af;
717 struct sctp_sockaddr_entry *saddr;
718 int i;
719 int retval = 0;
720 int stored = 0;
721
722 chunk = NULL;
723 if (!net->sctp.addip_enable)
724 return retval;
725
726 sp = sctp_sk(sk);
727 ep = sp->ep;
728
729 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
730 __func__, sk, addrs, addrcnt);
731
732 list_for_each_entry(asoc, &ep->asocs, asocs) {
733
734 if (!asoc->peer.asconf_capable)
735 continue;
736
737 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
738 continue;
739
740 if (!sctp_state(asoc, ESTABLISHED))
741 continue;
742
743
744
745
746
747
748 addr_buf = addrs;
749 for (i = 0; i < addrcnt; i++) {
750 laddr = addr_buf;
751 af = sctp_get_af_specific(laddr->v4.sin_family);
752 if (!af) {
753 retval = -EINVAL;
754 goto out;
755 }
756
757 if (!sctp_assoc_lookup_laddr(asoc, laddr))
758 break;
759
760 addr_buf += af->sockaddr_len;
761 }
762 if (i < addrcnt)
763 continue;
764
765
766
767
768
769
770 bp = &asoc->base.bind_addr;
771 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
772 addrcnt, sp);
773 if ((laddr == NULL) && (addrcnt == 1)) {
774 if (asoc->asconf_addr_del_pending)
775 continue;
776 asoc->asconf_addr_del_pending =
777 kzalloc(sizeof(union sctp_addr), GFP_ATOMIC);
778 if (asoc->asconf_addr_del_pending == NULL) {
779 retval = -ENOMEM;
780 goto out;
781 }
782 asoc->asconf_addr_del_pending->sa.sa_family =
783 addrs->sa_family;
784 asoc->asconf_addr_del_pending->v4.sin_port =
785 htons(bp->port);
786 if (addrs->sa_family == AF_INET) {
787 struct sockaddr_in *sin;
788
789 sin = (struct sockaddr_in *)addrs;
790 asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
791 } else if (addrs->sa_family == AF_INET6) {
792 struct sockaddr_in6 *sin6;
793
794 sin6 = (struct sockaddr_in6 *)addrs;
795 asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
796 }
797
798 pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
799 __func__, asoc, &asoc->asconf_addr_del_pending->sa,
800 asoc->asconf_addr_del_pending);
801
802 asoc->src_out_of_asoc_ok = 1;
803 stored = 1;
804 goto skip_mkasconf;
805 }
806
807 if (laddr == NULL)
808 return -EINVAL;
809
810
811
812
813
814 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
815 SCTP_PARAM_DEL_IP);
816 if (!chunk) {
817 retval = -ENOMEM;
818 goto out;
819 }
820
821skip_mkasconf:
822
823
824
825 addr_buf = addrs;
826 for (i = 0; i < addrcnt; i++) {
827 laddr = addr_buf;
828 af = sctp_get_af_specific(laddr->v4.sin_family);
829 list_for_each_entry(saddr, &bp->address_list, list) {
830 if (sctp_cmp_addr_exact(&saddr->a, laddr))
831 saddr->state = SCTP_ADDR_DEL;
832 }
833 addr_buf += af->sockaddr_len;
834 }
835
836
837
838
839
840 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
841 transports) {
842 dst_release(transport->dst);
843 sctp_transport_route(transport, NULL,
844 sctp_sk(asoc->base.sk));
845 }
846
847 if (stored)
848
849 continue;
850 retval = sctp_send_asconf(asoc, chunk);
851 }
852out:
853 return retval;
854}
855
856
857int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
858{
859 struct sock *sk = sctp_opt2sk(sp);
860 union sctp_addr *addr;
861 struct sctp_af *af;
862
863
864 addr = &addrw->a;
865 addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
866 af = sctp_get_af_specific(addr->sa.sa_family);
867 if (!af)
868 return -EINVAL;
869 if (sctp_verify_addr(sk, addr, af->sockaddr_len))
870 return -EINVAL;
871
872 if (addrw->state == SCTP_ADDR_NEW)
873 return sctp_send_asconf_add_ip(sk, (struct sockaddr *)addr, 1);
874 else
875 return sctp_send_asconf_del_ip(sk, (struct sockaddr *)addr, 1);
876}
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
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
954static int sctp_setsockopt_bindx(struct sock *sk,
955 struct sockaddr __user *addrs,
956 int addrs_size, int op)
957{
958 struct sockaddr *kaddrs;
959 int err;
960 int addrcnt = 0;
961 int walk_size = 0;
962 struct sockaddr *sa_addr;
963 void *addr_buf;
964 struct sctp_af *af;
965
966 pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
967 __func__, sk, addrs, addrs_size, op);
968
969 if (unlikely(addrs_size <= 0))
970 return -EINVAL;
971
972
973 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
974 return -EFAULT;
975
976
977 kaddrs = kmalloc(addrs_size, GFP_USER | __GFP_NOWARN);
978 if (unlikely(!kaddrs))
979 return -ENOMEM;
980
981 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
982 kfree(kaddrs);
983 return -EFAULT;
984 }
985
986
987 addr_buf = kaddrs;
988 while (walk_size < addrs_size) {
989 if (walk_size + sizeof(sa_family_t) > addrs_size) {
990 kfree(kaddrs);
991 return -EINVAL;
992 }
993
994 sa_addr = addr_buf;
995 af = sctp_get_af_specific(sa_addr->sa_family);
996
997
998
999
1000 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1001 kfree(kaddrs);
1002 return -EINVAL;
1003 }
1004 addrcnt++;
1005 addr_buf += af->sockaddr_len;
1006 walk_size += af->sockaddr_len;
1007 }
1008
1009
1010 switch (op) {
1011 case SCTP_BINDX_ADD_ADDR:
1012 err = sctp_bindx_add(sk, kaddrs, addrcnt);
1013 if (err)
1014 goto out;
1015 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
1016 break;
1017
1018 case SCTP_BINDX_REM_ADDR:
1019 err = sctp_bindx_rem(sk, kaddrs, addrcnt);
1020 if (err)
1021 goto out;
1022 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
1023 break;
1024
1025 default:
1026 err = -EINVAL;
1027 break;
1028 }
1029
1030out:
1031 kfree(kaddrs);
1032
1033 return err;
1034}
1035
1036
1037
1038
1039
1040
1041static int __sctp_connect(struct sock *sk,
1042 struct sockaddr *kaddrs,
1043 int addrs_size,
1044 sctp_assoc_t *assoc_id)
1045{
1046 struct net *net = sock_net(sk);
1047 struct sctp_sock *sp;
1048 struct sctp_endpoint *ep;
1049 struct sctp_association *asoc = NULL;
1050 struct sctp_association *asoc2;
1051 struct sctp_transport *transport;
1052 union sctp_addr to;
1053 sctp_scope_t scope;
1054 long timeo;
1055 int err = 0;
1056 int addrcnt = 0;
1057 int walk_size = 0;
1058 union sctp_addr *sa_addr = NULL;
1059 void *addr_buf;
1060 unsigned short port;
1061 unsigned int f_flags = 0;
1062
1063 sp = sctp_sk(sk);
1064 ep = sp->ep;
1065
1066
1067
1068
1069
1070
1071 if (sctp_sstate(sk, ESTABLISHED) ||
1072 (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
1073 err = -EISCONN;
1074 goto out_free;
1075 }
1076
1077
1078 addr_buf = kaddrs;
1079 while (walk_size < addrs_size) {
1080 struct sctp_af *af;
1081
1082 if (walk_size + sizeof(sa_family_t) > addrs_size) {
1083 err = -EINVAL;
1084 goto out_free;
1085 }
1086
1087 sa_addr = addr_buf;
1088 af = sctp_get_af_specific(sa_addr->sa.sa_family);
1089
1090
1091
1092
1093 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
1094 err = -EINVAL;
1095 goto out_free;
1096 }
1097
1098 port = ntohs(sa_addr->v4.sin_port);
1099
1100
1101 memcpy(&to, sa_addr, af->sockaddr_len);
1102
1103 err = sctp_verify_addr(sk, &to, af->sockaddr_len);
1104 if (err)
1105 goto out_free;
1106
1107
1108
1109
1110 if (asoc && asoc->peer.port && asoc->peer.port != port) {
1111 err = -EINVAL;
1112 goto out_free;
1113 }
1114
1115
1116
1117
1118 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1119 if (asoc2 && asoc2 != asoc) {
1120 if (asoc2->state >= SCTP_STATE_ESTABLISHED)
1121 err = -EISCONN;
1122 else
1123 err = -EALREADY;
1124 goto out_free;
1125 }
1126
1127
1128
1129
1130
1131 if (sctp_endpoint_is_peeled_off(ep, &to)) {
1132 err = -EADDRNOTAVAIL;
1133 goto out_free;
1134 }
1135
1136 if (!asoc) {
1137
1138
1139
1140
1141
1142 if (!ep->base.bind_addr.port) {
1143 if (sctp_autobind(sk)) {
1144 err = -EAGAIN;
1145 goto out_free;
1146 }
1147 } else {
1148
1149
1150
1151
1152
1153
1154
1155 if (ep->base.bind_addr.port < PROT_SOCK &&
1156 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE)) {
1157 err = -EACCES;
1158 goto out_free;
1159 }
1160 }
1161
1162 scope = sctp_scope(&to);
1163 asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1164 if (!asoc) {
1165 err = -ENOMEM;
1166 goto out_free;
1167 }
1168
1169 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope,
1170 GFP_KERNEL);
1171 if (err < 0) {
1172 goto out_free;
1173 }
1174
1175 }
1176
1177
1178 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
1179 SCTP_UNKNOWN);
1180 if (!transport) {
1181 err = -ENOMEM;
1182 goto out_free;
1183 }
1184
1185 addrcnt++;
1186 addr_buf += af->sockaddr_len;
1187 walk_size += af->sockaddr_len;
1188 }
1189
1190
1191
1192
1193 if (assoc_id) {
1194 err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1195 if (err < 0)
1196 goto out_free;
1197 }
1198
1199 err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1200 if (err < 0) {
1201 goto out_free;
1202 }
1203
1204
1205 inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1206 sp->pf->to_sk_daddr(sa_addr, sk);
1207 sk->sk_err = 0;
1208
1209
1210
1211
1212 if (sk->sk_socket->file)
1213 f_flags = sk->sk_socket->file->f_flags;
1214
1215 timeo = sock_sndtimeo(sk, f_flags & O_NONBLOCK);
1216
1217 err = sctp_wait_for_connect(asoc, &timeo);
1218 if ((err == 0 || err == -EINPROGRESS) && assoc_id)
1219 *assoc_id = asoc->assoc_id;
1220
1221
1222 asoc = NULL;
1223
1224out_free:
1225 pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1226 __func__, asoc, kaddrs, err);
1227
1228 if (asoc) {
1229
1230
1231
1232
1233 sctp_association_free(asoc);
1234 }
1235 return err;
1236}
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
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
1300static int __sctp_setsockopt_connectx(struct sock *sk,
1301 struct sockaddr __user *addrs,
1302 int addrs_size,
1303 sctp_assoc_t *assoc_id)
1304{
1305 struct sockaddr *kaddrs;
1306 gfp_t gfp = GFP_KERNEL;
1307 int err = 0;
1308
1309 pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1310 __func__, sk, addrs, addrs_size);
1311
1312 if (unlikely(addrs_size <= 0))
1313 return -EINVAL;
1314
1315
1316 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
1317 return -EFAULT;
1318
1319
1320 if (sk->sk_socket->file)
1321 gfp = GFP_USER | __GFP_NOWARN;
1322 kaddrs = kmalloc(addrs_size, gfp);
1323 if (unlikely(!kaddrs))
1324 return -ENOMEM;
1325
1326 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
1327 err = -EFAULT;
1328 } else {
1329 err = __sctp_connect(sk, kaddrs, addrs_size, assoc_id);
1330 }
1331
1332 kfree(kaddrs);
1333
1334 return err;
1335}
1336
1337
1338
1339
1340
1341static int sctp_setsockopt_connectx_old(struct sock *sk,
1342 struct sockaddr __user *addrs,
1343 int addrs_size)
1344{
1345 return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL);
1346}
1347
1348
1349
1350
1351
1352
1353
1354static int sctp_setsockopt_connectx(struct sock *sk,
1355 struct sockaddr __user *addrs,
1356 int addrs_size)
1357{
1358 sctp_assoc_t assoc_id = 0;
1359 int err = 0;
1360
1361 err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id);
1362
1363 if (err)
1364 return err;
1365 else
1366 return assoc_id;
1367}
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377#ifdef CONFIG_COMPAT
1378struct compat_sctp_getaddrs_old {
1379 sctp_assoc_t assoc_id;
1380 s32 addr_num;
1381 compat_uptr_t addrs;
1382};
1383#endif
1384
1385static int sctp_getsockopt_connectx3(struct sock *sk, int len,
1386 char __user *optval,
1387 int __user *optlen)
1388{
1389 struct sctp_getaddrs_old param;
1390 sctp_assoc_t assoc_id = 0;
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 err = __sctp_setsockopt_connectx(sk, (struct sockaddr __user *)
1415 param.addrs, param.addr_num,
1416 &assoc_id);
1417 if (err == 0 || err == -EINPROGRESS) {
1418 if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1419 return -EFAULT;
1420 if (put_user(sizeof(assoc_id), optlen))
1421 return -EFAULT;
1422 }
1423
1424 return err;
1425}
1426
1427
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
1477static void sctp_close(struct sock *sk, long timeout)
1478{
1479 struct net *net = sock_net(sk);
1480 struct sctp_endpoint *ep;
1481 struct sctp_association *asoc;
1482 struct list_head *pos, *temp;
1483 unsigned int data_was_unread;
1484
1485 pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout);
1486
1487 lock_sock(sk);
1488 sk->sk_shutdown = SHUTDOWN_MASK;
1489 sk->sk_state = SCTP_SS_CLOSING;
1490
1491 ep = sctp_sk(sk)->ep;
1492
1493
1494 data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1495 data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1496
1497
1498 list_for_each_safe(pos, temp, &ep->asocs) {
1499 asoc = list_entry(pos, struct sctp_association, asocs);
1500
1501 if (sctp_style(sk, TCP)) {
1502
1503
1504
1505
1506
1507 if (sctp_state(asoc, CLOSED)) {
1508 sctp_association_free(asoc);
1509 continue;
1510 }
1511 }
1512
1513 if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1514 !skb_queue_empty(&asoc->ulpq.reasm) ||
1515 (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1516 struct sctp_chunk *chunk;
1517
1518 chunk = sctp_make_abort_user(asoc, NULL, 0);
1519 sctp_primitive_ABORT(net, asoc, chunk);
1520 } else
1521 sctp_primitive_SHUTDOWN(net, asoc, NULL);
1522 }
1523
1524
1525 if (sctp_style(sk, TCP) && timeout)
1526 sctp_wait_for_close(sk, timeout);
1527
1528
1529 release_sock(sk);
1530
1531
1532
1533
1534
1535
1536 spin_lock_bh(&net->sctp.addr_wq_lock);
1537 bh_lock_sock(sk);
1538
1539
1540
1541
1542 sock_hold(sk);
1543 sk_common_release(sk);
1544
1545 bh_unlock_sock(sk);
1546 spin_unlock_bh(&net->sctp.addr_wq_lock);
1547
1548 sock_put(sk);
1549
1550 SCTP_DBG_OBJCNT_DEC(sock);
1551}
1552
1553
1554static int sctp_error(struct sock *sk, int flags, int err)
1555{
1556 if (err == -EPIPE)
1557 err = sock_error(sk) ? : -EPIPE;
1558 if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1559 send_sig(SIGPIPE, current, 0);
1560 return err;
1561}
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586static int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *);
1587
1588static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
1589{
1590 struct net *net = sock_net(sk);
1591 struct sctp_sock *sp;
1592 struct sctp_endpoint *ep;
1593 struct sctp_association *new_asoc = NULL, *asoc = NULL;
1594 struct sctp_transport *transport, *chunk_tp;
1595 struct sctp_chunk *chunk;
1596 union sctp_addr to;
1597 struct sockaddr *msg_name = NULL;
1598 struct sctp_sndrcvinfo default_sinfo;
1599 struct sctp_sndrcvinfo *sinfo;
1600 struct sctp_initmsg *sinit;
1601 sctp_assoc_t associd = 0;
1602 sctp_cmsgs_t cmsgs = { NULL };
1603 sctp_scope_t scope;
1604 bool fill_sinfo_ttl = false, wait_connect = false;
1605 struct sctp_datamsg *datamsg;
1606 int msg_flags = msg->msg_flags;
1607 __u16 sinfo_flags = 0;
1608 long timeo;
1609 int err;
1610
1611 err = 0;
1612 sp = sctp_sk(sk);
1613 ep = sp->ep;
1614
1615 pr_debug("%s: sk:%p, msg:%p, msg_len:%zu ep:%p\n", __func__, sk,
1616 msg, msg_len, ep);
1617
1618
1619 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
1620 err = -EPIPE;
1621 goto out_nounlock;
1622 }
1623
1624
1625 err = sctp_msghdr_parse(msg, &cmsgs);
1626 if (err) {
1627 pr_debug("%s: msghdr parse err:%x\n", __func__, err);
1628 goto out_nounlock;
1629 }
1630
1631
1632
1633
1634
1635
1636 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1637 int msg_namelen = msg->msg_namelen;
1638
1639 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
1640 msg_namelen);
1641 if (err)
1642 return err;
1643
1644 if (msg_namelen > sizeof(to))
1645 msg_namelen = sizeof(to);
1646 memcpy(&to, msg->msg_name, msg_namelen);
1647 msg_name = msg->msg_name;
1648 }
1649
1650 sinit = cmsgs.init;
1651 if (cmsgs.sinfo != NULL) {
1652 memset(&default_sinfo, 0, sizeof(default_sinfo));
1653 default_sinfo.sinfo_stream = cmsgs.sinfo->snd_sid;
1654 default_sinfo.sinfo_flags = cmsgs.sinfo->snd_flags;
1655 default_sinfo.sinfo_ppid = cmsgs.sinfo->snd_ppid;
1656 default_sinfo.sinfo_context = cmsgs.sinfo->snd_context;
1657 default_sinfo.sinfo_assoc_id = cmsgs.sinfo->snd_assoc_id;
1658
1659 sinfo = &default_sinfo;
1660 fill_sinfo_ttl = true;
1661 } else {
1662 sinfo = cmsgs.srinfo;
1663 }
1664
1665 if (sinfo) {
1666 sinfo_flags = sinfo->sinfo_flags;
1667 associd = sinfo->sinfo_assoc_id;
1668 }
1669
1670 pr_debug("%s: msg_len:%zu, sinfo_flags:0x%x\n", __func__,
1671 msg_len, sinfo_flags);
1672
1673
1674 if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) {
1675 err = -EINVAL;
1676 goto out_nounlock;
1677 }
1678
1679
1680
1681
1682
1683
1684 if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) ||
1685 (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) {
1686 err = -EINVAL;
1687 goto out_nounlock;
1688 }
1689
1690
1691
1692
1693 if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {
1694 err = -EINVAL;
1695 goto out_nounlock;
1696 }
1697
1698 transport = NULL;
1699
1700 pr_debug("%s: about to look up association\n", __func__);
1701
1702 lock_sock(sk);
1703
1704
1705 if (msg_name) {
1706
1707 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1708 if (!asoc) {
1709
1710
1711
1712
1713
1714 if ((sctp_style(sk, TCP) &&
1715 sctp_sstate(sk, ESTABLISHED)) ||
1716 sctp_endpoint_is_peeled_off(ep, &to)) {
1717 err = -EADDRNOTAVAIL;
1718 goto out_unlock;
1719 }
1720 }
1721 } else {
1722 asoc = sctp_id2assoc(sk, associd);
1723 if (!asoc) {
1724 err = -EPIPE;
1725 goto out_unlock;
1726 }
1727 }
1728
1729 if (asoc) {
1730 pr_debug("%s: just looked up association:%p\n", __func__, asoc);
1731
1732
1733
1734
1735
1736
1737 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
1738 err = -EPIPE;
1739 goto out_unlock;
1740 }
1741
1742 if (sinfo_flags & SCTP_EOF) {
1743 pr_debug("%s: shutting down association:%p\n",
1744 __func__, asoc);
1745
1746 sctp_primitive_SHUTDOWN(net, asoc, NULL);
1747 err = 0;
1748 goto out_unlock;
1749 }
1750 if (sinfo_flags & SCTP_ABORT) {
1751
1752 chunk = sctp_make_abort_user(asoc, msg, msg_len);
1753 if (!chunk) {
1754 err = -ENOMEM;
1755 goto out_unlock;
1756 }
1757
1758 pr_debug("%s: aborting association:%p\n",
1759 __func__, asoc);
1760
1761 sctp_primitive_ABORT(net, asoc, chunk);
1762 err = 0;
1763 goto out_unlock;
1764 }
1765 }
1766
1767
1768 if (!asoc) {
1769 pr_debug("%s: there is no association yet\n", __func__);
1770
1771 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) {
1772 err = -EINVAL;
1773 goto out_unlock;
1774 }
1775
1776
1777
1778
1779 if (sinfo) {
1780 if (!sinit || !sinit->sinit_num_ostreams) {
1781
1782 if (sinfo->sinfo_stream >=
1783 sp->initmsg.sinit_num_ostreams) {
1784 err = -EINVAL;
1785 goto out_unlock;
1786 }
1787 } else {
1788
1789 if (sinfo->sinfo_stream >=
1790 sinit->sinit_num_ostreams) {
1791 err = -EINVAL;
1792 goto out_unlock;
1793 }
1794 }
1795 }
1796
1797
1798
1799
1800
1801
1802
1803
1804 if (!ep->base.bind_addr.port) {
1805 if (sctp_autobind(sk)) {
1806 err = -EAGAIN;
1807 goto out_unlock;
1808 }
1809 } else {
1810
1811
1812
1813
1814
1815
1816
1817 if (ep->base.bind_addr.port < PROT_SOCK &&
1818 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE)) {
1819 err = -EACCES;
1820 goto out_unlock;
1821 }
1822 }
1823
1824 scope = sctp_scope(&to);
1825 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1826 if (!new_asoc) {
1827 err = -ENOMEM;
1828 goto out_unlock;
1829 }
1830 asoc = new_asoc;
1831 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
1832 if (err < 0) {
1833 err = -ENOMEM;
1834 goto out_free;
1835 }
1836
1837
1838
1839
1840 if (sinit) {
1841 if (sinit->sinit_num_ostreams) {
1842 asoc->c.sinit_num_ostreams =
1843 sinit->sinit_num_ostreams;
1844 }
1845 if (sinit->sinit_max_instreams) {
1846 asoc->c.sinit_max_instreams =
1847 sinit->sinit_max_instreams;
1848 }
1849 if (sinit->sinit_max_attempts) {
1850 asoc->max_init_attempts
1851 = sinit->sinit_max_attempts;
1852 }
1853 if (sinit->sinit_max_init_timeo) {
1854 asoc->max_init_timeo =
1855 msecs_to_jiffies(sinit->sinit_max_init_timeo);
1856 }
1857 }
1858
1859
1860 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
1861 if (!transport) {
1862 err = -ENOMEM;
1863 goto out_free;
1864 }
1865 }
1866
1867
1868 pr_debug("%s: we have a valid association\n", __func__);
1869
1870 if (!sinfo) {
1871
1872
1873
1874 memset(&default_sinfo, 0, sizeof(default_sinfo));
1875 default_sinfo.sinfo_stream = asoc->default_stream;
1876 default_sinfo.sinfo_flags = asoc->default_flags;
1877 default_sinfo.sinfo_ppid = asoc->default_ppid;
1878 default_sinfo.sinfo_context = asoc->default_context;
1879 default_sinfo.sinfo_timetolive = asoc->default_timetolive;
1880 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
1881
1882 sinfo = &default_sinfo;
1883 } else if (fill_sinfo_ttl) {
1884
1885
1886
1887 sinfo->sinfo_timetolive = asoc->default_timetolive;
1888 }
1889
1890
1891
1892
1893 if (msg_len > sk->sk_sndbuf) {
1894 err = -EMSGSIZE;
1895 goto out_free;
1896 }
1897
1898 if (asoc->pmtu_pending)
1899 sctp_assoc_pending_pmtu(sk, asoc);
1900
1901
1902
1903
1904
1905
1906 if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
1907 err = -EMSGSIZE;
1908 goto out_free;
1909 }
1910
1911
1912 if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) {
1913 err = -EINVAL;
1914 goto out_free;
1915 }
1916
1917 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1918 if (!sctp_wspace(asoc)) {
1919 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1920 if (err)
1921 goto out_free;
1922 }
1923
1924
1925
1926
1927
1928 if ((sctp_style(sk, TCP) && msg_name) ||
1929 (sinfo_flags & SCTP_ADDR_OVER)) {
1930 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
1931 if (!chunk_tp) {
1932 err = -EINVAL;
1933 goto out_free;
1934 }
1935 } else
1936 chunk_tp = NULL;
1937
1938
1939 if (sctp_state(asoc, CLOSED)) {
1940 err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1941 if (err < 0)
1942 goto out_free;
1943
1944 wait_connect = true;
1945 pr_debug("%s: we associated primitively\n", __func__);
1946 }
1947
1948
1949 datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
1950 if (IS_ERR(datamsg)) {
1951 err = PTR_ERR(datamsg);
1952 goto out_free;
1953 }
1954
1955
1956 list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
1957
1958 sctp_set_owner_w(chunk);
1959
1960 chunk->transport = chunk_tp;
1961 }
1962
1963
1964
1965
1966
1967
1968 err = sctp_primitive_SEND(net, asoc, datamsg);
1969 sctp_datamsg_put(datamsg);
1970
1971 if (err)
1972 goto out_free;
1973
1974 pr_debug("%s: we sent primitively\n", __func__);
1975
1976 err = msg_len;
1977
1978 if (unlikely(wait_connect)) {
1979 timeo = sock_sndtimeo(sk, msg_flags & MSG_DONTWAIT);
1980 sctp_wait_for_connect(asoc, &timeo);
1981 }
1982
1983
1984
1985
1986 goto out_unlock;
1987
1988out_free:
1989 if (new_asoc)
1990 sctp_association_free(asoc);
1991out_unlock:
1992 release_sock(sk);
1993
1994out_nounlock:
1995 return sctp_error(sk, msg_flags, err);
1996
1997#if 0
1998do_sock_err:
1999 if (msg_len)
2000 err = msg_len;
2001 else
2002 err = sock_error(sk);
2003 goto out;
2004
2005do_interrupted:
2006 if (msg_len)
2007 err = msg_len;
2008 goto out;
2009#endif
2010}
2011
2012
2013
2014
2015
2016
2017
2018
2019static int sctp_skb_pull(struct sk_buff *skb, int len)
2020{
2021 struct sk_buff *list;
2022 int skb_len = skb_headlen(skb);
2023 int rlen;
2024
2025 if (len <= skb_len) {
2026 __skb_pull(skb, len);
2027 return 0;
2028 }
2029 len -= skb_len;
2030 __skb_pull(skb, skb_len);
2031
2032 skb_walk_frags(skb, list) {
2033 rlen = sctp_skb_pull(list, len);
2034 skb->len -= (len-rlen);
2035 skb->data_len -= (len-rlen);
2036
2037 if (!rlen)
2038 return 0;
2039
2040 len = rlen;
2041 }
2042
2043 return len;
2044}
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
2062 int noblock, int flags, int *addr_len)
2063{
2064 struct sctp_ulpevent *event = NULL;
2065 struct sctp_sock *sp = sctp_sk(sk);
2066 struct sk_buff *skb;
2067 int copied;
2068 int err = 0;
2069 int skb_len;
2070
2071 pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2072 "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags,
2073 addr_len);
2074
2075 lock_sock(sk);
2076
2077 if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) {
2078 err = -ENOTCONN;
2079 goto out;
2080 }
2081
2082 skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
2083 if (!skb)
2084 goto out;
2085
2086
2087
2088
2089 skb_len = skb->len;
2090
2091 copied = skb_len;
2092 if (copied > len)
2093 copied = len;
2094
2095 err = skb_copy_datagram_msg(skb, 0, msg, copied);
2096
2097 event = sctp_skb2event(skb);
2098
2099 if (err)
2100 goto out_free;
2101
2102 sock_recv_ts_and_drops(msg, sk, skb);
2103 if (sctp_ulpevent_is_notification(event)) {
2104 msg->msg_flags |= MSG_NOTIFICATION;
2105 sp->pf->event_msgname(event, msg->msg_name, addr_len);
2106 } else {
2107 sp->pf->skb_msgname(skb, msg->msg_name, addr_len);
2108 }
2109
2110
2111 if (sp->recvnxtinfo)
2112 sctp_ulpevent_read_nxtinfo(event, msg, sk);
2113
2114 if (sp->recvrcvinfo)
2115 sctp_ulpevent_read_rcvinfo(event, msg);
2116
2117 if (sp->subscribe.sctp_data_io_event)
2118 sctp_ulpevent_read_sndrcvinfo(event, msg);
2119
2120 err = copied;
2121
2122
2123
2124
2125
2126 if (skb_len > copied) {
2127 msg->msg_flags &= ~MSG_EOR;
2128 if (flags & MSG_PEEK)
2129 goto out_free;
2130 sctp_skb_pull(skb, copied);
2131 skb_queue_head(&sk->sk_receive_queue, skb);
2132
2133
2134
2135
2136
2137 if (!sctp_ulpevent_is_notification(event))
2138 sctp_assoc_rwnd_increase(event->asoc, copied);
2139 goto out;
2140 } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2141 (event->msg_flags & MSG_EOR))
2142 msg->msg_flags |= MSG_EOR;
2143 else
2144 msg->msg_flags &= ~MSG_EOR;
2145
2146out_free:
2147 if (flags & MSG_PEEK) {
2148
2149
2150
2151 kfree_skb(skb);
2152 } else {
2153
2154
2155
2156
2157 sctp_ulpevent_free(event);
2158 }
2159out:
2160 release_sock(sk);
2161 return err;
2162}
2163
2164
2165
2166
2167
2168
2169
2170
2171static int sctp_setsockopt_disable_fragments(struct sock *sk,
2172 char __user *optval,
2173 unsigned int optlen)
2174{
2175 int val;
2176
2177 if (optlen < sizeof(int))
2178 return -EINVAL;
2179
2180 if (get_user(val, (int __user *)optval))
2181 return -EFAULT;
2182
2183 sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
2184
2185 return 0;
2186}
2187
2188static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
2189 unsigned int optlen)
2190{
2191 struct sctp_association *asoc;
2192 struct sctp_ulpevent *event;
2193
2194 if (optlen > sizeof(struct sctp_event_subscribe))
2195 return -EINVAL;
2196 if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
2197 return -EFAULT;
2198
2199
2200
2201
2202
2203 if (sctp_ulpevent_type_enabled(SCTP_SENDER_DRY_EVENT,
2204 &sctp_sk(sk)->subscribe)) {
2205 asoc = sctp_id2assoc(sk, 0);
2206
2207 if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2208 event = sctp_ulpevent_make_sender_dry_event(asoc,
2209 GFP_ATOMIC);
2210 if (!event)
2211 return -ENOMEM;
2212
2213 sctp_ulpq_tail_event(&asoc->ulpq, event);
2214 }
2215 }
2216
2217 return 0;
2218}
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
2232 unsigned int optlen)
2233{
2234 struct sctp_sock *sp = sctp_sk(sk);
2235 struct net *net = sock_net(sk);
2236
2237
2238 if (sctp_style(sk, TCP))
2239 return -EOPNOTSUPP;
2240 if (optlen != sizeof(int))
2241 return -EINVAL;
2242 if (copy_from_user(&sp->autoclose, optval, optlen))
2243 return -EFAULT;
2244
2245 if (sp->autoclose > net->sctp.max_autoclose)
2246 sp->autoclose = net->sctp.max_autoclose;
2247
2248 return 0;
2249}
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
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
2348static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2349 struct sctp_transport *trans,
2350 struct sctp_association *asoc,
2351 struct sctp_sock *sp,
2352 int hb_change,
2353 int pmtud_change,
2354 int sackdelay_change)
2355{
2356 int error;
2357
2358 if (params->spp_flags & SPP_HB_DEMAND && trans) {
2359 struct net *net = sock_net(trans->asoc->base.sk);
2360
2361 error = sctp_primitive_REQUESTHEARTBEAT(net, trans->asoc, trans);
2362 if (error)
2363 return error;
2364 }
2365
2366
2367
2368
2369
2370 if (params->spp_flags & SPP_HB_ENABLE) {
2371
2372
2373
2374
2375
2376 if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2377 params->spp_hbinterval = 0;
2378
2379 if (params->spp_hbinterval ||
2380 (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2381 if (trans) {
2382 trans->hbinterval =
2383 msecs_to_jiffies(params->spp_hbinterval);
2384 } else if (asoc) {
2385 asoc->hbinterval =
2386 msecs_to_jiffies(params->spp_hbinterval);
2387 } else {
2388 sp->hbinterval = params->spp_hbinterval;
2389 }
2390 }
2391 }
2392
2393 if (hb_change) {
2394 if (trans) {
2395 trans->param_flags =
2396 (trans->param_flags & ~SPP_HB) | hb_change;
2397 } else if (asoc) {
2398 asoc->param_flags =
2399 (asoc->param_flags & ~SPP_HB) | hb_change;
2400 } else {
2401 sp->param_flags =
2402 (sp->param_flags & ~SPP_HB) | hb_change;
2403 }
2404 }
2405
2406
2407
2408
2409
2410
2411 if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2412 if (trans) {
2413 trans->pathmtu = params->spp_pathmtu;
2414 sctp_assoc_sync_pmtu(sctp_opt2sk(sp), asoc);
2415 } else if (asoc) {
2416 asoc->pathmtu = params->spp_pathmtu;
2417 sctp_frag_point(asoc, params->spp_pathmtu);
2418 } else {
2419 sp->pathmtu = params->spp_pathmtu;
2420 }
2421 }
2422
2423 if (pmtud_change) {
2424 if (trans) {
2425 int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2426 (params->spp_flags & SPP_PMTUD_ENABLE);
2427 trans->param_flags =
2428 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2429 if (update) {
2430 sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2431 sctp_assoc_sync_pmtu(sctp_opt2sk(sp), asoc);
2432 }
2433 } else if (asoc) {
2434 asoc->param_flags =
2435 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2436 } else {
2437 sp->param_flags =
2438 (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2439 }
2440 }
2441
2442
2443
2444
2445
2446 if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2447 if (trans) {
2448 trans->sackdelay =
2449 msecs_to_jiffies(params->spp_sackdelay);
2450 } else if (asoc) {
2451 asoc->sackdelay =
2452 msecs_to_jiffies(params->spp_sackdelay);
2453 } else {
2454 sp->sackdelay = params->spp_sackdelay;
2455 }
2456 }
2457
2458 if (sackdelay_change) {
2459 if (trans) {
2460 trans->param_flags =
2461 (trans->param_flags & ~SPP_SACKDELAY) |
2462 sackdelay_change;
2463 } else if (asoc) {
2464 asoc->param_flags =
2465 (asoc->param_flags & ~SPP_SACKDELAY) |
2466 sackdelay_change;
2467 } else {
2468 sp->param_flags =
2469 (sp->param_flags & ~SPP_SACKDELAY) |
2470 sackdelay_change;
2471 }
2472 }
2473
2474
2475
2476
2477 if (params->spp_pathmaxrxt) {
2478 if (trans) {
2479 trans->pathmaxrxt = params->spp_pathmaxrxt;
2480 } else if (asoc) {
2481 asoc->pathmaxrxt = params->spp_pathmaxrxt;
2482 } else {
2483 sp->pathmaxrxt = params->spp_pathmaxrxt;
2484 }
2485 }
2486
2487 return 0;
2488}
2489
2490static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2491 char __user *optval,
2492 unsigned int optlen)
2493{
2494 struct sctp_paddrparams params;
2495 struct sctp_transport *trans = NULL;
2496 struct sctp_association *asoc = NULL;
2497 struct sctp_sock *sp = sctp_sk(sk);
2498 int error;
2499 int hb_change, pmtud_change, sackdelay_change;
2500
2501 if (optlen != sizeof(struct sctp_paddrparams))
2502 return -EINVAL;
2503
2504 if (copy_from_user(¶ms, optval, optlen))
2505 return -EFAULT;
2506
2507
2508 hb_change = params.spp_flags & SPP_HB;
2509 pmtud_change = params.spp_flags & SPP_PMTUD;
2510 sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2511
2512 if (hb_change == SPP_HB ||
2513 pmtud_change == SPP_PMTUD ||
2514 sackdelay_change == SPP_SACKDELAY ||
2515 params.spp_sackdelay > 500 ||
2516 (params.spp_pathmtu &&
2517 params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2518 return -EINVAL;
2519
2520
2521
2522
2523 if (!sctp_is_any(sk, (union sctp_addr *)¶ms.spp_address)) {
2524 trans = sctp_addr_id2transport(sk, ¶ms.spp_address,
2525 params.spp_assoc_id);
2526 if (!trans)
2527 return -EINVAL;
2528 }
2529
2530
2531
2532
2533
2534 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2535 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))
2536 return -EINVAL;
2537
2538
2539
2540
2541 if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2542 return -EINVAL;
2543
2544
2545 error = sctp_apply_peer_addr_params(¶ms, trans, asoc, sp,
2546 hb_change, pmtud_change,
2547 sackdelay_change);
2548
2549 if (error)
2550 return error;
2551
2552
2553
2554
2555 if (!trans && asoc) {
2556 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2557 transports) {
2558 sctp_apply_peer_addr_params(¶ms, trans, asoc, sp,
2559 hb_change, pmtud_change,
2560 sackdelay_change);
2561 }
2562 }
2563
2564 return 0;
2565}
2566
2567static inline __u32 sctp_spp_sackdelay_enable(__u32 param_flags)
2568{
2569 return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_ENABLE;
2570}
2571
2572static inline __u32 sctp_spp_sackdelay_disable(__u32 param_flags)
2573{
2574 return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_DISABLE;
2575}
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613static int sctp_setsockopt_delayed_ack(struct sock *sk,
2614 char __user *optval, unsigned int optlen)
2615{
2616 struct sctp_sack_info params;
2617 struct sctp_transport *trans = NULL;
2618 struct sctp_association *asoc = NULL;
2619 struct sctp_sock *sp = sctp_sk(sk);
2620
2621 if (optlen == sizeof(struct sctp_sack_info)) {
2622 if (copy_from_user(¶ms, optval, optlen))
2623 return -EFAULT;
2624
2625 if (params.sack_delay == 0 && params.sack_freq == 0)
2626 return 0;
2627 } else if (optlen == sizeof(struct sctp_assoc_value)) {
2628 pr_warn_ratelimited(DEPRECATED
2629 "%s (pid %d) "
2630 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
2631 "Use struct sctp_sack_info instead\n",
2632 current->comm, task_pid_nr(current));
2633 if (copy_from_user(¶ms, optval, optlen))
2634 return -EFAULT;
2635
2636 if (params.sack_delay == 0)
2637 params.sack_freq = 1;
2638 else
2639 params.sack_freq = 0;
2640 } else
2641 return -EINVAL;
2642
2643
2644 if (params.sack_delay > 500)
2645 return -EINVAL;
2646
2647
2648
2649
2650
2651 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
2652 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
2653 return -EINVAL;
2654
2655 if (params.sack_delay) {
2656 if (asoc) {
2657 asoc->sackdelay =
2658 msecs_to_jiffies(params.sack_delay);
2659 asoc->param_flags =
2660 sctp_spp_sackdelay_enable(asoc->param_flags);
2661 } else {
2662 sp->sackdelay = params.sack_delay;
2663 sp->param_flags =
2664 sctp_spp_sackdelay_enable(sp->param_flags);
2665 }
2666 }
2667
2668 if (params.sack_freq == 1) {
2669 if (asoc) {
2670 asoc->param_flags =
2671 sctp_spp_sackdelay_disable(asoc->param_flags);
2672 } else {
2673 sp->param_flags =
2674 sctp_spp_sackdelay_disable(sp->param_flags);
2675 }
2676 } else if (params.sack_freq > 1) {
2677 if (asoc) {
2678 asoc->sackfreq = params.sack_freq;
2679 asoc->param_flags =
2680 sctp_spp_sackdelay_enable(asoc->param_flags);
2681 } else {
2682 sp->sackfreq = params.sack_freq;
2683 sp->param_flags =
2684 sctp_spp_sackdelay_enable(sp->param_flags);
2685 }
2686 }
2687
2688
2689 if (asoc) {
2690 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2691 transports) {
2692 if (params.sack_delay) {
2693 trans->sackdelay =
2694 msecs_to_jiffies(params.sack_delay);
2695 trans->param_flags =
2696 sctp_spp_sackdelay_enable(trans->param_flags);
2697 }
2698 if (params.sack_freq == 1) {
2699 trans->param_flags =
2700 sctp_spp_sackdelay_disable(trans->param_flags);
2701 } else if (params.sack_freq > 1) {
2702 trans->sackfreq = params.sack_freq;
2703 trans->param_flags =
2704 sctp_spp_sackdelay_enable(trans->param_flags);
2705 }
2706 }
2707 }
2708
2709 return 0;
2710}
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen)
2724{
2725 struct sctp_initmsg sinit;
2726 struct sctp_sock *sp = sctp_sk(sk);
2727
2728 if (optlen != sizeof(struct sctp_initmsg))
2729 return -EINVAL;
2730 if (copy_from_user(&sinit, optval, optlen))
2731 return -EFAULT;
2732
2733 if (sinit.sinit_num_ostreams)
2734 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
2735 if (sinit.sinit_max_instreams)
2736 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
2737 if (sinit.sinit_max_attempts)
2738 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
2739 if (sinit.sinit_max_init_timeo)
2740 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
2741
2742 return 0;
2743}
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759static int sctp_setsockopt_default_send_param(struct sock *sk,
2760 char __user *optval,
2761 unsigned int optlen)
2762{
2763 struct sctp_sock *sp = sctp_sk(sk);
2764 struct sctp_association *asoc;
2765 struct sctp_sndrcvinfo info;
2766
2767 if (optlen != sizeof(info))
2768 return -EINVAL;
2769 if (copy_from_user(&info, optval, optlen))
2770 return -EFAULT;
2771 if (info.sinfo_flags &
2772 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2773 SCTP_ABORT | SCTP_EOF))
2774 return -EINVAL;
2775
2776 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2777 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
2778 return -EINVAL;
2779 if (asoc) {
2780 asoc->default_stream = info.sinfo_stream;
2781 asoc->default_flags = info.sinfo_flags;
2782 asoc->default_ppid = info.sinfo_ppid;
2783 asoc->default_context = info.sinfo_context;
2784 asoc->default_timetolive = info.sinfo_timetolive;
2785 } else {
2786 sp->default_stream = info.sinfo_stream;
2787 sp->default_flags = info.sinfo_flags;
2788 sp->default_ppid = info.sinfo_ppid;
2789 sp->default_context = info.sinfo_context;
2790 sp->default_timetolive = info.sinfo_timetolive;
2791 }
2792
2793 return 0;
2794}
2795
2796
2797
2798
2799static int sctp_setsockopt_default_sndinfo(struct sock *sk,
2800 char __user *optval,
2801 unsigned int optlen)
2802{
2803 struct sctp_sock *sp = sctp_sk(sk);
2804 struct sctp_association *asoc;
2805 struct sctp_sndinfo info;
2806
2807 if (optlen != sizeof(info))
2808 return -EINVAL;
2809 if (copy_from_user(&info, optval, optlen))
2810 return -EFAULT;
2811 if (info.snd_flags &
2812 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2813 SCTP_ABORT | SCTP_EOF))
2814 return -EINVAL;
2815
2816 asoc = sctp_id2assoc(sk, info.snd_assoc_id);
2817 if (!asoc && info.snd_assoc_id && sctp_style(sk, UDP))
2818 return -EINVAL;
2819 if (asoc) {
2820 asoc->default_stream = info.snd_sid;
2821 asoc->default_flags = info.snd_flags;
2822 asoc->default_ppid = info.snd_ppid;
2823 asoc->default_context = info.snd_context;
2824 } else {
2825 sp->default_stream = info.snd_sid;
2826 sp->default_flags = info.snd_flags;
2827 sp->default_ppid = info.snd_ppid;
2828 sp->default_context = info.snd_context;
2829 }
2830
2831 return 0;
2832}
2833
2834
2835
2836
2837
2838
2839
2840static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
2841 unsigned int optlen)
2842{
2843 struct sctp_prim prim;
2844 struct sctp_transport *trans;
2845
2846 if (optlen != sizeof(struct sctp_prim))
2847 return -EINVAL;
2848
2849 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
2850 return -EFAULT;
2851
2852 trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
2853 if (!trans)
2854 return -EINVAL;
2855
2856 sctp_assoc_set_primary(trans->asoc, trans);
2857
2858 return 0;
2859}
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
2870 unsigned int optlen)
2871{
2872 int val;
2873
2874 if (optlen < sizeof(int))
2875 return -EINVAL;
2876 if (get_user(val, (int __user *)optval))
2877 return -EFAULT;
2878
2879 sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
2880 return 0;
2881}
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen)
2896{
2897 struct sctp_rtoinfo rtoinfo;
2898 struct sctp_association *asoc;
2899 unsigned long rto_min, rto_max;
2900 struct sctp_sock *sp = sctp_sk(sk);
2901
2902 if (optlen != sizeof (struct sctp_rtoinfo))
2903 return -EINVAL;
2904
2905 if (copy_from_user(&rtoinfo, optval, optlen))
2906 return -EFAULT;
2907
2908 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
2909
2910
2911 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
2912 return -EINVAL;
2913
2914 rto_max = rtoinfo.srto_max;
2915 rto_min = rtoinfo.srto_min;
2916
2917 if (rto_max)
2918 rto_max = asoc ? msecs_to_jiffies(rto_max) : rto_max;
2919 else
2920 rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
2921
2922 if (rto_min)
2923 rto_min = asoc ? msecs_to_jiffies(rto_min) : rto_min;
2924 else
2925 rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
2926
2927 if (rto_min > rto_max)
2928 return -EINVAL;
2929
2930 if (asoc) {
2931 if (rtoinfo.srto_initial != 0)
2932 asoc->rto_initial =
2933 msecs_to_jiffies(rtoinfo.srto_initial);
2934 asoc->rto_max = rto_max;
2935 asoc->rto_min = rto_min;
2936 } else {
2937
2938
2939
2940 if (rtoinfo.srto_initial != 0)
2941 sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
2942 sp->rtoinfo.srto_max = rto_max;
2943 sp->rtoinfo.srto_min = rto_min;
2944 }
2945
2946 return 0;
2947}
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen)
2961{
2962
2963 struct sctp_assocparams assocparams;
2964 struct sctp_association *asoc;
2965
2966 if (optlen != sizeof(struct sctp_assocparams))
2967 return -EINVAL;
2968 if (copy_from_user(&assocparams, optval, optlen))
2969 return -EFAULT;
2970
2971 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
2972
2973 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
2974 return -EINVAL;
2975
2976
2977 if (asoc) {
2978 if (assocparams.sasoc_asocmaxrxt != 0) {
2979 __u32 path_sum = 0;
2980 int paths = 0;
2981 struct sctp_transport *peer_addr;
2982
2983 list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
2984 transports) {
2985 path_sum += peer_addr->pathmaxrxt;
2986 paths++;
2987 }
2988
2989
2990
2991
2992
2993
2994 if (paths > 1 &&
2995 assocparams.sasoc_asocmaxrxt > path_sum)
2996 return -EINVAL;
2997
2998 asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
2999 }
3000
3001 if (assocparams.sasoc_cookie_life != 0)
3002 asoc->cookie_life = ms_to_ktime(assocparams.sasoc_cookie_life);
3003 } else {
3004
3005 struct sctp_sock *sp = sctp_sk(sk);
3006
3007 if (assocparams.sasoc_asocmaxrxt != 0)
3008 sp->assocparams.sasoc_asocmaxrxt =
3009 assocparams.sasoc_asocmaxrxt;
3010 if (assocparams.sasoc_cookie_life != 0)
3011 sp->assocparams.sasoc_cookie_life =
3012 assocparams.sasoc_cookie_life;
3013 }
3014 return 0;
3015}
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen)
3028{
3029 int val;
3030 struct sctp_sock *sp = sctp_sk(sk);
3031
3032 if (optlen < sizeof(int))
3033 return -EINVAL;
3034 if (get_user(val, (int __user *)optval))
3035 return -EFAULT;
3036 if (val)
3037 sp->v4mapped = 1;
3038 else
3039 sp->v4mapped = 0;
3040
3041 return 0;
3042}
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen)
3072{
3073 struct sctp_assoc_value params;
3074 struct sctp_association *asoc;
3075 struct sctp_sock *sp = sctp_sk(sk);
3076 int val;
3077
3078 if (optlen == sizeof(int)) {
3079 pr_warn_ratelimited(DEPRECATED
3080 "%s (pid %d) "
3081 "Use of int in maxseg socket option.\n"
3082 "Use struct sctp_assoc_value instead\n",
3083 current->comm, task_pid_nr(current));
3084 if (copy_from_user(&val, optval, optlen))
3085 return -EFAULT;
3086 params.assoc_id = 0;
3087 } else if (optlen == sizeof(struct sctp_assoc_value)) {
3088 if (copy_from_user(¶ms, optval, optlen))
3089 return -EFAULT;
3090 val = params.assoc_value;
3091 } else
3092 return -EINVAL;
3093
3094 if ((val != 0) && ((val < 8) || (val > SCTP_MAX_CHUNK_LEN)))
3095 return -EINVAL;
3096
3097 asoc = sctp_id2assoc(sk, params.assoc_id);
3098 if (!asoc && params.assoc_id && sctp_style(sk, UDP))
3099 return -EINVAL;
3100
3101 if (asoc) {
3102 if (val == 0) {
3103 val = asoc->pathmtu;
3104 val -= sp->pf->af->net_header_len;
3105 val -= sizeof(struct sctphdr) +
3106 sizeof(struct sctp_data_chunk);
3107 }
3108 asoc->user_frag = val;
3109 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
3110 } else {
3111 sp->user_frag = val;
3112 }
3113
3114 return 0;
3115}
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
3127 unsigned int optlen)
3128{
3129 struct net *net = sock_net(sk);
3130 struct sctp_sock *sp;
3131 struct sctp_association *asoc = NULL;
3132 struct sctp_setpeerprim prim;
3133 struct sctp_chunk *chunk;
3134 struct sctp_af *af;
3135 int err;
3136
3137 sp = sctp_sk(sk);
3138
3139 if (!net->sctp.addip_enable)
3140 return -EPERM;
3141
3142 if (optlen != sizeof(struct sctp_setpeerprim))
3143 return -EINVAL;
3144
3145 if (copy_from_user(&prim, optval, optlen))
3146 return -EFAULT;
3147
3148 asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
3149 if (!asoc)
3150 return -EINVAL;
3151
3152 if (!asoc->peer.asconf_capable)
3153 return -EPERM;
3154
3155 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3156 return -EPERM;
3157
3158 if (!sctp_state(asoc, ESTABLISHED))
3159 return -ENOTCONN;
3160
3161 af = sctp_get_af_specific(prim.sspp_addr.ss_family);
3162 if (!af)
3163 return -EINVAL;
3164
3165 if (!af->addr_valid((union sctp_addr *)&prim.sspp_addr, sp, NULL))
3166 return -EADDRNOTAVAIL;
3167
3168 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
3169 return -EADDRNOTAVAIL;
3170
3171
3172 chunk = sctp_make_asconf_set_prim(asoc,
3173 (union sctp_addr *)&prim.sspp_addr);
3174 if (!chunk)
3175 return -ENOMEM;
3176
3177 err = sctp_send_asconf(asoc, chunk);
3178
3179 pr_debug("%s: we set peer primary addr primitively\n", __func__);
3180
3181 return err;
3182}
3183
3184static int sctp_setsockopt_adaptation_layer(struct sock *sk, char __user *optval,
3185 unsigned int optlen)
3186{
3187 struct sctp_setadaptation adaptation;
3188
3189 if (optlen != sizeof(struct sctp_setadaptation))
3190 return -EINVAL;
3191 if (copy_from_user(&adaptation, optval, optlen))
3192 return -EFAULT;
3193
3194 sctp_sk(sk)->adaptation_ind = adaptation.ssb_adaptation_ind;
3195
3196 return 0;
3197}
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213static int sctp_setsockopt_context(struct sock *sk, char __user *optval,
3214 unsigned int optlen)
3215{
3216 struct sctp_assoc_value params;
3217 struct sctp_sock *sp;
3218 struct sctp_association *asoc;
3219
3220 if (optlen != sizeof(struct sctp_assoc_value))
3221 return -EINVAL;
3222 if (copy_from_user(¶ms, optval, optlen))
3223 return -EFAULT;
3224
3225 sp = sctp_sk(sk);
3226
3227 if (params.assoc_id != 0) {
3228 asoc = sctp_id2assoc(sk, params.assoc_id);
3229 if (!asoc)
3230 return -EINVAL;
3231 asoc->default_rcv_context = params.assoc_value;
3232 } else {
3233 sp->default_rcv_context = params.assoc_value;
3234 }
3235
3236 return 0;
3237}
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263static int sctp_setsockopt_fragment_interleave(struct sock *sk,
3264 char __user *optval,
3265 unsigned int optlen)
3266{
3267 int val;
3268
3269 if (optlen != sizeof(int))
3270 return -EINVAL;
3271 if (get_user(val, (int __user *)optval))
3272 return -EFAULT;
3273
3274 sctp_sk(sk)->frag_interleave = (val == 0) ? 0 : 1;
3275
3276 return 0;
3277}
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296static int sctp_setsockopt_partial_delivery_point(struct sock *sk,
3297 char __user *optval,
3298 unsigned int optlen)
3299{
3300 u32 val;
3301
3302 if (optlen != sizeof(u32))
3303 return -EINVAL;
3304 if (get_user(val, (int __user *)optval))
3305 return -EFAULT;
3306
3307
3308
3309
3310 if (val > (sk->sk_rcvbuf >> 1))
3311 return -EINVAL;
3312
3313 sctp_sk(sk)->pd_point = val;
3314
3315 return 0;
3316}
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329static int sctp_setsockopt_maxburst(struct sock *sk,
3330 char __user *optval,
3331 unsigned int optlen)
3332{
3333 struct sctp_assoc_value params;
3334 struct sctp_sock *sp;
3335 struct sctp_association *asoc;
3336 int val;
3337 int assoc_id = 0;
3338
3339 if (optlen == sizeof(int)) {
3340 pr_warn_ratelimited(DEPRECATED
3341 "%s (pid %d) "
3342 "Use of int in max_burst socket option deprecated.\n"
3343 "Use struct sctp_assoc_value instead\n",
3344 current->comm, task_pid_nr(current));
3345 if (copy_from_user(&val, optval, optlen))
3346 return -EFAULT;
3347 } else if (optlen == sizeof(struct sctp_assoc_value)) {
3348 if (copy_from_user(¶ms, optval, optlen))
3349 return -EFAULT;
3350 val = params.assoc_value;
3351 assoc_id = params.assoc_id;
3352 } else
3353 return -EINVAL;
3354
3355 sp = sctp_sk(sk);
3356
3357 if (assoc_id != 0) {
3358 asoc = sctp_id2assoc(sk, assoc_id);
3359 if (!asoc)
3360 return -EINVAL;
3361 asoc->max_burst = val;
3362 } else
3363 sp->max_burst = val;
3364
3365 return 0;
3366}
3367
3368
3369
3370
3371
3372
3373
3374
3375static int sctp_setsockopt_auth_chunk(struct sock *sk,
3376 char __user *optval,
3377 unsigned int optlen)
3378{
3379 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3380 struct sctp_authchunk val;
3381
3382 if (!ep->auth_enable)
3383 return -EACCES;
3384
3385 if (optlen != sizeof(struct sctp_authchunk))
3386 return -EINVAL;
3387 if (copy_from_user(&val, optval, optlen))
3388 return -EFAULT;
3389
3390 switch (val.sauth_chunk) {
3391 case SCTP_CID_INIT:
3392 case SCTP_CID_INIT_ACK:
3393 case SCTP_CID_SHUTDOWN_COMPLETE:
3394 case SCTP_CID_AUTH:
3395 return -EINVAL;
3396 }
3397
3398
3399 return sctp_auth_ep_add_chunkid(ep, val.sauth_chunk);
3400}
3401
3402
3403
3404
3405
3406
3407
3408static int sctp_setsockopt_hmac_ident(struct sock *sk,
3409 char __user *optval,
3410 unsigned int optlen)
3411{
3412 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3413 struct sctp_hmacalgo *hmacs;
3414 u32 idents;
3415 int err;
3416
3417 if (!ep->auth_enable)
3418 return -EACCES;
3419
3420 if (optlen < sizeof(struct sctp_hmacalgo))
3421 return -EINVAL;
3422
3423 hmacs = memdup_user(optval, optlen);
3424 if (IS_ERR(hmacs))
3425 return PTR_ERR(hmacs);
3426
3427 idents = hmacs->shmac_num_idents;
3428 if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS ||
3429 (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo))) {
3430 err = -EINVAL;
3431 goto out;
3432 }
3433
3434 err = sctp_auth_ep_set_hmacs(ep, hmacs);
3435out:
3436 kfree(hmacs);
3437 return err;
3438}
3439
3440
3441
3442
3443
3444
3445
3446static int sctp_setsockopt_auth_key(struct sock *sk,
3447 char __user *optval,
3448 unsigned int optlen)
3449{
3450 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3451 struct sctp_authkey *authkey;
3452 struct sctp_association *asoc;
3453 int ret;
3454
3455 if (!ep->auth_enable)
3456 return -EACCES;
3457
3458 if (optlen <= sizeof(struct sctp_authkey))
3459 return -EINVAL;
3460
3461 authkey = memdup_user(optval, optlen);
3462 if (IS_ERR(authkey))
3463 return PTR_ERR(authkey);
3464
3465 if (authkey->sca_keylength > optlen - sizeof(struct sctp_authkey)) {
3466 ret = -EINVAL;
3467 goto out;
3468 }
3469
3470 asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3471 if (!asoc && authkey->sca_assoc_id && sctp_style(sk, UDP)) {
3472 ret = -EINVAL;
3473 goto out;
3474 }
3475
3476 ret = sctp_auth_set_key(ep, asoc, authkey);
3477out:
3478 kzfree(authkey);
3479 return ret;
3480}
3481
3482
3483
3484
3485
3486
3487
3488static int sctp_setsockopt_active_key(struct sock *sk,
3489 char __user *optval,
3490 unsigned int optlen)
3491{
3492 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3493 struct sctp_authkeyid val;
3494 struct sctp_association *asoc;
3495
3496 if (!ep->auth_enable)
3497 return -EACCES;
3498
3499 if (optlen != sizeof(struct sctp_authkeyid))
3500 return -EINVAL;
3501 if (copy_from_user(&val, optval, optlen))
3502 return -EFAULT;
3503
3504 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3505 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3506 return -EINVAL;
3507
3508 return sctp_auth_set_active_key(ep, asoc, val.scact_keynumber);
3509}
3510
3511
3512
3513
3514
3515
3516static int sctp_setsockopt_del_key(struct sock *sk,
3517 char __user *optval,
3518 unsigned int optlen)
3519{
3520 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3521 struct sctp_authkeyid val;
3522 struct sctp_association *asoc;
3523
3524 if (!ep->auth_enable)
3525 return -EACCES;
3526
3527 if (optlen != sizeof(struct sctp_authkeyid))
3528 return -EINVAL;
3529 if (copy_from_user(&val, optval, optlen))
3530 return -EFAULT;
3531
3532 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3533 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3534 return -EINVAL;
3535
3536 return sctp_auth_del_key_id(ep, asoc, val.scact_keynumber);
3537
3538}
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval,
3555 unsigned int optlen)
3556{
3557 int val;
3558 struct sctp_sock *sp = sctp_sk(sk);
3559
3560 if (optlen < sizeof(int))
3561 return -EINVAL;
3562 if (get_user(val, (int __user *)optval))
3563 return -EFAULT;
3564 if (!sctp_is_ep_boundall(sk) && val)
3565 return -EINVAL;
3566 if ((val && sp->do_auto_asconf) || (!val && !sp->do_auto_asconf))
3567 return 0;
3568
3569 spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3570 if (val == 0 && sp->do_auto_asconf) {
3571 list_del(&sp->auto_asconf_list);
3572 sp->do_auto_asconf = 0;
3573 } else if (val && !sp->do_auto_asconf) {
3574 list_add_tail(&sp->auto_asconf_list,
3575 &sock_net(sk)->sctp.auto_asconf_splist);
3576 sp->do_auto_asconf = 1;
3577 }
3578 spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3579 return 0;
3580}
3581
3582
3583
3584
3585
3586
3587
3588
3589static int sctp_setsockopt_paddr_thresholds(struct sock *sk,
3590 char __user *optval,
3591 unsigned int optlen)
3592{
3593 struct sctp_paddrthlds val;
3594 struct sctp_transport *trans;
3595 struct sctp_association *asoc;
3596
3597 if (optlen < sizeof(struct sctp_paddrthlds))
3598 return -EINVAL;
3599 if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval,
3600 sizeof(struct sctp_paddrthlds)))
3601 return -EFAULT;
3602
3603
3604 if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
3605 asoc = sctp_id2assoc(sk, val.spt_assoc_id);
3606 if (!asoc)
3607 return -ENOENT;
3608 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
3609 transports) {
3610 if (val.spt_pathmaxrxt)
3611 trans->pathmaxrxt = val.spt_pathmaxrxt;
3612 trans->pf_retrans = val.spt_pathpfthld;
3613 }
3614
3615 if (val.spt_pathmaxrxt)
3616 asoc->pathmaxrxt = val.spt_pathmaxrxt;
3617 asoc->pf_retrans = val.spt_pathpfthld;
3618 } else {
3619 trans = sctp_addr_id2transport(sk, &val.spt_address,
3620 val.spt_assoc_id);
3621 if (!trans)
3622 return -ENOENT;
3623
3624 if (val.spt_pathmaxrxt)
3625 trans->pathmaxrxt = val.spt_pathmaxrxt;
3626 trans->pf_retrans = val.spt_pathpfthld;
3627 }
3628
3629 return 0;
3630}
3631
3632static int sctp_setsockopt_recvrcvinfo(struct sock *sk,
3633 char __user *optval,
3634 unsigned int optlen)
3635{
3636 int val;
3637
3638 if (optlen < sizeof(int))
3639 return -EINVAL;
3640 if (get_user(val, (int __user *) optval))
3641 return -EFAULT;
3642
3643 sctp_sk(sk)->recvrcvinfo = (val == 0) ? 0 : 1;
3644
3645 return 0;
3646}
3647
3648static int sctp_setsockopt_recvnxtinfo(struct sock *sk,
3649 char __user *optval,
3650 unsigned int optlen)
3651{
3652 int val;
3653
3654 if (optlen < sizeof(int))
3655 return -EINVAL;
3656 if (get_user(val, (int __user *) optval))
3657 return -EFAULT;
3658
3659 sctp_sk(sk)->recvnxtinfo = (val == 0) ? 0 : 1;
3660
3661 return 0;
3662}
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683static int sctp_setsockopt(struct sock *sk, int level, int optname,
3684 char __user *optval, unsigned int optlen)
3685{
3686 int retval = 0;
3687
3688 pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
3689
3690
3691
3692
3693
3694
3695
3696 if (level != SOL_SCTP) {
3697 struct sctp_af *af = sctp_sk(sk)->pf->af;
3698 retval = af->setsockopt(sk, level, optname, optval, optlen);
3699 goto out_nounlock;
3700 }
3701
3702 lock_sock(sk);
3703
3704 switch (optname) {
3705 case SCTP_SOCKOPT_BINDX_ADD:
3706
3707 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
3708 optlen, SCTP_BINDX_ADD_ADDR);
3709 break;
3710
3711 case SCTP_SOCKOPT_BINDX_REM:
3712
3713 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
3714 optlen, SCTP_BINDX_REM_ADDR);
3715 break;
3716
3717 case SCTP_SOCKOPT_CONNECTX_OLD:
3718
3719 retval = sctp_setsockopt_connectx_old(sk,
3720 (struct sockaddr __user *)optval,
3721 optlen);
3722 break;
3723
3724 case SCTP_SOCKOPT_CONNECTX:
3725
3726 retval = sctp_setsockopt_connectx(sk,
3727 (struct sockaddr __user *)optval,
3728 optlen);
3729 break;
3730
3731 case SCTP_DISABLE_FRAGMENTS:
3732 retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
3733 break;
3734
3735 case SCTP_EVENTS:
3736 retval = sctp_setsockopt_events(sk, optval, optlen);
3737 break;
3738
3739 case SCTP_AUTOCLOSE:
3740 retval = sctp_setsockopt_autoclose(sk, optval, optlen);
3741 break;
3742
3743 case SCTP_PEER_ADDR_PARAMS:
3744 retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
3745 break;
3746
3747 case SCTP_DELAYED_SACK:
3748 retval = sctp_setsockopt_delayed_ack(sk, optval, optlen);
3749 break;
3750 case SCTP_PARTIAL_DELIVERY_POINT:
3751 retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen);
3752 break;
3753
3754 case SCTP_INITMSG:
3755 retval = sctp_setsockopt_initmsg(sk, optval, optlen);
3756 break;
3757 case SCTP_DEFAULT_SEND_PARAM:
3758 retval = sctp_setsockopt_default_send_param(sk, optval,
3759 optlen);
3760 break;
3761 case SCTP_DEFAULT_SNDINFO:
3762 retval = sctp_setsockopt_default_sndinfo(sk, optval, optlen);
3763 break;
3764 case SCTP_PRIMARY_ADDR:
3765 retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
3766 break;
3767 case SCTP_SET_PEER_PRIMARY_ADDR:
3768 retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
3769 break;
3770 case SCTP_NODELAY:
3771 retval = sctp_setsockopt_nodelay(sk, optval, optlen);
3772 break;
3773 case SCTP_RTOINFO:
3774 retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
3775 break;
3776 case SCTP_ASSOCINFO:
3777 retval = sctp_setsockopt_associnfo(sk, optval, optlen);
3778 break;
3779 case SCTP_I_WANT_MAPPED_V4_ADDR:
3780 retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
3781 break;
3782 case SCTP_MAXSEG:
3783 retval = sctp_setsockopt_maxseg(sk, optval, optlen);
3784 break;
3785 case SCTP_ADAPTATION_LAYER:
3786 retval = sctp_setsockopt_adaptation_layer(sk, optval, optlen);
3787 break;
3788 case SCTP_CONTEXT:
3789 retval = sctp_setsockopt_context(sk, optval, optlen);
3790 break;
3791 case SCTP_FRAGMENT_INTERLEAVE:
3792 retval = sctp_setsockopt_fragment_interleave(sk, optval, optlen);
3793 break;
3794 case SCTP_MAX_BURST:
3795 retval = sctp_setsockopt_maxburst(sk, optval, optlen);
3796 break;
3797 case SCTP_AUTH_CHUNK:
3798 retval = sctp_setsockopt_auth_chunk(sk, optval, optlen);
3799 break;
3800 case SCTP_HMAC_IDENT:
3801 retval = sctp_setsockopt_hmac_ident(sk, optval, optlen);
3802 break;
3803 case SCTP_AUTH_KEY:
3804 retval = sctp_setsockopt_auth_key(sk, optval, optlen);
3805 break;
3806 case SCTP_AUTH_ACTIVE_KEY:
3807 retval = sctp_setsockopt_active_key(sk, optval, optlen);
3808 break;
3809 case SCTP_AUTH_DELETE_KEY:
3810 retval = sctp_setsockopt_del_key(sk, optval, optlen);
3811 break;
3812 case SCTP_AUTO_ASCONF:
3813 retval = sctp_setsockopt_auto_asconf(sk, optval, optlen);
3814 break;
3815 case SCTP_PEER_ADDR_THLDS:
3816 retval = sctp_setsockopt_paddr_thresholds(sk, optval, optlen);
3817 break;
3818 case SCTP_RECVRCVINFO:
3819 retval = sctp_setsockopt_recvrcvinfo(sk, optval, optlen);
3820 break;
3821 case SCTP_RECVNXTINFO:
3822 retval = sctp_setsockopt_recvnxtinfo(sk, optval, optlen);
3823 break;
3824 default:
3825 retval = -ENOPROTOOPT;
3826 break;
3827 }
3828
3829 release_sock(sk);
3830
3831out_nounlock:
3832 return retval;
3833}
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851static int sctp_connect(struct sock *sk, struct sockaddr *addr,
3852 int addr_len)
3853{
3854 int err = 0;
3855 struct sctp_af *af;
3856
3857 lock_sock(sk);
3858
3859 pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__, sk,
3860 addr, addr_len);
3861
3862
3863 af = sctp_get_af_specific(addr->sa_family);
3864 if (!af || addr_len < af->sockaddr_len) {
3865 err = -EINVAL;
3866 } else {
3867
3868
3869
3870 err = __sctp_connect(sk, addr, af->sockaddr_len, NULL);
3871 }
3872
3873 release_sock(sk);
3874 return err;
3875}
3876
3877
3878static int sctp_disconnect(struct sock *sk, int flags)
3879{
3880 return -EOPNOTSUPP;
3881}
3882
3883
3884
3885
3886
3887
3888
3889
3890static struct sock *sctp_accept(struct sock *sk, int flags, int *err)
3891{
3892 struct sctp_sock *sp;
3893 struct sctp_endpoint *ep;
3894 struct sock *newsk = NULL;
3895 struct sctp_association *asoc;
3896 long timeo;
3897 int error = 0;
3898
3899 lock_sock(sk);
3900
3901 sp = sctp_sk(sk);
3902 ep = sp->ep;
3903
3904 if (!sctp_style(sk, TCP)) {
3905 error = -EOPNOTSUPP;
3906 goto out;
3907 }
3908
3909 if (!sctp_sstate(sk, LISTENING)) {
3910 error = -EINVAL;
3911 goto out;
3912 }
3913
3914 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
3915
3916 error = sctp_wait_for_accept(sk, timeo);
3917 if (error)
3918 goto out;
3919
3920
3921
3922
3923 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
3924
3925 newsk = sp->pf->create_accept_sk(sk, asoc);
3926 if (!newsk) {
3927 error = -ENOMEM;
3928 goto out;
3929 }
3930
3931
3932
3933
3934 sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
3935
3936out:
3937 release_sock(sk);
3938 *err = error;
3939 return newsk;
3940}
3941
3942
3943static int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
3944{
3945 int rc = -ENOTCONN;
3946
3947 lock_sock(sk);
3948
3949
3950
3951
3952
3953 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
3954 goto out;
3955
3956 switch (cmd) {
3957 case SIOCINQ: {
3958 struct sk_buff *skb;
3959 unsigned int amount = 0;
3960
3961 skb = skb_peek(&sk->sk_receive_queue);
3962 if (skb != NULL) {
3963
3964
3965
3966
3967 amount = skb->len;
3968 }
3969 rc = put_user(amount, (int __user *)arg);
3970 break;
3971 }
3972 default:
3973 rc = -ENOIOCTLCMD;
3974 break;
3975 }
3976out:
3977 release_sock(sk);
3978 return rc;
3979}
3980
3981
3982
3983
3984
3985static int sctp_init_sock(struct sock *sk)
3986{
3987 struct net *net = sock_net(sk);
3988 struct sctp_sock *sp;
3989
3990 pr_debug("%s: sk:%p\n", __func__, sk);
3991
3992 sp = sctp_sk(sk);
3993
3994
3995 switch (sk->sk_type) {
3996 case SOCK_SEQPACKET:
3997 sp->type = SCTP_SOCKET_UDP;
3998 break;
3999 case SOCK_STREAM:
4000 sp->type = SCTP_SOCKET_TCP;
4001 break;
4002 default:
4003 return -ESOCKTNOSUPPORT;
4004 }
4005
4006
4007
4008
4009 sp->default_stream = 0;
4010 sp->default_ppid = 0;
4011 sp->default_flags = 0;
4012 sp->default_context = 0;
4013 sp->default_timetolive = 0;
4014
4015 sp->default_rcv_context = 0;
4016 sp->max_burst = net->sctp.max_burst;
4017
4018 sp->sctp_hmac_alg = net->sctp.sctp_hmac_alg;
4019
4020
4021
4022
4023
4024 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;
4025 sp->initmsg.sinit_max_instreams = sctp_max_instreams;
4026 sp->initmsg.sinit_max_attempts = net->sctp.max_retrans_init;
4027 sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
4028
4029
4030
4031
4032 sp->rtoinfo.srto_initial = net->sctp.rto_initial;
4033 sp->rtoinfo.srto_max = net->sctp.rto_max;
4034 sp->rtoinfo.srto_min = net->sctp.rto_min;
4035
4036
4037
4038
4039 sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
4040 sp->assocparams.sasoc_number_peer_destinations = 0;
4041 sp->assocparams.sasoc_peer_rwnd = 0;
4042 sp->assocparams.sasoc_local_rwnd = 0;
4043 sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
4044
4045
4046
4047
4048 memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));
4049
4050
4051
4052
4053 sp->hbinterval = net->sctp.hb_interval;
4054 sp->pathmaxrxt = net->sctp.max_retrans_path;
4055 sp->pathmtu = 0;
4056 sp->sackdelay = net->sctp.sack_timeout;
4057 sp->sackfreq = 2;
4058 sp->param_flags = SPP_HB_ENABLE |
4059 SPP_PMTUD_ENABLE |
4060 SPP_SACKDELAY_ENABLE;
4061
4062
4063
4064
4065 sp->disable_fragments = 0;
4066
4067
4068 sp->nodelay = 0;
4069
4070 sp->recvrcvinfo = 0;
4071 sp->recvnxtinfo = 0;
4072
4073
4074 sp->v4mapped = 1;
4075
4076
4077
4078
4079
4080
4081 sp->autoclose = 0;
4082
4083
4084 sp->user_frag = 0;
4085
4086 sp->adaptation_ind = 0;
4087
4088 sp->pf = sctp_get_pf_specific(sk->sk_family);
4089
4090
4091 atomic_set(&sp->pd_mode, 0);
4092 skb_queue_head_init(&sp->pd_lobby);
4093 sp->frag_interleave = 0;
4094
4095
4096
4097
4098
4099 sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
4100 if (!sp->ep)
4101 return -ENOMEM;
4102
4103 sp->hmac = NULL;
4104
4105 sk->sk_destruct = sctp_destruct_sock;
4106
4107 SCTP_DBG_OBJCNT_INC(sock);
4108
4109 local_bh_disable();
4110 percpu_counter_inc(&sctp_sockets_allocated);
4111 sock_prot_inuse_add(net, sk->sk_prot, 1);
4112
4113
4114
4115
4116 if (net->sctp.default_auto_asconf) {
4117 spin_lock(&sock_net(sk)->sctp.addr_wq_lock);
4118 list_add_tail(&sp->auto_asconf_list,
4119 &net->sctp.auto_asconf_splist);
4120 sp->do_auto_asconf = 1;
4121 spin_unlock(&sock_net(sk)->sctp.addr_wq_lock);
4122 } else {
4123 sp->do_auto_asconf = 0;
4124 }
4125
4126 local_bh_enable();
4127
4128 return 0;
4129}
4130
4131
4132
4133
4134static void sctp_destroy_sock(struct sock *sk)
4135{
4136 struct sctp_sock *sp;
4137
4138 pr_debug("%s: sk:%p\n", __func__, sk);
4139
4140
4141 sp = sctp_sk(sk);
4142
4143
4144
4145 if (sp->ep == NULL)
4146 return;
4147
4148 if (sp->do_auto_asconf) {
4149 sp->do_auto_asconf = 0;
4150 list_del(&sp->auto_asconf_list);
4151 }
4152 sctp_endpoint_free(sp->ep);
4153 local_bh_disable();
4154 percpu_counter_dec(&sctp_sockets_allocated);
4155 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
4156 local_bh_enable();
4157}
4158
4159
4160static void sctp_destruct_sock(struct sock *sk)
4161{
4162 struct sctp_sock *sp = sctp_sk(sk);
4163
4164
4165 crypto_free_shash(sp->hmac);
4166
4167 inet_sock_destruct(sk);
4168}
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186static void sctp_shutdown(struct sock *sk, int how)
4187{
4188 struct net *net = sock_net(sk);
4189 struct sctp_endpoint *ep;
4190 struct sctp_association *asoc;
4191
4192 if (!sctp_style(sk, TCP))
4193 return;
4194
4195 if (how & SEND_SHUTDOWN) {
4196 ep = sctp_sk(sk)->ep;
4197 if (!list_empty(&ep->asocs)) {
4198 asoc = list_entry(ep->asocs.next,
4199 struct sctp_association, asocs);
4200 sctp_primitive_SHUTDOWN(net, asoc, NULL);
4201 }
4202 }
4203}
4204
4205
4206
4207
4208
4209
4210
4211
4212static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
4213 char __user *optval,
4214 int __user *optlen)
4215{
4216 struct sctp_status status;
4217 struct sctp_association *asoc = NULL;
4218 struct sctp_transport *transport;
4219 sctp_assoc_t associd;
4220 int retval = 0;
4221
4222 if (len < sizeof(status)) {
4223 retval = -EINVAL;
4224 goto out;
4225 }
4226
4227 len = sizeof(status);
4228 if (copy_from_user(&status, optval, len)) {
4229 retval = -EFAULT;
4230 goto out;
4231 }
4232
4233 associd = status.sstat_assoc_id;
4234 asoc = sctp_id2assoc(sk, associd);
4235 if (!asoc) {
4236 retval = -EINVAL;
4237 goto out;
4238 }
4239
4240 transport = asoc->peer.primary_path;
4241
4242 status.sstat_assoc_id = sctp_assoc2id(asoc);
4243 status.sstat_state = sctp_assoc_to_state(asoc);
4244 status.sstat_rwnd = asoc->peer.rwnd;
4245 status.sstat_unackdata = asoc->unack_data;
4246
4247 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
4248 status.sstat_instrms = asoc->c.sinit_max_instreams;
4249 status.sstat_outstrms = asoc->c.sinit_num_ostreams;
4250 status.sstat_fragmentation_point = asoc->frag_point;
4251 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
4252 memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
4253 transport->af_specific->sockaddr_len);
4254
4255 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
4256 (union sctp_addr *)&status.sstat_primary.spinfo_address);
4257 status.sstat_primary.spinfo_state = transport->state;
4258 status.sstat_primary.spinfo_cwnd = transport->cwnd;
4259 status.sstat_primary.spinfo_srtt = transport->srtt;
4260 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
4261 status.sstat_primary.spinfo_mtu = transport->pathmtu;
4262
4263 if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
4264 status.sstat_primary.spinfo_state = SCTP_ACTIVE;
4265
4266 if (put_user(len, optlen)) {
4267 retval = -EFAULT;
4268 goto out;
4269 }
4270
4271 pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
4272 __func__, len, status.sstat_state, status.sstat_rwnd,
4273 status.sstat_assoc_id);
4274
4275 if (copy_to_user(optval, &status, len)) {
4276 retval = -EFAULT;
4277 goto out;
4278 }
4279
4280out:
4281 return retval;
4282}
4283
4284
4285
4286
4287
4288
4289
4290
4291
4292static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
4293 char __user *optval,
4294 int __user *optlen)
4295{
4296 struct sctp_paddrinfo pinfo;
4297 struct sctp_transport *transport;
4298 int retval = 0;
4299
4300 if (len < sizeof(pinfo)) {
4301 retval = -EINVAL;
4302 goto out;
4303 }
4304
4305 len = sizeof(pinfo);
4306 if (copy_from_user(&pinfo, optval, len)) {
4307 retval = -EFAULT;
4308 goto out;
4309 }
4310
4311 transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
4312 pinfo.spinfo_assoc_id);
4313 if (!transport)
4314 return -EINVAL;
4315
4316 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
4317 pinfo.spinfo_state = transport->state;
4318 pinfo.spinfo_cwnd = transport->cwnd;
4319 pinfo.spinfo_srtt = transport->srtt;
4320 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
4321 pinfo.spinfo_mtu = transport->pathmtu;
4322
4323 if (pinfo.spinfo_state == SCTP_UNKNOWN)
4324 pinfo.spinfo_state = SCTP_ACTIVE;
4325
4326 if (put_user(len, optlen)) {
4327 retval = -EFAULT;
4328 goto out;
4329 }
4330
4331 if (copy_to_user(optval, &pinfo, len)) {
4332 retval = -EFAULT;
4333 goto out;
4334 }
4335
4336out:
4337 return retval;
4338}
4339
4340
4341
4342
4343
4344
4345
4346
4347static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
4348 char __user *optval, int __user *optlen)
4349{
4350 int val;
4351
4352 if (len < sizeof(int))
4353 return -EINVAL;
4354
4355 len = sizeof(int);
4356 val = (sctp_sk(sk)->disable_fragments == 1);
4357 if (put_user(len, optlen))
4358 return -EFAULT;
4359 if (copy_to_user(optval, &val, len))
4360 return -EFAULT;
4361 return 0;
4362}
4363
4364
4365
4366
4367
4368
4369static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
4370 int __user *optlen)
4371{
4372 if (len <= 0)
4373 return -EINVAL;
4374 if (len > sizeof(struct sctp_event_subscribe))
4375 len = sizeof(struct sctp_event_subscribe);
4376 if (put_user(len, optlen))
4377 return -EFAULT;
4378 if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))
4379 return -EFAULT;
4380 return 0;
4381}
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
4395{
4396
4397 if (sctp_style(sk, TCP))
4398 return -EOPNOTSUPP;
4399 if (len < sizeof(int))
4400 return -EINVAL;
4401 len = sizeof(int);
4402 if (put_user(len, optlen))
4403 return -EFAULT;
4404 if (copy_to_user(optval, &sctp_sk(sk)->autoclose, sizeof(int)))
4405 return -EFAULT;
4406 return 0;
4407}
4408
4409
4410int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp)
4411{
4412 struct sctp_association *asoc = sctp_id2assoc(sk, id);
4413 struct sctp_sock *sp = sctp_sk(sk);
4414 struct socket *sock;
4415 int err = 0;
4416
4417 if (!asoc)
4418 return -EINVAL;
4419
4420
4421
4422
4423 if (!sctp_style(sk, UDP))
4424 return -EINVAL;
4425
4426
4427 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
4428 if (err < 0)
4429 return err;
4430
4431 sctp_copy_sock(sock->sk, sk, asoc);
4432
4433
4434
4435
4436 sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sk);
4437
4438
4439
4440
4441 sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
4442
4443 *sockp = sock;
4444
4445 return err;
4446}
4447EXPORT_SYMBOL(sctp_do_peeloff);
4448
4449static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
4450{
4451 sctp_peeloff_arg_t peeloff;
4452 struct socket *newsock;
4453 struct file *newfile;
4454 int retval = 0;
4455
4456 if (len < sizeof(sctp_peeloff_arg_t))
4457 return -EINVAL;
4458 len = sizeof(sctp_peeloff_arg_t);
4459 if (copy_from_user(&peeloff, optval, len))
4460 return -EFAULT;
4461
4462 retval = sctp_do_peeloff(sk, peeloff.associd, &newsock);
4463 if (retval < 0)
4464 goto out;
4465
4466
4467 retval = get_unused_fd_flags(0);
4468 if (retval < 0) {
4469 sock_release(newsock);
4470 goto out;
4471 }
4472
4473 newfile = sock_alloc_file(newsock, 0, NULL);
4474 if (IS_ERR(newfile)) {
4475 put_unused_fd(retval);
4476 sock_release(newsock);
4477 return PTR_ERR(newfile);
4478 }
4479
4480 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__, sk, newsock->sk,
4481 retval);
4482
4483
4484 if (put_user(len, optlen)) {
4485 fput(newfile);
4486 put_unused_fd(retval);
4487 return -EFAULT;
4488 }
4489 peeloff.sd = retval;
4490 if (copy_to_user(optval, &peeloff, len)) {
4491 fput(newfile);
4492 put_unused_fd(retval);
4493 return -EFAULT;
4494 }
4495 fd_install(retval, newfile);
4496out:
4497 return retval;
4498}
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
4594 char __user *optval, int __user *optlen)
4595{
4596 struct sctp_paddrparams params;
4597 struct sctp_transport *trans = NULL;
4598 struct sctp_association *asoc = NULL;
4599 struct sctp_sock *sp = sctp_sk(sk);
4600
4601 if (len < sizeof(struct sctp_paddrparams))
4602 return -EINVAL;
4603 len = sizeof(struct sctp_paddrparams);
4604 if (copy_from_user(¶ms, optval, len))
4605 return -EFAULT;
4606
4607
4608
4609
4610 if (!sctp_is_any(sk, (union sctp_addr *)¶ms.spp_address)) {
4611 trans = sctp_addr_id2transport(sk, ¶ms.spp_address,
4612 params.spp_assoc_id);
4613 if (!trans) {
4614 pr_debug("%s: failed no transport\n", __func__);
4615 return -EINVAL;
4616 }
4617 }
4618
4619
4620
4621
4622
4623 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
4624 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {
4625 pr_debug("%s: failed no association\n", __func__);
4626 return -EINVAL;
4627 }
4628
4629 if (trans) {
4630
4631 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
4632 params.spp_pathmtu = trans->pathmtu;
4633 params.spp_pathmaxrxt = trans->pathmaxrxt;
4634 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
4635
4636
4637 params.spp_flags = trans->param_flags;
4638 } else if (asoc) {
4639
4640 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
4641 params.spp_pathmtu = asoc->pathmtu;
4642 params.spp_pathmaxrxt = asoc->pathmaxrxt;
4643 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
4644
4645
4646 params.spp_flags = asoc->param_flags;
4647 } else {
4648
4649 params.spp_hbinterval = sp->hbinterval;
4650 params.spp_pathmtu = sp->pathmtu;
4651 params.spp_sackdelay = sp->sackdelay;
4652 params.spp_pathmaxrxt = sp->pathmaxrxt;
4653
4654
4655 params.spp_flags = sp->param_flags;
4656 }
4657
4658 if (copy_to_user(optval, ¶ms, len))
4659 return -EFAULT;
4660
4661 if (put_user(len, optlen))
4662 return -EFAULT;
4663
4664 return 0;
4665}
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702static int sctp_getsockopt_delayed_ack(struct sock *sk, int len,
4703 char __user *optval,
4704 int __user *optlen)
4705{
4706 struct sctp_sack_info params;
4707 struct sctp_association *asoc = NULL;
4708 struct sctp_sock *sp = sctp_sk(sk);
4709
4710 if (len >= sizeof(struct sctp_sack_info)) {
4711 len = sizeof(struct sctp_sack_info);
4712
4713 if (copy_from_user(¶ms, optval, len))
4714 return -EFAULT;
4715 } else if (len == sizeof(struct sctp_assoc_value)) {
4716 pr_warn_ratelimited(DEPRECATED
4717 "%s (pid %d) "
4718 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
4719 "Use struct sctp_sack_info instead\n",
4720 current->comm, task_pid_nr(current));
4721 if (copy_from_user(¶ms, optval, len))
4722 return -EFAULT;
4723 } else
4724 return -EINVAL;
4725
4726
4727
4728
4729
4730 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
4731 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
4732 return -EINVAL;
4733
4734 if (asoc) {
4735
4736 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
4737 params.sack_delay = jiffies_to_msecs(
4738 asoc->sackdelay);
4739 params.sack_freq = asoc->sackfreq;
4740
4741 } else {
4742 params.sack_delay = 0;
4743 params.sack_freq = 1;
4744 }
4745 } else {
4746
4747 if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
4748 params.sack_delay = sp->sackdelay;
4749 params.sack_freq = sp->sackfreq;
4750 } else {
4751 params.sack_delay = 0;
4752 params.sack_freq = 1;
4753 }
4754 }
4755
4756 if (copy_to_user(optval, ¶ms, len))
4757 return -EFAULT;
4758
4759 if (put_user(len, optlen))
4760 return -EFAULT;
4761
4762 return 0;
4763}
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
4777{
4778 if (len < sizeof(struct sctp_initmsg))
4779 return -EINVAL;
4780 len = sizeof(struct sctp_initmsg);
4781 if (put_user(len, optlen))
4782 return -EFAULT;
4783 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
4784 return -EFAULT;
4785 return 0;
4786}
4787
4788
4789static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
4790 char __user *optval, int __user *optlen)
4791{
4792 struct sctp_association *asoc;
4793 int cnt = 0;
4794 struct sctp_getaddrs getaddrs;
4795 struct sctp_transport *from;
4796 void __user *to;
4797 union sctp_addr temp;
4798 struct sctp_sock *sp = sctp_sk(sk);
4799 int addrlen;
4800 size_t space_left;
4801 int bytes_copied;
4802
4803 if (len < sizeof(struct sctp_getaddrs))
4804 return -EINVAL;
4805
4806 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
4807 return -EFAULT;
4808
4809
4810 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4811 if (!asoc)
4812 return -EINVAL;
4813
4814 to = optval + offsetof(struct sctp_getaddrs, addrs);
4815 space_left = len - offsetof(struct sctp_getaddrs, addrs);
4816
4817 list_for_each_entry(from, &asoc->peer.transport_addr_list,
4818 transports) {
4819 memcpy(&temp, &from->ipaddr, sizeof(temp));
4820 addrlen = sctp_get_pf_specific(sk->sk_family)
4821 ->addr_to_user(sp, &temp);
4822 if (space_left < addrlen)
4823 return -ENOMEM;
4824 if (copy_to_user(to, &temp, addrlen))
4825 return -EFAULT;
4826 to += addrlen;
4827 cnt++;
4828 space_left -= addrlen;
4829 }
4830
4831 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
4832 return -EFAULT;
4833 bytes_copied = ((char __user *)to) - optval;
4834 if (put_user(bytes_copied, optlen))
4835 return -EFAULT;
4836
4837 return 0;
4838}
4839
4840static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
4841 size_t space_left, int *bytes_copied)
4842{
4843 struct sctp_sockaddr_entry *addr;
4844 union sctp_addr temp;
4845 int cnt = 0;
4846 int addrlen;
4847 struct net *net = sock_net(sk);
4848
4849 rcu_read_lock();
4850 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
4851 if (!addr->valid)
4852 continue;
4853
4854 if ((PF_INET == sk->sk_family) &&
4855 (AF_INET6 == addr->a.sa.sa_family))
4856 continue;
4857 if ((PF_INET6 == sk->sk_family) &&
4858 inet_v6_ipv6only(sk) &&
4859 (AF_INET == addr->a.sa.sa_family))
4860 continue;
4861 memcpy(&temp, &addr->a, sizeof(temp));
4862 if (!temp.v4.sin_port)
4863 temp.v4.sin_port = htons(port);
4864
4865 addrlen = sctp_get_pf_specific(sk->sk_family)
4866 ->addr_to_user(sctp_sk(sk), &temp);
4867
4868 if (space_left < addrlen) {
4869 cnt = -ENOMEM;
4870 break;
4871 }
4872 memcpy(to, &temp, addrlen);
4873
4874 to += addrlen;
4875 cnt++;
4876 space_left -= addrlen;
4877 *bytes_copied += addrlen;
4878 }
4879 rcu_read_unlock();
4880
4881 return cnt;
4882}
4883
4884
4885static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
4886 char __user *optval, int __user *optlen)
4887{
4888 struct sctp_bind_addr *bp;
4889 struct sctp_association *asoc;
4890 int cnt = 0;
4891 struct sctp_getaddrs getaddrs;
4892 struct sctp_sockaddr_entry *addr;
4893 void __user *to;
4894 union sctp_addr temp;
4895 struct sctp_sock *sp = sctp_sk(sk);
4896 int addrlen;
4897 int err = 0;
4898 size_t space_left;
4899 int bytes_copied = 0;
4900 void *addrs;
4901 void *buf;
4902
4903 if (len < sizeof(struct sctp_getaddrs))
4904 return -EINVAL;
4905
4906 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
4907 return -EFAULT;
4908
4909
4910
4911
4912
4913
4914
4915 if (0 == getaddrs.assoc_id) {
4916 bp = &sctp_sk(sk)->ep->base.bind_addr;
4917 } else {
4918 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4919 if (!asoc)
4920 return -EINVAL;
4921 bp = &asoc->base.bind_addr;
4922 }
4923
4924 to = optval + offsetof(struct sctp_getaddrs, addrs);
4925 space_left = len - offsetof(struct sctp_getaddrs, addrs);
4926
4927 addrs = kmalloc(space_left, GFP_USER | __GFP_NOWARN);
4928 if (!addrs)
4929 return -ENOMEM;
4930
4931
4932
4933
4934 if (sctp_list_single_entry(&bp->address_list)) {
4935 addr = list_entry(bp->address_list.next,
4936 struct sctp_sockaddr_entry, list);
4937 if (sctp_is_any(sk, &addr->a)) {
4938 cnt = sctp_copy_laddrs(sk, bp->port, addrs,
4939 space_left, &bytes_copied);
4940 if (cnt < 0) {
4941 err = cnt;
4942 goto out;
4943 }
4944 goto copy_getaddrs;
4945 }
4946 }
4947
4948 buf = addrs;
4949
4950
4951
4952
4953 list_for_each_entry(addr, &bp->address_list, list) {
4954 memcpy(&temp, &addr->a, sizeof(temp));
4955 addrlen = sctp_get_pf_specific(sk->sk_family)
4956 ->addr_to_user(sp, &temp);
4957 if (space_left < addrlen) {
4958 err = -ENOMEM;
4959 goto out;
4960 }
4961 memcpy(buf, &temp, addrlen);
4962 buf += addrlen;
4963 bytes_copied += addrlen;
4964 cnt++;
4965 space_left -= addrlen;
4966 }
4967
4968copy_getaddrs:
4969 if (copy_to_user(to, addrs, bytes_copied)) {
4970 err = -EFAULT;
4971 goto out;
4972 }
4973 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
4974 err = -EFAULT;
4975 goto out;
4976 }
4977 if (put_user(bytes_copied, optlen))
4978 err = -EFAULT;
4979out:
4980 kfree(addrs);
4981 return err;
4982}
4983
4984
4985
4986
4987
4988
4989
4990static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
4991 char __user *optval, int __user *optlen)
4992{
4993 struct sctp_prim prim;
4994 struct sctp_association *asoc;
4995 struct sctp_sock *sp = sctp_sk(sk);
4996
4997 if (len < sizeof(struct sctp_prim))
4998 return -EINVAL;
4999
5000 len = sizeof(struct sctp_prim);
5001
5002 if (copy_from_user(&prim, optval, len))
5003 return -EFAULT;
5004
5005 asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
5006 if (!asoc)
5007 return -EINVAL;
5008
5009 if (!asoc->peer.primary_path)
5010 return -ENOTCONN;
5011
5012 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
5013 asoc->peer.primary_path->af_specific->sockaddr_len);
5014
5015 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sp,
5016 (union sctp_addr *)&prim.ssp_addr);
5017
5018 if (put_user(len, optlen))
5019 return -EFAULT;
5020 if (copy_to_user(optval, &prim, len))
5021 return -EFAULT;
5022
5023 return 0;
5024}
5025
5026
5027
5028
5029
5030
5031
5032static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len,
5033 char __user *optval, int __user *optlen)
5034{
5035 struct sctp_setadaptation adaptation;
5036
5037 if (len < sizeof(struct sctp_setadaptation))
5038 return -EINVAL;
5039
5040 len = sizeof(struct sctp_setadaptation);
5041
5042 adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
5043
5044 if (put_user(len, optlen))
5045 return -EFAULT;
5046 if (copy_to_user(optval, &adaptation, len))
5047 return -EFAULT;
5048
5049 return 0;
5050}
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071static int sctp_getsockopt_default_send_param(struct sock *sk,
5072 int len, char __user *optval,
5073 int __user *optlen)
5074{
5075 struct sctp_sock *sp = sctp_sk(sk);
5076 struct sctp_association *asoc;
5077 struct sctp_sndrcvinfo info;
5078
5079 if (len < sizeof(info))
5080 return -EINVAL;
5081
5082 len = sizeof(info);
5083
5084 if (copy_from_user(&info, optval, len))
5085 return -EFAULT;
5086
5087 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
5088 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
5089 return -EINVAL;
5090 if (asoc) {
5091 info.sinfo_stream = asoc->default_stream;
5092 info.sinfo_flags = asoc->default_flags;
5093 info.sinfo_ppid = asoc->default_ppid;
5094 info.sinfo_context = asoc->default_context;
5095 info.sinfo_timetolive = asoc->default_timetolive;
5096 } else {
5097 info.sinfo_stream = sp->default_stream;
5098 info.sinfo_flags = sp->default_flags;
5099 info.sinfo_ppid = sp->default_ppid;
5100 info.sinfo_context = sp->default_context;
5101 info.sinfo_timetolive = sp->default_timetolive;
5102 }
5103
5104 if (put_user(len, optlen))
5105 return -EFAULT;
5106 if (copy_to_user(optval, &info, len))
5107 return -EFAULT;
5108
5109 return 0;
5110}
5111
5112
5113
5114
5115static int sctp_getsockopt_default_sndinfo(struct sock *sk, int len,
5116 char __user *optval,
5117 int __user *optlen)
5118{
5119 struct sctp_sock *sp = sctp_sk(sk);
5120 struct sctp_association *asoc;
5121 struct sctp_sndinfo info;
5122
5123 if (len < sizeof(info))
5124 return -EINVAL;
5125
5126 len = sizeof(info);
5127
5128 if (copy_from_user(&info, optval, len))
5129 return -EFAULT;
5130
5131 asoc = sctp_id2assoc(sk, info.snd_assoc_id);
5132 if (!asoc && info.snd_assoc_id && sctp_style(sk, UDP))
5133 return -EINVAL;
5134 if (asoc) {
5135 info.snd_sid = asoc->default_stream;
5136 info.snd_flags = asoc->default_flags;
5137 info.snd_ppid = asoc->default_ppid;
5138 info.snd_context = asoc->default_context;
5139 } else {
5140 info.snd_sid = sp->default_stream;
5141 info.snd_flags = sp->default_flags;
5142 info.snd_ppid = sp->default_ppid;
5143 info.snd_context = sp->default_context;
5144 }
5145
5146 if (put_user(len, optlen))
5147 return -EFAULT;
5148 if (copy_to_user(optval, &info, len))
5149 return -EFAULT;
5150
5151 return 0;
5152}
5153
5154
5155
5156
5157
5158
5159
5160
5161
5162
5163
5164static int sctp_getsockopt_nodelay(struct sock *sk, int len,
5165 char __user *optval, int __user *optlen)
5166{
5167 int val;
5168
5169 if (len < sizeof(int))
5170 return -EINVAL;
5171
5172 len = sizeof(int);
5173 val = (sctp_sk(sk)->nodelay == 1);
5174 if (put_user(len, optlen))
5175 return -EFAULT;
5176 if (copy_to_user(optval, &val, len))
5177 return -EFAULT;
5178 return 0;
5179}
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
5194 char __user *optval,
5195 int __user *optlen) {
5196 struct sctp_rtoinfo rtoinfo;
5197 struct sctp_association *asoc;
5198
5199 if (len < sizeof (struct sctp_rtoinfo))
5200 return -EINVAL;
5201
5202 len = sizeof(struct sctp_rtoinfo);
5203
5204 if (copy_from_user(&rtoinfo, optval, len))
5205 return -EFAULT;
5206
5207 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
5208
5209 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
5210 return -EINVAL;
5211
5212
5213 if (asoc) {
5214 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
5215 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
5216 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
5217 } else {
5218
5219 struct sctp_sock *sp = sctp_sk(sk);
5220
5221 rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
5222 rtoinfo.srto_max = sp->rtoinfo.srto_max;
5223 rtoinfo.srto_min = sp->rtoinfo.srto_min;
5224 }
5225
5226 if (put_user(len, optlen))
5227 return -EFAULT;
5228
5229 if (copy_to_user(optval, &rtoinfo, len))
5230 return -EFAULT;
5231
5232 return 0;
5233}
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246static int sctp_getsockopt_associnfo(struct sock *sk, int len,
5247 char __user *optval,
5248 int __user *optlen)
5249{
5250
5251 struct sctp_assocparams assocparams;
5252 struct sctp_association *asoc;
5253 struct list_head *pos;
5254 int cnt = 0;
5255
5256 if (len < sizeof (struct sctp_assocparams))
5257 return -EINVAL;
5258
5259 len = sizeof(struct sctp_assocparams);
5260
5261 if (copy_from_user(&assocparams, optval, len))
5262 return -EFAULT;
5263
5264 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
5265
5266 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
5267 return -EINVAL;
5268
5269
5270 if (asoc) {
5271 assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
5272 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
5273 assocparams.sasoc_local_rwnd = asoc->a_rwnd;
5274 assocparams.sasoc_cookie_life = ktime_to_ms(asoc->cookie_life);
5275
5276 list_for_each(pos, &asoc->peer.transport_addr_list) {
5277 cnt++;
5278 }
5279
5280 assocparams.sasoc_number_peer_destinations = cnt;
5281 } else {
5282
5283 struct sctp_sock *sp = sctp_sk(sk);
5284
5285 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
5286 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
5287 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
5288 assocparams.sasoc_cookie_life =
5289 sp->assocparams.sasoc_cookie_life;
5290 assocparams.sasoc_number_peer_destinations =
5291 sp->assocparams.
5292 sasoc_number_peer_destinations;
5293 }
5294
5295 if (put_user(len, optlen))
5296 return -EFAULT;
5297
5298 if (copy_to_user(optval, &assocparams, len))
5299 return -EFAULT;
5300
5301 return 0;
5302}
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
5315 char __user *optval, int __user *optlen)
5316{
5317 int val;
5318 struct sctp_sock *sp = sctp_sk(sk);
5319
5320 if (len < sizeof(int))
5321 return -EINVAL;
5322
5323 len = sizeof(int);
5324 val = sp->v4mapped;
5325 if (put_user(len, optlen))
5326 return -EFAULT;
5327 if (copy_to_user(optval, &val, len))
5328 return -EFAULT;
5329
5330 return 0;
5331}
5332
5333
5334
5335
5336
5337static int sctp_getsockopt_context(struct sock *sk, int len,
5338 char __user *optval, int __user *optlen)
5339{
5340 struct sctp_assoc_value params;
5341 struct sctp_sock *sp;
5342 struct sctp_association *asoc;
5343
5344 if (len < sizeof(struct sctp_assoc_value))
5345 return -EINVAL;
5346
5347 len = sizeof(struct sctp_assoc_value);
5348
5349 if (copy_from_user(¶ms, optval, len))
5350 return -EFAULT;
5351
5352 sp = sctp_sk(sk);
5353
5354 if (params.assoc_id != 0) {
5355 asoc = sctp_id2assoc(sk, params.assoc_id);
5356 if (!asoc)
5357 return -EINVAL;
5358 params.assoc_value = asoc->default_rcv_context;
5359 } else {
5360 params.assoc_value = sp->default_rcv_context;
5361 }
5362
5363 if (put_user(len, optlen))
5364 return -EFAULT;
5365 if (copy_to_user(optval, ¶ms, len))
5366 return -EFAULT;
5367
5368 return 0;
5369}
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398static int sctp_getsockopt_maxseg(struct sock *sk, int len,
5399 char __user *optval, int __user *optlen)
5400{
5401 struct sctp_assoc_value params;
5402 struct sctp_association *asoc;
5403
5404 if (len == sizeof(int)) {
5405 pr_warn_ratelimited(DEPRECATED
5406 "%s (pid %d) "
5407 "Use of int in maxseg socket option.\n"
5408 "Use struct sctp_assoc_value instead\n",
5409 current->comm, task_pid_nr(current));
5410 params.assoc_id = 0;
5411 } else if (len >= sizeof(struct sctp_assoc_value)) {
5412 len = sizeof(struct sctp_assoc_value);
5413 if (copy_from_user(¶ms, optval, sizeof(params)))
5414 return -EFAULT;
5415 } else
5416 return -EINVAL;
5417
5418 asoc = sctp_id2assoc(sk, params.assoc_id);
5419 if (!asoc && params.assoc_id && sctp_style(sk, UDP))
5420 return -EINVAL;
5421
5422 if (asoc)
5423 params.assoc_value = asoc->frag_point;
5424 else
5425 params.assoc_value = sctp_sk(sk)->user_frag;
5426
5427 if (put_user(len, optlen))
5428 return -EFAULT;
5429 if (len == sizeof(int)) {
5430 if (copy_to_user(optval, ¶ms.assoc_value, len))
5431 return -EFAULT;
5432 } else {
5433 if (copy_to_user(optval, ¶ms, len))
5434 return -EFAULT;
5435 }
5436
5437 return 0;
5438}
5439
5440
5441
5442
5443
5444static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
5445 char __user *optval, int __user *optlen)
5446{
5447 int val;
5448
5449 if (len < sizeof(int))
5450 return -EINVAL;
5451
5452 len = sizeof(int);
5453
5454 val = sctp_sk(sk)->frag_interleave;
5455 if (put_user(len, optlen))
5456 return -EFAULT;
5457 if (copy_to_user(optval, &val, len))
5458 return -EFAULT;
5459
5460 return 0;
5461}
5462
5463
5464
5465
5466
5467static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
5468 char __user *optval,
5469 int __user *optlen)
5470{
5471 u32 val;
5472
5473 if (len < sizeof(u32))
5474 return -EINVAL;
5475
5476 len = sizeof(u32);
5477
5478 val = sctp_sk(sk)->pd_point;
5479 if (put_user(len, optlen))
5480 return -EFAULT;
5481 if (copy_to_user(optval, &val, len))
5482 return -EFAULT;
5483
5484 return 0;
5485}
5486
5487
5488
5489
5490
5491static int sctp_getsockopt_maxburst(struct sock *sk, int len,
5492 char __user *optval,
5493 int __user *optlen)
5494{
5495 struct sctp_assoc_value params;
5496 struct sctp_sock *sp;
5497 struct sctp_association *asoc;
5498
5499 if (len == sizeof(int)) {
5500 pr_warn_ratelimited(DEPRECATED
5501 "%s (pid %d) "
5502 "Use of int in max_burst socket option.\n"
5503 "Use struct sctp_assoc_value instead\n",
5504 current->comm, task_pid_nr(current));
5505 params.assoc_id = 0;
5506 } else if (len >= sizeof(struct sctp_assoc_value)) {
5507 len = sizeof(struct sctp_assoc_value);
5508 if (copy_from_user(¶ms, optval, len))
5509 return -EFAULT;
5510 } else
5511 return -EINVAL;
5512
5513 sp = sctp_sk(sk);
5514
5515 if (params.assoc_id != 0) {
5516 asoc = sctp_id2assoc(sk, params.assoc_id);
5517 if (!asoc)
5518 return -EINVAL;
5519 params.assoc_value = asoc->max_burst;
5520 } else
5521 params.assoc_value = sp->max_burst;
5522
5523 if (len == sizeof(int)) {
5524 if (copy_to_user(optval, ¶ms.assoc_value, len))
5525 return -EFAULT;
5526 } else {
5527 if (copy_to_user(optval, ¶ms, len))
5528 return -EFAULT;
5529 }
5530
5531 return 0;
5532
5533}
5534
5535static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
5536 char __user *optval, int __user *optlen)
5537{
5538 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
5539 struct sctp_hmacalgo __user *p = (void __user *)optval;
5540 struct sctp_hmac_algo_param *hmacs;
5541 __u16 data_len = 0;
5542 u32 num_idents;
5543 int i;
5544
5545 if (!ep->auth_enable)
5546 return -EACCES;
5547
5548 hmacs = ep->auth_hmacs_list;
5549 data_len = ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t);
5550
5551 if (len < sizeof(struct sctp_hmacalgo) + data_len)
5552 return -EINVAL;
5553
5554 len = sizeof(struct sctp_hmacalgo) + data_len;
5555 num_idents = data_len / sizeof(u16);
5556
5557 if (put_user(len, optlen))
5558 return -EFAULT;
5559 if (put_user(num_idents, &p->shmac_num_idents))
5560 return -EFAULT;
5561 for (i = 0; i < num_idents; i++) {
5562 __u16 hmacid = ntohs(hmacs->hmac_ids[i]);
5563
5564 if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
5565 return -EFAULT;
5566 }
5567 return 0;
5568}
5569
5570static int sctp_getsockopt_active_key(struct sock *sk, int len,
5571 char __user *optval, int __user *optlen)
5572{
5573 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
5574 struct sctp_authkeyid val;
5575 struct sctp_association *asoc;
5576
5577 if (!ep->auth_enable)
5578 return -EACCES;
5579
5580 if (len < sizeof(struct sctp_authkeyid))
5581 return -EINVAL;
5582 if (copy_from_user(&val, optval, sizeof(struct sctp_authkeyid)))
5583 return -EFAULT;
5584
5585 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
5586 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
5587 return -EINVAL;
5588
5589 if (asoc)
5590 val.scact_keynumber = asoc->active_key_id;
5591 else
5592 val.scact_keynumber = ep->active_key_id;
5593
5594 len = sizeof(struct sctp_authkeyid);
5595 if (put_user(len, optlen))
5596 return -EFAULT;
5597 if (copy_to_user(optval, &val, len))
5598 return -EFAULT;
5599
5600 return 0;
5601}
5602
5603static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
5604 char __user *optval, int __user *optlen)
5605{
5606 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
5607 struct sctp_authchunks __user *p = (void __user *)optval;
5608 struct sctp_authchunks val;
5609 struct sctp_association *asoc;
5610 struct sctp_chunks_param *ch;
5611 u32 num_chunks = 0;
5612 char __user *to;
5613
5614 if (!ep->auth_enable)
5615 return -EACCES;
5616
5617 if (len < sizeof(struct sctp_authchunks))
5618 return -EINVAL;
5619
5620 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
5621 return -EFAULT;
5622
5623 to = p->gauth_chunks;
5624 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
5625 if (!asoc)
5626 return -EINVAL;
5627
5628 ch = asoc->peer.peer_chunks;
5629 if (!ch)
5630 goto num;
5631
5632
5633 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
5634 if (len < num_chunks)
5635 return -EINVAL;
5636
5637 if (copy_to_user(to, ch->chunks, num_chunks))
5638 return -EFAULT;
5639num:
5640 len = sizeof(struct sctp_authchunks) + num_chunks;
5641 if (put_user(len, optlen))
5642 return -EFAULT;
5643 if (put_user(num_chunks, &p->gauth_number_of_chunks))
5644 return -EFAULT;
5645 return 0;
5646}
5647
5648static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
5649 char __user *optval, int __user *optlen)
5650{
5651 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
5652 struct sctp_authchunks __user *p = (void __user *)optval;
5653 struct sctp_authchunks val;
5654 struct sctp_association *asoc;
5655 struct sctp_chunks_param *ch;
5656 u32 num_chunks = 0;
5657 char __user *to;
5658
5659 if (!ep->auth_enable)
5660 return -EACCES;
5661
5662 if (len < sizeof(struct sctp_authchunks))
5663 return -EINVAL;
5664
5665 if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
5666 return -EFAULT;
5667
5668 to = p->gauth_chunks;
5669 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
5670 if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP))
5671 return -EINVAL;
5672
5673 if (asoc)
5674 ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
5675 else
5676 ch = ep->auth_chunk_list;
5677
5678 if (!ch)
5679 goto num;
5680
5681 num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
5682 if (len < sizeof(struct sctp_authchunks) + num_chunks)
5683 return -EINVAL;
5684
5685 if (copy_to_user(to, ch->chunks, num_chunks))
5686 return -EFAULT;
5687num:
5688 len = sizeof(struct sctp_authchunks) + num_chunks;
5689 if (put_user(len, optlen))
5690 return -EFAULT;
5691 if (put_user(num_chunks, &p->gauth_number_of_chunks))
5692 return -EFAULT;
5693
5694 return 0;
5695}
5696
5697
5698
5699
5700
5701
5702static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
5703 char __user *optval, int __user *optlen)
5704{
5705 struct sctp_sock *sp = sctp_sk(sk);
5706 struct sctp_association *asoc;
5707 u32 val = 0;
5708
5709 if (sctp_style(sk, TCP))
5710 return -EOPNOTSUPP;
5711
5712 if (len < sizeof(u32))
5713 return -EINVAL;
5714
5715 len = sizeof(u32);
5716
5717 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
5718 val++;
5719 }
5720
5721 if (put_user(len, optlen))
5722 return -EFAULT;
5723 if (copy_to_user(optval, &val, len))
5724 return -EFAULT;
5725
5726 return 0;
5727}
5728
5729
5730
5731
5732
5733static int sctp_getsockopt_auto_asconf(struct sock *sk, int len,
5734 char __user *optval, int __user *optlen)
5735{
5736 int val = 0;
5737
5738 if (len < sizeof(int))
5739 return -EINVAL;
5740
5741 len = sizeof(int);
5742 if (sctp_sk(sk)->do_auto_asconf && sctp_is_ep_boundall(sk))
5743 val = 1;
5744 if (put_user(len, optlen))
5745 return -EFAULT;
5746 if (copy_to_user(optval, &val, len))
5747 return -EFAULT;
5748 return 0;
5749}
5750
5751
5752
5753
5754
5755
5756
5757
5758static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
5759 char __user *optval, int __user *optlen)
5760{
5761 struct sctp_sock *sp = sctp_sk(sk);
5762 struct sctp_association *asoc;
5763 struct sctp_assoc_ids *ids;
5764 u32 num = 0;
5765
5766 if (sctp_style(sk, TCP))
5767 return -EOPNOTSUPP;
5768
5769 if (len < sizeof(struct sctp_assoc_ids))
5770 return -EINVAL;
5771
5772 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
5773 num++;
5774 }
5775
5776 if (len < sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num)
5777 return -EINVAL;
5778
5779 len = sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num;
5780
5781 ids = kmalloc(len, GFP_USER | __GFP_NOWARN);
5782 if (unlikely(!ids))
5783 return -ENOMEM;
5784
5785 ids->gaids_number_of_ids = num;
5786 num = 0;
5787 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
5788 ids->gaids_assoc_id[num++] = asoc->assoc_id;
5789 }
5790
5791 if (put_user(len, optlen) || copy_to_user(optval, ids, len)) {
5792 kfree(ids);
5793 return -EFAULT;
5794 }
5795
5796 kfree(ids);
5797 return 0;
5798}
5799
5800
5801
5802
5803
5804
5805
5806
5807static int sctp_getsockopt_paddr_thresholds(struct sock *sk,
5808 char __user *optval,
5809 int len,
5810 int __user *optlen)
5811{
5812 struct sctp_paddrthlds val;
5813 struct sctp_transport *trans;
5814 struct sctp_association *asoc;
5815
5816 if (len < sizeof(struct sctp_paddrthlds))
5817 return -EINVAL;
5818 len = sizeof(struct sctp_paddrthlds);
5819 if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval, len))
5820 return -EFAULT;
5821
5822 if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
5823 asoc = sctp_id2assoc(sk, val.spt_assoc_id);
5824 if (!asoc)
5825 return -ENOENT;
5826
5827 val.spt_pathpfthld = asoc->pf_retrans;
5828 val.spt_pathmaxrxt = asoc->pathmaxrxt;
5829 } else {
5830 trans = sctp_addr_id2transport(sk, &val.spt_address,
5831 val.spt_assoc_id);
5832 if (!trans)
5833 return -ENOENT;
5834
5835 val.spt_pathmaxrxt = trans->pathmaxrxt;
5836 val.spt_pathpfthld = trans->pf_retrans;
5837 }
5838
5839 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
5840 return -EFAULT;
5841
5842 return 0;
5843}
5844
5845
5846
5847
5848
5849
5850
5851static int sctp_getsockopt_assoc_stats(struct sock *sk, int len,
5852 char __user *optval,
5853 int __user *optlen)
5854{
5855 struct sctp_assoc_stats sas;
5856 struct sctp_association *asoc = NULL;
5857
5858
5859 if (len < sizeof(sctp_assoc_t))
5860 return -EINVAL;
5861
5862
5863 len = min_t(size_t, len, sizeof(sas));
5864
5865 if (copy_from_user(&sas, optval, len))
5866 return -EFAULT;
5867
5868 asoc = sctp_id2assoc(sk, sas.sas_assoc_id);
5869 if (!asoc)
5870 return -EINVAL;
5871
5872 sas.sas_rtxchunks = asoc->stats.rtxchunks;
5873 sas.sas_gapcnt = asoc->stats.gapcnt;
5874 sas.sas_outofseqtsns = asoc->stats.outofseqtsns;
5875 sas.sas_osacks = asoc->stats.osacks;
5876 sas.sas_isacks = asoc->stats.isacks;
5877 sas.sas_octrlchunks = asoc->stats.octrlchunks;
5878 sas.sas_ictrlchunks = asoc->stats.ictrlchunks;
5879 sas.sas_oodchunks = asoc->stats.oodchunks;
5880 sas.sas_iodchunks = asoc->stats.iodchunks;
5881 sas.sas_ouodchunks = asoc->stats.ouodchunks;
5882 sas.sas_iuodchunks = asoc->stats.iuodchunks;
5883 sas.sas_idupchunks = asoc->stats.idupchunks;
5884 sas.sas_opackets = asoc->stats.opackets;
5885 sas.sas_ipackets = asoc->stats.ipackets;
5886
5887
5888
5889
5890
5891 sas.sas_maxrto = asoc->stats.max_obs_rto;
5892 memcpy(&sas.sas_obs_rto_ipaddr, &asoc->stats.obs_rto_ipaddr,
5893 sizeof(struct sockaddr_storage));
5894
5895
5896 asoc->stats.max_obs_rto = asoc->rto_min;
5897
5898 if (put_user(len, optlen))
5899 return -EFAULT;
5900
5901 pr_debug("%s: len:%d, assoc_id:%d\n", __func__, len, sas.sas_assoc_id);
5902
5903 if (copy_to_user(optval, &sas, len))
5904 return -EFAULT;
5905
5906 return 0;
5907}
5908
5909static int sctp_getsockopt_recvrcvinfo(struct sock *sk, int len,
5910 char __user *optval,
5911 int __user *optlen)
5912{
5913 int val = 0;
5914
5915 if (len < sizeof(int))
5916 return -EINVAL;
5917
5918 len = sizeof(int);
5919 if (sctp_sk(sk)->recvrcvinfo)
5920 val = 1;
5921 if (put_user(len, optlen))
5922 return -EFAULT;
5923 if (copy_to_user(optval, &val, len))
5924 return -EFAULT;
5925
5926 return 0;
5927}
5928
5929static int sctp_getsockopt_recvnxtinfo(struct sock *sk, int len,
5930 char __user *optval,
5931 int __user *optlen)
5932{
5933 int val = 0;
5934
5935 if (len < sizeof(int))
5936 return -EINVAL;
5937
5938 len = sizeof(int);
5939 if (sctp_sk(sk)->recvnxtinfo)
5940 val = 1;
5941 if (put_user(len, optlen))
5942 return -EFAULT;
5943 if (copy_to_user(optval, &val, len))
5944 return -EFAULT;
5945
5946 return 0;
5947}
5948
5949static int sctp_getsockopt(struct sock *sk, int level, int optname,
5950 char __user *optval, int __user *optlen)
5951{
5952 int retval = 0;
5953 int len;
5954
5955 pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
5956
5957
5958
5959
5960
5961
5962
5963 if (level != SOL_SCTP) {
5964 struct sctp_af *af = sctp_sk(sk)->pf->af;
5965
5966 retval = af->getsockopt(sk, level, optname, optval, optlen);
5967 return retval;
5968 }
5969
5970 if (get_user(len, optlen))
5971 return -EFAULT;
5972
5973 lock_sock(sk);
5974
5975 switch (optname) {
5976 case SCTP_STATUS:
5977 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
5978 break;
5979 case SCTP_DISABLE_FRAGMENTS:
5980 retval = sctp_getsockopt_disable_fragments(sk, len, optval,
5981 optlen);
5982 break;
5983 case SCTP_EVENTS:
5984 retval = sctp_getsockopt_events(sk, len, optval, optlen);
5985 break;
5986 case SCTP_AUTOCLOSE:
5987 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
5988 break;
5989 case SCTP_SOCKOPT_PEELOFF:
5990 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
5991 break;
5992 case SCTP_PEER_ADDR_PARAMS:
5993 retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
5994 optlen);
5995 break;
5996 case SCTP_DELAYED_SACK:
5997 retval = sctp_getsockopt_delayed_ack(sk, len, optval,
5998 optlen);
5999 break;
6000 case SCTP_INITMSG:
6001 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
6002 break;
6003 case SCTP_GET_PEER_ADDRS:
6004 retval = sctp_getsockopt_peer_addrs(sk, len, optval,
6005 optlen);
6006 break;
6007 case SCTP_GET_LOCAL_ADDRS:
6008 retval = sctp_getsockopt_local_addrs(sk, len, optval,
6009 optlen);
6010 break;
6011 case SCTP_SOCKOPT_CONNECTX3:
6012 retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
6013 break;
6014 case SCTP_DEFAULT_SEND_PARAM:
6015 retval = sctp_getsockopt_default_send_param(sk, len,
6016 optval, optlen);
6017 break;
6018 case SCTP_DEFAULT_SNDINFO:
6019 retval = sctp_getsockopt_default_sndinfo(sk, len,
6020 optval, optlen);
6021 break;
6022 case SCTP_PRIMARY_ADDR:
6023 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
6024 break;
6025 case SCTP_NODELAY:
6026 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
6027 break;
6028 case SCTP_RTOINFO:
6029 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
6030 break;
6031 case SCTP_ASSOCINFO:
6032 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
6033 break;
6034 case SCTP_I_WANT_MAPPED_V4_ADDR:
6035 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
6036 break;
6037 case SCTP_MAXSEG:
6038 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
6039 break;
6040 case SCTP_GET_PEER_ADDR_INFO:
6041 retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
6042 optlen);
6043 break;
6044 case SCTP_ADAPTATION_LAYER:
6045 retval = sctp_getsockopt_adaptation_layer(sk, len, optval,
6046 optlen);
6047 break;
6048 case SCTP_CONTEXT:
6049 retval = sctp_getsockopt_context(sk, len, optval, optlen);
6050 break;
6051 case SCTP_FRAGMENT_INTERLEAVE:
6052 retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
6053 optlen);
6054 break;
6055 case SCTP_PARTIAL_DELIVERY_POINT:
6056 retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
6057 optlen);
6058 break;
6059 case SCTP_MAX_BURST:
6060 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
6061 break;
6062 case SCTP_AUTH_KEY:
6063 case SCTP_AUTH_CHUNK:
6064 case SCTP_AUTH_DELETE_KEY:
6065 retval = -EOPNOTSUPP;
6066 break;
6067 case SCTP_HMAC_IDENT:
6068 retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
6069 break;
6070 case SCTP_AUTH_ACTIVE_KEY:
6071 retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
6072 break;
6073 case SCTP_PEER_AUTH_CHUNKS:
6074 retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
6075 optlen);
6076 break;
6077 case SCTP_LOCAL_AUTH_CHUNKS:
6078 retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
6079 optlen);
6080 break;
6081 case SCTP_GET_ASSOC_NUMBER:
6082 retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
6083 break;
6084 case SCTP_GET_ASSOC_ID_LIST:
6085 retval = sctp_getsockopt_assoc_ids(sk, len, optval, optlen);
6086 break;
6087 case SCTP_AUTO_ASCONF:
6088 retval = sctp_getsockopt_auto_asconf(sk, len, optval, optlen);
6089 break;
6090 case SCTP_PEER_ADDR_THLDS:
6091 retval = sctp_getsockopt_paddr_thresholds(sk, optval, len, optlen);
6092 break;
6093 case SCTP_GET_ASSOC_STATS:
6094 retval = sctp_getsockopt_assoc_stats(sk, len, optval, optlen);
6095 break;
6096 case SCTP_RECVRCVINFO:
6097 retval = sctp_getsockopt_recvrcvinfo(sk, len, optval, optlen);
6098 break;
6099 case SCTP_RECVNXTINFO:
6100 retval = sctp_getsockopt_recvnxtinfo(sk, len, optval, optlen);
6101 break;
6102 default:
6103 retval = -ENOPROTOOPT;
6104 break;
6105 }
6106
6107 release_sock(sk);
6108 return retval;
6109}
6110
6111static int sctp_hash(struct sock *sk)
6112{
6113
6114 return 0;
6115}
6116
6117static void sctp_unhash(struct sock *sk)
6118{
6119
6120}
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
6133
6134static struct sctp_bind_bucket *sctp_bucket_create(
6135 struct sctp_bind_hashbucket *head, struct net *, unsigned short snum);
6136
6137static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
6138{
6139 struct sctp_bind_hashbucket *head;
6140 struct sctp_bind_bucket *pp;
6141 unsigned short snum;
6142 int ret;
6143
6144 snum = ntohs(addr->v4.sin_port);
6145
6146 pr_debug("%s: begins, snum:%d\n", __func__, snum);
6147
6148 local_bh_disable();
6149
6150 if (snum == 0) {
6151
6152 int low, high, remaining, index;
6153 unsigned int rover;
6154 struct net *net = sock_net(sk);
6155
6156 inet_get_local_port_range(net, &low, &high);
6157 remaining = (high - low) + 1;
6158 rover = prandom_u32() % remaining + low;
6159
6160 do {
6161 rover++;
6162 if ((rover < low) || (rover > high))
6163 rover = low;
6164 if (inet_is_local_reserved_port(net, rover))
6165 continue;
6166 index = sctp_phashfn(sock_net(sk), rover);
6167 head = &sctp_port_hashtable[index];
6168 spin_lock(&head->lock);
6169 sctp_for_each_hentry(pp, &head->chain)
6170 if ((pp->port == rover) &&
6171 net_eq(sock_net(sk), pp->net))
6172 goto next;
6173 break;
6174 next:
6175 spin_unlock(&head->lock);
6176 } while (--remaining > 0);
6177
6178
6179 ret = 1;
6180 if (remaining <= 0)
6181 goto fail;
6182
6183
6184
6185
6186
6187 snum = rover;
6188 } else {
6189
6190
6191
6192
6193
6194
6195 head = &sctp_port_hashtable[sctp_phashfn(sock_net(sk), snum)];
6196 spin_lock(&head->lock);
6197 sctp_for_each_hentry(pp, &head->chain) {
6198 if ((pp->port == snum) && net_eq(pp->net, sock_net(sk)))
6199 goto pp_found;
6200 }
6201 }
6202 pp = NULL;
6203 goto pp_not_found;
6204pp_found:
6205 if (!hlist_empty(&pp->owner)) {
6206
6207
6208
6209
6210
6211 int reuse = sk->sk_reuse;
6212 struct sock *sk2;
6213
6214 pr_debug("%s: found a possible match\n", __func__);
6215
6216 if (pp->fastreuse && sk->sk_reuse &&
6217 sk->sk_state != SCTP_SS_LISTENING)
6218 goto success;
6219
6220
6221
6222
6223
6224
6225
6226
6227
6228
6229
6230 sk_for_each_bound(sk2, &pp->owner) {
6231 struct sctp_endpoint *ep2;
6232 ep2 = sctp_sk(sk2)->ep;
6233
6234 if (sk == sk2 ||
6235 (reuse && sk2->sk_reuse &&
6236 sk2->sk_state != SCTP_SS_LISTENING))
6237 continue;
6238
6239 if (sctp_bind_addr_conflict(&ep2->base.bind_addr, addr,
6240 sctp_sk(sk2), sctp_sk(sk))) {
6241 ret = (long)sk2;
6242 goto fail_unlock;
6243 }
6244 }
6245
6246 pr_debug("%s: found a match\n", __func__);
6247 }
6248pp_not_found:
6249
6250 ret = 1;
6251 if (!pp && !(pp = sctp_bucket_create(head, sock_net(sk), snum)))
6252 goto fail_unlock;
6253
6254
6255
6256
6257
6258 if (hlist_empty(&pp->owner)) {
6259 if (sk->sk_reuse && sk->sk_state != SCTP_SS_LISTENING)
6260 pp->fastreuse = 1;
6261 else
6262 pp->fastreuse = 0;
6263 } else if (pp->fastreuse &&
6264 (!sk->sk_reuse || sk->sk_state == SCTP_SS_LISTENING))
6265 pp->fastreuse = 0;
6266
6267
6268
6269
6270
6271success:
6272 if (!sctp_sk(sk)->bind_hash) {
6273 inet_sk(sk)->inet_num = snum;
6274 sk_add_bind_node(sk, &pp->owner);
6275 sctp_sk(sk)->bind_hash = pp;
6276 }
6277 ret = 0;
6278
6279fail_unlock:
6280 spin_unlock(&head->lock);
6281
6282fail:
6283 local_bh_enable();
6284 return ret;
6285}
6286
6287
6288
6289
6290static int sctp_get_port(struct sock *sk, unsigned short snum)
6291{
6292 union sctp_addr addr;
6293 struct sctp_af *af = sctp_sk(sk)->pf->af;
6294
6295
6296 af->from_sk(&addr, sk);
6297 addr.v4.sin_port = htons(snum);
6298
6299
6300 return !!sctp_get_port_local(sk, &addr);
6301}
6302
6303
6304
6305
6306static int sctp_listen_start(struct sock *sk, int backlog)
6307{
6308 struct sctp_sock *sp = sctp_sk(sk);
6309 struct sctp_endpoint *ep = sp->ep;
6310 struct crypto_shash *tfm = NULL;
6311 char alg[32];
6312
6313
6314 if (!sp->hmac && sp->sctp_hmac_alg) {
6315 sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
6316 tfm = crypto_alloc_shash(alg, 0, 0);
6317 if (IS_ERR(tfm)) {
6318 net_info_ratelimited("failed to load transform for %s: %ld\n",
6319 sp->sctp_hmac_alg, PTR_ERR(tfm));
6320 return -ENOSYS;
6321 }
6322 sctp_sk(sk)->hmac = tfm;
6323 }
6324
6325
6326
6327
6328
6329
6330
6331
6332
6333
6334
6335
6336 sk->sk_state = SCTP_SS_LISTENING;
6337 if (!ep->base.bind_addr.port) {
6338 if (sctp_autobind(sk))
6339 return -EAGAIN;
6340 } else {
6341 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
6342 sk->sk_state = SCTP_SS_CLOSED;
6343 return -EADDRINUSE;
6344 }
6345 }
6346
6347 sk->sk_max_ack_backlog = backlog;
6348 sctp_hash_endpoint(ep);
6349 return 0;
6350}
6351
6352
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366int sctp_inet_listen(struct socket *sock, int backlog)
6367{
6368 struct sock *sk = sock->sk;
6369 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6370 int err = -EINVAL;
6371
6372 if (unlikely(backlog < 0))
6373 return err;
6374
6375 lock_sock(sk);
6376
6377
6378 if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
6379 goto out;
6380
6381 if (sock->state != SS_UNCONNECTED)
6382 goto out;
6383
6384
6385 if (!backlog) {
6386 if (sctp_sstate(sk, CLOSED))
6387 goto out;
6388
6389 err = 0;
6390 sctp_unhash_endpoint(ep);
6391 sk->sk_state = SCTP_SS_CLOSED;
6392 if (sk->sk_reuse)
6393 sctp_sk(sk)->bind_hash->fastreuse = 1;
6394 goto out;
6395 }
6396
6397
6398 if (sctp_sstate(sk, LISTENING))
6399 sk->sk_max_ack_backlog = backlog;
6400 else {
6401 err = sctp_listen_start(sk, backlog);
6402 if (err)
6403 goto out;
6404 }
6405
6406 err = 0;
6407out:
6408 release_sock(sk);
6409 return err;
6410}
6411
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424
6425unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
6426{
6427 struct sock *sk = sock->sk;
6428 struct sctp_sock *sp = sctp_sk(sk);
6429 unsigned int mask;
6430
6431 poll_wait(file, sk_sleep(sk), wait);
6432
6433
6434
6435
6436 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
6437 return (!list_empty(&sp->ep->asocs)) ?
6438 (POLLIN | POLLRDNORM) : 0;
6439
6440 mask = 0;
6441
6442
6443 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
6444 mask |= POLLERR |
6445 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
6446 if (sk->sk_shutdown & RCV_SHUTDOWN)
6447 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
6448 if (sk->sk_shutdown == SHUTDOWN_MASK)
6449 mask |= POLLHUP;
6450
6451
6452 if (!skb_queue_empty(&sk->sk_receive_queue))
6453 mask |= POLLIN | POLLRDNORM;
6454
6455
6456 if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
6457 return mask;
6458
6459
6460 if (sctp_writeable(sk)) {
6461 mask |= POLLOUT | POLLWRNORM;
6462 } else {
6463 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
6464
6465
6466
6467
6468
6469
6470
6471
6472 if (sctp_writeable(sk))
6473 mask |= POLLOUT | POLLWRNORM;
6474 }
6475 return mask;
6476}
6477
6478
6479
6480
6481
6482static struct sctp_bind_bucket *sctp_bucket_create(
6483 struct sctp_bind_hashbucket *head, struct net *net, unsigned short snum)
6484{
6485 struct sctp_bind_bucket *pp;
6486
6487 pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC);
6488 if (pp) {
6489 SCTP_DBG_OBJCNT_INC(bind_bucket);
6490 pp->port = snum;
6491 pp->fastreuse = 0;
6492 INIT_HLIST_HEAD(&pp->owner);
6493 pp->net = net;
6494 hlist_add_head(&pp->node, &head->chain);
6495 }
6496 return pp;
6497}
6498
6499
6500static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
6501{
6502 if (pp && hlist_empty(&pp->owner)) {
6503 __hlist_del(&pp->node);
6504 kmem_cache_free(sctp_bucket_cachep, pp);
6505 SCTP_DBG_OBJCNT_DEC(bind_bucket);
6506 }
6507}
6508
6509
6510static inline void __sctp_put_port(struct sock *sk)
6511{
6512 struct sctp_bind_hashbucket *head =
6513 &sctp_port_hashtable[sctp_phashfn(sock_net(sk),
6514 inet_sk(sk)->inet_num)];
6515 struct sctp_bind_bucket *pp;
6516
6517 spin_lock(&head->lock);
6518 pp = sctp_sk(sk)->bind_hash;
6519 __sk_del_bind_node(sk);
6520 sctp_sk(sk)->bind_hash = NULL;
6521 inet_sk(sk)->inet_num = 0;
6522 sctp_bucket_destroy(pp);
6523 spin_unlock(&head->lock);
6524}
6525
6526void sctp_put_port(struct sock *sk)
6527{
6528 local_bh_disable();
6529 __sctp_put_port(sk);
6530 local_bh_enable();
6531}
6532
6533
6534
6535
6536
6537
6538
6539static int sctp_autobind(struct sock *sk)
6540{
6541 union sctp_addr autoaddr;
6542 struct sctp_af *af;
6543 __be16 port;
6544
6545
6546 af = sctp_sk(sk)->pf->af;
6547
6548 port = htons(inet_sk(sk)->inet_num);
6549 af->inaddr_any(&autoaddr, port);
6550
6551 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
6552}
6553
6554
6555
6556
6557
6558
6559
6560
6561
6562
6563
6564
6565
6566
6567
6568
6569
6570
6571
6572
6573
6574
6575
6576
6577
6578
6579
6580
6581
6582
6583
6584
6585
6586
6587
6588
6589
6590
6591
6592
6593static int sctp_msghdr_parse(const struct msghdr *msg, sctp_cmsgs_t *cmsgs)
6594{
6595 struct cmsghdr *cmsg;
6596 struct msghdr *my_msg = (struct msghdr *)msg;
6597
6598 for_each_cmsghdr(cmsg, my_msg) {
6599 if (!CMSG_OK(my_msg, cmsg))
6600 return -EINVAL;
6601
6602
6603 if (cmsg->cmsg_level != IPPROTO_SCTP)
6604 continue;
6605
6606
6607 switch (cmsg->cmsg_type) {
6608 case SCTP_INIT:
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
6620
6621
6622 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_initmsg)))
6623 return -EINVAL;
6624
6625 cmsgs->init = CMSG_DATA(cmsg);
6626 break;
6627
6628 case SCTP_SNDRCV:
6629
6630
6631
6632
6633
6634
6635
6636
6637
6638
6639
6640 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
6641 return -EINVAL;
6642
6643 cmsgs->srinfo = CMSG_DATA(cmsg);
6644
6645 if (cmsgs->srinfo->sinfo_flags &
6646 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
6647 SCTP_SACK_IMMEDIATELY |
6648 SCTP_ABORT | SCTP_EOF))
6649 return -EINVAL;
6650 break;
6651
6652 case SCTP_SNDINFO:
6653
6654
6655
6656
6657
6658
6659
6660
6661
6662
6663
6664 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndinfo)))
6665 return -EINVAL;
6666
6667 cmsgs->sinfo = CMSG_DATA(cmsg);
6668
6669 if (cmsgs->sinfo->snd_flags &
6670 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
6671 SCTP_SACK_IMMEDIATELY |
6672 SCTP_ABORT | SCTP_EOF))
6673 return -EINVAL;
6674 break;
6675 default:
6676 return -EINVAL;
6677 }
6678 }
6679
6680 return 0;
6681}
6682
6683
6684
6685
6686
6687
6688static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p)
6689{
6690 int error;
6691 DEFINE_WAIT(wait);
6692
6693 prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
6694
6695
6696 error = sock_error(sk);
6697 if (error)
6698 goto out;
6699
6700 if (!skb_queue_empty(&sk->sk_receive_queue))
6701 goto ready;
6702
6703
6704 if (sk->sk_shutdown & RCV_SHUTDOWN)
6705 goto out;
6706
6707
6708
6709
6710 error = -ENOTCONN;
6711
6712
6713 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
6714 goto out;
6715
6716
6717 if (signal_pending(current))
6718 goto interrupted;
6719
6720
6721
6722
6723
6724
6725 release_sock(sk);
6726 *timeo_p = schedule_timeout(*timeo_p);
6727 lock_sock(sk);
6728
6729ready:
6730 finish_wait(sk_sleep(sk), &wait);
6731 return 0;
6732
6733interrupted:
6734 error = sock_intr_errno(*timeo_p);
6735
6736out:
6737 finish_wait(sk_sleep(sk), &wait);
6738 *err = error;
6739 return error;
6740}
6741
6742
6743
6744
6745
6746struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags,
6747 int noblock, int *err)
6748{
6749 int error;
6750 struct sk_buff *skb;
6751 long timeo;
6752
6753 timeo = sock_rcvtimeo(sk, noblock);
6754
6755 pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo,
6756 MAX_SCHEDULE_TIMEOUT);
6757
6758 do {
6759
6760
6761
6762
6763
6764
6765
6766 if (flags & MSG_PEEK) {
6767 spin_lock_bh(&sk->sk_receive_queue.lock);
6768 skb = skb_peek(&sk->sk_receive_queue);
6769 if (skb)
6770 atomic_inc(&skb->users);
6771 spin_unlock_bh(&sk->sk_receive_queue.lock);
6772 } else {
6773 skb = skb_dequeue(&sk->sk_receive_queue);
6774 }
6775
6776 if (skb)
6777 return skb;
6778
6779
6780 error = sock_error(sk);
6781 if (error)
6782 goto no_packet;
6783
6784 if (sk->sk_shutdown & RCV_SHUTDOWN)
6785 break;
6786
6787 if (sk_can_busy_loop(sk) &&
6788 sk_busy_loop(sk, noblock))
6789 continue;
6790
6791
6792 error = -EAGAIN;
6793 if (!timeo)
6794 goto no_packet;
6795 } while (sctp_wait_for_packet(sk, err, &timeo) == 0);
6796
6797 return NULL;
6798
6799no_packet:
6800 *err = error;
6801 return NULL;
6802}
6803
6804
6805static void __sctp_write_space(struct sctp_association *asoc)
6806{
6807 struct sock *sk = asoc->base.sk;
6808
6809 if (sctp_wspace(asoc) <= 0)
6810 return;
6811
6812 if (waitqueue_active(&asoc->wait))
6813 wake_up_interruptible(&asoc->wait);
6814
6815 if (sctp_writeable(sk)) {
6816 struct socket_wq *wq;
6817
6818 rcu_read_lock();
6819 wq = rcu_dereference(sk->sk_wq);
6820 if (wq) {
6821 if (waitqueue_active(&wq->wait))
6822 wake_up_interruptible(&wq->wait);
6823
6824
6825
6826
6827
6828 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
6829 sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
6830 }
6831 rcu_read_unlock();
6832 }
6833}
6834
6835static void sctp_wake_up_waiters(struct sock *sk,
6836 struct sctp_association *asoc)
6837{
6838 struct sctp_association *tmp = asoc;
6839
6840
6841
6842
6843 if (asoc->ep->sndbuf_policy)
6844 return __sctp_write_space(asoc);
6845
6846
6847
6848
6849 if (asoc->base.dead)
6850 return sctp_write_space(sk);
6851
6852
6853
6854
6855
6856
6857
6858
6859
6860
6861
6862 for (tmp = list_next_entry(tmp, asocs); 1;
6863 tmp = list_next_entry(tmp, asocs)) {
6864
6865 if (&tmp->asocs == &((sctp_sk(sk))->ep->asocs))
6866 continue;
6867
6868 __sctp_write_space(tmp);
6869
6870 if (tmp == asoc)
6871 break;
6872 }
6873}
6874
6875
6876
6877
6878
6879static void sctp_wfree(struct sk_buff *skb)
6880{
6881 struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
6882 struct sctp_association *asoc = chunk->asoc;
6883 struct sock *sk = asoc->base.sk;
6884
6885 asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) +
6886 sizeof(struct sk_buff) +
6887 sizeof(struct sctp_chunk);
6888
6889 atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
6890
6891
6892
6893
6894 sk->sk_wmem_queued -= skb->truesize;
6895 sk_mem_uncharge(sk, skb->truesize);
6896
6897 sock_wfree(skb);
6898 sctp_wake_up_waiters(sk, asoc);
6899
6900 sctp_association_put(asoc);
6901}
6902
6903
6904
6905
6906
6907
6908void sctp_sock_rfree(struct sk_buff *skb)
6909{
6910 struct sock *sk = skb->sk;
6911 struct sctp_ulpevent *event = sctp_skb2event(skb);
6912
6913 atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
6914
6915
6916
6917
6918 sk_mem_uncharge(sk, event->rmem_len);
6919}
6920
6921
6922
6923static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
6924 size_t msg_len)
6925{
6926 struct sock *sk = asoc->base.sk;
6927 int err = 0;
6928 long current_timeo = *timeo_p;
6929 DEFINE_WAIT(wait);
6930
6931 pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc,
6932 *timeo_p, msg_len);
6933
6934
6935 sctp_association_hold(asoc);
6936
6937
6938 for (;;) {
6939 prepare_to_wait_exclusive(&asoc->wait, &wait,
6940 TASK_INTERRUPTIBLE);
6941 if (!*timeo_p)
6942 goto do_nonblock;
6943 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
6944 asoc->base.dead)
6945 goto do_error;
6946 if (signal_pending(current))
6947 goto do_interrupted;
6948 if (msg_len <= sctp_wspace(asoc))
6949 break;
6950
6951
6952
6953
6954 release_sock(sk);
6955 current_timeo = schedule_timeout(current_timeo);
6956 BUG_ON(sk != asoc->base.sk);
6957 lock_sock(sk);
6958
6959 *timeo_p = current_timeo;
6960 }
6961
6962out:
6963 finish_wait(&asoc->wait, &wait);
6964
6965
6966 sctp_association_put(asoc);
6967
6968 return err;
6969
6970do_error:
6971 err = -EPIPE;
6972 goto out;
6973
6974do_interrupted:
6975 err = sock_intr_errno(*timeo_p);
6976 goto out;
6977
6978do_nonblock:
6979 err = -EAGAIN;
6980 goto out;
6981}
6982
6983void sctp_data_ready(struct sock *sk)
6984{
6985 struct socket_wq *wq;
6986
6987 rcu_read_lock();
6988 wq = rcu_dereference(sk->sk_wq);
6989 if (skwq_has_sleeper(wq))
6990 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
6991 POLLRDNORM | POLLRDBAND);
6992 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
6993 rcu_read_unlock();
6994}
6995
6996
6997void sctp_write_space(struct sock *sk)
6998{
6999 struct sctp_association *asoc;
7000
7001
7002 list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
7003 __sctp_write_space(asoc);
7004 }
7005}
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015
7016
7017
7018static int sctp_writeable(struct sock *sk)
7019{
7020 int amt = 0;
7021
7022 amt = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
7023 if (amt < 0)
7024 amt = 0;
7025 return amt;
7026}
7027
7028
7029
7030
7031static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
7032{
7033 struct sock *sk = asoc->base.sk;
7034 int err = 0;
7035 long current_timeo = *timeo_p;
7036 DEFINE_WAIT(wait);
7037
7038 pr_debug("%s: asoc:%p, timeo:%ld\n", __func__, asoc, *timeo_p);
7039
7040
7041 sctp_association_hold(asoc);
7042
7043 for (;;) {
7044 prepare_to_wait_exclusive(&asoc->wait, &wait,
7045 TASK_INTERRUPTIBLE);
7046 if (!*timeo_p)
7047 goto do_nonblock;
7048 if (sk->sk_shutdown & RCV_SHUTDOWN)
7049 break;
7050 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
7051 asoc->base.dead)
7052 goto do_error;
7053 if (signal_pending(current))
7054 goto do_interrupted;
7055
7056 if (sctp_state(asoc, ESTABLISHED))
7057 break;
7058
7059
7060
7061
7062 release_sock(sk);
7063 current_timeo = schedule_timeout(current_timeo);
7064 lock_sock(sk);
7065
7066 *timeo_p = current_timeo;
7067 }
7068
7069out:
7070 finish_wait(&asoc->wait, &wait);
7071
7072
7073 sctp_association_put(asoc);
7074
7075 return err;
7076
7077do_error:
7078 if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
7079 err = -ETIMEDOUT;
7080 else
7081 err = -ECONNREFUSED;
7082 goto out;
7083
7084do_interrupted:
7085 err = sock_intr_errno(*timeo_p);
7086 goto out;
7087
7088do_nonblock:
7089 err = -EINPROGRESS;
7090 goto out;
7091}
7092
7093static int sctp_wait_for_accept(struct sock *sk, long timeo)
7094{
7095 struct sctp_endpoint *ep;
7096 int err = 0;
7097 DEFINE_WAIT(wait);
7098
7099 ep = sctp_sk(sk)->ep;
7100
7101
7102 for (;;) {
7103 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
7104 TASK_INTERRUPTIBLE);
7105
7106 if (list_empty(&ep->asocs)) {
7107 release_sock(sk);
7108 timeo = schedule_timeout(timeo);
7109 lock_sock(sk);
7110 }
7111
7112 err = -EINVAL;
7113 if (!sctp_sstate(sk, LISTENING))
7114 break;
7115
7116 err = 0;
7117 if (!list_empty(&ep->asocs))
7118 break;
7119
7120 err = sock_intr_errno(timeo);
7121 if (signal_pending(current))
7122 break;
7123
7124 err = -EAGAIN;
7125 if (!timeo)
7126 break;
7127 }
7128
7129 finish_wait(sk_sleep(sk), &wait);
7130
7131 return err;
7132}
7133
7134static void sctp_wait_for_close(struct sock *sk, long timeout)
7135{
7136 DEFINE_WAIT(wait);
7137
7138 do {
7139 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
7140 if (list_empty(&sctp_sk(sk)->ep->asocs))
7141 break;
7142 release_sock(sk);
7143 timeout = schedule_timeout(timeout);
7144 lock_sock(sk);
7145 } while (!signal_pending(current) && timeout);
7146
7147 finish_wait(sk_sleep(sk), &wait);
7148}
7149
7150static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
7151{
7152 struct sk_buff *frag;
7153
7154 if (!skb->data_len)
7155 goto done;
7156
7157
7158 skb_walk_frags(skb, frag)
7159 sctp_skb_set_owner_r_frag(frag, sk);
7160
7161done:
7162 sctp_skb_set_owner_r(skb, sk);
7163}
7164
7165void sctp_copy_sock(struct sock *newsk, struct sock *sk,
7166 struct sctp_association *asoc)
7167{
7168 struct inet_sock *inet = inet_sk(sk);
7169 struct inet_sock *newinet;
7170
7171 newsk->sk_type = sk->sk_type;
7172 newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
7173 newsk->sk_flags = sk->sk_flags;
7174 newsk->sk_tsflags = sk->sk_tsflags;
7175 newsk->sk_no_check_tx = sk->sk_no_check_tx;
7176 newsk->sk_no_check_rx = sk->sk_no_check_rx;
7177 newsk->sk_reuse = sk->sk_reuse;
7178
7179 newsk->sk_shutdown = sk->sk_shutdown;
7180 newsk->sk_destruct = sctp_destruct_sock;
7181 newsk->sk_family = sk->sk_family;
7182 newsk->sk_protocol = IPPROTO_SCTP;
7183 newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
7184 newsk->sk_sndbuf = sk->sk_sndbuf;
7185 newsk->sk_rcvbuf = sk->sk_rcvbuf;
7186 newsk->sk_lingertime = sk->sk_lingertime;
7187 newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
7188 newsk->sk_sndtimeo = sk->sk_sndtimeo;
7189
7190 newinet = inet_sk(newsk);
7191
7192
7193
7194
7195 newinet->inet_sport = inet->inet_sport;
7196 newinet->inet_saddr = inet->inet_saddr;
7197 newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
7198 newinet->inet_dport = htons(asoc->peer.port);
7199 newinet->pmtudisc = inet->pmtudisc;
7200 newinet->inet_id = asoc->next_tsn ^ jiffies;
7201
7202 newinet->uc_ttl = inet->uc_ttl;
7203 newinet->mc_loop = 1;
7204 newinet->mc_ttl = 1;
7205 newinet->mc_index = 0;
7206 newinet->mc_list = NULL;
7207
7208 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
7209 net_enable_timestamp();
7210
7211 security_sk_clone(sk, newsk);
7212}
7213
7214static inline void sctp_copy_descendant(struct sock *sk_to,
7215 const struct sock *sk_from)
7216{
7217 int ancestor_size = sizeof(struct inet_sock) +
7218 sizeof(struct sctp_sock) -
7219 offsetof(struct sctp_sock, auto_asconf_list);
7220
7221 if (sk_from->sk_family == PF_INET6)
7222 ancestor_size += sizeof(struct ipv6_pinfo);
7223
7224 __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
7225}
7226
7227
7228
7229
7230static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
7231 struct sctp_association *assoc,
7232 sctp_socket_type_t type)
7233{
7234 struct sctp_sock *oldsp = sctp_sk(oldsk);
7235 struct sctp_sock *newsp = sctp_sk(newsk);
7236 struct sctp_bind_bucket *pp;
7237 struct sctp_endpoint *newep = newsp->ep;
7238 struct sk_buff *skb, *tmp;
7239 struct sctp_ulpevent *event;
7240 struct sctp_bind_hashbucket *head;
7241
7242
7243
7244
7245 newsk->sk_sndbuf = oldsk->sk_sndbuf;
7246 newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
7247
7248 sctp_copy_descendant(newsk, oldsk);
7249
7250
7251
7252
7253 newsp->ep = newep;
7254 newsp->hmac = NULL;
7255
7256
7257 head = &sctp_port_hashtable[sctp_phashfn(sock_net(oldsk),
7258 inet_sk(oldsk)->inet_num)];
7259 spin_lock_bh(&head->lock);
7260 pp = sctp_sk(oldsk)->bind_hash;
7261 sk_add_bind_node(newsk, &pp->owner);
7262 sctp_sk(newsk)->bind_hash = pp;
7263 inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
7264 spin_unlock_bh(&head->lock);
7265
7266
7267
7268
7269 sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
7270 &oldsp->ep->base.bind_addr, GFP_KERNEL);
7271
7272
7273
7274
7275 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
7276 event = sctp_skb2event(skb);
7277 if (event->asoc == assoc) {
7278 __skb_unlink(skb, &oldsk->sk_receive_queue);
7279 __skb_queue_tail(&newsk->sk_receive_queue, skb);
7280 sctp_skb_set_owner_r_frag(skb, newsk);
7281 }
7282 }
7283
7284
7285
7286
7287
7288
7289
7290 skb_queue_head_init(&newsp->pd_lobby);
7291 atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
7292
7293 if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
7294 struct sk_buff_head *queue;
7295
7296
7297 if (assoc->ulpq.pd_mode) {
7298 queue = &newsp->pd_lobby;
7299 } else
7300 queue = &newsk->sk_receive_queue;
7301
7302
7303
7304
7305 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
7306 event = sctp_skb2event(skb);
7307 if (event->asoc == assoc) {
7308 __skb_unlink(skb, &oldsp->pd_lobby);
7309 __skb_queue_tail(queue, skb);
7310 sctp_skb_set_owner_r_frag(skb, newsk);
7311 }
7312 }
7313
7314
7315
7316
7317 if (assoc->ulpq.pd_mode)
7318 sctp_clear_pd(oldsk, NULL);
7319
7320 }
7321
7322 sctp_skb_for_each(skb, &assoc->ulpq.reasm, tmp)
7323 sctp_skb_set_owner_r_frag(skb, newsk);
7324
7325 sctp_skb_for_each(skb, &assoc->ulpq.lobby, tmp)
7326 sctp_skb_set_owner_r_frag(skb, newsk);
7327
7328
7329
7330
7331
7332 newsp->type = type;
7333
7334
7335
7336
7337
7338
7339
7340
7341
7342
7343 lock_sock_nested(newsk, SINGLE_DEPTH_NESTING);
7344 sctp_assoc_migrate(assoc, newsk);
7345
7346
7347
7348
7349 if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP))
7350 newsk->sk_shutdown |= RCV_SHUTDOWN;
7351
7352 newsk->sk_state = SCTP_SS_ESTABLISHED;
7353 release_sock(newsk);
7354}
7355
7356
7357
7358struct proto sctp_prot = {
7359 .name = "SCTP",
7360 .owner = THIS_MODULE,
7361 .close = sctp_close,
7362 .connect = sctp_connect,
7363 .disconnect = sctp_disconnect,
7364 .accept = sctp_accept,
7365 .ioctl = sctp_ioctl,
7366 .init = sctp_init_sock,
7367 .destroy = sctp_destroy_sock,
7368 .shutdown = sctp_shutdown,
7369 .setsockopt = sctp_setsockopt,
7370 .getsockopt = sctp_getsockopt,
7371 .sendmsg = sctp_sendmsg,
7372 .recvmsg = sctp_recvmsg,
7373 .bind = sctp_bind,
7374 .backlog_rcv = sctp_backlog_rcv,
7375 .hash = sctp_hash,
7376 .unhash = sctp_unhash,
7377 .get_port = sctp_get_port,
7378 .obj_size = sizeof(struct sctp_sock),
7379 .sysctl_mem = sysctl_sctp_mem,
7380 .sysctl_rmem = sysctl_sctp_rmem,
7381 .sysctl_wmem = sysctl_sctp_wmem,
7382 .memory_pressure = &sctp_memory_pressure,
7383 .enter_memory_pressure = sctp_enter_memory_pressure,
7384 .memory_allocated = &sctp_memory_allocated,
7385 .sockets_allocated = &sctp_sockets_allocated,
7386};
7387
7388#if IS_ENABLED(CONFIG_IPV6)
7389
7390#include <net/transp_v6.h>
7391static void sctp_v6_destroy_sock(struct sock *sk)
7392{
7393 sctp_destroy_sock(sk);
7394 inet6_destroy_sock(sk);
7395}
7396
7397struct proto sctpv6_prot = {
7398 .name = "SCTPv6",
7399 .owner = THIS_MODULE,
7400 .close = sctp_close,
7401 .connect = sctp_connect,
7402 .disconnect = sctp_disconnect,
7403 .accept = sctp_accept,
7404 .ioctl = sctp_ioctl,
7405 .init = sctp_init_sock,
7406 .destroy = sctp_v6_destroy_sock,
7407 .shutdown = sctp_shutdown,
7408 .setsockopt = sctp_setsockopt,
7409 .getsockopt = sctp_getsockopt,
7410 .sendmsg = sctp_sendmsg,
7411 .recvmsg = sctp_recvmsg,
7412 .bind = sctp_bind,
7413 .backlog_rcv = sctp_backlog_rcv,
7414 .hash = sctp_hash,
7415 .unhash = sctp_unhash,
7416 .get_port = sctp_get_port,
7417 .obj_size = sizeof(struct sctp6_sock),
7418 .sysctl_mem = sysctl_sctp_mem,
7419 .sysctl_rmem = sysctl_sctp_rmem,
7420 .sysctl_wmem = sysctl_sctp_wmem,
7421 .memory_pressure = &sctp_memory_pressure,
7422 .enter_memory_pressure = sctp_enter_memory_pressure,
7423 .memory_allocated = &sctp_memory_allocated,
7424 .sockets_allocated = &sctp_sockets_allocated,
7425};
7426#endif
7427