/* * net/tipc/socket.c: TIPC socket API * * Copyright (c) 2001-2007, 2012-2016, 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"#include "netlink.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;	u16 snt_unacked;	u16 snd_win;	u16 peer_caps;	u16 rcv_unacked;	u16 rcv_win;	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 void tipc_sock_destruct(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 rhashtable_params tsk_rht_params; 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 bool tsk_conn_cong(struct tipc_sock *tsk){	return tsk->snt_unacked > tsk->snd_win;} /* tsk_blocks(): translate a buffer size in bytes to number of * advertisable blocks, taking into account the ratio truesize(len)/len * We can trust that this ratio is always < 4 for len >= FLOWCTL_BLK_SZ */static u16 tsk_adv_blocks(int len){	return len / FLOWCTL_BLK_SZ / 4;} /* tsk_inc(): increment counter for sent or received data * - If block based flow control is not supported by peer we *   fall back to message based ditto, incrementing the counter */static u16 tsk_inc(struct tipc_sock *tsk, int msglen){	if (likely(tsk->peer_caps & TIPC_BLOCK_FLOWCTL))		return ((msglen / FLOWCTL_BLK_SZ) + 1);	return 1;} /** * 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 number 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;	sk->sk_destruct = tipc_sock_destruct;	tsk->conn_timeout = CONN_TIMEOUT_DEFAULT;	atomic_set(&tsk->dupl_rcvcnt, 0); 	/* Start out with safe limits until we receive an advertised window */	tsk->snd_win = tsk_adv_blocks(RCVBUF_MIN);	tsk->rcv_win = tsk->snd_win; 	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);	} 	/* 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. */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_sk_withdraw(tsk, 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;

Lines 1–500 of 2875. Load more