socket.c 48.9 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/socket.c: TIPC socket API
3
 *
4
 * Copyright (c) 2001-2007, 2012 Ericsson AB
5
 * Copyright (c) 2004-2008, 2010-2013, Wind River Systems
P
Per Liden 已提交
6 7
 * All rights reserved.
 *
P
Per Liden 已提交
8
 * Redistribution and use in source and binary forms, with or without
P
Per Liden 已提交
9 10
 * modification, are permitted provided that the following conditions are met:
 *
P
Per Liden 已提交
11 12 13 14 15 16 17 18
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
P
Per Liden 已提交
19
 *
P
Per Liden 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
P
Per Liden 已提交
34 35 36 37
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
38
#include "port.h"
P
Per Liden 已提交
39

40 41 42
#include <linux/export.h>
#include <net/sock.h>

P
Per Liden 已提交
43 44 45
#define SS_LISTENING	-1	/* socket is listening */
#define SS_READY	-2	/* socket is connectionless */

46
#define CONN_TIMEOUT_DEFAULT	8000	/* default connect timeout = 8s */
P
Per Liden 已提交
47 48 49 50

struct tipc_sock {
	struct sock sk;
	struct tipc_port *p;
51
	struct tipc_portid peer_name;
52
	unsigned int conn_timeout;
P
Per Liden 已提交
53 54
};

55
#define tipc_sk(sk) ((struct tipc_sock *)(sk))
J
Joe Perches 已提交
56
#define tipc_sk_port(sk) (tipc_sk(sk)->p)
P
Per Liden 已提交
57

58 59 60
#define tipc_rx_ready(sock) (!skb_queue_empty(&sock->sk->sk_receive_queue) || \
			(sock->state == SS_DISCONNECTING))

61
static int backlog_rcv(struct sock *sk, struct sk_buff *skb);
P
Per Liden 已提交
62 63
static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf);
static void wakeupdispatch(struct tipc_port *tport);
64 65
static void tipc_data_ready(struct sock *sk, int len);
static void tipc_write_space(struct sock *sk);
66 67
static int release(struct socket *sock);
static int accept(struct socket *sock, struct socket *new_sock, int flags);
P
Per Liden 已提交
68

69 70 71
static const struct proto_ops packet_ops;
static const struct proto_ops stream_ops;
static const struct proto_ops msg_ops;
P
Per Liden 已提交
72 73

static struct proto tipc_proto;
74
static struct proto tipc_proto_kern;
P
Per Liden 已提交
75

76
static int sockets_enabled;
P
Per Liden 已提交
77

78
/*
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
 * Revised TIPC socket locking policy:
 *
 * Most socket operations take the standard socket lock when they start
 * and hold it until they finish (or until they need to sleep).  Acquiring
 * this lock grants the owner exclusive access to the fields of the socket
 * data structures, with the exception of the backlog queue.  A few socket
 * operations can be done without taking the socket lock because they only
 * read socket information that never changes during the life of the socket.
 *
 * Socket operations may acquire the lock for the associated TIPC port if they
 * need to perform an operation on the port.  If any routine needs to acquire
 * both the socket lock and the port lock it must take the socket lock first
 * to avoid the risk of deadlock.
 *
 * The dispatcher handling incoming messages cannot grab the socket lock in
 * the standard fashion, since invoked it runs at the BH level and cannot block.
 * Instead, it checks to see if the socket lock is currently owned by someone,
 * and either handles the message itself or adds it to the socket's backlog
 * queue; in the latter case the queued message is processed once the process
 * owning the socket lock releases it.
 *
 * NOTE: Releasing the socket lock while an operation is sleeping overcomes
 * the problem of a blocked socket operation preventing any other operations
 * from occurring.  However, applications must be careful if they have
 * multiple threads trying to send (or receive) on the same socket, as these
 * operations might interfere with each other.  For example, doing a connect
 * and a receive at the same time might allow the receive to consume the
 * ACK message meant for the connect.  While additional work could be done
 * to try and overcome this, it doesn't seem to be worthwhile at the present.
 *
 * NOTE: Releasing the socket lock while an operation is sleeping also ensures
 * that another operation that must be performed in a non-blocking manner is
 * not delayed for very long because the lock has already been taken.
 *
 * NOTE: This code assumes that certain fields of a port/socket pair are
 * constant over its lifetime; such fields can be examined without taking
 * the socket lock and/or port lock, and do not need to be re-read even
 * after resuming processing after waiting.  These fields include:
 *   - socket type
 *   - pointer to socket sk structure (aka tipc_sock structure)
 *   - pointer to port structure
 *   - port reference
 */

/**
 * advance_rx_queue - discard first buffer in socket receive queue
 *
 * Caller must hold socket lock
P
Per Liden 已提交
127
 */
128
static void advance_rx_queue(struct sock *sk)
P
Per Liden 已提交
129
{
130
	kfree_skb(__skb_dequeue(&sk->sk_receive_queue));
P
Per Liden 已提交
131 132 133
}

/**
134 135 136
 * reject_rx_queue - reject all buffers in socket receive queue
 *
 * Caller must hold socket lock
P
Per Liden 已提交
137
 */
138
static void reject_rx_queue(struct sock *sk)
P
Per Liden 已提交
139
{
140 141
	struct sk_buff *buf;

142
	while ((buf = __skb_dequeue(&sk->sk_receive_queue)))
143
		tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
P
Per Liden 已提交
144 145 146
}

/**
147
 * tipc_sk_create - create a TIPC socket
148
 * @net: network namespace (must be default network)
P
Per Liden 已提交
149 150
 * @sock: pre-allocated socket structure
 * @protocol: protocol indicator (must be 0)
151
 * @kern: caused by kernel or by userspace?
152
 *
153 154
 * This routine creates additional data structures used by the TIPC socket,
 * initializes them, and links them together.
P
Per Liden 已提交
155 156 157
 *
 * Returns 0 on success, errno otherwise
 */
158 159
static int tipc_sk_create(struct net *net, struct socket *sock, int protocol,
			  int kern)
P
Per Liden 已提交
160
{
161 162
	const struct proto_ops *ops;
	socket_state state;
P
Per Liden 已提交
163
	struct sock *sk;
164
	struct tipc_port *tp_ptr;
165 166

	/* Validate arguments */
P
Per Liden 已提交
167 168 169 170 171
	if (unlikely(protocol != 0))
		return -EPROTONOSUPPORT;

	switch (sock->type) {
	case SOCK_STREAM:
172 173
		ops = &stream_ops;
		state = SS_UNCONNECTED;
P
Per Liden 已提交
174 175
		break;
	case SOCK_SEQPACKET:
176 177
		ops = &packet_ops;
		state = SS_UNCONNECTED;
P
Per Liden 已提交
178 179 180
		break;
	case SOCK_DGRAM:
	case SOCK_RDM:
181 182
		ops = &msg_ops;
		state = SS_READY;
P
Per Liden 已提交
183
		break;
184 185
	default:
		return -EPROTOTYPE;
P
Per Liden 已提交
186 187
	}

188
	/* Allocate socket's protocol area */
189 190 191 192 193
	if (!kern)
		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
	else
		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto_kern);

194
	if (sk == NULL)
P
Per Liden 已提交
195 196
		return -ENOMEM;

197
	/* Allocate TIPC port for socket to use */
198 199
	tp_ptr = tipc_createport(sk, &dispatch, &wakeupdispatch,
				 TIPC_LOW_IMPORTANCE);
200
	if (unlikely(!tp_ptr)) {
201 202 203
		sk_free(sk);
		return -ENOMEM;
	}
P
Per Liden 已提交
204

205 206 207
	/* Finish initializing socket data structures */
	sock->ops = ops;
	sock->state = state;
P
Per Liden 已提交
208

209 210
	sock_init_data(sock, sk);
	sk->sk_backlog_rcv = backlog_rcv;
211
	sk->sk_rcvbuf = sysctl_tipc_rmem[1];
212 213
	sk->sk_data_ready = tipc_data_ready;
	sk->sk_write_space = tipc_write_space;
214
	tipc_sk(sk)->p = tp_ptr;
215
	tipc_sk(sk)->conn_timeout = CONN_TIMEOUT_DEFAULT;
P
Per Liden 已提交
216

217 218
	spin_unlock_bh(tp_ptr->lock);

219
	if (sock->state == SS_READY) {
220
		tipc_set_portunreturnable(tp_ptr->ref, 1);
221
		if (sock->type == SOCK_DGRAM)
222
			tipc_set_portunreliable(tp_ptr->ref, 1);
223
	}
P
Per Liden 已提交
224 225 226 227

	return 0;
}

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
/**
 * tipc_sock_create_local - create TIPC socket from inside TIPC module
 * @type: socket type - SOCK_RDM or SOCK_SEQPACKET
 *
 * We cannot use sock_creat_kern here because it bumps module user count.
 * Since socket owner and creator is the same module we must make sure
 * that module count remains zero for module local sockets, otherwise
 * we cannot do rmmod.
 *
 * Returns 0 on success, errno otherwise
 */
