/* * net/tipc/socket.c: TIPC socket API * * Copyright (c) 2001-2007, 2012-2015, 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 <linux/rhashtable.h>#include "core.h"#include "name_table.h"#include "node.h"#include "link.h"#include "name_distr.h"#include "socket.h"#include "bcast.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	msecs_to_jiffies(3600000)  /* [ms] => 1 h */#define TIPC_FWD_MSG		1#define TIPC_CONN_OK		0#define TIPC_CONN_PROBING	1#define TIPC_MAX_PORT		0xffffffff#define TIPC_MIN_PORT		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 * @portid: unique port identity in TIPC socket hash table * @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_intv: * @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 * @remote: 'connected' peer for dgram/rdm * @node: hash table node * @rcu: rcu struct for tipc_sock */struct tipc_sock {	struct sock sk;	int connected;	u32 conn_type;	u32 conn_instance;	int published;	u32 max_pkt;	u32 portid;	struct tipc_msg phdr;	struct list_head sock_list;	struct list_head publications;	u32 pub_count;	u32 probing_state;	unsigned long probing_intv;	uint conn_timeout;	atomic_t dupl_rcvcnt;	bool link_cong;	uint sent_unacked;	uint rcv_unacked;	struct sockaddr_tipc remote;	struct rhash_head node;	struct rcu_head rcu;}; 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 data);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 struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid);static int tipc_sk_insert(struct tipc_sock *tsk);static void tipc_sk_remove(struct tipc_sock *tsk);static int __tipc_send_stream(struct socket *sock, struct msghdr *m,			      size_t dsz);static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz); 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 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 }}; static const struct rhashtable_params tsk_rht_params; /* * 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_own_node(struct tipc_sock *tsk){	return msg_prevnode(&tsk->phdr);} 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));} /* tipc_sk_respond() : send response message back to sender */static void tipc_sk_respond(struct sock *sk, struct sk_buff *skb, int err){	u32 selector;	u32 dnode;	u32 onode = tipc_own_addr(sock_net(sk)); 	if (!tipc_msg_reverse(onode, &skb, err))		return; 	dnode = msg_destnode(buf_msg(skb));	selector = msg_origport(buf_msg(skb));	tipc_node_xmit_skb(sock_net(sk), skb, dnode, selector);} /** * 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; 	while ((skb = __skb_dequeue(&sk->sk_receive_queue)))		tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT);} /* 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){	struct tipc_net *tn = net_generic(sock_net(&tsk->sk), tipc_net_id);	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 == tn->own_addr))		return true; 	if (!peer_node && (orig_node == tn->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){	struct tipc_net *tn;	const struct proto_ops *ops;	socket_state state;	struct sock *sk;	struct tipc_sock *tsk;	struct tipc_msg *msg; 	/* 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, kern);	if (sk == NULL)		return -ENOMEM; 	tsk = tipc_sk(sk);	tsk->max_pkt = MAX_PKT_DEFAULT;	INIT_LIST_HEAD(&tsk->publications);	msg = &tsk->phdr;	tn = net_generic(sock_net(sk), tipc_net_id);	tipc_msg_init(tn->own_addr, msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG,		      NAMED_H_SIZE, 0); 	/* Finish initializing socket data structures */	sock->ops = ops;	sock->state = state;	sock_init_data(sock, sk);	if (tipc_sk_insert(tsk)) {		pr_warn("Socket create failed; port numbrer exhausted\n");		return -EINVAL;	}	msg_set_origport(msg, tsk->portid);	setup_timer(&sk->sk_timer, tipc_sk_timeout, (unsigned long)tsk);	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;} static void tipc_sk_callback(struct rcu_head *head){	struct tipc_sock *tsk = container_of(head, struct tipc_sock, rcu); 	sock_put(&tsk->sk);} /** * 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 net *net;	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; 	net = sock_net(sk);	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(net, dnode, tsk->portid);			}			tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT);		}	} 	tipc_sk_withdraw(tsk, 0, NULL);	sk_stop_timer(sk, &sk->sk_timer);	tipc_sk_remove(tsk);	if (tsk->connected) {		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE,				      TIPC_CONN_MSG, SHORT_H_SIZE, 0, dnode,				      tsk_own_node(tsk), tsk_peer_port(tsk),				      tsk->portid, TIPC_ERR_NO_PORT);		if (skb)			tipc_node_xmit_skb(net, skb, dnode, tsk->portid);		tipc_node_remove_conn(net, dnode, tsk->portid);	} 	/* 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); 	call_rcu(&tsk->rcu, tipc_sk_callback);	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. */

Lines 1–500 of 2839. Load more