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