int tipc_sock_create_local(int type, struct socket **res)
{
	int rc;

	rc = sock_create_lite(AF_TIPC, type, 0, res);
	if (rc < 0) {
		pr_err("Failed to create kernel socket\n");
		return rc;
	}
	tipc_sk_create(&init_net, *res, 0, 1);

	return 0;
}

/**
 * tipc_sock_release_local - release socket created by tipc_sock_create_local
 * @sock: the socket to be released.
 *
 * Module reference count is not incremented when such sockets are created,
 * so we must keep it from being decremented when they are released.
 */
void tipc_sock_release_local(struct socket *sock)
{
	release(sock);
	sock->ops = NULL;
	sock_release(sock);
}

/**
 * tipc_sock_accept_local - accept a connection on a socket created
 * with tipc_sock_create_local. Use this function to avoid that
 * module reference count is inadvertently incremented.
 *
 * @sock:    the accepting socket
 * @newsock: reference to the new socket to be created
 * @flags:   socket flags
 */

int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,
278
			   int flags)
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
{
	struct sock *sk = sock->sk;
	int ret;

	ret = sock_create_lite(sk->sk_family, sk->sk_type,
			       sk->sk_protocol, newsock);
	if (ret < 0)
		return ret;

	ret = accept(sock, *newsock, flags);
	if (ret < 0) {
		sock_release(*newsock);
		return ret;
	}
	(*newsock)->ops = sock->ops;
	return ret;
}

P
Per Liden 已提交
297 298 299 300 301 302 303 304 305
/**
 * release - destroy a TIPC socket
 * @sock: socket to destroy
 *
 * This routine cleans up any messages that are still queued on the socket.
 * For DGRAM and RDM socket types, all queued messages are rejected.
 * For SEQPACKET and STREAM socket types, the first message is rejected
 * and any others are discarded.  (If the first message on a STREAM socket
 * is partially-read, it is discarded and the next one is rejected instead.)
306
 *
P
Per Liden 已提交
307 308 309 310 311 312 313 314 315
 * NOTE: Rejected messages are not necessarily returned to the sender!  They
 * are returned or discarded according to the "destination droppable" setting
 * specified for the message by the sender.
 *
 * Returns 0 on success, errno otherwise
 */
static int release(struct socket *sock)
{
	struct sock *sk = sock->sk;
316
	struct tipc_port *tport;
P
Per Liden 已提交
317
	struct sk_buff *buf;
318
	int res;
P
Per Liden 已提交
319

320 321 322 323 324
	/*
	 * Exit if socket isn't fully initialized (occurs when a failed accept()
	 * releases a pre-allocated child socket that was never used)
	 */
	if (sk == NULL)
P
Per Liden 已提交
325
		return 0;
326

327 328 329 330 331 332 333
	tport = tipc_sk_port(sk);
	lock_sock(sk);

	/*
	 * Reject all unreceived messages, except on an active connection
	 * (which disconnects locally & sends a 'FIN+' to peer)
	 */
P
Per Liden 已提交
334
	while (sock->state != SS_DISCONNECTING) {
335 336
		buf = __skb_dequeue(&sk->sk_receive_queue);
		if (buf == NULL)
P
Per Liden 已提交
337
			break;
Y
Ying Xue 已提交
338
		if (TIPC_SKB_CB(buf)->handle != NULL)
339
			kfree_skb(buf);
340 341 342 343 344 345
		else {
			if ((sock->state == SS_CONNECTING) ||
			    (sock->state == SS_CONNECTED)) {
				sock->state = SS_DISCONNECTING;
				tipc_disconnect(tport->ref);
			}
P
Per Liden 已提交
346
			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
347
		}
P
Per Liden 已提交
348 349
	}

350 351 352 353 354
	/*
	 * Delete TIPC port; this ensures no more messages are queued
	 * (also disconnects an active connection & sends a 'FIN-' to peer)
	 */
	res = tipc_deleteport(tport->ref);
P
Per Liden 已提交
355

356
	/* Discard any remaining (connection-based) messages in receive queue */
357
	__skb_queue_purge(&sk->sk_receive_queue);
P
Per Liden 已提交
358

359 360 361
	/* Reject any messages that accumulated in backlog queue */
	sock->state = SS_DISCONNECTING;
	release_sock(sk);
P
Per Liden 已提交
362 363

	sock_put(sk);
364
	sock->sk = NULL;
P
Per Liden 已提交
365 366 367 368 369 370 371 372 373

	return res;
}

/**
 * bind - associate or disassocate TIPC name(s) with a socket
 * @sock: socket structure
 * @uaddr: socket address describing name(s) and desired operation
 * @uaddr_len: size of socket address data structure
374
 *
P
Per Liden 已提交
375 376 377
 * Name and name sequence binding is indicated using a positive scope value;
 * a negative scope value unbinds the specified name.  Specifying no name
 * (i.e. a socket address length of 0) unbinds all names from the socket.
378
 *
P
Per Liden 已提交
379
 * Returns 0 on success, errno otherwise
380 381 382
 *
 * NOTE: This routine doesn't need to take the socket lock since it doesn't
 *       access any non-constant socket information.
P
Per Liden 已提交
383 384 385 386
 */
static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len)
{
	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
387
	u32 portref = tipc_sk_port(sock->sk)->ref;
P
Per Liden 已提交
388

389 390
	if (unlikely(!uaddr_len))
		return tipc_withdraw(portref, 0, NULL);
391

392 393 394 395
	if (uaddr_len < sizeof(struct sockaddr_tipc))
		return -EINVAL;
	if (addr->family != AF_TIPC)
		return -EAFNOSUPPORT;
P
Per Liden 已提交
396 397 398

	if (addr->addrtype == TIPC_ADDR_NAME)
		addr->addr.nameseq.upper = addr->addr.nameseq.lower;
399 400
	else if (addr->addrtype != TIPC_ADDR_NAMESEQ)
		return -EAFNOSUPPORT;
401

402
	if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) &&
403 404
	    (addr->addr.nameseq.type != TIPC_TOP_SRV) &&
	    (addr->addr.nameseq.type != TIPC_CFG_SRV))
405 406
		return -EACCES;

407 408 409
	return (addr->scope > 0) ?
		tipc_publish(portref, addr->scope, &addr->addr.nameseq) :
		tipc_withdraw(portref, -addr->scope, &addr->addr.nameseq);
P
Per Liden 已提交
410 411
}

412
/**
P
Per Liden 已提交
413 414 415 416
 * get_name - get port ID of socket or peer socket
 * @sock: socket structure
 * @uaddr: area for returned socket address
 * @uaddr_len: area for returned length of socket address
417
 * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID
418
 *
P
Per Liden 已提交
419
 * Returns 0 on success, errno otherwise
420
 *
421 422
 * NOTE: This routine doesn't need to take the socket lock since it only
 *       accesses socket information that is unchanging (or which changes in
423
 *       a completely predictable manner).
P
Per Liden 已提交
424
 */
425
static int get_name(struct socket *sock, struct sockaddr *uaddr,
P
Per Liden 已提交
426 427 428
		    int *uaddr_len, int peer)
{
	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
429
	struct tipc_sock *tsock = tipc_sk(sock->sk);
P
Per Liden 已提交
430

431
	memset(addr, 0, sizeof(*addr));
432
	if (peer) {
433 434 435 436 437
		if ((sock->state != SS_CONNECTED) &&
			((peer != 2) || (sock->state != SS_DISCONNECTING)))
			return -ENOTCONN;
		addr->addr.id.ref = tsock->peer_name.ref;
		addr->addr.id.node = tsock->peer_name.node;
438
	} else {
A
Allan Stephens 已提交
439 440
		addr->addr.id.ref = tsock->p->ref;
		addr->addr.id.node = tipc_own_addr;
441
	}
P
Per Liden 已提交
442 443 444 445 446 447 448

	*uaddr_len = sizeof(*addr);
	addr->addrtype = TIPC_ADDR_ID;
	addr->family = AF_TIPC;
	addr->scope = 0;
	addr->addr.name.domain = 0;

449
	return 0;
P
Per Liden 已提交
450 451 452 453 454 455 456 457
}

/**
 * poll - read and possibly block on pollmask
 * @file: file structure associated with the socket
 * @sock: socket for which to calculate the poll bits
 * @wait: ???
 *
458 459 460 461 462 463 464 465 466
 * Returns pollmask value
 *
 * COMMENTARY:
 * It appears that the usual socket locking mechanisms are not useful here
 * since the pollmask info is potentially out-of-date the moment this routine
 * exits.  TCP and other protocols seem to rely on higher level poll routines
 * to handle any preventable race conditions, so TIPC will do the same ...
 *
 * TIPC sets the returned events as follows:
467 468 469 470
 *
 * socket state		flags set
 * ------------		---------
 * unconnected		no read flags
471
 *			POLLOUT if port is not congested
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
 *
 * connecting		POLLIN/POLLRDNORM if ACK/NACK in rx queue
 *			no write flags
 *
 * connected		POLLIN/POLLRDNORM if data in rx queue
 *			POLLOUT if port is not congested
 *
 * disconnecting	POLLIN/POLLRDNORM/POLLHUP
 *			no write flags
 *
 * listening		POLLIN if SYN in rx queue
 *			no write flags
 *
 * ready		POLLIN/POLLRDNORM if data in rx queue
 * [connectionless]	POLLOUT (since port cannot be congested)
 *
 * IMPORTANT: The fact that a read or write operation is indicated does NOT
 * imply that the operation will succeed, merely that it should be performed
 * and will not block.
P
Per Liden 已提交
491
 */
