/* * net/tipc/socket.c: TIPC socket API * * Copyright (c) 2001-2007, 2012-2014, Ericsson AB * Copyright (c) 2004-2008, 2010-2013, 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 "core.h"#include "port.h" #include <linux/export.h> #define SS_LISTENING	-1	/* socket is listening */#define SS_READY	-2	/* socket is connectionless */ #define CONN_TIMEOUT_DEFAULT	8000	/* default connect timeout = 8s */ static int backlog_rcv(struct sock *sk, struct sk_buff *skb);static void tipc_data_ready(struct sock *sk);static void tipc_write_space(struct sock *sk);static int tipc_release(struct socket *sock);static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags); 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 struct proto tipc_proto_kern; /* * 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 */ #include "socket.h" /** * 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));} /** * 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);} /** * tipc_sk_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_sk_create(struct net *net, struct socket *sock,			  int protocol, int kern){	const struct proto_ops *ops;	socket_state state;	struct sock *sk;	struct tipc_sock *tsk;	struct tipc_port *port;	u32 ref; 	/* 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 */	if (!kern)		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);	else		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto_kern); 	if (sk == NULL)		return -ENOMEM; 	tsk = tipc_sk(sk);	port = &tsk->port; 	ref = tipc_port_init(port, TIPC_LOW_IMPORTANCE);	if (!ref) {		pr_warn("Socket registration failed, ref. table exhausted\n");		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;	sk->sk_rcvbuf = sysctl_tipc_rmem[1];	sk->sk_data_ready = tipc_data_ready;	sk->sk_write_space = tipc_write_space;	tipc_sk(sk)->conn_timeout = CONN_TIMEOUT_DEFAULT;	tipc_port_unlock(port); 	if (sock->state == SS_READY) {		tipc_port_set_unreturnable(port, true);		if (sock->type == SOCK_DGRAM)			tipc_port_set_unreliable(port, true);	}	return 0;} /** * tipc_sock_create_local - create TIPC socket from inside TIPC module * @type: socket type - SOCK_RDM or SOCK_SEQPACKET * * We cannot use sock_creat_kern here because it bumps module user count. * Since socket owner and creator is the same module we must make sure * that module count remains zero for module local sockets, otherwise * we cannot do rmmod. * * Returns 0 on success, errno otherwise */int tipc_sock_create_local(int type, struct socket **res){	int rc; 	rc = sock_create_lite(AF_TIPC, type, 0, res);	if (rc < 0) {		pr_err("Failed to create kernel socket\n");		return rc;	}	tipc_sk_create(&init_net, *res, 0, 1); 	return 0;} /** * tipc_sock_release_local - release socket created by tipc_sock_create_local * @sock: the socket to be released. * * Module reference count is not incremented when such sockets are created, * so we must keep it from being decremented when they are released. */void tipc_sock_release_local(struct socket *sock){	tipc_release(sock);	sock->ops = NULL;	sock_release(sock);} /** * tipc_sock_accept_local - accept a connection on a socket created * with tipc_sock_create_local. Use this function to avoid that * module reference count is inadvertently incremented. * * @sock:    the accepting socket * @newsock: reference to the new socket to be created * @flags:   socket flags */ int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,			   int flags){	struct sock *sk = sock->sk;	int ret; 	ret = sock_create_lite(sk->sk_family, sk->sk_type,			       sk->sk_protocol, newsock);	if (ret < 0)		return ret; 	ret = tipc_accept(sock, *newsock, flags);	if (ret < 0) {		sock_release(*newsock);		return ret;	}	(*newsock)->ops = sock->ops;	return ret;} /** * tipc_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 tipc_release(struct socket *sock){	struct sock *sk = sock->sk;	struct tipc_sock *tsk;	struct tipc_port *port;	struct sk_buff *buf; 	/*	 * 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; 	tsk = tipc_sk(sk);	port = &tsk->port;	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;		if (TIPC_SKB_CB(buf)->handle != NULL)			kfree_skb(buf);		else {			if ((sock->state == SS_CONNECTING) ||			    (sock->state == SS_CONNECTED)) {				sock->state = SS_DISCONNECTING;				tipc_port_disconnect(port->ref);			}			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);		}	} 	/* Destroy TIPC port; also disconnects an active connection and	 * sends a 'FIN-' to peer.	 */	tipc_port_destroy(port); 	/* Discard any remaining (connection-based) messages in receive queue */	__skb_queue_purge(&sk->sk_receive_queue); 	/* Reject any messages that accumulated in backlog queue */	sock->state = SS_DISCONNECTING;	release_sock(sk); 	sock_put(sk);	sock->sk = NULL; 	return 0;} /** * tipc_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 tipc_bind(struct socket *sock, struct sockaddr *uaddr,		     int uaddr_len){	struct sock *sk = sock->sk;	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;	struct tipc_sock *tsk = tipc_sk(sk);	int res = -EINVAL; 	lock_sock(sk);	if (unlikely(!uaddr_len)) {		res = tipc_withdraw(&tsk->port, 0, NULL);		goto exit;	} 	if (uaddr_len < sizeof(struct sockaddr_tipc)) {		res = -EINVAL;		goto exit;	}	if (addr->family != AF_TIPC) {		res = -EAFNOSUPPORT;		goto exit;	} 	if (addr->addrtype == TIPC_ADDR_NAME)		addr->addr.nameseq.upper = addr->addr.nameseq.lower;	else if (addr->addrtype != TIPC_ADDR_NAMESEQ) {		res = -EAFNOSUPPORT;		goto exit;	} 	if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) &&	    (addr->addr.nameseq.type != TIPC_TOP_SRV) &&	    (addr->addr.nameseq.type != TIPC_CFG_SRV)) {		res = -EACCES;		goto exit;	} 	res = (addr->scope > 0) ?		tipc_publish(&tsk->port, addr->scope, &addr->addr.nameseq) :		tipc_withdraw(&tsk->port, -addr->scope, &addr->addr.nameseq);exit:	release_sock(sk);	return res;} /** * tipc_getname - 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 tipc_getname(struct socket *sock, struct sockaddr *uaddr,			int *uaddr_len, int peer){	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;	struct tipc_sock *tsk = 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 = tipc_port_peerport(&tsk->port);		addr->addr.id.node = tipc_port_peernode(&tsk->port);	} else {		addr->addr.id.ref = tsk->port.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;} /** * tipc_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 *			POLLOUT if port is not congested * * 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 tipc_poll(struct file *file, struct socket *sock,			      poll_table *wait){	struct sock *sk = sock->sk;	struct tipc_sock *tsk = tipc_sk(sk);	u32 mask = 0; 

Lines 1–500 of 2024. Load more