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