492
static unsigned int poll(struct file *file, struct socket *sock,
P
Per Liden 已提交
493 494
			 poll_table *wait)
{
495
	struct sock *sk = sock->sk;
496
	u32 mask = 0;
497

498
	sock_poll_wait(file, sk_sleep(sk), wait);
499

500
	switch ((int)sock->state) {
501 502 503 504
	case SS_UNCONNECTED:
		if (!tipc_sk_port(sk)->congested)
			mask |= POLLOUT;
		break;
505 506 507 508 509 510 511 512 513 514 515 516 517 518
	case SS_READY:
	case SS_CONNECTED:
		if (!tipc_sk_port(sk)->congested)
			mask |= POLLOUT;
		/* fall thru' */
	case SS_CONNECTING:
	case SS_LISTENING:
		if (!skb_queue_empty(&sk->sk_receive_queue))
			mask |= (POLLIN | POLLRDNORM);
		break;
	case SS_DISCONNECTING:
		mask = (POLLIN | POLLRDNORM | POLLHUP);
		break;
	}
519 520

	return mask;
P
Per Liden 已提交
521 522
}

523
/**
P
Per Liden 已提交
524 525 526
 * dest_name_check - verify user is permitted to send to specified port name
 * @dest: destination address
 * @m: descriptor for message to be sent
527
 *
P
Per Liden 已提交
528 529
 * Prevents restricted configuration commands from being issued by
 * unauthorized users.
530
 *
P
Per Liden 已提交
531 532
 * Returns 0 if permission is granted, otherwise errno
 */
S
Sam Ravnborg 已提交
533
static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m)
P
Per Liden 已提交
534 535 536
{
	struct tipc_cfg_msg_hdr hdr;

537 538 539 540 541 542
	if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))
		return 0;
	if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))
		return 0;
	if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))
		return -EACCES;
P
Per Liden 已提交
543

544 545
	if (!m->msg_iovlen || (m->msg_iov[0].iov_len < sizeof(hdr)))
		return -EMSGSIZE;
546
	if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))
P
Per Liden 已提交
547
		return -EFAULT;
548
	if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))
P
Per Liden 已提交
549
		return -EACCES;
550

P
Per Liden 已提交
551 552 553 554 555
	return 0;
}

/**
 * send_msg - send message in connectionless manner
556
 * @iocb: if NULL, indicates that socket lock is already held
P
Per Liden 已提交
557 558
 * @sock: socket structure
 * @m: message to send
559
 * @total_len: length of message
560
 *
P
Per Liden 已提交
561
 * Message must have an destination specified explicitly.
562
 * Used for SOCK_RDM and SOCK_DGRAM messages,
P
Per Liden 已提交
563 564
 * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
 * (Note: 'SYN+' is prohibited on SOCK_STREAM.)
565
 *
P
Per Liden 已提交
566 567 568 569 570
 * Returns the number of bytes sent on success, or errno otherwise
 */
static int send_msg(struct kiocb *iocb, struct socket *sock,
		    struct msghdr *m, size_t total_len)
{
571 572
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
573
	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
P
Per Liden 已提交
574
	int needs_conn;
575
	long timeout_val;
P
Per Liden 已提交
576 577 578 579
	int res = -EINVAL;

	if (unlikely(!dest))
		return -EDESTADDRREQ;
580 581
	if (unlikely((m->msg_namelen < sizeof(*dest)) ||
		     (dest->family != AF_TIPC)))
P
Per Liden 已提交
582
		return -EINVAL;
583
	if (total_len > TIPC_MAX_USER_MSG_SIZE)
584
		return -EMSGSIZE;
P
Per Liden 已提交
585

586 587 588
	if (iocb)
		lock_sock(sk);

P
Per Liden 已提交
589 590
	needs_conn = (sock->state != SS_READY);
	if (unlikely(needs_conn)) {
591 592 593 594 595 596 597 598
		if (sock->state == SS_LISTENING) {
			res = -EPIPE;
			goto exit;
		}
		if (sock->state != SS_UNCONNECTED) {
			res = -EISCONN;
			goto exit;
		}
599
		if (tport->published) {
600 601 602
			res = -EOPNOTSUPP;
			goto exit;
		}
603
		if (dest->addrtype == TIPC_ADDR_NAME) {
604 605
			tport->conn_type = dest->addr.name.name.type;
			tport->conn_instance = dest->addr.name.name.instance;
606
		}
P
Per Liden 已提交
607 608

		/* Abort any pending connection attempts (very unlikely) */
609
		reject_rx_queue(sk);
P
Per Liden 已提交
610 611
	}

612 613
	timeout_val = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);

614 615
	do {
		if (dest->addrtype == TIPC_ADDR_NAME) {
616 617
			res = dest_name_check(dest, m);
			if (res)
618 619
				break;
			res = tipc_send2name(tport->ref,
620 621
					     &dest->addr.name.name,
					     dest->addr.name.domain,
622 623
					     m->msg_iov,
					     total_len);
624
		} else if (dest->addrtype == TIPC_ADDR_ID) {
625
			res = tipc_send2port(tport->ref,
626
					     &dest->addr.id,
627 628
					     m->msg_iov,
					     total_len);
629
		} else if (dest->addrtype == TIPC_ADDR_MCAST) {
P
Per Liden 已提交
630 631
			if (needs_conn) {
				res = -EOPNOTSUPP;
632
				break;
P
Per Liden 已提交
633
			}
634 635
			res = dest_name_check(dest, m);
			if (res)
636 637
				break;
			res = tipc_multicast(tport->ref,
638
					     &dest->addr.nameseq,
639 640
					     m->msg_iov,
					     total_len);
641 642
		}
		if (likely(res != -ELINKCONG)) {
643
			if (needs_conn && (res >= 0))
644 645
				sock->state = SS_CONNECTING;
			break;
646
		}
647 648
		if (timeout_val <= 0L) {
			res = timeout_val ? timeout_val : -EWOULDBLOCK;
649
			break;
650
		}
651
		release_sock(sk);
652 653
		timeout_val = wait_event_interruptible_timeout(*sk_sleep(sk),
					       !tport->congested, timeout_val);
654
		lock_sock(sk);
655
	} while (1);
656 657 658 659 660

exit:
	if (iocb)
		release_sock(sk);
	return res;
P
Per Liden 已提交
661 662
}

663
/**
P
Per Liden 已提交
664
 * send_packet - send a connection-oriented message
665
 * @iocb: if NULL, indicates that socket lock is already held
P
Per Liden 已提交
666 667
 * @sock: socket structure
 * @m: message to send
668
 * @total_len: length of message
669
 *
P
Per Liden 已提交
670
 * Used for SOCK_SEQPACKET messages and SOCK_STREAM data.
671
 *
P
Per Liden 已提交
672 673 674 675 676
 * Returns the number of bytes sent on success, or errno otherwise
 */
static int send_packet(struct kiocb *iocb, struct socket *sock,
		       struct msghdr *m, size_t total_len)
{
677 678
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
679
	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
680
	long timeout_val;
P
Per Liden 已提交
681 682 683 684 685 686
	int res;

	/* Handle implied connection establishment */
	if (unlikely(dest))
		return send_msg(iocb, sock, m, total_len);

687
	if (total_len > TIPC_MAX_USER_MSG_SIZE)
688 689
		return -EMSGSIZE;

690 691
	if (iocb)
		lock_sock(sk);
P
Per Liden 已提交
692

693 694
	timeout_val = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);

695
	do {
696 697
		if (unlikely(sock->state != SS_CONNECTED)) {
			if (sock->state == SS_DISCONNECTING)
698
				res = -EPIPE;
699 700
			else
				res = -ENOTCONN;
701
			break;
702 703
		}

704
		res = tipc_send(tport->ref, m->msg_iov, total_len);
705
		if (likely(res != -ELINKCONG))
706
			break;
707 708
		if (timeout_val <= 0L) {
			res = timeout_val ? timeout_val : -EWOULDBLOCK;
709
			break;
710
		}
711
		release_sock(sk);
712 713
		timeout_val = wait_event_interruptible_timeout(*sk_sleep(sk),
			(!tport->congested || !tport->connected), timeout_val);
714
		lock_sock(sk);
715
	} while (1);
716 717 718 719

	if (iocb)
		release_sock(sk);
	return res;
P
Per Liden 已提交
720 721
}

