socket.c 50.5 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/socket.c: TIPC socket API
3
 *
4
 * Copyright (c) 2001-2007, 2012-2014, 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
#include <linux/export.h>

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

45
#define CONN_TIMEOUT_DEFAULT	8000	/* default connect timeout = 8s */
P
Per Liden 已提交
46

47
static int backlog_rcv(struct sock *sk, struct sk_buff *skb);
48 49
static void tipc_data_ready(struct sock *sk, int len);
static void tipc_write_space(struct sock *sk);
50 51
static int tipc_release(struct socket *sock);
static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags);
P
Per Liden 已提交
52

53 54 55
static const struct proto_ops packet_ops;
static const struct proto_ops stream_ops;
static const struct proto_ops msg_ops;
P
Per Liden 已提交
56 57

static struct proto tipc_proto;
58
static struct proto tipc_proto_kern;
P
Per Liden 已提交
59

60
/*
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 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
 * 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
 */

105 106
#include "socket.h"

107 108 109 110
/**
 * advance_rx_queue - discard first buffer in socket receive queue
 *
 * Caller must hold socket lock
P
Per Liden 已提交
111
 */
112
static void advance_rx_queue(struct sock *sk)
P
Per Liden 已提交
113
{
114
	kfree_skb(__skb_dequeue(&sk->sk_receive_queue));
P
Per Liden 已提交
115 116 117
}

/**
118 119 120
 * reject_rx_queue - reject all buffers in socket receive queue
 *
 * Caller must hold socket lock
P
Per Liden 已提交
121
 */
122
static void reject_rx_queue(struct sock *sk)
P
Per Liden 已提交
123
{
124 125
	struct sk_buff *buf;

126
	while ((buf = __skb_dequeue(&sk->sk_receive_queue)))
127
		tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
P
Per Liden 已提交
128 129 130
}

/**
131
 * tipc_sk_create - create a TIPC socket
132
 * @net: network namespace (must be default network)
P
Per Liden 已提交
133 134
 * @sock: pre-allocated socket structure
 * @protocol: protocol indicator (must be 0)
135
 * @kern: caused by kernel or by userspace?
136
 *
137 138
 * This routine creates additional data structures used by the TIPC socket,
 * initializes them, and links them together.
P
Per Liden 已提交
139 140 141
 *
 * Returns 0 on success, errno otherwise
 */
142 143
static int tipc_sk_create(struct net *net, struct socket *sock,
			  int protocol, int kern)
P
Per Liden 已提交
144
{
145 146
	const struct proto_ops *ops;
	socket_state state;
P
Per Liden 已提交
147
	struct sock *sk;
148 149 150
	struct tipc_sock *tsk;
	struct tipc_port *port;
	u32 ref;
151 152

	/* Validate arguments */
P
Per Liden 已提交
153 154 155 156 157
	if (unlikely(protocol != 0))
		return -EPROTONOSUPPORT;

	switch (sock->type) {
	case SOCK_STREAM:
158 159
		ops = &stream_ops;
		state = SS_UNCONNECTED;
P
Per Liden 已提交
160 161
		break;
	case SOCK_SEQPACKET:
162 163
		ops = &packet_ops;
		state = SS_UNCONNECTED;
P
Per Liden 已提交
164 165 166
		break;
	case SOCK_DGRAM:
	case SOCK_RDM:
167 168
		ops = &msg_ops;
		state = SS_READY;
P
Per Liden 已提交
169
		break;
170 171
	default:
		return -EPROTOTYPE;
P
Per Liden 已提交
172 173
	}

174
	/* Allocate socket's protocol area */
175 176 177 178 179
	if (!kern)
		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
	else
		sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto_kern);

180
	if (sk == NULL)
P
Per Liden 已提交
181 182
		return -ENOMEM;

183 184 185 186 187 188
	tsk = tipc_sk(sk);
	port = &tsk->port;

	ref = tipc_port_init(port, TIPC_LOW_IMPORTANCE);
	if (!ref) {
		pr_warn("Socket registration failed, ref. table exhausted\n");
189 190 191
		sk_free(sk);
		return -ENOMEM;
	}
P
Per Liden 已提交
192

193 194 195
	/* Finish initializing socket data structures */
	sock->ops = ops;
	sock->state = state;
P
Per Liden 已提交
196

197 198
	sock_init_data(sock, sk);
	sk->sk_backlog_rcv = backlog_rcv;
199
	sk->sk_rcvbuf = sysctl_tipc_rmem[1];
200 201
	sk->sk_data_ready = tipc_data_ready;
	sk->sk_write_space = tipc_write_space;
202
	tipc_sk(sk)->conn_timeout = CONN_TIMEOUT_DEFAULT;
203
	tipc_port_unlock(port);
204

205
	if (sock->state == SS_READY) {
206
		tipc_port_set_unreturnable(port, true);
207
		if (sock->type == SOCK_DGRAM)
208
			tipc_port_set_unreliable(port, true);
209
	}
P
Per Liden 已提交
210 211 212
	return 0;
}

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
/**
 * 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)
{
247
	tipc_release(sock);
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
	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,
263
			   int flags)
264 265 266 267 268 269 270 271 272
{
	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;

273
	ret = tipc_accept(sock, *newsock, flags);
274 275 276 277 278 279 280 281
	if (ret < 0) {
		sock_release(*newsock);
		return ret;
	}
	(*newsock)->ops = sock->ops;
	return ret;
}

P
Per Liden 已提交
282
/**
283
 * tipc_release - destroy a TIPC socket
P
Per Liden 已提交
284 285 286 287 288 289 290
 * @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.)
291
 *
P
Per Liden 已提交
292 293 294 295 296 297
 * 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
 */
298
static int tipc_release(struct socket *sock)
P
Per Liden 已提交
299 300
{
	struct sock *sk = sock->sk;
301 302
	struct tipc_sock *tsk;
	struct tipc_port *port;
P
Per Liden 已提交
303 304
	struct sk_buff *buf;

305 306 307 308 309
	/*
	 * 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 已提交
310
		return 0;
311

312 313
	tsk = tipc_sk(sk);
	port = &tsk->port;
314 315 316 317 318 319
	lock_sock(sk);

	/*
	 * Reject all unreceived messages, except on an active connection
	 * (which disconnects locally & sends a 'FIN+' to peer)
	 */
P
Per Liden 已提交
320
	while (sock->state != SS_DISCONNECTING) {
321 322
		buf = __skb_dequeue(&sk->sk_receive_queue);
		if (buf == NULL)
P
Per Liden 已提交
323
			break;
Y
Ying Xue 已提交
324
		if (TIPC_SKB_CB(buf)->handle != NULL)
325
			kfree_skb(buf);
326 327 328 329
		else {
			if ((sock->state == SS_CONNECTING) ||
			    (sock->state == SS_CONNECTED)) {
				sock->state = SS_DISCONNECTING;
330
				tipc_port_disconnect(port->ref);
331
			}
P
Per Liden 已提交
332
			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
333
		}
P
Per Liden 已提交
334 335
	}

336 337
	/* Destroy TIPC port; also disconnects an active connection and
	 * sends a 'FIN-' to peer.
338
	 */
339
	tipc_port_destroy(port);
P
Per Liden 已提交
340

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

344 345 346
	/* Reject any messages that accumulated in backlog queue */
	sock->state = SS_DISCONNECTING;
	release_sock(sk);
P
Per Liden 已提交
347 348

	sock_put(sk);
349
	sock->sk = NULL;
P
Per Liden 已提交
350

351
	return 0;
P
Per Liden 已提交
352 353 354
}

