blob: f9f5f3c3dab530c0b798d314873800500ccc30b5 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
Jon Paul Maloy02c00c22014-06-09 11:08:18 -05002 * net/tipc/socket.c: TIPC socket API
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -05004 * Copyright (c) 2001-2007, 2012-2015, Ericsson AB
Ying Xuec5fa7b32013-06-17 10:54:39 -04005 * Copyright (c) 2004-2008, 2010-2013, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01006 * All rights reserved.
7 *
Per Liden9ea1fd32006-01-11 13:30:43 +01008 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +01009 * modification, are permitted provided that the following conditions are met:
10 *
Per Liden9ea1fd32006-01-11 13:30:43 +010011 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
Per Lidenb97bf3f2006-01-02 19:04:38 +010019 *
Per Liden9ea1fd32006-01-11 13:30:43 +010020 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Per Lidenb97bf3f2006-01-02 19:04:38 +010034 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
Ying Xue07f6c4b2015-01-07 13:41:58 +080037#include <linux/rhashtable.h>
Per Lidenb97bf3f2006-01-02 19:04:38 +010038#include "core.h"
Jon Paul Maloye2dafe82014-06-25 20:41:37 -050039#include "name_table.h"
Erik Hugne78acb1f2014-04-24 16:26:47 +020040#include "node.h"
Jon Paul Maloye2dafe82014-06-25 20:41:37 -050041#include "link.h"
Jon Paul Maloyc637c102015-02-05 08:36:41 -050042#include "name_distr.h"
Jon Paul Maloy2e84c602014-08-22 18:09:18 -040043#include "socket.h"
Jon Paul Maloya6bf70f2015-05-14 10:46:13 -040044#include "bcast.h"
Richard Alpe49cc66e2016-03-04 17:04:42 +010045#include "netlink.h"
Erik Hugne2cf8aa12012-06-29 00:16:37 -040046
Ying Xue07f6c4b2015-01-07 13:41:58 +080047#define SS_LISTENING -1 /* socket is listening */
48#define SS_READY -2 /* socket is connectionless */
Per Lidenb97bf3f2006-01-02 19:04:38 +010049
Ying Xue07f6c4b2015-01-07 13:41:58 +080050#define CONN_TIMEOUT_DEFAULT 8000 /* default connect timeout = 8s */
Ying Xue2f55c432015-01-09 15:27:00 +080051#define CONN_PROBING_INTERVAL msecs_to_jiffies(3600000) /* [ms] => 1 h */
Ying Xue07f6c4b2015-01-07 13:41:58 +080052#define TIPC_FWD_MSG 1
53#define TIPC_CONN_OK 0
54#define TIPC_CONN_PROBING 1
55#define TIPC_MAX_PORT 0xffffffff
56#define TIPC_MIN_PORT 1
Jon Paul Maloy301bae52014-08-22 18:09:20 -040057
58/**
59 * struct tipc_sock - TIPC socket structure
60 * @sk: socket - interacts with 'port' and with user via the socket API
61 * @connected: non-zero if port is currently connected to a peer port
62 * @conn_type: TIPC type used when connection was established
63 * @conn_instance: TIPC instance used when connection was established
64 * @published: non-zero if port has one or more associated names
65 * @max_pkt: maximum packet size "hint" used when building messages sent by port
Ying Xue07f6c4b2015-01-07 13:41:58 +080066 * @portid: unique port identity in TIPC socket hash table
Jon Paul Maloy301bae52014-08-22 18:09:20 -040067 * @phdr: preformatted message header used when sending messages
68 * @port_list: adjacent ports in TIPC's global list of ports
69 * @publications: list of publications for port
70 * @pub_count: total # of publications port has made during its lifetime
71 * @probing_state:
Ying Xue2f55c432015-01-09 15:27:00 +080072 * @probing_intv:
Jon Paul Maloy301bae52014-08-22 18:09:20 -040073 * @conn_timeout: the time we can wait for an unresponded setup request
74 * @dupl_rcvcnt: number of bytes counted twice, in both backlog and rcv queue
75 * @link_cong: non-zero if owner must sleep because of link congestion
76 * @sent_unacked: # messages sent by socket, and not yet acked by peer
77 * @rcv_unacked: # messages read by user, but not yet acked back to peer
Erik Hugnef2f80362015-03-19 09:02:19 +010078 * @remote: 'connected' peer for dgram/rdm
Ying Xue07f6c4b2015-01-07 13:41:58 +080079 * @node: hash table node
80 * @rcu: rcu struct for tipc_sock
Jon Paul Maloy301bae52014-08-22 18:09:20 -040081 */
82struct tipc_sock {
83 struct sock sk;
84 int connected;
85 u32 conn_type;
86 u32 conn_instance;
87 int published;
88 u32 max_pkt;
Ying Xue07f6c4b2015-01-07 13:41:58 +080089 u32 portid;
Jon Paul Maloy301bae52014-08-22 18:09:20 -040090 struct tipc_msg phdr;
91 struct list_head sock_list;
92 struct list_head publications;
93 u32 pub_count;
94 u32 probing_state;
Ying Xue2f55c432015-01-09 15:27:00 +080095 unsigned long probing_intv;
Jon Paul Maloy301bae52014-08-22 18:09:20 -040096 uint conn_timeout;
97 atomic_t dupl_rcvcnt;
98 bool link_cong;
Jon Paul Maloy10724cc2016-05-02 11:58:47 -040099 u16 snt_unacked;
100 u16 snd_win;
Jon Paul Maloy60020e12016-05-02 11:58:46 -0400101 u16 peer_caps;
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400102 u16 rcv_unacked;
103 u16 rcv_win;
Erik Hugnef2f80362015-03-19 09:02:19 +0100104 struct sockaddr_tipc remote;
Ying Xue07f6c4b2015-01-07 13:41:58 +0800105 struct rhash_head node;
106 struct rcu_head rcu;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400107};
Per Lidenb97bf3f2006-01-02 19:04:38 +0100108
Jon Paul Maloy4f4482d2014-05-14 05:39:09 -0400109static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb);
David S. Miller676d2362014-04-11 16:15:36 -0400110static void tipc_data_ready(struct sock *sk);
Ying Xuef288bef2012-08-21 11:16:57 +0800111static void tipc_write_space(struct sock *sk);
Ying Xuef4195d12015-11-22 15:46:05 +0800112static void tipc_sock_destruct(struct sock *sk);
Ying Xue247f0f32014-02-18 16:06:46 +0800113static int tipc_release(struct socket *sock);
114static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags);
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400115static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p);
Ying Xuef2f2a962015-01-09 15:27:02 +0800116static void tipc_sk_timeout(unsigned long data);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400117static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400118 struct tipc_name_seq const *seq);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400119static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400120 struct tipc_name_seq const *seq);
Ying Xuee05b31f2015-01-09 15:27:08 +0800121static struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid);
Ying Xue07f6c4b2015-01-07 13:41:58 +0800122static int tipc_sk_insert(struct tipc_sock *tsk);
123static void tipc_sk_remove(struct tipc_sock *tsk);
Ying Xue39a02952015-03-02 15:37:47 +0800124static int __tipc_send_stream(struct socket *sock, struct msghdr *m,
125 size_t dsz);
126static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100127
Florian Westphalbca65ea2008-02-07 18:18:01 -0800128static const struct proto_ops packet_ops;
129static const struct proto_ops stream_ops;
130static const struct proto_ops msg_ops;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100131static struct proto tipc_proto;
132
Herbert Xu6cca72892015-03-20 21:57:05 +1100133static const struct rhashtable_params tsk_rht_params;
134
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900135/*
Allan Stephens0c3141e2008-04-15 00:22:02 -0700136 * Revised TIPC socket locking policy:
137 *
138 * Most socket operations take the standard socket lock when they start
139 * and hold it until they finish (or until they need to sleep). Acquiring
140 * this lock grants the owner exclusive access to the fields of the socket
141 * data structures, with the exception of the backlog queue. A few socket
142 * operations can be done without taking the socket lock because they only
143 * read socket information that never changes during the life of the socket.
144 *
145 * Socket operations may acquire the lock for the associated TIPC port if they
146 * need to perform an operation on the port. If any routine needs to acquire
147 * both the socket lock and the port lock it must take the socket lock first
148 * to avoid the risk of deadlock.
149 *
150 * The dispatcher handling incoming messages cannot grab the socket lock in
151 * the standard fashion, since invoked it runs at the BH level and cannot block.
152 * Instead, it checks to see if the socket lock is currently owned by someone,
153 * and either handles the message itself or adds it to the socket's backlog
154 * queue; in the latter case the queued message is processed once the process
155 * owning the socket lock releases it.
156 *
157 * NOTE: Releasing the socket lock while an operation is sleeping overcomes
158 * the problem of a blocked socket operation preventing any other operations
159 * from occurring. However, applications must be careful if they have
160 * multiple threads trying to send (or receive) on the same socket, as these
161 * operations might interfere with each other. For example, doing a connect
162 * and a receive at the same time might allow the receive to consume the
163 * ACK message meant for the connect. While additional work could be done
164 * to try and overcome this, it doesn't seem to be worthwhile at the present.
165 *
166 * NOTE: Releasing the socket lock while an operation is sleeping also ensures
167 * that another operation that must be performed in a non-blocking manner is
168 * not delayed for very long because the lock has already been taken.
169 *
170 * NOTE: This code assumes that certain fields of a port/socket pair are
171 * constant over its lifetime; such fields can be examined without taking
172 * the socket lock and/or port lock, and do not need to be re-read even
173 * after resuming processing after waiting. These fields include:
174 * - socket type
175 * - pointer to socket sk structure (aka tipc_sock structure)
176 * - pointer to port structure
177 * - port reference
Per Lidenb97bf3f2006-01-02 19:04:38 +0100178 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100179
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500180static u32 tsk_own_node(struct tipc_sock *tsk)
181{
182 return msg_prevnode(&tsk->phdr);
183}
184
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400185static u32 tsk_peer_node(struct tipc_sock *tsk)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400186{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400187 return msg_destnode(&tsk->phdr);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400188}
189
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400190static u32 tsk_peer_port(struct tipc_sock *tsk)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400191{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400192 return msg_destport(&tsk->phdr);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400193}
194
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400195static bool tsk_unreliable(struct tipc_sock *tsk)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400196{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400197 return msg_src_droppable(&tsk->phdr) != 0;
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400198}
199
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400200static void tsk_set_unreliable(struct tipc_sock *tsk, bool unreliable)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400201{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400202 msg_set_src_droppable(&tsk->phdr, unreliable ? 1 : 0);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400203}
204
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400205static bool tsk_unreturnable(struct tipc_sock *tsk)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400206{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400207 return msg_dest_droppable(&tsk->phdr) != 0;
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400208}
209
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400210static void tsk_set_unreturnable(struct tipc_sock *tsk, bool unreturnable)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400211{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400212 msg_set_dest_droppable(&tsk->phdr, unreturnable ? 1 : 0);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400213}
214
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400215static int tsk_importance(struct tipc_sock *tsk)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400216{
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400217 return msg_importance(&tsk->phdr);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400218}
219
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400220static int tsk_set_importance(struct tipc_sock *tsk, int imp)
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400221{
222 if (imp > TIPC_CRITICAL_IMPORTANCE)
223 return -EINVAL;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400224 msg_set_importance(&tsk->phdr, (u32)imp);
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400225 return 0;
226}
Jon Paul Maloy8826cde2014-03-12 11:31:09 -0400227
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400228static struct tipc_sock *tipc_sk(const struct sock *sk)
229{
230 return container_of(sk, struct tipc_sock, sk);
231}
232
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400233static bool tsk_conn_cong(struct tipc_sock *tsk)
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400234{
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400235 return tsk->snt_unacked >= tsk->snd_win;
236}
237
238/* tsk_blocks(): translate a buffer size in bytes to number of
239 * advertisable blocks, taking into account the ratio truesize(len)/len
240 * We can trust that this ratio is always < 4 for len >= FLOWCTL_BLK_SZ
241 */
242static u16 tsk_adv_blocks(int len)
243{
244 return len / FLOWCTL_BLK_SZ / 4;
245}
246
247/* tsk_inc(): increment counter for sent or received data
248 * - If block based flow control is not supported by peer we
249 * fall back to message based ditto, incrementing the counter
250 */
251static u16 tsk_inc(struct tipc_sock *tsk, int msglen)
252{
253 if (likely(tsk->peer_caps & TIPC_BLOCK_FLOWCTL))
254 return ((msglen / FLOWCTL_BLK_SZ) + 1);
255 return 1;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400256}
257
Per Lidenb97bf3f2006-01-02 19:04:38 +0100258/**
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400259 * tsk_advance_rx_queue - discard first buffer in socket receive queue
Allan Stephens0c3141e2008-04-15 00:22:02 -0700260 *
261 * Caller must hold socket lock
Per Lidenb97bf3f2006-01-02 19:04:38 +0100262 */
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400263static void tsk_advance_rx_queue(struct sock *sk)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100264{
Allan Stephens5f6d9122011-11-04 13:24:29 -0400265 kfree_skb(__skb_dequeue(&sk->sk_receive_queue));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100266}
267
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400268/* tipc_sk_respond() : send response message back to sender
269 */
270static void tipc_sk_respond(struct sock *sk, struct sk_buff *skb, int err)
271{
272 u32 selector;
273 u32 dnode;
274 u32 onode = tipc_own_addr(sock_net(sk));
275
276 if (!tipc_msg_reverse(onode, &skb, err))
277 return;
278
279 dnode = msg_destnode(buf_msg(skb));
280 selector = msg_origport(buf_msg(skb));
281 tipc_node_xmit_skb(sock_net(sk), skb, dnode, selector);
282}
283
Per Lidenb97bf3f2006-01-02 19:04:38 +0100284/**
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400285 * tsk_rej_rx_queue - reject all buffers in socket receive queue
Allan Stephens0c3141e2008-04-15 00:22:02 -0700286 *
287 * Caller must hold socket lock
288 */
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400289static void tsk_rej_rx_queue(struct sock *sk)
Allan Stephens0c3141e2008-04-15 00:22:02 -0700290{
Ying Xuea6ca1092014-11-26 11:41:55 +0800291 struct sk_buff *skb;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700292
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400293 while ((skb = __skb_dequeue(&sk->sk_receive_queue)))
294 tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700295}
296
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400297/* tsk_peer_msg - verify if message was sent by connected port's peer
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400298 *
299 * Handles cases where the node's network address has changed from
300 * the default of <0.0.0> to its configured setting.
301 */
Jon Paul Maloy2e84c602014-08-22 18:09:18 -0400302static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg)
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400303{
Ying Xue34747532015-01-09 15:27:10 +0800304 struct tipc_net *tn = net_generic(sock_net(&tsk->sk), tipc_net_id);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400305 u32 peer_port = tsk_peer_port(tsk);
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400306 u32 orig_node;
307 u32 peer_node;
308
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400309 if (unlikely(!tsk->connected))
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400310 return false;
311
312 if (unlikely(msg_origport(msg) != peer_port))
313 return false;
314
315 orig_node = msg_orignode(msg);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400316 peer_node = tsk_peer_node(tsk);
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400317
318 if (likely(orig_node == peer_node))
319 return true;
320
Ying Xue34747532015-01-09 15:27:10 +0800321 if (!orig_node && (peer_node == tn->own_addr))
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400322 return true;
323
Ying Xue34747532015-01-09 15:27:10 +0800324 if (!peer_node && (orig_node == tn->own_addr))
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -0400325 return true;
326
327 return false;
328}
329
Allan Stephens0c3141e2008-04-15 00:22:02 -0700330/**
Ying Xuec5fa7b32013-06-17 10:54:39 -0400331 * tipc_sk_create - create a TIPC socket
Allan Stephens0c3141e2008-04-15 00:22:02 -0700332 * @net: network namespace (must be default network)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100333 * @sock: pre-allocated socket structure
334 * @protocol: protocol indicator (must be 0)
Eric Paris3f378b62009-11-05 22:18:14 -0800335 * @kern: caused by kernel or by userspace?
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900336 *
Allan Stephens0c3141e2008-04-15 00:22:02 -0700337 * This routine creates additional data structures used by the TIPC socket,
338 * initializes them, and links them together.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100339 *
340 * Returns 0 on success, errno otherwise
341 */
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400342static int tipc_sk_create(struct net *net, struct socket *sock,
343 int protocol, int kern)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100344{
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500345 struct tipc_net *tn;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700346 const struct proto_ops *ops;
347 socket_state state;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100348 struct sock *sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400349 struct tipc_sock *tsk;
Jon Paul Maloy5b8fa7c2014-08-22 18:09:13 -0400350 struct tipc_msg *msg;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700351
352 /* Validate arguments */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100353 if (unlikely(protocol != 0))
354 return -EPROTONOSUPPORT;
355
Per Lidenb97bf3f2006-01-02 19:04:38 +0100356 switch (sock->type) {
357 case SOCK_STREAM:
Allan Stephens0c3141e2008-04-15 00:22:02 -0700358 ops = &stream_ops;
359 state = SS_UNCONNECTED;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100360 break;
361 case SOCK_SEQPACKET:
Allan Stephens0c3141e2008-04-15 00:22:02 -0700362 ops = &packet_ops;
363 state = SS_UNCONNECTED;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100364 break;
365 case SOCK_DGRAM:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100366 case SOCK_RDM:
Allan Stephens0c3141e2008-04-15 00:22:02 -0700367 ops = &msg_ops;
368 state = SS_READY;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100369 break;
Allan Stephens49978652006-06-25 23:47:18 -0700370 default:
Allan Stephens49978652006-06-25 23:47:18 -0700371 return -EPROTOTYPE;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100372 }
373
Allan Stephens0c3141e2008-04-15 00:22:02 -0700374 /* Allocate socket's protocol area */
Eric W. Biederman11aa9c22015-05-08 21:09:13 -0500375 sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto, kern);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700376 if (sk == NULL)
377 return -ENOMEM;
378
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400379 tsk = tipc_sk(sk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400380 tsk->max_pkt = MAX_PKT_DEFAULT;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400381 INIT_LIST_HEAD(&tsk->publications);
382 msg = &tsk->phdr;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500383 tn = net_generic(sock_net(sk), tipc_net_id);
384 tipc_msg_init(tn->own_addr, msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG,
Jon Paul Maloy5b8fa7c2014-08-22 18:09:13 -0400385 NAMED_H_SIZE, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100386
Allan Stephens0c3141e2008-04-15 00:22:02 -0700387 /* Finish initializing socket data structures */
Allan Stephens0c3141e2008-04-15 00:22:02 -0700388 sock->ops = ops;
389 sock->state = state;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100390 sock_init_data(sock, sk);
Ying Xue07f6c4b2015-01-07 13:41:58 +0800391 if (tipc_sk_insert(tsk)) {
Masanari Iidac19ca6c2016-02-08 20:53:12 +0900392 pr_warn("Socket create failed; port number exhausted\n");
Ying Xue07f6c4b2015-01-07 13:41:58 +0800393 return -EINVAL;
394 }
395 msg_set_origport(msg, tsk->portid);
Ying Xue3721e9c2015-01-13 17:07:48 +0800396 setup_timer(&sk->sk_timer, tipc_sk_timeout, (unsigned long)tsk);
Jon Paul Maloy4f4482d2014-05-14 05:39:09 -0400397 sk->sk_backlog_rcv = tipc_backlog_rcv;
Ying Xuecc79dd12013-06-17 10:54:37 -0400398 sk->sk_rcvbuf = sysctl_tipc_rmem[1];
Ying Xuef288bef2012-08-21 11:16:57 +0800399 sk->sk_data_ready = tipc_data_ready;
400 sk->sk_write_space = tipc_write_space;
Ying Xuef4195d12015-11-22 15:46:05 +0800401 sk->sk_destruct = tipc_sock_destruct;
Jon Paul Maloy4f4482d2014-05-14 05:39:09 -0400402 tsk->conn_timeout = CONN_TIMEOUT_DEFAULT;
403 atomic_set(&tsk->dupl_rcvcnt, 0);
Allan Stephens7ef43eb2008-05-12 15:42:28 -0700404
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400405 /* Start out with safe limits until we receive an advertised window */
406 tsk->snd_win = tsk_adv_blocks(RCVBUF_MIN);
407 tsk->rcv_win = tsk->snd_win;
408
Allan Stephens0c3141e2008-04-15 00:22:02 -0700409 if (sock->state == SS_READY) {
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400410 tsk_set_unreturnable(tsk, true);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700411 if (sock->type == SOCK_DGRAM)
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400412 tsk_set_unreliable(tsk, true);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700413 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100414 return 0;
415}
416
Ying Xue07f6c4b2015-01-07 13:41:58 +0800417static void tipc_sk_callback(struct rcu_head *head)
418{
419 struct tipc_sock *tsk = container_of(head, struct tipc_sock, rcu);
420
421 sock_put(&tsk->sk);
422}
423
Ying Xuec5fa7b32013-06-17 10:54:39 -0400424/**
Ying Xue247f0f32014-02-18 16:06:46 +0800425 * tipc_release - destroy a TIPC socket
Per Lidenb97bf3f2006-01-02 19:04:38 +0100426 * @sock: socket to destroy
427 *
428 * This routine cleans up any messages that are still queued on the socket.
429 * For DGRAM and RDM socket types, all queued messages are rejected.
430 * For SEQPACKET and STREAM socket types, the first message is rejected
431 * and any others are discarded. (If the first message on a STREAM socket
432 * is partially-read, it is discarded and the next one is rejected instead.)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900433 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100434 * NOTE: Rejected messages are not necessarily returned to the sender! They
435 * are returned or discarded according to the "destination droppable" setting
436 * specified for the message by the sender.
437 *
438 * Returns 0 on success, errno otherwise
439 */
Ying Xue247f0f32014-02-18 16:06:46 +0800440static int tipc_release(struct socket *sock)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100441{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100442 struct sock *sk = sock->sk;
Sasha Levin357c4772015-01-13 12:46:41 -0500443 struct net *net;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400444 struct tipc_sock *tsk;
Ying Xuea6ca1092014-11-26 11:41:55 +0800445 struct sk_buff *skb;
Ying Xue1ea23a22015-05-28 13:19:22 +0800446 u32 dnode;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100447
Allan Stephens0c3141e2008-04-15 00:22:02 -0700448 /*
449 * Exit if socket isn't fully initialized (occurs when a failed accept()
450 * releases a pre-allocated child socket that was never used)
451 */
Allan Stephens0c3141e2008-04-15 00:22:02 -0700452 if (sk == NULL)
453 return 0;
454
Sasha Levin357c4772015-01-13 12:46:41 -0500455 net = sock_net(sk);
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400456 tsk = tipc_sk(sk);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700457 lock_sock(sk);
458
459 /*
460 * Reject all unreceived messages, except on an active connection
461 * (which disconnects locally & sends a 'FIN+' to peer)
462 */
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400463 dnode = tsk_peer_node(tsk);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100464 while (sock->state != SS_DISCONNECTING) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800465 skb = __skb_dequeue(&sk->sk_receive_queue);
466 if (skb == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467 break;
Ying Xuea6ca1092014-11-26 11:41:55 +0800468 if (TIPC_SKB_CB(skb)->handle != NULL)
469 kfree_skb(skb);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700470 else {
471 if ((sock->state == SS_CONNECTING) ||
472 (sock->state == SS_CONNECTED)) {
473 sock->state = SS_DISCONNECTING;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400474 tsk->connected = 0;
Ying Xuef2f98002015-01-09 15:27:05 +0800475 tipc_node_remove_conn(net, dnode, tsk->portid);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700476 }
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400477 tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700478 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100479 }
480
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400481 tipc_sk_withdraw(tsk, 0, NULL);
Ying Xue1ea23a22015-05-28 13:19:22 +0800482 sk_stop_timer(sk, &sk->sk_timer);
Ying Xue07f6c4b2015-01-07 13:41:58 +0800483 tipc_sk_remove(tsk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400484 if (tsk->connected) {
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500485 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE,
Ying Xue34747532015-01-09 15:27:10 +0800486 TIPC_CONN_MSG, SHORT_H_SIZE, 0, dnode,
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500487 tsk_own_node(tsk), tsk_peer_port(tsk),
Ying Xue07f6c4b2015-01-07 13:41:58 +0800488 tsk->portid, TIPC_ERR_NO_PORT);
Ying Xuea6ca1092014-11-26 11:41:55 +0800489 if (skb)
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400490 tipc_node_xmit_skb(net, skb, dnode, tsk->portid);
Ying Xuef2f98002015-01-09 15:27:05 +0800491 tipc_node_remove_conn(net, dnode, tsk->portid);
Jon Paul Maloy5b8fa7c2014-08-22 18:09:13 -0400492 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100493
Allan Stephens0c3141e2008-04-15 00:22:02 -0700494 /* Reject any messages that accumulated in backlog queue */
Allan Stephens0c3141e2008-04-15 00:22:02 -0700495 sock->state = SS_DISCONNECTING;
496 release_sock(sk);
Ying Xue07f6c4b2015-01-07 13:41:58 +0800497
498 call_rcu(&tsk->rcu, tipc_sk_callback);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700499 sock->sk = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100500
Geert Uytterhoeven065d7e32014-04-06 15:56:14 +0200501 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100502}
503
504/**
Ying Xue247f0f32014-02-18 16:06:46 +0800505 * tipc_bind - associate or disassocate TIPC name(s) with a socket
Per Lidenb97bf3f2006-01-02 19:04:38 +0100506 * @sock: socket structure
507 * @uaddr: socket address describing name(s) and desired operation
508 * @uaddr_len: size of socket address data structure
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900509 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100510 * Name and name sequence binding is indicated using a positive scope value;
511 * a negative scope value unbinds the specified name. Specifying no name
512 * (i.e. a socket address length of 0) unbinds all names from the socket.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900513 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100514 * Returns 0 on success, errno otherwise
Allan Stephens0c3141e2008-04-15 00:22:02 -0700515 *
516 * NOTE: This routine doesn't need to take the socket lock since it doesn't
517 * access any non-constant socket information.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100518 */
Ying Xue247f0f32014-02-18 16:06:46 +0800519static int tipc_bind(struct socket *sock, struct sockaddr *uaddr,
520 int uaddr_len)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100521{
Ying Xue84602762013-12-27 10:18:28 +0800522 struct sock *sk = sock->sk;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100523 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400524 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xue84602762013-12-27 10:18:28 +0800525 int res = -EINVAL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100526
Ying Xue84602762013-12-27 10:18:28 +0800527 lock_sock(sk);
528 if (unlikely(!uaddr_len)) {
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400529 res = tipc_sk_withdraw(tsk, 0, NULL);
Ying Xue84602762013-12-27 10:18:28 +0800530 goto exit;
531 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900532
Ying Xue84602762013-12-27 10:18:28 +0800533 if (uaddr_len < sizeof(struct sockaddr_tipc)) {
534 res = -EINVAL;
535 goto exit;
536 }
537 if (addr->family != AF_TIPC) {
538 res = -EAFNOSUPPORT;
539 goto exit;
540 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100541
Per Lidenb97bf3f2006-01-02 19:04:38 +0100542 if (addr->addrtype == TIPC_ADDR_NAME)
543 addr->addr.nameseq.upper = addr->addr.nameseq.lower;
Ying Xue84602762013-12-27 10:18:28 +0800544 else if (addr->addrtype != TIPC_ADDR_NAMESEQ) {
545 res = -EAFNOSUPPORT;
546 goto exit;
547 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900548
Ying Xue13a2e892013-06-17 10:54:40 -0400549 if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) &&
Ying Xue7d0ab172013-06-17 10:54:41 -0400550 (addr->addr.nameseq.type != TIPC_TOP_SRV) &&
Ying Xue84602762013-12-27 10:18:28 +0800551 (addr->addr.nameseq.type != TIPC_CFG_SRV)) {
552 res = -EACCES;
553 goto exit;
554 }
Allan Stephensc422f1b2011-11-02 15:49:40 -0400555
Ying Xue84602762013-12-27 10:18:28 +0800556 res = (addr->scope > 0) ?
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400557 tipc_sk_publish(tsk, addr->scope, &addr->addr.nameseq) :
558 tipc_sk_withdraw(tsk, -addr->scope, &addr->addr.nameseq);
Ying Xue84602762013-12-27 10:18:28 +0800559exit:
560 release_sock(sk);
561 return res;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100562}
563
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900564/**
Ying Xue247f0f32014-02-18 16:06:46 +0800565 * tipc_getname - get port ID of socket or peer socket
Per Lidenb97bf3f2006-01-02 19:04:38 +0100566 * @sock: socket structure
567 * @uaddr: area for returned socket address
568 * @uaddr_len: area for returned length of socket address
Allan Stephens2da59912008-07-14 22:43:32 -0700569 * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900570 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100571 * Returns 0 on success, errno otherwise
Allan Stephens0c3141e2008-04-15 00:22:02 -0700572 *
Allan Stephens2da59912008-07-14 22:43:32 -0700573 * NOTE: This routine doesn't need to take the socket lock since it only
574 * accesses socket information that is unchanging (or which changes in
Allan Stephens0e659672010-12-31 18:59:32 +0000575 * a completely predictable manner).
Per Lidenb97bf3f2006-01-02 19:04:38 +0100576 */
Ying Xue247f0f32014-02-18 16:06:46 +0800577static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
578 int *uaddr_len, int peer)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100579{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100580 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400581 struct tipc_sock *tsk = tipc_sk(sock->sk);
Ying Xue34747532015-01-09 15:27:10 +0800582 struct tipc_net *tn = net_generic(sock_net(sock->sk), tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100583
Kulikov Vasiliy88f8a5e2010-10-31 07:10:32 +0000584 memset(addr, 0, sizeof(*addr));
Allan Stephens0c3141e2008-04-15 00:22:02 -0700585 if (peer) {
Allan Stephens2da59912008-07-14 22:43:32 -0700586 if ((sock->state != SS_CONNECTED) &&
587 ((peer != 2) || (sock->state != SS_DISCONNECTING)))
588 return -ENOTCONN;
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400589 addr->addr.id.ref = tsk_peer_port(tsk);
590 addr->addr.id.node = tsk_peer_node(tsk);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700591 } else {
Ying Xue07f6c4b2015-01-07 13:41:58 +0800592 addr->addr.id.ref = tsk->portid;
Ying Xue34747532015-01-09 15:27:10 +0800593 addr->addr.id.node = tn->own_addr;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700594 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100595
596 *uaddr_len = sizeof(*addr);
597 addr->addrtype = TIPC_ADDR_ID;
598 addr->family = AF_TIPC;
599 addr->scope = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100600 addr->addr.name.domain = 0;
601
Allan Stephens0c3141e2008-04-15 00:22:02 -0700602 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100603}
604
605/**
Ying Xue247f0f32014-02-18 16:06:46 +0800606 * tipc_poll - read and possibly block on pollmask
Per Lidenb97bf3f2006-01-02 19:04:38 +0100607 * @file: file structure associated with the socket
608 * @sock: socket for which to calculate the poll bits
609 * @wait: ???
610 *
Allan Stephens9b674e82008-03-26 16:48:21 -0700611 * Returns pollmask value
612 *
613 * COMMENTARY:
614 * It appears that the usual socket locking mechanisms are not useful here
615 * since the pollmask info is potentially out-of-date the moment this routine
616 * exits. TCP and other protocols seem to rely on higher level poll routines
617 * to handle any preventable race conditions, so TIPC will do the same ...
618 *
619 * TIPC sets the returned events as follows:
Allan Stephens9b674e82008-03-26 16:48:21 -0700620 *
Allan Stephensf662c072010-08-17 11:00:06 +0000621 * socket state flags set
622 * ------------ ---------
623 * unconnected no read flags
Erik Hugnec4fc2982012-10-16 16:47:06 +0200624 * POLLOUT if port is not congested
Allan Stephensf662c072010-08-17 11:00:06 +0000625 *
626 * connecting POLLIN/POLLRDNORM if ACK/NACK in rx queue
627 * no write flags
628 *
629 * connected POLLIN/POLLRDNORM if data in rx queue
630 * POLLOUT if port is not congested
631 *
632 * disconnecting POLLIN/POLLRDNORM/POLLHUP
633 * no write flags
634 *
635 * listening POLLIN if SYN in rx queue
636 * no write flags
637 *
638 * ready POLLIN/POLLRDNORM if data in rx queue
639 * [connectionless] POLLOUT (since port cannot be congested)
640 *
641 * IMPORTANT: The fact that a read or write operation is indicated does NOT
642 * imply that the operation will succeed, merely that it should be performed
643 * and will not block.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100644 */
Ying Xue247f0f32014-02-18 16:06:46 +0800645static unsigned int tipc_poll(struct file *file, struct socket *sock,
646 poll_table *wait)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100647{
Allan Stephens9b674e82008-03-26 16:48:21 -0700648 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400649 struct tipc_sock *tsk = tipc_sk(sk);
Allan Stephensf662c072010-08-17 11:00:06 +0000650 u32 mask = 0;
Allan Stephens9b674e82008-03-26 16:48:21 -0700651
Ying Xuef288bef2012-08-21 11:16:57 +0800652 sock_poll_wait(file, sk_sleep(sk), wait);
Allan Stephens9b674e82008-03-26 16:48:21 -0700653
Allan Stephensf662c072010-08-17 11:00:06 +0000654 switch ((int)sock->state) {
Erik Hugnec4fc2982012-10-16 16:47:06 +0200655 case SS_UNCONNECTED:
Jon Paul Maloy60120522014-06-25 20:41:42 -0500656 if (!tsk->link_cong)
Erik Hugnec4fc2982012-10-16 16:47:06 +0200657 mask |= POLLOUT;
658 break;
Allan Stephensf662c072010-08-17 11:00:06 +0000659 case SS_READY:
660 case SS_CONNECTED:
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400661 if (!tsk->link_cong && !tsk_conn_cong(tsk))
Allan Stephensf662c072010-08-17 11:00:06 +0000662 mask |= POLLOUT;
663 /* fall thru' */
664 case SS_CONNECTING:
665 case SS_LISTENING:
666 if (!skb_queue_empty(&sk->sk_receive_queue))
667 mask |= (POLLIN | POLLRDNORM);
668 break;
669 case SS_DISCONNECTING:
670 mask = (POLLIN | POLLRDNORM | POLLHUP);
671 break;
672 }
Allan Stephens9b674e82008-03-26 16:48:21 -0700673
674 return mask;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100675}
676
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400677/**
678 * tipc_sendmcast - send multicast message
679 * @sock: socket structure
680 * @seq: destination address
Al Viro562640f2014-11-15 01:13:43 -0500681 * @msg: message to send
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400682 * @dsz: total length of message data
683 * @timeo: timeout to wait for wakeup
684 *
685 * Called from function tipc_sendmsg(), which has done all sanity checks
686 * Returns the number of bytes sent on success, or errno
687 */
688static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq,
Al Viro562640f2014-11-15 01:13:43 -0500689 struct msghdr *msg, size_t dsz, long timeo)
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400690{
691 struct sock *sk = sock->sk;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500692 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xuef2f98002015-01-09 15:27:05 +0800693 struct net *net = sock_net(sk);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500694 struct tipc_msg *mhdr = &tsk->phdr;
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100695 struct sk_buff_head pktchain;
Al Virof25dcc72014-11-28 15:52:29 -0500696 struct iov_iter save = msg->msg_iter;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400697 uint mtu;
698 int rc;
699
700 msg_set_type(mhdr, TIPC_MCAST_MSG);
701 msg_set_lookup_scope(mhdr, TIPC_CLUSTER_SCOPE);
702 msg_set_destport(mhdr, 0);
703 msg_set_destnode(mhdr, 0);
704 msg_set_nametype(mhdr, seq->type);
705 msg_set_namelower(mhdr, seq->lower);
706 msg_set_nameupper(mhdr, seq->upper);
707 msg_set_hdr_sz(mhdr, MCAST_H_SIZE);
708
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100709 skb_queue_head_init(&pktchain);
710
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400711new_mtu:
Jon Paul Maloy959e1782015-10-22 08:51:43 -0400712 mtu = tipc_bcast_get_mtu(net);
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100713 rc = tipc_msg_build(mhdr, msg, 0, dsz, mtu, &pktchain);
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400714 if (unlikely(rc < 0))
715 return rc;
716
717 do {
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100718 rc = tipc_bcast_xmit(net, &pktchain);
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400719 if (likely(!rc))
720 return dsz;
721
722 if (rc == -ELINKCONG) {
723 tsk->link_cong = 1;
724 rc = tipc_wait_for_sndmsg(sock, &timeo);
725 if (!rc)
726 continue;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400727 }
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100728 __skb_queue_purge(&pktchain);
Al Virof25dcc72014-11-28 15:52:29 -0500729 if (rc == -EMSGSIZE) {
730 msg->msg_iter = save;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400731 goto new_mtu;
Al Virof25dcc72014-11-28 15:52:29 -0500732 }
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400733 break;
734 } while (1);
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400735 return rc;
736}
737
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500738/**
739 * tipc_sk_mcast_rcv - Deliver multicast messages to all destination sockets
740 * @arrvq: queue with arriving messages, to be cloned after destination lookup
741 * @inputq: queue with cloned messages, delivered to socket after dest lookup
742 *
743 * Multi-threaded: parallel calls with reference to same queues may occur
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400744 */
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500745void tipc_sk_mcast_rcv(struct net *net, struct sk_buff_head *arrvq,
746 struct sk_buff_head *inputq)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400747{
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500748 struct tipc_msg *msg;
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -0500749 struct tipc_plist dports;
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -0500750 u32 portid;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400751 u32 scope = TIPC_CLUSTER_SCOPE;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500752 struct sk_buff_head tmpq;
753 uint hsz;
754 struct sk_buff *skb, *_skb;
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -0500755
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500756 __skb_queue_head_init(&tmpq);
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -0500757 tipc_plist_init(&dports);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400758
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500759 skb = tipc_skb_peek(arrvq, &inputq->lock);
760 for (; skb; skb = tipc_skb_peek(arrvq, &inputq->lock)) {
761 msg = buf_msg(skb);
762 hsz = skb_headroom(skb) + msg_hdr_sz(msg);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400763
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500764 if (in_own_node(net, msg_orignode(msg)))
765 scope = TIPC_NODE_SCOPE;
766
767 /* Create destination port list and message clones: */
768 tipc_nametbl_mc_translate(net,
769 msg_nametype(msg), msg_namelower(msg),
770 msg_nameupper(msg), scope, &dports);
771 portid = tipc_plist_pop(&dports);
772 for (; portid; portid = tipc_plist_pop(&dports)) {
773 _skb = __pskb_copy(skb, hsz, GFP_ATOMIC);
774 if (_skb) {
775 msg_set_destport(buf_msg(_skb), portid);
776 __skb_queue_tail(&tmpq, _skb);
777 continue;
778 }
779 pr_warn("Failed to clone mcast rcv buffer\n");
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400780 }
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500781 /* Append to inputq if not already done by other thread */
782 spin_lock_bh(&inputq->lock);
783 if (skb_peek(arrvq) == skb) {
784 skb_queue_splice_tail_init(&tmpq, inputq);
785 kfree_skb(__skb_dequeue(arrvq));
786 }
787 spin_unlock_bh(&inputq->lock);
788 __skb_queue_purge(&tmpq);
789 kfree_skb(skb);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400790 }
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500791 tipc_sk_rcv(net, inputq);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400792}
793
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900794/**
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500795 * tipc_sk_proto_rcv - receive a connection mng protocol message
796 * @tsk: receiving socket
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400797 * @skb: pointer to message buffer.
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500798 */
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -0400799static void tipc_sk_proto_rcv(struct tipc_sock *tsk, struct sk_buff *skb,
800 struct sk_buff_head *xmitq)
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500801{
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400802 struct sock *sk = &tsk->sk;
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -0400803 u32 onode = tsk_own_node(tsk);
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400804 struct tipc_msg *hdr = buf_msg(skb);
805 int mtyp = msg_type(hdr);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400806 bool conn_cong;
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400807
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500808 /* Ignore if connection cannot be validated: */
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400809 if (!tsk_peer_msg(tsk, hdr))
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500810 goto exit;
811
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400812 tsk->probing_state = TIPC_CONN_OK;
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500813
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400814 if (mtyp == CONN_PROBE) {
815 msg_set_type(hdr, CONN_PROBE_REPLY);
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -0400816 if (tipc_msg_reverse(onode, &skb, TIPC_OK))
817 __skb_queue_tail(xmitq, skb);
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400818 return;
819 } else if (mtyp == CONN_ACK) {
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400820 conn_cong = tsk_conn_cong(tsk);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -0400821 tsk->snt_unacked -= msg_conn_ack(hdr);
822 if (tsk->peer_caps & TIPC_BLOCK_FLOWCTL)
823 tsk->snd_win = msg_adv_win(hdr);
Jon Paul Maloy60120522014-06-25 20:41:42 -0500824 if (conn_cong)
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400825 sk->sk_write_space(sk);
826 } else if (mtyp != CONN_PROBE_REPLY) {
827 pr_warn("Received unknown CONN_PROTO msg\n");
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500828 }
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500829exit:
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400830 kfree_skb(skb);
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500831}
832
Ying Xue3f405042014-01-17 09:50:05 +0800833static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p)
834{
835 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400836 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xue3f405042014-01-17 09:50:05 +0800837 DEFINE_WAIT(wait);
838 int done;
839
840 do {
841 int err = sock_error(sk);
842 if (err)
843 return err;
844 if (sock->state == SS_DISCONNECTING)
845 return -EPIPE;
846 if (!*timeo_p)
847 return -EAGAIN;
848 if (signal_pending(current))
849 return sock_intr_errno(*timeo_p);
850
851 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Jon Paul Maloy60120522014-06-25 20:41:42 -0500852 done = sk_wait_event(sk, timeo_p, !tsk->link_cong);
Ying Xue3f405042014-01-17 09:50:05 +0800853 finish_wait(sk_sleep(sk), &wait);
854 } while (!done);
855 return 0;
856}
857
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500858/**
Ying Xue247f0f32014-02-18 16:06:46 +0800859 * tipc_sendmsg - send message in connectionless manner
Per Lidenb97bf3f2006-01-02 19:04:38 +0100860 * @sock: socket structure
861 * @m: message to send
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500862 * @dsz: amount of user data to be sent
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900863 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100864 * Message must have an destination specified explicitly.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900865 * Used for SOCK_RDM and SOCK_DGRAM messages,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100866 * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
867 * (Note: 'SYN+' is prohibited on SOCK_STREAM.)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900868 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100869 * Returns the number of bytes sent on success, or errno otherwise
870 */
Ying Xue1b784142015-03-02 15:37:48 +0800871static int tipc_sendmsg(struct socket *sock,
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500872 struct msghdr *m, size_t dsz)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100873{
Ying Xue39a02952015-03-02 15:37:47 +0800874 struct sock *sk = sock->sk;
875 int ret;
876
877 lock_sock(sk);
878 ret = __tipc_sendmsg(sock, m, dsz);
879 release_sock(sk);
880
881 return ret;
882}
883
884static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz)
885{
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500886 DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
Allan Stephens0c3141e2008-04-15 00:22:02 -0700887 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400888 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xuef2f98002015-01-09 15:27:05 +0800889 struct net *net = sock_net(sk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400890 struct tipc_msg *mhdr = &tsk->phdr;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500891 u32 dnode, dport;
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100892 struct sk_buff_head pktchain;
Ying Xuea6ca1092014-11-26 11:41:55 +0800893 struct sk_buff *skb;
Erik Hugnef2f80362015-03-19 09:02:19 +0100894 struct tipc_name_seq *seq;
Al Virof25dcc72014-11-28 15:52:29 -0500895 struct iov_iter save;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500896 u32 mtu;
Ying Xue3f405042014-01-17 09:50:05 +0800897 long timeo;
Erik Hugne88b17b62014-12-03 14:44:44 +0100898 int rc;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100899
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500900 if (dsz > TIPC_MAX_USER_MSG_SIZE)
Allan Stephensc29c3f72010-04-20 17:58:24 -0400901 return -EMSGSIZE;
Erik Hugnef2f80362015-03-19 09:02:19 +0100902 if (unlikely(!dest)) {
903 if (tsk->connected && sock->state == SS_READY)
904 dest = &tsk->remote;
905 else
906 return -EDESTADDRREQ;
907 } else if (unlikely(m->msg_namelen < sizeof(*dest)) ||
908 dest->family != AF_TIPC) {
909 return -EINVAL;
910 }
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500911 if (unlikely(sock->state != SS_READY)) {
Ying Xue39a02952015-03-02 15:37:47 +0800912 if (sock->state == SS_LISTENING)
913 return -EPIPE;
914 if (sock->state != SS_UNCONNECTED)
915 return -EISCONN;
916 if (tsk->published)
917 return -EOPNOTSUPP;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700918 if (dest->addrtype == TIPC_ADDR_NAME) {
Jon Paul Maloy301bae52014-08-22 18:09:20 -0400919 tsk->conn_type = dest->addr.name.name.type;
920 tsk->conn_instance = dest->addr.name.name.instance;
Allan Stephens0c3141e2008-04-15 00:22:02 -0700921 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100922 }
Erik Hugnef2f80362015-03-19 09:02:19 +0100923 seq = &dest->addr.nameseq;
Ying Xue3f405042014-01-17 09:50:05 +0800924 timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500925
926 if (dest->addrtype == TIPC_ADDR_MCAST) {
Ying Xue39a02952015-03-02 15:37:47 +0800927 return tipc_sendmcast(sock, seq, m, dsz, timeo);
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500928 } else if (dest->addrtype == TIPC_ADDR_NAME) {
929 u32 type = dest->addr.name.name.type;
930 u32 inst = dest->addr.name.name.instance;
931 u32 domain = dest->addr.name.domain;
932
933 dnode = domain;
934 msg_set_type(mhdr, TIPC_NAMED_MSG);
935 msg_set_hdr_sz(mhdr, NAMED_H_SIZE);
936 msg_set_nametype(mhdr, type);
937 msg_set_nameinst(mhdr, inst);
938 msg_set_lookup_scope(mhdr, tipc_addr_scope(domain));
Ying Xue4ac1c8d2015-01-09 15:27:09 +0800939 dport = tipc_nametbl_translate(net, type, inst, &dnode);
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500940 msg_set_destnode(mhdr, dnode);
941 msg_set_destport(mhdr, dport);
Ying Xue39a02952015-03-02 15:37:47 +0800942 if (unlikely(!dport && !dnode))
943 return -EHOSTUNREACH;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500944 } else if (dest->addrtype == TIPC_ADDR_ID) {
945 dnode = dest->addr.id.node;
946 msg_set_type(mhdr, TIPC_DIRECT_MSG);
947 msg_set_lookup_scope(mhdr, 0);
948 msg_set_destnode(mhdr, dnode);
949 msg_set_destport(mhdr, dest->addr.id.ref);
950 msg_set_hdr_sz(mhdr, BASIC_H_SIZE);
951 }
952
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100953 skb_queue_head_init(&pktchain);
Al Virof25dcc72014-11-28 15:52:29 -0500954 save = m->msg_iter;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500955new_mtu:
Ying Xuef2f98002015-01-09 15:27:05 +0800956 mtu = tipc_node_get_mtu(net, dnode, tsk->portid);
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100957 rc = tipc_msg_build(mhdr, m, 0, dsz, mtu, &pktchain);
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500958 if (rc < 0)
Ying Xue39a02952015-03-02 15:37:47 +0800959 return rc;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500960
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900961 do {
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100962 skb = skb_peek(&pktchain);
Ying Xuea6ca1092014-11-26 11:41:55 +0800963 TIPC_SKB_CB(skb)->wakeup_pending = tsk->link_cong;
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100964 rc = tipc_node_xmit(net, &pktchain, dnode, tsk->portid);
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400965 if (likely(!rc)) {
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500966 if (sock->state != SS_READY)
Allan Stephens0c3141e2008-04-15 00:22:02 -0700967 sock->state = SS_CONNECTING;
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400968 return dsz;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900969 }
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400970 if (rc == -ELINKCONG) {
971 tsk->link_cong = 1;
972 rc = tipc_wait_for_sndmsg(sock, &timeo);
973 if (!rc)
974 continue;
975 }
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +0100976 __skb_queue_purge(&pktchain);
Al Virof25dcc72014-11-28 15:52:29 -0500977 if (rc == -EMSGSIZE) {
978 m->msg_iter = save;
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500979 goto new_mtu;
Al Virof25dcc72014-11-28 15:52:29 -0500980 }
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400981 break;
982 } while (1);
Jon Paul Maloye2dafe82014-06-25 20:41:37 -0500983
984 return rc;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100985}
986
Ying Xue391a6dd2014-01-17 09:50:06 +0800987static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p)
988{
989 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -0400990 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xue391a6dd2014-01-17 09:50:06 +0800991 DEFINE_WAIT(wait);
992 int done;
993
994 do {
995 int err = sock_error(sk);
996 if (err)
997 return err;
998 if (sock->state == SS_DISCONNECTING)
999 return -EPIPE;
1000 else if (sock->state != SS_CONNECTED)
1001 return -ENOTCONN;
1002 if (!*timeo_p)
1003 return -EAGAIN;
1004 if (signal_pending(current))
1005 return sock_intr_errno(*timeo_p);
1006
1007 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1008 done = sk_wait_event(sk, timeo_p,
Jon Paul Maloy60120522014-06-25 20:41:42 -05001009 (!tsk->link_cong &&
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001010 !tsk_conn_cong(tsk)) ||
1011 !tsk->connected);
Ying Xue391a6dd2014-01-17 09:50:06 +08001012 finish_wait(sk_sleep(sk), &wait);
1013 } while (!done);
1014 return 0;
1015}
1016
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001017/**
Ying Xue247f0f32014-02-18 16:06:46 +08001018 * tipc_send_stream - send stream-oriented data
Per Lidenb97bf3f2006-01-02 19:04:38 +01001019 * @sock: socket structure
1020 * @m: data to send
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001021 * @dsz: total length of data to be transmitted
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001022 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01001023 * Used for SOCK_STREAM data.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001024 *
1025 * Returns the number of bytes sent on success (or partial success),
Allan Stephens1303e8f2006-06-25 23:46:50 -07001026 * or errno if no data sent
Per Lidenb97bf3f2006-01-02 19:04:38 +01001027 */
Ying Xue1b784142015-03-02 15:37:48 +08001028static int tipc_send_stream(struct socket *sock, struct msghdr *m, size_t dsz)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001029{
Allan Stephens0c3141e2008-04-15 00:22:02 -07001030 struct sock *sk = sock->sk;
Ying Xue39a02952015-03-02 15:37:47 +08001031 int ret;
1032
1033 lock_sock(sk);
1034 ret = __tipc_send_stream(sock, m, dsz);
1035 release_sock(sk);
1036
1037 return ret;
1038}
1039
1040static int __tipc_send_stream(struct socket *sock, struct msghdr *m, size_t dsz)
1041{
1042 struct sock *sk = sock->sk;
Ying Xuef2f98002015-01-09 15:27:05 +08001043 struct net *net = sock_net(sk);
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001044 struct tipc_sock *tsk = tipc_sk(sk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001045 struct tipc_msg *mhdr = &tsk->phdr;
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001046 struct sk_buff_head pktchain;
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001047 DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
Ying Xue07f6c4b2015-01-07 13:41:58 +08001048 u32 portid = tsk->portid;
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001049 int rc = -EINVAL;
1050 long timeo;
1051 u32 dnode;
1052 uint mtu, send, sent = 0;
Al Virof25dcc72014-11-28 15:52:29 -05001053 struct iov_iter save;
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001054 int hlen = MIN_H_SIZE;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001055
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001056 /* Handle implied connection establishment */
1057 if (unlikely(dest)) {
Ying Xue39a02952015-03-02 15:37:47 +08001058 rc = __tipc_sendmsg(sock, m, dsz);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001059 hlen = msg_hdr_sz(mhdr);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001060 if (dsz && (dsz == rc))
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001061 tsk->snt_unacked = tsk_inc(tsk, dsz + hlen);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001062 return rc;
1063 }
1064 if (dsz > (uint)INT_MAX)
1065 return -EMSGSIZE;
Allan Stephens0c3141e2008-04-15 00:22:02 -07001066
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001067 if (unlikely(sock->state != SS_CONNECTED)) {
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001068 if (sock->state == SS_DISCONNECTING)
Ying Xue39a02952015-03-02 15:37:47 +08001069 return -EPIPE;
wangweidongb0555972013-12-27 10:09:39 +08001070 else
Ying Xue39a02952015-03-02 15:37:47 +08001071 return -ENOTCONN;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001072 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001073
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001074 timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001075 dnode = tsk_peer_node(tsk);
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001076 skb_queue_head_init(&pktchain);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001077
1078next:
Al Virof25dcc72014-11-28 15:52:29 -05001079 save = m->msg_iter;
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001080 mtu = tsk->max_pkt;
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001081 send = min_t(uint, dsz - sent, TIPC_MAX_USER_MSG_SIZE);
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001082 rc = tipc_msg_build(mhdr, m, sent, send, mtu, &pktchain);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001083 if (unlikely(rc < 0))
Ying Xue39a02952015-03-02 15:37:47 +08001084 return rc;
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001085
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001086 do {
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001087 if (likely(!tsk_conn_cong(tsk))) {
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001088 rc = tipc_node_xmit(net, &pktchain, dnode, portid);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001089 if (likely(!rc)) {
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001090 tsk->snt_unacked += tsk_inc(tsk, send + hlen);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001091 sent += send;
1092 if (sent == dsz)
Jon Paul Maloy22d85c72015-07-16 16:54:23 -04001093 return dsz;
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001094 goto next;
Allan Stephens1303e8f2006-06-25 23:46:50 -07001095 }
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001096 if (rc == -EMSGSIZE) {
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001097 __skb_queue_purge(&pktchain);
Ying Xuef2f98002015-01-09 15:27:05 +08001098 tsk->max_pkt = tipc_node_get_mtu(net, dnode,
1099 portid);
Al Virof25dcc72014-11-28 15:52:29 -05001100 m->msg_iter = save;
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001101 goto next;
1102 }
1103 if (rc != -ELINKCONG)
1104 break;
Jon Paul Maloy22d85c72015-07-16 16:54:23 -04001105
Jon Paul Maloy50100a52014-08-22 18:09:07 -04001106 tsk->link_cong = 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001107 }
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001108 rc = tipc_wait_for_sndpkt(sock, &timeo);
1109 } while (!rc);
Ying Xue39a02952015-03-02 15:37:47 +08001110
Parthasarathy Bhuvaraganf214fc42016-03-01 11:07:09 +01001111 __skb_queue_purge(&pktchain);
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001112 return sent ? sent : rc;
1113}
1114
1115/**
1116 * tipc_send_packet - send a connection-oriented message
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001117 * @sock: socket structure
1118 * @m: message to send
1119 * @dsz: length of data to be transmitted
1120 *
1121 * Used for SOCK_SEQPACKET messages.
1122 *
1123 * Returns the number of bytes sent on success, or errno otherwise
1124 */
Ying Xue1b784142015-03-02 15:37:48 +08001125static int tipc_send_packet(struct socket *sock, struct msghdr *m, size_t dsz)
Jon Paul Maloy4ccfe5e2014-06-25 20:41:38 -05001126{
1127 if (dsz > TIPC_MAX_USER_MSG_SIZE)
1128 return -EMSGSIZE;
1129
Ying Xue1b784142015-03-02 15:37:48 +08001130 return tipc_send_stream(sock, m, dsz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001131}
1132
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001133/* tipc_sk_finish_conn - complete the setup of a connection
Per Lidenb97bf3f2006-01-02 19:04:38 +01001134 */
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001135static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port,
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001136 u32 peer_node)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001137{
Ying Xue3721e9c2015-01-13 17:07:48 +08001138 struct sock *sk = &tsk->sk;
1139 struct net *net = sock_net(sk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001140 struct tipc_msg *msg = &tsk->phdr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001141
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001142 msg_set_destnode(msg, peer_node);
1143 msg_set_destport(msg, peer_port);
1144 msg_set_type(msg, TIPC_CONN_MSG);
1145 msg_set_lookup_scope(msg, 0);
1146 msg_set_hdr_sz(msg, SHORT_H_SIZE);
Jon Paul Maloyf9fef182014-03-12 11:31:08 -04001147
Ying Xue2f55c432015-01-09 15:27:00 +08001148 tsk->probing_intv = CONN_PROBING_INTERVAL;
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001149 tsk->probing_state = TIPC_CONN_OK;
1150 tsk->connected = 1;
Ying Xue3721e9c2015-01-13 17:07:48 +08001151 sk_reset_timer(sk, &sk->sk_timer, jiffies + tsk->probing_intv);
Ying Xuef2f98002015-01-09 15:27:05 +08001152 tipc_node_add_conn(net, peer_node, tsk->portid, peer_port);
1153 tsk->max_pkt = tipc_node_get_mtu(net, peer_node, tsk->portid);
Jon Paul Maloy60020e12016-05-02 11:58:46 -04001154 tsk->peer_caps = tipc_node_get_capabilities(net, peer_node);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001155 if (tsk->peer_caps & TIPC_BLOCK_FLOWCTL)
1156 return;
1157
1158 /* Fall back to message based flow control */
1159 tsk->rcv_win = FLOWCTL_MSG_WIN;
1160 tsk->snd_win = FLOWCTL_MSG_WIN;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001161}
1162
1163/**
1164 * set_orig_addr - capture sender's address for received message
1165 * @m: descriptor for message info
1166 * @msg: received message header
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001167 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01001168 * Note: Address is not captured if not requested by receiver.
1169 */
Sam Ravnborg05790c62006-03-20 22:37:04 -08001170static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001171{
Steffen Hurrle342dfc32014-01-17 22:53:15 +01001172 DECLARE_SOCKADDR(struct sockaddr_tipc *, addr, m->msg_name);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001173
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001174 if (addr) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001175 addr->family = AF_TIPC;
1176 addr->addrtype = TIPC_ADDR_ID;
Mathias Krause60085c32013-04-07 01:52:00 +00001177 memset(&addr->addr, 0, sizeof(addr->addr));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001178 addr->addr.id.ref = msg_origport(msg);
1179 addr->addr.id.node = msg_orignode(msg);
Allan Stephens0e659672010-12-31 18:59:32 +00001180 addr->addr.name.domain = 0; /* could leave uninitialized */
1181 addr->scope = 0; /* could leave uninitialized */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001182 m->msg_namelen = sizeof(struct sockaddr_tipc);
1183 }
1184}
1185
1186/**
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001187 * tipc_sk_anc_data_recv - optionally capture ancillary data for received message
Per Lidenb97bf3f2006-01-02 19:04:38 +01001188 * @m: descriptor for message info
1189 * @msg: received message header
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001190 * @tsk: TIPC port associated with message
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001191 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01001192 * Note: Ancillary data is not captured if not requested by receiver.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001193 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01001194 * Returns 0 if successful, otherwise errno
1195 */
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001196static int tipc_sk_anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
1197 struct tipc_sock *tsk)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001198{
1199 u32 anc_data[3];
1200 u32 err;
1201 u32 dest_type;
Allan Stephens3546c752006-06-25 23:45:24 -07001202 int has_name;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001203 int res;
1204
1205 if (likely(m->msg_controllen == 0))
1206 return 0;
1207
1208 /* Optionally capture errored message object(s) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001209 err = msg ? msg_errcode(msg) : 0;
1210 if (unlikely(err)) {
1211 anc_data[0] = err;
1212 anc_data[1] = msg_data_sz(msg);
Allan Stephens2db99832010-12-31 18:59:33 +00001213 res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data);
1214 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001215 return res;
Allan Stephens2db99832010-12-31 18:59:33 +00001216 if (anc_data[1]) {
1217 res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
1218 msg_data(msg));
1219 if (res)
1220 return res;
1221 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001222 }
1223
1224 /* Optionally capture message destination object */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001225 dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
1226 switch (dest_type) {
1227 case TIPC_NAMED_MSG:
Allan Stephens3546c752006-06-25 23:45:24 -07001228 has_name = 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001229 anc_data[0] = msg_nametype(msg);
1230 anc_data[1] = msg_namelower(msg);
1231 anc_data[2] = msg_namelower(msg);
1232 break;
1233 case TIPC_MCAST_MSG:
Allan Stephens3546c752006-06-25 23:45:24 -07001234 has_name = 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001235 anc_data[0] = msg_nametype(msg);
1236 anc_data[1] = msg_namelower(msg);
1237 anc_data[2] = msg_nameupper(msg);
1238 break;
1239 case TIPC_CONN_MSG:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001240 has_name = (tsk->conn_type != 0);
1241 anc_data[0] = tsk->conn_type;
1242 anc_data[1] = tsk->conn_instance;
1243 anc_data[2] = tsk->conn_instance;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001244 break;
1245 default:
Allan Stephens3546c752006-06-25 23:45:24 -07001246 has_name = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001247 }
Allan Stephens2db99832010-12-31 18:59:33 +00001248 if (has_name) {
1249 res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data);
1250 if (res)
1251 return res;
1252 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001253
1254 return 0;
1255}
1256
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001257static void tipc_sk_send_ack(struct tipc_sock *tsk)
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001258{
Ying Xuef2f98002015-01-09 15:27:05 +08001259 struct net *net = sock_net(&tsk->sk);
Ying Xuea6ca1092014-11-26 11:41:55 +08001260 struct sk_buff *skb = NULL;
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001261 struct tipc_msg *msg;
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001262 u32 peer_port = tsk_peer_port(tsk);
1263 u32 dnode = tsk_peer_node(tsk);
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001264
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001265 if (!tsk->connected)
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001266 return;
Jon Paul Maloyc5898632015-02-05 08:36:36 -05001267 skb = tipc_msg_create(CONN_MANAGER, CONN_ACK, INT_H_SIZE, 0,
1268 dnode, tsk_own_node(tsk), peer_port,
1269 tsk->portid, TIPC_OK);
Ying Xuea6ca1092014-11-26 11:41:55 +08001270 if (!skb)
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001271 return;
Ying Xuea6ca1092014-11-26 11:41:55 +08001272 msg = buf_msg(skb);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001273 msg_set_conn_ack(msg, tsk->rcv_unacked);
1274 tsk->rcv_unacked = 0;
1275
1276 /* Adjust to and advertize the correct window limit */
1277 if (tsk->peer_caps & TIPC_BLOCK_FLOWCTL) {
1278 tsk->rcv_win = tsk_adv_blocks(tsk->sk.sk_rcvbuf);
1279 msg_set_adv_win(msg, tsk->rcv_win);
1280 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001281 tipc_node_xmit_skb(net, skb, dnode, msg_link_selector(msg));
Jon Paul Maloy739f5e42014-08-22 18:09:12 -04001282}
1283
Arnaldo Carvalho de Melo85d3fc92014-05-23 15:55:12 -04001284static int tipc_wait_for_rcvmsg(struct socket *sock, long *timeop)
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001285{
1286 struct sock *sk = sock->sk;
1287 DEFINE_WAIT(wait);
Arnaldo Carvalho de Melo85d3fc92014-05-23 15:55:12 -04001288 long timeo = *timeop;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001289 int err;
1290
1291 for (;;) {
1292 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Ying Xuefe8e4642014-03-06 14:40:18 +01001293 if (timeo && skb_queue_empty(&sk->sk_receive_queue)) {
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001294 if (sock->state == SS_DISCONNECTING) {
1295 err = -ENOTCONN;
1296 break;
1297 }
1298 release_sock(sk);
1299 timeo = schedule_timeout(timeo);
1300 lock_sock(sk);
1301 }
1302 err = 0;
1303 if (!skb_queue_empty(&sk->sk_receive_queue))
1304 break;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001305 err = -EAGAIN;
1306 if (!timeo)
1307 break;
Erik Hugne143fe222015-03-09 10:43:42 +01001308 err = sock_intr_errno(timeo);
1309 if (signal_pending(current))
1310 break;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001311 }
1312 finish_wait(sk_sleep(sk), &wait);
Arnaldo Carvalho de Melo85d3fc92014-05-23 15:55:12 -04001313 *timeop = timeo;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001314 return err;
1315}
1316
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001317/**
Ying Xue247f0f32014-02-18 16:06:46 +08001318 * tipc_recvmsg - receive packet-oriented message
Per Lidenb97bf3f2006-01-02 19:04:38 +01001319 * @m: descriptor for message info
1320 * @buf_len: total size of user buffer area
1321 * @flags: receive flags
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001322 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01001323 * Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.
1324 * If the complete message doesn't fit in user area, truncate it.
1325 *
1326 * Returns size of returned message data, errno otherwise
1327 */
Ying Xue1b784142015-03-02 15:37:48 +08001328static int tipc_recvmsg(struct socket *sock, struct msghdr *m, size_t buf_len,
1329 int flags)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001330{
Allan Stephens0c3141e2008-04-15 00:22:02 -07001331 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001332 struct tipc_sock *tsk = tipc_sk(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001333 struct sk_buff *buf;
1334 struct tipc_msg *msg;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001335 long timeo;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001336 unsigned int sz;
1337 u32 err;
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001338 int res, hlen;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001339
Allan Stephens0c3141e2008-04-15 00:22:02 -07001340 /* Catch invalid receive requests */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001341 if (unlikely(!buf_len))
1342 return -EINVAL;
1343
Allan Stephens0c3141e2008-04-15 00:22:02 -07001344 lock_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001345
Allan Stephens0c3141e2008-04-15 00:22:02 -07001346 if (unlikely(sock->state == SS_UNCONNECTED)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001347 res = -ENOTCONN;
1348 goto exit;
1349 }
1350
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001351 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
Allan Stephens0c3141e2008-04-15 00:22:02 -07001352restart:
Per Lidenb97bf3f2006-01-02 19:04:38 +01001353
Allan Stephens0c3141e2008-04-15 00:22:02 -07001354 /* Look for a message in receive queue; wait if necessary */
Arnaldo Carvalho de Melo85d3fc92014-05-23 15:55:12 -04001355 res = tipc_wait_for_rcvmsg(sock, &timeo);
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001356 if (res)
1357 goto exit;
Allan Stephens0c3141e2008-04-15 00:22:02 -07001358
1359 /* Look at first message in receive queue */
Allan Stephens0c3141e2008-04-15 00:22:02 -07001360 buf = skb_peek(&sk->sk_receive_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001361 msg = buf_msg(buf);
1362 sz = msg_data_sz(msg);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001363 hlen = msg_hdr_sz(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001364 err = msg_errcode(msg);
1365
Per Lidenb97bf3f2006-01-02 19:04:38 +01001366 /* Discard an empty non-errored message & try again */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001367 if ((!sz) && (!err)) {
Jon Paul Maloy2e84c602014-08-22 18:09:18 -04001368 tsk_advance_rx_queue(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001369 goto restart;
1370 }
1371
1372 /* Capture sender's address (optional) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001373 set_orig_addr(m, msg);
1374
1375 /* Capture ancillary data (optional) */
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001376 res = tipc_sk_anc_data_recv(m, msg, tsk);
Allan Stephens0c3141e2008-04-15 00:22:02 -07001377 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001378 goto exit;
1379
1380 /* Capture message data (if valid) & compute return value (always) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001381 if (!err) {
1382 if (unlikely(buf_len < sz)) {
1383 sz = buf_len;
1384 m->msg_flags |= MSG_TRUNC;
1385 }
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001386 res = skb_copy_datagram_msg(buf, hlen, m, sz);
Allan Stephens0232fd02011-02-21 09:45:40 -05001387 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001388 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001389 res = sz;
1390 } else {
1391 if ((sock->state == SS_READY) ||
1392 ((err == TIPC_CONN_SHUTDOWN) || m->msg_control))
1393 res = 0;
1394 else
1395 res = -ECONNRESET;
1396 }
1397
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001398 if (unlikely(flags & MSG_PEEK))
1399 goto exit;
1400
1401 if (likely(sock->state != SS_READY)) {
1402 tsk->rcv_unacked += tsk_inc(tsk, hlen + sz);
1403 if (unlikely(tsk->rcv_unacked >= (tsk->rcv_win / 4)))
1404 tipc_sk_send_ack(tsk);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001405 }
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001406 tsk_advance_rx_queue(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001407exit:
Allan Stephens0c3141e2008-04-15 00:22:02 -07001408 release_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001409 return res;
1410}
1411
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001412/**
Ying Xue247f0f32014-02-18 16:06:46 +08001413 * tipc_recv_stream - receive stream-oriented data
Per Lidenb97bf3f2006-01-02 19:04:38 +01001414 * @m: descriptor for message info
1415 * @buf_len: total size of user buffer area
1416 * @flags: receive flags
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001417 *
1418 * Used for SOCK_STREAM messages only. If not enough data is available
Per Lidenb97bf3f2006-01-02 19:04:38 +01001419 * will optionally wait for more; never truncates data.
1420 *
1421 * Returns size of returned message data, errno otherwise
1422 */
Ying Xue1b784142015-03-02 15:37:48 +08001423static int tipc_recv_stream(struct socket *sock, struct msghdr *m,
1424 size_t buf_len, int flags)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001425{
Allan Stephens0c3141e2008-04-15 00:22:02 -07001426 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001427 struct tipc_sock *tsk = tipc_sk(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001428 struct sk_buff *buf;
1429 struct tipc_msg *msg;
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001430 long timeo;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001431 unsigned int sz;
Florian Westphal3720d402010-08-17 11:00:04 +00001432 int sz_to_copy, target, needed;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001433 int sz_copied = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001434 u32 err;
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001435 int res = 0, hlen;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001436
1437 /* Catch invalid receive attempts */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001438 if (unlikely(!buf_len))
1439 return -EINVAL;
1440
Allan Stephens0c3141e2008-04-15 00:22:02 -07001441 lock_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001442
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001443 if (unlikely(sock->state == SS_UNCONNECTED)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001444 res = -ENOTCONN;
1445 goto exit;
1446 }
1447
Florian Westphal3720d402010-08-17 11:00:04 +00001448 target = sock_rcvlowat(sk, flags & MSG_WAITALL, buf_len);
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001449 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001450
Allan Stephens0c3141e2008-04-15 00:22:02 -07001451restart:
Allan Stephens0c3141e2008-04-15 00:22:02 -07001452 /* Look for a message in receive queue; wait if necessary */
Arnaldo Carvalho de Melo85d3fc92014-05-23 15:55:12 -04001453 res = tipc_wait_for_rcvmsg(sock, &timeo);
Ying Xue9bbb4ec2014-01-17 09:50:07 +08001454 if (res)
1455 goto exit;
Allan Stephens0c3141e2008-04-15 00:22:02 -07001456
1457 /* Look at first message in receive queue */
Allan Stephens0c3141e2008-04-15 00:22:02 -07001458 buf = skb_peek(&sk->sk_receive_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001459 msg = buf_msg(buf);
1460 sz = msg_data_sz(msg);
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001461 hlen = msg_hdr_sz(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001462 err = msg_errcode(msg);
1463
1464 /* Discard an empty non-errored message & try again */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001465 if ((!sz) && (!err)) {
Jon Paul Maloy2e84c602014-08-22 18:09:18 -04001466 tsk_advance_rx_queue(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001467 goto restart;
1468 }
1469
1470 /* Optionally capture sender's address & ancillary data of first msg */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001471 if (sz_copied == 0) {
1472 set_orig_addr(m, msg);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04001473 res = tipc_sk_anc_data_recv(m, msg, tsk);
Allan Stephens0c3141e2008-04-15 00:22:02 -07001474 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001475 goto exit;
1476 }
1477
1478 /* Capture message data (if valid) & compute return value (always) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001479 if (!err) {
Allan Stephens0232fd02011-02-21 09:45:40 -05001480 u32 offset = (u32)(unsigned long)(TIPC_SKB_CB(buf)->handle);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001481
Allan Stephens0232fd02011-02-21 09:45:40 -05001482 sz -= offset;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001483 needed = (buf_len - sz_copied);
1484 sz_to_copy = (sz <= needed) ? sz : needed;
Allan Stephens0232fd02011-02-21 09:45:40 -05001485
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001486 res = skb_copy_datagram_msg(buf, hlen + offset, m, sz_to_copy);
Allan Stephens0232fd02011-02-21 09:45:40 -05001487 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001488 goto exit;
Allan Stephens0232fd02011-02-21 09:45:40 -05001489
Per Lidenb97bf3f2006-01-02 19:04:38 +01001490 sz_copied += sz_to_copy;
1491
1492 if (sz_to_copy < sz) {
1493 if (!(flags & MSG_PEEK))
Allan Stephens0232fd02011-02-21 09:45:40 -05001494 TIPC_SKB_CB(buf)->handle =
1495 (void *)(unsigned long)(offset + sz_to_copy);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001496 goto exit;
1497 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001498 } else {
1499 if (sz_copied != 0)
1500 goto exit; /* can't add error msg to valid data */
1501
1502 if ((err == TIPC_CONN_SHUTDOWN) || m->msg_control)
1503 res = 0;
1504 else
1505 res = -ECONNRESET;
1506 }
1507
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001508 if (unlikely(flags & MSG_PEEK))
1509 goto exit;
1510
1511 tsk->rcv_unacked += tsk_inc(tsk, hlen + sz);
1512 if (unlikely(tsk->rcv_unacked >= (tsk->rcv_win / 4)))
1513 tipc_sk_send_ack(tsk);
1514 tsk_advance_rx_queue(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001515
1516 /* Loop around if more data is required */
Joe Perchesf64f9e72009-11-29 16:55:45 -08001517 if ((sz_copied < buf_len) && /* didn't get all requested data */
1518 (!skb_queue_empty(&sk->sk_receive_queue) ||
Florian Westphal3720d402010-08-17 11:00:04 +00001519 (sz_copied < target)) && /* and more is ready or required */
Joe Perchesf64f9e72009-11-29 16:55:45 -08001520 (!err)) /* and haven't reached a FIN */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001521 goto restart;
1522
1523exit:
Allan Stephens0c3141e2008-04-15 00:22:02 -07001524 release_sock(sk);
Allan Stephensa3b0a5a2006-06-25 23:48:22 -07001525 return sz_copied ? sz_copied : res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001526}
1527
1528/**
Ying Xuef288bef2012-08-21 11:16:57 +08001529 * tipc_write_space - wake up thread if port congestion is released
1530 * @sk: socket
1531 */
1532static void tipc_write_space(struct sock *sk)
1533{
1534 struct socket_wq *wq;
1535
1536 rcu_read_lock();
1537 wq = rcu_dereference(sk->sk_wq);
Herbert Xu1ce0bf52015-11-26 13:55:39 +08001538 if (skwq_has_sleeper(wq))
Ying Xuef288bef2012-08-21 11:16:57 +08001539 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
1540 POLLWRNORM | POLLWRBAND);
1541 rcu_read_unlock();
1542}
1543
1544/**
1545 * tipc_data_ready - wake up threads to indicate messages have been received
1546 * @sk: socket
1547 * @len: the length of messages
1548 */
David S. Miller676d2362014-04-11 16:15:36 -04001549static void tipc_data_ready(struct sock *sk)
Ying Xuef288bef2012-08-21 11:16:57 +08001550{
1551 struct socket_wq *wq;
1552
1553 rcu_read_lock();
1554 wq = rcu_dereference(sk->sk_wq);
Herbert Xu1ce0bf52015-11-26 13:55:39 +08001555 if (skwq_has_sleeper(wq))
Ying Xuef288bef2012-08-21 11:16:57 +08001556 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
1557 POLLRDNORM | POLLRDBAND);
1558 rcu_read_unlock();
1559}
1560
Ying Xuef4195d12015-11-22 15:46:05 +08001561static void tipc_sock_destruct(struct sock *sk)
1562{
1563 __skb_queue_purge(&sk->sk_receive_queue);
1564}
1565
Ying Xuef288bef2012-08-21 11:16:57 +08001566/**
Ying Xue7e6c1312012-11-29 18:39:14 -05001567 * filter_connect - Handle all incoming messages for a connection-based socket
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001568 * @tsk: TIPC socket
Jon Paul Maloy1186adf2015-02-05 08:36:37 -05001569 * @skb: pointer to message buffer. Set to NULL if buffer is consumed
Ying Xue7e6c1312012-11-29 18:39:14 -05001570 *
Jon Paul Maloycda36962015-07-22 10:11:20 -04001571 * Returns true if everything ok, false otherwise
Ying Xue7e6c1312012-11-29 18:39:14 -05001572 */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001573static bool filter_connect(struct tipc_sock *tsk, struct sk_buff *skb)
Ying Xue7e6c1312012-11-29 18:39:14 -05001574{
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001575 struct sock *sk = &tsk->sk;
Ying Xuef2f98002015-01-09 15:27:05 +08001576 struct net *net = sock_net(sk);
Jon Paul Maloy8826cde2014-03-12 11:31:09 -04001577 struct socket *sock = sk->sk_socket;
Jon Paul Maloycda36962015-07-22 10:11:20 -04001578 struct tipc_msg *hdr = buf_msg(skb);
Ying Xue7e6c1312012-11-29 18:39:14 -05001579
Jon Paul Maloycda36962015-07-22 10:11:20 -04001580 if (unlikely(msg_mcast(hdr)))
1581 return false;
Ying Xue7e6c1312012-11-29 18:39:14 -05001582
1583 switch ((int)sock->state) {
1584 case SS_CONNECTED:
Jon Paul Maloycda36962015-07-22 10:11:20 -04001585
Ying Xue7e6c1312012-11-29 18:39:14 -05001586 /* Accept only connection-based messages sent by peer */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001587 if (unlikely(!tsk_peer_msg(tsk, hdr)))
1588 return false;
1589
1590 if (unlikely(msg_errcode(hdr))) {
1591 sock->state = SS_DISCONNECTING;
1592 tsk->connected = 0;
1593 /* Let timer expire on it's own */
1594 tipc_node_remove_conn(net, tsk_peer_node(tsk),
1595 tsk->portid);
Ying Xue7e6c1312012-11-29 18:39:14 -05001596 }
Jon Paul Maloycda36962015-07-22 10:11:20 -04001597 return true;
1598
Ying Xue7e6c1312012-11-29 18:39:14 -05001599 case SS_CONNECTING:
Jon Paul Maloycda36962015-07-22 10:11:20 -04001600
Ying Xue7e6c1312012-11-29 18:39:14 -05001601 /* Accept only ACK or NACK message */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001602 if (unlikely(!msg_connected(hdr)))
1603 return false;
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001604
Jon Paul Maloycda36962015-07-22 10:11:20 -04001605 if (unlikely(msg_errcode(hdr))) {
Ying Xue584d24b2012-11-29 18:51:19 -05001606 sock->state = SS_DISCONNECTING;
Erik Hugne2c8d8512013-08-28 09:29:58 +02001607 sk->sk_err = ECONNREFUSED;
Jon Paul Maloycda36962015-07-22 10:11:20 -04001608 return true;
Ying Xue584d24b2012-11-29 18:51:19 -05001609 }
1610
Jon Paul Maloycda36962015-07-22 10:11:20 -04001611 if (unlikely(!msg_isdata(hdr))) {
Ying Xue584d24b2012-11-29 18:51:19 -05001612 sock->state = SS_DISCONNECTING;
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001613 sk->sk_err = EINVAL;
Jon Paul Maloycda36962015-07-22 10:11:20 -04001614 return true;
Ying Xue584d24b2012-11-29 18:51:19 -05001615 }
1616
Jon Paul Maloycda36962015-07-22 10:11:20 -04001617 tipc_sk_finish_conn(tsk, msg_origport(hdr), msg_orignode(hdr));
1618 msg_set_importance(&tsk->phdr, msg_importance(hdr));
Jon Paul Maloydadebc02014-08-22 18:09:11 -04001619 sock->state = SS_CONNECTED;
1620
Jon Paul Maloycda36962015-07-22 10:11:20 -04001621 /* If 'ACK+' message, add to socket receive queue */
1622 if (msg_data_sz(hdr))
1623 return true;
1624
1625 /* If empty 'ACK-' message, wake up sleeping connect() */
1626 if (waitqueue_active(sk_sleep(sk)))
1627 wake_up_interruptible(sk_sleep(sk));
1628
1629 /* 'ACK-' message is neither accepted nor rejected: */
1630 msg_set_dest_droppable(hdr, 1);
1631 return false;
1632
Ying Xue7e6c1312012-11-29 18:39:14 -05001633 case SS_LISTENING:
1634 case SS_UNCONNECTED:
Jon Paul Maloycda36962015-07-22 10:11:20 -04001635
Ying Xue7e6c1312012-11-29 18:39:14 -05001636 /* Accept only SYN message */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001637 if (!msg_connected(hdr) && !(msg_errcode(hdr)))
1638 return true;
Ying Xue7e6c1312012-11-29 18:39:14 -05001639 break;
1640 case SS_DISCONNECTING:
1641 break;
1642 default:
1643 pr_err("Unknown socket state %u\n", sock->state);
1644 }
Jon Paul Maloycda36962015-07-22 10:11:20 -04001645 return false;
Ying Xue7e6c1312012-11-29 18:39:14 -05001646}
1647
1648/**
Ying Xueaba79f32013-01-20 23:30:09 +01001649 * rcvbuf_limit - get proper overload limit of socket receive queue
1650 * @sk: socket
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001651 * @skb: message
Ying Xueaba79f32013-01-20 23:30:09 +01001652 *
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001653 * For connection oriented messages, irrespective of importance,
1654 * default queue limit is 2 MB.
Ying Xueaba79f32013-01-20 23:30:09 +01001655 *
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001656 * For connectionless messages, queue limits are based on message
1657 * importance as follows:
Ying Xueaba79f32013-01-20 23:30:09 +01001658 *
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001659 * TIPC_LOW_IMPORTANCE (2 MB)
1660 * TIPC_MEDIUM_IMPORTANCE (4 MB)
1661 * TIPC_HIGH_IMPORTANCE (8 MB)
1662 * TIPC_CRITICAL_IMPORTANCE (16 MB)
Ying Xueaba79f32013-01-20 23:30:09 +01001663 *
1664 * Returns overload limit according to corresponding message importance
1665 */
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001666static unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *skb)
Ying Xueaba79f32013-01-20 23:30:09 +01001667{
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001668 struct tipc_sock *tsk = tipc_sk(sk);
1669 struct tipc_msg *hdr = buf_msg(skb);
Ying Xueaba79f32013-01-20 23:30:09 +01001670
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001671 if (unlikely(!msg_connected(hdr)))
1672 return sk->sk_rcvbuf << msg_importance(hdr);
wangweidong0cee6bb2013-12-12 09:36:39 +08001673
Jon Paul Maloy10724cc2016-05-02 11:58:47 -04001674 if (likely(tsk->peer_caps & TIPC_BLOCK_FLOWCTL))
1675 return sk->sk_rcvbuf;
1676
1677 return FLOWCTL_MSG_LIM;
Ying Xueaba79f32013-01-20 23:30:09 +01001678}
1679
1680/**
Allan Stephens0c3141e2008-04-15 00:22:02 -07001681 * filter_rcv - validate incoming message
1682 * @sk: socket
Jon Paul Maloycda36962015-07-22 10:11:20 -04001683 * @skb: pointer to message.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001684 *
Allan Stephens0c3141e2008-04-15 00:22:02 -07001685 * Enqueues message on receive queue if acceptable; optionally handles
1686 * disconnect indication for a connected socket.
1687 *
Jon Paul Maloy1186adf2015-02-05 08:36:37 -05001688 * Called with socket lock already taken
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001689 *
Jon Paul Maloycda36962015-07-22 10:11:20 -04001690 * Returns true if message was added to socket receive queue, otherwise false
Per Lidenb97bf3f2006-01-02 19:04:38 +01001691 */
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001692static bool filter_rcv(struct sock *sk, struct sk_buff *skb,
1693 struct sk_buff_head *xmitq)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001694{
Allan Stephens0c3141e2008-04-15 00:22:02 -07001695 struct socket *sock = sk->sk_socket;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04001696 struct tipc_sock *tsk = tipc_sk(sk);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001697 struct tipc_msg *hdr = buf_msg(skb);
1698 unsigned int limit = rcvbuf_limit(sk, skb);
1699 int err = TIPC_OK;
1700 int usr = msg_user(hdr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001701
Jon Paul Maloycda36962015-07-22 10:11:20 -04001702 if (unlikely(msg_user(hdr) == CONN_MANAGER)) {
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001703 tipc_sk_proto_rcv(tsk, skb, xmitq);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001704 return false;
Jon Paul Maloy1186adf2015-02-05 08:36:37 -05001705 }
Jon Paul Maloyec8a2e52014-06-25 20:41:40 -05001706
Jon Paul Maloycda36962015-07-22 10:11:20 -04001707 if (unlikely(usr == SOCK_WAKEUP)) {
1708 kfree_skb(skb);
Jon Paul Maloy50100a52014-08-22 18:09:07 -04001709 tsk->link_cong = 0;
1710 sk->sk_write_space(sk);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001711 return false;
Jon Paul Maloy50100a52014-08-22 18:09:07 -04001712 }
1713
Jon Paul Maloycda36962015-07-22 10:11:20 -04001714 /* Drop if illegal message type */
1715 if (unlikely(msg_type(hdr) > TIPC_DIRECT_MSG)) {
1716 kfree_skb(skb);
1717 return false;
1718 }
Allan Stephens0c3141e2008-04-15 00:22:02 -07001719
Jon Paul Maloycda36962015-07-22 10:11:20 -04001720 /* Reject if wrong message type for current socket state */
1721 if (unlikely(sock->state == SS_READY)) {
1722 if (msg_connected(hdr)) {
1723 err = TIPC_ERR_NO_PORT;
1724 goto reject;
1725 }
1726 } else if (unlikely(!filter_connect(tsk, skb))) {
1727 err = TIPC_ERR_NO_PORT;
1728 goto reject;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001729 }
1730
1731 /* Reject message if there isn't room to queue it */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001732 if (unlikely(sk_rmem_alloc_get(sk) + skb->truesize >= limit)) {
1733 err = TIPC_ERR_OVERLOAD;
1734 goto reject;
1735 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001736
Ying Xueaba79f32013-01-20 23:30:09 +01001737 /* Enqueue message */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001738 TIPC_SKB_CB(skb)->handle = NULL;
1739 __skb_queue_tail(&sk->sk_receive_queue, skb);
1740 skb_set_owner_r(skb, sk);
Allan Stephens0c3141e2008-04-15 00:22:02 -07001741
David S. Miller676d2362014-04-11 16:15:36 -04001742 sk->sk_data_ready(sk);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001743 return true;
1744
1745reject:
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001746 if (tipc_msg_reverse(tsk_own_node(tsk), &skb, err))
1747 __skb_queue_tail(xmitq, skb);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001748 return false;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001749}
1750
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001751/**
Jon Paul Maloy4f4482d2014-05-14 05:39:09 -04001752 * tipc_backlog_rcv - handle incoming message from backlog queue
Allan Stephens0c3141e2008-04-15 00:22:02 -07001753 * @sk: socket
Ying Xuea6ca1092014-11-26 11:41:55 +08001754 * @skb: message
Allan Stephens0c3141e2008-04-15 00:22:02 -07001755 *
Jon Paul Maloye3a77562015-02-05 08:36:39 -05001756 * Caller must hold socket lock
Allan Stephens0c3141e2008-04-15 00:22:02 -07001757 *
1758 * Returns 0
1759 */
Ying Xuea6ca1092014-11-26 11:41:55 +08001760static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb)
Allan Stephens0c3141e2008-04-15 00:22:02 -07001761{
Jon Paul Maloycda36962015-07-22 10:11:20 -04001762 unsigned int truesize = skb->truesize;
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001763 struct sk_buff_head xmitq;
1764 u32 dnode, selector;
Allan Stephens0c3141e2008-04-15 00:22:02 -07001765
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001766 __skb_queue_head_init(&xmitq);
1767
1768 if (likely(filter_rcv(sk, skb, &xmitq))) {
Jon Paul Maloycda36962015-07-22 10:11:20 -04001769 atomic_add(truesize, &tipc_sk(sk)->dupl_rcvcnt);
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001770 return 0;
1771 }
1772
1773 if (skb_queue_empty(&xmitq))
1774 return 0;
1775
1776 /* Send response/rejected message */
1777 skb = __skb_dequeue(&xmitq);
1778 dnode = msg_destnode(buf_msg(skb));
1779 selector = msg_origport(buf_msg(skb));
1780 tipc_node_xmit_skb(sock_net(sk), skb, dnode, selector);
Allan Stephens0c3141e2008-04-15 00:22:02 -07001781 return 0;
1782}
1783
1784/**
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001785 * tipc_sk_enqueue - extract all buffers with destination 'dport' from
1786 * inputq and try adding them to socket or backlog queue
1787 * @inputq: list of incoming buffers with potentially different destinations
1788 * @sk: socket where the buffers should be enqueued
1789 * @dport: port number for the socket
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001790 *
1791 * Caller must hold socket lock
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001792 */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001793static void tipc_sk_enqueue(struct sk_buff_head *inputq, struct sock *sk,
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001794 u32 dport, struct sk_buff_head *xmitq)
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001795{
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001796 unsigned long time_limit = jiffies + 2;
1797 struct sk_buff *skb;
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001798 unsigned int lim;
1799 atomic_t *dcnt;
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001800 u32 onode;
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001801
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001802 while (skb_queue_len(inputq)) {
Jon Paul Maloy51a00da2015-02-08 11:10:50 -05001803 if (unlikely(time_after_eq(jiffies, time_limit)))
Jon Paul Maloycda36962015-07-22 10:11:20 -04001804 return;
1805
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001806 skb = tipc_skb_dequeue(inputq, dport);
1807 if (unlikely(!skb))
Jon Paul Maloycda36962015-07-22 10:11:20 -04001808 return;
1809
1810 /* Add message directly to receive queue if possible */
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001811 if (!sock_owned_by_user(sk)) {
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001812 filter_rcv(sk, skb, xmitq);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001813 continue;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001814 }
Jon Paul Maloycda36962015-07-22 10:11:20 -04001815
1816 /* Try backlog, compensating for double-counted bytes */
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001817 dcnt = &tipc_sk(sk)->dupl_rcvcnt;
Jon Paul Maloy7c8bcfb2016-05-02 11:58:45 -04001818 if (!sk->sk_backlog.len)
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001819 atomic_set(dcnt, 0);
1820 lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt);
1821 if (likely(!sk_add_backlog(sk, skb, lim)))
1822 continue;
Jon Paul Maloycda36962015-07-22 10:11:20 -04001823
1824 /* Overload => reject message back to sender */
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001825 onode = tipc_own_addr(sock_net(sk));
1826 if (tipc_msg_reverse(onode, &skb, TIPC_ERR_OVERLOAD))
1827 __skb_queue_tail(xmitq, skb);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001828 break;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001829 }
Jon Paul Maloyd570d862015-02-05 08:36:38 -05001830}
1831
1832/**
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001833 * tipc_sk_rcv - handle a chain of incoming buffers
1834 * @inputq: buffer list containing the buffers
1835 * Consumes all buffers in list until inputq is empty
1836 * Note: may be called in multiple threads referring to the same queue
Allan Stephens0c3141e2008-04-15 00:22:02 -07001837 */
Jon Paul Maloycda36962015-07-22 10:11:20 -04001838void tipc_sk_rcv(struct net *net, struct sk_buff_head *inputq)
Allan Stephens0c3141e2008-04-15 00:22:02 -07001839{
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001840 struct sk_buff_head xmitq;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001841 u32 dnode, dport = 0;
Erik Hugne9871b272015-04-23 09:37:39 -04001842 int err;
Jon Paul Maloy9816f062014-05-14 05:39:15 -04001843 struct tipc_sock *tsk;
Jon Paul Maloy9816f062014-05-14 05:39:15 -04001844 struct sock *sk;
Jon Paul Maloycda36962015-07-22 10:11:20 -04001845 struct sk_buff *skb;
Jon Paul Maloy9816f062014-05-14 05:39:15 -04001846
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001847 __skb_queue_head_init(&xmitq);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001848 while (skb_queue_len(inputq)) {
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001849 dport = tipc_skb_peek_port(inputq, dport);
1850 tsk = tipc_sk_lookup(net, dport);
Jon Paul Maloycda36962015-07-22 10:11:20 -04001851
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001852 if (likely(tsk)) {
1853 sk = &tsk->sk;
1854 if (likely(spin_trylock_bh(&sk->sk_lock.slock))) {
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001855 tipc_sk_enqueue(inputq, sk, dport, &xmitq);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001856 spin_unlock_bh(&sk->sk_lock.slock);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001857 }
Jon Paul Maloyf1d048f2016-06-17 06:35:57 -04001858 /* Send pending response/rejected messages, if any */
1859 while ((skb = __skb_dequeue(&xmitq))) {
1860 dnode = msg_destnode(buf_msg(skb));
1861 tipc_node_xmit_skb(net, skb, dnode, dport);
1862 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001863 sock_put(sk);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001864 continue;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001865 }
Jon Paul Maloycda36962015-07-22 10:11:20 -04001866
1867 /* No destination socket => dequeue skb if still there */
1868 skb = tipc_skb_dequeue(inputq, dport);
1869 if (!skb)
1870 return;
1871
1872 /* Try secondary lookup if unresolved named message */
1873 err = TIPC_ERR_NO_PORT;
1874 if (tipc_msg_lookup_dest(net, skb, &err))
1875 goto xmit;
1876
1877 /* Prepare for message rejection */
1878 if (!tipc_msg_reverse(tipc_own_addr(net), &skb, err))
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001879 continue;
Jon Paul Maloye3a77562015-02-05 08:36:39 -05001880xmit:
Jon Paul Maloycda36962015-07-22 10:11:20 -04001881 dnode = msg_destnode(buf_msg(skb));
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001882 tipc_node_xmit_skb(net, skb, dnode, dport);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001883 }
Allan Stephens0c3141e2008-04-15 00:22:02 -07001884}
1885
Ying Xue78eb3a52014-01-17 09:50:03 +08001886static int tipc_wait_for_connect(struct socket *sock, long *timeo_p)
1887{
1888 struct sock *sk = sock->sk;
1889 DEFINE_WAIT(wait);
1890 int done;
1891
1892 do {
1893 int err = sock_error(sk);
1894 if (err)
1895 return err;
1896 if (!*timeo_p)
1897 return -ETIMEDOUT;
1898 if (signal_pending(current))
1899 return sock_intr_errno(*timeo_p);
1900
1901 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1902 done = sk_wait_event(sk, timeo_p, sock->state != SS_CONNECTING);
1903 finish_wait(sk_sleep(sk), &wait);
1904 } while (!done);
1905 return 0;
1906}
1907
Per Lidenb97bf3f2006-01-02 19:04:38 +01001908/**
Ying Xue247f0f32014-02-18 16:06:46 +08001909 * tipc_connect - establish a connection to another TIPC port
Per Lidenb97bf3f2006-01-02 19:04:38 +01001910 * @sock: socket structure
1911 * @dest: socket address for destination port
1912 * @destlen: size of socket address data structure
Allan Stephens0c3141e2008-04-15 00:22:02 -07001913 * @flags: file-related flags associated with socket
Per Lidenb97bf3f2006-01-02 19:04:38 +01001914 *
1915 * Returns 0 on success, errno otherwise
1916 */
Ying Xue247f0f32014-02-18 16:06:46 +08001917static int tipc_connect(struct socket *sock, struct sockaddr *dest,
1918 int destlen, int flags)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001919{
Allan Stephens0c3141e2008-04-15 00:22:02 -07001920 struct sock *sk = sock->sk;
Erik Hugnef2f80362015-03-19 09:02:19 +01001921 struct tipc_sock *tsk = tipc_sk(sk);
Allan Stephensb89741a2008-04-15 00:20:37 -07001922 struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
1923 struct msghdr m = {NULL,};
Erik Hugnef2f80362015-03-19 09:02:19 +01001924 long timeout = (flags & O_NONBLOCK) ? 0 : tsk->conn_timeout;
Ying Xue78eb3a52014-01-17 09:50:03 +08001925 socket_state previous;
Erik Hugnef2f80362015-03-19 09:02:19 +01001926 int res = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001927
Allan Stephens0c3141e2008-04-15 00:22:02 -07001928 lock_sock(sk);
1929
Erik Hugnef2f80362015-03-19 09:02:19 +01001930 /* DGRAM/RDM connect(), just save the destaddr */
Allan Stephens0c3141e2008-04-15 00:22:02 -07001931 if (sock->state == SS_READY) {
Erik Hugnef2f80362015-03-19 09:02:19 +01001932 if (dst->family == AF_UNSPEC) {
1933 memset(&tsk->remote, 0, sizeof(struct sockaddr_tipc));
1934 tsk->connected = 0;
Sasha Levin610600c2015-03-23 15:30:00 -04001935 } else if (destlen != sizeof(struct sockaddr_tipc)) {
1936 res = -EINVAL;
Erik Hugnef2f80362015-03-19 09:02:19 +01001937 } else {
1938 memcpy(&tsk->remote, dest, destlen);
1939 tsk->connected = 1;
1940 }
Allan Stephens0c3141e2008-04-15 00:22:02 -07001941 goto exit;
1942 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001943
Allan Stephensb89741a2008-04-15 00:20:37 -07001944 /*
1945 * Reject connection attempt using multicast address
1946 *
1947 * Note: send_msg() validates the rest of the address fields,
1948 * so there's no need to do it here
1949 */
Allan Stephens0c3141e2008-04-15 00:22:02 -07001950 if (dst->addrtype == TIPC_ADDR_MCAST) {
1951 res = -EINVAL;
1952 goto exit;
1953 }
1954
Ying Xue78eb3a52014-01-17 09:50:03 +08001955 previous = sock->state;
Ying Xue584d24b2012-11-29 18:51:19 -05001956 switch (sock->state) {
1957 case SS_UNCONNECTED:
1958 /* Send a 'SYN-' to destination */
1959 m.msg_name = dest;
1960 m.msg_namelen = destlen;
1961
1962 /* If connect is in non-blocking case, set MSG_DONTWAIT to
1963 * indicate send_msg() is never blocked.
1964 */
1965 if (!timeout)
1966 m.msg_flags = MSG_DONTWAIT;
1967
Ying Xue39a02952015-03-02 15:37:47 +08001968 res = __tipc_sendmsg(sock, &m, 0);
Ying Xue584d24b2012-11-29 18:51:19 -05001969 if ((res < 0) && (res != -EWOULDBLOCK))
1970 goto exit;
1971
1972 /* Just entered SS_CONNECTING state; the only
1973 * difference is that return value in non-blocking
1974 * case is EINPROGRESS, rather than EALREADY.
1975 */
1976 res = -EINPROGRESS;
Ying Xue584d24b2012-11-29 18:51:19 -05001977 case SS_CONNECTING:
Ying Xue78eb3a52014-01-17 09:50:03 +08001978 if (previous == SS_CONNECTING)
1979 res = -EALREADY;
1980 if (!timeout)
1981 goto exit;
1982 timeout = msecs_to_jiffies(timeout);
1983 /* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
1984 res = tipc_wait_for_connect(sock, &timeout);
Ying Xue584d24b2012-11-29 18:51:19 -05001985 break;
1986 case SS_CONNECTED:
1987 res = -EISCONN;
1988 break;
1989 default:
1990 res = -EINVAL;
Ying Xue78eb3a52014-01-17 09:50:03 +08001991 break;
Allan Stephensb89741a2008-04-15 00:20:37 -07001992 }
Allan Stephens0c3141e2008-04-15 00:22:02 -07001993exit:
1994 release_sock(sk);
Allan Stephensb89741a2008-04-15 00:20:37 -07001995 return res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001996}
1997
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001998/**
Ying Xue247f0f32014-02-18 16:06:46 +08001999 * tipc_listen - allow socket to listen for incoming connections
Per Lidenb97bf3f2006-01-02 19:04:38 +01002000 * @sock: socket structure
2001 * @len: (unused)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002002 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002003 * Returns 0 on success, errno otherwise
2004 */
Ying Xue247f0f32014-02-18 16:06:46 +08002005static int tipc_listen(struct socket *sock, int len)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002006{
Allan Stephens0c3141e2008-04-15 00:22:02 -07002007 struct sock *sk = sock->sk;
2008 int res;
2009
2010 lock_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002011
Ying Xue245f3d32011-07-06 06:01:13 -04002012 if (sock->state != SS_UNCONNECTED)
Allan Stephens0c3141e2008-04-15 00:22:02 -07002013 res = -EINVAL;
2014 else {
2015 sock->state = SS_LISTENING;
2016 res = 0;
2017 }
2018
2019 release_sock(sk);
2020 return res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002021}
2022
Ying Xue6398e232014-01-17 09:50:04 +08002023static int tipc_wait_for_accept(struct socket *sock, long timeo)
2024{
2025 struct sock *sk = sock->sk;
2026 DEFINE_WAIT(wait);
2027 int err;
2028
2029 /* True wake-one mechanism for incoming connections: only
2030 * one process gets woken up, not the 'whole herd'.
2031 * Since we do not 'race & poll' for established sockets
2032 * anymore, the common case will execute the loop only once.
2033 */
2034 for (;;) {
2035 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
2036 TASK_INTERRUPTIBLE);
Ying Xuefe8e4642014-03-06 14:40:18 +01002037 if (timeo && skb_queue_empty(&sk->sk_receive_queue)) {
Ying Xue6398e232014-01-17 09:50:04 +08002038 release_sock(sk);
2039 timeo = schedule_timeout(timeo);
2040 lock_sock(sk);
2041 }
2042 err = 0;
2043 if (!skb_queue_empty(&sk->sk_receive_queue))
2044 break;
2045 err = -EINVAL;
2046 if (sock->state != SS_LISTENING)
2047 break;
Ying Xue6398e232014-01-17 09:50:04 +08002048 err = -EAGAIN;
2049 if (!timeo)
2050 break;
Erik Hugne143fe222015-03-09 10:43:42 +01002051 err = sock_intr_errno(timeo);
2052 if (signal_pending(current))
2053 break;
Ying Xue6398e232014-01-17 09:50:04 +08002054 }
2055 finish_wait(sk_sleep(sk), &wait);
2056 return err;
2057}
2058
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002059/**
Ying Xue247f0f32014-02-18 16:06:46 +08002060 * tipc_accept - wait for connection request
Per Lidenb97bf3f2006-01-02 19:04:38 +01002061 * @sock: listening socket
2062 * @newsock: new socket that is to be connected
2063 * @flags: file-related flags associated with socket
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002064 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002065 * Returns 0 on success, errno otherwise
2066 */
Ying Xue247f0f32014-02-18 16:06:46 +08002067static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002068{
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002069 struct sock *new_sk, *sk = sock->sk;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002070 struct sk_buff *buf;
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002071 struct tipc_sock *new_tsock;
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002072 struct tipc_msg *msg;
Ying Xue6398e232014-01-17 09:50:04 +08002073 long timeo;
Allan Stephens0c3141e2008-04-15 00:22:02 -07002074 int res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002075
Allan Stephens0c3141e2008-04-15 00:22:02 -07002076 lock_sock(sk);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002077
Allan Stephens0c3141e2008-04-15 00:22:02 -07002078 if (sock->state != SS_LISTENING) {
2079 res = -EINVAL;
2080 goto exit;
2081 }
Ying Xue6398e232014-01-17 09:50:04 +08002082 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
2083 res = tipc_wait_for_accept(sock, timeo);
2084 if (res)
2085 goto exit;
Allan Stephens0c3141e2008-04-15 00:22:02 -07002086
2087 buf = skb_peek(&sk->sk_receive_queue);
2088
Ying Xuec5fa7b32013-06-17 10:54:39 -04002089 res = tipc_sk_create(sock_net(sock->sk), new_sock, 0, 1);
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002090 if (res)
2091 goto exit;
Stephen Smalleyfdd75ea2015-07-07 09:43:45 -04002092 security_sk_clone(sock->sk, new_sock->sk);
Allan Stephens0c3141e2008-04-15 00:22:02 -07002093
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002094 new_sk = new_sock->sk;
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002095 new_tsock = tipc_sk(new_sk);
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002096 msg = buf_msg(buf);
Allan Stephens0c3141e2008-04-15 00:22:02 -07002097
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002098 /* we lock on new_sk; but lockdep sees the lock on sk */
2099 lock_sock_nested(new_sk, SINGLE_DEPTH_NESTING);
Allan Stephens0c3141e2008-04-15 00:22:02 -07002100
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002101 /*
2102 * Reject any stray messages received by new socket
2103 * before the socket lock was taken (very, very unlikely)
2104 */
Jon Paul Maloy2e84c602014-08-22 18:09:18 -04002105 tsk_rej_rx_queue(new_sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002106
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002107 /* Connect new socket to it's peer */
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002108 tipc_sk_finish_conn(new_tsock, msg_origport(msg), msg_orignode(msg));
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002109 new_sock->state = SS_CONNECTED;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002110
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002111 tsk_set_importance(new_tsock, msg_importance(msg));
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002112 if (msg_named(msg)) {
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002113 new_tsock->conn_type = msg_nametype(msg);
2114 new_tsock->conn_instance = msg_nameinst(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002115 }
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002116
2117 /*
2118 * Respond to 'SYN-' by discarding it & returning 'ACK'-.
2119 * Respond to 'SYN+' by queuing it on new socket.
2120 */
2121 if (!msg_data_sz(msg)) {
2122 struct msghdr m = {NULL,};
2123
Jon Paul Maloy2e84c602014-08-22 18:09:18 -04002124 tsk_advance_rx_queue(sk);
Ying Xue39a02952015-03-02 15:37:47 +08002125 __tipc_send_stream(new_sock, &m, 0);
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002126 } else {
2127 __skb_dequeue(&sk->sk_receive_queue);
2128 __skb_queue_head(&new_sk->sk_receive_queue, buf);
Ying Xueaba79f32013-01-20 23:30:09 +01002129 skb_set_owner_r(buf, new_sk);
Paul Gortmaker0fef8f22012-12-04 11:01:55 -05002130 }
2131 release_sock(new_sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002132exit:
Allan Stephens0c3141e2008-04-15 00:22:02 -07002133 release_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002134 return res;
2135}
2136
2137/**
Ying Xue247f0f32014-02-18 16:06:46 +08002138 * tipc_shutdown - shutdown socket connection
Per Lidenb97bf3f2006-01-02 19:04:38 +01002139 * @sock: socket structure
Allan Stephense247a8f2008-03-06 15:05:38 -08002140 * @how: direction to close (must be SHUT_RDWR)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002141 *
2142 * Terminates connection (if necessary), then purges socket's receive queue.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002143 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002144 * Returns 0 on success, errno otherwise
2145 */
Ying Xue247f0f32014-02-18 16:06:46 +08002146static int tipc_shutdown(struct socket *sock, int how)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002147{
Allan Stephens0c3141e2008-04-15 00:22:02 -07002148 struct sock *sk = sock->sk;
Ying Xuef2f98002015-01-09 15:27:05 +08002149 struct net *net = sock_net(sk);
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04002150 struct tipc_sock *tsk = tipc_sk(sk);
Ying Xuea6ca1092014-11-26 11:41:55 +08002151 struct sk_buff *skb;
Jon Paul Maloycda36962015-07-22 10:11:20 -04002152 u32 dnode = tsk_peer_node(tsk);
2153 u32 dport = tsk_peer_port(tsk);
2154 u32 onode = tipc_own_addr(net);
2155 u32 oport = tsk->portid;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002156 int res;
2157
Allan Stephense247a8f2008-03-06 15:05:38 -08002158 if (how != SHUT_RDWR)
2159 return -EINVAL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002160
Allan Stephens0c3141e2008-04-15 00:22:02 -07002161 lock_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002162
2163 switch (sock->state) {
Allan Stephens0c3141e2008-04-15 00:22:02 -07002164 case SS_CONNECTING:
Per Lidenb97bf3f2006-01-02 19:04:38 +01002165 case SS_CONNECTED:
2166
Per Lidenb97bf3f2006-01-02 19:04:38 +01002167restart:
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -04002168 dnode = tsk_peer_node(tsk);
2169
Paul Gortmaker617d3c72012-04-30 15:29:02 -04002170 /* Disconnect and send a 'FIN+' or 'FIN-' message to peer */
Ying Xuea6ca1092014-11-26 11:41:55 +08002171 skb = __skb_dequeue(&sk->sk_receive_queue);
2172 if (skb) {
2173 if (TIPC_SKB_CB(skb)->handle != NULL) {
2174 kfree_skb(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002175 goto restart;
2176 }
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -04002177 tipc_sk_respond(sk, skb, TIPC_CONN_SHUTDOWN);
Allan Stephens0c3141e2008-04-15 00:22:02 -07002178 } else {
Jon Paul Maloyc5898632015-02-05 08:36:36 -05002179 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE,
Jon Paul Maloy80e44c22014-08-22 18:09:10 -04002180 TIPC_CONN_MSG, SHORT_H_SIZE,
Jon Paul Maloycda36962015-07-22 10:11:20 -04002181 0, dnode, onode, dport, oport,
2182 TIPC_CONN_SHUTDOWN);
Vegard Nossumd2fbdf72016-07-23 08:15:04 +02002183 if (skb)
2184 tipc_node_xmit_skb(net, skb, dnode, tsk->portid);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002185 }
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002186 tsk->connected = 0;
Allan Stephens0c3141e2008-04-15 00:22:02 -07002187 sock->state = SS_DISCONNECTING;
Ying Xuef2f98002015-01-09 15:27:05 +08002188 tipc_node_remove_conn(net, dnode, tsk->portid);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002189 /* fall through */
2190
2191 case SS_DISCONNECTING:
2192
Ying Xue75031152012-10-29 09:38:15 -04002193 /* Discard any unreceived messages */
Ying Xue57467e52013-01-20 23:30:08 +01002194 __skb_queue_purge(&sk->sk_receive_queue);
Ying Xue75031152012-10-29 09:38:15 -04002195
2196 /* Wake up anyone sleeping in poll */
2197 sk->sk_state_change(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002198 res = 0;
2199 break;
2200
2201 default:
2202 res = -ENOTCONN;
2203 }
2204
Allan Stephens0c3141e2008-04-15 00:22:02 -07002205 release_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002206 return res;
2207}
2208
Ying Xuef2f2a962015-01-09 15:27:02 +08002209static void tipc_sk_timeout(unsigned long data)
Jon Paul Maloy57289012014-08-22 18:09:09 -04002210{
Ying Xuef2f2a962015-01-09 15:27:02 +08002211 struct tipc_sock *tsk = (struct tipc_sock *)data;
2212 struct sock *sk = &tsk->sk;
Ying Xuea6ca1092014-11-26 11:41:55 +08002213 struct sk_buff *skb = NULL;
Jon Paul Maloy57289012014-08-22 18:09:09 -04002214 u32 peer_port, peer_node;
Jon Paul Maloyc5898632015-02-05 08:36:36 -05002215 u32 own_node = tsk_own_node(tsk);
Jon Paul Maloy57289012014-08-22 18:09:09 -04002216
Jon Paul Maloy57289012014-08-22 18:09:09 -04002217 bh_lock_sock(sk);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002218 if (!tsk->connected) {
Jon Paul Maloy6c9808c2014-08-22 18:09:16 -04002219 bh_unlock_sock(sk);
2220 goto exit;
2221 }
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002222 peer_port = tsk_peer_port(tsk);
2223 peer_node = tsk_peer_node(tsk);
Jon Paul Maloy57289012014-08-22 18:09:09 -04002224
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002225 if (tsk->probing_state == TIPC_CONN_PROBING) {
Erik Hugneb3be5e32015-06-09 17:27:12 +02002226 if (!sock_owned_by_user(sk)) {
2227 sk->sk_socket->state = SS_DISCONNECTING;
2228 tsk->connected = 0;
2229 tipc_node_remove_conn(sock_net(sk), tsk_peer_node(tsk),
2230 tsk_peer_port(tsk));
2231 sk->sk_state_change(sk);
2232 } else {
2233 /* Try again later */
2234 sk_reset_timer(sk, &sk->sk_timer, (HZ / 20));
2235 }
2236
Jon Paul Maloy57289012014-08-22 18:09:09 -04002237 } else {
Jon Paul Maloyc5898632015-02-05 08:36:36 -05002238 skb = tipc_msg_create(CONN_MANAGER, CONN_PROBE,
2239 INT_H_SIZE, 0, peer_node, own_node,
Ying Xuef2f2a962015-01-09 15:27:02 +08002240 peer_port, tsk->portid, TIPC_OK);
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002241 tsk->probing_state = TIPC_CONN_PROBING;
Ying Xue3721e9c2015-01-13 17:07:48 +08002242 sk_reset_timer(sk, &sk->sk_timer, jiffies + tsk->probing_intv);
Jon Paul Maloy57289012014-08-22 18:09:09 -04002243 }
2244 bh_unlock_sock(sk);
Ying Xuea6ca1092014-11-26 11:41:55 +08002245 if (skb)
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04002246 tipc_node_xmit_skb(sock_net(sk), skb, peer_node, tsk->portid);
Jon Paul Maloy6c9808c2014-08-22 18:09:16 -04002247exit:
Ying Xue07f6c4b2015-01-07 13:41:58 +08002248 sock_put(sk);
Jon Paul Maloy57289012014-08-22 18:09:09 -04002249}
2250
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002251static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002252 struct tipc_name_seq const *seq)
2253{
Ying Xuef2f98002015-01-09 15:27:05 +08002254 struct net *net = sock_net(&tsk->sk);
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002255 struct publication *publ;
2256 u32 key;
2257
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002258 if (tsk->connected)
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002259 return -EINVAL;
Ying Xue07f6c4b2015-01-07 13:41:58 +08002260 key = tsk->portid + tsk->pub_count + 1;
2261 if (key == tsk->portid)
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002262 return -EADDRINUSE;
2263
Ying Xuef2f98002015-01-09 15:27:05 +08002264 publ = tipc_nametbl_publish(net, seq->type, seq->lower, seq->upper,
Ying Xue07f6c4b2015-01-07 13:41:58 +08002265 scope, tsk->portid, key);
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002266 if (unlikely(!publ))
2267 return -EINVAL;
2268
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002269 list_add(&publ->pport_list, &tsk->publications);
2270 tsk->pub_count++;
2271 tsk->published = 1;
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002272 return 0;
2273}
2274
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002275static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002276 struct tipc_name_seq const *seq)
2277{
Ying Xuef2f98002015-01-09 15:27:05 +08002278 struct net *net = sock_net(&tsk->sk);
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002279 struct publication *publ;
2280 struct publication *safe;
2281 int rc = -EINVAL;
2282
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002283 list_for_each_entry_safe(publ, safe, &tsk->publications, pport_list) {
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002284 if (seq) {
2285 if (publ->scope != scope)
2286 continue;
2287 if (publ->type != seq->type)
2288 continue;
2289 if (publ->lower != seq->lower)
2290 continue;
2291 if (publ->upper != seq->upper)
2292 break;
Ying Xuef2f98002015-01-09 15:27:05 +08002293 tipc_nametbl_withdraw(net, publ->type, publ->lower,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002294 publ->ref, publ->key);
2295 rc = 0;
2296 break;
2297 }
Ying Xuef2f98002015-01-09 15:27:05 +08002298 tipc_nametbl_withdraw(net, publ->type, publ->lower,
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002299 publ->ref, publ->key);
2300 rc = 0;
2301 }
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002302 if (list_empty(&tsk->publications))
2303 tsk->published = 0;
Jon Paul Maloy0fc87aa2014-08-22 18:09:17 -04002304 return rc;
2305}
2306
Jon Paul Maloy5a9ee0be2014-08-22 18:09:14 -04002307/* tipc_sk_reinit: set non-zero address in all existing sockets
2308 * when we go from standalone to network mode.
2309 */
Ying Xuee05b31f2015-01-09 15:27:08 +08002310void tipc_sk_reinit(struct net *net)
Jon Paul Maloy5a9ee0be2014-08-22 18:09:14 -04002311{
Ying Xuee05b31f2015-01-09 15:27:08 +08002312 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002313 const struct bucket_table *tbl;
2314 struct rhash_head *pos;
2315 struct tipc_sock *tsk;
Jon Paul Maloy5a9ee0be2014-08-22 18:09:14 -04002316 struct tipc_msg *msg;
Ying Xue07f6c4b2015-01-07 13:41:58 +08002317 int i;
Jon Paul Maloy5a9ee0be2014-08-22 18:09:14 -04002318
Ying Xue07f6c4b2015-01-07 13:41:58 +08002319 rcu_read_lock();
Ying Xuee05b31f2015-01-09 15:27:08 +08002320 tbl = rht_dereference_rcu((&tn->sk_rht)->tbl, &tn->sk_rht);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002321 for (i = 0; i < tbl->size; i++) {
2322 rht_for_each_entry_rcu(tsk, pos, tbl, i, node) {
2323 spin_lock_bh(&tsk->sk.sk_lock.slock);
2324 msg = &tsk->phdr;
Ying Xue34747532015-01-09 15:27:10 +08002325 msg_set_prevnode(msg, tn->own_addr);
2326 msg_set_orignode(msg, tn->own_addr);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002327 spin_unlock_bh(&tsk->sk.sk_lock.slock);
2328 }
2329 }
2330 rcu_read_unlock();
2331}
2332
Ying Xuee05b31f2015-01-09 15:27:08 +08002333static struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid)
Ying Xue07f6c4b2015-01-07 13:41:58 +08002334{
Ying Xuee05b31f2015-01-09 15:27:08 +08002335 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002336 struct tipc_sock *tsk;
2337
2338 rcu_read_lock();
Herbert Xu6cca72892015-03-20 21:57:05 +11002339 tsk = rhashtable_lookup_fast(&tn->sk_rht, &portid, tsk_rht_params);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002340 if (tsk)
2341 sock_hold(&tsk->sk);
2342 rcu_read_unlock();
2343
2344 return tsk;
2345}
2346
2347static int tipc_sk_insert(struct tipc_sock *tsk)
2348{
Ying Xuee05b31f2015-01-09 15:27:08 +08002349 struct sock *sk = &tsk->sk;
2350 struct net *net = sock_net(sk);
2351 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002352 u32 remaining = (TIPC_MAX_PORT - TIPC_MIN_PORT) + 1;
2353 u32 portid = prandom_u32() % remaining + TIPC_MIN_PORT;
2354
2355 while (remaining--) {
2356 portid++;
2357 if ((portid < TIPC_MIN_PORT) || (portid > TIPC_MAX_PORT))
2358 portid = TIPC_MIN_PORT;
2359 tsk->portid = portid;
2360 sock_hold(&tsk->sk);
Herbert Xu6cca72892015-03-20 21:57:05 +11002361 if (!rhashtable_lookup_insert_fast(&tn->sk_rht, &tsk->node,
2362 tsk_rht_params))
Ying Xue07f6c4b2015-01-07 13:41:58 +08002363 return 0;
2364 sock_put(&tsk->sk);
2365 }
2366
2367 return -1;
2368}
2369
2370static void tipc_sk_remove(struct tipc_sock *tsk)
2371{
2372 struct sock *sk = &tsk->sk;
Ying Xuee05b31f2015-01-09 15:27:08 +08002373 struct tipc_net *tn = net_generic(sock_net(sk), tipc_net_id);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002374
Herbert Xu6cca72892015-03-20 21:57:05 +11002375 if (!rhashtable_remove_fast(&tn->sk_rht, &tsk->node, tsk_rht_params)) {
Ying Xue07f6c4b2015-01-07 13:41:58 +08002376 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
2377 __sock_put(sk);
Jon Paul Maloy5a9ee0be2014-08-22 18:09:14 -04002378 }
2379}
2380
Herbert Xu6cca72892015-03-20 21:57:05 +11002381static const struct rhashtable_params tsk_rht_params = {
2382 .nelem_hint = 192,
2383 .head_offset = offsetof(struct tipc_sock, node),
2384 .key_offset = offsetof(struct tipc_sock, portid),
2385 .key_len = sizeof(u32), /* portid */
Herbert Xu6cca72892015-03-20 21:57:05 +11002386 .max_size = 1048576,
2387 .min_size = 256,
Thomas Grafb5e2c152015-03-24 20:42:19 +00002388 .automatic_shrinking = true,
Herbert Xu6cca72892015-03-20 21:57:05 +11002389};
2390
Ying Xuee05b31f2015-01-09 15:27:08 +08002391int tipc_sk_rht_init(struct net *net)
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002392{
Ying Xuee05b31f2015-01-09 15:27:08 +08002393 struct tipc_net *tn = net_generic(net, tipc_net_id);
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002394
Herbert Xu6cca72892015-03-20 21:57:05 +11002395 return rhashtable_init(&tn->sk_rht, &tsk_rht_params);
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002396}
2397
Ying Xuee05b31f2015-01-09 15:27:08 +08002398void tipc_sk_rht_destroy(struct net *net)
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002399{
Ying Xuee05b31f2015-01-09 15:27:08 +08002400 struct tipc_net *tn = net_generic(net, tipc_net_id);
2401
Ying Xue07f6c4b2015-01-07 13:41:58 +08002402 /* Wait for socket readers to complete */
2403 synchronize_net();
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002404
Ying Xuee05b31f2015-01-09 15:27:08 +08002405 rhashtable_destroy(&tn->sk_rht);
Jon Paul Maloy808d90f2014-08-22 18:09:19 -04002406}
2407
2408/**
Ying Xue247f0f32014-02-18 16:06:46 +08002409 * tipc_setsockopt - set socket option
Per Lidenb97bf3f2006-01-02 19:04:38 +01002410 * @sock: socket structure
2411 * @lvl: option level
2412 * @opt: option identifier
2413 * @ov: pointer to new option value
2414 * @ol: length of option value
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002415 *
2416 * For stream sockets only, accepts and ignores all IPPROTO_TCP options
Per Lidenb97bf3f2006-01-02 19:04:38 +01002417 * (to ease compatibility).
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002418 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002419 * Returns 0 on success, errno otherwise
2420 */
Ying Xue247f0f32014-02-18 16:06:46 +08002421static int tipc_setsockopt(struct socket *sock, int lvl, int opt,
2422 char __user *ov, unsigned int ol)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002423{
Allan Stephens0c3141e2008-04-15 00:22:02 -07002424 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04002425 struct tipc_sock *tsk = tipc_sk(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002426 u32 value;
2427 int res;
2428
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002429 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
2430 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002431 if (lvl != SOL_TIPC)
2432 return -ENOPROTOOPT;
2433 if (ol < sizeof(value))
2434 return -EINVAL;
Allan Stephens2db99832010-12-31 18:59:33 +00002435 res = get_user(value, (u32 __user *)ov);
2436 if (res)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002437 return res;
2438
Allan Stephens0c3141e2008-04-15 00:22:02 -07002439 lock_sock(sk);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002440
Per Lidenb97bf3f2006-01-02 19:04:38 +01002441 switch (opt) {
2442 case TIPC_IMPORTANCE:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002443 res = tsk_set_importance(tsk, value);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002444 break;
2445 case TIPC_SRC_DROPPABLE:
2446 if (sock->type != SOCK_STREAM)
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002447 tsk_set_unreliable(tsk, value);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002448 else
Per Lidenb97bf3f2006-01-02 19:04:38 +01002449 res = -ENOPROTOOPT;
2450 break;
2451 case TIPC_DEST_DROPPABLE:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002452 tsk_set_unreturnable(tsk, value);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002453 break;
2454 case TIPC_CONN_TIMEOUT:
Allan Stephensa0f40f02011-05-26 13:44:34 -04002455 tipc_sk(sk)->conn_timeout = value;
Allan Stephens0c3141e2008-04-15 00:22:02 -07002456 /* no need to set "res", since already 0 at this point */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002457 break;
2458 default:
2459 res = -EINVAL;
2460 }
2461
Allan Stephens0c3141e2008-04-15 00:22:02 -07002462 release_sock(sk);
2463
Per Lidenb97bf3f2006-01-02 19:04:38 +01002464 return res;
2465}
2466
2467/**
Ying Xue247f0f32014-02-18 16:06:46 +08002468 * tipc_getsockopt - get socket option
Per Lidenb97bf3f2006-01-02 19:04:38 +01002469 * @sock: socket structure
2470 * @lvl: option level
2471 * @opt: option identifier
2472 * @ov: receptacle for option value
2473 * @ol: receptacle for length of option value
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002474 *
2475 * For stream sockets only, returns 0 length result for all IPPROTO_TCP options
Per Lidenb97bf3f2006-01-02 19:04:38 +01002476 * (to ease compatibility).
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002477 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002478 * Returns 0 on success, errno otherwise
2479 */
Ying Xue247f0f32014-02-18 16:06:46 +08002480static int tipc_getsockopt(struct socket *sock, int lvl, int opt,
2481 char __user *ov, int __user *ol)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002482{
Allan Stephens0c3141e2008-04-15 00:22:02 -07002483 struct sock *sk = sock->sk;
Jon Paul Maloy58ed9442014-03-12 11:31:12 -04002484 struct tipc_sock *tsk = tipc_sk(sk);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002485 int len;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002486 u32 value;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002487 int res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002488
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002489 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
2490 return put_user(0, ol);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002491 if (lvl != SOL_TIPC)
2492 return -ENOPROTOOPT;
Allan Stephens2db99832010-12-31 18:59:33 +00002493 res = get_user(len, ol);
2494 if (res)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002495 return res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002496
Allan Stephens0c3141e2008-04-15 00:22:02 -07002497 lock_sock(sk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002498
2499 switch (opt) {
2500 case TIPC_IMPORTANCE:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002501 value = tsk_importance(tsk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002502 break;
2503 case TIPC_SRC_DROPPABLE:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002504 value = tsk_unreliable(tsk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002505 break;
2506 case TIPC_DEST_DROPPABLE:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002507 value = tsk_unreturnable(tsk);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002508 break;
2509 case TIPC_CONN_TIMEOUT:
Jon Paul Maloy301bae52014-08-22 18:09:20 -04002510 value = tsk->conn_timeout;
Allan Stephens0c3141e2008-04-15 00:22:02 -07002511 /* no need to set "res", since already 0 at this point */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002512 break;
Allan Stephens0e659672010-12-31 18:59:32 +00002513 case TIPC_NODE_RECVQ_DEPTH:
Ying Xue9da3d472012-11-27 06:15:27 -05002514 value = 0; /* was tipc_queue_size, now obsolete */
oscar.medina@motorola.com66506132009-06-30 03:25:39 +00002515 break;
Allan Stephens0e659672010-12-31 18:59:32 +00002516 case TIPC_SOCK_RECVQ_DEPTH:
oscar.medina@motorola.com66506132009-06-30 03:25:39 +00002517 value = skb_queue_len(&sk->sk_receive_queue);
2518 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002519 default:
2520 res = -EINVAL;
2521 }
2522
Allan Stephens0c3141e2008-04-15 00:22:02 -07002523 release_sock(sk);
2524
Paul Gortmaker25860c32010-12-31 18:59:31 +00002525 if (res)
2526 return res; /* "get" failed */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002527
Paul Gortmaker25860c32010-12-31 18:59:31 +00002528 if (len < sizeof(value))
2529 return -EINVAL;
2530
2531 if (copy_to_user(ov, &value, sizeof(value)))
2532 return -EFAULT;
2533
2534 return put_user(sizeof(value), ol);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002535}
2536
Ying Xuef2f98002015-01-09 15:27:05 +08002537static int tipc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
Erik Hugne78acb1f2014-04-24 16:26:47 +02002538{
Ying Xuef2f98002015-01-09 15:27:05 +08002539 struct sock *sk = sock->sk;
Erik Hugne78acb1f2014-04-24 16:26:47 +02002540 struct tipc_sioc_ln_req lnr;
2541 void __user *argp = (void __user *)arg;
2542
2543 switch (cmd) {
2544 case SIOCGETLINKNAME:
2545 if (copy_from_user(&lnr, argp, sizeof(lnr)))
2546 return -EFAULT;
Ying Xuef2f98002015-01-09 15:27:05 +08002547 if (!tipc_node_get_linkname(sock_net(sk),
2548 lnr.bearer_id & 0xffff, lnr.peer,
Erik Hugne78acb1f2014-04-24 16:26:47 +02002549 lnr.linkname, TIPC_MAX_LINK_NAME)) {
2550 if (copy_to_user(argp, &lnr, sizeof(lnr)))
2551 return -EFAULT;
2552 return 0;
2553 }
2554 return -EADDRNOTAVAIL;
Erik Hugne78acb1f2014-04-24 16:26:47 +02002555 default:
2556 return -ENOIOCTLCMD;
2557 }
2558}
2559
Ben Hutchingsae86b9e2012-07-10 10:55:35 +00002560/* Protocol switches for the various types of TIPC sockets */
2561
Florian Westphalbca65ea2008-02-07 18:18:01 -08002562static const struct proto_ops msg_ops = {
Allan Stephens0e659672010-12-31 18:59:32 +00002563 .owner = THIS_MODULE,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002564 .family = AF_TIPC,
Ying Xue247f0f32014-02-18 16:06:46 +08002565 .release = tipc_release,
2566 .bind = tipc_bind,
2567 .connect = tipc_connect,
Allan Stephens5eee6a62007-06-10 17:24:55 -07002568 .socketpair = sock_no_socketpair,
Ying Xue245f3d32011-07-06 06:01:13 -04002569 .accept = sock_no_accept,
Ying Xue247f0f32014-02-18 16:06:46 +08002570 .getname = tipc_getname,
2571 .poll = tipc_poll,
Erik Hugne78acb1f2014-04-24 16:26:47 +02002572 .ioctl = tipc_ioctl,
Ying Xue245f3d32011-07-06 06:01:13 -04002573 .listen = sock_no_listen,
Ying Xue247f0f32014-02-18 16:06:46 +08002574 .shutdown = tipc_shutdown,
2575 .setsockopt = tipc_setsockopt,
2576 .getsockopt = tipc_getsockopt,
2577 .sendmsg = tipc_sendmsg,
2578 .recvmsg = tipc_recvmsg,
YOSHIFUJI Hideaki82387452007-07-19 10:44:56 +09002579 .mmap = sock_no_mmap,
2580 .sendpage = sock_no_sendpage
Per Lidenb97bf3f2006-01-02 19:04:38 +01002581};
2582
Florian Westphalbca65ea2008-02-07 18:18:01 -08002583static const struct proto_ops packet_ops = {
Allan Stephens0e659672010-12-31 18:59:32 +00002584 .owner = THIS_MODULE,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002585 .family = AF_TIPC,
Ying Xue247f0f32014-02-18 16:06:46 +08002586 .release = tipc_release,
2587 .bind = tipc_bind,
2588 .connect = tipc_connect,
Allan Stephens5eee6a62007-06-10 17:24:55 -07002589 .socketpair = sock_no_socketpair,
Ying Xue247f0f32014-02-18 16:06:46 +08002590 .accept = tipc_accept,
2591 .getname = tipc_getname,
2592 .poll = tipc_poll,
Erik Hugne78acb1f2014-04-24 16:26:47 +02002593 .ioctl = tipc_ioctl,
Ying Xue247f0f32014-02-18 16:06:46 +08002594 .listen = tipc_listen,
2595 .shutdown = tipc_shutdown,
2596 .setsockopt = tipc_setsockopt,
2597 .getsockopt = tipc_getsockopt,
2598 .sendmsg = tipc_send_packet,
2599 .recvmsg = tipc_recvmsg,
YOSHIFUJI Hideaki82387452007-07-19 10:44:56 +09002600 .mmap = sock_no_mmap,
2601 .sendpage = sock_no_sendpage
Per Lidenb97bf3f2006-01-02 19:04:38 +01002602};
2603
Florian Westphalbca65ea2008-02-07 18:18:01 -08002604static const struct proto_ops stream_ops = {
Allan Stephens0e659672010-12-31 18:59:32 +00002605 .owner = THIS_MODULE,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002606 .family = AF_TIPC,
Ying Xue247f0f32014-02-18 16:06:46 +08002607 .release = tipc_release,
2608 .bind = tipc_bind,
2609 .connect = tipc_connect,
Allan Stephens5eee6a62007-06-10 17:24:55 -07002610 .socketpair = sock_no_socketpair,
Ying Xue247f0f32014-02-18 16:06:46 +08002611 .accept = tipc_accept,
2612 .getname = tipc_getname,
2613 .poll = tipc_poll,
Erik Hugne78acb1f2014-04-24 16:26:47 +02002614 .ioctl = tipc_ioctl,
Ying Xue247f0f32014-02-18 16:06:46 +08002615 .listen = tipc_listen,
2616 .shutdown = tipc_shutdown,
2617 .setsockopt = tipc_setsockopt,
2618 .getsockopt = tipc_getsockopt,
2619 .sendmsg = tipc_send_stream,
2620 .recvmsg = tipc_recv_stream,
YOSHIFUJI Hideaki82387452007-07-19 10:44:56 +09002621 .mmap = sock_no_mmap,
2622 .sendpage = sock_no_sendpage
Per Lidenb97bf3f2006-01-02 19:04:38 +01002623};
2624
Florian Westphalbca65ea2008-02-07 18:18:01 -08002625static const struct net_proto_family tipc_family_ops = {
Allan Stephens0e659672010-12-31 18:59:32 +00002626 .owner = THIS_MODULE,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002627 .family = AF_TIPC,
Ying Xuec5fa7b32013-06-17 10:54:39 -04002628 .create = tipc_sk_create
Per Lidenb97bf3f2006-01-02 19:04:38 +01002629};
2630
2631static struct proto tipc_proto = {
2632 .name = "TIPC",
2633 .owner = THIS_MODULE,
Ying Xuecc79dd12013-06-17 10:54:37 -04002634 .obj_size = sizeof(struct tipc_sock),
2635 .sysctl_rmem = sysctl_tipc_rmem
Per Lidenb97bf3f2006-01-02 19:04:38 +01002636};
2637
2638/**
Per Liden4323add2006-01-18 00:38:21 +01002639 * tipc_socket_init - initialize TIPC socket interface
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002640 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002641 * Returns 0 on success, errno otherwise
2642 */
Per Liden4323add2006-01-18 00:38:21 +01002643int tipc_socket_init(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002644{
2645 int res;
2646
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002647 res = proto_register(&tipc_proto, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002648 if (res) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002649 pr_err("Failed to register TIPC protocol type\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002650 goto out;
2651 }
2652
2653 res = sock_register(&tipc_family_ops);
2654 if (res) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002655 pr_err("Failed to register TIPC socket type\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002656 proto_unregister(&tipc_proto);
2657 goto out;
2658 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002659 out:
2660 return res;
2661}
2662
2663/**
Per Liden4323add2006-01-18 00:38:21 +01002664 * tipc_socket_stop - stop TIPC socket interface
Per Lidenb97bf3f2006-01-02 19:04:38 +01002665 */
Per Liden4323add2006-01-18 00:38:21 +01002666void tipc_socket_stop(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002667{
Per Lidenb97bf3f2006-01-02 19:04:38 +01002668 sock_unregister(tipc_family_ops.family);
2669 proto_unregister(&tipc_proto);
2670}
Richard Alpe34b78a122014-11-20 10:29:10 +01002671
2672/* Caller should hold socket lock for the passed tipc socket. */
Richard Alped8182802014-11-24 11:10:29 +01002673static int __tipc_nl_add_sk_con(struct sk_buff *skb, struct tipc_sock *tsk)
Richard Alpe34b78a122014-11-20 10:29:10 +01002674{
2675 u32 peer_node;
2676 u32 peer_port;
2677 struct nlattr *nest;
2678
2679 peer_node = tsk_peer_node(tsk);
2680 peer_port = tsk_peer_port(tsk);
2681
2682 nest = nla_nest_start(skb, TIPC_NLA_SOCK_CON);
2683
2684 if (nla_put_u32(skb, TIPC_NLA_CON_NODE, peer_node))
2685 goto msg_full;
2686 if (nla_put_u32(skb, TIPC_NLA_CON_SOCK, peer_port))
2687 goto msg_full;
2688
2689 if (tsk->conn_type != 0) {
2690 if (nla_put_flag(skb, TIPC_NLA_CON_FLAG))
2691 goto msg_full;
2692 if (nla_put_u32(skb, TIPC_NLA_CON_TYPE, tsk->conn_type))
2693 goto msg_full;
2694 if (nla_put_u32(skb, TIPC_NLA_CON_INST, tsk->conn_instance))
2695 goto msg_full;
2696 }
2697 nla_nest_end(skb, nest);
2698
2699 return 0;
2700
2701msg_full:
2702 nla_nest_cancel(skb, nest);
2703
2704 return -EMSGSIZE;
2705}
2706
2707/* Caller should hold socket lock for the passed tipc socket. */
Richard Alped8182802014-11-24 11:10:29 +01002708static int __tipc_nl_add_sk(struct sk_buff *skb, struct netlink_callback *cb,
2709 struct tipc_sock *tsk)
Richard Alpe34b78a122014-11-20 10:29:10 +01002710{
2711 int err;
2712 void *hdr;
2713 struct nlattr *attrs;
Ying Xue34747532015-01-09 15:27:10 +08002714 struct net *net = sock_net(skb->sk);
2715 struct tipc_net *tn = net_generic(net, tipc_net_id);
Richard Alpe34b78a122014-11-20 10:29:10 +01002716
2717 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
Richard Alpebfb3e5d2015-02-09 09:50:03 +01002718 &tipc_genl_family, NLM_F_MULTI, TIPC_NL_SOCK_GET);
Richard Alpe34b78a122014-11-20 10:29:10 +01002719 if (!hdr)
2720 goto msg_cancel;
2721
2722 attrs = nla_nest_start(skb, TIPC_NLA_SOCK);
2723 if (!attrs)
2724 goto genlmsg_cancel;
Ying Xue07f6c4b2015-01-07 13:41:58 +08002725 if (nla_put_u32(skb, TIPC_NLA_SOCK_REF, tsk->portid))
Richard Alpe34b78a122014-11-20 10:29:10 +01002726 goto attr_msg_cancel;
Ying Xue34747532015-01-09 15:27:10 +08002727 if (nla_put_u32(skb, TIPC_NLA_SOCK_ADDR, tn->own_addr))
Richard Alpe34b78a122014-11-20 10:29:10 +01002728 goto attr_msg_cancel;
2729
2730 if (tsk->connected) {
2731 err = __tipc_nl_add_sk_con(skb, tsk);
2732 if (err)
2733 goto attr_msg_cancel;
2734 } else if (!list_empty(&tsk->publications)) {
2735 if (nla_put_flag(skb, TIPC_NLA_SOCK_HAS_PUBL))
2736 goto attr_msg_cancel;
2737 }
2738 nla_nest_end(skb, attrs);
2739 genlmsg_end(skb, hdr);
2740
2741 return 0;
2742
2743attr_msg_cancel:
2744 nla_nest_cancel(skb, attrs);
2745genlmsg_cancel:
2746 genlmsg_cancel(skb, hdr);
2747msg_cancel:
2748 return -EMSGSIZE;
2749}
2750
2751int tipc_nl_sk_dump(struct sk_buff *skb, struct netlink_callback *cb)
2752{
2753 int err;
2754 struct tipc_sock *tsk;
Ying Xue07f6c4b2015-01-07 13:41:58 +08002755 const struct bucket_table *tbl;
2756 struct rhash_head *pos;
Ying Xuee05b31f2015-01-09 15:27:08 +08002757 struct net *net = sock_net(skb->sk);
2758 struct tipc_net *tn = net_generic(net, tipc_net_id);
Richard Alped6e164e2015-01-16 12:30:40 +01002759 u32 tbl_id = cb->args[0];
2760 u32 prev_portid = cb->args[1];
Richard Alpe34b78a122014-11-20 10:29:10 +01002761
Ying Xue07f6c4b2015-01-07 13:41:58 +08002762 rcu_read_lock();
Ying Xuee05b31f2015-01-09 15:27:08 +08002763 tbl = rht_dereference_rcu((&tn->sk_rht)->tbl, &tn->sk_rht);
Richard Alped6e164e2015-01-16 12:30:40 +01002764 for (; tbl_id < tbl->size; tbl_id++) {
2765 rht_for_each_entry_rcu(tsk, pos, tbl, tbl_id, node) {
Ying Xue07f6c4b2015-01-07 13:41:58 +08002766 spin_lock_bh(&tsk->sk.sk_lock.slock);
Richard Alped6e164e2015-01-16 12:30:40 +01002767 if (prev_portid && prev_portid != tsk->portid) {
2768 spin_unlock_bh(&tsk->sk.sk_lock.slock);
2769 continue;
2770 }
Richard Alpe34b78a122014-11-20 10:29:10 +01002771
Richard Alped6e164e2015-01-16 12:30:40 +01002772 err = __tipc_nl_add_sk(skb, cb, tsk);
2773 if (err) {
2774 prev_portid = tsk->portid;
2775 spin_unlock_bh(&tsk->sk.sk_lock.slock);
2776 goto out;
2777 }
2778 prev_portid = 0;
2779 spin_unlock_bh(&tsk->sk.sk_lock.slock);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002780 }
Richard Alpe34b78a122014-11-20 10:29:10 +01002781 }
Richard Alped6e164e2015-01-16 12:30:40 +01002782out:
Ying Xue07f6c4b2015-01-07 13:41:58 +08002783 rcu_read_unlock();
Richard Alped6e164e2015-01-16 12:30:40 +01002784 cb->args[0] = tbl_id;
2785 cb->args[1] = prev_portid;
Richard Alpe34b78a122014-11-20 10:29:10 +01002786
2787 return skb->len;
2788}
Richard Alpe1a1a1432014-11-20 10:29:11 +01002789
2790/* Caller should hold socket lock for the passed tipc socket. */
Richard Alped8182802014-11-24 11:10:29 +01002791static int __tipc_nl_add_sk_publ(struct sk_buff *skb,
2792 struct netlink_callback *cb,
2793 struct publication *publ)
Richard Alpe1a1a1432014-11-20 10:29:11 +01002794{
2795 void *hdr;
2796 struct nlattr *attrs;
2797
2798 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
Richard Alpebfb3e5d2015-02-09 09:50:03 +01002799 &tipc_genl_family, NLM_F_MULTI, TIPC_NL_PUBL_GET);
Richard Alpe1a1a1432014-11-20 10:29:11 +01002800 if (!hdr)
2801 goto msg_cancel;
2802
2803 attrs = nla_nest_start(skb, TIPC_NLA_PUBL);
2804 if (!attrs)
2805 goto genlmsg_cancel;
2806
2807 if (nla_put_u32(skb, TIPC_NLA_PUBL_KEY, publ->key))
2808 goto attr_msg_cancel;
2809 if (nla_put_u32(skb, TIPC_NLA_PUBL_TYPE, publ->type))
2810 goto attr_msg_cancel;
2811 if (nla_put_u32(skb, TIPC_NLA_PUBL_LOWER, publ->lower))
2812 goto attr_msg_cancel;
2813 if (nla_put_u32(skb, TIPC_NLA_PUBL_UPPER, publ->upper))
2814 goto attr_msg_cancel;
2815
2816 nla_nest_end(skb, attrs);
2817 genlmsg_end(skb, hdr);
2818
2819 return 0;
2820
2821attr_msg_cancel:
2822 nla_nest_cancel(skb, attrs);
2823genlmsg_cancel:
2824 genlmsg_cancel(skb, hdr);
2825msg_cancel:
2826 return -EMSGSIZE;
2827}
2828
2829/* Caller should hold socket lock for the passed tipc socket. */
Richard Alped8182802014-11-24 11:10:29 +01002830static int __tipc_nl_list_sk_publ(struct sk_buff *skb,
2831 struct netlink_callback *cb,
2832 struct tipc_sock *tsk, u32 *last_publ)
Richard Alpe1a1a1432014-11-20 10:29:11 +01002833{
2834 int err;
2835 struct publication *p;
2836
2837 if (*last_publ) {
2838 list_for_each_entry(p, &tsk->publications, pport_list) {
2839 if (p->key == *last_publ)
2840 break;
2841 }
2842 if (p->key != *last_publ) {
2843 /* We never set seq or call nl_dump_check_consistent()
2844 * this means that setting prev_seq here will cause the
2845 * consistence check to fail in the netlink callback
2846 * handler. Resulting in the last NLMSG_DONE message
2847 * having the NLM_F_DUMP_INTR flag set.
2848 */
2849 cb->prev_seq = 1;
2850 *last_publ = 0;
2851 return -EPIPE;
2852 }
2853 } else {
2854 p = list_first_entry(&tsk->publications, struct publication,
2855 pport_list);
2856 }
2857
2858 list_for_each_entry_from(p, &tsk->publications, pport_list) {
2859 err = __tipc_nl_add_sk_publ(skb, cb, p);
2860 if (err) {
2861 *last_publ = p->key;
2862 return err;
2863 }
2864 }
2865 *last_publ = 0;
2866
2867 return 0;
2868}
2869
2870int tipc_nl_publ_dump(struct sk_buff *skb, struct netlink_callback *cb)
2871{
2872 int err;
Ying Xue07f6c4b2015-01-07 13:41:58 +08002873 u32 tsk_portid = cb->args[0];
Richard Alpe1a1a1432014-11-20 10:29:11 +01002874 u32 last_publ = cb->args[1];
2875 u32 done = cb->args[2];
Ying Xuee05b31f2015-01-09 15:27:08 +08002876 struct net *net = sock_net(skb->sk);
Richard Alpe1a1a1432014-11-20 10:29:11 +01002877 struct tipc_sock *tsk;
2878
Ying Xue07f6c4b2015-01-07 13:41:58 +08002879 if (!tsk_portid) {
Richard Alpe1a1a1432014-11-20 10:29:11 +01002880 struct nlattr **attrs;
2881 struct nlattr *sock[TIPC_NLA_SOCK_MAX + 1];
2882
2883 err = tipc_nlmsg_parse(cb->nlh, &attrs);
2884 if (err)
2885 return err;
2886
Richard Alpe45e093a2016-05-16 11:14:54 +02002887 if (!attrs[TIPC_NLA_SOCK])
2888 return -EINVAL;
2889
Richard Alpe1a1a1432014-11-20 10:29:11 +01002890 err = nla_parse_nested(sock, TIPC_NLA_SOCK_MAX,
2891 attrs[TIPC_NLA_SOCK],
2892 tipc_nl_sock_policy);
2893 if (err)
2894 return err;
2895
2896 if (!sock[TIPC_NLA_SOCK_REF])
2897 return -EINVAL;
2898
Ying Xue07f6c4b2015-01-07 13:41:58 +08002899 tsk_portid = nla_get_u32(sock[TIPC_NLA_SOCK_REF]);
Richard Alpe1a1a1432014-11-20 10:29:11 +01002900 }
2901
2902 if (done)
2903 return 0;
2904
Ying Xuee05b31f2015-01-09 15:27:08 +08002905 tsk = tipc_sk_lookup(net, tsk_portid);
Richard Alpe1a1a1432014-11-20 10:29:11 +01002906 if (!tsk)
2907 return -EINVAL;
2908
2909 lock_sock(&tsk->sk);
2910 err = __tipc_nl_list_sk_publ(skb, cb, tsk, &last_publ);
2911 if (!err)
2912 done = 1;
2913 release_sock(&tsk->sk);
Ying Xue07f6c4b2015-01-07 13:41:58 +08002914 sock_put(&tsk->sk);
Richard Alpe1a1a1432014-11-20 10:29:11 +01002915
Ying Xue07f6c4b2015-01-07 13:41:58 +08002916 cb->args[0] = tsk_portid;
Richard Alpe1a1a1432014-11-20 10:29:11 +01002917 cb->args[1] = last_publ;
2918 cb->args[2] = done;
2919
2920 return skb->len;
2921}