722
/**
P
Per Liden 已提交
723 724 725 726 727
 * send_stream - send stream-oriented data
 * @iocb: (unused)
 * @sock: socket structure
 * @m: data to send
 * @total_len: total length of data to be sent
728
 *
P
Per Liden 已提交
729
 * Used for SOCK_STREAM data.
730 731
 *
 * Returns the number of bytes sent on success (or partial success),
732
 * or errno if no data sent
P
Per Liden 已提交
733 734 735 736
 */
static int send_stream(struct kiocb *iocb, struct socket *sock,
		       struct msghdr *m, size_t total_len)
{
737 738
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
P
Per Liden 已提交
739 740 741 742 743
	struct msghdr my_msg;
	struct iovec my_iov;
	struct iovec *curr_iov;
	int curr_iovlen;
	char __user *curr_start;
744
	u32 hdr_size;
P
Per Liden 已提交
745 746
	int curr_left;
	int bytes_to_send;
747
	int bytes_sent;
P
Per Liden 已提交
748
	int res;
749

750 751
	lock_sock(sk);

752
	/* Handle special cases where there is no connection */
753
	if (unlikely(sock->state != SS_CONNECTED)) {
W
wangweidong 已提交
754
		if (sock->state == SS_UNCONNECTED)
755
			res = send_packet(NULL, sock, m, total_len);
756 757
		else
			res = sock->state == SS_DISCONNECTING ? -EPIPE : -ENOTCONN;
W
wangweidong 已提交
758
		goto exit;
759
	}
P
Per Liden 已提交
760

761 762 763 764
	if (unlikely(m->msg_name)) {
		res = -EISCONN;
		goto exit;
	}
765

766
	if (total_len > (unsigned int)INT_MAX) {
767 768 769 770
		res = -EMSGSIZE;
		goto exit;
	}

771
	/*
P
Per Liden 已提交
772 773
	 * Send each iovec entry using one or more messages
	 *
774
	 * Note: This algorithm is good for the most likely case
P
Per Liden 已提交
775 776 777
	 * (i.e. one large iovec entry), but could be improved to pass sets
	 * of small iovec entries into send_packet().
	 */
778 779
	curr_iov = m->msg_iov;
	curr_iovlen = m->msg_iovlen;
P
Per Liden 已提交
780 781
	my_msg.msg_iov = &my_iov;
	my_msg.msg_iovlen = 1;
782 783
	my_msg.msg_flags = m->msg_flags;
	my_msg.msg_name = NULL;
784
	bytes_sent = 0;
P
Per Liden 已提交
785

786 787
	hdr_size = msg_hdr_sz(&tport->phdr);

P
Per Liden 已提交
788 789 790 791 792
	while (curr_iovlen--) {
		curr_start = curr_iov->iov_base;
		curr_left = curr_iov->iov_len;

		while (curr_left) {
793 794 795 796 797
			bytes_to_send = tport->max_pkt - hdr_size;
			if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)
				bytes_to_send = TIPC_MAX_USER_MSG_SIZE;
			if (curr_left < bytes_to_send)
				bytes_to_send = curr_left;
P
Per Liden 已提交
798 799
			my_iov.iov_base = curr_start;
			my_iov.iov_len = bytes_to_send;
800
			res = send_packet(NULL, sock, &my_msg, bytes_to_send);
801
			if (res < 0) {
802
				if (bytes_sent)
803
					res = bytes_sent;
804
				goto exit;
805
			}
P
Per Liden 已提交
806 807
			curr_left -= bytes_to_send;
			curr_start += bytes_to_send;
808
			bytes_sent += bytes_to_send;
P
Per Liden 已提交
809 810 811 812
		}

		curr_iov++;
	}
813 814 815 816
	res = bytes_sent;
exit:
	release_sock(sk);
	return res;
P
Per Liden 已提交
817 818 819 820 821 822
}

/**
 * auto_connect - complete connection setup to a remote port
 * @sock: socket structure
 * @msg: peer's response message
823
 *
P
Per Liden 已提交
824 825
 * Returns 0 on success, errno otherwise
 */
826
static int auto_connect(struct socket *sock, struct tipc_msg *msg)
P
Per Liden 已提交
827
{
828
	struct tipc_sock *tsock = tipc_sk(sock->sk);
829
	struct tipc_port *p_ptr;
P
Per Liden 已提交
830

831 832
	tsock->peer_name.ref = msg_origport(msg);
	tsock->peer_name.node = msg_orignode(msg);
833 834 835 836 837 838 839 840 841
	p_ptr = tipc_port_deref(tsock->p->ref);
	if (!p_ptr)
		return -EINVAL;

	__tipc_connect(tsock->p->ref, p_ptr, &tsock->peer_name);

	if (msg_importance(msg) > TIPC_CRITICAL_IMPORTANCE)
		return -EINVAL;
	msg_set_importance(&p_ptr->phdr, (u32)msg_importance(msg));
P
Per Liden 已提交
842 843 844 845 846 847 848 849
	sock->state = SS_CONNECTED;
	return 0;
}

/**
 * set_orig_addr - capture sender's address for received message
 * @m: descriptor for message info
 * @msg: received message header
850
 *
P
Per Liden 已提交
851 852
 * Note: Address is not captured if not requested by receiver.
 */
S
Sam Ravnborg 已提交
853
static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg)
P
Per Liden 已提交
854
{
855
	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)m->msg_name;
P
Per Liden 已提交
856

857
	if (addr) {
P
Per Liden 已提交
858 859
		addr->family = AF_TIPC;
		addr->addrtype = TIPC_ADDR_ID;
860
		memset(&addr->addr, 0, sizeof(addr->addr));
P
Per Liden 已提交
861 862
		addr->addr.id.ref = msg_origport(msg);
		addr->addr.id.node = msg_orignode(msg);
863 864
		addr->addr.name.domain = 0;	/* could leave uninitialized */
		addr->scope = 0;		/* could leave uninitialized */
P
Per Liden 已提交
865 866 867 868 869
		m->msg_namelen = sizeof(struct sockaddr_tipc);
	}
}

/**
870
 * anc_data_recv - optionally capture ancillary data for received message
P
Per Liden 已提交
871 872 873
 * @m: descriptor for message info
 * @msg: received message header
 * @tport: TIPC port associated with message
874
 *
P
Per Liden 已提交
875
 * Note: Ancillary data is not captured if not requested by receiver.
876
 *
P
Per Liden 已提交
877 878
 * Returns 0 if successful, otherwise errno
 */
S
Sam Ravnborg 已提交
879
static int anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
880
			 struct tipc_port *tport)
P
Per Liden 已提交
881 882 883 884
{
	u32 anc_data[3];
	u32 err;
	u32 dest_type;
885
	int has_name;
P
Per Liden 已提交
886 887 888 889 890 891 892 893 894 895
	int res;

	if (likely(m->msg_controllen == 0))
		return 0;

	/* Optionally capture errored message object(s) */
	err = msg ? msg_errcode(msg) : 0;
	if (unlikely(err)) {
		anc_data[0] = err;
		anc_data[1] = msg_data_sz(msg);
896 897
		res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data);
		if (res)
P
Per Liden 已提交
898
			return res;
899 900 901 902 903 904
		if (anc_data[1]) {
			res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
				       msg_data(msg));
			if (res)
				return res;
		}
P
Per Liden 已提交
905 906 907 908 909 910
	}

	/* Optionally capture message destination object */
	dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
	switch (dest_type) {
	case TIPC_NAMED_MSG:
911
		has_name = 1;
P
Per Liden 已提交
912 913 914 915 916
		anc_data[0] = msg_nametype(msg);
		anc_data[1] = msg_namelower(msg);
		anc_data[2] = msg_namelower(msg);
		break;
	case TIPC_MCAST_MSG:
917
		has_name = 1;
P
Per Liden 已提交
918 919 920 921 922
		anc_data[0] = msg_nametype(msg);
		anc_data[1] = msg_namelower(msg);
		anc_data[2] = msg_nameupper(msg);
		break;
	case TIPC_CONN_MSG:
923
		has_name = (tport->conn_type != 0);
P
Per Liden 已提交
924 925 926 927 928
		anc_data[0] = tport->conn_type;
		anc_data[1] = tport->conn_instance;
		anc_data[2] = tport->conn_instance;
		break;
	default:
929
		has_name = 0;
P
Per Liden 已提交
930
	}
931 932 933 934 935
	if (has_name) {
		res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data);
		if (res)
			return res;
	}
P
Per Liden 已提交
936 937 938 939

	return 0;
}

940
/**
P
Per Liden 已提交
941 942 943 944 945
 * recv_msg - receive packet-oriented message
 * @iocb: (unused)
 * @m: descriptor for message info
 * @buf_len: total size of user buffer area
 * @flags: receive flags
946
 *
P
Per Liden 已提交
947 948 949 950 951 952 953 954
 * Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.
 * If the complete message doesn't fit in user area, truncate it.
 *
 * Returns size of returned message data, errno otherwise
 */