/**
355
 * tipc_bind - associate or disassocate TIPC name(s) with a socket
P
Per Liden 已提交
356 357 358
 * @sock: socket structure
 * @uaddr: socket address describing name(s) and desired operation
 * @uaddr_len: size of socket address data structure
359
 *
P
Per Liden 已提交
360 361 362
 * 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.
363
 *
P
Per Liden 已提交
364
 * Returns 0 on success, errno otherwise
365 366 367
 *
 * NOTE: This routine doesn't need to take the socket lock since it doesn't
 *       access any non-constant socket information.
P
Per Liden 已提交
368
 */
369 370
static int tipc_bind(struct socket *sock, struct sockaddr *uaddr,
		     int uaddr_len)
P
Per Liden 已提交
371
{
372
	struct sock *sk = sock->sk;
P
Per Liden 已提交
373
	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
374
	struct tipc_sock *tsk = tipc_sk(sk);
375
	int res = -EINVAL;
P
Per Liden 已提交
376

377 378
	lock_sock(sk);
	if (unlikely(!uaddr_len)) {
379
		res = tipc_withdraw(&tsk->port, 0, NULL);
380 381
		goto exit;
	}
382

383 384 385 386 387 388 389 390
	if (uaddr_len < sizeof(struct sockaddr_tipc)) {
		res = -EINVAL;
		goto exit;
	}
	if (addr->family != AF_TIPC) {
		res = -EAFNOSUPPORT;
		goto exit;
	}
P
Per Liden 已提交
391 392 393

	if (addr->addrtype == TIPC_ADDR_NAME)
		addr->addr.nameseq.upper = addr->addr.nameseq.lower;
394 395 396 397
	else if (addr->addrtype != TIPC_ADDR_NAMESEQ) {
		res = -EAFNOSUPPORT;
		goto exit;
	}
398

399
	if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) &&
400
	    (addr->addr.nameseq.type != TIPC_TOP_SRV) &&
401 402 403 404
	    (addr->addr.nameseq.type != TIPC_CFG_SRV)) {
		res = -EACCES;
		goto exit;
	}
405

406
	res = (addr->scope > 0) ?
407 408
		tipc_publish(&tsk->port, addr->scope, &addr->addr.nameseq) :
		tipc_withdraw(&tsk->port, -addr->scope, &addr->addr.nameseq);
409 410 411
exit:
	release_sock(sk);
	return res;
P
Per Liden 已提交
412 413
}

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

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

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

451
	return 0;
P
Per Liden 已提交
452 453 454
}

/**
455
 * tipc_poll - read and possibly block on pollmask
P
Per Liden 已提交
456 457 458 459
 * @file: file structure associated with the socket
 * @sock: socket for which to calculate the poll bits
 * @wait: ???
 *
460 461 462 463 464 465 466 467 468
 * 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:
469 470 471 472
 *
 * socket state		flags set
 * ------------		---------
 * unconnected		no read flags
473
 *			POLLOUT if port is not congested
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
 *
 * 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 已提交
493
 */
494 495
static unsigned int tipc_poll(struct file *file, struct socket *sock,
			      poll_table *wait)
P
Per Liden 已提交
496
{
497
	struct sock *sk = sock->sk;
498
	struct tipc_sock *tsk = tipc_sk(sk);
499
	u32 mask = 0;
500

501
	sock_poll_wait(file, sk_sleep(sk), wait);
502

503
	switch ((int)sock->state) {
504
	case SS_UNCONNECTED:
505
		if (!tsk->port.congested)
506 507
			mask |= POLLOUT;
		break;
508 509
	case SS_READY:
	case SS_CONNECTED:
510
		if (!tsk->port.congested)
511 512 513 514 515 516 517 518 519 520 521
			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;
	}
522 523

	return mask;
P
Per Liden 已提交
524 525
}

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

540 541 542 543 544 545
	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 已提交
546

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

P
Per Liden 已提交
554 555 556
	return 0;
}

557 558 559
static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p)
{
	struct sock *sk = sock->sk;
560
	struct tipc_sock *tsk = tipc_sk(sk);
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
	DEFINE_WAIT(wait);
	int done;

	do {
		int err = sock_error(sk);
		if (err)
			return err;
		if (sock->state == SS_DISCONNECTING)
			return -EPIPE;
		if (!*timeo_p)
			return -EAGAIN;
		if (signal_pending(current))
			return sock_intr_errno(*timeo_p);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
576
		done = sk_wait_event(sk, timeo_p, !tsk->port.congested);
577 578 579 580 581
		finish_wait(sk_sleep(sk), &wait);
	} while (!done);
	return 0;
}

582

P
Per Liden 已提交
583
/**
584
 * tipc_sendmsg - send message in connectionless manner
585
 * @iocb: if NULL, indicates that socket lock is already held
P
Per Liden 已提交
586 587
 * @sock: socket structure
 * @m: message to send
588
 * @total_len: length of message
589
 *
P
Per Liden 已提交
590
 * Message must have an destination specified explicitly.
591
 * Used for SOCK_RDM and SOCK_DGRAM messages,
P
Per Liden 已提交
592 593
 * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
 * (Note: 'SYN+' is prohibited on SOCK_STREAM.)
594
 *
P
Per Liden 已提交
595 596
 * Returns the number of bytes sent on success, or errno otherwise
 */
597 598
static int tipc_sendmsg(struct kiocb *iocb, struct socket *sock,
			struct msghdr *m, size_t total_len)
P
Per Liden 已提交
599
{
600
	struct sock *sk = sock->sk;
601
	struct tipc_sock *tsk = tipc_sk(sk);
602
	struct tipc_port *port = &tsk->port;
603
	DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
P
Per Liden 已提交
604
	int needs_conn;
605
	long timeo;
P
Per Liden 已提交
606 607 608 609
	int res = -EINVAL;

	if (unlikely(!dest))
		return -EDESTADDRREQ;
610 611
	if (unlikely((m->msg_namelen < sizeof(*dest)) ||
		     (dest->family != AF_TIPC)))
P
Per Liden 已提交
612
		return -EINVAL;
613
	if (total_len > TIPC_MAX_USER_MSG_SIZE)
614
		return -EMSGSIZE;
P
Per Liden 已提交
615

616 617 618
	if (iocb)
		lock_sock(sk);

P
Per Liden 已提交
619 620
	needs_conn = (sock->state != SS_READY);
	if (unlikely(needs_conn)) {
621 622 623 624 625 626 627 628
		if (sock->state == SS_LISTENING) {
			res = -EPIPE;
			goto exit;
		}
		if (sock->state != SS_UNCONNECTED) {
			res = -EISCONN;
			goto exit;
		}
629
		if (tsk->port.published) {
630 631 632
			res = -EOPNOTSUPP;
			goto exit;
		}
633
		if (dest->addrtype == TIPC_ADDR_NAME) {
634 635
			tsk->port.conn_type = dest->addr.name.name.type;
			tsk->port.conn_instance = dest->addr.name.name.instance;
636
		}
P
Per Liden 已提交
637 638

		/* Abort any pending connection attempts (very unlikely) */
639
		reject_rx_queue(sk);
P
Per Liden 已提交
640 641
	}

642
	timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);
