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