static int recv_msg(struct kiocb *iocb, struct socket *sock,
		    struct msghdr *m, size_t buf_len, int flags)
{
955 956
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
P
Per Liden 已提交
957 958
	struct sk_buff *buf;
	struct tipc_msg *msg;
959
	long timeout;
P
Per Liden 已提交
960 961 962 963
	unsigned int sz;
	u32 err;
	int res;

964
	/* Catch invalid receive requests */
P
Per Liden 已提交
965 966 967
	if (unlikely(!buf_len))
		return -EINVAL;

968
	lock_sock(sk);
P
Per Liden 已提交
969

970 971
	if (unlikely(sock->state == SS_UNCONNECTED)) {
		res = -ENOTCONN;
P
Per Liden 已提交
972 973 974
		goto exit;
	}

975
	timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
976
restart:
P
Per Liden 已提交
977

978 979 980 981 982 983
	/* Look for a message in receive queue; wait if necessary */
	while (skb_queue_empty(&sk->sk_receive_queue)) {
		if (sock->state == SS_DISCONNECTING) {
			res = -ENOTCONN;
			goto exit;
		}
984 985
		if (timeout <= 0L) {
			res = timeout ? timeout : -EWOULDBLOCK;
986 987 988
			goto exit;
		}
		release_sock(sk);
989 990 991
		timeout = wait_event_interruptible_timeout(*sk_sleep(sk),
							   tipc_rx_ready(sock),
							   timeout);
992
		lock_sock(sk);
P
Per Liden 已提交
993 994
	}

995 996
	/* Look at first message in receive queue */
	buf = skb_peek(&sk->sk_receive_queue);
P
Per Liden 已提交
997 998 999 1000 1001 1002
	msg = buf_msg(buf);
	sz = msg_data_sz(msg);
	err = msg_errcode(msg);

	/* Discard an empty non-errored message & try again */
	if ((!sz) && (!err)) {
1003
		advance_rx_queue(sk);
P
Per Liden 已提交
1004 1005 1006 1007 1008 1009 1010
		goto restart;
	}

	/* Capture sender's address (optional) */
	set_orig_addr(m, msg);

	/* Capture ancillary data (optional) */
1011 1012
	res = anc_data_recv(m, msg, tport);
	if (res)
P
Per Liden 已提交
1013 1014 1015 1016 1017 1018 1019 1020
		goto exit;

	/* Capture message data (if valid) & compute return value (always) */
	if (!err) {
		if (unlikely(buf_len < sz)) {
			sz = buf_len;
			m->msg_flags |= MSG_TRUNC;
		}
1021 1022 1023
		res = skb_copy_datagram_iovec(buf, msg_hdr_sz(msg),
					      m->msg_iov, sz);
		if (res)
P
Per Liden 已提交
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
			goto exit;
		res = sz;
	} else {
		if ((sock->state == SS_READY) ||
		    ((err == TIPC_CONN_SHUTDOWN) || m->msg_control))
			res = 0;
		else
			res = -ECONNRESET;
	}

