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