/* * 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 "name_table.h"#include "node.h"#include "link.h"#include <linux/export.h>#include "config.h"#include "socket.h" #define SS_LISTENING	-1	/* socket is listening */#define SS_READY	-2	/* socket is connectionless */ #define CONN_TIMEOUT_DEFAULT  8000	/* default connect timeout = 8s */#define CONN_PROBING_INTERVAL 3600000	/* [ms] => 1 h */#define TIPC_FWD_MSG	      1#define TIPC_CONN_OK          0#define TIPC_CONN_PROBING     1 /** * struct tipc_sock - TIPC socket structure * @sk: socket - interacts with 'port' and with user via the socket API * @connected: non-zero if port is currently connected to a peer port * @conn_type: TIPC type used when connection was established * @conn_instance: TIPC instance used when connection was established * @published: non-zero if port has one or more associated names * @max_pkt: maximum packet size "hint" used when building messages sent by port * @ref: unique reference to port in TIPC object registry * @phdr: preformatted message header used when sending messages * @port_list: adjacent ports in TIPC's global list of ports * @publications: list of publications for port * @pub_count: total # of publications port has made during its lifetime * @probing_state: * @probing_interval: * @timer: * @port: port - interacts with 'sk' and with the rest of the TIPC stack * @peer_name: the peer of the connection, if any * @conn_timeout: the time we can wait for an unresponded setup request * @dupl_rcvcnt: number of bytes counted twice, in both backlog and rcv queue * @link_cong: non-zero if owner must sleep because of link congestion * @sent_unacked: # messages sent by socket, and not yet acked by peer * @rcv_unacked: # messages read by user, but not yet acked back to peer */struct tipc_sock {	struct sock sk;	int connected;	u32 conn_type;	u32 conn_instance;	int published;	u32 max_pkt;	u32 ref;	struct tipc_msg phdr;	struct list_head sock_list;	struct list_head publications;	u32 pub_count;	u32 probing_state;	u32 probing_interval;	struct timer_list timer;	uint conn_timeout;	atomic_t dupl_rcvcnt;	bool link_cong;	uint sent_unacked;	uint rcv_unacked;}; static int tipc_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 int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p);static void tipc_sk_timeout(unsigned long ref);static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,			   struct tipc_name_seq const *seq);static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,			    struct tipc_name_seq const *seq);static u32 tipc_sk_ref_acquire(struct tipc_sock *tsk);static void tipc_sk_ref_discard(u32 ref);static struct tipc_sock *tipc_sk_get(u32 ref);static struct tipc_sock *tipc_sk_get_next(u32 *ref);static void tipc_sk_put(struct tipc_sock *tsk); 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; static const struct nla_policy tipc_nl_sock_policy[TIPC_NLA_SOCK_MAX + 1] = {	[TIPC_NLA_SOCK_UNSPEC]		= { .type = NLA_UNSPEC },	[TIPC_NLA_SOCK_ADDR]		= { .type = NLA_U32 },	[TIPC_NLA_SOCK_REF]		= { .type = NLA_U32 },	[TIPC_NLA_SOCK_CON]		= { .type = NLA_NESTED },	[TIPC_NLA_SOCK_HAS_PUBL]	= { .type = NLA_FLAG }}; /* * 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 */ static u32 tsk_peer_node(struct tipc_sock *tsk){	return msg_destnode(&tsk->phdr);} static u32 tsk_peer_port(struct tipc_sock *tsk){	return msg_destport(&tsk->phdr);} static  bool tsk_unreliable(struct tipc_sock *tsk){	return msg_src_droppable(&tsk->phdr) != 0;} static void tsk_set_unreliable(struct tipc_sock *tsk, bool unreliable){	msg_set_src_droppable(&tsk->phdr, unreliable ? 1 : 0);} static bool tsk_unreturnable(struct tipc_sock *tsk){	return msg_dest_droppable(&tsk->phdr) != 0;} static void tsk_set_unreturnable(struct tipc_sock *tsk, bool unreturnable){	msg_set_dest_droppable(&tsk->phdr, unreturnable ? 1 : 0);} static int tsk_importance(struct tipc_sock *tsk){	return msg_importance(&tsk->phdr);} static int tsk_set_importance(struct tipc_sock *tsk, int imp){	if (imp > TIPC_CRITICAL_IMPORTANCE)		return -EINVAL;	msg_set_importance(&tsk->phdr, (u32)imp);	return 0;} static struct tipc_sock *tipc_sk(const struct sock *sk){	return container_of(sk, struct tipc_sock, sk);} static int tsk_conn_cong(struct tipc_sock *tsk){	return tsk->sent_unacked >= TIPC_FLOWCTRL_WIN;} /** * tsk_advance_rx_queue - discard first buffer in socket receive queue * * Caller must hold socket lock */static void tsk_advance_rx_queue(struct sock *sk){	kfree_skb(__skb_dequeue(&sk->sk_receive_queue));} /** * tsk_rej_rx_queue - reject all buffers in socket receive queue * * Caller must hold socket lock */static void tsk_rej_rx_queue(struct sock *sk){	struct sk_buff *skb;	u32 dnode; 	while ((skb = __skb_dequeue(&sk->sk_receive_queue))) {		if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT))			tipc_link_xmit_skb(skb, dnode, 0);	}} /* tsk_peer_msg - verify if message was sent by connected port's peer * * Handles cases where the node's network address has changed from * the default of <0.0.0> to its configured setting. */static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg){	u32 peer_port = tsk_peer_port(tsk);	u32 orig_node;	u32 peer_node; 	if (unlikely(!tsk->connected))		return false; 	if (unlikely(msg_origport(msg) != peer_port))		return false; 	orig_node = msg_orignode(msg);	peer_node = tsk_peer_node(tsk); 	if (likely(orig_node == peer_node))		return true; 	if (!orig_node && (peer_node == tipc_own_addr))		return true; 	if (!peer_node && (orig_node == tipc_own_addr))		return true; 	return false;} /** * 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_msg *msg;	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);	ref = tipc_sk_ref_acquire(tsk);	if (!ref) {		pr_warn("Socket create failed; reference table exhausted\n");		return -ENOMEM;	}	tsk->max_pkt = MAX_PKT_DEFAULT;	tsk->ref = ref;	INIT_LIST_HEAD(&tsk->publications);	msg = &tsk->phdr;	tipc_msg_init(msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG,		      NAMED_H_SIZE, 0);	msg_set_origport(msg, ref); 	/* Finish initializing socket data structures */	sock->ops = ops;	sock->state = state;	sock_init_data(sock, sk);	k_init_timer(&tsk->timer, (Handler)tipc_sk_timeout, ref);	sk->sk_backlog_rcv = tipc_backlog_rcv;	sk->sk_rcvbuf = sysctl_tipc_rmem[1];	sk->sk_data_ready = tipc_data_ready;	sk->sk_write_space = tipc_write_space;	tsk->conn_timeout = CONN_TIMEOUT_DEFAULT;	tsk->sent_unacked = 0;	atomic_set(&tsk->dupl_rcvcnt, 0); 	if (sock->state == SS_READY) {		tsk_set_unreturnable(tsk, true);		if (sock->type == SOCK_DGRAM)			tsk_set_unreliable(tsk, 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 sk_buff *skb;	u32 dnode; 	/*	 * 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);	lock_sock(sk); 	/*	 * Reject all unreceived messages, except on an active connection	 * (which disconnects locally & sends a 'FIN+' to peer)	 */	dnode = tsk_peer_node(tsk);	while (sock->state != SS_DISCONNECTING) {		skb = __skb_dequeue(&sk->sk_receive_queue);		if (skb == NULL)			break;		if (TIPC_SKB_CB(skb)->handle != NULL)			kfree_skb(skb);		else {			if ((sock->state == SS_CONNECTING) ||			    (sock->state == SS_CONNECTED)) {				sock->state = SS_DISCONNECTING;				tsk->connected = 0;				tipc_node_remove_conn(dnode, tsk->ref);			}			if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT))				tipc_link_xmit_skb(skb, dnode, 0);		}	} 

Lines 1–500 of 3009. Load more