	/* Consume received message (optional) */
	if (likely(!(flags & MSG_PEEK))) {
1036
		if ((sock->state != SS_READY) &&
1037 1038 1039
		    (++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
			tipc_acknowledge(tport->ref, tport->conn_unacked);
		advance_rx_queue(sk);
1040
	}
P
Per Liden 已提交
1041
exit:
1042
	release_sock(sk);
P
Per Liden 已提交
1043 1044 1045
	return res;
}

1046
/**
P
Per Liden 已提交
1047 1048 1049 1050 1051
 * recv_stream - receive stream-oriented data
 * @iocb: (unused)
 * @m: descriptor for message info
 * @buf_len: total size of user buffer area
 * @flags: receive flags
1052 1053
 *
 * Used for SOCK_STREAM messages only.  If not enough data is available
P
Per Liden 已提交
1054 1055 1056 1057 1058 1059 1060
 * will optionally wait for more; never truncates data.
 *
 * Returns size of returned message data, errno otherwise
 */
static int recv_stream(struct kiocb *iocb, struct socket *sock,
		       struct msghdr *m, size_t buf_len, int flags)
{
1061 1062
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
P
Per Liden 已提交
1063 1064
	struct sk_buff *buf;
	struct tipc_msg *msg;
1065
	long timeout;
P
Per Liden 已提交
1066
	unsigned int sz;
1067
	int sz_to_copy, target, needed;
P
Per Liden 已提交
1068 1069
	int sz_copied = 0;
	u32 err;
1070
	int res = 0;
P
Per Liden 已提交
1071

1072
	/* Catch invalid receive attempts */
P
Per Liden 已提交
1073 1074 1075
	if (unlikely(!buf_len))
		return -EINVAL;

1076
	lock_sock(sk);
P
Per Liden 已提交
1077

1078
	if (unlikely((sock->state == SS_UNCONNECTED))) {
1079
		res = -ENOTCONN;
P
Per Liden 已提交
1080 1081 1082
		goto exit;
	}

1083
	target = sock_rcvlowat(sk, flags & MSG_WAITALL, buf_len);
1084
	timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
P
Per Liden 已提交
1085

1086
restart:
1087 1088 1089 1090 1091 1092
	/* Look for a message in receive queue; wait if necessary */
	while (skb_queue_empty(&sk->sk_receive_queue)) {
		if (sock->state == SS_DISCONNECTING) {
			res = -ENOTCONN;
			goto exit;
		}
1093 1094
		if (timeout <= 0L) {
			res = timeout ? timeout : -EWOULDBLOCK;
1095 1096 1097
			goto exit;
		}
		release_sock(sk);
1098 1099 1100
		timeout = wait_event_interruptible_timeout(*sk_sleep(sk),
							   tipc_rx_ready(sock),
							   timeout);
1101
		lock_sock(sk);
P
Per Liden 已提交
1102 1103
	}

1104 1105
	/* Look at first message in receive queue */
	buf = skb_peek(&sk->sk_receive_queue);
P
Per Liden 已提交
1106 1107 1108 1109 1110 1111
	msg = buf_msg(buf);
	sz = msg_data_sz(msg);
	err = msg_errcode(msg);

	/* Discard an empty non-errored message & try again */
	if ((!sz) && (!err)) {
1112
		advance_rx_queue(sk);
P
Per Liden 已提交
1113 1114 1115 1116 1117 1118
		goto restart;
	}

	/* Optionally capture sender's address & ancillary data of first msg */
	if (sz_copied == 0) {
		set_orig_addr(m, msg);
1119 1120
		res = anc_data_recv(m, msg, tport);
		if (res)
P
Per Liden 已提交
1121 1122 1123 1124 1125
			goto exit;
	}

	/* Capture message data (if valid) & compute return value (always) */
	if (!err) {
1126
		u32 offset = (u32)(unsigned long)(TIPC_SKB_CB(buf)->handle);
P
Per Liden 已提交
1127

1128
		sz -= offset;
P
Per Liden 已提交
1129 1130
		needed = (buf_len - sz_copied);
		sz_to_copy = (sz <= needed) ? sz : needed;
1131 1132 1133 1134

		res = skb_copy_datagram_iovec(buf, msg_hdr_sz(msg) + offset,
					      m->msg_iov, sz_to_copy);
		if (res)
P
Per Liden 已提交
1135
			goto exit;
1136

P
Per Liden 已提交
1137 1138 1139 1140
		sz_copied += sz_to_copy;

		if (sz_to_copy < sz) {
			if (!(flags & MSG_PEEK))
1141 1142
				TIPC_SKB_CB(buf)->handle =
				(void *)(unsigned long)(offset + sz_to_copy);
P
Per Liden 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
			goto exit;
		}
	} else {
		if (sz_copied != 0)
			goto exit; /* can't add error msg to valid data */

		if ((err == TIPC_CONN_SHUTDOWN) || m->msg_control)
			res = 0;
		else
			res = -ECONNRESET;
	}

	/* Consume received message (optional) */
	if (likely(!(flags & MSG_PEEK))) {
1157 1158 1159
		if (unlikely(++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
			tipc_acknowledge(tport->ref, tport->conn_unacked);
		advance_rx_queue(sk);
1160
	}
P
Per Liden 已提交
1161 1162

	/* Loop around if more data is required */
1163 1164
	if ((sz_copied < buf_len) &&	/* didn't get all requested data */
	    (!skb_queue_empty(&sk->sk_receive_queue) ||
1165
	    (sz_copied < target)) &&	/* and more is ready or required */
1166 1167
	    (!(flags & MSG_PEEK)) &&	/* and aren't just peeking at data */
	    (!err))			/* and haven't reached a FIN */
P
Per Liden 已提交
1168 1169 1170
		goto restart;

exit:
1171
	release_sock(sk);
1172
	return sz_copied ? sz_copied : res;
P
Per Liden 已提交
1173 1174
}

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
/**
 * tipc_write_space - wake up thread if port congestion is released
 * @sk: socket
 */
static void tipc_write_space(struct sock *sk)
{
	struct socket_wq *wq;

	rcu_read_lock();
	wq = rcu_dereference(sk->sk_wq);
	if (wq_has_sleeper(wq))
		wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
						POLLWRNORM | POLLWRBAND);
	rcu_read_unlock();
}

/**
 * tipc_data_ready - wake up threads to indicate messages have been received
 * @sk: socket
 * @len: the length of messages
 */
static void tipc_data_ready(struct sock *sk, int len)
{
	struct socket_wq *wq;

	rcu_read_lock();
	wq = rcu_dereference(sk->sk_wq);
	if (wq_has_sleeper(wq))
		wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
						POLLRDNORM | POLLRDBAND);
	rcu_read_unlock();
}

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
/**
 * filter_connect - Handle all incoming messages for a connection-based socket
 * @tsock: TIPC socket
 * @msg: message
 *
 * Returns TIPC error status code and socket error status code
 * once it encounters some errors
 */
static u32 filter_connect(struct tipc_sock *tsock, struct sk_buff **buf)
{
	struct socket *sock = tsock->sk.sk_socket;
	struct tipc_msg *msg = buf_msg(*buf);
1220
	struct sock *sk = &tsock->sk;
1221
	u32 retval = TIPC_ERR_NO_PORT;
1222
	int res;
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239

	if (msg_mcast(msg))
		return retval;

	switch ((int)sock->state) {
	case SS_CONNECTED:
		/* Accept only connection-based messages sent by peer */
		if (msg_connected(msg) && tipc_port_peer_msg(tsock->p, msg)) {
			if (unlikely(msg_errcode(msg))) {
				sock->state = SS_DISCONNECTING;
				__tipc_disconnect(tsock->p);
			}
			retval = TIPC_OK;
		}
		break;
	case SS_CONNECTING:
		/* Accept only ACK or NACK message */
1240 1241
		if (unlikely(msg_errcode(msg))) {
			sock->state = SS_DISCONNECTING;
1242
			sk->sk_err = ECONNREFUSED;
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
			retval = TIPC_OK;
			break;
		}

		if (unlikely(!msg_connected(msg)))
			break;

		res = auto_connect(sock, msg);
		if (res) {
			sock->state = SS_DISCONNECTING;
1253
			sk->sk_err = -res;
1254
			retval = TIPC_OK;
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
			break;
		}

		/* If an incoming message is an 'ACK-', it should be
		 * discarded here because it doesn't contain useful
		 * data. In addition, we should try to wake up
		 * connect() routine if sleeping.
		 */
		if (msg_data_sz(msg) == 0) {
			kfree_skb(*buf);
			*buf = NULL;
			if (waitqueue_active(sk_sleep(sk)))
				wake_up_interruptible(sk_sleep(sk));
		}
		retval = TIPC_OK;
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
		break;
	case SS_LISTENING:
	case SS_UNCONNECTED:
		/* Accept only SYN message */
		if (!msg_connected(msg) && !(msg_errcode(msg)))
			retval = TIPC_OK;
		break;
	case SS_DISCONNECTING:
		break;
	default:
		pr_err("Unknown socket state %u\n", sock->state);
	}
	return retval;
}

1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
/**
 * rcvbuf_limit - get proper overload limit of socket receive queue
 * @sk: socket
 * @buf: message
 *
 * For all connection oriented messages, irrespective of importance,
 * the default overload value (i.e. 67MB) is set as limit.
 *
 * For all connectionless messages, by default new queue limits are
 * as belows:
 *
1296 1297 1298 1299
 * TIPC_LOW_IMPORTANCE       (4 MB)
 * TIPC_MEDIUM_IMPORTANCE    (8 MB)
 * TIPC_HIGH_IMPORTANCE      (16 MB)
 * TIPC_CRITICAL_IMPORTANCE  (32 MB)
1300 1301 1302 1303 1304 1305 1306 1307
 *
 * Returns overload limit according to corresponding message importance
 */
static unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *buf)
{
	struct tipc_msg *msg = buf_msg(buf);

	if (msg_connected(msg))
1308 1309 1310 1311
		return sysctl_tipc_rmem[2];

	return sk->sk_rcvbuf >> TIPC_CRITICAL_IMPORTANCE <<
		msg_importance(msg);
1312 1313
}

1314
/**
1315 1316
 * filter_rcv - validate incoming message
 * @sk: socket
P
Per Liden 已提交
1317
 * @buf: message
1318
 *
1319 1320 1321 1322
 * Enqueues message on receive queue if acceptable; optionally handles
 * disconnect indication for a connected socket.
 *
 * Called with socket lock already taken; port lock may also be taken.
1323
 *
P
Per Liden 已提交
1324 1325
 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
 */
1326
static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
P
Per Liden 已提交
1327
{
1328
	struct socket *sock = sk->sk_socket;
P
Per Liden 已提交
1329
	struct tipc_msg *msg = buf_msg(buf);
1330
	unsigned int limit = rcvbuf_limit(sk, buf);
1331
	u32 res = TIPC_OK;
P
Per Liden 已提交
1332 1333

	/* Reject message if it is wrong sort of message for socket */
1334 1335
	if (msg_type(msg) > TIPC_DIRECT_MSG)
		return TIPC_ERR_NO_PORT;
1336

P
Per Liden 已提交
1337
	if (sock->state == SS_READY) {
1338
		if (msg_connected(msg))
P
Per Liden 已提交
1339 1340
			return TIPC_ERR_NO_PORT;
	} else {
1341 1342 1343
		res = filter_connect(tipc_sk(sk), &buf);
		if (res != TIPC_OK || buf == NULL)
			return res;
P
Per Liden 已提交
1344 1345 1346
	}

	/* Reject message if there isn't room to queue it */
1347 1348
	if (sk_rmem_alloc_get(sk) + buf->truesize >= limit)
		return TIPC_ERR_OVERLOAD;
P
Per Liden 已提交
1349

1350
	/* Enqueue message */
Y
Ying Xue 已提交
1351
	TIPC_SKB_CB(buf)->handle = NULL;
1352
	__skb_queue_tail(&sk->sk_receive_queue, buf);
1353
	skb_set_owner_r(buf, sk);
1354

1355
	sk->sk_data_ready(sk, 0);
1356 1357
	return TIPC_OK;
}
P
Per Liden 已提交
1358

1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
/**
 * backlog_rcv - handle incoming message from backlog queue
 * @sk: socket
 * @buf: message
 *
 * Caller must hold socket lock, but not port lock.
 *
 * Returns 0
 */
static int backlog_rcv(struct sock *sk, struct sk_buff *buf)
{
	u32 res;

	res = filter_rcv(sk, buf);
	if (res)
		tipc_reject_msg(buf, res);
	return 0;
}

/**
 * dispatch - handle incoming message
 * @tport: TIPC port that received message
 * @buf: message
 *
 * Called with port lock already taken.
 *
 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
 */
static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
{
1389
	struct sock *sk = tport->sk;
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
	u32 res;

	/*
	 * Process message if socket is unlocked; otherwise add to backlog queue
	 *
	 * This code is based on sk_receive_skb(), but must be distinct from it
	 * since a TIPC-specific filter/reject mechanism is utilized
	 */
	bh_lock_sock(sk);
	if (!sock_owned_by_user(sk)) {
		res = filter_rcv(sk, buf);
	} else {
1402
		if (sk_add_backlog(sk, buf, rcvbuf_limit(sk, buf)))
Z
Zhu Yi 已提交
1403 1404 1405
			res = TIPC_ERR_OVERLOAD;
		else
			res = TIPC_OK;
1406 1407 1408 1409
	}
	bh_unlock_sock(sk);

	return res;
P
Per Liden 已提交
1410 1411
}

1412
/**
P
Per Liden 已提交
1413 1414
 * wakeupdispatch - wake up port after congestion
 * @tport: port to wakeup
1415
 *
1416
 * Called with port lock already taken.
P
Per Liden 已提交
1417 1418 1419
 */
static void wakeupdispatch(struct tipc_port *tport)
{
1420
	struct sock *sk = tport->sk;
P
Per Liden 已提交
1421

1422
	sk->sk_write_space(sk);
P
Per Liden 已提交
1423 1424 1425 1426 1427 1428 1429
}

/**
 * connect - establish a connection to another TIPC port
 * @sock: socket structure
 * @dest: socket address for destination port
 * @destlen: size of socket address data structure
1430
 * @flags: file-related flags associated with socket
P
Per Liden 已提交
1431 1432 1433
 *
 * Returns 0 on success, errno otherwise
 */
1434
static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
P
Per Liden 已提交
1435 1436
		   int flags)
{
1437
	struct sock *sk = sock->sk;
1438 1439
	struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
	struct msghdr m = {NULL,};
1440
	unsigned int timeout;
1441 1442
	int res;

1443 1444
	lock_sock(sk);

1445
	/* For now, TIPC does not allow use of connect() with DGRAM/RDM types */
1446 1447 1448 1449
	if (sock->state == SS_READY) {
		res = -EOPNOTSUPP;
		goto exit;
	}
1450 1451 1452 1453 1454 1455 1456

	/*
	 * Reject connection attempt using multicast address
	 *
	 * Note: send_msg() validates the rest of the address fields,
	 *       so there's no need to do it here
	 */
1457 1458 1459 1460 1461
	if (dst->addrtype == TIPC_ADDR_MCAST) {
		res = -EINVAL;
		goto exit;
	}

1462
	timeout = (flags & O_NONBLOCK) ? 0 : tipc_sk(sk)->conn_timeout;
1463

1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
	switch (sock->state) {
	case SS_UNCONNECTED:
		/* Send a 'SYN-' to destination */
		m.msg_name = dest;
		m.msg_namelen = destlen;

		/* If connect is in non-blocking case, set MSG_DONTWAIT to
		 * indicate send_msg() is never blocked.
		 */
		if (!timeout)
			m.msg_flags = MSG_DONTWAIT;

		res = send_msg(NULL, sock, &m, 0);
		if ((res < 0) && (res != -EWOULDBLOCK))
			goto exit;

		/* Just entered SS_CONNECTING state; the only
		 * difference is that return value in non-blocking
		 * case is EINPROGRESS, rather than EALREADY.
		 */
		res = -EINPROGRESS;
		break;
	case SS_CONNECTING:
		res = -EALREADY;
		break;
	case SS_CONNECTED:
		res = -EISCONN;
		break;
	default:
		res = -EINVAL;
1494
		goto exit;
1495
	}
1496

1497 1498 1499
	if (sock->state == SS_CONNECTING) {
		if (!timeout)
			goto exit;
1500

1501 1502 1503 1504 1505 1506 1507 1508 1509
		/* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
		release_sock(sk);
		res = wait_event_interruptible_timeout(*sk_sleep(sk),
				sock->state != SS_CONNECTING,
				timeout ? (long)msecs_to_jiffies(timeout)
					: MAX_SCHEDULE_TIMEOUT);
		if (res <= 0) {
			if (res == 0)
				res = -ETIMEDOUT;
1510
			return res;
1511
		}
1512
		lock_sock(sk);
1513 1514
	}

1515 1516 1517 1518 1519
	if (unlikely(sock->state == SS_DISCONNECTING))
		res = sock_error(sk);
	else
		res = 0;

1520 1521
exit:
	release_sock(sk);
1522
	return res;
P
Per Liden 已提交
1523 1524
}

1525
/**
P
Per Liden 已提交
1526 1527 1528
 * listen - allow socket to listen for incoming connections
 * @sock: socket structure
 * @len: (unused)
1529
 *
P
Per Liden 已提交
1530 1531 1532 1533
 * Returns 0 on success, errno otherwise
 */
static int listen(struct socket *sock, int len)
{
1534 1535 1536 1537
	struct sock *sk = sock->sk;
	int res;

	lock_sock(sk);
P
Per Liden 已提交
1538

1539
	if (sock->state != SS_UNCONNECTED)
1540 1541 1542 1543 1544 1545 1546 1547
		res = -EINVAL;
	else {
		sock->state = SS_LISTENING;
		res = 0;
	}

	release_sock(sk);
	return res;
P
Per Liden 已提交
1548 1549
}

1550
/**
P
Per Liden 已提交
1551 1552 1553 1554
 * accept - wait for connection request
 * @sock: listening socket
 * @newsock: new socket that is to be connected
 * @flags: file-related flags associated with socket
1555
 *
P
Per Liden 已提交
1556 1557
 * Returns 0 on success, errno otherwise
 */
1558
static int accept(struct socket *sock, struct socket *new_sock, int flags)
P
Per Liden 已提交
1559
{
1560
	struct sock *new_sk, *sk = sock->sk;
P
Per Liden 已提交
1561
	struct sk_buff *buf;
1562 1563 1564 1565 1566
	struct tipc_sock *new_tsock;
	struct tipc_port *new_tport;
	struct tipc_msg *msg;
	u32 new_ref;

1567
	int res;
P
Per Liden 已提交
1568

1569
	lock_sock(sk);
P
Per Liden 已提交
1570

1571 1572
	if (sock->state != SS_LISTENING) {
		res = -EINVAL;
P
Per Liden 已提交
1573 1574 1575
		goto exit;
	}

1576 1577 1578 1579 1580 1581
	while (skb_queue_empty(&sk->sk_receive_queue)) {
		if (flags & O_NONBLOCK) {
			res = -EWOULDBLOCK;
			goto exit;
		}
		release_sock(sk);
E
Eric Dumazet 已提交
1582
		res = wait_event_interruptible(*sk_sleep(sk),
1583 1584 1585 1586 1587 1588 1589 1590
				(!skb_queue_empty(&sk->sk_receive_queue)));
		lock_sock(sk);
		if (res)
			goto exit;
	}

	buf = skb_peek(&sk->sk_receive_queue);

1591
	res = tipc_sk_create(sock_net(sock->sk), new_sock, 0, 1);
1592 1593
	if (res)
		goto exit;
P
Per Liden 已提交
1594

1595 1596 1597 1598 1599
	new_sk = new_sock->sk;
	new_tsock = tipc_sk(new_sk);
	new_tport = new_tsock->p;
	new_ref = new_tport->ref;
	msg = buf_msg(buf);
P
Per Liden 已提交
1600

1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
	/* we lock on new_sk; but lockdep sees the lock on sk */
	lock_sock_nested(new_sk, SINGLE_DEPTH_NESTING);

	/*
	 * Reject any stray messages received by new socket
	 * before the socket lock was taken (very, very unlikely)
	 */
	reject_rx_queue(new_sk);

	/* Connect new socket to it's peer */
	new_tsock->peer_name.ref = msg_origport(msg);
	new_tsock->peer_name.node = msg_orignode(msg);
	tipc_connect(new_ref, &new_tsock->peer_name);
	new_sock->state = SS_CONNECTED;

	tipc_set_portimportance(new_ref, msg_importance(msg));
	if (msg_named(msg)) {
		new_tport->conn_type = msg_nametype(msg);
		new_tport->conn_instance = msg_nameinst(msg);
P
Per Liden 已提交
1620
	}
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633

	/*
	 * Respond to 'SYN-' by discarding it & returning 'ACK'-.
	 * Respond to 'SYN+' by queuing it on new socket.
	 */
	if (!msg_data_sz(msg)) {
		struct msghdr m = {NULL,};

		advance_rx_queue(sk);
		send_packet(NULL, new_sock, &m, 0);
	} else {
		__skb_dequeue(&sk->sk_receive_queue);
		__skb_queue_head(&new_sk->sk_receive_queue, buf);
1634
		skb_set_owner_r(buf, new_sk);
1635 1636 1637
	}
	release_sock(new_sk);

P
Per Liden 已提交
1638
exit:
1639
	release_sock(sk);
P
Per Liden 已提交
1640 1641 1642 1643 1644 1645
	return res;
}

/**
 * shutdown - shutdown socket connection
 * @sock: socket structure
1646
 * @how: direction to close (must be SHUT_RDWR)
P
Per Liden 已提交
1647 1648
 *
 * Terminates connection (if necessary), then purges socket's receive queue.
1649
 *
P
Per Liden 已提交
1650 1651 1652 1653
 * Returns 0 on success, errno otherwise
 */
static int shutdown(struct socket *sock, int how)
{
1654 1655
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
P
Per Liden 已提交
1656 1657 1658
	struct sk_buff *buf;
	int res;

1659 1660
	if (how != SHUT_RDWR)
		return -EINVAL;
P
Per Liden 已提交
1661

1662
	lock_sock(sk);
P
Per Liden 已提交
1663 1664

	switch (sock->state) {
1665
	case SS_CONNECTING:
P
Per Liden 已提交
1666 1667 1668
	case SS_CONNECTED:

restart:
1669
		/* Disconnect and send a 'FIN+' or 'FIN-' message to peer */
1670 1671
		buf = __skb_dequeue(&sk->sk_receive_queue);
		if (buf) {
Y
Ying Xue 已提交
1672
			if (TIPC_SKB_CB(buf)->handle != NULL) {
1673
				kfree_skb(buf);
P
Per Liden 已提交
1674 1675
				goto restart;
			}
1676
			tipc_disconnect(tport->ref);
P
Per Liden 已提交
1677
			tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
1678 1679
		} else {
			tipc_shutdown(tport->ref);
P
Per Liden 已提交
1680
		}
1681 1682

		sock->state = SS_DISCONNECTING;
P
Per Liden 已提交
1683 1684 1685 1686 1687

		/* fall through */

	case SS_DISCONNECTING:

1688
		/* Discard any unreceived messages */
1689
		__skb_queue_purge(&sk->sk_receive_queue);
1690 1691 1692

		/* Wake up anyone sleeping in poll */
		sk->sk_state_change(sk);
P
Per Liden 已提交
1693 1694 1695 1696 1697 1698 1699
		res = 0;
		break;

	default:
		res = -ENOTCONN;
	}

1700
	release_sock(sk);
P
Per Liden 已提交
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
	return res;
}

/**
 * setsockopt - set socket option
 * @sock: socket structure
 * @lvl: option level
 * @opt: option identifier
 * @ov: pointer to new option value
 * @ol: length of option value
1711 1712
 *
 * For stream sockets only, accepts and ignores all IPPROTO_TCP options
P
Per Liden 已提交
1713
 * (to ease compatibility).
1714
 *
P
Per Liden 已提交
1715 1716
 * Returns 0 on success, errno otherwise
 */
1717 1718
static int setsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
		      unsigned int ol)
P
Per Liden 已提交
1719
{
1720 1721
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
P
Per Liden 已提交
1722 1723 1724
	u32 value;
	int res;

1725 1726
	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
		return 0;
P
Per Liden 已提交
1727 1728 1729 1730
	if (lvl != SOL_TIPC)
		return -ENOPROTOOPT;
	if (ol < sizeof(value))
		return -EINVAL;
1731 1732
	res = get_user(value, (u32 __user *)ov);
	if (res)
P
Per Liden 已提交
1733 1734
		return res;

1735
	lock_sock(sk);
1736

P
Per Liden 已提交
1737 1738
	switch (opt) {
	case TIPC_IMPORTANCE:
1739
		res = tipc_set_portimportance(tport->ref, value);
P
Per Liden 已提交
1740 1741 1742
		break;
	case TIPC_SRC_DROPPABLE:
		if (sock->type != SOCK_STREAM)
1743
			res = tipc_set_portunreliable(tport->ref, value);
1744
		else
P
Per Liden 已提交
1745 1746 1747
			res = -ENOPROTOOPT;
		break;
	case TIPC_DEST_DROPPABLE:
1748
		res = tipc_set_portunreturnable(tport->ref, value);
P
Per Liden 已提交
1749 1750
		break;
	case TIPC_CONN_TIMEOUT:
1751
		tipc_sk(sk)->conn_timeout = value;
1752
		/* no need to set "res", since already 0 at this point */
P
Per Liden 已提交
1753 1754 1755 1756 1757
		break;
	default:
		res = -EINVAL;
	}

1758 1759
	release_sock(sk);

P
Per Liden 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	return res;
}

/**
 * getsockopt - get socket option
 * @sock: socket structure
 * @lvl: option level
 * @opt: option identifier
 * @ov: receptacle for option value
 * @ol: receptacle for length of option value
1770 1771
 *
 * For stream sockets only, returns 0 length result for all IPPROTO_TCP options
P
Per Liden 已提交
1772
 * (to ease compatibility).
1773
 *
P
Per Liden 已提交
1774 1775
 * Returns 0 on success, errno otherwise
 */
1776 1777
static int getsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
		      int __user *ol)
