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