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