P
Per Liden 已提交
1778
{
1779 1780
	struct sock *sk = sock->sk;
	struct tipc_port *tport = tipc_sk_port(sk);
1781
	int len;
P
Per Liden 已提交
1782
	u32 value;
1783
	int res;
P
Per Liden 已提交
1784

1785 1786
	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
		return put_user(0, ol);
P
Per Liden 已提交
1787 1788
	if (lvl != SOL_TIPC)
		return -ENOPROTOOPT;
1789 1790
	res = get_user(len, ol);
	if (res)
1791
		return res;
P
Per Liden 已提交
1792

1793
	lock_sock(sk);
P
Per Liden 已提交
1794 1795 1796

	switch (opt) {
	case TIPC_IMPORTANCE:
1797
		res = tipc_portimportance(tport->ref, &value);
P
Per Liden 已提交
1798 1799
		break;
	case TIPC_SRC_DROPPABLE:
1800
		res = tipc_portunreliable(tport->ref, &value);
P
Per Liden 已提交
1801 1802
		break;
	case TIPC_DEST_DROPPABLE:
1803
		res = tipc_portunreturnable(tport->ref, &value);
P
Per Liden 已提交
1804 1805
		break;
	case TIPC_CONN_TIMEOUT:
1806
		value = tipc_sk(sk)->conn_timeout;
1807
		/* no need to set "res", since already 0 at this point */
P
Per Liden 已提交
1808
		break;
1809
	case TIPC_NODE_RECVQ_DEPTH:
1810
		value = 0; /* was tipc_queue_size, now obsolete */
1811
		break;
1812
	case TIPC_SOCK_RECVQ_DEPTH:
1813 1814
		value = skb_queue_len(&sk->sk_receive_queue);
		break;
P
Per Liden 已提交
1815 1816 1817 1818
	default:
		res = -EINVAL;
	}

1819 1820
	release_sock(sk);

1821 1822
	if (res)
		return res;	/* "get" failed */
P
Per Liden 已提交
1823

1824 1825 1826 1827 1828 1829 1830
	if (len < sizeof(value))
		return -EINVAL;

	if (copy_to_user(ov, &value, sizeof(value)))
		return -EFAULT;

	return put_user(sizeof(value), ol);
P
Per Liden 已提交
1831 1832
}