643 644
	do {
		if (dest->addrtype == TIPC_ADDR_NAME) {
645 646
			res = dest_name_check(dest, m);
			if (res)
647
				break;
648
			res = tipc_send2name(port,
649 650
					     &dest->addr.name.name,
					     dest->addr.name.domain,
651 652
					     m->msg_iov,
					     total_len);
653
		} else if (dest->addrtype == TIPC_ADDR_ID) {
654
			res = tipc_send2port(port,
655
					     &dest->addr.id,
656 657
					     m->msg_iov,
					     total_len);
658
		} else if (dest->addrtype == TIPC_ADDR_MCAST) {
P
Per Liden 已提交
659 660
			if (needs_conn) {
				res = -EOPNOTSUPP;
661
				break;
P
Per Liden 已提交
662
			}
663 664
			res = dest_name_check(dest, m);
			if (res)
665
				break;
666
			res = tipc_port_mcast_xmit(port,
667 668 669
						   &dest->addr.nameseq,
						   m->msg_iov,
						   total_len);
670 671
		}
		if (likely(res != -ELINKCONG)) {
672
			if (needs_conn && (res >= 0))
673 674
				sock->state = SS_CONNECTING;
			break;
675
		}
676 677
		res = tipc_wait_for_sndmsg(sock, &timeo);
		if (res)
678
			break;
679
	} while (1);
680 681 682 683 684

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

687 688 689
static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p)
{
	struct sock *sk = sock->sk;
690 691
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	DEFINE_WAIT(wait);
	int done;

	do {
		int err = sock_error(sk);
		if (err)
			return err;
		if (sock->state == SS_DISCONNECTING)
			return -EPIPE;
		else if (sock->state != SS_CONNECTED)
			return -ENOTCONN;
		if (!*timeo_p)
			return -EAGAIN;
		if (signal_pending(current))
			return sock_intr_errno(*timeo_p);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		done = sk_wait_event(sk, timeo_p,
710
				     (!port->congested || !port->connected));
711 712 713 714 715
		finish_wait(sk_sleep(sk), &wait);
	} while (!done);
	return 0;
}

716
/**
717
 * tipc_send_packet - send a connection-oriented message
718
 * @iocb: if NULL, indicates that socket lock is already held
P
Per Liden 已提交
719 720
 * @sock: socket structure
 * @m: message to send
721
 * @total_len: length of message
722
 *
P
Per Liden 已提交
723
 * Used for SOCK_SEQPACKET messages and SOCK_STREAM data.
724
 *
P
Per Liden 已提交
725 726
 * Returns the number of bytes sent on success, or errno otherwise
 */
727 728
static int tipc_send_packet(struct kiocb *iocb, struct socket *sock,
			    struct msghdr *m, size_t total_len)
P
Per Liden 已提交
729
{
730
	struct sock *sk = sock->sk;
731
	struct tipc_sock *tsk = tipc_sk(sk);
732
	DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
733 734
	int res = -EINVAL;
	long timeo;
P
Per Liden 已提交
735 736 737

	/* Handle implied connection establishment */
	if (unlikely(dest))
738
		return tipc_sendmsg(iocb, sock, m, total_len);
P
Per Liden 已提交
739

740
	if (total_len > TIPC_MAX_USER_MSG_SIZE)
741 742
		return -EMSGSIZE;

743 744
	if (iocb)
		lock_sock(sk);
P
Per Liden 已提交
745

746 747 748 749 750 751 752
	if (unlikely(sock->state != SS_CONNECTED)) {
		if (sock->state == SS_DISCONNECTING)
			res = -EPIPE;
		else
			res = -ENOTCONN;
		goto exit;
	}
753

754
	timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);
755
	do {
756
		res = tipc_send(&tsk->port, m->msg_iov, total_len);
757
		if (likely(res != -ELINKCONG))
758
			break;
759 760
		res = tipc_wait_for_sndpkt(sock, &timeo);
		if (res)
761
			break;
762
	} while (1);
763
exit:
764 765 766
	if (iocb)
		release_sock(sk);
	return res;
P
Per Liden 已提交
767 768
}

769
/**
770
 * tipc_send_stream - send stream-oriented data
P
Per Liden 已提交
771 772 773 774
 * @iocb: (unused)
 * @sock: socket structure
 * @m: data to send
 * @total_len: total length of data to be sent
775
 *
P
Per Liden 已提交
776
 * Used for SOCK_STREAM data.
777 778
 *
 * Returns the number of bytes sent on success (or partial success),
779
 * or errno if no data sent
P
Per Liden 已提交
780
 */
781 782
static int tipc_send_stream(struct kiocb *iocb, struct socket *sock,
			    struct msghdr *m, size_t total_len)
P
Per Liden 已提交
783
{
784
	struct sock *sk = sock->sk;
785
	struct tipc_sock *tsk = tipc_sk(sk);
P
Per Liden 已提交
786 787 788 789 790
	struct msghdr my_msg;
	struct iovec my_iov;
	struct iovec *curr_iov;
	int curr_iovlen;
	char __user *curr_start;
791
	u32 hdr_size;
P
Per Liden 已提交
792 793
	int curr_left;
	int bytes_to_send;
794
	int bytes_sent;
P
Per Liden 已提交
795
	int res;
796

797 798
	lock_sock(sk);

799
	/* Handle special cases where there is no connection */
800
	if (unlikely(sock->state != SS_CONNECTED)) {
W
wangweidong 已提交
801
		if (sock->state == SS_UNCONNECTED)
802
			res = tipc_send_packet(NULL, sock, m, total_len);
803 804
		else
			res = sock->state == SS_DISCONNECTING ? -EPIPE : -ENOTCONN;
W
wangweidong 已提交
805
		goto exit;
806
	}
P
Per Liden 已提交
807

808 809 810 811
	if (unlikely(m->msg_name)) {
		res = -EISCONN;
		goto exit;
	}
812

813
	if (total_len > (unsigned int)INT_MAX) {
814 815 816 817
		res = -EMSGSIZE;
		goto exit;
	}

818
	/*
P
Per Liden 已提交
819 820
	 * Send each iovec entry using one or more messages
	 *
821
	 * Note: This algorithm is good for the most likely case
P
Per Liden 已提交
822 823 824
	 * (i.e. one large iovec entry), but could be improved to pass sets
	 * of small iovec entries into send_packet().
	 */
825 826
	curr_iov = m->msg_iov;
	curr_iovlen = m->msg_iovlen;
P
Per Liden 已提交
827 828
	my_msg.msg_iov = &my_iov;
	my_msg.msg_iovlen = 1;
829 830
	my_msg.msg_flags = m->msg_flags;
	my_msg.msg_name = NULL;
831
	bytes_sent = 0;
P
Per Liden 已提交
832

833
	hdr_size = msg_hdr_sz(&tsk->port.phdr);
834

P
Per Liden 已提交
835 836 837 838 839
	while (curr_iovlen--) {
		curr_start = curr_iov->iov_base;
		curr_left = curr_iov->iov_len;

		while (curr_left) {
840
			bytes_to_send = tsk->port.max_pkt - hdr_size;
841 842 843 844
			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 已提交
845 846
			my_iov.iov_base = curr_start;
			my_iov.iov_len = bytes_to_send;
847 848
			res = tipc_send_packet(NULL, sock, &my_msg,
					       bytes_to_send);
849
			if (res < 0) {
850
				if (bytes_sent)
851
					res = bytes_sent;
852
				goto exit;
853
			}
P
Per Liden 已提交
854 855
			curr_left -= bytes_to_send;
			curr_start += bytes_to_send;
856
			bytes_sent += bytes_to_send;
P
Per Liden 已提交
857 858 859 860
		}

		curr_iov++;
	}
861 862 863 864
	res = bytes_sent;
exit:
	release_sock(sk);
	return res;
P
Per Liden 已提交
865 866 867 868
}

