/* * net/tipc/socket.c: TIPC socket API * * Copyright (c) 2001-2007, Ericsson AB * Copyright (c) 2004-2008, 2010-2011, Wind River Systems * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. Neither the names of the copyright holders nor the names of its *    contributors may be used to endorse or promote products derived from *    this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <linux/export.h>#include <net/sock.h> #include "core.h"#include "port.h" #define SS_LISTENING	-1	/* socket is listening */#define SS_READY	-2	/* socket is connectionless */ #define OVERLOAD_LIMIT_BASE	5000#define CONN_TIMEOUT_DEFAULT	8000	/* default connect timeout = 8s */ struct tipc_sock {	struct sock sk;	struct tipc_port *p;	struct tipc_portid peer_name;	unsigned int conn_timeout;}; #define tipc_sk(sk) ((struct tipc_sock *)(sk))#define tipc_sk_port(sk) ((struct tipc_port *)(tipc_sk(sk)->p)) #define tipc_rx_ready(sock) (!skb_queue_empty(&sock->sk->sk_receive_queue) || \			(sock->state == SS_DISCONNECTING)) static int backlog_rcv(struct sock *sk, struct sk_buff *skb);static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf);static void wakeupdispatch(struct tipc_port *tport); static const struct proto_ops packet_ops;static const struct proto_ops stream_ops;static const struct proto_ops msg_ops; static struct proto tipc_proto; static int sockets_enabled; static atomic_t tipc_queue_size = ATOMIC_INIT(0); /* * Revised TIPC socket locking policy: * * Most socket operations take the standard socket lock when they start * and hold it until they finish (or until they need to sleep).  Acquiring * this lock grants the owner exclusive access to the fields of the socket * data structures, with the exception of the backlog queue.  A few socket * operations can be done without taking the socket lock because they only * read socket information that never changes during the life of the socket. * * Socket operations may acquire the lock for the associated TIPC port if they * need to perform an operation on the port.  If any routine needs to acquire * both the socket lock and the port lock it must take the socket lock first * to avoid the risk of deadlock. * * The dispatcher handling incoming messages cannot grab the socket lock in * the standard fashion, since invoked it runs at the BH level and cannot block. * Instead, it checks to see if the socket lock is currently owned by someone, * and either handles the message itself or adds it to the socket's backlog * queue; in the latter case the queued message is processed once the process * owning the socket lock releases it. * * NOTE: Releasing the socket lock while an operation is sleeping overcomes * the problem of a blocked socket operation preventing any other operations * from occurring.  However, applications must be careful if they have * multiple threads trying to send (or receive) on the same socket, as these * operations might interfere with each other.  For example, doing a connect * and a receive at the same time might allow the receive to consume the * ACK message meant for the connect.  While additional work could be done * to try and overcome this, it doesn't seem to be worthwhile at the present. * * NOTE: Releasing the socket lock while an operation is sleeping also ensures * that another operation that must be performed in a non-blocking manner is * not delayed for very long because the lock has already been taken. * * NOTE: This code assumes that certain fields of a port/socket pair are * constant over its lifetime; such fields can be examined without taking * the socket lock and/or port lock, and do not need to be re-read even * after resuming processing after waiting.  These fields include: *   - socket type *   - pointer to socket sk structure (aka tipc_sock structure) *   - pointer to port structure *   - port reference */ /** * advance_rx_queue - discard first buffer in socket receive queue * * Caller must hold socket lock */static void advance_rx_queue(struct sock *sk){	kfree_skb(__skb_dequeue(&sk->sk_receive_queue));	atomic_dec(&tipc_queue_size);} /** * discard_rx_queue - discard all buffers in socket receive queue * * Caller must hold socket lock */static void discard_rx_queue(struct sock *sk){	struct sk_buff *buf; 	while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {		atomic_dec(&tipc_queue_size);		kfree_skb(buf);	}} /** * reject_rx_queue - reject all buffers in socket receive queue * * Caller must hold socket lock */static void reject_rx_queue(struct sock *sk){	struct sk_buff *buf; 	while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {		tipc_reject_msg(buf, TIPC_ERR_NO_PORT);		atomic_dec(&tipc_queue_size);	}} /** * tipc_create - create a TIPC socket * @net: network namespace (must be default network) * @sock: pre-allocated socket structure * @protocol: protocol indicator (must be 0) * @kern: caused by kernel or by userspace? * * This routine creates additional data structures used by the TIPC socket, * initializes them, and links them together. * * Returns 0 on success, errno otherwise */static int tipc_create(struct net *net, struct socket *sock, int protocol,		       int kern){	const struct proto_ops *ops;	socket_state state;	struct sock *sk;	struct tipc_port *tp_ptr; 	/* Validate arguments */	if (unlikely(protocol != 0))		return -EPROTONOSUPPORT; 	switch (sock->type) {	case SOCK_STREAM:		ops = &stream_ops;		state = SS_UNCONNECTED;		break;	case SOCK_SEQPACKET:		ops = &packet_ops;		state = SS_UNCONNECTED;		break;	case SOCK_DGRAM:	case SOCK_RDM:		ops = &msg_ops;		state = SS_READY;		break;	default:		return -EPROTOTYPE;	} 	/* Allocate socket's protocol area */	sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);	if (sk == NULL)		return -ENOMEM; 	/* Allocate TIPC port for socket to use */	tp_ptr = tipc_createport_raw(sk, &dispatch, &wakeupdispatch,				     TIPC_LOW_IMPORTANCE);	if (unlikely(!tp_ptr)) {		sk_free(sk);		return -ENOMEM;	} 	/* Finish initializing socket data structures */	sock->ops = ops;	sock->state = state; 	sock_init_data(sock, sk);	sk->sk_backlog_rcv = backlog_rcv;	tipc_sk(sk)->p = tp_ptr;	tipc_sk(sk)->conn_timeout = CONN_TIMEOUT_DEFAULT; 	spin_unlock_bh(tp_ptr->lock); 	if (sock->state == SS_READY) {		tipc_set_portunreturnable(tp_ptr->ref, 1);		if (sock->type == SOCK_DGRAM)			tipc_set_portunreliable(tp_ptr->ref, 1);	} 	return 0;} /** * release - destroy a TIPC socket * @sock: socket to destroy * * This routine cleans up any messages that are still queued on the socket. * For DGRAM and RDM socket types, all queued messages are rejected. * For SEQPACKET and STREAM socket types, the first message is rejected * and any others are discarded.  (If the first message on a STREAM socket * is partially-read, it is discarded and the next one is rejected instead.) * * NOTE: Rejected messages are not necessarily returned to the sender!  They * are returned or discarded according to the "destination droppable" setting * specified for the message by the sender. * * Returns 0 on success, errno otherwise */static int release(struct socket *sock){	struct sock *sk = sock->sk;	struct tipc_port *tport;	struct sk_buff *buf;	int res; 	/*	 * Exit if socket isn't fully initialized (occurs when a failed accept()	 * releases a pre-allocated child socket that was never used)	 */	if (sk == NULL)		return 0; 	tport = tipc_sk_port(sk);	lock_sock(sk); 	/*	 * Reject all unreceived messages, except on an active connection	 * (which disconnects locally & sends a 'FIN+' to peer)	 */	while (sock->state != SS_DISCONNECTING) {		buf = __skb_dequeue(&sk->sk_receive_queue);		if (buf == NULL)			break;		atomic_dec(&tipc_queue_size);		if (TIPC_SKB_CB(buf)->handle != 0)			kfree_skb(buf);		else {			if ((sock->state == SS_CONNECTING) ||			    (sock->state == SS_CONNECTED)) {				sock->state = SS_DISCONNECTING;				tipc_disconnect(tport->ref);			}			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);		}	} 	/*	 * Delete TIPC port; this ensures no more messages are queued	 * (also disconnects an active connection & sends a 'FIN-' to peer)	 */	res = tipc_deleteport(tport->ref); 	/* Discard any remaining (connection-based) messages in receive queue */	discard_rx_queue(sk); 	/* Reject any messages that accumulated in backlog queue */	sock->state = SS_DISCONNECTING;	release_sock(sk); 	sock_put(sk);	sock->sk = NULL; 	return res;} /** * bind - associate or disassocate TIPC name(s) with a socket * @sock: socket structure * @uaddr: socket address describing name(s) and desired operation * @uaddr_len: size of socket address data structure * * Name and name sequence binding is indicated using a positive scope value; * a negative scope value unbinds the specified name.  Specifying no name * (i.e. a socket address length of 0) unbinds all names from the socket. * * Returns 0 on success, errno otherwise * * NOTE: This routine doesn't need to take the socket lock since it doesn't *       access any non-constant socket information. */static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len){	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;	u32 portref = tipc_sk_port(sock->sk)->ref; 	if (unlikely(!uaddr_len))		return tipc_withdraw(portref, 0, NULL); 	if (uaddr_len < sizeof(struct sockaddr_tipc))		return -EINVAL;	if (addr->family != AF_TIPC)		return -EAFNOSUPPORT; 	if (addr->addrtype == TIPC_ADDR_NAME)		addr->addr.nameseq.upper = addr->addr.nameseq.lower;	else if (addr->addrtype != TIPC_ADDR_NAMESEQ)		return -EAFNOSUPPORT; 	if (addr->addr.nameseq.type < TIPC_RESERVED_TYPES)		return -EACCES; 	return (addr->scope > 0) ?		tipc_publish(portref, addr->scope, &addr->addr.nameseq) :		tipc_withdraw(portref, -addr->scope, &addr->addr.nameseq);} /** * get_name - get port ID of socket or peer socket * @sock: socket structure * @uaddr: area for returned socket address * @uaddr_len: area for returned length of socket address * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID * * Returns 0 on success, errno otherwise * * NOTE: This routine doesn't need to take the socket lock since it only *       accesses socket information that is unchanging (or which changes in *       a completely predictable manner). */static int get_name(struct socket *sock, struct sockaddr *uaddr,		    int *uaddr_len, int peer){	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;	struct tipc_sock *tsock = tipc_sk(sock->sk); 	memset(addr, 0, sizeof(*addr));	if (peer) {		if ((sock->state != SS_CONNECTED) &&			((peer != 2) || (sock->state != SS_DISCONNECTING)))			return -ENOTCONN;		addr->addr.id.ref = tsock->peer_name.ref;		addr->addr.id.node = tsock->peer_name.node;	} else {		addr->addr.id.ref = tsock->p->ref;		addr->addr.id.node = tipc_own_addr;	} 	*uaddr_len = sizeof(*addr);	addr->addrtype = TIPC_ADDR_ID;	addr->family = AF_TIPC;	addr->scope = 0;	addr->addr.name.domain = 0; 	return 0;} /** * poll - read and possibly block on pollmask * @file: file structure associated with the socket * @sock: socket for which to calculate the poll bits * @wait: ??? * * Returns pollmask value * * COMMENTARY: * It appears that the usual socket locking mechanisms are not useful here * since the pollmask info is potentially out-of-date the moment this routine * exits.  TCP and other protocols seem to rely on higher level poll routines * to handle any preventable race conditions, so TIPC will do the same ... * * TIPC sets the returned events as follows: * * socket state		flags set * ------------		--------- * unconnected		no read flags *			no write flags * * connecting		POLLIN/POLLRDNORM if ACK/NACK in rx queue *			no write flags * * connected		POLLIN/POLLRDNORM if data in rx queue *			POLLOUT if port is not congested * * disconnecting	POLLIN/POLLRDNORM/POLLHUP *			no write flags * * listening		POLLIN if SYN in rx queue *			no write flags * * ready		POLLIN/POLLRDNORM if data in rx queue * [connectionless]	POLLOUT (since port cannot be congested) * * IMPORTANT: The fact that a read or write operation is indicated does NOT * imply that the operation will succeed, merely that it should be performed * and will not block. */static unsigned int poll(struct file *file, struct socket *sock,			 poll_table *wait){	struct sock *sk = sock->sk;	u32 mask = 0; 	poll_wait(file, sk_sleep(sk), wait); 	switch ((int)sock->state) {	case SS_READY:	case SS_CONNECTED:		if (!tipc_sk_port(sk)->congested)			mask |= POLLOUT;		/* fall thru' */	case SS_CONNECTING:	case SS_LISTENING:		if (!skb_queue_empty(&sk->sk_receive_queue))			mask |= (POLLIN | POLLRDNORM);		break;	case SS_DISCONNECTING:		mask = (POLLIN | POLLRDNORM | POLLHUP);		break;	} 	return mask;} /** * dest_name_check - verify user is permitted to send to specified port name * @dest: destination address * @m: descriptor for message to be sent * * Prevents restricted configuration commands from being issued by * unauthorized users. * * Returns 0 if permission is granted, otherwise errno */static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m){	struct tipc_cfg_msg_hdr hdr; 	if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))		return 0;	if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))		return 0;	if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))		return -EACCES; 	if (!m->msg_iovlen || (m->msg_iov[0].iov_len < sizeof(hdr)))		return -EMSGSIZE;	if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))		return -EFAULT;	if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))		return -EACCES; 	return 0;} /** * send_msg - send message in connectionless manner * @iocb: if NULL, indicates that socket lock is already held * @sock: socket structure * @m: message to send * @total_len: length of message * * Message must have an destination specified explicitly. * Used for SOCK_RDM and SOCK_DGRAM messages, * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections. * (Note: 'SYN+' is prohibited on SOCK_STREAM.) *

Lines 1–500 of 1818. Load more