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#include <linux/module.h>
38#include <linux/types.h>
39#include <linux/net.h>
40#include <linux/socket.h>
41#include <linux/errno.h>
42#include <linux/mm.h>
43#include <linux/slab.h>
44#include <linux/poll.h>
45#include <linux/fcntl.h>
46#include <asm/string.h>
47#include <asm/atomic.h>
48#include <net/sock.h>
49
50#include <linux/tipc.h>
51#include <linux/tipc_config.h>
52#include <net/tipc/tipc_msg.h>
53#include <net/tipc/tipc_port.h>
54
55#include "core.h"
56
57#define SS_LISTENING -1
58#define SS_READY -2
59
60#define OVERLOAD_LIMIT_BASE 5000
61#define CONN_TIMEOUT_DEFAULT 8000
62
63struct tipc_sock {
64 struct sock sk;
65 struct tipc_port *p;
66 struct tipc_portid peer_name;
67};
68
69#define tipc_sk(sk) ((struct tipc_sock *)(sk))
70#define tipc_sk_port(sk) ((struct tipc_port *)(tipc_sk(sk)->p))
71
72static int backlog_rcv(struct sock *sk, struct sk_buff *skb);
73static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf);
74static void wakeupdispatch(struct tipc_port *tport);
75
76static const struct proto_ops packet_ops;
77static const struct proto_ops stream_ops;
78static const struct proto_ops msg_ops;
79
80static struct proto tipc_proto;
81
82static int sockets_enabled = 0;
83
84static atomic_t tipc_queue_size = ATOMIC_INIT(0);
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137static void advance_rx_queue(struct sock *sk)
138{
139 buf_discard(__skb_dequeue(&sk->sk_receive_queue));
140 atomic_dec(&tipc_queue_size);
141}
142
143
144
145
146
147
148
149static void discard_rx_queue(struct sock *sk)
150{
151 struct sk_buff *buf;
152
153 while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {
154 atomic_dec(&tipc_queue_size);
155 buf_discard(buf);
156 }
157}
158
159
160
161
162
163
164
165static void reject_rx_queue(struct sock *sk)
166{
167 struct sk_buff *buf;
168
169 while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {
170 tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
171 atomic_dec(&tipc_queue_size);
172 }
173}
174
175
176
177
178
179
180
181
182
183
184
185
186
187static int tipc_create(struct net *net, struct socket *sock, int protocol)
188{
189 const struct proto_ops *ops;
190 socket_state state;
191 struct sock *sk;
192 struct tipc_port *tp_ptr;
193
194
195
196 if (net != &init_net)
197 return -EAFNOSUPPORT;
198
199 if (unlikely(protocol != 0))
200 return -EPROTONOSUPPORT;
201
202 switch (sock->type) {
203 case SOCK_STREAM:
204 ops = &stream_ops;
205 state = SS_UNCONNECTED;
206 break;
207 case SOCK_SEQPACKET:
208 ops = &packet_ops;
209 state = SS_UNCONNECTED;
210 break;
211 case SOCK_DGRAM:
212 case SOCK_RDM:
213 ops = &msg_ops;
214 state = SS_READY;
215 break;
216 default:
217 return -EPROTOTYPE;
218 }
219
220
221
222 sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
223 if (sk == NULL)
224 return -ENOMEM;
225
226
227
228 tp_ptr = tipc_createport_raw(sk, &dispatch, &wakeupdispatch,
229 TIPC_LOW_IMPORTANCE);
230 if (unlikely(!tp_ptr)) {
231 sk_free(sk);
232 return -ENOMEM;
233 }
234
235
236
237 sock->ops = ops;
238 sock->state = state;
239
240 sock_init_data(sock, sk);
241 sk->sk_rcvtimeo = msecs_to_jiffies(CONN_TIMEOUT_DEFAULT);
242 sk->sk_backlog_rcv = backlog_rcv;
243 tipc_sk(sk)->p = tp_ptr;
244
245 spin_unlock_bh(tp_ptr->lock);
246
247 if (sock->state == SS_READY) {
248 tipc_set_portunreturnable(tp_ptr->ref, 1);
249 if (sock->type == SOCK_DGRAM)
250 tipc_set_portunreliable(tp_ptr->ref, 1);
251 }
252
253 atomic_inc(&tipc_user_count);
254 return 0;
255}
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274static int release(struct socket *sock)
275{
276 struct sock *sk = sock->sk;
277 struct tipc_port *tport;
278 struct sk_buff *buf;
279 int res;
280
281
282
283
284
285
286 if (sk == NULL)
287 return 0;
288
289 tport = tipc_sk_port(sk);
290 lock_sock(sk);
291
292
293
294
295
296
297 while (sock->state != SS_DISCONNECTING) {
298 buf = __skb_dequeue(&sk->sk_receive_queue);
299 if (buf == NULL)
300 break;
301 atomic_dec(&tipc_queue_size);
302 if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf)))
303 buf_discard(buf);
304 else {
305 if ((sock->state == SS_CONNECTING) ||
306 (sock->state == SS_CONNECTED)) {
307 sock->state = SS_DISCONNECTING;
308 tipc_disconnect(tport->ref);
309 }
310 tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
311 }
312 }
313
314
315
316
317
318
319 res = tipc_deleteport(tport->ref);
320
321
322
323 discard_rx_queue(sk);
324
325
326
327 sock->state = SS_DISCONNECTING;
328 release_sock(sk);
329
330 sock_put(sk);
331 sock->sk = NULL;
332
333 atomic_dec(&tipc_user_count);
334 return res;
335}
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len)
354{
355 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
356 u32 portref = tipc_sk_port(sock->sk)->ref;
357
358 if (unlikely(!uaddr_len))
359 return tipc_withdraw(portref, 0, NULL);
360
361 if (uaddr_len < sizeof(struct sockaddr_tipc))
362 return -EINVAL;
363 if (addr->family != AF_TIPC)
364 return -EAFNOSUPPORT;
365
366 if (addr->addrtype == TIPC_ADDR_NAME)
367 addr->addr.nameseq.upper = addr->addr.nameseq.lower;
368 else if (addr->addrtype != TIPC_ADDR_NAMESEQ)
369 return -EAFNOSUPPORT;
370
371 return (addr->scope > 0) ?
372 tipc_publish(portref, addr->scope, &addr->addr.nameseq) :
373 tipc_withdraw(portref, -addr->scope, &addr->addr.nameseq);
374}
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390static int get_name(struct socket *sock, struct sockaddr *uaddr,
391 int *uaddr_len, int peer)
392{
393 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
394 struct tipc_sock *tsock = tipc_sk(sock->sk);
395
396 if (peer) {
397 if ((sock->state != SS_CONNECTED) &&
398 ((peer != 2) || (sock->state != SS_DISCONNECTING)))
399 return -ENOTCONN;
400 addr->addr.id.ref = tsock->peer_name.ref;
401 addr->addr.id.node = tsock->peer_name.node;
402 } else {
403 tipc_ownidentity(tsock->p->ref, &addr->addr.id);
404 }
405
406 *uaddr_len = sizeof(*addr);
407 addr->addrtype = TIPC_ADDR_ID;
408 addr->family = AF_TIPC;
409 addr->scope = 0;
410 addr->addr.name.domain = 0;
411
412 return 0;
413}
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441static unsigned int poll(struct file *file, struct socket *sock,
442 poll_table *wait)
443{
444 struct sock *sk = sock->sk;
445 u32 mask;
446
447 poll_wait(file, sk->sk_sleep, wait);
448
449 if (!skb_queue_empty(&sk->sk_receive_queue) ||
450 (sock->state == SS_UNCONNECTED) ||
451 (sock->state == SS_DISCONNECTING))
452 mask = (POLLRDNORM | POLLIN);
453 else
454 mask = 0;
455
456 if (sock->state == SS_DISCONNECTING)
457 mask |= POLLHUP;
458 else
459 mask |= POLLOUT;
460
461 return mask;
462}
463
464
465
466
467
468
469
470
471
472
473
474
475static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m)
476{
477 struct tipc_cfg_msg_hdr hdr;
478
479 if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))
480 return 0;
481 if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))
482 return 0;
483 if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))
484 return -EACCES;
485
486 if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))
487 return -EFAULT;
488 if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))
489 return -EACCES;
490
491 return 0;
492}
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509static int send_msg(struct kiocb *iocb, struct socket *sock,
510 struct msghdr *m, size_t total_len)
511{
512 struct sock *sk = sock->sk;
513 struct tipc_port *tport = tipc_sk_port(sk);
514 struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
515 int needs_conn;
516 int res = -EINVAL;
517
518 if (unlikely(!dest))
519 return -EDESTADDRREQ;
520 if (unlikely((m->msg_namelen < sizeof(*dest)) ||
521 (dest->family != AF_TIPC)))
522 return -EINVAL;
523
524 if (iocb)
525 lock_sock(sk);
526
527 needs_conn = (sock->state != SS_READY);
528 if (unlikely(needs_conn)) {
529 if (sock->state == SS_LISTENING) {
530 res = -EPIPE;
531 goto exit;
532 }
533 if (sock->state != SS_UNCONNECTED) {
534 res = -EISCONN;
535 goto exit;
536 }
537 if ((tport->published) ||
538 ((sock->type == SOCK_STREAM) && (total_len != 0))) {
539 res = -EOPNOTSUPP;
540 goto exit;
541 }
542 if (dest->addrtype == TIPC_ADDR_NAME) {
543 tport->conn_type = dest->addr.name.name.type;
544 tport->conn_instance = dest->addr.name.name.instance;
545 }
546
547
548
549 reject_rx_queue(sk);
550 }
551
552 do {
553 if (dest->addrtype == TIPC_ADDR_NAME) {
554 if ((res = dest_name_check(dest, m)))
555 break;
556 res = tipc_send2name(tport->ref,
557 &dest->addr.name.name,
558 dest->addr.name.domain,
559 m->msg_iovlen,
560 m->msg_iov);
561 }
562 else if (dest->addrtype == TIPC_ADDR_ID) {
563 res = tipc_send2port(tport->ref,
564 &dest->addr.id,
565 m->msg_iovlen,
566 m->msg_iov);
567 }
568 else if (dest->addrtype == TIPC_ADDR_MCAST) {
569 if (needs_conn) {
570 res = -EOPNOTSUPP;
571 break;
572 }
573 if ((res = dest_name_check(dest, m)))
574 break;
575 res = tipc_multicast(tport->ref,
576 &dest->addr.nameseq,
577 0,
578 m->msg_iovlen,
579 m->msg_iov);
580 }
581 if (likely(res != -ELINKCONG)) {
582 if (needs_conn && (res >= 0)) {
583 sock->state = SS_CONNECTING;
584 }
585 break;
586 }
587 if (m->msg_flags & MSG_DONTWAIT) {
588 res = -EWOULDBLOCK;
589 break;
590 }
591 release_sock(sk);
592 res = wait_event_interruptible(*sk->sk_sleep,
593 !tport->congested);
594 lock_sock(sk);
595 if (res)
596 break;
597 } while (1);
598
599exit:
600 if (iocb)
601 release_sock(sk);
602 return res;
603}
604
605
606
607
608
609
610
611
612
613
614
615
616
617static int send_packet(struct kiocb *iocb, struct socket *sock,
618 struct msghdr *m, size_t total_len)
619{
620 struct sock *sk = sock->sk;
621 struct tipc_port *tport = tipc_sk_port(sk);
622 struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
623 int res;
624
625
626
627 if (unlikely(dest))
628 return send_msg(iocb, sock, m, total_len);
629
630 if (iocb)
631 lock_sock(sk);
632
633 do {
634 if (unlikely(sock->state != SS_CONNECTED)) {
635 if (sock->state == SS_DISCONNECTING)
636 res = -EPIPE;
637 else
638 res = -ENOTCONN;
639 break;
640 }
641
642 res = tipc_send(tport->ref, m->msg_iovlen, m->msg_iov);
643 if (likely(res != -ELINKCONG)) {
644 break;
645 }
646 if (m->msg_flags & MSG_DONTWAIT) {
647 res = -EWOULDBLOCK;
648 break;
649 }
650 release_sock(sk);
651 res = wait_event_interruptible(*sk->sk_sleep,
652 (!tport->congested || !tport->connected));
653 lock_sock(sk);
654 if (res)
655 break;
656 } while (1);
657
658 if (iocb)
659 release_sock(sk);
660 return res;
661}
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676static int send_stream(struct kiocb *iocb, struct socket *sock,
677 struct msghdr *m, size_t total_len)
678{
679 struct sock *sk = sock->sk;
680 struct tipc_port *tport = tipc_sk_port(sk);
681 struct msghdr my_msg;
682 struct iovec my_iov;
683 struct iovec *curr_iov;
684 int curr_iovlen;
685 char __user *curr_start;
686 u32 hdr_size;
687 int curr_left;
688 int bytes_to_send;
689 int bytes_sent;
690 int res;
691
692 lock_sock(sk);
693
694
695
696 if (unlikely(sock->state != SS_CONNECTED)) {
697 if (sock->state == SS_UNCONNECTED) {
698 res = send_packet(NULL, sock, m, total_len);
699 goto exit;
700 } else if (sock->state == SS_DISCONNECTING) {
701 res = -EPIPE;
702 goto exit;
703 } else {
704 res = -ENOTCONN;
705 goto exit;
706 }
707 }
708
709 if (unlikely(m->msg_name)) {
710 res = -EISCONN;
711 goto exit;
712 }
713
714
715
716
717
718
719
720
721
722 curr_iov = m->msg_iov;
723 curr_iovlen = m->msg_iovlen;
724 my_msg.msg_iov = &my_iov;
725 my_msg.msg_iovlen = 1;
726 my_msg.msg_flags = m->msg_flags;
727 my_msg.msg_name = NULL;
728 bytes_sent = 0;
729
730 hdr_size = msg_hdr_sz(&tport->phdr);
731
732 while (curr_iovlen--) {
733 curr_start = curr_iov->iov_base;
734 curr_left = curr_iov->iov_len;
735
736 while (curr_left) {
737 bytes_to_send = tport->max_pkt - hdr_size;
738 if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)
739 bytes_to_send = TIPC_MAX_USER_MSG_SIZE;
740 if (curr_left < bytes_to_send)
741 bytes_to_send = curr_left;
742 my_iov.iov_base = curr_start;
743 my_iov.iov_len = bytes_to_send;
744 if ((res = send_packet(NULL, sock, &my_msg, 0)) < 0) {
745 if (bytes_sent)
746 res = bytes_sent;
747 goto exit;
748 }
749 curr_left -= bytes_to_send;
750 curr_start += bytes_to_send;
751 bytes_sent += bytes_to_send;
752 }
753
754 curr_iov++;
755 }
756 res = bytes_sent;
757exit:
758 release_sock(sk);
759 return res;
760}
761
762
763
764
765
766
767
768
769
770static int auto_connect(struct socket *sock, struct tipc_msg *msg)
771{
772 struct tipc_sock *tsock = tipc_sk(sock->sk);
773
774 if (msg_errcode(msg)) {
775 sock->state = SS_DISCONNECTING;
776 return -ECONNREFUSED;
777 }
778
779 tsock->peer_name.ref = msg_origport(msg);
780 tsock->peer_name.node = msg_orignode(msg);
781 tipc_connect2port(tsock->p->ref, &tsock->peer_name);
782 tipc_set_portimportance(tsock->p->ref, msg_importance(msg));
783 sock->state = SS_CONNECTED;
784 return 0;
785}
786
787
788
789
790
791
792
793
794
795static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg)
796{
797 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)m->msg_name;
798
799 if (addr) {
800 addr->family = AF_TIPC;
801 addr->addrtype = TIPC_ADDR_ID;
802 addr->addr.id.ref = msg_origport(msg);
803 addr->addr.id.node = msg_orignode(msg);
804 addr->addr.name.domain = 0;
805 addr->scope = 0;
806 m->msg_namelen = sizeof(struct sockaddr_tipc);
807 }
808}
809
810
811
812
813
814
815
816
817
818
819
820
821static int anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
822 struct tipc_port *tport)
823{
824 u32 anc_data[3];
825 u32 err;
826 u32 dest_type;
827 int has_name;
828 int res;
829
830 if (likely(m->msg_controllen == 0))
831 return 0;
832
833
834
835 err = msg ? msg_errcode(msg) : 0;
836 if (unlikely(err)) {
837 anc_data[0] = err;
838 anc_data[1] = msg_data_sz(msg);
839 if ((res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data)))
840 return res;
841 if (anc_data[1] &&
842 (res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
843 msg_data(msg))))
844 return res;
845 }
846
847
848
849 dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
850 switch (dest_type) {
851 case TIPC_NAMED_MSG:
852 has_name = 1;
853 anc_data[0] = msg_nametype(msg);
854 anc_data[1] = msg_namelower(msg);
855 anc_data[2] = msg_namelower(msg);
856 break;
857 case TIPC_MCAST_MSG:
858 has_name = 1;
859 anc_data[0] = msg_nametype(msg);
860 anc_data[1] = msg_namelower(msg);
861 anc_data[2] = msg_nameupper(msg);
862 break;
863 case TIPC_CONN_MSG:
864 has_name = (tport->conn_type != 0);
865 anc_data[0] = tport->conn_type;
866 anc_data[1] = tport->conn_instance;
867 anc_data[2] = tport->conn_instance;
868 break;
869 default:
870 has_name = 0;
871 }
872 if (has_name &&
873 (res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data)))
874 return res;
875
876 return 0;
877}
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892static int recv_msg(struct kiocb *iocb, struct socket *sock,
893 struct msghdr *m, size_t buf_len, int flags)
894{
895 struct sock *sk = sock->sk;
896 struct tipc_port *tport = tipc_sk_port(sk);
897 struct sk_buff *buf;
898 struct tipc_msg *msg;
899 unsigned int sz;
900 u32 err;
901 int res;
902
903
904
905 if (m->msg_iovlen != 1)
906 return -EOPNOTSUPP;
907
908 if (unlikely(!buf_len))
909 return -EINVAL;
910
911 lock_sock(sk);
912
913 if (unlikely(sock->state == SS_UNCONNECTED)) {
914 res = -ENOTCONN;
915 goto exit;
916 }
917
918restart:
919
920
921
922 while (skb_queue_empty(&sk->sk_receive_queue)) {
923 if (sock->state == SS_DISCONNECTING) {
924 res = -ENOTCONN;
925 goto exit;
926 }
927 if (flags & MSG_DONTWAIT) {
928 res = -EWOULDBLOCK;
929 goto exit;
930 }
931 release_sock(sk);
932 res = wait_event_interruptible(*sk->sk_sleep,
933 (!skb_queue_empty(&sk->sk_receive_queue) ||
934 (sock->state == SS_DISCONNECTING)));
935 lock_sock(sk);
936 if (res)
937 goto exit;
938 }
939
940
941
942 buf = skb_peek(&sk->sk_receive_queue);
943 msg = buf_msg(buf);
944 sz = msg_data_sz(msg);
945 err = msg_errcode(msg);
946
947
948
949 if (unlikely(sock->state == SS_CONNECTING)) {
950 res = auto_connect(sock, msg);
951 if (res)
952 goto exit;
953 }
954
955
956
957 if ((!sz) && (!err)) {
958 advance_rx_queue(sk);
959 goto restart;
960 }
961
962
963
964 set_orig_addr(m, msg);
965
966
967
968 res = anc_data_recv(m, msg, tport);
969 if (res)
970 goto exit;
971
972
973
974 if (!err) {
975 if (unlikely(buf_len < sz)) {
976 sz = buf_len;
977 m->msg_flags |= MSG_TRUNC;
978 }
979 if (unlikely(copy_to_user(m->msg_iov->iov_base, msg_data(msg),
980 sz))) {
981 res = -EFAULT;
982 goto exit;
983 }
984 res = sz;
985 } else {
986 if ((sock->state == SS_READY) ||
987 ((err == TIPC_CONN_SHUTDOWN) || m->msg_control))
988 res = 0;
989 else
990 res = -ECONNRESET;
991 }
992
993
994
995 if (likely(!(flags & MSG_PEEK))) {
996 if ((sock->state != SS_READY) &&
997 (++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
998 tipc_acknowledge(tport->ref, tport->conn_unacked);
999 advance_rx_queue(sk);
1000 }
1001exit:
1002 release_sock(sk);
1003 return res;
1004}
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019static int recv_stream(struct kiocb *iocb, struct socket *sock,
1020 struct msghdr *m, size_t buf_len, int flags)
1021{
1022 struct sock *sk = sock->sk;
1023 struct tipc_port *tport = tipc_sk_port(sk);
1024 struct sk_buff *buf;
1025 struct tipc_msg *msg;
1026 unsigned int sz;
1027 int sz_to_copy;
1028 int sz_copied = 0;
1029 int needed;
1030 char __user *crs = m->msg_iov->iov_base;
1031 unsigned char *buf_crs;
1032 u32 err;
1033 int res = 0;
1034
1035
1036
1037 if (m->msg_iovlen != 1)
1038 return -EOPNOTSUPP;
1039
1040 if (unlikely(!buf_len))
1041 return -EINVAL;
1042
1043 lock_sock(sk);
1044
1045 if (unlikely((sock->state == SS_UNCONNECTED) ||
1046 (sock->state == SS_CONNECTING))) {
1047 res = -ENOTCONN;
1048 goto exit;
1049 }
1050
1051restart:
1052
1053
1054
1055 while (skb_queue_empty(&sk->sk_receive_queue)) {
1056 if (sock->state == SS_DISCONNECTING) {
1057 res = -ENOTCONN;
1058 goto exit;
1059 }
1060 if (flags & MSG_DONTWAIT) {
1061 res = -EWOULDBLOCK;
1062 goto exit;
1063 }
1064 release_sock(sk);
1065 res = wait_event_interruptible(*sk->sk_sleep,
1066 (!skb_queue_empty(&sk->sk_receive_queue) ||
1067 (sock->state == SS_DISCONNECTING)));
1068 lock_sock(sk);
1069 if (res)
1070 goto exit;
1071 }
1072
1073
1074
1075 buf = skb_peek(&sk->sk_receive_queue);
1076 msg = buf_msg(buf);
1077 sz = msg_data_sz(msg);
1078 err = msg_errcode(msg);
1079
1080
1081
1082 if ((!sz) && (!err)) {
1083 advance_rx_queue(sk);
1084 goto restart;
1085 }
1086
1087
1088
1089 if (sz_copied == 0) {
1090 set_orig_addr(m, msg);
1091 res = anc_data_recv(m, msg, tport);
1092 if (res)
1093 goto exit;
1094 }
1095
1096
1097
1098 if (!err) {
1099 buf_crs = (unsigned char *)(TIPC_SKB_CB(buf)->handle);
1100 sz = (unsigned char *)msg + msg_size(msg) - buf_crs;
1101
1102 needed = (buf_len - sz_copied);
1103 sz_to_copy = (sz <= needed) ? sz : needed;
1104 if (unlikely(copy_to_user(crs, buf_crs, sz_to_copy))) {
1105 res = -EFAULT;
1106 goto exit;
1107 }
1108 sz_copied += sz_to_copy;
1109
1110 if (sz_to_copy < sz) {
1111 if (!(flags & MSG_PEEK))
1112 TIPC_SKB_CB(buf)->handle = buf_crs + sz_to_copy;
1113 goto exit;
1114 }
1115
1116 crs += sz_to_copy;
1117 } else {
1118 if (sz_copied != 0)
1119 goto exit;
1120
1121 if ((err == TIPC_CONN_SHUTDOWN) || m->msg_control)
1122 res = 0;
1123 else
1124 res = -ECONNRESET;
1125 }
1126
1127
1128
1129 if (likely(!(flags & MSG_PEEK))) {
1130 if (unlikely(++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
1131 tipc_acknowledge(tport->ref, tport->conn_unacked);
1132 advance_rx_queue(sk);
1133 }
1134
1135
1136
1137 if ((sz_copied < buf_len)
1138 && (!skb_queue_empty(&sk->sk_receive_queue) ||
1139 (flags & MSG_WAITALL))
1140
1141 && (!(flags & MSG_PEEK))
1142 && (!err)
1143 )
1144 goto restart;
1145
1146exit:
1147 release_sock(sk);
1148 return sz_copied ? sz_copied : res;
1149}
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160static int rx_queue_full(struct tipc_msg *msg, u32 queue_size, u32 base)
1161{
1162 u32 threshold;
1163 u32 imp = msg_importance(msg);
1164
1165 if (imp == TIPC_LOW_IMPORTANCE)
1166 threshold = base;
1167 else if (imp == TIPC_MEDIUM_IMPORTANCE)
1168 threshold = base * 2;
1169 else if (imp == TIPC_HIGH_IMPORTANCE)
1170 threshold = base * 100;
1171 else
1172 return 0;
1173
1174 if (msg_connected(msg))
1175 threshold *= 4;
1176
1177 return (queue_size >= threshold);
1178}
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
1194{
1195 struct socket *sock = sk->sk_socket;
1196 struct tipc_msg *msg = buf_msg(buf);
1197 u32 recv_q_len;
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207 if (sock->state == SS_READY) {
1208 if (msg_connected(msg)) {
1209 msg_dbg(msg, "dispatch filter 1\n");
1210 return TIPC_ERR_NO_PORT;
1211 }
1212 } else {
1213 if (msg_mcast(msg)) {
1214 msg_dbg(msg, "dispatch filter 2\n");
1215 return TIPC_ERR_NO_PORT;
1216 }
1217 if (sock->state == SS_CONNECTED) {
1218 if (!msg_connected(msg)) {
1219 msg_dbg(msg, "dispatch filter 3\n");
1220 return TIPC_ERR_NO_PORT;
1221 }
1222 }
1223 else if (sock->state == SS_CONNECTING) {
1224 if (!msg_connected(msg) && (msg_errcode(msg) == 0)) {
1225 msg_dbg(msg, "dispatch filter 4\n");
1226 return TIPC_ERR_NO_PORT;
1227 }
1228 }
1229 else if (sock->state == SS_LISTENING) {
1230 if (msg_connected(msg) || msg_errcode(msg)) {
1231 msg_dbg(msg, "dispatch filter 5\n");
1232 return TIPC_ERR_NO_PORT;
1233 }
1234 }
1235 else if (sock->state == SS_DISCONNECTING) {
1236 msg_dbg(msg, "dispatch filter 6\n");
1237 return TIPC_ERR_NO_PORT;
1238 }
1239 else {
1240 if (msg_connected(msg) || msg_errcode(msg)) {
1241 msg_dbg(msg, "dispatch filter 7\n");
1242 return TIPC_ERR_NO_PORT;
1243 }
1244 }
1245 }
1246
1247
1248
1249 recv_q_len = (u32)atomic_read(&tipc_queue_size);
1250 if (unlikely(recv_q_len >= OVERLOAD_LIMIT_BASE)) {
1251 if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE))
1252 return TIPC_ERR_OVERLOAD;
1253 }
1254 recv_q_len = skb_queue_len(&sk->sk_receive_queue);
1255 if (unlikely(recv_q_len >= (OVERLOAD_LIMIT_BASE / 2))) {
1256 if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE / 2))
1257 return TIPC_ERR_OVERLOAD;
1258 }
1259
1260
1261
1262 msg_dbg(msg, "<DISP<: ");
1263 TIPC_SKB_CB(buf)->handle = msg_data(msg);
1264 atomic_inc(&tipc_queue_size);
1265 __skb_queue_tail(&sk->sk_receive_queue, buf);
1266
1267
1268
1269 if (unlikely(msg_errcode(msg) && (sock->state == SS_CONNECTED))) {
1270 sock->state = SS_DISCONNECTING;
1271 tipc_disconnect_port(tipc_sk_port(sk));
1272 }
1273
1274 if (waitqueue_active(sk->sk_sleep))
1275 wake_up_interruptible(sk->sk_sleep);
1276 return TIPC_OK;
1277}
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289static int backlog_rcv(struct sock *sk, struct sk_buff *buf)
1290{
1291 u32 res;
1292
1293 res = filter_rcv(sk, buf);
1294 if (res)
1295 tipc_reject_msg(buf, res);
1296 return 0;
1297}
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
1310{
1311 struct sock *sk = (struct sock *)tport->usr_handle;
1312 u32 res;
1313
1314
1315
1316
1317
1318
1319
1320
1321 bh_lock_sock(sk);
1322 if (!sock_owned_by_user(sk)) {
1323 res = filter_rcv(sk, buf);
1324 } else {
1325 sk_add_backlog(sk, buf);
1326 res = TIPC_OK;
1327 }
1328 bh_unlock_sock(sk);
1329
1330 return res;
1331}
1332
1333
1334
1335
1336
1337
1338
1339
1340static void wakeupdispatch(struct tipc_port *tport)
1341{
1342 struct sock *sk = (struct sock *)tport->usr_handle;
1343
1344 if (waitqueue_active(sk->sk_sleep))
1345 wake_up_interruptible(sk->sk_sleep);
1346}
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
1359 int flags)
1360{
1361 struct sock *sk = sock->sk;
1362 struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
1363 struct msghdr m = {NULL,};
1364 struct sk_buff *buf;
1365 struct tipc_msg *msg;
1366 int res;
1367
1368 lock_sock(sk);
1369
1370
1371
1372 if (sock->state == SS_READY) {
1373 res = -EOPNOTSUPP;
1374 goto exit;
1375 }
1376
1377
1378
1379 if (flags & O_NONBLOCK) {
1380 res = -EWOULDBLOCK;
1381 goto exit;
1382 }
1383
1384
1385
1386 if (sock->state == SS_LISTENING) {
1387 res = -EOPNOTSUPP;
1388 goto exit;
1389 }
1390 if (sock->state == SS_CONNECTING) {
1391 res = -EALREADY;
1392 goto exit;
1393 }
1394 if (sock->state != SS_UNCONNECTED) {
1395 res = -EISCONN;
1396 goto exit;
1397 }
1398
1399
1400
1401
1402
1403
1404
1405
1406 if (dst->addrtype == TIPC_ADDR_MCAST) {
1407 res = -EINVAL;
1408 goto exit;
1409 }
1410
1411
1412
1413 reject_rx_queue(sk);
1414
1415
1416
1417 m.msg_name = dest;
1418 m.msg_namelen = destlen;
1419 res = send_msg(NULL, sock, &m, 0);
1420 if (res < 0) {
1421 goto exit;
1422 }
1423
1424
1425
1426 release_sock(sk);
1427 res = wait_event_interruptible_timeout(*sk->sk_sleep,
1428 (!skb_queue_empty(&sk->sk_receive_queue) ||
1429 (sock->state != SS_CONNECTING)),
1430 sk->sk_rcvtimeo);
1431 lock_sock(sk);
1432
1433 if (res > 0) {
1434 buf = skb_peek(&sk->sk_receive_queue);
1435 if (buf != NULL) {
1436 msg = buf_msg(buf);
1437 res = auto_connect(sock, msg);
1438 if (!res) {
1439 if (!msg_data_sz(msg))
1440 advance_rx_queue(sk);
1441 }
1442 } else {
1443 if (sock->state == SS_CONNECTED) {
1444 res = -EISCONN;
1445 } else {
1446 res = -ECONNREFUSED;
1447 }
1448 }
1449 } else {
1450 if (res == 0)
1451 res = -ETIMEDOUT;
1452 else
1453 ;
1454 sock->state = SS_DISCONNECTING;
1455 }
1456
1457exit:
1458 release_sock(sk);
1459 return res;
1460}
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470static int listen(struct socket *sock, int len)
1471{
1472 struct sock *sk = sock->sk;
1473 int res;
1474
1475 lock_sock(sk);
1476
1477 if (sock->state == SS_READY)
1478 res = -EOPNOTSUPP;
1479 else if (sock->state != SS_UNCONNECTED)
1480 res = -EINVAL;
1481 else {
1482 sock->state = SS_LISTENING;
1483 res = 0;
1484 }
1485
1486 release_sock(sk);
1487 return res;
1488}
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499static int accept(struct socket *sock, struct socket *new_sock, int flags)
1500{
1501 struct sock *sk = sock->sk;
1502 struct sk_buff *buf;
1503 int res;
1504
1505 lock_sock(sk);
1506
1507 if (sock->state == SS_READY) {
1508 res = -EOPNOTSUPP;
1509 goto exit;
1510 }
1511 if (sock->state != SS_LISTENING) {
1512 res = -EINVAL;
1513 goto exit;
1514 }
1515
1516 while (skb_queue_empty(&sk->sk_receive_queue)) {
1517 if (flags & O_NONBLOCK) {
1518 res = -EWOULDBLOCK;
1519 goto exit;
1520 }
1521 release_sock(sk);
1522 res = wait_event_interruptible(*sk->sk_sleep,
1523 (!skb_queue_empty(&sk->sk_receive_queue)));
1524 lock_sock(sk);
1525 if (res)
1526 goto exit;
1527 }
1528
1529 buf = skb_peek(&sk->sk_receive_queue);
1530
1531 res = tipc_create(sock_net(sock->sk), new_sock, 0);
1532 if (!res) {
1533 struct sock *new_sk = new_sock->sk;
1534 struct tipc_sock *new_tsock = tipc_sk(new_sk);
1535 struct tipc_port *new_tport = new_tsock->p;
1536 u32 new_ref = new_tport->ref;
1537 struct tipc_msg *msg = buf_msg(buf);
1538
1539 lock_sock(new_sk);
1540
1541
1542
1543
1544
1545
1546 reject_rx_queue(new_sk);
1547
1548
1549
1550 new_tsock->peer_name.ref = msg_origport(msg);
1551 new_tsock->peer_name.node = msg_orignode(msg);
1552 tipc_connect2port(new_ref, &new_tsock->peer_name);
1553 new_sock->state = SS_CONNECTED;
1554
1555 tipc_set_portimportance(new_ref, msg_importance(msg));
1556 if (msg_named(msg)) {
1557 new_tport->conn_type = msg_nametype(msg);
1558 new_tport->conn_instance = msg_nameinst(msg);
1559 }
1560
1561
1562
1563
1564
1565
1566 msg_dbg(msg,"<ACC<: ");
1567 if (!msg_data_sz(msg)) {
1568 struct msghdr m = {NULL,};
1569
1570 advance_rx_queue(sk);
1571 send_packet(NULL, new_sock, &m, 0);
1572 } else {
1573 __skb_dequeue(&sk->sk_receive_queue);
1574 __skb_queue_head(&new_sk->sk_receive_queue, buf);
1575 }
1576 release_sock(new_sk);
1577 }
1578exit:
1579 release_sock(sk);
1580 return res;
1581}
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593static int shutdown(struct socket *sock, int how)
1594{
1595 struct sock *sk = sock->sk;
1596 struct tipc_port *tport = tipc_sk_port(sk);
1597 struct sk_buff *buf;
1598 int res;
1599
1600 if (how != SHUT_RDWR)
1601 return -EINVAL;
1602
1603 lock_sock(sk);
1604
1605 switch (sock->state) {
1606 case SS_CONNECTING:
1607 case SS_CONNECTED:
1608
1609
1610restart:
1611 buf = __skb_dequeue(&sk->sk_receive_queue);
1612 if (buf) {
1613 atomic_dec(&tipc_queue_size);
1614 if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf))) {
1615 buf_discard(buf);
1616 goto restart;
1617 }
1618 tipc_disconnect(tport->ref);
1619 tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
1620 } else {
1621 tipc_shutdown(tport->ref);
1622 }
1623
1624 sock->state = SS_DISCONNECTING;
1625
1626
1627
1628 case SS_DISCONNECTING:
1629
1630
1631
1632 discard_rx_queue(sk);
1633 if (waitqueue_active(sk->sk_sleep))
1634 wake_up_interruptible(sk->sk_sleep);
1635 res = 0;
1636 break;
1637
1638 default:
1639 res = -ENOTCONN;
1640 }
1641
1642 release_sock(sk);
1643 return res;
1644}
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660static int setsockopt(struct socket *sock,
1661 int lvl, int opt, char __user *ov, unsigned int ol)
1662{
1663 struct sock *sk = sock->sk;
1664 struct tipc_port *tport = tipc_sk_port(sk);
1665 u32 value;
1666 int res;
1667
1668 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
1669 return 0;
1670 if (lvl != SOL_TIPC)
1671 return -ENOPROTOOPT;
1672 if (ol < sizeof(value))
1673 return -EINVAL;
1674 if ((res = get_user(value, (u32 __user *)ov)))
1675 return res;
1676
1677 lock_sock(sk);
1678
1679 switch (opt) {
1680 case TIPC_IMPORTANCE:
1681 res = tipc_set_portimportance(tport->ref, value);
1682 break;
1683 case TIPC_SRC_DROPPABLE:
1684 if (sock->type != SOCK_STREAM)
1685 res = tipc_set_portunreliable(tport->ref, value);
1686 else
1687 res = -ENOPROTOOPT;
1688 break;
1689 case TIPC_DEST_DROPPABLE:
1690 res = tipc_set_portunreturnable(tport->ref, value);
1691 break;
1692 case TIPC_CONN_TIMEOUT:
1693 sk->sk_rcvtimeo = msecs_to_jiffies(value);
1694
1695 break;
1696 default:
1697 res = -EINVAL;
1698 }
1699
1700 release_sock(sk);
1701
1702 return res;
1703}
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719static int getsockopt(struct socket *sock,
1720 int lvl, int opt, char __user *ov, int __user *ol)
1721{
1722 struct sock *sk = sock->sk;
1723 struct tipc_port *tport = tipc_sk_port(sk);
1724 int len;
1725 u32 value;
1726 int res;
1727
1728 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
1729 return put_user(0, ol);
1730 if (lvl != SOL_TIPC)
1731 return -ENOPROTOOPT;
1732 if ((res = get_user(len, ol)))
1733 return res;
1734
1735 lock_sock(sk);
1736
1737 switch (opt) {
1738 case TIPC_IMPORTANCE:
1739 res = tipc_portimportance(tport->ref, &value);
1740 break;
1741 case TIPC_SRC_DROPPABLE:
1742 res = tipc_portunreliable(tport->ref, &value);
1743 break;
1744 case TIPC_DEST_DROPPABLE:
1745 res = tipc_portunreturnable(tport->ref, &value);
1746 break;
1747 case TIPC_CONN_TIMEOUT:
1748 value = jiffies_to_msecs(sk->sk_rcvtimeo);
1749
1750 break;
1751 case TIPC_NODE_RECVQ_DEPTH:
1752 value = (u32)atomic_read(&tipc_queue_size);
1753 break;
1754 case TIPC_SOCK_RECVQ_DEPTH:
1755 value = skb_queue_len(&sk->sk_receive_queue);
1756 break;
1757 default:
1758 res = -EINVAL;
1759 }
1760
1761 release_sock(sk);
1762
1763 if (res) {
1764
1765 }
1766 else if (len < sizeof(value)) {
1767 res = -EINVAL;
1768 }
1769 else if (copy_to_user(ov, &value, sizeof(value))) {
1770 res = -EFAULT;
1771 }
1772 else {
1773 res = put_user(sizeof(value), ol);
1774 }
1775
1776 return res;
1777}
1778
1779
1780
1781
1782
1783static const struct proto_ops msg_ops = {
1784 .owner = THIS_MODULE,
1785 .family = AF_TIPC,
1786 .release = release,
1787 .bind = bind,
1788 .connect = connect,
1789 .socketpair = sock_no_socketpair,
1790 .accept = accept,
1791 .getname = get_name,
1792 .poll = poll,
1793 .ioctl = sock_no_ioctl,
1794 .listen = listen,
1795 .shutdown = shutdown,
1796 .setsockopt = setsockopt,
1797 .getsockopt = getsockopt,
1798 .sendmsg = send_msg,
1799 .recvmsg = recv_msg,
1800 .mmap = sock_no_mmap,
1801 .sendpage = sock_no_sendpage
1802};
1803
1804static const struct proto_ops packet_ops = {
1805 .owner = THIS_MODULE,
1806 .family = AF_TIPC,
1807 .release = release,
1808 .bind = bind,
1809 .connect = connect,
1810 .socketpair = sock_no_socketpair,
1811 .accept = accept,
1812 .getname = get_name,
1813 .poll = poll,
1814 .ioctl = sock_no_ioctl,
1815 .listen = listen,
1816 .shutdown = shutdown,
1817 .setsockopt = setsockopt,
1818 .getsockopt = getsockopt,
1819 .sendmsg = send_packet,
1820 .recvmsg = recv_msg,
1821 .mmap = sock_no_mmap,
1822 .sendpage = sock_no_sendpage
1823};
1824
1825static const struct proto_ops stream_ops = {
1826 .owner = THIS_MODULE,
1827 .family = AF_TIPC,
1828 .release = release,
1829 .bind = bind,
1830 .connect = connect,
1831 .socketpair = sock_no_socketpair,
1832 .accept = accept,
1833 .getname = get_name,
1834 .poll = poll,
1835 .ioctl = sock_no_ioctl,
1836 .listen = listen,
1837 .shutdown = shutdown,
1838 .setsockopt = setsockopt,
1839 .getsockopt = getsockopt,
1840 .sendmsg = send_stream,
1841 .recvmsg = recv_stream,
1842 .mmap = sock_no_mmap,
1843 .sendpage = sock_no_sendpage
1844};
1845
1846static const struct net_proto_family tipc_family_ops = {
1847 .owner = THIS_MODULE,
1848 .family = AF_TIPC,
1849 .create = tipc_create
1850};
1851
1852static struct proto tipc_proto = {
1853 .name = "TIPC",
1854 .owner = THIS_MODULE,
1855 .obj_size = sizeof(struct tipc_sock)
1856};
1857
1858
1859
1860
1861
1862
1863int tipc_socket_init(void)
1864{
1865 int res;
1866
1867 res = proto_register(&tipc_proto, 1);
1868 if (res) {
1869 err("Failed to register TIPC protocol type\n");
1870 goto out;
1871 }
1872
1873 res = sock_register(&tipc_family_ops);
1874 if (res) {
1875 err("Failed to register TIPC socket type\n");
1876 proto_unregister(&tipc_proto);
1877 goto out;
1878 }
1879
1880 sockets_enabled = 1;
1881 out:
1882 return res;
1883}
1884
1885
1886
1887
1888
1889void tipc_socket_stop(void)
1890{
1891 if (!sockets_enabled)
1892 return;
1893
1894 sockets_enabled = 0;
1895 sock_unregister(tipc_family_ops.family);
1896 proto_unregister(&tipc_proto);
1897}
1898
1899