1833 1834
/* Protocol switches for the various types of TIPC sockets */

1835
static const struct proto_ops msg_ops = {
1836
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1837 1838 1839 1840
	.family		= AF_TIPC,
	.release	= release,
	.bind		= bind,
	.connect	= connect,
1841
	.socketpair	= sock_no_socketpair,
1842
	.accept		= sock_no_accept,
P
Per Liden 已提交
1843 1844
	.getname	= get_name,
	.poll		= poll,
1845
	.ioctl		= sock_no_ioctl,
1846
	.listen		= sock_no_listen,
P
Per Liden 已提交
1847 1848 1849 1850 1851
	.shutdown	= shutdown,
	.setsockopt	= setsockopt,
	.getsockopt	= getsockopt,
	.sendmsg	= send_msg,
	.recvmsg	= recv_msg,
1852 1853
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1854 1855
};

1856
static const struct proto_ops packet_ops = {
1857
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1858 1859 1860 1861
	.family		= AF_TIPC,
	.release	= release,
	.bind		= bind,
	.connect	= connect,
1862
	.socketpair	= sock_no_socketpair,
P
Per Liden 已提交
1863 1864 1865
	.accept		= accept,
	.getname	= get_name,
	.poll		= poll,
1866
	.ioctl		= sock_no_ioctl,
P
Per Liden 已提交
1867 1868 1869 1870 1871 1872
	.listen		= listen,
	.shutdown	= shutdown,
	.setsockopt	= setsockopt,
	.getsockopt	= getsockopt,
	.sendmsg	= send_packet,
	.recvmsg	= recv_msg,
1873 1874
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1875 1876
};

1877
static const struct proto_ops stream_ops = {
1878
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1879 1880 1881 1882
	.family		= AF_TIPC,
	.release	= release,
	.bind		= bind,
	.connect	= connect,
1883
	.socketpair	= sock_no_socketpair,
P
Per Liden 已提交
1884 1885 1886
	.accept		= accept,
	.getname	= get_name,
	.poll		= poll,
1887
	.ioctl		= sock_no_ioctl,
P
Per Liden 已提交
1888 1889 1890 1891 1892 1893
	.listen		= listen,
	.shutdown	= shutdown,
	.setsockopt	= setsockopt,
	.getsockopt	= getsockopt,
	.sendmsg	= send_stream,
	.recvmsg	= recv_stream,
1894 1895
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1896 1897
};

1898
static const struct net_proto_family tipc_family_ops = {
1899
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1900
	.family		= AF_TIPC,
1901
	.create		= tipc_sk_create
P
Per Liden 已提交
1902 1903 1904 1905 1906
};

static struct proto tipc_proto = {
	.name		= "TIPC",
	.owner		= THIS_MODULE,
1907 1908
	.obj_size	= sizeof(struct tipc_sock),
	.sysctl_rmem	= sysctl_tipc_rmem
P
Per Liden 已提交
1909 1910
};

1911 1912 1913 1914 1915 1916
static struct proto tipc_proto_kern = {
	.name		= "TIPC",
	.obj_size	= sizeof(struct tipc_sock),
	.sysctl_rmem	= sysctl_tipc_rmem
};

P
Per Liden 已提交
1917
/**
1918
 * tipc_socket_init - initialize TIPC socket interface
1919
 *
P
Per Liden 已提交
1920 1921
 * Returns 0 on success, errno otherwise
 */
1922
int tipc_socket_init(void)
P
Per Liden 已提交
1923 1924 1925
{
	int res;

1926
	res = proto_register(&tipc_proto, 1);
P
Per Liden 已提交
1927
	if (res) {
1928
		pr_err("Failed to register TIPC protocol type\n");
P
Per Liden 已提交
1929 1930 1931 1932 1933
		goto out;
	}

	res = sock_register(&tipc_family_ops);
	if (res) {
1934
		pr_err("Failed to register TIPC socket type\n");
P
Per Liden 已提交
1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
		proto_unregister(&tipc_proto);
		goto out;
	}

	sockets_enabled = 1;
 out:
	return res;
}

/**
1945
 * tipc_socket_stop - stop TIPC socket interface
P
Per Liden 已提交
1946
 */
1947
void tipc_socket_stop(void)
P
Per Liden 已提交
1948 1949 1950 1951 1952 1953 1954 1955
{
	if (!sockets_enabled)
		return;

	sockets_enabled = 0;
	sock_unregister(tipc_family_ops.family);
	proto_unregister(&tipc_proto);
}