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