/**
 * auto_connect - complete connection setup to a remote port
869
 * @tsk: tipc socket structure
P
Per Liden 已提交
870
 * @msg: peer's response message
871
 *
P
Per Liden 已提交
872 873
 * Returns 0 on success, errno otherwise
 */
874
static int auto_connect(struct tipc_sock *tsk, struct tipc_msg *msg)
P
Per Liden 已提交
875
{
876 877
	struct tipc_port *port = &tsk->port;
	struct socket *sock = tsk->sk.sk_socket;
878 879 880 881
	struct tipc_portid peer;

	peer.ref = msg_origport(msg);
	peer.node = msg_orignode(msg);
P
Per Liden 已提交
882

883
	__tipc_port_connect(port->ref, port, &peer);
884 885 886

	if (msg_importance(msg) > TIPC_CRITICAL_IMPORTANCE)
		return -EINVAL;
887
	msg_set_importance(&port->phdr, (u32)msg_importance(msg));
P
Per Liden 已提交
888 889 890 891 892 893 894 895
	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
896
 *
P
Per Liden 已提交
897 898
 * Note: Address is not captured if not requested by receiver.
 */
S
Sam Ravnborg 已提交
899
static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg)
P
Per Liden 已提交
900
{
901
	DECLARE_SOCKADDR(struct sockaddr_tipc *, addr, m->msg_name);
P
Per Liden 已提交
902

903
	if (addr) {
P
Per Liden 已提交
904 905
		addr->family = AF_TIPC;
		addr->addrtype = TIPC_ADDR_ID;
906
		memset(&addr->addr, 0, sizeof(addr->addr));
P
Per Liden 已提交
907 908
		addr->addr.id.ref = msg_origport(msg);
		addr->addr.id.node = msg_orignode(msg);
909 910
		addr->addr.name.domain = 0;	/* could leave uninitialized */
		addr->scope = 0;		/* could leave uninitialized */
P
Per Liden 已提交
911 912 913 914 915
		m->msg_namelen = sizeof(struct sockaddr_tipc);
	}
}

/**
916
 * anc_data_recv - optionally capture ancillary data for received message
P
Per Liden 已提交
917 918 919
 * @m: descriptor for message info
 * @msg: received message header
 * @tport: TIPC port associated with message
920
 *
P
Per Liden 已提交
921
 * Note: Ancillary data is not captured if not requested by receiver.
922
 *
P
Per Liden 已提交
923 924
 * Returns 0 if successful, otherwise errno
 */
S
Sam Ravnborg 已提交
925
static int anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
926
			 struct tipc_port *tport)
P
Per Liden 已提交
927 928 929 930
{
	u32 anc_data[3];
	u32 err;
	u32 dest_type;
931
	int has_name;
P
Per Liden 已提交
932 933 934 935 936 937 938 939 940 941
	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);
942 943
		res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data);
		if (res)
P
Per Liden 已提交
944
			return res;
945 946 947 948 949 950
		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 已提交
951 952 953 954 955 956
	}

	/* Optionally capture message destination object */
	dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
	switch (dest_type) {
	case TIPC_NAMED_MSG:
957
		has_name = 1;
P
Per Liden 已提交
958 959 960 961 962
		anc_data[0] = msg_nametype(msg);
		anc_data[1] = msg_namelower(msg);
		anc_data[2] = msg_namelower(msg);
		break;
	case TIPC_MCAST_MSG:
963
		has_name = 1;
P
Per Liden 已提交
964 965 966 967 968
		anc_data[0] = msg_nametype(msg);
		anc_data[1] = msg_namelower(msg);
		anc_data[2] = msg_nameupper(msg);
		break;
	case TIPC_CONN_MSG:
969
		has_name = (tport->conn_type != 0);
P
Per Liden 已提交
970 971 972 973 974
		anc_data[0] = tport->conn_type;
		anc_data[1] = tport->conn_instance;
		anc_data[2] = tport->conn_instance;
		break;
	default:
975
		has_name = 0;
P
Per Liden 已提交
976
	}
977 978 979 980 981
	if (has_name) {
		res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data);
		if (res)
			return res;
	}
P
Per Liden 已提交
982 983 984 985

	return 0;
}

Y
Ying Xue 已提交
986 987 988 989 990 991 992 993
static int tipc_wait_for_rcvmsg(struct socket *sock, long timeo)
{
	struct sock *sk = sock->sk;
	DEFINE_WAIT(wait);
	int err;

	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
994
		if (timeo && skb_queue_empty(&sk->sk_receive_queue)) {
Y
Ying Xue 已提交
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
			if (sock->state == SS_DISCONNECTING) {
				err = -ENOTCONN;
				break;
			}
			release_sock(sk);
			timeo = schedule_timeout(timeo);
			lock_sock(sk);
		}
		err = 0;
		if (!skb_queue_empty(&sk->sk_receive_queue))
			break;
		err = sock_intr_errno(timeo);
		if (signal_pending(current))
			break;
		err = -EAGAIN;
		if (!timeo)
			break;
	}
	finish_wait(sk_sleep(sk), &wait);
	return err;
}

1017
/**
1018
 * tipc_recvmsg - receive packet-oriented message
P
Per Liden 已提交
1019 1020 1021 1022
 * @iocb: (unused)
 * @m: descriptor for message info
 * @buf_len: total size of user buffer area
 * @flags: receive flags
1023
 *
P
Per Liden 已提交
1024 1025 1026 1027 1028
 * 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
 */
1029 1030
static int tipc_recvmsg(struct kiocb *iocb, struct socket *sock,
			struct msghdr *m, size_t buf_len, int flags)
P
Per Liden 已提交
1031
{
1032
	struct sock *sk = sock->sk;
1033 1034
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
P
Per Liden 已提交
1035 1036
	struct sk_buff *buf;
	struct tipc_msg *msg;
Y
Ying Xue 已提交
1037
	long timeo;
P
Per Liden 已提交
1038 1039 1040 1041
	unsigned int sz;
	u32 err;
	int res;

1042
	/* Catch invalid receive requests */
P
Per Liden 已提交
1043 1044 1045
	if (unlikely(!buf_len))
		return -EINVAL;

1046
	lock_sock(sk);
P
Per Liden 已提交
1047

1048 1049
	if (unlikely(sock->state == SS_UNCONNECTED)) {
		res = -ENOTCONN;
P
Per Liden 已提交
1050 1051 1052
		goto exit;
	}

Y
Ying Xue 已提交
1053
	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1054
restart:
P
Per Liden 已提交
1055

1056
	/* Look for a message in receive queue; wait if necessary */
Y
Ying Xue 已提交
1057 1058 1059
	res = tipc_wait_for_rcvmsg(sock, timeo);
	if (res)
		goto exit;
P
Per Liden 已提交
1060

1061 1062
	/* Look at first message in receive queue */
	buf = skb_peek(&sk->sk_receive_queue);
P
Per Liden 已提交
1063 1064 1065 1066 1067 1068
	msg = buf_msg(buf);
	sz = msg_data_sz(msg);
	err = msg_errcode(msg);

	/* Discard an empty non-errored message & try again */
	if ((!sz) && (!err)) {
1069
		advance_rx_queue(sk);
P
Per Liden 已提交
1070 1071 1072 1073 1074 1075 1076
		goto restart;
	}

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

	/* Capture ancillary data (optional) */
1077
	res = anc_data_recv(m, msg, port);
1078
	if (res)
P
Per Liden 已提交
1079 1080 1081 1082 1083 1084 1085 1086
		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;
		}
