2 * net/tipc/socket.c: TIPC socket API
4 * Copyright (c) 2001-2007, 2012 Ericsson AB
5 * Copyright (c) 2004-2008, 2010-2012, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
40 #include <linux/export.h>
43 #define SS_LISTENING -1 /* socket is listening */
44 #define SS_READY -2 /* socket is connectionless */
46 #define OVERLOAD_LIMIT_BASE 10000
47 #define CONN_TIMEOUT_DEFAULT 8000 /* default connect timeout = 8s */
52 struct tipc_portid peer_name
;
53 unsigned int conn_timeout
;
56 #define tipc_sk(sk) ((struct tipc_sock *)(sk))
57 #define tipc_sk_port(sk) (tipc_sk(sk)->p)
59 #define tipc_rx_ready(sock) (!skb_queue_empty(&sock->sk->sk_receive_queue) || \
60 (sock->state == SS_DISCONNECTING))
62 static int backlog_rcv(struct sock
*sk
, struct sk_buff
*skb
);
63 static u32
dispatch(struct tipc_port
*tport
, struct sk_buff
*buf
);
64 static void wakeupdispatch(struct tipc_port
*tport
);
65 static void tipc_data_ready(struct sock
*sk
, int len
);
66 static void tipc_write_space(struct sock
*sk
);
68 static const struct proto_ops packet_ops
;
69 static const struct proto_ops stream_ops
;
70 static const struct proto_ops msg_ops
;
72 static struct proto tipc_proto
;
74 static int sockets_enabled
;
77 * Revised TIPC socket locking policy:
79 * Most socket operations take the standard socket lock when they start
80 * and hold it until they finish (or until they need to sleep). Acquiring
81 * this lock grants the owner exclusive access to the fields of the socket
82 * data structures, with the exception of the backlog queue. A few socket
83 * operations can be done without taking the socket lock because they only
84 * read socket information that never changes during the life of the socket.
86 * Socket operations may acquire the lock for the associated TIPC port if they
87 * need to perform an operation on the port. If any routine needs to acquire
88 * both the socket lock and the port lock it must take the socket lock first
89 * to avoid the risk of deadlock.
91 * The dispatcher handling incoming messages cannot grab the socket lock in
92 * the standard fashion, since invoked it runs at the BH level and cannot block.
93 * Instead, it checks to see if the socket lock is currently owned by someone,
94 * and either handles the message itself or adds it to the socket's backlog
95 * queue; in the latter case the queued message is processed once the process
96 * owning the socket lock releases it.
98 * NOTE: Releasing the socket lock while an operation is sleeping overcomes
99 * the problem of a blocked socket operation preventing any other operations
100 * from occurring. However, applications must be careful if they have
101 * multiple threads trying to send (or receive) on the same socket, as these
102 * operations might interfere with each other. For example, doing a connect
103 * and a receive at the same time might allow the receive to consume the
104 * ACK message meant for the connect. While additional work could be done
105 * to try and overcome this, it doesn't seem to be worthwhile at the present.
107 * NOTE: Releasing the socket lock while an operation is sleeping also ensures
108 * that another operation that must be performed in a non-blocking manner is
109 * not delayed for very long because the lock has already been taken.
111 * NOTE: This code assumes that certain fields of a port/socket pair are
112 * constant over its lifetime; such fields can be examined without taking
113 * the socket lock and/or port lock, and do not need to be re-read even
114 * after resuming processing after waiting. These fields include:
116 * - pointer to socket sk structure (aka tipc_sock structure)
117 * - pointer to port structure
122 * advance_rx_queue - discard first buffer in socket receive queue
124 * Caller must hold socket lock
126 static void advance_rx_queue(struct sock
*sk
)
128 kfree_skb(__skb_dequeue(&sk
->sk_receive_queue
));
132 * discard_rx_queue - discard all buffers in socket receive queue
134 * Caller must hold socket lock
136 static void discard_rx_queue(struct sock
*sk
)
140 while ((buf
= __skb_dequeue(&sk
->sk_receive_queue
)))
145 * reject_rx_queue - reject all buffers in socket receive queue
147 * Caller must hold socket lock
149 static void reject_rx_queue(struct sock
*sk
)
153 while ((buf
= __skb_dequeue(&sk
->sk_receive_queue
)))
154 tipc_reject_msg(buf
, TIPC_ERR_NO_PORT
);
158 * tipc_create - create a TIPC socket
159 * @net: network namespace (must be default network)
160 * @sock: pre-allocated socket structure
161 * @protocol: protocol indicator (must be 0)
162 * @kern: caused by kernel or by userspace?
164 * This routine creates additional data structures used by the TIPC socket,
165 * initializes them, and links them together.
167 * Returns 0 on success, errno otherwise
169 static int tipc_create(struct net
*net
, struct socket
*sock
, int protocol
,
172 const struct proto_ops
*ops
;
175 struct tipc_port
*tp_ptr
;
177 /* Validate arguments */
178 if (unlikely(protocol
!= 0))
179 return -EPROTONOSUPPORT
;
181 switch (sock
->type
) {
184 state
= SS_UNCONNECTED
;
188 state
= SS_UNCONNECTED
;
199 /* Allocate socket's protocol area */
200 sk
= sk_alloc(net
, AF_TIPC
, GFP_KERNEL
, &tipc_proto
);
204 /* Allocate TIPC port for socket to use */
205 tp_ptr
= tipc_createport_raw(sk
, &dispatch
, &wakeupdispatch
,
206 TIPC_LOW_IMPORTANCE
);
207 if (unlikely(!tp_ptr
)) {
212 /* Finish initializing socket data structures */
216 sock_init_data(sock
, sk
);
217 sk
->sk_backlog_rcv
= backlog_rcv
;
218 sk
->sk_rcvbuf
= TIPC_FLOW_CONTROL_WIN
* 2 * TIPC_MAX_USER_MSG_SIZE
* 2;
219 sk
->sk_data_ready
= tipc_data_ready
;
220 sk
->sk_write_space
= tipc_write_space
;
221 tipc_sk(sk
)->p
= tp_ptr
;
222 tipc_sk(sk
)->conn_timeout
= CONN_TIMEOUT_DEFAULT
;
224 spin_unlock_bh(tp_ptr
->lock
);
226 if (sock
->state
== SS_READY
) {
227 tipc_set_portunreturnable(tp_ptr
->ref
, 1);
228 if (sock
->type
== SOCK_DGRAM
)
229 tipc_set_portunreliable(tp_ptr
->ref
, 1);
236 * release - destroy a TIPC socket
237 * @sock: socket to destroy
239 * This routine cleans up any messages that are still queued on the socket.
240 * For DGRAM and RDM socket types, all queued messages are rejected.
241 * For SEQPACKET and STREAM socket types, the first message is rejected
242 * and any others are discarded. (If the first message on a STREAM socket
243 * is partially-read, it is discarded and the next one is rejected instead.)
245 * NOTE: Rejected messages are not necessarily returned to the sender! They
246 * are returned or discarded according to the "destination droppable" setting
247 * specified for the message by the sender.
249 * Returns 0 on success, errno otherwise
251 static int release(struct socket
*sock
)
253 struct sock
*sk
= sock
->sk
;
254 struct tipc_port
*tport
;
259 * Exit if socket isn't fully initialized (occurs when a failed accept()
260 * releases a pre-allocated child socket that was never used)
265 tport
= tipc_sk_port(sk
);
269 * Reject all unreceived messages, except on an active connection
270 * (which disconnects locally & sends a 'FIN+' to peer)
272 while (sock
->state
!= SS_DISCONNECTING
) {
273 buf
= __skb_dequeue(&sk
->sk_receive_queue
);
276 if (TIPC_SKB_CB(buf
)->handle
!= 0)
279 if ((sock
->state
== SS_CONNECTING
) ||
280 (sock
->state
== SS_CONNECTED
)) {
281 sock
->state
= SS_DISCONNECTING
;
282 tipc_disconnect(tport
->ref
);
284 tipc_reject_msg(buf
, TIPC_ERR_NO_PORT
);
289 * Delete TIPC port; this ensures no more messages are queued
290 * (also disconnects an active connection & sends a 'FIN-' to peer)
292 res
= tipc_deleteport(tport
->ref
);
294 /* Discard any remaining (connection-based) messages in receive queue */
295 discard_rx_queue(sk
);
297 /* Reject any messages that accumulated in backlog queue */
298 sock
->state
= SS_DISCONNECTING
;
308 * bind - associate or disassocate TIPC name(s) with a socket
309 * @sock: socket structure
310 * @uaddr: socket address describing name(s) and desired operation
311 * @uaddr_len: size of socket address data structure
313 * Name and name sequence binding is indicated using a positive scope value;
314 * a negative scope value unbinds the specified name. Specifying no name
315 * (i.e. a socket address length of 0) unbinds all names from the socket.
317 * Returns 0 on success, errno otherwise
319 * NOTE: This routine doesn't need to take the socket lock since it doesn't
320 * access any non-constant socket information.
322 static int bind(struct socket
*sock
, struct sockaddr
*uaddr
, int uaddr_len
)
324 struct sockaddr_tipc
*addr
= (struct sockaddr_tipc
*)uaddr
;
325 u32 portref
= tipc_sk_port(sock
->sk
)->ref
;
327 if (unlikely(!uaddr_len
))
328 return tipc_withdraw(portref
, 0, NULL
);
330 if (uaddr_len
< sizeof(struct sockaddr_tipc
))
332 if (addr
->family
!= AF_TIPC
)
333 return -EAFNOSUPPORT
;
335 if (addr
->addrtype
== TIPC_ADDR_NAME
)
336 addr
->addr
.nameseq
.upper
= addr
->addr
.nameseq
.lower
;
337 else if (addr
->addrtype
!= TIPC_ADDR_NAMESEQ
)
338 return -EAFNOSUPPORT
;
340 if (addr
->addr
.nameseq
.type
< TIPC_RESERVED_TYPES
)
343 return (addr
->scope
> 0) ?
344 tipc_publish(portref
, addr
->scope
, &addr
->addr
.nameseq
) :
345 tipc_withdraw(portref
, -addr
->scope
, &addr
->addr
.nameseq
);
349 * get_name - get port ID of socket or peer socket
350 * @sock: socket structure
351 * @uaddr: area for returned socket address
352 * @uaddr_len: area for returned length of socket address
353 * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID
355 * Returns 0 on success, errno otherwise
357 * NOTE: This routine doesn't need to take the socket lock since it only
358 * accesses socket information that is unchanging (or which changes in
359 * a completely predictable manner).
361 static int get_name(struct socket
*sock
, struct sockaddr
*uaddr
,
362 int *uaddr_len
, int peer
)
364 struct sockaddr_tipc
*addr
= (struct sockaddr_tipc
*)uaddr
;
365 struct tipc_sock
*tsock
= tipc_sk(sock
->sk
);
367 memset(addr
, 0, sizeof(*addr
));
369 if ((sock
->state
!= SS_CONNECTED
) &&
370 ((peer
!= 2) || (sock
->state
!= SS_DISCONNECTING
)))
372 addr
->addr
.id
.ref
= tsock
->peer_name
.ref
;
373 addr
->addr
.id
.node
= tsock
->peer_name
.node
;
375 addr
->addr
.id
.ref
= tsock
->p
->ref
;
376 addr
->addr
.id
.node
= tipc_own_addr
;
379 *uaddr_len
= sizeof(*addr
);
380 addr
->addrtype
= TIPC_ADDR_ID
;
381 addr
->family
= AF_TIPC
;
383 addr
->addr
.name
.domain
= 0;
389 * poll - read and possibly block on pollmask
390 * @file: file structure associated with the socket
391 * @sock: socket for which to calculate the poll bits
394 * Returns pollmask value
397 * It appears that the usual socket locking mechanisms are not useful here
398 * since the pollmask info is potentially out-of-date the moment this routine
399 * exits. TCP and other protocols seem to rely on higher level poll routines
400 * to handle any preventable race conditions, so TIPC will do the same ...
402 * TIPC sets the returned events as follows:
404 * socket state flags set
405 * ------------ ---------
406 * unconnected no read flags
407 * POLLOUT if port is not congested
409 * connecting POLLIN/POLLRDNORM if ACK/NACK in rx queue
412 * connected POLLIN/POLLRDNORM if data in rx queue
413 * POLLOUT if port is not congested
415 * disconnecting POLLIN/POLLRDNORM/POLLHUP
418 * listening POLLIN if SYN in rx queue
421 * ready POLLIN/POLLRDNORM if data in rx queue
422 * [connectionless] POLLOUT (since port cannot be congested)
424 * IMPORTANT: The fact that a read or write operation is indicated does NOT
425 * imply that the operation will succeed, merely that it should be performed
426 * and will not block.
428 static unsigned int poll(struct file
*file
, struct socket
*sock
,
431 struct sock
*sk
= sock
->sk
;
434 sock_poll_wait(file
, sk_sleep(sk
), wait
);
436 switch ((int)sock
->state
) {
438 if (!tipc_sk_port(sk
)->congested
)
443 if (!tipc_sk_port(sk
)->congested
)
448 if (!skb_queue_empty(&sk
->sk_receive_queue
))
449 mask
|= (POLLIN
| POLLRDNORM
);
451 case SS_DISCONNECTING
:
452 mask
= (POLLIN
| POLLRDNORM
| POLLHUP
);
460 * dest_name_check - verify user is permitted to send to specified port name
461 * @dest: destination address
462 * @m: descriptor for message to be sent
464 * Prevents restricted configuration commands from being issued by
465 * unauthorized users.
467 * Returns 0 if permission is granted, otherwise errno
469 static int dest_name_check(struct sockaddr_tipc
*dest
, struct msghdr
*m
)
471 struct tipc_cfg_msg_hdr hdr
;
473 if (likely(dest
->addr
.name
.name
.type
>= TIPC_RESERVED_TYPES
))
475 if (likely(dest
->addr
.name
.name
.type
== TIPC_TOP_SRV
))
477 if (likely(dest
->addr
.name
.name
.type
!= TIPC_CFG_SRV
))
480 if (!m
->msg_iovlen
|| (m
->msg_iov
[0].iov_len
< sizeof(hdr
)))
482 if (copy_from_user(&hdr
, m
->msg_iov
[0].iov_base
, sizeof(hdr
)))
484 if ((ntohs(hdr
.tcm_type
) & 0xC000) && (!capable(CAP_NET_ADMIN
)))
491 * send_msg - send message in connectionless manner
492 * @iocb: if NULL, indicates that socket lock is already held
493 * @sock: socket structure
494 * @m: message to send
495 * @total_len: length of message
497 * Message must have an destination specified explicitly.
498 * Used for SOCK_RDM and SOCK_DGRAM messages,
499 * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
500 * (Note: 'SYN+' is prohibited on SOCK_STREAM.)
502 * Returns the number of bytes sent on success, or errno otherwise
504 static int send_msg(struct kiocb
*iocb
, struct socket
*sock
,
505 struct msghdr
*m
, size_t total_len
)
507 struct sock
*sk
= sock
->sk
;
508 struct tipc_port
*tport
= tipc_sk_port(sk
);
509 struct sockaddr_tipc
*dest
= (struct sockaddr_tipc
*)m
->msg_name
;
515 return -EDESTADDRREQ
;
516 if (unlikely((m
->msg_namelen
< sizeof(*dest
)) ||
517 (dest
->family
!= AF_TIPC
)))
519 if ((total_len
> TIPC_MAX_USER_MSG_SIZE
) ||
520 (m
->msg_iovlen
> (unsigned int)INT_MAX
))
526 needs_conn
= (sock
->state
!= SS_READY
);
527 if (unlikely(needs_conn
)) {
528 if (sock
->state
== SS_LISTENING
) {
532 if (sock
->state
!= SS_UNCONNECTED
) {
536 if ((tport
->published
) ||
537 ((sock
->type
== SOCK_STREAM
) && (total_len
!= 0))) {
541 if (dest
->addrtype
== TIPC_ADDR_NAME
) {
542 tport
->conn_type
= dest
->addr
.name
.name
.type
;
543 tport
->conn_instance
= dest
->addr
.name
.name
.instance
;
546 /* Abort any pending connection attempts (very unlikely) */
550 timeout_val
= sock_sndtimeo(sk
, m
->msg_flags
& MSG_DONTWAIT
);
553 if (dest
->addrtype
== TIPC_ADDR_NAME
) {
554 res
= dest_name_check(dest
, m
);
557 res
= tipc_send2name(tport
->ref
,
558 &dest
->addr
.name
.name
,
559 dest
->addr
.name
.domain
,
563 } else if (dest
->addrtype
== TIPC_ADDR_ID
) {
564 res
= tipc_send2port(tport
->ref
,
569 } else if (dest
->addrtype
== TIPC_ADDR_MCAST
) {
574 res
= dest_name_check(dest
, m
);
577 res
= tipc_multicast(tport
->ref
,
583 if (likely(res
!= -ELINKCONG
)) {
584 if (needs_conn
&& (res
>= 0))
585 sock
->state
= SS_CONNECTING
;
588 if (timeout_val
<= 0L) {
589 res
= timeout_val
? timeout_val
: -EWOULDBLOCK
;
593 timeout_val
= wait_event_interruptible_timeout(*sk_sleep(sk
),
594 !tport
->congested
, timeout_val
);
605 * send_packet - send a connection-oriented message
606 * @iocb: if NULL, indicates that socket lock is already held
607 * @sock: socket structure
608 * @m: message to send
609 * @total_len: length of message
611 * Used for SOCK_SEQPACKET messages and SOCK_STREAM data.
613 * Returns the number of bytes sent on success, or errno otherwise
615 static int send_packet(struct kiocb
*iocb
, struct socket
*sock
,
616 struct msghdr
*m
, size_t total_len
)
618 struct sock
*sk
= sock
->sk
;
619 struct tipc_port
*tport
= tipc_sk_port(sk
);
620 struct sockaddr_tipc
*dest
= (struct sockaddr_tipc
*)m
->msg_name
;
624 /* Handle implied connection establishment */
626 return send_msg(iocb
, sock
, m
, total_len
);
628 if ((total_len
> TIPC_MAX_USER_MSG_SIZE
) ||
629 (m
->msg_iovlen
> (unsigned int)INT_MAX
))
635 timeout_val
= sock_sndtimeo(sk
, m
->msg_flags
& MSG_DONTWAIT
);
638 if (unlikely(sock
->state
!= SS_CONNECTED
)) {
639 if (sock
->state
== SS_DISCONNECTING
)
646 res
= tipc_send(tport
->ref
, m
->msg_iovlen
, m
->msg_iov
,
648 if (likely(res
!= -ELINKCONG
))
650 if (timeout_val
<= 0L) {
651 res
= timeout_val
? timeout_val
: -EWOULDBLOCK
;
655 timeout_val
= wait_event_interruptible_timeout(*sk_sleep(sk
),
656 (!tport
->congested
|| !tport
->connected
), timeout_val
);
666 * send_stream - send stream-oriented data
668 * @sock: socket structure
670 * @total_len: total length of data to be sent
672 * Used for SOCK_STREAM data.
674 * Returns the number of bytes sent on success (or partial success),
675 * or errno if no data sent
677 static int send_stream(struct kiocb
*iocb
, struct socket
*sock
,
678 struct msghdr
*m
, size_t total_len
)
680 struct sock
*sk
= sock
->sk
;
681 struct tipc_port
*tport
= tipc_sk_port(sk
);
682 struct msghdr my_msg
;
684 struct iovec
*curr_iov
;
686 char __user
*curr_start
;
695 /* Handle special cases where there is no connection */
696 if (unlikely(sock
->state
!= SS_CONNECTED
)) {
697 if (sock
->state
== SS_UNCONNECTED
) {
698 res
= send_packet(NULL
, sock
, m
, total_len
);
700 } else if (sock
->state
== SS_DISCONNECTING
) {
709 if (unlikely(m
->msg_name
)) {
714 if ((total_len
> (unsigned int)INT_MAX
) ||
715 (m
->msg_iovlen
> (unsigned int)INT_MAX
)) {
721 * Send each iovec entry using one or more messages
723 * Note: This algorithm is good for the most likely case
724 * (i.e. one large iovec entry), but could be improved to pass sets
725 * of small iovec entries into send_packet().
727 curr_iov
= m
->msg_iov
;
728 curr_iovlen
= m
->msg_iovlen
;
729 my_msg
.msg_iov
= &my_iov
;
730 my_msg
.msg_iovlen
= 1;
731 my_msg
.msg_flags
= m
->msg_flags
;
732 my_msg
.msg_name
= NULL
;
735 hdr_size
= msg_hdr_sz(&tport
->phdr
);
737 while (curr_iovlen
--) {
738 curr_start
= curr_iov
->iov_base
;
739 curr_left
= curr_iov
->iov_len
;
742 bytes_to_send
= tport
->max_pkt
- hdr_size
;
743 if (bytes_to_send
> TIPC_MAX_USER_MSG_SIZE
)
744 bytes_to_send
= TIPC_MAX_USER_MSG_SIZE
;
745 if (curr_left
< bytes_to_send
)
746 bytes_to_send
= curr_left
;
747 my_iov
.iov_base
= curr_start
;
748 my_iov
.iov_len
= bytes_to_send
;
749 res
= send_packet(NULL
, sock
, &my_msg
, bytes_to_send
);
755 curr_left
-= bytes_to_send
;
756 curr_start
+= bytes_to_send
;
757 bytes_sent
+= bytes_to_send
;
769 * auto_connect - complete connection setup to a remote port
770 * @sock: socket structure
771 * @msg: peer's response message
773 * Returns 0 on success, errno otherwise
775 static int auto_connect(struct socket
*sock
, struct tipc_msg
*msg
)
777 struct tipc_sock
*tsock
= tipc_sk(sock
->sk
);
778 struct tipc_port
*p_ptr
;
780 tsock
->peer_name
.ref
= msg_origport(msg
);
781 tsock
->peer_name
.node
= msg_orignode(msg
);
782 p_ptr
= tipc_port_deref(tsock
->p
->ref
);
786 __tipc_connect(tsock
->p
->ref
, p_ptr
, &tsock
->peer_name
);
788 if (msg_importance(msg
) > TIPC_CRITICAL_IMPORTANCE
)
790 msg_set_importance(&p_ptr
->phdr
, (u32
)msg_importance(msg
));
791 sock
->state
= SS_CONNECTED
;
796 * set_orig_addr - capture sender's address for received message
797 * @m: descriptor for message info
798 * @msg: received message header
800 * Note: Address is not captured if not requested by receiver.
802 static void set_orig_addr(struct msghdr
*m
, struct tipc_msg
*msg
)
804 struct sockaddr_tipc
*addr
= (struct sockaddr_tipc
*)m
->msg_name
;
807 addr
->family
= AF_TIPC
;
808 addr
->addrtype
= TIPC_ADDR_ID
;
809 addr
->addr
.id
.ref
= msg_origport(msg
);
810 addr
->addr
.id
.node
= msg_orignode(msg
);
811 addr
->addr
.name
.domain
= 0; /* could leave uninitialized */
812 addr
->scope
= 0; /* could leave uninitialized */
813 m
->msg_namelen
= sizeof(struct sockaddr_tipc
);
818 * anc_data_recv - optionally capture ancillary data for received message
819 * @m: descriptor for message info
820 * @msg: received message header
821 * @tport: TIPC port associated with message
823 * Note: Ancillary data is not captured if not requested by receiver.
825 * Returns 0 if successful, otherwise errno
827 static int anc_data_recv(struct msghdr
*m
, struct tipc_msg
*msg
,
828 struct tipc_port
*tport
)
836 if (likely(m
->msg_controllen
== 0))
839 /* Optionally capture errored message object(s) */
840 err
= msg
? msg_errcode(msg
) : 0;
843 anc_data
[1] = msg_data_sz(msg
);
844 res
= put_cmsg(m
, SOL_TIPC
, TIPC_ERRINFO
, 8, anc_data
);
848 res
= put_cmsg(m
, SOL_TIPC
, TIPC_RETDATA
, anc_data
[1],
855 /* Optionally capture message destination object */
856 dest_type
= msg
? msg_type(msg
) : TIPC_DIRECT_MSG
;
860 anc_data
[0] = msg_nametype(msg
);
861 anc_data
[1] = msg_namelower(msg
);
862 anc_data
[2] = msg_namelower(msg
);
866 anc_data
[0] = msg_nametype(msg
);
867 anc_data
[1] = msg_namelower(msg
);
868 anc_data
[2] = msg_nameupper(msg
);
871 has_name
= (tport
->conn_type
!= 0);
872 anc_data
[0] = tport
->conn_type
;
873 anc_data
[1] = tport
->conn_instance
;
874 anc_data
[2] = tport
->conn_instance
;
880 res
= put_cmsg(m
, SOL_TIPC
, TIPC_DESTNAME
, 12, anc_data
);
889 * recv_msg - receive packet-oriented message
891 * @m: descriptor for message info
892 * @buf_len: total size of user buffer area
893 * @flags: receive flags
895 * Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.
896 * If the complete message doesn't fit in user area, truncate it.
898 * Returns size of returned message data, errno otherwise
900 static int recv_msg(struct kiocb
*iocb
, struct socket
*sock
,
901 struct msghdr
*m
, size_t buf_len
, int flags
)
903 struct sock
*sk
= sock
->sk
;
904 struct tipc_port
*tport
= tipc_sk_port(sk
);
906 struct tipc_msg
*msg
;
912 /* Catch invalid receive requests */
913 if (unlikely(!buf_len
))
918 if (unlikely(sock
->state
== SS_UNCONNECTED
)) {
923 timeout
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
926 /* Look for a message in receive queue; wait if necessary */
927 while (skb_queue_empty(&sk
->sk_receive_queue
)) {
928 if (sock
->state
== SS_DISCONNECTING
) {
933 res
= timeout
? timeout
: -EWOULDBLOCK
;
937 timeout
= wait_event_interruptible_timeout(*sk_sleep(sk
),
943 /* Look at first message in receive queue */
944 buf
= skb_peek(&sk
->sk_receive_queue
);
946 sz
= msg_data_sz(msg
);
947 err
= msg_errcode(msg
);
949 /* Discard an empty non-errored message & try again */
950 if ((!sz
) && (!err
)) {
951 advance_rx_queue(sk
);
955 /* Capture sender's address (optional) */
956 set_orig_addr(m
, msg
);
958 /* Capture ancillary data (optional) */
959 res
= anc_data_recv(m
, msg
, tport
);
963 /* Capture message data (if valid) & compute return value (always) */
965 if (unlikely(buf_len
< sz
)) {
967 m
->msg_flags
|= MSG_TRUNC
;
969 res
= skb_copy_datagram_iovec(buf
, msg_hdr_sz(msg
),
975 if ((sock
->state
== SS_READY
) ||
976 ((err
== TIPC_CONN_SHUTDOWN
) || m
->msg_control
))
982 /* Consume received message (optional) */
983 if (likely(!(flags
& MSG_PEEK
))) {
984 if ((sock
->state
!= SS_READY
) &&
985 (++tport
->conn_unacked
>= TIPC_FLOW_CONTROL_WIN
))
986 tipc_acknowledge(tport
->ref
, tport
->conn_unacked
);
987 advance_rx_queue(sk
);
995 * recv_stream - receive stream-oriented data
997 * @m: descriptor for message info
998 * @buf_len: total size of user buffer area
999 * @flags: receive flags
1001 * Used for SOCK_STREAM messages only. If not enough data is available
1002 * will optionally wait for more; never truncates data.
1004 * Returns size of returned message data, errno otherwise
1006 static int recv_stream(struct kiocb
*iocb
, struct socket
*sock
,
1007 struct msghdr
*m
, size_t buf_len
, int flags
)
1009 struct sock
*sk
= sock
->sk
;
1010 struct tipc_port
*tport
= tipc_sk_port(sk
);
1011 struct sk_buff
*buf
;
1012 struct tipc_msg
*msg
;
1015 int sz_to_copy
, target
, needed
;
1020 /* Catch invalid receive attempts */
1021 if (unlikely(!buf_len
))
1026 if (unlikely((sock
->state
== SS_UNCONNECTED
) ||
1027 (sock
->state
== SS_CONNECTING
))) {
1032 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, buf_len
);
1033 timeout
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
1036 /* Look for a message in receive queue; wait if necessary */
1037 while (skb_queue_empty(&sk
->sk_receive_queue
)) {
1038 if (sock
->state
== SS_DISCONNECTING
) {
1042 if (timeout
<= 0L) {
1043 res
= timeout
? timeout
: -EWOULDBLOCK
;
1047 timeout
= wait_event_interruptible_timeout(*sk_sleep(sk
),
1048 tipc_rx_ready(sock
),
1053 /* Look at first message in receive queue */
1054 buf
= skb_peek(&sk
->sk_receive_queue
);
1056 sz
= msg_data_sz(msg
);
1057 err
= msg_errcode(msg
);
1059 /* Discard an empty non-errored message & try again */
1060 if ((!sz
) && (!err
)) {
1061 advance_rx_queue(sk
);
1065 /* Optionally capture sender's address & ancillary data of first msg */
1066 if (sz_copied
== 0) {
1067 set_orig_addr(m
, msg
);
1068 res
= anc_data_recv(m
, msg
, tport
);
1073 /* Capture message data (if valid) & compute return value (always) */
1075 u32 offset
= (u32
)(unsigned long)(TIPC_SKB_CB(buf
)->handle
);
1078 needed
= (buf_len
- sz_copied
);
1079 sz_to_copy
= (sz
<= needed
) ? sz
: needed
;
1081 res
= skb_copy_datagram_iovec(buf
, msg_hdr_sz(msg
) + offset
,
1082 m
->msg_iov
, sz_to_copy
);
1086 sz_copied
+= sz_to_copy
;
1088 if (sz_to_copy
< sz
) {
1089 if (!(flags
& MSG_PEEK
))
1090 TIPC_SKB_CB(buf
)->handle
=
1091 (void *)(unsigned long)(offset
+ sz_to_copy
);
1096 goto exit
; /* can't add error msg to valid data */
1098 if ((err
== TIPC_CONN_SHUTDOWN
) || m
->msg_control
)
1104 /* Consume received message (optional) */
1105 if (likely(!(flags
& MSG_PEEK
))) {
1106 if (unlikely(++tport
->conn_unacked
>= TIPC_FLOW_CONTROL_WIN
))
1107 tipc_acknowledge(tport
->ref
, tport
->conn_unacked
);
1108 advance_rx_queue(sk
);
1111 /* Loop around if more data is required */
1112 if ((sz_copied
< buf_len
) && /* didn't get all requested data */
1113 (!skb_queue_empty(&sk
->sk_receive_queue
) ||
1114 (sz_copied
< target
)) && /* and more is ready or required */
1115 (!(flags
& MSG_PEEK
)) && /* and aren't just peeking at data */
1116 (!err
)) /* and haven't reached a FIN */
1121 return sz_copied
? sz_copied
: res
;
1125 * tipc_write_space - wake up thread if port congestion is released
1128 static void tipc_write_space(struct sock
*sk
)
1130 struct socket_wq
*wq
;
1133 wq
= rcu_dereference(sk
->sk_wq
);
1134 if (wq_has_sleeper(wq
))
1135 wake_up_interruptible_sync_poll(&wq
->wait
, POLLOUT
|
1136 POLLWRNORM
| POLLWRBAND
);
1141 * tipc_data_ready - wake up threads to indicate messages have been received
1143 * @len: the length of messages
1145 static void tipc_data_ready(struct sock
*sk
, int len
)
1147 struct socket_wq
*wq
;
1150 wq
= rcu_dereference(sk
->sk_wq
);
1151 if (wq_has_sleeper(wq
))
1152 wake_up_interruptible_sync_poll(&wq
->wait
, POLLIN
|
1153 POLLRDNORM
| POLLRDBAND
);
1158 * rx_queue_full - determine if receive queue can accept another message
1159 * @msg: message to be added to queue
1160 * @queue_size: current size of queue
1161 * @base: nominal maximum size of queue
1163 * Returns 1 if queue is unable to accept message, 0 otherwise
1165 static int rx_queue_full(struct tipc_msg
*msg
, u32 queue_size
, u32 base
)
1168 u32 imp
= msg_importance(msg
);
1170 if (imp
== TIPC_LOW_IMPORTANCE
)
1172 else if (imp
== TIPC_MEDIUM_IMPORTANCE
)
1173 threshold
= base
* 2;
1174 else if (imp
== TIPC_HIGH_IMPORTANCE
)
1175 threshold
= base
* 100;
1179 if (msg_connected(msg
))
1182 return queue_size
>= threshold
;
1186 * filter_connect - Handle all incoming messages for a connection-based socket
1187 * @tsock: TIPC socket
1190 * Returns TIPC error status code and socket error status code
1191 * once it encounters some errors
1193 static u32
filter_connect(struct tipc_sock
*tsock
, struct sk_buff
**buf
)
1195 struct socket
*sock
= tsock
->sk
.sk_socket
;
1196 struct tipc_msg
*msg
= buf_msg(*buf
);
1197 struct sock
*sk
= &tsock
->sk
;
1198 u32 retval
= TIPC_ERR_NO_PORT
;
1204 switch ((int)sock
->state
) {
1206 /* Accept only connection-based messages sent by peer */
1207 if (msg_connected(msg
) && tipc_port_peer_msg(tsock
->p
, msg
)) {
1208 if (unlikely(msg_errcode(msg
))) {
1209 sock
->state
= SS_DISCONNECTING
;
1210 __tipc_disconnect(tsock
->p
);
1216 /* Accept only ACK or NACK message */
1217 if (unlikely(msg_errcode(msg
))) {
1218 sock
->state
= SS_DISCONNECTING
;
1219 sk
->sk_err
= -ECONNREFUSED
;
1224 if (unlikely(!msg_connected(msg
)))
1227 res
= auto_connect(sock
, msg
);
1229 sock
->state
= SS_DISCONNECTING
;
1235 /* If an incoming message is an 'ACK-', it should be
1236 * discarded here because it doesn't contain useful
1237 * data. In addition, we should try to wake up
1238 * connect() routine if sleeping.
1240 if (msg_data_sz(msg
) == 0) {
1243 if (waitqueue_active(sk_sleep(sk
)))
1244 wake_up_interruptible(sk_sleep(sk
));
1249 case SS_UNCONNECTED
:
1250 /* Accept only SYN message */
1251 if (!msg_connected(msg
) && !(msg_errcode(msg
)))
1254 case SS_DISCONNECTING
:
1257 pr_err("Unknown socket state %u\n", sock
->state
);
1263 * filter_rcv - validate incoming message
1267 * Enqueues message on receive queue if acceptable; optionally handles
1268 * disconnect indication for a connected socket.
1270 * Called with socket lock already taken; port lock may also be taken.
1272 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
1274 static u32
filter_rcv(struct sock
*sk
, struct sk_buff
*buf
)
1276 struct socket
*sock
= sk
->sk_socket
;
1277 struct tipc_msg
*msg
= buf_msg(buf
);
1281 /* Reject message if it is wrong sort of message for socket */
1282 if (msg_type(msg
) > TIPC_DIRECT_MSG
)
1283 return TIPC_ERR_NO_PORT
;
1285 if (sock
->state
== SS_READY
) {
1286 if (msg_connected(msg
))
1287 return TIPC_ERR_NO_PORT
;
1289 res
= filter_connect(tipc_sk(sk
), &buf
);
1290 if (res
!= TIPC_OK
|| buf
== NULL
)
1294 /* Reject message if there isn't room to queue it */
1295 recv_q_len
= skb_queue_len(&sk
->sk_receive_queue
);
1296 if (unlikely(recv_q_len
>= (OVERLOAD_LIMIT_BASE
/ 2))) {
1297 if (rx_queue_full(msg
, recv_q_len
, OVERLOAD_LIMIT_BASE
/ 2))
1298 return TIPC_ERR_OVERLOAD
;
1301 /* Enqueue message (finally!) */
1302 TIPC_SKB_CB(buf
)->handle
= 0;
1303 __skb_queue_tail(&sk
->sk_receive_queue
, buf
);
1305 sk
->sk_data_ready(sk
, 0);
1310 * backlog_rcv - handle incoming message from backlog queue
1314 * Caller must hold socket lock, but not port lock.
1318 static int backlog_rcv(struct sock
*sk
, struct sk_buff
*buf
)
1322 res
= filter_rcv(sk
, buf
);
1324 tipc_reject_msg(buf
, res
);
1329 * dispatch - handle incoming message
1330 * @tport: TIPC port that received message
1333 * Called with port lock already taken.
1335 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
1337 static u32
dispatch(struct tipc_port
*tport
, struct sk_buff
*buf
)
1339 struct sock
*sk
= (struct sock
*)tport
->usr_handle
;
1343 * Process message if socket is unlocked; otherwise add to backlog queue
1345 * This code is based on sk_receive_skb(), but must be distinct from it
1346 * since a TIPC-specific filter/reject mechanism is utilized
1349 if (!sock_owned_by_user(sk
)) {
1350 res
= filter_rcv(sk
, buf
);
1352 if (sk_add_backlog(sk
, buf
, sk
->sk_rcvbuf
))
1353 res
= TIPC_ERR_OVERLOAD
;
1363 * wakeupdispatch - wake up port after congestion
1364 * @tport: port to wakeup
1366 * Called with port lock already taken.
1368 static void wakeupdispatch(struct tipc_port
*tport
)
1370 struct sock
*sk
= (struct sock
*)tport
->usr_handle
;
1372 sk
->sk_write_space(sk
);
1376 * connect - establish a connection to another TIPC port
1377 * @sock: socket structure
1378 * @dest: socket address for destination port
1379 * @destlen: size of socket address data structure
1380 * @flags: file-related flags associated with socket
1382 * Returns 0 on success, errno otherwise
1384 static int connect(struct socket
*sock
, struct sockaddr
*dest
, int destlen
,
1387 struct sock
*sk
= sock
->sk
;
1388 struct sockaddr_tipc
*dst
= (struct sockaddr_tipc
*)dest
;
1389 struct msghdr m
= {NULL
,};
1390 unsigned int timeout
;
1395 /* For now, TIPC does not allow use of connect() with DGRAM/RDM types */
1396 if (sock
->state
== SS_READY
) {
1402 * Reject connection attempt using multicast address
1404 * Note: send_msg() validates the rest of the address fields,
1405 * so there's no need to do it here
1407 if (dst
->addrtype
== TIPC_ADDR_MCAST
) {
1412 timeout
= (flags
& O_NONBLOCK
) ? 0 : tipc_sk(sk
)->conn_timeout
;
1414 switch (sock
->state
) {
1415 case SS_UNCONNECTED
:
1416 /* Send a 'SYN-' to destination */
1418 m
.msg_namelen
= destlen
;
1420 /* If connect is in non-blocking case, set MSG_DONTWAIT to
1421 * indicate send_msg() is never blocked.
1424 m
.msg_flags
= MSG_DONTWAIT
;
1426 res
= send_msg(NULL
, sock
, &m
, 0);
1427 if ((res
< 0) && (res
!= -EWOULDBLOCK
))
1430 /* Just entered SS_CONNECTING state; the only
1431 * difference is that return value in non-blocking
1432 * case is EINPROGRESS, rather than EALREADY.
1447 if (sock
->state
== SS_CONNECTING
) {
1451 /* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
1453 res
= wait_event_interruptible_timeout(*sk_sleep(sk
),
1454 sock
->state
!= SS_CONNECTING
,
1455 timeout
? (long)msecs_to_jiffies(timeout
)
1456 : MAX_SCHEDULE_TIMEOUT
);
1462 ; /* leave "res" unchanged */
1467 if (unlikely(sock
->state
== SS_DISCONNECTING
))
1468 res
= sock_error(sk
);
1478 * listen - allow socket to listen for incoming connections
1479 * @sock: socket structure
1482 * Returns 0 on success, errno otherwise
1484 static int listen(struct socket
*sock
, int len
)
1486 struct sock
*sk
= sock
->sk
;
1491 if (sock
->state
!= SS_UNCONNECTED
)
1494 sock
->state
= SS_LISTENING
;
1503 * accept - wait for connection request
1504 * @sock: listening socket
1505 * @newsock: new socket that is to be connected
1506 * @flags: file-related flags associated with socket
1508 * Returns 0 on success, errno otherwise
1510 static int accept(struct socket
*sock
, struct socket
*new_sock
, int flags
)
1512 struct sock
*new_sk
, *sk
= sock
->sk
;
1513 struct sk_buff
*buf
;
1514 struct tipc_sock
*new_tsock
;
1515 struct tipc_port
*new_tport
;
1516 struct tipc_msg
*msg
;
1523 if (sock
->state
!= SS_LISTENING
) {
1528 while (skb_queue_empty(&sk
->sk_receive_queue
)) {
1529 if (flags
& O_NONBLOCK
) {
1534 res
= wait_event_interruptible(*sk_sleep(sk
),
1535 (!skb_queue_empty(&sk
->sk_receive_queue
)));
1541 buf
= skb_peek(&sk
->sk_receive_queue
);
1543 res
= tipc_create(sock_net(sock
->sk
), new_sock
, 0, 0);
1547 new_sk
= new_sock
->sk
;
1548 new_tsock
= tipc_sk(new_sk
);
1549 new_tport
= new_tsock
->p
;
1550 new_ref
= new_tport
->ref
;
1553 /* we lock on new_sk; but lockdep sees the lock on sk */
1554 lock_sock_nested(new_sk
, SINGLE_DEPTH_NESTING
);
1557 * Reject any stray messages received by new socket
1558 * before the socket lock was taken (very, very unlikely)
1560 reject_rx_queue(new_sk
);
1562 /* Connect new socket to it's peer */
1563 new_tsock
->peer_name
.ref
= msg_origport(msg
);
1564 new_tsock
->peer_name
.node
= msg_orignode(msg
);
1565 tipc_connect(new_ref
, &new_tsock
->peer_name
);
1566 new_sock
->state
= SS_CONNECTED
;
1568 tipc_set_portimportance(new_ref
, msg_importance(msg
));
1569 if (msg_named(msg
)) {
1570 new_tport
->conn_type
= msg_nametype(msg
);
1571 new_tport
->conn_instance
= msg_nameinst(msg
);
1575 * Respond to 'SYN-' by discarding it & returning 'ACK'-.
1576 * Respond to 'SYN+' by queuing it on new socket.
1578 if (!msg_data_sz(msg
)) {
1579 struct msghdr m
= {NULL
,};
1581 advance_rx_queue(sk
);
1582 send_packet(NULL
, new_sock
, &m
, 0);
1584 __skb_dequeue(&sk
->sk_receive_queue
);
1585 __skb_queue_head(&new_sk
->sk_receive_queue
, buf
);
1587 release_sock(new_sk
);
1595 * shutdown - shutdown socket connection
1596 * @sock: socket structure
1597 * @how: direction to close (must be SHUT_RDWR)
1599 * Terminates connection (if necessary), then purges socket's receive queue.
1601 * Returns 0 on success, errno otherwise
1603 static int shutdown(struct socket
*sock
, int how
)
1605 struct sock
*sk
= sock
->sk
;
1606 struct tipc_port
*tport
= tipc_sk_port(sk
);
1607 struct sk_buff
*buf
;
1610 if (how
!= SHUT_RDWR
)
1615 switch (sock
->state
) {
1620 /* Disconnect and send a 'FIN+' or 'FIN-' message to peer */
1621 buf
= __skb_dequeue(&sk
->sk_receive_queue
);
1623 if (TIPC_SKB_CB(buf
)->handle
!= 0) {
1627 tipc_disconnect(tport
->ref
);
1628 tipc_reject_msg(buf
, TIPC_CONN_SHUTDOWN
);
1630 tipc_shutdown(tport
->ref
);
1633 sock
->state
= SS_DISCONNECTING
;
1637 case SS_DISCONNECTING
:
1639 /* Discard any unreceived messages */
1640 discard_rx_queue(sk
);
1642 /* Wake up anyone sleeping in poll */
1643 sk
->sk_state_change(sk
);
1656 * setsockopt - set socket option
1657 * @sock: socket structure
1658 * @lvl: option level
1659 * @opt: option identifier
1660 * @ov: pointer to new option value
1661 * @ol: length of option value
1663 * For stream sockets only, accepts and ignores all IPPROTO_TCP options
1664 * (to ease compatibility).
1666 * Returns 0 on success, errno otherwise
1668 static int setsockopt(struct socket
*sock
,
1669 int lvl
, int opt
, char __user
*ov
, unsigned int ol
)
1671 struct sock
*sk
= sock
->sk
;
1672 struct tipc_port
*tport
= tipc_sk_port(sk
);
1676 if ((lvl
== IPPROTO_TCP
) && (sock
->type
== SOCK_STREAM
))
1678 if (lvl
!= SOL_TIPC
)
1679 return -ENOPROTOOPT
;
1680 if (ol
< sizeof(value
))
1682 res
= get_user(value
, (u32 __user
*)ov
);
1689 case TIPC_IMPORTANCE
:
1690 res
= tipc_set_portimportance(tport
->ref
, value
);
1692 case TIPC_SRC_DROPPABLE
:
1693 if (sock
->type
!= SOCK_STREAM
)
1694 res
= tipc_set_portunreliable(tport
->ref
, value
);
1698 case TIPC_DEST_DROPPABLE
:
1699 res
= tipc_set_portunreturnable(tport
->ref
, value
);
1701 case TIPC_CONN_TIMEOUT
:
1702 tipc_sk(sk
)->conn_timeout
= value
;
1703 /* no need to set "res", since already 0 at this point */
1715 * getsockopt - get socket option
1716 * @sock: socket structure
1717 * @lvl: option level
1718 * @opt: option identifier
1719 * @ov: receptacle for option value
1720 * @ol: receptacle for length of option value
1722 * For stream sockets only, returns 0 length result for all IPPROTO_TCP options
1723 * (to ease compatibility).
1725 * Returns 0 on success, errno otherwise
1727 static int getsockopt(struct socket
*sock
,
1728 int lvl
, int opt
, char __user
*ov
, int __user
*ol
)
1730 struct sock
*sk
= sock
->sk
;
1731 struct tipc_port
*tport
= tipc_sk_port(sk
);
1736 if ((lvl
== IPPROTO_TCP
) && (sock
->type
== SOCK_STREAM
))
1737 return put_user(0, ol
);
1738 if (lvl
!= SOL_TIPC
)
1739 return -ENOPROTOOPT
;
1740 res
= get_user(len
, ol
);
1747 case TIPC_IMPORTANCE
:
1748 res
= tipc_portimportance(tport
->ref
, &value
);
1750 case TIPC_SRC_DROPPABLE
:
1751 res
= tipc_portunreliable(tport
->ref
, &value
);
1753 case TIPC_DEST_DROPPABLE
:
1754 res
= tipc_portunreturnable(tport
->ref
, &value
);
1756 case TIPC_CONN_TIMEOUT
:
1757 value
= tipc_sk(sk
)->conn_timeout
;
1758 /* no need to set "res", since already 0 at this point */
1760 case TIPC_NODE_RECVQ_DEPTH
:
1761 value
= 0; /* was tipc_queue_size, now obsolete */
1763 case TIPC_SOCK_RECVQ_DEPTH
:
1764 value
= skb_queue_len(&sk
->sk_receive_queue
);
1773 return res
; /* "get" failed */
1775 if (len
< sizeof(value
))
1778 if (copy_to_user(ov
, &value
, sizeof(value
)))
1781 return put_user(sizeof(value
), ol
);
1784 /* Protocol switches for the various types of TIPC sockets */
1786 static const struct proto_ops msg_ops
= {
1787 .owner
= THIS_MODULE
,
1792 .socketpair
= sock_no_socketpair
,
1793 .accept
= sock_no_accept
,
1794 .getname
= get_name
,
1796 .ioctl
= sock_no_ioctl
,
1797 .listen
= sock_no_listen
,
1798 .shutdown
= shutdown
,
1799 .setsockopt
= setsockopt
,
1800 .getsockopt
= getsockopt
,
1801 .sendmsg
= send_msg
,
1802 .recvmsg
= recv_msg
,
1803 .mmap
= sock_no_mmap
,
1804 .sendpage
= sock_no_sendpage
1807 static const struct proto_ops packet_ops
= {
1808 .owner
= THIS_MODULE
,
1813 .socketpair
= sock_no_socketpair
,
1815 .getname
= get_name
,
1817 .ioctl
= sock_no_ioctl
,
1819 .shutdown
= shutdown
,
1820 .setsockopt
= setsockopt
,
1821 .getsockopt
= getsockopt
,
1822 .sendmsg
= send_packet
,
1823 .recvmsg
= recv_msg
,
1824 .mmap
= sock_no_mmap
,
1825 .sendpage
= sock_no_sendpage
1828 static const struct proto_ops stream_ops
= {
1829 .owner
= THIS_MODULE
,
1834 .socketpair
= sock_no_socketpair
,
1836 .getname
= get_name
,
1838 .ioctl
= sock_no_ioctl
,
1840 .shutdown
= shutdown
,
1841 .setsockopt
= setsockopt
,
1842 .getsockopt
= getsockopt
,
1843 .sendmsg
= send_stream
,
1844 .recvmsg
= recv_stream
,
1845 .mmap
= sock_no_mmap
,
1846 .sendpage
= sock_no_sendpage
1849 static const struct net_proto_family tipc_family_ops
= {
1850 .owner
= THIS_MODULE
,
1852 .create
= tipc_create
1855 static struct proto tipc_proto
= {
1857 .owner
= THIS_MODULE
,
1858 .obj_size
= sizeof(struct tipc_sock
)
1862 * tipc_socket_init - initialize TIPC socket interface
1864 * Returns 0 on success, errno otherwise
1866 int tipc_socket_init(void)
1870 res
= proto_register(&tipc_proto
, 1);
1872 pr_err("Failed to register TIPC protocol type\n");
1876 res
= sock_register(&tipc_family_ops
);
1878 pr_err("Failed to register TIPC socket type\n");
1879 proto_unregister(&tipc_proto
);
1883 sockets_enabled
= 1;
1889 * tipc_socket_stop - stop TIPC socket interface
1891 void tipc_socket_stop(void)
1893 if (!sockets_enabled
)
1896 sockets_enabled
= 0;
1897 sock_unregister(tipc_family_ops
.family
);
1898 proto_unregister(&tipc_proto
);