1087 1088 1089
		res = skb_copy_datagram_iovec(buf, msg_hdr_sz(msg),
					      m->msg_iov, sz);
		if (res)
P
Per Liden 已提交
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
			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))) {
1102
		if ((sock->state != SS_READY) &&
1103 1104
		    (++port->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
			tipc_acknowledge(port->ref, port->conn_unacked);
1105
		advance_rx_queue(sk);
1106
	}
P
Per Liden 已提交
1107
exit:
1108
	release_sock(sk);
P
Per Liden 已提交
1109 1110 1111
	return res;
}

1112
/**
1113
 * tipc_recv_stream - receive stream-oriented data
P
Per Liden 已提交
1114 1115 1116 1117
 * @iocb: (unused)
 * @m: descriptor for message info
 * @buf_len: total size of user buffer area
 * @flags: receive flags
1118 1119
 *
 * Used for SOCK_STREAM messages only.  If not enough data is available
P
Per Liden 已提交
1120 1121 1122 1123
 * will optionally wait for more; never truncates data.
 *
 * Returns size of returned message data, errno otherwise
 */
1124 1125
static int tipc_recv_stream(struct kiocb *iocb, struct socket *sock,
			    struct msghdr *m, size_t buf_len, int flags)
P
Per Liden 已提交
1126
{
1127
	struct sock *sk = sock->sk;
1128 1129
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
P
Per Liden 已提交
1130 1131
	struct sk_buff *buf;
	struct tipc_msg *msg;
Y
Ying Xue 已提交
1132
	long timeo;
P
Per Liden 已提交
1133
	unsigned int sz;
1134
	int sz_to_copy, target, needed;
P
Per Liden 已提交
1135 1136
	int sz_copied = 0;
	u32 err;
1137
	int res = 0;
P
Per Liden 已提交
1138

1139
	/* Catch invalid receive attempts */
P
Per Liden 已提交
1140 1141 1142
	if (unlikely(!buf_len))
		return -EINVAL;

1143
	lock_sock(sk);
P
Per Liden 已提交
1144

Y
Ying Xue 已提交
1145
	if (unlikely(sock->state == SS_UNCONNECTED)) {
1146
		res = -ENOTCONN;
P
Per Liden 已提交
1147 1148 1149
		goto exit;
	}

1150
	target = sock_rcvlowat(sk, flags & MSG_WAITALL, buf_len);
Y
Ying Xue 已提交
1151
	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
P
Per Liden 已提交
1152

1153
restart:
1154
	/* Look for a message in receive queue; wait if necessary */
Y
Ying Xue 已提交
1155 1156 1157
	res = tipc_wait_for_rcvmsg(sock, timeo);
	if (res)
		goto exit;
P
Per Liden 已提交
1158

1159 1160
	/* Look at first message in receive queue */
	buf = skb_peek(&sk->sk_receive_queue);
P
Per Liden 已提交
1161 1162 1163 1164 1165 1166
	msg = buf_msg(buf);
	sz = msg_data_sz(msg);
	err = msg_errcode(msg);

	/* Discard an empty non-errored message & try again */
	if ((!sz) && (!err)) {
1167
		advance_rx_queue(sk);
P
Per Liden 已提交
1168 1169 1170 1171 1172 1173
		goto restart;
	}

	/* Optionally capture sender's address & ancillary data of first msg */
	if (sz_copied == 0) {
		set_orig_addr(m, msg);
1174
		res = anc_data_recv(m, msg, port);
1175
		if (res)
P
Per Liden 已提交
1176 1177 1178 1179 1180
			goto exit;
	}

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

1183
		sz -= offset;
P
Per Liden 已提交
1184 1185
		needed = (buf_len - sz_copied);
		sz_to_copy = (sz <= needed) ? sz : needed;
1186 1187 1188 1189

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

P
Per Liden 已提交
1192 1193 1194 1195
		sz_copied += sz_to_copy;

		if (sz_to_copy < sz) {
			if (!(flags & MSG_PEEK))
1196 1197
				TIPC_SKB_CB(buf)->handle =
				(void *)(unsigned long)(offset + sz_to_copy);
P
Per Liden 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
			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))) {
1212 1213
		if (unlikely(++port->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
			tipc_acknowledge(port->ref, port->conn_unacked);
1214
		advance_rx_queue(sk);
1215
	}
P
Per Liden 已提交
1216 1217

	/* Loop around if more data is required */
1218 1219
	if ((sz_copied < buf_len) &&	/* didn't get all requested data */
	    (!skb_queue_empty(&sk->sk_receive_queue) ||
1220
	    (sz_copied < target)) &&	/* and more is ready or required */
1221 1222
	    (!(flags & MSG_PEEK)) &&	/* and aren't just peeking at data */
	    (!err))			/* and haven't reached a FIN */
P
Per Liden 已提交
1223 1224 1225
		goto restart;

exit:
1226
	release_sock(sk);
1227
	return sz_copied ? sz_copied : res;
P
Per Liden 已提交
1228 1229
}

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
/**
 * 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();
}

1263 1264
/**
 * filter_connect - Handle all incoming messages for a connection-based socket
1265
 * @tsk: TIPC socket
1266 1267 1268 1269 1270
 * @msg: message
 *
 * Returns TIPC error status code and socket error status code
 * once it encounters some errors
 */
1271
static u32 filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
1272
{
1273 1274
	struct sock *sk = &tsk->sk;
	struct tipc_port *port = &tsk->port;
1275
	struct socket *sock = sk->sk_socket;
1276
	struct tipc_msg *msg = buf_msg(*buf);
1277

1278
	u32 retval = TIPC_ERR_NO_PORT;
1279
	int res;
1280 1281 1282 1283 1284 1285 1286

	if (msg_mcast(msg))
		return retval;

	switch ((int)sock->state) {
	case SS_CONNECTED:
		/* Accept only connection-based messages sent by peer */
1287
		if (msg_connected(msg) && tipc_port_peer_msg(port, msg)) {
1288 1289
			if (unlikely(msg_errcode(msg))) {
				sock->state = SS_DISCONNECTING;
1290
				__tipc_port_disconnect(port);
1291 1292 1293 1294 1295 1296
			}
			retval = TIPC_OK;
		}
		break;
	case SS_CONNECTING:
		/* Accept only ACK or NACK message */
1297 1298
		if (unlikely(msg_errcode(msg))) {
			sock->state = SS_DISCONNECTING;
1299
			sk->sk_err = ECONNREFUSED;
1300 1301 1302 1303 1304 1305 1306
			retval = TIPC_OK;
			break;
		}

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

1307
		res = auto_connect(tsk, msg);
1308 1309
		if (res) {
			sock->state = SS_DISCONNECTING;
1310
			sk->sk_err = -res;
1311
			retval = TIPC_OK;
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
			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;
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
		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;
}

1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
/**
 * 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:
 *
1353 1354 1355 1356
 * TIPC_LOW_IMPORTANCE       (4 MB)
 * TIPC_MEDIUM_IMPORTANCE    (8 MB)
 * TIPC_HIGH_IMPORTANCE      (16 MB)
 * TIPC_CRITICAL_IMPORTANCE  (32 MB)
1357 1358 1359 1360 1361 1362 1363 1364
 *
 * 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))
1365 1366 1367 1368
		return sysctl_tipc_rmem[2];

	return sk->sk_rcvbuf >> TIPC_CRITICAL_IMPORTANCE <<
		msg_importance(msg);
1369 1370
}

1371
/**
1372 1373
 * filter_rcv - validate incoming message
 * @sk: socket
P
Per Liden 已提交
1374
 * @buf: message
1375
 *
1376 1377 1378 1379
 * 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.
1380
 *
P
Per Liden 已提交
1381 1382
 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
 */
1383
static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
P
Per Liden 已提交
1384
{
1385
	struct socket *sock = sk->sk_socket;
1386
	struct tipc_sock *tsk = tipc_sk(sk);
P
Per Liden 已提交
1387
	struct tipc_msg *msg = buf_msg(buf);
1388
	unsigned int limit = rcvbuf_limit(sk, buf);
1389
	u32 res = TIPC_OK;
P
Per Liden 已提交
1390 1391

	/* Reject message if it is wrong sort of message for socket */
1392 1393
	if (msg_type(msg) > TIPC_DIRECT_MSG)
		return TIPC_ERR_NO_PORT;
1394

P
Per Liden 已提交
1395
	if (sock->state == SS_READY) {
1396
		if (msg_connected(msg))
P
Per Liden 已提交
1397 1398
			return TIPC_ERR_NO_PORT;
	} else {
1399
		res = filter_connect(tsk, &buf);
1400 1401
		if (res != TIPC_OK || buf == NULL)
			return res;
P
Per Liden 已提交
1402 1403 1404
	}

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

1408
	/* Enqueue message */
Y
Ying Xue 已提交
1409
	TIPC_SKB_CB(buf)->handle = NULL;
1410
	__skb_queue_tail(&sk->sk_receive_queue, buf);
1411
	skb_set_owner_r(buf, sk);
1412

1413
	sk->sk_data_ready(sk, 0);
1414 1415
	return TIPC_OK;
}
P
Per Liden 已提交
1416

1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
/**
 * 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;
}

/**
1437 1438
 * tipc_sk_rcv - handle incoming message
 * @sk:  socket receiving message
1439 1440 1441 1442 1443 1444
 * @buf: message
 *
 * Called with port lock already taken.
 *
 * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
 */
1445
u32 tipc_sk_rcv(struct sock *sk, struct sk_buff *buf)
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
{
	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 {
1459
		if (sk_add_backlog(sk, buf, rcvbuf_limit(sk, buf)))
Z
Zhu Yi 已提交
1460 1461 1462
			res = TIPC_ERR_OVERLOAD;
		else
			res = TIPC_OK;
1463 1464 1465 1466
	}
	bh_unlock_sock(sk);

	return res;
P
Per Liden 已提交
1467 1468
}

Y
Ying Xue 已提交
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
static int tipc_wait_for_connect(struct socket *sock, long *timeo_p)
{
	struct sock *sk = sock->sk;
	DEFINE_WAIT(wait);
	int done;

	do {
		int err = sock_error(sk);
		if (err)
			return err;
		if (!*timeo_p)
			return -ETIMEDOUT;
		if (signal_pending(current))
			return sock_intr_errno(*timeo_p);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		done = sk_wait_event(sk, timeo_p, sock->state != SS_CONNECTING);
		finish_wait(sk_sleep(sk), &wait);
	} while (!done);
	return 0;
}

P
Per Liden 已提交
1491
/**
1492
 * tipc_connect - establish a connection to another TIPC port
P
Per Liden 已提交
1493 1494 1495
 * @sock: socket structure
 * @dest: socket address for destination port
 * @destlen: size of socket address data structure
1496
 * @flags: file-related flags associated with socket
P
Per Liden 已提交
1497 1498 1499
 *
 * Returns 0 on success, errno otherwise
 */
1500 1501
static int tipc_connect(struct socket *sock, struct sockaddr *dest,
			int destlen, int flags)
P
Per Liden 已提交
1502
{
1503
	struct sock *sk = sock->sk;
1504 1505
	struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
	struct msghdr m = {NULL,};
Y
Ying Xue 已提交
1506 1507
	long timeout = (flags & O_NONBLOCK) ? 0 : tipc_sk(sk)->conn_timeout;
	socket_state previous;
1508 1509
	int res;

1510 1511
	lock_sock(sk);

1512
	/* For now, TIPC does not allow use of connect() with DGRAM/RDM types */
1513 1514 1515 1516
	if (sock->state == SS_READY) {
		res = -EOPNOTSUPP;
		goto exit;
	}
1517 1518 1519 1520 1521 1522 1523

	/*
	 * 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
	 */
1524 1525 1526 1527 1528
	if (dst->addrtype == TIPC_ADDR_MCAST) {
		res = -EINVAL;
		goto exit;
	}

Y
Ying Xue 已提交
1529
	previous = sock->state;
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
	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;

1542
		res = tipc_sendmsg(NULL, sock, &m, 0);
1543 1544 1545 1546 1547 1548 1549 1550 1551
		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;
	case SS_CONNECTING:
Y
Ying Xue 已提交
1552 1553 1554 1555 1556 1557 1558
		if (previous == SS_CONNECTING)
			res = -EALREADY;
		if (!timeout)
			goto exit;
		timeout = msecs_to_jiffies(timeout);
		/* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
		res = tipc_wait_for_connect(sock, &timeout);
1559 1560 1561 1562 1563 1564
		break;
	case SS_CONNECTED:
		res = -EISCONN;
		break;
	default:
		res = -EINVAL;
Y
Ying Xue 已提交
1565
		break;
1566
	}
1567 1568
exit:
	release_sock(sk);
1569
	return res;
P
Per Liden 已提交
1570 1571
}

1572
/**
1573
 * tipc_listen - allow socket to listen for incoming connections
P
Per Liden 已提交
1574 1575
 * @sock: socket structure
 * @len: (unused)
1576
 *
P
Per Liden 已提交
1577 1578
 * Returns 0 on success, errno otherwise
 */
1579
static int tipc_listen(struct socket *sock, int len)
P
Per Liden 已提交
1580
{
1581 1582 1583 1584
	struct sock *sk = sock->sk;
	int res;

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

1586
	if (sock->state != SS_UNCONNECTED)
1587 1588 1589 1590 1591 1592 1593 1594
		res = -EINVAL;
	else {
		sock->state = SS_LISTENING;
		res = 0;
	}

	release_sock(sk);
	return res;
P
Per Liden 已提交
1595 1596
}

Y
Ying Xue 已提交
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
static int tipc_wait_for_accept(struct socket *sock, long timeo)
{
	struct sock *sk = sock->sk;
	DEFINE_WAIT(wait);
	int err;

	/* True wake-one mechanism for incoming connections: only
	 * one process gets woken up, not the 'whole herd'.
	 * Since we do not 'race & poll' for established sockets
	 * anymore, the common case will execute the loop only once.
	*/
	for (;;) {
		prepare_to_wait_exclusive(sk_sleep(sk), &wait,
					  TASK_INTERRUPTIBLE);
1611
		if (timeo && skb_queue_empty(&sk->sk_receive_queue)) {
Y
Ying Xue 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
			release_sock(sk);
			timeo = schedule_timeout(timeo);
			lock_sock(sk);
		}
		err = 0;
		if (!skb_queue_empty(&sk->sk_receive_queue))
			break;
		err = -EINVAL;
		if (sock->state != SS_LISTENING)
			break;
		err = sock_intr_errno(timeo);
		if (signal_pending(current))
			break;
		err = -EAGAIN;
		if (!timeo)
			break;
	}
	finish_wait(sk_sleep(sk), &wait);
	return err;
}

1633
/**
1634
 * tipc_accept - wait for connection request
P
Per Liden 已提交
1635 1636 1637
 * @sock: listening socket
 * @newsock: new socket that is to be connected
 * @flags: file-related flags associated with socket
1638
 *
P
Per Liden 已提交
1639 1640
 * Returns 0 on success, errno otherwise
 */
1641
static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags)
P
Per Liden 已提交
1642
{
1643
	struct sock *new_sk, *sk = sock->sk;
P
Per Liden 已提交
1644
	struct sk_buff *buf;
1645
	struct tipc_port *new_port;
1646
	struct tipc_msg *msg;
1647
	struct tipc_portid peer;
1648
	u32 new_ref;
Y
Ying Xue 已提交
1649
	long timeo;
1650
	int res;
P
Per Liden 已提交
1651

1652
	lock_sock(sk);
P
Per Liden 已提交
1653

1654 1655
	if (sock->state != SS_LISTENING) {
		res = -EINVAL;
P
Per Liden 已提交
1656 1657
		goto exit;
	}
Y
Ying Xue 已提交
1658 1659 1660 1661
	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
	res = tipc_wait_for_accept(sock, timeo);
	if (res)
		goto exit;
1662 1663 1664

	buf = skb_peek(&sk->sk_receive_queue);

1665
	res = tipc_sk_create(sock_net(sock->sk), new_sock, 0, 1);
1666 1667
	if (res)
		goto exit;
P
Per Liden 已提交
1668

1669
	new_sk = new_sock->sk;
1670
	new_port = &tipc_sk(new_sk)->port;
1671
	new_ref = new_port->ref;
1672
	msg = buf_msg(buf);
P
Per Liden 已提交
1673

1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
	/* 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 */
1684 1685 1686
	peer.ref = msg_origport(msg);
	peer.node = msg_orignode(msg);
	tipc_port_connect(new_ref, &peer);
1687 1688
	new_sock->state = SS_CONNECTED;

1689
	tipc_port_set_importance(new_port, msg_importance(msg));
1690
	if (msg_named(msg)) {
1691 1692
		new_port->conn_type = msg_nametype(msg);
		new_port->conn_instance = msg_nameinst(msg);
P
Per Liden 已提交
1693
	}
1694 1695 1696 1697 1698 1699 1700 1701 1702

	/*
	 * 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);
1703
		tipc_send_packet(NULL, new_sock, &m, 0);
1704 1705 1706
	} else {
		__skb_dequeue(&sk->sk_receive_queue);
		__skb_queue_head(&new_sk->sk_receive_queue, buf);
1707
		skb_set_owner_r(buf, new_sk);
1708 1709
	}
	release_sock(new_sk);
P
Per Liden 已提交
1710
exit:
1711
	release_sock(sk);
P
Per Liden 已提交
1712 1713 1714 1715
	return res;
}

/**
1716
 * tipc_shutdown - shutdown socket connection
P
Per Liden 已提交
1717
 * @sock: socket structure
1718
 * @how: direction to close (must be SHUT_RDWR)
P
Per Liden 已提交
1719 1720
 *
 * Terminates connection (if necessary), then purges socket's receive queue.
1721
 *
P
Per Liden 已提交
1722 1723
 * Returns 0 on success, errno otherwise
 */
1724
static int tipc_shutdown(struct socket *sock, int how)
P
Per Liden 已提交
1725
{
1726
	struct sock *sk = sock->sk;
1727 1728
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
P
Per Liden 已提交
1729 1730 1731
	struct sk_buff *buf;
	int res;

1732 1733
	if (how != SHUT_RDWR)
		return -EINVAL;
P
Per Liden 已提交
1734

1735
	lock_sock(sk);
P
Per Liden 已提交
1736 1737

	switch (sock->state) {
1738
	case SS_CONNECTING:
P
Per Liden 已提交
1739 1740 1741
	case SS_CONNECTED:

restart:
1742
		/* Disconnect and send a 'FIN+' or 'FIN-' message to peer */
1743 1744
		buf = __skb_dequeue(&sk->sk_receive_queue);
		if (buf) {
Y
Ying Xue 已提交
1745
			if (TIPC_SKB_CB(buf)->handle != NULL) {
1746
				kfree_skb(buf);
P
Per Liden 已提交
1747 1748
				goto restart;
			}
1749
			tipc_port_disconnect(port->ref);
P
Per Liden 已提交
1750
			tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
1751
		} else {
1752
			tipc_port_shutdown(port->ref);
P
Per Liden 已提交
1753
		}
1754 1755

		sock->state = SS_DISCONNECTING;
P
Per Liden 已提交
1756 1757 1758 1759 1760

		/* fall through */

	case SS_DISCONNECTING:

1761
		/* Discard any unreceived messages */
1762
		__skb_queue_purge(&sk->sk_receive_queue);
1763 1764 1765

		/* Wake up anyone sleeping in poll */
		sk->sk_state_change(sk);
P
Per Liden 已提交
1766 1767 1768 1769 1770 1771 1772
		res = 0;
		break;

	default:
		res = -ENOTCONN;
	}

1773
	release_sock(sk);
P
Per Liden 已提交
1774 1775 1776 1777
	return res;
}

/**
1778
 * tipc_setsockopt - set socket option
P
Per Liden 已提交
1779 1780 1781 1782 1783
 * @sock: socket structure
 * @lvl: option level
 * @opt: option identifier
 * @ov: pointer to new option value
 * @ol: length of option value
1784 1785
 *
 * For stream sockets only, accepts and ignores all IPPROTO_TCP options
P
Per Liden 已提交
1786
 * (to ease compatibility).
1787
 *
P
Per Liden 已提交
1788 1789
 * Returns 0 on success, errno otherwise
 */
1790 1791
static int tipc_setsockopt(struct socket *sock, int lvl, int opt,
			   char __user *ov, unsigned int ol)
P
Per Liden 已提交
1792
{
1793
	struct sock *sk = sock->sk;
1794 1795
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
P
Per Liden 已提交
1796 1797 1798
	u32 value;
	int res;

1799 1800
	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
		return 0;
P
Per Liden 已提交
1801 1802 1803 1804
	if (lvl != SOL_TIPC)
		return -ENOPROTOOPT;
	if (ol < sizeof(value))
		return -EINVAL;
1805 1806
	res = get_user(value, (u32 __user *)ov);
	if (res)
P
Per Liden 已提交
1807 1808
		return res;

1809
	lock_sock(sk);
1810

P
Per Liden 已提交
1811 1812
	switch (opt) {
	case TIPC_IMPORTANCE:
1813
		tipc_port_set_importance(port, value);
P
Per Liden 已提交
1814 1815 1816
		break;
	case TIPC_SRC_DROPPABLE:
		if (sock->type != SOCK_STREAM)
1817
			tipc_port_set_unreliable(port, value);
1818
		else
P
Per Liden 已提交
1819 1820 1821
			res = -ENOPROTOOPT;
		break;
	case TIPC_DEST_DROPPABLE:
1822
		tipc_port_set_unreturnable(port, value);
P
Per Liden 已提交
1823 1824
		break;
	case TIPC_CONN_TIMEOUT:
1825
		tipc_sk(sk)->conn_timeout = value;
1826
		/* no need to set "res", since already 0 at this point */
P
Per Liden 已提交
1827 1828 1829 1830 1831
		break;
	default:
		res = -EINVAL;
	}

1832 1833
	release_sock(sk);

P
Per Liden 已提交
1834 1835 1836 1837
	return res;
}

/**
1838
 * tipc_getsockopt - get socket option
P
Per Liden 已提交
1839 1840 1841 1842 1843
 * @sock: socket structure
 * @lvl: option level
 * @opt: option identifier
 * @ov: receptacle for option value
 * @ol: receptacle for length of option value
1844 1845
 *
 * For stream sockets only, returns 0 length result for all IPPROTO_TCP options
P
Per Liden 已提交
1846
 * (to ease compatibility).
1847
 *
P
Per Liden 已提交
1848 1849
 * Returns 0 on success, errno otherwise
 */
1850 1851
static int tipc_getsockopt(struct socket *sock, int lvl, int opt,
			   char __user *ov, int __user *ol)
P
Per Liden 已提交
1852
{
1853
	struct sock *sk = sock->sk;
1854 1855
	struct tipc_sock *tsk = tipc_sk(sk);
	struct tipc_port *port = &tsk->port;
1856
	int len;
P
Per Liden 已提交
1857
	u32 value;
1858
	int res;
P
Per Liden 已提交
1859

1860 1861
	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
		return put_user(0, ol);
P
Per Liden 已提交
1862 1863
	if (lvl != SOL_TIPC)
		return -ENOPROTOOPT;
1864 1865
	res = get_user(len, ol);
	if (res)
1866
		return res;
P
Per Liden 已提交
1867

1868
	lock_sock(sk);
P
Per Liden 已提交
1869 1870 1871

	switch (opt) {
	case TIPC_IMPORTANCE:
1872
		value = tipc_port_importance(port);
P
Per Liden 已提交
1873 1874
		break;
	case TIPC_SRC_DROPPABLE:
1875
		value = tipc_port_unreliable(port);
P
Per Liden 已提交
1876 1877
		break;
	case TIPC_DEST_DROPPABLE:
1878
		value = tipc_port_unreturnable(port);
P
Per Liden 已提交
1879 1880
		break;
	case TIPC_CONN_TIMEOUT:
1881
		value = tipc_sk(sk)->conn_timeout;
1882
		/* no need to set "res", since already 0 at this point */
P
Per Liden 已提交
1883
		break;
1884
	case TIPC_NODE_RECVQ_DEPTH:
1885
		value = 0; /* was tipc_queue_size, now obsolete */
1886
		break;
1887
	case TIPC_SOCK_RECVQ_DEPTH:
1888 1889
		value = skb_queue_len(&sk->sk_receive_queue);
		break;
P
Per Liden 已提交
1890 1891 1892 1893
	default:
		res = -EINVAL;
	}

1894 1895
	release_sock(sk);

1896 1897
	if (res)
		return res;	/* "get" failed */
P
Per Liden 已提交
1898

1899 1900 1901 1902 1903 1904 1905
	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 已提交
1906 1907
}

1908 1909
/* Protocol switches for the various types of TIPC sockets */

1910
static const struct proto_ops msg_ops = {
1911
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1912
	.family		= AF_TIPC,
1913 1914 1915
	.release	= tipc_release,
	.bind		= tipc_bind,
	.connect	= tipc_connect,
1916
	.socketpair	= sock_no_socketpair,
1917
	.accept		= sock_no_accept,
1918 1919
	.getname	= tipc_getname,
	.poll		= tipc_poll,
1920
	.ioctl		= sock_no_ioctl,
1921
	.listen		= sock_no_listen,
1922 1923 1924 1925 1926
	.shutdown	= tipc_shutdown,
	.setsockopt	= tipc_setsockopt,
	.getsockopt	= tipc_getsockopt,
	.sendmsg	= tipc_sendmsg,
	.recvmsg	= tipc_recvmsg,
1927 1928
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1929 1930
};

1931
static const struct proto_ops packet_ops = {
1932
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1933
	.family		= AF_TIPC,
1934 1935 1936
	.release	= tipc_release,
	.bind		= tipc_bind,
	.connect	= tipc_connect,
1937
	.socketpair	= sock_no_socketpair,
1938 1939 1940
	.accept		= tipc_accept,
	.getname	= tipc_getname,
	.poll		= tipc_poll,
1941
	.ioctl		= sock_no_ioctl,
1942 1943 1944 1945 1946 1947
	.listen		= tipc_listen,
	.shutdown	= tipc_shutdown,
	.setsockopt	= tipc_setsockopt,
	.getsockopt	= tipc_getsockopt,
	.sendmsg	= tipc_send_packet,
	.recvmsg	= tipc_recvmsg,
1948 1949
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1950 1951
};

1952
static const struct proto_ops stream_ops = {
1953
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1954
	.family		= AF_TIPC,
1955 1956 1957
	.release	= tipc_release,
	.bind		= tipc_bind,
	.connect	= tipc_connect,
1958
	.socketpair	= sock_no_socketpair,
1959 1960 1961
	.accept		= tipc_accept,
	.getname	= tipc_getname,
	.poll		= tipc_poll,
1962
	.ioctl		= sock_no_ioctl,
1963 1964 1965 1966 1967 1968
	.listen		= tipc_listen,
	.shutdown	= tipc_shutdown,
	.setsockopt	= tipc_setsockopt,
	.getsockopt	= tipc_getsockopt,
	.sendmsg	= tipc_send_stream,
	.recvmsg	= tipc_recv_stream,
1969 1970
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage
P
Per Liden 已提交
1971 1972
};

1973
static const struct net_proto_family tipc_family_ops = {
1974
	.owner		= THIS_MODULE,
P
Per Liden 已提交
1975
	.family		= AF_TIPC,
1976
	.create		= tipc_sk_create
P
Per Liden 已提交
1977 1978 1979 1980 1981
};

static struct proto tipc_proto = {
	.name		= "TIPC",
	.owner		= THIS_MODULE,
1982 1983
	.obj_size	= sizeof(struct tipc_sock),
	.sysctl_rmem	= sysctl_tipc_rmem
P
Per Liden 已提交
1984 1985
};

1986 1987 1988 1989 1990 1991
static struct proto tipc_proto_kern = {
	.name		= "TIPC",
	.obj_size	= sizeof(struct tipc_sock),
	.sysctl_rmem	= sysctl_tipc_rmem
};

P
Per Liden 已提交
1992
/**
1993
 * tipc_socket_init - initialize TIPC socket interface
1994
 *
P
Per Liden 已提交
1995 1996
 * Returns 0 on success, errno otherwise
 */
1997
int tipc_socket_init(void)
P
Per Liden 已提交
1998 1999 2000
{
	int res;

2001
	res = proto_register(&tipc_proto, 1);
P
Per Liden 已提交
2002
	if (res) {
2003
		pr_err("Failed to register TIPC protocol type\n");
P
Per Liden 已提交
2004 2005 2006 2007 2008
		goto out;
	}

	res = sock_register(&tipc_family_ops);
	if (res) {
2009
		pr_err("Failed to register TIPC socket type\n");
P
Per Liden 已提交
2010 2011 2012 2013 2014 2015 2016 2017
		proto_unregister(&tipc_proto);
		goto out;
	}
 out:
	return res;
}

/**
2018
 * tipc_socket_stop - stop TIPC socket interface
P
Per Liden 已提交
2019
 */
2020
void tipc_socket_stop(void)
P
Per Liden 已提交
2021 2022 2023 2024
{
	sock_unregister(tipc_family_ops.family);
	proto_unregister(&tipc_proto);
}